Erstellung von Bare-Bones AL2 (023) Container-Images

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.

2. 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. Es wird ein AL2 023-Container mit dem Namen gestartet. 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.

      2. 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 AL2 023-Bilder. Dies ist ein Feature von dnf, mit dem Installationsprogramme und Tools zur Image-Erstellung arbeiten können.

      3. 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.6.20250203. Dies würde bedeuten, dass der build Container als neueste Version AL2 023 ausgeführt wird, der Barebones-Container jedoch unabhängig von der aktuellen Version 023 ab 2023.6.20250203 erstellt wird. AL2

         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.

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

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

3. 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
   	

4. Erstellen Sie den Container, indem Sie den folgenden Befehl ausführen.

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

5. 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
   

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
   
   

2. Erstellen Sie den Container mithilfe des folgenden Befehls.

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

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

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