Eseguire la distribuzione in Kubernetes

Azure DevOps Services | Azure DevOps Server 2022

È possibile usare Azure Pipelines per la distribuzione in servizio Azure Kubernetes e cluster Kubernetes offerti da altri provider di servizi cloud. Azure Pipelines ha due attività per lavorare con Kubernetes:

• Attività KubernetesManifest: preparare e distribuire manifest nei cluster Kubernetes con Helm, Kompose o Kustomize
• Attività Kubectl: distribuire, configurare e aggiornare un cluster Kubernetes nel servizio Azure Container eseguendo comandi kubectl

Se si usa servizio Azure Kubernetes con una delle due attività, il tipo di connessione del servizio Azure Resource Manager è il modo migliore per connettersi a un cluster privato o un cluster con account locali disabilitati.

Per una maggiore tracciabilità della distribuzione, utilizzare una risorsa Kubernetes in ambienti con un'attività Kubernetes.

Per iniziare a usare Azure Pipelines e il servizio Azure Kubernetes, vedere Creare e distribuire in servizio Azure Kubernetes con Azure Pipelines. Per iniziare a usare Azure Pipelines, Kubernetes e la strategia di distribuzione canary in modo specifico, vedere Usare una strategia di distribuzione canary per le distribuzioni Kubernetes con Azure Pipelines.

Attività KubernetesManifest

L'attività KubernetesManifest verifica la stabilità degli oggetti prima di contrassegnare un'attività come operazione riuscita/errore. L'attività può anche eseguire la sostituzione degli artefatti, aggiungere annotazioni correlate alla tracciabilità della pipeline, semplificare la creazione e il riferimento degli imagePullSecrets, preparare i manifesti e facilitare l'attuazione delle strategie di distribuzione.

Nota

Sebbene i trigger della pipeline basata su YAML supportino un singolo repository Git, se è necessario un trigger per un file manifesto archiviato in un altro repository Git o se sono necessari trigger per Azure Container Registry o Docker Hub, è consigliabile usare una pipeline classica anziché una pipeline basata su YAML.

È possibile utilizzare l'azione bake nell'attività Kubernetes manifest task per convertire i modelli in file manifesto Kubernetes. L'azione consente di usare strumenti come Helm, Kustomize e Kompose. L'azione di bake dell'attività manifesti di Kubernetes offre visibilità sulla trasformazione tra i modelli di input e i file dei manifesti finali utilizzati nelle distribuzioni. È possibile utilizzare i file manifesto preconfigurati a valle (nelle attività) come input per l'azione di distribuzione del compito manifesto Kubernetes.

È possibile specificare come destinazione risorse Kubernetes che fanno parte di ambienti con processi di distribuzione. L'uso degli ambienti e della distribuzione delle risorse consente di accedere a una migliore tracciabilità delle pipeline in modo da poter diagnosticare i problemi di distribuzione. È anche possibile eseguire la distribuzione nei cluster Kubernetes con processi regolari senza le stesse funzionalità di integrità.

Il seguente codice YAML è un esempio di generazione di file manifesto da chart Helm.

steps:
- task: KubernetesManifest@0
  name: bake
  displayName: Bake K8s manifests from Helm chart
  inputs:
    action: bake
    helmChart: charts/sample
    overrides: 'image.repository:nginx'

- task: KubernetesManifest@0
  displayName: Deploy K8s manifests
  inputs:
    kubernetesServiceConnection: someK8sSC
    namespace: default
    manifests: $(bake.manifestsBundle)
    containers: |
      nginx: 1.7.9

Attività Kubectl

In alternativa all'attività KubernetesManifest, è possibile usare l'attività Kubectl per distribuire, configurare e aggiornare un cluster Kubernetes nel servizio Azure Container eseguendo i comandi kubectl.

L'esempio seguente illustra come viene usata una connessione al servizio per fare riferimento al cluster Kubernetes.

- task: Kubernetes@1
  displayName: kubectl apply
  inputs:
    connectionType: Kubernetes Service Connection
    kubernetesServiceEndpoint: Contoso

Attività di Script

È anche possibile usare kubectl con un'attività script.

Nell'esempio seguente viene usato uno script per eseguire kubectl.

- script: |
    kubectl apply -f manifest.yml

Strategie di distribuzione di Kubernetes

L'attività Manifest Kubernetes attualmente supporta la strategia di distribuzione Canary. Usare la strategia di distribuzione canary per distribuire parzialmente nuove modifiche in modo che le nuove modifiche coesistono con le distribuzioni correnti prima di un'implementazione completa.

Per altre informazioni sulle distribuzioni canary con pipeline, vedere Usare una strategia di distribuzione canary per le distribuzioni Kubernetes con Azure Pipelines.

Distribuzioni Kubernetes multicloud

Kubernetes esegue lo stesso modo in tutti i provider di servizi cloud. Azure Pipelines può essere usato per la distribuzione in servizio Azure Kubernetes (AKS), Google Kubernetes Engine (GKE), Amazon Elastic Kubernetes Service (EKS) o cluster di qualsiasi altro provider di servizi cloud.

Per configurare la distribuzione multicloud, creare un ambiente e poi aggiungere le risorse Kubernetes che sono associate ai namespace dei cluster Kubernetes.

• Servizio Azure Kubernetes
• Provider generico che usa l'account di servizio esistente

L'approccio del provider generico basato sull'account del servizio esistente funziona con i cluster di qualsiasi provider di servizi cloud, incluso Azure. Il vantaggio dell'uso dell'opzione servizio Azure Kubernetes consiste nel fatto che crea nuovi oggetti ServiceAccount e RoleBinding (anziché riutilizzare un ServiceAccount esistente) in modo che l'oggetto RoleBinding appena creato possa limitare le operazioni di ServiceAccount solo allo spazio dei nomi scelto.

Quando si usa l'approccio del provider generico, assicurarsi che esista un RoleBinding, che concede le autorizzazioni nell'account editClusterRole del servizio desiderato. È necessario concedere le autorizzazioni all'account di servizi appropriato in modo che l'account del servizio possa essere usato da Azure Pipelines per creare oggetti nello spazio dei nomi scelto.

Distribuzioni parallele su più cloud

L'esempio seguente mostra come fare una distribuzione parallela ai cluster su più cloud. In questo esempio, ci sono distribuzioni nei cluster AKS, GKE, EKS e OpenShift. Questi quattro namespace sono associati alle risorse Kubernetes dell'ambiente contoso.

trigger:
- main

jobs:
- deployment:
  displayName: Deploy to AKS
  pool:
    vmImage: ubuntu-latest
  environment: contoso.aksnamespace
  strategy:
    runOnce:
      deploy:
        steps:
        - checkout: self
        - task: KubernetesManifest@0
          displayName: Deploy to Kubernetes cluster
          inputs:
            action: deploy
            kubernetesServiceConnection: serviceConnection #replace with your service connection
            namespace: aksnamespace
            manifests: manifests/*
- deployment:
  displayName: Deploy to GKE
  pool:
    vmImage: ubuntu-latest
  environment: contoso.gkenamespace
  strategy:
    runOnce:
      deploy:
        steps:
        - checkout: self
        - task: KubernetesManifest@0
          displayName: Deploy to Kubernetes cluster
          inputs:
            action: deploy
            kubernetesServiceConnection: serviceConnection #replace with your service connection
            namespace: gkenamespace
            manifests: manifests/*
- deployment:
  displayName: Deploy to EKS
  pool:
    vmImage: ubuntu-latest
  environment: contoso.eksnamespace
  strategy:
    runOnce:
      deploy:
        steps:
        - checkout: self
        - task: KubernetesManifest@0
          displayName: Deploy to Kubernetes cluster
          inputs:
            action: deploy
            kubernetesServiceConnection: serviceConnection #replace with your service connection
            namespace: eksnamespace
            manifests: manifests/*
- deployment:
  displayName: Deploy to OpenShift
  pool:
    vmImage: ubuntu-latest
  environment: contoso.openshiftnamespace
  strategy:
    runOnce:
      deploy:
        steps:
        - checkout: self
        - task: KubernetesManifest@0
          displayName: Deploy to Kubernetes cluster
          inputs:
            action: deploy
            kubernetesServiceConnection: serviceConnection #replace with your service connection
            namespace: openshiftnamespace
            manifests: manifests/*
- deployment:
  displayName: Deploy to DigitalOcean
  pool:
    vmImage: ubuntu-latest
  environment: contoso.digitaloceannamespace
  strategy:
    runOnce:
      deploy:
        steps:
        - checkout: self
        - task: KubernetesManifest@0
          displayName: Deploy to Kubernetes cluster
          inputs:
            action: deploy
            kubernetesServiceConnection: serviceConnection #replace with your service connection
            namespace: digitaloceannamespace
            manifests: manifests/*