Distribuisci su Funzioni di Azure usando GitHub Actions

Puoi usare un workflow di GitHub Actions per compilare e distribuire automaticamente il codice delle funzioni su Azure utilizzando il Azure/functions-actionfile .

Per distribuire utilizzando GitHub Actions, completa questi tre passaggi chiave:

Crea un'identità gestita assegnata dall'utente in Azure con una credenziale federata che si fida del tuo repository GitHub, e assegnagli il ruolo di Contributore del sito web nella tua app funzionale.
Aggiungi l'ID client dell'identità, l'ID tenant e l'ID della sottoscrizione come segreti del repository in GitHub.
Aggiungi un file YAML di workflow al tuo repository che utilizza azure/login OpenID Connect (OIDC) per autenticare, poi chiama Azure/functions-action per distribuire.

Quando usi il portale Azure per abilitare GitHub Actions, Functions esegue automaticamente queste attività, sia nel tuo abbonamento Azure che nel tuo repository GitHub.

Crea una configurazione del workflow per Funzioni di Azure

Gestisci un file YAML (.yml) che definisce la configurazione del flusso di lavoro nel percorso /.github/workflows/ all'interno del tuo repository. Questa definizione contiene le azioni e i parametri che costituiscono il flusso di lavoro, specifico del linguaggio di sviluppo delle funzioni.

Scegli un metodo per creare il file del tuo flusso di lavoro usando il selettore in cima all'articolo:

metodo	Migliore per	Supporto per OIDC
Modello di workflow	Controllo completo: copia un template pronto per OIDC e personalizzalo	Richiede la configurazione
Portale di Azure	Configurazione più semplice: il portale può creare per te l'identità, le credenziali e il file di workflow	Configurato per te
GitHub Marketplace	GitHub-first: inizia dai template integrati del marketplace di GitHub	Richiede configurazione e modifica del template

Informazioni generali sull'autenticazione

GitHub Actions deve autenticarsi con Azure per distribuire il tuo codice. Questo articolo utilizza OpenID Connect (OIDC), che è il metodo di autenticazione raccomandato. L'OIDC utilizza credenziali federate per creare una relazione di fiducia tra il tuo repository GitHub e un'identità gestita assegnata dall'utente in Microsoft Entra. Nessun segreto è memorizzato su GitHub.

Esempio di autenticazione OIDC

Il seguente esempio inline mostra il modello principale di autenticazione e distribuzione OIDC utilizzato in tutti i modelli di workflow:

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 }}

Considerazioni sull'autenticazione OIDC su GitHub Actions

L'OIDC utilizza la federazione dell'identità del carico di lavoro e supporta solo le identità gestite assegnate dall'utente.
Quando abiliti una distribuzione basata su GitHub Actions nel portale Azure, l'autenticazione OIDC viene utilizzata di default.
Con OIDC, l'ID client, l'ID tenant e l'ID di abbonamento dell'identità gestita sono memorizzati come segreti del repository GitHub.
Usa il controllo degli accessi basato sul ruolo di Azure (Azure RBAC) per limitare l'accesso solo alle risorse Azure richieste per il tuo deployment.

Prerequisiti

Un account Azure con una sottoscrizione attiva. Creare un account gratuito.
Un account GitHub. Se non è disponibile, iscriversi per riceverne uno gratuito.
Codice sorgente del progetto in un repository GitHub.
Una comprensione di base dei flussi di lavoro di GitHub Actions. Se sei nuovo a GitHub Actions, consulta Understanding GitHub Actions.
Un'app funzionante ospitata su Azure (solo codice o basata su container).
(Solo per le distribuzioni di contenitori) Un registro contenitori esistente, come Registro Azure Container.

interfaccia della riga di comando di Azure durante lo sviluppo in locale. È anche possibile usare il interfaccia della riga di comando di Azure in Azure Cloud Shell.

Crea un'identità gestita per il deployment di GitHub Actions

OpenID Connect (OIDC) è il metodo di autenticazione consigliato per le implementazioni di GitHub Actions su Funzioni di Azure. Con OIDC, configuri un'identità gestita assegnata dall'utente in Azure e crei una relazione di fiducia con il tuo repository GitHub. Il flusso di lavoro può quindi autenticarsi con Azure senza memorizzare le credenziali come segreti.

