Connettersi a un'istanza Redis dalle funzioni Cloud Run

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

Configurazione

Se hai già installato Google Cloud CLI e creato un'istanza Redis, puoi saltare questi passaggi.

  1. Installa e inizializza gcloud CLI:

    gcloud init

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

Preparare il traffico in uscita della rete VPC per la configurazione

Per connetterti all'istanza Redis, la tua funzione Cloud Run deve avere accesso alla rete VPC autorizzata dell'istanza Redis.

Per trovare il nome di questa rete, esegui il comando seguente:

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

Prendi nota del nome della rete.

Funzione di esempio

Questa funzione di esempio stabilisce una connessione a un'istanza Redis da Cloud Run Functions.

Clona il repository per il linguaggio di programmazione che preferisci e vai alla cartella contenente il codice campione:

Vai

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

Node.js

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

Python

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

Il codice campione incrementa un contatore Redis ogni volta che viene attivata la funzione:

Vai

Questa funzione utilizza il github.com/gomodule/redigo/redis client.


// Package visitcount provides a Cloud Function that connects
// to a managed Redis instance.
package visitcount

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

	"github.com/GoogleCloudPlatform/functions-framework-go/functions"
	"github.com/gomodule/redigo/redis"
)

var redisPool *redis.Pool

func init() {
	// Register the HTTP handler with the Functions Framework
	functions.HTTP("VisitCount", visitCount)
}

// initializeRedis initializes and returns a connection pool
func initializeRedis() (*redis.Pool, error) {
	redisHost := os.Getenv("REDISHOST")
	if redisHost == "" {
		return nil, errors.New("REDISHOST must be set")
	}
	redisPort := os.Getenv("REDISPORT")
	if redisPort == "" {
		return nil, errors.New("REDISPORT must be set")
	}
	redisAddr := fmt.Sprintf("%s:%s", redisHost, redisPort)

	const maxConnections = 10
	return &redis.Pool{
		MaxIdle: maxConnections,
		Dial: func() (redis.Conn, error) {
			c, err := redis.Dial("tcp", redisAddr)
			if err != nil {
				return nil, fmt.Errorf("redis.Dial: %w", err)
			}
			return c, err
		},
	}, nil
}

// visitCount increments the visit count on the Redis instance
// and prints the current count in the HTTP response.
func visitCount(w http.ResponseWriter, r *http.Request) {
	// Initialize connection pool on first invocation
	if redisPool == nil {
		// Pre-declare err to avoid shadowing redisPool
		var err error
		redisPool, err = initializeRedis()
		if err != nil {
			log.Printf("initializeRedis: %v", err)
			http.Error(w, "Error initializing connection pool", http.StatusInternalServerError)
			return
		}
	}

	conn := redisPool.Get()
	defer conn.Close()

	counter, err := redis.Int(conn.Do("INCR", "visits"))
	if err != nil {
		log.Printf("redis.Int: %v", err)
		http.Error(w, "Error incrementing visit count", http.StatusInternalServerError)
		return
	}
	fmt.Fprintf(w, "Visit count: %d", counter)
}

Node.js

Questa funzione utilizza il redis modulo.


const functions = require('@google-cloud/functions-framework');
const redis = require('redis');

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

const redisClient = redis.createClient({
  socket: {
    host: REDISHOST,
    port: REDISPORT,
  },
});
redisClient.on('error', err => console.error('ERR:REDIS:', err));
redisClient.connect();

functions.http('visitCount', async (req, res) => {
  try {
    const response = await redisClient.incr('visits');
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end(`Visit count: ${response}`);
  } catch (err) {
    console.log(err);
    res.status(500).send(err.message);
  }
});

Python

Questa funzione utilizza il redis-py pacchetto.


import os

import functions_framework
import redis

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)


@functions_framework.http
def visit_count(request):
    value = redis_client.incr("visits", 1)
    return f"Visit count: {value}"

Eseguire il deployment dell'esempio in Cloud Run Functions

Per eseguire il deployment della funzione:

  1. Copia il Dockerfile nella directory di origine:

    cp ../../../memorystore/redis/cloud_run_deployment/Dockerfile .

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

    gcloud artifacts repositories create --location REPO_REGION --repository-format=docker REPO_ID
gcloud builds submit --pack image=REPO_REGION-docker.pkg.dev/PROJECT_ID/REPO_ID/visit-counter:v1,builder=gcr.io/buildpacks/builder:latest,env=GOOGLE_FUNCTION_SIGNATURE_TYPE=http,env=GOOGLE_FUNCTION_TARGET=VisitCount

  3. Esegui il deployment del container in Cloud Run eseguendo il comando seguente:

    gcloud run deploy \
  --image REPO_REGION-docker.pkg.dev/PROJECT_ID/REPO_ID/visit-counter:v1 \
  --allow-unauthenticated \
  --region REGION \
  --network NETWORK \
  --subnet SUBNET \
  --set-env-vars REDISHOST=REDIS_IP,REDISPORT=REDIS_PORT

    dove:

    • REPO_REGION è la regione del repository.
    • REPO_ID è il nome del repository contenente l'immagine dell'applicazione.
    • PROJECT_ID è l'ID del tuo Google Cloud progetto.
    • REGION è la regione in cui si trova l'istanza Redis.
    • NETWORK è il nome della rete VPC autorizzata a cui è collegata l'istanza Redis.
    • SUBNET è il nome della subnet. La subnet deve essere almeno /26 o superiore. Il traffico in uscita VPC diretto supporta gli intervalli IPv4 RFC 1918, RFC 6598, e di classe E.
    • REDIS_IP e REDIS_PORT sono l'indirizzo IP e il numero di porta dell'istanza Redis.

Al termine del deployment della funzione, recupera l'URL della funzione:

gcloud run services describe visit-count \
--region=REGION

Puoi vedere il contatore aumentare ogni volta che attivi la funzione inviando una richiesta GET al suo URL.