Livraison continue à l’aide de GitHub Actions

Article
11/05/2024

Vous pouvez utiliser le flux de travail GitHub Actions pour définir un flux de travail permettant de générer et de déployer automatiquement du code sur votre application de fonction dans Azure Functions.

Un fichier YAML (.yml) qui définit la configuration du flux de travail est conservé dans le chemin d’accès /.github/workflows/ de votre référentiel. Cette définition contient les actions et les paramètres qui composent le flux de travail, qui est spécifique au langage de développement de vos fonctions. Un flux de travail GitHub Actions pour Functions effectue les tâches suivantes, quelle que soit la langue :

Configurez l’environnement.
Générez le projet de code.
Déployez le package sur une application de fonction dans Azure.

L’action Azure Functions gère le déploiement sur une application de fonction existante dans Azure.

Vous pouvez créer manuellement un fichier de configuration de flux de travail pour votre déploiement. Vous pouvez également générer le fichier à partir d’un ensemble de modèles spécifiques à la langue de l’une des manières suivantes :

Dans le portail Azure
Utilisation de l’interface de ligne de commande Azure (CLI)
À partir de votre référentiel GitHub

Si vous ne souhaitez pas créer votre fichier YAML manuellement, sélectionnez une autre méthode en haut de l’article.

Prérequis

Compte Azure avec un abonnement actif. Créez un compte gratuitement.
Un compte GitHub. Si vous n’en avez pas, inscrivez-vous gratuitement.
Une application de fonction opérationnelle hébergée sur Azure avec un code source dans un référentiel GitHub.

Azure CLI, lors du développement local. Vous pouvez également utiliser Azure CLI dans Azure Cloud Shell.

Générer les informations d’identification du déploiement

Étant donné que GitHub Actions utilise votre profil de publication pour accéder à votre application de fonction pendant le déploiement, vous devez d’abord obtenir votre profil de publication et le stocker en toute sécurité en tant que secret GitHub.

Important

Le profil de publication est une information d’identification précieuse qui permet d’accéder aux ressources Azure. Veillez à toujours le transporter et à le stocker en toute sécurité. Dans GitHub, le profil de publication doit uniquement être stocké dans des secrets GitHub.

Téléchargement du profil de publication

Pour télécharger le profil de publication de votre application de fonction :

Dans le Portail Azure, recherchez la page de votre application de fonction, puis développez Paramètres>Configuration dans la colonne de gauche.
Dans la page Configuration, sélectionnez l’onglet Paramètres généraux et vérifiez que les Informations d’identification d’authentification de base SCM sont Activées. Lorsque ce paramètre est Désactivé, vous ne pouvez pas utiliser de profils de publication. Sélectionnez donc Activé, puis Enregistrez.
Revenez à la page Vue d’ensemble de l’application de fonction, puis sélectionnez Obtenir le profil de publication.
Enregistrez et copiez le contenu du fichier.

Ajout du secret GitHub

Dans GitHub, accédez à votre dépôt.
Accédez à Settings.
Sélectionnez Secrets et variables > Actions.
Sélectionnez New repository secret (Nouveau secret de dépôt).
Ajoutez un nouveau secret avec le nom AZURE_FUNCTIONAPP_PUBLISH_PROFILE et la valeur définis sur le contenu du fichier de profil de publication.
Sélectionnez Ajouter un secret.

GitHub peut à présent s’authentifier auprès de votre application de fonction dans Azure.

Créer le flux de travail à partir d’un modèle

La meilleure façon de créer manuellement une configuration de flux de travail consiste à commencer à partir du modèle officiellement pris en charge.

Créer la configuration du flux de travail dans le portail

Lorsque vous utilisez le portail pour activer GitHub Actions, Functions crée un fichier de flux de travail basé sur votre pile d’applications et le valide dans votre référentiel GitHub dans le répertoire approprié.

Le portail obtient automatiquement votre profil de publication et l’ajoute aux secrets GitHub de votre référentiel.

Pendant la création d’application de fonction

Vous pouvez commencer rapidement à utiliser GitHub Actions via l’onglet Déploiement lorsque vous créez une fonction dans Portail Azure. Pour ajouter un flux de travail GitHub Actions lorsque vous créez une application de fonction :

Dans le Portail Azure, sélectionnez Déploiement dans le flux Créer une application de fonction.
Activez le Déploiement continu si vous souhaitez que chaque mise à jour de code déclenche une poussée de code vers le portail Azure.
Entrez votre organisation GitHub, votre référentiel et votre branche.
Terminez la configuration de votre application de fonction. Votre référentiel GitHub inclut désormais un nouveau fichier de flux de travail dans /.github/workflows/.

Pour une application de fonction existante

Pour ajouter un flux de travail GitHub Actions à une application de fonction existante :

Accédez à votre application de fonction dans le Portail Microsoft Azure et sélectionnez Centre de déploiement.
Pour Source, sélectionnez GitHub. Si vous ne voyez pas le message par défaut Construire avec les actions GitHub, sélectionnez Changer de fournisseur, choisissez GitHub Actions et sélectionnez OK.
Si vous n'avez pas encore autorisé l'accès à GitHub, sélectionnez Autoriser. Fournissez vos informations d'identification GitHub et sélectionnez Se connecter. Pour autoriser un autre compte GitHub, sélectionnez Changer de compte et connectez-vous avec un autre compte.
Sélectionnez votre organisation GitHub, votre référentiel et votre branche. Pour déployer avec GitHub Actions, vous devez avoir un accès en écriture à ce référentiel.
Dans Paramètres d'authentification, choisissez si les GitHub Actions doivent s'authentifier avec une identité attribuée par l'utilisateur ou à l'aide des informations d'authentification de base. Pour l'authentification de base, les informations d'identification actuelles sont utilisées.
Sélectionnez Aperçu du fichier pour voir le fichier de workflow ajouté à votre référentiel GitHub dans github/workflows/.
Sélectionnez Enregistrer pour ajouter le fichier de flux de travail à votre référentiel.

Ajoutez la configuration de flux de travail dans votre référentiel

Vous pouvez utiliser la commande az functionapp deployment github-actions add pour générer un fichier de configuration de flux de travail à partir du modèle approprié pour votre application de fonction. Le nouveau fichier YAML est ensuite stocké à l’emplacement approprié (/.github/workflows/) dans le référentiel GitHub que vous fournissez, tandis que le fichier de profil de publication de votre application est ajouté aux secrets GitHub dans le même référentiel.

Exécutez cette commande az functionapp, en remplaçant les valeurs githubUser/githubRepo, MyResourceGroupet MyFunctionapp :
```
az functionapp deployment github-actions add --repo "githubUser/githubRepo" -g MyResourceGroup -n MyFunctionapp --login-with-github
```
Cette commande utilise une méthode interactive pour récupérer un jeton d’accès personnel pour votre compte GitHub.

Dans la fenêtre de votre terminal, vous devez voir un message semblable au suivant :

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

Copiez le code unique XXXX-XXXX, accédez à https://github.com/login/device, puis entrez le code que vous avez copié. Après avoir entré votre code, le message suivant doit s’afficher :

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

Accédez à votre référentiel GitHub et sélectionnez Actions. Vérifiez que votre flux de travail a été exécuté.

Créez le fichier de configuration de flux de travail

Vous pouvez créer le fichier de configuration de flux de travail GitHub Actions à partir des modèles Azure Functions directement à partir de votre référentiel GitHub.

Dans GitHub, accédez à votre dépôt.
Sélectionnez Actions et Nouveau flux de travail.
Recherchez des fonctions.
Dans les flux de travail d’application de fonction affichés créés par Microsoft Azure, recherchez celui qui correspond à votre langage de code, puis sélectionnez Configurer.
Dans le fichier YAML nouvellement créé, mettez à jour le paramètre env.AZURE_FUNCTIONAPP_NAME avec le nom de votre ressource d’application de fonction dans Azure. Vous devrez peut-être mettre à jour le paramètre qui définit la version de langue utilisée par votre application, par exemple DOTNET_VERSION pour C#.
Vérifiez que le nouveau fichier de flux de travail est en cours d’enregistrement dans /.github/workflows/ puis sélectionnez Valider les modifications....

Mettre à jour une configuration de flux de travail

Si, pour une raison quelconque, vous devez mettre à jour ou changer une configuration de workflow existante, accédez simplement à l’emplacement /.github/workflows/ dans votre dépôt, ouvrez le fichier YAML spécifique, apportez les changements nécessaires, puis commitez les mises à jour dans le dépôt.

Exemple : fichier de configuration de flux de travail

L’exemple suivant de modèle utilise la version 1 du functions-action et un publish profile pour l’authentification. Le modèle dépend de la langue choisie et du système d’exploitation sur lequel votre application de fonction est déployée :

Windows
Linux

Si votre application de fonction s’exécute sur Linux, sélectionnez 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 }}

Action Azure Functions

L’action Azure Functions (Azure/azure-functions) définit la façon dont votre code est publié sur une application de fonction existante dans Azure ou sur un emplacement spécifique dans votre application.

Paramètres

Les paramètres suivants sont requis pour tous les plans d’application de fonction :

Paramètre	Explication
app-name	Le nom de votre application de fonction.
package	Il s'agit de l'emplacement de votre projet à publier. Par défaut, cette valeur est définie sur `.`, ce qui signifie que tous les fichiers et dossiers du référentiel GitHub seront déployés.

Les paramètres suivants sont requis pour le plan Flex Consommation :

Paramètre	Explication
sku	Définissez ceci `flexconsumption` lors de l'authentification avec publish-profile. Lors de l'utilisation des informations d'identification RBAC ou du déploiement sur un plan de Consommation non Flex, l'action peut résoudre la valeur, le paramètre n'a donc pas besoin d'être inclus.
remote-build	Définissez l’option `true` pour activer une action de génération à partir de Kudu lorsque le package est déployé sur une application Flex Consommation. La build Oryx est toujours effectuée lors d'une build à distance dans Flex Consommation ; ne définissez pas scm-do-build-during-deployment ou enable-oryx-build. Par défaut, ce paramètre a la valeur `false`.

Les paramètres suivants sont spécifiques aux plans Consommation, Elastic Premium et App Service (dédié) :

Paramètre Explication

scm-do-build-during-deployment (Facultatif) Autoriser le site Kudu (par exemple https://<APP_NAME>.scm.azurewebsites.net/) à effectuer des opérations de pré-déploiement, telles que des builds à distance. Par défaut, il a la valeur false. Définissez l’option true lorsque vous souhaitez contrôler les comportements de déploiement à l’aide de Kudu au lieu de résoudre les dépendances dans votre flux de travail GitHub. Pour plus d'informations, consultez le paramètre SCM_DO_BUILD_DURING_DEPLOYMENT.

enable-oryx-build (Facultatif) Autorisez le site Kudu à résoudre les dépendances de votre projet avec Oryx. Par défaut, il a la valeur false. Si vous souhaitez utiliser Oryx pour résoudre vos dépendances au lieu du workflow GitHub, définissez scm-do-build-during-deployment et enable-oryx-build sur true.

Paramètre	Explication
scm-do-build-during-deployment	(Facultatif) Autoriser le site Kudu (par exemple `https://<APP_NAME>.scm.azurewebsites.net/`) à effectuer des opérations de pré-déploiement, telles que des builds à distance. Par défaut, il a la valeur `false`. Définissez l’option `true` lorsque vous souhaitez contrôler les comportements de déploiement à l’aide de Kudu au lieu de résoudre les dépendances dans votre flux de travail GitHub. Pour plus d'informations, consultez le paramètre `SCM_DO_BUILD_DURING_DEPLOYMENT`.
enable-oryx-build	(Facultatif) Autorisez le site Kudu à résoudre les dépendances de votre projet avec Oryx. Par défaut, il a la valeur `false`. Si vous souhaitez utiliser Oryx pour résoudre vos dépendances au lieu du workflow GitHub, définissez scm-do-build-during-deployment et enable-oryx-build sur `true`.

Paramètres facultatifs pour tous les plans d'application de fonction :

Paramètre	Explication
slot-name	Il s’agit du nom de l’emplacement de déploiement vers lequel le déploiement doit être effectué. Par défaut, cette valeur est vide, ce qui signifie que l'action GitHub sera déployée sur votre site de production. Lorsque ce paramètre pointe vers un emplacement hors production, assurez-vous que le paramètre publish-profile contient les informations d'identification de l'emplacement au lieu du site de production. Actuellement non pris en charge dans Flex Consumption.
publish-profile	Le nom du secret GitHub qui contient votre profil de publication.
respect-pom-xml	Utilisé uniquement pour les fonctions Java. Indique s’il est nécessaire que l’artefact de déploiement de votre application soit dérivé du fichier pom.xml. Lorsque vous déployez des applications de fonction Java, vous devez définir ce paramètre sur `true` et définir `package` sur `.`. Par défaut, ce paramètre est défini sur `false`, ce qui signifie que le paramètre `package` doit pointer vers l’emplacement de l’artefact de votre application, tel que `./target/azure-functions/`
respect-funcignore	Si GitHub Actions respecte votre fichier .funcignore pour exclure les fichiers et dossiers définis dans celui-ci. Définissez cette valeur `true` lorsque votre référentiel dispose d'un fichier .funcignore et que vous souhaitez l'utiliser pour exclure les chemins et les fichiers, tels que les configurations de l'éditeur de texte, .vscode/ ou un environnement virtuel Python (.venv/). La valeur par défaut est `false`.

À propos de l’installation

Gardez à l’esprit les considérations suivantes lors de l’utilisation de l’action Azure Functions :

Lorsque vous utilisez GitHub Actions, le code est déployé à l’aide d’un déploiement sur des applications sur le plan Flex Consumption et le déploiement zip sur les applications sur les plans Consommation, Elastic Premium et Dedicated (App Service). L’exception est La consommation Linux, où l’URL du package externe est utilisée.
Les informations d’identification requises par GitHub pour se connecter à Azure pour le déploiement sont stockées en tant que Secrets dans votre référentiel GitHub et accessibles dans le déploiement en tant que secrets.<SECRET_NAME>.
La méthode recommandée pour GitHub Actions pour s’authentifier auprès d’Azure Functions pour le déploiement consiste à utiliser un profil de publication. Vous pouvez également vous authentifier avec un principal de service. Pour plus d’informations, consultez ce référentiel GitHub Actions.
Les actions de configuration de l’environnement et d’exécution d’une build sont générées à partir des modèles et sont spécifiques au langage.
Les modèles utilisent des éléments env pour définir des paramètres propres à votre build et à votre déploiement.

Étapes suivantes

En savoir plus sur l’intégration entre Azure et GitHub

Partager via