高可用架構(gòu)etcd選主故障主備秒級切換實現(xiàn)

更新時間：2022年02月24日 17:02:52 作者：kl

這篇文章主要為大家介紹了高可用架構(gòu)etcd選主故障主備秒級切換的實現(xiàn)，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪

什么是Etcd？

etcd是一個強大的一致性的分布式鍵值存儲，它提供了一種可靠的方式來存儲需要由分布式系統(tǒng)或機器群訪問的數(shù)據(jù)。它優(yōu)雅地處理網(wǎng)絡分區(qū)期間的領(lǐng)導者選舉，并且可以容忍機器故障，即使在領(lǐng)導者節(jié)點中也是如此。從簡單的Web應用程序到Kubernetes，任何復雜的應用程序都可以讀取數(shù)據(jù)并將數(shù)據(jù)寫入etcd。這是官方對Etcd的描述，基于這些特性，Etcd常用于分布式配置、分布式鎖、分布式服務協(xié)調(diào)者以及分布式注冊。從功能上來說和zookeeper是一類項目，但是相比而言etcd更現(xiàn)代，etcd使用go語言開發(fā)，編譯后生成了系統(tǒng)可執(zhí)行的二進制產(chǎn)物，跨平臺性更好，更易維護。etcd直接提供http的接口，非常方便各大語言封裝自己的client sdk，在易用性方面也更好一點。下面也主要使用java的客戶端jetcd，解決主備服務的協(xié)調(diào)問題。

etcd官網(wǎng)：https://etcd.io

主備服務場景描述

很多時候為了服務的高可用，除了有個在工作的主服務外，還需要多啟用幾個備用服務，這樣，在主服務出現(xiàn)故障時，備用服務能夠馬上頂上。這個場景有個很明顯的特征就是同一時間只能有一個主服務。常見的如mysql主從切換等，同一時間只能有一個msyql負責寫數(shù)據(jù)。在我們這邊的場景是，有一個binlog解析服務，實時解析mysql 的binlog，將解析到的數(shù)據(jù)傳遞到kafka中，kafka消費端有一個Flink job去消費解析的數(shù)據(jù)。最終這些數(shù)據(jù)會下層到數(shù)據(jù)中臺中，提供給中臺系統(tǒng)做基礎的業(yè)務數(shù)據(jù)。很多在線的服務查詢的數(shù)據(jù)就是來源binlog解析的數(shù)據(jù)，所以binlog解析的服務不能存在單點故障，在架構(gòu)上只能是一主多備的模式，主服務故障時，備用服務實時頂上。同時binlog服務也不能同時多個解析。所以，這個場景使用etcd來做主備架構(gòu)再好不過了。

jetcd具體實現(xiàn)

首先引入jetcd依賴

<dependency>
            <groupId>io.etcd</groupId>
            <artifactId>jetcd-core</artifactId>
            <version>0.3.0</version>
</dependency>

初始化客戶端

Client client = Client.builder().endpoints(
                "http://127.0.0.1:2379",
                "http://127.0.0.1:3379",
                "http://127.0.0.1:4379"
        ).build();

關(guān)鍵api介紹

Lock lock = client.getLockClient();
        Lease lease = client.getLeaseClient();

Lease提供授予，撤銷和保持租約的方法，其中有兩個關(guān)鍵方法grant(long ttl)和keepAlive()。grant用于授予租約，入?yún)樽饧s的時間，即如果創(chuàng)建帶租約的key值，ttl秒后即自動刪除，返回租約的id。keepAlive()方法用于保持租約有效，即如果租約即將到期時，keepAlive能夠自動續(xù)租ttl時間。
Lock有兩個方法，lock(ByteSequence name, long leaseId)和unlock(ByteSequence lockKey)。來實現(xiàn)分布式鎖的功能，其中加鎖時，入?yún)easeid為續(xù)約對象的id，即定義了持有鎖的時間

通過這Lease和Lock的功能，很容易實現(xiàn)主備服務的切換。關(guān)鍵代碼如下：

ByteSequence lockKey = ByteSequence.from("/root/lock", StandardCharsets.UTF_8);
        Lock lock = client.getLockClient();
        Lease lease = client.getLeaseClient();
        long leaseId = lease.grant(lockTTl).get().getID();
        lease.keepAlive(leaseId, new StreamObserver<LeaseKeepAliveResponse>() {
            @Override
            public void onNext(LeaseKeepAliveResponse value) {
                System.err.println("LeaseKeepAliveResponse value:" + value.getTTL());
            }
            @Override
            public void onError(Throwable t) { t.printStackTrace(); }
            @Override
            public void onCompleted() { }
        });
        lock.lock(lockKey, leaseId).get().getKey();

首先申請授予續(xù)約獲取到leaseId，其中l(wèi)ockttl為1，單位秒，etcd的租約是秒級的。在這里ttl的設置是有講究的，取決于當主服務故障時，你想多快讓從服務感知并頂上。當然，受限于etcd本身租約秒級限制，最快也只能是1秒。
然后調(diào)用keepAlive方法，使授予到的leaseid?；?，這樣，只要應用還存活就會自動續(xù)約
接著調(diào)用lock方法，傳入leaseid。只有首次啟動的服務會獲取到鎖，而且在運行期間，會不斷的續(xù)約。當從服務運行到此處時，會阻塞住。這樣就能保證多個服務同時運行，只有一個服務真正工作的目的。當獲取到鎖的主服務出現(xiàn)問題時，原先的只有鎖的續(xù)約在1秒內(nèi)就會到期，從服務會馬上獲取到鎖執(zhí)行工作代碼

完整的測試用例

/**
 * @author: kl @kailing.pub
 * @date: 2019/7/22
 */
public class JEtcdTest {
    private Client client;
    private Lock lock;
    private Lease lease;
    //單位：秒
    private long lockTTl = 1;
    private ByteSequence lockKey = ByteSequence.from("/root/lock", StandardCharsets.UTF_8);
    private ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(2);
    @Before
    public void setUp() {
         client = Client.builder().endpoints(
                "http://127.0.0.1:2379",
                "http://127.0.0.1:3379",
                "http://127.0.0.1:4379"
        ).build();
         lock = client.getLockClient();
         lease = client.getLeaseClient();
    }
    @Test
    public void lockTest1toMaster() throws InterruptedException, ExecutionException {
        long leaseId = lease.grant(lockTTl).get().getID();
         lease.keepAlive(leaseId, new StreamObserver<LeaseKeepAliveResponse>() {
             @Override
             public void onNext(LeaseKeepAliveResponse value) {
                 System.err.println("LeaseKeepAliveResponse value:"+ value.getTTL());
             }
             @Override
             public void onError(Throwable t) {
                 scheduledThreadPool.shutdownNow();
                 t.printStackTrace();
             }
             @Override
             public void onCompleted() {
                 scheduledThreadPool.shutdownNow();
             }
         });
        lock.lock(lockKey, leaseId).get().getKey();
        scheduledThreadPool.submit(() -> {
            while (true) {
                System.err.println("我是主服務開始工作了");
                TimeUnit.SECONDS.sleep(1);
            }
        });
        TimeUnit.DAYS.sleep(1);
    }
    @Test
    public void lockTest2toStandby() throws InterruptedException, ExecutionException {
        long leaseId = lease.grant(lockTTl).get().getID();
        lease.keepAlive(leaseId, new StreamObserver<LeaseKeepAliveResponse>() {
            @Override
            public void onNext(LeaseKeepAliveResponse value) {
                System.err.println("LeaseKeepAliveResponse value:"+ value.getTTL());
            }
            @Override
            public void onError(Throwable t) {
                scheduledThreadPool.shutdownNow();
                t.printStackTrace();
            }
            @Override
            public void onCompleted() {
                 scheduledThreadPool.shutdownNow();
            }
        });
        lock.lock(lockKey, leaseId).get().getKey();
        scheduledThreadPool.submit(() -> {
            while (true) {
                System.err.println("我是備用服務，我開始工作了，估計主服務已經(jīng)掛了");
                TimeUnit.SECONDS.sleep(1);
            }
        });
        TimeUnit.DAYS.sleep(1);
    }
    @Test
    public void lockTest3toStandby() throws InterruptedException, ExecutionException {
        long leaseId = lease.grant(lockTTl).get().getID();
        lease.keepAlive(leaseId, new StreamObserver<LeaseKeepAliveResponse>() {
            @Override
            public void onNext(LeaseKeepAliveResponse value) {
                System.err.println("LeaseKeepAliveResponse value:"+ value.getTTL());
            }
            @Override
            public void onError(Throwable t) {
                scheduledThreadPool.shutdownNow();
                t.printStackTrace();
            }
            @Override
            public void onCompleted() {
                scheduledThreadPool.shutdownNow();
            }
        });
        lock.lock(lockKey, leaseId).get().getKey();
        scheduledThreadPool.submit(() -> {
            while (true) {
                System.err.println("我是備用服務，我開始工作了，估計主服務已經(jīng)掛了");
                TimeUnit.SECONDS.sleep(1);
            }
        });
        TimeUnit.DAYS.sleep(1);
    }
}

上面測試用例模擬了一主兩備的高可用架構(gòu)。分別執(zhí)行l(wèi)ockTest1toMaster()、lockTest2toStandby()、lockTest3toStandby()服務，會發(fā)現(xiàn)只有一個服務會打印。然后手動關(guān)閉這個服務，從服務馬上會接著打印。在關(guān)閉這個從服務，另外一個從服務就會接著打印。很好的模擬了主備故障切換的效果。

以上就是高可用架構(gòu)etcd選主故障主備秒級切換實現(xiàn)的詳細內(nèi)容，更多關(guān)于etcd主備故障秒級切換的資料請關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章: