Konfigurowanie wdrożenia funkcji GitHub Actions podczas tworzenia aplikacji
Wdrożenie funkcji GitHub Actions jest zintegrowane z domyślnym kreatorem tworzenia aplikacji. Wystarczy ustawić opcję Ciągłe wdrażanie na wartość Włącz na karcie Wdrażanie i skonfigurować odpowiednią organizację, repozytorium i gałąź.
Po włączeniu ciągłego wdrażania kreator tworzenia aplikacji automatycznie wybiera metodę uwierzytelniania na podstawie wyboru uwierzytelniania podstawowego i odpowiednio konfiguruje aplikację i repozytorium GitHub:
Konfigurowanie wdrożenia funkcji GitHub Actions z Centrum wdrażania
W przypadku istniejącej aplikacji możesz szybko rozpocząć pracę z funkcją GitHub Actions przy użyciu Centrum wdrażania usługi App Service. Ta metoda turn-key automatycznie generuje plik przepływu pracy funkcji GitHub Actions na podstawie stosu aplikacji i zatwierdza go w repozytorium GitHub.
Centrum wdrażania umożliwia również łatwe skonfigurowanie bezpieczniejszego uwierzytelniania openID Połączenie przy użyciu opcji tożsamości przypisanej przez użytkownika.
Jeśli twoje konto platformy Azure ma wymagane uprawnienia, możesz wybrać opcję utworzenia tożsamości przypisanej przez użytkownika. W przeciwnym razie możesz wybrać istniejącą tożsamość zarządzaną przypisaną przez użytkownika na liście rozwijanej Tożsamość . Możesz pracować z administratorem platformy Azure, aby utworzyć tożsamość zarządzaną przypisaną przez użytkownika z rolą Współautor witryny internetowej.
Zalecanym sposobem uwierzytelniania za pomocą usług aplikacja systemu Azure Services for GitHub Actions jest użycie tożsamości zarządzanej zdefiniowanej przez użytkownika. Najprostszym sposobem jest skonfigurowanie wdrożenia funkcji GitHub Actions bezpośrednio w portalu i wybranie tożsamości zarządzanej przypisanej przez użytkownika.
Uwaga
Uwierzytelnianie przy użyciu tożsamości zarządzanej przypisanej przez użytkownika jest obecnie dostępne w wersji zapoznawczej.
Alternatywnie możesz uwierzytelnić się za pomocą jednostki usługi, Połączenie OpenID lub profilu publikowania.
Profil publikowania to poświadczenia na poziomie aplikacji. Skonfiguruj profil publikowania jako wpis tajny usługi GitHub.
Przejdź do usługi app service w witrynie Azure Portal.
Na stronie Przegląd wybierz pozycję Pobierz profil publikowania.
Zapisz pobrany plik. Zawartość pliku zostanie użyta do utworzenia wpisu tajnego usługi GitHub.
Uwaga
Od października 2020 r. aplikacje internetowe systemu Linux wymagają ustawienia WEBSITE_WEBDEPLOY_USE_SCM aplikacji ustawionego trueprzed pobraniem profilu publikowania. To wymaganie zostanie usunięte w przyszłości.
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 podobne do poniższego fragmentu kodu JSON. Skopiuj ten obiekt JSON do późniejszego użycia.
Zawsze dobrym rozwiązaniem jest 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.
OpenID Połączenie to metoda uwierzytelniania, która używa tokenów krótkotrwałych. Konfigurowanie Połączenie OpenID za pomocą funkcji GitHub Actions jest bardziej złożone, ale oferuje zabezpieczenia ze wzmocnionymi zabezpieczeniami.
To polecenie zwraca kod JSON z identyfikatorem , który jest twoim client-idelementem appId . Zapisz wartość do użycia jako AZURE_CLIENT_ID wpis tajny usługi GitHub później.
Użyjesz objectId wartości podczas tworzenia poświadczeń federacyjnych przy użyciu interfejsu APPLICATION-OBJECT-IDAPI programu Graph i odwołujesz się do niej jako .
Tworzenie jednostki usługi. Zastąp element $appID identyfikatorem appId z danych wyjściowych JSON.
To polecenie generuje dane wyjściowe JSON z inną objectId wartością i będzie używane w następnym kroku. objectId Nowy element to assignee-object-id.
Skopiuj element appOwnerTenantId , aby użyć go jako wpisu tajnego usługi GitHub do AZURE_TENANT_ID późniejszego użycia.
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 ciąg identyfikatorem subskrypcji nazwą $resourceGroupName grupy zasobów i $assigneeObjectId wygenerowaną assignee-object-idwartością . Dowiedz się , jak zarządzać subskrypcjami platformy Azure przy użyciu interfejsu wiersza polecenia platformy Azure.
az role assignment create --role contributor --subscription $subscriptionId --assignee-object-id $assigneeObjectId --scope /subscriptions/$subscriptionId/resourceGroups/$resourceGroupName/providers/Microsoft.Web/sites/ --assignee-principal-type ServicePrincipal
Uruchom następujące polecenie, aby utworzyć nowe poświadczenia tożsamości federacyjnej dla aplikacji usługi Active Directory.
Zastąp APPLICATION-OBJECT-ID element objectId (wygenerowany podczas tworzenia aplikacji) dla aplikacji usługi Active Directory.
Ustaw wartość dla elementu , CREDENTIAL-NAME aby odwoływać się później.
Ustaw wartość subject. Jego wartość jest definiowana przez usługę GitHub w zależności od przepływu pracy:
Zadania w środowisku funkcji GitHub Actions: 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 żądania ściągnięcia: 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"
]
}
Aby dowiedzieć się, jak utworzyć aplikację usługi Active Directory, jednostkę usługi i poświadczenia federacyjne w witrynie Azure Portal, zobacz Połączenie GitHub i Azure.
W usłudze GitHub przejrzyj repozytorium. Wybierz pozycję Ustawienia > Wpisy tajne zabezpieczeń > i zmienne > Akcje > Nowy wpis tajny repozytorium.
Aby użyć poświadczeń na poziomie aplikacji, wklej zawartość pobranego pliku profilu publikowania w polu wartości wpisu tajnego. Nadaj kluczowi nazwę wpisu tajnego AZURE_WEBAPP_PUBLISH_PROFILE.
Podczas późniejszego konfigurowania pliku przepływu pracy usługi GitHub należy użyć AZURE_WEBAPP_PUBLISH_PROFILE akcji wdróż aplikację internetową platformy Azure. Na przykład:
W usłudze GitHub przejrzyj repozytorium. Wybierz pozycję Ustawienia > Wpisy tajne zabezpieczeń > i zmienne > Akcje > Nowy wpis tajny repozytorium.
Aby użyć poświadczeń na poziomie użytkownika, wklej całe dane wyjściowe JSON z polecenia interfejsu wiersza polecenia platformy Azure do pola wartości wpisu tajnego. Nadaj kluczowi nazwę wpisu tajnego AZURE_CREDENTIALS.
Podczas późniejszego konfigurowania pliku przepływu pracy usługi GitHub należy użyć wpisu tajnego dla danych wejściowych creds platformy Azure/logowania. Na przykład:
Musisz podać identyfikator klienta aplikacji, identyfikator dzierżawy i identyfikator subskrypcji do akcji Azure/login. 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 wpisów tajnych usługi GitHub jest bezpieczniejszą opcją.
Otwórz repozytorium GitHub i przejdź do pozycji Ustawienia > Wpisy tajne zabezpieczeń > i zmienne > Akcje > Nowy wpis tajny repozytorium.
Utwórz wpisy tajne dla , AZURE_CLIENT_IDAZURE_TENANT_IDi AZURE_SUBSCRIPTION_ID. Użyj tych wartości z aplikacji usługi Active Directory dla wpisów tajnych usługi GitHub:
Wpis tajny usługi GitHub
Aplikacja usługi Active Directory
AZURE_CLIENT_ID
Identyfikator aplikacji (klient)
AZURE_TENANT_ID
Identyfikator katalogu (dzierżawcy)
AZURE_SUBSCRIPTION_ID
Identyfikator subskrypcji
Zapisz każdy wpis tajny, wybierając pozycję Dodaj wpis tajny.
3. Dodawanie pliku przepływu pracy do repozytorium GitHub
Przepływ pracy jest definiowany przez plik YAML (.yml) w /.github/workflows/ ścieżce w repozytorium GitHub. Ta definicja zawiera różne kroki i parametry tworzące przepływ pracy.
Plik przepływu pracy musi mieć co najmniej następujące odrębne kroki:
Uwierzytelnianie w usłudze App Service przy użyciu utworzonego wpisu tajnego usługi GitHub.
Skompiluj aplikację internetową.
Wdróż aplikację internetową.
Aby wdrożyć kod w aplikacji usługi App Service, użyj akcji azure/webapps-deploy@v3 . Akcja wymaga nazwy aplikacji internetowej w app-name pliku i, w zależności od stosu języka, ścieżki *.zip, *.war, *.jar lub folderu do wdrożenia w programie package. Aby uzyskać pełną listę możliwych danych wejściowych dla azure/webapps-deploy@v3 akcji, zobacz definicję action.yml .
W poniższych przykładach przedstawiono część przepływu pracy, który kompiluje aplikację internetową w różnych obsługiwanych językach.
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'
Skompiluj i wdróż aplikację ASP.NET MVC, która używa pakietu 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/'
Tworzenie i wdrażanie aplikacji Java Spring 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: 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ć element warjarzamiast , zmień package wartość.
Skompiluj i wdróż aplikację Node.js na platformie Azure przy użyciu profilu publikowania aplikacji. Dane publish-profile wejściowe odwołują się do utworzonego wcześniej wpisu tajnego AZURE_WEBAPP_PUBLISH_PROFILE .
# 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ę, publish-profile jak dane wejściowe odwołują się do utworzonego wcześniej wpisu tajnego AZURE_WEBAPP_PUBLISH_PROFILE .
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 skonfigurowanej jednostki usługi, użyj azure/login@v1 akcji z kluczem creds i odwołaj się do utworzonego wcześniej wpisu 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:
# 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
Skompiluj i wdróż aplikację MVC ASP.NET na platformie Azure przy użyciu jednostki usługi platformy Azure. Zwróć uwagę, creds jak dane wejściowe odwołują się do utworzonego wcześniej wpisu tajnego AZURE_CREDENTIALS .
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
Skompiluj i wdróż aplikację Java Spring na platformie Azure przy użyciu jednostki usługi platformy Azure. Zwróć uwagę, creds jak dane wejściowe odwołują się do utworzonego wcześniej wpisu tajnego AZURE_CREDENTIALS .
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
Tworzenie i wdrażanie aplikacji Node.js na platformie Azure przy użyciu jednostki usługi platformy Azure. Zwróć uwagę, creds jak dane wejściowe odwołują się do utworzonego wcześniej wpisu tajnego AZURE_CREDENTIALS .
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
Skompiluj i wdróż aplikację w języku Python na platformie Azure przy użyciu jednostki usługi platformy Azure. Zwróć uwagę, creds jak dane wejściowe odwołują się do utworzonego wcześniej wpisu tajnego AZURE_CREDENTIALS .
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
Aby wdrożyć przy użyciu identyfikatora OpenID Połączenie przy użyciu skonfigurowanej tożsamości zarządzanej, użyj azure/login@v1 akcji z kluczami client-id, tenant-idi subscription-id odwołaj się do utworzonych wcześniej wpisów tajnych usługi GitHub.
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
Skompiluj i wdróż aplikację MVC ASP.NET na platformie Azure przy użyciu jednostki usługi platformy Azure. W tym przykładzie użyto wpisów tajnych usługi GitHub dla client-idwartości , tenant-idi subscription-id . Te wartości można również przekazać 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:
# 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
Skompiluj i wdróż aplikację Java Spring na platformie Azure przy użyciu jednostki usługi platformy Azure. W tym przykładzie użyto wpisów tajnych usługi GitHub dla client-idwartości , tenant-idi subscription-id . Te wartości można również przekazać bezpośrednio w akcji logowania.
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
Następne kroki
Zapoznaj się z odwołaniami do funkcji Azure GitHub Actions i przepływów pracy:
