Build a Self‑Healing Go Gateway with Circuit Breaker and Dynamic Rate Limiting

In microservice architectures, a gateway acts as a traffic hub; without intelligent scheduling it can become congested or collapse when downstream services fail or when abusive crawlers flood the APIs. This guide demonstrates how to build a "thinking" gateway in Go that automatically trips circuit breakers for unhealthy instances and adjusts rate‑limiting policies dynamically via Consul.

Circuit Breaker: Giving the Gateway Self‑Protection

The implementation uses mercari/go-circuitbreaker for its high‑concurrency, lock‑free design, flexible policies (failure‑rate, consecutive errors, etc.), observable state changes, and half‑open self‑recovery. Each backend instance gets its own circuit breaker, making failures isolated.

func NewCircuitBreakerWithConfig(cfg CircuitBreakerConfig) *circuitbreaker.CircuitBreaker {
    cb := circuitbreaker.New(
        circuitbreaker.WithCounterResetInterval(cfg.CounterResetInterval),
        circuitbreaker.WithHalfOpenMaxSuccesses(cfg.HalfOpenMaxSuccesses),
        circuitbreaker.WithTripFunc(
            circuitbreaker.NewTripFuncFailureRate(cfg.FailureRateWindow, cfg.FailureRateThreshold),
        ),
        circuitbreaker.WithOnStateChangeHookFn(func(from, to circuitbreaker.State) {
            fmt.Printf("[CB][%s] 状态变更: %s -> %s
", cfg.Name, from, to)
        }),
    )
    return cb
}

The circuit breaker transitions through Open, Half‑Open, and Closed states, similar to a highway toll booth closing a lane after repeated accidents and reopening it after successful probes.

Dynamic Rate Limiting: Tailoring Traffic per Client

The gateway supports flexible rate‑limiting rules that go beyond a static QPS number. Using easyms.golang, administrators can define limits per IP subnet, per User‑Agent, and hot‑update the rules via Consul without restarting the service.

IP‑segment limiting : Separate limits for internal networks and external IP ranges.

User‑Agent limiting : Different thresholds for crawlers, mobile apps, and browsers.

Hot rule updates : All limits are stored in Consul and take effect within seconds.

Example YAML configuration (loaded from Consul):

rate_limit:
  ip_limits:
    - cidr: "192.168.1.0/24"
      rate: 20
      burst: 40
  ua_limits:
    - pattern: ".*Chrome.*"
      rate: 50
      burst: 100
  default_rate: 100
  default_burst: 200

Core Go code that synchronizes the limiter manager with the application configuration:

func (lm *LimiterManager) SyncFromAppConfig() {
    cfg := config.GetAppConfig()
    if cfg == nil || cfg.RateLimit == nil {
        return
    }
    lm.mu.Lock()
    defer lm.mu.Unlock()
    // Parse and rebuild rate‑limit rules
    // ...
}

The synchronizer runs every 10 seconds, ensuring that any rule change in Consul is applied instantly.

Full Gateway Flow

Request arrival – The request first passes through the multi‑layer rate limiter (IP/UA/default).

Dispatch to backend – Each backend instance is protected by its own circuit breaker, automatically isolating failures.

Configuration change – When Consul updates the rules, the gateway reloads them within seconds, providing a truly live system.

Architecture Diagram

┌─────────────┐
│   Client    │
└─────┬───────┘
      │
      ▼
┌─────────────┐
│   Gateway   │
│ ┌─────────┐ │
│ │ Limiter │ │ ← Dynamic rules (Consul/YAML)
│ └─────────┘ │
│ ┌─────────┐ │
│ │ CB      │ │ ← One per backend instance
│ └─────────┘ │
└─────┬───────┘
      │
      ▼
┌─────────────┐
│   Backend   │
└─────────────┘

The complete source code is available at:

GitHub: https://github.com/louis-xie-programmer/easyms.golang

Gitee: https://gitee.com/louis_xie/easyms.golang