Microsoft Azure - Techniques et pratiques DevOps pour l’Ingénieur

@vanessakovalsky

1 Introduction

1.1 Objectifs de la formation

1.2 Programme

  1. Démarrer un parcours de transformation DevOps
  2. Travailler avec Git pour les DevOps d’entreprise
  3. Implémenter CI avec Azure pipelines et GitHub Actions
  4. Concevoir et mettre en oeuvre une stratégie de publication
  5. Implémenter un déploiement continu sécurisé à l’aide d’Azure Pipelines
  6. Gérer l’infrastructure en tant que code à l’aide d’Azure, DSC et d’outils tiers
  7. Concevoir et mettre en oeuvre une stratégie de gestion des dépendances
  8. Créer et gérer des conteneurs à l’aide de docker et kubernetes
  9. Mettre en oeuvre la rétroaction continue
  10. Mettre en oeuvre la sécurité et valider les bases de code pour la conformité

2 Démarrer un parcours de transformation DevOps

2.1 Objectifs d’apprentissage

À la fin de ce module, vous serez capable de :

2.2 Introduction à DevOps

2.2.1 Qu’est-ce que DevOps ?

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.

2.2.2 Les principes fondamentaux de DevOps

  1. Culture de collaboration : Briser les silos entre les équipes de développement et d’opérations
  2. Automatisation : Réduire les interventions manuelles pour minimiser les erreurs et accélérer les processus
  3. Mesure continue : Collecter et analyser des métriques pour améliorer constamment les processus
  4. Partage : Faciliter la transparence et le partage des connaissances entre équipes
  5. Amélioration continue : Itérer régulièrement pour perfectionner les processus et les pratiques

2.2.3 Le cycle DevOps

Cycle DevOps

2.2.4 Avantages du DevOps

2.3 Choisir le bon projet pour démarrer avec DevOps

2.3.1 Critères de sélection

  1. Criticité modérée : Éviter de commencer par les applications les plus critiques pour l’entreprise
  2. Équipe réceptive : Choisir une équipe ouverte au changement et motivée
  3. Taille gérable : Privilégier un projet de taille moyenne (ni trop petit, ni trop complexe)
  4. Valeur métier identifiable : Sélectionner un projet dont l’amélioration sera visible pour l’entreprise
  5. Technologies adaptées : Opter pour des technologies qui se prêtent bien à l’automatisation

2.3.2 Matrice de sélection de projet

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

2.3.3 Phases d’adoption recommandées

  1. Phase pilote : Mise en place des pratiques sur un projet pilote
  2. Évaluation : Mesure des résultats et ajustements des processus
  3. Extension : Déploiement progressif à d’autres projets
  4. Standardisation : Création de modèles et de normes pour l’organisation

2.4 Décrire les structures d’équipe

2.4.1 Modèles d’équipes DevOps

  1. Équipe DevOps dédiée
  2. Modèle intégré
  3. Modèle de communauté de pratique
  4. Modèle SRE (Site Reliability Engineering)

2.4.2 Rôles clés dans une organisation DevOps

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é

2.4.3 Structure organisationnelle recommandée selon la taille

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

2.5 Migrer vers DevOps

2.5.1 Évaluation de la maturité DevOps

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

2.5.2 Étapes de transformation DevOps

  1. Préparation (0-3 mois)
  2. Fondation (3-6 mois)
  3. Adaptation (6-12 mois)
  4. Optimisation (12-24 mois)

2.5.3 Défis courants et solutions

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

2.5.4 Mesurer le succès de la transformation

Métriques techniques

Métriques métier

2.6 Introduction au contrôle de code source

2.6.1 Principes fondamentaux

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

2.6.2 Concepts clés

  1. Repository (dépôt) : Emplacement où l’historique complet du projet et ses fichiers sont stockés
  2. Commit : Instantané d’un ensemble de modifications avec un message descriptif
  3. Branch (branche) : Ligne de développement indépendante permettant le travail parallèle
  4. Merge (fusion) : Intégration des modifications d’une branche dans une autre
  5. Clone : Copie complète d’un dépôt, incluant tout l’historique
  6. Pull/Push : Actions pour synchroniser les changements entre dépôts
  7. Conflict (conflit) : Situation où des modifications incompatibles ont été apportées

2.6.3 Bonnes pratiques

2.7 Décrire les types de systèmes de contrôle de code source

2.7.1 Systèmes centralisés vs. distribués

Systèmes centralisés (CVCS)

Systèmes distribués (DVCS)

2.7.2 Comparaison des principaux systèmes

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

2.7.3 Critères de choix

  1. Taille et distribution de l’équipe : Les équipes distribuées bénéficient davantage des DVCS
  2. Nature du projet : Projets avec beaucoup de code vs. projets avec des assets binaires
  3. Compétences de l’équipe : Expérience préalable avec certains outils
  4. Besoins de branching : Stratégies de développement parallèle
  5. Intégration avec les outils existants : CI/CD, IDE, outils de revue de code

2.8 Utiliser Azure Repos et GitHub

2.8.1 Azure Repos

Présentation

Fonctionnalités clés

  1. Dépôts Git illimités : Stockage privé de code sans limitation
  2. Pull Requests : Revue de code collaborative avec discussions
  3. Branch Policies : Protection des branches importantes avec règles configurables
  4. Intégration CI/CD : Connexion native avec Azure Pipelines
  5. Recherche de code : Indexation et recherche puissante dans le code
  6. Sécurité avancée : Contrôle d’accès fin et authentification Azure AD

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-fonctionnalite

2.8.2 GitHub

Présentation

Fonctionnalités clés

  1. Social Coding : Fork, Star, Watch et contributions communautaires
  2. GitHub Actions : CI/CD intégrée avec workflows automatisés
  3. GitHub Pages : Hébergement de sites statiques directement depuis les dépôts
  4. GitHub Discussions : Forums de discussion pour les projets
  5. GitHub Copilot : Assistant de codage basé sur l’IA
  6. GitHub Advanced Security : Analyse de sécurité avancée (SAST, dépendances)

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

2.8.3 Comparaison Azure Repos vs 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)

2.8.4 Bonnes pratiques communes

  1. Stratégie de branchement

  2. Standards de qualité

  3. Automatisation

2.9 Atelier : Planification agile et gestion de portefeuille avec Azure Boards

2.9.1 Objectifs

2.9.2 Prérequis

2.9.3 Étape 1 : Configuration initiale d’Azure Boards

  1. Accéder à Azure Boards

  2. Choisir une méthodologie Agile

  3. Configurer les zones (Areas)

  4. Configurer les itérations (Sprints)

  5. Configurer les équipes

2.9.4 Étape 2 : Création de la structure de backlog

  1. Définir les Epics (grandes initiatives)

  2. Créer les Features (fonctionnalités)

  3. Définir les User Stories / PBIs

  4. Définir l’effort et la valeur métier

2.9.5 Étape 3 : Configuration du tableau Kanban

  1. Personnaliser les colonnes Kanban

  2. Configurer les couloirs (swimlanes)

  3. Tester le déplacement des cartes

2.9.6 Étape 4 : Planification de Sprint

  1. Prioriser le Backlog

  2. Planifier un Sprint

  3. Définir la capacité de l’équipe

  4. Créer des tâches détaillées

2.9.7 Étape 5 : Connexion avec le contrôle de code source

  1. Lier les éléments de travail aux branches

  2. Lier les commits aux éléments de travail

    git commit -m "Ajout du formulaire d'inscription #1234"
  3. Créer une Pull Request liée

  4. Observer le tableau des liens

2.9.8 Étape 6 : Suivi et rapports

  1. Créer des requêtes personnalisées

  2. Configurer un dashboard

  3. Analyser les métriques de cycle

  4. Créer un rapport personnalisé

3 Travailler avec Git pour les DevOps d’entreprise

3.1 Objectifs d’apprentissage

À la fin de ce module, vous serez capable de :

  1. Structurer efficacement vos dépôts Git
  2. Maîtriser les stratégies de branches et workflows Git
  3. Exploiter les demandes d’extraction dans Azure Repos
  4. Mettre en œuvre des crochets Git
  5. Planifier la promotion de la source intérieure
  6. Gérer efficacement les référentiels Git en entreprise
  7. Pratiquer le contrôle de version avec Git dans Azure Repos

3.2 Structurer son dépôt Git

3.2.1 Principes d’organisation d’un dépôt Git

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 :

3.2.2 Approche monorepo vs multirepo

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é

3.2.3 Structure de répertoires recommandée

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

3.2.4 Gestion de fichiers volumineux

Les dépôts Git ne sont pas optimisés pour les fichiers binaires volumineux. Voici comment les gérer :

  1. Git LFS (Large File Storage)

  2. 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"

3.2.5 Bonnes pratiques pour les fichiers de configuration

  1. Gestion des secrets
  2. Configurations spécifiques à l’environnement
    /config
    ├── default.json         # Configuration commune
    ├── development.json     # Spécifique au développement
    ├── staging.json         # Spécifique à la préproduction
    └── production.json      # Spécifique à la production
  3. Documentation de la structure

3.3 Gérer les branches et les workflows Git

3.3.1 Stratégies de branchement pour l’entreprise

Plusieurs stratégies de branchement existent, chacune adaptée à des contextes différents :

3.3.1.1 Git Flow

Particulièrement adapté aux projets avec des cycles de release planifiés :

main (production)
   ↑
release branches
   ↑
develop
 ↗   ↖
feature  hotfix
branches branches

3.3.1.2 Trunk-Based Development

Adapté aux équipes pratiquant l’intégration continue et le déploiement continu :

main (trunk)
 ↗   ↖
feature  hotfix
branches branches (courte durée)

3.3.1.3 GitHub Flow

Simplifié, idéal pour les déploiements continus :

main
 ↑
feature branches

3.3.2 Configuration de politiques de branches dans Azure Repos

Pour sécuriser vos branches importantes :

  1. Accéder aux politiques de branches

  2. 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é
  3. Exiger des builds réussies

  4. Définir des validateurs de checklists

  5. Limiter les types de merge

3.3.3 Commandes Git avancées pour la gestion des branches

# 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 --decorate

3.3.4 Résolution de conflits Git

  1. Prévenir les conflits

  2. 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 merge
  3. Outils de résolution de conflits

3.4 Collaborer avec des demandes d’extraction dans Azure Repos

3.4.1 Principes fondamentaux des Pull Requests

Les Pull Requests (PR) sont au cœur d’un workflow Git collaboratif, permettant de :

3.4.2 Création et gestion de Pull Requests dans Azure Repos

  1. Créer une Pull Request

  2. 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]
  3. Gestion du processus de revue

  4. Compléter une Pull Request

3.4.2.1 Configuration des politiques de Pull Request

Pour renforcer la qualité et la standardisation :

  1. Accéder aux paramètres

  2. 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é
  3. Ajouter des validations automatiques

  4. Configurer l’auto-complétion

3.4.2.2 Automatisation du processus de Pull Request

  1. Templates de Pull Request
  2. Intégration avec Azure Pipelines
  3. Notifications personnalisées
  4. Analyse de code automatisée

3.5 Explorer les crochets Git

3.5.1 Introduction aux hooks Git

Les 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.

3.5.1.1 Types de hooks Git

  1. Hooks côté client
  2. Hooks côté serveur

3.5.2 Hooks Git côté client courants

Les hooks client sont des scripts exécutables (.sh ou .bat) placés dans le dossier .git/hooks/ :

  1. 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 0
  2. prepare-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
    fi
  3. commit-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
    fi
  4. pre-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
    fi

3.5.3 Configuration des hooks Git dans un projet d’entreprise

Pour standardiser les hooks dans une équipe :

  1. 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"
        }
      }
    }
  2. Stocker les hooks dans le dépôt

    #!/bin/bash
    # install-hooks.sh
    
    cp -r hooks/* .git/hooks/
    chmod +x .git/hooks/*

3.5.4 Hooks serveur avec Azure Repos

Azure DevOps offre des fonctionnalités similaires aux hooks serveur via :

  1. Repository Policies
  2. Service Hooks
  3. Server-side validation via Azure Pipelines

3.5.5 Cas d’utilisation des hooks Git en entreprise

  1. Conformité et gouvernance
  2. Qualité du code
  3. Intégration avec les processus d’entreprise

3.6 Planifier la promotion de la source intérieure

3.6.1 Concepts de promotion de code en entreprise

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.

3.6.2 Stratégies de promotion avec Git

  1. Promotion basée sur les branches

    feature branches → develop → release → main
  2. Promotion basée sur les tags

    main (avec tags pour les versions)
  3. Promotion basée sur les commits

    main (avec sélection de commits spécifiques)

3.6.3 Configuration du workflow de promotion dans Azure DevOps

  1. Branches protégées pour chaque environnement

  2. 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.0
  3. Pipeline 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 Production

3.6.4 Gestion des versions et étiquetage

  1. Convention de versionnement sémantique

  2. 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.3
  3. Automatisation des versions avec GitVersion

    mode: ContinuousDelivery
    branches:
      main:
        tag: ''
      develop:
        tag: beta
      feature:
        tag: alpha
    steps:
    - task: GitVersion@5
      inputs:
        preferBundledVersion: false
    
    - script: |
        echo "Major: $(GitVersion.Major)"
        echo "Minor: $(GitVersion.Minor)"
        echo "Patch: $(GitVersion.Patch)"
        echo "FullSemVer: $(GitVersion.FullSemVer)"

3.6.5 Automatisation de la promotion avec Azure Pipelines

  1. 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)
  2. Approbations pour les promotions

3.7 Gérer les référentiels Git

3.7.1 Administration des dépôts Git d’entreprise

La gestion efficace des dépôts Git est essentielle pour maintenir la productivité et la sécurité des équipes.

3.7.2 Gestion des permissions Git dans Azure Repos

  1. Niveaux de permissions

  2. Configurer les groupes de sécurité

  3. Permissions critiques à surveiller

  4. Exemple de configuration sécurisée

    Main branch:
      - Contributors: Read only
      - Release Managers: Contribute
    
    Feature branches:
      - Contributors: Contribute
      - Readers: Read only

3.7.3 Optimisation des performances des dépôts Git

Les dépôts Git d’entreprise peuvent devenir volumineux. Voici comment les optimiser :

  1. 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 -d
  2. Gestion des fichiers volumineux

  3. Optimisation 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>

3.7.4 Stratégies de migration et d’archivage

  1. 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/Path
  2. Archivage de dépôts

    git bundle create repo-archive.bundle --all
  3. Scission 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>

3.7.5 Bonnes pratiques de gestion des référentiels Git en entreprise

  1. Standardisation
  2. Documentation
  3. Automatisation
  4. Audit et sécurité

3.8 Atelier : Contrôle de version avec Git dans Azure Repos

3.8.1 Objectifs pédagogiques

À la fin de cet atelier, les participants seront capables de :

3.8.2 Prérequis

3.8.3 Durée approximative

3.8.4 Partie 1 : Configuration initiale d’Azure Repos

3.8.4.1 Exercice 1.1 : Création d’un projet Azure DevOps et initialisation d’un dépôt Git

  1. Connectez-vous à votre compte Azure DevOps
  2. Créez un nouveau projet :
  3. Une fois le projet créé, naviguez vers la section Repos
  4. Notez l’URL du dépôt Git qui vient d’être créé

3.8.4.2 Exercice 1.2 : Configuration de Git en local

  1. Ouvrez un terminal ou invite de commande
  2. Configurez vos informations d’identification Git globales :
git config --global user.name "Votre Nom"
git config --global user.email "votre.email@domaine.com"
  1. (Optionnel) Configurez d’autres paramètres utiles :
git config --global core.autocrlf true  # Pour les utilisateurs Windows
git config --global init.defaultBranch main
git config --global pull.rebase false
  1. Vérifiez votre configuration :
git config --list

3.8.4.3 Exercice 1.3 : Clonage du dépôt

  1. Dans Azure DevOps, accédez à votre dépôt et cliquez sur Cloner
  2. Copiez l’URL HTTPS ou SSH (selon votre configuration)
  3. Dans votre terminal, naviguez vers le dossier où vous souhaitez cloner le dépôt :
cd ~/Documents/Projets/  # Ou tout autre chemin de votre choix
git clone <URL_copiée>
cd AZ400-Git-Workshop
  1. Vérifiez que le dépôt a été correctement cloné :
git status

3.8.5 Partie 2 : Premiers pas avec Git dans Azure Repos

3.8.5.1 Exercice 2.1 : Structure du projet et premier commit

  1. Créez la structure de base du projet :
mkdir src
mkdir docs
mkdir tests
  1. Créez un fichier README.md à la racine du projet :
echo "# Projet AZ-400 Workshop\n\nCe projet est utilisé pour l'atelier Azure DevOps - Certification AZ-400." > README.md
  1. Ajoutez et validez vos modifications :
git add .
git commit -m "Initial commit: structure de base du projet"
  1. Poussez vos modifications vers Azure Repos :
git push origin main
  1. Rafraîchissez votre navigateur pour voir les changements dans Azure Repos

3.8.5.2 Exercice 2.2 : Création de fichiers pour l’application

  1. Créez un fichier application de base dans le dossier src :
echo "console.log('Application de démonstration pour Azure DevOps');" > src/app.js
  1. Créez un fichier de documentation :
echo "# Documentation\n\nCe document contient la documentation pour l'application de démonstration." > docs/documentation.md
  1. Ajoutez et validez ces fichiers :
git add src/app.js docs/documentation.md
git commit -m "Ajout des fichiers d'application et de documentation"
git push origin main

3.8.5.3 Exercice 2.3 : Utilisation de .gitignore

  1. Créez un fichier .gitignore à la racine du projet :
echo "# Fichiers et dossiers à ignorer\nnode_modules/\n.vscode/\n*.log\n.env\ntmp/\ndist/" > .gitignore
  1. Validez le fichier .gitignore :
git add .gitignore
git commit -m "Ajout du fichier .gitignore"
git push origin main

3.8.6 Partie 3 : Travail avec les branches

3.8.6.1 Exercice 3.1 : Création d’une branche de fonctionnalité

  1. Créez une nouvelle branche pour une fonctionnalité :
git checkout -b feature/nouvelle-fonctionnalite
  1. Modifiez le fichier app.js :
echo "// 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.js
  1. Validez vos modifications sur cette branche :
git add src/app.js
git commit -m "Implémentation de la nouvelle fonctionnalité"
git push -u origin feature/nouvelle-fonctionnalite

3.8.6.2 Exercice 3.2 : Création d’une Pull Request

  1. Dans Azure DevOps, naviguez vers Repos > Pull Requests
  2. Cliquez sur Nouvelle Pull Request
  3. Configurez la Pull Request :
  4. Assignez la PR à vous-même ou à un collègue
  5. Cliquez sur Créer

3.8.6.3 Exercice 3.3 : Examen et validation d’une Pull Request

  1. Examinez les changements de code dans l’interface d’Azure DevOps
  2. Ajoutez un commentaire sur une ligne spécifique du code
  3. Approuvez la Pull Request
  4. Complétez la Pull Request avec l’option de fusion standard
  5. Vérifiez que les changements ont été fusionnés dans la branche main

3.8.6.4 Exercice 3.4 : Synchronisation du dépôt local

  1. Retournez à votre terminal
  2. Basculez sur la branche main :
git checkout main
  1. Récupérez les dernières modifications :
git pull origin main
  1. Vérifiez que votre branche locale est à jour :
git log --oneline --graph --decorate --all -n 10

3.8.7 Partie 4 : Stratégies de branche et protection du code

3.8.7.1 Exercice 4.1 : Configuration des stratégies de branche

  1. Dans Azure DevOps, naviguez vers Repos > Branches
  2. Localisez la branche main, cliquez sur les points de suspension (…) et sélectionnez Stratégies de branche
  3. Configurez les stratégies suivantes :
  4. Cliquez sur Enregistrer

3.8.7.2 Exercice 4.2 : Travailler avec une branche protégée

  1. Créez une nouvelle branche pour corriger un bogue :
git checkout -b bugfix/correction-erreur
  1. Modifiez le fichier app.js pour corriger une “erreur” :
echo "// 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.js
  1. Validez vos modifications :
git add src/app.js
git commit -m "Correction du bug dans la nouvelle fonctionnalité"
git push -u origin bugfix/correction-erreur
  1. Créez une Pull Request et observez comment les stratégies de branche sont appliquées

3.8.8 Partie 5 : Résolution de conflits

3.8.8.1 Exercice 5.1 : Création d’un conflit

  1. Créez deux branches différentes :
git checkout main
git pull
git checkout -b feature/equipe-a
  1. Modifiez le fichier README.md dans cette branche :
echo "# 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.md
  1. Validez et poussez les modifications :
git add README.md
git commit -m "Ajout de la section Équipe A dans README"
git push -u origin feature/equipe-a
  1. Créez une autre branche à partir de main :
git checkout main
git checkout -b feature/equipe-b
  1. Modifiez le même fichier README.md mais différemment :
echo "# 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.md
  1. Validez et poussez les modifications :
git add README.md
git commit -m "Ajout de la section Fonctionnalités dans README"
git push -u origin feature/equipe-b

3.8.8.2 Exercice 5.2 : Fusion et résolution de conflits

  1. Fusionnez la branche feature/equipe-a dans main via une PR dans Azure DevOps

  2. Essayez de fusionner feature/equipe-b dans main et observez le conflit

  3. Pour résoudre le conflit localement :

git checkout main
git pull
git checkout feature/equipe-b
git merge main
  1. Résolvez le conflit en modifiant le fichier README.md :
# 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.
  1. Marquez le conflit comme résolu et terminez la fusion :
git add README.md
git commit -m "Résolution du conflit entre les équipes A et B"
git push origin feature/equipe-b
  1. Créez une nouvelle PR pour fusionner feature/equipe-b dans main

3.8.9 Partie 6 : Intégration avec les workflows CI/CD

3.8.9.1 Exercice 6.1 : Configuration d’un déclencheur de build sur les commits

  1. Dans Azure DevOps, naviguez vers Pipelines
  2. Créez un nouveau pipeline :
  3. Modifiez le pipeline YAML pour inclure un déclencheur sur le dépôt Git :
trigger:
- main
- feature/*

pool:
  vmImage: 'ubuntu-latest'

steps:
- script: echo "Exécution du build suite à un commit Git"
  displayName: 'Run build script'
  1. Enregistrez et exécutez le pipeline

3.8.9.2 Exercice 6.2 : Tests des déclencheurs CI/CD

  1. Créez une nouvelle branche de fonctionnalité :
git checkout main
git pull
git checkout -b feature/integration-ci-cd
  1. Ajoutez un fichier de test simple :
mkdir -p tests/unit
echo "console.log('Test unitaire factice');\nconsole.log('Tous les tests ont réussi!');" > tests/unit/test.js
  1. Validez et poussez les modifications :
git add tests/unit/test.js
git commit -m "Ajout de tests unitaires factices"
git push -u origin feature/integration-ci-cd
  1. Observez le déclenchement automatique du pipeline CI dans Azure DevOps

3.8.10 Partie 7 : Techniques Git avancées dans Azure Repos

3.8.10.1 Exercice 7.1 : Utilisation des tags Git

  1. Créez un tag pour marquer une version de votre code :
git checkout main
git pull
git tag -a v1.0.0 -m "Version 1.0.0 - Premier livrable"
git push origin v1.0.0
  1. Vérifiez dans Azure Repos que le tag est visible

3.8.10.2 Exercice 7.2 : Utilisation de git rebase

  1. Créez une branche pour expérimenter le rebase :
git checkout -b feature/rebase-demo
  1. Effectuez quelques modifications et commits :
echo "// 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"
  1. Pendant ce temps, simulez des modifications sur main :
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 main
  1. Rebasez votre branche de fonctionnalité sur main :
git checkout feature/rebase-demo
git rebase main
  1. Poussez les modifications (forcée car rebase) :
git push --force-with-lease origin feature/rebase-demo

3.8.10.3 Exercice 7.3 : Utilisation de git cherry-pick

  1. Créez une nouvelle branche pour un hotfix :
git checkout main
git checkout -b hotfix/urgent-fix
  1. Effectuez une correction :
echo "// 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"
  1. Prenez note de l’identifiant du commit (hash)
  2. Appliquez ce commit spécifique sur main :
git checkout main
git cherry-pick <hash_du_commit>
git push origin main

3.8.11 Partie 8 : Audit et historique dans Azure Repos

3.8.11.1 Exercice 8.1 : Explorer l’historique des commits

  1. Dans Azure DevOps, naviguez vers Repos > Commits
  2. Explorez l’historique des commits pour le projet
  3. Utilisez les filtres pour rechercher des commits spécifiques
  4. Examinez les différences introduites par chaque commit

3.8.11.2 Exercice 8.2 : Utilisation des outils de blame

  1. Dans Azure DevOps, naviguez vers Repos > Files
  2. Ouvrez un fichier de votre choix (par exemple, README.md)
  3. Cliquez sur Blame dans le menu supérieur
  4. Observez qui a modifié quelles lignes et quand

3.8.11.3 Exercice 8.3 : Récupération d’anciennes versions

  1. Dans votre terminal, affichez l’historique complet :
git log --pretty=format:"%h %ad | %s%d [%an]" --graph --date=short
  1. Identifiez un commit ancien et récupérez temporairement son contenu :
git checkout <hash_du_commit> -- README.md
  1. Examinez les différences :
git diff --staged README.md
  1. Validez ou annulez ces modifications selon votre choix

3.9 Ressources supplémentaires

4 Implémenter CI avec Azure pipelines et GitHub Actions

4.1 Objectifs d’apprentissage

4.2 Explorer Azure Pipelines

4.2.1 Qu’est-ce qu’Azure Pipelines ?

Azure 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.

4.2.2 Avantages d’Azure Pipelines

4.2.3 Types de fichiers de définition

4.2.3.1 YAML Pipelines

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

4.2.4 Structure d’un pipeline YAML

4.3 Gérer les agents et les pools Azure Pipeline

4.3.1 Types d’agents

  1. Agents hébergés par Microsoft
  2. Agents auto-hébergés

4.3.2 Pools d’agents

Un pool d’agents est une collection d’agents disponibles pour exécuter des jobs.

4.3.3 Configuration d’un agent auto-hébergé

  1. Créer un pool d’agents dans Azure DevOps
  2. Télécharger l’agent pour votre OS
  3. Configurer et enregistrer l’agent avec votre organisation
  4. Installer comme service (Windows) ou démon (Linux/macOS)
# Exemple d'installation sur Linux
./config.sh --url https://dev.azure.com/monorganisation --auth pat --token monPAT --pool MonPool
./svc.sh install
./svc.sh start

4.3.4 Capacités des agents

pool:
  name: MonPool
  demands:
    - docker
    - npm

4.4 Décrire les pipelines et la simultanéité

4.4.1 Concepts de simultanéité

4.4.2 Limites de simultanéité

4.4.3 Configuration de l’exécution parallèle

# 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

4.4.4 Stratégies de dépendance

# 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...

4.4.5 Contrôle de la concurrence

# Limitation des exécutions parallèles
pool:
  vmImage: 'ubuntu-latest'
  
jobs:
- job: LimitedJob
  strategy:
    maxParallel: 2  # Limite à 2 exécutions en parallèle

4.5 Explorer l’intégration continue

4.5.1 Définition de l’intégration continue (CI)

L’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.

4.5.2 Avantages de CI

4.5.3 Composants d’un processus CI efficace

  1. Contrôle de source
  2. Build automatisé
  3. Tests automatisés
  4. Artefacts

4.5.4 Configuration CI dans Azure Pipelines

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'

4.6 Mettre en œuvre une stratégie de pipeline

4.6.1 Stratégies de branchement

  1. GitFlow
  2. Trunk-Based Development
  3. GitHub Flow

4.6.2 Qualité de code

4.6.3 Stratégies de test

  1. Pyramide de tests
  2. Tests de non-régression
  3. Tests de performance

4.6.4 Gestion des environnements

4.6.5 Exemple de stratégie multi-environnement

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 Test

4.7 Intégration avec Azure Pipelines

4.7.1 Services Azure intégrables

  1. Azure App Service
  2. Azure Functions
  3. Azure Kubernetes Service (AKS)
  4. Azure SQL Database

4.7.2 Intégration avec des outils tiers

  1. SonarQube/SonarCloud
  2. JFrog Artifactory
  3. Selenium
  4. Docker/Container Registry

4.7.3 Service Connections

Les 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'

4.7.4 Variables et secrets

  1. Variables de pipeline
  2. Variables d’environnement
  3. Azure Key Vault
# 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'

4.8 Introduction aux actions GitHub

4.8.1 Qu’est-ce que GitHub Actions ?

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.

4.8.2 Composants principaux

  1. Workflows
  2. Events
  3. Jobs
  4. Steps
  5. Actions

4.8.3 Structure d’un workflow GitHub Actions

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-build

4.8.4 Types de runners GitHub Actions

  1. Runners hébergés par GitHub
  2. Runners auto-hébergés

4.8.5 Sécurité dans GitHub Actions

4.9 Apprendre l’intégration continue avec GitHub Actions

4.9.1 Configuration de CI basique

name: 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 test

4.9.2 Matrices de builds

name: 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 test

4.9.3 Caching de dépendances

name: 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 test

4.9.4 Publication d’artefacts

name: 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/

4.9.5 Déploiement continu (CD)

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'

4.10 Atelier 1 : Configuration des pools d’agents et compréhension des styles de pipelines

4.10.1 Durée estimée : 90 minutes

4.10.2 Objectifs d’apprentissage

4.10.3 Prérequis

4.10.4 Étapes détaillées

4.10.4.1 Partie 1 : Création d’un pool d’agents auto-hébergé

  1. Connexion à Azure DevOps
  2. Création du pool d’agents
  3. Préparation de la machine pour l’agent

4.10.4.2 Partie 2 : Installation et configuration de l’agent

  1. Téléchargement de l’agent
  2. Installation de l’agent (Windows)
  3. Installation de l’agent (Linux)
  4. Vérification de l’installation

4.10.4.3 Partie 3 : Configuration des capacités d’agent

  1. Ajout de capacités à l’agent
  2. Examinez les capacités détectées automatiquement

4.10.4.4 Partie 4 : Création d’un pipeline YAML

  1. Création d’un dépôt de code simple
  2. Création du pipeline YAML

4.10.4.5 Partie 5 : Création d’un pipeline Classic

  1. Création du pipeline Classic

4.10.4.6 Partie 6 : Comparaison et analyse

  1. Comparaison des approches
  2. Analyse des scénarios d’utilisation

4.10.5 Livrables

4.10.6 Ressources supplémentaires

4.11 Atelier 2 : Activation de l’intégration continue avec Azure Pipelines

4.11.1 Durée estimée : 120 minutes

4.11.2 Objectifs d’apprentissage

4.11.3 Prérequis

4.11.4 Étapes détaillées

4.11.4.1 Partie 1 : Préparation du projet

  1. Création du dépôt

  2. Création d’une application web simple

  3. Configuration des tests

  4. Commit et push du code

    git add .
    git commit -m "Initial commit with web application and tests"
    git push

4.11.4.2 Partie 2 : Configuration du pipeline CI

  1. Création du pipeline YAML

  2. Configuration du pipeline pour .NET Core

  3. Configuration du pipeline pour Node.js

  4. Sauvegarde et exécution du pipeline

4.11.4.3 Partie 3 : Test et amélioration des déclencheurs

  1. Ajout de déclencheurs pour Pull Requests

  2. Test des déclencheurs

4.11.4.4 Partie 4 : Configuration de la couverture de code et des badges

  1. Amélioration de la couverture de code

  2. Ajout d’un badge de build au README

  3. Configuration des politiques de branche

4.11.5 Livrables

4.11.6 Ressources supplémentaires

4.12 Atelier 3 : Intégration du contrôle de source externe avec Azure Pipelines

4.12.1 Durée estimée : 120 minutes

4.12.2 Objectifs d’apprentissage

4.12.3 Prérequis

4.12.4 Étapes détaillées

4.12.4.1 Partie 1 : Préparation du dépôt GitHub

  1. Création d’un dépôt GitHub

  2. Ajout d’une application simple

  3. Commit et push du code initial

    git add .
    git commit -m "Initial commit with Express app"
    git push

4.12.4.2 Partie 2 : Configuration de la connexion Azure DevOps à GitHub

  1. Création d’une connexion de service GitHub
  2. Vérification des autorisations

4.12.4.3 Partie 3 : Configuration du pipeline Azure pour le dépôt GitHub

  1. Création du pipeline dans Azure DevOps
  2. Configuration du fichier YAML

4.12.4.4 Partie 4 : Configuration des variables et secrets

  1. Création de variables de pipeline
  2. Configuration d’Azure Key Vault pour les secrets
  3. Création d’une connexion de service à Azure
  4. Mise à jour du pipeline pour utiliser Key Vault
  5. Test du pipeline avec variables et secrets

4.12.4.5 Partie 5 : Configuration des webhooks et déclencheurs

  1. Inspection des webhooks GitHub
  2. Test des déclencheurs par push
  3. Configuration des pull requests

4.12.4.6 Partie 6 : Publication d’artefacts et status checks (suite)

  1. Test complet d’intégration

4.12.4.7 Partie 7 : Personnalisation et optimisation

  1. Ajout d’un badge de statut dans le README

  2. Configuration du cache pour les dépendances

4.12.5 Livrables

4.12.6 Ressources supplémentaires

4.13 Atelier 4 : Mise en œuvre des actions GitHub pour CI/CD

4.13.1 Durée estimée : 120 minutes

4.13.2 Objectifs d’apprentissage

4.13.3 Prérequis

4.13.4 Étapes détaillées

4.13.4.1 Partie 1 : Préparation du dépôt GitHub

  1. Création du dépôt GitHub

  2. Clonage du dépôt et création d’une application web simple

     "scripts": {
       "start": "node app.js",
       "test": "jest",
       "test:coverage": "jest --coverage"
     }
  1. Commit et push du code initial

    git add .
    git commit -m "Initial commit with Express app and tests"
    git push

4.13.4.2 Partie 2 : Configuration d’un workflow GitHub Actions basique

  1. Création du répertoire de workflows
  2. Création d’un workflow CI basique
  3. Commit et push du workflow
   git add .github/workflows/ci.yml
   git commit -m "Add basic GitHub Actions workflow"
   git push
  1. Vérification de l’exécution du workflow

4.13.4.3 Partie 3 : Configuration d’une matrice de tests

  1. Mise à jour du workflow pour utiliser une matrice
  2. Commit et push des modifications
   git add .github/workflows/ci.yml
   git commit -m "Add test matrix across multiple Node.js versions and OSes"
   git push
  1. Vérification de l’exécution de la matrice

4.13.4.4 Partie 4 : Configuration du cache et optimisation

  1. Amélioration du cache pour les dépendances
  2. Ajout d’étapes de publication d’artefacts
  3. Ajout d’un job de build séparé
  4. Commit et push des modifications
    git add .github/workflows/ci.yml
    git commit -m "Optimize workflow with caching and separate build job"
    git push

4.13.4.5 Partie 5 : Configuration des secrets et déploiement conditionnel

  1. Ajout de secrets GitHub
  2. Ajout d’un job de déploiement
  3. Création d’un environnement GitHub
  4. Commit et push du workflow complet
    git add .github/workflows/ci.yml
    git commit -m "Add deployment job with environment protection"
    git push

4.13.4.6 Partie 6 : Test du processus CI/CD complet

  1. Test du processus par une Pull Request
      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');
      });
  1. Test du déploiement conditionnel
  2. Ajout d’un badge de statut au README
      # GitHub Actions Workshop
      
      ![CI/CD](https://github.com/votre-compte/github-actions-workshop/actions/workflows/ci.yml/badge.svg)
      
      This repository demonstrates a complete CI/CD pipeline using GitHub Actions.

4.13.5 Livrables

4.13.6 Ressources supplémentaires

4.14 Atelier : Déploiement de conteneurs Docker vers Azure App Service

4.14.1 Objectifs pédagogiques

À la fin de cet atelier, les participants seront capables de :

4.14.2 Prérequis

4.14.3 Durée estimée

3 heures

4.14.4 Introduction

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.

4.14.5 Architecture de la solution

Architecture de la solution

4.14.6 Partie 1 : Préparation de l’environnement

4.14.6.1 1.1 Configuration de l’application Docker

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

4.14.6.2 Contenu du fichier 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}`);
});

4.14.6.3 Contenu du fichier Dockerfile :

FROM node:14-alpine

WORKDIR /app

COPY package*.json ./
RUN npm install

COPY . .

EXPOSE 3000

CMD ["node", "server.js"]

4.14.6.4 Contenu du fichier 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"
  }
}

4.14.7 1.2 Créer un registry de conteneurs dans Azure

  1. Ouvrez le terminal et connectez-vous à Azure CLI :

    az login
  2. Créez un groupe de ressources :

    az group create --name rg-docker-webapp --location westeurope
  3. Créez un Azure Container Registry (ACR) :

    az acr create --resource-group rg-docker-webapp --name <votre-nom-acr-unique> --sku Basic --admin-enabled true
  4. Récupérez les informations d’identification de l’ACR :

    az acr credential show --name <votre-nom-acr-unique>

4.14.8 Partie 2 : Configuration d’Azure App Service

4.14.8.1 2.1 Créer un plan App Service

az appservice plan create --name asp-docker-webapp --resource-group rg-docker-webapp --sku B1 --is-linux

4.14.8.2 2.2 Créer une Web App pour conteneurs

az webapp create --resource-group rg-docker-webapp --plan asp-docker-webapp --name <votre-nom-webapp-unique> --deployment-container-image-name nginx:latest

4.14.9 Partie 3 : Configuration du pipeline CI/CD avec Azure DevOps

4.14.9.1 3.1 Créer un projet Azure DevOps

  1. Connectez-vous à votre compte Azure DevOps
  2. Créez un nouveau projet nommé “DockerWebAppDemo”
  3. Importez votre code source depuis GitHub ou initialisez un nouveau dépôt

4.14.9.2 3.2 Configurer les variables et les secrets

  1. Dans Azure DevOps, accédez à Pipelines > Library > Variable groups
  2. Créez un groupe de variables “docker-webapp-variables” avec :
  3. Ajoutez les secrets suivants :

4.14.9.3 3.3 Créer le fichier de pipeline Azure DevOps

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)'

4.14.9.4 3.4 Configurer les connexions de service

  1. Dans Azure DevOps, accédez à Project Settings > Service connections
  2. Créez une connexion nommée “azure-connection” vers votre abonnement Azure
  3. Créez une connexion nommée “docker-registry-connection” vers votre Azure Container Registry

4.14.10 Partie 4 : Configuration avec GitHub Actions (alternative)

4.14.10.1 4.1 Créer les secrets GitHub

Ajoutez les secrets suivants à votre repository GitHub :

4.14.10.2 4.2 Créer le workflow GitHub Actions

Cré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 }}

4.14.11 Partie 5 : Tester le déploiement

4.14.11.1 5.1 Déclencher le pipeline

  1. Validez et poussez vos modifications vers le dépôt
  2. Observez l’exécution du pipeline dans Azure DevOps ou GitHub Actions
  3. Vérifiez les logs de déploiement

4.14.11.2 5.2 Vérifier l’application

  1. Accédez à votre application : https://<votre-nom-webapp-unique>.azurewebsites.net
  2. Testez l’endpoint API : https://<votre-nom-webapp-unique>.azurewebsites.net/api/info

4.14.12 Partie 6 : Bonnes pratiques et optimisations

4.14.12.1 6.1 Configuration des slots de déploiement

# Créer un slot de staging
az webapp deployment slot create --name <votre-nom-webapp-unique> --resource-group rg-docker-webapp --slot staging

Modifiez 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: true

4.14.12.2 6.2 Configuration du monitoring

  1. Activez Application Insights pour votre App Service
  2. Configurez des alertes pour les métriques importantes (temps de réponse, erreurs HTTP)

4.14.12.3 6.3 Optimisation des images Docker

  1. Utilisez des images de base légères (alpine)
  2. Implémentez le multi-stage building
  3. Minimisez le nombre de couches

Exemple 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"]

4.14.13 Exercices pratiques pour aller plus loin

  1. Modifiez l’application pour inclure une nouvelle fonctionnalité et observez le déploiement automatique
  2. Configurez des variables d’environnement spécifiques pour chaque environnement (dev, staging, prod)
  3. Implémentez un test de disponibilité post-déploiement dans le pipeline

4.14.14 Ressources complémentaires

5 Concevoir et mettre en oeuvre une stratégie de publication

5.1 Objectifs d’apprentissage

À la fin de ce module, vous serez capable de :

5.2 Introduction à la livraison continue

5.2.1 Qu’est-ce que la livraison continue ?

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.

Schéma du pipeline CI/CD

5.2.2 Différence entre déploiement continu et livraison continue

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

5.2.3 Avantages de la livraison continue

5.3 Explorer les recommandations de stratégie de publication

5.3.1 Éléments clés d’une stratégie de publication

Une stratégie de publication efficace doit prendre en compte :

  1. La cadence de livraison : Quelle fréquence (quotidienne, hebdomadaire, mensuelle) ?
  2. Le type d’application : Application web, mobile, microservices, monolithique
  3. Les attentes des utilisateurs : Tolérance aux changements et aux interruptions
  4. Les contraintes réglementaires : Certains secteurs ont des exigences strictes
  5. Les ressources disponibles : Équipes, compétences, infrastructures

5.3.2 Meilleures pratiques

5.3.3 Exemple de stratégie de publication pour une application web

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]

5.4 Créer un pipeline de publication de haute qualité

Un pipeline de publication de haute qualité doit inclure plusieurs étapes et garanties :

5.4.1 Composants essentiels

5.4.2 Exemple de définition de pipeline Azure DevOps (YAML)

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'

5.4.3 Qualité et observabilité

Pour garantir un pipeline de haute qualité, il faut mettre en place :

5.5 Introduction aux modèles de déploiement

Il existe plusieurs stratégies pour déployer des applications en production tout en minimisant les risques :

5.5.1 Types de modèles de déploiement

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

5.5.2 Visualisation du déploiement Blue-Green

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]

5.6 5. Implémenter un déploiement bleu-vert et basculer les fonctionnalités

5.6.1 Principe du déploiement bleu-vert

Le déploiement bleu-vert utilise deux environnements identiques :

Le processus se déroule comme suit :

  1. La nouvelle version est déployée sur l’environnement inactif (vert)
  2. Des tests sont effectués sur cet environnement
  3. Le trafic est basculé de l’environnement bleu vers l’environnement vert
  4. L’ancien environnement (bleu) est conservé pour un rollback rapide si nécessaire

5.6.2 Mise en œuvre avec Azure App Service

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 production

5.6.3 Feature Flags (basculer les fonctionnalités)

Les Feature Flags permettent d’activer ou désactiver des fonctionnalités sans redéploiement :

  1. Implémentation dans le code :
if (featureManager.IsEnabled("nouvelle-fonctionnalite"))
{
    // Code de la nouvelle fonctionnalité
}
else
{
    // Ancien comportement
}
  1. Configuration avec Azure App Configuration :
// 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é
        }
    }
}

5.7 6. Mettre en œuvre des versions canari et un lancement sombre

5.7.1 Déploiement Canari

Le déploiement canari consiste à exposer progressivement une nouvelle version à un sous-ensemble d’utilisateurs avant un déploiement complet.

5.7.1.1 Étapes d’implémentation :

  1. Déployer la nouvelle version dans un environnement isolé
  2. Rediriger un petit pourcentage du trafic (ex: 5%) vers cette nouvelle version
  3. Surveiller attentivement les métriques et les erreurs
  4. Si tout va bien, augmenter progressivement le pourcentage de trafic
  5. En cas de problème, revenir immédiatement à l’ancienne version

5.7.1.2 Exemple avec Azure Traffic Manager :

# 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 5

5.7.2 Lancement sombre (Dark Launch)

Le lancement sombre consiste à déployer du code en production mais à le masquer des utilisateurs, permettant ainsi de tester son comportement en conditions réelles.

5.7.2.1 Techniques de mise en œuvre :

  1. Duplication des requêtes : Les requêtes réelles sont dupliquées vers le nouveau code sans que les utilisateurs voient les résultats
  2. Shadow testing : Le nouveau code s’exécute en parallèle mais ses résultats sont ignorés
  3. Feature flags désactivés : Le code est déployé mais désactivé via des flags

5.7.2.2 Exemple de code pour la duplication des requêtes :

// 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;
        }
    }
}

5.8 7. Mettre en œuvre des tests A-B et un déploiement progressif de l’exposition

5.8.1 Tests A/B

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.

5.8.1.1 Principes clés :

5.8.1.2 Mise en œuvre avec Azure App Configuration et Application Insights :

// 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();
    }
}

5.8.2 Déploiement progressif de l’exposition

Le déploiement progressif consiste à augmenter graduellement l’exposition des utilisateurs à une nouvelle version.

5.8.2.1 Étapes d’implémentation :

  1. Déployer la nouvelle version en parallèle de l’ancienne
  2. Commencer avec un faible pourcentage d’utilisateurs (1-5%)
  3. Surveiller les métriques clés (erreurs, performance, satisfaction)
  4. Augmenter progressivement le pourcentage (10%, 25%, 50%, 100%)
  5. À chaque étape, valider que les métriques restent dans les seuils acceptables

5.8.2.2 Exemple de configuration avec Azure Front Door :

{
  "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"
      }
    }
  ]
}

5.9 Ateliers

5.9.1 Atelier 1 : Contrôler les déploiements en utilisant les Release Gates

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 :

  1. Configuration des métriques de surveillance :

  2. 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é
  3. Test du pipeline :

  4. Analyse et ajustement :

5.9.2 Atelier 2 : Créer un tableau de bord des versions

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 :

  1. Analyse des besoins :

  2. 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 performances
  3. Personnalisation avancée :

  4. Partage et itération :

5.10 9. Ressources supplémentaires

5.10.1 Documentation officielle

5.10.2 Livres recommandés

5.10.3 Exercices pratiques

5.11 10. Quiz de révision

  1. Quelle est la principale différence entre la livraison continue et le déploiement continu ?

  2. Dans un déploiement bleu-vert, que représentent les environnements “bleu” et “vert” ?

  3. Pourquoi utiliserait-on des feature flags (ou feature toggles) ?

  4. Quelle est la caractéristique principale d’un déploiement canari ?

  5. Qu’est-ce qu’un “Release Gate” dans Azure DevOps ?

Réponses : 1-b, 2-b, 3-b, 4-b, 5-b

6 Implémenter un déploiement continu sécurisé à l’aide d’Azure Pipelines

6.1 Objectifs d’apprentissage

À la fin de ce module, vous serez capable de :

6.2 Créer un pipeline de versions

6.2.1 Introduction

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.

6.2.2 Concepts clés

6.2.2.1 Qu’est-ce qu’un pipeline de versions ?

Un pipeline de versions définit le processus de déploiement automatisé pour une application. Il spécifie :

Structure d’un pipeline de versions

6.2.2.2 Différence entre pipeline de build et pipeline de versions

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

6.2.3 Création d’un pipeline de versions pas à pas

6.2.3.1 Étape 1 : Accéder à Azure DevOps et créer un nouveau pipeline de versions

  1. Connectez-vous à votre organisation Azure DevOps
  2. Naviguez vers votre projet
  3. Sélectionnez Pipelines > Releases
  4. Cliquez sur New pipeline
Création d’un nouveau pipeline

6.2.3.2 Étape 2 : Sélectionner un modèle

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.

6.2.3.3 Étape 3 : Ajouter des artefacts

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 :

  1. Cliquez sur + Add dans la section Artifacts
  2. Sélectionnez la source (Build, GitHub, Azure Repository, etc.)
  3. Configurez les paramètres spécifiques à la source
# Exemple de définition d'artefact dans un YAML pipeline
resources:
  pipelines:
  - pipeline: myAppBuild
    source: 'Build Application'
    trigger: true  # Active le déclenchement automatique

6.2.3.4 Étape 4 : Définir les étapes de déploiement

Pour chaque environnement (Dev, Test, Prod), vous devez définir les tâches à exécuter :

  1. Sélectionnez votre environnement (ou créez-en un nouveau)
  2. Ajoutez des tâches en cliquant sur le signe +
  3. Configurez chaque tâche selon vos besoins de déploiement

Les tâches courantes incluent :

6.2.3.5 Étape 5 : Configurer les déclencheurs et les conditions de déploiement

Vous pouvez définir quand et comment votre pipeline de versions s’exécute :

6.2.4 Bonnes pratiques

  1. Versionnez vos déploiements - Utilisez des numéros de version cohérents
  2. Implémentez des approbations - En particulier pour les environnements de production
  3. Utilisez des variables - Pour rendre vos pipelines réutilisables
  4. Documentez - Ajoutez des descriptions à vos pipelines et étapes
  5. Testez vos pipelines - Validez-les dans des environnements de test avant la production

6.3 Configurer et provisionner des environnements

6.3.1 Introduction

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.

6.3.2 Concepts clés des environnements

6.3.2.1 Définition d’un environnement dans Azure DevOps

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 :

Structure d’un environnement Azure DevOps

6.3.2.2 Types de ressources dans les environnements

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

6.3.3 Configuration des environnements

6.3.3.1 Création d’un environnement

Pour créer un environnement dans Azure DevOps :

  1. Accédez à Pipelines > Environnements
  2. Cliquez sur Créer un environnement
  3. Donnez un nom à votre environnement (par exemple, Development, Testing, Production)
  4. Choisissez un type de ressource à ajouter (facultatif)
  5. Configurez les détails spécifiques à la ressource

6.3.3.2 Configuration des autorisations et de la sécurité

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

Configuration des approbations

6.3.3.3 Définition des variables d’environnement

Les variables d’environnement permettent de stocker des configurations spécifiques à l’environnement :

  1. Accédez à votre pipeline
  2. Allez dans Variables ou Variables de bibliothèque
  3. Créez des variables avec différentes valeurs pour chaque 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 variables

6.3.4 Provisionnement d’environnements

Le provisionnement des environnements devrait idéalement utiliser l’Infrastructure as Code pour assurer :

6.3.4.1 Azure Resource Manager (ARM)

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')))]"
      }
    }
  ]
}

6.3.4.2 Terraform pour Azure

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
}

6.3.4.3 Provisionnement dans le pipeline

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'

6.3.5 Environnements virtuels et conteneurisés

6.3.5.1 Azure Kubernetes Service (AKS)

Pour les applications conteneurisées, AKS offre :

Configuration d’un environnement AKS dans Azure DevOps :

  1. Créez un environnement
  2. Ajoutez une ressource Kubernetes
  3. Connectez-vous à votre cluster AKS
  4. Créez un espace de noms pour l’environnement

6.3.5.2 Machines virtuelles

Pour les applications traditionnelles, les VMs peuvent être utilisées comme cibles de déploiement :

  1. Créez un environnement
  2. Ajoutez des ressources de VM
  3. Installez l’agent de déploiement sur les VMs

6.3.6 Bonnes pratiques

  1. Parité environnementale - Assurez-vous que tous les environnements sont aussi similaires que possible
  2. Automatisation complète - Tout doit être automatisé, pas de configuration manuelle
  3. Séparation des préoccupations - Séparez le provisionnement de l’infrastructure du déploiement d’applications
  4. Idempotence - Les scripts de provisionnement doivent pouvoir être exécutés plusieurs fois sans effets secondaires
  5. Versionning - Versionnez votre code d’infrastructure comme votre code d’application )

6.4 Gérer et modulariser les tâches et les modèles

6.4.1 Introduction

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.

6.4.2 Les tâches dans Azure DevOps

6.4.2.1 Types de tâches

Azure DevOps propose plusieurs types de tâches pour les pipelines :

  1. Tâches intégrées - Fournies par Microsoft (plus de 200 tâches)
  2. Tâches de la marketplace - Créées par la communauté ou des tiers
  3. Tâches personnalisées - Développées spécifiquement pour votre organisation
Types de tâches dans Azure DevOps

6.4.2.2 Anatomie d’une tâche

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"
    }
  }
}

6.4.3 Création de tâches personnalisées

6.4.3.1 Pourquoi créer des tâches personnalisées ?

Les tâches personnalisées sont utiles lorsque :

6.4.3.2 Processus de création d’une tâche personnalisée

  1. Préparer l’environnement de développement

  2. Créer la structure du projet

    my-custom-task/
    ├── task.json
    ├── icon.png
    ├── package.json
    └── index.js ou script.ps1
  3. Développer la logique de la tâche

  4. Tester la tâche localement

  5. Publier la tâche

    tfx build tasks upload --task-path ./my-custom-task

6.4.3.3 Exemple de tâche personnalisée (PowerShell)

[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
}

6.4.4 Modèles de pipelines

6.4.4.1 Types de modèles

Azure DevOps propose plusieurs types de modèles :

  1. Modèles de tâches - Réutilisation d’un groupe de tâches
  2. Modèles de jobs - Réutilisation d’un job entier
  3. Modèles de stages - Réutilisation d’un stage complet
  4. Modèles de variables - Définition de variables réutilisables
  5. Modèles de pipelines complets - Réutilisation d’un pipeline entier
Hiérarchie des modèles

6.4.4.2 Structure d’un modèle de tâches

# 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 }}'

6.4.4.3 Utilisation d’un modèle dans un pipeline

# 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'

6.4.4.4 Modèles de jobs

# 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'

6.4.4.5 Modèles de stages

# 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'

6.4.5 Modèles conditionnels et avancés

6.4.5.1 Conditions dans les modèles

# 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'

6.4.5.2 Boucles dans les modèles

# 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'

6.4.6 Bibliothèques de tâches et modèles

6.4.6.1 Organisation des modèles

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

6.4.6.2 Partage entre équipes et projets

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'

6.4.7 Bonnes pratiques

  1. Paramétrer correctement - Rendez vos modèles flexibles avec des paramètres bien définis
  2. Documentation - Documentez les paramètres et l’utilisation attendue
  3. Versionnement - Versionnez vos modèles pour éviter les ruptures
  4. Tests - Testez vos modèles avant de les partager
  5. Simplicité - Gardez les modèles simples et concentrés sur une seule responsabilité
  6. DRY (Don’t Repeat Yourself) - Éliminez les duplications dans vos pipelines

6.5 Automatiser l’inspection de la santé

6.5.1 Introduction

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.

6.5.2 Concepts clés de l’inspection de la santé

6.5.2.1 Qu’est-ce que l’inspection de la santé ?

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 :

Composants de l’inspection de santé

6.5.2.2 Pourquoi automatiser l’inspection de la santé ?

L’automatisation de l’inspection de la santé offre plusieurs avantages :

6.5.3 Points de contrôle d’inspection de la santé

6.5.3.1 Points de contrôle dans le cycle de vie DevOps

L’inspection de la santé peut être intégrée à différentes étapes du cycle de vie DevOps :

  1. Pré-déploiement - Vérifications avant de déployer l’application
  2. Post-déploiement - Vérifications juste après le déploiement
  3. En continu - Surveillance continue après le déploiement
Points de contrôle d’inspection

6.5.3.2 Types de vérifications

6.5.3.2.1 Vérifications de base
6.5.3.2.2 Vérifications avancées

6.5.4 Outils d’inspection de la santé dans Azure

6.5.4.1 Azure Monitor

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'

6.5.4.2 Application Insights

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"

6.5.4.3 Azure Policy

Azure Policy aide à appliquer des normes organisationnelles et à évaluer la conformité à l’échelle.

Utilisations pour l’inspection de la santé :

6.5.4.4 Sondes de préparation et de disponibilité

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: 5

6.5.5 Implémentation d’endpoints de santé dans les applications

6.5.5.1 Conception d’API de santé

Une bonne API de santé devrait :

6.5.5.2 Exemple d’API de santé ASP.NET Core

// 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";
    });
}

6.5.5.3 Exemple d’API de santé en Java Spring Boot

// 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);
    }
}

6.5.6 Intégration dans les pipelines Azure DevOps

6.5.6.1 Portes de qualité (Gates)

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é :

  1. Accédez à votre environnement
  2. Sélectionnez Approbations et contrôles
  3. Choisissez Portes
  4. Ajoutez des portes comme Azure Monitor, REST API, etc.
Configuration des portes de qualité

6.5.6.2 Exemple de configuration de porte REST API

# 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")'

6.5.6.3 Intégration avec les tests fonctionnels

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: true

6.5.7 Surveillance continue

6.5.7.1 Azure DevOps avec Azure Monitor

Inté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'

6.5.7.2 Automatisation des réactions aux problèmes

# 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'

6.5.8 Journalisation et visibilité

6.5.8.1 Centralisation des journaux

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)

6.5.8.2 Tableaux de bord de santé

Configuration d’un tableau de bord de santé :

  1. Utilisez Azure Dashboard pour visualiser les métriques clés
  2. Intégrez des widgets Application Insights
  3. Configurez des alertes visuelles pour les problèmes

6.5.9 Bonnes pratiques

  1. Implémentez des health checks complets - Incluez tous les composants critiques
  2. Automatisez les vérifications - Intégrez-les dans vos pipelines
  3. Définissez des seuils clairs - Établissez ce qui constitue un état sain
  4. Créez des tableaux de bord - Rendez l’état de santé visible
  5. Mettez en place des alertes - Notifiez rapidement en cas de problème
  6. Implémentez des rollbacks automatiques - Réagissez rapidement aux problèmes
  7. Documentez vos procédures - Assurez une réponse cohérente aux incidents

6.6 Introduction au processus de développement de la sécurité

6.6.1 Introduction

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.

6.6.2 Concepts fondamentaux de DevSecOps

6.6.2.1 Qu’est-ce que DevSecOps ?

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 :

Cycle DevSecOps

6.6.2.2 Avantages de DevSecOps

6.6.3 Intégration de la sécurité dans le cycle DevOps

6.6.3.1 Phases du cycle de vie et contrôles de sécurité

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

6.6.3.2 Le modèle de responsabilité partagée

Dans DevSecOps, la sécurité n’est pas uniquement la responsabilité d’une équipe dédiée :

6.6.4 Outils de sécurité dans Azure DevOps

6.6.4.1 Analyse statique du code (SAST)

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'

6.6.4.2 Analyse des dépendances (SCA)

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'

6.6.4.3 Analyse des secrets

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'

6.6.4.4 Tests de sécurité dynamiques (DAST)

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'

6.6.4.5 Analyse de configuration

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'

6.6.5 Azure DevOps Security Features

6.6.5.1 Azure DevOps Advanced Security

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'

6.6.5.2 Portes de sécurité (Security Gates)

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: 0

6.6.5.3 Politiques de sécurité (Security Policies)

Azure DevOps permet de définir des politiques de sécurité pour les branches :

6.6.6 Sécurité des secrets et gestion des identités

6.6.6.1 Azure Key Vault

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: true

Utilisation 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)"'

6.6.6.2 Gestion des identités dans les pipelines

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 $webappName

6.6.7 Auditing et conformité

6.6.7.1 Journalisation de sécurité

Configuration 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=7

6.6.7.2 Rapports de conformité

Gé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'

6.6.8 Réponse aux incidents de sécurité

6.6.8.1 Détection des incidents

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)

6.6.8.2 Gestion des vulnérabilités

Processus de gestion des vulnérabilités détectées :

  1. Triage - Évaluer la gravité et la priorité
  2. Correction - Développer et tester des correctifs
  3. Validation - Vérifier que la vulnérabilité est corrigée
  4. Apprentissage - Documenter et partager les leçons apprises

6.6.9 Bonnes pratiques en DevSecOps

  1. Automatisez tout - Intégrez les contrôles de sécurité dans les pipelines CI/CD
  2. Privilégiez la prévention - Détectez les problèmes le plus tôt possible
  3. Formez les développeurs - La sécurité commence au niveau du code
  4. Testez régulièrement - Effectuez des tests de sécurité fréquents
  5. Utilisez la défense en profondeur - Implémentez plusieurs couches de contrôles
  6. Documentez - Maintenez une documentation à jour des contrôles de sécurité
  7. Restez informé - Suivez les tendances et les nouvelles vulnérabilités

6.7 Gérer les données de configuration des applications

6.7.1 Introduction

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.

6.7.2 Techniques de gestion de configuration

6.7.2.1 Variables d’environnement

6.7.2.2 Fichiers de configuration

- task: FileTransform@1
  inputs:
    folderPath: '$(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip'
    fileType: 'json'
    targetFiles: '**/appsettings.json'

6.7.2.3 Azure App Configuration

// 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);
           });
});

6.7.3 Bonnes pratiques

  1. Sécurité
  2. Hiérarchie
  3. Validation

6.8 Intégration avec les systèmes de gestion des identités

6.8.1 Azure Active Directory (Azure AD)

6.8.1.1 Intégration d’Azure DevOps avec Azure AD

6.8.1.2 Authentification des applications

# 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'

6.8.2 Gestion des secrets

6.8.2.1 Azure Key Vault

# 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

6.8.2.2 Gestion des identités dans les pipelines

6.8.3 Sécurisation des déploiements

6.9 Implémenter la configuration de l’application

6.9.1 Stratégies de déploiement

6.9.1.1 Configuration progressive

6.9.1.2 Gestion de la configuration par environnement

# 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)

6.9.2 Configuration à l’exécution

6.9.2.1 Azure App Services

6.9.2.2 Azure Functions

6.9.2.3 Conteneurs

6.9.3 Observabilité et supervision

6.10 Ateliers pratiques

6.10.1 Atelier 1: Configuration des pipelines en tant que code avec YAML

6.10.1.1 Objectifs

6.10.1.2 Étapes

  1. 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 application
  2. Ajout des étapes de compilation

    - task: DotNetCoreCLI@2
      inputs:
        command: 'restore'
        projects: '**/*.csproj'
    
    - task: DotNetCoreCLI@2
      inputs:
        command: 'build'
        projects: '**/*.csproj'
        arguments: '--configuration $(buildConfiguration)'
  3. Configuration des tests

    - task: DotNetCoreCLI@2
      inputs:
        command: 'test'
        projects: '**/*Tests/*.csproj'
        arguments: '--configuration $(buildConfiguration)'
  4. 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 PROD

6.10.1.3 Exercices pour aller plus loin

  1. Créer un pipeline pour une application web .NET
  2. Ajouter des variables spécifiques à chaque environnement
  3. Implémenter des conditions pour des déploiements sélectifs

6.10.2 Atelier 2: Configuration de pipelines et exécution de tests fonctionnels

6.10.2.1 Objectifs

6.10.2.2 Étapes

  1. Configuration des tests unitaires

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

    - task: DotNetCoreCLI@2
      displayName: 'Run functional tests'
      inputs:
        command: 'test'
        projects: '**/FunctionalTests/*.csproj'
        arguments: '--configuration $(buildConfiguration)'
  3. Publication des résultats de test

    - task: PublishCodeCoverageResults@1
      displayName: 'Publish code coverage report'
      inputs:
        codeCoverageTool: 'Cobertura'
        summaryFileLocation: '$(Agent.TempDirectory)/**/coverage.cobertura.xml'
  4. Définition des seuils de qualité

    - task: PublishTestResults@2
      inputs:
        testResultsFormat: 'VSTest'
        testResultsFiles: '**/*.trx'
        failTaskOnFailedTests: true

6.10.2.3 Exercices pour aller plus loin

  1. Configurer un pipeline avec des tests Selenium pour des tests d’interface utilisateur
  2. Ajouter des tests de performance avec JMeter
  3. Implémenter des gates de qualité basées sur les résultats des tests

