Skip to content


Switch branches/tags

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?


Failed to load latest commit information.
Latest commit message
Commit time
November 28, 2022 11:27
March 24, 2023 04:06
July 22, 2022 10:36
September 18, 2022 08:18
November 27, 2020 22:02
July 30, 2022 11:18
November 17, 2022 18:03
March 22, 2023 15:49


Go Report Card Go.Dev reference Apache License DigitalOcean Droplet Twitter @MicroDotDev

API first development platform


Micro addresses the key requirements for building services in the cloud. It leverages the microservices architecture pattern and provides a set of services which act as the building blocks of a platform. Micro deals with the complexity of distributed systems and provides simpler programmable abstractions to build on.


Below are the core components that make up Micro.


Micro is built as a microservices architecture and abstracts away the complexity of the underlying infrastructure. We compose this as a single logical server to the user but decompose that into the various building block primitives that can be plugged into any underlying system.

The server is composed of the following services.

  • API - A Gateway which dynamically maps HTTP requests to RPC using path based resolution
  • Auth - Authentication and authorization out of the box using JWT tokens and rule based access control.
  • Broker - Ephemeral pubsub messaging for asynchronous communication and distributing notifications
  • Config - Dynamic configuration and secrets management for service level config without reload
  • Events - Event streaming with ordered messaging, replay from offsets and persistent storage
  • Network - Inter-service networking, isolation and routing plane for all internal request traffic
  • Proxy - An identity aware proxy used for remote access and any external grpc request traffic
  • Runtime - Service lifecycle and process management with support for source to running auto build
  • Registry - Centralised service discovery and API endpoint explorer with feature rich metadata
  • Store - Key-Value storage with TTL expiry and persistent crud to keep microservices stateless


Micro comes with a built in Go microservices framework for service based development. The Go framework makes it drop dead simple to write your services without having to piece together endless lines of boilerplate code. Auto configured and initialised by default, just import and get started quickly.

Command Line

Micro brings not only a rich architectural model but a command line experience tailored for that need. The command line interface includes dynamic command mapping for all services running on the platform. Turns any service instantly into a CLI command along with flag parsing for inputs. Includes support for multiple environments and namespaces, automatic refreshing of auth credentials, creating and running services, status info and log streaming, plus much, much more.


Explore, discover and consume services via a browser using Micro Web. The dashboard makes use of your env configuration to locate the server and provides dynamic form fill for services.


Micro bakes in the concept of Environments and multi-tenancy through Namespaces. Run your server locally for development and in the cloud for staging and production, seamlessly switch between them using the CLI commands micro env set [environment] and micro user set [namespace].


  • Introduction - A high level introduction to Micro
  • Getting Started - The helloworld quickstart guide
  • Upgrade Guide - Update your go-micro project to use micro v3.
  • Architecture - Describes the architecture, design and tradeoffs
  • Reference - In-depth reference for Micro CLI and services
  • Resources - External resources and contributions
  • Roadmap - Stuff on our agenda over the long haul
  • FAQ - Frequently asked questions


From Source

go install

Docker Image

docker pull

Install Binaries


powershell -Command "iwr -useb | iex"


wget -q -O - | /bin/bash


curl -fsSL | /bin/bash

Run the server

The server starts with a single command ready to use


micro server


sudo docker run -p 8080:8080 -p 8081:8081 server

Now go to localhost:8080 and make sure the output is something like {"version": "v3.10.1"} which is the latest version of micro installed.


Set the environment e.g local

micro env set local

Login to Micro

Default username/password: admin/micro

$ micro login
Enter username: admin
Enter password:
Successfully logged in.

See what's running:

$ micro services

Create a Service

Generate a service using the template

micro new helloworld


Creating service helloworld

├── main.go
├── handler
│   └── helloworld.go
├── proto
│   └── helloworld.proto
├── Makefile
├── .gitignore
└── go.mod

download protoc zip packages (protoc-$VERSION-$ and install:


compile the proto file helloworld.proto:

cd helloworld
make init
go mod vendor
make proto

Making changes

Edit the protobuf definition in proto/helloworld.proto and run make proto to recompile

Go to handler/helloworld.go to make changes to the response handler

type Helloworld struct{}

func New() *Helloworld {
        return &Helloworld{}

func (h *Helloworld) Call(ctx context.Context, req *pb.Request, rsp *pb.Response) error {
        rsp.Msg = "Hello " + req.Name
        return nil

Run the service

Run from local dir

micro run .

Or from a git url

micro run

Check status of running service

$ micro status
helloworld	latest	running	n/a	4s ago	owner=admin, group=micro

View logs of the service to verify it's running.

$ micro logs helloworld
2020-10-06 17:52:21  file=service/service.go:195 level=info Starting [service] helloworld
2020-10-06 17:52:21  file=grpc/grpc.go:902 level=info Server [grpc] Listening on [::]:33975
2020-10-06 17:52:21  file=grpc/grpc.go:732 level=info Registry [service] Registering node: helloworld-67627b23-3336-4b92-a032-09d8d13ecf95

Call the service

$ micro helloworld call --name=Jane
	"msg": "Hello Jane"

Curl it

curl "http://localhost:8080/helloworld?name=John"

Write a service client

A service client is used within another service and must be run by micro

package main

import (

	pb ""

func callService(hw pb.HelloworldService) {
	for {
		// call an endpoint on the service
		rsp, err := hw.Call(context.Background(), &pb.CallRequest{
			Name: "John",
		if err != nil {
			fmt.Println("Error calling helloworld: ", err)

		// print the response
		fmt.Println("Response: ", rsp.Message)


func main() {
	// create and initialise a new service
	srv := service.New(

	// new helloworld client
	hw := pb.NewHelloworldService("helloworld", srv.Client())
	// run the client caller
	go callService(hw)
	// run the service

Run it

micro run .

Write an api client

An api client is an external app or client which makes requests through the micro api

Get a token

export TOKEN=`micro user token`

Call helloworld

package main

import (


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

type Response struct {
	Msg string `json:"msg"`

func main() {
	token := os.Getenv("TOKEN")
	c := micro.NewClient(nil)

	// set your api token

   	req := &Request{
		Name: "John",
	var rsp Response

	if err := c.Call("helloworld", "Call", req, &rsp); err != nil {

Run it

go run main.go

For more see the getting started guide.

Web Dashboard

Use services via the web with the Micro Web dashboard

micro web

Browse to localhost:8082


See LICENSE which makes use of Apache 2.0.


1 click deploy a Micro Dev environment on a DigitalOcean Droplet

Use our refcode so we get $25 credit too!