Entrega continua mediante Acciones de GitHub

Puede usar un flujo de trabajo de Acciones de GitHub para definir un flujo de trabajo para compilar e implementar código automáticamente en la 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 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.
Implemente 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 el portal de Azure
Uso del 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 de trabajo hospedada en Azure con código fuente en un repositorio de GitHub.

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

Genere las credenciales de implementación.

Dado que Acciones de GitHub utiliza el perfil de publicación para acceder a la aplicación de función 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 recursos de Azure. Asegúrese de transportarlo y almacenarlo siempre de forma segura. En GitHub, el perfil de publicación solo debe almacenarse en los secretos de GitHub.

Descarga del perfil de publicación

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

En el portal de Azure, busque la página de su aplicación de funciones, expanda Configuración>Ajustes en la columna izquierda.
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 es Desactivado, no puede usar perfiles de publicación, por lo que seleccione Activado y , a continuación, Aplicar.
Seleccione la página Información general de la aplicación de funciones y, después, seleccione Obtener perfil de publicación.

Descargar perfil de publicación
Guarde y copie el contenido del archivo.

Agrega el 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 y el valor establecido al contenido del archivo del perfil de publicación.
Seleccione Add secret (Agregar secreto).

GitHub ahora puede autenticarse en la aplicación de funciones en 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 para tu 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 el portal Azure, seleccione Deployment en el flujo Crear aplicación de funciones.

Captura de pantalla de la opción Implementación en el menú de Functions.
Habilite Continuous Deployment si desea que cada actualización de código desencadene una inserción de código en 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 el portal Azure y seleccione Centro de implementación.
Para Source seleccione GitHub. Si no ve el mensaje predeterminado Building with Acciones de GitHub, seleccione Change provider elija Acciones de GitHub y seleccione OK.
Si aún no ha autorizado GitHub acceso, seleccione Authorize. 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.
Seleccione su organización de GitHub, repositorio y rama. Para implementar con Acciones de GitHub, debe tener acceso de escritura a este repositorio.
En Configuración de autenticación, elija si Acciones de GitHub se autentica con una identidad asignada por usuario o mediante credenciales de autenticación básica. Para la autenticación básica, se usan las credenciales actuales.
Seleccione Vista previa del archivo para ver el archivo de flujo de trabajo que se agrega al 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 para generar un archivo de configuración del flujo de trabajo a partir de la plantilla correcta para su aplicación de funciones. A continuación, el nuevo archivo YAML se almacena en la ubicación correcta (/.github/workflows/) en el repositorio de GitHub que proporcione, mientras que el archivo de perfil de publicación de la aplicación se agrega a GitHub secretos en el mismo repositorio.

Ejecute este comando , reemplazando los valores , y :
```
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 , vaya a 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 al repositorio de GitHub y seleccione Actions. 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 mostrados creados por Microsoft Azure, busque el que coincida con el lenguaje de código y seleccione Configure.
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. Opcionalmente, es posible que tenga que actualizar el parámetro que establece la versión de idioma usada por la aplicación, como para C#.
Compruebe que el nuevo archivo de flujo de trabajo se está guardando en y seleccione Confirmar cambios....

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

Si por algún motivo necesita actualizar o cambiar una configuración de flujo de trabajo existente, simplemente vaya a la ubicación del repositorio, abra el archivo YAML específico, realice los cambios necesarios y, a continuación, confirme 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 y un 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/functions-action) 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 al autenticarse con publish-profile. Cuando se usan credenciales de RBAC o la implementación en un plan de consumo no flexible, la acción puede resolver el valor, por lo que no es necesario incluir el parámetro .
remote-build	Establezca esta opción en 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 .

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) Permitir que el sitio de Kudu (por ejemplo, ) realice operaciones previas a la implementación, como compilaciones remotas. De manera predeterminada, se establece en . 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 .

enable-oryx-build (Opcional) Permita que el sitio de Kudu resuelva las dependencias del proyecto con Oryx. De manera predeterminada, se establece en . Si desea 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ámetro	Explicación
scm-do-build-during-deployment	(Opcional) Permitir que el sitio de Kudu (por ejemplo, ) realice operaciones previas a la implementación, como compilaciones remotas. De manera predeterminada, se establece en . 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 .
enable-oryx-build	(Opcional) Permita que el sitio de Kudu resuelva las dependencias del proyecto con Oryx. De manera predeterminada, se establece en . Si desea 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 apunta a una ranura que no es 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	Nombre del secreto en GitHub que contiene tu perfil de publicación.
respect-pom-xml	Solo se usa para funciones de Java. Si es necesario que el artefacto de implementación de la aplicación se derive del archivo pom.xml. Al implementar aplicaciones de funciones Java, debe establecer este parámetro en `true` y establecer `package` en `.`. De manera predeterminada, este parámetro está establecido en , lo que significa que el parámetro debe apuntar a la ubicación del artefacto de su aplicación, como por ejemplo .
respect-funcignore	Si Acciones de GitHub respeta el archivo .funcignore para excluir archivos y carpetas definidos en él. Establezca este valor en `true` cuando el repositorio tenga un archivo .funcignore y quieras usarlo para excluir rutas y archivos, como configuraciones de editores de texto, .vscode/, o un entorno virtual de Python (.venv/). El valor predeterminado es .

Consideraciones

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

Al usar Acciones de GitHub, la forma en que se implementa el código depende del plan de hospedaje, como se muestra en esta tabla:

Plan de hospedaje	Método de implementación
Consumo flexible	Una implementación
Elastic Premium	Implementación Zip en aplicaciones en Consumo
Dedicado (App Service)	Implementación Zip en aplicaciones en Consumo
Consumo	Windows: Zip deploy Linux: dirección URL del paquete externo

La capacidad de ejecutar las aplicaciones en Linux en un Plan de consumo está planeada para su retirada. Para obtener más información, consulte Azure Functions Plan de consumo de hospedaje.

Las credenciales requeridas por GitHub para conectarse 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>.
La manera más fácil de Acciones de GitHub autenticarse con Azure Functions para la implementación es mediante un perfil de publicación. También puede autenticar con una entidad de servicio. Para más información, consulte 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 elementos para definir la configuración única para la compilación y la implementación.

Pasos siguientes

Learn más sobre la integración de Azure y GitHub

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2026-03-06