Entrega continua con Acciones de GitHub

Artículo
03/16/2024

Puede usar un flujo de trabajo de Acciones de GitHub para definir un flujo de trabajo para compilar e implementar automáticamente código en su aplicación de funciones en Azure Functions.

Un archivo YAML (.yml) que define la configuración del flujo de trabajo se mantiene en la ruta de acceso /.github/workflows/ del repositorio. Esta definición contiene las acciones y parámetros que componen el flujo de trabajo, que es específico del lenguaje de desarrollo de las funciones. Un flujo de trabajo de Acciones de GitHub para Functions realiza las siguientes tareas, independientemente del lenguaje:

Configure el entorno.
Compilar el proyecto de código.
Implementar el paquete en una aplicación de funciones en Azure.

La acción Azure Functions controla la implementación en una aplicación de funciones existente en Azure.

Puede crear manualmente un archivo de configuración de flujo de trabajo para la implementación. También puede generar el archivo a partir de un conjunto de plantillas específicas del lenguaje de una de estas maneras:

En Azure Portal
Uso de la CLI de Azure
Desde el repositorio de GitHub

Si no desea crear el archivo YAML manualmente, seleccione otro método en la parte superior del artículo.

Requisitos previos

Una cuenta de Azure con una suscripción activa. Cree una cuenta gratuita.
Una cuenta de GitHub. Si no tiene ninguna, regístrese gratis.
Una aplicación de funciones en funcionamiento alojada en Azure con el código fuente en un repositorio de GitHub.

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

Genere las credenciales de implementación.

Dado que Acciones de GitHub usa el perfil de publicación para acceder a la aplicación de funciones durante la implementación, primero debe obtener el perfil de publicación y almacenarlo de forma segura como un secreto de GitHub.

Importante

El perfil de publicación es una credencial valiosa que permite el acceso a los recursos de Azure. Asegúrese de transportarlo y almacenarlo siempre de forma segura. En GitHub, el perfil de publicación solo debe almacenarse en secretos de GitHub.

Descarga del perfil de publicación

Para descargar el perfil de publicación de la aplicación de funciones:

Seleccione la página Información general de la aplicación de funciones y, después, seleccione Obtener perfil de publicación.
Guarde y copie el contenido del archivo.

Adición del secreto de GitHub

En GitHub, vaya al repositorio.
Vaya a Configuración.
Seleccione Secretos y variables > Acciones.
Seleccione New repository secret (Nuevo secreto del repositorio).
Agregue un nuevo secreto con el nombre AZURE_FUNCTIONAPP_PUBLISH_PROFILE y el valor establecido al contenido del archivo del perfil de publicación.
Seleccione Add secret (Agregar secreto).

Ahora GitHub puede autenticarse en su aplicación de funciones de Azure.

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.

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

Cuando se usa el portal para habilitar Acciones de GitHub, Functions crea un archivo de flujo de trabajo basado en la pila de aplicaciones y lo confirma en el repositorio de GitHub en el directorio correcto.

El portal obtiene automáticamente el perfil de publicación y lo agrega a los secretos de GitHub del repositorio.

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:

En Azure Portal, seleccione Implementación en el flujo Crear aplicación de funciones.
Habilite la Implementación continua si quiere que cada actualización de código desencadene un envío de código a Azure Portal.
Escriba la organización, el repositorio y la rama de GitHub.
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:

Vaya a la aplicación de funciones en Azure Portal y seleccione Centro de implementación.
En Origen, seleccione GitHub. Si no ve el mensaje predeterminado Compilación con Acciones de GitHub, seleccione Cambie el proveedor, elija Acciones de GitHub y seleccione Aceptar.
Si aún no ha autorizado el acceso a GitHub, seleccione Autorizar. Proporcione las credenciales de GitHub y seleccione Iniciar sesión. Para autorizar una cuenta de GitHub diferente, seleccione Cambiar la cuenta e inicie sesión con otra cuenta.
Seleccione la organización, el repositorio y la rama de GitHub. Debe tener acceso de escritura a este repositorio para implementarlo con Acciones de GitHub.
En Configuración de autenticación, elija si Acciones de GitHub se autentica con una identidad asignada por el usuario o mediante credenciales de autenticación básica. Para la autenticación básica, se usan las credenciales actuales.
Seleccione Obtener vista previa de archivo para ver el archivo de flujo de trabajo que se agregará a su repositorio de GitHub en github/workflows/.
Seleccione Guardar para agregar el archivo de flujo de trabajo al repositorio.

Adición de la configuración del flujo de trabajo a su repositorio

Puede usar el comando az functionapp deployment github-actions add para generar un archivo de configuración del flujo de trabajo a partir de la plantilla correcta para su aplicación de funciones. El nuevo archivo YAML se almacena después en la ubicación correcta (/.github/workflows/) en el repositorio de GitHub que haya proporcionado, mientras que el archivo de perfil de publicación de su aplicación se agrega a los secretos de GitHub en el mismo repositorio.

Ejecute este comando az functionapp, reemplazando los valores githubUser/githubRepo, MyResourceGroup y MyFunctionapp:
```
az functionapp deployment github-actions add --repo "githubUser/githubRepo" -g MyResourceGroup -n MyFunctionapp --login-with-github
```
Este comando usa un método interactivo para recuperar un token de acceso personal para la cuenta de GitHub.

En la ventana del terminal, debería ver algo parecido al siguiente mensaje:

Please navigate to https://github.com/login/device and enter the user code XXXX-XXXX to activate and retrieve your GitHub personal access token.

Copie el código único XXXX-XXXX, vaya a https://github.com/login/device y escriba el código que ha copiado. Después de escribir el código, debería ver algo parecido al siguiente mensaje:

Verified GitHub repo and branch
Getting workflow template using runtime: java
Filling workflow template with name: func-app-123, branch: main, version: 8, slot: production, build_path: .
Adding publish profile to GitHub
Fetching publish profile with secrets for the app 'func-app-123'
Creating new workflow file: .github/workflows/master_func-app-123.yml

Vaya a su repositorio de GitHub y seleccione Acciones. Compruebe que se ejecutó el flujo de trabajo.

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.

En GitHub, vaya al repositorio.
Seleccione Acciones y Nuevo flujo de trabajo.
Busque funciones.
En los flujos de trabajo de la aplicación de funciones creados por Microsoft Azure que se muestran, busque el que coincida con su lenguaje de código y seleccione Configurar.
En el archivo YAML recién creado, actualice el parámetro env.AZURE_FUNCTIONAPP_NAME con el nombre de su recurso de aplicación de funciones en Azure. Opcionalmente, es posible que tenga que actualizar el parámetro que establece la versión de idioma usada por la aplicación, como DOTNET_VERSION para C#.
Compruebe que el nuevo archivo de flujo de trabajo se está guardando en /.github/workflows/ y seleccione Confirmar cambios....

Actualización de una configuración de flujo de trabajo

Si por alguna razón necesita actualizar o cambiar una configuración de flujo de trabajo existente, solo tiene que ir a la ubicación /.github/workflows/ de su repositorio, abrir el archivo YAML específico, realizar los cambios necesarios y después confirmar las actualizaciones en el repositorio.

Ejemplo: archivo de configuración de flujo de trabajo

El siguiente ejemplo de plantilla usa la versión 1 del functions-action y un publish profile para la autenticación. La plantilla depende del idioma elegido y del sistema operativo en el que se implemente la aplicación de funciones:

Windows
Linux

Si la aplicación de funciones se ejecuta en Linux, seleccione Linux.

name: Deploy DotNet project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  DOTNET_VERSION: '6.0.x'                   # set this to the dotnet version to use (e.g. '2.1.x', '3.1.x', '5.0.x')

jobs:
  build-and-deploy:
    runs-on: windows-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup DotNet ${{ env.DOTNET_VERSION }} Environment
      uses: actions/setup-dotnet@v3
      with:
        dotnet-version: ${{ env.DOTNET_VERSION }}

    - name: 'Resolve Project Dependencies Using Dotnet'
      shell: pwsh
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        dotnet build --configuration Release --output ./output
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: '${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}/output'
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy DotNet project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  DOTNET_VERSION: '6.0.x'                   # set this to the dotnet version to use (e.g. '2.1.x', '3.1.x', '5.0.x')

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

    - name: Setup DotNet ${{ env.DOTNET_VERSION }} Environment
      uses: actions/setup-dotnet@v3
      with:
        dotnet-version: ${{ env.DOTNET_VERSION }}

    - name: 'Resolve Project Dependencies Using Dotnet'
      shell: bash
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        dotnet build --configuration Release --output ./output
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: '${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}/output'
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy Java project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  POM_XML_DIRECTORY: '.'                    # set this to the directory which contains pom.xml file
  JAVA_VERSION: '8'                         # set this to the java version to use (e.g. '8', '11', '17')

jobs:
  build-and-deploy:
    runs-on: windows-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup Java Sdk ${{ env.JAVA_VERSION }}
      uses: actions/setup-java@v1
      with:
        java-version: ${{ env.JAVA_VERSION }}

    - name: 'Restore Project Dependencies Using Mvn'
      shell: pwsh
      run: |
        pushd './${{ env.POM_XML_DIRECTORY }}'
        mvn clean package
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: '${{ env.POM_XML_DIRECTORY }}' # if there are multiple function apps in same project, then this path will be like './${{ env.POM_XML_DIRECTORY }}/target/azure-functions/${{ env.POM_FUNCTIONAPP_NAME }'
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}
        respect-pom-xml: true

name: Deploy Java project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  POM_XML_DIRECTORY: '.'                    # set this to the directory which contains pom.xml file
  JAVA_VERSION: '8'                         # set this to the java version to use (e.g. '8', '11', '17')

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

    - name: Setup Java Sdk ${{ env.JAVA_VERSION }}
      uses: actions/setup-java@v1
      with:
        java-version: ${{ env.JAVA_VERSION }}

    - name: 'Restore Project Dependencies Using Mvn'
      shell: bash
      run: |
        pushd './${{ env.POM_XML_DIRECTORY }}'
        mvn clean package
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: '${{ env.POM_XML_DIRECTORY }}' # if there are multiple function apps in same project, then this path will be like './${{ env.POM_XML_DIRECTORY }}/target/azure-functions/${{ env.POM_FUNCTIONAPP_NAME }'
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}
        respect-pom-xml: true

name: Deploy Node.js project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  NODE_VERSION: '16.x'                      # set this to the node version to use (e.g. '8.x', '10.x', '12.x')

jobs:
  build-and-deploy:
    runs-on: windows-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup Node ${{ env.NODE_VERSION }} Environment
      uses: actions/setup-node@v3
      with:
        node-version: ${{ env.NODE_VERSION }}

    - name: 'Resolve Project Dependencies Using Npm'
      shell: pwsh
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        npm install
        npm run build --if-present
        npm run test --if-present
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy Node.js project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  NODE_VERSION: '16.x'                      # set this to the node version to use (e.g. '8.x', '10.x', '12.x')

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

    - name: Setup Node ${{ env.NODE_VERSION }} Environment
      uses: actions/setup-node@v3
      with:
        node-version: ${{ env.NODE_VERSION }}

    - name: 'Resolve Project Dependencies Using Npm'
      shell: bash
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        npm install
        npm run build --if-present
        npm run test --if-present
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy Python project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  PYTHON_VERSION: '3.9'                     # set this to the python version to use (e.g. '3.6', '3.7', '3.8')

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

    - name: Setup Python ${{ env.PYTHON_VERSION }} Environment
      uses: actions/setup-python@v4
      with:
        python-version: ${{ env.PYTHON_VERSION }}

    - name: 'Resolve Project Dependencies Using Pip'
      shell: bash
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        python -m pip install --upgrade pip
        pip install -r requirements.txt --target=".python_packages/lib/site-packages"
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}
        scm-do-build-during-deployment: true
        enable-oryx-build: true

name: Deploy PowerShell project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root

jobs:
  build-and-deploy:
    runs-on: windows-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy PowerShell project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root

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

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

Acción de Azure Functions

La acción Azure Functions (Azure/azure-functions) define cómo se publica el código en una aplicación de funciones existente en Azure o en una ranura específica de la aplicación.

Parámetros

Los siguientes parámetros son los más usados con esta acción:

Parámetro	Explicación
app-name	(Obligatorio) El nombre de su aplicación de funciones.
slot-name	(Opcional) El nombre de una Ranura de implementación específica en la que quiere realizar la implementación. La ranura debe existir ya en su aplicación de funciones. Cuando no se especifica, el código se implementa en la ranura activa.
publish-profile	(Opcional) El nombre del secreto de GitHub que contiene su perfil de publicación.

También se admiten los parámetros siguientes, pero solo se usan en casos específicos:

Parámetro	Explicación
package	(Opcional) Establece una subruta en el repositorio desde la que se va a publicar. De forma predeterminada, este valor se establece en `.`, lo que significa que se implementan todos los archivos y carpetas del repositorio de GitHub.
respect-pom-xml	(Opcional) Solo se usa para las funciones de Java. Si es necesario que el artefacto de implementación de la aplicación se derive del archivo pom.xml. Cuando implemente aplicaciones con funciones Java, debe establecer este parámetro en `true` y establecer `package` en `.`. De manera predeterminada, este parámetro está establecido en `false`, lo que significa que el parámetro `package` debe apuntar a la ubicación del artefacto de su aplicación, como por ejemplo `./target/azure-functions/`.
respect-funcignore	(Opcional) Si Acciones de GitHub respeta el archivo .funcignore para excluir archivos y carpetas definidos en él. Establezca este valor en `true` cuando su repositorio tenga un archivo .funcignore y quiera usarlo para excluir rutas y archivos, como configuraciones de editores de texto, .vscode/ o un entorno virtual Python (.venv/). El valor predeterminado es `false`.
scm-do-build-during-deployment	(Opcional) Si el sitio de implementación de App Service (Kudu) realiza operaciones previas a la implementación. El sitio de implementación de la aplicación de funciones se puede encontrar en `https://<APP_NAME>.scm.azurewebsites.net/`. Cambie esta configuración a `true` cuando necesite controlar las implementaciones en Kudu en lugar de resolver las dependencias en el flujo de trabajo de Acciones de GitHub. El valor predeterminado es `false`. Para más información, consulte la configuración SCM_DO_BUILD_DURING_DEPLOYMENT.
enable-oryx-build	(Opcional) Si el sitio de implementación de Kudu resuelve las dependencias del proyecto mediante Oryx. Establezca en `true` cuando quiera usar Oryx para resolver las dependencias de su proyecto usando una compilación remota en lugar del flujo de trabajo de Acciones de GitHub. Cuando `true`, también debería estar establecido `scm-do-build-during-deployment` a `true`. El valor predeterminado es `false`.

Consideraciones

Tenga en cuenta las siguientes consideraciones al usar la acción de Azure Functions:

Al usar Acciones de GitHub, el código se implementa en su aplicación de funciones usando Implementación Zip de Azure Functions.
Las credenciales requeridas por GitHub para la conexión a Azure para la implementación se almacenan como secretos en el repositorio de GitHub y se accede a ellas en la implementación como secrets.<SECRET_NAME>.
El uso de un perfil de publicación es la forma más sencilla de que las Acciones de GitHub se autentiquen con Azure Functions para su implementación. También puede autenticar con una entidad de servicio. Para obtener más información, vea este repositorio de Acciones de GitHub.
Las acciones para configurar el entorno y ejecutar una compilación se generan a partir de las plantillas y son específicas del lenguaje.
Las plantillas usan env elementos para definir la configuración única para la compilación y la implementación.

Pasos siguientes

Más información sobre la integración de Azure y GitHub