Micro - A microservice toolkit

Micro is a toolkit that provides the fundamental building blocks for writing and managing microservices. The slides are from the Go meetup in London on June 15th 2016.

Transcript

1. Micro A microservice toolkit
2. Bio Asim Aslam Mostly build platforms Micro Enjoy all things scale Hailo Write lots of cruft Google asimaslam.com @chuhnk
3. What is Micro?
4. Micro is too many 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
5. A microservice toolkit A set of building blocks {discovery, communication, etc} Simplifying distributed systems Pluggable framework Sane defaults Low barrier to entry Avoids magic
6. Wait...microservices?
7. Microservices “Loosely coupled service oriented architecture with a bounded context” @adrianco
8. “Turning a big ball of cruft into smaller balls of cruft which communicate over a network” @chuhnk
9. Monolith Microservices
10. OK... but why?
11. 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
12. But to be clear There are tradeoffs.
13. Why a toolkit?
14. Building distributed systems is still hard.
15. 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
16. The cloud will not save us...
17. Containers will not save us...
18. How do I actually write distributed systems?
19. The Origin Story
20. The Motivation 2014 Nothing really out there Enjoyed the Hailo way of building services We had no plans to open source at the time Everyone was building the same thing over and over Wanted to rally around one OSS effort
21. Humble Beginnings Started with go-micro A pluggable RPC framework Service discovery, encoding, synch/asynch communication Leveraged youtube/vitess/rpcplus Open sourced January 2015
22. Evolved into a toolkit Lots of plugins for go-micro Multiple companies in production Sponsored by Sixt Working full time on Micro Present Day
23. The Go Landscape
24. The Past 2014 net/http net/rpc gorilla/rpc kite custom in-house framework ???
25. The Present 2016 gizmo net/http go-kit net/rpc gRPC gorilla/rpc micro in-house frameworks Plus many more!
26. Beyond Go Netflix OSS Java Seneca Node.JS Nameko Python Finagle JVM Linkerd Agnostic
27. The Micro Toolkit
28. 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)
29. 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
30. 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
31. Pluggable
32. Interfaces A way to specify the behavior of an object If something can do this then it can be used here
33. 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 }
34. 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{} }
35. 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 }
36. 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{} }
37. Writing a service
38. go-micro define API syntax = "proto3"; service Greeter { rpc Hello(Request) returns (Response) {} } message Request { string name = 1; } message Response { string greeting = 1; }
39. go-micro define handler import "github.com/path/to/proto" type Greeter struct{} func (g *Greeter) Hello( ctx context.Context, request *proto.Request, response *proto.Response, ) error { response.Greeting = "Hello " + request.Name return nil }
40. 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) }
41. go-micro call service greeter := proto.NewGreeterClient("com.example.srv.greeter", service.Client()) response, err := greeter.Hello(context.TODO(), &proto.Request{ Name: "John" }) if err != nil { // Blurgh?!? } fmt.Println(response.Greeting)
42. Beneath the covers
43. go-micro service.Run Generate service definition Register with service discovery Listen and accept requests Decode and handle requests Optionally heartbeat with discovery
44. go-micro client.Call(“service”) Request encoding Service lookup Node selection Connection pooling Retries, timeouts, backoff Oh and making the request
45. What about rate limiting, circuit breaking, authentication, etc
46. Wrappers
47. Decorator Pattern A design pattern that allows behavior to be added to an individual object, without affecting the behavior of other objects
48. Client or Handler Authentication Circuit breaking Rate limiting Logging Event notifications Instrumentation Context injection
49. 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(breakerClientWrapper), micro.WrapHandler(rateLimiterHandlerWrapper), )
50. How do I access these things externally?
51. Entry Points
52. Sidecar > micro sidecar Replicates the features of go-micro as a HTTP interface Can be used as a proxy for the CLI with --proxy_address
53. API > micro api External gateway API service layer HTTP => RPC or Reverse Proxy Path based resolution /[service]/[method] Zero config
54. API > micro api
55. Web > micro web Dashboard Proxy Web apps as microservices First class citizens
56. 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 }
57. Bot > micro bot CLI features via messaging Supports slack and hipchat Pluggable Inputs and Commands Messaging is an entry point like the API, CLI, etc
58. What’s next?
59. Platform “A microservice platform” github.com/micro/go-platform Higher level requirements Authentication Dynamic configuration Distributed tracing Metrics Monitoring Structured logging Synchronisation
60. Plugins “Implement the interface” github.com/micro/go-plugins Swap out backends broker/kafka registry/etcd transport/nats Plus many more! Contributions welcome!
61. Community “Share the journey” slack.micro.mu All things microservices Discuss micro Discuss microservices Discuss production use Discuss the tradeoffs
62. Multi Language {go, js, java, rs}-micro Multi language support Full implementation? Lightweight client? Use the Sidecar? Help wanted!
63. Thanks! Questions? micro.mu @microhq github.com/micro