En el desarrollo de software, es crucial automatizar y desplegar soluciones rápidamente. Por ello, contar con un proceso de CI/CD robusto es fundamental para poner en producción nuevas características de forma ágil. En este blog, exploraremos cómo construir un pipeline en Azure DevOps, utilizando el repositorio de este sitio web como referencia para construir el pipeline en la plataforma.

Es importante mencionar que este pipeline no incluirá ninguna etapa de pruebas de código (testing), aunque sea un elemento fundamental en el proceso de CI/CD. Junto con esto, este post no incluirá configuraciones para desarrollar y implementar infraestructura como código (IaC).

¿Cuales son los requerimientos?

Los requerimientos para usar Azure DevOps son:

• 1-Cuenta Azure: Tener una cuenta de Azure DevOps. Se necesitas registrate lo puedes hacer en aquí (https://azure.microsoft.com/en-us/products/devops)
• 2-Suscripción Activa: Tener una suscripción activa en Microsoft Azure para desplegar servicios en Azure.

En el caso de este blog se construira un pipeline para actualizar la pagina https://focoanalytics.org/. Esta pagina esta construida sobre un app Service de Azure, donde esta vinculada a un Azure Container Register, el cual contiene el repositorio del sitio. Debido a esto, para que funcione el pipeline del blog se necesita constar con lo siguiente:

• 1-Registro de Contenedor: Tener un registro de contenedor (Azure Container Register) activo en Microsoft Azure que este vinculado a la aplicación a deployar (en nuestro caso a un App Service). Para mayor información sobre ACR aquí. (https://azure.microsoft.com/en-us/products/container-registry)

¿Cómo empezar?

Como mencionamos anteriormente, es necesario tener una cuenta de Azure DevOps. Puedes crear tu cuenta utilizando el enlace proporcionado anteriormente. Si ya tienes una cuenta, inicia sesión y verás la siguiente imagen:

En mi cuenta de AzureDevOps, ya tengo un proyecto llamado "FocoAnalytics", el cual contiene todo el código de este sitio web, junto con su pipeline. Si deseas crear tu propio proyecto, debes presionar el botón en la parte superior derecha llamado "+ New Project". Esto desplegará un cuadro donde deberás ingresar algunos campos tales como: Project Name, Description y Visibility. Al ingresar a un proyecto nuevo (o a tu propio proyecto creado), encontrarás una vista general de todas las opciones disponibles de DevOps, desde "Summary" hasta "Repos" y "Artifacts". Las secciones utilizadas en este blog son:

• 1-Repositorios: En esta sección puedes copiar, guardar y actualizar los códigos de tu proyecto en diferentes ramas.
• 2-Pipelines: Esta sección muestra todos los pipelines disponibles en tu proyecto. Podrás seleccionar cada uno de ellos para conocer su estado de ejecución.
• 3-Project Settings: Esta sección contiene las configuraciones de tu proyecto. Es importante acceder a esta parte del proyecto, ya que para construir pipelines es necesario crear una "Service Connection", que permite configurar la conexión entre tu suscripción de Azure y el pipeline.

Sección: Repositorio

Si ingresas a la sección "Repos" en tu nuevo proyecto, no encontrarás ningún repositorio activo. Por lo tanto, deberás clonar el repositorio dentro de una carpeta local para traer el código de tu aplicación o servicio a Azure DevOps. Si se trata de un proyecto nuevo, verás la siguiente pantalla:

Como lo mencione, debes clonar tu repositorio en un ambiente local, y subirlo a Azure DevOps. En el caso de esta pagina, el proyecto ya contiene los archivos en DevOps, mostrándose de la siguiente manera:

El elemento clave para construir un pipeline en DevOps es el archivo yml, que por default, debería llamarse "azure-pipelines.yml". Este archivo define y configura la integración y entrega continua en Azure, definiendo etapas, trabajos y pasos que componen el pipeline. En este caso, el archivo yml es:

trigger:
- master
- main
- dev

resources:
- repo: self

variables:
# ========================================================================
#                          Mandatory variables
# ========================================================================

# Update Azure.ResourceGroupName value with Azure resource group name.
Azure.ResourceGroupName: 'resource-name'

# Update Azure.ServiceConnectionId value with AzureRm service endpoint.
Azure.ServiceConnectionId: 'connection-string-project'

# Update Azure.Location value with Azure Location.
Azure.Location: 'westus'

ACR.Name: 'container-ACR-name'

# ========================================================================
#                           Optional variables
# ========================================================================

ACR.ImageName: 'container-ACR-name:$(Build.BuildId)'
ACR.FullName: 'container-ACR-name.azurecr.io'
Azure.CreateResources: 'false' 
System.Debug: 'false'

jobs:

- job: CreateResources
displayName: Create required resources
condition: and(succeeded(), eq(variables['Azure.CreateResources'], 'true'))

pool:
    'Azure Pipelines'

- job: BuildImage
displayName: Build
dependsOn: CreateResources
condition: or(succeeded(), ne(variables['Azure.CreateResources'], 'true'))

pool:
    'Azure Pipelines'

steps:
- task: AzureCLI@2
    displayName: 'Login to Azure'
    inputs:
    azureSubscription: $(Azure.ServiceConnectionId)
    scriptType: bash
    scriptLocation: inlineScript
    inlineScript: |
        az acr login --name $(ACR.Name)

- task: Docker@2
    displayName: 'Build an image'
    inputs:
    command: build
    repository: '$(ACR.FullName)/fmacayasecurity/focoanalytics'
    dockerfile: '**/Dockerfile'
    tags: |
        latest

- task: Docker@2
    displayName: 'Push an image'
    inputs:
    command: push
    repository: '$(ACR.FullName)/fmacayasecurity/focoanalytics'

El archivo YAML es una representación de una secuencia de instrucciones, donde cada una de sus partes representa una acción, variable o tarea. Si descomponemos el anterior archivo, encontraremos los siguientes puntos importantes:

• 1-Asignación de Trigger: Se asigna las ramas que estarán afectadas por el pipeline. Si hay cambio o actualizaciones de código en las ramas, se gatillara el trigger.
• 2-Asignación de Variables: Se asigna las variables utilizadas para ejecutar el pipeline. Las variables relevantes son: Grupo de recursos, ServiceConnection, Azure Container Registery. El ServiceConnection es una conexión de servicio que permite que Azure DevOps se conecte de forma segura a una cuenta de Azure u otros servicios.
• 3-Asignación de pool: Es el agente que ejecuta los trabajos. Este elemento se encuentra en Home (AzureDevops) > Organization Settings > Pipelines > Agent Pools > Choose the Agent (Name)
• 4-Desarrollo de Jobs: El pipeline contiene principalmente dos jobs, los cuales son: el primero para construir los recursos y la imagen del docker, y luego el segundo para deployarlo en Azure Container Register.

¿Qué es el ServiceConnection?

Como se mencionó anteriormente, una de las variables relevantes para crear el pipeline es el ServiceConnection, que permite establecer una conexión segura entre DevOps y tu cuenta de Azure. Para crear esta conexión, debes seguir los siguientes pasos:

• Paso 1: En el home del proyecto en AzureDevOps, se debe seleccionar “Projects settings”.
• Paso 2: En Project Setting, se debe seleccionar “Service Connections”.
• Paso 3: En Service Connections, se debe crear una nueva conexión, mediante el botón “new service connection”.
• Paso 4: En esta parte aparecerán múltiples opciones de conexión, en este caso, se seleccionara “Azure Resource Manager”.
• Paso 5: Se debe seleccionar Service Principal (manual).
• Paso 6: Finalmente, aparecerá un formulario para llenarlo con algunas variables como: Suscription Id, Suscription Name, - Service Principal ID, Service Principal Key y Tenand ID. La información de la suscripción se obtiene desde la suscripción activa de Azure.

Sección: “Pipeline”

Después de haber creado el proyecto y colocado el código en el repositorio de DevOps, junto con el archivo YAML y sus variables, estaremos listos para construir el pipeline. Para ello, debes seguir las siguientes etapas:

• Paso 1: En el home del proyecto, se debe seleccionar “Pipelines”.
• Paso 2: Luego, se debe apretar “new pipeline”.
• Paso 3: Después, aparecerán distintas opciones, selecciona “Azure Repos Git”.
• Paso 4: Selecciona el repositorio, en mi caso, es “FocoAnalytics”.
• Paso 5: En Configuración de pipeline, debes seleccionar “Start Pipeline”.
• Paso 6: Si esta bien configurado, debería aparecer el archivo YAML de tu branch por defecto. Seleccionas “Save and run”.

Luego de configurar el pipeline, debería aparecer un proceso ejecutándose de la siguiente manera en la sección “Pipeline”:

Como es la primera vez que se ejecuta el pipeline, es necesario ir al pipeline creado y autorizar su ejecución. Esto es importante, ya que de lo contrario no se ejecutará. Una vez autorizado, deberás esperar a que el pipeline se ejecute. Si todo sale correctamente, el estado del pipeline debería cambiar a "Success", mostrándose de la siguiente manera:

Conclusiones

Automatizar la integración y entrega continua (CI/CD) en el desarrollo de software es crucial para asegurar la agilidad y eficiencia en la implementación de nuevas características. Construir un pipeline en Azure DevOps, como hemos visto, no es complicado pero sí requiere atención a los detalles y la correcta configuración de variables y conexiones. Aunque este tutorial no incluyó etapas de pruebas de código, es altamente recomendable incorporarlas para mantener la calidad y estabilidad del software. Con esta guía, ya tienes las bases para comenzar a construir y desplegar tus proyectos de manera más eficiente utilizando Azure DevOps.