Ce repository content les artifacts du cours DevSecOps pour l'ESGI
Les templates AWS ou Azure sont disponibles pour déployer la VM utilisée pour les outils nécessaires à la pratique DevSecOps.
La VM utilisée pour les outils CI/CD
Utiliser les commandes ci-dessous pour installer Trivy
sudo apt-get install wget apt-transport-https gnupg lsb-release -y
wget -qO - https://aquasecurity.github.io/trivy-repo/deb/public.key | gpg --dearmor | sudo tee /usr/share/keyrings/trivy.gpg > /dev/null
echo "deb [signed-by=/usr/share/keyrings/trivy.gpg] https://aquasecurity.github.io/trivy-repo/deb $(lsb_release -sc) main" | sudo tee -a /etc/apt/sources.list.d/trivy.list
sudo apt-get update
sudo apt-get install trivy -yUtiliser les commandes ci-dessous pour installer Docker sur la VM :
sudo apt-get update
sudo apt-get install docker.io -y
sudo usermod -aG docker $USER
newgrp docker
sudo chmod 777 /var/run/docker.sockLes composants suivants sont déployés et utilisés pour illuster un pipeline DevSecOps.
L'installation se fait avec les commandes ci-dessous. Celles-ci sont regroupées dans le fichier jenkins.sh.
#!/bin/bash
sudo apt update -y
wget -O - https://packages.adoptium.net/artifactory/api/gpg/key/public | tee /etc/apt/keyrings/adoptium.asc
echo "deb [signed-by=/etc/apt/keyrings/adoptium.asc] https://packages.adoptium.net/artifactory/deb $(awk -F= '/^VERSION_CODENAME/{print$2}' /etc/os-release) main" | tee /etc/apt/sources.list.d/adoptium.list
sudo apt update -y
sudo apt install temurin-17-jdk -y
/usr/bin/java --version
curl -fsSL https://pkg.jenkins.io/debian-stable/jenkins.io-2023.key | sudo tee \
/usr/share/keyrings/jenkins-keyring.asc > /dev/null
echo deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc] \
https://pkg.jenkins.io/debian-stable binary/ | sudo tee \
/etc/apt/sources.list.d/jenkins.list > /dev/null
sudo apt-get update -y
sudo apt-get install jenkins -y
sudo systemctl start jenkins
sudo systemctl status jenkinssudo chmod 777 jenkins.sh
./jenkins.shLe port utilisé par défaut par Jenkins est le 8080, dans le cadre de cet exercice, nous allons le changer pour le port 8090 car l'application sera exposée sur le port 8080
Pour modifier le port de Jenkins, il s'agit de modifier des fichiers de configuration dans les fichiers /etc/default/jenkins et /lib/systemd/system/jenkins.service.
- Arrêter le service Jenkins :
sudo systemctl stop jenkins - Vérifier que Jenkins est bien arrêté :
sudo systemctl status jenkins - Modifier la valeur de la ligne
HTTP_PORT=à 8090 dans/etc/default/jenkins - Modifier la valeur du port
Environments="Jenkins_port=à 8090 dans /lib/systemd/system/jenkins.service - Redémarrer le daemon systemctl :
sudo systemctl daemon-reload - Redémarrer le service Jenkins :
sudo systemctl restart jenkins - Vérifier que Jenkins est bien démarré :
sudo systemctl status jenkins
http://<IP publique de la VM>:8090
sudo cat /var/lib/jenkins/secrets/initialAdminPassword
SonarQube est un outil SAST qui permet l'analyse de sécurité du code. SonarQube est exécutée sous forme de conteneur.
docker run -d --name sonar -p 9000:9000 sonarqube:lts-communityUne fois le conteneur déployé, vérifier qu'il est bien démarré et en état running
http://<IP publique de la VM>:9000
Les credentials à utiliser pour la première connexion sont admin/admin.
SonarQube vous demande de modifier le mot de passe admin
Voici la console de SonarQube :
👉 Eclipse Temurin Installer
👉 SonarQube Scanner
Créer un item dans Jenkins de type Pipeline que vous pouvez nommer petstore
Et utiliser le code ci-dessous pour définir le pipeline ;
pipeline{
agent any
tools {
jdk 'jdk17'
maven 'maven3'
}
stages{
stage ('clean Workspace'){
steps{
cleanWs()
}
}
stage ('checkout scm') {
steps {
git 'https://github.com/smontri/jpetstore-6.git'
}
}
stage ('maven compile') {
steps {
sh 'mvn clean compile'
}
}
stage ('maven Test') {
steps {
sh 'mvn test'
}
}
}
}
Attention à bien utiliser le fork du repo
jpetstore-6, que vous avez fait avant de démarrer, dans le stagecheckout scm.
Il s'agit de créer une token pour l'utilisateur SonarQube qui sera utilisée par Jenkins pour invoquer SonarQube dans le pipeline.
Cette token doit ensuite être utilisée pour configurer les credentials Sonar dans Jenkins.
ID = sonar-token
Description = sonar-token
Dans Jenkins - Manage Jenkins -> System, configurer le serveur SonarQube comme ci-dessous.
Dans Jenkins - Manage Jenkins -> Tools, ajouter un scanner pour SonarQube
Il s'agit de configurer un webhook dans SonarQube pour récupérer les informations dans la console Jenkins.
Depuis la console SonarQube :
Name : Jenkins
URL : <http://IP Jenkins:8090>/sonarqube-webhook/
Nous allons ajouter 2 étapes au pipeline ainsi que des informations d'environnement pour l'utilisation du scanner SonarQube.
- Environnement du scanner, à ajouter sous la section
tools
environment {
SCANNER_HOME=tool 'sonar-scanner'
}
- Ajout des étapes du pipeline, à ajouter en fin de liste des
stages
stage("Sonarqube Analysis "){
steps{
withSonarQubeEnv('sonar-server') {
sh ''' $SCANNER_HOME/bin/sonar-scanner -Dsonar.projectName=Petshop \
-Dsonar.java.binaries=. \
-Dsonar.projectKey=Petshop '''
}
}
}
stage("quality gate"){
steps {
script {
waitForQualityGate abortPipeline: false, credentialsId: 'Sonar-token'
}
}
}
Le pipeline doit, à présent, ressembler à ceci :
Et vous pouvez consulter le résultat de l'analyse SonarQube dans la console :
- Pour effectuer cette analyse, on s'appuie sur un plugin Jenkins
OWASP Dependency check.
A installer via Manage Jenkins -> Plugins
- Pour configurer l'outil dans Jenkins, Manage Jenkins -> Tools
- Ajout de l'étape dans le pipeline, , à ajouter en fin de liste des
stages
stage ('Build war file'){
steps{
sh 'mvn clean install -DskipTests=true'
}
}
stage("OWASP Dependency Check"){
steps{
dependencyCheck additionalArguments: '--scan ./ --format XML ', odcInstallation: 'DP-Check'
dependencyCheckPublisher pattern: '**/dependency-check-report.xml'
}
}
Le pipeline doit, à présent, ressembler à ceci :
Et pour visualiser le résultat de check des dépendances :
Il s'agit d'ajouter les plugins suivants :
DockerDocker CommonsDocker PipelineDocker APIdocker-build-step
Il s'agit de votre compte Docker Hub à renseigner
A ajouter en fin de liste des
stages
stage ('Build and push to docker hub'){
steps{
script{
withDockerRegistry(credentialsId: 'docker', toolName: 'docker') {
sh "docker build -t petshop ."
sh "docker tag petshop <dockerhub username>/petshop:latest"
sh "docker push <dockerhub username>/petshop:latest"
}
}
}
}
stage("TRIVY"){
steps{
sh "trivy image smontri/petshop:latest > trivy.txt"
}
}
stage ('Deploy to container'){
steps{
sh 'docker run -d --name pet1 -p 8080:8080 <dockerhub username>/petshop:latest'
}
}
Remplacer la valeur par votre nom d'utilisateur Docker Hub
Le pipeline doit, à présent, ressembler à ceci :
On peut y voir également un graphe de tendances de l'analyse des dépendances
Et l'étape d'analyse de vulnérabilités par Trivy
L'application est accessible via l'URL suivante : http://<IP publique de la VM>:8080/jpetstore
Question : sur quel composant tourne l'application en l'état actuel
A présent, nous allons déployer l'application vers un cluster Kubernetes
-
Me demander le fichier de configuration Kubernetes
-
Installer les plugins suivants dans Jenkins
- Ajout des credentials Kubernetes
- Installation commande kubectl
sudo apt update
sudo apt install curl
curl -LO https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl
sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl
kubectl version --client
- Ajout du stage de déploiement de Kubernetes
Créer un namespace avec le numéro du goupe (ex. groupe1) pour déployer votre application dans le namespace correspondant
stage('K8s'){
steps{
script{
withKubeConfig(caCertificate: '', clusterName: '', contextName: '', credentialsId: 'k8s', namespace: '', restrictKubeConfigAccess: false, serverUrl: '') {
sh 'kubectl create ns <votre namespace>'
sh 'kubectl apply -f deployment.yaml -n <votre namespace>'
}
}
}
}
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent