Notre équipe est composée d'un développeur et d'un ingénieur DevOps. Je suis responsable du déploiement de l'application sur le cluster Amazon ECS. En tant que serveur CI / CD, j'utilise Bamboo. Dans cet article, je vais décrire en détail comment je déploie une application dans un environnement de développement.

Créer une image Docker

Ici, je suive ces étapes:

• Étape 1: installez et configurez Docker;
• Étape 2: configurer les artefacts dans Bamboo;
• Étape 3: configurer le référentiel Amazon ECR;
• Étape 4: Créez l'image Docker dans Bamboo.

Étape 1: installer et configurer Docker

Tout d'abord, je mets à niveau le serveur sur lequel Bamboo est installé, j'installe les packages nécessaires et je configure le référentiel Docker. Il convient de noter ici que j'ai installé Bamboo sur le système d'exploitation CentOS 7. Des informations sur l'installation de docker sur d'autres systèmes d'exploitation sont disponibles sur www.docker.com .

$ sudo yum update $ sudo yum install -y yum-utils device-mapper-persistent-data lvm2 $ sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo 

Ensuite, j'installe l'application Docker et démarre le service:

 $ sudo yum install docker-ce docker-ce-cli containerd.io $ sudo systemctl enable docker $ sudo systemctl start docker 

Ensuite, j'ajoute l'utilisateur bamboo au groupe Docker:

 $ sudo usermod -aG docker bamboo $ sudo su - bamboo $ docker run hello-world 

Si, après avoir exécuté ces commandes, docker répond avec le message «Bonjour de Docker!», Cela signifie que mon installation fonctionne correctement.

Étape 2. Configurer les artefacts dans Bamboo

Le développement d'applications est en cours chez Grails . Lors de la compilation de l'application, un fichier avec l'extension war est créé. Ce fichier, dans la terminologie Bamboo, est un artefact. Configurez Bamboo pour utiliser ce fichier dans les tâches suivantes. Pour ce faire, je vais dans l'onglet Tâches :



Et j'ai configuré la tâche Grails, comme indiqué ci-dessous:



Nous voyons que Grails efface d'abord le dossier de construction, puis exécute les tests et crée enfin un fichier war pour l'environnement de développement.

Après cela, je clique sur l'onglet Artefacts et sur le bouton Créer un artefact :



Je définis un artefact comme indiqué ci-dessous:



Grails place le fichier war dans le répertoire build / libs . Je vérifierai le paramètre partagé , car j'aurai besoin de cet artefact plus tard.

Maintenant, je crée un projet de déploiement et spécifie un artefact à utiliser dans mon plan de build:





J'ai également configuré la tâche de téléchargement d'artefact dans le projet de déploiement:



Ainsi, Bamboo est maintenant configuré pour utiliser un fichier war.

Étape 3. Configurer le référentiel Amazon ECR

Amazon ECR est un service de stockage et de gestion Docker pour les images. Pour configurer, ouvrez la console AWS et sélectionnez ECR:



Après avoir créé le référentiel, j'obtiens l'adresse suivante:

 aws_account_id.dkr.ecr.us-east-2.amazonaws.com/onboard 

Après avoir terminé la configuration, vous pouvez également trouver des instructions sur la façon de se connecter, de télécharger une image à partir du référentiel et de télécharger l'image dans le référentiel.

Étape 4: créer l'image Docker dans Bamboo

Maintenant, je dois configurer le déclencheur pour commencer à créer l'image Docker. Pour ce faire, je vais dans l'onglet Déclencheurs et je clique sur le bouton Ajouter un déclencheur :



Ici, je sélectionne l'option Construire après avoir construit avec succès l' option de plan afin que l'image Docker soit créée après la compilation du projet.

Maintenant, nous devons ajouter la tâche de génération d'image Docker. Pour ce faire, accédez à l'onglet Tâches , cliquez sur Ajouter une tâche , sélectionnez le type Docker . Saisissez une description et sélectionnez Créer une image Docker dans le menu déroulant. Dans le champ Référentiel , entrez

  aws_account_id.dkr.ecr.us-east-2.amazonaws.com/onboard:latest. 

Quant au Dockerfile, il peut être comme indiqué ci-dessous:

 FROM openjdk:8-jre COPY *.war /usr/src/onboard.war WORKDIR /usr/src CMD ["/bin/bash", "-c", "java -DdataSource.url=$DATASOURCE_URL -DdataSource.username=$DATASOURCE_USERNAME -DdataSource.password=$DATASOURCE_PASSWORD -jar onboard.war"] 

Lors du démarrage de l'application, vous devez spécifier la base de données. Les variables d'environnement DATASOURCE_URL, DATASOURCE_USERNAME, DATASOURCE_PASSWORD sont utilisées pour transmettre ces informations à l'application, mais leurs valeurs sont définies au démarrage du conteneur.

