Esta página foi traduzida pela API Cloud Translation.

Associe-se a uma instância do Redis

Esta página descreve como estabelecer ligação à sua instância do Redis através do Telnet e do redis-cli. Além disso, esta página fornece instruções sobre como estabelecer ligação quando usar funcionalidades como réplicas de leitura, AUTH e encriptação em trânsito. Por último, esta página fornece instruções sobre como estabelecer ligação a partir de um ambiente do Google Kubernetes Engine.

Para ver uma lista dos Google Cloud ambientes suportados pelo Memorystore for Redis, consulte o artigo Ambientes suportados. Alguns ambientes sem servidor suportados pelo Memorystore requerem um conetor do Acesso a VPC sem servidor. Consulte o requisito do conetor do Acesso a VPC sem servidor para mais detalhes.

Ligue-se a uma instância do Redis a partir de uma VM do Compute Engine através do telnet

Pode estabelecer ligação à instância do Redis a partir de qualquer VM do Compute Engine que use a rede autorizada da instância do Redis com um endereço IP RFC 1918 suportado.

Se ainda não tiver uma VM do Compute Engine que use a mesma rede autorizada que a sua instância do Redis, crie uma e ligue-se a ela seguindo o Início rápido com uma VM Linux.
Instale o telnet com o apt-get:
```
sudo apt-get install telnet
```
No terminal, use o telnet para aceder ao endereço IP da instância do Redis, substituindo variables pelos valores adequados.
```
telnet instance-ip-address 6379
```
Se for bem-sucedido, o comando devolve este resultado:
```
Trying instance-ip-address…
Connected to instance-ip-address
```
Na sessão do telnet, introduza alguns comandos do Redis:

Introduza:
```
PING
```
Resultado:
```
PONG
```
Enter
```
SET HELLO WORLD
```
Resultado:
```
+OK
```
Introduza:
```
GET HELLO
```
Resultado:
```
$5
WORLD
```

Estabeleça ligação a uma instância do Redis a partir de uma VM do Compute Engine através do `redis-cli`

Pode estabelecer ligação à instância do Redis a partir de qualquer VM do Compute Engine que use a rede autorizada da instância do Redis com um endereço IP RFC 1918 suportado.

Se ainda não tiver uma VM do Compute Engine que use a rede autorizada para a sua instância do Redis, crie uma e estabeleça ligação à mesma seguindo os passos descritos no artigo Crie uma instância de VM numa sub-rede específica.
Instale o 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 por valores adequados.
```
redis-cli -h redis-instance-ip-address
```
Já tem ligação à sua instância do Redis através do redis-cli.
Quando terminar de testar a ligação à instância do Redis, deve considerar eliminar a VM do Compute Engine que usou para se ligar à instância do Redis. Deste modo, evita incorrer em custos na sua conta de faturação do Google Cloud.

Associe-se a uma instância do Redis que use AUTH

Esta secção descreve como estabelecer ligação a uma instância do Redis que tenha a funcionalidade AUTH ativada.

Se ainda não tiver uma VM do Compute Engine que use a mesma rede autorizada que a sua instância do Redis, crie uma e estabeleça ligação à mesma seguindo o Início rápido com uma VM do Linux.
Instale o redis-cli na VM do Compute Engine executando o seguinte comando no terminal SSH do Compute Engine:
```
sudo apt-get install redis-tools
```
Obtenha a string AUTH da sua instância
Execute o seguinte comando para usar redis-cli para autenticar e estabelecer ligação à sua instância, substituindo variables por valores adequados:
```
redis-cli -h instance-ip-address -a auth-string
```
Ou:
```
redis-cli -h instance-ip-address
AUTH auth-string
```
Execute um comando Redis SET e GET para verificar se estabeleceu uma ligação autenticada à sua instância.
Quando terminar de testar a ligação à instância do Redis, deve considerar eliminar a VM do Compute Engine que usou para se ligar à instância do Redis. Deste modo, evita incorrer em custos na sua conta de faturação do Google Cloud.

Associe-se a uma instância do Redis através do ponto final de leitura

Se a sua instância tiver réplicas de leitura ativadas, pode estabelecer ligação ao ponto final de leitura através das seguintes instruções:

Se ainda não tiver uma VM do Compute Engine que use a mesma rede autorizada que a sua instância do Redis, crie uma e ligue-se a ela seguindo o Início rápido com uma VM Linux.
Instale o telnet com o apt-get:
```
sudo apt-get install telnet
```
Para encontrar o endereço IP do ponto final de leitura da sua instância, veja as informações da réplica de leitura da sua instância.
A partir do terminal, use o telnet para o endereço IP do ponto final de leitura da instância do Redis, substituindo variables pelos valores adequados.
```
telnet read-endpoint-ip 6379
```
Se for bem-sucedido, o comando devolve este resultado:
```
Trying read-endpoint-ip…
Connected to read-endpoint-ip
```
Na sessão do telnet, introduza alguns comandos do Redis:

