Entrega continua con Acciones de GitHub

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:

1. Configure el entorno.
2. Compilar el proyecto de código.
3. 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:

1. En Azure Portal, busque la página de la aplicación de funciones y expanda Configuración>Configuración en la columna izquierda.

2. En la página Configuración, seleccione la pestaña Configuración general y asegúrese de que las credenciales de publicación de autenticación básica de SCM estén activadas. Cuando esta configuración está Desactivada, no puede usar perfiles de publicación, así que seleccione Activada y, a continuación, Guardar.

3. Seleccione la página Información general de la aplicación de funciones y, después, seleccione Obtener perfil de publicación.

   

4. Guarde y copie el contenido del archivo.

Adición del secreto de GitHub

1. En GitHub, vaya al repositorio.

2. Vaya a Configuración.

3. Seleccione Secretos y variables > Acciones.

4. Seleccione New repository secret (Nuevo secreto del repositorio).

5. Agregue un nuevo secreto con el nombre AZURE_FUNCTIONAPP_PUBLISH_PROFILE y el valor establecido al contenido del archivo del perfil de publicación.

6. 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.

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

   Windows

   Las implementaciones en Windows usan runs-on: windows-latest.

   Linux

   Las implementaciones en Linux usan runs-on: ubuntu-latest.

2. Copie la plantilla específica del idioma del repositorio de acciones de Azure Functions mediante el vínculo siguiente:

   .NET

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/windows-dotnet-functionapp-on-azure.yml

   .NET

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/linux-dotnet-functionapp-on-azure.yml

   Java

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/windows-java-functionapp-on-azure.yml

   Java

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/linux-java-functionapp-on-azure.yml

   JavaScript

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/windows-node.js-functionapp-on-azure.yml

   JavaScript

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/linux-node.js-functionapp-on-azure.yml

   Python

   Las funciones de Python no se admiten en Windows. Elija Linux en su lugar.

   Python

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/linux-python-functionapp-on-azure.yml

   PowerShell

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/windows-powershell-functionapp-on-azure.yml

   PowerShell

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/linux-powershell-functionapp-on-azure.yml

3. Actualice el parámetro env.AZURE_FUNCTIONAPP_NAME con el nombre del recurso de la 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#.

4. 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 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:

1. En Azure Portal, seleccione Implementación en el flujo Crear aplicación de funciones.

   

2. Habilite la Implementación continua si quiere que cada actualización de código desencadene un envío de código a Azure Portal.

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

   

4. 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. Vaya a la aplicación de funciones en Azure Portal y seleccione Centro de implementación.

2. 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.

3. 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.

4. 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.

5. 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.

6. 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/.

7. 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.

1. 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.

2. 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.
   

3. 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
   

4. 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.

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 creados por Microsoft Azure que se muestran, busque el que coincida con su lenguaje de código y seleccione Configurar.

5. 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#.

6. 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

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

Linux

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

.NET

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 }}

.NET

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 }}

Java

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

Java

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

JavaScript

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 }}

JavaScript

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 }}

Python

Las funciones de Python no se admiten en Windows. Elija Linux en su lugar.

Python

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

PowerShell

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 }}

PowerShell

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 necesarios para todos los planes de aplicación de funciones:

Parámetro	Explicación
app-name	Nombre de la aplicación de funciones.
package	Esta es la ubicación del proyecto que se va a publicar. De forma predeterminada, este valor se establece en ., lo que significa que se implementarán todos los archivos y carpetas del repositorio de GitHub.

Los siguientes parámetros son necesarios para el plan de Flex Consumption:

Parámetro	Explicación
sku	Establézcalo en flexconsumption al autenticarse con publish-profile. Cuando se usan credenciales de RBAC o se implementa en un plan que no sea de Flex Consumption, la acción puede resolver el valor, por lo que no es necesario incluir el parámetro.
remote-build	Establezca esta opción en true para habilitar una acción de compilación desde Kudu cuando el paquete se implemente en una aplicación de Flex Consumption. La compilación de Oryx siempre se realiza durante una compilación remota en Flex Consumption; no establezca scm-do-build-during-deployment ni enable-oryx-build. De manera predeterminada, este parámetro está establecido en false.

Los siguientes parámetros son específicos de los planes Consumo, Elastic Premium y App Service (dedicado):

Parámetro	Explicación
scm-do-build-during-deployment	(Opcional) Permita que el sitio de Kudu (por ejemplo, https://<APP_NAME>.scm.azurewebsites.net/) realice operaciones previas a la implementación, como compilaciones remotas. De manera predeterminada, se establece en false. Establézcalo en true cuando desee controlar los comportamientos de implementación mediante Kudu en lugar de resolver las dependencias en el flujo de trabajo de GitHub. Para obtener más información, consulte la configuración de SCM_DO_BUILD_DURING_DEPLOYMENT.
enable-oryx-build	(Opcional) Permita que el sitio de Kudu resuelva las dependencias del proyecto con Oryx. De manera predeterminada, se establece en false. Si quiere usar Oryx para resolver las dependencias en lugar del flujo de trabajo de GitHub, establezca scm-do-build-during-deployment y enable-oryx-build en true.

Parámetros opcionales para todos los planes de aplicación de funciones:

Parámetro	Explicación
slot-name	Este es el nombre de la ranura de implementación en la que se realizará la implementación. De forma predeterminada, este valor está vacío, lo que significa que la acción de GitHub se implementará en el sitio de producción. Cuando esta configuración apunte a una ranura que no sea de producción, asegúrese de que el parámetro publish-profile contiene las credenciales de la ranura en lugar del sitio de producción. Actualmente no se admite en Flex Consumption.
publish-profile	El nombre del secreto de GitHub que contiene su perfil de publicación.
respect-pom-xml	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	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.

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