Caching in Go: Redis, Memcached und integrierte Lösungen (Fortgeschrittenenniveau)

Einleitung: Warum ist Caching in Go auf fortgeschrittenem Niveau notwendig?

In hochbelasteten Systemen mit Go (Golang) wird die Geschwindigkeit des Datenzugriffs oft zum Engpass. Die Datenbank ist nicht immer in der Lage, Tausende von Anfragen pro Sekunde ohne nennenswerte Verzögerungen zu verarbeiten. Caching ist ein Schlüsselwerkzeug, um die Last auf der Datenbank zu reduzieren und die API-Antwort zu beschleunigen.

Auf Anfängerniveau verwenden Entwickler oft einfache map mit Mutexen. In der Produktion sind jedoch fortgeschrittenere Lösungen erforderlich: verteilte Caches (Redis, Memcached) und leistungsstarke In-Memory-Bibliotheken (BigCache, FreeCache). In diesem Artikel werden wir ihre Besonderheiten analysieren, die Leistung vergleichen und Codebeispiele in Go für jede Option zeigen.

1. Integrierte Lösungen: sync.Map und die Bibliotheken BigCache/FreeCache

1.1. sync.Map – wenn keine externe Abhängigkeit benötigt wird

Das Paket sync.Map ist eine threadsichere Map, optimiert für Szenarien, in denen Schlüssel einmal geschrieben und viele Male gelesen werden. Es erfordert keine Lese-Sperren, was einen Leistungsgewinn bringt.

Anwendungsbeispiel:

package main

import (    "fmt"    "sync")

func main() {    var cache sync.Map

    // Schreiben    cache.Store("user:1", "Alice")

    // Lesen    if value, ok := cache.Load("user:1"); ok {        fmt.Println("Gefunden:", value)    }

    // Löschen    cache.Delete("user:1")}

Nachteile: keine automatische Invalidierung per TTL, keine Speicherbegrenzung. Geeignet für die temporäre Speicherung von Konfigurationen oder selten geänderten Daten.

1.2. BigCache – schneller In-Memory-Cache mit TTL

BigCache von Allegro ist eine Bibliothek, die Daten in Byte-Arrays speichert und so den GC-Overhead vermeidet. Sie unterstützt TTL und die automatische Räumung alter Einträge.

Beispiel:

import (    "github.com/allegro/bigcache/v3"    "time")

func main() {    cache, _ := bigcache.NewBigCache(bigcache.DefaultConfig(10 * time.Minute))

    // Schreiben    cache.Set("mykey", []byte("myvalue"))

    // Lesen    entry, _ := cache.Get("mykey")    println(string(entry))}

Vorteile: minimaler Druck auf den GC, hohe Geschwindigkeit (Millionen von Operationen pro Sekunde). Nachteile: Daten werden nur in Bytes gespeichert, keine Unterstützung für komplexe Strukturen ohne Serialisierung.

1.3. FreeCache – Alternative mit fester Größe

FreeCache ist eine weitere In-Memory-Bibliothek mit konfigurierbarer Cache-Größe. Sie verwendet Segmentierung, um Sperren zu reduzieren.

import "github.com/coocood/freecache"

func main() {    // Cache-Größe – 100 MB    cache := freecache.NewCache(100 * 1024 * 1024)

    cache.Set([]byte("key"), []byte("value"), 60) // TTL 60 Sekunden    got, _ := cache.Get([]byte("key"))    println(string(got))}

2. Redis – Verteiltes Caching mit fortgeschrittenen Strukturen

Redis ist der beliebteste externe Cache für Go-Anwendungen. Es unterstützt nicht nur Strings, sondern auch Listen, Hashes, Sets sowie TTL, Pub/Sub und Transaktionen.

2.1. Verbindung und grundlegende Operationen

Für die Arbeit mit Redis in Go wird der Treiber go-redis/redis (oder redis/v8) verwendet.

import (    "github.com/go-redis/redis/v8"    "context")

var ctx = context.Background()

func main() {    rdb := redis.NewClient(&redis.Options{        Addr:     "localhost:6379",        Password: "",        DB:       0,    })

    // Setzen mit TTL von 10 Sekunden    err := rdb.Set(ctx, "key", "value", 10*time.Second).Err()    if err != nil {        panic(err)    }

    val, err := rdb.Get(c