Intégration continue et Azure DevOps
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
Les principes, objectifs
et avantages de l’intégration continue
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.
Principes
fondamentaux
![]()
Les 5 principes clés :
- Un dépôt unique : Tout le code source est
centralisé dans un seul référentiel
- Automatisation du build : Chaque commit
déclenche une construction automatique
- Tests automatiques : Des tests sont exécutés
à chaque intégration
- Commits fréquents : Les développeurs
intègrent leur code quotidiennement
- Feedback rapide : L’équipe est immédiatement
informée des problèmes
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 |
Avantages de
l’intégration continue
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
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
Le cycle de
l’intégration continue
![]()
Les différents composants
nécessaires pour faire de l’intégration continue
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 │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
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. 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'
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
/__________________\
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
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)
6. Outils de monitoring
et notification
Monitoring :
- Application Insights (Azure)
- Prometheus
- Grafana
- ELK Stack (Elasticsearch, Logstash, Kibana)
Notifications :
- Email
- Slack
- Microsoft Teams
- SMS
Écosystème
complet
![]()
Les concepts d’Azure
DevOps
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│ │
│ │ │ │
│ └─────────┘ │
│ │
└────────────────────────────────────────────────────────────┘
Les 5 services
principaux
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. 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
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.
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
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
Concepts
transversaux
Organisation
Organisation (contoso.visualstudio.com)
├─ Projet 1 (Application Web)
│ ├─ Boards
│ ├─ Repos
│ ├─ Pipelines
│ ├─ Test Plans
│ └─ Artifacts
├─ Projet 2 (Application Mobile)
└─ Projet 3 (Microservices)
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
La gestion de projet avec
Azure DevOps
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 |
Processus
Agile/Scrum
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 │
└─────┘ └─────┘ └─────┘
Cycle de vie d’une
User Story
![]()
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.
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 |
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
Les différents acteurs
intervenant avec Azure DevOps
Rôles et
responsabilités
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. 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
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
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
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
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é
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
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
Création et configuration
d’un nouveau projet
Prérequis
- Compte Azure DevOps (gratuit jusqu’à 5 utilisateurs)
- Organisation créée
- Droits d’administrateur sur l’organisation
Étapes de création
Étape 1 : Accéder à
Azure DevOps
- Se connecter à https://dev.azure.com
- Sélectionner votre organisation ou en créer une nouvelle
- Cliquer sur “New Project”
É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 :
Visibility
- Private : Uniquement les membres invités
(recommandé)
- Public : Accessible à tous (open source)
Version Control
- Git : Recommandé pour sa flexibilité
- TFVC : Pour compatibilité avec systèmes
existants
Work Item Process
- Agile : Équipes agiles standard
- Scrum : Équipes Scrum strictes
- Basic : Projets simples
- CMMI : Projets avec gouvernance
Étape 3 :
Configuration initiale du projet
Une fois le projet créé, configurer :
- Area Paths (structure organisationnelle)
MonApplicationWeb
├─ Frontend
│ ├─ UI
│ └─ UX
├─ Backend
│ ├─ API
│ └─ Database
└─ Infrastructure
- 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
└─ ...
Teams
- Créer les équipes nécessaires
- Assigner les area paths
- Configurer les iterations
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
Gestion des droits
d’accès au projet
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
│ │ └─────────────────────────┘ │ │
│ └─────────────────────────────────┘ │
└─────────────────────────────────────────┘
Groupes de sécurité
prédéfinis
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 |
Groupes spécifiques
:
- Endpoint Administrators : Gestion des service
connections
- Release Administrators : Gestion des
releases
- [Team] Team Members : Membres d’une équipe
spécifique
Configuration des
permissions
Accès via l’interface
:
- Project Settings →
Permissions
- Sélectionner un groupe
- 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 │ ✓ │
└────────────────────────────────┴────────┘
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 |
✗ |
✗ |
✗ |
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 │
│ │
└─────────────────────────────────────────────┘
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
Bonnes pratiques de
sécurité
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. 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)
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
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
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
Ressources
complémentaires
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
Le contrôleur de code source
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
Présentation de Team
Foundation Version Control (TFVC)
Qu’est-ce que TFVC
?
Team Foundation Version Control est un système
de contrôle de version centralisé développé par
Microsoft.
Architecture
centralisée vs distribuée
![]()
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 |
Concepts clés de
TFVC
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)
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. Cycle de vie
TFVC
![]()
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)
Commandes TFVC
essentielles
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 |
|
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
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
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)
Utilisation de Git dans
Visual Studio
Installation et
configuration
Prérequis
- Visual Studio 2019/2022 (Community,
Professional ou Enterprise)
- Git for Windows (inclus dans Visual
Studio)
- Compte Azure DevOps avec accès au projet
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
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
Connexion à Azure
DevOps depuis Visual Studio
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] │
│ │
└─────────────────────────────────────────┘
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
Interface Git dans
Visual Studio
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 │
│ │
└─────────────────────────────────────────────────────────────┘
Workflow Git dans
Visual Studio
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é)
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. 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 |
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] │
│ │
└─────────────────────────────────────────┘
Opérations Git
courantes dans Visual Studio
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
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
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]
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"
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
Utilisation de Git avec
Azure DevOps
Architecture Git dans
Azure DevOps
![]()
Cloner un repository
Azure Repos
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
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
Méthode 3 : Via
Visual Studio
Voir section 2.2 - “Connexion à Azure DevOps depuis Visual
Studio”
Authentification
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
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
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...
Branches stratégiques
Git
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
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
Configuration des
Branch Policies dans Azure DevOps
Accès aux
policies
Azure DevOps → Repos → Branches → [...] sur 'main' → Branch policies
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 |
Opérations Git
avancées
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}
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
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
# 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
Conventions de
nommage
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
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"
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)
Méthodes de
clonage
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)
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. Clone via Visual
Studio
Voir section 2.2 - “Connexion à Azure DevOps depuis Visual
Studio”
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
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
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
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
Troubleshooting du
clonage
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
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
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
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
Ressources
complémentaires
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
Mettre en place des tests
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
Plan de test et tests
fonctionnels
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.
![]()
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
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 |
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 │
│ │
└────────────────────────────────────────────────────────────┘
Créer un plan de test
dans Azure DevOps
É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]
É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]
É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
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)
Exécuter des tests
manuels
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 |
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!
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
Mesurer la qualité
avec des métriques
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 │
│ │
└────────────────────────────────────────────────────────┘
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) |
Gestion des bugs et
feedbacks
Cycle de vie d’un
bug
![]()
É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é |
Créer un bug de
qualité
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.
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 │
│ │
└────────────────────────────────────────────────┘
Niveaux de priorité et
sévérité
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 |
Workflow de gestion des
bugs
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
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"
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é
Gestion des feedbacks
utilisateurs
Sources de
feedback
![]()
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
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
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% │
│ │
└──────────────────────────────────────────────────────────┘
Test de charge dans le
Cloud
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.
![]()
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) │
└───────────────────┘
Créer un test de charge
avec JMeter
É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"}
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]
Analyser les
résultats
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 │
│ │
└────────────────────────────────────────────────────────────┘
Métriques
importantes
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
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
3. Error Rate (Taux
d’erreur)
Formule: Error Rate = (Errors / Total Requests) × 100%
Seuils:
├─ Production: < 0.1%
├─ Acceptable: < 1%
├─ Warning: 1-5%
└─ Critical: > 5%
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!"
Bonnes pratiques des
tests de charge
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
2. Ramp-up
progressif
❌ Mauvais: 0 → 1000 users instantanément
✓ Bon: Montée progressive
Users
1000 │ ▄▀▀▀▀▀▀▀▀
│ ▄▀▀
│ ▄▀▀
500 │ ▄▀▀
│ ▄▀▀
│ ▄▀▀
0 └──▀▀────────────────────────▶ Time
0 5 10 15 (minutes)
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. 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
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é
Ressources
complémentaires
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
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
Créer une nouvelle
définition de “build”
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.
![]()
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 |
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 │
│ │
└─────────────────────────────────────────────────────────┘
Créer un pipeline avec
Classic Editor
Étape 1 : Accéder à
Pipelines
Azure DevOps → Pipelines → Create Pipeline → Use the classic editor
É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] │
└────────────────────────────────────────────────┘
É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] │
└────────────────────────────────────────────────┘
É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] │
└──────────────────────────────────────────────────────────┘
Créer un pipeline YAML
(Recommandé)
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
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'
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
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]
Variables dans les
pipelines
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'
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'
Ajouter des tâches à un
build
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'
Catalogue de tâches
courantes
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
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
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'
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. 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
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'
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
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')
)
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
Compilation .NET
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'
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
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'
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'
Lancer les tests
unitaires
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
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'
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)
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"'
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'
Types de déclencheurs
(Triggers)
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*
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
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
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. Pipeline Trigger
(Dépendance entre pipelines)
# Pipeline A déclenche Pipeline B
resources:
pipelines:
- pipeline: upstream-build
source: 'CI-Build'
trigger:
branches:
include:
- main
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
Automatisation des builds
et des tests
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.
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)"
}
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)'
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
Ressources
complémentaires
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
Les release et leurs déploiements
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)
Créer une nouvelle
release
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 |
Types de Release
Pipelines
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 │
│ │
└────────────────────────────────────────────────────────┘
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"
Créer un Classic
Release Pipeline
É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
É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
Artifacts → Continuous deployment trigger (éclair ⚡)
┌────────────────────────────────────────────────┐
│ Continuous deployment trigger │
├────────────────────────────────────────────────┤
│ │
│ ☑ Enabled │
│ │
│ Build branch filters: │
│ ┌────────────────────────────────────────┐ │
│ │ Include │ │
│ │ ┌────────────────────────────────────┐ │ │
│ │ │ main │ │ │
│ │ └────────────────────────────────────┘ │ │
│ │ [+ Add] │ │
│ └────────────────────────────────────────┘ │
│ │
│ [Save] │
└────────────────────────────────────────────────┘
Créer un environnement
YAML Multi-Stage
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]
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'
Définir les tâches d’une
release
Types de tâches de
déploiement
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)"
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
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'
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)
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. 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
Tâches de pré et
post-déploiement
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
}
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'
Configuration des
variables
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'
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] ▼
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)"
Prévoir une intervention
manuelle lors d’un déploiement
Approbations
manuelles
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] │
└────────────────────────────────────────────────┘
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"
Gates (Portes
automatiques)
Les gates sont des vérifications automatiques
avant ou après le déploiement.
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
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] │
└────────────────────────────────────────────────┘
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')
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] │
└────────────────────────────────────────────────┘
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
Créer un Task
Group
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] │
└────────────────────────────────────────────────┘
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
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
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]
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'
Stratégies de
déploiement
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
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 \
# ...
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"
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"
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
Ressources
complémentaires
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
Validation et déclenchement des déploiements
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
Workflow d’approbation
complet
![]()
Configuration avancée
des approbations
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
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
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.
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] │
└────────────────────────────────────────────────┘
Processus d’approbation
en pratique
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] │
│ │
└──────────────────────────────────────────────────────────┘
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]
Automatisation des
déploiements
Stratégies de
déclenchement automatique
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"
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)
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
}
}
}'
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"
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'
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"
Conditions dans les
pipelines
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"
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"
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)"
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')
)
Expressions de
condition avancées
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')
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/'))
)
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] │
└────────────────────────────────────────────────┘
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
Monitoring et
notifications des déploiements
Notifications
automatiques
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
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'
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
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
Gérer différentes
versions dans différents environnements
Concepts de
versioning
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 |
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'
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)
Gestion multi-versions
avec Azure Pipelines
Stratégie de
branching et versioning
![]()
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'
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"
}
}
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)"
Définition des variables
d’environnement
Architecture des
variables
![]()
Niveaux de
variables
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'
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 │
└────────────────────────────────────┴──────────────────────┘
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)"
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
Variables de
substitution dans les fichiers de config
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)
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)"
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)"
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]"
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.
Gestion des erreurs
robuste
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'
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'
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)
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"
Collecte et analyse des
logs
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)'
- 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)"
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
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"
}
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%) ✅ │
│ │
└──────────────────────────────────────────────────────────────┘
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
Fonctionnement de l’agent pool
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
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.
![]()
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 |
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
Gestion de la file
d’attente
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 │
│ │ │
└───────────────┴──────────────────────────────────────────────┘
Parallélisme et
concurrence
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
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
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 ─────┘
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"
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
Les pipelines concurrents
pour les agents hébergés
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
Optimiser l’utilisation
des agents
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%
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'
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%
Ajouter des agents privés
(Self-hosted)
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
Installer un agent
privé sur Windows
É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] │
└────────────────────────────────────────────────┘
É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
É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"
É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
É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
Configuration avancée
des agents
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
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
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
Maintenance des agents
privés
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
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 ""
}
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
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é
Ressources
complémentaires
9.3.1 Comment fonctionne la file d’attente