Condividi tramite

Distribuire in Kubernetes

Azure DevOps Services | Azure DevOps Server 2022

Usare Azure Pipelines per la distribuzione nel servizio Azure Kubernetes e nei 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 il 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 a un cluster con account locali disabilitati.

Per una maggiore tracciabilità della distribuzione, usare una risorsa Kubernetes in ambienti insieme a un'operazione Kubernetes.

Per iniziare a usare Azure Pipelines e il servizio Azure Kubernetes, vedere Creare e distribuire nel servizio Azure Kubernetes con Azure Pipelines. Per iniziare a usare Azure Pipelines, Kubernetes e la strategia di distribuzione canary, 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 riuscita o non riuscita. 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

Trigger di supporto della pipeline basati 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, 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 del task "manifest" di Kubernetes mostra la trasformazione tra i modelli di input e i file manifesto 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.

Risorse Kubernetes di destinazione che fanno parte di ambienti con processi di distribuzione. L'uso di ambienti e distribuzioni di risorse migliora la tracciabilità delle pipeline, consentendo di diagnosticare i problemi di distribuzione. È anche possibile eseguire la distribuzione nei cluster Kubernetes con job regolari senza le stesse funzionalità di controllo dello stato.

Il seguente codice YAML illustra come generare file manifest dalle chart Helm.

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

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

Attività Kubectl

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

Questo esempio mostra come una connessione al servizio fa riferimento al cluster Kubernetes.

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

Attività di Script

Usa kubectl con un attività script.

In questo esempio viene usato uno script per eseguire kubectl.

- script: |
    kubectl apply -f manifest.yml

Strategie di distribuzione di Kubernetes

L'attività manifest Kubernetes supporta la strategia di distribuzione canarino. 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 funziona allo stesso modo in tutti i provider di servizi cloud. Usare Azure Pipelines per eseguire la distribuzione nel servizio Azure Kubernetes, nel motore di Google Kubernetes (GKE), nel servizio Amazon Elastic Kubernetes o nei cluster di altri provider di servizi cloud.

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

L'approccio del provider generico, basato su un account del servizio esistente, funziona con i cluster di qualsiasi provider di servizi cloud, incluso Azure. L'uso dell'opzione servizio Azure Kubernetes crea nuovi oggetti ServiceAccount e RoleBinding . In questo modo l'oggetto RoleBinding limita le operazioni di ServiceAccount allo spazio dei nomi scelto.

Quando si utilizza l'approccio del provider generico, assicurarsi che esista un RoleBinding che conceda le autorizzazioni al servizio desiderato nell'account editClusterRole. Concedere le autorizzazioni all'account del servizio corretto in modo che Azure Pipelines possa usarlo 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@1
          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@1
          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@1
          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@1
          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@1
          displayName: Deploy to Kubernetes cluster
          inputs:
            action: deploy
            kubernetesServiceConnection: serviceConnection #replace with your service connection
            namespace: digitaloceannamespace
            manifests: manifests/*