Configuración de una acción de GitHub para crear una instancia de contenedor

Acciones de GitHub es un conjunto de características de GitHub para automatizar los flujos de trabajo de desarrollo de software en el mismo lugar donde almacena el código y colabora en las solicitudes de incorporación de cambios y problemas.

Use las acciones de GitHub de implementación a Azure Container Instances para automatizar el proceso de implementación de un contenedor único en Azure Container Instances. La acción le permite establecer las propiedades de una instancia de contenedor de manera similar a las del comando az container create.

En este artículo se muestra cómo configurar un flujo de trabajo en un repositorio de GitHub que realiza las acciones siguientes:

• Creación de una imagen desde Dockerfile
• Inserción de la imagen en una instancia de Azure Container Registry
• Implementación de la imagen de contenedor en una instancia de Azure Container Instance

En este artículo se muestran dos maneras de configurar el flujo de trabajo:

• Configuración de un flujo de trabajo de GitHub: cree un flujo de trabajo en un repositorio de GitHub con la acción Deploy to Azure Container Instances y otras acciones.
• Uso de la extensión de la CLI: use el comando az container app up en la extensión Deploy to Azure en la CLI de Azure. Este comando simplifica la creación de un flujo de trabajo de GitHub y los pasos de implementación.

Importante

Actualmente, las acciones de GitHub para Azure Container Instances están en versión preliminar. Las versiones preliminares están a su disposición con la condición de que acepte los términos de uso adicionales. Es posible que algunos de los aspectos de esta característica cambien antes de ofrecer disponibilidad general.

Prerrequisitos

• Cuenta de GitHub: Cree una cuenta en https://github.com si aún no tiene una.
• CLI de Azure: Para completar los pasos de la CLI de Azure, puede usar Azure Cloud Shell o una instalación local de la CLI de Azure. Si necesita instalarla o actualizarla, vea Instalación de la CLI de Azure.
• Registro de contenedor de Azure: Si no tiene uno, cree un registro de contenedor de Azure en el nivel Básico mediante la CLI de Azure, Azure Portal u otros métodos. Tome nota del grupo de recursos que se utiliza para la implementación, que se usa para el flujo de trabajo de GitHub.

Configuración del repositorio

• Para ver los ejemplos de este artículo, utilice GitHub para bifurcar el siguiente repositorio: https://github.com/Azure-Samples/acr-build-helloworld-node

  Este repositorio contiene un Dockerfile y archivos de código fuente para crear una imagen de contenedor de una pequeña aplicación web.

  

• Asegúrese de Acciones esté habilitado para el repositorio. Navegue al repositorio bifurcado y seleccione Configuración>Acciones. En Permisos de acciones, asegúrese de que la opción Permitir todas las acciones esté seleccionada.

Configuración de flujo de trabajo de GitHub

Creación de credenciales para la autenticación de Azure

Entidad de servicio

En el flujo de trabajo de GitHub, debe proporcionar las credenciales de Azure para autenticarse en la CLI de Azure. En el ejemplo siguiente se crea una entidad de servicio con el rol Colaborador limitado al grupo de recursos del registro de contenedor.

En primer lugar, obtenga el identificador de recurso del grupo de recursos. Sustituya el nombre del grupo en el siguiente comando az group show:

groupId=$(az group show \
  --name <resource-group-name> \
  --query id --output tsv)

Utilice az ad sp create-for-rbac para crear la entidad de servicio:

az ad sp create-for-rbac \
  --scope $groupId \
  --role Contributor \
  --json-auth

La salida es parecida a esta:

{
  "clientId": "xxxx6ddc-xxxx-xxxx-xxx-ef78a99dxxxx",
  "clientSecret": "xxxx79dc-xxxx-xxxx-xxxx-aaaaaec5xxxx",
  "subscriptionId": "xxxx251c-xxxx-xxxx-xxxx-bf99a306xxxx",
  "tenantId": "xxxx88bf-xxxx-xxxx-xxxx-2d7cd011xxxx",
  "activeDirectoryEndpointUrl": "https://login.microsoftonline.com",
  "resourceManagerEndpointUrl": "https://management.azure.com/",
  "activeDirectoryGraphResourceId": "https://graph.windows.net/",
  "sqlManagementEndpointUrl": "https://management.core.windows.net:8443/",
  "galleryEndpointUrl": "https://gallery.azure.com/",
  "managementEndpointUrl": "https://management.core.windows.net/"
}

Guarde la salida de JSON porque se usará en un paso posterior. Además, tome nota de clientId, que necesita para actualizar la entidad de servicio en la sección siguiente.

OpenID Connect

Open ID Connect es un método de autenticación que usa tokens de corta duración. La configuración de OpenID Connect con Acciones de GitHub es un proceso más complejo que ofrece seguridad reforzada.

1. Si no tiene una aplicación existente, registre una nueva aplicación de Active Directory y una entidad de servicio que puedan acceder a los recursos. Cree la aplicación de Active Directory.

   az ad app create --display-name myApp
   

   Este comando genera un JSON de salida con un appId que es su client-id. Guarde el valor que se usará como secreto de GitHub de AZURE_CLIENT_ID más adelante.

   Usará el valor de objectId al crear credenciales federadas con Graph API y hará referencia a dicho valor como APPLICATION-OBJECT-ID.

2. Crear una entidad de servicio. Reemplace $appID por el valor de appId de la salida de JSON.

   Este comando genera una salida de JSON con un objectId diferente y se usará en el siguiente paso. El nuevo objectId es assignee-object-id.

   Copie el appOwnerTenantId para usarlo como secreto de GitHub para AZURE_TENANT_ID más adelante.

    az ad sp create --id $appId
   

3. Cree una asignación de roles por suscripción y objeto. De forma predeterminada, la asignación de roles se vinculará a la suscripción predeterminada. Reemplace $subscriptionId por el identificador de suscripción, $resourceGroupName por el nombre del grupo de recursos y $assigneeObjectId por el valor de assignee-object-id generado. Obtenga información sobre cómo administrar suscripciones de Azure con la CLI de Azure.

   az role assignment create --role contributor --subscription $subscriptionId --assignee-object-id  $assigneeObjectId --scope /subscriptions/$subscriptionId/resourceGroups/$resourceGroupName/providers/Microsoft.Web/sites/ --assignee-principal-type ServicePrincipal
   

4. Ejecute el siguiente comando para crear una credencial de identidad federada para la aplicación de Active Directory.

   • Reemplace APPLICATION-OBJECT-ID por el objectId (generado al crear la aplicación) de la aplicación de Active Directory.
   • Establezca un valor para CREDENTIAL-NAME al que haga referencia más adelante.
   • Establezca subject. Este valor lo define GitHub en función del flujo de trabajo:
     • Trabajos en el entorno de Acciones de GitHub: repo:< Organization/Repository >:environment:< Name >
     • En el caso de los trabajos no vinculados a un entorno, incluya la ruta de acceso de referencia para una rama o etiqueta en función de la ruta de acceso de referencia usada para desencadenar el flujo de trabajo: repo:< Organization/Repository >:ref:< ref path>. Por ejemplo, repo:n-username/ node_express:ref:refs/heads/my-branch o repo:n-username/ node_express:ref:refs/tags/my-tag.
     • En el caso de los flujos de trabajo desencadenados por un evento de solicitud de incorporación de cambios: repo:< Organization/Repository >:pull_request.

   az ad app federated-credential create --id <APPLICATION-OBJECT-ID> --parameters credential.json
   ("credential.json" contains the following content)
   {
       "name": "<CREDENTIAL-NAME>",
       "issuer": "https://token.actions.githubusercontent.com/",
       "subject": "repo:organization/repository:ref:refs/heads/main",
       "description": "Testing",
       "audiences": [
           "api://AzureADTokenExchange"
       ]
   }
   

Para obtener información sobre cómo crear una aplicación, una entidad de servicio y credenciales federadas de Active Directory en Azure Portal, consulte Conexión de GitHub y Azure.

Actualización para la autenticación del registro

Entidad de servicio

Actualice las credenciales de la entidad de servicio de Azure para habilitar el acceso de inserción y extracción en el registro de contenedor. Este paso permite que el flujo de trabajo de GitHub use la entidad de servicio para autenticarse en el registro de contenedor y realizar la inserción y extracción de una imagen de Docker.

Obtenga el identificador de recurso del registro de contenedor. Sustituya el nombre del registro en el siguiente comando az acr show:

registryId=$(az acr show \
  --name <registry-name> \
  --resource-group <resource-group-name> \
  --query id --output tsv)

Utilice az role assignment create para asignar el rol AcrPush, que proporciona acceso de inserción y extracción al registro. Sustituya el id. de cliente de la entidad de servicio:

az role assignment create \
  --assignee <ClientId> \
  --scope $registryId \
  --role AcrPush

OpenID Connect

Debe conceder permiso a la aplicación para acceder a Azure Container Registry y crear una instancia de contenedor de Azure.

1. Vaya a Registros de aplicaciones en Azure Portal.

2. Busque el registro de la aplicación OpenID Connect y copie el identificador de la aplicación (cliente).

3. Conceda permisos para la aplicación al grupo de recursos. Deberá establecer permisos en el nivel de grupo de recursos para poder crear instancias de contenedor de Azure.

   az role assignment create \
   --assignee <appID> \
   --role Contributor \
    --scope /subscriptions/<subscription-id>/resourceGroups/<resource-group>
   

Almacenamiento de las credenciales en el repositorio de GitHub

Entidad de servicio

1. En la interfaz de usuario de GitHub, vaya al repositorio bifurcado y seleccione Security > Secrets and variables > Actions.

2. Seleccione Nuevo secreto de repositorio para agregar los siguientes secretos:

Secreto	Value
AZURE_CREDENTIALS	Toda la salida JSON del paso de creación de la entidad de servicio
REGISTRY_LOGIN_SERVER	Nombre del servidor de inicio de sesión del registro (todo en minúsculas). Ejemplo: myregistry.azurecr.io
REGISTRY_USERNAME	clientId de la salida JSON de la creación de la entidad de servicio
REGISTRY_PASSWORD	clientSecret de la salida JSON de la creación de la entidad de servicio
RESOURCE_GROUP	Nombre del grupo de recursos que usó para limitar el ámbito de la entidad de servicio

OpenID Connect

Debe especificar el identificador de cliente, el identificador de inquilino y el identificador de suscripción en la acción de inicio de sesión. Estos valores se pueden proporcionar directamente en el flujo de trabajo o se pueden almacenar en secretos de GitHub y se puede hacer referencia a ellos en el flujo de trabajo. Guardar los valores como secretos de GitHub es la opción más segura.

1. Abra el repositorio de GitHub y vaya a Configuración > Seguridad > Secretos y variables > Acciones > Nuevo secreto de repositorio.

2. Cree secretos para AZURE_CLIENT_ID, AZURE_TENANT_ID y AZURE_SUBSCRIPTION_ID. Use estos valores de la aplicación de Active Directory para los secretos de GitHub:

   Secreto de GitHub	Aplicación de Active Directory
   AZURE_CLIENT_ID	Id. de aplicación (cliente)
   AZURE_TENANT_ID	Id. de directorio (inquilino)
   AZURE_SUBSCRIPTION_ID	Id. de suscripción

3. Guarde todos los secretos, para lo que debe seleccionar Add secret (Agregar secreto).

Creación del archivo de flujo de trabajo

1. En la interfaz de usuario de GitHub, seleccione Acciones.
2. Seleccione Set up a workflow yourself (Configurar un flujo de trabajo personalmente).
3. En Edit new file (Editar nuevo archivo), pegue el contenido de YAML siguiente para sobrescribir el código de ejemplo. Acepte el nombre de archivo predeterminado main.yml o proporcione un nombre de archivo a su elección.
4. Seleccione Start commit (Iniciar confirmación) y, opcionalmente, proporcione descripciones breves y ampliadas de la confirmación, y seleccione Commit new file (Confirmar nuevo archivo).

Entidad de servicio

on: [push]
name: Linux_Container_Workflow

jobs:
    build-and-deploy:
        runs-on: ubuntu-latest
        steps:
        # checkout the repo
        - name: 'Checkout GitHub Action'
          uses: actions/checkout@main

        - name: 'Login via Azure CLI'
          uses: azure/login@v1
          with:
            creds: ${{ secrets.AZURE_CREDENTIALS }}

        - name: 'Build and push image'
          uses: docker/login-action@v3
          with:
            registry: $({ secrets.REGISTRY_LOGIN_SERVER })
            username: ${{ secrets.AZURE_CLIENT_ID }}
            password: ${{ secrets.AZURE_CLIENT_SECRET }}
        - run: |
            docker build . -t ${{ secrets.REGISTRY_LOGIN_SERVER }}/sampleapp:${{ github.sha }}
            docker push ${{ secrets.REGISTRY_LOGIN_SERVER }}/sampleapp:${{ github.sha }}

        - name: 'Deploy to Azure Container Instances'
          uses: 'azure/aci-deploy@v1'
          with:
            resource-group: ${{ secrets.RESOURCE_GROUP }}
            dns-name-label: ${{ secrets.RESOURCE_GROUP }}${{ github.run_number }}
            image: ${{ secrets.REGISTRY_LOGIN_SERVER }}/sampleapp:${{ github.sha }}
            registry-login-server: ${{ secrets.REGISTRY_LOGIN_SERVER }}
            registry-username: ${{ secrets.REGISTRY_USERNAME }}
            registry-password: ${{ secrets.REGISTRY_PASSWORD }}
            name: aci-sampleapp
            location: 'west us'

OpenID Connect

on: [push]
name: Linux_Container_Workflow_OIDC

permissions:
  id-token: write
  contents: read

on:
  push:
    branches:
    - main
    - release/*

jobs:
    build-and-deploy:
        runs-on: ubuntu-latest
        steps:
        - name: 'Checkout GitHub Action'
          uses: actions/checkout@main

        - name: 'Login via Azure CLI'
          uses: azure/login@v1
          with:
           client-id: ${{ secrets.AZURE_CLIENT_ID }}
           tenant-id: ${{ secrets.AZURE_TENANT_ID }}
           subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

        - name: Build and push image
          id: build-image
          run: |
           az acr build --image ${{ secrets.REGISTRY_LOGIN_SERVER }}/sampleapp:${{ github.sha }} --registry ${{ secrets.REGISTRY_LOGIN_SERVER }} --file "Dockerfile" .

        - name: 'Deploy to Azure Container Instances'
          uses: 'azure/aci-deploy@v1'
          with:
           resource-group: ${{ secrets.RESOURCE_GROUP }}
           dns-name-label: ${{ secrets.RESOURCE_GROUP }}${{ github.run_number }}
           image: ${{ secrets.REGISTRY_LOGIN_SERVER }}/sampleapp:${{ github.sha }}
           registry-login-server: ${{ secrets.REGISTRY_LOGIN_SERVER }}
           registry-username: ${{ secrets.REGISTRY_USERNAME }}
           registry-password: ${{ secrets.REGISTRY_PASSWORD }}
           name: aci-sampleapp
           location: 'west us'

Validación del flujo de trabajo

Después de confirmar el archivo de flujo de trabajo, este se desencadena. Para revisar el progreso del flujo de trabajo, vaya a Acciones>Flujos de trabajo.

Consulte Viewing workflow run history para obtener información sobre cómo ver el estado y los resultados de cada paso del flujo de trabajo. Si el flujo de trabajo no se completa, consulte Visualización de registros para diagnosticar errores.

Cuando se complete correctamente el flujo de trabajo, obtenga información sobre la instancia de contenedor denominada aci-sampleapp mediante la ejecución del comando az container show. Sustituya el nombre del grupo de recursos:

az container show \
  --resource-group <resource-group-name> \
  --name aci-sampleapp \
  --query "{FQDN:ipAddress.fqdn,ProvisioningState:provisioningState}" \
  --output table

La salida es parecida a esta:

FQDN                                   ProvisioningState
---------------------------------      -------------------
aci-action01.westus.azurecontainer.io  Succeeded

Una vez aprovisionada la instancia, navegue hasta el FQDN del contenedor en el explorador para ver la aplicación web en ejecución.

Uso de la extensión Implementar en Azure

Como alternativa, utilice la extensión Implementar en Azure en la CLI de Azure para configurar el flujo de trabajo. El comando az container app up de la extensión toma los parámetros de entrada del usuario para configurar un flujo de trabajo que se va a implementar en Azure Container Instances.

El flujo de trabajo creado por la CLI de Azure es similar al flujo de trabajo que puede crear manualmente mediante GitHub.

Requisitos previos adicionales

Además de los requisitos previos y de la configuración del repositorio para este escenario, debe instalar la extensión Implementar en Azure para la CLI de Azure.

Ejecute el comando az extension add para instalar la extensión:

az extension add \
  --name deploy-to-azure

Para obtener información sobre cómo buscar, instalar y administrar extensiones, consulte Uso de extensiones con la CLI de Azure.

Ejecute az container app up:

Para ejecutar el comando az container app up, proporcione como mínimo:

• El nombre de la instancia de Azure Container Registry, por ejemplo, miregistro
• La dirección URL del repositorio de GitHub, por ejemplo, https://github.com/<your-GitHub-Id>/acr-build-helloworld-node

Comando de ejemplo:

az container app up \
  --acr myregistry \
  --repository https://github.com/myID/acr-build-helloworld-node

Progreso del comando

• Cuando se le solicite, proporcione sus credenciales de GitHub o proporcione un token de acceso personal (PAT) de GitHub que tenga ámbitos de repositorio y de usuario para autenticarse en la cuenta de GitHub. Si proporciona las credenciales de GitHub, el comando crea un PAT automáticamente. Siga las indicaciones adicionales para configurar el flujo de trabajo.

• El comando crea secretos del repositorio para el flujo de trabajo:

  • Credenciales de la entidad de servicio para la CLI de Azure
  • Credenciales para el acceso a la instancia de Azure Container Registry

• Después de que el comando confirme el archivo de flujo de trabajo en el repositorio, se desencadena el flujo de trabajo.

La salida es parecida a esta:

[...]
Checking in file github/workflows/main.yml in the GitHub repository myid/acr-build-helloworld-node
Creating workflow...
GitHub Action Workflow has been created - https://github.com/myid/acr-build-helloworld-node/runs/515192398
GitHub workflow completed.
Workflow succeeded
Your app is deployed at:  http://acr-build-helloworld-node.eastus.azurecontainer.io:8080/

Para ver el estado del flujo de trabajo y los resultados de cada paso en la UI de GitHub, consulte Viewing workflow run history.

Validación del flujo de trabajo

El flujo de trabajo implementa una instancia de Azure Container Instance con el nombre base del repositorio de GitHub, en este caso acr-build-helloworld-node. Cuando se complete el flujo de trabajo correctamente, obtenga información sobre la instancia de contenedor denominada acr-build-helloworld-node mediante la ejecución del comando az container show. Sustituya el nombre del grupo de recursos:

az container show \
  --resource-group <resource-group-name> \
  --name acr-build-helloworld-node \
  --query "{FQDN:ipAddress.fqdn,ProvisioningState:provisioningState}" \
  --output table

La salida es parecida a esta:

FQDN                                                   ProvisioningState
---------------------------------                      -------------------
acr-build-helloworld-node.westus.azurecontainer.io     Succeeded

Una vez aprovisionada la instancia, navegue hasta el FQDN del contenedor en el explorador para ver la aplicación web en ejecución.

Limpieza de recursos

Detenga la instancia de contenedor con el comando az container delete:

az container delete \
  --name <instance-name>
  --resource-group <resource-group-name>

Para eliminar el grupo de recursos y todos los recursos que contiene, ejecute el comando az group delete:

az group delete \
  --name <resource-group-name>

Pasos siguientes

Explore GitHub Marketplace para ver más acciones para automatizar el flujo de trabajo de desarrollo.