# Intégration continue et déploiement continu avec code Pepeline de AWS [Application Java]

[**Lien de projet sur Github**](https://github.com/YanisDevops/vprofile-project.git)

[**Lien de la vidéo Youtube**](https://youtu.be/7Zqr3GC7SGQ)

### **Prérequis**

* AWS Account
    
* AWS Cloud Services  
    1\. AWS CodeCommit ( en tant que référentiel du système de contrôle de version)  
    2\. AWS Codebuild ( pour construire l'image )  
    3\. AWS Codedeploy ( en tant que service de déploiement d'artefacts)  
    4\. AWS Codeartifact ( en tant que référentiel Maven pour les dépendances)  
    5\. S3 Bucket ( stockage des artefacts)  
    6\. AWS Codepipeline ( service pour intégrer toutes les tâches ensemble)
    
* AWS CLI
    
* Git
    
* SonarCloud
    

### **Flux d'exécution**

* Connectez-vous au compte AWS
    
* Configuration du dépôt de code  
    a. Créez un dépôt Codecommit  
    b. Synchronisez-le avec le référentiel local
    
* Configuration de l'artefact de code  
    a. Créez un référentiel  
    b. Mettez à jour le fichier settings.xml dans le référentiel  
    c. Mettez à jour le fichier pom.xml dans le référentiel  
    d. Générez et stockez le jeton dans le store de paramètres SSM
    
* Configuration du SonarCloud  
    a. Créez un compte SonarCloud  
    b. Générez et stocker le jeton dans le store de paramètres SSM  
    c. Créez un projet de build !  
    d. Mettez à jour le rôle de build de code pour accéder au store de paramètres SSM
    
* Créez une notification SNS
    
* Configurez le projet de construction  
    a. Mettez à jour pom.xml avec la version de l'artefact  
    b. Créez des variables dans le store de paramètres SSM  
    c. Créez un projet de build  
    d. Mettre à jour le rôle Codebuild pour accéder au magasin de paramètres SSM
    
* Créez un pipeline  
    a. Codecommit  
    b. Test de code  
    c. Codebuild  
    d. CodeDeploy sur le compartiment S3
    
* Testez le pipeline
    
* Créez Beanstalk et RDS.
    
* Mettre à jour le groupe de sécurité RDS.
    
* Déployez la base de données dans RDS.
    
* Basculez vers la branche cd-aws
    
* Mettez à jour les fichiers settings.xml et pom.xml
    
* Créez une autre tâche de build pour générer un artefact avec le fichier buildspec
    
* Créez une tâche de déploiement sur beanstalk
    
* Téléchargez la capture d'écran sur le compartiment s3
    
* Créez une tâche de build pour les tests logiciels
    
* Mettre à jour le pipeline
    
* Tester le pipeline
    

### **Étape 1 : configuration d'AWS CodeCommit**

Connectez-vous à votre console de gestion AWS, recherchez le service CodeCommit, sélectionnez le référentiel et créez un référentiel nommé :

```bash
Nom : vprofile-code-repo
```

Créez un utilisateur IAM didié au référentiel CodeCommit , ainsi qu'une stratégie pour le Codecommit qui permet un accès complet au dépôt ***vprofile-code-repo.*** Nommez la stratégie ***vprofile-code-admin-repo-fullaccess.***

Pour créer un IAM et attacher la stratégie spécifiquement au référentiel CodeCommit, suivez les étapes ci-dessous :

```bash
Naviguez dans IAM > cliquez sur Ajouter un utilisateur
```

```bash
Nom d'utilisateur IAM : vprofile-code-admin
```

Ensuite créez une stratégie à attacher

```bash
service : CodeCommit 
nom : vprofile-code-repo 
action : all
Nom de la stratégie : vprofile-code-admin-repo-fullaccess
```

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712856343318/dbb4b82a-c7ef-4393-a4b9-bd6d7a7bf332.png align="center")

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712856402415/8b97ddb2-61d0-4fa7-a5b9-8dfa28633b28.png align="center")

Attachez la stratégie à l'utilisateur IAM.

Après la création de l'utilisateur IAM, nous devrons télécharger la clé publique SSH dans la section Informations d'identification de sécurité de l'utilisateur nouvellement créé. Cela se fait en générant une paire de clé SSH sur la machine locale et en téléchargeant la clé publique ssh sur les informations d'identification de sécurité du rôle IAM. ***(Clés publiques SSH pour la section AWS CodeCommit)***

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712856620455/6e176dec-f3ad-4c2a-a8fe-6cffdf209495.png align="center")

De plus, nous devons également mettre à jour la configuration. Dans le répertoire .ssh, créez un fichier ***.ssh/config*** et ajoutez les informations sur l'hôte ssh.

```bash
Host git-codecommit.us-east-1.amazonaws.com
    User <SSH_Key_ID_from IAM_user>
    IdentityFile ~/.ssh/vpro-codecommit_rsa
```

Assurez-vous de modifier les autorisations de fichier pour lire et écrire avec cette commande ***chmod 600 config***

Testez que la connexion ssh à CodeCommit est établie et authentifiée avec succès avec la commande ci-dessous.

```bash
ssh git-codecommit.us-east-1.amazonaws.com
```

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712857273946/7a192ebf-f8ee-433d-a0ec-6ace95ad002b.png align="center")

