Compilare e distribuire al servizio Azure Kubernetes con Azure Pipelines

Articolo
02/04/2025

Servizi di Azure DevOps

Usare Azure Pipelines per eseguire automaticamente la distribuzione nel servizio Azure Kubernetes (AKS). Azure Pipelines consente di creare, testare e distribuire integrazione continua (CI, continuous integration) e recapito continuo (CD, continuous delivery) tramite Azure DevOps.

Questo articolo illustra come creare una pipeline che compila e distribuisce continuamente l'app. Ogni volta che si modifica il codice in un repository che contiene un Dockerfile, viene effettuato il push delle immagini nel Registro Azure Container e i manifesti vengono quindi distribuiti nel cluster del servizio Azure Kubernetes.

Prerequisiti

Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.
Una connessione al servizio Azure Resource Manager. Creare una connessione al servizio Azure Resource Manager.
Un account GitHub. Creare un account GitHub gratuito, se non ne è già disponibile uno.

Ottenere il codice

Creare una copia tramite fork del repository seguente contenente un'applicazione di esempio e un Dockerfile:

https://github.com/MicrosoftDocs/pipelines-javascript-docker

Creare le risorse di Azure

Accedere al portale di Azure e quindi selezionare il pulsante Cloud Shell nell'angolo in alto a destra. Usare l'interfaccia della riga di comando di Azure o PowerShell per creare un cluster del servizio Azure Kubernetes.

Creare un registro contenitori

Interfaccia della riga di comando di Azure
PowerShell

# Create a resource group
az group create --name myapp-rg --location eastus

# Create a container registry
az acr create --resource-group myapp-rg --name mycontainerregistry --sku Basic

# Create a Kubernetes cluster
az aks create \
    --resource-group myapp-rg \
    --name myapp \
    --node-count 1 \
    --enable-addons monitoring \
    --generate-ssh-keys

# Install Azure PowerShell
Install-Module -Name Az -Repository PSGallery -Force

# The Microsoft.OperationsManagement resource provider must be registered. This is a one-time activity per subscription.
Register-AzResourceProvider -ProviderNamespace Microsoft.OperationsManagement

# Create a resource group
New-AzResourceGroup -Name myapp-rg -Location eastus

# Create a container registry
New-AzContainerRegistry -ResourceGroupName myapp-rg -Name myContainerRegistry -Sku Basic -Location eastus

# Create a log analytics workspace (or use an existing one)
New-AzOperationalInsightsWorkspace -ResourceGroupName myapp-rg -Name myWorkspace -Location eastus

# Create an AKS cluster with monitoring add-on enabled
$aksParameters = @{ 
  ResourceGroupName = 'myapp-rg'
  Name = 'myapp'
  NodeCount = 1
  AddOnNameToBeEnabled = 'Monitoring'
  GenerateSshKey = $true
  WorkspaceResourceId = '/subscriptions/<subscription-id>/resourceGroups/myapp-rg/providers/Microsoft.OperationalInsights/workspaces/myWorkspace'
}

New-AzAksCluster @aksParameters

Accedere ad Azure Pipelines. Dopo l'accesso, il browser passa a https://dev.azure.com/my-organization-name e visualizza il dashboard di Azure DevOps.

All'interno dell'organizzazione selezionata creare un progetto. Se non sono presenti progetti nell'organizzazione, viene visualizzata la schermata Crea un progetto per iniziare. In caso contrario, selezionare il pulsante Crea progetto nell'angolo superiore destro del dashboard.

Creare la pipeline

Connettersi e selezionare il repository

Accedere all'organizzazione di Azure DevOps e passare al progetto.
Passare a Pipeline e quindi selezionare Nuova pipeline.
Eseguire i passaggi della procedura guidata selezionando prima di tutto GitHub come posizione del codice sorgente.
Si potrebbe essere reindirizzati a GitHub per l'accesso. In questo caso, immettere le credenziali di GitHub.
Quando si vede l’elenco dei repository, selezionarne uno.
È possibile che si venga reindirizzati a GitHub per installare l'app Azure Pipelines. In tal caso, selezionare Approva e installa.
Selezionare Distribuisci servizio Azure Kubernetes.
Se richiesto, selezionare la sottoscrizione in cui è stato creato il registro e il cluster.
Selezionare il cluster myapp.
In Spazio dei nomi selezionare Esistente e quindi selezionare predefinito.
Selezionare il nome del registro contenitori.
È possibile lasciare il nome dell'immagine impostato sul valore predefinito.
Impostare la porta del servizio su 8080.
Impostare la casella di controllo Abilita verifica app per le richieste pull per includere la configurazione relativa all'applicazione di revisione nello YAML della pipeline generato automaticamente nei passaggi successivi.
Selezionare Convalida e configura.

