แแแแแแแแ แแแแแแ แแ แฎแแแแแแฃแ แ แแแขแแแแฅแขแแกแ แแ แแแแฅแแแแแแชแแแแแแแแก แขแแฅแแแแแแแแแก แฃแแแ แฌแแ แแแขแแแแ แแงแแแแแแ แแฅแแแแ แกแแงแแแ แแแ แแแฆแแแแแแ, แกแแขแ แแแกแแแ แขแ แแแแแแแแแแ แแ แแแแแฃแ แแก แคแแ แแแแแช แแ.
แแ แแฃ แ แแแ แแ แกแแแแแก, แแแจแแ แฃแแแ แแ แแก แแแแก แจแแกแแฎแแ แแแขแแ แแแขแจแ... แฆแแ แแ แแแฅแขแ! แแแฎแแ, แ แแแแ แแแฎแแแ แแแแ Open Data Hub แแฎแแแ แขแแฅแแแแแแแแแแก แแแกแจแขแแแแ แแแแจแ แแ แแแแแ แแแแก แแแแแฌแแแแแแแก แแแแแแแ แแชแแแแแแจแ.
แฎแแแแแแฃแ แ แแแขแแแแฅแขแแก (AI) แแ แแแแฅแแแแแแชแแแแแแแแก (ML) แงแแแแ แฃแแแ แแขแแกแแแแ, แแ แแแแแแแชแแแแก แฎแจแแ แแ แฃแญแแ แ แแ แขแแฅแแแแแแแแแแก แแแกแจแขแแแแ แแแ. แแ แจแแแแฎแแแแแจแ แซแแ แแแแแ แแ แแแแแแแแ, แ แแแแ แช แฌแแกแ, แจแแแแแแแ:
- แแแคแแ แแแชแแแก แแแชแแแ แแ แแแแแแจแ แแแแแแ - แแแแฅแแแก แจแแฃแซแแแแแแแ แแแคแแ แแแชแแแก แฃแแ แแแแแแแ แแแชแแแ แแ แกแฌแ แแค แแแแแแ แแแแแจแ แแแแแแจแ แแแแแแ.
- แแแแแชแแแแ แฌแแแแแ โ แแแแแแฃแแ แแแแชแแแแกแแแแก แกแแญแแ แแ แแแกแ แฎแแแแฎแแ แแ แฎแแแแ แแจแแแแแ, แ แแกแแช แแแแ แแ แ แกแญแแ แแแแ.
- แฌแแแแแ แแแแฎแแแแแ โ แแแแฎแแแแแ แฌแแแแแแก แกแแจแฃแแแแแ แแ แแ แกแแแแแก แแแแฅแแแแแแชแแแแแแแแก แแแกแขแ แฃแแแแขแแแแ แแ แแแแขแคแแ แแแแ, แแกแแแ แ แแแแ แช แแแแแแแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแแ.
- แฌแแ แแแแแ โ แแแแแแแแ แ แฉแแแ แแ แแขแแขแแแแก แแขแแแแ แแ แแ แแ แแก แแแงแแแแแแ แกแแแ แแฌแแแแ แแแแแงแแแแแแจแ.
- แแแแแงแฃแ แ แแแแแแแ แแ แแฎแกแแแแ AI แจแแแแแแแ โ AI/ML แจแแแแแแแแก แแแแแแแ แแแแแแแ, แแแแแงแฃแ แแก แแแแแแแ แแ แแฎแกแแ แ แแฃแแแ.
แแแแแฃแญแ แแแ, แแก แแ แแแแแแแแ แฃแแ แงแแคแแแแ แแแกแแฎแแแ แฆแแ แแแฃแแ แแแแแชแแแแ แแแชแแแแ แแแแก แกแแฉแฅแแ แแแ, แแคแแฅแขแฃแ แแแแกแ แแ แแ แแแฃแฅแขแแฃแแแแแแ. แแก แแฌแแแแก แแแ แแแแแแแชแ แฃแแแแก, แแแแแแแชแ แฃแแแแก แกแแแฃแจแแแจแ แแ, แจแแแแแแ, แแแแแแกแแก แแแแแแแแแแ AI/ML-แแแ แแแแแแจแแ แแแแ แคแฃแญแแแแ.
แแ แแ แแแแแแแแแก แแแแแญแ แแแ แแแกแฃแฎแแกแแแแแแแแ แแแแกแ แแแ IT แกแแแชแแแแแกแขแแแก, แ แแแแแแแแช แฃแแแ แแแแฌแแแแ แแแแแชแแแแ แแแแแแขแแแแกแแแ - แแก แแแ แแแแแ, แ แแฆแแช แฆแ แฃแแแแก แแกแแแแกแ. แฃแคแ แ แแแขแแแฃแ แแ, แฉแแแ แแแญแแ แแแแ แแแแขแคแแ แแ, แ แแแแแแช แแซแแแแ แแ แฉแแแแแแก แแแแแกแฃแคแแแแแก แแ แแฅแแก แแแกแแฎแแ แฎแแแแแ, แแแ แขแแแ แฌแแแแแ. แแแแแแ แแฃแแแ, แแก แแ แแก แกแฌแ แแคแ, แแแแแแแ แแแแคแแแฃแ แแ แแแแแ, แแแกแจแขแแแแ แแแแแ แแแแฎแแแแแ แแ แแแแ แแแแ แฌแแ แฃแแแขแแแแแแแก แแแแแ แ. แฆแแ แแแแแก แขแแฅแแแแแแแแแแ แแกแแแ แแแแขแคแแ แแแก แแแแแ แฎแแแก แฃแฌแงแแแก แแแแงแแแแแแแก แฉแแแแขแแแก แแแแแแแ แแชแแแแแแก แแ แฎแแ แฏแแแแก แแแแขแ แแแแก แแแแแกแแแ แแกแแ แแ แซแแแแแแแแแ แกแขแ แแขแแแแฃแแ แฃแแแ แแขแแกแแแแก แจแแแแ แฉแฃแแแแแก.
แ แแแแแแแแ แฌแแแก แฌแแ แแกแแแแกแ แ แแ แฎแแแแแแ แแแแแแแชแแแแแก แจแแแฃแจแแแแแแจแ แแ แแแแแแฌแแแ แแแแ แแกแแ แแแกแแแแก, แฐแแแ แแแฃแแ แฆแ แฃแแแแแแก, IT แแแขแแแแขแแแแชแแแกแ แแ แกแฌแ แแคแ แแ แแชแแกแแแแก แแแฉแแแ. แแ แงแแแแแคแแ แแแ แแแกแแแแแแแแแแแ IT แแ แแคแแกแแแแแแแแแ แแแแแ แแแก แแแแขแแแแแ แแแก, แแฃแแแ แแแขแแแก แแ แฆแแ แฐแแแ แแแฃแ แฆแ แฃแแแแแก.
แแก แแแแแชแแแแแแ แแฎแแ แแแแแแงแแแแแ แแ-แแก แแแแแฌแแแแแแแ แแแกแฃแฎแแก แแแกแแชแแแแ. แกแฌแแ แแ แแแแขแแ, IT แแ แแคแแกแแแแแแแแ แแจแแแแแแ แแแแขแคแแ แแแแก, แ แแแแแแแช แแแแขแแแแแ แแแ แแแคแฃแซแแแแฃแแ, แกแแจแฃแแแแแแก แแซแแแแก แจแแฅแแแแก AI/ML แกแแ แแแกแแแ แกแฌแ แแคแ แแ แแชแแกแแแแก แคแแ แแแแแจแ, แแฉแฅแแ แแแก แแแแแแชแแแก แแ แแแแแฃแแแ แฐแแแ แแแฃแแ แฆแ แฃแแแแกแแแ.
แฉแแแ แแแแแฌแงแแแ แแกแแแ แแแแขแคแแ แแแก แจแแฅแแแแก Red Hat OpenShift-แแ, แฉแแแแ แแแแขแแแแแ แแแแแฃแแ Kubernetes แแแแขแคแแ แแแ แฐแแแ แแแฃแแ แฆแ แฃแแแแกแแแแก, แ แแแแแกแแช แแฅแแก แแ แแแ แแแฃแแ แแ แแแแ แแขแฃแ แแก ML แแแแแฌแงแแแขแแแแแแแแก แกแฌแ แแคแแ แแแแ แแ แแแแกแแกแขแแแ (NVIDIA, H2O.ai, Starburst, PerceptiLabs แแ แ.แจ.). Red Hat-แแก แแแแแแ แแแ แแแแฎแแแ แแแแแแ, แ แแแแ แแชแแ BMW Group, ExxonMobil แแ แกแฎแแแแ, แฃแแแ แแแแแแแแกแแก แแแแขแแแแแ แแแแแฃแแ ML แฎแแแกแแฌแงแแแแแก แฏแแญแแแแ แแ DevOps แแ แแชแแกแแแ แแแแขแคแแ แแแกแ แแ แแแกแ แแแแกแแกแขแแแแก แแแแแ, แ แแแ แแแแ ML แแ แฅแแขแแฅแขแฃแ แแแ แฌแแ แแแแแแแแ แแแแงแแแแแ แแ แแแแฉแฅแแ แแ แแแแแชแแแแ แแแแแแขแแแแกแแแแก แแฃแจแแแแ.
แแแแแ แแ แแ แแแแแแ, แ แแก แแแแแช แฉแแแ แแแแแฌแงแแ Open Data Hub แแ แแแฅแขแ, แแ แแก แแ แฅแแขแแฅแขแฃแ แแก แแแแแแแแแก แแแแแแกแขแ แแ แแแ, แ แแแแแแช แแแคแฃแซแแแแฃแแแ แ แแแแแแแแ แฆแแ แแแแแก แแ แแแ แแแฃแ แแ แแแฅแขแแ แแ แแแฉแแแแแ, แแฃ แ แแแแ แฃแแแ แแแแฎแแ แชแแแแแแก ML แแแแแฌแงแแแขแแก แแแแแ แกแแกแแชแแชแฎแแ แชแแแแ, แ แแแแแแช แแแคแฃแซแแแแฃแแแ OpenShift แแแแขแคแแ แแแแ.
แแแฎแกแแแแ แแแแแชแแแแ แฐแแ แแ แแแฅแขแ
แแก แแ แแก แฆแแ แแแแแก แแ แแแฅแขแ, แ แแแแแแช แจแแแฃแจแแแแแฃแแแ แแแแแแแแ แแแแก แจแแกแแแแแแก แกแแแแแแแแแแแจแ แแ แแฎแแ แชแแแแแแก แแแแ แแชแแแแแก แกแ แฃแ แชแแแแก - แกแแฌแงแแกแ แแแแแชแแแแแแก แฉแแขแแแ แแแแแแ แแ แขแ แแแกแคแแ แแแชแแแแแ แแแแแแแก แแแแแ แแ แแแแแแ, แกแฌแแแแแแแกแ แแ แจแแแแ แฉแฃแแแแแแแ - AI / ML แแ แแแแแแแแแก แแแแแญแ แแกแแก แแแแขแแแแแ แแแแก แแ Kubernetes-แแก แแแแแงแแแแแแ OpenShift-แแ. แแแแขแคแแ แแ. แแก แแ แแแฅแขแ แจแแแซแแแแ แฉแแแแแแแแก แกแแชแแแแแ แ แแแแแแแแแขแแชแแแ, แแแแแแแแแ, แแฃ แ แแแแ แฃแแแ แแแแจแแแแ แฆแแ AI/ML-as-a-service แแแแแฌแงแแแขแ OpenShift-แแ แแ แแแกแแแ แแแแแแจแแ แแแฃแ แฆแแ แแแแแก แแแกแขแ แฃแแแแขแแแแ, แ แแแแ แแชแแ Tensorflow, JupyterHub, Spark แแ แกแฎแแ. แแแแจแแแแแแแแแแ แแฆแแแแจแแแก, แ แแ แแแแแ Red Hat แแงแแแแแก แแ แแ แแแฅแขแก แแแแแกแ AI/ML แกแแ แแแกแแแแก แฃแแ แฃแแแแแกแแงแแคแแ. แแแ แแ แแแแกแ, OpenShift แแแขแแแ แแ แแแแ NVIDIA-แก, Seldon-แแก, Starbust-แแกแ แแ แกแฎแแ แแแแฌแแแแแแแแแก แซแแ แแแแแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแกแ แแ แแแแ แแขแฃแ แแก ML แแแแแฌแงแแแขแแแแแแแแแ, แ แแช แแแแแแแแแก แกแแแฃแแแ แ แแแแฅแแแฃแ แ แกแฌแแแแแแแก แกแแกแขแแแแแแก แจแแฅแแแแก แแ แแแจแแแแแก.
Open Data Hub แแ แแแฅแขแ แแ แแแแขแแ แแแฃแแแ แแแแฎแแแ แแแแแแ แจแแแแแ แแแขแแแแ แแแแแ แแ แแแแแงแแแแแแก แจแแแแฎแแแแแแแ:
- แแแแแชแแแแ แแแแแแขแแแแกแ, แ แแแแแกแแช แกแญแแ แแแแ แแแแแฌแงแแแขแ ML แแ แแแฅแขแแแแก แแแแกแแฎแแ แชแแแแแแแแ, แแ แแแแแแแแฃแแ แฆแ แฃแแแแแแแ แแแแแแแแกแแฎแฃแ แแแแก แคแฃแแฅแชแแแแแ.
- แแแแแชแแแแ แแแแแแขแแแแกแ, แ แแแแแกแแช แกแญแแ แแแแ แแแฅแกแแแแแฃแ แ แแ แฉแแแแแ แฃแแฎแแแกแ แฆแแ AI/ML แแแกแขแ แฃแแแแขแแแแแแ แแ แแแแขแคแแ แแแแแแแ.
- แแแแแชแแแแ แแแแแแขแแแแกแ, แ แแแแแกแแช แกแญแแ แแแแ แแแแแชแแแแ แฌแงแแ แแแแแ แฌแแแแแ แแแแแแแแแก แแแแแแแแแแกแแก.
- แแแแแชแแแแ แแแแแแขแแแแกแ, แ แแแแแกแแช แกแญแแ แแแแ แฌแแแแแ แแแแแแแแแ แ แแกแฃแ แกแแแแ (CPU, GPU, แแแฎแกแแแ แแแ).
- แแแแแชแแแแ แแแแแแขแแแแกแ, แ แแแแแแช แแแแแฎแแแก แแแแแแแแแแ แแแแแแจแ แแแแแแแกแ แแ แกแแแฃแจแแแก แแแแแแ แแแแก แฃแแแ แก, แแแแฆแแก แฃแแฃแแแแจแแ แ แแ แแแแฃแแฏแแแแกแแก แกแฌแ แแคแ แแแแแแ แแแ.
- แแแแแชแแแแ แแแแแแขแแแแกแ, แ แแแแแกแแช แกแฃแ แก แฃแ แแแแ แแฅแแแแแแ แแแแแแแแแ แแแแแ (แแ แแฌแแ แแแแแก แแฃแแแแแก) แแกแ, แ แแ แแแกแ ML แแแแแแแแ แแ แกแแแฃแจแแ แจแแแแแแแ แแแแแแแแแก แฌแแ แแแแแแจแ.
- แแแแแชแแแแ แแแแแแแ แ, แ แแแแแกแแช แกแญแแ แแแแ แแแแแชแแแแ แแแแแแขแแแแกแแกแแแแก แฌแแแแแ แแแแแชแแแแ แแ แแแแแคแแ แแแแ แฌแงแแ แแแ, แแแ แแแฃแแแ แแแแแ แแ แฃแกแแคแ แแฎแแแแแก แแแแฎแแแแแแแก แแแชแแแ.
- IT แกแแกแขแแแแก แแแแแแแกแขแ แแขแแ แ/แแแแ แแขแแ แ, แ แแแแแแช แแแแแฎแแแก แฆแแ แแแแแก แแแแแแแแแขแแแแกแ แแ แขแแฅแแแแแแแแแแก แกแแกแแชแแชแฎแแ แชแแแแแก (แแแกแขแแแแชแแ, แแแแคแแแฃแ แแชแแ, แแแแแฎแแแแ) แซแแแแกแฎแแแแแก แแแ แแจแ แแแแขแ แแแแก แฃแแแ แก. แฉแแแ แแกแแแ แแแญแแ แแแแ แจแแกแแแแแแกแ แแแ แแแแกแ แแ แแแแขแแ แแแแก แแแกแขแ แฃแแแแขแแแ.
Open Data Hub แแ แแแฅแขแ แแแ แแแแแแแก แฆแแ แแแแแก แแแกแขแ แฃแแแแขแแแแก แแแแ แ แแแก AI/ML แแแแ แแชแแแแแก แกแ แฃแแ แชแแแแแก แแแแกแแฎแแ แชแแแแแแแแ. Jupyter Notebook แแฅ แแแแแแงแแแแแ, แ แแแแ แช แซแแ แแแแแ แกแแแฃแจแแ แแแกแขแ แฃแแแแขแ แแแแแชแแแแ แแแแแแขแแแแกแแแแก. แแแกแขแ แฃแแแแขแแ แแแแ แแแ แแฆแแก แคแแ แแ แแแแฃแแแ แแแแ แกแแ แแแแแแแก แแแแแชแแแแ แแแชแแแแ แแ แจแแ แแก แแ Open Data Hub แกแแจแฃแแแแแแก แแซแแแแก แแแ แแแ แขแแแแ แจแแฅแแแแ แแ แแแ แแแ Jupyter Notebook แกแแแฃแจแแ แกแแแ แชแแแแ แฉแแจแแแแแฃแแ JupyterHub-แแก แแแแแงแแแแแแ. แแฃแแแขแแ แแก แแแฃแแแฃแฅแแแแก แจแแฅแแแแกแ แแ แแแแแ แขแแก แแแ แแ, Open Data Hub แแ แแแฅแขแ แแกแแแ แจแแแชแแแก แแแ แแแฃแแแฃแฅแแแก AI แแแแแแแแแแแก แกแแฎแแ.
แแก แแแแแแแแแแ แแ แแก แฆแแ แแแแแก แแแแฅแแแฃแ แ แกแฌแแแแแแแก แแแแแแแแแขแแแแกแ แแ แแแแแฌแงแแแขแแแแแแแแก แแแแแฅแชแแ แกแแแ แแ แกแชแแแแ แแแแกแแแแก, แ แแแแแแแช แแแแ แขแแแแแก แกแฌแ แแค แแ แแขแแขแแแแแก. JupyterHub แแแขแแแ แแ แแแฃแแแ OpenShift-แแก RBAC แฌแแแแแแก แแแแแแแแ, แ แแแแแแช แกแแจแฃแแแแแแก แแแซแแแแ แแแแแแงแแแแ แแ แกแแแฃแแ OpenShift แแแแแ แแจแแแ แแ แแแแแฎแแ แชแแแแแ แแ แแแแแ แจแแกแแแ. แแแ แแ แแแแกแ, JupyterHub แแแแแแแแแ แแแกแแฎแแ แฎแแแแแ แแแแฎแแแ แแแแแก แแแขแแ แคแแแกแก แกแแฎแแแฌแแแแแแ spawner, แ แแแแแก แแแจแแแแแแแแช แแแแฎแแแ แแแแแก แจแแฃแซแแแ แแแ แขแแแแ แแแแแแแคแแแฃแ แแ แแก แแแแแแแแแแ แ แแกแฃแ แกแแแแก แ แแแแแแแแ (CPU แแแ แแแแแ, แแแฎแกแแแ แแแ, GPU) แจแแ แฉแแฃแแ Jupyter Notebook-แแกแแแแก.
แแแก แจแแแแแ, แ แแช แแแแแชแแแแ แแแแแแขแแแแกแ แฅแแแแก แแ แแแแแแแคแแแฃแ แแ แแแก แแแแขแแแก, แแแกแแ แงแแแแ แกแฎแแ แแ แแแแแแแแ แแ แฃแแแแก Kubernetes-แแก แแแแ แแแ, แ แแแแแแช แแ แแก OpenShift-แแก แแแฌแแแ. แแแแฎแแแ แแแแแแก แจแแฃแซแแแแ แแฎแแแแ แแแแแแแแ แแฅแกแแแ แแแแแขแแแแก แฉแแขแแ แแแ, แแแแ แแฃแจแแแแแก แจแแแแแแแแก แจแแแแฎแแ แแ แแแแแแ แแแ. แแแ แแ แแแแกแ, แแแฌแแแแแ แแแแฎแแแ แแแแแแก แจแแฃแซแแแแ แแแ แแแแแ แฌแแแแแ OpenShift CLI แแแ แกแแ แแแ แแแแแ Jupyter-แแก แแแฃแแแฃแฅแแแแแแ, แ แแแ แแแแแแงแแแแ Kubernetes แแ แแแแขแแแแแ, แ แแแแ แแชแแ Job แแ OpenShift แคแฃแแฅแชแแแแ, แ แแแแ แแชแแ Tekton แแ Knative. แแ แแแแกแแแแก แจแแแแซแแแแ แแแแแแงแแแแ OpenShift-แแก แแแกแแฎแแ แฎแแแแแ GUI, แ แแแแแกแแช แแฌแแแแแ "OpenShift แแแ แแแแกแแแ".
แจแแแแแ แแขแแแแ แแแแแกแแแ, Open Data Hub แจแแกแแซแแแแแแก แฎแแแก แแแแแชแแแแ แแแแกแแแแแแแแก แแแ แแแแก. แแแแกแแแแแก แแแแแแงแแแแแ Ceph แแแแแฅแขแ, แ แแแแแแช แแแชแแแฃแแแ แ แแแแ แช S3-แแแ แแแแกแแแแแ แแแแแฅแขแแก แแแแแชแแแแ แกแแชแแแ. Apache Spark แกแแจแฃแแแแแแก แแแซแแแแ แแแแแแขแแแแ แแแแแชแแแแแ แแแ แ แฌแงแแ แแแแแแแ แแ แฉแแจแแแแแฃแแ Ceph S3 แกแแชแแแแแแ, แแกแแแ แแแซแแแแ แกแแจแฃแแแแแแก แจแแแกแ แฃแแแ แฌแแแแกแฌแแ แ แแแแแชแแแแแแก แขแ แแแกแคแแ แแแชแแแแ. Apache Kafka แฃแแ แฃแแแแแงแแคแก แแแแแชแแแแ แแแแกแแแแแแแแก แแแคแแ แแแแแฃแ แแแ แแแแก (แกแแแแช แแแแแชแแแแ แแ แแแแแฏแแ แฉแแขแแแ แแแ แจแแกแแซแแแแแแแ, แแกแแแ แแแแแชแแแแ แขแ แแแกแคแแ แแแชแแ, แแแแแแแ แแ แแแแ แแแ แแแแ แแชแแแแ).
แแกแ แ แแ, แแแแแชแแแแ แแแแแแขแแแแกแแ แแแแฆแ แแแคแแ แแแชแแ แแ แจแแฅแแแ แแแแแแ. แแฎแแ แแแก แแฅแแก แกแฃแ แแแแ, แแแฆแแแฃแแ แจแแแแแแแ แแแฃแแแแ แแก แแแแแแแแก แแ แแแแแแแชแแแก แจแแแฅแแแแแแแก แแ แแแแฌแแแแก แแแ แแแแแกแ แแแแแแ แกแแ แแแกแแก แแ แแแชแแแแแแ. แแแแกแแแแแก แกแแญแแ แแ แแแกแแแแแแแก แกแแ แแแ แ แแ Open Data Hub-แก แแฅแแก แแกแแแ แกแแ แแแ แ, แแแก แฐแฅแแแ Seldon แแ แแแซแแแแ แกแแจแฃแแแแแแก แแแแแแฅแแแงแแแ แแแแแแ, แ แแแแ แช RESTful แกแแ แแแกแ.
แ แแฆแแช แแแแแแขแจแ, Seldon แกแแ แแแ แแ แ แแแแแแแแ แแกแแแ แแแแแแแ แแ แกแแญแแ แแ แแแแ แแแแแงแแแแแแก แแแแแขแแ แแแแ. แแแแก แแแกแแฆแฌแแแแ, Open Data Hub แแแแแแแแแ แจแแกแแแแแแกแ แแแขแ แแแแก แแแแแฅแชแแแก แแ แกแแแแแแ แแจแ แซแ แแแแก, แ แแแแแแช แแแคแฃแซแแแแฃแแแ แคแแ แแแ แแแแแงแแแแแฃแ แฆแแ แแแแแก แแแแแขแแ แแแแแก แแแกแขแ แฃแแแแขแแแแ Prometheus แแ Grafana. แจแแแแแแ, แฉแแแ แแแฆแแแ แแแแแฎแแแฃแ แแแแก AI แแแแแแแแแก แแแแแงแแแแแแก แแแแแขแแ แแแแแกแแแแก, แแแแกแแแฃแแ แแแแ แกแแฌแแ แแแ แแแ แแแแจแ.
แแแแแแ แแ, Open Data Hub แฃแแ แฃแแแแแงแแคแก แฆแ แฃแแแแก แแกแแแแก แแแแแแแแก AI/ML แกแแกแแชแแชแฎแแ แชแแแแแก แแแแแแแแแแแจแ, แแแแแชแแแแ แฎแแแแแกแแฌแแแแแแแแกแ แแ แแแแแแแแแแแแ แแแฌแงแแแฃแแ แแแแแแแก แกแฌแแแแแแแแแ แแ แฌแแ แแแแแแแแ.
แแงแแแแแก แงแแแแ แแ แแแ
แแฎแแ แฉแแแแแ แแแแฎแแ, แแฃ แ แแแแ แฃแแแ แแแแฌแงแแ แแก แงแแแแแคแแ แ OpenShift แแแแแแแกแขแ แแขแแ แแกแแแแก. แแ แแฅ แแแฅแแแแแแก แกแแแชแแแแฃแ แ Kubernetes แแแแ แแขแแ แ Open Data Hub แแ แแแฅแขแแแแกแแแแก.
แแก แแแแ แแขแแ แ แแแ แแแแก Open Data Hub-แแก แแ แแแฅแขแแก แแแกแขแแแแชแแแก, แแแแคแแแฃแ แแชแแแก แแ แกแแกแแชแแชแฎแแ แชแแแแก, แแแ แจแแ แแก แแแแแแฆแแแจแแฃแแ แฎแแแกแแฌแงแแแแแก แแแแแงแแแแแแก, แ แแแแ แแชแแ JupyterHub, Ceph, Spark, Kafka, Seldon, Prometheus แแ Grafana. Open Data Hub แแ แแแฅแขแ แจแแแแซแแแแ แแฎแแแแ OpenShift แแแ แแแแกแแแจแ, แกแแแแแแแแแแแก แแแแ แแขแแ แแแแก แแแแงแแคแแแแแแจแ. แแแ แแแแ, OpenShift-แแก แแแแแแแกแขแ แแขแแ แก แจแแฃแซแแแ แแแแแแแแ แแขแแก, แ แแ แจแแกแแแแแแกแ OpenShift แแ แแแฅแขแแแ แแแขแแแแ แแแแแฃแแแ, แ แแแแ แช "Open Data Hub แแ แแแฅแขแ". แแก แแแแแแแ แแ แแฎแแ. แแแแก แจแแแแแ, แแแแแชแแแแ แแแแแแขแแแแกแ แจแแแแก แแแแแกแ แแ แแแฅแขแแก แกแแแ แชแแจแ OpenShift แแแ แแแแกแแแแก แแแจแแแแแแ แแ แฎแแแแแก, แ แแ แจแแกแแแแแแกแ Kubernetes แแแแ แแขแแ แ แแ แแก แแแแแกแขแแแแ แแแฃแแ แแ แฎแแแแแกแแฌแแแแแ แแแกแ แแ แแแฅแขแแแแกแแแแก. แจแแแแแ แแก แฅแแแแก Open Data Hub แแ แแแฅแขแแก แแแแแแแแก แแ แแ แแแฌแแแแฃแแแแแ แแ แแแฃแงแแแแแแแแ แแฅแแก แฌแแแแแ แแแแแ แแฆแฌแแ แแ แแแกแขแ แฃแแแแขแแแแ. แแ แแ แงแแแแแคแ แแก แแแแคแแแฃแ แแชแแ แจแแกแแซแแแแแแแ แแแฆแแแ แฎแแแแแกแแฌแแแแแแแแกแ แแ แฎแแ แแแแแแแก แขแแแแ แแแขแแแแก แ แแแแแจแ.
แแฃ แแกแฃแ แ แกแชแแแแ Open Data Hub แแ แแแฅแขแ แแฅแแแแแแแก, แแแแฌแงแแ
แจแแแแฎแกแแแแแ: แแแกแจแขแแแแก แกแแ แแแแฃแแ แแแแแฌแแแแแแ แฎแแแก แฃแจแแแก แแ แแแแแแแชแแแแก แฎแแแแแแฃแ แ แแแขแแแแฅแขแแกแ แแ แแแแฅแแแแแแชแแแแแแแแก แกแ แฃแแ แแแขแแแชแแแแแก แ แแแแแแแแแจแ. Red Hat OpenShift แฃแแแ แแแแ แฎแแแแ แฌแแ แแแขแแแแ แแแแแแงแแแแแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแแแฃแกแขแ แแแจแ แแกแแแแกแ แแ แแแแแแแแแก แแแแแกแแญแ แแแแ. Open Data Hub แแ แแแฅแขแ, แ แแแแแแช แแแแฎแแ แชแแแแแแฃแแแ แฆแแ แแแแแก แแแแแแแแ แแแแก แกแแแแแแแแแแแจแ, แแแแแแแแแ แกแแชแแแแแ แ แแ แฅแแขแแฅแขแฃแ แแก AI/ML แแแแ แแชแแแแแก แกแ แฃแแ แชแแแแแก แแ แแแแแแแแแกแแแแก OpenShift แฐแแแ แแแฃแแ แฆแ แฃแแแแก แกแแคแฃแซแแแแแ. แฉแแแ แแแแฅแแก แแแแคแแ แแ แแแแแ แแแฃแแ แแแแแ แแ แแ แแแฅแขแแก แแแแแแแแ แแแแกแแแแก แแ แกแแ แแแแฃแแแ แแแ แ แแแก แแ แแแแแ แแฅแขแแฃแ แ แแ แแแงแแคแแแ แ แกแแแแแแแแแแแก แจแแกแแฅแแแแแแ OpenShift แแแแขแคแแ แแแแ แฆแแ AI แแแแแฌแงแแแขแแแแแแแแก แจแแแฃแจแแแแแแกแแแแก.
แฌแงแแ แ: www.habr.com