Recapito continuo con GitHub Actions

Articolo
03/16/2024

È possibile usare un flusso di lavoro di GitHub Actions per definire un flusso di lavoro per compilare e distribuire automaticamente il codice nell'app per le funzioni in Funzioni di Azure.

Un file YAML (.yml) che definisce la configurazione del /.github/workflows/ flusso di lavoro viene mantenuto nel percorso nel repository. Questa definizione contiene le azioni e i parametri che costituiscono il flusso di lavoro, specifico del linguaggio di sviluppo delle funzioni. Un flusso di lavoro di GitHub Actions per Funzioni esegue le attività seguenti, indipendentemente dalla lingua:

Configurare l'ambiente.
Compilare il progetto di codice.
Distribuire il pacchetto in un'app per le funzioni in Azure.

L'azione Funzioni di Azure gestisce la distribuzione in un'app per le funzioni esistente in Azure.

È possibile creare manualmente un file di configurazione del flusso di lavoro per la distribuzione. È anche possibile generare il file da un set di modelli specifici della lingua in uno dei modi seguenti:

Nel portale di Azure
Con l'interfaccia della riga di comando di Azure
Dal repository GitHub

Se non si vuole creare il file YAML a mano, selezionare un metodo diverso nella parte superiore dell'articolo.

Prerequisiti

Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.
Un account GitHub. Se non è disponibile, iscriversi per riceverne uno gratuito.
Un'app per le funzioni funzionante ospitata in Azure con codice sorgente in un repository GitHub.

Interfaccia della riga di comando di Azure, durante lo sviluppo in locale. È anche possibile usare l'interfaccia della riga di comando di Azure in Azure Cloud Shell.

Generare le credenziali per la distribuzione

Poiché GitHub Actions usa il profilo di pubblicazione per accedere all'app per le funzioni durante la distribuzione, è prima necessario ottenere il profilo di pubblicazione e archiviarlo in modo sicuro come segreto GitHub.

Importante

Il profilo di pubblicazione è una credenziale preziosa che consente l'accesso alle risorse di Azure. Assicurarsi di trasportarlo sempre e archiviarlo in modo sicuro. In GitHub il profilo di pubblicazione deve essere archiviato solo nei segreti GitHub.

Scaricare il profilo di pubblicazione

Per scaricare il profilo di pubblicazione dell'app per le funzioni:

Selezionare la pagina Panoramica dell'app per le funzioni e quindi selezionare Recupera profilo di pubblicazione.
Salvare e copiare il contenuto del file.

Aggiungere il segreto GitHub

In GitHub, andare al proprio repository.
Andare a Impostazioni.
Selezionare Segreti e variabili > Azioni.
Selezionare Nuovo segreto repository.
Aggiungere un nuovo segreto con il nome AZURE_FUNCTIONAPP_PUBLISH_PROFILE e il valore impostato sul contenuto del file del profilo di pubblicazione.
Selezionare Aggiungi segreto.

GitHub può ora eseguire l'autenticazione all'app per le funzioni in Azure.

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.

Creare la configurazione del flusso di lavoro nel portale

Quando si usa il portale per abilitare GitHub Actions, Funzioni crea un file del flusso di lavoro basato sullo stack di applicazioni ed esegue il commit nel repository GitHub nella directory corretta.

Il portale ottiene automaticamente il profilo di pubblicazione e lo aggiunge ai segreti GitHub per il repository.

Durante la creazione dell'app per le funzioni

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

Nella portale di Azure selezionare Distribuzione nel flusso Crea app per le funzioni.
Abilitare la distribuzione continua se si vuole che ogni aggiornamento del codice attivi un push di codice per portale di Azure.
Immettere l'organizzazione, il repository e il ramo GitHub.
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 di GitHub Actions a un'app per le funzioni esistente:

Passare all'app per le funzioni nel portale di Azure e selezionare Centro distribuzione.
Per Origine selezionare GitHub. Se non viene visualizzato il messaggio predefinito Compilazione con GitHub Actions, selezionare Cambia provider scegliere GitHub Actions e selezionare OK.
Se l'accesso a GitHub non è già stato autorizzato, selezionare Autorizza. Specificare le credenziali di GitHub e selezionare Accedi. Per autorizzare un account GitHub diverso, selezionare Cambia account e accedere con un altro account.
Selezionare l'organizzazione, il repository e il ramo di GitHub. Per eseguire la distribuzione con GitHub Actions, è necessario avere accesso in scrittura a questo repository.
In Impostazioni di autenticazione scegliere se fare in modo che GitHub Actions esegua l'autenticazione con un'identitàassegnata dall'utente o usando le credenziali di autenticazione di base. Per l'autenticazione di base, vengono usate le credenziali correnti.
Selezionare Anteprima file per visualizzare il file del flusso di lavoro che viene aggiunto al repository GitHub in github/workflows/.
Selezionare Salva per aggiungere il file del flusso di lavoro al repository.

Aggiungere la configurazione del flusso di lavoro al repository

È possibile usare il az functionapp deployment github-actions add comando per generare un file di configurazione del flusso di lavoro dal modello corretto per l'app per le funzioni. Il nuovo file YAML viene quindi archiviato nel percorso corretto (/.github/workflows/) nel repository GitHub specificato, mentre il file del profilo di pubblicazione per l'app viene aggiunto ai segreti GitHub nello stesso repository.

Eseguire questo az functionapp comando, sostituendo i valori githubUser/githubRepo, MyResourceGroupe MyFunctionapp:
```
az functionapp deployment github-actions add --repo "githubUser/githubRepo" -g MyResourceGroup -n MyFunctionapp --login-with-github
```
Questo comando usa un metodo interattivo per recuperare un token di accesso personale per l'account GitHub.

Nella finestra del terminale dovrebbe essere visualizzato un messaggio simile al seguente:

Please navigate to https://github.com/login/device and enter the user code XXXX-XXXX to activate and retrieve your GitHub personal access token.

Copiare il codice univoco XXXX-XXXX , passare a https://github.com/login/devicee immettere il codice copiato. Dopo aver immesso il codice, verrà visualizzato un messaggio simile al seguente:

Verified GitHub repo and branch
Getting workflow template using runtime: java
Filling workflow template with name: func-app-123, branch: main, version: 8, slot: production, build_path: .
Adding publish profile to GitHub
Fetching publish profile with secrets for the app 'func-app-123'
Creating new workflow file: .github/workflows/master_func-app-123.yml

Passare al repository GitHub e selezionare Azioni. Verificare che il flusso di lavoro sia stato eseguito.

Creare il file di configurazione del flusso di lavoro

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

In GitHub, andare al proprio 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 individuare quello corrispondente al linguaggio di codice e selezionare Configura.
Nel file YAML appena creato aggiornare il env.AZURE_FUNCTIONAPP_NAME parametro con il nome della risorsa dell'app per le funzioni in Azure. Facoltativamente, potrebbe essere necessario aggiornare il parametro che imposta la versione del linguaggio usata dall'app, ad esempio DOTNET_VERSION per C#.
Verificare che il nuovo file del flusso di lavoro sia in fase di salvataggio /.github/workflows/ e selezionare Commit changes(Esegui il commit delle modifiche).

Aggiornare una configurazione del flusso di lavoro

Se per qualche motivo, è necessario aggiornare o modificare una configurazione del flusso di lavoro esistente, passare semplicemente al /.github/workflows/ percorso nel repository, aprire il file YAML specifico, apportare le modifiche necessarie e quindi eseguire il commit degli aggiornamenti nel repository.

Esempio: file di configurazione del flusso di lavoro

Nell'esempio di modello seguente viene usata la functions-action versione 1 di e un publish profile per l'autenticazione. Il modello dipende dal linguaggio scelto e dal sistema operativo in cui viene distribuita l'app per le funzioni:

Windows
Linux

Se l'app per le funzioni viene eseguita in Linux, selezionare Linux.

name: Deploy DotNet project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  DOTNET_VERSION: '6.0.x'                   # set this to the dotnet version to use (e.g. '2.1.x', '3.1.x', '5.0.x')

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

    - name: Setup DotNet ${{ env.DOTNET_VERSION }} Environment
      uses: actions/setup-dotnet@v3
      with:
        dotnet-version: ${{ env.DOTNET_VERSION }}

    - name: 'Resolve Project Dependencies Using Dotnet'
      shell: pwsh
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        dotnet build --configuration Release --output ./output
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: '${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}/output'
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy DotNet project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  DOTNET_VERSION: '6.0.x'                   # set this to the dotnet version to use (e.g. '2.1.x', '3.1.x', '5.0.x')

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

    - name: Setup DotNet ${{ env.DOTNET_VERSION }} Environment
      uses: actions/setup-dotnet@v3
      with:
        dotnet-version: ${{ env.DOTNET_VERSION }}

    - name: 'Resolve Project Dependencies Using Dotnet'
      shell: bash
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        dotnet build --configuration Release --output ./output
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: '${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}/output'
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy Java project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  POM_XML_DIRECTORY: '.'                    # set this to the directory which contains pom.xml file
  JAVA_VERSION: '8'                         # set this to the java version to use (e.g. '8', '11', '17')

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

    - name: Setup Java Sdk ${{ env.JAVA_VERSION }}
      uses: actions/setup-java@v1
      with:
        java-version: ${{ env.JAVA_VERSION }}

    - name: 'Restore Project Dependencies Using Mvn'
      shell: pwsh
      run: |
        pushd './${{ env.POM_XML_DIRECTORY }}'
        mvn clean package
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: '${{ env.POM_XML_DIRECTORY }}' # if there are multiple function apps in same project, then this path will be like './${{ env.POM_XML_DIRECTORY }}/target/azure-functions/${{ env.POM_FUNCTIONAPP_NAME }'
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}
        respect-pom-xml: true

name: Deploy Java project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  POM_XML_DIRECTORY: '.'                    # set this to the directory which contains pom.xml file
  JAVA_VERSION: '8'                         # set this to the java version to use (e.g. '8', '11', '17')

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

    - name: Setup Java Sdk ${{ env.JAVA_VERSION }}
      uses: actions/setup-java@v1
      with:
        java-version: ${{ env.JAVA_VERSION }}

    - name: 'Restore Project Dependencies Using Mvn'
      shell: bash
      run: |
        pushd './${{ env.POM_XML_DIRECTORY }}'
        mvn clean package
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: '${{ env.POM_XML_DIRECTORY }}' # if there are multiple function apps in same project, then this path will be like './${{ env.POM_XML_DIRECTORY }}/target/azure-functions/${{ env.POM_FUNCTIONAPP_NAME }'
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}
        respect-pom-xml: true

name: Deploy Node.js project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  NODE_VERSION: '16.x'                      # set this to the node version to use (e.g. '8.x', '10.x', '12.x')

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

    - name: Setup Node ${{ env.NODE_VERSION }} Environment
      uses: actions/setup-node@v3
      with:
        node-version: ${{ env.NODE_VERSION }}

    - name: 'Resolve Project Dependencies Using Npm'
      shell: pwsh
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        npm install
        npm run build --if-present
        npm run test --if-present
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy Node.js project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  NODE_VERSION: '16.x'                      # set this to the node version to use (e.g. '8.x', '10.x', '12.x')

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

    - name: Setup Node ${{ env.NODE_VERSION }} Environment
      uses: actions/setup-node@v3
      with:
        node-version: ${{ env.NODE_VERSION }}

    - name: 'Resolve Project Dependencies Using Npm'
      shell: bash
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        npm install
        npm run build --if-present
        npm run test --if-present
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy Python project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  PYTHON_VERSION: '3.9'                     # set this to the python version to use (e.g. '3.6', '3.7', '3.8')

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

    - name: Setup Python ${{ env.PYTHON_VERSION }} Environment
      uses: actions/setup-python@v4
      with:
        python-version: ${{ env.PYTHON_VERSION }}

    - name: 'Resolve Project Dependencies Using Pip'
      shell: bash
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        python -m pip install --upgrade pip
        pip install -r requirements.txt --target=".python_packages/lib/site-packages"
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}
        scm-do-build-during-deployment: true
        enable-oryx-build: true

name: Deploy PowerShell project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root

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

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy PowerShell project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root

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

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

Funzioni di Azure'azione

L'azione Funzioni di Azure (Azure/azure-functions) 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

I parametri seguenti vengono usati più comunemente con questa azione:

Parametro	Spiegazione
app-name	(Obbligatorio) Nome dell'app per le funzioni.
slot-name	(Facoltativo) Nome di uno slot di distribuzione specifico in cui si vuole eseguire la distribuzione. Lo slot deve esistere già nell'app per le funzioni. Se non specificato, il codice viene distribuito nello slot attivo.
publish-profile	(Facoltativo) Nome del segreto GitHub che contiene il profilo di pubblicazione.

Sono supportati anche i parametri seguenti, ma vengono usati solo in casi specifici:

Parametro	Spiegazione
package	(Facoltativo) Imposta un percorso secondario nel repository da cui pubblicare. Per impostazione predefinita, questo valore è impostato su `.`, il che significa che tutti i file e le cartelle nel repository GitHub vengono distribuiti.
respect-pom-xml	(Facoltativo) Usato solo per le funzioni Java. Indica se è necessario che l'artefatto di distribuzione dell'app sia derivato dal file pom.xml. Quando si distribuiscono app per le funzioni Java, è necessario impostare questo parametro su `true` e su `package.`. Per impostazione predefinita, questo parametro è impostato su `false`, il che significa che il `package` parametro deve puntare alla posizione dell'artefatto dell'app, ad esempio `./target/azure-functions/`
rispetto-funcignore	(Facoltativo) Se GitHub Actions rispetta il file con estensione funcignore per escludere file e cartelle definiti. Impostare questo valore su `true` quando il repository ha un file con estensione funcignore e si vuole usarlo per escludere percorsi e file, ad esempio configurazioni dell'editor di testo, vscode/o un ambiente virtuale Python (con estensione venv/). L'impostazione predefinita è `false`.
scm-do-build-during-deployment	(Facoltativo) Indica se il sito di distribuzione servizio app (Kudu) esegue operazioni di pre-distribuzione. Il sito di distribuzione per l'app per le funzioni è disponibile in `https://<APP_NAME>.scm.azurewebsites.net/`. Modificare questa impostazione su `true` quando è necessario controllare le distribuzioni in Kudu anziché risolvere le dipendenze nel flusso di lavoro di GitHub Actions. Il valore predefinito è `false`. Per altre informazioni, vedere l'impostazione SCM_DO_BUILD_DURING_DEPLOYMENT .
enable-oryx-build	(Facoltativo) Se il sito di distribuzione Kudu risolve le dipendenze del progetto usando Oryx. Impostare su `true` quando si vuole usare Oryx per risolvere le dipendenze del progetto usando una compilazione remota anziché il flusso di lavoro di GitHub Actions. Quando `true`, è necessario impostare anche su `truescm-do-build-during-deployment` . Il valore predefinito è `false`.

Considerazioni

Quando si usa l'azione di Funzioni di Azure, tenere presenti le considerazioni seguenti:

Quando si usa GitHub Actions, il codice viene distribuito nell'app per le funzioni usando la distribuzione ZIP per Funzioni di Azure.
Le credenziali richieste da GitHub per la connessione ad Azure per la distribuzione vengono archiviate come segreti nel repository GitHub e accessibili nella distribuzione come secrets.<SECRET_NAME>.
Il modo più semplice per l'autenticazione di GitHub Actions con Funzioni di Azure per la distribuzione consiste nell'usare un profilo di pubblicazione. È anche possibile eseguire l'autenticazione usando un'entità servizio. Per altre informazioni, vedere questo repository GitHub Actions.
Le azioni per la configurazione dell'ambiente e l'esecuzione di una compilazione vengono generate dai modelli e sono specifiche della lingua.
I modelli usano env elementi per definire impostazioni univoce per la compilazione e la distribuzione.

Passaggi successivi

Altre informazioni sull'integrazione di Azure e GitHub

Share via