Schnellstart: Verwenden von Azure Cache for Redis mit .NET Framework

  • Artikel

In dieser Schnellstartanleitung integrieren Sie Azure Cache für Redis in eine .NET Framework-App, um Zugriff auf einen sicheren, dedizierten Cache zu erhalten, der von jeder Anwendung in Azure aus zugänglich ist. Sie verwenden insbesondere den StackExchange.Redis-Client mit C#-Code in einer .NET-Konsolen-App.

Direktes Navigieren zum Code auf GitHub

Klonen Sie das Repository aus (https://github.com/Azure-Samples/azure-cache-redis-samples/tree/main/quickstart/dotnet) auf GitHub.

Voraussetzungen

Erstellen eines Caches

  1. Melden Sie sich zum Erstellen eines Caches beim Azure-Portal an, und wählen Sie Ressource erstellen aus.

    Create a resource is highlighted in the left navigation pane.

  2. Wählen Sie auf der Seite Neu die Option Datenbanken und dann Azure Cache for Redis aus.

    On New, Databases is highlighted, and Azure Cache for Redis is highlighted.

  3. Konfigurieren Sie auf der Seite Neuer Redis Cache die Einstellungen für den neuen Cache.

    Einstellung Wert auswählen BESCHREIBUNG
    Abonnement Öffnen Sie die Dropdownliste, und wählen Sie Ihr Abonnement aus. Das Abonnement, unter dem diese neue Azure Cache for Redis-Instanz erstellt wird.
    Ressourcengruppe Öffnen Sie die Dropdownliste, und wählen Sie eine Ressourcengruppe aus, oder wählen Sie Neu erstellen aus, und geben Sie einen Namen für eine neue Ressourcengruppe ein. Der Name der Ressourcengruppe, in der Ihr Cache und weitere Ressourcen erstellt werden. Wenn Sie alle Ihre App-Ressourcen in einer Ressourcengruppe zusammenfassen, können Sie sie einfacher gemeinsam verwalten oder löschen.
    DNS-Name Geben Sie einen eindeutigen Namen ein. Der Cachename muss zwischen 1 und 63 Zeichen lang sein und darf nur Ziffern, Buchstaben und Bindestriche enthalten. Der Name muss mit einer Zahl oder einem Buchstaben beginnen und enden und darf keine aufeinanderfolgenden Bindestriche enthalten. Der Hostname Ihrer Cache-Instanz lautet <DNS-Name>.redis.cache.windows.net.
    Location Öffnen Sie die Dropdownliste, und wählen Sie einen Standort aus. Wählen Sie eine Region in der Nähe anderer Dienste aus, die Ihren Cache verwenden.
    Cachetyp Öffnen Sie die Dropdownliste, und wählen Sie einen Tarif aus. Der Tarif bestimmt Größe, Leistung und verfügbare Features für den Cache. Weitere Informationen finden Sie unter What is Azure Cache for Redis (Was ist Azure Cache for Redis?).

  4. Wählen Sie die Registerkarte Netzwerk oder unten auf der Seite die Schaltfläche Netzwerk aus.

  5. Wählen Sie auf der Registerkarte Netzwerk Ihre Konnektivitätsmethode aus.

  6. Wählen Sie die Registerkarte Weiter: Erweitert oder unten auf der Seite die Schaltfläche Weiter: Erweitert aus, um die Registerkarte Erweitert anzuzeigen.

    Screenshot showing the Advanced tab in the working pane and the available option to select.

    • Schalten Sie für Basic- oder Standard-Caches die Auswahl auf einen Nicht-TLS-Port um. Sie können auch auswählen, ob Sie die Microsoft Entra-Authentifizierung aktivieren möchten.
    • Konfigurieren Sie für ein Premium-Cache die Einstellungen für einen Nicht-TLS-Port, das Clustering, die verwaltete Identität und die Datenpersistenz. Sie können auch auswählen, ob Sie die Microsoft Entra-Authentifizierung aktivieren möchten.

  7. Wählen Sie die Registerkarte Weiter: Tags oder unten auf der Seite die Schaltfläche Weiter: Tags aus.

  8. Geben Sie optional auf der Registerkarte Tags den Namen und den Wert ein, wenn Sie die Ressource kategorisieren möchten.

  9. Klicken Sie auf Überprüfen + erstellen. Sie werden zur Registerkarte Überprüfen und erstellen weitergeleitet, auf der Azure Ihre Konfiguration überprüft.

  10. Wenn die grüne Meldung „Validierung erfolgreich“ angezeigt wird, wählen Sie Erstellen aus.

Es dauert eine Weile, bis der Cache erstellt ist. Sie können den Fortschritt auf der Seite Übersicht von Azure Cache for Redis überwachen. Wenn Wird ausgeführt als Status angezeigt wird, ist der Cache einsatzbereit.

Abrufen von Hostname, Ports und Zugriffsschlüsseln vom Azure-Portal

Um ihren Azure Cache for Redis-Server zu verbinden, benötigt der Cacheclient den Hostnamen, die Ports und einen Schlüssel für den Cache. Von einigen Clients wird unter Umständen mit etwas anderen Namen auf diese Elemente verwiesen. Sie können den Hostnamen, Ports und Zugriffsschlüssel vom Azure-Portal abrufen.

  • Wählen Sie Zugriffsschlüssel aus, um die Zugriffsschlüssel aus dem linken Navigationsbereich des Cache abzurufen.

    Azure Cache for Redis keys

  • Wählen Sie Eigenschaften aus, um den Hostnamen und die Ports aus dem linken Navigationsbereich des Cache abzurufen. Der Hostname hat das Format <DNS-Name>.redis.cache.windows.net.

    Azure Cache for Redis properties

  1. Erstellen Sie eine Datei auf Ihrem Computer namens CacheSecrets.config, und legen Sie sie in C:\AppSecrets\CacheSecrets.config ab.

  2. Bearbeiten Sie die Datei CacheSecrets.config, und fügen Sie ihr folgende Inhalte hinzu:

    <appSettings>
    <add key="CacheConnection" value="<host-name>,abortConnect=false,ssl=true,allowAdmin=true,password=<access-key>"/>
</appSettings>

  3. Ersetzen Sie <host-name> durch den Cachehostnamen.

  4. Ersetzen Sie <access-key> durch den Primärschlüssel für Ihren Cache.

  5. Speichern Sie die Datei .

Konfigurieren des Cacheclients

In diesem Abschnitt bereiten Sie die Konsolenanwendung für die Verwendung des StackExchange.Redis-Clients für .NET vor.

  1. Wählen Sie in Visual Studio das Tools>NuGet-Paket-Manager>Paket-Manager-Konsole und führen Sie im Fenster der Paket-Manager-Konsole den folgenden Befehl aus.

    Install-Package StackExchange.Redis

  2. Nach Abschluss der Installation kann der StackExchange.Redis-Cacheclient für Ihr Projekt verwendet werden.

Verbinden mit dem Cache für Geheimnisse

Öffnen Sie in Visual Studio Ihre Datei App.config, um zu überprüfen, ob sie ein appSettingsfile-Attribut enthält, das auf die Datei CacheSecrets.config verweist.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <startup> 
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2" />
    </startup>

    <appSettings file="C:\AppSecrets\CacheSecrets.config"></appSettings>
</configuration>

Speichern Sie niemals Anmeldeinformationen im Quellcode. Um dieses Beispiel einfach zu halten, wird hier nur eine externe Konfigurationsdatei für Geheimnisse verwendet. Ein besserer Ansatz wäre die Nutzung von Azure Key Vault mit Zertifikaten.

Verbinden mit dem Cache mittels RedisConnection

Die Verbindung mit Ihrem Cache wird von der RedisConnection-Klasse verwaltet. Die Verbindung wird zuerst in dieser Anweisung von Program.cs hergestellt:

     _redisConnection = await RedisConnection.InitializeAsync(connectionString: ConfigurationManager.AppSettings["CacheConnection"].ToString());

Der Wert der appSetting-Einstellung CacheConnection wird verwendet, um über das Azure-Portal auf die Cacheverbindungszeichenfolge als Kennwortparameter zu verweisen.

In RedisConnection.cs sehen Sie den Namespace StackExchange.Redis mit dem Schlüsselwort using. Dies ist für die RedisConnection-Klasse erforderlich.

using StackExchange.Redis;

Der RedisConnection-Code stellt sicher, dass immer eine fehlerfreie Verbindung mit dem Cache besteht, indem die ConnectionMultiplexer-Instanz von StackExchange.Redis verwaltet wird. Die RedisConnection-Klasse erstellt die Verbindung neu, wenn eine Verbindung verloren geht und diese nicht automatisch wieder hergestellt werden kann.

Weitere Informationen finden Sie unter StackExchange.Redis sowie den Code in einem GitHub-Repository.

Ausführen von Cachebefehlen

In program.cs können Sie den folgenden Code für die RunRedisCommandsAsync-Methode in der Program-Klasse für die Konsolenanwendung sehen:

private static async Task RunRedisCommandsAsync(string prefix)
    {
        // Simple PING command
        Console.WriteLine($"{Environment.NewLine}{prefix}: Cache command: PING");
        RedisResult pingResult = await _redisConnection.BasicRetryAsync(async (db) => await db.ExecuteAsync("PING"));
        Console.WriteLine($"{prefix}: Cache response: {pingResult}");

        // Simple get and put of integral data types into the cache
        string key = "Message";
        string value = "Hello! The cache is working from a .NET console app!";

        Console.WriteLine($"{Environment.NewLine}{prefix}: Cache command: GET {key} via StringGetAsync()");
        RedisValue getMessageResult = await _redisConnection.BasicRetryAsync(async (db) => await db.StringGetAsync(key));
        Console.WriteLine($"{prefix}: Cache response: {getMessageResult}");

        Console.WriteLine($"{Environment.NewLine}{prefix}: Cache command: SET {key} \"{value}\" via StringSetAsync()");
        bool stringSetResult = await _redisConnection.BasicRetryAsync(async (db) => await db.StringSetAsync(key, value));
        Console.WriteLine($"{prefix}: Cache response: {stringSetResult}");

        Console.WriteLine($"{Environment.NewLine}{prefix}: Cache command: GET {key} via StringGetAsync()");
        getMessageResult = await _redisConnection.BasicRetryAsync(async (db) => await db.StringGetAsync(key));
        Console.WriteLine($"{prefix}: Cache response: {getMessageResult}");

        // Store serialized object to cache
        Employee e007 = new Employee("007", "Davide Columbo", 100);
        stringSetResult = await _redisConnection.BasicRetryAsync(async (db) => await db.StringSetAsync("e007", JsonSerializer.Serialize(e007)));
        Console.WriteLine($"{Environment.NewLine}{prefix}: Cache response from storing serialized Employee object: {stringSetResult}");

        // Retrieve serialized object from cache
        getMessageResult = await _redisConnection.BasicRetryAsync(async (db) => await db.StringGetAsync("e007"));
        Employee e007FromCache = JsonSerializer.Deserialize<Employee>(getMessageResult);
        Console.WriteLine($"{prefix}: Deserialized Employee .NET object:{Environment.NewLine}");
        Console.WriteLine($"{prefix}: Employee.Name : {e007FromCache.Name}");
        Console.WriteLine($"{prefix}: Employee.Id   : {e007FromCache.Id}");
        Console.WriteLine($"{prefix}: Employee.Age  : {e007FromCache.Age}{Environment.NewLine}");
    }

Cacheelemente können mit den Methoden StringSetAsync und StringGetAsync gespeichert und abgerufen werden.

Im Beispiel können Sie sehen, dass der Message-Schlüssel auf den Wert festgelegt ist. Die App hat diesen zwischengespeicherten Wert aktualisiert. Außerdem hat die App den Befehl PING ausgeführt.

Arbeiten mit .NET-Objekten im Cache

Der Redis-Server speichert die meisten Daten als Zeichenfolgen. Diese können jedoch unterschiedliche Datentypen enthalten, inklusive serialisierter Binärdaten, die zum Speichern von .NET-Objekten im Cache verwendet werden können.

Azure Cache for Redis kann sowohl .NET-Objekte als auch primitive Datentypen zwischenspeichern. .NET-Objekte müssen allerdings zunächst serialisiert werden.

Die Serialisierung des .NET-Objekts ist Aufgabe des Anwendungsentwicklers und überlässt dem Entwickler die Freiheit bei der Wahl des Serialisierers.

Eine einfache Möglichkeit zum Serialisieren von Objekten stellt die Verwendung der JsonConvert-Serialisierungsmethoden in System.text.Json dar.

Fügen Sie den Namespace System.text.Json zu Visual Studio hinzu:

  1. Wählen Sie Extras>NuGet-Paket-Manager>Paket-Manager-Konsole* aus.

  2. Führen Sie dann den folgenden Befehl im Fenster der Paket-Manager-Konsole aus.

    Install-Package system.text.json

Die folgende Employee-Klasse wurde in Program.cs definiert, damit mit dem Beispiel auch gezeigt werden kann, wie ein serialisiertes Objekt abgerufen und festgelegt wird:

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

Ausführen des Beispiels

Drücken Sie STRG+F5, um die Konsolen-App zum Testen der Serialisierung von .NET-Objekten zu erstellen und auszuführen.

Console app completed

Bereinigen von Ressourcen

Wenn Sie diese Schnellstartanleitung weiterhin verwenden, können Sie die darin erstellten Ressourcen behalten und wiederverwenden.

Wenn Sie die Schnellstart-Beispielanwendung nicht mehr benötigen, können Sie die in dieser Schnellstartanleitung erstellten Azure-Ressourcen löschen, um das Anfallen von Kosten zu vermeiden.

Wichtig

Das Löschen einer Ressourcengruppe kann nicht rückgängig gemacht werden. Die Ressourcengruppe und alle darin enthaltenen Ressourcen werden also dauerhaft gelöscht. Achten Sie daher darauf, dass Sie nicht versehentlich die falsche Ressourcengruppe oder die falschen Ressourcen löschen. Falls Sie die Ressourcen zum Hosten dieses Beispiels in einer vorhandenen Ressourcengruppe erstellt haben, die beizubehaltende Ressourcen enthält, können Sie die Ressourcen einzeln auf der linken Seite löschen, statt die Ressourcengruppe zu löschen.

Melden Sie sich beim Azure-Portal an, und klicken Sie auf Ressourcengruppen.

Geben Sie im Textfeld Nach Name filtern... den Namen Ihrer Ressourcengruppe ein. In diesem Artikel wurde eine Ressourcengruppe mit dem Namen TestResources verwendet. Klicken Sie in der Ergebnisliste in Ihrer Ressourcengruppe auf ... und dann auf Ressourcengruppe löschen.

Delete

Sie werden aufgefordert, das Löschen der Ressourcengruppe zu bestätigen. Geben Sie zur Bestätigung den Namen Ihrer Ressourcengruppe ein, und klicken Sie auf Löschen.

Daraufhin werden die Ressourcengruppe und alle darin enthaltenen Ressourcen gelöscht.

Nächste Schritte