Continuous Delivery mit GitHub Actions

Artikel
11/05/2024

Sie können einen GitHub Actions-Workflow verwenden, um einen Workflow zum automatischen Erstellen und Bereitstellen von Code in Ihrer Funktions-App in Azure Functions zu definieren.

Eine YAML-Datei, die die Workflowkonfiguration definiert, wird im Pfad /.github/workflows/ in Ihrem Repository beibehalten. Diese Definition enthält die Aktionen und Parameter, aus denen der Workflow besteht. Dies ist für die Entwicklungssprache Ihrer Funktionen spezifisch. Ein GitHub Actions Workflow für Functions führt die folgenden Aufgaben aus, unabhängig von der Sprache:

Einrichten der Umgebung.
Erstellen Sie das Codeprojekt.
Bereitstellen des Pakets in einer Funktions-App in Azure.

Die Azure Functions-Aktion übernimmt die Bereitstellung in einer vorhandenen Funktions-App in Azure.

Sie können eine Workflowkonfigurationsdatei für Ihre Bereitstellung manuell erstellen. Sie können die Datei auch aus einer Reihe sprachspezifischer Vorlagen auf eine der folgenden Arten generieren:

Im Azure-Portal
Verwenden der Azure CLI
Aus Ihrem GitHub-Repository

Wenn Sie Ihre YAML-Datei nicht manuell erstellen möchten, wählen Sie oben im Artikel eine andere Methode aus.

Voraussetzungen

Ein Azure-Konto mit einem aktiven Abonnement. Sie können kostenlos ein Konto erstellen.
Ein GitHub-Konto. Falls Sie noch nicht über ein Konto verfügen, können Sie sich kostenlos registrieren.
Aus einer funktionierenden Funktions-App, die in Azure mit einem GitHub-Repository gehostet wird.

Azure CLI bei lokaler Entwicklung. Sie können die Azure CLI auch in Azure Cloud Shell verwenden.

Generieren von Anmeldeinformationen für die Bereitstellung

Da GitHub Actions Ihr Veröffentlichungsprofil verwendet, um während der Bereitstellung auf Ihre Funktions-App zuzugreifen, müssen Sie zuerst Ihr Veröffentlichungsprofil abrufen und es sicher als GitHub-Geheimnis speichern.

Wichtig

Das Veröffentlichungsprofil ist eine wertvolle Anmeldeinformation, die den Zugriff auf Azure-Ressourcen ermöglicht. Stellen Sie sicher, dass Sie sie immer sicher transportieren und speichern. In GitHub darf das Veröffentlichungsprofil nur in GitHub-Geheimnissen gespeichert werden.

Herunterladen des Veröffentlichungsprofils

So laden Sie das Veröffentlichungs Profil Ihrer Funktions-App herunter:

Suchen Sie im Azure-Portal die Seite für Ihre Funktions-App, und erweitern Sie Einstellungen>Konfiguration in der linken Spalte.
Wählen Sie auf der Seite Konfiguration die Registerkarte Allgemeine Einstellungen aus, und stellen Sie sicher, dass die Option Veröffentlichungsanmeldeinformationen für die SCM-Standardauthentifizierung auf Ein eingestellt ist. Wenn diese Einstellung auf Aus eingestellt ist, können Sie keine Veröffentlichungsprofile verwenden. Wählen Sie daher Ein und dann Speichern aus.
Kehren Sie zur Seite Übersicht der Funktions-App zurück, und wählen Sie dann Veröffentlichungsprofil abrufen aus.
Speichern und kopieren Sie den Inhalt der Datei.

Hinzufügen des GitHub-Geheimnisses

Wechseln Sie in GitHub zu Ihrem Repository.
Wechseln Sie zu Einstellungen.
Wählen Sie Secrets and variables > Actions (Geheimnisse und Variablen > Aktionen) aus.
Wählen Sie New repository secret (Neues Repositorygeheimnis) aus.
Fügen Sie ein neues Geheimnis mit dem Namen AZURE_FUNCTIONAPP_PUBLISH_PROFILE hinzu, dessen Wert auf den Inhalt der Veröffentlichungsprofildatei festgelegt ist.
Klicken Sie auf Add secret (Geheimnis hinzufügen).

GitHub kann sich jetzt bei ihrer Funktions-App in Azure authentifizieren.

Erstellen des Workflows anhand einer Vorlage

Die beste Möglichkeit zum manuellen Erstellen einer Workflowkonfiguration besteht darin, mit der offiziell unterstützten Vorlage zu beginnen.

Erstellen der Workflowkonfiguration im Portal

Wenn Sie das Portal verwenden, um GitHub Actions zu aktivieren, erstellt Functions eine Workflowdatei basierend auf Ihrem Anwendungsstapel und committet sie in Ihr GitHub-Repository im richtigen Verzeichnis.

Das Portal ruft ihr Veröffentlichungsprofil automatisch ab und fügt es den GitHub-Geheimnissen für Ihr Repository hinzu.

Während der Erstellung von Funktions-Apps

Sie können schnell mit GitHub Actions über die Registerkarte „Deployment“ (Bereitstellung) beginnen, wenn Sie eine Funktion im Azure-Portal erstellen. So fügen Sie beim Erstellen einer neuen Funktions-App einen GitHub Actions-Workflow hinzu:

Wählen Sie im Azure-Portal im Flow Funktions-App erstellen die Option Bereitstellung aus.
Aktivieren Sie Continuous Deployment, wenn jedes Codeupdate einen Codepush an das Azure-Portal auslösen soll.
Geben Sie Ihre GitHub-Organisation, Ihr Repository und Ihren Branch ein.
Schließen Sie die Konfiguration Ihrer Funktions-App ab. Ihr GitHub-Repository enthält jetzt eine neue Workflowdatei in /.github/workflows/.

Für eine vorhandene Funktions-App

So fügen Sie einer vorhandenen Funktions-App einen GitHub Actions-Workflow hinzu:

Navigieren Sie im Azure-Portal zu ihrer Funktions-App, und wählen Sie die Option Bereitstellungscenter aus.
Wählen Sie unter Quelle die Option GitHub aus. Wenn die Standardmeldung Erstellen mit GitHub Actions nicht angezeigt wird, wählen Sie Anbieter GitHub Actions ändern und dann OK aus.
Wenn Sie noch keinen GitHub-Zugriff autorisiert haben, wählen Sie Autorisieren aus. Geben Sie Ihre GitHub-Anmeldeinformationen an, und wählen Sie Anmelden aus. Um ein anderes GitHub-Konto zu autorisieren, wählen Sie Konto ändern aus, und melden Sie sich mit einem anderen Konto an.
Geben Sie Ihre GitHub-Organisation, Ihr Repository und Ihren Branch ein. Zum Bereitstellen mit GitHub Actions benötigen Sie Schreibzugriff auf dieses Repository.
Wählen Sie in den Authentifizierungseinstellungen aus, ob GitHub Actions mit einer benutzerseitig zugewiesenen Identität authentifiziert oder Anmeldeinformationen für die Standardauthentifizierung verwendet werden sollen. Für die Standardauthentifizierung werden die aktuellen Anmeldeinformationen verwendet.
Wählen Sie Vorschau der Datei anzeigen aus, um die Workflowdatei anzuzeigen, die Ihrem GitHub-Repository in github/workflows/ hinzugefügt wird.
Wählen Sie Speichern aus, um die Workflowdatei Ihrem Repository hinzuzufügen.

Hinzufügen der Workflowkonfiguration zu Ihrem Repository

Sie können den Befehl az functionapp deployment github-actions add verwenden, um eine Workflowkonfigurationsdatei aus der richtigen Vorlage für Ihre Funktions-App zu generieren. Die neue YAML-Datei wird dann am richtigen Speicherort (/.github/workflows/) im von Ihnen bereitgestellten GitHub-Repository gespeichert, während die Veröffentlichungsprofildatei für Ihre App den GitHub-Geheimnissen im selben Repository hinzugefügt wird.

Führen Sie diesen Befehl az functionapp aus, und ersetzen Sie die Werte githubUser/githubRepo, MyResourceGroup und MyFunctionapp:
```
az functionapp deployment github-actions add --repo "githubUser/githubRepo" -g MyResourceGroup -n MyFunctionapp --login-with-github
```
Dieser Befehl verwendet eine interaktive Methode, um ein persönliches Zugriffstoken für Ihr GitHub-Konto abzurufen.

In Ihrem Terminal-Fenster sollte in etwa die folgende Meldung angezeigt werden:

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

Kopieren Sie den eindeutigen XXXX-XXXX-Code, navigieren Sie zu https://github.com/login/device, und geben Sie den kopierten Code ein. Nachdem Sie Ihren Code eingegeben haben, sollte etwas wie die folgende Meldung angezeigt werden:

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

Navigieren Sie zu Ihrem GitHub-Repository, und wählen Sie Aktionen aus. Vergewissern Sie sich, dass Ihr Workflow ausgeführt wurde.

Erstellen der Workflowkonfigurationsdatei

