Distribuera till Azure Functions genom att använda GitHub Actions

Du kan använda ett GitHub Actions-arbetsflöde för att automatiskt bygga och distribuera din funktionskod till Azure genom att använda .Azure/functions-action

För att distribuera med hjälp av GitHub Actions, genomför dessa tre viktiga steg:

Skapa en användartilldelad hanterad identitet i Azure med en federerad inloggningsbehörighet som litar på ditt GitHub-arkiv, och tilldela den rollen som webbplatsbidragsgivare i din funktionsapp.
Lägg till identitetens klient-ID, tenant-ID och prenumerations-ID som repository-hemligheter i GitHub.
Lägg till en arbetsflödes-YAML-fil i ditt repository som använder azure/login OpenID Connect (OIDC) för autentisering, sedan anrop Azure/functions-action för att distribuera.

När du använder Azure-portalen för att aktivera GitHub Actions utför Functions automatiskt dessa uppgifter, både i din Azure-prenumeration och i ditt GitHub-arkiv.

Skapa en arbetsflödeskonfiguration för Azure Functions

Du underhåller en YAML-fil (.yml) som definierar arbetsflödeskonfigurationen i sökvägen /.github/workflows/ i ditt repository. Den här definitionen innehåller de åtgärder och parametrar som utgör arbetsflödet, vilket är specifikt för utvecklingsspråket för dina funktioner.

Välj en metod för att skapa din arbetsflödesfil med hjälp av väljaren högst upp i artikeln:

Method	Bäst för	OIDC-stöd
Arbetsflödesmall	Full kontroll: kopiera en OIDC-klar mall och anpassa den	Kräver konfiguration
Azure Portal	Enklaste installationen: portalen kan skapa identitet, inloggningsuppgifter och arbetsflödesfiler åt dig	Konfigurerad för dig
GitHub-marknadsplats	GitHub-först: börja med GitHub:s inbyggda marknadsplatsmallar	Kräver konfiguration och malländring

Översikt över autentisering

GitHub Actions måste autentiseras med Azure för att distribuera din kod. Denna artikel använder OpenID Connect (OIDC), som är den rekommenderade autentiseringsmetoden. OIDC använder federerade inloggningsuppgifter för att skapa en förtroenderelation mellan ditt GitHub-arkiv och en användartilldelad hanterad identitet i Microsoft Entra. Inga hemligheter lagras i GitHub.

Exempel på OIDC-autentisering

Följande inline-exempel visar det centrala OIDC-autentiserings- och distributionsmönstret som används i alla arbetsflödesmallar:

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-autentiseringsöverväganden

OIDC använder arbetsbelastningsidentitetsfederation och stöder endast användar-tilldelade hanterade identiteter.
När du aktiverar en GitHub Actions-baserad distribution i Azure-portalen används OIDC-autentisering som standard.
Med OIDC lagras den hanterade identitetens klient-ID, tenant-ID och prenumerations-ID som GitHub-arkivhemligheter.
Använd Azure rollbaserad åtkomstkontroll (Azure RBAC) för att begränsa åtkomsten endast till de Azure-resurser som krävs för din installation.

Förutsättningar

Ett Azure konto med en aktiv prenumeration. Skapa ett konto kostnadsfritt.
Ett GitHub konto. Om du inte har ett sådant kan du registrera dig utan kostnad.
Project-källkod i ett GitHub-arkiv.
En grundläggande förståelse för GitHub Actions-arbetsflöden. Om du är ny på GitHub Actions, se Förstå GitHub Actions.
En fungerande funktionsapp som hostas på Azure (endast kod eller containerbaserad).
(Endast containerutplaceringar) Ett befintligt containerregister, såsom Azure Container Registry.

Azure CLI när du utvecklar lokalt. Du kan också använda Azure CLI i Azure Cloud Shell.

Skapa en hanterad identitet för GitHub Actions-distribution

OpenID Connect (OIDC) är den rekommenderade autentiseringsmetoden för GitHub Actions-distributioner till Azure Functions. Med OIDC konfigurerar du en användartilldelad hanterad identitet i Azure och skapar en förtroenderelation med ditt GitHub-arkiv. Arbetsflödet kan sedan autentisera sig med Azure utan att lagra inloggningsuppgifter som hemligheter.

Använd kommandot az identity create för att skapa en användartilldelad hanterad identitet:

az identity create --name myGitHubDeployIdentity --resource-group <RESOURCE_GROUP> \
--query "{clientId: clientId, tenantId: tenantId}" -o table

Ersätt <RESOURCE_GROUP> med namnet på din resursgrupp.

Från utdatan, notera clientId och tenantId värdena. Skaffa också ditt prenumerations-ID:
```
az account show --query "{subId: id}" -o table
```
Du behöver dessa tre värden senare när du lägger till inloggningsuppgifter på GitHub.

Använd kommandot az role assignment create för att tilldela Website Contributor rollen till den hanterade identiteten, begränsad till din funktionsapp:

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

Ersätt <APP_NAME> och <RESOURCE_GROUP> med namnen på din app respektive resursgrupp.

Använd az identity federated-credential create-kommandot för att skapa en federerad legitimation som litar på tokens från ditt GitHub-arkiv:

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

Ersätt <RESOURCE_GROUP>, <GITHUB_ORG>, <REPO_NAME> och <BRANCH_NAME> med dina värden. Ämnet måste matcha den gren som triggar ditt arbetsflöde.

(Valfritt) Om du distribuerar en container från Azure Container Registry, tilldela acrpull även rollen till den hanterade identiteten:

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>

Ersätt <SUBSCRIPTION_ID>, <RESOURCE_GROUP> och <REGISTRY_NAME> med dina värden.

Lägg till inloggningsuppgifter på GitHub

Använd de värden du kopierade när du skapade den hanterade identiteten.

I GitHub går du till lagringsplatsen.
Gå till Inställningar>, Hemligheter och variabler, Åtgärder>.
På fliken Hemligheter , välj Ny hemlighet i arkivet.

Skapa var och en av följande hemligheter:

Name	Value
`AZURE_CLIENT_ID`	Den `clientId` hanterade identiteten
`AZURE_TENANT_ID`	Den `tenantId` hanterade identiteten
`AZURE_SUBSCRIPTION_ID`	Prenumerations-ID:t som innehåller din funktionsapp

För containerutplaceringar från ett privat register behöver du också registerspecifika hemligheter. För mer information, se Docker Login Action.

Skapa arbetsflödet från en mall

Det bästa sättet att skapa en arbetsflödeskonfiguration manuellt är att börja från mallen som stöds officiellt.

Välj antingen Windows eller Linux för att se till att du får mallen för rätt operativsystem.
- Windows
- Linux
Distribuering till Windows använder runs-on: windows-latest. Containeriserade installationer kräver Linux.

Distributioner till Linux använder runs-on: ubuntu-latest. Använd Linux för containeriserade distributioner.

Använd den språkspecifika OIDC-arbetsflödesmallen från Azure Functions actions repository. Kopiera hela filinnehållet till en ny fil som heter .github/workflows/deploy-function-app.yml i ditt arkiv:

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

Viktigt!

För nya containerbaserade funktionsapp-distributioner, använd den inbyggda Azure Container Apps-hostingmodellen. Se Deploy to Azure Container Apps with GitHub Actions. Den Azure/functions-container-action som visas här distribuerar containerbilder till befintliga funktionsappresurser i Azure.

Innan du använder denna YAML-fil, genomför följande steg:

Uppdatera värdena för REGISTRY, NAMESPACE, IMAGE, och TAG baserat på ditt containerregister.
Uppdatera containerarkivets inloggningsuppgifter i åtgärden docker/login-action .

I mallen, uppdatera variablerna env: för ditt projekt. Varje mall kräver AZURE_FUNCTIONAPP_NAME. De andra variablerna beror på ditt språk:

Variabel	Krävs	Description
`AZURE_FUNCTIONAPP_NAME`	Yes	Your function app name in Azure
`DOTNET_VERSION`	Yes	.NET-versionen av ditt projekt (till exempel, `10.0.x`)
`AZURE_FUNCTIONAPP_PROJECT_PATH`	Nej	Väg till din projektmapp. Standard: `.` (repository-rot)

Variabel	Krävs	Description
`AZURE_FUNCTIONAPP_NAME`	Yes	Ditt funktionsappnamn i Azure. Måste matcha `functionAppName` i pom.xml.
`JAVA_VERSION`	Yes	Java-versionen av ditt projekt (till exempel, `21`)
`POM_XML_DIRECTORY`	Nej	Väg till katalogen som innehåller pom.xml. Standard: `.` (repository-rot)

Variabel	Krävs	Description
`AZURE_FUNCTIONAPP_NAME`	Yes	Your function app name in Azure
`NODE_VERSION`	Yes	Den Node.js versionen av ditt projekt (till exempel, `22`)
`AZURE_FUNCTIONAPP_PROJECT_PATH`	Nej	Väg till din projektmapp. Standard: `.` (repository-rot)

Variabel	Krävs	Description
`AZURE_FUNCTIONAPP_NAME`	Yes	Your function app name in Azure
`PYTHON_VERSION`	Yes	Python-versionen av ditt projekt (till exempel, `3.13.x`)
`AZURE_FUNCTIONAPP_PROJECT_PATH`	Nej	Väg till din projektmapp. Standard: `.` (repository-rot)

Variabel	Krävs	Description
`AZURE_FUNCTIONAPP_NAME`	Yes	Your function app name in Azure
`REGISTRY`	Yes	Din containerregistry-inloggningsserver (till exempel, `contoso.azurecr.io`)
`NAMESPACE`	Yes	Namnrymden/arkivet i ditt register
`IMAGE`	Yes	Containerbildens namn
`TAG`	Yes	Bildtaggen (till exempel, `${{ github.sha }}`)

OIDC-mallarna inkluderar redan steget azure/login med OIDC-autentisering. Kontrollera att , , och secrets.AZURE_CLIENT_ID referenserna stämmer överens med secrets.AZURE_TENANT_ID. secrets.AZURE_SUBSCRIPTION_ID
Lägg till den här nya YAML-filen i sökvägen /.github/workflows/ i din lagringsplats.

Skapa arbetsflödeskonfigurationen i portalen

När du använder portalen för att aktivera GitHub Actions hanterar Functions all installation automatiskt. Du behöver inte manuellt skapa en hanterad identitet, konfigurera behörigheter eller skriva en arbetsflödesfil. Functions utför dessa uppgifter åt dig:

I din Azure-prenumeration:

Skapar en användartilldelad hanterad identitet och tilldelar den rollen som webbplatsbidragsgivare i din funktionsapp.
Lägger till en federerad inloggningsinformation till den hanterade identiteten för GitHub OIDC-autentisering.

I ditt GitHub-arkiv:

Lägger till klient-ID, prenumerations-ID och tenant-ID-värden som GitHub Actions-hemligheter.
Skapar en arbetsflödesfil baserad på din applikationsstack och commitar den till .github/workflows.

Under funktionsappens skapande

Du kan komma igång snabbt med GitHub Actions via fliken Distribution när du skapar en funktion i Azure portalen. Så här lägger du till ett GitHub Actions arbetsflöde när du skapar en ny funktionsapp:

I Azure-portalen väljer du Deployment i flödet Skapa funktionsapp.
Aktivera Kontinuerlig distribution om du vill att varje koduppdatering ska utlösa en kod-push till Azure-portalen.
Under GitHub-inställningar, välj Auktorisera för att koppla ditt GitHub-konto. Logga in med GitHub-kontot som har skrivbehörighet till ditt repository.
Ange din GitHub organisation, lagringsplats och gren.
Valfritt, välj Förhandsgranska fil för att se hur arbetsflödesfilen ser ut innan den genereras och läggs till i ditt arkiv.
Slutför konfigurationen av funktionsappen. Din GitHub-lagringsplats innehåller nu en ny arbetsflödesfil i /.github/workflows/.

För en befintlig funktionsapp

Så här lägger du till ett GitHub Actions arbetsflöde i en befintlig funktionsapp:

Gå till din funktionsapp i Azure-portalen och välj Deployment>Deployment Center.
Välj Kontinuerlig Distribution (CI/CD). För Källa väljer du GitHub. Om du inte ser standardmeddelandet Bygger med GitHub Actions, välj Change provider, välj GitHub Actions och välj OK.
Om du inte redan har auktoriserat GitHub-åtkomst, välj Auktorisera. Ange dina GitHub autentiseringsuppgifter och välj Sign in. Om du vill auktorisera ett annat GitHub konto väljer du Change-konto och loggar in med ett annat konto.
Välj din GitHub Organization, Repository och Branch. För att distribuera med GitHub Actions måste du ha skrivbehörighet till detta arkiv.
För alternativet Arbetsflöde, välj Lägg till ett arbetsflöde. Detta alternativ skapar en ny arbetsflödesfil i /.github/workflows/. För att använda ett befintligt arbetsflöde, välj Använd tillgängligt arbetsflöde och välj din arbetsflödesfil.
I autentiseringsinställningarna, välj Användartilldelad identitet för att använda OpenID Connect (OIDC), vilket rekommenderas eftersom det inte kräver att du lagrar hemligheter i GitHub. Välj din prenumeration och det (nya) föreslagna identitetsnamnet. En ny användartilldelad hanterad identitet skapas och ges tillgång till rollen som webbplatsbidragsgivare . Om du använder en befintlig identitet måste du först ge den tillgång till rollen som webbplatsbidragsgivare .

Viktigt!

När du väljer Grundläggande autentisering lagras din publiceringsprofil, som innehåller delade hemligheter, i GitHub Secrets. Du måste också aktivera SCM-grundläggande autentisering, vilket gör din app mindre säker.
Välj Förhandsfil för att se arbetsflödesfilen som läggs till i din GitHub-lagringsplats i .github/workflows/.
Välj Spara för att lägga till arbetsflödesfilen på lagringsplatsen. Välj fliken Loggar för att se status för nuvarande och tidigare distributioner.

Skapa arbetsflödeskonfigurationsfilen

Du kan skapa konfigurationsfilen för GitHub Actions arbetsflöde från Azure Functions mallar direkt från din GitHub lagringsplats.

I GitHub går du till lagringsplatsen.
Välj Åtgärder och Nytt arbetsflöde.
Sök efter funktioner.
I de funktionsapparbetsflöden som visas som skapats av Microsoft Azure letar du reda på det som matchar kodspråket och väljer Configure.
I den nyligen skapade YAML-filen uppdaterar du parametern env.AZURE_FUNCTIONAPP_NAME med namnet på funktionsappresursen i Azure. Du kan också behöva uppdatera parametern som sätter språkversionen som används av din app, till exempel DOTNET_VERSION för C# eller PYTHON_VERSION Python-appar.
Standardmallarna kan använda verifiering av publicera profiler istället för den rekommenderade OIDC. För att byta till OIDC och anpassa dig till portalbeteenden, gör följande ändringar:
- Ta bort , publish-profile, och scm-do-build-during-deployment parametrarna enable-oryx-buildfrån Azure/functions-action.
- Ta bort inställningen environment från jobbet (om den finns), eftersom den federerade behörighetssubjektet måste matcha branch trigger.
- Lägg till ett azure/login steg före steget Azure/functions-action :
```
- 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 }}
```
- Lägg till följande behörigheter i jobbet:
```
permissions:
  id-token: write
  contents: read
```
Verifiera att den nya arbetsflödesfilen sparas med ett lämpligt namn i /.github/workflows/ och välj Commit changes.

Azure Functions åtgärd

Åtgärden Azure Functions (Azure/functions-action) definierar hur koden publiceras till en befintlig funktionsapp i Azure eller till ett specifikt fack i din app.

Parametrar

Följande tabell beskriver de indataparametrar som stöds av Azure/functions-action:

Parameter	Description
appnamn	(Obligatoriskt) Namnet på din funktionsapp i Azure.
paket	(Obligatoriskt) Vägen till ditt projekt att publicera. Standard: `.` (alla filer i arkivet).
Fjärrbyggnation	Ställ in på `true` för att aktivera en byggåtgärd från Kudu när du distribuerar till en Flex Consumption-app. Oryx-bygge utförs alltid; Sätt inte heller SCM-bygg-under-utplacering eller aktivera-oryx-bygga. Standardvärde: `false`.
SCM-DO-bygg-under-utplacering	Låt Kudu-platsen utföra fördriftoperationer som fjärrbyggnationer. Ställ in så att `true` Kudu bygger ditt projekt under driften. Standardvärde: `false`. Mer information finns i `SCM_DO_BUILD_DURING_DEPLOYMENT`.
aktivera-oryx-bygge	Låt Kudu lösa projektberoenden genom att använda Oryx. Ställ in både detta och scm-do-build-undering-deployment att `true` använda Oryx istället för arbetsflödet. Standardvärde: `false`. Linux, endast.
slot-name	Utplaceringsplatsen att utplacera till. Standard: produktionsplats.
publicera profil	Namnet på den GitHub-hemlighet som innehåller din publiceringsprofil. Inte nödvändigt när man använder rekommenderad OIDC-autentisering.
Sku	Ställ in på `flexconsumption` när du autentiserar med publicish-profile på en Flex Consumption-plan. Behövs inte med OIDC-autentisering eller andra hostingplaner.
respect-pom-xml	(endast Java) Ställ in på `true` för att härleda utplaceringsartefakten från pom.xml. När `true`, ställ paketet till .`.` Standardvärde: `false`.
respekt-funkonignär	Ställ in på `true` att respektera din .funcignore-fil och uteslut listade vägar. Standardvärde: `false`.

Följande tabell visar vilka parametrar som stöds för varje värdplan:

Parameter	Flex Consumption	Elastisk premie	Dedicated	Konsumtion
appnamn	Krävs	Krävs	Krävs	Krävs
paket	Krävs	Krävs	Krävs	Krävs
Fjärrbyggnation	Optional	—	—	—
SCM-DO-bygg-under-utplacering	—	Optional	Optional	Optional
aktivera-oryx-bygge	—	Valfritt (Linux)	Valfritt (Linux)	Valfritt (Linux)
slot-name	Stöds ej	Optional	Optional	Optional
publicera profil	Rekommenderas inte	Rekommenderas inte	Rekommenderas inte	Rekommenderas inte
Sku	Endast publicera profil	—	—	—
respect-pom-xml	Valfritt (Java)	Valfritt (Java)	Valfritt (Java)	Valfritt (Java)
respekt-funkonignär	Optional	Optional	Optional	Optional

Distributionsmetoder

När du använder GitHub Actions beror distributionsmetoden på din hostingplan:

Hostingplan	Distributionsmetod
Flexförbrukning	En distribution
Elastisk premie	Zip-distribution
Dedikerad (App Service)	Zip-distribution
Förbrukning	Windows: Distribution via ZIP Linux: URL för externt paket^*

* Möjligheten att köra dina appar på Linux i en konsumtionsplan planeras att avvecklas. Mer information finns i Azure Functions Consumption plan hosting.

Mer information finns i Distributionstekniker i Azure Functions.

Nästa steg

Feedback

Var den här sidan till hjälp?

Last updated on 2026-08-14