Bereitstellen in App Service mithilfe von GitHub Actions

Verwenden Sie GitHub Actions zum Automatisieren Ihres Workflows und zum Bereitstellen im Azure App Service aus GitHub.

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.

Einrichten der Bereitstellung von GitHub-Aktionen beim Erstellen der App

Die Bereitstellung von GitHub-Aktionen ist in den standardmäßigen App-Erstellungsassistenten integriert. Sie müssen lediglich Continuous Deployment (CD) auf Aktivieren der Registerkarte „Bereitstellung“ festlegen und die gewünschte Organisation, das Repository und die gewünschte Verzweigung konfigurieren.

Wenn Sie die kontinuierliche Bereitstellung aktivieren, wählt der Assistent für die App-Erstellung automatisch die Authentifizierungsmethode basierend auf der Auswahl der Standardauthentifizierung aus und konfiguriert Ihre App und Ihr GitHub-Repository entsprechend:

Auswahl der Standardauthentifizierung	Authentifizierungsmethode
Disable	Vom Benutzer zugewiesene Identität (OpenID Connect) (empfohlen)
Aktivieren	Standardauthentifizierung

Hinweis

Wenn beim Erstellen Ihrer App eine Fehlermeldung angezeigt wird, die besagt, dass Ihr Azure-Konto nicht über bestimmte Berechtigungen verfügt, hat es möglicherweise nicht die erforderlichen Berechtigungen zum Erstellen und Konfigurieren der vom Benutzer zugewiesenen Identität. Eine Alternative finden Sie unter Einrichten der Bereitstellung von GitHub Actions aus dem Deployment Center.

Einrichten der Bereitstellung von GitHub Actions über das Deployment Center

Bei einer vorhandenen Anwendung können Sie mit GitHub Actions schnell loslegen, indem Sie das App Service Deployment Center nutzen. Diese schlüsselfertige Methode generiert automatisch eine GitHub Actions Workflow-Datei auf der Grundlage Ihres Anwendungsstapels und überträgt sie in Ihr GitHub-Repository.

Mit dem Deployment Center können Sie auch die sicherere OpenID Connect-Authentifizierung mit der Option für die vom Benutzer zugewiesene Identität problemlos konfigurieren.

Wenn Ihr Azure-Konto über die erforderlichen Berechtigungen verfügt, können Sie eine benutzerseitig zugewiesene Identität erstellen. Andernfalls können Sie eine vorhandene, benutzerseitig zugewiesene verwaltete Identität im Dropdown Identität auswählen. Sie können mit Ihrem Azure-Administrator eine benutzerseitig zugewiesene verwaltete Identität mit der Rolle Website-Mitwirkender erstellen.

Weitere Informationen finden Sie unter Continuous Deployment in Azure App Service.

Manuelles Einrichten eines GitHub-Actions-Workflows

Sie können einen Workflow auch ohne das Deployment Center bereitstellen. In diesem Fall müssen Sie drei Schritte ausführen:

1. Generieren von Anmeldeinformationen für die Bereitstellung
2. Konfigurieren des GitHub-Geheimnisses
3. Hinzufügen der Workflowdatei zum GitHub-Repository

1. Generieren von Anmeldeinformationen für die Bereitstellung

Die empfohlene Vorgehensweise für die Authentifizierung mit Azure App Services für GitHub Actions ist mit OpenID Connect. Dies ist eine Authentifizierungsmethode, die kurzlebige Token verwendet. Einrichten von OpenID Connect mit GitHub Actions ist komplexer, bietet jedoch mehr Sicherheit.

Alternativ können Sie sich mit einer vom Benutzer zugewiesenen verwalteten Identität, einem Dienstprinzipal oder einem Veröffentlichungsprofil authentifizieren.

OpenID Connect

Die folgenden Schritte führen Sie durch die Erstellung einer Active Directory-Anwendung, eines Dienstprinzipals und von Verbundanmeldeinformationen mithilfe von Azure CLI-Anweisungen. Informationen zum Erstellen einer Active Directory-Anwendung, eines Dienstprinzipals und von Verbundanmeldeinformationen über das Azure-Portal finden Sie unter Verbinden von GitHub und Azure.

1. Wenn Sie keine bestehende Anwendung besitzen, registrieren Sie eine neue Active Directory-Anwendung und einen neuen Dienstprinzipal, die auf Ressourcen zugreifen können. Erstellen Sie die Active Directory-Anwendung.

   az ad app create --display-name myApp
   

   Dieser Befehl gibt JSON mit einem appId-Wert aus, der client-id entspricht. Speichern Sie den Wert, der später als AZURE_CLIENT_IDGitHub-Geheimnis verwendet werden soll.

   Sie verwenden den objectId Wert beim Erstellen von Verbundanmeldeinformationen mit Graph-API und verweisen diese als APPLICATION-OBJECT-ID.

2. Erstellen eines Dienstprinzipals. Ersetzen Sie $appID durch die AppId aus Ihrer JSON-Ausgabe.

   Dieser Befehl generiert eine JSON-Ausgabe mit einem anderen objectId und wird im nächsten Schritt verwendet. Der neue objectId ist der assignee-object-id.

   Kopieren Sie die appOwnerTenantId, um sie später als GitHub-Geheimnis für AZURE_TENANT_ID zu verwenden.

    az ad sp create --id $appId
   

3. Erstellen Sie eine neue Rollenzuweisung nach Abonnement und Objekt. Standardmäßig ist die Rollenzuweisung an Ihr Standardabonnement gebunden. Ersetzen Sie $subscriptionId durch Ihre Abonnement-ID, $resourceGroupName durch Ihren Ressourcengruppennamen, $webappName durch Ihren Web-App-Namen und $assigneeObjectId durch die generierte id. Erfahren Sie, wie Sie Azure-Abonnements mit der Azure CLI verwalten.

   az role assignment create --role contributor --subscription $subscriptionId --assignee-object-id  $assigneeObjectId --scope /subscriptions/$subscriptionId/resourceGroups/$resourceGroupName/providers/Microsoft.Web/sites/$webappName --assignee-principal-type ServicePrincipal
   

4. Führen Sie den folgenden Befehl aus, um neue Anmeldeinformationen für die Verbundidentität für Ihre Active Directory-Anwendung zu erstellen.

   • Ersetzen Sie APPLICATION-OBJECT-ID durch die AppId (die beim Erstellen der Anwendung generiert wurde) für Ihre Active Directory-Anwendung.
   • Legen Sie einen Wert für CREDENTIAL-NAME fest, um später auf ihn zu verweisen.
   • Legen Sie die subject fest. Der Wert wird von GitHub in Abhängigkeit von Ihrem Workflow festgelegt:
     • Aufträge in Ihrer GitHub Actions-Umgebung: repo:< Organization/Repository >:environment:< Name >
     • Bei Aufträgen, die nicht an eine Umgebung gebunden sind, fügen Sie den Referenzpfad für den Branch/Tag auf der Grundlage des für die Auslösung des Workflows verwendeten Referenzpfads ein: repo:< Organization/Repository >:ref:< ref path>. Zum Beispiel: repo:n-username/ node_express:ref:refs/heads/my-branch oder repo:n-username/ node_express:ref:refs/tags/my-tag.
     • Für Workflows, die durch ein Pull Request-Ereignis ausgelöst werden: repo:< Organization/Repository >:pull_request.

   az ad app federated-credential create --id <APPLICATION-OBJECT-ID> --parameters credential.json
   ("credential.json" contains the following content)
   {
       "name": "<CREDENTIAL-NAME>",
       "issuer": "https://token.actions.githubusercontent.com",
       "subject": "repo:organization/repository:ref:refs/heads/main",
       "description": "Testing",
       "audiences": [
           "api://AzureADTokenExchange"
       ]
   }     
   

Veröffentlichungsprofil

Hinweis

Für das Veröffentlichungsprofil muss Standardauthentifizierung aktiviert werden.

Ein Veröffentlichungsprofil stellt Anmeldeinformationen auf App-Ebene dar. Richten Sie Ihr Veröffentlichungsprofil als GitHub-Geheimnis ein.

1. Wechseln Sie im Azure-Portal zu Ihrem App Service.

2. Wählen Sie auf der Seite Übersicht die Option Veröffentlichungsprofil abrufen.

3. Speichern Sie die heruntergeladene Datei. Zum Erstellen eines GitHub-Geheimnisses verwenden Sie den Inhalt der Datei.

Hinweis

Ab Oktober 2020 muss für Linux-Web-Apps die App-Einstellung WEBSITE_WEBDEPLOY_USE_SCM auf true festgelegt werden, bevor das Veröffentlichungsprofil heruntergeladen wird. Diese Anforderung wird künftig entfallen.

Dienstprinzipal

Sie können mit dem Befehl az ad sp create-for-rbac in der Azure CLI einen Dienstprinzipal erstellen. Führen Sie diesen Befehl mit Azure Cloud Shell im Azure-Portal oder durch Auswählen der Schaltfläche Ausprobieren aus.

az ad sp create-for-rbac --name "myApp" --role contributor \
                            --scopes /subscriptions/<subscription-id>/resourceGroups/<group-name>/providers/Microsoft.Web/sites/<app-name> \
                            --json-auth

Ersetzen Sie im vorherigen Beispiel die Platzhalter durch Ihre Abonnement-ID, den Ressourcengruppennamen und den App-Namen. Die Ausgabe ist ein JSON-Objekt mit den Anmeldeinformationen für die Rollenzuweisung, die ähnlich wie der folgenden JSON-Codeschnipsel Zugriff auf Ihre App Service-App gewähren. Kopieren Sie dieses JSON-Objekt zur späteren Verwendung.

  {
    "clientId": "<GUID>",
    "clientSecret": "<GUID>",
    "subscriptionId": "<GUID>",
    "tenantId": "<GUID>",
    (...)
  }

Wichtig

Es ist immer empfehlenswert, den minimalen Zugriff zu gewähren. Der Bereich im vorherigen Beispiel ist auf die spezifische App Service-App und nicht auf die gesamte Ressourcengruppe beschränkt.

2. Konfigurieren des GitHub-Geheimnisses

OpenID Connect

Sie müssen die Client-ID Ihrer Anwendung, die Mandanten-ID und die Abonnement-ID für die Azure/Anmeldeaktion bereitstellen. Diese Werte können entweder direkt im Workflow bereitgestellt werden oder in GitHub-Geheimnissen gespeichert und darauf in Ihrem Workflow verwiesen werden. Das Speichern der Werte als GitHub-Geheimnisse ist die sicherere Option.

1. Öffnen Sie Ihr GitHub-Repository, und wechseln Sie zu Einstellungen > Sicherheit > Geheimnisse und Variablen > Aktionen > Neues Repositorygeheimnis.

2. Erstellen Sie Geheimnisse für AZURE_CLIENT_ID, AZURE_TENANT_ID und AZURE_SUBSCRIPTION_ID. Verwenden Sie diese Werte aus Ihrer Active Directory-Anwendung für Ihre GitHub-Geheimnisse:

   GitHub-Geheimnis	Eine Active Directory-Anwendung
   AZURE_CLIENT_ID	Anwendungs-ID (Client)
   AZURE_TENANT_ID	Verzeichnis-ID (Mandant)
   AZURE_SUBSCRIPTION_ID	Abonnement-ID

3. Speichern Sie jedes Geheimnis, indem Sie Geheimnis hinzufügen auswählen.

Veröffentlichungsprofil

Suchen Sie auf GitHub nach Ihrem Repository. Wählen Sie Einstellungen > Sicherheit > Geheimnisse und Variablen > Aktionen > Neues Repositorygeheimnis aus.

Um Anmeldeinformationen auf App-Ebene zu verwenden, fügen Sie den Inhalt der heruntergeladenen Veröffentlichungsprofildatei in das Wertfeld des Geheimnisses ein. Geben Sie dem Geheimnis den Namen AZURE_WEBAPP_PUBLISH_PROFILE.

Wenn Sie die GitHub-Workflowdatei später konfigurieren, verwenden Sie die AZURE_WEBAPP_PUBLISH_PROFILE in der Aktion Azure Webanwendung bereitstellen. Beispiel:

- uses: azure/webapps-deploy@v2
  with:
    publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}

Dienstprinzipal

Suchen Sie auf GitHub nach Ihrem Repository. Wählen Sie Einstellungen > Sicherheit > Geheimnisse und Variablen > Aktionen > Neues Repositorygeheimnis aus.

Um Anmeldeinformationen auf Benutzerebene zu verwenden, fügen Sie die gesamte JSON-Ausgabe aus dem Azure CLI-Befehl in das Wertfeld des Geheimnisses ein. Geben Sie dem Geheimnis den Namen AZURE_CREDENTIALS.

Wenn Sie später die GitHub-Workflowdatei konfigurieren, verwenden Sie das Geheimnis für die Eingabe creds des Azure/login. Zum Beispiel:

- uses: azure/login@v2
  with:
    creds: ${{ secrets.AZURE_CREDENTIALS }}

3. Hinzufügen der Workflowdatei zum GitHub-Repository

Ein Workflow wird durch eine YAML-Datei (.yml) in dem /.github/workflows/-Pfad in Ihrem GitHub-Repository definiert. Diese Definition enthält die verschiedenen Schritte und Parameter, die den Workflow bilden.

Die Workflowdatei sollte mindestens die folgenden einzelnen Schritte enthalten:

1. Authentifizieren Sie sich bei App Service mit dem von Ihnen erstellten GitHub-Geheimschlüssel.
2. Erstellen der Web-App.
3. Bereitstellen der Web-App.

Um Ihren Code in einer App Service-Anwendung bereitzustellen, verwenden Sie die Aktion azure/webapps-deploy@v3. Die Aktion erfordert den Namen Ihrer Web-App in app-name und, je nach Sprachstapel, den Pfad eines *.zip, *.war, *.jar oder Ordners, der in package bereitgestellt werden soll. Eine vollständige Liste der möglichen Eingaben für die azure/webapps-deploy@v3-Aktion finden Sie in der Definition action.yml.

Die folgenden Beispiele zeigen den Teil des Workflows, in dem die Web-App in den verschiedenen unterstützten Sprachen erstellt wird.

OpenID Connect

Um mit OpenID Connect mithilfe der von Ihnen konfigurierten verwalteten Identität bereitzustellen, verwenden Sie die azure/login@v1-Aktion mit den client-id, tenant-id und subscription-id-Schlüsseln und verweisen Sie auf die zuvor erstellten GitHub-Schlüssel.

ASP.NET Core

name: .NET Core

on: [push]

permissions:
      id-token: write
      contents: read

env:
  AZURE_WEBAPP_NAME: my-app    # set this to your application's name
  AZURE_WEBAPP_PACKAGE_PATH: '.'      # set this to the path to your web app project, defaults to the repository root
  DOTNET_VERSION: '6.0.x'           # set this to the dot net version to use

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      # Checkout the repo
      - uses: actions/checkout@main
      - uses: azure/login@v1
        with:
          client-id: ${{ secrets.AZURE_CLIENT_ID }}
          tenant-id: ${{ secrets.AZURE_TENANT_ID }}
          subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

      
      # Setup .NET Core SDK
      - name: Setup .NET Core
        uses: actions/setup-dotnet@v3
        with:
          dotnet-version: ${{ env.DOTNET_VERSION }} 
      
      # Run dotnet build and publish
      - name: dotnet build and publish
        run: |
          dotnet restore
          dotnet build --configuration Release
          dotnet publish -c Release --property:PublishDir='${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/myapp' 
          
      # Deploy to Azure Web apps
      - name: 'Run Azure webapp deploy action using publish profile credentials'
        uses: azure/webapps-deploy@v3
        with: 
          app-name: ${{ env.AZURE_WEBAPP_NAME }} # Replace with your app name
          package: '${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/myapp'
      
      - name: logout
        run: |
          az logout

ASP.NET

Erstellen Sie eine ASP.NET MVC-App, und stellen Sie sie mithilfe eines Azure-Dienstprinzipals in Azure bereit. Im Beispiel werden GitHub-Geheimnisse für die Werte client-id, tenant-id und subscription-id verwendet. Sie können diese Werte auch direkt in der Anmeldeaktion übergeben.

name: Deploy ASP.NET MVC App deploy to Azure Web App

on: [push]

permissions:
      id-token: write
      contents: read

env:
  AZURE_WEBAPP_NAME: my-app    # set this to your application's name
  AZURE_WEBAPP_PACKAGE_PATH: '.'      # set this to the path to your web app project, defaults to the repository root
  NUGET_VERSION: '5.3.x'           # set this to the dot net version to use

jobs:
  build-and-deploy:
    runs-on: windows-latest
    steps:

    # checkout the repo
    - uses: actions/checkout@main
    
    - uses: azure/login@v1
      with:
        client-id: ${{ secrets.AZURE_CLIENT_ID }}
        tenant-id: ${{ secrets.AZURE_TENANT_ID }}
        subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

    - name: Install Nuget
      uses: nuget/setup-nuget@v1
      with:
        nuget-version: ${{ env.NUGET_VERSION}}
    - name: NuGet to restore dependencies as well as project-specific tools that are specified in the project file
      run: nuget restore
  
    - name: Add msbuild to PATH
      uses: microsoft/setup-msbuild@v1.0.2

    - name: Run MSBuild
      run: msbuild .\SampleWebApplication.sln
       
    - name: 'Run Azure webapp deploy action using publish profile credentials'
      uses: azure/webapps-deploy@v3
      with: 
        app-name: ${{ env.AZURE_WEBAPP_NAME }} # Replace with your app name
        package: '${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/SampleWebApplication/'
  
    # Azure logout 
    - name: logout
      run: |
        az logout

Java SE

Erstellen Sie eine Java Spring-App, und stellen Sie sie mithilfe eines Azure-Dienstprinzipals in Azure bereit. Im Beispiel werden GitHub-Geheimnisse für die Werte client-id, tenant-id und subscription-id verwendet. Sie können diese Werte auch direkt in der Anmeldeaktion übergeben.

name: Java CI with Maven

on: [push]

permissions:
      id-token: write
      contents: read

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v4
    - uses: azure/login@v1
      with:
        client-id: ${{ secrets.AZURE_CLIENT_ID }}
        tenant-id: ${{ secrets.AZURE_TENANT_ID }}
        subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
    - name: Set up JDK 1.8
      uses: actions/setup-java@v3
      with:
        java-version: 1.8
    - name: Build with Maven
      run: mvn -B package --file pom.xml
      working-directory: complete
    - name: Azure WebApp
      uses: Azure/webapps-deploy@v3
      with:
        app-name: my-app-name
        package: my/target/*.jar

    # Azure logout 
    - name: logout
      run: |
        az logout

Tomcat

name: Build and deploy WAR app to Azure Web App using OpenID Connect

env:
  JAVA_VERSION: '11'                  # set this to the Java version to use
  DISTRIBUTION: microsoft             # set this to the Java distribution
  AZURE_WEBAPP_NAME: sampleapp        # set this to the name of your web app

on: [push]

permissions:
  id-token: write
  contents: read

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Set up Java version
        uses: actions/setup-java@v3.0.0
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.DISTRIBUTION }}
          cache: 'maven'

      - name: Build with Maven
        run: mvn clean install

      - name: Login to Azure
        uses: azure/login@v2
        with:
          client-id: ${{ secrets.AZURE_CLIENT_ID }}
          tenant-id: ${{ secrets.AZURE_TENANT_ID }}
          subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

      - name: Deploy to Azure Web App
        id: deploy-to-webapp
        uses: azure/webapps-deploy@v3
        with:
          app-name: ${{ env.AZURE_WEBAPP_NAME }}
          package: '*.war'

Sie finden das vollständige Beispiel für die Verwendung mehrerer Aufträge zum Erstellen und Bereitstellen hier.

Node.js

name: JavaScript CI

on: [push]

permissions:
      id-token: write
      contents: read

name: Node.js

env:
  AZURE_WEBAPP_NAME: my-app   # set this to your application's name
  AZURE_WEBAPP_PACKAGE_PATH: 'my-app-path'      # set this to the path to your web app project, defaults to the repository root
  NODE_VERSION: '18.x'                # set this to the node version to use

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
    # checkout the repo
    - name: 'Checkout GitHub Action' 
      uses: actions/checkout@main
   
    - uses: azure/login@v1
      with:
        client-id: ${{ secrets.AZURE_CLIENT_ID }}
        tenant-id: ${{ secrets.AZURE_TENANT_ID }}
        subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
        
    - name: Setup Node ${{ env.NODE_VERSION }}
      uses: actions/setup-node@v4
      with:
        node-version: ${{ env.NODE_VERSION }}
    
    - name: 'npm install, build, and test'
      run: |
        npm install
        npm run build --if-present
        npm run test --if-present
      working-directory:  my-app-path
               
    # deploy web app using Azure credentials
    - uses: azure/webapps-deploy@v3
      with:
        app-name: ${{ env.AZURE_WEBAPP_NAME }}
        package: ${{ env.AZURE_WEBAPP_PACKAGE_PATH }}

    # Azure logout 
    - name: logout
      run: |
        az logout

Python

name: Python application

on:
  [push]

permissions:
      id-token: write
      contents: read

env:
  AZURE_WEBAPP_NAME: my-app # set this to your application's name
  AZURE_WEBAPP_PACKAGE_PATH: '.' # set this to the path to your web app project, defaults to the repository root

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    
    - uses: azure/login@v1
      with:
        client-id: ${{ secrets.AZURE_CLIENT_ID }}
        tenant-id: ${{ secrets.AZURE_TENANT_ID }}
        subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

    - name: Set up Python 3.x
      uses: actions/setup-python@v4
      with:
        python-version: 3.x
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt
    - name: Deploy web App using GH Action azure/webapps-deploy
      uses: azure/webapps-deploy@v3
      with:
        app-name: ${{ env.AZURE_WEBAPP_NAME }}
        package: ${{ env.AZURE_WEBAPP_PACKAGE_PATH }}
    - name: logout
      run: |
        az logout

Veröffentlichungsprofil

Die publish-profile-Eingabe sollte auf den AZURE_WEBAPP_PUBLISH_PROFILEzuvor erstellten GitHub-Geheimschlüssel verweisen.

ASP.NET Core

name: .NET Core CI

on: [push]

env:
  AZURE_WEBAPP_NAME: my-app-name    # set this to your application's name
  AZURE_WEBAPP_PACKAGE_PATH: '.'      # set this to the path to your web app project, defaults to the repository root
  DOTNET_VERSION: '6.0.x'           # set this to the dot net version to use

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      # Checkout the repo
      - uses: actions/checkout@main
      
      # Setup .NET Core SDK
      - name: Setup .NET Core
        uses: actions/setup-dotnet@v3
        with:
          dotnet-version: ${{ env.DOTNET_VERSION }} 
      
      # Run dotnet build and publish
      - name: dotnet build and publish
        run: |
          dotnet restore
          dotnet build --configuration Release
          dotnet publish -c Release --property:PublishDir='${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/myapp' 
          
      # Deploy to Azure Web apps
      - name: 'Run Azure webapp deploy action using publish profile credentials'
        uses: azure/webapps-deploy@v3
        with: 
          app-name: ${{ env.AZURE_WEBAPP_NAME }} # Replace with your app name
          publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE  }} # Define secret variable in repository settings as per action documentation
          package: '${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/myapp'

ASP.NET

Erstellen Sie eine ASP.NET MVC-App, die NuGet und publish-profile für die Authentifizierung verwendet.

name: Deploy ASP.NET MVC App deploy to Azure Web App

on: [push]

env:
  AZURE_WEBAPP_NAME: my-app    # set this to your application's name
  AZURE_WEBAPP_PACKAGE_PATH: '.'      # set this to the path to your web app project, defaults to the repository root
  NUGET_VERSION: '5.3.x'           # set this to the dot net version to use

jobs:
  build-and-deploy:
    runs-on: windows-latest
    steps:

    - uses: actions/checkout@main  
    
    - name: Install Nuget
      uses: nuget/setup-nuget@v1
      with:
        nuget-version: ${{ env.NUGET_VERSION}}
    - name: NuGet to restore dependencies as well as project-specific tools that are specified in the project file
      run: nuget restore
  
    - name: Add msbuild to PATH
      uses: microsoft/setup-msbuild@v1.0.2

    - name: Run MSBuild
      run: msbuild .\SampleWebApplication.sln
       
    - name: 'Run Azure webapp deploy action using publish profile credentials'
      uses: azure/webapps-deploy@v3
      with: 
        app-name: ${{ env.AZURE_WEBAPP_NAME }} # Replace with your app name
        publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE  }} # Define secret variable in repository settings as per action documentation
        package: '${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/SampleWebApplication/'

Java SE

Erstellen Sie eine Java Spring-App, und stellen Sie sie mithilfe eines Azure-Veröffentlichungsprofils in Azure bereit. Die publish-profile-Eingabe verweist auf das AZURE_WEBAPP_PUBLISH_PROFILE-Geheimnis, das Sie zuvor erstellt haben.

name: Java CI with Maven

on: [push]

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v4
    - name: Set up JDK 1.8
      uses: actions/setup-java@v3
      with:
        java-version: 1.8
    - name: Build with Maven
      run: mvn -B package --file pom.xml
      working-directory: my-app-path
    - name: Azure WebApp
      uses: Azure/webapps-deploy@v3
      with:
        app-name: my-app-name
        publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
        package: my/target/*.jar

Um eine war-Datei anstelle einer jar-Datei bereitzustellen, ändern Sie den package-Wert.

    - name: Azure WebApp
      uses: Azure/webapps-deploy@v3
      with:
        app-name: my-app-name
        publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
        package: my/target/*.war

Tomcat

Erstellen Sie eine Tomcat-App, und stellen Sie sie mithilfe eines Azure-Veröffentlichungsprofils in Azure bereit. Die publish-profile-Eingabe verweist auf das AZURE_WEBAPP_PUBLISH_PROFILE-Geheimnis, das Sie zuvor erstellt haben.

name: Build and deploy WAR app to Azure Web App using publish profile

env:
  JAVA_VERSION: '11'                  # set this to the Java version to use
  DISTRIBUTION: microsoft             # set this to the Java distribution
  AZURE_WEBAPP_NAME: sampleapp        # set this to the name of your web app

on: [push]

permissions:
  id-token: write
  contents: read

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Set up Java version
        uses: actions/setup-java@v3.0.0
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.DISTRIBUTION }}
          cache: 'maven'

      - name: Build with Maven
        run: mvn clean install

      - name: Deploy to Azure Web App
        id: deploy-to-webapp
        uses: azure/webapps-deploy@v3
        with:
          app-name: ${{ env.AZURE_WEBAPP_NAME }}
          publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
          package: '*.war'

Sie finden das vollständige Beispiel für die Verwendung mehrerer Aufträge zum Erstellen und Bereitstellen hier.

Node.js

Erstellen Sie eine Node.js-App, und stellen Sie sie mithilfe des Veröffentlichungsprofils der App in Azure bereit. Die publish-profile-Eingabe verweist auf das AZURE_WEBAPP_PUBLISH_PROFILE-Geheimnis, das Sie zuvor erstellt haben.

# File: .github/workflows/workflow.yml
name: JavaScript CI

on: [push]

env:
  AZURE_WEBAPP_NAME: my-app-name   # set this to your application's name
  AZURE_WEBAPP_PACKAGE_PATH: 'my-app-path'      # set this to the path to your web app project, defaults to the repository root
  NODE_VERSION: '18.x'                # set this to the node version to use

jobs:
  build-and-deploy:
    name: Build and Deploy
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@main
    - name: Use Node.js ${{ env.NODE_VERSION }}
      uses: actions/setup-node@v4
      with:
        node-version: ${{ env.NODE_VERSION }}
    - name: npm install, build, and test
      run: |
        # Build and test the project, then
        # deploy to Azure Web App.
        npm install
        npm run build --if-present
        npm run test --if-present
      working-directory: my-app-path
    - name: 'Deploy to Azure WebApp'
      uses: azure/webapps-deploy@v3
      with: 
        app-name: ${{ env.AZURE_WEBAPP_NAME }}
        publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
        package: ${{ env.AZURE_WEBAPP_PACKAGE_PATH }}

Python

Erstellen Sie eine Python-App, und stellen Sie sie mithilfe des Veröffentlichungsprofils der App in Azure bereit. Beachten Sie, wie die publish-profile-Eingabe auf das AZURE_WEBAPP_PUBLISH_PROFILE-Geheimnis verweist, das Sie zuvor erstellt haben.

name: Python CI

on:
  [push]

env:
  AZURE_WEBAPP_NAME: my-web-app # set this to your application's name
  AZURE_WEBAPP_PACKAGE_PATH: '.' # set this to the path to your web app project, defaults to the repository root

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: Set up Python 3.x
      uses: actions/setup-python@v4
      with:
        python-version: 3.x
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt
    - name: Building web app
      uses: azure/appservice-build@v2
    - name: Deploy web App using GH Action azure/webapps-deploy
      uses: azure/webapps-deploy@v3
      with:
        app-name: ${{ env.AZURE_WEBAPP_NAME }}
        publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
        package: ${{ env.AZURE_WEBAPP_PACKAGE_PATH }}

Dienstprinzipal

Um die Bereitstellung mit dem von Ihnen konfigurierten Dienstprinzipal auszuführen, verwenden Sie die azure/login@v1-Aktion mit dem creds-Schlüssel, und verweisen Sie auf den AZURE_CREDENTIALS Geheimschlüssel, den Sie zuvor erstellt haben.

ASP.NET Core

name: .NET Core

on: [push]

env:
  AZURE_WEBAPP_NAME: my-app    # set this to your application's name
  AZURE_WEBAPP_PACKAGE_PATH: '.'      # set this to the path to your web app project, defaults to the repository root
  DOTNET_VERSION: '6.0.x'           # set this to the dot net version to use

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      # Checkout the repo
      - uses: actions/checkout@main
      - uses: azure/login@v1
        with:
          creds: ${{ secrets.AZURE_CREDENTIALS }}

      
      # Setup .NET Core SDK
      - name: Setup .NET Core
        uses: actions/setup-dotnet@v3
        with:
          dotnet-version: ${{ env.DOTNET_VERSION }} 
      
      # Run dotnet build and publish
      - name: dotnet build and publish
        run: |
          dotnet restore
          dotnet build --configuration Release
          dotnet publish -c Release --property:PublishDir='${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/myapp' 
          
      # Deploy to Azure Web apps
      - name: 'Run Azure webapp deploy action using Azure Credentials'
        uses: azure/webapps-deploy@v3
        with: 
          app-name: ${{ env.AZURE_WEBAPP_NAME }} # Replace with your app name
          package: '${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/myapp'
      
      - name: logout
        run: |
          az logout

ASP.NET

Erstellen Sie eine ASP.NET MVC-App, und stellen Sie sie mithilfe eines Azure-Dienstprinzipals in Azure bereit. Beachten Sie, wie die creds-Eingabe auf das AZURE_CREDENTIALS-Geheimnis verweist, das Sie zuvor erstellt haben.

name: Deploy ASP.NET MVC App deploy to Azure Web App

on: [push]

env:
  AZURE_WEBAPP_NAME: my-app    # set this to your application's name
  AZURE_WEBAPP_PACKAGE_PATH: '.'      # set this to the path to your web app project, defaults to the repository root
  NUGET_VERSION: '5.3.x'           # set this to the dot net version to use

jobs:
  build-and-deploy:
    runs-on: windows-latest
    steps:

    # checkout the repo
    - uses: actions/checkout@main
    
    - uses: azure/login@v1
      with:
        creds: ${{ secrets.AZURE_CREDENTIALS }}

    - name: Install Nuget
      uses: nuget/setup-nuget@v1
      with:
        nuget-version: ${{ env.NUGET_VERSION}}
    - name: NuGet to restore dependencies as well as project-specific tools that are specified in the project file
      run: nuget restore
  
    - name: Add msbuild to PATH
      uses: microsoft/setup-msbuild@v1.0.2

    - name: Run MSBuild
      run: msbuild .\SampleWebApplication.sln
       
    - name: 'Run Azure webapp deploy action using Azure Credentials'
      uses: azure/webapps-deploy@v3
      with: 
        app-name: ${{ env.AZURE_WEBAPP_NAME }} # Replace with your app name
        package: '${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/SampleWebApplication/'
  
    # Azure logout 
    - name: logout
      run: |
        az logout

Java SE

Erstellen Sie eine Java Spring-App, und stellen Sie sie mithilfe eines Azure-Dienstprinzipals in Azure bereit. Beachten Sie, wie die creds-Eingabe auf das AZURE_CREDENTIALS-Geheimnis verweist, das Sie zuvor erstellt haben.

name: Java CI with Maven

on: [push]

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v4
    - uses: azure/login@v1
      with:
        creds: ${{ secrets.AZURE_CREDENTIALS }}
    - name: Set up JDK 1.8
      uses: actions/setup-java@v3
      with:
        java-version: 1.8
    - name: Build with Maven
      run: mvn -B package --file pom.xml
      working-directory: complete
    - name: Azure WebApp
      uses: Azure/webapps-deploy@v3
      with:
        app-name: my-app-name
        package: my/target/*.jar

    # Azure logout 
    - name: logout
      run: |
        az logout

Tomcat

Erstellen Sie eine Tomcat-App und stellen Sie sie mithilfe eines Azure-Dienstprinzipals in Azure bereit. Beachten Sie, wie die creds-Eingabe auf das AZURE_CREDENTIALS-Geheimnis verweist, das Sie zuvor erstellt haben.

name: Build and deploy WAR app to Azure Web App using Service Principal Connect

env:
  JAVA_VERSION: '11'                  # set this to the Java version to use
  DISTRIBUTION: microsoft             # set this to the Java distribution
  AZURE_WEBAPP_NAME: sampleapp        # set this to the name of your web app

on: [push]

permissions:
  contents: read

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Set up Java version
        uses: actions/setup-java@v3.0.0
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: ${{ env.DISTRIBUTION }}
          cache: 'maven'

      - name: Build with Maven
        run: mvn clean install

      - name: Login to Azure
        uses: azure/login@v2
        with:
          creds: ${{ secrets.AZURE_CREDENTIALS }}

      - name: Deploy to Azure Web App
        id: deploy-to-webapp
        uses: azure/webapps-deploy@v3
        with:
          app-name: ${{ env.AZURE_WEBAPP_NAME }}
          package: '*.war'

Sie finden das vollständige Beispiel für die Verwendung mehrerer Aufträge zum Erstellen und Bereitstellen hier.

Node.js

Erstellen Sie eine Node.js-App, und stellen Sie sie mithilfe eines Azure-Dienstprinzipals in Azure bereit. Beachten Sie, wie die creds-Eingabe auf das AZURE_CREDENTIALS-Geheimnis verweist, das Sie zuvor erstellt haben.

name: JavaScript CI

on: [push]

name: Node.js

env:
  AZURE_WEBAPP_NAME: my-app   # set this to your application's name
  AZURE_WEBAPP_PACKAGE_PATH: 'my-app-path'      # set this to the path to your web app project, defaults to the repository root
  NODE_VERSION: '18.x'                # set this to the node version to use

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
    # checkout the repo
    - name: 'Checkout GitHub Action' 
      uses: actions/checkout@main
   
    - uses: azure/login@v1
      with:
        creds: ${{ secrets.AZURE_CREDENTIALS }}
        
    - name: Setup Node ${{ env.NODE_VERSION }}
      uses: actions/setup-node@v4
      with:
        node-version: ${{ env.NODE_VERSION }}
    
    - name: 'npm install, build, and test'
      run: |
        npm install
        npm run build --if-present
        npm run test --if-present
      working-directory:  my-app-path
               
    # deploy web app using Azure credentials
    - uses: azure/webapps-deploy@v3
      with:
        app-name: ${{ env.AZURE_WEBAPP_NAME }}
        package: ${{ env.AZURE_WEBAPP_PACKAGE_PATH }}

    # Azure logout 
    - name: logout
      run: |
        az logout

Python

Erstellen Sie eine Python-App, und stellen Sie sie mithilfe eines Azure-Dienstprinzipals in Azure bereit. Beachten Sie, wie die creds-Eingabe auf das AZURE_CREDENTIALS-Geheimnis verweist, das Sie zuvor erstellt haben.

name: Python application

on:
  [push]

env:
  AZURE_WEBAPP_NAME: my-app # set this to your application's name
  AZURE_WEBAPP_PACKAGE_PATH: '.' # set this to the path to your web app project, defaults to the repository root

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    
    - uses: azure/login@v1
      with:
        creds: ${{ secrets.AZURE_CREDENTIALS }}

    - name: Set up Python 3.x
      uses: actions/setup-python@v4
      with:
        python-version: 3.x
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt
    - name: Deploy web App using GH Action azure/webapps-deploy
      uses: azure/webapps-deploy@v3
      with:
        app-name: ${{ env.AZURE_WEBAPP_NAME }}
        package: ${{ env.AZURE_WEBAPP_PACKAGE_PATH }}
    - name: logout
      run: |
        az logout

Häufig gestellte Fragen

• Wie stelle ich eine WAR-Datei über das Maven-Plug-In bereit?
• Wie stelle ich eine WAR-Datei über die Azure CLI bereit?
• Wie stelle ich eine Startdatei bereit?
• Wie kann ich in einem Container bereitstellen?
• Wie aktualisiere ich die Tomcat-Konfiguration nach der Bereitstellung?

Wie stelle ich eine WAR-Datei über das Maven-Plug-In bereit?

Falls Sie Ihr Java Tomcat-Projekt mit dem Maven-Plug-In konfiguriert haben, können Sie es auch über dieses Plug-In für Azure App Service bereitstellen. Wenn Sie die Azure CLI-GitHub-Aktion verwenden, werden Ihre Azure-Anmeldeinformationen verwendet.

    - name: Azure CLI script file
      uses: azure/cli@v2
      with:
        inlineScript: |
          mvn package azure-webapp:deploy

Weitere Informationen zum Maven-Plug-In und zur Verwendung und Konfiguration finden Sie im Maven-Plug-In-Wiki für Azure App Service.

Wie stelle ich eine WAR-Datei über die Azure CLI bereit?

Wenn Sie die Azure CLI für die Bereitstellung in App Service verwenden, können Sie die GitHub-Aktion für die Azure CLI verwenden.

- name: Azure CLI script
  uses: azure/cli@v2
  with:
    inlineScript: |
      az webapp deploy --src-path '${{ github.workspace }}/target/yourpackage.war' --name ${{ env.AZURE_WEBAPP_NAME }} --resource-group ${{ env.RESOURCE_GROUP }}  --async true --type war

Weitere Informationen zur GitHub-Aktion für CLI und zur Verwendung und Konfiguration finden Sie in der GitHub-Aktion der Azure CLI. Weitere Informationen zum Befehl „az webapp deploy“, zur Verwendung und zu den Parameterdetails finden Sie in der Dokumentation zu „az webapp deploy“.

Wie stelle ich eine Startdatei bereit?

Verwenden Sie die GitHub-Aktion für die CLI. Zum Beispiel:

- name: Deploy startup script
  uses: azure/cli@v2
  with:
    inlineScript: |
      az webapp deploy --src-path ${{ github.workspace }}/src/main/azure/createPasswordlessDataSource.sh --name ${{ env.AZURE_WEBAPP_NAME }} --resource-group ${{ env.RESOURCE_GROUP }} --type startup --track-status false

Wie kann ich in einem Container bereitstellen?

Mit der Azure Web Deploy-Aktion können Sie Ihren Workflow automatisieren, um mithilfe von GitHub Actions benutzerdefinierte App Service-Container bereitzustellen. Ausführliche Informationen zu den Schritten zur Bereitstellung mithilfe von GitHub Actions finden Sie unter In Container bereitstellen.

Wie aktualisiere ich die Tomcat-Konfiguration nach der Bereitstellung?

Falls Sie eine Ihrer Web-Apps-Einstellungen nach der Bereitstellung aktualisieren möchten, können Sie die Aktion App Service-Einstellungen verwenden.

    - uses: azure/appservice-settings@v1
      with:
        app-name: 'my-app'
        slot-name: 'staging'  # Optional and needed only if the settings have to be configured on the specific deployment slot
        app-settings-json: '[{ "name": "CATALINA_OPTS", "value": "-Dfoo=bar" }]' 
        connection-strings-json: '${{ secrets.CONNECTION_STRINGS }}'
        general-settings-json: '{"alwaysOn": "false", "webSocketsEnabled": "true"}' #'General configuration settings as Key Value pairs'
      id: settings

Weitere Informationen zu dieser Aktion und zur Verwendung und Konfiguration finden Sie im Repository App Service-Einstellungen.

Nächste Schritte

Sehen Sie sich die Referenzen zu Azure GitHub Actions und Workflows an:

• Azure/login-Aktion
• Aktion: Azure/webapps-deploy
• Docker/login-Aktion
• Azure/k8s-Bereitstellungsaktion
• Aktionsworkflows für das Bereitstellen in Azure
• Workflows zum Einstieg
• Ereignisse, die Workflows auslösen