Build a Production-Ready Go Microservice with Nacos and Kubernetes

Overall Architecture Design

The system places Nacos at the core, providing both Naming (service registration & discovery) and Config (dynamic configuration). Individual services (User, Order, Pay) each embed a rate‑limiter, circuit‑breaker, and load‑balancer, all running as Pods inside Kubernetes.

┌──────────────────────┐
│       Nacos          │
│ Naming + Config │
└─────────┬────────────┘
          │
 ┌─────────────────────┼─────────────────────┐
 │                     │                     │
┌──────────────┐   ┌──────────────┐   ┌──────────────┐
│  User Svc    │   │  Order Svc   │   │  Pay Svc     │
│  Limiter    │   │  Limiter    │   │  Limiter    │
│  Breaker    │   │  Breaker    │   │  Breaker    │
│  LB Module  │   │  LB Module  │   │  LB Module  │
└──────┬──────┘   └──────┬──────┘   └──────┬──────┘
       │                │                │
   ┌───▼────┐      ┌───▼────┐      ┌───▼────┐
   │  Pod   │      │  Pod   │      │  Pod   │
   └────────┘      └────────┘      └────────┘
   (All running in Kubernetes)

Naming : Service registration and discovery.

Config : Dynamic configuration center.

Joint Governance : Real‑time adjustment of rate‑limit, circuit‑breaker, and load‑balancing parameters.

Chapter 2 – Preparing Nacos (Docker)

docker run -d \
  --name nacos \
  -p 8848:8848 \
  -e MODE=standalone \
  nacos/nacos-server

Access the console at http://localhost:8848/nacos with username/password nacos/nacos.

Chapter 3 – Go Integration with Nacos Naming (Service Registration & Discovery)

1. Initialize the client

sc := []constant.ServerConfig{
    *constant.NewServerConfig("127.0.0.1", 8848),
}
cc := *constant.NewClientConfig(
    constant.WithNamespaceId("prod"),
    constant.WithTimeoutMs(5000),
)

namingClient, _ := clients.NewNamingClient(vo.NacosClientParam{
    ClientConfig:  &cc,
    ServerConfigs: sc,
})

2. Register a service

namingClient.RegisterInstance(vo.RegisterInstanceParam{
    ServiceName: "user-service",
    Ip:         "10.1.1.10",
    Port:       8080,
    Weight:     10,
    Enable:     true,
    Healthy:    true,
})

3. Discover a service

instance, _ := namingClient.SelectOneHealthyInstance(vo.SelectOneHealthInstanceParam{
    ServiceName: "user-service",
})

Chapter 4 – Using Nacos as a Config Center

Key configuration dimensions:

Namespace : Environment isolation.

Group : Service or system grouping.

DataId : Specific configuration file.

Example user-service.yaml:

# user-service.yaml
mysql:
  host: 10.0.0.10
rateLimit:
  qps: 200
circuitBreaker:
  failCount: 5

Fetching configuration:

configClient, _ := clients.NewConfigClient(vo.NacosClientParam{
    ClientConfig:  &cc,
    ServerConfigs: sc,
})

content, _ := configClient.GetConfig(vo.ConfigParam{
    DataId: "user-service.yaml",
    Group:  "USER_SERVICE_GROUP",
})

Listening for changes:

configClient.ListenConfig(vo.ConfigParam{
    DataId: "user-service.yaml",
    Group:  "USER_SERVICE_GROUP",
    OnChange: func(_, _, _, data string) {
        LoadConfig(data)
    },
})

Configuration changes take effect instantly without restarting services.

Chapter 5 – Integrating Nacos with Kubernetes

1. Register using Pod IP

env:
  - name: POD_IP
    valueFrom:
      fieldRef:
        fieldPath: status.podIP

ip := os.Getenv("POD_IP")

2. Graceful shutdown

lifecycle:
  preStop:
    exec:
      command: ["/app/graceful-shutdown"]
terminationGracePeriodSeconds: 30

func gracefulShutdown() {
    namingClient.DeregisterInstance(vo.DeregisterInstanceParam{
        ServiceName: "user-service",
        Ip:         ip,
        Port:       8080,
    })
}

Full shutdown flow:

K8s sends SIGTERM
  ↓
preStop triggers
  ↓
Instance deregisters from Nacos
  ↓
No more traffic is routed to the pod
  ↓
Pod exits

Chapter 6 – The Three Pillars of Service Governance

1. Rate Limiting

var limiter = rate.NewLimiter(200, 50)

func Limit(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if !limiter.Allow() {
            w.WriteHeader(429)
            return
        }
        next.ServeHTTP(w, r)
    })
}

2. Circuit Breaking

cb := gobreaker.NewCircuitBreaker(gobreaker.Settings{
    Name: "user-service",
    ReadyToTrip: func(c gobreaker.Counts) bool {
        return c.ConsecutiveFailures > 5
    },
})

3. Load Balancing

instances, _ := namingClient.SelectInstances(vo.SelectInstancesParam{
    ServiceName: "user-service",
    HealthyOnly: true,
})
// Implement round‑robin, hash, or least‑connections as needed

Chapter 7 – Advanced: Configuration‑Driven Governance

Push all governance parameters into Nacos configuration:

rateLimit:
  qps: 300

circuitBreaker:
  failCount: 10

When the configuration changes, the application updates its limits in real time:

limiter.SetLimit(rate.Limit(GlobalConfig.RateLimit.QPS))
cb = NewCircuitBreaker(GlobalConfig)

Nacos becomes both a configuration center and a governance console.

Chapter 8 – End‑to‑End Production Call Flow

Request
  ↓
Rate Limiting
  ↓
Fetch instance from Nacos
  ↓
Load‑balance to a healthy node
  ↓
Circuit‑breaker decision
  ↓
Actual service call

Chapter 9 – Summary of Capabilities Delivered

Service Discovery : Nacos Naming.

Configuration Center : Nacos Config.

Service Governance : Integrated rate limiting, circuit breaking, and load balancing.

Container Scheduling : Native Kubernetes deployment with graceful shutdown.