Tutorial: Implantar um aplicativo ASP.NET Core e um Banco de Dados nos Aplicativos de Contêiner do Azure usando GitHub Actions

Artigo
11/03/2023

Neste tutorial, você aprenderá a implantar um aplicativo ASP.NET Core e um Banco de Dados SQL nos Aplicativos de Contêiner do Azure usando o Visual Studio e o GitHub Actions. Você também aprenderá a gerenciar migrações do Entity Framework e atualizações de banco de dados no GitHub Actions, embora os conceitos também possam ser aplicados a outras ferramentas e ambientes de CI/CD.

Pré-requisitos

Você precisa do Visual Studio 2022 instalado com as cargas de trabalho de desenvolvimento do ASP.NET e para a Web e desenvolvimento do Azure.

Se você já instalou o Visual Studio:

Instale as atualizações mais recentes no Visual Studio selecionando Ajuda>Verificar Atualizações.
Verifique se as cargas de trabalho desenvolvimento do ASP.NET e para a Web e desenvolvimento do Azure estão instaladas selecionando Ferramentas>Obter Ferramentas e Recursos.

Configurar o aplicativo de exemplo localmente

Use o aplicativo de exemplo ToDo para acompanhar este tutorial. Clone o aplicativo do GitHub usando o seguinte comando:

git clone https://github.com/Azure-Samples/msdocs-app-service-sqldb-dotnetcore.git
cd msdocs-app-service-sqldb-dotnetcore

Navegue até a pasta do projeto e abra a solução DotNetCoreSqlDb.sln no Visual Studio.

O aplicativo ToDo está pronto para uso, mas você precisará estabelecer uma conexão com o servidor SQL localdb que está disponível no Visual Studio. A conexão com localdb permitirá que você execute o aplicativo e persista listas de tarefas enquanto trabalha localmente.

Clique com o botão direito do mouse no nó Serviços Conectados no gerenciador de soluções do Visual Studio e selecione Adicionar > Banco de Dados SQL Server.
Na caixa de diálogo Conectar-se a dependência, selecione SQL Server Express LocalDB (Local) e Avançar.
Na caixa de diálogo Conectar-se ao SQL Server Express LocalDB (Local), defina os seguintes valores:
- Nome da cadeia de conexão: deixe o valor padrão.
- Valor da cadeia de conexão: deixe o valor padrão.
- Salvar o valor da cadeia de conexão em: selecione Nenhum.
- Selecione Avançar
Na tela Resumo das alterações, deixe as configurações com os valores padrão e selecione Concluir para concluir o fluxo de trabalho.

O Visual Studio exibe um resumo das dependências de serviço, incluindo a conexão com LocalDB.

Em seguida, você precisará criar uma migração inicial e usá-la para atualizar o banco de dados local com o esquema correto para o aplicativo de lista de tarefas.

Selecione o ícone ... à direita da lista de dependências de serviço ao lado da conexão LocalDB e escolha Adicionar migração.
Na caixa de diálogo Migrações do Entity Framework, aguarde um momento para que o Visual Studio localize a classe DbContext incluída no projeto. Após os valores serem carregados, selecione Concluir.
O Visual Studio gera uma pasta Migrations no projeto e cria uma classe de migrações inicial. Essa classe pode ser usada para atualizar o banco de dados com o esquema correto.
Selecione o ícone ... ao lado do serviço LocalDB novamente e selecione Atualizar banco de dados.
Na caixa de diálogo Migrações do Entity Framework, aguarde um momento para que o Visual Studio localize a classe DbContext novamente e escolha Concluir. O Visual Studio executa a migração e cria o esquema para o banco de dados no servidor LocalDB.

Inicie o projeto selecionando o botão de execução de DotNetCoreSqlDb na parte superior do Visual Studio.

Quando o aplicativo for carregado, verifique se o banco de dados está funcionando corretamente inserindo uma nova tarefa pendente. A tarefa pendente aparece no modo de exibição de lista principal na home page do aplicativo.

Explorar a configuração de inicialização do aplicativo

O aplicativo de exemplo inclui o seguinte código no arquivo Program.cs:

if(builder.Environment.IsDevelopment())
{
    builder.Services.AddDbContext<MyDatabaseContext>(options =>
        options.UseSqlServer(builder.Configuration.GetConnectionString("Default")));
}
else
{
    builder.Services.AddDbContext<MyDatabaseContext>(options =>
        options.UseSqlServer(Environment.GetEnvironmentVariable("AZURE_SQL_CONNECTIONSTRING")));
}

Esse código aplica as seguintes configurações:

Quando o aplicativo é executado localmente, a cadeia de conexão localdb é extraída do arquivo appsettings.json e fornecida ao Entity Framework. Essa configuração permite que seja feito check-in da cadeia de conexão localdb no controle do código-fonte para que outros desenvolvedores possam se conectar facilmente a um banco de dados local durante o desenvolvimento. Ela também permite que as migrações do Entity Framework sejam executadas localmente. Por padrão, o Entity Framework não descobrirá cadeias de conexão armazenadas na variável de ambiente ao executar migrações.
Quando o aplicativo é executado em fluxos de trabalho do GitHub Actions ou em Produção, a cadeia de conexão é extraída das variáveis de ambiente. Variáveis de ambiente podem impedir que seja feito o check-in de cadeias de conexão seguras de produção no controle do código-fonte ou que elas sejam incluídas em arquivos de configuração.

Criar os serviços do Azure

O aplicativo exigirá que os seguintes serviços do Azure sejam criados para uma implantação bem-sucedida:

Aplicativo de Contêiner: necessário para hospedar e executar o aplicativo implantado.
Registro de Contêiner: armazena o artefato de imagem compilado do aplicativo em contêineres.
Banco de Dados SQL: um banco de dados SQL do Azure para armazenar os dados do aplicativo.

Os recursos de publicação do Visual Studio podem lidar com a criação desses recursos para você.

Criar o Aplicativo de Contêiner do Azure e o Registro de Contêiner do Azure

No gerenciador de soluções do Visual Studio, clique com o botão direito do mouse no nó do projeto de nível superior e selecione Publicar.
Na caixa de diálogo de publicação, selecione Azure como destino de implantação e selecione Avançar.
Para o destino específico, selecione Aplicativos de Contêiner do Azure (Linux) e, em seguida, Avançar.
Crie um aplicativo de contêiner no qual implantar. Selecione o botão + Criar para abrir uma nova caixa de diálogo e insira os seguintes valores:
- Nome do aplicativo de contêiner: deixe o valor padrão ou insira um nome.
- Nome da assinatura: selecione a assinatura na qual implantar.
- Grupo de recursos: selecione Novo e crie um grupo de recursos chamado msdocs-app-db-ef.
- Ambiente de aplicativos de contêiner: selecione Novo para abrir a caixa de diálogo do ambiente de aplicativos de contêiner e insira os seguintes valores:
  - Nome do ambiente: mantenha o valor padrão.
  - Local: selecione um local próximo de você.
  - Workspace do Azure Log Analytics: selecione Novo para abrir a caixa de diálogo do workspace do Log Analytics.
    - Nome: deixe o valor padrão.
    - Local: selecione um local perto de você e, em seguida, Ok para fechar a caixa de diálogo.
  - Selecione Ok para fechar a caixa de diálogo do ambiente de aplicativos de contêiner.
- Selecione Criar para fechar a caixa de diálogo de aplicativos de contêiner original. O Visual Studio cria o recurso de aplicativo de contêiner no Azure.
Após o recurso ser criado, verifique se ele está selecionado na lista de aplicativos de contêiner e selecione Avançar.
Você precisará criar um Registro de Contêiner do Azure para armazenar o artefato de imagem publicado para seu aplicativo. Selecione o ícone + verde na tela do registro de contêiner.
Deixe os valores padrão e selecione Criar.
Depois que o registro de contêiner for criado, verifique se ele está selecionado e selecione avançar.
Na tela Tipo de implantação, selecione CI/CD usando fluxos de trabalho do GitHub Actions (gera o arquivo yml) e escolha Concluir. Se o Visual Studio solicitar que você habilite o usuário Administrador para acessar o contêiner do Docker publicado, selecione Sim.

O Visual Studio cria e exibe o perfil de publicação. A maioria das etapas e detalhes de publicação são descritos no arquivo .yml do GitHub Actions, que pode ser exibido clicando no botão Editar fluxo de trabalho na exibição de resumo do perfil de publicação. Esse arquivo é abordado com mais profundidade posteriormente no artigo.

Criar o banco de dados SQL do Azure

No gerenciador de soluções, clique com o botão direito do mouse no nó Serviços Conectados e selecione Adicionar > Banco de Dados SQL Server.
Na caixa de diálogo Conectar-se a dependência, selecione Banco de Dados SQL do Azure e escolha Avançar.
Selecione + Criar para adicionar um novo banco de dados.
Na caixa de diálogo Banco de Dados SQL do Azure, insira os seguintes valores:
- Nome do Banco de Dados: deixe o valor padrão.
- Nome da Assinatura: selecione a mesma assinatura que anteriormente.
- Grupo de Recursos: selecione o mesmo grupo msdocs-app-db-ef criado anteriormente.
- Servidor de Banco de Dados: selecione Novo... e insira os seguintes valores no novo pop-up:
  - Nome do Servidor de Banco de Dados: insira um nome de servidor exclusivo ou acrescente números aleatórios ao final do nome gerado automaticamente.
  - Local: escolha um local perto de você.
  - Nome de usuário do administrador: insira um valor de sua escolha.
  - Senha do administrador: insira um valor de sua escolha.
  - Senha do administrador (confirmar): insira a mesma senha para confirmar. Selecione OK para fechar a caixa de diálogo do SQL Server
- Selecione Criar para criar o servidor SQL e o banco de dados.
- Quando a operação for concluída, selecione o servidor na lista e escolha Avançar
Na caixa de diálogo Conectar-se ao Banco de Dados SQL do Azure, deixe os valores padrão, mas verifique se Nenhum está selecionado na parte inferior para a opção Salvar valor da cadeia de conexão em.
Selecione Concluir e o Visual Studio criará os recursos do SQL.

Conectar o Aplicativo de Contêiner ao SQL do Azure

Na página de visão geral do Aplicativo de Contêiner que você criou, selecione Conector de Serviço (versão prévia) na navegação à esquerda.
Selecione + Criar para criar uma conexão.
No submenu Criar conexão, insira os seguintes valores:
- Contêiner: selecione o contêiner dotnetcoresqldb que você criou.
- Tipo de serviço: selecione Banco de Dados SQL.
- Assinatura: selecione a mesma assinatura usada para criar o aplicativo de contêiner.
- Nome da conexão: deixe o valor padrão.
- SQL Server: selecione o servidor de banco de dados criado anteriormente.
- Banco de dados SQL: selecione o banco de dados criado anteriormente.
- Tipo de cliente: selecione .NET.
Selecione Avançar: Autenticação e insira os seguintes valores:
- Selecione Cadeia de conexão para o tipo de autenticação.
- Nome de usuário: insira o nome de usuário usado ao criar o servidor de banco de dados.
- Senha: insira a senha usada ao criar o servidor de banco de dados.
Deixe o restante das configurações com os valores padrão e selecione Avançar: Rede.
Deixe o valor padrão selecionado e escolha Avançar: Examinar + Criar.
Depois que o Azure validar as configurações, selecione Criar.

Após um momento, a conexão com o banco de dados SQL deve aparecer. Selecione a seta para expandir a conexão e ver o valor AZURE_SQL_CONNECTIONSTRING. Esse nome da conexão corresponde ao nome da cadeia de conexão da variável de ambiente definida no aplicativo de exemplo.

Configurar o fluxo de trabalho do GitHub Actions

O arquivo de fluxo de trabalho do GitHub Actions gerado pelo Visual Studio pode ser usado pelo GitHub para compilar e implantar o aplicativo no Azure quando alterações são enviadas por push. Atualmente, esse processo funcionaria, mas o aplicativo implantado geraria uma exceção. Embora o banco de dados SQL do Azure tenha sido criado, uma etapa precisa ser adicionada ao fluxo de trabalho do GitHub Actions para gerar o esquema. A cadeia de conexão do banco de dados SQL do Azure pode ser armazenada com segurança como um segredo no GitHub e recuperada pelo fluxo de trabalho quando ele é executado.

Recuperar a cadeia de conexão e adicioná-la aos segredos do GitHub

No portal do Azure, pesquise pelo banco de dados que você criou na barra de pesquisa principal e selecione-o nos resultados.
Na página de visão geral do banco de dados, selecione Cadeias de conexão na navegação à esquerda.
Na guia ADO.NET, copie a cadeia de conexão para fora do campo de formulário.
Navegue até o repositório do GitHub bifurcado do aplicativo.
Na guia Configurações, selecione Segredos > Ações na navegação à esquerda e escolha Novo segredo do repositório.
Na página Novo segredo, insira os seguintes valores:
- Nome: insira um nome de DbConnection.
- Segredo: cole a cadeia de conexão copiada do Azure. Substitua o espaço reservado de senha na cadeia de conexão pela senha escolhida ao criar o banco de dados.
- Selecione Adicionar segredo.

A cadeia de conexão agora é armazenada com segurança nos segredos do repositório GitHub e pode ser recuperada usando um fluxo de trabalho do GitHub.

Modificar o fluxo de trabalho do GitHub Actions para habilitar migrações

Abra o arquivo .yml de fluxo de trabalho do GitHub Actions gerado pelo Visual Studio selecionando o botão Editar Fluxo de Trabalho na página de resumo de publicação.
Acrescente o seguinte yaml ao final do arquivo de fluxo de trabalho:
```
- name: Run EF 
  run: | 
    dotnet tool install --global dotnet-ef
    dotnet tool restore
    dotnet ef database update -p DotNetCoreSqlDb --connection '${{ secrets.DBConnection }}'
```
Esse código instala as ferramentas de linha de comando da estrutura de entidade e executa as migrações de aplicativo. Quando o fluxo de trabalho é executado, o código também usa o parâmetro connection do comando database update para substituir a cadeia de conexão localdb armazenada no arquivo appsettings.json pelo valor adicionado aos segredos do GitHub.

Executar o fluxo de trabalho do GitHub Actions e testar a implantação

Confirme as alterações no aplicativo e efetue push para o repositório bifurcado usando o seguinte comando:
```
git add --all
git commit -m "Added GitHub Actions workflow"
git push
```
Navegue até o repositório do GitHub e selecione a guia Ações. Uma execução de fluxo de trabalho deve ter sido disparada automaticamente se o push foi bem-sucedido.
Selecione o fluxo de trabalho ativo para exibir os detalhes do log de cada etapa conforme elas são concluídas. A migração é executada por último para atualizar o banco de dados no Azure.

Após a conclusão do fluxo de trabalho, o aplicativo é implantado nos Aplicativos de Contêiner do Azure e conectado ao banco de dados com um esquema atualizado.

Você pode testar a implantação navegando até a home page do aplicativo de contêiner e criando uma tarefa pendente, assim como o fez localmente. Você sempre pode encontrar a URL para seu aplicativo de contêiner na página de visão geral do aplicativo no portal do Azure.