Bonjour !

Whoami

Et vous ?

Organisation du Cours

Objectifs

Temps

Evaluation

Evaluation

QCM

Rendu de TP

Source Code Management (SCM)

Qu’est ce que le SCM ?

Pourquoi les SCM ?

Quels sont les types de SCM ?

SCM Locaux

SCM Centralisés (CVCS)

SCM Distribués (DVCS)

Comment héberger son SCM ?

SCM "Hébergés dans le Cloud"

SCM "Hébergés à la maison"

Terminologie des SCM : Basiques

Terminologie des SCM : Représentation

Terminologie des SCM : Branches

Terminologie des SCM : Merge

Terminologie des SCM : Pull Request

Motifs d’utilisation des SCMs ?

Centralized Flow

Feature Branch Flow

Git Flow

GitHub Flow

Résoudre des problèmes avec le SCM

Pour aller plus loin…​

Tests Logiciels

Pourquoi tester un logiciel ?

Qu’est ce que le "test logiciel" ?

Tests Automatisé ou Manuels ?

Terminologie du Test Logiciel

Comment tester le logiciel ?

Test Unitaire

Tests d’Intégration

Smoke Testing

Tests Fonctionnels

Tests de Régression

Tests d’Acceptation

Ordre des Tests

Test Driven Development

Behaviour Driven Development

Pour aller plus loin…​

"Continuous Everything"

Qu’est ce que l’Intégration Continue ?

Intégration Continue (CI)

Pourquoi la CI ?

Livraison Continue

Pourquoi la Livraison Continue ?

Qu’est ce que la Livraison Continue ?

Déploiement Continu

Qu’est-ce que le Déploiement Continu ?

Continuous Delivery versus Deployment

Pour aller plus loin…​

Chaîne Logistique du Logiciel

La boucle de rétroaction

Pourquoi de la rétroaction ?

Qu’est-ce qu’une boucle de Feedback ?

Comment implémenter la rétroaction ?

Chaîne Logistique du Logiciel

The Pipeline

Qu’est-ce qu’un Pipeline ?

Anatomie d’un "Pipeline" 1/2

Anatomie d’un "Pipeline" 2/2

Etapes de "Deploiement"

Un example de Pipeline

Comment faire des "bons" Pipelines ?

Bonnes Pratiques

Optimiser le Pipeline

Exemple de Pipeline optimisé

Pour aller plus loin…​

Sécurité: Basiques

Pourquoi la Sécurité ?

Qu’est-ce que la Sécurité ?

AAA

Authentification

Authorisation

Accounting (Comptabilisation)

Pour aller plus loin…​

Démarrer le lab

Pré-requis

Obtenir le projet

Démarrer / Arrêter le lab

docker-compose up -d # Démarrage
docker-compose stop # Suspendre
docker-compose kill # Arrêt brutal
docker-compose down -v # Tout supprimer une fois arrêté

2019-2020 HotFix Gitea

# Arrêter le gitserver
docker-compose kill gitserver
# Nettoyer le gitserver
docker-compose rm -f -v gitserver
# Récupérer le fix
git pull origin 2019-2020
# Récupérer la nouvelle image
docker-compose pull gitserver
# Redémarrer le gitserver
dockr-compose up -d gitserver

Accéder au Lab

Accéder au code source

Demo Application

Pourquoi ?

Demo Application

Demo Application : Technical Stack

Demo Application : Check it

Web Command Line

Command Line Tricks

Quelques commandes

Obtenir le code de la demo

# Get the code. Requires authentication.
git clone http://gitserver:3000/butler/demoapp
# Browse to the local repository
cd ./demoapp
# Check source code
ls -l

Demo Application : Maven

Demo Application : Compiler

Demo Application : Tests Unitaires

Demo Application : Construire

Demo Application : Exécution

Demo Application : Tests d’intégration

Jenkins

Meet Jenkins

Jenkins

Communauté Jenkins

Un Outil Populaire

Jenkins en 2016 : Jenkins 2

Jenkins en 2017

Débuter avec les pipelines

Débuter avec les Pipelines

Syntaxe Déclarative ou Scriptée ?

Blue Ocean Pipeline Editor

Simple Jenkins Pipeline

Accéder à Jenkins

Blue Ocean

Exercice : Configurer le projet dans Jenkins

Exercice : L’éditeur de Pipeline

Exercice : Votre Premier Pipeline

Solution : Votre Premier Pipeline

pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        echo 'Build'
      }
    }
    stage('Test') {
      steps {
        echo 'Test'
      }
    }
    stage('Deploy') {
      steps {
        echo 'Deploy'
      }
    }
  }
}

Exercice : Exécuter des tâches

Solution : Exécuter des tâches

pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        sh './scripts/build.sh'
      }
    }
    stage('Test') {
      steps {
        sh './scripts/integration-tests.sh'
      }
    }
    stage('Deploy') {
      steps {
        sh './scripts/deploy.sh'
      }
    }
  }
}

Exercice : Archives et Tests

Solution : Archives et Tests

pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        sh './scripts/build.sh'
        archiveArtifacts 'target/*.jar'
      }
    }
    stage('Test') {
      steps {
        sh './scripts/integration-tests.sh'
        junit 'target/failsafe-reports/**/*.xml'
      }
    }
    stage('Deploy') {
      steps {
        sh './scripts/deploy.sh'
      }
    }
  }
}

Amélioration du Pipeline

Exercise: Réparer le build

Solution: Réparer le build

Webhooks pour un retour plus rapide

Exercise: Webhooks

Solution: Webhooks

Aller plus loin…​

Exercise - Réutilisation Binaire

Solution - Réutilisation Binaire

pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        sh './scripts/build.sh'
        archiveArtifacts 'target/*.jar'
        stash(name: 'build-result', includes: 'target/**/*')
      }
    }
    stage('Test') {
      steps {
        unstash 'build-result'
        sh './scripts/integration-tests.sh'
        junit 'target/failsafe-reports/**/*.xml'
      }
    }
    stage('Deploy') {
      steps {
        sh './scripts/deploy.sh'
      }
    }
  }
}

Post-Stage

Exercice - Rapport de Tests Unitaires

Solution - Rapport de Tests Unitaires

pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        sh './scripts/build.sh'
      }
      post {
        success {
          archiveArtifacts 'target/*.jar'
          stash(name: 'build-result', includes: 'target/**/*')
        }
        always {
          junit 'target/surefire-reports/**/*.xml'
        }
      }
    }
    stage('Test') {
      steps {
        unstash 'build-result'
        sh './scripts/integration-tests.sh'
        junit 'target/failsafe-reports/**/*.xml'
      }
    }
    stage('Deploy') {
      steps {
        sh './scripts/deploy.sh'
      }
    }
  }
}

Agents

Qu’est ce qu’un Agent?

Exercice : Agents

Solution : Agents

pipeline {
  agent any
  stages {
    stage('Build') {
      agent {
        node {
          label 'maven-jdk8'
        }
      }
      steps {
        sh './scripts/build.sh'
      }
      post {
        always {
          junit 'target/surefire-reports/**/*.xml'
        }
        success {
          archiveArtifacts 'target/*.jar'
          stash(name: 'build-result', includes: 'target/**/*')
        }
      }
    }
    stage('Test') {
      agent {
        node {
          label 'java8'
        }
      }
      steps {
        unstash 'build-result'
        sh './scripts/integration-tests.sh'
        junit 'target/failsafe-reports/**/*.xml'
      }
    }
    stage('Deploy') {
      steps {
        sh './scripts/deploy.sh'
      }
    }
  }
}

Exercice : Tests Parallèles

Solution : Tests Parallèles

pipeline {
  agent any
  stages {
    stage('Build') {
      agent {
        node {
          label 'maven-jdk8'
        }
      }
      steps {
        sh './scripts/build.sh'
      }
      post {
        always {
          junit 'target/surefire-reports/**/*.xml'
        }
        success {
          archiveArtifacts 'target/*.jar'
          stash(name: 'build-result', includes: 'target/**/*')
        }
      }
    }
    stage('Test') {
      parallel {
        stage('Test Java 8') {
          agent {
            node {
              label 'java8'
            }
          }
          steps {
            unstash 'build-result'
            sh './scripts/integration-tests.sh'
            junit 'target/failsafe-reports/**/*.xml'
          }
        }
        stage('Test Java Next') {
          agent {
            node {
              label 'javanext'
            }
          }
          steps {
            unstash 'build-result'
            sh './scripts/integration-tests.sh'
            junit 'target/failsafe-reports/**/*.xml'
          }
        }
      }
    }
    stage('Deploy') {
      steps {
        sh './scripts/deploy.sh'
      }
    }
  }
}

