Creazione di immagini di contenitori essenziali AL2023

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 denominato AL2023 . 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.

         Usare l'--installrootopzione to dnf in questo modo è il modo in cui creiamo le altre AL2023 immagini. 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.10.20260216. Ciò significherebbe che il build contenitore funzionerebbe come AL2023 versione più recente, ma creerebbe il contenitore barebones a partire dalla versione 2023.10.20260216 indipendentemente dalla versione corrente. AL2023

         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!