คู่มือขั้นตอนขั้นตอนการสร้างภาพหลายระดับ

การ สร้าง โดเค อร์ หลาย ชนิด คือ อะไร?

การสร้าง Docerker ในหลายระยะนี้ เป็นคุณสมบัติที่นําเข้ามาใน Docer 17.05 ซึ่งช่วยให้คุณสามารถใช้ประโยคต่าง ๆ [FLT: 0] ในแฟ้มเดียว แต่ละแฟ้ม [FLT: 1) การสอนแต่ละแบบจะเริ่มสร้างใหม่ ซึ่งสามารถมีภาพพื้นฐาน, ความขึ้นกับคําสั่งของตัวเองได้ Artifacts สามารถคัดลอกจากแต่ละขั้นไปยังอีกขั้น ในขณะที่ภาพสุดท้ายเก็บสิ่งที่จําเป็นสําหรับการใช้งานเท่านั้น ทั้งนี้จะเป็นการกําจัดการเรียกดูแฟ้มแบบดอกเกอร์ด้วยตนเอง หรือการสร้างสคริปต์ที่ซับซ้อนอย่างน่าประหลาด และลดขนาดของภาพลงได้อย่างมาก โดยตัวจําลองและแฟ้มต่าง ๆ ที่ถูกปรับเปลี่ยนมา

แนวคิดหลักคือแยกสภาพแวดล้อมการสร้างจากสภาพแวดล้อมที่ทํางานอยู่ โดยในโครงสร้างแบบเดี่ยว นักพัฒนาจะติดตั้งเครื่องมือต่าง ๆ (เช่น ผู้จัดทําแพกเกจ, ผู้จัดการแพกเกจ, เฟรมเวิร์ก) ในภาพเดียวกันที่จะใช้ในการผลิต ภาพและเพิ่มพื้นผิว การสร้างมัลติมีเดียนี้ จะสามารถแก้ไขได้โดยสร้างภาพหนา ๆ ที่สร้างจากภาพ และแล้วคัดลอกภาพต่าง ๆ ให้กลายเป็นภาพแบบย่อ ๆ เช่น [FLT2] หรือ [FL3] เป็นต้นมา

ผล ประโยชน์ จาก การ สร้าง หลาย หลาก หลาย รูป แบบ

ข้อดีของการรับเอาสิ่งก่อสร้างหลายระดับมาสร้างนั้น ส่งผลอย่างมากต่อความปลอดภัย ความมั่นคง และความเร็วในการใช้งาน

1 ภาพลดขนาดลง

โดยละทิ้งการขึ้นต่อกันแบบต่อเวลา การสร้างหลายชั้นนั้น มักจะหดตัวลงโดย 50% ถึง 90% ตัวอย่างเช่น โปรแกรม Node.js ที่สร้างขึ้นโดยใช้ภาพเต็ม (FLT: 4) ภาพแบบเต็ม (กว่า 300 MB) สามารถลดต่ําลงถึง 20 MB ได้โดยคัดลอกเฉพาะโฟลเดอร์ที่สร้าง [FT: 5] เป็นฐาน (FLT: 6) จัดเก็บข้อมูลนี้สามารถแปลเวลาได้โดยตรงได้โดยตรง โดยเพิ่มค่าเครือข่ายที่ต่ํากว่า 8 และลดค่าใช้จ่ายของเครือข่าย

2. การปรับปรุงความปลอดภัย

ทุกแพกเกจหรือเครื่องมือที่ถูกติดตั้งไว้ในกล่องเป็นภาพที่มีศักยภาพในการอ่อนแอ การสร้างหลายขั้นจะช่วยให้คุณสามารถแยกการรวมเข้ากับการรวม, ตัวดีบั๊ก, และไลบรารีพัฒนาจากภาพสุดท้ายได้ โดยจะลดพื้นผิวการโจมตีลงเล็กน้อย คุณสามารถใช้ภาพต่าง ๆ เช่น [FLT: 7] หรือ [FLT: 8] สําหรับระยะการทํางาน ซึ่งมีเฉพาะการเรียกใช้น้อยที่สุดเท่านั้น

3. กรรมวิธีการสร้างสายน้ํา

ขั้นการสร้างทั้งหมดถูกกําหนดไว้ในแฟ้ม Docerfile ครั้งเดียว ทําให้โพรเซสมีโครงสร้างด้วยตนเองและง่ายต่อรุ่น สายส่ง cI/CD ได้ ประโยชน์จากค่านําเข้าเดียว: The Docerfile. ไม่จําเป็นที่จะต้องรักษาขั้นบันไดในการสร้างหรือล้างด้วยตนเอง

4. การ เพิ่ม ความ สามารถ และ ความ เสมอ ต้น เสมอ ปลาย

การ ใช้ ป้าย ที่ ระบุ ว่า เป็น แบบ ใด สําหรับ ภาพ ฐาน ที่ เป็น ฐาน นั้น ยิ่ง ทํา ให้ มี การ ปรับ ปรุง สิ่ง แวด ล้อม ให้ เสมอ ต้น เสมอ ปลาย.

สร้างแฟ้ม Docker หลายๆ แบบ: ขั้นต่อขั้น

การเดินนี้ครอบคลุมการสร้างแฟ้มประเภทหลายแผ่นของ Natalie Doperfile สําหรับโปรแกรม Node.js และ React

1. วาง แผน ขั้น ตอน

ก่อน จะ เขียน รหัส จง ทํา แผนที่ ขั้น ตอน ที่ คุณ จําเป็น ต้อง มี.

• [FLT: 0] เวทีก่อสร้าง – ติดตั้งเครื่องมือก่อสร้างทั้งหมด ติดตั้งแพกเกจ เชื่อมต่อ และดําเนินการสร้างคําสั่ง
• [FLT: 0] ระยะวิ่ง - ใช้ภาพแบบพื้นฐานน้อยที่สุด ทําสําเนาเฉพาะวัตถุที่สร้างจากเวทีก่อสร้าง และนิยามพฤติกรรมการวิ่งของเวลา

สําหรับโครงการที่ซับซ้อน คุณอาจเพิ่มขั้นตอนกลาง สําหรับการทดสอบ วิเคราะห์แบบคงที่ หรือการบีบข้อมูลสินทรัพย์

2. เขียน เวที ผู้ สร้าง

เริ่มด้วยภาพฐานที่รวมการใช้เครื่องมือต่าง ๆ ที่ต้องการใช้ [FLT: 0] ระยะต่าง ๆ ที่มีชื่อ [FLT: 1] โดยมี [FLT: 9] เพื่ออ้างอิงถึงมันในภายหลัง สําหรับ Node.js:

FROM node:14-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
RUN npm run build

จุดสําคัญ:

• ใช้ [FLT: 11] สําหรับ การติดตั้งสิ่งกีดขวาง, เชื่อมต่อได้เร็วขึ้น
• เก็บ [FLT: 12] คําสั่งเป็นชั้นแยก เมื่อเป็นไปได้ในการต่อรอง
• ติดตั้งเครื่องมือก่อสร้าง (เช่น ชนิด scrapt, weback) เท่านั้นในเวทีนี้

3. เพิ่มเวทีทดสอบอินเตอร์มีเดีย (Opteal)

เพื่อ จะ บังคับ คุณภาพ ของ รหัส ให้ เพิ่ม ขั้น ตอน ที่ ใช้ ใน การ ทดสอบ.

FROM builder AS test
RUN npm run test

คุณสามารถดําเนินการบนเวทีนี้ในท่อส่งน้ํา CI ของคุณด้วย เพื่อจับความล้มเหลวเร็ว ๆ นี้โดยไม่ต้องสร้างภาพสุดท้ายทั้งหมด

4. กําหนดเวทีรันไทม์

สําหรับโปรแกรมที่ทํางาน แฟ้มภาพเวลาทํางาน สามารถเป็นแม่ข่าย Nginx สําหรับแบ็คเอนต์ API อาจจะเป็นภาพพื้นฐานที่แยกออกจากรูปแบบพื้นฐานหรือภาพแบบ Alguage ที่เล็กที่สุดที่มีเวลา โหนด. js ประมวลผล คัดลอกเฉพาะวัตถุที่สําคัญเท่านั้น [FLT: 15]

FROM nginx:alpine
COPY --from=builder /app/build /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

หาก คุณ ต้องการ เวลา ทํา งาน ของ โนด เจส์ จง หลีก เลี่ยง การ ลอก แบบ [FLT: 17] จาก ผู้ สร้าง แทน ที่ จะ ติด ตั้ง การ ผลิต แพกเกจ ขึ้น ใหม่ ใน ช่วง ที่ เสิร์ฟ:

FROM node:14-alpine AS runtime
WORKDIR /app
COPY --from=builder /app/dist ./dist
RUN npm ci --only=production
EXPOSE 3000
CMD ["node", "dist/server.js"]

5. สร้างและทดสอบภาพ

สร้างอิมเมจสุดท้ายโดยใช้คําสั่งมาตรฐาน:

docker build -t myapp:latest .

เพื่อตรวจสอบขนาด ให้เรียก [FLT: 20] และเปรียบเทียบกับการสร้างซิงเกิลสวาป เรียกคอนเทนเนอร์ และยืนยันการตอบสนองของโปรแกรมที่ถูกต้อง:

docker run -d -p 8080:80 myapp:latest
curl http://localhost:8080

การปฏิบัติที่ดีที่สุดสําหรับการสร้างหลาย ๆ สิ่ง

• [FLT: 0] ใช้แท็กพื้นฐาน – เลี่ยง[FLT: 22] เพื่อป้องกันความประหลาดใจ preffer หรือ.
• [FLT: 0]. . . . . . . . . . . . . . . . . . . . . . .
• [FLT: 0]. สืบค้นเมื่อ Kit – อนุญาตให้สร้างคิตได้โดย สําหรับการสร้างที่เร็วขึ้น, เรียงเรียงต่อสาย Cacing, และมีความคล้ายคลึงกันที่ดีขึ้น.
• [FLT: 0] จัดวางขั้นตอนสุดท้ายสําหรับสิ่งแวดล้อมที่แตกต่างกันหลายขั้น [FLT: 1) เป็นต้น – เป็นต้น, เวทีพัฒนาด้วยเครื่องมือดีบั๊ก และเวทีการผลิตที่มีภาพฐานแข็ง.
• [FLT: 0] ใช้ สําหรับการพัฒนาก่อสร้าง – ในการพัฒนา คุณสามารถหยุดที่ เวทีรับโหลดสดและแหล่งที่มา จากนั้นสร้างใหม่ด้วย .
• [FLT: 0] เก็บความลับออกจากภาพ – ใช้ธงของดอกเกอร์คอมคิต หากคุณต้องการที่จะผ่านใบรับรองระหว่างการสร้าง; ไม่เคยรวมมันไว้ในภาพสุดท้าย

แบบ แผน ทั่ว ไป และ ใช้ กรณี

ภาษาที่คอมไพล์แล้ว (ไป, Ross, C++)

สําหรับไบนารีแบบคงที่ ระยะการรันตย์สามารถใช้ [FLT: 33] (ภาพฐาน:) ได้เฉพาะแฟ้มไบนารีและแฟ้มปรับแต่งอาจจะถูกคัดลอกไป (ตัวอย่างสําหรับ go:

FROM golang:1.20-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -o myapp .

FROM scratch
COPY --from=builder /app/myapp /myapp
ENTRYPOINT ["/myapp"]

โปรแกรมไพธอน

ใช้เวทีก่อสร้างกับ [FLT: 35] เพื่อติดตั้งแพกเกจที่ขึ้นต่อกันและคอมไพล์ C ใด ๆ ก็ตาม จากนั้นคัดลอกเฉพาะแพกเกจที่ติดตั้งไว้ ในระยะทํางาน:

FROM python:3.11-slim AS builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --user -r requirements.txt
COPY . .

FROM python:3.11-slim
COPY --from=builder /root/.local /root/.local
COPY --from=builder /app /app
ENV PATH=/root/.local/bin:$PATH
CMD ["python", "app.py"]

ด้านหน้าด้วยเซิร์ฟเวอร์ API

สร้างทั้งหน้าและแบ็คเอนต์ในแฟ้มของ Docerfile หนึ่งตัว โดยแยกระยะการสร้างแต่ละตัวออกจากกัน แล้วคัดลอกทั้งวัตถุไปเป็นรูปภาพแบบเวลาทํางานครั้งเดียว:

FROM node:14-alpine AS frontend-builder
WORKDIR /app
COPY frontend/package*.json ./
RUN npm ci
COPY frontend/ .
RUN npm run build

FROM node:14-alpine AS api-builder
WORKDIR /app
COPY api/package*.json ./
RUN npm ci
COPY api/ .
RUN npm run build

FROM node:14-alpine
WORKDIR /app
COPY --from=frontend-builder /app/build ./public
COPY --from=api-builder /app/dist ./dist
RUN npm ci --only=production
EXPOSE 3000
CMD ["node", "dist/server.js"]

การเจาะระบบหลายระบบ

• [FLT: 0] ลาเยร์ cacing ไม่ทํางาน – แน่ใจว่า สั่งลําดับการขึ้นต่อกันก่อนที่รหัสแหล่งจะเสร็จ ใช้[FT:39] เพื่อยกเว้นแฟ้มที่ไม่จําเป็น
• [FLT: 0] ไม่พบเครื่องหมาย – ตรวจสอบเส้นทางในประโยค เวทีสร้างจะต้องผลิตผลลัพธ์ในตําแหน่งที่ระบุไว้ ใช้ เพื่อดีบั๊ เพื่อดีบั๊
• [FLT: 0] รั่วไหล [FLT: 1] – ห้ามคัดลอกไดเรกทอรีทั้งหมด ที่อาจจะมี หรือ. ทําสําเนาเฉพาะแฟ้มที่จําเป็นเท่านั้น.
• [FLT: 0] ภาพสุดท้ายแม้จะมีหลายระดับ [FLT: 1] – ตรวจสอบว่า คุณถูกคัดลอกโดยไม่ได้ตั้งใจ หรือทั้งแหล่ง. ใช้ ดูขนาดของชั้น

รูปแบบการวน

การสร้างโดกเกอร์หลายระดับ คือรากฐานของการทําคอนเทนเนอร์สมัยใหม่ พวกเขาช่วยให้คุณสามารถใช้งานภาพแบบผอมๆ และปลอดภัยได้ โดยให้กระบวนการก่อสร้างอย่างง่ายและบันทึกในรูปแบบของ Docerfile โดยแยกความกังวลระหว่างการสร้างและเวลาทํางาน คุณสามารถลดขนาดภาพลงได้อย่างมาก โดยเพิ่มระดับความปลอดภัย และลดปริมาณการผลิตท่อส่งแสงแบบสายรุ้ง CI/ CCD เทคนิคที่แสดงที่นี่จะนําไปใช้กับทั้งสแต็กใด ๆ -- ไม่ว่าคุณจะสร้าง Nodj, Go, Java, หรือโปรแกรมฟร้อน หรือเริ่มสร้างโปรแกรมโดย Docers ของคุณที่มีอยู่แล้ว เพื่อสร้างโครงสร้างและสร้างข้อมูลต่าง ๆ ขึ้นทันที คุณจะเห็นการปรับปรุงในการปรับปรุงความเร็ว และค่าใช้จ่ายโดยรวม

สําหรับรายละเอียดเพิ่มเติมนี้ จงอ้างอิงถึง [FLT: 0] ตัวอย่างที่แสดงในภาพยนตร์หลายภาคหน้านี้ (FLT: 1) และ [FLT] Docerfile offical official guard (FLT:3]. alTH World ยังมีอยู่ใน [FLT: 4] สําเนาหอสมุด Docerk (FLT: 5).