基于QJM/Qurom Journal Manager/Paxos的HDFS HA原理及代码分析

namenode启动异常问题解决 HA集群配置完成并启动后,namenode不能正常启动。刚启动的时候 jps看到了namenode,但是隔了一两分钟,再看namenode就不见了。如果不启动journalnode,namenode运行正常,一旦启动journalnode,则namenode过一会就会挂掉。查看namenode日志,发现报错如下: 2019-10-18 15:32:36,835 INFO org.apache.... 阅读详情

HDFS HA的解决方案可谓百花齐放,Linux HA, VMware FT, shared NAS+NFS, BookKeeper, QJM/Quorum Journal Manager, BackupNode等等。目前普遍采用的是shard NAS+NFS,因为简单易用,但是需要提供一个HA的共享存储设备。而社区已经把基于QJM/Quorum Journal Manager的方案merge到trunk了,clouderea提供的发行版中也包含了这个feature,这种方案也是社区在未来发行版中默认的HA方案。本文从代码的角度分析这种方案的实现。

关于HDFS源代码中HA机制的整体框架实现,Active NN, Standby NN两种角色各自的代码执行流程,client如何做failover,为什么要fencing,每个DN要向Active和Standby NN都要report block,这样才能保证hot standby等等类似的问题,可以参考前面的文章: http://yanbohappy.sinaapp.com/?p=50  和 http://yanbohappy.sinaapp.com/?p=55 。

在HA具体实现方法不同的情况下,HA框架的流程是一致的。不一致的就是如何存储和管理日志。在Active NN和Standby NN之间要有个共享的存储日志的地方,Active NN把EditLog写到这个共享的存储日志的地方,Standby NN去读取日志然后执行,这样Active和Standby NN内存中的HDFS元数据保持着同步。一旦发生主从切换Standby NN可以尽快接管Active NN的工作(虽然要经历一小段时间让原来Standby追上原来的Active,但是时间很短)。

说到这个共享的存储日志的地方,目前采用最多的就是用共享存储NAS+NFS。缺点有:1)这个存储设备要求是HA的,不能挂掉;2)主从切换时需要fencing方法让原来的Active不再写EditLog,否则的话会发生brain-split,因为如果不阻止原来的Active停止向共享存储写EditLog,那么就有两个Active NN了,这样就会破坏HDFS的元数据了。对于防止brain-split问题,在QJM出现之前,常见的方法就是在发生主从切换的时候,把共享存储上存放EditLog的文件夹对原来的Active的写权限拿掉,那么就可以保证同时至多只有一个Active NN,防止了破坏HDFS元数据。

Clouera为解决这个问题提出了QJM/Qurom Journal Manager,这是一个基于Paxos算法实现的HDFS HA方案。QJM的结构图如下所示:

QJM的基本原理就是用2N+1台JournalNode存储EditLog,每次写数据操作有大多数(>=N+1)返回成功时即认为该次写成功,数据不会丢失了。当然这个算法所能容忍的是最多有N台机器挂掉,如果多于N台挂掉,这个算法就失效了。这个原理是基于Paxos算法的,可以参考http://en.wikipedia.org/wiki/Paxos_(computer_science) 。

用QJM的方式来实现HA的主要好处有:1)不需要配置额外的高共享存储,这样对于基于commodity hardware的云计算数据中心来说,降低了复杂度和维护成本;2)不在需要单独配置fencing实现,因为QJM本身内置了fencing的功能;3)不存在Single Point Of Failure;4)系统鲁棒性的程度是可配置的(QJM基于Paxos算法,所以如果配置2N+1台JournalNode组成的集群,能容忍最多N台机器挂掉);5)QJM中存储日志的JournalNode不会因为其中一台的延迟而影响整体的延迟,而且也不会因为JournalNode的数量增多而影响性能(因为NN向JournalNode发送日志是并行的)。

1, NameNode格式化和启动

关于HDFS NN的元数据管理逻辑,FSImage和EditLog相关的源代码分析请参考: http://yanbohappy.sinaapp.com/?p=84 和http://yanbohappy.sinaapp.com/?p=101 ,NN的这部分代码在不同的HA解决方案中是一样的。先格式化HDFS,生成存放FSImage和EditLog的目录,目录初始化,把文件系统元数据持久化到文件。然后在启动的时候加载最新的FSImage和在那之后的EditLog。

NN存放FSImage和EditLog的目录用NNStorage这个类来管理。看FSImage的构造函数,传进去两个URI的集合,分别是存放FSImage和EditLog的地方。我们一直在说的NN HA解决的是EditLog的共享存储问题,不包括FSImage,除非我们配置把这两个东西存储到一个地方,但是一般是不会这么做的。

