Distribuisci su Funzioni di Azure usando GitHub Actions

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

• 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.

1. 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.

2. Dall'output, si notano i clientId valori di 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.

3. Usa il comando az role assignment create per assegnare il Website Contributor ruolo all'identità gestita, con ambito alla tua app di funzione:

   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.

4. Usa il comando create di un'identità federata di az per creare una credenziale federata che si fida dei token dal tuo 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.

5. (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.

1. In GitHub passare al repository.

2. Vai su Impostazioni>Segreti e variabili>Azioni.

3. Nella scheda Segreti , seleziona Nuovo segreto del repository.

4. 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.

1. 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.

2. Usa il modello di workflow OIDC specifico per linguaggio dal repository 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:

   • .NET
   • Java
   • JavaScript
   • Python
   • PowerShell
   • Contenitore

   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'
   

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

   • .NET
   • Java
   • JavaScript
   • Python
   • PowerShell
   • Contenitore

   Variabile	Richiesto	Description
   AZURE_FUNCTIONAPP_NAME	Sì	Il nome della tua app funzione 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 repository)

4. 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.

5. 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 archivio 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 fa commit su .github/workflows.

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:

1. Nel portale Azure, selezionare Distribuzione nel flusso Crea app per le funzioni.

2. Abilitare Continuous Deployment se si vuole che ogni aggiornamento del codice attivi un push di codice nel portale di Azure.

3. 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.

4. Inserire l'organizzazione GitHub, il repository e il ramo.

5. Opzionalmente, seleziona File di anteprima per vedere come appare il file di workflow prima che venga generato e aggiunto al tuo repository.

6. 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:

1. Vai all'app funzione nel portale Azure e seleziona Centro di distribuzione> distribuzione.

2. Seleziona Continuous Deployment (CI/CD). In Origine selezionare GitHub. Se non vedi la creazione di messaggi predefinita con GitHub Actions, seleziona Change provider, scegli GitHub Actions e seleziona OK.

3. 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.

4. Seleziona la tua Organizzazione, Repository e Branch su GitHub. Per distribuire utilizzando GitHub Actions, devi avere accesso di scrittura a questo repository.

5. 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.

6. 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.

7. Seleziona Anteprima file per visualizzare il file del flusso di lavoro aggiunto al repository GitHub in .github/workflows/.

8. 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.

1. In GitHub passare al repository.

2. Selezionare Azioni e Nuovo flusso di lavoro.

3. Cercare le funzioni.

   

4. Nei flussi di lavoro delle app per le funzioni visualizzate creati da Microsoft Azure trovare quello corrispondente al linguaggio di codice e selezionare Configura.

5. 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.

6. 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 publish-profileparametri , 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
     

7. Verifica che il nuovo file di workflow sia salvato con un nome appropriato in /.github/workflows/ e seleziona Commit modifiche.