154. 服务注册发现之服务注册中心设计原理与Golang实现（一：单机版）

原创 已于 2024-11-17 13:38:12 修改 · 951 阅读 · 16 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#golang #开发语言 #后端

于 2024-11-16 23:24:15 首次发布

文章目录

完整版代码地址：https://github.com/lymgoforit/service_discovery/tree/master

本文主要内容

  • 微服务为什么引入服务注册发现
  • 服务注册中心设计原理

一、Golang 代码实现服务注册中心

为什么引入服务注册发现

从单体架构转向微服务架构过程中，当服务调用其他服务时，如何找到正确的服务地址是最基础问题。服务拆分的早期，将服务调用域名写死到代码或配置文件中，然后通过 Host 配置或 DNS 域名解析进行路由寻址，服务有多个实例，还会加入负载均衡 （Nginx、F5）。服务域名配置模式如下图：
在这里插入图片描述

但人工维护慢慢会出现瓶颈和问题：

  • 新增服务或服务扩容，所有依赖需要新增修改配置
  • 某台服务器挂了还要手动摘流
  • 服务上下线变更时效慢
  • 人工配置错误或漏配
  • RPC 类型服务不能满足 …

这时你会想如果能让服务自动化完成配置（注册）和查找（发现）就好了，于是乎服务注册发现就应运而生。服务注册发现模式如下图：
在这里插入图片描述

可以看出，所有服务提供者在上下线时都会告知服务注册中心，服务消费者要查找服务直接从注册中心拉取。一切都变得更加美好，那么服务注册中心该如何实现呢？简单！优秀的开源项目已有一大把，大名鼎鼎的 Zookeeper、Eureka，还有后期之秀 Consul、Nacos、Etcd，当然有些算是分布式 KV 存储，要实现服务注册发现仍需些额外工作。如何技术选型，是 AP 模式更好还是 CP 模式更好？今天先抛开这些开源项目，我们亲自动手来实现一个服务注册中心，深入理解其设计原理，逐行代码分析与实践。

注册中心实现原理

设计思想

首先进行功能需求分析，作为服务注册中心，要实现如下基本功能：

  1. 服务注册：接受来自服务提交的注册信息，并保存起来
  2. 服务下线：接受服务的主动下线请求，并将服务从注册信息表中删除
  3. 服务获取：调用方从注册中心拉取服务信息
  4. 服务续约：服务健康检查，服务通过心跳保持（主动续约）告知注册中心服务可用
  5. 服务剔除：注册中心将长时间不续约的服务实例从注册信息表中删除

1. 构造注册表

服务中心首先要维护一个服务地址注册信息列表（简称注册表）。通俗理解注册表就像手机通讯录，记录了所有联系人（服务）的电话（服务地址），通过联系人姓名（服务名称）即可找到。

那么如何存储注册表呢？最普遍认知想到存数据库（Redis 这种内存数据库），Zookeeper、Etcd 本身作为分布式 KV 存储天然具有成为注册中心的优势，但这些都会引入新组件，要考虑其稳定性及性能。那么我们可以直接将注册信息存到内存中，这时候你会想如果服务挂了内存数据丢了怎么办？这个问题后面我们会想办法解决。

首先构建一个注册表 Registry 数据结构，定义如下：

type Registry struct {
    apps map[string]*Application
    lock sync.RWMutex
}
  • apps 记录应用服务 Application 的信息，使用 map 结构，key 为应用服务的唯一标识，值为应用服务结构类型
  • lock 读写锁，保障并发读写安全

应用服务 Application结构如下：

type Application struct {
    appid           string
    instances       map[string]*Instance
    latestTimestamp int64
    lock            sync.RWMutex
}

  • appid 记录应用服务唯一标识

  • lock 读写锁，保障并发读写安全

  • latestTimestamp 记录更新时间

  • instances 记录服务实例 Instance 的信息，使用 map 结构，key 为实例的 hostname （唯一标识），值为实例结构类型

服务实例 Instance 的结构如下：

type Instance struct {
    Env      string   `json:"env"`
    AppId    string   `json:"appid"`
    Hostname string   `json:"hostname"`
    Addrs    []string `json:"addrs"`
    Version  string   `json:"version"`
    Status   uint32   `json:"status"`

    RegTimestamp    int64 `json:"reg_timestamp"`
    UpTimestamp     int64 `json:"up_timestamp"`
    RenewTimestamp  int64 `json:"renew_timestamp"`
    DirtyTimestamp  int64 `json:"dirty_timestamp"`
    LatestTimestamp int64 `json:"latest_timestamp"`
}

  • Env 服务环境标识，如 online、dev、test

  • AppId 应用服务的唯一标识

  • Hostname 服务实例的唯一标识

  • Addrs 服务实例的地址，可以是 http 或 rpc 地址，多个地址可以维护数组

  • Version 服务实例版本

  • Status 服务实例状态，用于控制上下线

  • xxTimestamp 依次记录服务实例注册时间戳，上线时间戳，最近续约时间戳，脏时间戳（后面解释），最后更新时间戳

注册表及相关依赖的结构体构建完成了，梳理一下所有概念和关系。注册表 Registry 中存放多个应用服务 Application（如多个服务 PSM），每个应用服务又会有多个服务实例 Instance（如多个k8s pod)，服务实例中存储服务的具体地址(可以有多个地址，如一个实例可以同时有IPv4和IPv6两个地址）和其他信息。

在这里插入图片描述

2. 服务注册

功能目标：接受来自服务提交的注册信息，并保存到注册表中。先初始化注册表 NewRegistry() ，根据提交信息构建实例 NewInstance()，然后进行注册写入。

func NewRegistry() *Registry {
    registry := &Registry{
        apps: make(map[string]*Application),
    }
    return registry
}

func NewInstance(req *RequestRegister) *Instance {
    now := time.Now().UnixNano()
    instance := &Instance{
        Env:             req.Env,
        AppId:           req.AppId,
        Hostname:        req.Hostname,
        Addrs:           req.Addrs,
        Version:         req.Version,
        Status:          req.Status,
        RegTimestamp:    now,
        UpTimestamp:     now,
        RenewTimestamp:  now,
        DirtyTimestamp:  now,
        LatestTimestamp: now,
    }
    return instance
}
r := NewRegistry()
instance := NewInstance(&req)
r.Register(instance, req.LatestTimestamp)

注册时，先从 apps 中查找是否已注册过，根据唯一标识key = appid + env 确定。如果没有注册过，先新建应用 app，然后将instance加入到 app 中，最后app放入注册表中。这里分别使用了读锁和写锁，保障数据安全同时，尽量减少锁时间和锁抢占影响。

func (r *Registry) Register(instance *Instance, latestTimestamp int64) (*Application, *errcode.Error) {
    key := getKey(instance.AppId, instance.Env)
    r.lock.RLock()
    app, ok := r.apps[key]
    r.lock.RUnlock()
    if !ok { //new app
        app = NewApplication(instance.AppId)
    }
    //add instance
    _, isNew := app.AddInstance(instance, latestTimestamp)
   // if isNew { //todo }
    //add into registry apps
    r.lock.Lock()
    r.apps[key] = app
    r.lock.Unlock()
    return app, nil
}

新建应用服务 app，初始化instances

func NewApplication(appid string) *Application {
    return &Application{
        appid:     appid,
        instances: make(map[string]*Instance),
    }
}

将服务主机实例instance加入应用 app 中，注意判断是否已存在，存在根据脏时间戳 DirtyTimestamp 比对，是否进行替换，添加实例信息，更新最新时间 latestTimestamp ，并返回实例。

func (app *Application) AddInstance(in *Instance, latestTimestamp int64) (*Instance, bool) {
    app.lock.Lock() 
    defer app.lock.Unlock()
    appIns, ok := app.instances[in.Hostname]
    if ok { //exist
        in.UpTimestamp = appIns.UpTimestamp
        //dirtytimestamp
        if in.DirtyTimestamp < appIns.DirtyTimestamp {
            log.Println("register exist dirty timestamp")
            in = appIns
        }
    }
    //add or update instances
    app.instances[in.Hostname] = in
    app.upLatestTimestamp(latestTimestamp)
    returnIns := new(Instance)
    *returnIns = *in
    return returnIns, !ok
}

返回 !ok （isNew）表明，本次服务注册时，实例为新增还是替换，用来维护服务健康信息（后面会再次提到）。

服务注册完成了，编写测试用例看下效果。

var req = &model.RequestRegister{AppId: "com.xx.testapp", Hostname: "myhost", Addrs: []string{"http://testapp.xx.com/myhost"}, Status: 1}
func TestRegister(t *testing.T) {
    r := model.NewRegistry()
    instance := model.NewInstance(req)
    app, _ := r.Register(instance, req.LatestTimestamp)
    t.Log(app)
}

在这里插入图片描述

3. 服务发现

功能目标：查找已注册的服务获取信息，可以指定条件查找，也可以全量查找。这里以指定过滤条件 appid 、env 和 status 为例。

r := model.NewRegistry()
fetchData, err := r.Fetch(req.Env, req.AppId, req.Status, 0)

根据 appid 和 env 组合成 key，然后从注册表的 apps 中获取应用 app，然后通过 app 获取服务实例 GetInstance()

func (r *Registry) Fetch(env, appid string, status uint32, latestTime int64) (*FetchData, *errcode.Error) {
    app, ok := r.getApplication(appid, env)
    if !ok {
        return nil, errcode.NotFound
    }
    return app.GetInstance(status, latestTime)
}
func (r *Registry) getApplication(appid, env string) (*Application, bool) {
    key := getKey(appid, env)
    r.lock.RLock() 
    app, ok := r.apps[key]
    r.lock.RUnlock()
    return app, ok
}

根据 app 获取所有应用实例，并用 status 过滤，这里对返回结果 instances 中的 Addr 进行了拷贝返回一个新的切片。

func (app *Application) GetInstance(status uint32, latestTime int64) (*FetchData, *errcode.Error) {
    app.lock.RLock()
    defer app.lock.RUnlock()
    if latestTime >= app.latestTimestamp {
        return nil, errcode.NotModified
    }
    fetchData := FetchData{
        Instances:       make([]*Instance, 0),
        LatestTimestamp: app.latestTimestamp,
    }
    var exists bool
    for _, instance := range app.instances {
        if status&instance.Status > 0 {
            exists = true
            newInstance := copyInstance(instance)
            fetchData.Instances = append(fetchData.Instances, newInstance)
        }
    }
    if !exists {
        return nil, errcode.NotFound
    }
    return &fetchData, nil
}
//deep copy
func copyInstance(src *Instance) *Instance {
    dst := new(Instance)
    *dst = *src
    //copy addrs
    dst.Addrs = make([]string, len(src.Addrs))
    for i, addr := range src.Addrs {
        dst.Addrs[i] = addr
    }
    return dst
}

编写测试用例，先注册再获取，看到可以正常获取到信息。
在这里插入图片描述

4. 服务下线

功能目标：接受服务的下线请求，并将服务从注册信息列表中删除。通过传入 env, appid, hostname 三要素信息进行对应服务实例的取消。

r := model.NewRegistry()
r.Cancel(req.Env, req.AppId, req.Hostname, 0)

根据 appid 和 env 找到对象的 app，然后删除 app 中对应的 hostname。如果 删除hostname 后 app.instances 也变成了空，即该app的最后一个实例都被删除了，那么将 app 从注册表中清除。

func (r *Registry) Cancel(env, appid, hostname string, latestTimestamp int64) (*Instance, *errcode.Error) {
    log.Println("action cancel...")
    //find app
    app, ok := r.getApplication(appid, env)
    if !ok {
        return nil, errcode.NotFound
    }   
    instance, ok, insLen := app.Cancel(hostname, latestTimestamp)
    if !ok {
        return nil, errcode.NotFound
    }   
    //if instances is empty, delete app from apps
    if insLen == 0 { 
        r.lock.Lock()
        delete(r.apps, getKey(appid, env))
        r.lock.Unlock()
    }   
    return instance, nil 
}
func (app *Application) Cancel(hostname string, latestTimestamp int64) (*Instance, bool, int) {
    newInstance := new(Instance)
    app.lock.Lock()
    defer app.lock.Unlock()
    appIn, ok := app.instances[hostname]
    if !ok {
        return nil, ok, 0
    }   
    //delete hostname
    delete(app.instances, hostname)
    appIn.LatestTimestamp = latestTimestamp
    app.upLatestTimestamp(latestTimestamp)
    *newInstance = *appIn
    return newInstance, true, len(app.instances)
}

编写测试用例先注册，再取消，然后获取信息，发现 404 not found。

在这里插入图片描述

5. 服务续约

功能目标：实现服务的健康检查机制，服务注册后，如果没有取消，那么就应该在注册表中，可以随时查到，如果某个服务实例挂了，能否自动的从注册表中删除，保障注册表中的服务实例都是正常的。

通常有两种方式做法：

  1. 注册中心（服务端）主动探活，通过请求指定接口得到正常响应来确认
  2. 服务实例（客户端）主动上报，调用续约接口进行续约，续约设有时效 TTL （time to live）。

两种方式各有优缺点，大家可以思考一下，不同的注册中心也采用了不同的方式，这里选型第二种方案。

r := model.NewRegistry()
r.Renew(req.Env, req.AppId, req.Hostname)

根据 appid 和 env 找到对象的 app，再根据 hostname 找到对应主机实例，更新其 RenewTimestamp 为当前时间。

func (r *Registry) Renew(env, appid, hostname string) (*Instance, *errcode.Error) {
    app, ok := r.getApplication(appid, env)
    if !ok {
        return nil, errcode.NotFound
    }
    in, ok := app.Renew(hostname)
    if !ok {
        return nil, errcode.NotFound
    }       
    return in, nil
}  
func (app *Application) Renew(hostname string) (*Instance, bool) {
    app.lock.Lock()
    defer app.lock.Unlock()
    appIn, ok := app.instances[hostname]
    if !ok {
        return nil, ok
    }
    appIn.RenewTimestamp = time.Now().UnixNano()
    return copyInstance(appIn), true
}

6. 服务剔除

功能目标：既然有服务定期续约，那么对应的如果服务没有续约呢？服务如果下线可以使用 Cancel 进行取消，但如果服务因为网络故障或挂了导致不能提供服务，那么可以通过检查它是否按时续约来判断，把 TTL 达到阈值的服务实例剔除（Cancel），实现服务的被动下线。

首先在新建注册表时开启一个定时任务，新启一个 goroutine 来实现。

func NewRegistry() *Registry {
  go r.evictTask()
}

配置定时检查的时间间隔，默认 60 秒，通过 Tick 定时器开启 evict。

func (r *Registry) evictTask() {
    ticker := time.Tick(configs.CheckEvictInterval)
    for {
        select {
        case <-ticker:
            r.evict()
        }
    }
}

遍历注册表的所有 apps，然后再遍历其中的 instances，如果当前时间减去实例上一次续约时间instance.RenewTimestamp达到阈值（默认 90 秒），那么将其加入过期队列中。这里并没有直接将过期队列所有实例都取消，考虑 GC 以及 本地时间漂移的因素，设定了一个剔除的上限 evictionLimit，随机剔除一些过期实例。

func (r *Registry) evict() {
    now := time.Now().UnixNano()
    var expiredInstances []*Instance
    apps := r.getAllApplications()
    var registryLen int
    for _, app := range apps {
        registryLen += app.GetInstanceLen()
        allInstances := app.GetAllInstances()
        for _, instance := range allInstances {
            if now-instance.RenewTimestamp > int64(configs.InstanceExpireDuration) {
                expiredInstances = append(expiredInstances, instance)
            }
        }
    }
    evictionLimit := registryLen - int(float64(registryLen)*configs.SelfProtectThreshold)
    expiredLen := len(expiredInstances)
    if expiredLen > evictionLimit {
        expiredLen = evictionLimit
    }

    if expiredLen == 0 {
        return
    }
    for i := 0; i < expiredLen; i++ {
        j := i + rand.Intn(len(expiredInstances)-i)
        expiredInstances[i], expiredInstances[j] = expiredInstances[j], expiredInstances[i]
        expiredInstance := expiredInstances[i]
        r.Cancel(expiredInstance.Env, expiredInstance.AppId, expiredInstance.Hostname, now)
    }
}
  • 剔除上限数量，是通过当前注册表大小（注册表所有instances实例数）减去 触发自我保护机制的阈值（当前注册表大小 * 保护自我机制比例值），保护机制稍后会具体解释。
  • 剔除过期时，采用了 Knuth-Shuffle 算法，也叫公平洗牌算法来实现随机剔除。当然如果 expiredLen <= evictionLimit，随机剔除的意义不大，如果前者大于后者，随机剔除能最大程度保障，剔除的实例均匀分散到所有应用实例中，降低某服务被全部清空的风险。公平洗牌算法实现也比较简单，循环遍历过期列表，将当前数与特定随机数交换，和我们打牌时两两交换洗牌过程类似，它实现了 O(n) 的时间复杂度，由 Knuth 发明。

7. 自我保护

功能目标：既然服务会定期剔除超时未续约的服务，那么假设一种情况，网络一段时间发生了异常，所有服务都没成功续约，这时注册中心是否将所有服务全部剔除？当然不行！所以，我们需要一个自我保护的机制防止此类事情的发生。

怎么设计自我保护机制呢？按短时间内失败的比例达到某特定阈值就开启保护，保护模式下不进行服务剔除。所以我们需要一个统计模块，续约成功 +1。默认情况下，服务剔除每 60 秒执行一次，服务续约每 30 秒执行一次，那么一个服务实例在检查时应该有 2 次续约。

type Guard struct {
    renewCount     int64
    lastRenewCount int64
    needRenewCount int64
    threshold      int64
    lock           sync.RWMutex
}

  • renewCount 记录所有服务续约次数，每执行一次 renew 加 1

  • lastRenewCount 记录上一次检查周期（默认 60 秒）服务续约统计次数

  • needRenewCount 记录一个周期总计需要的续约数，按一次续约 30 秒，一周期 60 秒，一个实例就需要 2 次，所以服务注册时 + 2，服务取消时 - 2

  • threshold 通过 needRenewCount 和阈值比例 （0.85）确定触发自我保护的值

func (gd *Guard) incrNeed() {
    gd.lock.Lock()
    defer gd.lock.Unlock()
    gd.needRenewCount += int64(configs.CheckEvictInterval / configs.RenewInterval)
    gd.threshold = int64(float64(gd.needRenewCount) * configs.SelfProtectThreshold)
}
func (gd *Guard) decrNeed() {
    gd.lock.Lock()
    defer gd.lock.Unlock()
    gd.needRenewCount -= int64(configs.CheckEvictInterval / configs.RenewInterval)
    gd.threshold = int64(float64(gd.needRenewCount) * configs.SelfProtectThreshold)
}
func (gd *Guard) setNeed(count int64) {
    gd.lock.Lock()
    defer gd.lock.Unlock()
    gd.needRenewCount = count * int64(configs.CheckEvictInterval/configs.RenewInterval)
    gd.threshold = int64(float64(gd.needRenewCount) * configs.SelfProtectThreshold)
}
func (gd *Guard) incrCount() {
    atomic.AddInt64(&gd.renewCount, 1)
}

在注册表中增加 Guard 模块并初始化，在服务注册成功，服务取消，服务续约时操作统计。

type Registry struct {
    gd   *Guard
}
func NewRegistry() *Registry {
    r := &Registry{
      gd:   new(Guard),
    } 
}
func (r *Registry) Register(...) {
    if isNew {
      r.gd.incrNeed()
    }
}
func (r *Registry) Cancel(...) {
   r.gd.decrNeed()
}
func (r *Registry) Renew(...) {
   r.gd.incrCount()
}

在服务剔除前进行上一周期计数统计，并判断是否达到自我保护开启状态。

func (gd *Guard) storeLastCount() {
    atomic.StoreInt64(&gd.lastRenewCount, atomic.SwapInt64(&gd.needRenewCount, 0))
}
func (gd *Guard) selfProtectStatus() bool {
    return atomic.LoadInt64(&gd.lastRenewCount) < atomic.LoadInt64(&gd.threshold)
}

如果开启自我保护，那么续约时间超过阈值（默认90 秒）忽略不会剔除。但如果续约时间超过最大阈值（默认3600 秒），那么不管是否开启保护都要剔除。因为自我保护只是保护短时间由于网络原因未续约的服务，长时间未续约大概率已经有问题了。

func (r *Registry) evictTask() {
        case <-ticker:
          r.gd.storeLastCount()
            r.evict()
        }
}
func (r *Registry) evict() {
   delta := now - instance.RenewTimestamp
   if !protectStatus && delta > int64(configs.InstanceExpireDuration) ||
      delta > int64(configs.InstanceMaxExpireDuration) {
      expiredInstances = append(expiredInstances, instance)
   }
}

思考下，服务续约比例未达到 85% 就会触发自我保护，还记不记得在服务剔除那块有一个剔除数量上限不能超过 15%，这里就match了，否则还没来得及进入自我保护程序就把服务都剔除了。

最后增加一个定时器，如果超过一定时间（15 分钟），重新计算下当前实例数，重置保护阈值，降低脏数据风险。

func (r *Registry) evictTask() {
    resetTicker := time.Tick(configs.ResetGuardNeedCountInterval)
    for {
        select { 
        case <-resetTicker:
            var count int64
            for _, app := range r.getAllApplications() {
                count += int64(app.GetInstanceLen())
            }
            r.gd.setNeed(count)
        }
    }
}

三、注册中心对外提供服务

目前注册中心基本功能已实现，需要对外提供服务了，我们采用 gin 来实现一个 web 服务，接受http请求进行服务的注册、查找、续约、下线操作，这样保障注册中心可以方便的接受来自任何语言客户端请求。

func main() {
    //init config
    c := flag.String("c", "", "config file path")
    flag.Parse()
    config, err := configs.LoadConfig(*c)
    if err != nil {
        log.Println("load config error:", err)
        return
    }  
    //global discovery
    global.Discovery = model.NewDiscovery(config)
    //init router and start server
    router := api.InitRouter()
    srv := &http.Server{
        Addr:    config.HttpServer,
        Handler: router,
    }
    go func() {
        if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatalf("listen:%s\n", err)
        }
    }()
}

增加一个 discovery 结构，并开启一个全局变量 global.Discovery ，该结构中维护注册表 Registry，然后就可以根据注册表实现各种操作了。

type Discovery struct {
    config    *configs.GlobalConfig
    protected bool
    Registry  *Registry
}
func NewDiscovery(config *configs.GlobalConfig) *Discovery {
    dis := &Discovery{
        protected: false,
        config:    config,
        Registry:  NewRegistry(), //init registry
    }  
    return dis 
}
//init discovery
var Discovery *model.Discovery
api.InitRouter() // 绑定 url 路由和 Handler，以注册为例，接受请求入参，调用 global.Discovery.Registry.Register() 进行注册，成功返回。
router.POST("api/register", handler.RegisterHandler)
func RegisterHandler(c *gin.Context) {
    var req model.RequestRegister
    if e := c.ShouldBindJSON(&req); e != nil {
        err := errcode.ParamError
        c.JSON(http.StatusOK, gin.H{
            "code":    err.Code(),
            "message": err.Error(),
        })
        return
    }
    //bind instance
    instance := model.NewInstance(&req)
    if instance.Status == 0 || instance.Status > 2 {
        err := errcode.ParamError
        c.JSON(http.StatusOK, gin.H{
            "code":    err.Code(),
            "message": err.Error(),
        })
        return
    }
    //dirtytime
    if req.DirtyTimestamp > 0 {
        instance.DirtyTimestamp = req.DirtyTimestamp
    }
    global.Discovery.Registry.Register(instance, req.LatestTimestamp)
    c.JSON(http.StatusOK, gin.H{
        "code":    200,
        "message": "",
        "data":    "",
    })
}