protectedFSImage(Configuration conf,
                    Collection<URI> imageDirs,
                    List<URI> editsDirs)
      throwsIOException {
    this.conf = conf;
    //注意此时的storage对象中storageDirs变量只存放File目录,不存放bookkeeper,qjournal目录。
    //bookkeeper,qjournal目录是后面通过调用fsImage.getEditLog().initJournalsForWrite()来初始化bookeeper或者qjournal目录的。
    storage =new NNStorage(conf, imageDirs, editsDirs);
    if(conf.getBoolean(DFSConfigKeys.DFS_NAMENODE_NAME_DIR_RESTORE_KEY,
                       DFSConfigKeys.DFS_NAMENODE_NAME_DIR_RESTORE_DEFAULT)) {
      storage.setRestoreFailedStorage(true);
    }
 
    this.editLog =new FSEditLog(conf, storage, editsDirs);
 
    archivalManager =new NNStorageRetentionManager(conf, storage, editLog);
  }

就像前面说的,EditLog的管理相对FSImage要复杂很多。所以接下来就是fsImage.getEditLog().initJournalsForWrite()来初始化存放日志的地方。这个在FSEditLog.initJournals()中完成,对于基于File的共享存储(NFS)来说,就是创建了一个用于管理这个设备和其中EditLog文件的FileJournaManger,然后加入EditLog.journalSet集合统一管理;而对于其他类型的共享存储(BookKeeper,QJM,BackupNode)则是创建对应的JournalManager对象。对于我们的QJM来说,就是创建了一个QuorumJournalManager对象。

2,构造QuroumJournalManager

QuromJournalManager的构造函数初始化了一些变量,比如这个QJM的uri,nsinfo等。注意我们使用URI来区分不同的JournalNode集群,JournalNode集群的URI表示类似于Zookeeper,这里有个例子,我们在hdfs-site.xml中会通过以下的形式配置使用QJM:

<property>
  <name>dfs.namenode.shared.edits.dir</name>
  <value>qjournal://node1.example.com:8485;node2.example.com:8485;node3.example.com:8485/mycluster</value>
</property>

然后构造一个AsyncLoggerSet对象用于管理该QuromJournalManager向多个JournalNode的连接。这个AsyncLoggerSet对象里面有个存放AsyncLogger接口(真正的实现类是IPCLoggerChannel,每个IPCLoggerChannel管理QJM与一个JournalNode的连接和异步通信)的List。

this.loggers = new AsyncLoggerSet(createLoggers(loggerFactory));

进一步调用

static List<AsyncLogger> createLoggers (Configuration conf,

      URI uri, NamespaceInfo nsInfo, AsyncLogger.Factory factory)

创建一系列的AsyncLogger用于写Log

static List<AsyncLogger> createLoggers(Configuration conf,
      URI uri, NamespaceInfo nsInfo, AsyncLogger.Factory factory)
          throwsIOException {
    List <AsyncLogger> ret = Lists.newArrayList();
    //从uri中解析出对应的2N+1台JournalNode节点的ip+port
    List <InetSocketAddress> addrs = getLoggerAddresses(uri);
    //从uri中解析出JournalId,我们的例子中解析出来的应该是mycluster
    String jid = parseJournalId(uri);
    for(InetSocketAddress addr : addrs) {
      //返回为每一个JN创建的IPCLoggerChannel类对象,IPCLoggerChannel继承自AsyncLogger
      ret.add(factory.createLogger(conf, nsInfo, jid, addr));
    }
    returnret;
  }

3,格式化qjournal

New出这个FSImage对象之后就该初始化了,FSImage.format()->editLog.formatNonFileJournals (ns) 负责format非File的EditLog存放URI。进一步会调用

QuorumJournalManager.format(NamespaceInfo nsInfo)会格式化qjournal。

public void format(NamespaceInfo nsInfo) throwsIOException {
    // AsyncLoggerSet这个wrapper类会依次调用其内部的AsyncLogger.format(),发送format RPC,然后注册callback函数。
    QuorumCall<AsyncLogger,Void> call = loggers.format(nsInfo);
    try{
       //在这个函数里循环等待有足够的success response或者exception或者time out。对于format请求,要求所有JN(不是大多数)返回成功才行。
      call.waitFor( loggers.size(), loggers.size(),0, FORMAT_TIMEOUT_MS,
          "format");
    }catch (InterruptedException e) {
      thrownew IOException( "Interrupted waiting for format() response");
    }catch (TimeoutException e) {
      thrownew IOException( "Timed out waiting for format() response");
    }
 
    if(call.countExceptions() > 0) {
      call.rethrowException("Could not format one or more JournalNodes");
    }
  }

这里就涉及到QJM的核心原理Paxos算法了。关于这个算法的原理大家可参考wikipedia,简单说就是Active NN把日志写到2N+1个JournalNode上,每次写日志的操作只要其中a quorum of JNs(即大多数,大于等于N+1台JN)返回成功即认为这次操作是成功的。但是这个format操作是比较特殊的,要求所有的JN返回都是成功的才行,因为它相当于是做了个初始化的工作。在后面的写数据的过程中,只要大多数success response就认为这次写成功了。

QuorumCall这个类包装了整个异步调用的过程:每次QuorumJournalManager对象向2N+1台JN发送写日志请求都是异步的,发出之后不是同步等待每个JN的返回值,而是注册一个callback函数,每当有一个返回,就把response计数加1(如果返回是success,把success计数加1;如果返回是failure,把failure计数加1)。这样QuorumJournalManager这端只需要发出去请求,然后循环检测时候有足够的success response或者足够的exception或者是time out。

上面在代码中提到了RPC,QJM的RPC主要就一个协议类:QuorumJournalManager与多个JournalNode通信的协议QJournalProtocol。那么RPC的通信双方的实体类分别是哪个呢?客户端(QuorumJournalManager)是QJournalProtocolTranslatorPB;服务器端(JournalNode)是JournalNodeRpcServer。

看看这个format命令到了JN端做了哪些事情?

先是根据journalId创建了Journal对象,然后调用Journal.format()。接下来就是创建本地存储目录,创建Journal元数据,写元数据到目录等。由于JournalNode管理本地的数据采用的是FileJournalManager对象,所以后面的逻辑跟使用FileJournalManager的NN很像了。

4,NN发生主从切换

接下来就该看看一个Standby NN由Standby变成Active时,需要执行哪些操作:

1) fencing原来Active NN的写。

2) recover in-progress logs。原来Active NN写EditLog过程中发生了主从切换,那么处在不同JournalNode上的EditLog的数据可能不一致,需要把不同JournalNode上的EditLog同步一致,并且finalized。(这个过程类似于HDFS append中的recover lease的过程)

3) startLogSegment。不一致的EditLog都同步一致且finalized,那么原来的Standby NN正式行驶正常的Active NN的写日志功能。

4) write edits

5) finalizeLogSegment

4.1,fencing原来Active NN的写

前面说过,基于QJM的HA不需要处理fencing问题。这是怎么做到的呢?解决这个问题靠的是epoch number,这个和Paxos算法中选主(master election)所做的工作类似。

当Active 和Standby NN 发生主从切换时,原来的Standby NN需要执行:

NameNode.startActiveServices()->FSNamesystem.startActiveServices()->FSEditLog.recoverUnclosedStreams()->JournalSet.recoverUnfinalizedSegments()->QourumJournalManager.recoverUnfinalizedSegment()。这个过程说白了就是给原来的Active NN擦屁股,也可以算作是Standby要接管qjournal写权利的开始。这里面就出现了我们所说的brain-split的问题,Standby NN怎么保证原来的Active NN已经不再往qjournal上写数据了。看看QourumJournalManager.recoverUnfinalizedSegment()是怎么实现的:

public void recoverUnfinalizedSegments() throwsIOException {
    Preconditions.checkState(!isActiveWriter,"already active writer");
 
    LOG.info("Starting recovery process for unclosed journal segments...");
    //这句话解决了brain-split问题,也就是fencing writer
    Map<AsyncLogger, NewEpochResponseProto> resps = createNewUniqueEpoch();
    LOG.info("Successfully started new epoch "+ loggers.getEpoch());
 
    if(LOG.isDebugEnabled()) {
      LOG.debug("newEpoch("+ loggers.getEpoch() + ") responses:\n"+
        QuorumCall.mapToString(resps));
    }
    //找出最后一块edit log segment,因为只有最后一块有可能是不完整的。
    longmostRecentSegmentTxId = Long.MIN_VALUE;
    for(NewEpochResponseProto r : resps.values()) {
      if(r.hasLastSegmentTxId()) {
        mostRecentSegmentTxId = Math.max(mostRecentSegmentTxId,
            r.getLastSegmentTxId());
      }
    }
 
    // On a completely fresh system, none of the journals have any
    // segments, so there's nothing to recover.
    if(mostRecentSegmentTxId != Long.MIN_VALUE) {
      //把不完整的log segment恢复完整,这个过程在后面会具体讲
      recoverUnclosedSegment(mostRecentSegmentTxId);
    }
    isActiveWriter =true;
  }

Epoch解决了我们所说的问题,Standby NN向每个JournalNode发送getJournalState RPC请求,JN返回自己的lastPromisedEpoch。QuorumJournalManager收到大多数JN返回的lastPromisedEpoch,在其中选择最大的一个,然后加1作为当前QJM的epoch,同时通过发送newEpoch RPC把这个新的epoch写到qjournal上。因为在这之后每次QuorumJournalManager在向qjournal执行写相关操作(startLogSegment(),logEdits(),finalizedLogSegment()等)的时候,都要把自己的epoch作为参数传递过去,写相关操作到达每个JournalNode端会比较如果传过来的epoch如果小于JournalNode端存储的lastPromisedEpoch,那么这次写相关操作会被拒绝。如果大多数JournalNode都拒绝了这次写相关操作,这次操作就失败了。回到我们目前的逻辑中,在主从切换时,原来的Standby NN把epoch+1了之后,原来的Active NN的epoch就肯定比这个小了,那么如果它再向qjournal写日志就会被拒绝。因为qjournal不接收比lastPromisedEpoch小的QJM写日志。

看看JN收到newEpoch RPC之后怎么办:JN检查来自QJM的这个epoch和自己存储的lastPromisedEpoch:如果来自writer的epoch小于lastPromisedEpoch,那么说明不允许这个writer向JNs写数据了,抛出异常,writer端收到异常response,那么达不到大多数的success response,就不会有写qjournal的权限了。(其实这个过程就是Paxos算法里面选主的过程)

4.2 recover in-progress logs

接着上面的代码,Standby已经通过createNewUniqueEpoch()来fencing原来的Active,这个RPC请求除了会返回epoch,还会返回最后一个log segment的txid。因为只有最后一个log segment可能需要恢复。这个recover算法就是Paxos算法的一个实例(instance),目的是使得分布在不同JN上的log segment的数据达成一致。

接下来就开始recoverUnclosedSegment()恢复算法

private void recoverUnclosedSegment(longsegmentTxId) throwsIOException {
    Preconditions.checkArgument(segmentTxId >0);
    LOG.info("Beginning recovery of unclosed segment starting at txid "+
        segmentTxId);
 
    // Step 1. Prepare recovery
    //QJM向JNs问segmentTxId对应的segment的长度和finalized/in-progress状况;JNs返回这些信息。(对应Paxos算法的Phase 1a和Phase 1b)
    QuorumCall<AsyncLogger,PrepareRecoveryResponseProto> prepare =
        loggers.prepareRecovery(segmentTxId);
    Map<AsyncLogger, PrepareRecoveryResponseProto> prepareResponses=
        loggers.waitForWriteQuorum(prepare, prepareRecoveryTimeoutMs,
            "prepareRecovery("+ segmentTxId + ")");
    LOG.info("Recovery prepare phase complete. Responses:\n"+
        QuorumCall.mapToString(prepareResponses));
    //在每个JN的返回信息中通过SegmentRecoveryComparator比较,选择其中最好的一个log segment作为后面同步log的标准。
    //如何选择更好的Log segment后面有详细解释。
    Entry<AsyncLogger, PrepareRecoveryResponseProto> bestEntry = Collections.max(
        prepareResponses.entrySet(), SegmentRecoveryComparator.INSTANCE);
    AsyncLogger bestLogger = bestEntry.getKey();
    PrepareRecoveryResponseProto bestResponse = bestEntry.getValue();
 
    // Log the above decision, check invariants.
    if(bestResponse.hasAcceptedInEpoch()) {
      LOG.info("Using already-accepted recovery for segment "+
          "starting at txid "+ segmentTxId + ": "+
          bestEntry);
    }else if(bestResponse.hasSegmentState()) {
      LOG.info("Using longest log: "+ bestEntry);
    }else {
      //prepareRecovery RPC没有返回任何指定txid的segment,原因可能如下:
      //有3个JNs: JN1,JN2,JN3。原来的Active NN 在JN1上开始写segment 101,
      //然后原来Active NN挂了,主从切换,此时segment 101在JN2和JN3上并不存在,
      //newEpoch RPC,因为我们看到了JN1上的segment 101,所以决定recover的是segment 101
      //在prepareRecovery之前,JN1挂了,那么prepareRecovery RPC只能发向JN2和JN3了,RPC返回的结果是没有segment 101
      //这种情况下是不需要recover的,因为segment 101并没有写成功(没有达到大多数)
      for(PrepareRecoveryResponseProto resp : prepareResponses.values()) {
        assert!resp.hasSegmentState() :
          "One of the loggers had a response, but no best logger "+
          "was found.";
      }
 
      LOG.info("None of the responders had a log to recover: "+
          QuorumCall.mapToString(prepareResponses));
      return;
    }
 
    SegmentStateProto logToSync = bestResponse.getSegmentState();
    assertsegmentTxId == logToSync.getStartTxId();
 
    // Sanity check: none of the loggers should be aware of a higher
    // txid than the txid we intend to truncate to
    for(Map.Entry<AsyncLogger, PrepareRecoveryResponseProto> e :
         prepareResponses.entrySet()) {
      AsyncLogger logger = e.getKey();
      PrepareRecoveryResponseProto resp = e.getValue();
 
      if(resp.hasLastCommittedTxId() &&
          resp.getLastCommittedTxId() > logToSync.getEndTxId()) {
        thrownew AssertionError("Decided to synchronize log to "+ logToSync +
            " but logger "+ logger + " had seen txid "+
            resp.getLastCommittedTxId() +" committed");
      }
    }
    //同步log的数据源JN找到后,构造URL用于其他JN读取EditLog(JN端有HTTP server通过servlet形式提供HTTP读)
    URL syncFromUrl = bestLogger.buildURLToFetchLogs(segmentTxId);
    //向JNs发送acceptRecovery RPC请求(对应Paxos算法的Phase 2a)
    //JN收到这个acceptRecovery RPC之后,使自己的log与syncFromUrl同步,并持久化这个logsegment和epoch
    //如果收到大多数的JNs的success response,那么这个同步操作成功。(对应Paxos算法的Phase 2b)
    QuorumCall<AsyncLogger,Void> accept = loggers.acceptRecovery(logToSync, syncFromUrl);
    loggers.waitForWriteQuorum(accept, acceptRecoveryTimeoutMs,
        "acceptRecovery("+ TextFormat.shortDebugString(logToSync) + ")");
 
    // If one of the loggers above missed the synchronization step above, but
    // we send a finalize() here, that's OK. It validates the log before
    // finalizing. Hence, even if it is not "in sync", it won't incorrectly
    // finalize.
    //EditLog既然已经同步完了,那么就应该正常finalized了。
    QuorumCall<AsyncLogger, Void> finalize =
        loggers.finalizeLogSegment(logToSync.getStartTxId(), logToSync.getEndTxId());
    loggers.waitForWriteQuorum(finalize, finalizeSegmentTimeoutMs,
        String.format("finalizeLogSegment(%s-%s)",
            logToSync.getStartTxId(),
            logToSync.getEndTxId()));
  }

代码中留给我们一个问题,就是什么样的log segment是更好的,在recover的过程中被选为同步源呢。详细的设计可以参考Todd写的<<Quorum-Journal Design>>https://issues.apache.org/jira/secure/attachment/12547598/qjournal-design.pdf 的2.9和2.10。在代码中的实现是SegmentRecoveryComparator类。

简单描述下原理就是:有finalized的不用in-progress的;如果有多个finalized必须length一致;没有finalized的看谁的epoch更大;如果前面的都一样就看谁的最后一个txid更大。

在<<Quorum-Journal Design>>中有具体的例子。我看完这块之后感觉和HDFS append的block recover过程中选择同步源的思路有异曲同工之妙。

经历了上面的QourumJournalManager.recoverUnfinalizedSegment()过程,不完整的log segment都是完整的了,接下来就是调用NameNode.startActiveServices()->FSNamesystem.startActiveServices()->EditLogTailer.catchupDuringFailover()->EditLogTailer.doTailEdits(),原来Standby NN先去和原来Active NN同步EditLog,然后把EditLog执行,这时两台NN内存数据才真正一致。这里会调用QuorumJournalManager.selectInputStreams()从JNs中读取EditLog。而且目前HDFS中只有finalized edit log才能被Standby NN读取并执行。在Standby NN从JNs读取EditLog时,首先向所有的JN节点发送getEditLogManifest() RPC去读取大于某一txid并且已经finalized edit log segment,收到大多数返回success,则把这些log segment整合成一个RedundantEditLogInputStream,然后Standby NN只要向其中的一台JN读取数据就行了。

至此原来的Standby NN所做的擦屁股的工作就结束了,那么它就正式变成了Active NN,接下来就是正常的记录日志的工作了。

4.3 startLogSegment

NameNode.startActiveServices()->FSNamesystem.startActiveServices()->FSEditLog.openForWrite()->FSEditLog.startLogSegmentAndWriteHeaderTxn()->FSEditLog.startLogSegment()->JournalSet.startLogSegment()->JournalSet.startLogSegment()->QuorumJournalManager.startLogSegment()。QJM向JNs发送startLogSegment RPC调用,如果收到多数success response则成功,用这个AsynaLogSet构造QuorumOutputStream用于写log。

4.4 write edits

写EditLog的过程:FSEditLog.logEdit()->QuorumOutputStream.write()把Log写到QuorumOutputStream的double buffer里面。

Log持久化的过程:FSEditLog.logSync()->EditLogOutputStream.flush()->QuorumOutputStream.flushAndSync(),在这个函数里通过AsyncLoggerSet.sendEdits()调用Journal RPC把对应的日志写到JNs,同样是大多数success response即认为成功。如果大多数返回失败的话,这次logSync操作失败,那么NameNode会abort,因为没法正常写日志了。

4.5 finalizedLogSegment

流程和startLogSegment基本一样。

【HDFS】QJournalProtocol——journal:写JournalNode相关的RPC 阅读详情

相关推荐

微信小程序网关逆向分析:从协议、签名到会话管理的安全架构剖析

在现代Web与移动应用开发中,API网关作为客户端与后端服务之间的关键通信枢纽,承担着协议转换、流量调度、安全防护与性能优化等核心职责。其工作原理通常涉及统一的请求路由、身份认证、参数校验与响应聚合。从技术价值看,深入理解网关机制不仅能帮助开发者构建更健壮、可扩展的微服务架构,还能为安全评估、性能调优与故障排查提供基础。在移动生态如微信小程序中,网关设计尤为关键,它需要处理微信特有的登录态、数据加密与防重放攻击等安全需求。本文聚焦于微信小程序网关的逆向分析方法,通过结合网络抓包与代码反编译技术,深入解析其通

weixin_29323493的博客 443

0100-Hadoop3.2.0 qjournal HA集群搭建

Hadoop HA搭建1. 原理说明2. 环境准备3. 集群规划3. zookeeper集群搭建4. hadoop集群搭建4.1 Hadoop下载4.2 解压4.3 配置文件4.3.1 配置环境变量4.3.2 hadoo-env.sh配置4.3.3 core-site.xml4.3.4 hdfs-site.xml4.3.5 mapred-site.xml4.3.6 yarn-site.xml4.3...

登峰小蚁 3396

CentOS7下Graylog3.0高效日志管理:从零搭建到实战应用

本文详细介绍了在CentOS7操作系统上从零开始搭建Graylog3.0日志管理平台的完整过程。内容涵盖Java环境准备、MongoDB与Elasticsearch依赖安装、Graylog Server核心配置,并实战演示了通过Graylog Sidecar集中管理日志采集器以及配置邮件告警功能,为中小型团队提供了一个比ELK更轻量、易维护的一体化日志解决方案。

weixin_29207149的博客 88

Hadoop 大数据启蒙:深入解析分布式基石 HDFS

HDFS 的核心价值在于通过分布式存储 + 多副本机制 + 主从架构解决了海量数据的存储可靠性问题。其设计哲学深刻影响了后续分布式系统(如 Ceph、OSS 等)。推荐学习路径TestDFSIONNBench研究 Erasure Coding(EC)如何降低存储成本探索 Ozone:下一代 Hadoop 对象存储方案实践 HDFS 与 Kubernetes 的整合部署思考题:当集群达到 5000 个 DataNode 时,NameNode 可能遇到什么瓶颈?如何优化?

IT技术学习与工作笔记分享 1432

深入解析STM32定时器中央对齐模式3的双中断机制

本文深入解析了STM32定时器中央对齐模式3的双中断机制。该模式在一个PWM周期内,会在计数器到达ARR(上溢)和0(下溢)时各触发一次更新中断,实现更精细的实时控制。文章详细阐述了其工作原理、配置方法,并指导如何在中断服务函数中通过DIR位区分中断来源,同时探讨了其在电机控制、数字电源等场景下的应用优势与CPU负载挑战。

weixin_29164185的博客 494

5G初始注册流程详解(2)-Registration Request

1:了解注册的本质,5G终端为什么要注册? 2:SUCI,SUPI,5G-GUTI的区别? 3:为什么会有COMPLETE REGISTRATION REQUEST呢?

weixin_53220301的博客 3795

Namenode HA原理以及配置

NameNode HA 原理 • hadoop2.x之后,Clouera提出了QJM/Qurom Journal Manager. 这是一个基于Paxos算法实现的HDFS HA方案,它给出了一种较好的解决思路和方案,示意图如下: • QJM方式来实现HA的原理: • 基本原理就是用2N+1台 JN 存储EditLog,每次写数据操作有大多数(>=N+1)返回成功时即认为...

贾己人的博客 2517

USB3.0一致性测试方案

为各测试项目具体测试结果包括脉冲串突发时间、脉冲串重复时间、时钟周期以及眼图等完整USB3.0测试项目,工程师可以看到各项测试的具体结果方便观察。RIGOL 提供了一套完善的工具,包括数字示波器、专业的测试夹具以及全自动一致性测试软件,使得USB 3.0设备设计人员能够高效精确地进行信号捕捉、测试与分析。报告第二部分测试摘要,在此可以看到USB3.0测试所有测试项目,并且可以观看到测试是否正常,可以帮助工程师更好的判断测试结果。,以简化下载、存储以及对于多媒体的大量内容的共享。

2409_87378937的博客 2533

HDFS使用QJM(Quorum Journal Manager)实现的高可用性以及备份机制

目录 前言 1.NameNode的启动和对edits和QJM相关配置文件的解析 2.使用FSImage和FSEditLog类对image和edit log文件进行读写和管理 3.EditsDoubleBuffer 双缓存,让flush和write同时进行,互不干扰 4.AsyncLoggerSetl类代理对QJM集群的读写 6.QuorumCall封装了对基于paxos算法的QJM集群的异...

小昌昌的博客 6259

voc与txt互转

voc2txt # coding:utf-8 from __future__ import print_function import os import random import glob import xml.etree.ElementTree as ET def xml_reader(filename): """ Parse a PASCAL VOC xml file """ tree = ET.parse(filename) size = tree.find('siz

weixin_44898889的博客 826

通算、智算、超算:三种算力的区别与应用选型指南

算力是数字时代的基础资源,但通算、智算、超算常被混淆。通算基于CPU,支撑日常业务;智算依赖GPU/NPU,驱动AI模型训练与推理;超算以大规模并行集群实现尖端科学计算。理解三者在硬件、精度、软件生态上的差异,是合理规划算力基础设施、避免预算浪费的关键。从概念到原理,再到应用场景,本文帮你看清三种算力的真实分工与未来融合趋势。

weixin_30983965的博客 179

ES与分布式系统(一)

一、简介   首先我们这个平台是ES专题技术的分享平台,众所周知,ES是一个典型的分布式系统。在工作和学习中,我们可能读已经接触和学习过多种不同的分布式系统了,各有各的区别,但也有很多共性。不知道大家在接触过这么多分布式系统后,会不会有下面这些疑问和困惑:   1.不同的分布式系统采用了不同的架构模式,比如主备模式(primary-backup)、领导者跟随者模式(leader-follower)、主仆模式(master-slaver)等等,这些模式有什么区别,应用场景是什么?   2.我们了解ES的分片机

xieegai的博客 2855

银河麒麟服务器操作系统V10 SP1:跨架构激活与设备更换无忧指南

本文详细解析了银河麒麟服务器操作系统V10 SP1的跨架构激活新特性。该特性彻底解除了授权与CPU架构的绑定,允许同一份授权在x86、ARM、龙芯等不同架构服务器间灵活使用。文章提供了从新设备激活到硬件更换后保持激活状态的全流程实战指南,并分享了内网环境部署等高级技巧,助力企业简化运维、提升硬件资源管理灵活性。

ff678的博客 355

【HDFS入门】HDFS高可用性与容错机制深度解析

在大数据生产环境中,Hadoop分布式文件系统(HDFS)的高可用性(HA)和容错能力是确保业务连续性的关键要素。ZKFC(ZooKeeper Failover Controller):每个NN的守护进程。

IT成长日记的博客 757

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

HDFS源码分析EditLog之读取操作符

在《HDFS源码分析EditLog之获取编辑日志输入流》一文中,我们详细了解了如何获取编辑日志输入流EditLogInputStream。在我们得到编辑日志输入流后,是不是就该从输入流中获取数据来处理呢?答案是显而易见的!在《HDFS源码分析之EditLogTailer》一文中,我们在讲编辑日志追踪同步时,也讲到了如下两个连续的处理流程...

weixin_34342207的博客 246

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

Caused by: java.lang.IllegalArgumentException: bad journal id: qjournal://

CM 6.2.0 cdh hdfs 配置HA方法: CDH 5.0 和更高版本不支持使用共享 NFS 挂载的 HDFS High Availability。建议您将 HDFS HA 设置切换为 Quorum-based Storage。必须将 HDFS HA 设置切换为 Quorum-based Storage,然后再尝试升级至 CDH 5。 Suppress...一直是个警告,真的是很烦啊...

mtj66的博客,交流WX:SpringBreeze1104 2396

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

大数据异常问题集锦

未知错误1 org.apache.hadoop.hdfs.qjournal.client.QuorumException: Could not format one or more JournalNodes. 1 exceptions thrown: 192.168.141.104:8485: Directory /var/bdsp/hadoop/ha/qjm/bdsp is in an inconsistent state: Can't format the storage directory becau

weixin_43813200的博客 1249

HDFS之Qurom Journal Manager(QJM)实现机制分析

1.前言 1.1背景 自从hadoop2版本开始,社区引入了NameNode高可用方案。NameNode主从节点间需要同步操作日志来达到主从节点元数据一致。最初业界均通过NFS来实现日志同步,大家之所以选择NFS,一方面因为可以很方便地实现数据共享,另外一方面因为NFS已经发展20多年,已经相对稳定成熟。 虽然如此,NFS也有缺点不能满足HDFS的在线存储业务:网络单点及其存储节点单点。业界提供了数据共享的一些高可用解决方案,但均不能很好地满足目前HDFS的应用场景。 方案 ...

breakout_alex的博客 912

hadoop3高可用集群搭建异常(Can‘t format the storage directory because the current directory is not empty)

hadoop3分布式集群搭建异常 集群环境 4台虚拟机: centos7 hadoop3.3.0 最初jdk版本,是openJDK8_272版本,最后发现启动报错原因就是openJDK原因,最终换为非openJDK版本 及java 8版本,及jdk-8u131,再次启动集群,问题解决。 启动集群hdfs namenode -format,进行格式化时,报错如下: ************************************************************/ 2020-12-28

qq_21480329的博客 6967

Quorum Journal Manager原理

Quorum Journal Manager原理     在一个典型的HA集群,两个独立的物理节点配置为NameNodes。在任何时间点,其中之一NameNodes是处于Active状态,另一种是在Standby状态。 Active NameNode负责所有的客户端的操作,而Standby NameNode尽用来保存好足够多的状态,以提供快速的故障恢复能力。     为了保

chenglinhust的专栏 1868

hadoop-HA集群搭建,启动DataNode,检测启动状态,执行HDFS命令,启动YARN,HDFS权限配置,C++客户端编程,常见错误...

本篇博文为整理网络上Hadoop-HA搭建后出来的博客,参考网址为:http://blog.chinaunix.net/uid-196700-id-5751309.html 3.部署 3.1.机器列表 共5台机器(zookeeper部署在这5台机器上),部署如下表所示: NameNode JournalNode DataNode ZooK...

weixin_34392843的博客 945

大数据生态HA(全)

目录 Hadoop HA NameNode Federation HBase HA Storm HA Flink HA 先安装好ZooKeeper。 Hadoop HA 1、集群规划 host HDFS Yarn ZK HA bigdata111 NameNode SecondaryNameNode ResourceManager QuorumPeerMain bigdata112 DataNode...

L 617

分布式文件系统HDFS架构解析

HDFS是以中间控制节点为代表的分布式存储架构,一部分节点 NameNode 是存放管理数据,另一部分节点DataNode存放业务数据。本文简要整理HDFS分布式文件系统的整体架构和关键技术,进一步了解不同分布式存储技术实现原因上的差异。

牧羊人的方向 6520

Hadoop 基础知识---之HDFS篇

HDFS基础知识 HDFS简介 起源       源于Google发布的GFS论文 HDFS是Hadoop DistributeFile System 的简称,是Hadoop的一个分布式文件系统。 设计目标 大文件存储:支持TB-PB级的数据量 高容错:运行在商业硬件上,而商业硬件并不可靠 高吞吐量:为大量数据访问的应用提供高吞吐量支持 适应场景: 大文件访问 流式数据

bigdata_player的博客 5723
上一篇: fuse_trash.c:119: error: too few arguments to function 'hdfsDelete'
下一篇: Hadoop 2.2.0 HDFS的HA配置
迷途小码
博客等级 码龄19年 71粉丝 95原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值