Snabbstart: Använda Azure Cache for Redis med en .NET-app

I den här snabbstarten införlivar du Azure Cache for Redis i en .NET-app för åtkomst till en säker, dedikerad cache som är tillgänglig från alla program i Azure. Du använder specifikt StackExchange.Redis-klienten med C#-kod i en .NET-konsolapp.

Hoppa till koden på GitHub

Den här artikeln beskriver hur du ändrar koden för en exempelapp för att skapa en fungerande app som ansluter till Azure Cache for Redis.

Om du vill gå direkt till koden kan du läsa .NET-snabbstartsexemplet på GitHub.

Förutsättningar

• En Azure-prenumeration. Skapa en kostnadsfritt
• Visual Studio 2019
• .NET Framework 4 eller senare som krävs av StackExchange.Redis-klienten

Skapa en cache

1. Om du vill skapa en cache loggar du in på Azure Portal. På portalmenyn väljer du Skapa en resurs.

   

2. I fönstret Kom igång anger du Azure Cache for Redis i sökfältet. I sökresultaten letar du upp Azure Cache for Redis och väljer sedan Skapa.

   

3. I fönstret Ny Redis Cache på fliken Grundläggande konfigurerar du följande inställningar för din cache:

   Inställning	Åtgärd	beskrivning
   Abonnemang	Välj din Azure-prenumerationen.	Prenumerationen som ska användas för att skapa den nya instansen av Azure Cache for Redis.
   Resursgrupp	Välj en resursgrupp eller välj Skapa ny och ange ett nytt resursgruppsnamn.	Ett namn på resursgruppen där du kan skapa cacheminnet och andra resurser. Genom att placera alla dina appresurser i en resursgrupp kan du enkelt hantera eller ta bort dem tillsammans.
   DNS-namn	Ange ett unikt namn.	Cachenamnet måste vara en sträng på 1 till 63 tecken som endast innehåller siffror, bokstäver och bindestreck. Namnet måste börja och sluta med ett tal eller en bokstav, och det får inte innehålla bindestreck i följd. Värdnamnet för cacheinstansen är \<DNS name>.redis.cache.windows.net.
   Plats	Välj en plats.	En Azure-region som ligger nära andra tjänster som använder din cache.
   Cache-SKU	Välj en SKU.	SKU:n avgör vilka storleks-, prestanda- och funktionsparametrar som är tillgängliga för cachen. Mer information finns i Översikt över Azure Cache for Redis.
   Cachestorlek	Välj en cachestorlek.	Mer information finns i Översikt över Azure Cache for Redis.

4. Välj fliken Nätverk eller välj Nästa: Nätverk.

5. På fliken Nätverk väljer du en anslutningsmetod som ska användas för cacheminnet.

6. Välj fliken Avancerat eller välj Nästa: Avancerat.

7. I fönstret Avancerat kontrollerar eller väljer du en autentiseringsmetod baserat på följande information:

   

   • Som standard aktiveras Microsoft Entra-autentisering för en ny Basic-, Standard- eller Premium-cache och åtkomstnycklarnas autentisering inaktiveras.
   • För Basic- eller Standard-cacheminnen kan du välja valet för en icke-TLS-port.
   • För Standard- och Premium-cacheminnen kan du välja att aktivera tillgänglighetszoner. Du kan inte inaktivera tillgänglighetszoner när cacheminnet har skapats.
   • För en Premium-cache konfigurerar du inställningarna för icke-TLS-port, klustring, hanterad identitet och datapersistence.

   Viktigt!

   För optimal säkerhet rekommenderar vi att du använder Microsoft Entra-ID med hanterade identiteter för att auktorisera begäranden mot din cache om möjligt. Auktorisering med hjälp av Microsoft Entra-ID och hanterade identiteter ger överlägsen säkerhet och användarvänlighet för auktorisering av delad åtkomstnyckel. Mer information om hur du använder hanterade identiteter med din cache finns i Använda Microsoft Entra-ID för cacheautentisering.

8. (Valfritt) Välj fliken Taggar eller välj Nästa: Taggar.

9. (Valfritt) På fliken Taggar anger du ett taggnamn och värde om du vill kategorisera cacheresursen.

10. Välj knappen Granska + skapa.

    På fliken Granska + skapa verifierar Azure automatiskt din konfiguration.

11. När det gröna verifieringsmeddelandet har skickats väljer du Skapa.

En ny cachedistribution sker under flera minuter. Du kan övervaka förloppet för distributionen i översiktsfönstret Azure Cache for Redis. När Status visar Körs är cachen redo att användas.

Hämta värdnamnet, portarna och åtkomstnyckeln

För att ansluta till Azure Cache for Redis-servern behöver cacheklienten cachens värdnamn, portar och en åtkomstnyckel. Vissa klienter kan referera till dessa objekt med hjälp av lite olika namn. Du kan hämta värdnamnet, portarna och nycklarna i Azure Portal.

• Så här hämtar du en åtkomstnyckel för din cache:

  1. I Azure Portal går du till cacheminnet.
  2. På tjänstmenyn går du till Inställningar och väljer Autentisering.
  3. I fönstret Autentisering väljer du fliken Åtkomstnycklar .
  4. Om du vill kopiera värdet för en åtkomstnyckel väljer du ikonen Kopiera i nyckelfältet.

  

• Så här hämtar du värdnamnet och portarna för cachen:

  1. I Azure Portal går du till cacheminnet.
  2. På tjänstmenyn väljer du Översikt.
  3. Under Essentials, för Värdnamn, väljer du ikonen Kopiera för att kopiera värdnamnets värde. Värdnamnets värde har formuläret <DNS name>.redis.cache.windows.net.
  4. För Portar väljer du ikonen Kopiera för att kopiera portvärdena.

  

1. Skapa en fil på datorn med namnet CacheSecrets.config. Placera den i mappen *C:\AppSecrets*.

2. Redigera filen CacheSecrets.config och lägg till följande innehåll:

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

   • Ersätt <host-name> med din cachens värdnamn.

   • Ersätt <access-key> med primärnyckeln för cachen.

3. Spara filen.

Konfigurera cacheklienten

I det här avsnittet förbereder du konsolprogrammet för att använda StackExchange.Redis-klienten för .NET.

1. I Visual Studio, välj Verktyg>NuGet pakethanterare>Pakethanterarkonsol. Kör följande kommando i package manager-konsolfönstret:

   Install-Package StackExchange.Redis
   

2. När installationen är klar är StackExchange.Redis-cacheklienten tillgänglig för användning med projektet.

Ansluta till cacheminnet för hemligheter

I Visual Studio öppnar du filen App.config för att kontrollera att den innehåller ett file appSettings attribut som refererar till filen CacheSecrets.config:

<?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>

Lagra aldrig autentiseringsuppgifter i källkoden. För att hålla det här exemplet enkelt använder vi en konfigurationsfil för externa hemligheter. En bättre metod är att använda Azure Key Vault med certifikat.

Ansluta till cachen med hjälp av RedisConnection

Anslutningen till cachen hanteras av RedisConnection klassen. Gör först anslutningen i den här instruktionen i Program.cs:

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

Värdet för appinställningen CacheConnection används för att referera till cachen anslutningssträng från Azure Portal som lösenordsparameter.

I RedisConnection.cs visas Namnområdet StackExchange.Redis som en using instruktion som RedisConnection klassen kräver:

using StackExchange.Redis;

Klasskoden RedisConnection ser till att det alltid finns en felfri anslutning till cacheminnet. Anslutningen hanteras av instansen ConnectionMultiplexer från StackExchange.Redis. Klassen RedisConnection återskapar anslutningen när en anslutning går förlorad och kan inte återansluta automatiskt.

Mer information finns i StackExchange.Redis och koden i GitHub-lagringsplatsen StackExchange.Redis.

Köra cachekommandon

I Program.cs kan du se följande kod för RunRedisCommandsAsync metoden i Program -klassen för konsolprogrammet:

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

Cacheobjekt kan lagras i och hämtas med hjälp av StringSetAsync- och StringGetAsync-metoderna.

I exemplet kan du se att Message nyckeln är inställd på värde. Appen uppdatera det cachelagrade värdet. Appen körde PING också kommandot och .

Arbeta med .NET-objekt i cachen

Redis-servern lagrar de flesta data som strängar, men dessa strängar kan innehålla många typer av data, inklusive serialiserade binära data, som kan användas när .NET-objekt lagras i cacheminnet.

Azure Cache for Redis kan cachelagras både .NET-objekt och primitiva datatyper, men innan ett .NET-objekt kan cachelagras måste det serialiseras.

Den här .NET-objektserialiseringen är programutvecklarens ansvar. Du har viss flexibilitet i valet av serialiserare.

Ett enkelt sätt att serialisera objekt är att använda serialiseringsmetoderna JsonConvert i System.text.Json.

Lägg till namnområdet System.text.Json i Visual Studio:

1. Välj Verktyg>NuGet Package Manager Package Manager>Console*.

2. Kör sedan följande kommando i fönstret Package Manager Console:

   Install-Package system.text.json
   

Följande Employee klass definierades i Program.cs så att exemplet kan visa hur du hämtar och anger ett serialiserat objekt:

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

Kör exemplet

Om du vill skapa och köra konsolappen för att testa serialiseringen av .NET-objekt väljer du Ctrl+F5.

Rensa resurser

Om du vill fortsätta att använda de resurser som du skapade i den här artikeln behåller du resursgruppen.

Annars kan du ta bort den Azure-resursgrupp som du skapade om du är klar med resurserna för att undvika kostnader som är relaterade till resurserna.

Varning

Att ta bort en resursgrupp kan inte ångras. När du tar bort en resursgrupp tas alla resurser i resursgruppen bort permanent. Kontrollera att du inte av misstag tar bort fel resursgrupp eller resurser. Om du har skapat resurserna i en befintlig resursgrupp som har resurser som du vill behålla kan du ta bort varje resurs individuellt i stället för att ta bort resursgruppen.

Ta bort en resursgrupp

1. Logga in på Azure-portalen och välj Resursgrupper.

2. Välj den resursgrupp som ska tas bort.

   Om det finns många resursgrupper anger du namnet på den resursgrupp som du skapade för att slutföra den här artikeln i Filtrera efter valfritt fält. I listan med sökresultat väljer du resursgruppen.

   

3. Välj Ta bort resursgrupp.

4. I fönstret Ta bort en resursgrupp anger du namnet på resursgruppen som ska bekräftas och väljer sedan Ta bort.

   

Inom en liten stund tas resursgruppen och alla dess resurser bort.

Relaterat innehåll

• Metodtips för anslutningsresiliens för din cache
• Metodtips för utveckling för cacheminnet