Docker est un outil de contenairisation pour creer des contenaire, chaque

contenaire est un micro vm pour executer une application si l'application s'arrete,

le contenaire est detruit
docker build -t [ciproject] --build-arg JAR_FILE=bouda.jar . ---> besoin d'un
docker file => cree image docker
docker run -d -p 8000:8081 ciproject

Github= platforme git pour versionner le code

kubernetes est une platforme de deploiement qui utilise docker

pod = docker run avec une config bien precise
= un ou plusieurs contenaires
deploiment= est une rsource de kubernetes qui cree un pod avec un ou plusieurs
replication
service pour exposer les pod 2 clusterip et (Nodeport forward to localmachine on
port between 30000 32768)

jenkins = est un outil d'integration continue, il y a 2 types de pipeline,

declaratif et scripté

nexus= c'est un repertoire privé pour stocker les libréries et les applications
buildés et pour stocker les images docker
eg. dans java on peut stocker JARs/WAR dans nexus

sonarqube= c'est un outil devops qui permet d'evaluer la qualité du code, comme les
vulnerabilté, les code couverages, les codes...

dans le CICD moderne, les serveurs d'applications comme tomcat sont contenairisé,
alors j'ai decider de creer un workflow CICD a jour en utilisant les technologies
modernes comme minikube(une version de kuberetes local), docker,
jenkins(contenairisé, master and nodes) , nexus (contenairisé), sonarqube(serveur
physique, manque de ressources)

Tout d'abord dans jenkins on a configuré le plugin de github, le plugin de

kubernetes existe deja parceque le jenkins est deployé en utilisant helm et aussi
pour creer les agents sur la plateforme kubernetes et on a aussi configuré les
plugins comme cleaning workspace pour nettoyer le workspace avant chaque run

Dans jenkis il y a 2 types de creation de pipeline. il y a le type declaratif qui

est plus simple et facile a utiliser et les fonctions sont deja predefinies et
commance toujour par pipeline{}. et il ya le type scripté, qui est un peu compliqué
car il utilise le language de scripting groovy, ce qui est present dans ce travail.
dans ce type le pipeline commance par node(''){}

on ne peut pas faire des tache complexes dans le type declaratif.

helm= c'est le manageur des applications kubernetes qui permettent d'installer

modifier, mettre a jour et supprimer des applications.
on a utilisé helm pour installer jenkins, nexus et mysql.
helm install --name jenkins stable/jenkins -f .\jenkins-values.yml
helm install --name my-release stable/mysql -f .\mysql.yml
PS C:\minikube> helm install --name nexus -f .\nexus.yml stable/sonatype-nexus

on modifie le serviceType: NodePort pour qu'il soit exposé sur minikube

STAGE préInitial:
Dans le cas ou jenkins est deployé sur kuberenetes, on doit definir notre agent qui
sera un pod sur la plateforme kubernetes, dans ce pod on va creer 4 contenaires, un
contenaire pour faire le git checkout, un pour builder le code en utilisant maven.
et un pour pour builder les images docker, et le dernier pour deployer sur
kubernetes.

STAGE DOCKER:

Tout d'abord on commance par builder le docker image en utilisant le dockerfile, on

commance par definir l'image de base, dans notre cas c'est open jdk, puis on ajoute
un group et un utilisateur "spring" pour que l'image ne roule pas avec root, en
suite j'ai défini 2 label pour tester, apres on a definit un argumant pour definir
l'emplacement du war, par defaut il prend la valeur target/timesheet-1.0.0-
SNAPSHOT.war . apres on copie le war dans dockerimage et enfin on lance
l'application
Puisqu'on doit faire un push vers un registre privé, selon docker on doit taguer
l'image avec un tag private-repo-ip/imagename:tag
docker tag ciproject_$BUILD_NUMBER:latest
192.168.99.100:32068/ciproject_$BUILD_NUMBER:latest
ensuite on a loguer en utilisant la commande docker login dans le private registry.
et enfin on a pousser l'image vers notre registry.

Stage Déploiement:
apres avoir buildé l'image et poussé dans le private registry, on doit le deployer
dans minikube en utilisant la commande kubectl
La premiere commande etait kubectl apply -f deployment.yml , ce fichier contient la
definition d'un deploiement dans kubernetes. en suite on update ce deploiement avec
la nouvelle image qu'on a crée, en utilisant ( kubectl set image deployment
ciproject ciproject=ciproject_$BUILD_NUMBER:latest)
et enfin on a exposé ce deploiement en utilisant le service dans kubernetes avec la
commande kubectl expose deployment ciproject --type=NodePort --port=8010|| true

Nexus= on a passé sur l'interface adminsitrave, dans le menu repository on a créer

un hosted docker et on a sauvguarder la config. maintenat chaque run dans jenkins
on push une nouvelle image vers nexus

maven = gestion des dependances, details des livrables, le packaging et la

compilation