Remote-App-Einrichtung

Konfigurationswerte

Damit die ASP.NET Core-App mit der ASP.NET-App kommunizieren kann, müssen Sie für jede App einige kleine Änderungen vornehmen.

Sie müssen zwei Konfigurationswerte in beiden Anwendungen konfigurieren:

• RemoteAppApiKey: Ein Schlüssel (muss als GUID analysiert werden), der zwischen den beiden Anwendungen gemeinsam genutzt wird. Dies sollte ein GUID-Wert wie 12345678-1234-1234-1234-123456789012 sein.
• RemoteAppUri: Der URI der Remote-ASP.NET Framework-Anwendung (nur in der ASP.NET Core-Anwendungskonfiguration erforderlich). Dies sollte die vollständige URL sein, unter der die ASP.NET Framework-App gehostet wird, wie https://localhost:44300 oder https://myapp.example.com.

Konfigurieren ASP.NET Framework-Anwendung

Für ASP.NET Framework-Anwendungen, fügen Sie diese Werte zu Ihrem web.config in the <appSettings> Abschnitt:

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

Um die Anwendung so zu konfigurieren, dass sie verfügbar ist, um die Anforderungen vom ASP.NET Core-Client zu verarbeiten, richten Sie Folgendes ein:

1. Installieren des NuGet-Pakets Microsoft.AspNetCore.SystemWebAdapters.FrameworkServices

2. Fügen Sie den Konfigurationscode zu den Application_Start Methode in Ihrer Global.asax.cs Datei:

   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. Fügen Sie das SystemWebAdapterModule Modul dem web.config Modul hinzu, wenn es noch nicht von NuGet hinzugefügt wurde. Diese Modulkonfiguration ist für IIS-Hostingszenarien erforderlich. Das SystemWebAdapterModule Modul wird nicht automatisch hinzugefügt, wenn SDK-Stilprojekte für ASP.NET Core verwendet werden.

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

Konfigurieren ASP.NET Kernanwendung

Fügen Sie für ASP.NET Core-Anwendungen diese Werte zu Ihrem appsettings.json:

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

Um die ASP.NET Core-App einzurichten, um Anforderungen an die ASP.NET-App senden zu können, konfigurieren Sie den Remote-App-Client, indem Sie AddRemoteAppClient nach der Registrierung von System.Web Adapter-Diensten bei AddSystemWebAdaptersaufrufen.

Fügen Sie ihrer Program.cs Datei diese Konfiguration hinzu:

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

Da sowohl die ASP.NET als auch ASP.NET Core-Apps aktualisiert wurden, können Erweiterungsmethoden jetzt bei Bedarf zum Einrichten der Remote-App-Authentifizierung oder Remotesitzung verwendet werden.

Proxys aktivieren

Um proxying from the ASP.NET Core application to the ASP.NET Framework application zu aktivieren, können Sie eine Fallbackroute einrichten, die nicht übereinstimmende Anforderungen an die Legacyanwendung weiterleitet. Dies ermöglicht eine schrittweise Migration, bei der die ASP.NET Core-App migrierte Funktionen verarbeitet, während sie auf die ursprüngliche App zurückfällt, um nicht migrierte Funktionen zu nutzen.

1. Installieren Sie das NuGet-Paket YARP (Yet Another Reverse Proxy) nach den neuesten Anleitungen.

2. Fügen Sie die erforderlichen mit-Anweisungen zu Ihren Program.cs:

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

3. Registrieren Sie die Reverse-Proxy-Dienste in Ihrem Program.cs:

   builder.Services.AddReverseProxy();
   

4. Nachdem Sie die App erstellt und andere Middleware konfiguriert haben, fügen Sie die Fallbackroutenzuordnung hinzu:

   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();
   

Einrichten Aspire der Orchestrierung

1. Hinzufügen der Orchestrierung Aspire für die ASP.NET Framework-Anwendung

2. Fügen Sie der Lösung eine neue ASP.NET Core-Anwendung hinzu, und fügen Sie sie ihrer Aspire Orchestrierung hinzu.

3. Fügen Sie das Aspire.Hosting.IncrementalMigration Paket zu Ihrem AppHost-Projekt hinzu.

4. Konfigurieren Sie IIS Express so, dass Sie Ihre Frameworkanwendung lokal hosten und inkrementelle Migrationsfallbacks mithilfe der inkrementellen Migrationserweiterungen konfigurieren:

   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. Konfigurieren Sie die Optionen des inkrementellen Migrationsfallbacks für die Szenarien, die Sie unterstützen möchten.

Konfigurieren von ServiceDefaults zur Unterstützung von ASP.NET Framework

1. Fügen Sie das Paket Aspire.Microsoft.AspNetCore.SystemWebAdapters zu Ihrer Anwendung hinzu.

2. Aktualisieren Sie das ServiceDefaults-Projekt, um .NET Framework zu unterstützen. Dies basiert auf den Standardmäßigen ServiceDefaults und kann variieren, wenn Sie etwas angepasst haben.

   • Aktualisieren Sie den Zielrahmen auf Multitarget:

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

   • Aktualisieren Sie die PackageReferences so, dass sie die verschiedenen Frameworks berücksichtigen:

     <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>
     

   • Um Telemetrie zu aktivieren, aktualisieren Sie die Metriken und Ablaufverfolgungsregistrierungen:

             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();
                 });
     

   • Deaktivieren Sie die Standardendpunkte, da dies nur für ASP.NET Core gilt:

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

   Ein vollständiges, funktionierendes Beispiel für eine multiorientierte ServiceDefaults Konfiguration, die sowohl ASP.NET Core als auch ASP.NET Framework unterstützt, finden Sie in der Beispieldatei Extensions.cs im Repository "System.Web adapters": https://github.com/dotnet/systemweb-adapters/blob/main/samples/ServiceDefaults/Extensions.cs.

Konfigurieren ASP.NET Framework-Anwendung

1. Verweisen auf das ServiceDefaults-Projekt

2. Fügen Sie den Konfigurationscode zu den Application_Start Methode in Ihrer Global.asax.cs Datei:

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

Konfigurieren ASP.NET Kernanwendung

1. Verweisen auf das ServiceDefaults-Projekt

2. Fügen Sie die System.Web-Adapter in Programs.cs hinzu:

   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();