go操作zookeeper

已于 2024-08-16 23:47:03 修改
阅读量318 收藏 8
点赞数 4
文章标签： golang zookeeper 开发语言
于 2024-08-16 23:30:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73880436/article/details/141271942
版权

基本使用

连接至zookeeper

 /* 获取一个zk连接
 * @return {[type]}
 */
func getConnect(zkList []string) (conn *zk.Conn) {
    conn, _, err := zk.Connect(zkList, 10*time.Second)
    if err != nil {
        fmt.Println(err)
    }
    return
}

新增

/* 测试连接
 * @return
 */
func test1() {
    zkList := []string{"localhost:2181"}
    conn := getConnect(zkList)

    defer conn.Close()
    var flags int32 = 0
    //flags有4种取值：
    //0:永久，除非手动删除
    //zk.FlagEphemeral = 1:短暂，session断开则改节点也被删除
    //zk.FlagSequence  = 2:会自动在节点后面添加序号
    //3:Ephemeral和Sequence，即，短暂且自动添加序号
    conn.Create("/go_servers", nil, flags, zk.WorldACL(zk.PermAll)) // zk.WorldACL(zk.PermAll)控制访问权限模式

    time.Sleep(20 * time.Second)
}

注册方式

var flags int32 = 0
flags有4种取值：

  • 0:永久，除非手动删除
  • zk.FlagEphemeral = 1:短暂，session断开则改节点也被删除
  • zk.FlagSequence = 2:会自动在节点后面添加序号
  • 3:Ephemeral和Sequence，即，短暂且自动添加序号

​ conn.Create(“/go_servers”, nil, flags, zk.WorldACL(zk.PermAll)) // zk.WorldACL(zk.PermAll)控制访问权限模式

更改和删除

//删改与增不同在于其函数中的version参数,其中version是用于 CAS支持
func (c *Conn) Set(path string, data []byte, version int32) (*Stat, error)
func (c *Conn) Delete(path string, version int32) error

demo：
if err = conn.Delete(migrateLockPath, -1); err != nil {
    log.Error("conn.Delete(\"%s\") error(%v)", migrateLockPath, err)
}

func main() {
    // 连接到 ZooKeeper
    servers := []string{"127.0.0.1:2181"} // 这里需要替换为你的 ZooKeeper 实例的地址
    conn, _, err := zk.Connect(servers, time.Second) // 连接超时时间
    if err != nil {
        log.Fatalf("Failed to connect to ZooKeeper: %v", err)
    }
    defer conn.Close()

    // ZooKeeper 操作
    path := "/example/message" // 在 ZooKeeper 中的路径
    data := []byte("Hello ZooKeeper!") // 要保存的消息内容
    
    // 创建节点并保存消息
    flags := int32(0) // 标记：0 表示持久节点，zk.FlagEphemeral 表示临时节点
    acl := zk.WorldACL(zk.PermAll) // 权限：全世界可读写
    createdPath, err := conn.Create(path, data, flags, acl)
    if err != nil {
        log.Fatalf("Failed to create node: %v", err)
    }
    fmt.Printf("Node created: %s\n", createdPath)
    
    // 读取节点数据
    storedData, _, err := conn.Get(path)
    if err != nil {
        log.Fatalf("Failed to get node data: %v", err)
    }
    fmt.Printf("Stored message: %s\n", string(storedData))

}

监听key的变化

可以通过设置“监听器”（watcher）来监听某个节点（key）的变化。当节点的数据发生变化、节点被删除或子节点发生变化时，监听器会被触发

package main

import (
    "github.com/samuel/go-zookeeper/zk"

)

func main() {
    // 连接到 ZooKeeper
    servers := []string{"127.0.0.1:2181"} // 替换为你的 ZooKeeper 实例的地址
    conn, _, err := zk.Connect(servers, time.Second)
    if err != nil {
        log.Fatalf("Failed to connect to ZooKeeper: %v", err)
    }
    defer conn.Close()

    // 要监听的节点路径
    path := "/example/message"
    
    // 获取节点数据并设置监听器
    data, _, ch, err := conn.GetW(path)
    if err != nil {
        log.Fatalf("Failed to get data for node: %v", err)
    }
    fmt.Printf("Current data: %s\n", string(data))
    
    // 等待事件发生
    for {
        select {
        case event := <-ch:
            if event.Type == zk.EventNodeDataChanged {
                fmt.Println("Node data changed, fetching new data...")
    
                // 获取新数据
                newData, _, newCh, err := conn.GetW(path)
                if err != nil {
                    log.Fatalf("Failed to get updated data for node: %v", err)
                }
                fmt.Printf("Updated data: %s\n", string(newData))
    
                // 更新监听通道
                ch = newCh
            } else if event.Type == zk.EventNodeDeleted {
                fmt.Println("Node deleted")
                return
            }
        }
    }

}

获取所有节点

func test3() {
    zkList := []string{"localhost:2181"}
    conn := getConnect(zkList)

    defer conn.Close()

    children, _, err := conn.Children("/go_servers")
    if err != nil {
        fmt.Println(err)
    }
    fmt.Printf("%v \n", children)
}

实现分布式锁node

以下是一个简单的示例，展示如何使用 ZooKeeper 实现分布式锁：

go复制代码package main

import (
    "fmt"
    "log"
    "time"

    "github.com/samuel/go-zookeeper/zk"
)

type DistributedLock struct {
    conn      *zk.Conn
    lockPath  string
    lockNode  string
    ephemeral bool
}

// 创建一个新的分布式锁
func NewDistributedLock(conn *zk.Conn, lockPath string) *DistributedLock {
    return &DistributedLock{
        conn:     conn,
        lockPath: lockPath,
    }
}

// 获取锁
func (dl *DistributedLock) Lock() error {
    // 创建持久顺序节点
    nodePath := fmt.Sprintf("%s/lock_", dl.lockPath)
    node, err := dl.conn.CreateProtectedEphemeralSequential(nodePath, []byte{}, zk.WorldACL(zk.PermAll))
    if err != nil {
        return fmt.Errorf("failed to create lock node: %v", err)
    }
    dl.lockNode = node

    // 获取当前锁节点下的所有子节点
    children, _, err := dl.conn.Children(dl.lockPath)
    if err != nil {
        return fmt.Errorf("failed to get children: %v", err)
    }

    // 获取序号最小的节点
    minNode := node
    for _, child := range children {
        if child < minNode {
            minNode = child
        }
    }

    // 如果当前节点是序号最小的节点，获取锁
    if node == minNode {
        fmt.Println("Lock acquired!")
        return nil
    }

    // 如果不是最小节点，等待前一个节点的删除
    prevNode := ""
    for _, child := range children {
        if child < node && (prevNode == "" || child > prevNode) {
            prevNode = child
        }
    }

    // 监听前一个节点的删除事件
    prevNodePath := fmt.Sprintf("%s/%s", dl.lockPath, prevNode)
    _, _, ch, err := dl.conn.ExistsW(prevNodePath)
    if err != nil {
        return fmt.Errorf("failed to set watch on previous node: %v", err)
    }

    // 等待前一个节点被删除
    event := <-ch
    if event.Type == zk.EventNodeDeleted {
        fmt.Println("Lock acquired!")
        return nil
    }

    return fmt.Errorf("failed to acquire lock")
}

// 释放锁
func (dl *DistributedLock) Unlock() error {
    if dl.lockNode == "" {
        return fmt.Errorf("lock not acquired")
    }

    err := dl.conn.Delete(dl.lockNode, -1)
    if err != nil {
        return fmt.Errorf("failed to release lock: %v", err)
    }

    fmt.Println("Lock released!")
    return nil
}

func main() {
    servers := []string{"127.0.0.1:2181"} // 替换为你的 ZooKeeper 实例的地址
    conn, _, err := zk.Connect(servers, time.Second)
    if err != nil {
        log.Fatalf("Failed to connect to ZooKeeper: %v", err)
    }
    defer conn.Close()

    lockPath := "/distributed_lock"
    lock := NewDistributedLock(conn, lockPath)

    err = lock.Lock()
    if err != nil {
        log.Fatalf("Failed to acquire lock: %v", err)
    }

    // 在这里执行需要同步的操作
    time.Sleep(2 * time.Second)

    err = lock.Unlock()
    if err != nil {
        log.Fatalf("Failed to release lock: %v", err)
    }
}

服务注册与发现

目前分布式系统已经很流行了，一些开源框架也被广泛应用，如dubbo、Motan等。对于一个分布式服务，最基本的一项功能就是服务的注册和发现，而利用zk的EPHEMERAL节点则可以很方便的实现该功能。EPHEMERAL节点正如其名，是临时性的，其生命周期是和客户端会话绑定的，当会话连接断开时，节点也会被删除。下边我们就来实现一个简单的分布式server：

server：

服务启动时，创建zk连接，并在go_servers节点下创建一个新节点，节点名为"ip:port"，完成服务注册 服务结束时，由于连接断开，创建的节点会被删除，这样client就不会连到该节点

server.go

package main

import (
    "github.com/samuel/go-zookeeper/zk"
)

func main() {
    go starServer("127.0.0.1:8897")
    go starServer("127.0.0.1:8898")
    go starServer("127.0.0.1:8899")

    a := make(chan bool, 1)
    <-a
}

func checkError(err error) {
    if err != nil {
        fmt.Println(err)
    }
}

func starServer(port string) {
    tcpAddr, err := net.ResolveTCPAddr("tcp4", port)
    fmt.Println(tcpAddr)
    checkError(err)

    listener, err := net.ListenTCP("tcp", tcpAddr)
    checkError(err)

    //注册zk节点q
    // 链接zk
    conn, err := GetConnect()
    if err != nil {
        fmt.Printf(" connect zk error: %s ", err)
    }
    defer conn.Close()
    // zk节点注册
    err = RegistServer(conn, port)
    if err != nil {
        fmt.Printf(" regist node error: %s ", err)
    }

    for {
        conn, err := listener.Accept()
        if err != nil {
            fmt.Fprintf(os.Stderr, "Error: %s", err)
            continue
        }
        go handleCient(conn, port)
    }

    fmt.Println("aaaaaa")
}

func handleCient(conn net.Conn, port string) {
    defer conn.Close()

    daytime := time.Now().String()
    conn.Write([]byte(port + ": " + daytime))
}
func GetConnect() (conn *zk.Conn, err error) {
    zkList := []string{"localhost:2181"}
    conn, _, err = zk.Connect(zkList, 10*time.Second)
    if err != nil {
        fmt.Println(err)
    }
    return
}

func RegistServer(conn *zk.Conn, host string) (err error) {
    _, err = conn.Create("/go_servers/"+host, nil, zk.FlagEphemeral, zk.WorldACL(zk.PermAll))
    return
}

func GetServerList(conn *zk.Conn) (list []string, err error) {
    list, _, err = conn.Children("/go_servers")
    return
}

client：

先从zk获取go_servers节点下所有子节点，这样就拿到了所有注册的server 从server列表中选中一个节点（这里只是随机选取，实际服务一般会提供多种策略），创建连接进行通信 这里为了演示，我们每次client连接server，获取server发送的时间后就断开。主要代码如下：

client.go

package main

import (
    "github.com/samuel/go-zookeeper/zk"
)

func checkError(err error) {
    if err != nil {
        fmt.Println(err)
    }
}
func main() {
    for i := 0; i < 100; i++ {
        startClient()

        time.Sleep(1 * time.Second)
    }
}

func startClient() {
    // service := "127.0.0.1:8899"
    //获取地址
    serverHost, err := getServerHost()
    if err != nil {
        fmt.Printf("get server host fail: %s \n", err)
        return
    }

    fmt.Println("connect host: " + serverHost)
    tcpAddr, err := net.ResolveTCPAddr("tcp4", serverHost)
    checkError(err)
    conn, err := net.DialTCP("tcp", nil, tcpAddr)
    checkError(err)
    defer conn.Close()

    _, err = conn.Write([]byte("timestamp"))
    checkError(err)

    result, err := ioutil.ReadAll(conn)
    checkError(err)
    fmt.Println(string(result))

    return
}

func getServerHost() (host string, err error) {
    conn, err := GetConnect()
    if err != nil {
        fmt.Printf(" connect zk error: %s \n ", err)
        return
    }
    defer conn.Close()
    serverList, err := GetServerList(conn)
    if err != nil {
        fmt.Printf(" get server list error: %s \n", err)
        return
    }

    count := len(serverList)
    if count == 0 {
        err = errors.New("server list is empty \n")
        return
    }

    //随机选中一个返回
    r := rand.New(rand.NewSource(time.Now().UnixNano()))
    host = serverList[r.Intn(3)]
    return
}
func GetConnect() (conn *zk.Conn, err error) {
    zkList := []string{"localhost:2181"}
    conn, _, err = zk.Connect(zkList, 10*time.Second)
    if err != nil {
        fmt.Println(err)
    }
    return
}
func GetServerList(conn *zk.Conn) (list []string, err error) {
    list, _, err = conn.Children("/go_servers")
    return
}

参考
https://topgoer.com/%E6%95%B0%E6%8D%AE%E5%BA%93%E6%93%8D%E4%BD%9C/zookeeper/

m0_73880436
关注
golang操作zookeeper
qq_39280718的博客
09-13 765
golang操作zookeeper
Go-借助zookeeper实现服务发现
08-14
在Go中，我们可以使用`go-zookeeper/zk`库来操作Zookeeper。这个库提供了与Zookeeper通信的API，包括连接、读写节点、设置Watcher等功能。以下是一些基本操作示例： ```go import ( "fmt" "github....
go-zookeeper：Go的本机ZooKeeper客户端。 该项目不再维护。 请改用https：github.comgo-zookeeperzk
02-27
本机Go Zookeeper客户端库 执照 3句BSD。 请参阅许可文件。 该存储库不再维护 请使用主动维护派生。
zookeeper(go-zookeeper)
xiaoxiaoyu85的专栏
03-20 423
1. 单机搭建 https://blog.csdn.net/weixin_42207486/article/details/80647802 下载wget http://apache.fayea.com/zookeeper/zookeeper-3.4.14/zookeeper-3.4.14.tar.gz 2.集群搭建 Zookeeper集群中节点个数一般为奇数个（>=3），若集群中...
【GO】27. zookeeper golang库go-zookeeper实例
chen_peng7的博客
10-19 1513
Golang 操作 zookeeper 使用库：https://github.com/samuel/go-zookeeper 文档地址：http://godoc.org/github.com/samuel/go-zookeeper/zk 连接zk server package main import ( "fmt" "github.com/samuel/go-zookeeper/zk" "time" ) func main() { // 创建zk连接地址 hosts := [].
ZooKeeper 实战（GO）
热门推荐
Comin的博客
10-20 5万+
1、安装和基础操作 1、下载 地址Apache ZooKeeper 2、解压后进入目录： tar -zxvf apache-zookeeper-3.7.0-bin.tar.gz cd apache-zookeeper-3.7.0-bin 3、配置 拷贝一份conf/zoo_sample.cfg，命名为zoo_1.cfg 单实例情况下，配置不用做修改 4、启动 bin/zkServer.sh start conf/zoo...
Go ZooKeeper客户端
最新发布
gitblog_00032的博客
03-17 430
Go ZooKeeper客户端 go-zookeeperNative ZooKeeper client for Go. This project is no longer maintained. Please use https://github.com/go-zookeeper/zk instead.项目地址:https://gitcode.com/gh_mirrors/goz/go-zook...
go-zab:ZooKeeper 原子广播的 Go 实现
06-12
在标题中，"go-zab"是一个用Go语言实现的项目，它专注于ZooKeeper的原子广播（Atomic Broadcast）机制。ZooKeeper是Apache的一个分布式协调服务，而原子广播是其核心功能之一，用于确保在分布式环境中数据的一致性和...
Go-zk-sniffer使用golang嗅探和解析ZooKeeper数据包
08-14
《Go-zk-sniffer：利用Golang解析ZooKeeper数据包》 ZooKeeper，作为分布式协调服务，广泛应用于各种分布式系统中。然而，对于其内部数据包的监控和分析，往往需要专业的工具来帮助我们理解系统运行状态。Go-zk-...
zookeeper-operator:适用于Apache Zookeeper的Kubernetes运算符
05-01
Zookeeper操作员管理部署到Zookeeper集群，并自动执行与操作Zookeeper集群相关的任务。 要求 Kubernetes 1.7以上 Zookeeper 3.5.3-beta + 安装Zookeeper操作员 为Zookeeper操作员创建部署： $ kubectl create -f ...
Go语言连接 zookeeper
冰河世纪20的博客
03-15 5513
介绍 Apache ZooKeeper 是 Apache 软件基金会的一个软件项目，他为大型分布式计算提供开源的分布式配置服务、同步服务和命名注册。ZooKeeper 曾经是 Hadoop 的一个子项目，但现在是一个独立的顶级项目。 ZooKeeper 的架构通过冗余服务实现高可用性。因此，如果第一次无应答，客户端就可以询问另一台 ZooKeeper 主机。ZooKeeper 节点将它们的数据存储...
Golang 操作 Zookeeper
weixin_38846160的博客
05-14 441
完整的源码地址：https://github.com/xuqil/experiments/tree/main/zookeeper-clientgo-zookeeper 库地址：https://pkg.go.dev/github.com/go-zookeeper/zk@v1.0.3。
Golang分布式应用之ZooKeeper
Qinng的博客
08-10 1517
本文分析了ZooKeeper在分布式锁、服务发现等场景上的实现方式，并对比了与etcd的差异点。
Zookeeper Golang客户端：go-zookeeper的基本使用
业精于勤，荒于嬉；行成于思，毁于随
08-25 2万+
Zookeeper Golang客户端：go-zookeeper的基本使用1.连接到ZK server端var hosts = []string{"localhost:8000"}//server端host conn, _, err := zk.Connect(hosts, time.Second*5) if err != nil { fmt.Println(err)
zookeeper的介绍和用docker搭建zookeeper集群，以及Go语言使用zookeeper
m0_52530105的博客
06-21 3721
Apache ZooKeeper 是 Apache 软件基金会的一个软件项目，为大型分布式系统提供开源分布式配置服务、同步服务和命名注册。ZooKeeper原本是Hadoop的一个子项目，但现在它本身已经是一个顶级项目了。zookeeper是经典的分布式数据一致性解决方案，致力于为分布式应用提供一个高性能，高可用，且具有严格顺序访问控制能力的分布式协调存储服务。
golang使用zookeeper进行CURD
weixin_42128977的博客
10-10 655
Zookeeper是一个分布式数据库(程序协调服务)，Hadoop子项目；以树状方式维护节点方数据的增、删、改、查；通过监听可以获取相应消息事件；持久节点：一直存储在服务器上(0)临时节点：会话失效、节点自动清理(FlagEphemeral)顺序节点：节点创建时自动分配序列号(FlagSequence)
go-zookeeper客户端可选参数配置
大叶子不小的博客
05-17 277
go-zookeeper有3个比较常用的可选参数，分别控制日志输出和事件回调： //是否输出日志 func WithLogInfo(logInfo bool) connOption //定制日志输出 func WithLogger(logger Logger) connOption //事件回调 func WithEventCallback(cb EventCallback) connOption 示例： package main import ( "github.com/sa...
Go语言：zookeeper客户端可选参数配置
pengpengzhou的博客
04-23 535
go-zookeeper有3个比较常用的可选参数，分别控制日志输出和事件回调： //是否输出日志 func WithLogInfo(logInfo bool) connOption //定制日志输出 func WithLogger(logger Logger) connOption //事件回调 func WithEventCallback(cb EventCallback) connOpt...
Codis3.1集群搭建全攻略：从Go到Zookeeper
在搭建 Codis 集群之前，首先需要安装 Go 语言环境，并配置好 GOPATH，这将作为 Codis 安装和工作目录。然后，搭建 Zookeeper 集群，每个节点都需要配置 `zoo.cfg` 文件，设置数据目录、日志目录以及服务器列表，并...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值