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

Cikk
2024. 10. 31.

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:

Állítsa be a környezetet.
Hozza létre a kódprojektet.
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:

Az Azure Portalon keresse meg a függvényalkalmazás lapját, és bontsa ki a Beállítások>konfigurációja lehetőséget a bal oldali oszlopban.
A Konfiguráció lapon válassza az Általános beállítások lapot, és győződjön meg arról, hogy be van kapcsolva az SCM alapszintű hitelesítés-közzétételi hitelesítő adatai. Ha ez a beállítás ki van kapcsolva, nem használhat közzétételi profilokat, ezért válassza a Be , majd a Mentés lehetőséget.
Lépjen vissza a függvényalkalmazás Áttekintés lapjára, majd válassza a Közzétételi profil lekérése lehetőséget.
Mentse és másolja a fájl tartalmát.

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

A GitHubon nyissa meg az adattárat.
Ugrás a beállításokhoz .
Válassza a Titkos kódok és változók > műveletek lehetőséget.
Válassza az Új tárház titkos kódját.
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.
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.

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:

Az Azure Portalon válassza az Üzembe helyezés lehetőséget a Függvényalkalmazás létrehozása folyamatban.
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.
Adja meg a GitHub-szervezetet, az adattárat és az ágat.
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:

Lépjen a függvényalkalmazásra az Azure Portalon, és válassza az Üzembe helyezési központ lehetőséget.
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.
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.
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.
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.
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/
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.

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

Azure CLI
```
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.

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

Output

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

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:

Output

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

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.

A GitHubon nyissa meg az adattárat.
Válassza a Műveletek és az Új munkafolyamat lehetőséget.
Függvények keresése.
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.
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.
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
Linux

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

yml

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

yml

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

yml

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

yml

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

yml

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

yml

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

yml

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

yml

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

yml

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

Az összes függvényalkalmazás-csomaghoz a következő paraméterek szükségesek:

Paraméter	Magyarázat
alkalmazás neve	A függvényalkalmazás neve.
csomag	Ez a közzéteendő hely a projektben. 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 lesz helyezve.

A Rugalmas kihasználtság csomaghoz a következő paraméterek szükségesek:

Paraméter Magyarázat

Sku Ezt állítsa be a flexconsumption közzétételi profil hitelesítésekor. RBAC-hitelesítő adatok használatakor vagy nem Flex-használatú csomagban való üzembe helyezéskor a művelet feloldhatja az értéket, így a paramétert nem kell belefoglalni.

távoli build Ezt úgy állíthatja be, hogy true engedélyezze a Kudu buildelési műveletét, amikor a csomag egy Flex Consumption-alkalmazásban van üzembe helyezve. Az Oryx buildelése mindig egy távoli build során történik a Flex Consumptionben; ne állítsa be az scm-do-build-during-deployment vagy enable-oryx-build értéket. Ez a paraméter alapértelmezés szerint a következőre falsevan állítva: .

Paraméter	Magyarázat
Sku	Ezt állítsa be a `flexconsumption` közzétételi profil hitelesítésekor. RBAC-hitelesítő adatok használatakor vagy nem Flex-használatú csomagban való üzembe helyezéskor a művelet feloldhatja az értéket, így a paramétert nem kell belefoglalni.
távoli build	Ezt úgy állíthatja be, hogy `true` engedélyezze a Kudu buildelési műveletét, amikor a csomag egy Flex Consumption-alkalmazásban van üzembe helyezve. Az Oryx buildelése mindig egy távoli build során történik a Flex Consumptionben; ne állítsa be az scm-do-build-during-deployment vagy enable-oryx-build értéket. Ez a paraméter alapértelmezés szerint a következőre `false`van állítva: .

A következő paraméterek a Használat, az Elastic Premium és az App Service (Dedikált) csomagokra vonatkoznak:

Paraméter Magyarázat

scm-do-build-during-deployment (Nem kötelező) Engedélyezze a Kudu-helynek (például https://<APP_NAME>.scm.azurewebsites.net/) az üzembe helyezés előtti műveleteket, például a távoli buildeket. Alapértelmezés szerint ez a beállítás a következőre falsevan állítva: . Ezt akkor true állítsa be, ha a GitHub-munkafolyamat függőségeinek feloldása helyett a Kudu használatával szeretné szabályozni az üzembe helyezési viselkedést. További információkért lásd a SCM_DO_BUILD_DURING_DEPLOYMENT beállítást.

enable-oryx-build (Nem kötelező) A Kudu-webhely feloldhatja a projektfüggőségeket az Oryx használatával. Alapértelmezés szerint ez a beállítás a következőre falsevan állítva: . Ha az Oryx használatával szeretné feloldani a függőségeket a GitHub-munkafolyamat helyett, állítsa be az scm-do-build-during-deployment és az enable-oryx-build true értéket.

Paraméter	Magyarázat
scm-do-build-during-deployment	(Nem kötelező) Engedélyezze a Kudu-helynek (például `https://<APP_NAME>.scm.azurewebsites.net/`) az üzembe helyezés előtti műveleteket, például a távoli buildeket. Alapértelmezés szerint ez a beállítás a következőre `false`van állítva: . Ezt akkor `true` állítsa be, ha a GitHub-munkafolyamat függőségeinek feloldása helyett a Kudu használatával szeretné szabályozni az üzembe helyezési viselkedést. További információkért lásd a `SCM_DO_BUILD_DURING_DEPLOYMENT` beállítást.
enable-oryx-build	(Nem kötelező) A Kudu-webhely feloldhatja a projektfüggőségeket az Oryx használatával. Alapértelmezés szerint ez a beállítás a következőre `false`van állítva: . Ha az Oryx használatával szeretné feloldani a függőségeket a GitHub-munkafolyamat helyett, állítsa be az scm-do-build-during-deployment és az enable-oryx-build `true` értéket.

Az összes függvényalkalmazás-csomag választható paraméterei:

Paraméter	Magyarázat
pont-név	Ez az üzembe helyezési pont neve. Alapértelmezés szerint ez az érték üres, ami azt jelenti, hogy a GitHub-művelet üzembe lesz helyezve az éles helyen. Ha ez a beállítás egy nem éles pontra mutat, győződjön meg arról, hogy a közzétételi profil paraméter az éles hely helyett a pont hitelesítő adatait tartalmazza. A Rugalmas használat jelenleg nem támogatott.
közzétételi profil	A közzétételi profilt tartalmazó GitHub-titkos kód neve.
respect-pom-xml	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 `false`van á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	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`.

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 helyezése egyetlen üzembe helyezéssel történik a Rugalmas használat csomag alkalmazásaiban, a zip-üzembe helyezés pedig a Használat, Az Elastic Premium és a Dedikált (App Service) csomagokban futó alkalmazásokban. Kivételt képez a Linux-használat, ahol külső csomag URL-címét használják.
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

Megosztás a következőn keresztül: