The document discusses microservices architecture using the Go programming language and Go-kit framework. It provides an overview of microservices and some of the challenges they present. It then discusses using the Go language for microservices due to its simplicity. Go-kit is introduced as a framework for building microservices in Go that addresses transport protocols, endpoints, services, and other concerns through its modular architecture. The document dives into various aspects of the Go-kit architecture including transports, endpoints, services, and instrumentation. Code examples are provided to illustrate implementing a simple math service using Go-kit.

1. Microservices
dengan Go-kit
Bandung, Februari 2020

2. Irfan Aris Nur Hakim
Software Engineer at HOOQ
@irfannurhakim

3. Hari ini
• Sedikit tentang Microservices
• Sedikit tentang Bahasa Pemrograman Go
• Go-kit

4. ! 5 Negara
☀ 100juta++ requests per hari
📽 20juta++ streaming minutes per hari
⚡ 50Gbps++ bandwidth saat puncak
🌻 50++ services

5. Microservices

7. Microservices
• Ditulis dalam bahasa pemgorgraman apa pun, dan
framework apa pun.
• Independen; kode, versi, deployment, scaled.
• Berinteraksi dengan microservices lainnya melalui interfaces
atau protokol lain yang terdefinisi - kontrak.
• Mempunyai alamat/nama yang unik (URLs) untuk digunakan
dalam mengaksesnya.
• Tetap konsisten dan tersedia dimana terjadinya suatu
kegagalan.

8. –Peter Bourgon
Microservices solve organizational problems
~
Microservices cause technical problems

10. Masalah
• Dibutuhkan domain bisnis yang telah terdifinisi dengan baik
untuk menghasilkan API yang stabil.
• Tidak ada lagi shared-database.
• Testing yang menjadi sangat sulit.
• Pipeline - Memerlukan kultur dev/ops yang berjalan.
• Monitoring dan instrumentasi — tail -f? Nagios & New Relic?
Ha! Distributed tracing?
• Keamanan.

11. Go

12. Go
• Sangan mudah dipelajari, dikuasai, dan di-maintain.
• Kompilasi cepat.
• Native.
• Statically Typed.
• Koleksi Standard Library yang lengkap.
• Garbage collected.
• dll

13. Go-Kit
Kenapa dibuat?

14. Komparasi
• Micro (go)
• Finagle (scala)
• Spring Boot (java)
• Tokio (rust)

15. Tinjauan Arsitektur
• Transport
• Endpoint
• Service
Terdiri dari tiga komponen utama:

16. Tinjauan Arsitektur
Source code dependencies can only point inwards. In other
words, the source code of each circle can only access code
in an inner circle but never any code in an outer circle.

17. Request & Response
Transport ———— Endpoint ———— Service
Request
Response

18. Simple Svc
// SimpleService describes a service that adds things together.
type SimpleService interface {
Sum(a, b int) (int, error)
Concat(a, b string) (string, error)
}
type simpleService struct{}
func (s *simpleService) Sum(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 *simpleService) Concat(a, b string) (string, error) {
if len(a)+len(b) > maxLen {
return "", ErrMaxSizeExceeded
}
return a + b, nil
}

19. Simple Svc
// ServeHTTP turns simpleService into an HTTP handler
func (s *simpleService) ServeHTTP(w http.ResponseWriter, r *http.Request) {
switch r.URL.Path[1:] {
case “sum":
keys := r.URL.Query()
a, _ := strconv.Atoi(keys.Get("a"))
b, _ := strconv.Atoi(keys.Get("b"))
c, err := s.Sum(a, b)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
fmt.Fprintf(w, strconv.Itoa(c))
case "concat":
keys := r.URL.Query()
a := keys.Get("a")
b := keys.Get("b")
c, err := s.Concat(a, b)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
fmt.Fprintf(w, c)
}
}

20. Simple Svc
func main() {
ss := &simpleService{}
http.ListenAndServe(":9090", ss)
}

21. Core
Logic
Transport

22. Core
Logic
Logging
Transport

23. Logging
func (s *simpleService) ServeHTTP(w http.ResponseWriter, r *http.Request) {
switch r.URL.Path[1:] {
case "sum":
keys := r.URL.Query()
a, _ := strconv.Atoi(keys.Get("a"))
b, _ := strconv.Atoi(keys.Get("b"))
c, err := s.Sum(a, b)
if err != nil {
code := http.StatusInternalServerError
http.Error(w, err.Error(), code)
log.Printf("%s: %s %s: %d", r.RemoteAddr, r.Method, r.URL.Path[1:], code)
return
}
fmt.Fprintf(w, strconv.Itoa(c))
log.Printf("%s: %s %s: %d", r.RemoteAddr, r.Method, r.URL.Path[1:], 200)

24. Logging
case "concat":
keys := r.URL.Query()
a := keys.Get("a")
b := keys.Get("b")
c, err := s.Concat(a, b)
if err != nil {
code := http.StatusInternalServerError
http.Error(w, err.Error(), code)
log.Printf("%s: %s %s: %d", r.RemoteAddr, r.Method, r.URL.Path[1:], code)
return
}
fmt.Fprintf(w, c)
log.Printf("%s: %s %s: %d", r.RemoteAddr, r.Method, r.URL.Path[1:], 200)
}
}

25. Logging
func main() {
ss := &simpleService{}
log.Printf(“listening:9090")
log.Fatal(http.ListenAndServe(":9090", ss))
}

26. Core
Logic
Logging
Metrics
Transport

27. Instrumentasi
var dur = prometheus.NewSummaryVec(prometheus.SummaryOpts{
Namespace: "simple_space",
Subsystem: "simple_service",
Name: "http_request_duration_seconds",
Help: "Time spent serving HTTP requests.",
}, []string{"method", "status_code"})

28. Instrumentasi
func (s *simpleService) ServeHTTP(w http.ResponseWriter, r *http.Request) {
begin := time.Now()
switch r.URL.Path[1:] {
case "sum":
keys := r.URL.Query()
a, _ := strconv.Atoi(keys.Get("a"))
b, _ := strconv.Atoi(keys.Get("b"))
c, err := s.Sum(a, b)
if err != nil {
code := http.StatusInternalServerError
http.Error(w, err.Error(), code)
log.Printf("%s: %s %s: %d", r.RemoteAddr, r.Method, r.URL.Path[1:], code)
dur.WithLabelValues(r.URL.Path[1:],
fmt.Sprint(code)).Observe(time.Since(begin).Seconds())
return
}
fmt.Fprintf(w, strconv.Itoa(c))
log.Printf("%s: %s %s: %d", r.RemoteAddr, r.Method, r.URL.Path[1:], 200)

29. Instrumentasi
case "concat":
keys := r.URL.Query()
a := keys.Get("a")
b := keys.Get("b")
c, err := s.Concat(a, b)
if err != nil {
code := http.StatusInternalServerError
http.Error(w, err.Error(), code)
log.Printf("%s: %s %s: %d", r.RemoteAddr, r.Method, r.URL.Path[1:], code)
dur.WithLabelValues(r.URL.Path[1:],
fmt.Sprint(code)).Observe(time.Since(begin).Seconds())
return
}
fmt.Fprintf(w, c)
log.Printf("%s: %s %s: %d", r.RemoteAddr, r.Method, r.URL.Path[1:], 200)
dur.WithLabelValues(r.URL.Path[1:],
fmt.Sprint(200)).Observe(time.Since(begin).Seconds())
}
}

30. Core
Logic
Logging
Metrics
Circuit
Breaker
Rate
Limiter
Transport
Audit
Logging
Tracing:(

31. Business logic masih bersih, tapi untuk handler tadi jadi “Mixed concern”

32. Tinjauan Arsitektur

33. Transport Layer
• Layer paling luar, untuk komunikasi/akses.
• Mendukung beberapa protokol komunikasi, diantaranya
HTTP, gRPC, AMQP, Thirft, NATS, dll.
• Satu microservices bisa dipasang beberapa jenis
transport.
• Decoder/Encoder
• Kirim data ke layer selanjutnya —> Endpoint Layer

34. HTTP
// NewHTTPHandler returns an HTTP handler that makes a set of endpoints
// available on predefined paths.
func NewHTTPHandler(endpoints addendpoint.Set, otTracer stdopentracing.Tracer, zipkinTracer *stdzipkin.Tracer, logger
log.Logger) http.Handler {
options := []httptransport.ServerOption{
httptransport.ServerErrorEncoder(errorEncoder),
httptransport.ServerErrorHandler(transport.NewLogErrorHandler(logger)),
}
m := http.NewServeMux()
m.Handle("/sum", httptransport.NewServer(
endpoints.SumEndpoint,
decodeHTTPSumRequest,
encodeHTTPGenericResponse,
append(options, httptransport.ServerBefore(opentracing.HTTPToContext(otTracer, "Sum", logger)))...,
))
m.Handle("/concat", httptransport.NewServer(
endpoints.ConcatEndpoint,
decodeHTTPConcatRequest,
encodeHTTPGenericResponse,
append(options, httptransport.ServerBefore(opentracing.HTTPToContext(otTracer, "Concat", logger)))...,
))
return m
}

35. HTTP
// decodeHTTPSumRequest is a transport/http.DecodeRequestFunc that decodes a
// JSON-encoded sum request from the HTTP request body. Primarily useful in a
// server.
func decodeHTTPSumRequest(_ context.Context, r *http.Request) (interface{}, error) {
var req addendpoint.SumRequest
err := json.NewDecoder(r.Body).Decode(&req)
return req, err
}
// encodeHTTPGenericResponse is a transport/http.EncodeResponseFunc that encodes
// the response as JSON to the response writer. Primarily useful in a server.
func encodeHTTPGenericResponse(ctx context.Context, w http.ResponseWriter, response interface{}) error {
if f, ok := response.(endpoint.Failer); ok && f.Failed() != nil {
errorEncoder(ctx, f.Failed(), w)
return nil
}
w.Header().Set("Content-Type", "application/json; charset=utf-8")
return json.NewEncoder(w).Encode(response)
}

36. gRPC
// NewGRPCServer makes a set of endpoints available as a gRPC AddServer.
func NewGRPCServer(endpoints addendpoint.Set, otTracer stdopentracing.Tracer, zipkinTracer *stdzipkin.Tracer, logger
log.Logger) pb.AddServer {
options := []grpctransport.ServerOption{
grpctransport.ServerErrorHandler(transport.NewLogErrorHandler(logger)),
}
return &grpcServer{
sum: grpctransport.NewServer(
endpoints.SumEndpoint,
decodeGRPCSumRequest,
encodeGRPCSumResponse,
append(options, grpctransport.ServerBefore(opentracing.GRPCToContext(otTracer, "Sum", logger)))...,
),
concat: grpctransport.NewServer(
endpoints.ConcatEndpoint,
decodeGRPCConcatRequest,
encodeGRPCConcatResponse,
append(options, grpctransport.ServerBefore(opentracing.GRPCToContext(otTracer, "Concat", logger)))...,
),
}
}

37. Endpoint Layer
• Seperti handler pada sebuah controller.
• Terima interface{} sbg Request, kembalikan interface{}
Response.
• Setiap endpoint ini mengekspos service terhadap dunia
luar melalui Transport.

38. // MakeSumEndpoint constructs a Sum endpoint wrapping the service.
func MakeSumEndpoint(s addservice.Service) endpoint.Endpoint {
return func(ctx context.Context, request interface{}) (response interface{}, err error) {
req := request.(SumRequest)
v, err := s.Sum(ctx, req.A, req.B)
return SumResponse{V: v, Err: err}, nil
}
}
// MakeConcatEndpoint constructs a Concat endpoint wrapping the service.
func MakeConcatEndpoint(s addservice.Service) endpoint.Endpoint {
return func(ctx context.Context, request interface{}) (response interface{}, err error) {
req := request.(ConcatRequest)
v, err := s.Concat(ctx, req.A, req.B)
return ConcatResponse{V: v, Err: err}, nil
}
}

39. // MakeSumEndpoint constructs a Sum endpoint wrapping the service.
func MakeSumEndpoint(s addservice.Service) endpoint.Endpoint {
return func(ctx context.Context, request interface{}) (response interface{}, err error) {
req := request.(SumRequest)
v, err := s.Sum(ctx, req.A, req.B)
return SumResponse{V: v, Err: err}, nil
}
}
// MakeConcatEndpoint constructs a Concat endpoint wrapping the service.
func MakeConcatEndpoint(s addservice.Service) endpoint.Endpoint {
return func(ctx context.Context, request interface{}) (response interface{}, err error) {
req := request.(ConcatRequest)
v, err := s.Concat(ctx, req.A, req.B)
return ConcatResponse{V: v, Err: err}, nil
}
}

40. // MakeSumEndpoint constructs a Sum endpoint wrapping the service.
func MakeSumEndpoint(s addservice.Service) endpoint.Endpoint {
return func(ctx context.Context, request interface{}) (response interface{}, err error) {
req := request.(SumRequest)
v, err := s.Sum(ctx, req.A, req.B)
return SumResponse{V: v, Err: err}, nil
}
}
// MakeConcatEndpoint constructs a Concat endpoint wrapping the service.
func MakeConcatEndpoint(s addservice.Service) endpoint.Endpoint {
return func(ctx context.Context, request interface{}) (response interface{}, err error) {
req := request.(ConcatRequest)
v, err := s.Concat(ctx, req.A, req.B)
return ConcatResponse{V: v, Err: err}, nil
}
}

41. // MakeSumEndpoint constructs a Sum endpoint wrapping the service.
func MakeSumEndpoint(s addservice.Service) endpoint.Endpoint {
return func(ctx context.Context, request interface{}) (response interface{}, err error) {
req := request.(SumRequest)
v, err := s.Sum(ctx, req.A, req.B)
return SumResponse{V: v, Err: err}, nil
}
}
// MakeConcatEndpoint constructs a Concat endpoint wrapping the service.
func MakeConcatEndpoint(s addservice.Service) endpoint.Endpoint {
return func(ctx context.Context, request interface{}) (response interface{}, err error) {
req := request.(ConcatRequest)
v, err := s.Concat(ctx, req.A, req.B)
return ConcatResponse{V: v, Err: err}, nil
}
}

42. Service Layer
• Bagian dimana business logic diimplementasi.
• Biasanya dimodelkan dengan interface, dimana
implementasi konkretnya berisi business logic.
• Tidak ada knowledge terhadap layer sebelumnya,
misalnya HTTP Headers (Transport Layer).

43. // Service describes a service that adds things together.
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
}
// Concat implements Service.
func (s basicService) Concat(_ context.Context, a, b string) (string, error) {
if len(a)+len(b) > maxLen {
return "", ErrMaxSizeExceeded
}
return a + b, nil
}

44. // Service describes a service that adds things together.
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
}
// Concat implements Service.
func (s basicService) Concat(_ context.Context, a, b string) (string, error) {
if len(a)+len(b) > maxLen {
return "", ErrMaxSizeExceeded
}
return a + b, nil
}

45. // Service describes a service that adds things together.
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
}
// Concat implements Service.
func (s basicService) Concat(_ context.Context, a, b string) (string, error) {
if len(a)+len(b) > maxLen {
return "", ErrMaxSizeExceeded
}
return a + b, nil
}

46. // Service describes a service that adds things together.
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
}
// Concat implements Service.
func (s basicService) Concat(_ context.Context, a, b string) (string, error) {
if len(a)+len(b) > maxLen {
return "", ErrMaxSizeExceeded
}
return a + b, nil
}

47. Middlewares
• Bentuk konkret dari konsep separation of concern dengan
menggunakan decorator pattern.
• Membungkus endpoint atau services untuk menambah
fungsionalitas yang generik, misal logging, rate limiting
atau distributed tracing.
• Ada 2 tipe, Endpoint Middleware & Endpoint Service.

48. Endpoint Middleware
func InstrumentingMiddleware(duration metrics.Histogram) endpoint.Middleware {
return func(next endpoint.Endpoint) endpoint.Endpoint {
return func(ctx context.Context, request interface{}) (response interface{}, err error) {
defer func(begin time.Time) {
duration.With("success", fmt.Sprint(err == nil)).Observe(time.Since(begin).Seconds())
}(time.Now())
return next(ctx, request)
}
}
}

