0Pricing
Azure Fundamentals · Leçon

Flux de travail de développement de bout en bout

Reliez GitHub Actions CI/CD, Azure Container Registry, Container Apps et Application Insights pour créer une boucle interne complète, du commit jusqu’à la production observable.

Flux de travail de développement de bout en bout est une leçon Azure Fundamentals gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Azure Fundamentals, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Azure Fundamentals comprend 4 leçons au total.

La boucle moderne de développement Azure

Un flux de travail moderne de développement Azure relie le contrôle de code source, l'intégration et la livraison continues, l'infrastructure de conteneurs et l'observabilité en une boucle interne fluide, de la validation du code jusqu'à la production observable. Les principaux composants sont : GitHub (source), GitHub actions (chaîne de compilation et de déploiement), Azure Container Registry (stockage des images), Azure Container Apps (environnement d'exécution) et Application Insights (observabilité). Chaque modification passe automatiquement de l'ordinateur portable du développeur à la production en quelques minutes, avec des contrôles de qualité à chaque étape.

Étape 1 : contrôle du code source et stratégie de branches

Organisez votre code dans un référentiel GitHub en utilisant un développement basé sur le tronc ou une stratégie de branches GitFlow. Pour la plupart des microservices, le développement basé sur le tronc (branches de fonctionnalités à courte durée de vie fusionnées quotidiennement dans main) réduit les conflits d'intégration et maintient la chaîne simple. Utilisez des règles de protection des branches sur main pour exiger la révision des demandes d'extraction et la réussite des vérifications d'intégration continue avant la fusion. Un fichier CODEOWNERS garantit que les modifications apportées aux services critiques nécessitent l'approbation des ingénieurs expérimentés de l'équipe concernée.

# Example .github/CODEOWNERS
# Require payments-team review for any changes under /src/payments/
/src/payments/ @payments-team
/infrastructure/   @platform-team

Étape 2 : intégration continue avec GitHub Actions

La chaîne d'intégration continue s'exécute à chaque demande d'extraction. Un flux de travail courant est le suivant : extraire le code → restaurer les dépendances → exécuter les tests unitaires → exécuter les tests d'intégration → créer l'image Docker → envoyer l'image vers Azure Container Registry. L'image est étiquetée avec le SHA de la validation git pour assurer sa traçabilité. Utilisez l'authentification basée sur OIDC de GitHub Actions vers Azure (via une identité fédérée) afin d'éviter de stocker des secrets de principaux de service Azure dans GitHub : il s'agit d'un équivalent d'identité managée pour les chaînes d'intégration continue.

# .github/workflows/ci.yml (abbreviated)
name: CI
on: [pull_request]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Login to ACR
        uses: azure/docker-login@v1
        with:
          login-server: myacr.azurecr.io
          username: ${{ secrets.AZURE_CLIENT_ID }}
          password: ${{ secrets.AZURE_CLIENT_SECRET }}
      - name: Build and push image
        run: |
          docker build -t myacr.azurecr.io/myapi:${{ github.sha }} .
          docker push myacr.azurecr.io/myapi:${{ github.sha }}

Étape 3 : livraison continue vers la préproduction

Une fois la chaîne d'intégration continue réussie après une fusion dans main, la chaîne de livraison continue déploie automatiquement l'application dans l'environnement de préproduction. La chaîne met à jour l'étiquette d'image de l'application Container Apps avec le SHA qui vient d'être créé, attend que la nouvelle révision soit saine, puis exécute des tests de bon fonctionnement sur l'URL de préproduction. Ces tests vérifient que les points de terminaison d'API critiques renvoient les réponses attendues. Si les tests échouent, la chaîne annule le déploiement en redirigeant le trafic d'entrée vers la révision précédente, sans intervention manuelle.

# CD stage: update Container App to new image
- name: Deploy to staging
  uses: azure/cli@v2
  with:
    azcliversion: latest
    inlineScript: |
      az containerapp update \
        --name myapi-staging \
        --resource-group myRG \
        --image myacr.azurecr.io/myapi:${{ github.sha }}

- name: Run smoke tests
  run: |
    STAGING_URL=$(az containerapp show --name myapi-staging \
      --resource-group myRG \
      --query 'properties.configuration.ingress.fqdn' -o tsv)
    curl -f https://$STAGING_URL/health || exit 1

Étape 4 : porte d'approbation pour la production

Après la validation de la préproduction, la chaîne de livraison continue s'interrompt sur une porte d'approbation. Les protections d'environnement de GitHub Actions vous permettent de configurer les réviseurs requis pour l'environnement production. La chaîne envoie une notification Slack à l'ingénieur d'astreinte, qui examine les résultats des tests de préproduction, les différences et les incidents ouverts avant d'approuver. Ce n'est qu'après l'approbation que la chaîne poursuit le déploiement de la même image identifiée par le SHA en production. Cette étape avec intervention humaine est essentielle pour les services à fort trafic ou soumis à une réglementation.

# In GitHub: create 'production' environment with required reviewers
# .github/workflows/cd.yml (abbreviated)
jobs:
  deploy-production:
    environment:
      name: production
      url: https://myapi.contoso.com
    needs: deploy-staging
    steps:
      - name: Deploy to production
        uses: azure/cli@v2
        with:
          inlineScript: |
            az containerapp update \
              --name myapi \
              --resource-group myRG \
              --image myacr.azurecr.io/myapi:${{ github.sha }}

Étape 5 : observabilité de la production

Une fois le déploiement effectué en production, Application Insights fournit une visibilité en temps réel. Le SDK App Insights (ou l'instrumentation automatique pour les environnements d'exécution pris en charge) suit : les taux de requêtes, taux d'échec et latences (les trois signaux clés), les appels aux dépendances (bases de données, Service Bus et autres API), ainsi que les exceptions avec leurs traces de pile complètes. L'Application Map visualise la manière dont les services s'appellent entre eux et met en évidence les dépendances qui contribuent le plus aux échecs ou à la latence.

# Python: Add Application Insights SDK
from opencensus.ext.azure.log_exporter import AzureLogHandler
from opencensus.ext.azure.trace_exporter import AzureExporter
from opencensus.trace.samplers import ProbabilitySampler
from opencensus.trace.tracer import Tracer

tracer = Tracer(
  exporter=AzureExporter(connection_string='InstrumentationKey=<key>'),
  sampler=ProbabilitySampler(1.0)
)

Relier les déploiements aux traces

Utilisez les Annotations Application Insights pour marquer les événements de déploiement sur vos graphiques de métriques. Lorsqu'une annotation de mise à disposition est créée (via l'action azure/appinsights-annotation de GitHub Actions), elle apparaît sous la forme d'une ligne verticale sur tous les graphiques de métriques App Insights. Vous voyez ainsi immédiatement si un pic de latence ou une hausse du taux d'erreur est corrélé à un déploiement récent, ce qui réduit considérablement le temps moyen de diagnostic (MTTD) pendant les incidents.

