An 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.
Server
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
Framework
Micro comes with a built in Go framework for service 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.
Dashboard
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.
Environments
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]
.
go install github.com/tickoalcantara12/micro/v3@latest
docker pull ghcr.io/micro/micro:latest
powershell -Command "iwr -useb https://raw.githubusercontent.com/micro/micro/master/scripts/install.ps1 | iex"
wget -q https://raw.githubusercontent.com/micro/micro/master/scripts/install.sh -O - | /bin/bash
curl -fsSL https://raw.githubusercontent.com/micro/micro/master/scripts/install.sh | /bin/bash
The server starts with a single command ready to use
micro server
sudo docker run -p 8080:8080 -p 8081:8081 ghcr.io/micro/micro:latest 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
Default username/password: admin/micro
$ micro login
Enter username: admin
Enter password:
Successfully logged in.
See what's running:
$ micro services
api
auth
broker
config
events
network
proxy
registry
runtime
server
store
Generate a service using the template
micro new helloworld
Output
Creating service helloworld
.
├── main.go
├── handler
│ └── helloworld.go
├── proto
│ └── helloworld.proto
├── Makefile
├── README.md
├── .gitignore
└── go.mod
download protoc zip packages (protoc-$VERSION-$PLATFORM.zip) and install:
visit https://github.com/protocolbuffers/protobuf/releases
compile the proto file helloworld.proto:
cd helloworld
make init
go mod vendor
make proto
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 from local dir
micro run .
Or from a git url
micro run github.com/micro/services/helloworld
$ micro status
NAME VERSION SOURCE STATUS BUILD UPDATED METADATA
helloworld latest github.com/micro/services/helloworld running n/a 4s ago owner=admin, group=micro
$ 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
$ micro helloworld call --name=Jane
{
"msg": "Hello Jane"
}
Curl it
curl "http://localhost:8080/helloworld?name=John"
A service client is used within another service and must be run by micro
package main
import (
"context"
"fmt"
"time"
"github.com/tickoalcantara12/micro/v3/service"
"github.com/tickoalcantara12/micro/v3/service/client"
proto "github.com/micro/services/helloworld/proto"
)
func callService(c client.Client) {
// create the proto client for helloworld
hw := proto.NewHelloworldService("helloworld", c)
for {
// call an endpoint on the service
rsp, err := hw.Call(context.Background(), &proto.CallRequest{
Name: "John",
})
if err != nil {
fmt.Println("Error calling helloworld: ", err)
return
}
// print the response
fmt.Println("Response: ", rsp.Message)
time.Sleep(time.Second)
}
}
func main() {
// create and initialise a new service
srv := service.New(
service.Name("caller"),
)
// run the client caller
go callService(srv.Client())
// run the service
service.Run()
}
Run it
micro run .
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 (
"fmt"
"os"
"github.com/tickoalcantara12/micro/v3/client/api"
)
type Request struct {
Name string `json:"name"`
}
type Response struct {
Msg string `json:"msg"`
}
func main() {
token := os.Getenv("TOKEN")
c := api.NewClient(nil)
// set your api token
c.SetToken(token)
req := &Request{
Name: "John",
}
var rsp Response
if err := c.Call("helloworld", "Call", req, &rsp); err != nil {
fmt.Println(err)
return
}
fmt.Println(rsp)
}
Run it
go run main.go
For more see the getting started guide.
Use services via the web with the Micro Web dashboard
micro web
Browse to localhost:8082
- 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
See LICENSE which makes use of Apache 2.0.