Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Membangun gambar kontainer tanpa tulang AL2023
<a name="barebones-containers"></a>

Gambar kontainer AL2023 dibuat dari komponen perangkat lunak yang sama yang disertakan dalam AMI AL2023. Ini mencakup perangkat lunak yang memungkinkan lapisan wadah dasar berperilaku serupa dengan berjalan pada instance Amazon EC2, seperti manajer paket. `dnf` Bagian ini menjelaskan bagaimana Anda dapat membuat kontainer dari awal yang hanya mencakup dependensi minimum yang diperlukan untuk aplikasi.

**catatan**  
Gambar AL2023 wadah standar cocok untuk sebagian besar kasus penggunaan. Menggunakan gambar kontainer standar membuatnya mudah untuk membangun di atas gambar Anda. Gambar kontainer tanpa tulang membuatnya lebih sulit untuk dibangun di atas gambar Anda.

**Untuk membuat wadah dengan dependensi minimum untuk aplikasi**

1. Tentukan dependensi runtime Anda. Ini akan bervariasi berdasarkan aplikasi Anda.

1. Membangun a`Dockerfile`/`Containerfile`yang membangun`FROM scratch`. Contoh berikut dari a `Dockerfile` dapat digunakan untuk membangun sebuah wadah yang hanya berisi `bash` shell dan dependensinya.

   ```
   FROM public.ecr.aws/amazonlinux/amazonlinux:2023 as build
   RUN mkdir /sysroot
   RUN dnf --releasever=$(rpm -q system-release --qf '%{VERSION}') \
     --installroot /sysroot \
     -y \
     --setopt=install_weak_deps=False \
     install bash
   
   FROM scratch
   COPY --from=build /sysroot /
   WORKDIR /
   ENTRYPOINT ["/bin/bash"]
   ```

   1. Ini `Dockerfile` bekerja oleh:

     1.  Memulai AL2023 wadah bernama`build`. Wadah ini akan digunakan untuk mem-bootstrap wadah barebone, wadah ini tidak digunakan sendiri, tetapi menghasilkan wadah yang akan digunakan. 

     1.  Membuat `/sysroot` direktori. Direktori ini akan menjadi tempat `build` wadah akan menginstal dependensi yang diperlukan untuk wadah barebones. Pada langkah berikutnya, `/sysroot` jalur akan dikemas menjadi direktori root dari gambar barebone kami. 

         Menggunakan `--installroot` opsi untuk dengan `dnf` cara ini adalah bagaimana kita membuat AL2023 gambar lainnya. Ini adalah fitur `dnf` yang memungkinkan penginstal dan perkakas pembuatan gambar berfungsi. 

     1.  Memohon `dnf` untuk menginstal paket ke dalam`/sysroot`. 

         `rpm -q system-release --qf '%{VERSION}'`Perintah query (`-q`) `system-release` paket, mengatur format query (`--qf`) untuk mencetak versi paket yang ditanyakan (`%{VERSION}`variabel adalah `rpm` variabel untuk versi). `RPM` 

         Dengan menyetel `--releasever` argumen `dnf` ke versi `system-release` dalam `build` wadah, ini `Dockerfile` dapat digunakan untuk membangun kembali wadah barebone setiap kali gambar dasar kontainer yang diperbarui dari Amazon Linux dirilis. 

         Dimungkinkan untuk mengatur ke versi Amazon Linux 2023 apa pun, seperti 2023.10.20260325. `--releasever` Melakukan ini berarti bahwa `build` penampung akan berjalan sebagai AL2023 versi terbaru, tetapi membangun wadah barebone dari 2023.10.20260325 terlepas dari apa rilis saat ini. AL2023 

         Opsi `--setopt=install_weak_deps=False` konfigurasi memberitahu `dnf` untuk hanya menginstal dependensi yang *diperlukan* daripada direkomendasikan atau disarankan. 

     1. Menyalin sistem yang diinstal ke root wadah kosong (`FROM scratch`).

     1. Mengatur `ENTRYPOINT` menjadi biner yang diinginkan, dalam hal ini`/bin/bash`.

1. Buat direktori kosong dan tambahkan konten contoh di Langkah 2 ke file bernama`Dockerfile`.

   ```
   $ mkdir al2023-barebones-bash-example
   	$ cd al2023-barebones-bash-example
   	$ cat > Dockerfile <<EOF
   FROM public.ecr.aws/amazonlinux/amazonlinux:2023 as build
   RUN mkdir /sysroot
   RUN dnf --releasever=$(rpm -q system-release --qf '%{VERSION}') \
     --installroot /sysroot \
     -y \
     --setopt=install_weak_deps=False \
     install bash && dnf --installroot /sysroot clean all
   
   FROM scratch
   COPY --from=build /sysroot /
   WORKDIR /
   ENTRYPOINT ["/bin/bash"]
   EOF
   ```

1. Bangun wadah dengan menjalankan perintah berikut.

   ```
   $ docker build -t al2023-barebones-bash-example
   ```

1. Jalankan container menggunakan perintah berikut untuk melihat seberapa minimal container `bash` -only.

   ```
   $ docker run -it --rm al2023-barebones-bash-example
   bash-5.2# rpm
   bash: rpm: command not found
   bash-5.2# du -sh /usr/
   bash: du: command not found
   bash-5.2# ls
   bash: ls: command not found
   bash-5.2# echo /bin/*
   /bin/alias /bin/bash /bin/bashbug /bin/bashbug-64 /bin/bg /bin/catchsegv /bin/cd /bin/command /bin/fc /bin/fg /bin/gencat /bin/getconf /bin/getent /bin/getopts /bin/hash /bin/iconv /bin/jobs /bin/ld.so /bin/ldd /bin/locale /bin/localedef /bin/pldd /bin/read /bin/sh /bin/sotruss /bin/sprof /bin/type /bin/tzselect /bin/ulimit /bin/umask /bin/unalias /bin/wait /bin/zdump
   ```

Untuk contoh yang lebih praktis, prosedur berikut membangun wadah untuk aplikasi C yang ditampilkan`Hello World!`.

1. Buat direktori kosong dan tambahkan kode sumber C dan`Dockerfile`.

   ```
   $ mkdir al2023-barebones-c-hello-world-example
   $ cd al2023-barebones-c-hello-world-example
   $ cat > hello-world.c <<EOF
   #include <stdio.h>
   int main(void)
   {
     printf("Hello World!\n");
     return 0;
   }
   EOF
   
   $ cat > Dockerfile <<EOF
   FROM public.ecr.aws/amazonlinux/amazonlinux:2023 as build
   COPY hello-world.c /
   RUN dnf -y install gcc
   RUN gcc -o hello-world hello-world.c
   RUN mkdir /sysroot
   RUN mv hello-world /sysroot/
   RUN dnf --releasever=$(rpm -q system-release --qf '%{VERSION}') \
     --installroot /sysroot \
     -y \
     --setopt=install_weak_deps=False \
     install glibc && dnf --installroot /sysroot clean all
   
   FROM scratch
   COPY --from=build /sysroot /
   WORKDIR /
   ENTRYPOINT ["/hello-world"]
   EOF
   ```

1. Bangun wadah menggunakan perintah berikut.

   ```
   $ docker build -t al2023-barebones-c-hello-world-example .
   ```

1. Jalankan wadah menggunakan perintah berikut.

   ```
   $ docker run -it --rm al2023-barebones-c-hello-world-example
   Hello World!
   ```