Conéctate a una instancia de Redis desde una aplicación del entorno estándar de App Engine

Puedes conectarte a una instancia de Redis desde el entorno estándar de App Engine mediante el acceso a VPC sin servidores.

Configuración

Si ya instalaste Google Cloud CLI y creaste una instancia de Redis, puedes omitir estos pasos.

1. Instala la CLI de gcloud y realiza la inicialización:

   gcloud init
   

2. Sigue la Guía de inicio rápido para crear una instancia de Redis. Anota la zona, la dirección IP y el puerto de la instancia de Redis.

Configura el Acceso a VPC sin servidores

Para conectarte desde tu aplicación de App Engine a la red de VPC autorizada de la instancia de Redis, debes configurar el acceso a VPC sin servidores.

1. Encuentra la red autorizada de tu instancia de Redis mediante la ejecución del siguiente comando:

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

2. Sigue las instrucciones para crear un conector a fin de crear un conector de Acceso a VPC sin servidores. Asegúrate de crear el conector en la misma región que tu app y de que el conector esté conectado a la red de VPC autorizada de la instancia de Redis. Recuerda el nombre del conector.

Aplicación de muestra

Esta aplicación del servidor HTTP de muestra establece una conexión con una instancia de Redis desde una aplicación del entorno estándar de App Engine.

Clona el repositorio de tu lenguaje de programación deseado y navega a la carpeta que contiene el código de muestra:

Go

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

Esta aplicación de muestra aumenta un contador de Redis cada vez que se accede al extremo /.

Go

En esta aplicación, se usa el cliente github.com/gomodule/redigo/redis. Para instalarla, ejecuta el siguiente 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

Esta aplicación se basa en el servlet Jetty 3.1.

Usa la biblioteca de Jedis:

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

La clase AppServletContextListener se usa para crear un grupo de conexiones de Redis de larga duración:

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 clase VisitCounterServlet es un servlet web que incrementa un contador de 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

En esta aplicación, se usa el módulo 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

Esta aplicación usa Flask para la entrega web y el paquete redis-py a fin de comunicarse con la instancia de 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)

Preparar la aplicación para la implementación

Para acceder a la instancia de Redis, la aplicación de App Engine debe estar configurada a fin de usar tu conector de acceso a VPC sin servidores y debes proporcionar los detalles de conexión de la instancia de Redis.

1. Si aún no tienes una, crea una aplicación de App Engine.

2. Actualiza la configuración de la app para especificar el conector de acceso a VPC sin servidores, además de la dirección IP y el puerto de tu instancia de Redis:

   Go

   Actualiza el archivo 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>'

   Consulta el archivo de configuración app.yaml para obtener más detalles.

   Java

   Nota: En esta muestra, se usa el entorno de ejecución de Java 8. Para aprender a migrar al entorno de ejecución de Java 11, consulta Migra tu app de App Engine de Java 8 a Java  11.

   Actualiza el archivo gae_standard_deployment/appengine-web.xml para especificar el conector de acceso a VPC sin servidores:

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

   Actualiza el archivo src/main/resources/application.properties mediante la dirección IP y el puerto de tu instancia de Redis:

   redis.host=REDIS_HOST_IP
   redis.port=6379

   Para obtener más información sobre la configuración de tu aplicación, consulta Referencia de appengine-web.xml.

   Node.js

   Actualiza el archivo 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>'

   Consulta el archivo de configuración app.yaml para obtener más detalles.

   Python

   Actualiza el archivo 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>'

   Consulta el archivo de configuración app.yaml para obtener más detalles.

Implementa la app en el entorno estándar de App Engine

Para implementar la aplicación, haz lo siguiente:

1. Copia los archivos de configuración necesarios en el directorio del código fuente:

   Go

   Copia los archivos app.yaml y go.mod en el directorio del código fuente:

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

   Java

   Copia el archivo appengine-web.xml en el directorio fuente:

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

   Node.js

   Copia el archivo app.yaml en el directorio fuente:

   cp gae_standard_deployment/app.yaml .
   

   Python

   Copia el archivo app.yaml en el directorio fuente:

   cp gae_standard_deployment/app.yaml .
   

2. Ejecuta el comando de implementación:

   Go

   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
   

Cuando se complete la implementación, el comando generará la URL en la que puedes visitar tu app. Si visitas esta URL, el recuento en tu instancia de Redis aumentará cada vez que se cargue la página.