Connessione a un'istanza Redis

In questa pagina viene descritto come connetterti all'istanza Redis tramite Telnet e redis-cli. Inoltre, in questa pagina vengono fornite istruzioni su come stabilire la connessione quando si utilizzano funzionalità come le repliche di lettura, AUTH e la crittografia dei dati in transito. Infine, questa pagina fornisce istruzioni sulla connessione da un ambiente Google Kubernetes Engine.

Per un elenco degli ambienti Google Cloud supportati da Memorystore for Redis, consulta Ambienti supportati. Alcuni ambienti serverless non supportati da Memorystore richiedono un connettore di accesso VPC serverless. Per ulteriori dettagli, consulta Requisito del connettore di accesso VPC serverless.

Connessione a un'istanza Redis da una VM di Compute Engine tramite telnet

Puoi connetterti all'istanza Redis da qualsiasi VM di Compute Engine che utilizza la rete autorizzata dell'istanza Redis con un indirizzo IP RFC 1918 supportato.

Se non hai ancora una VM di Compute Engine che utilizza la stessa rete autorizzata della tua istanza Redis, creane una e connettila seguendo Quickstart utilizzando una VM Linux.
Installa telnet utilizzando apt-get:
```
sudo apt-get install telnet
```
Nel terminale, inserisci il comando telnet seguito dall'indirizzo IP dell'istanza Redis, sostituendo variables con i valori appropriati.
```
telnet instance-ip-address 6379
```
In caso di esito positivo, il comando restituirà questo risultato:
```
Trying instance-ip-address…
Connected to instance-ip-address
```
Nella sessione di Telnet, inserisci alcuni comandi Redis:

Digita:
```
PING
```
Risultato:
```
PONG
```
Invio
```
SET HELLO WORLD
```
Risultato:
```
+OK
```
Digita:
```
GET HELLO
```
Risultato:
```
$5
WORLD
```

Connessione a un'istanza Redis da una VM di Compute Engine mediante `redis-cli`

Puoi connetterti all'istanza Redis da qualsiasi VM di Compute Engine che utilizza la rete autorizzata dell'istanza Redis con un indirizzo IP RFC 1918 supportato.

Se non hai ancora una VM di Compute Engine che utilizza la rete autorizzata per la tua istanza Redis, creane una e connettiti seguendo Utilizzo rapido 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 nel terminale Compute Engine, sostituendo variables con i valori appropriati.
```
redis-cli -h redis-instance-ip-address
```
Ora sei connesso alla tua istanza Redis utilizzando redis-cli.
Dopo aver completato la verifica della connessione all'istanza Redis, ti consigliamo di eliminare la VM di Compute Engine utilizzata per la connessione all'istanza Redis. In questo modo eviterai che non ti vengano addebitati costi per il tuo account di fatturazione Cloud.

Connessione a un'istanza Redis che utilizza AUTH

Questa sezione descrive come connettersi a un'istanza Redis in cui è abilitata la funzionalità AUTH.

Se non hai ancora una VM di Compute Engine che utilizza la stessa rete autorizzata della tua istanza 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
```
Recupera la stringa AUTH della tua istanza
Esegui questo comando per utilizzare redis-cli per autenticare e connettere all'istanza, sostituendo variables con i valori appropriati:
```
redis-cli -h instance-ip-address -a auth-string
```
Oppure:
```
redis-cli -h instance-ip-address
AUTH auth-string
```
Esegui un comando Redis SET e GET per verificare di aver stabilito una connessione autenticata alla tua istanza.
Dopo aver completato la verifica della connessione all'istanza Redis, ti consigliamo di eliminare la VM di Compute Engine utilizzata per la connessione all'istanza Redis. In questo modo eviterai che non ti vengano addebitati costi per il tuo account di fatturazione Cloud.

Connessione a un'istanza Redis tramite endpoint di lettura

Se l'istanza ha abilitato le repliche di lettura, puoi connetterti all'endpoint di lettura seguendo le istruzioni seguenti:

Se non hai ancora una VM di Compute Engine che utilizza la stessa rete autorizzata della tua istanza Redis, creane una e connettila seguendo Quickstart utilizzando una VM Linux.
Installa telnet utilizzando apt-get:
```
sudo apt-get install telnet
```
Trova l'indirizzo IP dell'endpoint di lettura dell'istanza Visualizzazione delle informazioni sulla replica di lettura per l'istanza.
Nel terminale, inserisci il comando telnet seguito dall'indirizzo IP dell'endpoint di lettura dell'istanza Redis, sostituendo variables con i valori appropriati.
```
telnet read-endpoint-ip 6379
```
In caso di esito positivo, il comando restituirà questo risultato:
```
Trying read-endpoint-ip…
Connected to read-endpoint-ip
```
Nella sessione di Telnet, inserisci alcuni comandi Redis:

Digita:
```
PING
```
Risultato:
```
PONG
```

Connessione sicura a un'istanza Redis tramite Stunnel e Telnet

Questa sezione fornisce un esempio di come connettersi a un'istanza Redis con crittografia abilitata in transito mediante Stunnel.

Se non hai già attivato un'istanza Redis con crittografia in transito, creane una seguendo la procedura Creare un'istanza Redis con crittografia in transito.
Se non hai già una VM di Compute Engine che utilizza la stessa rete autorizzata dell'istanza Redis del passaggio precedente, creane una e connettiti seguendo questa guida rapida all'utilizzo di una VM Linux.
1. Installa gli strumenti necessari per questa guida eseguendo i comandi seguenti:
```
sudo apt-get install stunnel4
```
```
sudo apt-get install telnet
```
Nota: i passaggi rimanenti di questa guida si verificano nel terminale SSH della VM di Compute Engine che hai creato e a cui hai connesso, se non diversamente specificato.
Configura la tua VM di Compute Engine da utilizzare con Stunnel:
1. Crea un nuovo file in cui inserire l'autorità di certificazione (CA) eseguendo il comando seguente:
```
sudo vim /tmp/server_ca.pem
```
2. Visualizza le autorità di certificazione delle tue istanze Redis eseguendo il comando seguente nel terminale standard che utilizzi per gestire le risorse di Google Cloud (non il terminale Compute Engine):
```
gcloud redis instances describe instance-id --region=region
```
  Possono esserci fino a tre autorità di certificazione.
3. Copia tutte le autorità di certificazione visibili, comprese la riga -----BEGIN CERTIFICATE----- e le righe -----END CERTIFICATE-----, e incolla e salva il file server_ca.pem che hai creato in precedenza.
  
  Nota: assicurati che il testo dell'autorità di certificazione sia completamente giustificato. Non devono esserci spazi vuoti iniziali su nessuna riga dell'autorità di certificazione.
4. Crea un nuovo file in cui inserire le informazioni di configurazione di Stunnel eseguendo il comando seguente:
```
sudo vim /etc/stunnel/redis-client.conf
```
  Incolla il testo seguente nel file, sostituendo redis-instance-ip con l'indirizzo IP dell'istanza Redis:
```
output=/tmp/stunnel.log
CAfile=/tmp/server_ca.pem
client=yes
pid=/var/run/stunnel.pid
verifyChain=yes
sslVersion=TLSv1.2
[redis]
accept=127.0.0.1:6378
connect=redis-instance-ip:6378
```
  Avvia stunnel eseguendo il comando seguente:
```
sudo stunnel /etc/stunnel/redis-client.conf
```
  Verifica che stunnel sia in esecuzione:
```
ps aux | grep stunnel
```
5. Riavvia Stunnel eseguendo i seguenti comandi:
```
sudo systemctl restart stunnel4
```
  Nota: puoi utilizzare il comando ps aux | grep stunnel prima e dopo il riavvio di stunnel per verificare che il riavvio sia riuscito. Se l'ID processo di stunell, mostrato dal comando ps aux | grep stunnel, è diverso, significa che lo stunell è stato riavviato correttamente.
Per connetterti all'istanza Redis tramite Telnet, esegui il comando seguente:
```
telnet localhost 6378
```
Nella sessione di Telnet, invia un ping all'istanza Redis:

Digita:
```
PING
```
Risultato:
```
PONG
```

Connessione da una macchina locale con port forwarding

Può essere utile connettersi all'istanza Redis dalla tua macchina locale durante lo sviluppo. Per farlo, devi creare un'istanza di Compute Engine da utilizzare per il port forwarding all'istanza di Redis.

Crea un'istanza di Compute Engine eseguendo questo comando:
```
gcloud compute instances create NAME --machine-type=f1-micro --zone=ZONE
```
Dove:
- NAME è il nome che assegni alla VM di Compute Engine.
- ZONE è la zona in cui vuoi eseguire il provisioning della VM.
Questo comando crea una VM di Compute Engine con il tipo di macchina f1-micro per ottenere costi contenuti. Se preferisci, puoi scegliere altri tipi di macchine.
Apri un nuovo terminale sulla macchina locale.
Per creare un tunnel SSH che inoltra il traffico attraverso la VM di Compute Engine, esegui il comando seguente:
```
gcloud compute ssh COMPUTE_VM_NAME --zone=ZONE -- -N -L 6379:REDIS_INSTANCE_IP_ADDRESS:6379
```
Dove:
- COMPUTE_VM_NAME è il nome della VM di Compute Engine.
- ZONE è la stessa zona in cui si trova la VM di Compute Engine.
- REDIS_INSTANCE_IP_ADDRESS è l'indirizzo IP della tua istanza Redis.
Per testare la connessione, apri una nuova finestra del terminale ed esegui questo comando:
```
redis-cli ping
```
Se funziona correttamente, il risultato dovrebbe restituire:
```
PONG
```
Ora sei connesso all'istanza Redis e puoi inviare comandi all'istanza Redis utilizzando questo tunnel SSH aperto. Se non hai ancora installato redis-cli, installalo per poter eseguire questo comando.
Il tunnel SSH rimane aperto finché mantieni aperta la finestra del terminale con la connessione al tunnel SSH.

Connessione a un'istanza Redis da un cluster Google Kubernetes Engine

Puoi connetterti all'istanza Redis dai cluster Google Kubernetes Engine che utilizzano la stessa rete autorizzata dell'istanza Redis.

Connessione da un pod che esegue una shell bash

Vai alla pagina GKE in Google Cloud Console.
GKE
Fai clic sul cluster GKE da cui vuoi connetterti. Se non hai ancora un cluster, creane uno con gli alias IP abilitati. Per istruzioni su come creare un cluster con alias IP abilitati, vedi Creazione di un cluster nativo di VPC.
Fai clic sul pulsante Connetti a destra del nome del cluster e fai clic sul pulsante Esegui in Cloud Shell nella finestra visualizzata.
Configura l'accesso da riga di comando kubectl eseguendo il comando seguente:
```
gcloud container clusters get-credentials CLUSTER_NAME --zone=CLUSTER_ZONE --project=PROJECT_ID
```
- CLUSTER_NAME è il nome del cluster.
- CLUSTER_ZONE è la zona in cui si trova il tuo cluster. Deve essere anche la zona in cui si trova la tua istanza Redis.
- PROJECT_ID è il progetto in cui esistono il cluster e le istanze Redis.
Dovresti ricevere il messaggio di operazione riuscita: kubeconfig generated for CLUSTER_NAME
Se il cluster è versione 1.8 o successiva e sono abilitati gli alias IP, salta questo passaggio. Se nel tuo cluster è installata la versione 1.7 o una versione precedente oppure se nel cluster della versione 1.8 o successiva non sono abilitati gli alias IP, segui questi passaggi alternativi prima di provare a connetterti all'istanza:
Soluzione alternativa

Esegui questi tre comandi, sostituendo RESERVED_IP_RANGE con l'intervallo IP riservato della tua istanza:
```
git clone https://github.com/bowei/k8s-custom-iptables.git
```
```
cd k8s-custom-iptables/
```
```
TARGETS="RESERVED_IP_RANGE" ./install.sh
```
Se non conosci l'intervallo IP riservato della tua istanza, puoi scoprirlo inserendo questo comando: gcloud redis instances describe INSTANCE_ID --region=REGION
Per ulteriori informazioni sugli alias IP, incluso come creare un cluster con questa impostazione abilitata, consulta Creazione di un cluster nativo di VPC.
Utilizza il comando seguente per connetterti a una shell bash:
```
kubectl run -i --tty busybox --image=busybox -- sh
```
Telnet alla tua istanza Redis utilizzando l'indirizzo host e il numero di porta:
```
telnet HOST-IP PORT
```
Inserisci un comando Redis di base per verificare la connessione:
```
PING
+PONG
```
Per chiudere la connessione telnet, premi Ctrl + C (o Comando + C su Mac). Per uscire dalla shell bash nel pod, inserisci Invio. Se hai finito e non hai più bisogno di connetterti a Redis, esegui il seguente comando dalla directory /k8s-custom-iptables/:
```
./uninstall.sh
```

Connessione a un'istanza Redis da un pod Google Kubernetes Engine

Prima di iniziare ti serve un cluster GKE. Se non hai già un cluster, creane uno con gli alias IP abilitati. Per istruzioni su come creare un cluster con gli alias IP abilitati, consulta Creazione di un cluster nativo di VPC.

Nell'angolo in alto a destra della console, fai clic sul pulsante Attiva Cloud Shell .
Configura l'accesso da riga di comando kubectl eseguendo il comando seguente:
```
gcloud container clusters get-credentials CLUSTER_NAME --zone CLUSTER_ZONE --project PROJECT_ID
```
- CLUSTER_NAME è il nome del cluster.
- CLUSTER_ZONE è la zona in cui si trova il tuo cluster. Deve essere anche la zona in cui si trova la tua istanza Redis.
- PROJECT_ID è il progetto in cui esistono il cluster e le istanze Redis.
Dovresti ricevere il messaggio di operazione riuscita: kubeconfig generated for CLUSTER_NAME
Se il cluster è versione 1.8 o successiva e sono abilitati gli alias IP, salta questo passaggio. Se nel tuo cluster è installata la versione 1.7 o una versione precedente oppure se nel cluster della versione 1.8 o successiva non sono abilitati gli alias IP, segui questi passaggi alternativi prima di provare a connetterti all'istanza:
Soluzione alternativa

Esegui questi tre comandi, sostituendo RESERVED_IP_RANGE con l'intervallo IP riservato della tua istanza:
```
git clone https://github.com/bowei/k8s-custom-iptables.git
```
```
cd k8s-custom-iptables/
```
```
TARGETS="RESERVED_IP_RANGE" ./install.sh
```
Se non conosci l'intervallo IP riservato della tua istanza, puoi scoprirlo inserendo questo comando: gcloud redis instances describe INSTANCE_ID --region [REGION]
Per ulteriori informazioni sugli alias IP, incluso come creare un cluster con questa impostazione abilitata, consulta Creazione di un cluster nativo di VPC.
Utilizza il comando seguente per avviare un pod Redis con l'esecuzione del redis-cli:
```
kubectl run -i --tty redisbox --image=gcr.io/google_containers/redis:v1 -- sh
```
Esegui un comando redis-cli, sostituendo HOST-IP con l'indirizzo IP dell'istanza Redis:
```
redis-cli -h HOST-IP info
```

Facoltativamente, esegui un comando Redis benchmark, sostituendo di nuovo HOST-IP con l'indirizzo IP dell'istanza Redis:

redis-benchmark -c 100 -n 100000 -d 1024 -r 100000 -t PING,SET,GET,INCR,LPUSH,RPUSH,LPOP,RPOP,SADD,SPOP,MSET -h HOST-IP -q

Per uscire dal pod Redis, inserisci return. Se hai finito e non devi più connetterti a Redis, esegui questo comando dalla directory /k8s-custom-iptables/:
```
./uninstall.sh
```

Passaggi successivi

Connettiti all'istanza Redis utilizzando un'applicazione di esempio in esecuzione su: