

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. Les générations d'image Docker en plusieurs étapes contribuent à 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 *\$1\$1\$1 BEGIN ADDING STATEMENT HERE \$1\$1\$1* et*\$1\$1\$1 END ADDING STATEMENT HERE \$1\$1\$1*) à 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 *\$1\$1\$1 BEGIN ADDING STATEMENT HERE \$1\$1\$1* et*\$1\$1\$1 END ADDING STATEMENT HERE \$1\$1\$1*) à 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 visualisez 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\$1DEFAULT\$1REGION avec une valeur de *region-ID* 
      +  AWS\$1ACCOUNT\$1ID avec une valeur de *account-ID* 
      +  IMAGE\$1TAG avec la valeur Latest 
      +  IMAGE\$1REPO\$1NAME avec une valeur de *Amazon-ECR-repo-name* 

   Si vous utilisez le AWS CLI pour créer le projet de construction, l'entrée au format JSON 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.

# Adaptez l'exemple « Publier une image Docker sur Amazon ECR » pour le transférer vers Docker Hub
<a name="sample-docker-docker-hub"></a>

Pour adapter l'exemple « Publier une image Docker sur Amazon ECR » afin que l'image Docker soit envoyée vers Docker Hub plutôt que vers Amazon ECR, modifiez le code de l'exemple. Pour plus d'informations sur l'exemple, reportez-vous aux sections [Exemple « Publier une image Docker dans un référentiel d'images Amazon ECR » pour CodeBuild](sample-docker.md) et[Exécutez l'exemple « Publier une image Docker sur Amazon ECR »](sample-docker.md#sample-docker-running).
**Note**  
Si vous utilisez une version de Docker antérieure à 17.06, supprimez l'option `--no-include-email`.

1. Remplacez ces lignes de code spécifiques à Amazon ECR dans le `buildspec.yml` fichier :

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

   Par ces lignes de code spécifiques à Docker Hub :

   ```
   ...
     pre_build:
       commands:
         - echo Logging in to Docker Hub...
         # Type the command to log in to your Docker Hub account here.          
     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 $IMAGE_REPO_NAME:$IMAGE_TAG
     post_build:
       commands:
         - echo Build completed on `date`
         - echo Pushing the Docker image...
         - docker push $IMAGE_REPO_NAME:$IMAGE_TAG
   ...
   ```

1. Téléchargez le code modifié dans un compartiment d'entrée S3 ou un AWS CodeCommit référentiel Bitbucket. GitHub 
**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. Remplacez ces lignes de code de l'entrée au format JSON vers la commande `create-project` :

   ```
   ...
       "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"
         }
       ]
   ...
   ```

   Par ces lignes de code :

   ```
   ...
       "environmentVariables": [
         {
           "name": "IMAGE_REPO_NAME",
           "value": "your-Docker-Hub-repo-name"
         },
         {
           "name": "IMAGE_TAG",
           "value": "latest"
         }
       ]
   ...
   ```

1. Créez un environnement de génération, exécutez le build et consultez les informations de build associées.

1. Vérifiez que l'image Docker a AWS CodeBuild bien été transférée vers le référentiel. Connectez-vous à Docker Hub, accédez au référentiel et choisissez l'onglet **Tags**. La balise `latest` doit comporter une valeur **Last Updated** très récente.