Penembolokan terdistribusi di ASP.NET Core

Oleh Mohsin Nasir dan smandia

Cache terdistribusi adalah cache yang dibagikan oleh beberapa server aplikasi. Cache biasanya dipertahankan sebagai layanan eksternal untuk server aplikasi yang mengaksesnya. Cache terdistribusi dapat meningkatkan performa dan skalabilitas aplikasi ASP.NET Core, terutama ketika layanan cloud atau farm server menghosting aplikasi.

Cache terdistribusi memiliki beberapa keunggulan dibandingkan skenario caching lainnya yang menyimpan data cache di server aplikasi individual.

Saat data yang di-cache didistribusikan, data:

• Koheren (konsisten) pada setiap permintaan ke beberapa server.
• Mempertahankan diri dari restart server dan implementasi aplikasi berulang.
• Tidak menggunakan memori lokal.

Konfigurasi cache terdistribusi bergantung pada implementasi. Artikel ini menjelaskan cara mengonfigurasi cache terdistribusi SQL Server, Redis, atau Postgres. Implementasi non-Microsoft juga tersedia, seperti NCache (NCache pada GitHub), Azure Cosmos DB, dan Postgres. Terlepas dari implementasi mana yang dipilih, aplikasi berinteraksi dengan cache dengan menggunakan IDistributedCache antarmuka.

Melihat atau mengunduh kode sampel (cara mengunduh)

Warning

Artikel ini menggunakan database lokal yang tidak mengharuskan pengguna untuk diautentikasi. Aplikasi produksi harus menggunakan alur autentikasi paling aman yang tersedia. Untuk informasi selengkapnya tentang autentikasi untuk aplikasi pengujian dan produksi yang disebarkan, lihat Mengamankan alur autentikasi.

Prerequisites

Tambahkan referensi paket untuk penyedia cache terdistribusi yang digunakan:

• Untuk cache terdistribusi Redis, Microsoft.Extensions.Caching.StackExchangeRedis.
• Untuk SQL Server, Microsoft.Extensions.Caching.SqlServer.
• Untuk Postgres, Microsoft.Extensions.Caching.Postgres.
• Untuk Azure Cosmos DB, Microsoft. Extensions.Caching.Cosmos.
• Untuk cache terdistribusi NCache, NCache.Microsoft.Extensions.Caching.OpenSource.

Menggunakan antarmuka IDistributedCache

Antarmuka IDistributedCache menyediakan metode berikut untuk memanipulasi item dalam implementasi cache terdistribusi:

• Get, GetAsync: Menerima kunci string dan mengambil item yang di-cache sebagai byte[] array jika ditemukan di cache.
• Set, SetAsync: Menambahkan item (sebagai byte[] array) ke cache dengan menggunakan kunci string.
• Refresh, RefreshAsync: Menyegarkan item di dalam cache berdasarkan kunci, mengatur ulang batas waktu kedaluwarsa geser (jika ada).
• Remove, RemoveAsync: Menghapus item cache berdasarkan kunci stringnya.

Menetapkan layanan cache terdistribusi

Daftarkan implementasi IDistributedCache dalam file Program.cs . Implementasi yang disediakan kerangka kerja berikut dijelaskan dalam artikel ini:

• Cache Redis Terdistribusi
• Cache memori terdistribusi
• Cache terdistribusi SQL Server
• Cache Postgres Terdistribusi
• Cache terdistribusi NCache
• Cache Azure Cosmos DB terdistribusi

Cache Redis Terdistribusi

Cache Redis terdistribusi memberikan performa terbaik dan direkomendasikan untuk aplikasi produksi. Redis adalah penyimpanan data dalam memori sumber terbuka, yang sering digunakan sebagai cache terdistribusi. Anda dapat mengonfigurasi Azure Cache for Redis untuk aplikasi ASP.NET Core yang dihosting Azure, dan menggunakan Azure Cache for Redis untuk pengembangan lokal. Untuk informasi selengkapnya, lihat Meninjau rekomendasi cache.

Aplikasi mengonfigurasi implementasi cache dengan memanggil metode AddStackExchangeRedisCache pada instans RedisCache. Untuk penyimpanan sementara output, gunakan metode AddStackExchangeRedisOutputCache.

1. Buat instance dari Azure Cache untuk Redis.

2. Salin string koneksi utama (StackExchange.Redis) ke Configuration.

   • Untuk pengembangan lokal: Simpan string koneksi dengan Secret Manager.

   • Untuk Azure: Simpan string koneksi di penyimpanan aman seperti Azure Key Vault.

Kode berikut mengaktifkan Azure Cache for Redis:

builder.Services.AddStackExchangeRedisCache(options =>
 {
     options.Configuration = builder.Configuration.GetConnectionString("MyRedisConStr");
     options.InstanceName = "SampleInstance";
 });

Kode sebelumnya mengasumsikan string koneksi utama (StackExchange.Redis) disimpan dalam konfigurasi dengan nama kunci MyRedisConStr.

Untuk informasi selengkapnya, lihat Azure Managed Redis.

Untuk diskusi tentang pendekatan alternatif ke cache Redis lokal, lihat masalah GitHub /dotnet/aspnetcore #19542.

Cache memori terdistribusi

Cache memori terdistribusi (AddDistributedMemoryCache) adalah implementasi IDistributedCache yang disediakan kerangka kerja yang menyimpan item dalam memori. Namun, cache memori terdistribusi bukanlah cache terdistribusi yang sebenarnya. Instans aplikasi menyimpan item yang di-cache di server tempat aplikasi berjalan.

Cache memori terdistribusi adalah implementasi yang berguna untuk skenario pengembangan dan pengujian. Ini juga berguna untuk satu server dalam skenario produksi di mana konsumsi memori bukan masalah. Menerapkan cache memori terdistribusi mengabstraksi penyimpanan data cache. Ini memungkinkan untuk menerapkan solusi caching terdistribusi yang sesungguhnya di masa depan jika berbagai node atau toleransi kesalahan menjadi diperlukan.

Aplikasi sampel menggunakan cache memori terdistribusi saat aplikasi berjalan di Development lingkungan dalam file Program.cs .

builder.Services.AddDistributedMemoryCache();

Cache SQL Server terdistribusi

Implementasi cache SQL Server terdistribusi (AddDistributedSqlServerCache) memungkinkan cache terdistribusi menggunakan database SQL Server sebagai penyimpanan cadangannya. Untuk membuat tabel item cache SQL Server dalam instans SQL Server, Anda dapat menggunakan alat ini sql-cache . Alat ini membuat tabel dengan nama dan skema yang Anda tentukan.

Buat tabel di SQL Server dengan menjalankan sql-cache create perintah . Berikan instans SQL Server (Data Source), database (Initial Catalog), skema (misalnya, dbo), dan nama tabel (misalnya, TestCache):

dotnet sql-cache create "Data Source=(localdb)/MSSQLLocalDB;Initial Catalog=DistCache;Integrated Security=True;" dbo TestCache

Ketika alat berhasil, pesan dicatat:

Table and index were created successfully.

Tabel yang sql-cache dibuat oleh alat ini memiliki skema berikut:

Note

Aplikasi harus memanipulasi nilai cache dengan menggunakan instans IDistributedCache, bukan instans .SqlServerCache

Aplikasi sampel mengimplementasikan SqlServerCache kelas di lingkungan nondevelopment (Development) dalam file Program.cs :

builder.Services.AddDistributedSqlServerCache(options =>
{
    options.ConnectionString = builder.Configuration.GetConnectionString(
        "DistCache_ConnectionString");
    options.SchemaName = "dbo";
    options.TableName = "TestCache";
});

Note

