Déploiement d'un ECS service Amazon à l'aide d'un déploiement bleu/vert - Amazon Elastic Container Service
PrérequisÉtape 1 : Créer un Application Load BalancerÉtape 2 : Créer un ECS cluster AmazonÉtape 3 : Enregistrer une définition de tâcheÉtape 4 : Créer un ECS service AmazonÉtape 5 : Créer les ressources AWS CodeDeployÉtape 6 : Créer er surveiller un CodeDeploy déploiementÉtape 7 : nettoyer

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.

Déploiement d'un ECS service Amazon à l'aide d'un déploiement bleu/vert

Découvrez comment créer un ECS service Amazon contenant une tâche Fargate qui utilise le type de déploiement bleu/vert avec l'. AWS CLI

Note

La prise en charge d'un déploiement bleu/vert a été ajoutée pour AWS CloudFormation. Pour plus d'informations, consultez la section Effectuer des déploiements ECS bleu/vert d'Amazon en les CodeDeploy utilisant AWS CloudFormation dans le AWS CloudFormation guide de l'utilisateur.

Prérequis

Le didacticiel suppose de remplir les prérequis suivants :

Étape 1 : Créer un Application Load Balancer

Les ECS services Amazon utilisant le type de déploiement bleu/vert 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-balancercommande 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

    La sortie inclut 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

  2. Utilisez la create-target-groupcommande 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 ARN de sortie contiennent celles du groupe cible, au format suivant :

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

  3. Utilisez la commande create-listener 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 ARN de sortie contiennent l'auditeur, au format suivant :

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

Étape 2 : Créer un ECS cluster Amazon

Utilisez la commande create-cluster 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 ARN de sortie contiennent le cluster, au format suivant :

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

Étape 3 : Enregistrer une définition de tâche

Utilisez la register-task-definitioncommande 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 le ARN pour votre rôle d'exécution de tâches. Pour de plus amples informations, veuillez consulter IAMRôle d'exécution des ECS tâches Amazon.

