Condividi tramite

Ambiente - Risorsa di Kubernetes

  • Articolo

Azure DevOps Services | Azure DevOps Server 2022 | Azure DevOps Server 2020

La visualizzazione delle risorse Kubernetes mostra lo stato degli oggetti all'interno dello spazio dei nomi che sono mappati alla risorsa. La visualizzazione delle risorse sovrappone anche la tracciabilità della pipeline in modo da poter risalire da un oggetto Kubernetes alla pipeline e quindi tornare al commit.

Usare le risorse Kubernetes per indirizzare i cluster Kubernetes in un ambiente per la distribuzione. Usare le pipeline per distribuire all'Azure Kubernetes Service (AKS) e ai cluster di qualsiasi altro provider cloud.

È possibile usare le risorse Kubernetes con cluster pubblici o privati. Per altre informazioni sul funzionamento delle risorse, vedere risorse in YAML e sicurezza con le risorse.

Nota

Se si usa un cluster AKS privato, è necessario essere connessi alla rete virtuale del cluster poiché l'endpoint del server API non è esposto tramite un IP pubblico.

Azure Pipelines consiglia di configurare un agente self-hosted all'interno di una rete virtuale che abbia accesso alla rete virtuale del cluster. Per informazioni dettagliate, vedere Opzioni per la connessione al cluster privato.

Panoramica

Vedere i vantaggi seguenti dell'uso delle viste delle risorse Kubernetes all'interno degli ambienti:

  • Tracciabilità della pipeline - L'attività manifesto di Kubernetes, usata per le distribuzioni, aggiunge ulteriori annotazioni per mostrare la tracciabilità della pipeline nelle visualizzazioni delle risorse. La tracciabilità delle pipeline consente di identificare l'organizzazione, il progetto e la pipeline di Azure DevOps di origine responsabili degli aggiornamenti apportati a un oggetto all'interno dello spazio dei nomi.

    Tracciabilità delle pipeline

  • Diagnosticare l'integrità delle risorse: lo stato del carico di lavoro può essere utile per eseguire rapidamente il debug di errori o regressioni introdotti da una nuova distribuzione. Ad esempio, per imagePullSecrets non configurati che generano errori ImagePullBackOff, le informazioni sullo stato del pod consentono di identificare la causa radice del problema.

    ImagePullBackOff

  • Review App: Review App funziona distribuendo ogni richiesta pull dal tuo repository Git su una risorsa Kubernetes dinamica all'interno dell'ambiente. I revisori possono vedere come appaiono e funzionano tali modifiche con altri servizi dipendenti prima che vengano uniti nel ramo di destinazione e distribuiti in produzione.

Usare il servizio Azure Kubernetes

Un account di servizio viene creato nel cluster e nello spazio dei nomi scelti quando si utilizza Azure Kubernetes Service (AKS). Per un cluster abilitato a RBAC di Kubernetes, viene creato anche un RoleBinding per limitare l'ambito dell'account di servizio creato allo spazio dei nomi scelto. Per un cluster con controllo degli accessi in base al ruolo di Kubernetes disabilitato, il ServiceAccount creato dispone di privilegi a livello di cluster (attraverso i namespace).

Aggiungere una risorsa AKS Kubernetes

  1. Nella pagina dei dettagli dell'ambiente selezionare Aggiungi risorsa e scegliere Kubernetes.

  2. Selezionare Azure Kubernetes Service nell'elenco a discesa Provider.

  3. Scegliere la sottoscrizione di Azure, il cluster e lo spazio dei nomi (nuovo/esistente).

  4. Selezionare Convalida e crea per creare la risorsa Kubernetes.

  5. Verificare che venga visualizzato un cluster per l'ambiente in uso. Se il codice non è ancora stato distribuito nel cluster, verrà visualizzato il testo "Mai distribuito".

    Aggiungere un cluster Kubernetes.

Usare un account di servizio esistente

Il servizio Azure Kubernetes esegue il mapping di una risorsa Kubernetes all'interno dell'ambiente a uno spazio dei nomi.

Per altre informazioni sulla configurazione di una connessione al servizio Kubernetes all'esterno di un ambiente, vedere la sezione Connessione al servizio Kubernetes in Connessioni al servizio.

Suggerimento

Usare il fornitore generico (account di servizio esistente) per mappare una risorsa Kubernetes a un namespace da un cluster non AKS.

Aggiungere una risorsa Kubernetes non AKS

  1. Nella pagina dei dettagli dell'ambiente selezionare Aggiungi risorsa e scegliere Kubernetes.

  2. Selezionare Fornitore generico (account del servizio esistente) per il fornitore.

  3. Aggiungere i valori del nome del cluster e dello spazio dei nomi.

  4. Aggiungere l'URL del server. È possibile ottenere l'URL con il comando seguente:

    kubectl config view --minify -o 'jsonpath={.clusters[0].cluster.server}'

  5. Per ottenere l'oggetto segreto.

    Kubernetes 1.22+

    Sostituire service-account-name con il nome dell'account.

    kubectl get secret -n <namespace>  -o jsonpath='{.items[?(@.metadata.annotations.kubernetes\.io/service-account\.name==\"service-account-name\")]}'

    Se non si ottiene nulla, vedere Creare manualmente un token API di lunga durata per un Account di servizio.

    Kubernetes 1.22 e versioni successive:

    1. Trovare il nome della chiave segreta del servizio
    kubectl get serviceAccounts <service-account-name> -n <namespace> -o 'jsonpath={.secrets[*].name}'
    1. sostituire <service-account-secret-name> con il valore nel comando precedente in questo comando
    kubectl get secret <service-account-secret-name> -n <namespace> -o json

  6. Ottenere l'oggetto segreto usando l'output del passaggio precedente.

    kubectl get secret <service-account-secret-name> -n <namespace> -o json

  7. Copiare e incollare l'oggetto Segreto recuperato nel modulo JSON nel campo Segreto.

  8. Selezionare Convalida e crea per creare la risorsa Kubernetes.

Fare riferimento alle risorse Kubernetes in una pipeline

Se si usa servizio Azure Kubernetes e si compila una pipeline YAML, il modo più semplice per configurare la pipeline consiste nell'usare un modello. Connettersi al repository e selezionare una delle due opzioni del servizio Kubernetes seguenti:

I modelli consentono di configurare l'app di revisione senza dover scrivere codice YAML da zero o creare manualmente associazioni di ruolo esplicite.

Opzioni del modello Kubernetes.

Configurare l'app di revisione

Nell'esempio seguente, il primo processo di distribuzione viene eseguito per rami non PR e esegue distribuzioni contro una normale risorsa Kubernetes all'interno di ambienti. Il secondo processo viene eseguito solo per i rami delle richieste pull e viene distribuito su risorse App di revisione (spazi dei nomi all'interno del cluster Kubernetes) generati su richiesta. Le risorse vengono etichettate con "Rivedi" nella visualizzazione dell'elenco delle risorse dell'ambiente. Definire le variabili da usare nella pipeline. Se si usa il Deploy to Azure Kubernetes Services template, queste variabili vengono definite automaticamente.

# Build and push image to Azure Container Registry; Deploy to Azure Kubernetes Service
trigger:
- main

resources:
- repo: self

variables:

  # Container registry service connection established during pipeline creation
  dockerRegistryServiceConnection: '12345' # Docker service connection identifier
  envName: 'myEnv' # name of your environment
  imageRepository: 'name-of-image-repository' # name of image repository
  containerRegistry: 'mycontainer.azurecr.io' # path to container registry
  dockerfilePath: '**/Dockerfile'
  tag: '$(Build.BuildId)'
  imagePullSecret: 'my-app-secret' # image pull secret

  # Agent VM image name
  vmImageName: 'ubuntu-latest'

  # Name of the new namespace being created to deploy the PR changes.
  k8sNamespaceForPR: 'review-app-$(System.PullRequest.PullRequestId)'

stages:
- stage: Build
  displayName: Build stage
  jobs:
  - job: Build
    displayName: Build
    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)

    - upload: manifests
      artifact: manifests

- stage: Production
  displayName: Deploy stage
  dependsOn: Build

  jobs:
  - deployment: Production
    condition: and(succeeded(), not(startsWith(variables['Build.SourceBranch'], 'refs/pull/')))
    displayName: Production
    pool:
      vmImage: $(vmImageName)
    environment: 
      name: $(envName).$(resourceName)
      resourceType: Kubernetes 
    strategy:
      runOnce:
        deploy:
          steps:
          - task: KubernetesManifest@0
            displayName: Create imagePullSecret
            inputs:
              action: createSecret
              secretName: $(imagePullSecret)
              dockerRegistryEndpoint: $(dockerRegistryServiceConnection)

          - task: KubernetesManifest@0
            displayName: Deploy to Kubernetes cluster
            inputs:
              action: deploy
              manifests: |
                $(Pipeline.Workspace)/manifests/deployment.yml
                $(Pipeline.Workspace)/manifests/service.yml
              imagePullSecrets: |
                $(imagePullSecret)
              containers: |
                $(containerRegistry)/$(imageRepository):$(tag)

  - deployment: DeployPullRequest
    displayName: Deploy Pull request
    condition: and(succeeded(), startsWith(variables['Build.SourceBranch'], 'refs/pull/'))
    pool:
      vmImage: $(vmImageName)

    environment: 
      name: $(envName).$(resourceName)
      resourceType: Kubernetes
    strategy:
      runOnce:
        deploy:
          steps:
          - reviewApp: default

          - task: Kubernetes@1
            displayName: 'Create a new namespace for the pull request'
            inputs:
              command: apply
              useConfigurationFile: true
              inline: '{ "kind": "Namespace", "apiVersion": "v1", "metadata": { "name": "$(k8sNamespaceForPR)" }}'

          - task: KubernetesManifest@0
            displayName: Create imagePullSecret
            inputs:
              action: createSecret
              secretName: $(imagePullSecret)
              namespace: $(k8sNamespaceForPR)
              dockerRegistryEndpoint: $(dockerRegistryServiceConnection)

          - task: KubernetesManifest@0
            displayName: Deploy to the new namespace in the Kubernetes cluster
            inputs:
              action: deploy
              namespace: $(k8sNamespaceForPR)
              manifests: |
                $(Pipeline.Workspace)/manifests/deployment.yml
                $(Pipeline.Workspace)/manifests/service.yml
              imagePullSecrets: |
                $(imagePullSecret)
              containers: |
                $(containerRegistry)/$(imageRepository):$(tag)

          - task: Kubernetes@1
            name: get
            displayName: 'Get services in the new namespace'
            continueOnError: true
            inputs:
              command: get
              namespace: $(k8sNamespaceForPR)
              arguments: svc
              outputFormat: jsonpath='http://{.items[0].status.loadBalancer.ingress[0].ip}:{.items[0].spec.ports[0].port}'

          # Getting the IP of the deployed service and writing it to a variable for posting comment
          - script: |
              url="$(get.KubectlOutput)"
              message="Your review app has been deployed"
              if [ ! -z "$url" -a "$url" != "http://:" ]
              then
                message="${message} and is available at $url.<br><br>[Learn More](https://aka.ms/testwithreviewapps) about how to test and provide feedback for the app."
              fi
              echo "##vso[task.setvariable variable=GITHUB_COMMENT]$message"

Per usare questo processo in una pipeline esistente , la connessione al servizio che esegue il backup della normale risorsa dell'ambiente Kubernetes deve essere modificata in "Usare le credenziali di amministratore del cluster". In caso contrario, le associazioni di ruolo devono essere create per l'account del servizio sottostante nello spazio dei nomi dell'app di revisione.

Passaggi successivi

Compilare e distribuire in servizio Azure Kubernetes