The Principal Dev – Masterclass for Tech Leads

The Principal Dev – Masterclass for Tech Leads28-29 May

Join

Go Micro Go.Dev reference Go Report Card

Go Micro is a framework for distributed systems development.

📖 Documentation | Sponsor the project | Discord

Overview

Go Micro provides the core requirements for distributed systems development including RPC and Event driven communication. The Go Micro philosophy is sane defaults with a pluggable architecture. We provide defaults to get you started quickly but everything can be easily swapped out.

Features

Go Micro abstracts away the details of distributed systems. Here are the main features.

Getting Started

To make use of Go Micro

go get go-micro.dev/v5@latest

Create a service and register a handler

package main

import (
        "go-micro.dev/v5"
)

type Request struct {
        Name string `json:"name"`
}

type Response struct {
        Message string `json:"message"`
}

type Say struct{}

func (h *Say) Hello(ctx context.Context, req *Request, rsp *Response) error {
        rsp.Message = "Hello " + req.Name
        return nil
}

func main() {
        // create the service
        service := micro.New("helloworld")

        // register handler
        service.Handle(new(Say))

        // run the service
        service.Run()
}

Set a fixed address

service := micro.NewService(
    micro.Name("helloworld"),
    micro.Address(":8080"),
)

Call it via curl

curl -XPOST \
     -H 'Content-Type: application/json' \
     -H 'Micro-Endpoint: Say.Hello' \
     -d '{"name": "alice"}' \
      http://localhost:8080

MCP & AI Agents

Go Micro is designed for an agent-first workflow. Every service you build automatically becomes a tool that AI agents can discover and use via the Model Context Protocol (MCP).

Services as Tools

Write a normal Go Micro service and it's instantly available as an MCP tool:

// SayHello greets a person by name.
// @example {"name": "Alice"}
func (g *GreeterService) SayHello(ctx context.Context, req *HelloRequest, rsp *HelloResponse) error {
    rsp.Message = "Hello " + req.Name
    return nil
}

Run with micro run and the agent playground and MCP tools registry are ready:

micro run
# Agent Playground:  http://localhost:8080/agent
# MCP Tools:         http://localhost:8080/api/mcp/tools

Use micro mcp serve for local AI tools like Claude Code, or connect any MCP-compatible agent to the HTTP endpoint.

See the MCP guide for authentication, scopes, and advanced usage.

Examples

Check out /examples for runnable code:

See all examples for more.

Protobuf

Install the code generator and see usage in the docs:

go install go-micro.dev/v5/cmd/protoc-gen-micro@v5.16.0

Note: Use a specific version instead of @latest to avoid module path conflicts. See releases for the latest version.

Docs: internal/website/docs/getting-started.md

Command Line

Install the CLI:

go install go-micro.dev/v5/cmd/micro@v5.16.0

Note: Use a specific version instead of @latest to avoid module path conflicts. See releases for the latest version.

Quick Start

micro new helloworld   # Create a new service
cd helloworld
micro run              # Run with API gateway and hot reload

Then open http://localhost:8080 to see your service and call it from the browser.

Development Workflow

Stage Command Purpose
Develop micro run Local dev with hot reload and API gateway
Build micro build Compile production binaries
Deploy micro deploy Push to a remote Linux server via SSH + systemd
Dashboard micro server Optional production web UI with JWT auth

micro run

micro run starts your services with:

Note: micro run and micro server use a unified gateway architecture. See Gateway Architecture for details.

micro run                    # Gateway on :8080
micro run --address :3000    # Custom gateway port
micro run --no-gateway       # Services only
micro run --env production   # Use production environment

Configuration

For multi-service projects, create a micro.mu file:

service users
    path ./users
    port 8081

service posts
    path ./posts
    port 8082
    depends users

env development
    DATABASE_URL sqlite://./dev.db

The gateway runs on :8080 by default, so services should use other ports.

Deployment

Deploy to any Linux server with systemd:

# On your server (one-time setup)
curl -fsSL https://go-micro.dev/install.sh | sh
sudo micro init --server

# From your laptop
micro deploy user@your-server

The deploy command:

  1. Builds binaries for Linux
  2. Copies via SSH to the server
  3. Sets up systemd services
  4. Verifies services are healthy

Optionally run micro server on the deployed machine for a production web dashboard with JWT auth, user management, and API explorer.

Manage deployed services:

micro status --remote user@server    # Check status
micro logs --remote user@server      # View logs
micro logs myservice --remote user@server -f  # Follow specific service

No Docker required. No Kubernetes. Just systemd.

See internal/website/docs/deployment.md for full deployment guide.

See cmd/micro/README.md for full CLI documentation.

Docs: internal/website/docs

Package reference: https://pkg.go.dev/go-micro.dev/v5

User Guides:

Architecture & Performance:

Security:

Adopters

Join libs.tech

...and unlock some superpowers

GitHub

We won't share your data with anyone else.