マイクロサービス理論 (CAP、整合性プロトコル)

CAP理論

CAP 理論の概要については、この記事を直接読むことができます。

CAPとは何ですか?

整合性 (
整合性には、強整合性、弱い整合性、結果整合性が含まれます。
整合性とは実際にはデータの整合性を指します。データが不整合なのはなぜですか?

上の図に示すように、私たちのサービスはクラスター内の外部で提供されており、クライアントは今回どのノードをリクエストしたかを気にしません。最初のリクエストはデータを更新するためにノード A に送信されましたが、2 番目のリクエストはノード B に転送されたとします。このとき、サービス A とサービス B のデータが同期されていないと、この時点でデータの不整合が生じますが、実際には、サービス A のデータが同期されている場合、サービス A のデータをすぐにサービス B に転送して同期することは困難です。サービス A は、特にリクエストが特殊な場合には頻繁に変更されます。したがって、実際のシナリオに基づいて強整合性を確保する必要があるかどうかを判断する必要があります。たとえば、お金と在庫が関係するサービス クラスターでは、強力な一貫性を確保する必要があります。もう 1 つの例は、「いいね！」、ビュー、または訪問の数です。これらはリアルタイムで一貫している必要はなく、最終的に一貫している必要があるだけです。

可用性（可用性）と
は、実際には、データが正しいかどうかに関係なく、ユーザーが要求した限り、データがユーザーに返されることを意味します。
一貫性について話すとき、強い一貫性を確保したい場合、この時点でリクエストが B に到達すると、クライアントは外部サービスを提供できなくなります。サービスが提供されると、データは古いデータのままになり、その結果、データの不整合。しかし、サービスが提供されていない場合、このサービス ノードは使用できなくなるのではないでしょうか? つまり、可用性は保証されません。したがって、一貫性と可用性の間で一定の妥協が必要であることもわかります。

パーティション許容度

1 パーティション
パーティションとは? 分散システムは複数のサブネットワークに分散されます。分散システム内のサービス ノードは、ネットワーク上の理由やその他の要因により、相互に通信できない場合があります。この状況はパーティショニングと呼ばれます。

2 ゾーニング耐性とは何ですか?
通常、分割は避けられないため、2 つのサービス ノードが例外なく相互に完全に通信できることを完全に保証することはできません。

总结下来就是在一个分布式系统中，这个P分区是一定存在的。我们需要根据业务场景来做C和A的一些取舍。

共通コンポーネント保証パターン

• ナコスはAP+CPを保証
• 動物園の飼育員がCPを保証
• エウレカはAPを保証

ディストリビューション整合性プロトコル (一時ノード プロトコル)

ディストリビューションプロトコルはアリババの「自作プロトコル」であるため、原文にリンクされている
情報は比較的少ないですが、ソースコードを通してディストリビューションプロトコルの要点をまとめてみましょう:ディストリビューションプロトコルは登録用に作成されたプロトコルですセンター;
2 つの側面があります: クライアントとサーバー。重要な対話、サービス登録とハートビート送信。
クライアントはサービスをディメンションとしてサーバーに登録し、登録後時々サーバーにハートビートを送信します。ハートビート パッケージには、クライアントで表示できる、登録されたサービスのすべての情報が含まれる必要があります。サーバー ノードは等しいため、要求されたノードはランダムです。クライアントの要求が失敗した場合、別のノードが要求
を再送信します。
サーバーノードはすべてのデータを保存しますが、各ノードはサービスの一部のみを担当します クライアントの受信後 クライアントの「書き込み」（登録、ハートビート、オフラインなど）リクエストの後、サーバーノードは、リクエストされたサービスがそのサービスであるかどうかを判断します。そうであれば処理し、そうでない場合は処理のために責任ノードに引き渡されます;各サーバーノードは積極的に健康情報を送信します 他のノードが検出され、応答したノードはその
ノードによって正常なノードとみなされます;
サーバーはクライアントのサービス ハートビートを受信します。サービスが存在しない場合は、ハートビート リクエストを登録リクエストとして処理します。
サーバーが存在しない場合は、クライアント ハートビートを受信した後、サービスはオフラインになります。
担当ノードはデータを書き込み、サービス登録やサービス ハートビートなどの書き込みリクエストを受信した後に戻り、バックグラウンドで他のノードにデータを非同期に同期します。ノードは
リクエスト後、データがローカル マシンかどうかに関係なく、ローカル マシンから直接取得されて返されます。最新。
新しいノード同期メカニズム:
DistroProtocol#startDistroTask

private void startDistroTask() {
    
    
    if (EnvUtil.getStandaloneMode()) {
    
    
        isInitialized = true;
        return;
    }
    // 健康检查
    startVerifyTask();
    // 开始加载
    startLoadTask();
}

等価メカニズム:
Nacos の各ノードは同等であり、書き込みリクエストを処理できます。
非同期レプリケーション メカニズム:
DistroProtocol#sync

public void sync(DistroKey distroKey, DataOperation action) {
    
    
     sync(distroKey, action, DistroConfig.getInstance().getSyncDelayMillis());
 }

ヘルスチェックメカニズム:
DistroProtocol#startDistroTask

private void startVerifyTask() {
    
    
    GlobalExecutor.schedulePartitionDataTimedSync(new DistroVerifyTimedTask(memberManager, distroComponentHolder,
                    distroTaskEngineHolder.getExecuteWorkersManager()),
            DistroConfig.getInstance().getVerifyIntervalMillis());
}

ローカル読み取りメカニズム (各ノードには全量のデータがあります):
ただし、書き込み処理にはデータの一部のみが含まれます。つまり、データ分割および分割統治メカニズムが存在します。
インスタンスコントローラー#リスト

/**
  * Get all instance of input service.
  *
  * @param request http request
  * @return list of instance
  * @throws Exception any error during list
  */
 @GetMapping("/list")
 @Secured(action = ActionTypes.READ)
 public Object list(HttpServletRequest request) throws Exception {
    
    }

ルーティング転送メカニズム:
DistroFilter#doFilter

if (distroMapper.responsible(distroTag)) {
    
    
     filterChain.doFilter(req, resp);
     return;
 }

Raft コンセンサス プロトコル (永続ノード プロトコル)

このプロトコルは主に、選挙の開始と選挙後のデータの同期方法に関するものです。ノードが起動すると投票が開始され、クラスター内のデータの過半数がノードを承認すると、そのノードはリーダーになり、リーダーになった後、他のノードとの接続を確立します。
V1 バージョンの選択と同期

try {
    
    
     if (stopWork) {
    
    
         return;
     }
     if (!peers.isReady()) {
    
    
         return;
     }
     
     RaftPeer local = peers.local();
     local.leaderDueMs -= GlobalExecutor.TICK_PERIOD_MS;
     
     if (local.leaderDueMs > 0) {
    
    
         return;
     }
     // 来到这里以后已经和Master失联了
     // reset timeout
     local.resetLeaderDue();
     local.resetHeartbeatDue();
     // 发起投票，里面会向其它节点发起异步请求
     sendVote();
 } catch (Exception e) {
    
    
     Loggers.RAFT.warn("[RAFT] error while master election {}", e);
 }
// 过半
if (maxApproveCount >= majorityCount()) {
    
    
    RaftPeer peer = peers.get(maxApprovePeer);
    peer.state = RaftPeer.State.LEADER;
    if (!Objects.equals(leader, peer)) {
    
    
        leader = peer;
        ApplicationUtils.publishEvent(new LeaderElectFinishedEvent(this, leader, local()));
        Loggers.RAFT.info("{} has become the LEADER", leader.ip);
    }
}

// 处理心跳
try {
    
    
     if (stopWork) {
    
    
         return;
     }
     if (!peers.isReady()) {
    
    
         return;
     }
     RaftPeer local = peers.local();
     local.heartbeatDueMs -= GlobalExecutor.TICK_PERIOD_MS;
     if (local.heartbeatDueMs > 0) {
    
    
         return;
     }
     local.resetHeartbeatDue();
     sendBeat();
 } catch (Exception e) {
    
    
     Loggers.RAFT.warn("[RAFT] error while sending beat {}", e);
 }

V2 バージョンのオプションは、同じコードに関連する
ソースコード
com.alibaba.nacos.naming.consistency.DelegateConsistencyServiceImpl
com.alibaba.nacos.naming.consistency.persistent.PersistentConsistencyServiceDelegateImpl#PersistentConsistencyServiceDelegateImpl
com.alibaba.nacos.naming.consistency. persistent.impl.PersistentServiceProcessor# afterConstruct
com.alibaba.nacos.core.distributed.raft.JRaftProtocol#addRequestProcessors
com.alibaba.nacos.core.distributed.raft.JRaftServer#createMultiRaftGroup
com.alipay.sofa.jraft.RaftGroupService#start(boolean)
com.alipay.sofa .jraft.RaftServiceFactory#createAndInitRaftNode
com.alipay.sofa.jraft.core.NodeImpl#init
com.alipay.sofa.jraft.core.NodeImpl#electSelf
com.alipay.sofa.jraft.core.NodeImpl#becomeLeader
同步
com.alipay。ソファ.jraft.ReplicatorGroup#addReplicator(com.alipay.sofa.jraft.entity.PeerId)
部分ソースコード：

private BasePersistentServiceProcessor createNewPersistentServiceProcessor(ProtocolManager protocolManager,
           ClusterVersionJudgement versionJudgement) throws Exception {
    
    
       final BasePersistentServiceProcessor processor =
               EnvUtil.getStandaloneMode() ? new StandalonePersistentServiceProcessor(versionJudgement)
                       : new PersistentServiceProcessor(protocolManager, versionJudgement);
       processor.afterConstruct();
       return processor;
   }

PersistentServiceProcessor#afterConstruct

@Override
public void afterConstruct() {
    
    
   super.afterConstruct();
   String raftGroup = Constants.NAMING_PERSISTENT_SERVICE_GROUP;
   this.protocol.protocolMetaData().subscribe(raftGroup, MetadataKey.LEADER_META_DATA, o -> {
    
    
       if (!(o instanceof ProtocolMetaData.ValueItem)) {
    
    
           return;
       }
       Object leader = ((ProtocolMetaData.ValueItem) o).getData();
       hasLeader = StringUtils.isNotBlank(String.valueOf(leader));
       Loggers.RAFT.info("Raft group {} has leader {}", raftGroup, leader);
   });
   this.protocol.addRequestProcessors(Collections.singletonList(this));
   // If you choose to use the new RAFT protocol directly, there will be no compatible logical execution
   if (EnvUtil.getProperty(Constants.NACOS_NAMING_USE_NEW_RAFT_FIRST, Boolean.class, false)) {
    
    
       NotifyCenter.registerSubscriber(notifier);
       waitLeader();
       startNotify = true;
   }
}

JRaft

public void init(RaftConfig config) {
    
    
    if (initialized.compareAndSet(false, true)) {
    
    
        this.raftConfig = config;
        NotifyCenter.registerToSharePublisher(RaftEvent.class);
        this.raftServer.init(this.raftConfig);
        this.raftServer.start();
        
        // There is only one consumer to ensure that the internal consumption
        // is sequential and there is no concurrent competition
        NotifyCenter.registerSubscriber(new Subscriber<RaftEvent>() {
    
    
            @Override
            public void onEvent(RaftEvent event) {
    
    
                Loggers.RAFT.info("This Raft event changes : {}", event);
                final String groupId = event.getGroupId();
                Map<String, Map<String, Object>> value = new HashMap<>();
                Map<String, Object> properties = new HashMap<>();
                final String leader = event.getLeader();
                final Long term = event.getTerm();
                final List<String> raftClusterInfo = event.getRaftClusterInfo();
                final String errMsg = event.getErrMsg();
                
                // Leader information needs to be selectively updated. If it is valid data,
                // the information in the protocol metadata is updated.
                MapUtil.putIfValNoEmpty(properties, MetadataKey.LEADER_META_DATA, leader);
                MapUtil.putIfValNoNull(properties, MetadataKey.TERM_META_DATA, term);
                MapUtil.putIfValNoEmpty(properties, MetadataKey.RAFT_GROUP_MEMBER, raftClusterInfo);
                MapUtil.putIfValNoEmpty(properties, MetadataKey.ERR_MSG, errMsg);
                
                value.put(groupId, properties);
                metaData.load(value);
                
                // The metadata information is injected into the metadata information of the node
                injectProtocolMetaData(metaData);
            }
            
            @Override
            public Class<? extends Event> subscribeType() {
    
    
                return RaftEvent.class;
            }
            
        });
    }
}