Continue levering met behulp van GitHub Actions

Artikel
31/10/2024

U kunt een GitHub Actions-werkstroom gebruiken om een werkstroom te definiëren om automatisch code te bouwen en te implementeren in uw functie-app in Azure Functions.

Een YAML-bestand (.yml) dat de werkstroomconfiguratie definieert, wordt bijgehouden in het /.github/workflows/ pad in uw opslagplaats. Deze definitie bevat de acties en parameters waaruit de werkstroom bestaat, die specifiek is voor de ontwikkeltaal van uw functies. Een GitHub Actions-werkstroom voor Functions voert de volgende taken uit, ongeacht de taal:

Stel de omgeving in.
Bouw het codeproject.
Implementeer het pakket in een functie-app in Azure.

De actie Azure Functions verwerkt de implementatie naar een bestaande functie-app in Azure.

U kunt handmatig een werkstroomconfiguratiebestand voor uw implementatie maken. U kunt het bestand ook op een van de volgende manieren genereren op basis van een set taalspecifieke sjablonen:

In Azure Portal
Met gebruik van de Azure CLI
Vanuit uw GitHub-opslagplaats

Als u uw YAML-bestand niet handmatig wilt maken, selecteert u een andere methode bovenaan het artikel.

Vereisten

Een Azure-account met een actief abonnement. Gratis een account maken
Een GitHub-account. Als u geen account hebt, kunt u zich registreren voor een gratis account.
Een werkende functie-app die wordt gehost in Azure met broncode in een GitHub-opslagplaats.

Azure CLI, bij het lokaal ontwikkelen. U kunt ook de Azure CLI in Azure Cloud Shell gebruiken.

Genereer implementatiereferenties

Omdat GitHub Actions uw publicatieprofiel gebruikt voor toegang tot uw functie-app tijdens de implementatie, moet u eerst uw publicatieprofiel ophalen en veilig opslaan als een GitHub-geheim.

Belangrijk

Het publicatieprofiel is een waardevolle referentie waarmee toegang tot Azure-resources mogelijk is. Zorg ervoor dat u altijd veilig vervoert en opslaat. In GitHub mag het publicatieprofiel alleen worden opgeslagen in GitHub-geheimen.

Uw publicatieprofiel downloaden

Het publicatieprofiel van uw functie-app downloaden:

Zoek in Azure Portal de pagina voor uw functie-app en vouw Instellingenconfiguratie> uit in de linkerkolom.
Selecteer op de pagina Configuratie het tabblad Algemene instellingen en zorg ervoor dat SCM Basic Auth Publishing Credentials is ingeschakeld. Wanneer deze instelling is uitgeschakeld, kunt u geen publicatieprofielen gebruiken, dus selecteer Aan en vervolgens Opslaan.
Ga terug naar de overzichtspagina van de functie-app en selecteer vervolgens Publicatieprofiel ophalen.
Sla de inhoud van het bestand op en kopieer deze.

Het GitHub-geheim toevoegen

Ga in GitHub naar uw opslagplaats.
Ga naar Instellingen.
Selecteer Geheimen en variabelenacties>.
Selecteer Nieuw opslagplaatsgeheim.
Voeg een nieuw geheim toe met de naam AZURE_FUNCTIONAPP_PUBLISH_PROFILE en de waarde die is ingesteld op de inhoud van het publicatieprofielbestand.
Selecteer Geheim toevoegen.

GitHub kan nu worden geverifieerd bij uw functie-app in Azure.

De werkstroom maken op basis van een sjabloon

De beste manier om handmatig een werkstroomconfiguratie te maken, is door te beginnen met de officieel ondersteunde sjabloon.

De werkstroomconfiguratie maken in de portal

Wanneer u de portal gebruikt om GitHub Actions in te schakelen, maakt Functions een werkstroombestand op basis van uw toepassingsstack en voert dit door naar uw GitHub-opslagplaats in de juiste map.

In de portal wordt uw publicatieprofiel automatisch opgehaald en toegevoegd aan de GitHub-geheimen voor uw opslagplaats.

Tijdens het maken van de functie-app

U kunt snel aan de slag met GitHub Actions via het tabblad Implementatie wanneer u een functie maakt in Azure Portal. Een GitHub Actions-werkstroom toevoegen wanneer u een nieuwe functie-app maakt:

Selecteer In Azure Portal de optie Implementatie in de stroom Functie-app maken.
Schakel continue implementatie in als u wilt dat elke code-update een codepush naar Azure Portal activeert.
Voer uw GitHub-organisatie, opslagplaats en vertakking in.
Voltooi de configuratie van uw functie-app. Uw GitHub-opslagplaats bevat nu een nieuw werkstroombestand in /.github/workflows/.

Voor een bestaande functie-app

Een GitHub Actions-werkstroom toevoegen aan een bestaande functie-app:

Navigeer naar uw functie-app in Azure Portal en selecteer Deployment Center.
Selecteer GitHub als bron. Als u het standaardbericht Building met GitHub Actions niet ziet, selecteert u Change provider choose GitHub Actions en selecteert u OK.
Als u nog geen geautoriseerde GitHub-toegang hebt, selecteert u Autoriseren. Geef uw GitHub-referenties op en selecteer Aanmelden. Als u een ander GitHub-account wilt autoriseren, selecteert u Account wijzigen en meldt u zich aan met een ander account.
Selecteer uw GitHub-organisatie, -opslagplaats en -vertakking. Als u wilt implementeren met GitHub Actions, moet u schrijftoegang hebben tot deze opslagplaats.
Kies in verificatie-instellingen of GitHub Actions moeten worden geverifieerd met een door de gebruiker toegewezen identiteit of met behulp van basisverificatiereferenties . Voor basisverificatie worden de huidige referenties gebruikt.
Selecteer Voorbeeldbestand om het werkstroombestand te zien dat wordt toegevoegd aan uw GitHub-opslagplaats in github/workflows/.
Selecteer Opslaan om het werkstroombestand toe te voegen aan uw opslagplaats.

Werkstroomconfiguratie toevoegen aan uw opslagplaats

U kunt de az functionapp deployment github-actions add opdracht gebruiken om een werkstroomconfiguratiebestand te genereren op basis van de juiste sjabloon voor uw functie-app. Het nieuwe YAML-bestand wordt vervolgens opgeslagen op de juiste locatie (/.github/workflows/) in de GitHub-opslagplaats die u opgeeft, terwijl het publicatieprofielbestand voor uw app wordt toegevoegd aan GitHub-geheimen in dezelfde opslagplaats.

Voer deze az functionapp opdracht uit, vervang de waarden githubUser/githubRepoenMyResourceGroupMyFunctionapp:

Azure CLI
```
az functionapp deployment github-actions add --repo "githubUser/githubRepo" -g MyResourceGroup -n MyFunctionapp --login-with-github
```
Deze opdracht maakt gebruik van een interactieve methode om een persoonlijk toegangstoken voor uw GitHub-account op te halen.

In het terminalvenster ziet u ongeveer het volgende bericht:

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.

Kopieer de unieke XXXX-XXXX code, blader naar https://github.com/login/deviceen voer de code in die u hebt gekopieerd. Nadat u uw code hebt ingevoerd, ziet u ongeveer het volgende bericht:

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

Ga naar uw GitHub-opslagplaats en selecteer Acties. Controleer of uw werkstroom is uitgevoerd.

Het configuratiebestand voor de werkstroom maken

U kunt het configuratiebestand voor de Werkstroom voor GitHub Actions maken vanuit de Azure Functions-sjablonen rechtstreeks vanuit uw GitHub-opslagplaats.

Ga in GitHub naar uw opslagplaats.
Selecteer Acties en nieuwe werkstroom.
Zoeken naar functies.
Zoek in de weergegeven werkstromen van de functions-app die zijn gemaakt door Microsoft Azure, de werkstroom die overeenkomt met uw codetaal en selecteer Configureren.
Werk in het zojuist gemaakte YAML-bestand de env.AZURE_FUNCTIONAPP_NAME parameter bij met de naam van uw functie-app-resource in Azure. Mogelijk moet u desgewenst de parameter bijwerken waarmee de taalversie wordt ingesteld die door uw app wordt gebruikt, zoals DOTNET_VERSION voor C#.
Controleer of het nieuwe werkstroombestand wordt opgeslagen en /.github/workflows/ selecteer Wijzigingen doorvoeren....

Een werkstroomconfiguratie bijwerken

Als u om een of andere reden een bestaande werkstroomconfiguratie moet bijwerken of wijzigen, navigeert u naar de /.github/workflows/ locatie in uw opslagplaats, opent u het specifieke YAML-bestand, brengt u de benodigde wijzigingen aan en voert u de updates door naar de opslagplaats.

Voorbeeld: werkstroomconfiguratiebestand

In het volgende sjabloonvoorbeeld wordt versie 1 van de functions-action en een publish profile voor verificatie gebruikt. De sjabloon is afhankelijk van de gekozen taal en het besturingssysteem waarop uw functie-app is geïmplementeerd:

Windows
Linux

Als uw functie-app wordt uitgevoerd in Windows, selecteert u Windows.

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

Met de actie Azure Functions (Azure/azure-functions) wordt gedefinieerd hoe uw code wordt gepubliceerd naar een bestaande functie-app in Azure of naar een specifieke site in uw app.

Parameters

De volgende parameters zijn vereist voor alle functie-app-plannen:

Parameter	Uitleg
app-naam	De naam van uw functie-app.
package	Dit is de locatie in uw project die moet worden gepubliceerd. Deze waarde is standaard ingesteld op `.`, wat betekent dat alle bestanden en mappen in de GitHub-opslagplaats worden geïmplementeerd.

De volgende parameters zijn vereist voor het Flex Consumption-abonnement:

Parameter	Uitleg
sku	Stel dit in op `flexconsumption` bij het verifiëren met een publicatieprofiel. Wanneer u RBAC-referenties gebruikt of implementeert in een niet-Flex Consumption-plan, kan de actie de waarde oplossen, zodat de parameter niet hoeft te worden opgenomen.
remote-build	Stel dit in om `true` een build-actie van Kudu in te schakelen wanneer het pakket wordt geïmplementeerd in een Flex Consumption-app. Oryx-build wordt altijd uitgevoerd tijdens een externe build in Flex Consumption; stel scm-do-build-during-deployment of enable-oryx-build niet in. Deze parameter is standaard ingesteld op `false`.