Properti seperti ConnectionString (dan opsional, SchemaName dan TableName) biasanya disimpan di luar kontrol sumber. Misalnya, Secret Manager atau appsettings.json atau appsettings.{Environment}.json mungkin menyimpan properti-properti. string koneksi dapat berisi kredensial yang harus dijaga dari sistem kontrol sumber.

Untuk informasi selengkapnya, lihat SQL Database di Azure.

Cache Postgres Terdistribusi

Azure Database for PostgreSQL dapat digunakan sebagai penyimpanan backing cache terdistribusi melalui IDistributedCache antarmuka. Azure Database for PostgreSQL adalah penawaran Database-as-a-Service (DBaaS) siap-AI yang dikelola sepenuhnya yang dibangun di atas mesin PostgreSQL sumber terbuka. Desain ini mendukung beban kerja misi penting dengan performa yang dapat diprediksi, keamanan yang kuat, ketersediaan tinggi, dan skalabilitas yang mulus.

Setelah menginstal paket NuGet Microsoft.Extensions.Caching.Postgres , konfigurasikan cache terdistribusi Anda sebagai berikut:

1. Daftarkan Layanan.

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

2. Gunakan 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 terdistribusi

NCache adalah cache terdistribusi dalam memori sumber terbuka yang dikembangkan secara asli di .NET. NCache berfungsi baik secara lokal maupun dikonfigurasi sebagai kluster cache terdistribusi untuk aplikasi ASP.NET Core yang berjalan di Azure atau di platform hosting lainnya.

Untuk menginstal dan mengonfigurasi NCache di komputer lokal Anda, lihat Panduan Memulai.

Untuk mengonfigurasi NCache:

1. Instal paket NCache SDK NuGet, yang mendukung NCache Opensource untuk aplikasi .NET Framework dan .NET Core.

2. Konfigurasikan kluster cache dalam konfigurasi klien (file client.ncconf ).

3. Tambahkan kode berikut ke file Program.cs :

builder.Services.AddNCacheDistributedCache(configuration =>
{
    configuration.CacheName = "democache";
    configuration.EnableLogs = true;
    configuration.ExceptionsEnabled = true;
});

Cache Azure Cosmos DB terdistribusi

Azure Cosmos DB dapat dikonfigurasi di ASP.NET Core sebagai penyedia status sesi dengan menggunakan IDistributedCache antarmuka. Azure Cosmos DB adalah database NoSQL dan relasional yang dikelola sepenuhnya untuk pengembangan aplikasi modern yang menawarkan ketersediaan tinggi, skalabilitas, dan akses latensi rendah ke data untuk aplikasi misi penting.

Setelah Anda menginstal Microsoft. Extensions.Caching.Cosmos Paket NuGet, konfigurasikan cache terdistribusi Azure Cosmos DB. Anda dapat menggunakan klien Azure Cosmos DB yang sudah ada atau membuat klien baru, seperti yang dijelaskan di bagian berikut.

Untuk informasi lebih lanjut, lihat Ekstensi Penembolokan Microsoft menggunakan Azure Cosmos DB, berkas README di repositori GitHub untuk paket NuGet.

Menggunakan kembali klien yang sudah ada

Cara term mudah untuk mengonfigurasi cache terdistribusi adalah dengan menggunakan kembali klien Azure Cosmos DB yang ada. Dalam kasus ini, CosmosClient instans tidak dihapus saat penyedia dihapus.

services.AddCosmosCache((CosmosCacheOptions cacheOptions) =>
{
    cacheOptions.ContainerName = Configuration["CosmosCacheContainer"];
    cacheOptions.DatabaseName = Configuration["CosmosCacheDatabase"];
    cacheOptions.CosmosClient = existingCosmosClient;
    cacheOptions.CreateIfNotExists = true;
});

Membuat klien baru

Atau, buat klien baru. Dalam hal ini, CosmosClient instance dibuang ketika penyedia dibuang.

services.AddCosmosCache((CosmosCacheOptions cacheOptions) =>
{
    cacheOptions.ContainerName = Configuration["CosmosCacheContainer"];
    cacheOptions.DatabaseName = Configuration["CosmosCacheDatabase"];
    cacheOptions.ClientBuilder = new CosmosClientBuilder(Configuration["CosmosConnectionString"]);
    cacheOptions.CreateIfNotExists = true;
});

Menggunakan cache terdistribusi

Untuk menggunakan antarmuka IDistributedCache, mintalah instans IDistributedCache dalam aplikasi. Instans disediakan oleh injeksi dependensi (DI).

Saat aplikasi contoh dimulai, IDistributedCache instans disuntikkan ke dalam file Program.cs. Waktu saat ini di-cache dengan menggunakan IHostApplicationLifetime antarmuka. (Untuk informasi selengkapnya, lihat .NET Host Generik: 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.GetService<IDistributedCache>()
                              .Set("cachedTimeUTC", encodedCurrentTimeUTC, options);
});

Aplikasi sampel menyuntikkan instans IDistributedCache ke dalam objek IndexModel untuk digunakan oleh halaman indeks.

Setiap kali halaman Indeks dimuat, cache diperiksa untuk memeriksa waktu yang telah di-cache dengan menggunakan metode OnGetAsync. Jika waktu yang di-cache tidak kedaluwarsa, waktu ditampilkan. Jika 20 detik berlalu sejak terakhir kali waktu cache diakses (terakhir kali halaman ini dimuat), halaman menampilkan pesan, Waktu Singgahan Kedaluwarsa.

Segera perbarui waktu yang di-cache ke waktu saat ini dengan memilih opsi Reset Waktu Singgahan . Tindakan ini memicu metode penanganan OnPostResetCachedTime.

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

Anda tidak perlu menggunakan masa pakai Singleton atau Cakupan untuk IDistributedCache instans dengan implementasi bawaan.

Anda juga dapat membuat IDistributedCache instans di mana pun Anda mungkin memerlukannya alih-alih menggunakan DI. Namun, membuat instans dalam kode dapat membuat kode Anda lebih sulit untuk menguji dan melanggar Prinsip Dependensi Eksplisit.

Meninjau rekomendasi cache

Saat memutuskan implementasi IDistributedCache antarmuka mana yang terbaik untuk aplikasi Anda, pertimbangkan poin-poin berikut:

• Infrastruktur yang ada
• Persyaratan performa
• Cost
• Pengalaman tim

Solusi caching biasanya mengandalkan penyimpanan dalam memori untuk mempercepat pengambilan data yang di-cache, tetapi memori adalah sumber daya terbatas dan memperluasnya mahal. Hanya simpan data yang umum digunakan dalam cache.

Untuk sebagian besar aplikasi, cache Redis menyediakan throughput yang lebih tinggi dan latensi yang lebih rendah daripada cache SQL Server. Namun, pengujian disarankan untuk menentukan karakteristik performa strategi caching.

Jika SQL Server adalah penyimpanan backing cache terdistribusi, dan penyimpanan/pengambilan data cache dan aplikasi menggunakan database yang sama, performa dapat dikurangi. Pendekatan yang direkomendasikan adalah menggunakan instans SQL Server khusus untuk penyimpanan backing cache terdistribusi.

Konten terkait

• Redis Cache di Azure
• SQL Database di Azure
• Azure Database for PostgreSQL
• ASP.NET Core IDistributedCache Provider untuk NCache di Web Farms (NCache di GitHub)
• File README repositori untuk Microsoft.Extensions.Caching.Cosmos
• Mendeteksi perubahan dengan token perubahan di ASP.NET Core
• Pembantu Tag Cache di ASP.NET Core MVC
• Pembantu Tag Singgahan Terdistribusi di ASP.NET Core
• Menghosting ASP.NET Core di kumpulan server web