Tutorial: Criar um aplicativo ASP.NET Core e do Banco de Dados SQL do Azure no Serviço de Aplicativo do Azure

O Serviço de Aplicativo do Azure fornece um serviço de hospedagem na Web altamente escalonável e com aplicação automática de patches no Azure. Este tutorial mostra como criar um aplicativo ASP.NET Core e conectá-lo ao Banco de Dados SQL. Quando terminar, você terá um aplicativo .NET MVC em execução no Serviço de Aplicativo no Windows.

O Serviço de Aplicativo do Azure fornece um serviço de hospedagem na Web altamente escalonável e com aplicação automática de patches usando o sistema operacional Linux. Este tutorial mostra como criar um aplicativo ASP.NET Core e conectá-lo a um banco de dados SQL. Quando terminar, você terá um aplicativo ASP.NET Core MVC em execução no Serviço de Aplicativo no Linux.

aplicativo em execução no Serviço de Aplicativo

Neste tutorial, você aprenderá como:

  • Criar um Banco de Dados SQL no Azure
  • Conectar um aplicativo ASP.NET Core ao Banco de Dados SQL
  • Implantar o aplicativo no Azure
  • Atualizar o modelo de dados e reimplantar o aplicativo
  • Transmitir logs de diagnóstico do Azure
  • Gerenciar o aplicativo no portal do Azure

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

Pré-requisitos

Para concluir este tutorial:

  • Use o ambiente Bash no Azure Cloud Shell.

    Inicie o Cloud Shell em uma nova janela

  • Se preferir, instale a CLI do Azure para executar comandos de referência da CLI.

    • Se estiver usando uma instalação local, entre com a CLI do Azure usando o comando az login. Para concluir o processo de autenticação, siga as etapas exibidas no terminal. Para mais opções de entrada, confira Entrar com a CLI do Azure.

    • Quando solicitado, instale as extensões da CLI do Azure no primeiro uso. Para obter mais informações sobre extensões, confira Usar extensões com a CLI do Azure.

    • Execute az version para localizar a versão e as bibliotecas dependentes que estão instaladas. Para fazer a atualização para a versão mais recente, execute az upgrade.

Criar um aplicativo ASP.NET Core local

Nesta etapa, você configura o projeto ASP.NET Core local.

Clonar o aplicativo de exemplo

  1. Na janela do terminal, cd para um diretório de trabalho.

  2. Execute os comandos a seguir para clonar o repositório de exemplo e alterar sua raiz.

    git clone https://github.com/azure-samples/dotnetcore-sqldb-tutorial
    cd dotnetcore-sqldb-tutorial
    

    Esse projeto de exemplo contém um aplicativo CRUD (create-read-update-delete) básico usando o Entity Framework Core.

  3. Verifique se o branch padrão é main.

    git branch -m main
    

    Dica

    A alteração do nome do branch não é necessária para o Serviço de Aplicativo. No entanto, como muitos repositórios estão alterando o branch padrão para main (confira Alterar o branch de implantação), este tutorial também mostra como implantar um repositório por meio de main.

Executar o aplicativo

  1. Execute os comandos a seguir para instalar os pacotes necessários, executar as migrações de banco de dados e iniciar o aplicativo.

    dotnet tool install -g dotnet-ef
    dotnet ef database update
    dotnet run
    
  2. Navegue até http://localhost:5000 em um navegador. Selecione o link Criar novo e crie alguns itens de tarefas.

    conecta-se com êxito ao Banco de Dados SQL

  3. Para parar o ASP.NET Core a qualquer momento, pressione Ctrl+C no terminal.

Criar um Banco de Dados SQL de produção

Nesta etapa, você cria um Banco de Dados SQL no Azure. Quando seu aplicativo é implantado no Azure, ele usa esse banco de dados na nuvem.

Para o Banco de Dados SQL, este tutorial usa o Banco de Dados SQL do Azure.

Criar um grupo de recursos

Um grupo de recursos é um contêiner lógico no qual os recursos do Azure, como aplicativos Web, bancos de dados e contas de armazenamento, são implantados e gerenciados. Por exemplo, é possível excluir posteriormente todo o grupo de recursos com uma única etapa simples.

No Cloud Shell, crie um grupo de recursos com o comando az group create. O exemplo a seguir cria um grupo de recursos chamado myResourceGroup no local Europa Ocidental. Para ver todos os locais com suporte para o Serviço de Aplicativo no nível Gratuito, execute o comando az appservice list-locations --sku FREE.

az group create --name myResourceGroup --location "West Europe"

Em geral, você cria seu grupo de recursos e os recursos em uma região próxima a você.

Quando o comando for concluído, uma saída JSON mostra as propriedades do grupo de recursos.

Criar um servidor lógico do Banco de Dados SQL

No Cloud Shell, crie um servidor lógico do Banco de Dados SQL com o comando az sql server create.

Substitua o espaço reservado <server-name> por um nome exclusivo do Banco de Dados SQL. Esse nome é usado como parte do ponto de extremidade do Banco de Dados SQL globalmente exclusivo, <server-name>.database.windows.net. Os caracteres válidos são a-z, 0-9, -. Além disso, substitua <db-username> e <db-password> por um nome de usuário e uma senha de sua escolha.

az sql server create --name <server-name> --resource-group myResourceGroup --location "West Europe" --admin-user <db-username> --admin-password <db-password>

Quando o servidor lógico do Banco de Dados SQL é criado, a CLI do Azure mostra informações semelhantes ao seguinte exemplo:

{
  "administratorLogin": "<db-username>",
  "administratorLoginPassword": null,
  "fullyQualifiedDomainName": "<server-name>.database.windows.net",
  "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Sql/servers/<server-name>",
  "identity": null,
  "kind": "v12.0",
  "location": "westeurope",
  "name": "<server-name>",
  "resourceGroup": "myResourceGroup",
  "state": "Ready",
  "tags": null,
  "type": "Microsoft.Sql/servers",
  "version": "12.0"
}

Configurar uma regra de firewall de servidor

  1. Crie uma regra de firewall no nível de servidor do Banco de Dados SQL do Azure usando o comando az sql server firewall create. Quando o IP inicial e o IP final estiverem definidos como 0.0.0.0, o firewall estará aberto somente para outros recursos do Azure.

    az sql server firewall-rule create --resource-group myResourceGroup --server <server-name> --name AllowAzureIps --start-ip-address 0.0.0.0 --end-ip-address 0.0.0.0
    

    Dica

    Você pode ser ainda mais restritivo na regra de firewall ao usar somente os endereços de IP de saída que seu aplicativo usa.

  2. No Cloud Shell, execute o comando novamente para permitir acesso no computador local, substituindo <your-ip-address> pelo endereço IP IPv4 local.

    az sql server firewall-rule create --name AllowLocalClient --server <server-name> --resource-group myResourceGroup --start-ip-address=<your-ip-address> --end-ip-address=<your-ip-address>
    

Criar um banco de dados

Crie um banco de dados com um nível de desempenho S0 no servidor usando o comando az sql db create.

az sql db create --resource-group myResourceGroup --server <server-name> --name coreDB --service-objective S0

Recuperar a cadeia de conexão

Obtenha a cadeia de conexão usando o comando az sql db show-connection-string.

az sql db show-connection-string --client ado.net --server <server-name> --name coreDB

Na saída do comando, substitua <username> e <password> pelas credenciais de administrador de banco de dados usadas anteriormente.

Esta é a cadeia de conexão do aplicativo ASP.NET Core. Copie-a para uso posterior.

Configurar o aplicativo para se conectar ao banco de dados de produção

No repositório local, abra Startup.cs e encontre o seguinte código:

services.AddDbContext<MyDatabaseContext>(options =>
        options.UseSqlite("Data Source=localdatabase.db"));

Substitua-o pelo código a seguir.

services.AddDbContext<MyDatabaseContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("MyDbConnection")));

Importante

Para aplicativos de produção que precisam ser expandidos horizontalmente, siga as práticas recomendadas em Aplicar migrações em produção.

Executar migrações de banco de dados para o banco de dados de produção

Seu aplicativo conecta-se atualmente a um banco de dados SQLite local. Agora que você configurou um Banco de Dados SQL do Azure, recrie a migração inicial para defini-lo como destino.

Na raiz do repositório, execute os comandos a seguir. Substitua <connection-string> pela cadeia de conexão criada anteriormente.

# Delete old migrations
rm -r Migrations
# Recreate migrations with UseSqlServer (see previous snippet)
dotnet ef migrations add InitialCreate

# Set connection string to production database
# PowerShell
$env:ConnectionStrings:MyDbConnection="<connection-string>"
# CMD (no quotes)
set ConnectionStrings:MyDbConnection=<connection-string>
# Bash (no quotes)
export ConnectionStrings__MyDbConnection=<connection-string>

# Run migrations
dotnet ef database update

Executar o aplicativo com nova configuração

  1. Agora que as migrações de banco de dados são executadas no banco de dados de produção, teste seu aplicativo executando:

    dotnet run
    
  2. Navegue até http://localhost:5000 em um navegador. Selecione o link Criar novo e crie alguns itens de tarefas. Agora, seu aplicativo está lendo e gravando dados no banco de dados de produção.

  3. Confirme suas alterações locais e então confirme-as no repositório do Git.

    git add .
    git commit -m "connect to SQLDB in Azure"
    

Agora, você está pronto para implantar seu código.

Implantar o aplicativo no Azure

Nesta etapa, você implantará seu aplicativo ASP.NET Core conectado ao Banco de Dados SQL no Serviço de Aplicativo.

Configurar a implantação do git local

O FTP e o Git local podem implantar em um aplicativo Web do Azure usando um usuário de implantação. Após configurar o usuário de implantação, use-o em todas as implantações do Azure. O nome de usuário e a senha da implantação no nível da conta são diferentes das credenciais de assinatura do Azure.

Para configurar o usuário de implantação, execute o comando az webapp deployment user set no Azure Cloud Shell. Substitua <username> e <password> pelo nome de usuário e a senha do usuário de implantação.

  • O nome de usuário precisa ser exclusivo no Azure. Para envios por push do Git local, não deve conter o símbolo "@".
  • A senha deve ter pelo menos oito caracteres, com dois destes três elementos: letras, números, símbolos.
az webapp deployment user set --user-name <username> --password <password>

A saída JSON mostra a senha como null. Se receber um erro 'Conflict'. Details: 409, altere o nome de usuário. Se receber um erro 'Bad Request'. Details: 400, use uma senha mais forte.

Registre seu nome de usuário e senha para usá-los na implantação de aplicativos Web.

Criar um plano de Serviço de Aplicativo

No Cloud Shell, crie um plano do Serviço de Aplicativo com o comando az appservice plan create.

O exemplo a seguir cria um plano do Serviço de Aplicativo denominado myAppServicePlan usando o tipo de preço Gratuita:

az appservice plan create --name myAppServicePlan --resource-group myResourceGroup --sku FREE

Quando o Plano do Serviço de Aplicativo for criado, a CLI do Azure mostrará informações semelhantes ao exemplo a seguir:

{ 
  "adminSiteName": null,
  "appServicePlanName": "myAppServicePlan",
  "geoRegion": "West Europe",
  "hostingEnvironmentProfile": null,
  "id": "/subscriptions/0000-0000/resourceGroups/myResourceGroup/providers/Microsoft.Web/serverfarms/myAppServicePlan",
  "kind": "app",
  "location": "West Europe",
  "maximumNumberOfWorkers": 1,
  "name": "myAppServicePlan",
  < JSON data removed for brevity. >
  "targetWorkerSizeId": 0,
  "type": "Microsoft.Web/serverfarms",
  "workerTierName": null
} 

No Cloud Shell, crie um plano do Serviço de Aplicativo com o comando az appservice plan create.

O exemplo a seguir cria um plano do Serviço de Aplicativo denominado myAppServicePlan usando o tipo de preço Gratuita:

az appservice plan create --name myAppServicePlan --resource-group myResourceGroup --sku FREE --is-linux

Quando o Plano do Serviço de Aplicativo for criado, a CLI do Azure mostrará informações semelhantes ao exemplo a seguir:

{ 
  "freeOfferExpirationTime": null,
  "geoRegion": "West Europe",
  "hostingEnvironmentProfile": null,
  "id": "/subscriptions/0000-0000/resourceGroups/myResourceGroup/providers/Microsoft.Web/serverfarms/myAppServicePlan",
  "kind": "linux",
  "location": "West Europe",
  "maximumNumberOfWorkers": 1,
  "name": "myAppServicePlan",
  < JSON data removed for brevity. >
  "targetWorkerSizeId": 0,
  "type": "Microsoft.Web/serverfarms",
  "workerTierName": null
} 

Criar um aplicativo Web

Crie um aplicativo Web no plano do Serviço de Aplicativo myAppServicePlan.

No Cloud Shell, é possível usar o comando az webapp create. No exemplo a seguir, substitua <app-name> por um nome do aplicativo exclusivo globalmente (os caracteres válidos são a-z, 0-9 e -).

az webapp create --resource-group myResourceGroup --plan myAppServicePlan --name <app-name> --deployment-local-git

Quando o aplicativo Web for criado, a CLI do Azure mostrará um resultado semelhante ao seguinte exemplo:

Local git is configured with url of 'https://<username>@<app-name>.scm.azurewebsites.net/<app-name>.git'
{
  "availabilityState": "Normal",
  "clientAffinityEnabled": true,
  "clientCertEnabled": false,
  "clientCertExclusionPaths": null,
  "cloningInfo": null,
  "containerSize": 0,
  "dailyMemoryTimeQuota": 0,
  "defaultHostName": "<app-name>.azurewebsites.net",
  "deploymentLocalGitUrl": "https://<username>@<app-name>.scm.azurewebsites.net/<app-name>.git",
  "enabled": true,
  < JSON data removed for brevity. >
}

Observação

A URL do Git remoto é mostrada na propriedade deploymentLocalGitUrl com o formato https://<username>@<app-name>.scm.azurewebsites.net/<app-name>.git. Salve essa URL, pois você precisará dela mais tarde.

Crie um aplicativo Web no plano do Serviço de Aplicativo myAppServicePlan.

No Cloud Shell, é possível usar o comando az webapp create. No exemplo a seguir, substitua <app-name> por um nome do aplicativo exclusivo globalmente (os caracteres válidos são a-z, 0-9 e -). A execução é predefinida para DOTNET|5.0. Para ver todos os runtimes com suporte, execute az webapp list-runtimes --linux.

az webapp create --resource-group myResourceGroup --plan myAppServicePlan --name <app-name> --runtime 'DOTNET|5.0' --deployment-local-git

Quando o aplicativo Web for criado, a CLI do Azure mostrará um resultado semelhante ao seguinte exemplo:

Local git is configured with url of 'https://<username>@<app-name>.scm.azurewebsites.net/<app-name>.git'
{
  "availabilityState": "Normal",
  "clientAffinityEnabled": true,
  "clientCertEnabled": false,
  "cloningInfo": null,
  "containerSize": 0,
  "dailyMemoryTimeQuota": 0,
  "defaultHostName": "<app-name>.azurewebsites.net",
  "deploymentLocalGitUrl": "https://<username>@<app-name>.scm.azurewebsites.net/<app-name>.git",
  "enabled": true,
  < JSON data removed for brevity. >
}

Você criou um aplicativo Web vazio em um contêiner do Linux, com a implantação do Git habilitada.

Observação

A URL do Git remoto é mostrada na propriedade deploymentLocalGitUrl com o formato https://<username>@<app-name>.scm.azurewebsites.net/<app-name>.git. Salve essa URL, pois você precisará dela mais tarde.

Configurar a cadeia de conexão

Para definir as cadeias de conexão para o aplicativo do Azure, use o comando az webapp config appsettings set no Cloud Shell. No comando a seguir, substitua <app-name> pelo nome do aplicativo, bem como o parâmetro <connection-string> pela cadeia de conexão criada anteriormente.

az webapp config connection-string set --resource-group myResourceGroup --name <app-name> --settings MyDbConnection='<connection-string>' --connection-string-type SQLAzure

No ASP.NET Core, você poderá usar essa cadeia de conexão nomeada (MyDbConnection) empregando o modelo padrão, como qualquer cadeia de conexão especificada em appsettings.json. Nesse caso, MyDbConnection também é definido em seu appsettings.json. Durante a execução no Serviço de Aplicativo, a cadeia de conexão definida no Serviço de Aplicativo tem precedência sobre a cadeia de conexão definida no seu appsettings.json. O código usa o valor appsettings.json durante o desenvolvimento local e o mesmo código usa o valor do Serviço de Aplicativo quando implantado.

Para ver como a cadeia de conexão é referenciada em seu código, confira Configurar o aplicativo para conectar-se ao banco de dados de produção.

Enviar do Git para o Azure

  1. Como você está implantando o branch main, você precisa definir o branch de implantação padrão para seu aplicativo do Serviço de Aplicativo como main (consulte Alterar o branch de implantação). No Cloud Shell, defina a configuração do aplicativo DEPLOYMENT_BRANCH com o comando az webapp config appsettings set.

    az webapp config appsettings set --name <app-name> --resource-group myResourceGroup --settings DEPLOYMENT_BRANCH='main'
    
  2. De volta na janela do terminal local, adicione um remoto do Azure ao repositório Git local. Substitua <deploymentLocalGitUrl-from-create-step> pela URL do repositório remoto Git que você salvou em Criar um aplicativo Web.

    git remote add azure <deploymentLocalGitUrl-from-create-step>
    
  3. Envie por push para o Azure remoto para implantar seu aplicativo com o comando a seguir. Quando solicitado a fornecer credenciais pelo Gerenciador de Credenciais do Git, insira as credenciais criadas em Configurar um usuário de implantação, não as credenciais usadas para entrar no portal do Azure.

    git push azure main
    

    Esse comando pode demorar um pouco para ser executado. Na execução, ele exibe informações semelhantes ao seguinte exemplo:

   Enumerating objects: 268, done.
   Counting objects: 100% (268/268), done.
   Compressing objects: 100% (171/171), done.
   Writing objects: 100% (268/268), 1.18 MiB | 1.55 MiB/s, done.
   Total 268 (delta 95), reused 251 (delta 87), pack-reused 0
   remote: Resolving deltas: 100% (95/95), done.
   remote: Updating branch 'main'.
   remote: Updating submodules.
   remote: Preparing deployment for commit id '64821c3558'.
   remote: Generating deployment script.
   remote: Project file path: .\DotNetCoreSqlDb.csproj
   remote: Generating deployment script for ASP.NET MSBuild16 App
   remote: Generated deployment script files
   remote: Running deployment command...
   remote: Handling ASP.NET Core Web Application deployment with MSBuild16.
   remote: .
   remote: .
   remote: .
   remote: Finished successfully.
   remote: Running post deployment command(s)...
   remote: Triggering recycle (preview mode disabled).
   remote: App container will begin restart within 10 seconds.
   To https://<app-name>.scm.azurewebsites.net/<app-name>.git
    * [new branch]      main -> main
   
   Enumerating objects: 273, done.
   Counting objects: 100% (273/273), done.
   Delta compression using up to 4 threads
   Compressing objects: 100% (175/175), done.
   Writing objects: 100% (273/273), 1.19 MiB | 1.85 MiB/s, done.
   Total 273 (delta 96), reused 259 (delta 88)
   remote: Resolving deltas: 100% (96/96), done.
   remote: Deploy Async
   remote: Updating branch 'main'.
   remote: Updating submodules.
   remote: Preparing deployment for commit id 'cccecf86c5'.
   remote: Repository path is /home/site/repository
   remote: Running oryx build...
   remote: Build orchestrated by Microsoft Oryx, https://github.com/Microsoft/Oryx
   remote: You can report issues at https://github.com/Microsoft/Oryx/issues
   remote: .
   remote: .
   remote: .
   remote: Done.
   remote: Running post deployment command(s)...
   remote: Triggering recycle (preview mode disabled).
   remote: Deployment successful.
   remote: Deployment Logs : 'https://<app-name>.scm.azurewebsites.net/newui/jsonviewer?view_url=/api/deployments/cccecf86c56493ffa594e76ea1deb3abb3702d89/log'
   To https://<app-name>.scm.azurewebsites.net/<app-name>.git
    * [new branch]      main -> main
   

Navegar até o aplicativo do Azure

  1. Navegue até o aplicativo implantado usando o navegador da Web.

    http://<app-name>.azurewebsites.net
    
  2. Adicione alguns itens de tarefas.

    aplicativo em execução no Serviço de Aplicativo

Parabéns! Você está executando um aplicativo ASP.NET Core controlado por dados no Serviço de Aplicativo.

Atualizar localmente e reimplantar

Nesta etapa, você faz uma alteração no esquema de banco de dados e publica-o no Azure.

Atualizar seu modelo de dados

Abra Models/Todo.cs no editor de códigos. Adicione a seguinte propriedade à classe ToDo:

public bool Done { get; set; }

Executar migrações de banco de dados novamente

Execute alguns comandos para fazer atualizações ao banco de dados de produção.

dotnet ef migrations add AddProperty
dotnet ef database update

Observação

Se você abrir uma nova janela de terminal, precisará definir a cadeia de conexão para o banco de dados de produção no terminal, como fez em Executar migrações de banco de dados para o banco de dados de produção.

Usar a nova propriedade

Faça algumas alterações em seu código para usar a propriedade Done. Para simplificar este tutorial, somente as exibições Index e Create serão alteradas para observar a propriedade em ação.

  1. Abra Controllers/TodosController.cs.

  2. Localize o Create([Bind("ID,Description,CreatedDate")] Todo todo) método e adicione Done à lista de propriedades no atributo Bind. Quando terminar, a assinatura do método Create() deverá ter o seguinte código:

    public async Task<IActionResult> Create([Bind("ID,Description,CreatedDate,Done")] Todo todo)
    
  3. Abra Views/Todos/Create.cshtml.

  4. No código do Razor, você deve ver um elemento <div class="form-group"> para Description e, em seguida, outro elemento <div class="form-group"> para CreatedDate. Imediatamente após esses dois elementos, adicione outro elemento <div class="form-group"> para Done:

    <div class="form-group">
        <label asp-for="Done" class="col-md-2 control-label"></label>
        <div class="col-md-10">
            <input asp-for="Done" class="form-control" />
            <span asp-validation-for="Done" class="text-danger"></span>
        </div>
    </div>
    
  5. Abra Views/Todos/Index.cshtml.

  6. Procure o elemento vazio <th></th>. Logo acima desse elemento, adicione o seguinte código do Razor:

    <th>
        @Html.DisplayNameFor(model => model.Done)
    </th>
    
  7. Localize o elemento <td> que contém os auxiliares de marcação asp-action. Logo acima desse elemento, adicione o seguinte código do Razor:

    <td>
        @Html.DisplayFor(modelItem => item.Done)
    </td>
    

Isso é tudo o que você precisa para ver as alterações nas exibições Index e Create.

Testar suas alterações localmente

  1. Execute o aplicativo localmente.

    dotnet run
    

    Observação

    Se você abrir uma nova janela de terminal, precisará definir a cadeia de conexão para o banco de dados de produção no terminal, como fez em Executar migrações de banco de dados para o banco de dados de produção.

  2. No navegador, navegue até http://localhost:5000/. Agora você pode adicionar um item de tarefas e marcar Concluído. Em seguida, ele deverá aparecer na sua página inicial como um item concluído. Lembre-se de que a exibição Edit não mostra o campo Done, porque você não alterou a exibição Edit.

Publicar alterações no Azure

  1. Faça commit das alterações no Git e efetue push delas para o aplicativo do Serviço de Aplicativo.

    git add .
    git commit -m "added done field"
    git push azure main
    
  2. Quando git push estiver concluído, navegue até seu aplicativo do Serviço de Aplicativo e tente adicionar um item de tarefa pendente e marcar Concluído.

    Aplicativo do Azure após Migração do Code First

Observe que todos os itens de tarefas existentes ainda são exibidos. Quando você republicar o aplicativo ASP.NET Core, os dados existentes no Banco de Dados SQL não serão perdidos. Além disso, as Migrações do Entity Framework Core apenas alteram o esquema de dados e deixam os dados existentes intactos.

Logs de diagnóstico de fluxo

Enquanto o aplicativo ASP.NET Core é executado no serviço de aplicativo do Azure, você pode transferir os logs do console para o Cloud Shell. Dessa forma, é possível obter as mesmas mensagens de diagnóstico para ajudá-lo a depurar erros de aplicativo.

O projeto de exemplo já segue as diretrizes do provedor de logs do Serviço de Aplicativo do Azure com duas alterações de configuração:

  • Inclui uma referência a Microsoft.Extensions.Logging.AzureAppServices em DotNetCoreSqlDb.csproj.
  • Chama loggerFactory.AddAzureWebAppDiagnostics() em Program.cs.
  1. Para definir o nível de log do ASP.NET Core no Serviço de Aplicativo para Information do nível padrão Error, use o comando az webapp log config no Cloud Shell.

    az webapp log config --name <app-name> --resource-group myResourceGroup --application-logging filesystem --level information
    

    Observação

    O nível de log do projeto já está definido como Information em appsettings.json.

  2. Para iniciar o streaming de log, use o comando az webapp log tail no Cloud Shell.

    az webapp log tail --name <app-name> --resource-group myResourceGroup
    
  3. Depois que o streaming de log for iniciado, atualize o aplicativo do Azure no navegador para obter parte do tráfego da Web. Agora é possível ver os logs do console redirecionados para o terminal. Se você não vir os logs do console imediatamente, verifique novamente após 30 segundos.

  4. Para interromper o streaming de log a qualquer momento, digite Ctrl+C.

Para obter mais informações sobre como personalizar os logs do ASP.NET Core, confira Log no .NET.

Limpar os recursos

Nas etapas anteriores, você criou os recursos do Azure em um grupo de recursos. Se você acha que não precisará desses recursos no futuro, exclua o grupo de recursos executando o seguinte comando no Cloud Shell:

az group delete --name myResourceGroup

Esse comando pode demorar um pouco para ser executado.

Próximas etapas

O que você aprendeu:

  • Criar um Banco de Dados SQL no Azure
  • Conectar um aplicativo ASP.NET Core ao Banco de Dados SQL
  • Implantar o aplicativo no Azure
  • Atualizar o modelo de dados e reimplantar o aplicativo
  • Transmitir logs do Azure para seu terminal
  • Gerenciar o aplicativo no portal do Azure

Prossiga para o próximo tutorial para saber como mapear um nome DNS personalizado para o seu aplicativo.

Se preferir, confira outros recursos: