O Google usa tecnologia de IA na tradução de conteúdos para seu idioma de preferência. As traduções com IA podem ter erros.

Conectar-se a uma instância do Redis

Nesta página, descrevemos como se conectar à instância do Redis usando o Telnet e o redis-cli. Além disso, esta página fornece instruções sobre como se conectar ao usar recursos como réplicas de leitura, AUTH e criptografia em trânsito. Por fim, esta página fornece instruções sobre como se conectar a partir de um ambiente do Google Kubernetes Engine.

Para uma lista de Google Cloud ambientes compatíveis com o Memorystore para Redis, consulte Ambientes compatíveis. Alguns ambientes sem servidor compatíveis com o Memorystore exigem um conector de acesso VPC sem servidor. Consulte Requisito do conector de acesso VPC sem servidor para mais detalhes.

Conectar-se a uma instância do Redis a partir de uma VM do Compute Engine usando o telnet

É possível se conectar à instância do Memorystore para Redis de qualquer VM do Compute Engine que use a rede autorizada da instância com um endereço IP RFC 1918 compatível.

Se você não tiver uma VM do Compute Engine que use a mesma rede autorizada que a instância, crie uma e conecte-se à VM usando SSH. Para fazer isso, siga as etapas em Criar uma instância de VM do Linux no Compute Engine.
Use apt-get para instalar telnet:
```
sudo apt-get install telnet
```
No terminal, use o telnet para o endereço IP da instância. Substitua VARIABLES pelos valores apropriados.
```
telnet INSTANCE_IP_ADDRESS 6379
```
Se você puder se conectar à instância, o comando retornará este resultado:
```
Trying INSTANCE_IP_ADDRESS…
Connected to INSTANCE_IP_ADDRESS
```
Na sessão telnet, digite alguns comandos do Redis:

Insira:
```
PING
```
Result:
```
PONG
```
Enter
```
SET HELLO WORLD
```
Result:
```
+OK
```
Insira o seguinte:
```
GET HELLO
```
Resultado:
```
$5
WORLD
```

Conectar-se a uma instância do Redis a partir de uma VM do Compute Engine usando `redis-cli`

É possível se conectar à instância do Redis de qualquer VM do Compute Engine que use a rede autorizada da instância do Redis usando um endereço IP RFC 1918 compatível.

Se você ainda não tem uma VM do Compute Engine que use a rede autorizada para a instância do Redis, crie uma e conecte-se a ela seguindo Criar uma instância de VM em uma sub-rede específica.
Instale redis-cli na VM do Compute Engine executando o seguinte comando no terminal SSH do Compute Engine:
```
sudo apt-get install redis-tools
```
Execute o seguinte comando no terminal do Compute Engine, substituindo variables pelos valores apropriados.
```
redis-cli -h redis-instance-ip-address
```
Agora você está conectado à instância do Redis usando redis-cli.
Após concluir o teste de conexão com a instância do Redis, exclua a VM do Compute Engine usada para se conectar à instância do Redis. Isso ajuda a evitar cobranças na sua conta do Cloud Billing.

Conectar-se a uma instância do Redis que usa AUTH

Nesta seção, descrevemos como se conectar a uma instância do Redis que tem o AUTH recurso ativado.

Se você ainda não tem uma VM do Compute Engine que use a mesma rede autorizada da instância do Redis, crie uma e conecte-se a ela seguindo o Guia de início rápido sobre como usar uma VM do Linux.
Instale redis-cli na VM do Compute Engine executando o seguinte comando no terminal SSH do Compute Engine:
```
sudo apt-get install redis-tools
```
Consiga a string AUTH de sua instância
Execute o seguinte comando e use redis-cli para autenticar e se conectar à instância, substituindo variables pelos valores apropriados:
```
redis-cli -h instance-ip-address -a auth-string
```
Ou:
```
redis-cli -h instance-ip-address
AUTH auth-string
```
Execute os comandos SET e GET do Redis para verificar se você estabeleceu uma conexão autenticada com a instância.
Após concluir o teste de conexão com a instância do Redis, exclua a VM do Compute Engine usada para se conectar à instância do Redis. Isso ajuda a evitar cobranças na sua conta do Cloud Billing.

Conectar-se a uma instância do Redis usando o endpoint de leitura

Se a instância tiver réplicas de leitura ativadas, será possível se conectar ao endpoint de leitura usando as seguintes instruções:

Se você ainda não tem uma VM do Compute Engine que usa a mesma rede autorizada que sua instância do Redis, crie uma e conecte-se a ela seguindo o Guia de início rápido sobre como usar uma VM do Linux.
Instale telnet usando apt-get:
```
sudo apt-get install telnet
```
Para encontrar o endereço IP do endpoint de leitura da instância, consulte as informações da réplica de leitura da instância.
Do terminal, o telnet para o endereço IP do endpoint de leitura da instância do Redis, substituindo variables pelos valores apropriados.
```
telnet read-endpoint-ip 6379
```
Se for bem-sucedido, o comando retornará este resultado:
```
Trying read-endpoint-ip…
Connected to read-endpoint-ip
```
Na sessão telnet, digite alguns comandos do Redis:

Insira:
```
PING
```
Resultado:
```
PONG
```

Conectar-se a uma instância do Redis com segurança usando o stunnel e o telnet

Esta seção fornece um exemplo de como se conectar a uma instância do Redis que tem a criptografia em trânsito ativada usando o stunnel. O stunnel é um proxy que adiciona a funcionalidade de criptografia Transport Layer Security (TLS) a clientes e servidores sem mudar o código deles. Para mais informações, consulte a documentação do Stunnel.

Se você não tiver uma instância do Redis com a criptografia em trânsito ativada, crie uma. Para mais informações, consulte Criar uma instância do Redis com criptografia em trânsito.
Se você não tiver uma VM do Compute Engine que use a mesma rede autorizada que a instância do Redis da etapa anterior, crie uma e conecte-se a ela. Para mais informações, consulte Criar uma instância de VM do Linux no Compute Engine.
Instale as ferramentas necessárias para esse procedimento executando os seguintes comandos:
```
sudo apt-get install stunnel4
```
```
sudo apt-get install telnet
```
As etapas restantes neste procedimento ocorrem no terminal SSH da VM do Compute Engine que você criou e se conectou, a menos que especificado de outra forma.
Configure a VM do Compute Engine para uso com o stunnel:
1. Crie um arquivo para sua autoridade de certificação (AC) executando o seguinte comando:
```
sudo vim /tmp/server_ca.pem
```
2. Consulte as ACs da instância do Redis executando o seguinte comando no terminal padrão que você usa para gerenciar seus Google Cloud recursos (não o terminal do Compute Engine):
```
gcloud redis instances describe INSTANCE_ID --region=REGION
```
  Faça as seguintes substituições:
  - INSTANCE_ID: o ID da sua instância do Redis
  - REGION: a região em que a instância está localizada
  Pode haver até três ACs.
3. Copie todas as ACs, incluindo a linha -----BEGIN CERTIFICATE----- e a
  -----END CERTIFICATE-----, cole e salve o conteúdo no arquivo server_ca.pem que você criou.
  
  Verifique se o texto da AC está totalmente justificado à esquerda e se não há espaço em branco à esquerda em nenhuma linha da AC.
4. Crie um arquivo para as informações de configuração do stunnel executando o seguinte comando:
```
sudo vim /etc/stunnel/redis-client.conf
```
5. Cole o texto a seguir no arquivo, substituindo REDIS_INSTANCE_IP pelo endereço IP da instância:
```
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. Inicie o stunnel executando o seguinte comando:
```
sudo stunnel /etc/stunnel/redis-client.conf
```
7. Verifique se o stunnel está em execução:
```
ps aux | grep stunnel
```
8. Reinicie o stunnel executando o seguinte comando:
```
sudo systemctl restart stunnel4
```
  Você pode usar o comando ps aux | grep stunnel antes e depois de reiniciar o stunnel para confirmar se a reinicialização foi bem-sucedida. Se o ID de processo do stunnel, mostrado pelo comando ps aux | grep stunnel, for diferente, o stunnel será reiniciado.
Para se conectar à instância do Redis usando o telnet, execute o seguinte comando:
```
telnet localhost 6378
```
Na sessão telnet, teste a conexão.
1. Opcional: se a instância tiver o AUTH do Redis ativado, você precisará se autenticar antes de testar a conexão.
  
  Execute este comando:
```
AUTH AUTH_STRING
```
  Substitua AUTH_STRING pela string de autenticação da instância.
  
  Resultado:
```
OK
```
Execute este comando:
```
PING
```
Resultado:
```
PONG
```
Opcional: como alternativa ao telnet, você pode se conectar usando redis-cli pela porta stunnel local e transmitir a string AUTH.

Execute este comando:
```
redis-cli -h 127.0.0.1 -p 6378 -a AUTH_STRING
```

Conectar-se de uma máquina local usando o encaminhamento de portas

Pode ser útil se conectar à instância do Redis da máquina local durante o desenvolvimento. Para fazer isso, você precisa criar uma instância do Compute Engine para usar no encaminhamento de portas para a instância do Redis.

Crie uma instância do Compute Engine executando o seguinte comando:
```
gcloud compute instances create COMPUTE_VM_NAME --machine-type=f1-micro --zone=ZONE
```
Em que:
- COMPUTE_VM_NAME é o nome que você designa para a VM do Compute Engine.
- ZONE é a zona em que você quer provisionar a VM.
Esse comando cria uma VM do Compute Engine com o f1-micro tipo de máquina para economia. Você pode escolher outros tipos de máquinas.
Abra um novo terminal na máquina local.
Para criar um túnel SSH que encaminha o tráfego por meio do encaminhamento de portas pela VM do Compute Engine, execute o seguinte comando:
```
gcloud compute ssh COMPUTE_VM_NAME --zone=ZONE -- -N -L 6379:REDIS_INSTANCE_IP_ADDRESS:6379
```
Em que:
- COMPUTE_VM_NAME é o nome da VM do Compute Engine.
- ZONE é a mesma zona em que a VM do Compute Engine está localizada.
- REDIS_INSTANCE_IP_ADDRESS é o endereço IP da instância do Redis.
Para testar a conexão, abra uma nova janela do terminal e execute o seguinte comando:
```
redis-cli ping
```
Se estiver funcionando corretamente, o resultado retornará:
```
PONG
```
Agora você está conectado à instância do Redis e pode enviar comandos para a instância usando esse túnel SSH aberto. Se você ainda não instalou o redis-cli, instale-o para executar este comando.
O túnel SSH permanece aberto enquanto você mantém a janela do terminal com a conexão do túnel SSH em funcionamento.

Conectar-se a uma instância do Redis a partir de um cluster do Google Kubernetes Engine

Para verificar se o cluster usa o aliasing de IP, use gcloud container clusters describe.

É possível se conectar à sua instância do Redis a partir de clusters do Google Kubernetes Engine que usam a mesma rede autorizada que a instância do Redis.

Conectar-se de um pod que executa um shell bash

Acesse a página do GKE no Google Cloud console.
GKE
Clique no cluster do GKE a que você quer se conectar. Se você ainda não tem um cluster, crie um com aliases de IP ativados. Para instruções sobre como criar um cluster com aliases de IP ativados, consulte Como criar um cluster nativo de VPC.
Clique no botão Conectar, à direita do nome do cluster e, em seguida, clique no botão Executar no Cloud Shell, na janela que aparece.
Configure o acesso à linha de comando kubectl executando o comando a seguir:
```
gcloud container clusters get-credentials CLUSTER_NAME --zone=CLUSTER_ZONE --project=PROJECT_ID
```
- CLUSTER_NAME é o nome do cluster;
- CLUSTER_ZONE é a zona em que o cluster está. É preciso que seja também a zona em que está a instância do Redis.
- PROJECT_ID é o projeto em que estão o cluster e as instâncias do Redis.
Você vai receber a mensagem de sucesso: kubeconfig generated for CLUSTER_NAME
Se a versão do seu cluster for 1.8 ou superior e tiver aliases de IP ativados, pule esta etapa. Se a versão do seu cluster for 1.7 ou inferior, ou se o cluster da versão 1.8 ou superior não tiver aliases de IP ativados, siga estas etapas de solução alternativa, antes de tentar se conectar à sua instância:
Alternativa

Execute os comandos a seguir, substituindo RESERVED_IP_RANGE pelo intervalo de IP reservado da instância:
```
git clone https://github.com/bowei/k8s-custom-iptables.git
```
```
cd k8s-custom-iptables/
```
```
TARGETS="RESERVED_IP_RANGE" ./install.sh
```
Se você não souber o intervalo de IP reservado da instância, descubra-o inserindo este comando: gcloud redis instances describe INSTANCE_ID --region=REGION
Para mais informações sobre aliases de IP, incluindo como criar um cluster com essa configuração ativada, consulte Como criar um cluster nativo de VPC.
Use o seguinte comando para se conectar a um shell bash:
```
kubectl run -i --tty busybox --image=busybox -- sh
```
Use o Telnet para a instância do Redis usando o endereço do host e o número da porta:
```
telnet HOST-IP PORT
```
Digite um comando básico do Redis para verificar a conexão:
```
PING
+PONG
```
Para fechar a conexão telnet, pressione Control+C (ou Command+C no Mac). Para sair do shell bash no seu pod, insira "return". Se você tiver terminado e não precisar mais se conectar ao Redis, execute o seguinte comando no /k8s-custom-iptables/ diretório:
```
./uninstall.sh
```

Conectar-se a uma instância do Redis a partir de um pod do Google Kubernetes Engine

Antes de começar, é preciso ter um cluster do GKE. Se você ainda não tem um cluster, crie um com aliases de IP ativados. Para instruções sobre como criar um cluster com aliases de IP ativados, consulte Como criar um cluster nativo de VPC.

No canto superior direito do console, clique no botão Ativar o Cloud Shell .
Configure o acesso à linha de comando kubectl executando o comando a seguir:
```
gcloud container clusters get-credentials CLUSTER_NAME --zone CLUSTER_ZONE --project PROJECT_ID
```
- CLUSTER_NAME é o nome do cluster;
- CLUSTER_ZONE é a zona em que o cluster está. É preciso que seja também a zona em que está a instância do Redis.
- PROJECT_ID é o projeto em que estão o cluster e as instâncias do Redis.
Você vai receber a mensagem de sucesso: kubeconfig generated for CLUSTER_NAME
Se a versão do seu cluster for 1.8 ou superior e tiver aliases de IP ativados, pule esta etapa. Se a versão do seu cluster for 1.7 ou inferior, ou se o cluster da versão 1.8 ou superior não tiver aliases de IP ativados, siga estas etapas de solução alternativa, antes de tentar se conectar à sua instância:
Alternativa

Execute os comandos a seguir, substituindo RESERVED_IP_RANGE pelo intervalo de IP reservado da instância:
```
git clone https://github.com/bowei/k8s-custom-iptables.git
```
```
cd k8s-custom-iptables/
```
```
TARGETS="RESERVED_IP_RANGE" ./install.sh
```
Se você não souber o intervalo de IP reservado da instância, descubra-o inserindo este comando: gcloud redis instances describe INSTANCE_ID --region [REGION]
Para mais informações sobre aliases de IP, incluindo como criar um cluster com essa configuração ativada, consulte Como criar um cluster nativo de VPC.
Use o comando a seguir para iniciar um pod do Redis que executa o redis-cli:
```
kubectl run -i --tty redisbox --image=redis:7.2 -- sh
```
Execute um comando redis-cli, substituindo HOST-IP pelo endereço IP do host da instância do Redis:
```
redis-cli -h HOST-IP info
```

Opcionalmente, execute um comando de benchmark do Redis, substituindo HOST-IP pelo endereço IP do host da instância do 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 sair do pod do Redis, digite return. Se você tiver terminado e não precisar mais se conectar ao Redis, execute o seguinte comando no diretório /k8s-custom-iptables/:
```
./uninstall.sh
```

A seguir

Conecte-se à sua instância do Redis usando um aplicativo de amostra, que é executado em: