Design your client: go way

DESIGN YOUR CLIENTMike Kabischev

JUNO
▸250k lines of code
▸~70 microservices
▸hundreds of running containers
▸thousands RPS
▸40+ backend engineers

CODE BELONGS TO THE
TEAM, NOT THE INDIVIDUAL

CLEAN CODE
▸Simple
▸Adaptable
▸Testable

3-RD PARTY
SERVICE A SERVICE B SERVICE C

// HTTPClient wraps httpClient
type HTTPClient struct {
httpClient *http.Client
}
// Do sends HTTP request
func (c *HTTPClient) Do(r *http.Request) (*http.Response, error) {
return http.DefaultClient.Do(r)
}
HTTP CLIENT

HTTP CLIENT
‣Authorization
‣Logging
‣Instrumentation
‣Backoff retries
‣Load balancing

// Do sends HTTP request with authorization, load balancing,
// retries, metrics & logging
func (c *HTTPClient) Do(r *http.Request) (res *http.Response, err error) {
    r.Header.Add("Authorization", c.AuthToken)
    for i := 0; i < c.RetryAttempts; i++ {
        r.URL.Host = c.Backends[rand.Intn(len(c.Backends))]
        c.Logger.Printf("make HTTP call. Method: %v. URL: %v", r.Method, r.URL)
        start := time.Now()
        res, err = http.DefaultClient.Do(r)
        c.DurationSummary.Observe(time.Since(start).Seconds())
        if err != nil {
            c.Logger.Printf("error while making HTTP call: %v", err)
            time.Sleep(time.Duration(i) * c.RetryDelay)
            continue
        }
        break
    }
    c.Logger.Printf("response code: %v", res.StatusCode)
    return res, err
}
HTTP CLIENT

EVERYTHING IS ALREADY INVENTED

// A Handler responds to an HTTP request.
type Handler interface {
ServeHTTP(ResponseWriter, *Request)
}
// The HandlerFunc type is an adapter to allow the use of
// ordinary functions as HTTP handlers. If f is a function
// with the appropriate signature, HandlerFunc(f) is a
// Handler that calls f.
type HandlerFunc func(ResponseWriter, *Request)
// ServeHTTP calls f(w, r).
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
f(w, r)
}
HTTP HANDLERS

MIDDLEWARE
// Middleware adds additional behaviour to handler
type Middleware func(http.Handler) http.Handler

MIDDLEWARE CHAIN
HANDLERREQUEST
Middleware A
Middleware B
Middleware C

MIDDLEWARE CHAIN
HANDLERRESPONSE
Middleware A
Middleware B
Middleware C

MIDDLEWARE CHAIN
CLIENTRESPONSE
Middleware A
Middleware B
Middleware C

MIDDLEWARE CHAIN
HANDLER RESPONSE
Middleware A
Middleware B
Middleware C

CLIENT INTERFACE
// Client is an interface supported by http.Client
type Client interface {
Do(req *http.Request) (*http.Response, error)
}
// ClientFn is a function that implements Client
type ClientFn func(*http.Request) (*http.Response, error)
// Do is an implementation of Client interface
func (c ClientFn) Do(r *http.Request) (*http.Response, error) {
return c(r)
}

MIDDLEWARE
// Middleware adds additional behaviour to Client
type Middleware func(Client) Client

LOGGING
// Logging returns a Middleware that logs request
func Logging(l *log.Logger) Middleware {
    return func(c Client) Client {
        return ClientFn(func(r *http.Request) (*http.Response, error) {
            l.Printf("HTTP call. Method: %v. URL: %v", r.Method, r.URL)
            return c.Do(r)
        })
    }
}

HEADERS
// Header adds specified header to request
func Header(key, value string) Middleware {
            r.Header.Add(key, value)
            return c.Do(r)
        })
    }
}
// BasicAuthorization adds header for Basic HTTP Authorization
func BasicAuthorization(username, password string) Middleware {
    value := []byte(username + ":" + password)
    encoded := base64.StdEncoding.EncodeToString(value)
    return Header("Authorization", "Basic "+encoded)
}

METRICS
// Metrics returns a Middleware that measures the time taken by request
func Metrics(s prometheus.Summary) Middleware {
            defer func(t time.Time) {
                s.Observe(time.Since(t).Seconds())
            }(time.Now())
            return c.Do(r)
        })
    }
}

BACKOFF
// Backoff returns a Middleware that makes configured number of attemps
// to make HTTP call
func Backoff(attemps int, delay time.Duration) Middleware {
        return ClientFn(func(r *http.Request) (res *http.Response, err error) {
            for i := 0; i < attemps; i++ {
                if res, err := c.Do(r); err == nil {
                    break
                }
                time.Sleep(time.Duration(i) * delay)
            }
            return res, err
        })
    }
}

LOAD BALANCING
// LoadBalancing returns a Middleware that chooses random backend from
// the specified list
func LoadBalancing(backends ...string) Middleware {
            r.URL.Host = backends[rand.Intn(len(backends))]
            return c.Do®
        })
    }
}

RECOVER
// Recover returns a middleware that recovers all panics
func Recover() Middleware {
        return ClientFn(func(r *http.Request) (res *http.Response, err error) {
            defer func() {
                if r := recover(); r != nil {
                    err = fmt.Errorf("recovered panic: %v", r)
                }
            }()
            return c.Do(r)
        })
    }
}

MIDDLEWARE CHAIN
// Chain wraps a Client c with all the given middlewares
func Chain(c Client, mw ...Middleware) Client {
    result := c
    for _, middleware := range mw {
        result = middleware(result)
    }
    return result
}

MIDDLEWARE CHAIN
client := Chain(
&http.Client{},
Logging(log.New(os.Stdout, "http: ", log.LstdFlags)),
)

MIDDLEWARE CHAIN
client := Chain(
    &http.Client{},
    BasicAuthorization("username", "password"),
)

MIDDLEWARE CHAIN
client := Chain(
    &http.Client{},
    Metrics(NewSummary("request_duration_seconds")),
)

MIDDLEWARE CHAIN
client := Chain(
    &http.Client{},
    Backoff(3, 20*time.Millisecond),
)

MIDDLEWARE CHAIN
client := Chain(
    &http.Client{},
    LoadBalancing("instance01", "instance02", "instance03"),
)

MIDDLEWARE CHAIN
client := Chain(
    &http.Client{},
LoadBalancing("instance01", "instance02", "instance03"),
    Recover(),
)

http://idiomaticgo.com/post/best-practice/accept-interfaces-return-structs/
ACCEPT INTERFACES
RETURN STRUCTS

https://github.com/gojuno/go-zooz
GO WAY

NOT GO WAY
googlemaps.github.io/maps
github.com/aws/aws-sdk-go
github.com/coreos/go-etcd
github.com/moby/moby
github.com/openzipkin/zipkin-go-opentracing
github.com/stripe/stripe-go
... and more ...

DON'T FORGET THE BASICS
https://go-proverbs.github.io
https://golang.org/doc/effective_go.html
https://github.com/golang/go/wiki/CodeReviewComments

SIMPLICITY IS COMPLICATED
Rob Pike

Design your client: go way

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (13)

Semelhante a Design your client: go way

Semelhante a Design your client: go way (20)

Último

Último (20)

Design your client: go way