Bagaimanakah saya menggunakan pelbagai peringkat membina di Docker untuk membuat imej yang lebih kecil dan lebih selamat?

Multi-stage dibina di Docker adalah ciri yang membolehkan anda menggunakan pelbagai FROM pernyataan di Dockerfile anda. Setiap FROM pernyataan boleh memulakan tahap baru proses membina, dan anda boleh menyalin artifak dari satu tahap ke tahap yang lain. Kaedah ini amat berguna untuk mewujudkan imej Docker yang lebih kecil dan lebih selamat dengan memisahkan persekitaran membina dari persekitaran runtime.

Berikut adalah cara anda boleh menggunakan pelbagai peringkat untuk mencapai matlamat ini:

1. Tentukan Peringkat Membina : Mulailah dengan menentukan tahap binaan di mana anda menyusun permohonan anda atau sediakan artifak anda. Sebagai contoh, anda mungkin menggunakan imej golang untuk menyusun aplikasi GO.

    <code class="Dockerfile">FROM golang:1.16 as builder WORKDIR /app COPY . . RUN go build -o myapp</code>

2. Tentukan Peringkat Runtime : Selepas peringkat membina, tentukan peringkat runtime dengan imej asas yang minimum. Salin hanya artifak yang diperlukan dari peringkat binaan ke peringkat runtime ini.

    <code class="Dockerfile">FROM alpine:3.14 COPY --from=builder /app/myapp /myapp CMD ["/myapp"]</code>

Dengan menggunakan membina pelbagai peringkat, anda berakhir dengan imej akhir yang hanya mengandungi apa yang diperlukan untuk menjalankan aplikasi anda, yang jauh lebih kecil dan mempunyai kelemahan yang lebih sedikit berbanding dengan imej yang digunakan untuk membina.

Apakah amalan terbaik untuk menganjurkan kod dalam membina Docker pelbagai peringkat?

Menguruskan kod dengan berkesan dalam pembentukan Docker pelbagai peringkat dapat meningkatkan kecekapan dan kejelasan fail docker anda. Berikut adalah beberapa amalan terbaik:

1. Kebimbangan berasingan : Gunakan peringkat yang berbeza untuk tujuan yang berbeza (contohnya, bangunan, ujian, dan penyebaran). Pemisahan kebimbangan ini menjadikan fail docker anda lebih mudah difahami dan dikekalkan.

    <code class="Dockerfile"># Build stage FROM node:14 as builder WORKDIR /app COPY package*.json ./ RUN npm install COPY . . RUN npm run build # Test stage FROM node:14 as tester WORKDIR /app COPY --from=builder /app . RUN npm run test # Runtime stage FROM node:14-alpine WORKDIR /app COPY --from=builder /app/build /app/build CMD ["node", "app/build/index.js"]</code>

2. Kurangkan bilangan lapisan : Campurkan arahan lari jika mungkin untuk mengurangkan bilangan lapisan dalam imej anda. Amalan ini bukan sahaja mempercepatkan proses membina tetapi juga menjadikan imej yang dihasilkan lebih kecil.

    <code class="Dockerfile">RUN apt-get update && \ apt-get install -y some-package && \ rm -rf /var/lib/apt/lists/*</code>

3. Gunakan .dockerignore : Buat fail .dockerignore untuk mengecualikan fail yang tidak perlu daripada disalin ke dalam konteks membina Docker. Ini mempercepat proses membina dan mengurangkan saiz imej.
4. Mengoptimumkan operasi salinan : Hanya salin fail yang diperlukan untuk setiap peringkat. Sebagai contoh, dalam peringkat binaan untuk aplikasi Node.js, anda mungkin menyalin package.json terlebih dahulu, jalankan npm install , dan kemudian menyalin permohonan yang lain.
5. Gunakan peringkat bernama : Berikan nama yang bermakna ke peringkat anda untuk menjadikan Dockerfile lebih mudah dibaca dan diselenggara.

Bagaimanakah saya dapat mengoptimumkan caching di Docker pelbagai peringkat membina untuk meningkatkan masa binaan?

Mengoptimumkan caching dalam pembentukan Docker pelbagai peringkat boleh mengurangkan masa membina. Berikut adalah beberapa strategi untuk mencapai ini:

1. Perintah Operasi : Letakkan perintah yang kerap berubah ke arah akhir Dockerfile anda. Docker akan cache lapisan dari permulaan fail Docker, mempercepatkan binaan berikutnya.

    <code class="Dockerfile">FROM node:14 as builder WORKDIR /app COPY package*.json ./ RUN npm install COPY . . RUN npm run build</code>

   Dalam contoh ini, npm install kurang berkemungkinan berubah daripada kod aplikasi, jadi ia diletakkan sebelum COPY . . perintah.

2. Gunakan Multi-Stage Builds : Setiap peringkat boleh di-cache secara bebas. Ini bermakna anda boleh memanfaatkan cache membina untuk setiap peringkat, berpotensi menjimatkan masa pada binaan berikutnya.

3. Leverage Buildkit : Docker Buildkit menawarkan mekanisme caching membina yang lebih baik. Dayakan BuildKit dengan menetapkan pembolehubah persekitaran DOCKER_BUILDKIT=1 dan gunakan perintah RUN --mount baru untuk melancarkan direktori cache.

    <code class="Dockerfile"># syntax=docker/dockerfile:experimental FROM golang:1.16 as builder RUN --mount=type=cache,target=/root/.cache/go-build \ go build -o myapp</code>

4. Kurangkan konteks membina Docker : Gunakan fail .dockerignore untuk mengecualikan fail yang tidak perlu dari konteks binaan. Konteks yang lebih kecil bermakna kurang data untuk memindahkan dan membina lebih cepat.
5. Gunakan imej asas tertentu : Gunakan imej asas ringan dan stabil untuk mengurangkan masa yang diperlukan untuk menarik lapisan asas semasa membina.

Apakah faedah keselamatan yang dibina oleh Docker Multi-Stage berbanding dengan binaan satu peringkat?

Docker Multi-Stage Membina menyediakan beberapa manfaat keselamatan berbanding dengan satu peringkat membina:

1. Saiz imej yang lebih kecil : Dengan menyalin hanya artifak yang diperlukan dari peringkat binaan ke peringkat runtime, pelbagai peringkat membina menghasilkan imej akhir yang lebih kecil. Imej yang lebih kecil mempunyai permukaan serangan yang dikurangkan kerana ia mengandungi komponen yang lebih sedikit yang boleh terdedah.
2. Kerentanan yang dikurangkan : Oleh kerana imej akhir tidak termasuk alat binaan atau kebergantungan yang diperlukan hanya semasa proses membina, terdapat lebih sedikit peluang untuk penyerang untuk mengeksploitasi kelemahan dalam alat tersebut.
3. Pengasingan Persekitaran Membina dan Runtime : Pembentukan pelbagai peringkat membolehkan anda menggunakan imej asas yang berbeza untuk membina dan menjalankan aplikasi anda. Persekitaran membina boleh menjadi lebih permisif dan termasuk alat yang diperlukan untuk menyusun atau membungkus, sementara persekitaran runtime boleh lebih terhad dan dioptimumkan untuk keselamatan.
4. Pematuhan yang lebih mudah : Imej yang lebih kecil dan lebih fokus lebih mudah untuk mengimbas kelemahan dan memastikan pematuhan terhadap dasar keselamatan, menjadikannya lebih mudah untuk mengekalkan persekitaran yang selamat.
5. Mengehadkan Pendedahan Rahsia : Oleh kerana data sensitif (seperti kekunci API yang digunakan semasa binaan) tidak perlu dimasukkan ke dalam imej akhir, membina pelbagai peringkat dapat membantu mencegah rahsia daripada terdedah dalam persekitaran runtime.

Dengan memanfaatkan pelbagai peringkat membina, anda dapat meningkatkan sikap keselamatan imej docker anda sambil juga mengoptimumkan saiz dan prestasi mereka.

Atas ialah kandungan terperinci Bagaimanakah saya menggunakan pelbagai peringkat membina di Docker untuk membuat imej yang lebih kecil dan lebih selamat?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!