henriqueatila/golang-gin-best-practices / skills/golang-gin-architect
golang-gin-architect
VerifiedSoftware architect for Go Gin APIs. Use when making architecture decisions, evaluating complexity, designing systems, choosing patterns, or coordinating across gin skills.
references/redis-cache-warming-pubsub.md
View on GitHub# Redis — Cache Warming and Pub/Sub Invalidation
Advanced Redis patterns beyond basic caching for Go Gin APIs.
---
## Cache Warming
**Pattern A — Startup warming** for critical, bounded datasets:
```go
func (s *ProductService) WarmCache(ctx context.Context) error {
s.logger.Info("warming product cache")
products, err := s.repo.ListAll(ctx)
if err != nil {
return fmt.Errorf("warm cache: %w", err)
}
pipe := s.redis.Pipeline()
for _, p := range products {
b, _ := json.Marshal(p)
key := fmt.Sprintf("myapp:v1:product:%s", p.ID)
pipe.Set(ctx, key, b, withJitter(time.Hour, 300))
}
_, err = pipe.Exec(ctx)
return err
}
// Call in main.go after Redis connection established
if err := productService.WarmCache(context.Background()); err != nil {
logger.Warn("cache warm failed, degrading gracefully", "err", err)
}
```
**Pattern B — Background refresh** (serve stale, refresh before expiry):
```go
type CachedItem[T any] struct {
Data T `json:"data"`
ExpiresAt time.Time `json:"expires_at"`
RefreshAt time.Time `json:"refresh_at"` // 80% of TTL
}
func (s *ProductService) GetWithEarlyRefresh(ctx context.Context, id string) (*Product, error) {
key := fmt.Sprintf("myapp:v1:product:%s", id)
data, err := s.redis.Get(ctx, key).Bytes()
if err == nil {
var item CachedItem[Product]
if json.Unmarshal(data, &item) == nil {
if time.Now().After(item.RefreshAt) {
go s.refreshAsync(context.Background(), id, key)
}
return &item.Data, nil
}
}
return s.fetchAndCache(ctx, id, key)
}
```
---
## Pub/Sub Invalidation (Multi-Instance)
Use when multiple app instances each have local in-memory caches. When instance A updates data, it tells others to invalidate.
```go
const invalidationChannel = "myapp:cache:invalidations"
type InvalidationMessage struct {
Entity string `json:"entity"`
ID string `json:"id"`
}
func (s *ProductService) publishInvalidation(ctx context.Context, id string) {
msg := InvalidationMessage{Entity: "product", ID: id}
b, _ := json.Marshal(msg)
if err := s.redis.Publish(ctx, invalidationChannel, b).Err(); err != nil {
s.logger.Warn("publish invalidation failed", "err", err)
}
}
func (s *ProductService) SubscribeInvalidations(ctx context.Context) {
sub := s.redis.Subscribe(ctx, invalidationChannel)
defer sub.Close()
ch := sub.Channel()
for {
select {
case <-ctx.Done():
return
case msg, ok := <-ch:
if !ok {
return
}
var inv InvalidationMessage
if err := json.Unmarshal([]byte(msg.Payload), &inv); err != nil {
continue
}
if inv.Entity == "product" {
s.localCache.Delete(inv.ID)
}
}
}
}
// Wire in main.go
go productService.SubscribeInvalidations(ctx)
```
---
## See Also
- `redis-session-distributed-lock.md` — session storage, distributed locking, Redis connection setup
- `redis-caching-patterns.md` — cache-aside, key design, singleflight stampede prevention
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| brainstormingobra/superpowersYou MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a renovation). | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| brand-guidelinesanthropics/skillsApplies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| frontend-designanthropics/skillsGuidance for distinctive, intentional visual design when building new UI or reshaping an existing one. Helps with aesthetic direction, typography, and making choices that don't read as templated defaults. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| mcp-builderanthropics/skillsGuide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK). | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |