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:
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.
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.
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.
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.
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.
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
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
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"
]
}
Ein Veröffentlichungsprofil stellt Anmeldeinformationen auf App-Ebene dar. Richten Sie Ihr Veröffentlichungsprofil als GitHub-Geheimnis ein.
Wechseln Sie im Azure-Portal zu Ihrem App Service.
Wählen Sie auf der Seite Übersicht die Option Veröffentlichungsprofil abrufen.
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.
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.
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.
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.
Ö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
Eine Active Directory-Anwendung
AZURE_CLIENT_ID
Anwendungs-ID (Client)
AZURE_TENANT_ID
Verzeichnis-ID (Mandant)
AZURE_SUBSCRIPTION_ID
Abonnement-ID
Speichern Sie jedes Geheimnis, indem Sie Geheimnis hinzufügen auswählen.
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:
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:
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:
Authentifizieren Sie sich bei App Service mit dem von Ihnen erstellten GitHub-Geheimschlüssel.
Erstellen der Web-App.
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.
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.
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
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
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: 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.
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
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
Die publish-profile-Eingabe sollte auf den AZURE_WEBAPP_PUBLISH_PROFILEzuvor erstellten GitHub-Geheimschlüssel 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:
# 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'
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/'
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.
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.
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 }}
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 }}
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.
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
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
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
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.
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
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
Wie kann ich eine WAR-Datei über das Maven-Plug-In und OpenID Connect bereitstellen
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.
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 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:
