Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
Di Mohsin Nasir e smandia
Note
Questa non è la versione più recente di questo articolo. Per la versione corrente, vedere la versione .NET 11 di questo articolo.
Una cache distribuita è una cache condivisa da più server app. La cache viene in genere mantenuta come servizio esterno per i server app che vi accedono. Una cache distribuita può migliorare le prestazioni e la scalabilità di un'app ASP.NET Core, soprattutto quando un servizio cloud o una server farm ospita l'app.
Una cache distribuita offre diversi vantaggi rispetto ad altri scenari di memorizzazione nella cache in cui i dati memorizzati nella cache vengono archiviati in singoli server app.
Quando i dati memorizzati nella cache vengono distribuiti, i dati:
- Il sistema è coerente (consistente) tra le richieste a più server.
- Sopravvive ai riavvii del server e alle distribuzioni di app.
- Non usa memoria locale.
La configurazione della cache distribuita è specifica dell'implementazione. Questo articolo descrive come configurare le cache distribuite di SQL Server, Redis o Postgres. Sono disponibili anche implementazioni non Microsoft, ad esempio NCache (NCache in GitHub), Azure Cosmos DB e Postgres. Indipendentemente dall'implementazione selezionata, l'app interagisce con la cache usando l'interfaccia IDistributedCache .
Visualizzare o scaricare il codice di esempio (come scaricare)
Warning
Questo articolo usa un database locale che non richiede l'autenticazione dell'utente. Le app di produzione devono usare il flusso di autenticazione più sicuro disponibile. Per altre informazioni sull'autenticazione per le app di test e produzione distribuite, vedere Proteggere i flussi di autenticazione.
Prerequisites
Aggiungere un riferimento al pacchetto per il provider di cache distribuita usato:
- Per una cache distribuita Redis, Microsoft.Extensions.Caching.StackExchangeRedis.
- Per SQL Server, Microsoft.Extensions.Caching.SqlServer.
- Per Postgres, Microsoft.Extensions.Caching.Postgres.
- Per Azure Cosmos DB, Microsoft.Extensions.Caching.Cosmos.
- Per la cache distribuita NCache, NCache.Microsoft.Extensions.Caching.OpenSource.
Usare l'interfaccia IDistributedCache
L'interfaccia IDistributedCache fornisce i metodi seguenti per modificare gli elementi nell'implementazione della cache distribuita:
-
Get, GetAsync: Accetta una chiave di tipo stringa e recupera un elemento memorizzato nella cache come array
byte[], se presente. -
Set, SetAsync: aggiunge un elemento (come
byte[]matrice) alla cache usando una chiave stringa. - Refresh, RefreshAsync: Aggiorna un elemento nella cache in base alla chiave, reimpostando il timeout di scadenza variabile (se presente).
- Remove, RemoveAsync: rimuove un elemento della cache in base alla relativa chiave stringa.
Archiviare oggetti diversi da matrici di byte
IDistributedCache archivia i valori come array byte[]. Per memorizzare nella cache altri tipi, serializzarli per primi. I metodi di estensione seguenti usano System.Text.Json per archiviare qualsiasi tipo serializzabile come JSON UTF-8:
using System.Text.Json;
using Microsoft.Extensions.Caching.Distributed;
public static class DistributedCacheExtensions
{
public static Task SetAsync<T>(this IDistributedCache cache, string key, T value,
DistributedCacheEntryOptions options, CancellationToken token = default) =>
cache.SetAsync(key, JsonSerializer.SerializeToUtf8Bytes(value), options, token);
public static async Task<T?> GetAsync<T>(this IDistributedCache cache, string key,
CancellationToken token = default)
{
var bytes = await cache.GetAsync(key, token);
return bytes is null ? default : JsonSerializer.Deserialize<T>(bytes);
}
}
GetAsync<T> restituisce il valore predefinito del tipo, ad esempio null, quando la chiave non si trova nella cache.
Tip
La HybridCache libreria serializza automaticamente i valori e aggiunge una cache primaria in-process e una protezione dallo stampede della cache oltre alla cache distribuita.
Stabilire servizi di memorizzazione nella cache distribuita
Registrare un'implementazione di IDistributedCache nel file Program.cs . Le implementazioni fornite dal framework seguenti sono descritte in questo articolo:
- Cache distribuita Redis
- Cache di memoria distribuita
- Cache distribuita di SQL Server
- Cache Postgres distribuito
- Cache distribuita NCache
- Cache distribuita di Azure Cosmos DB
Cache Redis distribuita
La cache Redis distribuita offre prestazioni ottimali ed è consigliata per le app di produzione. Redis è un archivio dati open source in memoria, che viene spesso usato come cache distribuita. È possibile configurare un cache di Azure per Redis per un'app ASP.NET Core ospitata in Azure e usare un cache di Azure per Redis per lo sviluppo locale. Per altre informazioni, vedere Esaminare le raccomandazioni della cache.
Un'app configura l'implementazione della cache con un'istanza RedisCache chiamando il AddStackExchangeRedisCache metodo . Per la memorizzazione nella cache dell'output, usare il metodo .
Creare un'istanza di cache di Azure per Redis.
Copiare la stringa di connessione primaria (StackExchange.Redis) in Configuration.
Per lo sviluppo locale: salvare il stringa di connessione con Secret Manager.
Per Azure: salva il stringa di connessione in un archivio sicuro, ad esempio Azure Key Vault.
Il codice seguente abilita il cache di Azure per Redis:
builder.Services.AddStackExchangeRedisCache(options =>
{
options.Configuration = builder.Configuration.GetConnectionString("MyRedisConStr");
options.InstanceName = "SampleInstance";
});
Il codice sopra presuppone che la stringa di connessione primaria (StackExchange.Redis) sia salvata nella configurazione con il nome della chiave MyRedisConStr.
Per altre informazioni, vedere Azure Managed Redis.
Per una discussione sugli approcci alternativi a una cache Redis locale, vedere GitHub problema /dotnet/aspnetcore #19542.
Cache di memoria distribuita
La cache di memoria distribuita (AddDistributedMemoryCache) è un'implementazione fornita dal framework di IDistributedCache che archivia gli elementi in memoria. Tuttavia, la cache di memoria distribuita non è una cache distribuita effettiva. L'istanza dell'app archivia gli elementi memorizzati nella cache nel server in cui è in esecuzione l'app.
La cache di memoria distribuita è un'implementazione utile per scenari di sviluppo e test. È utile anche per un singolo server in uno scenario di produzione in cui l'utilizzo della memoria non è un problema. L'implementazione della cache di memoria distribuita astrae l'archiviazione dei dati memorizzata nella cache. Consente di implementare una vera soluzione di memorizzazione nella cache distribuita in futuro se sono necessari più nodi o tolleranza di errore.
L'app di esempio usa la cache di memoria distribuita quando l'app viene eseguita nell'ambiente Development nel file Program.cs .
builder.Services.AddDistributedMemoryCache();
Cache SQL Server distribuita
L'implementazione della cache SQL Server distribuita (AddDistributedSqlServerCache) consente alla cache distribuita di usare un database SQL Server come archivio di backup. Per creare una tabella di elementi memorizzata nella cache di SQL Server in un'istanza di SQL Server, è possibile usare lo sql-cache strumento . Lo strumento crea una tabella con il nome e lo schema specificati.
Creare una tabella in SQL Server eseguendo il sql-cache create comando . Specificare l'istanza di SQL Server (Data Source), il database (Initial Catalog), lo schema (ad esempio, dbo) e il nome della tabella (ad esempio, TestCache):
dotnet sql-cache create "Data Source=(localdb)/MSSQLLocalDB;Initial Catalog=DistCache;Integrated Security=True;" dbo TestCache
Quando lo strumento ha esito positivo, viene registrato un messaggio:
Table and index were created successfully.
La tabella creata dallo sql-cache strumento ha lo schema seguente:
Note
Un'app deve modificare i valori della cache usando un'istanza di IDistributedCache, non un'istanza di SqlServerCache.
L'app di esempio implementa la SqlServerCache classe in un ambiente non di sviluppo (Development) nel file Program.cs :
builder.Services.AddDistributedSqlServerCache(options =>
{
options.ConnectionString = builder.Configuration.GetConnectionString(
"DistCache_ConnectionString");
options.SchemaName = "dbo";
options.TableName = "TestCache";
});
Note
Le proprietà come ConnectionString (e facoltativamente SchemaName , e TableName) vengono in genere archiviate all'esterno del controllo del codice sorgente. Ad esempio, Secret Manager o ilappsettings.json o appsettings.{ Environment}.json file potrebbe archiviare le proprietà. Il stringa di connessione può contenere credenziali che devono essere mantenute fuori dai sistemi di controllo del codice sorgente.
Per altre informazioni, vedere database SQL in Azure.
Cache Postgres distribuita
Database di Azure per PostgreSQL può essere usato come archivio di supporto della cache distribuita tramite l'interfaccia IDistributedCache. Database di Azure per PostgreSQL è un'offerta DBaaS (Database as a Service) completamente gestita e pronta per l'intelligenza artificiale basata sul motore PostgreSQL open source. La progettazione supporta carichi di lavoro cruciali con prestazioni prevedibili, sicurezza affidabile, disponibilità elevata e scalabilità senza problemi.
Dopo aver installato il pacchetto NuGet Microsoft.Extensions.Caching.Postgres , configurare la cache distribuita come segue:
Registrare il servizio.
using Microsoft.Extensions.DependencyInjection; var builder = WebApplication.CreateBuilder(args); // Register the Postgres distributed cache. builder.Services.AddDistributedPostgresCache(options => { options.ConnectionString = builder.Configuration.GetConnectionString("PostgresCache"); options.SchemaName = builder.Configuration.GetValue<string>("PostgresCache:SchemaName", "public"); options.TableName = builder.Configuration.GetValue<string>("PostgresCache:TableName", "cache"); options.CreateIfNotExists = builder.Configuration.GetValue<bool>("PostgresCache:CreateIfNotExists", true); options.UseWAL = builder.Configuration.GetValue<bool>("PostgresCache:UseWAL", false); // Optional: Configure expiration settings. var expirationInterval = builder.Configuration.GetValue<string>("PostgresCache:ExpiredItemsDeletionInterval"); if (!string.IsNullOrEmpty(expirationInterval) && TimeSpan.TryParse(expirationInterval, out var interval)) { options.ExpiredItemsDeletionInterval = interval; } var slidingExpiration = builder.Configuration.GetValue<string>("PostgresCache:DefaultSlidingExpiration"); if (!string.IsNullOrEmpty(slidingExpiration) && TimeSpan.TryParse(slidingExpiration, out var sliding)) { options.DefaultSlidingExpiration = sliding; } }); var app = builder.Build();Usare la cache.
public class MyService { private readonly IDistributedCache _cache; public MyService(IDistributedCache cache) { _cache = cache; } public async Task<string> GetDataAsync(string key) { var cachedData = await _cache.GetStringAsync(key); if (cachedData == null) { // Fetch the data from source. var data = await FetchDataFromSource(); // Cache the data with options. var options = new DistributedCacheEntryOptions { AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(30), SlidingExpiration = TimeSpan.FromMinutes(5) }; await _cache.SetStringAsync(key, data, options); return data; } return cachedData; } }
Cache NCache distribuita
NCache è una cache distribuita in memoria open source sviluppata in modo nativo in .NET. NCache funziona sia in locale che configurato come cluster di cache distribuita per un'app ASP.NET Core in esecuzione in Azure o in altre piattaforme di hosting.
Per installare e configurare NCache nel computer locale, vedere la Guida introduttiva.
Per configurare NCache:
Installare il pacchetto NuGet NCache SDK, che supporta NCache Opensource per .NET Framework e .NET app Core.
Configurare il cluster della cache nella configurazione del client (nel file client.ncconf).
Aggiungere il codice seguente al file Program.cs :
builder.Services.AddNCacheDistributedCache(configuration =>
{
configuration.CacheName = "democache";
configuration.EnableLogs = true;
configuration.ExceptionsEnabled = true;
});
Cache Azure Cosmos DB distribuita
Azure Cosmos DB può essere configurato in ASP.NET Core come provider di stato della sessione usando l'interfaccia IDistributedCache . Azure Cosmos DB è un database noSQL e relazionale completamente gestito per lo sviluppo di app moderne che offre disponibilità elevata, scalabilità e accesso a bassa latenza ai dati per applicazioni cruciali.
Dopo aver installato il Microsoft. Extensions.Caching.Cosmos pacchetto NuGet, configurare una cache distribuita Azure Cosmos DB. È possibile usare un client Azure Cosmos DB esistente o crearne uno nuovo, come descritto nelle sezioni seguenti.
Per altre informazioni, vedere l'estensione Microsoft caching usando Azure Cosmos DB, il file README del repository GitHub per il pacchetto NuGet.
Riutilizzare un client esistente
Il modo più semplice per configurare una cache distribuita consiste nel riutilizzare un client di Azure Cosmos DB esistente. In questo caso, l'istanza CosmosClient non viene eliminata quando il provider viene eliminato.
services.AddCosmosCache((CosmosCacheOptions cacheOptions) =>
{
cacheOptions.ContainerName = Configuration["CosmosCacheContainer"];
cacheOptions.DatabaseName = Configuration["CosmosCacheDatabase"];
cacheOptions.CosmosClient = existingCosmosClient;
cacheOptions.CreateIfNotExists = true;
});
Creare un nuovo client
In alternativa, creare un'istanza di un nuovo client. In questo caso, l'istanza CosmosClient viene eliminata quando il provider viene eliminato.
services.AddCosmosCache((CosmosCacheOptions cacheOptions) =>
{
cacheOptions.ContainerName = Configuration["CosmosCacheContainer"];
cacheOptions.DatabaseName = Configuration["CosmosCacheDatabase"];
cacheOptions.ClientBuilder = new CosmosClientBuilder(Configuration["CosmosConnectionString"]);
cacheOptions.CreateIfNotExists = true;
});
Usare la cache distribuita
Per usare l'interfaccia IDistributedCache , richiedere un'istanza di IDistributedCache nell'app. L'istanza è fornita da dependency injection (DI).
All'avvio dell'app di esempio, l'istanza IDistributedCache viene inserita nel file Program.cs . L'ora corrente viene memorizzata nella cache tramite l'interfaccia IHostApplicationLifetime . Per altre informazioni, vedere .NET Host generico: IHostApplicationLifetime.
app.Lifetime.ApplicationStarted.Register(() =>
{
var currentTimeUTC = DateTime.UtcNow.ToString();
byte[] encodedCurrentTimeUTC = System.Text.Encoding.UTF8.GetBytes(currentTimeUTC);
var options = new DistributedCacheEntryOptions()
.SetSlidingExpiration(TimeSpan.FromSeconds(20));
app.Services.GetRequiredService<IDistributedCache>()
.Set("cachedTimeUTC", encodedCurrentTimeUTC, options);
});
L'app di esempio inserisce l'istanza IDistributedCache nell'oggetto IndexModel da usare dalla pagina Index.
Ogni volta che viene caricata la pagina Indice, la cache viene verificata per il tempo memorizzato nella cache usando il OnGetAsync metodo . Se l'ora memorizzata nella cache non è scaduta, viene visualizzata l'ora. Se sono trascorsi 20 secondi dall'ultima volta che è stato eseguito l'accesso alla cache (l'ultima volta che questa pagina è stata caricata), nella pagina viene visualizzato il messaggio Ora memorizzata nella cache scaduta.
Aggiornare immediatamente l'ora memorizzata nella cache all'ora corrente selezionando l'opzione Reimposta ora memorizzata nella cache . Questa azione attiva il OnPostResetCachedTime metodo del gestore.
public class IndexModel : PageModel
{
private readonly IDistributedCache _cache;
public IndexModel(IDistributedCache cache)
{
_cache = cache;
}
public string? CachedTimeUTC { get; set; }
public string? ASP_Environment { get; set; }
public async Task OnGetAsync()
{
CachedTimeUTC = "Cached Time Expired";
var encodedCachedTimeUTC = await _cache.GetAsync("cachedTimeUTC");
if (encodedCachedTimeUTC != null)
{
CachedTimeUTC = Encoding.UTF8.GetString(encodedCachedTimeUTC);
}
ASP_Environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
if (String.IsNullOrEmpty(ASP_Environment))
{
ASP_Environment = "Null, so Production";
}
}
public async Task<IActionResult> OnPostResetCachedTime()
{
var currentTimeUTC = DateTime.UtcNow.ToString();
byte[] encodedCurrentTimeUTC = Encoding.UTF8.GetBytes(currentTimeUTC);
var options = new DistributedCacheEntryOptions()
.SetSlidingExpiration(TimeSpan.FromSeconds(20));
await _cache.SetAsync("cachedTimeUTC", encodedCurrentTimeUTC, options);
return RedirectToPage();
}
}
Note
Non è necessario usare una durata singleton o con ambito per le istanze IDistributedCache con un'implementazione predefinita.
È anche possibile creare un'istanza IDistributedCache ovunque possa servire, invece di utilizzare l'inserimento delle dipendenze. Tuttavia, la creazione di un'istanza nel codice può rendere il codice più difficile da testare e violare il principio delle dipendenze esplicite.
Revisione delle raccomandazioni della cache
Quando decidi quale implementazione dell'interfaccia è migliore per la IDistributedCache tua app, prendi in considerazione i punti seguenti:
- Infrastruttura esistente
- Requisiti di prestazioni
- Cost
- Esperienza del team
Le soluzioni di memorizzazione nella cache si basano in genere sull'archiviazione in memoria per fornire un recupero rapido dei dati memorizzati nella cache, ma la memoria è una risorsa limitata e costosa da espandere. Archiviare solo i dati di uso comune in una cache.
Per la maggior parte delle app, una cache Redis offre una velocità effettiva più elevata e una latenza inferiore rispetto a una cache di SQL Server. Tuttavia, è consigliabile eseguire il benchmarking per determinare le caratteristiche delle prestazioni delle strategie di memorizzazione nella cache.
Se SQL Server è l'archivio di backup della cache distribuita e la cache e l'archiviazione/recupero dei dati dell'app usano lo stesso database, le prestazioni possono essere ridotte. L'approccio consigliato consiste nell'usare un'istanza di SQL Server dedicata per l'archivio di backup della cache distribuita.
Contenuti correlati
- Cache Redis in Azure
- Database SQL in Azure
- Database di Azure per PostgreSQL
- ASP.NET Core provider IDistributedCache per NCache nelle Web farm (NCache su GitHub)
- File README del repository di Microsoft.Extensions.Caching.Cosmos
- Rilevare le modifiche con i token di modifica in ASP.NET Core
- Cache Tag Helper in ASP.NET Core MVC
- Helper tag cache distribuita in ASP.NET Core
- Ospitare ASP.NET Core in una Web farm