Configuração remota da aplicação

Valores de configuração

Para permitir que o aplicativo ASP.NET Core se comunique com o aplicativo ASP.NET, é necessário fazer algumas pequenas alterações em cada aplicativo.

Você precisa configurar dois valores de configuração em ambos os aplicativos:

• RemoteAppApiKey: Uma chave (necessária para ser analisada como um GUID) que é compartilhada entre os dois aplicativos. Este deve ser um valor GUID como 12345678-1234-1234-1234-123456789012.
• RemoteAppUri: O URI do aplicativo remoto do ASP.NET Framework (necessário apenas na configuração do aplicativo ASP.NET Core). Essa deve ser a URL completa onde o aplicativo ASP.NET Framework está hospedado, como https://localhost:44300 ou https://myapp.example.com.

Configurar o aplicativo ASP.NET Framework

Para aplicativos do ASP.NET Framework, adicione estes valores ao seu web.config na <appSettings> seção :

<appSettings>
  <add key="RemoteAppApiKey" value="..." />
</appSettings>

Para configurar o aplicativo para estar disponível para lidar com as solicitações do cliente ASP.NET Core, configure o seguinte:

1. Instalar o pacote NuGet Microsoft.AspNetCore.SystemWebAdapters.FrameworkServices

2. Adicione o código de configuração ao método Application_Start no seu ficheiro Global.asax.cs.

   protected void Application_Start()
   {
       HttpApplicationHost.RegisterHost(builder =>
       {
           builder.AddSystemWebAdapters()
               .AddRemoteAppServer(options =>
               {
                   // ApiKey is a string representing a GUID
                   options.ApiKey = System.Configuration.ConfigurationManager.AppSettings["RemoteAppApiKey"];
               });
       });
   
       // ...existing code...
   }
   

3. Adicione o SystemWebAdapterModule módulo ao web.config se ainda não tiver sido adicionado pelo NuGet. Essa configuração de módulo é necessária para cenários de hospedagem do IIS. O SystemWebAdapterModule módulo não é adicionado automaticamente ao usar projetos no estilo SDK para ASP.NET Core.

     <system.webServer>
       <modules>
   +      <remove name="SystemWebAdapterModule" />
   +      <add name="SystemWebAdapterModule" type="Microsoft.AspNetCore.SystemWebAdapters.SystemWebAdapterModule, Microsoft.AspNetCore.SystemWebAdapters.FrameworkServices" preCondition="managedHandler" />
       </modules>
   </system.webServer>
   

Configurar ASP.NET aplicativo principal

Para aplicativos ASP.NET Core, adicione estes valores ao seu appsettings.json:

{
  "RemoteAppApiKey": "...",
  "RemoteAppUri": "https://localhost:44300"
}

Para configurar a aplicação ASP.NET Core para poder enviar solicitações para a aplicação ASP.NET, configure o cliente da aplicação remota chamando AddRemoteAppClient depois de registar os serviços do adaptador System.Web com AddSystemWebAdapters.

Adicione esta configuração ao seu Program.cs ficheiro:

builder.Services.AddSystemWebAdapters()
    .AddRemoteAppClient(options =>
    {
        options.RemoteAppUrl = new(builder.Configuration["RemoteAppUri"]);
        options.ApiKey = builder.Configuration["RemoteAppApiKey"];
    });

Com os aplicativos ASP.NET e ASP.NET Core atualizados, os métodos de extensão agora podem ser usados para configurar a autenticação remota de aplicativos ou a sessão remota, conforme necessário.

Ativar proxy

Para habilitar o proxy do aplicativo ASP.NET Core para o aplicativo ASP.NET Framework, você pode configurar uma rota de fallback que encaminha solicitações incomparáveis para o aplicativo herdado. Isso permite uma migração gradual em que o aplicativo ASP.NET Core lida com a funcionalidade migrada enquanto retorna ao aplicativo original para recursos não migrados.

1. Instale o pacote NuGet YARP (Yet Another Reverse Proxy) seguindo as orientações mais recentes.

2. Adicione as declarações 'using' necessárias ao seu Program.cs.

   using Microsoft.Extensions.Options;
   using Microsoft.AspNetCore.SystemWebAdapters;
   

3. Registre os serviços de proxy reverso em seu Program.cs:

   builder.Services.AddReverseProxy();
   

4. Depois de criar a aplicação e configurar outro middleware, adicione o mapeamento de rota de fallback:

   var app = builder.Build();
   
   // Configure your other middleware here (authentication, routing, etc.)
   
   // Map the fallback route
   app.MapForwarder("/{**catch-all}", app.Services.GetRequiredService<IOptions<RemoteAppClientOptions>>().Value.RemoteAppUrl.OriginalString)
   
       // Ensures this route has the lowest priority (runs last)
       .WithOrder(int.MaxValue)
   
       // Skips remaining middleware when this route matches
       .ShortCircuit();
   
   app.Run();
   

Configuração de orquestração Aspire

1. Adicionar Aspire orquestração para o aplicativo ASP.NET Framework

2. Adicione um novo aplicativo ASP.NET Core à solução e adicione-o à sua Aspire orquestração

3. Adicione o Aspire.Hosting.IncrementalMigration pacote ao seu projeto AppHost.

4. Configure o IIS Express para alojar localmente a sua aplicação de framework e configurar a recuperação de migração incremental utilizando as extensões de migração incremental.

   var builder = DistributedApplication.CreateBuilder(args);
   
   // Add ASP.NET Framework app with IIS Express
   var frameworkApp = builder.AddIISExpressProject<Projects.FrameworkApplication>("framework");
   
   // Add ASP.NET Core app with fallback to Framework app
   var coreApp = builder.AddProject<Projects.CoreApplication>("core")
       .WithIncrementalMigrationFallback(frameworkApp, options =>
       {
           options.RemoteSession = RemoteSession.Enabled;
           options.RemoteAuthentication = RemoteAuthentication.DefaultScheme;
       });
   
   builder.Build().Run();
   

5. Configure as opções da alternativa de migração incremental para os cenários que pretende apoiar.

Configurar ServiceDefaults para suportar ASP.NET Framework

1. Adicione o pacote Aspire.Microsoft.AspNetCore.SystemWebAdapters ao seu aplicativo.

2. Atualize o projeto ServiceDefaults para oferecer suporte ao .NET Framework. Isto é baseado no padrão ServiceDefaults e pode diferir se tiver personalizado alguma coisa.

   • Atualize a estrutura de destino para multitarget:

     - <TargetFramework>net10.0</TargetFramework>
     + <TargetFrameworks>net481;net10.0</TargetFrameworks>
     

   • Atualize o PackageReferences para levar em conta as diferentes estruturas:

     <ItemGroup>
         <PackageReference Include="Microsoft.Extensions.Http.Resilience" />
         <PackageReference Include="Microsoft.Extensions.ServiceDiscovery" />
         <PackageReference Include="OpenTelemetry.Exporter.OpenTelemetryProtocol" />
         <PackageReference Include="OpenTelemetry.Extensions.Hosting" />
         <PackageReference Include="OpenTelemetry.Instrumentation.Http" />
         <PackageReference Include="OpenTelemetry.Instrumentation.Runtime" />
         <PackageReference Include="OpenTelemetry.Instrumentation.SqlClient" />
     </ItemGroup>
     
     <ItemGroup Condition=" '$(TargetFramework)' == 'net10.0' ">
         <FrameworkReference Include="Microsoft.AspNetCore.App" />
         <PackageReference Include="OpenTelemetry.Instrumentation.AspNetCore" />
     </ItemGroup>
     
     <ItemGroup Condition=" '$(TargetFramework)' == 'net481' ">
         <PackageReference Include="Microsoft.Extensions.Diagnostics.HealthChecks" />
         <PackageReference Include="OpenTelemetry.Instrumentation.AspNet" />
     </ItemGroup>
     

   • Para habilitar a telemetria, atualize as métricas e os registros de rastreamento:

             builder.Services.AddOpenTelemetry()
                 .WithMetrics(metrics =>
                 {
                     metrics
     + #if NET
                         .AddAspNetCoreInstrumentation()
     + #else
     +                   .AddAspNetInstrumentation()
     + #endif
                         .AddSqlClientInstrumentation()
                         .AddHttpClientInstrumentation()
                         .AddRuntimeInstrumentation();
                 })
                 .WithTracing(tracing =>
                 {
                     tracing.AddSource(builder.Environment.ApplicationName)
     + #if NET
                         .AddAspNetCoreInstrumentation()
     + #else
     +                   .AddAspNetInstrumentation()
     + #endif
                         .AddSqlClientInstrumentation()
                         .AddHttpClientInstrumentation();
                 });
     

   • Desative os pontos de extremidade padrão, pois isso só se aplica ao ASP.NET Core:

     + #if NET
         public static WebApplication MapDefaultEndpoints(this WebApplication app)
         {
             // Default endpoint registrations
         }
     + #endif
     

   Para um exemplo completo e funcional de uma configuração multidirecionada ServiceDefaults que suporta tanto ASP.NET Core como ASP.NET Framework, consulte o ficheiro de exemplo Extensions.cs no repositório System.Web adapters: https://github.com/dotnet/systemweb-adapters/blob/main/samples/ServiceDefaults/Extensions.cs.

Configurar o aplicativo ASP.NET Framework

1. Fazer referência ao projeto ServiceDefaults

2. Adicione o código de configuração ao método Application_Start no seu ficheiro Global.asax.cs.

   protected void Application_Start()
   {
       HttpApplicationHost.RegisterHost(builder =>
       {
           builder.AddServiceDefaults();
           builder.AddSystemWebAdapters();
       });
   }
   

Configurar ASP.NET aplicativo principal

1. Fazer referência ao projeto ServiceDefaults

2. Adicione os adaptadores System.Web em Programs.cs:

   var builder = WebApplication.CreateBuilder();
   
   builder.AddServiceDefaults();
   + builder.AddSystemWebAdapters();
   
   ...
   
   var app = builder.Build();
   
   ...
   
   + // Must be placed after routing if manually added
   + app.UseSystemWebAdapters();
   
   ...
   
   + app.MapRemoteAppFallback()
   +
   +   // Optional, but recommended unless middleware is needed
   +   .ShortCircuit();
   
   app.Run();