Connessione a un'istanza Redis da un'applicazione dell'ambiente standard App Engine

Puoi connetterti a un'istanza Redis dall'ambiente standard App Engine mediante 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.

Configurazione dell'accesso VPC serverless

Per connetterti dall'app App Engine all'istanza Redis sulla rete VPC autorizzata, devi configurare l'accesso VPC serverless.

1. Trova la rete autorizzata dell'istanza Redis eseguendo il comando:

   gcloud beta redis instances describe [INSTANCE_ID] --region [REGION]
   

2. Segui le istruzioni alla pagina Creazione di un connettore per creare un connettore di accesso VPC serverless. Assicurati di crea il connettore nella stessa regione dell'app e assicurati che è collegato alla rete VPC autorizzata dell'istanza Redis. Ricorda il nome del il connettore.

Applicazione di esempio

Questa applicazione server HTTP di esempio stabilisce una connessione a un Redis da un'app dell'ambiente standard di App Engine.

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

Vai

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

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

Java

Questa applicazione è basata su servlet Jetty 3.1.

Utilizza la libreria Jedis:

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

La classe AppServletContextListener viene utilizzata per creare un'istanza Pool di connessioni Redis:

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 è un servlet web che incrementa un contatore 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

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 la pubblicazione web e 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)

Preparazione dell'applicazione per il deployment

Per accedere all'istanza Redis, l'app App Engine deve essere configurata per utilizzare il connettore di accesso VPC serverless, fornisci i dettagli della connessione dell'istanza Redis.

1. Se non ne hai già uno, crea un Applicazione App Engine.

2. Aggiorna la configurazione dell'app per specificare Connettore di accesso VPC serverless, indirizzo IP e porta della tua istanza Redis:

   Vai

   Aggiorna il file gae_standard_deployment/app.yaml:

   runtime: go111
   
   # Update with Redis instance details
   env_variables:
     REDISHOST: '<REDIS_IP>'
     REDISPORT: '6379'
   
   # Update with Serverless VPC Access connector details
   vpc_access_connector:
     name: 'projects/<PROJECT_ID>/locations/<REGION>/connectors/<CONNECTOR_NAME>'

   Vedi file di configurazione app.yaml per ulteriori dettagli.

   Java

   Nota: questo esempio utilizza il runtime Java 8. Per scoprire come eseguire la migrazione a il runtime Java 11, consulta Migrazione dell'app App Engine da Java 8 a Java 11.

   Aggiorna il file gae_standard_deployment/appengine-web.xml per specificare il tuo connettore di accesso VPC serverless:

   <appengine-web-app xmlns="http://appengine.google.com/ns/1.0">
     <runtime>java8</runtime>
     <threadsafe>true</threadsafe>
     <vpc-access-connector>
       <name>projects/[PROJECT_ID]/locations/[REGION]/connectors/[CONNECTOR_NAME]</name>
     </vpc-access-connector>
   </appengine-web-app>

   Aggiorna il file src/main/resources/application.properties con l'indirizzo IP e la porta dell'istanza Redis:

   redis.host=REDIS_HOST_IP
   redis.port=6379

   Per ulteriori informazioni sulla configurazione dell'app, vedi Riferimento appengine-web.xml.

   Node.js

   Aggiorna il file gae_standard_deployment/app.yaml:

   runtime: nodejs10
   
   # Update with Redis instance details
   env_variables:
     REDISHOST: '<REDIS_IP>'
     REDISPORT: '6379'
   
   # Update with Serverless VPC Access connector details
   vpc_access_connector:
     name: 'projects/<PROJECT_ID>/locations/<REGION>/connectors/<CONNECTOR_NAME>'

   Vedi file di configurazione app.yaml per ulteriori dettagli.

   Python

   Aggiorna il file gae_standard_deployment/app.yaml:

   runtime: python37
   entrypoint: gunicorn -b :$PORT main:app
   
   # Update with Redis instance details
   env_variables:
     REDISHOST: '<REDIS_IP>'
     REDISPORT: '6379'
   
   # Update with Serverless VPC Access connector details
   vpc_access_connector:
     name: 'projects/<PROJECT_ID>/locations/<REGION>/connectors/<CONNECTOR_NAME>'

   Vedi file di configurazione app.yaml per ulteriori dettagli.

Deployment dell'applicazione nell'ambiente standard di App Engine

Per eseguire il deployment dell'applicazione:

1. Copia i file di configurazione necessari nella directory di origine:

   Vai

   Copia i file app.yaml e go.mod nella directory di origine:

   cp gae_standard_deployment/{app.yaml,go.mod} .
   

   Java

   Copia il file appengine-web.xml nella directory di origine:

   mkdir -p src/main/webapp/WEB-INF
   cp gae_standard_deployment/appengine-web.xml src/main/webapp/WEB-INF/
   

   Node.js

   Copia il file app.yaml nella directory di origine:

   cp gae_standard_deployment/app.yaml .
   

   Python

   Copia il file app.yaml nella directory di origine:

   cp gae_standard_deployment/app.yaml .
   

2. Esegui il comando di deployment:

   Vai

   gcloud app deploy
   

   Java

   mvn package appengine:stage
   gcloud app deploy target/appengine-staging/app.yaml
   

   Node.js

   gcloud app deploy
   

   Python

   gcloud app deploy
   

Al termine del deployment, il comando restituirà l'URL in cui puoi visita la tua app. Se visiti questo URL, vedrai il conteggio sul tuo Redis dell'istanza ogni volta che viene caricata la pagina.