Implementazione di un ECS servizio Amazon utilizzando una distribuzione blu/verde - Amazon Elastic Container Service
PrerequisitiFase 1: Creazione di un Application Load BalancerFase 2: Creare un ECS cluster AmazonFase 3: Registra una definizione di attivitàFase 4: Creare un ECS servizio AmazonFase 5: Creazione delle risorse AWS CodeDeployFase 6: Creare e monitorare una CodeDeploy distribuzioneFase 7: pulire

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Implementazione di un ECS servizio Amazon utilizzando una distribuzione blu/verde

Scopri come creare un ECS servizio Amazon contenente un'attività Fargate che utilizza il tipo di distribuzione blu/verde con. AWS CLI

Nota

È stato aggiunto il supporto per l'esecuzione di un'implementazione blu/verde per AWS CloudFormation. Per ulteriori informazioni, consulta Eseguire le distribuzioni Amazon ECS blue/green CodeDeploy utilizzando AWS CloudFormation nella Guida per l'utente.AWS CloudFormation

Prerequisiti

Questo tutorial presuppone che siano stati soddisfatti i prerequisiti seguenti:

Fase 1: Creazione di un Application Load Balancer

ECSI servizi Amazon che utilizzano il tipo di distribuzione blu/verde richiedono l'uso di un Application Load Balancer o un Network Load Balancer. In questa esercitazione viene utilizzato un Application Load Balancer.

Per creare un Application Load Balancer

  1. Utilizzate il create-load-balancercomando per creare un Application Load Balancer. Specificare due sottoreti che non appartengono alla stessa zona di disponibilità, nonché un gruppo di sicurezza.

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

    L'output include l'Amazon Resource Name (ARN) del load balancer, con il seguente formato:

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

  2. Usa il create-target-groupcomando per creare un gruppo target. Questo gruppo target instraderà il traffico verso il set di attività originale nel servizio.

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

    L'output include ARN il gruppo target, con il seguente formato:

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

  3. Utilizzare il comando create-listener per creare un listener del load balancer con una regola predefinita che inoltra le richieste al gruppo target.

    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

    L'output include il file ARN del listener, con il seguente formato:

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

Fase 2: Creare un ECS cluster Amazon

Utilizzare il comando create-cluster per creare un cluster denominato tutorial-bluegreen-cluster da utilizzare.

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

L'output include ARN il cluster, con il seguente formato:

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

Fase 3: Registra una definizione di attività

Utilizzate il register-task-definitioncomando per registrare una definizione di attività compatibile con Fargate. Devi usare la modalità di rete awsvpc. Di seguito è riportata la definizione di attività di esempio usata per questo tutorial.

Crea innanzitutto un file denominato fargate-task.json con i seguenti contenuti. Assicuratevi di utilizzare il ARN per il vostro ruolo di esecuzione delle attività. Per ulteriori informazioni, consulta IAMRuolo di esecuzione delle ECS attività di 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"
}

Quindi, registra la definizione di attività utilizzando il file fargate-task.json creato.

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

Fase 4: Creare un ECS servizio Amazon

Utilizza il comando create-service per creare un servizio.

Crea innanzitutto un file denominato service-bluegreen.json con i seguenti contenuti.

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

Quindi, crea il servizio utilizzando il file service-bluegreen.json creato.

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

L'output include ARN il servizio, con il seguente formato:

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

DNSOttenete il nome del load balancer utilizzando il seguente comando. 

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

Inserisci il DNS nome nel tuo browser web e dovresti vedere una pagina web che mostra l'app di esempio con uno sfondo blu.

Fase 5: Creazione delle risorse AWS CodeDeploy

Utilizza i seguenti passaggi per creare CodeDeploy l'applicazione, il gruppo target Application Load Balancer per il gruppo di CodeDeploy distribuzione e il gruppo di CodeDeploy distribuzione.

Per creare risorse CodeDeploy

  1. Utilizzate il comando create-application per creare un' CodeDeploy applicazione. Specificare la piattaforma di calcolo ECS.

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

    L'output include l'ID applicazione, con il formato seguente:

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

  2. Utilizzate il create-target-groupcomando per creare un secondo gruppo target di Application Load Balancer, che verrà utilizzato durante la creazione del gruppo di CodeDeploy distribuzione.

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

    L'output include il ARN per il gruppo target, con il seguente formato:

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

  3. Utilizzate il create-deployment-groupcomando per creare un gruppo CodeDeploy di distribuzione.

    Crea innanzitutto un file denominato tutorial-deployment-group.json con i seguenti contenuti. Questo esempio utilizza la risorsa che è stata creata. Per ilserviceRoleArn, specifica ARN il tuo ECS CodeDeploy IAM ruolo Amazon. Per ulteriori informazioni, consulta ECS CodeDeploy IAMRuolo di 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"
       }
   ]
}

    Quindi crea il gruppo CodeDeploy di distribuzione.

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

    L'output include l'ID del gruppo di distribuzione, con il formato seguente:

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

Fase 6: Creare e monitorare una CodeDeploy distribuzione

Prima di creare una CodeDeploy distribuzione, aggiorna la definizione command dell'attività fargate-task.json come segue per modificare il colore di sfondo dell'app di esempio in verde.

{
    ...
        "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\""
                ]
            }
        ],
       ...
}

Registra la definizione di attività aggiornata utilizzando il comando seguente. 

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

Ora, utilizzate i seguenti passaggi per creare e caricare un file di specifiche dell'applicazione (AppSpec file) e una CodeDeploy distribuzione.

Per creare e monitorare una CodeDeploy distribuzione

  1. Crea e carica un AppSpec file utilizzando i seguenti passaggi.

    1. Crea un file denominato appspec.yaml con il contenuto del gruppo di CodeDeploy distribuzione. Questo esempio utilizza la definizione di attività aggiornata.

      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. Usa il comando s3 mb per creare un bucket Amazon S3 per il file. AppSpec 

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

    3. Usa il comando s3 cp per caricare il AppSpec file nel bucket Amazon S3.

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

  2. Crea la CodeDeploy distribuzione utilizzando i seguenti passaggi.

    1. Crea un file denominato create-deployment.json con il contenuto della CodeDeploy distribuzione. Questo esempio utilizza le risorse create in precedenza nel tutorial.

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

    2. Utilizzare il comando create-deployment per creare l'implementazione.

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

      L'output include l'ID di distribuzione, con il formato seguente:

      {
    "deploymentId": "d-RPCR1U3TW"
}

  3. Utilizzate il get-deployment-targetcomando per ottenere i dettagli della distribuzione, specificando l'deploymentIdoutput precedente.

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

    Inizialmente, lo stato dell'implementazione è InProgress. Il traffico viene indirizzato al set di attività originale, che presenta taskSetLabel con valore BLUE, uno stato PRIMARY e un trafficWeight di 100.0. Il set di attività di sostituzione ha taskSetLabel con valore GREEN, uno stato ACTIVE e un trafficWeight di 0.0. Il browser Web in cui hai inserito il DNS nome mostra ancora l'app di esempio con uno sfondo blu.

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

    Continua a recuperare i dettagli di implementazione utilizzando il comando fino a quando lo stato è Succeeded, come mostrato nel seguente output. Il traffico viene ora instradato al set di attività di sostituzione, che presenta uno stato PRIMARY e un trafficWeight di 100.0. Aggiorna il browser web in cui hai inserito il DNS nome del load balancer e ora dovresti vedere l'app di esempio con uno sfondo verde.

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

Fase 7: pulire

Una volta terminato questo tutorial, rimuovi le risorse associate per evitare costi aggiuntivi per risorse che non utilizzi.

Rimozione delle risorse del tutorial

  1. Usa il delete-deployment-groupcomando per eliminare il gruppo di CodeDeploy distribuzione.

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

  2. Utilizzate il comando delete-application per eliminare l' CodeDeploy applicazione.

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

  3. Utilizza il comando delete-service per eliminare il servizio AmazonECS. L'uso del flag --force consente di eliminare un servizio anche se il numero di attività non è stato ridotto a zero.

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

  4. Utilizza il comando delete-cluster per eliminare il cluster AmazonECS.

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

  5. Usa il comando s3 rm per eliminare il AppSpec file dal bucket Amazon S3.

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

  6. Utilizza il comando s3 rb per eliminare il bucket Amazon S3.

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

  7. Utilizzate il delete-load-balancercomando per eliminare 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. Utilizzate il delete-target-groupcomando per eliminare i due gruppi target di 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