0Pricing
Cloud & IT Cert Prep · Lezione

Distribuzione continua in Azure

Estenda la pipeline con una fase di distribuzione che invii l'artefatto di compilazione a uno slot App Service, esegua smoke test e lo scambi con la produzione dopo l'approvazione.

Distribuzione continua in Azure è una lezione Cloud & IT Cert Prep gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Cloud & IT Cert Prep, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Cloud & IT Cert Prep include 4 lezioni in totale.

Che cos'è la continuous deployment?

La Continuous Deployment (CD) rilascia automaticamente in produzione ogni modifica che supera i test CI, senza intervento manuale. La Continuous Delivery è la variante più prudente: automatizza la distribuzione fino a un ambiente di staging e richiede l'approvazione di una persona prima della produzione. Entrambe le pratiche si basano sulla stessa infrastruttura di pipeline. In Azure Pipelines, la CD viene implementata aggiungendo stages di distribuzione dopo lo stage CI, indirizzati agli ambienti Azure con gli eventuali quality gate di approvazione.

Pipeline multi-stage: CI + CD

Una pipeline CI/CD completa comprende almeno tre stages: Build (compilazione, test e pubblicazione dell'artifact), Deploy to Staging (distribuzione dell'artifact in uno slot non di produzione) e Deploy to Production (scambio dello slot o distribuzione dopo l'approvazione). Gli stages passano l'artifact allo stage successivo tramite l'archiviazione degli artifact della pipeline. Lo stage di staging esegue automaticamente test di integrazione o smoke test; lo stage di produzione attende l'approvazione manuale prima di procedere.

# azure-pipelines.yml: multi-stage CI/CD
trigger:
  branches:
    include: [main]

pool:
  vmImage: ubuntu-latest

stages:
- stage: Build
  jobs:
  - job: BuildApp
    steps:
    - script: npm ci && npm run build
    - task: PublishPipelineArtifact@1
      inputs: {targetPath: dist, artifactName: webapp}

- stage: DeployStaging
  dependsOn: Build
  jobs:
  - deployment: StagingDeploy
    environment: Staging
    strategy:
      runOnce:
        deploy:
          steps:
          - task: AzureWebApp@1
            inputs: {appName: myapp-staging, package: '$(Pipeline.Workspace)/webapp'}

- stage: DeployProduction
  dependsOn: DeployStaging
  jobs:
  - deployment: ProductionDeploy
    environment: Production   # Has manual approval gate
    strategy:
      runOnce:
        deploy:
          steps:
          - task: AzureWebApp@1
            inputs: {appName: myapp, package: '$(Pipeline.Workspace)/webapp'}

Job di distribuzione e ambienti

Utilizzi job deployment (non il normale job) per gli stages di distribuzione. I job di deployment supportano strategie di distribuzione (runOnce, rolling, canary), tengono traccia della cronologia delle distribuzioni per ogni ambiente e devono fare riferimento agli Environments di Azure DevOps. Un ambiente registra quali esecuzioni della pipeline vi hanno effettuato una distribuzione, quale versione è attualmente attiva e fornisce in un'unica dashboard i quality gate di approvazione, i controlli e lo stato di integrità delle risorse.

# Deployment job with rolling strategy
- job: RollingDeploy
  strategy:
    rolling:
      maxParallel: 2     # Deploy to 2 targets at a time
      preDeploy:
        steps:
        - script: echo 'Pre-deploy checks'
      deploy:
        steps:
        - task: AzureWebApp@1
          inputs:
            appName: myapp
            package: '$(Pipeline.Workspace)/webapp'
      postRouteDeploy:
        steps:
        - script: curl -f https://myapp.azurewebsites.net/health

Distribuzione in Azure App Service

Il task AzureWebApp@1 distribuisce un'applicazione Web in Azure App Service. Supporta la distribuzione in uno slot specifico (ad esempio, staging) e la distribuzione di pacchetti ZIP, immagini Docker o file JAR/WAR. Dopo la distribuzione in uno slot di staging, utilizzi il task AzureAppServiceManage@0 per swap dello slot di staging in produzione: è il modello di distribuzione preferito per App Service quando si vuole evitare l'interruzione del servizio.

# Deploy to staging slot, then swap to production
steps:
- task: AzureWebApp@1
  displayName: 'Deploy to staging slot'
  inputs:
    azureSubscription: 'AzureProductionSC'
    appType: webAppLinux
    appName: myUniqueWebApp
    deployToSlotOrASE: true
    resourceGroupName: MyRG
    slotName: staging
    package: '$(Pipeline.Workspace)/webapp/app.zip'
    runtimeStack: 'NODE|18-lts'

- task: AzureAppServiceManage@0
  displayName: 'Swap staging into production'
  inputs:
    azureSubscription: 'AzureProductionSC'
    action: Swap Slots
    webAppName: myUniqueWebApp
    resourceGroupName: MyRG
    sourceSlot: staging

Smoke test nella pipeline CD

Dopo la distribuzione in staging, esegua gli smoke test, cioè un insieme minimo di test che verifica che la distribuzione sia riuscita e che l'applicazione risponda correttamente. Gli smoke test chiamano generalmente gli endpoint API principali e verificano i codici di stato e il contenuto della risposta attesi. Se gli smoke test hanno esito negativo, la pipeline si interrompe prima dello scambio verso la produzione o della richiesta di approvazione, impedendo che un rilascio non funzionante raggiunga gli utenti.

# Smoke test step after staging deployment
- script: |
    MAX_RETRY=10
    COUNT=0
    until curl -sf https://myUniqueWebApp-staging.azurewebsites.net/health; do
      COUNT=$((COUNT+1))
      if [ $COUNT -ge $MAX_RETRY ]; then
        echo 'Health check failed after $MAX_RETRY attempts'
        exit 1
      fi
      echo 'Waiting for app to start... attempt '$COUNT
      sleep 10
    done
    echo 'App is healthy'
  displayName: 'Smoke test: health endpoint'

Quality gate di approvazione dell'ambiente

Aggiunga quality gate di approvazione agli Environments di Azure DevOps per richiedere un'approvazione manuale prima di procedere con le distribuzioni. Acceda alle impostazioni dell'ambiente e aggiunga le approvazioni, specificando gli utenti o i gruppi che devono approvare. Quando la pipeline raggiunge un job di deployment indirizzato a quell'ambiente, si mette in pausa e invia una notifica via e-mail. Gli approvatori possono visualizzare i dettagli della distribuzione e approvare o rifiutare la richiesta nel portale Azure DevOps o tramite il link contenuto nell'e-mail di notifica.

# Pipeline YAML: deployment to production environment
# (Approval configured in Azure DevOps portal on 'Production' environment)
- stage: DeployProduction
  displayName: 'Deploy to Production'
  dependsOn: DeployStaging
  condition: succeeded('DeployStaging')
  jobs:
  - deployment: ProdDeploy
    environment: Production   # <-- Triggers approval gate configured in portal
    strategy:
      runOnce:
        deploy:
          steps:
          - task: AzureWebApp@1
            inputs:
              appName: myapp-prod
              package: '$(Pipeline.Workspace)/webapp/app.zip'

Distribuzione in Azure Kubernetes Service

Distribuisca le applicazioni containerizzate in AKS utilizzando il task KubernetesManifest@0. Questo task applica i manifest YAML di Kubernetes al cluster, con supporto integrato per imagePullSecrets e le distribuzioni canary. Si connetta al cluster AKS utilizzando una connessione al servizio Kubernetes configurata in Azure DevOps. Il task utilizza kubectl apply internamente e attende il completamento del rollout prima di contrassegnare lo step come completato correttamente.

# AKS deployment step in Azure Pipelines
- task: KubernetesManifest@0
  displayName: 'Deploy to AKS'
  inputs:
    action: deploy
    kubernetesServiceConnection: 'AKS-Production-SC'
    namespace: production
    manifests: |
      k8s/deployment.yaml
      k8s/service.yaml
    containers: 'mycontainerregistry.azurecr.io/myapp:$(Build.BuildId)'
    imagePullSecrets: acr-secret

Strategia di tagging delle immagini

Assegni alle immagini dei container il build ID ($(Build.BuildId)) o lo SHA del commit Git ($(Build.SourceVersion)), così da poter sempre risalire dal container in esecuzione all'esatta revisione del codice da cui è stato creato. Eviti di usare il tag latest in produzione: Kubernetes lo memorizza nella cache e potrebbe non scaricare la nuova versione. Memorizzi il tag specifico dell'immagine come variabile della pipeline e lo inserisca nei manifest Kubernetes al momento della distribuzione utilizzando envsubst o sed.

# Tag and push image with build ID in CI stage
- script: |
    IMAGE='mycontainerregistry.azurecr.io/myapp'
    TAG='$(Build.BuildId)'
    docker build -t $IMAGE:$TAG -t $IMAGE:latest .
    az acr login --name mycontainerregistry
    docker push $IMAGE:$TAG
    docker push $IMAGE:latest
    echo "##vso[task.setvariable variable=imageTag;isOutput=true]$TAG"
  name: BuildImage
  displayName: 'Build and push container image'

Strategie di rollback

Definisca una strategia di rollback per le distribuzioni in produzione, così potrà ripristinare rapidamente il servizio dopo un rilascio problematico. Per App Service, il rollback consiste nel riportare lo slot di produzione alla versione precedente dello staging. Per AKS, utilizzi kubectl rollout undo. Crei una pipeline di rollback dedicata oppure aggiunga un processo di rollback manuale che possa essere avviato dal portale Azure DevOps. Documenti la procedura di rollback e la eserciti regolarmente: un rollback non testato non è un rollback.

# Rollback job triggered manually
- job: Rollback
  condition: and(failed(), eq(variables['Build.Reason'], 'Manual'))
  steps:
  # App Service rollback: swap production back to previous
  - task: AzureAppServiceManage@0
    inputs:
      azureSubscription: 'AzureProductionSC'
      action: Swap Slots
      webAppName: myUniqueWebApp
      resourceGroupName: MyRG
      sourceSlot: production  # Swap production back to staging version
      targetSlot: staging

Notifiche e monitoraggio delle distribuzioni

Dopo ogni distribuzione in produzione, esegua automaticamente un controllo di monitoraggio per verificare che la nuova versione funzioni correttamente. Utilizzi il controllo di pipeline AzureMonitor@1 per interrogare le metriche di Azure Monitor: se il tasso di errori aumenta dopo la distribuzione, blocchi l'avanzamento della pipeline e avvii un rollback. Invii notifiche sulle distribuzioni a Microsoft Teams o Slack tramite attività webhook, così il team saprà quando una distribuzione è completata e quale versione è attiva.

# Send Teams notification on deployment completion
- task: InvokeRestAPI@1
  displayName: 'Notify Teams channel'
  inputs:
    connectionType: connectedServiceName
    serviceConnection: 'TeamsWebhookSC'
    method: POST
    body: '{
      "text": "Deployed **$(Build.BuildId)** to Production. Committed by $(Build.RequestedFor). <br>View: https://myapp.contoso.com"
    }'
    waitForCompletion: false

Best practice per il CD

Segua queste best practice per la distribuzione continua: distribuisca frequentemente (lotti di piccole dimensioni riducono i rischi), utilizzi i feature flag per separare la distribuzione dal rilascio, automatizzi tutti i quality gate prima della produzione, utilizzi uno staging simile alla produzione così che le differenze non nascondano i bug, monitori le finestre di distribuzione con controlli automatici dello stato e disponga sempre di un piano di rollback testato. Una pipeline CD matura rende la distribuzione un'operazione ordinaria anziché un'attività ad alto stress.

Verifica rapida

Verifichi la Sua comprensione dei concetti di Microsoft Azure Fundamentals (AZ-900) trattati in questa lezione.

Riepilogo della lezione

In questa lezione ha imparato che: le pipeline YAML multi-stage concatenano le fasi Build, Staging e Production trasferendo gli artifact, i processi di distribuzione con Environments consentono di configurare gate di approvazione e monitorare le distribuzioni e gli smoke test dopo la distribuzione nello staging impediscono ai rilasci non funzionanti di raggiungere la produzione. Ora esamineremo GitHub Actions in Azure.

Domande Frequenti

La lezione «Distribuzione continua in Azure» è gratuita?

Sì — il testo completo di «Distribuzione continua in Azure» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Cloud & IT Cert Prep, passa a CoddyKit PRO. Il corso Cloud & IT Cert Prep include 4 lezioni in totale.

Cosa imparerò in «Distribuzione continua in Azure»?

Estenda la pipeline con una fase di distribuzione che invii l'artefatto di compilazione a uno slot App Service, esegua smoke test e lo scambi con la produzione dopo l'approvazione. Eserciti Cloud & IT Cert Prep con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Cloud & IT Cert Prep?

Non è richiesta alcuna esperienza precedente. Cloud & IT Cert Prep su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Distribuzione continua in Azure»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Cloud & IT Cert Prep?

Sì. Ogni lezione Cloud & IT Cert Prep include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Panoramica di Azure DevOps Services
  2. Creazione di una pipeline CI con Azure Pipelines
  3. Distribuzione continua in Azure
  4. GitHub Actions su Azure
← Torna a Cloud & IT Cert Prep