Exercices et Projets

---

1 - Exercices pratiques

Exercice 1 : Configuration initiale

Objectif : Créer une organisation et un projet Azure DevOps.

Tâches :

1. Créer une organisation sur dev.azure.com
2. Créer un projet "MyApp" avec le process Agile
3. Initialiser un repo avec un README
4. Configurer les branch policies sur main

Solution

# Installer Azure CLI et extension DevOps
az extension add --name azure-devops

# Se connecter
az login
az devops configure --defaults organization=https://dev.azure.com/MonOrg

# Créer le projet
az devops project create --name "MyApp" --process Agile --visibility private

# Configurer le projet par défaut
az devops configure --defaults project=MyApp

# Créer le repo (déjà créé avec le projet)
az repos list

# Configurer branch policy (via l'interface ou API)
# Project Settings > Repos > Policies > main

---

Exercice 2 : Pipeline CI

Objectif : Créer un pipeline CI pour une application Node.js.

Solution

# azure-pipelines.yml
trigger:
  - main
  - develop

pool:
  vmImage: 'ubuntu-latest'

variables:
  NODE_VERSION: '18.x'

stages:
  - stage: Build
    jobs:
      - job: BuildAndTest
        steps:
          - task: NodeTool@0
            inputs:
              versionSpec: $(NODE_VERSION)
            displayName: 'Install Node.js'
          
          - script: npm ci
            displayName: 'Install dependencies'
          
          - script: npm run lint
            displayName: 'Lint'
          
          - script: npm run build
            displayName: 'Build'
          
          - script: npm test -- --coverage --reporters=default --reporters=jest-junit
            displayName: 'Test'
          
          - task: PublishTestResults@2
            inputs:
              testResultsFormat: 'JUnit'
              testResultsFiles: '**/junit.xml'
            condition: always()
          
          - task: PublishCodeCoverageResults@1
            inputs:
              codeCoverageTool: 'Cobertura'
              summaryFileLocation: '$(System.DefaultWorkingDirectory)/coverage/cobertura-coverage.xml'
          
          - task: PublishBuildArtifacts@1
            inputs:
              pathToPublish: 'dist'
              artifactName: 'app'

---

Exercice 3 : Pipeline CD

Objectif : Ajouter des stages de déploiement avec approvals.

Solution

# Ajouter après le stage Build
stages:
  - stage: Build
    # ... (voir exercice 2)

  - stage: DeployDev
    dependsOn: Build
    jobs:
      - deployment: DeployToDev
        environment: 'Development'
        strategy:
          runOnce:
            deploy:
              steps:
                - download: current
                  artifact: app
                
                - task: AzureWebApp@1
                  inputs:
                    azureSubscription: 'Azure-Dev'
                    appType: 'webAppLinux'
                    appName: 'myapp-dev'
                    package: '$(Pipeline.Workspace)/app/**/*.zip'

  - stage: DeployProd
    dependsOn: DeployDev
    condition: eq(variables['Build.SourceBranch'], 'refs/heads/main')
    jobs:
      - deployment: DeployToProd
        environment: 'Production'  # Requires approval
        strategy:
          runOnce:
            deploy:
              steps:
                - download: current
                  artifact: app
                
                - task: AzureWebApp@1
                  inputs:
                    azureSubscription: 'Azure-Prod'
                    appType: 'webAppLinux'
                    appName: 'myapp-prod'
                    package: '$(Pipeline.Workspace)/app/**/*.zip'

---

Exercice 4 : Azure Boards

Objectif : Créer un sprint avec des work items.

Solution

# Créer une itération
az boards iteration project create \
    --name "Sprint 1" \
    --start-date 2024-01-15 \
    --finish-date 2024-01-29

# Créer une Epic
az boards work-item create \
    --type "Epic" \
    --title "Authentication System"

# Créer une Feature
az boards work-item create \
    --type "Feature" \
    --title "User Login" \
    --parent 1

# Créer des User Stories
az boards work-item create \
    --type "User Story" \
    --title "As a user, I want to login with email/password" \
    --parent 2 \
    --iteration "MyApp\Sprint 1"

az boards work-item create \
    --type "User Story" \
    --title "As a user, I want to reset my password" \
    --parent 2 \
    --iteration "MyApp\Sprint 1"

# Créer des Tasks
az boards work-item create \
    --type "Task" \
    --title "Create login form UI" \
    --parent 3

az boards work-item create \
    --type "Task" \
    --title "Implement authentication API" \
    --parent 3

---

2 - Projet complet : Application Web Full Stack

Architecture

Structure du projet

my-fullstack-app/
├── .azure/
│   ├── pipelines/
│   │   ├── ci.yml
│   │   ├── cd.yml
│   │   └── templates/
│   │       ├── build-template.yml
│   │       └── deploy-template.yml
│   └── boards/
│       └── work-item-template.json
├── frontend/
│   ├── package.json
│   ├── Dockerfile
│   └── src/
├── backend/
│   ├── package.json
│   ├── Dockerfile
│   └── src/
├── infrastructure/
│   └── kubernetes/
│       ├── deployment.yml
│       └── service.yml
└── README.md

Pipeline CI complet

# .azure/pipelines/ci.yml
trigger:
  branches:
    include:
      - main
      - develop
  paths:
    exclude:
      - README.md
      - docs/**

pr:
  branches:
    include:
      - main

variables:
  - group: 'CI-Variables'
  - name: dockerRegistry
    value: 'myacr.azurecr.io'

stages:
  - stage: Validate
    jobs:
      - job: Lint
        pool:
          vmImage: 'ubuntu-latest'
        steps:
          - script: npm run lint
            workingDirectory: frontend
          - script: npm run lint
            workingDirectory: backend

  - stage: Test
    dependsOn: Validate
    jobs:
      - job: FrontendTests
        pool:
          vmImage: 'ubuntu-latest'
        steps:
          - template: templates/build-template.yml
            parameters:
              workingDirectory: 'frontend'
              runTests: true

      - job: BackendTests
        pool:
          vmImage: 'ubuntu-latest'
        steps:
          - template: templates/build-template.yml
            parameters:
              workingDirectory: 'backend'
              runTests: true

  - stage: Build
    dependsOn: Test
    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
    jobs:
      - job: BuildImages
        pool:
          vmImage: 'ubuntu-latest'
        steps:
          - task: Docker@2
            inputs:
              containerRegistry: 'ACR-Connection'
              repository: 'frontend'
              command: 'buildAndPush'
              Dockerfile: 'frontend/Dockerfile'
              tags: |
                $(Build.BuildId)
                latest
          
          - task: Docker@2
            inputs:
              containerRegistry: 'ACR-Connection'
              repository: 'backend'
              command: 'buildAndPush'
              Dockerfile: 'backend/Dockerfile'
              tags: |
                $(Build.BuildId)
                latest

Pipeline CD

# .azure/pipelines/cd.yml
trigger: none

resources:
  pipelines:
    - pipeline: CI
      source: 'MyApp-CI'
      trigger: true

variables:
  - group: 'CD-Variables'

stages:
  - stage: DeployDev
    jobs:
      - deployment: Deploy
        environment: 'Development'
        strategy:
          runOnce:
            deploy:
              steps:
                - task: KubernetesManifest@0
                  inputs:
                    action: 'deploy'
                    kubernetesServiceConnection: 'AKS-Dev'
                    namespace: 'development'
                    manifests: |
                      infrastructure/kubernetes/*.yml
                    containers: |
                      $(dockerRegistry)/frontend:$(resources.pipeline.CI.runID)
                      $(dockerRegistry)/backend:$(resources.pipeline.CI.runID)

  - stage: DeployStaging
    dependsOn: DeployDev
    jobs:
      - deployment: Deploy
        environment: 'Staging'
        strategy:
          runOnce:
            deploy:
              steps:
                - task: KubernetesManifest@0
                  inputs:
                    action: 'deploy'
                    kubernetesServiceConnection: 'AKS-Staging'
                    namespace: 'staging'
                    manifests: |
                      infrastructure/kubernetes/*.yml

  - stage: DeployProduction
    dependsOn: DeployStaging
    jobs:
      - deployment: Deploy
        environment: 'Production'
        strategy:
          canary:
            increments: [10, 50]
            preDeploy:
              steps:
                - script: echo "Pre-deploy checks"
            deploy:
              steps:
                - task: KubernetesManifest@0
                  inputs:
                    action: 'deploy'
                    kubernetesServiceConnection: 'AKS-Prod'
                    namespace: 'production'
                    manifests: |
                      infrastructure/kubernetes/*.yml

---

3 - Quiz de révision

1. Quelle est la différence entre Azure Repos et GitHub ?

2. Quels sont les 5 services d'Azure DevOps ?

3. Comment sécuriser les secrets dans un pipeline ?

4. Qu'est-ce qu'une branch policy ?

5. Comment configurer des approvals de déploiement ?

Réponses

1. Azure Repos est le service Git intégré à Azure DevOps, avec intégration native aux autres services. GitHub est une plateforme indépendante mais peut être connecté à Azure Pipelines.

2. Azure Boards, Azure Repos, Azure Pipelines, Azure Artifacts, Azure Test Plans.

3. Utiliser des Variable Groups marqués comme secrets, Azure Key Vault, ou les secrets des Service Connections.

4. Règles appliquées aux branches (reviewers requis, build validation, etc.) pour protéger le code.

5. Dans Environments > Production > Approvals and checks, ajouter des Approvals avec les approbateurs.

---

4 - Certification Microsoft

Azure DevOps Engineer Expert (AZ-400)

Domaine	Poids
Design and implement processes and communications	10-15%
Design and implement source control	15-20%
Design and implement build and release pipelines	40-45%
Develop a security and compliance plan	10-15%
Implement an instrumentation strategy	10-15%

Ressources

• Microsoft Learn - AZ-400
• Azure DevOps Labs
• Documentation officielle

---

Résumé du cours

Félicitations ! Vous avez complété le cours Azure DevOps.

Vous maîtrisez maintenant :

• Azure Repos pour le contrôle de source
• Azure Boards pour la gestion de projet
• Azure Pipelines pour CI/CD
• Azure Artifacts pour les packages
• Azure Test Plans pour les tests
• Les bonnes pratiques de sécurité

Prochaines étapes

• Pratiquer avec des projets réels
• Passer la certification AZ-400
• Explorer les intégrations avec Azure Cloud
• Étudier GitHub Actions comme alternative

---

← Retour à la table des matières