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

# Utilizzo AL2023 in contenitori
<a name="container"></a>

**Nota**  
 Per ulteriori informazioni su come utilizzare per ospitare carichi AL2023 di lavoro containerizzati su Amazon ECS, consulta. [AL2023 per gli host di container Amazon ECS](ecs.md) 

 Esistono diversi modi che AL2023 possono essere utilizzati all'interno dei contenitori a seconda del caso d'uso. [AL2023 Immagine del contenitore di base](base-container.md)È molto simile a un'immagine di contenitore Amazon Linux 2 e all'AMI AL2023 minima. 

 Per gli utenti esperti, offriamo un'immagine minimale del contenitore, introdotta nella release AL2023 .2, insieme alla documentazione che descrive come creare contenitori [bare-bone](barebones-containers.md). 

 AL2023 può essere utilizzato anche per ospitare carichi di lavoro containerizzati, basati su immagini di container o contenitori AL2023 basati su altre distribuzioni Linux. Puoi usare [AL2023 per gli host di container Amazon ECS](ecs.md) oppure usare direttamente i pacchetti di runtime dei container forniti. I `nerdctl` pacchetti`docker`,`containerd`, e sono disponibili per essere installati e utilizzati. AL2023 

**Topics**
+ [Utilizzo dell'immagine del contenitore di AL2023 base](base-container.md)
+ [AL2023 Immagine minima del contenitore](minimal-container.md)
+ [Creazione di immagini di contenitori essenziali AL2023](barebones-containers.md)
+ [Confronto dei pacchetti installati sulle immagini di container Amazon Linux 2023](al2023-container-image-types.md)
+ [Confronto dei pacchetti installati sulle immagini di container e AMI minime Amazon Linux 2023](al2023-container-ami.md)

# Utilizzo dell'immagine del contenitore di AL2023 base
<a name="base-container"></a>

L'immagine del AL2023 contenitore è costruita con gli stessi componenti software inclusi nell' AL2023 AMI. È disponibile per l'uso in qualsiasi ambiente come immagine di base per i carichi di lavoro di Docker. Se usi già l'AMI Amazon Linux per le applicazioni in [Amazon Elastic Compute Cloud](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/) (Amazon EC2), puoi containerizzare le tue applicazioni con l'immagine di container Amazon Linux.

Usa l'immagine del contenitore Amazon Linux nel tuo ambiente di sviluppo locale e poi invia l'applicazione all' AWS utilizzo di [Amazon Elastic Container Service](https://docs.aws.amazon.com/AmazonECS/latest/userguide/) (Amazon ECS). Per ulteriori informazioni, consulta la pagina dedicata all'[utilizzo di immagini Amazon ECR con Amazon ECS](https://docs.aws.amazon.com/AmazonECR/latest/userguide/ECR_on_ECS.html) nella *Guida per l'utente di Amazon Elastic Container Registry*.

L'immagine di container Amazon Linux è disponibile su Amazon ECR Public. Puoi fornire un feedback AL2023 tramite il tuo AWS rappresentante designato o segnalando un problema nel repository [amazon-linux-2023](https://github.com/amazonlinux/amazon-linux-2023/issues) su. GitHub

****Per estrarre l'immagine di container Amazon Linux da Amazon ECR Public****

1. Autentica il client Docker nel registro Amazon Linux Public. I token di autenticazione sono validi 12 ore. Per ulteriori informazioni, consulta [Autenticazione del registro privato](https://docs.aws.amazon.com/AmazonECR/latest/userguide/registry_auth.html) nella *Guida per l'utente di Amazon Elastic Container Registry*.
**Nota**  
Il **get-login-password** comando è supportato utilizzando l'ultima versione della versione 2. AWS CLI Per ulteriori informazioni, consulta [Installazione dell’ AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) nella *Guida per l’utente dell’AWS Command Line Interface *.

   ```
   $ aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws
   ```

   L'output è il seguente.

   ```
   Login succeeded
   ```

1. Estrai l'immagine di container Amazon Linux eseguendo il comando **docker pull**. Per visualizzare l'immagine del container Amazon Linux nella galleria di Amazon ECR Public, consulta la [galleria di Amazon ECR Public - amazonlinux](https://gallery.ecr.aws/amazonlinux/amazonlinux).
**Nota**  
Quando si estrae l'immagine del AL2023 Docker contenitore, è possibile utilizzare i tag in uno dei seguenti formati:  
Per ottenere la versione più recente dell'immagine del AL2023 contenitore, usa il `:2023` tag.
Per ottenere una versione specifica di AL2023, puoi utilizzare il seguente formato:  
`:2023.[0-7 release quarter].[release date].[build number]`
Gli esempi seguenti utilizzano il tag `:2023` e recuperano l'immagine del contenitore più recente disponibile di AL2023.

   ```
   $ docker pull public.ecr.aws/amazonlinux/amazonlinux:2023
   ```

1. (Opzionale) Esegui il container a livello locale.

   ```
   $ docker run -it --security-opt seccomp=unconfined public.ecr.aws/amazonlinux/amazonlinux:2023 /bin/bash
   ```

**Per estrarre l'immagine del AL2023 contenitore da Docker Hub**

1. Estrai l'immagine del AL2023 contenitore usando il **docker pull** comando.

   ```
   $ docker pull amazonlinux:2023
   ```

1. (Opzionale) Esegui il container a livello locale.

   ```
   $ docker run -it amazonlinux:2023 /bin/bash
   ```
**Nota**  
L'immagine del contenitore di AL2023 utilizza solo il gestore di `dnf` pacchetti per installare i pacchetti software. Ciò significa che non esiste alcun comando `amazon-linux-extras` né uno equivalente da usare per software aggiuntivi.

# AL2023 Immagine minima del contenitore
<a name="minimal-container"></a>

**Nota**  
 Le immagini standard del AL2023 contenitore sono adatte alla maggior parte dei casi d'uso e l'adattamento all'immagine minima del contenitore è probabilmente più faticoso che adattarsi all'immagine del contenitore di AL2023 base. 

 L'immagine AL2023 minima del contenitore, introdotta in AL2023 .2, differisce dall'immagine del contenitore di base perché contiene solo i pacchetti minimi necessari per installare altri pacchetti. L'immagine minima del contenitore è progettata per essere un insieme minimo di pacchetti, non un comodo set di pacchetti. 

 L'immagine AL2023 minima del contenitore è creata a partire da componenti software già disponibili in AL2023. La differenza principale nell'immagine minimale del contenitore consiste nell'utilizzo `microdnf` del gestore dei `dnf` pacchetti piuttosto che in quello Python basato su tutte le funzionalità`dnf`. Ciò consente di ridurre al minimo l'immagine del contenitore, con il vantaggio di non disporre del set completo di funzionalità del gestore di `dnf` pacchetti, incluso nell'immagine del AL2023 AMIs contenitore di base. 

 L'immagine AL2023 minimale del contenitore costituisce la base dell'ambiente di runtime `provided.al2023` AWS Lambda. 

 Per un elenco dettagliato dei pacchetti inclusi nell'immagine minima del contenitore, consulta[Confronto dei pacchetti installati sulle immagini di container Amazon Linux 2023](al2023-container-image-types.md). 

## Dimensioni dell'immagine di container minima
<a name="container-minimal-size"></a>

 Poiché l'immagine AL2023 minima del contenitore contiene meno pacchetti rispetto all'immagine del contenitore di AL2023 base, è anche notevolmente più piccola. La tabella seguente confronta le opzioni relative all'immagine del contenitore delle versioni correnti e precedenti di Amazon Linux. 

**Nota**  
 Le dimensioni delle immagini sono quelle mostrate nella pagina della [Galleria pubblica di Amazon ECR dedicata ad Amazon Linux](https://gallery.ecr.aws/amazonlinux/amazonlinux). 


| Immagine | Versione | Dimensioni dell'immagine | Nota | 
| --- | --- | --- | --- | 
| Amazon Linux (1AL1) | 2018/03/0,20230918,0 | 62,3 MB | Solo x86-64 | 
| Amazon Linux 2 | 2,0,20230926,0 | 64,2 MB | aarch64 è di 1,6 MB più grande di x86-64 | 
| Immagine di container di base Amazon Linux 2023 | 20232,20231002,0 | 52,4 MB |  | 
| Immagine di container minima Amazon Linux 2023 | 2023.2.20231002.0-minimal | 35,2 MB |  | 

## Utilizzo dell'immagine Minimal Container AL2023
<a name="using-container-minimal"></a>

 L'immagine AL2023 minima del contenitore è disponibile su ECR e il `2023-minimal` tag punterà sempre all'immagine del contenitore minimo AL2023 basata più recente, mentre il `minimal` tag può essere aggiornato a una versione più recente di Amazon Linux rispetto AL2023 a. 

 Puoi estrarre questi tag usando `docker` il seguente esempio: 

```
$ docker pull public.ecr.aws/amazonlinux/amazonlinux:minimal
```

```
$ docker pull public.ecr.aws/amazonlinux/amazonlinux:2023-minimal
```

L'esempio seguente mostra un file `Dockerfile` che prende l'immagine minima del contenitore e installa GCC su di essa:

```
FROM public.ecr.aws/amazonlinux/amazonlinux:2023-minimal
RUN dnf install -y gcc && dnf clean all
```

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

# Confronto dei pacchetti installati sulle immagini di container Amazon Linux 2023
<a name="al2023-container-image-types"></a>

Un confronto tra il RPMs presente sull'immagine del contenitore di AL2023 base e il RPMs presente sull'immagine AL2023 minima del contenitore.

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/linux/al2023/ug/al2023-container-image-types.html)

# Confronto dei pacchetti installati sulle immagini di container e AMI minime Amazon Linux 2023
<a name="al2023-container-ami"></a>

Un confronto tra il RPMs presente sull'AMI AL2023 minimale e il RPMs presente sulle immagini di AL2023 base e minimali del contenitore.

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/linux/al2023/ug/al2023-container-ami.html)