Prostředky Kubernetes v prostředích

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

Tento článek popisuje použití prostředků Kubernetes v prostředích Azure Pipelines, na která můžete cílit svými deploymenty. Můžete se připojit k veřejným nebo privátním clusterům Kubernetes ve službě Azure Kubernetes Service (AKS) nebo jiných poskytovatelů cloudu.

Zobrazení prostředků prostředí ukazují stav prostředků Kubernetes a poskytují sledovatelnost k pipeline a zpět k potvrzení, které triggerovalo akci. Můžete také vytvořit dynamické prostředky prostředí Kubernetes pro kontrolu žádostí o přijetí změn před sloučením. Další informace o prostředcích prostředí najdete v tématech Prostředky v kanálech YAML a Zabezpečení prostředků.

Poznámka:

Privátní cluster AKS nezpřístupňuje koncový bod serveru rozhraní API prostřednictvím veřejné IP adresy, takže se musíte připojit k virtuální síti clusteru. Můžete nastavit samohostovaného agenta ve virtuální síti, který má přístup k virtuální síti clusteru, nebo použít Managed DevOps Pools. Další informace najdete v tématu Možnosti připojení k privátnímu clusteru.

Výhody zdrojů prostředí Kubernetes

Prostředky prostředí Kubernetes a zobrazení prostředků v prostředích poskytují následující výhody:

Sledovatelnost kanálu. Úloha nasazení manifestu Kubernetes přidává anotace, které podporují sledovatelnost pipeline. Uvidíte organizaci, projekt, a pipeline Azure DevOps, která je zodpovědná za aktualizace objektů v rámci prostoru názvů.
Diagnostika služby Resource Health Zobrazení stavu úloh představuje rychlý způsob ladění chyb nebo regresí zavedených novými nasazeními. Například informace o stavu podu vám můžou pomoct identifikovat příčinu problémů, jako je nekonfigurované imagePullSecrets , což vede k ImagePullBackOff chybám.
Recenze aplikace. Aplikace pro revize nasadí každý pull request z vašeho úložiště Git do dynamického prostředku Kubernetes v prostředí a zanechá komentář na GitHubu s odkazem na recenzní aplikaci. Recenzenti mohou vidět, jak změny v PR vypadají a fungují s dalšími závislými službami dříve, než se změny sloučí do cílové větve a nasadí do produkčního prostředí.

Prostředky AKS

AKS vytvoří serviceAccount ve zvoleném clusteru a oboru názvů a mapuje prostředky Kubernetes ve vašem prostředí na zadaný obor názvů. Informace o nastavení připojení služby Kubernetes mimo prostředí najdete v tématu Připojení ke službě Kubernetes.

U clusteru s podporou řízení přístupu na základě role Kubernetes (RBAC) se vytvoří také roleBinding , který omezí rozsah účtu služby na zvolený obor názvů. V případě clusteru bez povoleného RBAC Kubernetes má vytvořený účet služby oprávnění v rámci celého clusteru napříč obory názvů.

Přidání prostředku AKS do prostředí Azure Pipelines:

Na stránce prostředí v části Kanály>Prostředí vyberte Přidat prostředek a pak vyberte Kubernetes.
Na další obrazovce vyberte Azure Kubernetes Service pro poskytovatele a pak vyberte své předplatné Azure, AKS Cluster a nový nebo existující Namespace. Pro nový obor názvů zadejte název oboru názvů.
Vyberte Ověřit a vytvořit. Nový prostředek se zobrazí na kartě Prostředky prostředí s textem Nikdy nenasazeno.

Prostředky Kubernetes bez AKS

Pokud chcete namapovat prostředek Kubernetes z clusteru mimo AKS na obor názvů, musíte mít existující účet služby pro jiného poskytovatele než AKS.

Přidání prostředku Kubernetes mimo AKS do prostředí Azure Pipelines:

Na stránce prostředí v části Kanály>Prostředí vyberte Přidat prostředek a pak vyberte Kubernetes.
Na další obrazovce vyberte Obecný poskytovatel (existující účet služby) pro Poskytovatele.
V části Přihlašovací údaje clusteru zadejte název clusteru, obor názvů, adresu URL serveru a tajný kód.
- Adresu URL serveru získáte spuštěním kubectl config view --minify -o jsonpath={.clusters[0].cluster.server} v místním prostředí.
- Získání tajného kódu:
  1. Získáte názvy tajných klíčů účtu služby spuštěním kubectl get serviceAccounts <service-account-name> -n <namespace> -o=jsonpath={.secrets[*].name}.
  2. Spusťte kubectl get secret <service-account-secret-name> -n <namespace> -o json příkaz pomocí výstupu předchozího příkazu.
  Poznámka:
  
  Pokud z příkazu get ServiceAccounts nezískáte žádné výsledky, podívejte se na Ruční vytvoření dlouhodobého tokenu rozhraní API pro ServiceAccount.
Vyberte Ověřit a vytvořit.

Prostředky Kubernetes v pipelinech

Nejjednodušší způsob, jak vytvořit kanál YAML pro nasazení do AKS, je začít s šablonou Deploy to Azure Kubernetes Services . Nemusíte psát kód YAML ani ručně vytvářet explicitní vazby rolí. Vygenerovaná sada potrubí nastavuje a používá proměnné a další hodnoty na základě vašich konfiguračních nastavení.

Použití aplikace pro kontrolu

Úloha DeployPullRequest nasadí každý pull request z vašeho Git úložiště do dynamického Kubernetes prostředku v daném prostředí. Pokud chcete tuto úlohu přidat do kanálu, zaškrtněte políčko Povolit tok aplikace pro kontrolu žádostí o přijetí změn ve formuláři Konfigurace služby Azure Kubernetes Services .

Poznámka:

Pokud chcete tuto úlohu přidat do existujícího kanálu, ujistěte se, že je připojení služby, které podporuje běžné prostředí Kubernetes, nastavené na Použití přihlašovacích údajů správce clusteru. Jinak je nutné vytvořit vazby rolí pro příslušný účet služby do oboru názvů revizí aplikace.

Kontrolní prostředky aplikace jsou označeny jako Kontrola v seznamu prostředků daného prostředí.

Snímek obrazovky znázorňující prostředí Kontrola v seznamu prostředí kanálu

Příklad kanálu

Následující ukázkový kanál je založený na šabloně Deploy to Azure Kubernetes Services . Pipeline nejprve sestaví a odešle image do služby Azure Container Registry.

První úloha nasazení se poté spustí pro všechny potvrzení do main větve a nasadí do běžného zdroje Kubernetes v daném prostředí.

Druhá úloha se spustí při vytvoření nebo aktualizaci PR do main větve a nasazuje se proti dynamickému zdroji recenze aplikace, který vytvoří v clusteru podle potřeby.

# Deploy to Azure Kubernetes Service
# Build and push image to Azure Container Registry; Deploy to Azure Kubernetes Service
# https://docs.microsoft.com/azure/devops/pipelines/languages/docker

trigger:
- main

resources:
- repo: self

variables:

  # Container registry service connection established during pipeline creation
  dockerRegistryServiceConnection: '12345' # Docker service connection identifier
  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: 'myenvironmentname.myresourcename'
    strategy:
      runOnce:
        deploy:
          steps:
          - task: KubernetesManifest@1
            displayName: Create imagePullSecret
            inputs:
              action: createSecret
              secretName: $(imagePullSecret)
              dockerRegistryEndpoint: $(dockerRegistryServiceConnection)

          - task: KubernetesManifest@1
            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: 'myenvironmentname.$(k8sNamespaceForPR)'
    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@1
            displayName: Create imagePullSecret
            inputs:
              action: createSecret
              secretName: $(imagePullSecret)
              namespace: $(k8sNamespaceForPR)
              dockerRegistryEndpoint: $(dockerRegistryServiceConnection)

          - task: KubernetesManifest@1
            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}'

          # Get 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."
              fi
              echo "##vso[task.setvariable variable=GITHUB_COMMENT]$message"

Váš názor

Byla tato stránka užitečná?

Last updated on 2025-10-08