6.10.3 Atelier 3: Intégration d’Azure Key Vault avec Azure DevOps

6.10.3.1 Objectifs

6.10.3.2 Étapes

  1. Configuration de la connexion à Key Vault

    - task: AzureKeyVault@2
      inputs:
        azureSubscription: 'Azure subscription'
        KeyVaultName: 'myKeyVault'
        SecretsFilter: '*'
        RunAsPreJob: true
  2. Utilisation 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)'
  3. 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]

6.10.3.3 Exercices pour aller plus loin

  1. Configurer un Key Vault et y stocker des secrets pour une application
  2. Créer un pipeline qui récupère les secrets et les utilise dans un déploiement
  3. Implémenter un mécanisme de rotation automatique des secrets

6.10.4 Atelier 4: Pipelines permettant la configuration dynamique et les indicateurs de fonctionnalités

6.10.4.1 Objectifs

6.10.4.2 Étapes

  1. 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" --yes
  2. Configuration 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 false
  3. Inté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();
        }
    }
  4. 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 true

6.10.4.3 Exercices pour aller plus loin

  1. Créer une application web avec des features flags
  2. Configurer Azure App Configuration pour gérer ces feature flags
  3. Implémenter un pipeline qui active/désactive des fonctionnalités selon l’environnement

6.11 Ressources complémentaires

6.11.1 Documentation officielle

6.11.2 Tutoriels et guides pratiques

6.11.3 Livres recommandés

6.12 Quiz de révision- Déploiement continu sécurisé avec Azure Pipelines

6.12.1 Question 1

Quelle est la meilleure pratique pour gérer les secrets dans un pipeline Azure DevOps?

  1. Stocker les secrets dans des fichiers de configuration avec un chiffrement personnalisé
  2. Utiliser Azure Key Vault intégré au pipeline via la tâche AzureKeyVault
  3. Sauvegarder les secrets dans des variables d’environnement non marquées comme secrètes
  4. Inclure les secrets directement dans le code source avec des commentaires explicatifs

Réponse correcte : B

6.12.2 Question 2

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?

  1. Déploiement blue/green
  2. Déploiement big bang
  3. Déploiement canary
  4. Déploiement rollback

Réponse correcte : C

6.12.3 Question 3

Comment implémenter correctement des indicateurs de fonctionnalités (feature flags) dans une application .NET?

  1. Utiliser des #if/#endif directives de préprocesseur dans le code source
  2. Créer des branches Git séparées pour chaque fonctionnalité
  3. Utiliser la bibliothèque Microsoft.FeatureManagement avec Azure App Configuration
  4. Modifier manuellement le code pour activer/désactiver des fonctionnalités

Réponse correcte : C

6.12.4 Question 4

Quelle est la meilleure approche pour gérer les configurations spécifiques à l’environnement dans un pipeline CI/CD?

  1. Créer différentes copies du code source pour chaque environnement
  2. Utiliser des variables de stage et des groupes de variables dans le pipeline
  3. Hardcoder les valeurs de configuration dans le code avec des commentaires
  4. Reconfigurer manuellement l’application après chaque déploiement

Réponse correcte : B

6.12.5 Question 5

Quelle tâche dans un pipeline YAML est utilisée pour permuter les slots de déploiement dans Azure App Service?

  1. AzureResourceManagerTemplateDeployment@3
  2. AzureWebApp@1
  3. AzureAppServiceManage@0
  4. AzureFileCopy@4

Réponse correcte : C

7 Gérer l’infrastructure en tant que code à l’aide d’Azure, DSC et d’outils tiers

7.1 Objectifs d’apprentissage

À la fin de ce module, vous serez capable de :

  1. Comprendre les principes de l’Infrastructure as Code (IaC) et les approches de gestion de configuration
  2. Maîtriser les modèles Azure Resource Manager (ARM) pour le déploiement de ressources Azure
  3. Utiliser l’interface de ligne de commande Azure pour créer et gérer des ressources de façon automatisée
  4. Implémenter Azure Automation dans un contexte DevOps pour l’automatisation des opérations
  5. Appliquer la configuration d’état souhaité (DSC) pour maintenir les configurations système
  6. Acquérir les bases de Chef et Puppet pour la gestion de configuration multi-plateformes
  7. Déployer Ansible pour l’orchestration et la gestion de configuration sans agent
  8. Utiliser Terraform pour provisionner et gérer l’infrastructure cloud de manière déclarative

7.2 Explorer l’infrastructure en tant que gestion du code et de la configuration

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.

7.2.0.1 Avantages de l’IaC :

7.2.1 Types d’approches IaC

7.2.1.1 Approche déclarative vs impérative

7.2.1.2 Modèles de configuration vs scripting

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

7.2.2 Principes de la gestion de configuration

7.3 Créer des ressources Azure à l’aide de modèles Azure Resource Manager

7.3.1 Introduction à Azure Resource Manager (ARM)

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.

7.3.1.1 Structure d’un modèle ARM

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": {}
}

7.3.2 Éléments clés des modèles ARM

7.3.3 Création d’un modèle ARM simple

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'))]"
    }
  }
}

7.3.4 Déploiement de modèles ARM

7.3.4.1 Via le portail Azure

7.3.4.2 Via PowerShell

New-AzResourceGroupDeployment -ResourceGroupName MonGroupe -TemplateFile ./monmodele.json -TemplateParameterFile ./parametres.json

7.3.4.3 Via Azure CLI

az deployment group create --resource-group MonGroupe --template-file ./monmodele.json --parameters ./parametres.json

7.3.5 Bonnes pratiques pour les modèles ARM

7.4 Créer des ressources Azure à l’aide de l’interface de ligne de commande Azure

7.4.1 Introduction à Azure CLI

Azure 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.

7.4.2 Installation d’Azure CLI

7.4.2.1 Windows

Invoke-WebRequest -Uri https://aka.ms/installazurecliwindows -OutFile .\AzureCLI.msi
Start-Process msiexec.exe -Wait -ArgumentList '/I AzureCLI.msi /quiet'

7.4.2.2 macOS

brew update && brew install azure-cli

7.4.2.3 Linux (Ubuntu)

curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

7.4.3 Connexion à Azure

# Connexion interactive
az login

# Connexion avec un compte de service
az login --service-principal -u <app-id> -p <password-or-cert> --tenant <tenant>

7.4.4 Gestion des groupes de ressources

# 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-wait

7.4.5 Création de ressources avec Azure CLI

7.4.5.1 Création d’un compte de stockage

az storage account create \
  --name mystorageaccount \
  --resource-group MonGroupe \
  --location francecentral \
  --sku Standard_LRS \
  --kind StorageV2

7.4.5.2 Création d’une machine virtuelle

az vm create \
  --resource-group MonGroupe \
  --name MyVM \
  --image UbuntuLTS \
  --admin-username azureuser \
  --generate-ssh-keys

7.4.6 Automatisation avec des scripts Azure CLI

Exemple 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 !"

7.4.7 Exportation de modèles à partir de ressources existantes

# Exporter un groupe de ressources en modèle ARM
az group export --name MonGroupe > template.json

7.5 Explorer Azure Automation avec DevOps

7.5.1 Introduction à Azure Automation

Azure 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.

7.5.1.1 Fonctionnalités principales

7.5.2 Runbooks Azure Automation

Les runbooks sont des ensembles d’actions ou de tâches qui s’exécutent sur Azure Automation.

7.5.2.1 Types de runbooks

7.5.3 Création d’un runbook PowerShell

# 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)"
}

7.5.4 Intégration d’Azure Automation avec Azure DevOps

7.5.4.1 Configuration d’un webhook pour déclencher un runbook

  1. Dans Azure Automation, ouvrir le runbook
  2. Sélectionner “Webhooks” et créer un webhook
  3. Copier l’URL du webhook

7.5.4.2 Déclenchement depuis Azure DevOps

# 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)"

7.5.5 Gestion d’inventaire avec Azure Automation

Azure Automation Inventory collecte et visualise les informations sur les logiciels installés, les fichiers, les services Windows, les clés de registre, etc.

7.5.5.1 Configuration de l’inventaire

  1. Créer un compte Automation
  2. Activer la fonctionnalité Inventory
  3. Ajouter des machines à gérer
  4. Configurer les paramètres de collecte
  5. Consulter les données d’inventaire dans le portail Azure

7.6 Implémenter la configuration de l’état souhaité (DSC)

7.6.1 Introduction à PowerShell DSC

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.

7.6.1.1 Principes clés de DSC

7.6.2 Composants de DSC

7.6.3 Création d’une configuration DSC simple

# 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"

7.6.4 Application de configurations DSC

7.6.4.1 Application locale

# Application directe
Start-DscConfiguration -Path "C:\DSC" -Wait -Verbose

# Test de la configuration
Test-DscConfiguration -Path "C:\DSC"

7.6.4.2 Configuration du LCM

# 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" -Verbose

7.6.5 Intégration de DSC avec Azure Automation

Azure Automation DSC permet de gérer centralement les configurations DSC pour les nœuds Azure et sur site.

7.6.5.1 Étapes d’intégration

  1. Créer un compte Automation avec State Configuration
  2. Importer les modules DSC nécessaires
  3. Télécharger et compiler les configurations DSC
  4. Enregistrer les nœuds à gérer
  5. Attribuer les configurations aux nœuds

7.6.5.2 Exemple : Enregistrement d’un nœud Windows

# 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 $true

7.7 Introduction au Chef et à Puppet

7.7.1 Présentation de Chef

Chef 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.

7.7.1.1 Architecture de Chef

7.7.1.2 Concepts clés de Chef

7.7.2 Exemple de recette Chef simple

# 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]
end

7.7.3 Présentation de Puppet

Puppet est une plateforme d’automatisation qui permet de gérer l’infrastructure tout au long de son cycle de vie.

7.7.3.1 Architecture de Puppet

7.7.3.2 Concepts clés de Puppet

7.7.4 Exemple de manifeste Puppet simple

# 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']],
  }
}

7.7.5 Intégration avec Azure

7.7.5.1 Chef

7.7.5.2 Puppet

7.8 Implémenter Ansible

7.8.1 Introduction à Ansible

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.

7.8.1.1 Caractéristiques d’Ansible

7.8.2 Architecture d’Ansible

7.8.3 Installation d’Ansible

7.8.3.1 Sur Ubuntu

sudo apt update
sudo apt install -y ansible

7.8.3.2 Sur CentOS/RHEL

sudo yum install -y epel-release
sudo yum install -y ansible

7.8.4 Création d’un inventaire 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

7.8.5 Création d’un playbook Ansible simple


# 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

7.8.6 Exécution d’un playbook Ansible

# 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 --check

7.8.7 Ansible avec Azure

7.8.7.1 Installation du module Azure

pip install ansible[azure]

7.8.7.2 Configuration des informations d’identification 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"

7.8.7.3 Exemple de playbook pour Azure


# 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: latest

7.9 Mettre en œuvre Terraform

7.9.1 Introduction à Terraform

Terraform 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.

7.9.1.1 Caractéristiques de Terraform

7.9.2 Installation de Terraform

7.9.2.1 Windows

choco install terraform

7.9.2.2 macOS

brew install terraform

7.9.2.3 Linux

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

7.9.3 Configuration de Terraform pour Azure

7.9.3.1 Authentification via Service Principal

# 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"

7.9.3.2 Fichier de fournisseur (provider.tf)

terraform {
  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~> 2.65"
    }
  }
}

provider "azurerm" {
  features {}
}

7.9.4 Création d’une infrastructure Azure avec Terraform

7.9.4.1 Exemple de fichier main.tf

# 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"
  }
}

7.9.5 Variables et modules Terraform

7.9.5.1 Fichier variables.tf

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"
}

7.9.5.2 Utilisation de modules Terraform

# 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
}

7.9.6 État et backend Terraform

7.9.6.1 État local

Par défaut, Terraform stocke l’état de l’infrastructure dans un fichier local terraform.tfstate.

7.9.6.2 État distant avec Azure Storage

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 terraformstate123

7.9.7 Cycle de vie Terraform

7.9.7.1 Initialisation

terraform init

7.9.7.2 Planification

terraform plan -out=tfplan

7.9.7.3 Application

terraform apply tfplan

7.9.7.4 Destruction

terraform destroy

7.9.8 Meilleures pratiques Terraform

  1. Structure de projet
  2. Gestion des versions
  3. État
  4. Sécurité
  5. Automatisation

7.10 Ressources supplémentaires

7.10.1 Documentation officielle

7.10.2 Cours et ateliers pratiques

7.10.3 Livres recommandés

8 Concevoir et mettre en oeuvre une stratégie de gestion des dépendances

8.1 1. Explorer les dépendances de package

8.1.1 1.1 Comprendre les dépendances logicielles

Les 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.

8.1.1.1 Types de dépendances

8.1.1.2 Défis liés aux dépendances

8.1.2 1.2 Analyse des dépendances

8.1.2.1 Outils d’analyse de dépendances par langage

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

8.1.2.2 Exemple d’analyse avec .NET

# 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

8.1.2.3 Exemple d’analyse avec NPM

# Lister les dépendances directes
npm list --depth=0

# Vérifier les vulnérabilités
npm audit

# Visualiser l'arbre de dépendances
npm list

8.1.3 1.3 Graphes de dépendances dans Azure DevOps

Azure DevOps propose des outils pour visualiser et gérer les dépendances de votre projet :

8.1.3.1 Dépendances entre épics et fonctionnalités

8.1.3.2 Dépendances entre pipelines

8.1.3.3 Utilisation de la visualisation de dépendances

  1. Naviguer vers un élément de travail dans Azure Boards
  2. Sélectionner “Visualiser” dans le menu
  3. Explorer les dépendances amont et aval

8.1.4 1.4 Gestion des dépendances externes dans Azure Pipelines

# 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'

8.2 2. Comprendre la gestion des packages

8.2.1 2.1 Flux de packages et référentiels

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 :

8.2.1.1 Feeds publics

8.2.1.2 Feeds privés

8.2.2 2.2 Azure Artifacts

Azure Artifacts est le service de gestion de packages intégré à Azure DevOps. Il permet de créer, héberger et partager des packages.

8.2.2.1 Types de packages supportés

8.2.2.2 Création d’un feed dans Azure Artifacts

  1. Dans Azure DevOps, naviguer vers “Artifacts”
  2. Cliquer sur “Create Feed”
  3. Définir le nom, la visibilité et les options de rétention
  4. Configurer les autorisations d’accès

8.2.2.3 Configuration des sources de 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

8.2.3 2.3 Gestion des packages dans un pipeline CI/CD

8.2.3.1 Publication de packages

# 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'

8.2.3.2 Consommation de packages

# Exemple de consommation de packages NPM
steps:
- task: Npm@1
  displayName: 'npm install'
  inputs:
    command: 'install'
    customRegistry: 'useFeed'
    customFeed: 'myfeed'

8.2.4 2.4 Politiques de rétention et promotion de packages

Azure Artifacts permet de définir des politiques pour la gestion du cycle de vie des packages :

8.2.4.1 Politiques de rétention

8.2.4.2 Vues et promotion de packages

8.2.4.3 Configuration d’une politique de rétention

  1. Dans Azure DevOps, naviguer vers “Artifacts”
  2. Sélectionner le feed
  3. Cliquer sur “Feed settings”
  4. Configurer les paramètres de rétention

8.3 3. Migrer, consolider et sécuriser les artefacts

8.3.1 3.1 Migration des artefacts entre référentiels

La migration des artefacts peut être nécessaire lors de la consolidation des systèmes ou de la transition vers de nouveaux outils.

8.3.1.1 Stratégies de migration

8.3.1.2 Outils de migration

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

8.3.1.3 Exemple de migration NuGet vers Azure Artifacts

# 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
}

8.3.2 3.2 Consolidation des référentiels d’artefacts

La consolidation des référentiels vise à réduire la complexité et améliorer la gouvernance.

8.3.2.1 Avantages de la consolidation

8.3.2.2 Étapes de consolidation

  1. Inventaire : Identifier tous les référentiels existants
  2. Analyse : Évaluer les dépendances et les dépendants
  3. Planification : Définir la stratégie de migration
  4. Exécution : Migrer les artefacts
  5. Validation : Vérifier l’intégrité des artefacts migrés
  6. Transition : Rediriger les consommateurs vers le nouveau référentiel

8.3.3 3.3 Sécurisation des artefacts

8.3.3.1 Menaces courantes

8.3.3.2 Bonnes pratiques de sécurité

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

8.3.3.3 Exemple d’intégration de scans de sécurité dans un pipeline Azure

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'

8.3.4 3.4 Gestion des artefacts dans un environnement multi-cloud

8.3.4.1 Défis des environnements multi-cloud

8.3.4.2 Stratégies de gestion

8.3.4.3 Exemple de synchronisation entre référentiels

# 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"
}

8.4 4. Mettre en œuvre une stratégie de gestion des versions

8.4.1 4.1 Comprendre le versionnage sémantique (SemVer)

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.

8.4.1.1 Format de SemVer

MAJEUR.MINEUR.CORRECTIF[-préversion][+métadonnées]

8.4.1.2 Exemples de versions SemVer

8.4.2 4.2 Stratégies de versionnage

8.4.2.1 Versionnage calendaire

Format 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

8.4.2.2 Versionnage continu

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

8.4.2.3 Versionnage hybride

Combinaison de plusieurs approches - Exemple : 2023.1.0-rc.2+build.123 - Avantages : Flexibilité maximale - Inconvénients : Peut devenir complexe

8.4.3 4.3 Automatisation du versionnage

8.4.3.1 Outils de versionnage automatique

8.4.3.2 Exemple d’utilisation de GitVersion dans Azure Pipelines

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

8.4.4 4.4 Gestion des versions dans les différentes technologies

8.4.4.1 .NET

<!-- 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>

8.4.4.2 JavaScript (Node.js)

// package.json
{
  "name": "my-package",
  "version": "1.2.3-beta.1",
  "description": "My package description"
}

8.4.4.3 Java (Maven)

<!-- pom.xml -->
<project>
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example</groupId>
  <artifactId>my-project</artifactId>
  <version>1.2.3-SNAPSHOT</version>
</project>

8.4.5 4.5 Stratégies de versions pour les microservices

8.4.5.1 Défis des microservices

8.4.5.2 Approches de versionnage pour microservices

8.4.5.3 Exemple de versionnage d’API REST

// 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 { }

9 Formation Azure DevOps - Préparation Certification AZ-400

9.1 Module 7 : Concevoir et mettre en œuvre une stratégie de gestion des dépendances

9.1.1 Atelier 1 : Mettre en œuvre la sécurité et la conformité dans un pipeline Azure DevOps

9.1.1.1 Objectifs pédagogiques

9.1.1.2 Prérequis

9.1.1.3 Partie 1 : Configuration des règles de sécurité de base

Instructions:

  1. Configurer la protection des branches
  2. Créer une politique de validation de code
  3. Questions de réflexion:

9.1.1.4 Partie 2 : Intégration des scans de sécurité dans le pipeline

Instructions:

  1. Installer l’extension Microsoft Security DevOps
  2. Ajouter un scan de sécurité au pipeline CI/CD
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'
  1. Configurer un scan des dépendances
- 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'
  1. Créez une tâche pour publier les résultats du scan
- task: PublishBuildArtifacts@1
  displayName: 'Publier les résultats du scan de sécurité'
  inputs:
    pathToPublish: '$(Build.SourcesDirectory)/dependency-check-report.html'
    artifactName: 'security-reports'
  1. Questions de réflexion:

9.1.1.5 Partie 3 : Mise en place de stratégies de conformité

Instructions:

  1. Créer une stratégie de conformité avec Azure Policy
{
  "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"
      }
    }
  }
}
  1. Intégrer le contrôle de conformité dans le pipeline CD
- task: AzurePolicyComplianceCheck@0
  displayName: 'Vérification de la conformité Azure Policy'
  inputs:
    azureSubscriptionEndpoint: '$(AzureSubscriptionEndpoint)'
    resourceGroupName: '$(ResourceGroupName)'
    resourceId: '$(ResourceId)'
  1. Configurer un gate de validation avant déploiement en production
  2. Questions de réflexion:

9.1.1.6 Partie 4 : Gestion des secrets dans le pipeline

Instructions:

  1. Créer un Azure Key Vault
  2. Ajouter des secrets au Key Vault
  3. Configurer l’accès sécurisé dans le pipeline
- 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)"'
  1. Questions de réflexion:

9.1.1.7 Évaluation

Pour valider cet atelier, répondez aux questions suivantes:

  1. Quelles sont les trois principales stratégies de sécurité que vous avez implémentées?
  2. Comment avez-vous géré les secrets sensibles dans le pipeline?
  3. Quelles mesures avez-vous prises pour assurer la conformité du code déployé?
  4. Comment avez-vous configuré la protection des branches, et pourquoi est-ce important?
  5. Expliquez comment vous avez intégré les scans de sécurité au pipeline CI/CD.

9.1.2 Atelier 2 : Gérer la dette technique avec SonarCloud et Azure DevOps

9.1.2.1 Objectifs pédagogiques

9.1.2.2 Prérequis

9.1.2.3 Partie 1 : Configuration de SonarCloud

Instructions:

  1. Créer un compte SonarCloud
  2. Installer l’extension SonarCloud pour Azure DevOps
  3. Créer un projet SonarCloud
  4. Questions de réflexion:

9.1.2.4 Partie 2 : Intégration de SonarCloud dans le pipeline CI/CD

Instructions:

  1. Configurer les variables de service connection
  2. Configurer l’analyse SonarCloud pour un projet .NET
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'
  1. Pour les projets JavaScript/TypeScript
- 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.info
  1. Questions de réflexion:

9.1.2.5 Partie 3 : Configuration des Quality Gates

Instructions:

  1. Configurer un Quality Gate dans SonarCloud
  2. Configurer l’échec du build en cas de non-respect du Quality Gate
- 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;]"
      }
  1. Ajouter une condition de déploiement basée sur le Quality Gate
  2. Questions de réflexion:

9.1.2.6 Partie 4 : Analyse et remédiation de la dette technique

Instructions:

  1. Exécuter une première analyse complète
  2. Créer un plan de remédiation
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
  1. Mettre en place un suivi de la dette technique
  2. Questions de réflexion:

9.1.2.7 Partie 5 : Automatisation du processus d’amélioration continue

Instructions:

  1. Configurer des Pull Request Decorators
  2. Créer une politique de branche liée à SonarCloud
  3. Configurer des rapports hebdomadaires
  4. Questions de réflexion:

9.1.2.8 Évaluation

Pour valider cet atelier, répondez aux questions suivantes:

  1. Définissez la dette technique et expliquez son importance dans le développement logiciel.
  2. Comment avez-vous intégré SonarCloud dans votre pipeline Azure DevOps?
  3. Quels Quality Gates avez-vous configurés et pourquoi?
  4. Décrivez votre stratégie pour suivre et réduire la dette technique.
  5. Comment les fonctionnalités d’analyse de code affectent-elles le processus de revue de code?
  6. Présentez votre dashboard de suivi de la qualité du code et expliquez les métriques choisies.

10 Créer et gérer des conteneurs à l’aide de docker et kubernetes

10.1 Objectifs d’apprentissage

À la fin de ce module, vous serez capable de :

  1. Concevoir une stratégie de conteneurisation efficace
  2. Implémenter et optimiser des builds Docker multi-étapes
  3. Déployer et gérer un cluster Azure Kubernetes Service (AKS)
  4. Utiliser les principaux outils Kubernetes
  5. Intégrer AKS dans des pipelines CI/CD
  6. Appliquer les connaissances acquises dans des scénarios réels

10.2 Concevoir une stratégie de création de conteneurs

10.2.1 Introduction aux conteneurs

10.2.2 Principes de la conteneurisation

10.2.3 1.3 Éléments d’une stratégie de conteneurisation

10.2.4 1.4 Bonnes pratiques pour les images Docker

10.2.5 1.5 Stratégie de sécurité des conteneurs

10.3 2. Implémenter des builds Docker en plusieurs étapes

10.3.1 2.1 Le problème des builds Docker traditionnels

10.3.2 2.2 Concept des builds multi-étapes

10.3.3 2.3 Structure d’un Dockerfile multi-étapes

# É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"]

10.3.4 2.4 Exemples de builds multi-étapes pour différents langages

10.3.4.1 2.4.1 Pour une application .NET

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"]

10.3.4.2 2.4.2 Pour une application Java/Spring Boot

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"]

10.3.4.3 2.4.3 Pour une application React

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;"]

10.3.5 2.5 Optimisations avancées

10.4 3. Implémenter Azure Kubernetes Service (AKS)

10.4.1 3.1 Introduction à AKS

10.4.2 3.2 Architecture d’AKS

10.4.3 3.3 Création d’un cluster AKS

10.4.3.1 3.3.1 Via le portail Azure

  1. Accéder au portail Azure
  2. Rechercher “Kubernetes Services”
  3. Cliquer sur “Créer un cluster AKS”
  4. Configurer les paramètres de base (subscription, resource group, etc.)
  5. Configurer les pools de nœuds
  6. Configurer les paramètres d’authentification et de réseau
  7. Valider et créer

10.4.3.2 3.3.2 Via Azure CLI

# 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

10.4.4 3.4 Configuration avancée d’AKS

10.4.5 3.5 Gestion des identités et des accès

10.4.6 3.6 Sécurité d’AKS

10.5 4. Explorer les outils Kubernetes

10.5.1 4.1 Outils en ligne de commande

10.5.2 4.2 Interfaces graphiques

10.5.3 4.3 Outils de développement

10.5.4 4.4 Outils de surveillance et de diagnostic

10.5.5 4.5 Outils de gestion avancée

10.6 5. Intégrer AKS aux pipelines

10.6.1 5.1 Vue d’ensemble de CI/CD avec AKS

10.6.2 5.2 Configuration des registres d’images

10.6.3 5.3 Configuration d’un pipeline CI/CD avec Azure DevOps

10.6.3.1 5.3.1 Configuration du pipeline CI

# 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)'

10.6.3.2 5.3.2 Configuration du pipeline CD

# 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)'

10.6.4 Stratégies de déploiement sur AKS

10.6.5 Automatisation avec GitHub Actions

# .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 }}

10.6.6 Pratiques DevOps pour AKS

10.7 Ressources complémentaires

10.7.1 Documentation officielle

10.7.2 Cours et tutoriels

10.7.3 Livres recommandés

11 Mettre en oeuvre la rétroaction continue

11.1 Introduction

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.

11.2 Objectifs d’apprentissage

À la fin de ce module, vous serez capable de :

11.3 Mettre en œuvre des outils pour suivre l’utilisation et le flux

11.3.1 Azure Application Insights

Azure Application Insights est un service d’APM (Application Performance Management) essentiel pour suivre l’utilisation et les performances des applications.

11.3.1.1 Configuration d’Application Insights

# 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"]);

11.3.1.2 Télémétrie disponible

11.3.1.3 Suivi des parcours utilisateurs

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} });

11.3.2 1.2 Azure Monitor

Azure Monitor fournit une vue complète de l’infrastructure et des applications.

11.3.2.1 Métriques clés à surveiller

11.3.2.2 Intégration avec Azure Log Analytics

# 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 timechart

11.3.3 1.3 User Flow Analytics

Les analyses de flux utilisateur permettent de visualiser comment les utilisateurs naviguent dans votre application.

11.3.3.1 Mise en œuvre avec Power BI

11.4 2. Implémenter l’itinéraire pour les données de rapport d’incident d’application mobile

11.4.1 2.1 Collecte de données d’incidents mobiles

11.4.1.1 Configuration d’App Center pour les applications mobiles

// 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])

11.4.1.2 Intégration d’Azure DevOps avec App Center

11.4.2 2.2 Pipeline de traitement des incidents

11.4.2.1 Architecture recommandée

  1. Collecte : App Center / Application Insights
  2. Traitement : Azure Functions pour enrichissement des données
  3. Stockage : Azure Blob Storage / Cosmos DB
  4. Analyse : Azure Data Explorer / Power BI
  5. Action : Azure DevOps Work Items / Logic Apps

11.4.2.2 Implémentation d’un webhook Azure Functions

[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();
}

11.4.3 2.3 Analyse des tendances d’incidents

11.5 3. Développer des tableaux de bord de surveillance et d’état

11.5.1 3.1 Tableaux de bord Azure DevOps

11.5.1.1 Types de tableaux de bord

11.5.1.2 Widgets essentiels

11.5.1.3 Création d’un tableau de bord personnalisé

{
  "name": "System Health Dashboard",
  "widgets": [
    {
      "id": "markdown",
      "settings": {
        "content": "# Santé du système"
      }
    },
    {
      "id": "QueryResults",
      "settings": {
        "queryId": "12345678-1234-1234-1234-123456789012"
      }
    }
  ]
}

11.5.2 3.2 Azure Monitor Workbooks

Les workbooks permettent de créer des rapports interactifs riches qui combinent texte, métriques, journaux et paramètres.

11.5.2.1 Exemples de workbooks utiles

11.5.2.2 Création d’un workbook avec KQL

// 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

11.5.3 3.3 Power BI pour l’analyse approfondie

11.5.3.1 Intégration d’Azure DevOps avec Power BI

11.5.3.2 Mesures clés à inclure

11.6 4. Partager les connaissances au sein des équipes

11.6.1 4.1 Documentation en tant que code

11.6.1.1 Approches recommandées

11.6.1.2 Exemple de structure de documentation

/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

11.6.2 4.2 Wiki Azure DevOps

11.6.2.1 Organisation efficace

11.6.2.2 Automatisation de la documentation

# 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
      }

11.6.3 4.3 Système de gestion des connaissances

11.6.3.1 Outils intégrables avec Azure DevOps

11.6.3.2 Pratiques efficaces

11.7 5. Explorer les pratiques de SRE et de conception pour mesurer la satisfaction des utilisateurs finaux

11.7.1 5.1 Principes fondamentaux de SRE (Site Reliability Engineering)

11.7.1.1 SLI (Service Level Indicators)

11.7.1.2 Implémentation des SLI avec Azure Monitor

// 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

11.7.1.3 SLO (Service Level Objectives)

Comment définir des objectifs réalistes : - Basés sur les attentes utilisateurs - Mesurables via les SLI - Réalistes et atteignables

11.7.1.4 SLA (Service Level Agreements)

11.7.2 5.2 Mesure de l’expérience utilisateur

11.7.2.1 APDEX (Application Performance Index)

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

11.7.2.2 Implémentation avec Application Insights

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)

11.7.3 5.3 Outils de mesure du comportement utilisateur

11.8 6. Concevoir des processus pour capturer et analyser les commentaires des utilisateurs

11.8.1 6.1 Canaux de feedback

11.8.1.1 Intégration dans l’application

// 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);
}

11.8.1.2 Canaux externes

11.8.2 6.2 Analyse des sentiments

11.8.2.1 Integration avec Azure Cognitive Services

// 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;
}

11.8.2.2 Visualisation des tendances de sentiment

11.8.3 6.3 Boucle de rétroaction

11.8.3.1 Processus recommandé

  1. Collecte des commentaires utilisateurs
  2. Catégorisation par thèmes et impact
  3. Analyse des causes profondes
  4. Priorisation dans le backlog
  5. Implémentation des améliorations
  6. Communication aux utilisateurs
  7. Mesure de l’impact des changements

11.9 7. Concevoir des processus pour automatiser l’analyse des applications

11.9.1 7.1 Analyse des performances

11.9.1.1 APM (Application Performance Monitoring)

11.9.1.2 Implémentation avec Application Insights Profiler

# 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

11.9.2 7.2 Analyse de code automatisée

11.9.2.1 Intégration de SonarQube dans Azure DevOps

# 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'

11.9.2.2 Métriques clés à suivre

11.9.3 7.3 Testing automatisé

11.9.3.1 Tests de charge avec Azure Load Testing

# 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

11.9.3.2 Tests de disponibilité avec Application Insights

# 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

11.10 8. Gérer les alertes, les rétrospectives irréprochables et une culture juste

11.10.1 8.1 Gestion efficace des alertes

11.10.1.1 Configuration d’alertes intelligentes

# 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"

11.10.1.2 Routing des alertes

11.10.2 8.2 Rétrospectives irréprochables

11.10.2.1 Principes clés

11.10.2.2 Modèle de document de rétrospective

# 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]

11.10.3 8.3 Culture juste

11.10.3.1 Caractéristiques d’une culture juste

11.10.3.2 Mise en œuvre dans l’organisation

11.11 Exercices pratiques

11.11.1 Exercice 1 : Configuration d’Application Insights

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

11.11.2 Exercice 2 : Création d’un tableau de bord Azure DevOps

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

11.11.3 Exercice 3 : Mise en place d’un processus de gestion des incidents

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

11.12 Ressources supplémentaires

11.13 Préparation à l’examen AZ-400

11.13.1 Points clés à retenir

11.13.2 Questions typiques

  1. Quelle est la différence entre un SLI et un SLO ?
  2. Comment configurer une alerte basée sur une détection d’anomalies dans Azure Monitor ?
  3. Quels sont les avantages de l’approche “documentation as code” ?
  4. Comment configurer App Center pour collecter des données d’incidents d’applications mobiles ?
  5. Quelles sont les étapes d’une rétrospective irréprochable efficace ?

12 Mettre en oeuvre la sécurité et valider les bases de code pour la conformité