Creazione di 023 immagini di contenitori semplici AL2

Per creare un container con dipendenze minime essenziali per un'applicazione

1. Determina le dipendenze di runtime. Questo aspetto varia a seconda dell'applicazione.

2. Crea un Dockerfile/Containerfile che consenta di sviluppare FROM scratch. Il seguente esempio di Dockerfile può essere usato per creare un container che include solo la shell bash e le relative dipendenze.

   
   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. Questo Dockerfile funziona tramite:

      1. Avvio di un contenitore AL2 023 denominato. build Questo container viene utilizzato per il bootstrap dei container essenziali; non viene implementato, ma genera il container da implementare.

      2. Creazione della directory /sysroot. In questa directory il container build installa le dipendenze necessarie per il container essenziale. In un passaggio successivo, il percorso /sysroot viene impacchettato per diventare la directory principale dell'immagine essenziale.

         L'uso dell'--installrootopzione to dnf in questo modo è il modo in cui creiamo le altre immagini AL2 023. Si tratta di una funzionalità di dnf che consente il funzionamento dei programmi di installazione e degli strumenti per la creazione di immagini.

      3. Richiamo di dnf per installare pacchetti in /sysroot.

         Il comando rpm -q system-release --qf '%{VERSION}' interroga (-q) il pacchetto system-release, impostando il formato della query (--qf) per stampare la versione del pacchetto sottoposta a query (la variabile %{VERSION} è la variabile rpm per la versione di RPM).

         Impostando l'argomento --releasever di dnf sulla versione di system-release nel container build, il Dockerfile può essere utilizzato per creare nuovamente il container essenziali ogni volta che viene rilasciata un'immagine di container di base aggiornata di Amazon Linux.

         È possibile impostarlo su qualsiasi versione di Amazon Linux 2023, --releasever ad esempio 2023.8.20250908. Ciò significherebbe che il build contenitore funzionerebbe come l'ultima versione AL2 023, ma creerebbe il contenitore barebones dalla versione 2023.8.20250908 indipendentemente dalla versione 023 corrente. AL2

         L'opzione di configurazione --setopt=install_weak_deps=False istruisce dnf affinché installi solo le dipendenze che sono richieste, anziché quelle consigliate o suggerite.

      4. Copia del sistema installato nella directory principale di un container vuoto (FROM scratch).

      5. Impostazione di ENTRYPOINT come binario desiderato, in questo caso /bin/bash.

3. Crea una directory vuota e aggiungi il contenuto dell'esempio riportato nel passaggio 2 a un file denominato 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
   	

4. Crea il container eseguendo il comando seguente.

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

5. Esegui il container usando il comando seguente per capire quanto è minimo un container solo bash.

   $ 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. Crea una directory vuota, quindi aggiungi il codice sorgente C e 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
   
   

2. Avvia il container utilizzando il comando seguente.

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

3. Esegui il container utilizzando il comando seguente.

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