Ejercicio: Incorporación de un trabajo de vista previa al flujo de trabajo

  • 3 minutos

Quiere agregar un trabajo adicional al flujo de trabajo para poder comprobar qué cambios se realizarán en el entorno de Azure.

Durante el proceso, hará estas tareas:

  • Actualice el archivo YAML de definición de flujo de trabajo para agregar un nuevo trabajo en versión preliminar.
  • Agregar un entorno al repositorio de GitHub.
  • Configurar el entorno para exigir una revisión.
  • Actualizar el archivo YAML del flujo de trabajo a fin de usar el entorno para el trabajo de implementación.
  • Ver los resultados hipotéticos y aprobar una ejecución de flujo de trabajo.

Actualización de la definición de flujo de trabajo para agregar un trabajo de vista previa

Aquí, agregará un trabajo nuevo al flujo de trabajo que ejecuta la operación what-if.

  1. En Visual Studio Code, abra el archivo workflow.yml en la carpeta .github/workflows.

  2. Entre los trabajos Validate (Validación) y Deploy (Implementación), agregue la definición siguiente para el trabajo Preview (Vista previa):

    preview:
  runs-on: ubuntu-latest
  needs: [lint, validate]
  steps:
  - uses: actions/checkout@v3
  - uses: azure/login@v1
    name: Sign in to Azure
    with:
      client-id: ${{ secrets.AZURE_CLIENT_ID }}
      tenant-id: ${{ secrets.AZURE_TENANT_ID }}
      subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
  - uses: azure/arm-deploy@v1
    name: Run what-if
    with:
      failOnStdErr: false
      resourceGroupName: ${{ env.AZURE_RESOURCEGROUP_NAME }}
      template: deploy/main.bicep
      parameters: >
        environmentType=${{ env.ENVIRONMENT_TYPE }}
      additionalArguments: --what-if

    Observe que el trabajo versión preliminar depende de la finalización con éxito de los trabajos lint y validate.

  3. Actualice el trabajo deploy (Implementación) para que dependa del trabajo preview (Vista previa):

    deploy:
  runs-on: ubuntu-latest
  needs: preview
  steps:
  - uses: actions/checkout@v3
  - uses: azure/login@v1
    name: Sign in to Azure
    with:
      client-id: ${{ secrets.AZURE_CLIENT_ID }}
      tenant-id: ${{ secrets.AZURE_TENANT_ID }}
      subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
  - uses: azure/arm-deploy@v1
    name: Deploy website
    with:
      failOnStdErr: false
      deploymentName: ${{ github.run_number }}
      resourceGroupName: ${{ env.AZURE_RESOURCEGROUP_NAME }}
      template: ./deploy/main.bicep
      parameters: environmentType=${{ env.ENVIRONMENT_TYPE }}

  4. Guarde los cambios en el archivo.

Adición de un entorno

  1. En el explorador, vaya Settings>Environments (Configuración > Entornos).

  2. Seleccione Nuevo entorno.

    Captura de pantalla de la interfaz de GitHub en la que se muestra la página Entornos, con el botón para crear un entorno resaltado.

  3. Escriba Website como nombre de entorno.

  4. Seleccione Configure environment (Configurar el entorno).

    Captura de pantalla de la página de GitHub para un nuevo entorno, con los detalles completados y el botón Configurar el entorno resaltado.

En los pasos de configuración de este módulo, ya ha creado una credencial federada para que el flujo de trabajo la use cuando se implementa en el entorno.

Incorporación de la regla de protección de revisor obligatorio en el entorno

  1. Seleccione la casilla Required reviewers (Revisores obligatorios).

  2. Agregue su propio nombre de usuario de GitHub a la lista de revisores.

    Captura de pantalla de la interfaz de GitHub en la que se muestra el entorno del sitio web, con la casilla y el cuadro de texto Revisores obligatorios resaltados.

  3. Seleccione Save protection rules (Guardar reglas de protección).

  4. Seleccione Entornos para salir de la configuración.

