Go + microservices = Go kit

Go + microservices = Go kit

Microservices are hard, but Go and Go kit can make them easier.

Eb68eb9603a0e8822eda69e7ca721866?s=128

Peter Bourgon

March 29, 2017
Tweet

Transcript

  1. Go + microservices = Go kit @peterbourgon · Cloud Native

    Con 2017 · Berlin
  2. Go is a good language
 for microservices I want to

    convince you that and maybe Go kit will help
  3. What is Go?

  4. History Date: Sun, 23 Sep 2007 23:33:41 -0700
 From: "Robert

    Griesemer" <gri@google.com>
 To: "Rob 'Commander' Pike" <r@google.com>, ken@google.com
 Subject: prog lang discussion
 ...
 *** General:
 Starting point: C, fix some obvious flaws, remove crud, add a few missing features
 - no includes, instead: import
 - no macros (do we need something instead?)
 - ideally only one file instead of a .h and .c file, module interface 
 should be extracted automatically
 - statements: like in C, though should fix 'switch' statement
 - expressions: like in C, though with caveats (do we need ',' expressions?)
 - essentially strongly typed, but probably w/ support for runtime types
 - want arrays with bounds checking on always (except perhaps in 'unsafe mode'-see section on GC)
 - mechanism to hook up GC (I think that most code can live w/ GC, but for a true systems
 programming language there should be mode w/ full control over memory allocation)
 - support for interfaces (differentiate between concrete, or implementation types, and abstract,
 or interface types)
 - support for nested and anonymous functions/closures (don't pay if not used)
 - a simple compiler should be able to generate decent code
 - the various language mechanisms should result in predictable code
 ...
  5. Go properties • Statically typed • Compiled — fast! •

    Native binaries • Garbage collected • Looks like C • Big standard library • Baked-in concurrency
  6. Go IMO • A breath of fresh air from “kitchen

    sink” languages — cf. Scala • Simple, orthogonal features that aren't surprising — cf. Node • Efficient by default — cf. Python, Ruby • Predictable runtime behavior — cf. JVM languages • Familiar heritage, syntax, and paradigm — cf. Haskell, Elixir
  7. “Simple”

  8. “No magic”

  9. https://talks.golang.org/2012/splash.article

  10. None
  11. Mindshare

  12. Mindshare

  13. Microservices

  14. None
  15. Microservices solve organizational problems
 ~
 Microservices cause
 technical problems

  16. Problems solved • Team is too large to work effectively

    on shared codebase • Teams are blocked on other teams, can't make progress • Communication overhead becomes gigantic • Product velocity stalled
  17. Problems caused • Need well-defined business domains for stable APIs

    • No more shared DB — distributed transactions? • Testing becomes really hard • Require dev/ops culture: devs deploy & operate their work • Job (service) scheduling — manually works, for a while...
  18. Problems caused • Addressability i.e. service discovery • Monitoring and

    instrumentation — tail -f? Nagios & New Relic? Ha! • Distributed tracing? • Build pipelines?? • Security???
  19. None
  20. None
  21. None
  22. None
  23. Concerns for a single service, Sean Treadway, SoundCloud

  24. Enter Go kit

  25. Initial goals • A standard library for microservices • Something

    like Finagle for Go • Adapters, bindings, etc. to common infrastructure components • Play nice in your existing, heterogeneous infrastructure • Structure to tame the beast of incidental complexity
  26. Current goals • Mostly the same • Even less opinionated

    about infrastructure than anticipated • More opinionated about application architecture than anticipated
  27. Non-goals • Messaging patterns other than RPC • Requiring specific

    bits of infrastructure or tooling to work • Acting as an all-in service framework • Re-implementing existing, good solutions to problems
  28. Comparisons • Micro (Go) — very opinionated, all-in, framework-ish •

    Finagle (Scala) — original inspiration, lower-level than Go kit • Spring Boot (Java) — similar abstractions, far more magical • Tokio (Rust) — explicitly a clone of Finagle, lower-level than Go kit
  29. I don’t care if you use Go kit; I do

    care if you use Go I really want to emphasize
  30. Example service

  31. type AddService interface { Sum(a, b int) int Concat(a, b

    string) string }
  32. type AddService interface { Sum(a, b int) (int, error) Concat(a,

    b string) (string, error) }
  33. Naïve first draft

  34. type basicService struct{} func (s basicService) Sum(a, b int) (int,

    error) { return a + b, nil } func (s basicService) Concat(a, b string) (string, error) { return a + b, nil } Core Business Logic
  35. Transport Core Business Logic

  36. func (s basicService) ServeHTTP(w http.ResponseWriter, r *http.Request) { switch r.URL.Path

    { case "/sum":
  37. func (s basicService) ServeHTTP(w http.ResponseWriter, r *http.Request) { switch r.URL.Path

    { case "/sum": var req struct { A int `json:"a"` B int `json:"b"` } if err := json.NewDecoder(r.Body).Decode(&req); err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return }
  38. func (s basicService) ServeHTTP(w http.ResponseWriter, r *http.Request) { switch r.URL.Path

    { case "/sum": var req struct { A int `json:"a"` B int `json:"b"` } if err := json.NewDecoder(r.Body).Decode(&req); err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return } v, err := s.Sum(req.A, req.B) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return }
  39. func (s basicService) ServeHTTP(w http.ResponseWriter, r *http.Request) { switch r.URL.Path

    { case "/sum": var req struct { A int `json:"a"` B int `json:"b"` } if err := json.NewDecoder(r.Body).Decode(&req); err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return } v, err := s.Sum(req.A, req.B) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } w.Header().Set("Content-Type", "application/json; charset=utf-8") json.NewEncoder(w).Encode(map[string]int{"v": v})
  40. case "/concat":

  41. case "/concat": var req struct { A string `json:"a"` B

    string `json:"b"` } if err := json.NewDecoder(r.Body).Decode(&req); err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return }
  42. case "/concat": var req struct { A string `json:"a"` B

    string `json:"b"` } if err := json.NewDecoder(r.Body).Decode(&req); err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return } v, err := s.Concat(req.A, req.B) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return }
  43. case "/concat": var req struct { A string `json:"a"` B

    string `json:"b"` } if err := json.NewDecoder(r.Body).Decode(&req); err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return } v, err := s.Concat(req.A, req.B) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } w.Header().Set("Content-Type", "application/json; charset=utf-8") json.NewEncoder(w).Encode(map[string]string{"v": v})
  44. Transport Core Business Logic App Logging

  45. if err := json.NewDecoder(r.Body).Decode(&req); err != nil { code :=

    http.StatusBadRequest log.Printf("%s: %s: %d", r.RemoteAddr, r.URL, code) http.Error(w, err.Error(), code) return } v, err := s.Sum(req.A, req.B) if err != nil { code := http.StatusInternalServerError log.Printf("%s: %s: %d", r.RemoteAddr, r.URL, code) http.Error(w, err.Error(), code) return } w.Header().Set("Content-Type", "application/json; charset=utf-8") json.NewEncoder(w).Encode(map[string]int{"v": v}) log.Printf("%s: %s: %d", r.RemoteAddr, r.URL, 200)
  46. type basicService struct{} func (s basicService) Sum(a, b int) (v

    int, err error) { defer func() { log.Printf(“Sum(%d,%d)=(%d,%v)”, a, b, v, err) }() return a + b, nil } func (s basicService) Concat(a, b string) (string, error) { defer func() { log.Printf(“Concat(%q,%q)=(%q,%v)”, a, b, v, err) }() return a + b, nil }
  47. Transport Core Business Logic App Logging Metrics

  48. if err := json.NewDecoder(r.Body).Decode(&req); err != nil { code :=

    http.StatusBadRequest log.Printf("%s: %s: %d", r.RemoteAddr, r.URL, code) errorCount.Add(1) http.Error(w, err.Error(), code) return } v, err := s.Sum(req.A, req.B) if err != nil { code := http.StatusInternalServerError log.Printf("%s: %s: %d", r.RemoteAddr, r.URL, code) errorCount.Add(1) http.Error(w, err.Error(), code) return } w.Header().Set("Content-Type", "application/json; charset=utf-8") json.NewEncoder(w).Encode(map[string]int{"v": v}) log.Printf("%s: %s: %d", r.RemoteAddr, r.URL, 200)
 successCount.Add(1)
  49. Transport Core Business Logic App Logging Metrics Tracing Circuit Breaking

    Rate Limiting Audit Logging Service Discovery Deploy Strategy Contract Testing Alerting Caching Strategy Security Service Registry :( :( :( ;( :( :(
  50. The onion model

  51. Transport Operational Metrics Balancing, Limiting, Safety Business Analytics Application Logging

    Service Metrics Business Logic Service Endpoint Transport
  52. http://fideloper.com/hexagonal-architecture

  53. The central rule of The Clean Architecture is the Dependency

    Rule, which says source code dependencies can only point inwards. — http://appliedgo.net/di
  54. Service layer

  55. type Service interface { Sum(ctx context.Context, a, b int) (int,

    error) Concat(ctx context.Context, a, b string) (string, error) }
  56. type Service interface { Sum(ctx context.Context, a, b int) (int,

    error) Concat(ctx context.Context, a, b string) (string, error) } type basicService struct{}
  57. type Service interface { Sum(ctx context.Context, a, b int) (int,

    error) Concat(ctx context.Context, a, b string) (string, error) } type basicService struct{} func (s basicService) Sum(_ context.Context, a, b int) (int, error) { if a == 0 && b == 0 { return 0, ErrTwoZeroes } if (b > 0 && a > (intMax-b)) || (b < 0 && a < (intMin-b)) { return 0, ErrIntOverflow } return a + b, nil }
  58. type Service interface { Sum(ctx context.Context, a, b int) (int,

    error) Concat(ctx context.Context, a, b string) (string, error) } type basicService struct{} func (s basicService) Sum(_ context.Context, a, b int) (int, error) { if a == 0 && b == 0 { return 0, ErrTwoZeroes } if (b > 0 && a > (intMax-b)) || (b < 0 && a < (intMin-b)) { return 0, ErrIntOverflow } return a + b, nil } func (s basicService) Concat(_ context.Context, a, b string) (string, error) { if len(a)+len(b) > maxLen { return "", ErrMaxSizeExceeded } return a+b, nil }
  59. type Middleware func(Service) Service

  60. type Middleware func(Service) Service type loggingMiddleware struct { logger log.Logger

    next Service }
  61. type Middleware func(Service) Service type loggingMiddleware struct { logger log.Logger

    next Service } func NewLoggingMiddleware(logger log.Logger) Middleware { return func(next Service) Service { return loggingMiddleware{logger, next} } }
  62. type Middleware func(Service) Service type loggingMiddleware struct { logger log.Logger

    next Service } func NewLoggingMiddleware(logger log.Logger) Middleware { return func(next Service) Service { return loggingMiddleware{logger, next} } } func (mw loggingMiddleware) Sum(ctx context.Context, a, b int) (v int, err error) { defer func() { mw.logger.Log("method", "Sum", "a", a, "b", b, "v", v, "err", err) }() return mw.next.Sum(ctx, a, b) } // Concat is the same
  63. type Middleware func(Service) Service

  64. type Middleware func(Service) Service type instrumentingMiddleware struct { ints metrics.Counter

    chars metrics.Counter next Service }
  65. type Middleware func(Service) Service type instrumentingMiddleware struct { ints metrics.Counter

    chars metrics.Counter next Service } func NewInstrumentingMiddleware(ints, chars metrics.Counter) Middleware { return func(next Service) Service { return instrumentingMiddleware{ ints: ints, chars: chars, next: next, } } }
  66. type Middleware func(Service) Service type instrumentingMiddleware struct { ints metrics.Counter

    chars metrics.Counter next Service } func NewInstrumentingMiddleware(ints, chars metrics.Counter) Middleware { return func(next Service) Service { return instrumentingMiddleware{ ints: ints, chars: chars, next: next, } } } func (mw instrumentingMiddleware) Sum(ctx context.Context, a, b int) (int, error) { v, err := mw.next.Sum(ctx, a, b) mw.ints.Add(v) return v, err }
  67. And a lot more...!

  68. Endpoint layer

  69. type Endpoint func(req) resp

  70. type Endpoint func(req interface{}) (resp interface{})

  71. type Endpoint func(ctx context.Context, req interface{}) (resp interface{}, err error)

  72. type Endpoint func(ctx context.Context, req interface{}) (resp interface{}, err error)

    func MakeSumEndpoint(s Service) Endpoint { return func(ctx context.Context, req interface{}) (resp interface{}, err error) { request := req.(SumRequest) v, err := s.Sum(ctx, request.A, request.B) return SumResponse{V: v, Err: err}, nil } }
  73. type Endpoint func(ctx context.Context, req interface{}) (resp interface{}, err error)

    func MakeSumEndpoint(s Service) Endpoint { return func(ctx context.Context, req interface{}) (resp interface{}, err error) { request := req.(SumRequest) v, err := s.Sum(ctx, request.A, request.B) return SumResponse{V: v, Err: err}, nil } } type SumRequest struct { A, B int } type SumResponse struct { V int Err error }
  74. type Middleware func(Endpoint) Endpoint

  75. type Middleware func(Endpoint) Endpoint func NewCircuitBreakingMiddleware(cb *gobreaker.CircuitBreaker) Middleware { return

    func(next Endpoint) Endpoint { return func(ctx context.Context, req interface{}) (interface{}, error) { return cb.Execute(func() (interface{}, error) { return next(ctx, req) }) } } }
  76. type Middleware func(Endpoint) Endpoint func NewCircuitBreakingMiddleware(cb *gobreaker.CircuitBreaker) Middleware { return

    func(next Endpoint) Endpoint { return func(ctx context.Context, req interface{}) (interface{}, error) { return cb.Execute(func() (interface{}, error) { return next(ctx, req) }) } } } func NewThrottlingMiddleware(b *ratelimit.Bucket) Middleware { return func(next Endpoint) Endpoint { return func(ctx context.Context, req interface{}) (interface{}, error) { time.Sleep(tb.Take(1)) return next(ctx, request) } } }
  77. Transport layer

  78. Endpoint HTTP, gRPC, etc. Decode
 Request Encode
 Response

  79. HTTP func NewServer( e endpoint.Endpoint, dec DecodeRequestFunc, enc EncodeResponseFunc, options

    ...ServerOption, ) *Server { // ...
 } func (s Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { request, err := s.dec(ctx, r) if err != nil { return }
 response, err := s.e(ctx, request) if err != nil { return } if err := s.enc(ctx, w, response); err != nil { return } }
  80. gRPC func NewServer( e endpoint.Endpoint, dec DecodeRequestFunc, enc EncodeResponseFunc, options

    ...ServerOption, ) *Server { // ...
 } func (s Server) ServeGRPC(ctx Context, req interface{}) (Context, interface{}, request, err := s.dec(ctx, req) if err != nil { s.logger.Log("err", err) return ctx, nil, err } response, err := s.e(ctx, request) if err != nil { return ctx, nil, err } grpcResp, err := s.enc(ctx, response) if err != nil { return ctx, nil, err } return ctx, grpcResp, nil }
  81. HTTP Mux HTTP Server HTTP Server CB CB RL RL

    Concat Sum Logging Service
  82. HTTP Mux gRPC Mux gRPC Server gRPC Server HTTP Server

    HTTP Server CB CB RL RL Concat Sum Logging Service
  83. Simple & non-magical We embrace and extend Go’s philosophy, to

    be in service to software engineering in the large * *
  84. Maintainability Optimize for above all else!

  85. Integration with the
 Cloud Native stack

  86. Prometheus type metricsMiddleware struct { ints metrics.Counter chars metrics.Counter next

    Service } func (mw metricsMiddleware) Sum(ctx context.Context, a, b int) (int, error) { v, err := mw.next.Sum(ctx, a, b) mw.ints.Add(v) return v, err } func (mw metricsMiddleware) Concat(ctx context.Context, a, b string) (string, error) { v, err := mw.next.Concat(ctx, a, b) mw.chars.Add(len(v)) return v, err }
  87. OpenTracing & Zipkin Transport Operational Metrics Balancing, Limiting, Safety Business

    Analytics Application Logging Service Metrics Business Logic Extract Inject Annotate & Collect
  88. OpenTracing & Zipkin Extract Inject Annotate & Collect

  89. Demo

  90. Where to Go from here?

  91. invite.slack.golangbridge.org appliedgo.net gobyexample.com gokit.io

  92. gophercon.com

  93. Thanks @peterbourgon · Cloud Native Con 2017 · Berlin