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à.
# Configurare istanze di container Amazon ECS per immagini Docker private
L'agente di container di Amazon ECS è in grado di eseguire l'autenticazione con registri privati utilizzando l'autenticazione di base. Quando si abilita l'autenticazione dei registri privati, puoi utilizzare le immagini Docker private nelle tue definizioni di attività. Questa funzionalità è supportata solo dalle attività che utilizzano EC2.
Un altro metodo per abilitare l'autenticazione del registro privato consiste nell' Gestione dei segreti AWS archiviare le credenziali del registro privato in modo sicuro e quindi farvi riferimento nella definizione del contenitore. In questo modo le attività possono utilizzare immagini da repository privati. Questo metodo supporta le attività utilizzando EC2 o Fargate. Per ulteriori informazioni, consulta [Utilizzo di immagini non AWS containerizzate in Amazon ECS](private-auth.md).
L'agente del container di Amazon ECS all'avvio ricerca due variabili di ambiente:
+ `ECS_ENGINE_AUTH_TYPE`, che specifica il tipo di dati di autenticazione inviati.
+ `ECS_ENGINE_AUTH_DATA`, che contiene le credenziali di autenticazione effettive.
Le varianti Linux dell'AMI ottimizzata per Amazon ECS analizzano il `/etc/ecs/ecs.config` file alla ricerca di queste variabili all'avvio dell'istanza del contenitore e ogni volta che il servizio viene avviato (con il **sudo start ecs** comando). AMIs che non sono ottimizzate per Amazon ECS devono archiviare queste variabili di ambiente in un file e passarle con l'`--env-file path_to_env_file`opzione al **docker run** comando che avvia l'agente contenitore.
**Importante**
Consigliamo di non inserire queste variabili di ambiente di autenticazione al momento dell'avvio dell'istanza con i dati utente di Amazon EC2 o di trasferirle con l'opzione `--env` al comando **docker run**. Questi metodi non sono ideali per i dati sensibili, come le credenziali di autenticazione. Per informazioni sull'aggiunta sicura delle credenziali di autenticazione alle istanze di container, consulta [Archiviazione della configurazione di un'istanza di container Amazon ECS in Amazon S3](ecs-config-s3.md).
## Formati di autenticazione
Sono disponibili due formati per l'autenticazione di registri privati, `dockercfg` e `docker`.
**Formato di autenticazione dockercfg**
Il formato `dockercfg` utilizza le informazioni di autenticazione archiviate nel file di configurazione che viene creato quando esegui il comando **docker login**. Puoi creare questo file eseguendo il comando **docker login** sul sistema locale e inserendo il nome utente, la password e l'indirizzo e-mail del registro. Puoi inoltre effettuare l'accesso a un'istanza di container ed eseguire il comando qui. A seconda della tua versione Docker, questo file viene salvato come `~/.dockercfg` o `~/.docker/config.json`.
```
cat ~/.docker/config.json
```
Output:
```
{
"auths": {
"https://index.docker.io/v1/": {
"auth": "zq212MzEXAMPLE7o6T25Dk0i"
}
}
}
```
**Importante**
Le nuove versioni di Docker creano un file di configurazione come mostrato in precedenza con un oggetto `auths` esterno. L'agente Amazon ECS supporta solo i dati di autenticazione `dockercfg` nel formato seguente senza l'oggetto `auths`. Se è installata l'utility **jq**, puoi estrarre questi dati con il seguente comando: **cat \$1/.docker/config.json \$1 jq .auths**
```
cat ~/.docker/config.json | jq .auths
```
Output:
```
{
"https://index.docker.io/v1/": {
"auth": "zq212MzEXAMPLE7o6T25Dk0i",
"email": "email@example.com"
}
}
```
Nell'esempio precedente, è necessario aggiungere le seguenti variabili di ambiente al file delle variabili di ambiente (`/etc/ecs/ecs.config` per l'AMI ottimizzata per Amazon ECS) che l'agente del container di Amazon ECS carica in fase di runtime. Se non stai utilizzando l'AMI ottimizzata per Amazon ECS e stai avviando l'agente manualmente con **docker run**, specifica il file delle variabili d'ambiente con l'opzione `--env-file path_to_env_file` all'avvio dell'agente.
```
ECS_ENGINE_AUTH_TYPE=dockercfg
ECS_ENGINE_AUTH_DATA={"https://index.docker.io/v1/":{"auth":"zq212MzEXAMPLE7o6T25Dk0i","email":"email@example.com"}}
```
Puoi configurare più registri privati con la seguente sintassi:
```
ECS_ENGINE_AUTH_TYPE=dockercfg
ECS_ENGINE_AUTH_DATA={"repo.example-01.com":{"auth":"zq212MzEXAMPLE7o6T25Dk0i","email":"email@example-01.com"},"repo.example-02.com":{"auth":"fQ172MzEXAMPLEoF7225DU0j","email":"email@example-02.com"}}
```
**Formato di autenticazione docker**
Il formato `docker` utilizza una rappresentazione JSON del server di registro con il quale l'agente deve eseguire l'autenticazione. Include anche i parametri di autenticazione richiesti da tale registro (ad esempio il nome utente, la password e l'indirizzo e-mail per l'account). Per un account Docker Hub, la rappresentazione JSON sarà simile a quanto segue:
```
{
"https://index.docker.io/v1/": {
"username": "my_name",
"password": "my_password",
"email": "email@example.com"
}
}
```
In questo esempio, è necessario aggiungere le seguenti variabili di ambiente al file delle variabili di ambiente (`/etc/ecs/ecs.config` per l'AMI ottimizzata per Amazon ECS) che l'agente del container di Amazon ECS carica in fase di runtime. Se non stai utilizzando l'AMI ottimizzata per Amazon ECS e stai avviando l'agente manualmente con il comando **docker run**, quando avvii l'agente specifica il file delle variabili d'ambiente con l'opzione `--env-file path_to_env_file`.
```
ECS_ENGINE_AUTH_TYPE=docker
ECS_ENGINE_AUTH_DATA={"https://index.docker.io/v1/":{"username":"my_name","password":"my_password","email":"email@example.com"}}
```
Puoi configurare più registri privati con la seguente sintassi:
```
ECS_ENGINE_AUTH_TYPE=docker
ECS_ENGINE_AUTH_DATA={"repo.example-01.com":{"username":"my_name","password":"my_password","email":"email@example-01.com"},"repo.example-02.com":{"username":"another_name","password":"another_password","email":"email@example-02.com"}}
```
## Procedura
Utilizza la procedura seguente per attivare i registri privati per le istanze di container.
**Come abilitare i registri privati nell'AMI ottimizzata per Amazon ECS**
1. Accedi alla tua istanza di container con SSH.
1. Apri il file `/etc/ecs/ecs.config` e aggiungi i valori `ECS_ENGINE_AUTH_TYPE` ed `ECS_ENGINE_AUTH_DATA` per il registro e l'account:
```
sudo vi /etc/ecs/ecs.config
```
In questo esempio si esegue l'autenticazione di un account utente Docker Hub:
```
ECS_ENGINE_AUTH_TYPE=docker
ECS_ENGINE_AUTH_DATA={"https://index.docker.io/v1/":{"username":"my_name","password":"my_password","email":"email@example.com"}}
```
1. Controlla se il tuo agente utilizza la variabile di ambiente `ECS_DATADIR` per salvarne lo stato:
```
docker inspect ecs-agent | grep ECS_DATADIR
```
Output:
```
"ECS_DATADIR=/data",
```
**Importante**
Se il comando precedente non restituisce la variabile di ambiente `ECS_DATADIR`, è necessario arrestare qualsiasi attività in esecuzione in questa istanza di container prima di arrestare l'agente. Gli agenti più nuovi con la variabile di ambiente `ECS_DATADIR` salvano il proprio stato e puoi arrestarli e avviarli mentre le attività vengono eseguite senza problemi. Per ulteriori informazioni, consulta [Aggiornamento dell'agente del container Amazon ECS](ecs-agent-update.md).
1. Arresta il servizio `ecs`:
```
sudo stop ecs
```
Output:
```
ecs stop/waiting
```
1. Riavvia il servizio `ecs`.
+ Per l'AMI Amazon Linux 2 ottimizzata per Amazon ECS:
```
sudo systemctl restart ecs
```
+ Per l'AMI Amazon Linux ottimizzata per Amazon ECS:
```
sudo stop ecs && sudo start ecs
```
1. (Facoltativo) Puoi verificare se l'agente è in esecuzione e visualizzare alcune informazioni sulla nuova istanza di container interrogando l'operazione API di introspezione dell'agente. Per ulteriori informazioni, consulta [Introspezione del container di Amazon ECS](ecs-agent-introspection.md).
```
curl http://localhost:51678/v1/metadata
```