Connect to a Redis instance from an App Engine standard environment application

// Command redis is a basic app that connects to a managed Redis instance.
packagemain
import(
"fmt"
"log"
"net/http"
"os"
"github.com/gomodule/redigo/redis"
)
varredisPool*redis.Pool
funcincrementHandler(whttp.ResponseWriter,r*http.Request){
conn:=redisPool.Get()
deferconn.Close()
counter,err:=redis.Int(conn.Do("INCR","visits"))
iferr!=nil{
http.Error(w,"Error incrementing visitor counter",http.StatusInternalServerError)
return
}
fmt.Fprintf(w,"Visitor number: %d",counter)
}
funcmain(){
redisHost:=os.Getenv("REDISHOST")
redisPort:=os.Getenv("REDISPORT")
redisAddr:=fmt.Sprintf("%s:%s",redisHost,redisPort)
constmaxConnections=10
redisPool=&redis.Pool{
MaxIdle:maxConnections,
Dial:func()(redis.Conn,error){returnredis.Dial("tcp",redisAddr)},
}
http.HandleFunc("/",incrementHandler)
port:=os.Getenv("PORT")
ifport==""{
port="8080"
}
log.Printf("Listening on port %s",port)
iferr:=http.ListenAndServe(":"+port,nil);err!=nil{
log.Fatal(err)
}
}

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

packagecom.example.redis;
importjava.io.IOException;
importjava.util.Properties;
importjavax.servlet.ServletContextEvent;
importjavax.servlet.ServletContextListener;
importjavax.servlet.annotation.WebListener;
importredis.clients.jedis.JedisPool;
importredis.clients.jedis.JedisPoolConfig;
@WebListener
publicclass AppServletContextListenerimplementsServletContextListener{
privatePropertiesconfig=newProperties();
privateJedisPoolcreateJedisPool()throwsIOException{
Stringhost;
Integerport;
config.load(
Thread.currentThread()
.getContextClassLoader()
.getResourceAsStream("application.properties"));
host=config.getProperty("redis.host");
port=Integer.valueOf(config.getProperty("redis.port","6379"));
JedisPoolConfigpoolConfig=newJedisPoolConfig();
// Default : 8, consider how many concurrent connections into Redis you will need under load
poolConfig.setMaxTotal(128);
returnnewJedisPool(poolConfig,host,port);
}
@Override
publicvoidcontextDestroyed(ServletContextEventevent){
JedisPooljedisPool=(JedisPool)event.getServletContext().getAttribute("jedisPool");
if(jedisPool!=null){
jedisPool.destroy();
event.getServletContext().setAttribute("jedisPool",null);
}
}
// Run this before web application is started
@Override
publicvoidcontextInitialized(ServletContextEventevent){
JedisPooljedisPool=(JedisPool)event.getServletContext().getAttribute("jedisPool");
if(jedisPool==null){
try{
jedisPool=createJedisPool();
event.getServletContext().setAttribute("jedisPool",jedisPool);
}catch(IOExceptione){
// handle exception
}
}
}
}

packagecom.example.redis;
importjava.io.IOException;
importjava.net.SocketException;
importjavax.servlet.annotation.WebServlet;
importjavax.servlet.http.HttpServlet;
importjavax.servlet.http.HttpServletRequest;
importjavax.servlet.http.HttpServletResponse;
importredis.clients.jedis.Jedis;
importredis.clients.jedis.JedisPool;
@WebServlet(name="Track visits",value="")
publicclass VisitCounterServletextendsHttpServlet{
@Override
publicvoiddoGet(HttpServletRequestreq,HttpServletResponseresp)throwsIOException{
try{
JedisPooljedisPool=(JedisPool)req.getServletContext().getAttribute("jedisPool");
if(jedisPool==null){
thrownewSocketException("Error connecting to Jedis pool");
}
Longvisits;
try(Jedisjedis=jedisPool.getResource()){
visits=jedis.incr("visits");
}
resp.setStatus(HttpServletResponse.SC_OK);
resp.getWriter().println("Visitor counter: "+String.valueOf(visits));
}catch(Exceptione){
resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,e.getMessage());
}
}
}

{
"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';
consthttp=require('http');
constredis=require('redis');
constREDISHOST=process.env.REDISHOST||'localhost';
constREDISPORT=process.env.REDISPORT||6379;
constclient=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);

Flask==3.0.3
gunicorn==23.0.0
redis==6.0.0
Werkzeug==3.0.3

importlogging
importos
fromflaskimport Flask
importredis
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("/")
defindex():
 value = redis_client.incr("counter", 1)
 return f"Visitor number: {value}"
@app.errorhandler(500)
defserver_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)