go 集成nacos注册中心、配置中心的过程详解

go get -u github.com/nacos-group/nacos-sdk-go/v2

constant.clientconfig{
  timeoutms            uint64 // 请求nacos服务端的超时时间，默认是10000ms
  namespaceid          string // nacos的命名空间id
  endpoint             string // 当使用地址服务器时，需要该配置. https://help.aliyun.com/document_detail/130146.html
  regionid             string // nacos&kms的regionid，用于配置中心的鉴权
  accesskey            string // nacos&kms的accesskey，用于配置中心的鉴权
  secretkey            string // nacos&kms的secretkey，用于配置中心的鉴权
  openkms              bool   // 是否开启kms，默认不开启，kms可以参考文档 https://help.aliyun.com/product/28933.html
                              // 同时dataid必须以"cipher-"作为前缀才会启动加解密逻辑
  cachedir             string // 缓存service信息的目录，默认是当前运行目录
  updatethreadnum      int    // 监听service变化的并发数，默认20
  notloadcacheatstart  bool   // 在启动的时候不读取缓存在cachedir的service信息
  updatecachewhenempty bool   // 当service返回的实例列表为空时，不更新缓存，用于推空保护
  username             string // nacos服务端的api鉴权username
  password             string // nacos服务端的api鉴权password
  logdir               string // 日志存储路径
  rotatetime           string // 日志轮转周期，比如：30m, 1h, 24h, 默认是24h
  maxage               int64  // 日志最大文件数，默认3
  loglevel             string // 日志默认级别，值必须是：debug,info,warn,error，默认值是info
}

constant.serverconfig{
  contextpath string // nacos的contextpath，默认/nacos，在2.0中不需要设置
  ipaddr      string // nacos的服务地址
  port        uint64 // nacos的服务端口
  scheme      string // nacos的服务地址前缀，默认http，在2.0中不需要设置
  grpcport    uint64 // nacos的 grpc 服务端口, 默认为 服务端口+1000, 不是必填
}

// 创建clientconfig
clientconfig := constant.clientconfig{
  namespaceid:         "e525eafa-f7d7-4029-83d9-008937f9d468", // 如果需要支持多namespace，我们可以创建多个client,它们有不同的namespaceid。当namespace是public时，此处填空字符串。
  timeoutms:           5000,
  notloadcacheatstart: true,
  logdir:              "/tmp/nacos/log",
  cachedir:            "/tmp/nacos/cache",
  loglevel:            "debug",
}
// 创建clientconfig的另一种方式
clientconfig := *constant.newclientconfig(
    constant.withnamespaceid("e525eafa-f7d7-4029-83d9-008937f9d468"), //当namespace是public时，此处填空字符串。
    constant.withtimeoutms(5000),
    constant.withnotloadcacheatstart(true),
    constant.withlogdir("/tmp/nacos/log"),
    constant.withcachedir("/tmp/nacos/cache"),
    constant.withloglevel("debug"),
)
// 至少一个serverconfig
serverconfigs := []constant.serverconfig{
    {
        ipaddr:      "console1.nacos.io",
        contextpath: "/nacos",
        port:        80,
        scheme:      "http",
    },
    {
      ipaddr:      "console2.nacos.io",
      contextpath: "/nacos",
      port:        80,
        scheme:      "http",
    },
}
// 创建serverconfig的另一种方式
serverconfigs := []constant.serverconfig{
    *constant.newserverconfig(
        "console1.nacos.io",
        80,
        constant.withscheme("http"),
        constant.withcontextpath("/nacos"),
    ),
    *constant.newserverconfig(
        "console2.nacos.io",
        80,
        constant.withscheme("http"),
        constant.withcontextpath("/nacos"),
    ),
}
// 创建服务发现客户端
_, _ := clients.createnamingclient(map[string]interface{}{
  "serverconfigs": serverconfigs,
  "clientconfig":  clientconfig,
})
// 创建动态配置客户端
_, _ := clients.createconfigclient(map[string]interface{}{
  "serverconfigs": serverconfigs,
  "clientconfig":  clientconfig,
})
// 创建服务发现客户端的另一种方式 (推荐)
namingclient, err := clients.newnamingclient(
    vo.nacosclientparam{
        clientconfig:  &clientconfig,
        serverconfigs: serverconfigs,
    },
)
// 创建动态配置客户端的另一种方式 (推荐)
configclient, err := clients.newconfigclient(
    vo.nacosclientparam{
        clientconfig:  &clientconfig,
        serverconfigs: serverconfigs,
    },
)

success, err := namingclient.registerinstance(vo.registerinstanceparam{
    ip:          "10.0.0.11",
    port:        8848,
    servicename: "demo.go",
    weight:      10,
    enable:      true,
    healthy:     true,
    ephemeral:   true,
    metadata:    map[string]string{"idc":"shanghai"},
    clustername: "cluster-a", // 默认值default
    groupname:   "group-a",   // 默认值default_group
})

success, err := namingclient.deregisterinstance(vo.deregisterinstanceparam{
    ip:          "10.0.0.11",
    port:        8848,
    servicename: "demo.go",
    ephemeral:   true,
    cluster:     "cluster-a", // 默认值default
    groupname:   "group-a",   // 默认值default_group
})

services, err := namingclient.getservice(vo.getserviceparam{
    servicename: "demo.go",
    clusters:    []string{"cluster-a"}, // 默认值default
    groupname:   "group-a",             // 默认值default_group
})

// selectallinstance可以返回全部实例列表,包括healthy=false,enable=false,weight<=0
instances, err := namingclient.selectallinstances(vo.selectallinstancesparam{
    servicename: "demo.go",
    groupname:   "group-a",             // 默认值default_group
    clusters:    []string{"cluster-a"}, // 默认值default
})

// selectinstances 只返回满足这些条件的实例列表：healthy=${healthyonly},enable=true 和weight>0
instances, err := namingclient.selectinstances(vo.selectinstancesparam{
    servicename: "demo.go",
    groupname:   "group-a",             // 默认值default_group
    clusters:    []string{"cluster-a"}, // 默认值default
    healthyonly: true,
})

// selectonehealthyinstance将会按加权随机轮询的负载均衡策略返回一个健康的实例
// 实例必须满足的条件：health=true,enable=true and weight>0
instance, err := namingclient.selectonehealthyinstance(vo.selectonehealthinstanceparam{
    servicename: "demo.go",
    groupname:   "group-a",             // 默认值default_group
    clusters:    []string{"cluster-a"}, // 默认值default
})

// subscribe key=servicename+groupname+cluster
// 注意:我们可以在相同的key添加多个subscribecallback.
err := namingclient.subscribe(vo.subscribeparam{
    servicename: "demo.go",
    groupname:   "group-a",             // 默认值default_group
    clusters:    []string{"cluster-a"}, // 默认值default
    subscribecallback: func(services []model.instance, err error) {
        log.printf("\n\n callback return services:%s \n\n", utils.tojsonstring(services))
    },
})

err := namingclient.unsubscribe(vo.subscribeparam{
    servicename: "demo.go",
    groupname:   "group-a",             // 默认值default_group
    clusters:    []string{"cluster-a"}, // 默认值default
    subscribecallback: func(services []model.instance, err error) {
        log.printf("\n\n callback return services:%s \n\n", utils.tojsonstring(services))
    },
})

serviceinfos, err := namingclient.getallservicesinfo(vo.getallserviceinfoparam{
    namespace: "0e83cc81-9d8c-4bb8-a28a-ff703187543f",
    pageno:   1,
    pagesize: 10,
  }),

success, err := configclient.publishconfig(vo.configparam{
    dataid:  "dataid",
    group:   "group",
    content: "hello world!222222"})

success, err = configclient.deleteconfig(vo.configparam{
    dataid: "dataid",
    group:  "group"})

content, err := configclient.getconfig(vo.configparam{
    dataid: "dataid",
    group:  "group"})

err := configclient.listenconfig(vo.configparam{
    dataid: "dataid",
    group:  "group",
    onchange: func(namespace, group, dataid, data string) {
        fmt.println("group:" + group + ", dataid:" + dataid + ", data:" + data)
  },
})

err := configclient.cancellistenconfig(vo.configparam{
    dataid: "dataid",
    group:  "group",
})

configpage,err := configclient.searchconfig(vo.searchconfigparam{
    search:   "blur",
    dataid:   "",
    group:    "",
    pageno:   1,
    pagesize: 10,
})

/*
 * copyright 1999-2020 alibaba group holding ltd.
 *
 * licensed under the apache license, version 2.0 (the "license");
 * you may not use this file except in compliance with the license.
 * you may obtain a copy of the license at
 *
 *      http://www.apache.org/licenses/license-2.0
 *
 * unless required by applicable law or agreed to in writing, software
 * distributed under the license is distributed on an "as is" basis,
 * without warranties or conditions of any kind, either express or implied.
 * see the license for the specific language governing permissions and
 * limitations under the license.
 */
package nacos
import (
	"fmt"
	"github.com/nacos-group/nacos-sdk-go/v2/clients/naming_client"
	"github.com/nacos-group/nacos-sdk-go/v2/vo"
)
func registerserviceinstance(client naming_client.inamingclient, param vo.registerinstanceparam) {
	success, err := client.registerinstance(param)
	if !success || err != nil {
		panic("registerserviceinstance failed!" + err.error())
	}
	fmt.printf("registerserviceinstance,param:%+v,result:%+v \n\n", param, success)
}
func batchregisterserviceinstance(client naming_client.inamingclient, param vo.batchregisterinstanceparam) {
	success, err := client.batchregisterinstance(param)
	if !success || err != nil {
		panic("batchregisterserviceinstance failed!" + err.error())
	}
	fmt.printf("batchregisterserviceinstance,param:%+v,result:%+v \n\n", param, success)
}
func deregisterserviceinstance(client naming_client.inamingclient, param vo.deregisterinstanceparam) {
	success, err := client.deregisterinstance(param)
	if !success || err != nil {
		panic("deregisterserviceinstance failed!" + err.error())
	}
	fmt.printf("deregisterserviceinstance,param:%+v,result:%+v \n\n", param, success)
}
func updateserviceinstance(client naming_client.inamingclient, param vo.updateinstanceparam) {
	success, err := client.updateinstance(param)
	if !success || err != nil {
		panic("updateinstance failed!" + err.error())
	}
	fmt.printf("updateserviceinstance,param:%+v,result:%+v \n\n", param, success)
}
func getservice(client naming_client.inamingclient, param vo.getserviceparam) {
	service, err := client.getservice(param)
	if err != nil {
		panic("getservice failed!" + err.error())
	}
	fmt.printf("getservice,param:%+v, result:%+v \n\n", param, service)
}
func selectallinstances(client naming_client.inamingclient, param vo.selectallinstancesparam) {
	instances, err := client.selectallinstances(param)
	if err != nil {
		panic("selectallinstances failed!" + err.error())
	}
	fmt.printf("selectallinstance,param:%+v, result:%+v \n\n", param, instances)
}
func selectinstances(client naming_client.inamingclient, param vo.selectinstancesparam) {
	instances, err := client.selectinstances(param)
	if err != nil {
		panic("selectinstances failed!" + err.error())
	}
	fmt.printf("selectinstances,param:%+v, result:%+v \n\n", param, instances)
}
func selectonehealthyinstance(client naming_client.inamingclient, param vo.selectonehealthinstanceparam) {
	instances, err := client.selectonehealthyinstance(param)
	if err != nil {
		panic("selectonehealthyinstance failed!")
	}
	fmt.printf("selectonehealthyinstance,param:%+v, result:%+v \n\n", param, instances)
}
func subscribe(client naming_client.inamingclient, param *vo.subscribeparam) {
	_ = client.subscribe(param)
}
func unsubscribe(client naming_client.inamingclient, param *vo.subscribeparam) {
	_ = client.unsubscribe(param)
}
func getallservice(client naming_client.inamingclient, param vo.getallserviceinfoparam) {
	service, err := client.getallservicesinfo(param)
	if err != nil {
		panic("getallservice failed!")
	}
	fmt.printf("getallservice,param:%+v, result:%+v \n\n", param, service)
}

/*
 * copyright 1999-2020 alibaba group holding ltd.
 *
 * licensed under the apache license, version 2.0 (the "license");
 * you may not use this file except in compliance with the license.
 * you may obtain a copy of the license at
 *
 *      http://www.apache.org/licenses/license-2.0
 *
 * unless required by applicable law or agreed to in writing, software
 * distributed under the license is distributed on an "as is" basis,
 * without warranties or conditions of any kind, either express or implied.
 * see the license for the specific language governing permissions and
 * limitations under the license.
 */
package nacos
import (
	"fmt"
	"github.com/nacos-group/nacos-sdk-go/v2/clients/config_client"
	"github.com/nacos-group/nacos-sdk-go/v2/model"
	"github.com/nacos-group/nacos-sdk-go/v2/vo"
)
func publishconfig(client config_client.iconfigclient, param vo.configparam) {
	//publish config
	//config key=dataid+group+namespaceid
	_, err := client.publishconfig(param)
	if err != nil {
		fmt.printf("publishconfig err:%+v \n", err)
	}
}
func deleteconfig(client config_client.iconfigclient, param vo.configparam) {
	_, err := client.deleteconfig(param)
	if err != nil {
		fmt.printf("deleteconfig err:%+v \n", err)
	}
}
func getconfig(client config_client.iconfigclient, param vo.configparam) string {
	//get config
	content, err := client.getconfig(param)
	if err != nil {
		fmt.printf("getconfig err:%+v \n", err)
	} else {
		fmt.println("getconfig,config :" + content)
	}
	return content
}
func listenconfig(client config_client.iconfigclient, param vo.configparam) {
	//listen config change,key=dataid+group+namespaceid.
	err := client.listenconfig(vo.configparam{
		dataid: "test-data",
		group:  "test-group",
		onchange: func(namespace, group, dataid, data string) {
			fmt.println("config changed group:" + group + ", dataid:" + dataid + ", content:" + data)
		},
	})
	if err != nil {
		fmt.printf("publishconfig err:%+v \n", err)
	}
}
func cancellistenconfig(client config_client.iconfigclient, param vo.configparam) {
	//cancel config change
	err := client.cancellistenconfig(param)
	if err != nil {
		fmt.printf("cancellistenconfig err:%+v \n", err)
	}
}
func searchconfig(client config_client.iconfigclient, param vo.searchconfigparam) *model.configpage {
	searchpage, err := client.searchconfig(param)
	if err != nil {
		fmt.printf("searchconfig err:%+v \n", err)
	} else {
		fmt.printf("searchconfig:%+v \n", searchpage)
	}
	return searchpage
}