Effectuez des déploiements d'ECS bleu/vert en utilisant CodeDeploy AWS CloudFormation

Vous pouvez l'utiliser CloudFormation pour effectuer des déploiements d'ECS bleu/vert via. AWS CodeDeploy Les déploiements bleu/vert constituent une stratégie de déploiement sûre fournie CodeDeploy pour minimiser les interruptions causées par le changement de version des applications. Ceci est accompli en créant votre nouvel environnement d'application, appelé vert, à côté de votre application actuelle qui dessert votre trafic en direct, appelé bleu. Cela permet pendant un temps donné de surveiller et tester l'environnement vert avant que votre trafic en direct ne soit acheminé du bleu au vert et, par la suite, arrête les ressources bleues.

Lorsque vous effectuez des déploiements ECS bleu/vert, vous commencez par créer un modèle de pile qui définit les ressources pour vos environnements d'applications bleus et verts, notamment en spécifiant les paramètres de routage et de stabilisation du trafic à utiliser CloudFormation . Ensuite, vous créez une pile à partir de ce modèle ; cela génère votre application bleue (actuelle). CloudFormationcrée uniquement les ressources bleues lors de la création de la pile. Les ressources pour un déploiement vert ne sont pas créées tant qu'elles ne sont pas requises.

Ensuite, si, lors d'une future mise à jour de la pile, vous mettez à jour la définition des tâches ou les ressources de l'ensemble de tâches dans votre application CloudFormation bleue, procédez comme suit :

• Génère toutes les ressources d'environnement d'applications « vertes » nécessaires.

• Déplace le trafic en fonction des paramètres de routage de trafic spécifiés.

• Supprime les ressources « bleu »

Si une erreur survient à un moment quelconque avant que le déploiement écologique ne soit réussi et CloudFormation finalisé, rétablit la pile dans son état antérieur au lancement complet du déploiement écologique.

Pour permettre CloudFormation d'effectuer des déploiements bleu/vert sur une pile, incluez les informations suivantes dans son modèle de pile :

• Une section Transform de votre modèle qui appelle la transformation AWS::CodeDeployBlueGreen et une section Hook qui appelle le hook AWS::CodeDeploy::BlueGreen.

• Au moins une des ressources ECS qui déclenche un déploiement bleu/vert si elle est remplacée lors d'une mise à jour de pile. Actuellement, ces ressources sont AWS::ECS::TaskDefinition et AWS::ECS::TaskSet.

Ensuite, si vous lancez une mise à jour de la pile qui met à jour les propriétés des ressources ci-dessus nécessitant CloudFormation le remplacement de la ressource, CloudFormation effectue un déploiement bleu/vert comme décrit ci-dessus. Pour plus d'informations sur le comportement de mise à jour des ressources, consultez Comportements de mise à jour des ressources d'une pile.

Dans certains cas, vous devrez configurer votre modèle de pile pour activer les déploiements bleu/vert avant de créer la pile. Cependant, vous pouvez également ajouter la possibilité d' CloudFormation effectuer des déploiements bleu/vert sur une pile existante. Pour ce faire, ajoutez les informations nécessaires au modèle existant de la pile.

En outre, nous vous recommandons de CloudFormation générer un ensemble de modifications pour le déploiement écologique avant de lancer la mise à jour de la pile. Cela vous permet de vérifier les modifications réelles qui seront apportées à la pile. Pour plus d’informations, consultez Mise à jour des piles à l'aide de jeux de modifications.

Modélisation de votre déploiement bleu/vert à l'aide de ressources CloudFormation

Pour effectuer un déploiement bleu/vert d'ECS à l'aide de CodeDeploy through CloudFormation, votre modèle doit inclure les ressources qui modélisent votre déploiement, telles qu'un service Amazon ECS et un équilibreur de charge. Pour de plus amples informations sur ce que représentent ces ressources, veuillez consulter Avant de commencer un déploiement Amazon ECS dans le Guide de l'utilisateur AWS CodeDeploy .

Exigence	Ressource	Obligatoire/facultatif	Déclenche le déploiement bleu/vert en cas de remplacement
Cluster Amazon ECS	AWS::ECS::Cluster	Facultatif. Le cluster par défaut peut être utilisé.	Non
Amazon ECS service	AWS::ECS::Service	Obligatoire.	Non
Application Load Balancer ou Network Load Balancer	AWS::ECS::Service LoadBalancer	Obligatoire.	Non
Écouteur de production	AWS::ElasticLoadBalancingV2::Listener	Obligatoire.	Non
Écouteur de test	AWS::ElasticLoadBalancingV2::Listener	Facultatif.	Non
Deux groupes cibles	AWS::ElasticLoadBalancingV2::TargetGroup	Obligatoire.	Non
Définition de tâche Amazon ECS	AWS::ECS::TaskDefinition	Obligatoire.	Oui
Conteneur de votre application Amazon ECS	AWS::ECS::TaskDefinition ContainerDefinition Name	Obligatoire.	Non
Port de votre ensemble de tâches de remplacement	AWS::ECS::TaskDefinition PortMapping ContainerPort	Obligatoire.	Non

Mises à jour des ressources qui déclenchent des déploiements verts

Si vous effectuez une mise à jour de la pile qui met à jour toute propriété nécessitant le remplacement des ressources ECS suivantes, CloudFormation lancez un déploiement écologique :

• AWS::ECS::TaskDefinition

• AWS::ECS::TaskSet

La mise à jour de propriétés dans ces ressources qui ne nécessitent pas de remplacement de ressource ne déclenche pas de déploiement vert.

Vous ne pouvez pas inclure les mises à jour des ressources ci-dessus avec les mises à jour d'autres ressources dans la même mise à jour de pile. Si vous devez mettre à jour des ressources dans la liste ci-dessus ainsi que d'autres ressources dans la même pile, effectuez l'une des opérations suivantes :

• Effectuez deux opérations de mise à jour de pile distinctes : l'une qui inclut uniquement les mises à jour des ressources ci-dessus et l'autre qui inclut les modifications apportées à d'autres ressources.

• Supprimez les sections Hook Transform de votre modèle, puis effectuez la mise à jour de la pile. Dans ce cas, CloudFormation n'effectuera pas de déploiement écologique.

Considérations relatives à la gestion des déploiements bleu/vert d'ECS à l'aide de CloudFormation

Vous devez tenir compte des points suivants lorsque vous définissez votre déploiement bleu/vert à l'aide de : CloudFormation

• Seules les mises à jour de certaines ressources déclencheront un déploiement écologique, comme indiqué dansMises à jour des ressources qui déclenchent des déploiements verts.

• Vous ne pouvez pas inclure de mises à jour de ressources qui initient des déploiements écologiques ni de mises à jour d'autres ressources dans la même mise à jour de la pile, comme indiqué dansMises à jour des ressources qui déclenchent des déploiements verts.

• Vous ne pouvez spécifier qu'un seul service ECS comme cible de déploiement.

• Les paramètres dont les valeurs sont masquées ne CloudFormation peuvent pas être mis à jour par le CodeDeploy service lors d'un déploiement écologique, ce qui entraînera une erreur et un échec de la mise à jour de la pile. Il s'agit des licences suivantes :

  • Paramètres définis avec l'attribut NoEcho.

  • Paramètres qui utilisent des références dynamiques pour récupérer leurs valeurs à partir de services externes. Pour plus d’informations, consultez Spécifiez les valeurs stockées dans d'autres services à l'aide de références dynamiques.

• Pour annuler un déploiement écologique toujours en cours, annulez la mise à jour de la pile dans CloudFormation CodeDeploy ou pas dans ECS. Pour plus d’informations, consultez Annulation d'une mise à jour de la pile. (Une fois qu'une mise à jour est terminée, vous ne pouvez plus l'annuler. Vous pouvez, toutefois, mettre à jour à nouveau une pile afin de rétablir les paramètres précédents.)

• La déclaration Outputs ou l'utilisation Fn::ImportValue pour importer des valeurs depuis d'autres piles n'est actuellement pas prise en charge pour les modèles définissant des déploiements ECS bleu/vert.

• Intégrer les ressources existantes à CloudFormation la gestionn'est actuellement pas pris en charge pour les modèles définissant des déploiements ECS bleu/vert.

• Vous ne pouvez pas utiliser le hook AWS::CodeDeploy::BlueGreen dans un modèle qui inclut des ressources de pile imbriquées.

• Vous ne pouvez pas utiliser le hook AWS::CodeDeploy::BlueGreendans une pile imbriquée.

Lorsque vous avez l' CloudFormation habitude d'effectuer vos déploiements bleus et verts ECS CodeDeploy, le processus est différent de celui d'un déploiement Amazon ECS standard utilisant uniquement. CodeDeploy Pour plus d'informations, consultez la section Différences entre les déploiements bleu/vert d'Amazon ECS AWS CloudFormation dans CodeDeploy et dans le guide de l'AWS CodeDeploy utilisateur.

Préparation de votre modèle pour effectuer des déploiements ECS bleu/vert

Pour activer les déploiements bleu/vert sur votre pile, incluez les sections suivantes dans votre modèle de pile avant d'effectuer une mise à jour de pile.

• Ajoutez une référence à la transformation AWS::CodeDeployBlueGreen dans votre modèle :

      "Transform": [
          "AWS::CodeDeployBlueGreen"
      ],

• Ajoutez une section Hook qui appelle le hook AWS::CodeDeploy::BlueGreen et spécifie les propriétés de votre déploiement. Utilisez la référence du modèle ci-dessous comme guide.

• Dans la section Resources, définissez les ressources bleues et vertes pour votre déploiement.

Vous pouvez ajouter ces sections lorsque vous créez le modèle pour la première fois (c'est-à-dire avant de créer la pile elle-même), ou vous pouvez les ajouter à un modèle existant avant d'effectuer une mise à jour de la pile. Si vous spécifiez le déploiement bleu/vert pour une nouvelle pile, les ressources bleues CloudFormation ne sont créées que lors de la création de la pile. Les ressources pour le déploiement vert ne sont créées que lorsqu'elles sont requises lors d'une mise à jour de la pile.

Examen des jeux de modifications pour votre déploiement bleu/vert

Nous vous recommandons fortement de créer un jeu de modifications avant d'effectuer une mise à jour de pile qui initiera un déploiement vert. Cela vous permet de voir les modifications réelles qui seront apportées à votre pile avant d'effectuer la mise à jour de la pile. Sachez que les modifications de ressources peuvent ne pas être répertoriées dans l'ordre dans lequel elles seront effectuées lors de la mise à jour de la pile. Pour plus d’informations, consultez Mise à jour des piles à l'aide de jeux de modifications.

Affichage des événements de pile pour votre déploiement bleu/vert

Vous pouvez afficher les événements de pile générés à chaque étape du déploiement ECS dans l'onglet Events (Événements) de la page Pile et à l'aide de l' AWS CLI. Pour plus d’informations, consultez Surveillance de la progression de la mise à jour d'une pile.

Référence de modèles

"Hooks": {
  "Logical ID": {
    "Properties": {
      "TrafficRoutingConfig": {
        "Type": "Traffic routing type",
        "TimeBasedCanary": {
          "StepPercentage": Integer,
          "BakeTimeMins": Integer
        },
        "TimeBasedLinear": {
          "StepPercentage": Integer,
          "BakeTimeMins": Integer
        }
      },
      "AdditionalOptions": {"TerminationWaitTimeInMinutes": Integer},
      "LifecycleEventHooks": {
        "BeforeInstall": "FunctionName",
        "AfterInstall": "FunctionName",
        "AfterAllowTestTraffic": "FunctionName",
        "BeforeAllowTraffic": "FunctionName",
        "AfterAllowTraffic": "FunctionName"
      },
      "ServiceRole": "CodeDeployServiceRoleName",
      "Applications": [
        {
          "Target": {
            "Type": "AWS::ECS::Service",
            "LogicalID": "Resource Logical ID"
          },
          "ECSAttributes": {
            "TaskDefinitions": [
              "AWS::ECS::TaskDefinition Resource Logical ID (Blue)",
              "AWS::ECS::TaskDefinition Resource Logical ID (Green)"
            ],
            "TaskSets": [
              "AWS::ECS::TaskSet Resource Logical ID (Blue)",
              "AWS::ECS::TaskSet Resource Logical ID (Green)"
            ],
            "TrafficRouting": {
              "ProdTrafficRoute": {
                "Type": "AWS::ElasticLoadBalancingV2::Listener",
                "LogicalID": "Resource Logical ID (Production)"
              },
              "TestTrafficRoute": {
                "Type": "AWS::ElasticLoadBalancingV2::Listener",
                "LogicalID": "Resource Logical ID (Test)"
              },
              "TargetGroups": [
                "AWS::ElasticLoadBalancingV2::TargetGroup Resource Logical ID (Blue)",
                "AWS::ElasticLoadBalancingV2::TargetGroup Resource Logical ID (Green)"
              ]
            }
          }
        }
      ]
    },
    "Type": "AWS::CodeDeploy::BlueGreen"
  }
}

Propriétés

Logical ID

L'ID logique doit être alphanumérique (A-Za-z0-9) et ne doit correspondre à aucun autre ID logique dans le modèle.

Obligatoire : oui

Properties

Propriétés du hook.

Obligatoire : oui

TrafficRoutingConfig

Paramètres de configuration du routage du trafic.

Obligatoire : non

La configuration par défaut est le déplacement du trafic Canary basé sur le temps, avec un pourcentage d'étape de 15 % et un temps d'attente de cinq minutes.

Type

Type de déplacement de trafic utilisé par la configuration de déploiement.

Valeurs valides : AllAtOnce | TimeBasedCanary | TimeBasedLinear

Obligatoire : oui

TimeBasedCanary

Spécifie une configuration qui déplace le trafic d'une version du déploiement vers une autre en deux incréments.

Requis : sous certaines conditions. Si vous spécifiez TimeBasedCanary comme type de routage du trafic, vous devez inclure le paramètre TimeBasedCanary.

StepPercentage

Pourcentage de trafic à déplacer dans le premier incrément d'un déploiement TimeBasedCanary. Le pourcentage d'étape doit être de 14 % ou plus.

Obligatoire : non

BakeTimeMins

Nombre de minutes entre les premier et deuxième déplacements de trafic d'un déploiement TimeBasedCanary.

Obligatoire : non

TimeBasedLinear

Spécifie une configuration qui déplace le trafic d'une version du déploiement vers une autre par incréments égaux, avec un nombre égal de minutes entre chaque incrément.

Requis : sous certaines conditions. Si vous spécifiez TimeBasedLinear comme type de routage du trafic, vous devez inclure le paramètre TimeBasedLinear.

StepPercentage

Pourcentage de trafic déplacé au début de chaque incrément d'un déploiement TimeBasedLinear. Le pourcentage d'étape doit être de 14 % ou plus.

Obligatoire : non

BakeTimeMins

Nombre de minutes entre chaque déplacement de trafic incrémentiel d'un déploiement TimeBasedLinear.

Obligatoire : non

AdditionalOptions

Options supplémentaires pour le déploiement bleu/vert.

Obligatoire : non

TerminationWaitTimeInMinutes

Spécifie le temps d'attente, en minutes, avant de mettre fin aux ressources bleues.

Obligatoire : non

LifecycleEventHooks

Utilisez les hooks d'événements du cycle de vie pour spécifier une fonction Lambda CodeDeploy pouvant être appelée pour valider un déploiement. Vous pouvez utiliser la même fonction ou une autre fonction pour les événements du cycle de vie du déploiement. Une fois les tests de validation terminés, la AfterAllowTraffic fonction Lambda rappelle CodeDeploy et fournit un résultat de Succeeded ou. Failed

Pour plus d'informations, consultez la section « crochets AppSpec  » du guide de l'AWS CodeDeploy utilisateur.

Obligatoire : non

BeforeInstall

Fonction permettant d'exécuter des tâches avant que l'ensemble des tâches de remplacement ne soit créé.

Obligatoire : non

AfterInstall

Fonction permettant d'exécuter des tâches après que l'ensemble des tâches de remplacement a été créé et que l'un des groupes cibles lui a été associé.

Obligatoire : non

AfterAllowTestTraffic

Fonction permettant d'exécuter des tâches après que l'écouteur de test a dirigé le trafic vers l'ensemble des tâches de remplacement.

Obligatoire : non

BeforeAllowTraffic

Fonction permettant d'exécuter des tâches après l'association du second groupe cible avec l'ensemble des tâches de remplacement, mais avant que le trafic ne soit déplacé vers ce dernier.

Obligatoire : non

AfterAllowTraffic

Fonction permettant d'exécuter des tâches une fois que le second groupe cible a dirigé le trafic vers l'ensemble des tâches de remplacement.

Obligatoire : non

ServiceRole

Le rôle d'exécution CloudFormation à utiliser pour effectuer les déploiements bleu-vert. Pour obtenir la liste des autorisations nécessaires, consultezAutorisations IAM nécessaires pour les déploiements bleu/vert.

Obligatoire : oui

Applications

Spécifie les propriétés de l'application Amazon ECS.

Obligatoire : oui

Target

Obligatoire : oui

Type

Type de la ressource.

Obligatoire : oui

LogicalID

ID logique de la ressource.

Obligatoire : oui

ECSAttributes

Ressources qui représentent les différentes exigences du déploiement de votre application Amazon ECS.

Obligatoire : oui

TaskDefinitions

ID logique de la ressource AWS::ECS::TaskDefinition pour exécuter le conteneur Docker qui contient votre application Amazon ECS.

Obligatoire : oui

TaskSets

ID logiques des ressources AWS::ECS::TaskSet à utiliser comme ensembles de tâches pour l'application.

Obligatoire : oui

TrafficRouting

Spécifie les ressources utilisées pour le routage du trafic.

Obligatoire : oui

ProdTrafficRoute

Un écouteur est utilisé par votre équilibreur de charge pour diriger le trafic vers vos groupes cibles.

Obligatoire : oui

Type

Type de la ressource. AWS::ElasticLoadBalancingV2::Listener

Obligatoire : oui

LogicalID

ID logique de la ressource.

Obligatoire : oui

TestTrafficRoute

Un écouteur est utilisé par votre équilibreur de charge pour diriger le trafic vers vos groupes cibles.

Obligatoire : oui

Type

Type de la ressource. AWS::ElasticLoadBalancingV2::Listener

Obligatoire : oui

LogicalID

ID logique de la ressource.

Obligatoire : non

TargetGroups

ID logique des ressources à utiliser comme groupes cibles pour acheminer le trafic vers la cible enregistrée.

Obligatoire : oui

Type

Type de hook. AWS::ElasticLoadBalancingV2::Listener

Obligatoire : oui

Autorisations IAM nécessaires pour les déploiements bleu/vert

CloudFormation Pour effectuer avec succès les déploiements bleu-vert, vous devez disposer des autorisations suivantes : CodeDeploy

• codedeploy:Get*

• codedeploy:CreateCloudFormationDeployment

Pour plus d'informations, consultez la section Actions, ressources et clés de CodeDeploy condition du guide de l'utilisateur AWS d'Identity and Access Management.

Exemple de modèle

L'exemple suivant met en place un déploiement d'ECS bleu/vert CodeDeploy, avec une progression du routage du trafic de 15 % par étape, avec une période de stabilisation de 5 minutes entre chaque étape. La création d'une pile avec le modèle permet d'allouer la configuration initiale du déploiement.

Si vous apportez ensuite des modifications aux propriétés de la "BlueTaskSet" ressource qui nécessitent son remplacement, vous CloudFormation lancerez un déploiement écologique dans le cadre de la mise à jour de la pile.

JSON

{
    "Parameters": {
        "Vpc": {
            "Type": "AWS::EC2::VPC::Id"
        },
        "Subnet1": {
            "Type": "AWS::EC2::Subnet::Id"
        },
        "Subnet2": {
            "Type": "AWS::EC2::Subnet::Id"
        }
    },
    "Transform": [
        "AWS::CodeDeployBlueGreen"
    ],
    "Hooks": {
        "CodeDeployBlueGreenHook": {
            "Properties": {
                "TrafficRoutingConfig": {
                    "Type": "TimeBasedCanary",
                    "TimeBasedCanary": {
                        "StepPercentage": 15,
                        "BakeTimeMins": 5
                    }
                },
                "Applications": [
                    {
                        "Target": {
                            "Type": "AWS::ECS::Service",
                            "LogicalID": "ECSDemoService"
                        },
                        "ECSAttributes": {
                            "TaskDefinitions": [
                                "BlueTaskDefinition",
                                "GreenTaskDefinition"
                            ],
                            "TaskSets": [
                                "BlueTaskSet",
                                "GreenTaskSet"
                            ],
                            "TrafficRouting": {
                                "ProdTrafficRoute": {
                                    "Type": "AWS::ElasticLoadBalancingV2::Listener",
                                    "LogicalID": "ALBListenerProdTraffic"
                                },
                                "TargetGroups": [
                                    "ALBTargetGroupBlue",
                                    "ALBTargetGroupGreen"
                                ]
                            }
                        }
                    }
                ]
            },
            "Type": "AWS::CodeDeploy::BlueGreen"
        }
    },
    "Resources": {
        "ExampleSecurityGroup": {
            "Type": "AWS::EC2::SecurityGroup",
            "Properties": {
                "GroupDescription": "Security group for ec2 access",
                "VpcId": {
                    "Ref": "Vpc"
                },
                "SecurityGroupIngress": [
                    {
                        "IpProtocol": "tcp",
                        "FromPort": 80,
                        "ToPort": 80,
                        "CidrIp": "0.0.0.0/0"
                    },
                    {
                        "IpProtocol": "tcp",
                        "FromPort": 8080,
                        "ToPort": 8080,
                        "CidrIp": "0.0.0.0/0"
                    },
                    {
                        "IpProtocol": "tcp",
                        "FromPort": 22,
                        "ToPort": 22,
                        "CidrIp": "0.0.0.0/0"
                    }
                ]
            }
        },
        "ALBTargetGroupBlue": {
            "Type": "AWS::ElasticLoadBalancingV2::TargetGroup",
            "Properties": {
                "HealthCheckIntervalSeconds": 5,
                "HealthCheckPath": "/",
                "HealthCheckPort": "80",
                "HealthCheckProtocol": "HTTP",
                "HealthCheckTimeoutSeconds": 2,
                "HealthyThresholdCount": 2,
                "Matcher": {
                    "HttpCode": "200"
                },
                "Port": 80,
                "Protocol": "HTTP",
                "Tags": [
                    {
                        "Key": "Group",
                        "Value": "Example"
                    }
                ],
                "TargetType": "ip",
                "UnhealthyThresholdCount": 4,
                "VpcId": {
                    "Ref": "Vpc"
                }
            }
        },
        "ALBTargetGroupGreen": {
            "Type": "AWS::ElasticLoadBalancingV2::TargetGroup",
            "Properties": {
                "HealthCheckIntervalSeconds": 5,
                "HealthCheckPath": "/",
                "HealthCheckPort": "80",
                "HealthCheckProtocol": "HTTP",
                "HealthCheckTimeoutSeconds": 2,
                "HealthyThresholdCount": 2,
                "Matcher": {
                    "HttpCode": "200"
                },
                "Port": 80,
                "Protocol": "HTTP",
                "Tags": [
                    {
                        "Key": "Group",
                        "Value": "Example"
                    }
                ],
                "TargetType": "ip",
                "UnhealthyThresholdCount": 4,
                "VpcId": {
                    "Ref": "Vpc"
                }
            }
        },
        "ExampleALB": {
            "Type": "AWS::ElasticLoadBalancingV2::LoadBalancer",
            "Properties": {
                "Scheme": "internet-facing",
                "SecurityGroups": [
                    {
                        "Ref": "ExampleSecurityGroup"
                    }
                ],
                "Subnets": [
                    {
                        "Ref": "Subnet1"
                    },
                    {
                        "Ref": "Subnet2"
                    }
                ],
                "Tags": [
                    {
                        "Key": "Group",
                        "Value": "Example"
                    }
                ],
                "Type": "application",
                "IpAddressType": "ipv4"
            }
        },
        "ALBListenerProdTraffic": {
            "Type": "AWS::ElasticLoadBalancingV2::Listener",
            "Properties": {
                "DefaultActions": [
                    {
                        "Type": "forward",
                        "ForwardConfig": {
                            "TargetGroups": [
                                {
                                    "TargetGroupArn": {
                                        "Ref": "ALBTargetGroupBlue"
                                    },
                                    "Weight": 1
                                }
                            ]
                        }
                    }
                ],
                "LoadBalancerArn": {
                    "Ref": "ExampleALB"
                },
                "Port": 80,
                "Protocol": "HTTP"
            }
        },
        "ALBListenerProdRule": {
            "Type": "AWS::ElasticLoadBalancingV2::ListenerRule",
            "Properties": {
                "Actions": [
                    {
                        "Type": "forward",
                        "ForwardConfig": {
                            "TargetGroups": [
                                {
                                    "TargetGroupArn": {
                                        "Ref": "ALBTargetGroupBlue"
                                    },
                                    "Weight": 1
                                }
                            ]
                        }
                    }
                ],
                "Conditions": [
                    {
                        "Field": "http-header",
                        "HttpHeaderConfig": {
                            "HttpHeaderName": "User-Agent",
                            "Values": [
                                "Mozilla"
                            ]
                        }
                    }
                ],
                "ListenerArn": {
                    "Ref": "ALBListenerProdTraffic"
                },
                "Priority": 1
            }
        },
        "ECSTaskExecutionRole": {
            "Type": "AWS::IAM::Role",
            "Properties": {
                "AssumeRolePolicyDocument": {
                    "Version": "2012-10-17",
                    "Statement": [
                        {
                            "Sid": "",
                            "Effect": "Allow",
                            "Principal": {
                                "Service": "ecs-tasks.amazonaws.com"
                            },
                            "Action": "sts:AssumeRole"
                        }
                    ]
                },
                "ManagedPolicyArns": [
                    "arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy"
                ]
            }
        },
        "BlueTaskDefinition": {
            "Type": "AWS::ECS::TaskDefinition",
            "Properties": {
                "ExecutionRoleArn": {
                    "Fn::GetAtt": [
                        "ECSTaskExecutionRole",
                        "Arn"
                    ]
                },
                "ContainerDefinitions": [
                    {
                        "Name": "DemoApp",
                        "Image": "nginxdemos/hello:latest",
                        "Essential": true,
                        "PortMappings": [
                            {
                                "HostPort": 80,
                                "Protocol": "tcp",
                                "ContainerPort": 80
                            }
                        ]
                    }
                ],
                "RequiresCompatibilities": [
                    "FARGATE"
                ],
                "NetworkMode": "awsvpc",
                "Cpu": "256",
                "Memory": "512",
                "Family": "ecs-demo"
            }
        },
        "ECSDemoCluster": {
            "Type": "AWS::ECS::Cluster",
            "Properties": {}
        },
        "ECSDemoService": {
            "Type": "AWS::ECS::Service",
            "Properties": {
                "Cluster": {
                    "Ref": "ECSDemoCluster"
                },
                "DesiredCount": 1,
                "DeploymentController": {
                    "Type": "EXTERNAL"
                }
            }
        },
        "BlueTaskSet": {
            "Type": "AWS::ECS::TaskSet",
            "Properties": {
                "Cluster": {
                    "Ref": "ECSDemoCluster"
                },
                "LaunchType": "FARGATE",
                "NetworkConfiguration": {
                    "AwsVpcConfiguration": {
                        "AssignPublicIp": "ENABLED",
                        "SecurityGroups": [
                            {
                                "Ref": "ExampleSecurityGroup"
                            }
                        ],
                        "Subnets": [
                            {
                                "Ref": "Subnet1"
                            },
                            {
                                "Ref": "Subnet2"
                            }
                        ]
                    }
                },
                "PlatformVersion": "1.4.0",
                "Scale": {
                    "Unit": "PERCENT",
                    "Value": 100
                },
                "Service": {
                    "Ref": "ECSDemoService"
                },
                "TaskDefinition": {
                    "Ref": "BlueTaskDefinition"
                },
                "LoadBalancers": [
                    {
                        "ContainerName": "DemoApp",
                        "ContainerPort": 80,
                        "TargetGroupArn": {
                            "Ref": "ALBTargetGroupBlue"
                        }
                    }
                ]
            }
        },
        "PrimaryTaskSet": {
            "Type": "AWS::ECS::PrimaryTaskSet",
            "Properties": {
                "Cluster": {
                    "Ref": "ECSDemoCluster"
                },
                "Service": {
                    "Ref": "ECSDemoService"
                },
                "TaskSetId": {
                    "Fn::GetAtt": [
                        "BlueTaskSet",
                        "Id"
                    ]
                }
            }
        }
    }
}

YAML

Parameters:
  Vpc:
    Type: 'AWS::EC2::VPC::Id'
  Subnet1:
    Type: 'AWS::EC2::Subnet::Id'
  Subnet2:
    Type: 'AWS::EC2::Subnet::Id'
Transform:
  - 'AWS::CodeDeployBlueGreen'
Hooks:
  CodeDeployBlueGreenHook:
    Properties:
      TrafficRoutingConfig:
        Type: TimeBasedCanary
        TimeBasedCanary:
          StepPercentage: 15
          BakeTimeMins: 5
      Applications:
        - Target:
            Type: 'AWS::ECS::Service'
            LogicalID: ECSDemoService
          ECSAttributes:
            TaskDefinitions:
              - BlueTaskDefinition
              - GreenTaskDefinition
            TaskSets:
              - BlueTaskSet
              - GreenTaskSet
            TrafficRouting:
              ProdTrafficRoute:
                Type: 'AWS::ElasticLoadBalancingV2::Listener'
                LogicalID: ALBListenerProdTraffic
              TargetGroups:
                - ALBTargetGroupBlue
                - ALBTargetGroupGreen
    Type: 'AWS::CodeDeploy::BlueGreen'
Resources:
  ExampleSecurityGroup:
    Type: 'AWS::EC2::SecurityGroup'
    Properties:
      GroupDescription: Security group for ec2 access
      VpcId: !Ref Vpc
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: 80
          ToPort: 80
          CidrIp: 0.0.0.0/0
        - IpProtocol: tcp
          FromPort: 8080
          ToPort: 8080
          CidrIp: 0.0.0.0/0
        - IpProtocol: tcp
          FromPort: 22
          ToPort: 22
          CidrIp: 0.0.0.0/0
  ALBTargetGroupBlue:
    Type: 'AWS::ElasticLoadBalancingV2::TargetGroup'
    Properties:
      HealthCheckIntervalSeconds: 5
      HealthCheckPath: /
      HealthCheckPort: '80'
      HealthCheckProtocol: HTTP
      HealthCheckTimeoutSeconds: 2
      HealthyThresholdCount: 2
      Matcher:
        HttpCode: '200'
      Port: 80
      Protocol: HTTP
      Tags:
        - Key: Group
          Value: Example
      TargetType: ip
      UnhealthyThresholdCount: 4
      VpcId: !Ref Vpc
  ALBTargetGroupGreen:
    Type: 'AWS::ElasticLoadBalancingV2::TargetGroup'
    Properties:
      HealthCheckIntervalSeconds: 5
      HealthCheckPath: /
      HealthCheckPort: '80'
      HealthCheckProtocol: HTTP
      HealthCheckTimeoutSeconds: 2
      HealthyThresholdCount: 2
      Matcher:
        HttpCode: '200'
      Port: 80
      Protocol: HTTP
      Tags:
        - Key: Group
          Value: Example
      TargetType: ip
      UnhealthyThresholdCount: 4
      VpcId: !Ref Vpc
  ExampleALB:
    Type: 'AWS::ElasticLoadBalancingV2::LoadBalancer'
    Properties:
      Scheme: internet-facing
      SecurityGroups:
        - !Ref ExampleSecurityGroup
      Subnets:
        - !Ref Subnet1
        - !Ref Subnet2
      Tags:
        - Key: Group
          Value: Example
      Type: application
      IpAddressType: ipv4
  ALBListenerProdTraffic:
    Type: 'AWS::ElasticLoadBalancingV2::Listener'
    Properties:
      DefaultActions:
        - Type: forward
          ForwardConfig:
            TargetGroups:
              - TargetGroupArn: !Ref ALBTargetGroupBlue
                Weight: 1
      LoadBalancerArn: !Ref ExampleALB
      Port: 80
      Protocol: HTTP
  ALBListenerProdRule:
    Type: 'AWS::ElasticLoadBalancingV2::ListenerRule'
    Properties:
      Actions:
        - Type: forward
          ForwardConfig:
            TargetGroups:
              - TargetGroupArn: !Ref ALBTargetGroupBlue
                Weight: 1
      Conditions:
        - Field: http-header
          HttpHeaderConfig:
            HttpHeaderName: User-Agent
            Values:
              - Mozilla
      ListenerArn: !Ref ALBListenerProdTraffic
      Priority: 1
  ECSTaskExecutionRole:
    Type: 'AWS::IAM::Role'
    Properties:
      AssumeRolePolicyDocument:
        Version: 2012-10-17
        Statement:
          - Sid: ''
            Effect: Allow
            Principal:
              Service: ecs-tasks.amazonaws.com
            Action: 'sts:AssumeRole'
      ManagedPolicyArns:
        - 'arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy'
  BlueTaskDefinition:
    Type: 'AWS::ECS::TaskDefinition'
    Properties:
      ExecutionRoleArn: !GetAtt 
        - ECSTaskExecutionRole
        - Arn
      ContainerDefinitions:
        - Name: DemoApp
          Image: 'nginxdemos/hello:latest'
          Essential: true
          PortMappings:
            - HostPort: 80
              Protocol: tcp
              ContainerPort: 80
      RequiresCompatibilities:
        - FARGATE
      NetworkMode: awsvpc
      Cpu: '256'
      Memory: '512'
      Family: ecs-demo
  ECSDemoCluster:
    Type: 'AWS::ECS::Cluster'
    Properties: {}
  ECSDemoService:
    Type: 'AWS::ECS::Service'
    Properties:
      Cluster: !Ref ECSDemoCluster
      DesiredCount: 1
      DeploymentController:
        Type: EXTERNAL
  BlueTaskSet:
    Type: 'AWS::ECS::TaskSet'
    Properties:
      Cluster: !Ref ECSDemoCluster
      LaunchType: FARGATE
      NetworkConfiguration:
        AwsVpcConfiguration:
          AssignPublicIp: ENABLED
          SecurityGroups:
            - !Ref ExampleSecurityGroup
          Subnets:
            - !Ref Subnet1
            - !Ref Subnet2
      PlatformVersion: 1.4.0
      Scale:
        Unit: PERCENT
        Value: 100
      Service: !Ref ECSDemoService
      TaskDefinition: !Ref BlueTaskDefinition
      LoadBalancers:
        - ContainerName: DemoApp
          ContainerPort: 80
          TargetGroupArn: !Ref ALBTargetGroupBlue
  PrimaryTaskSet:
    Type: 'AWS::ECS::PrimaryTaskSet'
    Properties:
      Cluster: !Ref ECSDemoCluster
      Service: !Ref ECSDemoService
      TaskSetId: !GetAtt 
        - BlueTaskSet
        - Id