Folyamatos teljesítés a GitHub Actions használatával

Egy GitHub Actions-munkafolyamat használatával definiálhat egy munkafolyamatot, amely automatikusan létrehoz és üzembe helyez kódokat a függvényalkalmazásban az Azure Functionsben.

A munkafolyamat-konfigurációt meghatározó YAML-fájl (.yml) megmarad az /.github/workflows/ adattár elérési útján. Ez a definíció tartalmazza a munkafolyamatot alkotó műveleteket és paramétereket, amelyek a függvények fejlesztési nyelvére vonatkoznak. A Függvényekhez készült GitHub Actions-munkafolyamat nyelvtől függetlenül a következő feladatokat hajtja végre:

1. Állítsa be a környezetet.
2. Hozza létre a kódprojektet.
3. Helyezze üzembe a csomagot egy függvényalkalmazásban az Azure-ban.

Az Azure Functions-művelet kezeli az Üzembe helyezést egy meglévő függvényalkalmazásban az Azure-ban.

Manuálisan is létrehozhat munkafolyamat-konfigurációs fájlt az üzembe helyezéshez. A fájlt nyelvspecifikus sablonok készletéből is létrehozhatja az alábbi módokon:

• Az Azure Portalon
• Az Azure CLI-vel
• A GitHub-adattárból

Ha nem szeretné kézzel létrehozni a YAML-fájlt, válasszon egy másik módszert a cikk tetején.

Előfeltételek

• Egy Azure-fiók, aktív előfizetéssel. Fiók ingyenes létrehozása.

• Egy GitHub-fiók. Ha nincs fiókja, ingyenesen regisztrálhat egyet.

• Az Azure-ban üzemeltetett működő függvényalkalmazás, amely egy GitHub-adattárban lévő forráskóddal rendelkezik.

• Azure CLI, helyi fejlesztéskor. Az Azure CLI-t az Azure Cloud Shellben is használhatja.

Üzembehelyezési hitelesítő adatok létrehozása

Mivel a GitHub Actions a közzétételi profillal fér hozzá a függvényalkalmazáshoz az üzembe helyezés során, először le kell kérnie a közzétételi profilt, és biztonságosan kell tárolnia GitHub-titkos kódként.

Fontos

A közzétételi profil egy értékes hitelesítő adat, amely lehetővé teszi az Azure-erőforrásokhoz való hozzáférést. Győződjön meg arról, hogy mindig biztonságosan szállítja és tárolja. A GitHubon a közzétételi profilt csak GitHub-titkos kulcsokban szabad tárolni.

A közzétételi profil letöltése

A függvényalkalmazás közzétételi profiljának letöltése:

1. Válassza a függvényalkalmazás Áttekintés lapját, majd válassza a Közzétételi profil lekérése lehetőséget.

   

2. Mentse és másolja a fájl tartalmát.

A GitHub titkos kódjának hozzáadása

1. A GitHubon nyissa meg az adattárat.

2. Ugrás a beállításokhoz .

3. Válassza a Titkos kódok és változók > műveletek lehetőséget.

4. Válassza az Új tárház titkos kódját.

5. Adjon hozzá egy új titkos kulcsot a közzétételi profilfájl tartalmának nevével AZURE_FUNCTIONAPP_PUBLISH_PROFILE és értékével.

6. Válassza az Add secret (Titkos kód hozzáadása) lehetőséget.

A GitHub mostantól hitelesítheti magát a függvényalkalmazásban az Azure-ban.

Munkafolyamat létrehozása sablonból

A munkafolyamat-konfiguráció manuális létrehozásának legjobb módja, ha a hivatalosan támogatott sablonból indul ki.

1. Válassza a Windows vagy a Linux lehetőséget, hogy biztosan megkapja a megfelelő operációs rendszer sablont.

   Windows

   Központi telepítések a Windowsban.runs-on: windows-latest

   Linux

   Üzembe helyezések Linuxon.runs-on: ubuntu-latest

