I’ve been thinking a lot about building systems that can handle real-world scale and complexity. In my experience, the combination of event-driven architecture with robust observability isn’t just a nice-to-have—it’s essential for modern applications. That’s why I want to walk you through creating a production-ready system using Go, NATS JetStream, and OpenTelemetry.

Let me show you how to set up the foundation. We start by defining our project structure and core dependencies. The beauty of Go modules makes dependency management straightforward.

// go.mod
module eventdriven-microservices

go 1.21

require (
    github.com/nats-io/nats.go v1.31.0
    go.opentelemetry.io/otel v1.21.0
    github.com/gin-gonic/gin v1.9.1
)

Have you ever wondered how to ensure your events maintain consistency across services? Let me share how we define our event structure.

type BaseEvent struct {
    ID          string
    Type        EventType
    AggregateID string
    Timestamp   time.Time
    TraceID     string
}

Setting up our infrastructure with Docker Compose makes local development consistent and reproducible. Here’s how we configure NATS with JetStream:

services:
  nats:
    image: nats:2.10-alpine
    command: ["--jetstream", "--store_dir=/data"]
    volumes:
      - nats_data:/data

Now, let’s talk about the messaging layer. How do we ensure reliable message delivery while maintaining performance? The NATS JetStream client implementation handles reconnections and provides a clean interface for publishing events.

func (j *JetStreamClient) PublishEvent(ctx context.Context, event events.Event) error {
    data, err := json.Marshal(event)
    if err != nil {
        return fmt.Errorf("failed to marshal event: %w", err)
    }
    
    _, err = j.js.Publish(ctx, string(event.Type), data)
    return err
}

Observability is where many systems fall short. With OpenTelemetry, we can trace requests across service boundaries. Have you considered how distributed tracing changes how you debug production issues?

func StartSpan(ctx context.Context, name string) (context.Context, trace.Span) {
    tracer := otel.Tracer("order-service")
    return tracer.Start(ctx, name)
}

Building resilient services means handling failures gracefully. Circuit breakers and retry mechanisms prevent cascading failures. What patterns do you use for handling transient failures?

The beauty of this architecture lies in its simplicity and power. Each service focuses on its domain while communicating through well-defined events. This approach scales beautifully and makes systems easier to reason about.

As we wrap up, I’d love to hear your thoughts on event-driven architectures. What challenges have you faced when building distributed systems? Share your experiences in the comments below—let’s learn from each other. If you found this helpful, please like and share with others who might benefit from this approach.

Remember, the goal isn’t just to build something that works today, but to create systems that can evolve and scale with your needs. The combination of Go’s performance, NATS JetStream’s reliability, and OpenTelemetry’s observability gives us a solid foundation for building exactly that.