Gestisci l'autenticazione IAM

Questa pagina fornisce istruzioni sulle attività comuni per la funzionalità di autenticazione IAM per il cluster Memorystore for Redis. Per maggiori dettagli sulla funzionalità, consulta Informazioni sull'autenticazione IAM.

Crea un'istanza con autenticazione IAM

Per creare un'istanza di Memorystore for Redis Cluster che utilizza l'autenticazione IAM, esegui il comando create:

gcloud beta redis clusters create INSTANCE_ID --region=REGION_ID --network=NETWORK --shard-count=SHARD_COUNT --auth-mode=iam-auth

Sostituisci quanto segue:

INSTANCE_ID è l'ID dell'istanza del cluster Memorystore for Redis che stai creando. L'ID istanza deve contenere da 1 a 63 caratteri e deve contenere solo lettere minuscole, numeri o trattini. Deve iniziare con una lettera minuscola e terminare con una lettera minuscola o un numero.
REGION_ID è la regione in cui vuoi posizionare l'istanza.

Nota: puoi creare istanze solo nelle regioni supportate per il cluster Memorystore for Redis. Non tutte le regioni attualmente supportate da Memorystore for Redis sono disponibili per il cluster Memorystore for Redis. I comandi gcloud redis regions list mostrano le regioni supportate per Memorystore for Redis, non per il cluster Memorystore for Redis.
NETWORK è la rete utilizzata per creare l'istanza. Deve utilizzare il formato: projects/NETWORK_PROJECT_ID/global/networks/NETWORK_ID. L'ID di rete utilizzato qui deve corrispondere all'ID di rete utilizzato dal criterio di connessione del servizio. In caso contrario, l'operazione create non andrà a buon fine. Per maggiori dettagli, consulta Networking.
SHARD_COUNT determina il numero di shard da 13 GB nella tua istanza. Il conteggio degli shard determina la capacità di memoria totale per l'archiviazione dei dati delle istanze. Per maggiori dettagli sulle specifiche dell'istanza, consulta la specifica del cluster e dello shard.

Gestire le autorizzazioni per l'autenticazione IAM

Crea un ruolo di amministratore IAM limitato per un'istanza

Ti consigliamo di creare un ruolo in grado di modificare le autorizzazioni IAM della connessione dell'istanza senza concedere l'accesso amministrativo completo a IAM. A questo scopo, puoi creare un amministratore IAM limitato per il ruolo "roles/redis.dbConnectionUser". Per informazioni dettagliate, vedi Creare amministratori IAM con limitazioni.

Concedi l'accesso all'istanza con IAM

Per impostazione predefinita, la concessione di un ruolo roles/redis.dbConnectionUser consente all'entità di accedere a tutte le istanze del progetto. Per concedere l'accesso a un sottoinsieme di risorse nel progetto, configura l'accesso basato sulle risorse IAM per il ruolo roles/redis.dbConnectionUser. Per maggiori dettagli, vedi Configurare l'accesso basato sulle risorse.

Connettersi a un'istanza che utilizza l'autenticazione IAM

Se non hai ancora una VM di Compute Engine che utilizza la stessa rete autorizzata del tuo cluster Redis, creane una e connettiti seguendo questa guida rapida all'utilizzo di una VM Linux.
Installa redis-cli sulla VM di Compute Engine eseguendo questo comando dal terminale SSH di Compute Engine:
```
sudo apt-get install redis-tools
```
Esegui questo comando per ottenere un token di accesso per il tuo utente IAM:
```
gcloud auth print-access-token
```
Nota: i token di accesso scadranno tra un'ora. Per saperne di più, vedi Periodo di tempo del token di accesso IAM.
Connettiti all'endpoint di rilevamento della tua istanza:
```
redis-cli -h NETWORK_ADDRESS -p PORT -a ACCESS_TOKEN -c
```
Sostituisci quanto segue:
- NETWORK_ADDRESS è l'indirizzo di rete dell'istanza. Per visualizzare l'indirizzo di rete, consulta Visualizza informazioni sull'istanza.
- PORT è il numero di porta delle istanze. Per visualizzare il numero di porta, consulta Visualizza informazioni sull'istanza.
- ACCESS_TOKEN è il token di accesso IAM recuperato nei passaggi precedenti.
Nota: le connessioni autenticate hanno una validità di 12 ore. Per maggiori informazioni, consulta la pagina Intervallo di tempo di autenticazione.
Esegui il comando CLUSTER SHARDS per visualizzare la topologia del tuo cluster. Prendi nota di uno degli indirizzi IP e dei numeri di porta del nodo.
Connettiti al nodo desiderato eseguendo il comando seguente:
```
redis-cli -h NODE_IP_ADDRESS -p NODE_PORT -a ACCESS_TOKEN -c
```
Sostituisci quanto segue:
- NODE_IP_ADDRESS è l'indirizzo IP del nodo che hai trovato nel passaggio precedente.
- NODE_PORT è il numero di porta del nodo che hai trovato nel passaggio precedente.
Esegui un comando Redis SET e GET per verificare di aver stabilito una connessione autenticata al tuo nodo cluster.
Dopo aver completato la verifica della connessione all'istanza Redis, devi eliminare la VM di Compute Engine utilizzata per connetterti al cluster Redis. In questo modo eviterai che al tuo account di fatturazione Cloud vengano addebitati costi.
Esegui questo comando per utilizzare redis-cli per eseguire l'autenticazione e connetterti all'istanza, sostituendo le variabili con i valori appropriati:
```
redis-cli -h NETWORK_ADDRESS -p PORT -a ACCESS_TOKEN -c
```
Sostituisci quanto segue:
- NETWORK_ADDRESS è l'indirizzo di rete dell'istanza. Per visualizzare l'indirizzo di rete, consulta Visualizza informazioni sull'istanza.
- PORT è il numero di porta delle istanze. Per visualizzare il numero di porta, consulta Visualizza informazioni sull'istanza.
- ACCESS_TOKEN è il token di accesso IAM recuperato nei passaggi precedenti.
Nota: le connessioni autenticate hanno una validità di 12 ore. Per maggiori informazioni, consulta la pagina Intervallo di tempo di autenticazione.
Esegui un comando Redis SET e GET per verificare di aver stabilito una connessione autenticata per la tua istanza.
Una volta completato il test della connessione al cluster Redis, devi eliminare la VM di Compute Engine utilizzata per connetterti al cluster Redis. In questo modo eviterai che al tuo account di fatturazione Cloud vengano addebitati costi.

Automatizza il recupero dei token di accesso

Ti consigliamo di automatizzare il recupero dei token di accesso nella tua applicazione, poiché l'hard-coding dei token di accesso non è facile a causa della loro breve durata.

(Facoltativo) Se non lo hai già fatto, crea un account di servizio per la tua applicazione (vedi Creazione e gestione di un account di servizio).
```
gcloud iam service-accounts create SA_NAME \
    --description="DESCRIPTION" \
    --display-name="DISPLAY_NAME"
```
Sostituisci quanto segue:
- SA_NAME è il nome dell'account di servizio.
- DESCRIPTION è una descrizione facoltativa dell'account di servizio.
- DISPLAY_NAME è il nome di un account di servizio da visualizzare nella console Google Cloud.
Concedi al tuo account di servizio l'autorizzazione redis.dbConnectionUser per il tuo progetto.
```
gcloud projects add-iam-policy-binding PROJECT_ID \
--member="serviceAccount:SA_NAME@PROJECT_ID.iam.gserviceaccount.com" \
--role="redis.dbConnectionUser"
```
Sostituisci quanto segue:
- PROJECT_ID è l'ID progetto.
- SA_NAME è il nome dell'account di servizio.
- ROLE_NAME è un nome di ruolo, ad esempio roles/compute.osLogin.
Autentica la tua applicazione come l'account di servizio specificato. Per ulteriori informazioni, consulta gli account di servizio.

Per esempi di codice che mostrano come autenticare l'applicazione utilizzando librerie client popolari, consulta gli esempi di codice delle librerie client di autenticazione IAM.

Esempi di codice per la libreria client di autenticazione IAM

Questa sezione fornisce esempi generali di codice client per l'autenticazione con l'autenticazione IAM per il tuo cluster Memorystore con la libreria client Lettuce.

Lattuga


public void example() {
  String discoveryEndpointIp = "insert discovery endpoint ip"
  String discoveryEndpointPort = "insert discovery endpoint port"
  RedisCredentialsProvider provider =
     () ->
           Mono.just(RedisCredentials.just("default", retrieveAccessToken().toCharArray()));
  RedisURI redisUri =
     RedisURI.Builder.redis(discoveryEndpointIp, discoveryEndpointPort)
           .withAuthentication(provider)
           .build();
  ClientResources resources =
     DefaultClientResources.builder()
           .reconnectDelay(
              Delay.fullJitter(
                 Duration.ofMillis(100),
                 Duration.ofSeconds(5),
                 100,
                 TimeUnit.MILLISECONDS))
           .build();
  ClusterTopologyRefreshOptions topologyRefreshOptions = ClusterTopologyRefreshOptions.builder()
     .enablePeriodicRefresh(1, TimeUnit.MINUTES)
     .enableAllAdaptiveRefreshTriggers()
     .dynamicRefreshSources(false)
     .closeStaleConnections(true)
     .build();

  SocketOptions socketOptions = SocketOptions.builder()
     .connectTimeout(Duration.ofSeconds(5))
     .keepAlive(true)
     .build();

  // Create Redis Cluster Client
  RedisClusterClient clusterClient = RedisClusterClient.create(resources, redisUri);
  clusterClient.setOptions(
     ClusterClientOptions.builder()
           .topologyRefreshOptions(topologyRefreshOptions)
           .socketOptions(socketOptions)
           .autoReconnect(true)
           .nodeFilter(
              it ->
                 !(it.is(RedisClusterNode.NodeFlag.FAIL)
                       || it.is(RedisClusterNode.NodeFlag.EVENTUAL_FAIL)
                       || it.is(RedisClusterNode.NodeFlag.NOADDR)))
           .validateClusterNodeMembership(false)
           .build());

  // Establish connection to Redis Cluster
  StatefulRedisClusterConnection connection = clusterClient.connect();
  // Retrieve synchronous Redis Cluster commands
  RedisAdvancedClusterCommands syncCommands = connection.sync();
  // Perform Redis operations
  syncCommands.set("key1", "value1");

  // Close the connection and shutdown the client
  connection.close();
  clusterClient.shutdown();
}