Ejercicio: Creación de una canalización de Azure DevOps para implementar una aplicación nativa de la nube

  • 5 minutos

El administrador quiere que cambie la CI/CD de la aplicación eShop de la empresa para que use Azure Pipelines. Ahora creará una canalización de Azure DevOps para compilar e implementar el servicio de productos.

Crear una canalización de Azure DevOps

Importante

Antes de comenzar, deberá tener una cuenta de Azure DevOps. Si no tiene una, puede crear una de forma gratuita en dev.azure.com.

  1. Inicie sesión en dev.azure.com.
  2. Seleccione + Nuevo proyecto.
  3. En Nombre del proyecto, escriba Implementación de eShop.
  4. Deje la opción Visibilidad establecida en Privado y luego seleccione Crear.
  5. A la izquierda, seleccione Canalizaciones y, después, Crear canalización.
  6. En la página Conectar, en ¿Dónde está el código?, seleccione GitHub.
  7. Si se le solicita, inicie sesión en GitHub y autorice a Azure Pipelines a acceder a su cuenta de GitHub.
  8. En Seleccionar un repositorio, seleccione el repositorio bifurcado.
  9. En la página Configurar, seleccione la opción Implementar en Azure Kubernetes Service.
  10. En el panel Implementar en Azure Kubernetes Service, seleccione la suscripción de Azure y, a continuación, seleccione Continuar.
  11. Si se le solicita, inicie sesión en la suscripción de Azure.
  12. En Clúster, seleccione el clúster de AKS que creó en la unidad anterior aks-eshop.
  13. En Espacio de nombres, deje Existente seleccionado y, después, seleccione predeterminado.
  14. En Registro de contenedor, seleccione el registro de Azure Container Registry que creó en la unidad anterior; por ejemplo, acseshop186748394.
  15. En Nombre de la imagen, escriba productservice.
  16. En Puerto de servicio, escriba 8080.
  17. Seleccione Validar y configurar.

Revisión del archivo de canalización YAML

Azure Pipelines usa archivos YAML para definir los pasos para compilar e implementar la aplicación. El archivo YAML se almacena en el repositorio de GitHub y se creó automáticamente en función de la información proporcionada.

Vamos a revisar el archivo YAML:

trigger:
- main

resources:
- repo: self

variables:

  # Container registry service connection established during pipeline creation
  dockerRegistryServiceConnection: '3bcbb23c-6fca-4ff0-8719-bfbdb64a89b1'
  imageRepository: 'productservice'
  containerRegistry: 'acseshop186748394.azurecr.io'
  dockerfilePath: '**/Dockerfile'
  tag: '$(Build.BuildId)'
  imagePullSecret: 'acseshop18674839414442d34-auth'

  # Agent VM image name
  vmImageName: 'ubuntu-latest'


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
    displayName: Deploy
    pool:
      vmImage: $(vmImageName)
    environment: 'PhilStollerymod9cloudnativeexercisecode-1959.default'
    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)

Las secciones desencadenador y recursos definen cuándo se debe ejecutar la canalización. En este caso, la canalización se ejecutará cuando se confirme un cambio en la rama principal del repositorio.

La sección variables define las variables usadas en la canalización. Las variables se usan para definir el Azure Container Registry y el Dockerfile que se van a usar.

A continuación, YAML define un trabajo de compilación que usa el agente ubuntu-latest. El trabajo usa la tarea de Docker para compilar e insertar la imagen en Azure Container Registry.

La última fase es implementar el servicio de producto actualizado en AKS. El trabajo usa la tarea KubernetesManifest para implementar la imagen en AKS.

Ejecución de la canalización

En la parte superior derecha de la página Revisar la canalización de YAML, seleccione Guardar y ejecutar. En el panel Guardar y ejecutar:

  1. Seleccione Crear una rama nueva para este commit.
  2. Deje las opciones restantes con sus valores predeterminados.
  3. Seleccione Guardar y ejecutar.

Supervisión y solución de problemas de la canalización

Azure Pipelines se supervisa y administra desde el portal de Azure DevOps. Echemos un vistazo a la salida de la ejecución de la canalización que ha creado.

A screenshot showing the status of an Azure Pipeline.

En la página de resumen se muestran todas las fases de la canalización en ejecución. Puede seleccionar una fase para ver los pasos con más detalle. En un momento, verá que se ha producido un error en la canalización. Seleccione la fase Compilación.

A screenshot of the build stage in a pipeline that has failed.

En la fase de compilación, puede ver que se ha producido un error en la compilación. Seleccione el paso Compilar e insertar una imagen en Azure Container Registry. El error del archivo de registro muestra que:

##[error]Unhandled: No Dockerfile matching  /home/vsts/work/1/s/**/Dockerfile  was found.

Corregir el error

En DevOps, vuelva a la página de resumen de canalización. Va a editar la canalización creada para corregir el error.

  1. En la parte superior derecha, seleccione el menú Más acciones y, a continuación, seleccione Editar canalización.

  2. La línea 17 del archivo YAML define el Dockerfile que se va a usar y, de forma predeterminada, la canalización espera que haya un archivo denominado Dockerfile en la raíz del repositorio.

    La eShop usa un archivo de Docker diferente para el servicio de producto denominado DockerfileProducts. Edite la línea 17 así:

      dockerfilePath: '**/DockerfileProducts.acr'

  3. Seleccione Guardar.

  4. En el panel Guardar, seleccione Guardar.

  5. Seleccione Ejecutar y, a continuación, en el panel Ejecutar canalización, seleccione Ejecutar.

    Vea la finalización de la fase de compilación. La fase de implementación se pausa hasta que se selecciona y se permite que se ejecute.

    A screenshot showing the completed pipeline.

    La canalización se completa correctamente. Seleccione la fase de implementación para ver los pasos.

    A screenshot showing the Deploy stage and the successfully completed steps.