49. func InstrumentingMiddleware(duration metrics.Histogram) endpoint.Middleware {
return func(next endpoint.Endpoint) endpoint.Endpoint {
return func(ctx context.Context, request interface{}) (response interface{}, err error) {
defer func(begin time.Time) {
duration.With("success", fmt.Sprint(err == nil)).Observe(time.Since(begin).Seconds())
}(time.Now())
return next(ctx, request)
}
}
}
Endpoint Middleware

50. func InstrumentingMiddleware(duration metrics.Histogram) endpoint.Middleware {
return func(next endpoint.Endpoint) endpoint.Endpoint {
return func(ctx context.Context, request interface{}) (response interface{}, err error) {
defer func(begin time.Time) {
duration.With("success", fmt.Sprint(err == nil)).Observe(time.Since(begin).Seconds())
}(time.Now())
return next(ctx, request)
}
}
}
Endpoint Middleware

51. // Middleware describes a service (as opposed to endpoint) middleware.
type Middleware func(Service) Service
// LoggingMiddleware takes a logger as a dependency
// and returns a service Middleware.
func LoggingMiddleware(logger log.Logger) Middleware {
return func(next Service) Service {
return loggingMiddleware{logger, next}
}
}
type loggingMiddleware struct {
logger log.Logger
next Service
}
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)
}
func (mw loggingMiddleware) Concat(ctx context.Context, a, b string) (v string, err error) {
defer func() {
mw.logger.Log("method", "Concat", "a", a, "b", b, "v", v, "err", err)
}()
return mw.next.Concat(ctx, a, b)
}

52. // Middleware describes a service (as opposed to endpoint) middleware.
type Middleware func(Service) Service
// LoggingMiddleware takes a logger as a dependency
// and returns a service Middleware.
func LoggingMiddleware(logger log.Logger) Middleware {
return func(next Service) Service {
return loggingMiddleware{logger, next}
}
}
type loggingMiddleware struct {
logger log.Logger
next Service
}
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)
}
func (mw loggingMiddleware) Concat(ctx context.Context, a, b string) (v string, err error) {
defer func() {
mw.logger.Log("method", "Concat", "a", a, "b", b, "v", v, "err", err)
}()
return mw.next.Concat(ctx, a, b)
}

53. // Middleware describes a service (as opposed to endpoint) middleware.
type Middleware func(Service) Service
// LoggingMiddleware takes a logger as a dependency
// and returns a service Middleware.
func LoggingMiddleware(logger log.Logger) Middleware {
return func(next Service) Service {
return loggingMiddleware{logger, next}
}
}
type loggingMiddleware struct {
logger log.Logger
next Service
}
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)
}
func (mw loggingMiddleware) Concat(ctx context.Context, a, b string) (v string, err error) {
defer func() {
mw.logger.Log("method", "Concat", "a", a, "b", b, "v", v, "err", err)
}()
return mw.next.Concat(ctx, a, b)
}

54. // Middleware describes a service (as opposed to endpoint) middleware.
type Middleware func(Service) Service
// LoggingMiddleware takes a logger as a dependency
// and returns a service Middleware.
func LoggingMiddleware(logger log.Logger) Middleware {
return func(next Service) Service {
return loggingMiddleware{logger, next}
}
}
type loggingMiddleware struct {
logger log.Logger
next Service
}
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)
}
func (mw loggingMiddleware) Concat(ctx context.Context, a, b string) (v string, err error) {
defer func() {
mw.logger.Log("method", "Concat", "a", a, "b", b, "v", v, "err", err)
}()
return mw.next.Concat(ctx, a, b)
}

55. // Middleware describes a service (as opposed to endpoint) middleware.
type Middleware func(Service) Service
// LoggingMiddleware takes a logger as a dependency
// and returns a service Middleware.
func LoggingMiddleware(logger log.Logger) Middleware {
return func(next Service) Service {
return loggingMiddleware{logger, next}
}
}
type loggingMiddleware struct {
logger log.Logger
next Service
}
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)
}
func (mw loggingMiddleware) Concat(ctx context.Context, a, b string) (v string, err error) {
defer func() {
mw.logger.Log("method", "Concat", "a", a, "b", b, "v", v, "err", err)
}()
return mw.next.Concat(ctx, a, b)
}

56. main.go
// Build the layers of the service "onion" from the inside out. First, the
// business logic service; then, the set of endpoints that wrap the service;
// and finally, a series of concrete transport adapters. The adapters, like
// the HTTP handler or the gRPC server, are the bridge between Go kit and
// the interfaces that the transports expect. Note that we're not binding
// them to ports or anything yet; we'll do that next.
var (
service = addservice.New(logger, ints, chars)
endpoints = addendpoint.New(service, logger, duration, tracer, zipkinTracer)
httpHandler = addtransport.NewHTTPHandler(endpoints, tracer, zipkinTracer, logger)
grpcServer = addtransport.NewGRPCServer(endpoints, tracer, zipkinTracer, logger)
)

57. main.go
var g group.Group
{
// The HTTP listener mounts the Go kit HTTP handler we created.
httpListener, err := net.Listen("tcp", *httpAddr)
if err != nil {
logger.Log("transport", "HTTP", "during", "Listen", "err", err)
os.Exit(1)
}
g.Add(func() error {
logger.Log("transport", "HTTP", "addr", *httpAddr)
return http.Serve(httpListener, httpHandler)
}, func(error) {
httpListener.Close()
})
}
logger.Log("exit", g.Run())

58. Sejauh ini…
• Cenderung susah dipahami diawal.
• Verbose.
• Sangat gampang ketika ada perubahan requirement.
• Banyak dukungan library.
• Pakai apa yang kita butuhkan.

59. Terus..
• Implementasi core business logic di service layer, dengan
mendefinisikan interface plus dengan implementasi konkretnya.
• Buat service middleware, disini biasanya utk beberapa fungsi
tambahan, seperti analytics atau logging - intinya yang dibutuhkan
oleh domain business.
• Untuk middleware yang agnostik terhadap domain business, misal
circuit breaker, rate limiter, dll bisa dibuat di endpoint middleware.
• Buat Transport Layer dengan semua decoder/encoder-nya.
• Satukan mereka ❤ di Endpoint Layer.

60. Referensi
• go-kit.io
• https://martinfowler.com/articles/microservices.html
• https://blog.cleancoder.com/uncle-bob/2012/08/13/the-
clean-architecture.html
• https://docs.microsoft.com/en-us/azure/service-fabric/
service-fabric-overview-microservices

61. Terima kasih!