There are books & many articles online, like this one arguing for using Postgres for everything. I thought I’d take a look at one use case - using Postgres instead of Redis for caching. I work with APIs quite a bit, so I’d build a super simple HTTP server that responds with data from that cache. I’d start from Redis as this is something I frequently encounter at work, switch it out to Postgres using unlogged tables and see if there’s a difference.
The setup
I’ll run the experiment on my homelab’s k8s cluster. The idea is to run Postgres or Redis on one node, limiting it to 2CPUs via k8s limits, as well as 8GiB of memory. On another node, I’ll run the web server itself and then spin a pod for the benchmark executed via k6 on the third.
Both postgres and redis are used with the out of the box settings for the following images:
- Postgres -
postgres:17.6 - Redis -
redis:8.2
I wrote a simple webserver, with 2 endpoints, a cache and a “Session” struct which we’ll store in the cache:
var ErrCacheMiss = errors.New("cache miss")
type Cache interface {
Get(ctx context.Context, key string) (string, error)
Set(ctx context.Context, key string, value string) error
}
type Session struct {
ID string
}
func serveHTTP(c Cache) {
http.HandleFunc("/get", getHandler(c))
http.HandleFunc("/set", setHandler(c))
port := os.Getenv("PORT")
if port == "" {
port = "8080"
}
fmt.Println("Server starting on http://0.0.0.0:" + port)
server := &http.Server{Addr: "0.0.0.0:" + port}
go func() {
if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
fmt.Println("Error starting server:", err)
}
}()
quit := make(chan os.Signal, 1)
signal.Notify(quit, os.Interrupt)
<-quit
fmt.Println("Shutting down server...")
if err := server.Close(); err != nil {
fmt.Println("Error shutting down server:", err)
}
}For redis, I’ve implemented the cache using github.com/redis/go-redis/v9 as follows:
type RedisCache struct {
client *redis.Client
}
func NewRedisCache() *RedisCache {
redisURL := os.Getenv("REDIS_URL")
if redisURL == "" {
redisURL = "localhost:6379"
}
fmt.Println("Connecting to Redis at", redisURL)
client := redis.NewClient(&redis.Options{
Addr: redisURL,
Password: "",
DB: 0,
})
return &RedisCache{
client: client,
}
}
func (r *RedisCache) Get(ctx context.Context, key string) (string, error) {
val, err := r.client.Get(ctx, key).Result()
if err == redis.Nil {
return "", ErrCacheMiss
}
if err != nil {
return "", err
}
return val, nil
}
func (r *RedisCache) Set(ctx context.Context, key string, value string) error {
return r.client.Set(ctx, key, value, 0).Err()
}The postgres cache is implemented using the github.com/jackc/pgx/v5 library:
type PostgresCache struct {
db *pgxpool.Pool
}
func NewPostgresCache() (*PostgresCache, error) {
pgDSN := os.Getenv("POSTGRES_DSN")
if pgDSN == "" {
pgDSN = "postgres://user:password@localhost:5432/mydb"
}
cfg, err := pgxpool.ParseConfig(pgDSN)
if err != nil {
return nil, err
}
cfg.MaxConns = 50
cfg.MinConns = 10
pool, err := pgxpool.NewWithConfig(context.Background(), cfg)
if err != nil {
return nil, err
}
_, err = pool.Exec(context.Background(), `
CREATE UNLOGGED TABLE IF NOT EXISTS cache (
key VARCHAR(255) PRIMARY KEY,
value TEXT
);
`)
if err != nil {
return nil, err
}
return &PostgresCache{
db: pool,
}, nil
}
func (p *PostgresCache) Get(ctx context.Context, key string) (string, error) {
var content string
err := p.db.QueryRow(ctx, `SELECT value FROM cache WHERE key = $1`, key).Scan(&content)
if err == pgx.ErrNoRows {
return "", ErrCacheMiss
}
if err != nil {
return "", err
}
return content, nil
}
func (p *PostgresCache) Set(ctx context.Context, key string, value string) error {
_, err := p.db.Exec(ctx, `INSERT INTO cache (key, value) VALUES ($1, $2) ON CONFLICT (key) DO UPDATE SET value = $2`, key, value)
return err
}I’ll seed the redis and postgres with 30 million entries each, keeping record of the inserted uuids. From there, I’ll generate a subset of existing uuids to use while benchmarking. This allows for simulating both hits and misses.
I’ll do a few runs of benchmarks for gets first, then sets and then a mixed run. Each run will execute for 2 minutes. I’ll look at the number of operations per second, latencies as well as memory and CPU usage during those times.
To simulate a somewhat real scenario where only a subset of keys exist in the cache the set benchmark will have a 10% chance to update an existing key, whereas the get will have an 80% chance of picking an existing key. The mixed workload will have a 20% chance to execute a set scenario and 80% for the get scenario.
The results
Getting values from cache
Redis performed better than Postgres, which did not surprise me at all. The bottleneck was actually the HTTP server. The machine running the http server maxed out on CPU, with redis running comfortably with ~1280mCPU - short of the 2000mCPU limit imposed. Redis used ~3800MiB of RAM, which stayed flat across the runs.
For postgres, the bottleneck was the CPU on postgres side. It consistently maxed out the 2 cores dedicated to it, while also using ~5000MiB of RAM.
Redis also did better when it comes to latencies of the HTTP responses:
Setting values in cache
Once again Redis performed better. The CPU usage stayed roughly the same as in the case of the GET experiment, with the RAM usage growing to ~4300MiB due to the new keys being inserted. The bottleneck stayed on the HTTP server side, with Redis using ~1280mCPU once again.
Postgres once again was bottlenecked by the CPU, constantly using 100% of the 2 cores it was limited to. During the course of the run, the memory usage grew to ~5500MiB.
During the test, the endpoints with the Redis cache implementation also had better latencies:
Read/write performance
The mixed benchmark also returned the predictable result of Redis reigning superior. As has been the story so far, the CPU stayed put at ~1280mCPU, RAM usage grew a bit due to the new keys being inserted.
Postgres maxed out the two cores and reached around 6GiB of memory used.
Latencies once again were better when using redis:
Unlogged tables
In the benchmark, I’ve used an unlogged table for postgres but this has not seemed to help, or has it? If I rerun the same benchmark with a normal(logged) table we can look at the numbers.
The unlogged table makes a huge difference for the write benchmark and a somewhat smaller but still significant one for the mixed workload. This is because the unlogged tables skip the write ahead log making them a lot faster for writes. There’s very little difference for the read performance though and I expect more runs would show the two test cases converging.
Conclusion
Redis is faster than postgres when it comes to caching, there’s no doubt about it. It conveniently comes with a bunch of other useful functionality that one would expect from a cache, such as TTLs. It was also bottlenecked by the hardware, my service or a combination of both and could definitely show better numbers. Surely, we should all use Redis for our caching needs then, right? Well, I think I’ll still use postgres. Almost always, my projects need a database. Not having to add another dependency comes with its own benefits. If I need my keys to expire, I’ll add a column for it, and a cron job to remove those keys from the table. As far as speed goes - 7425 requests per second is still a lot. That’s more than half a billion requests per day. All on hardware that’s 10 years old and using laptop CPUs. Not many projects will reach this scale and if they do I can just upgrade the postgres instance or if need be spin up a redis then. Having an interface for your cache so you can easily switch out the underlying store is definitely something I’ll keep doing exactly for this purpose.
Thanks for reading!