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à.
# Spostamento di un'immagine durante il suo ciclo di vita in Amazon ECR
Se utilizzi Amazon ECR per la prima volta, segui i passaggi seguenti con la CLI Docker e poi AWS CLI per creare un'immagine di esempio, autenticarti nel registro predefinito e creare un repository privato. Quindi invia un'immagine e recupera un'immagine dal repository privato. Quando hai finito con l'immagine di esempio, elimina l'immagine campione e il repository.
Per utilizzare il Console di gestione AWS anziché il AWS CLI, consulta[Creazione di un repository privato Amazon ECR per archiviare immagini](repository-create.md).
[Per ulteriori informazioni sugli altri strumenti disponibili per la gestione AWS delle risorse, inclusi i diversi AWS SDKs toolkit IDE e gli strumenti da riga di PowerShell comando di Windows, vedere http://aws.amazon.com/tools/.](https://aws.amazon.com/tools/)
## Prerequisiti
Se non hai la versione più recente AWS CLI e Docker installata e pronta all'uso, segui la procedura seguente per installare entrambi questi strumenti.
### Installa il AWS CLI
Per utilizzarlo AWS CLI con Amazon ECR, installa la AWS CLI versione più recente. Per informazioni, consulta [Installazione dell' AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html) nella *Guida per l'utente di AWS Command Line Interface *.
### Installa Docker
Docker è disponibile per diversi sistemi operativi, compresa la maggior parte delle distribuzioni Linux, ad esempio Ubuntu, e persino per macOS e Windows. Per ulteriori informazioni sull'installazione di Docker sul tuo specifico sistema operativo, consulta la [guida all'installazione di Docker](https://docs.docker.com/engine/installation/#installation).
Per l'utilizzo di Docker non è necessario un sistema di sviluppo locale. Se già utilizzi Amazon EC2, puoi avviare un'istanza Amazon Linux 2023 e installare Docker per iniziare.
Se hai già installato Docker, passa a [Fase 1: creazione di un'immagine Docker](#cli-create-image).
**Installazione di Docker su un'istanza Amazon EC2 con un'AMI Amazon Linux 2023**
1. Avvia un'istanza con l'ultima AMI Amazon Linux 2023. Per ulteriori informazioni, consulta [Launching an Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/launching-instance.html) nella *Amazon EC2* User Guide.
1. Connettiti alla tua istanza. Per ulteriori informazioni, consulta [Connect to Your Linux Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstances.html) nella *Amazon EC2 User Guide*.
1. Aggiorna i pacchetti installati e la cache dei pacchetti sulla tua istanza.
```
sudo yum update -y
```
1. Installa il pacchetto Docker Community Edition più recente.
```
sudo yum install docker
```
1. Avvia il servizio Docker.
```
sudo service docker start
```
1. Aggiungi `ec2-user` al gruppo `docker` in modo da poter eseguire comandi Docker senza utilizzare `sudo`.
```
sudo usermod -a -G docker ec2-user
```
1. Esci e ripeti l'accesso per trovare il nuovo gruppo di autorizzazioni `docker`. A questo scopo, puoi chiudere la finestra del terminale SSH corrente e riconnetterti all'istanza in una nuova finestra. La nuova sessione SSH avrà le autorizzazioni del gruppo `docker` appropriate.
1. Verifica che `ec2-user` possa eseguire i comandi Docker senza `sudo`.
```
docker info
```
**Nota**
In alcuni casi, l'assegnazione delle autorizzazioni necessarie a `ec2-user` per accedere al daemon Docker può richiedere il riavvio dell'istanza. Prova a riavviare l'istanza se visualizzi questo errore:
```
Cannot connect to the Docker daemon. Is the docker daemon running on this host?
```
## Fase 1: creazione di un'immagine Docker
In questa fase viene descritto come creare un'immagine Docker di una semplice applicazione Web e come testarla nel sistema locale o nell'istanza Amazon EC2.
**Per creare un'immagine Docker di una semplice applicazione Web**
1. Crea un file denominato `Dockerfile`. Un Dockerfile è un file manifest che descrive l'immagine di base da utilizzare per l'immagine Docker, nonché gli elementi da installare ed eseguire su di essa. Per ulteriori informazioni sui Dockerfile, consulta la [documentazione di riferimento sui Dockerfile](https://docs.docker.com/engine/reference/builder/).
```
touch Dockerfile
```
1. Modifica il `Dockerfile` appena creato e aggiungi i seguenti contenuti.
```
FROM public.ecr.aws/amazonlinux/amazonlinux:latest
# Install dependencies
RUN yum update -y && \
yum install -y httpd
# Install apache and write hello world message
RUN echo 'Hello World!' > /var/www/html/index.html
# Configure apache
RUN echo 'mkdir -p /var/run/httpd' >> /root/run_apache.sh && \
echo 'mkdir -p /var/lock/httpd' >> /root/run_apache.sh && \
echo '/usr/sbin/httpd -D FOREGROUND' >> /root/run_apache.sh && \
chmod 755 /root/run_apache.sh
EXPOSE 80
CMD /root/run_apache.sh
```
Questo Dockerfile utilizza l'immagine pubblica di Amazon Linux 2 ospitata su Amazon ECR Public. Le istruzioni `RUN` aggiornano le cache dei pacchetti, installano alcuni pacchetti software per il server Web e infine scrivono il contenuto "Hello World\$1" nella root del documento del server Web. L'istruzione `EXPOSE` espone la porta 80 nel container, mentre l'istruzione `CMD` avvia il server Web.
1. Crea l'immagine Docker dal tuo Dockerfile.
**Nota**
In alcune versioni di Docker, il seguente comando potrebbe richiedere il percorso completo al Dockerfile anziché il percorso relativo mostrato di seguito.
```
docker build -t hello-world .
```
1. Elenca l'immagine del container.
```
docker images --filter reference=hello-world
```
Output:
```
REPOSITORY TAG IMAGE ID CREATED SIZE
hello-world latest e9ffedc8c286 4 minutes ago 194MB
```
1. Esegui l'immagine appena creata. L'opzione `-p 80:80` mappa la porta 80 esposta sul container alla porta 80 sul sistema host. Per ulteriori informazioni sul comando **docker run**, consulta la documentazione di riferimento di [Docker run](https://docs.docker.com/engine/reference/run/).
```
docker run -t -i -p 80:80 hello-world
```
**Nota**
L'output dal server Web Apache viene visualizzato nella finestra del terminale. Puoi ignorare il messaggio "`Could not reliably determine the fully qualified domain name`".
1. Apri un browser e accedi al server su cui è in esecuzione Docker e che ospita il tuo container.
+ Se utilizzi un'istanza EC2, si tratta del valore **Public DNS** (DNS pubblico) del server, che è lo stesso indirizzo utilizzato per la connessione all'istanza con SSH. Assicurati che il gruppo di sicurezza per l'istanza consenta il traffico in entrata sulla porta 80.
+ Se Docker è in esecuzione in locale, accedi con il browser a [http://localhost/](http://localhost/).
+ Se lo utilizzi **docker-machine** su un computer Windows o Mac, trova l'indirizzo IP della macchina VirtualBox virtuale che ospita Docker con il **docker-machine ip** comando, sostituendolo *machine-name* con il nome della macchina docker che stai utilizzando.
```
docker-machine ip machine-name
```
Visualizzerai una pagina Web con il tuo contenuto "Hello World\$1" dichiarazione.
1. Interrompi il container Docker digitando **Ctrl\$1c**.
## Fase 2: Creare un repository
Ora che hai un'immagine da inviare ad Amazon ECR, devi creare un repository in cui memorizzarla. In questo esempio, viene creato un archivio denominato `hello-repository` in cui successivamente inviare l'immagine `hello-world:latest`. Per creare un repository, eseguire il comando seguente:
```
aws ecr create-repository \
--repository-name hello-repository \
--region region
```
## Fase 3: Effettua l'autenticazione nel registro predefinito
Dopo aver installato e configurato AWS CLI, autentica la CLI Docker nel registro predefinito. In questo modo, il comando **docker** può inviare ed estrarre le immagini con Amazon ECR. AWS CLI Fornisce un **get-login-password** comando per semplificare il processo di autenticazione.
Per autenticare Docker in un registro Amazon ECR con get-login-password, esegui il comando. **aws ecr get-login-password** Quando si passa il token di autenticazione al comando **docker login**, usare il valore `AWS` per il nome utente e specificare l'URI di registro Amazon ECR a cui si desidera autenticare. Se si esegue l'autenticazione a più registri, è necessario ripetere il comando per ogni registro di sistema.
**Importante**
Se viene visualizzato un errore, installare o eseguire l'upgrade alla versione più recente dell' AWS CLI. Per ulteriori informazioni, consulta [Installazione dell’ AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html) nella *Guida per l’utente dell’AWS Command Line Interface *.
+ [get-login-password](https://docs.aws.amazon.com/cli/latest/reference/ecr/get-login-password.html) (AWS CLI)
```
aws ecr get-login-password --region region | docker login --username AWS --password-stdin aws_account_id.dkr.ecr.region.amazonaws.com
```
+ Comando [Get () ECRLogin](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-ECRLoginCommand.html)AWS Tools for Windows PowerShell
```
(Get-ECRLoginCommand).Password | docker login --username AWS --password-stdin aws_account_id.dkr.ecr.region.amazonaws.com
```
## Fase 4: invio di un'immagine ad Amazon ECR
Ora puoi inviare la tua immagine al repository Amazon ECR creato nella sezione precedente. Utilizza la **docker** CLI per inviare immagini dopo aver soddisfatto i seguenti prerequisiti:
+ È installata la versione minima **docker** di: 1.7.
+ Il token di autorizzazione Amazon ECR è stato configurato con**docker login**.
+ Il repository Amazon ECR è stato creato e l'utente ha accesso per eseguire l'invio al repository stesso.
Dopo che tali prerequisiti sono stati soddisfatti, puoi inviare l'immagine al repository appena creato nel registro predefinito del tuo account.
**Per assegnare un tag a un'immagine e inviarla ad Amazon ECR**
1. Elencare le immagini memorizzate localmente per identificare l'immagine a cui aggiungere il tag e inviare.
```
docker images
```
Output:
```
REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE
hello-world latest e9ffedc8c286 4 minutes ago 241MB
```
1. Aggiungere un tag all'immagine da inviare al tuo repository.
```
docker tag hello-world:latest aws_account_id.dkr.ecr.region.amazonaws.com/hello-repository
```
1. Invia l'immagine.
```
docker push aws_account_id.dkr.ecr.region.amazonaws.com/hello-repository:latest
```
Output:
```
The push refers to a repository [aws_account_id.dkr.ecr.region.amazonaws.com/hello-repository] (len: 1)
e9ae3c220b23: Pushed
a6785352b25c: Pushed
0998bf8fb9e9: Pushed
0a85502c06c9: Pushed
latest: digest: sha256:215d7e4121b30157d8839e81c4e0912606fca105775bb0636EXAMPLE size: 6774
```
## Fase 5: estrazione di un'immagine da Amazon ECR
Dopo che l'immagine è stata inserita nel tuo repository Amazon ECR, puoi recuperarla da altre posizioni. Utilizza la **docker** CLI per estrarre le immagini dopo aver soddisfatto i seguenti prerequisiti:
+ È installata la versione minima **docker** di: 1.7.
+ Il token di autorizzazione Amazon ECR è stato configurato con**docker login**.
+ Il repository Amazon ECR è stato creato e l'utente ha accesso per eseguire l'estrazione dal repository stesso.
Dopo che tali prerequisiti sono stati soddisfatti, si può estrarre l'immagine. Per estrarre l'immagine di esempio da Amazon ECR, eseguire il comando seguente:
```
docker pull aws_account_id.dkr.ecr.region.amazonaws.com/hello-repository:latest
```
Output:
```
latest: Pulling from hello-repository
0a85502c06c9: Pull complete
0998bf8fb9e9: Pull complete
a6785352b25c: Pull complete
e9ae3c220b23: Pull complete
Digest: sha256:215d7e4121b30157d8839e81c4e0912606fca105775bb0636EXAMPLE
Status: Downloaded newer image for aws_account_id.dkr.region.amazonaws.com/hello-repository:latest
```
## Fase 6: eliminazione di un'immagine
Se non hai più bisogno di un'immagine in uno dei tuoi repository, puoi eliminarla. Per eliminare un'immagine, specifica il repository in cui si trova e un `imageDigest` valore `imageTag` or per l'immagine. L'esempio seguente elimina un'immagine dal `hello-repository` repository con il tag image. `latest` Per eliminare l'immagine di esempio dal repository, esegui il comando seguente:
```
aws ecr batch-delete-image \
--repository-name hello-repository \
--image-ids imageTag=latest \
--region region
```
## Fase 7: eliminazione di un repository
Se non è più necessario un intero archivio di immagini, è possibile eliminarlo. L'esempio seguente utilizza il `--force` flag per eliminare un archivio che contiene immagini. Per eliminare un repository che contiene immagini (e tutte le immagini in esso contenute), esegui il comando seguente:
```
aws ecr delete-repository \
--repository-name hello-repository \
--force \
--region region
```