Ejercicio: Publicación de un módulo en un registro

• 5 minutos

En su empresa de juguetes ha estado publicando los módulos de Bicep en un registro. Ha estado ejecutando el proceso de publicación manualmente desde su propio equipo. Ahora quiere crear una canalización para controlar el proceso de publicación.

En este ejercicio, aprenderá a:

Creación de un Registro de contenedor

Para poder publicar los módulos, debe crear un registro para su organización. En este caso, usa el Portal de Azure para crear un registro.

1. Cree un nuevo registro de contenedor en el Portal de Azure en el explorador.

2. En la pestaña Aspectos básicos seleccione la suscripción de destino y el grupo de recursos ToyReusable que ha creado anteriormente.

3. Escriba un nombre para el registro y una ubicación cercana.

   Importante

   El nombre del registro debe ser único dentro de Azure y contener entre 5 y 50 caracteres alfanuméricos. Una marca de verificación junto al nombre del registro indica que el nombre que ha elegido está disponible.

4. En SKU, seleccione Básico.

   Para las demás opciones de configuración, deje los valores predeterminados.

5. Seleccione Revisar + crear.

   

6. Revise la configuración Validación superada y, a continuación, seleccione Crear.

   Espere a que finalice la implementación, lo que normalmente tarda entre 1 y 2 minutos.

7. Cuando aparezca el mensaje Implementación correcta, seleccione Ir al recurso para abrir el registro de contenedor.

   

8. En el área Información general del registro de contenedor, anote el valor de la configuración del servidor de inicio de sesión. Será algo como yourregistryname.azurecr.io.

   

   Necesitará este valor más adelante.

Agregación de un archivo de metadatos de módulo

En la unidad anterior ha aprendido la importancia de tener una estrategia de control de versiones para los módulos. También ha aprendido a usar los archivos de metadatos del módulo para especificar el número de versión principal y secundaria del módulo dentro de una canalización. Aquí agregará un archivo de metadatos para el módulo de la cuenta de almacenamiento.

1. En Visual Studio Code, expanda la carpeta modules/storage-account en la raíz del repositorio.

2. Cree un nuevo archivo denominado metadata.json.

   

3. Agregue el siguiente contenido al archivo:

   {
     "version": {
       "major": 1,
       "minor": 2
     }
   }
   

   Tenga en cuenta que en el archivo de metadatos se definen por separado los números de versión principal y secundaria. La canalización combina estos números junto con el número de compilación de la canalización en un número de versión completo cada vez que se ejecute la canalización.

4. Guarde los cambios en el archivo.

Actualización de la definición de canalización y agregación de una fase de lint

El repositorio contiene un borrador de una canalización que puede usar como punto de partida.

1. Abra el archivo pipeline.yml en la carpeta módulos/cuenta de almacenamiento.

2. Actualice el valor de la variable de entorno ModuleRegistryServer al nombre del servidor del registro de contenedor. Ese es el nombre que ha copiado anteriormente en este ejercicio.

   Por ejemplo, si el servidor de inicio de sesión del registro es yourregistryname.azurecr.io, tendrá el siguiente aspecto:

   - name: ModuleRegistryServer
     value: yourregistryname.azurecr.io
   

3. En la parte inferior del archivo, en el comentario # To be added agregue la siguiente definición de fase de lint:

   stages:
   
   - stage: Lint
     jobs:
     - job: LintCode
       displayName: Lint code
       steps:
         - script: |
             az bicep build --file $(ModuleFilePath)
           name: LintBicepCode
           displayName: Run Bicep linter
   

Agregación de una fase de publicación a la canalización

Ahora puede agregar una segunda fase para publicar el módulo en el registro de contenedor.

1. En la parte inferior del archivopipeline.yml, defina la fasePublicar, y agregie un paso para leer el número de la versión del archivo de su módulo metadata.json y configúrelo como una variable de canalización.

   - stage: Publish
     jobs:
     - job: Publish
       steps:
         - script: |
             majorMinorVersionNumber=$(jq '(.version.major | tostring) + "." + (.version.minor | tostring)' $(ModuleMetadataFilePath) -r )
             versionNumber="$majorMinorVersionNumber.$(Build.BuildNumber)"
             echo "##vso[task.setvariable variable=ModuleVersion;]$versionNumber"
           name: GetModuleVersionNumber
           displayName: Get module version number
   

   El paso ejecuta un script que usa la aplicación de línea de comandos jq para analizar el archivo JSON.

2. Después del paso que acaba de crear, agregue un paso para publicar el módulo en el registro.

   - task: AzureCLI@2
     name: Publish
     displayName: Publish module
     inputs:
       azureSubscription: $(ServiceConnectionName)
       scriptType: 'bash'
       scriptLocation: 'inlineScript'
       inlineScript: |
         az bicep publish \
           --target 'br:$(ModuleRegistryServer)/$(ModuleName):$(ModuleVersion)' \
           --file $(ModuleFilePath)
   

   Observe que este paso construye de forma dinámica el valor del argumento --target. Combina el valor del servidor del registro, el nombre del módulo y el número de versión.

3. Guarde los cambios en el archivo.

Comprobación y confirmación de la definición de canalización

1. Compruebe que el archivo storage_account_module.yml es similar al del ejemplo siguiente:

   trigger:
     batch: true
     branches:
       include:
       - main
     paths:
       include:
       - 'modules/storage-account/**'
   
   variables: 
   - name: ServiceConnectionName
     value: ToyReusable
   - name: ModuleName
     value: storage-account
   - name: ModuleRegistryServer
     value: yourregistryname.azurecr.io
   - name: ModuleFilePath
     value: modules/storage-account/main.bicep
   - name: ModuleMetadataFilePath
     value: modules/storage-account/metadata.json
   
   pool:
     vmImage: ubuntu-latest
   
   stages:
   
   - stage: Lint
     jobs:
     - job: LintCode
       displayName: Lint code
       steps:
         - script: |
             az bicep build --file $(ModuleFilePath)
           name: LintBicepCode
           displayName: Run Bicep linter
   
   - stage: Publish
     jobs:
     - job: Publish
       steps:
         - script: |
             majorMinorVersionNumber=$(jq '(.version.major | tostring) + "." + (.version.minor | tostring)' $(ModuleMetadataFilePath) -r )
             versionNumber="$majorMinorVersionNumber.$(Build.BuildNumber)"
             echo "##vso[task.setvariable variable=ModuleVersion;]$versionNumber"
           name: GetModuleVersionNumber
           displayName: Get module version number
         - task: AzureCLI@2
           name: Publish
           displayName: Publish module
           inputs:
             azureSubscription: $(ServiceConnectionName)
             scriptType: 'bash'
             scriptLocation: 'inlineScript'
             inlineScript: |
               az bicep publish \
                 --target 'br:$(ModuleRegistryServer)/$(ModuleName):$(ModuleVersion)' \
                 --file $(ModuleFilePath)
   

   Si no es así, actualícelo para que coincida con este ejemplo y después guárdelo.

2. Confirme e inserte los cambios en el repositorio de Git mediante la ejecución de los comandos siguientes en el terminal de Visual Studio Code:

   git add .
   git commit -m "Add lint and publish stages to storage account module pipeline"
   git push
   

   Inmediatamente después de la inserción, Azure Pipelines inicia una nueva ejecución de canalización.

Supervisar la canalización

1. Seleccione Canalizaciones>Canalizaciones en el explorador.

2. Seleccione la ejecución de canalización activa.

3. Se muestra la ejecución de canalización.

   Espere a que finalice la ejecución de la canalización. El módulo de Bicep se publica en el registro de contenedor.

4. Observe el número de compilación de la canalización, que incluye la fecha de hoy y un número de revisión único.

Revisión del módulo en el registro

También puede visualizar el módulo publicado en el Portal de Azure.

1. En el explorador, vaya a Azure Portal.

2. Vaya al grupo de recursos ToyReusable.

3. Seleccione el registro de contenedor que ha creado anteriormente.

4. Seleccione el panel Repositorios del menú. A continuación, seleccione el repositorio módulos\cuenta de almacenamiento, que representa el módulo que ha publicado la canalización.

   

   Observe que hay una sola etiqueta, que coincide con el número de versión del módulo que ha publicado la canalización. La versión principal (1) y la versión secundaria (2) coinciden con los números de versión que ha definido en el archivo metadata.json. El número de revisión (20230407.3) coincide con el número de compilación de la canalización.

Limpiar los recursos

Ahora que ha completado el ejercicio, puede quitar los recursos para que no se le facturen.

En el terminal de Visual Studio Code, ejecute el comando siguiente:

az group delete --resource-group ToyReusable --yes --no-wait

Remove-AzResourceGroup -Name ToyReusable -Force

También puede quitar la conexión de servicio y el proyecto de Azure DevOps.

• Conexión de servicio

  1. En el proyecto de Azure DevOps, seleccione Configuración del proyecto>Conexiones de servicio.
  2. Seleccione ToyReusable.
  3. En la esquina superior derecha, seleccione los tres puntos para Más acciones.
  4. Seleccione Eliminar y confirme la eliminación.

• Registro de aplicaciones de Azure

  1. En la página principal del portal, busque Microsoft Entra ID y selecciónelo en la lista de Servicios.
  2. Vaya a Administrar>Registros de aplicaciones.
  3. En Aplicaciones eliminadas, seleccione toy-reusable.
  4. Seleccione Eliminar permanentemente y siga las indicaciones.

• Proyecto de Azure DevOps

  1. En el proyecto de Azure DevOps, seleccione Configuración del proyecto>Información general.
  2. En Eliminar proyecto, seleccione Eliminar.
  3. Escriba el nombre del proyecto y confirme la eliminación.