Guida introduttiva: Usare la cache di Azure per Redis con un'app .NET

In questa guida introduttiva si incorpora la cache di Azure per Redis in un'app .NET per l'accesso a una cache sicura e dedicata accessibile da qualsiasi applicazione in Azure. Si usa specificamente il client StackExchange.Redis con codice C# in un'app console .NET.

Passare al codice in GitHub

Questo articolo descrive come modificare il codice per un'app di esempio per creare un'app funzionante che si connette alla cache di Azure per Redis.

Per passare direttamente al codice, vedere l'esempio di avvio rapido di .NET in GitHub.

Prerequisiti

• Una sottoscrizione di Azure. Crearne uno gratuito
• Visual Studio 2019
• .NET Framework 4 o versione successiva come richiesto dal client StackExchange.Redis

Creare una cache

1. Per creare una cache, accedere al portale di Azure. Nel menu del portale selezionare Crea una risorsa.

   

2. Nella pagina Attività iniziali immettere Cache di Azure per Redis nella barra di ricerca. Nei risultati della ricerca trovare Cache di Azure per Redis e quindi selezionare Crea.

   

3. Nel riquadro Nuova cache Redis, nella scheda Informazioni di base configurare le impostazioni seguenti per la cache:

   Impostazione	Azione	Descrizione
   Abbonamento	Seleziona la tua sottoscrizione di Azure.	Sottoscrizione da usare per creare la nuova istanza della cache di Azure per Redis.
   Gruppo di risorse	Selezionare un gruppo di risorse oppure selezionare Crea nuovo e immettere un nuovo nome del gruppo di risorse.	Nome del gruppo di risorse in cui creare la cache e altre risorse. L'inserimento di tutte le risorse di un'app in un unico gruppo di risorse ne semplifica la gestione o l'eliminazione.
   Nome DNS	Immettere un nome univoco.	Il nome della cache deve essere una stringa compresa tra 1 e 63 caratteri contenente solo numeri, lettere o trattini. Il nome deve iniziare e terminare con un numero o una lettera e non può contenere trattini consecutivi. Il nome host dell'istanza della cache è \<DNS name>.redis.cache.windows.net.
   Location	Selezionare una località.	Un'area di Azure vicina ad altri servizi che usano la cache.
   SKU della cache	Selezionare uno SKU.	Lo SKU determina le dimensioni, le prestazioni e i parametri delle funzionalità disponibili per la cache. Per altre informazioni, vedere la panoramica su Cache Redis di Azure.
   Dimensioni della cache	Selezionare le dimensioni della cache.	Per altre informazioni, vedere la panoramica su Cache Redis di Azure.

4. Selezionare la scheda Rete oppure selezionare Avanti: Rete.

5. Nella scheda Rete selezionare un metodo di connettività da usare per la cache.

6. Selezionare la scheda Avanzate o Avanti: Avanzate.

7. Nel riquadro Avanzate verificare o selezionare un metodo di autenticazione in base alle informazioni seguenti:

   

   • Per impostazione predefinita, per una nuova cache Basic, Standard o Premium, l'Autenticazione di Microsoft Entra è abilitata e l'Autenticazione delle chiavi di accesso è disabilitata.
   • Per le cache Basic o Standard, è possibile scegliere la selezione di una porta non TLS.
   • Per le cache Standard e Premium, è possibile scegliere di abilitare le zone di disponibilità. Non è possibile disabilitare le zone di disponibilità dopo la creazione della cache.
   • Per una cache Premium, configurare le impostazioni per la porta non TLS, il clustering, l'identità gestita e la persistenza dei dati.

   Importante

   Per una protezione ottimale, è consigliabile usare Microsoft Entra ID con identità gestite per autorizzare le richieste nella cache ogni volta che è possibile. L'autorizzazione tramite Microsoft Entra ID e le identità gestite offre sicurezza e facilità d'uso superiori rispetto all'autorizzazione con chiave di accesso condiviso. Per altre informazioni sull'uso delle identità gestite con le cache, vedere Usare Microsoft Entra ID per l'autenticazione della cache.

8. (Facoltativo) Selezionare la scheda Tag o selezionare Avanti: Tag.

9. (Facoltativo) Nella scheda Tag immettere un nome e un valore di tag per classificare la risorsa della cache.

10. Selezionare il pulsante Rivedi e crea.

    Nella scheda Rivedi e crea Azure convalida automaticamente la configurazione.

11. Quando viene visualizzato il messaggio verde di Convalida superata, selezionare Crea.

Una nuova distribuzione della cache richiede diversi minuti. È possibile monitorare lo stato di avanzamento della distribuzione nel riquadro Panoramica della cache di Azure per Redis. Quando l'elemento Stato mostra In esecuzione, la cache è pronta per l'uso.

Ottenere il nome host, le porte e la chiave di accesso

Per connettersi al server della cache di Azure per Redis, il client della cache deve avere il nome host, le porte e una chiave di accesso della cache. Alcuni client possono fare riferimento a questi elementi usando nomi leggermente diversi. È possibile ottenere il nome host, le porte e le chiavi nel portale di Azure.

• Per ottenere una chiave di accesso per la cache:

  1. Nel portale di Azure, passare alla cache.
  2. Nel menu del servizio, in Impostazioni, selezionare Autenticazione.
  3. Nel riquadro Autenticazione selezionare la scheda Chiavi di accesso.
  4. Per copiare il valore per una chiave di accesso, selezionare l'icona Copia nel campo della chiave.

  

• Per ottenere il nome host e le porte della cache:

  1. Nel portale di Azure, passare alla cache.
  2. Nel menu del servizio, selezionare Panoramica.
  3. In Essentials, per Nome host, selezionare l'icona Copia per copiare il valore del nome host. Il formato del valore del nome host è il seguente: <DNS name>.redis.cache.windows.net.
  4. Per Porte, selezionare l'icona Copia per copiare i valori delle porte.

  

1. Creare un file nel computer denominato CacheSecrets.config. Posizionarlo nella cartella *C:\AppSecrets*.

2. Modificare il file CacheSecrets.config e aggiungere il contenuto seguente:

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

   • Sostituire <host-name> con il nome host della cache.

   • Sostituire <access-key> con la chiave primaria per la cache.

3. Salvare il file.

Configurare il client della cache

In questa sezione, si preparerà l'applicazione console per usare il client StackExchange.Redis per .NET.

1. In Visual Studio, seleziona Strumenti>Gestione pacchetti NuGet>Console di gestione pacchetti. Eseguire il comando seguente nella finestra Console di Gestione pacchetti:

   Install-Package StackExchange.Redis
   

2. Al termine dell'installazione, il client della cache StackExchange.Redis è disponibile per l'uso con il progetto.

Connettersi alla cache dei segreti

In Visual Studio, aprire il file App.config per verificare che contenga un attributo appSettings file che fa riferimento al file 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>

Non archiviare mai le credenziali nel codice sorgente. Per semplificare questo esempio, viene usato solo un file di configurazione dei segreti esterno. Un approccio migliore potrebbe consistere nell'usare Azure Key Vault con certificati.

Connettersi alla cache usando RedisConnection

La connessione alla cache viene gestita dalla classe RedisConnection. Prima di tutto, stabilire la connessione in questa istruzione in Program.cs:

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

Il valore dell'impostazione dell'app CacheConnection viene usato per fare riferimento alla stringa di connessione della cache dal portale di Azure come parametro della password.

In RedisConnection.cs lo spazio dei nomi StackExchange.Redis viene visualizzato come istruzione using richiesta dalla classe RedisConnection:

using StackExchange.Redis;

Il codice della classe RedisConnection garantisce che sia sempre presente una connessione integra alla cache. La connessione viene gestita dall'istanza ConnectionMultiplexer di StackExchange.Redis. La classe RedisConnection ricrea la connessione quando una connessione viene persa e non è possibile riconnettersi automaticamente.

Per altre informazioni, vedere StackExchange.Redis e il codice nel repository GitHub di StackExchange.Redis.

Eseguire i comandi della cache

In Program.cs, è possibile visualizzare il codice seguente per il metodo RunRedisCommandsAsync nella classe Program per l'applicazione console:

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

Per archiviare e recuperare gli elementi nella cache, è possibile usare i metodi StringSetAsync e StringGetAsync.

Nell'esempio è possibile vedere che la chiave Message è impostata su Value. L'app ha aggiornato questo valore memorizzato nella cache. L'app ha anche eseguito PING e il comando.

Gestire gli oggetti .NET nella cache

Il server Redis archivia la maggior parte dei dati come stringhe, tuttavia queste stringhe possono contenere molti tipi di dati, tra cui dati binari serializzati, utilizzabili durante l'archiviazione di oggetti .NET nella cache.

La cache di Azure per Redis può memorizzare nella cache sia oggetti .NET che tipi di dati primitivi, ma prima della memorizzazione nella cache un oggetto .NET deve essere serializzato.

Questa serializzazione di oggetti .NET spetta allo sviluppatore dell'applicazione. Si ha una certa flessibilità nella scelta del serializzatore.

Un modo semplice per serializzare gli oggetti consiste nell'usare i metodi di serializzazione JsonConvert in System.text.Json.

Aggiungere lo spazio dei nomi System.text.Json in Visual Studio:

1. Selezionare Strumenti>Gestione Pacchetti NuGet>Console di Gestione pacchetti.

2. Eseguire quindi il comando seguente nella finestra Console di Gestione pacchetti:

   Install-Package system.text.json
   

La classe Employee seguente è stata definita in Program.cs in modo che l'esempio possa mostrare come ottenere e impostare un oggetto serializzato:

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

Eseguire l'esempio

Premere CTRL+F5 per compilare ed eseguire l'app console per testare la serializzazione degli oggetti .NET.

Pulire le risorse

Per continuare a usare le risorse create in questo articolo, mantenere il gruppo di risorse.

In alternativa, per evitare addebiti relativi alle risorse, se si è terminato di usare le risorse è possibile eliminare il gruppo di risorse di Azure creato.

Eliminare un gruppo di risorse

1. Accedere al portale di Azure e selezionare Gruppi di risorse.

2. Selezionare il gruppo di risorse da eliminare.

   Se sono presenti molti gruppi di risorse, in Filtra per qualsiasi campo immettere il nome del gruppo di risorse creato per completare questo articolo. Nell'elenco dei risultati della ricerca selezionare il gruppo di risorse.

   

3. Selezionare Elimina gruppo di risorse.

4. Nel riquadro Elimina un gruppo di risorse immettere il nome del gruppo di risorse per confermare e quindi selezionare Elimina.

   

Dopo qualche istante, il gruppo di risorse e tutte le risorse che contiene vengono eliminati.

Contenuto correlato

• Procedure consigliate per la resilienza della connessione per la cache
• Procedure consigliate per lo sviluppo per la cache