Esta página se ha traducido con Cloud Translation API.

Conectarse a una instancia de Redis

En esta página se describe cómo conectarse a su instancia de Redis mediante Telnet y redis-cli. Además, en esta página se proporcionan instrucciones sobre cómo conectarse al usar funciones como réplicas de lectura, AUTH y cifrado en tránsito. Por último, en esta página se proporcionan instrucciones para conectarse desde un entorno de Google Kubernetes Engine.

Para ver una lista de los Google Cloud entornos compatibles con Memorystore para Redis, consulta Entornos admitidos. Algunos entornos sin servidor compatibles con Memorystore requieren un conector de Acceso a VPC sin servidor. Consulta los requisitos del conector de Acceso a VPC sin servidor para obtener más información.

Conectarse a una instancia de Redis desde una VM de Compute Engine mediante telnet

Puedes conectarte a la instancia de Redis desde cualquier VM de Compute Engine que use la red autorizada de la instancia de Redis con una dirección IP RFC 1918 compatible.

Si aún no tienes una máquina virtual de Compute Engine que use la misma red autorizada que tu instancia de Redis, crea una y conéctate a ella siguiendo la guía de inicio rápido con una máquina virtual de Linux.
Instala telnet con apt-get:
```
sudo apt-get install telnet
```
En el terminal, usa telnet para conectarte a la dirección IP de la instancia de Redis. Sustituye variables por los valores adecuados.
```
telnet instance-ip-address 6379
```
Si la acción se realiza correctamente, el comando mostrará lo siguiente:
```
Trying instance-ip-address…
Connected to instance-ip-address
```
En la sesión de Telnet, introduce algunos comandos de Redis:

Introduce estos datos:
```
PING
```
Resultado:
```
PONG
```
Intro
```
SET HELLO WORLD
```
Resultado:
```
+OK
```
Introduce estos datos:
```
GET HELLO
```
Resultado:
```
$5
WORLD
```

Conectarse a una instancia de Redis desde una VM de Compute Engine mediante `redis-cli`

Puedes conectarte a la instancia de Redis desde cualquier VM de Compute Engine que use la red autorizada de la instancia de Redis con una dirección IP RFC 1918 compatible.

Si aún no tienes una máquina virtual de Compute Engine que use la red autorizada de tu instancia de Redis, crea una y conéctate a ella siguiendo los pasos que se indican en Crear una instancia de VM en una subred específica.
Instala redis-cli en la máquina virtual de Compute Engine ejecutando el siguiente comando desde la terminal SSH de Compute Engine:
```
sudo apt-get install redis-tools
```
Ejecuta el siguiente comando en el terminal de Compute Engine y sustituye variables por los valores correspondientes.
```
redis-cli -h redis-instance-ip-address
```
Ahora estás conectado a tu instancia de Redis mediante redis-cli.
Cuando hayas terminado de probar la conexión a la instancia de Redis, te recomendamos que elimines la VM de Compute Engine que has usado para conectarte a la instancia de Redis. De esta forma, evitarás que se apliquen cargos a tu cuenta de Facturación de Cloud.

Conectarse a una instancia de Redis que usa AUTH

En esta sección se describe cómo conectarse a una instancia de Redis que tiene habilitada la función AUTH.

Si aún no tienes una VM de Compute Engine que use la misma red autorizada que tu instancia de Redis, crea una y conéctate a ella siguiendo la guía de inicio rápido con una VM de Linux.
Instala redis-cli en la máquina virtual de Compute Engine ejecutando el siguiente comando desde la terminal SSH de Compute Engine:
```
sudo apt-get install redis-tools
```
Obtener la cadena de autenticación de tu instancia
Ejecuta el siguiente comando para usar redis-cli para autenticarte y conectarte a tu instancia. Sustituye variables por los valores adecuados:
```
redis-cli -h instance-ip-address -a auth-string
```
O:
```
redis-cli -h instance-ip-address
AUTH auth-string
```
Ejecuta los comandos SET y GET de Redis para verificar que has establecido una conexión autenticada con tu instancia.
Cuando hayas terminado de probar la conexión a la instancia de Redis, te recomendamos que elimines la VM de Compute Engine que has usado para conectarte a la instancia de Redis. De esta forma, evitarás que se apliquen cargos a tu cuenta de Facturación de Cloud.

Conectarse a una instancia de Redis mediante el endpoint de lectura

Si tu instancia tiene réplicas de lectura habilitadas, puedes conectarte al endpoint de lectura siguiendo estas instrucciones:

Si aún no tienes una máquina virtual de Compute Engine que use la misma red autorizada que tu instancia de Redis, crea una y conéctate a ella siguiendo la guía de inicio rápido con una máquina virtual de Linux.
Instala telnet con apt-get:
```
sudo apt-get install telnet
```
Para encontrar la dirección IP del endpoint de lectura de tu instancia, consulta la sección Ver la información de la réplica de lectura de tu instancia.
En la terminal, usa telnet para conectarte a la dirección IP del endpoint de lectura de la instancia de Redis. Sustituye variables por los valores correspondientes.
```
telnet read-endpoint-ip 6379
```
Si la acción se realiza correctamente, el comando mostrará lo siguiente:
```
Trying read-endpoint-ip…
Connected to read-endpoint-ip
```
En la sesión de Telnet, introduce algunos comandos de Redis:

Introduce estos datos:
```
PING
```
Resultado:
```
PONG
```

Conectarse de forma segura a una instancia de Redis mediante Stunnel y telnet

En esta sección se muestra un ejemplo de cómo conectarse a una instancia de Redis que tiene habilitado el cifrado en tránsito mediante Stunnel.

Si aún no tienes una instancia de Redis con el cifrado en tránsito habilitado, crea una siguiendo los pasos que se indican en Crear una instancia de Redis con el cifrado en tránsito.
Si aún no tienes una máquina virtual de Compute Engine que use la misma red autorizada que la instancia de Redis del paso anterior, crea una y conéctate a ella siguiendo la guía de inicio rápido con una máquina virtual de Linux.
1. Instala las herramientas necesarias para esta guía ejecutando los siguientes comandos:
```
sudo apt-get install stunnel4
```
```
sudo apt-get install telnet
```
Nota: Los pasos restantes de esta guía se llevan a cabo en el terminal SSH de la VM de Compute Engine que has creado y a la que te has conectado, a menos que se indique lo contrario.
Configura tu máquina virtual de Compute Engine para usarla con Stunnel:
1. Crea un archivo en el que colocar tu autoridad de certificación (CA) ejecutando el siguiente comando:
```
sudo vim /tmp/server_ca.pem
```
2. Para ver las autoridades de certificación de tu instancia de Redis, ejecuta el siguiente comando en el terminal estándar que usas para gestionar losGoogle Cloud recursos (no en el terminal de Compute Engine):
```
gcloud redis instances describe instance-id --region=region
```
  Puede haber hasta tres CAs.
3. Copia todas las autoridades de certificación visibles, incluidas las líneas -----BEGIN CERTIFICATE----- y -----END CERTIFICATE-----, y pégalas en el archivo server_ca.pem que has creado anteriormente.
  
  Nota: Asegúrate de que el texto de la autoridad de certificación esté completamente justificado a la izquierda. No debe haber espacios en blanco al principio de ninguna línea de la CA.
4. Crea un archivo en el que colocar la información de configuración de Stunnel ejecutando el siguiente comando:
```
sudo vim /etc/stunnel/redis-client.conf
```
  Pega el siguiente texto en el archivo y sustituye redis-instance-ip por la dirección IP de la instancia de 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
```
  Inicia stunnel ejecutando el siguiente comando:
```
sudo stunnel /etc/stunnel/redis-client.conf
```
  Comprueba que stunnel se esté ejecutando:
```
ps aux | grep stunnel
```
5. Reinicia Stunnel ejecutando los siguientes comandos:
```
sudo systemctl restart stunnel4
```
  Nota: Puedes usar el comando ps aux | grep stunnel antes y después de reiniciar stunnel para confirmar que el reinicio se ha realizado correctamente. Si el ID de proceso de stunell, que se muestra con el comando ps aux | grep stunnel , es diferente, significa que stunell se ha reiniciado correctamente.
Para conectarte a tu instancia de Redis mediante Telnet, ejecuta el siguiente comando:
```
telnet localhost 6378
```
En la sesión de Telnet, haz ping en la instancia de Redis:

Introduce estos datos:
```
PING
```
Resultado:
```
PONG
```

Conectarse desde una máquina local con redirección de puertos

Puede ser útil conectarse a su instancia de Redis desde su máquina local durante el desarrollo. Para ello, debes crear una instancia de Compute Engine que se use para la redirección de puertos a la instancia de Redis.

Crea una instancia de Compute Engine ejecutando el siguiente comando:
```
gcloud compute instances create COMPUTE_VM_NAME --machine-type=f1-micro --zone=ZONE
```
Donde:
- COMPUTE_VM_NAME es el nombre que asignas a la VM de Compute Engine.
- ZONE es la zona en la que quieres aprovisionar la VM.
Este comando crea una máquina virtual de Compute Engine con el f1-micro tipo de máquina para que sea rentable. Si quieres, puedes elegir otros tipos de máquina.
Abre un nuevo terminal en tu máquina local.
Para crear un túnel SSH que reenvíe el tráfico a través de la VM de Compute Engine, ejecuta el siguiente comando:
```
gcloud compute ssh COMPUTE_VM_NAME --zone=ZONE -- -N -L 6379:REDIS_INSTANCE_IP_ADDRESS:6379
```
Donde:
- COMPUTE_VM_NAME es el nombre de la VM de Compute Engine.
- ZONE es la misma zona en la que se encuentra la VM de Compute Engine.
- REDIS_INSTANCE_IP_ADDRESS es la dirección IP de tu instancia de Redis.
Para probar la conexión, abre una nueva ventana de terminal y ejecuta el siguiente comando:
```
redis-cli ping
```
Si funciona correctamente, el resultado debería ser el siguiente:
```
PONG
```
Ahora estás conectado a la instancia de Redis y puedes enviarle comandos mediante este túnel SSH abierto. Si aún no lo has hecho, instala redis-cli para poder ejecutar este comando.
El túnel SSH permanece abierto mientras mantengas la ventana de terminal con la conexión del túnel SSH activa.

Conectarse a una instancia de Redis desde un clúster de Google Kubernetes Engine

Puedes conectarte a tu instancia de Redis desde clústeres de Google Kubernetes Engine que usen la misma red autorizada que tu instancia de Redis.

Conectarse desde un pod que ejecuta un shell bash

Ve a la página de GKE en la Google Cloud consola
.GKE
Haz clic en el clúster de GKE desde el que quieras conectarte. Si aún no tienes un clúster, crea uno con los alias de IP habilitados. Para obtener instrucciones sobre cómo crear un clúster con alias de IP habilitados, consulta Crear un clúster nativo de VPC.
Haz clic en el botón Connect (Conectar) situado a la derecha del nombre de tu clúster y, a continuación, en el botón Run in Cloud Shell (Ejecutar en Cloud Shell) de la ventana que aparece.
Configura el acceso mediante línea de comandos kubectl ejecutando el siguiente comando:
```
gcloud container clusters get-credentials CLUSTER_NAME --zone=CLUSTER_ZONE --project=PROJECT_ID
```
- CLUSTER_NAME es el nombre de tu clúster.
- CLUSTER_ZONE es la zona en la que se encuentra tu clúster. También debe ser la zona en la que se encuentra tu instancia de Redis.
- PROJECT_ID es el proyecto en el que se encuentran tu clúster y tus instancias de Redis.
Debería aparecer el mensaje de confirmación: kubeconfig generated for CLUSTER_NAME
Si tu clúster tiene la versión 1.8 o una posterior y los alias de IP están habilitados, omite este paso. Si tu clúster tiene la versión 1.7 o una anterior, o si tu clúster con la versión 1.8 o una posterior no tiene habilitados los alias de IP, sigue estos pasos alternativos antes de intentar conectarte a tu instancia:
Solución

Ejecuta estos tres comandos y sustituye RESERVED_IP_RANGE por el intervalo de IPs reservado de tu instancia:
```
git clone https://github.com/bowei/k8s-custom-iptables.git
```
```
cd k8s-custom-iptables/
```
```
TARGETS="RESERVED_IP_RANGE" ./install.sh
```
Si no conoces el intervalo de IPs reservadas de tu instancia, puedes averiguarlo introduciendo este comando: gcloud redis instances describe INSTANCE_ID --region=REGION
Para obtener más información sobre los alias de IP, incluido cómo crear un clúster con este ajuste habilitado, consulta el artículo Crear un clúster nativo de VPC.
Usa el siguiente comando para conectarte a un shell de Bash:
```
kubectl run -i --tty busybox --image=busybox -- sh
```
Conéctate por Telnet a tu instancia de Redis mediante la dirección del host y el número de puerto:
```
telnet HOST-IP PORT
```
Introduce un comando básico de Redis para verificar la conexión:
```
PING
+PONG
```
Para cerrar la conexión telnet, pulsa Control+C (o Comando+C en Mac). Para salir del shell de bash en tu pod, pulsa Intro. Si has terminado y ya no necesitas conectarte a Redis, ejecuta el siguiente comando desde el directorio /k8s-custom-iptables/:
```
./uninstall.sh
```

Conectarse a una instancia de Redis desde un pod de Google Kubernetes Engine

Antes de empezar, necesitas un clúster de GKE. Si aún no tienes un clúster, crea uno con los alias de IP habilitados. Para obtener instrucciones sobre cómo crear un clúster con alias de IP habilitados, consulta Crear un clúster nativo de VPC.

En la esquina superior derecha de la consola, haz clic en el botón Activar Cloud Shell .
Configura el acceso mediante línea de comandos kubectl ejecutando el siguiente comando:
```
gcloud container clusters get-credentials CLUSTER_NAME --zone CLUSTER_ZONE --project PROJECT_ID
```
- CLUSTER_NAME es el nombre de tu clúster.
- CLUSTER_ZONE es la zona en la que se encuentra tu clúster. También debe ser la zona en la que se encuentra tu instancia de Redis.
- PROJECT_ID es el proyecto en el que se encuentran tu clúster y tus instancias de Redis.
Debería aparecer el mensaje de confirmación: kubeconfig generated for CLUSTER_NAME
Si tu clúster tiene la versión 1.8 o una posterior y los alias de IP están habilitados, omite este paso. Si tu clúster tiene la versión 1.7 o una anterior, o si tu clúster con la versión 1.8 o una posterior no tiene habilitados los alias de IP, sigue estos pasos alternativos antes de intentar conectarte a tu instancia:
Solución

Ejecuta estos tres comandos y sustituye RESERVED_IP_RANGE por el intervalo de IPs reservado de tu instancia:
```
git clone https://github.com/bowei/k8s-custom-iptables.git
```
```
cd k8s-custom-iptables/
```
```
TARGETS="RESERVED_IP_RANGE" ./install.sh
```
Si no conoces el intervalo de IPs reservadas de tu instancia, puedes averiguarlo introduciendo este comando: gcloud redis instances describe INSTANCE_ID --region [REGION]
Para obtener más información sobre los alias de IP, incluido cómo crear un clúster con este ajuste habilitado, consulta el artículo Crear un clúster nativo de VPC.

Usa el siguiente comando para iniciar un pod de Redis que ejecute redis-cli:

kubectl run -i --tty redisbox --image=gcr.io/google_containers/redis:v1 -- sh

Ejecuta el comando redis-cli y sustituye HOST-IP por la dirección IP del host de tu instancia de Redis:
```
redis-cli -h HOST-IP info
```
También puedes ejecutar un comando de comparativa de Redis. Para ello, vuelve a sustituir HOST-IP por la dirección IP del host de tu instancia de 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
```
Para salir del pod de Redis, introduce return. Si has terminado y ya no necesitas conectarte a Redis, ejecuta el siguiente comando desde el directorio /k8s-custom-iptables/:
```
./uninstall.sh
```

Siguientes pasos

Conéctate a tu instancia de Redis mediante una aplicación de ejemplo que se ejecute en: