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

@vanessakovalsky

1 Introduction

1.1 Objectifs de la formation

  • Apprendre à développer avec Azure DevOps
  • Maîtriser la planification Agile
  • Configurer un environnement de build moderne, automatiser les builds
  • Gérer la qualité du code, créer des pipelines et release automatisés
  • Automatiser les tests fonctionnels et de performance
  • Gérer Azure Resource Manager (ARM), surveiller des applications avec Application Insights
  • Créer des tableaux de bord pour les stats de build et release

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 :

  • Comprendre les fondamentaux DevOps
  • Sélectionner des projets adaptés à la transformation DevOps
  • Organiser les équipes pour le DevOps
  • Planifier une migration vers DevOps
  • Maîtriser les concepts de gestion de code source
  • Différencier les systèmes de contrôle de version
  • Mettre en œuvre la planification agile avec Azure Boards

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
  • Planification : Définition des exigences et planification du travail
  • Développement : Écriture et revue du code
  • Intégration continue : Compilation et tests automatisés fréquents
  • Déploiement continu : Livraison automatisée vers les environnements
  • Exploitation : Surveillance et maintenance des applications
  • Feedback : Collecte des retours utilisateurs et identification des améliorations

2.2.4 Avantages du DevOps

  • Réduction du temps de mise sur le marché (Time-to-Market)
  • Amélioration de la qualité des logiciels
  • Augmentation de la fréquence des déploiements
  • Réduction des échecs de déploiement
  • Résolution plus rapide des incidents
  • Meilleure collaboration entre équipes

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
    • Structure : Équipe spécialisée séparée qui soutient les autres équipes
    • Avantages : Expertise concentrée, standardisation des pratiques
    • Inconvénients : Risque de créer un nouveau silo, peut ralentir l’adoption globale
  2. Modèle intégré
    • Structure : Les compétences DevOps sont intégrées directement dans les équipes produit
    • Avantages : Responsabilisation de l’équipe, meilleure adoption des pratiques
    • Inconvénients : Duplication possible des efforts, besoin de formation importante
  1. Modèle de communauté de pratique
    • Structure : Experts DevOps intégrés aux équipes + communauté transverse de partage
    • Avantages : Équilibre entre standardisation et autonomie, partage des connaissances
    • Inconvénients : Nécessite un fort engagement pour animer la communauté
  2. Modèle SRE (Site Reliability Engineering)
    • Structure : Équipe d’ingénieurs de fiabilité qui travaille avec les développeurs
    • Avantages : Focus sur la fiabilité et les performances, équilibre entre stabilité et innovation
    • Inconvénients : Requiert des compétences spécifiques et une maturité technique élevée

2.4.3 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.4 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)
    • Évaluation de la maturité actuelle
    • Formation des leaders sur les concepts DevOps
    • Sélection des projets pilotes
    • Définition des indicateurs de succès
  2. Fondation (3-6 mois)
    • Mise en place des outils de base (Git, CI/CD)
    • Formation des équipes pilotes
    • Automatisation des premiers tests
    • Déploiements manuels assistés
  1. Adaptation (6-12 mois)
    • Extension à d’autres équipes
    • Automatisation des déploiements
    • Mise en place de pratiques de revue de code
    • Amélioration de la qualité du code
  2. Optimisation (12-24 mois)
    • Déploiement continu
    • Infrastructure as Code généralisée
    • Observabilité complète
    • Culture DevOps ancrée dans l’organisation

2.5.4 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.5 Mesurer le succès de la transformation

Métriques techniques

  • Fréquence des déploiements
  • Temps de cycle (du commit au déploiement)
  • Taux d’échec des modifications
  • Temps moyen de récupération (MTTR)
  • Couverture des tests automatisés

Métriques métier

  • Time-to-Market des nouvelles fonctionnalités
  • Satisfaction client
  • Coût opérationnel
  • Taux d’innovation
  • Réduction des incidents en production

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

  • Traçabilité des modifications
  • Collaboration entre développeurs
  • Gestion des versions du logiciel
  • Restauration d’états antérieurs
  • Expérimentation sécurisée via les branches

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

  • Messages de commit significatifs : Expliquer clairement le “pourquoi” et le “quoi” des modifications
  • Commits atomiques : Chaque commit devrait représenter une modification logique unique
  • Branches de fonctionnalités : Créer une branche par fonctionnalité ou correction
  • Intégration fréquente : Fusionner régulièrement pour éviter les conflits majeurs
  • Pull requests / Merge requests : Faciliter la revue de code avant l’intégration
  • Git Flow ou Trunk-Based Development : Adopter une stratégie de branchement cohérente

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)

  • Exemple : Subversion (SVN), Team Foundation Version Control (TFVC)
  • Architecture : Un serveur central contient l’intégralité du dépôt
  • Caractéristiques :
    • Numéros de version séquentiels
    • Nécessite une connexion réseau pour la plupart des opérations
    • Modèle de verrouillage pour éviter les conflits
    • Plus simple à comprendre pour les débutants
  • Avantages : Contrôle administratif, simplicité conceptuelle
  • Inconvénients : Point unique de défaillance, opérations réseau plus lentes

Systèmes distribués (DVCS)

  • Exemples : Git, Mercurial
  • Architecture : Chaque clone contient l’historique complet du dépôt
  • Caractéristiques :
    • Identifiants de commit basés sur le contenu (hashes)
    • Travail hors ligne possible
    • Branches et fusions plus légères et rapides
    • Modèle basé sur la fusion plutôt que le verrouillage
  • Avantages : Robustesse, performances, flexibilité des workflows
  • Inconvénients : Courbe d’apprentissage plus raide, taille des dépôts

2.7.3 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.4 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

  • Service de gestion de code source intégré à Azure DevOps
  • Supporte à la fois Git (distribué) et TFVC (centralisé)
  • Inclus dans Azure DevOps Services (cloud) et Azure DevOps Server (on-premise)

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

Présentation

  • Plus grande plateforme d’hébergement de code au monde (acquise par Microsoft)
  • Orientée principalement vers les projets open source mais aussi utilisée pour les projets privés
  • Basée exclusivement sur Git

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.5 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.7 Bonnes pratiques communes

  1. Stratégie de branchement

    • Trunk-Based : main + branches de fonctionnalités éphémères
    • Git Flow : main, develop, feature/*, release/*, hotfix/*
  2. Standards de qualité

    • Branch Protection Rules / Branch Policies
    • Validations obligatoires des pipelines CI
    • Nombre minimum de réviseurs pour les PR/MR
  3. Automatisation

    • Hooks Git pour vérifications pré-commit
    • Intégration avec les outils d’analyse statique
    • Déploiements automatisés basés sur les tags

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

2.9.1 Objectifs

  • Configurer Azure Boards pour la gestion agile des projets
  • Créer et organiser un backlog de produit
  • Configurer des sprints et des tableaux Kanban
  • Établir un suivi du travail avec les requêtes et rapports
  • Connecter les éléments de travail aux commits Git

2.9.2 Prérequis

  • Accès à un projet Azure DevOps
  • Permissions pour créer et gérer des éléments de travail
  • Un navigateur web moderne

2.9.3 Étape 1 : Configuration initiale d’Azure Boards

  1. Accéder à Azure Boards

    • Connectez-vous à votre organisation Azure DevOps
    • Sélectionnez votre projet
    • Cliquez sur “Boards” dans la barre de navigation gauche
  2. Choisir une méthodologie Agile

    • Accédez à Paramètres du projet > Boards > Processus
    • Sélectionnez l’un des modèles suivants:
      • Scrum : Pour une approche Scrum stricte (Product Backlog Items, Sprints)
      • Agile : Pour une méthodologie hybride (User Stories, Iterations)
      • Basic : Pour une approche simplifiée (Issues, Epics)
      • CMMI : Pour des projets nécessitant plus de formalisme (Requirements, Reviews)
  1. Configurer les zones (Areas)

    • Accédez à Paramètres du projet > Boards > Classification > Areas

    • Créez une structure qui reflète les composants de votre application:

      [Nom du Projet]
      ├── Frontend
      ├── Backend
      │   ├── API
      │   └── Database
      └── Infrastructure
  2. Configurer les itérations (Sprints)

    • Accédez à Paramètres du projet > Boards > Classification > Iterations

    • Créez vos sprints avec les dates appropriées:

      [Nom du Projet]
      ├── Release 1
      │   ├── Sprint 1 (JJ/MM/AAAA - JJ/MM/AAAA)
      │   ├── Sprint 2 (JJ/MM/AAAA - JJ/MM/AAAA)
      │   └── Sprint 3 (JJ/MM/AAAA - JJ/MM/AAAA)
      └── Release 2
          ├── Sprint 4 (JJ/MM/AAAA - JJ/MM/AAAA)
          └── Sprint 5 (JJ/MM/AAAA - JJ/MM/AAAA)
  1. Configurer les équipes

    • Accédez à Paramètres du projet > Teams
    • Créez des équipes correspondant à vos besoins:
      • Team Frontend
      • Team Backend
      • Team Infrastructure
    • Associez chaque équipe aux zones et itérations appropriées

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

  1. Définir les Epics (grandes initiatives)

    • Accédez à Boards > Backlogs > Epics

    • Créez 3-4 epics représentant les grandes fonctionnalités de votre produit

    • Exemple:

      Epic 1: Authentification & Sécurité
      Epic 2: Gestion des commandes
      Epic 3: Tableau de bord utilisateur
      Epic 4: Intégration des paiements
  1. Créer les Features (fonctionnalités)

    • Accédez à Boards > Backlogs > Features

    • Créez des features rattachées à chaque epic

    • Exemple pour “Authentification & Sécurité”:

      Feature 1: Inscription utilisateur
      Feature 2: Connexion avec authentification à deux facteurs
      Feature 3: Gestion des rôles et permissions
      Feature 4: Réinitialisation de mot de passe
  1. Définir les User Stories / PBIs

    • Accédez à Boards > Backlogs > Stories / PBIs

    • Créez des stories détaillant les fonctionnalités

    • Utilisez le format: “En tant que [rôle], je veux [action] afin de [bénéfice]”

    • Exemple pour “Inscription utilisateur”:

      Story 1: En tant que nouvel utilisateur, je veux créer un compte avec mon email afin d'accéder à l'application
      Story 2: En tant que système, je veux valider le format de l'email afin d'assurer des données correctes
      Story 3: En tant qu'administrateur, je veux voir les nouveaux inscrits afin de surveiller la croissance
  1. Définir l’effort et la valeur métier

    • Pour chaque story, définissez:
      • Story Points (effort): utilisez la suite de Fibonacci (1, 2, 3, 5, 8, 13…)
      • Business Value: évaluez l’importance (ex: 1-10)
    • Utilisez la vue Planning Poker pour estimer en équipe

2.9.10 Étape 3 : Configuration du tableau Kanban

  1. Personnaliser les colonnes Kanban

    • Accédez à Boards > Boards

    • Cliquez sur l’icône d’engrenage (paramètres)

    • Configurez les colonnes suivantes:

      - Backlog (initial)
      - Analysed
      - In Progress (WIP limit: 3)
      - Code Review (WIP limit: 2)
      - Testing
      - Done (final)
  1. Configurer les couloirs (swimlanes)

    • Dans les paramètres du tableau, accédez à “Swimlanes”

    • Créez les couloirs suivants:

      - Expedite (pour les urgences)
      - Standard (par défaut)
      - Technical Debt
  2. Tester le déplacement des cartes

    • Déplacez quelques stories à travers les colonnes
    • Vérifiez que les limites WIP fonctionnent
    • Observez les changements automatiques d’état

2.9.12 Étape 4 : Planification de Sprint

  1. Prioriser le Backlog

    • Accédez à Boards > Backlogs
    • Réorganisez les items par drag & drop
    • Les items les plus importants doivent être en haut
  2. Planifier un Sprint

    • Cliquez sur “Sprint” en haut du backlog
    • Sélectionnez le Sprint en cours
    • Faites glisser les stories du backlog vers le sprint
    • Vérifiez la capacité de l’équipe vs. la somme des points
  1. Définir la capacité de l’équipe

    • Dans la vue Sprint, cliquez sur “Capacity”
    • Ajoutez les membres de l’équipe
    • Définissez les jours de congés et pourcentage d’allocation
    • Observez les graphiques de capacité
  2. Créer des tâches détaillées

    • Pour chaque User Story, créez 3-5 tâches techniques
    • Estimez chaque tâche en heures
    • Assurez-vous que chaque tâche est assignée

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

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

    • Créez une nouvelle branche dans Azure Repos
    • Utilisez la convention: type/ID-description-courte
    • Exemple: feature/1234-user-registration
  2. Lier les commits aux éléments de travail

    • Dans votre message de commit, référencez l’ID:
    git commit -m "Ajout du formulaire d'inscription #1234"
  1. Créer une Pull Request liée

    • Dans Azure Repos, créez une Pull Request
    • Dans la description, utilisez #ID ou AB#ID pour lier l’élément
  2. Observer le tableau des liens

    • Retournez dans Azure Boards
    • Ouvrez la story et vérifiez l’onglet “Development”
    • Constatez les liens automatiques avec les commits, branches et PRs

2.9.16 Étape 6 : Suivi et rapports

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

    • Accédez à Boards > Queries
    • Créez une nouvelle requête:
      • Type: “Flat list of work items”
      • Colonnes: ID, Title, State, AssignedTo, Tags
      • Critères: State = “In Progress” AND AssignedTo = @Me
  2. Configurer un dashboard

    • Accédez à Overview > Dashboards
    • Créez un nouveau dashboard “Sprint Status”
    • Ajoutez les widgets:
      • Burndown chart
      • Sprint Overview
      • Query Results (basé sur votre requête)
      • Velocity
  1. Analyser les métriques de cycle

    • Accédez à Analytics > Velocity
    • Observez la vélocité sur plusieurs sprints
    • Identifiez les tendances et opportunités d’amélioration
  2. Créer un rapport personnalisé

    • Accédez à Analytics > Analytics views
    • Créez une vue pour “Cycle Time”
    • Analysez le temps moyen entre les états

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.4 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.5 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)
    • Installation : git lfs install
    • Tracking de fichiers : git lfs track "*.psd"
    • Vérifier les patterns trackés : git lfs track
    • Commandes Git habituelles : git add, git commit, etc.
  1. 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.7 Bonnes pratiques pour les fichiers de configuration

  1. Gestion des secrets
    • Ne jamais stocker de secrets dans Git

    • Utiliser des variables d’environnement ou Azure Key Vault

    • Pour les configurations sensibles :

      # Créer un modèle de fichier de configuration sans secrets
      cp config.json config.template.json
      
      # Ajouter le vrai fichier de configuration au .gitignore
      echo "config.json" >> .gitignore
  1. Configurations spécifiques à l’environnement
    • Créer des dossiers ou fichiers par 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
  2. Documentation de la structure
    • Créer un README.md à la racine expliquant la structure
    • Ajouter des README.md dans les sous-dossiers importants

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.2.1 Git Flow

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

main (production)
   ↑
release branches
   ↑
develop
 ↗   ↖
feature  hotfix
branches branches
  • main : Reflète le code en production
  • develop : Intégration continue des fonctionnalités
  • feature/* : Développement de fonctionnalités
  • release/* : Préparation des releases
  • hotfix/* : Corrections urgentes en production

3.3.3.1 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)
  • main : Branche principale, toujours déployable
  • feature/* : Branches de courte durée (1-2 jours max)
  • Intégration fréquente dans main

3.3.4.1 GitHub Flow

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

main
 ↑
feature branches
  • main : Toujours déployable
  • feature/* : Branches pour nouvelles fonctionnalités et corrections
  • Déploiement après merge dans main

3.3.5 Configuration de politiques de branches dans Azure Repos

Pour sécuriser vos branches importantes :

  1. Accéder aux politiques de branches

    • Dans Azure DevOps : Repos > Branches > [sélectionner la branche] > Branch policies
  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é
  1. Exiger des builds réussies
    • Lier un pipeline de build existant
    • Définir comme obligatoire avant le merge
  2. Définir des validateurs de checklists
    • Créer une checklist de validation :

      - Le code est-il testé ?
      - La documentation est-elle à jour ?
      - Les exigences de sécurité sont-elles respectées ?
  3. Limiter les types de merge
    • Autoriser uniquement les squash merge pour garder l’historique propre

3.3.7 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.8 Résolution de conflits Git

  1. Prévenir les conflits

    • Intégrer fréquemment les modifications de la branche principale
    • Communiquer sur les fichiers en cours de modification
    • Structurer le code pour minimiser 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
  1. Outils de résolution de conflits
    • Visual Studio Code avec extension GitLens
    • Azure DevOps web interface
    • Git GUI tools (GitKraken, SourceTree)

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 :

  • Effectuer des revues de code avant intégration
  • Automatiser les validations de qualité
  • Documenter les changements apportés
  • Maintenir un historique des discussions techniques

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

  1. Créer une Pull Request
    • Depuis Azure Repos : Repos > Pull Requests > New Pull Request
    • Sélectionner la branche source et la branche cible
    • Ajouter un titre descriptif et une description détaillée
    • Lier les éléments de travail (work items) concernés
    • Assigner des reviewers
  1. 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]
  1. Gestion du processus de revue
    • Commenter des lignes spécifiques
    • Proposer des modifications
    • Résoudre les discussions
    • Approuver ou rejeter la PR
  2. Compléter une Pull Request
    • Vérifier que toutes les politiques sont respectées
    • Choisir le type de merge (merge commit, squash, rebase)
    • Activer/désactiver la suppression automatique de la branche source
    • Compléter la PR

3.4.5.1 Configuration des politiques de Pull Request

Pour renforcer la qualité et la standardisation :

  1. Accéder aux paramètres

    • Dans Azure DevOps : Repos > Branches > [sélectionner la branche] > Branch policies
  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é
  1. Ajouter des validations automatiques
    • Exiger une build réussie
    • Ajouter des validateurs de statut externes (SonarQube, etc.)
    • Configurer des règles de validation du code
  2. Configurer l’auto-complétion
    • Définir des déclencheurs pour compléter automatiquement
    • Paramétrer le comportement de merge préféré

3.4.7.1 Automatisation du processus de Pull Request

  1. Templates de Pull Request
    • Créer un dossier .azuredevops à la racine
    • Ajouter un fichier pull_request_template.md
  2. Intégration avec Azure Pipelines
    • Déclencher des builds à la création de PR
    • Afficher les résultats des tests et analyses
  3. Notifications personnalisées
    • Configurer des alertes pour les équipes
    • Intégrer avec Microsoft Teams ou Slack
  4. Analyse de code automatisée
    • Intégrer SonarCloud pour l’analyse de qualité
    • Configurer des vérifications de couverture de code

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.2.1 Types de hooks Git

  1. Hooks côté client
    • Exécutés sur la machine du développeur
    • Placés dans .git/hooks/ (non versionné)
    • Peuvent être contournés, donc ne pas utiliser pour des contrôles critiques
  2. Hooks côté serveur
    • Exécutés sur le serveur Git (Azure Repos)
    • Impossible à contourner par les développeurs
    • Parfaits pour les contrôles de gouvernance

3.5.3 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
  1. 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
  1. 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
  1. 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.7 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"
        }
      }
    }
  1. Stocker les hooks dans le dépôt
    • Créer un dossier hooks à la racine
    • Inclure un script d’installation
    #!/bin/bash
    # install-hooks.sh
    
    cp -r hooks/* .git/hooks/
    chmod +x .git/hooks/*

3.5.9 Hooks serveur avec Azure Repos

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

  1. Repository Policies
    • Similaires aux hooks pre-receive
    • Configuration : Repos > Branches > Branch policies
  2. Service Hooks
    • Réagir aux événements Git (push, PR)
    • Configuration : Project Settings > Service hooks
  3. Server-side validation via Azure Pipelines
    • Créer un pipeline de validation
    • L’associer comme build obligatoire dans les politiques de branche

3.5.10 Cas d’utilisation des hooks Git en entreprise

  1. Conformité et gouvernance
    • Validation des formats de message de commit
    • Vérification des règles de sécurité
    • Interdiction de pousser des secrets
  2. Qualité du code
    • Exécution automatique des tests
    • Analyses statiques du code
    • Vérification du formatage
  3. Intégration avec les processus d’entreprise
    • Mise à jour automatique des tickets
    • Notifications aux équipes concernées
    • Déclenchement des déploiements

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
    • Le code progresse à travers des branches dédiées à chaque environnement
    • Les merges sont effectués lorsque le code est prêt pour l’environnement suivant
  2. Promotion basée sur les tags

    main (avec tags pour les versions)
    • Une seule branche principale
    • Les versions sont marquées avec des tags (v1.2.3)
    • Les déploiements sont basés sur les tags
  1. Promotion basée sur les commits

    main (avec sélection de commits spécifiques)
    • Identifie les commits exacts à déployer
    • Utilise des SHA de commit spécifiques pour le déploiement
    • Fonctionne bien avec une approche Trunk-Based Development

3.6.4 Configuration du workflow de promotion dans Azure DevOps

  1. Branches protégées pour chaque environnement

    • Configurer des politiques strictes pour les branches principales
    • Restreindre les droits de push directs
  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
  1. Pipeline de release multi-étapes
    • Créer un pipeline YAML avec des étapes de promotion
    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.6 Gestion des versions et étiquetage

  1. Convention de versionnement sémantique

    • Format: MAJOR.MINOR.PATCH (ex: 2.4.1)
    • MAJOR: changements incompatibles
    • MINOR: ajouts de fonctionnalités compatibles
    • PATCH: corrections de bugs compatibles
  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
  1. Automatisation des versions avec GitVersion
    • Installer l’extension GitVersion Task dans Azure DevOps
    • Configurer GitVersion.yml à la racine du projet
    mode: ContinuousDelivery
    branches:
      main:
        tag: ''
      develop:
        tag: beta
      feature:
        tag: alpha
    • Utiliser dans le pipeline Azure
    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.8 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)
  1. Approbations pour les promotions
    • Configurer des approbations manuelles pour les environnements sensibles
    • Dans Azure DevOps : Pipelines > Environments > [Environment] > Approvals

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
    • Organisation : Contrôle global
    • Projet : Permissions sur tous les dépôts du projet
    • Dépôt : Permissions spécifiques à un dépôt
    • Branche : Permissions sur une branche particulière
  2. Configurer les groupes de sécurité
    • Dans Azure DevOps : Project Settings > Repositories > Security
    • Groupes communs :
      • Project Administrators : Contrôle total
      • Contributors : Push/Pull, création de branches
      • Readers : Lecture seule
      • Build Service : Accès CI/CD
  1. Permissions critiques à surveiller

    • Create branch : Qui peut créer des branches
    • Force push : À restreindre fortement
    • Manage permissions : Délégation de contrôle
    • Create tag : Contrôle des versions
  2. Exemple de configuration sécurisée

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

3.7.4 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

    • Utiliser Git LFS pour les binaires
    • Configurer correctement .gitignore
    • Éviter les fichiers générés ou de build
  1. 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.6 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

    • Marquer en lecture seule dans Azure DevOps
    • Créer une archive complète :
    git bundle create repo-archive.bundle --all
    • Documentation du contexte et des décisions
  1. 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.8 Bonnes pratiques de gestion des référentiels Git en entreprise

  1. Standardisation
    • Nommage cohérent des dépôts et branches
    • Structure de répertoires commune
    • Templates de PR et d’issues
  2. Documentation
    • README.md complet et à jour
    • Guide de contribution (CONTRIBUTING.md)
    • Documentation des processus Git dans un wiki
  1. Automatisation
    • Scripts de maintenance régulière
    • Vérifications automatiques de qualité
    • Intégration aux outils d’entreprise
  2. Audit et sécurité
    • Revues périodiques des permissions
    • Monitoring des activités suspectes
    • Scans de sécurité pour les secrets exposés

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 :

  • Configurer et utiliser Azure Repos avec Git
  • Comprendre les concepts fondamentaux du contrôle de version distribué
  • Appliquer les meilleures pratiques Git dans un contexte DevOps d’entreprise
  • Gérer efficacement les branches, les pull requests et les stratégies de branche
  • Intégrer Azure Repos avec les workflows CI/CD d’Azure DevOps

3.8.2 Prérequis

  • Un compte Azure DevOps actif
  • Git installé localement (version 2.25 ou ultérieure)
  • Visual Studio Code ou IDE préféré
  • Notions de base en développement logiciel
  • Connexion internet stable

3.8.3 Durée approximative

  • 3 heures

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 :
    • Nom : AZ400-Git-Workshop
    • Description : Atelier pour la certification AZ-400 - Contrôle de version avec Git
    • Visibilité : Privée
    • Contrôle de version : Git
  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.5.1 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.6.1 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.7 Partie 2 : Premiers pas avec Git dans Azure Repos

3.8.7.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.9.1 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.10.1 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.11 Partie 3 : Travail avec les branches

3.8.11.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.12.1 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 :
    • Branche source : feature/nouvelle-fonctionnalite
    • Branche cible : main
    • Titre : Ajout d'une nouvelle fonctionnalité
    • Description : Cette PR ajoute une nouvelle fonctionnalité à l'application principale.
  4. Assignez la PR à vous-même ou à un collègue
  5. Cliquez sur Créer

3.8.13.1 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.14.1 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.15 Partie 4 : Stratégies de branche et protection du code

3.8.15.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 :
    • Nombre minimal de réviseurs : 1
    • Autoriser les votants à approuver leurs propres modifications : Désactivé
    • Validation du build : Activé (si un pipeline est disponible)
    • Liens de travail requis : Activé
  4. Cliquez sur Enregistrer

3.8.16.1 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.18 Partie 5 : Résolution de conflits

3.8.18.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.20.1 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.22 Partie 6 : Intégration avec les workflows CI/CD

3.8.22.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 :
    • Sélectionnez Azure Repos Git comme source
    • Choisissez votre projet AZ400-Git-Workshop
    • Utilisez le modèle “Node.js” ou “Starter pipeline”
  1. 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.24.1 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.26 Partie 7 : Techniques Git avancées dans Azure Repos

3.8.26.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.27.1 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.29.1 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.30 Partie 8 : Audit et historique dans Azure Repos

3.8.30.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.31.1 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.32.1 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

  • Comprendre les fondamentaux de l’intégration continue (CI)
  • Configurer les pipelines Azure pour l’intégration continue
  • Exploiter GitHub Actions pour l’intégration continue
  • Implémenter des tests automatisés dans les pipelines CI
  • Gérer les artefacts et les dépendances
  • Mettre en œuvre des stratégies de branche et des politiques de validation
  • Mettre en pratique les bonnes pratiques de CI

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

  • Polyvalence : Fonctionne avec n’importe quel langage, plateforme ou cloud
  • Intégration native : S’intègre facilement avec Azure DevOps et d’autres services
  • Compatibilité multi-cloud : Déploiement sur AWS, GCP et autres
  • Extensibilité : Plus de 1000 extensions disponibles dans le marketplace
  • Sécurité : Contrôles d’accès avancés et gestion des secrets

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'

4.2.3.2 Classic Pipelines (Interface graphique)

  • Configuration via l’interface utilisateur d’Azure DevOps
  • Organisation en phases, jobs et tâches

4.2.4 Structure d’un pipeline YAML

  • Trigger : Définit quand le pipeline doit s’exécuter
  • Pool : Spécifie l’environnement d’exécution
  • Variables : Paramètres utilisables dans le pipeline
  • Stages : Principales divisions du pipeline (ex: Build, Test, Deploy)
  • Jobs : Unités de travail exécutées sur un agent
  • Steps : Actions individuelles à effectuer
  • Templates : Portions réutilisables de code 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
    • Machines virtuelles préconfigurées et gérées par Microsoft
    • Images disponibles : Windows, Linux, macOS
    • Reconstruites régulièrement avec les derniers outils
    • Limites de temps d’exécution (60 minutes par défaut)
  2. Agents auto-hébergés
    • Installés et gérés par votre organisation
    • Plus de contrôle sur l’environnement
    • Accès aux ressources internes du réseau
    • Possibilité d’utiliser du matériel spécifique

4.3.2 Pools d’agents

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

  • Pools par défaut : Azure Pipelines (agents Microsoft)
  • Pools personnalisés : Collections d’agents auto-hébergés

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

  • Caractéristiques ou fonctionnalités d’un agent
  • Découvertes automatiquement ou définies manuellement
  • Permettent de cibler des agents spécifiques dans vos pipelines
pool:
  name: MonPool
  demands:
    - docker
    - npm

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

4.4.1 Concepts de simultanéité

  • Parallélisme : Exécution simultanée de jobs ou tasks
  • Concurrence : Nombre d’exécutions de pipeline pouvant s’exécuter en même temps
  • Dépendances : Relations entre les jobs ou stages qui dictent l’ordre d’exécution

4.4.2 Limites de simultanéité

  • Par défaut, Azure Pipelines limite le nombre de jobs concurrents par organisation
  • Ces limites dépendent de votre abonnement Azure DevOps
  • Pour les agents Microsoft-hébergés, typiquement :
    • Plan gratuit : 1 job à la fois
    • Plan Microsoft-hébergé : 10-40 jobs selon le niveau

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

  • Détection précoce des problèmes
  • Réduction des conflits de fusion
  • Qualité de code améliorée
  • Feedback rapide pour les développeurs
  • Base solide pour le déploiement continu

4.5.3 Composants d’un processus CI efficace

  1. Contrôle de source
    • Gestion de code via Git (Azure Repos, GitHub, etc.)
    • Stratégies de branchement (GitFlow, Trunk-based, etc.)
  2. Build automatisé
    • Compilation du code source
    • Exécution des tests unitaires
    • Analyse de code statique
  3. Tests automatisés
    • Tests unitaires
    • Tests d’intégration
    • Tests fonctionnels
  4. Artefacts
    • Publication des composants construits
    • Versionning des artefacts
    • Stockage dans des référentiels d’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
    • Branches principales : main, develop
    • Branches de support : feature/, release/, hotfix/*
    • Bien adapté aux cycles de release formels
  2. Trunk-Based Development
    • Une branche principale (trunk/main)
    • Intégrations fréquentes
    • Feature flags pour gérer les fonctionnalités en développement
  3. GitHub Flow
    • Une branche principale (main)
    • Branches de fonctionnalités directement mergées dans main
    • Adapté pour le déploiement continu

4.6.2 Qualité de code

  • Pull Requests : Revue de code avant intégration
  • Politiques de branche : Critères d’acceptation avant merge
  • Tests automatisés : Validation du comportement attendu
  • Analyse statique : Détection de problèmes potentiels

4.6.3 Stratégies de test

  1. Pyramide de tests
    • Base : tests unitaires (nombreux, rapides)
    • Milieu : tests d’intégration
    • Sommet : tests d’interface/end-to-end (peu nombreux, lents)
  2. Tests de non-régression
    • Vérification des fonctionnalités existantes
  3. Tests de performance
    • Validation des temps de réponse et capacité

4.6.4 Gestion des environnements

  • Dev → Test → Staging → Production
  • Approbations pour les environnements critiques
  • Infrastructure as Code pour la consistance

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
    • Déploiement web direct
    • Slots de déploiement pour transition sans interruption
  2. Azure Functions
    • Serverless compute
    • Intégration CI/CD native
  3. Azure Kubernetes Service (AKS)
    • Orchestration de conteneurs
    • Déploiement via Helm ou manifestes K8s
  4. Azure SQL Database
    • Migrations de schéma
    • Gestion des données

4.7.2 Intégration avec des outils tiers

  1. SonarQube/SonarCloud
    • Analyse de qualité de code
    • Détection de dette technique
  2. JFrog Artifactory
    • Gestion d’artefacts
    • Dépôts de paquets
  3. Selenium
    • Tests d’interface utilisateur automatisés
  4. Docker/Container Registry
    • Construction et publication d’images

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
    • Définies dans le YAML ou l’interface
    • Valeurs partagées entre étapes
  2. Variables d’environnement
    • Spécifiques à un environnement
    • Facilitent la configuration par environnement
  1. Azure Key Vault
    • Stockage sécurisé pour secrets
    • Intégration native avec Azure Pipelines
# 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
    • Fichiers YAML (.github/workflows/*.yml)
    • Déclenchés par événements GitHub
  2. Events
    • Déclencheurs comme push, pull request, schedule
  3. Jobs
    • Ensembles de steps exécutés sur un runner
  4. Steps
    • Actions individuelles ou commandes shell
  5. Actions
    • Unités réutilisables de code
    • Marketplace public d’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
    • Windows, Ubuntu, macOS
    • Environnements préinstallés
    • Minutes gratuites limitées selon le plan
  2. Runners auto-hébergés
    • Exécutés sur votre propre infrastructure
    • Accès à des ressources internes
    • Configuration personnalisée

4.8.5 Sécurité dans GitHub Actions

  • Secrets : Variables cryptées pour informations sensibles
  • GITHUB_TOKEN : Authentification automatique pour accéder au dépôt
  • Autorisations : Contrôle précis des capacités du token

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

  • Configurer un pool d’agents auto-hébergé dans Azure DevOps
  • Comprendre les différences entre les pipelines YAML et Classic
  • Maîtriser les concepts de capacités et demandes d’agent
  • Identifier les scénarios appropriés pour chaque type de pipeline

4.10.3 Prérequis

  • Accès à une organisation Azure DevOps
  • Machine virtuelle Windows, Linux ou macOS pour héberger l’agent
  • Permissions suffisantes dans Azure DevOps pour créer des pools d’agents

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
    • Connectez-vous à votre organisation Azure DevOps
    • Accédez au projet où vous souhaitez configurer le pool d’agents
  2. Création du pool d’agents
    • Naviguez vers Project Settings > Pipelines > Agent pools
    • Cliquez sur “Add pool”
    • Sélectionnez “Self-hosted” comme type de pool
    • Nommez votre pool (ex: “WorkshopPool”)
    • Cliquez sur “Create”
  3. Préparation de la machine pour l’agent
    • Assurez-vous que la machine respecte les prérequis système
    • Pour Windows: PowerShell 3.0 ou supérieur, .NET Framework 4.6.2 ou supérieur
    • Pour Linux: GLIBC 2.17 ou supérieur, Curl, tar, git

4.10.5.1 Partie 2 : Installation et configuration de l’agent

  1. Téléchargement de l’agent
    • Dans le pool d’agents nouvellement créé, cliquez sur “New agent”
    • Sélectionnez le système d’exploitation de votre machine (Windows/Linux/macOS)
    • Téléchargez le package de l’agent sur votre machine
  1. Installation de l’agent (Windows)
    • Extrayez le package ZIP dans un dossier (ex: C:\agents\agent1)

    • Ouvrez PowerShell en tant qu’administrateur dans ce dossier

    • Exécutez la commande de configuration:

      .\config.cmd --url https://dev.azure.com/votreorganisation --auth pat --token votrePersonalAccessToken --pool WorkshopPool --agent AgentName1 --replace
    • Suivez les instructions pour compléter la configuration

    • Installez l’agent comme service:

      .\config.cmd --service install
      .\config.cmd --service start
  1. Installation de l’agent (Linux)
    • Extrayez le package dans un dossier: mkdir ~/agent && cd ~/agent && tar zxvf ~/Downloads/vsts-agent-linux-x64-VERSION.tar.gz

    • Exécutez la configuration:

      ./config.sh --url https://dev.azure.com/votreorganisation --auth pat --token votrePersonalAccessToken --pool WorkshopPool --agent AgentName1 --replace
    • Installez et démarrez comme service:

      sudo ./svc.sh install
      sudo ./svc.sh start
  2. Vérification de l’installation
    • Retournez dans Azure DevOps > Agent pools > WorkshopPool
    • Vérifiez que votre agent apparaît comme “Online”

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

  1. Ajout de capacités à l’agent
    • Dans le pool d’agents, localisez votre agent
    • Allez dans l’onglet “Capabilities”
    • Ajoutez des capacités personnalisées:
      • Cliquez sur “Add capability”
      • Ajoutez CustomTool comme nom et Workshop comme valeur
      • Ajoutez Environment comme nom et Training comme valeur
    • Cliquez sur “Save”
  2. Examinez les capacités détectées automatiquement
    • Observez les capacités découvertes automatiquement (OS, outils installés, etc.)
    • Notez comment ces capacités peuvent être utilisées dans les pipelines

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

  1. Création d’un dépôt de code simple
    • Créez un nouveau référentiel dans Azure Repos ou utilisez un existant
    • Ajoutez un fichier index.html simple
  1. Création du pipeline YAML
    • Dans votre projet Azure DevOps, naviguez vers Pipelines > Pipelines
    • Cliquez sur “New pipeline”
    • Sélectionnez votre référentiel source
    • Choisissez “Starter pipeline” comme modèle
- Modifiez le YAML pour cibler votre agent auto-hébergé:
  ```yaml
  trigger:
  - main

  pool:
    name: WorkshopPool
    demands:
      - CustomTool -equals Workshop
      - Environment -equals Training

  steps:
  - script: echo Bonjour depuis l'agent $(Agent.Name)
    displayName: 'Echo agent info'

  - script: |
      echo Liste des capacités de l'agent:
      echo OS: $(Agent.OS)
      echo Directory: $(Agent.HomeDirectory)
    displayName: 'Liste des capacités'

  - script: |
      echo Contenu du répertoire de travail:
      dir
    displayName: 'Liste des fichiers'
    condition: eq(variables['Agent.OS'], 'Windows_NT')

  - script: |
      echo Contenu du répertoire de travail:
      ls -la
    displayName: 'Liste des fichiers'
    condition: ne(variables['Agent.OS'], 'Windows_NT')
  ```
- Cliquez sur "Save and run"
- Observez l'exécution du pipeline sur votre agent auto-hébergé

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

  1. Création du pipeline Classic

    • Dans Pipelines > Pipelines, cliquez sur “New pipeline”
    • Choisissez “Use the classic editor”
    • Sélectionnez votre référentiel source
    • Choisissez “Empty job” comme modèle
    • Configurez l’agent:
      • Sélectionnez votre pool d’agents “WorkshopPool”
      • Dans “Demands”, ajoutez vos contraintes personnalisées:
        • CustomTool = Workshop
        • Environment = Training
  • Ajoutez trois tâches “Command line”: - Tâche 1: - Display name: “Echo agent info” - Script: echo Bonjour depuis l'agent $(Agent.Name) - Tâche 2: - Display name: “Liste des capacités” - Script: echo Liste des capacités de l'agent: echo OS: $(Agent.OS) echo Directory: $(Agent.HomeDirectory) - Tâche 3: - Display name: “Liste des fichiers” - Script pour Windows: dir - Script pour Linux/macOS: ls -la - Control options > Run this task: Custom condition - Condition pour Windows: eq(variables['Agent.OS'], 'Windows_NT') - Créez une tâche similaire pour Linux avec condition inverse
    • Sauvegardez et exécutez le pipeline

4.10.14.1 Partie 6 : Comparaison et analyse

  1. Comparaison des approches
    • Comparez les résultats d’exécution des deux pipelines
    • Analysez les logs générés
    • Notez les différences et similitudes dans la configuration
  2. Analyse des scénarios d’utilisation
    • Discutez des cas d’utilisation appropriés pour:
      • Les agents Microsoft-hébergés vs auto-hébergés
      • Les pipelines YAML vs Classic
    • Considérez les facteurs tels que:
      • Besoins d’accès au réseau interne
      • Exigences de personnalisation
      • Gestion du code dans le référentiel (GitOps)

4.10.15 Livrables

  • Agent auto-hébergé fonctionnel dans Azure DevOps
  • Pipeline YAML configuré pour utiliser l’agent auto-hébergé
  • Pipeline Classic équivalent
  • Document de comparaison des deux approches de pipeline

4.10.16 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

  • Mettre en place un pipeline CI complet pour une application web
  • Configurer des tests automatisés avec publication de résultats
  • Implémenter l’analyse de couverture de code
  • Comprendre les stratégies de déclenchement de builds

4.11.3 Prérequis

  • Accès à une organisation Azure DevOps
  • Connaissances de base en développement web (.NET Core ou Node.js)
  • Git installé sur votre poste de travail

4.11.4 Étapes détaillées

4.11.4.1 Partie 1 : Préparation du projet

  1. Création du dépôt
    • Dans Azure DevOps, naviguez vers Repos > Files
    • Cliquez sur “Initialize repository” s’il est vide
    • Ou créez un nouveau dépôt si nécessaire
  1. Création d’une application web simple
    • Clonez le dépôt sur votre poste local: git clone [url-du-depot]

    • Pour .NET Core:

      dotnet new webapi -o WebApiSample
      cd WebApiSample
      dotnet new xunit -o WebApiSample.Tests
    • Ou pour Node.js:

      mkdir node-sample
      cd node-sample
      npm init -y
      npm install express --save
      npm install jest supertest --save-dev
  • Créez quelques fichiers de base:
    • Pour .NET Core: un contrôleur API simple et un test unitaire
    • Pour Node.js: un serveur Express simple et un test Jest
  1. Configuration des tests
    • Pour .NET Core, créez un test simple dans WebApiSample.Tests:

      using Xunit;
      using WebApiSample.Controllers;
      
      public class WeatherForecastControllerTests
      {
          [Fact]
          public void Get_ReturnsData()
          {
              // Arrange
              var controller = new WeatherForecastController();
      
              // Act
              var result = controller.Get();
      
              // Assert
              Assert.NotNull(result);
              Assert.NotEmpty(result);
          }
      }
  • Pour Node.js, créez un test Jest:

    const request = require('supertest');
    const app = require('./app');
    
    test('GET / responds with Hello World', async () => {
      const response = await request(app).get('/');
      expect(response.status).toBe(200);
      expect(response.text).toContain('Hello World');
    });
  1. Commit et push du code

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

4.11.10.1 Partie 2 : Configuration du pipeline CI

  1. Création du pipeline YAML

    • Dans Azure DevOps, naviguez vers Pipelines > Pipelines
    • Cliquez sur “New pipeline”
    • Sélectionnez votre référentiel source
    • Pour .NET Core, choisissez le modèle “ASP.NET Core” ou “Starter pipeline”
    • Pour Node.js, choisissez le modèle “Node.js” ou “Starter pipeline”
  1. Configuration du pipeline pour .NET Core

    • Modifiez le YAML comme suit:

      trigger:
        branches:
          include:
          - main
          - feature/*
        paths:
          include:
          - WebApiSample/**
          exclude:
          - '*.md'
      
      pool:
        vmImage: 'ubuntu-latest'
      
      variables:
        buildConfiguration: 'Release'
        projectPath: 'WebApiSample'
        testProjectPath: 'WebApiSample.Tests'
      
      steps:
      - task: DotNetCoreCLI@2
        displayName: 'Restore packages'
        inputs:
          command: 'restore'
          projects: '$(projectPath)/**/*.csproj'
      
      - task: DotNetCoreCLI@2
        displayName: 'Build solution'
        inputs:
          command: 'build'
          projects: '$(projectPath)/**/*.csproj'
          arguments: '--configuration $(buildConfiguration)'
      
      - task: DotNetCoreCLI@2
        displayName: 'Run tests'
        inputs:
          command: 'test'
          projects: '$(testProjectPath)/**/*.csproj'
          arguments: '--configuration $(buildConfiguration) --collect:"XPlat Code Coverage"'
          publishTestResults: true
      
      - task: PublishCodeCoverageResults@1
        displayName: 'Publish code coverage report'
        inputs:
          codeCoverageTool: 'Cobertura'
          summaryFileLocation: '$(Agent.TempDirectory)/**/coverage.cobertura.xml'
      
      - task: DotNetCoreCLI@2
        displayName: 'Publish website'
        inputs:
          command: 'publish'
          publishWebProjects: true
          arguments: '--configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)'
          zipAfterPublish: true
      
      - task: PublishBuildArtifacts@1
        displayName: 'Publish artifacts'
        inputs:
          PathtoPublish: '$(Build.ArtifactStagingDirectory)'
          ArtifactName: 'webapp'
  1. Configuration du pipeline pour Node.js

    • Modifiez le YAML comme suit:

      trigger:
        branches:
          include:
          - main
          - feature/*
        paths:
          include:
          - node-sample/**
          exclude:
          - '*.md'
      
      pool:
        vmImage: 'ubuntu-latest'
      
      steps:
      - task: NodeTool@0
        inputs:
          versionSpec: '16.x'
        displayName: 'Install Node.js'
      
      - script: |
          cd node-sample
          npm install
        displayName: 'npm install'
      
      - script: |
          cd node-sample
          npm test
        displayName: 'Run tests'
      
      - script: |
          cd node-sample
          npm test -- --coverage
        displayName: 'Run tests with coverage'
      
      - task: PublishTestResults@2
        inputs:
          testResultsFormat: 'JUnit'
          testResultsFiles: '**/junit.xml'
          searchFolder: '$(System.DefaultWorkingDirectory)/node-sample'
          mergeTestResults: true
          testRunTitle: 'Node.js Tests'
        condition: succeededOrFailed()
        displayName: 'Publish test results'
      
      - task: PublishCodeCoverageResults@1
        inputs:
          codeCoverageTool: 'Cobertura'
          summaryFileLocation: '$(System.DefaultWorkingDirectory)/node-sample/coverage/cobertura-coverage.xml'
          reportDirectory: '$(System.DefaultWorkingDirectory)/node-sample/coverage'
        displayName: 'Publish code coverage'
      
      - task: ArchiveFiles@2
        inputs:
          rootFolderOrFile: '$(System.DefaultWorkingDirectory)/node-sample'
          includeRootFolder: false
          archiveType: 'zip'
          archiveFile: '$(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip'
          replaceExistingArchive: true
        displayName: 'Archive files'
      
      - task: PublishBuildArtifacts@1
        inputs:
          PathtoPublish: '$(Build.ArtifactStagingDirectory)'
          ArtifactName: 'node-app'
          publishLocation: 'Container'
        displayName: 'Publish artifacts'
  1. Sauvegarde et exécution du pipeline

    • Cliquez sur “Save and run”
    • Observez l’exécution du pipeline
    • Vérifiez que les tests sont exécutés et que les résultats sont publiés

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

  1. Ajout de déclencheurs pour Pull Requests

    • Modifiez la section trigger dans votre YAML:

      trigger:
        branches:
          include:
          - main
          - feature/*
        paths:
          include:
          - WebApiSample/** # ou node-sample/**
          exclude:
          - '*.md'
      
      pr:
        branches:
          include:
          - main
        paths:
          include:
          - WebApiSample/** # ou node-sample/**
          exclude:
          - '*.md'
  1. Test des déclencheurs

    • Créez une nouvelle branche: git checkout -b feature/nouvelle-fonctionnalite

    • Ajoutez un fichier ou modifiez du code existant

    • Committez et poussez:

      git add .
      git commit -m "Ajout d'une nouvelle fonctionnalité"
      git push --set-upstream origin feature/nouvelle-fonctionnalite
    • Dans Azure DevOps, créez une Pull Request vers la branche main

    • Vérifiez que le pipeline se déclenche automatiquement

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

  1. Amélioration de la couverture de code

    • Ajoutez d’autres tests pour augmenter la couverture
    • Pour .NET Core, ajoutez des tests supplémentaires pour couvrir différentes conditions
    • Pour Node.js, assurez-vous que Jest est configuré pour la couverture
  1. Ajout d’un badge de build au README

    • Créez un fichier README.md à la racine du projet

    • Dans Azure DevOps, naviguez vers votre pipeline

    • Cliquez sur les “…” et sélectionnez “Status badge”

    • Copiez le markdown du badge

    • Ajoutez-le à votre README.md:

      # Projet Demo CI/CD
      
      [![Build Status](https://dev.azure.com/votre-org/votre-projet/_apis/build/status/votre-pipeline?branchName=main)](https://dev.azure.com/votre-org/votre-projet/_build/latest?definitionId=X&branchName=main)
      
      Cette application démontre l'intégration continue avec Azure Pipelines.
    • Committez et poussez le README

  1. Configuration des politiques de branche

    • Dans Azure DevOps, allez dans Repos > Branches
    • Cliquez sur “…” à côté de la branche main
    • Sélectionnez “Branch policies”
    • Activez “Require a minimum number of reviewers”
    • Ajoutez votre pipeline dans “Build validation”
    • Sauvegardez les politiques

4.11.19 Livrables

  • Application web avec tests unitaires
  • Pipeline CI fonctionnel avec déclencheurs configurés
  • Rapports de test et de couverture de code
  • README avec badge de build
  • Pull Request démontrant le déclenchement automatique du pipeline

4.11.20 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

  • Connecter Azure Pipelines à un dépôt GitHub externe
  • Configurer des connexions de service sécurisées
  • Utiliser des variables et secrets dans les pipelines
  • Mettre en place une intégration continue entre GitHub et Azure DevOps

4.12.3 Prérequis

  • Compte GitHub
  • Accès à une organisation Azure DevOps
  • Connaissance de base de Git et des pipelines YAML

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
    • Connectez-vous à votre compte GitHub
    • Créez un nouveau dépôt (ex: “azure-pipelines-demo”)
    • Initialisez-le avec un README.md
  1. Ajout d’une application simple
    • Clonez le dépôt sur votre machine locale
    • Créez une application web simple
      • Pour Node.js:

        git clone https://github.com/votre-compte/azure-pipelines-demo
        cd azure-pipelines-demo
        npm init -y
        npm install express --save
      • Créez un fichier app.js avec un serveur Express basique

      • Créez un fichier azure-pipelines.yml à la racine (vide pour l’instant)

  1. Commit et push du code initial

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

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

  1. Création d’une connexion de service GitHub
    • Dans Azure DevOps, naviguez vers Project Settings > Service connections
    • Cliquez sur “New service connection”
    • Sélectionnez “GitHub”
    • Choisissez “GitHub App” comme méthode d’authentification
    • Cliquez sur “Authorize” pour permettre à Azure DevOps d’accéder à GitHub
    • Sélectionnez votre compte GitHub et autorisez l’accès
    • Nommez la connexion (ex: “GitHub-Connection”)
    • Cliquez sur “Save”
  1. Vérification des autorisations
    • Dans GitHub, allez dans Settings > Applications
    • Vérifiez que “Azure Pipelines” est autorisé
    • Examinez les permissions accordées

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

  1. Création du pipeline dans Azure DevOps
    • Naviguez vers Pipelines > Pipelines
    • Cliquez sur “New pipeline”
    • Sélectionnez “GitHub” comme source de code
    • Autorisez Azure DevOps à accéder à GitHub si demandé
    • Sélectionnez votre dépôt “azure-pipelines-demo”
    • Choisissez “Node.js” comme modèle de départ
  1. Configuration du fichier YAML
    • Azure DevOps va générer un pipeline YAML de base pour Node.js

    • Modifiez le pipeline comme suit:

      trigger:
        branches:
          include:
          - main
        paths:
          include:
          - '**'
          exclude:
          - '*.md'
      
      pool:
        vmImage: 'ubuntu-latest'
      
      variables:
        # Déclaration de variables non-secrètes
        nodeVersion: '16.x'
        # Les secrets seront ajoutés via le vault
      
      steps:
      - task: NodeTool@0
        inputs:
          versionSpec: '$(nodeVersion)'
        displayName: 'Install Node.js'
      
      - script: |
          npm install
        displayName: 'npm install'
      
      - script: |
          npm test
        displayName: 'Run tests'
        continueOnError: true  # Continuer même si les tests échouent (pour l'atelier)
      
      - script: |
          echo "Application name: $(applicationName)"
          echo "Environment: $(environment)"
        displayName: 'Echo variables'
        # Les variables applicationName et environment seront définies plus tard
    • Cliquez sur “Save and run”

    • Choisissez de valider directement dans la branche main

    • Le pipeline échouera car les variables ne sont pas encore définies, c’est normal

4.12.11.1 Partie 4 : Configuration des variables et secrets

  1. Création de variables de pipeline
    • Dans Azure DevOps, naviguez vers votre pipeline
    • Cliquez sur “Edit”
    • Cliquez sur les “…” en haut à droite et sélectionnez “Variables”
    • Ajoutez deux variables:
      • Nom: applicationName, Valeur: AzureWorkshopApp, Maintenir secret: Non
      • Nom: environment, Valeur: Development, Maintenir secret: Non
    • Cliquez sur “Save”
  1. Configuration d’Azure Key Vault pour les secrets
    • Dans Azure Portal, créez un nouveau Key Vault ou utilisez un existant
    • Ajoutez deux secrets:
      • dbConnectionString avec une valeur fictive
      • apiKey avec une valeur fictive
  2. Création d’une connexion de service à Azure
    • Dans Azure DevOps, Project Settings > Service connections
    • Cliquez sur “New service connection”
    • Sélectionnez “Azure Resource Manager”
    • Choisissez “Service principal (automatic)”
    • Sélectionnez votre abonnement Azure
    • Nommez la connexion (ex: “Azure-Workshop-Connection”)
    • Cliquez sur “Save”
  1. Mise à jour du pipeline pour utiliser Key Vault
    • Modifiez votre pipeline YAML pour ajouter l’accès à Key Vault:

      trigger:
        branches:
          include:
          - main
        paths:
          include:
          - '**'
          exclude:
          - '*.md'
      
      pool:
        vmImage: 'ubuntu-latest'
      
      variables:
        nodeVersion: '16.x'
      
      steps:
      - task: NodeTool@0
        inputs:
          versionSpec: '$(nodeVersion)'
        displayName: 'Install Node.js'
      
      - task: AzureKeyVault@2
        inputs:
          azureSubscription: 'Azure-Workshop-Connection'
          KeyVaultName: 'votre-key-vault-name'
          SecretsFilter: 'dbConnectionString,apiKey'
          RunAsPreJob: true
        displayName: 'Get secrets from Azure Key Vault'
      
      - script: |
          npm install
        displayName: 'npm install'
      
      - script: |
          npm test
        displayName: 'Run tests'
        continueOnError: true
      
      - script: |
          echo "Application name: $(applicationName)"
          echo "Environment: $(environment)"
          echo "Using connection string: $(dbConnectionString)"
          echo "API Key length: $(apiKey)"
        displayName: 'Echo variables'
    • Committez les changements au fichier YAML (Azure DevOps le fera pour vous si vous utilisez l’éditeur)

  1. Test du pipeline avec variables et secrets
    • Exécutez le pipeline
    • Vérifiez les logs pour confirmer que les variables sont correctement utilisées
    • Notez que les secrets de Key Vault sont masqués dans les logs

4.12.15.1 Partie 5 : Configuration des webhooks et déclencheurs

  1. Inspection des webhooks GitHub
    • Dans votre dépôt GitHub, allez dans Settings > Webhooks
    • Observez le webhook créé automatiquement par Azure Pipelines
    • Examinez les événements qui déclenchent le webhook
  2. Test des déclencheurs par push
    • Modifiez un fichier dans votre dépôt GitHub (via l’interface web ou localement)
    • Pushez les modifications
    • Observez le déclenchement automatique du pipeline dans Azure DevOps
  1. Configuration des pull requests
    • Modifiez votre pipeline pour ajouter des déclencheurs de pull request:

      trigger:
        branches:
          include:
          - main
        paths:
          include:
          - '**'
          exclude:
          - '*.md'
      
      pr:
        branches:
          include:
          - main
    • Créez une nouvelle branche et une pull request dans GitHub

    • Vérifiez que le pipeline se déclenche lors de la création de la PR

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

  1. Test complet d’intégration
    • Créez une nouvelle branche dans votre dépôt GitHub: git checkout -b feature/test-integration
    • Modifiez ou ajoutez un fichier dans le projet
    • Committez et pushez les modifications
    • Créez une Pull Request vers la branche main
    • Observez le déclenchement automatique du pipeline
    • Vérifiez que le status check est requis avant de pouvoir fusionner la PR
    • Une fois le pipeline réussi, fusionnez la PR
    • Observez le déclenchement d’un nouveau build sur la branche main

4.12.18.1 Partie 7 : Personnalisation et optimisation

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

    • Dans Azure DevOps, accédez à votre pipeline
    • Cliquez sur “…” et sélectionnez “Status badge”
    • Copiez le markdown généré
    • Modifiez le README.md dans votre dépôt GitHub pour y ajouter le badge
    • Committez et pushez les modifications
  1. Configuration du cache pour les dépendances

    • Modifiez votre pipeline pour ajouter la mise en cache des modules npm:

      steps:
      - task: NodeTool@0
        inputs:
          versionSpec: '$(nodeVersion)'
        displayName: 'Install Node.js'
      
      - task: AzureKeyVault@2
        inputs:
          azureSubscription: 'Azure-Workshop-Connection'
          KeyVaultName: 'votre-key-vault-name'
          SecretsFilter: 'dbConnectionString,apiKey'
          RunAsPreJob: true
        displayName: 'Get secrets from Azure Key Vault'
      
      - task: Cache@2
        inputs:
          key: 'npm | "$(Agent.OS)" | package-lock.json'
          restoreKeys: |
            npm | "$(Agent.OS)"
          path: '$(npm.config.cache)'
        displayName: 'Cache npm modules'
      
      - script: |
          npm install
        displayName: 'npm install'
      
      # ... reste du pipeline
    • Exécutez le pipeline deux fois consécutives

    • Vérifiez que la deuxième exécution utilise le cache

4.12.20 Livrables

  • Dépôt GitHub connecté à Azure Pipelines
  • Pipeline CI fonctionnel qui s’exécute automatiquement sur les pushes et PRs
  • Variables et secrets correctement configurés et utilisés
  • Status checks GitHub qui protègent la branche main
  • Badge de statut dans le README
  • Optimisation des performances avec cache

4.12.21 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

  • Configurer un workflow GitHub Actions complet pour CI/CD
  • Utiliser des matrices pour tester sur plusieurs environnements
  • Mettre en place le cache pour optimiser les performances
  • Implémenter un processus de déploiement conditionnel
  • Utiliser les secrets GitHub pour les informations sensibles

4.13.3 Prérequis

  • Compte GitHub
  • Connaissances de base en Git et YAML
  • Notions de développement Web (.NET Core ou Node.js ou Python)

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
    • Connectez-vous à votre compte GitHub
    • Créez un nouveau dépôt (ex: “github-actions-workshop”)
    • Initialisez-le avec un README.md
    • Ajoutez un .gitignore pour le langage que vous allez utiliser (Node.js, Python ou .NET)
  1. Clonage du dépôt et création d’une application web simple

    • Clonez le dépôt sur votre machine locale

    • Pour Node.js:

      git clone https://github.com/votre-compte/github-actions-workshop
      cd github-actions-workshop
      npm init -y
      npm install express --save
      npm install jest supertest --save-dev
  • Créez un fichier app.js avec un serveur Express de base:

    const express = require('express');
    const app = express();
    
    app.get('/', (req, res) => {
      res.send('Hello, GitHub Actions!');
    });
    
    app.get('/api/status', (req, res) => {
      res.json({ status: 'ok', version: '1.0.0' });
    });
    
    const port = process.env.PORT || 3000;
    
    if (require.main === module) {
      app.listen(port, () => {
        console.log(`Server running on port ${port}`);
      });
    }
    
    module.exports = app;
  • Créez un fichier de test app.test.js:

    const request = require('supertest');
    const app = require('./app');
    
    test('GET / responds with Hello message', async () => {
      const response = await request(app).get('/');
      expect(response.status).toBe(200);
      expect(response.text).toContain('Hello, GitHub Actions');
    });
    
    test('GET /api/status returns correct status', async () => {
      const response = await request(app).get('/api/status');
      expect(response.status).toBe(200);
      expect(response.body).toHaveProperty('status', 'ok');
    });
  • Mettez à jour package.json pour ajouter des scripts:
     "scripts": {
       "start": "node app.js",
       "test": "jest",
       "test:coverage": "jest --coverage"
     }
  1. Commit et push du code initial

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

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

  1. Création du répertoire de workflows
    • Créez un répertoire .github/workflows à la racine de votre projet:

      mkdir -p .github/workflows
  1. Création d’un workflow CI basique
    • Créez un fichier .github/workflows/ci.yml:

      name: Node.js CI
      
      on:
        push:
          branches: [ main ]
        pull_request:
          branches: [ main ]
      
      jobs:
        build:
          runs-on: ubuntu-latest
      
          steps:
          - uses: actions/checkout@v3
      
          - name: Use Node.js 16.x
            uses: actions/setup-node@v3
            with:
              node-version: 16.x
              cache: 'npm'
      
          - name: Install dependencies
            run: npm ci
      
          - name: Run tests
            run: npm test
      
          - name: Check code style
            run: |
              echo "Checking code style (simulated)"
              # Ici, vous pourriez utiliser ESLint, Prettier, etc.
  1. 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
    • Dans GitHub, accédez à votre dépôt
    • Allez dans l’onglet “Actions”
    • Vérifiez que votre workflow s’est exécuté correctement
    • Examinez les logs d’exécution

4.13.12.1 Partie 3 : Configuration d’une matrice de tests

  1. Mise à jour du workflow pour utiliser une matrice
    • Modifiez le fichier .github/workflows/ci.yml:

      name: Node.js CI
      
      on:
        push:
          branches: [ main ]
        pull_request:
          branches: [ main ]
      
      jobs:
        test:
          runs-on: ${{ matrix.os }}
      
          strategy:
            matrix:
              os: [ubuntu-latest, windows-latest]
              node-version: [14.x, 16.x, 18.x]
              # Exclure certaines combinaisons si nécessaire
              exclude:
                - os: windows-latest
                  node-version: 14.x
      
          steps:
          - uses: actions/checkout@v3
      
          - name: Use Node.js ${{ matrix.node-version }}
            uses: actions/setup-node@v3
            with:
              node-version: ${{ matrix.node-version }}
              cache: 'npm'
      
          - name: Install dependencies
            run: npm ci
      
          - name: Run tests
            run: npm test
      
          - name: Generate test coverage
            run: npm run test:coverage
  1. 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
    • Dans GitHub, accédez à l’onglet “Actions”
    • Observez comment plusieurs jobs sont exécutés pour chaque combinaison d’OS et de version Node.js
    • Examinez les résultats pour chaque combinaison

4.13.14.1 Partie 4 : Configuration du cache et optimisation

  1. Amélioration du cache pour les dépendances
    • Modifiez le workflow pour optimiser le cache:

      - name: Use Node.js ${{ matrix.node-version }}
        uses: actions/setup-node@v3
        with:
          node-version: ${{ matrix.node-version }}
          cache: 'npm'
      
      # Alternative plus détaillée si vous préférez:
      - name: Cache node modules
        uses: actions/cache@v3
        with:
          path: ~/.npm
          key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
          restore-keys: |
            ${{ runner.os }}-node-
  1. Ajout d’étapes de publication d’artefacts
    • Ajoutez les étapes suivantes à votre workflow:

      - name: Archive production artifacts
        if: success() && matrix.os == 'ubuntu-latest' && matrix.node-version == '16.x'
        uses: actions/upload-artifact@v3
        with:
          name: node-app
          path: |
            .
            !node_modules/
            !.git/
      
      - name: Archive code coverage results
        if: success() && matrix.os == 'ubuntu-latest' && matrix.node-version == '16.x'
        uses: actions/upload-artifact@v3
        with:
          name: code-coverage-report
          path: coverage/
  1. Ajout d’un job de build séparé
    • Restructurez le workflow pour séparer les tests et le build:

      name: Node.js CI/CD
      
      on:
        push:
          branches: [ main ]
        pull_request:
          branches: [ main ]
      
      jobs:
        test:
          runs-on: ${{ matrix.os }}
      
          strategy:
            matrix:
              os: [ubuntu-latest, windows-latest]
              node-version: [14.x, 16.x, 18.x]
              exclude:
                - os: windows-latest
                  node-version: 14.x
      
          steps:
          - uses: actions/checkout@v3
      
          - name: Use Node.js ${{ matrix.node-version }}
            uses: actions/setup-node@v3
            with:
              node-version: ${{ matrix.node-version }}
              cache: 'npm'
      
          - name: Install dependencies
            run: npm ci
      
          - name: Run tests
            run: npm test
      
          - name: Generate test coverage
            run: npm run test:coverage
      
        build:
          needs: test
          runs-on: ubuntu-latest
      
          steps:
          - uses: actions/checkout@v3
      
          - name: Use Node.js 16.x
            uses: actions/setup-node@v3
            with:
              node-version: 16.x
              cache: 'npm'
      
          - name: Install dependencies
            run: npm ci
      
          - name: Build application
            run: |
              echo "Building application for production..."
              npm run build --if-present
      
          - name: Archive production artifacts
            uses: actions/upload-artifact@v3
            with:
              name: node-app
              path: |
                .
                !node_modules/
                !.git/
  1. 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.18.1 Partie 5 : Configuration des secrets et déploiement conditionnel

  1. Ajout de secrets GitHub
    • Dans GitHub, accédez à votre dépôt
    • Allez dans Settings > Secrets and variables > Actions
    • Cliquez sur “New repository secret”
    • Ajoutez deux secrets:
      • Nom: AZURE_CREDENTIALS (avec une valeur JSON simulée pour l’atelier)
      • Nom: DEPLOYMENT_URL (avec une URL fictive, ex: https://myapp.azurewebsites.net)
  1. Ajout d’un job de déploiement
    • Modifiez votre workflow pour ajouter un job de déploiement:

      deploy:
        needs: build
        if: github.ref == 'refs/heads/main' && github.event_name == 'push'
        runs-on: ubuntu-latest
      
        environment:
          name: production
          url: ${{ secrets.DEPLOYMENT_URL }}
      
        steps:
        - name: Download artifact
          uses: actions/download-artifact@v3
          with:
            name: node-app
      
        - name: Display structure of downloaded files
          run: ls -R
      
        - name: Set up Azure credentials
          uses: azure/login@v1
          with:
            creds: ${{ secrets.AZURE_CREDENTIALS }}
            # Note: Pour un vrai déploiement, utilisez des creds valides
      
        - name: 'Deploy to Azure Web App (simulated)'
          run: |
            echo "Deploying to ${{ secrets.DEPLOYMENT_URL }}"
            # Simulons le déploiement pour l'atelier
            echo "Application would be deployed to Azure Web App"
  1. Création d’un environnement GitHub
    • Dans GitHub, accédez à votre dépôt
    • Allez dans Settings > Environments
    • Cliquez sur “New environment”
    • Nommez-le “production”
    • Activez “Required reviewers” et ajoutez-vous comme reviewer
    • Cliquez sur “Save protection rules”
  2. 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.21.1 Partie 6 : Test du processus CI/CD complet

  1. Test du processus par une Pull Request
    • Créez une nouvelle branche: git checkout -b feature/update-api

    • Modifiez le code, par exemple, ajoutez un nouvel endpoint dans app.js:

      app.get('/api/info', (req, res) => {
        res.json({
          name: 'github-actions-demo',
          environment: process.env.NODE_ENV || 'development',
          timestamp: new Date().toISOString()
        });
      });
  • Ajoutez un test pour ce nouvel endpoint dans app.test.js:
      test('GET /api/info returns application info', async () => {
        const response = await request(app).get('/api/info');
        expect(response.status).toBe(200);
        expect(response.body).toHaveProperty('name');
        expect(response.body).toHaveProperty('timestamp');
      });
  • Committez et pushez les modifications
  • Créez une Pull Request vers la branche main
  • Observez l’exécution des workflows de test
  1. Test du déploiement conditionnel
    • Une fois les tests passés, fusionnez la Pull Request
    • Observez le déclenchement du workflow complet, y compris le job de déploiement
    • Notez comment le déploiement attend une approbation (si configuré)
    • Approuvez le déploiement et observez son exécution
  2. Ajout d’un badge de statut au README
    • Modifiez le README.md pour ajouter un badge de statut:
      # 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.
  • Committez et pushez les modifications

4.13.24 Livrables

  • Application web simple avec tests unitaires
  • Workflow GitHub Actions avec matrice de tests
  • Configuration de cache pour optimiser les performances
  • Processus de build et publication d’artefacts
  • Workflow de déploiement conditionnel avec protection d’environnement
  • README avec badge de statut

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

  • Comprendre le déploiement de conteneurs Docker sur Azure App Service
  • Configurer un pipeline CI/CD dans Azure DevOps pour automatiser le déploiement
  • Implémenter des bonnes pratiques de déploiement avec intégration GitHub
  • Configurer les variables d’environnement et les secrets pour le déploiement sécurisé

4.14.2 Prérequis

  • Un abonnement Azure actif
  • Un compte Azure DevOps
  • Un repository GitHub contenant une application conteneurisée
  • Docker installé localement
  • Azure CLI installé localement

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.7.1 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.8.1 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.9.1 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.10 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.11 Partie 2 : Configuration d’Azure App Service

4.14.11.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.12.1 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.13 Partie 3 : Configuration du pipeline CI/CD avec Azure DevOps

4.14.13.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.14.1 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 :
    • acrName : Nom de votre Azure Container Registry
    • acrLoginServer : URL du serveur de login ACR (format : .azurecr.io)
    • webAppName : Nom de votre Web App Azure
  3. Ajoutez les secrets suivants :
    • acrUsername : Nom d’utilisateur ACR (récupéré précédemment)
    • acrPassword : Mot de passe ACR (récupéré précédemment)

4.14.15.1 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.16.1 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.17 Partie 4 : Configuration avec GitHub Actions (alternative)

4.14.17.1 4.1 Créer les secrets GitHub

Ajoutez les secrets suivants à votre repository GitHub :

  • AZURE_CREDENTIALS : Informations d’identification JSON pour l’accès à Azure
  • ACR_USERNAME : Nom d’utilisateur ACR
  • ACR_PASSWORD : Mot de passe ACR
  • ACR_LOGIN_SERVER : URL du serveur de login ACR
  • WEBAPP_NAME : Nom de votre App Service

4.14.18.1 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.19 Partie 5 : Tester le déploiement

4.14.19.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.20.1 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.21 Partie 6 : Bonnes pratiques et optimisations

4.14.21.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.22.1 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.23.1 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.24 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.25 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 :

  • Comprendre les principes fondamentaux de la livraison continue
  • Concevoir une stratégie de publication adaptée à différents contextes applicatifs
  • Créer un pipeline de publication de haute qualité
  • Implémenter différents modèles de déploiement (bleu-vert, canari, A/B testing)
  • Utiliser les Release Gates pour contrôler les déploiements
  • Mettre en place et interpréter un tableau de bord des versions

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

  • Réduction des risques : Les déploiements deviennent plus petits et plus fréquents
  • Détection précoce des problèmes : Les bugs sont découverts plus tôt dans le cycle de développement
  • Feedback plus rapide : Les développeurs obtiennent rapidement des retours sur leurs modifications
  • Time-to-market réduit : Les nouvelles fonctionnalités peuvent être livrées plus rapidement
  • Meilleure qualité des livrables : Grâce à l’automatisation des tests et des processus de validation

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

  • Automatiser tout ce qui peut l’être : Tests, validation, déploiement
  • Versionner tout : Code, configuration, scripts de déploiement, documentation
  • Utiliser des environnements similaires : Dev, Test, UAT, Prod doivent être aussi proches que possible
  • Implémenter une stratégie de rollback : Pouvoir revenir rapidement à une version stable
  • Mesurer et monitorer : Définir des KPIs clairs pour vos déploiements

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

  • Source du code : Extraction depuis le système de contrôle de version
  • Compilation : Génération des binaires et artefacts
  • Tests unitaires : Vérification du comportement des composants individuels
  • Tests d’intégration : Vérification des interactions entre composants
  • Analyse de code : Qualité, sécurité, conformité aux standards
  • Packaging : Création des artefacts déployables
  • Déploiement : Mise en place sur les environnements cibles
  • Tests de validation : Vérification post-déploiement
  • Approbations : Points de contrôle humain si nécessaire

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 :

  • Tests de régression automatisés
  • Validation de la qualité avec des seuils d’acceptation
  • Surveillance des performances pendant et après le déploiement
  • Alertes en cas d’anomalies
  • Traçabilité : chaque déploiement doit être traçable de bout en bout

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

  • Environnement bleu : Actuellement en production
  • Environnement vert : Nouvelle version à déployer

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.2.1 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.3 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.3.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.4.1 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 :

  • Définir clairement l’objectif et les métriques de succès (taux de conversion, temps passé, etc.)
  • Segmenter les utilisateurs de manière aléatoire mais cohérente
  • Collecter suffisamment de données pour obtenir une signification statistique
  • Ne tester qu’une seule variable à la fois pour des résultats clairs

5.8.2.1 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.3 Déploiement progressif de l’exposition

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

5.8.3.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.4.1 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 :

  • Un compte Azure DevOps
  • Un projet avec une application simple
  • Un pipeline CI/CD de base

Étapes :

  1. Configuration des métriques de surveillance :

    • Créer une application Azure App Service
    • Configurer Application Insights
    • Définir des alertes sur les métriques clés (temps de réponse, taux d’erreur)
  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é
  1. Test du pipeline :
    • Déclencher un déploiement
    • Observer le comportement des gates
    • Simuler des erreurs pour voir le blocage du déploiement
  2. Analyse et ajustement :
    • Analyser les journaux de déploiement
    • Ajuster les seuils des métriques
    • Optimiser la configuration des gates

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

  • Un compte Azure DevOps
  • Plusieurs pipelines de release configurés

Étapes :

  1. Analyse des besoins :

    • Identifier les KPIs essentiels pour l’équipe
    • Définir les métriques à suivre (fréquence, succès/échec, durée)
  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
  1. Personnalisation avancée :
    • Créer des requêtes personnalisées pour les problèmes
    • Configurer des filtres par environnement
    • Ajouter des indicateurs visuels (feux tricolores)
  2. Partage et itération :
    • Partager le tableau de bord avec l’équipe
    • Recueillir les commentaires
    • Affiner les métriques et la présentation

5.10 9. Ressources supplémentaires

5.10.1 Documentation officielle

5.10.2 Livres recommandés

  • “Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation” par Jez Humble et David Farley
  • “Release It!: Design and Deploy Production-Ready Software” par Michael T. Nygard

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 ?

      1. La livraison continue inclut les tests, le déploiement continu non
      1. Dans le déploiement continu, les changements sont automatiquement déployés en production sans validation manuelle
      1. La livraison continue est plus rapide que le déploiement continu
      1. Il n’y a pas de différence, ce sont des synonymes
  1. Dans un déploiement bleu-vert, que représentent les environnements “bleu” et “vert” ?
      1. Les environnements de test et de production
      1. Deux environnements identiques où l’un est actif et l’autre inactif
      1. L’état de santé des applications (bleu = bon, vert = en cours d’évaluation)
      1. Les versions principales et secondaires d’une application
  1. Pourquoi utiliserait-on des feature flags (ou feature toggles) ?
      1. Pour sécuriser le code source
      1. Pour activer/désactiver des fonctionnalités sans redéploiement
      1. Pour améliorer les performances de l’application
      1. Pour faciliter les tests unitaires
  1. Quelle est la caractéristique principale d’un déploiement canari ?
      1. Il est toujours utilisé pour les applications web
      1. Il expose progressivement une nouvelle version à un sous-ensemble d’utilisateurs
      1. Il nécessite toujours deux environnements identiques
      1. Il est nommé d’après un oiseau car il est très rapide
  1. Qu’est-ce qu’un “Release Gate” dans Azure DevOps ?
      1. Une personne qui approuve les déploiements
      1. Un point de contrôle automatisé qui évalue des critères pour autoriser ou bloquer un déploiement
      1. Un environnement de préproduction
      1. Une restriction d’accès aux ressources Azure

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 :

  • Créer et configurer des pipelines de versions dans Azure DevOps
  • Provisionner et gérer différents environnements de déploiement
  • Modulariser vos tâches de pipeline pour une meilleure réutilisabilité
  • Mettre en œuvre des mécanismes automatisés d’inspection de la santé des applications
  • Intégrer des pratiques de sécurité dans votre processus de développement
  • Gérer efficacement les configurations d’application et les secrets
  • Utiliser YAML pour définir vos pipelines en tant que code

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 :

  • Les artefacts à déployer
  • Les environnements cibles
  • Les approbations requises
  • Les tâches à exécuter
Structure d’un pipeline de versions

6.2.3.1 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.4 Création d’un pipeline de versions pas à pas

6.2.4.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.5.1 Étape 2 : Sélectionner un modèle

Azure DevOps propose plusieurs modèles prédéfinis selon votre scénario de déploiement :

  • Azure App Service deployment
  • Azure Kubernetes Service deployment
  • IIS website deployment
  • Et bien d’autres…

Vous pouvez également commencer avec un modèle vide (Empty job) et construire votre pipeline de zéro.

6.2.6.1 É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.7.1 É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 :

  • Déploiement sur Azure App Service
  • Exécution de scripts PowerShell/Bash
  • Déploiement de machines virtuelles
  • Configuration d’applications

6.2.8.1 É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 :

  • Déclencheurs d’artefacts : Exécution automatique lorsqu’un nouvel artefact est disponible
  • Déclencheurs planifiés : Exécution à des moments précis
  • Conditions de pré-déploiement : Approbations, portes de qualité
  • Conditions de post-déploiement : Vérifications, notifications

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

  • Visibilité sur les déploiements vers les ressources spécifiques
  • Contrôle des déploiements via des approbations et des portes
  • Traçabilité complète des déploiements
  • Sécurité améliorée pour les environnements sensibles
Structure d’un environnement Azure DevOps

6.3.3.1 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.4 Configuration des environnements

6.3.4.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.5.1 Configuration des autorisations et de la sécurité

Les environnements peuvent être sécurisés à l’aide de plusieurs mécanismes :

  • Contrôle d’accès basé sur les rôles (RBAC) : Limitez qui peut modifier ou utiliser l’environnement
  • Approbations : Exigez une approbation explicite avant le déploiement
  • Portes : Vérifications automatisées avant ou après le déploiement

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.6.1 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.7 Provisionnement d’environnements

6.3.7.1 Infrastructure as Code (IaC)

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

  • Cohérence entre les environnements
  • Versionning de l’infrastructure
  • Déploiements reproductibles
  • Documentation vivante de l’infrastructure

6.3.8.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.9.1 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.10.1 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.11 Environnements virtuels et conteneurisés

6.3.11.1 Azure Kubernetes Service (AKS)

Pour les applications conteneurisées, AKS offre :

  • Scalabilité horizontale
  • Gestion simplifiée de Kubernetes
  • Intégration avec Azure DevOps pour les déploiements

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.12.1 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.13 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.3.1 Anatomie d’une tâche

Une tâche Azure DevOps comprend :

  • Un identifiant unique
  • Une version
  • Des entrées (paramètres)
  • Des sorties (résultats)
  • Le code d’exécution (généralement en Node.js ou PowerShell)
{
  "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.4 Création de tâches personnalisées

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

Les tâches personnalisées sont utiles lorsque :

  • Vous avez des processus spécifiques à votre organisation
  • Vous voulez encapsuler une logique complexe
  • Vous avez besoin d’intégrer avec des systèmes propriétaires
  • Vous souhaitez standardiser certaines opérations

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

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

    • Installer Node.js et npm
    • Installer TFX-CLI: npm install -g tfx-cli
  2. Créer la structure du projet

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

    • Utiliser Node.js ou PowerShell
    • Accéder aux variables d’environnement et aux paramètres
    • Gérer les erreurs et les résultats
  2. Tester la tâche localement

  3. Publier la tâche

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

6.4.7.1 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.8 Modèles de pipelines

6.4.8.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.9.1 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.10.1 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.11.1 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.13.1 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.15 Modèles conditionnels et avancés

6.4.15.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.16.1 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.18 Bibliothèques de tâches et modèles

6.4.18.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.19.1 Partage entre équipes et projets

Pour partager des modèles entre projets :

  • Utiliser un dépôt dédié pour les modèles
  • Référencer les modèles à partir d’autres dépôts
  • Versionner les modèles
# 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.20 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 :

  • Disponibilité - L’application est-elle accessible ?
  • Performance - L’application répond-elle dans les délais attendus ?
  • Fonctionnalité - Les fonctionnalités clés fonctionnent-elles correctement ?
  • Sécurité - L’application présente-t-elle des vulnérabilités ?
  • Conformité - L’application respecte-t-elle les normes requises ?
Composants de l’inspection de santé

6.5.3.1 Pourquoi automatiser l’inspection de la santé ?

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

  • Détection précoce des problèmes
  • Réduction du temps de résolution
  • Amélioration de la qualité des déploiements
  • Réduction des temps d’arrêt
  • Possibilité de rollback automatique en cas de problème

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

6.5.4.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.5.1 Types de vérifications

6.5.5.1.1 Vérifications de base
  • Ping/Heartbeat - Simple vérification de disponibilité
  • Statut HTTP - Vérification des codes de réponse HTTP
  • Temps de réponse - Mesure des performances de base
6.5.5.1.2 Vérifications avancées
  • Tests synthetiques - Simulation des parcours utilisateurs
  • Tests de charge - Vérification du comportement sous charge
  • Tests de conformité - Vérification des normes de conformité

6.5.6 Outils d’inspection de la santé dans Azure

6.5.6.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 :

  • Métriques et journaux d’application
  • Alertes et notifications
  • Tableaux de bord personnalisables
  • Intégration avec Azure DevOps

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.8.1 Application Insights

Application Insights est un service d’APM (Application Performance Management) qui surveille vos applications web en temps réel.

Points forts :

  • Surveillance des performances
  • Analyse des utilisateurs
  • Détection des anomalies
  • Tests de disponibilité

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

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

Utilisations pour l’inspection de la santé :

  • Vérification de la configuration sécurisée
  • Contrôle de conformité
  • Gouvernance des ressources

6.5.11.1 Sondes de préparation et de disponibilité

Les sondes (probes) sont des mécanismes pour vérifier l’état d’une application :

  • Readiness probe - L’application est-elle prête à servir le trafic ?
  • Liveness probe - L’application fonctionne-t-elle correctement ?
  • Startup probe - L’application a-t-elle démarré correctement ?

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.13 Implémentation d’endpoints de santé dans les applications

6.5.13.1 Conception d’API de santé

Une bonne API de santé devrait :

  • Fournir un statut clair (UP, DOWN, DEGRADED)
  • Inclure des données détaillées sur les composants
  • Être légère et rapide à exécuter
  • Sécurisée mais accessible pour les outils de surveillance

6.5.14.1 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.15.1 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.16 Intégration dans les pipelines Azure DevOps

6.5.16.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.17.1 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.18.1 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.19 Surveillance continue

6.5.19.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.20.1 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.21 Journalisation et visibilité

6.5.21.1 Centralisation des journaux

La centralisation des journaux est essentielle pour une inspection efficace de la santé :

  • Azure Log Analytics - Stockage centralisé des journaux
  • Application Insights - Télémétrie d’application
  • Event Hubs - Ingestion en temps réel
# 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.22.1 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.23 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 :

  • Sécurité dès la conception (Shift-Left)
  • Automatisation des contrôles de sécurité
  • Responsabilité partagée
  • Amélioration continue
Cycle DevSecOps

6.6.3.1 Avantages de DevSecOps

  • Détection plus précoce des vulnérabilités
  • Réduction des coûts de correction
  • Accélération du délai de mise sur le marché
  • Réduction des risques de sécurité
  • Conformité continue

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

6.6.4.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.5.1 Le modèle de responsabilité partagée

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

  • Développeurs - Écrire du code sécurisé, respecter les bonnes pratiques
  • Opérations - Sécuriser l’infrastructure, gérer les configurations
  • Équipe sécurité - Définir les standards, fournir une expertise
  • Management - Allouer des ressources, promouvoir la culture

6.6.6 Outils de sécurité dans Azure DevOps

6.6.6.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.7.1 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.8.1 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.9.1 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.10.1 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.11 Azure DevOps Security Features

6.6.11.1 Azure DevOps Advanced Security

Azure DevOps propose une suite de fonctionnalités de sécurité avancées :

  • Dependency scanning - Détection des vulnérabilités dans les dépendances
  • Secret scanning - Identification des secrets exposés
  • Code scanning - Analyse statique du code source

Configuration dans un pipeline :

# Configuration d'Azure DevOps Advanced Security
steps:
- task: AdvancedSecurity-Codeql-Build@1
  inputs:
    buildCommands: 'dotnet build'
    language: 'csharp'

6.6.12.1 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.13.1 Politiques de sécurité (Security Policies)

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

  • Revues de code obligatoires
  • Vérifications de build obligatoires
  • Restrictions de push

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

6.6.14.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.16.1 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.17 Auditing et conformité

6.6.17.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.18.1 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.19 Réponse aux incidents de sécurité

6.6.19.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.20.1 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.21 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

  • Utilisation des variables d’environnement pour stocker les paramètres de configuration
  • Configuration dans Azure DevOps via les variables de pipeline
  • Avantages: simplicité, intégration native avec les plateformes cloud
  • Inconvénients: nombre limité de variables, difficulté de gestion à grande échelle

6.7.3.1 Fichiers de configuration

  • Formats courants: JSON, XML, YAML
  • Transformation des fichiers de configuration selon l’environnement
  • Utilisation de la tâche “File Transform” dans Azure Pipelines
- task: FileTransform@1
  inputs:
    folderPath: '$(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip'
    fileType: 'json'
    targetFiles: '**/appsettings.json'

6.7.4.1 Azure App Configuration

  • Service géré pour centraliser les paramètres d’application et les indicateurs de fonctionnalités
  • Intégration avec Azure DevOps et les applications Azure
  • Prise en charge du chiffrement, des étiquettes et du versionnement
// 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.5 Bonnes pratiques

  1. Sécurité
    • Ne jamais stocker de secrets (mots de passe, clés API) dans les fichiers de configuration versionnés
    • Utiliser des services comme Azure Key Vault pour les secrets
  2. Hiérarchie
    • Établir une hiérarchie claire pour les paramètres (globaux, par environnement, par application)
    • Utiliser la surcharge pour les paramètres spécifiques
  3. Validation
    • Valider les configurations au démarrage de l’application
    • Implémenter des tests automatisés pour vérifier les configurations

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

  • Configuration de l’authentification Azure AD pour Azure DevOps
  • Gestion des groupes et des utilisateurs
  • Attribution des rôles et des permissions

6.8.2.1 Authentification des applications

  • Identités gérées pour les ressources Azure
  • Authentification des applications avec OAuth 2.0 et OpenID Connect
  • Service Principals pour l’authentification automatisée
# 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.3 Gestion des secrets

6.8.3.1 Azure Key Vault

  • Stockage sécurisé des secrets, certificats et clés
  • Intégration avec Azure DevOps via des tâches dédiées
  • Rotation des secrets et audit des accès
# 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.4.1 Gestion des identités dans les pipelines

  • Variables secrètes dans les pipelines
  • Utilisation des service connections
  • Limitation des permissions selon le principe du moindre privilège

6.8.5 Sécurisation des déploiements

  • Approbations et gates dans les pipelines de déploiement
  • Exigence de l’authentification multifacteur pour les opérations critiques
  • Audit et traçabilité des actions de déploiement

6.9 Implémenter la configuration de l’application

6.9.1 Stratégies de déploiement

6.9.1.1 Configuration progressive

  • Déploiements bleu/vert
  • Déploiements canary
  • Feature flags pour activer progressivement les fonctionnalités

6.9.2.1 Gestion de la configuration par environnement

  • Variables de groupe dans Azure DevOps
  • Variables de stage dans les pipelines YAML
  • Templates de déploiement paramétrables
# 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.3 Configuration à l’exécution

6.9.3.1 Azure App Services

  • Slots de déploiement pour les permutations sans temps d’arrêt
  • Paramètres d’application et chaînes de connexion
  • Configuration des variables d’environnement

6.9.4.1 Azure Functions

  • Configuration des applications de fonction
  • Environnements d’exécution et scaling
  • Déclencheurs et bindings

6.9.5.1 Conteneurs

  • Variables d’environnement pour les conteneurs
  • Configuration des orchestrateurs (AKS, Azure Container Apps)
  • Gestion des secrets avec Kubernetes

6.9.6 Observabilité et supervision

  • Configuration de la journalisation (Application Insights, Log Analytics)
  • Alertes et métriques
  • Surveillance de la configuration et détection des dérives

6.10 Ateliers pratiques

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

6.10.1.1 Objectifs

  • Créer un pipeline CI/CD complet en utilisant YAML
  • Utiliser des templates et des paramètres pour la réutilisabilité
  • Implémenter des conditions et des dépendances

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

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

    - task: DotNetCoreCLI@2
      inputs:
        command: 'test'
        projects: '**/*Tests/*.csproj'
        arguments: '--configuration $(buildConfiguration)'
  1. 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.6.1 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.7 Atelier 2: Configuration de pipelines et exécution de tests fonctionnels

6.10.7.1 Objectifs

  • Configurer des tests automatisés dans le pipeline
  • Intégrer des rapports de tests et de couverture
  • Implémenter des gates de qualité

6.10.8.1 É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"'
  1. Configuration des tests fonctionnels

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

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

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

6.10.12.1 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.13 Atelier 3: Intégration d’Azure Key Vault avec Azure DevOps

6.10.13.1 Objectifs

  • Configurer l’accès à Azure Key Vault depuis un pipeline
  • Récupérer et utiliser des secrets dans le déploiement
  • Implémenter une rotation sécurisée des secrets

6.10.14.1 Étapes

  1. Configuration de la connexion à Key Vault

    - task: AzureKeyVault@2
      inputs:
        azureSubscription: 'Azure subscription'
        KeyVaultName: 'myKeyVault'
        SecretsFilter: '*'
        RunAsPreJob: true
  1. 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)'
  1. 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.17.1 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.18 Atelier 4: Pipelines permettant la configuration dynamique et les indicateurs de fonctionnalités

6.10.18.1 Objectifs

  • Configurer Azure App Configuration
  • Implémenter des feature flags dans une application
  • Gérer les feature flags via le pipeline CI/CD

6.10.19.1 É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
  1. 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
  1. 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();
        }
    }
  1. 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.23.1 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

  • “DevOps avec Azure DevOps et GitHub” - Microsoft Press
  • “Implementing Azure DevOps Solutions” - Packt Publishing

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

7.2.1 1.1 Qu’est-ce que l’Infrastructure as Code (IaC) ?

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.2.1 Avantages de l’IaC :

  • Reproductibilité : Les environnements sont identiques à chaque déploiement
  • Évolutivité : Facilite le déploiement à grande échelle
  • Contrôle de version : L’infrastructure est versionnable dans un système de gestion de code source
  • Cohérence : Réduit les erreurs humaines et la configuration manuelle
  • Documentation intégrée : Le code décrit l’infrastructure de manière explicite
  • Rapidité : Accélère le provisionnement des ressources
  • Test : Possibilité de tester l’infrastructure avant le déploiement

7.2.3 Types d’approches IaC

7.2.3.1 Approche déclarative vs impérative

  • Déclarative : Spécifie l’état souhaité du système, sans décrire comment y parvenir
    • Exemples : ARM Templates, Terraform, CloudFormation, Kubernetes YAML
  • Impérative : Décrit les étapes exactes pour atteindre l’état souhaité
    • Exemples : Scripts PowerShell, Azure CLI, AWS CLI

7.2.4.1 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.5 Principes de la gestion de configuration

  • Idempotence : L’application répétée des mêmes configurations ne change pas le résultat final
  • États souhaités : Définir l’état souhaité plutôt que les étapes pour y parvenir
  • Gestion centralisée : Gérer les configurations à partir d’un point central
  • Correction de dérive : Détecter et corriger les écarts par rapport à la configuration souhaitée
  • Modularité : Créer des composants réutilisables

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.2.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.3 Éléments clés des modèles ARM

  • Parameters : Valeurs qui peuvent être fournies lors du déploiement
  • Variables : Valeurs réutilisables dans le modèle
  • Functions : Fonctions définies par l’utilisateur pour réutiliser du code
  • Resources : Ressources Azure à déployer
  • Outputs : Valeurs retournées après le déploiement

7.3.4 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.5 Déploiement de modèles ARM

7.3.5.1 Via le portail Azure

  • Rechercher “Déployer un modèle personnalisé” dans le portail Azure
  • Sélectionner “Créer votre propre modèle dans l’éditeur”
  • Coller le modèle ARM et cliquer sur “Enregistrer”
  • Remplir les paramètres et déployer

7.3.6.1 Via PowerShell

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

7.3.7.1 Via Azure CLI

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

7.3.8 Bonnes pratiques pour les modèles ARM

  • Utiliser des paramètres pour les valeurs qui changent
  • Limiter l’utilisation des variables aux valeurs réutilisées
  • Utiliser des expressions de modèle pour des transformations complexes
  • Utiliser des modèles liés pour les déploiements complexes
  • Documenter les paramètres avec des métadonnées
  • Utiliser des tests avant le déploiement

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.6.1 Création d’une machine virtuelle

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

7.4.7 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.8 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.2.1 Fonctionnalités principales

  • Automatisation des processus avec des runbooks
  • Configuration d’état souhaité (DSC)
  • Gestion des mises à jour
  • Suivi des modifications
  • Inventaire

7.5.3 Runbooks Azure Automation

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

7.5.3.1 Types de runbooks

  • PowerShell : Scripts PowerShell (.ps1)
  • Graphiques : Créés visuellement avec des activités
  • Python : Scripts Python (.py)
  • PowerShell Workflow : Pour les processus longs ou parallèles

7.5.4 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.5 Intégration d’Azure Automation avec Azure DevOps

7.5.5.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.6.1 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.7 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.8.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.2.1 Principes clés de DSC

  • Déclaratif : On définit ce que doit être le système
  • Idempotent : L’application répétée de la configuration ne change pas le résultat
  • Centralisé : Gestion depuis un point central (Pull Server ou Azure Automation)

7.6.3 Composants de DSC

  • Configurations : Documents qui décrivent un environnement composé de ressources
  • Ressources : Modules implémentant la gestion de différents aspects du système
  • Local Configuration Manager (LCM) : Moteur qui applique les configurations aux nœuds

7.6.4 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.5 Application de configurations DSC

7.6.5.1 Application locale

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

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

7.6.6.1 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.7 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.7.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.8.1 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.2.1 Architecture de Chef

  • Chef Server : Composant central qui stocke les configurations
  • Chef Client : S’exécute sur les nœuds gérés et applique les configurations
  • Workstation : Où les configurations sont développées et testées

7.7.3.1 Concepts clés de Chef

  • Cookbook : Unité fondamentale de configuration, contenant recettes, attributs, etc.
  • Recipe : Script Ruby qui définit les configurations à appliquer
  • Resource : Déclaration de l’état d’un élément spécifique du système
  • Attributes : Variables utilisées dans les recipes
  • Data Bags : Stockage global de données JSON

7.7.4 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.5 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.6.1 Architecture de Puppet

  • Puppet Master : Serveur central qui compile et distribue les manifestes
  • Puppet Agent : S’exécute sur les nœuds gérés pour appliquer les configurations
  • Forge : Référentiel de modules Puppet partagés par la communauté

7.7.7.1 Concepts clés de Puppet

  • Manifest : Fichier contenant du code Puppet (.pp)
  • Module : Collection de manifestes, fichiers, templates, etc.
  • Resource : Élément du système à gérer (package, service, fichier, etc.)
  • Class : Regroupement de ressources liées
  • Node : Système géré par Puppet

7.7.8 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.9 Intégration avec Azure

7.7.9.1 Chef

  • Extension de machine virtuelle Chef pour Azure
  • Azure Chef Extension pour faciliter l’intégration
  • Provisionnement via ARM Templates

7.7.10.1 Puppet

  • Extension de machine virtuelle Puppet pour Azure
  • Module Puppet pour Azure pour gérer les ressources Azure
  • Provisionnement via ARM Templates

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.2.1 Caractéristiques d’Ansible

  • Agentless : Ne nécessite pas d’agent sur les nœuds gérés
  • Idempotence : Les tâches peuvent être exécutées plusieurs fois sans effet secondaire
  • Simple : Utilise YAML pour les playbooks
  • SSH : Utilise SSH pour la communication
  • Extensible : Nombreux modules disponibles

7.8.3 Architecture d’Ansible

  • Control Node : Machine où Ansible est installé
  • Managed Nodes : Systèmes gérés par Ansible
  • Inventory : Liste des nœuds gérés
  • Modules : Unités de code exécutées sur les nœuds
  • Playbooks : Fichiers YAML décrivant les tâches à exécuter
  • Roles : Regroupement de playbooks et autres fichiers

7.8.4 Installation d’Ansible

7.8.4.1 Sur Ubuntu

sudo apt update
sudo apt install -y ansible

7.8.4.2 Sur CentOS/RHEL

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

7.8.5 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.6 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.7 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.8 Ansible avec Azure

7.8.8.1 Installation du module Azure

pip install ansible[azure]

7.8.9.1 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.10.1 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.2.1 Caractéristiques de Terraform

  • Déclaratif : Définit l’état souhaité de l’infrastructure
  • Multi-plateformes : Supporte de nombreux fournisseurs cloud et services
  • Plan d’exécution : Montre les changements avant de les appliquer
  • Graphe de dépendances : Crée ou modifie les ressources dans l’ordre correct
  • État : Suit l’état de l’infrastructure déployée

7.9.3 Installation de Terraform

7.9.3.1 Windows

choco install terraform

7.9.3.2 macOS

brew install terraform

7.9.3.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.4 Configuration de Terraform pour Azure

7.9.4.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.5.1 Fichier de fournisseur (provider.tf)

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

provider "azurerm" {
  features {}
}

7.9.6 Création d’une infrastructure Azure avec Terraform

7.9.6.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.7 Variables et modules Terraform

7.9.7.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.8.1 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.9 État et backend Terraform

7.9.9.1 État local

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

7.9.10.1 É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.12 Cycle de vie Terraform

7.9.12.1 Initialisation

terraform init
  • Initialise le répertoire de travail
  • Télécharge les plugins requis
  • Initialise le backend

7.9.13.1 Planification

terraform plan -out=tfplan
  • Crée un plan d’exécution
  • Montre les changements qui seront appliqués

7.9.14.1 Application

terraform apply tfplan
  • Applique les changements définis dans le plan

7.9.15.1 Destruction

terraform destroy
  • Supprime toutes les ressources gérées par Terraform

7.9.16 Meilleures pratiques Terraform

  1. Structure de projet
    • Utiliser une structure de répertoires cohérente
    • Séparer les environnements (dev, test, prod)
    • Utiliser des modules réutilisables
  2. Gestion des versions
    • Utiliser un système de contrôle de version
    • Définir des versions spécifiques pour les providers
    • Utiliser des tags pour marquer les versions stables
  3. État
    • Utiliser un backend distant pour l’état
    • Activer le verrouillage d’état
    • Sauvegarder régulièrement l’état
  1. Sécurité
    • Ne pas stocker de secrets dans le code
    • Utiliser des clés d’accès avec des droits limités
    • Utiliser des variables pour les valeurs sensibles
  2. Automatisation
    • Intégrer Terraform dans les pipelines CI/CD
    • Automatiser les tests d’infrastructure
    • Utiliser des outils de validation comme Terraform Validate

7.10 Ressources supplémentaires

7.10.1 Documentation officielle

7.10.2 Cours et ateliers pratiques

7.10.3 Livres recommandés

  • “Infrastructure as Code” par Kief Morris
  • “Terraform: Up & Running” par Yevgeniy Brikman
  • “Ansible for DevOps” par Jeff Geerling

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

  • Dépendances directes : Packages explicitement référencés dans votre projet
  • Dépendances transitives : Packages dont dépendent vos dépendances directes
  • Dépendances de développement : Outils nécessaires uniquement pour le développement (tests, build)
  • Dépendances de runtime : Composants nécessaires lors de l’exécution

8.1.1.2 Défis liés aux dépendances

  • Incompatibilités de version : Conflits entre différentes versions de packages
  • Vulnérabilités de sécurité : Utilisation de packages vulnérables
  • Problèmes de licence : Utilisation de packages avec des restrictions légales
  • Dépendances orphelines : Packages qui ne sont plus maintenus
  • Dépendances cycliques : Packages qui dépendent mutuellement l’un de l’autre

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

  • Visualisation des relations entre éléments de travail
  • Identification des dépendances entre équipes et projets

8.1.3.2 Dépendances entre pipelines

  • Création de pipelines avec des dépendances entre eux
  • Déclenchement automatique de pipelines en fonction des résultats d’autres 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

  • NuGet.org : Packages .NET
  • npm Registry : Packages JavaScript
  • Maven Central : Packages Java
  • PyPI : Packages Python
  • Docker Hub : Images conteneur

8.2.1.2 Feeds privés

  • Azure Artifacts : Solution intégrée à Azure DevOps
  • GitHub Packages : Intégration avec GitHub
  • Artifactory : Solution multi-technologie
  • Nexus Repository : Alternative populaire à Artifactory

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

  • NuGet (.NET)
  • npm (JavaScript)
  • Maven (Java)
  • Python (pip)
  • Universal Packages (format agnostique pour tout type de contenu)

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

  • Définir une durée de conservation des packages
  • Conserver un nombre maximum de versions
  • Protéger les versions stables contre la suppression

8.2.4.2 Vues et promotion de packages

  • Vues @prerelease : Packages en cours de développement
  • Vues @release : Packages stables pour la production
  • Promouvoir un package de prerelease à release
  • Définir des autorisations spécifiques par vue

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

  • Migration big bang : Tout migrer en une seule fois
  • Migration progressive : Migrer par étapes
  • Migration parallèle : Maintenir les deux systèmes pendant la transition

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

  • Réduction des coûts d’infrastructure
  • Simplification de la gestion
  • Amélioration de la sécurité
  • Visibilité centralisée
  • Gestion unifiée des droits d’accès

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

  • Injection de code malveillant dans les packages
  • Vol de secrets ou d’informations sensibles
  • Utilisation de packages vulnérables
  • Utilisation de packages avec des licences incompatibles

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

  • Synchronisation des artefacts entre clouds
  • Cohérence des versions
  • Performances d’accès aux artefacts
  • Sécurité entre les différents clouds

8.3.4.2 Stratégies de gestion

  • Repository unique : Un seul référentiel accessible depuis tous les clouds
  • Réplication : Synchronisation entre référentiels dans chaque cloud
  • Référentiel par environnement : Promotion des artefacts entre environnements

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]
  • MAJEUR : Modifications incompatibles avec les versions précédentes
  • MINEUR : Ajout de fonctionnalités rétrocompatibles
  • CORRECTIF : Corrections de bugs rétrocompatibles
  • Préversion : Identifiant de préversion (alpha, beta, rc)
  • Métadonnées : Informations supplémentaires (build, commit)

8.4.1.2 Exemples de versions SemVer

  • 1.0.0 : Version initiale stable
  • 1.1.0 : Ajout de fonctionnalités
  • 1.1.1 : Correction de bugs
  • 2.0.0 : Modifications incompatibles
  • 1.0.0-alpha.1 : Version alpha
  • 1.0.0-beta.2 : Version bêta
  • 1.0.0-rc.1 : Version candidate

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

  • GitVersion : Calcule la version basée sur l’historique Git
  • GitHubFlow : Versionnage basé sur les branches et tags
  • Azure DevOps versionnage : Incrémentation automatique dans les pipelines

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

  • Interdépendances entre services
  • Déploiements indépendants
  • Compatibilité API
  • Versions combinées de multiples services

8.4.5.2 Approches de versionnage pour microservices

  • Versionnage indépendant : Chaque service a son propre cycle de vie
  • Versionnage d’API : Versionnage explicite des interfaces publiques
  • Versionnage des contrats : Garantir la compatibilité entre services
  • Compatibilité sémantique : Suivre les changements qui impactent les autres services

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

  • Implémenter des contrôles de sécurité dans les pipelines CI/CD
  • Configurer des règles de conformité pour les pipelines
  • Mettre en place des stratégies de scan de vulnérabilités
  • Intégrer des contrôles d’accès sécurisés

9.1.1.2 Prérequis

  • Un compte Azure DevOps avec les permissions appropriées
  • Un projet Azure DevOps préconfiguré
  • Une application de démonstration (idéalement une application web simple)

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

Instructions:

  1. Configurer la protection des branches
    • Accédez à votre projet dans Azure DevOps
    • Naviguez vers Repos > Branches
    • Sélectionnez la branche principale (main/master)
    • Activez la protection de branche avec les options suivantes:
      • Exiger une politique d’approbation minimale (min. 1 réviseur)
      • Exiger la résolution des commentaires de revue de code
      • Activer “Require successful builds”
  2. Créer une politique de validation de code
    • Allez dans Repos > Stratégies de branche
    • Sélectionnez la branche principale
    • Configurez les stratégies suivantes:
      • Nombre minimal de réviseurs: 1
      • Autorisations requises: Créateur de la pull request ne peut pas approuver
      • Vérifications de build: Ajoutez votre pipeline CI existant
  3. Questions de réflexion:
    • Comment ces politiques améliorent-elles la sécurité du code?
    • Quels autres paramètres pourraient être ajoutés pour une sécurité renforcée?

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

Instructions:

  1. Installer l’extension Microsoft Security DevOps
    • Accédez au Azure DevOps Marketplace
    • Recherchez “Microsoft Security DevOps”
    • Installez l’extension dans votre organisation
  2. Ajouter un scan de sécurité au pipeline CI/CD
    • Modifiez votre fichier azure-pipelines.yml pour ajouter le scan de sécurité:
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
    • Installez l’extension Dependency Check pour Azure DevOps
    • Ajoutez la tâche au pipeline pour analyser les dépendances vulnérables:
- 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:
    • Quels sont les avantages d’intégrer des scans de sécurité dans le pipeline CI/CD?
    • Comment pouvez-vous gérer les faux positifs?

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
    • Accédez au portail Azure
    • Allez dans le service Azure Policy
    • Créez une nouvelle définition avec le JSON suivant:
{
  "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
    • Ajoutez une tâche dans la phase de déploiement:
- 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
    • Dans le pipeline de release, configurez un gate avant l’environnement de production:
      • Activez “Pre-deployment approvals”
      • Activez “Gates”
      • Ajoutez une vérification “Azure Policy Compliance”
  2. Questions de réflexion:
    • Comment les gates améliorent-ils la sécurité des déploiements?
    • Quelles autres politiques pourraient être pertinentes pour votre organisation?

9.1.1.6 Partie 4 : Gestion des secrets dans le pipeline

Instructions:

  1. Créer un Azure Key Vault
    • Dans le portail Azure, créez un nouveau Key Vault
    • Configurez les politiques d’accès appropriées
  2. Ajouter des secrets au Key Vault
    • Créez un secret nommé “DatabaseConnectionString” avec une valeur de test
  3. Configurer l’accès sécurisé dans le pipeline
    • Modifiez votre pipeline pour utiliser les secrets de Key Vault:
- 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:
    • Pourquoi est-il important de ne pas stocker les secrets en clair dans les pipelines?
    • Comment pouvez-vous assurer la rotation régulière des secrets?

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

  • Comprendre le concept de dette technique
  • Configurer SonarCloud pour l’analyse de code
  • Intégrer SonarCloud avec Azure DevOps
  • Établir des règles de qualité de code dans les pipelines
  • Mettre en place une stratégie d’amélioration continue

9.1.2.2 Prérequis

  • Un compte Azure DevOps avec les permissions appropriées
  • Un projet Azure DevOps contenant du code source
  • Un compte SonarCloud (version d’essai gratuite disponible)

9.1.2.3 Partie 1 : Configuration de SonarCloud

Instructions:

  1. Créer un compte SonarCloud
    • Rendez-vous sur SonarCloud
    • Créez un compte en utilisant votre compte Azure DevOps
    • Créez une nouvelle organisation SonarCloud
  2. Installer l’extension SonarCloud pour Azure DevOps
  3. Créer un projet SonarCloud
    • Dans SonarCloud, créez un nouveau projet
    • Sélectionnez votre organisation
    • Choisissez “Configurer avec Azure Pipelines”
    • Notez votre token d’accès et votre clé de projet
  4. Questions de réflexion:
    • Pourquoi est-il préférable d’utiliser SonarCloud plutôt que SonarQube pour les projets cloud-native?
    • Quels types de problèmes SonarCloud peut-il identifier dans votre code?

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

Instructions:

  1. Configurer les variables de service connection
    • Dans Azure DevOps, accédez à Paramètres du projet > Service connections
    • Créez une connexion de service SonarCloud
    • Utilisez le token d’accès précédemment obtenu
  2. Configurer l’analyse SonarCloud pour un projet .NET
    • Modifiez votre fichier azure-pipelines.yml pour inclure l’analyse SonarCloud:
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
    • Utilisez cette configuration alternative:
- 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:
    • Comment l’intégration de SonarCloud peut-elle améliorer votre processus de revue de code?
    • Quels avantages y a-t-il à collecter la couverture de code avec l’analyse SonarCloud?

9.1.2.5 Partie 3 : Configuration des Quality Gates

Instructions:

  1. Configurer un Quality Gate dans SonarCloud
    • Accédez à votre projet dans SonarCloud
    • Allez dans Administration > Quality Gates
    • Créez un nouveau Quality Gate ou utilisez “Sonar Way”
    • Configurez les conditions suivantes:
      • Couverture de code > 80%
      • Bugs critiques = 0
      • Dette technique < 5% (ratio)
      • Code dupliqué < 3%
  2. Configurer l’échec du build en cas de non-respect du Quality Gate
    • Modifiez votre pipeline pour ajouter une étape de vérification:
- 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
    • Dans votre pipeline de release, ajoutez une gate avant le déploiement:
      • Utilisez la tâche “Evaluate SonarCloud Quality Gate”
      • Configurez-la pour bloquer le déploiement si le Quality Gate échoue
  2. Questions de réflexion:
    • Quelle est l’importance des Quality Gates dans la gestion de la dette technique?
    • Comment équilibrer les exigences de qualité strictes avec les délais de livraison?

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

Instructions:

  1. Exécuter une première analyse complète
    • Déclenchez manuellement votre pipeline pour analyser le code
    • Consultez les résultats dans SonarCloud
  2. Créer un plan de remédiation
    • Analysez le rapport de dette technique
    • Identifiez les 5 problèmes les plus importants
    • Créez des user stories dans Azure DevOps pour chaque problème:
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
    • Créez un dashboard Azure DevOps avec:
      • Un widget SonarCloud montrant l’évolution de la dette technique
      • Un rapport de bugs détectés par SonarCloud
      • Un suivi des user stories de remédiation
  2. Questions de réflexion:
    • Comment équilibrer le développement de nouvelles fonctionnalités et la correction de la dette technique?
    • Quels indicateurs clés utiliser pour suivre la santé du code?

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

Instructions:

  1. Configurer des Pull Request Decorators
    • Dans SonarCloud, activez l’analyse des pull requests
    • Configurez Azure DevOps pour afficher les résultats SonarCloud dans les PRs
  2. Créer une politique de branche liée à SonarCloud
    • Dans Repos > Branches > Policies
    • Ajoutez une politique “Status Check”
    • Sélectionnez SonarCloud comme provider
  3. Configurer des rapports hebdomadaires
    • Activez les notifications SonarCloud
    • Configurez l’envoi de rapports hebdomadaires par email
  4. Questions de réflexion:
    • Comment l’automatisation peut-elle aider à maintenir la qualité du code sur le long terme?
    • Quelles mesures organisationnelles peuvent compléter les outils techniques?

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

  • Définition des conteneurs : Les conteneurs sont des unités logicielles standardisées qui empaquetent le code et toutes ses dépendances.
  • Différences entre conteneurs et machines virtuelles
    • Les conteneurs partagent le même système d’exploitation (noyau)
    • Les VMs incluent un système d’exploitation complet
    • Les conteneurs sont plus légers et démarrent plus rapidement

10.2.2 Principes de la conteneurisation

  • Isolation : Chaque conteneur s’exécute de manière isolée
  • Portabilité : Fonctionne de la même manière dans n’importe quel environnement
  • Scalabilité : Facilité à déployer plusieurs instances
  • Immutabilité : Les conteneurs ne sont pas modifiés mais recréés

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

  • Analyse des applications candidates : Identification des applications adaptées à la conteneurisation
  • Choix de l’architecture : Monolithique vs microservices
  • Gestion des images : Stratégie de versionnement et registres d’images
  • Orchestration : Choix entre Docker Compose, Kubernetes, etc.
  • Surveillance et journalisation : Mise en place d’outils de monitoring

10.2.4 1.4 Bonnes pratiques pour les images Docker

  • Images de base minimales : Alpine Linux, Distroless
  • Multistage builds : Séparation des dépendances de build et d’exécution
  • Une responsabilité par conteneur : Principe du single concern
  • Utilisation des secrets sécurisés : Ne pas inclure de secrets dans les images
  • Images non-root : Éviter d’exécuter les processus en tant que root

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

  • Scan des vulnérabilités : Outils comme Trivy, Clair, Microsoft Defender for Containers
  • Principe du moindre privilège : Limitation des accès et des capacités
  • Gestion des secrets : Azure Key Vault, Kubernetes Secrets
  • Isolation réseau : Mise en place de politiques réseau
  • Mise à jour des images : Processus automatisé de mise à jour

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

10.3.1 2.1 Le problème des builds Docker traditionnels

  • Images volumineuses : Inclusion des outils de build dans l’image finale
  • Surface d’attaque élargie : Présence d’outils inutiles en production
  • Optimisation difficile du cache des couches

10.3.2 2.2 Concept des builds multi-étapes

  • Définition : Utilisation de plusieurs instructions FROM dans un Dockerfile
  • Avantages :
    • Réduction de la taille des images
    • Séparation des préoccupations
    • Amélioration de la sécurité

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

  • Organisation des couches : Ordonner les instructions par fréquence de changement
  • Utilisation du cache : Stratégies pour maximiser le cache des couches
  • Copie sélective : Utilisation de .dockerignore pour exclure les fichiers inutiles
  • Arguments de build : Paramètres variables pour les builds

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

10.4.1 3.1 Introduction à AKS

  • Définition : Service Kubernetes managé par Microsoft Azure
  • Avantages :
    • Plan de contrôle géré sans coût supplémentaire
    • Intégration avec les services Azure
    • Scaling automatique des nœuds
    • Mise à jour simplifiée de Kubernetes

10.4.2 3.2 Architecture d’AKS

  • Plan de contrôle : Géré par Azure (API server, scheduler, etc.)
  • Nœuds : VMs Azure exécutant les workloads
  • Groupes de nœuds : Collections de nœuds avec les mêmes configurations
  • Modèles de déploiement : Standard, Virtual Nodes, Windows Containers

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

10.4.3.3 3.3.3 Via Infrastructure as Code (IaC)

  • ARM Template
  • Terraform
  • Bicep

10.4.4 3.4 Configuration avancée d’AKS

  • Scaling : Manuel, automatique (HPA, KEDA)
  • Mise en réseau : Kubenet vs Azure CNI
  • Identité : Service principal vs Managed Identity
  • Stockage : Azure Disks, Azure Files
  • Surveillance : Azure Monitor, Container Insights

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

  • RBAC Kubernetes : Rôles et ClusterRoles
  • Azure AD Integration : Authentification via Azure AD
  • Azure RBAC : Contrôle d’accès basé sur les rôles Azure

10.4.6 3.6 Sécurité d’AKS

  • Stratégies Azure : Application de contraintes sur les ressources
  • Network Policies : Contrôle du trafic entre les pods
  • Pod Security : Contraintes de sécurité pour les pods
  • Microsoft Defender for Containers : Détection des menaces

10.5 4. Explorer les outils Kubernetes

10.5.1 4.1 Outils en ligne de commande

  • kubectl : Outil CLI principal pour interagir avec Kubernetes

    # Commandes essentielles
    kubectl get [resource]
    kubectl describe [resource] [name]
    kubectl apply -f [file]
    kubectl delete [resource] [name]
    kubectl logs [pod]
  • kubeadm : Outil pour créer et gérer des clusters Kubernetes

  • helm : Gestionnaire de paquets pour Kubernetes

    # Installation d'une chart Helm
    helm repo add [repo-name] [repo-url]
    helm install [release-name] [chart]

10.5.2 4.2 Interfaces graphiques

  • Kubernetes Dashboard : Interface web officielle
  • Azure Portal : Vue AKS intégrée
  • Lens / OpenLens : IDE Kubernetes Desktop
  • K9s : Terminal UI pour Kubernetes

10.5.3 4.3 Outils de développement

  • Skaffold : Facilite le workflow de développement
  • Draft : Outils de Microsoft pour le développement local
  • Tilt : Automatisation du développement sur Kubernetes
  • Telepresence : Développement local avec accès aux services distants

10.5.4 4.4 Outils de surveillance et de diagnostic

  • Prometheus : Surveillance des métriques
  • Grafana : Visualisation des métriques
  • Jaeger / Zipkin : Traçage distribué
  • Fluentd / Elasticsearch / Kibana (EFK) : Journalisation

10.5.5 4.5 Outils de gestion avancée

  • Kustomize : Personnalisation des ressources Kubernetes
  • Flux / ArgoCD : GitOps pour Kubernetes
  • Istio / Linkerd : Service Mesh
  • Knative : Plateforme serverless sur Kubernetes

10.6 5. Intégrer AKS aux pipelines

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

  • Principes : Automatisation, tests, déploiement continu
  • Flux de travail typique :
    1. Construction de l’image
    2. Tests
    3. Push vers un registre
    4. Déploiement sur AKS

10.6.2 5.2 Configuration des registres d’images

  • Azure Container Registry (ACR)
    • Création et configuration
    • Intégration avec AKS
    # Création d'un ACR
    az acr create --name myACR --resource-group myRG --sku Standard
    
    # Connexion d'AKS à ACR
    az aks update --name myAKS --resource-group myRG --attach-acr myACR
  • Autres registres : Docker Hub, GitHub Container Registry, etc.

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

  • Rolling Update : Mise à jour progressive des pods
  • Blue/Green : Deux environnements identiques avec switch
  • Canary : Déploiement progressif vers un sous-ensemble d’utilisateurs
  • A/B Testing : Test de différentes versions

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

  • Infrastructure as Code : Définition du cluster et des applications
  • Environnements séparés : Dev, Test, Production
  • Gestion des secrets : Azure Key Vault, Kubernetes Secrets
  • Stratégie de tests : Unit, Integration, E2E

10.7 Ressources complémentaires

10.7.1 Documentation officielle

10.7.2 Cours et tutoriels

10.7.3 Livres recommandés

  • “Kubernetes: Up and Running” par Brendan Burns, Kelsey Hightower et Joe Beda
  • “Docker Deep Dive” par Nigel Poulton
  • “Cloud Native DevOps with Kubernetes” par John Arundel et Justin Domingus

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 :

  • Configurer des outils pour suivre l’utilisation et le flux des applications
  • Mettre en place des systèmes de collecte de données d’incidents pour les applications mobiles
  • Créer et interpréter des tableaux de bord de surveillance
  • Mettre en œuvre des pratiques de partage de connaissances
  • Appliquer les principes SRE pour mesurer la satisfaction utilisateur
  • Concevoir des processus de collecte et d’analyse des retours utilisateurs
  • Implémenter l’analyse automatisée des applications
  • Gérer efficacement les alertes et adopter une culture d’amélioration continue

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

  • Télémétrie de requêtes : Durée, taux de réussite, dépendances
  • Télémétrie personnalisée : Événements et métriques spécifiques à l’application
  • Traces et exceptions : Journalisation des erreurs et problèmes
  • Utilisation : Utilisateurs, sessions, pages vues

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

  • CPU, mémoire, et utilisation du disque
  • Latence des requêtes et taux d’erreur
  • Files d’attente et messages traités
  • Trafic réseau et latence

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

  • Création de diagrammes de flux Sankey
  • Analyse des chemins de conversion
  • Identification des goulets d’étranglement

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

  • Configuration des pipelines de feedback
  • Création automatique d’éléments de travail à partir des incidents
  • Association des incidents aux versions spécifiques

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

  • Identification des causes profondes communes
  • Classification par impact utilisateur
  • Priorisation basée sur la fréquence et la gravité

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

  • Tableaux de bord d’équipe : Focus sur les sprints et les activités en cours
  • Tableaux de bord de projet : Vue d’ensemble de l’état du projet
  • Tableaux de bord d’état du système : Focus sur les métriques opérationnelles

11.5.1.2 Widgets essentiels

  • Burn-down / Burn-up charts
  • Velocity charts
  • Bug trends
  • Build status
  • Release status
  • Custom queries

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

  • Performance des applications
  • Disponibilité des services
  • Utilisation des ressources
  • Analyse des incidents
  • Trafic utilisateur

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

  • Utilisation de l’extension “Azure DevOps Analytics”
  • Création de visualisations personnalisées
  • Partage de rapports interactifs

11.5.3.2 Mesures clés à inclure

  • Cycle time
  • Lead time
  • MTTR (Mean Time To Recovery)
  • Taux de déploiement
  • Taux d’incidents

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

  • Utilisation de Markdown dans les dépôts Azure Repos
  • Documentation intégrée aux pipelines CI/CD
  • Génération automatique de documentation

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

  • Structure hiérarchique claire
  • Utilisation de tags pour la classification
  • Liens vers les éléments de travail pertinents

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

  • Confluence
  • SharePoint
  • GitHub Pages

11.6.3.2 Pratiques efficaces

  • Sessions de partage de connaissances régulières
  • Revues post-incidents documentées
  • Bibliothèque de solutions pour problèmes connus

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)

  • Disponibilité : % de temps où le service est opérationnel
  • Latence : Temps de réponse des requêtes
  • Débit : Nombre de requêtes traitées par seconde
  • Taux d’erreur : % de requêtes échouées

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)

  • Formalisation des engagements de service
  • Conséquences en cas de non-respect
  • Relation avec les SLO

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

  • Cartes de chaleur : Visualisation des zones d’intérêt
  • Enregistrements de session : Capture des parcours utilisateurs
  • Entonnoirs de conversion : Analyse des étapes clés

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

  • Formulaires de feedback in-app
  • Système de notation simple (étoiles, pouces)
  • Collecte automatique de contexte
// 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

  • Enquêtes NPS (Net Promoter Score)
  • Tickets de support
  • Évaluations dans les stores
  • Médias sociaux

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

  • Évolution du sentiment au fil du temps
  • Corrélation avec les déploiements
  • Identification des fonctionnalités critiques

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)

  • Profiling distribué
  • Traçage des transactions
  • Analyse des dépendances

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

  • Dette technique
  • Vulnérabilités de sécurité
  • Code smells
  • Couverture de tests
  • Duplication de code

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

  • Utilisation d’algorithmes de détection d’anomalies
  • Réduction du bruit par corrélation
  • Priorisation basée sur l’impact utilisateur
# 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

  • Définition de matrices de responsabilité
  • Escalade automatique
  • Rotation des astreintes

11.10.2 8.2 Rétrospectives irréprochables

11.10.2.1 Principes clés

  • Focus sur les systèmes, pas sur les individus
  • Recherche des causes profondes, pas des coupables
  • Apprentissage continu

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

  • Responsabilité partagée
  • Communication ouverte
  • Apprentissage continu
  • Sécurité psychologique

11.10.3.2 Mise en œuvre dans l’organisation

  • Formation à l’analyse des causes profondes
  • Reconnaissance des comportements positifs
  • Partage transparent des incidents
  • Support de la direction

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

  • Les SLI, SLO et SLA sont des concepts fondamentaux de la fiabilité des services
  • La rétroaction continue implique de collecter des données à plusieurs niveaux
  • Les rétrospectives irréprochables sont essentielles pour l’amélioration continue
  • L’automatisation de l’analyse est un pilier de DevOps moderne
  • La culture juste favorise l’innovation et la stabilité

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é