Cette page a été traduite par l'API Cloud Translation.

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 ou de l'accès au VPC sans serveur.

Configuration

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

Installez la gcloud CLI et initialisez-la:
```
gcloud init
```
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 activer cet accès, vous avez besoin de la sortie VPC directe ou d'un connecteur d'accès au VPC sans serveur. Comparez les deux méthodes de sortie réseau.

Recherchez le nom du réseau autorisé de votre instance Redis en exécutant la commande suivante:
```
gcloud redis instances describe INSTANCE_ID --region REGION --format "value(authorizedNetwork)"
```
Notez le nom du réseau.
Si vous utilisez l'accès au VPC sans serveur, créez un connecteur. Veillez à utiliser la même région et le même réseau VPC que ceux utilisés par l'instance Redis. Notez le nom du connecteur.

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 choisi 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==22.0.0
redis==5.0.1
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 :

Copiez le fichier Dockerfile dans le répertoire source :
```
cp cloud_run_deployment/Dockerfile .
```
Utilisez Cloud Build pour créer une image de conteneur à l'aide de la commande suivante :
```
gcloud builds submit --tag gcr.io/PROJECT_ID/visit-count
```
Déployez le conteneur dans Cloud Run.
- Si vous utilisez la sortie VPC directe, exécutez la commande suivante:
```
gcloud run deploy \
--image gcr.io/PROJECT_ID/visit-count \
--platform managed \
--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.
- Si vous utilisez un connecteur d'accès au VPC sans serveur, exécutez la commande suivante:
```
gcloud run deploy \
--image gcr.io/PROJECT_ID/visit-count \
--platform managed \
--allow-unauthenticated \
--region REGION \
--vpc-connector CONNECTOR_NAME \
--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 où se trouvent le connecteur d'accès au VPC sans serveur et votre instance Redis.
  - CONNECTOR_NAME est le nom du connecteur.
  - 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.