go kit 是一个分布式的开发工具集&＃xff0c;在大型的组织&＃xff08;业务&＃xff09;中可以用来构建微服务。其解决了分布式系统中的大多数常见问题&＃xff0c;因此&＃xff0c;使用者可以将精力集中在业务逻辑上。
Go kit首先解决了RPC消息模式。其使用了一个抽象的 endpoint 来为每一个RPC建立模型。
endpoint通过被一个server进行实现&＃xff08;implement&＃xff09;&＃xff0c;或是被一个client调用。这是很多 Go kit组件的基本构建代码块。
Circuitbreaker&＃xff08;回路断路器&＃xff09; 模块提供了很多流行的回路断路lib的端点&＃xff08;endpoint&＃xff09;适配器。回路断路器可以避免雪崩&＃xff0c;并且提高了针对间歇性错误的弹性。每一个client的端点都应该封装&＃xff08;wrapped&＃xff09;在回路断路器中。
ratelimit模块提供了到限流器代码包的端点适配器。限流器对服务端&＃xff08;server-client&＃xff09;和客户端&＃xff08;client-side&＃xff09;同等生效。使用限流器可以强制进、出请求量在阈值上限以下。
transport 模块提供了将特定的序列化算法绑定到端点的辅助方法。当前&＃xff0c;Go kit只针对JSON和HTTP提供了辅助方法。如果你的组织使用完整功能的传输层&＃xff0c;典型的方案是使用Go在传输层提供的函数库&＃xff0c;Go kit并不需要来做太多的事情。这些情况&＃xff0c;可以查阅代码例子来理解如何为你的端点写一个适配器。目前&＃xff0c;可以查看 addsvc的代码来理解Transport绑定是如何工作的。我们还提供了针对Thirft,gRPC,net/rpc,和http json的特殊例子。对JSON/RPC和Swagger的支持在计划中。
服务产生的日志是会被延迟消费&＃xff08;使用&＃xff09;的&＃xff0c;或者是人或者是机器&＃xff08;来使用&＃xff09;。人可能会对调试错误、跟踪特殊的请求感兴趣。机器可能会对统计那些有趣的事件&＃xff0c;或是对离线处理的结果进行聚合。这两种情况&＃xff0c;日志消息的结构化和可操作性是很重要的。Go kit的 log 模块针对这些实践提供了最好的设计。
直到服务经过了跟踪计数、延迟、健康状况和其他的周期性的或针对每个请求信息的仪表盘化&＃xff0c;才能被认为是“生产环境”完备的。Go kit 的 metric 模块为你的服务提供了通用并健壮的接口集合。可以绑定到常用的后端服务&＃xff0c;比如 expvar 、statsd、Prometheus。
随着你的基础设施的增长&＃xff0c;能够跟踪一个请求变得越来越重要&＃xff0c;因为它可以在多个服务中进行穿梭并回到用户。Go kit的 tracing 模块提供了为端点和传输的增强性的绑定功能&＃xff0c;以捕捉关于请求的信息&＃xff0c;并把它们发送到跟踪系统中。&＃xff08;当前支持 Zipkin&＃xff0c;计划支持Appdash
如果你的服务调用了其他的服务&＃xff0c;需要知道如何找到它&＃xff08;另一个服务&＃xff09;&＃xff0c;并且应该智能的将负载在这些发现的实例上铺开&＃xff08;即&＃xff0c;让被发现的实例智能的分担服务压力&＃xff09;。Go kit的loadbalancer模块提供了客户端端点的中间件来解决这类问题&＃xff0c;无论你是使用的静态的主机名还是IP地址&＃xff0c;或是 DNS的 SRV 记录&＃xff0c;Consul&＃xff0c;etcd 或是 Zookeeper。并且&＃xff0c;如果你使用定制的系统&＃xff0c;也可以非常容易的编写你自己的 Publisher&＃xff0c;以使用 Go kit 提供的负载均衡策略。&＃xff08;目前&＃xff0c;支持静态主机名、etcd、Consul、Zookeeper&＃xff09;
Go kit 是一个函数库&＃xff0c;设计的目标是引入到二进制文件中。对于二进制软件包的作者来讲&＃xff0c;Vendoring是目前用来确保软件可靠、可重新构建的最好的机制。因此&＃xff0c;我们强烈的建议我们的用户使用vendoring机制来管理他们软件的依赖&＃xff0c;包括Go kit。
为了避免兼容性和可用性的问题&＃xff0c;Go kit没有vendor它自己的依赖&＃xff0c;并且并不推荐使用第三方的引用代理。
有一些工具可以让vendor机制更简单&＃xff0c;包括 gb、glide、gvt、 govendor 和 vendetta。另外&＃xff0c;Go kit使用了一系列的持续集成的机制来确保在尽快地修复那些复杂问题。
标注有 ★ 的项目对 Go kit 的设计有着特别的影响 &＃xff08;反之亦然&＃xff09;
afex/hystrix-go, client-side latency and fault tolerance library
armon/go-metrics, library for exporting performance and runtime metrics to external metrics systems
codahale/lunk, structured logging in the style of Google’s Dapper or Twitter’s Zipkin
eapache/go-resiliency, resiliency patterns
sasbury/logging, a tagged style of logging
grpc/grpc-go, HTTP/2 based RPC
inconshreveable/log15, simple, powerful logging for Go ★
mailgun/vulcand, programmatic load balancer backed by etcd
mattheath/phosphor, distributed system tracing
pivotal-golang/lager, an opinionated logging library
rubyist/circuitbreaker, circuit breaker library
Sirupsen/logrus, structured, pluggable logging for Go ★
sourcegraph/appdash, application tracing system based on Google’s Dapper
spacemonkeygo/monitor, data collection, monitoring, instrumentation, and Zipkin client library
streadway/handy, net/http handler filters
vitess/rpcplus, package rpc &＃43; context.Context
gdamore/mangos, nanomsg implementation in pure Go
Beego
Gin
Goji
Gorilla
Martini
Negroni
Revel (considered harmful)
Architecting for the Cloud — Netflix
Dapper, a Large-Scale Distributed Systems Tracing Infrastructure — Google
Your Server as a Function (PDF) — Twitter
go-kit 入门 &＃xff08;二&＃xff09; 第一个 Go kit 程序
发表于2016 年 5 月 28 日由chunshengster&＃64;gmail.com
服务&＃xff08;Service&＃xff09;是从业务逻辑开始的&＃xff0c;在 Go kit 中&＃xff0c;我们将服务以 interface 作为模型
| 1 2 3 4 5 | // StringService provides operations on strings. type StringService interface { Uppercase(string) (string, error) Count(string) int } |
这个 interface 需要有一个“实现”
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | type stringService struct{}
func (stringService) Uppercase(s string) (string, error) { if s &＃61;&＃61; "" { return "", ErrEmpty } return strings.ToUpper(s), nil }
func (stringService) Count(s string) int { return len(s) }
// ErrEmpty is returned when input string is empty var ErrEmpty &＃61; errors.New("Empty string") |
在 Go kit 中&＃xff0c;主要的消息模式是 RPC。因此&＃xff0c;接口&＃xff08; interface &＃xff09;的每一个方法都会被模型化为远程过程调用&＃xff08;RPC&＃xff09;。对于每一个方法&＃xff0c;我们都定义了请求和响应的结构体&＃xff0c;捕获输入、输出各自的所有参数。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | type uppercaseRequest struct { S string &＃96;json:"s"&＃96; }
type uppercaseResponse struct { V string &＃96;json:"v"&＃96; Err string &＃96;json:"err,omitempty"&＃96; // errors don&＃39;t define JSON marshaling }
type countRequest struct { S string &＃96;json:"s"&＃96; }
type countResponse struct { V int &＃96;json:"v"&＃96; } |
Go kit 通过 endpoint 提供了非常丰富的功能。
一个端点代表一个RPC&＃xff0c;也就是我们服务接口中的一个函数。我们将编写简单的适配器&＃xff0c;将我们的服务的每一个方法转换成端点。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | import ( "golang.org/x/net/context" "github.com/go-kit/kit/endpoint" )
func makeUppercaseEndpoint(svc StringService) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { req :&＃61; request.(uppercaseRequest) v, err :&＃61; svc.Uppercase(req.S) if err !&＃61; nil { return uppercaseResponse{v, err.Error()}, nil } return uppercaseResponse{v, ""}, nil } }
func makeCountEndpoint(svc StringService) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { req :&＃61; request.(countRequest) v :&＃61; svc.Count(req.S) return countResponse{v}, nil } } |
现在我们需要将服务暴露给外界&＃xff0c;这样它们才能被调用。对于服务如何与外界交互&＃xff0c;你的组织可能已经有了定论。可能你会使用 Thrift、基于 HTTP 的自定义 JSON。Go kit支持多种开箱即用的 传输 方式。(Adding support for new ones is easy—just 对新方式的支持是非常简单的。参见 这里
针对我们现在的这个微型的服务例子&＃xff0c;我们使用基于 HTTP 的 JSON。Go kit 中提供了一个辅助结构体&＃xff0c;在 transport/http 中。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 | import ( "encoding/json" "log" "net/http"
"golang.org/x/net/context"
httptransport "github.com/go-kit/kit/transport/http" )
func main() { ctx :&＃61; context.Background() svc :&＃61; stringService{}
uppercaseHandler :&＃61; httptransport.NewServer( ctx, makeUppercaseEndpoint(svc), decodeUppercaseRequest, encodeResponse, )
countHandler :&＃61; httptransport.NewServer( ctx, makeCountEndpoint(svc), decodeCountRequest, encodeResponse, )
http.Handle("/uppercase", uppercaseHandler) http.Handle("/count", countHandler) log.Fatal(http.ListenAndServe(":8080", nil)) }
func decodeUppercaseRequest(_ context.Context, r *http.Request) (interface{}, error) { var request uppercaseRequest if err :&＃61; json.NewDecoder(r.Body).Decode(&request); err !&＃61; nil { return nil, err } return request, nil }
func decodeCountRequest(_ context.Context, r *http.Request) (interface{}, error) { var request countRequest if err :&＃61; json.NewDecoder(r.Body).Decode(&request); err !&＃61; nil { return nil, err } return request, nil }
func encodeResponse(_ context.Context, w http.ResponseWriter, response interface{}) error { return json.NewEncoder(w).Encode(response) } |
go-kit 入门&＃xff08;三&＃xff09;日志和仪表化
发表于2016 年 6 月 1 日由chunshengster&＃64;gmail.com
任何服务在日志和仪表化没有就绪的情况下&＃xff0c;都不能说是生产环境就绪的。
任何需要日志记录的组件都需要将 logger 作为依赖&＃xff0c;就像数据库连接一样。因此&＃xff0c;我们在 main 函数中构造 logger 对象&＃xff0c;然后将其传入需要使用它的组件中。我们始终不去使用一个全局的 logger 对象。
我们可以直接将 logger 传入到 stringService 的实现代码中&＃xff0c;但是&＃xff0c;还有一个更好的方式。我们可以使用 中间件 (middleware) ,也常常被称为 装饰者。
middleware 是一个函数&＃xff0c;它接收一个 endpoint 作为参数&＃xff0c;并且返回一个 endpoint。
| 1 | type Middleware func(Endpoint) Endpoint |
在函数中&＃xff0c;它可以做任何事情。下面就让我们来创建一个基本的日志中间件。
| 1 2 3 4 5 6 7 8 9 | func loggingMiddleware(logger log.Logger) Middleware { return func(next endpoint.Endpoint) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { logger.Log("msg", "calling endpoint") defer logger.Log("msg", "called endpoint") return next(ctx, request) } } } |
然后&＃xff0c;我们将它加入到每一个处理函数中。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | logger :&＃61; log.NewLogfmtLogger(os.Stderr)
svc :&＃61; stringService{}
var uppercase endpoint.Endpoint uppercase &＃61; makeUppercaseEndpoint(svc) uppercase &＃61; loggingMiddleware(log.NewContext(logger).With("method", "uppercase"))(uppercase)
var count endpoint.Endpoint count &＃61; makeCountEndpoint(svc) count &＃61; loggingMiddleware(log.NewContext(logger).With("method", "count"))(count)
uppercaseHandler :&＃61; httptransport.Server( // ... uppercase, // ... )
countHandler :&＃61; httptransport.Server( // ... count, // ... ) |
事实证明&＃xff0c;这项技术是非常有价值的&＃xff0c;远远不止于记录日志&＃xff0c;Go kit 的很多模块都被实现为端点中间件。
那么&＃xff0c;在我们的应用中&＃xff0c;应该如何记录日志呢&＃xff1f;比如那些需要被传入的参数等。事实上&＃xff0c;我们能够为我们的服务定义一个中间件&＃xff0c;从而获得同样好的组合效果。由于我们的 StringService被定义为一个接口&＃xff0c;我们只需要作出一个新的类型&＃xff0c;来包装先有的 StringService&＃xff0c;让它来执行扩充的记录日志的任务。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 | type loggingMiddleware struct{ logger log.Logger StringService }
func (mw loggingMiddleware) Uppercase(s string) (output string, err error) { defer func(begin time.Time) { mw.logger.Log( "method", "uppercase", "input", s, "output", output, "err", err, "took", time.Since(begin), ) }(time.Now())
output, err &＃61; mw.StringService.Uppercase(s) return }
func (mw loggingMiddleware) Count(s string) (n int) { defer func(begin time.Time) { mw.logger.Log( "method", "count", "input", s, "n", n, "took", time.Since(begin), ) }(time.Now())
n &＃61; mw.StringService.Count(s) return } |
然后&＃xff0c;将新的类型引入到下面的代码中&＃xff1a;
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | import ( "os"
"github.com/go-kit/kit/log" httptransport "github.com/go-kit/kit/transport/http" )
func main() { logger :&＃61; log.NewLogfmtLogger(os.Stderr)
svc :&＃61; stringService{} svc &＃61; loggingMiddleware{logger, svc}
uppercaseHandler :&＃61; httptransport.NewServer( // ... makeUppercaseEndpoint(svc), // ... )
countHandler :&＃61; httptransport.NewServer( // ... makeCountEndpoint(svc), // ... ) } |
在传输环节使用端点中间件&＃xff0c;比如回路断路器和速率限制。在业务环节使用服务中间件&＃xff0c;比如日志和仪表化。
在 Go kit 中&＃xff0c;仪表化意味着使用 包指标 来记录关于服务运行行为的状态。统计执行的任务的数量&＃xff0c;在请求完成后记录消耗的时间&＃xff0c;以及跟踪所有正在执行的操作的数量&＃xff0c;都被认为是 仪表化。
我们可以使用同样的中间件模式&＃xff0c;在记录日志的环节我们曾经用过。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | type instrumentingMiddleware struct { requestCount metrics.Counter requestLatency metrics.TimeHistogram countResult metrics.Histogram StringService }
func (mw instrumentingMiddleware) Uppercase(s string) (output string, err error) { defer func(begin time.Time) { methodField :&＃61; metrics.Field{Key: "method", Value: "uppercase"} errorField :&＃61; metrics.Field{Key: "error", Value: fmt.Sprintf("%v", err)} mw.requestCount.With(methodField).With(errorField).Add(1) mw.requestLatency.With(methodField).With(errorField).Observe(time.Since(begin)) }(time.Now())
output, err &＃61; mw.StringService.Uppercase(s) return }
func (mw instrumentingMiddleware) Count(s string) (n int) { defer func(begin time.Time) { methodField :&＃61; metrics.Field{Key: "method", Value: "count"} errorField :&＃61; metrics.Field{Key: "error", Value: fmt.Sprintf("%v", error(nil))} mw.requestCount.With(methodField).With(errorField).Add(1) mw.requestLatency.With(methodField).With(errorField).Observe(time.Since(begin)) mw.countResult.Observe(int64(n)) }(time.Now())
n &＃61; mw.StringService.Count(s) return } |
然后将其引入到服务中&＃xff1a;
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 | import ( stdprometheus "github.com/prometheus/client_golang/prometheus" kitprometheus "github.com/go-kit/kit/metrics/prometheus" "github.com/go-kit/kit/metrics" )
func main() { logger :&＃61; log.NewLogfmtLogger(os.Stderr)
fieldKeys :&＃61; []string{"method", "error"} requestCount :&＃61; kitprometheus.NewCounter(stdprometheus.CounterOpts{ // ... }, fieldKeys) requestLatency :&＃61; metrics.NewTimeHistogram(time.Microsecond, kitprometheus.NewSummary(stdprometheus.SummaryOpts{ // ... }, fieldKeys)) countResult :&＃61; kitprometheus.NewSummary(stdprometheus.SummaryOpts{ // ... }, []string{}))
svc :&＃61; stringService{} svc &＃61; loggingMiddleware{logger, svc} svc &＃61; instrumentingMiddleware{requestCount, requestLatency, countResult, svc}
uppercaseHandler :&＃61; httptransport.NewServer( // ... makeUppercaseEndpoint(svc), // ... )
countHandler :&＃61; httptransport.NewServer( // ... makeCountEndpoint(svc), // ... )
http.Handle("/metrics", stdprometheus.Handler()) } |
目前位置&＃xff0c;完整的服务是 stringsvc2.
| 1 2 3 | $ go get github.com/go-kit/kit/examples/stringsvc2 $ stringsvc2 msg&＃61;HTTP addr&＃61;:8080 |
| 1 2 3 4 | $ curl -XPOST -d&＃39;{"s":"hello, world"}&＃39; localhost:8080/uppercase {"v":"HELLO, WORLD","err":null} $ curl -XPOST -d&＃39;{"s":"hello, world"}&＃39; localhost:8080/count {"v":12} |
| 1 2 | method&＃61;uppercase input&＃61;"hello, world" output&＃61;"HELLO, WORLD" err&＃61;null took&＃61;2.455µs method&＃61;count input&＃61;"hello, world" n&＃61;12 took&＃61;743ns |
Go-kit 入门&＃xff08;四&＃xff09;服务调用
发表于2016 年 6 月 16 日由chunshengster&＃64;gmail.com
存在“真空”&＃xff08;即极其独立&＃xff0c;与其他任何服务无互相调用的关系&＃xff09;中的服务是罕见的。而我们常见的是&＃xff0c;我们需要调用其他的服务。这也是 Go kit 的闪光点 ,我们提供了 传输中间件机制来解决可能出现的很多问题。
下面我们将实现一个代理功能的中间件&＃xff0c;作为一个服务中间件。在这里我们只代理一个方法&＃xff0c;Uppercase。
| 1 2 3 4 5 6 7 8 | // proxymw implements StringService, forwarding Uppercase requests to the // provided endpoint, and serving all other (i.e. Count) requests via the // embedded StringService. type proxymw struct { context.Context StringService // Serve most requests via this embedded service... UppercaseEndpoint endpoint.Endpoint // ...except Uppercase, which gets served by this endpoint } |
我们已经有了一个跟我们所知道的完全相同的端点&＃xff0c;但是我们将使用它来调用一个请求&＃xff0c;而不是提供服务。按照这种方式来使用它的时候&＃xff0c;我们称它为客户端端点。为了调用客户端端点&＃xff0c;我们需要做一些简单的转换。
| 1 2 3 4 5 6 7 8 9 10 11 | func (mw proxymw) Uppercase(s string) (string, error) { response, err :&＃61; mw.UppercaseEndpoint(mw.Context, uppercaseRequest{S: s}) if err !&＃61; nil { return "", err } resp :&＃61; response.(uppercaseResponse) if resp.Err !&＃61; "" { return resp.V, errors.New(resp.Err) } return resp.V, nil } |
现在&＃xff0c;我们为了构造一个代理中间件&＃xff0c;我们将一个代理URL字符串转换为一个端点。加入我们使用 HTTP 协议之上的 JSON&＃xff0c;我们可以使用 transport/http 包中的一个辅助&＃xff08;helper&＃xff09;函数。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | import ( httptransport "github.com/go-kit/kit/transport/http" )
func proxyingMiddleware(proxyURL string, ctx context.Context) ServiceMiddleware { return func(next StringService) StringService { return proxymw{ctx, next, makeUppercaseEndpoint(ctx, proxyURL)} } }
func makeUppercaseEndpoint(ctx context.Context, proxyURL string) endpoint.Endpoint { return httptransport.NewClient( "GET", mustParseURL(proxyURL), encodeUppercaseRequest, decodeUppercaseResponse, ).Endpoint() } |
如果我们只使用一个远程的服务就好了。但是实际上&＃xff0c;我们往往 会有很多个服务实例。我们希望通过一些服务发现算法来发现它们&＃xff0c;然后将我们的负载分散到它们上面&＃xff0c;并且如果这些实例中的任何一个变得糟糕&＃xff0c;我们能够处理它&＃xff0c;并且不影响我们服务的可用性。
Go kit 为不同的服务发现系统提供了适配器&＃xff0c;为了获取最新的服务实例集合&＃xff0c;暴露端点个体。这些适配器被称为 发布器&＃xff08;publishers&＃xff09;。
| 1 2 3 | type Publisher interface { Endpoints() ([]endpoint.Endpoint, error) } |
在发布器内部&＃xff0c;它使用一个私有的工厂函数&＃xff0c;将被发现的每一个 host:port 字符串 转换成一个可用的端点。
| 1 | type Factory func(instance string) (endpoint.Endpoint, error) |
目前&＃xff0c;我们的工程方法&＃xff0c;makeUppercaseEndpoint&＃xff0c;只是直接请求 URL。但是&＃xff0c;在工厂函数中加入一些安全的中间件方法是很重要的&＃xff0c;比如 回路断路器 和 限流器。
| 1 2 3 4 5 6 7 8 9 | func factory(ctx context.Context, maxQPS int) loadbalancer.Factory { return func(instance string) (endpoint.Endpoint, error) { var e endpoint.Endpoint e &＃61; makeUppercaseProxy(ctx, instance) e &＃61; circuitbreaker.Gobreaker(gobreaker.NewCircuitBreaker(gobreaker.Settings{}))(e) e &＃61; kitratelimit.NewTokenBucketLimiter(jujuratelimit.NewBucketWithRate(float64(maxQPS), int64(maxQPS)))(e) return e, nil } } |
现在&＃xff0c;我们已经有了一系列的端点&＃xff0c;我们需要在其中选择一个。负载均衡器包装了 发布器&＃xff0c;并且从端点集合中选择其中的某一个。Go kit 提供了一组基本的负载均衡器&＃xff0c;并且&＃xff0c;如果你希望更多的高级的算法&＃xff0c;也可以很容易的自己来写一个。
| 1 2 3 | type LoadBalancer interface { Endpoint() (endpoint.Endpoint, error) } |
现在&＃xff0c;我们可以根据一下算法来选择端点。我们能够使用它为消费器提供一个单一的、逻辑的可靠的端点。通过重试的策略包装负载均衡器&＃xff0c;并且返回一个可用的端点。重试的策略可以将一个失败的请求进行重试&＃xff0c;直到达到最大的可重试次数或是达到超时时间。
| 1 | func Retry(max int, timeout time.Duration, lb LoadBalancer) endpoint.Endpoint |
现在&＃xff0c;让我们将最后的代理中间件加入到代码中。为了简洁&＃xff0c;我们假设用户会为逗号&＃xff08;,)分隔的多个实例端点指定一个标记。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 | func proxyingMiddleware(proxyList string, ctx context.Context, logger log.Logger) ServiceMiddleware { return func(next StringService) StringService { var ( qps &＃61; 100 // max to each instance publisher &＃61; static.NewPublisher(split(proxyList), factory(ctx, qps), logger) lb &＃61; loadbalancer.NewRoundRobin(publisher) maxAttempts &＃61; 3 maxTime &＃61; 100 * time.Millisecond endpoint &＃61; loadbalancer.Retry(maxAttempts, maxTime, lb) ) return proxymw{ctx, endpoint, next} } } |
截止目前&＃xff0c;这个完整的服务是 stringsvc3$ go get github.com/go-kit/kit/examples/stringsvc3 $ stringsvc3 -listen&＃61;:8001 & listen&＃61;:8001 caller&＃61;proxying.go:25 proxy_to&＃61;none listen&＃61;:8001 caller&＃61;main.go:72 msg&＃61;HTTP addr&＃61;:8001 $ stringsvc3 -listen&＃61;:8002 & listen&＃61;:8002 caller&＃61;proxying.go:25 proxy_to&＃61;none listen&＃61;:8002 caller&＃61;main.go:72 msg&＃61;HTTP addr&＃61;:8002 $ stringsvc3 -listen&＃61;:8003 & listen&＃61;:8003 caller&＃61;proxying.go:25 proxy_to&＃61;none listen&＃61;:8003 caller&＃61;main.go:72 msg&＃61;HTTP addr&＃61;:8003 $ stringsvc3 -listen&＃61;:8080 -proxy&＃61;localhost:8001,localhost:8002,localhost:8003 listen&＃61;:8080 caller&＃61;proxying.go:29 proxy_to&＃61;"[localhost:8001 localhost:8002 localhost:8003]" listen&＃61;:8080 caller&＃61;main.go:72 msg&＃61;HTTP addr&＃61;:8080
| 1 2 3 4 | $ for s in foo bar baz ; do curl -d"{\"s\":\"$s\"}" localhost:8080/uppercase ; done {"v":"FOO","err":null} {"v":"BAR","err":null} {"v":"BAZ","err":null} |
| 1 2 3 4 5 6 | listen&＃61;:8001 caller&＃61;logging.go:28 method&＃61;uppercase input&＃61;foo output&＃61;FOO err&＃61;null took&＃61;5.168µs listen&＃61;:8080 caller&＃61;logging.go:28 method&＃61;uppercase input&＃61;foo output&＃61;FOO err&＃61;null took&＃61;4.39012ms listen&＃61;:8002 caller&＃61;logging.go:28 method&＃61;uppercase input&＃61;bar output&＃61;BAR err&＃61;null took&＃61;5.445µs listen&＃61;:8080 caller&＃61;logging.go:28 method&＃61;uppercase input&＃61;bar output&＃61;BAR err&＃61;null took&＃61;2.04831ms listen&＃61;:8003 caller&＃61;logging.go:28 method&＃61;uppercase input&＃61;baz output&＃61;BAZ err&＃61;null took&＃61;3.285µs listen&＃61;:8080 caller&＃61;logging.go:28 method&＃61;uppercase input&＃61;baz output&＃61;BAZ err&＃61;null took&＃61;1.388155ms |
上下文对象用来在单个请求中携带那些需要跨越概念性边界的信息。在我们的例子中&＃xff0c;我们还没有在业务逻辑中使用线程上下文。但是&＃xff0c;这种方式几乎会永远都是一个好方案。它允许我们在业务逻辑和中间件中传递请求范围内的信息&＃xff0c;并且对于复杂的任务&＃xff08;比如&＃xff0c;分布式系统的细粒度追踪信息&＃xff09;也是很必要的。
具体点来讲&＃xff0c;这也意味着你的业务逻辑接口会这样&＃xff1a;
| 1 2 3 4 5 | type MyService interface { Foo(context.Context, string, int) (string, error) Bar(context.Context, string) error Baz(context.Context) (int, error) } |
一旦你的基础设施增长超过一定的规模&＃xff0c;在多个服务中跟踪请求是非常必要的&＃xff0c;这样&＃xff0c;你就能够分析并解决故障热点。参见 package tracing 获取更多信息。
使用 Go kit 为你的服务创建一个客户端软件包是很可能的事情&＃xff0c;让你的服务能够很容易对其他的 Go 程序进行调用。实际上&＃xff0c;你的客户端package会提供你的服务接口&＃xff0c;这个接口会使用指定的传输方式来调用远程服务。参见 package addsvc/client 作为参考例子.
addsvc 是原来的一个例子。它公开 所有支持的传输方式 的系列操作。它完整地做了日志记录、仪表盘化&＃xff0c;并且使用 Zipkin 来跟踪请求。同样&＃xff0c;它也示范了如何创建和使用客户端package。它是一个非常棒的例子&＃xff0c;为 Go kit 服务提供了完整的功能示例。
profilesvc 示范了如何使用 Go kit 来打造 REST 风格的微服务。
apigateway 示范了如何实现一个 API 网关模式&＃xff0c;通过 Consul 作为服务发现系统。
shipping 是一个完整的&＃xff0c;真实的应用&＃xff0c;由多个微服务组成&＃xff0c;基于领域驱动设计原则。
京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有