Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Erstellung einfacher Container-Images AL2023
<a name="barebones-containers"></a>

Das AL203-Container-Image besteht aus denselben Softwarekomponenten, die im AL2023-AMI enthalten sind. Es enthält eine Software, die es der Basis-Container-Ebene ermöglicht, sich ähnlich zu verhalten wie die Ausführung auf einer Amazon EC2 EC2-Instance, z. B. dem Paketmanager`dnf`. In diesem Abschnitt wird erklärt, wie Sie einen Container von Grund auf neu erstellen können, der nur die für eine Anwendung erforderlichen Mindestabhängigkeiten enthält.

**Anmerkung**  
Die AL2023 Standard-Container-Images sind für die meisten Anwendungsfälle geeignet. Mit den Standard-Container-Images ist es einfach, auf Ihrem eigenen Image aufzubauen. Ein einfaches Container-Image macht es schwieriger, auf Ihrem Image aufzubauen.

**So erstellen Sie einen Container mit minimalen Abhängigkeiten für eine Anwendung**

1. Stellen Sie Ihre Laufzeitabhängigkeiten fest. Diese sind von Ihrer Anwendung abhängig.

1. Konstruieren Sie ein `Dockerfile`/`Containerfile`, das `FROM scratch` aufbaut. Das folgende `Dockerfile`-Beispiel kann verwendet werden, um einen Container zu erstellen, der nur die `bash`-Shell und deren Abhängigkeiten enthält.

   ```
   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. Dieses `Dockerfile` funktioniert wie folgt:

     1.  Starten eines AL2023 Containers mit dem Namen. `build` Dieser Container wird für das Bootstrapping des minimalen Containers verwendet. Dieser Container wird selbst nicht bereitgestellt, sondern generiert den Container, der bereitgestellt werden soll. 

     1.  Erstellen des `/sysroot`-Verzeichnisses. In diesem Verzeichnis installiert der `build`-Container die für den minimalen Container benötigten Abhängigkeiten. Im nächsten Schritt wird der `/sysroot`-Pfad so gepackt, dass er zum Stammverzeichnis unseres minimalen Images wird. 

         Wenn wir die `--installroot` Option auf diese `dnf` Weise verwenden, erstellen wir die anderen AL2023 Bilder. Dies ist ein Feature von `dnf`, mit dem Installationsprogramme und Tools zur Image-Erstellung arbeiten können. 

     1.  Aufruf von `dnf` um Pakete in `/sysroot` zu installieren. 

         Der `rpm -q system-release --qf '%{VERSION}'`-Befehl fragt (`-q`) das `system-release`-Paket ab, wobei das Abfrageformat (`--qf`) festgelegt wird, mit dem die Version des abgefragten Pakets ausgedruckt wird (die `%{VERSION}`-Variable ist die `rpm`-Variable für die `RPM`-Version). 

         Durch eine Festlegung des `--releasever`-Arguments von `dnf` auf die `system-release`-Version im `build`-Container, kann dieses `Dockerfile` verwendet werden, um den minimalen Container jedes Mal neu zu erstellen, wenn ein aktualisiertes Container-Basis-Image von Amazon Linux veröffentlicht wird. 

         Es ist möglich, das `--releasever` auf eine beliebige Amazon Linux 2023-Version einzustellen, z. B. 2023.10.20260325. Dies würde bedeuten, dass der `build` Container als neueste AL2023 Version ausgeführt wird, der Barebones-Container jedoch unabhängig von der aktuellen Version ab 2023.10.20260325 erstellt wird. AL2023 

         Die `--setopt=install_weak_deps=False`-Konfigurationsoption informiert `dnf`, dass nur *erforderliche* Abhängigkeiten installiert werden sollen und nicht solche, die empfohlen oder vorgeschlagen werden. 

     1. Kopieren des installierten Systems in das Stammverzeichnis eines leeren (`FROM scratch`-) Containers.

     1. `ENTRYPOINT` auf den gewünschten Binärwert setzen, hier `/bin/bash`.

1. Erstellen Sie ein leeres Verzeichnis und fügen Sie den Inhalt des Beispiels in Schritt 2 zu einer Datei mit dem Namen `Dockerfile` hinzu.

   ```
   $ 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. Erstellen Sie den Container, indem Sie den folgenden Befehl ausführen.

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

1. Führen Sie den Container mit dem folgenden Befehl aus, um zu sehen, wie minimal ein Nur-`bash`-Container ist.

   ```
   $ 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
   ```

Ein praktischeres Beispiel sehen Sie im folgenden Verfahren, in dem ein Container für eine C-Anwendung erstellt wird, die `Hello World!` anzeigt.

1. Erstellen Sie ein leeres Verzeichnis und fügen Sie den C-Quellcode und `Dockerfile` hinzu.

   ```
   $ 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. Erstellen Sie den Container mithilfe des folgenden Befehls.

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

1. Führen Sie den Container mithilfe des folgenden Befehls aus.

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