Kontinuierliche Lieferung mithilfe von GitHub Actions

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 Funktionen führt unabhängig von der Sprache die folgenden Aufgaben aus:

Einrichten der Umgebung.
Erstellen Sie das Codeprojekt.
Stellen Sie das Paket in einer Funktions-App in Azure bereit.

Die Azure Functions-Aktion behandelt die Bereitstellung 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. Kostenlos ein Konto erstellen.
Ein GitHub Konto. Falls Sie noch nicht über ein Konto verfügen, können Sie sich kostenlos registrieren.
Eine auf Azure gehostete Arbeitsfunktions-App mit Quellcode in einem GitHub Repository.

Azure CLI bei der lokalen 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 für den Zugriff auf Ihre Funktions-App während der Bereitstellung verwendet, müssen Sie zuerst Ihr Veröffentlichungsprofil abrufen und es sicher als GitHub secret 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-Secrets 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, erweitern Sie Settings>Configuration 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 deaktiviert ist, können Sie keine Veröffentlichungsprofile verwenden. Wählen Sie " Ein" und dann " Übernehmen" 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 "Neuer Repositoryschlüssel" 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.
Wählen Sie "Geheimen Schlüssel hinzufügen" aus.

GitHub kann sich jetzt bei Ihrer Function 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 führt einen Commit für Ihr GitHub Repository im richtigen Verzeichnis durch.

Das Portal ruft Ihr Veröffentlichungsprofil automatisch ab und fügt es dem GitHub Geheimen Schlüssel für Ihr Repository hinzu.

Während der Erstellung von Funktions-Apps

Sie können schnell mit GitHub Actions über die Registerkarte "Bereitstellung" beginnen, wenn Sie eine Funktion im Azure Portal erstellen. So fügen Sie einen GitHub Actions Workflow hinzu, wenn Sie eine neue Funktions-App erstellen:

Wählen Sie im Azure-PortalBereitstellung im Erstellen Funktions-App-Fluss aus.
Aktivieren Sie Kontinierte Bereitstellung, wenn für jede Codeaktualisierung ein Code-Push an Azure Portal ausgelöst werden 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 portal Azure portal zu Ihrer Funktions-App, und wählen Sie Deployment Center aus.
Wählen Sie für SourceGitHub aus. Wenn die Standardmeldung nicht Building with GitHub Actions angezeigt wird, wählen Sie Change providerGitHub Actions und dann OK aus.
Wenn Sie GitHub Zugriff noch nicht autorisiert haben, wählen Sie Authorize aus. Geben Sie Ihre GitHub Anmeldeinformationen an, und wählen Sie Sign in aus. Um ein anderes GitHub Konto zu autorisieren, wählen Sie Konto ändern aus, und melden Sie sich mit einem anderen Konto an.
Wählen Sie Ihre GitHub Organization, Repository und Branch aus. Zum Bereitstellen mit GitHub Actions benötigen Sie Schreibzugriff auf dieses Repository.
Wählen Sie in den Authentifizierungseinstellungen aus, ob GitHub Actions sich mit einer benutzerzugewiesenen Identität oder mit grundlegenden Authentifizierungsdaten authentifizieren soll. Für die Standardauthentifizierung werden die aktuellen Anmeldeinformationen verwendet.
Wählen Sie Vorschaudatei 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 zu GitHub geheimen Schlüsseln 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

Wechseln Sie zu Ihrem GitHub Repository, und wählen Sie Actions 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 Funktionen-App-Workflows, die von Microsoft Azure erstellt wurden, das Ihrer Codesprache entspricht, und wählen Sie Configure aus.
Aktualisieren Sie in der neu erstellten YAML-Datei den Parameter env.AZURE_FUNCTIONAPP_NAME 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 /.github/workflows/ Speicherort in Ihrem Repository, öffnen Sie die spezifische YAML-Datei, nehmen Sie alle erforderlichen Änderungen vor, und übernehmen Sie dann die Updates für das 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/functions-action) definiert, wie Ihr Code in einer vorhandenen 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. Dieser Wert ist standardmäßig 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 anderen Verbrauchsplan als Flex bereitstellen, kann die Aktion den Wert auflösen, sodass der Parameter nicht mit 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. Oryx-Build wird immer während eines Remote-Builds in Flex Consumption durchgeführt; setzen Sie scm-do-build-during-deployment oder enable-oryx-build nicht. 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) Ermöglichen Sie der Kudu-Website (zum Beispiel https://<APP_NAME>.scm.azurewebsites.net/), Vorbereitungsarbeiten wie Remote-Builds auszuführen. Sie ist standardmäßig auf false festgelegt. Legen Sie dies 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 verwenden möchten, um Ihre Abhängigkeiten anstelle des GitHub Workflows aufzulösen, Legen Sie scm-do-build-during-deployment und enable-oryx-build auf true fest.

Parameter	Erklärung
scm-do-build-during-deployment	(Optional) Ermöglichen Sie der Kudu-Website (zum Beispiel `https://<APP_NAME>.scm.azurewebsites.net/`), Vorbereitungsarbeiten wie Remote-Builds auszuführen. Sie ist standardmäßig auf `false` festgelegt. Legen Sie dies 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 verwenden möchten, um Ihre Abhängigkeiten anstelle des GitHub Workflows aufzulösen, 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 auf Ihrer Produktionswebsite bereitgestellt wird. Wenn diese Einstellung auf einen Nicht-Produktionsplatz verweist, stellen Sie sicher, dass der Parameter "publish-profile " die Anmeldeinformationen für den Slot anstelle der Produktionswebsite enthält. Wird derzeit nicht für den Flex-Verbrauch unterstützt..
publish-profile	Der Name des GitHub geheimen Schlüssels, der 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. Bei der Bereitstellung Java Funktions-Apps sollten Sie diesen Parameter auf `true` festlegen 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	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 sie verwenden möchten, um Pfade und Dateien auszuschließen, z. B. Text-Editor-Konfigurationen, .vscode/- oder eine Python-virtuelle Umgebung (.venv/). Die Standardeinstellung ist `false`.

Überlegungen

Beachten Sie bei der Verwendung der Azure Functions-Aktion die folgenden Überlegungen:

Wenn Sie GitHub Actions verwenden, hängt die Art und Weise, wie Ihr Code bereitgestellt wird, von Ihrem Hostingplan ab, wie in dieser Tabelle gezeigt:

Hostingplan	Bereitstellungsmethode
Flex-Verbrauch	OneDeploy
Elastic Premium	Zip-Bereitstellung auf Apps im Verbrauch
Dediziert (App Service)	Zip-Bereitstellung auf Apps im Verbrauch
Verbrauch	Windows: Zip deploy Linux: URL des externen Pakets^*

* Die Möglichkeit, Ihre Apps unter Linux in einem Verbrauchsplan auszuführen, ist für den Ruhestand geplant. Weitere Informationen finden Sie unter Azure Functions Verbrauchsplan-Hosting.

Die Anmeldeinformationen, die von GitHub zum Herstellen einer Verbindung mit Azure für die Bereitstellung erforderlich sind, werden in Ihrem GitHub-Repository als Secrets gespeichert und während der Bereitstellung mit secrets.<SECRET_NAME> abgerufen.
Die einfachste Möglichkeit für GitHub Actions, sich bei Azure Functions für die Bereitstellung zu authentifizieren, besteht darin, ein Veröffentlichungsprofil zu verwenden. Sie können sich auch mit einem Dienstprinzipal authentifizieren. Weitere Informationen finden Sie unter Dieses 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

Learn Sie mehr über Azure und GitHub Integration

Feedback

War diese Seite hilfreich?

Last updated on 2026-03-11