Ambiente - Risorsa Kubernetes

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

La visualizzazione risorse Kubernetes offre un'occhiata allo stato degli oggetti all'interno dello spazio dei nomi mappato alla risorsa. Questa visualizzazione sovrappone anche la tracciabilità della pipeline in modo da poter tornare 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 la distribuzione in servizio Azure Kubernetes e cluster da qualsiasi altro provider di servizi 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.

Panoramica

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

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

    Tracciabilità della pipeline

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

    ImagePullBackOff

  • Esaminare l'app - Esaminare l'app funziona distribuendo ogni richiesta pull dal repository Git a una risorsa Kubernetes dinamica nell'ambiente. I revisori possono vedere come queste modifiche vengono visualizzate e utilizzate con altri servizi dipendenti prima di essere uniti nel ramo di destinazione e distribuiti nell'ambiente di produzione.

Usare il servizio Azure Kubernetes

Un ServiceAccount viene creato nel cluster e nello spazio dei nomi scelto quando si usa servizio Azure Kubernetes (servizio Azure Kubernetes). Per un cluster abilitato per il controllo degli accessi in base al ruolo kubernetes, RoleBinding viene creato anche per limitare l'ambito dell'account del servizio creato allo spazio dei nomi scelto. Per un cluster disabilitato dal controllo degli accessi in base al ruolo di Kubernetes, ServiceAccount creato ha privilegi a livello di cluster (tra spazi dei nomi).

Aggiungere una risorsa Kubernetes del servizio Azure Kubernetes

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

  2. Selezionare servizio Azure Kubernetes 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. Il testo "Mai distribuito" verrà visualizzato se il codice non è ancora stato distribuito nel cluster.

    Aggiungere un cluster Kubernetes.

Usare un account di servizio esistente

La servizio Azure Kubernetes crea un nuovo ServiceAccount, ma l'opzione del provider generico consente di usare un ServiceAccount esistente. ServiceAccount esistente può essere mappato a una risorsa Kubernetes all'interno dell'ambiente in 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 nelle connessioni al servizio.

Suggerimento

Usare il provider generico (account del servizio esistente) per eseguire il mapping di una risorsa Kubernetes a uno spazio dei nomi da un cluster non del servizio Azure Kubernetes.

Aggiungere una risorsa Kubernetes non del servizio Azure Kubernetes

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

  2. Selezionare Provider generico (account del servizio esistente) per il provider.

  3. Aggiungere il nome del cluster e i valori 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, trovare il nome segreto dell'account del servizio.

    kubectl get serviceAccounts <service-account-name> -n <namespace> -o 'jsonpath={.secrets[*].name}'
    
  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 Secret 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 crea 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 di 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 di modello kubernetes.

Configurare l'app Rivedi

Nell'esempio seguente il primo processo di distribuzione viene eseguito per rami non PR e esegue distribuzioni in una risorsa Kubernetes regolare in ambienti. Il secondo processo viene eseguito solo per i rami della richiesta richiesta e viene distribuito in Esaminare le risorse dell'app (spazi dei nomi all'interno del cluster Kubernetes) generati su richiesta. Le risorse vengono etichettate con "Rivedi" nella visualizzazione elenco risorse dell'ambiente. Definire le variabili da usare nella pipeline. Se si usa il modello Distribuisci in Servizi Azure Kubernetes, queste variabili vengono definite per l'utente.

# 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: $(envName).$(resourceName)
    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: $(envName).$(resourceName)
    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 posing 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 , è necessario modificare la risorsa di ambiente Kubernetes regolare in "Usare le credenziali di amministratore del cluster". In caso contrario, le associazioni di ruolo devono essere create per l'account del servizio sottostante allo spazio dei nomi Rivedi app.

Passaggi successivi