Implantação no Serviço de Aplicativo usando o GitHub Actions

Introdução ao GitHub Actions para automatizar o fluxo de trabalho e implantar no Serviço de Aplicativo do Azure no GitHub.

Pré-requisitos

• Uma conta do Azure com uma assinatura ativa. Crie uma conta gratuitamente.
• Uma conta do GitHub. Caso ainda não tenha uma, inscreva-se gratuitamente.

Configurar a implantação do GitHub Actions ao criar o aplicativo

A implantação do GitHub Actions é integrada ao assistente de criação de aplicativo padrão. Você só precisa configurar a Implantação contínua para Habilitar na guia Implantação e configurar a organização, o repositório e a ramificação desejada.

Quando você habilita a implantação contínua, o assistente de criação de aplicativo escolhe automaticamente o método de autenticação com base na seleção de autenticação básica e configura seu aplicativo e seu repositório GitHub de acordo:

Seleção básica de autenticação	Método de autenticação
Desabilitar	Identidade atribuída pelo usuário (OpenID Connect) (recomendado)
Habilitar	Autenticação Básica

Observação

Se você receber um erro ao criar seu aplicativo informando que sua conta do Azure não tem determinadas permissões, ela poderá não ter as permissões necessárias para criar e configurar a identidade atribuída pelo usuário. Para obter uma alternativa, confira Configurar a implantação do GitHub Actions no Centro de Implantação.

Configurar a implantação do GitHub Actions no Centro de Implantação

Para um aplicativo existente, você pode começar rapidamente com o GitHub Actions usando o Centro de Implantação do Serviço de Aplicativo. Este método pronto para uso gera automaticamente um arquivo de fluxo de trabalho do GitHub Actions com base na pilha de aplicativos e o envia para o repositório GitHub.

O Centro de Implantação também permite configurar facilmente a autenticação OpenID Connect mais segura com a opção de identidade atribuída pelo usuário.

Se a sua conta do Azure tiver as permissões necessárias, você poderá optar por criar uma identidade atribuída pelo usuário. Caso contrário, poderá selecionar uma identidade gerenciada atribuída pelo usuário existente na lista suspensa Identidade. Você pode trabalhar com o administrador do Azure para criar uma identidade gerenciada atribuída pelo usuário com a função Colaborador do Site.

Para obter mais informações, consulte Implantação contínua no Serviço de Aplicativo do Azure.

Configurar um fluxo de trabalho do GitHub Actions manualmente

Você também pode implantar um fluxo de trabalho sem usar o Centro de Implantação. Nesse caso, você precisa executar três etapas:

1. Gerar as credenciais de implantação
2. Configurar o segredo do GitHub
3. Adicionar o arquivo de fluxo de trabalho ao seu repositório GitHub

1. Gerar as credenciais de implantação

A maneira recomendada de autenticar com os Serviços de Aplicativo do Azure para GitHub Actions é com o OpenID Connect. Este é um método de autenticação que usa tokens de curta duração. Configurar o OpenID Connect com o GitHub Actions é mais complexo, mas oferece segurança reforçada.

Como alternativa, você pode autenticar com uma Identidade Gerenciada atribuída pelo usuário, uma entidade de serviço ou um perfil de publicação.

OpenID Connect

O artigo abaixo mostra a você as etapas de criação de um aplicativo do Active Directory, uma entidade de serviço e credenciais federadas usando instruções da CLI do Azure. Para saber como criar um aplicativo do Active Directory, uma entidade de serviço e credenciais federadas no portal do Azure, confira Conectar o GitHub e o Azure.

1. Se você não tiver um aplicativo existente, registre um novo aplicativo do Active Directory e uma entidade de serviço que possa acessar recursos. Criar o aplicativo do Azure Active Directory.

   az ad app create --display-name myApp
   

   Esse comando gera um JSON com um appId que é seu client-id. Salve o valor para usar mais tarde como o segredo AZURE_CLIENT_ID do GitHub.

   Você usará o valor objectId ao criar credenciais federadas com a API do Graph e ao referenciá-la como o APPLICATION-OBJECT-ID.

2. Crie uma entidade de serviço. Substitua $appID pelo AppID de sua saída JSON.

   Esse comando gera uma saída JSON com um objectId diferente e será usado na próxima etapa. O novo objectId é o assignee-object-id.

   Copie o appOwnerTenantId para usar mais tarde como um segredo do GitHub para AZURE_TENANT_ID.

    az ad sp create --id $appId
   

3. Crie uma atribuição de função por assinatura e objeto. Por padrão, a atribuição de função é vinculada à sua assinatura padrão. Substitua $subscriptionId pela ID da assinatura, $resourceGroupName pelo nome do grupo de recursos, $webappName pelo nome do aplicativo Web e $assigneeObjectId pelo id gerado. Saiba como gerenciar as assinaturas do Azure com a CLI do 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. Execute o comando a seguir para criar uma credencial de identidade federada para seu aplicativo do Active Directory.

   • Substitua APPLICATION-OBJECT-ID pela appId (gerada durante a criação do aplicativo) para o seu aplicativo do Active Directory.
   • Defina um valor de CREDENTIAL-NAME para referência posterior.
   • Defina o subject. Seu valor é definido pelo GitHub dependendo do fluxo de trabalho:
     • Trabalhos em seu ambiente do GitHub Actions: repo:< Organization/Repository >:environment:< Name >
     • Para trabalhos não vinculados a um ambiente, inclua o caminho de referência para ramificação/marca com base no caminho de referência usado para disparar o fluxo de trabalho: repo:< Organization/Repository >:ref:< ref path>. Por exemplo, repo:n-username/ node_express:ref:refs/heads/my-branch ou repo:n-username/ node_express:ref:refs/tags/my-tag.
     • Para fluxos de trabalho disparados por um evento de solicitação de pull: 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"
       ]
   }     
   

Perfil de publicação

Observação

O perfil de publicação requer que a autenticação básica seja habilitada.

Um perfil de publicação é uma credencial de nível de aplicativo. Configure o perfil de publicação como segredo do GitHub.

1. Acesse o serviço de aplicativo no portal do Azure.

2. Na página Visão geral, selecione Obter perfil de publicação.

3. Salve o arquivo baixado. Você usará o conteúdo do arquivo para criar um segredo do GitHub.

Observação

A partir de outubro de 2020, os aplicativos Web do Linux precisam da configuração do aplicativo WEBSITE_WEBDEPLOY_USE_SCM definida como trueantes de baixar o perfil de publicação. Esse requisito será removido no futuro.

Entidade de serviço

Crie uma entidade de serviço com o comando az ad sp create-for-rbac na CLI do Azure. Execute esse comando com o Azure Cloud Shell no portal do Azure ou selecionando o botão Experimentar.

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

No exemplo anterior, substitua os espaços reservados pela ID da assinatura, nome do grupo de recursos e nome do aplicativo. A saída é um objeto JSON com as credenciais de atribuição de função que fornecem acesso ao aplicativo do Serviço de Aplicativo semelhante ao seguinte snippet JSON. Copie esse objeto JSON para uso posterior.

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

Importante

É sempre uma boa prática permitir acesso mínimo. O escopo no exemplo anterior é limitado ao aplicativo do Serviço de Aplicativo e não ao grupo de recursos inteiro.

2. Configurar o segredo do GitHub

OpenID Connect

Você precisa fornecer a ID do cliente, a ID do locatário e a ID da assinatura do seu aplicativo para a ação Azure/login. Esses valores podem ser fornecidos diretamente no fluxo de trabalho ou podem ser armazenados em segredos do GitHub e referenciados em seu fluxo de trabalho. Salvar os valores como segredos do GitHub é a opção mais segura.

1. Abra o repositório GitHub e acesse Configurações > Segurança > Segredos e variáveis > Ações > Novo segredo do repositório.

2. Crie segredos para AZURE_CLIENT_ID, AZURE_TENANT_ID e AZURE_SUBSCRIPTION_ID. Use esses valores do seu aplicativo do Active Directory para seus segredos do GitHub:

   Segredo do GitHub	Aplicativo do AD DS
   AZURE_CLIENT_ID	ID do aplicativo (cliente)
   AZURE_TENANT_ID	ID do diretório (locatário)
   AZURE_SUBSCRIPTION_ID	ID da assinatura

3. Salve cada segredo selecionando Adicionar segredo.

Perfil de publicação

Em GitHub, procure seu repositório. Selecione Configurações > Segurança > Segredos e variáveis > Ações > Novo segredo do repositório.

Para usar as credenciais de nível de aplicativo, cole o conteúdo do arquivo de perfil de publicação baixado no campo de valor do segredo. Nomeie o segredo como AZURE_WEBAPP_PUBLISH_PROFILE.

Ao configurar o arquivo de fluxo de trabalho do GitHub posteriormente, use o AZURE_WEBAPP_PUBLISH_PROFILE na ação implantar o Aplicativo Web do Azure. Por exemplo:

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

Entidade de serviço

Em GitHub, procure seu repositório. Selecione Configurações > Segurança > Segredos e variáveis > Ações > Novo segredo do repositório.

Para usar as credenciais de nível de usuário, cole toda a saída JSON do comando da CLI do Azure no campo de valor do segredo. Nomeie o segredo como AZURE_CREDENTIALS.

Ao configurar o arquivo de fluxo de trabalho do GitHub posteriormente, use o segredo para a entrada creds do Azure/login. Por exemplo:

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

3. Adicionar o arquivo de fluxo de trabalho ao repositório GitHub

Um fluxo de trabalho é definido por um arquivo YAML (.yml) no caminho /.github/workflows/ do seu repositório GitHub. Essa definição contém as várias etapas e os parâmetros que compõem o fluxo de trabalho.

No mínimo, o arquivo de fluxo de trabalho teria as seguintes etapas distintas:

1. Autenticar com o Serviço de Aplicativo usando o segredo do GitHub que você criou.
2. Criar o aplicativo Web.
3. Implantar o aplicativo Web.

Para implementar o seu código em um aplicativo do Serviço de Aplicativo, use a ação azure/webapps-deploy@v3. A ação requer o nome do seu aplicativo Web no app-name e, dependendo da pilha de idiomas, o caminho de um *.zip, *.war, *.jar ou pasta para implantar no package. Para obter uma lista completa de possíveis entradas para a ação azure/webapps-deploy@v3, confira a definição action.yml.

Os exemplos a seguir mostram a parte do fluxo de trabalho que cria o aplicativo Web, nos diferentes idiomas compatíveis.

OpenID Connect

Para implantar com o OpenID Connect usando a identidade gerenciada configurada, use a ação azure/login@v1 com as chaves client-id, tenant-id e subscription-id e faça referência aos segredos do GitHub que você criou anteriormente.

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

Crie e implante um aplicativo ASP.NET MVC no Azure usando uma entidade de serviço do Azure. O exemplo usa segredos do GitHub para os valores client-id, tenant-id e subscription-id. Você também pode passar esses valores diretamente na ação de logon.

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

Crie e implante um aplicativo Java Spring no Azure usando uma entidade de serviço do Azure. O exemplo usa segredos do GitHub para os valores client-id, tenant-id e subscription-id. Você também pode passar esses valores diretamente na ação de logon.

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'

Você também pode encontrar este exemplo completo usando vários trabalhos para compilar e implantar aqui.

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

Perfil de publicação

A entrada publish-profile deve fazer referência ao segredo do GitHub AZURE_WEBAPP_PUBLISH_PROFILE que você criou anteriormente.

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

Crie e implante um aplicativo ASP.NET MVC que usa o NuGet e publish-profile para autenticação.

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

Crie e implante um aplicativo Java Spring no Azure usando um perfil de publicação do Azure. A entrada publish-profile referencia o segredo AZURE_WEBAPP_PUBLISH_PROFILE criado anteriormente.

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

Para implantar um war em vez de um jar, altere o valor package.

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

Tomcat

Crie e implante um aplicativo Tomcat no Azure usando um perfil de publicação do Azure. A entrada publish-profile referencia o segredo AZURE_WEBAPP_PUBLISH_PROFILE criado anteriormente.

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'

Você também pode encontrar este exemplo completo usando vários trabalhos para compilar e implantar aqui.

Node.js

Crie e implante um aplicativo Node.js no Azure usando um perfil de publicação do aplicativo. A entrada publish-profile referencia o segredo AZURE_WEBAPP_PUBLISH_PROFILE criado anteriormente.

# 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

Crie e implante um aplicativo Python no Azure usando um perfil de publicação do aplicativo. Observe como a entrada publish-profile referencia o segredo AZURE_WEBAPP_PUBLISH_PROFILE criado anteriormente.

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

Entidade de serviço

Para implantar com a entidade de serviço configurada, use a ação azure/login@v1 com a chave creds e faça referência ao segredo AZURE_CREDENTIALS que você criou anteriormente.

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

Crie e implante um aplicativo ASP.NET MVC no Azure usando uma entidade de serviço do Azure. Observe como a entrada creds referencia o segredo AZURE_CREDENTIALS criado anteriormente.

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

Crie e implante um aplicativo Java Spring no Azure usando uma entidade de serviço do Azure. Observe como a entrada creds referencia o segredo AZURE_CREDENTIALS criado anteriormente.

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

Crie e implante um aplicativo Tomcat no Azure usando uma entidade de serviço do Azure. Observe como a entrada creds referencia o segredo AZURE_CREDENTIALS criado anteriormente.

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'

Você também pode encontrar este exemplo completo usando vários trabalhos para compilar e implantar aqui.

Node.js

Crie e implante um aplicativo Node.js no Azure usando uma entidade de serviço do Azure. Observe como a entrada creds referencia o segredo AZURE_CREDENTIALS criado anteriormente.

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

Crie e implante um aplicativo Python no Azure usando uma entidade de serviço do Azure. Observe como a entrada creds referencia o segredo AZURE_CREDENTIALS criado anteriormente.

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

Perguntas frequentes

• Como implantar um arquivo WAR por meio do plug-in do Maven e do OpenID Connect
• Como implantar um arquivo WAR por meio da CLI do Az e do OpenID Connect
• Como fazer para implantar em um contêiner
• Como atualizar a configuração do Tomcat após a implantação

Como implantar um arquivo WAR por meio do plug-in do Maven e do OpenID Connect

Caso você tenha configurado o seu projeto Java Tomcat com o plug-in do Maven, você também pode implantar no Serviço de Aplicativo do Azure por meio desse plug-in. Se você usar a ação do GitHub da CLI do Azure, ela usará suas credenciais de logon do Azure.

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

Mais informações sobre o plug-in do Maven e como usá-lo e configurá-lo podem ser encontradas na Wiki do plug-in do Maven para o Serviço de Aplicativo do Azure.

Como fazer para implantar um arquivo WAR por meio da CLI do Az e do OpenID Connect

Se preferir que a CLI do Azure seja implantada no Serviço de Aplicativo, você poderá usar a Ação do GitHub para a CLI.

    - name: Azure CLI script
      uses: azure/cli@v2
      with:
        inlineScript: |
          az webapp deploy --src-path '${{ github.workspace }}/target/yourpackage.war' --name ${{ env.AZURE_WEBAPP_NAME }} --resource-group ${{ env.RESOURCE_GROUP }}  --async true --type war

Mais informações sobre a Ação do GitHub para a CLI e como usá-la e configurá-la podem ser encontradas em Ação do GitHub da CLI do Azure. Mais informações sobre o comando az webapp deploy, como usá-lo e os detalhes do parâmetro podem ser encontrados na documentação do az webapp deploy.

Como fazer para implantar em um contêiner

Com a ação da Implantação da Web do Azure, você pode automatizar seu fluxo de trabalho a fim de implantar contêineres personalizados no Serviço de Aplicativo usando o GitHub Actions. Informações detalhadas sobre as etapas de implantação usando o GitHub Actions podem ser encontradas em Implantação em um contêiner.

Como atualizar a configuração do Tomcat após a implantação

Caso você queira atualizar qualquer uma de suas configurações de aplicativos Web após a implantação, poderá usar a ação Configurações do Serviço de Aplicativo.

    - 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

Mais informações sobre esta ação e como usá-la e configurá-la podem ser encontradas no repositório de Configurações do Serviço de Aplicativo.

Próximas etapas

Confira referências sobre o GitHub Actions e fluxos de trabalho do Azure:

• Ação Azure/login
• Azure/webapps-deploy action
• Ação Docker/login
• Ação Azure/k8s-deploy
• Fluxos de trabalho de ações a serem implantados no Azure
• Fluxos de trabalho iniciais
• Eventos que disparam fluxos de trabalho