Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Se connecter à une instance Redis

Cette page explique comment vous connecter à votre instance Redis à l'aide de Telnet et de redis-cli. Elle fournit également des instructions sur la connexion lorsque vous utilisez des fonctionnalités telles que les instances dupliquées avec accès en lecture, AUTH et le chiffrement en transit. Enfin, elle explique comment vous connecter à partir d'un environnement Google Kubernetes Engine.

Pour obtenir la liste des Google Cloud environnements compatibles avec Memorystore pour Redis, consultez la section Environnements compatibles. Certains environnements sans serveur compatibles avec Memorystore nécessitent un connecteur d'accès au VPC sans serveur. Pour en savoir plus, consultez la section Exigence concernant le connecteur d'accès au VPC sans serveur.

Se connecter à une instance Redis depuis une VM Compute Engine à l'aide de telnet

Vous pouvez vous connecter à une instance Memorystore pour Redis depuis n'importe quelle VM Compute Engine utilisant le réseau autorisé de l'instance avec une adresse IP RFC 1918 compatible.

Si vous ne disposez pas d'une VM Compute Engine utilisant le même réseau autorisé que votre instance, créez-en une et connectez-vous à la VM à l'aide de SSH. Pour ce faire, suivez les étapes décrites dans la section Créer une instance de VM Linux dans Compute Engine.
Utilisez apt-get pour installer telnet :
```
sudo apt-get install telnet
```
Depuis le terminal, connectez-vous via telnet à l'adresse IP de l'instance. Remplacez VARIABLES par les valeurs appropriées.
```
telnet INSTANCE_IP_ADDRESS 6379
```
Si vous pouvez vous connecter à l'instance, la commande renvoie le résultat suivant :
```
Trying INSTANCE_IP_ADDRESS…
Connected to INSTANCE_IP_ADDRESS
```
Dans la session telnet, renseignez quelques commandes Redis. Exemple :

Saisissez le code suivant :
```
PING
```
Résultat :
```
PONG
```
Saisissez les informations suivantes :
```
SET HELLO WORLD
```
Résultat :
```
+OK
```
Saisissez le code suivant :
```
GET HELLO
```
Résultat :
```
$5
WORLD
```

Se connecter à une instance Redis depuis une VM Compute Engine à l'aide de `redis-cli`

Vous pouvez vous connecter à une instance Redis depuis n'importe quelle VM Compute Engine utilisant le réseau autorisé de l'instance Redis avec une adresse IP RFC 1918 compatible.

Si vous ne disposez pas encore d'une VM Compute Engine utilisant le réseau autorisé de votre instance Redis, créez-en une et connectez-vous en suivant les instructions de la section Créer une instance de VM dans un sous-réseau spécifique.
Installez redis-cli sur la VM Compute Engine en exécutant la commande suivante à partir du terminal SSH de Compute Engine :
```
sudo apt-get install redis-tools
```
Exécutez la commande suivante dans le terminal Compute Engine, en remplaçant les variables par les valeurs appropriées.
```
redis-cli -h redis-instance-ip-address
```
Vous êtes maintenant connecté à votre instance Redis à l'aide de redis-cli.
Une fois que vous avez terminé de tester la connexion à l'instance Redis, pensez à supprimer la VM Compute Engine que vous avez utilisée pour vous connecter à l'instance Redis. Vous éviterez ainsi que des frais soient facturés sur votre compte de facturation Cloud.

Se connecter à une instance Redis qui utilise AUTH

Cette section explique comment se connecter à une instance Redis pour laquelle la fonctionnalité AUTH est activée.

Si vous ne disposez pas encore d'une VM Compute Engine utilisant le même réseau autorisé que votre instance Redis, créez-en une et connectez-vous en suivant les instructions de la page Démarrage rapide à l'aide d'une VM Linux.
Installez redis-cli sur la VM Compute Engine en exécutant la commande suivante à partir du terminal SSH de Compute Engine :
```
sudo apt-get install redis-tools
```
Obtenez la chaîne AUTH de votre instance.
Exécutez la commande suivante pour vous authentifier et vous connecter à votre instance à l'aide de redis-cli, en remplaçant les variables par les valeurs appropriées :
```
redis-cli -h instance-ip-address -a auth-string
```
ou
```
redis-cli -h instance-ip-address
AUTH auth-string
```
Exécutez une commande Redis SET et GET pour vérifier que vous avez établi une connexion authentifiée à votre instance.
Une fois que vous avez terminé de tester la connexion à l'instance Redis, pensez à supprimer la VM Compute Engine que vous avez utilisée pour vous connecter à l'instance Redis. Vous éviterez ainsi que des frais soient facturés sur votre compte de facturation Cloud.

Se connecter à une instance Redis à l'aide du point de terminaison en lecture

Si les instances dupliquées avec accès en lecture sont activées sur votre instance, vous pouvez vous connecter au point de terminaison en lecture en procédant comme suit :

Si vous ne disposez pas encore d'une VM Compute Engine utilisant le même réseau autorisé que votre instance Redis, créez-en une et connectez-vous en suivant les instructions de la page Démarrage rapide à l'aide d'une VM Linux.
Installez telnet à l'aide de apt-get :
```
sudo apt-get install telnet
```
Pour trouver l'adresse IP du point de terminaison en lecture de votre instance, consultez les informations sur les instances dupliquées avec accès en lecture de votre instance.
Depuis le terminal, connectez telnet à l'adresse IP du point de terminaison de lecture de l'instance Redis, en remplaçant variables par les valeurs appropriées.
```
telnet read-endpoint-ip 6379
```
Si l'opération réussit, la commande renvoie ce résultat :
```
Trying read-endpoint-ip…
Connected to read-endpoint-ip
```
Dans la session telnet, renseignez quelques commandes Redis. Exemple :

Saisissez le code suivant :
```
PING
```
Résultat :
```
PONG
```

Se connecter à une instance Redis de manière sécurisée à l'aide de Stunnel et de telnet

Cette section explique comment se connecter à une instance Redis pour laquelle le chiffrement en transit est activé à l'aide de Stunnel. Stunnel est un proxy qui ajoute une fonctionnalité de chiffrement TLS (Transport Layer Security) aux clients et aux serveurs sans modifier leur code. Pour en savoir plus, consultez la documentation Stunnel.

Si vous ne disposez pas d'une instance Redis pour laquelle le chiffrement en transit est activé, créez-en une. Pour en savoir plus, consultez la section Créer une instance Redis avec chiffrement en transit.
Si vous ne disposez pas d'une VM Compute Engine utilisant le même réseau autorisé que l'instance Redis de l'étape précédente, créez-en une et connectez-vous. Pour en savoir plus, consultez la section Créer une instance de VM Linux dans Compute Engine.
Installez les outils nécessaires à cette procédure en exécutant les commandes suivantes :
```
sudo apt-get install stunnel4
```
```
sudo apt-get install telnet
```
Les étapes restantes de cette procédure se déroulent dans le terminal SSH de la VM Compute Engine que vous avez créée et à laquelle vous vous êtes connecté, sauf indication contraire.
Configurez votre VM Compute Engine l'utiliser avec Stunnel :
1. Créez un fichier pour votre autorité de certification (CA) en exécutant la commande suivante :
```
sudo vim /tmp/server_ca.pem
```
2. Affichez les autorités de certification de votre instance Redis en exécutant la commande suivante dans le terminal standard que vous utilisez pour gérer vos Google Cloud ressources (et non dans le terminal Compute Engine) :
```
gcloud redis instances describe INSTANCE_ID --region=REGION
```
  Effectuez les remplacements suivants :
  - INSTANCE_ID : ID de votre instance Redis
  - REGION : région dans laquelle se trouve l'instance
  Il peut y avoir jusqu'à trois autorités de certification.
3. Copiez toutes les autorités de certification, y compris la -----BEGIN CERTIFICATE----- ligne et la
  -----END CERTIFICATE----- ligne, puis collez et enregistrez le contenu dans le server_ca.pem fichier que vous avez créé.
  
  Assurez-vous que le texte de l'autorité de certification est entièrement justifié à gauche et qu'il n'y a pas d'espace au début d'une ligne de l'autorité de certification.
