Verwenden Sie GitHub-Aktionen , um Ihren Workflow zu automatisieren und über GitHub auf Azure App Service bereitzustellen.
Voraussetzungen
Einrichten der Bereitstellung von GitHub-Aktionen beim Erstellen einer App
Die Bereitstellung von GitHub Actions ist in den Standardprozess Web-App erstellen integriert. Stellen Sie fortlaufende Bereitstellung auf Aktiviert in der Bereitstellung-Registerkarte ein und konfigurieren Sie Ihre ausgewählte Organisation, das Repository und den Branch.
Wenn Sie eine kontinuierliche Bereitstellung aktivieren, wählt der Create Web App-Prozess automatisch die Authentifizierungsmethode basierend auf der Standardauthentifizierungsauswahl aus und konfiguriert Ihre App und Ihr GitHub-Repository entsprechend:
Einrichten der Bereitstellung von GitHub-Aktionen über das Bereitstellungscenter
Für eine vorhandene App können Sie schnell mit GitHub-Aktionen beginnen, indem Sie das Deployment Center in App Service verwenden. Diese turnkey-Methode generiert eine GitHub Actions-Workflowdatei basierend auf Ihrem Anwendungsstapel und führt einen Commit in Ihr GitHub-Repository durch.
Mithilfe des Bereitstellungscenters können Sie auch die sicherere OpenID Connect-Authentifizierung mit einer vom Benutzer zugewiesenen Identität problemlos konfigurieren. Weitere Informationen finden Sie im Abschnitt zur Option für die benutzerseitig zugewiesene Identität.
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 Dropdownmenü 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-Aktionsworkflows
Sie können einen Workflow bereitstellen, ohne das Deployment Center zu verwenden. Führen Sie die folgenden drei Schritte aus:
-
Generieren Sie Bereitstellungsanmeldeinformationen.
-
Konfigurieren Sie den geheimen GitHub-Schlüssel.
-
Fügen Sie die Workflowdatei zu Ihrem GitHub-Repository hinzu.
Generieren von Anmeldeinformationen für die Bereitstellung
Es wird empfohlen, OpenID Connect zum Authentifizieren mit Azure App Service für GitHub-Aktionen zu verwenden. Diese Authentifizierungsmethode verwendet kurzlebige Token. Einrichten von OpenID Connect mit GitHub Actions ist komplexer, bietet jedoch mehr Sicherheit.
Sie können sich auch mit einer benutzerseitig zugewiesenen verwalteten Identität, einem Dienstprinzipal oder einem Veröffentlichungsprofil authentifizieren.
Das folgende Verfahren beschreibt die Schritte zum Erstellen einer Microsoft Entra-Anwendung, eines Dienstprinzipals und von Verbundanmeldeinformationen mithilfe von Azure CLI-Anweisungen. Informationen zum Erstellen einer Microsoft Entra-Anwendung, eines Dienstprinzipals und von Verbundanmeldeinformationen über das Azure-Portal finden Sie unter Verbinden von GitHub und Azure.
Wenn Sie keine bestehende Anwendung besitzen, registrieren Sie eine neue Microsoft Entra-Anwendung und einen neuen Dienstprinzipal, die auf Ressourcen zugreifen können. Erstellen Sie die Microsoft Entra-Anwendung.
az ad app create --display-name myApp
Dieser Befehl gibt eine JSON-Ausgabe mit einem appId-Wert zurück, 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 auf diese als APPLICATION-OBJECT-ID.
Erstellen Sie einen Dienstprinzipal. Ersetzen Sie $appID durch appId aus Ihrer JSON-Ausgabe.
Dieser Befehl generiert eine JSON-Ausgabe mit einer anderen objectId , die im nächsten Schritt verwendet werden kann. Der neue objectId ist der assignee-object-id.
Kopieren Sie appOwnerTenantId zur späteren Verwendung als GitHub-Geheimnis für AZURE_TENANT_ID.
az ad sp create --id $appId
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 "Website Contributor" --subscription $subscriptionId --assignee-object-id $assigneeObjectId --scope /subscriptions/$subscriptionId/resourceGroups/$resourceGroupName/providers/Microsoft.Web/sites/$webappName --assignee-principal-type ServicePrincipal
Führen Sie den folgenden Befehl aus, um eine neue Verbundidentitäts-Anmeldeinformationen für Ihre Microsoft Entra-App zu erstellen.
Ersetzen Sie den Wert APPLICATION-OBJECT-ID mit dem Wert appId, den Sie während der App-Erstellung für Ihre Active Directory-Anwendung generiert haben.
Legen Sie einen Wert für CREDENTIAL-NAME fest, um später auf ihn zu verweisen.
Legen Sie die subject fest. GitHub legt den Wert in Abhängigkeit von Ihrem Workflow fest:
- Verwenden Sie für Aufträge in Ihrer GitHub-Aktionsumgebung Folgendes:
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.
- Verwenden Sie für Workflows, die durch ein Pullanforderungsereignis 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"
]
}
Ein Veröffentlichungsprofil stellt Anmeldeinformationen auf App-Ebene dar. Richten Sie Ihr Veröffentlichungsprofil als GitHub-Geheimnis ein.
Wechseln Sie im Azure-Portal zu App Service.
Wählen Sie auf der Seite Übersicht die Option Veröffentlichungsprofil herunterladen aus.
Speichern Sie die heruntergeladene Datei. Verwenden Sie zum Erstellen eines GitHub-Geheimnisses 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.
Sie können einen Dienstprinzipal mit dem az ad sp create-for-rbac Befehl in der Azure CLI erstellen. Führen Sie diesen Befehl mithilfe von Azure Cloud Shell im Azure-Portal aus, oder wählen Sie "Cloud Shell öffnen" aus.
az ad sp create-for-rbac --name "myApp" --role "Website 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 Zugriff auf deine App Service-Anwendung gewähren. Die Ausgabe sollte dem folgenden JSON-Codeausschnitt ähneln. Kopieren Sie dieses JSON-Objekt zur späteren Verwendung.
{
"clientId": "<GUID>",
"clientSecret": "<GUID>",
"subscriptionId": "<GUID>",
"tenantId": "<GUID>",
(...)
}
Wichtig
Es wird empfohlen, den Minimalzugriff zu gewähren. Der Bereich im vorherigen Beispiel ist auf die spezifische App Service-App und nicht auf die gesamte Ressourcengruppe beschränkt.
Sie müssen die Client-ID, Mandanten-ID und Abonnement-ID Ihrer Anwendung für die Azure/login Aktion angeben. 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.
Öffnen Sie Ihr GitHub-Repository, und wechseln Sie zu Einstellungen>Sicherheit>Geheimnisse und Variablen>Aktionen>Neues Repositorygeheimnis.
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 |
Active Directory-Anwendung |
AZURE_CLIENT_ID |
Anwendungs-ID (Client) |
AZURE_TENANT_ID |
Verzeichnis-ID (Mandant) |
AZURE_SUBSCRIPTION_ID |
Abonnement-ID |
Wählen Sie "Geheimer Schlüssel hinzufügen" aus, um jeden geheimen Schlüssel zu speichern.
Suchen Sie auf GitHub nach Ihrem Repository. Wählen Sie Einstellungen>Sicherheit>Geheimnisse und Variablen>Aktionen>Neues Repositorygeheimnis aus.
Um die Im vorherigen Abschnitt erstellten Anmeldeinformationen auf App-Ebene zu verwenden, fügen Sie den Inhalt der heruntergeladenen Veröffentlichungsprofildatei in das Wertfeld des geheimen Schlüssels 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 Web App bereitstellen ". Zum Beispiel:
- uses: azure/webapps-deploy@v2
with:
publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
Suchen Sie auf GitHub nach Ihrem Repository. Wählen Sie Einstellungen>Sicherheit>Geheimnisse und Variablen>Aktionen>Neues Repositorygeheimnis aus.
Um die Anmeldeinformationen auf Benutzerebene zu verwenden, die Sie im vorherigen Abschnitt erstellt haben, fügen Sie die gesamte JSON-Ausgabe aus dem Azure CLI-Befehl in das Wertfeld des geheimen Schlüssels ein. Geben Sie dem Geheimnis den Namen AZURE_CREDENTIALS.
Wenn Sie die GitHub-Workflowdatei später konfigurieren, verwenden Sie den geheimen Schlüssel für die Eingabe creds von Azure/login. Zum Beispiel:
- uses: azure/login@v2
with:
creds: ${{ secrets.AZURE_CREDENTIALS }}
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 weist mindestens die folgenden unterschiedlichen Schritte auf:
- Authentifizieren mit App Service mithilfe des von Ihnen erstellten GitHub-Schlüssels.
- Erstellen der Web-App.
- Bereitstellen der Web-App.
Verwenden Sie die azure/webapps-deploy@v3 Aktion, um Ihren Code in einer App Service-App bereitzustellen. 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 Aktion azure/webapps-deploy@v3 finden Sie in action.yml.
Die folgenden Beispiele zeigen den Teil des Workflows, in dem die Web-App in den verschiedenen unterstützten Sprachen erstellt wird.
Um mit der von Ihnen konfigurierten verwalteten Identität OpenID Connect bereitzustellen, verwenden Sie die Aktion azure/login@v2 mit den Schlüsseln client-id, tenant-id und subscription-id. Verweisen Sie auf die zuvor erstellten GitHub-Geheimnisse.
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:
# Check out the repo
- uses: actions/checkout@main
- uses: azure/login@v2
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
Erstellen und Bereitstellen einer ASP.NET-Model View Controller-App (MVC) in Azure mithilfe eines Azure-Dienstprinzipals. 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:
# Check out the repo
- uses: actions/checkout@main
- uses: azure/login@v2
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
Erstellen und Bereitstellen einer Java Spring Boot-App in Azure mithilfe eines Azure-Dienstprinzipals. 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@v2
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
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'
Im Folgenden finden Sie ein vollständiges Beispiel , in dem mehrere Aufträge zum Erstellen und Bereitstellen verwendet werden.
Wichtig
Wenn Sie eine Node.js-App mit TypeScript oder anderen kompilierten Sprachen unter Verwendung von azure/webapps-deploy@v3 bereitstellen, erstellen Sie Ihre App zuerst in GitHub Actions und stellen Sie dann den kompilierten Ausgabeordner (wie zum Beispiel dist/ oder build/) bereit. Wenn Sie stattdessen die App Service-Buildautomatisierung verwenden möchten, legen Sie die SCM_DO_BUILD_DURING_DEPLOYMENT App-Einstellung auf true.
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: '24.x' # Set this to the node version to use
jobs:
build-and-deploy:
runs-on: ubuntu-latest
steps:
# Check out the repo
- name: 'Checkout GitHub Action'
uses: actions/checkout@main
- uses: azure/login@v2
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 by 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
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@v2
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
Die publish-profile-Eingabe sollte auf das zuvor erstellte GitHub-Geheimnis AZURE_WEBAPP_PUBLISH_PROFILE verweisen.
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:
# Check out 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'
Erstellen und Bereitstellen einer ASP.NET Modellansichtscontroller-App (MVC), 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/'
Erstellen und Bereitstellen einer Java Spring Boot-App in Azure mithilfe eines Azure-Veröffentlichungsprofils. 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
Erstellen und Bereitstellen einer Tomcat-App in Azure mithilfe eines Azure-Veröffentlichungsprofils. 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'
Im Folgenden finden Sie ein vollständiges Beispiel , in dem mehrere Aufträge zum Erstellen und Bereitstellen verwendet werden.
Wichtig
Wenn Sie eine Node.js App mit TypeScript oder anderen kompilierten Sprachen mit azure/webapps-deploy@v3 bereitstellen, erstellen Sie Ihre App zunächst in GitHub Actions und stellen dann den kompilierten Ausgabeordner (wie z. B. dist/ oder build/) bereit. Wenn Sie stattdessen die App Service-Build-Automatisierung verwenden möchten, legen Sie die SCM_DO_BUILD_DURING_DEPLOYMENT App-Einstellung auf true.
Erstellen und Bereitstellen einer Node.js-App in Azure mithilfe des Veröffentlichungsprofils der App. 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: '24.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 }}
Erstellen und Bereitstellen einer Python-App in Azure mithilfe des Veröffentlichungsprofils der App. 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 }}
Um die Bereitstellung mit dem von Ihnen konfigurierten Dienstprinzipal auszuführen, verwenden Sie die Aktion azure/login@v2 mit dem Schlüssel creds, und verweisen Sie auf das Geheimnis AZURE_CREDENTIALS, das Sie zuvor erstellt haben.
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:
# Check out the repo
- uses: actions/checkout@main
- uses: azure/login@v2
with:
creds: ${{ secrets.AZURE_CREDENTIALS }}
# Set up .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
Erstellen und Bereitstellen einer ASP.NET-Model View Controller-App (MVC) in Azure mithilfe eines Azure-Dienstprinzipals. Die creds-Eingabe verweist auf das AZURE_CREDENTIALS-Geheimnis, 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:
# Check out the repo
- uses: actions/checkout@main
- uses: azure/login@v2
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
Erstellen und Bereitstellen einer Java Spring Boot-App in Azure mithilfe eines Azure-Dienstprinzipals. Die creds-Eingabe verweist auf das AZURE_CREDENTIALS-Geheimnis, 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@v2
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
Erstellen Sie und stellen Sie eine Tomcat-App in Azure mithilfe eines Azure-Dienstprinzipal bereit. Die creds-Eingabe verweist auf das AZURE_CREDENTIALS-Geheimnis, 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'
Im Folgenden finden Sie ein vollständiges Beispiel , in dem mehrere Aufträge zum Erstellen und Bereitstellen verwendet werden.
Wichtig
Wenn Sie eine Node.js-App mit TypeScript oder anderen kompilierten Sprachen mithilfe von azure/webapps-deploy@v3 bereitstellen, erstellen Sie Ihre App zuerst in GitHub Actions und stellen Sie dann den kompilierten Ausgabeordner (z. B. dist/ oder build/) bereit. Wenn Sie stattdessen die Build-Automatisierung des App Service verwenden möchten, setzen Sie die SCM_DO_BUILD_DURING_DEPLOYMENT App-Einstellung auf true.
Erstellen Sie eine Node.js-App, und stellen Sie sie mithilfe eines Azure-Dienstprinzipals in Azure bereit. Die creds-Eingabe verweist auf das AZURE_CREDENTIALS-Geheimnis, 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: '24.x' # Set this to the node version to use
jobs:
build-and-deploy:
runs-on: ubuntu-latest
steps:
# Check out the repo
- name: 'Checkout GitHub Action'
uses: actions/checkout@main
- uses: azure/login@v2
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
Erstellen und Bereitstellen einer Python-App in Azure mithilfe eines Azure-Dienstprinzipals. Die creds-Eingabe verweist auf das AZURE_CREDENTIALS-Geheimnis, 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@v2
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 kann ich eine WAR-Datei über das Maven-Plug-In bereitstellen?
Wenn 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 GitHub-Aktion der Azure CLI verwenden, werden Ihre Azure-Anmeldeinformationen verwendet.
- name: Azure CLI script file
uses: azure/cli@v2
with:
inlineScript: |
mvn package azure-webapp:deploy
Weitere Informationen zur Verwendung und Konfiguration des Maven-Plug-Ins finden Sie im Maven-Plug-In-Wiki für Azure App Service.
Wie kann ich eine WAR-Datei über die Azure CLI bereitstellen?
Wenn Sie die Azure CLI für die Bereitstellung in App Service verwenden möchten, 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 Verwendung und Konfiguration der GitHub-Aktion für die Azure CLI finden Sie in der Azure CLI-GitHub-Aktion.
Weitere Informationen zum az webapp deploy Befehl, einschließlich der Verwendung des Befehls und der Parameterdetails, finden Sie in az webapp deploy der Dokumentation.
Wie stelle ich eine Startdatei bereit?
Verwenden Sie die GitHub-Aktion für die Azure 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 auf einen Container deployen?
Mit der Azure Web Deploy-Aktion können Sie Ihren Workflow automatisieren, um benutzerdefinierte Container mithilfe von GitHub-Aktionen in App Service bereitzustellen. Weitere Informationen finden Sie unter Bereitstellung in einem Container.
Wie stelle ich einen Slot für die Bereitstellung bereit?
Sie können einen Bereitstellungsslot anstelle des Produktionsslots bereitstellen, indem Sie den Parameter slot-name in der azure/webapps-deploy@v3Aktion verwenden. Um einen Slot bereitzustellen, fügen Sie den Parameter slot-name zum Bereitstellungsschritt in Ihrem Workflow hinzu:
- name: Deploy to Azure Web App
uses: azure/webapps-deploy@v3
with:
app-name: 'my-app-name'
slot-name: 'staging' # Deploy to the 'staging' slot instead of production
package: './output'
Hinweis
Wenn Sie OpenID Connect oder eine Dienstprinzipal-Authentifizierung verwenden, stellen Sie sicher, dass die Identität sowohl für die App als auch für den Bereitstellungs-Slot die Rolle Mitwirkender hat. Für die Profilauthentifizierung, laden Sie das Veröffentlichungsprofil für den spezifischen Slot aus dem Azure-Portal herunter (Bereitstellung>Bereitstellungsplätze> Slot auswählen >Veröffentlichungsprofil herunterladen).
Wie aktualisiere ich die Tomcat-Konfiguration nach der Bereitstellung?
Wenn Sie eine Ihrer Web-Apps-Einstellungen nach der Bereitstellung aktualisieren möchten, können Sie die App Service-Einstellungsaktion 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 zur Verwendung und Konfiguration dieser Aktion finden Sie im App Service-Einstellungsrepository .
Zugehöriger Inhalt
Sehen Sie sich die folgenden Verweise auf Azure GitHub-Aktionen und -Workflows an: