Debugging Aspire Services in the IDE

1. A Experiência "F5": Depuração Padrão no Aspire

A beleza do .NET Aspire é que ele se integra perfeitamente ao fluxo de trabalho de desenvolvimento .NET que você já conhece. Quando você inicia a depuração do projeto AppHost (seja pressionando F5 no Visual Studio/Rider ou usando um comando de depuração), o Aspire orquestra todos os serviços definidos e, por padrão, o depurador se anexa a todos os projetos .NET que estão sendo executados.

Isso permite uma experiência de depuração "cross-service" muito poderosa. Você pode definir um breakpoint em um serviço, acionar uma ação em outro serviço que o chama, e o fluxo de execução irá parar exatamente onde você espera.

Vamos ver isso na prática com a aplicação que montamos na lição anterior.

1. Abra a solução MyAspireApp no seu IDE.
2. No projeto MyAspireApp.ApiService, abra o arquivo que contém o endpoint /weatherforecast (provavelmente Program.cs ou um arquivo de endpoints separado).
3. Coloque um breakpoint na linha que gera ou retorna os dados do tempo.
4. Certifique-se de que o projeto de inicialização (startup project) seja o MyAspireApp.AppHost.
5. Inicie a depuração (F5). O Aspire irá compilar e iniciar os projetos ApiService e Web, e o Aspire Dashboard será aberto.
6. No Dashboard, na linha correspondente ao webfrontend, clique no link do endpoint para abrir a aplicação web.
7. Navegue até a página "Weather".

No momento em que o frontend tenta buscar os dados, seu IDE deve pausar a execução no breakpoint que você definiu no ApiService. Você agora pode inspecionar variáveis, percorrer o código (step through) e usar todas as ferramentas de depuração a que está acostumado, mesmo que a chamada tenha sido originada de um processo completamente diferente.

2. Combinando o Dashboard com o Depurador

O verdadeiro poder do Aspire vem da sinergia entre o dashboard e o depurador. Eles não são ferramentas excludentes, mas complementares, formando um ciclo de diagnóstico completo.

Imagine o seguinte cenário: você está testando sua aplicação e percebe uma lentidão inesperada ao carregar uma página.

1. Observar (Dashboard): Você vai para a aba Traces no Aspire Dashboard e encontra a requisição lenta. O gráfico em cascata mostra que uma chamada específica para o apiservice está demorando 5 segundos, mas não há erros nos logs.
2. Hipótese (Cérebro): Você suspeita que pode haver um processamento ineficiente ou uma espera desnecessária dentro do método do apiservice que foi chamado.
3. Depurar (IDE): Você define um breakpoint no início do método suspeito no apiservice.
4. Acionar (Aplicação): Você recarrega a página lenta para acionar o cenário novamente.
5. Analisar (IDE): O breakpoint é atingido. Agora você pode percorrer o código linha a linha, inspecionar o valor das variáveis e usar o call stack para entender exatamente onde o tempo está sendo gasto. Talvez você encontre um Task.Delay(5000) esquecido, um loop ineficiente ou uma consulta lenta ao banco de dados.

3. Foco em um Único Serviço: Depuração com Launch Profiles

Depurar todos os serviços de uma vez é ótimo, mas para aplicações grandes, pode consumir muitos recursos e tornar a inicialização mais lenta. Às vezes, você quer apenas focar em um único serviço e deixar os outros rodarem normalmente, sem o overhead do depurador.

Além disso, pode haver cenários em que você queira iniciar um serviço com uma configuração de depuração específica (por exemplo, com variáveis de ambiente diferentes). É aqui que os Launch Profiles entram em jogo.

Como você sabe, projetos .NET têm um arquivo Properties/launchSettings.json que define diferentes perfis de inicialização. O Aspire é inteligente o suficiente para usar esses perfis. Por padrão, ele tenta usar um perfil no serviço que tenha o mesmo nome do perfil usado para iniciar o AppHost.

No entanto, podemos instruir o AppHost a usar um perfil de inicialização específico para um determinado projeto.

Vamos criar um perfil de depuração customizado para nosso ApiService:

1. No projeto MyAspireApp.ApiService, abra o arquivo Properties/launchSettings.json.
2. Dentro do objeto profiles, adicione um novo perfil chamado special-debug:

   "special-debug": {
     "commandName": "Project",
     "dotnetRunMessages": true,
     "launchBrowser": true,
     "launchUrl": "swagger",
     "applicationUrl": "https://localhost:7101;http://localhost:5101",
     "environmentVariables": {
       "ASPNETCORE_ENVIRONMENT": "Development",
       "SPECIAL_DEBUG_FLAG": "ENABLED" // Nossa variável customizada
     }
   }
   

3. Agora, no Program.cs do MyAspireApp.AppHost, modifique a linha que adiciona o ApiService para especificar este perfil:

   // Antes
   // var apiService = builder.AddProject<Projects.MyAspireApp_ApiService>("apiservice");
   
   // Depois
   var apiService = builder.AddProject<Projects.MyAspireApp_ApiService>("apiservice", launchProfileName: "special-debug");
   

4. Coloque um breakpoint em qualquer lugar no ApiService e inicie a depuração. Quando o breakpoint for atingido, use a janela de inspeção ou o console imediato para verificar o valor de Environment.GetEnvironmentVariable("SPECIAL_DEBUG_FLAG"). O valor deve ser ENABLED, confirmando que o Aspire iniciou o serviço usando seu perfil customizado.

Essa técnica é extremamente útil para alternar entre diferentes configurações de depuração sem ter que comentar/descomentar código ou alterar as configurações do projeto.

Conclusão

Nesta lição, você aprendeu a ir além da simples observação e a mergulhar na depuração ativa de aplicações .NET Aspire.

Principais Pontos:

• A experiência de depuração padrão ("F5") no Aspire anexa o depurador a todos os projetos .NET, permitindo a depuração transparente entre serviços.
• O Aspire Dashboard e o depurador do IDE são ferramentas complementares: use o dashboard para identificar onde está um problema e o depurador para descobrir porquê ele ocorre.
• Você pode usar launch profiles customizados e o método AddProject para ter um controle refinado sobre como cada serviço é iniciado durante a depuração.

Até agora, focamos em orquestrar e depurar nossos próprios projetos. Mas o poder do Aspire se estende muito além. Na próxima lição, vamos explorar os componentes e integrações do .NET Aspire, onde aprenderemos como o Aspire simplifica drasticamente a adição e configuração de dependências externas, como bancos de dados (PostgreSQL), caches (Redis) e filas de mensagens (RabbitMQ), tornando o ambiente de desenvolvimento local ainda mais robusto e próximo da produção.