Guida introduttiva: Connettersi a Redis gestito di Azure con Go

Questo articolo illustra come usare una cache Redis di Azure con la lingua Go e connettersi usando Microsoft Entra ID.

Prerequisiti

• Sottoscrizione di Azure: crearne una gratuitamente
• Installare l'ambiente linguistico Go
• Aggiungere due importazioni da Redis al progetto e all'ambiente di sviluppo
  • entraid "github.com/redis/go-redis-entraid"
  • "github.com/redis/go-redis/v9"

Creare un'istanza di Redis gestita di Azure

Creare prima di tutto una cache. È possibile creare una cache usando Azure Managed Redis o Cache Redis di Azure usando il portale di Azure. In questo Quickstart si usa Azure Managed Redis.

Quando si crea la cache, Microsoft Entra ID è abilitato per impostazione predefinita, rendendolo sicuro dall'avvio. La cache deve anche usare un endpoint pubblico per questo avvio rapido.

Per creare una cache con il portale, seguire una delle procedure seguenti:

• Redis Gestito di Azure
• cache di Azure per Redis

Facoltativamente, è possibile creare una cache usando l'interfaccia della riga di comando di Azure, PowerShell, a qualsiasi scelta.

Codice per la connessione a una cache Redis

Nella prima parte dell'esempio di codice impostare la connessione alla cache:

package main

import (
  "context"
  "crypto/tls"
  "fmt"
  "log"
  "time"

  entraid "github.com/redis/go-redis-entraid"
  "github.com/redis/go-redis/v9"
)

func main() {
  ctx := context.Background()

  // Set your Redis endpoint (hostname:port) from the cache you created.
  redisHost := "<host >:<public port number>"

  // Create a credentials provider using DefaultAzureCredential
  provider, err := entraid.NewDefaultAzureCredentialsProvider(entraid.DefaultAzureCredentialsProviderOptions{})

  if err != nil {
    log.Fatalf("Failed to create credentials provider: %v", err)
  }

  // Create Redis client with Entra ID authentication
  client := redis.NewClient(&redis.Options{
    Addr:                         redisHost,
    TLSConfig:                    &tls.Config{MinVersion: tls.VersionTLS12},
    WriteTimeout:                 5 * time.Second,
    StreamingCredentialsProvider: provider,
  })
  defer client.Close()

Codice per testare una connessione

Nella sezione successiva testare la connessione usando il comando ping Redis che restituisce la pong stringa.

        // Ping the Redis server to test the connection
        pong, err := client.Ping(ctx).Result()
        if err != nil {
                log.Fatal("Failed to connect to Redis:", err)
        }
        fmt.Println("Ping returned: ", pong)

Impostare un codice, ottenere una chiave

In questa sezione, usa una sequenza di base set e get per iniziare a usare la cache Redis nel modo più semplice.

        // Do something with Redis and a key-value pair
        result, err := client.Set(ctx, "Message", "Hello, The cache is working with Go!", 0).Result()
        if err != nil {
                log.Fatal("SET Message failed:", err)
        }
        fmt.Println("SET Message succeeded:", result)

        value, err := client.Get(ctx, "Message").Result()
        if err != nil {
                if err == redis.Nil {
                        fmt.Println("GET Message returned: key does not exist")
                } else {
                        log.Fatal("GET Message failed:", err)
                }
        } else {
                fmt.Println("GET Message returned:", value)
        }

}

Prima di poter eseguire questo codice, è necessario aggiungersi come utente Redis.

È anche necessario autorizzare la connessione ad Azure dalla riga di comando usando la riga di comando di Azure o la riga di comando per sviluppatori di Azure (azd).

È anche necessario aggiungere utenti o un'entità di sistema alla cache. Aggiungere chiunque possa eseguire il programma come utente nella cache Redis.

Il risultato è simile al seguente:

Ping returned:  PONG
SET Message succeeded: OK
GET Message returned: Hello, The cache is working with Go!

Qui è possibile vedere l'intero esempio di codice.

package main

import (
        "context"
        "crypto/tls"
        "fmt"
        "log"
        "time"

        entraid "github.com/redis/go-redis-entraid"
        "github.com/redis/go-redis/v9"
)

func main() {
        ctx := context.Background()

        // Set your Redis host (hostname:port)
        redisHost := "<host >:<public port number>"

        // Create a credentials provider using DefaultAzureCredential
        provider, err := entraid.NewDefaultAzureCredentialsProvider(entraid.DefaultAzureCredentialsProviderOptions{})

        if err != nil {
                log.Fatalf("Failed to create credentials provider: %v", err)
        }

        // Create Redis client with Entra ID authentication
        client := redis.NewClient(&redis.Options{
                Addr:                         redisHost,
                TLSConfig:                    &tls.Config{MinVersion: tls.VersionTLS12},
                WriteTimeout:                 5 * time.Second,
                StreamingCredentialsProvider: provider,
        })
        defer client.Close()

        // Ping the Redis server to test the connection
        pong, err := client.Ping(ctx).Result()
        if err != nil {
                log.Fatal("Failed to connect to Redis:", err)
        }
        fmt.Println("Ping returned: ", pong)

        // Do something with Redis and a key-value pair
        result, err := client.Set(ctx, "Message", "Hello, The cache is working with Go!", 0).Result()
        if err != nil {
                log.Fatal("SET Message failed:", err)
        }
        fmt.Println("SET Message succeeded:", result)

        value, err := client.Get(ctx, "Message").Result()
        if err != nil {
                if err == redis.Nil {
                        fmt.Println("GET Message returned: key does not exist")
                } else {
                        log.Fatal("GET Message failed:", err)
                }
        } else {
                fmt.Println("GET Message returned:", value)
        }

}

Pulire le risorse

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

In caso contrario, se le risorse sono state completate, per evitare addebiti è possibile eliminare il gruppo di risorse di Azure creato.

Importante

L'eliminazione di un gruppo di risorse è irreversibile. Quando si elimina un gruppo di risorse, tutte le risorse in esso contenute vengono eliminate in modo permanente. Assicurarsi di non eliminare accidentalmente il gruppo di risorse sbagliato o le risorse errate. Se le risorse sono state create all'interno di un gruppo di risorse esistente che contiene anche elementi da mantenere, è possibile eliminare ogni singolo elemento a sinistra anziché eliminare il gruppo di risorse.

Per eliminare un gruppo di risorse

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

2. Scegliere il gruppo di risorse da eliminare.

   Se sono presenti molti gruppi di risorse, usare la casella Filtro per qualsiasi campo... e digitare il nome del gruppo di risorse creato per questo articolo. Nell’elenco dei risultati selezionare il gruppo di risorse.

   

3. Selezionare Elimina gruppo di risorse.

4. Verrà chiesto di confermare l'eliminazione del gruppo di risorse. Digitare 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.

Contenuti correlati

• Estensione Redis per la connessione tramite Microsoft Entra ID
• Guida a Go-Redis