Ensuite, clonez le référentiel sur votre machine local depuis Github en utilisant l'URL git@github.

[***Lien Github***](https://github.com/YanisDevops/vprofile-project).

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712858632764/fea268cc-810e-403a-a9cc-6ab195c450d9.png align="center")

Convertissez le référentiel github en référentiel CodeCommit. Pour ce faire, assurez-vous d'être dans le référentiel cloné et exécutez les commandes ci-dessous :

```bash
git checkout master
git branch -a | grep -v HEAD | cur -d'/' -f3 | grep -v master > /tmp/branches
for i in `cat  /tmp/branches`; do git checkout $i; done
git fetch --tags
git remote rm origin
git remote add origin ssh://git-codecommit.us-east-1.amazonaws.com/v1/repos/vprofile-code-repo
cat .git/config
git push origin --all
git push --tags
```

Observez maintenant que le référentiel distant est désormais passée de Github à Codecommit. Utilisez la commande **cat .git/config** pour vérifier.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712858871864/970a98c1-c6bc-421f-b507-49b91780bb0a.png align="center")

Transférez le code source vers Codecommit

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712859099029/a1416c3f-66d8-4f9d-9c2d-eece35510216.png align="center")

Vérifiez pour confirmer que le référentiel contient notre code sur Codecommit. Le dépôt est désormais prêt avec toutes les branches présentes sur AWS Codecommit.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712859369607/b288aa54-55e1-4d00-ab91-bec6cb875a46.png align="center")

### **Étape 2 : configuration CodeArtifact d'AWS et store de paramètres**

Créez un référentiel CodeArtifact pour Maven :

```bash
Nom: vprofile-maven-repo
Repo public en amont: maven-central-store
Nom de domaine: visualpath
et cliquez sur créer
```

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712859859794/8cd59a43-901d-447a-bb8a-528e500c41a8.png align="center")

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712859940714/afe23804-508d-4009-ae68-d45e6db245b5.png align="center")

Suivez les instructions de connexion fournies dans CodeArtifact pour le **vprofile-maven-repo** qui vient d'être créé\*\*.\*\* cliquez sur afficher les instructions de connexion, sélectionnez votre type de machine et continuez.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712860037665/dd112223-2901-4f9b-95fa-555713b51e51.png align="center")

Créez l'utilisateur IAM pour CodeArtifact nommé **vprofile-cart-admin** , téléchargez la clé d'accès, attachez à cet utilisateur les autorisations **AWSCodeArtifactAdminAccess** et configurez l'utilisateur sur AWS CLI avec ses informations d'identification.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712995134899/21684260-a024-42a4-9b81-95c8020c9017.png align="center")

Exécutez ***aws configure*** sur votre machine pour configurer les informations d'identification.

```bash
aws configure # entrez vos informations d'identification d'utilisateur IAM
```

La commande ci-dessous provient des instructions de connexion, copiez exécutez la commande dans votre terminal à l'aide d'AWS CLI.

```bash

export CODEARTIFACT_AUTH_TOKEN=`aws codeartifact get-authorization-token --domain visualpath --domain-owner <aws account ID> --region us-east-1 --query authorizationToken --output text`
```

Utilisez cette commande ci-dessous pour imprimer le jeton sur votre terminal

```bash
echo $CODEARTIFACT_AUTH_TOKEN
```

Procédez à la mise à jour des fichiers pom.xml et settings.xml avec les URL correctes suggérées dans les instructions de connexion.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712860491524/c83df251-0b55-4271-b232-7660bf56e1b6.png align="center")

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712860665492/3bd95be5-136b-4358-a61a-058f115e71f8.png align="center")

Ensuite, envoyez les deux fichiers vers CodeCommit.

```bash
git add .
git commit -m "message" (add you commit message)
git push origin ci-aws
```

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712860825541/05063f1b-78e9-4474-81c8-f703d9e6eb06.png align="center")

### **Étape 3 : Configurer SonarCloud**

Créez un compte si vous n'en avez pas déjà un sur la site Web officiel [**sonarcloud.io**](http://sonarcloud.io)

Cliquez sur l'avatar du compte &gt; Mon compte &gt; Sécurité. Donnez un nom au jeton ***vprofile-sonartoken*** &gt; cliquez sur générer.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712861940152/b3068356-222b-44f1-a716-67eac73d45ae.png align="center")

Ensuite, nous créons un projet, cliquez sur le signe + dans le coin supérieur droit de la page &gt; Analyser le projet &gt; Créer un projet manuellement. Notez ci-dessous les informations qui seront utilisées dans notre travail de construction.

***Remarque :*** Créez votre organisation unique et votre clé de projet, mais n'oubliez pas de les conserver en toute sécurité.

```bash
Organisation : Name-projects 
Clé du projet : Name-vprofile-repo 
URL sonarcloud : sonarcloud.io 
jeton généré : <>
```

### **Étape 4 : AWS Systems Manager Parameter Store pour SonarCloud**

Créez des paramètres avec les variables ci-dessous:

```bash
CODEARTIFACT_TOKEN   Type:SecureString	Value: (value of echo $CODEARTIFACT_AUTH_TOKEN)
HOST                 Value: https://sonarcloud.io type: string
ORGANIZATION         Value:Name-projects type: string
PROJECT              Value: Name-vprofile-repo type: string
SONARTOKEN           Value: vprofile-sonartoken geenrated token SecureString
```

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712862949690/0de1d679-0ab7-4063-8e6f-30a6b04d3253.png align="center")

### **Étape 5 : AWS CodeBuild pour l'analyse du code SonarQube**

Naviguez dans CodeBuild sur votre console de gestion AWS et cliquez sur Créer un projet de build.

```bash
ProjectName: Vprofile-Build
Source: CodeCommit
Branch: ci-aws
Environment: Ubuntu
runtime: standard:5.0
select New service role: codebuild009-Vprofile-Build-service-role 
Insert buildspec content from directory aws-files/sonar_buildspec.yml, cat its content and past in the insert build command tab
under Logs > GroupName: vprofile-buildlogs
StreamName: sonarbuildjob
```

Assurez-vous que les sections paramètres du fichier ***sonar\_buildspec.yml*** sont mises à jour avec les noms exacts donnés dans le **store** de paramètres SSM.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712863046908/32e505e5-55b0-4c4e-9e84-e31813e3f816.png align="center")

Cliquez sur Modifier &gt; environnement et copiez le nom du rôle affiché et cliquez sur Annuler pour ajouter une politique au rôle de service créé pour ce projet Build

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712864340237/d41d2836-a1cd-4770-b5bd-c92a9f8ca7e6.png align="center")

Accédez à IAM &gt; cliquez sur Rôles &gt; collez le rôle dans la barre de recherche pour trouver le rôle copié à partir de notre projet de build, le rôle devrait apparaître, cliquez dessus et modifiez pour attacher la stratégie.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712863656265/369aa56b-f771-42f8-8860-e9a809ebe37f.png align="center")

Choisissez le service ( **System Manager** ), Dans **le niveau d'accès Liste** cochez la *case****Describeparameter***

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712863720874/aa0cbc83-1099-444c-a2e0-244b6142f2f0.png align="center")

Également dans le **niveau d'accès Lecture,** sélectionnez les **cases de paramètres** comme indiqué ci-dessous.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712863751370/eb7e28cd-3d4a-4eb4-9b0e-b4d07f3f7bea.png align="center")

Vérifiez et donnez un nom à votre stratégie « ***vprofile-sonarparameteraccess »*** , puis cliquez sur Créer une stratégie.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712863814378/44506293-b4bb-433c-996b-72c5bbbe46af.png align="center")

Attachez la stratégie que vous venez de créer au rôle de projet CodeBuild.

Maintenant que CodeBuild dispose de l'autorisation appropriée, procédez à la création du projet en cliquant sur **Démarrer la génération**.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712864440848/f1031a9e-cce7-4362-8660-aae3a55a4857.png align="center")

Une fois la construction terminée, vérifiez les résultats publiés dans SonarCloud.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712863989354/b4c65b3c-a3e6-4d87-ab17-448876137413.png align="center")

### **Étape 6 : Configurer le projet de construction pour l'artefact**

Sur votre console AWS, revenez à **CodeBuild**, puis cliquez sur Créer un projet de build. Encore une fois, les étapes sont similaires à celles précédemment vues lors de la création de build pour l'analyse du code avec DonarCloud.

```bash
Name: vprofile-CI-Pipeline
SourceProvider: Codecommit
branch: ci-aws
Change detection options: CloudWatch events
Build Provider: CodeBuild
ProjectName: vprofile-Build-Artifact
BuildType: single build
Deploy provider: Amazon S3
Bucket name: vprofile98-build-artifact
object name: pipeline-artifact
```

Après avoir créé le projet de build, vous devrez mettre à jour la nouvelle stratégie de rôle de service et pour ce faire, suivez les étapes ci-dessous :

Cliquez sur Génération &gt; Projet de génération &gt; Vprofile-Build-Artifact. Copiez le nom du rôle de service (voir la capture d'écran ci-dessous)

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712865561826/564721a1-78be-47c9-aaee-2c52f99fc076.png align="center")

Ensuite, accédez à IAM &gt; sélectionnez les rôles &gt; recherchez le rôle de service que nous venons de copier &gt; Cliquez dessus &gt; cliquez sur Ajouter des autorisations &gt; cliquez sur l'option attacher des stratégies

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712865637866/4e152d61-0ddf-4880-a8b6-0428ee1e98d7.png align="center")

Recherchez ensuite et utilisez la stratégie utilisée pour le ***paramètre sonaraccess*** créé à la précédente étape. Sélectionnez-le et attachez-le au rôle de service. Cela devrait activer le niveau d'accès à la liste et les autorisations de niveau d'accès en lecture nécessaires pour créer notre Build. (reportez-vous à l'**étape 5** pour voir **le niveau d'accès complet en lecture et les autorisations des paramètres d'accès en liste)**

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712866025890/84404538-3fa0-41f3-a44b-55258af76d49.png align="center")

Avec la politique mise à jour, il est temps de construire notre projet. Revenez à votre CodeBuild, sélectionnez le projet **Vprofile-Build-Artifact** et cliquez sur **Démarrer la génération.**

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712866211223/a7fdff73-f6f9-4b3e-a325-1ec3ed2e876a.png align="center")

### **Étape 7 : configurer CodePipeline et notification SNS**

Dans votre console AWS, accédez au service SNS et créez une notification SNS. Ensuite, créer un abonnement à une adresse mail valide.

```bash
SNS Topic Name: vprofile-pipeline-notification
Topic Type: Standard
subcription protocol: email
```

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712866380876/2f1806af-f6cc-4298-9236-440b549ba18c.png align="center")

Une fois inscrit avec l'e-mail fourni, accédez à votre boîte de réception et confirmez l'abonnement aux notifications.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712866557800/84089840-8a60-4548-b319-2ffaec65b3cb.png align="center")

La prochaine étape consiste à créer CodePipeline avec les détails ci-dessous

```bash
Name: vprofile-CI-Pipeline
SourceProvider: Codecommit
branch: ci-aws
Change detection options: CloudWatch events
Build Provider: CodeBuild
ProjectName: vprofile-Build-Aetifact
BuildType: single build
Deploy provider: Amazon S3
Bucket name: vprofile98-build-artifact
object name: pipeline-artifact
```

Lorsque le pipeline est en cours de création, arrêtez le pipeline et ajoutez une étape de test à votre pipeline en cliquant sur ajouter une étape après l'étape **source**, nommez-la **Test** et saisissez les informations ci-dessous.

```bash
Action Name: Sonar-Code-Analysis
Action Provider: AWS CodeBuild
input aritfact: SourceArtifact
Project Name Vprofile-Build
Build Type: Select the Single Build
```

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712866868390/fa69a63c-8f01-4056-bf3b-54e0be29f304.png align="center")

Ajoutez une autre étape après l'étape de **Build**, nommez-la ***Deploy*** et utilisez les informations ci-dessous.

```bash
Action Name: Deploy-To-S3
Action provider: Amazom s3
Region: Same region of codebuild
input artifact: BuilArtifact
Deployment Path: pipeline-artifact (this is the folder name created in your s3 bucket for the pipeline)
check the Extract file before deploy option
```

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712867150544/22895f05-cd12-4269-be8d-f21f579c32a9.png align="center")

Assurez-vous d'avoir enregistré le pipeline après avoir ajouté les étapes de **test** et de **déploiement.**

L'étape suivante consiste à configurer les notifications. Accédez aux paramètre dans CodePipeline &gt; cliquez sur l’option de notification &gt; les paramètres de règles de notification.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712867191634/10bd097a-943e-428f-a3d0-56d31c2aac5b.png align="center")

### **Étape 8 : Tester le CodePipeline**

Cliquez sur **Publier les modifications** et le pipeline devrait commencer à s'exécuter. suivez et assurez-vous que le pipeline s'est exécuté avec succès.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712867255918/a16e6775-1dca-4f08-b154-0a46a51d80e4.png align="center")

Vous devez vérifier que le pipeline est correctement configuré pour déclencher une tâche lorsque les modifications sont validées. Apportez une modification à n'importe quel code ou fichier **README.md**, ajoutez et validez les modifications dans la branche source et observez qu'un nouveau job est déclenché. Si cela se produit, votre pipeline est correctement configuré et prêt à passer à l’étape suivante.

### **Étape 9 : Créer un environnement Elastic Beanstalk**

Configurez un environnement à l’aide d’un exemple d’application.

```bash
Name: vprofile-app
Plateform: Tomcat
Platform branch: Tomcat 8.5
Capacity: LoadBalanced
    Min: 2
    Max: 4
Keypair : Choose existing key-pair usedin previous steps
```

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712869173684/03743a4c-33a3-40dd-8c3e-ba52ce1d2524.png align="center")

### **Étape 10 : Créer une base de données RDS MySQL**

Créez un service RDS en utilisant les informations ci-dessous.

**Remarque** : N'oubliez pas de noter le mot de passe (vous le trouverez dans \[Afficher les détails des informations d'identification\]. Il sera utilisé plus tard lors de la configuration de votre base de données.

```bash
Engine: MySQL
version: 5.7
Template: use the Free-Tier
DB Identifier: vprofile-cicd-mysql
credentials: admin
Auto generate password (will take note of pwd once RDS is created)
DB instance class: db.t2.micro
Create new SecGrp Named: vprofile-cicd-rds-mysql-sg
In Additional Configurations: initial db name "accounts"
```

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712869278620/165cfa7e-5308-4c1c-a8fc-0f56ec067ea2.png align="center")

### **Étape 11 : Mettre à jour le groupe de sécurité RDS**

Accédez aux instances Beanstalk créées et copiez son ID de groupe de sécurité. Procédez à la mise à jour des règles entrantes du groupe de sécurité RDS pour autoriser l'accès aux instances Beanstalk sur le port 3306.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712869383423/28c8521c-aa59-4da3-ad15-04f3b28a0c80.png align="center")

### **Étape 12 : Déployer la base de données dans RDS. (initialisation de la base de données)**

connectez vous à l'une des instances beanstalk et installez le client MySQL dans cette instance pour pouvoir se connecter à RDS. Installez également **git** pour cloner notre code source et nos scripts afin de créer un schéma dans notre base de données. Exécutez les commandes ci-dessous et assurez-vous de mettre à jour vos informations d'identification en conséquence pour le nom d'utilisateur, le mot de passe et le point de terminaison RDS.

```bash
sudo -i
yum install mysql git -y
mysql -h <RDS_endpoint> -u <RDS_username> -p<RDS_password>
show databases;
git clone https://github.com/Adutoby/vprofile-project-all.git
cd vprofileproject-all/
git checkout cd-aws
cd src/main/resources
mysql -h <RDS_endpoint> -u <RDS_username> -p<RDS_password> accounts < db_backup.sql
mysql -h <RDS_endpoint> -u <RDS_username> -p<RDS_password>
use accounts;
show tables;
```

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712869913340/a07d5bf4-97bf-40ad-8659-4f3b8acf2ed4.png align="center")

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712870424101/77aedefd-3a1e-4fd4-a406-bffb18da0fb6.png align="center")

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712870585809/3ceefc86-81f2-465b-8db9-76f1eb12a5d1.png align="center")

### **Mise à jour de la surveillance de l'état :**

Revenez à Elastic Beanstalk sur votre console AWS, dans l'environnement de votre projet, cliquez sur Configuration &gt; modifiez la section Trafic et mise à l'échelle de l'instance, en particulier type d'équilibreur de charge &gt; Cliquez sur **Processus**, et mettez à jour le chemin de vérification de l'état avec ***/login*** . Enregistrez et appliquez les modifications.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712870726859/5ef42776-7ec1-416e-8b64-6ec20764df4c.png align="center")

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712870782874/458b3563-06fe-44b2-a323-42268a911f22.png align="center")

### **Étape 13 : Mettre à jour les scripts pom.xml & settings.xml**

Revenez à CodeCommit et accédez à la branche cd-aws. Mettez à jour les fichiers pom.xml et settings.xml comme nous l'avons fait plus haut dans le projet dans la branche ci-aws et validez les modifications.

Dans le pom.xml, ajoutez l'URL correcte à partir des étapes de connexion de votre artefact de code :

```bash
<repository>
        <id>codeartifact</id>
        <name>codeartifact</name>
    <url>https://visualpath-<awsaccountid>.d.codeartifact.us-east-1.amazonaws.com/maven/maven-central-store/</url>
      </repository>
```

Également dans le fichier settings.xml, mettez à jour l'URL à partir de code artefact de (Remarque: assurez-vous de copier à partir des étapes de connexion et de mettre à jour l'URL en fonction de votre compte)

```bash
<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
  <servers>
        <server>
            <id>codeartifact</id>
            <username>aws</username>
            <password>${env.CODEARTIFACT_AUTH_TOKEN}</password>
        </server>
    </servers>
<profiles>
  <profile>
    <id>default</id>
    <repositories>
      <repository>
        <id>codeartifact</id>
    <url>https://visualpath-<awsaccountid>.d.codeartifact.us-east-1.amazonaws.com/maven/vprofile-maven-repo/</url>
      </repository>
    </repositories>
  </profile>
</profiles>
<activeProfiles>
        <activeProfile>default</activeProfile>
    </activeProfiles>
<mirrors>
  <mirror>
    <id>codeartifact</id>
    <name>visualpath-vprofile-maven-repo</name>
    <url>https://visualpath-<awsaccountid>.d.codeartifact.us-east-1.amazonaws.com/maven/vprofile-maven-repo/</url>
    <mirrorOf>*</mirrorOf>
  </mirror>
</mirrors>
</settings>
```

### **Étape 14 : configuration Build**

Accédez à Codebuild et modifiez le code source des tâches de build précédentes Vprofile-Build et Vprofile-Build-Artifact de ci-aws à cd-aws puisque nous avons l'intention de construire à partir de la branche cd-aws. Cela déclenchera notre travail à partir de la nouvelle branchbranche cd-aws.e qui est la

Cliquez sur le projet de construction &gt; cliquez sur le projet Vprofile-Build &gt; cliquez sur modifier puis sur source &gt; changez la branche source en cd-aws &gt; cliquez sur mettre à jour les modifications. Répétez la même chose pour la branche source de Vprofile-Build-Artifact.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712871211572/89665965-a933-4a18-a7ac-cabfdd226cfe.png align="center")

### **Créer un projet de construction BuildAndRelease**

Créez un nouveau projet de build pour déployer les artefacts sur Elastic Beanstalk. Utilisez les détails ci-dessous:

```bash
Name: Vprofile-BuildAndRelease
Repo: CodeCommit
Repository: vprofile-code-repo
branch: cd-aws
In the Environment
Managed image: Ubuntu
select Standard
Image 5.0
Use existing role from previous Build project which has access to SSM Parameter Store
Buildspec: Insert build commands and switch to editor.
(From source code copy the spec file under `aws-files/buildAndRelease_buildspec.yml`)
LogGroup: vprofile-cicd-logs
Streamname: BuildAndReleaseJob
```

Ensuite, nous devons créer 3 nouveaux paramètres d'environnement qui seront utilisés dans le fichier BuilAndRelease\_buildspec.yml dans le store de paramètres SSM. Voir ci-dessous. Si vous rencontrez une erreur avec le jeton d'artefact, régénérez le.

```bash
RDS-Endpoint: use String
RDSUSER: Use String
RDSPASS: use SecureString as this is the DB password.
```

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712871814200/54d0498f-dda4-4fbd-8b32-d5b2582d9eab.png align="center")

Il est temps de lancer notre projet.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712871986236/d0916e0a-5da6-4aca-b4aa-bc6168f5b806.png align="center")

Notre projet de construction s'est exécuté avec succès !

### **Créez une tâche de build pour les tests logiciels.**

De retour dans le projet de construction, nous créerons un autre projet qui exécutera nos scripts d'automatisation **Selenium** et stockera les artefacts dans le compartiment S3. Tout d’abord, nous devrons créer le bucket S3.

```bash
Name: vprofile-cicd-testoutput-rd (you need to have a unique name for your S3 bucket)
Region: You bucket must be in same region where you create your pipeline
```

Une fois le compartiment créé, nous créerons un nouveau projet de construction pour les tests d'automatisation **Selenium** en utilisant les détails ci-dessous :

```bash
Name: SoftwareTesting
Repo: CodeCommit
branch: seleniumAutoScripts
in the Environment section:
Operating systen: Windows Server 2019
Runtime: Base
Image: 1.0
Use existing role from previous Build project which has access to SSM Parameter Store
Insert build commands: 
From source code we will get spec file under `aws-files/win_buildspec.yml`.
Update url part to your Elastic Beanstalk URL.

Artifacts:
Type: S3
Bucketname: vprofile-cicd-testoutput-toby
Enable semantic versioning
Artifcats packaging: zip
LogGroup: vprofile-cicd-logs
Streamname:
```

