Compartilhar via


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

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.

Uma captura de tela mostrando como habilitar a implantação do GitHub Actions no assistente de criação do Serviço de Aplicativo.

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.

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

2. Configurar o segredo do GitHub

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.

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.

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.

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

Perguntas frequentes

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: