Wdrażanie w usłudze App Service przy użyciu funkcji GitHub Actions

Rozpocznij pracę z funkcją GitHub Actions, aby zautomatyzować przepływ pracy i wdrożyć go w usłudze aplikacja systemu Azure z usługi GitHub.

Wymagania wstępne

• Konto platformy Azure z aktywną subskrypcją. Utwórz konto bezpłatnie.
• Konto usługi GitHub. Jeśli nie masz takiego konta, zarejestruj się bezpłatnie.

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:

Wybór uwierzytelniania podstawowego	Metoda uwierzytelniania
Wyłącz	Tożsamość przypisana przez użytkownika (Połączenie OpenID) (zalecane)
Włącz	Uwierzytelnianie podstawowe

Uwaga

Jeśli podczas tworzenia aplikacji wystąpi błąd informujący, że twoje konto platformy Azure nie ma pewnych uprawnień, może nie mieć wymaganych uprawnień do tworzenia i konfigurowania tożsamości przypisanej przez użytkownika. Aby uzyskać alternatywę, zobacz Konfigurowanie wdrożenia funkcji GitHub Actions z Centrum wdrażania.

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.

Aby uzyskać więcej informacji, zobacz Ciągłe wdrażanie w usłudze aplikacja systemu Azure Service.

Ręczne konfigurowanie przepływu pracy funkcji GitHub Actions

Przepływ pracy można również wdrożyć bez korzystania z Centrum wdrażania. W takim przypadku należy wykonać 3 kroki:

1. Generowanie poświadczeń wdrożenia
2. Konfigurowanie wpisu tajnego usługi GitHub
3. Dodawanie pliku przepływu pracy do repozytorium GitHub

1. Generowanie poświadczeń wdrożenia

Zalecanym sposobem uwierzytelniania za pomocą usług aplikacja systemu Azure Services for GitHub Actions jest użycie Połączenie OpenID. Jest 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.

Alternatywnie można uwierzytelnić się przy użyciu tożsamości zarządzanej przypisanej przez użytkownika, jednostki usługi lub profilu publikowania.

OpenID Connect

Poniżej przedstawiono procedurę tworzenia aplikacji usługi Active Directory, jednostki usługi i poświadczeń federacyjnych przy użyciu instrukcji interfejsu wiersza polecenia platformy Azure. 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.

1. Jeśli nie masz istniejącej aplikacji, zarejestruj nową aplikację usługi Active Directory i jednostkę usługi, która może uzyskiwać dostęp do zasobów. Utwórz aplikację usługi Active Directory.

   az ad app create --display-name myApp
   

   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 .

2. 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
   

3. 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, $webappName nazwą aplikacji internetowej i $assigneeObjectId wygenerowaną 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/$webappName --assignee-principal-type ServicePrincipal
   

4. 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 ciąg wartością appId (wygenerowaną 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"
       ]
   }     
   

Publikowanie profilu

Uwaga

Profil publikowania wymaga włączenia uwierzytelniania podstawowego.

Profil publikowania to poświadczenia na poziomie aplikacji. Skonfiguruj profil publikowania jako wpis tajny usługi GitHub.

1. Przejdź do usługi app service w witrynie Azure Portal.

2. Na stronie Przegląd wybierz pozycję Pobierz profil publikowania.

3. 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.

Jednostka usługi

Jednostkę usługi można utworzyć za pomocą polecenia az ad sp create-for-rbac w interfejsie wiersza polecenia platformy Azure. Uruchom to polecenie za pomocą usługi Azure Cloud Shell w witrynie Azure Portal lub wybierając przycisk Wypróbuj .

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.

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

Ważne

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.

2. Konfigurowanie wpisu tajnego usługi GitHub

OpenID Connect

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ą.

1. Otwórz repozytorium GitHub i przejdź do pozycji Ustawienia > Wpisy tajne zabezpieczeń > i zmienne > Akcje > Nowy wpis tajny repozytorium.

2. 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

3. Zapisz każdy wpis tajny, wybierając pozycję Dodaj wpis tajny.

Publikowanie profilu

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:

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

Jednostka usługi

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:

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

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:

1. Uwierzytelnianie w usłudze App Service przy użyciu utworzonego wpisu tajnego usługi GitHub.
2. Skompiluj aplikację internetową.
3. 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.

OpenID Connect

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.

ASP.NET Core

name: .NET Core

on: [push]

permissions:
      id-token: write
      contents: read

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

jobs:
  build:
    runs-on: ubuntu-latest

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

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

ASP.NET

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

Java SE

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: Java CI with Maven

on: [push]

permissions:
      id-token: write
      contents: read

jobs:
  build:

    runs-on: ubuntu-latest

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

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

Tomcat

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

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

on: [push]

permissions:
  id-token: write
  contents: read

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

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

      - name: Build with Maven
        run: mvn clean install

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

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

Ten pełny przykład można znaleźć przy użyciu wielu zadań do kompilowanie i wdrażanie w tym miejscu .

Node.js

name: JavaScript CI

on: [push]

permissions:
      id-token: write
      contents: read

name: Node.js

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

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

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

Python

name: Python application

on:
  [push]

permissions:
      id-token: write
      contents: read

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

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

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

Publikowanie profilu

Dane publish-profile wejściowe powinny odwoływać się do utworzonego wcześniej wpisu tajnego AZURE_WEBAPP_PUBLISH_PROFILEusługi GitHub.

ASP.NET Core

name: .NET Core CI

on: [push]

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

jobs:
  build:
    runs-on: ubuntu-latest

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

ASP.NET

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/'

Java SE

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ść.

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

Tomcat

Kompilowanie 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'

Ten pełny przykład można znaleźć przy użyciu wielu zadań do kompilowanie i wdrażanie w tym miejscu .

Node.js

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 }}

Python

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 }}

Jednostka usługi

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.

ASP.NET Core

name: .NET Core

on: [push]

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

jobs:
  build:
    runs-on: ubuntu-latest

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

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

ASP.NET

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

Java SE

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

Tomcat

Kompilowanie i wdrażanie aplikacji Tomcat 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: 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'

Ten pełny przykład można znaleźć przy użyciu wielu zadań do kompilowanie i wdrażanie w tym miejscu .

Node.js

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

Python

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

Często zadawane pytania

• Jak mogę wdrożyć plik WAR za pomocą wtyczki Maven i Połączenie OpenID
• Jak mogę wdrożyć plik WAR za pomocą interfejsu wiersza polecenia Az i Połączenie OpenID
• Jak mogę wdrażanie w kontenerze
• Jak mogę zaktualizować konfigurację serwera Tomcat po wdrożeniu

Jak mogę wdrożyć plik WAR za pomocą wtyczki Maven i Połączenie OpenID

Jeśli skonfigurowano projekt Java Tomcat za pomocą wtyczki Maven, możesz również wdrożyć go w usłudze aplikacja systemu Azure za pomocą tej wtyczki. Jeśli używasz akcji GitHub interfejsu wiersza polecenia platformy Azure, użyjesz poświadczeń logowania platformy Azure.

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

Więcej informacji na temat wtyczki Maven oraz sposobu jej używania i konfigurowania można znaleźć w witrynie typu wiki wtyczki Maven dla usługi aplikacja systemu Azure Service.

Jak mogę wdrożyć plik WAR za pomocą interfejsu wiersza polecenia Az i Połączenie OpenID

Jeśli wolisz wdrożyć interfejs wiersza polecenia platformy Azure w usłudze App Service, możesz użyć akcji usługi GitHub dla interfejsu wiersza polecenia.

    - 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

Więcej informacji na temat akcji usługi GitHub dla interfejsu wiersza polecenia oraz sposobu jej używania i konfigurowania można znaleźć w akcji GitHub interfejsu wiersza polecenia platformy Azure. Więcej informacji na temat polecenia az webapp deploy, how to use i szczegóły parametru można znaleźć w dokumentacji az webapp deploy.

Jak mogę wdrażanie 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. Szczegółowe informacje na temat kroków wdrażania przy użyciu funkcji GitHub Actions można znaleźć w temacie 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

Więcej informacji na temat tej akcji oraz sposobu jej używania i konfigurowania można znaleźć w repozytorium usługi App Service Ustawienia.

Następne kroki

Zapoznaj się z odwołaniami do funkcji Azure GitHub Actions i przepływów pracy:

• Akcja platformy Azure/logowania
• Akcja azure/webapps-deploy
• Akcja platformy Docker/logowania
• Akcja azure/k8s-deploy
• Przepływy pracy akcji do wdrożenia na platformie Azure
• Początkowe przepływy pracy
• Zdarzenia wyzwalające przepływy pracy