Usare il comando az identity create per creare un'identità gestita assegnata all'utente.
```
az identity create --name myGitHubDeployIdentity --resource-group <RESOURCE_GROUP> \
--query "{clientId: clientId, tenantId: tenantId}" -o table
```
Sostituire <RESOURCE_GROUP> con il nome del gruppo di risorse.
Dall'output, annota i valori clientId e tenantId. Ottieni anche il tuo ID di abbonamento:
```
az account show --query "{subId: id}" -o table
```
Ti servono questi tre valori più avanti, quando aggiungi le credenziali a GitHub.

Usa il comando az role assignment create per assegnare il ruolo Website Contributor all'identità gestita, nell'ambito della tua app per le funzioni:

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

Sostituisci <APP_NAME> e <RESOURCE_GROUP> con i nomi della tua app e del gruppo risorse, rispettivamente.

Usa il comando az identity federated-credential create per creare una credenziale federata che considera attendibili i token del repository GitHub:

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

Sostituire <RESOURCE_GROUP>, <GITHUB_ORG>, <REPO_NAME> e <BRANCH_NAME> con i propri valori. L'argomento deve corrispondere al ramo che attiva il tuo flusso di lavoro.

(Opzionale) Se stai distribuendo un container da Registro Azure Container, assegna anche il acrpull ruolo all'identità gestita:

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>

Sostituire <SUBSCRIPTION_ID>, <RESOURCE_GROUP> e <REGISTRY_NAME> con i propri valori.

Aggiungi credenziali a GitHub

Usa i valori che hai copiato quando hai creato l'identità gestita.

In GitHub passare al repository.
Vai su Impostazioni>Segreti e variabili>Azioni.
Nella scheda Segreti , seleziona Nuovo segreto del repository.

Crea ciascuno dei seguenti segreti:

Name	Valore
`AZURE_CLIENT_ID`	La `clientId` dell'identità gestita
`AZURE_TENANT_ID`	La `tenantId` dell'identità gestita
`AZURE_SUBSCRIPTION_ID`	L'ID di abbonamento che contiene la tua app di funzione

Per le implementazioni di container da un registro privato, servono anche segreti specifici per registro. Per maggiori informazioni, vedi Azione di accesso Docker.

Creare il flusso di lavoro da un modello

Il modo migliore per creare manualmente una configurazione del flusso di lavoro consiste nell'iniziare dal modello ufficialmente supportato.

Scegliere Windows o Linux per assicurarsi di ottenere il modello per il sistema operativo corretto.
- Windows
- Linux
Le distribuzioni in Windows usano runs-on: windows-latest. Le implementazioni containerizzate richiedono Linux.

Le distribuzioni in Linux usano runs-on: ubuntu-latest. Usa Linux per le implementazioni containerizzate.

Usa il modello di flusso di lavoro OIDC specifico per la lingua dal repository delle azioni di Funzioni di Azure. Copia l'intero contenuto del file in un nuovo file chiamato .github/workflows/deploy-function-app.yml nel tuo repository:

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

Importante

Per nuove implementazioni di app di funzioni basate su container, utilizza il modello nativo di hosting App contenitore di Azure. Vedi Distribuire in App contenitore di Azure con GitHub Actions. L'elemento Azure/functions-container-action mostrato qui distribuisce immagini di contenitore nelle risorse esistenti dell'app per le funzioni in Azure.

Prima di utilizzare questo file YAML, completa i seguenti passaggi:

Aggiorna i valori di REGISTRY, NAMESPACE, IMAGE, e TAG in base al tuo registro container.
Aggiorna le credenziali del repository del container nell'azione docker/login-action .

Nel template, aggiorna le env: variabili per il tuo progetto. Ogni template richiede AZURE_FUNCTIONAPP_NAME. Le altre variabili dipendono dal tuo linguaggio:

Variabile	Richiesto	Description
`AZURE_FUNCTIONAPP_NAME`	Sì	Il nome dell'app per le funzioni in Azure
`DOTNET_VERSION`	Sì	La versione .NET del tuo progetto (ad esempio, `10.0.x`)
`AZURE_FUNCTIONAPP_PROJECT_PATH`	NO	Percorso verso la cartella del tuo progetto. Predefinito: `.` (radice del repository)

Variabile	Richiesto	Description
`AZURE_FUNCTIONAPP_NAME`	Sì	Il nome della tua app per le funzioni in Azure. Deve corrispondere a `functionAppName` in pom.xml.
`JAVA_VERSION`	Sì	La versione Java del tuo progetto (ad esempio, `21`)
`POM_XML_DIRECTORY`	NO	Percorso verso la directory che contiene pom.xml. Predefinito: `.` (radice del repository)

Variabile	Richiesto	Description
`AZURE_FUNCTIONAPP_NAME`	Sì	Il nome dell'app per le funzioni in Azure
`NODE_VERSION`	Sì	La versione Node.js del tuo progetto (ad esempio, `22`)
`AZURE_FUNCTIONAPP_PROJECT_PATH`	NO	Percorso verso la cartella del tuo progetto. Predefinito: `.` (radice del repository)

Variabile	Richiesto	Description
`AZURE_FUNCTIONAPP_NAME`	Sì	Il nome della tua app per le funzioni in Azure
`PYTHON_VERSION`	Sì	La versione Python del tuo progetto (ad esempio, `3.13.x`)
`AZURE_FUNCTIONAPP_PROJECT_PATH`	NO	Percorso verso la cartella del tuo progetto. Predefinito: `.` (radice del repository)

Variabile	Richiesto	Description
`AZURE_FUNCTIONAPP_NAME`	Sì	Il nome della tua app per le funzioni in Azure
`AZURE_FUNCTIONAPP_PROJECT_PATH`	NO	Percorso verso la cartella del tuo progetto. Predefinita: `.` (radice del repository)

Variabile	Richiesto	Description
`AZURE_FUNCTIONAPP_NAME`	Sì	Nome dell'app per le funzioni in Azure
`REGISTRY`	Sì	Il tuo server di login del registro container (ad esempio, `contoso.azurecr.io`)
`NAMESPACE`	Sì	Il namespace/repository nel tuo registro
`IMAGE`	Sì	Il nome dell'immagine del contenitore
`TAG`	Sì	Il tag immagine (ad esempio, `${{ github.sha }}`)

I template OIDC includono già il azure/login passaggio con l'autenticazione OIDC. Verifica che i secrets.AZURE_CLIENT_IDriferimenti , secrets.AZURE_TENANT_ID, e secrets.AZURE_SUBSCRIPTION_IDcorrispondano ai segreti del repository che hai creato.
Aggiungere questo nuovo file YAML nel percorso /.github/workflows/ nel repository.

Creare la configurazione del flusso di lavoro nel portale

Quando usi il portale per abilitare GitHub Actions, Functions gestisce tutta la configurazione automaticamente. Non è necessario creare manualmente un'identità gestita, configurare le credenziali o scrivere un file di workflow. Functions svolge questi compiti per te:

Nel tuo abbonamento Azure:

Crea un'identità gestita assegnata dall'utente e le assegna il ruolo di Contributore del sito web nella tua app di funzione.
Aggiunge una credenziale federata all'identità gestita per l'autenticazione OIDC su GitHub.

Nel tuo repository GitHub:

Aggiunge i valori dell'ID client, dell'ID dell'abbonamento e dell'ID tenant come segreti di GitHub Actions.
Crea un file di workflow basato sul tuo stack applicativo e lo invia a .github/workflows con un commit.

Durante la creazione dell'app per le funzioni

È possibile iniziare rapidamente a usare GitHub Actions tramite la scheda Distribuzione quando si crea una funzione nel portale di Azure. Per aggiungere un flusso di lavoro GitHub Actions quando si crea una nuova app per le funzioni:

Nel portale Azure, selezionare Distribuzione nel flusso Crea app per le funzioni.
Abilitare Continuous Deployment se si vuole che ogni aggiornamento del codice attivi un push di codice nel portale di Azure.
Nelle impostazioni di GitHub, seleziona Autorizza per connettere il tuo account GitHub. Accedi con l'account GitHub che ha accesso di scrittura al tuo repository.
Inserire l'organizzazione GitHub, il repository e il ramo.
Opzionalmente, seleziona File di anteprima per vedere come appare il file di workflow prima che venga generato e aggiunto al tuo repository.
Completare la configurazione dell'app per le funzioni. Il repository GitHub include ora un nuovo file del flusso di lavoro in /.github/workflows/.

Per un'app per le funzioni esistente

Per aggiungere un flusso di lavoro GitHub Actions a un'app per le funzioni esistente:

Vai all'app per le funzioni nel portale di Azure e seleziona Distribuzione>Centro distribuzione.
Seleziona Continuous Deployment (CI/CD). In Origine selezionare GitHub. Se non vedi il messaggio predefinito Building with GitHub Actions, seleziona Cambia provider, scegli GitHub Actions e seleziona OK.
Se non hai già autorizzato l'accesso a GitHub, seleziona Autorizza. Specificare le credenziali GitHub e selezionare Accedere. Per autorizzare un account di GitHub diverso, selezionare Modifica account e accedere con un altro account.
Seleziona la tua Organizzazione, Repository e Branch su GitHub. Per distribuire utilizzando GitHub Actions, devi avere accesso di scrittura a questo repository.
Per l'opzione Workflow, seleziona Aggiungi workflow. Questa opzione crea un nuovo file di workflow in /.github/workflows/. Per utilizzare un flusso di lavoro esistente, seleziona Usa il flusso di lavoro disponibile e scegli il file del tuo flusso di lavoro.
Nelle impostazioni di Autenticazione, scegli Identità assegnata dall'utente per usare OpenID Connect (OIDC), consigliata perché non richiede di memorizzare segreti in GitHub. Seleziona il tuo abbonamento e il nome di identità (Nuovo ) suggerito. Viene creata una nuova identità gestita assegnata dall'utente e viene concesso l'accesso al ruolo di Contributore del Sito Web. Se utilizzi un'identità esistente, devi prima concederle l'accesso al ruolo di Contributore del Sito Web.

Importante

Quando selezioni Autenticazione Base, il tuo profilo di pubblicazione, che contiene segreti condivisi, viene memorizzato in GitHub Secrets. Devi anche abilitare l'autenticazione SCM di base, che rende la tua app meno sicura.
Seleziona Anteprima file per visualizzare il file del flusso di lavoro aggiunto al repository GitHub in .github/workflows/.
Selezionare Salva per aggiungere il file del flusso di lavoro al repository. Seleziona la scheda Log per visualizzare lo stato delle implementazioni attuali e precedenti.

Creare il file di configurazione del flusso di lavoro

È possibile creare il file di configurazione del flusso di lavoro GitHub Actions dai modelli di Funzioni di Azure direttamente dal repository GitHub.

In GitHub passare al repository.
Selezionare Azioni e Nuovo flusso di lavoro.
Cercare le funzioni.
Nei flussi di lavoro delle app per le funzioni visualizzate creati da Microsoft Azure trovare quello corrispondente al linguaggio di codice e selezionare Configura.
Nel file YAML appena creato aggiornare il parametro env.AZURE_FUNCTIONAPP_NAME con il nome della risorsa dell'app per le funzioni in Azure. Potresti anche dover aggiornare il parametro che imposta la versione del linguaggio usata dalla tua app, ad esempio DOTNET_VERSION per C# o PYTHON_VERSION per app Python.
I template predefiniti potrebbero usare l'autenticazione del profilo pubblica invece dell'OIDC raccomandato. Per passare all'OIDC e allinearsi ai comportamenti dei portali, apporta le seguenti modifiche:
- Rimuovi i parametri publish-profile, scm-do-build-during-deployment e enable-oryx-build da Azure/functions-action.
- Rimuovi l'impostazione environment dal lavoro (se presente), poiché l'oggetto della credenziale federata deve corrispondere al trigger del ramo.
- Aggiungi un azure/login passaggio prima del Azure/functions-action passaggio:
```
- 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 }}
```
- Aggiungi i seguenti permessi al lavoro:
```
permissions:
  id-token: write
  contents: read
```
Verifica che il nuovo file di workflow sia salvato con un nome appropriato in /.github/workflows/ e seleziona Commit modifiche.

Azione di Funzioni di Azure

L'azione Funzioni di Azure (Azure/functions-action) definisce il modo in cui il codice viene pubblicato in un'app per le funzioni esistente in Azure o in uno slot specifico nell'app.

Parametri

La tabella seguente descrive i parametri di input supportati da Azure/functions-action:

Parametro	Description
app-name	(Richiesto) Il nome della tua function app in Azure.
package	(Richiesto) Il percorso verso il tuo progetto per pubblicare. Predefinito: `.` (tutti i file nel repository).
Costruzione remota	Imposta su `true` per richiedere una build remota quando distribuisci in un'applicazione nel piano Flex Consumption. La build remota usa sempre Oryx. Non impostare neanche scm-do-build-during-deployment o enable-oryx-build. Impostazione predefinita: `false`.
scm-do-build-during-deployment	Consentire al sito Kudu di eseguire operazioni prima della distribuzione come compilazioni remote. Imposta `true` per fare in modo che Kudu compili il progetto durante la distribuzione. Impostazione predefinita: `false`. Per altre informazioni, vedere `SCM_DO_BUILD_DURING_DEPLOYMENT`.
enable-oryx-build	Permette a Kudu di risolvere le dipendenze di progetto usando Oryx. Imposta questo e scm-do-build-during-deployment su `true` per usare Oryx invece del flusso di lavoro. Impostazione predefinita: `false`. Solo Linux.
slot-name	Lo slot di distribuzione in cui distribuire. Predefinito: slot di produzione.
publish-profile	Nome del segreto GitHub che contiene il profilo di pubblicazione. Non è necessario quando si utilizza l'autenticazione OIDC raccomandata.
sku	Impostato su `flexconsumption` quando si esegue l'autenticazione con il profilo di pubblicazione su un piano Flex Consumption. Non è necessario con l'autenticazione OIDC o altri piani di hosting.
respect-pom-xml	(solo per Java) Imposta su `true` per ricavare l'artefatto di deployment da pom.xml. Quando `true`, imposta il pacchetto su `.`. Impostazione predefinita: `false`.
respect-funcignore	Impostare su `true` per rispettare il file .funcignore ed escludere i percorsi elencati. Impostazione predefinita: `false`.

La tabella seguente mostra quali parametri sono supportati per ciascun piano di hosting:

Parametro	Flex Consumption	Elastic Premium	Dedicated	Consumo
app-name	Richiesto	Richiesto	Richiesto	Richiesto
package	Richiesto	Richiesto	Richiesto	Richiesto
Costruzione remota	Optional	—	—	—
scm-do-build-during-deployment	—	Optional	Optional	Optional
enable-oryx-build	—	Opzionale (Linux)	Opzionale (Linux)	Opzionale (Linux)
slot-name	Non supportato	Optional	Optional	Optional
publish-profile	Non consigliata	Non consigliata	Non consigliata	Non consigliata
sku	Pubblica solo il profilo	—	—	—
respect-pom-xml	Opzionale (Java)	Opzionale (Java)	Opzionale (Java)	Opzionale (Java)
respect-funcignore	Optional	Optional	Optional	Optional

Metodi di distribuzione

Quando usi GitHub Actions, il metodo di distribuzione dipende dal tuo piano di hosting:

Piano di hosting	Metodo di distribuzione
Consumo flessibile	Distribuzione di pacchetti
Elastic Premium	Distribuzione ZIP
Dedicato (servizio app)	Distribuzione ZIP
Consumo	Windows: distribuzione ZIP Linux: URL del pacchetto esterno^*

La possibilità di eseguire le app in Linux in un piano a consumo è pianificata per il ritiro. Per altre informazioni, vedere Hosting del piano a consumo di Funzioni di Azure.

Per altre informazioni, vedere Deployment technologies in Funzioni di Azure.

Passaggi successivi

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-09-16