Użyj funkcji GitHub Actions , aby zautomatyzować przepływ pracy i wdrożyć go w usłudze Azure App Service z usługi GitHub.
Wymagania wstępne
Konfigurowanie wdrożenia funkcji GitHub Actions podczas tworzenia aplikacji
Wdrożenie funkcji GitHub Actions jest zintegrowane z domyślnym procesem Tworzenie aplikacji internetowej. Ustaw pozycję Ciągłe wdrażanie na wartość Włącz na karcie Wdrażanie i skonfiguruj wybraną organizację, repozytorium i gałąź.
Po włączeniu ciągłego wdrażania proces Tworzenia aplikacji internetowej automatycznie wybiera metodę uwierzytelniania na podstawie wyboru podstawowego uwierzytelniania i odpowiednio konfiguruje aplikację i repozytorium GitHub:
Skonfiguruj wdrożenie GitHub Actions w Centrum wdrażania
W przypadku istniejącej aplikacji możesz szybko rozpocząć pracę z funkcją GitHub Actions przy użyciu Centrum wdrażania w usłudze App Service. Ta gotowa do użycia metoda generuje plik przepływu pracy funkcji GitHub Actions na podstawie stosu aplikacji i zatwierdza go w repozytorium GitHub.
Za pomocą Centrum wdrażania można również łatwo skonfigurować bezpieczniejsze uwierzytelnianie OpenID Connect przy użyciu tożsamości przypisanej przez użytkownika. Aby uzyskać więcej informacji, zobacz opcję tożsamości przypisanej przez użytkownika.
Jeśli twoje konto platformy Azure ma wymagane uprawnienia, możesz utworzyć tożsamość przypisaną przez użytkownika. W przeciwnym razie możesz wybrać istniejącą przypisaną przez użytkownika tożsamość zarządzaną w menu rozwijanym Tożsamość. Możesz współpracować z administratorem platformy Azure, aby utworzyć tożsamość zarządzaną przypisaną przez użytkownika z rolą Twórca witryny.
Aby uzyskać więcej informacji, zobacz Ciągłe wdrażanie do usługi Azure App Service.
Ręczne konfigurowanie przepływu pracy funkcji GitHub Actions
Przepływ pracy można wdrożyć bez korzystania z Centrum wdrażania. Wykonaj następujące trzy kroki:
-
Generowanie poświadczeń wdrożenia.
-
Skonfiguruj tajny wpis GitHub.
-
Dodaj plik przepływu pracy do repozytorium GitHub.
Generowanie poświadczeń wdrożenia
Zalecamy użycie narzędzia OpenID Connect do uwierzytelniania za pomocą usługi Azure App Service for GitHub Actions. Ta metoda uwierzytelniania używa tokenów krótkotrwałych. Konfigurowanie narzędzi OpenID Connect za pomocą GitHub Actions jest bardziej złożone, ale oferuje wzmocnione zabezpieczenia.
Można również uwierzytelnić się przy użyciu tożsamości zarządzanej przypisanej przez użytkownika, jednostki usługi lub profilu publikowania.
Poniższa procedura zawiera opis kroków tworzenia aplikacji Microsoft Entra, jednostki usługi i poświadczeń federacyjnych za pomocą poleceń Azure CLI. Aby dowiedzieć się, jak utworzyć aplikację Microsoft Entra, jednostkę usługi i poświadczenia federacyjne w portalu Azure, zobacz Łączenie GitHub i Azure.
Jeśli nie masz istniejącej aplikacji, zarejestruj nową aplikację Microsoft Entra oraz usługę główną, która może uzyskiwać dostęp do zasobów. Utwórz aplikację Microsoft Entra.
az ad app create --display-name myApp
To polecenie zwraca dane wyjściowe JSON z appId, które jest twoim client-id. Zapisz wartość do późniejszego użycia jako tajny klucz GitHub AZURE_CLIENT_ID.
Użyj wartości objectId podczas tworzenia poświadczeń federacyjnych za pomocą interfejsu API Graph i odwołuj się do niej jako APPLICATION-OBJECT-ID.
Utwórz jednostkę usługi. Zastąp $appID elementem appId z danych wyjściowych JSON.
To polecenie generuje dane wyjściowe JSON z różnym objectId, które należy użyć w następnym kroku. Nowy objectId to assignee-object-id.
Skopiuj appOwnerTenantId do późniejszego użycia jako tajny klucz GitHub dla AZURE_TENANT_ID.
az ad sp create --id $appId
Utwórz nowe przypisanie roli według subskrypcji i obiektu. Domyślnie przypisanie roli jest powiązane z domyślną subskrypcją. Zastąp $subscriptionId swoim identyfikatorem subskrypcji, $resourceGroupName nazwą swojej grupy zasobów, $webappName nazwą swojej aplikacji internetowej, a $assigneeObjectId wygenerowaną wartością id. Dowiedz się , jak zarządzać subskrypcjami platformy Azure przy użyciu interfejsu wiersza polecenia (CLI).
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
Uruchom następujące polecenie, aby utworzyć nowe poświadczenia tożsamości federacyjnej dla aplikacji Microsoft Entra.
Zastąp APPLICATION-OBJECT-ID wartością appId wygenerowaną podczas tworzenia swojej aplikacji Active Directory.
Ustaw wartość dla elementu CREDENTIAL-NAME, aby odwoływać się do niej później.
Ustaw wartość subject. Usługa GitHub definiuje jego wartość w zależności od przepływu pracy:
- W przypadku zadań w środowisku funkcji GitHub Actions użyj:
repo:< Organization/Repository >:environment:< Name >
- W przypadku zadań, które nie są powiązane ze środowiskiem, dołącz ścieżkę ref dla gałęzi/tagu na podstawie ścieżki ref używanej do wyzwalania przepływu pracy:
repo:< Organization/Repository >:ref:< ref path>. Na przykład: repo:n-username/ node_express:ref:refs/heads/my-branch lub repo:n-username/ node_express:ref:refs/tags/my-tag.
- W przypadku przepływów pracy wyzwalanych przez zdarzenie pull request, użyj:
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"
]
}
Profil publikowania to uprawnienia na poziomie aplikacji. Skonfiguruj profil publikowania jako sekret GitHub.
Przejdź do usługi App Service w witrynie Azure Portal.
Na stronie Przegląd wybierz pozycję Pobierz profil publikacji.
Zapisz pobrany plik. Użyj zawartości pliku, aby utworzyć tajny wpis GitHub.
Uwaga
Od października 2020 r. aplikacje internetowe systemu Linux wymagają, aby ustawienie aplikacji WEBSITE_WEBDEPLOY_USE_SCM było ustawione trueprzed pobraniem profilu publikowania.
"Zasady usługi można utworzyć za pomocą polecenia az ad sp create-for-rbac w interfejsie wiersza polecenia Azure CLI." Uruchom to polecenie przy użyciu usługi Azure Cloud Shell w witrynie Azure Portal lub wybierając pozycję Otwórz usługę Cloud Shell.
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
W poprzednim przykładzie zastąp symbole zastępcze identyfikatorem subskrypcji, nazwą grupy zasobów i nazwą aplikacji. Dane wyjściowe to obiekt JSON z poświadczeniami przypisania roli, które zapewniają dostęp do aplikacji usługi App Service. Dane wyjściowe powinny wyglądać podobnie do poniższego fragmentu kodu JSON. Skopiuj ten obiekt JSON do późniejszego użycia.
{
"clientId": "<GUID>",
"clientSecret": "<GUID>",
"subscriptionId": "<GUID>",
"tenantId": "<GUID>",
(...)
}
Ważne
Zalecamy przyznanie minimalnego dostępu. Zakres w poprzednim przykładzie jest ograniczony do określonej aplikacji usługi App Service, a nie całej grupy zasobów.
Musisz podać identyfikator klienta aplikacji, identyfikator dzierżawy i identyfikator subskrypcji do Azure/login akcji. Te wartości można podać bezpośrednio w przepływie pracy lub przechowywać w wpisach tajnych usługi GitHub i odwoływać się do nich w przepływie pracy. Zapisanie wartości jako sekretów GitHub jest bezpieczniejszą opcją.
Otwórz repozytorium GitHub i przejdź do Ustawienia>Zabezpieczenia>Tajne i zmienne>Akcje>Nowy tajny element repozytorium.
Utwórz wpisy tajne dla AZURE_CLIENT_ID, AZURE_TENANT_ID i AZURE_SUBSCRIPTION_ID. Użyj tych wartości z aplikacji Active Directory dla sekretów GitHub.
| Sekret GitHub |
Aplikacja usługi Active Directory |
AZURE_CLIENT_ID |
Identyfikator aplikacji (klient) |
AZURE_TENANT_ID |
Identyfikator katalogu (najemcy) |
AZURE_SUBSCRIPTION_ID |
Identyfikator subskrypcji |
Wybierz pozycję Dodaj wpis tajny , aby zapisać każdy wpis tajny.
W usłudze GitHub przejdź do repozytorium. Wybierz Ustawienia>Zabezpieczenia>Wpisy tajne i zmienne>Akcje>Nowy wpis tajny repozytorium.
Aby użyć poświadczeń na poziomie aplikacji utworzonych w poprzedniej sekcji, wklej zawartość pobranego pliku profilu publikowania do pola wartości tajnego. Nadaj nazwę sekretowi AZURE_WEBAPP_PUBLISH_PROFILE.
Podczas późniejszego konfigurowania pliku przepływu pracy GitHub użyj elementu AZURE_WEBAPP_PUBLISH_PROFILE w akcji Wdróż aplikację internetową platformy Azure. Na przykład:
- uses: azure/webapps-deploy@v2
with:
publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
W usłudze GitHub przejdź do repozytorium. Wybierz Ustawienia>Zabezpieczenia>Wpisy tajne i zmienne>Akcje>Nowy wpis tajny repozytorium.
Aby użyć poświadczeń na poziomie użytkownika utworzonych w poprzedniej sekcji, wklej całe dane wyjściowe JSON z polecenia Azure CLI do pola wartości sekretu. Nadaj nazwę tajnemu AZURE_CREDENTIALS.
Podczas późniejszego konfigurowania pliku przepływu pracy usługi GitHub użyj tajnego klucza dla danych wejściowych credsAzure/login. Na przykład:
- uses: azure/login@v2
with:
creds: ${{ secrets.AZURE_CREDENTIALS }}
Dodawanie pliku przepływu pracy do repozytorium GitHub
Plik YAML (.yml) w /.github/workflows/ ścieżce w repozytorium GitHub definiuje przepływ pracy. Ta definicja zawiera różne kroki i parametry tworzące przepływ pracy.
Plik przepływu pracy ma co najmniej następujące odrębne kroki:
- Uwierzytelnij się w usłudze App Service przy użyciu utworzonego sekretu GitHub.
- Skompiluj aplikację internetową.
- Wdróż aplikację internetową.
Aby wdróż kod w aplikacji App Service, użyj akcji azure/webapps-deploy@v3. Akcja wymaga nazwy aplikacji internetowej w app-name, a w zależności od stosu języka, ścieżkę *.zip, *.war, *.jar lub folderu do wdrożenia w package. Aby uzyskać pełną listę możliwych danych wejściowych dla azure/webapps-deploy@v3 akcji, zobacz action.yml.
W poniższych przykładach przedstawiono część przepływu pracy, który kompiluje aplikację internetową w różnych obsługiwanych językach.
Aby wdrożyć OpenID Connect, używając skonfigurowanej tożsamości zarządzanej, użyj akcji azure/login@v2 wraz z kluczami client-id, tenant-id i subscription-id. Użyj tajemnic GitHub, które utworzyłeś wcześniej.
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
Skompiluj i wdroż aplikację ASP.NET model-view-controller (MVC) do Azure przy użyciu usługi głównej platformy Azure. W tym przykładzie użyto wpisów tajnych GitHub dla wartości client-id, tenant-id i subscription-id. Możesz również przekazać te wartości bezpośrednio w akcji logowania.
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
Zbuduj i wdroż aplikację Java Spring Boot na Azure przy użyciu zasady usługi Azure. W tym przykładzie użyto sekretów GitHub dla wartości client-id, tenant-id i subscription-id. Możesz również przekazać te wartości bezpośrednio w akcji logowania.
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'
Oto pełny przykład , który używa wielu zadań do kompilowanie i wdrażanie.
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:
# 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
Dane publish-profile wejściowe powinny odwoływać się do utworzonego wcześniej wpisu tajnego AZURE_WEBAPP_PUBLISH_PROFILE usługi GitHub.
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'
Skompiluj i wdróż aplikację ASP.NET model-view-controller (MVC), która używa narzędzia NuGet i publish-profile do uwierzytelniania.
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/'
Skompiluj i wdróż aplikację Java Spring Boot na platformie Azure przy użyciu profilu publikowania platformy Azure. Dane publish-profile wejściowe odnoszą się do utworzonego wcześniej sekretu AZURE_WEBAPP_PUBLISH_PROFILE.
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
Aby wdrożyć war zamiast jar, zmień wartość package.
- 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
Tworzenie i wdrażanie aplikacji Tomcat na platformie Azure przy użyciu profilu publikowania platformy Azure. Dane publish-profile wejściowe odwołują się do utworzonego wcześniej wpisu tajnego AZURE_WEBAPP_PUBLISH_PROFILE .
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'
Oto pełny przykład , który używa wielu zadań do kompilowanie i wdrażanie.
Skompiluj i wdróż aplikację Node.js na platformie Azure przy użyciu profilu publikowania aplikacji.
publish-profile Wejście odnosi się do tajemnicy AZURE_WEBAPP_PUBLISH_PROFILE utworzonej wcześniej.
# 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 }}
Skompiluj i wdróż aplikację w języku Python na platformie Azure przy użyciu profilu publikowania aplikacji. Zwróć uwagę, jak dane wejściowe publish-profile odwołują się do tajemnicy AZURE_WEBAPP_PUBLISH_PROFILE utworzonej wcześniej.
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 }}
Aby wdrożyć przy użyciu skonfigurowanego zasobu usługi, użyj azure/login@v2 akcji z kluczem creds i odwołaj się do utworzonego wcześniej tajnego AZURE_CREDENTIALS.
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
Skompiluj i wdróż aplikację ASP.NET model-view-controller (MVC) na platformie Azure przy użyciu jednostki usługi platformy Azure. Dane wejściowe creds odnoszą się do sekretu AZURE_CREDENTIALS który utworzyłeś wcześniej.
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
Utwórz i wdroż aplikację Java Spring Boot na platformie Azure przy użyciu głównej jednostki usługi Azure. Dane wejściowe creds odwołują się do tajemnicy AZURE_CREDENTIALS utworzonej wcześniej.
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
Zbuduj i wdróż aplikację Tomcat na platformę Azure przy użyciu jednostki usługi Azure. Dane creds wejściowe odwołują się do tajemnicy AZURE_CREDENTIALS utworzonej wcześniej.
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'
Oto pełny przykład , który używa wielu zadań do kompilowanie i wdrażanie.
Tworzenie i wdrażanie aplikacji Node.js na platformie Azure przy użyciu jednostki usługi platformy Azure. Dane creds wejściowe odwołują się do tajemnicy AZURE_CREDENTIALS utworzonej wcześniej.
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:
# 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
Tworzenie i wdrażanie aplikacji Python na platformie Azure przy użyciu zasady usługi Azure. Dane wejściowe creds odnoszą się do tajemnicy AZURE_CREDENTIALS, którą utworzyłeś wcześniej.
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
Najczęściej zadawane pytania
Jak wdrożyć plik WAR za pośrednictwem wtyczki Maven?
Jeśli skonfigurowano projekt Java Tomcat za pomocą wtyczki Maven, możesz również wdrożyć w usłudze Azure App Service za pomocą tej wtyczki. Jeśli używasz akcji GitHub dla interfejsu wiersza polecenia Azure (Azure CLI), korzysta ona z Twoich poświadczeń platformy Azure.
- name: Azure CLI script file
uses: azure/cli@v2
with:
inlineScript: |
mvn package azure-webapp:deploy
Aby uzyskać więcej informacji na temat używania i konfigurowania wtyczki Maven, zobacz witrynę typu wiki wtyczki Maven dla usługi Azure App Service.
Jak wdrożyć plik WAR za pomocą interfejsu wiersza polecenia platformy Azure?
Jeśli wolisz użyć Azure CLI do wdrożenia w usłudze App Service, możesz użyć akcji GitHub dla Azure CLI.
- 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
Aby uzyskać więcej informacji na temat używania i konfigurowania akcji usługi GitHub dla interfejsu wiersza polecenia platformy Azure, zobacz akcję GitHub interfejsu wiersza polecenia platformy Azure.
Aby uzyskać więcej informacji na az webapp deploy temat polecenia, w tym jak go używać oraz szczegółowe informacje o parametrach, zobacz az webapp deploy dokumentację.
Jak mogę wdrożyć plik startowy?
Użyj akcji usługi GitHub dla interfejsu wiersza polecenia platformy Azure. Na przykład:
- 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
Jak wdrożyć w kontenerze?
Za pomocą akcji Azure Web Deploy możesz zautomatyzować przepływ pracy, aby wdrożyć niestandardowe kontenery w usłudze App Service przy użyciu funkcji GitHub Actions. Aby uzyskać więcej informacji, zobacz Wdrażanie w kontenerze.
Jak mogę zaktualizować konfigurację serwera Tomcat po wdrożeniu?
Jeśli chcesz zaktualizować dowolne ustawienia aplikacji internetowych po wdrożeniu, możesz użyć akcji Ustawienia usługi App Service .
- 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
Aby uzyskać więcej informacji na temat używania i konfigurowania tej akcji, zobacz repozytorium ustawień usługi App Service .
Powiązana zawartość
Zapoznaj się z następującymi materiałami dotyczącymi GitHub Actions i przepływów pracy w Azure: