Průběžné doručování pomocí GitHub Actions

Pracovní postup GitHub Actions můžete použít k definování pracovního postupu, který automaticky sestaví a nasadí kód do aplikace funkcí ve službě Azure Functions.

Soubor YAML (.yml), který definuje konfiguraci pracovního postupu, se udržuje v /.github/workflows/ cestě ve vašem úložišti. Tato definice obsahuje akce a parametry, které tvoří pracovní postup, který je specifický pro vývojový jazyk vašich funkcí. Pracovní postup GitHub Actions pro funkce provádí následující úlohy bez ohledu na jazyk:

1. Nastavte prostředí.
2. Sestavte projekt kódu.
3. Nasaďte balíček do aplikace funkcí v Azure.

Akce Azure Functions zpracovává nasazení do existující aplikace funkcí v Azure.

Konfigurační soubor pracovního postupu pro nasazení můžete vytvořit ručně. Soubor můžete také vygenerovat ze sady šablon specifických pro jazyk jedním z těchto způsobů:

• Na webu Azure Portal
• Použití Azure CLI
• Z úložiště GitHub

Pokud soubor YAML nechcete vytvořit ručně, vyberte v horní části článku jinou metodu.

Požadavky

• Účet Azure s aktivním předplatným. Vytvoření účtu zdarma

• Účet GitHub. Pokud ho nemáte, zdarma se zaregistrujte.

• Funkční aplikace funkcí hostovaná v Azure se zdrojovým kódem v úložišti GitHub.

• Azure CLI při místním vývoji Azure CLI můžete použít také v Azure Cloud Shellu.

Generování přihlašovacích údajů pro nasazení

Vzhledem k tomu, že GitHub Actions používá váš profil publikování pro přístup k aplikaci funkcí během nasazování, musíte nejprve získat svůj profil publikování a bezpečně ho uložit jako tajný klíč GitHubu.

Důležité

Profil publikování je cenné přihlašovací údaje, které umožňují přístup k prostředkům Azure. Ujistěte se, že je vždy přepravujete a bezpečně ukládáte. V GitHubu musí být profil publikování uložený jenom v tajných klíčích GitHubu.

Stažení profilu publikování

Stažení profilu publikování aplikace funkcí:

1. Na webu Azure Portal vyhledejte stránku vaší aplikace funkcí a v levém sloupci rozbalte položku Konfigurace nastavení>.

2. Na stránce Konfigurace vyberte kartu Obecné nastavení a ujistěte se, že je zapnuté přihlašovací údaje pro základní ověřování ověřování SCM. Pokud je toto nastavení vypnuté, nemůžete použít profily publikování, takže vyberte Zapnuto a pak Uložit.

3. Vraťte se na stránku Přehled aplikace funkcí a pak vyberte Získat profil publikování.

   

4. Uložte a zkopírujte obsah souboru.

Přidání tajného kódu GitHubu

1. Na GitHubu přejděte do svého úložiště.

2. Přejděte na Nastavení.

3. Vyberte Akce tajných kódů a proměnných>.

4. Vyberte Nový tajný klíč úložiště.

5. Přidejte nový tajný klíč s názvem AZURE_FUNCTIONAPP_PUBLISH_PROFILE a hodnotou nastavenou na obsah souboru profilu publikování.

6. Vyberte Add secret (Přidat tajný kód).

GitHub se teď může ověřit ve vaší aplikaci funkcí v Azure.

Vytvoření pracovního postupu ze šablony

Nejlepší způsob, jak ručně vytvořit konfiguraci pracovního postupu, je začít ze oficiálně podporované šablony.

1. Zvolte Windows nebo Linux, abyste měli jistotu, že jste získali šablonu pro správný operační systém.

   Windows

   Nasazení do Systému Windows používají runs-on: windows-latest.

   Linux

   Nasazení do Linuxu používají runs-on: ubuntu-latest.

2. Zkopírujte šablonu specifickou pro jazyk z úložiště akcí Azure Functions pomocí následujícího odkazu:

   .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

   Funkce Pythonu nejsou ve Windows podporované. Místo toho zvolte Linux.

   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. env.AZURE_FUNCTIONAPP_NAME Aktualizujte parametr názvem prostředku vaší aplikace funkcí v Azure. Volitelně můžete potřebovat aktualizovat parametr, který nastaví jazykovou verzi používanou vaší aplikací, například DOTNET_VERSION pro jazyk C#.

4. Přidejte tento nový soubor YAML do /.github/workflows/ cesty v úložišti.

Vytvoření konfigurace pracovního postupu na portálu

Když pomocí portálu povolíte GitHub Actions, Functions vytvoří soubor pracovního postupu na základě zásobníku vaší aplikace a potvrdí ho do vašeho úložiště GitHub ve správném adresáři.

Portál automaticky získá váš profil publikování a přidá ho do tajných kódů GitHubu pro vaše úložiště.

Vytvoření aplikace funkcí

S GitHub Actions můžete rychle začít pracovat prostřednictvím karty Nasazení při vytváření funkce na webu Azure Portal. Přidání pracovního postupu GitHub Actions při vytváření nové aplikace funkcí:

1. Na webu Azure Portal vyberte Nasazení v toku Vytvořit aplikaci funkcí.

   

2. Pokud chcete, aby každá aktualizace kódu aktivovala nabízení kódu na webu Azure Portal, povolte průběžné nasazování .

3. Zadejte svoji organizaci, úložiště a větev GitHubu.

   

4. Dokončete konfiguraci aplikace funkcí. Vaše úložiště GitHub teď obsahuje nový soubor pracovního postupu v /.github/workflows/souboru .

Pro existující aplikaci funkcí

Přidání pracovního postupu GitHub Actions do existující aplikace funkcí:

1. Přejděte do aplikace funkcí na webu Azure Portal a vyberte Deployment Center.

2. Jako zdroj vyberte GitHub. Pokud se nezobrazuje výchozí zpráva Sestavení pomocí GitHub Actions, vyberte Změnit zprostředkovatele GitHub Actions a vyberte OK.

3. Pokud jste ještě neověřili přístup k GitHubu, vyberte Autorizovat. Zadejte svoje přihlašovací údaje GitHubu a vyberte Přihlásit se. Pokud chcete autorizovat jiný účet GitHubu, vyberte Změnit účet a přihlaste se pomocí jiného účtu.

4. Vyberte svoji organizaci, úložiště a větev GitHubu. Pokud chcete provést nasazení pomocí GitHub Actions, musíte mít k tomuto úložišti přístup pro zápis.

5. V nastavení ověřování zvolte, jestli se má GitHub Actions ověřovat pomocí identity přiřazené uživatelem nebo pomocí přihlašovacích údajů základního ověřování. Pro základní ověřování se použijí aktuální přihlašovací údaje.

6. Výběrem možnosti Náhled zobrazíte soubor pracovního postupu, který se přidá do úložiště GitHub v github/workflows/.

7. Vyberte Uložit a přidejte soubor pracovního postupu do úložiště.

Přidání konfigurace pracovního postupu do úložiště

Pomocí příkazu můžete az functionapp deployment github-actions add vygenerovat konfigurační soubor pracovního postupu ze správné šablony pro vaši aplikaci funkcí. Nový soubor YAML se pak uloží do správného umístění (/.github/workflows/) v úložišti GitHub, které zadáte, zatímco soubor profilu publikování pro vaši aplikaci se přidá do tajných kódů GitHubu ve stejném úložišti.

1. Spusťte tento az functionapp příkaz, nahraďte hodnoty githubUser/githubRepoa MyResourceGroupMyFunctionapp:

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

   Tento příkaz používá interaktivní metodu k načtení tokenu pat pro váš účet GitHubu.

2. V okně terminálu by se mělo zobrazit něco jako následující zpráva:

   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. Zkopírujte jedinečný XXXX-XXXX kód, přejděte na https://github.com/login/devicea zadejte kód, který jste zkopírovali. Po zadání kódu by se mělo zobrazit něco jako následující zpráva:

   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. Přejděte do úložiště GitHub a vyberte Akce. Ověřte, že váš pracovní postup běžel.

Vytvoření konfiguračního souboru pracovního postupu

Konfigurační soubor pracovního postupu GitHub Actions můžete vytvořit ze šablon Azure Functions přímo z úložiště GitHub.

1. Na GitHubu přejděte do svého úložiště.

2. Vyberte Akce a Nový pracovní postup.

3. Vyhledejte funkce.

   

4. V pracovních postupech zobrazených aplikací funkcí vytvořených v Microsoft Azure najděte ten, který odpovídá vašemu jazyku kódu, a vyberte Konfigurovat.

5. V nově vytvořeném souboru YAML aktualizujte env.AZURE_FUNCTIONAPP_NAME parametr názvem prostředku vaší aplikace funkcí v Azure. Volitelně můžete potřebovat aktualizovat parametr, který nastaví jazykovou verzi používanou vaší aplikací, například DOTNET_VERSION pro jazyk C#.

6. Ověřte, že se nový soubor pracovního postupu ukládá, /.github/workflows/ a vyberte Potvrdit změny....

Aktualizace konfigurace pracovního postupu

Pokud z nějakého důvodu potřebujete aktualizovat nebo změnit existující konfiguraci pracovního postupu, jednoduše přejděte do /.github/workflows/ umístění ve vašem úložišti, otevřete konkrétní soubor YAML, proveďte potřebné změny a potvrďte aktualizace do úložiště.

Příklad: konfigurační soubor pracovního postupu

Následující příklad šablony používá verzi 1 functions-action a pro publish profile ověřování. Šablona závisí na zvoleném jazyce a operačním systému, na kterém je vaše aplikace funkcí nasazená:

Windows

Pokud vaše aplikace funkcí běží v Linuxu, vyberte Linux.

Linux

Pokud vaše aplikace funkcí běží ve Windows, vyberte 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

Funkce Pythonu nejsou ve Windows podporované. Místo toho zvolte Linux.

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

Akce Azure Functions

Akce Azure Functions (Azure/azure-functions) definuje, jak se váš kód publikuje do existující aplikace funkcí v Azure nebo do konkrétního slotu v aplikaci.

Parametry

Pro všechny plány aplikace funkcí jsou vyžadovány následující parametry:

Parametr	Vysvětlení
název aplikace	Název vaší aplikace funkcí.
balíček	Toto je umístění v projektu, které se má publikovat. Ve výchozím nastavení je tato hodnota nastavená na ., což znamená, že se nasadí všechny soubory a složky v úložišti GitHub.

Pro plán Flex Consumption jsou vyžadovány následující parametry:

Parametr	Vysvětlení
sku	Tuto možnost nastavte při flexconsumption ověřování pomocí profilu publikování. Pokud používáte přihlašovací údaje RBAC nebo nasazujete do jiného plánu než Flex Consumption, akce dokáže tuto hodnotu vyřešit, takže parametr nemusí být zahrnutý.
vzdálené sestavení	Nastavte na to, aby true se při nasazení balíčku do aplikace Flex Consumption povolila akce sestavení z Kudu. Sestavení Oryx se vždy provádí během vzdáleného sestavení ve funkci Flex Consumption; nenastavujte scm-do-build-during-deployment nebo enable-oryx-build. Ve výchozím nastavení je tento parametr nastaven na false.

Následující parametry jsou specifické pro plány Consumption, Elastic Premium a App Service (Dedicated):

Parametr	Vysvětlení
scm-do-build-during-deployment	(Volitelné) Umožňuje webu Kudu (např. https://<APP_NAME>.scm.azurewebsites.net/) provádět operace před nasazením, jako jsou vzdálené sestavení. Ve výchozím nastavení je tato možnost nastavena na falsehodnotu . Tuto možnost nastavte, true když chcete řídit chování nasazení pomocí Kudu místo překladu závislostí v pracovním postupu GitHubu. Další informace najdete v SCM_DO_BUILD_DURING_DEPLOYMENT nastavení.
enable-oryx-build	(Volitelné) Povolte webu Kudu přeložit závislosti projektu pomocí Oryxu. Ve výchozím nastavení je tato možnost nastavena na falsehodnotu . Pokud chcete použít Oryx k vyřešení závislostí místo pracovního postupu GitHubu, nastavte scm-do-build-during-deployment a enable-oryx-build na true.

Volitelné parametry pro všechny plány aplikace funkcí:

Parametr	Vysvětlení
název slotu	Toto je název slotu nasazení, do které se má nasadit. Ve výchozím nastavení je tato hodnota prázdná, což znamená, že akce GitHubu se nasadí do produkčního webu. Pokud toto nastavení odkazuje na neprodukční slot, ujistěte se, že parametr profilu publikování obsahuje přihlašovací údaje pro slot místo produkční lokality. V současné době není v flex consumption podporováno.
publish-profile	Název tajného kódu GitHubu, který obsahuje váš profil publikování.
respect-pom-xml	Používá se jenom pro funkce v Javě. Jestli se vyžaduje, aby artefakt nasazení vaší aplikace byl odvozen z pom.xml souboru. Při nasazování aplikací funkcí v Javě byste měli tento parametr nastavit na true hodnotu a nastavit package na .hodnotu . Ve výchozím nastavení je tento parametr nastavený na falsehodnotu , což znamená, že package parametr musí odkazovat na umístění artefaktů vaší aplikace, například ./target/azure-functions/
respect-funcignore	Jestli GitHub Actions respektuje váš soubor .funcignore, aby se vyloučily soubory a složky definované v něm. Tuto hodnotu nastavte, pokud true má úložiště soubor .funcignore a chcete ji použít k vyloučení cest a souborů, jako jsou konfigurace textového editoru, .vscode/nebo virtuální prostředí Pythonu (.venv/). Výchozí nastavení je false.

Důležité informace

Při použití akce Azure Functions mějte na paměti následující skutečnosti:

• Při použití GitHub Actions se kód nasadí pomocí jednoho nasazení do aplikací v plánu Flex Consumption a nasazení zip do aplikací v plánech Consumption, Elastic Premium a Dedicated (App Service). Výjimkou je Využití Linuxu, kde se používá adresa URL externího balíčku.

• Přihlašovací údaje vyžadované GitHubem pro připojení k Azure pro nasazení se ukládají jako tajné kódy ve vašem úložišti GitHub a přistupují secrets.<SECRET_NAME>k němu jako .

• Nejjednodušší způsob, jak gitHub Actions ověřit pomocí Azure Functions pro nasazení, je použití profilu publikování. Můžete se také ověřit pomocí instančního objektu. Další informace najdete v tomto úložišti GitHub Actions.

• Akce pro nastavení prostředí a spuštění sestavení se generují ze šablon a jsou specifické pro jazyk.

• Šablony používají env prvky k definování nastavení jedinečných pro sestavení a nasazení.

Další kroky

Další informace o integraci Azure a GitHubu