• 云原生 | go-micro全量配置详解

    目录

    本篇针对上一篇【go-micro学习与实践】进行补充，希望大家能对go-micro有一个全面、清晰的认知！

    Server

    • micro.Server(server.Server)：

    定义微服务的服务端。服务端⽤于接收并处理客户端请求。go-micro将服务端抽象成了server.Server接⼝。官⽅Server插件库提供的服务端插件包含：grpc，http，mucp。默认采⽤mucp。以mucp为例：mucp是go-micro的原⽣协议。server.NewServer(…server.Option)返回了server.rpcServer插件。

    • server.Name(string)：

    配置服务名称。默认go.micro.server。也可以通过micro.Name(string)进⾏配置。

    • server.Id(string)：

    服务标识。默认通过uuid.New().String()⽣成。

    • server.Version(string)：

    服务版本。默认latest。

    • server.Address(string)：

    服务发布地址。使⽤transport.Listen监听时，传⼊的地址。默认:0。

    • server.Advertise(string)：

    服务发现地址。节点注册时，该地址随着节点信息⼀同注册到注册中⼼；客户端发起请求时，seletor通过服务名匹配到节点，然后通过该服务发现地址向节点发送请求。默认空，为空时使⽤服务发布地址的真实地址。

    • server.Broker(broker.Broker)：

    事件订阅⽅配置。⽤于处理接收到的事件通知，使⽤broker.Subscribe订阅事件。默认broker.httpBroker。

    • server.Codec(contentType string, c codec.NewCodec)：

    新增⾃定义消息解码器。服务端通过content-type获取消息解码器，对收到的请求进⾏解码。codec.ReadHeader⽅法解码消息头，codec.ReadBody⽅法解码消息体。

    当添加的content-type与默认的相同时，新增编码器的会覆盖默认的解码器。mucp默认的消息解码器如下：

    在这里插入图片描述

    • server.Context(context.Context)：

    上下⽂，⽤于传递值。mucp服务中，有两个地⽅⽤到context。

    1、 存储server.Wait(*sync.WaitGroup)设置的wait值。

    2、传递到RegisterCheck⽅法中执⾏。

    • server.Tracer(trace.Tracer)：

    服务链路追踪器，客户端发起请求时，构造⼀个包含trace-id和span-id的content，服务端处理请求时，会修改content中的span-id。当前版本该字段默认未⽤到。可通过server.WrapHandler()⾃主实现。

    • server.Transport(transport.Transport)：

    服务端通信协议，服务端通过Transport的Listen()⽅法发布服务监听。默认httpTransport。

    • server.Metadata(map[string]string)：

    设置元信息。元信息会在节点信息中展示，默认元信息有transport，broker，server，registry，protocol。默认的元信息⽆法修改。

    • server.Registry(registry.Registry)：

    服务注册中⼼，启动服务时，通过Regsitry的Register()⽅法向注册中⼼注册节点信息。

    • server.RegisterTTL(time.Duration)：

    注册⽣效时间，对应registry插件中的Timeout。默认90s。

    • server.RegisterCheck(func(context.Context) error)：

    注册检查。启动服务时，在节点注册前进⾏检查，检查通过才继续注册。服务运⾏时，进⾏周期性检查，检查失败的断开注册，检查成功的重新注册。默认对任何信息都检查通过。

    • server.RegisterInterval(time.Duration)：

    注册检查周期，执⾏注册检查的周期，为0时不进⾏周期检查。默认30s。

    • server.TLSConfig(*tls.TLSConfig)：

    设置transport监听的tls配置。

    • server.WithRouter(server.Router)：

    覆盖默认的请求路由。对客户端对请求进⾏处理，默认是server.router。ProcessMessage()处理事件，ServeRequest()处理微服务请求。

    • server.Wait(*sync.WaitGroup)：

    服务退出时，等待请求结束。传空也能设置成功。

    • server.WrapHandler(server.HandlerWrapper)：

    请求拦截器。构建请求处理链，先配置的先处理，最后处理router.ServeRequest⽅法。

    • server.Subwrapper(server.SubscriberWrapper)：

    事件拦截器。构建事件处理链，先配置的先处理，最后处理router.ProcessMessage⽅法。

    srv := micro.NewService(
 micro.Server(
 server.NewServer(
 server.Name(service),
 server.Id(server.DefaultId),
 server.Version(version),
 server.Address(server.DefaultAddress),
 //server.Advertise(server.DefaultAddress),
 server.Broker(broker.DefaultBroker),
 server.Codec("application/text", func(closer io.ReadWriteCloser) codec.Codec {
 return &bytes.Codec{}
 }),
 server.Context(context.Background()),
 server.Registry(registry.DefaultRegistry),
 //server.Tracer(trace.DefaultTracer),
 server.Metadata(map[string]string{"description": "web ui and route"}),
 server.RegisterTTL(server.DefaultRegisterTTL),
 server.Context(context.WithValue(context.Background(), "isReady", true)),
 server.RegisterCheck(func(ctx context.Context) error {
 if !ctx.Value("isReady").(bool) {
 return fmt.Errorf("server not ready to registry")
 }
 return nil
 }),
 server.RegisterInterval(server.DefaultRegisterInterval),
 server.TLSConfig(&tls.Config{Certificates: []tls.Certificate{transportCert}}),
 //server.WithRouter(server.DefaultRouter),
 server.Wait(nil),
 server.WrapHandler(func(handlerFunc server.HandlerFunc) server.HandlerFunc {
 return func(ctx context.Context, req server.Request, rsp interface{}) error {
// ⽀持链路追踪
 newCtx, s := trace.DefaultTracer.Start(ctx, "web")
 s.Type = trace.SpanTypeRequestInbound
 defer trace.DefaultTracer.Finish(s)
 return handlerFunc(newCtx, req, rsp)
 }
 }),
 server.WrapHandler(func(handlerFunc server.HandlerFunc) server.HandlerFunc { //
⽀持auth认证
 return func(ctx context.Context, req server.Request, rsp interface{}) error {
 token := req.Header()[authHeader]
 account, err := auth.DefaultAuth.Inspect(token)
 if err != nil {
 return err
 }
 return handlerFunc(context.WithValue(ctx, "account", account), req, rsp)
 }
 }),
 server.WrapSubscriber(func(subscriberFunc server.SubscriberFunc)
server.SubscriberFunc {
 return func(ctx context.Context, msg server.Message) error {
 return subscriberFunc(ctx, msg)
 }
 }),
 ),
 ),
 )

    • 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
    • 53
    • 54
    • 55
    • 56
    • 57
    Server-补充字段

    在这里插入图片描述
    在这里插入图片描述

    srv := micro.NewService(
micro.Name(service),
 micro.Version(version),
micro.RegisterTTL(10*time.Second),
 micro.RegisterInterval(10*time.Second),
micro.Metadata(),
micro.WrapHandler(),
 micro.WrapSubscriber(),
)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    client

    • micro.Client(client.Client)：

    定义微服务的客户端。客户端⽤于发送请求。go-micro将客户端抽象成了client.Client接⼝。官⽅Client插件库提供的客户端插件包含：grpc，http，mucp。默认mucp。

    以mucp为例。client.NewClient(…client.Option)返回了client.rpcClient插件。

    • client.Broker(broker.Broker)：

    事件发布⽅配置。⽤于发布事件通知，使⽤Broker.Publish⽅法发布事件。

    • client.Codec(string, codec.NewCodec)：

    新增⾃定义消息编码器。客户端通过content-type获取消息编码器，对要发出的请求使⽤codec.Write⽅法进⾏编码。当添加的content-type与默认的相同时，新增编码器的会覆盖默认的编码器。消息编码器和消息解码器⼀⼀对应。

    • client.ContentType(string)：

    设置请求头的Content-Type。通过client.NewRequest()构造请求时，将该参数设

    置为请求头的Content-Type，客户端和服务端会根据该请求头，进⾏相应的编码和解码。默认applicaiton/json。

    • client.PoolSize(int)：

    连接池⼤⼩。连接池每个地址缓存连接池⼤⼩的连接，发起请求时，先通过pool.Get从连接池中获取连接，⽆法获取再创建新的连接；请求结束时，通过pool.Release将连接放回连接池，连接池满或连接出错时，关闭连接，并从连接池中丢弃。

    • client.PoolTTL(time.Duration)：

    连接池超时时间。连接创建时，会记录连接的创建时间，每次获取连接时，计算是否超时，超时时，关闭连接，并从连接池中丢弃。

    • client.Transport(transport.Transport)：

    客户端端通信协议，客户端通过Transport的Dial⽅法发起请求。默认httpTransport。

    • client.Selector(selector.Selector)：

    设置选择器。客户端先通过Registry.GetService，获取注册中⼼该服务所有的节点信息，然后通过选择器策略strategy，在注册中⼼获取⼀个服务端的节点信息，向节点发起请求。默认选择器为selector.registrySelector，该selector包含两个重要⽅法：

    • selector.Registry(registry.Registry)：

    设置注册中⼼。

    • selector.SetStrategy(func ([]*registry.Service) Next)：

    设置选择器算法。mucp提供的选择器算法有：

    【图片】

    • client.Registry(registry.Registry)：

    ⽤于设置选择器⾥的注册中⼼。同selector.Registry

    • client.Wrap(client.Wrapper)：

    客户端中间件。初始化客户端时执⾏的链⽅法。先配置的先执⾏，先执⾏其他参数的初始化，最后执⾏链路上的⽅法，返回最终的客户端。

    • client.WrapCall(client.CallWrapper)：

    请求中间件。每次请求时执⾏的链⽅法。先配置的先执⾏。先执⾏链路上的⽅法，最后执⾏client.call⽅法发起tcp请求。

    • client.Backoff(client.BackoffFunc)：

    请求备份。请求前执⾏，执⾏完成后，系统休眠⽅法返回的时间。

    • client.Retry(client.RetryFunc)：

    请求是否重试。请求完成后，是否重新发起请求.mucp⽀持以下⼏种⽅法

    【图片】

    • client.Retries(int)：

    请求重试次数。默认1。

    • client.RequestTimeout(time.Duration)：

    请求及响应超时时间。该参数将会设置到请求头Timeout。默认5s。

    • client.StreamTimeout(time.Duration)：

    流连接超时时间。该参数将会设置到请求头Timeout。默认5s。流连接可以是双向流，也可以是单向流。

    • client.DialTimeout(time.Duration)：

    设置transport中的超时时间，默认5s。

    • client.WithRouter(Router)：

    设置router，暂时没有⽤到。

    srv := micro.NewService(
 micro.Server(
 client.NewClient(
 client.Broker(broker.DefaultBroker),
 client.Codec("application/text", func(closer io.ReadWriteCloser) codec.Codec {
 return &bytes.Codec{}
 }),
 client.ContentType(client.DefaultContentType),
 client.PoolSize(0),
 client.Selector(selector.NewSelector(selector.SetStrategy(selector.RoundRobin))),
 client.Registry(registry.DefaultRegistry),
 client.Wrap(func(c client.Client) client.Client { // 构造客户端
 if c.Options().Registry == nil {
 return nil
 }
 return c
 }),
 client.WrapCall(func(callFunc client.CallFunc) client.CallFunc {
 return func(ctx context.Context, node *registry.Node, req client.Request, rsp
interface{}, opts client.CallOptions) error { // 设置请求链路追踪
 newCtx, s := trace.DefaultTracer.Start(ctx, "web")
 s.Type = trace.SpanTypeRequestInbound
 defer trace.DefaultTracer.Finish(s)
 return callFunc(newCtx, node, req, rsp, opts)
 }
 }),
 client.Backoff(func(ctx context.Context, req client.Request, attempts int)
(time.Duration, error) { // 打印请求
 log.Infof("attempts %v, the req is %v", attempts, req.Body())
 return 0, nil
 }),
 client.Retry(func(ctx context.Context, req client.Request, retryCount int, err
error) (bool, error) {
 return err != nil, nil
 }),
 client.Retries(client.DefaultRetries),
 client.RequestTimeout(client.DefaultRequestTimeout),
 client.StreamTimeout(client.DefaultRequestTimeout),
 client.DialTimeout(transport.DefaultDialTimeout),
 client.WithRouter(nil),
 ),
 ),
 )

    • 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
    Client-补充字段
    • micro.Selector(selector)：

    同client.Selector。官⽅Selector插件库提供的选择器插件包含：dns，label，registry，shard，static。默认使⽤registry。

    • micro.WrapClient(…client.Wrapper)：

    同client.Wrapper(client.Wrapper)

    • micro.WrapCall(…client.CallWrapper)：

    同client.WrapCall(client.CallWrapper)

    