Ceci termine le processus d'installation pour assembler l'image Docker avec l'application. L'étape suivante consiste à configurer le téléchargement de cette image vers le référentiel Amazon ECR.

Importer une image dans Elastic Container Registry

Vous pouvez utiliser Elastic Container Registry pour stocker les images collectées à l'aide de Bamboo. Pour y parvenir, je procède comme suit:

• Étape 1. Installer Amazon ECR Docker Credential Helper
• Étape 2. Connectez le rôle IAM au serveur Bamboo
• Étape 3: configurer le travail de démarrage de l'image Docker

Étape 1. Installer Amazon ECR Docker Credential Helper

Pour télécharger des images Docker sur Amazon ECR, vous devez disposer d'informations d'identification. Ces informations d'identification peuvent être obtenues en exécutant la commande

 aws ecr get-login 

Cependant, ces informations d'identification ne sont valables que 12 heures. Par conséquent, vous pouvez soit exécuter la commande ci-dessus à chaque fois avant de télécharger l'image sur l'ECR, soit installer l'ECR Docker Credential Helper, qui maintient les informations d'identification temporaires à jour et se connecte à l'ECR. Suivez ces étapes pour installer ECR Docker Credential Helper.

Vous devez d'abord installer git , puis cloner le référentiel github:

 $ sudo yum install git $ sudo su - bamboo $ git clone https://github.com/awslabs/amazon-ecr-credential-helper.git $ make docker 

Ensuite, vous devez placer les lignes suivantes dans le fichier /home/bamboo/.docker/config.json :

 { "credsStore": "ecr-login" } 

Et copiez l'application compilée dans le répertoire / usr / bin :

 $ exit $ sudo cp /home/bamboo/docker-credential-ecr-login /usr/bin/ 

Étape 2. Connectez le rôle IAM au serveur Bamboo

Pour que le serveur Bamboo puisse utiliser ECR, vous devez créer un rôle, ajouter la stratégie AmazonEC2ContainerRegistryPowerUser à ce rôle, puis attacher ce rôle à l'instance EC2 Bamboo. Ouvrez la console AWS et sélectionnez IAM. Ensuite, cliquez sur le bouton Créer un rôle , sélectionnez le service AWS et EC2 , comme indiqué ci-dessous:



Ensuite, nous cliquons sur le bouton Suivant: Autorisations et sur l'écran suivant, nous trouvons et sélectionnons la politique AmazonEC2ContainerRegistryPowerUser . Après cela, nous finissons de créer le rôle et l'attachons à notre serveur Bamboo.

Étape 3: configurer le travail de démarrage de l'image Docker

L'application que nous avons construite et assemblé une image Docker avec un fichier de guerre. Vous devez maintenant télécharger cette image dans le référentiel. Pour ce faire, j'ajoute une autre tâche Docker, cette fois pour télécharger l'image dans le référentiel ECR. Je vais dans l'onglet Tâches , cliquez sur Ajouter une tâche , sélectionnez le type Docker . J'entre une description et sélectionne Poussez une image Docker dans un registre Docker dans le menu déroulant. Je sélectionne Registre personnalisé et saisis l'adresse du référentiel dans le champ Référentiel . Pour le type d'authentification, je sélectionne Utiliser les informations d'identification natives de l'agent .

Ceci termine le processus d'installation pour charger l'image Docker dans le référentiel Amazon ECR. Les étapes suivantes décrivent le processus de configuration d'un cluster et d'un service pour lancer une application conteneur. Mais avant cela, vous devez configurer les options de lancement du conteneur. C'est ce que nous allons faire maintenant.

Créer une définition de tâche Amazon ECS

Définition de la tâche - les paramètres d'exécution du conteneur sont écrits ici. Notre application utilise une base de données dont les paramètres sont spécifiés au démarrage du conteneur, donc dans cette section nous allons également créer une base de données. J'utilise Amazon RDS comme base de données et je stocke le mot de passe pour accéder à la base de données sous forme chiffrée dans AWS Systems Manager Parameter Store . Les étapes suivantes que je suis afin de créer une définition de tâche:

• Étape 1. Création d'une base de données sur une instance Amazon RDS;
• Étape 2. Configuration du magasin de paramètres AWS Systems Manager;
• Étape 3. Créez la définition de tâche.

Étape 1. Créez une base de données sur une instance Amazon RDS

Notre application utilise la base de données PostgreSQL. Pour créer une base de données, ouvrez la console AWS, sélectionnez le service Amazon RDS, cliquez sur le bouton Créer une base de données , puis sélectionnez PostgreSQL comme moteur de base de données. Sur la page suivante, je sélectionne Dev / Test comme environnement de travail et cliquez sur Suivant . Ensuite, je désigne l' identifiant d'instance de base de données comme onboard-dev-db et le nom d' utilisateur principal comme devdbadmin . Ensuite, je passe à la page suivante pour configurer le VPC, le groupe de sous-réseaux et le groupe de sécurité. Cette base de données sera utilisée sur un réseau privé, je sélectionne donc Non pour le paramètre Accessibilité publique . J'entre devdb dans le champ Nom de la base de données et cliquez sur le bouton Créer une base de données .

Étape 2. Configuration du magasin de paramètres AWS Systems Manager

Je stocke le mot de passe de la base de données sous forme cryptée. Pour ce faire, ouvrez la console AWS et accédez à AWS Systems Manager → Ressources partagées → Magasin de paramètres → Créer un paramètre. J'entre devdbpassword comme nom de paramètre et sélectionne SecureString pour le type de paramètre, puis j'entre le mot de passe de la base de données dans le champ Valeur .

Étape 3. Créer une définition de tâche

Amazon ECS est le cluster sur lequel s'exécutent les applications de conteneur. Il utilise la définition de tâche pour spécifier les paramètres d'exécution d'une application conteneur. Pour définir ces paramètres, cliquez sur le bouton Créer une nouvelle définition de tâche . Ensuite, je sélectionne Fargate comme type de démarrage et je passe à l'étape suivante. Ici, j'ai défini le nom comme onboard-dev-taskdef . Pour le paramètre de champ Rôle de tâche d'exécution IAM , sélectionnez Créer un nouveau rôle . Quant aux ressources allouées à cette application, je désigne 2 Go de mémoire et 1 vCPU. Vous devez maintenant ajouter des options de lancement de conteneur. Je nommerai le conteneur onboard-dev-container . Je nommerai le nom de l'image comme ceci:

aws_account_id.dkr.ecr.us-east-2.amazonaws.com/onboard:latest . Amazon ECR Docker Credential Helper se chargera de l'authentification ECR, je laisse donc l'option d' authentification du référentiel privé décochée. Dans l'environnement de développement, l'application est disponible sur le port 8080, donc pour le paramètre de mappage de ports, j'écris 8080 et sélectionne le protocole TCP . Les paramètres d'URL de la base de données, le nom d'utilisateur et le mot de passe sont transmis au conteneur à l'aide de variables d'environnement. J'ai défini ces paramètres dans la section Variables d'environnement. Afin d'obtenir la valeur du paramètre devdbpassword à partir du magasin de paramètres, je spécifie le type ValueFrom . La dernière chose que je configure est la configuration des journaux , ici je sélectionne Auto-configure CloudWatch Logs . La création de la définition de tâche est maintenant terminée.

Cependant, le rôle ecsTaskExecutionRole a besoin d'une stratégie pour obtenir devdbpassword à partir du magasin de paramètres. Pour ce faire, accédez à Rôles IAM et sélectionnez ecsTaskExecutionRole, cliquez sur Ajouter une stratégie en ligne . Dans ce cas, j'ajoute en utilisant un éditeur visuel. Par conséquent, dans le champ Service, j'entre Systems Manager , dans le champ Actions - GetParameters . Ensuite, je clique sur Ajouter ARN pour le champ Ressources et remplis mes valeurs:



À la fin, je regarde les valeurs des paramètres qui sont définis en cliquant sur Review policy, je lui donne un nom et je termine de travailler avec la configuration ecsTaskExecutionRole.

Ceci termine la configuration des paramètres de l'application du conteneur de lancement. Vous devez maintenant créer un cluster et un service ECS.

Créer un service Amazon ECS

Notre application de conteneur s'exécute en tant que service dans un cluster ECS. Pour configurer, vous devez effectuer les étapes suivantes:

• Étape 1. Créez un cluster Amazon ECS;
• Étape 2: création d'un service

Étape 1. Créez un cluster Amazon ECS

Pour créer un cluster ECS, accédez à la console AWS et sélectionnez le service ECS. Cliquez ensuite sur Créer un cluster et sélectionnez le modèle de cluster de mise en réseau uniquement . Sur la page suivante, je nomme le cluster onboard-dev-cluster et complète le cluster. J'ai maintenant un cluster ECS basé sur Fargate .

Étape 2: création d'un service

Pour créer un service, je clique sur le lien onboard-dev-cluster , puis je vais dans l'onglet Services et je clique sur le bouton Créer . Pour le type de lancement, je sélectionne Fargate, pour la définition de tâche, je sélectionne onboard-dev-taskdef. De plus, je sélectionne onboard-dev-cluster dans le champ Cluster. Dans le champ Nom du service , j'écris onboard-dev. J'ai défini le paramètre Nombre de tâches sur zéro, car je ne veux pas démarrer l'application pour le moment. Je laisse les paramètres de pourcentage d'intégrité minimal égal à 100 et le pourcentage maximal égal à 200. Pour le paramètre Type de déploiement , sélectionnez Mise à jour continue et passez à l'étape suivante.

Sur la page Configurer le réseau , pour le paramètre Cluster VPC , je sélectionne un VPC créé précédemment appelé Development VPC . L'application en cours de développement n'est disponible que sur le réseau privé, j'ai donc choisi deux sous-réseaux privés. Pour configurer les groupes de sécurité, je clique sur le bouton Modifier , puis sélectionnez Sélectionner le groupe de sécurité existant , puis le groupe de sécurité par défaut et cliquez sur le bouton Enregistrer . Pour le paramètre IP public assigné automatiquement , je sélectionne Désactivé . Ensuite, pour le paramètre de type d'équilibreur de charge , je sélectionne Aucun et je laisse l'option Activer l'intégration de la découverte de services décochée . Ensuite, je clique sur Suivant, Suivant et Créer un service .

Maintenant, j'ai un service dans lequel le nombre de travaux en cours d'exécution est nul. Nous configurerons le lancement de l'application à l'étape suivante.

Mise à jour du service

Dès que le développeur met à jour le code de l'application, notre déploiement passe par la création d'une image Docker, son téléchargement sur Elastic Container Registry et enfin le lancement de l'application conteneur en tant que service dans le cluster ECS Fargate. Pour le moment, le nombre de travaux en cours d'exécution dans le cluster est nul. Pour que l'application démarre, vous devez mettre à jour le service, en indiquant la quantité égale à un. Je poursuis ces étapes pour y parvenir:

• Étape 1. Installation du plug-in Tâches pour AWS Bamboo;
• Étape 2. Mise à jour du service ECS

Étape 1. Installation du plug-in Tâches pour AWS Bamboo

Tâches pour AWS Bamboo est un plugin qui simplifie la préparation et le fonctionnement des ressources AWS à partir des projets de construction et de déploiement Bamboo. Pour installer ce plugin, je vais dans le projet de déploiement, cliquez sur Ajouter une tâche , allez sur Atlassian Marketplace et installez des tâches pour AWS (Bamboo) .

Étape 2. Mise à jour du service ECS

Maintenant, dans le projet de déploiement, j'ajoute le travail Amazon ECS Service . Ensuite, j'écris dans le champ de description de travail Update Service for onBoard-dev . Dans le champ Action, sélectionnez Mettre à jour le service et Forcer le nouveau déploiement . Ensuite, je sélectionne US East (Ohio) comme région de lancement. Ensuite, j'écris dans les champs appropriés ARN (Amazon Resource Name) pour la définition de tâche, le cluster et le service. Dans cette tâche, je mets à jour le nombre souhaité de tâches en cours d'exécution. Ensuite, je remplis la zone de texte de configuration de déploiement avec les valeurs suivantes:

 { "maximumPercent": 200, "minimumHealthyPercent": 100 } 

J'installe un réseau sans IP publique comme suit:

 { "awsvpcConfiguration": { "assignPublicIp": "DISABLED", "subnets": ["subnet-ID1", "subnet-ID2"], "securityGroups": ["sg-ID"] } } 

Dans la section Source pour les informations d'identification de sécurité AWS, je sélectionne Rôle IAM pour EC2 .

Je dois pouvoir mettre à jour ECS, donc j'attache la stratégie AmazonECS_FullAccess à mon instance Bamboo EC2. Pour ce faire, ouvrez la console AWS, sélectionnez IAM. Ensuite, je sélectionne le rôle que j'utilise pour mon serveur Bamboo. Je clique sur le bouton Attacher les politiques , je trouve la politique AmazonECS_FullAccess, je coche la case à gauche et je termine de joindre la politique.

Ceci conclut la configuration CI / CD à l'aide d'AWS et de Bamboo. Ainsi, lorsque le développeur met à jour le code de l'application, télécharge ce code dans le référentiel, les tests et l'assemblage de l'application sont lancés. Ensuite, l'image Docker est créée avec le fichier war de l'application, et cette image est copiée dans le référentiel Amazon ECR. Ensuite, dans le cluster Amazon ECS, une application conteneur est lancée en tant que service, qui met à jour l'application actuelle si elle n'a pas été arrêtée. Si l'application a été arrêtée pour économiser des ressources, l'application démarre simplement. Après avoir vérifié l'application dans l'environnement de développement, vous pouvez arrêter l'application en spécifiant le nombre de travaux en cours d'exécution dans le cluster à zéro.

Si vous avez aimé l'article et avez des idées d'amélioration, écrivez dans les commentaires.