Nacos-Go-Sdk代码逻辑解析

已于 2023-09-15 09:29:57 修改
阅读量303 收藏
点赞数
分类专栏： nacos 文章标签： golang 开发语言 后端
于 2023-09-15 09:28:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yin_ming_hui/article/details/132895021
版权

文章目录

初始化服务，获取nacosClient

  • Nacos Client Config

    • 是用于配置 Nacos 客户端的选项
    • 它包含了客户端连接 Nacos 服务器所需的配置信息
      • 连接的命名空间（NamespaceId）
      • 连接超时时间（TimeoutMs）
      • 是否在启动时不加载缓存（NotLoadCacheAtStart）
      • 日志级别（LogLevel）等。

  • Nacos Server Config

    • 是用于配置 Nacos 服务器的选项
    • 它包含了 Nacos 服务器的配置信息
      • 服务器的 IP 地址（IpAddr）
      • 端口号（Port）
      • 上下文路径（ContextPath）
      • 协议（Scheme）等。

  • 结构：

    • type NacosClient struct {
    client config_client.IConfigClient
}
// ClientConfigOptions 存储Nacos ClientConfig的部分配置项
type ClientConfigOptions struct {
    NamespaceId         string `json:"namespaceId"`
    TimeoutMs           uint64 `json:"timeoutMs"`
    NotLoadCacheAtStart bool   `json:"notLoadCacheAtStart"`
    LogLevel            string `json:"logLevel"`
    AppendToStdout      bool   `json:"appendToStdout"`
    LogDir              string `json:"logDir"`
    CacheDir            string `json:"cacheDir"`
}

type ServerConfigOptions struct {
    IpAddr      string `json:"ipAddr"`
    Port        uint64 `json:"port"`
    ContextPath string `json:"contextPath"`
    Scheme      string `json:"scheme"`
}

  • 初始化

// Nacos Client Config
namespace := "3ac59d8c-8213-4619-859a-a00477496ae4"
ccOpts := nacos.ClientConfigOptions{
    NamespaceId:         namespace,
    TimeoutMs:           100000000,
    NotLoadCacheAtStart: true,
    LogLevel:            "debug",
    AppendToStdout:      true,
    LogDir:              "./config",
    CacheDir:            "./config",
}
cfg.NacosClient = &ccOpts

// Nacos Server Config
scOpt := nacos.ServerConfigOptions{
    IpAddr:      "nacos.dev.surreal-ai.com",
    Port:        443,
    ContextPath: "/nacos",
    Scheme:      "https",
}
cfg.NacosServer = &scOpt
  • 创建 
    • func NewNacosClient(ccOpts *ClientConfigOptions, scOpt *ServerConfigOptions) (*NacosClient, error) {
    //new 返回指针
    sc := []constant.ServerConfig{
       {
          IpAddr:      scOpt.IpAddr,
          Port:        scOpt.Port,
          ContextPath: scOpt.ContextPath,
          Scheme:      scOpt.Scheme,
       },
    }
    cc := constant.ClientConfig{
       NamespaceId:         ccOpts.NamespaceId,
       TimeoutMs:           ccOpts.TimeoutMs,
       NotLoadCacheAtStart: ccOpts.NotLoadCacheAtStart,
       LogDir:              ccOpts.LogDir,
       CacheDir:            ccOpts.CacheDir,
       LogLevel:            ccOpts.LogLevel,
       AppendToStdout:      ccOpts.AppendToStdout,
    }
    // a more graceful way to create config client
    client, err := clients.NewConfigClient(
       vo.NacosClientParam{
          ClientConfig:  &cc,
          ServerConfigs: sc,
       },
    )
    if err != nil {
       panic(err)
    }

    // 创建新的NacosClient实例并将config_client.IConfigClient包装在其中
    nacosClient := &NacosClient{
       client: client,
    }

    return nacosClient, nil
}

获取配置

func (c *NacosClient) GetString(dataid string, group string) (string, error) {
    content, err := c.client.GetConfig(vo.ConfigParam{
       DataId: dataid,
       Group:  group,
    })
    if err != nil {
       return content, err
    }

    return content, nil
}
源码逻辑

  • GetConfig

    • func (client *ConfigClient) GetConfig(param vo.ConfigParam) (content string, err error) {
    content, err = client.getConfigInner(param)

    if err != nil {
       return "", err
    }

    return client.decrypt(param.DataId, content)
}

    • 每次请求获取配置

  • getConfigInner

func (client *ConfigClient) getConfigInner(param vo.ConfigParam) (content string, err error) {
        if len(param.DataId) <= 0 {
       err = errors.New("[client.GetConfig] param.dataId can not be empty")
       return "", err
    }
    if len(param.Group) <= 0 {
       err = errors.New("[client.GetConfig] param.group can not be empty")
       return "", err
    }
    clientConfig, _ := client.GetClientConfig()
    cacheKey := util.GetConfigCacheKey(param.DataId, param.Group, clientConfig.NamespaceId)
    content, err = client.configProxy.GetConfigProxy(param, clientConfig.NamespaceId, clientConfig.AccessKey, clientConfig.SecretKey)

    if err != nil {
       logger.Errorf("get config from server error:%+v ", err)
       if _, ok := err.(*nacos_error.NacosError); ok {
          nacosErr := err.(*nacos_error.NacosError)
          if nacosErr.ErrorCode() == "404" {
             cache.WriteConfigToFile(cacheKey, client.configCacheDir, "")
             logger.Warnf("[client.GetConfig] config not found, dataId: %s, group: %s, namespaceId: %s.", param.DataId, param.Group, clientConfig.NamespaceId)
             return "", nil
          }
          if nacosErr.ErrorCode() == "403" {
             return "", errors.New("get config forbidden")
          }
       }
       content, err = cache.ReadConfigFromFile(cacheKey, client.configCacheDir)
       if err != nil {
          logger.Errorf("get config from cache  error:%+v ", err)
          return "", errors.New("read config from both server and cache fail")
       }

    } else {
       cache.WriteConfigToFile(cacheKey, client.configCacheDir, content)
    }
    return content, nil
}
  • 整体逻辑：
    • 先尝试从配置服务器获取配置信息
    • 如果获取失败则从缓存中获取，如果获取成功则将获取到的配置写入缓存。
  1. 先判断参数是否合法
  2. 获取客户端参数和 缓存key
  3. 向nacos获取
    1. 获取成功
      1. 写入对应的缓存文件返回
    2. 获取失败
      1. 首先在日志中记录获取配置失败的错误信息。然后，检查错误类型是否为*nacos_error.NacosError
        1. 如果是，进一步判断错误码。
          1. 如果错误码是 “404”，表示配置不存在
          2. 则将空配置写入缓存，并在日志中记录相应的警告信息，然后返回空内容。
      2. 如果错误码是 “403”
        1. 表示无权限访问配置，函数会返回对应的错误信息。
      3. 如果不是 “404” 或 “403”
        1. 则表示从配置服务器获取配置信息失败
        2. 这时尝试从缓存文件中读取配置数据
          1. 使用 cache.ReadConfigFromFile() 方法从缓存中获取配置内容。
          2. 如果从缓存中获取失败，函数会返回对应的错误信息。
  4. 如果从配置服务器获取配置信息成功（即 err 为 nil）
    1. 则将获取到的配置内容写入缓存中，使用 cache.WriteConfigToFile() 方法。

获取json配置

func (c *NacosClient) GetObject(dataid string, group string, obj interface{}) error {
    val, err := c.client.GetConfig(vo.ConfigParam{
       DataId: dataid,
       Group:  group,
    })
    if err != nil {
       return err
    }

    // 假设配置值是JSON格式的，可以使用json.Unmarshal将其解析到传入的obj中
    err = json.Unmarshal([]byte(val), obj)
    if err != nil {
       return err
    }

    return nil
}

发布配置

// PublishConfig is used to publish a configuration to Nacos.
func (c *NacosClient) PublishConfig(dataId, group, content string) error {
    _, err := c.client.PublishConfig(vo.ConfigParam{
       DataId:  dataId,
       Group:   group,
       Content: content,
    })
    if err != nil {
       return err
    }

    return nil
}

监听配置变化

func (c *NacosClient) Listen(dataid string, group string, callback func(namespace, group, dataId, data string)) error {
    err := c.client.ListenConfig(vo.ConfigParam{
       DataId: dataid,
       Group:  group,
       OnChange: func(namespace, group, dataId, data string) {
          callback(namespace, group, dataId, data)
       },
    })
    if err != nil {
       return err
    }

    return nil
}
源码逻辑
func (client *ConfigClient) ListenConfig(param vo.ConfigParam) (err error) {
    if len(param.DataId) <= 0 {
       err = errors.New("[client.ListenConfig] DataId can not be empty")
       return err
    }
    if len(param.Group) <= 0 {
       err = errors.New("[client.ListenConfig] Group can not be empty")
       return err
    }
    clientConfig, err := client.GetClientConfig()
    if err != nil {
       err = errors.New("[checkConfigInfo.GetClientConfig] failed")
       return err
    }

    key := util.GetConfigCacheKey(param.DataId, param.Group, clientConfig.NamespaceId)
    var cData cacheData
    if v, ok := client.cacheMap.Get(key); ok {
       cData = v.(cacheData)
       cData.isInitializing = true
    } else {
       var (
          content string
          md5Str  string
       )
       if content, _ = cache.ReadConfigFromFile(key, client.configCacheDir); len(content) > 0 {
          md5Str = util.Md5(content)
       }
       listener := &cacheDataListener{
          listener: param.OnChange,
          lastMd5:  md5Str,
       }

       cData = cacheData{
          isInitializing:    true,
          dataId:            param.DataId,
          group:             param.Group,
          tenant:            clientConfig.NamespaceId,
          content:           content,
          md5:               md5Str,
          cacheDataListener: listener,
          taskId:            client.cacheMap.Count() / perTaskConfigSize,
       }
    }
    client.cacheMap.Set(key, cData)
    return
}
  • 参数param为vo.ConfigParam类型
    • 表示要监听的配置信息，包括DataId、Group和OnChange等。
  • 如果DataId或Group为空，
    • 则返回对应的错误信息。
  • 首先获取客户端的配置信息，然后根据DataId、Group和NamespaceId构建一个缓存键key。
  • 读取监听表 : cacheMap[key]
    • 如果监听表中存在对应的配置信息 (cacheMap中存在这个key)
      • 则将该配置信息的isInitializing字段设置为true
    • 如果监听表中不存在对应的配置信息
      • 则从缓存文件中读取内容并计算md5值，创建一个新的cacheData对象
      • 并且设置isInitializing字段设置为true
  • 将该对象加入cacheMap 中，由longPulling 进行监听
  1. 读取监听表
  2. 假如有的话，将设置为true
  3. 没有的话，从缓存文件中读取配置，创建新的 对象放入 监听表中
listenConfigExecutor调度longPulling
func (client *ConfigClient) listenConfigExecutor() func() error {
    return func() error {
       // 计算当前监听器的数量
       listenerSize := client.cacheMap.Count()

       // 计算总共需要的任务数量，每个任务处理的监听器数量为 perTaskConfigSize
       taskCount := int(math.Ceil(float64(listenerSize) / float64(perTaskConfigSize)))

       // 获取当前正在执行的任务数量
       currentTaskCount := int(atomic.LoadInt32(&client.currentTaskCount))

       // 根据任务数量的比较，进行任务的启动和停止
       if taskCount > currentTaskCount {
          // 有新的监听器加入，需要启动新的任务来处理新的监听器
          for i := currentTaskCount; i < taskCount; i++ {
             // 设置任务状态为运行中
             client.schedulerMap.Set(strconv.Itoa(i), true)

             // 创建新的定时器，定时触发长轮询操作 client.longPulling(i)
             go client.delayScheduler(time.NewTimer(1*time.Millisecond), 10*time.Millisecond, strconv.Itoa(i), client.longPulling(i))
          }

          // 更新当前任务数量为 taskCount
          atomic.StoreInt32(&client.currentTaskCount, int32(taskCount))
       } else if taskCount < currentTaskCount {
          // 有监听器停止监听，需要停止相应的任务
          for i := taskCount; i < currentTaskCount; i++ {
             // 检查相应任务是否在 schedulerMap 中，如果存在则将任务状态设置为停止
             if _, ok := client.schedulerMap.Get(strconv.Itoa(i)); ok {
                client.schedulerMap.Set(strconv.Itoa(i), false)
             }
          }

          // 更新当前任务数量为 taskCount
          atomic.StoreInt32(&client.currentTaskCount, int32(taskCount))
       }

       return nil
    }
}
  • 根据监听的个数 计算当前需要的 任务协程
longPulling
// longPulling 是一个长轮询监听配置变化的方法。
// 参数 taskId 表示监听任务的标识，用于区分不同的监听任务。
// 该方法返回一个函数，该函数用于执行长轮询操作，监听配置变化。
func (client *ConfigClient) longPulling(taskId int) func() error {
    return func() error {
       var listeningConfigs string
       initializationList := make([]cacheData, 0)

       // 遍历缓存中的所有配置信息，根据 taskId 筛选出当前监听任务的配置信息
       for _, key := range client.cacheMap.Keys() {
          if value, ok := client.cacheMap.Get(key); ok {
             cData := value.(cacheData)
             if cData.taskId == taskId {
                // 如果配置数据正在初始化中，则将其加入 initializationList 列表
                if cData.isInitializing {
                   initializationList = append(initializationList, cData)
                }

                // 构建监听配置列表listeningConfigs，用于发送给配置服务器进行监听
                if len(cData.tenant) > 0 {
                   listeningConfigs += cData.dataId + constant.SPLIT_CONFIG_INNER + cData.group + constant.SPLIT_CONFIG_INNER +
                      cData.md5 + constant.SPLIT_CONFIG_INNER + cData.tenant + constant.SPLIT_CONFIG
                } else {
                   listeningConfigs += cData.dataId + constant.SPLIT_CONFIG_INNER + cData.group + constant.SPLIT_CONFIG_INNER +
                      cData.md5 + constant.SPLIT_CONFIG
                }
             }
          }
       }

       // 如果有要监听的配置信息，则继续进行长轮询
       if len(listeningConfigs) > 0 {
          clientConfig, err := client.GetClientConfig()
          if err != nil {
             logger.Errorf("[checkConfigInfo.GetClientConfig] 获取客户端配置失败 err: %+v", err)
             return err
          }

          // 构建监听配置请求参数params，用于发送给配置服务器进行监听
          params := make(map[string]string)
          params[constant.KEY_LISTEN_CONFIGS] = listeningConfigs

          var changed string
          // 发送监听配置的请求，进行长轮询
          changedTmp, err := client.configProxy.ListenConfig(params, len(initializationList) > 0, clientConfig.NamespaceId, clientConfig.AccessKey, clientConfig.SecretKey)
          if err == nil {
             changed = changedTmp
          } else {
             // 如果监听配置出现错误，尝试处理错误情况
             if _, ok := err.(*nacos_error.NacosError); ok {
                // 如果返回的错误是NacosError类型，则将监听结果设为变更信息（changedTmp）
                changed = changedTmp
             } else {
                // 否则，记录错误日志并返回错误
                logger.Errorf("[client.ListenConfig] 监听配置错误 err: %+v", err)
             }
             return err
          }

          // 对于初始化中的配置数据，将其isInitializing字段设为false，表示配置数据已经初始化完毕
          for _, v := range initializationList {
             v.isInitializing = false
             client.cacheMap.Set(util.GetConfigCacheKey(v.dataId, v.group, v.tenant), v)
          }

          // 根据监听结果changed，判断是否有配置发生了变更，如果有则通知相应的监听器进行处理
          if len(strings.ToLower(strings.Trim(changed, " "))) == 0 {
             logger.Info("[client.ListenConfig] 配置无变更")
          } else {
             logger.Info("[client.ListenConfig] 配置发生变更: " + changed)
             client.callListener(changed, clientConfig.NamespaceId)
          }
       }

       // 返回nil，表示长轮询监听成功完成
       return nil
    }
}
  1. 遍历监听表，拼接listeningConfigs 
    1. listeningConfigs += cData.dataId + constant.SPLIT_CONFIG_INNER + cData.group + constant.SPLIT_CONFIG_INNER +
    cData.md5 + constant.SPLIT_CONFIG_INNER + cData.tenant + constant.SPLIT_CONFIG
  2. 发送请求
  3. 全部的 isInitializing = false ， 一次长轮训结束
  4. 根据返回信息处理
    1. 假如为空，则未变化
    2. 不为空
      1. client.callListener(changed, clientConfig.NamespaceId) 处理变化的值
callListener
// Execute the Listener callback func()
// 执行监听器的回调函数
// 当配置发生变更时，通过该方法通知相应的监听器进行处理。
func (client *ConfigClient) callListener(changed, tenant string) {
    // 解码配置变更字符串
    changedDecoded, _ := url.QueryUnescape(changed)

    // 使用分隔符 "\u0001" 拆分配置变更信息，得到一个 changedConfigs 切片，每个元素表示一个配置项的变更内容。
    changedConfigs := strings.Split(changedDecoded, "\u0001")

    // 遍历 changedConfigs，每个元素代表一个配置项的变更信息。
    for _, config := range changedConfigs {
       // 使用分隔符 "\u0002" 拆分配置变更项，得到一个 attrs 切片，包含了配置项的 DataId 和 Group 信息，以及其他可能的变更内容。
       attrs := strings.Split(config, "\u0002")

       // 如果 attrs 的长度大于等于 2，表示配置项的 DataId 和 Group 信息是有效的，可以根据这些信息从缓存中获取相应的配置数据。
       if len(attrs) >= 2 {
          // 从缓存中获取配置数据
          if value, ok := client.cacheMap.Get(util.GetConfigCacheKey(attrs[0], attrs[1], tenant)); ok {
             cData := value.(cacheData)

             // 获取配置内容，并计算新的 MD5 值
             content, err := client.getConfigInner(vo.ConfigParam{
                DataId: cData.dataId,
                Group:  cData.group,
             })
             if err != nil {
                // 获取配置内容出错，记录错误日志并继续处理下一个配置变更项
                logger.Errorf("[client.getConfigInner] DataId:[%s] Group:[%s] Error:[%+v]", cData.dataId, cData.group, err)
                continue
             }

             // 更新配置数据
             cData.content = content
             cData.md5 = util.Md5(content)

             // 如果 MD5 值与之前的不同，则表示配置发生了变更，调用监听器的回调函数处理配置变更。
             if cData.md5 != cData.cacheDataListener.lastMd5 {
                go cData.cacheDataListener.listener(tenant, attrs[1], attrs[0], cData.content)
                cData.cacheDataListener.lastMd5 = cData.md5
                client.cacheMap.Set(util.GetConfigCacheKey(cData.dataId, cData.group, tenant), cData)
             }
          }
       }
    }
}

img

  1. 解析出每个变化的配置项信息 ，分隔符"\u0001"
  2. 遍历
    1. 解析出具体信息 ，分隔符\u0002"
    2. 解析出的信息长度大于等于 2，表示配置项的 DataId 和 Group 信息是有效的
      1. 从监听表 中 拿 这个 配置数据
      2. getConfigInner 从远端 获取对应的最新数据
      3. 更新配置数据到
      4. 假如与之前的MD5 不一样
        1. 调用 自己设置的回调函数
        2. 更新监听表
监听表 中 配置 的 结构
type cacheData struct {
    isInitializing    bool
    dataId            string
    group             string
    content           string
    tenant            string
    cacheDataListener *cacheDataListener  // 回调函数的封装
    md5               string
    appName           string
    taskId            int
}
  • cacheDataListener 
    • type cacheDataListener struct {
    listener vo.Listener //type Listener func(namespace, group, dataId, data string)
    lastMd5  string
}

监听功能的调用逻辑

img

雪芙花
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
GO语言使用Nacos（nacos-sdk-go的使用）
qq_36305027的博客
08-16 3610
​ Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service的首字母简称，一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。​ Nacos 致力于帮助您发现、配置和管理微服务。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据及流量管理。​ Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。......
nacos 公共_Nacos Go SDK 概述
weixin_39536010的博客
12-22 326
示例代码Go 格式说明 请将代码中的 ${endpoint}、${namespace}、${accessKey}、${secretKey} 分别替换为 ACM 控制台上命名空间详情对话框内的 End Point、命名空间 ID、AccessKey、SecretKey。出于安全考虑，建议使用 RAM 用户的 AccessKey 和 SecretKey。package mainimport ("fmt...
Nacos中间件go sdk使用填坑指南
WenCoo的博客
05-10 603
无法访问通，为了排查问题，所以在本地（linux环境）搭建了一个nacos服务，然后通过go sdk，可以正确获取配置。在添加了域名映射后，使用openapi，可以做到访问本地服务和云服务的访问，go sdk，经过各种测试，查找资料，发现原来是端口问题，将端口加入到云服务的安全组后，go sdk也可以获取配置信息了。然后换上域名访问，则无法获取配置，测试：给本地服务加上域名，通过域名访问，可以正确访问,使用openapi去访问，也可以正确访问（自己搭建的服务），但是使用go sdk却不行（云服务）
Go微服务: 封装nacos-sdk-go的v2版本与应用
最新发布
Wang的专栏
05-29 840
基于前文：[https://active.blog.csdn.net/article/details/139213323](https://active.blog.csdn.net/article/details/139213323) - 我们基于此SDK提供的API封装一个公共方法来用于生产环境 封装 nacos-sdk-go - 我们封装一个 nacos.go 文件, 这个是通用的工具库
nacos go
Go的全部
11-29 240
https://github.com/nacos-group/nacos-sdk-go/blob/master/README_CN.md
nacos-sdk-python:Nacos Python SDK
05-08
nacos-sdk-python Nacos OpenAPI的Python实现。 参见： :支持的Python版本： Python 2.7 Python 3.6 Python 3.7支持的Nacos版本Nacos 0.8.0〜1.3.2安装pip install nacos-sdk-python入门import nacos# Both ...
nacos-plugin:使用nacos-sdk-go的go-micro注册表插件
03-16
Nacos-SDK-Go是Nacos服务发现功能在Go语言环境下的实现，它提供了完整的客户端API，使得Go应用程序能够无缝地与Nacos服务器交互。通过Nacos-SDK-Go，开发者可以轻松地注册服务、查询服务、订阅服务变更事件等。 **...
nacos配置中心nacos-server-2.2.3
08-16
对于Java开发者，Nacos提供了丰富的SDK和API，可以方便地集成到Spring Boot等应用框架中。 总的来说，Nacos-server-2.2.3是为了解决分布式系统中的服务治理和配置管理问题而设计的工具，它集成了Java生态，提供了...
nacos-server-2.1.1.tar.gz
08-16
5. **多语言支持**：Nacos-server 通过丰富的 SDK 支持多种编程语言，如 Java、Go、Python 等，方便不同语言开发的应用接入。 6. **数据一致性**：Nacos-server 使用 Raft 算法保证数据的一致性，确保在分布式环境...
最新nacos-server-2.2.0下载
12-29
6. **多语言支持**：Nacos提供多种语言的客户端SDK，便于不同语言的应用集成。 7. **API与CLI操作**：除了Web UI，Nacos还提供了丰富的命令行接口（CLI），方便开发者进行自动化运维。 **二、Nacos 2.2.0新特性** ...
探索 Nacos SDK Go：高效、易用的微服务管理工具
gitblog_00030的博客
04-10 331
探索 Nacos SDK Go：高效、易用的微服务管理工具 项目地址:https://gitcode.com/nacos-group/nacos-sdk-go 项目简介 Nacos SDK Go 是一个针对阿里云 Nacos 平台的官方 Go 语言客户端。Nacos 是一个专注于服务发现和服务配置的服务管理平台，而该 SDK 则提供了与 Nacos 交互的一系列便捷 API，帮助开发者轻松地在 G...
go使用nacos作为配置中心
weixin_44540711的博客
05-09 2754
前言 什么是nacos,nacos优点，具体参考官网http://nacos.io Nacos 致力于帮助您发现、配置和管理微服务。Nacos 提供了一组简单易用的特性集，帮助您实现动态服务发现、服务配置管理、服务及流量管理。 Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。 Nacos 是构建以“服务”为中心的现代应用架构(例如微服务范式、云原生范式)的服务基础设施。 1、windows安装nacos环境 1、需要提前安装jdk环境，并且jdk版本在1.8以上，jdk环境搭建自行解决
Go-整合Nacos(小试牛刀)
程序员劝退师的博客
01-05 2563
前言 最近在搞JAVA领域的Nacos，看了Nacos相关源码，趁着深夜，用Go玩玩Nacos，小试牛刀！ 获取Nacos整合包 go get github.com/nacos-group/nacos-sdk-go git上有现成的例子，写的挺好的，只是跑起来会把注册的节点都又删除，不太人性 Nacos服务端搭建 关于这块我不多说，详情请看我JAVA领域的文章Nacos-深入浅出 Nacos客户端搭建 service_client_example.go package main import ( "
Nacos Go 微服务生态系列（一）| Dubbo-go 云原生核心引擎探索
阿里云云栖号
09-25 1319
简介：作为微服务框架的核心引擎--注册中心，是必不可缺少的组件，市面已经有多款注册中心支持 Go 语言，应该如何选择呢？我们可以对目前主流的支持 Go 语言的注册中心做个对比。 作者 |李志鹏 近几年，随着 Go 语言社区逐渐发展和壮大，越来越多的公司开始尝试采用 Go 搭建微服务体系，也涌现了一批 Go 的微服务框架，如 go-micro、go-kit、Dubbo-go 等，跟微服务治理相关的组件也逐渐开始在 Go 生态发力，如 Sentinel、Hystrix 等都推出了 Go 语言版本，而..
聊聊nacos-sdk-go的NamingProxy
求关注
06-27 543
序 本文主要研究一下nacos-sdk-go的NamingProxy NamingProxy nacos-sdk-go-v0.3.2/clients/naming_client/naming_proxy.go type NamingProxy struct { clientConfig constant.ClientConfig nacosServer nacos_server.NacosServer } 复制代码 NamingProxy定义了clientConfig、nacosServe
go集成nacos配置管理
yzh_1346983557的博客
05-11 1024
【代码】go集成nacos配置管理。
go 进阶 三方库之 nacos 配置中心
qq_29799655的博客
05-11 482
【代码】go 进阶 三方库之 nacos 配置中心。
使用go sdk 连接nacos, nacos open-api 安全认证问题？
weixin_45277567的博客
10-09 265
使用go sdk 参考网址。
nacos-sdk-go服务发现
09-05
nacos-sdk-go是一个用于服务发现的开源软件包。它提供了一种简单且可靠的方式来实现服务发现功能，可以帮助开发人员更方便地构建分布式应用程序。 nacos-sdk-go基于Nacos开源项目开发，Nacos是阿里巴巴开源的一个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

雪芙花

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值