Livraison continue à l’aide de GitHub Actions

Article
04/08/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 :

Sélectionnez 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 couramment utilisés avec cette action :

Paramètre	Explication
app-name	(Obligatoire) Nom de votre application de fonction.
slot-name	(Facultatif) Nom de l’emplacement de déploiement spécifique sur lequel vous voulez effectuer le déploiement. L’emplacement doit déjà exister dans votre application de fonction. Lorsqu’il n’est pas spécifié, le code est déployé sur l’emplacement actif.
publish-profile	(Facultatif) Nom du secret GitHub qui contient votre profil de publication.

Les paramètres suivants sont également pris en charge, mais sont utilisés uniquement dans des cas spécifiques :

Paramètre	Explication
package	(Facultatif) Définit un sous-chemin dans votre référentiel à partir duquel publier. Par défaut, cette valeur est définie sur `.`, ce qui signifie que tous les fichiers et dossiers du référentiel GitHub sont déployés.
respect-pom-xml	(Facultatif) 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	(Facultatif) Indique si GitHub Actions honore votre fichier .funcignore pour exclure les fichiers et les 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`.
scm-do-build-during-deployment	(Facultatif) Indique si le site de déploiement App Service (Kudu) effectue des opérations de prédéploiement. Le site de déploiement de votre application de fonction se trouve à l’adresse `https://<APP_NAME>.scm.azurewebsites.net/`. Remplacez ce paramètre par `true` lorsque vous devez contrôler les déploiements dans Kudu, au lieu de résoudre les dépendances dans le flux de travail GitHub Actions. La valeur par défaut est `false`. Pour plus d’informations, consultez le paramètre SCM_DO_BUILD_DURING_DEPLOYMENT.
enable-oryx-build	(Facultatif) Indique si le site de déploiement Kudu résout vos dépendances de projet à l’aide d’Oryx. Définissez sur `true` lorsque vous souhaitez utiliser Oryx pour résoudre les dépendances de votre projet à l’aide d’une build distante au lieu du flux de travail GitHub Actions. Lorsque `true`, vous devez également définir `scm-do-build-during-deployment` sur `true`. La valeur par défaut est `false`.

Considérations

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é sur votre application de fonction à l’aide du déploiement Zip pour Azure Functions.
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