srv := micro.NewService(
 micro.Selector(selector.DefaultSelector),
 micro.WrapClient(),
 micro.WrapCall(),
 )

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    Transport

    • micro.Tranport(transport.Transport)：

    统⼀定义服务端和客户端中使⽤的transport插件。

    go-micro将服务通信抽象成了transport.Transport接⼝。官⽅Transport插件库提供了众多服务通信插件。包含：grpc，http，memory，nats，quic，rabbitmq，tcp，utp。默认http。

    以http为例。transport.NewTransport()返回了transport.httpTransport插件。

    • transport.Addr(…string)：

    httpTransport中暂时没有⽤到。

    • transport.Codec(codec.Marshaler)：

    httpTransport中暂时没有⽤到。

    • transport.Timeout(time.Duration)：

    设置服务端和客户端，接收和发送消息的超时时间。零值表示不设置超时时间，默认零值。

    • transport.Secure(bool)：

    是否开启tls通信。

    • transport.TLSConfig(*tls.Config)：

    tls证书认证配置，为空时，跳过tls校验。

    srv := micro.NewService(
 micro.Transport(
 transport.NewHTTPTransport(
 transport.Addrs(),
 transport.Codec(nil),
 transport.Timeout(transport.DefaultDialTimeout),
 transport.Secure(true),
 transport.TLSConfig(&tls.Config{Certificates: []tls.Certificate{caCert}}),
 ),
 ),
 )

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    Broker

    • micro.Broker(broker.Broker)：

    统⼀定义服务端和客户端中使⽤的broker插件。

    go-micro将消息通知抽象成了broker.Broker接⼝。官⽅Broker插件库提供的插件包含：gocloud，

    googlepubsub，grpc，http，kafka，memory，mqtt，nats，nsq，proxy，rabbitmq，redis，segmentio，snssqs，sqs，stan，stomp。默认使⽤http。

    以http为例。broker.NewBroker(…broker.Option)返回了broker.httpBroker插件。

    • broker.Addrs(…string)：

    broker订阅地址。发布⽅发布消息后，可通过该地址访问对应节点，进⾏消息通知。

    • broker.Codec(codec.Marshaler)：

    消息编码，解码器。发布消息时进⾏编码，接收消息时进⾏解码。

    • broker.ErrorHandler(broker.Handler)：

    消息错误处理逻辑。在memory插件中使⽤，发送消息出现错误时，进⾏的处理罗。

    • broker.Registry(registry.Registry)：

    设置注册中⼼，httpBroker在订阅时，会向注册中⼼注册⼀条节点订阅信息。httpBroker在发布消息时，会在注册中⼼找到所有订阅的节点，并向这些节点发送消息。

    • broker.Secure(bool)：

    是否开启tls通信broker.TLSConfig(*tls.Config)：tls证书认证配置，为空时，跳过tls校验。

    srv := micro.NewService(
 micro.Broker(
 broker.NewBroker(
 broker.Addrs(),
 broker.Codec(json.Marshaler{}),
 broker.ErrorHandler(func(event broker.Event) error {
 return nil
 }),
 broker.Registry(registry.DefaultRegistry),
 broker.Secure(true),
 broker.TLSConfig(nil),
 ),
 ),
 )

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    Registry

    • micro.Registry(registry.Registry)：

    统⼀定义服务端，客户端，broker组件中使⽤的registry插件。go-micro将服务注册抽象成了registry.Registry接⼝。官⽅Registry插件库提供了众多服务注册插件。包含：cache，consul，etcd，eureka，gossip，kubernetes，mdns，memory，mutli，nacos，nats，proxy，zookeeper。默认采⽤mdns协议。

    以etcd为例：etcd.NewRegistry(…registry.Option)返回了etcd.etcdRegistry插件。

    • registry.Addrs(…string)：

    注册中⼼的地址。也可以通过环境变量MICRO_REGISTRY_ADDRESS，etcd默认127.0.0.1:2379。

    • registry.Timeout(time.Duration)：

    注册超时时间。通过registry.Timeout(time.Duration)设置，默认5s。

    • registry.Secure(bool)：

    是否启⽤tls认证。

    • registry.TLSConfig(*tls.Config)：

    tls认证证书配置。

    • etcd⽤户名，密码：

    通过环境变量ETCD_USERNAME设置⽤户名，环境变量ETCD_PASSWORD设置密码。

    srv := micro.NewService(
 micro.Registry(
etcd.NewRegistry( // 设置etcd注册中⼼
 registry.Addrs(), // etcd 地址。默认127.0.0.1:2379
 registry.Timeout(10*time.Second), // 超时时间
 registry.Secure(true), // 是否启⽤tls
registry.TLSConfig(&tls.Config{Certificates: []tls.Certificate{pair}})
 ), // tls设置
 ),
 )

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    Auth

    • micro.Auth(auth.Auth)：

    定义认证插件。auth的创建和认证，需⾃⾏实现。⽐如在server拦截器中，实现auth逻辑。

    go-micro将认证抽象成了auth.Auth接⼝。官⽅Auth插件库提供的插件包含：jwt。默认不使⽤认证。

    以jwt为例。jwt.NewAuth(…auth.Option)返回了jwt.jwt插件。

    • auth.Addrs(…string)：

    认证地址。jwt未使⽤。

    • auth.Namespace(string)：

    微服务命名空间，以原数据Micro-Namespace存储在context中。

    • auth.PublicKey(string)：

    ⽤于解码jwt。

    • auth.PrivateKey(string)：

    ⽤于编码jwt。

    • auth.Credentials(string, string)：

    存储账号密码。

    • auth.ClientToken(*auth.Token)：

    存储token值。

    srv := micro.NewService(
 micro.Auth(
 jwt.NewAuth(
 auth.Addrs(),
 auth.Namespace("blog"),
 auth.PublicKey("1234567"),
 auth.PrivateKey("7654321"),
 //auth.Credentials("root", "123"),
 //auth.ClientToken(&auth.Token{}),
 ),
 ),
 )

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    Cache

    • micro.Cache(cache.Cache)：

    定义缓存插件。go-micro将缓存抽象成了cache.Cache接⼝。官⽅Cache插件库提供的插件包含：redis。默认使⽤本地内存缓存。

    以redis为例。cache.NewCache(…cache.Option)返回了redis.redisCache插件。

    • cache.Expiration(time.Duration)：

    缓存失效时间。适⽤于本地缓存。

    • cache.Items(map[string]cache.Item)：

    缓存值，适⽤于本地缓存。

    • cache.WithAddress(string)：

    redis服务地址。默认redis://127.0.0.1:6379。

    • cache.WithContext(context.Context)：

    上下⽂。暂时没有⽤到。

    srv := micro.NewService(
 micro.Cache(
 cacheRedis.NewCache(
 cache.Expiration(10*time.Second),
 //cache.Items(nil),
 cache.WithAddress("redis://127.0.0.1:6379"),
 //cache.WithContext(context.Background()),
 ),
 ),
 )

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    Store

    • micro.Store(store.Store)：

    定义存储插件。⼀个store表示⼀张表。

    go-micro将存储抽象成了store.Store接⼝。官⽅Store插件库提供的插件包含：cockroach、consul、file、memcached、memory、mysql、nats-js、redis。默认使⽤memory。

    以redis为例。redis.NewStore(…store.Option)返回了redis.redisCache插件。

    • store.Nodes(…string)：

    redis连接地址。⽀持redis集群。

    • store.Database(string)：

    数据库名称。redis没有⽤到。

    • store.Table(string)：

    表名称。redis中，key值由“表名称“+”key”组成。

    • store.WithContext(context.Context)：

    上下⽂。redis没有⽤到。

    • store.WithClient(client.Client)：

    客户端。redis没有⽤到。

    srv := micro.NewService(
 micro.Store(
 redis.NewStore(
 store.Nodes("127.0.0.1:6379"),
 //store.Database("blog"),
 store.Table("web"),
 //store.WithContext(context.Background()),
 //store.WithClient(nil),
 ),
 ),
 )

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    Config

    • micro.Config(config.Config)：

    定义动态配置插件。

    go-micro将动态配置抽象成了config.Config接⼝。默认使⽤的是config.config插件。官⽅Config插件库提供了两类插件对config.config插件进⾏配置：

    配置插件的格式包含：cue、hcl、toml、xml、yaml。默认json

    配置插件的来源⽅包含：configmap，consul，etcd，grpc，mucp，nacos，nats，pkger，runtimevar，url，vault。默认内存。

    先通过config.Load(…source.Source)，配置插件的来源及格式。然后通过config.Values中提供的⽅法，就可以对配置的值进⾏增删改等操作。

    cfg := config.DefaultConfig() // 定义插件
cfg.Load(etcd.NewSource(source.WithEncoder(yaml.NewEncoder()))) // 对插件进⾏配置
srv := micro.NewService(
 micro.Config(cfg),
 )
srv.Options().Config.Set("value","parentItem","childItem") // 设置配置
srv.Options().Config.Sync()
srv.Options().Config.Get("parentItem","childItem") // 读取配置值

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    Runtime

    • micro.Runtime(runtime.Runtime)：

    定义服务运⾏时。go-micro将服务运⾏时抽象为runtime.Runtime接⼝。官⽅⾃带⽀持两种Runtime插件：kubernetes，memory。

    • kubernetes：

    通过k8sAPI对其他微服务进⾏管理。

    • memory：

    通过本地进程状态来对其他微服务进⾏管理。

    以memory为例。runtime.NewRuntime(…runtime.Option)返回了runtime.runtime组件。

    • runtime.WithSource(string)：

    来源。暂未使⽤。

    • runtime.WithScheduler(runtime.Scheduler)：

    执⾏计划。服务运⾏时插件启动后，会开启⼀个循环来处理事件（事件类型包含：create，delete，update）。⾃定义执⾏计划可以发布⼀个事件交给服务运⾏时来处理。

    • runtime.WithType(string)：

    类型。暂时只在kubernetes中使⽤，以labels的⽅式展示。

    • runtime.WithImage(string)：

    镜像。暂未使⽤。

    • runtime.WithClient(client.Client)：

    服务端，⽤于发起微服务请求。

    type scheduler struct {
 stop chan bool
}
func (s scheduler) Notify() (<-chan runtime.Event, error) {
 var a = make(chan runtime.Event)
 go func() {
 ticker := time.NewTicker(1 * time.Minute)
for {
 select {
 case <-ticker.C:
 a <- runtime.Event{}
 case <-s.stop:
 return
 }
 }
 }()
 return a, nil
}
func (s scheduler) Close() error {
 s.stop <- true
 return nil
}
srv := micro.NewService(
 micro.Runtime(
 runtime.NewRuntime(
 runtime.WithSource("blog"),
 runtime.WithScheduler(&scheduler{}),
 //runtime.WithType("service"),
 //runtime.WithImage("web:1.0"),
 //runtime.WithClient(nil),
 ),
 ),
 ) 

    • 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

    Cmd

    cmd控制程序的启动参数。go-micro，默认对组件的配置进⾏了参数话。可通过以下两个⽅法来扩展启动参数：

    micro.Flags(…cli.Flag)：设置启动参数。

    micro.Action(func(*cli.Context) error)：获取参数并处理。

    srv := micro.NewService(
 micro.Flags(&cli.StringFlag{
 Name: "ca-cert-file",
 Usage: "ca cert file path",
 EnvVars: []string{"CA_CERT_FILE"},
 }, &cli.StringFlag{
 Name: "ca-key-file",
 Usage: "ca key file path",
 EnvVars: []string{"CA_KEY_FILE"},
 }),
 micro.Action(func(c *cli.Context) error {
caCertFile := c.String("ca-cert-file")
caKeyFile := c.String("ca-key-file")
return nil
 }),
 )

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    Profile

    • micro.Profile(profile.Profile)：

    定义了调试组件。

    go-micro将调试插件抽象为profile.Profile接⼝。官⽅⾃带⽀持两种Profile插件：http，pprof。

    http：以http的形式，提供⽹⻚地址进⾏访问。访问地址：/debug/pprof

    pprof：以⽂件的形式保存在本地⽬录。⽬录路径：系统临时⽬录

    • profile.Name(string)：

    设置调试组件的名称。

    srv := micro.NewService(
 micro.Profile(http.NewProfile(profile.Name("web"))),
 )

    • 1
    • 2
    • 3

    流程控制

    • micro.BeforeStart(func() error)：

    服务启动前执⾏的⽅法。可设置多个，先设置的先执⾏。

    • micro.AfterStart(func() error)：

    服务启动后执⾏的⽅法。可设置多个，先设置的先执⾏。

    • micro.BefortStop(func() error)：

    服务关闭前执⾏的⽅法。可设置多个，先设置的先执⾏。

    • micro.AfterStop(func() error)：

    服务关闭后执⾏的⽅法。可设置多个，先设置的先执⾏。

    • micro.HandleSignal(bool)：

    是否⽀持通过系统信号来关闭服务。为true时，当收到SIGTERM、SIGINT、SIGQUIT、SIGKILL信号时，关闭服务。

    srv := micro.NewService(
 micro.BeforeStart(func() error {
 log.Info("before start 1")
 return nil
 }),
 micro.AfterStart(func() error {
 log.Info("after start 1")
 return nil
 }),
 micro.BeforeStart(func() error {
 log.Info("before stop 1")
 return nil
 }),
 micro.BeforeStart(func() error {
 log.Info("after stop 1")
 return nil
 }),
 micro.HandleSignal(true),
 )

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    配置执⾏顺序

    由上述配置可以看到有许多重复的配置。

    go-micro采⽤的是循环加载配置。即放在前⾯的配置会先执⾏，后⾯的配置后执⾏，后执⾏的配置会覆盖先执⾏的配置。

    ⽐如：

    micro.NewService(micro.Server(server.Registry(r1)), micro.Registry(r2))，后配置的注册中⼼r2，会覆盖服务中先配置的注册中⼼r1。

  • 相关阅读:
    像你这么优秀的测试工程师，怎么就约不到面试呢？
    如何用蓝牙实现无线定位（三）--本地定位显示
    一线互联网大厂普遍使用的Docker，掌握这套面试题，让领导主动涨薪
    Ubuntu22.04 安装 MongoDB 7.0
    扩散模型在图像生成中的应用：从真实样例到逼真图像的奇妙转变
    OpenCV入门（C++/Python）- 使用OpenCV标注图像（六）
    激光雷达中国前装大幕开启，数百万颗产能待消化
    liunx常用命令整理
    Profinet转Ethernet IP网关在汽车配件生产中的应用
    C# 面向对象
  • 原文地址：https://blog.csdn.net/CBGCampus/article/details/127421270