Implementar no Serviço de Aplicações através do GitHub Actions

Comece a usar as Ações do GitHub para automatizar seu fluxo de trabalho e implantar no Serviço de Aplicativo do Azure a partir do GitHub.

Pré-requisitos

• Uma conta do Azure com uma subscrição ativa. Crie uma conta gratuitamente.
• Uma conta GitHub. Se não tiver 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 aplicativos padrão. Você só precisa definir Implantação contínua como Habilitar na guia Implantação e configurar a organização, o repositório e a ramificação desejados.

Quando você habilita a implantação contínua, o assistente de criação de aplicativos seleciona 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 de autenticação básica	Método de autenticação
Desativar	Identidade atribuída pelo usuário (OpenID Connect) (recomendado)
Ativar	Autenticação básica

Nota

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

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

Para um aplicativo existente, você pode começar rapidamente com as Ações do GitHub usando o Centro de Implantação do Serviço de Aplicativo. Esse método turn-key gera automaticamente um arquivo de fluxo de trabalho GitHub Actions com base em sua pilha de aplicativos e o confirma em seu repositório GitHub.

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

Se 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, você pode selecionar uma identidade gerenciada atribuída ao usuário existente no menu suspenso Identidade . Você pode trabalhar com o administrador do Azure para criar uma identidade gerenciada atribuída pelo usuário com a função de 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 de Ações do GitHub manualmente

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

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

1. Gerar credenciais de implantação

A maneira recomendada de autenticar com os Serviços de Aplicativo do Azure para Ações do GitHub é 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

A seguir você percorre as etapas para criar um aplicativo de diretório ativo, entidade de serviço e credenciais federadas usando instruções da CLI do Azure. Para saber como criar um aplicativo de diretório ativo, entidade de serviço e credenciais federadas no portal do Azure, consulte Conectar o GitHub e o Azure.

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

   az ad app create --display-name myApp
   

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

   Você usará o valor ao criar credenciais federadas com a API do Graph e fará referência a objectId ele como o APPLICATION-OBJECT-ID.

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

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

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

    az ad sp create --id $appId
   

3. Crie uma nova atribuição de função por assinatura e objeto. Por padrão, a atribuição de função está vinculada à sua assinatura padrão. Substitua $subscriptionId pelo ID da assinatura, $resourceGroupName pelo nome do grupo de recursos, $webappName pelo nome do aplicativo Web e $assigneeObjectId pelo arquivo id. Saiba como gerenciar 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 seguinte comando para criar uma nova credencial de identidade federada para seu aplicativo Ative Directory.

   • Substitua APPLICATION-OBJECT-ID pelo appId (gerado durante a criação do aplicativo) para seu aplicativo do Ative Directory.
   • Defina um valor para CREDENTIAL-NAME referenciar mais tarde.
   • Defina o subjectarquivo . Seu valor é definido pelo GitHub dependendo do seu fluxo de trabalho:
     • Trabalhos em seu ambiente de ações do GitHub: repo:< Organization/Repository >:environment:< Name >
     • Para Trabalhos não vinculados a um ambiente, inclua o caminho ref para ramificação/tag com base no caminho ref usado para acionar 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 acionados por um evento pull request: 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"
       ]
   }     
   

Publicar perfil

Nota

O perfil de publicação requer autenticação básica para ser habilitado.

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

1. Aceda ao serviço da sua aplicação 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.

Nota

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

Principal de serviço

Você pode criar uma entidade de serviço com o comando az ad sp create-for-rbac na CLI do Azure. Execute este 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 seu aplicativo do Serviço de Aplicativo semelhante ao trecho JSON a seguir. Copie este objeto JSON para mais tarde.

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

Importante

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

2. Configure 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 seu repositório GitHub e vá para Configurações > Segredos de segurança > e variáveis > Ações > Novo segredo do repositório.

2. Crie segredos para AZURE_CLIENT_ID, AZURE_TENANT_IDe AZURE_SUBSCRIPTION_ID. Use estes valores do seu aplicativo Ative Directory para seus segredos do GitHub:

   Segredo do GitHub	Aplicativo Ative Directory
   AZURE_CLIENT_ID	ID da aplicação (cliente)
   AZURE_TENANT_ID	ID do Diretório (inquilino)
   AZURE_SUBSCRIPTION_ID	ID de Subscrição

3. Salve cada segredo selecionando Adicionar segredo.

Publicar perfil

No GitHub, navegue pelo repositório. Selecione Configurações > Segredos de segurança > e variáveis > Ações > Novo segredo do repositório.

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

Ao configurar o arquivo de fluxo de trabalho do GitHub posteriormente, você usa a ação implantar o AZURE_WEBAPP_PUBLISH_PROFILE Azure Web App. Por exemplo:

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

Principal de serviço

No GitHub, navegue pelo repositório. Selecione Configurações > Segredos de segurança > e variáveis > Ações > Novo segredo do repositório.

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

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

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

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

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

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

1. Autentique-se com o Serviço de Aplicativo usando o segredo do GitHub que você criou.
2. Crie o aplicativo Web.
3. Implante o aplicativo Web.

Para implantar 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 e app-name , dependendo da sua 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 azure/webapps-deploy@v3 ação, consulte a definição de action.yml .

Os exemplos a seguir mostram a parte do fluxo de trabalho que cria o aplicativo Web, em diferentes idiomas suportados.

OpenID Connect

Para implantar com o OpenID Connect usando a identidade gerenciada que você configurou, use a azure/login@v1 ação com as client-idchaves , tenant-ide subscription-id e faça referência aos segredos do GitHub criados 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 client-idvalores , tenant-ide subscription-id . Você também pode passar esses valores diretamente na ação de login.

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 client-idvalores , tenant-ide subscription-id . Você também pode passar esses valores diretamente na ação de login.

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ê pode encontrar este exemplo completo usando vários trabalhos para criar e implantar aqui também.

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

Publicar perfil

A publish-profile entrada deve fazer referência ao segredo do AZURE_WEBAPP_PUBLISH_PROFILE GitHub 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 MVC ASP.NET que usa 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 publish-profile entrada faz referência ao AZURE_WEBAPP_PUBLISH_PROFILE segredo que você criou 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 package valor.

    - 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 publish-profile entrada faz referência ao AZURE_WEBAPP_PUBLISH_PROFILE segredo que você criou 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ê pode encontrar este exemplo completo usando vários trabalhos para criar e implantar aqui também.

Node.js

Crie e implante um aplicativo Node.js no Azure usando o perfil de publicação do aplicativo. A publish-profile entrada faz referência ao AZURE_WEBAPP_PUBLISH_PROFILE segredo que você criou 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 o perfil de publicação do aplicativo. Observe como a publish-profile entrada faz referência ao AZURE_WEBAPP_PUBLISH_PROFILE segredo que você criou 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 }}

Principal de serviço

Para implantar com a entidade de serviço configurada, use a ação com a creds chave e faça referência ao AZURE_CREDENTIALSazure/login@v1 segredo criado 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 creds entrada faz referência ao AZURE_CREDENTIALS segredo que você criou 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 creds entrada faz referência ao AZURE_CREDENTIALS segredo que você criou 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 creds entrada faz referência ao AZURE_CREDENTIALS segredo que você criou 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ê pode encontrar este exemplo completo usando vários trabalhos para criar e implantar aqui também.

Node.js

Crie e implante um aplicativo Node.js no Azure usando uma entidade de serviço do Azure. Observe como a creds entrada faz referência ao AZURE_CREDENTIALS segredo que você criou 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 creds entrada faz referência ao AZURE_CREDENTIALS segredo que você criou 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 Mais Frequentes

• Como faço para implantar um arquivo WAR através do plugin Maven e do OpenID Connect
• Como faço para implantar um arquivo WAR através da Az CLI e OpenID Connect
• Como faço para implantar em um contêiner
• Como atualizo a configuração do Tomcat após a implantação

Como faço para implantar um arquivo WAR através do plugin Maven e do OpenID Connect

Caso você tenha configurado seu projeto Java Tomcat com o plug-in Maven, também poderá implantar no Serviço de Aplicativo do Azure por meio desse plug-in. Se você usar a ação 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 Maven e como usá-lo e configurá-lo podem ser encontradas no wiki do plug-in Maven para o Serviço de Aplicativo do Azure.

Como faço para implantar um arquivo WAR através da Az CLI e OpenID Connect

Se você preferir a CLI do Azure para implantar no Serviço de Aplicativo, poderá usar a Ação do GitHub para 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 CLI e como usá-la e configurá-la podem ser encontradas na ação GitHub da CLI do Azure. Mais informações sobre o comando az webapp deploy, como usar e os detalhes do parâmetro podem ser encontradas na documentação az webapp deploy.

Como faço para implantar em um contêiner

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

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

Caso deseje atualizar qualquer uma das configurações de seus aplicativos Web após a implantação, você pode 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 essa ação e como usá-la e configurá-la podem ser encontradas no repositório de Configurações do Serviço de Aplicativo.

Próximos passos

Confira as referências sobre Ações e fluxos de trabalho do GitHub do Azure:

• Ação Azure/login
• Ação Azure/webapps-deploy
• Ação Docker/login
• Ação Azure/k8s-deploy
• Fluxos de trabalho de ações para implantar no Azure
• Fluxos de trabalho iniciais
• Eventos que acionam fluxos de trabalho