À la fin de ce module, vous serez capable de :
DevOps est une approche culturelle et technique qui vise à unifier le développement logiciel (Dev) et l’exploitation des systèmes informatiques (Ops). Cette méthodologie favorise la collaboration entre les équipes traditionnellement cloisonnées, avec pour objectif d’automatiser et d’optimiser le processus de livraison de logiciels.

| Critère | Faible (1) | Moyen (2) | Élevé (3) |
|---|---|---|---|
| Valeur métier | Impact limité | Impact significatif | Impact stratégique |
| Fréquence des changements | Peu fréquente | Mensuelle | Hebdomadaire ou quotidienne |
| Complexité technique | Très complexe | Modérée | Simple |
| Ouverture de l’équipe | Résistance | Neutre | Enthousiaste |
| Dépendances externes | Nombreuses | Quelques-unes | Peu ou aucune |
Conseil : Commencer par un projet ayant un score total entre 10 et 13
| Rôle | Responsabilités |
|---|---|
| DevOps Engineer | Automatisation des pipelines CI/CD, scripting, infrastructure as code |
| Product Owner | Priorisation du backlog, définition de la valeur métier |
| Scrum Master / Coach Agile | Facilitation des processus, suppression des obstacles |
| Developer | Développement des fonctionnalités, tests unitaires |
| QA Engineer | Assurance qualité, tests automatisés |
| Site Reliability Engineer | Fiabilité des systèmes, observabilité, gestion des incidents |
| Security Engineer | Sécurité intégrée (DevSecOps), tests de sécurité |
Petite organisation (< 50 personnes) - Équipes polyvalentes avec des compétences DevOps partagées - Focus sur l’automatisation des tâches répétitives - Utilisation d’outils cloud pour réduire la charge opérationnelle
Organisation moyenne (50-500 personnes) - Modèle intégré avec des champions DevOps dans chaque équipe - Communauté de pratique pour standardiser les approches - Équipe centrale légère pour gérer la plateforme commune
Grande organisation (> 500 personnes) - Équipe plateforme DevOps qui fournit des services aux équipes produit - Communautés de pratique organisées par domaine technique - Centre d’excellence DevOps pour la gouvernance et l’innovation
Avant de démarrer une transformation DevOps, il est essentiel d’évaluer le niveau de maturité actuel de l’organisation selon plusieurs dimensions :
| Dimension | Niveau initial | Niveau géré | Niveau défini | Niveau mesuré | Niveau optimisé |
|---|---|---|---|---|---|
| Culture & Collaboration | Silos fonctionnels | Communication ponctuelle | Collaboration régulière | Équipes intégrées | Culture unifiée |
| Automatisation | Processus manuels | Automatisation basique | CI/CD partiellement automatisé | Pipeline complet automatisé | Optimisation continue |
| Architecture | Monolithique | Composants découplés | Microservices partiels | Architecture cloud-native | Auto-scaling et résilience |
| Surveillance & Feedback | Réactif aux incidents | Monitoring basique | Monitoring avancé | Télémétrie complète | Amélioration prédictive |
| Défi | Solutions |
|---|---|
| Résistance au changement | Communication claire des avantages, formations, implication des parties prenantes |
| Dette technique | Allocation de temps pour le remboursement, refactoring progressif |
| Silos organisationnels | Réorganisation des équipes, objectifs communs, espaces de travail partagés |
| Manque de compétences | Formation continue, recrutement ciblé, partenariats externes |
| Complexité des outils | Démarrer simple, ajouter progressivement, standardiser |
Métriques techniques
Métriques métier
Le contrôle de code source (ou gestion de version) est un système qui enregistre les modifications apportées à un fichier ou un ensemble de fichiers au fil du temps, permettant de rappeler des versions spécifiques ultérieurement.
Objectifs principaux
Systèmes centralisés (CVCS)
Systèmes distribués (DVCS)
| Fonctionnalité | Git | TFVC | SVN | Mercurial |
|---|---|---|---|---|
| Type | Distribué | Centralisé | Centralisé | Distribué |
| Performances | Excellentes | Bonnes | Moyennes | Très bonnes |
| Branching | Léger et rapide | Plus lourd | Moyen | Léger |
| Taille du dépôt local | Complète | Partielle | Partielle | Complète |
| Courbe d’apprentissage | Raide | Moyenne | Douce | Moyenne |
| Support grands fichiers | Limité (LFS) | Bon | Bon | Moyen (LFS) |
| Intégration Azure DevOps | Excellente | Native | Possible | Limitée |
Présentation
Fonctionnalités clés
Configuration initiale
# Cloner un dépôt Azure Repos
git clone https://dev.azure.com/organisation/projet/_git/repository
# Configurer les identifiants
git config --global credential.helper cache
# Créer une branche et pousser les modifications
git checkout -b feature/nouvelle-fonctionnalite
git add .
git commit -m "Ajout de la nouvelle fonctionnalité"
git push -u origin feature/nouvelle-fonctionnalitePrésentation
Fonctionnalités clés
Configuration initiale
# Cloner un dépôt GitHub
git clone https://github.com/utilisateur/repository.git
# Configurer l'authentification (par exemple avec un token personnel)
git config --global credential.helper store
# Créer un fork et contribuer
# (via l'interface web GitHub) Fork du projet
git clone https://github.com/votre-utilisateur/repository-forked.git
git checkout -b fix/correction-bug
git add .
git commit -m "Correction du bug #123"
git push -u origin fix/correction-bug
# Créer une Pull Request via l'interface GitHub| Aspect | Azure Repos | GitHub |
|---|---|---|
| Focus | Développement d’entreprise | Collaboration ouverte |
| Intégration | Écosystème Azure DevOps | Large écosystème d’outils tiers |
| Contrôle d’accès | Très granulaire (Azure AD) | Basé sur les organisations et équipes |
| CI/CD | Azure Pipelines | GitHub Actions |
| Aspect | Azure Repos | GitHub |
|---|---|---|
| Visibilité | Généralement privé | Public par défaut, options privées |
| Modèle économique | Par utilisateur/mois | Gratuit (public), par utilisateur (privé) |
| Taille des fichiers | Jusqu’à 2GB avec TFVC | Limite de 100MB par fichier (Git LFS) |
Stratégie de branchement
main + branches de fonctionnalités éphémèresmain, develop, feature/*, release/*, hotfix/*Standards de qualité
Automatisation
Accéder à Azure Boards
Choisir une méthodologie Agile
Configurer les zones (Areas)
Accédez à Paramètres du projet > Boards > Classification > Areas
Créez une structure qui reflète les composants de votre application:
[Nom du Projet]
├── Frontend
├── Backend
│ ├── API
│ └── Database
└── InfrastructureConfigurer les itérations (Sprints)
Accédez à Paramètres du projet > Boards > Classification > Iterations
Créez vos sprints avec les dates appropriées:
[Nom du Projet]
├── Release 1
│ ├── Sprint 1 (JJ/MM/AAAA - JJ/MM/AAAA)
│ ├── Sprint 2 (JJ/MM/AAAA - JJ/MM/AAAA)
│ └── Sprint 3 (JJ/MM/AAAA - JJ/MM/AAAA)
└── Release 2
├── Sprint 4 (JJ/MM/AAAA - JJ/MM/AAAA)
└── Sprint 5 (JJ/MM/AAAA - JJ/MM/AAAA)Configurer les équipes
Définir les Epics (grandes initiatives)
Accédez à Boards > Backlogs > Epics
Créez 3-4 epics représentant les grandes fonctionnalités de votre produit
Exemple:
Epic 1: Authentification & Sécurité
Epic 2: Gestion des commandes
Epic 3: Tableau de bord utilisateur
Epic 4: Intégration des paiementsCréer les Features (fonctionnalités)
Accédez à Boards > Backlogs > Features
Créez des features rattachées à chaque epic
Exemple pour “Authentification & Sécurité”:
Feature 1: Inscription utilisateur
Feature 2: Connexion avec authentification à deux facteurs
Feature 3: Gestion des rôles et permissions
Feature 4: Réinitialisation de mot de passeDéfinir les User Stories / PBIs
Accédez à Boards > Backlogs > Stories / PBIs
Créez des stories détaillant les fonctionnalités
Utilisez le format: “En tant que [rôle], je veux [action] afin de [bénéfice]”
Exemple pour “Inscription utilisateur”:
Story 1: En tant que nouvel utilisateur, je veux créer un compte avec mon email afin d'accéder à l'application
Story 2: En tant que système, je veux valider le format de l'email afin d'assurer des données correctes
Story 3: En tant qu'administrateur, je veux voir les nouveaux inscrits afin de surveiller la croissanceDéfinir l’effort et la valeur métier
Personnaliser les colonnes Kanban
Accédez à Boards > Boards
Cliquez sur l’icône d’engrenage (paramètres)
Configurez les colonnes suivantes:
- Backlog (initial)
- Analysed
- In Progress (WIP limit: 3)
- Code Review (WIP limit: 2)
- Testing
- Done (final)Configurer les couloirs (swimlanes)
Dans les paramètres du tableau, accédez à “Swimlanes”
Créez les couloirs suivants:
- Expedite (pour les urgences)
- Standard (par défaut)
- Technical DebtTester le déplacement des cartes
Prioriser le Backlog
Planifier un Sprint
Définir la capacité de l’équipe
Créer des tâches détaillées
Lier les éléments de travail aux branches
type/ID-description-courtefeature/1234-user-registrationLier les commits aux éléments de travail
git commit -m "Ajout du formulaire d'inscription #1234"Créer une Pull Request liée
#ID ou AB#ID pour lier l’élémentObserver le tableau des liens
Créer des requêtes personnalisées
Configurer un dashboard
Analyser les métriques de cycle
Créer un rapport personnalisé
À la fin de ce module, vous serez capable de :
La structure d’un dépôt Git est fondamentale pour la maintenabilité et l’efficacité du développement, particulièrement dans les environnements d’entreprise. Voici les approches principales :
| Approche | Description | Avantages | Inconvénients |
|---|---|---|---|
| Monorepo | Un seul dépôt contenant tous les projets liés | • Visibilité complète • Refactoring atomique • Partage de code simplifié • CI/CD unifiée |
• Taille potentiellement importante • Performances réduites • Contrôle d’accès global |
| Approche | Description | Avantages | Inconvénients |
|---|---|---|---|
| Multirepo | Plusieurs dépôts distincts | • Séparation claire • Performance optimisée • Contrôle d’accès précis * Équipes autonomes |
• Dépendances complexes • Synchronisation difficile • Contexte fragmenté |
Pour un projet d’entreprise typique, voici une structure de répertoires recommandée :
/
├── src/ # Code source principal
│ ├── service1/ # Code des différents services
│ ├── service2/
│ └── common/ # Code partagé
│ ├── models/
│ └── utils/
├── tests/ # Tests unitaires, d'intégration, end-to-end
│ ├── unit/
│ ├── integration/
│ └── e2e/
├── docs/ # Documentation
│ ├── architecture/
│ ├── api/
│ └── guides/
├── build/ # Scripts et configurations de build
│ ├── ci/
│ └── docker/
├── deploy/ # Scripts et templates de déploiement
│ ├── kubernetes/
│ ├── terraform/
│ └── arm-templates/
├── tools/ # Outils et scripts utilitaires
├── .gitignore # Fichiers à ignorer par Git
├── .editorconfig # Configuration d'éditeur cohérente
├── README.md # Documentation principale
└── LICENSE # Licence du projet
Les dépôts Git ne sont pas optimisés pour les fichiers binaires volumineux. Voici comment les gérer :
Git LFS (Large File Storage)
git lfs installgit lfs track "*.psd"git lfs trackgit add, git commit, etc.Configuration dans Azure Repos
# Installation de Git LFS
git lfs install
# Configuration sur Azure Repos
git config --global lfs.contenttype application/vnd.git-lfs+json
git config --global http.version HTTP/1.1
# Tracking des fichiers binaires
git lfs track "*.zip" "*.psd" "*.bin"
git add .gitattributes
git commit -m "Configuration de Git LFS"Ne jamais stocker de secrets dans Git
Utiliser des variables d’environnement ou Azure Key Vault
Pour les configurations sensibles :
# Créer un modèle de fichier de configuration sans secrets
cp config.json config.template.json
# Ajouter le vrai fichier de configuration au .gitignore
echo "config.json" >> .gitignore/config
├── default.json # Configuration commune
├── development.json # Spécifique au développement
├── staging.json # Spécifique à la préproduction
└── production.json # Spécifique à la productionPlusieurs stratégies de branchement existent, chacune adaptée à des contextes différents :
Particulièrement adapté aux projets avec des cycles de release planifiés :
main (production)
↑
release branches
↑
develop
↗ ↖
feature hotfix
branches branches
Adapté aux équipes pratiquant l’intégration continue et le déploiement continu :
main (trunk)
↗ ↖
feature hotfix
branches branches (courte durée)
Simplifié, idéal pour les déploiements continus :
main
↑
feature branches
Pour sécuriser vos branches importantes :
Accéder aux politiques de branches
Configurer les exigences minimales
• Nombre minimum d'approbateurs : 1 ou 2
• Réinitialiser les votes lors de nouvelles modifications : Activé
• Permettre aux auteurs de s'approuver eux-mêmes : DésactivéExiger des builds réussies
Définir des validateurs de checklists
Créer une checklist de validation :
- Le code est-il testé ?
- La documentation est-elle à jour ?
- Les exigences de sécurité sont-elles respectées ?Limiter les types de merge
# Créer une nouvelle branche à partir de main
git checkout main
git pull
git checkout -b feature/nouvelle-fonctionnalite
# Garder une branche à jour avec sa source
git checkout feature/ma-branche
git fetch origin
git rebase origin/main
# Nettoyer les branches locales fusionnées
git branch --merged main | grep -v "main" | xargs git branch -d
# Créer une branche de release
git checkout main
git checkout -b release/1.0.0
# Tagguer une version
git tag -a v1.0.0 -m "Version 1.0.0"
git push origin v1.0.0
# Chercher dans l'historique qui a modifié une ligne
git blame path/to/file.js
# Voir l'historique graphique
git log --graph --oneline --all --decoratePrévenir les conflits
Résoudre un conflit de merge
# Lors d'un conflit pendant un merge
git status # Voir les fichiers en conflit
# Ouvrir chaque fichier en conflit, ils contiennent des marqueurs:
# <<<<<<< HEAD
# Version de votre branche
# =======
# Version de l'autre branche
# >>>>>>> feature/autre-branche
# Après résolution manuelle des conflits
git add .
git commit # Finaliser le mergeOutils de résolution de conflits
Les Pull Requests (PR) sont au cœur d’un workflow Git collaboratif, permettant de :
Créer une Pull Request
Structure d’une bonne description de PR
## Changements proposés
[Description concise des modifications]
## Éléments de travail liés
- AB#12345
## Type de changement
- [ ] Correction de bug
- [x] Nouvelle fonctionnalité
- [ ] Modification d'une fonctionnalité existante
## Checklist
- [x] Tests ajoutés/mis à jour
- [x] Documentation mise à jour
- [x] Vérifié sur les navigateurs cibles
## Notes pour les reviewers
[Instructions spécifiques pour tester]Gestion du processus de revue
Compléter une Pull Request
Pour renforcer la qualité et la standardisation :
Accéder aux paramètres
Configurer les exigences de base
• Nombre minimum d'approbateurs : 2
• Réinitialiser les approbations après modifications : Activé
• Permettre à l'auteur de s'approuver : DésactivéAjouter des validations automatiques
Configurer l’auto-complétion
.azuredevops à la racinepull_request_template.mdLes hooks Git sont des scripts déclenchés automatiquement lors d’événements Git spécifiques, permettant d’automatiser des tâches et de garantir la qualité du code.
.git/hooks/ (non versionné)Les hooks client sont des scripts exécutables (.sh ou .bat) placés dans le dossier .git/hooks/ :
pre-commit : Exécuté avant la création d’un commit
#!/bin/bash
# Exemple de hook pre-commit vérifiant le format du code
# Vérifier le formatage avec Prettier
npx prettier --check "src/**/*.{js,ts,jsx,tsx}"
if [ $? -ne 0 ]; then
echo "❌ Le code n'est pas correctement formaté. Exécutez 'npm run format'."
exit 1
fi
# Exécuter les linters
npm run lint
if [ $? -ne 0 ]; then
echo "❌ Erreurs de linting détectées."
exit 1
fi
exit 0prepare-commit-msg : Modifie le message de commit par défaut
#!/bin/bash
# Ajouter automatiquement l'ID du work item Azure DevOps
BRANCH_NAME=$(git symbolic-ref --short HEAD)
TICKET_NUMBER=$(echo $BRANCH_NAME | grep -o '[0-9]\+')
if [ -n "$TICKET_NUMBER" ]; then
echo "$(cat $1) [AB#$TICKET_NUMBER]" > $1
ficommit-msg : Valide le format du message de commit
#!/bin/bash
# Vérifier que le message de commit suit la convention
commit_msg=$(cat $1)
pattern="^(feat|fix|docs|style|refactor|perf|test|chore)(\(.+\))?: .{1,50}"
if ! [[ $commit_msg =~ $pattern ]]; then
echo "❌ Le message de commit ne suit pas la convention."
echo "Format attendu: type(scope): message"
echo "Types: feat, fix, docs, style, refactor, perf, test, chore"
exit 1
fipre-push : Exécuté avant la poussée des commits
#!/bin/bash
# Exécuter les tests avant de pousser
npm test
if [ $? -ne 0 ]; then
echo "❌ Les tests ont échoué. Corrigez-les avant de pousser."
exit 1
fiPour standardiser les hooks dans une équipe :
Utiliser Husky pour les hooks côté client
# Installation
npm install husky --save-dev
# Configuration dans package.json
{
"husky": {
"hooks": {
"pre-commit": "npm run lint && npm run test",
"commit-msg": "commitlint -E HUSKY_GIT_PARAMS"
}
}
}Stocker les hooks dans le dépôt
hooks à la racine#!/bin/bash
# install-hooks.sh
cp -r hooks/* .git/hooks/
chmod +x .git/hooks/*Azure DevOps offre des fonctionnalités similaires aux hooks serveur via :
La promotion de code est le processus par lequel le code passe d’un environnement à un autre (développement → test → préproduction → production) de manière contrôlée.
Promotion basée sur les branches
feature branches → develop → release → main
Promotion basée sur les tags
main (avec tags pour les versions)
Promotion basée sur les commits
main (avec sélection de commits spécifiques)
Branches protégées pour chaque environnement
Utiliser des release branches
# Créer une branche de release
git checkout develop
git checkout -b release/1.0.0
# Corrections sur la branche de release
git commit -m "fix: correction pour la release"
# Fusion dans main lorsque prêt
git checkout main
git merge release/1.0.0 --no-ff
# Tag de la version
git tag -a v1.0.0 -m "Version 1.0.0"
git push origin v1.0.0
# Report des corrections dans develop
git checkout develop
git merge release/1.0.0Pipeline de release multi-étapes
stages:
- stage: Dev
jobs:
- job: Deploy
steps:
- script: echo Deploying to Dev
- stage: Test
dependsOn: Dev
condition: succeeded()
jobs:
- job: Deploy
steps:
- script: echo Deploying to Test
- stage: Production
dependsOn: Test
condition: succeeded()
jobs:
- deployment: Deploy
environment: Production
strategy:
runOnce:
deploy:
steps:
- script: echo Deploying to ProductionConvention de versionnement sémantique
MAJOR.MINOR.PATCH (ex: 2.4.1)Commandes de gestion de tags
# Créer un tag annoté
git tag -a v1.2.3 -m "Version 1.2.3"
# Pousser les tags
git push origin --tags
# Lister les tags
git tag -l
# Extraire une version spécifique
git checkout v1.2.3Automatisation des versions avec GitVersion
GitVersion.yml à la racine du projetmode: ContinuousDelivery
branches:
main:
tag: ''
develop:
tag: beta
feature:
tag: alphasteps:
- task: GitVersion@5
inputs:
preferBundledVersion: false
- script: |
echo "Major: $(GitVersion.Major)"
echo "Minor: $(GitVersion.Minor)"
echo "Patch: $(GitVersion.Patch)"
echo "FullSemVer: $(GitVersion.FullSemVer)"Pipeline de déploiement continu
trigger:
branches:
include:
- develop
- release/*
- main
variables:
${{ if eq(variables['Build.SourceBranch'], 'refs/heads/develop') }}:
environment: Development
${{ if startsWith(variables['Build.SourceBranch'], 'refs/heads/release/') }}:
environment: Staging
${{ if eq(variables['Build.SourceBranch'], 'refs/heads/main') }}:
environment: Production
stages:
- stage: Build
jobs:
- job: BuildJob
steps:
- script: echo Building for $(environment)
- stage: Deploy
dependsOn: Build
jobs:
- deployment: DeployToEnvironment
environment: $(environment)
strategy:
runOnce:
deploy:
steps:
- script: echo Deploying to $(environment)Approbations pour les promotions
La gestion efficace des dépôts Git est essentielle pour maintenir la productivité et la sécurité des équipes.
Niveaux de permissions
Configurer les groupes de sécurité
Permissions critiques à surveiller
Exemple de configuration sécurisée
Main branch:
- Contributors: Read only
- Release Managers: Contribute
Feature branches:
- Contributors: Contribute
- Readers: Read onlyLes dépôts Git d’entreprise peuvent devenir volumineux. Voici comment les optimiser :
Maintenance régulière
# Vérifier la taille du dépôt
git count-objects -v -H
# Compresser la base de données Git
git gc --aggressive
# Supprimer les branches fusionnées
git branch --merged | grep -v "^*" | xargs git branch -dGestion des fichiers volumineux
.gitignoreOptimisation des clones
# Clone peu profond (historique récent uniquement)
git clone --depth=1 <repo-url>
# Clone d'une seule branche
git clone --single-branch --branch=main <repo-url>Migration entre systèmes de gestion de versions
# Migration de SVN vers Git
git svn clone <svn-repo-url> --authors-file=authors.txt <git-repo-name>
# Migration de TFVC vers Git
git-tf clone --deep <collection-url> $/TeamProject/PathArchivage de dépôts
git bundle create repo-archive.bundle --allScission de dépôts monolithiques
# Extraire un sous-dossier avec historique
git subtree split -P <prefix> -b <branch>
# Alternative avec git-filter-repo
git filter-repo --path <prefix> --subdirectory-filter <prefix>À la fin de cet atelier, les participants seront capables de :
AZ400-Git-WorkshopAtelier pour la certification AZ-400 - Contrôle de version avec GitPrivéeGitgit config --global user.name "Votre Nom"
git config --global user.email "votre.email@domaine.com"git config --global core.autocrlf true # Pour les utilisateurs Windows
git config --global init.defaultBranch main
git config --global pull.rebase falsegit config --listcd ~/Documents/Projets/ # Ou tout autre chemin de votre choix
git clone <URL_copiée>
cd AZ400-Git-Workshopgit statusmkdir src
mkdir docs
mkdir testsecho "# Projet AZ-400 Workshop\n\nCe projet est utilisé pour l'atelier Azure DevOps - Certification AZ-400." > README.mdgit add .
git commit -m "Initial commit: structure de base du projet"git push origin mainecho "console.log('Application de démonstration pour Azure DevOps');" > src/app.jsecho "# Documentation\n\nCe document contient la documentation pour l'application de démonstration." > docs/documentation.mdgit add src/app.js docs/documentation.md
git commit -m "Ajout des fichiers d'application et de documentation"
git push origin mainecho "# Fichiers et dossiers à ignorer\nnode_modules/\n.vscode/\n*.log\n.env\ntmp/\ndist/" > .gitignoregit add .gitignore
git commit -m "Ajout du fichier .gitignore"
git push origin maingit checkout -b feature/nouvelle-fonctionnaliteecho "// Module principale de l'application\nfunction main() {\n console.log('Application de démonstration pour Azure DevOps');\n console.log('Nouvelle fonctionnalité ajoutée');\n}\n\nmain();" > src/app.jsgit add src/app.js
git commit -m "Implémentation de la nouvelle fonctionnalité"
git push -u origin feature/nouvelle-fonctionnalitefeature/nouvelle-fonctionnalitemainAjout d'une nouvelle fonctionnalitéCette PR ajoute une nouvelle fonctionnalité à l'application principale.git checkout maingit pull origin maingit log --oneline --graph --decorate --all -n 10main, cliquez sur les points de suspension (…) et sélectionnez Stratégies de branchegit checkout -b bugfix/correction-erreurecho "// Module principale de l'application\nfunction main() {\n console.log('Application de démonstration pour Azure DevOps');\n console.log('Nouvelle fonctionnalité ajoutée - Bug corrigé');\n}\n\nmain();" > src/app.jsgit add src/app.js
git commit -m "Correction du bug dans la nouvelle fonctionnalité"
git push -u origin bugfix/correction-erreurgit checkout main
git pull
git checkout -b feature/equipe-aecho "# Projet AZ-400 Workshop\n\nCe projet est utilisé pour l'atelier Azure DevOps - Certification AZ-400.\n\n## Équipe A\nContribution de l'équipe A au projet." > README.mdgit add README.md
git commit -m "Ajout de la section Équipe A dans README"
git push -u origin feature/equipe-agit checkout main
git checkout -b feature/equipe-becho "# Projet AZ-400 Workshop\n\nCe projet est utilisé pour l'atelier Azure DevOps - Certification AZ-400.\n\n## Fonctionnalités\nListe des fonctionnalités implémentées par l'équipe B." > README.mdgit add README.md
git commit -m "Ajout de la section Fonctionnalités dans README"
git push -u origin feature/equipe-bFusionnez la branche feature/equipe-a dans main via une PR dans Azure DevOps
Essayez de fusionner feature/equipe-b dans main et observez le conflit
Pour résoudre le conflit localement :
git checkout main
git pull
git checkout feature/equipe-b
git merge main# Projet AZ-400 Workshop
Ce projet est utilisé pour l'atelier Azure DevOps - Certification AZ-400.
## Équipe A
Contribution de l'équipe A au projet.
## Fonctionnalités
Liste des fonctionnalités implémentées par l'équipe B.git add README.md
git commit -m "Résolution du conflit entre les équipes A et B"
git push origin feature/equipe-bAZ400-Git-Workshoptrigger:
- main
- feature/*
pool:
vmImage: 'ubuntu-latest'
steps:
- script: echo "Exécution du build suite à un commit Git"
displayName: 'Run build script'git checkout main
git pull
git checkout -b feature/integration-ci-cdmkdir -p tests/unit
echo "console.log('Test unitaire factice');\nconsole.log('Tous les tests ont réussi!');" > tests/unit/test.jsgit add tests/unit/test.js
git commit -m "Ajout de tests unitaires factices"
git push -u origin feature/integration-ci-cdgit checkout main
git pull
git tag -a v1.0.0 -m "Version 1.0.0 - Premier livrable"
git push origin v1.0.0git checkout -b feature/rebase-demoecho "// Fichier de configuration\nconst config = {\n env: 'development',\n debug: true\n};\n\nmodule.exports = config;" > src/config.js
git add src/config.js
git commit -m "Ajout du fichier de configuration"
echo "// Utilitaires\nfunction formatDate(date) {\n return date.toISOString();\n}\n\nmodule.exports = {\n formatDate\n};" > src/utils.js
git add src/utils.js
git commit -m "Ajout de fonctions utilitaires"git checkout main
echo "# Tests\n\nCe dossier contient les tests automatisés du projet." > tests/README.md
git add tests/README.md
git commit -m "Documentation des tests"
git push origin maingit checkout feature/rebase-demo
git rebase maingit push --force-with-lease origin feature/rebase-demogit checkout main
git checkout -b hotfix/urgent-fixecho "// Fichier avec correctif urgent\nconst fix = {\n applyPatch: () => console.log('Correctif appliqué')\n};\n\nmodule.exports = fix;" > src/hotfix.js
git add src/hotfix.js
git commit -m "Ajout d'un correctif urgent"git checkout main
git cherry-pick <hash_du_commit>
git push origin maingit log --pretty=format:"%h %ad | %s%d [%an]" --graph --date=shortgit checkout <hash_du_commit> -- README.mdgit diff --staged README.mdAzure Pipelines est un service cloud entièrement géré qui automatise la construction et le déploiement de vos applications. Il s’intègre avec GitHub, GitLab, Bitbucket, Azure Repos et d’autres systèmes de gestion de versions.
trigger:
- main
pool:
vmImage: 'ubuntu-latest'
steps:
- script: echo Hello, world!
displayName: 'Run a one-line script'@delete - Configuration via l’interface utilisateur d’Azure DevOps - Organisation en phases, jobs et tâches
Un pool d’agents est une collection d’agents disponibles pour exécuter des jobs.
Azure Pipelines (agents Microsoft)# Exemple d'installation sur Linux
./config.sh --url https://dev.azure.com/monorganisation --auth pat --token monPAT --pool MonPool
./svc.sh install
./svc.sh startpool:
name: MonPool
demands:
- docker
- npm# Exécution parallèle de jobs
jobs:
- job: Windows
pool:
vmImage: 'windows-latest'
steps:
- script: echo Hello from Windows
- job: Linux
pool:
vmImage: 'ubuntu-latest'
steps:
- script: echo Hello from Linux# Jobs avec dépendances
jobs:
- job: Build
steps:
- script: echo Building...
- job: Test
dependsOn: Build # Attend que Build soit terminé
steps:
- script: echo Testing...
- job: Deploy
dependsOn:
- Build
- Test # Attend que Build ET Test soient terminés
steps:
- script: echo Deploying...# Limitation des exécutions parallèles
pool:
vmImage: 'ubuntu-latest'
jobs:
- job: LimitedJob
strategy:
maxParallel: 2 # Limite à 2 exécutions en parallèleL’intégration continue est une pratique de développement logiciel où les membres d’une équipe intègrent fréquemment leur travail, généralement plusieurs fois par jour. Chaque intégration est vérifiée par un build automatisé pour détecter les erreurs le plus tôt possible.
trigger:
branches:
include:
- main
- feature/*
paths:
include:
- src/*
exclude:
- docs/*
pool:
vmImage: 'ubuntu-latest'
steps:
- task: DotNetCoreCLI@2
inputs:
command: 'restore'
projects: '**/*.csproj'
- task: DotNetCoreCLI@2
inputs:
command: 'build'
projects: '**/*.csproj'
arguments: '--configuration Release'
- task: DotNetCoreCLI@2
inputs:
command: 'test'
projects: '**/*Tests/*.csproj'
arguments: '--configuration Release'
- task: PublishBuildArtifacts@1
inputs:
PathtoPublish: '$(Build.ArtifactStagingDirectory)'
ArtifactName: 'drop'stages:
- stage: Build
jobs:
- job: BuildJob
steps:
- script: echo Building application
- stage: DeployDev
dependsOn: Build
jobs:
- deployment: DeployToDev
environment: Dev
strategy:
runOnce:
deploy:
steps:
- script: echo Deploying to Dev
- stage: DeployTest
dependsOn: DeployDev
jobs:
- deployment: DeployToTest
environment: Test
strategy:
runOnce:
deploy:
steps:
- script: echo Deploying to TestLes connexions de service permettent à Azure DevOps de se connecter à des ressources externes.
# Exemple d'utilisation d'une connexion de service
steps:
- task: AzureWebApp@1
inputs:
azureSubscription: 'MonAzureServiceConnection'
appName: 'monAppService'
package: '$(System.DefaultWorkingDirectory)/**/*.zip'# Utilisation de Key Vault
steps:
- task: AzureKeyVault@1
inputs:
azureSubscription: 'MonAzureServiceConnection'
KeyVaultName: 'monKeyVault'
SecretsFilter: 'Secret1,Secret2'
- script: |
echo "Using secret: $(Secret1)"
displayName: 'Utilisation sécurisée de secrets'GitHub Actions est la solution d’automatisation intégrée à GitHub pour CI/CD. Elle permet d’automatiser des workflows directement depuis votre dépôt GitHub.
.github/workflows/*.yml)name: CI
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Set up .NET
uses: actions/setup-dotnet@v1
with:
dotnet-version: '6.0.x'
- name: Restore dependencies
run: dotnet restore
- name: Build
run: dotnet build --no-restore
- name: Test
run: dotnet test --no-buildname: CI Basic
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Build et test
run: |
npm ci
npm run build
npm testname: CI Matrix
on: [push, pull_request]
jobs:
test:
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-latest, windows-latest, macos-latest]
node-version: [14.x, 16.x, 18.x]
steps:
- uses: actions/checkout@v2
- name: Use Node.js ${{ matrix.node-version }}
uses: actions/setup-node@v2
with:
node-version: ${{ matrix.node-version }}
- run: npm ci
- run: npm testname: CI with Cache
on: [push]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Cache node modules
uses: actions/cache@v2
with:
path: ~/.npm
key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
restore-keys: |
${{ runner.os }}-node-
- name: Install dependencies
run: npm ci
- name: Run tests
run: npm testname: Build and Publish
on: [push]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Build
run: |
npm ci
npm run build
- name: Upload artifacts
uses: actions/upload-artifact@v2
with:
name: app-build
path: build/name: CI/CD Workflow
on:
push:
branches: [ main ]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Build
run: npm ci && npm run build
- name: Upload artifact
uses: actions/upload-artifact@v2
with:
name: build-files
path: build
deploy:
needs: build
runs-on: ubuntu-latest
steps:
- name: Download artifact
uses: actions/download-artifact@v2
with:
name: build-files
path: build
- name: Deploy to Azure
uses: azure/webapps-deploy@v2
with:
app-name: 'myApp'
publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
package: './build'Extrayez le package ZIP dans un dossier (ex: C:\agents\agent1)
Ouvrez PowerShell en tant qu’administrateur dans ce dossier
Exécutez la commande de configuration:
.\config.cmd --url https://dev.azure.com/votreorganisation --auth pat --token votrePersonalAccessToken --pool WorkshopPool --agent AgentName1 --replaceSuivez les instructions pour compléter la configuration
Installez l’agent comme service:
.\config.cmd --service install
.\config.cmd --service startExtrayez le package dans un dossier: mkdir ~/agent && cd ~/agent && tar zxvf ~/Downloads/vsts-agent-linux-x64-VERSION.tar.gz
Exécutez la configuration:
./config.sh --url https://dev.azure.com/votreorganisation --auth pat --token votrePersonalAccessToken --pool WorkshopPool --agent AgentName1 --replaceInstallez et démarrez comme service:
sudo ./svc.sh install
sudo ./svc.sh startCustomTool comme nom et Workshop comme valeurEnvironment comme nom et Training comme valeurindex.html simpleDans votre projet Azure DevOps, naviguez vers Pipelines > Pipelines
Cliquez sur “New pipeline”
Sélectionnez votre référentiel source
Choisissez “Starter pipeline” comme modèle
Modifiez le YAML pour cibler votre agent auto-hébergé:
trigger:
- main
pool:
name: WorkshopPool
demands:
- CustomTool -equals Workshop
- Environment -equals Training
steps:
- script: echo Bonjour depuis l'agent $(Agent.Name)
displayName: 'Echo agent info'
- script: |
echo Liste des capacités de l'agent:
echo OS: $(Agent.OS)
echo Directory: $(Agent.HomeDirectory)
displayName: 'Liste des capacités'
- script: |
echo Contenu du répertoire de travail:
dir
displayName: 'Liste des fichiers'
condition: eq(variables['Agent.OS'], 'Windows_NT')
- script: |
echo Contenu du répertoire de travail:
ls -la
displayName: 'Liste des fichiers'
condition: ne(variables['Agent.OS'], 'Windows_NT')Cliquez sur “Save and run”
Observez l’exécution du pipeline sur votre agent auto-hébergé
Création du pipeline Classic
CustomTool = WorkshopEnvironment = Trainingecho Bonjour depuis l'agent $(Agent.Name) - Tâche 2: - Display name: “Liste des capacités” - Script: echo Liste des capacités de l'agent: echo OS: $(Agent.OS) echo Directory: $(Agent.HomeDirectory) - Tâche 3: - Display name: “Liste des fichiers” - Script pour Windows: dir - Script pour Linux/macOS: ls -la - Control options > Run this task: Custom condition - Condition pour Windows: eq(variables['Agent.OS'], 'Windows_NT') - Créez une tâche similaire pour Linux avec condition inverse
Création du dépôt
Création d’une application web simple
Clonez le dépôt sur votre poste local: git clone [url-du-depot]
Pour .NET Core:
dotnet new webapi -o WebApiSample
cd WebApiSample
dotnet new xunit -o WebApiSample.TestsOu pour Node.js:
mkdir node-sample
cd node-sample
npm init -y
npm install express --save
npm install jest supertest --save-devCréez quelques fichiers de base:
Configuration des tests
Pour .NET Core, créez un test simple dans WebApiSample.Tests:
using Xunit;
using WebApiSample.Controllers;
public class WeatherForecastControllerTests
{
[Fact]
public void Get_ReturnsData()
{
// Arrange
var controller = new WeatherForecastController();
// Act
var result = controller.Get();
// Assert
Assert.NotNull(result);
Assert.NotEmpty(result);
}
}Pour Node.js, créez un test Jest:
const request = require('supertest');
const app = require('./app');
test('GET / responds with Hello World', async () => {
const response = await request(app).get('/');
expect(response.status).toBe(200);
expect(response.text).toContain('Hello World');
});Commit et push du code
git add .
git commit -m "Initial commit with web application and tests"
git pushCréation du pipeline YAML
Configuration du pipeline pour .NET Core
Modifiez le YAML comme suit:
trigger:
branches:
include:
- main
- feature/*
paths:
include:
- WebApiSample/**
exclude:
- '*.md'
pool:
vmImage: 'ubuntu-latest'
variables:
buildConfiguration: 'Release'
projectPath: 'WebApiSample'
testProjectPath: 'WebApiSample.Tests'
steps:
- task: DotNetCoreCLI@2
displayName: 'Restore packages'
inputs:
command: 'restore'
projects: '$(projectPath)/**/*.csproj'
- task: DotNetCoreCLI@2
displayName: 'Build solution'
inputs:
command: 'build'
projects: '$(projectPath)/**/*.csproj'
arguments: '--configuration $(buildConfiguration)'
- task: DotNetCoreCLI@2
displayName: 'Run tests'
inputs:
command: 'test'
projects: '$(testProjectPath)/**/*.csproj'
arguments: '--configuration $(buildConfiguration) --collect:"XPlat Code Coverage"'
publishTestResults: true
- task: PublishCodeCoverageResults@1
displayName: 'Publish code coverage report'
inputs:
codeCoverageTool: 'Cobertura'
summaryFileLocation: '$(Agent.TempDirectory)/**/coverage.cobertura.xml'
- task: DotNetCoreCLI@2
displayName: 'Publish website'
inputs:
command: 'publish'
publishWebProjects: true
arguments: '--configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)'
zipAfterPublish: true
- task: PublishBuildArtifacts@1
displayName: 'Publish artifacts'
inputs:
PathtoPublish: '$(Build.ArtifactStagingDirectory)'
ArtifactName: 'webapp'Configuration du pipeline pour Node.js
Modifiez le YAML comme suit:
trigger:
branches:
include:
- main
- feature/*
paths:
include:
- node-sample/**
exclude:
- '*.md'
pool:
vmImage: 'ubuntu-latest'
steps:
- task: NodeTool@0
inputs:
versionSpec: '16.x'
displayName: 'Install Node.js'
- script: |
cd node-sample
npm install
displayName: 'npm install'
- script: |
cd node-sample
npm test
displayName: 'Run tests'
- script: |
cd node-sample
npm test -- --coverage
displayName: 'Run tests with coverage'
- task: PublishTestResults@2
inputs:
testResultsFormat: 'JUnit'
testResultsFiles: '**/junit.xml'
searchFolder: '$(System.DefaultWorkingDirectory)/node-sample'
mergeTestResults: true
testRunTitle: 'Node.js Tests'
condition: succeededOrFailed()
displayName: 'Publish test results'
- task: PublishCodeCoverageResults@1
inputs:
codeCoverageTool: 'Cobertura'
summaryFileLocation: '$(System.DefaultWorkingDirectory)/node-sample/coverage/cobertura-coverage.xml'
reportDirectory: '$(System.DefaultWorkingDirectory)/node-sample/coverage'
displayName: 'Publish code coverage'
- task: ArchiveFiles@2
inputs:
rootFolderOrFile: '$(System.DefaultWorkingDirectory)/node-sample'
includeRootFolder: false
archiveType: 'zip'
archiveFile: '$(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip'
replaceExistingArchive: true
displayName: 'Archive files'
- task: PublishBuildArtifacts@1
inputs:
PathtoPublish: '$(Build.ArtifactStagingDirectory)'
ArtifactName: 'node-app'
publishLocation: 'Container'
displayName: 'Publish artifacts'Sauvegarde et exécution du pipeline
Ajout de déclencheurs pour Pull Requests
Modifiez la section trigger dans votre YAML:
trigger:
branches:
include:
- main
- feature/*
paths:
include:
- WebApiSample/** # ou node-sample/**
exclude:
- '*.md'
pr:
branches:
include:
- main
paths:
include:
- WebApiSample/** # ou node-sample/**
exclude:
- '*.md'Test des déclencheurs
Créez une nouvelle branche: git checkout -b feature/nouvelle-fonctionnalite
Ajoutez un fichier ou modifiez du code existant
Committez et poussez:
git add .
git commit -m "Ajout d'une nouvelle fonctionnalité"
git push --set-upstream origin feature/nouvelle-fonctionnaliteDans Azure DevOps, créez une Pull Request vers la branche main
Vérifiez que le pipeline se déclenche automatiquement
Amélioration de la couverture de code
Ajout d’un badge de build au README
Créez un fichier README.md à la racine du projet
Dans Azure DevOps, naviguez vers votre pipeline
Cliquez sur les “…” et sélectionnez “Status badge”
Copiez le markdown du badge
Ajoutez-le à votre README.md:
# Projet Demo CI/CD
[](https://dev.azure.com/votre-org/votre-projet/_build/latest?definitionId=X&branchName=main)
Cette application démontre l'intégration continue avec Azure Pipelines.Committez et poussez le README
Configuration des politiques de branche
Création d’un dépôt GitHub
Ajout d’une application simple
Pour Node.js:
git clone https://github.com/votre-compte/azure-pipelines-demo
cd azure-pipelines-demo
npm init -y
npm install express --saveCréez un fichier app.js avec un serveur Express basique
Créez un fichier azure-pipelines.yml à la racine (vide pour l’instant)
Commit et push du code initial
git add .
git commit -m "Initial commit with Express app"
git pushAzure DevOps va générer un pipeline YAML de base pour Node.js
Modifiez le pipeline comme suit:
trigger:
branches:
include:
- main
paths:
include:
- '**'
exclude:
- '*.md'
pool:
vmImage: 'ubuntu-latest'
variables:
# Déclaration de variables non-secrètes
nodeVersion: '16.x'
# Les secrets seront ajoutés via le vault
steps:
- task: NodeTool@0
inputs:
versionSpec: '$(nodeVersion)'
displayName: 'Install Node.js'
- script: |
npm install
displayName: 'npm install'
- script: |
npm test
displayName: 'Run tests'
continueOnError: true # Continuer même si les tests échouent (pour l'atelier)
- script: |
echo "Application name: $(applicationName)"
echo "Environment: $(environment)"
displayName: 'Echo variables'
# Les variables applicationName et environment seront définies plus tardCliquez sur “Save and run”
Choisissez de valider directement dans la branche main
Le pipeline échouera car les variables ne sont pas encore définies, c’est normal
applicationName, Valeur: AzureWorkshopApp, Maintenir secret: Nonenvironment, Valeur: Development, Maintenir secret: NondbConnectionString avec une valeur fictiveapiKey avec une valeur fictiveModifiez votre pipeline YAML pour ajouter l’accès à Key Vault:
trigger:
branches:
include:
- main
paths:
include:
- '**'
exclude:
- '*.md'
pool:
vmImage: 'ubuntu-latest'
variables:
nodeVersion: '16.x'
steps:
- task: NodeTool@0
inputs:
versionSpec: '$(nodeVersion)'
displayName: 'Install Node.js'
- task: AzureKeyVault@2
inputs:
azureSubscription: 'Azure-Workshop-Connection'
KeyVaultName: 'votre-key-vault-name'
SecretsFilter: 'dbConnectionString,apiKey'
RunAsPreJob: true
displayName: 'Get secrets from Azure Key Vault'
- script: |
npm install
displayName: 'npm install'
- script: |
npm test
displayName: 'Run tests'
continueOnError: true
- script: |
echo "Application name: $(applicationName)"
echo "Environment: $(environment)"
echo "Using connection string: $(dbConnectionString)"
echo "API Key length: $(apiKey)"
displayName: 'Echo variables'Committez les changements au fichier YAML (Azure DevOps le fera pour vous si vous utilisez l’éditeur)
Modifiez votre pipeline pour ajouter des déclencheurs de pull request:
trigger:
branches:
include:
- main
paths:
include:
- '**'
exclude:
- '*.md'
pr:
branches:
include:
- mainCréez une nouvelle branche et une pull request dans GitHub
Vérifiez que le pipeline se déclenche lors de la création de la PR
git checkout -b feature/test-integrationAjout d’un badge de statut dans le README
Configuration du cache pour les dépendances
Modifiez votre pipeline pour ajouter la mise en cache des modules npm:
steps:
- task: NodeTool@0
inputs:
versionSpec: '$(nodeVersion)'
displayName: 'Install Node.js'
- task: AzureKeyVault@2
inputs:
azureSubscription: 'Azure-Workshop-Connection'
KeyVaultName: 'votre-key-vault-name'
SecretsFilter: 'dbConnectionString,apiKey'
RunAsPreJob: true
displayName: 'Get secrets from Azure Key Vault'
- task: Cache@2
inputs:
key: 'npm | "$(Agent.OS)" | package-lock.json'
restoreKeys: |
npm | "$(Agent.OS)"
path: '$(npm.config.cache)'
displayName: 'Cache npm modules'
- script: |
npm install
displayName: 'npm install'
# ... reste du pipelineExécutez le pipeline deux fois consécutives
Vérifiez que la deuxième exécution utilise le cache
Création du dépôt GitHub
Clonage du dépôt et création d’une application web simple
Clonez le dépôt sur votre machine locale
Pour Node.js:
git clone https://github.com/votre-compte/github-actions-workshop
cd github-actions-workshop
npm init -y
npm install express --save
npm install jest supertest --save-devCréez un fichier app.js avec un serveur Express de base:
const express = require('express');
const app = express();
app.get('/', (req, res) => {
res.send('Hello, GitHub Actions!');
});
app.get('/api/status', (req, res) => {
res.json({ status: 'ok', version: '1.0.0' });
});
const port = process.env.PORT || 3000;
if (require.main === module) {
app.listen(port, () => {
console.log(`Server running on port ${port}`);
});
}
module.exports = app;Créez un fichier de test app.test.js:
const request = require('supertest');
const app = require('./app');
test('GET / responds with Hello message', async () => {
const response = await request(app).get('/');
expect(response.status).toBe(200);
expect(response.text).toContain('Hello, GitHub Actions');
});
test('GET /api/status returns correct status', async () => {
const response = await request(app).get('/api/status');
expect(response.status).toBe(200);
expect(response.body).toHaveProperty('status', 'ok');
});Mettez à jour package.json pour ajouter des scripts:
"scripts": {
"start": "node app.js",
"test": "jest",
"test:coverage": "jest --coverage"
}Commit et push du code initial
git add .
git commit -m "Initial commit with Express app and tests"
git pushCréez un répertoire .github/workflows à la racine de votre projet:
mkdir -p .github/workflowsCréez un fichier .github/workflows/ci.yml:
name: Node.js CI
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Use Node.js 16.x
uses: actions/setup-node@v3
with:
node-version: 16.x
cache: 'npm'
- name: Install dependencies
run: npm ci
- name: Run tests
run: npm test
- name: Check code style
run: |
echo "Checking code style (simulated)"
# Ici, vous pourriez utiliser ESLint, Prettier, etc. git add .github/workflows/ci.yml
git commit -m "Add basic GitHub Actions workflow"
git pushModifiez le fichier .github/workflows/ci.yml:
name: Node.js CI
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
jobs:
test:
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-latest, windows-latest]
node-version: [14.x, 16.x, 18.x]
# Exclure certaines combinaisons si nécessaire
exclude:
- os: windows-latest
node-version: 14.x
steps:
- uses: actions/checkout@v3
- name: Use Node.js ${{ matrix.node-version }}
uses: actions/setup-node@v3
with:
node-version: ${{ matrix.node-version }}
cache: 'npm'
- name: Install dependencies
run: npm ci
- name: Run tests
run: npm test
- name: Generate test coverage
run: npm run test:coverage git add .github/workflows/ci.yml
git commit -m "Add test matrix across multiple Node.js versions and OSes"
git pushModifiez le workflow pour optimiser le cache:
- name: Use Node.js ${{ matrix.node-version }}
uses: actions/setup-node@v3
with:
node-version: ${{ matrix.node-version }}
cache: 'npm'
# Alternative plus détaillée si vous préférez:
- name: Cache node modules
uses: actions/cache@v3
with:
path: ~/.npm
key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
restore-keys: |
${{ runner.os }}-node-Ajoutez les étapes suivantes à votre workflow:
- name: Archive production artifacts
if: success() && matrix.os == 'ubuntu-latest' && matrix.node-version == '16.x'
uses: actions/upload-artifact@v3
with:
name: node-app
path: |
.
!node_modules/
!.git/
- name: Archive code coverage results
if: success() && matrix.os == 'ubuntu-latest' && matrix.node-version == '16.x'
uses: actions/upload-artifact@v3
with:
name: code-coverage-report
path: coverage/Restructurez le workflow pour séparer les tests et le build:
name: Node.js CI/CD
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
jobs:
test:
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-latest, windows-latest]
node-version: [14.x, 16.x, 18.x]
exclude:
- os: windows-latest
node-version: 14.x
steps:
- uses: actions/checkout@v3
- name: Use Node.js ${{ matrix.node-version }}
uses: actions/setup-node@v3
with:
node-version: ${{ matrix.node-version }}
cache: 'npm'
- name: Install dependencies
run: npm ci
- name: Run tests
run: npm test
- name: Generate test coverage
run: npm run test:coverage
build:
needs: test
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Use Node.js 16.x
uses: actions/setup-node@v3
with:
node-version: 16.x
cache: 'npm'
- name: Install dependencies
run: npm ci
- name: Build application
run: |
echo "Building application for production..."
npm run build --if-present
- name: Archive production artifacts
uses: actions/upload-artifact@v3
with:
name: node-app
path: |
.
!node_modules/
!.git/ git add .github/workflows/ci.yml
git commit -m "Optimize workflow with caching and separate build job"
git pushAZURE_CREDENTIALS (avec une valeur JSON simulée pour l’atelier)DEPLOYMENT_URL (avec une URL fictive, ex: https://myapp.azurewebsites.net)Modifiez votre workflow pour ajouter un job de déploiement:
deploy:
needs: build
if: github.ref == 'refs/heads/main' && github.event_name == 'push'
runs-on: ubuntu-latest
environment:
name: production
url: ${{ secrets.DEPLOYMENT_URL }}
steps:
- name: Download artifact
uses: actions/download-artifact@v3
with:
name: node-app
- name: Display structure of downloaded files
run: ls -R
- name: Set up Azure credentials
uses: azure/login@v1
with:
creds: ${{ secrets.AZURE_CREDENTIALS }}
# Note: Pour un vrai déploiement, utilisez des creds valides
- name: 'Deploy to Azure Web App (simulated)'
run: |
echo "Deploying to ${{ secrets.DEPLOYMENT_URL }}"
# Simulons le déploiement pour l'atelier
echo "Application would be deployed to Azure Web App" git add .github/workflows/ci.yml
git commit -m "Add deployment job with environment protection"
git pushCréez une nouvelle branche: git checkout -b feature/update-api
Modifiez le code, par exemple, ajoutez un nouvel endpoint dans app.js:
app.get('/api/info', (req, res) => {
res.json({
name: 'github-actions-demo',
environment: process.env.NODE_ENV || 'development',
timestamp: new Date().toISOString()
});
});app.test.js: test('GET /api/info returns application info', async () => {
const response = await request(app).get('/api/info');
expect(response.status).toBe(200);
expect(response.body).toHaveProperty('name');
expect(response.body).toHaveProperty('timestamp');
}); # GitHub Actions Workshop

This repository demonstrates a complete CI/CD pipeline using GitHub Actions.À la fin de cet atelier, les participants seront capables de :
3 heures
Azure App Service offre un service d’hébergement géré pour les applications web qui peuvent être déployées dans des conteneurs Docker. Dans cet atelier, nous allons explorer comment intégrer le déploiement de conteneurs dans un pipeline CI/CD automatisé avec Azure DevOps et GitHub Actions.
Nous allons utiliser une application web simple en Node.js comme exemple. Voici la structure du projet :
app/
├── Dockerfile
├── package.json
├── server.js
└── views/
└── index.html
server.js :const express = require('express');
const app = express();
const port = process.env.PORT || 3000;
app.use(express.static('views'));
app.get('/api/info', (req, res) => {
res.json({
version: '1.0.0',
environment: process.env.NODE_ENV || 'development',
message: 'Application déployée avec succès!'
});
});
app.listen(port, () => {
console.log(`App listening at http://localhost:${port}`);
});Dockerfile :FROM node:14-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]package.json :{
"name": "azure-devops-docker-demo",
"version": "1.0.0",
"description": "Application demo pour le déploiement de conteneurs Docker vers Azure App Service",
"main": "server.js",
"scripts": {
"start": "node server.js",
"test": "echo \"Tests passed successfully\" && exit 0"
},
"dependencies": {
"express": "^4.17.1"
}
}Ouvrez le terminal et connectez-vous à Azure CLI :
az loginCréez un groupe de ressources :
az group create --name rg-docker-webapp --location westeuropeCréez un Azure Container Registry (ACR) :
az acr create --resource-group rg-docker-webapp --name <votre-nom-acr-unique> --sku Basic --admin-enabled trueRécupérez les informations d’identification de l’ACR :
az acr credential show --name <votre-nom-acr-unique>az appservice plan create --name asp-docker-webapp --resource-group rg-docker-webapp --sku B1 --is-linuxaz webapp create --resource-group rg-docker-webapp --plan asp-docker-webapp --name <votre-nom-webapp-unique> --deployment-container-image-name nginx:latestacrName : Nom de votre Azure Container RegistryacrLoginServer : URL du serveur de login ACR (format : webAppName : Nom de votre Web App AzureacrUsername : Nom d’utilisateur ACR (récupéré précédemment)acrPassword : Mot de passe ACR (récupéré précédemment)Créez un fichier nommé azure-pipelines.yml à la racine de votre projet :
trigger:
- main
variables:
- group: docker-webapp-variables
stages:
- stage: Build
displayName: 'Build and Push Docker Image'
jobs:
- job: BuildPushImage
displayName: 'Build and Push Docker Image'
pool:
vmImage: 'ubuntu-latest'
steps:
- task: Docker@2
displayName: 'Build Docker Image'
inputs:
command: build
repository: $(acrName)/docker-webapp-demo
dockerfile: '$(Build.SourcesDirectory)/Dockerfile'
tags: |
$(Build.BuildId)
latest
- task: Docker@2
displayName: 'Push Docker Image to ACR'
inputs:
command: login
containerRegistry: 'docker-registry-connection'
- task: Docker@2
displayName: 'Push Docker image'
inputs:
command: push
repository: $(acrName)/docker-webapp-demo
tags: |
$(Build.BuildId)
latest
- stage: Deploy
displayName: 'Deploy to Azure App Service'
dependsOn: Build
jobs:
- job: DeployToAppService
displayName: 'Deploy to App Service'
pool:
vmImage: 'ubuntu-latest'
steps:
- task: AzureWebAppContainer@1
displayName: 'Azure Web App on Container Deploy'
inputs:
azureSubscription: 'azure-connection'
appName: $(webAppName)
containers: '$(acrLoginServer)/docker-webapp-demo:$(Build.BuildId)'Ajoutez les secrets suivants à votre repository GitHub :
AZURE_CREDENTIALS : Informations d’identification JSON pour l’accès à AzureACR_USERNAME : Nom d’utilisateur ACRACR_PASSWORD : Mot de passe ACRACR_LOGIN_SERVER : URL du serveur de login ACRWEBAPP_NAME : Nom de votre App ServiceCréez un fichier .github/workflows/docker-deploy.yml :
name: Build and Deploy to Azure App Service
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
jobs:
build-and-deploy:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Login to Azure Container Registry
uses: docker/login-action@v1
with:
registry: ${{ secrets.ACR_LOGIN_SERVER }}
username: ${{ secrets.ACR_USERNAME }}
password: ${{ secrets.ACR_PASSWORD }}
- name: Build and push Docker image
uses: docker/build-push-action@v2
with:
context: .
push: true
tags: ${{ secrets.ACR_LOGIN_SERVER }}/docker-webapp-demo:${{ github.sha }}, ${{ secrets.ACR_LOGIN_SERVER }}/docker-webapp-demo:latest
- name: Login to Azure
uses: azure/login@v1
with:
creds: ${{ secrets.AZURE_CREDENTIALS }}
- name: Deploy to Azure App Service
uses: azure/webapps-deploy@v2
with:
app-name: ${{ secrets.WEBAPP_NAME }}
images: ${{ secrets.ACR_LOGIN_SERVER }}/docker-webapp-demo:${{ github.sha }}https://<votre-nom-webapp-unique>.azurewebsites.nethttps://<votre-nom-webapp-unique>.azurewebsites.net/api/info# Créer un slot de staging
az webapp deployment slot create --name <votre-nom-webapp-unique> --resource-group rg-docker-webapp --slot stagingModifiez votre pipeline pour déployer d’abord sur le slot de staging, puis échanger avec la production :
# Ajoutez ces étapes au stage de déploiement
- task: AzureAppServiceManage@0
inputs:
azureSubscription: 'azure-connection'
Action: 'Swap Slots'
WebAppName: $(webAppName)
ResourceGroupName: 'rg-docker-webapp'
SourceSlot: 'staging'
SwapWithProduction: trueExemple de Dockerfile multi-stage :
# Build stage
FROM node:14-alpine AS build
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
# Production stage
FROM node:14-alpine
WORKDIR /app
COPY --from=build /app .
EXPOSE 3000
CMD ["node", "server.js"]À la fin de ce module, vous serez capable de :
La livraison continue (CD - Continuous Delivery) est une approche logicielle qui permet de produire des logiciels de manière à ce qu’ils puissent être publiés à tout moment. Elle étend le concept d’intégration continue en garantissant que le code est toujours dans un état déployable après avoir passé avec succès les tests automatisés.
| Livraison continue | Déploiement continu |
|---|---|
| Le code est toujours prêt à être déployé, mais la mise en production est déclenchée manuellement | Automatisation complète jusqu’à la mise en production, sans intervention humaine |
| Un humain décide quand effectuer la mise en production | Les modifications qui passent tous les tests sont automatiquement déployées en production |
| Flexibilité pour les entreprises ayant des cycles de publication planifiés | Idéal pour les environnements nécessitant une publication très fréquente |
Une stratégie de publication efficace doit prendre en compte :
graph TD
A[Développement] --> B[Tests Automatisés]
B --> C{Tests passés?}
C -->|Non| A
C -->|Oui| D[Déploiement en Staging]
D --> E[Tests d'acceptation]
E --> F{Accepté?}
F -->|Non| A
F -->|Oui| G[Déploiement Progressif en Production]
G --> H[Monitoring]
H --> I{Problèmes?}
I -->|Oui| J[Rollback]
I -->|Non| K[Déploiement Complet]
Un pipeline de publication de haute qualité doit inclure plusieurs étapes et garanties :
trigger:
- main
pool:
vmImage: 'ubuntu-latest'
stages:
- stage: Build
jobs:
- job: BuildJob
steps:
- task: DotNetCoreCLI@2
inputs:
command: 'build'
projects: '**/*.csproj'
- task: DotNetCoreCLI@2
inputs:
command: 'test'
projects: '**/*Tests/*.csproj'
- task: PublishBuildArtifacts@1
inputs:
pathToPublish: '$(Build.ArtifactStagingDirectory)'
artifactName: 'drop'
- stage: DeployDev
dependsOn: Build
jobs:
- deployment: Deploy
environment: 'Development'
strategy:
runOnce:
deploy:
steps:
- task: AzureWebApp@1
inputs:
azureSubscription: 'Azure-Connection'
appName: 'myapp-dev'
package: '$(Pipeline.Workspace)/drop/*.zip'
- stage: DeployProd
dependsOn: DeployDev
jobs:
- deployment: Deploy
environment: 'Production'
strategy:
runOnce:
deploy:
steps:
- task: AzureWebApp@1
inputs:
azureSubscription: 'Azure-Connection'
appName: 'myapp-prod'
package: '$(Pipeline.Workspace)/drop/*.zip'Pour garantir un pipeline de haute qualité, il faut mettre en place :
Il existe plusieurs stratégies pour déployer des applications en production tout en minimisant les risques :
| Modèle | Description | Avantages | Inconvénients |
|---|---|---|---|
| Big Bang | Remplacer complètement l’ancienne version par la nouvelle | Simple à mettre en œuvre | Risqué, pas de retour en arrière facile |
| Blue-Green | Deux environnements identiques avec bascule du trafic | Zéro temps d’arrêt, rollback facile | Coûteux (double infrastructure) |
| Canary | Exposition progressive à un sous-ensemble d’utilisateurs | Risque limité, détection précoce des problèmes | Plus complexe à mettre en œuvre |
| Modèle | Description | Avantages | Inconvénients |
|---|---|---|---|
| Feature Toggle | Activer/désactiver des fonctionnalités via des flags | Flexibilité, séparation déploiement/activation | Complexité du code, dette technique |
| A/B Testing | Comparaison de deux versions avec mesures | Décisions basées sur des données | Nécessite une infrastructure d’analyse |
graph LR
A[Version Actuelle] -->|"Trafic initial (100%)"| B[Environnement Bleu]
C[Nouvelle Version] -->|Déploiement| D[Environnement Vert]
D -->|Tests de validation| E{Tests OK?}
E -->|Oui| F[Bascule du Load Balancer]
F -->|"Nouveau trafic (100%)"| D
E -->|Non| G[Abandon du déploiement]
Le déploiement bleu-vert utilise deux environnements identiques :
Le processus se déroule comme suit :
Azure App Service propose des “slots de déploiement” qui facilitent l’implémentation d’un déploiement bleu-vert :
# Créer un slot de déploiement (environnement vert)
az webapp deployment slot create --name myApp --resource-group myResourceGroup --slot staging
# Déployer sur le slot staging
az webapp deployment source config-zip --name myApp --resource-group myResourceGroup --slot staging --src app.zip
# Échanger les slots (bascule du trafic)
az webapp deployment slot swap --name myApp --resource-group myResourceGroup --slot staging --target-slot productionLes Feature Flags permettent d’activer ou désactiver des fonctionnalités sans redéploiement :
if (featureManager.IsEnabled("nouvelle-fonctionnalite"))
{
// Code de la nouvelle fonctionnalité
}
else
{
// Ancien comportement
}// Program.cs
builder.Configuration.AddAzureAppConfiguration(options =>
{
options.Connect(connectionString)
.UseFeatureFlags();
});
// Controller
public class HomeController : Controller
{
private readonly IFeatureManager _featureManager;
public HomeController(IFeatureManager featureManager)
{
_featureManager = featureManager;
}
public async Task<IActionResult> Index()
{
if (await _featureManager.IsEnabledAsync("Beta"))
{
// Nouvelle fonctionnalité
}
}
}Le déploiement canari consiste à exposer progressivement une nouvelle version à un sous-ensemble d’utilisateurs avant un déploiement complet.
# Créer un profil Traffic Manager
az network traffic-manager profile create --name myCanaryTM --resource-group myResourceGroup --routing-method Weighted --unique-dns-name myapp-canary
# Ajouter l'endpoint principal (production actuelle - 95%)
az network traffic-manager endpoint create --name production --profile-name myCanaryTM --resource-group myResourceGroup --type azureEndpoints --target-resource-id /subscriptions/id/resourceGroups/myResourceGroup/providers/Microsoft.Web/sites/myapp-prod --weight 95
# Ajouter l'endpoint canari (nouvelle version - 5%)
az network traffic-manager endpoint create --name canary --profile-name myCanaryTM --resource-group myResourceGroup --type azureEndpoints --target-resource-id /subscriptions/id/resourceGroups/myResourceGroup/providers/Microsoft.Web/sites/myapp-canary --weight 5Le lancement sombre consiste à déployer du code en production mais à le masquer des utilisateurs, permettant ainsi de tester son comportement en conditions réelles.
// Middleware ASP.NET Core pour dupliquer les requêtes
public class DarkLaunchMiddleware
{
private readonly RequestDelegate _next;
private readonly HttpClient _httpClient;
private readonly string _darkEndpoint;
public DarkLaunchMiddleware(RequestDelegate next, IConfiguration config)
{
_next = next;
_httpClient = new HttpClient();
_darkEndpoint = config["DarkLaunch:Endpoint"];
}
public async Task InvokeAsync(HttpContext context)
{
// Continuer le traitement normal
var originalResponseBody = context.Response.Body;
try
{
// Dupliquer la requête vers le nouvel endpoint (dark launch)
if (!string.IsNullOrEmpty(_darkEndpoint))
{
// Cloner la requête de manière asynchrone pour ne pas bloquer l'utilisateur
_ = Task.Run(async () =>
{
try
{
var request = new HttpRequestMessage(new HttpMethod(context.Request.Method), _darkEndpoint);
await _httpClient.SendAsync(request);
// Les résultats sont ignorés
}
catch
{
// Les erreurs sont silencieuses car c'est un dark launch
}
});
}
// Continuer le traitement normal
await _next(context);
}
finally
{
context.Response.Body = originalResponseBody;
}
}
}Les tests A/B permettent de comparer deux versions d’une fonctionnalité pour déterminer laquelle offre les meilleures performances selon des métriques définies.
// Configuration du test A/B
public class HomeController : Controller
{
private readonly IFeatureManager _featureManager;
private readonly TelemetryClient _telemetryClient;
public HomeController(IFeatureManager featureManager, TelemetryClient telemetryClient)
{
_featureManager = featureManager;
_telemetryClient = telemetryClient;
}
public async Task<IActionResult> Index()
{
// Récupérer l'ID utilisateur ou générer un ID de session
string userId = User.Identity.IsAuthenticated ? User.FindFirst(ClaimTypes.NameIdentifier).Value : HttpContext.Session.Id;
// Déterminer la variante (A ou B) basée sur un hachage de l'ID utilisateur
bool isVariantB = await _featureManager.IsEnabledAsync("VariantB", new TargetingContext
{
UserId = userId
});
// Tracer la variante pour l'analyse
_telemetryClient.TrackEvent("VariantViewed", new Dictionary<string, string>
{
{ "UserId", userId },
{ "Variant", isVariantB ? "B" : "A" }
});
// Afficher la variante appropriée
return View(isVariantB ? "IndexB" : "IndexA");
}
[HttpPost]
public IActionResult Conversion()
{
// Enregistrer la conversion
string userId = User.Identity.IsAuthenticated ? User.FindFirst(ClaimTypes.NameIdentifier).Value : HttpContext.Session.Id;
_telemetryClient.TrackEvent("Conversion", new Dictionary<string, string>
{
{ "UserId", userId }
});
return Ok();
}
}Le déploiement progressif consiste à augmenter graduellement l’exposition des utilisateurs à une nouvelle version.
{
"routingRules": [
{
"name": "ProgressiveRollout",
"acceptedProtocols": ["Http", "Https"],
"patternsToMatch": ["/*"],
"routeConfiguration": {
"@odata.type": "#Microsoft.Azure.FrontDoor.Models.FrontdoorForwardingConfiguration",
"forwardingProtocol": "MatchRequest",
"backendPool": {
"id": "/subscriptions/{subscription-id}/resourceGroups/{resource-group}/providers/Microsoft.Network/frontDoors/{front-door-name}/backendPools/ProgressivePool"
}
}
}
],
"backendPools": [
{
"name": "ProgressivePool",
"backends": [
{
"address": "old-version.azurewebsites.net",
"httpPort": 80,
"httpsPort": 443,
"weight": 80,
"priority": 1
},
{
"address": "new-version.azurewebsites.net",
"httpPort": 80,
"httpsPort": 443,
"weight": 20,
"priority": 1
}
],
"loadBalancingSettings": {
"id": "/subscriptions/{subscription-id}/resourceGroups/{resource-group}/providers/Microsoft.Network/frontDoors/{front-door-name}/loadBalancingSettings/loadBalancingSettings1"
},
"healthProbeSettings": {
"id": "/subscriptions/{subscription-id}/resourceGroups/{resource-group}/providers/Microsoft.Network/frontDoors/{front-door-name}/healthProbeSettings/healthProbeSettings1"
}
}
]
}Objectif : Mettre en place des Release Gates dans Azure DevOps pour contrôler automatiquement la progression d’un déploiement.
Durée : 2 heures
Prérequis :
Étapes :
Configuration des métriques de surveillance :
Création des Release Gates :
- Dans Azure DevOps, créer un pipeline de release
- Configurer un pre-deployment gate :
- Vérification des builds réussies
- Vérification des PR approuvées
- Configurer un post-deployment gate :
- Vérification des alertes Application Insights
- Vérification des tests de disponibilitéTest du pipeline :
Analyse et ajustement :
Objectif : Construire un tableau de bord personnalisé dans Azure DevOps pour suivre l’état et la qualité des déploiements.
Durée : 1,5 heure
Prérequis :
Étapes :
Analyse des besoins :
Configuration des widgets :
- Créer un nouveau tableau de bord dans Azure DevOps
- Ajouter le widget "Deployment Status"
- Ajouter le widget "Release Pipeline Overview"
- Ajouter le widget "Query Results" pour les bugs post-déploiement
- Configurer le widget "Metrics" pour les performancesPersonnalisation avancée :
Partage et itération :
Quelle est la principale différence entre la livraison continue et le déploiement continu ?
Dans un déploiement bleu-vert, que représentent les environnements “bleu” et “vert” ?
Pourquoi utiliserait-on des feature flags (ou feature toggles) ?
Quelle est la caractéristique principale d’un déploiement canari ?
Qu’est-ce qu’un “Release Gate” dans Azure DevOps ?
Réponses : 1-b, 2-b, 3-b, 4-b, 5-b
À la fin de ce module, vous serez capable de :
Les pipelines de versions (release pipelines) dans Azure DevOps permettent d’automatiser le déploiement de vos applications dans différents environnements. Ils constituent un élément fondamental du déploiement continu (CD) dans l’écosystème Azure.
Un pipeline de versions définit le processus de déploiement automatisé pour une application. Il spécifie :
| Pipeline de build (CI) | Pipeline de versions (CD) |
|---|---|
| Compile le code source | Déploie les artefacts compilés |
| Exécute les tests unitaires | Gère les environnements de déploiement |
| Produit des artefacts | Applique des configurations spécifiques à l’environnement |
| Déclenché par des commits | Déclenché par de nouveaux artefacts ou manuellement |
Azure DevOps propose plusieurs modèles prédéfinis selon votre scénario de déploiement :
Vous pouvez également commencer avec un modèle vide (Empty job) et construire votre pipeline de zéro.
Les artefacts sont les éléments à déployer, généralement issus d’un pipeline de build ou d’un référentiel.
Pour ajouter un artefact :
# Exemple de définition d'artefact dans un YAML pipeline
resources:
pipelines:
- pipeline: myAppBuild
source: 'Build Application'
trigger: true # Active le déclenchement automatiquePour chaque environnement (Dev, Test, Prod), vous devez définir les tâches à exécuter :
Les tâches courantes incluent :
Vous pouvez définir quand et comment votre pipeline de versions s’exécute :
Les environnements dans Azure DevOps représentent les cibles de déploiement pour vos applications, comme les environnements de développement, de test, de préproduction et de production. Une configuration et un provisionnement efficaces des environnements sont essentiels pour établir un pipeline de livraison continue fiable.
Un environnement dans Azure DevOps est une collection de ressources qui peuvent être ciblées par des déploiements à partir d’un pipeline. Les environnements apportent plusieurs avantages :
Les environnements peuvent contenir différents types de ressources :
| Type de ressource | Description |
|---|---|
| Kubernetes | Clusters Kubernetes, y compris AKS |
| Machines virtuelles | VMs Windows ou Linux |
| App Services | Services d’applications Azure |
| Ressources génériques | Tout autre type de ressource |
Pour créer un environnement dans Azure DevOps :
Les environnements peuvent être sécurisés à l’aide de plusieurs mécanismes :
Pour configurer les approbations : 1. Accédez à votre environnement 2. Sélectionnez Approbations et contrôles 3. Choisissez Approbations 4. Ajoutez les approbateurs requis
Les variables d’environnement permettent de stocker des configurations spécifiques à l’environnement :
# Exemple de variables dans un pipeline YAML
variables:
- name: connectionString
value: 'Server=dev-server;Database=mydb;'
# Exemple de groupe de variables par environnement
variables:
- group: 'Development' # Référence à un groupe de variablesLe provisionnement des environnements devrait idéalement utiliser l’Infrastructure as Code pour assurer :
Les modèles ARM sont le format natif pour IaC dans Azure :
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"webAppName": {
"type": "string",
"metadata": {
"description": "Nom de l'application web"
}
},
"environment": {
"type": "string",
"allowedValues": [
"dev",
"test",
"prod"
]
}
},
"resources": [
{
"type": "Microsoft.Web/serverfarms",
"apiVersion": "2020-06-01",
"name": "[concat('plan-', parameters('environment'))]",
"location": "[resourceGroup().location]",
"sku": {
"name": "[if(equals(parameters('environment'), 'prod'), 'P1V2', 'B1')]"
}
},
{
"type": "Microsoft.Web/sites",
"apiVersion": "2020-06-01",
"name": "[concat(parameters('webAppName'), '-', parameters('environment'))]",
"location": "[resourceGroup().location]",
"dependsOn": [
"[resourceId('Microsoft.Web/serverfarms', concat('plan-', parameters('environment')))]"
],
"properties": {
"serverFarmId": "[resourceId('Microsoft.Web/serverfarms', concat('plan-', parameters('environment')))]"
}
}
]
}Terraform est un autre outil populaire pour IaC, multi-cloud :
provider "azurerm" {
features {}
}
variable "environment" {
type = string
}
resource "azurerm_resource_group" "example" {
name = "rg-app-${var.environment}"
location = "West Europe"
}
resource "azurerm_app_service_plan" "example" {
name = "plan-${var.environment}"
location = azurerm_resource_group.example.location
resource_group_name = azurerm_resource_group.example.name
sku {
tier = var.environment == "prod" ? "PremiumV2" : "Basic"
size = var.environment == "prod" ? "P1v2" : "B1"
}
}
resource "azurerm_app_service" "example" {
name = "app-myservice-${var.environment}"
location = azurerm_resource_group.example.location
resource_group_name = azurerm_resource_group.example.name
app_service_plan_id = azurerm_app_service_plan.example.id
}
Pour intégrer le provisionnement dans votre pipeline :
# Exemple d'intégration d'IaC dans un pipeline
steps:
- task: AzureResourceManagerTemplateDeployment@3
inputs:
deploymentScope: 'Resource Group'
azureResourceManagerConnection: 'AzureConnection'
subscriptionId: '$(subscriptionId)'
action: 'Create Or Update Resource Group'
resourceGroupName: 'rg-myapp-$(Environment)'
location: 'West Europe'
templateLocation: 'Linked artifact'
csmFile: '$(System.DefaultWorkingDirectory)/templates/template.json'
csmParametersFile: '$(System.DefaultWorkingDirectory)/templates/parameters.$(Environment).json'
deploymentMode: 'Incremental'Pour les applications conteneurisées, AKS offre :
Configuration d’un environnement AKS dans Azure DevOps :
Pour les applications traditionnelles, les VMs peuvent être utilisées comme cibles de déploiement :
La modularisation des tâches et l’utilisation de modèles dans Azure DevOps permettent de créer des pipelines plus maintenables, réutilisables et cohérents. Cette section couvre les techniques pour organiser efficacement vos pipelines à l’aide de tâches personnalisées et de modèles.
Azure DevOps propose plusieurs types de tâches pour les pipelines :
Une tâche Azure DevOps comprend :
{
"id": "e213ff0f-5d5c-4791-802d-52ea3e7be1f1",
"name": "CustomDeploymentTask",
"friendlyName": "Custom Deployment Task",
"description": "Deploy using custom process",
"author": "Your Company",
"version": {
"Major": 1,
"Minor": 0,
"Patch": 0
},
"inputs": [
{
"name": "targetEnvironment",
"type": "string",
"label": "Target Environment",
"required": true,
"helpMarkDown": "The environment to deploy to (dev, test, prod)"
}
],
"execution": {
"Node10": {
"target": "index.js"
},
"PowerShell3": {
"target": "deploy.ps1"
}
}
}Les tâches personnalisées sont utiles lorsque :
Préparer l’environnement de développement
npm install -g tfx-cliCréer la structure du projet
my-custom-task/
├── task.json
├── icon.png
├── package.json
└── index.js ou script.ps1Développer la logique de la tâche
Tester la tâche localement
Publier la tâche
tfx build tasks upload --task-path ./my-custom-task[CmdletBinding()]
param()
# Import module
Import-Module "$(PSScriptRoot)\ps_modules\VstsTaskSdk\VstsTaskSdk.psm1" -Verbose
try {
# Get inputs
$targetEnvironment = Get-VstsInput -Name "targetEnvironment" -Require
# Log environment info
Write-Host "Deploying to environment: $targetEnvironment"
# Your deployment logic here
switch ($targetEnvironment) {
"dev" {
# Dev-specific deployment steps
Write-Host "Using development configuration"
}
"test" {
# Test-specific deployment steps
Write-Host "Using testing configuration"
}
"prod" {
# Production-specific deployment steps
Write-Host "Using production configuration"
}
default {
Write-Error "Unknown environment: $targetEnvironment"
exit 1
}
}
Write-Host "Deployment completed successfully"
} catch {
Write-Error $_.Exception.Message
exit 1
}Azure DevOps propose plusieurs types de modèles :
# File: templates/build-tasks.yml
parameters:
projectPath: ''
buildConfiguration: 'Release'
steps:
- task: DotNetCoreCLI@2
displayName: 'Restore NuGet packages'
inputs:
command: 'restore'
projects: '${{ parameters.projectPath }}'
- task: DotNetCoreCLI@2
displayName: 'Build project'
inputs:
command: 'build'
projects: '${{ parameters.projectPath }}'
arguments: '--configuration ${{ parameters.buildConfiguration }}'# azure-pipelines.yml
trigger:
- main
pool:
vmImage: 'windows-latest'
steps:
# Utilisation du modèle de tâches
- template: templates/build-tasks.yml
parameters:
projectPath: 'src/MyProject.csproj'
buildConfiguration: 'Release'# templates/test-job.yml
parameters:
jobName: 'TestJob'
testProjects: '**/*.Tests.csproj'
jobs:
- job: ${{ parameters.jobName }}
steps:
- task: DotNetCoreCLI@2
displayName: 'Run unit tests'
inputs:
command: 'test'
projects: '${{ parameters.testProjects }}'
arguments: '--configuration Release'Utilisation dans le pipeline principal :
# azure-pipelines.yml
jobs:
- template: templates/test-job.yml
parameters:
jobName: 'RunUnitTests'
testProjects: 'tests/Unit/**/*.csproj'
- template: templates/test-job.yml
parameters:
jobName: 'RunIntegrationTests'
testProjects: 'tests/Integration/**/*.csproj'# templates/deploy-stage.yml
parameters:
stageName: 'Deploy'
environmentName: 'Development'
serviceConnection: ''
webAppName: ''
stages:
- stage: ${{ parameters.stageName }}
jobs:
- deployment: Deploy
environment: ${{ parameters.environmentName }}
strategy:
runOnce:
deploy:
steps:
- task: AzureWebApp@1
displayName: 'Deploy Azure Web App'
inputs:
azureSubscription: '${{ parameters.serviceConnection }}'
appName: '${{ parameters.webAppName }}'
package: '$(Pipeline.Workspace)/drop/*.zip'Utilisation dans le pipeline principal :
# azure-pipelines.yml
stages:
- stage: Build
jobs:
- job: BuildJob
steps:
# Build steps...
- publish: '$(Build.ArtifactStagingDirectory)'
artifact: 'drop'
# Utilisation du modèle de stage pour plusieurs environnements
- template: templates/deploy-stage.yml
parameters:
stageName: 'DeployToDev'
environmentName: 'Development'
serviceConnection: 'DevAzureConnection'
webAppName: 'my-app-dev'
- template: templates/deploy-stage.yml
parameters:
stageName: 'DeployToTest'
environmentName: 'Testing'
serviceConnection: 'TestAzureConnection'
webAppName: 'my-app-test'# templates/conditional-tasks.yml
parameters:
runTests: true
publishArtifacts: true
steps:
- task: DotNetCoreCLI@2
displayName: 'Build project'
inputs:
command: 'build'
projects: '**/*.csproj'
# Exécution conditionnelle des tests
- ${{ if eq(parameters.runTests, true) }}:
- task: DotNetCoreCLI@2
displayName: 'Run tests'
inputs:
command: 'test'
projects: '**/*.Tests.csproj'
# Publication conditionnelle des artefacts
- ${{ if eq(parameters.publishArtifacts, true) }}:
- task: PublishBuildArtifacts@1
displayName: 'Publish artifacts'
inputs:
pathtoPublish: '$(Build.ArtifactStagingDirectory)'
artifactName: 'drop'# templates/multi-project-build.yml
parameters:
projects: []
steps:
- ${{ each project in parameters.projects }}:
- task: DotNetCoreCLI@2
displayName: 'Build ${{ project.name }}'
inputs:
command: 'build'
projects: '${{ project.path }}'
arguments: '--configuration ${{ project.configuration }}'Utilisation avec plusieurs projets :
# azure-pipelines.yml
steps:
- template: templates/multi-project-build.yml
parameters:
projects:
- name: 'API'
path: 'src/API/API.csproj'
configuration: 'Release'
- name: 'WebApp'
path: 'src/WebApp/WebApp.csproj'
configuration: 'Debug'Une bonne structure de répertoire pour les modèles :
/templates
/build # Modèles liés à la compilation
/test # Modèles liés aux tests
/deploy # Modèles liés au déploiement
/common # Modèles communs à plusieurs pipelines
/utilities # Tâches utilitaires
Pour partager des modèles entre projets :
# Référence à un modèle dans un autre dépôt
resources:
repositories:
- repository: templates
type: git
name: DevOpsTemplates
steps:
- template: build/dotnet.yml@templates
parameters:
buildConfiguration: 'Release'L’automatisation de l’inspection de la santé est un élément essentiel d’un pipeline DevOps mature. Cette pratique permet de surveiller en continu la santé des applications déployées et de déclencher des actions correctives si nécessaire. Dans cette section, nous explorerons les différentes approches pour automatiser l’inspection de la santé dans Azure DevOps.
L’inspection de la santé consiste à vérifier régulièrement l’état et les performances d’une application déployée pour s’assurer qu’elle fonctionne correctement. Cette inspection peut couvrir :
L’automatisation de l’inspection de la santé offre plusieurs avantages :
L’inspection de la santé peut être intégrée à différentes étapes du cycle de vie DevOps :
Azure Monitor est un service complet de surveillance qui collecte, analyse et agit sur les données de télémétrie de vos applications et ressources Azure.
Fonctionnalités principales :
Configuration dans un pipeline :
steps:
- task: AzureMonitor@1
displayName: 'Check Azure Monitor Alerts'
inputs:
connectedServiceNameARM: 'AzureServiceConnection'
resourceGroupName: '$(resourceGroupName)'
filterType: 'resource'
resource: '$(webAppName)'
alertState: 'Active'Application Insights est un service d’APM (Application Performance Management) qui surveille vos applications web en temps réel.
Points forts :
Configuration des tests de disponibilité :
# Exemple PowerShell pour configurer un test de disponibilité
$test = New-AzApplicationInsightsWebTest -Name "API Health Check" `
-ResourceGroupName "myResourceGroup" `
-Location "East US" `
-ApplicationInsightsComponent $appInsights `
-Frequency 300 `
-Timeout 120 `
-Kind "ping" `
-RetryEnabled $true `
-Url "https://myapi.azurewebsites.net/health"Azure Policy aide à appliquer des normes organisationnelles et à évaluer la conformité à l’échelle.
Utilisations pour l’inspection de la santé :
Les sondes (probes) sont des mécanismes pour vérifier l’état d’une application :
Exemple pour Kubernetes :
# Configuration de sondes dans un déploiement Kubernetes
apiVersion: apps/v1
kind: Deployment
metadata:
name: my-app
spec:
template:
spec:
containers:
- name: my-container
image: myapp:v1
livenessProbe:
httpGet:
path: /health/live
port: 8080
initialDelaySeconds: 15
periodSeconds: 10
readinessProbe:
httpGet:
path: /health/ready
port: 8080
initialDelaySeconds: 5
periodSeconds: 5Une bonne API de santé devrait :
// Exemple d'API de santé en ASP.NET Core
public void ConfigureServices(IServiceCollection services)
{
services.AddHealthChecks()
.AddCheck("SQL", () =>
{
using (var connection = new SqlConnection(_configuration["ConnectionStrings:DefaultConnection"]))
{
try
{
connection.Open();
return HealthCheckResult.Healthy();
}
catch (Exception ex)
{
return HealthCheckResult.Unhealthy(ex.Message);
}
}
})
.AddCheck<StorageHealthCheck>("Storage")
.AddCheck<ExternalApiHealthCheck>("ExternalAPI");
// Ajout d'un système de publication des résultats
services.AddHealthChecksUI()
.AddInMemoryStorage();
}
public void Configure(IApplicationBuilder app)
{
// Exposition de l'endpoint de santé
app.UseHealthChecks("/health", new HealthCheckOptions
{
ResponseWriter = async (context, report) =>
{
context.Response.ContentType = "application/json";
var response = new
{
status = report.Status.ToString(),
components = report.Entries.Select(e => new
{
component = e.Key,
status = e.Value.Status.ToString(),
description = e.Value.Description
})
};
await context.Response.WriteAsync(JsonSerializer.Serialize(response));
}
});
// Configuration du tableau de bord UI
app.UseHealthChecksUI(options =>
{
options.UIPath = "/healthui";
options.ApiPath = "/health-api";
});
}// Exemple de contrôleur de santé en Spring Boot
@RestController
public class HealthController {
@Autowired
private DatabaseService databaseService;
@Autowired
private CacheService cacheService;
@GetMapping("/health")
public ResponseEntity<HealthStatus> checkHealth() {
HealthStatus status = new HealthStatus();
// Vérification de la base de données
boolean dbHealth = databaseService.isHealthy();
status.addComponent("database", dbHealth ? "UP" : "DOWN");
// Vérification du cache
boolean cacheHealth = cacheService.isHealthy();
status.addComponent("cache", cacheHealth ? "UP" : "DOWN");
// Statut global
status.setOverallStatus(dbHealth && cacheHealth ? "UP" : "DOWN");
HttpStatus httpStatus = status.getOverallStatus().equals("UP") ?
HttpStatus.OK : HttpStatus.SERVICE_UNAVAILABLE;
return new ResponseEntity<>(status, httpStatus);
}
}Les portes de qualité sont des vérifications automatisées exécutées avant ou après un déploiement pour s’assurer que l’environnement est sain.
Configuration des portes de qualité :
# Configuration d'une porte de qualité via REST API
gates:
- id: 'restCallCheck'
type: 'HttpRequest'
inputs:
url: 'https://myapp.azurewebsites.net/health'
method: 'GET'
headers: '{"Content-Type": "application/json"}'
skipCertificateCheck: false
timeout: 30
successCriteria: 'eq(root.status, "UP")'Les tests fonctionnels peuvent servir d’inspection de santé avancée :
# Exemple d'intégration de tests fonctionnels post-déploiement
stages:
- stage: Deploy
jobs:
- deployment: DeployWebApp
environment: 'Production'
strategy:
runOnce:
deploy:
steps:
- task: AzureWebApp@1
inputs:
azureSubscription: '$(azureSubscription)'
appName: '$(webAppName)'
package: '$(Pipeline.Workspace)/drop/*.zip'
- stage: HealthCheck
dependsOn: Deploy
jobs:
- job: FunctionalTests
steps:
- task: VSTest@2
displayName: 'Run Functional Tests'
inputs:
testSelector: 'testAssemblies'
testAssemblyVer2: |
**\*HealthCheck*.dll
!**\obj\**
searchFolder: '$(System.DefaultWorkingDirectory)'
codeCoverageEnabled: trueIntégration de la surveillance continue :
# Exemple de tâche de surveillance
- task: AzureMonitorAlerts@0
displayName: 'Check for active alerts'
inputs:
ConnectedServiceNameARM: '$(azureServiceConnection)'
ResourceGroupName: '$(resourceGroupName)'
FilterType: 'Resource'
Resource: '$(webAppName)'
AlertState: 'Active'
SortBy: 'Severity asc'# Exemple de rollback automatique en cas de problème
steps:
- task: AzureMonitorAlerts@0
displayName: 'Check for active alerts'
inputs:
ConnectedServiceNameARM: '$(azureServiceConnection)'
ResourceGroupName: '$(resourceGroupName)'
FilterType: 'Resource'
Resource: '$(webAppName)'
AlertState: 'Active'
continueOnError: true
condition: succeeded()
name: alertsTask
- task: AzureAppServiceManage@0
displayName: 'Rollback to previous version'
condition: and(succeeded(), eq(variables['alertsTask.hasActiveAlerts'], 'true'))
inputs:
azureSubscription: '$(azureServiceConnection)'
action: 'Swap Slots'
webAppName: '$(webAppName)'
sourceSlot: 'production'
targetSlot: 'staging'La centralisation des journaux est essentielle pour une inspection efficace de la santé :
# Configuration d'Azure Log Analytics dans un pipeline
- task: AzureCLI@2
displayName: 'Configure Log Analytics'
inputs:
azureSubscription: '$(azureServiceConnection)'
scriptType: 'pscore'
scriptLocation: 'inlineScript'
inlineScript: |
$workspaceId = $(workspaceId)
$workspaceKey = $(workspaceKey)
az webapp config appsettings set --resource-group $(resourceGroupName) --name $(webAppName) --settings APPLICATIONINSIGHTS_CONNECTION_STRING=$(appInsightsConnectionString)Configuration d’un tableau de bord de santé :
La sécurité ne doit plus être considérée comme une étape distincte qui intervient après le développement, mais comme une partie intégrante du processus de développement continu. Cette section explore l’intégration de la sécurité dans le cycle DevOps, souvent appelée DevSecOps, et comment Azure DevOps permet cette intégration.
DevSecOps est l’intégration des pratiques, outils et cultures de sécurité dans l’ensemble du cycle de vie du développement logiciel, de la conception au déploiement et à la maintenance.
Les piliers de DevSecOps :
| Phase | Contrôles de sécurité |
|---|---|
| Planification | Modélisation des menaces, Exigences de sécurité |
| Développement | Analyse statique, Revue de code, Sécurité des dépendances |
| Build | Tests unitaires de sécurité, Analyse de composition logicielle |
| Test | Tests de pénétration, Tests dynamiques, Fuzzing |
| Déploiement | Analyse de configuration, Scan de vulnérabilités |
| Exploitation | Surveillance de sécurité, Gestion des incidents |
Dans DevSecOps, la sécurité n’est pas uniquement la responsabilité d’une équipe dédiée :
L’analyse statique examine le code source sans l’exécuter pour identifier les vulnérabilités potentielles.
Intégration dans Azure DevOps :
# Exemple d'intégration SonarQube
steps:
- task: SonarCloudPrepare@1
inputs:
SonarCloud: 'SonarCloud Connection'
organization: 'your-organization'
scannerMode: 'MSBuild'
projectKey: 'your-project-key'
projectName: 'Your Project Name'
extraProperties: |
sonar.exclusions=**/obj/**,**/bin/**
- task: DotNetCoreCLI@2
inputs:
command: 'build'
projects: '**/*.csproj'
arguments: '--configuration Release'
- task: SonarCloudAnalyze@1
- task: SonarCloudPublish@1
inputs:
pollingTimeoutSec: '300'L’analyse de composition logicielle vérifie les vulnérabilités connues dans les dépendances tierces.
Intégration dans Azure DevOps :
# Exemple d'intégration OWASP Dependency Check
- task: dependency-check-build-task@5
inputs:
projectName: '$(Build.Repository.Name)'
scanPath: '$(Build.SourcesDirectory)'
format: 'HTML,JSON'
failOnCVSS: '7'Détection des secrets codés en dur dans le code source :
# Exemple d'intégration de GitLeaks
- script: |
docker pull zricethezav/gitleaks
docker run --rm -v $(Build.SourcesDirectory):/src zricethezav/gitleaks detect --source="/src" --verbose --report-format=json --report-path=/src/gitleaks-report.json
displayName: 'Scan for secrets with GitLeaks'Les tests dynamiques analysent l’application en cours d’exécution pour identifier les vulnérabilités.
Intégration dans Azure DevOps :
# Exemple d'intégration OWASP ZAP
- task: Bash@3
inputs:
targetType: 'inline'
script: |
docker pull owasp/zap2docker-stable
docker run --rm -v $(pwd):/zap/wrk owasp/zap2docker-stable zap-baseline.py -t https://your-app-url.azurewebsites.net -g gen.conf -r zap-report.html
displayName: 'Run OWASP ZAP Scan'
- task: PublishBuildArtifacts@1
inputs:
pathtoPublish: '$(Build.SourcesDirectory)/zap-report.html'
artifactName: 'security-reports'
displayName: 'Publish ZAP Report'Vérification des configurations d’infrastructure sécurisées :
# Exemple d'utilisation de Checkov pour analyser l'infrastructure as code
- script: |
pip install checkov
checkov -d $(Build.SourcesDirectory)/terraform -o json > $(Build.ArtifactStagingDirectory)/checkov-report.json
displayName: 'Run Checkov on Terraform files'
- task: PublishBuildArtifacts@1
inputs:
pathtoPublish: '$(Build.ArtifactStagingDirectory)/checkov-report.json'
artifactName: 'security-reports'
displayName: 'Publish Checkov Report'Azure DevOps propose une suite de fonctionnalités de sécurité avancées :
Configuration dans un pipeline :
# Configuration d'Azure DevOps Advanced Security
steps:
- task: AdvancedSecurity-Codeql-Build@1
inputs:
buildCommands: 'dotnet build'
language: 'csharp'Les portes de sécurité sont des critères qui doivent être satisfaits avant de passer à l’étape suivante du pipeline :
# Exemple de porte de sécurité basée sur les vulnérabilités
- task: securitygate@1
inputs:
ConnectedServiceName: 'AzureConnection'
ResourceGroupName: '$(resourceGroupName)'
threshold: 'Critical'
maximumAllowedVulnerabilities: 0Azure DevOps permet de définir des politiques de sécurité pour les branches :
Azure Key Vault est un service géré qui permet de stocker et d’accéder de manière sécurisée aux secrets.
Intégration dans un pipeline Azure DevOps :
# Exemple d'intégration d'Azure Key Vault
- task: AzureKeyVault@2
inputs:
azureSubscription: 'Azure Service Connection'
KeyVaultName: 'your-key-vault'
SecretsFilter: '*'
RunAsPreJob: trueUtilisation des secrets dans le pipeline :
# Utilisation d'un secret Azure Key Vault
- task: AzureWebApp@1
inputs:
azureSubscription: 'Azure Service Connection'
appName: 'your-web-app'
deployToSlotOrASE: true
resourceGroupName: 'your-resource-group'
slotName: 'staging'
packageForLinux: '$(Build.ArtifactStagingDirectory)/**/*.zip'
appSettings: '-ConnectionString "$(ConnectionString)" -ApiKey "$(ApiKey)"'Utilisation de managed identities pour l’accès aux ressources Azure :
# Configuration d'une identité gérée pour un service Azure
- task: AzureCLI@2
inputs:
azureSubscription: 'Azure Service Connection'
scriptType: 'ps'
scriptLocation: 'inlineScript'
inlineScript: |
$resourceGroup = "$(resourceGroupName)"
$webappName = "$(webAppName)"
az webapp identity assign --resource-group $resourceGroup --name $webappNameConfiguration de la journalisation pour les audits de sécurité :
# Configuration de la journalisation Azure Monitor
- task: AzureCLI@2
inputs:
azureSubscription: 'Azure Service Connection'
scriptType: 'ps'
scriptLocation: 'inlineScript'
inlineScript: |
$resourceGroup = "$(resourceGroupName)"
$webappName = "$(webAppName)"
az webapp config appsettings set --resource-group $resourceGroup --name $webappName --settings APPLICATIONINSIGHTS_CONNECTION_STRING="$(AppInsightsConnectionString)" WEBSITE_HTTPLOGGING_RETENTION_DAYS=7Génération de rapports de conformité dans le pipeline :
# Exemple de génération de rapport de conformité
- task: PowerShell@2
inputs:
targetType: 'inline'
script: |
$securityScanResults = Get-Content -Path "$(Build.ArtifactStagingDirectory)/security-scan.json" | ConvertFrom-Json
$complianceReport = @{
ScanDate = Get-Date -Format "yyyy-MM-dd"
ProjectName = "$(Build.Repository.Name)"
CriticalVulnerabilities = $securityScanResults.critical
HighVulnerabilities = $securityScanResults.high
MediumVulnerabilities = $securityScanResults.medium
LowVulnerabilities = $securityScanResults.low
}
$complianceReport | ConvertTo-Json | Out-File -FilePath "$(Build.ArtifactStagingDirectory)/compliance-report.json"
displayName: 'Generate Compliance Report'Configuration d’alertes pour les incidents de sécurité :
# Configuration d'alertes Azure Monitor
- task: AzureCLI@2
inputs:
azureSubscription: 'Azure Service Connection'
scriptType: 'ps'
scriptLocation: 'inlineScript'
inlineScript: |
$resourceGroup = "$(resourceGroupName)"
$actionGroup = "$(alertActionGroup)"
az monitor metrics alert create --name "High401Errors" --resource-group $resourceGroup --scopes $(webAppId) --condition "count 401Response > 10" --window-size 5m --evaluation-frequency 1m --action $(actionGroupId)Processus de gestion des vulnérabilités détectées :
La gestion des données de configuration est un aspect crucial du déploiement continu. Elle permet de séparer le code de l’application des paramètres spécifiques à l’environnement, ce qui facilite le déploiement dans différents environnements (développement, test, production) sans modification du code.
- task: FileTransform@1
inputs:
folderPath: '$(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip'
fileType: 'json'
targetFiles: '**/appsettings.json'// Exemple d'intégration dans une application .NET
builder.Configuration.AddAzureAppConfiguration(options =>
{
options.Connect(connectionString)
.Select("myApp:*", "Production")
.ConfigureRefresh(refresh =>
{
refresh.Register("myApp:settings:Sentinel", refreshAll: true);
});
});# Exemple de connexion à Azure dans un pipeline en utilisant un Service Principal
- task: AzureCLI@2
inputs:
azureSubscription: 'my-service-connection'
scriptType: 'bash'
scriptLocation: 'inlineScript'
inlineScript: 'az webapp list --resource-group myResourceGroup'# Exemple d'utilisation d'Azure Key Vault dans un pipeline
- task: AzureKeyVault@2
inputs:
azureSubscription: 'my-service-connection'
KeyVaultName: 'my-key-vault'
SecretsFilter: 'ConnectionString,ApiKey'
RunAsPreJob: true# Exemple de variables de stage dans un pipeline YAML
stages:
- stage: Development
variables:
environment: 'dev'
resourceGroup: 'rg-app-dev'
jobs:
- job: Deploy
steps:
- script: echo Deploying to $(environment)
- stage: Production
variables:
environment: 'prod'
resourceGroup: 'rg-app-prod'
jobs:
- job: Deploy
steps:
- script: echo Deploying to $(environment)Création du fichier de pipeline de base
trigger:
- main
pool:
vmImage: 'ubuntu-latest'
variables:
buildConfiguration: 'Release'
stages:
- stage: Build
jobs:
- job: BuildJob
steps:
- script: echo Building the applicationAjout des étapes de compilation
- task: DotNetCoreCLI@2
inputs:
command: 'restore'
projects: '**/*.csproj'
- task: DotNetCoreCLI@2
inputs:
command: 'build'
projects: '**/*.csproj'
arguments: '--configuration $(buildConfiguration)'Configuration des tests
- task: DotNetCoreCLI@2
inputs:
command: 'test'
projects: '**/*Tests/*.csproj'
arguments: '--configuration $(buildConfiguration)'Ajout du déploiement multi-environnement
- stage: DeployToDev
dependsOn: Build
jobs:
- deployment: DeployToDevEnvironment
environment: 'development'
strategy:
runOnce:
deploy:
steps:
- script: echo Deploying to DEV
- stage: DeployToProd
dependsOn: DeployToDev
jobs:
- deployment: DeployToProdEnvironment
environment: 'production'
strategy:
runOnce:
deploy:
steps:
- script: echo Deploying to PRODConfiguration des tests unitaires
- task: DotNetCoreCLI@2
displayName: 'Run unit tests'
inputs:
command: 'test'
projects: '**/UnitTests/*.csproj'
arguments: '--configuration $(buildConfiguration) --collect:"XPlat Code Coverage"'Configuration des tests fonctionnels
- task: DotNetCoreCLI@2
displayName: 'Run functional tests'
inputs:
command: 'test'
projects: '**/FunctionalTests/*.csproj'
arguments: '--configuration $(buildConfiguration)'Publication des résultats de test
- task: PublishCodeCoverageResults@1
displayName: 'Publish code coverage report'
inputs:
codeCoverageTool: 'Cobertura'
summaryFileLocation: '$(Agent.TempDirectory)/**/coverage.cobertura.xml'Définition des seuils de qualité
- task: PublishTestResults@2
inputs:
testResultsFormat: 'VSTest'
testResultsFiles: '**/*.trx'
failTaskOnFailedTests: trueConfiguration de la connexion à Key Vault
- task: AzureKeyVault@2
inputs:
azureSubscription: 'Azure subscription'
KeyVaultName: 'myKeyVault'
SecretsFilter: '*'
RunAsPreJob: trueUtilisation des secrets dans le pipeline
- task: AzureRmWebAppDeployment@4
inputs:
ConnectionType: 'AzureRM'
azureSubscription: 'Azure subscription'
appType: 'webApp'
WebAppName: 'myWebApp'
deployToSlotOrASE: true
ResourceGroupName: 'myResourceGroup'
SlotName: 'staging'
ConnectionString: '$(myConnectionString)'Rotation des secrets
# Script PowerShell pour la rotation des secrets
$newPassword = [System.Guid]::NewGuid().ToString()
# Mettre à jour le secret dans Key Vault
az keyvault secret set --vault-name "myKeyVault" --name "DatabasePassword" --value $newPassword
# Mettre à jour le mot de passe dans la base de données
# [Code pour mettre à jour le mot de passe dans la base de données]Configuration d’Azure App Configuration
- task: AzureCLI@2
inputs:
azureSubscription: 'Azure subscription'
scriptType: 'bash'
scriptLocation: 'inlineScript'
inlineScript: |
az appconfig kv set --name myAppConfig --key "MyApp:Settings:BackgroundColor" --value "blue" --label "dev" --yes
az appconfig kv set --name myAppConfig --key "MyApp:Settings:BackgroundColor" --value "green" --label "prod" --yesConfiguration des feature flags
- task: AzureCLI@2
inputs:
azureSubscription: 'Azure subscription'
scriptType: 'bash'
scriptLocation: 'inlineScript'
inlineScript: |
az appconfig feature set --name myAppConfig --feature "Beta_Feature" --label "dev" --enable true
az appconfig feature set --name myAppConfig --feature "Beta_Feature" --label "prod" --enable falseIntégration avec l’application
// Exemple de code C# pour utiliser les feature flags
public class HomeController : Controller
{
private readonly IFeatureManager _featureManager;
public HomeController(IFeatureManager featureManager)
{
_featureManager = featureManager;
}
public async Task<IActionResult> Index()
{
if (await _featureManager.IsEnabledAsync("Beta_Feature"))
{
ViewData["Message"] = "La fonctionnalité bêta est activée!";
}
return View();
}
}Mise à jour des feature flags via le pipeline
- task: AzureCLI@2
inputs:
azureSubscription: 'Azure subscription'
scriptType: 'bash'
scriptLocation: 'inlineScript'
inlineScript: |
# Activer une fonctionnalité lors du déploiement
az appconfig feature set --name myAppConfig --feature "New_UI" --label "$(Environment)" --enable trueQuelle est la meilleure pratique pour gérer les secrets dans un pipeline Azure DevOps?
Réponse correcte : B
Quelle stratégie de déploiement permet de déployer une nouvelle version de l’application à un petit groupe d’utilisateurs avant de la déployer à tous les utilisateurs?
Réponse correcte : C
Comment implémenter correctement des indicateurs de fonctionnalités (feature flags) dans une application .NET?
Réponse correcte : C
Quelle est la meilleure approche pour gérer les configurations spécifiques à l’environnement dans un pipeline CI/CD?
Réponse correcte : B
Quelle tâche dans un pipeline YAML est utilisée pour permuter les slots de déploiement dans Azure App Service?
Réponse correcte : C
À la fin de ce module, vous serez capable de :
L’Infrastructure as Code (IaC) est une approche de gestion des infrastructures informatiques où l’on définit et déploie les infrastructures à l’aide de fichiers de configuration et de code source, plutôt que par des configurations manuelles ou des scripts interactifs.
| Configuration | Scripting |
|---|---|
| Décrit l’état souhaité | Décrit les actions à exécuter |
| Gère les dépendances | Exécution linéaire |
| Idempotent | Peut ne pas être idempotent |
| Ex : ARM, Terraform | Ex : PowerShell, Bash |
Azure Resource Manager est le service de déploiement et de gestion pour Azure. Il fournit une couche de gestion qui permet de créer, mettre à jour et supprimer des ressources dans votre compte Azure.
Les modèles ARM sont des fichiers JSON avec la structure suivante :
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {},
"variables": {},
"functions": [],
"resources": [],
"outputs": {}
}Exemple de modèle pour déployer un compte de stockage Azure :
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"storageAccountName": {
"type": "string",
"metadata": {
"description": "Name of the storage account"
}
},
"location": {
"type": "string",
"defaultValue": "[resourceGroup().location]",
"metadata": {
"description": "Location for all resources"
}
}
},
"resources": [
{
"type": "Microsoft.Storage/storageAccounts",
"apiVersion": "2021-04-01",
"name": "[parameters('storageAccountName')]",
"location": "[parameters('location')]",
"sku": {
"name": "Standard_LRS"
},
"kind": "StorageV2"
}
],
"outputs": {
"storageAccountId": {
"type": "string",
"value": "[resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName'))]"
}
}
}New-AzResourceGroupDeployment -ResourceGroupName MonGroupe -TemplateFile ./monmodele.json -TemplateParameterFile ./parametres.jsonaz deployment group create --resource-group MonGroupe --template-file ./monmodele.json --parameters ./parametres.jsonAzure CLI est un outil de ligne de commande multiplateforme qui permet de gérer les ressources Azure. Il est disponible pour Windows, macOS et Linux.
Invoke-WebRequest -Uri https://aka.ms/installazurecliwindows -OutFile .\AzureCLI.msi
Start-Process msiexec.exe -Wait -ArgumentList '/I AzureCLI.msi /quiet'
brew update && brew install azure-cli
curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash
# Connexion interactive
az login
# Connexion avec un compte de service
az login --service-principal -u <app-id> -p <password-or-cert> --tenant <tenant># Création d'un groupe de ressources
az group create --name MonGroupe --location francecentral
# Liste des groupes de ressources
az group list --output table
# Suppression d'un groupe de ressources
az group delete --name MonGroupe --yes --no-waitaz storage account create \
--name mystorageaccount \
--resource-group MonGroupe \
--location francecentral \
--sku Standard_LRS \
--kind StorageV2az vm create \
--resource-group MonGroupe \
--name MyVM \
--image UbuntuLTS \
--admin-username azureuser \
--generate-ssh-keysExemple de script pour créer un environnement complet :
#!/bin/bash
# Variables
resourceGroup="MonEnvironnement"
location="francecentral"
vmName="maVM"
storageName="monstorage$RANDOM"
# Création du groupe de ressources
az group create --name $resourceGroup --location $location
# Création du compte de stockage
az storage account create \
--name $storageName \
--resource-group $resourceGroup \
--location $location \
--sku Standard_LRS
# Création de la VM
az vm create \
--resource-group $resourceGroup \
--name $vmName \
--image UbuntuLTS \
--admin-username azureuser \
--generate-ssh-keys
echo "Environnement déployé avec succès !"# Exporter un groupe de ressources en modèle ARM
az group export --name MonGroupe > template.jsonAzure Automation est un service d’automatisation et de configuration basé sur le cloud qui permet une gestion cohérente des environnements Azure et non-Azure.
Les runbooks sont des ensembles d’actions ou de tâches qui s’exécutent sur Azure Automation.
# Exemple de runbook qui démarre toutes les VM d'un groupe de ressources
param (
[Parameter(Mandatory=$true)]
[string] $ResourceGroupName
)
# Connexion au compte Run As
$connection = Get-AutomationConnection -Name "AzureRunAsConnection"
Connect-AzAccount -ServicePrincipal -Tenant $connection.TenantID `
-ApplicationId $connection.ApplicationID -CertificateThumbprint $connection.CertificateThumbprint
# Démarrage des VMs
$VMs = Get-AzVM -ResourceGroupName $ResourceGroupName
foreach ($VM in $VMs) {
Start-AzVM -ResourceGroupName $ResourceGroupName -Name $VM.Name
Write-Output "Démarrage de la VM: $($VM.Name)"
}# Extrait de pipeline YAML
- task: PowerShell@2
inputs:
targetType: 'inline'
script: |
$uri = "https://webhook-url-from-automation"
$body = @{
ResourceGroupName = "MonGroupe"
} | ConvertTo-Json
$response = Invoke-WebRequest -Method Post -Uri $uri -Body $body -ContentType "application/json"
Write-Host "Response: $($response.Content)"Azure Automation Inventory collecte et visualise les informations sur les logiciels installés, les fichiers, les services Windows, les clés de registre, etc.
PowerShell Desired State Configuration (DSC) est une plateforme de gestion de configuration intégrée à Windows PowerShell. Elle permet de définir, déployer et gérer la configuration des systèmes.
# Configuration pour installer IIS
Configuration WebServerConfig {
# Import du module nécessaire
Import-DscResource -ModuleName PSDesiredStateConfiguration
# Nœud à configurer (localhost ou nom spécifique)
Node 'localhost' {
# Installer le rôle IIS
WindowsFeature IIS {
Ensure = "Present"
Name = "Web-Server"
}
# Créer un fichier index.html
File WebContent {
Ensure = "Present"
Type = "File"
DestinationPath = "C:\inetpub\wwwroot\index.html"
Contents = "<html><body><h1>Mon serveur Web avec DSC</h1></body></html>"
DependsOn = "[WindowsFeature]IIS"
}
}
}
# Compilation de la configuration
WebServerConfig -OutputPath "C:\DSC"# Application directe
Start-DscConfiguration -Path "C:\DSC" -Wait -Verbose
# Test de la configuration
Test-DscConfiguration -Path "C:\DSC"# Configuration du LCM en mode Pull
[DSCLocalConfigurationManager()]
Configuration LCMConfig {
Node localhost {
Settings {
RefreshMode = "Pull"
ConfigurationMode = "ApplyAndAutoCorrect"
ConfigurationModeFrequencyMins = 15
}
ConfigurationRepositoryWeb PullServer {
ServerURL = "https://dscpullserver.contoso.com/PSDSCPullServer.svc"
RegistrationKey = "140a952b-b9d6-406b-b416-e0f759c9c0e4"
ConfigurationNames = @("WebServerConfig")
}
}
}
# Application de la configuration du LCM
LCMConfig -OutputPath "C:\LCM"
Set-DscLocalConfigurationManager -Path "C:\LCM" -VerboseAzure Automation DSC permet de gérer centralement les configurations DSC pour les nœuds Azure et sur site.
# Enregistrement d'un nœud Windows avec Azure Automation DSC
$RegistrationInfo = Register-AzAutomationDscNode `
-AutomationAccountName "MonCompteAutomation" `
-ResourceGroupName "MonGrouepRessources" `
-AzureVMName "MaVMAzure" `
-NodeConfigurationName "WebServerConfig.localhost" `
-ConfigurationMode "ApplyAndAutoCorrect" `
-RefreshFrequencyMins 30 `
-ActionAfterReboot "ContinueConfiguration" `
-RebootNodeIfNeeded $trueChef est un outil de gestion de configuration qui permet d’automatiser la façon dont l’infrastructure est configurée, déployée et gérée.
# Cookbook pour installer et configurer un serveur web
package 'apache2' do
action :install
end
template '/var/www/html/index.html' do
source 'index.html.erb'
owner 'www-data'
group 'www-data'
mode '0644'
action :create
end
service 'apache2' do
action [:enable, :start]
endPuppet est une plateforme d’automatisation qui permet de gérer l’infrastructure tout au long de son cycle de vie.
# Manifeste pour installer et configurer un serveur web
node 'webserver.example.com' {
# Installation du package Apache
package { 'apache2':
ensure => installed,
}
# Création du fichier index.html
file { '/var/www/html/index.html':
ensure => file,
content => "<html><body><h1>Mon serveur web Puppet</h1></body></html>",
owner => 'www-data',
group => 'www-data',
mode => '0644',
require => Package['apache2'],
}
# Gestion du service Apache
service { 'apache2':
ensure => running,
enable => true,
require => [Package['apache2'], File['/var/www/html/index.html']],
}
}
Ansible est un outil d’automatisation open-source qui permet de configurer des systèmes, déployer des logiciels et orchestrer des tâches plus avancées.
sudo apt update
sudo apt install -y ansiblesudo yum install -y epel-release
sudo yum install -y ansible# /etc/ansible/hosts ou fichier personnalisé
[webservers]
web1.example.com
web2.example.com
[dbservers]
db1.example.com
db2.example.com
[all:vars]
ansible_user=admin
ansible_ssh_private_key_file=/path/to/key.pem
# playbook.yml - Installation et configuration d'un serveur web
- name: Configure web servers
hosts: webservers
become: yes
tasks:
- name: Install Apache
apt:
name: apache2
state: present
when: ansible_os_family == "Debian"
- name: Install Apache on RedHat
yum:
name: httpd
state: present
when: ansible_os_family == "RedHat"
- name: Create index.html
copy:
content: "<html><body><h1>Serveur configuré avec Ansible</h1></body></html>"
dest: /var/www/html/index.html
owner: www-data
group: www-data
mode: '0644'
- name: Start and enable Apache service
service:
name: "{{ 'apache2' if ansible_os_family == 'Debian' else 'httpd' }}"
state: started
enabled: yes# Exécution simple
ansible-playbook playbook.yml
# Avec un inventaire personnalisé
ansible-playbook -i inventory.ini playbook.yml
# Avec des variables supplémentaires
ansible-playbook playbook.yml -e "variable=valeur"
# Avec une vérification (dry run)
ansible-playbook playbook.yml --checkpip install ansible[azure]export AZURE_CLIENT_ID="your-client-id"
export AZURE_SECRET="your-client-secret"
export AZURE_SUBSCRIPTION_ID="your-subscription-id"
export AZURE_TENANT="your-tenant-id"
# azure_vm.yml - Création d'une VM Azure
- name: Create Azure VM
hosts: localhost
connection: local
tasks:
- name: Create resource group
azure_rm_resourcegroup:
name: myResourceGroup
location: westeurope
- name: Create virtual network
azure_rm_virtualnetwork:
name: myVNet
resource_group: myResourceGroup
address_prefixes: "10.0.0.0/16"
- name: Create subnet
azure_rm_subnet:
name: mySubnet
resource_group: myResourceGroup
virtual_network: myVNet
address_prefix: "10.0.1.0/24"
- name: Create VM
azure_rm_virtualmachine:
resource_group: myResourceGroup
name: myVM
vm_size: Standard_DS1_v2
admin_username: azureuser
admin_password: Password1234!
image:
offer: UbuntuServer
publisher: Canonical
sku: 18.04-LTS
version: latestTerraform est un outil d’infrastructure as code qui permet de créer, modifier et versionner l’infrastructure de manière sécurisée et efficace.
choco install terraform
brew install terraform
curl -fsSL https://apt.releases.hashicorp.com/gpg | sudo apt-key add -
sudo apt-add-repository "deb [arch=amd64] https://apt.releases.hashicorp.com $(lsb_release -cs) main"
sudo apt-get update && sudo apt-get install terraform# Création d'un Service Principal
az ad sp create-for-rbac --name TerraformSP --role Contributor --scopes /subscriptions/your-subscription-id
# Variables d'environnement
export ARM_CLIENT_ID="your-client-id"
export ARM_CLIENT_SECRET="your-client-secret"
export ARM_SUBSCRIPTION_ID="your-subscription-id"
export ARM_TENANT_ID="your-tenant-id"terraform {
required_providers {
azurerm = {
source = "hashicorp/azurerm"
version = "~> 2.65"
}
}
}
provider "azurerm" {
features {}
}
# Groupe de ressources
resource "azurerm_resource_group" "example" {
name = "example-resources"
location = "West Europe"
}
# Réseau virtuel
resource "azurerm_virtual_network" "example" {
name = "example-network"
address_space = ["10.0.0.0/16"]
location = azurerm_resource_group.example.location
resource_group_name = azurerm_resource_group.example.name
}
# Sous-réseau
resource "azurerm_subnet" "example" {
name = "internal"
resource_group_name = azurerm_resource_group.example.name
virtual_network_name = azurerm_virtual_network.example.name
address_prefixes = ["10.0.2.0/24"]
}
# Interface réseau
resource "azurerm_network_interface" "example" {
name = "example-nic"
location = azurerm_resource_group.example.location
resource_group_name = azurerm_resource_group.example.name
ip_configuration {
name = "internal"
subnet_id = azurerm_subnet.example.id
private_ip_address_allocation = "Dynamic"
}
}
# Machine virtuelle
resource "azurerm_linux_virtual_machine" "example" {
name = "example-machine"
resource_group_name = azurerm_resource_group.example.name
location = azurerm_resource_group.example.location
size = "Standard_DS1_v2"
admin_username = "adminuser"
network_interface_ids = [
azurerm_network_interface.example.id,
]
admin_ssh_key {
username = "adminuser"
public_key = file("~/.ssh/id_rsa.pub")
}
os_disk {
caching = "ReadWrite"
storage_account_type = "Standard_LRS"
}
source_image_reference {
publisher = "Canonical"
offer = "UbuntuServer"
sku = "18.04-LTS"
version = "latest"
}
}
variable "resource_group_name" {
description = "Nom du groupe de ressources"
type = string
default = "example-resources"
}
variable "location" {
description = "Région Azure pour les ressources"
type = string
default = "West Europe"
}
variable "vm_size" {
description = "Taille de la machine virtuelle"
type = string
default = "Standard_DS1_v2"
}
variable "admin_username" {
description = "Nom d'utilisateur administrateur"
type = string
default = "adminuser"
}
# Definition d'un module dans le dossier modules/web_server/main.tf
# modules/web_server/main.tf
resource "azurerm_network_interface" "web" {
name = "${var.name}-nic"
location = var.location
resource_group_name = var.resource_group_name
ip_configuration {
name = "internal"
subnet_id = var.subnet_id
private_ip_address_allocation = "Dynamic"
}
}
resource "azurerm_linux_virtual_machine" "web" {
name = "${var.name}-vm"
location = var.location
resource_group_name = var.resource_group_name
size = var.vm_size
admin_username = var.admin_username
network_interface_ids = [
azurerm_network_interface.web.id,
]
admin_ssh_key {
username = var.admin_username
public_key = file(var.ssh_public_key_path)
}
os_disk {
caching = "ReadWrite"
storage_account_type = "Standard_LRS"
}
source_image_reference {
publisher = "Canonical"
offer = "UbuntuServer"
sku = "18.04-LTS"
version = "latest"
}
}
# modules/web_server/variables.tf
variable "name" {
description = "Nom de base pour les ressources"
type = string
}
variable "location" {
description = "Région Azure"
type = string
}
variable "resource_group_name" {
description = "Nom du groupe de ressources"
type = string
}
variable "subnet_id" {
description = "ID du sous-réseau"
type = string
}
variable "vm_size" {
description = "Taille de la VM"
type = string
default = "Standard_DS1_v2"
}
variable "admin_username" {
description = "Nom d'utilisateur administrateur"
type = string
default = "adminuser"
}
variable "ssh_public_key_path" {
description = "Chemin vers la clé SSH publique"
type = string
default = "~/.ssh/id_rsa.pub"
}
# Utilisation du module dans le fichier principal
# main.tf
module "web_server" {
source = "./modules/web_server"
name = "web"
location = azurerm_resource_group.example.location
resource_group_name = azurerm_resource_group.example.name
subnet_id = azurerm_subnet.example.id
vm_size = var.vm_size
admin_username = var.admin_username
}
Par défaut, Terraform stocke l’état de l’infrastructure dans un fichier local terraform.tfstate.
terraform {
backend "azurerm" {
resource_group_name = "terraform-state-rg"
storage_account_name = "terraformstate123"
container_name = "tfstate"
key = "prod.terraform.tfstate"
}
required_providers {
azurerm = {
source = "hashicorp/azurerm"
version = "~> 2.65"
}
}
}
Configuration du stockage d’état :
# Création du groupe de ressources pour l'état
az group create --name terraform-state-rg --location westeurope
# Création du compte de stockage
az storage account create --name terraformstate123 --resource-group terraform-state-rg --sku Standard_LRS
# Création du conteneur de stockage
az storage container create --name tfstate --account-name terraformstate123terraform initterraform plan -out=tfplanterraform apply tfplanterraform destroyLes dépendances logicielles sont des composants ou bibliothèques externes dont votre application a besoin pour fonctionner correctement. Dans le développement moderne, il est rare qu’une application soit entièrement autonome sans dépendances externes.
| Langage | Outils | Description |
|---|---|---|
| .NET | NuGet Package Explorer, dotnet list package | Visualisation et gestion des packages NuGet |
| Java | Maven Dependency Plugin, Gradle Dependencies | Analyse des dépendances Maven/Gradle |
| JavaScript | npm list, yarn list, npm-check | Liste et vérification des dépendances NPM |
| Python | pip list, pipdeptree, pipenv graph | Analyse des dépendances Python |
| Go | go list -m all, go mod graph | Liste des modules Go et leurs dépendances |
# Lister toutes les dépendances du projet
dotnet list package
# Lister les dépendances obsolètes
dotnet list package --outdated
# Vérifier les vulnérabilités
dotnet list package --vulnerable# Lister les dépendances directes
npm list --depth=0
# Vérifier les vulnérabilités
npm audit
# Visualiser l'arbre de dépendances
npm listAzure DevOps propose des outils pour visualiser et gérer les dépendances de votre projet :
# Exemple de gestion des dépendances .NET dans un pipeline Azure
trigger:
- main
pool:
vmImage: 'ubuntu-latest'
steps:
- task: DotNetCoreCLI@2
displayName: 'Restore NuGet packages'
inputs:
command: 'restore'
projects: '**/*.csproj'
feedsToUse: 'select'
vstsFeed: 'my-feed'
- task: DotNetCoreCLI@2
displayName: 'Check for vulnerable packages'
inputs:
command: 'custom'
custom: 'list'
arguments: 'package --vulnerable'
projects: '**/*.csproj'
- task: DotNetCoreCLI@2
displayName: 'Build'
inputs:
command: 'build'
projects: '**/*.csproj'Un référentiel de packages (ou feed) est un emplacement centralisé pour stocker et distribuer des packages. Il existe deux types principaux de feeds :
Azure Artifacts est le service de gestion de packages intégré à Azure DevOps. Il permet de créer, héberger et partager des packages.
<!-- NuGet.config -->
<?xml version="1.0" encoding="utf-8"?>
<configuration>
<packageSources>
<clear />
<add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
<add key="MyPrivateFeed" value="https://pkgs.dev.azure.com/myorg/_packaging/myfeed/nuget/v3/index.json" />
</packageSources>
</configuration>// .npmrc
registry=https://registry.npmjs.org/
@mycompany:registry=https://pkgs.dev.azure.com/myorg/_packaging/myfeed/npm/registry/
always-auth=true# Exemple de publication d'un package NuGet
steps:
- task: DotNetCoreCLI@2
displayName: 'Pack'
inputs:
command: 'pack'
packagesToPack: '**/*.csproj'
versioningScheme: 'byPrereleaseNumber'
majorVersion: '1'
minorVersion: '0'
patchVersion: '0'
- task: NuGetCommand@2
displayName: 'Push'
inputs:
command: 'push'
packagesToPush: '$(Build.ArtifactStagingDirectory)/**/*.nupkg'
nuGetFeedType: 'internal'
publishVstsFeed: 'myfeed'# Exemple de consommation de packages NPM
steps:
- task: Npm@1
displayName: 'npm install'
inputs:
command: 'install'
customRegistry: 'useFeed'
customFeed: 'myfeed'Azure Artifacts permet de définir des politiques pour la gestion du cycle de vie des packages :
La migration des artefacts peut être nécessaire lors de la consolidation des systèmes ou de la transition vers de nouveaux outils.
| Type de package | Outils de migration |
|---|---|
| NuGet | nuget-migrate, nuget.exe, dotnet nuget |
| npm | npm-migrate, verdaccio-migration-tools |
| Maven | maven-artifact-transfer, jfrog-cli |
| Docker | skopeo, docker save/load |
# Récupérer tous les packages d'un feed source
$packages = Find-Package -Source "Source Feed URL" -AllVersions
# Publier chaque package dans Azure Artifacts
foreach ($package in $packages) {
$packagePath = Install-Package $package -ProviderName NuGet -Source "Source Feed URL" -Destination .
nuget push "$packagePath\$($package.Name).$($package.Version).nupkg" -Source "Azure Artifacts URL" -ApiKey az
}La consolidation des référentiels vise à réduire la complexité et améliorer la gouvernance.
| Pratique | Description |
|---|---|
| Scan des vulnérabilités | Utiliser des outils comme OWASP Dependency Check, Snyk, WhiteSource |
| Signature des packages | Vérifier l’authenticité des packages via des signatures numériques |
| Intégration des scans dans les pipelines | Automatiser la détection des vulnérabilités |
| Contrôle d’accès | Limiter qui peut publier et consommer des packages |
| Utilisation de feeds privés | Limiter l’exposition aux packages publics non vérifiés |
steps:
- task: WhiteSource@21
displayName: 'WhiteSource Scan'
inputs:
cwd: '$(Build.SourcesDirectory)'
projectName: '$(Build.Repository.Name)'
- task: SnykSecurityScan@1
displayName: 'Snyk Security Scan'
inputs:
serviceConnectionEndpoint: 'Snyk'
testType: 'app'
severityThreshold: 'high'
monitorWhen: 'always'# Script de synchronisation de packages entre deux feeds
$sourcePackages = Get-ChildItem -Path ".\packages" -Filter "*.nupkg"
foreach ($package in $sourcePackages) {
# Push vers Azure DevOps Artifacts
nuget push $package.FullName -Source "https://pkgs.dev.azure.com/org/project/_packaging/feed/nuget/v3/index.json" -ApiKey az
# Push vers AWS CodeArtifact
aws codeartifact login --tool nuget --domain mydomain --domain-owner 111122223333 --repository myrepo
nuget push $package.FullName -Source "https://mydomain-111122223333.d.codeartifact.us-west-2.amazonaws.com/nuget/myrepo/v3/index.json"
}Le versionnage sémantique est une convention de numérotation des versions qui permet de communiquer clairement les types de modifications apportées entre les versions.
MAJEUR.MINEUR.CORRECTIF[-préversion][+métadonnées]
1.0.0 : Version initiale stable1.1.0 : Ajout de fonctionnalités1.1.1 : Correction de bugs2.0.0 : Modifications incompatibles1.0.0-alpha.1 : Version alpha1.0.0-beta.2 : Version bêta1.0.0-rc.1 : Version candidateFormat basé sur la date : ANNÉE.MOIS.RÉVISION - Exemple : 2023.04.001 - Avantages : Indique clairement quand la version a été publiée - Inconvénients : Ne communique pas la nature des changements
Basé sur des identifiants uniques comme les numéros de build ou les commits - Exemple : 1.0.0+20230413.1 ou 1.0.0+abcdef - Avantages : Traçabilité directe avec le code source - Inconvénients : Difficile à interpréter pour les utilisateurs
Combinaison de plusieurs approches - Exemple : 2023.1.0-rc.2+build.123 - Avantages : Flexibilité maximale - Inconvénients : Peut devenir complexe
steps:
- task: GitVersion@5
displayName: 'GitVersion'
inputs:
runtime: 'core'
configFilePath: 'GitVersion.yml'
- task: DotNetCoreCLI@2
displayName: 'Pack'
inputs:
command: 'pack'
packagesToPack: '**/*.csproj'
versioningScheme: 'byEnvVar'
versionEnvVar: 'GitVersion.SemVer'Configuration GitVersion.yml :
mode: ContinuousDelivery
branches:
main:
tag: ''
feature:
tag: beta
hotfix:
tag: patch
release:
tag: rc<!-- Versionnage dans le fichier .csproj -->
<PropertyGroup>
<Version>1.2.3</Version>
<AssemblyVersion>1.2.3.0</AssemblyVersion>
<FileVersion>1.2.3.0</FileVersion>
<PackageVersion>1.2.3-beta.1</PackageVersion>
</PropertyGroup>// package.json
{
"name": "my-package",
"version": "1.2.3-beta.1",
"description": "My package description"
}<!-- pom.xml -->
<project>
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>my-project</artifactId>
<version>1.2.3-SNAPSHOT</version>
</project>// Versionnage dans l'URL
[Route("api/v1/products")]
public class ProductsV1Controller : ControllerBase { }
[Route("api/v2/products")]
public class ProductsV2Controller : ControllerBase { }
// Versionnage dans l'en-tête
[ApiVersion("1.0")]
[Route("api/products")]
public class ProductsV1Controller : ControllerBase { }
[ApiVersion("2.0")]
[Route("api/products")]
public class ProductsV2Controller : ControllerBase { }Instructions:
Instructions:
trigger:
- main
pool:
vmImage: 'ubuntu-latest'
steps:
- task: UseDotNet@2
inputs:
packageType: 'sdk'
version: '6.0.x'
- task: DotNetCoreCLI@2
displayName: 'Restore packages'
inputs:
command: 'restore'
projects: '**/*.csproj'
- task: DotNetCoreCLI@2
displayName: 'Build'
inputs:
command: 'build'
projects: '**/*.csproj'
# Ajouter le scan de sécurité avec MSDO
- task: MicrosoftSecurityDevOps@1
displayName: 'Exécuter Microsoft Security DevOps'
inputs:
categories: 'IaC,containers,code'
break: true
- task: DotNetCoreCLI@2
displayName: 'Publish'
inputs:
command: 'publish'
publishWebProjects: true
arguments: '--configuration Release --output $(Build.ArtifactStagingDirectory)'
- task: PublishBuildArtifacts@1
displayName: 'Publish Build Artifacts'
inputs:
pathToPublish: '$(Build.ArtifactStagingDirectory)'
artifactName: 'drop'- task: dependency-check-build-task@6
displayName: 'Analyse des dépendances avec OWASP Dependency Check'
inputs:
projectName: '$(Build.Repository.Name)'
scanPath: '$(Build.SourcesDirectory)'
format: 'HTML,JSON'
failOnCVSS: '7'- task: PublishBuildArtifacts@1
displayName: 'Publier les résultats du scan de sécurité'
inputs:
pathToPublish: '$(Build.SourcesDirectory)/dependency-check-report.html'
artifactName: 'security-reports'Instructions:
{
"properties": {
"displayName": "Audit AppService HTTPS Only",
"description": "Audit if HTTPS Only is enabled for App Service",
"mode": "Indexed",
"parameters": {},
"policyRule": {
"if": {
"allOf": [
{
"field": "type",
"equals": "Microsoft.Web/sites"
},
{
"field": "Microsoft.Web/sites/httpsOnly",
"notEquals": true
}
]
},
"then": {
"effect": "audit"
}
}
}
}- task: AzurePolicyComplianceCheck@0
displayName: 'Vérification de la conformité Azure Policy'
inputs:
azureSubscriptionEndpoint: '$(AzureSubscriptionEndpoint)'
resourceGroupName: '$(ResourceGroupName)'
resourceId: '$(ResourceId)'Instructions:
- task: AzureKeyVault@2
inputs:
azureSubscription: '$(AzureSubscriptionName)'
KeyVaultName: '$(KeyVaultName)'
SecretsFilter: 'DatabaseConnectionString'
RunAsPreJob: true
# Utiliser le secret plus tard dans le pipeline
- task: AzureWebApp@1
inputs:
azureSubscription: '$(AzureSubscriptionName)'
appName: '$(WebAppName)'
package: '$(System.ArtifactsDirectory)/**/*.zip'
appSettings: '-ConnectionString "$(DatabaseConnectionString)"'Pour valider cet atelier, répondez aux questions suivantes:
Instructions:
Instructions:
trigger:
- main
pool:
vmImage: 'ubuntu-latest'
variables:
buildConfiguration: 'Release'
steps:
- task: SonarCloudPrepare@1
inputs:
SonarCloud: 'SonarCloud'
organization: 'votre-organisation'
scannerMode: 'MSBuild'
projectKey: 'votre-projet-key'
projectName: 'Nom du Projet'
extraProperties: |
sonar.exclusions=**/obj/**,**/bin/**
sonar.cs.opencover.reportsPaths=$(Build.SourcesDirectory)/**/coverage.opencover.xml
sonar.cs.vstest.reportsPaths=$(Agent.TempDirectory)/*.trx
- task: DotNetCoreCLI@2
displayName: 'Restore'
inputs:
command: 'restore'
projects: '**/*.csproj'
- task: DotNetCoreCLI@2
displayName: 'Build'
inputs:
command: 'build'
projects: '**/*.csproj'
arguments: '--configuration $(buildConfiguration)'
- task: DotNetCoreCLI@2
displayName: 'Test with code coverage'
inputs:
command: 'test'
projects: '**/*Tests/*.csproj'
arguments: '--configuration $(buildConfiguration) --collect:"XPlat Code Coverage" -- DataCollectionRunSettings.DataCollectors.DataCollector.Configuration.Format=opencover'
- task: SonarCloudAnalyze@1
displayName: 'Run SonarCloud Analysis'
- task: SonarCloudPublish@1
displayName: 'Publish SonarCloud Results'
inputs:
pollingTimeoutSec: '300'- task: SonarCloudPrepare@1
inputs:
SonarCloud: 'SonarCloud'
organization: 'votre-organisation'
scannerMode: 'CLI'
configMode: 'manual'
cliProjectKey: 'votre-projet-key'
cliProjectName: 'Nom du Projet'
cliSources: '.'
extraProperties: |
sonar.sources=src
sonar.tests=tests
sonar.javascript.lcov.reportPaths=coverage/lcov.infoInstructions:
- task: SonarCloudPublish@1
inputs:
pollingTimeoutSec: '300'
- task: PowerShell@2
displayName: 'Vérifier Quality Gate SonarCloud'
inputs:
targetType: 'inline'
script: |
$status = Invoke-RestMethod -Uri "https://sonarcloud.io/api/qualitygates/project_status?projectKey=votre-projet-key" -Headers @{Authorization = "Bearer $(SonarToken)"}
Write-Host "Quality Gate Status: $($status.projectStatus.status)"
if ($status.projectStatus.status -eq "ERROR") {
Write-Host "##vso[task.logissue type=error]Le Quality Gate SonarCloud a échoué."
Write-Host "##vso[task.complete result=Failed;]"
}Instructions:
Titre: Corriger [Type de problème] dans [Composant]
Description:
- Problème détecté par SonarCloud: [Description du problème]
- Localisation: [Fichier/Méthode]
- Impact: [Sécurité/Maintenabilité/Performance]
- Effort estimé: [X] Story Points
Instructions:
Pour valider cet atelier, répondez aux questions suivantes:
À la fin de ce module, vous serez capable de :
# Étape de build
FROM node:14 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build
# Étape de production
FROM node:14-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY package*.json ./
RUN npm install --only=production
EXPOSE 3000
CMD ["node", "dist/main.js"]FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /src
COPY *.csproj ./
RUN dotnet restore
COPY . .
RUN dotnet publish -c Release -o /app/publish
FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS final
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "myapp.dll"]FROM maven:3.8-openjdk-17 AS build
WORKDIR /app
COPY pom.xml .
COPY src ./src
RUN mvn package -DskipTests
FROM openjdk:17-jdk-slim
COPY --from=build /app/target/*.jar app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]FROM node:16 AS build
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build
FROM nginx:alpine
COPY --from=build /app/build /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]# Créer un groupe de ressources
az group create --name myAKSResourceGroup --location westeurope
# Créer un cluster AKS
az aks create \
--resource-group myAKSResourceGroup \
--name myAKSCluster \
--node-count 3 \
--enable-addons monitoring \
--generate-ssh-keys
# Se connecter au cluster
az aks get-credentials --resource-group myAKSResourceGroup --name myAKSCluster@delete - ARM Template - Terraform - Bicep
kubectl : Outil CLI principal pour interagir avec Kubernetes
# Commandes essentielles
kubectl get [resource]
kubectl describe [resource] [name]
kubectl apply -f [file]
kubectl delete [resource] [name]
kubectl logs [pod]kubeadm : Outil pour créer et gérer des clusters Kubernetes
helm : Gestionnaire de paquets pour Kubernetes
# Installation d'une chart Helm
helm repo add [repo-name] [repo-url]
helm install [release-name] [chart]# Création d'un ACR
az acr create --name myACR --resource-group myRG --sku Standard
# Connexion d'AKS à ACR
az aks update --name myAKS --resource-group myRG --attach-acr myACR# azure-pipelines.yml
trigger:
- main
pool:
vmImage: 'ubuntu-latest'
variables:
imageRepository: 'myapp'
containerRegistry: 'myacr.azurecr.io'
dockerfilePath: '**/Dockerfile'
tag: '$(Build.BuildId)'
stages:
- stage: Build
jobs:
- job: BuildAndPublish
steps:
- task: Docker@2
inputs:
containerRegistry: 'ACR Connection'
repository: '$(imageRepository)'
command: 'buildAndPush'
Dockerfile: '$(dockerfilePath)'
tags: '$(tag)'# release-pipeline.yml
stages:
- stage: Deploy
jobs:
- job: DeployToAKS
steps:
- task: KubernetesManifest@0
inputs:
action: 'deploy'
kubernetesServiceConnection: 'AKS-Connection'
namespace: 'default'
manifests: '$(Pipeline.Workspace)/manifests/*.yml'
containers: '$(containerRegistry)/$(imageRepository):$(tag)'# .github/workflows/aks-deploy.yml
name: Build and Deploy to AKS
on:
push:
branches: [ main ]
jobs:
build-and-deploy:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Login to ACR
uses: azure/docker-login@v1
with:
login-server: ${{ secrets.ACR_SERVER }}
username: ${{ secrets.ACR_USERNAME }}
password: ${{ secrets.ACR_PASSWORD }}
- name: Build and Push
run: |
docker build -t ${{ secrets.ACR_SERVER }}/myapp:${{ github.sha }} .
docker push ${{ secrets.ACR_SERVER }}/myapp:${{ github.sha }}
- name: Set up Kubeconfig
uses: azure/k8s-set-context@v1
with:
kubeconfig: ${{ secrets.KUBE_CONFIG }}
- name: Deploy to AKS
uses: azure/k8s-deploy@v1
with:
manifests: |
kubernetes/deployment.yml
kubernetes/service.yml
images: |
${{ secrets.ACR_SERVER }}/myapp:${{ github.sha }}La rétroaction continue est un élément essentiel des pratiques DevOps modernes. Elle permet aux équipes de développement de comprendre l’impact réel de leurs applications, d’identifier rapidement les problèmes et d’améliorer continuellement l’expérience utilisateur. Ce module explore les différentes façons d’implémenter des mécanismes de rétroaction efficaces dans le cadre d’Azure DevOps.
À la fin de ce module, vous serez capable de :
Azure Application Insights est un service d’APM (Application Performance Management) essentiel pour suivre l’utilisation et les performances des applications.
# Installation du package NuGet pour ASP.NET Core
dotnet add package Microsoft.ApplicationInsights.AspNetCore
# Configuration dans Program.cs
builder.Services.AddApplicationInsightsTelemetry(builder.Configuration["ApplicationInsights:ConnectionString"]);Application Insights permet de créer des “entonnoirs de conversion” pour analyser comment les utilisateurs naviguent dans votre application et identifier où ils abandonnent.
// Traçage d'un événement personnalisé
telemetryClient.TrackEvent("ProductPurchased",
new Dictionary<string, string> { {"ProductId", "12345"}, {"Category", "Electronics"} },
new Dictionary<string, double> { {"Price", 99.99}, {"Quantity", 1} });Azure Monitor fournit une vue complète de l’infrastructure et des applications.
# Extraction de données de Log Analytics
let StartTime = ago(24h);
let EndTime = now();
requests
| where timestamp between (StartTime and EndTime)
| where success == false
| summarize ErrorCount = count() by bin(timestamp, 1h), operation_Name
| render timechartLes analyses de flux utilisateur permettent de visualiser comment les utilisateurs naviguent dans votre application.
// Android (Kotlin)
AppCenter.start(application, "{Your App Secret}", Analytics.class, Crashes.class);
// iOS (Swift)
AppCenter.start(withAppSecret: "{Your App Secret}", services: [Analytics.self, Crashes.self])[FunctionName("ProcessCrashReport")]
public static async Task<IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req,
ILogger log)
{
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
var crashData = JsonConvert.DeserializeObject<CrashReport>(requestBody);
// Traitement du rapport d'incident
await CreateWorkItemInDevOps(crashData);
return new OkResult();
}{
"name": "System Health Dashboard",
"widgets": [
{
"id": "markdown",
"settings": {
"content": "# Santé du système"
}
},
{
"id": "QueryResults",
"settings": {
"queryId": "12345678-1234-1234-1234-123456789012"
}
}
]
}Les workbooks permettent de créer des rapports interactifs riches qui combinent texte, métriques, journaux et paramètres.
// Suivi des performances des appels API
requests
| where timestamp > ago(24h)
| where name startswith "GET /"
| summarize AvgDuration=avg(duration), Count=count() by bin(timestamp, 1h), name
| render timechart
/docs
/architecture
architecture-overview.md
component-diagrams.md
/development
coding-standards.md
branching-strategy.md
/operations
deployment-process.md
monitoring-guide.md
/runbooks
incident-response.md
scaling-procedures.md
# Pipeline pour publier le contenu du dossier docs vers le Wiki
trigger:
branches:
include:
- main
paths:
include:
- docs/*
steps:
- task: PowerShell@2
inputs:
targetType: 'inline'
script: |
# Script pour convertir et publier vers le Wiki
$docFiles = Get-ChildItem -Path "$(System.DefaultWorkingDirectory)/docs" -Recurse -Filter "*.md"
foreach ($file in $docFiles) {
# Logique de publication
}// Calcul de la disponibilité
requests
| where timestamp > ago(30d)
| summarize RequestCount=count(), ErrorCount=countif(success == false) by bin(timestamp, 1d)
| extend Availability = 100.0 - (ErrorCount * 100.0 / RequestCount)
| render timechart
Comment définir des objectifs réalistes : - Basés sur les attentes utilisateurs - Mesurables via les SLI - Réalistes et atteignables
L’APDEX est un standard ouvert qui permet de quantifier la satisfaction utilisateur basée sur les temps de réponse.
APDEX = (Satisfying + Tolerating/2) / Total
Où : - Satisfying : Requêtes traitées en moins de T secondes - Tolerating : Requêtes traitées entre T et 4T secondes - Frustrating : Requêtes prenant plus de 4T secondes
let T = 1.5; // Seuil de satisfaction en secondes
requests
| where timestamp > ago(7d)
| extend Satisfaction = case(
duration <= T, "Satisfied",
duration <= 4*T, "Tolerating",
"Frustrated")
| summarize Count=count() by Satisfaction
| extend Total = toscalar(requests | where timestamp > ago(7d) | count())
| extend Ratio = Count * 1.0 / Total
| extend ApdexContribution = case(
Satisfaction == "Satisfied", Ratio,
Satisfaction == "Tolerating", Ratio / 2,
0)
| summarize Apdex = sum(ApdexContribution)
// Capture de feedback in-app avec contexte
public void SubmitFeedback(string comment, int rating, string userId)
{
var properties = new Dictionary<string, string>
{
{ "Comment", comment },
{ "UserId", userId },
{ "AppVersion", GetAppVersion() },
{ "DeviceInfo", GetDeviceInfo() },
{ "CurrentScreen", GetCurrentScreen() }
};
var metrics = new Dictionary<string, double>
{
{ "Rating", rating }
};
telemetryClient.TrackEvent("UserFeedback", properties, metrics);
}// Analyse de sentiment avec Text Analytics
private async Task<double> AnalyzeSentiment(string feedbackText)
{
var client = new TextAnalyticsClient(
new Uri(endpoint),
new AzureKeyCredential(apiKey));
var response = await client.AnalyzeSentimentAsync(feedbackText);
return response.Value.ConfidenceScores.Positive;
}# Activation du profiler pour un App Service
$appServiceResourceId = (Get-AzResource -ResourceGroupName "MyResourceGroup" -ResourceType "Microsoft.Web/sites" -ResourceName "MyAppService").ResourceId
Set-AzDiagnosticSetting -ResourceId $appServiceResourceId -Name "AppInsightsProfiler" -Enabled $true# Pipeline incluant l'analyse SonarQube
trigger:
- main
pool:
vmImage: 'ubuntu-latest'
steps:
- task: SonarQubePrepare@4
inputs:
SonarQube: 'SonarQube'
scannerMode: 'MSBuild'
projectKey: 'my-project'
projectName: 'My Project'
- task: DotNetCoreCLI@2
inputs:
command: 'build'
projects: '**/*.csproj'
- task: SonarQubeAnalyze@4
- task: SonarQubePublish@4
inputs:
pollingTimeoutSec: '300'# Définition d'un test de charge dans Azure Load Testing
name: LoadTest
testPlan: jmeter/test-plan.jmx
description: "API Load Test"
autoStop:
errorPercentage: 20
timeWindow: 60
engineInstances: 2# Création d'un test de disponibilité
$webTestName = "MyWebTest"
$webTestUrl = "https://myapp.azurewebsites.net"
$location = "East US"
$frequency = 300 # secondes
New-AzApplicationInsightsWebTest -Name $webTestName -ResourceGroupName "MyResourceGroup" `
-Location $location -ApplicationInsightsComponentName "MyAppInsights" `
-Kind "ping" -Frequency $frequency -Enabled $true -Url $webTestUrl# Création d'une alerte basée sur une métrique avec détection d'anomalies
$condition = New-AzMetricAlertRuleV2Criteria -MetricName "requests/failed" `
-TimeAggregation "Count" -Operator "GreaterThan" `
-Threshold 10 -MetricNamespace "Microsoft.Web/sites"
$actionGroup = Get-AzActionGroup -ResourceGroupName "MyResourceGroup" -Name "MyActionGroup"
Add-AzMetricAlertRuleV2 -Name "FailedRequestsAlert" `
-ResourceGroupName "MyResourceGroup" `
-WindowSize 00:05:00 -Frequency 00:01:00 `
-TargetResourceId "/subscriptions/{subscription-id}/resourceGroups/MyResourceGroup/providers/Microsoft.Web/sites/MyAppService" `
-Condition $condition `
-ActionGroup $actionGroup.Id `
-Severity 2 `
-Description "Alert when failed requests exceed normal pattern"# Rétrospective d'incident : [Titre de l'incident]
## Chronologie
- **[Date et heure]** : Détection de l'incident
- **[Date et heure]** : Actions entreprises
- **[Date et heure]** : Résolution
## Impact
- Durée totale : X heures
- Services affectés : [Liste]
- Utilisateurs impactés : [Estimation]
## Ce qui s'est bien passé
- [Point positif 1]
- [Point positif 2]
## Ce qui aurait pu mieux se passer
- [Point d'amélioration 1]
- [Point d'amélioration 2]
## Causes profondes
- [Cause 1]
- [Cause 2]
## Actions correctives
- [ ] [Action 1] - Responsable: [Nom] - Échéance: [Date]
- [ ] [Action 2] - Responsable: [Nom] - Échéance: [Date]
## Leçons apprises
- [Leçon 1]
- [Leçon 2]Créez une application web .NET Core et configurez Application Insights pour collecter : - Télémétrie de requêtes - Exceptions - Événements personnalisés liés aux actions utilisateur - Métriques de performance
Concevez un tableau de bord qui présente : - L’état des builds récents - Les bugs ouverts et leur gravité - Les métriques de performance des applications - L’évolution du backlog
Créez un guide de réponse aux incidents qui définit : - Les rôles et responsabilités - Les étapes de diagnostic - Les procédures d’escalade - Le template de rétrospective