แแแแแแ แแ แจแแฎแแแแ แแแ แแแแก แจแแกแแฎแแ, แแฃ แ แ แกแฎแแ แแ แแชแแกแแแแก แแแขแแแแขแแแแ แแแ แจแแแซแแแแ, แฉแแแแแ แกแฎแแแแแกแฎแแ แแแแแก แแแแแแกแจแ แงแแแแแแฆแ. แแแแ แแ แแแ แแ แแแแกแ, แ แแ แแแแ แ แแ แ แจแแแซแแแแ แแแฎแแ แฏแแก แแแแแแแก แจแแฅแแแแแ, แแฅแแแ แฃแแแ แแแฎแแ แฏแแ แแแ แแแก แจแแคแแกแแแแแ แแ แแแแก แจแแแแฌแแแแแแ, แ แแ แแแฆแแแฃแแ แจแแแแแ แแ แแ แแก แจแแแแฎแแแแแแ. แแแแฎแแ แชแแแแแแแก แจแแแแแ, แแแแแกแแแแ แ แแแแแแ แฃแแแ แแงแแก แแแแแขแแ แแแแ แแ แแแ แแแแฃแแแ แจแแแแฌแแแแก.
แแ แแก แแ แแก แงแแแแ แแก แแขแแแ, แ แแแแแแช แฃแแแ แแแกแ แฃแแแแก แแแแแกแแแแ แแแแแแแแแจแ, แแแแฃแ แฉแแแแแ แแแกแ แแแแแกแ. แแฃ แแกแแฃแแ แแแ แกแแแ แแแแแแก แแแกแจแขแแแแแกแ แแ แแแแแแแแ แแแแแแ, แกแ แฃแแงแแคแแแแแแก แ แแแแแแแแ แแแแจแแแแแแแแแ แแแ แแแแ. 2019 แฌแแแก แแแแแกแแแแก Sber-แแ แฃแแแ แแแแแแงแแแ 2000-แแ แแแขแ แแแแแแ. แกแแแแแ แแกแ แแ แแ แแก แฃแแ แแแแ แแแแแแแก แจแแแฃแจแแแแแ, แกแแญแแ แแ แกแแแ แแฌแแแแ แกแแกแขแแแแแแแ แแแขแแแ แแ แแแ, แกแแแจแแแแแแ แแแแแแแแแก แแแแแชแแแแ แแแ แขแแก แจแแแฃแจแแแแแ แแ แแแแกแขแแ แแ แแแกแ แแฃแจแแแแแก แแแแขแ แแแแก แฃแแ แฃแแแแแงแแคแ.
แฉแแแแ แแฃแแแ แแแแแแ แแแก Sber.DS แแแแขแคแแ แแแก. แแก แกแแจแฃแแแแแแก แแแซแแแแ แแแแแญแ แแก แแแแฅแแแแแแชแแแแแแแแก แแ แแแแแแแแ, แแฉแฅแแ แแแก แฐแแแแแแแแแแก แขแแกแขแแ แแแแก แแ แแชแแกแก, แแ แแแชแแแจแ แแแแ แขแแแแแก แแแแแแแแแก แจแแแฃแจแแแแแแกแ แแ แแแแแฌแแแแแก แแ แแชแแกแก แแ แแกแแแ แแแแแขแ แแแแแก แแแแแแแก แจแแแแแก PROM-แจแ.
แแแแกแแแแแก, แ แแ แแ แแแแแขแงแฃแแ แแฅแแแแ แแแแแแแแแแ, แฌแแแแกแฌแแ แแแแแ แแแฅแแ, แ แแ แแก แแแกแขแ แแ แแก แจแแกแแแแแ แแ แญแ แแแแก แฅแแแจ, แแแแฌแงแแแแแแแแก, แฉแแแ แแกแแฃแแ แแแ แแแแแ, แ แแช, แแ แแแชแแแจแ, แแ แแก Sber.DS แแแแขแคแแ แแแก แฅแฃแแแก แฅแแแจ. แฉแแแ แชแแแแ แแแแแงแแแแแ แแแแแแแก แกแแกแแชแแชแฎแแ แชแแแแแก แจแแกแแฎแแ แจแแฅแแแแแแ แแแแแ แแแแแแ.
Sber.DS แจแแแแแแ แ แแแแแแแแ แแแแแแแแแขแแกแแแ, แ แแแแแแแแแ แแแแแแ แแ แแแแแแแแแแ, แแแแแแแแ แแแแก แกแแกแขแแแ แแ แแแแแแแก แจแแกแ แฃแแแแแก แกแแกแขแแแ.
แแแแแแแแแแ แแแแแขแ แแแแแก แแแแแแแก แกแแกแแชแแชแฎแแ แชแแแแก แแแกแ แแแแแแแแ แแแแก แแแแแก แแแฉแแแแก แแแแแแขแแแแ แแแก แแแแฎแแ แชแแแแแแแแแ PROM-แจแ, แแแแแขแแ แแแแกแ แแ แแแแแแแกแแแชแแแแแ. แแแแแแแแแแแก แแ แแแแแ แจแแกแแซแแแแแแแ แแแแแ แแแฎแแแแ แแแ แแแฃแแแ แแแแแก แฌแแกแแแแ, แแแแแแแแแ, แขแ แแแแแแแกแ แแ แแแแแแแชแแแก แแแแฃแจแแแแก แแแฎแกแแแแแ แแ แจแแแแฎแแ. แกแแแแแแแแแแจแ, แแก แแ แแก แฉแแแแ แงแแแแ แแแแแแแก แ แแแกแขแ แ.
แแแแแแแแ แแแแก แกแแกแขแแแ แจแแฅแแแแแแ แแแแแแแแแก แแแแฃแแแฃแ แ แแแแแแแแ แแแแกแแแแก แแ แแแแแแแชแแแก แขแแฅแแแแแกแแแแก. แจแแแฃแจแแแแแฃแแ แแแแแแแแ แแแแแแ แแแแแแแแ แแแ แแแแแแแชแแแก แแ แแแแฌแแแแแ แแฆแกแ แฃแแแแแก แกแแกแขแแแแก แแแแแแแแ แแแแแแก แคแฃแแฅแชแแแแแก แจแแกแแกแ แฃแแแแแแ. แแกแแแ, แแแจแแแแแก แกแแกแขแแแแจแ, แแแแแแ แจแแแซแแแแ แแแแแแแกแแแก แแแแแขแแ แแ, แ แแแ แแแ แแแแฃแแแ แแแแฌแงแแก แแแแแแแชแแแก แขแแฅแแแแแแ แแแกแ แแฃแจแแแแแก แแแแแขแแ แแแแแกแแแแก.
แกแแกแขแแแแจแ แ แแแแแแแแ แขแแแแก แแแแแซแแ. แแแแแแ แแ แจแแฅแแแแแแ แแแแแชแแแแ แกแฎแแแแแกแฎแแ แฌแงแแ แแกแแแ แแแกแแแแแจแแ แแแแแ, แกแฎแแแแ แจแแฅแแแแแแ แฌแงแแ แแก แแแแแชแแแแแแก แแแ แแแฅแแแแกแ แแ แแแก แแแกแแแแแแ แแแแแ (แแแ แแแแ). แแ แกแแแแแก แแ แแแแแ แแแแแซแ แกแฎแแแแแกแฎแแ แแแแแแแแแก แจแแกแแฅแแแแแแ แแ แแแแแซแแแ แแแแ แแแกแแแแกแขแฃแ แแแแแ. แแแแแแแแแ แก แจแแฃแซแแแ แแแแแชแแแแแแก แฉแแขแแแ แแแ แแแแแกแแแแ แ แฌแงแแ แแแแ, แแแ แแแฅแแแ, แแแคแแแขแแ แ, แจแฃแแแแแฃแ แ แแแแแชแแแแแแก แแแแฃแแแแแแชแแ แแ แแแฌแแแแแแ แแแงแแคแ.
แแแแขแคแแ แแ แแกแแแ แจแแแชแแแก แแแ แแแแฃแแแแก, แ แแแแแแแช แจแแแซแแแแ แแแแแแแฌแแแก แแ แฉแแแแแแแแก แแแแแแแแก แแแแแจแ. แงแแแแ แแแฅแแแแแแ แจแแกแ แฃแแแแฃแแแ แแแแฃแแแฃแ แ แแแขแแ แคแแแกแแก แแแแแงแแแแแแ. แกแแแแแแแแแแจแ, แแฅแแแ แจแแแแซแแแแ แแ แแแแแแแก แแแแแญแ แ แแแแแก แแ แแ แฎแแแแก แแแ แแจแ.
แแฃ แฉแแจแแแแแฃแแ แจแแกแแซแแแแแแแแแ แแ แแ แแก แกแแแแแ แแกแ, แกแแกแขแแแ แแซแแแแ แจแแกแแซแแแแแแแแก แกแฌแ แแคแแ แจแแฅแแแแ แกแแแฃแแแ แ แแแแฃแแแแ. แฉแแแ แจแแแฅแแแแแ แแแขแแแ แแ แแแฃแแ แแแแแแแแ แแแแก แ แแแแแ แแแแก แกแแคแฃแซแแแแแ แแแแแแแก, แแแแช แฅแแแแก แแฎแแ แแแแฃแแแแก แแฃแแแแแ.
Sber.DS-แแก แแ แฅแแขแแฅแขแฃแ แ แแแแแฃแแแ แแแแ แแกแแ แแแกแแแแ. แแ แกแแแแแก แแ แแแแแ แแแกแแแ แแแ แแแแก แจแแกแแฎแแ, แแฃ แ แ แแ แแก แแแแ แแกแแ แแแกแแแ. แแแแ แคแแฅแ แแแก, แ แแ แกแแแแแ แแกแแ แแแแแแแแฃแ แ แแแแแก แแแฌแแแแแแ แแแงแแคแ, แแแแ แแ แแแแแ แแ แแก แแกแแแ แแแแแช แแแแแแ แแแแแ แแแแแชแแแแ แแแแแจแ. แฉแแแแ แแแแ แแกแแ แแแกแ แกแฎแแ แแแแ แแกแแ แแแกแแแ แฃแแแ แแแฃแแแแจแแ แแแก แแฎแแแแ REST API-แก แแแจแแแแแแ. แแ แแแแแ แ แแแแแกแแแแแ แแ แแ แแก แแแแแชแแแแ แแแแแแ แแแ แแแแแ แฌแแแแแแกแแแแก.
แฉแแแ แแชแแแแแแ แฃแแ แฃแแแแแแงแแ, แ แแ แกแแ แแแกแแแ แแ แแแฎแแแก แซแแแแแ แแแแ แแ แแแฃแฎแแ แฎแแแแแ: แแ แแ แแแแแแแแ แแ แฃแแแ แแแแฎแแแ แแก 4-8 แแแแแแแแขแแ แแแข แแแแ แแขแแฃแแ แแแฎแกแแแ แแแ แแ แฃแแแ แฃแแ แฃแแแแแงแแก แแแแฎแแแแแแแก แฐแแ แแแแแขแแแฃแ แ แแแกแจแขแแแแก แจแแกแแซแแแแแแแ แแฎแแแ แแแกแขแแแชแแแแแก แแแจแแแแแ. แแแแแแฃแแ แกแแ แแแกแ แกแฎแแแแแแ แฃแ แแแแ แแแแก แแฎแแแแ REST API-แแก แกแแจแฃแแแแแแ (). แกแแ แแแกแแ แแแกแฃแฎแแกแแแแแแแ แแฃแแแ แแแแแแแฃแแแ แจแแแแแ แฉแฃแแแก API แฃแแฃแจแแแแแกแแแแแแแ แแแแ แแแแแแขแแแแ, แ แแแแแแช แแแแแแงแแแแแก แแแก.
แแแแแแแชแแแก แแแ แแแ แแฌแแ แแแ Java-แจแ Spring Framework-แแก แแแแแงแแแแแแ. แแแแแกแแแแแ แแแแแแแแ แแแแแ แจแแแฅแแแ แฆแ แฃแแแแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแจแ แกแฌแ แแคแ แแแแแแแแแแกแแแแก, แแแแขแแ แแแแแแแชแแ แแจแแแแ แแแแขแแแแแ แแแแชแแแก แกแแกแขแแแแก แแแแแงแแแแแแ. (). แแแแขแคแแ แแ แแฃแแแแแแ แแแแแ แแแแ, แ แแแแ แช แแแแแแก แคแฃแแฅแชแแแแแแแแแก แแแแ แแแก แแฃแแฎแแ (แแแแขแแแ แแฎแแแ แแแแแฅแขแแ แแแ, AutoML), แแกแแแ แขแแฅแแแแแแแฃแ แ แแคแแฅแขแฃแ แแแแก แแฃแแฎแแ.
แฉแแแแ แแแแขแคแแ แแแก แแ แ-แแ แแ แแแฎแแกแแแแแแแแแ แแก, แ แแ แฉแแแ แจแแแแแซแแแ แแแแฃแแแฃแ แ แแแขแแ แคแแแกแแ แจแแแฃแจแแแแแฃแแ แแแแแก แแแจแแแแ แกแแแ แแแแแแก แแแแแแแก แจแแกแ แฃแแแแแก แแแแแกแแแแ แกแแกแขแแแแแ. แแฎแแ แฃแแแ แแ แ แแแแแแแแ: แแ แแ Hadoop-แแ, แแแแ แ OpenShift-แแ (Docker). แฉแแแ แแฅ แแ แแฉแแ แแแแแ แแ แแฅแแแแ แแแขแแแ แแชแแแก แแแแฃแแแแก แแแแแก แแแกแแจแแแแแ แแแแแกแแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแแ, แแแ แจแแ แแก แจแแแ แแ แฆแ แฃแแแแจแ. แ แแช แจแแแฎแแแ แกแแแ แแแแแแก แแแแกแแกแขแแแแจแ แแคแแฅแขแฃแ แ แแแขแแแ แแชแแแก แจแแกแแซแแแแแแแแแก, แฉแแแ แแกแแแ แแแแแแแแ แแฃแจแแแแแก แแ แกแแแฃแ แกแแแฆแกแ แฃแแแแ แแแ แแแแจแ. แกแแแแแแแแแ, แแแแแกแแแแแ แจแแแซแแแแ แแแฅแแแแแ แแงแแก แแแขแแแ แแ แแแฃแแ แแแแแกแแแแ แ แแ แแแแแแแชแแแก แแแแแกแแแแ แแแแแจแแคแขแจแ.
แแแ, แแแแช แแแแกแแ แชแแแแแแแ แแแแฎแแแ แ แแแแแฌแงแแแขแแก, แ แแแแแแช แแฌแแ แแแแแก Python-แก Hadoop-แแ PROM-แจแ, แแชแแแ, แ แแ แกแแแแแ แแกแ แแ แแ แแก Python แแแแฎแแแ แแแแแก แแแ แแแแก แแแแแแแแแ แแ แแแฌแแแแแ แแแแแแฃแ แแแแแชแแแแ แแแแแซแแ. C/C++ แแแแแแแแแแแแแก แแแแ แ แแแแแแแแ แแแแฅแแแแแแชแแแแแแแแกแแแแก, แ แแแแแแแช แแงแแแแแแ Python แแแแฃแแแแก, แแ แแแแชแแแ แกแแแจแแแแแก แกแแจแฃแแแแแแก. แฉแแแ แฃแแแ แแแแฎแกแแแแแก แแแแแขแแแแก แแแแแฎแแแแ แแฎแแแ แแแแแแแแแแแแแก แแ แกแแ แแแ แแแแก แแแแแขแแแแกแแก, แแแแแแ แแฃแแแ, แจแแแแแแ แฉแฃแแแ แฃแแแ แแแแกแแแแแแแ แฃแแแ แแแแแ แแแแ แแแแแแแก แแแแแแ.
แแ แกแแแแแก แ แแแแแแแแ แแแแแแแ, แแฃ แ แแแแ แฃแแแ แแแแแแแแแ แแก. แแแแแแแแแ, แฌแแแแกแฌแแ แแแแแแแแแ แ แแแแแแแแ แฎแจแแ แแ แแแแแงแแแแแฃแแ แแแแแแแแแแ แแ แแแแแฎแแ แชแแแแแ แแกแแแ PROM-แจแ. Cloudera's Hadoop แแแกแขแ แแแฃแชแแแจแ แแกแแแ แฉแแแฃแแแแ แแ แแงแแแแแแ . แแกแแแ แแฎแแ Hadoop-แจแ แจแแกแแซแแแแแแแ แกแแ แแแแ - แแแแขแแแแแ แแแ. แแแแแแ แ แแแ แขแแ แจแแแแฎแแแแแจแ แจแแกแแซแแแแแแแ แแแแแก แแแฌแแแแแ แแแแแขแแแ แแ แแแ .
แแแแแ แซแแแแแ แกแแ แแแแฃแแแ แแแแแแแ แแแกแแแ แแฎแแ แแก แแแแแก แแแจแแแแแก แฃแกแแคแ แแฎแแแแแก, แแแแขแแ แแแฅแกแแแแแฃแ แแ แแแงแแแแแ Linux-แแก แแแ แแแแก แแฎแแ แคแฃแแฅแชแแแแก, แกแแแแช แแ แแชแแกแ แแฃแจแแแแก แแแแแแ แแแฃแ แแแ แแแแจแ. , แจแแแแซแแแแ แจแแแฆแฃแแแ, แแแแแแแแแ, แฅแกแแแจแ แแ แแแแแแแแ แแ แแแกแแแ แฌแแแแแ, แ แแช แแแแจแแแแแแแแแ แแแชแแ แแแก แแแแแ แแแแแก แจแแกแแซแแแแแแแแแก. แแแแแแฃแแ แแแแแ แขแแแแแขแแก แแแแแชแแแแ แแแแแแ แแแชแฃแแ แแ แฎแแแแแกแแฌแแแแแแ แแฎแแแแ แแ แแแแแชแแแแแแก แแคแแแแแแแแแกแแแแก. แแแแขแคแแ แแ แฃแแ แฃแแแแแงแแคแก, แ แแ แแ แแ แขแแ แแขแแ แแแก แแแแแชแแแแแก แจแแฃแซแแแ แแแแฆแฌแแแก แแแแ แ แแแแแก แแฎแแแแ แแแแแชแแแแ แแแแแฅแแแงแแแแแก แแ แแชแแกแแก แแแจแแแแแแ, แ แแแแแแช แแแแแขแ แแแแแก แงแแแแ แแขแแแแ แฌแงแแ แแแแแ แฌแแแแแแแแ แแแแแชแแแแ แกแแแแแแ แแแขแ แแแแจแ แแแจแแแแแแแ.
แฌแแแก แฉแแแ แแแแแแแแ แแแแแกแ แฃแแแ Python/R/Java-แจแ แแแฌแแ แแแ แแแแแแแแแก แแแจแแแแแก MVP Hadoop-แแ. แฉแแแ แแแแกแแแ แแแแแชแแฃแ แ แแแแชแแแ, แแแกแฌแแแแแ แแฃ แ แแแแ แฃแแแ แแแฃแจแแแ แแแแแกแแแแ แ แแแ แแแแฃแแ แแแ แแแ Hadoop-แแ, แ แแแ แแ แแแแแ แแ แแ แจแแแแฆแฃแแแ แฉแแแแ แแแแขแคแแ แแแก แแแแฎแแแ แแแแแแ.
แแแ แแ แแแแกแ, แ แแแแ แช แแแแ แแแ, DS-แแก แแแแ แ แกแแแชแแแแแกแขแ แจแแกแแแแจแแแแแ แแแแแแแขแแแแกแ แแ แกแขแแขแแกแขแแแแจแ, แแแแแแแก แแแแแ แแแแแแแแก, แแแแ แแ แแ แช แแฃ แแกแ แแแ แแแ แแ แแแแแ แแแแ แแแแแชแแแแแแก แขแ แแแกแคแแ แแแชแแแจแ แแ แแแ แกแญแแ แแแแแ แฉแแแแ แแแแแชแแแแ แแแแแแ แแแแก แแแฎแแแ แแแ แกแแกแฌแแแแ แแแแฃแจแแแแก แแแกแแแแแแแแแแ. แฉแแแ แแแแแแฌแงแแแขแแ แแแแแฎแแแ แแ แฉแแแแก แแแแแแแแก แแ แจแแแฅแแแแ แแแกแแฎแแ แฎแแแแแ แแแแฃแแแแ แกแขแแแแแ แขแฃแแ แขแ แแแกแคแแ แแแชแแแกแ แแ แคแฃแแฅแชแแแแแก แแแแแแแแแแกแแแแก Spark แซแ แแแแก แแแแแแแแแกแแแแก. แแก แกแแจแฃแแแแแแก แแแแชแแแ แแแขแ แแ แ แแแฃแแแแ แแแแแแแแแก แจแแแฃแจแแแแแแก แแ แแ แแแแแแแแ แแแแแชแแแแ แแแแแแ แแแก แแฎแแแ แแแแแชแแแแ แแแแ แแแแก แแแแแแแแแแก.
แฉแแแ แแแกแแฅแแแแ แแแแแแแแแแก แกแฎแแแแแกแฎแแ แแแแแ แแฃแแแแแ: Linux แแ DevOps, Hadoop แแ Spark, Java แแ Spring, Scala แแ Akka, OpenShift แแ Kubernetes. แจแแแแแ แฏแแ แแ แแแกแแฃแแ แแแ แแแแแแแก แแแแแแแแแแแแ, แ แแแแ แแแแแก แแแแแแ แแแแแแแแแก แกแแกแแชแแชแฎแแ แชแแแแก, แ แแแแ แฎแแแแ แแแแแแแชแแ แแ แแแแฎแแ แชแแแแแแ.
แฌแงแแ แ: www.habr.com