Esta página foi traduzida pela API Cloud Translation.

Como se conectar a uma instância do Redis

Esta página descreve como se conectar à instância do Redis usando Telnet e redis-cli. Além disso, nesta página você verá instruções sobre como se conectar ao usar recursos como réplicas de leitura, AUTH e criptografia em trânsito. Por fim, nesta página, fornecemos instruções sobre como se conectar em um ambiente do Google Kubernetes Engine.

Para uma lista dos ambientes do Google Cloud 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 Requisitos do conector de acesso VPC sem servidor para mais detalhes.

Como se conectar a uma instância do Redis a partir de uma VM do Compute Engine usando telnet

É 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 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
```
A partir do terminal, use o telnet para acessar o endereço IP da instância do Redis, substituindo variables pelos valores apropriados.
```
telnet instance-ip-address 6379
```
Se for bem-sucedido, 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
```
Result:
```
$5
WORLD
```

Como se conectar 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 usa a rede autorizada para 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 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.

Como se conectar a uma instância do Redis que usa o AUTH

Nesta seção, descrevemos como se conectar a uma instância do Redis que tem o recurso AUTH 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.

Como se conectar 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
```
Encontre o endereço IP do endpoint de leitura da sua instância em Como ver as informações de 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
```
Result:
```
PONG
```

Como se conectar a uma instância do Redis com segurança usando stunnel e telnet

Nesta seção, você verá um exemplo de como se conectar a uma instância do Redis com criptografia em trânsito ativada usando o stunnel.

Se você ainda não tem uma instância do Redis com a criptografia em trânsito ativada, siga estas etapas para Criar uma instância do Redis com criptografia em trânsito.
Se você ainda não tem uma VM do Compute Engine que use a mesma rede autorizada da instância anterior do Redis, crie uma e conecte-se a ela seguindo o Guia de início rápido sobre como usar uma VM do Linux.
1. Instale as ferramentas necessárias para este guia executando os seguintes comandos:
```
sudo apt-get install stunnel4
```
```
sudo apt-get install telnet
```
Observação: As etapas restantes neste guia 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 novo arquivo para colocar a Autoridade de certificação (CA, na sigla em inglês) executando o seguinte comando:
```
sudo vim /tmp/server_ca.pem
```
2. Visualize as autoridades de certificação da instância do Redis executando o seguinte comando no terminal padrão que você usa para gerenciar os recursos do Google Cloud, e não o terminal do Compute Engine:
```
gcloud redis instances describe instance-id --region=region
```
  Pode haver até três CAs.
3. Copie todas as autoridades de certificação visíveis, incluindo a linha -----BEGIN CERTIFICATE----- e as linhas -----END CERTIFICATE-----, e cole e salve o arquivo server_ca.pem criado anteriormente.
  
  Observação: certifique-se de que o texto da autoridade de certificação esteja totalmente justificado. Não deve haver espaços em branco na linha da CA.
4. Faça o seguinte comando para colocar as informações de configuração do stunnel executando o seguinte comando:
```
sudo vim /etc/stunnel/redis-client.conf
```
  Cole o seguinte texto no arquivo, substituindo redis-instance-ip pelo endereço IP da instância do 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
```
  Inicie o stunnel executando o seguinte comando:
```
sudo stunnel /etc/stunnel/redis-client.conf
```
  Verifique se o stunnel é executado:
```
ps aux | grep stunnel
```
5. Reinicie o stunnel executando os seguintes comandos:
```
sudo systemctl restart stunnel4
```
  Observação: use o comando ps aux | grep stunnel antes e depois de reiniciar o stunnel para confirmar se o processo foi concluído. Se o ID do processo do stunell, mostrado pelo comando ps aux | grep stunnel, for diferente, você saberá que ele foi reiniciado com sucesso.
Para se conectar à instância do Redis usando o Telnet, execute o seguinte comando:
```
telnet localhost 6378
```
Na sessão Telnet, dê um ping na instância do Redis:

Insira:
```
PING
```
Result:
```
PONG
```

Como se conectar de uma máquina local com 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 comando a seguir:
```
gcloud compute instances create NAME --machine-type=f1-micro --zone=ZONE
```
Em que:
- 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 tipo de máquina f1-micro para economia. É possível escolher outros tipos de máquina, se quiser.
Abra um novo terminal na máquina local.
Para criar um túnel SSH que encaminha o tráfego usando da 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 de 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.

Como se conectar a uma instância do Redis a partir de um cluster do Google Kubernetes Engine

É 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.

Como se conectar a partir de um pod, executando um shell bash

Acesse a página do GKE no Console do Google Cloud.
GKE
Clique no cluster do GKE em que você gostaria de se conectar. Se você ainda não tiver 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ê verá 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 estes três comandos, substituindo RESERVED_IP_RANGE pelo intervalo de IPs reservados 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 diretório /k8s-custom-iptables/:
```
./uninstall.sh
```

Como se conectar 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 Google 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ê verá 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 estes três comandos, substituindo RESERVED_IP_RANGE pelo intervalo de IPs reservados 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 iniciar um pod do Redis executando redis-cli:

kubectl run -i --tty redisbox --image=gcr.io/google_containers/redis:v1 -- 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
```
Outra opção é executar um comando Redis benchmark, substituindo HOST-IP novamente 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: