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 include due attività per l'uso di Kubernetes:

• Attività KubernetesManifest: bake e distribuzione di manifesti 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 la tracciabilità della distribuzione aggiunta, usare 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 di imagePullSecrets, manifesti bake e facilitare l'implementazione della strategia di distribuzione.

Nota

Sebbene i trigger di supporto della pipeline basata su YAML in un singolo repository Git, se è necessario un trigger per un file manifesto archiviato in un altro repository Git o se sono necessari trigger per Registro Azure Container o l'hub Docker, è consigliabile usare una pipeline classica anziché una pipeline basata su YAML.

È possibile usare l'azione bake nell'attività manifesto kubernetes per creare il bake dei modelli nei file manifesto di Kubernetes. L'azione consente di usare strumenti come Helm, Kustomize e Kompose. L'azione di bake dell'attività manifesto kubernetes offre visibilità sulla trasformazione tra i modelli di input e i file manifesto finali usati nelle distribuzioni. È possibile usare i file manifesto con bake downstream (nelle attività) come input per l'azione di distribuzione dell'attività 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 codice YAML seguente è un esempio di file manifesto da grafici 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 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à 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à manifesto kubernetes supporta attualmente 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 quindi aggiungere le risorse Kubernetes associate agli spazi dei nomi dei cluster Kubernetes.

• Servizio Azure Kubernetes
• Provider generico che usa l'account del 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 edit ClusterRole 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 a più cloud

L'esempio seguente illustra come eseguire distribuzioni parallele ai cluster in più cloud. In questo esempio sono presenti distribuzioni nei cluster servizio Azure Kubernetes, GKE, EKS e OpenShift. Questi quattro spazi dei nomi sono associati alle risorse Kubernetes nell'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/*