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

Artigo
02/23/2024

Este tutorial orienta você na configuração de um fluxo de trabalho de Ações do GitHub para implantar um aplicativo ASP.NET Core em contêiner 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 de Ações do GitHub de modelo ARM.

Neste tutorial, irá aprender a:

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

Se não tiver uma subscrição do Azure, crie uma conta gratuita do Azure antes de começar.

Pré-requisitos

Para concluir este tutorial, você precisará:

Uma conta do Azure com uma subscrição ativa. Crie uma conta gratuitamente.
Uma conta GitHub. Se não tiver uma, inscreva-se gratuitamente.
- Um repositório GitHub para armazenar seus modelos do Resource Manager e seus arquivos de fluxo de trabalho. Para criar um, consulte Criando um novo repositório.

Transferir o exemplo

Bifurque 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 alternadamente a CLI do Azure se a tiver instalado localmente. (Para obter mais informações sobre o Cloud Shell, consulte a Visão geral do Cloud Shell.)

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

Gerar credenciais de implantação

OpenID Connect é um método de autenticação que usa tokens de curta duração. Configurar o OpenID Connect com o GitHub Actions é um processo mais complexo que oferece segurança reforçada.

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

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
```
Crie uma nova 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 gerado assignee-object-id (a ID do objeto principal 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 seguinte comando para criar uma nova credencial de identidade federada para seu aplicativo Microsoft Entra.
- Substitua APPLICATION-OBJECT-ID pelo objectId (gerado durante a criação do aplicativo) para seu aplicativo Microsoft Entra.
- Defina um valor para CREDENTIAL-NAME referenciar mais tarde.
- Defina o subjectarquivo . O valor disso é 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:octo-org/octo-repo:environment:Production",
    "description": "Testing",
    "audiences": [
        "api://AzureADTokenExchange"
    ]
}
```

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.

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 aplicativo para a ação de 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.

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

Segredo do GitHub Aplicação Microsoft Entra

AZURE_CLIENT_ID ID da aplicação (cliente)

AZURE_TENANT_ID ID do Diretório (inquilino)

AZURE_SUBSCRIPTION_ID ID de Subscrição
Salve cada segredo selecionando Adicionar segredo.

Segredo do GitHub	Aplicação Microsoft Entra
AZURE_CLIENT_ID	ID da aplicação (cliente)
AZURE_TENANT_ID	ID do Diretório (inquilino)
AZURE_SUBSCRIPTION_ID	ID de Subscrição

Adicionar um segredo do SQL Server

Crie um novo segredo em seu repositório para SQL_SERVER_ADMIN_PASSWORDo . 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, então salve-a separadamente.

Criar recursos do Azure

O fluxo de trabalho de criação de recursos do Azure executa um modelo ARM para implantar recursos no Azure. O fluxo de trabalho:

Faz check-out do código-fonte com a ação Checkout.
Efetua logon no Azure com a ação Logon do Azure e reúne 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 azuredeploy.yaml arquivo em .github/workflows seu repositório.
Atualize o valor de para o nome do seu grupo de AZURE_RESOURCE_GROUP recursos.
Atualize os valores de e SQL_SERVER_NAME para o nome do aplicativo Web e o nome do WEB_APP_NAME servidor SQL.
Vá para Ações e selecione Executar fluxo de trabalho.
Verifique se sua ação foi executada com êxito verificando se há uma marca de seleção verde na página Ações .

Adicionar registro de contêiner e segredos SQL

No portal do Azure, abra o Registro de Contêiner do Azure recém-criado em seu grupo de recursos.
Vá para Teclas de acesso e copie os valores de nome de usuário e senha.
Crie novos segredos e senha do GitHub em ACR_USERNAMEACR_PASSWORD seu repositório.
No portal do Azure, abra seu banco de dados SQL do Azure. Abra Cadeias de conexão e copie o valor.
Crie um novo segredo para SQL_CONNECTION_STRINGo . Substitua {your_password} pelo seu SQL_SERVER_ADMIN_PASSWORDarquivo .

Crie, envie por push e implante sua imagem

O fluxo de trabalho de compilação, envio por push e implantação 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 enviado por push mais recente. O fluxo de trabalho contêinera um trabalho de compilação e implantação:

O trabalho de compilação faz check-out do código-fonte com a ação Checkout. 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 registra no Azure com a ação Logon do Azure e reúne informações de ambiente e recursos do Azure. Em seguida, o trabalho atualiza as Configurações do Aplicativo Web com a ação 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 Implantação da Web do Azure. Por último, o trabalho executa um script personalizado para atualizar o banco de dados SQL e troca o slot de preparo para a produção.

Para executar o fluxo de trabalho de compilação, envio por push e implantação:

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

Próximos passos

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