Google utiliza tecnología de IA para traducir contenido a tu idioma preferido. Las traducciones realizadas con IA pueden contener errores.

Conéctate a una instancia de Redis

En esta página, se describe cómo conectarte a tu instancia de Redis con Telnet y redis-cli. Además, se proporcionan instrucciones para conectarse cuando se usan funciones como réplicas de lectura, AUTH y encriptación en tránsito. Por último, se proporcionan instrucciones para conectarse desde un entorno de Google Kubernetes Engine.

Para obtener una lista de los Google Cloud entornos que admite Memorystore para Redis, consulta Entornos compatibles. Algunos entornos sin servidores que admite Memorystore requieren un conector de Acceso a VPC sin servidores. Consulta Requisito del conector de Acceso a VPC sin servidores para obtener más detalles.

Conéctate a una instancia de Redis desde una VM de Compute Engine con telnet

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

Si no tienes una VM de Compute Engine que use la misma red autorizada que tu instancia, crea una y conéctate a ella con SSH. Para ello, sigue los pasos que se indican en Crea una instancia de VM de Linux en Compute Engine.
Usa apt-get para instalar telnet:
```
sudo apt-get install telnet
```
Desde la terminal, ejecuta telnet a la dirección IP de la instancia. Reemplaza VARIABLES por los valores adecuados.
```
telnet INSTANCE_IP_ADDRESS 6379
```
Si puedes conectarte a la instancia, el comando muestra este resultado:
```
Trying INSTANCE_IP_ADDRESS…
Connected to INSTANCE_IP_ADDRESS
```
En la sesión de telnet, ingresa algunos comandos de Redis:

Ingrese:
```
PING
```
Resultado:
```
PONG
```
Ingresa:
```
SET HELLO WORLD
```
Resultado:
```
+OK
```
Ingrese:
```
GET HELLO
```
Resultado:
```
$5
WORLD
```

Conéctate a una instancia de Redis desde una VM de Compute Engine con `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 VM de Compute Engine que use la red autorizada para tu instancia de Redis, crea una y conéctate a ella siguiendo Crea una instancia de VM en una subred específica.
Para instalar redis-cli en la VM de Compute Engine, ejecuta el siguiente comando desde la terminal SSH de Compute Engine:
```
sudo apt-get install redis-tools
```
Ejecuta el siguiente comando en la terminal de Compute Engine y reemplaza variables por los valores apropiados.
```
redis-cli -h redis-instance-ip-address
```
Ahora estás conectado a tu instancia de Redis mediante redis-cli.
Una vez que termines de probar tu conexión con la instancia de Redis, debes considerar borrar la VM de Compute Engine que usaste para conectarte a la instancia de Redis. Si lo haces, evitarás que se apliquen cargos a tu cuenta de Facturación de Cloud.

Conéctate 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 sobre el uso de una VM de Linux.
Para instalar redis-cli en la VM de Compute Engine, ejecuta el siguiente comando desde la terminal SSH de Compute Engine:
```
sudo apt-get install redis-tools
```
Obtén la string AUTH de la instancia
Ejecuta el siguiente comando a fin de usar redis-cli para autenticar y conectarte a tu instancia, y reemplaza variables por los valores apropiados:
```
redis-cli -h instance-ip-address -a auth-string
```
O el siguiente:
```
redis-cli -h instance-ip-address
AUTH auth-string
```
Ejecuta un comando SET y GET de Redis para verificar que estableciste una conexión autenticada a tu instancia.
Una vez que termines de probar tu conexión con la instancia de Redis, debes considerar borrar la VM de Compute Engine que usaste para conectarte a la instancia de Redis. Si lo haces, evitarás que se apliquen cargos a tu cuenta de Facturación de Cloud.

Conéctate a una instancia de Redis con el extremo de lectura

Si tu instancia tiene réplicas de lectura habilitadas, puedes conectarte al extremo de lectura con las siguientes instrucciones:

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 sobre el uso de una VM de Linux.
Instala telnet con apt-get:
```
sudo apt-get install telnet
```
Para encontrar la dirección IP del extremo de lectura de tu instancia, consulta la información de la réplica de lectura de tu instancia.
Desde la terminal, ejecuta telnet a la dirección IP de extremo de lectura de la instancia de Redis y reemplaza variables por los valores adecuados.
```
telnet read-endpoint-ip 6379
```
Si se ejecuta de forma correcta, el comando mostrará este resultado:
```
Trying read-endpoint-ip…
Connected to read-endpoint-ip
```
En la sesión de telnet, ingresa algunos comandos de Redis:

Ingrese:
```
PING
```
Resultado:
```
PONG
```

Conéctate a una instancia de Redis de forma segura con Stunnel y telnet

En esta sección, se proporciona un ejemplo de cómo conectarse a una instancia de Redis que tiene habilitada la encriptación en tránsito con Stunnel. Stunnel es un proxy que agrega funcionalidad de encriptación de seguridad de la capa de transporte (TLS) a clientes y servidores sin cambiar su código. Para obtener más información, consulta la documentación de Stunnel.

Si no tienes una instancia de Redis que tenga habilitada la encriptación en tránsito, crea una. Para obtener más información, consulta Crea una instancia de Redis con encriptación en tránsito.
Si no tienes una VM de Compute Engine que use la misma red autorizada que la instancia de Redis del paso anterior, crea una y conéctate a ella. Para obtener más información, consulta Crea una instancia de VM de Linux en Compute Engine.
Para instalar las herramientas necesarias para este procedimiento, ejecuta los siguientes comandos:
```
sudo apt-get install stunnel4
```
```
sudo apt-get install telnet
```
Los pasos restantes de este procedimiento se realizan en la terminal SSH de la VM de Compute Engine que creaste y a la que te conectaste, a menos que se especifique lo contrario.
Configura tu VM de Compute Engine para usarla con Stunnel:
1. Ejecuta el siguiente comando para crear un archivo para tu autoridad certificadora (AC):
```
sudo vim /tmp/server_ca.pem
```
2. Para ver las AC de tu instancia de Redis, ejecuta el siguiente comando en la terminal estándar que usas para administrar tus Google Cloud recursos (no la terminal de Compute Engine):
```
gcloud redis instances describe INSTANCE_ID --region=REGION
```
  Realiza los siguientes reemplazos:
  - INSTANCE_ID: Es el ID de tu instancia de Redis.
  - REGION: Es la región en la que se encuentra la instancia.
  Puede haber hasta tres AC.
3. Copia todas las AC, incluidas la línea -----BEGIN CERTIFICATE----- y la línea
  -----END CERTIFICATE-----, pega y guarda el contenido en el archivo server_ca.pem que creaste.
  
  Asegúrate de que el texto de la AC esté completamente justificado a la izquierda y de que no haya espacios en blanco iniciales en ninguna línea de la AC.
4. Ejecuta el siguiente comando para crear un archivo para la información de configuración de Stunnel:
```
sudo vim /etc/stunnel/redis-client.conf
```
5. Pega el siguiente texto en el archivo y reemplaza REDIS_INSTANCE_IP por la dirección IP de la instancia:
```
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. Para iniciar Stunnel, ejecuta el siguiente comando:
```
sudo stunnel /etc/stunnel/redis-client.conf
```
7. Verifica que Stunnel se esté ejecutando:
```
ps aux | grep stunnel
```
8. Para reiniciar Stunnel, ejecuta el siguiente comando:
```
sudo systemctl restart stunnel4
```
  Puedes usar el comando ps aux | grep stunnel antes y después de reiniciar Stunnel para confirmar que el reinicio se realizó correctamente. Si el ID del proceso de Stunell, que muestra el comando ps aux | grep stunnel, es diferente, significa que Stunell se reinició correctamente.
Para conectarte a tu instancia de Redis con telnet, ejecuta el siguiente comando:
```
telnet localhost 6378
```
En la sesión de telnet, prueba tu conexión.
1. Opcional: Si tu instancia tiene habilitada la AUTH de Redis, debes autenticarte antes de probar la conexión.
  
  Ejecuta el siguiente comando:
```
AUTH AUTH_STRING
```
  Reemplaza AUTH_STRING por la cadena de autenticación de la instancia.
  
  Resultado:
```
OK
```
Ejecuta el siguiente comando:
```
PING
```
Resultado:
```
PONG
```
Opcional: Como alternativa a telnet, puedes conectarte con redis-cli a través del puerto Stunnel local y pasar la cadena AUTH.

Ejecuta el siguiente comando:
```
redis-cli -h 127.0.0.1 -p 6378 -a AUTH_STRING
```

Conéctate desde una máquina local con la redirección de puertos

Puede ser útil conectarte a tu instancia de Redis desde tu máquina local durante el desarrollo. Para ello, debes crear una instancia de Compute Engine para usarla para la redirección de puertos a la instancia de Redis.

Ejecuta el siguiente comando para crear una instancia de Compute Engine:
```
gcloud compute instances create COMPUTE_VM_NAME --machine-type=f1-micro --zone=ZONE
```
Aquí:
- COMPUTE_VM_NAME es el nombre que designas para la VM de Compute Engine.
- ZONE es la zona en la que deseas aprovisionar la VM.
Este comando crea una VM de Compute Engine con el f1-micro tipo de máquina para la rentabilidad. Puedes elegir otros tipos de máquinas.
Abre una terminal nueva en la máquina local.
Para crear un túnel SSH que reenvíe el tráfico mediante la redirección de puertos 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
```
Aquí:
- 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 mostrar lo siguiente:
```
PONG
```
Ahora estás conectado a la instancia de Redis y puedes enviar comandos a la instancia de Redis con este túnel SSH abierto. Si aún no instalaste redis-cli, instálalo 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 en funcionamiento.

Conéctate a una instancia de Redis desde un clúster de Google Kubernetes Engine

Para verificar si tu clúster usa alias de IP, usa gcloud container clusters describe.

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.

Conéctate 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 deseas 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 los alias de IP habilitados, consulta Crea un clúster nativo de la VPC.
Haz clic en el botón Conectar a la derecha del nombre de tu clúster y haz clic en el botón Ejecutar en Cloud Shell en la ventana que aparece.
Configura el acceso a la línea de comandos de kubectl mediante la ejecución del 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 donde existen tu clúster y tus instancias de Redis.
Deberías recibir el mensaje de éxito: kubeconfig generated for CLUSTER_NAME
Si tu clúster es de la versión 1.8 o superior y tienes habilitados los alias de IP, omite este paso. Si tu clúster es de la versión 1.7 o inferior, o tu clúster de la versión 1.8 o superior no tiene habilitados los alias de IP, sigue estos pasos alternativos antes de intentar conectarte a tu instancia:
Solución alternativa

Ejecuta los siguientes comandos y reemplaza RESERVED_IP_RANGE por el rango de IP 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 rango de IP reservado de tu instancia, puedes averiguarlo si ingresas 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 esta configuración habilitada, consulta Crea un clúster nativo de la VPC.
Usa el siguiente comando para conectarte a un shell Bash:
```
kubectl run -i --tty busybox --image=busybox -- sh
```
Ejecuta telnet a tu instancia de Redis mediante la dirección de host y el número de puerto:
```
telnet HOST-IP PORT
```
Ingresa un comando básico de Redis para verificar la conexión:
```
PING
+PONG
```
Para cerrar la conexión telnet, presiona Control + C (o Comando + C en Mac). Para salir de un shell Bash en tu pod, ingresa mostrar. Si terminaste y ya no necesitas conectarte a Redis, ejecuta el siguiente comando desde el /k8s-custom-iptables/ directorio:
```
./uninstall.sh
```

Conéctate a una instancia de Redis desde un pod de Google Kubernetes Engine

Antes de comenzar, 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 los alias de IP habilitados, consulta Crea un clúster nativo de la VPC.

En la esquina superior derecha de la consola, haz clic en el botón Activar Cloud Shell .
Configura el acceso a la línea de comandos de kubectl mediante la ejecución del 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 donde existen tu clúster y tus instancias de Redis.
Deberías recibir el mensaje de éxito: kubeconfig generated for CLUSTER_NAME
Si tu clúster es de la versión 1.8 o superior y tienes habilitados los alias de IP, omite este paso. Si tu clúster es de la versión 1.7 o inferior, o tu clúster de la versión 1.8 o superior no tiene habilitados los alias de IP, sigue estos pasos alternativos antes de intentar conectarte a tu instancia:
Solución alternativa

Ejecuta los siguientes comandos y reemplaza RESERVED_IP_RANGE por el rango de IP 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 rango de IP reservado de tu instancia, puedes averiguarlo si ingresas 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 esta configuración habilitada, consulta Crea un clúster nativo de la VPC.
Usa el siguiente comando para iniciar un pod de Redis que ejecute redis-cli:
```
kubectl run -i --tty redisbox --image=redis:7.2 -- sh
```
Ejecuta un comando redis-cli y reemplaza HOST-IP por la dirección IP de host de tu instancia de Redis:
```
redis-cli -h HOST-IP info
```
De manera opcional, ejecuta un comando de comparativa de Redis y vuelve a reemplazar HOST-IP por la dirección IP de 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, ingresa return. Si terminaste y ya no necesitas conectarte a Redis, ejecuta el siguiente comando desde el directorio /k8s-custom-iptables/:
```
./uninstall.sh
```

Qué sigue

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