Implantar um contêiner personalizado no Serviço de Aplicativo usando as GitHub Actions

Artigo
06/01/2023

O GitHub Actions oferece a flexibilidade para criar um fluxo de trabalho de desenvolvimento de software automatizado. 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.

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

Para um fluxo de trabalho de contêiner do Serviço de Aplicativo do Azure, o arquivo tem três seções:

Seção	Tarefas
Autenticação	1. Recuperar uma entidade de serviço ou um perfil de publicação. 2. Criar um segredo do GitHub.
Compilar	1. Criar o ambiente. 2. Compilar a imagem de contêiner.
Implantar	1. Implantar a imagem de contêiner.

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. Você precisa ter código em um repositório GitHub para implantar no Serviço de Aplicativo do Azure.
Um registro de contêiner em funcionamento e um aplicativo do Serviço de Aplicativo do Azure para contêineres. Este exemplo usa o Registro de Contêiner do Azure. Conclua toda a implantação do Serviço de Aplicativo do Azure para contêineres. Ao contrário de aplicativos Web regulares, os aplicativos Web para contêineres não têm uma página de aterrissagem padrão. Publique o contêiner para ter um exemplo em funcionamento.
- Aprenda a criar um aplicativo Node.js em contêiner usando o Docker, enviar por push a imagem de contêiner para um Registro e então implantar a imagem no Serviço de Aplicativo do Azure

Gerar as credenciais de implantação

A maneira recomendada de autenticar com os Serviços de Aplicativos do Azure para o GitHub Actions é com um perfil de publicação. A autenticação também pode ser feita com uma entidade de serviço ou com o OpenID Connect, mas o processo requer mais etapas.

Salve a credencial do perfil de publicação ou a entidade de serviço como segredo do GitHub para autenticar com o Azure. Você acessará o segredo no fluxo de trabalho.

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

Acesse o serviço de aplicativo no portal do Azure.
Na página Visão geral, selecione Obter perfil de publicação.

Observação

A partir de outubro de 2020, os aplicativos Web do Linux precisarão da configuração do aplicativo WEBSITE_WEBDEPLOY_USE_SCM definida como true antes de baixar o arquivo. Esse requisito será removido no futuro. Confira Configurar um aplicativo do Serviço de Aplicativo no portal do Azure para saber como definir configurações comuns do aplicativo Web.
Salve o arquivo baixado. Você usará o conteúdo do arquivo para criar um segredo do GitHub.

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

O OpenID Connect é um método de autenticação que usa tokens de curta duração. A configuração do OpenID Connect com o GitHub Actions é um processo mais complexo que oferece segurança aprimorada.

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 produzirá um JSON com um appId que consiste em 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.
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
```
Crie uma atribuição de função por assinatura e objeto. Por padrão, a atribuição de função será vinculada à sua assinatura padrão. Substitua $subscriptionId pela ID da assinatura, $resourceGroupName pelo nome do grupo de recursos e $assigneeObjectId pelo assignee-object-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 --assignee-principal-type ServicePrincipal --scopes /subscriptions/$subscriptionId/resourceGroups/$resourceGroupName/providers/Microsoft.Web/sites/
```
Execute o comando a seguir para criar uma credencial de identidade federada para seu aplicativo do Active Directory.
- Substitua APPLICATION-OBJECT-ID pelo objectId (gerado durante a criação do aplicativo) do aplicativo Active Directory.
- Defina um valor de CREDENTIAL-NAME para referência posterior.
- Defina o subject. O valor disso é definido pelo GitHub dependendo do seu 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 rest --method POST --uri 'https://graph.microsoft.com/beta/applications/<APPLICATION-OBJECT-ID>/federatedIdentityCredentials' --body '{"name":"<CREDENTIAL-NAME>","issuer":"https://token.actions.githubusercontent.com","subject":"repo:organization/repository:ref:refs/heads/main","description":"Testing","audiences":["api://AzureADTokenExchange"]}' 
```
Para saber como criar um aplicativo Active Directory, uma entidade de serviço e as credenciais federadas no portal do Azure, confira Conexão entre GitHub e Azure.

Configurar o segredo do GitHub para autenticaçã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 fluxo de trabalho do GitHub, você usará o AZURE_WEBAPP_PUBLISH_PROFILE na ação Implantar aplicativo Web do Azure. Por exemplo:

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

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. Dê ao segredo um nome como AZURE_CREDENTIALS.

Ao configurar o arquivo de fluxo de trabalho posteriormente, você usa o segredo para o creds de entrada da ação de Logon do Azure. Por exemplo:

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

Você precisa fornecer a ID do cliente, a ID do locatário e a ID da assinatura do seu aplicativo para a ação de logon. 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.

Abra o repositório GitHub e acesse Configurações > Segurança > Segredos e variáveis > Ações > Novo segredo do repositório.
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. Você pode encontrar os valores no portal do Azure pesquisando seu aplicativo do Active Directory.

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
Salve cada segredo selecionando Adicionar segredo.

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

Configurar segredos do GitHub para o registro

Defina os segredos a serem usados com a ação de logon do Docker. O exemplo neste documento usa o Registro de Contêiner do Azure para o registro de contêiner.

Vá para o contêiner no portal do Azure ou no Docker e copie o nome de usuário e a senha. Você pode encontrar o nome de usuário e a senha do Registro de Contêiner do Azure no portal do Azure em Configurações>Chaves de acesso para o registro.
Defina um novo segredo para o nome de usuário do registro chamado REGISTRY_USERNAME.
Defina um novo segredo para a senha do registro chamada REGISTRY_PASSWORD.

Compilar a imagem de contêiner

O exemplo a seguir mostra parte do fluxo de trabalho que cria uma imagem do Docker em Node.JS. Use o Logon do Docker para fazer logon em um registro de contêiner privado. Este exemplo usa o Registro de Contêiner do Azure, mas a mesma ação funciona para outros registros.

name: Linux Container Node Workflow

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2
    - uses: azure/docker-login@v1
      with:
        login-server: mycontainer.azurecr.io
        username: ${{ secrets.REGISTRY_USERNAME }}
        password: ${{ secrets.REGISTRY_PASSWORD }}
    - run: |
        docker build . -t mycontainer.azurecr.io/myapp:${{ github.sha }}
        docker push mycontainer.azurecr.io/myapp:${{ github.sha }}

Você também pode usar o Logon do Docker para fazer logon em vários registros de contêiner ao mesmo tempo. Este exemplo inclui dois novos segredos do GitHub para autenticação com docker.io. O exemplo supõe que haja um Dockerfile no nível da raiz do registro.

name: Linux Container Node Workflow

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2
    - uses: azure/docker-login@v1
      with:
        login-server: mycontainer.azurecr.io
        username: ${{ secrets.REGISTRY_USERNAME }}
        password: ${{ secrets.REGISTRY_PASSWORD }}
    - uses: azure/docker-login@v1
      with:
        login-server: index.docker.io
        username: ${{ secrets.DOCKERIO_USERNAME }}
        password: ${{ secrets.DOCKERIO_PASSWORD }}
    - run: |
        docker build . -t mycontainer.azurecr.io/myapp:${{ github.sha }}
        docker push mycontainer.azurecr.io/myapp:${{ github.sha }}

Implantar em um contêiner do Serviço de Aplicativo

Para implantar a imagem em um contêiner personalizado no Serviço de Aplicativo, use a ação azure/webapps-deploy@v2. Essa ação tem sete parâmetros:

Parâmetro	Explicação
app-name	(Obrigatório) Nome do aplicativo do Serviço de Aplicativo
publish-profile	(Opcional) Aplica-se a Aplicativos Web (Windows e Linux) e a Contêineres de Aplicativos Web (Linux). Não há suporte a cenários de vários contêineres. Conteúdo de arquivo de perfil de publicação (*.publishsettings) com segredos da Implantação da Web
slot-name	(Opcional) Insira um slot existente que não seja o slot de produção
package	(Opcional) Aplica-se somente ao Aplicativo Web: caminho para pacote ou pasta. .zip, .war, *.jar ou uma pasta a ser implantada
images	(Obrigatório) Aplica-se somente a Contêineres do Aplicativo Web: especifique o nome das imagens do contêiner totalmente qualificado. Por exemplo, 'myregistry.azurecr.io/nginx:latest' ou 'python:3.7.2-alpine/'. Para um aplicativo de vários contêineres, vários nomes de imagem de contêiner podem ser fornecidos (separados por várias linhas)
configuration-file	(Opcional) Aplica-se somente a contêineres de Aplicativo Web: caminho do arquivo Docker-Compose. Deve ser um caminho totalmente qualificado ou relativo ao diretório de trabalho padrão. Obrigatório para aplicativos de vários contêineres.
startup-command	(Opcional) Insira o comando de inicialização. Por exemplo, dotnet run ou dotnet filename.dll

name: Linux Container Node Workflow

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2

    - uses: azure/docker-login@v1
      with:
        login-server: mycontainer.azurecr.io
        username: ${{ secrets.REGISTRY_USERNAME }}
        password: ${{ secrets.REGISTRY_PASSWORD }}

    - run: |
        docker build . -t mycontainer.azurecr.io/myapp:${{ github.sha }}
        docker push mycontainer.azurecr.io/myapp:${{ github.sha }}     

    - uses: azure/webapps-deploy@v2
      with:
        app-name: 'myapp'
        publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
        images: 'mycontainer.azurecr.io/myapp:${{ github.sha }}'

on: [push]

name: Linux_Container_Node_Workflow

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
    # checkout the repo
    - name: 'Checkout GitHub Action' 
      uses: actions/checkout@main
    
    - name: 'Sign in via Azure CLI'
      uses: azure/login@v1
      with:
        creds: ${{ secrets.AZURE_CREDENTIALS }}
    
    - uses: azure/docker-login@v1
      with:
        login-server: mycontainer.azurecr.io
        username: ${{ secrets.REGISTRY_USERNAME }}
        password: ${{ secrets.REGISTRY_PASSWORD }}
    - run: |
        docker build . -t mycontainer.azurecr.io/myapp:${{ github.sha }}
        docker push mycontainer.azurecr.io/myapp:${{ github.sha }}     
      
    - uses: azure/webapps-deploy@v2
      with:
        app-name: 'myapp'
        images: 'mycontainer.azurecr.io/myapp:${{ github.sha }}'
    
    - name: Azure logout
      run: |
        az logout

on: [push]
name: Linux_Container_Node_Workflow

permissions:
      id-token: write
      contents: read

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
    # checkout the repo
    - name: 'Checkout GitHub Action' 
      uses: actions/checkout@main
    
    - name: 'Sign in via Azure CLI'
      uses: azure/login@v1
      with:
        client-id: ${{ secrets.AZURE_CLIENT_ID }}
        tenant-id: ${{ secrets.AZURE_TENANT_ID }}
        subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
    
    - uses: azure/docker-login@v1
      with:
        login-server: mycontainer.azurecr.io
        username: ${{ secrets.REGISTRY_USERNAME }}
        password: ${{ secrets.REGISTRY_PASSWORD }}
    - run: |
        docker build . -t mycontainer.azurecr.io/myapp:${{ github.sha }}
        docker push mycontainer.azurecr.io/myapp:${{ github.sha }}     
      
    - uses: azure/webapps-deploy@v2
      with:
        app-name: 'myapp'
        images: 'mycontainer.azurecr.io/myapp:${{ github.sha }}'
    
    - name: Azure logout
      run: |
        az logout

Próximas etapas

Encontre nosso conjunto de ações agrupadas em diferentes repositórios no GitHub, cada um contendo documentação e exemplos para ajudar você a usar o GitHub para CI/CD e implantar seus aplicativos no Azure.

Compartilhar via