Déploiement sans temps d’arrêt à l’aide de la méthodologie Blue-Green

Le déploiement d’une nouvelle version d’une application dans un environnement de production est la tâche la plus critique du cycle de vie du développement logiciel. Et une petite erreur dans le cycle de publication entraîne des pannes et des pannes en cascade.

Pour réaliser le déploiement d’une nouvelle version de l’application, existe-t-il une option qui réduit les risques d’échec ou de pannes et garantit l’absence de temps d’arrêt pendant le déploiement ?

Oui, la solution à ce problème est la stratégie bleu-vert.

Un bleu/vert est le type de déploiement dans lequel il crée deux environnements identiques mais avec différentes versions d’applications exécutées dessus.
L’environnement bleu est l’endroit où la version actuelle est en cours d’exécution tandis que l’environnement vert est l’endroit où la nouvelle version de l’application sera exécutée.

Dans ce blog, j’ai créé un pipeline sur AWS qui utilise une stratégie de déploiement bleu/vert pour déployer une nouvelle version de l’application.

Architecture Diagramme:

Avantages :

1. Publication rapide : avec le déploiement bleu-vert, on peut publier une application dans un environnement de production car il n’y a pas de temps d’arrêt qui lui est associé et cela n’a aucun impact négatif sur les utilisateurs.
2. Restaurations rapides : des restaurations faciles sont réalisées avec cette approche entre la version actuelle et la nouvelle version de l’application, ce qui réduit les risques inhérents à l’expérimentation dans un environnement de production.
3. Reprise après sinistre intégrée : comme l’environnement bleu-vert utilise deux environnements identiques, l’environnement de production double est sa propre sauvegarde à chaud

1. Création de rôles pour différents services :
   
   Nous devons créer 3 rôles pour permettre aux services de fonctionner.
   a) Rôle CodeDeploy :
   Ce rôle sera utilisé lors de la création de l’étape de déploiement lors de la création de CodePipeline.

• Allez dans « IAM » cliquez sur les rôles.
• Créer un rôle, sélectionnez le cas d’utilisation comme « CodeDeploy »
• Donnez le nom « bluegreencodedeploy » et créez un rôle.
• De même, créez un rôle pour CodeDeploy – ECS et donner le nom comme « bleuvertECS”.
• Créez également un rôle pour Rôle CodeBuild et donner le nom comme « bluegreencodebuild”.

2. Création d’Elastic Container Registry (ECR) :

   Nous devons créer un ECR pour stocker les images Docker.

• Accédez au service « ECR » et créez un référentiel.
• Donnez le nom « bluegreenrepo » et créez un référentiel.
• Au départ, nous devons créer manuellement l’image à partir du Dockerfile pour cette instance Launch one EC2 et y installer Git et Docker.
• Clonez le référentiel github et créez l’image.
• Exécutez les commandes ci-dessous affichées dans une image sur une instance EC2 pour pousser l’image vers ECR.

3. Création de groupes cibles et d’équilibreur de charge :

   Suivez les étapes ci-dessous pour créer des groupes cibles et un équilibreur de charge.

• Accédez au service « EC2 », sur le côté gauche, recherchez l’option « Groupes cibles » et ouvrez-la.
• Cliquez sur créer un « groupe cible »
• Choisissez un type de cible : sélectionnez « Adresses IP »
• Donnez le nom comme « ALB-Tgroup1 » et spécifiez le port comme 8080.
• Laissez le reste des paramètres par défaut et créez un groupe cible.

En suivant les étapes ci-dessus, créez un deuxième groupe cible nommé ALB-Tgroup2 et le port 8080.

Avec les étapes ci-dessous, créez un équilibreur de charge d’application.

• Accédez au service « EC2 », recherchez l’option « Équilibreurs de charge » et ouvrez-la.
• Cliquez sur « Créer un équilibreur de charge », sélectionnez le type d’équilibreur de charge comme « Équilibreur de charge d’application ».
• Donnez le nom comme « ALB-app » et le type de schéma comme « face à Internet ».
• Mappages réseau : sélectionnez le VPC par défaut et sélectionnez tous les sous-réseaux.
• Le groupe de sécurité doit avoir le port 8080 ouvert.

Nous ne pouvons pas ajouter 2 groupes cibles à la fois lors de la création d’un équilibreur de charge. Nous devrons ajouter un autre groupe cible une fois notre équilibreur de charge créé.

• Une fois l’équilibreur de charge créé, cliquez dessus.
• Allez dans « Auditeurs & routages »
• Spécifiez le port en tant que 8080 et l’action en tant que « transférer » et ajoutez un autre groupe cible.

4. Création du Cluster ECS, mission et service :
   
   Créez un cluster, une tâche et un service ECS en suivant les étapes ci-dessous.

• Accédez au service « ECS », cliquez sur le côté gauche sur « Clusters » et créez un cluster.
• Sélectionnez le modèle de cluster comme « Mise en réseau uniquement ».
• Donnez le nom « Bluegreencluster ».
• Laissez le reste des paramètres par défaut et créez un cluster.

• Sur le côté gauche, recherchez une option « Définition de tâche » et créez une nouvelle définition de tâche.
• Sélectionnez la compatibilité du type de lancement en tant que « Fargate ».
• Donnez le nom « bluegreen-taskdef ».
• Sélectionnez le rôle de tâche comme « ecsTaskExecutionRole ».
• Spécifiez la mémoire de la tâche sur 0,5 Go et le processeur de la tâche sur 0,25 vcpu.

• Maintenant, cliquez sur « Ajouter un conteneur » et nommez-le « bluegreencontainer ».
• Mentionné l’URL de l’image, qui peut être trouvée dans la console ECR.
• Spécifiez la limite de mémoire à 128 et le mappage de port à 8080.

• Une fois la définition de tâche créée, cliquez sur la définition de tâche puis cliquez sur le service.
• Cliquez sur « Créer un service », sélectionnez le type de lancement comme « fargate ».
• Donnez le nom du service comme « bluegreen-service » et le nombre de tâches comme 2.
• Sélectionnez le type de déploiement comme « Déploiement bleu/vert ».
• Sélectionnez le rôle de service pour codedeploy en tant que « bluegreenECS » (2ème rôle que nous avons créé à l’étape 1).
• Sélectionnez cluster vpc comme « default vpc » et sélectionnez tous les sous-réseaux.
• Sélectionnez le type d’équilibreur de charge comme « Équilibreur de charge d’application » et spécifiez le port comme 80 et le port de test comme 8080.
• Sélectionnez les deux groupes cibles.

• Une fois le conteneur créé, copiez l’adresse IP publique de chaque tâche et testez-la dans le navigateur.
• Il doit héberger votre version v1.1 et tester le point de terminaison DNS de l’équilibreur de charge pour voir s’il fonctionne ou non.

5. Création du projet CodeBuild :
   Nous devons créer un projet de construction de code qui récupérera un Dockerfile de GitHub et générera une image à partir de celui-ci.

• Accédez au service « CodeBuild » et créez un projet de codebuild.
• Donnez le nom « bluegreen-Codebuild ».
• Spécifiez l’URL git comme « https://github.com/Vijaygawate/Blue-Green-Deployment-On-ECS.git”.
• Sélectionnez le système d’exploitation comme « Ubuntu », active la case à cocher privilégiée.
• Sélectionnez le rôle de service en tant que « bluegreencodebuild » (3ème rôle que nous avons créé à l’étape 1)
• Décochez la section des journaux cloudwatch.
• Laissez le reste des paramètres par défaut et créez.

6. Création de CodePipeline :
   
   Enfin, nous devons combiner CodeBuild et CodeBuild et CodeDeploy en créant CodePipeline.

• Allez dans « CodePipeline » et créez un pipeline.
• Donnez le nom de pipeline comme « bluegreenpipeline » et le rôle de service : nouveau rôle de service.

• Sélectionnez la source comme Github version1 dans l’étape source et cliquez sur n connectez-vous à Github
• Sélectionnez les options de détection de changement en tant que Webhooks GitHub.

• Ajoutez le fournisseur de build en tant que « CodeBuild » .
• Sélectionnez le nom du projet comme « bluegreen-codebuild » et cliquez sur l’étape suivante.

• Sélectionnez Déployer le fournisseur en tant que « Amazon ECS (bleu/vert) ».
• Sélectionnez le nom de l’application CodeDeploy et le groupe de déploiement.
• Définition de tâche Amazon ECS : BuildArtifact
• Fichier AWS CodeDeploy AppSpec : BuildArtifact
• Texte d’espace réservé dans la définition de tâche en tant que « ImageURI ».
• Examinez et créez un pipeline.

Une fois le pipeline déclenché, nous pourrons voir la page ci-dessous.

Maintenant, si vous apportez des modifications au fichier server.js. Cela démarrerait un nouveau pipeline qui créerait une nouvelle image à partir d’un Dockerfile et la pousserait vers ECR, ainsi que l’ajout de deux nouvelles tâches dans le cluster ECS.

• Les environnements bleu et vert sont disponibles, et nous pouvons décider lequel nous aimerions continuer à exécuter.
• Si nous voulons que la version 2 continue de fonctionner, nous pouvons simplement appuyer sur l’onglet « Terminer » pour qu’elle maintienne la version 2 en cours d’exécution tout en mettant fin aux ressources de la version précédente.

• Et disons que notre version 2 ne fonctionne pas comme prévu et aimerait revenir à la version précédente.
• Pour cela, appuyez simplement sur « Arrêter et restaurer le déploiement » et il reviendra à la version 1 tout en mettant fin aux ressources de la version 2.

.

Conclusion:

De cette manière, nous pouvons atteindre zéro temps d’arrêt lors du passage à différentes versions d’applications, et ce type de stratégie joue un rôle essentiel dans le déploiement d’applications critiques.