Folyamatos teljesítés 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 a Azure Functions.

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 Functions GitHub Actions munkafolyamata a következő feladatokat hajtja végre, nyelvtől függetlenül:

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

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

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:

A Azure portálon
Az Azure CLI használata
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

Aktív előfizetéssel rendelkező Azure fiók. Hozzon létre egy fiókot ingyenesen.
Egy GitHub fiók. Ha nincs fiókja, ingyenesen regisztrálhat egyet.
Egy Azure üzemeltetett működő függvényalkalmazás, amely egy GitHub-adattár forráskódjával rendelkezik.

Azure CLI, helyi fejlesztés esetén. Az Azure Cloud Shellben az Azure CLI-t is használhatja.

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

Mivel 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 szereznie 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 Azure erőforrások elérését. Győződjön meg arról, hogy mindig biztonságosan szállítja és tárolja. A GitHubban a közzétételi profilt csak GitHub titkokban 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éséhez:

A Azure portálon keresse meg a függvényalkalmazás lapját, és bontsa ki a Beállítások>Konfiguráció menüpontot 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 az Alkalmaz lehetőséget.
Lépjen vissza a függvényalkalmazás Áttekintés lapjára, majd válassza ki 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ód hozzáadása

A(z) GitHub-ban lépjen az adattárába.
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.

GitHub mostantól képes hitelesíteni a függvényalkalmazásodra az Azure-on.

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ál használatával engedélyezi a GitHub Actions, a Functions létrehoz egy munkafolyamat-fájlt az alkalmazásverem alapján, és véglegesíti azt a megfelelő könyvtárban lévő GitHub adattárba.

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

Ha Azure portálon hoz létre függvényt, gyorsan megkezdheti a GitHub Actions használatát az Üzembe helyezés lapon. GitHub Actions munkafolyamat hozzáadása új függvényalkalmazás létrehozásakor:

A Azure portálon válassza a Deployment lehetőséget a 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 Azure portálra.
Adja meg a GitHub szervezetét, adattárát és ágát.
Fejezze be a függvényalkalmazás konfigurálását. A GitHub-adattár mostantól tartalmaz egy új munkafolyamat-fájlt /.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 a Azure portálon és válassza a Deployment Center lehetőséget.
Source válassza a GitHub lehetőséget. Ha nem látja az alapértelmezett üzenetet Építés GitHub Actions-szel, válassza a Szolgáltató módosítása lehetőséget, válassza a GitHub Actions-t, majd kattintson az OK gombra.
Ha még nem engedélyezte GitHub hozzáférést, válassza a Authorize lehetőséget. Adja meg a GitHub hitelesítő adatait, és válassza a Sign in lehetőséget. 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 Organization, Repository és Branch. Az GitHub Actions való üzembe helyezéshez írási hozzáféréssel kell rendelkeznie ehhez az adattárhoz.
A Hitelesítési beállításokban válassza ki, hogy GitHub Actions hitelesítést szeretne-e Felhasználó által hozzárendelt identitással vagy Basic hitelesítés hitelesítő adatokkal. Az alapszintű hitelesítéshez a rendszer az aktuális hitelesítő adatokat használja.
Válassza a Előtekintő fájl lehetőséget a github/workflows/ GitHub tárházához hozzáadott munkafolyamat-fájl megtekintéséhez.
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 tárházban, míg az alkalmazáshoz tartozó közzétételi profilfájlt hozzáadja GitHub titkos kulcsokhoz ugyanabban az adattárban.

Futtassa ezt a az functionapp parancsot, és cserélje le a következő értékeketgithubUser/githubRepoMyResourceGroupMyFunctionapp:
```
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 GitHub-fiókjához tartozó személyes hozzáférési jogkivonatot.

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.

Másolja ki az egyedi XXXX-XXXX kódot, 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

Nyissa meg a GitHub adattárat, és válassza a Actions 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ájlt közvetlenül a GitHub-adattárból hozhatja létre a Azure Functions-sablonokból.

A(z) GitHub-ban lépjen az adattárába.
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 Configure lehetőséget.
Az újonnan létrehozott YAML-fájlban frissítse a env.AZURE_FUNCTIONAPP_NAME paramétert 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.
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 a functions-action és a publish profile 1. verzióját használja 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 Linuxon fut, válassza a Linux lehetőséget.

name: Deploy DotNet project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  DOTNET_VERSION: '6.0.x'                   # set this to the dotnet version to use (e.g. '2.1.x', '3.1.x', '5.0.x')

jobs:
  build-and-deploy:
    runs-on: windows-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup DotNet ${{ env.DOTNET_VERSION }} Environment
      uses: actions/setup-dotnet@v3
      with:
        dotnet-version: ${{ env.DOTNET_VERSION }}

    - name: 'Resolve Project Dependencies Using Dotnet'
      shell: pwsh
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        dotnet build --configuration Release --output ./output
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: '${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}/output'
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy DotNet project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  DOTNET_VERSION: '6.0.x'                   # set this to the dotnet version to use (e.g. '2.1.x', '3.1.x', '5.0.x')

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup DotNet ${{ env.DOTNET_VERSION }} Environment
      uses: actions/setup-dotnet@v3
      with:
        dotnet-version: ${{ env.DOTNET_VERSION }}

    - name: 'Resolve Project Dependencies Using Dotnet'
      shell: bash
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        dotnet build --configuration Release --output ./output
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: '${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}/output'
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy Java project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  POM_XML_DIRECTORY: '.'                    # set this to the directory which contains pom.xml file
  JAVA_VERSION: '8'                         # set this to the java version to use (e.g. '8', '11', '17')

jobs:
  build-and-deploy:
    runs-on: windows-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup Java Sdk ${{ env.JAVA_VERSION }}
      uses: actions/setup-java@v1
      with:
        java-version: ${{ env.JAVA_VERSION }}

    - name: 'Restore Project Dependencies Using Mvn'
      shell: pwsh
      run: |
        pushd './${{ env.POM_XML_DIRECTORY }}'
        mvn clean package
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: '${{ env.POM_XML_DIRECTORY }}' # if there are multiple function apps in same project, then this path will be like './${{ env.POM_XML_DIRECTORY }}/target/azure-functions/${{ env.POM_FUNCTIONAPP_NAME }'
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}
        respect-pom-xml: true

name: Deploy Java project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  POM_XML_DIRECTORY: '.'                    # set this to the directory which contains pom.xml file
  JAVA_VERSION: '8'                         # set this to the java version to use (e.g. '8', '11', '17')

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup Java Sdk ${{ env.JAVA_VERSION }}
      uses: actions/setup-java@v1
      with:
        java-version: ${{ env.JAVA_VERSION }}

    - name: 'Restore Project Dependencies Using Mvn'
      shell: bash
      run: |
        pushd './${{ env.POM_XML_DIRECTORY }}'
        mvn clean package
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: '${{ env.POM_XML_DIRECTORY }}' # if there are multiple function apps in same project, then this path will be like './${{ env.POM_XML_DIRECTORY }}/target/azure-functions/${{ env.POM_FUNCTIONAPP_NAME }'
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}
        respect-pom-xml: true

name: Deploy Node.js project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  NODE_VERSION: '16.x'                      # set this to the node version to use (e.g. '8.x', '10.x', '12.x')

jobs:
  build-and-deploy:
    runs-on: windows-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup Node ${{ env.NODE_VERSION }} Environment
      uses: actions/setup-node@v3
      with:
        node-version: ${{ env.NODE_VERSION }}

    - name: 'Resolve Project Dependencies Using Npm'
      shell: pwsh
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        npm install
        npm run build --if-present
        npm run test --if-present
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy Node.js project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  NODE_VERSION: '16.x'                      # set this to the node version to use (e.g. '8.x', '10.x', '12.x')

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup Node ${{ env.NODE_VERSION }} Environment
      uses: actions/setup-node@v3
      with:
        node-version: ${{ env.NODE_VERSION }}

    - name: 'Resolve Project Dependencies Using Npm'
      shell: bash
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        npm install
        npm run build --if-present
        npm run test --if-present
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy Python project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  PYTHON_VERSION: '3.9'                     # set this to the python version to use (e.g. '3.6', '3.7', '3.8')

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup Python ${{ env.PYTHON_VERSION }} Environment
      uses: actions/setup-python@v4
      with:
        python-version: ${{ env.PYTHON_VERSION }}

    - name: 'Resolve Project Dependencies Using Pip'
      shell: bash
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        python -m pip install --upgrade pip
        pip install -r requirements.txt --target=".python_packages/lib/site-packages"
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}
        scm-do-build-during-deployment: true
        enable-oryx-build: true

name: Deploy PowerShell project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root

jobs:
  build-and-deploy:
    runs-on: windows-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy PowerShell project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

Azure Functions művelet

A Azure Functions művelet (Azure/functions-action) meghatározza, hogy a kód hogyan lesz közzétéve egy meglévő függvényalkalmazásban Azure, 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 `.` értékre van állítva, ami azt jelenti, hogy az GitHub adattár összes fájlja és mappája üzembe lesz helyezve.

A Rugalmas fogyasztási csomaghoz a következő paraméterek szükségesek:

Paraméter	Magyarázat
SKU	Ezt állítsa `flexconsumption` értékre közzétételi profil hitelesítésekor. RBAC-hitelesítő adatok használatakor, vagy ha egy nem Flex-fogyasztási csomagra történik a telepítés, a művelet feloldja az értéket, ezért a paramétert nem szükséges belefoglalni.
távoli építés	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 építése mindig egy távoli build során történik a Flex Consumption keretében; ne adja meg az scm-do-build-during-deployment vagy az enable-oryx-build értéket. Ez a paraméter alapértelmezés szerint `false`.

A következő paraméterek a Használat, az Elastic Prémium é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 építéseket. Alapértelmezés szerint ez a beállítás a következőre falsevan állítva: . Ezt akkor állítsa be true értékre, 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 Oryx használatával szeretné feloldani a függőségeket a GitHub munkafolyamat helyett, állítsa be a scm-do-build-during-deployment és enable-oryx-buildtrue értékre.

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 építéseket. Alapértelmezés szerint ez a beállítás a következőre `false`van állítva: . Ezt akkor állítsa be `true` értékre, 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 Oryx használatával szeretné feloldani a függőségeket a GitHub munkafolyamat helyett, állítsa be a scm-do-build-during-deployment és enable-oryx-build`true` értékre.

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

Paraméter	Magyarázat
pont-név	Ez az üzembe helyezési hely neve, ahová üzembe kell helyezni. 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. Jelenleg nem támogatott a Flex fogyasztás.
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 `true` értékre kell állítania, és `package.` értékre kell állítania. Ez a paraméter alapértelmezés szerint `false` van állítva, ami azt jelenti, hogy a `package` paraméternek az alkalmazás artifakt-helyére kell mutatnia, például `./target/azure-functions/`.
respect-funcignore	Azt, hogy GitHub Actions tiszteletben tartja-e a .funcignore fájlt, hogy kizárja-e a benne definiált fájlokat és mappákat. Állítsa ezt az értéket `true` értékre, ha az adattár .funcignore fájllal rendelkezik, é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 egy Python virtuális környezetet (.venv/). Az alapértelmezett beállítás: `false`.

Megfontolások

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

A GitHub Actions használatakor a kód üzembe helyezésének módja az üzemeltetési csomagtól függ, ahogyan az ebben a táblázatban látható:

Szolgáltatási csomag	Üzembe helyezési módszer
Rugalmas felhasználás	Egyik telepítés
Elastic Premium	Zip-telepítés a Fogyasztási alkalmazásokra
Dedikált (App Service)	Zip-telepítés a Fogyasztási alkalmazásokra
Fogyasztás	Windows: Zip deploy Linux: külső csomag URL-címe^*

* Az alkalmazások Linuxon való futtatásának lehetősége a használatalapú csomagban a tervek szerint megszűnik. További információ: Azure Functions Használati terv üzemeltetése.

A GitHub által az Azure-hoz való csatlakozáshoz szükséges hitelesítő adatok titkosított adatként vannak tárolva a GitHub-adattárban, és a telepítés során így érhetők el: secrets.<SECRET_NAME>.
A GitHub Actions számára a legegyszerűbb módja az Azure Functions üzembe helyezéséhez való hitelesítésnek egy közzétételi profil használata. Hitelesíthet szolgáltatási főazonosítóval is. További információ: this GitHub Actions adattár.
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

A Azure és GitHub integrációról

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2026-03-10