Hızlı Başlangıç: .NET Core Redis için Azure Cache da ağ kullanma

Bu hızlı başlangıçta, Azure'Redis için Azure Cache herhangi bir uygulama tarafından erişilebilen güvenli ve ayrılmış bir önbelleğe erişim sağlamak için bir .NET Core uygulamasına uygulama dahil edin. StackExchange.Redis istemcisini bir .NET Core konsol uygulamasında C# koduyla özellikle kullanırsınız.

GitHub'de koda atla

Doğrudan koda atlamak için bkz. .NET Core hızlı başlangıç GitHub.

Önkoşullar

• Azure aboneliği - ücretsiz bir abonelik oluşturun
• .NET Core SDK

Bir önbellek oluşturma

1. Önbellek oluşturmak için Azure Portal oturum açın ve kaynak oluştur' u seçin.

   

2. Yeni sayfada veritabanları ' nı seçin ve ardından redsıs için Azure önbelleği' ni seçin.

   

3. Yeni Redis Cache sayfasında, yeni önbelleğiniz için ayarları yapılandırın.

   Ayar	Değer seçme	Açıklama
   Abonelik	Açılır ve aboneliğinizi seçin.	Redsıs örneği için bu yeni Azure önbelleğinin oluşturulacağı abonelik.
   Kaynak grubu	Açılır ve bir kaynak grubu seçin veya Yeni oluştur ' u seçin ve yeni bir kaynak grubu adı girin.	Önbelleğinizin ve diğer kaynaklarınızın oluşturulacağı kaynak grubunun adı. Tüm uygulama kaynaklarınızı tek bir kaynak grubuna yerleştirerek, bunları birlikte kolayca yönetebilir veya silebilirsiniz.
   DNS adı	Benzersiz bir ad girin.	Önbellek adı yalnızca rakam, harf veya kısa çizgi içeren 1 ile 63 karakter arasında bir dize olmalıdır. Ad bir sayı veya harfle başlamalı ve bitmeli ve ardışık kısa çizgi içeremez. Önbellek örneğinizin ana bilgisayar adı <DNS name> . Redis.cache.Windows.net olacaktır.
   Konum	Açılır ve bir konum seçin.	Önbelleğinizi kullanacak diğer hizmetlerin yakınında bir bölge seçin.
   Önbellek türü	Açılır ve bir Katmanseçin.	Katman, önbellek için kullanılabilen boyut, performans ve özellikleri belirler. Daha fazla bilgi için bkz. redsıs Için Azure önbelleği 'Ne genel bakış.

4. Ağ sekmesini seçin veya sayfanın altındaki ağ düğmesini seçin.

5. Ağ sekmesinde, bağlantı yönteminizi seçin.

6. İleri: Gelişmiş sekmesini seçin veya sayfanın altındaki İleri: Gelişmiş düğmesini seçin.

7. Bir temel veya standart önbellek örneğinin Gelişmiş SEKMESINDE, TLS olmayan bir bağlantı noktasını etkinleştirmek istiyorsanız geçişi etkinleştir ' i seçin. Ayrıca, 4 veya 6 ' da kullanmak istediğiniz redo sürümünü seçebilirsiniz.

   

8. Premium önbellek örneğinin Gelişmiş SEKMESINDE, TLS olmayan bağlantı noktası, kümeleme ve veri kalıcılığı için ayarları yapılandırın. Ayrıca, 4 veya 6 ' da kullanmak istediğiniz redo sürümünü seçebilirsiniz.

9. Sonraki: Etiketler sekmesini seçin veya sayfanın altındaki Sonraki: Etiketler düğmesini seçin.

10. İsteğe bağlı olarak, Etiketler sekmesinde, kaynağı sınıflandırmak istiyorsanız ad ve değeri girin.

11. Gözden geçir ve oluştur’u seçin. Azure 'un yapılandırmanızı doğruladığı, gözden geçir + Oluştur sekmesine götürülürsünüz.

12. Yeşil doğrulama başarılı iletisi göründüğünde Oluştur' u seçin.

Önbelleğin oluşturulması biraz zaman alır. Redsıs genel bakış sayfasında ilerlemeyi izleyebilirsiniz. Durum çalışıyor olarak görüntülendiğinde, önbellek kullanıma hazırdır.

Azure portal ana bilgisayar adı, bağlantı noktaları ve erişim anahtarlarını alın

Redsıs örneği için bir Azure önbelleğine bağlanmak üzere önbellek istemcilerinin, önbellek için ana bilgisayar adı, bağlantı noktaları ve bir anahtar olması gerekir. Bazı istemciler bu öğelere biraz daha farklı adlarla başvurabilir. Ana bilgisayar adı, bağlantı noktaları ve anahtarları Azure Portaledinebilirsiniz.

• Önbellek sol gezininizden erişim anahtarlarını almak için erişim tuşları' nı seçin.

  

• Ana bilgisayar adını ve bağlantı noktalarını, önbellek sol gezininizden almak için Özellikler' i seçin. Ana bilgisayar adı <DNS name> . Redis.cache.Windows.net biçimindedir.

  

ANA BİLGİSAYAR ADI ve Birincil erişim anahtarı bilgilerini not edin. Daha sonra CacheConnection gizli dizisini oluşturmak için bu değerleri kullanacaksınız.

Konsol uygulaması oluşturma

Yeni bir komut penceresi açın ve aşağıdaki komutu yürüterek yeni bir .NET Core konsol uygulaması oluşturun:

dotnet new console -o Redistest

Komut pencerenizde yeni Redistest proje dizinine geçin.

Projeye Gizli Dizi Yöneticisi ekleme

Bu bölümde, projenize Gizli Dizi Yöneticisi aracını ekleyeceksiniz. Gizli Dizi Yöneticisi aracı, geliştirme işine yönelik hassas verileri proje ağacınızın dışında depolar. Bu yaklaşım, uygulama gizli dizilerini kaynak kodunun içinde yanlışlıkla paylaşmayı önlemeye yardımcı olur.

Redistest.csproj dosyanızı açın. Microsoft.Extensions.SecretManager.Tools öğesini dahil etmek için bir DotNetCliToolReference öğesi ekleyin. Ayrıca, aşağıda gösterildiği gibi bir UserSecretsId öğesi ekleyin ve dosyayı kaydedin.

<Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
        <OutputType>Exe</OutputType>
        <TargetFramework>net5.0</TargetFramework>
        <UserSecretsId>Redistest</UserSecretsId>
    </PropertyGroup>
    <ItemGroup>
        <DotNetCliToolReference Include="Microsoft.Extensions.SecretManager.Tools" Version="2.0.0" />
    </ItemGroup>
</Project>

Aşağıdaki komutu yürüterek Microsoft.Extensions.Configuration.UserSecrets paketini projeye ekleyin:

dotnet add package Microsoft.Extensions.Configuration.UserSecrets

Paketlerinizi geri yüklemek için aşağıdaki komutu yürütün:

dotnet restore

Komut pencerenizde aşağıdaki komutu yürüterek, önbellek adınız ve birincil erişim anahtarınız için yer tutucuları (açılı ayraçlar dahil) değiştirdikten sonra CacheConnection adlı yeni bir gizli diziyi depolayın:

dotnet user-secrets set CacheConnection "<cache name>.redis.cache.windows.net,abortConnect=false,ssl=true,allowAdmin=true,password=<primary-access-key>"

Aşağıdaki using deyimini Program.cs dosyasına ekleyin:

using Microsoft.Extensions.Configuration;

Aşağıdaki üyeleri, Program.cs dosyasında Program sınıfına ekleyin. Bu kod, bağlantı dizesinin kullanıcı gizli dizisine erişmek için Redis için Azure Cache başlatılır.

private static IConfigurationRoot Configuration { get; set; }
const string SecretName = "CacheConnection";

private static void InitializeConfiguration()
{
    var builder = new ConfigurationBuilder()
        .AddUserSecrets<Program>();

    Configuration = builder.Build();
}

Önbellek istemcisini yapılandırma

Bu bölümde, .NET için StackExchange.Redis istemcisini kullanmak üzere konsol uygulamasını yapılandıracaksınız.

Komut pencerenizde, Redistest proje dizininde aşağıdaki komutu yürütün:

dotnet add package StackExchange.Redis

Yükleme tamamlandıktan sonra StackExchange.Redis önbellek istemcisi, projenizle kullanılabilir olur.

Önbelleğe bağlanma

Aşağıdaki using deyimini Program.cs dosyasına ekleyin:

using StackExchange.Redis;

Redis için Azure Cache sınıfı tarafından ConnectionMultiplexer yönetilir. Bu sınıf, istemci uygulamanız genelinde paylaşılmalı ve yeniden kullanılmalıdır. Her işlem için yeni bir bağlantı oluşturmayın.

Program.cs dosyasında, konsol uygulamanızın Program sınıfına aşağıdaki üyeleri ekleyin:

private static Lazy<ConnectionMultiplexer> lazyConnection = CreateConnection();

public static ConnectionMultiplexer Connection
{
    get
    {
        return lazyConnection.Value;
    }
}

private static Lazy<ConnectionMultiplexer> CreateConnection()
{
    return new Lazy<ConnectionMultiplexer>(() =>
    {
        string cacheConnection = Configuration[SecretName];
        return ConnectionMultiplexer.Connect(cacheConnection);
    });
}

Uygulamanızda bir ConnectionMultiplexer örneğini paylaşmaya ilişkin bu yaklaşım, bağlı bir örnek döndüren bir statik özelliği kullanır. Kod yalnızca tek bir bağlı ConnectionMultiplexer örneği başlatmak için iş parçacığı güvenli bir yol sağlar. abortConnect false olarak ayarlanır, başka bir ifadeyle bağlantı kurulmasa bile çağrının Redis için Azure Cache olur. ConnectionMultiplexer temel özelliklerinden biri ağ sorunu ya da diğer nedenler çözümlendiğinde önbellek bağlantısını otomatik olarak geri yüklemesidir.

CacheConnection gizli dizisinin değerine, Gizli Dizi Yöneticisi yapılandırma sağlayıcısı kullanılarak erişilir ve bu gizli dizi, parola parametresi olarak kullanılır.

Yeniden bağlanarak RedisConnectionException ve SocketException olaylarını işleme

üzerinde yöntemler çağrılırken önerilen en iyi yöntem, bağlantıyı kapatıp yeniden kurmayla ve özel durumları otomatik ConnectionMultiplexer RedisConnectionException olarak SocketException çözümlemeye çalışmadır.

Aşağıdaki using deyimlerini Program.cs dosyasına ekleyin:

using System.Net.Sockets;
using System.Threading;

Program.cs içinde, sınıfına aşağıdaki üyeleri Program ekleyin:

private static IConfigurationRoot Configuration { get; set; }
private static long _lastReconnectTicks = DateTimeOffset.MinValue.UtcTicks;
private static DateTimeOffset _firstErrorTime = DateTimeOffset.MinValue;
private static DateTimeOffset _previousErrorTime = DateTimeOffset.MinValue;
private static SemaphoreSlim _reconnectSemaphore = new SemaphoreSlim(initialCount: 1, maxCount: 1);
private static SemaphoreSlim _initSemaphore = new SemaphoreSlim(initialCount: 1, maxCount: 1);
private static ConnectionMultiplexer _connection;
private static bool _didInitialize = false;
// In general, let StackExchange.Redis handle most reconnects,
// so limit the frequency of how often ForceReconnect() will
// actually reconnect.
public static TimeSpan ReconnectMinInterval => TimeSpan.FromSeconds(60);
// If errors continue for longer than the below threshold, then the
// multiplexer seems to not be reconnecting, so ForceReconnect() will
// re-create the multiplexer.
public static TimeSpan ReconnectErrorThreshold => TimeSpan.FromSeconds(30);
public static TimeSpan RestartConnectionTimeout => TimeSpan.FromSeconds(15);
public static int RetryMaxAttempts => 5;

public static ConnectionMultiplexer Connection { get { return _connection; } }
private static async Task InitializeAsync()
{
    if (_didInitialize)
    {
        throw new InvalidOperationException("Cannot initialize more than once.");
    }
    var builder = new ConfigurationBuilder()
        .AddUserSecrets<Program>();
    Configuration = builder.Build();
    _connection = await CreateConnectionAsync();
    _didInitialize = true;
}
// This method may return null if it fails to acquire the semaphore in time.
// Use the return value to update the "connection" field
private static async Task<ConnectionMultiplexer> CreateConnectionAsync()
{
    if (_connection != null)
    {
        // If we already have a good connection, let's re-use it
        return _connection;
    }
    try
    {
        await _initSemaphore.WaitAsync(RestartConnectionTimeout);
    }
    catch
    {
        // We failed to enter the semaphore in the given amount of time. Connection will either be null, or have a value that was created by another thread.
        return _connection;
    }
    // We entered the semaphore successfully.
    try
    {
        if (_connection != null)
        {
            // Another thread must have finished creating a new connection while we were waiting to enter the semaphore. Let's use it
            return _connection;
        }
        // Otherwise, we really need to create a new connection.
        string cacheConnection = Configuration["CacheConnection"].ToString();
        return await ConnectionMultiplexer.ConnectAsync(cacheConnection);
    }
    finally
    {
        _initSemaphore.Release();
    }
}
private static async Task CloseConnectionAsync(ConnectionMultiplexer oldConnection)
{
    if (oldConnection == null)
    {
        return;
    }
    try
    {
        await oldConnection.CloseAsync();
    }
    catch (Exception)
    {
        // Ignore any errors from the oldConnection
    }
}
/// <summary>
/// Force a new ConnectionMultiplexer to be created.
/// NOTES:
///     1. Users of the ConnectionMultiplexer MUST handle ObjectDisposedExceptions, which can now happen as a result of calling ForceReconnectAsync().
///     2. Call ForceReconnectAsync() for RedisConnectionExceptions and RedisSocketExceptions. You can also call it for RedisTimeoutExceptions,
///         but only if you're using generous ReconnectMinInterval and ReconnectErrorThreshold. Otherwise, establishing new connections can cause
///         a cascade failure on a server that's timing out because it's already overloaded.
///     3. The code will:
///         a. wait to reconnect for at least the "ReconnectErrorThreshold" time of repeated errors before actually reconnecting
///         b. not reconnect more frequently than configured in "ReconnectMinInterval"
/// </summary>
public static async Task ForceReconnectAsync()
{
    var utcNow = DateTimeOffset.UtcNow;
    long previousTicks = Interlocked.Read(ref _lastReconnectTicks);
    var previousReconnectTime = new DateTimeOffset(previousTicks, TimeSpan.Zero);
    TimeSpan elapsedSinceLastReconnect = utcNow - previousReconnectTime;
    // If multiple threads call ForceReconnectAsync at the same time, we only want to honor one of them.
    if (elapsedSinceLastReconnect < ReconnectMinInterval)
    {
        return;
    }
    try
    {
        await _reconnectSemaphore.WaitAsync(RestartConnectionTimeout);
    }
    catch
    {
        // If we fail to enter the semaphore, then it is possible that another thread has already done so.
        // ForceReconnectAsync() can be retried while connectivity problems persist.
        return;
    }
    try
    {
        utcNow = DateTimeOffset.UtcNow;
        elapsedSinceLastReconnect = utcNow - previousReconnectTime;
        if (_firstErrorTime == DateTimeOffset.MinValue)
        {
            // We haven't seen an error since last reconnect, so set initial values.
            _firstErrorTime = utcNow;
            _previousErrorTime = utcNow;
            return;
        }
        if (elapsedSinceLastReconnect < ReconnectMinInterval)
        {
            return; // Some other thread made it through the check and the lock, so nothing to do.
        }
        TimeSpan elapsedSinceFirstError = utcNow - _firstErrorTime;
        TimeSpan elapsedSinceMostRecentError = utcNow - _previousErrorTime;
        bool shouldReconnect =
            elapsedSinceFirstError >= ReconnectErrorThreshold // Make sure we gave the multiplexer enough time to reconnect on its own if it could.
            && elapsedSinceMostRecentError <= ReconnectErrorThreshold; // Make sure we aren't working on stale data (e.g. if there was a gap in errors, don't reconnect yet).
        // Update the previousErrorTime timestamp to be now (e.g. this reconnect request).
        _previousErrorTime = utcNow;
        if (!shouldReconnect)
        {
            return;
        }
        _firstErrorTime = DateTimeOffset.MinValue;
        _previousErrorTime = DateTimeOffset.MinValue;
        ConnectionMultiplexer oldConnection = _connection;
        await CloseConnectionAsync(oldConnection);
        _connection = null;
        _connection = await CreateConnectionAsync();
        Interlocked.Exchange(ref _lastReconnectTicks, utcNow.UtcTicks);
    }
    finally
    {
        _reconnectSemaphore.Release();
    }
}
// In real applications, consider using a framework such as
// Polly to make it easier to customize the retry approach.
private static async Task<T> BasicRetryAsync<T>(Func<T> func)
{
    int reconnectRetry = 0;
    int disposedRetry = 0;
    while (true)
    {
        try
        {
            return func();
        }
        catch (Exception ex) when (ex is RedisConnectionException || ex is SocketException)
        {
            reconnectRetry++;
            if (reconnectRetry > RetryMaxAttempts)
                throw;
            await ForceReconnectAsync();
        }
        catch (ObjectDisposedException)
        {
            disposedRetry++;
            if (disposedRetry > RetryMaxAttempts)
                throw;
        }
    }
}
public static Task<IDatabase> GetDatabaseAsync()
{
    return BasicRetryAsync(() => Connection.GetDatabase());
}
public static Task<System.Net.EndPoint[]> GetEndPointsAsync()
{
    return BasicRetryAsync(() => Connection.GetEndPoints());
}
public static Task<IServer> GetServerAsync(string host, int port)
{
    return BasicRetryAsync(() => Connection.GetServer(host, port));
}

Önbellek komutlarını yürütme

Program.cs dosyasında, konsol uygulamanıza yönelik Program sınıfının Main yordamı için aşağıdaki kodu ekleyin:

static void Main(string[] args)
{
    InitializeConfiguration();

    IDatabase cache = GetDatabase();

    // Perform cache operations using the cache object...

    // Simple PING command
    string cacheCommand = "PING";
    Console.WriteLine("\nCache command  : " + cacheCommand);
    Console.WriteLine("Cache response : " + cache.Execute(cacheCommand).ToString());

    // Simple get and put of integral data types into the cache
    cacheCommand = "GET Message";
    Console.WriteLine("\nCache command  : " + cacheCommand + " or StringGet()");
    Console.WriteLine("Cache response : " + cache.StringGet("Message").ToString());

    cacheCommand = "SET Message \"Hello! The cache is working from a .NET Core console app!\"";
    Console.WriteLine("\nCache command  : " + cacheCommand + " or StringSet()");
    Console.WriteLine("Cache response : " + cache.StringSet("Message", "Hello! The cache is working from a .NET Core console app!").ToString());

    // Demonstrate "SET Message" executed as expected...
    cacheCommand = "GET Message";
    Console.WriteLine("\nCache command  : " + cacheCommand + " or StringGet()");
    Console.WriteLine("Cache response : " + cache.StringGet("Message").ToString());

    // Get the client list, useful to see if connection list is growing...
    // Note that this requires allowAdmin=true in the connection string
    cacheCommand = "CLIENT LIST";
    Console.WriteLine("\nCache command  : " + cacheCommand);
    var endpoint = (System.Net.DnsEndPoint)GetEndPoints()[0];
    IServer server = GetServer(endpoint.Host, endpoint.Port);
    ClientInfo[] clients = server.ClientList();

    Console.WriteLine("Cache response :");
    foreach (ClientInfo client in clients)
    {
        Console.WriteLine(client.Raw);
    }

    CloseConnection(lazyConnection);
}

Program.cs dosyasını kaydedin.

Redis için Azure Cache bir veritabanı içindeki verileri mantıksal olarak ayırmak için kullanılan yapılandırılabilir sayıda veritabanı (varsayılan değer 16) Redis için Azure Cache. Kod, DB 0 adlı varsayılan veritabanına bağlanır. Daha fazla bilgi için bkz. Redis veritabanı nedir? ve Varsayılan Redis sunucu yapılandırması.

StringSet ve StringGet yöntemleri kullanılarak önbellek öğeleri depolanabilir ve alınabilir.

Redis, Redis dizeleri kadar veri depolar, ancak bu dizeler önbellekte .NET nesneleri depolarken kullanılabilecek seri hale getirilmiş ikili veriler dahil, birçok veri türünü içerebilir.

Uygulamayı derlemek için komut pencerenizde aşağıdaki komutu yürütün:

dotnet build

Ardından aşağıdaki komutla uygulamayı çalıştırın:

dotnet run

Aşağıdaki örnekte, Message anahtarının Azure portalındaki Redis Konsolu kullanılarak ayarlanan, önceden önbelleğe alınmış bir değer içerdiğini görebilirsiniz. Uygulama, önbelleğe alınan bu değeri güncelleştirdi. Ayrıca uygulama, PING ve CLIENT LIST komutlarını da yürüttü.

Önbellekte .NET nesneleriyle çalışma

Redis için Azure Cache hem .NET nesnelerini hem de temel veri türlerini önbelleğe alasa da bir .NET nesnesinin önbelleğe alınamadan önce seri hale getirmesi gerekir. Bu .NET nesne serileştirmesi uygulama geliştiricisinin sorumluluğundadır ve geliştiriciye seri hale getirici tercihinde esneklik sağlar.

Nesneleri seri hale getirmenin basit bir yolu, Newtonsoft.Json’da JsonConvert seri hale getirme yöntemlerini kullanmak ve JSON’a ve JSON’dan seri hale getirmektir. Bu bölümde, önbelleğe bir .NET nesnesi ekleyeceksiniz.

Newtonsoft.json paketini uygulamaya eklemek için aşağıdaki komutu yürütün:

dotnet add package Newtonsoft.json

Aşağıdaki using deyimini Program.cs dosyasının üst kısmına ekleyin:

using Newtonsoft.Json;

Aşağıdaki Employee sınıf tanımını Program.cs dosyasına ekleyin:

class Employee
{
    public string Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }

    public Employee(string employeeId, string name, int age)
    {
        Id = employeeId;
        Name = name;
        Age = age;
    }
}

Program.cs dosyasındaki Main() yordamının alt kısmına ve CloseConnection() için çağrı yapılmadan önce aşağıdaki kod satırlarını önbelleğe ekleyin ve seri hale getirilmiş bir .NET nesnesi alın:

    // Store .NET object to cache
    Employee e007 = new Employee("007", "Davide Columbo", 100);
    Console.WriteLine("Cache response from storing Employee .NET object : " + 
    cache.StringSet("e007", JsonConvert.SerializeObject(e007)));

    // Retrieve .NET object from cache
    Employee e007FromCache = JsonConvert.DeserializeObject<Employee>(cache.StringGet("e007"));
    Console.WriteLine("Deserialized Employee .NET object :\n");
    Console.WriteLine("\tEmployee.Name : " + e007FromCache.Name);
    Console.WriteLine("\tEmployee.Id   : " + e007FromCache.Id);
    Console.WriteLine("\tEmployee.Age  : " + e007FromCache.Age + "\n");

Program.cs dosyasını kaydedin ve uygulamayı aşağıdaki komut ile yeniden derleyin:

dotnet build

.NET nesnelerinin seri duruma getirilmesini test etmek için aşağıdaki komut ile uygulamayı çalıştırın:

dotnet run

Kaynakları temizleme

Sonraki öğreticiyle devam edecekseniz, bu hızlı başlangıçta oluşturulan kaynakları tutabilir ve sonraki öğreticide yeniden kullanabilirsiniz.

Aksi takdirde, hızlı başlangıç örnek uygulamasını tamamladıysanız ücret yansıtılmaması için bu hızlı başlangıçta oluşturulan Azure kaynaklarını silebilirsiniz.

Azure portalda oturum açın ve Kaynak grupları’nı seçin.

Ada göre filtrele... metin kutusuna kaynak grubunuzun adını girin. Bu makaledeki yönergelerde TestResources adlı bir kaynak grubu kullanılmıştır. Sonuç listesinde kaynak grubu üzerinde ... öğesini ve ardından Kaynak grubunu sil'i seçin.

Kaynak grubunun silinmesini onaylamanız istenir. Onaylamak için kaynak grubu adının yazın ve Sil'i seçin.

Birkaç dakika sonra kaynak grubu ve içerdiği kaynakların tümü silinir.

Sonraki adımlar

Bu hızlı başlangıçta bir .NET Core uygulamasından Redis için Azure Cache kullanmayı öğrendiniz. Yeni bir web uygulamasıyla Redis için Azure Cache sonraki hızlı ASP.NET devam edin.

Bulut harcamalarınızı iyileştirmek ve tasarruf etmek ister misiniz?