Continuous Delivery mit GitHub Actions

Artikel
04/15/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

Die folgenden Parameter werden am häufigsten für diese Aktion verwendet:

Parameter	Erklärung
app-name	(Erforderlich) Der Name Ihrer Funktions-App.
slot-name	(Optional) Der Name eines bestimmten Bereitstellungsslots, in dem die Bereitstellung erfolgen soll. Der Slot muss in ihrer Funktions-App bereits vorhanden sein. Wenn er nicht angegeben wird, wird der Code im aktiven Slot bereitgestellt.
publish-profile	(Optional) Der Name des GitHub-Geheimnisses, das Ihr Veröffentlichungsprofil enthält.

Die folgenden Parameter werden ebenfalls unterstützt, aber nur in bestimmten Fällen verwendet:

Parameter	Erklärung
package	(Optional) Legt einen Unterpfad in Ihrem Repository fest, aus dem die Veröffentlichung erfolgen soll. Standardmäßig ist dieser Wert auf `.` festgelegt, was bedeutet, dass alle Dateien und Ordner im GitHub-Repository bereitgestellt werden.
respect-pom-xml	(Optional) 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	(Optional) 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`.
scm-do-build-during-deployment	(Optional) Gibt an, ob die App Service-Bereitstellungswebsite (Kudu) Vorgänge vor der Bereitstellung ausführt. Die Bereitstellungswebsite für Ihre Funktions-App finden Sie unter `https://<APP_NAME>.scm.azurewebsites.net/`. Ändern Sie diese Einstellung in `true`, wenn Sie die Bereitstellungen in Kudu steuern müssen, anstatt die Abhängigkeiten im GitHub Actions-Workflow aufzulösen. Der Standardwert ist `false`. Weitere Informationen finden Sie in der Einstellung SCM_DO_BUILD_DURING_DEPLOYMENT.
enable-oryx-build	(Optional) Gibt an, ob die Kudu-Bereitstellungswebsite Ihre Projektabhängigkeiten mithilfe von Oryx auflöst. Legen Sie den Wert auf `true` fest, wenn Sie Oryx verwenden möchten, um Ihre Projektabhängigkeiten mithilfe eines Remotebuilds anstelle des GitHub Actions-Workflows aufzulösen. Wenn der Wert `true` ist, sollten Sie auch `scm-do-build-during-deployment` auf `true` festlegen. Der Standardwert 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