De volgende parameters zijn specifiek voor de abonnementen Consumption, Elastic Premium en App Service (Dedicated):

Parameter Uitleg

scm-do-build-during-deployment (Optioneel) Sta de Kudu-site (bijvoorbeeld https://<APP_NAME>.scm.azurewebsites.net/) toe om pre-implementatiebewerkingen uit te voeren, zoals externe builds. Dit is standaard ingesteld op false. Stel dit in op true wanneer u het implementatiegedrag wilt beheren met Behulp van Kudu in plaats van afhankelijkheden in uw GitHub-werkstroom op te lossen. Zie de SCM_DO_BUILD_DURING_DEPLOYMENT instelling voor meer informatie.

enable-oryx-build (Optioneel) Sta Kudu-site toe uw projectafhankelijkheden op te lossen met Oryx. Dit is standaard ingesteld op false. Als u Oryx wilt gebruiken om uw afhankelijkheden op te lossen in plaats van de GitHub Workflow, stelt u zowel scm-do-build-during-deployment als enable-oryx-build in op true.

Parameter	Uitleg
scm-do-build-during-deployment	(Optioneel) Sta de Kudu-site (bijvoorbeeld `https://<APP_NAME>.scm.azurewebsites.net/`) toe om pre-implementatiebewerkingen uit te voeren, zoals externe builds. Dit is standaard ingesteld op `false`. Stel dit in op `true` wanneer u het implementatiegedrag wilt beheren met Behulp van Kudu in plaats van afhankelijkheden in uw GitHub-werkstroom op te lossen. Zie de `SCM_DO_BUILD_DURING_DEPLOYMENT` instelling voor meer informatie.
enable-oryx-build	(Optioneel) Sta Kudu-site toe uw projectafhankelijkheden op te lossen met Oryx. Dit is standaard ingesteld op `false`. Als u Oryx wilt gebruiken om uw afhankelijkheden op te lossen in plaats van de GitHub Workflow, stelt u zowel scm-do-build-during-deployment als enable-oryx-build in op `true`.

Optionele parameters voor alle plannen voor functie-apps:

Parameter	Uitleg
sitenaam	Dit is de naam van de implementatiesite waar moet worden geïmplementeerd. Deze waarde is standaard leeg, wat betekent dat de GitHub Action wordt geïmplementeerd op uw productiesite. Wanneer deze instelling verwijst naar een niet-productiesite, moet u ervoor zorgen dat de parameter publicatieprofiel de referenties voor de site bevat in plaats van de productiesite. Momenteel niet ondersteund in Flex Consumption.
publicatieprofiel	De naam van het GitHub-geheim dat uw publicatieprofiel bevat.
respect-pom-xml	Alleen gebruikt voor Java-functies. Of het vereist is dat het implementatieartefact van uw app wordt afgeleid van het pom.xml-bestand. Wanneer u Java-functie-apps implementeert, moet u deze parameter `true` instellen op en instellen `package` op `.`. Deze parameter is standaard ingesteld op `false`, wat betekent dat de parameter moet verwijzen naar de `package` artefactlocatie van uw app, zoals `./target/azure-functions/`
respect-funcignore	Of GitHub Actions uw .funcignore-bestand respecteert om bestanden en mappen uit te sluiten die erin zijn gedefinieerd. Stel deze waarde in op `true` wanneer uw opslagplaats een .funcignore-bestand heeft en u deze wilt gebruiken om paden en bestanden uit te sluiten, zoals configuraties van teksteditor, .vscode/of een virtuele Python-omgeving (.venv/). De standaardinstelling is `false`.

Overwegingen

Houd rekening met de volgende overwegingen bij het gebruik van de Azure Functions-actie:

Wanneer u GitHub Actions gebruikt, wordt de code geïmplementeerd met behulp van één implementatie in apps in het Flex Consumption-abonnement en zip-implementatie naar apps in de abonnementen Consumption, Elastic Premium en Dedicated (App Service). De uitzondering is Linux-verbruik, waarbij de URL van het externe pakket wordt gebruikt.
De referenties die door GitHub zijn vereist om verbinding te maken met Azure voor implementatie, worden opgeslagen als Geheimen in uw GitHub-opslagplaats en geopend in de implementatie als secrets.<SECRET_NAME>.
De eenvoudigste manier om GitHub Actions te verifiëren met Azure Functions voor implementatie is met behulp van een publicatieprofiel. U kunt zich ook verifiëren met behulp van een service-principal. Zie deze GitHub Actions-opslagplaats voor meer informatie.
De acties voor het instellen van de omgeving en het uitvoeren van een build worden gegenereerd op basis van de sjablonen en zijn taalspecifiek.
De sjablonen gebruiken env elementen om instellingen te definiëren die uniek zijn voor uw build en implementatie.

Volgende stappen

Meer informatie over Azure- en GitHub-integratie

Share via