

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.

# Tutoriel : Création d'un pipeline avec une source Amazon ECR et déploiement ECS-to-CodeDeploy
<a name="tutorials-ecs-ecr-codedeploy"></a>

Dans ce didacticiel, vous allez configurer un pipeline AWS CodePipeline qui déploie des applications de conteneur à l'aide d'un blue/green déploiement prenant en charge les images Docker. Dans un déploiement bleu/vert, vous pouvez lancer la nouvelle version de votre application avec l'ancienne version, et tester la nouvelle version avant de rediriger le trafic. Vous pouvez également surveiller le processus de déploiement et revenir rapidement en arrière en cas de problème.

**Important**  
Dans le cadre de la création d'un pipeline, un compartiment d'artefacts S3 fourni par le client sera utilisé CodePipeline pour les artefacts. (Ceci est différent du compartiment utilisé pour une action source S3.) Si le compartiment d'artefacts S3 se trouve dans un compte différent de celui de votre pipeline, assurez-vous que le compartiment d'artefacts S3 appartient à cette personne sûre et Comptes AWS qu'elle sera fiable.

**Note**  
Ce didacticiel est destiné à l'action de déploiement d'Amazon ECS vers le CodeDeploy bleu/vert pour. CodePipeline Pour un didacticiel utilisant l'action de déploiement standard d'Amazon ECS dans CodePipeline, consultez[Tutoriel : Déploiement standard d'Amazon ECS avec CodePipeline](ecs-cd-pipeline.md).

Le pipeline terminé détecte les modifications apportées à votre image, qui est stockée dans un référentiel d'images tel qu'Amazon ECR, et utilisée CodeDeploy pour acheminer et déployer le trafic vers un cluster Amazon ECS et un équilibreur de charge. CodeDeploy utilise un écouteur pour rediriger le trafic vers le port du conteneur mis à jour spécifié dans le AppSpec fichier. Pour plus d'informations sur la manière dont l'équilibreur de charge, l'écouteur de production, les groupes cibles et votre application Amazon ECS sont utilisés dans le cadre d'un blue/green déploiement, consultez [Tutoriel : Déployer un service Amazon ECS](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorial-ecs-deployment.html).

Le pipeline est également configuré pour utiliser un emplacement source CodeCommit, tel que l'endroit où votre définition de tâche Amazon ECS est stockée. Dans ce didacticiel, vous allez configurer chacune de ces AWS ressources, puis créer votre pipeline avec des étapes contenant des actions pour chaque ressource.

Votre pipeline de livraison continue créera et déploiera automatiquement des images de conteneur chaque fois que le code source est modifié ou qu'une nouvelle image de base est téléchargée sur Amazon ECR.

Ce flux utilise les artefacts suivants :
+ Un fichier image Docker qui spécifie le nom du conteneur et l'URI du référentiel de votre référentiel d'images Amazon ECR.
+ Définition de tâche Amazon ECS répertoriant le nom de votre image Docker, le nom du conteneur, le nom du service Amazon ECS et la configuration de votre équilibreur de charge.
+  CodeDeploy AppSpec Fichier qui spécifie le nom du fichier de définition de tâche Amazon ECS, le nom du conteneur de l'application mise à jour et le port du conteneur où le trafic de production est CodeDeploy redirigé. Il peut également spécifier la configuration du réseau et les fonctions Lambda facultatifs que vous pouvez exécuter durant les hooks d'événement de cycle de vie de déploiement.

**Note**  
Lorsque vous validez une modification dans votre référentiel d'images Amazon ECR, l'action de la source du pipeline crée un `imageDetail.json` fichier pour cette validation. Pour de plus amples informations concernant le fichier `imageDetail.json`, veuillez consulter [Fichier ImageDetail.json pour les actions de déploiement d'Amazon ECS blue/green](file-reference.md#file-reference-ecs-bluegreen).

Lorsque vous créez ou modifiez votre pipeline et mettez à jour ou spécifiez des artefacts source pour votre étape de déploiement, assurez-vous pour qu'il pointe vers la source des artefacts avec le nom et la version les plus récents que vous souhaitez utiliser. Une fois que vous avez configuré votre pipeline, au fur et à mesure que vous apportez des modifications à votre image ou à une définition de tâche, il se peut que vous ayez besoin de mettre à jour vos fichiers d'artefact source dans vos référentiels, puis de modifier l'étape de déploiement dans votre pipeline.

**Topics**
+ [Conditions préalables](#tutorials-ecs-ecr-codedeploy-prereq)
+ [Étape 1 : créer une image et la transférer vers un référentiel Amazon ECR](#tutorials-ecs-ecr-codedeploy-imagerepository)
+ [Étape 2 : Création de fichiers AppSpec source et de définition de tâches, puis transfert vers un CodeCommit référentiel](#tutorials-ecs-ecr-codedeploy-taskdefinition)
+ [Étape 3 : Créer votre équilibreur de charge d'application et vos groupes cibles](#tutorials-ecs-ecr-codedeploy-loadbal)
+ [Étape 4 : créer votre cluster et votre service Amazon ECS](#tutorials-ecs-ecr-codedeploy-cluster)
+ [Étape 5 : Création de votre CodeDeploy application et de votre groupe de déploiement (plateforme de calcul ECS)](#tutorials-ecs-ecr-codedeploy-deployment)
+ [Étape 6 : Créer le pipeline](#tutorials-ecs-ecr-codedeploy-pipeline)
+ [Étape 7 : Modifier le pipeline et vérifier le déploiement](#tutorials-ecs-ecr-codedeploy-update)

## Conditions préalables
<a name="tutorials-ecs-ecr-codedeploy-prereq"></a>

Vous devez avoir déjà créé les ressources suivantes :
+ Un CodeCommit référentiel. Vous pouvez utiliser le AWS CodeCommit référentiel dans lequel vous l'avez créé[Tutoriel : Création d'un pipeline simple (CodeCommit référentiel)](tutorials-simple-codecommit.md).
+ Lancez une instance Linux Amazon EC2 et installez Docker pour créer une image, comme indiqué dans ce didacticiel. Si vous avez déjà une image que vous souhaitez utiliser, vous pouvez ignorer cette condition préalable.

## Étape 1 : créer une image et la transférer vers un référentiel Amazon ECR
<a name="tutorials-ecs-ecr-codedeploy-imagerepository"></a>

Dans cette section, vous utilisez Docker pour créer une image, puis vous l'utilisez AWS CLI pour créer un référentiel Amazon ECR et transférer l'image vers le référentiel.

**Note**  
Si vous avez déjà une image que vous souhaitez utiliser, vous pouvez ignorer cette étape.

**Pour créer une image**

1. Connectez-vous à votre instance Linux dans laquelle Docker est installé.

   Retirez une image pour `nginx`. Cette commande fournit l'`nginx:latest`image :

   ```
   docker pull nginx
   ```

1. Exécutez **docker images**. Vous devez voir l'image dans la liste.

   ```
   docker images
   ```

**Pour créer un référentiel Amazon ECR et publier votre image**

1. Créez un référentiel Amazon ECR pour stocker votre image . Notez l'`repositoryUri` dans la sortie.

   ```
   aws ecr create-repository --repository-name nginx
   ```

   Sortie :

   ```
   {
       "repository": {
           "registryId": "aws_account_id",
           "repositoryName": "nginx",
           "repositoryArn": "arn:aws:ecr:us-east-1:aws_account_id:repository/nginx",
           "createdAt": 1505337806.0,
           "repositoryUri": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/nginx"
       }
   }
   ```

1. Balisez l'image avec la valeur `repositoryUri` de l'étape précédente.

   ```
   docker tag nginx:latest aws_account_id.dkr.ecr.us-east-1.amazonaws.com/nginx:latest
   ```

1. Exécutez la **aws ecr get-login-password** commande, comme indiqué dans cet exemple pour la `us-west-2` région et l'ID de compte 111122223333.

   ```
   aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com/nginx
   ```

1. Transférez l'image vers Amazon ECR à l'aide `repositoryUri` de l'étape précédente.

   ```
   docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/nginx:latest
   ```

## Étape 2 : Création de fichiers AppSpec source et de définition de tâches, puis transfert vers un CodeCommit référentiel
<a name="tutorials-ecs-ecr-codedeploy-taskdefinition"></a>

Dans cette section, vous allez créer un fichier JSON de définition de tâche et l'enregistrer auprès d'Amazon ECS. Vous créez ensuite un AppSpec fichier pour votre client Git CodeDeploy et vous l'utilisez pour transférer les fichiers vers votre CodeCommit dépôt.

**Pour créer une définition de tâche pour votre image**

1. Créez un fichier nommé `taskdef.json` avec les contenus suivants. Pour `image`, saisissez votre nom d'image, par exemple nginx. Cette valeur est mise à jour lorsque votre pipeline est exécuté.
**Note**  
Assurez-vous que le rôle d'exécution spécifié dans la définition de tâche contient la stratégie `AmazonECSTaskExecutionRolePolicy`. Pour plus d'informations, consultez [Amazon ECS Task Execution IAM Role](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html) dans le *manuel du développeur Amazon ECS*.

   ```
   {
       "executionRoleArn": "arn:aws:iam::account_ID:role/ecsTaskExecutionRole",
       "containerDefinitions": [
           {
               "name": "sample-website",
               "image": "nginx",
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512",
       "family": "ecs-demo"
   }
   ```

1. Enregistrez votre définition de tâche dans le fichier `taskdef.json`.

   ```
   aws ecs register-task-definition --cli-input-json file://taskdef.json
   ```

1. Une fois la définition de tâche enregistrée, modifiez votre fichier afin de supprimer le nom et d'inclure le texte d'espace réservé `<IMAGE1_NAME>` dans le champ de l'image.

   ```
   {
       "executionRoleArn": "arn:aws:iam::account_ID:role/ecsTaskExecutionRole",
       "containerDefinitions": [
           {
               "name": "sample-website",
               "image": "<IMAGE1_NAME>",
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512",
       "family": "ecs-demo"
   }
   ```

**Pour créer un AppSpec fichier**
+ Le AppSpec fichier est utilisé pour les CodeDeploy déploiements. Le fichier, qui inclut des champs facultatifs, utilise ce format :

  ```
  version: 0.0
  Resources:
    - TargetService:
        Type: AWS::ECS::Service
        Properties:
          TaskDefinition: "task-definition-ARN"
          LoadBalancerInfo:
            ContainerName: "container-name"
            ContainerPort: container-port-number
  # Optional properties
          PlatformVersion: "LATEST"
          NetworkConfiguration:
              AwsvpcConfiguration:
                Subnets: ["subnet-name-1", "subnet-name-2"]
                SecurityGroups: ["security-group"]
                AssignPublicIp: "ENABLED"
  Hooks:
  - BeforeInstall: "BeforeInstallHookFunctionName"
  - AfterInstall: "AfterInstallHookFunctionName"
  - AfterAllowTestTraffic: "AfterAllowTestTrafficHookFunctionName"
  - BeforeAllowTraffic: "BeforeAllowTrafficHookFunctionName"
  - AfterAllowTraffic: "AfterAllowTrafficHookFunctionName"
  ```

  Pour plus d'informations sur le AppSpec fichier, y compris des exemples, consultez la section [Référence CodeDeploy AppSpec du fichier](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html).

  Créez un fichier nommé `appspec.yaml` avec les contenus suivants. Pour `TaskDefinition`, ne modifiez pas le texte d'espace réservé `<TASK_DEFINITION>`. Cette valeur est mise à jour lorsque votre pipeline est exécuté.

  ```
  version: 0.0
  Resources:
    - TargetService:
        Type: AWS::ECS::Service
        Properties:
          TaskDefinition: <TASK_DEFINITION>
          LoadBalancerInfo:
            ContainerName: "sample-website"
            ContainerPort: 80
  ```

**Pour transférer des fichiers vers votre CodeCommit dépôt**

1. Envoyez ou téléchargez les fichiers dans votre CodeCommit dépôt. Ces fichiers constituent l'artefact source créé par l'assistant **Create Pipeline (Création de pipeline)** pour votre action de déploiement dans CodePipeline. Vos fichiers doivent être similaires à ce qui suit dans votre répertoire local :

   ```
   /tmp
     |my-demo-repo
       |-- appspec.yaml
       |-- taskdef.json
   ```

1. Choisissez la méthode que vous souhaitez utiliser pour charger vos fichiers :

   1. Pour utiliser la ligne de commande Git à partir d'un référentiel cloné sur votre ordinateur local :

      1. Modifiez les répertoires vers votre référentiel local :

         ```
         (For Linux, macOS, or Unix) cd /tmp/my-demo-repo
         (For Windows) cd c:\temp\my-demo-repo
         ```

      1. Exécutez la commande suivante pour organiser tous vos fichiers à la fois :

         ```
         git add -A
         ```

      1. Exécutez la commande suivante pour valider les fichiers avec un message de validation :

         ```
         git commit -m "Added task definition files"
         ```

      1. Exécutez la commande suivante pour transférer les fichiers de votre dépôt local vers votre CodeCommit dépôt :

         ```
         git push
         ```

   1. Pour télécharger vos fichiers à l' CodeCommit aide de la console, procédez comme suit :

      1. Ouvrez la CodeCommit console et choisissez votre dépôt dans la liste des **référentiels**.

      1. Choisissez **Ajouter un fichier**, puis choisissez **Charger le fichier**.

      1. Sélectionnez **Choisir un fichier**, puis recherchez votre fichier. Validez la modification en entrant votre nom d'utilisateur et votre adresse e-mail. Choisissez **Valider les modifications**.

      1. Répétez cette étape pour chaque fichier que vous souhaitez charger.

## Étape 3 : Créer votre équilibreur de charge d'application et vos groupes cibles
<a name="tutorials-ecs-ecr-codedeploy-loadbal"></a>

Dans cette section, vous allez créer un Amazon EC2 Application Load Balancer. Vous utiliserez les noms de sous-réseaux et les valeurs de groupe cible que vous créerez avec votre équilibreur de charge ultérieurement, lorsque vous créerez votre service Amazon ECS. Vous pouvez créer un équilibreur de charge d'application ou un Network Load Balancer. L'équilibreur de charge doit utiliser un VPC avec deux sous-réseaux publics dans différentes zones de disponibilité. Au cours de ces étapes, vous devez confirmer votre VPC par défaut, créer un équilibreur de charge, puis créer deux groupes cible pour votre équilibreur de charge. Pour plus d'informations, consultez [Groupes cibles pour vos équilibreurs de charge du réseau](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-target-groups.html).

**Pour vérifier votre VPC par défaut et les sous-réseaux publics**

1. Connectez-vous à la console Amazon VPC AWS Management Console et ouvrez-la à l'adresse. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)

1. Vérifiez le VPC par défaut à utiliser. Dans le volet de navigation, sélectionnez **Votre VPCs**. Notez que le VPC affiche **Oui** dans la colonne **VPC par défaut**. Il s'agit du VPC par défaut. Il contient des sous-réseaux par défaut que vous pouvez sélectionner.

1. Choisissez **Sous-réseaux**. Choisissez deux sous-réseaux qui contiennent **Oui** dans la colonne **Sous-réseau par défaut**.
**Note**  
Prenez note de votre sous-réseau IDs. Vous en aurez besoin ultérieurement dans ce didacticiel.

1. Choisissez les sous-réseaux, puis choisissez l'onglet **Description**. Vérifiez que les sous-réseaux que vous souhaitez utiliser sont dans des zones de disponibilité différentes.

1. Choisissez les sous-réseaux, puis choisissez l'onglet **Table de routage**. Pour vérifier que chaque sous-réseau que vous souhaitez utiliser est un sous-réseau public, vérifiez qu'une ligne de passerelle est incluse dans la table de routage.

**Pour créer un Amazon EC2 Application Load Balancer**

1. Connectez-vous à la console Amazon EC2 AWS Management Console et ouvrez-la à l'adresse. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)

1. Dans le volet de navigation, choisissez **Load Balancers**.

1. Sélectionnez **Create Load Balancer** (Créer un équilibreur de charge).

1. Choisissez **Équilibreur de charge d'application**, puis choisissez **Créer**.

1. Dans **Nom**, entrez le nom de votre équilibreur de charge.

1. Dans **Méthode**, choisissez **Accessible sur Internet**.

1. Dans **Type d'adresse IP**, choisissez **ipv4**.

1. Configurez deux ports d'écoute pour votre équilibreur de charge :

   1. Sous **Protocole d'écoute de l'équilibreur de charge**, choisissez **HTTP**. Sous **Port de l'équilibreur de charge**, entrez **80**.

   1. Choisissez **Add listener** (Ajouter un écouteur).

   1. Sous **Protocole de l'équilibreur de charge** pour le deuxième écouteur, choisissez **HTTP**. Sous **Port de l'équilibreur de charge**, entrez **8080**.

1. Sous **Zones de disponibilité**, dans **VPC**, choisissez le VPC par défaut. Ensuite, choisissez deux sous-réseaux par défaut que vous souhaitez utiliser.

1. Choisissez **Next: Configure Security Settings** (Suivant : Configurer les paramètres de sécurité).

1. Choisissez **Next: Configure Security Groups** (Suivant : Configurer des groupes de sécurité).

1. Choisissez **Sélectionner un groupe de sécurité existant** et prenez note de l'ID du groupe de sécurité.

1. Choisissez **Next: Configure Routing** (Suivant :Configurer le routage).

1. Dans **Groupe cible**, choisissez **Nouveau groupe cible** et configurez votre premier groupe cible :

   1. Dans **Nom**, entrez un nom de groupe cible (par exemple, **target-group-1**).

   1. Dans **Type cible**, choisissez **IP**.

   1. Dans **Protocole**, choisissez **HTTP**. Dans **Port**, entrez **80**.

   1. Choisissez **Next: Register Targets** (Suivant : Enregistrer des cibles).

1. Choisissez **Suivant : Vérification**, puis **Créer**.

**Pour créer un deuxième groupe cible pour votre équilibreur de charge**

1. Une fois votre équilibreur de charge configuré, ouvrez la console Amazon EC2. Dans le volet de navigation, sélectionnez **Groupes cibles**.

1. Sélectionnez **Créer un groupe cible**.

1. Dans **Nom**, entrez un nom de groupe cible (par exemple, **target-group-2**).

1. Dans **Type cible**, choisissez **IP**.

1. Dans **Protocole**, choisissez **HTTP**. Dans **Port**, entrez **8080**.

1. Dans **VPC**, choisissez le VPC par défaut.

1. Choisissez **Créer**.
**Note**  
Vous devez avoir deux groupes cibles créés pour votre équilibreur de charge afin de permettre l'exécution du déploiement. Vous devez uniquement noter l'ARN de votre premier groupe cible. Cet ARN est utilisé dans le fichier JSON `create-service` au cours de l'étape suivante.

**Pour mettre à jour votre équilibreur de charge de façon à inclure votre deuxième groupe cible**

1. Ouvrez la console Amazon EC2. Dans le volet de navigation, choisissez **Load Balancers**.

1. Choisissez l'équilibreur de charge, puis choisissez l'onglet **Ecouteurs**. Choisissez l'écouteur avec le port 8080, puis choisissez **Modifier**.

1. Choisissez l'icône en forme de crayon en regard de **Réacheminer vers**. Choisissez votre deuxième groupe cible, puis choisissez la coche. Choisissez **Mettre à jour** pour mettre à jour les mises à jour.

## Étape 4 : créer votre cluster et votre service Amazon ECS
<a name="tutorials-ecs-ecr-codedeploy-cluster"></a>

Dans cette section, vous créez un cluster et un service Amazon ECS qui CodeDeploy acheminent le trafic pendant le déploiement (vers un cluster Amazon ECS plutôt que vers des instances EC2). Pour créer votre service Amazon ECS, vous devez utiliser les noms de sous-réseaux, le groupe de sécurité et la valeur du groupe cible que vous avez créés avec votre équilibreur de charge pour créer votre service.

**Note**  
Lorsque vous suivez ces étapes pour créer votre cluster Amazon ECS, vous utilisez le modèle de cluster **Networking only**, qui approvisionne les conteneurs AWS Fargate. AWS Fargate est une technologie qui gère votre infrastructure d'instance de conteneur pour vous. Vous n'avez pas besoin de choisir ou de créer manuellement des instances Amazon EC2 pour votre cluster Amazon ECS.

**Pour créer un nouveau cluster Amazon ECS**

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

1. Dans le panneau de navigation, choisissez **Clusters**.

1. Choisissez **Créer un cluster**.

1. **Choisissez le modèle de cluster **Networking only** qui utilise AWS Fargate, puis choisissez Next step.**

1. Saisissez le nom d'un cluster sur la page **Configure cluster (Configurer le cluster)**. Vous pouvez ajouter une balise facultative pour votre ressource. Choisissez **Créer**.

**Pour créer un service Amazon ECS**

Utilisez le AWS CLI pour créer votre service dans Amazon ECS.

1. Créez un fichier JSON et nommez-le `create-service.json`. Collez ce qui suit dans le fichier JSON.

   Pour le `taskDefinition` champ, lorsque vous enregistrez une définition de tâche dans Amazon ECS, vous lui attribuez une famille. Il s'agit d'un élément similaire à un nom pour plusieurs versions de la définition de tâche, spécifié avec un numéro de révision. Dans cet exemple, utilisez « `ecs-demo:1` » comme famille et numéro de révision dans votre fichier. Utilisez les noms des sous-réseau, le groupe de sécurité et la valeur du groupe cible créés avec l'équilibreur de charge dans [Étape 3 : Créer votre équilibreur de charge d'application et vos groupes cibles](#tutorials-ecs-ecr-codedeploy-loadbal).
**Note**  
Vous devez inclure votre ARN de groupe cible dans ce fichier. Ouvrez la console Amazon EC2 et dans le volet de navigation, sous **LOAD BALANCING**, sélectionnez **Target** Groups. Choisissez votre premier groupe cible. Copiez votre ARN à partir de l'onglet **Description**.

   ```
   {
       "taskDefinition": "family:revision-number",
       "cluster": "my-cluster",
       "loadBalancers": [
           {
               "targetGroupArn": "target-group-arn",
               "containerName": "sample-website",
               "containerPort": 80
           }
       ],
       "desiredCount": 1,
       "launchType": "FARGATE",
       "schedulingStrategy": "REPLICA",
       "deploymentController": {
           "type": "CODE_DEPLOY"
       },
       "networkConfiguration": {
           "awsvpcConfiguration": {
               "subnets": [
                   "subnet-1",
                   "subnet-2"
               ],
               "securityGroups": [
                   "security-group"
               ],
               "assignPublicIp": "ENABLED"
           }
       }
   }
   ```

1. Exécutez la commande **create-service**, en spécifiant le fichier JSON :
**Important**  
N'oubliez pas d'inclure `file://` devant le nom du fichier. Il est nécessaire dans cette commande.

   Cet exemple crée un service nommé `my-service`.
**Note**  
Cet exemple de commande crée un service nommé my-service. Si vous avez déjà un service portant ce nom, la commande renvoie une erreur.

   ```
   aws ecs create-service --service-name my-service --cli-input-json file://create-service.json
   ```

   La sortie renvoie les champs de description pour votre service.

1. Exécutez la commande **describe-services** pour vérifier que le service a été créé.

   ```
   aws ecs describe-services --cluster cluster-name --services service-name
   ```

## Étape 5 : Création de votre CodeDeploy application et de votre groupe de déploiement (plateforme de calcul ECS)
<a name="tutorials-ecs-ecr-codedeploy-deployment"></a>

Lorsque vous créez une CodeDeploy application et un groupe de déploiement pour la plate-forme de calcul Amazon ECS, l'application est utilisée lors d'un déploiement pour référencer le groupe de déploiement, les groupes cibles, les écouteurs et le comportement de réacheminement du trafic appropriés.

**Pour créer une CodeDeploy application**

1. Ouvrez la CodeDeploy console et choisissez **Create application**.

1. Dans **Nom de l'application**, entrez le nom que vous souhaitez utiliser.

1. Dans **Plateforme de calcul**, choisissez **Amazon ECS**.

1. Choisissez **Créer une application**.

**Pour créer un groupe CodeDeploy de déploiement**

1. Sur la page de votre application, dans l'onglet **Groupe de déploiement**, choisissez **Créer un groupe de déploiement**.

1. Dans **Nom du groupe de déploiement**, entrez un nom décrivant le groupe de déploiement.

1. Dans **Rôle de service**, choisissez un rôle de service qui accorde CodeDeploy l'accès à Amazon ECS. Pour créer un rôle de service, procédez comme suit :

   1. Ouvrez la console IAM à l'adresse [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)).

   1. Dans le tableau de bord de la console, choisissez **Rôles**.

   1. Choisissez **Créer un rôle**.

   1. Sous **Sélectionner le type d'entité de confiance**, sélectionnez **Service AWS**. Sous **Choisir un cas d'utilisation**, sélectionnez **CodeDeploy**. Sous **Sélectionnez votre cas d'utilisation**, sélectionnez **CodeDeploy - ECS**. Choisissez **Suivant : Autorisations**. La stratégie gérée `AWSCodeDeployRoleForECS` est déjà attachée au rôle.

   1. Choisissez **Suivant : Balises**, puis **Suivant : Vérification**.

   1. Entrez un nom pour le rôle (par exemple, **CodeDeployECSRole**), puis choisissez **Créer un rôle**.

1. Dans **Configuration de l'environnement**, choisissez le nom de votre cluster Amazon ECS et le nom du service.

1. Dans **Équilibreurs de charge**, choisissez le nom de l'équilibreur de charge qui achemine le trafic vers votre service Amazon ECS.

1. Dans **Port d'écoute de production**, choisissez le port et le protocole de l'écouteur qui transmet le trafic de production à votre service Amazon ECS. Dans **Test listener port (Port de l'écouteur de test)**, choisissez le port et le protocole de l'écouteur de test.

1. À partir de **Nom du groupe cible 1** et **Nom du groupe cible 2**, choisissez les groupes cible utilisés pour acheminer le trafic au cours de votre déploiement. Assurez-vous que ce sont les groupes cibles que vous avez créés pour votre équilibreur de charge.

1. Choisissez **Réacheminer le trafic immédiatement** pour déterminer combien de temps après un déploiement réussi vous souhaitez rediriger le trafic vers votre tâche Amazon ECS mise à jour.

1. Choisissez **Créer un groupe de déploiement**.

## Étape 6 : Créer le pipeline
<a name="tutorials-ecs-ecr-codedeploy-pipeline"></a>

Dans cette section, vous créez un pipeline avec les actions suivantes :
+  CodeCommit Action dans laquelle les artefacts sources sont la définition de la tâche et le AppSpec fichier.
+ Un stage source avec une action de source Amazon ECR où l'artefact source est le fichier image.
+ Une phase de déploiement avec une action de déploiement Amazon ECS au cours de laquelle le déploiement s'exécute avec une CodeDeploy application et un groupe de déploiement.

**Pour créer un pipeline à deux étapes avec l'assistant**

1. Connectez-vous à la CodePipeline console AWS Management Console et ouvrez-la à l'[adresse http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).

1. Sur la page **Bienvenue**, la page **Démarrez** ou la page **Pipelines**, choisissez **Créer un pipeline**.

1. Sur la page **Étape 1 : Choisir une option de création**, sous **Options de création**, choisissez l'option **Créer un pipeline personnalisé**. Choisissez **Suivant**.

1. À **l'étape 2 : Choisissez les paramètres du pipeline**, dans **Nom du pipeline**, entrez**MyImagePipeline**.

1. CodePipeline fournit des pipelines de type V1 et V2, dont les caractéristiques et le prix diffèrent. Le type V2 est le seul type que vous pouvez choisir dans la console. Pour plus d'informations, consultez la section [Types de pipelines](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel). Pour plus d'informations sur la tarification CodePipeline, consultez la section [Tarification](https://aws.amazon.com/codepipeline/pricing/).

1. Dans **Rôle de service**, choisissez **Nouveau rôle de service** pour autoriser CodePipeline la création d'un rôle de service dans IAM.

1. Laissez les paramètres sous **Advanced settings (Paramètres avancés)** à leurs valeurs par défaut, puis choisissez **Suivant**.

1. À **l'étape 3 : Ajouter une étape source**, dans **Source provider**, choisissez **AWS CodeCommit**. Dans **Nom du référentiel**, choisissez le nom du référentiel CodeCommit que vous avez créé dans [Étape 1 : Création d'un CodeCommit référentiel](tutorials-simple-codecommit.md#codecommit-create-repository). Dans **Nom de branche**, choisissez le nom de la branche qui contient votre dernière mise à jour du code.

   Choisissez **Suivant**.

1. À **l'étape 4 : Ajouter une phase de construction**, choisissez **Ignorer l'étape** de génération, puis acceptez le message d'avertissement en choisissant à nouveau **Ignorer**. Choisissez **Suivant**.

1. À **l'étape 5 : Ajouter une phase de test**, choisissez **Ignorer l'étape de test**, puis acceptez le message d'avertissement en choisissant à nouveau **Ignorer**. 

   Choisissez **Suivant**.

1. À **l'étape 6 : Ajouter une phase de déploiement** :

   1. Dans **Fournisseur de déploiement**, choisissez **Amazon ECS (Bleu/vert)**. Dans **Nom de l'application**, entrez ou choisissez le nom de l'application dans la liste, comme `codedeployapp`. Dans **Groupe de déploiement**, saisissez ou choisissez le nom du groupe de déploiement dans la liste, comme `codedeploydeplgroup`.

       
**Note**  
« Déploiement » est le nom donné par défaut à l'étape du pipeline créée lors de l'**Étape 4 : Déploiement** tout comme « Source » est le nom donné à la première étape du pipeline.

   1. Sous **Définition de tâche Amazon ECS**, sélectionnez **SourceArtifact**. Dans le champ, entrez **taskdef.json**.

   1. Sous **AWS CodeDeploy AppSpec fichier**, sélectionnez **SourceArtifact**. Dans le champ, entrez **appspec.yaml**.
**Note**  
À ce stade, ne renseignez aucune information sous **Mettre à jour l'image de la définition de tâche de manière dynamique**.

   1. Choisissez **Suivant**.

1. À **l'étape 7 : Passez** en revue, passez en revue les informations, puis choisissez **Créer un pipeline**.

**Pour ajouter une action source Amazon ECR à votre pipeline**

Consultez votre pipeline et ajoutez une action source Amazon ECR à votre pipeline.

1. Choisissez votre pipeline. Dans le coin supérieur gauche, choisissez **Modifier**.

1. Dans la phase source, choisissez **Modifier l'étape**.

1. Ajoutez une action parallèle en choisissant **\$1 Ajouter une action** à côté de votre action CodeCommit source.

1. Dans **Nom d'action**, saisissez un nom pour le pipeline (par exemple, **Image**).

1. Dans **Fournisseur d'action**, choisissez **Amazon ECR**.  
![\[\]](http://docs.aws.amazon.com/fr_fr/codepipeline/latest/userguide/images/ECR-source-action.png)

1. Dans **Nom du référentiel**, choisissez le nom de votre référentiel Amazon ECR.

1. Dans **Balise d'image**, spécifiez le nom et la version de l'image, s'ils sont différents des précédents.

1. Dans **Artefacts de sortie**, choisissez l'artefact de sortie par défaut (par exemple, `MyImage`) qui contient les informations de nom d'image et d'URI de référentiel que l'étape suivante doit utiliser.

1. Choisissez **Save (Enregistrer)** sur l'écran de l'action. Choisissez **Done (Terminé)** sur l'écran de l'étape. Choisissez **Save (Enregistrer)** sur le pipeline. Un message indique la règle Amazon CloudWatch Events à créer pour l'action source Amazon ECR.

**Pour relier vos artefacts source à l'action de déploiement**

1. Choisissez **Modifier** lors de votre phase de déploiement et choisissez l'icône pour modifier l'action **Amazon ECS (bleu/vert).**

1. Faites défiler jusqu'au bas du panneau. Dans **Artefacts d'entrée**, choisissez **Ajouter**. Ajoutez l'artefact source depuis votre nouveau référentiel Amazon ECR (par exemple,`MyImage`).

1. Dans **Définition de tâche**, sélectionnez **SourceArtifact**, puis vérifiez que la saisie **taskdef.json** est effectuée.

1. Dans **AWS CodeDeploy AppSpec Fichier**, sélectionnez **SourceArtifact**, puis vérifiez que la saisie **appspec.yaml** est effectuée.

1. Dans **Mettre à jour dynamiquement l'image de définition de tâche**, dans **Artifact d'entrée avec URI d'image **MyImage****, choisissez, puis entrez le texte de l'espace réservé utilisé dans le `taskdef.json` fichier :. ** IMAGE1\$1NAME** Choisissez **Enregistrer**.

1. Dans le AWS CodePipeline volet, choisissez **Enregistrer la modification du pipeline**, puis cliquez **sur Enregistrer la modification**. Affichez votre pipeline mis à jour.

   Une fois cet exemple de pipeline créé, la configuration d'action pour les entrées de la console s'affiche dans la structure du pipeline, comme suit :

   ```
   "configuration": {
     "AppSpecTemplateArtifact": "SourceArtifact",
     "AppSpecTemplatePath": "appspec.yaml",
     "TaskDefinitionTemplateArtifact": "SourceArtifact",
     "TaskDefinitionTemplatePath": "taskdef.json",
     "ApplicationName": "codedeployapp",
     "DeploymentGroupName": "codedeploydeplgroup",
     "Image1ArtifactName": "MyImage",
     "Image1ContainerName": "IMAGE1_NAME"
   },
   ```

1. Pour soumettre vos modifications et lancer la génération d'un pipeline, choisissez **Changement de version**, puis **Publication**.

1. Choisissez l'action de déploiement pour la visualiser CodeDeploy et suivre la progression du transfert du trafic.
**Note**  
Il se peut qu'une étape de déploiement affiche un temps d'attente facultatif. Par défaut, CodeDeploy attend une heure après un déploiement réussi avant de mettre fin à l'ensemble de tâches initial. Vous pouvez utiliser ce temps pour revenir en arrière ou mettre fin à la tâche. Sinon, votre déploiement prend fin lorsque l’ensemble de tâches est terminé.

## Étape 7 : Modifier le pipeline et vérifier le déploiement
<a name="tutorials-ecs-ecr-codedeploy-update"></a>

Apportez une modification à votre image, puis transférez la modification dans votre référentiel Amazon ECR. Cela déclenche l'exécution de votre pipeline. Vérifiez que la modification de la source de l'image est déployée.