Deploy naar Azure Functions door gebruik te maken van GitHub Actions

Je kunt een GitHub Actions-workflow gebruiken om automatisch je functiecode te bouwen en uit te rollen naar Azure door gebruik te maken van de Azure/functions-action.

Om te deployen met GitHub Actions, voltooi je deze drie belangrijke stappen:

Maak een door gebruikers toegewezen beheerde identiteit aan in Azure met een gefedereerd inlogeerbewijs dat je GitHub-repository vertrouwt, en wijs deze toe de rol van Website Contributor in je functie-app.
Voeg de client-ID, tenant-ID en abonnements-ID van de identiteit toe als repository-geheimen in GitHub.
Voeg een workflow YAML-bestand toe aan je repository dat OpenID Connect (OIDC) gebruikt azure/login om te authenticeren, en vervolgens oproepen Azure/functions-action om te deployen.

Wanneer je het Azure-portaal gebruikt om GitHub Actions in te schakelen, voert Functions deze taken automatisch uit, zowel in je Azure-abonnement als in je GitHub-repository.

Creëer een workflowconfiguratie voor Azure Functions

Je onderhoudt een YAML-bestand (.yml) dat de workflowconfiguratie in het /.github/workflows/ pad in je repository definieert. Deze definitie bevat de acties en parameters waaruit de werkstroom bestaat, die specifiek is voor de ontwikkeltaal van uw functies.

Kies een methode om je workflowbestand te maken met de selector bovenaan het artikel:

Method	Geschikt voor	OIDC-ondersteuning
Workflowsjabloon	Volledige controle: kopieer een OIDC-klaar sjabloon en pas het aan	Configuratie vereist
Azure-portal	Makkelijkste setup: het portaal kan de identiteit, inloggegevens en workflowbestand voor je aanmaken	Voor jou geconfigureerd
GitHub-marktplaats	GitHub-eerst: begin met de ingebouwde marktplaatstemplates van GitHub	Vereist configuratie en sjabloonaanpassing

Overzicht van verificatie

GitHub Actions moet zich authenticeren bij Azure om je code te kunnen deployen. Dit artikel gebruikt OpenID Connect (OIDC), de aanbevolen authenticatiemethode. OIDC gebruikt gefedereerde inloggegevens om een vertrouwensrelatie te creëren tussen je GitHub-repository en een door de gebruiker toegewezen beheerde identiteit in Microsoft Entra. Er worden geen geheimen opgeslagen in GitHub.

Voorbeeld van OIDC-authenticatie

Het volgende inline voorbeeld toont het kernpatroon van OIDC-authenticatie en -deployment dat in alle workflowtemplates wordt gebruikt:

permissions:
  id-token: write
  contents: read

steps:
  - name: 'Login via OIDC'
    uses: azure/login@v3
    with:
      client-id: ${{ secrets.AZURE_CLIENT_ID }}
      tenant-id: ${{ secrets.AZURE_TENANT_ID }}
      subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

  - name: 'Deploy to Azure Functions'
    uses: Azure/functions-action@v1
    with:
      app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
      package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}

GitHub Actions OIDC-authenticatie overwegingen

OIDC gebruikt workload identity federation en ondersteunt alleen door gebruikers toegewezen beheerde identiteiten.
Wanneer je een op GitHub Actions gebaseerde deployment inschakelt in het Azure-portaal, wordt standaard OIDC-authenticatie gebruikt.
Met OIDC worden de client-ID, tenant-ID en abonnements-ID van de beheerde identiteit opgeslagen als GitHub-repositorygeheimen.
Gebruik Azure rolgebaseerde toegangscontrole (Azure RBAC) om de toegang alleen te beperken tot de Azure-bronnen die nodig zijn voor uw implementatie.

Vereisten

Een Azure-account met een actief abonnement. Gratis een account maken
Een GitHub-account. Als u nog geen account hebt, kunt u zich aanmelden voor gratis.
Project-broncode in een GitHub-repository.
Een basisbegrip van GitHub Actions-workflows. Als je nieuw bent met GitHub Actions, zie dan Understanding GitHub Actions.
Een werkende functie-app die op Azure wordt gehost (alleen code-based of container-based).
(Alleen container-implementaties) Een bestaand containerregister, zoals Azure Container Registry.

Azure CLI, tijdens lokale ontwikkeling. U kunt ook de Azure CLI in Azure Cloud Shell gebruiken.

Maak een beheerde identiteit aan voor GitHub Actions-implementatie

OpenID Connect (OIDC) is de aanbevolen authenticatiemethode voor GitHub Actions-implementaties naar Azure Functions. Met OIDC configureer je een door de gebruiker toegewezen beheerde identiteit in Azure en creëer je een vertrouwensrelatie met je GitHub-repository. De workflow kan dan authenticeren met Azure zonder inloggegevens als geheimen op te slaan.

Gebruik de opdracht az identity create om een door de gebruiker toegewezen beheerde identiteit te maken:
```
az identity create --name myGitHubDeployIdentity --resource-group <RESOURCE_GROUP> \
--query "{clientId: clientId, tenantId: tenantId}" -o table
```
Vervang <RESOURCE_GROUP> door de naam van uw resourcegroep.
Let op de outputwaarden op de clientId en tenantId . Haal ook je abonnements-ID:
```
az account show --query "{subId: id}" -o table
```
Je hebt deze drie waarden later nodig wanneer je referenties toevoegt aan GitHub.

Gebruik het az role assignment create-commando om de Website Contributor rol toe te wijzen aan de beheerde identiteit, gescoped naar je functie-app:

IDENTITY_PRINCIPAL=$(az identity show --name myGitHubDeployIdentity --resource-group <RESOURCE_GROUP> --query 'principalId' -o tsv)
FUNCTION_APP_ID=$(az functionapp show --name <APP_NAME> --resource-group <RESOURCE_GROUP> --query 'id' -o tsv)
az role assignment create --assignee $IDENTITY_PRINCIPAL --role "Website Contributor" --scope $FUNCTION_APP_ID

Vervang <APP_NAME> en <RESOURCE_GROUP> door respectievelijk de namen van je app en resourcegroep.

Gebruik het az identity federated-credential create commando om een gefedereerd credential te creëren dat tokens uit je GitHub-repository vertrouwt:

az identity federated-credential create \
    --identity-name myGitHubDeployIdentity \
    --resource-group <RESOURCE_GROUP> \
    --name github-deploy-credential \
    --issuer https://token.actions.githubusercontent.com \
    --subject repo:<GITHUB_ORG>/<REPO_NAME>:ref:refs/heads/<BRANCH_NAME> \
    --audiences api://AzureADTokenExchange

Vervang <RESOURCE_GROUP>, <GITHUB_ORG>, <REPO_NAME> en <BRANCH_NAME> met uw eigen waarden. Het onderwerp moet overeenkomen met de branch die je workflow activeert.

(Optioneel) Als je een container vanuit Azure Container Registry uitrolt, wijs je de acrpull rol dan ook toe aan de beheerde identiteit:

IDENTITY_PRINCIPAL=$(az identity show --name myGitHubDeployIdentity --resource-group <RESOURCE_GROUP> --query 'principalId' -o tsv)
az role assignment create --assignee $IDENTITY_PRINCIPAL --role acrpull \
    --scope /subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.ContainerRegistry/registries/<REGISTRY_NAME>

Vervang <SUBSCRIPTION_ID>, <RESOURCE_GROUP> en <REGISTRY_NAME> door uw waarden.

Voeg inloggegevens toe aan GitHub

Gebruik de waarden die je hebt gekopieerd toen je de beheerde identiteit hebt aangemaakt.

Ga in GitHub naar uw opslagplaats.
Ga naar Instellingen>, Geheimen en variabelen,>Acties.
Selecteer op het tabblad GeheimenNieuw repositorygeheim.
Maak elk van de volgende geheimen aan:

Name Value

AZURE_CLIENT_ID De clientId van de beheerde identiteit

AZURE_TENANT_ID De tenantId van de beheerde identiteit

AZURE_SUBSCRIPTION_ID De abonnements-ID die je functie-app bevat

Name	Value
`AZURE_CLIENT_ID`	De `clientId` van de beheerde identiteit
`AZURE_TENANT_ID`	De `tenantId` van de beheerde identiteit
`AZURE_SUBSCRIPTION_ID`	De abonnements-ID die je functie-app bevat

Voor container-implementaties vanuit een privé-register heb je ook register-specifieke geheimen nodig. Voor meer informatie, zie Docker Login Actie.

De werkstroom maken op basis van een sjabloon

De beste manier om handmatig een werkstroomconfiguratie te maken, is door te beginnen met de officieel ondersteunde sjabloon.

Kies Windows of Linux om ervoor te zorgen dat u de sjabloon voor het juiste besturingssysteem krijgt.
- Windows
- Linux
Implementaties voor Windows maken gebruik van runs-on: windows-latest. Containerized deployments vereisen Linux.

Implementaties voor Linux-gebruik runs-on: ubuntu-latest. Gebruik Linux voor containerisatie-implementaties.

Gebruik de taalspecifieke OIDC-workflowtemplate uit de Azure Functions actions repository. Kopieer de volledige inhoud van het bestand naar een nieuw bestand dat in je repository is genoemd .github/workflows/deploy-function-app.yml :

name: Build and deploy .NET project to Azure Function App using OIDC

on:
  push:
    branches: [ main ]
  workflow_dispatch:

env:
  AZURE_FUNCTIONAPP_NAME: 'APP_NAME'         # Set this to your function app name on Azure 
  AZURE_FUNCTIONAPP_PROJECT_PATH: '.'        # Set this to the path to your function app project, defaults to the repository root. The deploy action will package the contents of this path.
  DOTNET_VERSION: '10.0.x'                   # Set this to the .NET version of your project
  BUILD_ARTIFACT_NAME: 'released-package'    # Set this according to your team's naming convention
  
jobs:
  build:
    runs-on: windows-latest # Assumes your target function app is Windows-based
    permissions:
      id-token: write  # Required for OIDC
      contents: read   # Required for actions/checkout
    defaults:
      run:
        shell: bash
        working-directory: ${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}
    steps:
      - name: 'Checkout repository'
        uses: actions/checkout@v6

      - name: 'Set up .NET version: ${{ env.DOTNET_VERSION }}'
        uses: actions/setup-dotnet@v5
        with:
          dotnet-version: ${{ env.DOTNET_VERSION }}

      # Perform additional steps such as running tests, if needed

      - name: 'Build and prepare .NET project for deployment'
        run: dotnet publish --configuration Release --output ./output

      - name: Upload artifact for the deployment job
        uses: actions/upload-artifact@v7
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: ${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/output
          include-hidden-files: true  # Required for .NET projects
  
  deploy:
    runs-on: windows-latest # Assumes your target function app is Windows-based
    needs: build
    permissions:
      id-token: write  # Required for OIDC
    steps:
      - name: 'Download artifact from build job'
        uses: actions/download-artifact@v8
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: '${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/downloaded-artifact'
     
      - name: 'Log in to Azure with AZ CLI'
        uses: azure/login@v3
        with:
          client-id: ${{ vars.AZURE_CLIENT_ID }}
          tenant-id: ${{ vars.AZURE_TENANT_ID }}
          subscription-id: ${{ vars.AZURE_SUBSCRIPTION_ID }}
        
      - name: 'Run the Azure Functions action'
        uses: Azure/functions-action@v1
        id: deploy-to-function-app
        with:
          app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
          package: '${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/downloaded-artifact'

name: Build and deploy .NET project to Azure Function App using OIDC

on:
  push:
    branches: [ main ]
  workflow_dispatch:

env:
  AZURE_FUNCTIONAPP_NAME: 'APP_NAME'         # Set this to your function app name on Azure 
  AZURE_FUNCTIONAPP_PROJECT_PATH: '.'        # Set this to the path to your function app project, defaults to the repository root. The deploy action will package the contents of this path.
  DOTNET_VERSION: '10.0.x'                   # Set this to the .NET version of your project
  BUILD_ARTIFACT_NAME: 'released-package'    # Set this according to your team's naming convention
  
jobs:
  build:
    runs-on: ubuntu-latest # Assumes your target function app is Linux-based
    permissions:
      id-token: write  # Required for OIDC
      contents: read   # Required for actions/checkout
    defaults:
      run:
        shell: bash
        working-directory: ${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}
    steps:
      - name: 'Checkout repository'
        uses: actions/checkout@v6

      - name: 'Set up .NET version: ${{ env.DOTNET_VERSION }}'
        uses: actions/setup-dotnet@v5
        with:
          dotnet-version: ${{ env.DOTNET_VERSION }}

      # Perform additional steps such as running tests, if needed

      - name: 'Build and prepare .NET project for deployment'
        run: dotnet publish --configuration Release --output ./output

      - name: Upload artifact for the deployment job
        uses: actions/upload-artifact@v7
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: ${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/output
          include-hidden-files: true  # Required for .NET projects
  
  deploy:
    runs-on: ubuntu-latest # Assumes your target function app is Linux-based
    needs: build
    permissions:
      id-token: write  # Required for OIDC
    steps:
      - name: 'Download artifact from build job'
        uses: actions/download-artifact@v8
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: '${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/downloaded-artifact'
     
      - name: 'Log in to Azure with AZ CLI'
        uses: azure/login@v3
        with:
          client-id: ${{ vars.AZURE_CLIENT_ID }}
          tenant-id: ${{ vars.AZURE_TENANT_ID }}
          subscription-id: ${{ vars.AZURE_SUBSCRIPTION_ID }}
        
      - name: 'Run the Azure Functions action'
        uses: Azure/functions-action@v1
        id: deploy-to-function-app
        with:
          app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
          package: '${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/downloaded-artifact'

name: Build and deploy Java project to Azure Function App using OIDC

on:
  push:
    branches: [ main ]
  workflow_dispatch:

env:
  AZURE_FUNCTIONAPP_NAME: 'APP_NAME'          # set this to your function app name on Azure. Ensure that `functionAppName` in your pom.xml file matches. 
  POM_XML_DIRECTORY: '.'                      # set this to the directory which contains the pom.xml file. The deploy action will package the contents of this path.
  JAVA_VERSION: '21'                          # set this to the Java version of your project
  BUILD_ARTIFACT_NAME: 'released-package'     # Set this according to your team's naming convention

jobs:
  build:
    runs-on: windows-latest # Assumes your target function app is Windows-based
    permissions:
        id-token: write  # Required to fetch an OIDC token to authenticate with the job
        contents: read # Required for actions/checkout
    defaults:
      run:
        shell: bash
        working-directory: ${{ env.POM_XML_DIRECTORY }}
    steps:
      - name: 'Checkout repository'
        uses: actions/checkout@v6

      - name: 'Set up Java version: ${{ env.JAVA_VERSION }}'
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: 'microsoft'

      - name: 'Build project with Maven'
        run: mvn clean package -DfunctionAppName=${{ env.AZURE_FUNCTIONAPP_NAME }}

      # Perform additional steps such as running tests, if needed
      
      - name: 'Upload artifact for the deployment job'
        uses: actions/upload-artifact@v7
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: ${{ env.POM_XML_DIRECTORY }}/target/azure-functions/${{ env.AZURE_FUNCTIONAPP_NAME }}

  deploy:
    runs-on: windows-latest # Assumes your target function app is Windows-based
    needs: build
    permissions:
      id-token: write  # Required to fetch an OIDC token to authenticate with the job
    steps:
      - name: 'Download artifact from build job'
        uses: actions/download-artifact@v8
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: '${{ env.POM_XML_DIRECTORY }}/downloaded-artifact'
      
      - name: 'Log in to Azure with AZ CLI'
        uses: azure/login@v3
        with:
          client-id: ${{ vars.AZURE_CLIENT_ID }}
          tenant-id: ${{ vars.AZURE_TENANT_ID }}
          subscription-id: ${{ vars.AZURE_SUBSCRIPTION_ID }}

      - name: 'Run the Azure Functions action'
        uses: Azure/functions-action@v1
        id: deploy-to-function-app
        with:
          app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
          package: '${{ env.POM_XML_DIRECTORY }}/downloaded-artifact'
          respect-pom-xml: false # Set to `true` if the build artifact path is ${{ env.POM_XML_DIRECTORY }}

name: Build and deploy Java project to Azure Function App using OIDC

on:
  push:
    branches: [ main ]
  workflow_dispatch:

env:
  AZURE_FUNCTIONAPP_NAME: 'APP_NAME'          # set this to your function app name on Azure. Ensure that `functionAppName` in your pom.xml file matches. 
  POM_XML_DIRECTORY: '.'                      # set this to the directory which contains the pom.xml file. The deploy action will package the contents of this path.
  JAVA_VERSION: '21'                          # set this to the Java version of your project
  BUILD_ARTIFACT_NAME: 'released-package'     # Set this according to your team's naming convention

jobs:
  build:
    runs-on: ubuntu-latest # Assumes your target function app is Linux-based
    permissions:
        id-token: write  # Required to fetch an OIDC token to authenticate with the job
        contents: read # Required for actions/checkout
    defaults:
      run:
        shell: bash
        working-directory: ${{ env.POM_XML_DIRECTORY }}
    steps:
      - name: 'Checkout repository'
        uses: actions/checkout@v6

      - name: 'Set up Java version: ${{ env.JAVA_VERSION }}'
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: 'microsoft'

      - name: 'Build project with Maven'
        run: mvn clean package -DfunctionAppName=${{ env.AZURE_FUNCTIONAPP_NAME }}

      # Perform additional steps such as running tests, if needed
      
      - name: 'Upload artifact for the deployment job'
        uses: actions/upload-artifact@v7
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: ${{ env.POM_XML_DIRECTORY }}/target/azure-functions/${{ env.AZURE_FUNCTIONAPP_NAME }}

  deploy:
    runs-on: ubuntu-latest # Assumes your target function app is Linux-based
    needs: build
    permissions:
      id-token: write  # Required to fetch an OIDC token to authenticate with the job
    steps:
      - name: 'Download artifact from build job'
        uses: actions/download-artifact@v8
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: '${{ env.POM_XML_DIRECTORY }}/downloaded-artifact'
      
      - name: 'Log in to Azure with AZ CLI'
        uses: azure/login@v3
        with:
          client-id: ${{ vars.AZURE_CLIENT_ID }}
          tenant-id: ${{ vars.AZURE_TENANT_ID }}
          subscription-id: ${{ vars.AZURE_SUBSCRIPTION_ID }}

      - name: 'Run the Azure Functions action'
        uses: Azure/functions-action@v1
        id: deploy-to-function-app
        with:
          app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
          package: '${{ env.POM_XML_DIRECTORY }}/downloaded-artifact'
          respect-pom-xml: false # Set to `true` if the build artifact path is ${{ env.POM_XML_DIRECTORY }}

name: Build and deploy Node.js project to Azure Function App using OIDC

on:
  push:
    branches: [ main ]
  workflow_dispatch:

env:
  AZURE_FUNCTIONAPP_NAME: 'APP_NAME'        # Set this to your function app name on Azure 
  AZURE_FUNCTIONAPP_PROJECT_PATH: '.'       # Set this to the path to your function app project, defaults to the repository root. The deploy action will package the contents of this path.
  NODE_VERSION: '22'                        # Set this to the Node version of your project
  BUILD_ARTIFACT_NAME: 'released-package'   # Set this according to your team's naming convention
  
jobs:
  build:
    runs-on: windows-latest # Assumes your target function app is Windows-based
    permissions:
      id-token: write  # Required for OIDC
      contents: read   # Required for actions/checkout
    defaults:
      run:
        shell: bash
        working-directory: ${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}
    steps:
      - name: 'Checkout repository'
        uses: actions/checkout@v6

      - name: 'Set up Node version: ${{ env.NODE_VERSION }}'
        uses: actions/setup-node@v6
        with:
          node-version: ${{ env.NODE_VERSION }}

      - name: 'Install project dependencies'
        run: npm install # Use `npm ci` if you have a package-lock.json file and want to ensure a clean install
      
      - name: 'Build project'
        run: npm run build --if-present
      
      - name: 'Run tests'
        run: npm run test --if-present
      
      - name: 'Prune development dependencies'
        run: npm prune --production
      
      - name: 'Upload artifact for the deployment job'
        uses: actions/upload-artifact@v7
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: ${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}
  
  deploy:
    runs-on: windows-latest # Assumes your target function app is Windows-based
    needs: build
    permissions:
      id-token: write  # Required for OIDC
    steps:
      - name: 'Download artifact from build job'
        uses: actions/download-artifact@v8
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: '${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/downloaded-artifact'
     
      - name: 'Log in to Azure with AZ CLI'
        uses: azure/login@v3
        with:
          client-id: ${{ vars.AZURE_CLIENT_ID }}
          tenant-id: ${{ vars.AZURE_TENANT_ID }}
          subscription-id: ${{ vars.AZURE_SUBSCRIPTION_ID }}
        
      - name: 'Run the Azure Functions action'
        uses: Azure/functions-action@v1
        id: deploy-to-function-app
        with:
          app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
          package: '${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/downloaded-artifact'

name: Build and deploy Node.js project to Azure Function App using OIDC

on:
  push:
    branches: [ main ]
  workflow_dispatch:

env:
  AZURE_FUNCTIONAPP_NAME: 'APP_NAME'        # Set this to your function app name on Azure 
  AZURE_FUNCTIONAPP_PROJECT_PATH: '.'       # Set this to the path to your function app project, defaults to the repository root. The deploy action will package the contents of this path.
  NODE_VERSION: '22'                        # Set this to the Node version of your project
  BUILD_ARTIFACT_NAME: 'released-package'   # Set this according to your team's naming convention
  
jobs:
  build:
    runs-on: ubuntu-latest # Assumes your target function app is Linux-based
    permissions:
      id-token: write  # Required for OIDC
      contents: read   # Required for actions/checkout
    defaults:
      run:
        shell: bash
        working-directory: ${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}
    steps:
      - name: 'Checkout repository'
        uses: actions/checkout@v6

      - name: 'Set up Node version: ${{ env.NODE_VERSION }}'
        uses: actions/setup-node@v6
        with:
          node-version: ${{ env.NODE_VERSION }}

      - name: 'Install project dependencies'
        run: npm install # Use `npm ci` if you have a package-lock.json file and want to ensure a clean install
      
      - name: 'Build project'
        run: npm run build --if-present
      
      - name: 'Run tests'
        run: npm run test --if-present
      
      - name: 'Prune development dependencies'
        run: npm prune --production
      
      - name: 'Upload artifact for the deployment job'
        uses: actions/upload-artifact@v7
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: ${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}
  
  deploy:
    runs-on: ubuntu-latest # Assumes your target function app is Linux-based
    needs: build
    permissions:
      id-token: write  # Required for OIDC
    steps:
      - name: 'Download artifact from build job'
        uses: actions/download-artifact@v8
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: '${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/downloaded-artifact'
     
      - name: 'Log in to Azure with AZ CLI'
        uses: azure/login@v3
        with:
          client-id: ${{ vars.AZURE_CLIENT_ID }}
          tenant-id: ${{ vars.AZURE_TENANT_ID }}
          subscription-id: ${{ vars.AZURE_SUBSCRIPTION_ID }}
        
      - name: 'Run the Azure Functions action'
        uses: Azure/functions-action@v1
        id: deploy-to-function-app
        with:
          app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
          package: '${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/downloaded-artifact'

name: Build and deploy Python project to Azure Function App using OIDC

on:
  push:
    branches: [ main ]
  workflow_dispatch:

env:
  AZURE_FUNCTIONAPP_NAME: 'APP_NAME'        # Set this to your function app name on Azure 
  AZURE_FUNCTIONAPP_PROJECT_PATH: '.'       # Set this to the path to your function app project, defaults to the repository root. The deploy action will package the contents of this path.
  PYTHON_VERSION: '3.13.x'                  # Set this to the Python version of your project
  BUILD_ARTIFACT_NAME: 'released-package'   # Set this according to your team's naming convention
  
jobs:
  build:
    runs-on: ubuntu-latest # Python function apps are Linux-based
    permissions:
      id-token: write  # Required for OIDC
      contents: read   # Required for actions/checkout
    defaults:
      run:
        shell: bash
        working-directory: ${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}
    steps:
      - name: 'Checkout repository'
        uses: actions/checkout@v6

      - name: 'Set up Python version: ${{ env.PYTHON_VERSION }}'
        uses: actions/setup-python@v6
        with:
          python-version: ${{ env.PYTHON_VERSION }}

      - name: 'Install project dependencies'
        run: pip install -r requirements.txt --target ".python_packages/lib/site-packages"  # Ensure requirements.txt contains all dependencies
      
      # Perform additional steps such as running tests, if needed

      - name: 'Upload artifact for the deployment job'
        uses: actions/upload-artifact@v7
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: ${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}
  
  deploy:
    runs-on: ubuntu-latest # Python function apps are Linux-based
    needs: build
    permissions:
      id-token: write  # Required for OIDC
    steps:
      - name: 'Download artifact from build job'
        uses: actions/download-artifact@v8
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: '${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/downloaded-artifact'
     
      - name: 'Log in to Azure with AZ CLI'
        uses: azure/login@v3
        with:
          client-id: ${{ vars.AZURE_CLIENT_ID }}
          tenant-id: ${{ vars.AZURE_TENANT_ID }}
          subscription-id: ${{ vars.AZURE_SUBSCRIPTION_ID }}
        
      - name: 'Run the Azure Functions action'
        uses: Azure/functions-action@v1
        id: deploy-to-function-app
        with:
          app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
          package: '${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/downloaded-artifact'

name: Deploy PowerShell project to Azure Function App using OIDC

on:
  push:
    branches: [ main ]
  workflow_dispatch:

env:
  AZURE_FUNCTIONAPP_NAME: 'APP_NAME'       # Set this to your function app name on Azure 
  AZURE_FUNCTIONAPP_PROJECT_PATH: '.'        # Set this to the path to your function app project, defaults to the repository root. The deploy action will package the contents of this path.
  
jobs:
  # PowerShell projects do not require a build step
  deploy:
    runs-on: windows-latest # For PowerShell projects, the OS of the runner does not affect deployment. You may use either ubuntu-latest or windows-latest.
    permissions:
      id-token: write  # Required for OIDC
      contents: read   # Required for actions/checkout
    steps:
      - name: 'Checkout repository'
        uses: actions/checkout@v6

      # Perform additional steps such as running tests, if needed
     
      - name: 'Log in to Azure with AZ CLI'
        uses: azure/login@v3
        with:
          client-id: ${{ vars.AZURE_CLIENT_ID }}
          tenant-id: ${{ vars.AZURE_TENANT_ID }}
          subscription-id: ${{ vars.AZURE_SUBSCRIPTION_ID }}
        
      - name: 'Run the Azure Functions action'
        uses: Azure/functions-action@v1
        id: deploy-to-function-app
        with:
          app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
          package: ${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}

# Action Requires
# 1. Setup the AZURE_CREDENTIALS secrets in your GitHub Repository
name: Linux_Container_Workflow

on:
  push:
    branches:
    - master

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

    - name: 'Login via Azure CLI'
      uses: azure/login@v1
      with:
        creds: ${{ secrets.AZURE_CREDENTIALS }}

    - name: 'Docker Login'
      uses: azure/docker-login@v1
      with:
        login-server: contoso.azurecr.io
        username: ${{ secrets.REGISTRY_USERNAME }}
        password: ${{ secrets.REGISTRY_PASSWORD }}

    - name: 'Compose Customized Docker Image'
      shell: bash
      run: |
        # If your function app project is not located in your repository's root
        # Please change the path to your directory for docker build
        docker build . -t REGISTRY/NAMESPACE/IMAGE:TAG
        docker push REGISTRY/NAMESPACE/IMAGE:TAG

    - name: 'Run Azure Functions Container Action'
      uses: Azure/functions-container-action@v1
      id: fa
      with:
        app-name: PLEASE_REPLACE_THIS_WITH_YOUR_FUNCTION_APP_NAME
        image: REGISTRY/NAMESPACE/IMAGE:TAG

    #- name: 'use the published functionapp url in upcoming steps'
    #  run: |
    #    echo "${{ steps.fa.outputs.app-url }}"

    - name: Azure logout
      run: |
        az logout

Belangrijk

Voor nieuwe container-gebaseerde functie-app-implementaties gebruik het native Azure Container Apps hostingmodel. Zie Deploy to Azure Container Apps with GitHub Actions. De hier getoonde Azure/functions-container-action map deployt containerimages naar bestaande functionele app-resources in Azure.

Voordat je dit YAML-bestand gebruikt, voltooi je de volgende stappen:

Werk de waarden van REGISTRY, NAMESPACE, , IMAGEen TAG bij op basis van je containerregister.
Werk de inloggegevens van de containerrepository bij in de docker/login-action actie.

Werk in het sjabloon de env: variabelen voor je project bij. Elke template vereist AZURE_FUNCTIONAPP_NAME. De andere variabelen hangen af van je taal:

Veranderlijk	Vereist	Beschrijving
`AZURE_FUNCTIONAPP_NAME`	Ja	Your function app name in Azure
`DOTNET_VERSION`	Ja	De .NET-versie van je project (bijvoorbeeld `10.0.x`)
`AZURE_FUNCTIONAPP_PROJECT_PATH`	No	Pad naar je projectmap. Standaard: `.` (repository root)

Veranderlijk	Vereist	Beschrijving
`AZURE_FUNCTIONAPP_NAME`	Ja	Je functieapp-naam in Azure. Moet in pom.xmlmatchen `functionAppName` .
`JAVA_VERSION`	Ja	De Java-versie van je project (bijvoorbeeld, `21`)
`POM_XML_DIRECTORY`	No	Path naar de map die pom.xmlbevat. Standaard: `.` (repository root)

Veranderlijk	Vereist	Beschrijving
`AZURE_FUNCTIONAPP_NAME`	Ja	Your function app name in Azure
`NODE_VERSION`	Ja	De Node.js versie van je project (bijvoorbeeld, `22`)
`AZURE_FUNCTIONAPP_PROJECT_PATH`	No	Pad naar je projectmap. Standaard: `.` (repository root)

Veranderlijk	Vereist	Beschrijving
`AZURE_FUNCTIONAPP_NAME`	Ja	Your function app name in Azure
`PYTHON_VERSION`	Ja	De Python-versie van je project (bijvoorbeeld, `3.13.x`)
`AZURE_FUNCTIONAPP_PROJECT_PATH`	No	Pad naar je projectmap. Standaard: `.` (repository root)

Veranderlijk	Vereist	Beschrijving
`AZURE_FUNCTIONAPP_NAME`	Ja	Your function app name in Azure
`REGISTRY`	Ja	Je containerregister-inlogserver (bijvoorbeeld, `contoso.azurecr.io`)
`NAMESPACE`	Ja	De naamruimte/repository in je register
`IMAGE`	Ja	De naam van de containerafbeelding
`TAG`	Ja	De image tag (bijvoorbeeld, `${{ github.sha }}`)

De OIDC-sjablonen bevatten al de azure/login stap met OIDC-authenticatie. Controleer of de secrets.AZURE_CLIENT_ID, secrets.AZURE_TENANT_ID, en secrets.AZURE_SUBSCRIPTION_ID referenties overeenkomen met de repository-geheimen die je hebt aangemaakt.
Voeg dit nieuwe YAML-bestand toe aan het /.github/workflows/ pad in uw opslagplaats.

De werkstroomconfiguratie maken in de portal

Wanneer je het portaal gebruikt om GitHub Actions in te schakelen, regelt Functions automatisch alle instellingen. Je hoeft geen beheerde identiteit handmatig aan te maken, inloggegevens te configureren of een workflowbestand te schrijven. Functions voert deze taken voor u uit:

In je Azure-abonnement:

Maakt een door gebruikers toegewezen beheerde identiteit aan en wijst deze de rol van Website-bijdrager toe in je functie-app.
Voegt een gefedereerd inloggegevens toe aan de beheerde identiteit voor GitHub OIDC-authenticatie.

In je GitHub-repository:

Voegt de client-ID, abonnements-ID en tenant-ID-waarden toe als GitHub Actions-geheimen.
Maakt een workflowbestand aan op basis van je applicatiestack en commit dit naar .github/workflows.

Tijdens het aanmaken van de app-functie

U kunt snel aan de slag met GitHub Actions via het tabblad Implementatie wanneer u een functie maakt in Azure portal. Een GitHub Actions-werkstroom toevoegen wanneer u een nieuwe functie-app maakt:

Selecteer in de Azure-portal, Implementatie in de workflow Create Function App.
Schakel Continuous Deployment in als u wilt dat elke code-update een codepush naar Azure portal activeert.
Selecteer onder GitHub-instellingen'Autoriseren om je GitHub-account te verbinden. Log in met het GitHub-account dat schrijfrechten heeft voor je repository.
Voer uw GitHub organisatie, opslagplaats en vertakking in.
Selecteer optioneel Voorbeeldbestand om te zien hoe het workflowbestand eruitziet voordat het wordt gegenereerd en toegevoegd aan je repository.
Voltooi de configuratie van uw functie-app. Uw GitHub-opslagplaats bevat nu een nieuw werkstroombestand in /.github/workflows/.

Voor een bestaande functie-app

Een GitHub Actions-werkstroom toevoegen aan een bestaande functie-app:

Ga naar je functie-app in het Azure-portaal en selecteer Deployment>Deployment Center.
Selecteer Continue Uitrol (CI/CD). Kies voor Bron de optie GitHub. Als je het standaardbericht Building with GitHub Actions niet ziet, selecteer dan Change provider, kies GitHub Actions en selecteer OK.
Als je nog geen toegang tot GitHub hebt goedgekeurd, kies dan Autoriseren. Geef uw GitHub referenties op en selecteer Aanmelden. Om een ander GitHub-account te autoriseren, selecteert u Account wijzigen en meldt u zich aan met een ander account.
Selecteer uw GitHub Organization, Repository en Branch. Om te deployen met GitHub Actions, moet je schrijftoegang hebben tot deze repository.
Selecteer voor de optie WorkflowEen workflow toevoegen. Deze optie maakt een nieuw workflowbestand aan in /.github/workflows/. Om een bestaande workflow te gebruiken, selecteer je Gebruik beschikbare workflow en kies je je workflowbestand.
Kies in de authenticatie-instellingenvoor User-assigned identity om OpenID Connect (OIDC) te gebruiken, wat wordt aanbevolen omdat je geen geheimen in GitHub hoeft op te slaan. Selecteer uw abonnement en de (nieuwe) voorgestelde identiteitsnaam. Er wordt een nieuwe door gebruikers toegewezen beheerde identiteit aangemaakt en krijgt toegang tot de rol Website Contributor . Als je een bestaande identiteit gebruikt, moet je deze eerst toegang geven tot de rol Website-bijdrager .

Belangrijk

Wanneer je Basisauthenticatie selecteert, wordt je publicatieprofiel, dat gedeelde geheimen bevat, opgeslagen in GitHub Secrets. Je moet ook SCM-basisauthenticatie inschakelen, wat je app minder veilig maakt.
Selecteer Voorbeeld-bestand om het werkstroombestand te zien dat wordt toegevoegd aan uw GitHub-opslagplaats in .github/workflows/.
Selecteer Opslaan om het werkstroombestand toe te voegen aan uw opslagplaats. Selecteer het tabblad Logs om de status van huidige en eerdere uitrolingen te bekijken.

Het configuratiebestand voor de werkstroom maken

U kunt het configuratiebestand voor de GitHub Actions werkstroom maken vanuit de Azure Functions sjablonen rechtstreeks vanuit uw GitHub opslagplaats.

Ga in GitHub naar uw opslagplaats.
Selecteer Acties en nieuwe werkstroom.
Zoeken naar functies.
Zoek in de weergegeven werkstromen van de functionaliteit-app, die zijn gemaakt door Microsoft Azure, naar degene die overeenkomt met uw codetaal en selecteer Configureren.
Werk in het zojuist gemaakte YAML-bestand de parameter env.AZURE_FUNCTIONAPP_NAME bij met de naam van uw functie-app-resource in Azure. Je moet misschien ook de parameter aanpassen die de taalversie van je app bepaalt, bijvoorbeeld DOTNET_VERSION voor C# of PYTHON_VERSION Python-apps.
De standaardsjablonen kunnen gebruik maken van publicatieprofielauthenticatie in plaats van de aanbevolen OIDC. Om over te stappen naar OIDC en af te stemmen op portaalgedrag, breng je de volgende wijzigingen aan:
- Verwijder de publish-profileparameters , scm-do-build-during-deployment, en enable-oryx-build uit Azure/functions-action.
- Verwijder de environment instelling uit de taak (indien aanwezig), omdat het subject voor de gefedereerde credential overeenkomt met de branch trigger.
- Voeg een azure/login stap toe vóór de Azure/functions-action stap:
```
- name: 'Login via OIDC'
  uses: azure/login@v3
  with:
    client-id: ${{ secrets.AZURE_CLIENT_ID }}
    tenant-id: ${{ secrets.AZURE_TENANT_ID }}
    subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

- name: 'Run Azure Functions Action'
  uses: Azure/functions-action@v1
  with:
    app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
    package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
```
- Voeg de volgende rechten toe aan de taak:
```
permissions:
  id-token: write
  contents: read
```
Controleer of het nieuwe workflowbestand is opgeslagen met een passende naam en /.github/workflows/ selecteer Commit changes.

Azure Functions-actie

Met de actie Azure Functions (Azure/functions-action) wordt gedefinieerd hoe uw code wordt gepubliceerd naar een bestaande functie-app in Azure of naar een specifieke site in uw app.

Parameters

De volgende tabel beschrijft de invoerparameters die worden ondersteund door Azure/functions-action:

Parameter	Beschrijving
app-naam	(Vereist) De naam van je functie-app in Azure.
package	(Vereist) De weg naar je project om te publiceren. Standaard: `.` (alle bestanden in de repository).
Externe bouw	Ingesteld op `true` om een build-actie vanuit Kudu in te schakelen bij het uitrollen naar een Flex Consumption-app. Oryx-build wordt altijd uitgevoerd; Stel ook niet scm-do-build-whileing-deployment of enable-oryx-build in. Standaard: `false`.
SCM-DO-Build-Whileing-Deployment	Laat de Kudu-site pre-deployment operaties uitvoeren, zoals remote builds. Stel in dat `true` Kudu je project tijdens de deployment bouwt. Standaard: `false`. Zie `SCM_DO_BUILD_DURING_DEPLOYMENT` voor meer informatie.
Enable-Oryx-build	Laat Kudu projectafhankelijkheden oplossen door Oryx te gebruiken. Stel zowel dit als scm-do-build-whileing-deployment in om `true` Oryx te gebruiken in plaats van de workflow. Standaard: `false`. Alleen Linux.
sitenaam	De inzetplek om naartoe te gaan. Standaard: productieslot.
publicatieprofiel	De naam van het GitHub geheim dat uw publicatieprofiel bevat. Niet nodig bij het gebruik van de aanbevolen OIDC-authenticatie.
Sku	Stel in op `flexconsumption` bij authenticatie met public-profile op een Flex Consumption-plan. Niet nodig bij OIDC-authenticatie of andere hostingplannen.
respect-pom-xml	(Java alleen) Ingesteld op `true` om het inzetartefact af te leiden van pom.xml. Wanneer `true`, zet het pakket op `.`. Standaard: `false`.
respect-funcignore	Stel in op `true` om je .funcignore-bestand te honoreren en vermelde paden uit te sluiten. Standaard: `false`.

De volgende tabel toont welke parameters worden ondersteund voor elk hostingplan:

Parameter	Flex Consumption	Elastische premie	Dedicated	Consumptie
app-naam	Vereist	Vereist	Vereist	Vereist
package	Vereist	Vereist	Vereist	Vereist
Externe bouw	Optional	—	—	—
SCM-DO-Build-Whileing-Deployment	—	Optional	Optional	Optional
Enable-Oryx-build	—	Optioneel (Linux)	Optioneel (Linux)	Optioneel (Linux)
sitenaam	Niet ondersteund	Optional	Optional	Optional
publicatieprofiel	Niet aanbevolen	Niet aanbevolen	Niet aanbevolen	Niet aanbevolen
Sku	Alleen publiceren-profiel	—	—	—
respect-pom-xml	Optioneel (Java)	Optioneel (Java)	Optioneel (Java)	Optioneel (Java)
respect-funcignore	Optional	Optional	Optional	Optional

Implementatiemethoden

Wanneer je GitHub Actions gebruikt, hangt de deployment-methode af van je hostingplan:

Hostingabonnement	Implementatiemethode
Flexverbruik	Een implementatie
Elastische premie	Zip-deploy
Toegewezen (App Service)	Zip-deploy
Verbruik	Windows: Zip-implementatie Linux: URL van extern pakket^*

* De mogelijkheid om uw apps uit te voeren op Linux in een verbruiksabonnement is gepland voor buitengebruikstelling. Zie Azure Functions Hosting van verbruiksabonnementen voor meer informatie.

Zie Implementatietechnologieën in Azure Functions voor meer informatie.

Volgende stappen

Feedback

Is deze pagina nuttig?

Last updated on 2026-08-14