Man mano che Azure Pipelines crea la pipeline, il processo:
- Creare una connessione al servizio registro Docker per consentire alla pipeline di eseguire il push delle immagini nel registro contenitori.
- Creare un ambiente e una risorsa Kubernetes all'interno dell'ambiente. Per un cluster abilitato per il controllo degli accessi in base al ruolo (RBAC), la risorsa Kubernetes creata crea in modo implicito oggetti ServiceAccount e RoleBinding nel cluster in modo che il ServiceAccount creato non possa eseguire operazioni esterne allo spazio dei nomi scelto.
- Generare un file azure-pipelines.yml, che definisce la pipeline.
- Scaricare i file manifesto Kubernetes Questi file vengono generati idratando i modelli di deployment.yml e service.yml in base alle selezioni effettuate. Quando si è pronti, selezionare Salva ed esegui.
Seleziona Salva ed Esegui.
È possibile modificare il messaggio Commit in modo che sia simile ad Aggiungi pipeline al repository. Quando si è pronti, selezionare Salva ed esegui per eseguire il commit della nuova pipeline nel repository e quindi iniziare la prima esecuzione della nuova pipeline.

Visualizzare la distribuzione dell'app

Durante l'esecuzione della pipeline, osservare come fase di compilazione e quindi la fase di distribuzione passare da blu (in esecuzione) a verde (completato). È possibile selezionare le fasi e i processi per controllare la pipeline in azione.

Nota

Se si usa un agente ospitato da Microsoft, è necessario aggiungere l'intervallo IP dell'agente ospitato da Microsoft al firewall. Ottenere l'elenco settimanale degli intervalli IP dal file JSON settimanale, pubblicato ogni mercoledì. I nuovi intervalli IP diventano effettivi il lunedì seguente. Per altre informazioni, vedere Agenti ospitati da Microsoft. Per trovare gli intervalli IP necessari per l'organizzazione di Azure DevOps, vedere come identificare gli intervalli IP possibili per gli agenti ospitati da Microsoft.

Al termine dell'esecuzione della pipeline, esaminare cosa è successo e quindi vedere l'app distribuita. Dal riepilogo della pipeline:

Fare clic sulla scheda Ambienti.
Selezionare Visualizza ambiente.
Selezionare l'istanza dell'app per lo spazio dei nomi distribuito in. Se sono state usate le impostazioni predefinite, si tratta dell'app myapp nello spazio dei nomi predefinito.
Selezionare la scheda Servizi.
Selezionare e copiare l'indirizzo IP esterno negli Appunti.
Aprire una nuova scheda o finestra del browser e immettere <l'indirizzo IP>:8080.

Se stai creando l'app di esempio, hello world viene visualizzato nel browser.

Compilazione della pipeline

Dopo aver selezionato le opzioni e aver completato la convalida e la configurazione della pipeline Azure Pipelines ha creato automaticamente una pipeline usando il modello Distribuisci nel servizio Azure Kubernetes.

La fase di compilazione usa l'attività Docker per compilare ed eseguire il push dell'immagine nel Registro Azure Container.

- stage: Build
  displayName: Build stage
  jobs:  
  - job: Build
    displayName: Build job
    pool:
      vmImage: $(vmImageName)
    steps:
    - task: Docker@2
      displayName: Build and push an image to container registry
      inputs:
        command: buildAndPush
        repository: $(imageRepository)
        dockerfile: $(dockerfilePath)
        containerRegistry: $(dockerRegistryServiceConnection)
        tags: |
          $(tag)
          
    - task: PublishPipelineArtifact@1
      inputs:
        artifactName: 'manifests'
        path: 'manifests'

Il processo di distribuzione usa l'attività Manifesto Kubernetes per creare il imagePullSecret richiesto dai nodi del cluster Kubernetes per eseguire il pull dalla risorsa registro Azure Container. I file manifesto vengono quindi usati dall'attività manifesto kubernetes per la distribuzione nel cluster Kubernetes. I file manifesto service.yml e deployment.yml sono stati generati quando è stato usato il modello Distribuisci nel servizio Azure Kubernetes.

- stage: Deploy
  displayName: Deploy stage
  dependsOn: Build
  jobs:
  - deployment: Deploy
    displayName: Deploy job
    pool:
      vmImage: $(vmImageName)
    environment: 'myenv.aksnamespace' #customize with your environment
    strategy:
      runOnce:
        deploy:
          steps:
          - task: DownloadPipelineArtifact@2
            inputs:
              artifactName: 'manifests'
              downloadPath: '$(System.ArtifactsDirectory)/manifests'

          - task: KubernetesManifest@1
            displayName: Create imagePullSecret
            inputs:
              action: 'createSecret'
              connectionType: 'kubernetesServiceConnection'
              kubernetesServiceConnection: 'myapp-default' #customize for your Kubernetes service connection
              secretType: 'dockerRegistry'
              secretName: '$(imagePullSecret)'
              dockerRegistryEndpoint: '$(dockerRegistryServiceConnection)'

          - task: KubernetesManifest@1
            displayName: Deploy to Kubernetes cluster
            inputs:
              action: 'deploy'
              connectionType: 'kubernetesServiceConnection'
              kubernetesServiceConnection: 'myapp-default' #customize for your Kubernetes service connection
              manifests: |
                $(Pipeline.Workspace)/manifests/deployment.yml
                $(Pipeline.Workspace)/manifests/service.yml
              containers: '$(containerRegistry)/$(imageRepository):$(tag)'
              imagePullSecrets: '$(imagePullSecret)'

Pulire le risorse

Al termine delle risorse create, è possibile usare il comando seguente per eliminarle:

az group delete --name myapp-rg

Immettere y quando viene richiesto.

Condividi tramite