micro alternatives and similar packages
Based on the "Distributed Systems" category.
Alternatively, view micro alternatives based on common mentions on social networks and blogs.
-
Nomad
Nomad is an easy-to-use, flexible, and performant workload orchestrator that can deploy a mix of microservice, batch, containerized, and non-containerized applications. Nomad is easy to operate and scale and has native Consul and Vault integrations. -
go-zero
go-zero is a web and rpc framework written in Go. It's born to ensure the stability of the busy sites with resilient design. Builtin goctl greatly improves the development productivity. [Moved to: https://github.com/zeromicro/go-zero] -
rpcx
Best microservices framework in Go, like alibaba Dubbo, but with more features, Scale easily. Try it. Test it. If you feel it's better, use it! ๐๐๐ฏ๐ๆ๐๐ฎ๐๐๐จ, ๐๐จ๐ฅ๐๐ง๐ ๆ๐ซ๐ฉ๐๐ฑ! build for cloud! -
Encore
Encore is the Backend Development Platform purpose-built to help you create event-driven and distributed systems. -
gleam
Fast, efficient, and scalable distributed map/reduce system, DAG execution, in memory or on disk, written in pure Go, runs standalone or distributedly. -
glow
Glow is an easy-to-use distributed computation system written in Go, similar to Hadoop Map Reduce, Spark, Flink, Storm, etc. I am also working on another similar pure Go system, https://github.com/chrislusf/gleam , which is more flexible and more performant. -
Olric
Distributed in-memory object store. It can be used as an embedded Go library and a language-independent service. -
Dragonfly
Dragonfly is an open source P2P-based file distribution and image acceleration system. It is hosted by the Cloud Native Computing Foundation (CNCF) as an Incubating Level Project. -
go-doudou
go-doudou๏ผdoudou pronounce /dษudษu/๏ผis OpenAPI 3.0 (for REST) spec and Protobuf v3 (for grpc) based lightweight microservice framework. It supports monolith service application as well. -
resgate
A Realtime API Gateway used with NATS to build REST, real time, and RPC APIs, where all your clients are synchronized seamlessly. -
go-sundheit
A library built to provide support for defining service health for golang services. It allows you to register async health checks for your dependencies and the service itself, provides a health endpoint that exposes their status, and health metrics. -
Maestro
Take control of your data, connect with anything, and expose it anywhere through protocols such as HTTP, GraphQL, and gRPC. -
celeriac
Golang client library for adding support for interacting and monitoring Celery workers, tasks and events. -
drmaa
Compute cluster (HPC) job submission library for Go (#golang) based on the open DRMAA standard.
WorkOS - The modern identity platform for B2B SaaS
Do you think we are missing an alternative of micro or a related project?
Popular Comparisons
README
Micro
An API first development platform
Overview
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.
Features
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]
.
Docs
- 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
Installation
From Source
go install github.com/micro/micro/v3@latest
Docker Image
docker pull ghcr.io/micro/micro:latest
Install Binaries
Windows
powershell -Command "iwr -useb https://raw.githubusercontent.com/micro/micro/master/scripts/install.ps1 | iex"
Linux
wget -q https://raw.githubusercontent.com/micro/micro/master/scripts/install.sh -O - | /bin/bash
MacOS
curl -fsSL https://raw.githubusercontent.com/micro/micro/master/scripts/install.sh | /bin/bash
Run the server
The server starts with a single command ready to use
Local
micro server
Docker
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.
Usage
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
api
auth
broker
config
events
network
proxy
registry
runtime
server
store
Create a Service
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
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 github.com/micro/services/helloworld
Check status of running service
$ 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
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 (
"context"
"fmt"
"time"
"github.com/micro/micro/v3/service"
pb "github.com/micro/services/helloworld/proto"
)
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)
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"),
)
// new helloworld client
hw := pb.NewHelloworldService("helloworld", srv.Client())
// run the client caller
go callService(hw)
// run the service
service.Run()
}
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 (
"fmt"
"os"
"github.com/micro/micro-go"
)
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
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.
Web Dashboard
Use services via the web with the Micro Web dashboard
micro web
Browse to localhost:8082
License
See [LICENSE](LICENSE) which makes use of Apache 2.0.
Updates
Follow on Twitter for updates
*Note that all licence references and agreements mentioned in the micro README section above
are relevant to that project's source code only.