Docker & DevOps Fundamentals · บทเรียน

การปรับใช้อัตโนมัติด้วย Jenkins

สร้าง pipeline CI/CD ใน Jenkins เพื่อปรับใช้คอนเทนเนอร์ Docker ไปยังสภาพแวดล้อมเป้าหมาย

การปรับใช้อัตโนมัติด้วย Jenkins เป็นบทเรียน Docker & DevOps Fundamentals ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Docker & DevOps Fundamentals และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Docker & DevOps Fundamentals มีบทเรียนทั้งหมด 4 บทเรียน

บทนำสู่การนำไปใช้งานอัตโนมัติ

ยินดีต้อนรับสู่บทเรียนสุดท้ายเกี่ยวกับ CI/CD ด้วย Jenkins และ Docker วันนี้เราจะเน้นการทำให้การนำคอนเทนเนอร์ Docker ของคุณไปใช้งานเป็นไปโดยอัตโนมัติ

การนำไปใช้งานอัตโนมัติคือกระบวนการเผยแพร่ซอฟต์แวร์ไปยังสภาพแวดล้อมจริงหรือสภาพแวดล้อมเตรียมใช้งานโดยไม่ต้องดำเนินการด้วยตนเอง ซึ่งเป็นส่วนสำคัญของการส่งมอบและการนำไปใช้งานอย่างต่อเนื่อง ช่วยให้การทำงานรวดเร็ว สม่ำเสมอ และเชื่อถือได้

การปรับใช้อัตโนมัติด้วย Jenkins — ภาพประกอบ 1

เหตุใดจึงควรทำให้การนำไปใช้งานเป็นอัตโนมัติ

การนำแอปพลิเคชันไปใช้งานด้วยตนเองอาจล่าช้า เกิดข้อผิดพลาดได้ง่าย และไม่สม่ำเสมอ ระบบอัตโนมัติช่วยแก้ปัญหาเหล่านี้:

ความเร็ว: นำฟีเจอร์ใหม่หรือการแก้ไขไปใช้งานได้อย่างรวดเร็ว
ความน่าเชื่อถือ: ลดข้อผิดพลาดจากมนุษย์ด้วยกระบวนการมาตรฐาน
ความสม่ำเสมอ: ทำให้มั่นใจว่าการนำไปใช้งานทุกครั้งทำตามขั้นตอนเดียวกัน
ประสิทธิภาพ: ช่วยให้นักพัฒนามุ่งเน้นการเขียนโค้ดได้ โดยไม่ต้องจัดการงานนำไปใช้งาน

ขั้นตอนของกระบวนการนำไปใช้งาน

กระบวนการ Jenkins ทั่วไปสำหรับการนำ Docker ไปใช้งานประกอบด้วยขั้นตอนสำคัญหลายขั้น:

สร้าง: สร้างอิมเมจ Docker (กล่าวถึงในบทเรียนก่อนหน้า)
ทดสอบ: เรียกใช้การทดสอบอัตโนมัติกับอิมเมจ
ส่ง: ส่งอิมเมจไปยังรีจิสทรี Docker
นำไปใช้งาน: ดึงอิมเมจจากรีจิสทรีและเรียกใช้บนเซิร์ฟเวอร์เป้าหมาย
ตรวจสอบ: ยืนยันว่าการนำไปใช้งานใหม่ทำงานได้อย่างปกติ

วันนี้เราจะเน้นขั้นตอน 'นำไปใช้งาน' และ 'ตรวจสอบ'

การตั้งค่าสภาพแวดล้อมเป้าหมาย

ก่อนที่ Jenkins จะนำแอปพลิเคชันไปใช้งาน เซิร์ฟเวอร์เป้าหมายของคุณต้องพร้อม โดยทั่วไปหมายความว่าต้องมีสิ่งต่อไปนี้:

ติดตั้ง Docker แล้ว: เซิร์ฟเวอร์เป้าหมายต้องติดตั้ง Docker Engine
การเข้าถึงผ่าน SSH: Jenkins ต้องมีการเข้าถึง Shell ที่ปลอดภัย (SSH) ไปยังเซิร์ฟเวอร์เป้าหมาย
สิทธิ์ของผู้ใช้: ผู้ใช้ SSH ต้องมีสิทธิ์เรียกใช้คำสั่ง Docker

โดยทั่วไปเราจะจัดการข้อมูลรับรอง SSH อย่างปลอดภัยภายใน Jenkins

ข้อมูลรับรอง SSH สำหรับ Jenkins

ในการเชื่อมต่อกับเซิร์ฟเวอร์ระยะไกล Jenkins จะใช้ข้อมูลรับรอง SSH โดยทั่วไปข้อมูลเหล่านี้คือคู่ชื่อผู้ใช้ SSH และคีย์ส่วนตัวที่จัดเก็บอย่างปลอดภัยในตัวจัดการข้อมูลรับรองของ Jenkins

เมื่อกำหนดกระบวนการ คุณสามารถระบุให้ Jenkins ใช้ข้อมูลรับรองเหล่านี้ในขั้นตอนที่กำหนดได้ ทำให้ Jenkins เรียกใช้คำสั่งบนเซิร์ฟเวอร์เป้าหมายของคุณ

ตัวอย่างสคริปต์การนำไปใช้งานพื้นฐาน

นี่คือตัวอย่างสคริปต์เชลล์อย่างง่ายที่สามารถเรียกใช้บนเซิร์ฟเวอร์เป้าหมายเพื่ออัปเดตคอนเทนเนอร์ Docker สคริปต์จะหยุดคอนเทนเนอร์เดิม ลบคอนเทนเนอร์นั้น ดึงอิมเมจใหม่ และเรียกใช้

APP_NAME และ IMAGE_NAME จะถูกส่งเข้ามาเป็นตัวแปรสภาพแวดล้อม

#!/bin/bash

# Stop and remove existing container
docker stop ${APP_NAME} || true
docker rm ${APP_NAME} || true

# Pull the new Docker image
docker pull ${IMAGE_NAME}

# Run the new container
docker run -d --name ${APP_NAME} -p 80:80 ${IMAGE_NAME}

echo "Deployment of ${APP_NAME} complete!"

การผสานรวมกับกระบวนการ Jenkins

ใน Jenkinsfile คุณสามารถใช้ปลั๊กอิน sshPublisher หรือขั้นตอน sh แบบง่ายร่วมกับการส่งต่อตัวแทน SSH เพื่อเรียกใช้คำสั่งบนโฮสต์ระยะไกลได้ ต่อไปนี้คือตัวอย่างลักษณะของขั้นตอนการนำไปใช้งาน โดยใช้ขั้นตอน sh พื้นฐานในกรณีที่กำหนดค่า SSH ไว้แล้ว

agent { label 'remote-deploy-host' } หมายความว่าขั้นตอนนี้จะทำงานบนเซิร์ฟเวอร์เป้าหมาย

stage('Deploy to Production') {
  agent { label 'remote-deploy-host' } 
  steps {
    withEnv([
      "APP_NAME=my-webapp",
      "IMAGE_NAME=myregistry/my-webapp:latest"
    ]) {
      sh '''
        docker stop ${APP_NAME} || true
        docker rm ${APP_NAME} || true
        docker pull ${IMAGE_NAME}
        docker run -d --name ${APP_NAME} -p 80:80 ${IMAGE_NAME}
        echo "Deployment successful!"
      '''
    }
  }
}

การทำให้อัปเดตแบบทยอยเปลี่ยนทำงานได้

หากต้องการนำไปใช้งานโดยไม่หยุดให้บริการ การหยุดแล้วเริ่มใหม่แบบธรรมดายังไม่เพียงพอ โดยทั่วไปคุณจะใช้กลยุทธ์อย่างใดอย่างหนึ่งต่อไปนี้:

การอัปเดตแบบทยอยเปลี่ยน: ค่อย ๆ แทนที่คอนเทนเนอร์เก่าด้วยคอนเทนเนอร์ใหม่ทีละรายการ เพื่อให้บริการยังคงพร้อมใช้งาน
การนำไปใช้งานแบบสีน้ำเงิน/สีเขียว: นำเวอร์ชันใหม่ (สีเขียว) ไปใช้งานควบคู่กับเวอร์ชันเก่า (สีน้ำเงิน) แล้วจึงเปลี่ยนเส้นทางการรับส่งข้อมูล

แม้ Jenkins จะควบคุมกระบวนการเหล่านี้ได้ แต่เครื่องมืออย่าง Docker Swarm หรือ Kubernetes ก็รองรับกลยุทธ์ขั้นสูงเหล่านี้โดยตรง

การตรวจสอบการนำไปใช้งาน

หลังจากนำไปใช้งานแล้ว สิ่งสำคัญคือต้องตรวจสอบว่าแอปพลิเคชันทำงานอย่างถูกต้อง ซึ่งอาจประกอบด้วย:

การตรวจสอบสถานะ: ส่งคำขอ HTTP GET อย่างง่ายไปยังปลายทางตรวจสอบสถานะของแอปพลิเคชัน
การตรวจสอบบันทึก: ตรวจสอบบันทึกของคอนเทนเนอร์เพื่อค้นหาข้อผิดพลาด
การทดสอบการผสานรวม: เรียกใช้ชุดการทดสอบอย่างรวดเร็วกับเวอร์ชันที่เพิ่งนำไปใช้งาน

กระบวนการ Jenkins ของคุณสามารถมีขั้นตอน 'ตรวจสอบ' เพื่อทำให้การตรวจสอบเหล่านี้เป็นอัตโนมัติ

ตรวจสอบความรู้ของคุณ

พิจารณาส่วนของ Jenkinsfile ต่อไปนี้สำหรับขั้นตอนการนำไปใช้งาน จุดประสงค์หลักของ docker stop ${APP_NAME} || true คืออะไร

สรุป: การนำไปใช้งานอัตโนมัติ

ทำได้ดีมาก คุณได้เรียนรู้วิธีดำเนินการกับการนำไปใช้งานอัตโนมัติด้วย Jenkins และ Docker แล้ว

การนำไปใช้งานอัตโนมัติช่วยให้การเผยแพร่รวดเร็ว เชื่อถือได้ และสม่ำเสมอ
สภาพแวดล้อมเป้าหมายต้องมี Docker และการเข้าถึงผ่าน SSH
Jenkins ใช้ข้อมูลรับรองที่ปลอดภัยเพื่อเชื่อมต่อกับเซิร์ฟเวอร์ระยะไกล
โดยทั่วไปสคริปต์การนำไปใช้งานจะหยุดคอนเทนเนอร์เก่า ดึงอิมเมจใหม่ และเริ่มคอนเทนเนอร์ใหม่
ขั้นตอนการตรวจสอบมีความสำคัญอย่างยิ่งเพื่อยืนยันว่าการนำไปใช้งานสำเร็จ

เนื้อหานี้เป็นบทสรุปของหลักสูตร CI/CD ด้วย Jenkins และ Docker ขอให้ฝึกฝนต่อไปเพื่อเชี่ยวชาญเครื่องมืออันทรงพลังเหล่านี้

คำถามที่พบบ่อย

บทเรียน “การปรับใช้อัตโนมัติด้วย Jenkins” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การปรับใช้อัตโนมัติด้วย Jenkins” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Docker & DevOps Fundamentals ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Docker & DevOps Fundamentals มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การปรับใช้อัตโนมัติด้วย Jenkins”

สร้าง pipeline CI/CD ใน Jenkins เพื่อปรับใช้คอนเทนเนอร์ Docker ไปยังสภาพแวดล้อมเป้าหมาย คุณปฏิบัติ Docker & DevOps Fundamentals ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Docker & DevOps Fundamentals หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Docker & DevOps Fundamentals บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน

บทเรียน “การปรับใช้อัตโนมัติด้วย Jenkins” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Docker & DevOps Fundamentals นี้ได้ไหม

ได้ บทเรียน Docker & DevOps Fundamentals ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

บทนำสู่ Jenkins
การสร้างอิมเมจ Docker ด้วย Jenkins
การปรับใช้อัตโนมัติด้วย Jenkins
Jenkins Pipeline เป็นโค้ดด้วย Jenkinsfile

← กลับไปที่ Docker & DevOps Fundamentals