Actualización de la definición de flujo de trabajo para requerir un entorno y un revisor

Aquí, configurará el trabajo deploy (Implementación) para que se ejecute en el entorno Website que ha creado anteriormente.

  1. En Visual Studio Code, abra el archivo workflow.yml.

  2. Agregue el parámetro environment al trabajo deploy (Implementación). Establezca el valor en Website para que coincida con el nombre del entorno que acabamos de crear:

    deploy:
  runs-on: ubuntu-latest
  environment: Website
  needs: preview
  steps:
  - uses: actions/checkout@v3
  - uses: azure/login@v1
    name: Sign in to Azure
    with:
      client-id: ${{ secrets.AZURE_CLIENT_ID }}
      tenant-id: ${{ secrets.AZURE_TENANT_ID }}
      subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
  - uses: azure/arm-deploy@v1
    name: Deploy website
    with:
      failOnStdErr: false
      deploymentName: ${{ github.run_number }}
      resourceGroupName: ${{ env.AZURE_RESOURCEGROUP_NAME }}
      template: ./deploy/main.bicep
      parameters: environmentType=${{ env.ENVIRONMENT_TYPE }}

  3. Guarde el archivo.

Comprobación y confirmación de la definición de flujo de trabajo

  1. Compruebe que el archivo workflow.yml es similar al código siguiente:

    name: deploy-toy-website-test
concurrency: toy-company

on:
  push:
    branches:
      - main

permissions:
  id-token: write
  contents: read

env:
  AZURE_RESOURCEGROUP_NAME: ToyWebsiteTest
  ENVIRONMENT_TYPE: Test

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Run Bicep linter
      run: az bicep build --file deploy/main.bicep

  validate:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - uses: azure/login@v1
      name: Sign in to Azure
      with:
        client-id: ${{ secrets.AZURE_CLIENT_ID }}
        tenant-id: ${{ secrets.AZURE_TENANT_ID }}
        subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
    - uses: azure/arm-deploy@v1
      name: Run preflight validation
      with:
        deploymentName: ${{ github.run_number }}
        resourceGroupName: ${{ env.AZURE_RESOURCEGROUP_NAME }}
        template: ./deploy/main.bicep
        parameters: environmentType=${{ env.ENVIRONMENT_TYPE }}
        deploymentMode: Validate

  preview:
    runs-on: ubuntu-latest
    needs: [lint, validate]
    steps:
    - uses: actions/checkout@v3
    - uses: azure/login@v1
      name: Sign in to Azure
      with:
        client-id: ${{ secrets.AZURE_CLIENT_ID }}
        tenant-id: ${{ secrets.AZURE_TENANT_ID }}
        subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
    - uses: azure/arm-deploy@v1
      name: Run what-if
      with:
        failOnStdErr: false
        resourceGroupName: ${{ env.AZURE_RESOURCEGROUP_NAME }}
        template: deploy/main.bicep
        parameters: >
          environmentType=${{ env.ENVIRONMENT_TYPE }}
        additionalArguments: --what-if

  deploy:
    runs-on: ubuntu-latest
    environment: Website
    needs: preview
    steps:
    - uses: actions/checkout@v3
    - uses: azure/login@v1
      name: Sign in to Azure
      with:
        client-id: ${{ secrets.AZURE_CLIENT_ID }}
        tenant-id: ${{ secrets.AZURE_TENANT_ID }}
        subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
    - uses: azure/arm-deploy@v1
      name: Deploy website
      with:
        failOnStdErr: false
        deploymentName: ${{ github.run_number }}
        resourceGroupName: ${{ env.AZURE_RESOURCEGROUP_NAME }}
        template: ./deploy/main.bicep
        parameters: environmentType=${{ env.ENVIRONMENT_TYPE }}

    Si el archivo tiene un aspecto diferente, actualícelo para que coincida con este ejemplo y 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 preview job"
git push

Ejecución del flujo de trabajo y revisión de las salidas what-if

  1. En el explorador, vaya a las ejecuciones del flujo de trabajo.

  2. Seleccione la ejecución más reciente del flujo de trabajo.

    Espere hasta que el flujo de trabajo complete los trabajos lint, validate (Validación) y preview (Vista previa). Aunque GitHub actualiza automáticamente la página con el estado más reciente, es recomendable actualizarla ocasionalmente.

  3. Observe que el flujo de trabajo le pide una revisión. En función de cómo configure la cuenta de GitHub, recibirá un correo electrónico o una notificación web con una solicitud para revisar el flujo de trabajo.

    Captura de pantalla de la interfaz de GitHub en la que se muestra la ejecución del flujo de trabajo, con el requisito de revisión resaltado.

    Antes de aprobar la continuación del flujo de trabajo, revisará los resultados what-if para asegurarse de que coincidan con las expectativas.

  4. Seleccione el trabajo preview (Vista previa).

  5. Seleccione el paso Run what-if (Ejecutar hipótesis) para inspeccionar los cambios sobre los que informa el comando hipotético.

  6. Observe que el registro de flujo de trabajo proporciona resultados what-if similares al código siguiente:

    Resource and property changes are indicated with these symbols:
  - Delete
  + Create
  ~ Modify
  = Nochange
  * Ignore

The deployment will update the following scope:

Scope: /subscriptions/***/resourceGroups/ToyWebsiteTest

  ~ Microsoft.OperationalInsights/workspaces/workspace-abcdefghijklm [2022-10-01]
    - properties.retentionInDays: 30
    - properties.sku:

        name: "pergb2018"

    - properties.workspaceCapping:

        dailyQuotaGb: -1.0

  ~ Microsoft.Web/sites/toy-website-abcdefghijklm [2022-03-01]
    + properties.siteConfig.localMySqlEnabled:   false
    + properties.siteConfig.netFrameworkVersion: "v4.6"

  = Microsoft.Insights/components/toywebsite [2020-02-02]
  = Microsoft.Storage/storageAccounts/mystorageabcdefghijklm [2022-09-01]
  = Microsoft.Web/serverfarms/toy-website [2022-03-01]
  * microsoft.alertsmanagement/smartDetectorAlertRules/Failure Anomalies - toywebsite

Resource changes: 2 to modify, 3 no change, 1 to ignore.

    La operación hipotética ha detectado un cambio en el área de trabajo de Log Analytics y en los recursos del sitio web. Pero los cambios que ha detectado son ruido. No representan cambios reales en el recurso. Con el tiempo, el equipo de Azure trabaja para reducir el ruido. Mientras tanto, los cambios detectados se pueden omitir.

    Es posible que también vea un elemento en la salida hipotética para el tipo de recurso microsoft.alertsmanagement/smartDetectorAlertRules/Failure Anomalies - toywebsite. Se trata de un recurso que Application Insights crea automáticamente. El comando hipotético detecta que no se realizará ningún cambio en el recurso.

Aprobación de la ejecución del flujo de trabajo

  1. Seleccione el Resumen para volver a la información general de la ejecución del flujo de trabajo.

    Captura de pantalla de la interfaz de GitHub en la que se muestra el menú Resumen, con la flecha atrás resaltada.

  2. Seleccione el botón Review deployments (Revisar implementaciones) en el panel de revisión.

  3. En el menú emergente Review pending deployments (Revisar implementaciones pendientes), seleccione el entorno Website (Sitio web). En el cuadro Leave a comment (Dejar un comentario), escriba Resultados what-if revisados.

  4. Seleccione Approve and deploy (Aprobar e implementar).

    Captura de pantalla de la interfaz de GitHub en la que se muestra la página de aprobación del flujo de trabajo, con el botón Aprobar resaltado.

Observación de la implementación correcta

  1. Después de aprobar la ejecución del flujo de trabajo, observe que el trabajo deploy (Implementación) empieza a ejecutarse.

    espere a que el trabajo finalice.

  2. Observe que la ejecución del flujo de trabajo finaliza correctamente.