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

Remarque : Pour vous connecter à une instance Redis qui utilise le mode de connexion d'accès aux services privés, vous devez activer l'alias VPC natif/IP sur votre cluster GKE. Pour utiliser GKE afin de vous connecter à une instance Redis qui utilise le mode de connexion d'appairage direct, utilisez la solution de contournement de l'étape 3 de la section Préparer votre cluster GKE.

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

Vous ne pouvez vous connecter à votre instance Redis qu'à partir de clusters Google Kubernetes Engine qui utilisent le même réseau autorisé que l'instance Redis.

Configuration

Si vous avez déjà installé Google Cloud CLI et créé une instance Redis, vous pouvez ignorer ces étapes.

1. Installez la gcloud CLI et initialisez-la :

   gcloud init
   

2. Suivez le Guide de démarrage rapide pour créer une instance Redis. Retenez la zone, l'adresse IP et le port de l'instance Redis.

Préparer le cluster GKE

1. Si vous n'avez pas créé de cluster GKE, créez-en un à l'aide des commandes suivantes pour Google Cloud CLI :

   1. Désignez le projet pour cet exemple d'application dans gcloud.

      gcloud config set project PROJECT_ID

   2. Définissez la variable de configuration de la zone Compute Engine dans gcloud.

      gcloud config set compute/zone ZONE

   3. Créer un cluster GKE nommé visitcount-cluster.

      gcloud container clusters create visitcount-cluster --num-nodes=3 --enable-ip-alias

2. Si vous n'avez pas créé le cluster à l'aide de gcloud, utilisez la commande suivante pour récupérer les identifiants du cluster :

   gcloud container clusters get-credentials CLUSTER_NAME --zone CLUSTER_ZONE --project PROJECT_ID

   1. CLUSTER_NAME est le nom de votre cluster GKE.
   2. CLUSTER_ZONE est la zone dans laquelle se trouve votre cluster.
   3. PROJECT_ID est le projet dans lequel votre cluster et vos instances Redis se trouvent.

3. Si votre cluster est de version 1.8 ou supérieure et que les alias d'adresses IP sont activés, ignorez cette étape. Si le 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 ultérieure, procédez comme suit avant d'essayer de vous connecter à l'instance :

   1. Exécutez les commandes suivantes, en remplaçant RESERVED_IP_RANGE par la plage d'adresses IP réservées de votre instance :

      git clone https://github.com/bowei/k8s-custom-iptables.git
      cd k8s-custom-iptables/
      TARGETS="RESERVED_IP_RANGE" ./install.sh
      cd ..
      

   2. Si vous ne connaissez pas la plage d'adresses IP réservées de votre instance, obtenez cette information à l'aide de la console (options avancées) ou de la commande suivante :

      gcloud redis instances describe INSTANCE_ID --region=REGION
      

   Pour en savoir plus sur les alias d'adresses IP et sur la création de clusters avec ce paramètre activé, consultez la documentation relative aux alias d'adresses IP.

Exemple d'application

Cet exemple d'application de serveur HTTP établit une connexion à une instance Redis à partir d'un cluster Google Kubernetes Engine.

Clonez le dépôt correspondant au langage de programmation de votre choix et accédez au dossier contenant l'exemple de code :

Go

git clone https://github.com/GoogleCloudPlatform/golang-samples
cd golang-samples/memorystore/redis

Java

git clone https://github.com/GoogleCloudPlatform/java-docs-samples
cd java-docs-samples/memorystore/redis

Node.js

git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples
cd nodejs-docs-samples/memorystore/redis

Python

git clone https://github.com/GoogleCloudPlatform/python-docs-samples
cd python-docs-samples/memorystore/redis

Cet exemple de code incrémente un compteur Redis à chaque accès au point de terminaison /.

Go

Cette application utilise le client github.com/gomodule/redigo/redis. Installez-le en exécutant la commande suivante :

go get github.com/gomodule/redigo/redis@latest

Exemple d'application :

// Command redis is a basic app that connects to a managed Redis instance.
package main

import (
	"fmt"
	"log"
	"net/http"
	"os"

	"github.com/gomodule/redigo/redis"
)

var redisPool *redis.Pool

func incrementHandler(w http.ResponseWriter, r *http.Request) {
	conn := redisPool.Get()
	defer conn.Close()

	counter, err := redis.Int(conn.Do("INCR", "visits"))
	if err != nil {
		http.Error(w, "Error incrementing visitor counter", http.StatusInternalServerError)
		return
	}
	fmt.Fprintf(w, "Visitor number: %d", counter)
}

func main() {
	redisHost := os.Getenv("REDISHOST")
	redisPort := os.Getenv("REDISPORT")
	redisAddr := fmt.Sprintf("%s:%s", redisHost, redisPort)

	const maxConnections = 10
	redisPool = &redis.Pool{
		MaxIdle: maxConnections,
		Dial:    func() (redis.Conn, error) { return redis.Dial("tcp", redisAddr) },
	}

	http.HandleFunc("/", incrementHandler)

	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}
	log.Printf("Listening on port %s", port)
	if err := http.ListenAndServe(":"+port, nil); err != nil {
		log.Fatal(err)
	}
}

Java

Cette application est basée sur un servlet Jetty 3.1.

Il utilise la bibliothèque Jedis :

<dependency>
  <groupId>redis.clients</groupId>
  <artifactId>jedis</artifactId>
  <version>5.1.0</version>
</dependency>

La classe AppServletContextListener permet de créer un pool de connexions Redis longue durée :

package com.example.redis;

import java.io.IOException;
import java.util.Properties;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

@WebListener
public class AppServletContextListener implements ServletContextListener {

  private Properties config = new Properties();

  private JedisPool createJedisPool() throws IOException {
    String host;
    Integer port;
    config.load(
        Thread.currentThread()
            .getContextClassLoader()
            .getResourceAsStream("application.properties"));
    host = config.getProperty("redis.host");
    port = Integer.valueOf(config.getProperty("redis.port", "6379"));

    JedisPoolConfig poolConfig = new JedisPoolConfig();
    // Default : 8, consider how many concurrent connections into Redis you will need under load
    poolConfig.setMaxTotal(128);

    return new JedisPool(poolConfig, host, port);
  }

  @Override
  public void contextDestroyed(ServletContextEvent event) {
    JedisPool jedisPool = (JedisPool) event.getServletContext().getAttribute("jedisPool");
    if (jedisPool != null) {
      jedisPool.destroy();
      event.getServletContext().setAttribute("jedisPool", null);
    }
  }

  // Run this before web application is started
  @Override
  public void contextInitialized(ServletContextEvent event) {
    JedisPool jedisPool = (JedisPool) event.getServletContext().getAttribute("jedisPool");
    if (jedisPool == null) {
      try {
        jedisPool = createJedisPool();
        event.getServletContext().setAttribute("jedisPool", jedisPool);
      } catch (IOException e) {
        // handle exception
      }
    }
  }
}

La classe VisitCounterServlet est un servlet Web qui incrémente un compteur Redis :

package com.example.redis;

import java.io.IOException;
import java.net.SocketException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

@WebServlet(name = "Track visits", value = "")
public class VisitCounterServlet extends HttpServlet {

  @Override
  public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
    try {
      JedisPool jedisPool = (JedisPool) req.getServletContext().getAttribute("jedisPool");

      if (jedisPool == null) {
        throw new SocketException("Error connecting to Jedis pool");
      }
      Long visits;

      try (Jedis jedis = jedisPool.getResource()) {
        visits = jedis.incr("visits");
      }

      resp.setStatus(HttpServletResponse.SC_OK);
      resp.getWriter().println("Visitor counter: " + String.valueOf(visits));
    } catch (Exception e) {
      resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage());
    }
  }
}

Node.js

Cette application utilise le module redis.

{
  "name": "memorystore-redis",
  "description": "An example of using Memorystore(Redis) with Node.js",
  "version": "0.0.1",
  "private": true,
  "license": "Apache Version 2.0",
  "author": "Google Inc.",
  "engines": {
    "node": ">=16.0.0"
  },
  "dependencies": {
    "redis": "^4.0.0"
  }
}

'use strict';
const http = require('http');
const redis = require('redis');

const REDISHOST = process.env.REDISHOST || 'localhost';
const REDISPORT = process.env.REDISPORT || 6379;

const client = redis.createClient(REDISPORT, REDISHOST);
client.on('error', err => console.error('ERR:REDIS:', err));

// create a server
http
  .createServer((req, res) => {
    // increment the visit counter
    client.incr('visits', (err, reply) => {
      if (err) {
        console.log(err);
        res.status(500).send(err.message);
        return;
      }
      res.writeHead(200, {'Content-Type': 'text/plain'});
      res.end(`Visitor number: ${reply}\n`);
    });
  })
  .listen(8080);

Python

Cette application utilise Flask pour la diffusion Web et le package redis-py pour communiquer avec l'instance Redis.

Flask==3.0.3
gunicorn==23.0.0
redis==6.0.0
Werkzeug==3.0.3

import logging
import os

from flask import Flask
import redis

app = Flask(__name__)

redis_host = os.environ.get("REDISHOST", "localhost")
redis_port = int(os.environ.get("REDISPORT", 6379))
redis_client = redis.StrictRedis(host=redis_host, port=redis_port)


@app.route("/")
def index():
    value = redis_client.incr("counter", 1)
    return f"Visitor number: {value}"


@app.errorhandler(500)
def server_error(e):
    logging.exception("An error occurred during a request.")
    return (
        """
    An internal error occurred: <pre>{}</pre>
    See logs for full stacktrace.
    """.format(
            e
        ),
        500,
    )


if __name__ == "__main__":
    # This is used when running locally. Gunicorn is used to run the
    # application on Google App Engine and Cloud Run.
    # See entrypoint in app.yaml or Dockerfile.
    app.run(host="127.0.0.1", port=8080, debug=True)

Créer l'image du conteneur

Créez et transférez l'image du conteneur vers Container Registry de la manière suivante :

    gcloud artifacts repositories create --location REPO_REGION --repository-format=docker REPO_ID
    cp gke_deployment/Dockerfile .
    docker build -t REPO_REGION-docker.pkg.dev/PROJECT_ID/REPO_ID/visit-counter:v1 .
    gcloud docker -- push REPO_REGION-docker.pkg.dev/PROJECT_ID/REPO_ID/visit-counter:v1

Déployer votre application sur Google Kubernetes Engine

Pour éviter de coder en dur l'adresse IP de l'instance Redis, vous pouvez créer un ConfigMap redishost :

    export REDISHOST_IP=REDISHOST_IP
    kubectl create configmap redishost --from-literal=REDISHOST=${REDISHOST_IP}

Vérifiez la configuration à l'aide de la commande suivante :

kubectl get configmaps redishost -o yaml

Mettez à jour gke_deployment/visit-counter.yaml en remplaçant <REPO_REGION>, <PROJECT_ID> et <REPO_ID> par les valeurs de votre image de conteneur créée dans Créer l'image de conteneur. Ce fichier contient la configuration du déploiement et du service.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: visit-counter
  labels:
    app: visit-counter
spec:
  replicas: 1
  selector:
    matchLabels:
      app: visit-counter
  template:
    metadata:
      labels:
        app: visit-counter
    spec:
      containers:
      - name: visit-counter
        image: "<REPO_REGION>-docker.pkg.dev/<PROJECT_ID>/<REPO_ID>/visit-counter:v1"
        env:
        - name: REDISHOST
          valueFrom:
            configMapKeyRef:
              name: redishost
              key: REDISHOST
        ports:
        - name: http
          containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: visit-counter
spec:
  type: LoadBalancer
  selector:
    app: visit-counter
  ports:
  - port: 80
    targetPort: 8080
    protocol: TCP

Appliquez la configuration à votre cluster comme suit :

kubectl apply -f gke_deployment/visit-counter.yaml

Déterminez l'adresse IP externe pour cet exemple d'application en exécutant la commande suivante :

kubectl get service visit-counter

Vérifiez que votre application est hébergée à l'adresse IP externe en utilisant votre navigateur, ou envoyez une requête GET à l'aide de curl ou de votre navigateur :

curl http://EXTERNAL_IP

Supprimer l'entrée des tables d'adresses IP pour l'instance Redis

Si vous avez suivi la troisième étape de la section Préparer le cluster GKE de ce tutoriel, vous avez installé la plage d'adresses IP réservées de votre instance Redis dans les tables d'adresses IP de votre instance GKE. Si vous souhaitez supprimer cette entrée de plage d'adresses IP Redis des tables IP de votre instance GKE, exécutez la commande suivante à partir du répertoire k8s-custom-iptables/ :

./uninstall.sh