4. Créez un fichier pour les informations de configuration de Stunnel en exécutant la commande suivante :
```
sudo vim /etc/stunnel/redis-client.conf
```
5. Collez le texte suivant dans le fichier, en remplaçant REDIS_INSTANCE_IP avec l'adresse IP de l'instance :
```
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. Démarrez Stunnel en exécutant la commande suivante :
```
sudo stunnel /etc/stunnel/redis-client.conf
```
7. Vérifiez que Stunnel est en cours d'exécution :
```
ps aux | grep stunnel
```
8. Redémarrez Stunnel en exécutant la commande suivante :
```
sudo systemctl restart stunnel4
```
  Vous pouvez utiliser la commande ps aux | grep stunnel avant et après le redémarrage de Stunnel pour vérifier que le redémarrage a réussi. Si l'identifiant de processus Stunnel, affiché par la commande ps aux | grep stunnel, est différent, cela signifie que Stunnel a redémarré correctement.
Pour vous connecter à votre instance Redis à l'aide de telnet, exécutez la commande suivante :
```
telnet localhost 6378
```
Dans la session telnet, testez la connexion.
1. Facultatif : Si Redis AUTH est activé sur votre instance, vous devez vous authentifier avant de tester la connexion.
  
  Exécutez la commande suivante :
```
AUTH AUTH_STRING
```
  Remplacez AUTH_STRING par la chaîne d'authentification de l'instance.
  
  Résultat :
```
OK
```
Exécutez la commande suivante :
```
PING
```
Résultat :
```
PONG
```
Facultatif : Au lieu de telnet, vous pouvez vous connecter à l'aide de redis-cli via le port Stunnel local et transmettre la chaîne AUTH.

Exécutez la commande suivante :
```
redis-cli -h 127.0.0.1 -p 6378 -a AUTH_STRING
```

Se connecter à partir d'une machine locale à l'aide du transfert de port

Pendant le développement, il peut être utile de vous connecter à votre instance Redis à partir de votre machine locale. Pour ce faire, vous devez créer une instance Compute Engine à utiliser pour le transfert de port vers l'instance Redis.

Créez une instance Compute Engine en exécutant la commande suivante :
```
gcloud compute instances create COMPUTE_VM_NAME --machine-type=f1-micro --zone=ZONE
```
Où :
- COMPUTE_VM_NAME est le nom que vous avez attribué à la VM Compute Engine.
- ZONE est la zone dans laquelle vous souhaitez provisionner la VM.
Cette commande crée une VM Compute Engine avec le f1-micro type de machine pour optimiser son coût. Vous pouvez choisir d'autres types de machines.
Ouvrez un nouveau terminal sur votre machine locale.
Pour créer un tunnel SSH qui assure le transfert de port pour le trafic via la VM Compute Engine, exécutez la commande suivante :
```
gcloud compute ssh COMPUTE_VM_NAME --zone=ZONE -- -N -L 6379:REDIS_INSTANCE_IP_ADDRESS:6379
```
Où :
- COMPUTE_VM_NAME est le nom de la VM Compute Engine.
- ZONE est la même zone que celle où se trouve la VM Compute Engine.
- REDIS_INSTANCE_IP_ADDRESS est l'adresse IP de votre instance Redis.
Pour tester la connexion, ouvrez une nouvelle fenêtre de terminal et exécutez la commande suivante :
```
redis-cli ping
```
Si tout fonctionne correctement, le résultat suivant doit s'afficher :
```
PONG
```
Vous êtes maintenant connecté à l'instance Redis et vous pouvez lui envoyer des commandes à l'aide de ce tunnel SSH ouvert. Si vous n'avez pas encore installé l'outil redis-cli, installez-le pour pouvoir exécuter cette commande.
Le tunnel SSH reste ouvert tant que la fenêtre de terminal hébergeant la connexion au tunnel SSH est opérationnelle.

Se connecter à une instance Redis à partir d'un cluster Google Kubernetes Engine

Pour vérifier si votre cluster utilise l'alias d'adresse IP, utilisez gcloud container clusters describe.

Vous pouvez vous connecter à une instance Redis à partir de clusters Google Kubernetes Engine utilisant le même réseau autorisé que votre instance Redis.

Se connecter à partir d'un pod exécutant une interface système bash

Accédez à la page GKE dans la Google Cloud console.
GKE
Cliquez sur le cluster GKE à partir duquel vous souhaitez vous connecter. Si vous ne possédez pas encore de cluster, vous devez en créer un avec les adresses IP d'alias activées. Pour savoir comment créer un cluster avec les adresses IP d'alias activées, consultez la page Créer un cluster de VPC natif.
Cliquez sur le bouton Se connecter situé à droite du nom de votre cluster, puis sur le bouton Exécuter dans Cloud Shell dans la fenêtre qui s'affiche.
Configurez l'accès à la ligne de commande kubectl en exécutant la commande suivante :
```
gcloud container clusters get-credentials CLUSTER_NAME --zone=CLUSTER_ZONE --project=PROJECT_ID
```
- CLUSTER_NAME est le nom du cluster.
- CLUSTER_ZONE est la zone dans laquelle se trouve le cluster. Elle doit également correspondre à la zone de votre instance Redis.
- PROJECT_ID est le projet dans lequel le cluster et les instances Redis se trouvent.
Le message de réussite suivant doit s'afficher : kubeconfig generated for CLUSTER_NAME
Si le cluster est de version 1.8 ou supérieure et que les alias d'adresses IP sont activés, ignorez cette étape. Si votre cluster est de version 1.7 ou inférieure, ou si les alias d'adresses IP ne sont pas activés sur votre cluster de version 1.8 ou supérieure, procédez comme suit avant d'essayer de vous connecter à l'instance :
Solution

Exécutez les commandes suivantes, en remplaçant RESERVED_IP_RANGE par la plage d'adresses IP réservée de votre instance :
```
git clone https://github.com/bowei/k8s-custom-iptables.git
```
```
cd k8s-custom-iptables/
```
```
TARGETS="RESERVED_IP_RANGE" ./install.sh
```
Si vous ne connaissez pas la plage d'adresses IP réservée de votre instance, vous pouvez le savoir en saisissant la commande suivante : gcloud redis instances describe INSTANCE_ID --region=REGION
Pour en savoir plus sur les adresses IP d'alias et sur la création de clusters avec ce paramètre activé, consultez la page Créer un cluster de VPC natif.
Utilisez la commande suivante pour vous connecter à une interface système bash :
```
kubectl run -i --tty busybox --image=busybox -- sh
```
Connectez-vous à votre instance Redis à l'aide de l'adresse hôte et du numéro de port :
```
telnet HOST-IP PORT
```
Saisissez une commande Redis de base pour vérifier la connexion :
```
PING
+PONG
```
Pour quitter la connexion telnet, appuyez sur Ctrl + C (ou sur Commande + C sur Mac). Pour quitter l'interface système bash de votre pod, renseignez la commande "return". Si vous avez terminé et n'avez plus besoin de vous connecter à Redis, exécutez la commande suivante à partir du /k8s-custom-iptables/ répertoire :
```
./uninstall.sh
```

Se connecter à une instance Redis à partir d'un pod Google Kubernetes Engine

Avant de commencer, vous avez besoin d'un cluster GKE. Si vous ne possédez pas encore de cluster, vous devez en créer un avec les adresses IP d'alias activées. Pour savoir comment créer un cluster avec les adresses IP d'alias activées, consultez la page Créer un cluster de VPC natif.

En haut à droite de la console, cliquez sur le bouton Activer Cloud Shell .
Configurez l'accès à la ligne de commande kubectl en exécutant la commande suivante :
```
gcloud container clusters get-credentials CLUSTER_NAME --zone CLUSTER_ZONE --project PROJECT_ID
```
- CLUSTER_NAME est le nom du cluster.
- CLUSTER_ZONE est la zone dans laquelle se trouve le cluster. Elle doit également correspondre à la zone de votre instance Redis.
- PROJECT_ID est le projet dans lequel le cluster et les instances Redis se trouvent.
Le message de réussite suivant doit s'afficher : kubeconfig generated for CLUSTER_NAME
Si le cluster est de version 1.8 ou supérieure et que les alias d'adresses IP sont activés, ignorez cette étape. Si votre cluster est de version 1.7 ou inférieure, ou si les alias d'adresses IP ne sont pas activés sur votre cluster de version 1.8 ou supérieure, procédez comme suit avant d'essayer de vous connecter à l'instance :
Solution

Exécutez les commandes suivantes, en remplaçant RESERVED_IP_RANGE par la plage d'adresses IP réservée de votre instance :
```
git clone https://github.com/bowei/k8s-custom-iptables.git
```
```
cd k8s-custom-iptables/
```
```
TARGETS="RESERVED_IP_RANGE" ./install.sh
```
Si vous ne connaissez pas la plage d'adresses IP réservée de votre instance, vous pouvez le savoir en saisissant la commande suivante : gcloud redis instances describe INSTANCE_ID --region [REGION]
Pour en savoir plus sur les adresses IP d'alias et sur la création de clusters avec ce paramètre activé, consultez la page Créer un cluster de VPC natif.
Utilisez la commande suivante pour démarrer un pod Redis exécutant redis-cli :
```
kubectl run -i --tty redisbox --image=redis:7.2 -- sh
```
Exécutez une commande redis-cli, en remplaçant HOST-IP par l'adresse IP hôte de votre instance Redis :
```
redis-cli -h HOST-IP info
```
Vous pouvez également exécuter une commande d'évaluation comparative Redis, en remplaçant à nouveau HOST-IP par l'adresse IP hôte de votre instance 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
```
Pour quitter le pod Redis, saisissez return. Si vous avez terminé et n'avez plus besoin de vous connecter à Redis, exécutez la commande suivante à partir du répertoire /k8s-custom-iptables/ :
```
./uninstall.sh
```

Étape suivante

Connectez-vous à l'instance Redis à l'aide d'un exemple d'application s'exécutant sur les environnements suivants :