Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Connettiti a un'istanza Redis

Questa pagina descrive come connetterti all'istanza Redis utilizzando Telnet e redis-cli. Inoltre, fornisce istruzioni su come connettersi quando si utilizzano funzionalità come le repliche di lettura, AUTH e la crittografia in transito. Infine, fornisce istruzioni su come connettersi da un ambiente Google Kubernetes Engine.

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

Connettersi a un'istanza Redis da una VM di Compute Engine utilizzando telnet

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

Se non hai una VM di Compute Engine che utilizza la stessa rete autorizzata dell'istanza, creane una e connettiti alla VM utilizzando SSH. Per farlo, segui i passaggi descritti in Creare un'istanza VM Linux in Compute Engine.
Utilizza apt-get per installare telnet:
```
sudo apt-get install telnet
```
Nel terminale, inserisci il comando telnet seguito dall'indirizzo IP dell'istanza. Sostituisci VARIABLES con valori appropriati.
```
telnet INSTANCE_IP_ADDRESS 6379
```
Se riesci a connetterti all'istanza, il comando restituisce 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
```

Connettersi a un'istanza Redis da una VM di Compute Engine utilizzando `redis-cli`

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

Se non hai già una VM di Compute Engine che utilizza la rete autorizzata per l'istanza Redis, creane una e connettiti seguendo la procedura descritta in Creare un'istanza VM in una subnet specifica.
Installa redis-cli sulla VM di Compute Engine eseguendo il seguente comando dal terminale SSH di Compute Engine:
```
sudo apt-get install redis-tools
```
Esegui il seguente comando nel terminale di Compute Engine, sostituendo variables con valori appropriati.
```
redis-cli -h redis-instance-ip-address
```
Ora sei connesso all'istanza Redis utilizzando redis-cli.
Una volta terminato il test della connessione all'istanza Redis, ti consigliamo di eliminare la VM di Compute Engine che hai utilizzato per connetterti all'istanza Redis. In questo modo, eviti di incorrere in addebiti sul tuo account di fatturazione Cloud.

Connettersi a un'istanza Redis che utilizza AUTH

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

Se non hai già una VM di Compute Engine che utilizza la stessa rete autorizzata dell'istanza Redis, creane una e connettiti seguendo la Guida rapida all'utilizzo di una VM Linux.
Installa redis-cli sulla VM di Compute Engine eseguendo il seguente comando dal terminale SSH di Compute Engine:
```
sudo apt-get install redis-tools
```
Recupera la stringa AUTH dell'istanza.
Esegui il seguente comando per utilizzare redis-cli per autenticare e connetterti a l'istanza, sostituendo variables con 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 all'istanza.
Una volta terminato il test della connessione all'istanza Redis, ti consigliamo di eliminare la VM di Compute Engine che hai utilizzato per connetterti all'istanza Redis. In questo modo, eviti di incorrere in addebiti sul tuo account di fatturazione Cloud.

Connettersi a un'istanza Redis utilizzando l'endpoint di lettura

Se la tua istanza ha le repliche di lettura abilitate, puoi connetterti all'endpoint di lettura seguendo queste istruzioni:

Se non hai già una VM di Compute Engine che utilizza la stessa rete autorizzata dell'istanza Redis, creane una e connettiti seguendo la Guida rapida all'utilizzo di una VM Linux.
Installa telnet utilizzando apt-get:
```
sudo apt-get install telnet
```
Per trovare l'indirizzo IP dell'endpoint di lettura dell'istanza, visualizza le 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 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
```

Connettersi a un'istanza Redis in modo sicuro utilizzando Stunnel e telnet

Questa sezione fornisce un esempio di come connettersi a un'istanza Redis con la crittografia in transito abilitata utilizzando Stunnel. Stunnel è un proxy che aggiunge la funzionalità di crittografia TLS (Transport Layer Security) a client e server senza modificarne il codice. Per saperne di più, consulta la documentazione di Stunnel.

Se non hai un'istanza Redis con la crittografia in transito abilitata, creane una. Per saperne di più, consulta Creare un'istanza Redis con la crittografia in transito.
Se non hai una VM di Compute Engine che utilizza la stessa rete autorizzata dell'istanza Redis del passaggio precedente, creane una e connettiti. Per saperne di più, consulta Creare un'istanza VM Linux in Compute Engine.
Installa gli strumenti necessari per questa procedura eseguendo i seguenti comandi:
```
sudo apt-get install stunnel4
```
```
sudo apt-get install telnet
```
I passaggi rimanenti di questa procedura vengono eseguiti nel terminale SSH della VM di Compute Engine che hai creato e a cui ti sei connesso, se non diversamente specificato.
Configura la VM di Compute Engine per l'utilizzo con Stunnel:
1. Crea un file per l'autorità di certificazione (CA) eseguendo il seguente comando:
```
sudo vim /tmp/server_ca.pem
```
2. Visualizza le CA dell'istanza Redis eseguendo il seguente comando nel terminale standard che utilizzi per gestire le Google Cloud risorse (non il terminale di Compute Engine):
```
gcloud redis instances describe INSTANCE_ID --region=REGION
```
  Esegui le seguenti sostituzioni:
  - INSTANCE_ID: l'ID dell'istanza Redis
  - REGION: la regione in cui si trova l'istanza
  Possono essere presenti fino a tre CA.
3. Copia tutte le CA, inclusa la riga -----BEGIN CERTIFICATE----- e la riga
  -----END CERTIFICATE-----, incolla e salva i contenuti nel file server_ca.pem che hai creato.
  
  Assicurati che il testo della CA sia completamente giustificato a sinistra e che non ci siano spazi vuoti iniziali su nessuna riga della CA.
4. Crea un file per le informazioni di configurazione di Stunnel eseguendo il seguente comando:
```
sudo vim /etc/stunnel/redis-client.conf
```
5. Incolla il seguente testo nel file, sostituendo REDIS_INSTANCE_IP con l'indirizzo IP dell'istanza:
```
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
```
6. Avvia Stunnel eseguendo il seguente comando:
```
sudo stunnel /etc/stunnel/redis-client.conf
```
7. Verifica che Stunnel sia in esecuzione:
```
ps aux | grep stunnel
```
8. Riavvia Stunnel eseguendo il seguente comando:
```
sudo systemctl restart stunnel4
```
  Puoi utilizzare il comando ps aux | grep stunnel prima e dopo il riavvio di Stunnel per verificare che il riavvio sia andato a buon fine. Se l'ID di processo Stunell, mostrato dal comando ps aux | grep stunnel, è diverso, significa che Stunell è stato riavviato correttamente.
Per connetterti all'istanza Redis utilizzando telnet, esegui il seguente comando:
```
telnet localhost 6378
```
Nella sessione di Telnet, verifica la connessione.
1. (Facoltativo) Se la tua istanza ha Redis AUTH abilitato, devi autenticarti prima di testare la connessione.
  
  Esegui questo comando:
```
AUTH AUTH_STRING
```
  Sostituisci AUTH_STRING con la stringa di autenticazione dell'istanza.
  
  Risultato:
```
OK
```
Esegui questo comando:
```
PING
```
Risultato:
```
PONG
```
(Facoltativo) In alternativa a telnet, puoi connetterti utilizzando redis-cli tramite la porta Stunnel locale e passare la stringa AUTH.

Esegui questo comando:
```
redis-cli -h 127.0.0.1 -p 6378 -a AUTH_STRING
```

Connettersi da una macchina locale utilizzando il port forwarding

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

Crea un'istanza di Compute Engine eseguendo il seguente comando:
```
gcloud compute instances create COMPUTE_VM_NAME --machine-type=f1-micro --zone=ZONE
```
Dove:
- COMPUTE_VM_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 f1-micro tipo di macchina per ridurre i costi. Puoi scegliere altri tipi di macchine.
Apri un nuovo terminale sulla macchina locale.
Per creare un tunnel SSH che inoltri il traffico tramite la VM di Compute Engine, esegui il seguente comando:
```
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 dell'istanza Redis.
Per testare la connessione, apri una nuova finestra del terminale ed esegui il seguente comando:
```
redis-cli ping
```
Se funziona correttamente, il risultato dovrebbe essere:
```
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é la finestra del terminale con la connessione del tunnel SSH è attiva e in esecuzione.

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

Per verificare se il cluster utilizza gli alias IP, utilizza gcloud container clusters describe.

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

Connettersi da un pod che esegue una shell bash

Vai alla pagina GKE nella Google Cloud console.
GKE
Fai clic sul cluster GKE da cui vuoi connetterti. 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 Creare un cluster nativo di VPC.
Fai clic sul pulsante Connetti a destra del nome del cluster, quindi fai clic sul pulsante Esegui in Cloud Shell nella finestra visualizzata.
Configura l'accesso alla riga di comando kubectl eseguendo il seguente comando:
```
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 cluster. Deve essere anche la zona in cui si trova l'istanza Redis.
- PROJECT_ID è il progetto in cui esistono il cluster e le istanze Redis.
Dovresti ricevere il messaggio di riuscita: kubeconfig generated for CLUSTER_NAME
Se il cluster è la versione 1.8 o successive e ha gli alias IP abilitati, salta questo passaggio. Se il cluster è la versione 1.7 o precedenti oppure il cluster della versione 1.8 o successive non ha gli alias IP abilitati, segui questi passaggi di soluzione alternativa prima di provare a connetterti all'istanza:
Soluzione alternativa

Esegui i seguenti comandi, sostituendo RESERVED_IP_RANGE con l'intervallo IP riservato dell'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 dell'istanza, puoi scoprirlo inserendo questo comando: gcloud redis instances describe INSTANCE_ID --region=REGION
Per saperne di più sugli alias IP, incluso come creare un cluster con questa impostazione abilitata, consulta Creare un cluster nativo di VPC.
Utilizza il seguente comando per connetterti a una shell bash:
```
kubectl run -i --tty busybox --image=busybox -- sh
```
Inserisci il comando telnet seguito dall'indirizzo host e dal numero di porta dell'istanza Redis:
```
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, premi Invio. Se hai finito e non devi più connetterti a Redis, esegui il seguente comando dalla /k8s-custom-iptables/ directory:
```
./uninstall.sh
```

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

Prima di iniziare, devi avere 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 Creare un cluster nativo di VPC.

Nell'angolo in alto a destra della console, fai clic sul pulsante Attiva Cloud Shell .
Configura l'accesso alla riga di comando kubectl eseguendo il seguente comando:
```
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 cluster. Deve essere anche la zona in cui si trova l'istanza Redis.
- PROJECT_ID è il progetto in cui esistono il cluster e le istanze Redis.
Dovresti ricevere il messaggio di riuscita: kubeconfig generated for CLUSTER_NAME
Se il cluster è la versione 1.8 o successive e ha gli alias IP abilitati, salta questo passaggio. Se il cluster è la versione 1.7 o precedenti oppure il cluster della versione 1.8 o successive non ha gli alias IP abilitati, segui questi passaggi di soluzione alternativa prima di provare a connetterti all'istanza:
Soluzione alternativa

Esegui i seguenti comandi, sostituendo RESERVED_IP_RANGE con l'intervallo IP riservato dell'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 dell'istanza, puoi scoprirlo inserendo questo comando: gcloud redis instances describe INSTANCE_ID --region [REGION]
Per saperne di più sugli alias IP, incluso come creare un cluster con questa impostazione abilitata, consulta Creare un cluster nativo di VPC.
Utilizza il seguente comando per avviare un pod Redis che esegue redis-cli:
```
kubectl run -i --tty redisbox --image=redis:7.2 -- sh
```
Esegui un comando redis-cli, sostituendo HOST-IP con l'indirizzo IP host dell'istanza Redis:
```
redis-cli -h HOST-IP info
```

(Facoltativo) Esegui un comando di benchmark Redis, sostituendo di nuovo HOST-IP con l'indirizzo IP host 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, premi return. Se hai finito e non devi più connetterti a Redis, esegui il seguente comando dalla directory /k8s-custom-iptables/:
```
./uninstall.sh
```

Passaggi successivi

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