Golang 1.18 ETCD操作实践

ETCD Golang

Golang 1.18 ETCD操作实践

在分布式系统领域，ETCD 凭借其高可用、强一致性的特点，成为服务发现、配置管理等场景的核心工具。Golang 以其高效性能和简洁语法，与 ETCD 搭配能极大提升分布式系统开发效率。

本文基于 Golang 1.18 版本，深入探讨 ETCD 在 Golang 中的使用实践，涵盖增删改查、Watch 机制、事务操作等丰富用例。

一、环境搭建与依赖引入

1.1 安装 ETCD

在本地开发环境，可通过官网（https://github.com/etcd-io/etcd/releases）下载对应操作系统的 ETCD 二进制文件。以 Linux 系统为例，下载完成后解压文件，将etcd和etcdctl可执行文件添加到系统路径中。启动 ETCD 服务：

./etcd

服务默认监听localhost:2379端口，可通过etcdctl endpoint health命令检查服务状态。

1.2 初始化 Golang 项目

创建项目目录并初始化 Go 模块：

mkdir etcd-practice
cd etcd-practice
go mod init github.com/your-username/etcd-practice

1.3 引入 ETCD 客户端库

使用go get命令获取 ETCD 客户端库：

go get go.etcd.io/etcd/client/v3

该库提供了与 ETCD 交互的完整功能接口，支持连接管理、数据操作等核心功能。

二、建立与 ETCD 的连接

在 Golang 中连接 ETCD，需创建客户端实例。示例代码如下：

package main

import (
    "context"
    "fmt"
    "time"

    "go.etcd.io/etcd/client/v3"
)

func connectETCD() (*clientv3.Client, error) {
    client, err := clientv3.New(clientv3.Config{
        Endpoints:   []string{"localhost:2379"},
        DialTimeout: 5 * time.Second,
    })
    if err != nil {
        return nil, fmt.Errorf("failed to connect to etcd: %v", err)
    }
    return client, nil
}

上述代码通过clientv3.New函数创建客户端实例，Endpoints指定 ETCD 服务地址，DialTimeout设置连接超时时间。连接成功后，可使用返回的client对象进行后续操作。

三、数据增删改查操作

3.1 数据插入（Put）

向 ETCD 中插入数据，使用Put方法：

func putData(client *clientv3.Client, key, value string) error {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    _, err := client.Put(ctx, key, value)
    cancel()
    if err != nil {
        return fmt.Errorf("failed to put data: %v", err)
    }
    fmt.Printf("Successfully put key %s with value %s\n", key, value)
    return nil
}

Put方法接收上下文、键和值作为参数，执行成功后会打印提示信息。

3.2 数据查询（Get）

查询数据使用Get方法：

func getData(client *clientv3.Client, key string) (string, error) {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    resp, err := client.Get(ctx, key)
    cancel()
    if err != nil {
        return "", fmt.Errorf("failed to get data: %v", err)
    }
    if len(resp.Kvs) == 0 {
        return "", nil
    }
    value := string(resp.Kvs[0].Value)
    fmt.Printf("Successfully got key %s with value %s\n", key, value)
    return value, nil
}

Get方法返回包含键值对的响应对象，通过解析resp.Kvs获取对应的值。

3.3 数据修改

修改数据本质上是重新执行Put操作，覆盖原有键值对：

func updateData(client *clientv3.Client, key, newValue string) error {
    return putData(client, key, newValue)
}

3.4 数据删除（Delete）

删除数据使用Delete方法：

func deleteData(client *clientv3.Client, key string) error {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    _, err := client.Delete(ctx, key)
    cancel()
    if err != nil {
        return fmt.Errorf("failed to delete data: %v", err)
    }
    fmt.Printf("Successfully deleted key %s\n", key)
    return nil
}

四、Watch 机制实践

Watch 操作可监听 ETCD 中键值对变化，示例如下：

func watchData(client *clientv3.Client, key string) {
    rch := client.Watch(context.Background(), key)
    for wresp := range rch {
        for _, ev := range wresp.Events {
            switch ev.Type {
            case clientv3.EventTypePut:
                fmt.Printf("Key %s updated with value %s\n", string(ev.Kv.Key), string(ev.Kv.Value))
            case clientv3.EventTypeDelete:
                fmt.Printf("Key %s deleted\n", string(ev.Kv.Key))
            }
        }
    }
}

上述代码通过Watch方法创建监听通道rch，当键值对发生Put或Delete事件时，会在控制台输出相应提示。

五、事务操作实践

ETCD 支持事务操作，确保一系列操作的原子性。以下示例展示条件判断下的事务操作：

func transaction(client *clientv3.Client) error {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    resp, err := client.Txn(ctx).
        If(clientv3.Compare(clientv3.Value("key1"), "=", "value1")).
        Then(clientv3.OpPut("key2", "value2")).
        Else(clientv3.OpPut("key3", "value3")).
        Commit()
    cancel()
    if err != nil {
        return fmt.Errorf("failed to execute transaction: %v", err)
    }
    if resp.Succeeded {
        fmt.Println("Transaction succeeded")
    } else {
        fmt.Println("Transaction failed")
    }
    return nil
}

该事务通过If条件判断key1的值，满足条件则执行Then分支操作，否则执行Else分支操作，最后通过Commit提交事务。

六、完整示例代码

package main

import (
    "context"
    "fmt"
    "time"

    "go.etcd.io/etcd/client/v3"
)

func connectETCD() (*clientv3.Client, error) {
    client, err := clientv3.New(clientv3.Config{
        Endpoints:   []string{"localhost:2379"},
        DialTimeout: 5 * time.Second,
    })
    if err != nil {
        return nil, fmt.Errorf("failed to connect to etcd: %v", err)
    }
    return client, nil
}

func putData(client *clientv3.Client, key, value string) error {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    _, err := client.Put(ctx, key, value)
    cancel()
    if err != nil {
        return fmt.Errorf("failed to put data: %v", err)
    }
    fmt.Printf("Successfully put key %s with value %s\n", key, value)
    return nil
}

func getData(client *clientv3.Client, key string) (string, error) {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    resp, err := client.Get(ctx, key)
    cancel()
    if err != nil {
        return "", fmt.Errorf("failed to get data: %v", err)
    }
    if len(resp.Kvs) == 0 {
        return "", nil
    }
    value := string(resp.Kvs[0].Value)
    fmt.Printf("Successfully got key %s with value %s\n", key, value)
    return value, nil
}

func updateData(client *clientv3.Client, key, newValue string) error {
    return putData(client, key, newValue)
}

func deleteData(client *clientv3.Client, key string) error {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    _, err := client.Delete(ctx, key)
    cancel()
    if err != nil {
        return fmt.Errorf("failed to delete data: %v", err)
    }
    fmt.Printf("Successfully deleted key %s\n", key)
    return nil
}

func watchData(client *clientv3.Client, key string) {
    rch := client.Watch(context.Background(), key)
    for wresp := range rch {
        for _, ev := range wresp.Events {
            switch ev.Type {
            case clientv3.EventTypePut:
                fmt.Printf("Key %s updated with value %s\n", string(ev.Kv.Key), string(ev.Kv.Value))
            case clientv3.EventTypeDelete:
                fmt.Printf("Key %s deleted\n", string(ev.Kv.Key))
            }
        }
    }
}

func transaction(client *clientv3.Client) error {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    resp, err := client.Txn(ctx).
        If(clientv3.Compare(clientv3.Value("key1"), "=", "value1")).
        Then(clientv3.OpPut("key2", "value2")).
        Else(clientv3.OpPut("key3", "value3")).
        Commit()
    cancel()
    if err != nil {
        return fmt.Errorf("failed to execute transaction: %v", err)
    }
    if resp.Succeeded {
        fmt.Println("Transaction succeeded")
    } else {
        fmt.Println("Transaction failed")
    }
    return nil
}

func main() {
    client, err := connectETCD()
    if err != nil {
        fmt.Println(err)
        return
    }
    defer client.Close()

    // 插入数据
    if err := putData(client, "test-key", "test-value"); err != nil {
        fmt.Println(err)
        return
    }
    // 查询数据
    if value, err := getData(client, "test-key"); err != nil {
        fmt.Println(err)
        return
    } else {
        fmt.Println("Retrieved value:", value)
    }
    // 修改数据
    if err := updateData(client, "test-key", "new-test-value"); err != nil {
        fmt.Println(err)
        return
    }
    // 删除数据
    if err := deleteData(client, "test-key"); err != nil {
        fmt.Println(err)
        return
    }
    // Watch操作
    go watchData(client, "watch-key")
    // 模拟数据变化触发Watch
    go func() {
        time.Sleep(2 * time.Second)
        putData(client, "watch-key", "initial-value")
        time.Sleep(2 * time.Second)
        updateData(client, "watch-key", "updated-value")
        time.Sleep(2 * time.Second)
        deleteData(client, "watch-key")
    }()
    // 事务操作
    if err := transaction(client); err != nil {
        fmt.Println(err)
        return
    }

    select {}
}

七、总结

本文介绍了 Golang 1.18 下 ETCD 的使用实践，通过丰富的代码示例展示了数据增删改查、Watch 机制和事务操作。在实际分布式系统开发中，合理运用这些功能，可实现高效的服务发现、动态配置更新等关键需求。开发者在使用过程中，需注意异常处理和资源释放，确保系统稳定运行。

如需进一步探索 ETCD 的高级特性，可深入研究租约（Lease）、分布式锁等功能，拓展系统应用场景。

如果觉得文章对你有用，请随意赞赏

ETCD Golang

Golang 1.18 ETCD操作实践

https://www.ztong-techhub.com/archives/Oc9dBGEO

作者

张同

发布于

2025-03-21

更新于

2025-04-20

许可协议

CC BY 4.0

Golang 1.18 ETCD操作实践

Golang 1.18 ETCD操作实践

一、环境搭建与依赖引入

1.1 安装 ETCD

1.2 初始化 Golang 项目

1.3 引入 ETCD 客户端库

二、建立与 ETCD 的连接

三、数据增删改查操作

3.1 数据插入（Put）

3.2 数据查询（Get）

3.3 数据修改

3.4 数据删除（Delete）

四、Watch 机制实践

五、事务操作实践

六、完整示例代码

七、总结

作者

发布于

更新于

许可协议

评论