แแแแแฌแแแแแฃแแ แแแแแแแแแแ แแ แแแแ แแแแแชแแแแแแก แแแแแ แ, แจแแกแแแแแแกแแ , แฌแแแแฌแแแจแ 18-19%-แแ แแแ แแแแ. แแก แแแจแแแแก, แ แแ แแ แแแแแแแแกแแแแก แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแ แฉแแแแก แกแแแแแฎแ แแฅแขแฃแแแฃแ แ แ แฉแแแ. แแ แแแกแขแจแ แฉแแแ แแแแแฌแงแแแ แแแแ, แแฃ แ แแขแแ แแ แแก แกแแญแแ แ แแแแแฌแแแแแฃแแ แแแแแแแแแแ, แฃแคแ แ แแแขแแแฃแ แแ แแแแแแฎแแแแแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแ แฉแแแแก, แแแกแแฃแแ แแแ Hadoop-แแก แแแแแงแแแแแแแ Cloudera-แก แแแแแงแแแแแแ แแ แแแแแก แแแกแแฃแแ แแแ แแแแ แแขแฃแ แแก แแ แฉแแแแแ แแ แแแแแ, แแฃ แ แแแแ แแแฅแแแแแแก แแแ แจแแกแ แฃแแแแแแ แกแฎแแแแแกแฎแแ แแแแ.
แ แแขแแ แแ แแก แกแแญแแ แ แแแแแฌแแแแแฃแแ แแแแแแแแแแ แ แแแฃแแแ แฃแ แแแแแแกแจแ? แแฅ แงแแแแแคแแ แ แแแ แขแแแแ แแ แแแแแ แแ แแก แ แแฃแแ. แแแ แขแแแ - แแแแขแแ, แ แแ แฃแแแขแแก แจแแแแฎแแแแแจแ แฉแแแ แแแแแแแแ แจแแแแ แแแแ แแแ แขแแ แแแแแแแแแแก แแแคแแ แแแชแแแก แแ แแแฃแแแ. แ แแฃแแแ, แ แแแแแ แแกแแแ แแแคแแ แแแชแแ แแแแ แแ. แแแแแแ. แจแแแแแแ, แแฃแชแแแแแแแแ . แแแ แแแแ, แแแแแงแแแแแแก แจแแแแฎแแแแแแ แกแแแแแแ แฃแแแแแ แกแแแฃแ แแ: แแแแแแแแแแ แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แแฅ, แกแแแแช แกแแญแแ แแ แแแแแแแแแแกแฌแแแแ แแแขแ แแแแก แแแแ แ แแแแแแแแ แแแแแชแแแแ แแแแแ แฃแคแ แ แแแ แแแกแแแแ.
แแ แ-แแ แแ แแแแ แแแแแแแแ: แแแชแแ แแแแแก แฅแกแแแ Dodo Pizza แแแแแแแแแก แจแแแแแแแแแก แแแแแชแแแแ แแแแแก แแแแแแแแ แแแงแ แแแแแแ, แ แแ แแแชแแก แแ แฉแแแแกแแก แจแแแแฎแแแแแแ แขแแแแแแแ, แแแแฎแแแ แแแแแแ แฉแแแฃแแแแ แแ แแฃแจแแแแแ แแแแ แแแแแแขแแแแก แแฎแแแแ แแฅแแกแ แซแแ แแแแแ แแแแแแแฅแขแแ แแ แ แแแแแแแแ แจแแแแฎแแแแแแ. แแแแก แจแแกแแแแแแกแแ แแแชแแ แแแ แจแแแกแฌแแ แ แจแแกแงแแแแแแ. แแแ แแ แแแแกแ, แแแ แจแแซแแ แจแแแแแแแก แแขแแแแ แแแแฎแแแ แแแแแแแกแแแแก แจแแแแแแแแแฃแแ แแแแแขแแแแแ แแ แแแฃแฅแขแแแแก แฃแแแ แ แแแแแแแแแชแแ, แ แแแแช แแแแแ แแ แแแแแแ.
แแแแแ แแ แแ แแแแแแแแ: แแ แแแฃแฅแขแแก แแ แแแฃแฅแขแแแแ แกแแจแฃแแแแแ แแแกแชแ H&M แแแฆแแแแแก แจแแแแชแแ แแแแแ แแกแแ แขแแแแแขแ แชแแแแแฃแ แแแฆแแแแแแจแ 40%-แแ แแแงแแแแแแแก แแแแแก แจแแแแ แฉแฃแแแแแ. แแก แแแฆแฌแแฃแแ แแฅแแ แชแฃแแแ แแแงแแแแแแ แแแแแแแแก แแแแแ แแชแฎแแแ แแ แแแแแแแแจแ แแแแแแแแกแฌแแแแแฃแแ แแงแ แกแแแแแฃแ แแแ.
แฎแแแกแแฌแงแแก แจแแ แฉแแแ
แแแแฃแกแขแ แแแก แกแขแแแแแ แขแ แแ แขแแแแก แแแแแแแแแกแแแแก แแ แแก Hadoop. แ แแขแแ? แแแแก แแแแ, แ แแ Hadoop แแ แแก แจแแกแแแแจแแแแ, แแแ แแแ แแแแฃแแแแขแแ แแแฃแแ แฉแแ แฉแ (แแแแแ Habr แแแแแแแแแ แแแแ แแแขแแแฃแ แกแขแแขแแแก แแ แแแแแแ), แ แแแแแกแแช แแฎแแแแก แแแแฃแแแแฃแ แ แแ แแแแแแแแแแแแแก แแแแแ แแแแ แแแ. แแฅแแแ แจแแแแซแแแแ แจแแแงแแแแแ แ แแแแ แช แกแขแ แฃแฅแขแฃแ แแ แแแฃแแ, แแกแ แแ แแกแขแ แฃแฅแขแฃแ แแ แแแฃแแ แแแแแชแแแแแแก แฃแแแ แแแแแ แ แแแแ แแแ แแ แแแแแ แกแแกแขแแแ แแแแแแฌแแแแแก แแแ แแแแแแแแแ แซแแแแก แจแแ แแก. แฃแคแ แ แแแขแแช, แแแแแ แจแแกแแซแแแแแแแแแ แจแแแซแแแแ แแแแแแ แแแก แแ แแแแแ แแแก แแแแแกแแแแ แแ แแก - แแแแแ แฐแแ แแแแแขแแแฃแ แ แแแกแจแขแแแแ แแแ แแแฅแแแแแแแจแ.
2017 แฌแแแก แแแแแแแแแแ แกแแแแแกแฃแแขแแชแแ แแแแแแแแ Gartner แ แแ แฐแแแแแ แแแแ แแแซแแแแแแแ. แแแแแแ แกแแแแแแ แแแแแแฃแ แแ: แแแแแแขแแแแกแแแ แแแแแแ, แ แแ แแแแแแแแแแ แแแกแแแ แแแแ แแแแแแแแแแแแแแแ แฆแ แฃแแแแจแ, แ แแแแแ แแฅ แแกแแแ แจแแซแแแแแ แแแแแแฎแแแแ แแแแแแแแแแ แกแแแซแแแแ แแก แแแแแงแแแแแแ. แแแแ แ แแแแจแแแแแแแแแ แคแแฅแขแแ แ, แ แแแแแกแแช แจแแกแแซแแแ แฐแแแแแแก โแแแแแ แฎแแโ แจแแฃแซแแแ, แแ แแก แแแกแ แกแแฉแฅแแ แ. แแแแก แแแแ, แ แแ แแกแแแ แแแ แแแแขแแแ, แ แแแแ แแชแแ Apache Spark แแ Google Cloud DataFlow, แฃแคแ แ แกแฌแ แแคแแ, แแแแ แ MapReduce, แ แแแแแแช แกแแคแฃแซแแแแ แฃแแแแก Hadoop-แก.
Hadoop แแงแ แแแแแ แ แแแแแแแแ แกแแงแ แแแแก, แ แแแแแแแแแ แงแแแแแแ แแแแแกแแฉแแแแ MapReduce แขแแฅแแแแแแแแแ (แกแแ แแแ แแแก แจแแ แแก แแแแแแแแแแแกแแแแก แแแแแชแแแแ แแแแแฌแแแแแแก แกแแกแขแแแ) แแ HDFS แคแแแแฃแ แ แกแแกแขแแแ. แแก แฃแแแแแกแแแแแ แกแแแชแแแแฃแ แแ แจแแฅแแแแแแ แแแแกแขแแ แฃแ แแแแแซแแแก แจแแ แแก แแแแแฌแแแแแฃแแ แแแคแแ แแแชแแแก แจแแกแแแแฎแแ: แคแแฅแกแแ แแแฃแแ แแแแแก แแแแแแฃแแ แแแแแ แจแแแซแแแแ แแแแแแแกแแแก แ แแแแแแแแ แแแแแซแแ แแ แ แแแแแแแชแแแก แฌแงแแแแแแ, แกแแกแขแแแ แแแแ แแแแ แชแแแแแฃแแ แแแแแซแแแแก แฌแแ แฃแแแขแแแแแแแก แแแแแ แ. แคแแแแแก แชแฎแ แแแแก แแแชแแแแ แแแแแแงแแแแแ แกแแแชแแแแฃแ แ แกแแ แแแ แ แกแแฎแแแแ NameNode.
แฅแแแแแ แแแงแแแแแแ แแแฃแกแขแ แแชแแ แแแแฉแแแแแแก, แแฃ แ แแแแ แแฃแจแแแแก MapReduce. แแแ แแแ แแขแแแแ แแแแแชแแแแแ แแแฌแแแแแแ แแแ แแแแฃแแ แแ แแขแแ แแฃแแแ, แแแแ แ แแขแแแแ แแแฌแแแแแแ แแแแแแแแแแ แกแแแซแแแแ แแก แแแฎแแแแแ, แฎแแแ แแแกแแแ แแขแแแแ แฎแแแแ แแแแแแแแ.
MapReduce แแแแแแแแ แแแแแ แจแแแฅแแแ Google-แแก แแแแ แแแกแ แกแแซแแแแ แกแแญแแ แแแแแกแแแแก. แจแแแแแ MapReduce-แแ แแแแฆแ แฃแคแแกแ แแแแ แแ Apache-แ แแแฆแ แแ แแแฅแขแ. แแกแ, Google แแแแแแแแ แแแแแแแแ แกแฎแแ แแแแแฌแงแแแขแแแแแแแแ. แกแแแแขแแ แแกแ แแแแแแ: Google-แก แแแแแแแ แแฅแแก แแ แแแฅแขแ แกแแฎแแแฌแแแแแแ Google Cloud Dataflow, แ แแแแแแช แแแแแแแแแฃแแแ Hadoop-แแก แจแแแแแ แจแแแแแ แแขแแแแ, แ แแแแ แช แแแกแ แกแฌแ แแคแ แฉแแแแชแแแแแ.
แฃแคแ แ แแแขแแแฃแ แ แแแแแแแแแ แแแ แแแแฉแแแแแแก, แ แแ Google Cloud Dataflow แแแคแฃแซแแแแฃแแแ Apache Beam-แแก แแแ แแแชแแแแ, แฎแแแ Apache Beam แแแแชแแแก แแแ แแแ แแแแฃแแแแขแแ แแแฃแ Apache Spark แฉแแ แฉแแก, แ แแแแแแช แกแแจแฃแแแแแแก แแแแซแแแแก แแแกแแฃแแ แแ แแแแแฌแงแแแขแแแแแแแแก แจแแกแ แฃแแแแแก แแแแฅแแแก แแแแแ แกแแฉแฅแแ แแแ. แแกแ, Apache Spark แแจแแแแแแ แแ แแฃแจแแแแก HDFS แคแแแแฃแ แกแแกแขแแแแแ, แ แแช แกแแจแฃแแแแแแก แแซแแแแก แแแก แแแแแแแแแก Hadoop แกแแ แแแ แแแแ.
แแแแแแขแแ แแฅ แแแแฃแแแแขแแชแแแก แแแชแฃแแแแ แแ แแแ แแแแแฌแงแแแขแแแแแแแ Hadoop-แแกแ แแ Spark-แแกแแแแก Google Cloud Dataflow-แแก แฌแแแแแฆแแแแ แแ แฎแแแกแแฌแงแแก แแ แฉแแแแแ แแจแแแ แ แแแฎแแแแ. แฃแคแ แ แแแขแแช, แแแแแแ แแแก แจแแฃแซแแแแ แแแแแ แแแแแฌแงแแแขแแ, แ แแแแแ แแแแ - Hadoop-แแกแแแแก แแ Spark-แแกแแแแก - แฃแแแ แแแฃแจแแแ, แแฅแชแแแขแ แแแแแแฎแแแแแ แแแแแแแแแแ, แแแแแชแแแแแแแแ แแ แแแแแแคแแแแชแแแแ.
แฆแ แฃแแแแแแแ แแ แแแแแแฃแ แ แกแแ แแแ แ
แฆแ แฃแแแแแ แแแแแแ แแแแแกแแแแก แขแแแแแแชแแแ แฌแแ แแแจแแ แแกแแแ แกแแแแขแแ แแกแ แขแแ แแแแแช, แ แแแแ แแชแแ Hadoop-as-a-service. แแกแแ แกแชแแแแ แจแ แแแแแแจแแ แแแฃแแ แกแแ แแแ แแแแก แแแแแแแกแขแ แแ แแแ แซแแแแแ แแแแจแแแแแแแแแ แแแฎแแ. แแแแก แแแแ, แ แแ แกแแแฌแฃแฎแแ แแ, แแแฃแฎแแแแแแ แแแกแ แแแแฃแแแ แแแแกแ, แกแฃแคแแ Hadoop แกแแแแแแ แ แแฃแแ แแแกแขแ แฃแแแแขแแ แแแแคแแแฃแ แแชแแแกแแแแก, แ แแแแแ แแแแ แ แ แแ แฃแแแ แแแแแแแแก แฎแแแแ. แแแแแแแแแ, แแแแแแแคแแแฃแ แแ แแ แกแแ แแแ แแแ แแแแแแแแฃแแแฃแ แแ, แแแแแขแ แแแแ แแแแ แจแแกแ แฃแแแแ แแ แงแฃแ แแแฆแแแแ แแแแแแแคแแแฃแ แแ แแ แแ แแแแแ แแแ แแแแขแ แ. แแแแแแแ, แแแแฃแจแแแแ แ แแแงแแแ แฃแแแกแแแแกแแ แแ แแแแ แจแแแกแแ แกแแแแ แแฃแ แแ แแ แ แแแ แแแแแแ แฉแแก.
แแแแขแแ, แกแฎแแแแแกแฎแแ แกแแแแกแขแ แแแฃแชแแ แแแแ แแแ, แ แแแแแแช แแแแแแแแ แแแแแ แแฆแญแฃแ แแแแแ แแแกแแฎแแ แฎแแแแแ แแแแแแแแแแกแ แแ แแแแแแแกแขแ แแ แแแแก แฎแแแกแแฌแงแแแแแ, แซแแแแแ แแแแฃแแแ แฃแแ แแแฎแแ. แแ แ-แแ แแ แงแแแแแแ แแแแฃแแแ แฃแแ แแแกแขแ แแแฃแชแแ, แ แแแแแแช แแฎแแ แก แฃแญแแ แก Spark-แก แแ แงแแแแแคแแ แก แแแ แขแแแก แฎแแแก, แแ แแก Cloudera. แแแก แแฅแแก แ แแแแ แช แคแแกแแแแ, แแกแแแ แฃแคแแกแ แแแ แกแแแแ - แแ แแ แฃแแแแแกแแแแแจแ แฎแแแแแกแแฌแแแแแแ แงแแแแ แซแแ แแแแแ แคแฃแแฅแชแแ, แแแแแซแแแแก แ แแแแแแแแแก แจแแแฆแฃแแแแก แแแ แแจแ.
แแแงแแแแแแก แแ แแก, Cloudera แแแแแฏแแ แ SSH-แแก แกแแจแฃแแแแแแ แแแฃแแแแจแแ แแแแ แแฅแแแแก แกแแ แแแ แแแก. แกแแแแขแแ แแกแ แแฃแแฅแขแ: แแแกแขแแแแชแแแกแแก แฃแแฏแแแแกแแ แแแฃแแแแแ, แ แแ แแก แแแแแฎแแ แชแแแแแก แ.แฌ แแแแแแแแแ: แกแแแชแแแแฃแ แ แแแแแขแแแ, แ แแแแแแแแแ แแแแแแฃแแ แจแแแชแแแก แงแแแแ แกแแญแแ แ แแแแแแแแแขแก, แ แแแแแแแช แแแแคแแแฃแ แแ แแแฃแแแ แแ แแแแแแแแแ แกแแแฃแจแแแ. แแ แกแแแแแแ, แแก แแ แแก แแแแแขแแก แแแแแฏแแ แแก แแแฃแแฏแแแแกแแแฃแแ แแแ แกแแ.
แแแกแขแแแแชแแแก แจแแแแแ แฉแแแ แแแฆแแแ แแแแกแขแแ แแแแก แแแ แแแแก แแแแกแแแก, แกแแแแช แจแแแแซแแแแ แแฎแแแแ แแแแกแขแแ แฃแแ แขแแแแแแขแ แแ, แแแแแกแขแแแแ แแแฃแแ แกแแ แแแกแแแ, แแกแแแ แจแแแแซแแแแ แแแแแแขแแ/แแแแจแแแแ แ แแกแฃแ แกแแแ แแ แจแแชแแแแแ แแแแกแขแแ แแก แแแแคแแแฃแ แแชแแ.
แจแแแแแแ, แแฅแแแแก แแแแแฌแแ แฉแแแแแ แ แแแแขแแก แกแแแแแ, แ แแแแแแช แแแแแแแงแแแแ BigData-แก แแแแแ แแแแแแแแแ. แแแแ แแ แกแแแแ แแแขแงแแแ "แแแแแ แฌแแแแแแ", แแแแแ แแแแแแแแแ แแแแแขแแก แฅแแแจ.
แขแแฅแแแแแก แแแแฎแแแแแแ
แแแแแก แแแแกแแแขแแ Cloudera แแฆแแแจแแแแก แกแฎแแแแแกแฎแแ แจแแกแแซแแ แแแแคแแแฃแ แแชแแแก. แแแแแแ แแ แแแชแแแแแ, แ แแแแแแแช แแกแแแ แแจแแแแแฃแแแ, แแแฉแแแแแแแ แแแฃแกแขแ แแชแแแจแ:
MapReduce-แก แจแแฃแซแแแ แแ แแแขแแแแกแขแฃแ แ แกแฃแ แแแแก แแแแแแแแ. แแฃ แแแแแ แแ แแฎแแ แแแแแฎแแแแแ แฌแแแ แแแแงแแคแแแแแแก แแแแแ แแแแก, แชแฎแแแ แแแฎแแแแ, แ แแ แแแแฅแแแก แงแแแแ แจแแแแฎแแแแแจแ, MapReduce แกแแแฃแจแแแก แจแแแซแแแแ แฌแแแฌแงแแแก แจแแคแแ แฎแแแ แแแกแแแแแ แแ แฅแกแแแแแแ แแแแแชแแแแแแก แฌแแแแแฎแแแกแแก. แแก แแกแแแ แแฆแแแจแแฃแแแ Cloudera-แก แแแแแจแ. แจแแแแแแ, แแแแแกแแแแ แ แกแฌแ แแคแ แแแแแแแแแแแกแแแแก, แแแ แจแแ แแก Spark-แแก แกแแจแฃแแแแแแ, แ แแแแแแช แฎแจแแ แแ แแแแแแงแแแแแ แ แแแแฃแ แแ แแจแ แแแแแแแแแแแกแแแแก, I/O แกแแฉแฅแแ แ แซแแแแแ แแแแจแแแแแแแแแแ. แแแแขแแ, Hadoop-แแก แแแแแงแแแแแแกแแก แซแแแแแ แแแแจแแแแแแแแแแ, แ แแ แแแแกแขแแ แจแ แจแแแแแแแแ แแแแแแแแกแแแฃแแ แแ แกแฌแ แแคแ แแแแฅแแแแแ, แ แแช, แ แแแแแ แ แแ แแแฅแแแ, แงแแแแแแแแก แแ แแ แแก แฃแแ แฃแแแแแงแแคแแแ แฆแ แฃแแแแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแจแ.
แแแแแแกแ แแแขแแแ แแแแก แแแแแฌแแแแแแจแ แแแแฆแฌแแแ Openstack แแแ แขแฃแแแแแแชแแแก แแแแแงแแแแแแ แกแแ แแแ แแแแ แแซแแแแ แ แแ แแแแแแแ แแแแแแ CPU-แแแแ. แแแแแชแแแแ แแแแแซแแแก แแแแญแแแแ แกแแแฃแแแ แ แแ แแชแแกแแ แแก แ แแกแฃแ แกแแแ แแ แแแแแ แแขแฃแแ แแแกแแแแ. แฉแแแแก แแแแแฌแงแแแขแแแแแแจแ Atos Codex Data Lake Engine แแแฆแฌแแฃแแแ แคแแ แแ แแแ แขแฃแแแแแแชแแ, แ แแก แแแแแช แฉแแแ แแกแแ แแแแแแแ แ แแแแ แช แจแแกแ แฃแแแแแก แแแแแกแแแ แแกแแ (แฅแกแแแแก แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแแแแแแ แแแแแแฃแแแแแแ แแแงแแแแแแ) แแกแแแ TCO-แจแ (แแแแแขแแแแแ แคแแแแแฃแ แ แกแแ แแแ แแแ แแฆแแแแคแฎแแ แแแ).
BullSequana S200 แกแแ แแแ แแแแก แแแแแงแแแแแแกแแก, แฉแแแ แแแฆแแแ แซแแแแแ แแ แแแแแ แแแแ แแแขแแแ แแแแก, แแแแแแแฃแแแ แแแ แแแแฃแแ แแแกแขแแแฃแแก. แแแแแแแแฃแ แ แแแแคแแแฃแ แแชแแ แแแแชแแแก 3 BullSequana S200 แกแแ แแแ แก, แแแแแแฃแแก แแ แ JBOD-แแ, แแแฃแก แแแแแขแแแแแ S200-แแแ, แ แแแแแแแช แจแแแชแแแก แแแฎ แแแแแชแแแแ แแแแแซแก, แกแฃแ แแแแแกแแแแแ แแแแแแจแแ แแแฃแแแ. แแฅ แแแชแแแฃแแแ แแแขแแแ แแแแก แแแแแแแแ TeraGen แขแแกแขแจแ:
แขแแกแขแแแ แแแแแชแแแแ แกแฎแแแแแกแฎแแ แแแชแฃแแแแแ แแ แ แแแแแแแชแแแก แแแแจแแแแแแแแแแ แแฉแแแแแแก แแ แแกแ แแ แแแแแ แจแแแแแแแก แแแแกแขแแ แฃแ แแแแแซแแแก แจแแ แแก แแแขแแแ แแแแก แแแแแฌแแแแแแก แแแแแกแแแ แแกแแ. แฅแแแแแ แแแชแแแฃแแแ แแแกแแแ แฌแแแแแแก แแแแแฌแแแแแแก แแ แแคแแแ แจแแกแ แฃแแแแแก แขแแกแขแแแแก แแแฎแแแแแ.
แแแแแแแแแแ แจแแกแ แฃแแแ 3 BullSequana S200 แกแแ แแแ แแก แแแแแแแแฃแ แ แแแแคแแแฃแ แแชแแแก แกแแคแฃแซแแแแแ. แแแกแจแ แจแแแแก 9 แแแแแชแแแแ แแแแแซแ แแ 3 แซแแ แแแแแ แแแแแซแ, แแกแแแ แ แแแแ แแแ แแแฃแแ แแแ แขแฃแแแฃแ แ แแแแฅแแแแแ OpenStack แแแ แขแฃแแแแแแชแแแก แกแแคแฃแซแแแแแ แแแชแแแก แแแแแแแแแแก แจแแแแฎแแแแแจแ. TeraSort แขแแกแขแแก แจแแแแแ: แแแแแแก แแแแ 512 MB แ แแแแแแแชแแแก แแแแคแแชแแแแขแ แกแแแแก แขแแแแ แแแจแแคแแ แแ แแ แแก 23,1 แฌแฃแแ.
แ แแแแ แจแแแซแแแแ แกแแกแขแแแแก แแแคแแ แแแแแ? แแแแแชแแแแ แขแแแก แซแ แแแแกแแแแก แฎแแแแแกแแฌแแแแแแ แกแฎแแแแแกแฎแแ แขแแแแก แแแคแแ แแแแแแแ:
- แแแแแชแแแแ แแแแแซแแแ: แงแแแแแ 40 แขแ แแแแแกแแงแแแแแแแ แกแแแ แชแแกแแแแก
- แแแแแแขแแแฃแ แ แแแแแซแแแ GPU-แก แแแงแแแแแแก แจแแกแแซแแแแแแแแ
- แกแฎแแ แแแ แแแแขแแแ, แ แแแแแแแช แแแแแแแแแแฃแแแ แแแแแแกแแก แกแแญแแ แแแแแแแ (แแแแแแแแแ, แแฃ แแญแแ แแแแแ แแแคแแ แแ แแกแแแแกแ)
Atos Codex Data Lake Engine แแแแชแแแก แ แแแแ แช แแแแแ แกแแ แแแ แแแก, แแกแแแ แฌแแแแกแฌแแ แแแแแกแขแแแแ แแแฃแ แแ แแแ แแแฃแ แฃแแ แฃแแแแแงแแคแแก, แแแชแแแแแ แแแฃแแ Cloudera แแแแ แแแแก แฉแแแแแแ; แแแแแ Hadoop, OpenStack แแแ แขแฃแแแฃแ แ แแแแฅแแแแแแ, แ แแแแแแช แแแคแฃแซแแแแฃแแแ RedHat Enterprise Linux-แแก แแแ แแแแ, แแแแแชแแแแ แ แแแแแแแชแแแกแ แแ แกแแ แแแแ แแ แกแแกแขแแแแแแ (แแแ แจแแ แแก, แกแแ แแแแ แแ แแแแแซแแกแ แแ Cloudera BDR - Backup and Disaster Recovery-แแก แแแแแงแแแแแแ). Atos Codex Data Lake Engine แแแฎแแ แแแ แแแแ แแแ แขแฃแแแแแแชแแแก แแแแแฌแงแแแขแ, แ แแแแแแช แแแแแฌแแแแฃแแ แแงแ .
แแฃ แแแแแขแแ แแกแแแ แแแขแแแแแ, แแแฎแแ แฃแแ แแแฅแแแแแ แฃแแแกแฃแฎแแ แฉแแแแก แแแแฎแแแแก แแแแแแขแแ แแแจแ.
แฌแงแแ แ: www.habr.com