Etcd 框架 - 悦读

基本了解

客户端、长连接与租约的关系

客户端对象

etcd的客户端对象是用户与etcd服务进行交互的主要接口，主要功能就是存储、通知和事务等功能访问

键值存储：客户端通过put 和 get操作存储数据；数据存储在etcd的层级化键值数据库中
监听器（Watcher）：客户端可以监听指定键的变化事件，如果键值发生改变，etcd会通过回调通知客户端；借助监听器可以实现动态管理配置和服务发现
事务：提供txn接口，允许客户端进行原子性操作

工作原理

客户端通过gRpc与etcd集群进行交互
连接时，客户端需要提供集群的地址和认证信息
连接建立后，客户端可以调用功能不同API完成具体功能

长连接

长连接是指客户端与etcd服务之间的持续连接，主要用于保持会话状态以及实现实时性功能

保持租约长期有效：租约需要客户端通过长连接向etcd定期发送心跳包，否则租约会到期
监听：监听功能依赖于长连接，当监听的键发生变化的时候，etcd通过长连接向客户端推送事件
减少开销：长连接避免了频繁的连接断开，节省了建立连接的时间和资源

工作原理

客户端与 etcd 集群节点通过 gRPC 建立连接
建立连接后，客户端发送 KeepAlive 请求以保持连接
如果 etcd 未在一定时间内接收到心跳，会认为连接断开

租约

etcd提供的一种机制，主要用于一段时间内绑定键值数据，并确保键值在租约有效期内有效

动态生存时间：键值可以绑定到租约，租约到期后，绑定的键值会自动删除
分布式锁：租约结合键值和keeplive实现分布式锁，确保资源的唯一占用
Session管理：通过租约，可以熟实现分布式会话管理

工作原理

客户端调用 LeaseGrant 接口创建租约，并设置租期
将键值与租约绑定。例如，使用 Put 命令时指定租约ID
客户端通过长连接定期向 etcd 发送心跳，续租以保持租约有效
如果未续约，租约到期后，绑定的键值会自动被删除

应用：服务实例向 etcd 注册自己（通过租约绑定信息），当实例下线或不可用时，租约自动到期并移除信息

基本使用

安装

框架安装

GitHub - etcd-cpp-apiv3/etcd-cpp-apiv3: The etcd-cpp-apiv3 is a C++ library for etcd's v3 client APIs, i.e., ETCDCTL_API=3.

验证动态库和相应的文件是否存在

使用

上传和获取逻辑

// get.cc

#include <etcd/Client.hpp>
#include <etcd/KeepAlive.hpp>
#include <etcd/Response.hpp>
#include <etcd/Watcher.hpp>
#include <etcd/Value.hpp>
#include <thread>

// 回调函数：用于处理监控到的键值变化事件
void callback(const etcd::Response &resp) {
    // 如果收到的事件通知无效，打印错误信息并返回
    if (!resp.is_ok()) {
        std::cout << "收到一个错误的事件通知: " << resp.error_message() << std::endl;
        return;
    }

    // 遍历事件列表，逐个处理每个事件
    for (auto const& ev : resp.events()) {
        // 如果事件类型是 PUT（键值被创建或修改）
        if (ev.event_type() == etcd::Event::EventType::PUT) {
            std::cout << "服务信息发生了改变:\n";
            std::cout << "当前的值：" << ev.kv().key() << " - " << ev.kv().as_string() << std::endl;
            std::cout << "原来的值：" << ev.prev_kv().key() << " - " << ev.prev_kv().as_string() << std::endl;
        }
        // 如果事件类型是 DELETE（键值被删除）
        else if (ev.event_type() == etcd::Event::EventType::DELETE_) {
            std::cout << "服务信息下线被删除:\n";
            std::cout << "当前的值：" << ev.kv().key() << " - " << ev.kv().as_string() << std::endl;
            std::cout << "原来的值：" << ev.prev_kv().key() << " - " << ev.prev_kv().as_string() << std::endl;
        }
    }
}

int main(int argc, char *argv[])
{
    // 定义etcd服务的地址，默认使用本地运行的etcd服务
    std::string etcd_host = "http://127.0.0.1:2379";

    // 1. 实例化etcd客户端对象，用于和etcd服务交互
    etcd::Client client(etcd_host);

    // 2. 获取 "/service" 路径下的所有键值对
    auto resp = client.ls("/service").get(); // 同步调用获取响应
    if (!resp.is_ok()) {
        // 如果获取失败，打印错误信息并退出程序
        std::cout << "获取键值对数据失败: " << resp.error_message() << std::endl;
        return -1;
    }

    // 3. 遍历返回的键值对，打印每个键值对的信息
    int sz = resp.keys().size(); // 获取键值对的数量
    for (int i = 0; i < sz; ++i) {
        std::cout << resp.value(i).as_string() << " 可以提供 " << resp.key(i) << " 服务\n";
    }

    // 4. 实例化一个Watcher对象，用于监听 "/service" 路径下的键值变化
    // 参数说明：
    // - `client`: 使用前面实例化的客户端对象
    // - "/service": 要监听的路径
    // - `callback`: 监听到键值变化后调用的回调函数
    // - `true`: 是否递归监听路径下的子路径（true 表示递归）
    auto watcher = etcd::Watcher(client, "/service", callback, true);

    // 5. 启动Watcher，阻塞当前线程，持续监听事件，直到程序被中断
    watcher.Wait();

    // 6. 结束程序
    return 0;
}

//put.cc

#include <etcd/Client.hpp>
#include <etcd/KeepAlive.hpp>
#include <etcd/Response.hpp>
#include <thread>

int main(int argc, char *argv[])
{
    std::string etcd_host = "http://127.0.0.1:2379";
    //实例化客户端对象
    etcd::Client client(etcd_host);
    //获取租约保活对象--伴随着创建一个指定有效时长的租约
    auto keep_alive = client.leasekeepalive(3).get();
    //获取租约ID
    auto lease_id = keep_alive->Lease();
    //向etcd新增数据
    auto resp1 = client.put("/service/user", "127.0.0.1:8080", lease_id).get();
    if (resp1.is_ok() == false) {
        std::cout << "新增数据失败：" << resp1.error_message() << std::endl;
        return -1;
    }
    auto resp2 = client.put("/service/friend", "127.0.0.1:9090").get();
    if (resp2.is_ok() == false) {
        std::cout << "新增数据失败：" << resp2.error_message() << std::endl;
        return -1;
    }
    std::this_thread::sleep_for(std::chrono::seconds(10));
    return 0;
}

接口学习

基于上传和获取学习接口

etcd::Client 类

etcd::Client 是核心客户端类，用于与 etcd 服务进行交互，提供基本的键值存取和操作功能

构造函数

etcd_url：etcd 服务地址（例如 http://127.0.0.1:2379）
创建一个与 etcd 服务通信的客户端对象

etcd::Client client(const std::string &etcd_url);

ls() 方法

列出路径下所有的键值
key：路径键，表示需要获取其子键的根路径（例如 /service）
返回一个 std::future<etcd::Response>，可以通过 .get() 同步获取结果

std::future<etcd::Response> ls(const std::string &key);

auto resp = client.ls("/service").get();
if (resp.is_ok()) {
    // 获取成功，遍历键值
    for (const auto &key : resp.keys()) {
        std::cout << key << ": " << resp.value(key).as_string() << std::endl;
    }
} else {
    std::cerr << "获取失败: " << resp.error_message() << std::endl;
}

etcd::Watcher 类

用于监听指定路径下的键值变化事件，并触发回调函数处理这些事件

构造函数

client：etcd::Client 对象，用于连接 etcd 服务。
key：要监听的路径键（例如 /service）。
callback：回调函数，当监听到键值变化时触发，参数是 etcd::Response 对象。
recursive：是否递归监听子路径下的键值变化，默认为 false。
功能：创建一个监听器对象，监听制定路径下的键值变化

etcd::Watcher watcher(etcd::Client &client, const std::string &key,
                      std::function<void(const etcd::Response &)> callback,
                      bool recursive = false);

Wait() 方法

阻塞当前线程，持续监听键值变化事件，直到被中断

auto watcher = etcd::Watcher(client, "/service", callback, true);
watcher.Wait(); // 阻塞线程等待事件

etcd::Response 类

etcd 请求或事件的响应对象，包含操作结果及相关数据

is_ok() 方法

判断请求是否成功：成功则返回true，失败则返回false

bool is_ok() const;

error_message() 方法

获取请求或者事件失败的错误信息

std::string error_message() const;

keys() 方法

获取路径下所有键的列表

std::vector<std::string> keys() const;

value(key) 方法

返回指向键的值对象

etcd::Value value(const std::string &key) const;

events() 方法

获取监听器捕获到的事件列表

std::vector<etcd::Event> events() const;

etcd::Value 类

etcd::Value 表示 etcd 中的键值对，包含键、值及其元数据

key() 方法

获取键的名称

std::string key() const;

as_string() 方法

获取键对应的值（字符串形式）

std::string as_string() const;

etcd::Value val = resp.value(key);
std::cout << "Key: " << val.key() << ", Value: " << val.as_string() << std::endl;

二次封装

基本思想

服务注册客户端类（Registry）

主要目标

向etcd注册服务信息（通过键值对方式）并确保其活跃状态
借用租约机制保证注册信息的有效性，如果租约过期，服务注册信息回自动清除

实现逻辑

创建一个etcd客户端，用于与etcd进行通信
创建租约（Lease），为服务注册信息绑定一个动态生存空间
定期发送心跳保活（KeepLive），续约租约，确保服务信息不会被自动删除
提供一个registry方法，用于注册服务信息（键值对）

服务发现客户端类

主要目标

从etcd中获取指定路径下的当前服务信息
通过监听机制实时监控服务信息的变化（例如服务新增、服务下线）
使用回调函数处理服务变更事件

实现逻辑

创建etcd客户端用于与etcd通信
使用ls方法获取当前路径下所有的键值对，处理当前已有数据
创建Watcher对象，监听指定路径下的数据变更事件
在事件回调中，根据事件的类型调用对应的回调函数

具体实现

细节补充：Watcher中使用Bind进行回调的逻辑总结

Watcher 检测到事件：etcd::Watcher 检测到指定路径的键值发生了变化（例如新增或删除）
Watcher 调用回调函数：Watcher 将变化事件封装为 etcd::Response 对象，调用绑定后的函数对象，并将 etcd::Response 作为参数传递
绑定的函数对象调用 callback：其中，this 是 Discovery 类的实例，resp 是 etcd::Watcher 提供的事件响应
callback 函数执行：callback 使用 resp 提供的事件信息，执行具体的业务逻辑（例如调用 _put_cb 或 _del_cb）

this->callback(resp);

etcd二次封装实现

#pragma once
#include <etcd/Client.hpp>
#include <etcd/KeepAlive.hpp>
#include <etcd/Response.hpp>
#include <etcd/Watcher.hpp>
#include <etcd/Value.hpp>
#include <functional>
#include "logger.hpp"

namespace mag {
    // 服务注册客户端类
    class Registry 
    {
    public:
        using ptr = std::shared_ptr<Registry>;

        // 构造函数：初始化etcd客户端和租约（Lease）机制
        Registry(const std::string &host):
            _client(std::make_shared<etcd::Client>(host)), // 创建etcd客户端
            _keep_alive(_client->leasekeepalive(3).get()), // 创建一个3秒TTL的租约并保持续约
            _lease_id(_keep_alive->Lease()){} // 获取租约ID

        // 析构函数：取消租约续约，释放资源
        ~Registry() { _keep_alive->Cancel(); }

        // 注册服务信息：将键值对存入etcd并绑定租约
        bool registry(const std::string &key, const std::string &val) 
        {
            auto resp = _client->put(key, val, _lease_id).get(); // 绑定租约，写入键值对
            if (resp.is_ok() == false) 
            {
                LOG_ERROR("注册数据失败：{}", resp.error_message()); // 打印错误日志
                return false;
            }
            return true; // 返回注册结果
        }
    private:
        std::shared_ptr<etcd::Client> _client; // etcd客户端对象
        std::shared_ptr<etcd::KeepAlive> _keep_alive; // 租约续约对象
        uint64_t _lease_id; // 租约ID
    };

    // 服务发现客户端类
    class Discovery 
    {
    public:
        using ptr = std::shared_ptr<Discovery>;
        using NotifyCallback = std::function<void(std::string, std::string)>;

        // 构造函数：初始化etcd客户端，执行服务发现和事件监听
        Discovery(const std::string &host, 
            const std::string &basedir,
            const NotifyCallback &put_cb,
            const NotifyCallback &del_cb)
            :_client(std::make_shared<etcd::Client>(host)), // 创建etcd客户端
             _put_cb(put_cb), _del_cb(del_cb) // 设置回调函数
            {
            // 服务发现：获取当前路径下的已有服务数据
            auto resp = _client->ls(basedir).get(); // 列出路径下的所有键值
            if (resp.is_ok() == false) 
            {
                LOG_ERROR("获取服务信息数据失败：{}", resp.error_message()); // 打印错误日志
            }
            int sz = resp.keys().size();
            for (int i = 0; i < sz; ++i) 
            {
                if (_put_cb) _put_cb(resp.key(i), resp.value(i).as_string()); // 调用服务新增回调
            }

            // 事件监控：监听路径数据变更并调用回调处理
            _watcher = std::make_shared<etcd::Watcher>(*_client.get(), basedir,
                std::bind(&Discovery::callback, this, std::placeholders::_1), true);
        }

        // 析构函数：取消事件监听，释放资源
        ~Discovery() {
            _watcher->Cancel();
        }
    private:
        // 事件回调函数：处理服务新增和删除事件
        void callback(const etcd::Response &resp) 
        {
            if (resp.is_ok() == false) {
                LOG_ERROR("收到一个错误的事件通知: {}", resp.error_message()); // 打印错误日志
                return;
            }
            for (auto const& ev : resp.events()) 
            {
                // 新增服务事件
                if (ev.event_type() == etcd::Event::EventType::PUT) {
                    if (_put_cb) _put_cb(ev.kv().key(), ev.kv().as_string()); // 调用服务新增回调
                    LOG_DEBUG("新增服务：{}-{}", ev.kv().key(), ev.kv().as_string()); // 打印调试信息
                }
                // 服务下线事件
                else if (ev.event_type() == etcd::Event::EventType::DELETE_) {
                    if (_del_cb) _del_cb(ev.prev_kv().key(), ev.prev_kv().as_string()); // 调用服务删除回调
                    LOG_DEBUG("下线服务：{}-{}", ev.prev_kv().key(), ev.prev_kv().as_string()); // 打印调试信息
                }
            }
        }
    private:
        NotifyCallback _put_cb; // 服务新增事件回调
        NotifyCallback _del_cb; // 服务删除事件回调
        std::shared_ptr<etcd::Client> _client; // etcd客户端对象
        std::shared_ptr<etcd::Watcher> _watcher; // 事件监听器
    };
}

测试注册和发现逻辑

#include "etcd.hpp"
#include <iostream>
#include <chrono>
#include <thread>

// 服务新增回调
void onServiceAdded(const std::string &key, const std::string &value) {
    std::cout << "发现新增服务：" << key << " -> " << value << std::endl;
}

// 服务下线回调
void onServiceRemoved(const std::string &key, const std::string &value) {
    std::cout << "服务下线：" << key << " -> " << value << std::endl;
}

int main() {
    std::string etcd_host = "http://127.0.0.1:2379";
    std::string watch_dir = "/service";

    // 创建Discovery对象
    mag::Discovery::ptr discovery = std::make_shared<mag::Discovery>(
        etcd_host, watch_dir, onServiceAdded, onServiceRemoved
    );

    // 保持监听状态
    std::cout << "开始监听服务变更，按 Ctrl+C 退出..." << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(600));

    return 0;
}

#include "etcd.hpp"
#include <iostream>
#include <chrono>
#include <thread>

int main() {
    std::string etcd_host = "http://127.0.0.1:2379";
    std::string key = "/service/example";
    std::string value = "127.0.0.1:8080";

    // 创建Registry对象
    mag::Registry::ptr registry = std::make_shared<mag::Registry>(etcd_host);

    // 注册服务
    if (registry->registry(key, value)) {
        std::cout << "服务注册成功：" << key << " -> " << value << std::endl;
    } else {
        std::cerr << "服务注册失败！" << std::endl;
        return -1;
    }

    // 保持注册信息的活跃状态
    std::cout << "服务正在运行，按 Ctrl+C 退出..." << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(600));

    return 0;
}

问题

编译问题慢

问题描述

多次对该文件进行编译，编译总是卡在80%左右停止，服务器环境是2核2G的云服务器

分析

经htop进行排查，发现部分服务占用了大量内存，从而导致编译写入和读取文件速度变慢

解决思路

停止占用内存较高的MySQL服务

sudo systemctl stop mysql

清理缓存和无用数据

sync; echo 3 | sudo tee /proc/sys/vm/drop_caches

删除临时文件进一步释放空间

sudo apt autoremove -y
sudo apt clean

使用两个线程对程序进行编译

make -j2