Agents avec Docker

Exercice : Agent Docker

Solution : Agent Docker

pipeline {
  agent any
  stages {
    stage('Build') {
      agent {
        dockerfile {
          filename 'Dockerfile.build'
          label 'docker'
          additionalBuildArgs  '--build-arg HTTP_PROXY=http://10.0.4.2:3128/ --build-arg HTTPS_PROXY=http://10.0.4.2:3128/'
        }
      }
      steps {
        sh './scripts/build.sh'
      }
      post {
        always {
          junit 'target/surefire-reports/**/*.xml'
        }
        success {
          archiveArtifacts 'target/*.jar'
          stash(name: 'build-result', includes: 'target/**/*')
        }
      }
    }
    stage('Test') {
      parallel {
        stage('Test Java 8') {
          agent {
            node {
              label 'java8'
            }
          }
          steps {
            unstash 'build-result'
            sh './scripts/integration-tests.sh'
            junit 'target/failsafe-reports/**/*.xml'
          }
        }
        stage('Test Java Next') {
          agent {
            node {
              label 'javanext'
            }
          }
          steps {
            unstash 'build-result'
            sh './scripts/integration-tests.sh'
            junit 'target/failsafe-reports/**/*.xml'
          }
        }
      }
    }
    stage('Deploy') {
      steps {
        sh './scripts/deploy.sh'
      }
    }
  }
}

Docker

Docker: un environment portable

Exercices avec Docker

## Construire uniquement l'environnement de build
docker build --build-arg HTTP_PROXY=http://10.0.4.2:3128/ \
    --build-arg HTTPS_PROXY=http://10.0.4.2:3128/  \
    -t demoapp:build -f Dockerfile.build ./

## Executer un container
mvn -v
docker run --rm -ti -v $(pwd):/app --entrypoint="bash" demoapp:build
bash-4.4# ls -al /app
bash-4.4# mvn -v # Difference ?

Agents avec Docker

Exercice : Agent Docker

Solution : Agent Docker 1/3

pipeline {
  agent any
  stages {
    stage('Build') {
      agent {
        dockerfile {
          filename 'Dockerfile.build'
          label 'docker'
          additionalBuildArgs  '--build-arg HTTP_PROXY=http://10.0.4.2:3128/ --build-arg HTTPS_PROXY=http://10.0.4.2:3128/'
        }
      }
      steps {
        sh './scripts/build.sh'
      }
      post {
        always {
          junit 'target/surefire-reports/**/*.xml'
        }
        success {
          archiveArtifacts 'target/*.jar'
          stash(name: 'build-result', includes: 'target/**/*')
        }
      }
    }
    stage('Test') {
      parallel {
        stage('Test Java 8') {
          agent {
            node {
              label 'java8'
            }
          }
          steps {
            unstash 'build-result'
            sh './scripts/integration-tests.sh'
            junit 'target/failsafe-reports/**/*.xml'
          }
        }
        stage('Test Java Next') {
          agent {
            node {
              label 'javanext'
            }
          }
          steps {
            unstash 'build-result'
            sh './scripts/integration-tests.sh'
            junit 'target/failsafe-reports/**/*.xml'
          }
        }
      }
    }
    stage('Deploy') {
      steps {
        sh './scripts/deploy.sh'
      }
    }
  }
}

Solution : Agent Docker 2/3

<settings>
    <proxies>
        <proxy>
            <id>httpproxy</id>
            <active>true</active>
            <protocol>http</protocol>
            <host>10.0.4.2</host>
            <port>3128</port>
            <nonProxyHosts>ensg.eu|localhost</nonProxyHosts>
        </proxy>
        <proxy>
            <id>httpsproxy</id>
            <active>true</active>
            <protocol>https</protocol>
            <host>10.0.4.2</host>
            <port>3128</port>
            <nonProxyHosts>ensg.eu|localhost</nonProxyHosts>
        </proxy>
    </proxies>
</settings>

Solution : Agent Docker 3/3

FROM maven:3-jdk-8-alpine
# Install Some tools
RUN apk add --no-cache \
  curl \
  bats \
  docker \
  git

# Configure Proxy
RUN mkdir -p /root/.m2
COPY ./settings.xml /root/.m2/settings.xml

Pipeline Avancés

Input

Exercice : Validation Humaine

Solution : Validation Humaine

pipeline {
  agent any
  stages {
    stage('Build') {
      agent {
        dockerfile {
          filename 'Dockerfile.build'
          label 'docker'
          additionalBuildArgs  '--build-arg HTTP_PROXY=http://10.0.4.2:3128/ --build-arg HTTPS_PROXY=http://10.0.4.2:3128/'
        }
      }
      steps {
        sh './scripts/build.sh'
      }
      post {
        always {
          junit 'target/surefire-reports/**/*.xml'
        }
        success {
          archiveArtifacts 'target/*.jar'
          stash(name: 'build-result', includes: 'target/**/*')
        }
      }
    }
    stage('Test') {
      parallel {
        stage('Test Java 8') {
          agent {
            node {
              label 'java8'
            }
          }
          steps {
            unstash 'build-result'
            sh './scripts/integration-tests.sh'
            junit 'target/failsafe-reports/**/*.xml'
          }
        }
        stage('Test Java Next') {
          agent {
            node {
              label 'javanext'
            }
          }
          steps {
            unstash 'build-result'
            sh './scripts/integration-tests.sh'
            junit 'target/failsafe-reports/**/*.xml'
          }
        }
      }
    }
    stage('Approval') {
      agent none
      steps {
        input(message: 'Deploy Application?', ok: 'Yes Deploy!')
      }
    }
    stage('Deploy') {
      steps {
        sh './scripts/deploy.sh'
      }
    }
  }
}

Conditionnal Stage

Variables d’environments

Exercice : Déploiement Conditionnel

Solution : Déploiement Conditionnel

pipeline {
  agent any
  environment {
    FORCE_DEPLOY = 'false'
  }
  stages {
    stage('Build') {
      agent {
        dockerfile {
          filename 'Dockerfile.build'
          label 'docker'
          additionalBuildArgs  '--build-arg HTTP_PROXY=http://10.0.4.2:3128/ --build-arg HTTPS_PROXY=http://10.0.4.2:3128/'
        }
      }
      steps {
        sh './scripts/build.sh'
      }
      post {
        always {
          junit 'target/surefire-reports/**/*.xml'
        }
        success {
          archiveArtifacts 'target/*.jar'
          stash(name: 'build-result', includes: 'target/**/*')
        }
      }
    }
    stage('Test') {
      parallel {
        stage('Test Java 8') {
          agent {
            node {
              label 'java8'
            }
          }
          steps {
            unstash 'build-result'
            sh './scripts/integration-tests.sh'
            junit 'target/failsafe-reports/**/*.xml'
          }
        }
        stage('Test Java Next') {
          agent {
            node {
              label 'javanext'
            }
          }
          steps {
            unstash 'build-result'
            sh './scripts/integration-tests.sh'
            junit 'target/failsafe-reports/**/*.xml'
          }
        }
      }
    }
    stage('Approval') {
      agent none
      steps {
        input(message: 'Deploy Application?', ok: 'Yes Deploy!')
      }
      when {
        anyOf {
          branch 'master'
          environment name: 'FORCE_DEPLOY', value: 'true'
        }
      }
    }
    stage('Deploy') {
      steps {
        sh './scripts/deploy.sh'
      }
      when {
        anyOf {
          branch 'master'
          environment name: 'FORCE_DEPLOY', value: 'true'
        }
      }
    }
  }
}

Paramètres

Exercice : Paramètres

Solution : Paramètres

pipeline {
  agent any
  parameters {
    string(name: 'DEPLOY_MESSAGE', defaultValue: 'Deploy ?', description: 'Message de déploiement')
  }
  environment {
    FORCE_DEPLOY = 'false'
  }
  stages {
    stage('Build') {
      agent {
        dockerfile {
          filename 'Dockerfile.build'
          label 'docker'
          additionalBuildArgs  '--build-arg HTTP_PROXY=http://10.0.4.2:3128/ --build-arg HTTPS_PROXY=http://10.0.4.2:3128/'
        }
      }
      steps {
        sh './scripts/build.sh'
      }
      post {
        always {
          junit 'target/surefire-reports/**/*.xml'
        }
        success {
          archiveArtifacts 'target/*.jar'
          stash(name: 'build-result', includes: 'target/**/*')
        }
      }
    }
    stage('Test') {
      parallel {
        stage('Test Java 8') {
          agent {
            node {
              label 'java8'
            }
          }
          steps {
            unstash 'build-result'
            sh './scripts/integration-tests.sh'
            junit 'target/failsafe-reports/**/*.xml'
          }
        }
        stage('Test Java Next') {
          agent {
            node {
              label 'javanext'
            }
          }
          steps {
            unstash 'build-result'
            sh './scripts/integration-tests.sh'
            junit 'target/failsafe-reports/**/*.xml'
          }
        }
      }
    }
    stage('Approval') {
      agent none
      steps {
        input(message: params.DEPLOY_MESSAGE, ok: 'Yes Deploy!')
      }
      when {
        anyOf {
          branch 'master'
          environment name: 'FORCE_DEPLOY', value: 'true'
        }
      }
    }
    stage('Deploy') {
      steps {
        sh './scripts/deploy.sh'
      }
      when {
        anyOf {
          branch 'master'
          environment name: 'FORCE_DEPLOY', value: 'true'
        }
      }
    }
  }
}

Options & Configurations

Exercice : Options & Timeout Approval

Solution : Options & Timeout Approval

pipeline {
  agent any
  options {
    buildDiscarder(logRotator(numToKeepStr: '5'))
  }
  parameters {
    string(name: 'DEPLOY_MESSAGE', defaultValue: 'Deploy ?', description: 'Message de déploiement')
  }
  environment {
    FORCE_DEPLOY = 'false'
  }
  stages {
    stage('Build') {
      agent {
        dockerfile {
          filename 'Dockerfile.build'
          label 'docker'
          additionalBuildArgs  '--build-arg HTTP_PROXY=http://10.0.4.2:3128/ --build-arg HTTPS_PROXY=http://10.0.4.2:3128/'
        }
      }
      steps {
        sh './scripts/build.sh'
      }
      post {
        always {
          junit 'target/surefire-reports/**/*.xml'
        }
        success {
          archiveArtifacts 'target/*.jar'
          stash(name: 'build-result', includes: 'target/**/*')
        }
      }
    }
    stage('Test') {
      parallel {
        stage('Test Java 8') {
          agent {
            node {
              label 'java8'
            }
          }
          steps {
            unstash 'build-result'
            sh './scripts/integration-tests.sh'
            junit 'target/failsafe-reports/**/*.xml'
          }
        }
        stage('Test Java Next') {
          agent {
            node {
              label 'javanext'
            }
          }
          steps {
            unstash 'build-result'
            sh './scripts/integration-tests.sh'
            junit 'target/failsafe-reports/**/*.xml'
          }
        }
      }
    }
    stage('Approval') {
      agent none
      steps {
        timeout(time: 3, unit: 'MINUTES') {
          input(message: params.DEPLOY_MESSAGE, ok: 'Yes Deploy!')
        }
      }
      when {
        anyOf {
          branch 'master'
          environment name: 'FORCE_DEPLOY', value: 'true'
        }
      }
    }
    stage('Deploy') {
      steps {
        sh './scripts/deploy.sh'
      }
      when {
        anyOf {
          branch 'master'
          environment name: 'FORCE_DEPLOY', value: 'true'
        }
      }
    }
  }
}

Aller plus loin

Industrie CI/CD

Analyse du besoin

De nombreux outils 1/2

De nombreux outils 2/2

Le Futur