Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Creazione di immagini di contenitori essenziali AL2023
<a name="barebones-containers"></a>

L'immagine del contenitore AL2023 è costruita con gli stessi componenti software inclusi nell'AMI AL2023. Include un software che consente al livello di contenitore di base di comportarsi in modo simile all'esecuzione su un'istanza Amazon EC2, ad esempio il gestore di pacchetti. `dnf` Questa sezione spiega come creare un contenitore partendo da zero che includa solo le dipendenze minime necessarie per un'applicazione.

**Nota**  
Le immagini standard dei AL2023 contenitori sono adatte alla maggior parte dei casi d'uso. L'uso dell'immagine di container standard semplifica la creazione sulla base dell'immagine. Un'immagine contenitore semplice rende più difficile la creazione sulla base dell'immagine.

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

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

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

     1.  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'`--installroot`opzione 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. 

     1.  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.20260325. Ciò significherebbe che il `build` contenitore funzionerebbe come AL2023 versione più recente, ma creerebbe il contenitore barebones a partire dalla versione 2023.10.20260325 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. 

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

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

1. 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
   ```

1. Crea il container eseguendo il comando seguente.

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

1. 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
   ```

Per un esempio più pratico, la procedura seguente consente di creare un container per un'applicazione C che visualizza `Hello World!`.

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

1. Avvia il container utilizzando il comando seguente.

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

1. Esegui il container utilizzando il comando seguente.

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