Tutorial: Usar o GitHub Actions para implantar em um contêiner personalizado do Serviço de Aplicativo e conectar-se a um banco de dados

Artigo
02/21/2024

Este tutorial explica como configurar um fluxo de trabalho GitHub Actions para implantar um aplicativo ASP.NET Core em contêineres com um back-end do Banco de Dados SQL do Azure. Quando terminar, você terá um aplicativo ASP.NET em execução no Azure e conectado ao Banco de Dados SQL. Primeiro, você criará recursos do Azure com um fluxo de trabalho do GitHub Actions de modelo do ARM.

Neste tutorial, você aprenderá como:

Usar um fluxo de trabalho do GitHub Actions para adicionar recursos ao Azure com um modelo do ARM (Azure Resource Manager)
Usar um fluxo de trabalho do GitHub Actions para criar um contêiner com as alterações mais recentes do aplicativo Web

Caso você não tenha uma assinatura do Azure, crie uma conta gratuita do Azure antes de começar.

Pré-requisitos

Para concluir este tutorial, você precisará de:

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.
- Um repositório GitHub para armazenar seus modelos do Resource Manager e seus arquivos de fluxo de trabalho. Para criá-lo, confira Como criar um repositório.

Baixar o exemplo

Bifurcar o projeto de exemplo no repositório de Exemplos do Azure.

https://github.com/Azure-Samples/dotnetcore-containerized-sqldb-ghactions/

Criar o grupo de recursos

Abra o Azure Cloud Shell em https://shell.azure.com. Você pode usar a CLI do Azure se a instalou localmente. (Para obter mais informações sobre Cloud Shell, consulte a Visão Geral da Cloud Shell.)

    az group create --name {resource-group-name} --location {resource-group-location}

Gerar as credenciais de implantação

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 atual, registre um novo aplicativo do Microsoft Entra e uma entidade de serviço que possa acessar recursos.
```
az ad app create --display-name myApp
```
Esse comando produzirá um JSON com um appId que consiste em seu client-id. objectId é referente a APPLICATION-OBJECT-ID e será usado para criar credenciais federadas com as chamadas à API do Graph. Salve o valor para usar mais tarde como o segredo AZURE_CLIENT_ID do GitHub.
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 que será usado na próxima etapa. O novo objectId é o assignee-object-id.

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 sua assinatura, $resourceGroupName pelo nome do seu grupo de recursos e $assigneeObjectId pela assignee-object-id gerada (a ID do objeto da entidade de serviço recém-criada).
```
az role assignment create --role contributor --subscription $subscriptionId --assignee-object-id  $assigneeObjectId --assignee-principal-type ServicePrincipal --scope /subscriptions/$subscriptionId/resourceGroups/$resourceGroupName
```
Execute o comando a seguir a fim de criar uma credencial de identidade federada para o aplicativo do Microsoft Entra.
- Substitua APPLICATION-OBJECT-ID pela objectId (gerada ao criar o aplicativo) do aplicativo do Microsoft Entra.
- 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 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:octo-org/octo-repo:environment:Production",
    "description": "Testing",
    "audiences": [
        "api://AzureADTokenExchange"
    ]
}
```

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.

Configurar o segredo do GitHub para autenticação

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.

No GitHub, acesse seu repositório.
Acesse Configurações no menu de navegação.
Selecione Segurança > Segredos e variáveis > Ações.
Selecione Novo segredo de repositório.
Crie segredos para AZURE_CLIENT_ID, AZURE_TENANT_ID e AZURE_SUBSCRIPTION_ID. Use esses valores do aplicativo Microsoft Entra para seus segredos do GitHub:

Segredo do GitHub Aplicativo do Microsoft Entra

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 Microsoft Entra
AZURE_CLIENT_ID	ID do aplicativo (cliente)
AZURE_TENANT_ID	ID do diretório (locatário)
AZURE_SUBSCRIPTION_ID	ID da assinatura

Adicionar um SQL Server

Crie um novo segredo em seu repositório para SQL_SERVER_ADMIN_PASSWORD. Esse segredo pode ser qualquer senha que atenda aos padrões do Azure para segurança de senha. Você não poderá acessar essa senha novamente, portanto, salve-a separadamente.

Criar recursos do Azure

O fluxo de trabalho criar recursos do Azure executa um modelo do ARM para implantar recursos no Azure. O fluxo de trabalho:

Verifica o código-fonte com a ação Check-out.
Faz logon no Azure com a ação de Logon no Azure e coleta informações de ambiente e recursos do Azure.
Implanta recursos com a ação Implantar do Azure Resource Manager.

Para executar o fluxo de trabalho de criação de recursos do Azure:

Abra o arquivo azuredeploy.yaml no .github/workflows dentro do seu repositório.
Atualize o valor de AZURE_RESOURCE_GROUP para o nome do grupo de recursos.
Atualize os valores de WEB_APP_NAME e SQL_SERVER_NAME para o nome do aplicativo Web e o nome do sql Server.
Vá para Ações e selecione Executar fluxo de trabalho.
Confirme se a ação foi executada com êxito verificando uma marca de seleção verde na página Ações.

Adicionar registro de contêiner e segredos do SQL

No portal do Azure, abra o Registro de Contêiner do Azure recém-criado em seu grupo de recursos.
Acesse as Chaves de acesso e copie os valores de nome de usuário e senha.
Crie novos segredos do GitHub para as senhas ACR_USERNAME e ACR_PASSWORD em seu repositório.
No portal do Azure, abra o banco de dados SQL do Azure. Abra Cadeias de conexão e copie o valor.
Crie um novo segredo para SQL_CONNECTION_STRING. Substitua {your_password} por seu SQL_SERVER_ADMIN_PASSWORD.

Criar, enviar por push e implantar sua imagem

O fluxo de trabalho de compilar, enviar e implantar cria um contêiner com as alterações mais recentes do aplicativo, envia o contêiner para o Registro de Contêiner do Azure e atualiza o slot de preparo do aplicativo Web para apontar para o contêiner mais recente enviado por push. Os contêineres de fluxo de trabalho criam um trabalho de compilação e implantação:

O trabalho de compilação verifica o código-fonte com a ação Check-out. Em seguida, o trabalho usa a ação de logon do Docker e um script personalizado para autenticar com o Registro de Contêiner do Azure, criar uma imagem de contêiner e implantá-la no Registro de Contêiner do Azure.
O trabalho de implantação faz logon no Azure com a ação de Logon no Azure e coleta informações de ambiente e recursos do Azure. O trabalho, em seguida, atualiza as configurações do aplicativo Web com a ação de Configurações do Serviço de Aplicativo do Azure e implanta em um slot de preparo do Serviço de Aplicativo com a ação de Implantação da Web do Azure. Por fim, o trabalho executa um script personalizado para atualizar o banco de dados SQL e troca o slot de preparo para produção.

Para executar o fluxo de trabalho compilar, enviar e implantar:

Abra o arquivo build-deploy.yaml no .github/workflows dentro do seu repositório.
Verifique se as variáveis de ambiente para AZURE_RESOURCE_GROUP e WEB_APP_NAME correspondem àquelas em azuredeploy.yaml.
Atualize o valor ACR_LOGIN_SERVER do servidor de Login do Registro de Contêiner do Azure.

Próximas etapas

Saiba mais sobre a integração do Azure com o GitHub

Compartilhar via