DevOps Bootcamp · บทเรียน

การสร้างแบบหลายขั้นตอนเพื่อประสิทธิภาพ

ใช้การสร้างแบบหลายขั้นตอนเพื่อสร้างอิมเมจสำหรับใช้งานจริงที่เล็กลงและปลอดภัยยิ่งขึ้น โดยแยกการพึ่งพาสำหรับการสร้างออกจากการทำงาน

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

บทนำสู่การสร้างแบบหลายขั้นตอน

ยินดีต้อนรับสู่บทเรียนการปรับแต่ง Dockerfile ขั้นสูง วันนี้เราจะสำรวจ การสร้างแบบหลายขั้นตอน ซึ่งเป็นเทคนิคที่มีประสิทธิภาพในการสร้างอิมเมจ Docker ที่มีขนาดเล็กลงและมีประสิทธิภาพมากขึ้น

อิมเมจที่มีขนาดเล็กลงช่วยให้ดาวน์โหลดได้เร็วขึ้น มีความปลอดภัยดีขึ้น และใช้ทรัพยากรได้ดียิ่งขึ้น

การสร้างแบบหลายขั้นตอนเพื่อประสิทธิภาพ — ภาพประกอบ 1

เหตุใดอิมเมจที่มีขนาดเล็กลงจึงสำคัญ

เมื่อคุณสร้างอิมเมจ Docker อิมเมจนั้นมักรวมเครื่องมือและไลบรารีที่จำเป็นเฉพาะระหว่างกระบวนการสร้าง แต่ไม่จำเป็นต่อการเรียกใช้แอปพลิเคชันขั้นสุดท้าย

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

ปัญหาของการสร้างแบบขั้นตอนเดียว

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

ทำให้อิมเมจสุดท้ายมีขนาดใหญ่เกินความจำเป็น เนื่องจากไม่จำเป็นต้องใช้คอมไพเลอร์เพื่อเรียกใช้ไบนารีที่คอมไพล์แล้ว

ตัวอย่างการสร้างแบบขั้นตอนเดียว (Go)

นี่คือตัวอย่างแอปพลิเคชัน Go อย่างง่ายและ Dockerfile ที่สร้างแอปพลิเคชันในขั้นตอนเดียว สังเกตว่าสภาพแวดล้อมการสร้างถูกรวมอยู่ในอิมเมจสุดท้าย

main.go:

package main

import "fmt"

func main() {
    fmt.Println("Hello from Single-Stage Docker!")
}

Dockerfile แบบขั้นตอนเดียว

Dockerfile นี้ใช้ `golang:1.21-alpine` เป็นอิมเมจพื้นฐาน หลังจากสร้างแอปแล้ว อิมเมจพื้นฐานขนาดใหญ่นี้พร้อมเครื่องมือสร้างทั้งหมดจะยังคงอยู่ในอิมเมจสุดท้าย

FROM golang:1.21-alpine
WORKDIR /app
COPY main.go .
RUN go build -o myapp main.go
EXPOSE 8080
CMD ["./myapp"]

องค์ประกอบของการสร้างแบบหลายขั้นตอน

การสร้างแบบหลายขั้นตอนแก้ปัญหานี้ด้วยการอนุญาตให้คุณกำหนดคำสั่ง `FROM` หลายคำสั่งใน Dockerfile เดียว แต่ละ `FROM` จะเริ่มขั้นตอนการสร้างใหม่

ใช้คีย์เวิร์ด AS เพื่อตั้งชื่อขั้นตอน เช่น FROM golang:1.21-alpine AS builder
จากนั้นคุณสามารถคัดลอกสิ่งที่สร้างจากขั้นตอนก่อนหน้าโดยใช้ COPY --from=<stage_name>

เฉพาะขั้นตอนสุดท้ายเท่านั้นที่จะถูกบันทึกเป็นอิมเมจ

โครงสร้างแบบหลายขั้นตอน

โดยทั่วไป Dockerfile แบบหลายขั้นตอนจะมีอย่างน้อยสองขั้นตอน:

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

อิมเมจชั่วคราวของขั้นตอนการสร้างจะถูกทิ้ง เหลือเพียงอิมเมจสุดท้ายที่มีขนาดกะทัดรัด

ตัวอย่างการสร้างแบบหลายขั้นตอน (Go)

ลองเขียน Dockerfile ของแอปพลิเคชัน Go ใหม่โดยใช้แนวทางแบบหลายขั้นตอน เราจะสร้างแอปในขั้นตอนแรก จากนั้นคัดลอกเฉพาะไบนารีที่คอมไพล์แล้วไปยังอิมเมจพื้นฐาน `alpine` ที่มีขนาดเล็กกว่ามาก

# Stage 1: Build the application
FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY main.go .
RUN go build -o myapp main.go

# Stage 2: Create the final lightweight image
FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/myapp .
EXPOSE 8080
CMD ["./myapp"]

การเรียกใช้การสร้างแบบหลายขั้นตอน

เมื่อคุณสร้าง Dockerfile นี้ Docker จะดำเนินการแต่ละขั้นตอน อย่างไรก็ตาม เฉพาะเนื้อหาของคำสั่ง `FROM` สุดท้าย รวมกับไฟล์ที่คัดลอกจากขั้นตอนก่อนหน้าเท่านั้นที่จะประกอบเป็นอิมเมจสุดท้าย

ผลลัพธ์คืออิมเมจมีขนาดเล็กกว่าการสร้างแบบขั้นตอนเดียวอย่างมาก เนื่องจากคอมไพเลอร์ Go และเครื่องมือสร้างถูกทิ้งไว้ในขั้นตอนก่อนหน้า

ประโยชน์ของการสร้างแบบหลายขั้นตอน

การสร้างแบบหลายขั้นตอนมีประโยชน์อย่างยิ่งสำหรับ:

ภาษาที่ต้องคอมไพล์: Go, Java, C++ และ Rust
เฟรมเวิร์กส่วนหน้า: การสร้างแอป React/Angular และให้บริการไฟล์ทรัพยากรแบบคงที่ด้วย Nginx
แอปพลิเคชัน Node.js: ติดตั้ง `node_modules` ในขั้นตอนการสร้าง จากนั้นคัดลอกเฉพาะ `package.json`, `package-lock.json` และแอปที่สร้างแล้วไปยังอิมเมจสำหรับเรียกใช้ที่มีขนาดเล็ก

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

ข้อใดต่อไปนี้คือประโยชน์หลักของการใช้การสร้าง Docker แบบหลายขั้นตอน

สรุป: ประสิทธิภาพของการสร้างแบบหลายขั้นตอน

คุณได้เรียนรู้เกี่ยวกับการสร้าง Docker แบบหลายขั้นตอนแล้ว

การสร้างรูปแบบนี้ใช้คำสั่ง FROM หลายคำสั่งใน Dockerfile เดียว
คีย์เวิร์ด AS ใช้ตั้งชื่อขั้นตอน และ COPY --from= ใช้ถ่ายโอนสิ่งที่สร้าง
ประโยชน์สำคัญคืออิมเมจสุดท้ายมีขนาดเล็กลงอย่างมาก ปลอดภัยขึ้น และมีประสิทธิภาพมากขึ้น

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

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

บทเรียน “การสร้างแบบหลายขั้นตอนเพื่อประสิทธิภาพ” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “การสร้างแบบหลายขั้นตอนเพื่อประสิทธิภาพ”

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

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

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

บทเรียน “การสร้างแบบหลายขั้นตอนเพื่อประสิทธิภาพ” ใช้เวลานานแค่ไหน

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

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

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

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

การสร้างแบบหลายขั้นตอนเพื่อประสิทธิภาพ
การใช้ประโยชน์จากแคชการสร้าง
แนวทางปฏิบัติที่ดีด้านความปลอดภัยของ Dockerfile
ลดขนาดอิมเมจด้วยฐาน Slim และ Distroless

← กลับไปที่ DevOps Bootcamp