

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Exemple « Publier une image Docker dans un référentiel d'images Amazon ECR » pour CodeBuild
<a name="sample-docker"></a>

Cet exemple produit une image Docker en tant que sortie de compilation, puis envoie l'image Docker vers un référentiel d'images Amazon Elastic Container Registry (Amazon ECR). Vous pouvez adapter cet exemple pour transférer l'image Docker vers Docker Hub. Pour de plus amples informations, veuillez consulter [Adaptez l'exemple « Publier une image Docker sur Amazon ECR » pour le transférer vers Docker Hub](sample-docker-docker-hub.md).

Pour savoir comment générer une image Docker à l'aide d'une image de génération Docker personnalisée (`docker:dind` dans Docker Hub), consultez notre [Exemple Docker dans une image personnalisée](sample-docker-custom-image.md).

Cet exemple a été testé en faisant référence à `golang:1.12`.

Cet exemple utilise la nouvelle fonction de générations Docker en plusieurs étapes, qui produit une image Docker comme sortie de génération. Il envoie ensuite l'image Docker vers un référentiel d'images Amazon ECR. Multi-stage Les builds d'images Docker aident à réduire la taille de l'image Docker finale. Pour plus d'informations, consultez [Use multi-stage builds with Docker](https://docs.docker.com/engine/userguide/eng-image/multistage-build/).

**Important**  
L'exécution de cet échantillon peut entraîner des frais sur votre AWS compte. Cela inclut les éventuels frais pour AWS CodeBuild et pour les AWS ressources et les actions liées à Amazon S3 AWS KMS, CloudWatch Logs et Amazon ECR. Pour plus d'informations, consultez [CodeBuild les rubriques Tarification](https://aws.amazon.com/codebuild/pricing), [Tarification Amazon S3](https://aws.amazon.com/s3/pricing), [AWS Key Management Service Tarification](https://aws.amazon.com/kms/pricing) [Amazon et CloudWatch Tarification](https://aws.amazon.com/cloudwatch/pricing) [Amazon Elastic Container Registry](https://aws.amazon.com/ecr/pricing).

**Topics**
+ [Exécutez l'exemple « Publier une image Docker sur Amazon ECR »](#sample-docker-running)
+ [Adaptez l'exemple « Publier une image Docker sur Amazon ECR » pour le transférer vers Docker Hub](sample-docker-docker-hub.md)

## Exécutez l'exemple « Publier une image Docker sur Amazon ECR »
<a name="sample-docker-running"></a>

Utilisez la procédure suivante pour exécuter l'exemple qui publie une image Docker sur Amazon ECR. Pour plus d'informations sur cet exemple, consultez. [Exemple « Publier une image Docker dans un référentiel d'images Amazon ECR » pour CodeBuild](#sample-docker)

**Pour exécuter cet exemple**

1. Si vous avez déjà un référentiel d'images dans Amazon ECR que vous souhaitez utiliser, passez à l'étape 3. Sinon, si vous utilisez un utilisateur au lieu d'un compte AWS root ou un utilisateur administrateur pour travailler avec Amazon ECR, ajoutez cette déclaration (entre {{\#\#\# BEGIN ADDING STATEMENT HERE \#\#\#}} et{{\#\#\# END ADDING STATEMENT HERE \#\#\#}}) à l'utilisateur (ou au groupe IAM auquel l'utilisateur est associé). L'utilisation d'un compte AWS root n'est pas recommandée. Cette déclaration permet la création de référentiels Amazon ECR pour le stockage d'images Docker. Des ellipses (`...`) sont utilisées par souci de concision et pour vous aider à déterminer l'endroit où ajouter l'instruction. Ne supprimez aucune instruction, et n'entrez pas ces ellipses dans la stratégie. Pour plus d'informations, consultez la section [Utilisation des politiques intégrées à l'aide du AWS Management Console](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_inline-using.html#AddingPermissions_Console) *guide de l'utilisateur*. 

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "ecr:CreateRepository"
               ],
               "Resource": "*"
           }
       ]
   }
   ```

------
**Note**  
L'entité IAM qui modifie cette politique doit être autorisée dans IAM à modifier les politiques.

1. Créez un référentiel d'images dans Amazon ECR. Assurez-vous de créer le référentiel dans la même AWS région que celle dans laquelle vous créez votre environnement de génération et exécutez votre build. Pour plus d'informations, consultez la section [Création d'un référentiel](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html) dans le *guide de l'utilisateur Amazon ECR.* Le nom de ce référentiel doit correspondre au nom du référentiel que vous spécifierez ultérieurement dans cette procédure, représenté par la variable d'environnement `IMAGE_REPO_NAME`. Assurez-vous que la politique de référentiel Amazon ECR accorde un accès push aux images pour votre rôle IAM CodeBuild de service. 

1. Ajoutez cette déclaration (entre {{\#\#\# BEGIN ADDING STATEMENT HERE \#\#\#}} et{{\#\#\# END ADDING STATEMENT HERE \#\#\#}}) à la politique que vous avez attachée à votre rôle AWS CodeBuild de service. Cette instruction permet de CodeBuild télécharger des images Docker dans les référentiels Amazon ECR. Des ellipses (`...`) sont utilisées par souci de concision et pour vous aider à déterminer l'endroit où ajouter l'instruction. Ne supprimez aucune instruction, et n'entrez pas ces ellipses dans la stratégie. 

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "ecr:BatchCheckLayerAvailability",
                   "ecr:CompleteLayerUpload",
                   "ecr:GetAuthorizationToken",
                   "ecr:InitiateLayerUpload",
                   "ecr:PutImage",
                   "ecr:UploadLayerPart"
               ],
               "Resource": "*"
           }
       ]
   }
   ```

------
**Note**  
L'entité IAM qui modifie cette politique doit être autorisée dans IAM à modifier les politiques.

1. Créez les fichiers comme décrit dans les [Fichiers](#sample-docker-files) sections [Structure de répertoire](#sample-docker-dir) et de cette rubrique, puis chargez-les dans un compartiment d'entrée S3 ou un AWS CodeCommit référentiel Bitbucket. GitHub Pour plus d'informations, reportez-vous à la section [Référence des fichiers de définitions d'images](https://docs.aws.amazon.com/codepipeline/latest/userguide/file-reference.html) dans le *Guide de AWS CodePipeline l'utilisateur*.
**Important**  
Ne chargez pas `{{(root directory name)}}`, mais seulement les fichiers à l'intérieur de `{{(root directory name)}}`.   
Si vous utilisez un compartiment d'entrée S3, veillez à créer un fichier ZIP contenant les fichiers, puis chargez ce fichier dans le compartiment d'entrée. N'ajoutez pas `{{(root directory name)}}` au fichier ZIP, mais seulement les fichiers à l'intérieur de `{{(root directory name)}}`.

1. Créez un projet de build, exécutez le build et consultez les informations de build.

    Si vous utilisez la console pour créer votre projet :

   1.  Pour **Système d'exploitation**, choisissez **Ubuntu**. 

   1.  Pour **Runtime (Exécution)**, sélectionnez **Standard**. 

   1.  Pour **Image**, choisissez **aws/codebuild/standard:5.0**. 

   1.  Ajoutez les variables d'environnement suivantes : 
      +  AWS\_DEFAULT\_REGION avec une valeur de {{region-ID}} 
      +  AWS\_ACCOUNT\_ID avec une valeur de {{account-ID}} 
      +  IMAGE\_TAG avec la valeur Latest 
      +  IMAGE\_REPO\_NAME avec une valeur de {{Amazon-ECR-repo-name}} 

   Si vous utilisez le AWS CLI pour créer le projet de construction, l' JSON-formatted entrée de la `create-project` commande peut ressembler à ceci. (Remplacez les espaces réservés par vos propres valeurs.)

   ```
   {
     "name": "sample-docker-project",
     "source": {
       "type": "S3",
       "location": "codebuild-{{region-ID}}-{{account-ID}}-input-bucket/{{DockerSample}}.zip"
     },
     "artifacts": {
       "type": "NO_ARTIFACTS"
     },
     "environment": {
       "type": "LINUX_CONTAINER",
       "image": "aws/codebuild/standard:5.0",
       "computeType": "BUILD_GENERAL1_SMALL",
       "environmentVariables": [
         {
           "name": "AWS_DEFAULT_REGION",
           "value": "{{region-ID}}"
         },
         {
           "name": "AWS_ACCOUNT_ID",
           "value": "{{account-ID}}"
         },
         {
           "name": "IMAGE_REPO_NAME",
           "value": "{{Amazon-ECR-repo-name}}"
         },
         {
           "name": "IMAGE_TAG",
           "value": "latest"
         }
       ],
     },
     "serviceRole": "arn:aws:iam::{{account-ID}}:role/{{role-name}}",
     "encryptionKey": "arn:aws:kms:{{region-ID}}:{{account-ID}}:key/{{key-ID}}"
   }
   ```

1. Confirmez que CodeBuild l'image Docker a bien été transférée vers le référentiel :

   1. Ouvrez la console Amazon ECR à [https://console.aws.amazon.com/ecr/](https://console.aws.amazon.com/ecr/)l'adresse.

   1. Choisissez le nom du référentiel. L'image doit apparaître dans la colonne **Balise d'image**.

### Structure de répertoire
<a name="sample-docker-dir"></a>

Cet exemple suppose que cette structure de répertoire est utilisée.

```
{{(root directory name)}}
├── buildspec.yml
└── Dockerfile
```

### Fichiers
<a name="sample-docker-files"></a>

Cet exemple utilise ces fichiers.

`buildspec.yml` (dans `{{(root directory name)}}`)

```
version: 0.2

phases:
  pre_build:
    commands:
      - echo Logging in to Amazon ECR...
      - aws ecr get-login-password --region $AWS_DEFAULT_REGION | docker login --username AWS --password-stdin $AWS_ACCOUNT_ID.dkr.ecr.$AWS_DEFAULT_REGION.amazonaws.com
  build:
    commands:
      - echo Build started on `date`
      - echo Building the Docker image...          
      - docker build -t $IMAGE_REPO_NAME:$IMAGE_TAG .
      - docker tag $IMAGE_REPO_NAME:$IMAGE_TAG $AWS_ACCOUNT_ID.dkr.ecr.$AWS_DEFAULT_REGION.amazonaws.com/$IMAGE_REPO_NAME:$IMAGE_TAG      
  post_build:
    commands:
      - echo Build completed on `date`
      - echo Pushing the Docker image...
      - docker push $AWS_ACCOUNT_ID.dkr.ecr.$AWS_DEFAULT_REGION.amazonaws.com/$IMAGE_REPO_NAME:$IMAGE_TAG
```

`Dockerfile` (dans `{{(root directory name)}}`)

```
FROM golang:1.12-alpine AS build
#Install git
RUN apk add --no-cache git
#Get the hello world package from a GitHub repository
RUN go get github.com/golang/example/hello
WORKDIR /go/src/github.com/golang/example/hello
# Build the project and send the output to /bin/HelloWorld 
RUN go build -o /bin/HelloWorld

FROM golang:1.12-alpine
#Copy the build's output binary from the previous build container
COPY --from=build /bin/HelloWorld /bin/HelloWorld
ENTRYPOINT ["/bin/HelloWorld"]
```

**Note**  
CodeBuild remplace le `ENTRYPOINT` pour les images Docker personnalisées.