← Blog

Getting Started with Golang Microservices

Building microservices with Golang has been one of the most rewarding experiences in my journey as a backend developer. In this post, I'll share insights from building production-grade microservices at Tap Invest, where we processed thousands of transactions daily.

Why Golang for Microservices?

After working with Java Spring Boot and considering other options, we chose Golang for our new services. Here's why:

  • —Blazing Fast Compilation — Go compiles to a single binary in seconds
  • —Goroutines — Lightweight concurrency without the complexity of threads
  • —Small Memory Footprint — Our services run on minimal resources
  • —Strong Standard Library — Built-in HTTP, JSON, and testing support

"Go is designed to scale. It's simple, fast, and perfect for microservices." — Rob Pike

This separation keeps our code testable and maintainable.

Building a Simple HTTP Server

Let's start with a basic HTTP server using the Gin framework:

package main

import (
    "log"
    "net/http"
    
    "github.com/gin-gonic/gin"
)

type HealthResponse struct {
    Status  string `json:"status"`
    Version string `json:"version"`
}

func main() {
    r := gin.Default()
    
    // Health check endpoint
    r.GET("/health", func(c *gin.Context) {
        c.JSON(http.StatusOK, HealthResponse{
            Status:  "healthy",
            Version: "1.0.0",
        })
    })
    
    // Graceful error handling
    if err := r.Run(":8080"); err != nil {
        log.Fatal("Failed to start server:", err)
    }
}

Repository Pattern for Clean Data Access

One pattern that's worked well for us is the Repository Pattern:

package repository

import (
    "context"
    "database/sql"
)

type OrderRepository interface {
    Create(ctx context.Context, order *Order) error
    FindByID(ctx context.Context, id string) (*Order, error)
    Update(ctx context.Context, order *Order) error
}

type orderRepository struct {
    db *sql.DB
}

func NewOrderRepository(db *sql.DB) OrderRepository {
    return &orderRepository{db: db}
}

func (r *orderRepository) Create(ctx context.Context, order *Order) error {
    query := `INSERT INTO orders (id, user_id, amount, status) 
              VALUES ($1, $2, $3, $4)`
    
    _, err := r.db.ExecContext(ctx, query, 
        order.ID, order.UserID, order.Amount, order.Status)
    return err
}

Error Handling Done Right

Go's explicit error handling might seem verbose, but it leads to more robust code:

func (s *OrderService) PlaceOrder(ctx context.Context, req PlaceOrderRequest) (*Order, error) {
    // Validate request
    if err := req.Validate(); err != nil {
        return nil, fmt.Errorf("invalid request: %w", err)
    }
    
    // Check inventory
    available, err := s.inventoryClient.Check(ctx, req.ProductID)
    if err != nil {
        return nil, fmt.Errorf("failed to check inventory: %w", err)
    }
    
    if !available {
        return nil, ErrOutOfStock
    }
    
    // Create order
    order := &Order{
        ID:        uuid.New().String(),
        ProductID: req.ProductID,
        Quantity:  req.Quantity,
        Status:    OrderStatusPending,
    }
    
    if err := s.repo.Create(ctx, order); err != nil {
        return nil, fmt.Errorf("failed to create order: %w", err)
    }
    
    return order, nil
}

Key Takeaways

  1. —Start with a clear project structure — It pays dividends as your codebase grows
  2. —Use interfaces for testability — Mock dependencies easily in tests
  3. —Embrace explicit error handling — It makes debugging easier
  4. —Keep services small and focused — One service, one responsibility
  5. —Add observability from day one — Logs, metrics, and tracing are essential

What's Next?

In future posts, I'll dive deeper into:

  • —Setting up distributed tracing with Jaeger
  • —Building event-driven microservices with Kafka
  • —Deploying Go services on Kubernetes

Stay tuned for more! 🚀