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 service à l'aide d'un Blue/Green déploiement
<a name="create-blue-green"></a>

Amazon ECS a intégré blue/green les déploiements dans l'assistant de création de service sur la console Amazon ECS. Pour de plus amples informations, veuillez consulter [Création d’un déploiement de mise à jour propagée Amazon ECS](create-service-console-v2.md).

Le didacticiel suivant explique comment créer un service Amazon ECS contenant une tâche Fargate qui utilise blue/green le type de déploiement avec le. AWS CLI

**Note**  
Support pour effectuer un blue/green déploiement a été ajouté pour CloudFormation. *Pour plus d'informations, consultez la section [Effectuer des déploiements bleu/vert d'Amazon ECS CloudFormation dans le AWS CloudFormation guide CodeDeploy de l'](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/blue-green.html)utilisateur.*

## Conditions préalables
<a name="create-blue-green-prereqs"></a>

Le didacticiel suppose de remplir les prérequis suivants :
+ La dernière version du AWS CLI est installée et configurée. Pour plus d'informations sur l'installation ou la mise à niveau du AWS CLI, voir [Installation du AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html).
+ Vous devez avoir suivi les étapes de [Configurer l'utilisation d'Amazon ECS](get-set-up-for-amazon-ecs.md).
+ Votre utilisateur IAM dispose des autorisations requises spécifiées dans l’exemple de politique IAM [Amazon ECS\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess).
+ Vous avez un créé un VPC et un groupe de sécurité prêts à être utilisés. Pour de plus amples informations, veuillez consulter [Créer un Virtual Private Cloud](get-set-up-for-amazon-ecs.md#create-a-vpc).
+ Le rôle Amazon ECS CodeDeploy IAM est créé. Pour de plus amples informations, veuillez consulter [Rôle CodeDeploy IAM d'Amazon ECS](codedeploy_IAM_role.md).

## Étape 1 : Créer un Application Load Balancer
<a name="create-blue-green-loadbalancer"></a>

Les services Amazon ECS utilisant le type de blue/green déploiement nécessitent l'utilisation d'un Application Load Balancer ou d'un Network Load Balancer. Ce didacticiel utilise un équilibreur de charge Application Load Balancer.

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

1. Utilisez la [create-load-balancer](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-load-balancer.html)commande pour créer un Application Load Balancer. Spécifiez deux sous-réseaux qui ne proviennent pas de la même zone de disponibilité, ainsi qu'un groupe de sécurité.

   ```
   aws elbv2 create-load-balancer \
        --name bluegreen-alb \
        --subnets subnet-abcd1234 subnet-abcd5678 \
        --security-groups sg-abcd1234 \
        --region us-east-1
   ```

   Les données de sortie contiennent l'Amazon Resource Name (ARN) de l'équilibreur de charge, au format suivant :

   ```
   arn:aws:elasticloadbalancing:region:aws_account_id:loadbalancer/app/bluegreen-alb/e5ba62739c16e642
   ```

1. Utilisez la [create-target-group](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-target-group.html)commande pour créer un groupe cible. Ce groupe cible achemine le trafic vers la tâche d'origine définie dans votre service.

   ```
   aws elbv2 create-target-group \
        --name bluegreentarget1 \
        --protocol HTTP \
        --port 80 \
        --target-type ip \
        --vpc-id vpc-abcd1234 \
        --region us-east-1
   ```

   Les données de sortie contiennent l'ARN du groupe cible, au format suivant :

   ```
   arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4
   ```

1. Utilisez la commande [create-listener](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-listener.html) pour créer un écouteur d'équilibreur de charge avec une règle par défaut qui transfère les demandes au groupe cible :

   ```
   aws elbv2 create-listener \
        --load-balancer-arn arn:aws:elasticloadbalancing:region:aws_account_id:loadbalancer/app/bluegreen-alb/e5ba62739c16e642 \
        --protocol HTTP \
        --port 80 \
        --default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4 \
        --region us-east-1
   ```

   Les données de sortie contiennent l'ARN de l'écouteur, au format suivant :

   ```
   arn:aws:elasticloadbalancing:region:aws_account_id:listener/app/bluegreen-alb/e5ba62739c16e642/665750bec1b03bd4
   ```

## Étape 2 : créer un cluster Amazon ECS
<a name="create-blue-green-cluster"></a>

Utilisez la commande [create-cluster](https://docs.aws.amazon.com/cli/latest/reference/ecs/create-cluster.html) pour créer un cluster nommé `tutorial-bluegreen-cluster` à utiliser.

```
aws ecs create-cluster \
     --cluster-name tutorial-bluegreen-cluster \
     --region us-east-1
```

Les données de sortie contiennent l'ARN du cluster, au format suivant :

```
arn:aws:ecs:region:aws_account_id:cluster/tutorial-bluegreen-cluster
```

## Étape 3 : Enregistrer une définition de tâche
<a name="create-blue-green-taskdef"></a>

Utilisez la [register-task-definition](https://docs.aws.amazon.com/cli/latest/reference/ecs/register-task-definition.html)commande pour enregistrer une définition de tâche compatible avec Fargate. Cela exige d'utiliser le mode réseau `awsvpc`. Voici l'exemple de définition de tâche utilisé pour ce didacticiel.

Pour commencer, créez un fichier nommé `fargate-task.json` avec le contenu suivant. Assurez-vous d'utiliser l'ARN de votre rôle d'exécution de tâche. Pour de plus amples informations, veuillez consulter [Rôle IAM d'exécution de tâche Amazon ECS](task_execution_IAM_role.md).

```
{
    "family": "sample-fargate", 
    "networkMode": "awsvpc", 
    "containerDefinitions": [
        {
            "name": "sample-app", 
            "image": "public.ecr.aws/docker/library/httpd:latest", 
            "portMappings": [
                {
                    "containerPort": 80, 
                    "hostPort": 80, 
                    "protocol": "tcp"
                }
            ], 
            "essential": true, 
            "entryPoint": [
                "sh",
		"-c"
            ], 
            "command": [
                "/bin/sh -c \"echo '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> </div></body></html>' >  /usr/local/apache2/htdocs/index.html && httpd-foreground\""
            ]
        }
    ], 
    "requiresCompatibilities": [
        "FARGATE"
    ], 
    "cpu": "256", 
    "memory": "512"
}
```

Enregistrez ensuite la définition de tâche à l'aide du fichier `fargate-task.json` que vous avez créé.

```
aws ecs register-task-definition \
     --cli-input-json file://fargate-task.json \
     --region us-east-1
```

## Étape 4 : créer un service Amazon ECS
<a name="create-blue-green-service"></a>

Utilisez la commande [create-service](https://docs.aws.amazon.com/cli/latest/reference/ecs/create-service.html) pour créer un service. 

Pour commencer, créez un fichier nommé `service-bluegreen.json` avec le contenu suivant.

```
{
    "cluster": "tutorial-bluegreen-cluster",
    "serviceName": "service-bluegreen",
    "taskDefinition": "tutorial-task-def",
    "loadBalancers": [
        {
            "targetGroupArn": "arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4",
            "containerName": "sample-app",
            "containerPort": 80
        }
    ],
    "launchType": "FARGATE",
    "schedulingStrategy": "REPLICA",
    "deploymentController": {
        "type": "CODE_DEPLOY"
    },
    "platformVersion": "LATEST",
    "networkConfiguration": {
       "awsvpcConfiguration": {
          "assignPublicIp": "ENABLED",
          "securityGroups": [ "sg-abcd1234" ],
          "subnets": [ "subnet-abcd1234", "subnet-abcd5678" ]
       }
    },
    "desiredCount": 1
}
```

Ensuite, créez votre service à l'aide du fichier `service-bluegreen.json` que vous avez créé.

```
aws ecs create-service \
     --cli-input-json file://service-bluegreen.json \
     --region us-east-1
```

Les données de sortie contiennent l'ARN du service, au format suivant :

```
arn:aws:ecs:region:aws_account_id:service/service-bluegreen
```

## Étape 5 : Création des AWS CodeDeploy ressources
<a name="create-blue-green-codedeploy"></a>

Suivez les étapes ci-dessous pour créer votre CodeDeploy application, le groupe cible Application Load Balancer pour le groupe de CodeDeploy déploiement et le groupe de CodeDeploy déploiement.

**Pour créer des CodeDeploy ressources**

1. Utilisez la commande [create-application](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-application.html) pour créer une CodeDeploy application. Précisez la plateforme de calcul `ECS`.

   ```
   aws deploy create-application \
        --application-name tutorial-bluegreen-app \
        --compute-platform ECS \
        --region us-east-1
   ```

   Les données de sortie contiennent l'ID d'application, au format suivant :

   ```
   {
       "applicationId": "b8e9c1ef-3048-424e-9174-885d7dc9dc11"
   }
   ```

1. Utilisez la [create-target-group](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-target-group.html)commande pour créer un deuxième groupe cible Application Load Balancer, qui sera utilisé lors de la création de votre groupe de CodeDeploy déploiement.

   ```
   aws elbv2 create-target-group \
        --name bluegreentarget2 \
        --protocol HTTP \
        --port 80 \
        --target-type ip \
        --vpc-id "vpc-0b6dd82c67d8012a1" \
        --region us-east-1
   ```

   Les données de sortie contiennent l'ARN du groupe cible, au format suivant :

   ```
   arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget2/708d384187a3cfdc
   ```

1. Utilisez la [create-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-group.html)commande pour créer un groupe CodeDeploy de déploiement.

   Pour commencer, créez un fichier nommé `tutorial-deployment-group.json` avec le contenu suivant. Cet exemple utilise la ressource que vous avez créée. Pour le`serviceRoleArn`, spécifiez l'ARN de votre rôle Amazon ECS CodeDeploy IAM. Pour de plus amples informations, veuillez consulter [Rôle CodeDeploy IAM d'Amazon ECS](codedeploy_IAM_role.md).

   ```
   {
      "applicationName": "tutorial-bluegreen-app",
      "autoRollbackConfiguration": {
         "enabled": true,
         "events": [ "DEPLOYMENT_FAILURE" ]
      },
      "blueGreenDeploymentConfiguration": {
         "deploymentReadyOption": {
            "actionOnTimeout": "CONTINUE_DEPLOYMENT",
            "waitTimeInMinutes": 0
         },
         "terminateBlueInstancesOnDeploymentSuccess": {
            "action": "TERMINATE",
            "terminationWaitTimeInMinutes": 5
         }
      },
      "deploymentGroupName": "tutorial-bluegreen-dg",
      "deploymentStyle": {
         "deploymentOption": "WITH_TRAFFIC_CONTROL",
         "deploymentType": "BLUE_GREEN"
      },
      "loadBalancerInfo": {
         "targetGroupPairInfoList": [
           {
             "targetGroups": [
                {
                    "name": "bluegreentarget1"
                },
                {
                    "name": "bluegreentarget2"
                }
             ],
             "prodTrafficRoute": {
                 "listenerArns": [
                     "arn:aws:elasticloadbalancing:region:aws_account_id:listener/app/bluegreen-alb/e5ba62739c16e642/665750bec1b03bd4"
                 ]
             }
           }
         ]
      },
      "serviceRoleArn": "arn:aws:iam::aws_account_id:role/ecsCodeDeployRole",
      "ecsServices": [
          {
              "serviceName": "service-bluegreen",
              "clusterName": "tutorial-bluegreen-cluster"
          }
      ]
   }
   ```

   Créez ensuite le groupe CodeDeploy de déploiement.

   ```
   aws deploy create-deployment-group \
        --cli-input-json file://tutorial-deployment-group.json \
        --region us-east-1
   ```

   Les données de sortie contiennent l'ID du groupe de déploiement, au format suivant :

   ```
   {
       "deploymentGroupId": "6fd9bdc6-dc51-4af5-ba5a-0a4a72431c88"
   }
   ```

## Étape 6 : Création et surveillance d'un CodeDeploy déploiement
<a name="create-blue-green-verify"></a>

Suivez les étapes ci-dessous pour créer et télécharger un fichier de spécification d'application (AppSpec fichier) et un CodeDeploy déploiement.

**Pour créer et surveiller un CodeDeploy déploiement**

1. Créez et chargez un AppSpec fichier en suivant les étapes ci-dessous.

   1. Créez un fichier nommé `appspec.yaml` avec le contenu du groupe de déploiement CodeDeploy . Cet exemple utilise les ressources que vous avez créées précédemment dans le didacticiel.

      ```
      version: 0.0
      Resources:
        - TargetService:
            Type: AWS::ECS::Service
            Properties:
              TaskDefinition: "arn:aws:ecs:region:aws_account_id:task-definition/first-run-task-definition:7"
              LoadBalancerInfo:
                ContainerName: "sample-app"
                ContainerPort: 80
              PlatformVersion: "LATEST"
      ```

   1. Utilisez la commande [s3 mb](https://docs.aws.amazon.com/cli/latest/reference/s3/mb.html) pour créer un compartiment Amazon S3 pour le AppSpec fichier.

      ```
      aws s3 mb s3://tutorial-bluegreen-bucket
      ```

   1. Utilisez la commande [s3 cp](https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html) pour charger le AppSpec fichier dans le compartiment Amazon S3.

      ```
      aws s3 cp ./appspec.yaml s3://tutorial-bluegreen-bucket/appspec.yaml
      ```

1. Créez le CodeDeploy déploiement en suivant les étapes ci-dessous.

   1. Créez un fichier nommé `create-deployment.json` avec le contenu du CodeDeploy déploiement. Cet exemple utilise les ressources que vous avez créées précédemment dans le didacticiel.

      ```
      {
          "applicationName": "tutorial-bluegreen-app",
          "deploymentGroupName": "tutorial-bluegreen-dg",
          "revision": {
              "revisionType": "S3",
              "s3Location": {
                  "bucket": "tutorial-bluegreen-bucket",
                  "key": "appspec.yaml",
                  "bundleType": "YAML"
              }
          }
      }
      ```

   1. Utilisez la commande [create-deployment](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment.html) pour créer le déploiement.

      ```
      aws deploy create-deployment \
           --cli-input-json file://create-deployment.json \
           --region us-east-1
      ```

      Les données de sortie contiennent l'ID du déploiement, au format suivant :

      ```
      {
          "deploymentId": "d-RPCR1U3TW"
      }
      ```

   1. Utilisez la [get-deployment-target](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-target.html)commande pour obtenir les détails du déploiement, en spécifiant ceux `deploymentId` de la sortie précédente.

      ```
      aws deploy get-deployment-target \
           --deployment-id "d-IMJU3A8TW" \
           --target-id tutorial-bluegreen-cluster:service-bluegreen \
           --region us-east-1
      ```

      Continuez de récupérer les détails du déploiement jusqu'à ce que le statut soit `Succeeded`, comme indiqué dans la sortie suivante.

      ```
      {
          "deploymentTarget": {
              "deploymentTargetType": "ECSTarget",
              "ecsTarget": {
                  "deploymentId": "d-RPCR1U3TW",
                  "targetId": "tutorial-bluegreen-cluster:service-bluegreen",
                  "targetArn": "arn:aws:ecs:region:aws_account_id:service/service-bluegreen",
                  "lastUpdatedAt": 1543431490.226,
                  "lifecycleEvents": [
                      {
                          "lifecycleEventName": "BeforeInstall",
                          "startTime": 1543431361.022,
                          "endTime": 1543431361.433,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "Install",
                          "startTime": 1543431361.678,
                          "endTime": 1543431485.275,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "AfterInstall",
                          "startTime": 1543431485.52,
                          "endTime": 1543431486.033,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "BeforeAllowTraffic",
                          "startTime": 1543431486.838,
                          "endTime": 1543431487.483,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "AllowTraffic",
                          "startTime": 1543431487.748,
                          "endTime": 1543431488.488,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "AfterAllowTraffic",
                          "startTime": 1543431489.152,
                          "endTime": 1543431489.885,
                          "status": "Succeeded"
                      }
                  ],
                  "status": "Succeeded",
                  "taskSetsInfo": [
                      {
                          "identifer": "ecs-svc/9223370493425779968",
                          "desiredCount": 1,
                          "pendingCount": 0,
                          "runningCount": 1,
                          "status": "ACTIVE",
                          "trafficWeight": 0.0,
                          "targetGroup": {
                              "name": "bluegreentarget1"
                          }
                      },
                      {
                          "identifer": "ecs-svc/9223370493423413672",
                          "desiredCount": 1,
                          "pendingCount": 0,
                          "runningCount": 1,
                          "status": "PRIMARY",
                          "trafficWeight": 100.0,
                          "targetGroup": {
                              "name": "bluegreentarget2"
                          }
                      }
                  ]
              }
          }
      }
      ```

## Étape 7 : Nettoyer
<a name="create-blue-green-cleanup"></a>

Lorsque vous avez terminé ce didacticiel, nettoyez les ressources qui lui sont associées afin d'éviter la facturation de frais pour des ressources que vous n'utilisez pas.

**Nettoyage des ressources du didacticiel**

1. Utilisez la [delete-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-deployment-group.html)commande pour supprimer le groupe CodeDeploy de déploiement.

   ```
   aws deploy delete-deployment-group \
        --application-name tutorial-bluegreen-app \
        --deployment-group-name tutorial-bluegreen-dg \
        --region us-east-1
   ```

1. Utilisez la commande [delete-application](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-application.html) pour supprimer l' CodeDeploy application.

   ```
   aws deploy delete-application \
        --application-name tutorial-bluegreen-app \
        --region us-east-1
   ```

1. Utilisez la commande [delete-service](https://docs.aws.amazon.com/cli/latest/reference/ecs/delete-service.html) pour supprimer l'Amazon ECS service. Utiliser l'indicateur `--force` vous permet de supprimer un service, même s'il n'a pas été abaissé à 0 tâche.

   ```
   aws ecs delete-service \
        --service arn:aws:ecs:region:aws_account_id:service/service-bluegreen \
        --force \
        --region us-east-1
   ```

1. Utilisez la commande [delete-cluster](https://docs.aws.amazon.com/cli/latest/reference/ecs/delete-cluster.html) pour supprimer le cluster Amazon ECS.

   ```
   aws ecs delete-cluster \
        --cluster tutorial-bluegreen-cluster \
        --region us-east-1
   ```

1. Utilisez la commande [s3 rm](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html) pour supprimer le AppSpec fichier du compartiment Amazon S3.

   ```
   aws s3 rm s3://tutorial-bluegreen-bucket/appspec.yaml
   ```

1. Utilisez la commande [s3 rb](https://docs.aws.amazon.com/cli/latest/reference/s3/rb.html) pour supprimer le compartiment Amazon S3.

   ```
   aws s3 rb s3://tutorial-bluegreen-bucket
   ```

1. Utilisez la [delete-load-balancer](https://docs.aws.amazon.com/cli/latest/reference/elbv2/delete-load-balancer.html)commande pour supprimer l'Application Load Balancer.

   ```
   aws elbv2 delete-load-balancer \
        --load-balancer-arn arn:aws:elasticloadbalancing:region:aws_account_id:loadbalancer/app/bluegreen-alb/e5ba62739c16e642 \
        --region us-east-1
   ```

1. Utilisez la [delete-target-group](https://docs.aws.amazon.com/cli/latest/reference/elbv2/delete-target-group.html)commande pour supprimer les deux groupes cibles Application Load Balancer.

   ```
   aws elbv2 delete-target-group \
        --target-group-arn arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4 \
        --region us-east-1
   ```

   ```
   aws elbv2 delete-target-group \
        --target-group-arn arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget2/708d384187a3cfdc \
        --region us-east-1
   ```