Recapito continuo con GitHub Actions

Articolo
10/31/2024

È possibile usare un flusso di lavoro 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 flusso di lavoro viene mantenuto nel percorso /.github/workflows/ 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.

L'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:

Nel portale di Azureindividuare la pagina per l'app per le funzioni, espandere Impostazioni>Configurazione nella colonna sinistra.
Nella pagina Configurazione, selezionare la scheda Impostazioni generali e assicurarsi che le Credenziali di pubblicazione dell'autenticazione di base di SCM siano impostate su On. Quando questa impostazione è Disattivata, non è possibile usare i profili di pubblicazione, quindi selezionare On e Salva.
Tornare alla pagina Panoramica dell'app per le funzioni e quindi selezionare Ottieni profilo di pubblicazione.
Salvare e copiare il contenuto del file.

Aggiungere il segreto di 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 nel portale di Azure. Per aggiungere un flusso di lavoro GtHub Actions quando si crea una nuova app per le funzioni:

Nel portale di Azure, selezionare Distribuzione nel flusso di Crea app per le funzioni.
Abilitare Distribuzione continua se si vuole che ogni aggiornamento del codice attivi un push di codice nel 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 Organizzazione, Repository e Ramo in GitHub. Per eseguire la distribuzione con GitHub Actions, è necessario avere accesso in scrittura a questo repository.
In Impostazioni di autenticazione, scegliere se eseguire l'autenticazione di GitHub Actions con una identità assegnata dall'utente o usare le credenziali di autenticazione di base. Per l'autenticazione di base, vengono usate le credenziali correnti.
Selezionare file di anteprima 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.

Aggiungere la configurazione del flusso di lavoro al repository

È possibile usare il comando az functionapp deployment github-actions add 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 comando az functionapp, sostituendo i valori githubUser/githubRepo, MyResourceGroup e 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 XXXX-XXXX univoco, passare a https://github.com/login/device e 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 alla lingua del 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. 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 venga salvato in /.github/workflows/ e selezionare Conferma 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 percorso di /.github/workflows/ 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 versione 1 del functions-action 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 }}

Azione di Funzioni di Azure

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

Per tutti i piani dell'app per le funzioni sono necessari i parametri seguenti:

Parametro	Spiegazione
app-name	Nome dell'app per le funzioni.
package	Questo è il percorso nel progetto da pubblicare. Per impostazione predefinita, questo valore è impostato su `.`, il che significa che tutti i file e le cartelle nel repository GitHub verranno distribuiti.

Per il piano Flex Consumption sono necessari i parametri seguenti:

Parametro	Spiegazione
sku	Impostare su quando `flexconsumption` si esegue l'autenticazione con publish-profile. Quando si usano le credenziali di controllo degli accessi in base al ruolo o si distribuisce in un piano a consumo non flessibile, l'azione può risolvere il valore, pertanto il parametro non deve essere incluso.
remote-build	Impostare questa opzione su `true` per abilitare un'azione di compilazione da Kudu quando il pacchetto viene distribuito in un'app Flex Consumption. La compilazione Oryx viene sempre eseguita durante una compilazione remota in Flex Consumption; non impostare scm-do-build-during-deployment o enable-oryx-build. Per impostazione predefinita, il parametro è impostato su `false`.

I parametri seguenti sono specifici dei piani Consumption, Elastic Premium e servizio app (Dedicated):

Parametro Spiegazione

scm-do-build-during-deployment (Facoltativo) Consentire al sito Kudu ( ad esempio https://<APP_NAME>.scm.azurewebsites.net/) di eseguire operazioni di pre-distribuzione, ad esempio compilazioni remote. Per impostazione predefinita, il parametro è impostato su false. Impostare questa opzione su true quando si vogliono controllare i comportamenti di distribuzione usando Kudu invece di risolvere le dipendenze nel flusso di lavoro di GitHub. Per altre informazioni, vedere l'impostazione SCM_DO_BUILD_DURING_DEPLOYMENT .

enable-oryx-build (Facoltativo) Consentire al sito Kudu di risolvere le dipendenze del progetto con Oryx. Per impostazione predefinita, il parametro è impostato su false. Se si vuole usare Oryx per risolvere le dipendenze anziché il flusso di lavoro GitHub, impostare sia scm-do-build-during-deployment che enable-oryx-build su true.

Parametro	Spiegazione
scm-do-build-during-deployment	(Facoltativo) Consentire al sito Kudu ( ad esempio `https://<APP_NAME>.scm.azurewebsites.net/`) di eseguire operazioni di pre-distribuzione, ad esempio compilazioni remote. Per impostazione predefinita, il parametro è impostato su `false`. Impostare questa opzione su `true` quando si vogliono controllare i comportamenti di distribuzione usando Kudu invece di risolvere le dipendenze nel flusso di lavoro di GitHub. Per altre informazioni, vedere l'impostazione `SCM_DO_BUILD_DURING_DEPLOYMENT` .
enable-oryx-build	(Facoltativo) Consentire al sito Kudu di risolvere le dipendenze del progetto con Oryx. Per impostazione predefinita, il parametro è impostato su `false`. Se si vuole usare Oryx per risolvere le dipendenze anziché il flusso di lavoro GitHub, impostare sia scm-do-build-during-deployment che enable-oryx-build su `true`.

Parametri facoltativi per tutti i piani dell'app per le funzioni:

Parametro	Spiegazione
slot-name	Si tratta del nome dello slot di distribuzione in cui eseguire la distribuzione. Per impostazione predefinita, questo valore è vuoto, il che significa che GitHub Action verrà distribuito nel sito di produzione. Quando questa impostazione punta a uno slot non di produzione, verificare che il parametro publish-profile contenga le credenziali per lo slot anziché il sito di produzione. Attualmente non è supportato in Flex Consumption.
publish-profile	Nome del segreto GitHub che contiene il profilo di pubblicazione.
respect-pom-xml	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 impostare `package` su `.`. Per impostazione predefinita, questo parametro è impostato su `false`, il che significa che il parametro `package` deve puntare alla posizione dell'artefatto dell'app, ad esempio `./target/azure-functions/`
respect-funcignore	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`.

Considerazioni

Quando si usa l'azione 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 univoche per la compilazione e la distribuzione.

Passaggi successivi

Altre informazioni sull'integrazione di Azure e GitHub

Condividi tramite