Slide 1

Slide 1 text

Simplifying Microservices With Micro

Slide 2

Slide 2 text

Bio Asim Aslam Mostly build platforms Micro Enjoy all things scale Hailo Write lots of cruft Google asimaslam.com @chuhnk

Slide 3

Slide 3 text

What is Micro?

Slide 4

Slide 4 text

Micro is a lot of things... Framework… toolkit… library… community… company… It’s a toolkit! It’s an ecosystem! It’s an overloaded term...sorry! Let’s just talk about the toolkit

Slide 5

Slide 5 text

A microservice toolkit Building blocks {discovery, encoding, communication, etc} Simplifying distributed systems Pluggable framework Sane defaults Low barrier to entry No magic

Slide 6

Slide 6 text

What are microservices?

Slide 7

Slide 7 text

Microservices “Loosely coupled service oriented architecture with a bounded context” @adrianco

Slide 8

Slide 8 text

“Turning a big ball of cruft into smaller balls of cruft which communicate over a network” @chuhnk

Slide 9

Slide 9 text

Monolith Microservices

Slide 10

Slide 10 text

Why microservices?

Slide 11

Slide 11 text

So many reasons 1. The monolith becomes brittle as it grows 2. Most large scale systems are naturally distributed 3. Teams are easier to scale with microservices 4. Faster development cycles 5. Independently managed services 6. More enjoyable to write 7. So many more reasons 8. Do you really like monoliths? 9. Insert more reasons here

Slide 12

Slide 12 text

But to be clear There are tradeoffs Operational overhead Many moving parts aka distributed Requires a different set of skills Not the answer for everything! Be pragmatic!

Slide 13

Slide 13 text

Why a toolkit?

Slide 14

Slide 14 text

Building distributed systems is still hard.

Slide 15

Slide 15 text

Distributed Systems Fallacies 1. The network is reliable 2. Latency is zero 3. Bandwidth is infinite 4. The network is secure 5. Topology doesn’t change 6. There is one administrator 7. Transport code is zero 8. The network is homogeneous

Slide 16

Slide 16 text

No content

Slide 17

Slide 17 text

No content

Slide 18

Slide 18 text

No content

Slide 19

Slide 19 text

How do I actually write distributed systems?

Slide 20

Slide 20 text

The origin of Micro

Slide 21

Slide 21 text

The Motivation 2014 Nothing really out there Enjoyed the Hailo way of building services We had no plans to open source Everyone was building bespoke in-house frameworks Wanted to rally around one OSS effort

Slide 22

Slide 22 text

Humble Beginnings Started with go-micro A pluggable RPC framework Service discovery, encoding, synch/asynch communication Leveraged youtube/vitess/rpcplus Open sourced January 2015

Slide 23

Slide 23 text

Evolved into a toolkit Lots of plugins for go-micro Multiple companies in production Sponsored by Sixt Working full time on Micro Present Day

Slide 24

Slide 24 text

The Go Landscape

Slide 25

Slide 25 text

The Past 2014 net/http net/rpc gorilla/rpc kite custom in-house framework ???

Slide 26

Slide 26 text

The Present 2016 gizmo net/http go-kit net/rpc gRPC gorilla/rpc micro in-house frameworks Plus many more!

Slide 27

Slide 27 text

Beyond Go Netflix OSS Java Seneca Node.JS Nameko Python Finagle JVM Linkerd Agnostic

Slide 28

Slide 28 text

The Micro Toolkit

Slide 29

Slide 29 text

The Toolkit github.com/micro/micro Fundamental Building blocks Go-micro (RPC Framework) Sidecar (HTTP Proxy) API (HTTP => RPC) Web (UI + Proxy) CLI (Terminal) Bot (Hubot)

Slide 30

Slide 30 text

go-micro github.com/micro/go-micro Pluggable RPC framework Strongly defined interfaces Addresses core requirements for microservices Sane defaults; consul, http, {json, proto}-rpc Extensible via wrappers/middleware

Slide 31

Slide 31 text

go-micro features Service discovery Message encoding RPC client/server Request-Response Publish-Subscribe Client side load balancing Service Client Server Transport Selector Registry Codec Broker

Slide 32

Slide 32 text

Pluggable

Slide 33

Slide 33 text

Interfaces A way to specify the behavior of an object If something can do this then it can be used here

Slide 34

Slide 34 text

Registry Service Discovery type Registry interface { Register(*Service, ...RegisterOption) error Deregister(*Service) error GetService(string) ([]*Service, error) ListServices() ([]*Service, error) Watch() (Watcher, error) String() string }

Slide 35

Slide 35 text

Consul Implement the interface type consulRegistry struct {} func (c *consulRegistry) Register(*Service, ...RegisterOption) error {…} func (c *consulRegistry) Deregister(*Service) error {…} func (c *consulRegistry) GetService(string) ([]*Service, error) {…} func (c *consulRegistry) ListServices() ([]*Service, error) {…} func (c *consulRegistry) Watch() (Watcher, error) {…} func (c *consulRegistry) String() string { return "consul" } func NewRegistry(...Option) Registry { return &consulRegistry{} }

Slide 36

Slide 36 text

Transport Request-Response type Transport interface { Dial(addr string, opts ...DialOption) (Client, error) Listen(addr string, opts ...ListenOption) (Listener, error) String() string } type Listener interface { Addr() string Close() error Accept(func(Socket)) error }

Slide 37

Slide 37 text

Mock Testing type mockTransport struct {} func (m *mockTransport) Dial(string, ...DialOption) (Client, error) {…} func (m *mockTransport) Listen(string, ...ListenOption) (Listener, error) {…} func (m *mockTransport) String() string { return "mock" } func NewTransport(opts ...Option) Transport { return &mockTransport{} }

Slide 38

Slide 38 text

Writing a service

Slide 39

Slide 39 text

go-micro define API syntax = "proto3"; service Greeter { rpc Hello(Request) returns (Response) {} } message Request { string name = 1; } message Response { string greeting = 1; }

Slide 40

Slide 40 text

go-micro define handler import ( "github.com/path/to/proto" "golang.org/x/net/context" ) type Greeter struct{} func (g *Greeter) Hello(ctx context.Context, req *proto.Request, rsp *proto.Response) error { rsp.Greeting = "Hello " + req.Name return nil }

Slide 41

Slide 41 text

go-micro create service service := micro.NewService( micro.Name("com.example.srv.greeter"), micro.Version("1.0.0"), ) service.Init() proto.RegisterGreeterHandler(service.Server(), new(Greeter)) if err := service.Run(); err != nil { log.Fatal(err) }

Slide 42

Slide 42 text

go-micro call service greeter := proto.NewGreeterClient("com.example.srv.greeter", service.Client()) rsp, err := greeter.Hello(context.TODO(), &proto.Request{ Name: "John" }) if err != nil { // Blurgh?!? } fmt.Println(rsp.Greeting) // Hello John

Slide 43

Slide 43 text

Beneath the covers

Slide 44

Slide 44 text

go-micro service.Run Generate service definition {Name, Version, Address...} Register with service discovery Listen and accept requests Decode and handle requests Optionally heartbeat with discovery

Slide 45

Slide 45 text

go-micro client.Call(“service”) Request encoding Service lookup Node selection Connection pooling Retries, timeouts, backoff Oh and making the request

Slide 46

Slide 46 text

What about rate limiting, circuit breaking, authentication, etc

Slide 47

Slide 47 text

Wrappers

Slide 48

Slide 48 text

Decorator Pattern A design pattern allowing behavior to be added to an individual object, without affecting the behavior of other objects

Slide 49

Slide 49 text

Client or Handler Authentication Circuit breaking Rate limiting Logging Event notifications Instrumentation Context injection

Slide 50

Slide 50 text

go-micro wrappers client type Wrapper func(Client) Client server type HandlerWrapper func(HandlerFunc) HandlerFunc … service := micro.NewService( micro.Name("com.example.srv.foobar"), micro.WrapClient(circuitBreaker(3)), micro.WrapHandler(rateLimiter(10)), )

Slide 51

Slide 51 text

Example Terrible Rate Limit Wrapper func rateLimiter(rate int) server.HandlerWrapper { tokens := make(chan bool, rate) for i := 0; i < rate; i++ { tokens <- true } return func(handler server.HandlerFunc) server.HandlerFunc { return func(ctx context.Context, req server.Request, rsp interface{}) error { token := <-tokens defer func() { tokens <- token }() return handler(ctx, req, rsp) } } }

Slide 52

Slide 52 text

Go forth and write Micro services!

Slide 53

Slide 53 text

Wait... How do I access these things externally?

Slide 54

Slide 54 text

Entry Points

Slide 55

Slide 55 text

API > micro api External gateway aka API Gateway API service layer HTTP => RPC or Reverse Proxy Path based resolution /[service]/[method] Zero config

Slide 56

Slide 56 text

API > micro api

Slide 57

Slide 57 text

Web > micro web Dashboard Proxy Web apps as microservices First class citizens

Slide 58

Slide 58 text

Logical separation of responsibilities

Slide 59

Slide 59 text

Sidecar > micro sidecar Replicates the features of go-micro as a HTTP interface * CLI Proxy for remote environments with --proxy_address flag

Slide 60

Slide 60 text

CLI > micro get service $ micro get service go.micro.srv.greeter service go.micro.srv.greeter version 1.0.0 Id Address Port Metadata go.micro.srv.greeter-e081eb6a-325f-11e6-8303-68a86d0d36b6 192.168.1.64 62628 server=rpc,registry=consul,transport=http,broker=http Endpoint: Say.Hello Metadata: stream=false Request: { name string } Response: { msg string }

Slide 61

Slide 61 text

Bot > micro bot CLI features via messaging Supports slack and hipchat Pluggable Inputs and Commands Messaging is an entry point much like an API or CLI

Slide 62

Slide 62 text

Beyond the toolkit

Slide 63

Slide 63 text

Plugins “Implement the interface” github.com/micro/go-plugins Swap out backends broker/kafka registry/etcd transport/nats Plus many more! Contributions welcome!

Slide 64

Slide 64 text

Platform “A microservice platform” github.com/micro/go-platform Higher level requirements Authentication Dynamic configuration Distributed tracing Metrics Monitoring Structured logging Synchronisation

Slide 65

Slide 65 text

Community “Share the journey” slack.micro.mu All things microservices Discuss micro Discuss microservices Discuss production use Discuss the tradeoffs

Slide 66

Slide 66 text

In Closing Micro is a toolkit to help simplify microservices Micro is opinionated Micro is not everyone’s cup of tea and that’s ok Micro services are not the answer for everything Pick the tools and patterns that work for you!

Slide 67

Slide 67 text

Thanks! micro.mu @microhq github.com/micro