# Create a release annotation in Application Insights
- name: Annotate release in App Insights
  uses: azure/appinsights-annotation@v1
  with:
    appInsightsResourceName: myAppInsights
    resourceGroupName: myRG
    releaseName: '${{ github.run_id }}-${{ github.sha }}'

Annulation automatique en cas de pic du taux d'erreur

Pour les chaînes les plus résilientes, mettez en œuvre une annulation automatique. Après le déploiement en production, la chaîne attend 10 minutes, puis interroge Application Insights afin d'obtenir le taux d'erreur. Si celui-ci dépasse un seuil configurable (par exemple, >5 %), la chaîne annule automatiquement le déploiement en redirigeant le trafic d'entrée de Container Apps à 100 % vers la révision précédente. Ce modèle de livraison progressive réduit l'ampleur des conséquences d'un mauvais déploiement et permet aux équipes de déployer en toute confiance, même pour des modifications complexes ou sensibles.

# Query App Insights error rate via REST (abbreviated)
QUERY='requests | where timestamp > ago(10m) | summarize failed = countif(success == false), total = count() | extend errorRate = round(100.0 * failed / total, 2)'
RESULT=$(az monitor app-insights query \
  --apps myAppInsights \
  --resource-group myRG \
  --analytics-query "$QUERY" \
  --query 'tables[0].rows[0][2]' -o tsv)
if [ $(echo '$RESULT > 5' | bc -l) -eq 1 ]; then
  echo 'Error rate $RESULT% - rolling back!'
  az containerapp ingress traffic set --name myapi --resource-group myRG --revision-weight stable=100
