DevOps Bootcamp · บทเรียน

เลเยอร์อิมเมจและการเพิ่มประสิทธิภาพ

ค้นพบวิธีจัดเลเยอร์อิมเมจ Docker และใช้เทคนิคเพื่อเพิ่มประสิทธิภาพขนาดอิมเมจและเวลาในการสร้าง

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

เลเยอร์ของอิมเมจ: องค์ประกอบพื้นฐาน

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

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

เลเยอร์อิมเมจและการเพิ่มประสิทธิภาพ — ภาพประกอบ 1

คำสั่ง Dockerfile และเลเยอร์

เมื่อคุณเขียน Dockerfile คำสั่งเกือบทุกคำสั่งจะสร้างเลเยอร์ใหม่ทับเลเยอร์ก่อนหน้า คำสั่งอย่าง FROM, RUN, COPY และ ADD ล้วนมีส่วนสร้างเลเยอร์ใหม่

ด็อกเกอร์จะดำเนินการตามคำสั่งเหล่านี้ตามลำดับ โดยสร้างเลเยอร์ใหม่แต่ละชั้นจากสถานะของเลเยอร์ก่อนหน้า

การตรวจสอบประวัติอิมเมจ

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

เครื่องมือนี้มีประโยชน์อย่างมากสำหรับแก้ไขปัญหาเกี่ยวกับขนาดอิมเมจ

docker history my-image:latest

พลังของการแคชเลเยอร์

ด็อกเกอร์ใช้แคชการสร้างที่ชาญฉลาด หากคำสั่งใน Dockerfile และบริบทของคำสั่งนั้น (เช่น ไฟล์ที่กำลังคัดลอก) ไม่ได้เปลี่ยนแปลงนับจากการสร้างครั้งล่าสุด ด็อกเกอร์จะนำเลเยอร์เดิมกลับมาใช้

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

การเพิ่มประสิทธิภาพ 1: จัดลำดับเลเยอร์อย่างเหมาะสม

ลำดับคำสั่งใน Dockerfile มีความสำคัญอย่างยิ่งต่อการใช้แคชอย่างมีประสิทธิภาพ ให้วางคำสั่งที่เปลี่ยนแปลงไม่บ่อย (เช่น การติดตั้งสิ่งที่ระบบต้องพึ่งพา) ไว้ด้านบน

ส่วนคำสั่งที่เปลี่ยนแปลงบ่อย (เช่น การคัดลอกโค้ดแอปพลิเคชัน) ควรวางไว้ด้านล่าง วิธีนี้ หากมีเพียงโค้ดที่เปลี่ยนแปลง ด็อกเกอร์ก็ยังใช้เลเยอร์ที่แคชไว้ของสิ่งที่ต้องพึ่งพาซึ่งไม่เปลี่ยนแปลงได้

ตัวอย่าง: การเพิ่มประสิทธิภาพลำดับเลเยอร์

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

FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
CMD ["node", "server.js"]

การเพิ่มประสิทธิภาพ 2: รวมคำสั่ง RUN

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

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

ตัวอย่าง: การเชื่อมคำสั่ง RUN

แทนที่จะใช้คำสั่ง RUN หลายคำสั่ง ให้เชื่อมคำสั่งเหล่านั้นด้วย && \ วิธีนี้จะสร้างเลเยอร์เดียวที่มีประสิทธิภาพมากขึ้นสำหรับการดำเนินการทั้งหมด

FROM ubuntu:latest
RUN apt-get update && \
    apt-get install -y curl && \
    rm -rf /var/lib/apt/lists/*
CMD ["bash"]

การเพิ่มประสิทธิภาพ 3: ล้างไฟล์

ควรล้างไฟล์ที่จำเป็นเฉพาะระหว่างกระบวนการสร้างออกเสมอ ตัวอย่างเช่น แคชของตัวจัดการแพ็กเกจ (เช่น apt-get clean) หรือไฟล์ชั่วคราวที่เกิดจากการสร้าง อาจเพิ่มขนาดให้เลเยอร์อิมเมจอย่างมาก

การล้างไฟล์เหล่านี้ภายในคำสั่ง RUN เดียวกับที่สร้างไฟล์ขึ้นมา จะช่วยให้ไฟล์ไม่คงอยู่ในเลเยอร์ก่อนหน้า

ตรวจสอบความเข้าใจอย่างรวดเร็ว: การเพิ่มประสิทธิภาพอิมเมจ

พิจารณาส่วนของ Dockerfile ต่อไปนี้:

FROM alpine:latest
COPY . /app
RUN apk add --no-cache git
RUN apk add --no-cache make
CMD ["sh"]

การเปลี่ยนแปลงข้อใดต่อไปนี้จะเพิ่มประสิทธิภาพ Dockerfile นี้ได้ดีที่สุด เพื่อให้มีขนาดอิมเมจเล็กลงและอาจสร้างใหม่ได้เร็วขึ้น

สรุป: อิมเมจที่เล็กลงและเร็วขึ้น

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

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

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

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

บทเรียน “เลเยอร์อิมเมจและการเพิ่มประสิทธิภาพ” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “เลเยอร์อิมเมจและการเพิ่มประสิทธิภาพ”

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

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

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

บทเรียน “เลเยอร์อิมเมจและการเพิ่มประสิทธิภาพ” ใช้เวลานานแค่ไหน

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

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

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

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

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