2. Másolja ki a nyelvspecifikus sablont az Azure Functions actions-adattárból az alábbi hivatkozás használatával:

   .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

   A Python-függvények Windows rendszeren nem támogatottak. Válassza inkább a Linuxot.

   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. Frissítse a paramétert env.AZURE_FUNCTIONAPP_NAME a függvényalkalmazás-erőforrás nevével az Azure-ban. Előfordulhat, hogy frissítenie kell a paramétert, amely az alkalmazás által használt nyelvi verziót állítja be, például DOTNET_VERSION a C#-hoz.

4. Adja hozzá ezt az új YAML-fájlt az /.github/workflows/ adattár elérési útjához.

A munkafolyamat-konfiguráció létrehozása a portálon

Amikor a portálon engedélyezi a GitHub Actionst, a Functions létrehoz egy munkafolyamat-fájlt az alkalmazásverem alapján, és véglegesíti azt a GitHub-adattárban a megfelelő könyvtárban.

A portál automatikusan lekéri a közzétételi profilt, és hozzáadja az adattár GitHub-titkos kulcsaihoz.

A függvényalkalmazás létrehozása során

A GitHub Actions gyors használatbavételét az Üzembe helyezés lapon végezheti el, amikor függvényt hoz létre az Azure Portalon. GitHub Actions-munkafolyamat hozzáadása új függvényalkalmazás létrehozásakor:

1. Az Azure Portalon válassza az Üzembe helyezés lehetőséget a Függvényalkalmazás létrehozása folyamatban.

   

2. Engedélyezze a folyamatos üzembe helyezést , ha azt szeretné, hogy minden kódfrissítés kódküldést aktiváljon az Azure Portalra.

3. Adja meg a GitHub-szervezetet, az adattárat és az ágat.

   

4. Fejezze be a függvényalkalmazás konfigurálását. A GitHub-adattár mostantól tartalmaz egy új munkafolyamat-fájlt a /.github/workflows/.

Meglévő függvényalkalmazás esetén

GitHub Actions-munkafolyamat hozzáadása meglévő függvényalkalmazáshoz:

1. Lépjen a függvényalkalmazásra az Azure Portalon, és válassza az Üzembe helyezési központ lehetőséget.

2. Forráskéntválassza a GitHubot. Ha nem jelenik meg az alapértelmezett üzenet a GitHub Actions használatával, válassza a Szolgáltató módosítása lehetőséget, válassza a GitHub Actions lehetőséget, és válassza az OK gombot.

3. Ha még nem engedélyezte a GitHub-hozzáférést, válassza az Engedélyezés lehetőséget. Adja meg a GitHub hitelesítő adatait, és válassza a Bejelentkezés lehetőséget. Egy másik GitHub-fiók engedélyezéséhez válassza a Fiók módosítása lehetőséget, és jelentkezzen be egy másik fiókkal.

4. Válassza ki a GitHub-szervezetet, az adattárat és az ágat. A GitHub Actions használatával történő üzembe helyezéshez írási hozzáféréssel kell rendelkeznie ehhez az adattárhoz.

5. A hitelesítési beállításokban adja meg, hogy a GitHub Actions hitelesítése felhasználó által hozzárendelt identitással vagy egyszerű hitelesítési hitelesítő adatokkal történjen. Az alapszintű hitelesítéshez a rendszer az aktuális hitelesítő adatokat használja.

6. Válassza az Előnézet fájl lehetőséget a GitHub-adattárhoz hozzáadott munkafolyamat-fájl megtekintéséhez.github/workflows/

7. A Mentés gombra kattintva hozzáadhatja a munkafolyamat-fájlt az adattárhoz.

Munkafolyamat-konfiguráció hozzáadása az adattárhoz

A az functionapp deployment github-actions add parancs használatával munkafolyamat-konfigurációs fájlt hozhat létre a függvényalkalmazás megfelelő sablonjából. Az új YAML-fájlt ezután a rendszer a megfelelő helyen (/.github/workflows/) tárolja az Ön által megadott GitHub-adattárban, míg az alkalmazáshoz tartozó közzétételi profilfájl ugyanabban az adattárban lesz hozzáadva a GitHub titkos kulcsaihoz.

1. Futtassa ezt a az functionapp parancsot, és cserélje le a következő értékeketMyResourceGroupgithubUser/githubRepoMyFunctionapp:

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

   Ez a parancs interaktív módszerrel kéri le a Személyes hozzáférési jogkivonatot a GitHub-fiókhoz.

2. A terminálablakban az alábbihoz hasonló üzenetnek kell megjelennie:

   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. Másolja ki az egyedi XXXX-XXXX kódot, tallózással keresse meg https://github.com/login/device, és írja be a másolt kódot. A kód beírása után a következő üzenethez hasonló üzenetnek kell megjelennie:

   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. Nyissa meg a GitHub-adattárat, és válassza a Műveletek lehetőséget. Ellenőrizze, hogy futott-e a munkafolyamat.

A munkafolyamat konfigurációs fájljának létrehozása

A GitHub Actions munkafolyamat-konfigurációs fájlját közvetlenül a GitHub-adattárból hozhatja létre az Azure Functions-sablonokból.

1. A GitHubon nyissa meg az adattárat.

2. Válassza a Műveletek és az Új munkafolyamat lehetőséget.

3. Függvények keresése.

   

4. A Microsoft Azure által létrehozott megjelenített függvényalkalmazás-munkafolyamatokban keresse meg a kódnyelvnek megfelelőt, és válassza a Konfigurálás lehetőséget.

5. Az újonnan létrehozott YAML-fájlban frissítse a env.AZURE_FUNCTIONAPP_NAME paramétert az Azure-ban található függvényalkalmazás-erőforrás nevével. Előfordulhat, hogy frissítenie kell a paramétert, amely az alkalmazás által használt nyelvi verziót állítja be, például DOTNET_VERSION a C#-hoz.

6. Ellenőrizze, hogy az új munkafolyamat-fájl mentése /.github/workflows/ folyamatban van-e, és válassza a Módosítások véglegesítése...lehetőséget.

Munkafolyamat-konfiguráció frissítése

Ha valamilyen okból frissítenie vagy módosítania kell egy meglévő munkafolyamat-konfigurációt, csak keresse meg az /.github/workflows/ adattár helyét, nyissa meg az adott YAML-fájlt, végezze el a szükséges módosításokat, majd véglegesítse a frissítéseket az adattárban.

Példa: munkafolyamat konfigurációs fájlja

Az alábbi példasablon az 1. és a publish profile 1. verziót használja a functions-action hitelesítéshez. A sablon a választott nyelvtől és az operációs rendszertől függ, amelyre a függvényalkalmazás telepítve van:

Windows

Ha a függvényalkalmazás Linuxon fut, válassza a Linux lehetőséget.

Linux

Ha a függvényalkalmazás Windows rendszeren fut, válassza a Windows lehetőséget.

.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

A Python-függvények Windows rendszeren nem támogatottak. Válassza inkább a Linuxot.

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-művelet

Az Azure Functions-művelet (Azure/azure-functions) meghatározza, hogy a kód hogyan lesz közzétéve egy meglévő függvényalkalmazásban az Azure-ban, vagy az alkalmazás egy adott pontjára.

Paraméterek

A művelethez leggyakrabban a következő paramétereket használják:

Paraméter	Magyarázat
alkalmazás neve	(Kötelező) A függvényalkalmazás neve.
pont-név	(Nem kötelező) Annak az üzembehelyezési pontnak a neve, amelybe üzembe szeretne helyezni. A pontnak már léteznie kell a függvényalkalmazásban. Ha nincs megadva, a kód az aktív ponton lesz üzembe helyezve.
közzétételi profil	(Nem kötelező) A közzétételi profilt tartalmazó GitHub-titkos kód neve.

A következő paraméterek is támogatottak, de csak bizonyos esetekben használhatók:

Paraméter	Magyarázat
Csomag	(Nem kötelező) Beállít egy segédútmutatót az adattárban, amelyből közzé szeretné tenni. Alapértelmezés szerint ez az érték a következőre van állítva, ami azt jelenti, hogy .a GitHub-adattárban lévő összes fájl és mappa üzembe van helyezve.
respect-pom-xml	(Nem kötelező) Csak Java-függvényekhez használható. Szükség van-e az alkalmazás üzembehelyezési összetevőjének a pom.xml fájlból való származtatására. Java-függvényalkalmazások telepítésekor ezt a paramétert truepackage.a következőre kell beállítania: Ez a paraméter alapértelmezés szerint a következőre falsevan állítva, ami azt jelenti, hogy a package paraméternek az alkalmazás összetevőhelyére kell mutatnia, például ./target/azure-functions/
respect-funcignore	(Nem kötelező) Azt, hogy a GitHub Actions tiszteletben tartja-e a .funcignore fájlt, hogy kizárja-e a benne definiált fájlokat és mappákat. Állítsa be ezt az értéket true , ha az adattárban .funcignore fájl található, és azt szeretné használni, hogy kizárja az elérési utakat és fájlokat, például a szövegszerkesztő konfigurációit, a .vscode/- vagy a Python virtuális környezetet (.venv/). Az alapértelmezett beállítás: false.
scm-do-build-during-deployment	(Nem kötelező) Azt jelzi, hogy az App Service üzembehelyezési helye (Kudu) végrehajtja-e az előzetes üzembe helyezési műveleteket. A függvényalkalmazás üzembehelyezési helye a következő helyen https://<APP_NAME>.scm.azurewebsites.net/található: . Módosítsa ezt a beállítást arra az állapotra true , amikor a GitHub Actions munkafolyamat függőségeinek feloldása helyett a Kuduban kell vezérelnie az üzemelő példányokat. Az alapértelmezett érték false. További információ: SCM_DO_BUILD_DURING_DEPLOYMENT beállítás.
enable-oryx-build	(Nem kötelező) Azt jelzi, hogy a Kudu üzembehelyezési helye feloldja-e a projektfüggőségeket az Oryx használatával. Állítsa be, true hogy mikor szeretné az Oryx használatával megoldani a projektfüggőségeket a GitHub Actions munkafolyamat helyett egy távoli build használatával. Ha true, akkor is be kell állítania scm-do-build-during-deployment .true Az alapértelmezett érték false.

Megfontolások

Tartsa szem előtt az alábbi szempontokat az Azure Functions-művelet használatakor:

• A GitHub Actions használatakor a kód üzembe lesz helyezve a függvényalkalmazásban az Azure Functions Zip-üzembe helyezésével.

• A GitHub által az Azure-hoz való üzembe helyezéshez szükséges hitelesítő adatok titkos kulcsként vannak tárolva a GitHub-adattárban, és az üzembe helyezésben a következőképpen secrets.<SECRET_NAME>érhetők el.

• A GitHub Actions legegyszerűbben egy közzétételi profil használatával hitelesíthető az Azure Functions használatával. A hitelesítés szolgáltatásnévvel is lehetővé teszi a hitelesítést. További információkért tekintse meg ezt a GitHub Actions-adattárat.

• A környezet beállítására és a build futtatására szolgáló műveletek a sablonokból jönnek létre, és nyelvspecifikusak.

• A sablonok elemeket használnak env a build és az üzembe helyezés egyedi beállításainak meghatározásához.

Következő lépések

További információ az Azure és a GitHub integrációjáról