fi

Productivité des développeurs : développement local avec des émulateurs

Les développeurs doivent pouvoir exécuter et tester localement l'ensemble de la pile sans se connecter aux ressources Azure de production. Utilisez Azure Storage Emulator (Azurite) pour le stockage local d'objets blob et de files d'attente, Cosmos DB Emulator pour les tests de base de données locaux et Service Bus Emulator pour la messagerie locale. La variable d'environnement AZURE_ENVIRONMENT=local peut faire basculer DefaultAzureCredential vers l'utilisation de chaînes de connexion pointant vers les émulateurs, tandis que le même code utilise une identité managée dans Azure. Docker Compose orchestre toutes les dépendances locales avec une seule commande docker compose up.

# docker-compose.yml for local development
services:
  azurite:
    image: mcr.microsoft.com/azure-storage/azurite
    ports:
      - '10000:10000'
      - '10001:10001'
  cosmos-emulator:
    image: mcr.microsoft.com/cosmosdb/linux/azure-cosmos-emulator
    ports:
      - '8081:8081'

Sécurité dans le flux de travail du développeur

Intégrez la sécurité à chaque étape du flux de travail du développeur : Dependabot recherche les dépendances vulnérables dans les demandes d'extraction ; GitHub Advanced Security (analyse du code avec CodeQL) détecte les vulnérabilités telles que les injections SQL et les secrets codés en dur ; Microsoft Defender for DevOps s'intègre à GitHub pour présenter les recommandations de sécurité Azure à côté des modifications du code ; et l'analyse des vulnérabilités par ACR Defender vérifie les images de conteneurs à la recherche de CVE affectant le système d'exploitation ou la couche applicative après chaque envoi. Les résultats de sécurité apparaissent sous forme de commentaires dans les demandes d'extraction et peuvent donc être traités avant la fusion.

Tout assembler

Le flux de travail complet du développeur forme une boucle de rétroaction continue : un développeur valide du code, l'intégration continue crée et teste l'image du conteneur, l'image est envoyée vers ACR avec le SHA de la validation comme étiquette, la livraison continue déploie en préproduction et exécute les tests de bon fonctionnement, une personne approuve le déploiement en production, la chaîne déploie en production et crée une annotation de mise à disposition, puis Application Insights surveille les taux d'erreur et déclenche une annulation automatique si les seuils sont dépassés. L'infrastructure en tant que code (Bicep ou Terraform) du même référentiel garantit que la chaîne, l'application Container Apps et la configuration de surveillance sont toutes gérées par versions avec le code de l'application.

Vérification rapide

Vérifiez votre compréhension des concepts de Microsoft Azure Fundamentals (AZ-900) présentés dans cette leçon.

Récapitulatif de la leçon

Dans cette leçon, vous avez appris que le flux de travail de développement de bout en bout relie le contrôle du code source GitHub, l'intégration et la livraison continues avec GitHub Actions, Azure Container Registry, Container Apps et Application Insights ; que les annotations de mise à disposition corrèlent les déploiements avec les évolutions des métriques pour accélérer le diagnostic des incidents ; et que l'annulation automatique fondée sur les requêtes de taux d'erreur réduit l'ampleur des conséquences des mauvais déploiements. Nous allons maintenant passer à la préparation de l'examen avec une révision complète des concepts du cloud et de l'architecture Azure.

Questions Fréquemment Posées

La leçon « Flux de travail de développement de bout en bout » est-elle gratuite ?

Oui — le texte complet de « Flux de travail de développement de bout en bout » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Azure Fundamentals, passe à CoddyKit PRO. Le cours Azure Fundamentals comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Flux de travail de développement de bout en bout » ?

Reliez GitHub Actions CI/CD, Azure Container Registry, Container Apps et Application Insights pour créer une boucle interne complète, du commit jusqu’à la production observable. Tu pratiques Azure Fundamentals avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Azure Fundamentals ?

Aucune expérience préalable n'est requise. Azure Fundamentals sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Flux de travail de développement de bout en bout » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Azure Fundamentals ?

Oui. Chaque leçon Azure Fundamentals inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Identité managée pour une authentification sans mot de passe
  2. Azure Service Bus pour une messagerie découplée
  3. Azure Container Apps
  4. Flux de travail de développement de bout en bout
← Retour à Azure Fundamentals