Sie können die GitHub Actions-Workflowkonfigurationsdatei aus den Azure Functions-Vorlagen direkt aus Ihrem GitHub-Repository erstellen.

Wechseln Sie in GitHub zu Ihrem Repository.
Wählen Sie Actions (Aktionen) und New Workflow (Neuer Workflow) aus.
Suchen Sie nach Funktionen.
Suchen Sie in den angezeigten Funktions-App-Workflows, die von Microsoft Azure erstellt wurden, nach dem Workflow, der Ihrer Codesprache entspricht, und wählen Sie Konfigurieren aus.
Aktualisieren Sie in der neu erstellten YAML-Datei den env.AZURE_FUNCTIONAPP_NAME-Parameter mit dem Namen Ihrer Funktions-App-Ressource in Azure. Möglicherweise müssen Sie optional den Parameter aktualisieren, der die von Ihrer App verwendete Sprachversion festlegt, z. B. DOTNET_VERSION für C#.
Vergewissern Sie sich, dass die neue Workflowdatei in /.github/workflows/ gespeichert wird, und wählen Sie Commit changes... (Änderungen committen) aus.

Aktualisieren einer Workflowkonfiguration

Wenn Sie aus irgendeinem Grund eine vorhandene Workflowkonfiguration aktualisieren oder ändern müssen, navigieren Sie einfach zum Speicherort /.github/workflows/ in Ihrem Repository, öffnen die entsprechende YAML-Datei, nehmen alle erforderlichen Änderungen vor und committen dann die Aktualisierungen im Repository.

Beispiel: Workflowkonfigurationsdatei

Im folgenden Vorlagenbeispiel wird Version 1 von functions-action und ein publish profile für die Authentifizierung verwendet. Die Vorlage hängt von der gewählten Sprache und dem Betriebssystem ab, unter dem Ihre Funktions-App bereitgestellt wird:

Windows
Linux

Wenn Ihre Funktions-App unter Linux ausgeführt wird, wählen Sie Linux aus.

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

Die Azure Functions-Aktion (Azure/azure-functions) definiert, wie Ihr Code für eine vorhandene Funktions-App in Azure oder in einem bestimmten Slot in Ihrer App veröffentlicht wird.

Parameter

Für alle Funktions-App-Pläne sind die folgenden Parameter erforderlich:

Parameter	Erklärung
app-name	Der Name Ihrer Funktions-App.
package	Dies ist der Speicherort in Ihrem Projekt, der veröffentlicht werden soll. Standardmäßig ist dieser Wert auf `.` festgelegt, was bedeutet, dass alle Dateien und Ordner im GitHub-Repository bereitgestellt werden.

Für den Flex-Verbrauchsplan sind die folgenden Parameter erforderlich:

Parameter	Erklärung
sku	Legen Sie diesen Parameter beim Authentifizieren mit publish-profile auf `flexconsumption` fest. Wenn Sie RBAC-Anmeldeinformationen verwenden oder in einem Nicht-Flex-Verbrauchsplan bereitstellen, kann die Aktion den Wert auflösen, sodass der Parameter nicht einbezogen werden muss.
remote-build	Legen Sie diesen Parameter auf `true` fest, um eine Buildaktion aus Kudu zu aktivieren, wenn das Paket in einer Flex-Verbrauchs-App bereitgestellt wird. Der Oryx-Build wird immer während eines Remote-Builds beim Flex-Verbrauch durchgeführt; legen Sie scm-do-build-during-deployment oder enable-oryx-build nicht fest. Dieser Parameter ist standardmäßig auf `false` festgelegt.

Die folgenden Parameter gelten speziell für die Pläne „Verbrauch“, „Elastic Premium“ und „App Service“ (Dediziert):

Parameter Erklärung

scm-do-build-during-deployment (Optional) Lassen Sie zu, dass die Kudu-Website (z. B. https://<APP_NAME>.scm.azurewebsites.net/) Vorgänge vor der Bereitstellung ausführt, z. B. Remotebuilds. Sie ist standardmäßig auf false festgelegt. Legen Sie diesen Parameter auf true fest, wenn Sie das Bereitstellungsverhalten mithilfe von Kudu steuern möchten, anstatt Abhängigkeiten in Ihrem GitHub-Workflow aufzulösen. Weitere Informationen finden Sie in der Einstellung SCM_DO_BUILD_DURING_DEPLOYMENT.

enable-oryx-build (Optional) Lassen Sie zu, dass die Kudu-Website Ihre Projektabhängigkeiten mit Oryx auflösen kann. Sie ist standardmäßig auf false festgelegt. Wenn Sie Oryx anstelle des GitHub-Workflows für das Auflösen Ihrer Abhängigkeiten verwenden möchten, legen Sie scm-do-build-during-deployment und enable-oryx-build auf true fest.

Parameter	Erklärung
scm-do-build-during-deployment	(Optional) Lassen Sie zu, dass die Kudu-Website (z. B. `https://<APP_NAME>.scm.azurewebsites.net/`) Vorgänge vor der Bereitstellung ausführt, z. B. Remotebuilds. Sie ist standardmäßig auf `false` festgelegt. Legen Sie diesen Parameter auf `true` fest, wenn Sie das Bereitstellungsverhalten mithilfe von Kudu steuern möchten, anstatt Abhängigkeiten in Ihrem GitHub-Workflow aufzulösen. Weitere Informationen finden Sie in der Einstellung `SCM_DO_BUILD_DURING_DEPLOYMENT`.
enable-oryx-build	(Optional) Lassen Sie zu, dass die Kudu-Website Ihre Projektabhängigkeiten mit Oryx auflösen kann. Sie ist standardmäßig auf `false` festgelegt. Wenn Sie Oryx anstelle des GitHub-Workflows für das Auflösen Ihrer Abhängigkeiten verwenden möchten, legen Sie scm-do-build-during-deployment und enable-oryx-build auf `true` fest.

Optionale Parameter für alle Funktions-App-Pläne:

Parameter	Erklärung
slot-name	Dies ist der Name des Bereitstellungsslots, für den bereitgestellt werden soll. Dieser Wert ist standardmäßig leer, was bedeutet, dass die GitHub-Aktion für Ihren Produktionsstandort bereitgestellt wird. Wenn diese Einstellung auf einen Nicht-Produktionsslot verweist, stellen Sie sicher, dass der Parameter publish-profile die Anmeldeinformationen für den Slot anstelle des Produktionsstandorts enthält. Wird derzeit nicht für den Flex-Verbrauch unterstützt..
publish-profile	Der Name des GitHub-Geheimnisses, das Ihr Veröffentlichungsprofil enthält.
respect-pom-xml	Wird nur für Java-Funktionen verwendet. Gibt an, ob es erforderlich ist, dass das Bereitstellungsartefakt Ihrer App aus der Datei „pom.xml“ abgeleitet wird. Beim Bereitstellen von Java-Funktions-Apps sollten Sie diesen Parameter auf `true` und `package` auf `.` festlegen. Standardmäßig ist dieser Parameter auf `false` festgelegt, was bedeutet, dass der `package`-Parameter auf den Artefaktspeicherort Ihrer App verweisen muss, z. B. auf `./target/azure-functions/`.
respect-funcignore	Gibt an, ob GitHub Actions Ihre FUNCIGNORE-Datei berücksichtigt, um darin definierte Dateien und Ordner auszuschließen. Legen Sie diesen Wert auf `true` fest, wenn Ihr Repository über eine .funcignore-Datei verfügt und Sie diese verwenden möchten, um Pfade und Dateien auszuschließen, z. B. Text-Editor-Konfigurationen, .vscode/ oder eine virtuelle Python-Umgebung (.venv/). Die Standardeinstellung ist `false`.

Überlegungen

Beachten Sie die folgenden Überlegungen, wenn Sie die Azure Functions-Aktion verwenden:

Wenn Sie GitHub Actions verwenden, wird der Code für Ihre Funktions-App mithilfe der Zip-Bereitstellung für Azure Functions bereitgestellt.
Die Anmeldeinformationen, die GitHub für die Verbindung mit Azure für die Bereitstellung benötigt, werden als Geheimnisse in Ihrem GitHub-Repository gespeichert und in der Bereitstellung als secrets.<SECRET_NAME> aufgerufen.
Die einfachste Möglichkeit für GitHub Actions, sich bei Azure Functions für die Bereitstellung zu authentifizieren, ist die Verwendung eines Veröffentlichungsprofils. Sie können sich auch mit einem Dienstprinzipal authentifizieren. Weitere Informationen finden Sie in diesem GitHub Actions-Repository.
Die Aktionen zum Einrichten der Umgebung und Ausführen eines Builds werden aus den Vorlagen generiert und sind sprachspezifisch.
Die Vorlagen verwenden env-Elemente, um Einstellungen zu definieren, die für Ihren Build und Ihre Bereitstellung eindeutig sind.

Nächste Schritte

Weitere Informationen zu Azure und zur GitHub-Integration

Teilen über