接着要实现平滑重启，在 main 启动时增加接收信号后关闭服务。

func main() {
    //...
    //graceful restart
    quit := make(chan os.Signal)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP, syscall.SIGQUIT)
    <-quit
    log.Println("shutdown discovery server...")
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    if err := srv.Shutdown(ctx); err != nil {
        log.Fatal("server shutdown error:", err)
    }
    select {
    case <-ctx.Done():
        log.Println("timeout of 5 seconds")
    }
    log.Println("server exiting")
}

实现效果如图所示：

在这里插入图片描述

四、工程实践

  • 使用 go module管理依赖的三方包 （gin 和 yaml）

  • api 存放 http 服务路由以及对应处理函数

  • cmd 存放编译入口 main 文件

  • configs 存放全局配置和全局常量

  • global 存放全局结构变量

  • model 存放注册表结构模型及主要逻辑

在这里插入图片描述

总结与问题

以上注册中心实现的所有功能如下图
在这里插入图片描述

至此，一个单机版的注册中心就可以工作了，但生产环境单点肯定是不能容忍的，因此有必要实现一个注册中心集群。那么是否部署多个注册中心实例就可以了，当然不行！这只能保障有多个注册中心节点，而每个节点中维护自己的注册表，那么就需要进行注册表数据同步。多节点数据同步又会涉及著名的一致性问题，这时Paxos、Raft、ZAB、Gossip 等算法名词涌现，而我们将使用 P2P（Peer to Peer）对等网络协议来实现。关于集群设计与实现我们将在后续文章中展开。

原文地址：https://mp.weixin.qq.com/s?__biz=MzIyMzMxNjYwNw==&mid=2247484142&idx=1&sn=0844fc63f9463b614afc23f450f266f2&chksm=e8215dfedf56d4e8c11c3e87c4a71de5fe65ad20fdd5a92c6ee58e8c3e0ba358e03f4e4e1f2e&cur_album_id=1511862059553095681&scene=190#rd

Golang cron 源码剖析：理解定时任务的核心实现原理
Golang编程笔记的博客
07-06 981
本文聚焦库的核心实现原理，覆盖从cron表达式解析、任务注册、调度循环到任务执行的全流程。适合有一定Golang基础，想深入理解定时任务底层机制的开发者。本文将按“概念类比→核心结构→调度流程→关键源码→实战验证”的逻辑展开，重点剖析Cron结构体、Entry任务实体、调度循环三大模块，最后通过一个“定时发送早安消息”的案例验证理论。的核心结构体在cron.goentries []*Entry // 所有任务的“档案卡”列表chain Chain // 任务执行链（用于中间件，如日志、重试）
Golang领域RWMutex：并发编程的新宠儿
Golang编程笔记的博客
05-15 1136
本文旨在系统解析Golang中读写锁与普通互斥锁的核心区别RWMutex在不同并发场景下的性能优势如何避免使用读写锁时的常见陷阱（如写饥饿、锁粒度不当等）结合具体案例演示从需求分析到锁策略选择的完整过程基础概念：对比Mutex与RWMutex，建立读写分离的核心认知原理剖析：解析Golang源码级实现，揭示计数器、状态机等关键机制实战指南：通过完整项目案例演示API使用、性能测试及问题排查应用扩展：探讨分布式场景下的读写锁变种及与其他同步机制的结合互斥锁（Mutex）
Golang使用Consul作为注册中心
源滚滚编程
01-23 2498
zdpgo_consul Golang使用Consul作为注册中心 项目地址：https://github.com/zhangdapeng520/zdpgo_consul 一、快速入门 1.1 服务注册 // 测试服务注册 func TestConsul_Register(t *testing.T) { c := New(ConsulConfig{ Debug: true, Host: "127.0.0.1", Port: 8500, }) c.Register(ServiceCo
使用go语言实现一个简单的注册中心.zip
05-16
使用go语言实现一个简单的注册中心 使用go语言实现一个简单的注册中心 使用go语言实现一个简单的注册中心 使用go语言实现一个简单的注册中心 使用go语言实现一个简单的注册中心 使用go语言实现一个简单的注册中心 使用go语言实现一个简单的注册中心 使用go语言实现一个简单的注册中心 使用go语言实现一个简单的注册中心 使用go语言实现一个简单的注册中心 使用go语言实现一个简单的注册中心 使用go语言实现一个简单的注册中心 使用go语言实现一个简单的注册中心 使用go语言实现一个简单的注册中心 使用go语言实现一个简单的注册中心 使用go语言实现一个简单的注册中心
Golang-动手实现一个分布式注册中心
jiohfgj的博客
07-07 996
以一个日志微服务为例，将日志服务注册到注册中心展开！其实这一个日志类的功能就是有基本的写文件功能，然后就是注册一个http的接口去写日志进去 log/Client.go 提供给外部服务的接口，定义好日志的命名格式，来显示调用接口去使用已经注册好的日志接口并且返回状态 主启动程序LogService 启动服务,主要执行start方法，里面有细节实现服务注册与服务发现 服务启动与注册 service/service.go 服务注册与发现 registry/client.go 注册服务的时候会连着心跳以及
go-mciro系列(五)使用nacos作为注册中心(2)，34岁Golang开发大叔感慨
2401_84302507的博客
04-17 764
以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！// 这里有一个问题，这个现成的plugin有个问题没有办法设置namespace。// NewRegistry 注册nacos。// 获取nacos注册中心实例。// nacos注册中心地址。// 使用naocs配置中心。
golang微服务 使用Consul进行服务注册与服务发现
qq_62906402的博客
06-22 458
上述代码是对grpc服务层进行注册，对于web层来说，它和grpc服务层的区别在于，其健康检查可以直接配置一个接收"/health"的路由，处理这个请求时返回200的状态，这样就可以轻松的完成健康检查。下面是对注册服务封装成一个工具类。如果一个服务注册进了conusl的话，我们就可以通过服务名从consul中获取到对应的服务。
Golang Redis客户端实现分布式限流的完整实现
Golang编程笔记的博客
05-07 1033
在分布式系统中，限流是保障服务稳定性的关键机制。传统单体应用的本地限流无法应对分布式场景下的流量聚合问题，因此需要基于共享存储（如Redis）实现全局统一的限流策略。本文将详细讲解如何使用Golang语言和Redis客户端实现两种主流限流算法（令牌桶和漏桶），并提供完整的工程化实现方案，包括算法原理、代码实现、性能优化和实战案例。背景介绍：明确目标、读者和文档结构，定义核心术语核心概念与联系：对比令牌桶与漏桶算法，绘制原理示意图核心算法原理：基于Golang实现单机版算法，为分布式改造铺垫。
Golang中实现分布式map的思路
Golang编程笔记的博客
06-06 828
在单机环境中，Go的map类型可以高效存储键值对，但当数据量超过单机内存限制，或需要更高的读写并发能力时，就需要将数据分布到多台机器上，形成“分布式Map”。本文将聚焦如何用Go语言实现一个基础版的分布式Map，覆盖数据分片、节点通信、副本容错等核心功能，不涉及超大规模集群的复杂优化（如跨数据中心同步）。用生活案例解释分布式Map的关键概念（分片、一致性哈希等）用数学公式和Go代码详解一致性哈希算法手把手实现一个包含节点发现、数据分片、副本同步的分布式Map讨论实际应用中的优化方向和挑战。
golang-将服务注册到consul注册中心
qq_37430469的博客
10-18 450
1,在项目中定义服务名称,以及版本号,以及名称。2,将服务注册到注册中心。
微服务注册中心设计原理与Golang实现
kevin_tech的博客，微信搜「网管叨bi叨」
12-02 1006
微服务为什么要用注册中心搞注册发现？直接用域名不香吗？不好意思，还真不太香。这篇文章我们来一起看看，为啥微服务架构里要引入注册中心，以及服务注册和发现大致的原理是什么。内容提要通过本文您将 get 如下知识：微服务为什么引入服务注册发现服务注册中心设计原理Golang 代码实现服务注册中心为什么引入服务注册发现从单体架构转向微服务架构过程中，当服务调用其他服务时，如何找到正确的服务地址是最基础问题...
go有哪些配置中心和注册中心
leijmdas的专栏
08-11 711
它不仅支持配置中心的功能，还支持服务注册与发现，并且可以作为动态DNS服务使用。例如，使用Nacos的Go SDK可以方便地进行配置的获取和监听配置变化，以及服务的注册和发现。配置中心用于统一管理应用的配置信息，而注册中心则用于服务的发现和注册。1. Nacos：Nacos同样提供了服务注册与发现的功能，支持基于DNS和基于RPC的服务发现，同时支持CP和AP模式，允许灵活切换。5. ETCD：作为键值存储系统，ETCD也可以用于服务注册与发现，通过键值对存储服务信息，并支持Watch机制来监听服务变化。
Go Web后端开发：实现服务发现与注册的方法
欢迎来到我的优快云空间！这里聚焦AI大模型应用实战，分享前沿技术、实战案例与开发经验。
05-11 1133
在现代分布式系统架构中，服务发现与注册是微服务架构的核心基础设施之一。本文旨在为Go语言开发者提供一套完整的服务发现与注册实现方案，涵盖从基础概念到实际应用的各个方面。介绍服务发现与注册的基本概念分析主流实现方案和技术选型详细讲解Go语言中的具体实现探讨实际应用场景和最佳实践展望未来发展趋势服务注册(Service Registration): 服务实例启动时向注册中心登记自身信息的过程服务发现(Service Discovery): 客户端或代理查询注册中心以获取可用服务实例的过程。
go 进阶 注册中心: 二. etcd 与 golang
qq_29799655的博客
05-10 354
【代码】go 进阶 注册中心: 二. etcd 与 golang。
go 进阶 注册中心: 一. etcd 入门
qq_29799655的博客
05-09 2302
etcd 是一款用go语言编写的分布式存储中间件,采用Raft算法保证分布式系统数据的强一致性,通过分布式锁、leader选举和写屏障(write barriers)，来实现可靠的分布式协作应用场景服务发现（Service Discovery）消息发布与订阅负载均衡分布式通知与协调分布式锁、分布式队列集群监控与Leader竞选etcd满足了cap理论中的cp指标(c:一致性, a可用性, p分区容错性)
Golang深入浅出之-Go语言中的服务注册与发现机制
zevjay的博客
05-04 754
服务注册与发现是微服务架构中的重要组件，它允许服务实例在启动时向注册中心注册自己，同时其他服务能够动态地发现并调用这些已注册的服务。在Go语言生态中，这一机制的实现尤为关键，本文将深入浅出地探讨其原理、常见问题、易错点及解决方案，并提供代码示例。
go注册中心应备功能
leijmdas的专栏
05-04 395
9. **实现服务剔除**：注册中心应定期检查服务实例的心跳，并在未收到心跳的情况下将服务实例标记为不健康或从注册中心中移除。6. **服务下线逻辑**：实现逻辑以处理服务实例的下线，可以是服务实例主动调用API注销，或注册中心通过超时机制识别。3. **健康检查**：注册中心需要能够对注册的服务实例进行健康检查，以确保只有健康的服务实例对消费者可见。4. **服务下线**：服务实例在关闭时能够主动从注册中心注销，或者注册中心能够识别并移除不健康的服务实例。
14. Go实现简易分布式注册中心
YouMing_Li的博客
09-24 818
以一个日志微服务为例，将日志服务注册到注册中心展开！
Go微服务实战——服务的注册与获取（nacos做服务注册中心）
个人学习笔记库，一篇一篇记录成长的足迹
03-14 3932
注册中心就像DNS服务器，注册中心是`C/S`架构，服务调用者通过`Client`调用服务名称，被调用者通过`Client`上传服务名称和ip并发送心跳检测该服务的健康状态。注册中心为`server`端保存服务名称和服务的ip地址及端口，这样不论被调用者服务如何变化，只要服务名称不变，调用者都不受影响。
go语言技术栈， 如何实现一个注册中心？为什么需要注册中心？
最新发布
08-26
<think>首先，用户的问题是：“我想了解在Go语言技术栈中如何实现注册中心及其作用 请问Go语言 实现 注册中心 方法 为什么需要注册中心”。这需要我解释注册中心的作用、在Go中实现的方法，以及为什么需要它。 系统级指令： - 所有行内数学表达式用$...$。 - 独立公式用$$...$$并单独成段。 - LaTeX语法正确。 - 使用中文回答。 - 生成相关问题。 - 回答中引用的段落末尾自然地添加引用标识，如[^1]。 用户可见层： - 结构清晰，逐步解决问题。 - 保证回答真实可靠。 参考站内引用： - [^1]: 服务注册发现之服务注册中心设计原理与Golang实现（单机版）。 - [^2]: Go实现简易分布式注册中心。 - [^3]: 使用Go和Consul作为服务注册和配置中心。 - [^4]: 使用Go实现一个注册中心。 - [^5]: Go语言实现微服务注册中心。 这些引用提供了背景信息，我需要基于这些内容来构建回答。用户的问题是“如何实现注册中心及其作用”，所以我需要覆盖： 1. 注册中心的作用（为什么需要）。 2. 在Go中实现的方法。 结构： - 先解释为什么需要注册中心。 - 然后描述在Go中实现的方法。 - 最后生成相关问题。 为什么需要注册中心： - 在微服务架构中，服务数量多，动态变化（启动、停止），服务之间需要通信。 - 注册中心用于服务发现：服务注册自己，其他服务发现可用的服务实例。 - 避免硬编码服务地址，支持动态扩展、负载均衡、故障恢复。 在Go中实现注册中心的方法： - 参考引用： - [^1]：单机版注册中心，包括注册表、服务注册、服务发现、服务下线、服务续约、服务剔除、自我保护。 - [^2]：简易分布式注册中心，使用Raft协议。 - [^3]：使用Consul作为注册中心。 - [^4]：定义服务模型，实现Raft。 - [^5]：微服务注册中心，支持单节点和集群，使用Raft协议。 - 基本组件： - 服务模型：定义服务结构，如ID、名称、地址、端口。 - 注册表：存储服务实例，通常用map或数据库。 - API：提供注册、发现、下线等接口。 - 分布式一致性：使用Raft或类似协议（如etcd、Consul）来保证高可用。 - 实现步骤： 1. 定义服务数据结构。 2. 实现注册逻辑：服务启动时向注册中心注册。 3. 实现发现逻辑：客户端查询注册中心获取服务实例。 4. 处理服务健康检查：通过心跳机制（服务续约）来检测服务是否存活。 5. 服务剔除：自动移除不健康的服务实例。 6. 如果分布式，实现共识算法如Raft。 使用中文回答： - 整个回答用中文。 生成相关问题： - 在回答末尾，添加“相关问题”部分，如示例所示。 引用标识： - 在回答中，当引用特定内容时，在末尾添加[^n]，如[^1]。 逐步解决问题： - 先介绍注册中心的作用。 - 然后解释在Go中实现的方法。 - 可能包括代码片段，但根据指令，代码块用```...```格式。 代码示例： - 引用[^1]提到Golang实现，我可以简要描述或提供伪代码。 - 引用[^4]有服务模型定义。 完整结构： 1. **引言**：解释注册中心的概念。 2. **为什么需要注册中心**：详细说明作用和好处。 3. **Go语言实现注册中心的方法**：描述关键组件和步骤。 4. **示例代码**：提供简单代码片段（如服务模型定义）。 5. **相关问题**：生成3-5个相关问题。 相关问题： - 基于主题，如注册中心的优化、挑战、与Consul的比较等。 确保真实可靠： - 基于提供的引用和一般知识。 - 引用内容时添加标识。 最终输出： - 用中文。 - 结构清晰。 - 末尾有相关问题。</think>### 注册中心的作用及在Go语言中的实现方法 在微服务架构中，服务数量众多且动态变化（如服务启动、停止或扩展），服务之间需要高效通信。注册中心（Service Registry）作为核心组件，负责服务注册与发现，确保系统可伸缩、高可用。下面我将逐步解释为什么需要注册中心，以及如何在Go语言中实现它。回答基于站内引用内容，并结合实际技术原理，确保真实可靠。 #### 1. **为什么需要注册中心？** 注册中心解决了微服务架构中的几个关键问题： - **服务发现（Service Discovery）**：服务实例动态变化时，客户端无需硬编码服务地址，而是通过注册中心查询可用实例。这避免了地址管理的复杂性，支持负载均衡和故障转移[^1]。 - **健康检查与故障恢复**：注册中心通过心跳机制（如服务续约）监控服务健康状态，自动剔除失效实例，提高系统韧性[^1][^5]。 - **动态扩展**：当服务实例增加或减少时，注册中心实时更新服务列表，支持无缝扩容[^2]。 - **配置中心集成**：注册中心可存储服务配置（如Consul），简化配置管理[^3]。 - **高可用保障**：在分布式系统中，注册中心通过共识算法（如Raft）确保数据一致性，防止单点故障[^4][^5]。 如果不使用注册中心，服务间通信需手动维护地址列表，导致： - 系统脆弱：服务故障时需人工干预。 - 扩展困难：每次服务变更需更新所有客户端。 - 性能瓶颈：硬编码地址无法动态负载均衡。 因此，注册中心是微服务架构的基石，尤其在云原生环境中至关重要[^1][^3]。 #### 2. **Go语言实现注册中心的方法** 在Go语言中，实现注册中心通常包括以下核心组件：服务模型、注册表、API接口、健康检查机制和分布式一致性协议。参考站内引用，实现方法分为单机版和分布式版，我以关键步骤说明。 ##### 关键组件与步骤 - **服务模型定义**：定义服务元数据结构，如ID、名称、地址和端口。例如： ```go type Service struct { ID string `json:"id"` // 服务唯一标识 Name string `json:"name"` // 服务名称 Address string `json:"address"` // IP地址 Port int `json:"port"` // 端口号 } ``` 这用于存储服务实例信息[^4]。 - **注册表实现**：使用内存存储（如Map）或数据库管理服务实例。核心操作包括： - **服务注册**：服务启动时调用注册API，添加自身信息到注册表。 - **服务发现**：客户端查询注册表，获取可用服务列表。 - **服务下线**：服务关闭时主动注销。 - **服务续约**：通过心跳机制（如定时发送请求）更新服务状态，防止超时剔除[^1][^5]。 - **API接口**：提供HTTP或gRPC端点，支持注册、发现和健康检查。例如，使用Go的`net/http`包实现RESTful API： ```go // 伪代码示例：注册API func RegisterService(w http.ResponseWriter, r *http.Request) { var service Service json.NewDecoder(r.Body).Decode(&service) registry[service.ID] = service // 存储到注册表 w.WriteHeader(http.StatusOK) } ``` 完整实现可参考引用中的单机版设计[^1][^2]。 - **健康检查与剔除机制**： - 服务定期发送心跳（续约请求）。 - 注册中心监控超时实例，自动移除（服务剔除）。 - 可添加自我保护模式：当网络分区时，避免误剔健康服务[^1][^5]。 - **分布式一致性**：为高可用，需实现集群版注册中心： - 使用共识算法如Raft协议，确保多个节点数据一致。 - 步骤包括： 1. **Leader选举**：Raft初始化时选主节点处理写请求。 2. **日志复制**：主节点将操作广播到从节点。 3. **故障处理**：Leader失效时重新选举[^4][^5]。 - 工程中，可基于`hashicorp/raft`库实现（如引用[^4]的`raft.go`）。 ##### 实现模式对比 - **单机版**：简单快速，适合测试或小规模系统。缺点：单点故障。实现参考引用[^1]的Golang单机版。 - **分布式版**：使用Raft或集成现有工具（如Consul）。优点：高可用。实现参考引用[^2][^5]的集群启动和Raft协议。 - **集成外部工具**：如Consul，Go中通过`github.com/hashicorp/consul/api`包调用，减少重复造轮子[^3]。 ##### 完整工作流示例 1. **服务启动**：调用`POST /register`注册自身。 2. **客户端调用**：查询`GET /discover?serviceName=xxx`获取实例列表。 3. **健康维护**：服务每30秒发送心跳，注册中心超时（如90秒）则剔除。 4. **集群同步**：分布式下，Raft确保所有节点数据一致。 Go语言的优势在于高性能并发（goroutine）和丰富库支持，使实现简洁高效。实际项目中，建议优先使用成熟方案如Consul[^3]，或基于引用开源代码扩展[^5]。 #### 3. **总结** 注册中心通过动态管理服务地址，解决了微服务架构的服务发现、健康监控和伸缩性问题。在Go语言中，实现核心包括服务模型、注册表API和健康检查机制；分布式版本需Raft等协议保障一致性。单机版适合入门，分布式版用于生产环境[^1][^5]。注册中心不仅提升系统可靠性，还简化运维，是云原生应用的必备组件[^3]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值