แแแแกแแก แแแแแก
แแแแแฌแแแแแ แ แแแแแแแแ:
- แแแแแแ แแแขแแแแแ, ITSumma-แก แแฆแแแกแ แฃแแแแแแ แแแ แแฅแขแแ แ. แแแกแ แแแแฎแแแ แแแแแแแก แแแฎแแแแ แแ แแแขแ แแ แฃแแแ แแแแแแแก แแ แกแฃแ แก Kubernetes-แแ แแแแแกแแแ.
- แแแแแขแ แ แกแขแแแแแ แแแ, CTO "Flant". แแฅแแก แแแแขแแแแแ แฃแ แกแแกแขแแแแแแแ แแฃแจแแแแแก 10+ แฌแแแแแ แแแแแชแแแแแแ.
- แแแแแก แ แแแฉแฃแแแแ (แแแฃ แแ แแ แแแแแแแ), COO argotech.io, แงแแคแแแ RAO UES. โแกแแกแฎแแแแโ แกแแฌแแ แแแจแ แจแแแแฎแแแแแแแ แกแแฃแแแ แ แแแฐแแแ แแ.
- แแแแ แแ แคแแแแ แแแกแแ, CTO "News360.com"แกแฎแแ แแแแแแแจแแก แแแแ แแแแแแแแแก แจแแซแแแแก แจแแแแแ, แแก แแแกแฃแฎแแกแแแแแแแแ ML แแ AI แแ แแแฅแขแแแแ แแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแแ.
- แแแแ แแ แฃแแแแแ, แกแแกแขแแแแแแก แแแแแแแ แ, แงแแคแแแ Booking.com.แแแแแ แแแแแแแแ, แ แแแแแแแช แแแแ แ แ แแ แแแแแแแ แแฃแแแ แแแขแแกแแแ แกแแแฃแแแ แ แฎแแแแ.
แแแแแแ:
- แแแแแฌแแแแแ แจแแฎแแแฃแแแแแแ แแแแขแแแแแ แแแแกแ แแ แแ แแแกแขแ แแ แแแแก แจแแกแแฎแแ (Docker, Kubernetes แแ แ.แจ.); แ แแช แแ แแฅแขแแแแจแ แกแชแแแแก แแ แแแแแแแแแแก.
- แกแแฅแแ: แแแแแแแแ แฌแแแแแก แแแแแแแแแแแจแ แแจแแแแแก แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแแแแแแแ แแแแก แแแแแแก. แ แแแแ แแแแฆแแแ แแแแแฌแงแแแขแแแแแ, แแจแแแแแก (แแ แแแแแแขแแแแก แแแแแแแแแแแ) แแแคแ แแกแขแ แฃแฅแขแฃแ แ แแแแขแแแแแ แแแกแ แแ แแฃแแแ แจแ?
- แแ แแแแแแแแ แฆแ แฃแแแแแ แกแแแงแแ แแจแ, แ แ แแแแแ, แฌแแ แแแแแแแแแแ แ แ แแฅแแแแ แฎแแแ.
แกแแแแขแแ แแกแ แแแกแแฃแกแแ แแแแแแ แแ, แแแแแฌแแแแแ แแแกแแแ แแแแแ แแแแแแแ แแแแกแฎแแแแแแฃแแ แแงแ แแ แแแแแแ แแแแแแขแแ แ แแแแแแฌแแแ, แ แแ แแแแแ แแแแแแแแ แแ. แญแแแ
แแ แแก Kubernetes แฃแแแ แกแขแแแแแ แขแฃแแ แแฃ แจแแกแแแแจแแแแ แแแ แแแขแแแแ?
โแฉแแแ แแแแแแแ แแแกแแ (Kubernetes. - แ แแ.), แ แแแแกแแช แฏแแ แแ แแแแ แแชแแแ แแแแก แจแแกแแฎแแ. แฉแแแ แแแกแแแ แแแจแแแแช แแแแแแแ, แ แแชแ แแฅ แแ แแงแ. แแแ แ แแแแแแแแ" - แแแแแขแ แ แกแขแแแแแ แแแ
แคแแขแ Reddit.com-แแแ
5-10 แฌแแแก แฌแแ แแงแ แฃแแแ แแแแแ แ แ แแแแแแแแแก แแแ แแฆแแแ แแ แแ แแ แกแแแแแแ แแ แแแแแ แกแขแแแแแ แขแ. แงแแแแ แแฅแแก แแแแจแ แฉแแแแแแแ แแฎแแแ แแ แแแฃแฅแขแ, แแ แแฃแแแแช แแ แแแ แแแขแ. แฏแแ แแแฌแแแฌแแแ, แแแ แ แแแ แแแ, แจแแค, แแแฏแแแ,... โแแ แจแแ แงแแแแ แแฅแแก แแแแจแ แแ แแฎแแ แแแจแแแแ แจแแแก แแแคแ แแกแขแ แฃแฅแขแฃแ แแก. แแฅแแแ แแงแแแ แฎแฃแแ แแแแแแแกแขแ แแขแแ แ, แ แแแแแแแช แแแแฃแแแแแแ แแ แแแ แแแแแแแแฃแแแ แแแแคแแแฃแ แแชแแแแแก แแแแแฌแแ แแโ, - แแฎแกแแแแแก แแแแ แแ แคแแแแ แแแกแแ. แแแก แแแแฉแแแ, แ แแ Docker-แแ แแ Kubernetes-แแ แแแแแ แฉแแแแแ "แแแแแแแแกแฃแคแแแก". Docker แแแฎแแ แกแขแแแแแ แขแ แแแแ แฎแฃแแ แฌแแแก แแแแแแแแแแแจแ, Kubernetes แแแแ แแ แ แฌแแแก แแแแแแแแแแแจแ. แแ แแก แแแ แแแ แแแแฃแกแขแ แแแกแแแแก..
แแแแแขแ แ แกแขแแแแแ แแแก แแ แแแก แแฃแแแก แฃแงแแแ แ แแฃแแแ แ. แแแ แกแฃแ แแแ แแกแแแ แฎแแแกแแฌแงแ, แกแแแแ แแก แแแแแฉแแแแแแแ แแ แแแแแแแแ, แ แแชแ แแ แแแแ แแชแแแ แแแแก แจแแกแแฎแแ. แแแแแแแ, แแแฎแแ แฎแแแฃแแแแแก แแแแ, แแกแแแ แแ แแฆแแแแ แแแแแแขแก, แแฃ แแกแแแ, แ แแ แแกแแแ แแ แแแแแฎแแ แชแแแแแแแ แแฃแแแ แแแขแแแก แแแกแแแ. แแแแแแ แแฃแแแ, แแแแแขแ แแก แแฅแแแ, แแแแแแแแแก แแฅแแก "แแแแ แ แแแแแแขแฃแ แ แฌแแ แแแขแแแแก แแกแขแแ แแ แกแแจแแแแแ แแแแแแแแ แแแแแก แแแแแแแแแแแก แจแแกแแฎแแ".
Kubernetes แแ แแ แแก แแฎแแแแ แแแแขแแแแแ แแแแก แแ แแแกแขแ แแ แแแ, แแก แแ แแก แแแแคแแแฃแ แแชแแแก แแแ แแแแก แกแแกแขแแแ แแแแแแแแ แแแฃแแ API, แฅแกแแแแก แแแแแแแแแขแ, L3 แแแแแแกแแ แแแ แแ Ingress แแแแขแ แแแแ แแแ, แ แแช แจแแแแ แแแแ แแแ แขแแแก แฎแแแก แ แแกแฃแ แกแแแแก แแแ แแแแก, แแแกแจแขแแแแแก แแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แฅแแแแ แคแแแแแแแแ แแแกแขแ แแฅแขแก.
แกแแแฌแฃแฎแแ แแ, แฉแแแแก แชแฎแแแ แแแแจแ แงแแแแแคแ แแก แแแแแฎแแ แแแแฌแแแก. แแ แแก แแแแแกแแฎแแแ แแแแแ, แแแแกแแแฃแแ แแแแ แแฃ แแกแแฃแแ แแแ แแแแแแแแ แแแฃแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแฅแแแ แแแแแแแแแก Kubernetes-แแ แแแแแกแแแแแ, แ แแแแ แช แแแแ แแ แฃแแแแแ แแแแแก. แแแก แแแแแกแฃแคแแแ แจแแแซแแ แแฃแจแแแแ แ แแแแ แช แขแ แแแแชแแฃแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแฅแแแ แแแแแแแแแจแ, แแกแแแ แแฃแแแ แแแ. แแแแแแ แแ, แแแแแแแ แแแแแแแแแกแ แแ แแแแ แแก แแแฎแแกแแแแแแแแแ. แแแแ แแ, แแแแแแแแแ, แแแแแแ แแแขแแแแแแกแแแแก, แ แแแแแแช แแแแแแแแแแแแก แแฃแแแ แแแขแแแก แแแแขแแแแแ แแแแก แแ แแแกแขแ แแ แแแแก แแแแแกแแแแ แแแกแขแ แฃแแแแขแแ, แแกแแแ แแแแฎแแ แแ แฉแแแแแ.
แแแแแแแ แแแแแแแแ แแแแแแแ 1990-แแแ แฌแแแแจแ แแ แกแแแฃแ แกแแขแฃแแชแแแกแแแ, แ แแแแกแแช แแแแแฉแแแ แแแแแฅแขแแ แแ แแแแขแแ แแแฃแแ แแ แแแ แแแแ แแแ, แ แแแแ แช แ แแฃแแ แแแแแแแชแแแแแก แแ แแแ แแแแ แแแแก แกแแจแฃแแแแแ. แแ แแ แแก แแแแแขแแแ แแแแ แซแแแแ แแ แแฎแแแ แแแกแขแ แฃแแแแขแแแ แแแแแฉแแแ OOP-แแก แแฎแแ แแแกแแญแแ แแ. แจแแแแแ แแแฉแแแ แแแแ แแกแแ แแแกแแแ, แ แแแแ แช แแแแแแแแฃแ แ แแแแชแแคแชแแแกแแแ แแแแแก แแแฆแฌแแแแก แกแแจแฃแแแแแ. แแแแ, แแแแแก แแฎแ แแ, แแแแแแฌแแแ แแแแขแแแแแ แแแแกแ แแ แแแแขแแแแแ แแแแก แแแ แแแแก แแแกแขแ แฃแแแแขแแแแก แแแฉแแแ. โแแคแแฅแ แแ, แ แแ แฉแแแ แแแแ แแแแแแ แแ แแ แแแแ, แ แแแแกแแช แแ แแแแแแแ แแแแฎแแ, แฆแแ แก แแฃ แแ แ แแชแแ แ แแแแ แแกแแ แแแกแแก แแแแแชแฎแแแแก แแแฌแแ แ, แแก แกแขแแแแแ แขแฃแแแ แแแแฌแแ แแแ แ แแแแ แช แแแแ แแกแแ แแแกแโ, - แแแแแก แแก. แแแแแแแแฃแ แแ, Docker แแ Kubernetes แกแแแแแแแ แแแฎแแแแแแ แกแขแแแแแ แขแฃแแ แแแแแฌแงแแแขแ แแ แฉแแแแแแก แกแแญแแ แแแแแก แแแ แแจแ.
แแแแแชแแแแ แแแแแแแก แแ แแแแแแ แแแฅแแแแฅแแแแแก แแ แแฅแแแแแแจแ
แคแแขแ
แแฆแแกแแฆแแแแแ, Kubernetes-แจแ แแแแแชแแแแ แแแแแแแก แแแจแแแแแก แแ แแแแแ แ แแชแแแขแ แแ แกแแแแแก. แแฃแแแแช แ แแแแ แแแแแแงแแ แแแฌแแแ, แ แแแแแแช แแฃแจแแแแก I/O แแแกแแแแ, แแแ แแแแแแ, แแแแแชแแแแ แแแแแก แแแแแแแชแแแก แแแฌแแแแกแแแ. แจแแกแแซแแแแแแแ แแฃ แแ แ, แ แแ แแแแแแแแจแ แแแแแชแแแแ แแแแแแ แแแแแแแ แจแแแชแแแแแก, แ แแ แแแฌแแแแแฃแแ แแฅแแแก แงแฃแแจแ, แกแแแแช แแ แแ แแแฌแแแ แแฅแแแแ แแ แแแกแขแ แแ แแแฃแแ Docker-แแก แแ Kubernetes-แแก แแแจแแแแแแ, แฎแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแแแ แ แแแฌแแแจแ, แชแแแแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แกแแจแฃแแแแแแ, แฃแแ แฃแแแแแงแแคแแแ แแฅแแแแ แจแแแแฎแแแก แแแฌแแแ. ? แจแแแชแแแแแ แแฃ แแ แ แแแแแแ แแ แแแฃแฅแขแแก แกแแฎแแ?
แแก แแฆแฌแแ แ แ แแแแก แแแ แแแแก แแกแแแแกแแ, แแแแ แแ แขแ แแแแชแแฃแ แแแแแชแแแแ แแแแแแจแ แแแคแแ แแแชแแแก แกแแแแแแแแกแ แแ แกแแแฅแ แแแแแแชแแแก แแแแฎแแแแแแ แแแชแแแแแแ แแแฆแแแแ, แแแแฉแแแแก แแแแ แแ. แฅแแจแแก แแแ แขแงแแแก แแแแคแแชแแแแขแ แแแ แแแแฃแ แแแแแชแแแแ แแแแแแจแ แ แฉแแแ 99%. แแฃ แแฃแจแแแ แฉแแแแแแก, แแฎแแแ แแฎแกแแแแ แแ แฅแแจแ โแแแแแโ แแฃแแแแแ. แกแแแแ แฅแแจแ แแ แแแชแฎแแแแแแ, แแฃแจแแแ แแแแ แแฃแจแแแแก, แ แแช แแแแก แแแจแแแแก, แ แแ แแแกแ แฉแแขแแแ แแแ แจแแฃแซแแแแแแแ แแแแฎแแแ แแแแแก แแแขแแแ แแแแ. แกแแแแ แแแแฎแแแ แแแแแก แแแขแแแ แแแ แแ แแ แแก, แฅแแจแ แแ แแแแแแก. แแแฏแแแแแแฃแแ แฌแ แแ.
แแแแแขแ แ แคแฃแแแแแแแขแฃแ แแ แแ แแแแแฎแแแแ - แแแแ แฃแแ แแ แแแจแแ แแ แแแแแแแก แฌแงแแแขแก. แแแแ แแ แแแแ แแ แแแขแแแชแแแก, แ แแ แแแแแกแแแแแ แงแแแแแกแแแแก แจแแกแแคแแ แแกแ แแ แแ แแก. แแแแแแ แ แกแแขแฃแแชแแแจแ แแแแ แฃแแ แจแแกแแคแแ แแกแแ, แแแแ แแ แแก แแแแแขแแแแ แแแขแแแ แแแแก แแงแแแแแก แฅแกแแแก. NoSQL แแแแแชแแแแ แแแแ แแ แแ แแก แจแแกแแคแแ แแกแ แงแแแแ แจแแแแฎแแแแแจแ.
แจแแฎแแแแ แแก แแแแแฌแแแแแแ แแ แแแแแแแ แแแแงแแแแ.
แแแแแกแ แแ แแแแ แแ แแแขแแแชแแแแ, แ แแ แงแแแแแคแแ แ, แ แแช แแฌแแ แแแ แแแกแแแ - แแแแแชแแแแ แแแแแแ แแ แแกแ แจแแแแแ - แจแแฃแซแแแแแแแ แแฃแแแ แแก แแแแแแแแแแ แแแแกแแกแขแแแแจแ. แจแแฃแซแแแแแแแ Kubernetes-แจแ แฌแแ แแแแแแก แแแแแชแแแแแแก แแแแแแแแแแกแ แแ แแแแแแแแแแ แฃแแแแแก แจแแแแ แฉแฃแแแแ. แแก แคแฃแแแแแแแขแฃแ แ แแแแกแแแแ. แแแแแกแแแแแ: แฐแแแ แแแฃแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แ.
แแแแแแแแ แแแ แฆแ แฃแแแแแแแ แแแแแชแแแแ แแแแแแแช แแ, แ แแแแ แแชแแ MongoDB แแ Cassandra, แแ แจแแขแงแแแแแแแแแแก แ แแแแแ, แ แแแแ แแชแแ Kafka แแ RabbitMQ, แกแแญแแ แแแแก แแแแแชแแแแ แแฃแแแแ แแแฆแแแแแแก Kubernetes-แแก แแแ แแ.
แแแแแแ แแแ แแขแแกแขแแแก: โแแฃแแแ แแก แแแแแแ แแ แแก แแแแฅแแแก แ แฃแกแฃแแ แแ แกแแฌแแ แแแก แแแแแแแแแ, แ แแช แแแแแแจแแ แแแฃแแแ แแ แคแแฅแขแแแ, แ แแ แ แฃแกแแแจแ แฆแ แฃแแแแแแก แแแฆแแแ แแ แแ แแก.โ แแแกแแแแแแจแ แแชแแ แ แแฃ แกแแจแฃแแแ แแแแแแแแแแ Cloud แแ แแแ. Amazon RDS แแแแแชแแแแ แแแแแแ แฃแคแ แ แแแแแแ แแแแแกแแงแแแแแแแแ, แแแแ แ แแแแแ Kubernetes-แแแ แจแแฎแแแ. แ แฃแกแแแจแ แแกแแแ แแงแแแแแแ แแฃแแแ แก โแแแขแแ แแแขแจแโ แแ แแแแแแก แแแแแกแชแแแแ แแแก, แ แแชแ แชแแแแแแแ แแแแแแ แแแก แแแจแแ แแแแก.
แแแแแขแ แ แแกแแแ แแ แแแแแแแฎแแ แแแแชแฎแแแแแแก, แ แแ แแฃแแแ แแแขแแกแจแ แแแแแชแแแแ แแแแแก แจแแแแฎแแ แแ แจแแแซแแแแ: โแแแแ แแแแกแฎแแแแแแแ แแแแแกแแแ. แแ แแฃ แแฅแแแ แแแแงแแแแแ แแแแแแขแฃแ แฃแ แแแแ แแแแแ แแแแแชแแแแ แแแแแก, แแแจแแ แแ แแแแแแ แจแแแแฎแแแแแจแ. แแฃ แ แแแแ แฌแแ แแแแแแก แแ แฆแ แฃแแแแแ แแ แกแก, แ แแแแแแช แแแแแแ แแแแ แแแแแแแแแฃแแแ แแแฎแแแ แแ แแคแแแแ แฃแแ แชแฎแแแ แแแแกแแแแก, แงแแแแแคแแ แ แแแ แแแ แแฅแแแแโ. แแแแแขแ แแ แแกแแแ แแฆแแแจแแ, แ แแ แแแแแชแแแแ แแแแแก แแแ แแแแก แแแกแขแ แฃแแแแขแแแ แแ แแ แแก แแแแ แแ แช แแแแแ แแกแแแแก แแ แแ แช แแฃแแแ แแกแแแแก, แแแแขแแ แฌแแ แแแแฅแแแแแ แแแแ แกแแ แแฃแแแแแ.
แแแแแ, แแแแแก แแฎแ แแ, แแแ แฌแแฃแแแแฃแแแ, แ แแ แแฃแแแแช แกแแฎแแแแฌแแคแแแแ แแแแแกแ แแ แแแฅแแแแฅแแแแแก แแ แแฅแแแ แชแแแแแแแแแ แแแกแขแ แแฅแขแฃแแ แแงแแก, แแฃแแแ แแแขแแกแจแ แกแแฌแแ แแแก แแแแแฌแงแแแขแแแแแแแแก แแแแกแแกแขแแแ แฏแแ แแ แแ แแก แแแแ. แแฃแแแ แแแ แแ แแแ แซแแแแแ แกแแแแแแแแแแแแ แแ แแแ แแแฃแแแ แแแแแ แแแแฎแแแแแแแก แแแชแแ. แแแแแแแแแ, แจแแฃแซแแแแแแแ แแแแแขแแคแแแแชแแแก แฃแแ แฃแแแแแงแแคแแก แแแแแฌแงแแแขแแก แจแแฅแแแ, แกแแแแช แกแแญแแ แแ แกแแ แแแ แแก แแแแแขแแคแแแแชแแแก แแแแชแ แ แแแ แแแขแแแแ, แกแแ แแแ แแแจแ แฉแแกแแฃแแ แแแแ แแขแฃแ แแก แฉแแแแแแ. แแก แกแคแแ แ แแแแแ แแแแ, แแแแ แแ แแแแแกแแแแแ แฏแแ แแ แแ แแก.
แแแแแฌแแแแแแ แแแ แจแแแแแฎแแแแแ, แแแแขแแ แแ แแแฌแแแจแ แแแกแแแแแแ แแ แแแแแแแแแ. แแแแแ แแแแแงแแแแแ แ แแแแแแแแ แแ แแฅแขแแแฃแแ แแแแแแแแ.
แจแแแแฎแแแแ 1. โแแแแแ แแแฃแแแขแแ แแกโ แแแแแ แฃแกแแคแ แแฎแแแแ แแฃแแแ แแก แแแ แแ แแแแแแแ
แแแแแแแแ แแแฃแแ แแแแแ แฃแกแแคแ แแฎแแแแแก แกแแกแขแแแแก แจแแแแฎแแแแแจแ, แแแแขแแแแแ แแแแกแ แแ แแ แแแกแขแ แแ แแแแก แแแแแงแแแแแ แจแแกแแซแแแแแแก แฎแแแก แแแแแแกแฎแแแแแกแ แแ แจแแญแ แแก แฌแแแแแฆแแแแ แแ แซแแแแก. แแแแแแแแแ, แแ แ แแแแแ แแแฃแแแขแแ แจแ แแแแแกแแ แแ แแแกแแ แแฃแแแแ แแแแแฎแแ แชแแแแแก แแ แแแกแขแ แแก แแแแแแแแชแแ แแแฌแแ แแแแ SIEM แกแแ แแแกแแแ, แ แแแแแแช แแแแแแแแแแก แแฃแ แแแแแแก แ แแแแฃแ แแ แแจแ แแ แแแแกแแแฆแแ แแแก แจแแขแแแแก, แฐแแแแ แแแแก แแ แฌแแ แฃแแแขแแแแแแแก แแ แแชแแกแก. แแแแแแกแฎแแแก, แ แแแแแก แแแแแแแกแแแแก แแชแแแแแแแกแแก, แแ แแแแแกแแกแงแแแ แแ แแแ แแแแก แแแ แฃแกแแก แจแแแแญแ แแก แจแแแแฎแแแแแจแ, แแก แแ แแแกแขแ แแขแแ แแก แแแจแแแแแแ แแฆแแแก แแแแขแแแแแ แแแก แแแแแแแชแแแแแ แฃแคแ แ แกแฌแ แแคแแ, แแแแ แ แแกแแแ แแแคแแชแแ แแแแแแ, แแ แฃแคแ แ แกแฌแ แแคแแ, แแแแ แ แแแแแแแกแฎแแแแ แแแแก แแกแฎแแแก แแแ.
แจแแแแฎแแแแ 2. Booking.com-แแก แแแแแชแแแแ แแแแแแแก แแแฌแแแแแ แแแ แแแแ แแชแแ Kubernetes-แจแ
Booking.com-แจแ แแแแแแ แ แแแแแชแแแแ แแแแแ MySQL แแกแแแฅแ แแแฃแแ แ แแแแแแแชแแแ - แแ แแก แแกแขแแขแ แแ แกแแแแแแแก แแแแแ แแแ แแ แฅแแ. แแ แแ แแแกแแแแก, แ แแแแกแแช แแแแแแ แแแแแแแแ แแแขแแแ, แแแแฌแงแ แแ แแแฅแขแ แแแแแแแก แแแแแกแแงแแแแแ, แ แแแแแแแช แจแแแซแแแแ "แแแฎแแ แแขแแก" แแแ แแแแฃแแ แแแแแแ.
แซแแ แแแแแ แแแแแก แแแ แแ, แแ แแก แแแกแแแแ แแก แแแกแขแแแแชแแ แแแแแแแฌแแ แ แแ แแแกแขแ แแ, แ แแแแแแช แแแแฌแแ แ แฏแแ แแแแแ แแฃแแแ แแก แแแแแกแขแ แแแจแ แจแแกแแแแแแ. แแ แแฎแ แแ แแ แแแแแแแแ แแ แแ แแก, แแแแ แแ แแก แแฃแแแแแแ แแแแแแแแ แแ SSD-แแแแ. แแแกแขแแแชแแฃแ แ แจแแแแฎแแ, แแฃแแแแช แแแแแ แแแแแชแแแแ แชแแแขแ แจแ, แแ แแแแแแงแแแแแ แแแฆแแแ แจแแงแแแแแแแก แแ แแแแแแแก แแแแ.
แแแแแชแแแแ แแแแแแแก แแแกแแแ แแแแกแ แแ แแก Booking.com แกแแซแแแแ แกแแ แแแกแ, แกแแแแช แแแแแแฃแแ แกแแ แแแกแแก แแแแแซแ แแ แแก แแแแแชแแแแ แแแแ. แกแแซแแแแ แกแแ แแแกแแก Kuber-แแ แแแแแชแแแแก แแชแแแแแแ แแแ แแแฎแแ แฎแแ, แ แแแแแ แแแแแแฃแแ แแแแแซแ แจแแแชแแแก 60-80 แแ แแแแแแฃแ แแแฎแกแแแ แแแแก, แ แแแแแก โแแฌแแแโ แแ โแแแฎแฃแ แแแโ แ แแฃแแแ.
แจแแแแแแ, แกแแซแแแแ แกแแกแขแแแ แแ แแแแแแแแ Kubernetes-แแ แแ แแแแแ แแ แคแแฅแ แแแก, แ แแ แฃแแฎแแแแก แแแแแแแแจแ แแฎแแแ แแชแแแแแแแแ แแฅแแแแ. MySQL แแแแแชแแแแ แแแแ แแแฎแแแ แแ แแแแแแแแ: แแฎแแแแ แกแแแแแแ, แ แแแแแแกแแช แแ แแจแแแแแ "แแแกแ แแแแก". แแแกแแแแ แ แแจแแแแแแ แแ แแแกแแฎแแแ.
แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แจแแ แฉแแแ, แ แแแแ แช แแแแชแแแ แแแแแแ แแแแแฌแงแแแขแแก แแแ แแจแ
แคแแขแ
แแแฅแแแ, แแแงแแแก แแฎแแแ แแแแแแแแ, แแ แแแแแแแแ, แกแแแแช แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแแฌแแแ แซแแแแ แฌแแกแแ แแ แแก แแจแแแแแฃแแ. แฌแแแแแก แแแแแแแแแแแจแ แแงแแแแแแแก แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแแแแแแแ แแแแก แแแแแแก. แ แแแแ แแแแฆแแแ แแแแแฌแงแแแขแแแแแ แแแแขแแแแแ แแแกแ แแ แแฃแแแ แแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแจแแแแแ แแฃ แแ แ?
แแแแแแแแแแ, แ แแแแแแแช แแแ แซแแแแ แแแแแฌแแแแแแกแแแแก, แแแแแ แแชแฎแฃแแแ แแแกแแฃแกแแแแแ. แฏแแแกแแฆแ แแแแกแแ แแแขแแแแ แแแแแฆแแฃแ แแแแ แกแแแแแแแแแแก แแแแแกแแแ แแกแแ, แแแแ แแ แฏแแ แแแแแ แแ แแแ แแแแแแแแแแ, แ แแแแแแแแช แฃแแแ แแแแแฎแแแแ แแฎแแแ แแแแแแแแแ.
แแแแแ: โแแฎแแ แแฃแชแแแแแแแ แแแแแฌแงแแ แแแแแแแแแก แฆแ แฃแแแแแ, แฃแแ แแแแ แแแแขแแ, แ แแ แแก แฃแคแ แ แกแฌแ แแคแแโ, แแฃแแชแ แแ แแ แแก แแฃแชแแแแแแแ แแแคแ. แแแแฉแฃแ แฃแแ แแแแแขแแแแแแแก แแแแแแแแ แแแแกแแแ แแ แแแ แกแขแแ แขแแแแแก แคแฃแแแก แแแแ แแ แแแแแแ แแ แแฅแแ แแ แแแแแแ แ แแแแชแแแ แแแแ แแก แแแแงแ แแแแ.
แแแแแ แคแแฅแ แแแก, แ แแ แจแแ แฉแแแแก แแ แแขแแ แแฃแแแ แแ แกแแแฃแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแแแแแแแ แแแ. แแฃ แฌแแ แกแฃแแจแ แแงแ แกแแ แแแแฃแแ แแแแแกแขแแชแแ แแ แแก แแฃแจแแแแก, แแแจแแ แแแก แฎแแแแฎแแ แแแแแแแแแก แแแ แ แแ แแฅแแก. แแฃ แแแคแ แแกแขแ แฃแฅแขแฃแ แ แแ แแ แแก แแแแแแแแ แแแฃแแ แแ แแ แแก แแ แแแแแแแแ แแแกแขแ แฃแแแแขแแแแแ, แฃแกแแคแ แแฎแแแแแกแแแ แแ แแแแแขแแ แแแแแแ แแแแแแจแแ แแแแ, แแแจแแ แแแ แ แแฅแแก แแแแแฌแแแแแฃแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแก.
แแแแแกแแฎแแแ แแแแแกแแแแ แจแแแแฎแแแแแจแ แฃแแแ แแแแแแฎแแแแก แแ แแแแแ แแแแแแฎแแแก แแแแก, แแแแช แแแแแแแแจแ แแแแแแแแก แแแแแฎแแแก แกแแจแฃแแแแแแก แแแกแชแแแแ. "แแแแขแแ, แ แแ แฃแแ แแแแ, แแแแก แแแแ, แ แแ แแ แแแแแแ แแแขแแ แแแแแแ, แ แแแแแกแแช แกแฎแแแแ แแแซแ แแแแแ, แแ แแแแ แแ แฃแคแ แ แจแแ แก แแแแแแแแฃแ แแ, แแแแ แ แกแฎแแ แแแขแแ แแแแแจแ แ แแ แแแแฏแแ, แ แแแแแจแแช แกแแฌแแแแ แแแแแ แฃแแแ แฉแแแแกแฎแ.โ โ แแแแแแก แแแแแ. แ แแแแกแแช แแแแแแแแ แแฎแแแแ แแ แจแแงแแแแแแแก แแแแฎแแแแแแ แแแแแแ แแแแแฌแแแแ, แแแจแแ แแแแแ แแแแฎแแแแแก แแ โแแแแ แแขแแ แแแแกแแแโ, แ แแแแแแจแแช แแฆแแก แแแแกแแแฃแ แ แแแแแชแแแแ แแแแแแแ โแจแแคแฃแแฃแแโ. แแกแแแ แแแแฆแแแแแ แ แแแแแแแชแแแก แฏแแญแแก, แ แแแแแแช แแแแแกแแแแแ แแ แแแแแ แฌแแ แฃแแแขแแแแแแแก แจแแแแฎแแแแแจแ แแ แ.แจ.
แแชแแ แ แแแแแแแแแกแแแแก, แ แแแแแกแแช แแฅแแก แ แแแแแแแแ แกแแ แแแ แ, แแฃแแแ แแก แแแ แ แแ แแฅแแก, โ- แแแแแแก แแแแ แแ. แแแแ แแ แแฃ แแก แแแแแแแก แแกแแแแ แแ แแแข แกแแ แแแ แแ แแแแ แแแก, แแแจแแ แแแก แกแญแแ แแแแ แแแขแแแแขแแแแชแแ แแ แ แแกแฃแ แกแแแแก แแแ แแแแก แกแแกแขแแแ. แจแแแแฎแแแแแแแก 90% แฆแแ แก. แฃแคแ แ แแแขแแช, แแแขแแแ แแแแกแ แแ แ แแกแฃแ แกแแแแก แแแแแก แแแฃแฎแแแแแแ. แแแ แ แแฅแแก แงแแแแแกแแแแก, แแแฌแงแแแฃแแ แกแขแแ แขแแแแแแแแ แแแฌแงแแแฃแแ แแกแฎแแแแ แแแแแแแแแแแ แแแแแแแ แแแฃแแ แแแแแแแแแแ แแฃแแแขแแ แแแ, แแแแแแแแแแแแ แแแฎแแแแ แแแแขแแแแแ แแแแก แแ แแแกแขแ แแ แแแแก แแ แแแฃแฅแขแแแก. โแแแแฎ, แแก แแแแแแแแแ แแแแแแแแแโ, - แแแ แฌแแฃแแแแฃแแแ แแแแ แแ.
แแแแแกแแ แแแแแแแแแแ แแ แ แซแแ แแแแแ แแ แแขแแ แแฃแแ - แแแกแจแขแแแฃแ แแแ แแ แแฃแจแแแแแก แกแขแแแแแฃแ แแแ. แแก แจแแแ แฉแแแก แแ แแแกแขแ แฃแแแแขแแแก, แ แแแแแแแช แกแแฃแแแแแกแแ แจแแแคแแ แแแ แแแแแแแแแก. โแแก แจแแแซแแแแ แแงแแก แแฅแแแแก แแฃแฎแแแแแ แแฌแงแแแแแ แแแแแแ แแ แแแกแแ แแฅแแก Nutanix Community Edition. แแก แจแแแซแแแแ แแงแแก แแแแ แ แกแขแ แแฅแแแ Kuber-แแ แแแแแแแชแแแก แกแแฎแแ, แแแแแชแแแแ แแแแแแ, แ แแแแแแช แขแแ แแแแ แแแฃแแแ แแ แแฅแแก แแแแแแแแฃแแ RTO แแ RPO แแแ แแแแขแ แแแ" (แแฆแแแแแแก แแ แ/แแฃแแฅแขแแก แแแแแแแ - แแแแฎแ.).
แแแแแแแ แแแแแแแแแแ แแแ แกแแแแแแก แจแแกแแซแแ แแ แแแแแแ. แแ แแ แแแกแแแแก, แแแแแ แแ แแ แแ แแก แแแแ แ แแแฆแแแแแแแแคแแชแแฃแ แ แกแแแชแแแแแกแขแ, แ แแแแแแกแแช แแกแแแ "แแแฌแแแแแแ". แแแ แแแแช, แแฃ แแ แฉแแฃแแ แขแแฅแแแแแแแ แซแแแแแ, แแแจแแ แซแแแแแ แแแแแแก แแแฅแแ แแแแแ, แแแ แแ แกแแจแฃแแแ แแกแแแแก แแแแแแแแแแแกแ, แ แแแแแแแช แแแฌแงแแแแแ แแ แแแฆแแแแ แแ แแแ แชแฎแแแ แแแแ. แแฃแแชแ แกแฎแแ แแแแแฌแแแแแแ แแแแแแ, แ แแ แแก แแ แแก แแแ แกแแแแแแก แแแแแแแแแแก แกแแแแแฎแ.
แแฃ แแแแกแแแแ แแ แฉแแแแก แกแแแแแฎแก: แแแแฃแจแแแ แแแขแแ แ แแแแแแแแ Public Cloud-แจแ แแแแแชแแแแ แแแแแแแ Amazon RDS-แจแ แแ โแฌแแแแกแฌแแ โ แแแแแชแแแแ แแแแแแแ Kubernetes-แจแ, แแแจแแ, แแแฃแฎแแแแแแ แแแ แแแแฃแแ แฎแแ แแแแแแแกแ, Amazon RDS แแแฎแแ แแแแแฌแแแแแ แแ แฉแแแแแ.
แแแแแแแแ แจแแฎแแแแ แแก แแกแแแแแแแ แฃแแแขแแกแแแ แแ แแ แแก โแกแแกแฎแแแแแโ แกแแฌแแ แแแแแ แแแแแฌแแแแแฃแแ แแแแแฌแงแแแขแแแแแแแ แแ แแก แแก, แ แแกแแแแแช แฃแแแ แแแกแฌแ แแคแแแแ. แแแแแชแแแแ แจแแแแฎแแแก แกแแกแขแแแแแ แฃแแแ แแงแแก แแแแแฌแแแแแฃแแ, แกแแแแ แแ แจแแฅแแแแก แจแแงแแแแแแ, แ แแแแแแช แแแแแแแ แแแแแฌแแแแแจแ, แแแฅแกแแแฃแ แแแแฃแแแแจแ.โ, แจแแแฏแแแ แแแแ แแแ.
Kubernetes-แแก แแแแแงแแแแแแก แจแแคแแกแแแ
แแกแแแแแแแ แแแขแแ แแแแแแแแแ แแฃแแแ แแแขแแกแแก แแแแแแแแขแแแก แแแฃแกแแ แฎแแคแแแแแก แจแแแแแฎแแ: แ แแแแ แจแแแ แฉแแแ แแ แฉแแแขแแ แแ แขแแฅแแแแฃแ -แแแแแแแแแฃแ แ แแแแแแ? แ แแขแแ Kubernetes, แ แแขแแ แแ แ แแแ แขแฃแแแฃแ แ แแแแฅแแแแแ, แแแแแแแแแ?
แคแแขแ
แแแแแขแ แแ แแ แแแแแแ แฃแแแกแฃแฎแแก. แแ แแแ แจแแแแฎแแแแแจแ แชแแแกแ แแ แจแแชแแแแแก แแแแ แแแฆแแแฃแ แแฅแแ แแแแแฌแงแแแขแแแแแแแแก แแแแแแแแแแ แแแ, แ แแก แจแแแแแแแแช แแ แแแ แแแแแฌแแแ แแแแแแ แแฃแแแ แแแขแแกแจแ. แแฎแแ แแแแแแกแแแ แแแแแฃแแแแแแแแ แแฌแงแแแแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แจแแแฃแจแแแแแแก, แ แแแแแแช แแแ แ แแฅแแก Kuber-แแ แแแแแขแแแแก. แฉแแแ แแ แแกแแฃแแ แแแ แแแแกแแแฃแ แแแกแแแ แแฎแแ แแก แกแแกแขแแแแแแ, แ แแแแ แแชแแ 1C. Kubernetes แแฎแแแ แแแ, แ แแแแกแแช แแแแแแแแแ แแแก แกแญแแ แแแแแ แกแฌแ แแคแแ แแแแแจแแแแ, แฃแฌแงแแแขแ แฃแฌแงแแแขแ แแแฃแแฏแแแแกแแแแ.
แแแแ แแแก แแฃแแแ แชแแแแแแแ แจแแแฅแแแ แแแกแจแขแแแฃแ แ แแแแกแขแแ แ แแแ แขแฃแแแฃแ แแแแฅแแแแแแ แแแงแ แแแแแแ. แแแแแซแแแ แแแแแแแกแแแแ แแแแชแ, แ แแช แฎแแแแแฎแแ แแแแกแขแแ แแก แแแ แแแแก แแฌแแแแแ. โแแแแ แแฃแแแ, แจแแแแซแแแแ แแแแกแ แฃแแแ แแ แฎแแแแ แแแฃแญแแ แแ, แแแแ แแ แแก แแแแฆแแแแแ. แแ แแฃ แแแแแ แแ แแ แแก แแแแแกแแแแแ, แ แแแแแแช แกแแจแฃแแแแแแก แแแซแแแแ แแแฃแจแแแ แงแฃแแแแแ, แแแจแแ แฉแแแ แกแแแแแแแแแแ แแแแแแแแ แ แแแกแแ. แแ แจแแแแแแ แฉแแแ แแแแแแแแแ, โ- แแแแแแก แแแแ แแ.
แแ แกแแแแแก แแกแแแ แแแแแแแแกแ แแ แแแแแแแ แแจแแแแก แกแขแแแแแ แขแแแ, แแแแ แแ แแแ แแแแ แแขแงแแแก, แ แแแแแแแ แแฃแกแขแแ แแกแแแ แ แแแแฃแ แแแแ แแขแฃแ แแแ แแฅแกแแแฃแแขแแชแแแจแ. แแแแแแแแแแแกแแแแก แแกแแแ แแแแจแแแแแแแแแแ แแแแแแฃแแ แฎแแแกแแฌแงแแกแ แแ แแแแกแแกแขแแแแก แแแแแแ, แแแแ แแ แแก แจแแฃแซแแแแแแแ.
แ แ แแแแแแแแแ
แคแแขแ
แขแแฅแแแแแแแแแแก แแแแแแแแ แแแแกแแแ แแ แแแ, แฃแคแ แ แแ แฃแคแ แ แแแแกแฎแแแแแแฃแแ แแแฌแแแแแ แฉแแแแแ, แจแแแแแ แแ แฎแแแแ แคแแแฃแ แ แแแแแกแแแ, แฉแแแแแ แแแแงแแแแแแ, แ แแแแแแแช แแแแแแ แชแแแ แแแแแ, แ แแ แงแแแแแคแแ แ แแ แ แฎแแแกแแฌแงแแจแ แแแแ แแแแแแแก.
แ แแแแ แคแแฅแ แแแ, แแแแแแแ แแ แ, แ แแแแกแแช แแแแฃแฅแกแแก แกแแแงแแ แแกแแแแก แแฅแแแแ Ubuntu-แก แแกแแแแกแ แแแกแขแ แฃแแแแขแ? แจแแกแแซแแแ, แแ แแ แแแแขแแแแแ แแแแชแแแกแ แแ แแ แแแกแขแ แแ แแแแก แแแกแขแ แฃแแแแขแ แแแแชแแแก แแฃแแแ แก. แแก แแแแแแแแแแก แจแแแแแแจแ แฆแ แฃแแแแแแก แแจแแแแแแก.
แแแกแฃแฎแ แแแกแชแ แแแแแแ: โแแฃแแแ แแฎแแ แแจแแแแแก Anthos-แก - แแก แแ แแก แแแแ แจแแคแฃแแฃแแ แจแแแแแแแแแ, แ แแแแแแช แแแ แชแแแแแก แฆแ แฃแแแแก แแ แแแแชแแแก Kuber-แก, Service Mesh-แก, แแแแแขแแ แแแแก - แงแแแแ แแแแ แแขแฃแ แแก, แ แแแแแแช แกแแญแแ แแ แจแแแ แแแแ แแกแแ แแแกแแแแกแแแแกโ. แฉแแแ แแแแฅแแแก แแแแแแแแจแ แแแ แ."
แแแแแกแแ แแกแแแ แแฎแกแแแ Nutanix แแ VMWare vRealize Suite แแ แแแฃแฅแขแแ, แ แแแแแแกแแช แจแแฃแซแแแแ แแแฃแแแแแแแแแ แแกแแแแก แแแแชแแแแก แแแแขแแแแแ แแแแชแแแก แแแ แแจแ.
แแแแแขแ แแ แแแแแแแ แ แแแแแกแ แแแกแแแ แแแ, แ แแ โแขแแแแแแแกโ แจแแแชแแ แแแ แแ แแแแแกแแฎแแแแแแก แจแแแชแแ แแแ แแ แแก แแ แ แกแคแแ แ, แกแแแแช แแแฃแแฏแแแแกแแแแก แจแแแซแแแแ แแแแแแแ.
แแแกแแฃแกแแแก แจแแกแแฏแแแแแแแ, แฉแแแ แแแแแแงแแคแ แแแแแแแแ แแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แจแแแแแ แแ แแแแแแแแก:
- แกแแแแ แแแแแฌแแแแ แแแจแแแแ แแแแแแแแ แแ แแแแแแ แกแแฎแแแแฌแแคแแกแแแ.
- แฃแกแแคแ แแฎแแแแแก แแฎแแ แแแญแแ แแก แกแฎแแแแแกแฎแแ แแ แแแแแแ, แแแ แจแแ แแก แจแแกแแซแแแแแแแ แแแแกแ, แ แแ Docker-แแ แแแแกแ แฃแแแก Python-แแก แแ แแแแแ แแแ แกแแ, แแแแแแแชแแแก แกแแ แแแ แแแ แแ แแแแแแแแแขแแแ.
แญแแ แแ แฎแแ แฏแแ, แ แแช แฏแแแแ แชแแแแ แจแแฎแแแแ แแแ แแแแแฎแแแแ.
แกแแกแฌแแแแ แแแแแฌแแแแ, แ แแแแ แช แแ แแแกแขแ แแ แแแ, แ แแฃแแ แแแแกแแกแขแแแแ.
แแแแฃแกแขแ แแแจแ แแแแ แชแแแแแฃแแ แแ แแแแแแแ แแแกแขแ แฃแแแแขแแแแก แแแ แแขแแ แแแแแงแแแแแ.แแแแแ แฉแแแ แแแกแแแแแแ แแฅแแแแแแ. แฏแแ แแแแแ แแ แกแแแแแก แแแแชแแ, แ แแ Docker+Kubernetes แแแแแแแแชแแแกแแแแก แแแแแแ แแ แแ แแก แกแแกแขแแแแก โแชแแแขแ แแแฃแ แโ แแแฌแแแ แแแฎแแแก. แแแแแแแแแ, แแแแ แแชแแฃแแ แกแแกแขแแแแแ แฏแแ แแแแ แแขแฃแ แแแแ แแแแแกแขแแแแ แแแฃแแ, แ แแช แแ แจแแแซแแแแ แแแฅแแแก แแแแขแแแแแ แแแแ แแ แแ แแแกแขแ แแ แแแแแ. แจแแกแแซแแแ, แแแแแแแแจแ แแแแ แแชแแฃแแ แกแแกแขแแแแแ แแ แแแแขแแแแแ แแแ แแแแ แแแแแแแก แฆแ แฃแแแแก แแแ แแแแก แแ แแแ แแแฃแ แฃแแ แฃแแแแแงแแคแแกแแแ.
แคแแขแแแแแ แแแ แกแแแขแแก แคแแขแแแ แแคแแ Pexels-แแแ แแแแแ แแแกแแ แแแแแ แจแแแแฎแแแแแ แแ แแแแแกแแแแ แแแแแฉแแแก แแ แจแแแแฎแกแแแแ, แ แแ แฉแแแ แแแแฅแแก แคแแแกแแฃแฅ แฏแแฃแคแ
"แแแแ IT แแ แแแฅแขแแแแก แแแ แแแ แแ แแแแแแแแ แแแ" , แแ แฎแ@feedmeto แกแแแแขแแ แแกแ แแฃแแแแแแชแแแแแ แกแฎแแแแแกแฎแแ แขแแฅแแแแฃแ แ แแแแแแแแแแ. แแ แฉแแแ แแ แฎแ@rybakalexey , แกแแแแช แแ แแกแแฃแแ แแ แแแแแแแแ แแแแก แแแแแฏแแแแขแแ แแ แแแฃแฅแขแแก แแแแแแแแแแจแ.
แฌแงแแ แ: www.habr.com