Connessione a un'istanza Redis da un servizio Cloud Run

Nota: per Cloud Run, anziché seguire le istruzioni riportate in questo articolo pagina, puoi utilizzare la funzionalità di integrazione Cloud Run per connetterti a una nuova istanza Redis in modo più semplice. Questa è un'anteprima .

Puoi connetterti a un'istanza Redis da Cloud Run utilizzando il traffico VPC diretto in uscita Accesso VPC serverless.

Configurazione

Se hai già installato Google Cloud CLI e hai creato un database Redis Ad esempio, puoi saltare questi passaggi.

1. Installa gcloud CLI e inizializza:

   gcloud init
   

2. Segui la guida rapida. per creare un'istanza Redis. Prendi nota della zona, dell'indirizzo IP e della porta l'istanza Redis.

Prepara il traffico in uscita dalla rete VPC per la configurazione

Per connettersi all'istanza Redis, il servizio Cloud Run deve avere accesso alla rete VPC autorizzata dell'istanza Redis. A abilitare questo accesso, è necessario il traffico VPC diretto in uscita o Connettore di accesso VPC serverless. Confronta i due metodi di traffico in uscita dalla rete.

1. Per trovare il nome della rete autorizzata dell'istanza Redis, esegui il comando seguente:

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

   Prendi nota del nome della rete.

2. Se utilizzi l'accesso VPC serverless, crea un connettore. Assicurati di utilizzare la stessa regione e la stessa rete VPC di quella utilizzata dall'istanza Redis. Prendi nota del nome del connettore.

Applicazione di esempio

Questa applicazione di server HTTP di esempio stabilisce una connessione a un'istanza Redis da un servizio Cloud Run.

Clona il repository per il linguaggio di programmazione scelto ed esplora alla cartella che contiene il codice campione:

Vai

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

Questa applicazione di esempio incrementa un contatore Redis ogni volta che l'endpoint / a cui si accede.

Vai

Questa applicazione utilizza github.com/gomodule/redigo/redis di alto profilo. Installalo eseguendo questo comando:

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

Questa applicazione utilizza la classe redis in maggior dettaglio più avanti in questo modulo.

{
  "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

Questa applicazione utilizza Flask per il servizio web e il pacchetto redis-py per comunicare con l'istanza 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)

Deployment dell'applicazione in Cloud Run

Per eseguire il deployment dell'applicazione:

1. Copia Dockerfile nella directory di origine:

   cp cloud_run_deployment/Dockerfile .
   

2. Crea un'immagine container utilizzando Cloud Build con il comando seguente:

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

3. Eseguire il deployment del container in Cloud Run.

   • Se utilizzi il traffico VPC diretto in uscita, esegui questo comando:

     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
     

     dove:

     • PROJECT_ID è l'ID del tuo progetto Google Cloud.
     • REGION è la regione in cui l'istanza Redis in cui viene localizzato.
     • NETWORK è il nome dell'utente autorizzato Rete VPC a cui è collegata l'istanza Redis.
     • SUBNET è il nome della tua subnet. La subnet deve /26 o superiore. Il traffico VPC diretto in uscita supporta intervalli IPv4 RFC 1918, RFC 6598, e Classe E.
     • REDIS_IP e REDIS_PORT sono l'indirizzo IP e il numero di porta dell'istanza Redis.

   • Se utilizzi un connettore di accesso VPC serverless, esegui seguente comando:

     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
     

     dove:

     • PROJECT_ID è l'ID del tuo progetto Google Cloud.
     • REGION è la regione in cui Connettore di accesso VPC serverless e l'istanza Redis in cui si trovano.
     • CONNECTOR_NAME è il nome del tuo connettore.
     • REDIS_IP e REDIS_PORT sono l'indirizzo IP e il numero di porta dell'istanza Redis.

Al termine del deployment, la riga di comando mostra l'URL del servizio Cloud Run. Visita questo URL in un browser web (oppure usa uno strumento come curl) e controlla l'aumento del conteggio delle istanze Redis ogni volta che viene visitato il servizio.