Caching in Go (Golang): Redis und andere Lösungen |…

Caching in Go (Golang): Redis und andere Tools

Caching ist einer der wichtigsten Mechanismen zur Leistungsoptimierung von Webanwendungen und Microservices. Im Go (Golang)-Ökosystem gibt es zahlreiche Bibliotheken zur Implementierung von Caching, von einfachen In-Memory-Lösungen bis hin zu verteilten Systemen auf Basis von Redis. In diesem Artikel werden wir drei Hauptansätze im Detail betrachten: eingebaute Datenstrukturen (sync.Map), beliebte In-Memory-Bibliotheken (go-cache, freecache, bigcache) und die Integration mit Redis.

1. Eingebaute Mittel: sync.Map

Go bietet eine threadsichere Map – sync.Map. Sie eignet sich für einfaches Caching mit kleinen Datenmengen und seltenen Aktualisierungen. Ihre Leistung bei hoher Last ist jedoch spezialisierten Bibliotheken unterlegen.

Beispiel zur Verwendung von sync.Map:

package main

import (    "fmt"    "sync"    "time")

func main() {    var cache sync.Map

    // Schreiben    cache.Store("user:42", map[string]interface{}{        "name": "Alice",        "age":  30,    })

    // Lesen mit Prüfung    if val, ok := cache.Load("user:42"); ok {        fmt.Println("Cache gefunden:", val)    }

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

    // Caching mit TTL (muss manuell implementiert werden)    cache.Store("session:abc", time.Now().Unix())}

Nachteile: Fehlendes automatisches TTL, eingeschränkter Satz an Operationen, mögliche Leistungsprobleme bei häufigen Schreibvorgängen.

2. In-Memory-Bibliotheken

Für komplexere Szenarien verwenden Sie spezialisierte Bibliotheken. Betrachten wir drei beliebte:

2.1 go-cache

Einfache Bibliothek mit TTL-Unterstützung. Ideal für kleine Projekte.

import "github.com/patrickmn/go-cache"

func main() {    c := cache.New(5*time.Minute, 10*time.Minute) // Standard-TTL, Bereinigungsintervall

    c.Set("key", "value", cache.DefaultExpiration)    val, found := c.Get("key")    if found {        fmt.Println(val)    }}

2.2 freecache

Bibliothek mit fester Speichergröße (kein GC-Overhead). Unterstützt TTL und hohe Leistung.

import "github.com/coocood/freecache"

func main() {    cache := freecache.NewCache(100 * 1024 * 1024) // 100 MB

    cache.Set([]byte("mykey"), []byte("myvalue"), 60) // TTL 60 Sek.    val, err := cache.Get([]byte("mykey"))    if err == nil {        fmt.Println(string(val))    }}

2.3 bigcache

Optimiert für die Speicherung großer Datenmengen ohne GC-Pausen. Arbeitet mit serialisierten Daten.

import "github.com/allegro/bigcache/v3"

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

    cache.Set("key", []byte("value"))    val, _ := cache.Get("key")    fmt.Println(string(val))}

3. Redis: Verteiltes Caching

Für verteilte Systeme und Microservices bleibt Redis der De-facto-Standard. In Go verwenden Sie die Bibliothek go-redis/redis (v9+).

Verbindung und grundlegende Operationen:

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

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

    // Wert mit TTL setzen    err := rdb.Set(ctx, "user:42", `{"name":"Bob"}`, 10*time.Minute).Err()    if err != nil {        panic(err)    }

    // Lesen    val, err := rdb.Get(ctx, "user:42").Result()    if err == redis.Nil {        fmt.Println("Cache nicht gefunden")    } else if err != nil {        panic(err)    } else {        fmt.Println("Wert:", val)    }}