Crea una canalización de IC/EC con Azure Pipelines y Google Kubernetes Engine

Last reviewed 2022-11-29 UTC

En este instructivo, se muestra cómo usar Azure Pipelines, Google Kubernetes Engine (GKE) y Container Registry de Google a fin de crear una canalización de integración continua/implementación continua (CI/CD) para una aplicación web ASP.NET MVC. Para los fines de este instructivo, puedes seleccionar entre dos aplicaciones de ejemplo:

Una aplicación web de ASP.NET Core que usa .NET 6.0 y se ejecuta en Linux
Una aplicación web ASP.NET MVC que usa .NET Framework 4 y se ejecuta en Windows

La canalización de CI/CD usa dos clústeres de GKE independientes, uno para el desarrollo y otro para la producción, como se muestra en el siguiente diagrama.

Diagrama conceptual de la canalización de CI/CD en el que se muestra cómo los desarrolladores y los usuarios finales interactúan con la aplicación

Al comienzo de la canalización, los desarrolladores confirman cambios en la base de código de ejemplo. Esta acción activa la canalización para crear una nueva versión y para implementarla en el clúster de desarrollo. Un administrador de versiones puede promover la versión para que se implemente en el clúster de producción.

Este instructivo está dirigido a ingenieros DevOps y desarrolladores. Se supone que tienes conocimientos básicos de Microsoft .NET, Azure Pipelines y GKE. Para este instructivo también es necesario tener acceso de administrador a una cuenta de Azure DevOps.

Objetivos

Conectar Container Registry de Google con Azure Pipelines para publicar imágenes de Docker
Preparar una app de muestra de .NET para implementarla en GKE
Autenticar de forma segura en GKE sin tener que utilizar la autenticación heredada
Utilizar la administración de versiones de Azure Pipelines para organizar las implementaciones de GKE

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

GKE
Cloud Load Balancing
Cloud Storage (para Container Registry)

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Cuando finalices las tareas que se describen en este documento, puedes borrar los recursos que creaste para evitar que continúe la facturación. Para obtener más información, consulta Cómo realizar una limpieza.

Consulta la página de precios de Azure DevOps para conocer las tarifas que podrían aplicarse por su uso.

Antes de comenzar

Por lo general, se recomienda usar proyectos diferentes para las cargas de trabajo de desarrollo y producción, a fin de que las funciones y los permisos de administración de identidades y accesos (IAM) se puedan otorgar de forma individual. Por cuestiones prácticas, en este instructivo se usa un solo proyecto para ambos clústeres de GKE, el de desarrollo y el de producción.

En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

Nota: Si no planeas conservar los recursos que creaste durante este procedimiento, crea un proyecto en lugar de seleccionar uno existente. Cuando termines, puedes borrar el proyecto y quitar todos los recursos asociados con él.

Ir al selector de proyectos

Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

Asegúrate de tener una cuenta de Azure DevOps y de contar con acceso de administrador. Si todavía no tienes una cuenta de Azure DevOps, puedes registrarte en su página principal.

Crea un proyecto de Azure DevOps

Azure DevOps se usa con el fin de administrar el código fuente, ejecutar compilaciones y pruebas, y organizar la implementación en GKE. Para comenzar, crea un proyecto en tu cuenta de Azure DevOps.

Ve a la página principal de Azure DevOps (https://dev.azure.com/YOUR_AZURE_DEVOPS_ACCOUNT_NAME).
Haz clic en Nuevo proyecto.
Ingresa un nombre para el proyecto, como CloudDemo.
Configura la Visibilidad como Privada y, luego, haz clic en Crear.
Después de crear el proyecto, haz clic en Repos en el menú de la izquierda.
Haz clic en Importar para bifurcar el repositorio dotnet-docs-samples de GitHub y, luego, establece los siguientes valores:
- Tipo de repositorio: Git
- URL de clonación: https://github.com/GoogleCloudPlatform/dotnet-docs-samples.git
Haga clic en Import.

Una vez completado el proceso de importación, verás el código fuente del repositorio de dotnet-docs-samples.

Conecta Azure Pipelines a Google Container Registry

Antes de configurar la integración continua para la app de CloudDemo, debes conectar Azure Pipelines a Container Registry. Esta conexión permite que Azure Pipelines publique imágenes de contenedor en Container Registry.

Configura una cuenta de servicio para publicar imágenes

Crea una cuenta de servicio de Google Cloud en tu proyecto:

Abre la consola de Google Cloud.
En la consola de Google Cloud, activa Cloud Shell.

Activar Cloud Shell
Para ahorrar tiempo cuando escribes el ID del proyecto y las opciones de la zona de Compute Engine, establece los valores de configuración predeterminados; para ello, ejecuta los siguientes comandos:
```
gcloud config set project PROJECT_ID
gcloud config set compute/zone us-central1-a
```
Reemplaza PROJECT_ID por el ID de tu proyecto:

Habilita la API de Container Registry en el proyecto

gcloud services enable containerregistry.googleapis.com

Crea una cuenta de servicio que Azure Pipelines use para publicar imágenes de Docker:

gcloud iam service-accounts create azure-pipelines-publisher \
    --display-name="Azure Pipelines Publisher"

Otorga la función de IAM de administrador de almacenamiento (roles/storage.admin) a la cuenta de servicio para permitir que Azure Pipelines se envíe a Container Registry:

AZURE_PIPELINES_PUBLISHER=azure-pipelines-publisher@$GOOGLE_CLOUD_PROJECT.iam.gserviceaccount.com

gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT \
    --member serviceAccount:$AZURE_PIPELINES_PUBLISHER \
    --role roles/storage.admin

Genera una clave de cuenta de servicio:

gcloud iam service-accounts keys create azure-pipelines-publisher.json \
    --iam-account $AZURE_PIPELINES_PUBLISHER

tr -d '\n' < azure-pipelines-publisher.json > azure-pipelines-publisher-oneline.json

Visualiza el contenido del archivo de claves de la cuenta de servicio:
```
echo $(<azure-pipelines-publisher-oneline.json)
```
Necesitas la clave de la cuenta de servicio en uno de los siguientes pasos.

Crea una conexión de servicio para Container Registry de Google

En Azure Pipelines, crea una conexión de servicio nueva para Container Registry:

En el menú de Azure DevOps, selecciona Configuración del proyecto y, luego, selecciona Canalizaciones > Conexiones de servicio.
Haz clic en Crear conexión de servicio.
En la lista, selecciona Registro de Docker y, luego, haz clic en Siguiente.
En el diálogo, ingresa valores para los siguientes campos:
- Tipo de registro: Otros
- Registro de Docker: https://gcr.io/PROJECT_ID, y reemplaza PROJECT_ID por el nombre de tu proyecto (por ejemplo, https://gcr.io/azure-pipelines-test-project-12345)
- ID de Docker: _json_key
- Contraseña: Pega el contenido de azure-pipelines-publisher-oneline.json
- Nombre de conexión del servicio: gcr-tutorial
Haz clic en Guardar para crear la conexión.

Compila de forma continua

Ahora puedes usar Azure Pipelines para configurar la integración continua. Por cada confirmación que se envía al repositorio de Git, Azure Pipelines compila el código y empaqueta los artefactos de la compilación en un contenedor de Docker. Luego, el contenedor se publica en Container Registry.

El repositorio ya contiene el siguiente Dockerfile:

.NET/Linux

applications/clouddemo/netcore/Dockerfile

Ver en GitHub

#
# Copyright 2020 Google LLC
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
#

FROM mcr.microsoft.com/dotnet/aspnet:6.0
EXPOSE 8080

#------------------------------------------------------------------------------
# Copy publishing artifacts.
#------------------------------------------------------------------------------

WORKDIR /app
COPY CloudDemo.MvcCore/bin/Release/net6.0/publish/ /app/

ENV ASPNETCORE_URLS=http://0.0.0.0:8080

#------------------------------------------------------------------------------
# Run application in Kestrel.
#------------------------------------------------------------------------------

ENTRYPOINT ["dotnet", "CloudDemo.MvcCore.dll"]

.NET Framework/Windows

applications/clouddemo/net4/Dockerfile

Ver en GitHub

#
# Copyright 2020 Google LLC
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
#

FROM mcr.microsoft.com/windows/servercore/iis:windowsservercore-ltsc2019
EXPOSE 80
SHELL ["powershell", "-command"]

#------------------------------------------------------------------------------
# Add LogMonitor so that IIS and Windows logs are emitted to STDOUT and can be
# picked up by Docker/Kubernetes.
#
# See https://github.com/microsoft/windows-container-tools/wiki/Authoring-a-Config-File
# for details.
#------------------------------------------------------------------------------

ADD https://github.com/microsoft/windows-container-tools/releases/download/v1.1/LogMonitor.exe LogMonitor/
ADD LogMonitorConfig.json LogMonitor/

#------------------------------------------------------------------------------
# Copy publishing artifacts to webroot.
#------------------------------------------------------------------------------

ADD CloudDemo.Mvc/bin/Release/PublishOutput/ c:/inetpub/wwwroot/

#------------------------------------------------------------------------------
# Configure IIS using the helper functions from deployment.ps1.
#------------------------------------------------------------------------------

ADD deployment.ps1 /
RUN . /deployment.ps1; \
	Install-Iis; \
	Register-WebApplication -AppName "CloudDemo"; \
	Remove-Item /deployment.ps1

#------------------------------------------------------------------------------
# Run IIS, wrapped by LogMonitor.
#------------------------------------------------------------------------------

ENTRYPOINT ["C:\\LogMonitor\\LogMonitor.exe", "C:\\ServiceMonitor.exe", "w3svc"]

Ahora, debes crear una canalización nueva que use la sintaxis YAML:

Mediante Visual Studio o un cliente git de línea de comandos, clona el repositorio de Git nuevo y revisa la rama main.
En la raíz del repositorio, crea un archivo llamado azure-pipelines.yml.

Copia el siguiente código en el archivo:

.NET/Linux

resources:
- repo: self
  fetchDepth: 1
pool:
  vmImage: ubuntu-20.04
trigger:
- main
variables:
  TargetFramework: 'net6.0'
  BuildConfiguration: 'Release'
  DockerImageName: 'PROJECT_ID/clouddemo'
steps:
- task: DotNetCoreCLI@2
  displayName: Publish
  inputs:
    projects: 'applications/clouddemo/netcore/CloudDemo.MvcCore.sln'
    publishWebProjects: false
    command: publish
    arguments: '--configuration $(BuildConfiguration) --framework=$(TargetFramework)'
    zipAfterPublish: false
    modifyOutputPath: false
- task: CmdLine@1
  displayName: 'Lock image version in deployment.yaml'
  inputs:
    filename: /bin/bash
    arguments: '-c "awk ''{gsub(\"CLOUDDEMO_IMAGE\", \"gcr.io/$(DockerImageName):$(Build.BuildId)\", $0); print}'' applications/clouddemo/netcore/deployment.yaml > $(build.artifactstagingdirectory)/deployment.yaml"'
- task: PublishBuildArtifacts@1
  displayName: 'Publish Artifact'
  inputs:
    PathtoPublish: '$(build.artifactstagingdirectory)'
- task: Docker@2
  displayName: 'Login to Container Registry'
  inputs:
    command: login
    containerRegistry: 'gcr-tutorial'
- task: Docker@2
  displayName: 'Build and push image'
  inputs:
    Dockerfile: 'applications/clouddemo/netcore/Dockerfile'
    command: buildAndPush
    repository: '$(DockerImageName)'

.NET Framework/Windows

resources:
- repo: self
  fetchDepth: 1
pool:
  vmImage: windows-2019     # Matches WINDOWS_LTSC in GKE
  demands:
  - msbuild
  - visualstudio
trigger:
- master
variables:
  Solution: 'applications/clouddemo/net4/CloudDemo.Mvc.sln'
  BuildPlatform: 'Any CPU'
  BuildConfiguration: 'Release'
  DockerImageName: 'PROJECT_ID/clouddemo'
steps:
- task: NuGetCommand@2
  displayName: 'NuGet restore'
  inputs:
    restoreSolution: '$(Solution)'
- task: VSBuild@1
  displayName: 'Build solution'
  inputs:
    solution: '$(Solution)'
    msbuildArgs: '/p:DeployOnBuild=true /p:PublishProfile=FolderProfile'
    platform: '$(BuildPlatform)'
    configuration: '$(BuildConfiguration)'
- task: PowerShell@2
  displayName: 'Lock image version in deployment.yaml'
  inputs:
    targetType: 'inline'
    script: '(Get-Content applications\clouddemo\net4\deployment.yaml) -replace "CLOUDDEMO_IMAGE","gcr.io/$(DockerImageName):$(Build.BuildId)" | Out-File -Encoding ASCII $(build.artifactstagingdirectory)\deployment.yaml'
- task: PublishBuildArtifacts@1
  displayName: 'Publish Artifact'
  inputs:
    PathtoPublish: '$(build.artifactstagingdirectory)'
- task: Docker@2
  displayName: 'Login to Container Registry'
  inputs:
    command: login
    containerRegistry: 'gcr-tutorial'
- task: Docker@2
  displayName: 'Build and push image'
  inputs:
    Dockerfile: 'applications/clouddemo/net4/Dockerfile'
    command: buildAndPush
    repository: '$(DockerImageName)'

Reemplaza PROJECT_ID por el nombre del proyecto y, luego, guarda el archivo.

Confirma los cambios y envíalos a Azure Pipelines.
Visual Studio
1. Abre Team Explorer y haz clic en el ícono de página principal.
2. Haz clic en Cambios.
3. Ingresa un mensaje de confirmación, como Add pipeline definition.
4. Haz clic en Confirmar todo y enviar.
Línea de comandos
1. Almacena en etapa intermedia todos los archivos modificados:
```
git add -A
```
2. Confirma los cambios en el repositorio local:
```
git commit -m "Add pipeline definition"
```
3. Envía los cambios a Azure DevOps:
```
git push
```
En el menú de Azure DevOps, selecciona Canalizaciones y, luego, haz clic en Crear canalización.
Selecciona Azure Repos Git.
Selecciona tu repositorio.
En la página Revisar la canalización de YAML, haz clic en Ejecutar.

Se activará una compilación nueva. Es posible que la compilación tarde alrededor de 6 minutos en completarse.
Para verificar que la imagen se publicó en Container Registry, cambia al proyecto en la consola de Google Cloud y selecciona Container Registry > Imágenes y, luego, haz clic en clouddemo.

Se muestra una sola imagen y su etiqueta. La etiqueta corresponde al ID numérico de la compilación que se ejecutó en Azure Pipelines.

Implementa de forma continua

Debido a que Azure Pipelines compila el código de forma automática y publica las imágenes de Docker de cada confirmación, ahora puedes enfocarte en la implementación.

A diferencia de otros sistemas de integración continua, Azure Pipelines distingue entre la implementación y la compilación, y ofrece un conjunto especializado de herramientas etiquetadas como Administración de versiones para todas las tareas relacionadas con la implementación.

La Administración de versiones de Azure Pipelines se basa en los siguientes conceptos:

El término versión hace referencia a un conjunto de artefactos que conforman una versión específica de la app y que, por lo general, son el resultado de un proceso de compilación.
La implementación se refiere al proceso de tomar una actualización e implementarla en un entorno específico.
Una implementación realiza un conjunto de tareas, que se pueden agrupar en trabajos.
Las etapas te permiten segmentar la canalización y se pueden usar para organizar implementaciones en varios entornos, por ejemplo, entornos de desarrollo y prueba.

El artefacto principal que produce el proceso de compilación de CloudDemo es la imagen de Docker. Sin embargo, debido a que la imagen de Docker se publica en Container Registry, la imagen está fuera del alcance de Azure Pipelines. Por ende, la imagen no funciona bien como definición de una versión.

Para implementar en Kubernetes, también necesitas un manifiesto, que se parece a una factura de materiales. El manifiesto no solamente define los recursos que se supone que Kubernetes creará y administrará, sino que, además, especifica la versión exacta de la imagen de Docker que se utilizará. El manifiesto de Kubernetes es adecuado para funcionar como el artefacto que define la versión en la Administración de versiones de Azure Pipelines.

Configura la implementación de Kubernetes

Para ejecutar CloudDemo en Kubernetes, necesitarás los siguientes recursos:

Una implementación que defina un solo pod que ejecute la imagen de Docker producida por la compilación
Un servicio NodePort que vuelve al pod accesible para el balanceador de cargas
Un Ingress que exponga la aplicación a la Internet pública mediante un balanceador de cargas de HTTP(S) de Cloud

El repositorio ya contiene el siguiente manifiesto de Kubernetes que define estos recursos:

.NET/Linux

applications/clouddemo/netcore/deployment.yaml

Ver en GitHub

#
# Copyright 2020 Google LLC
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
#

apiVersion: v1
kind: Service
metadata:
  name: clouddemo-netcore
spec:
  ports:
  - port: 80
    targetPort: 8080
    protocol: TCP
    name: http
  selector:
    app: clouddemo-netcore
  type: NodePort

---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: clouddemo-netcore
spec:
  defaultBackend:
    service:
      name: clouddemo-netcore
      port:
        number: 80

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: clouddemo-netcore
spec:
  replicas: 2
  selector:
    matchLabels:
      app: clouddemo-netcore
  template:
    metadata:
      labels:
        app: clouddemo-netcore
    spec:
      containers:
      - name: clouddemo-netcore
        image: CLOUDDEMO_IMAGE
        ports:
          - containerPort: 8080
        livenessProbe:      # Used by deployment controller
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 5
        readinessProbe:     # Used by Ingress/GCLB
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 3
          periodSeconds: 5
        resources:
          limits:
            memory: 1024Mi
          requests:
            memory: 256Mi

.NET Framework/Windows

applications/clouddemo/net4/deployment.yaml

Ver en GitHub

#
# Copyright 2020 Google LLC
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
#

apiVersion: v1
kind: Service
metadata:
  name: clouddemo-net4
  annotations:
    cloud.google.com/neg: '{"ingress": false}' # Disable NEG

spec:
  ports:
  - port: 80
    targetPort: 80
    protocol: TCP
    name: http
  selector:
    app: clouddemo-net4
  type: NodePort

---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: clouddemo-net4
spec:
  defaultBackend:
    service:
      name: clouddemo-net4
      port:
        number: 80

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: clouddemo-net4
spec:
  replicas: 2
  selector:
    matchLabels:
      app: clouddemo-net4
  template:
    metadata:
      labels:
        app: clouddemo-net4
    spec:
      nodeSelector:
        kubernetes.io/os: windows
      containers:
      - name: clouddemo-net4
        image: CLOUDDEMO_IMAGE
        ports:
          - containerPort: 80
        livenessProbe:      # Used by deployment controller
          httpGet:
            path: /health
            port: 80
          initialDelaySeconds: 120
          periodSeconds: 5
        readinessProbe:     # Used by Ingress/GCLB
          httpGet:
            path: /health
            port: 80
          initialDelaySeconds: 10
          periodSeconds: 5
        resources:
          limits:
            memory: 1024Mi
          requests:
            memory: 256Mi

Configura los entornos de desarrollo y producción

Antes de volver a la Administración de versiones de Azure Pipelines, deberás crear el clúster de GKE.

Crea clústeres de GKE

Regresa a tu instancia de Cloud Shell.

Habilita la API de GKE para tu proyecto:

gcloud services enable container.googleapis.com

Crea el clúster de desarrollo; para ello, utiliza el siguiente comando. Ten en cuenta que puede tardar unos minutos en completarse:

.NET/Linux

gcloud container clusters create azure-pipelines-cicd-dev --enable-ip-alias

.NET Framework/Windows

gcloud container clusters create azure-pipelines-cicd-dev --enable-ip-alias

gcloud container node-pools create azure-pipelines-cicd-dev-win \
    --cluster=azure-pipelines-cicd-dev \
    --image-type=WINDOWS_LTSC \
    --no-enable-autoupgrade \
    --machine-type=n1-standard-2

Crea el clúster de producción mediante el siguiente comando. Ten en cuenta que puede tomar unos minutos en completarse:

.NET/Linux

gcloud container clusters create azure-pipelines-cicd-prod --enable-ip-alias

.NET Framework/Windows

gcloud container clusters create azure-pipelines-cicd-prod --enable-ip-alias

gcloud container node-pools create azure-pipelines-cicd-prod-win \
    --cluster=azure-pipelines-cicd-prod \
    --image-type=WINDOWS_LTSC \
    --no-enable-autoupgrade \
    --machine-type=n1-standard-2

Conecta Azure Pipelines al clúster de desarrollo

Así como puedes usar Azure Pipelines para conectarte a un registro externo de Docker, como Container Registry, Azure Pipelines admite la integración de clústeres de Kubernetes externos.

Es posible autenticarse en Container Registry mediante una cuenta de servicio de Google Cloud, pero Azure Pipelines no admite el uso de cuentas de servicio de Google Cloud para la autenticación con GKE. En su lugar, debes usar una cuenta de servicio de Kubernetes.

Por lo tanto, para conectar Azure Pipelines al clúster de desarrollo, primero debes crear una cuenta de servicio de Kubernetes.

En Cloud Shell, conéctate al clúster de desarrollo:

gcloud container clusters get-credentials azure-pipelines-cicd-dev

Crea una cuenta de servicio de Kubernetes para Azure Pipelines:
```
kubectl create serviceaccount azure-pipelines-deploy
```

Crea un Secret de Kubernetes que contenga una credencial de token para Azure Pipelines:

kubectl create secret generic azure-pipelines-deploy-token --type=kubernetes.io/service-account-token --dry-run -o yaml \
  | kubectl annotate --local -o yaml -f - kubernetes.io/service-account.name=azure-pipelines-deploy \
  | kubectl apply -f -

Asigna la función cluster-admin a la cuenta de servicio mediante la creación de una vinculación de función de clúster:

kubectl create clusterrolebinding azure-pipelines-deploy --clusterrole=cluster-admin --serviceaccount=default:azure-pipelines-deploy

Define la dirección IP del clúster:

gcloud container clusters describe azure-pipelines-cicd-dev --format=value\(endpoint\)

Necesitarás esta dirección en un momento.

En el menú de Azure DevOps, selecciona Configuración del proyecto y, luego, Canalizaciones > Conexiones de servicio.
Haz clic en Nueva conexión de servicio.
Selecciona Kubernetes y haz clic en Siguiente.
Establece la siguiente configuración:

Nota: Para obtener algunos de estos valores, debes ejecutar comandos de kubectl en Cloud Shell y, luego, copiar los valores en la página de Azure.
- Método de autenticación: Cuenta de servicio
- URL del servidor: https://PRIMARY_IP. Reemplaza PRIMARY_IP por la dirección IP que definiste antes.
- Secret: El Secret de Kubernetes que creaste antes. Para obtener el Secret, ejecuta el siguiente comando, copia el Secret y, luego, cópialo en la página de Azure.
```
kubectl get secret azure-pipelines-deploy-token -o yaml
```
- Nombre de la conexión de servicio: azure-pipelines-cicd-dev
Haz clic en Guardar.

Conecta Azure Pipelines al clúster de producción

Para conectar Azure Pipelines al clúster de producción, puedes seguir el mismo enfoque.

En Cloud Shell, conéctate al clúster de producción:

gcloud container clusters get-credentials azure-pipelines-cicd-prod

Crea una cuenta de servicio de Kubernetes para Azure Pipelines:
```
kubectl create serviceaccount azure-pipelines-deploy
```

Asigna la función cluster-admin a la cuenta de servicio mediante la creación de una vinculación de función de clúster:

kubectl create clusterrolebinding azure-pipelines-deploy --clusterrole=cluster-admin --serviceaccount=default:azure-pipelines-deploy

Define la dirección IP del clúster:

gcloud container clusters describe azure-pipelines-cicd-prod --format=value\(endpoint\)

Necesitarás esta dirección en un momento.

En el menú de Azure DevOps, selecciona Configuración del proyecto y, luego, Canalizaciones > Conexiones de servicio.
Haz clic en Nueva conexión de servicio.
Selecciona Kubernetes y haz clic en Siguiente.
Establece la siguiente configuración:

Nota: Para obtener algunos de estos valores, debes ejecutar comandos de kubectl en Cloud Shell y, luego, copiar los valores en la página de Azure.
- Método de autenticación: Cuenta de servicio
- URL del servidor: https://PRIMARY_IP. Reemplaza PRIMARY_IP por la dirección IP que definiste antes.
- Secreto: Ejecuta el siguiente comando en Cloud Shell y copia el resultado:
```
kubectl get secret $(kubectl get serviceaccounts azure-pipelines-deploy -o custom-columns=":secrets[0].name") -o yaml
```
- Nombre de la conexión de servicio: azure-pipelines-cicd-prod.
Haz clic en Guardar.

Configura la canalización de la versión

Después de configurar la infraestructura de GKE, vuelve a Azure Pipelines para automatizar la implementación, lo que incluye las siguientes acciones:

Implementar en el entorno de desarrollo
Solicitar aprobación manual antes de iniciar una implementación en el entorno de producción
Implementar en el entorno de producción

Crea una definición de la versión

Como primer paso, crea una nueva definición de la versión.

En el menú de Azure DevOps, selecciona Canalizaciones > Versiones.
Haz clic en Nueva canalización.
En la lista de plantillas, selecciona Trabajo vacío.
Cuando se te solicite un nombre para la etapa, ingresa Development.
En la parte superior de la pantalla, nombra la versión CloudDemo-KubernetesEngine.
En el diagrama de la canalización, junto a Artifacts (Artefactos), haz clic en Add (Agregar).
Selecciona Compilar y agrega la siguiente configuración:
- Tipo de origen: Compilación
- Origen (canalización de compilación): Selecciona la definición de compilación (solo debe haber una opción)
- Versión predeterminada: Latest
- Alias de origen: manifest
Haga clic en Agregar.
En el cuadro Artefacto, haz clic en el ícono del rayo Desencadenador de implementación continua para agregar un desencadenador de implementación.
En Desencadenador de implementación continua, establece la opción como Habilitado.
Haz clic en Guardar.
Si lo deseas, ingresa un comentario y, luego, haz clic en Aceptar para confirmar.

La canalización se muestra de la siguiente manera.

Implementa en el clúster de desarrollo

Una vez que creaste la definición de la versión, puedes configurar la implementación en el clúster de desarrollo de GKE.

En el menú, cambia a la pestaña Tareas.
Haz clic en Trabajo de agente y establece la siguiente configuración:
- Grupo de agentes: Azure Pipelines
- Especificación del agente: ubuntu-18.04
Junto a Trabajo de agente, haz clic en Add a task to agent job para agregar un paso a la fase.
Selecciona la tarea Implementar en Kubernetes y haz clic en Agregar.
Haz clic en la tarea recién agregada y establece la siguiente configuración:
- Nombre visible: Deploy
- Acción: implementar
- Conexión de servicio de Kubernetes: azure-pipelines-cicd-dev
- Espacio de nombres: default
- Estrategia: ninguna
- Manifiestos: manifest/drop/deployment.yaml
Haz clic en Guardar.
Si lo deseas, ingresa un comentario y, luego, haz clic en Aceptar para confirmar.

Implementa en el clúster de producción

Por último, configura la implementación en el clúster de producción de GKE.

En el menú, pasa a la pestaña Canalización.
En la casilla Etapas, selecciona Agregar > Nueva etapa.
En la lista de plantillas, selecciona Trabajo vacío.
Cuando se te solicite un nombre para la etapa, ingresa Production.
Haz clic en el ícono del rayo de la etapa recién creada.
Establece la siguiente configuración:
- Seleccionar activador: After stage
- Etapas: Dev
- Aprobaciones previas a la implementación: (habilitadas)
- Responsables de aprobación: Selecciona tu propio nombre de usuario.
La canalización ahora se ve de la siguiente manera:
Pasa a la pestaña Tareas.
Mantén el mouse sobre la pestaña Tareas y selecciona Tareas > Producción
Haz clic en Trabajo de agente y establece la siguiente configuración:
- Grupo de agentes: Azure Pipelines
- Especificación del agente: ubuntu-18.04
Haz clic en Add a task to agent job para agregar un paso a la fase.
Selecciona la tarea Implementar en Kubernetes y haz clic en Agregar.
Haz clic en la tarea recién agregada y establece la siguiente configuración:
- Nombre visible: Deploy
- Acción: implementar
- Conexión de servicio de Kubernetes: azure-pipelines-cicd-prod
- Espacio de nombres: default
- Estrategia: ninguna
- Manifiestos: manifest/drop/deployment.yaml
Haz clic en Guardar.
Si lo deseas, ingresa un comentario y, luego, haz clic en Aceptar para confirmar.

Ejecuta la canalización

Ahora que configuraste toda la canalización, realiza un cambio en el código fuente para probarla:

En tu computadora local, abre el archivo Index.cshtml desde el repositorio de Git que clonaste antes:

.NET/Linux
El archivo se encuentra en applications\clouddemo\netcore\CloudDemo.MvcCore\Views\Home\

.NET Framework/Windows
El archivo se encuentra en applications\clouddemo\net4\CloudDemo.Mvc\Views\Home\
En la línea 26, cambia el valor de ViewBag.Title de Home Page a This app runs on GKE.
Confirma tus cambios y envíalos a Azure Pipelines.
Visual Studio
1. Abre Team Explorer y haz clic en el ícono de página principal.
2. Haz clic en Cambios.
3. Ingresa un mensaje de confirmación, como Change site title.
4. Haz clic en Confirmar todo y enviar.
Línea de comandos
1. Almacena en etapa intermedia todos los archivos modificados:
```
git add -A
```
2. Confirma los cambios en el repositorio local:
```
git commit -m "Change site title"
```
3. Envía los cambios a Azure Pipelines:
```
git push
```
En el menú de Azure DevOps, selecciona Canalizaciones. Se activará una compilación.
Cuando se complete la compilación, selecciona Canalizaciones > Versiones. Se iniciará un proceso de actualización.
Haz clic en Release-1 para abrir la página de detalles y espera a que el estado de la etapa de Desarrollo cambie a Finalizado.
En la consola de Google Cloud, selecciona Kubernetes Engine > Ingress y servicios > Ingress.
Ubica el servicio de Ingress del clúster azure-pipelines-cicd-dev y espera a que su estado cambie a Correcto. Esto podría llevar varios minutos.
Abre el vínculo en la columna Frontends de la misma fila. Es posible que al principio te encuentres con un error debido a que el balanceador de cargas tarda unos minutos en estar disponible. Cuando esté listo, verás que CloudDemo se implementó y usa el título personalizado.
En Azure Pipelines, haz clic en el botón Aprobar (Approve) ubicado en la etapa de Producción (Prod) para promover la implementación en el entorno de producción.

Si no ves el botón, es posible que primero debas aprobar o rechazar una versión anterior.
Si lo deseas, ingresa un comentario y, luego, haz clic en Aprobar (Approve) para confirmarlo.
Espera a que el estado del entorno Prod cambie a Succeeded (Correcto). Es posible que tengas que actualizar de forma manual la página en tu navegador.
En la consola de Google Cloud, actualiza la página Ingress y servicios.
Ubica el servicio de Ingress del clúster azure-pipelines-cicd-prod y espera a que su estado cambie a Correcto. Esto podría llevar varios minutos.
Abre el vínculo en la columna Frontends de la misma fila. De nuevo, es posible que al principio te encuentres con un error, debido a que el balanceador de cargas tarda unos minutos en estar disponible. Cuando esté listo, verás la aplicación de CloudDemo con el título personalizado, pero esta vez se estará ejecutando en el clúster de producción.

Limpia

Para evitar que se generen más costos después de completar este instructivo, borra las entidades que creaste.

Borra el proyecto de Azure Pipelines

Para borrar el proyecto de Azure Pipelines, consulta la documentación de servicios de Azure DevOps. Si borras el proyecto de Azure Pipelines, se perderán todos los cambios del código fuente.

Borra el desarrollo y los proyectos de Google Cloud

Precaución: Borrar un proyecto tiene estas consecuencias:

Se borra todo en el proyecto. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.

Si planeas explorar varias infraestructuras, instructivos y guías de inicio rápido la reutilización de proyectos puede ayudarte a evitar exceder los límites de las cuotas del proyecto.

En la consola de Google Cloud, ve a la página Administrar recursos.
Ir a Administrar recursos
En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

¿Qué sigue?

Configura el control de acceso preciso para Container Registry.
Obtén más información sobre cómo implementar un grupo de SQL Server altamente disponible en Compute Engine.
Obtén más información sobre .NET en Google Cloud Platform.
Instala Cloud Tools for Visual Studio.
Explora arquitecturas de referencia, diagramas y prácticas recomendadas sobre Google Cloud. Consulta nuestro Cloud Architecture Center.

Crea una canalización de IC/EC con Azure Pipelines y Google Kubernetes Engine

Objetivos

Costos

Antes de comenzar

Crea un proyecto de Azure DevOps

Conecta Azure Pipelines a Google Container Registry

Configura una cuenta de servicio para publicar imágenes

Crea una conexión de servicio para Container Registry de Google

Compila de forma continua

.NET/Linux

.NET Framework/Windows

.NET/Linux

.NET Framework/Windows

Visual Studio

Línea de comandos

Implementa de forma continua

Configura la implementación de Kubernetes

.NET/Linux

.NET Framework/Windows

Configura los entornos de desarrollo y producción

Crea clústeres de GKE

.NET/Linux

.NET Framework/Windows

.NET/Linux

.NET Framework/Windows

Conecta Azure Pipelines al clúster de desarrollo

Conecta Azure Pipelines al clúster de producción

Configura la canalización de la versión

Crea una definición de la versión

Implementa en el clúster de desarrollo

Implementa en el clúster de producción

Ejecuta la canalización

.NET/Linux

.NET Framework/Windows

Visual Studio

Línea de comandos

Limpia

Borra el proyecto de Azure Pipelines

Borra el desarrollo y los proyectos de Google Cloud

¿Qué sigue?