{
    "family": "tutorial-task-def",
        "networkMode": "awsvpc",
        "containerDefinitions": [
            {
                "name": "sample-app",
                "image": "httpd:2.4",
                "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: #00FFFF;} </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",
        "executionRoleArn": "arn:aws:iam::aws_account_id:role/ecsTaskExecutionRole"
}

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 ECS service Amazon

Utilisez la commande create-service 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 ARN de sortie contiennent le service, au format suivant :

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

Obtenez le DNS nom de l'équilibreur de charge à l'aide de la commande suivante. 

 aws elbv2 describe-load-balancers --name bluegreen-alb  --query 'LoadBalancers[*].DNSName'

Saisissez le DNS nom dans votre navigateur web. Vous devriez voir une page Web qui affiche l'exemple d'application avec un fond bleu.

Étape 5 : Créer les ressources AWS CodeDeploy

Effectuez les étapes suivantes 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 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"
}

  2. Utilisez la create-target-groupcommande pour créer un second 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 ARN contiennent celles pour le groupe cible, au format suivant :

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

  3. Utilisez la create-deployment-groupcommande 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 leserviceRoleArn, spécifiez le ECS CodeDeploy IAM rôle ARN de votre Amazon. Pour de plus amples informations, veuillez consulter ECS CodeDeploy IAMRôle Amazon.

    {
   "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éer er surveiller un CodeDeploy déploiement

Avant de créer un CodeDeploy déploiement, mettez à jour la définition command de tâche fargate-task.json comme suit pour passer la couleur d'arrière-plan de l'exemple d'application au vert.

{
    ...
        "containerDefinitions": [
            {
                ...
                "command": [
                    "/bin/sh -c \"echo '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #097969;} </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\""
                ]
            }
        ],
       ...
}

Enregistrez la définition de tâche mise à jour à l'aide de la commande suivante. 

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

Utilisez maintenant les étapes suivantes pour créer et charger un fichier de spécification d'application (AppSpec fichier) et un CodeDeploy déploiement.

Pour créer er surveiller un CodeDeploy déploiement

  1. Créez et chargez un AppSpec fichier à l'aide des étapes suivantes.

    1. Créez un fichier nommé appspec.yaml avec le contenu du groupe de CodeDeploy déploiement. Cet exemple utilise la définition de tâche mise à jour.

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

    2. Utilisez la commande s3 mb pour créer un compartiment Amazon S3 pour le AppSpec fichier.

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

    3. Utilisez la commande s3 cp pour télécharger le AppSpec fichier dans le compartiment Amazon S3.

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

  2. Créez le CodeDeploy déploiement en procédant comme suit.

    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"
        }
    }
}

    2. Utilisez la commande create-deployment 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"
}

  3. Utilisez la get-deployment-targetcommande 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

    Au départ, l'état du déploiement est InProgress. Le trafic est dirigé vers l'ensemble de tâches d'origine, dont le taskSetLabel est BLUE, le statut est PRIMARY et le trafficWeight est 100.0. L'ensemble de tâches de remplacement possède un taskSetLabel de GREEN, un statut de ACTIVE et un trafficWeight de 0.0. Le navigateur Web dans lequel vous avez saisi le DNS nom affiche toujours l'exemple d'application sur fond bleu.

    {
"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": "2023-08-10T12:07:24.797000-05:00",
    "lifecycleEvents": [
        {
            "lifecycleEventName": "BeforeInstall",
            "startTime": "2023-08-10T12:06:22.493000-05:00",
            "endTime": "2023-08-10T12:06:22.790000-05:00",
            "status": "Succeeded"
        },
        {
            "lifecycleEventName": "Install",
            "startTime": "2023-08-10T12:06:22.936000-05:00",
            "status": "InProgress"
        },
        {
            "lifecycleEventName": "AfterInstall",
            "status": "Pending"
        },
        {
            "lifecycleEventName": "BeforeAllowTraffic",
            "status": "Pending"
        },
        {
            "lifecycleEventName": "AllowTraffic",
            "status": "Pending"
        },
        {
            "lifecycleEventName": "AfterAllowTraffic",
            "status": "Pending"
        }
    ],
    "status": "InProgress",
    "taskSetsInfo": [
        {
            "identifer": "ecs-svc/9223370493423413672",
            "desiredCount": 1,
            "pendingCount": 0,
            "runningCount": 1,
            "status": "ACTIVE",
            "trafficWeight": 0.0,
            "targetGroup": {
                "name": "bluegreentarget2"
            },
            "taskSetLabel": "Green"
        },
        {
            "identifer": "ecs-svc/9223370493425779968",
            "desiredCount": 1,
            "pendingCount": 0,
            "runningCount": 1,
            "status": "PRIMARY",
            "trafficWeight": 100.0,
            "targetGroup": {
                "name": "bluegreentarget1"
            },
            "taskSetLabel": "Blue"
        }
    ]
}
}
}

    Continuez de récupérer les détails du déploiement à l'aide de la commande jusqu'à ce que le statut de déploiement soit Succeeded, comme indiqué dans la sortie suivante. Le trafic est désormais redirigé vers l'ensemble de tâches de remplacement, dont le statut est désormais PRIMARY et le trafficWeight est 100.0. Actualisez le navigateur Web dans lequel vous avez saisi le DNS nom de l'équilibreur de charge, et vous devriez maintenant voir l'exemple d'application sur fond vert.

    {
"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": "2023-08-10T12:07:24.797000-05:00",
    "lifecycleEvents": [
        {
            "lifecycleEventName": "BeforeInstall",
            "startTime": "2023-08-10T12:06:22.493000-05:00",
            "endTime": "2023-08-10T12:06:22.790000-05:00",
            "status": "Succeeded"
        },
        {
            "lifecycleEventName": "Install",
            "startTime": "2023-08-10T12:06:22.936000-05:00",
            "endTime": "2023-08-10T12:08:25.939000-05:00",
            "status": "Succeeded"
        },
        {
            "lifecycleEventName": "AfterInstall",
            "startTime": "2023-08-10T12:08:26.089000-05:00",
            "endTime":  "2023-08-10T12:08:26.403000-05:00",
            "status": "Succeeded"
        },
        {
            "lifecycleEventName": "BeforeAllowTraffic",
            "startTime": "2023-08-10T12:08:26.926000-05:00",
            "endTime":  "2023-08-10T12:08:27.256000-05:00",
            "status": "Succeeded"
        },
        {
            "lifecycleEventName": "AllowTraffic",
            "startTime": "2023-08-10T12:08:27.416000-05:00",
            "endTime": "2023-08-10T12:08:28.195000-05:00",
            "status": "Succeeded"
        },
        {
            "lifecycleEventName": "AfterAllowTraffic",
            "startTime": "2023-08-10T12:08:28.715000-05:00",
            "endTime":  "2023-08-10T12:08:28.994000-05:00",
            "status": "Succeeded"
        }
    ],
    "status": "Succeeded",
    "taskSetsInfo": [
        {
            "identifer": "ecs-svc/9223370493425779968",
            "desiredCount": 1,
            "pendingCount": 0,
            "runningCount": 1,
            "status": "ACTIVE",
            "trafficWeight": 0.0,
            "targetGroup": {
                "name": "bluegreentarget1"
            },
            "taskSetLabel": "Blue"
        },
        {
            "identifer": "ecs-svc/9223370493423413672",
            "desiredCount": 1,
            "pendingCount": 0,
            "runningCount": 1,
            "status": "PRIMARY",
            "trafficWeight": 100.0,
            "targetGroup": {
                "name": "bluegreentarget2"
            },
            "taskSetLabel": "Green"
        }
    ]
}
}
}

Étape 7 : nettoyer

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-groupcommande 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

  2. Utilisez la commande delete-application pour supprimer l' CodeDeploy application.

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

  3. Utilisez la commande delete-service AmazonECS. 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

  4. Utilisez la commande delete-cluster pour supprimer l'AmazonECS.

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

  5. Utilisez la commande s3 rm pour supprimer le AppSpec fichier du compartiment Amazon S3.

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

  6. Utilisez la commande s3 rb pour supprimer le compartiment Amazon S3.

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

  7. Utilisez la delete-load-balancercommande 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

  8. Utilisez la delete-target-groupcommande 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