### **Étape 15 : Créer un pipeline**

Créez un CodePipeline avec le nom vprofile-cicd-pipeline. utilisez les détails ci-dessous pour le configurer :

```bash
Pipeline name: vprofile-cicd-pipeline
Source provider: CodeCommit
Repository name: vprofile-code-repo
Branch name: cd-aws
select Amazon CloudWatch Events
select CodePipeline default
```

```bash
Build
Build Provider: CodeBuild
Project Name: Vprofile-BuildAndRelease
Build type: Single Build
```

```bash
Deploy
Deploy provider: Beanstalk
Application name: vprofile-app
Environment name: vprofile-app-env
click on next and create pipeline
```

Arrêtez le pipeline une fois qu'il est lancé et modifiez-le pour ajouter d'autres étapes.

Après l'étape Source, ajoutez l'étape CodeAnalysis en utilisant les détails ci-dessous :

```bash
Name: CodeAnalysis
Action provider: CodeBuild
Input artifacts: SourceArtifact
Project name: Vprofile-Build
Build type: single build
```

Ajoutez une deuxième étape également appelée étape CodeAnalysis pour créer et stocker les artefacts :

```bash
Name: BuildAndStore
Action provider: CodeBuild
Input artifacts: SourceArtifact
Project name: Vprofile-Build-artifact
OutputArtifact: BuildArtifact
```

Ajoutez ensuite une autre après l’étape BuildAndStore appelée étape DeployTos3. Cette étape déploiera l'artefact sur le compartiment S3 :

```bash
Name: DeployToS3
Action provider: Amazon S3
Input artifacts: BuildArtifact
Bucket name: vprofile98-build-artifact
check the Extract file before deploy box
```

Modifiez les artefacts de sortie des étapes Build et Deploy. Remplacez le nom de l'artefact de sortie par ***BuildArtifactToBeanStalk*** .

Modifiez à nouveau l'étape de déploiement, remplacez ***InputArtifact*** par ***BuildArtifactToBeanStalk.***

Enfin, ajoutez après l’étape Deploy une étape pour tester l'application. Utilisez les détails ci-dessous:

```bash
Name: Software Testing
Action provider: CodeBuild
Input artifacts: SourceArtifact
ProjectName: SoftwareTesting
```

Enregistrez et appliquer la modification. Le CodePipeline devrait démarrer automatiquement.

### **Étape 16 : Notification SNS**

Sélectionnez le pipeline &gt; Cliquez sur Notifier &gt; Cliquez sur Gérer la notification. Créez une nouvelle notification et enregistrez.

```bash
vprofile-aws-cicd-pipeline-notification
Select all
Notification Topic: use same topic from CI pipeline
```

### **Étape 17 : Valider et tester**

Le pipeline s'est exécuté avec succès.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712872543780/0684f0a0-d320-4a4f-ac36-2b2380666d20.png align="center")

Revenez à votre environnement Elastic Beanstalk et récupérez le domaine ou le point de terminaison, collez-le dans un navigateur et vous devriez voir votre site Web opérationnel.

Si vous disposez de plusieurs instances, vous devrez activer la persistance de session. vous le trouverez en modifiant la section Trafic d'instance et mise à l'échelle dans la configuration, en particulier Type d'équilibreur de charge &gt; Cliquez sur Processus &gt; Action &gt; modifier, puis recherchez les sessions, &gt; activez la persistance de session en cochant la case. Assurez-vous de suivre ces étapes si vous avez plus d'une instance définie comme instance minimale dans vos configurations d'équilibrage de charge.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1713008719920/02b20aba-a445-4e3f-94a5-da41fe066bf7.png align="center")

```bash
Nom d'utilisateur : admin_vp 
Mot de passe : admin_vp
```

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1713008936024/cccc0d35-9561-4b5c-821d-aacc530e4019.png align="center")

Félicitation !!! Vous avez arrivez à bout du projet.
