Despliega en Azure Functions usando Acciones de GitHub

Cuando usas el portal de Azure para habilitar Acciones de GitHub, Functions realiza estas tareas automáticamente, tanto en tu suscripción de Azure como en tu repositorio de GitHub.

• CLI de Azure, al desarrollar localmente. También puede usar el CLI de Azure en Azure Cloud Shell.

Crea una identidad gestionada para el despliegue de Acciones de GitHub

OpenID Connect (OIDC) es el método de autenticación recomendado para despliegues de Acciones de GitHub en Azure Functions. Con OIDC, configuras una identidad gestionada asignada por el usuario en Azure y creas una relación de confianza con tu repositorio de GitHub. El flujo de trabajo puede autenticarse con Azure sin almacenar credenciales como secretos.

1. Utiliza el comando az identity create para crear una identidad gestionada asignada al usuario.

   az identity create --name myGitHubDeployIdentity --resource-group <RESOURCE_GROUP> \
   --query "{clientId: clientId, tenantId: tenantId}" -o table
   

   Reemplace <RESOURCE_GROUP> por el nombre del grupo de recursos.

2. En la salida, anota los clientId valores de y tenantId . También consigue tu ID de suscripción:

   az account show --query "{subId: id}" -o table
   

   Necesitas estos tres valores más adelante cuando añadas credenciales a GitHub.

3. Utiliza el comando create de asignación de rol az para asignar el Website Contributor rol a la identidad gestionada, con el alcance de tu aplicación de función:

   IDENTITY_PRINCIPAL=$(az identity show --name myGitHubDeployIdentity --resource-group <RESOURCE_GROUP> --query 'principalId' -o tsv)
   FUNCTION_APP_ID=$(az functionapp show --name <APP_NAME> --resource-group <RESOURCE_GROUP> --query 'id' -o tsv)
   az role assignment create --assignee $IDENTITY_PRINCIPAL --role "Website Contributor" --scope $FUNCTION_APP_ID
   

   Sustituye <APP_NAME> y <RESOURCE_GROUP> por los nombres de tu app y grupo de recursos, respectivamente.

4. Utiliza el comando de creación de credenciales federadas de identidad de az para crear una credencial federada que confíe en los tokens de tu repositorio de GitHub:

   az identity federated-credential create \
       --identity-name myGitHubDeployIdentity \
       --resource-group <RESOURCE_GROUP> \
       --name github-deploy-credential \
       --issuer https://token.actions.githubusercontent.com \
       --subject repo:<GITHUB_ORG>/<REPO_NAME>:ref:refs/heads/<BRANCH_NAME> \
       --audiences api://AzureADTokenExchange
   

   Reemplace <RESOURCE_GROUP>, <GITHUB_ORG>, <REPO_NAME> y <BRANCH_NAME> por sus valores. El sujeto debe coincidir con la rama que activa tu flujo de trabajo.

5. (Opcional) Si despliegas un contenedor desde Azure Container Registry, también asigna el acrpull rol a la identidad gestionada:

   IDENTITY_PRINCIPAL=$(az identity show --name myGitHubDeployIdentity --resource-group <RESOURCE_GROUP> --query 'principalId' -o tsv)
   az role assignment create --assignee $IDENTITY_PRINCIPAL --role acrpull \
       --scope /subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.ContainerRegistry/registries/<REGISTRY_NAME>
   

   Reemplace <SUBSCRIPTION_ID>, <RESOURCE_GROUP> y <REGISTRY_NAME> por sus valores.

Añadir credenciales a GitHub

Utiliza los valores que copiaste cuando creaste la identidad gestionada.

1. En GitHub, vaya al repositorio.

2. Ve a Ajustes>Secretos y variables>Acciones.

3. En la pestaña de Secretos , selecciona Nuevo secreto de repositorio.

4. Crea cada uno de los siguientes secretos:

   Nombre	Value
   AZURE_CLIENT_ID	La clientId de la identidad gestionada
   AZURE_TENANT_ID	La tenantId de la identidad gestionada
   AZURE_SUBSCRIPTION_ID	El ID de suscripción que contiene tu aplicación de función

Para despliegues de contenedores desde un registro privado, también necesitas secretos específicos de cada registro. Para más información, véase Acción de inicio de sesión en Docker.

Crear un flujo de trabajo a partir de una plantilla

La mejor manera de crear manualmente una configuración de flujo de trabajo es empezar a partir de la plantilla compatible oficialmente.

1. Elija Windows o Linux para asegurarse de que obtiene la plantilla para el sistema operativo correcto.

   • Windows
   • Linux

   Las implementaciones para Windows usan runs-on: windows-latest. Los despliegues en contenedores requieren Linux.

2. Utiliza la plantilla de flujo de trabajo OIDC específica del lenguaje del repositorio de acciones de Azure Functions. Copia el contenido completo del archivo en un nuevo archivo llamado .github/workflows/deploy-function-app.yml en tu repositorio:

   • .NET
   • Java
   • JavaScript
   • Python
   • PowerShell
   • Contenedor

   name: Build and deploy .NET project to Azure Function App using OIDC
   
   on:
     push:
       branches: [ main ]
     workflow_dispatch:
   
   env:
     AZURE_FUNCTIONAPP_NAME: 'APP_NAME'         # Set this to your function app name on Azure 
     AZURE_FUNCTIONAPP_PROJECT_PATH: '.'        # Set this to the path to your function app project, defaults to the repository root. The deploy action will package the contents of this path.
     DOTNET_VERSION: '10.0.x'                   # Set this to the .NET version of your project
     BUILD_ARTIFACT_NAME: 'released-package'    # Set this according to your team's naming convention
     
   jobs:
     build:
       runs-on: windows-latest # Assumes your target function app is Windows-based
       permissions:
         id-token: write  # Required for OIDC
         contents: read   # Required for actions/checkout
       defaults:
         run:
           shell: bash
           working-directory: ${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}
       steps:
         - name: 'Checkout repository'
           uses: actions/checkout@v6
   
         - name: 'Set up .NET version: ${{ env.DOTNET_VERSION }}'
           uses: actions/setup-dotnet@v5
           with:
             dotnet-version: ${{ env.DOTNET_VERSION }}
   
         # Perform additional steps such as running tests, if needed
   
         - name: 'Build and prepare .NET project for deployment'
           run: dotnet publish --configuration Release --output ./output
   
         - name: Upload artifact for the deployment job
           uses: actions/upload-artifact@v7
           with:
             name: ${{ env.BUILD_ARTIFACT_NAME }}
             path: ${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/output
             include-hidden-files: true  # Required for .NET projects
     
     deploy:
       runs-on: windows-latest # Assumes your target function app is Windows-based
       needs: build
       permissions:
         id-token: write  # Required for OIDC
       steps:
         - name: 'Download artifact from build job'
           uses: actions/download-artifact@v8
           with:
             name: ${{ env.BUILD_ARTIFACT_NAME }}
             path: '${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/downloaded-artifact'
        
         - name: 'Log in to Azure with AZ CLI'
           uses: azure/login@v3
           with:
             client-id: ${{ vars.AZURE_CLIENT_ID }}
             tenant-id: ${{ vars.AZURE_TENANT_ID }}
             subscription-id: ${{ vars.AZURE_SUBSCRIPTION_ID }}
           
         - name: 'Run the Azure Functions action'
           uses: Azure/functions-action@v1
           id: deploy-to-function-app
           with:
             app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
             package: '${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/downloaded-artifact'
   

3. En la plantilla, actualiza las env: variables de tu proyecto. Cada plantilla requiere AZURE_FUNCTIONAPP_NAME. Las otras variables dependen de tu lenguaje:

   • .NET
   • Java
   • JavaScript
   • Python
   • PowerShell
   • Contenedor

   Variable	Obligatorio	Description
   AZURE_FUNCTIONAPP_NAME	Sí	Nombre de tu aplicación de función en Azure
   DOTNET_VERSION	Sí	La versión .NET de tu proyecto (por ejemplo, 10.0.x)
   AZURE_FUNCTIONAPP_PROJECT_PATH	No	Ruta hacia la carpeta de tu proyecto. Por defecto: . (raíz del repositorio)

4. Las plantillas OIDC ya incluyen el azure/login paso con autenticación OIDC. Verifica que las secrets.AZURE_CLIENT_IDreferencias , secrets.AZURE_TENANT_ID, y secrets.AZURE_SUBSCRIPTION_IDcoincidan con los secretos del repositorio que creaste.

5. Agregue este nuevo archivo YAML en la ruta de acceso /.github/workflows/ del repositorio.

Creación de la configuración del flujo de trabajo en el portal

Cuando usas el portal para habilitar Acciones de GitHub, Functions se encarga de toda la configuración automáticamente. No necesitas crear manualmente una identidad gestionada, configurar credenciales ni escribir un archivo de flujo de trabajo. Functions realiza estas tareas por ti:

En tu suscripción a Azure:

• Crea una identidad gestionada asignada por el usuario y le asigna el rol de Colaborador del sitio web en tu aplicación funcional.
• Añade una credencial federada a la identidad gestionada para la autenticación OIDC de GitHub.

En tu repositorio de GitHub:

• Añade los valores del ID del cliente, ID de suscripción y ID de tenant como secretos de Acciones de GitHub.
• Crea un archivo de flujo de trabajo basado en tu pila de aplicaciones y lo hace commit en .github/workflows.

Durante la creación de la aplicación de funciones

Puede empezar a trabajar rápidamente con Acciones de GitHub a través de la pestaña Implementación al crear una función en Azure portal. Para agregar un flujo de trabajo de Acciones de GitHub al crear una nueva aplicación de funciones:

1. En el portal Azure, seleccione Deployment en el flujo Crear aplicación de funciones.

2. Habilite Continuous Deployment si desea que cada actualización de código desencadene una inserción de código en Azure portal.

3. En la configuración de GitHub, selecciona Autorizar para conectar tu cuenta de GitHub. Inicia sesión con la cuenta de GitHub que tiene acceso de escritura a tu repositorio.

4. Escriba la organización, el repositorio y la rama de GitHub.

5. Opcionalmente, selecciona Archivo de Vista previa para ver cómo se ve el archivo de flujo de trabajo antes de que se genere y añada a tu repositorio.

6. Complete la configuración de la aplicación de funciones. El repositorio de GitHub ahora incluye un nuevo archivo de flujo de trabajo en /.github/workflows/.

Para una aplicación de funciones existente

Para agregar un flujo de trabajo de Acciones de GitHub a una aplicación de funciones existente:

1. Ve a tu aplicación de funciones en el portal de Azure y seleccionaCentro de despliegue de >.

2. Seleccione Despliegue Continuo (CI/CD). En Origen, seleccione GitHub. Si no ves la creación de mensajes por defecto con Acciones de GitHub, selecciona el proveedor de cambios, selecciona Acciones de GitHub y selecciona OK.

3. Si aún no has autorizado el acceso a GitHub, selecciona Autorizar. Proporcione sus credenciales de GitHub y seleccione Sign in. Para autorizar una cuenta de GitHub diferente, seleccione Change Account e inicie sesión con otra cuenta.

4. Seleccione su organización de GitHub, repositorio y rama. Para desplegar usando Acciones de GitHub, debes tener acceso de escritura a este repositorio.

5. Para la opción Flujo de trabajo, selecciona Añadir un flujo de trabajo. Esta opción crea un nuevo archivo de flujo de trabajo en /.github/workflows/. Para usar un flujo de trabajo existente, selecciona Usar flujo de trabajo disponible y elige tu archivo de flujo de trabajo.

6. En la configuración de autenticación, elige Identidad asignada por el usuario para usar OpenID Connect (OIDC), lo cual se recomienda porque no requiere almacenar secretos en GitHub. Selecciona tu suscripción y el nombre de identidad (Nuevo) sugerido. Se crea una nueva identidad gestionada asignada por el usuario y se concede acceso al rol de Contribuidor del Sitio Web . Si utilizas una identidad existente, primero debes concederle acceso al rol de Colaborador del Sitio Web .

   Importante

   Cuando seleccionas Autenticación Básica, tu perfil de publicación, que contiene secretos compartidos, se almacena en GitHub Secrets. También debes activar la autenticación SCM básica, lo que hace que tu aplicación sea menos segura.

7. Seleccione Vista previa del archivo para ver el archivo de flujo de trabajo que se agrega al repositorio de GitHub en .github/workflows/.

8. Seleccione Guardar para agregar el archivo de flujo de trabajo al repositorio. Seleccione la pestaña Registros para ver el estado de los despliegues actuales y anteriores.

Creación del archivo de configuración de flujo de trabajo

Puede crear el archivo de configuración de flujo de trabajo de Acciones de GitHub desde las plantillas de Azure Functions directamente desde el repositorio de GitHub.

1. En GitHub, vaya al repositorio.

2. Seleccione Acciones y Nuevo flujo de trabajo.

3. Busque funciones.

   

4. En los flujos de trabajo de la aplicación de funciones mostrados creados por Microsoft Azure, busque el que coincida con el lenguaje de código y seleccione Configure.

5. En el archivo YAML recién creado, actualice el parámetro env.AZURE_FUNCTIONAPP_NAME con el nombre del recurso de la aplicación de funciones en Azure. También puede que necesites actualizar el parámetro que establece la versión del lenguaje que usa tu app, como DOTNET_VERSION para C# o PYTHON_VERSION aplicaciones de Python.

6. Las plantillas predeterminadas podrían usar la autenticación de publicar el perfil en lugar del OIDC recomendado. Para cambiar a OIDC y alinearse con los comportamientos del portal, realiza los siguientes cambios:

   • Elimina los publish-profileparámetros , scm-do-build-during-deployment, y enable-oryx-build de Azure/functions-action.

   • Elimina la environment configuración del puesto (si existe), ya que el sujeto de credencial federada debe coincidir con el disparador de la rama.

   • Añade un azure/login paso antes del Azure/functions-action paso:

     - name: 'Login via OIDC'
       uses: azure/login@v3
       with:
         client-id: ${{ secrets.AZURE_CLIENT_ID }}
         tenant-id: ${{ secrets.AZURE_TENANT_ID }}
         subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
     
     - name: 'Run Azure Functions Action'
       uses: Azure/functions-action@v1
       with:
         app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
         package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
     

   • Añade los siguientes permisos al trabajo:

     permissions:
       id-token: write
       contents: read
     

7. Verifica que el nuevo archivo de flujo de trabajo esté guardado con un nombre apropiado y /.github/workflows/selecciona Commit cambios.