Kovalibre Logo partenaire

Azure DevOps, mettre en œuvre l’intégration continue

@vanessakovalsky

1 Introduction

1.1 Présentation d’Azure DevOps

1.2 Objectifs

  • Mettre en place une intégration continue avec Azure
  • Maîtriser la chaîne de déploiement continu : les bons réflexes, les outils, les rituels collaboratifs
  • Développer le culte de la mesure et mettre en œuvre les bonnes pratiques

1.3 Program

  • Intégration continue et Azure DevOps
  • Le contrôleur de code source
  • Mettre en place des tests
  • Les Builds
  • Les release et leurs déploiements
  • Validation et déclenchement des déploiements
  • La gestion des releases
  • Fonctionnement de l’agent pool

2 Intégration continue et Azure DevOps

2.1 Objectifs pédagogiques

À l’issue de ce module, vous serez capable de :

  • Comprendre les principes et avantages de l’intégration continue
  • Identifier les composants nécessaires à l’intégration continue
  • Maîtriser les concepts fondamentaux d’Azure DevOps
  • Créer et configurer un projet Azure DevOps
  • Gérer les droits d’accès et les acteurs du projet

2.2 Les principes, objectifs et avantages de l’intégration continue

2.2.1 Qu’est-ce que l’intégration continue (CI) ?

L’Intégration Continue (Continuous Integration) est une pratique de développement logiciel qui consiste à intégrer régulièrement les modifications de code dans un référentiel partagé, plusieurs fois par jour.

2.2.2.1 Principes fondamentaux

Les 5 principes clés :

  1. Un dépôt unique : Tout le code source est centralisé dans un seul référentiel
  2. Automatisation du build : Chaque commit déclenche une construction automatique
  3. Tests automatiques : Des tests sont exécutés à chaque intégration
  4. Commits fréquents : Les développeurs intègrent leur code quotidiennement
  5. Feedback rapide : L’équipe est immédiatement informée des problèmes

2.2.4 Objectifs de l’intégration continue

Objectif Description Bénéfice
Détection précoce des erreurs Identifier les bugs dès leur introduction Réduction des coûts de correction
Qualité du code Maintenir un niveau de qualité constant Code plus maintenable
Réduction des risques Intégrations petites et fréquentes Moins de conflits
Accélération des livraisons Processus automatisé et fiable Time-to-market réduit
Collaboration améliorée Visibilité sur l’état du projet Communication facilitée

2.2.5 Avantages de l’intégration continue

2.2.5.1 Pour l’équipe de développement

✅ Moins de bugs en production - Détection précoce des problèmes - Tests automatisés systématiques - Validation continue du code

✅ Gain de temps - Automatisation des tâches répétitives - Moins de temps passé à corriger les bugs - Déploiements plus rapides

✅ Meilleure collaboration - Visibilité partagée sur l’état du code - Feedback immédiat - Réduction des conflits de fusion

2.2.6.1 Pour le business

💰 Réduction des coûts

  • Moins de temps passé sur les bugs
  • Détection précoce = correction moins coûteuse
  • Automatisation = moins de ressources mobilisées

📈 Amélioration de la qualité

  • Produit plus stable
  • Moins de régressions
  • Satisfaction client accrue

⚡ Time-to-market réduit

  • Livraisons plus fréquentes
  • Feedback client plus rapide
  • Adaptation agile aux besoins

2.2.7 Le cycle de l’intégration continue

2.3 Les différents composants nécessaires pour faire de l’intégration continue

2.3.1 Architecture globale d’un système CI/CD

┌─────────────────────────────────────────────────────────────┐
│                    SYSTÈME CI/CD                            │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ┌──────────────┐      ┌──────────────┐      ┌────────────┐ │
│  │   Contrôle   │──────│    Build     │──────│  Tests     │ │
│  │   de Source  │      │   Système    │      │ Automatisés│ |
│  └──────────────┘      └──────────────┘      └────────────┘ │
│         │                     │                     │       │
│         └─────────────────────┼─────────────────────┘       │
│                               │                             │
│                    ┌──────────▼──────────┐                  │
│                    │   Orchestrateur     │                  │
│                    │   de Pipeline       │                  │
│                    └──────────┬──────────┘                  │
│                               │                             │
│         ┌─────────────────────┼─────────────────────┐       │
│         │                     │                     │       │
│  ┌──────▼──────┐      ┌──────▼──────┐      ┌────────▼────┐  │
│  │  Artefacts  │      │ Déploiement │      │Notification │  │
│  │  Repository │      │   Système   │      │  Système    │  │
│  └─────────────┘      └─────────────┘      └─────────────┘  │
│                                                             │
└─────────────────────────────────────────────────────────────┘

2.3.2 1. Système de contrôle de version

Rôle : Gérer le code source et son historique

Options :

  • Git (recommandé) : Système distribué, flexible
  • TFVC (Team Foundation Version Control) : Système centralisé Microsoft

Fonctionnalités clés :

  • Gestion des branches
  • Historique complet des modifications
  • Collaboration multi-développeurs
  • Fusion et résolution de conflits

2.3.3 2. Serveur de build

Rôle : Compiler le code et créer les artefacts

Composants :

  • Agent de build : Machine qui exécute les tâches
  • Pipeline de build : Définition des étapes de compilation
  • Outils de compilation : MSBuild, Maven, Gradle, npm, etc.

Exemple de pipeline de build :

# Exemple Azure Pipelines
trigger:
  - main

pool:
  vmImage: 'ubuntu-latest'

steps:
- task: DotNetCoreCLI@2
  displayName: 'Restore dependencies'
  inputs:
    command: 'restore'

- task: DotNetCoreCLI@2
  displayName: 'Build project'
  inputs:
    command: 'build'
    configuration: 'Release'

- task: DotNetCoreCLI@2
  displayName: 'Run tests'
  inputs:
    command: 'test'

2.3.5 3. Framework de tests

Types de tests automatisés :

Type de test Objectif Exemple d’outils
Tests unitaires Valider des fonctions isolées NUnit, xUnit, JUnit
Tests d’intégration Valider l’interaction entre composants SpecFlow, Selenium
Tests de performance Mesurer les performances JMeter, Apache Bench
Tests de sécurité Détecter les vulnérabilités OWASP ZAP, SonarQube

Pyramide des tests :

          /\
         /  \
        / UI \          Peu nombreux, lents, coûteux
       /______\
      /        \
     /  Intég.  \      Volume moyen, temps moyen
    /____________\
   /              \
  /   Unitaires    \   Nombreux, rapides, peu coûteux
 /__________________\

2.3.7 4. Gestionnaire d’artefacts

Rôle : Stocker les versions compilées et les dépendances

Exemples :

  • Azure Artifacts : Intégré à Azure DevOps
  • NuGet : Packages .NET
  • npm : Packages JavaScript
  • Maven : Packages Java
  • Docker Registry : Images de conteneurs

2.3.8 5. Système de déploiement

Rôle : Automatiser le déploiement vers les environnements

Environnements typiques :

Développement → Test → Staging → Production
     (DEV)      (QA)    (UAT)      (PROD)

2.3.9 6. Outils de monitoring et notification

Monitoring :

  • Application Insights (Azure)
  • Prometheus
  • Grafana
  • ELK Stack (Elasticsearch, Logstash, Kibana)

Notifications :

  • Email
  • Slack
  • Microsoft Teams
  • SMS

2.3.10 Écosystème complet

2.4 Les concepts d’Azure DevOps

2.4.1 Vue d’ensemble d’Azure DevOps

Azure DevOps est une plateforme complète de services pour gérer le cycle de vie du développement logiciel.

┌────────────────────────────────────────────────────────────┐
│                     AZURE DEVOPS                           │
├────────────────────────────────────────────────────────────┤
│                                                            │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐        │
│  │ Azure   │  │ Azure   │  │ Azure   │  │ Azure   │        │
│  │ Boards  │  │  Repos  │  │Pipelines│  │  Test   │        │
│  │         │  │         │  │         │  │  Plans  │        │
│  └─────────┘  └─────────┘  └─────────┘  └─────────┘        │
│                                                            │
│                    ┌─────────┐                             │
│                    │ Azure   │                             │
│                    │Artifacts│                             │
│                    │         │                             │
│                    └─────────┘                             │
│                                                            │
└────────────────────────────────────────────────────────────┘

2.4.2 Les 5 services principaux

2.4.2.1 1. Azure Boards

Fonction : Gestion de projet et suivi du travail

Fonctionnalités :

  • Tableaux Kanban et Scrum
  • Backlogs
  • Sprints
  • Requêtes personnalisées
  • Dashboards

Types d’éléments de travail :

  • Epic : Grande fonctionnalité ou initiative
  • Feature : Fonctionnalité business
  • User Story : Besoin utilisateur
  • Task : Tâche technique
  • Bug : Défaut à corriger

2.4.4.1 2. Azure Repos

Fonction : Gestion du code source

Options :

  • Git : Système distribué (recommandé)
  • TFVC : Système centralisé

Fonctionnalités Git :

  • Dépôts illimités
  • Pull Requests avec revue de code
  • Protection des branches
  • Politiques de branche
  • Intégration avec Boards

Workflow typique :

main (protected)
  ├─ develop
  │   ├─ feature/login
  │   ├─ feature/dashboard
  │   └─ bugfix/header
  └─ release/v1.0

2.4.6.1 3. Azure Pipelines

Fonction : CI/CD automatisé

Composants :

  • Build Pipelines : Compilation et tests
  • Release Pipelines : Déploiement
  • YAML Pipelines : Pipeline as Code
  • Classic Editor : Interface graphique

Avantages :

  • Support multi-plateformes (Windows, Linux, macOS)
  • Support multi-langages (.NET, Java, Python, Node.js, etc.)
  • Agents hébergés ou auto-hébergés
  • Intégration avec GitHub, Bitbucket, etc.

2.4.8.1 4. Azure Test Plans

Fonction : Gestion des tests manuels et automatisés

Fonctionnalités :

  • Plans de test
  • Suites de tests
  • Cas de tests
  • Tests exploratoires
  • Capture de bugs avec contexte
  • Suivi de la couverture

2.4.9.1 5. Azure Artifacts

Fonction : Gestion des packages et dépendances

Types de packages supportés :

  • NuGet (.NET)
  • npm (JavaScript)
  • Maven (Java)
  • Python (PyPI)
  • Universal Packages

Avantages :

  • Feeds publics et privés
  • Versioning automatique
  • Intégration avec les pipelines
  • Cache de packages externes

2.4.11 Concepts transversaux

2.4.11.1 Organisation

Organisation (contoso.visualstudio.com)
├─ Projet 1 (Application Web)
│  ├─ Boards
│  ├─ Repos
│  ├─ Pipelines
│  ├─ Test Plans
│  └─ Artifacts
├─ Projet 2 (Application Mobile)
└─ Projet 3 (Microservices)

2.4.12.1 Teams

Au sein d’un projet, vous pouvez créer plusieurs équipes :

  • Équipe Frontend
  • Équipe Backend
  • Équipe QA

Chaque équipe peut avoir :

  • Son propre backlog
  • Ses propres sprints
  • Son tableau Kanban
  • Son dashboard

2.5 La gestion de projet avec Azure DevOps

2.5.1 Méthodologies supportées

Azure DevOps supporte plusieurs méthodologies de gestion de projet :

Méthodologie Process Template Cas d’usage
Agile Agile Développement itératif standard
Scrum Scrum Sprints avec rôles définis
CMMI CMMI Projets avec gouvernance stricte
Basic Basic Projets simples, petites équipes

2.5.2 Processus Agile/Scrum

2.5.2.1 Hiérarchie des éléments de travail

┌─────────────────────────────────────────────┐
│              EPIC                           │
│  "Refonte du système d'authentification"    │
└──────────────┬──────────────────────────────┘
               │
    ┌──────────┼──────────┐
    │          │          │
┌───▼───┐  ┌───▼───┐  ┌───▼───┐
│Feature│  │Feature│  │Feature│
│ SSO   │  │ 2FA   │  │OAuth2 │
└───┬───┘  └──┬────┘  └──┬────┘
    │         │          │
┌───▼───┐ ┌───▼───┐ ┌────▼───┐
│ User  │ │ User  │ │ User   │
│ Story │ │ Story │ │ Story  │
└───┬───┘ └──┬────┘ └────┬───┘
    │        │        │
┌───▼─┐  ┌───▼─┐  ┌───▼─┐
│Task │  │Task │  │Task │
└─────┘  └─────┘  └─────┘

2.5.3.1 Cycle de vie d’une User Story

2.5.4 Tableau Kanban

Colonnes typiques :

┌─────────┬─────────┬─────────┬─────────┬─────────┐
│   New   │ Active  │  Dev    │ Testing │  Done   │
├─────────┼─────────┼─────────┼─────────┼─────────┤
│ Story A │ Story B │ Story C │ Story D │ Story E │
│ Story F │         │ Story G │         │ Story H │
│         │         │         │         │ Story I │
└─────────┴─────────┴─────────┴─────────┴─────────┘
WIP: ∞      WIP: 2     WIP: 3    WIP: 2     ∞

WIP Limits (Work In Progress) : Limiter le nombre d’éléments dans chaque colonne pour améliorer le flux.

2.5.5 Sprints et planification

Durée typique : 2 à 4 semaines

Cérémonies Scrum :

Cérémonie Durée Participants Objectif
Sprint Planning 2-4h Équipe complète Planifier le sprint
Daily Standup 15 min Équipe dev Synchronisation quotidienne
Sprint Review 1-2h Équipe + stakeholders Démonstration
Sprint Retrospective 1-2h Équipe complète Amélioration continue

2.5.6 Dashboards et reporting

Widgets disponibles :

  • Burndown chart
  • Velocity chart
  • Cumulative flow diagram
  • Test results trend
  • Build history
  • Cycle time

Exemple de Burndown Chart :

│                                             
│ ●                                           
│  \                                          
│   ●___                                      
│       \___                                  
│           ●___                              
│               \___●                         
│                   \___                      
│                       ●___                  
│                           \___●___●_____●   
└──────────────────────────────────────────▶
  J1  J2  J3  J4  J5  J6  J7  J8  J9  J10

2.6 Les différents acteurs intervenant avec Azure DevOps

2.6.1 Rôles et responsabilités

2.6.1.1 1. Project Administrator

Permissions :

  • Configuration du projet
  • Gestion des équipes
  • Configuration des processus
  • Gestion des area paths et iterations
  • Configuration des politiques de sécurité

Responsabilités :

  • Créer la structure du projet
  • Définir les area paths (modules)
  • Configurer les sprints
  • Gérer les permissions

2.6.2.1 2. Product Owner / Project Lead

Permissions :

  • Gestion du backlog
  • Création d’épics et features
  • Priorisation des user stories
  • Validation des releases

Responsabilités :

  • Définir la vision produit
  • Prioriser le backlog
  • Accepter les user stories
  • Interagir avec les stakeholders

2.6.3.1 3. Scrum Master / Team Lead

Permissions :

  • Configuration des sprints
  • Gestion du tableau Kanban
  • Animation des cérémonies

Responsabilités :

  • Faciliter les cérémonies Scrum
  • Supprimer les obstacles
  • Suivre la vélocité de l’équipe
  • Coach agile

2.6.4.1 4. Développeur

Permissions :

  • Lecture/écriture sur les repos
  • Création de branches
  • Pull requests
  • Mise à jour des work items

Responsabilités :

  • Développer les user stories
  • Créer et réviser les pull requests
  • Écrire les tests unitaires
  • Mettre à jour le statut des tâches

2.6.5.1 5. Testeur / QA

Permissions :

  • Test Plans
  • Création de bugs
  • Validation des user stories

Responsabilités :

  • Créer les plans de test
  • Exécuter les tests manuels
  • Reporter les bugs
  • Valider les corrections

2.6.6.1 6. DevOps Engineer

Permissions :

  • Gestion des pipelines
  • Configuration des agents
  • Gestion des service connections
  • Configuration des environments

Responsabilités :

  • Créer et maintenir les pipelines CI/CD
  • Configurer les agents de build
  • Gérer les déploiements
  • Monitorer la qualité

2.6.7.1 7. Stakeholder / Business Analyst

Permissions limitées :

  • Lecture seule sur les boards
  • Accès aux dashboards
  • Possibilité de commenter

Responsabilités :

  • Suivre l’avancement du projet
  • Donner du feedback
  • Participer aux sprint reviews

2.6.8 Matrice de permissions typique

┌─────────────────┬──────┬──────┬──────┬──────┬──────┐
│ Permission      │Admin │  PO  │ Dev  │  QA  │Stake │
├─────────────────┼──────┼──────┼──────┼──────┼──────┤
│ Config projet   │  ✓   │  -   │  -   │  -   │  -   │
│ Gestion backlog │  ✓   │  ✓   │  ✓   │  R   │  R   │
│ Code source     │  ✓   │  R   │  ✓   │  R   │  -   │
│ Pipelines       │  ✓   │  R   │  ✓   │  R   │  -   │
│ Test Plans      │  ✓   │  ✓   │  ✓   │  ✓   │  -   │
│ Dashboards      │  ✓   │  ✓   │  ✓   │  ✓   │  R   │
└─────────────────┴──────┴──────┴──────┴──────┴──────┘
✓ = Full access | R = Read only | - = No access

2.7 Création et configuration d’un nouveau projet

2.7.1 Prérequis

  • Compte Azure DevOps (gratuit jusqu’à 5 utilisateurs)
  • Organisation créée
  • Droits d’administrateur sur l’organisation

2.7.2 Étapes de création

2.7.2.1 Étape 1 : Accéder à Azure DevOps

  1. Se connecter à https://dev.azure.com
  2. Sélectionner votre organisation ou en créer une nouvelle
  3. Cliquer sur “New Project”

2.7.3.1 Étape 2 : Configuration du projet

Paramètres à définir :

┌─────────────────────────────────────────────┐
│ Create new project                          │
├─────────────────────────────────────────────┤
│                                             │
│ Project name: *                             │
│ ┌─────────────────────────────────────┐     │
│ │ MonApplicationWeb                   │     │
│ └─────────────────────────────────────┘     │
│                                             │
│ Description: (optional)                     │
│ ┌─────────────────────────────────────┐     │
│ │ Application de gestion commerciale  │     │
│ └─────────────────────────────────────┘     │
│                                             │
│ Visibility:                                 │
│ ○ Public   ● Private                        │
│                                             │
│ Advanced ▼                                  │
│   Version control: ● Git  ○ TFVC            │
│   Work item process: ● Agile  ○ Scrum       │
│                      ○ Basic  ○ CMMI        │
│                                             │
│         [Cancel]  [Create]                  │
└─────────────────────────────────────────────┘

Choix importants :

  1. Visibility

    • Private : Uniquement les membres invités (recommandé)
    • Public : Accessible à tous (open source)
  2. Version Control

    • Git : Recommandé pour sa flexibilité
    • TFVC : Pour compatibilité avec systèmes existants
  3. Work Item Process

    • Agile : Équipes agiles standard
    • Scrum : Équipes Scrum strictes
    • Basic : Projets simples
    • CMMI : Projets avec gouvernance

2.7.5.1 Étape 3 : Configuration initiale du projet

Une fois le projet créé, configurer :

  1. Area Paths (structure organisationnelle)
MonApplicationWeb
├─ Frontend
│  ├─ UI
│  └─ UX
├─ Backend
│  ├─ API
│  └─ Database
└─ Infrastructure
  1. Iterations (sprints/versions)
MonApplicationWeb
├─ Release 1.0
│  ├─ Sprint 1 (01/06 - 14/06)
│  ├─ Sprint 2 (15/06 - 28/06)
│  └─ Sprint 3 (29/06 - 12/07)
└─ Release 2.0
   └─ ...
  1. Teams

    • Créer les équipes nécessaires
    • Assigner les area paths
    • Configurer les iterations

2.7.7 Commandes CLI (optionnel)

Installation de l’extension Azure DevOps :

az extension add --name azure-devops

Création d’un projet via CLI :

az devops project create \
  --name "MonApplicationWeb" \
  --organization "https://dev.azure.com/votre-org" \
  --description "Application de gestion" \
  --visibility private \
  --source-control git \
  --process agile

2.8 Gestion des droits d’accès au projet

2.8.1 Niveaux de sécurité

Azure DevOps utilise un modèle de sécurité hiérarchique :

┌─────────────────────────────────────────┐
│ Organisation                            │  ← Niveau 1
├─────────────────────────────────────────┤
│  ┌─────────────────────────────────┐    │
│  │ Projet                          │    │  ← Niveau 2
│  ├─────────────────────────────────┤    │
│  │  ┌─────────────────────────┐    │    │
│  │  │ Team                    │    │    │  ← Niveau 3
│  │  └─────────────────────────┘    │    │
│  │  ┌─────────────────────────┐    │    │
│  │  │ Repository / Pipeline   │    │    │  ← Niveau 4
│  │  └─────────────────────────┘    │    │
│  └─────────────────────────────────┘    │
└─────────────────────────────────────────┘

2.8.2 Groupes de sécurité prédéfinis

2.8.2.1 Au niveau du projet :

Groupe Permissions Usage
Project Administrators Contrôle total Administrateurs projet
Contributors Lecture/écriture sur repos et work items Développeurs
Readers Lecture seule Stakeholders, auditeurs
Build Administrators Gestion des pipelines DevOps engineers
Project Valid Users Accès de base au projet Tous les membres

2.8.3.1 Groupes spécifiques :

  • Endpoint Administrators : Gestion des service connections
  • Release Administrators : Gestion des releases
  • [Team] Team Members : Membres d’une équipe spécifique

2.8.4 Configuration des permissions

2.8.4.1 Accès via l’interface :

  1. Project Settings → Permissions
  2. Sélectionner un groupe
  3. Configurer les permissions

Exemple de permissions pour Contributors :

┌────────────────────────────────┬────────┐
│ Permission                     │ Status │
├────────────────────────────────┼────────┤
│ View project-level information │   ✓    │
│ Edit project-level information │   ✗    │
│ Delete team project            │   ✗    │
│ Manage project properties      │   ✗    │
│ Create test runs               │   ✓    │
│ Delete test runs               │   ✓    │
│ View test results              │   ✓    │
│ Manage test plans              │   ✓    │
└────────────────────────────────┴────────┘

2.8.6 Permissions sur les repos Git

Configuration au niveau du repository :

Repository Settings → Security

Permissions importantes :

Permission Contributors Readers Build Service
Read ✓ ✓ ✓
Clone ✓ ✓ ✓
Contribute ✓ ✗ ✓
Create branch ✓ ✗ ✓
Force push ✗ ✗ ✗
Manage permissions ✗ ✗ ✗

2.8.7 Branch Policies (Protection)

Configuration recommandée pour la branche main :

Branch Protection: main
├─ Require a minimum number of reviewers: 2
├─ Check for linked work items: Required
├─ Check for comment resolution: Required
├─ Limit merge types: Squash merge only
├─ Automatically include reviewers
└─ Build validation: Required

Exemple de configuration :

┌─────────────────────────────────────────────┐
│ Branch policies for main                    │
├─────────────────────────────────────────────┤
│                                             │
│ ✓ Require a minimum number of reviewers     │
│   Minimum number: [2] ▼                     │
│   ✓ Allow requestors to approve their own   │
│     changes                                 │
│   ✓ Prohibit the most recent pusher from    │
│     approving                               │
│                                             │
│ ✓ Check for linked work items               │
│   ● Required                                │
│                                             │
│ ✓ Check for comment resolution              │
│   ● Required                                │
│                                             │
│ ✓ Build validation                          │
│   Build pipeline: [CI-Build] ▼              │
│   Trigger: ● Automatic                      │
│   Policy requirement: ● Required            │
│                                             │
└─────────────────────────────────────────────┘

2.8.9 Gestion des Service Connections

Les Service Connections permettent de connecter Azure DevOps à des services externes :

  • Azure Subscription
  • Docker Registry
  • Kubernetes
  • SSH
  • Generic

Configuration de la sécurité :

Project Settings → Service Connections → [Connection] → Security

Permissions:
├─ Administrator: Project Administrators
├─ User: Build Service, Release Administrators
└─ Reader: Contributors

2.8.11 Bonnes pratiques de sécurité

2.8.11.1 1. Principe du moindre privilège

❌ Mauvais :

Tout le monde = Project Administrator

✅ Bon :

Développeurs = Contributors
QA = Contributors (avec permissions spécifiques sur Test Plans)
Stakeholders = Readers
DevOps = Build Administrators

2.8.12.1 2. Utiliser des groupes Azure AD

Si votre organisation utilise Azure Active Directory :

Azure AD Group: Developers@contoso.com
    ↓
Azure DevOps Group: Contributors

Avantages :

  • Gestion centralisée
  • Synchronisation automatique
  • Single Sign-On (SSO)

2.8.13.1 3. Auditer régulièrement les accès

Vérifier périodiquement :

  • Qui a accès au projet ?
  • Qui a des permissions administratives ?
  • Qui a accès aux service connections ?

Audit log location :

Organization Settings → Auditing

2.8.14.1 4. Protéger les informations sensibles

Utiliser Azure Key Vault pour :

  • Chaînes de connexion
  • Clés API
  • Certificats
  • Secrets

Ne jamais stocker de secrets dans :

  • Le code source
  • Les variables de pipeline en clair
  • Les work items

2.9 Travaux Pratiques

TP1 : Créer et configurer un nouveau projet Azure DevOps

2.10 Synthèse du Module 1

2.10.1 Points clés à retenir

✅ Intégration Continue

  • Pratique de développement avec intégrations fréquentes
  • Automatisation du build et des tests
  • Feedback rapide pour l’équipe

✅ Composants CI/CD

  • Contrôle de version (Git)
  • Serveur de build
  • Tests automatisés
  • Gestionnaire d’artefacts
  • Système de déploiement

✅ Azure DevOps

  • 5 services principaux : Boards, Repos, Pipelines, Test Plans, Artifacts
  • Support des méthodologies Agile/Scrum
  • Plateforme complète pour le cycle de vie DevOps

✅ Organisation du projet

  • Structure avec Area Paths et Iterations
  • Équipes avec backlogs dédiés
  • Hiérarchie des work items (Epic → Feature → User Story → Task)

✅ Sécurité et permissions

  • Groupes de sécurité prédéfinis
  • Permissions au niveau projet et repository
  • Branch policies pour protéger le code
  • Service connections pour les déploiements

2.11 Ressources complémentaires

2.11.1 Documentation officielle

2.11.2 Outils

2.11.3 Communauté

2.12 Préparation pour le Module 2

Dans le prochain module, nous allons :

  • Approfondir Git et TFVC
  • Pratiquer les commandes Git essentielles
  • Configurer Visual Studio avec Azure Repos
  • Gérer les branches et les pull requests

3 Le contrôleur de code source

3.1 Objectifs pédagogiques

À l’issue de ce module, vous serez capable de :

  • Comprendre les différences entre Git et TFVC
  • Utiliser Git avec Azure Repos
  • Maîtriser les commandes Git essentielles
  • Configurer Visual Studio avec Azure DevOps
  • Gérer les branches et les pull requests
  • Appliquer les bonnes pratiques de gestion de code source

3.2 Présentation de Team Foundation Version Control (TFVC)

3.2.1 Qu’est-ce que TFVC ?

Team Foundation Version Control est un système de contrôle de version centralisé développé par Microsoft.

3.2.2 Architecture centralisée vs distribuée

3.2.3 Caractéristiques de TFVC

Caractéristique Description Avantage Inconvénient
Architecture Centralisée Source unique de vérité Dépendance au serveur
Permissions Granulaires (fichier par fichier) Contrôle fin Configuration complexe
Fichiers volumineux Optimisé pour les gros fichiers Bon pour binaires Moins flexible
Workflow Check-out/Check-in Simple à comprendre Moins de flexibilité
Historique Sur le serveur uniquement Centralisation Pas de travail offline

3.2.4 Concepts clés de TFVC

3.2.4.1 1. Workspace (Espace de travail)

┌─────────────────────────────────────────────┐
│         Workspace Local                     │
├─────────────────────────────────────────────┤
│                                             │
│  C:\Projects\MonProjet                      │
│  ├─ $/TeamProject/Main                      │ ← Mapping
│  │  ├─ Source/                              │
│  │  ├─ Tests/                               │
│  │  └─ Docs/                                │
│  │                                          │
│  └─ Status:                                 │
│     • Modified: 3 files                     │
│     • Added: 1 file                         │
│     • Deleted: 0 files                      │
└─────────────────────────────────────────────┘

Types de workspace :

  • Server workspace : Modifications trackées par le serveur (check-out requis)
  • Local workspace : Modifications détectées localement (plus flexible)

3.2.6.1 2. Structure arborescente

$/TeamProject
├─ Main                    ← Branche principale
│  ├─ Source/
│  ├─ Tests/
│  └─ Docs/
├─ Development             ← Branche de développement
│  └─ ...
└─ Releases
   ├─ Release_1.0          ← Branches de release
   └─ Release_2.0

3.2.7.1 3. Cycle de vie TFVC

3.2.8 Changesets

Un changeset est un ensemble atomique de modifications avec un numéro unique.

Exemple :

Changeset 12345
├─ Date: 2024-05-25 14:30:00
├─ Author: alice@contoso.com
├─ Comment: "Fix login bug - Issue #456"
├─ Work Items: Bug #456
└─ Files:
   ├─ $/Main/Source/Login.cs (edit)
   ├─ $/Main/Tests/LoginTests.cs (edit)
   └─ $/Main/Docs/ChangeLog.md (edit)

3.2.9 Commandes TFVC essentielles

3.2.9.1 Via Visual Studio

Action Menu Raccourci
Get Latest Team Explorer → Source Control Explorer Ctrl+G
Check Out Clic droit → Check Out
Check In Team Explorer → Pending Changes Ctrl+0, P
View History Clic droit → View History
Compare Clic droit → Compare

3.2.10.1 Via ligne de commande (tf.exe)

# Obtenir la dernière version
tf get /recursive

# Check-out d'un fichier
tf checkout Login.cs

# Ajouter un nouveau fichier
tf add NewFile.cs

# Supprimer un fichier
tf delete OldFile.cs

# Check-in avec commentaire
tf checkin /comment:"Fix bug #123"

# Voir l'historique
tf history Login.cs /recursive

# Annuler les modifications locales
tf undo /recursive

3.2.11 Branchement dans TFVC

Main (Production)
  │
  ├─── Branch ───→ Dev (Development)
  │                  │
  │                  ├─── Branch ───→ Feature_Login
  │                  │
  │                  └─── Branch ───→ Feature_Dashboard
  │
  └─── Branch ───→ Release_1.0
                     │
                     └─── Bugfix_Critical

Opérations de branche :

# Créer une branche
tf branch $/Main $/Dev

# Fusionner (merge) de Dev vers Main
tf merge $/Dev $/Main

# Baseless merge (sans relation parent-enfant)
tf merge $/Branch1 $/Branch2 /baseless

3.2.13 Quand utiliser TFVC ?

✅ Utiliser TFVC si :

  • Vous travaillez avec des fichiers binaires volumineux
  • Vous avez besoin de permissions au niveau fichier
  • Votre équipe est habituée aux systèmes centralisés (VSS, SVN)
  • Vous utilisez déjà TFS on-premises

❌ Éviter TFVC si :

  • Vous avez besoin de branches légères et fréquentes
  • Votre équipe travaille souvent offline
  • Vous voulez utiliser des outils Git standard
  • Vous démarrez un nouveau projet (préférer Git)

3.3 Utilisation de Git dans Visual Studio

3.3.1 Installation et configuration

3.3.1.1 Prérequis

  1. Visual Studio 2019/2022 (Community, Professional ou Enterprise)
  2. Git for Windows (inclus dans Visual Studio)
  3. Compte Azure DevOps avec accès au projet

3.3.2.1 Configuration initiale de Git

# Configuration du nom et email (obligatoire)
git config --global user.name "Votre Nom"
git config --global user.email "votre.email@example.com"

# Configuration de l'éditeur par défaut
git config --global core.editor "code --wait"  # VS Code
# OU
git config --global core.editor "notepad"       # Notepad

# Configuration de la fin de ligne (Windows)
git config --global core.autocrlf true

# Afficher la configuration
git config --list

3.3.3.1 Vérification de la configuration

# Vérifier la version de Git
git --version

# Afficher la configuration utilisateur
git config user.name
git config user.email

3.3.4 Connexion à Azure DevOps depuis Visual Studio

3.3.4.1 Méthode 1 : Team Explorer

1. Visual Studio → View → Team Explorer
2. Manage Connections → Connect to a Project
3. Sélectionner Azure DevOps
4. S'authentifier avec votre compte Microsoft/Azure AD
5. Sélectionner votre organisation et projet
┌─────────────────────────────────────────┐
│ Team Explorer - Connect                 │
├─────────────────────────────────────────┤
│                                         │
│ Local Git Repositories                  │
│   C:\Projects\MonProjet                 │
│                                         │
│ Azure DevOps                            │
│   ✓ dev.azure.com/contoso               │
│      └─ ShopConnect                     │
│         └─ Clone                        │
│                                         │
│ [Add GitHub account]                    │
│ [Manage Connections]                    │
│                                         │
└─────────────────────────────────────────┘

3.3.6.1 Méthode 2 : Cloner un repository

1. Team Explorer → Clone
2. Entrer l'URL du repository Azure DevOps
   https://dev.azure.com/contoso/ShopConnect/_git/ShopConnect
3. Choisir le chemin local
4. Cliquer sur Clone

3.3.7 Interface Git dans Visual Studio

3.3.7.1 Vue d’ensemble

┌─────────────────────────────────────────────────────────────┐
│ Team Explorer - Home                                        │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│ Project: ShopConnect                                        │
│ Repository: ShopConnect                                     │
│ Branch: main                                                │
│                                                             │
│ [Changes]           ← Voir les modifications locales        │
│ [Branches]          ← Gérer les branches                    │
│ [Sync]              ← Push/Pull/Fetch                       │
│ [Pull Requests]     ← Créer et gérer les PR                 │
│ [Work Items]        ← Lier aux work items                   │
│                                                             │
│ Solution Explorer                                           │
│   └─ ShopConnect.sln                                        │
│       ├─ ShopConnect.Web                                    │
│       ├─ ShopConnect.API                                    │
│       └─ ShopConnect.Tests                                  │
│                                                             │
└─────────────────────────────────────────────────────────────┘

3.3.8 Workflow Git dans Visual Studio

3.3.8.1 1. Modifications locales (Changes)

Team Explorer → Changes
┌───────────────────────────────────────┐
│ Changes                               │
├───────────────────────────────────────┤
│                                       │
│ Message:                              │
│ ┌─────────────────────────────────┐   │
│ │ Add user authentication         │   │
│ │ - Implement login controller    │   │
│ │ - Add JWT token validation      │   │
│ │ Fixes #123                    │   │
│ └─────────────────────────────────┘   │
│                                       │
│ Included Changes (3)                  │
│   ✓ Controllers/LoginController.cs M  │
│   ✓ Services/AuthService.cs       M   │
│   ✓ Models/UserModel.cs           A   │
│                                       │
│ Excluded Changes (1)                  │
│   - appsettings.json               M  │
│                                       │
│ [Commit All]  [Commit and Push]       │
│ [Commit and Sync]                     │
│                                       │
└───────────────────────────────────────┘

Légende:
M = Modified (Modifié)
A = Added (Ajouté)
D = Deleted (Supprimé)
R = Renamed (Renommé)

3.3.9.1 2. Gestion des branches

Team Explorer → Branches
┌─────────────────────────────────────────┐
│ Branches                                │
├─────────────────────────────────────────┤
│                                         │
│ Active Branch:                          │
│   ● main                                │
│                                         │
│ Local Branches:                         │
│   ● main                                │
│     develop                             │
│     feature/user-auth                   │
│                                         │
│ Remote Branches (origin):               │
│     main                                │
│     develop                             │
│     feature/user-auth                   │
│     feature/dashboard                   │
│                                         │
│ [New Branch]  [Merge]  [Rebase]         │
│                                         │
└─────────────────────────────────────────┘

Actions disponibles (clic droit sur une branche) :

Action Description
Checkout Basculer vers cette branche
Merge Fusionner dans la branche courante
Rebase Rebaser la branche courante
Delete Supprimer la branche locale
View History Voir l’historique des commits
Compare Comparer avec une autre branche
New Local Branch From… Créer une branche à partir de celle-ci

3.3.11.1 3. Synchronisation (Sync)

Team Explorer → Sync
┌─────────────────────────────────────────┐
│ Synchronization                         │
├─────────────────────────────────────────┤
│                                         │
│ Incoming Commits (3)                    │
│   abc1234 - Fix login bug (Bob)         │
│   def5678 - Update README (Alice)       │
│   ghi9012 - Add tests (Charlie)         │
│                                         │
│ [Pull]  [Fetch]                         │
│                                         │
│  ─────────────────────────────────────  │
│                                         │
│ Outgoing Commits (2)                    │
│   jkl3456 - Add authentication (You)    │
│   mno7890 - Refactor service (You)      │
│                                         │
│ [Push]  [Sync]                          │
│                                         │
└─────────────────────────────────────────┘

Différence entre les actions :

Action Description Commande Git
Fetch Télécharge les commits distants sans fusionner git fetch
Pull Télécharge et fusionne (Fetch + Merge) git pull
Push Envoie vos commits locaux vers le serveur git push
Sync Pull puis Push (synchronisation complète) git pull && git push

3.3.13.1 4. Pull Requests

Team Explorer → Pull Requests
┌─────────────────────────────────────────┐
│ Pull Requests                           │
├─────────────────────────────────────────┤
│                                         │
│ My Pull Requests                        │
│   #42 - Add user authentication         │
│         Status: Active                  │
│         Reviewers: Bob, Alice (1/2)     │
│         Comments: 3                     │
│                                         │
│ Assigned to Me                          │
│   #41 - Update dashboard UI             │
│         Author: Bob                     │
│         Status: Waiting for review      │
│                                         │
│ [Create Pull Request]                   │
│                                         │
└─────────────────────────────────────────┘

3.3.14 Opérations Git courantes dans Visual Studio

3.3.14.1 Créer une nouvelle branche

1. Team Explorer → Branches → New Branch
2. Nom: feature/add-payment
3. Base branch: develop
4. [✓] Checkout branch
5. [Create Branch]

Équivalent ligne de commande :

git checkout -b feature/add-payment develop

3.3.15.1 Faire un commit

1. Modifier les fichiers dans Solution Explorer
2. Team Explorer → Changes
3. Saisir le message de commit
4. Vérifier les fichiers à inclure
5. Cliquer [Commit All] ou [Commit and Push]

Équivalent ligne de commande :

git add .
git commit -m "Add payment gateway integration"
git push origin feature/add-payment

3.3.16.1 Créer une Pull Request

1. Team Explorer → Pull Requests → New Pull Request
2. Source branch: feature/add-payment
3. Target branch: develop
4. Title: Add payment gateway integration
5. Description: 
   - Integrate Stripe API
   - Add payment controller
   - Add unit tests
6. Reviewers: Bob, Alice
7. Work Items: Link #123
8. [Create]

3.3.17.1 Résoudre un conflit de fusion

Scénario : Vous faites un Pull et il y a des conflits.

┌─────────────────────────────────────────┐
│ Conflicts Detected                      │
├─────────────────────────────────────────┤
│                                         │
│ The following files have conflicts:     │
│   • Controllers/LoginController.cs      │
│   • Services/AuthService.cs             │
│                                         │
│ [View Conflicts]                        │
│                                         │
└─────────────────────────────────────────┘

Résolution :

1. Cliquer sur le fichier en conflit
2. Visual Studio ouvre le Merge Tool:

┌─────────────────────────────────────────────────────────┐
│ Merge - LoginController.cs                              │
├─────────────────────────────────────────────────────────┤
│                                                         │
│ YOUR VERSION         │  BASE   │  REMOTE VERSION        │
│ (Local changes)      │         │  (Server changes)      │
│─────────────────────────────────────────────────────────│
│ if (user == null)    │ if ...  │ if (user is null)      │
│   return NotFound(); │         │   throw new Ex...      │
│                      │         │                        │
│                                                         │
│ [✓] Take Local  [✓] Take Remote  [ ] Take Both          │
│                                                         │
│─────────────────────────────────────────────────────────│
│ RESULT (After merge)                                    │
│ if (user is null)                                       │
│   return NotFound();                                    │
│                                                         │
│ [Accept Merge]                                          │
└─────────────────────────────────────────────────────────┘

3. Choisir la version à garder ou éditer manuellement
4. [Accept Merge]
5. Répéter pour tous les fichiers en conflit
6. Team Explorer → Changes → Commit Merge

Équivalent ligne de commande :

git pull origin develop
# CONFLICT (content): Merge conflict in LoginController.cs
# Auto-merging LoginController.cs

# Éditer manuellement les fichiers
code Controllers/LoginController.cs

# Marquer comme résolu
git add Controllers/LoginController.cs

# Compléter la fusion
git commit -m "Merge develop into feature/add-payment"

3.3.20 Git Graph (Extension recommandée)

Installation :

Visual Studio → Extensions → Manage Extensions
Rechercher: Git Graph
Install

Visualisation :

* commit abc1234 (HEAD -> feature/add-payment)
│ Author: You
│ Add payment controller
│
* commit def5678
│ Author: You
│ Integrate Stripe API
│
│ * commit ghi9012 (origin/develop, develop)
│ │ Author: Bob
│ │ Update user model
│ /
* commit jkl3456
│ Author: Alice
│ Initial commit

3.4 Utilisation de Git avec Azure DevOps

3.4.1 Architecture Git dans Azure DevOps

3.4.2 Cloner un repository Azure Repos

3.4.2.1 Méthode 1 : Via Azure DevOps Web

1. Naviguer vers Azure DevOps → Repos → Files
2. Cliquer sur [Clone] en haut à droite
3. Copier l'URL HTTPS ou SSH

HTTPS:
https://dev.azure.com/contoso/ShopConnect/_git/ShopConnect

SSH:
git@ssh.dev.azure.com:v3/contoso/ShopConnect/ShopConnect

3.4.3.1 Méthode 2 : Via ligne de commande

# Clone HTTPS (recommandé pour débutants)
git clone https://dev.azure.com/contoso/ShopConnect/_git/ShopConnect

# Clone SSH (pour utilisateurs avancés)
git clone git@ssh.dev.azure.com:v3/contoso/ShopConnect/ShopConnect

# Clone vers un répertoire spécifique
git clone https://dev.azure.com/contoso/ShopConnect/_git/ShopConnect C:\Projects\ShopConnect

# Clone d'une branche spécifique
git clone -b develop https://dev.azure.com/contoso/ShopConnect/_git/ShopConnect

3.4.4.1 Méthode 3 : Via Visual Studio

Voir section 2.2 - “Connexion à Azure DevOps depuis Visual Studio”

3.4.5 Authentification

3.4.5.1 Option 1 : Git Credential Manager (Recommandé)

Avantages :

  • Gestion automatique des credentials
  • Support Multi-Factor Authentication (MFA)
  • Intégré à Windows

Installation :

# Inclus dans Git for Windows 2.29+
# Vérification
git credential-manager-core --version

Premier push/pull :

1. Une fenêtre s'ouvre pour s'authentifier
2. Se connecter avec votre compte Microsoft/Azure AD
3. Les credentials sont stockés de manière sécurisée
4. Les futures opérations sont automatiques

3.4.7.1 Option 2 : Personal Access Token (PAT)

Création du PAT :

1. Azure DevOps → User Settings → Personal Access Tokens
2. [+ New Token]
3. Name: "Development Machine"
4. Organization: All accessible organizations
5. Expiration: 90 days (recommandé)
6. Scopes:
   ✓ Code (Read, Write, Manage)
   ✓ Work Items (Read, Write)
   ✓ Build (Read, Execute)
7. [Create]
8. COPIER LE TOKEN (ne sera plus affiché)

Utilisation du PAT :

# Première fois, Git demande username/password:
# Username: [n'importe quoi, ex: "pat"]
# Password: [coller le PAT]

# Ou configurer directement:
git config --global credential.helper store
git push
# Entrer le PAT comme password

3.4.9.1 Option 3 : Clés SSH

Génération de clé SSH :

# Générer une paire de clés
ssh-keygen -t rsa -b 4096 -C "votre.email@example.com"

# Fichiers créés:
# ~/.ssh/id_rsa (clé privée - NE PAS PARTAGER)
# ~/.ssh/id_rsa.pub (clé publique - à uploader)

Ajouter la clé à Azure DevOps :

1. Copier le contenu de ~/.ssh/id_rsa.pub
2. Azure DevOps → User Settings → SSH Public Keys
3. [+ New Key]
4. Coller la clé publique
5. Name: "Development Machine"
6. [Save]

Tester la connexion :

ssh -T git@ssh.dev.azure.com
# You've successfully authenticated...

3.4.12 Branches stratégiques Git

3.4.12.1 Stratégie Git Flow

main (production)
  │
  ├─── develop (intégration)
  │      │
  │      ├─── feature/user-auth
  │      │      └─── merge ──→ develop
  │      │
  │      ├─── feature/payment
  │      │      └─── merge ──→ develop
  │      │
  │      └─── release/1.0
  │             └─── merge ──→ main + develop
  │
  └─── hotfix/critical-bug
         └─── merge ──→ main + develop

Branches principales :

Branche Durée de vie Protection Utilisation
main Permanente ✓ Protégée Code en production
develop Permanente ✓ Protégée Code en développement
feature/* Temporaire Non Nouvelles fonctionnalités
release/* Temporaire ✓ Protégée Préparation de release
hotfix/* Temporaire Non Corrections urgentes

Workflow Git Flow :

# 1. Créer une feature branch
git checkout develop
git checkout -b feature/user-authentication

# 2. Développer
git add .
git commit -m "Add login controller"
git push origin feature/user-authentication

# 3. Créer une Pull Request (via Azure DevOps UI)
# develop ← feature/user-authentication

# 4. Après merge, créer une release
git checkout develop
git pull
git checkout -b release/1.0

# 5. Finaliser la release
git checkout main
git merge release/1.0
git tag -a v1.0 -m "Release version 1.0"
git push origin main --tags

git checkout develop
git merge release/1.0
git push origin develop

# 6. Supprimer les branches temporaires
git branch -d release/1.0
git push origin --delete release/1.0

3.4.15.1 Stratégie GitHub Flow (simplifiée)

main (production)
  │
  ├─── feature/user-auth
  │      └─── PR ──→ main
  │
  ├─── feature/payment
  │      └─── PR ──→ main
  │
  └─── bugfix/login-error
         └─── PR ──→ main

Plus simple pour les petites équipes :

# 1. Créer une branche depuis main
git checkout main
git pull
git checkout -b feature/add-dashboard

# 2. Développer et pousser
git add .
git commit -m "Add dashboard component"
git push origin feature/add-dashboard

# 3. Pull Request vers main (via Azure DevOps)
# main ← feature/add-dashboard

# 4. Après merge et validation
git checkout main
git pull
git branch -d feature/add-dashboard

3.4.17 Configuration des Branch Policies dans Azure DevOps

3.4.17.1 Accès aux policies

Azure DevOps → Repos → Branches → [...] sur 'main' → Branch policies

3.4.18.1 Policies recommandées pour la branche main

┌─────────────────────────────────────────────────────────┐
│ Branch policies - main                                  │
├─────────────────────────────────────────────────────────┤
│                                                         │
│ ✓ Require a minimum number of reviewers                 │
│   Minimum: [2] ▼                                        │
│   ✓ Allow requestors to approve their own changes       │
│   ✓ Prohibit the most recent pusher from approving      │
│   ✓ Reset code reviewer votes when there are new pushes │
│   ✓ When new changes are pushed: Reset all approval     │
│       votes                                             │
│                                                         │
│ ✓ Check for linked work items                           │
│   ● Required                                            │
│                                                         │
│ ✓ Check for comment resolution                          │
│   ● All comments must be resolved                       │
│                                                         │
│ ✓ Limit merge types                                     │
│   ✓ Squash merge                                        │
│   □ Rebase and fast-forward                             │
│   □ Rebase with merge commit                            │
│   ✓ Basic merge (no fast-forward)                       │
│                                                         │
│ ✓ Build validation                                      │
│   Build pipeline: [CI-Build] ▼                          │
│   Trigger: ● Automatic                                  │
│   Policy requirement: ● Required                        │
│   Build expiration: [12] hours                          │
│   Display name: "CI Build"                              │
│                                                         │
│ ✓ Status checks                                         │
│   □ SonarQube Quality Gate                              │
│   □ Security Scan                                       │
│                                                         │
│ ✓ Automatically include reviewers                       │
│   Reviewers: [DevOps Team] ▼                            │
│   Policy requirement: ● Required                        │
│                                                         │
└─────────────────────────────────────────────────────────┘

Explication des policies :

Policy Impact Recommandation
Minimum reviewers Force la revue de code 1-2 pour petites équipes, 2-3 pour grandes
Linked work items Traçabilité complète Toujours requis
Comment resolution Qualité des reviews Requis pour main/develop
Build validation Code compilable Obligatoire sur main
Limit merge types Historique propre Squash pour features, merge pour releases

3.4.20 Opérations Git avancées

3.4.20.1 Stash (Mettre de côté des modifications)

Scénario : Vous travaillez sur une feature mais devez rapidement corriger un bug.

# Mettre les modifications de côté
git stash save "WIP: payment integration"

# Basculer vers une autre branche
git checkout develop

# ... corriger le bug ...

# Revenir à votre branche
git checkout feature/payment

# Récupérer les modifications
git stash pop

# Lister les stash
git stash list
# stash@{0}: On feature/payment: WIP: payment integration

# Appliquer un stash spécifique sans le supprimer
git stash apply stash@{0}

# Supprimer un stash
git stash drop stash@{0}

3.4.21.1 Cherry-pick (Appliquer un commit spécifique)

Scénario : Un commit de develop doit être appliqué sur main en urgence.

# 1. Identifier le commit sur develop
git log develop --oneline
# abc1234 Fix critical security issue
# def5678 Add feature X

# 2. Basculer sur main
git checkout main

# 3. Appliquer uniquement le commit abc1234
git cherry-pick abc1234

# 4. Pousser
git push origin main

3.4.22.1 Rebase (Réécrire l’historique)

⚠️ Attention : Ne jamais rebaser des branches publiques (main, develop) !

Scénario : Votre feature branch est derrière develop.

# Situation:
# develop:  A -- B -- C -- D
#                \
# feature:        E -- F

# Rebaser feature sur develop
git checkout feature/user-auth
git rebase develop

# Résultat:
# develop:  A -- B -- C -- D
#                            \
# feature:                    E' -- F'

# En cas de conflit:
git rebase --continue  # Après résolution
git rebase --abort     # Annuler le rebase

Rebase interactif (nettoyer l’historique) :

# Modifier les 3 derniers commits
git rebase -i HEAD~3

# Éditeur s'ouvre:
pick abc1234 Add login form
pick def5678 Fix typo
pick ghi9012 Add validation

# Modifier en:
pick abc1234 Add login form
fixup def5678 Fix typo        ← Fusionne avec le précédent
reword ghi9012 Add validation  ← Modifier le message

# Sauvegarder et fermer

3.4.24.1 Tags (Marquer des versions)

# Créer un tag annoté (recommandé)
git tag -a v1.0.0 -m "Release version 1.0.0"

# Créer un tag léger
git tag v1.0.0

# Lister les tags
git tag
git tag -l "v1.*"

# Pousser les tags
git push origin v1.0.0      # Un tag spécifique
git push origin --tags      # Tous les tags

# Supprimer un tag
git tag -d v1.0.0                    # Local
git push origin --delete v1.0.0      # Remote

# Checkout un tag (pour hotfix)
git checkout v1.0.0
git checkout -b hotfix/v1.0.1

3.4.25 Conventions de nommage

3.4.25.1 Branches

feature/     → Nouvelles fonctionnalités
  feature/user-authentication
  feature/payment-gateway
  
bugfix/      → Corrections de bugs non critiques
  bugfix/login-validation
  bugfix/typo-homepage
  
hotfix/      → Corrections urgentes en production
  hotfix/security-vulnerability
  hotfix/payment-crash
  
release/     → Préparation de release
  release/1.0
  release/2.0-beta
  
docs/        → Documentation uniquement
  docs/api-specification
  docs/user-guide

3.4.26.1 Commits (Convention Conventional Commits)

<type>(<scope>): <subject>

<body>

<footer>

Types :

  • feat: Nouvelle fonctionnalité
  • fix: Correction de bug
  • docs: Documentation
  • style: Formatting, points-virgules, etc.
  • refactor: Refactoring sans changement fonctionnel
  • test: Ajout ou modification de tests
  • chore: Tâches de maintenance

Exemples :

git commit -m "feat(auth): add JWT token validation"

git commit -m "fix(payment): resolve null reference exception

The payment controller was throwing NullReferenceException
when the user object was null.

Fixes #123"

git commit -m "docs(api): update authentication endpoint documentation"

git commit -m "refactor(services): extract common logic into base service"

3.5 Cloner un dépôt Git

3.5.1 Prérequis

  • Git installé sur votre machine
  • Accès au repository Azure DevOps (permissions de lecture)
  • Authentification configurée (PAT, SSH ou Git Credential Manager)

3.5.2 Méthodes de clonage

3.5.2.1 1. Clone HTTPS (Recommandé)

# Syntaxe de base
git clone <URL_HTTPS>

# Exemple Azure DevOps
git clone https://dev.azure.com/contoso/ShopConnect/_git/ShopConnect

# Clone dans un répertoire spécifique
git clone https://dev.azure.com/contoso/ShopConnect/_git/ShopConnect C:\Projects\MyShop

# Clone d'une branche spécifique
git clone -b develop https://dev.azure.com/contoso/ShopConnect/_git/ShopConnect

# Clone shallow (historique limité, plus rapide)
git clone --depth 1 https://dev.azure.com/contoso/ShopConnect/_git/ShopConnect

Avantages HTTPS :

  • ✅ Simple à configurer
  • ✅ Fonctionne derrière un proxy
  • ✅ Support natif du MFA
  • ✅ Pas de configuration SSH

Inconvénients :

  • ❌ Peut demander le mot de passe (si pas de credential manager)

3.5.4.1 2. Clone SSH

Prérequis : - Clé SSH générée et ajoutée à Azure DevOps (voir section 2.3)

# Syntaxe SSH pour Azure DevOps
git clone git@ssh.dev.azure.com:v3/<organization>/<project>/<repo>

# Exemple
git clone git@ssh.dev.azure.com:v3/contoso/ShopConnect/ShopConnect

# Spécifier une clé SSH différente
GIT_SSH_COMMAND="ssh -i ~/.ssh/id_rsa_work" git clone git@ssh.dev.azure.com:v3/contoso/ShopConnect/ShopConnect

Avantages SSH :

  • ✅ Pas de mot de passe à chaque opération
  • ✅ Plus sécurisé
  • ✅ Idéal pour automation/scripts

Inconvénients :

  • ❌ Configuration initiale plus complexe
  • ❌ Peut être bloqué par certains firewalls

3.5.6.1 3. Clone via Visual Studio

Voir section 2.2 - “Connexion à Azure DevOps depuis Visual Studio”

3.5.7 Vérification après clonage

# Entrer dans le répertoire
cd ShopConnect

# Vérifier la configuration du remote
git remote -v
# origin  https://dev.azure.com/contoso/ShopConnect/_git/ShopConnect (fetch)
# origin  https://dev.azure.com/contoso/ShopConnect/_git/ShopConnect (push)

# Vérifier la branche courante
git branch
# * main

# Voir toutes les branches (y compris distantes)
git branch -a
# * main
#   remotes/origin/HEAD -> origin/main
#   remotes/origin/main
#   remotes/origin/develop
#   remotes/origin/feature/user-auth

# Vérifier l'historique
git log --oneline -5
# abc1234 (HEAD -> main, origin/main) Update README
# def5678 Add authentication
# ghi9012 Initial commit

# Vérifier le statut
git status
# On branch main
# Your branch is up to date with 'origin/main'.
# nothing to commit, working tree clean

3.5.8 Configuration post-clonage

# Configuration du nom et email (si pas déjà fait globalement)
git config user.name "Votre Nom"
git config user.email "votre.email@example.com"

# Configuration spécifique au projet (optionnel)
git config core.autocrlf true  # Windows
git config core.editor "code --wait"

# Ajouter des alias utiles
git config alias.st status
git config alias.co checkout
git config alias.br branch
git config alias.ci commit
git config alias.unstage 'reset HEAD --'

# Afficher la config du repository
git config --list --local

3.5.9 Clonage de plusieurs repositories

Scénario : Projet avec architecture microservices

# Structure souhaitée:
# C:\Projects\ShopConnect\
# ├─ frontend\
# ├─ backend-api\
# ├─ backend-auth\
# └─ infrastructure\

# Créer la structure
mkdir C:\Projects\ShopConnect
cd C:\Projects\ShopConnect

# Cloner chaque repo
git clone https://dev.azure.com/contoso/ShopConnect/_git/Frontend frontend
git clone https://dev.azure.com/contoso/ShopConnect/_git/BackendAPI backend-api
git clone https://dev.azure.com/contoso/ShopConnect/_git/BackendAuth backend-auth
git clone https://dev.azure.com/contoso/ShopConnect/_git/Infrastructure infrastructure

3.5.10 Clonage avec Git Submodules

Scénario : Repository avec dépendances Git

# Cloner avec les submodules
git clone --recurse-submodules https://dev.azure.com/contoso/ShopConnect/_git/ShopConnect

# OU après clonage normal:
git clone https://dev.azure.com/contoso/ShopConnect/_git/ShopConnect
cd ShopConnect
git submodule update --init --recursive

# Mettre à jour les submodules
git submodule update --remote

3.5.11 Troubleshooting du clonage

3.5.11.1 Erreur d’authentification

# Erreur:
fatal: Authentication failed for 'https://dev.azure.com/contoso/ShopConnect/_git/ShopConnect/'

# Solutions:
# 1. Vérifier les credentials
git credential-manager-core erase
# Puis re-cloner (va redemander les credentials)

# 2. Utiliser un PAT explicitement
git clone https://<PAT>@dev.azure.com/contoso/ShopConnect/_git/ShopConnect

# 3. Vérifier les permissions Azure DevOps
# User Settings → Security → Permissions → Code: Read

3.5.12.1 Erreur de certificat SSL

# Erreur:
SSL certificate problem: unable to get local issuer certificate

# Solution temporaire (NON RECOMMANDÉ pour production):
git config --global http.sslVerify false

# Solution recommandée: installer les certificats d'entreprise
# Ou spécifier le bundle de certificats:
git config --global http.sslCAInfo C:/path/to/ca-bundle.crt

3.5.13.1 Clone très lent

# Utiliser shallow clone
git clone --depth 1 https://dev.azure.com/contoso/ShopConnect/_git/ShopConnect

# Ou cloner une seule branche
git clone --single-branch --branch main https://dev.azure.com/contoso/ShopConnect/_git/ShopConnect

# Plus tard, si besoin de l'historique complet:
git fetch --unshallow

3.6 Travaux Pratiques

TP2 : Utiliser Git avec Azure DevOps

3.7 Synthèse du Module 2

3.7.1 Points clés à retenir

✅ TFVC vs Git

  • TFVC : Centralisé, permissions granulaires, adapté aux gros fichiers binaires
  • Git : Distribué, flexible, branches légères, standard de l’industrie

✅ Visual Studio & Git

  • Intégration native de Git dans Visual Studio
  • Team Explorer pour gérer repos, branches, commits, PRs
  • Outils de résolution de conflits intégrés

✅ Workflow Git avec Azure DevOps

  • Clone HTTPS ou SSH
  • Stratégies de branches : Git Flow ou GitHub Flow
  • Pull Requests avec reviews obligatoires
  • Branch Policies pour protéger les branches importantes

✅ Commandes Git essentielles

git clone    # Cloner un repo
git status   # Voir l'état
git add      # Stager des changements
git commit   # Créer un commit
git push     # Envoyer vers remote
git pull     # Récupérer depuis remote
git branch   # Gérer les branches
git checkout # Basculer de branche
git merge    # Fusionner des branches

✅ Bonnes pratiques

  • Commits petits et fréquents
  • Messages de commit descriptifs (Conventional Commits)
  • Toujours travailler sur des branches
  • Pull Requests pour toute modification sur main
  • Résoudre les conflits localement avant de pousser

3.8 Ressources complémentaires

3.8.1 Documentation

3.8.2 Tutoriels interactifs

3.8.3 Outils

3.8.4 Cheat Sheets

3.9 Préparation pour le Module 3

Dans le prochain module, nous allons :

  • Créer des plans de tests
  • Implémenter des tests fonctionnels
  • Gérer les bugs et feedbacks
  • Utiliser Azure Test Plans
  • Faire des tests de charge dans le Cloud

4 Mettre en place des tests

4.1 Objectifs pédagogiques

À l’issue de ce module, vous serez capable de :

  • Créer et gérer des plans de tests dans Azure Test Plans
  • Implémenter des tests fonctionnels manuels et automatisés
  • Gérer les bugs et le cycle de feedback
  • Exécuter des tests de charge dans le Cloud
  • Intégrer les tests dans le processus CI/CD

4.2 Plan de test et tests fonctionnels

4.2.1 Qu’est-ce qu’un plan de test ?

Un plan de test est un document qui définit la stratégie, les ressources, le périmètre et le planning des activités de test.

4.2.2 Hiérarchie des tests dans Azure DevOps

Test Plan (Plan de test global)
├─ Test Suite (Suite de tests par fonctionnalité)
│  ├─ Test Case (Cas de test spécifique)
│  │  ├─ Test Steps (Étapes du test)
│  │  ├─ Expected Results (Résultats attendus)
│  │  └─ Attachments (Captures, fichiers)
│  └─ Test Case
└─ Test Suite

4.2.3 Types de suites de tests

Type Description Usage
Static Suite Suite manuelle avec test cases ajoutés manuellement Tests de validation métier
Requirement-based Suite Suite basée sur des User Stories/Requirements Tests de validation des exigences
Query-based Suite Suite dynamique basée sur une requête Tests de régression

4.2.4 Anatomie d’un test case

┌────────────────────────────────────────────────────────────┐
│ Test Case #123: User Login with Valid Credentials        │
├────────────────────────────────────────────────────────────┤
│                                                            │
│ State: Design              Priority: 1 (High)              │
│ Assigned To: Alice         Area: Authentication            │
│ Iteration: Sprint 3                                        │
│                                                            │
│ Description:                                               │
│ Verify that a user can successfully log in with valid      │
│ credentials.                                               │
│                                                            │
│ Steps:                                                     │
│ ┌──┬────────────────────────────┬─────────────────────┐    │
│ │# │ Action                     │ Expected Result     │    │
│ ├──┼────────────────────────────┼─────────────────────┤    │
│ │1 │ Navigate to login page     │ Login form displays │    │
│ │2 │ Enter username: user@ex... │ Username accepted   │    │
│ │3 │ Enter password: Pass123!   │ Password masked     │    │
│ │4 │ Click Login button         │ Redirected to dash  │    │
│ │5 │ Verify user name displayed │ "Welcome, User"     │    │
│ └──┴────────────────────────────┴─────────────────────┘    │
│                                                            │
│ Automation Status: Not Automated                           │
│ Automated Test: N/A                                        │
│                                                            │
│ Attachments: login-mockup.png                              │
│ Links: User Story #45                                      │
│                                                            │
└────────────────────────────────────────────────────────────┘

4.2.5 Créer un plan de test dans Azure DevOps

4.2.5.1 Étape 1 : Créer le test plan

Azure DevOps → Test Plans → + New Test Plan

Name: ShopConnect - Sprint 3 Testing
Area Path: ShopConnect\Testing
Iteration: Sprint 3

[Create]

4.2.6.1 Étape 2 : Créer des suites de tests

Test Plan → + New Suite

Option 1: Static test suite
Name: User Authentication Tests
[Create]

Option 2: Requirement-based test suite
Based on requirement: User Story #45 - User Login
[Create]

Option 3: Query-based test suite
Query: Work Item Type = Bug AND State = Active
[Create]

4.2.7.1 Étape 3 : Créer des test cases

Via l’interface :

Test Suite → + New Test Case

┌────────────────────────────────────────────────┐
│ New Test Case                                  │
├────────────────────────────────────────────────┤
│                                                │
│ Title: *                                       │
│ User can login with valid credentials          │
│                                                │
│ Assigned To: [Select user]                     │
│ State: Design                                  │
│ Priority: 1 - High                             │
│ Area: Authentication                           │
│                                                │
│ Steps:                                         │
│ ┌────────────────────────────────────────┐   │
│ │ Step 1:                                 │   │
│ │ Action: Navigate to /login              │   │
│ │ Expected: Login form visible            │   │
│ │ [+ Add step]                            │   │
│ └────────────────────────────────────────┘   │
│                                                │
│ [Save & Close]                                 │
└────────────────────────────────────────────────┘

Format détaillé d’un test case :

# TC-001: User Login with Valid Credentials

## Preconditions
- User account exists in the system
- Database is populated with test data
- Application is running on test environment

## Test Data
| Username | Password | Expected |
|----------|----------|----------|
| user@test.com | Pass123! | Success |
| admin@test.com | Admin123! | Success |

## Test Steps

### Step 1: Navigate to login page
**Action:** Open browser and go to https://shopconnect-test.com/login
**Expected Result:** 
- Login page loads within 2 seconds
- Login form is visible
- Username and password fields are present

### Step 2: Enter valid username
**Action:** Type "user@test.com" in the username field
**Expected Result:** 
- Text appears in the field
- No validation error

### Step 3: Enter valid password
**Action:** Type "Pass123!" in the password field
**Expected Result:** 
- Password is masked (shows dots)
- No validation error

### Step 4: Click Login button
**Action:** Click the "Login" button
**Expected Result:** 
- Loading indicator appears briefly
- User is redirected to dashboard
- URL changes to /dashboard

### Step 5: Verify successful login
**Action:** Check the dashboard page
**Expected Result:** 
- User name "User" is displayed in header
- Logout button is visible
- User-specific data is shown

## Postconditions
- User remains logged in
- Session cookie is created
- Last login timestamp is updated in database

## Notes
- Test on Chrome, Firefox, and Edge
- Mobile responsiveness to be tested separately

4.2.9 Configurations de test

Les configurations permettent de tester sur différents environnements.

Test Configurations:
├─ Windows 10 + Chrome
├─ Windows 10 + Firefox
├─ Windows 10 + Edge
├─ macOS + Safari
├─ Android + Chrome Mobile
└─ iOS + Safari Mobile

Créer une configuration :

Project Settings → Test → Test Configurations

Name: Windows 10 Chrome
Configuration Variables:
├─ OS: Windows 10
├─ Browser: Chrome 120
└─ Resolution: 1920x1080

[Save]

Assigner une configuration à un test :

Test Case → Configurations → + Add configuration
Select: Windows 10 Chrome, macOS Safari
[Save]

Résultat: Le test devra être exécuté 2 fois (une fois par config)

4.2.12 Exécuter des tests manuels

4.2.12.1 Via le Test Runner

Test Suite → Test Case → [Run for web application]

┌────────────────────────────────────────────────┐
│ Test Runner - TC-001                           │
├────────────────────────────────────────────────┤
│                                                │
│ [◀] Step 1 of 5 [▶]                           │
│                                                │
│ Action:                                        │
│ Navigate to login page                         │
│                                                │
│ Expected Result:                               │
│ Login form displays within 2 seconds           │
│                                                │
│ ┌──────────────────────────────────────┐      │
│ │ [Screenshot] [📹 Record] [📎 Attach] │      │
│ └──────────────────────────────────────┘      │
│                                                │
│ Actual Result: (optional)                      │
│ ┌──────────────────────────────────────┐      │
│ │ Login form loaded in 1.2s             │      │
│ └──────────────────────────────────────┘      │
│                                                │
│ [✓ Pass]  [✗ Fail]  [⊘ Blocked]  [◯ Not Run] │
│                                                │
│ [Save & Continue]                              │
└────────────────────────────────────────────────┘

Résultats possibles :

Status Description Action
Passed ✓ Test réussi Continuer
Failed ✗ Test échoué Créer un bug
Blocked ⊘ Impossible de tester Marquer l’obstacle
Not Run ○ Non exécuté Reporter

4.2.14.1 Créer un bug depuis le Test Runner

[✗ Fail] → Create bug

┌────────────────────────────────────────────────┐
│ New Bug                                        │
├────────────────────────────────────────────────┤
│                                                │
│ Title: *                                       │
│ Login button not responding on mobile          │
│                                                │
│ Repro Steps: (Auto-populated)                  │
│ 1. Navigate to login page                      │
│ 2. Enter username: user@test.com               │
│ 3. Enter password: Pass123!                    │
│ 4. Click Login button                          │
│ Result: Button click has no effect             │
│                                                │
│ System Info: (Auto-populated)                  │
│ OS: Android 12                                 │
│ Browser: Chrome Mobile 120                     │
│                                                │
│ Attachments: (Auto-added)                      │
│ • screenshot-2024-05-25-14-30.png              │
│ • test-session-log.txt                         │
│                                                │
│ Severity: 2 - High                             │
│ Priority: 2 - High                             │
│ Assigned To: [Dev Team]                        │
│                                                │
│ [Save & Close]                                 │
└────────────────────────────────────────────────┘

Le bug est automatiquement lié au test case!

4.2.15 Tests exploratoires

Les tests exploratoires permettent de tester librement sans test case prédéfini.

Azure DevOps → Test Plans → Runs → + New Test → Exploratory Testing

1. Télécharger l'extension Chrome "Test & Feedback"
2. Configurer la connexion à Azure DevOps
3. Démarrer une session exploratoire:
   - Cible: https://shopconnect-test.com
   - Duration: 30 minutes
   - Focus: User checkout flow

4. Pendant l'exploration:
   • Créer des bugs à la volée
   • Capturer des screenshots/vidéos
   • Ajouter des notes
   • Créer des test cases pour les scénarios intéressants

5. Terminer la session
   → Tous les artifacts sont automatiquement sauvegardés

4.2.16 Mesurer la qualité avec des métriques

4.2.16.1 Dashboard de test

┌────────────────────────────────────────────────────────┐
│ Test Summary Dashboard - Sprint 3                      │
├────────────────────────────────────────────────────────┤
│                                                        │
│ Test Execution Status                                  │
│ ┌────────────────────────────────────────┐             │
│ │         █████████░░░░░░                │             │
│ │ Passed:   45 (75%)                     │             │
│ │ Failed:    8 (13%)                     │             │
│ │ Blocked:   3 (5%)                      │             │
│ │ Not Run:   4 (7%)                      │             │
│ │ Total:    60                           │             │
│ └────────────────────────────────────────┘             │
│                                                        │
│ Test Results Trend                                     │
│ │                               ●                      │
│ │                           ●       ●                  │
│ │                       ●               ●              │
│ │                   ●                                  │
│ │ Pass Rate     ●                                      │
│ │           ●                                          │
│ └──────────────────────────────────────────▶           │
│   S1   S2   S3   S4   S5   S6   S7   (Sprints)         │
│                                                        │
│ Bugs by Priority                                       │
│ Critical:   2   ██                                     │
│ High:       5   █████                                  │
│ Medium:     8   ████████                               │
│ Low:        3   ███                                    │
│                                                        │
│ Test Coverage: 87%                                     │
│ Requirements Tested: 23/26                             │
│                                                        │
└────────────────────────────────────────────────────────┘

4.2.17.1 KPIs importants

Métrique Formule Objectif
Pass Rate (Passed / Total) × 100 > 90%
Test Coverage (Features Tested / Total Features) × 100 > 85%
Bug Density Bugs / 1000 LOC < 5
Defect Removal Efficiency (Bugs Found Pre-Prod / Total Bugs) × 100 > 95%
Time to Fix Moyenne du temps de résolution < 48h (Critical)

4.3 Gestion des bugs et feedbacks

4.3.1 Cycle de vie d’un bug

4.3.2 États des bugs

État Responsable Actions
New Triage team Évaluer, prioriser, assigner
Active Developer Analyser, corriger, commiter
Resolved Developer Fix déployé en test
Closed QA Fix vérifié et validé

4.3.3 Créer un bug de qualité

4.3.3.1 Template de bug complet

# Bug #456: Login button unresponsive on mobile devices

## Severity: 2 - High
## Priority: 2 - High
## Found in Build: 1.2.34
## Iteration: Sprint 3

## Description
The login button does not respond to touch events on mobile devices 
(Android and iOS), preventing users from logging in.

## Steps to Reproduce
1. Open ShopConnect on mobile device (Android 12 or iOS 16)
2. Navigate to /login
3. Enter valid credentials:
   - Username: test@example.com
   - Password: TestPass123!
4. Tap the "Login" button
5. **Actual Result:** No response, button does not trigger login
6. **Expected Result:** User should be logged in and redirected to dashboard

## Environment
- **Device:** Samsung Galaxy S21, iPhone 13 Pro
- **OS:** Android 12, iOS 16
- **Browser:** Chrome Mobile 120, Safari Mobile 16
- **Build:** 1.2.34
- **URL:** https://shopconnect-test.com/login

## Reproduction Rate
- Occurs: 10/10 times (100%)
- Intermittent: No
- Specific conditions: Mobile devices only

## Impact
- **User Impact:** Critical - Users cannot login on mobile
- **Business Impact:** High - 40% of traffic is mobile
- **Workaround:** None available

## Attachments
- Screenshot: login-button-issue.png
- Screen recording: mobile-login-fail.mp4
- Console logs: console-errors.txt
- Network trace: network-activity.har

## Related Work Items
- Test Case: #TC-001 - User Login
- User Story: #45 - User Authentication
- Related Bug: #423 - Touch events not working (Closed)

## Additional Information
Issue started appearing after deployment of build 1.2.34.
Previous build (1.2.33) was working fine on mobile devices.
Desktop browsers (Chrome, Firefox, Edge) are not affected.

4.3.4.1 Champs obligatoires d’un bug

┌────────────────────────────────────────────────┐
│ Bug Work Item                                  │
├────────────────────────────────────────────────┤
│                                                │
│ Title: * (Required)                            │
│ ┌──────────────────────────────────────────┐   │
│ │ Login button unresponsive on mobile      │   │
│ └──────────────────────────────────────────┘   │
│                                                │
│ Assigned To: * (Required)                      │
│ [John Doe - Developer] ▼                       │
│                                                │
│ State: * (Required)                            │
│ [New] ▼                                        │
│                                                │
│ Area: * (Required)                             │
│ [ShopConnect\Authentication] ▼                 │
│                                                │
│ Iteration: * (Required)                        │
│ [Sprint 3] ▼                                   │
│                                                │
│ Priority: * (Required)                         │
│ [2 - High] ▼                                   │
│                                                │
│ Severity: * (Required)                         │
│ [2 - High] ▼                                   │
│                                                │
│ Repro Steps: * (Required)                      │
│ ┌──────────────────────────────────────────┐   │
│ │ 1. Navigate to /login on mobile          │   │
│ │ 2. Enter credentials                     │   │
│ │ 3. Tap Login button                      │   │
│ │ Result: No response                      │   │
│ └──────────────────────────────────────────┘   │
│                                                │
│ System Info:                                   │
│ ┌──────────────────────────────────────────┐   │
│ │ Android 12, Chrome Mobile 120            │   │
│ └──────────────────────────────────────────┘   │
│                                                │
│ Found In Build:                                │
│ [1.2.34] ▼                                     │
│                                                │
│ Tags:                                          │
│ mobile; authentication; critical               │
│                                                │
└────────────────────────────────────────────────┘

4.3.5 Niveaux de priorité et sévérité

4.3.5.1 Matrice Priorité vs Sévérité

              IMPACT (Severity)
               │
        Low    │  Medium  │  High   │ Critical
    ───────────┼──────────┼─────────┼──────────
      Low   │    P4    │    P3    │    P2    │
            │ (Minor)  │ (Normal) │ (Major)  │
    ────────┼──────────┼──────────┼──────────┤
    Medium│    P3    │    P2    │    P1    │
  U         │ (Normal) │ (Major)  │(Critical)│
  R ────────┼──────────┼──────────┼──────────┤
  G   High  │    P2    │    P1    │    P0    │
  E         │ (Major)  │(Critical)│ (Blocker)│
  N ────────┴──────────┴──────────┴──────────┘
  C
  Y

Définitions :

Priorité SLA Description
P0 - Blocker 4h Système down, perte de données
P1 - Critical 1 jour Fonctionnalité majeure inutilisable
P2 - High 3 jours Impact significatif sur les utilisateurs
P3 - Medium 1 semaine Impact modéré, workaround existe
P4 - Low 2 semaines Impact mineur, cosmétique

4.3.7 Workflow de gestion des bugs

4.3.7.1 1. Triage des bugs

Réunion de triage quotidienne (15 min) :

Participants: Product Owner, Tech Lead, QA Lead

Agenda:
├─ Review des nouveaux bugs (State = New)
├─ Évaluation de la priorité et sévérité
├─ Assignment aux développeurs
├─ Identification des duplicatas
└─ Décision: Fix, Defer, ou Close

Critères de décision:
• Impact utilisateur
• Complexité de la correction
• Priorités du sprint
• Disponibilité de l'équipe

4.3.8.1 2. Investigation et correction

Developer Workflow:

1. Prendre le bug en charge (State: Active)
   git checkout -b bugfix/456-login-mobile

2. Reproduire localement
   • Suivre les "Repro Steps"
   • Confirmer le problème
   • Si non reproductible → Demander plus d'infos

3. Analyser la cause racine
   • Déboguer le code
   • Identifier le commit qui a introduit le bug
   • Documenter dans le bug

4. Implémenter la correction
   • Corriger le code
   • Ajouter un test de non-régression
   • Commiter avec référence au bug

5. Créer une Pull Request
   Title: Fix #456: Login button unresponsive on mobile
   Description:
   • Root cause: Touch event listener not attached
   • Solution: Bind touchstart event in addition to click
   • Testing: Verified on Android 12 and iOS 16
   
   Fixes #456

6. Une fois mergé, changer l'état
   State: Resolved → Fixed In Build: 1.2.35

Commit message avec référence au bug :

git commit -m "fix(auth): attach touch event listener to login button

On mobile devices, the click event was not triggered by touch.
Added touchstart event listener for mobile compatibility.

Fixes #456"

4.3.10.1 3. Vérification par QA

QA Workflow:

1. Attendre le déploiement en environnement de test
   Build 1.2.35 deployed to https://shopconnect-test.com

2. Retester le scénario original
   • Suivre les "Repro Steps" du bug
   • Tester sur les environnements affectés
   • Vérifier qu'aucune régression n'est introduite

3. Tests de régression
   • Exécuter les test cases liés
   • Vérifier les fonctionnalités connexes

4. Décision:
   ✓ Si OK → State: Closed
   ✗ Si KO → State: Active + Commentaire détaillé

4.3.11 Gestion des feedbacks utilisateurs

4.3.11.1 Sources de feedback

4.3.12.1 Catégoriser les feedbacks

Azure DevOps → Boards → Work Items

Type de feedback:
├─ Bug → Si comportement incorrect
├─ User Story → Si nouvelle fonctionnalité
├─ Task → Si amélioration technique
└─ Impediment → Si blocage

Tags:
├─ user-feedback
├─ customer-reported
├─ high-value-customer
└─ product-improvement

4.3.13.1 Template pour feedback utilisateur

# Feedback: Checkout process too complex

## Source: Customer Support Ticket #7892
## Reporter: Jane Smith (Premium Customer)
## Date: 2024-05-25
## Category: User Experience

## Original Feedback
"The checkout process has too many steps. I have to click through 
5 different pages just to buy one item. Amazon does this in 2 clicks, 
why can't you?"

## Business Impact
- Customer Segment: Premium (high value)
- Frequency: 15 similar reports this month
- Revenue Impact: Estimated 5% cart abandonment due to this issue

## Current Process
1. View Cart
2. Confirm Items
3. Shipping Address
4. Billing Address
5. Payment Method
6. Review Order
7. Confirm Purchase

## Proposed Solution
Combine steps 3-5 into a single page for returning customers.
Implement "1-Click Buy" for saved payment methods.

## Priority: High
## Assigned To: UX Team
## Target Sprint: Sprint 4

## Related Work Items
- User Story #234: Improve checkout flow
- User Story #235: Implement 1-click purchase
- Analytics Report: Checkout Funnel Analysis

4.3.14 Dashboards de suivi des bugs

┌──────────────────────────────────────────────────────────┐
│ Bug Tracking Dashboard                                   │
├──────────────────────────────────────────────────────────┤
│                                                          │
│ Active Bugs by Priority                                  │
│ ┌────────────────────────────────────────┐               │
│ │ P0 - Blocker:     0 │███               │               │
│ │ P1 - Critical:    3 │███████████       │               │
│ │ P2 - High:        8 │████████████████  │               │
│ │ P3 - Medium:     12 │███████████       │               │
│ │ P4 - Low:         5 │█████             │               │
│ └────────────────────────────────────────┘               │
│                                                          │
│ Bug Age (Days Open)                                      │
│ ┌────────────────────────────────────────┐               │
│ │ 0-3 days:    15 bugs                   │               │
│ │ 4-7 days:     8 bugs                   │               │
│ │ 8-14 days:    3 bugs ⚠️                │               │
│ │ > 14 days:    2 bugs 🚨                │               │
│ └────────────────────────────────────────┘               │
│                                                          │
│ Top Bug Categories                                       │
│ 1. Authentication     8 bugs                             │
│ 2. Payment           5 bugs                              │
│ 3. UI/UX             4 bugs                              │
│ 4. Performance       3 bugs                              │
│ 5. Data validation   2 bugs                              │
│                                                          │
│ Bugs Opened vs Resolved (Last 7 days)                    │
│ │                                                        │
│ │     █ █                                                │
│ │   █ █ █   █                                            │
│ │ █ █ █ █ █ █ █                                          │
│ └─┴─┴─┴─┴─┴─┴─▶                                          │
│  M T W T F S S                                           │
│  █ Opened  █ Resolved                                    │
│                                                          │
│ SLA Compliance: 85%  ⚠️ Target: 95%                      │
│                                                          │
└──────────────────────────────────────────────────────────┘

4.4 Test de charge dans le Cloud

4.4.1 Qu’est-ce qu’un test de charge ?

Un test de charge simule l’activité de nombreux utilisateurs simultanés pour évaluer les performances et la stabilité de l’application.

4.4.2 Types de tests de performance

Type Objectif Métrique clé Durée
Load Test Performance sous charge normale Response time, throughput 15-60 min
Stress Test Identifier le point de rupture Max users, error rate 30-90 min
Spike Test Réaction aux pics soudains Recovery time 15-30 min
Soak Test Stabilité sur longue durée Memory leaks, degradation 4-24h
Scalability Test Capacité à scaler Linear scalability Variable

4.4.3 Azure Load Testing

Azure Load Testing est un service managé pour exécuter des tests de charge à grande échelle.

Architecture:
┌────────────────────────────────────────────────────┐
│                 Azure Load Testing                 │
├────────────────────────────────────────────────────┤
│                                                    │
│  ┌──────────────┐        ┌───────────────┐         │
│  │ Test Script  │───────▶│ Test Engine   │         │
│  │ (JMeter/K6)  │        │               │         │
│  └──────────────┘        └───────┬───────┘         │
│                                  │                 │
│                         ┌────────▼─────────┐       │
│                         │  Load Generators │       │
│                         │  (Auto-scaled)   │       │
│                         └────────┬─────────┘       │
│                                  │                 │
└──────────────────────────────────┼─────────────────┘
                                   │
                          ┌────────▼──────────┐
                          │ Target Application│
                          │  (ShopConnect)    │
                          └───────────────────┘

4.4.4 Créer un test de charge avec JMeter

4.4.4.1 Étape 1 : Créer un script JMeter

Scénario de test : Simuler 100 utilisateurs qui naviguent et achètent des produits.

<?xml version="1.0" encoding="UTF-8"?>
<jmeterTestPlan version="1.2" properties="5.0">
  <hashTree>
    <TestPlan guiclass="TestPlanGui" testname="ShopConnect Load Test">
      <elementProp name="TestPlan.user_defined_variables" elementType="Arguments">
        <collectionProp name="Arguments.arguments">
          <elementProp name="BASE_URL" elementType="Argument">
            <stringProp name="Argument.name">BASE_URL</stringProp>
            <stringProp name="Argument.value">https://shopconnect-test.com</stringProp>
          </elementProp>
          <elementProp name="USERS" elementType="Argument">
            <stringProp name="Argument.name">USERS</stringProp>
            <stringProp name="Argument.value">100</stringProp>
          </elementProp>
          <elementProp name="RAMP_UP" elementType="Argument">
            <stringProp name="Argument.name">RAMP_UP</stringProp>
            <stringProp name="Argument.value">60</stringProp>
          </elementProp>
        </collectionProp>
      </elementProp>
    </TestPlan>
    
    <hashTree>
      <ThreadGroup guiclass="ThreadGroupGui" testname="User Journey">
        <stringProp name="ThreadGroup.num_threads">${USERS}</stringProp>
        <stringProp name="ThreadGroup.ramp_time">${RAMP_UP}</stringProp>
        <stringProp name="ThreadGroup.duration">300</stringProp>
        <boolProp name="ThreadGroup.scheduler">true</boolProp>
      </ThreadGroup>
      
      <hashTree>
        <!-- Scenario: Browse Products -->
        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testname="GET /products">
          <stringProp name="HTTPSampler.domain">${BASE_URL}</stringProp>
          <stringProp name="HTTPSampler.path">/api/products</stringProp>
          <stringProp name="HTTPSampler.method">GET</stringProp>
        </HTTPSamplerProxy>
        
        <hashTree>
          <ResponseAssertion guiclass="AssertionGui" testname="Check 200 OK">
            <collectionProp name="Asserion.test_strings">
              <stringProp name="49586">200</stringProp>
            </collectionProp>
            <stringProp name="Assertion.test_field">Assertion.response_code</stringProp>
          </ResponseAssertion>
          
          <JSONExtractor guiclass="JSONPostProcessorGui" testname="Extract Product ID">
            <stringProp name="JSONExtractor.referenceName">PRODUCT_ID</stringProp>
            <stringProp name="JSONExtractor.jsonPathExpression">$[0].id</stringProp>
          </JSONExtractor>
        </hashTree>
        
        <!-- Add to Cart -->
        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testname="POST /cart/add">
          <stringProp name="HTTPSampler.domain">${BASE_URL}</stringProp>
          <stringProp name="HTTPSampler.path">/api/cart/add</stringProp>
          <stringProp name="HTTPSampler.method">POST</stringProp>
          <stringProp name="HTTPSampler.postBodyRaw">{"productId": "${PRODUCT_ID}", "quantity": 1}</stringProp>
          <elementProp name="HTTPsampler.Headers" elementType="HeaderManager">
            <collectionProp name="HeaderManager.headers">
              <elementProp name="Content-Type" elementType="Header">
                <stringProp name="Header.name">Content-Type</stringProp>
                <stringProp name="Header.value">application/json</stringProp>
              </elementProp>
            </collectionProp>
          </elementProp>
        </HTTPSamplerProxy>
        
        <!-- Think Time -->
        <UniformRandomTimer guiclass="UniformRandomTimerGui" testname="Think Time">
          <stringProp name="ConstantTimer.delay">2000</stringProp>
          <stringProp name="RandomTimer.range">3000</stringProp>
        </UniformRandomTimer>
        
        <!-- Checkout -->
        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testname="POST /checkout">
          <stringProp name="HTTPSampler.domain">${BASE_URL}</stringProp>
          <stringProp name="HTTPSampler.path">/api/checkout</stringProp>
          <stringProp name="HTTPSampler.method">POST</stringProp>
        </HTTPSamplerProxy>
      </hashTree>
    </hashTree>
  </hashTree>
</jmeterTestPlan>

Version simplifiée pour débutants (CSV):

Label,Method,URL,Body
Browse Products,GET,https://shopconnect-test.com/api/products,
Add to Cart,POST,https://shopconnect-test.com/api/cart,{"productId":1,"qty":1}
Checkout,POST,https://shopconnect-test.com/api/checkout,{"paymentMethod":"credit_card"}

4.4.6.1 Étape 2 : Configurer Azure Load Testing

1. Azure Portal → Create Resource → Azure Load Testing
   Name: shopconnect-loadtest
   Region: West Europe
   [Create]

2. Upload JMeter script
   Azure Load Testing → Tests → + Create → Upload a JMX file
   File: ShopConnectLoadTest.jmx
   Test name: Product Purchase Load Test
   Description: Simulate 100 users browsing and purchasing

3. Configure test parameters
   Engine instances: 1 (scales automatically)
   Load pattern: Linear
   Total users: 100
   Ramp-up time: 60 seconds
   Test duration: 300 seconds (5 minutes)

4. Configure monitoring
   ✓ Enable Application Insights
   ✓ Enable Azure Monitor
   Resource to monitor: shopconnect-webapp

5. [Run Test]

4.4.7 Analyser les résultats

4.4.7.1 Dashboard de test de charge

┌────────────────────────────────────────────────────────────┐
│ Load Test Results - Product Purchase Load Test             │
├────────────────────────────────────────────────────────────┤
│                                                            │
│ Test Summary                                               │
│ ├─ Start Time: 2024-05-25 14:00:00                         │
│ ├─ Duration: 5 minutes                                     │
│ ├─ Total Requests: 15,247                                  │
│ ├─ Success Rate: 98.7% ✓                                   │
│ └─ Error Rate: 1.3%                                        │
│                                                            │
│ Response Times (ms)                                        │
│ ┌────────────────────────────────────────┐                 │
│ │ Metric     │  Min │  Avg │  P95 │  Max │                 │
│ ├────────────┼──────┼──────┼──────┼──────┤                 │
│ │ GET /prods │   45 │  127 │  245 │  890 │                 │
│ │ POST /cart │   67 │  156 │  312 │ 1245 │                 │
│ │ POST /chkt │  123 │  289 │  567 │ 2134 │                 │
│ └────────────┴──────┴──────┴──────┴──────┘                 │
│                                                            │
│ Throughput                                                 │
│ │                                                          │
│ │         ╱▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔╲                             │
│ │       ╱                      ╲                           │
│ │     ╱                          ╲                         │
│ │   ╱                              ╲                       │
│ │ ╱                                  ╲                     │
│ └────────────────────────────────────────▶                 │
│  0    1    2    3    4    5  (minutes)                     │
│  Peak: 52 req/sec at 2:30                                  │
│                                                            │
│ Error Analysis                                             │
│ ├─ HTTP 500: 128 (0.8%) - Internal Server Error            │
│ ├─ HTTP 503: 45 (0.3%) - Service Unavailable               │
│ ├─ Timeout: 23 (0.2%) - Request Timeout                    │
│ └─ Connection: 2 (0.01%) - Connection Refused              │
│                                                            │
│ Resource Utilization (Target App)                          │
│ ├─ CPU: Avg 67%, Peak 89%                                  │
│ ├─ Memory: Avg 73%, Peak 85%                               │
│ ├─ Network: Avg 45 Mbps                                    │
│ └─ Database: Avg 234 connections, Peak 456                 │
│                                                            │
│ Recommendations:                                           │
│ ⚠️ High P95 response time on checkout endpoint             │
│ ⚠️ CPU peaked at 89% - consider scaling                    │
│ ✓ Error rate within acceptable range                       │
│                                                            │
└────────────────────────────────────────────────────────────┘

4.4.8 Métriques importantes

4.4.8.1 1. Response Time (Temps de réponse)

Catégories:
├─ Excellent: < 100ms
├─ Good: 100-300ms
├─ Fair: 300-1000ms
├─ Poor: 1000-3000ms
└─ Unacceptable: > 3000ms

Percentiles importants:
├─ P50 (Médiane): Expérience typique
├─ P95: 95% des users ont ce temps ou mieux
├─ P99: Les cas extrêmes
└─ Max: Le pire cas

4.4.9.1 2. Throughput (Débit)

Formule: Throughput = Requests / Second

Objectifs typiques:
├─ Application web: 100-1000 req/s
├─ API REST: 1000-10000 req/s
├─ Microservice: 10000+ req/s

4.4.10.1 3. Error Rate (Taux d’erreur)

Formule: Error Rate = (Errors / Total Requests) × 100%

Seuils:
├─ Production: < 0.1%
├─ Acceptable: < 1%
├─ Warning: 1-5%
└─ Critical: > 5%

4.4.11 Tests de charge avec Azure DevOps Pipeline

Intégrer les tests de charge dans CI/CD :

# azure-pipelines-loadtest.yml

trigger: none  # Manuel uniquement

pool:
  vmImage: 'ubuntu-latest'

variables:
  loadTestResource: 'shopconnect-loadtest'
  testFile: 'loadtests/ProductPurchase.jmx'

stages:
- stage: LoadTest
  displayName: 'Execute Load Test'
  jobs:
  - job: RunLoadTest
    displayName: 'Run Load Test'
    steps:
    
    - task: AzureCLI@2
      displayName: 'Upload and Run Load Test'
      inputs:
        azureSubscription: 'Azure-Connection'
        scriptType: 'bash'
        scriptLocation: 'inlineScript'
        inlineScript: |
          # Upload test
          az load test create \
            --test-id "product-purchase-test" \
            --load-test-resource $(loadTestResource) \
            --test-file $(testFile) \
            --display-name "Product Purchase Test - Build $(Build.BuildId)"
          
          # Run test
          az load test run \
            --test-id "product-purchase-test" \
            --load-test-resource $(loadTestResource) \
            --display-name "Run-$(Build.BuildId)"
    
    - task: AzureCLI@2
      displayName: 'Get Test Results'
      inputs:
        azureSubscription: 'Azure-Connection'
        scriptType: 'bash'
        scriptLocation: 'inlineScript'
        inlineScript: |
          # Wait for test completion
          az load test run wait \
            --test-run-id $(az load test run show --query id -o tsv) \
            --load-test-resource $(loadTestResource)
          
          # Download results
          az load test run download-files \
            --test-run-id $(az load test run show --query id -o tsv) \
            --load-test-resource $(loadTestResource) \
            --path $(Build.ArtifactStagingDirectory)/results
    
    - task: PublishBuildArtifacts@1
      displayName: 'Publish Test Results'
      inputs:
        PathtoPublish: '$(Build.ArtifactStagingDirectory)/results'
        ArtifactName: 'LoadTestResults'
    
    - task: Bash@3
      displayName: 'Validate Performance Thresholds'
      inputs:
        targetType: 'inline'
        script: |
          # Extract metrics from results
          AVG_RESPONSE_TIME=$(cat results/summary.json | jq '.avgResponseTime')
          ERROR_RATE=$(cat results/summary.json | jq '.errorRate')
          
          # Define thresholds
          MAX_AVG_RESPONSE_TIME=500  # ms
          MAX_ERROR_RATE=1.0         # %
          
          # Validate
          if (( $(echo "$AVG_RESPONSE_TIME > $MAX_AVG_RESPONSE_TIME" | bc -l) )); then
            echo "##vso[task.logissue type=error]Average response time ($AVG_RESPONSE_TIME ms) exceeds threshold ($MAX_AVG_RESPONSE_TIME ms)"
            exit 1
          fi
          
          if (( $(echo "$ERROR_RATE > $MAX_ERROR_RATE" | bc -l) )); then
            echo "##vso[task.logissue type=error]Error rate ($ERROR_RATE%) exceeds threshold ($MAX_ERROR_RATE%)"
            exit 1
          fi
          
          echo "✓ Performance thresholds met!"

4.4.12 Bonnes pratiques des tests de charge

4.4.12.1 1. Scénarios réalistes

❌ Mauvais: Tous les users font exactement la même chose
✓ Bon: Mix de comportements utilisateurs

Exemple de distribution:
├─ 60% Browse only (navigation)
├─ 25% Browse + Add to Cart
├─ 10% Complete Purchase
└─ 5% Search + Filter

4.4.13.1 2. Ramp-up progressif

❌ Mauvais: 0 → 1000 users instantanément
✓ Bon: Montée progressive

Users
1000 │                    ▄▀▀▀▀▀▀▀▀
     │                 ▄▀▀
     │              ▄▀▀
 500 │           ▄▀▀
     │        ▄▀▀
     │     ▄▀▀
   0 └──▀▀────────────────────────▶ Time
     0   5   10   15  (minutes)

4.4.14.1 3. Think Time

Simuler les pauses utilisateur:

page.click('#product')
await page.waitForTimeout(random(2000, 5000))  // Think time
page.click('#add-to-cart')
await page.waitForTimeout(random(1000, 3000))
page.click('#checkout')

4.4.15.1 4. Test Data

❌ Mauvais: Tous les users utilisent le même compte
✓ Bon: Pool de comptes de test

CSV avec test data:
username,password,credit_card
user001@test.com,Pass123!,4111111111111111
user002@test.com,Pass123!,4111111111111112
user003@test.com,Pass123!,4111111111111113
...

JMeter: CSV Data Set Config
File: testusers.csv
Variable Names: username,password,card
Recycle on EOF: True

4.5 Travaux Pratiques

TP3 : Conception et mise en œuvre des tests avec Azure

4.6 Synthèse du Module 3

4.6.1 Points clés à retenir

✅ Plans de test

  • Structure hiérarchique: Test Plan → Test Suite → Test Case
  • Types de suites: Static, Requirement-based, Query-based
  • Configurations pour tester sur différents environnements

✅ Test Cases

  • Steps détaillés avec actions et résultats attendus
  • Priorité et sévérité
  • Liens avec User Stories et Requirements
  • Screenshots et attachments pour contexte

✅ Gestion des bugs

  • Cycle de vie: New → Active → Resolved → Closed
  • Informations essentielles: Repro steps, environnement, impact
  • Création depuis Test Runner avec contexte automatique
  • Lien avec test cases pour traçabilité

✅ Tests de charge

  • Types: Load, Stress, Spike, Soak
  • Outils: Azure Load Testing, JMeter, K6
  • Métriques: Response time, throughput, error rate
  • Analyse et identification des goulots d’étranglement

✅ Intégration CI/CD

  • Tests automatiques dans pipelines
  • Validation des seuils de performance
  • Feedback rapide sur la qualité

4.7 Ressources complémentaires

4.7.1 Documentation

4.7.2 Outils de test

4.7.3 Bonnes pratiques

4.8 Préparation pour le Module 4

Dans le prochain module, nous allons :

  • Créer des build pipelines
  • Compiler des projets
  • Exécuter des tests unitaires automatiquement
  • Automatiser les builds
  • Générer des artefacts

5 Les Builds

5.1 Objectifs pédagogiques

À l’issue de ce module, vous serez capable de :

  • Créer des pipelines de build dans Azure DevOps
  • Configurer la compilation de projets multi-plateformes
  • Intégrer les tests unitaires dans le processus de build
  • Déclencher des builds automatiquement
  • Générer et publier des artefacts
  • Optimiser les performances des builds

5.2 Créer une nouvelle définition de “build”

5.2.1 Qu’est-ce qu’un build pipeline ?

Un build pipeline est une suite d’étapes automatisées qui transforment le code source en un artefact déployable.

5.2.2 Types de pipelines

Type Description Cas d’usage
Classic Editor Interface graphique Débutants, builds simples
YAML Pipeline Pipeline as Code Recommandé, versionné avec le code
Multi-stage Pipeline Plusieurs stages (build, test, deploy) Projets complexes

5.2.3 Architecture d’un build pipeline

┌─────────────────────────────────────────────────────────┐
│                    BUILD PIPELINE                       │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  Trigger (Déclencheur)                                  │
│  ├─ Push sur main                                       │
│  ├─ Pull Request                                        │
│  └─ Planifié (nightly build)                            │
│                                                         │
│  Agent Pool (Environnement d'exécution)                 │
│  ├─ Microsoft-hosted (Ubuntu, Windows, macOS)           │
│  └─ Self-hosted (Vos propres machines)                  │
│                                                         │
│  Variables                                              │
│  ├─ BuildConfiguration: Release                         │
│  ├─ BuildPlatform: Any CPU                              │
│  └─ DotNetVersion: 8.0.x                                │
│                                                         │
│  Stages (Étapes principales)                            │
│  └─ Build                                               │
│      ├─ Jobs (Tâches parallèles)                        │
│      │   └─ Build Job                                   │
│      │       ├─ Steps (Étapes séquentielles)            │
│      │       │   ├─ Checkout code                       │
│      │       │   ├─ Install dependencies                │
│      │       │   ├─ Build solution                      │
│      │       │   ├─ Run tests                           │
│      │       │   └─ Publish artifacts                   │
│      │       └─ Conditions                              │
│      │           └─ Always, On Success, On Failure      │
│      └─ Dependencies                                    │
│                                                         │
└─────────────────────────────────────────────────────────┘

5.2.4 Créer un pipeline avec Classic Editor

5.2.4.1 Étape 1 : Accéder à Pipelines

Azure DevOps → Pipelines → Create Pipeline → Use the classic editor

5.2.5.1 Étape 2 : Sélectionner la source

┌────────────────────────────────────────────────┐
│ Select a source                                │
├────────────────────────────────────────────────┤
│                                                │
│ Where is your code?                            │
│                                                │
│ ● Azure Repos Git                              │
│   ○ GitHub                                     │
│   ○ Bitbucket Cloud                            │
│   ○ Other Git                                  │
│   ○ Subversion                                 │
│                                                │
│ Repository: [ShopConnect] ▼                    │
│ Default branch: [main] ▼                       │
│                                                │
│ [Continue]                                     │
└────────────────────────────────────────────────┘

5.2.6.1 Étape 3 : Choisir un template

┌────────────────────────────────────────────────┐
│ Select a template                              │
├────────────────────────────────────────────────┤
│                                                │
│ Featured templates:                            │
│                                                │
│ [ASP.NET]                                      │
│ Build and test ASP.NET projects                │
│                                                │
│ [ASP.NET Core]                                 │
│ Build and test ASP.NET Core projects           │
│                                                │
│ [.NET Desktop]                                 │
│ Build and test .NET Desktop applications       │
│                                                │
│ [Node.js]                                      │
│ Build and test Node.js projects                │
│                                                │
│ [Maven]                                        │
│ Build Java projects with Maven                 │
│                                                │
│ [Empty job]                                    │
│ Start with an empty pipeline                   │
│                                                │
│ [Apply]                                        │
└────────────────────────────────────────────────┘

5.2.7.1 Étape 4 : Configuration du pipeline (exemple ASP.NET Core)

┌──────────────────────────────────────────────────────────┐
│ Pipeline: ShopConnect-CI                                 │
├──────────────────────────────────────────────────────────┤
│                                                          │
│ [Get sources]                                            │
│ Repository: ShopConnect                                  │
│ Branch: main                                             │
│                                                          │
│ [Agent job 1]                                            │
│ Agent pool: [Azure Pipelines] ▼                          │
│ Agent Specification: [ubuntu-latest] ▼                   │
│                                                          │
│ Tasks:                                                   │
│ ├─ [+] Use .NET Core sdk 8.x                             │
│ ├─ [+] Restore NuGet packages                            │
│ ├─ [+] Build solution                                    │
│ ├─ [+] Run tests                                         │
│ └─ [+] Publish artifacts                                 │
│                                                          │
│ [Variables] [Triggers] [Options] [Retention] [History]   │
│                                                          │
│ [Save & queue] ▼  [Save]                                 │
└──────────────────────────────────────────────────────────┘

5.2.8 Créer un pipeline YAML (Recommandé)

5.2.8.1 Pourquoi YAML ?

✅ Avantages :

  • Pipeline versionné avec le code
  • Revue de code via Pull Request
  • Réutilisable (templates)
  • Support des multi-stages
  • Historique complet dans Git

5.2.9.1 Exemple de pipeline YAML basique

# azure-pipelines.yml

trigger:
  branches:
    include:
    - main
    - develop
  paths:
    exclude:
    - README.md
    - docs/*

pool:
  vmImage: 'ubuntu-latest'

variables:
  buildConfiguration: 'Release'
  dotnetVersion: '8.0.x'

steps:
- task: UseDotNet@2
  displayName: 'Use .NET Core SDK $(dotnetVersion)'
  inputs:
    version: $(dotnetVersion)
    includePreviewVersions: false

- task: DotNetCoreCLI@2
  displayName: 'Restore NuGet packages'
  inputs:
    command: 'restore'
    projects: '**/*.csproj'

- task: DotNetCoreCLI@2
  displayName: 'Build solution'
  inputs:
    command: 'build'
    projects: '**/*.csproj'
    arguments: '--configuration $(buildConfiguration) --no-restore'

- task: DotNetCoreCLI@2
  displayName: 'Run unit tests'
  inputs:
    command: 'test'
    projects: '**/*Tests.csproj'
    arguments: '--configuration $(buildConfiguration) --no-build --collect:"XPlat Code Coverage"'

- task: DotNetCoreCLI@2
  displayName: 'Publish application'
  inputs:
    command: 'publish'
    publishWebProjects: true
    arguments: '--configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)'
    zipAfterPublish: true

- task: PublishBuildArtifacts@1
  displayName: 'Publish artifacts to Azure Pipelines'
  inputs:
    pathToPublish: '$(Build.ArtifactStagingDirectory)'
    artifactName: 'drop'
    publishLocation: 'Container'

5.2.10.1 Structure d’un fichier YAML

# Déclencheurs
trigger:                    # Quand le pipeline s'exécute
  - main

# Ressources externes
resources:                  # Repos, pipelines, containers
  repositories:
    - repository: templates
      type: git
      name: SharedTemplates

# Variables
variables:                  # Variables globales
  buildConfig: 'Release'
  
# Stages (optionnel pour pipelines simples)
stages:
- stage: Build
  displayName: 'Build Stage'
  
  # Jobs (tâches parallèles)
  jobs:
  - job: BuildJob
    displayName: 'Build Job'
    
    # Pool d'agents
    pool:
      vmImage: 'ubuntu-latest'
    
    # Variables de job
    variables:
      projectPath: 'src/ShopConnect.Web'
    
    # Steps (étapes séquentielles)
    steps:
    - checkout: self           # Clone le repo
      clean: true
    
    - script: echo "Building..."
      displayName: 'Build step'
    
    - task: TaskName@version
      inputs:
        inputName: value

5.2.11.1 Créer le pipeline YAML via l’interface

Azure DevOps → Pipelines → New Pipeline

┌────────────────────────────────────────────────┐
│ Where is your code?                            │
├────────────────────────────────────────────────┤
│                                                │
│ [Azure Repos Git]                              │
│ YAML pipeline as code                          │
│                                                │
│ [GitHub]                                       │
│ YAML pipeline with GitHub integration          │
│                                                │
│ [Bitbucket Cloud]                              │
│ YAML pipeline with Bitbucket integration       │
│                                                │
│ [Use the classic editor]                       │
│ Create a pipeline without YAML                 │
│                                                │
└────────────────────────────────────────────────┘

---

Sélectionner: Azure Repos Git

┌────────────────────────────────────────────────┐
│ Select a repository                            │
├────────────────────────────────────────────────┤
│                                                │
│ ● ShopConnect                                  │
│   Last updated 2 hours ago                     │
│                                                │
│   main                                         │
│                                                │
│ [Continue]                                     │
└────────────────────────────────────────────────┘

---

┌────────────────────────────────────────────────┐
│ Configure your pipeline                        │
├────────────────────────────────────────────────┤
│                                                │
│ [Starter pipeline]                             │
│ Start with a minimal pipeline                  │
│                                                │
│ [ASP.NET Core]                                 │
│ Build and test ASP.NET Core projects           │
│                                                │
│ [Node.js]                                      │
│ Build and test Node.js projects                │
│                                                │
│ [Existing Azure Pipelines YAML file]           │
│ Select an existing YAML file in your repo      │
│                                                │
└────────────────────────────────────────────────┘

---

Sélectionner: ASP.NET Core

→ Un fichier azure-pipelines.yml est généré
→ Vous pouvez le modifier dans l'éditeur web
→ [Save and run]

5.2.12 Variables dans les pipelines

5.2.12.1 Types de variables

# 1. Variables définies dans le YAML
variables:
  buildConfiguration: 'Release'
  dotnetVersion: '8.0.x'

# 2. Variables prédéfinies (par Azure DevOps)
# $(Build.BuildId)              - ID unique du build
# $(Build.BuildNumber)          - Numéro du build
# $(Build.SourceBranch)         - Branche source
# $(Build.SourceVersion)        - Commit SHA
# $(Build.ArtifactStagingDirectory) - Répertoire des artefacts
# $(Agent.BuildDirectory)       - Répertoire de travail

# 3. Variables de groupe (définies dans l'interface)
variables:
- group: 'Production-Variables'

# 4. Variables de stage/job
stages:
- stage: Build
  variables:
    stageName: 'Build Stage'
  jobs:
  - job: BuildJob
    variables:
      jobVar: 'Job Variable'

# 5. Variables runtime (set durant l'exécution)
- script: |
    echo "##vso[task.setvariable variable=myVar]myValue"
  displayName: 'Set variable'

- script: echo $(myVar)
  displayName: 'Use variable'

5.2.13.1 Utilisation des variables

variables:
  projectName: 'ShopConnect'
  version.major: 1
  version.minor: 0
  version.patch: $[counter(variables['version.minor'], 0)]

name: $(version.major).$(version.minor).$(version.patch)

steps:
- script: |
    echo "Building $(projectName)"
    echo "Version: $(Build.BuildNumber)"
    echo "Branch: $(Build.SourceBranchName)"
  displayName: 'Display build info'

5.3 Ajouter des tâches à un build

5.3.1 Tâches prédéfinies vs Scripts

# Tâches prédéfinies (recommandé)
- task: DotNetCoreCLI@2
  inputs:
    command: 'build'
    
# Scripts personnalisés
- script: dotnet build
  displayName: 'Build with script'

- bash: |
    echo "Multi-line"
    echo "bash script"
  displayName: 'Bash script'

- pwsh: |
    Write-Host "PowerShell script"
  displayName: 'PowerShell script'

5.3.2 Catalogue de tâches courantes

5.3.2.1 1. Checkout (Clone du code)

- checkout: self
  clean: true              # Nettoyer le workspace
  fetchDepth: 0            # Historique complet
  lfs: true               # Large File Support
  submodules: recursive   # Clone submodules
  persistCredentials: true # Garder les credentials

5.3.3.1 2. .NET Core / .NET

# Installer SDK .NET
- task: UseDotNet@2
  displayName: 'Use .NET Core SDK'
  inputs:
    version: '8.0.x'
    includePreviewVersions: false

# Restore
- task: DotNetCoreCLI@2
  displayName: 'Restore dependencies'
  inputs:
    command: 'restore'
    projects: '**/*.csproj'
    feedsToUse: 'select'
    vstsFeed: 'my-feed'  # Si Azure Artifacts

# Build
- task: DotNetCoreCLI@2
  displayName: 'Build solution'
  inputs:
    command: 'build'
    projects: '**/*.csproj'
    arguments: '--configuration $(buildConfiguration) --no-restore'

# Test
- task: DotNetCoreCLI@2
  displayName: 'Run tests'
  inputs:
    command: 'test'
    projects: '**/*Tests.csproj'
    arguments: '--configuration $(buildConfiguration) --no-build --collect:"XPlat Code Coverage"'
    publishTestResults: true

# Publish
- task: DotNetCoreCLI@2
  displayName: 'Publish application'
  inputs:
    command: 'publish'
    publishWebProjects: true
    arguments: '--configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)'
    zipAfterPublish: true
    modifyOutputPath: true

5.3.4.1 3. Node.js / npm

# Installer Node.js
- task: NodeTool@0
  displayName: 'Use Node.js'
  inputs:
    versionSpec: '20.x'

# npm install
- task: Npm@1
  displayName: 'npm install'
  inputs:
    command: 'install'
    workingDir: 'frontend'

# npm run build
- task: Npm@1
  displayName: 'npm build'
  inputs:
    command: 'custom'
    customCommand: 'run build'
    workingDir: 'frontend'

# npm test
- task: Npm@1
  displayName: 'npm test'
  inputs:
    command: 'custom'
    customCommand: 'run test:ci'
    workingDir: 'frontend'

5.3.5.1 4. Maven (Java)

# Installer JDK
- task: JavaToolInstaller@0
  displayName: 'Use Java 17'
  inputs:
    versionSpec: '17'
    jdkArchitectureOption: 'x64'
    jdkSourceOption: 'PreInstalled'

# Maven build
- task: Maven@3
  displayName: 'Maven build'
  inputs:
    mavenPomFile: 'pom.xml'
    goals: 'clean package'
    options: '-DskipTests=false'
    publishJUnitResults: true
    testResultsFiles: '**/surefire-reports/TEST-*.xml'
    javaHomeOption: 'JDKVersion'
    jdkVersionOption: '1.17'
    mavenVersionOption: 'Default'

5.3.6.1 5. Docker

# Build image
- task: Docker@2
  displayName: 'Build Docker image'
  inputs:
    command: 'build'
    repository: 'shopconnect/web'
    dockerfile: '$(Build.SourcesDirectory)/Dockerfile'
    tags: |
      $(Build.BuildId)
      latest

# Push image
- task: Docker@2
  displayName: 'Push Docker image'
  inputs:
    command: 'push'
    repository: 'shopconnect/web'
    containerRegistry: 'DockerHub'
    tags: |
      $(Build.BuildId)
      latest

5.3.7.1 6. Publier des artefacts

# Publier artefacts build
- task: PublishBuildArtifacts@1
  displayName: 'Publish build artifacts'
  inputs:
    pathToPublish: '$(Build.ArtifactStagingDirectory)'
    artifactName: 'drop'
    publishLocation: 'Container'

# Publier résultats de tests
- task: PublishTestResults@2
  displayName: 'Publish test results'
  inputs:
    testResultsFormat: 'VSTest'
    testResultsFiles: '**/*.trx'
    mergeTestResults: true
    failTaskOnFailedTests: true

# Publier couverture de code
- task: PublishCodeCoverageResults@1
  displayName: 'Publish code coverage'
  inputs:
    codeCoverageTool: 'Cobertura'
    summaryFileLocation: '$(Build.SourcesDirectory)/**/coverage.cobertura.xml'

5.3.8.1 7. Copier et archiver des fichiers

# Copier fichiers
- task: CopyFiles@2
  displayName: 'Copy files to staging'
  inputs:
    SourceFolder: '$(Build.SourcesDirectory)/dist'
    Contents: '**'
    TargetFolder: '$(Build.ArtifactStagingDirectory)'
    CleanTargetFolder: true

# Archiver fichiers
- task: ArchiveFiles@2
  displayName: 'Archive application'
  inputs:
    rootFolderOrFile: '$(Build.ArtifactStagingDirectory)'
    includeRootFolder: false
    archiveType: 'zip'
    archiveFile: '$(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip'
    replaceExistingArchive: true

5.3.9 Conditions et dépendances

steps:
# Toujours exécuter
- script: echo "Always run"
  displayName: 'Always step'
  condition: always()

# Uniquement si succès
- script: echo "Run on success"
  displayName: 'Success step'
  condition: succeeded()

# Uniquement si échec
- script: echo "Run on failure"
  displayName: 'Failure step'
  condition: failed()

# Condition personnalisée
- script: echo "Run on main branch"
  displayName: 'Conditional step'
  condition: eq(variables['Build.SourceBranch'], 'refs/heads/main')

# Condition complexe
- script: echo "Complex condition"
  condition: |
    and(
      succeeded(),
      eq(variables['Build.SourceBranch'], 'refs/heads/main'),
      eq(variables['buildConfiguration'], 'Release')
    )

5.3.10 Retry et timeout

steps:
- script: npm install
  displayName: 'npm install with retry'
  retryCountOnTaskFailure: 3  # Réessayer 3 fois en cas d'échec
  timeoutInMinutes: 10         # Timeout après 10 minutes

5.4 Compiler le projet

5.4.1 Compilation .NET

5.4.1.1 Pipeline complet .NET

# azure-pipelines-dotnet.yml

trigger:
  branches:
    include:
    - main
    - develop
    - feature/*

pool:
  vmImage: 'windows-latest'

variables:
  solution: '**/*.sln'
  buildPlatform: 'Any CPU'
  buildConfiguration: 'Release'
  dotnetVersion: '8.0.x'

stages:
- stage: Build
  displayName: 'Build and Test'
  jobs:
  - job: BuildJob
    displayName: 'Build Job'
    steps:
    
    # Checkout
    - checkout: self
      displayName: 'Checkout source code'
      clean: true
    
    # Install .NET SDK
    - task: UseDotNet@2
      displayName: 'Use .NET SDK $(dotnetVersion)'
      inputs:
        version: $(dotnetVersion)
        includePreviewVersions: false
    
    # Restore NuGet packages
    - task: NuGetToolInstaller@1
      displayName: 'Install NuGet'
    
    - task: NuGetCommand@2
      displayName: 'Restore NuGet packages'
      inputs:
        restoreSolution: '$(solution)'
        feedsToUse: 'select'
    
    # Build solution
    - task: VSBuild@1
      displayName: 'Build solution'
      inputs:
        solution: '$(solution)'
        platform: '$(buildPlatform)'
        configuration: '$(buildConfiguration)'
        msbuildArgs: '/p:DeployOnBuild=true /p:WebPublishMethod=Package /p:PackageAsSingleFile=true /p:SkipInvalidConfigurations=true /p:PackageLocation="$(Build.ArtifactStagingDirectory)"'
    
    # Run unit tests
    - task: VSTest@2
      displayName: 'Run unit tests'
      inputs:
        platform: '$(buildPlatform)'
        configuration: '$(buildConfiguration)'
        testSelector: 'testAssemblies'
        testAssemblyVer2: |
          **\*Tests.dll
          !**\*TestAdapter.dll
          !**\obj\**
        codeCoverageEnabled: true
        runInParallel: true
    
    # Publish test results
    - task: PublishTestResults@2
      displayName: 'Publish test results'
      condition: succeededOrFailed()
      inputs:
        testResultsFormat: 'VSTest'
        testResultsFiles: '**/*.trx'
        mergeTestResults: true
        failTaskOnFailedTests: true
    
    # Publish code coverage
    - task: PublishCodeCoverageResults@1
      displayName: 'Publish code coverage'
      condition: succeeded()
      inputs:
        codeCoverageTool: 'Cobertura'
        summaryFileLocation: '$(Agent.TempDirectory)/**/*coverage.cobertura.xml'
    
    # Publish build artifacts
    - task: PublishBuildArtifacts@1
      displayName: 'Publish artifacts'
      condition: succeeded()
      inputs:
        pathToPublish: '$(Build.ArtifactStagingDirectory)'
        artifactName: 'drop'
        publishLocation: 'Container'

5.4.2.1 Compilation avec MSBuild

- task: MSBuild@1
  displayName: 'Build with MSBuild'
  inputs:
    solution: '**/*.sln'
    platform: 'Any CPU'
    configuration: 'Release'
    msbuildArguments: |
      /p:OutputPath=$(Build.ArtifactStagingDirectory)
      /p:DebugSymbols=false
      /p:DebugType=None
      /p:TreatWarningsAsErrors=true
    clean: true

5.4.3 Compilation Node.js / React

# azure-pipelines-node.yml

trigger:
  branches:
    include:
    - main
  paths:
    include:
    - frontend/*

pool:
  vmImage: 'ubuntu-latest'

variables:
  nodeVersion: '20.x'
  workingDirectory: 'frontend'

stages:
- stage: Build
  displayName: 'Build Frontend'
  jobs:
  - job: BuildJob
    displayName: 'Build React App'
    steps:
    
    # Install Node.js
    - task: NodeTool@0
      displayName: 'Install Node.js $(nodeVersion)'
      inputs:
        versionSpec: $(nodeVersion)
    
    # Cache node_modules
    - task: Cache@2
      displayName: 'Cache node_modules'
      inputs:
        key: 'npm | "$(Agent.OS)" | $(workingDirectory)/package-lock.json'
        path: '$(workingDirectory)/node_modules'
        restoreKeys: |
          npm | "$(Agent.OS)"
    
    # npm install
    - script: npm ci
      displayName: 'npm ci (clean install)'
      workingDirectory: $(workingDirectory)
    
    # Linting
    - script: npm run lint
      displayName: 'Run ESLint'
      workingDirectory: $(workingDirectory)
      continueOnError: true
    
    # Unit tests
    - script: npm run test:ci
      displayName: 'Run Jest tests'
      workingDirectory: $(workingDirectory)
      env:
        CI: true
    
    # Build production
    - script: npm run build
      displayName: 'Build production bundle'
      workingDirectory: $(workingDirectory)
      env:
        NODE_ENV: production
        REACT_APP_API_URL: $(API_URL)
    
    # Analyze bundle size
    - script: npm run build:analyze
      displayName: 'Analyze bundle size'
      workingDirectory: $(workingDirectory)
      continueOnError: true
    
    # Publish test results
    - task: PublishTestResults@2
      displayName: 'Publish test results'
      condition: succeededOrFailed()
      inputs:
        testResultsFormat: 'JUnit'
        testResultsFiles: '$(workingDirectory)/junit.xml'
        mergeTestResults: true
    
    # Publish coverage
    - task: PublishCodeCoverageResults@1
      displayName: 'Publish code coverage'
      condition: succeeded()
      inputs:
        codeCoverageTool: 'Cobertura'
        summaryFileLocation: '$(workingDirectory)/coverage/cobertura-coverage.xml'
    
    # Archive build output
    - task: ArchiveFiles@2
      displayName: 'Archive build output'
      inputs:
        rootFolderOrFile: '$(workingDirectory)/build'
        includeRootFolder: false
        archiveType: 'zip'
        archiveFile: '$(Build.ArtifactStagingDirectory)/frontend-$(Build.BuildId).zip'
    
    # Publish artifacts
    - task: PublishBuildArtifacts@1
      displayName: 'Publish frontend artifacts'
      inputs:
        pathToPublish: '$(Build.ArtifactStagingDirectory)'
        artifactName: 'frontend'

5.4.4 Compilation Java / Maven

# azure-pipelines-java.yml

trigger:
  branches:
    include:
    - main

pool:
  vmImage: 'ubuntu-latest'

variables:
  jdkVersion: '17'
  mavenGoals: 'clean package'

stages:
- stage: Build
  displayName: 'Build Java Application'
  jobs:
  - job: BuildJob
    displayName: 'Maven Build'
    steps:
    
    # Install JDK
    - task: JavaToolInstaller@0
      displayName: 'Install JDK $(jdkVersion)'
      inputs:
        versionSpec: $(jdkVersion)
        jdkArchitectureOption: 'x64'
        jdkSourceOption: 'PreInstalled'
    
    # Cache Maven dependencies
    - task: Cache@2
      displayName: 'Cache Maven local repo'
      inputs:
        key: 'maven | "$(Agent.OS)" | **/pom.xml'
        restoreKeys: |
          maven | "$(Agent.OS)"
          maven
        path: $(HOME)/.m2/repository
    
    # Maven build
    - task: Maven@3
      displayName: 'Maven $(mavenGoals)'
      inputs:
        mavenPomFile: 'pom.xml'
        goals: $(mavenGoals)
        options: '-B -DskipTests=false'
        publishJUnitResults: true
        testResultsFiles: '**/surefire-reports/TEST-*.xml'
        codeCoverageToolOption: 'JaCoCo'
        javaHomeOption: 'JDKVersion'
        jdkVersionOption: $(jdkVersion)
        mavenVersionOption: 'Default'
        mavenOptions: '-Xmx3072m'
        mavenAuthenticateFeed: false
        effectivePomSkip: false
        sonarQubeRunAnalysis: false
    
    # Publish artifacts
    - task: CopyFiles@2
      displayName: 'Copy JAR files'
      inputs:
        SourceFolder: '$(System.DefaultWorkingDirectory)/target'
        Contents: '**/*.jar'
        TargetFolder: '$(Build.ArtifactStagingDirectory)'
    
    - task: PublishBuildArtifacts@1
      displayName: 'Publish artifacts'
      inputs:
        pathToPublish: '$(Build.ArtifactStagingDirectory)'
        artifactName: 'java-app'

5.4.5 Compilation multi-plateforme

# Compiler pour Windows, Linux et macOS

strategy:
  matrix:
    Linux:
      imageName: 'ubuntu-latest'
      rid: 'linux-x64'
    Windows:
      imageName: 'windows-latest'
      rid: 'win-x64'
    macOS:
      imageName: 'macos-latest'
      rid: 'osx-x64'

pool:
  vmImage: $(imageName)

steps:
- task: DotNetCoreCLI@2
  displayName: 'Build for $(rid)'
  inputs:
    command: 'publish'
    publishWebProjects: false
    projects: '**/*.csproj'
    arguments: '--configuration Release --runtime $(rid) --self-contained true --output $(Build.ArtifactStagingDirectory)/$(rid)'
    zipAfterPublish: true

- task: PublishBuildArtifacts@1
  inputs:
    pathToPublish: '$(Build.ArtifactStagingDirectory)/$(rid)'
    artifactName: 'app-$(rid)'

5.5 Lancer les tests unitaires

5.5.1 Intégration des tests dans le pipeline

stages:
- stage: Build
  jobs:
  - job: Build
    steps:
    - task: DotNetCoreCLI@2
      displayName: 'Build'
      inputs:
        command: 'build'

- stage: Test
  dependsOn: Build
  jobs:
  - job: UnitTests
    displayName: 'Unit Tests'
    steps:
    - task: DotNetCoreCLI@2
      displayName: 'Run unit tests'
      inputs:
        command: 'test'
        projects: '**/*Tests.csproj'
        arguments: '--configuration Release --no-build --collect:"XPlat Code Coverage" --logger trx'
        publishTestResults: true

5.5.2 Tests .NET avec couverture de code

steps:
# Run tests avec couverture
- task: DotNetCoreCLI@2
  displayName: 'Run unit tests with coverage'
  inputs:
    command: 'test'
    projects: '**/*Tests.csproj'
    arguments: >
      --configuration Release
      --no-build
      --collect:"XPlat Code Coverage"
      --results-directory $(Agent.TempDirectory)
      --logger trx
      --
      DataCollectionRunSettings.DataCollectors.DataCollector.Configuration.Format=cobertura
    publishTestResults: true

# Install ReportGenerator
- task: DotNetCoreCLI@2
  displayName: 'Install ReportGenerator'
  inputs:
    command: 'custom'
    custom: 'tool'
    arguments: 'install --global dotnet-reportgenerator-globaltool'

# Generate coverage report
- script: |
    reportgenerator \
      -reports:$(Agent.TempDirectory)/**/coverage.cobertura.xml \
      -targetdir:$(Build.SourcesDirectory)/CodeCoverage \
      -reporttypes:HtmlInline_AzurePipelines;Cobertura;Badges
  displayName: 'Generate coverage report'

# Publish coverage
- task: PublishCodeCoverageResults@1
  displayName: 'Publish code coverage'
  inputs:
    codeCoverageTool: 'Cobertura'
    summaryFileLocation: '$(Build.SourcesDirectory)/CodeCoverage/Cobertura.xml'
    reportDirectory: '$(Build.SourcesDirectory)/CodeCoverage'
    failIfCoverageEmpty: false

# Validate coverage threshold
- script: |
    COVERAGE=$(grep -oP 'line-rate="\K[^"]+' $(Build.SourcesDirectory)/CodeCoverage/Cobertura.xml | head -1)
    COVERAGE_PERCENT=$(echo "$COVERAGE * 100" | bc -l | cut -d. -f1)
    echo "Code coverage: $COVERAGE_PERCENT%"
    
    if [ $COVERAGE_PERCENT -lt 80 ]; then
      echo "##vso[task.logissue type=error]Code coverage ($COVERAGE_PERCENT%) is below threshold (80%)"
      exit 1
    fi
  displayName: 'Validate coverage threshold'

5.5.3 Tests JavaScript / Jest

steps:
# Run tests
- script: npm test -- --ci --coverage --maxWorkers=2
  displayName: 'Run Jest tests'
  workingDirectory: $(workingDirectory)
  env:
    CI: true

# Publish test results
- task: PublishTestResults@2
  displayName: 'Publish test results'
  condition: succeededOrFailed()
  inputs:
    testResultsFormat: 'JUnit'
    testResultsFiles: '**/junit.xml'
    mergeTestResults: true
    failTaskOnFailedTests: true
    testRunTitle: 'Jest Tests'

# Publish coverage
- task: PublishCodeCoverageResults@1
  displayName: 'Publish code coverage'
  condition: succeeded()
  inputs:
    codeCoverageTool: 'Cobertura'
    summaryFileLocation: '$(workingDirectory)/coverage/cobertura-coverage.xml'
    reportDirectory: '$(workingDirectory)/coverage'

# Coverage threshold
- script: |
    COVERAGE=$(cat coverage/coverage-summary.json | jq '.total.lines.pct')
    echo "Line coverage: $COVERAGE%"
    
    if (( $(echo "$COVERAGE < 80" | bc -l) )); then
      echo "##vso[task.logissue type=error]Coverage ($COVERAGE%) below 80%"
      exit 1
    fi
  displayName: 'Check coverage threshold'
  workingDirectory: $(workingDirectory)

5.5.4 Tests parallèles

strategy:
  parallel: 4  # Exécuter sur 4 agents en parallèle

steps:
- task: DotNetCoreCLI@2
  displayName: 'Run tests (parallel batch $(System.JobPositionInPhase))'
  inputs:
    command: 'test'
    projects: '**/*Tests.csproj'
    arguments: '--configuration Release --filter "TestCategory!=Integration"'

5.5.5 Tests d’intégration (séparés)

- job: IntegrationTests
  displayName: 'Integration Tests'
  dependsOn: UnitTests
  condition: succeeded()
  
  services:
    postgres:
      image: postgres:15
      ports:
      - 5432:5432
      env:
        POSTGRES_PASSWORD: testpassword
  
  steps:
  - task: DotNetCoreCLI@2
    displayName: 'Run integration tests'
    inputs:
      command: 'test'
      projects: '**/*IntegrationTests.csproj'
      arguments: '--configuration Release --filter "TestCategory=Integration"'
    env:
      ConnectionStrings__Default: 'Host=localhost;Database=testdb;Username=postgres;Password=testpassword'

5.6 Déclencher un build

5.6.1 Types de déclencheurs (Triggers)

5.6.1.1 1. CI Trigger (Push)

# Déclenchement sur push
trigger:
  branches:
    include:
    - main
    - develop
    - release/*
    exclude:
    - feature/experimental
  paths:
    include:
    - src/*
    - tests/*
    exclude:
    - docs/*
    - README.md
  tags:
    include:
    - v*

5.6.2.1 2. Pull Request Trigger

# Déclenchement sur PR
pr:
  branches:
    include:
    - main
    - develop
  paths:
    include:
    - src/*
    exclude:
    - docs/*
  drafts: false  # Ne pas déclencher sur draft PR

5.6.3.1 3. Scheduled Trigger (Nightly builds)

# Build nocturne à 2h du matin
schedules:
- cron: "0 2 * * *"
  displayName: Nightly build
  branches:
    include:
    - main
  always: true  # Même si pas de changements

Syntaxe cron :

* * * * *
│ │ │ │ │
│ │ │ │ └─── Jour de la semaine (0-6, 0=Dimanche)
│ │ │ └───── Mois (1-12)
│ │ └─────── Jour du mois (1-31)
│ └───────── Heure (0-23)
└─────────── Minute (0-59)

Exemples:
"0 2 * * *"      # Tous les jours à 2h
"0 2 * * 1-5"    # Du lundi au vendredi à 2h
"0 */6 * * *"    # Toutes les 6 heures
"*/15 * * * *"   # Toutes les 15 minutes

5.6.5.1 4. Manual Trigger

trigger: none  # Pas de déclenchement automatique
pr: none       # Pas de déclenchement sur PR

Pour déclencher manuellement :

Azure DevOps → Pipelines → [Pipeline] → Run pipeline

5.6.6.1 5. Pipeline Trigger (Dépendance entre pipelines)

# Pipeline A déclenche Pipeline B
resources:
  pipelines:
  - pipeline: upstream-build
    source: 'CI-Build'
    trigger:
      branches:
        include:
        - main

5.6.7 Configuration avancée des triggers

trigger:
  batch: true  # Grouper les commits pendant un build
  branches:
    include:
    - main
    - release/*
  paths:
    include:
    - src/*
    - azure-pipelines.yml
    exclude:
    - src/docs/*
    - '**/*.md'

pr:
  autoCancel: true  # Annuler les builds PR précédents
  branches:
    include:
    - main
  paths:
    exclude:
    - docs/*

schedules:
- cron: "0 3 * * 0"  # Dimanche à 3h
  displayName: Weekly full build
  branches:
    include:
    - main
  always: true

5.7 Automatisation des builds et des tests

5.7.1 Build complète automatisée

# azure-pipelines-complete.yml

name: $(Date:yyyyMMdd)$(Rev:.r)

trigger:
  batch: true
  branches:
    include:
    - main
    - develop

pr:
  autoCancel: true
  branches:
    include:
    - main
    - develop

schedules:
- cron: "0 2 * * *"
  displayName: Nightly build
  branches:
    include:
    - main
  always: true

variables:
  buildConfiguration: 'Release'
  dotnetVersion: '8.0.x'
  vmImage: 'ubuntu-latest'

stages:
- stage: Build
  displayName: 'Build Stage'
  jobs:
  - job: BuildJob
    displayName: 'Build and Unit Test'
    pool:
      vmImage: $(vmImage)
    
    steps:
    - checkout: self
      clean: true
      fetchDepth: 1
    
    # Restore and build
    - task: UseDotNet@2
      displayName: 'Use .NET $(dotnetVersion)'
      inputs:
        version: $(dotnetVersion)
    
    - task: DotNetCoreCLI@2
      displayName: 'Restore'
      inputs:
        command: 'restore'
    
    - task: DotNetCoreCLI@2
      displayName: 'Build'
      inputs:
        command: 'build'
        arguments: '--configuration $(buildConfiguration) --no-restore'
    
    # Unit tests
    - task: DotNetCoreCLI@2
      displayName: 'Unit Tests'
      inputs:
        command: 'test'
        projects: '**/*UnitTests.csproj'
        arguments: '--configuration $(buildConfiguration) --no-build --collect:"XPlat Code Coverage"'
        publishTestResults: true
    
    # Code coverage
    - task: PublishCodeCoverageResults@1
      displayName: 'Publish Coverage'
      inputs:
        codeCoverageTool: 'Cobertura'
        summaryFileLocation: '$(Agent.TempDirectory)/**/coverage.cobertura.xml'
    
    # Publish artifacts
    - task: DotNetCoreCLI@2
      displayName: 'Publish'
      inputs:
        command: 'publish'
        publishWebProjects: true
        arguments: '--configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)'
        zipAfterPublish: true
    
    - task: PublishBuildArtifacts@1
      displayName: 'Publish Artifacts'
      inputs:
        pathToPublish: '$(Build.ArtifactStagingDirectory)'
        artifactName: 'drop'

- stage: IntegrationTest
  displayName: 'Integration Test Stage'
  dependsOn: Build
  condition: succeeded()
  
  jobs:
  - job: IntegrationTestJob
    displayName: 'Integration Tests'
    pool:
      vmImage: $(vmImage)
    
    services:
      sqlserver:
        image: mcr.microsoft.com/mssql/server:2022-latest
        env:
          ACCEPT_EULA: Y
          SA_PASSWORD: YourStrong@Passw0rd
        ports:
        - 1433:1433
    
    steps:
    - task: DotNetCoreCLI@2
      displayName: 'Integration Tests'
      inputs:
        command: 'test'
        projects: '**/*IntegrationTests.csproj'
        arguments: '--configuration $(buildConfiguration)'
      env:
        ConnectionStrings__Default: 'Server=localhost;Database=TestDB;User Id=sa;Password=YourStrong@Passw0rd;'

- stage: QualityGate
  displayName: 'Quality Gate'
  dependsOn: 
  - Build
  - IntegrationTest
  condition: succeeded()
  
  jobs:
  - job: QualityChecks
    displayName: 'Quality Checks'
    pool:
      vmImage: $(vmImage)
    
    steps:
    - script: echo "Quality gate checks"
      displayName: 'Run quality checks'
    
    # Ici: SonarQube, security scans, etc.

5.7.2 Notifications automatiques

# Notifier sur Microsoft Teams
- task: PublishToAzureServiceBus@1
  displayName: 'Notify Teams'
  condition: always()
  inputs:
    azureSubscription: 'Azure-Connection'
    messageBody: |
      {
        "BuildNumber": "$(Build.BuildNumber)",
        "Status": "$(Agent.JobStatus)",
        "Repository": "$(Build.Repository.Name)",
        "Branch": "$(Build.SourceBranchName)"
      }

5.7.3 Matrice de builds

# Tester plusieurs versions/configurations
strategy:
  matrix:
    DotNet6_Debug:
      dotnetVersion: '6.0.x'
      buildConfiguration: 'Debug'
    DotNet6_Release:
      dotnetVersion: '6.0.x'
      buildConfiguration: 'Release'
    DotNet8_Debug:
      dotnetVersion: '8.0.x'
      buildConfiguration: 'Debug'
    DotNet8_Release:
      dotnetVersion: '8.0.x'
      buildConfiguration: 'Release'

pool:
  vmImage: 'ubuntu-latest'

steps:
- task: UseDotNet@2
  displayName: 'Use .NET $(dotnetVersion)'
  inputs:
    version: $(dotnetVersion)

- task: DotNetCoreCLI@2
  displayName: 'Build $(buildConfiguration)'
  inputs:
    command: 'build'
    arguments: '--configuration $(buildConfiguration)'

5.8 Travaux Pratiques

TP4 : Générer les builds et compiler le projet

5.9 Synthèse du Module 4

5.9.1 Points clés à retenir

✅ Build Pipelines

  • YAML recommandé (versionné, réutilisable)
  • Structure: trigger → pool → variables → stages → jobs → steps
  • Classic Editor pour débutants

✅ Compilation

  • Support multi-plateformes (.NET, Node.js, Java, Python)
  • Restauration de dépendances
  • Build incrémental pour performance
  • Compilation parallèle

✅ Tests unitaires

  • Intégration automatique dans le pipeline
  • Publication des résultats
  • Couverture de code
  • Seuils de qualité (thresholds)

✅ Déclencheurs

  • CI: push sur branches
  • PR: validation avant merge
  • Scheduled: nightly builds
  • Manual: déploiements contrôlés

✅ Artefacts - Résultat compilé et packagé - Stocké dans Azure Artifacts - Utilisé par les releases - Traçabilité complète

5.10 Ressources complémentaires

5.10.1 Documentation

5.10.2 Outils

5.11 Préparation pour le Module 5

Dans le prochain module, nous allons :

  • Créer des release pipelines
  • Définir des stages de déploiement
  • Configurer des environnements
  • Gérer les approbations manuelles
  • Automatiser les déploiements

6 Les release et leurs déploiements

6.1 Objectifs pédagogiques

À l’issue de ce module, vous serez capable de :

  • Comprendre la différence entre Build et Release pipelines
  • Créer des release pipelines multi-stages
  • Définir des environnements de déploiement
  • Configurer les tâches de déploiement
  • Gérer les approbations manuelles
  • Utiliser les groupes de tâches (task groups)
  • Déployer vers différentes cibles (Azure, IIS, Kubernetes)

6.2 Créer une nouvelle release

6.2.1 Build vs Release Pipeline

Aspect Build Pipeline Release Pipeline
Objectif Compiler et tester Déployer
Input Code source Artefacts de build
Output Artefacts Application déployée
Fréquence À chaque commit Sur demande ou automatique
Environnements Un seul (agent de build) Multiples (Dev, Test, Prod)
Rollback Non applicable Possible

6.2.3 Types de Release Pipelines

6.2.3.1 1. Classic Release Pipeline

┌────────────────────────────────────────────────────────┐
│              CLASSIC RELEASE PIPELINE                  │
├────────────────────────────────────────────────────────┤
│                                                        │
│  Artifacts                                             │
│  ├─ Build artifacts (primary)                          │
│  └─ Other sources (Git, Jenkins, etc.)                 │
│                                                        │
│  Stages                                                │
│  ├─ Dev Environment                                    │
│  │   ├─ Pre-deployment conditions                      │
│  │   ├─ Deployment tasks                               │
│  │   └─ Post-deployment conditions                     │
│  │                                                     │
│  ├─ Test Environment                                   │
│  │   ├─ Pre-deployment approvals                       │
│  │   ├─ Deployment tasks                               │
│  │   └─ Post-deployment approvals                      │
│  │                                                     │
│  └─ Production Environment                             │
│      ├─ Pre-deployment approvals (required)            │
│      ├─ Deployment tasks                               │
│      └─ Post-deployment approvals                      │
│                                                        │
│  Variables                                             │
│  ├─ Pipeline variables                                 │
│  ├─ Stage-specific variables                           │
│  └─ Variable groups                                    │
│                                                        │
└────────────────────────────────────────────────────────┘

6.2.4.1 2. YAML Multi-Stage Pipeline

# azure-pipelines-release.yml

trigger: none  # Déclenchement manuel

resources:
  pipelines:
  - pipeline: buildPipeline
    source: 'ShopConnect-CI'
    trigger:
      branches:
        include:
        - main

stages:
- stage: Dev
  displayName: 'Deploy to Dev'
  jobs:
  - deployment: DeployDev
    environment: 'Development'
    strategy:
      runOnce:
        deploy:
          steps:
          - script: echo "Deploying to Dev"

- stage: Test
  displayName: 'Deploy to Test'
  dependsOn: Dev
  condition: succeeded()
  jobs:
  - deployment: DeployTest
    environment: 'Test'
    strategy:
      runOnce:
        deploy:
          steps:
          - script: echo "Deploying to Test"

- stage: Prod
  displayName: 'Deploy to Production'
  dependsOn: Test
  condition: succeeded()
  jobs:
  - deployment: DeployProd
    environment: 'Production'
    strategy:
      runOnce:
        deploy:
          steps:
          - script: echo "Deploying to Production"

6.2.5 Créer un Classic Release Pipeline

6.2.5.1 Étape 1 : Créer une nouvelle release

Azure DevOps → Pipelines → Releases → New pipeline

┌────────────────────────────────────────────────┐
│ Select a template                              │
├────────────────────────────────────────────────┤
│                                                │
│ Featured templates:                            │
│                                                │
│ [Azure App Service deployment]                 │
│ Deploy to Azure App Service                    │
│                                                │
│ [IIS website deployment]                       │
│ Deploy to IIS web servers                      │
│                                                │
│ [Azure Kubernetes Service]                     │
│ Deploy to AKS cluster                          │
│                                                │
│ [Empty job]                                    │
│ Start with an empty stage                      │
│                                                │
│ [Apply]  [Close]                               │
└────────────────────────────────────────────────┘

Sélectionner: Empty job

6.2.6.1 Étape 2 : Ajouter un artefact

Add an artifact

┌────────────────────────────────────────────────┐
│ Add an artifact                                │
├────────────────────────────────────────────────┤
│                                                │
│ Source type:                                   │
│ ● Build                                        │
│   ○ Git                                        │
│   ○ GitHub                                     │
│   ○ TFVC                                       │
│   ○ Azure Repos                                │
│                                                │
│ Project: [ShopConnect] ▼                       │
│ Source (build pipeline): [ShopConnect-CI] ▼    │
│ Default version: [Latest] ▼                    │
│                                                │
│ Source alias: _ShopConnect-CI                  │
│                                                │
│ [Add]                                          │
└────────────────────────────────────────────────┘

Options de version par défaut :

  • Latest : Dernière build réussie
  • Latest from specific branch : Dernière build d’une branche
  • Specific version : Version spécifique
  • Latest from specific branch with tags : Avec tags Git

6.2.8.1 Étape 3 : Configurer le déclencheur

Artifacts → Continuous deployment trigger (éclair ⚡)

┌────────────────────────────────────────────────┐
│ Continuous deployment trigger                  │
├────────────────────────────────────────────────┤
│                                                │
│ ☑ Enabled                                      │
│                                                │
│ Build branch filters:                          │
│ ┌────────────────────────────────────────┐     │
│ │ Include                                │     │
│ │ ┌────────────────────────────────────┐ │     │
│ │ │ main                               │ │     │
│ │ └────────────────────────────────────┘ │     │
│ │ [+ Add]                                │     │
│ └────────────────────────────────────────┘     │
│                                                │
│ [Save]                                         │
└────────────────────────────────────────────────┘

6.2.9 Créer un environnement YAML Multi-Stage

6.2.9.1 Définir les environnements

Azure DevOps → Pipelines → Environments

1. [New environment]
   Name: Development
   Resource: None (for now)
   [Create]

2. [New environment]
   Name: Test
   Resource: None
   [Create]

3. [New environment]
   Name: Production
   Resource: None
   Approvals and checks: ☑ (configure after creation)
   [Create]

6.2.10.1 Pipeline multi-stage complet

# azure-pipelines-multistage.yml

trigger:
  branches:
    include:
    - main

variables:
  buildConfiguration: 'Release'
  azureSubscription: 'Azure-ServiceConnection'
  webAppName: 'shopconnect-app'

stages:
# Stage 1: Build
- stage: Build
  displayName: 'Build Stage'
  jobs:
  - job: BuildJob
    displayName: 'Build and Publish'
    pool:
      vmImage: 'ubuntu-latest'
    steps:
    - task: DotNetCoreCLI@2
      displayName: 'Restore'
      inputs:
        command: 'restore'
    
    - task: DotNetCoreCLI@2
      displayName: 'Build'
      inputs:
        command: 'build'
        arguments: '--configuration $(buildConfiguration)'
    
    - task: DotNetCoreCLI@2
      displayName: 'Publish'
      inputs:
        command: 'publish'
        publishWebProjects: true
        arguments: '--configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)'
        zipAfterPublish: true
    
    - task: PublishBuildArtifacts@1
      displayName: 'Publish Artifacts'
      inputs:
        pathToPublish: '$(Build.ArtifactStagingDirectory)'
        artifactName: 'drop'

# Stage 2: Deploy to Dev
- stage: DeployDev
  displayName: 'Deploy to Development'
  dependsOn: Build
  condition: succeeded()
  variables:
    environmentName: 'dev'
  jobs:
  - deployment: DeploymentJob
    displayName: 'Deploy to Dev'
    environment: 'Development'
    pool:
      vmImage: 'ubuntu-latest'
    strategy:
      runOnce:
        deploy:
          steps:
          - download: current
            artifact: drop
            displayName: 'Download Artifact'
          
          - task: AzureWebApp@1
            displayName: 'Deploy to Azure Web App'
            inputs:
              azureSubscription: '$(azureSubscription)'
              appName: '$(webAppName)-$(environmentName)'
              package: '$(Pipeline.Workspace)/drop/**/*.zip'

# Stage 3: Deploy to Test
- stage: DeployTest
  displayName: 'Deploy to Test'
  dependsOn: DeployDev
  condition: succeeded()
  variables:
    environmentName: 'test'
  jobs:
  - deployment: DeploymentJob
    displayName: 'Deploy to Test'
    environment: 'Test'
    pool:
      vmImage: 'ubuntu-latest'
    strategy:
      runOnce:
        deploy:
          steps:
          - download: current
            artifact: drop
          
          - task: AzureWebApp@1
            displayName: 'Deploy to Azure Web App'
            inputs:
              azureSubscription: '$(azureSubscription)'
              appName: '$(webAppName)-$(environmentName)'
              package: '$(Pipeline.Workspace)/drop/**/*.zip'
          
          - task: PowerShell@2
            displayName: 'Run Smoke Tests'
            inputs:
              targetType: 'inline'
              script: |
                $response = Invoke-WebRequest -Uri "https://$(webAppName)-$(environmentName).azurewebsites.net/health" -UseBasicParsing
                if ($response.StatusCode -ne 200) {
                  Write-Error "Health check failed!"
                  exit 1
                }
                Write-Host "Health check passed!"

# Stage 4: Deploy to Production
- stage: DeployProd
  displayName: 'Deploy to Production'
  dependsOn: DeployTest
  condition: succeeded()
  variables:
    environmentName: 'prod'
  jobs:
  - deployment: DeploymentJob
    displayName: 'Deploy to Production'
    environment: 'Production'
    pool:
      vmImage: 'ubuntu-latest'
    strategy:
      runOnce:
        deploy:
          steps:
          - download: current
            artifact: drop
          
          - task: AzureWebApp@1
            displayName: 'Deploy to Azure Web App'
            inputs:
              azureSubscription: '$(azureSubscription)'
              appName: '$(webAppName)-$(environmentName)'
              package: '$(Pipeline.Workspace)/drop/**/*.zip'
              deploymentMethod: 'zipDeploy'

6.3 Définir les tâches d’une release

6.3.1 Types de tâches de déploiement

6.3.1.1 1. Azure App Service

- task: AzureWebApp@1
  displayName: 'Deploy Azure Web App'
  inputs:
    azureSubscription: 'Azure-Connection'
    appType: 'webApp'
    appName: 'shopconnect-webapp'
    package: '$(Pipeline.Workspace)/drop/**/*.zip'
    deploymentMethod: 'zipDeploy'
    appSettings: |
      -ASPNETCORE_ENVIRONMENT Production
      -ConnectionStrings:DefaultConnection "$(ConnectionString)"

6.3.2.1 2. IIS Web Deploy

- task: IISWebAppDeploymentOnMachineGroup@0
  displayName: 'Deploy to IIS'
  inputs:
    WebSiteName: 'ShopConnect'
    Package: '$(Pipeline.Workspace)/drop/**/*.zip'
    RemoveAdditionalFilesFlag: true
    TakeAppOfflineFlag: true
    XmlTransformation: true
    XmlVariableSubstitution: true

6.3.3.1 3. Azure SQL Database

- task: SqlAzureDacpacDeployment@1
  displayName: 'Deploy SQL Database'
  inputs:
    azureSubscription: 'Azure-Connection'
    authenticationType: 'servicePrincipal'
    serverName: 'shopconnect-sqlserver.database.windows.net'
    databaseName: 'ShopConnectDB'
    sqlUsername: '$(SqlUsername)'
    sqlPassword: '$(SqlPassword)'
    deployType: 'DacpacTask'
    deploymentAction: 'Publish'
    dacpacFile: '$(Pipeline.Workspace)/drop/Database.dacpac'

6.3.4.1 4. Kubernetes (AKS)

- task: KubernetesManifest@0
  displayName: 'Deploy to Kubernetes'
  inputs:
    action: 'deploy'
    kubernetesServiceConnection: 'AKS-Connection'
    namespace: 'production'
    manifests: |
      $(Pipeline.Workspace)/manifests/deployment.yml
      $(Pipeline.Workspace)/manifests/service.yml
    containers: |
      myregistry.azurecr.io/shopconnect:$(Build.BuildId)

6.3.5.1 5. Azure Functions

- task: AzureFunctionApp@1
  displayName: 'Deploy Azure Function'
  inputs:
    azureSubscription: 'Azure-Connection'
    appType: 'functionApp'
    appName: 'shopconnect-functions'
    package: '$(Pipeline.Workspace)/drop/functions.zip'
    deploymentMethod: 'zipDeploy'

6.3.6.1 6. Azure Storage (Static Website)

- task: AzureCLI@2
  displayName: 'Deploy to Azure Storage'
  inputs:
    azureSubscription: 'Azure-Connection'
    scriptType: 'bash'
    scriptLocation: 'inlineScript'
    inlineScript: |
      az storage blob upload-batch \
        --account-name shopconnectstorage \
        --destination '$web' \
        --source $(Pipeline.Workspace)/drop/wwwroot \
        --overwrite

6.3.7 Tâches de pré et post-déploiement

6.3.7.1 Tâches communes de pré-déploiement

# 1. Backup de la base de données
- task: SqlAzureDacpacDeployment@1
  displayName: 'Backup Database'
  inputs:
    azureSubscription: 'Azure-Connection'
    serverName: 'shopconnect-sqlserver.database.windows.net'
    databaseName: 'ShopConnectDB'
    sqlUsername: '$(SqlUsername)'
    sqlPassword: '$(SqlPassword)'
    deployType: 'SqlTask'
    sqlFile: 'scripts/backup.sql'

# 2. Stop Application
- task: AzureAppServiceManage@0
  displayName: 'Stop App Service'
  inputs:
    azureSubscription: 'Azure-Connection'
    action: 'Stop Azure App Service'
    webAppName: 'shopconnect-webapp'

# 3. Vérifier l'espace disque
- task: PowerShell@2
  displayName: 'Check Disk Space'
  inputs:
    targetType: 'inline'
    script: |
      $drive = Get-PSDrive C
      $freeSpaceGB = [math]::Round($drive.Free / 1GB, 2)
      Write-Host "Free space: $freeSpaceGB GB"
      if ($freeSpaceGB -lt 5) {
        Write-Error "Insufficient disk space!"
        exit 1
      }

6.3.8.1 Tâches communes de post-déploiement

# 1. Smoke Tests
- task: PowerShell@2
  displayName: 'Run Smoke Tests'
  inputs:
    targetType: 'inline'
    script: |
      $endpoints = @(
        "https://shopconnect-webapp.azurewebsites.net/health",
        "https://shopconnect-webapp.azurewebsites.net/api/products"
      )
      
      foreach ($endpoint in $endpoints) {
        try {
          $response = Invoke-WebRequest -Uri $endpoint -UseBasicParsing -TimeoutSec 30
          if ($response.StatusCode -eq 200) {
            Write-Host "✓ $endpoint - OK"
          } else {
            Write-Error "✗ $endpoint - Failed (Status: $($response.StatusCode))"
            exit 1
          }
        } catch {
          Write-Error "✗ $endpoint - Error: $_"
          exit 1
        }
      }
      Write-Host "All smoke tests passed!"

# 2. Start Application
- task: AzureAppServiceManage@0
  displayName: 'Start App Service'
  inputs:
    azureSubscription: 'Azure-Connection'
    action: 'Start Azure App Service'
    webAppName: 'shopconnect-webapp'

# 3. Warm-up
- task: PowerShell@2
  displayName: 'Warm-up Application'
  inputs:
    targetType: 'inline'
    script: |
      $urls = @(
        "https://shopconnect-webapp.azurewebsites.net",
        "https://shopconnect-webapp.azurewebsites.net/api/products"
      )
      
      foreach ($url in $urls) {
        Write-Host "Warming up: $url"
        Invoke-WebRequest -Uri $url -UseBasicParsing | Out-Null
        Start-Sleep -Seconds 2
      }
      Write-Host "Warm-up completed!"

# 4. Notifications
- task: PowerShell@2
  displayName: 'Send Deployment Notification'
  inputs:
    targetType: 'inline'
    script: |
      $message = @{
        text = "✅ Deployment to Production completed successfully`nBuild: $(Build.BuildNumber)`nRelease: $(Release.ReleaseName)"
      }
      
      $json = $message | ConvertTo-Json
      Invoke-RestMethod -Uri "$(SlackWebhookUrl)" -Method Post -Body $json -ContentType 'application/json'

6.3.9 Configuration des variables

6.3.9.1 Variables de pipeline

variables:
  # Variables globales
  buildConfiguration: 'Release'
  azureSubscription: 'Azure-ServiceConnection'
  
  # Variables par stage
- ${{ if eq(variables['Build.SourceBranchName'], 'main') }}:
  - name: environmentName
    value: 'prod'
  - name: webAppName
    value: 'shopconnect-webapp'
- ${{ if eq(variables['Build.SourceBranchName'], 'develop') }}:
  - name: environmentName
    value: 'dev'
  - name: webAppName
    value: 'shopconnect-webapp-dev'

6.3.10.1 Variables de groupe

Pipelines → Library → + Variable group

Name: ShopConnect-Production

Variables:
┌──────────────────────────┬─────────────────────────┬────────┐
│ Name                     │ Value                   │ Secret │
├──────────────────────────┼─────────────────────────┼────────┤
│ SqlConnectionString      │ Server=...;Database=... │   🔒   │
│ ApiKey                   │ *********************   │   🔒   │
│ AppInsightsKey           │ *********************   │   🔒   │
│ WebAppName               │ shopconnect-webapp      │        │
│ ResourceGroup            │ shopconnect-rg          │        │
└──────────────────────────┴─────────────────────────┴────────┘

Link to Azure Key Vault: ☑
Azure subscription: [Azure-Connection] ▼
Key vault name: [shopconnect-keyvault] ▼

6.3.11.1 Utilisation dans le pipeline

variables:
- group: ShopConnect-Production

stages:
- stage: DeployProd
  jobs:
  - deployment: Deploy
    environment: Production
    strategy:
      runOnce:
        deploy:
          steps:
          - task: AzureWebApp@1
            inputs:
              azureSubscription: 'Azure-Connection'
              appName: '$(WebAppName)'
              appSettings: |
                -ConnectionStrings:Default "$(SqlConnectionString)"
                -ApplicationInsights:InstrumentationKey "$(AppInsightsKey)"

6.4 Prévoir une intervention manuelle lors d’un déploiement

6.4.1 Approbations manuelles

6.4.1.1 Configuration dans Classic Release

Stage → Pre-deployment conditions

┌────────────────────────────────────────────────┐
│ Pre-deployment approvals                       │
├────────────────────────────────────────────────┤
│                                                │
│ ☑ Enabled                                      │
│                                                │
│ Approvers:                                     │
│ ┌────────────────────────────────────────┐     │
│ │ [+] Alice (Product Owner)              │     │
│ │ [+] Bob (Tech Lead)                    │     │
│ └────────────────────────────────────────┘     │
│                                                │
│ Approval policy:                               │
│ ● Any one user                                 │
│ ○ All users must approve                       │
│ ○ First responder                              │
│                                                │
│ Timeout: [7] days                              │
│                                                │
│ ☑ Approver can approve their own runs          │
│                                                │
│ Instructions for approver:                     │
│ ┌────────────────────────────────────────┐     │
│ │ Please verify:                         │     │
│ │ - All tests passed                     │     │
│ │ - Change log reviewed                  │     │
│ │ - Stakeholders notified                │     │
│ └────────────────────────────────────────┘     │
│                                                │
│ [Save]                                         │
└────────────────────────────────────────────────┘

6.4.2.1 Configuration dans YAML (Environments)

Azure DevOps → Pipelines → Environments → Production → [...] → Approvals and checks

Add check:
1. [Approvals]
   
   ┌────────────────────────────────────────┐
   │ Approvals                              │
   ├────────────────────────────────────────┤
   │                                        │
   │ Approvers: *                           │
   │ [Alice, Bob, Charlie]                  │
   │                                        │
   │ Minimum number of approvers: [1] ▼     │
   │                                        │
   │ ☑ Allow approvers to approve their     │
   │   own runs                             │
   │                                        │
   │ Timeout: [30] days                     │
   │                                        │
   │ Instructions:                          │
   │ Please review deployment details       │
   │ before approving.                      │
   │                                        │
   │ [Create]                               │
   └────────────────────────────────────────┘

Le pipeline YAML reste simple :

- stage: DeployProd
  displayName: 'Deploy to Production'
  jobs:
  - deployment: DeploymentJob
    environment: 'Production'  # Les approbations sont configurées sur l'environnement
    strategy:
      runOnce:
        deploy:
          steps:
          - script: echo "Deploying to production"

6.4.4 Gates (Portes automatiques)

Les gates sont des vérifications automatiques avant ou après le déploiement.

6.4.4.1 Types de gates

1. Invoke Azure Function
   → Appeler une fonction pour validation
   
2. Query Azure Monitor alerts
   → Vérifier qu'il n'y a pas d'alertes actives
   
3. Invoke REST API
   → Appeler une API pour validation
   
4. Query Work Items
   → Vérifier qu'il n'y a pas de bugs bloquants

6.4.5.1 Configuration d’une gate

Stage → Pre-deployment conditions → Gates

┌────────────────────────────────────────────────┐
│ Gates                                          │
├────────────────────────────────────────────────┤
│                                                │
│ ☑ Enabled                                      │
│                                                │
│ Delay before evaluation: [5] minutes           │
│                                                │
│ Evaluation options:                            │
│ • Time between re-evaluation: [5] minutes      │
│ • Timeout after: [1] days                      │
│ • Sampling interval: [15] minutes              │
│                                                │
│ [+ Add gate]                                   │
│                                                │
│ Gate 1: Query Azure Monitor alerts             │
│ ┌─────────────────────────────────────────┐    │
│ │ Azure subscription: Azure-Connection    │    │
│ │ Resource group: shopconnect-rg          │    │
│ │ Resource type: App Service              │    │
│ │ Resource name: shopconnect-webapp       │    │
│ │ Alert state: Active                     │    │
│ │                                         │    │
│ │ Success criteria:                       │    │
│ │ eq(root['count'], 0)                    │    │
│ └─────────────────────────────────────────┘    │
│                                                │
│ Gate 2: Query Work Items                       │
│ ┌─────────────────────────────────────────┐    │
│ │ Query: Blocking Bugs                    │    │
│ │                                         │    │
│ │ Success criteria:                       │    │
│ │ eq(root['count'], 0)                    │    │
│ └─────────────────────────────────────────┘    │
│                                                │
│ [Save]                                         │
└────────────────────────────────────────────────┘

6.4.6.1 Gate avec Azure Function

// Azure Function pour gate personnalisée
[FunctionName("DeploymentGate")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req,
    ILogger log)
{
    // Vérifications personnalisées
    var allTestsPassed = await CheckTestResults();
    var noActiveIncidents = await CheckServiceHealth();
    var changeApproved = await CheckChangeManagement();
    
    if (allTestsPassed && noActiveIncidents && changeApproved)
    {
        return new OkObjectResult(new { 
            status = "success",
            message = "All gates passed"
        });
    }
    
    return new BadRequestObjectResult(new { 
        status = "failed",
        message = "Gate validation failed"
    });
}

Configuration dans la release :

Gate: Invoke Azure Function
Function URL: https://shopconnect-gates.azurewebsites.net/api/DeploymentGate
Function key: $(AzureFunctionKey)
Method: POST
Success criteria: eq(root['status'], 'success')

6.4.8 Manual Intervention Task

Permet une intervention manuelle pendant le déploiement.

- task: ManualIntervention@8
  displayName: 'Manual validation required'
  inputs:
    instructions: |
      Please validate the following before resuming:
      
      1. Check application health dashboard
      2. Verify database migration completed
      3. Test key user journeys manually
      4. Confirm with business stakeholders
      
      Environment: Production
      Build: $(Build.BuildNumber)
      Release: $(Release.ReleaseName)
    
    emailRecipients: 'alice@contoso.com;bob@contoso.com'
    onTimeout: 'reject'

Lors de l’exécution :

┌────────────────────────────────────────────────┐
│ Manual Intervention                            │
├────────────────────────────────────────────────┤
│                                                │
│ Instructions:                                  │
│ Please validate the following before resuming: │
│                                                │
│ 1. Check application health dashboard          │
│ 2. Verify database migration completed         │
│ 3. Test key user journeys manually             │
│ 4. Confirm with business stakeholders          │
│                                                │
│ Environment: Production                        │
│ Build: 20240525.1                              │
│                                                │
│ Comments: (optional)                           │
│ ┌────────────────────────────────────────┐     │
│ │ All checks completed successfully      │     │
│ └────────────────────────────────────────┘     │
│                                                │
│ [Resume]  [Reject]                             │
└────────────────────────────────────────────────┘

6.5 Les groupes de tâches

6.5.1 Qu’est-ce qu’un Task Group ?

Un task group est un ensemble réutilisable de tâches de pipeline.

Avantages :

  • ✅ Réutilisation dans plusieurs pipelines
  • ✅ Maintenance centralisée
  • ✅ Cohérence entre les déploiements
  • ✅ Paramètres configurables

6.5.2 Créer un Task Group

6.5.2.1 Depuis un pipeline existant

1. Dans un pipeline, sélectionner plusieurs tâches
2. Clic droit → Create task group
3. Configurer:

┌────────────────────────────────────────────────┐
│ Create task group                              │
├────────────────────────────────────────────────┤
│                                                │
│ Name: *                                        │
│ Deploy Azure Web App                           │
│                                                │
│ Description:                                   │
│ Standard deployment to Azure App Service       │
│ with pre and post checks                       │
│                                                │
│ Category: [Deploy] ▼                           │
│                                                │
│ Parameters:                                    │
│ ┌─────────────────────────────────────────┐    │
│ │ + webAppName (string, required)         │    │
│ │ + azureSubscription (string, required)  │    │
│ │ + packagePath (string, required)        │    │
│ └─────────────────────────────────────────┘    │
│                                                │
│ [Create]                                       │
└────────────────────────────────────────────────┘

6.5.3.1 Exemple de Task Group

Contenu du Task Group “Deploy Azure Web App” :

Tasks:
1. Download Artifact
2. Azure App Service: Stop
3. Azure Web App Deploy
4. Azure App Service: Start
5. Health Check (PowerShell)

Paramètres :

  • $(webAppName) - Nom de l’App Service
  • $(azureSubscription) - Service connection Azure
  • $(packagePath) - Chemin vers le package
  • $(healthCheckUrl) - URL de health check

6.5.4 Utiliser un Task Group

# Classic Release Pipeline
# Le task group apparaît dans la liste des tâches

Stage: Production
  Agent job:
    - Task Group: Deploy Azure Web App
      webAppName: shopconnect-webapp-prod
      azureSubscription: Azure-Connection
      packagePath: $(System.DefaultWorkingDirectory)/_ShopConnect-CI/drop/*.zip
      healthCheckUrl: https://shopconnect-webapp-prod.azurewebsites.net/health

6.5.5 Versionner les Task Groups

Pipelines → Task groups → Deploy Azure Web App → [...]

┌────────────────────────────────────────────────┐
│ Version history                                │
├────────────────────────────────────────────────┤
│                                                │
│ Version 3.0 (Latest)                           │
│ Modified: 2024-05-20 by Alice                  │
│ • Added warm-up step                           │
│ • Improved error handling                      │
│                                                │
│ Version 2.0                                    │
│ Modified: 2024-04-15 by Bob                    │
│ • Added health check                           │
│                                                │
│ Version 1.0                                    │
│ Created: 2024-03-01 by Charlie                 │
│ • Initial version                              │
│                                                │
│ [+ New version]                                │
└────────────────────────────────────────────────┘

Dans les pipelines :

Task Group version: [Latest] ▼
                    [3.0]
                    [2.0]
                    [1.0]

6.5.7 Task Group vs YAML Templates

Aspect Task Group YAML Template
Portée Classic pipelines uniquement YAML pipelines uniquement
Versioning Via l’interface Via Git
Paramétrisation Interface graphique Code YAML
Réutilisation Entre pipelines du même projet Tous les projets (si repo partagé)

YAML Template équivalent :

# templates/deploy-webapp.yml

parameters:
- name: webAppName
  type: string
- name: azureSubscription
  type: string
- name: packagePath
  type: string

steps:
- download: current
  artifact: drop
  displayName: 'Download Artifact'

- task: AzureAppServiceManage@0
  displayName: 'Stop App Service'
  inputs:
    azureSubscription: '${{ parameters.azureSubscription }}'
    action: 'Stop Azure App Service'
    webAppName: '${{ parameters.webAppName }}'

- task: AzureWebApp@1
  displayName: 'Deploy to Azure Web App'
  inputs:
    azureSubscription: '${{ parameters.azureSubscription }}'
    appName: '${{ parameters.webAppName }}'
    package: '${{ parameters.packagePath }}'

- task: AzureAppServiceManage@0
  displayName: 'Start App Service'
  inputs:
    azureSubscription: '${{ parameters.azureSubscription }}'
    action: 'Start Azure App Service'
    webAppName: '${{ parameters.webAppName }}'

- task: PowerShell@2
  displayName: 'Health Check'
  inputs:
    targetType: 'inline'
    script: |
      $url = "https://${{ parameters.webAppName }}.azurewebsites.net/health"
      $response = Invoke-WebRequest -Uri $url -UseBasicParsing
      if ($response.StatusCode -ne 200) {
        Write-Error "Health check failed!"
        exit 1
      }
      Write-Host "Health check passed!"

Utilisation :

# azure-pipelines.yml

stages:
- stage: Deploy
  jobs:
  - deployment: DeployProd
    environment: Production
    strategy:
      runOnce:
        deploy:
          steps:
          - template: templates/deploy-webapp.yml
            parameters:
              webAppName: 'shopconnect-webapp'
              azureSubscription: 'Azure-Connection'
              packagePath: '$(Pipeline.Workspace)/drop/**/*.zip'

6.6 Stratégies de déploiement

6.6.1 1. Blue-Green Deployment

Deux environnements identiques : Blue (actuel) et Green (nouveau).

Après validation → Switch :

Load Balancer → Green: 100% → Blue: 0%

Implémentation Azure :

- task: AzureAppServiceManage@0
  displayName: 'Swap slots (Blue-Green)'
  inputs:
    azureSubscription: 'Azure-Connection'
    action: 'Swap Slots'
    webAppName: 'shopconnect-webapp'
    sourceSlot: 'staging'  # Green
    targetSlot: 'production'  # Blue

6.6.3 2. Canary Deployment

Déploiement progressif sur un sous-ensemble d’utilisateurs.

Phase 1: 5% des utilisateurs  → v2.0
Phase 2: 25% des utilisateurs → v2.0
Phase 3: 50% des utilisateurs → v2.0
Phase 4: 100% des utilisateurs → v2.0

Implémentation avec Traffic Manager :

# Phase 1: Canary 5%
- task: AzureCLI@2
  displayName: 'Route 5% to Canary'
  inputs:
    azureSubscription: 'Azure-Connection'
    scriptType: 'bash'
    scriptLocation: 'inlineScript'
    inlineScript: |
      az network traffic-manager endpoint update \
        --name canary-endpoint \
        --profile-name shopconnect-tm \
        --resource-group shopconnect-rg \
        --type azureEndpoints \
        --weight 5

# Attendre et monitorer
- task: Delay@1
  inputs:
    delayForMinutes: '15'

# Vérifier les métriques
- task: PowerShell@2
  displayName: 'Check Canary Metrics'
  inputs:
    targetType: 'inline'
    script: |
      # Vérifier taux d'erreur
      $errorRate = Get-ErrorRate -Environment "Canary"
      if ($errorRate -gt 0.01) {
        Write-Error "Error rate too high: $errorRate"
        exit 1
      }

# Phase 2: 25%
- task: AzureCLI@2
  displayName: 'Route 25% to Canary'
  inputs:
    scriptLocation: 'inlineScript'
    inlineScript: |
      az network traffic-manager endpoint update \
        --name canary-endpoint \
        --weight 25 \
        # ...

6.6.5 3. Rolling Deployment

Déploiement progressif instance par instance.

strategy:
  rolling:
    maxParallel: 2  # Déployer sur 2 instances à la fois
    preDeploy:
      steps:
      - script: echo "Pre-deployment"
    deploy:
      steps:
      - task: AzureWebApp@1
        inputs:
          appName: 'shopconnect-webapp'
          package: '$(Pipeline.Workspace)/drop/**/*.zip'
    routeTraffic:
      steps:
      - script: echo "Route traffic to new version"
    postRouteTraffic:
      steps:
      - task: PowerShell@2
        inputs:
          script: |
            # Health check
            Invoke-WebRequest -Uri "https://shopconnect-webapp.azurewebsites.net/health"
    on:
      failure:
        steps:
        - script: echo "Rolling back..."
      success:
        steps:
        - script: echo "Deployment successful"

6.6.6 4. Runonce (Déploiement standard)

Déploiement classique sans stratégie avancée.

strategy:
  runOnce:
    preDeploy:
      steps:
      - script: echo "Pre-deployment tasks"
    deploy:
      steps:
      - task: AzureWebApp@1
        inputs:
          appName: 'shopconnect-webapp'
          package: '$(Pipeline.Workspace)/drop/**/*.zip'
    routeTraffic:
      steps:
      - script: echo "Traffic routed"
    postRouteTraffic:
      steps:
      - script: echo "Post-deployment validation"
    on:
      failure:
        steps:
        - task: PowerShell@2
          inputs:
            script: |
              # Rollback
              Write-Host "Deploying previous version..."
      success:
        steps:
        - script: echo "Deployment completed successfully"

6.7 Travaux Pratiques

TP5 : Mettre en place un déploiement multi-environnements

6.8 Synthèse du Module 5

6.8.1 Points clés à retenir

✅ Release Pipelines

  • Transformation d’artefacts en applications déployées
  • Multi-stages pour différents environnements
  • YAML recommandé pour versioning avec le code

✅ Environnements

  • Séparation Dev / Test / Prod
  • Approbations et checks
  • Historique de déploiement

✅ Tâches de déploiement

  • Azure App Service, IIS, Kubernetes
  • Pre/Post deployment tasks
  • Smoke tests et health checks

✅ Approbations manuelles

  • Gates automatiques (Azure Monitor, API)
  • Approbations humaines
  • Manual intervention

✅ Task Groups

  • Réutilisation de tâches
  • Maintenance centralisée
  • Versioning

✅ Stratégies de déploiement

  • Blue-Green : Switch instantané
  • Canary : Déploiement progressif
  • Rolling : Instance par instance
  • RunOnce : Standard

6.9 Ressources complémentaires

6.9.1 Documentation

6.9.2 Outils

6.10 Préparation pour le Module 6

Dans le prochain module, nous allons :

  • Approfondir les approbations de déploiement
  • Automatiser les déploiements conditionnels
  • Configurer des déclencheurs avancés
  • Gérer les rollbacks
  • Implémenter des quality gates

7 Validation et déclenchement des déploiements

7.1 Objectifs pédagogiques

À l’issue de ce module, vous serez capable de :

  • Configurer des approbations granulaires par environnement
  • Automatiser entièrement les déploiements
  • Implémenter des déploiements conditionnels
  • Configurer des quality gates automatiques
  • Gérer les rollbacks
  • Mettre en place des notifications de déploiement

7.2 Approuver un déploiement

7.2.1 Workflow d’approbation complet

7.2.2 Configuration avancée des approbations

7.2.2.1 1. Approbations multi-niveaux

┌──────────────────────────────────────────────────────────┐
│ Approvals and Checks - Production                        │
├──────────────────────────────────────────────────────────┤
│                                                          │
│ Level 1 - Technical Approval                             │
│ ┌───────────────────────────────────────────────────┐    │
│ │ Approvers: Tech Lead, Senior Developer            │    │
│ │ Minimum: 1 of 2                                   │    │
│ │ Instructions: "Verify build quality and tests"    │    │
│ │ Timeout: 24 hours                                 │    │
│ └───────────────────────────────────────────────────┘    │
│                                                          │
│ Level 2 - Business Approval                              │
│ ┌───────────────────────────────────────────────────┐    │
│ │ Approvers: Product Owner                          │    │
│ │ Minimum: 1 of 1                                   │    │
│ │ Instructions: "Verify business requirements"      │    │
│ │ Timeout: 48 hours                                 │    │
│ └───────────────────────────────────────────────────┘    │
│                                                          │
└──────────────────────────────────────────────────────────┘

Configuration YAML :

# azure-pipelines.yml
stages:
- stage: DeployProd
  displayName: 'Deploy to Production'
  jobs:
  - deployment: DeployProdJob
    environment: 'Production'  # Checks définis sur l'environnement
    strategy:
      runOnce:
        deploy:
          steps:
          - script: echo "Deploying to Production"

Configuration de l’environnement (via UI) :

Pipelines → Environments → Production → Approvals and checks

Ajouter dans cet ordre:
1. Approvals (Tech Lead)
   → Doit être approuvé en premier

2. Approvals (Product Owner)
   → Doit être approuvé en second

3. Business Hours
   → Déploiements uniquement entre 9h et 17h

4. Required template
   → Forcer l'utilisation d'un template spécifique

7.2.5.1 2. Checks d’environnement (YAML)

# Ces checks sont configurés via l'interface Azure DevOps
# sur chaque environnement, pas dans le YAML

# L'environnement "Production" aura ces checks:
# - Approvals: Tech Lead (requis)
# - Approvals: Product Owner (requis)
# - Branch control: main uniquement
# - Business hours: 9h-17h, Lu-Ve
# - Required template: /templates/production-deploy.yml

7.2.6.1 3. Branch Control Check

Environment: Production → Approvals and checks → Branch control

┌────────────────────────────────────────────────┐
│ Branch control                                 │
├────────────────────────────────────────────────┤
│                                                │
│ Allowed branches: *                            │
│ ┌─────────────────────────────────────────┐    │
│ │ refs/heads/main                         │    │
│ │ refs/heads/release/*                    │    │
│ └─────────────────────────────────────────┘    │
│                                                │
│ ☑ Verify branch protection                     │
│                                                │
│ [Save]                                         │
└────────────────────────────────────────────────┘

Effet : Seuls les déploiements depuis main ou release/* sont autorisés en production.

7.2.7.1 4. Exclusive Lock

Environment: Production → Approvals and checks → Exclusive lock

┌────────────────────────────────────────────────┐
│ Exclusive lock                                 │
├────────────────────────────────────────────────┤
│                                                │
│ ☑ Enabled                                      │
│                                                │
│ This check ensures that only one run at a      │
│ time can deploy to this environment.           │
│                                                │
│ On pending run(s):                             │
│ ● Cancel the pending run(s)                    │
│ ○ Wait for the previous deployment to finish   │
│                                                │
│ [Save]                                         │
└────────────────────────────────────────────────┘

7.2.8 Processus d’approbation en pratique

7.2.8.1 Vue de l’approbateur

📧 Email reçu:
┌──────────────────────────────────────────────────────────┐
│ From: Azure DevOps                                       │
│ Subject: [Action Required] Approval requested for        │
│          ShopConnect - Deploy to Production              │
├──────────────────────────────────────────────────────────┤
│                                                          │
│ An approval is pending for your review.                  │
│                                                          │
│ Pipeline: ShopConnect-Release                            │
│ Stage: DeployProd                                        │
│ Environment: Production                                  │
│ Requested by: Alice                                      │
│ Build: 20240525.3                                        │
│                                                          │
│ [Review and Approve]  ← Lien direct                      │
│                                                          │
│ This approval will expire in 7 days.                     │
└──────────────────────────────────────────────────────────┘

Interface d’approbation dans Azure DevOps :

┌──────────────────────────────────────────────────────────┐
│ Deployment details                                       │
├──────────────────────────────────────────────────────────┤
│                                                          │
│ Pipeline:   ShopConnect-Release                          │
│ Stage:      DeployProd                                   │
│ Run #:      20240525.3                                   │
│ Requested:  25 May 2024, 14:30                           │
│ Expires:    01 Jun 2024, 14:30                           │
│                                                          │
│ ──────────────────────────────────────────────────────   │
│                                                          │
│ Changes in this release:                                 │
│ • feat(auth): add OAuth2 support                         │
│ • fix(payment): resolve null reference                   │
│ • docs: update API documentation                         │
│                                                          │
│ Build artifacts:                                         │
│ • shopconnect-api-1.2.35.zip (2.3 MB)                    │
│                                                          │
│ Tests:                                                   │
│ ✓ 45 passed  ✗ 0 failed  ⊘ 0 skipped                     │
│ Coverage: 87%                                            │
│                                                          │
│ Previous successful deployment: 24 May 2024, 10:00       │
│                                                          │
│ ──────────────────────────────────────────────────────   │
│                                                          │
│ Comments: (optional)                                     │
│ ┌───────────────────────────────────────────────────┐    │
│ │ Verified tests, approving deployment              │    │
│ └───────────────────────────────────────────────────┘    │
│                                                          │
│ [Approve]  [Reject]  [Reassign]                          │
│                                                          │
└──────────────────────────────────────────────────────────┘

7.2.10 Historique des déploiements

Pipelines → Environments → Production → Deployments

┌─────────────────────────────────────────────────────────┐
│ Deployment History - Production                         │
├────────────┬────────────┬──────────┬────────┬───────────┤
│ Date       │ Pipeline   │ Build    │ Status │ Approver  │
├────────────┼────────────┼──────────┼────────┼───────────┤
│ 25/05 14h45│ Release    │ 20240525 │ ✓ OK   │ Alice     │
│ 24/05 10h00│ Release    │ 20240524 │ ✓ OK   │ Bob       │
│ 23/05 15h30│ Release    │ 20240523 │ ✗ Fail │ Alice     │
│ 22/05 09h15│ Release    │ 20240522 │ ✓ OK   │ Charlie   │
└────────────┴────────────┴──────────┴────────┴───────────┘

[Compare deployments]  [View deployment details]

7.3 Automatisation des déploiements

7.3.1 Stratégies de déclenchement automatique

7.3.1.1 1. Continuous Deployment (CD) complet

Configuration YAML :

# Pipeline déclenché automatiquement depuis le build
resources:
  pipelines:
  - pipeline: buildPipeline
    source: 'ShopConnect-CI'
    trigger:
      branches:
        include:
        - main

stages:
# Dev: Déploiement 100% automatique
- stage: DeployDev
  displayName: 'Auto Deploy → Dev'
  jobs:
  - deployment: DeployDevJob
    environment: 'Development'  # Aucune approbation configurée
    strategy:
      runOnce:
        deploy:
          steps:
          - script: echo "Auto-deploying to Dev"

# Test: Déploiement automatique si Dev OK
- stage: DeployTest
  displayName: 'Auto Deploy → Test'
  dependsOn: DeployDev
  condition: succeeded()
  jobs:
  - deployment: DeployTestJob
    environment: 'Test'  # Aucune approbation
    strategy:
      runOnce:
        deploy:
          steps:
          - script: echo "Auto-deploying to Test"

# Prod: Approbation manuelle requise
- stage: DeployProd
  displayName: 'Manual Deploy → Production'
  dependsOn: DeployTest
  condition: succeeded()
  jobs:
  - deployment: DeployProdJob
    environment: 'Production'  # Approbation configurée ici
    strategy:
      runOnce:
        deploy:
          steps:
          - script: echo "Deploying to Production"

7.3.3.1 2. Déclencheurs planifiés (Scheduled releases)

schedules:
# Release nocturne vers Dev (chaque nuit à 1h)
- cron: "0 1 * * *"
  displayName: Nightly Dev Release
  branches:
    include:
    - develop
  always: true

# Release hebdomadaire vers Test (vendredi à 16h)
- cron: "0 16 * * 5"
  displayName: Weekly Test Release
  branches:
    include:
    - main
  always: false

# Pas de schedule pour Prod (approbation manuelle uniquement)

7.3.4.1 3. Déclenchement via API REST

# Déclencher un pipeline via l'API Azure DevOps
curl -X POST \
  "https://dev.azure.com/{org}/{project}/_apis/pipelines/{pipelineId}/runs?api-version=7.0" \
  -H "Content-Type: application/json" \
  -H "Authorization: Basic $(echo -n ':PAT_TOKEN' | base64)" \
  -d '{
    "resources": {
      "repositories": {
        "self": {
          "refName": "refs/heads/main"
        }
      }
    },
    "variables": {
      "deploymentTarget": {
        "value": "production",
        "isSecret": false
      }
    }
  }'

7.3.5.1 4. Déclenchement via webhook

# Déclencher depuis un système externe
resources:
  webhooks:
  - webhook: ExternalSystem
    connection: 'WebhookConnection'
    filters:
    - path: eventType
      value: deployment.approved
    - path: environment
      value: production

trigger: none

stages:
- stage: Deploy
  condition: eq(variables['resources.webhook.ExternalSystem.body.environment'], 'production')
  jobs:
  - deployment: DeployJob
    environment: Production
    strategy:
      runOnce:
        deploy:
          steps:
          - script: echo "Deploying triggered by external webhook"

7.3.6 Automatisation complète avec quality gates

# Pipeline de release entièrement automatisé avec quality gates

trigger: none

resources:
  pipelines:
  - pipeline: buildPipeline
    source: 'ShopConnect-CI'
    trigger:
      branches:
        include:
        - main

variables:
  azureSubscription: 'Azure-ShopConnect'

stages:
- stage: QualityGate
  displayName: 'Quality Gate'
  jobs:
  - job: QualityChecks
    displayName: 'Automated Quality Checks'
    pool:
      vmImage: 'ubuntu-latest'
    steps:
    
    # Vérifier le taux de couverture de code
    - task: PowerShell@2
      displayName: 'Check Code Coverage'
      inputs:
        targetType: 'inline'
        script: |
          # Récupérer la couverture via API Azure DevOps
          $coverage = $(Build.CodeCoverage)
          
          Write-Host "Code coverage: $coverage%"
          
          if ([int]$coverage -lt 80) {
            Write-Error "Coverage ($coverage%) is below threshold (80%)"
            exit 1
          }
          Write-Host "✓ Coverage threshold passed"
    
    # Vérifier qu'il n'y a pas de bugs critiques ouverts
    - task: PowerShell@2
      displayName: 'Check Active Critical Bugs'
      inputs:
        targetType: 'inline'
        script: |
          $organization = "$(System.TeamFoundationCollectionUri)"
          $project = "$(System.TeamProject)"
          $pat = "$(System.AccessToken)"
          
          $base64 = [Convert]::ToBase64String([Text.Encoding]::ASCII.GetBytes(":$pat"))
          $headers = @{ Authorization = "Basic $base64" }
          
          $wiql = @{
            query = "SELECT [System.Id] FROM WorkItems WHERE [System.TeamProject] = '$project' AND [System.WorkItemType] = 'Bug' AND [Microsoft.VSTS.Common.Priority] = 1 AND [System.State] = 'Active'"
          }
          
          $response = Invoke-RestMethod `
            -Uri "${organization}${project}/_apis/wit/wiql?api-version=7.0" `
            -Method Post `
            -Headers $headers `
            -Body ($wiql | ConvertTo-Json) `
            -ContentType 'application/json'
          
          $bugCount = $response.workItems.Count
          Write-Host "Critical bugs: $bugCount"
          
          if ($bugCount -gt 0) {
            Write-Error "There are $bugCount critical bugs. Deployment blocked."
            exit 1
          }
          Write-Host "✓ No critical bugs"

- stage: DeployDev
  displayName: 'Deploy Dev'
  dependsOn: QualityGate
  condition: succeeded()
  jobs:
  - deployment: DeployDevJob
    environment: 'Development'
    pool:
      vmImage: 'ubuntu-latest'
    strategy:
      runOnce:
        deploy:
          steps:
          - download: buildPipeline
            artifact: drop
          - task: AzureWebApp@1
            inputs:
              azureSubscription: '$(azureSubscription)'
              appName: 'shopconnect-webapp-dev'
              package: '$(Pipeline.Workspace)/buildPipeline/drop/**/*.zip'

- stage: IntegrationTests
  displayName: 'Integration Tests'
  dependsOn: DeployDev
  condition: succeeded()
  jobs:
  - job: RunIntegrationTests
    pool:
      vmImage: 'ubuntu-latest'
    steps:
    - script: |
        echo "Running integration tests against Dev..."
        # Exemples de tests avec Playwright ou Cypress
        npx playwright test --reporter=junit
      displayName: 'Run Integration Tests'
    
    - task: PublishTestResults@2
      condition: always()
      inputs:
        testResultsFormat: 'JUnit'
        testResultsFiles: '**/junit.xml'

- stage: DeployTest
  displayName: 'Deploy Test'
  dependsOn: IntegrationTests
  condition: succeeded()
  jobs:
  - deployment: DeployTestJob
    environment: 'Test'
    pool:
      vmImage: 'ubuntu-latest'
    strategy:
      runOnce:
        deploy:
          steps:
          - download: buildPipeline
            artifact: drop
          - task: AzureWebApp@1
            inputs:
              azureSubscription: '$(azureSubscription)'
              appName: 'shopconnect-webapp-test'
              package: '$(Pipeline.Workspace)/buildPipeline/drop/**/*.zip'

- stage: DeployProd
  displayName: 'Deploy Production'
  dependsOn: DeployTest
  condition: succeeded()
  jobs:
  - deployment: DeployProdJob
    environment: 'Production'
    pool:
      vmImage: 'ubuntu-latest'
    strategy:
      runOnce:
        deploy:
          steps:
          - download: buildPipeline
            artifact: drop
          - task: AzureWebApp@1
            inputs:
              azureSubscription: '$(azureSubscription)'
              appName: 'shopconnect-webapp-prod'
              package: '$(Pipeline.Workspace)/buildPipeline/drop/**/*.zip'

7.3.7 Rollback automatique

- stage: DeployProd
  jobs:
  - deployment: DeployProdJob
    environment: 'Production'
    strategy:
      runOnce:
        deploy:
          steps:
          - download: buildPipeline
            artifact: drop
          
          # Sauvegarder la version actuelle avant déploiement
          - task: AzureCLI@2
            displayName: 'Save current version (rollback point)'
            inputs:
              azureSubscription: '$(azureSubscription)'
              scriptType: 'bash'
              scriptLocation: 'inlineScript'
              inlineScript: |
                CURRENT_VERSION=$(az webapp deployment list \
                  --name shopconnect-webapp-prod \
                  --resource-group shopconnect-rg \
                  --query "[0].id" -o tsv)
                echo "##vso[task.setvariable variable=rollbackVersion]$CURRENT_VERSION"
                echo "Rollback point: $CURRENT_VERSION"
          
          - task: AzureWebApp@1
            displayName: 'Deploy new version'
            inputs:
              azureSubscription: '$(azureSubscription)'
              appName: 'shopconnect-webapp-prod'
              package: '$(Pipeline.Workspace)/buildPipeline/drop/**/*.zip'
        
        postRouteTraffic:
          steps:
          - task: PowerShell@2
            displayName: 'Health Check with auto-rollback'
            inputs:
              targetType: 'inline'
              script: |
                $url = "https://shopconnect-webapp-prod.azurewebsites.net/health"
                $maxRetries = 5
                $retryCount = 0
                $success = $false
                
                while (-not $success -and $retryCount -lt $maxRetries) {
                  try {
                    $response = Invoke-WebRequest -Uri $url -UseBasicParsing -TimeoutSec 10
                    if ($response.StatusCode -eq 200) {
                      $success = $true
                      Write-Host "✓ Health check passed!"
                    }
                  } catch {
                    $retryCount++
                    Write-Host "Attempt $retryCount/$maxRetries failed, waiting..."
                    Start-Sleep -Seconds 10
                  }
                }
                
                if (-not $success) {
                  Write-Error "Health check failed after $maxRetries attempts!"
                  exit 1
                }
        
        on:
          failure:
            steps:
            - task: AzureCLI@2
              displayName: 'ROLLBACK to previous version'
              inputs:
                azureSubscription: '$(azureSubscription)'
                scriptType: 'bash'
                scriptLocation: 'inlineScript'
                inlineScript: |
                  echo "⚠️ Deployment failed! Rolling back..."
                  
                  az webapp deployment slot swap \
                    --name shopconnect-webapp-prod \
                    --resource-group shopconnect-rg \
                    --slot staging \
                    --target-slot production
                  
                  echo "✓ Rollback completed"

7.4 Déploiement conditionnel

7.4.1 Conditions dans les pipelines

7.4.1.1 1. Conditions basées sur la branche

stages:
# Deploy Dev: seulement depuis develop ou feature/*
- stage: DeployDev
  displayName: 'Deploy to Dev'
  condition: |
    and(
      succeeded(),
      or(
        eq(variables['Build.SourceBranch'], 'refs/heads/develop'),
        startsWith(variables['Build.SourceBranch'], 'refs/heads/feature/')
      )
    )
  jobs:
  - deployment: DeployDevJob
    environment: Development
    strategy:
      runOnce:
        deploy:
          steps:
          - script: echo "Deploying from $(Build.SourceBranchName)"

# Deploy Prod: seulement depuis main ET avec tag
- stage: DeployProd
  displayName: 'Deploy to Production'
  condition: |
    and(
      succeeded('DeployTest'),
      eq(variables['Build.SourceBranch'], 'refs/heads/main'),
      startsWith(variables['Build.SourceVersionMessage'], 'release:')
    )
  jobs:
  - deployment: DeployProdJob
    environment: Production
    strategy:
      runOnce:
        deploy:
          steps:
          - script: echo "Production deployment from main"

7.4.2.1 2. Conditions basées sur des variables

variables:
  deployToProduction: 'false'  # Override lors du run manuel
  runIntegrationTests: 'true'

stages:
- stage: DeployTest
  displayName: 'Deploy to Test'
  condition: eq(variables['runIntegrationTests'], 'true')
  jobs:
  - deployment: TestDeployment
    environment: Test
    strategy:
      runOnce:
        deploy:
          steps:
          - script: echo "Running tests"

- stage: DeployProd
  displayName: 'Deploy to Production'
  condition: |
    and(
      succeeded('DeployTest'),
      eq(variables['deployToProduction'], 'true')
    )
  jobs:
  - deployment: ProdDeployment
    environment: Production
    strategy:
      runOnce:
        deploy:
          steps:
          - script: echo "Deploying to prod"

7.4.3.1 3. Conditions basées sur des tags Git

trigger:
  tags:
    include:
    - v*

stages:
- stage: Build
  jobs:
  - job: BuildJob
    steps:
    - script: |
        # Extraire le numéro de version du tag
        VERSION=$(echo $(Build.SourceBranch) | sed 's/refs\/tags\/v//')
        echo "Version: $VERSION"
        echo "##vso[task.setvariable variable=version;isOutput=true]$VERSION"
      name: SetVersion

- stage: DeployProd
  displayName: 'Deploy Release $(Build.SourceBranchName)'
  dependsOn: Build
  condition: |
    and(
      succeeded('Build'),
      startsWith(variables['Build.SourceBranch'], 'refs/tags/v')
    )
  jobs:
  - deployment: ReleaseDeployment
    displayName: 'Release Deployment'
    environment: Production
    strategy:
      runOnce:
        deploy:
          steps:
          - script: echo "Deploying version $(Build.SourceBranchName)"

7.4.4.1 4. Conditions basées sur les résultats de tests

- stage: DeployProd
  displayName: 'Deploy to Production'
  dependsOn:
  - Build
  - Test
  condition: |
    and(
      eq(dependencies.Build.result, 'Succeeded'),
      eq(dependencies.Test.result, 'Succeeded'),
      eq(stageDependencies.Test.TestJob.outputs['TestResults.passRate'], '100')
    )

7.4.5 Expressions de condition avancées

7.4.5.1 Fonctions disponibles

# Fonctions de comparaison
condition: eq(variables['var'], 'value')      # Égal
condition: ne(variables['var'], 'value')      # Différent
condition: gt(variables['count'], '5')        # Supérieur
condition: ge(variables['count'], '5')        # Supérieur ou égal
condition: lt(variables['count'], '5')        # Inférieur
condition: le(variables['count'], '5')        # Inférieur ou égal

# Fonctions logiques
condition: and(cond1, cond2)                  # ET logique
condition: or(cond1, cond2)                   # OU logique
condition: not(condition)                     # NON logique

# Fonctions de chaîne
condition: startsWith(variables['branch'], 'feature/')
condition: endsWith(variables['name'], '-prod')
condition: contains(variables['tags'], 'release')

# Fonctions d'état
condition: succeeded()                        # Stage précédent réussi
condition: failed()                           # Stage précédent échoué
condition: canceled()                         # Stage précédent annulé
condition: always()                           # Toujours exécuter
condition: succeededOrFailed()                # Réussi ou échoué

# Fonctions spéciales
condition: eq(variables['Build.Reason'], 'PullRequest')
condition: eq(variables['Build.Reason'], 'Schedule')
condition: eq(variables['Build.Reason'], 'Manual')
condition: eq(variables['Build.Reason'], 'IndividualCI')

7.4.6.1 Exemples complexes

# Déployer en prod uniquement si:
# - Build réussi
# - Tests réussis
# - Branche main
# - Pas un PR
# - Pas un build planifié
condition: |
  and(
    succeeded('Build'),
    succeeded('Test'),
    eq(variables['Build.SourceBranch'], 'refs/heads/main'),
    ne(variables['Build.Reason'], 'PullRequest'),
    ne(variables['Build.Reason'], 'Schedule')
  )

# Déployer en test uniquement si:
# - Feature branch OU develop
# - Pas les branches de documentation
condition: |
  and(
    succeeded(),
    or(
      startsWith(variables['Build.SourceBranch'], 'refs/heads/feature/'),
      eq(variables['Build.SourceBranch'], 'refs/heads/develop')
    ),
    not(startsWith(variables['Build.SourceBranch'], 'refs/heads/docs/'))
  )

7.4.7 Paramètres de pipeline runtime

parameters:
- name: targetEnvironment
  displayName: 'Target Environment'
  type: string
  default: 'dev'
  values:
  - dev
  - test
  - prod

- name: runTests
  displayName: 'Run Tests After Deployment'
  type: boolean
  default: true

- name: forceDeployment
  displayName: 'Force deployment (skip quality gates)'
  type: boolean
  default: false

stages:
- stage: Deploy
  displayName: 'Deploy to ${{ parameters.targetEnvironment }}'
  jobs:
  - deployment: DeployJob
    environment: ${{ parameters.targetEnvironment }}
    strategy:
      runOnce:
        deploy:
          steps:
          - script: echo "Deploying to ${{ parameters.targetEnvironment }}"
          
          - ${{ if parameters.runTests }}:
            - script: echo "Running post-deployment tests"

Interface lors du déclenchement manuel :

Run pipeline

┌────────────────────────────────────────────────┐
│ Parameters                                     │
├────────────────────────────────────────────────┤
│                                                │
│ Target Environment:                            │
│ ● dev  ○ test  ○ prod                          │
│                                                │
│ Run Tests After Deployment:                    │
│ ● true  ○ false                                │
│                                                │
│ Force deployment:                              │
│ ○ true  ● false                                │
│                                                │
│ [Run]  [Cancel]                                │
└────────────────────────────────────────────────┘

7.4.9 Déploiement par feature flags

# Déployer avec activation conditionnelle de features
- stage: DeployProd
  jobs:
  - deployment: DeployProdJob
    environment: Production
    strategy:
      runOnce:
        deploy:
          steps:
          - task: AzureWebApp@1
            inputs:
              appName: 'shopconnect-webapp-prod'
              package: '$(Pipeline.Workspace)/drop/**/*.zip'
              appSettings: |
                -FeatureFlags:NewCheckout $(enableNewCheckout)
                -FeatureFlags:PaymentV2 false
                -FeatureFlags:Dashboard true

7.5 Monitoring et notifications des déploiements

7.5.1 Notifications automatiques

7.5.1.1 Configuration des notifications Azure DevOps

Project Settings → Notifications → New subscription

Event: Release deployment completed
Delivery: Send to members of team...

Filters:
- Environment: Production
- Status: Succeeded, Failed

7.5.2.1 Notification Microsoft Teams

- task: PowerShell@2
  displayName: 'Notify Teams Channel'
  condition: always()
  inputs:
    targetType: 'inline'
    script: |
      $status = "$(Agent.JobStatus)"
      $color = if ($status -eq "Succeeded") { "00FF00" } else { "FF0000" }
      $emoji = if ($status -eq "Succeeded") { "✅" } else { "❌" }
      
      $body = @{
        "@type" = "MessageCard"
        "@context" = "http://schema.org/extensions"
        "themeColor" = $color
        "summary" = "Deployment Notification"
        "sections" = @(
          @{
            "activityTitle" = "$emoji ShopConnect Deployment - $status"
            "activitySubtitle" = "$(Build.BuildNumber)"
            "facts" = @(
              @{ "name" = "Environment"; "value" = "Production" },
              @{ "name" = "Build"; "value" = "$(Build.BuildNumber)" },
              @{ "name" = "Branch"; "value" = "$(Build.SourceBranchName)" },
              @{ "name" = "Triggered by"; "value" = "$(Build.RequestedFor)" },
              @{ "name" = "Status"; "value" = $status }
            )
          }
        )
        "potentialAction" = @(
          @{
            "@type" = "OpenUri"
            "name" = "View in Azure DevOps"
            "targets" = @(
              @{
                "os" = "default"
                "uri" = "$(System.TeamFoundationCollectionUri)$(System.TeamProject)/_build/results?buildId=$(Build.BuildId)"
              }
            )
          }
        )
      }
      
      Invoke-RestMethod -Uri "$(TeamsWebhookUrl)" -Method Post -Body ($body | ConvertTo-Json -Depth 10) -ContentType 'application/json'

7.6 Travaux Pratiques

TP6 : Automatiser les déploiements et les valider

7.7 Synthèse du Module 6

7.7.1 Points clés à retenir

✅ Approbations

  • Multi-niveaux (technique + business)
  • Checks automatiques (branch control, business hours)
  • Exclusive lock pour éviter les conflits
  • Historique complet des approbations

✅ Automatisation

  • CD complet (Dev/Test auto, Prod manuel)
  • Déclencheurs planifiés (nightly, weekly)
  • Quality gates automatiques
  • Rollback automatique en cas d’échec

✅ Déploiement conditionnel

  • Conditions par branche
  • Conditions par variable
  • Conditions par tags Git
  • Paramètres runtime

✅ Monitoring

  • Notifications email / Teams
  • Health checks post-déploiement
  • Alertes en cas d’échec

8 La gestion des releases

8.1 Objectifs pédagogiques

À l’issue de ce module, vous serez capable de :

  • Gérer plusieurs versions dans différents environnements
  • Définir et surcharger des variables par environnement
  • Analyser les logs de déploiement
  • Implémenter une gestion d’erreurs robuste
  • Tracer et auditer les déploiements
  • Mettre en place des stratégies de versioning

8.2 Gérer différentes versions dans différents environnements

8.2.1 Concepts de versioning

8.2.1.1 Semantic Versioning (SemVer)

MAJOR.MINOR.PATCH[-PRERELEASE][+BUILD]

Exemples:
  1.0.0          → Release initiale
  1.1.0          → Nouvelle fonctionnalité (rétrocompatible)
  1.1.1          → Correction de bug
  2.0.0          → Changement majeur (breaking change)
  1.2.0-alpha.1  → Version alpha
  1.2.0-beta.3   → Version bêta
  1.2.0-rc.1     → Release candidate

Règles :

Incrémenter Quand Exemple
MAJOR Breaking change, API incompatible 1.x.x → 2.0.0
MINOR Nouvelle feature rétrocompatible x.1.x → x.2.0
PATCH Correction de bug rétrocompatible x.x.1 → x.x.2
PRERELEASE Version instable 1.2.0-alpha.1

8.2.3.1 Numérotation des builds Azure DevOps

# Convention de nommage des builds
name: $(Build.DefinitionName)_$(SourceBranchName)_$(Date:yyyyMMdd)$(Rev:.r)

# Exemples de sorties:
# ShopConnect-CI_main_20240525.1
# ShopConnect-CI_main_20240525.2
# ShopConnect-CI_feature-auth_20240525.1

Gestion automatique du numéro de version :

variables:
  major: 1
  minor: 2
  # Compteur automatique qui s'incrémente à chaque build sur minor
  patch: $[counter(variables['minor'], 0)]

name: $(major).$(minor).$(patch)

steps:
- script: |
    echo "Version: $(Build.BuildNumber)"
    # Mise à jour du fichier de version
    sed -i "s/VERSION_PLACEHOLDER/$(Build.BuildNumber)/g" src/version.txt
  displayName: 'Apply version number'

8.2.5 Matrice des environnements et versions

┌─────────────────────────────────────────────────────────────┐
│                 VERSION TRACKING MATRIX                     │
├─────────────────┬──────────┬──────────┬──────────┬──────────┤
│ Environment     │ Version  │ Build    │ Date     │ Status   │
├─────────────────┼──────────┼──────────┼──────────┼──────────┤
│ Development     │ 1.3.0-dev│ 20240525 │ 25/05/24 │ ✓ Active │
│ Test            │ 1.2.5    │ 20240524 │ 24/05/24 │ ✓ Active │
│ Staging         │ 1.2.4    │ 20240520 │ 20/05/24 │ ✓ Active │
│ Production      │ 1.2.3    │ 20240515 │ 15/05/24 │ ✓ Active │
└─────────────────┴──────────┴──────────┴──────────┴──────────┘

Règle: Prod < Staging ≤ Test ≤ Dev (versions croissantes)

8.2.6 Gestion multi-versions avec Azure Pipelines

8.2.6.1 Stratégie de branching et versioning

8.2.7.1 Pipeline avec gestion de version

# azure-pipelines-versioned.yml

trigger:
  branches:
    include:
    - main
    - release/*
  tags:
    include:
    - v*

variables:
  buildConfiguration: 'Release'

# Calcul automatique de la version selon le contexte
stages:
- stage: CalculateVersion
  displayName: 'Calculate Version'
  jobs:
  - job: VersionJob
    pool:
      vmImage: 'ubuntu-latest'
    steps:
    - checkout: self
      fetchDepth: 0  # Historique complet pour gitversion

    # Installer GitVersion (outil de versioning automatique)
    - task: gitversion/setup@0
      displayName: 'Install GitVersion'
      inputs:
        versionSpec: '5.x'

    - task: gitversion/execute@0
      displayName: 'Calculate version with GitVersion'
      name: GitVersion

    - script: |
        echo "SemVer:        $(GitVersion.SemVer)"
        echo "MajorMinorPatch: $(GitVersion.MajorMinorPatch)"
        echo "PreReleaseTag: $(GitVersion.PreReleaseTag)"
        echo "FullSemVer:    $(GitVersion.FullSemVer)"
        echo "NuGetVersion:  $(GitVersion.NuGetVersion)"
        echo "AssemblySemVer: $(GitVersion.AssemblySemVer)"
      displayName: 'Display calculated version'

    - task: PublishBuildArtifacts@1
      inputs:
        pathToPublish: '$(Build.ArtifactStagingDirectory)'
        artifactName: 'version'

- stage: Build
  displayName: 'Build v$(GitVersion.SemVer)'
  dependsOn: CalculateVersion
  jobs:
  - job: BuildJob
    pool:
      vmImage: 'ubuntu-latest'
    variables:
      semVer: $[ stageDependencies.CalculateVersion.VersionJob.outputs['GitVersion.SemVer'] ]
    steps:
    - task: DotNetCoreCLI@2
      displayName: 'Build with version $(semVer)'
      inputs:
        command: 'build'
        arguments: >
          --configuration $(buildConfiguration)
          /p:Version=$(semVer)
          /p:AssemblyVersion=$(semVer)
          /p:FileVersion=$(semVer)
    
    - task: DotNetCoreCLI@2
      displayName: 'Publish'
      inputs:
        command: 'publish'
        arguments: >
          --configuration $(buildConfiguration)
          /p:Version=$(semVer)
          --output $(Build.ArtifactStagingDirectory)
        zipAfterPublish: true
    
    - task: PublishBuildArtifacts@1
      inputs:
        pathToPublish: '$(Build.ArtifactStagingDirectory)'
        artifactName: 'drop'

8.2.8 Promotion de versions entre environnements

8.2.8.1 Workflow de promotion

┌──────────────────────────────────────────────────────────────┐
│                    RELEASE PROMOTION                         │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│  Build v1.2.5                                                │
│      │                                                       │
│      ▼                                                       │
│  Dev  ──────── Auto ────────────────────────────▶            │
│  (v1.2.5)       Smoke tests: ✓                               │
│      │                                                       │
│      ▼                                                       │
│  Test ──────── Auto (après Dev) ──────────────▶              │
│  (v1.2.5)       Integration tests: ✓                         │
│                 Regression tests: ✓                          │
│      │                                                       │
│      ▼                                                       │
│  Staging ────── Approval: Tech Lead ──────────▶              │
│  (v1.2.5)       UAT: ✓                                       │
│                 Performance tests: ✓                         │
│      │                                                       │
│      ▼                                                       │
│  Prod ────────── Approval: PO + Tech Lead ────▶              │
│  (v1.2.5)       Change Window: Fri 17h-19h                   │
│                                                              │
└──────────────────────────────────────────────────────────────┘

8.2.9.1 Comparer les versions déployées

- task: PowerShell@2
  displayName: 'Compare versions across environments'
  inputs:
    targetType: 'inline'
    script: |
      $environments = @{
        "Dev"     = "https://shopconnect-webapp-dev.azurewebsites.net"
        "Test"    = "https://shopconnect-webapp-test.azurewebsites.net"
        "Staging" = "https://shopconnect-webapp-staging.azurewebsites.net"
        "Prod"    = "https://shopconnect-webapp-prod.azurewebsites.net"
      }
      
      Write-Host "=== Version Report ==="
      foreach ($env in $environments.GetEnumerator()) {
        try {
          $response = Invoke-RestMethod -Uri "$($env.Value)/api/version"
          Write-Host "$($env.Key): v$($response.version) (Build: $($response.buildNumber))"
        } catch {
          Write-Host "$($env.Key): ⚠️ Unavailable"
        }
      }

8.2.10 Gestion des hotfixes

Scénario : Bug critique en production → correction urgente

Pipeline hotfix :

# azure-pipelines-hotfix.yml
trigger:
  branches:
    include:
    - hotfix/*

variables:
  isHotfix: true
  skipNonCriticalTests: true

stages:
- stage: BuildHotfix
  displayName: '🚨 Hotfix Build'
  jobs:
  - job: BuildJob
    pool:
      vmImage: 'ubuntu-latest'
    steps:
    - task: DotNetCoreCLI@2
      inputs:
        command: 'build'
        arguments: '--configuration Release'
    
    # Tests critiques uniquement (pas les tests longs)
    - task: DotNetCoreCLI@2
      displayName: 'Critical tests only'
      inputs:
        command: 'test'
        arguments: '--filter "Category=Critical|Category=Smoke"'

# Déploiement direct en Prod (avec double approbation)
- stage: DeployProdHotfix
  displayName: '🚨 Emergency Deploy to Production'
  dependsOn: BuildHotfix
  condition: succeeded()
  jobs:
  - deployment: HotfixDeploy
    environment: 'Production-Hotfix'  # Environnement avec règles d'urgence
    strategy:
      runOnce:
        deploy:
          steps:
          - script: |
              echo "⚠️  HOTFIX DEPLOYMENT"
              echo "Branch: $(Build.SourceBranchName)"
              echo "Time: $(date)"

8.3 Définition des variables d’environnement

8.3.1 Architecture des variables

8.3.2 Niveaux de variables

8.3.2.1 Niveau 1 : Variables de pipeline (YAML)

variables:
  # Variables simples
  buildConfiguration: 'Release'
  dotnetVersion: '8.0.x'
  
  # Variables avec template expression
  artifactName: 'drop'
  
  # Variables conditionnelles
  ${{ if eq(variables['Build.SourceBranchName'], 'main') }}:
    environment: 'production'
    logLevel: 'Warning'
  ${{ else }}:
    environment: 'development'
    logLevel: 'Debug'

8.3.3.1 Niveau 2 : Variables de groupe

Pipelines → Library

Groupe 1: ShopConnect-Common
┌────────────────────────────────────┬──────────────────────┐
│ Variable                           │ Value                │
├────────────────────────────────────┼──────────────────────┤
│ ApplicationName                    │ ShopConnect          │
│ AzureRegion                        │ West Europe          │
│ ResourceGroup                      │ shopconnect-rg       │
│ ArtifactFeedName                   │ ShopConnect-Feed     │
└────────────────────────────────────┴──────────────────────┘

Groupe 2: ShopConnect-Dev
┌────────────────────────────────────┬──────────────────────┐
│ Variable                           │ Value                │
├────────────────────────────────────┼──────────────────────┤
│ WebAppName                         │ shopconnect-dev      │
│ SqlServerName                      │ shopconnect-sql-dev  │
│ ConnectionString                   │ ******** (secret)    │
│ LogLevel                           │ Debug                │
│ AppInsightsKey                     │ ******** (secret)    │
│ EnableDetailedErrors               │ true                 │
└────────────────────────────────────┴──────────────────────┘

Groupe 3: ShopConnect-Test
┌────────────────────────────────────┬──────────────────────┐
│ Variable                           │ Value                │
├────────────────────────────────────┼──────────────────────┤
│ WebAppName                         │ shopconnect-test     │
│ SqlServerName                      │ shopconnect-sql-test │
│ ConnectionString                   │ ******** (secret)    │
│ LogLevel                           │ Information          │
│ AppInsightsKey                     │ ******** (secret)    │
│ EnableDetailedErrors               │ false                │
└────────────────────────────────────┴──────────────────────┘

Groupe 4: ShopConnect-Prod
┌────────────────────────────────────┬──────────────────────┐
│ Variable                           │ Value                │
├────────────────────────────────────┼──────────────────────┤
│ WebAppName                         │ shopconnect-prod     │
│ SqlServerName                      │ shopconnect-sql-prod │
│ ConnectionString                   │ ******** (secret)    │
│ LogLevel                           │ Warning              │
│ AppInsightsKey                     │ ******** (secret)    │
│ EnableDetailedErrors               │ false                │
└────────────────────────────────────┴──────────────────────┘

8.3.4.1 Utiliser des groupes selon l’environnement

stages:
- stage: DeployDev
  variables:
  - group: ShopConnect-Common
  - group: ShopConnect-Dev
  jobs:
  - deployment: DeployDevJob
    environment: 'Development'
    strategy:
      runOnce:
        deploy:
          steps:
          - task: AzureWebApp@1
            inputs:
              appName: '$(WebAppName)'   # shopconnect-dev
              appSettings: |
                -ASPNETCORE_ENVIRONMENT Development
                -Logging:LogLevel:Default $(LogLevel)
                -ConnectionStrings:Default "$(ConnectionString)"
                -ApplicationInsights:InstrumentationKey "$(AppInsightsKey)"

- stage: DeployProd
  variables:
  - group: ShopConnect-Common
  - group: ShopConnect-Prod
  jobs:
  - deployment: DeployProdJob
    environment: 'Production'
    strategy:
      runOnce:
        deploy:
          steps:
          - task: AzureWebApp@1
            inputs:
              appName: '$(WebAppName)'   # shopconnect-prod
              appSettings: |
                -ASPNETCORE_ENVIRONMENT Production
                -Logging:LogLevel:Default $(LogLevel)
                -ConnectionStrings:Default "$(ConnectionString)"

8.3.5.1 Niveau 3 : Azure Key Vault

Pipelines → Library → + Variable group

Name: ShopConnect-KeyVault-Secrets
Link secrets from an Azure key vault: ☑

Azure subscription: Azure-ShopConnect
Key vault name: shopconnect-keyvault

+ Add variables from Key Vault:
  ✓ SqlConnectionString
  ✓ ApiKey
  ✓ JwtSecret
  ✓ AppInsightsConnectionString
  ✓ StorageAccountKey

Utilisation dans le pipeline :

variables:
- group: ShopConnect-KeyVault-Secrets  # Secrets depuis Key Vault

steps:
- task: AzureWebApp@1
  inputs:
    appSettings: |
      -ConnectionStrings:Default "$(SqlConnectionString)"
      -Authentication:JwtSecret "$(JwtSecret)"
      -Storage:AccountKey "$(StorageAccountKey)"

Politique d’accès Key Vault :

# Accorder l'accès au service principal Azure DevOps
az keyvault set-policy \
  --name shopconnect-keyvault \
  --spn <azure-devops-service-principal-id> \
  --secret-permissions get list

8.3.8 Variables de substitution dans les fichiers de config

8.3.8.1 Web.config / appsettings.json Transformation

appsettings.json (base) :

{
  "ConnectionStrings": {
    "Default": "#{SqlConnectionString}#"
  },
  "Logging": {
    "LogLevel": {
      "Default": "#{LogLevel}#"
    }
  },
  "ApplicationInsights": {
    "InstrumentationKey": "#{AppInsightsKey}#"
  },
  "FeatureFlags": {
    "NewCheckout": false,
    "PaymentV2": false
  }
}

appsettings.Production.json :

{
  "FeatureFlags": {
    "NewCheckout": true,
    "PaymentV2": true
  }
}

Substitution dans le pipeline :

# Méthode 1: File Transform (XML/JSON)
- task: FileTransform@1
  displayName: 'Transform appsettings.json'
  inputs:
    folderPath: '$(Pipeline.Workspace)/drop'
    targetFiles: '**/appsettings.json'
    fileType: 'json'

# Variables dans le pipeline (correspondant aux #{var}# dans le json)
variables:
  SqlConnectionString: '$(SqlConnectionString)'  # Depuis Key Vault
  LogLevel: 'Warning'
  AppInsightsKey: '$(AppInsightsKey)'

Méthode 2 : envsubst (bash)

- task: Bash@3
  displayName: 'Substitute environment variables'
  inputs:
    targetType: 'inline'
    script: |
      # Créer le fichier de config depuis le template
      envsubst < appsettings.template.json > appsettings.json
      
      echo "Config file generated:"
      cat appsettings.json | jq '.ConnectionStrings'  # Log sans les secrets
  env:
    SqlConnectionString: $(SqlConnectionString)
    LogLevel: $(LogLevel)
    AppInsightsKey: $(AppInsightsKey)

8.3.12 Variables runtime et outputs

stages:
- stage: Build
  jobs:
  - job: BuildJob
    steps:
    # Définir une variable de sortie
    - script: |
        VERSION=$(cat VERSION.txt)
        echo "##vso[task.setvariable variable=appVersion;isOutput=true]$VERSION"
      name: SetVersion
      displayName: 'Read version from file'

- stage: Deploy
  dependsOn: Build
  variables:
    # Récupérer la variable de sortie du stage précédent
    appVersion: $[ stageDependencies.Build.BuildJob.outputs['SetVersion.appVersion'] ]
  jobs:
  - deployment: DeployJob
    environment: Production
    strategy:
      runOnce:
        deploy:
          steps:
          - script: echo "Deploying version $(appVersion)"

8.3.13 Masquer les variables sensibles

# Définir une variable secrète dans le pipeline
# NE JAMAIS écrire des secrets en clair dans le YAML !

# Dans l'interface Azure DevOps:
# Pipeline → Edit → Variables → + Add
# Name: MySecret, Value: ***, ☑ Keep this value secret

# Dans le YAML, utiliser des groupes Key Vault
variables:
- group: 'ShopConnect-Secrets'

# Ou définir un secret au runtime
steps:
- script: |
    echo "##vso[task.setvariable variable=dynamicSecret;isSecret=true]$(computedValue)"
  displayName: 'Set dynamic secret'

# Bonne pratique: ne jamais afficher les secrets dans les logs
- script: |
    # ❌ NE PAS FAIRE
    echo "Connection string: $(SqlConnectionString)"
    
    # ✓ FAIRE
    echo "Connection string configured ($(SqlConnectionString) is masked in logs)"

8.4 Gestion d’erreur et logs

8.4.1 Niveaux de journalisation

# Niveaux de log disponibles dans Azure Pipelines
steps:
- script: |
    echo "##vso[task.logissue type=warning]This is a warning"
    echo "##vso[task.logissue type=error]This is an error"
    echo "##vso[task.setvariable variable=myVar]value"
    echo "##vso[task.uploadfile]path/to/file"
    echo "##vso[build.addbuildtag]my-tag"
  displayName: 'Logging examples'

# Logger depuis PowerShell
- task: PowerShell@2
  inputs:
    script: |
      Write-Host "Standard output"
      Write-Warning "Warning message"
      Write-Error "Error message" -ErrorAction Continue
      
      # Logging structuré pour Azure DevOps
      Write-Host "##[section]Starting section"
      Write-Host "##[command]Running command"
      Write-Host "##[debug]Debug info"
      Write-Host "##[warning]Warning info"
      Write-Host "##[error]Error info"
      Write-Host "##[endgroup]"

8.4.2 Groupes de logs

- script: |
    echo "##[group]Database Migration"
    echo "Running migration step 1..."
    echo "Running migration step 2..."
    echo "Migration completed."
    echo "##[endgroup]"
    
    echo "##[group]Application Deployment"
    echo "Deploying application..."
    echo "Deployment completed."
    echo "##[endgroup]"
  displayName: 'Grouped logging'

Résultat dans l’interface :

▶ Database Migration (click to expand)
  ├─ Running migration step 1...
  ├─ Running migration step 2...
  └─ Migration completed.

▶ Application Deployment (click to expand)
  ├─ Deploying application...
  └─ Deployment completed.

8.4.4 Gestion des erreurs robuste

8.4.4.1 1. Continue on Error

steps:
# Cette tâche peut échouer sans bloquer le pipeline
- task: SonarQubePrepare@5
  displayName: 'SonarQube analysis (non-blocking)'
  continueOnError: true
  inputs:
    SonarQube: 'SonarQube-Connection'
    scannerMode: 'MSBuild'
    projectKey: 'ShopConnect'

# Cette tâche doit réussir obligatoirement
- task: DotNetCoreCLI@2
  displayName: 'Build (blocking)'
  inputs:
    command: 'build'

8.4.5.1 2. Retry sur erreur transitoire

steps:
# Réessayer automatiquement (utile pour les opérations réseau)
- task: AzureWebApp@1
  displayName: 'Deploy (with retry)'
  retryCountOnTaskFailure: 3
  timeoutInMinutes: 10
  inputs:
    azureSubscription: 'Azure-Connection'
    appName: 'shopconnect-webapp'
    package: '$(Pipeline.Workspace)/drop/**/*.zip'

8.4.6.1 3. Try/Catch en PowerShell

- task: PowerShell@2
  displayName: 'Deploy with error handling'
  inputs:
    targetType: 'inline'
    script: |
      $maxRetries = 3
      $retryDelay = 30
      $attempt = 0
      
      do {
        $attempt++
        Write-Host "Attempt $attempt/$maxRetries"
        
        try {
          # Opération de déploiement
          Invoke-WebRequest -Uri "https://shopconnect-webapp.azurewebsites.net" `
            -UseBasicParsing -TimeoutSec 30
          
          Write-Host "✅ Success on attempt $attempt"
          exit 0
          
        } catch {
          $errorMessage = $_.Exception.Message
          Write-Warning "Attempt $attempt failed: $errorMessage"
          
          if ($attempt -lt $maxRetries) {
            Write-Host "Waiting $retryDelay seconds before retry..."
            Start-Sleep -Seconds $retryDelay
          } else {
            Write-Error "All $maxRetries attempts failed. Last error: $errorMessage"
            exit 1
          }
        }
      } while ($attempt -lt $maxRetries)

8.4.7.1 4. Error handling en Bash

- task: Bash@3
  displayName: 'Deploy with bash error handling'
  inputs:
    targetType: 'inline'
    script: |
      set -e  # Arrêter sur erreur
      set -u  # Arrêter sur variable non définie
      set -o pipefail  # Propager les erreurs dans les pipes
      
      # Fonction de nettoyage appelée en cas d'erreur
      cleanup() {
        local exit_code=$?
        echo "❌ Script failed with exit code: $exit_code"
        echo "Cleaning up resources..."
        # Actions de nettoyage
        exit $exit_code
      }
      trap cleanup ERR
      
      # Déploiement
      echo "Starting deployment..."
      
      # Avec timeout
      timeout 300 az webapp deploy \
        --name shopconnect-webapp \
        --resource-group shopconnect-rg \
        --src-path drop/app.zip \
        --type zip
      
      echo "✅ Deployment successful"

8.4.8 Collecte et analyse des logs

8.4.8.1 Récupérer les logs d’application Azure

- task: AzureCLI@2
  displayName: 'Download application logs'
  condition: failed()
  inputs:
    azureSubscription: 'Azure-Connection'
    scriptType: 'bash'
    scriptLocation: 'inlineScript'
    inlineScript: |
      # Télécharger les logs de l'application
      az webapp log download \
        --name shopconnect-webapp-prod \
        --resource-group shopconnect-rg \
        --log-file $(Build.ArtifactStagingDirectory)/app-logs.zip
      
      # Extraire et afficher les logs récents
      unzip $(Build.ArtifactStagingDirectory)/app-logs.zip -d $(Build.ArtifactStagingDirectory)/logs
      
      echo "=== Recent Application Logs ==="
      tail -100 $(Build.ArtifactStagingDirectory)/logs/LogFiles/Application/*.txt 2>/dev/null || \
        echo "No application logs found"
      
      echo ""
      echo "=== Recent HTTP Logs ==="
      tail -50 $(Build.ArtifactStagingDirectory)/logs/LogFiles/http/RawLogs/*.log 2>/dev/null || \
        echo "No HTTP logs found"

- task: PublishBuildArtifacts@1
  displayName: 'Publish error logs'
  condition: failed()
  inputs:
    pathToPublish: '$(Build.ArtifactStagingDirectory)/logs'
    artifactName: 'error-logs-$(Build.BuildId)'

8.4.9.1 Configurer la journalisation Azure App Service

- task: AzureCLI@2
  displayName: 'Enable App Service logging'
  inputs:
    azureSubscription: 'Azure-Connection'
    scriptType: 'bash'
    scriptLocation: 'inlineScript'
    inlineScript: |
      # Activer les logs d'application
      az webapp log config \
        --name $(webAppName) \
        --resource-group $(resourceGroup) \
        --application-logging filesystem \
        --level verbose \
        --web-server-logging filesystem \
        --detailed-error-messages true \
        --failed-request-tracing true
      
      echo "✓ Logging configured for $(webAppName)"

8.4.10.1 Logs en temps réel pendant le déploiement

- task: AzureCLI@2
  displayName: 'Stream deployment logs'
  inputs:
    azureSubscription: 'Azure-Connection'
    scriptType: 'bash'
    scriptLocation: 'inlineScript'
    inlineScript: |
      # Streamer les logs en temps réel (pendant 60 secondes)
      timeout 60 az webapp log tail \
        --name $(webAppName) \
        --resource-group $(resourceGroup) || true

8.4.11 Application Insights - Analyse des erreurs

- task: PowerShell@2
  displayName: 'Check Application Insights for errors'
  inputs:
    targetType: 'inline'
    script: |
      $appId = "$(AppInsightsAppId)"
      $apiKey = "$(AppInsightsApiKey)"
      
      # Requête KQL pour les erreurs récentes
      $query = @"
      exceptions
      | where timestamp > ago(5m)
      | where severityLevel >= 3
      | summarize count() by type, outerMessage
      | order by count_ desc
      | take 10
      "@
      
      $body = @{
        query = $query
        timespan = "PT5M"
      } | ConvertTo-Json
      
      $headers = @{
        "x-api-key" = $apiKey
        "Content-Type" = "application/json"
      }
      
      $response = Invoke-RestMethod `
        -Uri "https://api.applicationinsights.io/v1/apps/$appId/query" `
        -Method Post `
        -Headers $headers `
        -Body $body
      
      $rows = $response.tables[0].rows
      
      if ($rows.Count -gt 0) {
        Write-Warning "⚠️ Exceptions detected in last 5 minutes:"
        foreach ($row in $rows) {
          Write-Host "  Type: $($row[0]) | Count: $($row[2])"
          Write-Host "  Message: $($row[1])"
        }
        
        # Créer un work item pour investigation
        Write-Host "##vso[task.logissue type=warning]Post-deployment exceptions detected!"
      } else {
        Write-Host "✅ No exceptions detected in last 5 minutes"
      }

8.4.12 Dashboard de monitoring des releases

┌──────────────────────────────────────────────────────────────┐
│                  RELEASE MONITORING DASHBOARD                │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│ Release Health                                               │
│ ┌─────────┬─────────┬─────────┬─────────┐                    │
│ │   Dev   │  Test   │ Staging │  Prod   │                    │
│ │  v1.3.0 │  v1.2.5 │  v1.2.4 │  v1.2.3 │                    │
│ │   ✓ OK  │  ✓ OK   │  ✓ OK   │  ✓ OK   │                    │
│ │  98.5%  │  99.1%  │  99.7%  │  99.9%  │                    │
│ └─────────┴─────────┴─────────┴─────────┘                    │
│                                                              │
│ Deployment Frequency (last 30 days)                          │
│ │  ●                                                         │
│ │● ●  ●    ●   ●  ●    ●     ●    ●   ●    ●                 │
│ └─────────────────────────────────────────▶                  │
│  Dev: 28 deployments                                         │
│  Test: 14 deployments                                        │
│  Prod: 6 deployments                                         │
│                                                              │
│ MTTR (Mean Time to Recovery)                                 │
│ Dev:     15 minutes                                          │
│ Test:    25 minutes                                          │
│ Prod:    45 minutes (target: < 1h) ✓                         │
│                                                              │
│ Failed Deployments (last 30 days)                            │
│ Dev:  3 (10.7%) ⚠️                                           │
│ Test: 1 (7.1%)  ✓                                            │
│ Prod: 0 (0%)    ✅                                           │
│                                                              │
└──────────────────────────────────────────────────────────────┘

8.5 Travaux Pratiques

TP7 : Gérer les versions et visualiser les logs

8.6 Synthèse du Module 7

8.6.1 Points clés à retenir

✅ Versioning

  • SemVer: MAJOR.MINOR.PATCH
  • GitVersion: automatique selon les branches
  • Numérotation cohérente des builds

✅ Variables d’environnement

  • Groupes de variables par environnement
  • Azure Key Vault pour les secrets
  • Substitution dans les fichiers de config
  • Jamais de secrets en clair dans le YAML

✅ Gestion d’erreurs

  • continueOnError pour tâches non bloquantes
  • retryCountOnTaskFailure pour les erreurs transitoires
  • Try/catch en PowerShell et Bash
  • Rollback automatique

✅ Logs et monitoring

  • Collecte automatique en cas d’échec
  • Application Insights pour les erreurs applicatives
  • Rapport de release automatisé
  • Dashboards de suivi

9 Fonctionnement de l’agent pool

9.1 Objectifs pédagogiques

À l’issue de ce module, vous serez capable de :

  • Comprendre l’architecture des agents Azure DevOps
  • Gérer la file d’attente des pipelines
  • Configurer des agents hébergés par Microsoft
  • Installer et configurer des agents privés (self-hosted)
  • Optimiser l’utilisation des agents
  • Diagnostiquer les problèmes liés aux agents

9.2 Architecture des agents

9.2.1 Qu’est-ce qu’un agent Azure DevOps ?

Un agent est un logiciel qui s’exécute sur une machine et qui exécute les jobs d’un pipeline.

9.2.2 Types d’agents

Type Description Avantages Inconvénients
Microsoft-hosted VMs éphémères gérées par Microsoft Pas de maintenance, toujours à jour Coût, pas de persistance, performance limitée
Self-hosted Agents sur vos propres machines Personnalisable, persistance, réseau privé Maintenance requise, coût infra
Scale Set Agents Agents auto-scalables via VMSS Azure Élasticité + personnalisation Configuration initiale complexe

9.2.3 Images Microsoft-hosted

Images disponibles (2024):
┌─────────────────────────────────────────────────────────────┐
│ Label YAML             │ Système d'exploitation             │
├────────────────────────┼────────────────────────────────────┤
│ ubuntu-latest          │ Ubuntu 22.04 LTS                   │
│ ubuntu-22.04           │ Ubuntu 22.04 LTS                   │
│ ubuntu-20.04           │ Ubuntu 20.04 LTS                   │
│ windows-latest         │ Windows Server 2022                │
│ windows-2022           │ Windows Server 2022                │
│ windows-2019           │ Windows Server 2019                │
│ macos-latest           │ macOS 14 Sonoma                    │
│ macos-14               │ macOS 14 Sonoma                    │
│ macos-13               │ macOS 13 Ventura                   │
│ macos-12               │ macOS 12 Monterey                  │
└────────────────────────┴────────────────────────────────────┘

Logiciels pré-installés (ubuntu-latest) :

Langages & Runtimes:
├─ .NET 6, 7, 8
├─ Java 8, 11, 17, 21 (OpenJDK)
├─ Node.js 18, 20
├─ Python 3.8, 3.9, 3.10, 3.11, 3.12
├─ Ruby 3.0, 3.1, 3.2
├─ Go 1.20, 1.21
├─ PHP 8.1, 8.2, 8.3
└─ R 4.3

Package Managers:
├─ npm, yarn, pnpm
├─ pip, pipenv, poetry
├─ gem
├─ mvn, gradle
└─ nuget, dotnet

Outils DevOps:
├─ Docker
├─ kubectl
├─ helm
├─ terraform
├─ ansible
├─ azure-cli
└─ GitHub CLI

Outils de test:
├─ jest, cypress
├─ selenium
├─ k6
└─ playwright

Sécurité:
├─ Trivy
├─ OWASP ZAP
└─ snyk

9.3 Gestion de la file d’attente

9.3.1 Comment fonctionne la file d’attente

┌──────────────────────────────────────────────────────────────┐
│                    JOB QUEUE MANAGEMENT                      │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│  Jobs en attente (par priorité):                             │
│  ┌─────────────────────────────────────────────────────┐     │
│  │  [1] ShopConnect-CI #125       → Agent libre: ✓   │     │
│  │  [2] ShopConnect-Release #45   → Agent libre: ✓     │     │
│  │  [3] OtherProject-CI #89       → Attente agent...   │     │
│  │  [4] ShopConnect-CI #126       → Attente agent... │     │
│  └─────────────────────────────────────────────────────┘     │
│                                                              │
│  Agents disponibles:                                         │
│  ┌─────────────────────────────────────────────────────┐     │
│  │  Agent 1 (ubuntu-latest) → BUSY: Job #125         │     │
│  │  Agent 2 (ubuntu-latest) → BUSY: Job #45            │     │
│  │  Agent 3 (windows-latest) → IDLE                    │     │
│  │  Agent 4 (ubuntu-latest) → OFFLINE ⚠️               │     │
│  └─────────────────────────────────────────────────────┘     │
│                                                              │
│  Statistiques:                                               │
│  ├─ Jobs en cours: 2                                         │
│  ├─ Jobs en attente: 2                                       │
│  ├─ Agents actifs: 3/4                                       │
│  └─ Temps moyen d'attente: 3 min 42 sec                      │
│                                                              │
└──────────────────────────────────────────────────────────────┘

9.3.2 Visualiser la file d’attente

Azure DevOps → Organization Settings → Agent pools → [Pool Name] → Jobs

┌──────────────────────────────────────────────────────────────┐
│ Agent Pool: Default                                          │
├───────────────┬──────────────────────────────────────────────┤
│  Running Jobs │  Queued Jobs                                 │
├───────────────┼──────────────────────────────────────────────┤
│               │                                              │
│ • Job #125    │ • Job #126 (waiting 5m 30s)              │
│   ShopConnect │   ShopConnect-CI                             │
│   Started 2m  │   Queued by: Alice                           │
│               │                                              │
│ • Job #45     │ • Job #127 (waiting 1m 15s)                │
│   Release     │   OtherProject                               │
│   Started 8m  │   Queued by: Bob                             │
│               │                                              │
└───────────────┴──────────────────────────────────────────────┘

9.3.3 Parallélisme et concurrence

9.3.3.1 Plan Free vs Payant

Plan Free (organisation):
├─ Microsoft-hosted: 1 job parallèle gratuit (1800 min/mois)
├─ Self-hosted: 1 agent gratuit (illimité)
└─ Limite: 1 job à la fois

Plan Basic (payant):
├─ Microsoft-hosted: 1 job parallèle inclus + achat de parallélisme
├─ Self-hosted: Illimité
└─ Prix: ~$40/mois par job parallèle supplémentaire

9.3.4.1 Configuration du parallélisme dans un pipeline

# Exécuter jusqu'à 4 jobs en parallèle
strategy:
  parallel: 4

# OU : Matrice avec jobs parallèles
strategy:
  matrix:
    Ubuntu_Debug:
      imageName: 'ubuntu-latest'
      buildConfig: 'Debug'
    Ubuntu_Release:
      imageName: 'ubuntu-latest'
      buildConfig: 'Release'
    Windows_Debug:
      imageName: 'windows-latest'
      buildConfig: 'Debug'
    Windows_Release:
      imageName: 'windows-latest'
      buildConfig: 'Release'
  maxParallel: 2  # Limiter à 2 agents simultanés

9.3.5.1 Dépendances entre jobs

jobs:
- job: A
  displayName: 'Job A (immediate)'
  steps:
  - script: echo "Job A running"

- job: B
  displayName: 'Job B (depends on A)'
  dependsOn: A
  steps:
  - script: echo "Job B running after A"

- job: C
  displayName: 'Job C (depends on A)'
  dependsOn: A
  steps:
  - script: echo "Job C running after A (parallel with B)"

- job: D
  displayName: 'Job D (depends on B and C)'
  dependsOn:
  - B
  - C
  steps:
  - script: echo "Job D running after B and C complete"

Visualisation :

A ─────┬──▶ B ─────┐
       │            ├──▶ D
       └──▶ C ─────┘

9.3.6 Priorité des jobs

# Azure DevOps respecte l'ordre FIFO par défaut
# Vous pouvez influencer la priorité via :

# 1. Branch priority (via branch policies)
# 2. Queue time permissions
# 3. Dedicated agent pools par équipe

# Exemple: Pool dédié pour les releases
stages:
- stage: Build
  pool:
    name: 'Standard-Pool'  # Pool partagé
  jobs:
  - job: BuildJob
    steps:
    - script: echo "Build"

- stage: Deploy
  pool:
    name: 'Release-Pool'   # Pool dédié aux releases
  jobs:
  - deployment: DeployJob
    environment: Production
    strategy:
      runOnce:
        deploy:
          steps:
          - script: echo "Deploy"

9.3.7 Timeouts et annulations

# Timeout au niveau du job
jobs:
- job: BuildJob
  timeoutInMinutes: 60    # Annuler après 60 minutes
  cancelTimeoutInMinutes: 5  # Délai avant annulation forcée
  steps:
  - script: echo "Build"

# Timeout au niveau d'une tâche
steps:
- task: DotNetCoreCLI@2
  timeoutInMinutes: 30
  inputs:
    command: 'build'

Annulation automatique des PRs obsolètes :

pr:
  autoCancel: true  # Annuler les anciens builds PR quand un nouveau push arrive
  branches:
    include:
    - main

9.4 Les pipelines concurrents pour les agents hébergés

9.4.1 Comprendre le parallélisme Microsoft-hosted

Exemple avec 2 agents parallèles payants:

Timeline:
00:00  Job A1 démarre (Agent 1)
00:00  Job B1 démarre (Agent 2)
00:05  Job A1 termine
00:05  Job C1 démarre (Agent 1 libéré)
00:08  Job B1 termine
00:08  Job D1 démarre (Agent 2 libéré)
00:12  Job C1 termine
00:15  Job D1 termine

Total: 15 min avec 2 agents
VS: 30 min avec 1 seul agent

9.4.2 Optimiser l’utilisation des agents

9.4.2.1 1. Cache des dépendances

steps:
# Cache NuGet
- task: Cache@2
  displayName: 'Cache NuGet packages'
  inputs:
    key: 'nuget | "$(Agent.OS)" | **/*.csproj'
    restoreKeys: |
      nuget | "$(Agent.OS)"
    path: $(NUGET_PACKAGES)
  
# Cache npm
- task: Cache@2
  displayName: 'Cache npm packages'
  inputs:
    key: 'npm | "$(Agent.OS)" | frontend/package-lock.json'
    restoreKeys: |
      npm | "$(Agent.OS)"
    path: frontend/node_modules

# Cache Maven
- task: Cache@2
  displayName: 'Cache Maven packages'
  inputs:
    key: 'maven | "$(Agent.OS)" | **/pom.xml'
    restoreKeys: |
      maven | "$(Agent.OS)"
    path: $(HOME)/.m2/repository

# Cache pip
- task: Cache@2
  displayName: 'Cache pip packages'
  inputs:
    key: 'pip | "$(Agent.OS)" | requirements.txt'
    restoreKeys: |
      pip | "$(Agent.OS)"
    path: $(Pipeline.Workspace)/.pip

Impact du cache :

Sans cache:
├─ npm install: 3m 45s
├─ Build: 2m 30s
└─ Total: ~6m 15s

Avec cache:
├─ npm cache restore: 0m 15s
├─ npm install (delta): 0m 20s
├─ Build: 2m 30s
└─ Total: ~3m 05s

Gain: ~50%

9.4.4.1 2. Build incrémental

steps:
# Utiliser --no-restore et --no-build quand possible
- task: DotNetCoreCLI@2
  displayName: 'Restore (once)'
  inputs:
    command: 'restore'

- task: DotNetCoreCLI@2
  displayName: 'Build (no restore)'
  inputs:
    command: 'build'
    arguments: '--no-restore'  # Réutilise le restore précédent

- task: DotNetCoreCLI@2
  displayName: 'Test (no build)'
  inputs:
    command: 'test'
    arguments: '--no-build --no-restore'  # Réutilise le build précédent

- task: DotNetCoreCLI@2
  displayName: 'Publish (no build)'
  inputs:
    command: 'publish'
    arguments: '--no-build --no-restore'

9.4.5.1 3. Séparer les jobs de façon optimale

# ❌ Mauvais: Tout dans un seul job long
jobs:
- job: EverythingInOne
  steps:
  - script: echo "Build"        # 3 min
  - script: echo "Unit tests"   # 5 min
  - script: echo "Lint"         # 2 min
  - script: echo "Security"     # 4 min
  # Total: 14 min

# ✓ Bon: Jobs parallèles
jobs:
- job: Build
  steps:
  - script: echo "Build"        # 3 min

- job: UnitTests
  dependsOn: Build
  steps:
  - script: echo "Unit tests"   # 5 min ─┐
                                          │  Parallèle
- job: Lint
  dependsOn: Build              #         │
  steps:                        #         │
  - script: echo "Lint"         # 2 min ─┤
                                          │
- job: Security
  dependsOn: Build              #         │
  steps:                        #         │
  - script: echo "Security"     # 4 min ─┘
  
# Total: 3 min (Build) + 5 min (le plus long des parallèles) = 8 min
# Gain: ~43%

9.5 Ajouter des agents privés (Self-hosted)

9.5.1 Quand utiliser des agents privés ?

✅ Utiliser des agents privés si :

  • Accès à des ressources réseau privées (bases de données internes, NAS)
  • Logiciels spécifiques non disponibles sur les agents hébergés
  • Builds nécessitant du matériel spécifique (GPU, dongles)
  • Conformité réglementaire (données ne doivent pas quitter le réseau)
  • Builds fréquents → réduction des coûts
  • Builds nécessitant des performances élevées
  • Déploiement vers des environnements on-premises

❌ Éviter les agents privés si :

  • Petits projets avec peu de builds
  • Agents hébergés suffisants pour les besoins
  • Pas de ressources pour la maintenance

9.5.2 Installer un agent privé sur Windows

9.5.2.1 Étape 1 : Créer un agent pool

Azure DevOps → Organization Settings → Agent pools → Add pool

┌────────────────────────────────────────────────┐
│ Add agent pool                                 │
├────────────────────────────────────────────────┤
│                                                │
│ Pool type:                                     │
│ ● Self-hosted                                  │
│ ○ Azure virtual machine scale set              │
│                                                │
│ Name: *                                        │
│ ShopConnect-Private                            │
│                                                │
│ ☑ Grant access permission to all pipelines     │
│                                                │
│ [Create]                                       │
└────────────────────────────────────────────────┘

9.5.3.1 Étape 2 : Générer un PAT pour l’agent

Azure DevOps → User Settings → Personal Access Tokens → New Token

Name: ShopConnect-Agent-Token
Organization: All accessible
Expiration: 1 year
Scopes: Agent Pools (Read & manage)

[Create] → Copier le token

9.5.4.1 Étape 3 : Installer l’agent sur Windows

# 1. Créer le répertoire
mkdir C:\AzureDevOps\Agent
cd C:\AzureDevOps\Agent

# 2. Télécharger l'agent
# Azure DevOps → Organization Settings → Agent pools → ShopConnect-Private
# → New agent → Windows x64 → Télécharger

# 3. Extraire l'archive
Add-Type -AssemblyName System.IO.Compression.FileSystem
[System.IO.Compression.ZipFile]::ExtractToDirectory(
    "$env:USERPROFILE\Downloads\vsts-agent-win-x64-3.x.x.zip",
    "C:\AzureDevOps\Agent"
)

# 4. Configurer l'agent
.\config.cmd

# Réponses à l'assistant de configuration:
# Server URL: https://dev.azure.com/votre-organisation
# Authentication type: PAT
# PAT: [coller votre PAT]
# Agent pool: ShopConnect-Private
# Agent name: BUILDSERVER01
# Work folder: _work
# Run as a service: Y
# Service account: NT AUTHORITY\NETWORK SERVICE (ou compte de service dédié)

Configuration automatisée (silencieuse) :

# Installation silencieuse pour l'automatisation
.\config.cmd `
  --unattended `
  --url "https://dev.azure.com/votre-organisation" `
  --auth "pat" `
  --token "VOTRE_PAT" `
  --pool "ShopConnect-Private" `
  --agent "BUILDSERVER01" `
  --work "_work" `
  --runAsService `
  --windowsLogonAccount "NT AUTHORITY\NETWORK SERVICE"

9.5.6.1 Étape 4 : Installer l’agent sur Linux (Ubuntu)

# 1. Créer un utilisateur dédié pour l'agent
sudo useradd -m -s /bin/bash azureagent
sudo usermod -aG docker azureagent  # Si Docker requis

# 2. Créer le répertoire
sudo mkdir -p /opt/azure-devops-agent
sudo chown azureagent:azureagent /opt/azure-devops-agent
cd /opt/azure-devops-agent

# 3. Télécharger et extraire l'agent
AGENT_VERSION="3.236.1"
sudo -u azureagent curl -O \
  "https://vstsagentpackage.azureedge.net/agent/${AGENT_VERSION}/vsts-agent-linux-x64-${AGENT_VERSION}.tar.gz"

sudo -u azureagent tar xzf vsts-agent-linux-x64-${AGENT_VERSION}.tar.gz
rm vsts-agent-linux-x64-${AGENT_VERSION}.tar.gz

# 4. Installer les dépendances
sudo ./bin/installdependencies.sh

# 5. Configurer l'agent
sudo -u azureagent ./config.sh \
  --unattended \
  --url "https://dev.azure.com/votre-organisation" \
  --auth "pat" \
  --token "VOTRE_PAT" \
  --pool "ShopConnect-Private" \
  --agent "LINUX-BUILD-01" \
  --work "_work"

# 6. Installer comme service systemd
sudo ./svc.sh install azureagent
sudo ./svc.sh start

# Vérifier le statut
sudo ./svc.sh status

Fichier systemd généré :

# /etc/systemd/system/vsts.agent.votre-organisation.ShopConnect-Private.LINUX-BUILD-01.service

[Unit]
Description=Azure Pipelines Agent (votre-organisation.ShopConnect-Private.LINUX-BUILD-01)
After=network.target

[Service]
ExecStart=/opt/azure-devops-agent/runsvc.sh
User=azureagent
WorkingDirectory=/opt/azure-devops-agent
KillMode=process
KillSignal=TERM
TimeoutStopSec=10min

[Install]
WantedBy=multi-user.target

9.5.8.1 Étape 5 : Installer sur macOS

# 1. Créer le répertoire
mkdir ~/azure-devops-agent
cd ~/azure-devops-agent

# 2. Télécharger l'agent (Apple Silicon M1/M2)
curl -O "https://vstsagentpackage.azureedge.net/agent/3.236.1/vsts-agent-osx-arm64-3.236.1.tar.gz"
tar xzf vsts-agent-osx-arm64-3.236.1.tar.gz

# 3. Configurer
./config.sh \
  --unattended \
  --url "https://dev.azure.com/votre-organisation" \
  --auth "pat" \
  --token "VOTRE_PAT" \
  --pool "ShopConnect-Private" \
  --agent "MACBUILD-01"

# 4. Installer comme service launchd
./svc.sh install
./svc.sh start

9.5.9 Configuration avancée des agents

9.5.9.1 Capabilities (Capacités)

Les capabilities permettent de router les jobs vers les bons agents.

Agent → Capabilities → + Add capability

System capabilities (automatiques):
├─ Agent.OS: Windows_NT
├─ Agent.OSArchitecture: X64
├─ Agent.Version: 3.236.1
├─ dotnet: 8.0.x
├─ java: 17
├─ node.tool: 20.x
└─ docker: 24.0.x

User capabilities (ajoutées manuellement):
├─ GPU: NVIDIA-RTX4090
├─ SpecialLicense: Oracle
├─ Environment: Production
└─ Team: Frontend

9.5.10.1 Demands (Exigences) dans les pipelines

# Exiger des capabilities spécifiques
pool:
  name: 'ShopConnect-Private'
  demands:
  - GPU -equals NVIDIA-RTX4090      # GPU spécifique
  - SpecialLicense                   # Doit avoir cette capability
  - dotnet -equals 8.0.x             # Version .NET spécifique
  - Agent.OS -equals Windows_NT      # OS Windows uniquement

9.5.11.1 Proxy pour les agents derrière un pare-feu

# Configuration du proxy pour l'agent Linux
./config.sh \
  --url "https://dev.azure.com/votre-organisation" \
  --auth pat \
  --token "$PAT" \
  --pool "ShopConnect-Private" \
  --agent "PROXY-AGENT-01" \
  --proxyurl "http://proxy.contoso.com:8080" \
  --proxyusername "proxyuser" \
  --proxypassword "proxypass"

Configuration du proxy dans .proxybypass :

# /opt/azure-devops-agent/.proxybypass
# Exclure ces domaines du proxy
localhost
127.0.0.1
*.contoso.com
dev.azure.com
*.visualstudio.com

9.5.13 Maintenance des agents privés

9.5.13.1 Script de mise à jour automatique

#!/bin/bash
# update-agent.sh

AGENT_DIR="/opt/azure-devops-agent"
AGENT_NAME="LINUX-BUILD-01"
ORG_URL="https://dev.azure.com/votre-organisation"
PAT="$AZURE_DEVOPS_PAT"

echo "Checking for agent updates..."

# Obtenir la version actuelle
CURRENT_VERSION=$(cat $AGENT_DIR/bin/agent.version 2>/dev/null || echo "0.0.0")

# Obtenir la dernière version
LATEST_VERSION=$(curl -s \
  "https://api.github.com/repos/microsoft/azure-pipelines-agent/releases/latest" | \
  jq -r '.tag_name' | sed 's/v//')

echo "Current: $CURRENT_VERSION"
echo "Latest:  $LATEST_VERSION"

if [ "$CURRENT_VERSION" != "$LATEST_VERSION" ]; then
  echo "Update available! Updating..."
  
  # Arrêter le service
  sudo $AGENT_DIR/svc.sh stop
  
  # Télécharger la nouvelle version
  curl -O \
    "https://vstsagentpackage.azureedge.net/agent/${LATEST_VERSION}/vsts-agent-linux-x64-${LATEST_VERSION}.tar.gz"
  
  # Backup de la config
  cp $AGENT_DIR/.credentials $AGENT_DIR/.credentials.bak
  cp $AGENT_DIR/.agent $AGENT_DIR/.agent.bak
  
  # Extraire la nouvelle version
  tar xzf vsts-agent-linux-x64-${LATEST_VERSION}.tar.gz -C $AGENT_DIR
  
  # Redémarrer le service
  sudo $AGENT_DIR/svc.sh start
  
  echo "✓ Agent updated to $LATEST_VERSION"
else
  echo "✓ Agent is up to date"
fi

9.5.14.1 Health check des agents

# health-check-agents.ps1

$Organization = "votre-organisation"
$PAT = $env:AZURE_DEVOPS_PAT
$base64 = [Convert]::ToBase64String([Text.Encoding]::ASCII.GetBytes(":$PAT"))
$headers = @{ Authorization = "Basic $base64" }

# Récupérer tous les pools
$pools = Invoke-RestMethod `
    -Uri "https://dev.azure.com/$Organization/_apis/distributedtask/pools?api-version=7.0" `
    -Headers $headers

Write-Host "=== Agent Pool Health Report ===" -ForegroundColor Cyan
Write-Host "Date: $(Get-Date)" -ForegroundColor Gray
Write-Host ""

foreach ($pool in $pools.value) {
    # Récupérer les agents de ce pool
    $agents = Invoke-RestMethod `
        -Uri "https://dev.azure.com/$Organization/_apis/distributedtask/pools/$($pool.id)/agents?includeCapabilities=false&api-version=7.0" `
        -Headers $headers
    
    Write-Host "Pool: $($pool.name)" -ForegroundColor Yellow
    
    $online  = ($agents.value | Where-Object { $_.status -eq "online"  }).Count
    $offline = ($agents.value | Where-Object { $_.status -eq "offline" }).Count
    $busy    = ($agents.value | Where-Object { $_.assignedRequest -ne $null }).Count
    $idle    = $online - $busy
    
    Write-Host "  Total:   $($agents.value.Count)"
    Write-Host "  Online:  $online  (Idle: $idle, Busy: $busy)"
    
    if ($offline -gt 0) {
        Write-Host "  Offline: $offline ⚠️" -ForegroundColor Red
        $agents.value | Where-Object { $_.status -eq "offline" } | ForEach-Object {
            Write-Host "    - $($_.name)" -ForegroundColor Red
        }
    }
    Write-Host ""
}

9.5.15 Scale Set Agents (Agents auto-scalables)

Configuration:
Azure DevOps → Organization Settings → Agent pools → Add pool

Pool type: Azure virtual machine scale set
Azure subscription: Azure-ShopConnect
Virtual machine scale set: shopconnect-buildagents-vmss
Name: ShopConnect-ScaleSet

Options:
├─ Automatically tear down virtual machines: ☑
├─ Maximum number of virtual machines: 10
├─ Minimum number of agents on standby: 1
└─ Delay in minutes before deleting excess agents: 30

Créer le VMSS :

# Créer une image de base pour les agents
az vmss create \
  --resource-group shopconnect-rg \
  --name shopconnect-buildagents-vmss \
  --image Ubuntu2204 \
  --vm-sku Standard_D4s_v3 \
  --instance-count 0 \
  --disable-overprovision \
  --upgrade-policy-mode manual \
  --single-placement-group false \
  --platform-fault-domain-count 1 \
  --load-balancer "" \
  --admin-username azureagent \
  --generate-ssh-keys

# Script cloud-init pour configurer l'agent
cat > cloud-init-agent.yml << 'EOF'
#cloud-config
package_update: true
packages:
  - docker.io
  - dotnet-sdk-8
  - nodejs
  - npm
  - openjdk-17-jdk

runcmd:
  - mkdir /opt/azure-agent
  - cd /opt/azure-agent
  - curl -LO https://vstsagentpackage.azureedge.net/agent/3.236.1/vsts-agent-linux-x64-3.236.1.tar.gz
  - tar xzf vsts-agent-linux-x64-3.236.1.tar.gz
  - ./bin/installdependencies.sh
  - useradd -m -s /bin/bash azpagent
  - chown -R azpagent:azpagent /opt/azure-agent
  - usermod -aG docker azpagent
EOF

9.6 Travaux Pratiques

TP8 : Gérer la file d’attente et utiliser des agents privés

9.7 Synthèse du Module 8

9.7.1 Points clés à retenir

✅ Architecture des agents

  • Agents hébergés (Microsoft) : clé en main, éphémères
  • Agents privés (self-hosted) : persistants, personnalisables
  • Scale Set Agents : élastiques, idéal pour les grandes charges

✅ File d’attente

  • Jobs dispatched par ordre FIFO
  • Parallélisme selon le plan (gratuit = 1 job)
  • Visibilité complète dans l’interface
  • Timeout et annulation automatiques

✅ Agents privés

  • Installation sur Windows, Linux, macOS, Docker
  • Capabilities pour le routage des jobs
  • Gestion via PAT ou service accounts
  • Mise à jour et maintenance

✅ Optimisations

  • Cache des dépendances (NuGet, npm, pip, Maven)
  • Build incrémental (–no-restore, –no-build)
  • Jobs parallèles
  • Scale Set pour l’élasticité

9.8 Ressources complémentaires

9.8.1 Documentation

9.8.2 Outils

10 TP Final