Entorno: recurso de Kubernetes

Artículo
11/29/2021
6 minutos para leer

Azure Pipelines

La vista de recursos de Kubernetes proporciona una visión del estado de los objetos dentro del espacio de nombres asignado al recurso. Esta vista también superpone la rastreabilidad de la canalización para que pueda realizar un seguimiento desde un objeto de Kubernetes a la canalización y, a continuación, volver a la confirmación.

Use recursos de Kubernetes para dirigirse a clústeres de Kubernetes en un entorno para la implementación. Use canalizaciones para implementar en Azure Kubernetes Service (AKS) y clústeres desde cualquier otro proveedor de nube.

Para obtener más información sobre cómo funcionan los recursos, vea Recursos en YAML y seguridad con recursos.

Información general

Vea las siguientes ventajas de usar vistas de recursos de Kubernetes en entornos:

Rastreabilidad de canalizaciones: la tarea manifiesto de Kubernetes,que se usa para las implementaciones, agrega más anotaciones para mostrar la rastreabilidad de la canalización en las vistas de recursos. La rastreabilidad de la canalización ayuda a identificar el origen Azure DevOps organización, proyecto y canalización responsables de las actualizaciones realizadas en un objeto dentro del espacio de nombres .
Diagnosticar el estado de los recursos: el estado de la carga de trabajo puede ser útil para depurar rápidamente errores o regresiones que podrían haber sido introducidos por una nueva implementación. Por ejemplo, en el caso de imagePullSecrets no configurado que da lugar a errores ImagePullBackOff, la información de estado del pod puede ayudarle a identificar la causa principal del problema.
Revisar aplicación: revisar el funcionamiento de la aplicación mediante la implementación de todas las solicitudes de extracción del repositorio de Git en un recurso dinámico de Kubernetes en el entorno. Los revisores pueden ver cómo se ven esos cambios y cómo funcionan con otros servicios dependientes antes de combinarse en la rama de destino e implementarse en producción.

Uso de Azure Kubernetes Service

Se crea una cuenta de servicio en el clúster y espacio de nombres elegidos cuando se usa Azure Kubernetes Service (AKS). En el caso de un clúster habilitado para RBAC de Kubernetes,RoleBinding también se crea para limitar el ámbito de la cuenta de servicio creada al espacio de nombres elegido. En el caso de un clúster con RBAC de Kubernetes deshabilitado, la cuenta de servicio creada tiene privilegios para todo el clúster (entre espacios de nombres).

Adición de un recurso de Kubernetes de AKS

En la página de detalles del entorno, seleccione Agregar recurso y elija Kubernetes.
Seleccione Azure Kubernetes Service en la lista desplegable Proveedor.
Elija la suscripción, el clúster y el espacio de nombres de Azure (nuevo o existente).
Seleccione Validar y crear para crear el recurso de Kubernetes.
Compruebe que ve un clúster para su entorno. Verá el texto "Nunca implementado" si aún no ha implementado código en el clúster.

Usar una cuenta de servicio existente

El Azure Kubernetes Service crea una nueva ServiceAccount, pero la opción de proveedor genérico le permite usar una ServiceAccount existente. ServiceAccount existente se puede asignar a un recurso de Kubernetes dentro de su entorno a un espacio de nombres.

Para obtener más información sobre cómo configurar una conexión de servicio de Kubernetes fuera de un entorno, consulte la sección Conexión de servicio de Kubernetes en Conexiones de servicio.

Sugerencia

Use el proveedor genérico (cuenta de servicio existente) para asignar un recurso de Kubernetes a un espacio de nombres desde un clúster que no es de AKS.

Adición de un recurso de Kubernetes que no es de AKS

En la página de detalles del entorno, seleccione Agregar recurso y elija Kubernetes.
Seleccione Proveedor genérico (cuenta de servicio existente) para el proveedor.
Agregue los valores de nombre de clúster y espacio de nombres.
Agregue la dirección URL del servidor. Puede obtener la dirección URL con el comando siguiente:
```
kubectl config view --minify -o 'jsonpath={.clusters[0].cluster.server}'
```

Para obtener el objeto secreto, busque el nombre del secreto de la cuenta de servicio.

kubectl get serviceAccounts <service-account-name> -n <namespace> -o 'jsonpath={.secrets[*].name}'

Obtenga el objeto secreto mediante la salida del paso anterior.

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

Copie y pegue el objeto Secreto que se captura en formato JSON en el campo Secreto.
Seleccione Validar y crear para crear el recurso de Kubernetes.

Hacer referencia a los recursos de Kubernetes en una canalización

Si usa la Azure Kubernetes Service y la compilación de una canalización de YAML, la manera más fácil de configurar la canalización es usar una plantilla. Conectar al repositorio y seleccione una de las dos opciones siguientes de Kubernetes Service:

Implementación en una plantilla de Azure Kubernetes Services
Implementación en Kubernetes: revisión de la aplicación con Azure DevSpaces

Las plantillas permiten configurar La aplicación de revisión sin necesidad de escribir código YAML desde cero o crear manualmente enlaces de rol explícitos.

Opciones de plantilla de Kubernetes.

Configuración de la aplicación de revisión

En el ejemplo siguiente, el primer trabajo de implementación se ejecuta para ramas que no son de PR y realiza implementaciones en un recurso de Kubernetes normal en entornos. El segundo trabajo se ejecuta solo para ramas de PR e implementa en recursos de revisión de aplicaciones (espacios de nombres dentro del clúster de Kubernetes) generados a petición. Los recursos se etiquetan con "Revisar" en la vista de lista de recursos del entorno. Defina las variables que se usarán en la canalización. Si usa la plantilla Deploy to Azure Kubernetes Services (Implementar en Azure Kubernetes Services),estas variables se definen automáticamente.

# 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"

Para usar este trabajo en una canalización existente, la conexión de servicio que hace una copia de seguridad del recurso de entorno de Kubernetes normal debe modificarse a "Usar credenciales de administrador de clúster". De lo contrario, se deben crear enlaces de rol para la cuenta de servicio subyacente al espacio de nombres Revisar aplicación.

Pasos siguientes

Creación e implementación en Azure Kubernetes Service