Se connecter à une instance Redis à partir d'un service Cloud Run

Vous pouvez vous connecter à une instance Redis à partir de Cloud Run à l'aide de la sortie VPC directe.

Important : Nous vous recommandons d'utiliser la sortie VPC directe, car elle offre une latence plus faible, un débit plus élevé et des coûts réduits en éliminant le besoin d'instances de connecteur gérées.

Vous pouvez également vous connecter à une instance Redis depuis Cloud Run à l'aide de l'accès au VPC sans serveur. Pour utiliser un connecteur d'accès au VPC sans serveur, consultez VPC avec connecteurs.

Configuration

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

1. Installez gcloud CLI et initialisez-le :

   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 la sortie réseau VPC pour la configuration

Pour se connecter à votre instance Redis, votre service Cloud Run doit avoir accès au réseau VPC autorisé de votre instance Redis.

Pour trouver le nom de ce réseau, exécutez la commande suivante :

    gcloud redis instances describe INSTANCE_ID --region REGION --format "value(authorizedNetwork)"

Notez le nom du réseau.

Exemple d'application

Cet exemple d'application de serveur HTTP établit une connexion à une instance Redis à partir d'un service Cloud Run.

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

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

// 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)
	}
}

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)

Déployer l'application dans Cloud Run

Pour déployer l'application, procédez comme suit :

1. Copiez le fichier Dockerfile dans le répertoire source :

   cp cloud_run_deployment/Dockerfile .
   

2. Créez une image de conteneur à l'aide de Cloud Build en exécutant la commande suivante :

   gcloud builds submit --tag gcr.io/PROJECT_ID/visit-count
   

3. Déployez le conteneur dans Cloud Run en exécutant la commande suivante :

       gcloud run deploy \
       --image gcr.io/PROJECT_ID/visit-count \
       --allow-unauthenticated \
       --region REGION \
       --network NETWORK \
       --subnet SUBNET \
       --set-env-vars REDISHOST=REDIS_IP,REDISPORT=REDIS_PORT
   

   où :

   • PROJECT_ID est l'ID de votre projet Google Cloud .
   • REGION est la région dans laquelle se trouve votre instance Redis.
   • NETWORK est le nom du réseau VPC autorisé auquel votre instance Redis est associée.
   • SUBNET est le nom de votre sous-réseau. Le sous-réseau doit être /26 ou supérieur. La sortie VPC directe est compatible avec les plages IPv4 RFC 1918, RFC 6598 et Classe E.
   • REDIS_IP et REDIS_PORT sont l'adresse IP et le numéro de port de votre instance Redis.

Une fois le déploiement terminé, la ligne de commande affiche l'URL de votre service Cloud Run. Accédez à cette URL dans un navigateur Web (ou utilisez un outil tel que curl) et observez le compteur sur votre instance Redis à chaque visite du service.