Kontinuerlig leverans med hjälp av GitHub Actions

Du kan använda ett GitHub Actions-arbetsflöde för att definiera ett arbetsflöde för att automatiskt skapa och distribuera kod till funktionsappen i Azure Functions.

En YAML-fil (.yml) som definierar arbetsflödeskonfigurationen /.github/workflows/ underhålls i sökvägen på lagringsplatsen. Den här definitionen innehåller de åtgärder och parametrar som utgör arbetsflödet, vilket är specifikt för utvecklingsspråket för dina funktioner. Ett GitHub Actions-arbetsflöde för Functions utför följande uppgifter, oavsett språk:

1. Konfigurera miljön.
2. Skapa kodprojektet.
3. Distribuera paketet till en funktionsapp i Azure.

Azure Functions-åtgärden hanterar distributionen till en befintlig funktionsapp i Azure.

Du kan skapa en arbetsflödeskonfigurationsfil för distributionen manuellt. Du kan också generera filen från en uppsättning språkspecifika mallar på något av följande sätt:

• I Azure-portalen
• Använda Azure CLI
• Från din GitHub-lagringsplats

Om du inte vill skapa YAML-filen för hand väljer du en annan metod överst i artikeln.

Förutsättningar

• Ett Azure-konto med en aktiv prenumeration. Skapa ett konto utan kostnad.

• Ett GitHub-konto. Om du inte har ett sådant kan du registrera dig utan kostnad.

• En fungerande funktionsapp som finns i Azure med källkod på en GitHub-lagringsplats.

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

Generera autentiseringsuppgifter för distribution

Eftersom GitHub Actions använder din publiceringsprofil för att komma åt funktionsappen under distributionen måste du först hämta din publiceringsprofil och lagra den på ett säkert sätt som en GitHub-hemlighet.

Viktigt!

Publiceringsprofilen är en värdefull autentiseringsuppgift som ger åtkomst till Azure-resurser. Se till att du alltid transporterar och lagrar den säkert. I GitHub får publiceringsprofilen endast lagras i GitHub-hemligheter.

Ladda ned din publiceringsprofil

Så här laddar du ned publiceringsprofilen för funktionsappen:

1. I Azure Portal letar du upp sidan för funktionsappen och expanderar Konfiguration av inställningar>i den vänstra kolumnen.

2. På sidan Konfiguration väljer du fliken Allmänna inställningar och kontrollerar att SCM Basic Auth Publishing Credentials är aktiverat. När den här inställningen är Av kan du inte använda publiceringsprofiler, så välj På och sedan Spara.

3. Gå tillbaka till funktionsappens Översiktssida och välj sedan Hämta publiceringsprofil.

   

4. Spara och kopiera innehållet i filen.

Lägg till GitHub-hemligheten

1. Gå till din lagringsplats i GitHub.

2. Gå till inställningar.

3. Välj Hemligheter och variabler > Åtgärder.

4. Välj Ny lagringsplatshemlighet.

5. Lägg till en ny hemlighet med namnet AZURE_FUNCTIONAPP_PUBLISH_PROFILE och värdet inställt på innehållet i publiceringsprofilfilen.

6. Välj Add secret (Lägg till hemlighet).

GitHub kan nu autentisera till din funktionsapp i Azure.

Skapa arbetsflödet från en mall

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

1. Välj antingen Windows eller Linux för att se till att du får mallen för rätt operativsystem.

   Windows

   Distributioner till Windows använder runs-on: windows-latest.

   Linux

   Distributioner till Linux använder runs-on: ubuntu-latest.

2. Kopiera den språkspecifika mallen från Azure Functions-åtgärdslagringsplatsen med hjälp av följande länk:

   .NET

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/windows-dotnet-functionapp-on-azure.yml

   .NET

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/linux-dotnet-functionapp-on-azure.yml

   Java

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/windows-java-functionapp-on-azure.yml

   Java

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/linux-java-functionapp-on-azure.yml

   JavaScript

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/windows-node.js-functionapp-on-azure.yml

   JavaScript

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/linux-node.js-functionapp-on-azure.yml

   Python

   Python-funktioner stöds inte i Windows. Välj Linux i stället.

   Python

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/linux-python-functionapp-on-azure.yml

   PowerShell

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/windows-powershell-functionapp-on-azure.yml

   PowerShell

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/linux-powershell-functionapp-on-azure.yml

3. Uppdatera parametern env.AZURE_FUNCTIONAPP_NAME med namnet på funktionsappresursen i Azure. Du kan också behöva uppdatera parametern som anger språkversionen som används av din app, till exempel DOTNET_VERSION för C#.

4. Lägg till den här nya YAML-filen i /.github/workflows/ sökvägen i lagringsplatsen.

Skapa arbetsflödeskonfigurationen i portalen

När du använder portalen för att aktivera GitHub Actions skapar Functions en arbetsflödesfil baserat på programstacken och checkar in den på din GitHub-lagringsplats i rätt katalog.

Portalen hämtar automatiskt din publiceringsprofil och lägger till den i GitHub-hemligheterna för din lagringsplats.

Under funktionsappens skapande

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

1. I Azure Portal väljer du Distribution i flödet Skapa funktionsapp.

   

2. Aktivera kontinuerlig distribution om du vill att varje koduppdatering ska utlösa en kod push till Azure Portal.

3. Ange din GitHub-organisation, lagringsplats och gren.

   

4. Slutför konfigurationen av funktionsappen. GitHub-lagringsplatsen innehåller nu en ny arbetsflödesfil i /.github/workflows/.

För en befintlig funktionsapp

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

1. Gå till funktionsappen i Azure Portal och välj Distributionscenter.

2. För Källa väljer du GitHub. Om du inte ser standardmeddelandet Skapa med GitHub Actions väljer du Ändra provider , väljer GitHub Actions och väljer OK.

3. Om du inte redan har auktoriserad GitHub-åtkomst väljer du Auktorisera. Ange dina GitHub-autentiseringsuppgifter och välj Logga in. Om du vill auktorisera ett annat GitHub-konto väljer du Ändra konto och loggar in med ett annat konto.

4. Välj din GitHub-organisation, lagringsplats och gren. Om du vill distribuera med GitHub Actions måste du ha skrivåtkomst till den här lagringsplatsen.

5. I Autentiseringsinställningar väljer du om GitHub Actions ska autentiseras med en användartilldelad identitet eller använda grundläggande autentiseringsuppgifter . För grundläggande autentisering används de aktuella autentiseringsuppgifterna.

6. Välj Förhandsgranskningsfil för att se arbetsflödesfilen som läggs till i GitHub-lagringsplatsen i github/workflows/.

7. Välj Spara för att lägga till arbetsflödesfilen på lagringsplatsen.

Lägga till arbetsflödeskonfiguration på lagringsplatsen

Du kan använda az functionapp deployment github-actions add kommandot för att generera en arbetsflödeskonfigurationsfil från rätt mall för funktionsappen. Den nya YAML-filen lagras sedan på rätt plats (/.github/workflows/) på den GitHub-lagringsplats som du anger, medan publiceringsprofilfilen för din app läggs till i GitHub-hemligheter på samma lagringsplats.

1. Kör det här az functionapp kommandot och ersätt värdena githubUser/githubRepo, MyResourceGroupoch MyFunctionapp:

   az functionapp deployment github-actions add --repo "githubUser/githubRepo" -g MyResourceGroup -n MyFunctionapp --login-with-github
   

   Det här kommandot använder en interaktiv metod för att hämta en personlig åtkomsttoken för ditt GitHub-konto.

2. I terminalfönstret bör du se något som liknar följande meddelande:

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

3. Kopiera den unika XXXX-XXXX koden, bläddra till https://github.com/login/deviceoch ange den kod som du kopierade. När du har angett koden bör du se något som liknar följande meddelande:

   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
   

4. Gå till din GitHub-lagringsplats och välj Åtgärder. Kontrollera att arbetsflödet kördes.

Skapa arbetsflödeskonfigurationsfilen

Du kan skapa konfigurationsfilen för GitHub Actions-arbetsflödet från Azure Functions-mallarna direkt från din GitHub-lagringsplats.

1. Gå till din lagringsplats i GitHub.

2. Välj Åtgärder och Nytt arbetsflöde.

3. Sök efter funktioner.

   

4. I de funktionsapparbetsflöden som visas som skapats av Microsoft Azure letar du reda på det som matchar ditt kodspråk och väljer Konfigurera.

5. I den nyligen skapade YAML-filen uppdaterar du parametern env.AZURE_FUNCTIONAPP_NAME med namnet på funktionsappresursen i Azure. Du kan också behöva uppdatera parametern som anger språkversionen som används av din app, till exempel DOTNET_VERSION för C#.

6. Kontrollera att den nya arbetsflödesfilen sparas i /.github/workflows/ och välj Checka in ändringar....

Uppdatera en arbetsflödeskonfiguration

Om du av någon anledning behöver uppdatera eller ändra en befintlig arbetsflödeskonfiguration går du bara till platsen /.github/workflows/ på lagringsplatsen, öppnar den specifika YAML-filen, gör nödvändiga ändringar och genomför sedan uppdateringarna till lagringsplatsen.

Exempel: konfigurationsfil för arbetsflöde

I följande mallexempel används version 1 av functions-action och en publish profile för autentisering. Mallen beror på ditt valda språk och det operativsystem som funktionsappen distribueras på:

Windows

Om din funktionsapp körs på Linux väljer du Linux.

Linux

Om funktionsappen körs i Windows väljer du Windows.

.NET

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

.NET

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

Java

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

Java

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

JavaScript

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

JavaScript

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

Python

Python-funktioner stöds inte i Windows. Välj Linux i stället.

Python

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

PowerShell

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

PowerShell

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

Azure Functions-åtgärd

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

Parametrar

Följande parametrar krävs för alla funktionsappplaner:

Parameter	Förklaring
appnamn	Namnet på funktionsappen.
paket	Det här är platsen i projektet som ska publiceras. Som standard är det här värdet inställt på , vilket innebär att .alla filer och mappar på GitHub-lagringsplatsen kommer att distribueras.

Följande parametrar krävs för Flex Consumption-planen:

Parameter	Förklaring
Sku	Ange detta till flexconsumption när du autentiserar med publiceringsprofilen. När du använder RBAC-autentiseringsuppgifter eller distribuerar till en plan som inte är flexförbrukning kan åtgärden matcha värdet, så parametern behöver inte inkluderas.
fjärrbygge	Ange detta för true att aktivera en byggåtgärd från Kudu när paketet distribueras till en Flex Consumption-app. Oryx-versionen utförs alltid under en fjärrversion i Flex Consumption; ange inte scm-do-build-during-deployment eller enable-oryx-build. Som standard är den här parametern inställd på false.

Följande parametrar är specifika för förbruknings-, Elastic Premium- och App Service-planer (dedikerade):

Parameter	Förklaring
scm-do-build-during-deployment	(Valfritt) Tillåt att Kudu-platsen (t.ex. https://<APP_NAME>.scm.azurewebsites.net/) utför fördistributionsåtgärder, till exempel fjärrversioner. Som standard är detta inställt på false. Ange detta till true när du vill styra distributionsbeteenden med Kudu i stället för att matcha beroenden i ditt GitHub-arbetsflöde. Mer information finns i inställningen SCM_DO_BUILD_DURING_DEPLOYMENT .
enable-oryx-build	(Valfritt) Tillåt att Kudu-webbplatsen löser dina projektberoenden med Oryx. Som standard är detta inställt på false. Om du vill använda Oryx för att lösa dina beroenden i stället för GitHub-arbetsflödet anger du både scm-do-build-during-deployment och enable-oryx-build till true.

Valfria parametrar för alla funktionsappplaner:

Parameter	Förklaring
slot-name	Det här är namnet på distributionsfacket som ska distribueras till. Som standard är det här värdet tomt, vilket innebär att GitHub-åtgärden distribueras till din produktionsplats. När den här inställningen pekar på en icke-produktionsplats kontrollerar du att parametern publish-profile innehåller autentiseringsuppgifterna för facket i stället för produktionsplatsen. Stöds för närvarande inte i Flex Consumption.
publicera profil	Namnet på GitHub-hemligheten som innehåller din publiceringsprofil.
respect-pom-xml	Används endast för Java-funktioner. Om det krävs för att appens distributionsartefakt ska härledas från filen pom.xml. När du distribuerar Java-funktionsappar bör du ange den här parametern till true och inställd package på .. Som standard är den här parametern inställd på false, vilket innebär att parametern package måste peka på appens artefaktplats, till exempel ./target/azure-functions/
respect-funcignore	Om GitHub Actions respekterar .funcignore-filen för att undanta filer och mappar som definierats i den. Ange det här värdet till true när lagringsplatsen har en .funcignore-fil och du vill använda den för att exkludera sökvägar och filer, till exempel textredigerarens konfigurationer, .vscode/eller en virtuell Python-miljö (.venv/). Standardinställningen är false.

Att tänka på

Tänk på följande när du använder Azure Functions-åtgärden:

• När du använder GitHub Actions distribueras koden med hjälp av en distribution till appar i Flex Consumption-planen och zip-distribueras till appar enligt abonnemangen Förbrukning, Elastic Premium och Dedikerad (App Service). Undantaget är Linux-förbrukning, där extern paket-URL används.

• De autentiseringsuppgifter som krävs av GitHub för anslutning till Azure för distribution lagras som hemligheter i din GitHub-lagringsplats och används i distributionen som secrets.<SECRET_NAME>.

• Det enklaste sättet för GitHub Actions att autentisera med Azure Functions för distribution är genom att använda en publiceringsprofil. Du kan också autentisera med hjälp av ett huvudnamn för tjänsten. Mer information finns i den här GitHub Actions-lagringsplatsen.

• Åtgärderna för att konfigurera miljön och köra en version genereras från mallarna och är språkspecifika.

• Mallarna använder env element för att definiera inställningar som är unika för din version och distribution.

Nästa steg

Läs mer om Azure- och GitHub-integrering