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 procesem Tworzenie aplikacji internetowej. Ustaw pozycję Ciągłe wdrażanie na wartość Włącz na karcie Wdrażanie i skonfiguruj odpowiednią organizację, repozytorium i gałąź.

Po włączeniu ciągłego wdrażania tworzenie 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 (OpenID Connect) (zalecane)
Włącz	Uwierzytelnianie podstawowe

Uwaga

Podczas tworzenia aplikacji, której konto platformy Azure nie ma pewnych uprawnień, może wystąpić błąd. Twoje konto może wymagać wymaganych uprawnień do utworzenia i skonfigurowania 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 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 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ą tożsamość zarządzaną przypisaną przez użytkownika w menu rozwijanym 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 wdrożyć bez korzystania z Centrum wdrażania. W takim przypadku należy wykonać trzy kroki:

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

Generowanie poświadczeń wdrożenia

Zalecanym sposobem uwierzytelniania za pomocą usługi aplikacja systemu Azure Services for GitHub Actions jest użycie programu OpenID Connect. Jest to metoda uwierzytelniania, która używa tokenów krótkotrwałych. Konfigurowanie programu OpenID Connect 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ższa procedura zawiera opis kroków 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 Connect GitHub and Azure (Łączenie usług 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 elementem , który jest twoim client-idelementem appId . Zapisz wartość do użycia jako AZURE_CLIENT_ID wpis tajny usługi GitHub później.

   Wartość jest używana objectId podczas tworzenia poświadczeń federacyjnych za pomocą interfejsu API programu Graph i odwoływania się do niej jako .APPLICATION-OBJECT-ID

2. Tworzenie jednostki usługi. Zastąp element $appID identyfikatorem appId z danych wyjściowych JSON.

   To polecenie generuje dane wyjściowe JSON z innym objectId elementem do użycia 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. Usługa GitHub definiuje jego wartość w zależności od przepływu pracy:

     • W przypadku zadań 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. Użyj zawartości pliku, aby utworzyć wpis tajny usługi GitHub.

Uwaga

Od października 2020 r. aplikacje internetowe systemu Linux wymagają ustawienia WEBSITE_WEBDEPLOY_USE_SCM aplikacji ustawionego true na wartość przed 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 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 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.

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 przejdź do repozytorium. Wybierz pozycję Ustawienia>Wpisy tajne zabezpieczeń>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 w polu wartości wpisu tajnego. Nadaj kluczowi nazwę wpisu tajnego AZURE_WEBAPP_PUBLISH_PROFILE.

Po skonfigurowaniu pliku przepływu pracy usługi GitHub użyj 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 przejdź do repozytorium. Wybierz pozycję Ustawienia>Wpisy tajne zabezpieczeń>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 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 użyj wpisu tajnego dla danych wejściowych creds platformy Azure/logowania. 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 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 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ć program OpenID Connect 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 . 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:

    # 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 . 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@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.

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_PROFILE usł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 war jarzamiast , 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.

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. Dane creds 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. Dane creds 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. Dane creds 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.

Node.js

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 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. Dane creds 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?
• Jak mogę wdrożyć plik WAR za pomocą interfejsu wiersza polecenia Az?
• Jak mogę wdrożyć plik startowy?
• Jak mogę wdrożyć w kontenerze?
• Jak mogę zaktualizować konfigurację serwera Tomcat po wdrożeniu?

Jak mogę wdrożyć plik WAR za pomocą wtyczki Maven?

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, korzysta ona z 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 wtyczki Maven i sposobu jej używania i konfigurowania, zobacz witrynę typu wiki wtyczki Maven dla usługi aplikacja systemu Azure Service.

Jak mogę wdrożyć plik WAR za pomocą interfejsu wiersza polecenia Az?

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 platformy Azure.

- 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 akcji usługi GitHub dla interfejsu wiersza polecenia oraz sposobu jej używania i konfigurowania, zobacz Akcja interfejsu wiersza polecenia platformy Azure w usłudze GitHub.

Aby uzyskać więcej informacji na temat polecenia az webapp deploy, jak go używać i szczegółów parametru, zobacz dokumentację az webapp deploy.

Jak mogę wdrożyć plik startowy?

Użyj akcji usługi GitHub dla interfejsu wiersza polecenia. 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 mogę 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 na temat kroków wdrażania przy użyciu funkcji GitHub Actions, 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 tej akcji i sposobu jej używania i konfigurowania, zobacz repozytorium Ustawień usługi App Service.

Powiązana zawartość

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