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à.
# Invio di un'immagine a un repository privato Amazon ECR
Puoi inviare immagini Docker, elenchi manifesto e immagini Open Container Initiative (OCI) e artefatti compatibili ai tuoi repository privati.
Amazon ECR offre un modo per replicare le immagini su altri repository. Specificando una configurazione di replica nelle impostazioni del registro privato, puoi eseguire la replica tra regioni nel tuo registro e su diversi account. Per ulteriori informazioni, consulta [Impostazioni del registro privato in Amazon ECR](registry-settings.md).
**Nota**
Se si inserisce un'immagine attualmente archiviata, tale immagine verrà ripristinata e rimossa automaticamente dall'archivio. Per ulteriori informazioni sull'archiviazione e il ripristino delle immagini, vedere. [Archiviazione di un'immagine in Amazon ECR](archive_restore_image.md)
Quando il montaggio dei blob del registro è abilitato e i parametri di montaggio sono inclusi, Amazon ECR verifica automaticamente i livelli esistenti nel registro durante le operazioni push. Se un layer esiste già in un altro repository all'interno dello stesso registro, Amazon ECR monterà il layer esistente anziché caricarne un duplicato. Per ulteriori informazioni, consulta [Montaggio di blob in Amazon ECR](blob-mounting.md).
**Topics**
+ [Autorizzazioni IAM per il trasferimento di un'immagine a un repository privato Amazon ECR](image-push-iam.md)
+ [Trasferimento di un'immagine Docker a un repository privato Amazon ECR](docker-push-ecr-image.md)
+ [Trasferimento di un'immagine multiarchitettura a un repository privato Amazon ECR](docker-push-multi-architecture-image.md)
+ [Trasferimento di un grafico Helm a un repository privato Amazon ECR](push-oci-artifact.md)
# Autorizzazioni IAM per il trasferimento di un'immagine a un repository privato Amazon ECR
Gli utenti necessitano delle autorizzazioni IAM per inviare immagini agli archivi privati di Amazon ECR. Seguendo la migliore pratica di concessione del privilegio minimo, puoi concedere l'accesso a un repository specifico. È inoltre possibile concedere l'accesso a tutti i repository.
Un utente deve autenticarsi in ogni registro Amazon ECR a cui desidera inviare le immagini richiedendo un token di autorizzazione. Amazon ECR fornisce diverse policy AWS gestite per controllare l'accesso degli utenti a vari livelli. Per ulteriori informazioni, consulta [AWS politiche gestite per Amazon Elastic Container Registry](security-iam-awsmanpol.md).
Puoi anche creare politiche IAM personalizzate. La seguente policy IAM concede le autorizzazioni necessarie per inviare un'immagine a un repository specifico. Per limitare le autorizzazioni per un repository specifico, utilizza l'Amazon Resource Name (ARN) completo del repository.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ecr:CompleteLayerUpload",
"ecr:UploadLayerPart",
"ecr:InitiateLayerUpload",
"ecr:BatchCheckLayerAvailability",
"ecr:PutImage",
"ecr:BatchGetImage"
],
"Resource": "arn:aws:ecr:us-east-1:111122223333:repository/repository-name"
},
{
"Effect": "Allow",
"Action": "ecr:GetAuthorizationToken",
"Resource": "*"
}
]
}
```
------
La seguente policy IAM concede le autorizzazioni necessarie per inviare un'immagine a tutti i repository.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ecr:CompleteLayerUpload",
"ecr:GetAuthorizationToken",
"ecr:UploadLayerPart",
"ecr:InitiateLayerUpload",
"ecr:BatchCheckLayerAvailability",
"ecr:PutImage",
"ecr:BatchGetImage"
],
"Resource": "arn:aws:ecr:us-west-2:111122223333:repository/*"
}
]
}
```
# Trasferimento di un'immagine Docker a un repository privato Amazon ECR
Puoi inviare le immagini del container a un repository Amazon ECR con il comando **docker push**.
Amazon ECR supporta anche la creazione e l'invio di elenchi di manifest Docker utilizzati per immagini multiarchitettura. Per informazioni, consulta [Trasferimento di un'immagine multiarchitettura a un repository privato Amazon ECR](docker-push-multi-architecture-image.md).
**Per inviare un'immagine Docker a un repository Amazon ECR**
Il repository Amazon ECR deve esistere prima di inviare l'immagine oppure è necessario che sia stato definito un modello di creazione del repository. Per ulteriori informazioni, consultare [Creazione di un repository privato Amazon ECR per archiviare immagini](repository-create.md) e [Modelli per controllare i repository creati durante un pull through cache, la creazione in modalità push o un'azione di replica](repository-creation-templates.md).
1. Autentica il tuo client Docker nel registro Amazon ECR al quale desideri inviare l'immagine. Devi ottenere i token di autenticazione per ciascun registro utilizzato. I token hanno una validità di 12 ore. Per ulteriori informazioni, consulta [Autenticazione del registro privato in Amazon ECR](registry_auth.md).
Per autenticare Docker in un registro Amazon ECR, 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 *.
```
aws ecr get-login-password --region | docker login --username AWS --password-stdin .dkr.ecr..amazonaws.com
```
1. Se il tuo repository di immagini non è ancora presente nel registro che intendi visitare e hai definito un modello per la creazione del repository, puoi inviare l'immagine utilizzando il prefisso del modello di creazione del repository e il nome del repository desiderato. ECR creerà automaticamente il repository per te utilizzando le impostazioni predefinite del modello di creazione del repository.
Se non hai definito un modello di creazione del repository corrispondente, dovrai creare un repository. Per ulteriori informazioni, consulta [Modelli per controllare i repository creati durante un pull through cache, la creazione in modalità push o un'azione di replica](repository-creation-templates.md) o [Creazione di un repository privato Amazon ECR per archiviare immagini](repository-create.md).
1. Identifica l'immagine locale da inviare. Esegui il comando **docker images** per elencare le immagini container nel tuo sistema.
```
docker images
```
È possibile identificare un'immagine con il *repository:tag* valore o l'ID dell'immagine nell'output del comando risultante.
1. Assegna un tag alla tua immagine con la combinazione di registro, repository, e nome tag immagine opzionale Amazon ECR da utilizzare. Il formato del registro è `aws_account_id.dkr.ecr.region.amazonaws.com`. Il nome del repository deve corrispondere a quello del repository che hai creato per la tua immagine. Se ometti il tag dell'immagine, presupponiamo che sia `latest`.
L'esempio seguente contrassegna un'immagine locale con l'ID * e9ae3c220b23* come`aws_account_id.dkr.ecr.region.amazonaws.com/my-repository:tag`.
```
docker tag e9ae3c220b23 aws_account_id.dkr.ecr.region.amazonaws.com/my-repository:tag
```
1. Invia l'immagine con il comando **docker push**:
```
docker push aws_account_id.dkr.ecr.region.amazonaws.com/my-repository:tag
```
1. (Opzionale) Assegna eventuali tag aggiuntivi alla tua immagine e invia questi tag ad Amazon ECR ripetendo [Step 4](#image-tag-step) e [Step 5](#image-push-step).
# Trasferimento di un'immagine multiarchitettura a un repository privato Amazon ECR
Puoi inviare immagini multiarchitettura a un repository Amazon ECR creando e inviando elenchi di manifest Docker. Un *elenco manifesto* è un elenco di immagini che viene creato specificando uno o più nomi di immagini. Nella maggior parte dei casi, l'elenco dei manifesti viene creato a partire da immagini che svolgono la stessa funzione ma sono per sistemi operativi o architetture diversi. L'elenco manifesto non è obbligatorio. Per ulteriori informazioni, consulta [Docker manifest](https://docs.docker.com/engine/reference/commandline/manifest/).
Un elenco manifesto può essere estratto o è possibile farvi riferimento in una definizione di attività Amazon ECS o specifiche del pod Amazon EKS come altre immagini Amazon ECR.
**Prerequisiti**
+ Nella CLI Docker, attiva le funzionalità sperimentali. Per informazioni sulle funzionalità sperimentali, consulta [Funzionalità sperimentali](https://docs.docker.com/engine/reference/commandline/cli/#experimental-features) nella documentazione Docker.
+ Il repository Amazon ECR deve esistere prima di eseguire l'invio dell'immagine. Per ulteriori informazioni, consulta [Creazione di un repository privato Amazon ECR per archiviare immagini](repository-create.md).
+ Le immagini devono essere inviate al tuo repository prima di creare il manifesto Docker. Per informazioni su come inviare un'immagine, consulta [Trasferimento di un'immagine Docker a un repository privato Amazon ECR](docker-push-ecr-image.md).
**Per eseguire l'invio di un'immagine Docker multi-architettura in un repository Amazon ECR**
1. Autentica il tuo client Docker nel registro Amazon ECR al quale desideri inviare l'immagine. Devi ottenere i token di autenticazione per ciascun registro utilizzato. I token hanno una validità di 12 ore. Per ulteriori informazioni, consulta [Autenticazione del registro privato in Amazon ECR](registry_auth.md).
Per autenticare Docker in un registro Amazon ECR, 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 *.
```
aws ecr get-login-password --region | docker login --username AWS --password-stdin .dkr.ecr..amazonaws.com
```
1. Elenca le immagini nel tuo repository, confermando i tag immagine.
```
aws ecr describe-images --repository-name my-repository
```
1. Crea l'elenco manifesto Docker. Il comando `manifest create` verifica che le immagini di riferimento siano già presenti nel repository e crea il manifest localmente.
```
docker manifest create aws_account_id.dkr.ecr.region.amazonaws.com/my-repository aws_account_id.dkr.ecr.region.amazonaws.com/my-repository:image_one_tag aws_account_id.dkr.ecr.region.amazonaws.com/my-repository:image_two
```
1. (Facoltativo) Ispezionare l'elenco dei manifest Docker. Ciò consente di confermare le dimensioni e il digest per ogni manifest immagine a cui si fa riferimento nell'elenco dei manifest.
```
docker manifest inspect aws_account_id.dkr.ecr.region.amazonaws.com/my-repository
```
1. Eseguire l'invio dell'elenco manifesto Docker nel repository Amazon ECR.
```
docker manifest push aws_account_id.dkr.ecr.region.amazonaws.com/my-repository
```
# Trasferimento di un grafico Helm a un repository privato Amazon ECR
Puoi inviare gli artefatti dell'Open Container Initiative (OCI) a un repository Amazon ECR. Per vedere un esempio di questa funzionalità, utilizza i seguenti passaggi per inviare un grafico Helm ad Amazon ECR.
Per informazioni sull'utilizzo dei grafici Helm ospitati da Amazon ECR con Amazon EKS, consulta. [Installazione di un grafico Helm su un cluster Amazon EKS](using-helm-charts-eks.md)
**Per inviare un grafico Helm a un repository Amazon ECR**
1. Installa la versione più recente del client Helm. Questi passaggi sono stati scritti utilizzando la versione `3.18.6` di Helm. Per la compatibilità con le versioni di Kubernetes supportate da Amazon EKS, usa Helm versione 3.9 o successiva. Per ulteriori informazioni, consulta l'argomento relativo all'[installazione di Helm](https://helm.sh/docs/intro/install/).
1. Utilizza i seguenti passaggi per creare un grafico Helm di prova. Per ulteriori informazioni, consulta [Documenti Helm - Nozioni di base](https://helm.sh/docs/chart_template_guide/getting_started/).
1. Creare un grafico Helm denominato `helm-test-chart` e cancellare il contenuto della directory `templates`.
```
helm create helm-test-chart
rm -rf ./helm-test-chart/templates/*
```
1. Crea un file nella cartella. `ConfigMap` `templates`
```
cd helm-test-chart/templates
cat < configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: helm-test-chart-configmap
data:
myvalue: "Hello World"
EOF
```
1. Creazione pacchetto del grafico. L'output conterrà il nome del file del grafico in pacchetto utilizzato quando si invia il grafico Helm.
```
cd ../..
helm package helm-test-chart
```
Output
```
Successfully packaged chart and saved it to: /Users/username/helm-test-chart-0.1.0.tgz
```
1. Creare un repository per archiviare il grafico Helm. Il nome del repository deve corrispondere al nome utilizzato nel grafico Helm al passaggio 2. Per ulteriori informazioni, consulta [Creazione di un repository privato Amazon ECR per archiviare immagini](repository-create.md).
```
aws ecr create-repository \
--repository-name helm-test-chart \
--region us-west-2
```
1. Autentica il tuo client Helm nel registro Amazon ECR al quale desideri inviare il grafico Helm. Devi ottenere i token di autenticazione per ciascun registro utilizzato. I token hanno una validità di 12 ore. Per ulteriori informazioni, consulta [Autenticazione del registro privato in Amazon ECR](registry_auth.md).
```
aws ecr get-login-password \
--region us-west-2 | helm registry login \
--username AWS \
--password-stdin aws_account_id.dkr.ecr.region.amazonaws.com
```
1. Inviare il grafico Helm utilizzando il comando **helm push**. L'output deve includere l'URI del repository Amazon ECR e il digest SHA.
```
helm push helm-test-chart-0.1.0.tgz oci://aws_account_id.dkr.ecr.region.amazonaws.com/
```
1. Descrivi il tuo grafico Helm.
```
aws ecr describe-images \
--repository-name helm-test-chart \
--region us-west-2
```
Nell'output, verificare che il parametri `artifactMediaType` indichi il tipo di artefatto corretto.
```
{
"imageDetails": [
{
"registryId": "aws_account_id",
"repositoryName": "helm-test-chart",
"imageDigest": "sha256:dd8aebdda7df991a0ffe0b3d6c0cf315fd582cd26f9755a347a52adEXAMPLE",
"imageTags": [
"0.1.0"
],
"imageSizeInBytes": 1620,
"imagePushedAt": "2021-09-23T11:39:30-05:00",
"imageManifestMediaType": "application/vnd.oci.image.manifest.v1+json",
"artifactMediaType": "application/vnd.cncf.helm.config.v1+json"
}
]
}
```
1. (Facoltativo) Per ulteriori passaggi, installa Helm `ConfigMap` e inizia a usare Amazon EKS. Per ulteriori informazioni, consulta [Installazione di un grafico Helm su un cluster Amazon EKS](using-helm-charts-eks.md).