gRPC e AOT nativo

Di James Newton-King

gRPC supporta .NET native in anticipo (AOT) in .NET 8. AOT nativo consente di pubblicare app server e client gRPC come file eseguibili nativi di piccole dimensioni e veloci.

Avvertimento

In .NET 8, non tutte le funzionalità di ASP.NET Core sono compatibili con Native AOT. Per altre informazioni, vedere compatibilità ASP.NET Core e Native AOT.

Inizia subito

La compilazione AOT si verifica quando l'app viene pubblicata. L'AOT nativo è abilitato con l'opzione PublishAot .

1. Aggiungere <PublishAot>true</PublishAot> al file di progetto del client gRPC o dell'app server. In questo modo si abiliterà la compilazione AOT nativa durante la pubblicazione e abiliterà l'analisi dinamica dell'utilizzo del codice durante la compilazione e la modifica.

   <Project Sdk="Microsoft.NET.Sdk.Web">
   
     <PropertyGroup>
       <TargetFramework>net8.0</TargetFramework>
       <PublishAot>true</PublishAot>
     </PropertyGroup>
   
     <ItemGroup>
       <PackageReference Include="Grpc.AspNetCore" Version="2.51.0" />
       <PackageReference Include="Google.Protobuf" Version="3.22.0" />
     </ItemGroup>
   
   </Project>
   

   È anche possibile abilitare AOT nativo specificando l'opzione --aot con il modello ASP.NET Core gRPC:

   dotnet new grpc --aot
   

2. Pubblica l'app per uno specifico identificatore di runtime (RID) usando dotnet publish -r <RID>.

L'app è disponibile nella directory di pubblicazione e contiene tutto il codice necessario per eseguirlo.

L'analisi AOT nativa include tutto il codice dell'app e le librerie da cui dipende l'app. Esaminare gli avvisi AOT nativi e adottare misure correttive. È consigliabile testare frequentemente le app di pubblicazione per individuare i problemi all'inizio del ciclo di vita dello sviluppo.

Ottimizzare le dimensioni di pubblicazione

Un eseguibile AOT nativo contiene solo il codice delle dipendenze esterne necessarie per supportare l'app. Il codice inutilizzato viene eliminato automaticamente.

Le dimensioni di pubblicazione di un servizio ASP.NET Core gRPC possono essere ottimizzate creando il generatore di host con WebApplication.CreateSlimBuilder(). Questo generatore fornisce un elenco minimo di funzionalità necessarie per eseguire un'app ASP.NET Core.

var builder = WebApplication.CreateSlimBuilder(args);
builder.Services.AddGrpc();

var app = builder.Build();
app.MapGrpcService<GreeterService>();
app.Run();

Vantaggi dell'uso di AOT nativo

Le app pubblicate con AOT nativo hanno:

• Footprint del disco ridotto al minimo
• Tempo di avvio ridotto
• Ridurre la domanda di memoria

Per altre informazioni ed esempi dei vantaggi offerti da Native AOT, vedere Vantaggi dell'uso di AOT nativo con ASP.NET Core.

Risorse aggiuntive

• Supporto per l'AOT nativo in ASP.NET Core
• Distribuzione AOT nativa