Ambiente - Risorsa Kubernetes

Azure Pipelines

La visualizzazione delle risorse Kubernetes offre una visione d'insieme dello stato degli oggetti all'interno dello spazio dei nomi di cui è stato eseguito il mapping alla risorsa. Questa visualizzazione sovrappone anche la tracciabilità della pipeline in modo da poter eseguire la tracciabilità da un oggetto Kubernetes alla pipeline e quindi tornare al commit.

Usare le risorse Kubernetes per i cluster Kubernetes in un ambiente per la distribuzione. Usare pipeline per la distribuzione in servizio Azure Kubernetes (AKS) e cluster da qualsiasi altro provider di servizi cloud.

Per altre informazioni sul funzionamento delle risorse, vedere risorse in YAMLe sicurezza con le risorse.

Panoramica

Vedere i vantaggi seguenti dell'uso delle visualizzazioni delle risorse Kubernetes all'interno degli 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'Azure DevOps, il progetto e la pipeline di origine responsabili degli aggiornamenti apportati a un oggetto all'interno dello spazio dei nomi.

    Pipeline traceability

  • 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 le immagini non configuratePullSecrets che causano errori ImagePullBackOff, le informazioni sullo stato del pod consentono di identificare la causa radice del problema.

    ImagePullBackOff

  • Esaminare il funzionamento dell'app - Rivedi app distribuendo ogni richiesta pull dal repository Git a una risorsa Kubernetes dinamica nell'ambiente. I revisori possono vedere l'aspetto e il funzionamento di tali modifiche 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 scelti quando si usa servizio Azure Kubernetes (AKS). Per un cluster kubernetesabilitato per il controllo degli accessi in base al ruolo, viene creato anche RoleBinding 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 Kubernetes del servizio 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 sia visualizzato un cluster per l'ambiente. Se il codice non è ancora stato distribuito nel cluster, verrà visualizzato il testo "Mai distribuito".

    Add a Kubernetes cluster.

Usare un account di servizio esistente

Il servizio Azure Kubernetes crea un nuovo ServiceAccount, ma l'opzione del provider generico consente di usare un ServiceAccount esistente. L'oggetto ServiceAccount esistente può essere mappato a 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 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 Kubernetes.

Aggiungere una risorsa Kubernetes non del servizio Kubernetes del servizio 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 del 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 Segreto recuperato in formato 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 è usare un modello. Connessione al repository e selezionare una delle due opzioni del servizio Kubernetes seguenti:

I modelli consentono di configurare Review App senza dover scrivere codice YAML da zero o creare manualmente associazioni di ruolo esplicite.

Kubernetes template options.

Configurare l'app di revisione

Nell'esempio seguente il primo processo di distribuzione viene eseguito per i rami non pr ed esegue distribuzioni in una risorsa Kubernetes normale negli ambienti. Il secondo processo viene eseguito solo per i rami di richiesta pull e viene distribuito nelle risorse dell'app di revisione (spazi dei nomi all'interno del cluster Kubernetes) generate su richiesta. Le risorse vengono contrassegnate con "Rivedi" nella visualizzazione elenco risorse dell'ambiente. Definire le variabili da usare nella pipeline. Se si usa il modello Deploy to Azure Kubernetes Services, 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: Deploy
  displayName: Deploy stage
  dependsOn: Build

  jobs:
  - deployment: Deploy
    condition: and(succeeded(), not(startsWith(variables['Build.SourceBranch'], 'refs/pull/')))
    displayName: Deploy
    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, la connessione al servizio che backup la risorsa ambiente Kubernetes normale deve essere modificata in "Usare le credenziali di amministratore del cluster". In caso contrario, è necessario creare associazioni di ruolo per l'account del servizio sottostante allo spazio dei nomi Rivedi app.

Passaggi successivi