redisクラスタ実装(一)クラスタアーキテクチャと初期化

9599 ワード

redis クラスタ保存

redisは、高可用性、高性能、高拡張性のメモリベースで永続化ストレージもサポートされるkvストレージデータベースであり、redisは、従来のkvストレージmemcachedに比べてサポートされていたvalueタイプが大幅に増加するだけでなく、memcachedの永続化が不可能な欠点を補うデータの永続化もサポートするが、3.0以前のredisはクラスタ機能をサポートしていなかった.これもredisが3.0以前に大量に配備できなかった理由の一つですが、3.0以降のredisはクラスタ機能をサポートしているため、redisは以前のmemcachedに大量に代替し始め、今日はソースコード階層からredisがどのようにクラスタ機能を実現しているかを学びました.
私が見たソースコードはredis-3.0ソースコードで、下のリンクでダウンロードできます.
http://download.redis.io/releases/redis-3.0.0-rc1.tar.gz
redisのクラスタはHDFSのようなnamenodeやdatanodeのようなアーキテクチャではなく、改善されたコンシステンシハッシュアルゴリズムを用いてデータをスライスし、各masterノードに平均的に割り当て、各masterノードには対応するslaveノードがmasterノードのデータをコピーし、masterがダウンタイムしたときにmasterノードになるように選択する.概略的なアーキテクチャは、次の図に示されています.
コンシステンシハッシュアルゴリズムを用いて、各データが0〜16384の区間の上にマッピングされることを保証し、その後、この区間の一部が1つのmasterにサービスを提供する(もちろん、このように簡単には区別されない).クライアントがアクセスするたびに対応するマスターにアクセスし、クライアントがどのようにデータがどのマスター上にあるかを知りたい人がいるかもしれませんが、クライアントも知らないので、クライアントがmasterにアクセスし、masterがこのmasterノード上にデータがないことを発見すると、masterはクライアントがクライアントが望んでいるデータを格納するマスターアドレスをクライアントに伝えます.クライアントは正しいマスターにアクセスします.
では、redisクラスタはどのように構築されているのでしょうか.何十台もの機械が同時に電源を入れて自動的に接続されているのではないでしょうか.もちろんそうではありません.1台のマシンしかないクラスタと考えられ、clientはmasterにログインしてcluster meetを実行してipアドレスを指定したマシンをクラスタに追加します.これで、このクラスタには2台の機械があります.このように,1台1台の追加により,大規模なredisクラスタが実現される.
まずクラスタに関連するデータ構造を見てみましょう.これらはクラスタ実装の基礎です.

//        
struct clusterNode {

    //        
    mstime_t ctime; 

    //   ID，       ，   40，         16    
    char name[REDIS_CLUSTER_NAMELEN];

    //        ，               。
    int flags;  

    //          
    uint64_t configEpoch; 

    //   node        ，REDIS_CLUSTER_SLOTS  redis        ，      16384，    1                 ，   0        。
    unsigned char slots[REDIS_CLUSTER_SLOTS/8]; 

    //   node         
    int numslots;  

    //          ，            
    int numslaves; 

    //     ，       
    struct clusterNode **slaves;

    //          ，       
    struct clusterNode *slaveof;                                                                                            

    //        PING      
    mstime_t ping_sent;      

    //        PONG       
    mstime_t pong_received; 

    //          FAIL     
    mstime_t fail_time;     

    //                
    mstime_t voted_time;    

    //                     
    mstime_t repl_offset_time; 

    //           
    long long repl_offset;     

    //     IP  
    char ip[REDIS_IP_STR_LEN];  

    //       
    int port;               

    //          
    clusterLink *link; 

    //     ，                  
    list *fail_reports; 
};

次にクラスタ間の接続を記録する構造体

// clusterLink                    
typedef struct clusterLink {                                                                                                                                  

    //        
    mstime_t ctime;        

    // TCP       
    int fd;          

    //      ，               （message）。
    sds sndbuf;     

    //      ，              。
    sds rcvbuf;     

    //            ，         NULL
    struct clusterNode *node;

} clusterLink;

次に、クラスタ状態を記録する構造体であり、各ノードには、現在のクラスタの状態を表す構造体がある.

typedef struct clusterState {
                                                                                                                                                              
    //          
    clusterNode *myself;

    //          ，        
    uint64_t currentEpoch;

    //        ：       
    int state;

    //                  。
    int size;   

    //       （   myself  ）
    //           ，      clusterNode  
    dict *nodes;   

    //      ，   CLUSTER FORGET  
    //     FORGET             
    // （              ，   ？      ？）
    dict *nodes_black_list;

    //                  ，         
    // migrating_slots_to[i] = NULL     i    
    // migrating_slots_to[i] = clusterNode_A     i           A
    clusterNode *migrating_slots_to[REDIS_CLUSTER_SLOTS];

    //                ，          
    // importing_slots_from[i] = NULL     i     
    // importing_slots_from[i] = clusterNode_A        A     i
    clusterNode *importing_slots_from[REDIS_CLUSTER_SLOTS];

    //           
    //    slots[i] = clusterNode_A    i     A  
    clusterNode *slots[REDIS_CLUSTER_SLOTS];

    //    ，        ，     ，        
    //            （range）   ，           
    //         db.c  
    zskiplist *slots_to_keys;

    //                 

    //                  
    mstime_t failover_auth_time;

    //          
    int failover_auth_count; 

    //      1，                   
    int failover_auth_sent; 

    int failover_auth_rank;

    uint64_t failover_auth_epoch; 

    /*             */

    //              
    mstime_t mf_end;           

    /*               */
    clusterNode *mf_slave;     

    /*               */
    long long mf_master_offset;    //                   
    //     0               
    int mf_can_start;          

    /* The followign fields are uesd by masters to take state on elections. */
    /*             ，           */

    //              
    uint64_t lastVoteEpoch;   

    //                 ，    flag   
    int todo_before_sleep;

    //    cluster         
    long long stats_bus_messages_sent; 

    //    cluster        
    long long stats_bus_messages_received; 
} clusterState;

基本的な構造体の紹介は終わりましたが,クラスタのコード実装を見てみましょう.
まずredis単一ノードの初期化コードを見ます.これはクラスタの最初のステップであり、まず単一ノードサービスを開始します.
redisソースでrediscファイルのmain関数はredis-serverの始まりです.クラスタの実装コードだけに関心を持っているので、クラスタとはあまり関係のない私は無視しました.
int main(int argc, char **argv) {
………………..
//ユーザーがパラメータを指定したことを説明します.ユーザーがプロファイルを指定したかどうかを確認する必要があります.
if (argc >= 2) {
……………………
//プロファイルの読み込み
loadServerConfig(configfile,options);
}
次にloadServerConfig関数にジャンプして文字列構成の解析を行います.loadServerConfig関数には以下のコードがあり、構成項目にcluster-enabledがある場合はserverを設定します.cluster_Enabledは1であり,クラスタ機能のオンを示す.
else if (!strcasecmp(argv[0],"cluster-enabled") && argc ==2) {
   if ((server.cluster_enabled = yesnotoi(argv[1])) == -1) {
   err = "argument must be 'yes' or 'no'";goto loaderr;
   }
次にmain関数の中で、プレイプロファイルを読み込み、initServer()関数を実行し、initServer関数の中で、
//サーバがclusterモードで開いている場合はclusterを初期化
if (server.cluster_enabled) clusterInit();
次にclusterInit関数に入り、単一クラスタ設定の初期化コードを見てみましょう.

//      
void clusterInit(void) {
    int saveconf = 0; 

    //      ，server.cluster  clusterState   ，         。
    server.cluster = zmalloc(sizeof(clusterState));
    //         
    server.cluster->myself = NULL;
    //       0
    server.cluster->currentEpoch = 0; 
    //      fail
    server.cluster->state = REDIS_CLUSTER_FAIL;
    //     1
    server.cluster->size = 1; 
    server.cluster->todo_before_sleep = 0; 
    //            
    server.cluster->nodes = dictCreate(&clusterNodesDictType,NULL);
    //      。。
    server.cluster->nodes_black_list =
        dictCreate(&clusterNodesBlackListDictType,NULL);
    //            
    server.cluster->failover_auth_time = 0; 
    server.cluster->failover_auth_count = 0; 
    server.cluster->failover_auth_rank = 0; 
    server.cluster->failover_auth_epoch = 0; 
    server.cluster->lastVoteEpoch = 0; 
    server.cluster->stats_bus_messages_sent = 0; 
    server.cluster->stats_bus_messages_received = 0; 
    //    
    memset(server.cluster->slots,0, sizeof(server.cluster->slots));
    //      
    clusterCloseAllSlots();

    /*         ，                    */
    if (clusterLockConfig(server.cluster_configfile) == REDIS_ERR)
        exit(1);

    /*             . */
    if (clusterLoadConfig(server.cluster_configfile) == REDIS_ERR) {
        /*             ，          . */
        myself = server.cluster->myself =
            createClusterNode(NULL,REDIS_NODE_MYSELF|REDIS_NODE_MASTER);
        redisLog(REDIS_NOTICE,"No cluster configuration found, I'm %.40s",
            myself->name);
        clusterAddNode(myself);
        saveconf = 1;
    }

    //    nodes.conf  
    if (saveconf) clusterSaveConfigOrDie(1);

    //    TCP  
    server.cfd_count = 0;

    if (server.port > (65535-REDIS_CLUSTER_PORT_INCR)) {
        redisLog(REDIS_WARNING, "Redis port number too high. "
                   "Cluster communication port is 10,000 port "
                   "numbers higher than your Redis port. "
                   "Your Redis port number must be "
                   "lower than 55535.");
        exit(1);
    }
    //         
    if (listenToPort(server.port+REDIS_CLUSTER_PORT_INCR,
        server.cfd,&server.cfd_count) == REDIS_ERR)
    {
        exit(1);
    } else {
        int j;

        for (j = 0; j < server.cfd_count; j++) {
            //          
            if (aeCreateFileEvent(server.el, server.cfd[j], AE_READABLE,
                clusterAcceptHandler,NULL) == AE_ERR)                                                                                                        
                    redisPanic("Unrecoverable error creating Redis Cluster "
                                "file event.");
        }
    }

    // slots -> keys          ，         ，     ，    key 
    server.cluster->slots_to_keys = zslCreate();
    resetManualFailover();
}

さて、これでクラスタ関連の初期化は終わりますが、後で削除ノードの追加やフェイルオーバに関する記事を書きますので、質問を歓迎します.

Redis限流の実現方式は3種類ある

1.Redis ubuntuでのインストールと起動