Creare e distribuire un'applicazione multi-contenitore su servizio Azure Kubernetes

Usare Azure Pipelines per costruire e distribuire continuamente un’app multi-contenitore in Servizio Azure Kubernetes (AKS). In questo tutorial si distribuisce l'app Web Tailspin Space Game e l'API del tabellone punteggi come contenitori separati, si esegue il push di entrambe le immagini in Registro Azure Container e le si distribuisce nel servizio Azure Kubernetes usando manifest Kubernetes.

Prerequisiti

Prodotto	Requisiti
Azure DevOps	- Un'organizzazione e un progetto di Azure DevOps. Creane uno gratis. Autorizzazioni - : - Per concedere l'accesso a tutte le pipeline nel progetto: devi essere membro del gruppo Project Administrators. - Per creare connessioni al servizio: è necessario avere il ruolo Amministratore o Creator per le connessioni al servizio. Possibilità di eseguire pipeline su agenti ospitati da Microsoft. È possibile acquistare un incarico parallelo oppure richiedere un piano gratuito.
GitHub	- Un account GitHub .
Azure	- Una sottoscrizione di Azure .

Ottenere il codice

Effettua un fork del seguente repository nel tuo account GitHub:

https://github.com/MicrosoftDocs/mslearn-tailspin-spacegame-web-kubernetes

Creare le risorse di Azure

Usare Azure Cloud Shell per creare il cluster servizio Azure Kubernetes e Registro Azure Container.

Accedere a Azure portale quindi aprire Cloud Shell e selezionare Bash.

Impostare variabili riutilizzabili:

resourceSuffix=$RANDOM
registryName="tailspinspacegame${resourceSuffix}"
aksName="tailspinspacegame-${resourceSuffix}"
rgName='tailspin-space-game-rg'

(Facoltativo) Impostare un'area predefinita:

az account list-locations \
  --query "[].{Name: name, DisplayName: displayName}" \
  --output table

az configure --defaults location=westus2

Creare il gruppo di risorse, ACR e il cluster AKS.

az group create --name $rgName

az acr create \
  --name $registryName \
  --resource-group $rgName \
  --sku Standard

az aks create \
  --name $aksName \
  --resource-group $rgName \
  --enable-addons monitoring \
  --generate-ssh-keys

Consentire all'identità kubelet di AKS l'accesso pull ad ACR. Kubelet è l'agente del nodo che viene eseguito in ogni nodo Kubernetes ed esegue il pull delle immagini del contenitore in modo che i pod possano iniziare:

clientId=$(az aks show \
  --resource-group $rgName \
  --name $aksName \
  --query "identityProfile.kubeletidentity.clientId" \
  --output tsv)

acrId=$(az acr show \
  --name $registryName \
  --resource-group $rgName \
  --query "id" \
  --output tsv)

az role assignment create \
  --assignee $clientId \
  --role AcrPull \
  --scope $acrId

Trova il server di login di Azure Container Registry, copia il valore e conservalo per la sezione successiva in cui si imposta la variabile RegistryName nel gruppo di variabili pipeline.
```
az acr list \
  --resource-group $rgName \
  --query "[].{loginServer: loginServer}" \
  --output table
```

Configurare l'autenticazione in Azure DevOps

Prima di creare la pipeline, configurare l'autenticazione e le variabili condivise usate da Azure Pipelines per accedere alle risorse di Azure e al registro dei contenitori.

Nel progetto di Azure DevOps passare a Pipelines>Library.
Creare un gruppo di variabili denominato Release.
Aggiungere una variabile denominata RegistryName e impostare il valore sul server di accesso di Azure Container Registry, ad esempio tailspinspacegame4692.azurecr.io.
Creare queste connessioni al servizio:
- Connessione al servizio di Azure Resource Manager per l'abbonamento e il gruppo di risorse.
- Connessione al servizio Registro Docker per l'istanza ACR.

Creare la pipeline

In questa sezione viene creata una definizione di Azure Pipelines a più fasi che compila due immagini del contenitore, pubblica manifesti Kubernetes e distribuisce entrambi i servizi nel cluster servizio Azure Kubernetes.

Prima di incollare yaml, verificare che questi elementi esistano già nel progetto:

Gruppo di variabili denominato Release con RegistryName impostato sul server di accesso Registro Azure Container.
Una connessione al servizio del Registro di sistema Docker denominata Container Registry Connection.
Connessione al servizio Azure Resource Manager denominata Kubernetes Cluster Connection.

Accedere all'organizzazione di Azure DevOps e quindi passare al progetto.
Selezionare Pipeline e quindi Modifica.

Incollare il frammento di codice seguente nel file YAML e sostituire i valori segnaposto con i valori appropriati per l'ambiente:

trigger:
- 'main'

variables:
  buildConfiguration: 'Release'
  leaderboardRepository: 'leaderboard'
  webRepository: 'web'
  tag: '$(Build.BuildId)'
  imagePullSecret: 'secret'

stages:
- stage: Build
  displayName: Build the containers
  jobs:
  - job: Build
    pool:
      vmImage: 'ubuntu-latest'
    steps:
    - task: Docker@2
      displayName: Build and push the web image to container registry
      inputs:
        command: buildAndPush
        buildContext: $(Build.Repository.LocalPath)
        repository: $(webRepository)
        dockerfile: '$(Build.SourcesDirectory)/Tailspin.SpaceGame.Web/Dockerfile'
        containerRegistry: 'Container Registry Connection'
        tags: |
          $(tag)

    - task: Docker@2
      displayName: Build and push the leaderboard image to container registry
      inputs:
        command: buildAndPush
        buildContext: $(Build.Repository.LocalPath)
        repository: $(leaderboardRepository)
        dockerfile: '$(Build.SourcesDirectory)/Tailspin.SpaceGame.LeaderboardContainer/Dockerfile'
        containerRegistry: 'Container Registry Connection'
        tags: |
          $(tag)

    - publish: '$(Build.SourcesDirectory)/manifests'
      artifact: manifests

- stage: Deploy
  displayName: Deploy the containers
  dependsOn: Build
  jobs:
  - deployment: Deploy
    displayName: Deploy
    pool:
      vmImage: 'ubuntu-latest'
    environment: 'spike.default'
    variables:
    - group: Release
    strategy:
      runOnce:
        deploy:
          steps:
          - download: current
            artifact: manifests

          - task: KubernetesManifest@1
            displayName: Create imagePullSecret
            inputs:
              action: createSecret
              connectionType: azureResourceManager
              secretName: $(imagePullSecret)
              dockerRegistryEndpoint: 'Container Registry Connection'
              azureSubscriptionConnection: 'Kubernetes Cluster Connection'
              azureResourceGroup: 'tailspin-space-game-rg'
              kubernetesCluster: 'tailspinspacegame-24591'
              namespace: 'default'

          - task: KubernetesManifest@1
            displayName: Deploy to Kubernetes cluster
            inputs:
              action: deploy
              connectionType: azureResourceManager
              azureSubscriptionConnection: 'Kubernetes Cluster Connection'
              azureResourceGroup: 'tailspin-space-game-rg'
              kubernetesCluster: 'tailspinspacegame-24591'
              namespace: 'default'
              manifests: |
                $(Pipeline.Workspace)/manifests/deployment.yml
                $(Pipeline.Workspace)/manifests/service.yml
              imagePullSecrets: |
                $(imagePullSecret)
              containers: |
                $(RegistryName)/$(webRepository):$(tag)
                $(RegistryName)/$(leaderboardRepository):$(tag)

Suggerimento

YAML è sensibile agli spazi vuoti. Assicurarsi di mantenere il rientro coerente.

Come funziona la pipeline

Questa pipeline usa un modello di compilazione e distribuzione standard in due fasi.

Fase di compilazione:
Le due attività Docker@2 compilano e pubblicano le immagini web e leaderboard in Registro Azure Container.
I tag di immagine usano $(Build.BuildId) in modo che ogni esecuzione produa una versione tracciabile e univoca.
La cartella manifests viene pubblicata come artifatto della pipeline in modo che la fase di distribuzione possa usare gli stessi manifest su un agente diverso.
Fase di distribuzione:
Il processo di distribuzione è destinato all'ambiente di Azure DevOps configurato, che offre la cronologia di distribuzione e la visibilità a livello di ambiente.
Il download passaggio recupera l'artefatto manifests dall'esecuzione corrente.
KubernetesManifest@1 con createSecret crea un segreto di estrazione immagini nel namespace di destinazione in modo che i nodi del cluster possano autenticarsi presso Registro Azure Container.
KubernetesManifest@1 con deploy applica i manifesti Kubernetes e inserisce i riferimenti immagine di web e leaderboard per il tag di compilazione corrente.

Eseguire e convalidare la distribuzione

Usare questa sezione per verificare che la compilazione sia stata completata, che la distribuzione sia riuscita e che entrambi gli endpoint dell'applicazione siano raggiungibili dall'esterno del cluster.

In Azure DevOps aprire l'esecuzione della pipeline e confermare che entrambe le fasi siano state completate correttamente:
- Build Fase: conferma che entrambe le immagini sono state compilate e inviate ad Registro Azure Container.
- Deploy fase: conferma che i manifesti sono stati applicati e i pod sono stati aggiornati nel cluster servizio Azure Kubernetes.
Nel portale di Azure aprire il cluster servizio Azure Kubernetes e quindi selezionare Servizi e ingresso.
Trovare i web servizi e leaderboard e attendere che ogni servizio abbia un indirizzo IP esterno.
Aprire l'indirizzo IP esterno per il web servizio nel browser.
Copiare l'indirizzo IP esterno per il leaderboard servizio, quindi aprire l'endpoint seguente nel browser:
```
http://<external-ip>/api/Leaderboard?pageSize=10
```
Confermare i risultati della convalida:
- La pagina Web di Space Game viene caricata dall'endpoint del web servizio.
- L'endpoint del tabellone punteggi restituisce dati JSON dall'API leaderboard .

Pulire le risorse

Dopo aver completato questa esercitazione, eliminare il gruppo di risorse per evitare addebiti aggiuntivi. Eseguire il comando seguente per rimuovere il gruppo di risorse e tutte le risorse in esso contenute.

az group delete --name tailspin-space-game-rg

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-04-28