Introduza:
```
PING
```
Resultado:
```
PONG
```

Ligue-se a uma instância do Redis de forma segura através do Stunnel e do telnet

Esta secção fornece um exemplo de como estabelecer ligação a uma instância do Redis que tenha a encriptação em trânsito ativada através do Stunnel.

Se ainda não tiver uma instância do Redis com a encriptação em trânsito ativada, crie uma seguindo o artigo Criar uma instância do Redis com encriptação em trânsito.
Se ainda não tiver uma VM do Compute Engine que use a mesma rede autorizada que a instância do Redis do passo anterior, crie uma e ligue-se a ela seguindo o Início rápido com uma VM Linux.
1. Instale as ferramentas necessárias para este guia executando os seguintes comandos:
```
sudo apt-get install stunnel4
```
```
sudo apt-get install telnet
```
Nota: os restantes passos neste guia ocorrem no terminal SSH da VM do Compute Engine que criou e à qual se ligou, salvo indicação em contrário.
Configure a VM do Compute Engine para utilização com o Stunnel:
1. Crie um novo ficheiro no qual colocar a sua autoridade de certificação (AC) executando o seguinte comando:
```
sudo vim /tmp/server_ca.pem
```
2. Veja as autoridades de certificação da sua instância do Redis executando o seguinte comando no terminal padrão que usa para gerir os recursos (não o terminal do Compute Engine):Google Cloud
```
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-as e guarde-as no ficheiro server_ca.pem que criou anteriormente.
  
  Nota: certifique-se de que o texto da autoridade de certificação está totalmente alinhado à esquerda. Não deve haver espaços em branco no início de nenhuma linha da CA.
4. Crie um novo ficheiro no qual 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 ficheiro, 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 está em execução:
```
ps aux | grep stunnel
```
5. Reinicie o Stunnel executando os seguintes comandos:
```
sudo systemctl restart stunnel4
```
  Nota: pode usar o comando ps aux | grep stunnel antes e depois de reiniciar o stunnel para confirmar que o reinício foi bem-sucedido. Se o ID do processo stunell, apresentado pelo comando ps aux | grep stunnel , for diferente, significa que o stunell foi reiniciado com êxito.
Para se ligar à sua instância do Redis através do Telnet, execute o seguinte comando:
```
telnet localhost 6378
```
Na sessão do Telnet, envie um ping para a instância do Redis:

Introduza:
```
PING
```
Resultado:
```
PONG
```

Ligue-se a partir de uma máquina local através do encaminhamento de portas

Pode ser útil ligar-se à sua instância do Redis a partir da sua máquina local durante o desenvolvimento. Para tal, tem de criar uma instância do Compute Engine para usar para o encaminhamento de porta 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
```
Onde:
- COMPUTE_VM_NAME é o nome que designa para a VM do Compute Engine.
- ZONE é a zona onde quer aprovisionar a VM.
Este comando cria uma VM do Compute Engine com o f1-microtipo de máquina para rentabilidade. Se quiser, pode escolher outros tipos de máquinas.
Abra um novo terminal na sua máquina local.
Para criar um túnel SSH que encaminhe o tráfego através 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
```
Onde:
- COMPUTE_VM_NAME é o nome da VM do Compute Engine.
- ZONE é a mesma zona onde a VM do Compute Engine está localizada.
- REDIS_INSTANCE_IP_ADDRESS é o endereço IP da sua instância do Redis.
Para testar a ligação, abra uma nova janela de terminal e execute o seguinte comando:
```
redis-cli ping
```
Se funcionar corretamente, o resultado deve devolver:
```
PONG
```
Agora, tem uma ligação à instância do Redis e pode enviar comandos para a instância do Redis através deste túnel SSH aberto. Se ainda não instalou o redis-cli, instale-o para poder executar este comando.
O túnel SSH permanece aberto enquanto mantiver a janela do terminal com a ligação do túnel SSH em funcionamento.

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

Pode estabelecer ligação à sua instância do Redis a partir de clusters do Google Kubernetes Engine que usam a mesma rede autorizada que a sua instância do Redis.

Ligue-se a partir de um pod que execute um shell bash

Aceda à página do GKE na Google Cloud consola.
GKE
Clique no cluster do GKE a partir do qual quer estabelecer ligação. Se ainda não tiver um cluster, crie um com os alias de IP ativados. Para ver instruções sobre como criar um cluster com alias de IP ativados, consulte o artigo Criar um cluster nativo da VPC.
Clique no botão Ligar à direita do nome do cluster e, de seguida, clique no botão Executar no Cloud Shell na janela apresentada.
Configure o acesso à linha de comandos kubectl executando o seguinte comando:
```
gcloud container clusters get-credentials CLUSTER_NAME --zone=CLUSTER_ZONE --project=PROJECT_ID
```
- CLUSTER_NAME é o nome do seu cluster.
- CLUSTER_ZONE é a zona em que o cluster se encontra. Também tem de ser a zona em que a sua instância do Redis se encontra.
- PROJECT_ID é o projeto onde existem o cluster e as instâncias do Redis.
Deverá receber a mensagem de sucesso: kubeconfig generated for CLUSTER_NAME
Se o cluster tiver a versão 1.8 ou superior e tiver aliases de IP ativados, ignore este passo. Se o cluster for da versão 1.7 ou inferior, ou o cluster da versão 1.8 ou superior não tiver aliases de IP ativados, siga estes passos de solução alternativa antes de tentar estabelecer ligação à instância:
Alternativa

Execute estes três comandos, substituindo RESERVED_IP_RANGE pelo intervalo de IP reservado da sua instância:
```
git clone https://github.com/bowei/k8s-custom-iptables.git
```
```
cd k8s-custom-iptables/
```
```
TARGETS="RESERVED_IP_RANGE" ./install.sh
```
Se não souber o intervalo de IPs reservados da sua instância, pode descobri-lo introduzindo este comando: gcloud redis instances describe INSTANCE_ID --region=REGION
Para mais informações sobre os alias de IP, incluindo como criar um cluster com esta definição ativada, consulte o artigo Criar um cluster nativo da VPC.
Use o seguinte comando para estabelecer ligação a uma shell bash:
```
kubectl run -i --tty busybox --image=busybox -- sh
```
Use o Telnet na sua instância do Redis com o endereço do anfitrião e o número da porta:
```
telnet HOST-IP PORT
```
Introduza um comando Redis básico para validar a ligação:
```
PING
+PONG
```
Para fechar a ligação telnet, prima Control+C (ou Command+C no Mac). Para sair da shell bash no seu pod, introduza return. Se terminar e já não precisar de estabelecer ligação ao Redis, execute o seguinte comando a partir do diretório /k8s-custom-iptables/:
```
./uninstall.sh
```

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

Antes de começar, precisa de um cluster do GKE. Se ainda não tiver um cluster, crie um com os alias de IP ativados. Para ver instruções sobre como criar um cluster com aliases de IP ativados, consulte o artigo Criar um cluster nativo da VPC.

No canto superior direito da consola, clique no botão Ativar Cloud Shell .
Configure o acesso à linha de comandos kubectl executando o seguinte comando:
```
gcloud container clusters get-credentials CLUSTER_NAME --zone CLUSTER_ZONE --project PROJECT_ID
```
- CLUSTER_NAME é o nome do seu cluster.
- CLUSTER_ZONE é a zona em que o cluster se encontra. Também tem de ser a zona em que a sua instância do Redis se encontra.
- PROJECT_ID é o projeto onde existem o cluster e as instâncias do Redis.
Deverá receber a mensagem de sucesso: kubeconfig generated for CLUSTER_NAME
Se o cluster tiver a versão 1.8 ou superior e tiver aliases de IP ativados, ignore este passo. Se o cluster for da versão 1.7 ou inferior, ou o cluster da versão 1.8 ou superior não tiver aliases de IP ativados, siga estes passos de solução alternativa antes de tentar estabelecer ligação à instância:
Alternativa

Execute estes três comandos, substituindo RESERVED_IP_RANGE pelo intervalo de IP reservado da sua instância:
```
git clone https://github.com/bowei/k8s-custom-iptables.git
```
```
cd k8s-custom-iptables/
```
```
TARGETS="RESERVED_IP_RANGE" ./install.sh
```
Se não souber o intervalo de IPs reservados da sua instância, pode descobri-lo introduzindo este comando: gcloud redis instances describe INSTANCE_ID --region [REGION]
Para mais informações sobre os alias de IP, incluindo como criar um cluster com esta definição ativada, consulte o artigo Criar um cluster nativo da VPC.

Use o seguinte comando para iniciar um pod do Redis que execute o 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 anfitrião da sua instância do Redis:
```
redis-cli -h HOST-IP info
```
Opcionalmente, execute um comando Redis benchmark, substituindo novamente HOST-IP pelo endereço IP do anfitrião da sua 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 Redis, introduza return. Se terminou e já não precisa de estabelecer ligação ao Redis, execute o seguinte comando a partir do diretório /k8s-custom-iptables/:
```
./uninstall.sh
```

O que se segue?

Associe-se à sua instância do Redis através de uma aplicação de exemplo executada em: