Kubernetes แแ แแก แจแแกแแแแจแแแแ แแแกแขแ แฃแแแแขแ Docker แแแแขแแแแแ แแแแก แแแกแแจแแแแแ แแแแกแขแแ แฃแ แฌแแ แแแแแแก แแแ แแแแจแ. แแฃแแชแ, แแ แแก แแ แแแแแแแแ, แ แแแแแแกแแช แแฃแแแ แแแขแแแ แแแ แแแแแญแ แแก. แฌแแ แแแแแแก แฎแจแแ แ แแแแแแแแแแกแแแแก, แฉแแแ แแแญแแ แแแแ แกแ แฃแแแ แแแขแแแแขแแแแ แแแฃแแ แชแแกแคแแ แ/แแฌแแแแ แแแแแแแแแ, แ แแแ แแแแแแแ แแแแชแแแแ แจแแคแแ แฎแแแ แแ แแชแแกแจแ, แ แแแแแแช แแกแแแ แกแแญแแ แแแแก แแแ แ HTTP แแแแฎแแแแแแก แแ SSL แแแแแแขแแแ แแแแก. แแก แแแแแฎแแแก แแแขแแแ แแชแแแก แแแขแแแ แแแแก แแแแแแกแแ แแแ, แ แแแแ แแชแแ ha-proxy. แแแแแ แแ แแ แแแแแฌแแแแแ แแแแแ Kubernetes แแแแกแขแแ แแก แแแฎแแแ แแ แแแขแแแแขแฃแ แ แแแกแจแขแแแแ แแแ แฆแ แฃแแแแแแแ แแแ แแแแจแ แแฃแจแแแแแกแแก, แแแแแแแแแ, แแแแกแขแแ แแก แแแฌแแแแแ แแแ แจแแแชแแ แแแ แฆแแแแ.
แแแฃแฎแแแแแแ แแแแกแ, แ แแ Kubernetes-แก แแ แแฅแแก แแก แคแฃแแฅแชแแแแ, แแก แฃแแ แฃแแแแแงแแคแก API-แก, แ แแแแแแช แจแแแแซแแแแ แแแแแแงแแแแ แแกแแแแกแ แแ แแแแแแแแแก แแแแแกแแญแ แแแแ. แแแกแขแ แฃแแแแขแแแ แแฃแ แฏแ/แแฌแแแแ แแแขแแแแขแฃแ แ แแแแแแแแแแกแ แแ Kubernetes แแแแกแขแแ แแก แกแแแแแ แแแแก แแแแแแ แจแแแฃแจแแแแ Cloud RTI แแ แแแฅแขแแก แคแแ แแแแแจแ, แ แแแแแแช แจแแแฅแแแ แฆแแ แแแแแก แกแแคแฃแซแแแแแ.
แแก แกแขแแขแแ, แแแแแ แขแ แแแกแแ แแแขแ, แแแฉแแแแแแ, แแฃ แ แแแแ แฃแแแ แแแแงแแแแ Kubernetes แกแฎแแ แฆแแ แแแแแก แแแแแแแแแขแแแแแ แแ แแแ, แ แแแ แจแแแฅแแแแก แฌแแ แแแแแแกแแแแก แแแ แแแ แแแ, แ แแแแแแช แแแแฆแแแก แแแแก git commit-แแแแ แฌแแ แแแแแแก แจแแคแแ แฎแแแแก แแแ แแจแ.
แแกแ แ แแ, แแแก แจแแแแแ แ แแช แแฅแแแ แแแฅแแ แฌแแแแแ แแฅแแแแก แแแแแแแชแแแแแ แแแ แ แกแแแงแแ แแแแ, แจแแแแซแแแแ แแแแฌแงแแ แแแขแแแแขแแแแชแแแก แกแ แฃแแแ แแแงแแแแแ, แแแฃ แแแแงแแแแแ แแก แแ แแขแแแแ, แกแแแแช แจแแแแซแแแแ แจแแแกแ แฃแแแ git commit แแ แแแ แฌแแฃแแแแ, แ แแ แแก git commit แแแกแ แฃแแแแแ แฌแแ แแแแแแจแ. แแฃแแแแ แแแแ, แแ แแแแแฏแแแแก แแแแฎแแ แชแแแแแแแกแแก, แแแแแแแแแแก แแแแฎแแ แชแแแแแแแกแแก, แฉแแแ แแ แแแแแแ แจแแแแฎแแแแก แจแแคแแ แฎแแแ. แแกแ แ แแ, Kubernetes-แจแ แแแแแกแแแแ แ แแแขแแแแขแแแแชแแ แแฌแงแแแ API-แแ.
Kubernetes แแ แแ แแก แแแกแขแ แฃแแแแขแ, แ แแแแแก แแแงแแคแแแ แแ แแแแแงแแแแแ แจแแกแแซแแแแแแแ แงแฃแแแแแ. แ แ แแฅแแ แฃแแแ, แจแแแแซแแแแ แแแแก แแแแแแแแ, แแแแแแงแแแแ kubectl แแ แแกแ แจแแแแแ, แแแแ แแ แแแแแช API แแ แแก แงแแแแแแ แกแแแแขแแ แแกแ แแ แกแแกแแ แแแแแ แ แแ แแ แแแแขแคแแ แแแแ. API-แแก, แ แแแแ แช แคแฃแแฅแชแแแแแก แแ แแแแแแแแแก แแแแแงแแแแแแ, แจแแแแซแแแแ แฌแแแแแ แแแแฅแแแก แงแแแแแคแแ แแ, แ แแกแ แแแแแแแแแช แแกแฃแ แ Kubernetes-แจแ. แแแแแ kubectl แแกแแแ แแงแแแแแก REST API-แก.
แแก แแ แแก REST, แแกแ แ แแ แแฅแแแ แจแแแแซแแแแ แแแแแแงแแแแ แแแแแกแแแแ แ แแแ แแ แแแกแขแ แฃแแแแขแ แแ API-แกแแแ แแฃแจแแแแแกแแแแก, แแแแ แแ แแฅแแแแ แชแฎแแแ แแแ แแแแ แแ แแแแแแแแแแแแแแ แแแ แแแ แแแแแแแแแแแแแ. แฉแแแแ แแฃแแแแ แแแฌแแ แ 2 แแกแแแ แแแแแแแแแแ: แแ แแ Java/OSGi-แกแแแแก แแ แแ แแ Go-แกแแแแก. แแแแ แ แฎแจแแ แแ แแ แแแแแแงแแแแแ, แแแแ แแ แแแแแกแแแแ แจแแแแฎแแแแแจแ แแก แกแแกแแ แแแแแ แแแแแแแ แแแฅแแ แแฅแแแแก แแแแแแ แแฃแแแแแจแ. แแกแแแ แแแฌแแแแแ แแ แแแชแแแแแ แแแฃแแ แฆแแ แแแแแก แแ แแแฅแขแแ. แฃแแแ แแแ แแกแแแ แแแแแแแแแแแ แกแฎแแแแแกแฎแแ แแแแแแกแแแแก, แแกแ แ แแ แแฅแแแ แจแแแแซแแแแ แแแ แฉแแแ แแก, แ แแช แงแแแแแแ แแแขแแ แแแแฌแแแ.
แแกแ แ แแ, แกแแแแ แแแแฌแงแแแ แแฅแแแแ แแแแแแแแแแก แแแขแแแแขแแแแชแแแก, แแฅแแแ แฃแแแ แแแ แฌแแฃแแแแ, แ แแ แแ แแชแแกแ แแ แแแแฅแแแแแแแแ แแแ แ แแแแ แจแแคแแ แฎแแแแก. แแแแแแแแแ, แฉแแแแ แแฃแแแ แแฌแแ แแแแแก แแ แแแฃแฅแชแแแก แแแแแแแแแแก แจแฃแ แแฆแแก แแแแแแแแแแแจแ, แ แแแแกแแช แฎแแแฎแ แแงแแแแแก แแแแแแแชแแแแก แแแฅแกแแแฃแ, แแแแขแแ แแแแจแแแแแแแแแแ, แ แแ แแแแแแแ แแแแชแแแแ แจแแคแแ แฎแแแแแ แแ แแ แแชแแกแจแ. แจแแคแแ แฎแแแแก แแแแแแแ แแชแแแแแแก แแแแแแ แแแแแแงแแแแแ 2 แแแแแแ: แแฃแ แฏแ/แแฌแแแแ แแแแแแแแแ แแ แแแซแ แแแ แแแแแฎแแแแ. แแ แฃแแแแแกแแแแ แจแแแแฎแแแแแจแ, แแฃ แแฅแแแ แแแฅแแ แแแแแแแชแแแก 5 แแกแแ แแแจแแแแฃแแ, แแกแแแ แแแแแฎแแแแแ แแแแแแแแแแ แแแแ แแ แแแแแแแแก แแแงแแแแแแ. แแก แแแแแแ แแจแแแแแแ แแ แแฃแจแแแแก, แแแแ แแ แแ แแ แแก แจแแกแแคแแ แแกแ, แแฃ แแฅแแแ แแแฅแแ แแแแแแแชแแแก แกแฎแแแแแกแฎแแ แแแ แกแแ แแ แแแ แแฃแแแ แแแจแแแแฃแแ แแแแแแแแแแก แแ แแชแแกแจแ. แแ แจแแแแฎแแแแแจแ, แแฅแแแ แจแแแแซแแแแ แแแแแแฎแแแ แแแแฎแแแ แแแแแก แแแขแแ แคแแแกแ, แกแแแแ backend แแฃแจแแแแก แซแแแ แแแ แกแแแแ แแ แแแแแแแชแแ แจแแฌแงแแแขแก แแฃแจแแแแแก. แแแแขแแ, แแ แแแ แแแแ แแแแก แแแแแกแแแ แแกแแ, แแกแแ แแแ แแแแแจแ แแฃแจแแแแ แกแแแแแแ แ แแฃแแแ.
แแก แแ แแก แแ แ-แแ แแ แแแแแแ, แ แแก แแแแแช แฉแแแ แแแแ แฉแแแแแ แแแแแแแงแแแแ แแฃแ แฏแ/แแฌแแแแ แแแแแแแแแ แฉแแแแ แแแแแแแชแแแแแก แแแแแแแแแแก แแแขแแแแขแแแแชแแแกแแแแก. แแ แแแแแแแ, แแฅแแแ แฃแแแ แแแ แฌแแฃแแแแ, แ แแ แแแแแแแชแแแก แแฎแแแแ แแ แแ แแแ แกแแ แแฅแขแแฃแ แแ แแ แแแ แแฃแแแ.
แแฃแ แฏแ/แแฌแแแแ แแแแแแแแแแก แแแฅแแแแแแ แแกแ แแแแแแงแฃแ แแแ. แฉแแแ แแแฆแแแ แขแ แแคแแแก แฉแแแแ แแแแแแแชแแแแแกแแแแก ha-proxy-แแก แแแจแแแแแแ, แ แแแแแแช แแแแแกแชแแแก แแแก แแแแแ แแแ แกแแแก แแแแแแแชแแแก แแแจแแแแฃแ แแกแแแแแ.
แ แแแแกแแช แฎแแแแ แแฎแแแ แแแแแแแแแ, แฉแแแ แแแงแแแแแ Deployer-แก, แ แแแแแกแแช แแซแแแแ แแฎแแแ แแแแแแแแแขแแแ แแ แแแแแแแแกแแแก แแฎแแ แแแ แกแแแก. แแแแแแแชแแแก แแฎแแแ แแแ แกแแแก แแแแแ แแแ แแแจแแแแก, แ แแ แ แแแแแแแแแก แแฎแแแ แแแแ แแแ โแแแแฆแแแแฃแแแโ, แ แแก แจแแแแแแแช แแฎแแแ แแแ แกแแแก แแก แแกแแแแ แแฎแกแแแแ แชแแแแ, แแฎแแ แแแแจแ. แแฃแแชแ, แฐแ-แแ แแฅแกแแ แแ แแคแแ แ แแชแแก แแแ แจแแกแแฎแแ แแ แฏแแ แแ แแฌแแแแก แ แแแแ แแแขแแแ แแแแก แแแแแ.
แแแแขแแ, แฃแแแ แแแแแก แงแแแแแกแ, แแฃแชแแแแแแแแ แฉแแขแแ แแแก แฏแแแแ แแแแแแแก แจแแแแฌแแแแแก แแฎแแแ แแแ แกแแแแแก แจแแกแ แฃแแแแแก แจแแแแฌแแแแ, แ แแแ แแแ แฌแแฃแแแแ, แ แแ แแกแแแแ แแแแ แแ แแแ แขแแแ แแแก แแแแกแแฎแฃแ แแแแกแแแแก.
แแแแแแแแแแก แงแแแแ แแแแแแแแแขแแ แฃแแแ แฃแแ แฃแแแแแงแแก แฏแแแแ แแแแแแแก แจแแแแฌแแแแแก แแแ แแแแฃแแ แคแแ แแ. แแก แจแแแซแแแแ แแงแแก แซแแแแแ แแแ แขแแแ HTTP แแแ แแก แจแแแแฌแแแแ, แ แแแแกแแช แแแแฆแแแ แแแแก 200 แกแขแแขแฃแกแแ, แแ แฃแคแ แ แกแแฆแ แแแกแแฃแแ แจแแแแฌแแแแ, แ แแแแแจแแช แแแแฌแแแแ แ แแแแแแแแแก แแแแจแแ แก แแแแแชแแแแ แแแแแกแแแ แแ แกแฎแแ แกแแ แแแกแแแแแ, แแแแแแแฃแ แ แแแ แแแแก แแแแจแแ แแแแก แกแขแแแแแฃแ แแแแก. แแ แงแแแแแคแแ แ แกแฌแแ แแ แแฌแงแแแ แแ แแฃแจแแแแก แแฃ แแ แ. แแก แแ แแชแแกแ แจแแแซแแแแ แกแแแแแแ แ แแฃแแ แแงแแก.
แแแก แจแแแแแ, แ แแช แกแแกแขแแแ แแแแแแกแขแฃแ แแแก, แ แแ แงแแแแ แแแแแฎแแแแฃแแ แ แแแแแแ แแฃแจแแแแก, Deployer แแแแแแฎแแแแก แแแแคแแแฃแ แแชแแแก แแ แแแแแกแชแแแก แกแฌแแ แแแแคแแก, แ แแแแแแช แฎแแแแฎแแ แแแแแแแคแแแฃแ แแ แแแก ha-proxy-แก.
แแฎแแแแ แแแแก แจแแแแแ แแฅแแแแ แขแ แแคแแแ แแแแแ แแฃแแ แแแแแ แแฎแแแ แแแ แกแแแก แแกแแแแแ แแ แซแแแแ แฏแแจแ แแแฅแ แแแ.
แแก แแแฅแแแแแแ แแ แแ แแก Kubernetes-แแก แแแฎแแกแแแแแแแแ. แแฃแ แฏแ/แแฌแแแแ แแแแแแแแแแก แแแแชแแคแชแแ แกแแแแแแ แแแแ แฎแแแแ แแ แกแแแแแก แแ แแก แงแแแแแแแแก แแงแแแแแแ แแแขแแแ แแแแก แแแแแแกแแ แก. แแแ แแแ แ แแแจแ, แแฅแแแ แแแแแ แแแแ แแแแ แขแ แแคแแแก แแแแแแแชแแแก แซแแแ แแแ แกแแแแ, แฎแแแ แแแแแฎแแแแแก แจแแแแแ, แแแแแแแแ แแแแแแขแแแแ แแฎแแ แแแ แกแแแแ. แแก แแ แแแชแแแ แแแแแแงแแแแแ แแ แ แแฎแแแแ Kubernetes-แจแ.
แแฎแแ แแ แแแแแชแแแแ แแฎแแ แแแแแ แแแแก แแแแแแแแแขแก - Deployer, แ แแแแแแช แแฎแแ แชแแแแแแก แฏแแแแ แแแแแแแก แจแแแแฌแแแแแแก, แแฎแแแแก แแ แแฅแกแแแแแก แฎแแแแฎแแ แแแแคแแแฃแ แแชแแแก แแ แ.แจ. แแก แแ แแก แแแแชแแคแชแแ, แ แแแแแแช แแ แแ แชแแแแแแ แแแ แ แกแแแงแแ แแแ แแ แแ แกแแแแแก แแฃแแแ แแแขแแก แจแแแแแ. แแ แแแฉแแแแแแ, แแฃ แ แแแแ แจแแแแซแแแแ แจแแฅแแแแ แแฅแแแแ แกแแแฃแแแ แ Deployer แแแแชแแคแชแแ แฆแแ แฌแงแแ แแก แแแกแขแ แฃแแแแขแแแแก แแแแแงแแแแแแ.
แแกแ แ แแ, แแแ แแแแ, แ แแกแแช Deployer แแแแแแแก แแ แแก RC แ แแแแแแแชแแแก แแแแขแ แแแแ แแก แจแแฅแแแ Kubernetes API-แแก แแแแแงแแแแแแ. แแก API แฅแแแแก แแแแแแกแ แแ แกแแ แแแกแแแก แจแแแแแแแ แแแแแแแแแแกแแแแก, แแแฃ แฅแแแแก แกแ แฃแแแแ แแฎแแ แแแแกแขแแ แก แฉแแแแ แแแแแแแชแแแแแกแแแแก. แ แแแแ แช แแ RC แแแ แฌแแฃแแแแแ, แ แแ แ แแแแแแ แแแแฌแงแ, แแก แฉแแแขแแ แแแก แฏแแแแ แแแแแแแก แจแแแแฌแแแแแก แแแ แคแฃแแฅแชแแแแแ แแแแแ. แแแแกแแแแก Deployer แแงแแแแแก GET/health แแ แซแแแแแแก. แแก แแฌแแ แแแแแก แจแแกแแแแแแก แกแแแแแ แแแแก แแแแแแแแแขแแแก แแ แแแแฌแแแแก แงแแแแ แแแแแแแขแก, แ แแแแแแช แแฎแแ แก แฃแญแแ แก แแแแกแขแแ แแก แแฃแจแแแแแก.
แแแก แจแแแแแ, แ แแช แงแแแแ แแแแแ แแแแแแชแฎแแแ แแแแ แฏแแแแ แแแแแแแก แแแแแแแ แแแแ, Deployer แฅแแแแก แแฎแแ แแแแคแแแฃแ แแชแแแก แแแแแแแขแก - etcd แแแแแฌแแแแแฃแ แกแแชแแแก, แ แแแแแกแแช แจแแแ แแฃแแแ แแแขแแแ แแงแแแแแก, แแแขแแแ แแแแก แแแแแแกแแ แแก แแแแคแแแฃแ แแชแแแก แจแแแแฎแแแก แฉแแแแแแ. แฉแแแ แแฌแแ แ แแแแแชแแแแแก etcd-แจแ แแ แแแขแแ แ แฎแแแกแแฌแงแแก แกแแฎแแแฌแแแแแแ confd monitors etcd แแฎแแแ แแแแแชแแแแแแกแแแแก.
แแฃ แแก แแฆแแแแฉแแแก แ แแแแ แชแแแแแแแแก แกแแฌแงแแก แแแแคแแแฃแ แแชแแแจแ, แแก แฅแแแแก แแฎแแ แแแ แแแแขแ แแแแก แคแแแแก แแ แแแแแกแชแแแก แแแก ha-proxy-แแ. แแ แจแแแแฎแแแแแจแ, ha-proxy แแแแแแขแแแ แแแแ แงแแแแแแแแ แ แแแแจแแ แแก แแแแแ แแแแก แแแ แแจแ แแ แแแแแ แแแแก แแแขแแแ แแแแก แแฎแแ แกแแ แแแกแแแแ, แ แแช แกแแจแฃแแแแแแก แแซแแแแก แฉแแแแ แแแแแแแชแแแแแก แแฎแแ แแแ แกแแแก แแแฃแจแแแก.
แ แแแแ แช แฎแแแแแ, แแแแแแแแแขแแแแก แกแแแ แแแแแก แแแฃแฎแแแแแแ, แแฅ แแ แแคแแ แแ แ แแฃแแ. แแฅแแแ แฃแแ แแแแ แแแขแ แงแฃแ แแแฆแแแ แฃแแแ แแแแฅแชแแแ API-แก แแ แ.แจ. แแแแแ แแแแฎแ แแ แฆแแ แแแแแก แแแแแแแแแ แแ, แ แแแแแกแแช แฉแแแ แแแแแแ แแแงแแแแแ - Amdatu Kubernetes Deployer.
แแก แแ แแก แแแกแขแ แฃแแแแขแ Kubernetes-แแก แแแแแแแแแแก แแ แแแกแขแ แแ แแแแกแแแแก แแ แแฅแแก แจแแแแแแ แแแฎแแกแแแแแแแแแ:
- แแฃแ แฏแ/แแฌแแแแ แแแแแแแแแ;
- แแแ แ แแแขแแแ แแแแก แแแแแแกแแ แแก แแแงแแแแแ;
- แแแแแแแแแแก แแฆแฌแแ แแก แแแ แแแ;
- แคแแฅแขแแแ แแแ แแแแแแแแแแก แแแ แแแ;
- แแแแแแแแแแก แแ แแก แฏแแแแ แแแแแแแก แจแแแแฌแแแแแแแก แคแฃแแฅแชแแแแแ แแแแก แจแแแแฌแแแแ;
- แแแ แแแแก แชแแแแแแแแก แแแแแ แแแ แแแแแแจแ.
แแก Deployer แแแแแฃแแแ Kubernetes API-แแ แแ แฃแแ แฃแแแแแงแแคแก REST API-แก แกแแฎแแแฃแ แแแแกแ แแ แแแแแแแแแแก แกแแแแ แแแแแ, แแกแแแ Websocket API-แก แกแขแ แแแแแแแก แแฃแ แแแแแแแก แแแแแแแแแแก แแ แแชแแกแจแ.
แแก แแแแแกแแแก แแแขแแแ แแแแก แแแแแแกแแก แแแแคแแแฃแ แแชแแแก แแแแแชแแแแแก etcd-แจแ, แแกแ แ แแ แแฅแแแ แแ แแญแแ แแแแแ แฐแ-แแ แแฅแกแแก แแแแแงแแแแแ แแแ แ แแฎแแ แแแญแแ แแ, แแแแ แแ แแแ แขแแแแ แแแแแแงแแแแ แแฅแแแแ แแแขแแแ แแแแก แแแแแแกแแก แแแแคแแแฃแ แแชแแแก แคแแแแ. Amdatu Deployer แแฌแแ แแแ Go-แจแ, แแกแแแ แ แแแแ แช แแแแแ Kubernetes แแ แแแชแแแแแ แแแฃแแแ Apache-แก แแแแ .
แกแแแแ แแแแแฌแงแแแแ แแแแแแแแแแก แแ แแแ แกแแแก แแแแแงแแแแแแก, แแแแแแแงแแแ แจแแแแแแ แแแแแแแแแแก แแฆแแฌแแ แ, แ แแแแแแช แแแแแแ แแขแแแก แฉแแแแแแก แกแแญแแ แ แแแ แแแแขแ แแแก.
แแ แแแแแก แแ แ-แแ แแ แแแแจแแแแแแแแแ แแแ แแแแขแ แแ โuseHealthCheckโ แแ แแจแแก แฉแแ แแแ. แฃแแแ แแแแแแแแแ แแขแแ, แ แแ แแแแแแแแแแก แแ แแชแแกแจแ แฃแแแ แฉแแขแแ แแแก แกแแฆแ แแแ แแก แจแแแแฌแแแแ. แแ แแแ แแแแขแ แแก แแแแแ แแแ แจแแกแแซแแแแแแแ, แ แแแแกแแช แแแแแแแแแ แแงแแแแแก แแแกแแแ แแฎแแ แแก แแแแขแแแแแ แแแก, แ แแแแแแแช แแ แกแแญแแ แแแแก แจแแแแฌแแแแแก. แแก แแแกแแ แแแขแแ แ แแกแแแ แแแฃแแแแแแก แ แแแแแแแแแก แ แแแแแแแแแกแ แแ แคแ แแแขแแก URL-แก, แ แแแแแแช แกแญแแ แแแแ ha-proxy-แก. แแแกแแกแ แฃแแก แแ แแก pod แกแแแชแแคแแแแชแแแก แแ แแจแ "podspec", แ แแแแแแช แฃแฌแแแแแก Kubernetes-แก แแแ แขแแก แแแแคแแแฃแ แแชแแแก, แกแฃแ แแแแก แแ แ.แจ. แแก แแ แแก แกแแแแแแ แแแ แขแแแ JSON แแฆแแฌแแ แ.
แแแแแ แแ แแ แแแกแขแ แฃแแแแขแ, แ แแแแแแช แแ แแก แฆแแ แฌแงแแ แ Amdatu แแ แแแฅแขแแก แแแฌแแแ, แแ แแก Deploymentctl. แแแก แแฅแแก แแแขแแ แคแแแกแ แแแแแแแแแแก แแแแคแแแฃแ แแชแแแกแแแแก, แแแแฎแแแก แแแแแแแแแแก แแกแขแแ แแแก แแ แจแแแชแแแก แแแ-แฐแฃแแแแก แแแกแแแ แแฎแแ แแก แแแแฎแแแ แแแแแแแกแ แแ แแแแแแแแแ แแแแกแแแ แแแแแซแแฎแแแแกแแแแก. แแฅแแแ แจแแแซแแแแ แแ แแแแแแงแแแแ UI, แ แแแแแ Amdatu Deployer แแแแแ แแ แแก REST API, แแแแ แแ แแ แแแขแแ แคแแแกแก แจแแฃแซแแแ แแแแแแแแแแแ แแแแแแแแแ แ แแแแ API-แก แฉแแ แแแแก แแแ แแจแ. Deploymentctl แแฌแแ แแแ OSGi/Vertx-แจแ Angular 2-แแก แแแแแงแแแแแแ.
แแ แแฎแแ แแแแแแฆแแแจแแฃแแแก แแแแแแกแขแ แแ แแแแก แแแแแแแแแ แแแ แแแแ แฌแแแแกแฌแแ แฉแแฌแแ แแแ แฉแแแแฌแแ แแก แแแแแงแแแแแแ, แแกแ แ แแ แแฅแแแ แแ แแแแญแแ แแแแแ แแแแแแ. แฉแแแ แแแแแแแแแกแแแ แแแ แขแแ Go แแแแแแแชแแแก. แแ แแแแ แแแฃแแแ, แแฃ แแฅแแแแ แแ แแแชแแแแ Go, แแก แซแแแแแ แแแ แขแแแ แแแแแแแชแแแ, แแกแ แ แแ แแฅแแแ แฃแแแ แจแแซแแแ แแแกแ แแแ แแแแแ.
แแฅ แฉแแแ แแฅแแแแ HTTP แกแแ แแแ แก, แ แแแแแแช แแแกแฃแฎแแแก แแฎแแแแ /แฏแแแแ แแแแแแแก, แแแแขแแ แแก แแแแแแแชแแ แแฎแแแแ แฏแแแแ แแแแแแแก แจแแแแฌแแแแแก แแแแฌแแแแก แแ แกแฎแแ แแ แแคแแ แก. แแฃ แจแแแแฌแแแแ แแแแแแแก, แแแแแแงแแแแแ แฅแแแแแ แแแฉแแแแแแ JSON แกแขแ แฃแฅแขแฃแ แ. แแก แจแแแชแแแก แแแแแแแชแแแก แแแ แกแแแก, แ แแแแแแช แแแแแแแแแแ แแแแแแแ แชแแแแแแแก แแแแ , แจแแขแงแแแแแแแแก, แ แแแแแกแแช แฎแแแแแ แคแแแแแก แแแแ แแแฌแแแจแ แแ แแแแแแฃแ แ แแแแแชแแแแ แขแแแ - แแฃแจแแแแก แแฃ แแ แ แฉแแแแ แแแแแแแชแแ.
แแแแ แฎแแแแ แชแแขแ แแแแแขแงแฃแ, แ แแแแแ แแแแแงแแแ แคแแฅแกแแ แแแฃแแ แแแแแแฃแ แ แแแแจแแแแแแแ แคแแแแแก แแแแ แแแฌแแแจแ, แ แแช แแแแแแแแจแ แแแแแฎแแแ แแแ แแฃแแแแช "แแ แแฏแแแกแแฆแ" แแแแแแแชแแแก แแแแแแแกแแแแจแ. แแแแก แแแแแแแแแแแ แจแแแแฎแแแแ.
แแแแแ แแแแแฌแงแแ. แแแ แแแ แ แแแจแ, แฉแแแ แแแแแฌแแแแ แแแแแกแแแแ แ แแแจแแแแฃแแ แแแแแก แแ แกแแแแแแก แแ แซแแแแแแก ~ kubectl get pods-แแก แแแแแงแแแแแแ แแ, แคแ แแแขแแแแแก URL-แแแ แแแกแฃแฎแแก แแ แแ แกแแแแแแก แกแแคแฃแซแแแแแ, แฉแแแ แแแแ แฌแแฃแแแแแแ, แ แแ แแแแแแแ แแแแแแแแแ แแ แฎแแแแ.
แจแแแแแ แแแ แแแแ แฎแแแแแ แฉแแแก แแแแ แแแฎแกแแแแแ Deploymentctl แแแขแแ แคแแแกแก, แ แแแแแจแแช แแแงแแแแแฃแแแ แแแแแแแแแแก แแแ แแแแขแ แแแ: แกแแฎแแแแแแก แกแแแ แชแ, แแแแแแแชแแแก แกแแฎแแแ, แแแแแแแแแแก แแแ แกแแ, แ แแแแแแแแแก แ แแแแแแแแ, แฌแแแ แแแแ URL, แแแแขแแแแแ แแก แกแแฎแแแ, แกแฃแ แแแ, แ แแกแฃแ แกแแก แแแแแขแแแ, แแแ แขแแก แแแแแ แ แฏแแแแ แแแแแแแก แจแแแแฌแแแแแกแแแแก, แแ แ.แจ. แ แแกแฃแ แกแแแแก แแแแแขแแแ แซแแแแแ แแแแจแแแแแแแแแแ, แ แแแแแ แแกแแแ แกแแจแฃแแแแแแก แแแซแแแแ แแแแแแงแแแแ แขแแฅแแแแแก แแแฅแกแแแแแฃแ แ แจแแกแแซแแ แ แแแแแแแแ. แแฅ แแกแแแ แจแแแแซแแแแ แแแฎแแ แแแแแแแแแแก แแฃแ แแแแ.
แแฃ แแฎแแ แแแแแแแ แแแ แแ แซแแแแแแก ~ kubectl get pods, แฎแแแแแ, แ แแ แกแแกแขแแแ โแแงแแแแแโ 20 แฌแแแแก แแแแแแแแแแแจแ, แ แแแแแก แแ แแกแแช แฎแแแแ ha-proxy-แแก แฎแแแแฎแแแ แแแแคแแแฃแ แแชแแ. แแแแก แจแแแแแ, pod แแฌแงแแแ แแ แฉแแแแ แ แแแแแแ แจแแแซแแแแ แแแฎแแ แแแแแแแแแแก แแฃแ แแแแจแ.
แแ แแแแแแฆแ แแแแแแแแ 20 แฌแแแแแแ แแแแแแ แแ แแฎแแ แแฅแแแ แฎแแแแแ แแแ แแแแ, แ แแ แแแแแแแแแฃแแแ แแแแแแแชแแแก แแแ แแแแ แแแ แกแแ. แแก แงแแแแแคแแ แ แแแแแแแ แแฎแแแแ แแแขแแ แคแแแกแแก แแแแแงแแแแแแ.
แแฎแแ แแชแแแแ แแแแ แ แแแ แกแแ. แแแแกแแแแแก แแ แแชแแแ แแแแแแแชแแแก แจแแขแงแแแแแแแแก "แแแแแ แฏแแแ, Kubernetes!" "แแแแแ แฏแแแ, Deployer!"-แแ, แกแแกแขแแแ แฅแแแแก แแ แกแฃแ แแแก แแ แแแแแกแแแก แแแก Docker-แแก แ แแแกแขแ แจแ, แ แแก แจแแแแแแแช แฉแแแ แฃแแ แแแแ แแแญแแ แ แฆแแแแแก "Deploy" แแกแแ Deploymentctl แคแแแฏแแ แแจแ. แแ แจแแแแฎแแแแแจแ, แแแแแแแแแแก แแฃแ แแแแ แแแขแแแแขแฃแ แแ แแฎแกแแแแ แแกแแแ, แ แแแแ แช แแก แแแฎแแ แแแแแแแชแแแก แแแ แแแแ แแแ แกแแแก แแแแแแแแแแกแแก.
แแ แซแแแแแ ~ kubectl get pods แแแแฉแแแแแแก, แ แแ แแแแแแแ แแแจแแแแฃแแแ แแแแแแแชแแแก 2 แแแ แกแแ, แแแแ แแ แฌแแแ แแแฌแแแ แแฉแแแแแแก, แ แแ แฉแแแ แฏแแ แแแแแ แแแจแแแแฃแแ แแแแฅแแก 1 แแแ แกแแ.
แแแขแแแ แแแแก แแแแแแกแแ แ แแแแแแแ แฏแแแแ แแแแแแแก แจแแแแฌแแแแแก แแแกแ แฃแแแแแก แขแ แแคแแแแก แแฎแแ แแแ แกแแแแ แแแแแแแกแแแแ แแแแแแแ. 20 แฌแแแแก แจแแแแแ แแแแแแแแแแ แ curl-แแ แแ แแฎแแแแแ, แ แแ แแฎแแ แแแแแแแแแฃแแแ แแแแแแแชแแแก 2 แแแ แกแแ แแ แแแ แแแแ แฌแแจแแแแแ.
แแก แแงแ "แฏแแแกแแฆแ" แแแแแแแชแแแก แแแแแแแแแ. แแแแฎแแ, แ แ แแแฎแแแแ, แแฃ แแแแแแแชแแแก แแฎแแแ แแแ แกแแแกแแแแก แแ แจแแแชแแแ Healthy แแแ แแแแขแ แก true-แแแ false-แแ, แแแฃ แแชแแแแแ แแแแแแแแแกแ แแ แแฏแแแกแแฆแ แแแแแแแชแแ, แ แแแแแแแช แแแ แจแแซแแ แฏแแแแ แแแแแแแก แจแแแแฌแแแแ. แแก แจแแแซแแแแ แแแฎแแแก, แแฃ แแแแแชแฎแแแจแ แแแจแแแแฃแแ แแฅแแ แแแ แแแแฃแแ แแแแคแแแฃแ แแชแแแก แจแแชแแแแแแ แแแแแแแแ แแแแก แแขแแแแ แแ แแก แแ แคแแ แแแ แแแแแแแแแแแ แฌแแ แแแแแแจแ.
แ แแแแ แช แฎแแแแแ, แแแแแแแแแ แแแแแก แแแแแ แแแชแแแฃแ แงแแแแ แกแแคแแฎแฃแ แก แแ ~kubectl get pods แแฉแแแแแแก, แ แแ แแ แแแ แแแแ แแฃแจแแแแก. แแแแ แแ แฌแแแ แแแแแแแแแแกแแแ แแแแกแฎแแแแแแแ, แแฃแ แแแแ แแฉแแแแแแก แแ แแแก แแแแฌแฃแ แแแก แกแขแแขแฃแกแก. แแแฃ แแแแก แแแแ, แ แแ แฏแแแแ แแแแแแแก แจแแแแฌแแแแ แแแ แแแฎแแ แฎแแ, แแแแแแแชแแแก แแฎแแแ แแแ แกแแแก แแแแแแแกแแแ แจแแฃแซแแแแแแแ. แจแแแแแแ, แฎแแแแแ, แ แแ แกแแกแขแแแ แแแฃแแ แฃแแแ แแแแแแแชแแแก แซแแแ แแแ แกแแแก แแ แแฎแแแ แแแ แกแแ แฃแแ แแแแ แแแแแกแขแแแแ แแแฃแแแ.
แแแแจแ แแแ แแ แแก แแ แแก, แ แแ แแแจแแแแช แแ, แแฃ แแฅแแแ แแแฅแแ แแแแแชแฎแแแแก แแ แแแ แแฃแแ แแแแฎแแแแแก แแแแ แ แแแแแแแแ, แแกแแแ แแแ แช แแ แจแแแแฉแแแแแ แจแแคแแ แฎแแแแก แแแแแแแแแแก แแ แแชแแแฃแ แแก แแแแฎแแ แชแแแแแแแกแแก. แแฃ แแฅแแแ แจแแแแแฌแแแแ แแ แแแแแแแชแแแก Gatling Framework-แแก แแแแแงแแแแแแ, แ แแแแแแช แฃแแแแแแแก แแแก แ แแช แจแแแซแแแแ แแแข แแแแฎแแแแแก, แแแจแแ แแ แชแแ แแ แแแแฎแแแแ แแ แแแฃแฅแแแแแ. แแก แแแจแแแแก, แ แแ แฉแแแแ แแแแฎแแแ แแแแแแ แแแ แช แแ แจแแแแฉแแแแแ แแแ แกแแแก แแแแแฎแแแแแแก แ แแแแฃแ แแ แแจแ. แแฃ แแก แแแ แแแฎแแ แฎแแ, แแฃแจแแแแ แแแแ แซแแแแแแ แซแแแ แแแ แกแแแแ, แแฃ แแก แฌแแ แแแขแแแฃแแแ, แแแแฎแแแ แแแแแแ แแแแแแ แแแแแแแ แแฎแแ แแแ แกแแแแ.
แแ แกแแแแแก แแฎแแแแ แแ แแ แ แแ, แ แแช แจแแแซแแแแ แฉแแแแ แแแก - แแฃ แฏแแแแ แแแแแแแก แจแแแแฌแแแแ แฌแแ แแแขแแแแ แแแกแ แฃแแแ, แแแแ แแ แแแแแแแชแแ แฉแแแจแแแแ แ แแแแ แช แแ แแแกแแ แแแขแแแ แแแ แแฅแแแแ, แแแฃ แแแแแคแกแ แแแฎแแแแ แแฎแแแแ แแแแแแแแแแก แแแกแ แฃแแแแแก แจแแแแแ. แแ แจแแแแฎแแแแแจแ, แแฅแแแ แแแแแฌแแแ แฎแแแแ แแแแแ แฃแแแ แซแแแ แแแ แกแแแแ. แแกแ แ แแ, แฉแแแ แแแแแแฎแแแแ, แแฃ แ แแแแ แแแแแแแงแแแแ Kubernetes แแแกแแแแก แจแแฅแแแแแ แฆแแ แฌแงแแ แแก แแแกแขแ แฃแแแแขแแแแ. แแแแแแแแแแก แแ แแชแแกแ แแแแ แแ แฃแคแ แ แแแแแแ แแฅแแแแ, แแฃ แแ แแแกแขแ แฃแแแแขแแแก แแแฌแงแแแ แแฅแแแแก Build/Deploy แแแแกแแแแแแแจแ. แแแแแแ แแฃแแแ, แแแแแแแแแแก แแแกแแฌแงแแแแ, แจแแแแซแแแแ แแแแแแงแแแแ แแแแฎแแแ แแแแแก แแแขแแ แคแแแกแ แแ แแ แแ แแชแแกแแก แกแ แฃแแแ แแแขแแแแขแแแแชแแ, แแแแแแแแแ, commit to master-แแก แแแแแงแแแแแแ.
แฉแแแแ Build แกแแ แแแ แ แจแแฅแแแแก Docker แกแฃแ แแแก, แแแแแแงแแแแแก แแแก Docker Hub-แจแ แแ แแแแแกแแแแ แ แแแกแขแ แจแ, แ แแแแแกแแช แแฅแแแ แแงแแแแแ. Docker Hub แแฎแแ แก แฃแญแแ แก webhook-แก, แแกแ แ แแ, แฉแแแ แจแแแแแซแแแ แแแแแแแงแแแแ แแแกแขแแแชแแฃแ แ แแแแแแแแแ Deployer-แแก แแแจแแแแแแ แแแแแ แแแฉแแแแแแ แแแแ. แแ แแแแ แแฅแแแ แจแแแแซแแแแ แกแ แฃแแแ แแแขแแแแขแแแแ แแแแแ แแฅแแแแ แแแแแแแชแแแก แแแขแแแชแแฃแ แฌแแ แแแแแแแ แแแแแแแแแแก.
แแแแแแแแแ แจแแแแแ แแแแแแ - แแฃแแแ แแแขแแก แแแแกแขแแ แแก แแแกแจแขแแแแ แแแ. แแแแแแแแแกแฌแแแแ, แ แแ kubectl แแ แซแแแแแ แแ แแก แกแแแแแ แแแแก แแ แซแแแแแ. แแแขแ แแแฎแแแ แแแแ, แฉแแแ แจแแแแแซแแแ แแแ แขแแแแ แแแแแแ แแแ แ แแแแแแแแแก แ แแแแแแแแ แฉแแแแก แแ แกแแแฃแ แแแแกแขแแ แจแ. แแฃแแชแ, แแ แแฅแขแแแแจแ, แฉแแแ แฉแแแฃแแแแ แแ แแแแแแ แแแแแแ แแแ แแแแแซแแแแก แ แแแแแแแแ แแ แแ แ แแแแแซแแแ.
แแแแแแ แแฃแแแ, แกแแแฃแจแแ แกแแแแแแจแ แจแแแซแแแแ แแแแญแแ แแแ แแแแ แแ, แฎแแแ แฆแแแแ, แแแแแแแแก แกแแ แแแกแแแแก แฆแแ แแแฃแแแแแก แจแแกแแแชแแ แแแแแ, แจแแแซแแแแ แแแแญแแ แแแ แแแจแแแแฃแแ แแแแแแแชแแแแแก แ แแแแแแแแแก แจแแแชแแ แแแ. แแก แแ แแแจแแแแก, แ แแ แแฎแแแแ แแแแแแแก แ แแแแแแแแแก แกแแแแแ แแแ แกแแแแแ แแกแ แแฅแแแแ, แ แแแแแ แแฃแแแแช แแ แ-แแ แแ แแแแแซแ แฃแแแฅแแแแ แแงแแก, แแฅแแแ แแแแแช แแแแแฌแแแ แแแแแแแแก แแแแแฎแแ. แแแฃ, แฌแแแฌแแแแก แกแแแแแ แแแแกแแแ แแ แแแ, แแแแญแแ แแแแแ แแแแแงแแแแแฃแแ แแแแฅแแแแแแก แ แแแแแแแแแก แแแกแจแขแแแแ แแแ.
แแก แจแแแซแแแแ แแงแแก แ แแฃแแ, แ แแแแแ แแแงแแแแแ แแแแแแแก แแฃ แกแฎแแ แฆแ แฃแแแแแแ แกแแ แแแกแก, Kubernetes-แแ แแ แแคแแ แ แแชแแก แแแแแงแแแแแฃแแ แแแแฅแแแแแแก แ แแแแแแแแแก แจแแกแแฎแแ. แแแก แแแแแ แแแกแขแ แฃแแแแขแ, แ แแแแแแช แกแแจแฃแแแแแแก แแแซแแแแ แแแแคแแ แแแแแ แกแแกแขแแแ แแแแแซแแก แแแแแแ.
แแกแ แ แแ, แฉแแแ แแแแแแฌแแแก แแ แฃแแแ แ แแแแ แช แแแแแซแแแแ, แแกแแแ แแแแแแแ. แฉแแแ แจแแแแแซแแแ แแแ แขแแแแ แแแแแคแแ แแแแแ แแฎแแแ แแแแแซแแแแก แแแจแแแแ AWS API แแ Scaling แฏแแฃแคแแก แแแแ แแขแแแแก แแแแแงแแแแแแ Kubernetes-แแก แแฃแจแ แแแแแซแแแแก แ แแแแแแแแแก แแแแคแแแฃแ แแชแแแกแแแแก. แแฅแแแ แแกแแแ แจแแแแซแแแแ แแแแแแงแแแแ cloud-init แแ แแกแแแแกแ แกแแ แแแขแ Kubernetes แแแแกแขแแ แจแ แแแแแซแแแแก แแแกแแ แแแแกแขแ แแ แแแแแ.
แแฎแแแ แแแแฅแแแ แแฌแงแแแ Scaling แฏแแฃแคแจแ, แแฌแงแแแก แแแแแก แแแแก แแแแแซแแก แกแแฎแแ, แ แแแแกแขแ แแ แแแแ แกแแแแแแกแขแ แ แ แแแกแขแ แจแ แแ แแฌแงแแแก แแฃแจแแแแแก. แแแแก แจแแแแแ, แแฅแแแ แจแแแแซแแแแ แแแแแ แแแ แ แแแแแแแแแก แ แแแแแแแแ แแแฆแแแฃแ แแแแแซแแแแ แแแแแกแแงแแแแแแแ. แจแแแชแแ แแแ แแแแแฎแแแก แแแข แซแแแแกแฎแแแแแก, แ แแแแแ แแฅแแแ แฃแแแ แแแ แฌแแฃแแแแ, แ แแ แแกแแแ แแแแแฏแ แแ แแแแแแฌแแแแก แฃแแแ แแแจแแแแฃแแ แแแแแแแชแแแแแก แแแแแแแฃแ แแแแก โแแ แแกแแญแแ แโ แแแแฅแแแแแแก แแแแแ แแแแก แจแแแแแ. แแกแแแ แกแชแแแแ แแก แแแแแแแ แแกแแชแแแแแแแ, แแฅแแแ แฃแแแ แแแแงแแแแ แแแแแซแแแ "แแแฃแแแแแแแ" แกแขแแขแฃแกแแ. แแก แแแจแแแแก, แ แแ แแแแฃแแแกแฎแแแแ แแแแแแแแแแ แฃแแฃแแแแแแงแแคแก แแ แแแแแซแแแก DaemonSet pod-แแแแก แแแแแแแแแกแแก. แแแแแแแแแแ แแ แฌแแจแแแก แแ แแคแแ แก แแ แกแแ แแแ แแแแแแ, แแแแ แแ แแกแแแ แแ แแแแแฃแจแแแแก แแฅ แแฎแแ แแแแขแแแแแ แแแก. แจแแแแแแ แแแแแฏแ แแ แแก แกแแแแแฆแแ แ แแแแแซแแก แแแแแแแแ, แแแฃ แแแกแแแ แแแจแแแแฃแแ แแแแแซแแแแก แแแแแขแแแ แกแฎแแ แแแแฅแแแแแ แแ แกแฎแแ แแแแแซแแแแ, แ แแแแแแกแแช แแฅแแ แกแแแแแ แแกแ แกแแแซแแแแ แ แแแแกแแแแแก. แแแก แจแแแแแ แ แแช แแแ แฌแแฃแแแแแแ, แ แแ แแฆแแ แแ แแก แแแแขแแแแแ แแแ แแ แแแแแซแแแแ, แจแแแแซแแแแ แแแแแฆแแ แแกแแแ Kubernetes-แแแแ. แแแแก แจแแแแแ แแกแแแ แฃแแ แแแแ แจแแฌแงแแแขแแ แแ แกแแแแแแก Kubernetes-แแกแแแแก. แจแแแแแแ, แแฅแแแ แฃแแแ แแแแแแงแแแแ AWS API แแ แแกแแญแแ แ แแแแแซแแแแก แแ แแแแฅแแแแแแก แแแแแ แแแแกแแแแก.
แจแแแแซแแแแ แแแแแแงแแแแ Amdatu Scalerd, แกแฎแแ แฆแแ แฌแงแแ แแก แกแแแแแ แแแแก แแแกแขแ แฃแแแแขแ, แแกแแแแกแ AWS API. แแก แฃแแ แฃแแแแแงแแคแก CLI-แก แแแแกแขแแ แจแ แแแแแซแแแแก แแแกแแแแขแแแแแ แแ แแแแกแแฆแแแแ. แแแกแ แกแแแแขแแ แแกแ แแแฎแแกแแแแแแแแแ แแ แแคแแแแก แแแแคแแแฃแ แแชแแแก แจแแกแแซแแแแแแแ แจแแแแแแ json แคแแแแแก แแแแแงแแแแแแ.
แแแฉแแแแแแ แแแแ แแแชแแ แแแก แแแแกแขแแ แแก แกแแแซแแแแ แแก แแแฎแแแแ แก แฆแแแแก แแแ แแแแจแ. แแก แแแแแคแแแฃแ แแ แแแก แ แแแแ แช แฎแแแแแกแแฌแแแแแ แแกแแแแแก แ แแแแแแแแแก, แแกแแแ Amazon แแแแกแขแแ แแก แกแแกแฃแ แแแ แแแชแฃแแแแแก. แแ แแแแ แแแแก แแแแแงแแแแแ แแแขแแแแขแฃแ แแ แจแแแแชแแ แแแก แแแแแซแแแแก แ แแแแแแแแแก แฆแแแแ แแ แแแแ แแแก แแแ แแแแแ, แแแแแแแแก แแแแแซแแแแก แแแแแงแแแแแแก แฆแแ แแแฃแแแแแก แฆแ แฃแแแแแแแ แกแแ แแแกแแแแ, แ แแแแ แแชแแ Amazon. แแก แคแฃแแฅแชแแ แแ แแ แแก แฉแแจแแแแแฃแแ Kubernetes-แจแ, แแแแ แแ Scalerd-แแก แแแแแงแแแแแ แกแแจแฃแแแแแแก แแแแชแแแ แแแแคแแ แแแแแ แแก แแแแขแคแแ แแ แแกแ, แ แแแแ แช แแกแฃแ แ.
แแแแแ แแฆแแแแจแแ, แ แแ แแแแ แ แแแแแแแแ แแแฃแแแแแ: โแแก แงแแแแแคแแ แ แแแ แแแ, แแแแ แแ แ แแช แจแแแฎแแแ แฉแแแก แแแแแชแแแแ แแแแแก, แ แแแแแแช แฉแแแฃแแแแ แแ แกแขแแขแแแฃแ แแ?โ แ แแแแ แจแแแแซแแแแ แแฌแแ แแแแ แแกแแแแกแ แ แแ แแแแแแแฃแ แแแ แแแแจแ, แ แแแแ แแชแแ Kubernetes? แฉแแแ แแแ แแ, แแฅแแแ แแ แฃแแแ แแแแแแแแ แแก, แแฅแแแ แแ แฃแแแ แกแชแแแแ แแแแแชแแแแ แกแแฌแงแแแแก แแแจแแแแ Kubernetes-แจแ. แแก แขแแฅแแแแฃแ แแ แจแแกแแซแแแแแแแ แแ แแแขแแ แแแขแจแ แแ แแก แแแแแแแแแแแ แแ แแแแแแ, แแแแ แแ แแก แกแแ แแแแฃแแแ แแแแ แแฃแแแแก แแฅแแแแก แชแฎแแแ แแแแก.
แแแแฎ, Kubernetes-แจแ แแ แกแแแแแก แแฃแแแแแ แแแฆแแแแแแแก แแแแชแแคแชแแ แแ แจแแแแซแแแแ แกแชแแแแ แแแแแชแแแแ แแแฆแแแแแแแก แแแจแแแแ, แ แแแแ แแชแแ Mongo แแ MySQL, แแแแ แแ แแก แกแแแแแแ แจแ แแแแขแแแแแ แแแแชแแแแ. แแก แแแแแฌแแแฃแแแ แแแแ, แ แแ แแแแแชแแแแ แกแแฌแงแแแแแ แกแ แฃแแแ แแ แฃแญแแ แแ แแฎแแ แก แแแแแแแฃแ แแแ แแแแกแแแ แฃแ แแแแ แแฅแแแแแแแก. แแแแแชแแแแ แแแแแแแก แฃแแแขแแกแแแแก แกแญแแ แแแแ แแแแจแแแแแแแแแ แแแแคแแแฃแ แแชแแ, แแแ แจแแ แแก แแแแกแขแแ แแก แฎแแแแ แแแแคแแแฃแ แแชแแ, แแ แแแกแฌแแแก แแแขแแกแแแแแ แแแ แแ แกแฎแแ แแกแแแแกแ แ แแ.
แแแแขแแ, แแฅแแแ แแ แฃแแแ แแแแ แแฃแแแ แแฅแแแแ แชแฎแแแ แแแ Kubernetes-แจแ แแแแแชแแแแ แกแแฌแงแแแแก แแแจแแแแแก แแชแแแแแแแ. แแแแฌแงแแ แแแแ แแฃแจแแแแ แขแ แแแแชแแฃแแ แแแแ แแแชแแแแ แกแแ แแแกแแแแก แแแแแงแแแแแแ แแ แฃแแ แแแแ แแแแฌแแแแ Kubernetes-แก แแแแ แแแแแงแแแแแแก แจแแกแแซแแแแแแแ.
แแแแแก แแแกแแกแ แฃแแแแแแ แแแแแ แแแแแชแแแ แแฃแแแ แแแขแแกแแ แแแคแฃแซแแแแฃแแ Cloud RTI แแแแขแคแแ แแ, แ แแแแแแแช แฉแแแ แแฃแแแ แแฃแจแแแแก. แแก แฃแแ แฃแแแแแงแแคแก แชแแแขแ แแแแแแแฃแ แแฃแ แแแแก, แแแแแแแชแแแแแกแ แแ แแแแกแขแแ แแแแก แแแแแขแแ แแแแก แแ แแแแ แกแฎแแ แกแแกแแ แแแแแ แคแฃแแฅแชแแแก, แ แแแแแแช แแแแแแแแแแแแ. แแก แแงแแแแแก แกแฎแแแแแกแฎแแ แฆแแ แฌแงแแ แแก แแแกแขแ แฃแแแแขแแแก, แ แแแแ แแชแแ Grafana แแแแแขแแ แแแแแก แกแแฉแแแแแแแแ.
แแแฉแแแ แแแแฎแแ แแแแก แจแแกแแฎแแ, แแฃ แ แแขแแ แแแแแแแงแแแแ ha-proxy แแแขแแแ แแแแก แแแแแแกแแ แ Kubernetes-แแแ. แแแ แแ แแแแฎแแแ, แ แแแแแ แแแแแแแ แแ แกแแแแแก แแแขแแแ แแแแก แแแแแแแแกแแแแก 2 แแแแ. แแฃแแแ แแแขแแก แกแแ แแแกแแแ แแแแแ แ แฉแแแ แแแ แขแฃแแแฃแ IP แแแกแแแแ แแแแแ. แแฅแแแ แแ แจแแแแซแแแแ แแแแแแงแแแแ แแกแแแ แแแ แขแแแแกแแแแก แแแ แ แแแกแแแแซแแ แแแแ แแขแแแแ, แ แแแแแ แแฃ Amazon แแแแแขแแแ แแแแก แแแแแก แฆแ แฃแแแแแแ แฐแแกแขแก, แแแกแแแแ แแ แจแแแชแแแแแ. แกแฌแแ แแ แแแแขแแ แแแแแแกแแแ ha-proxy-แก แกแแ แแแกแแแแก แฌแแ - แฃแคแ แ แกแขแแขแแแฃแ แ แกแขแ แฃแฅแขแฃแ แแก แจแแกแแฅแแแแแแ แขแ แแคแแแแกแแแแก Kubernetes-แแแ แจแแฃแคแแ แฎแแแแแ แแแแฃแแแแแชแแแกแแแแก.
แแแแแ แแ แแ แแแ แแ แแแแฎแแ แแ แแก แ แแแแ แจแแแแซแแแแ แแแ แฃแแแ แแแแแชแแแแ แแแแแก แกแฅแแแแก แชแแแแแแแแแแ แแฃแ แฏแ/แแฌแแแแ แแแแแแแแแแกแแก? แคแแฅแขแแ, แ แแ Kubernetes-แแก แแแแแงแแแแแแก แแแฃแฎแแแแแแ, แแแแแชแแแแ แแแแแก แกแฅแแแแก แจแแชแแแ แ แแฃแแ แแแแชแแแแ. แแฅแแแ แฃแแแ แแแ แฌแแฃแแแแ, แ แแ แซแแแแ แแ แแฎแแแ แกแฅแแแ แแแแกแแแแแแ, แ แแก แจแแแแแแแช แจแแแแซแแแแ แแแแแแฎแแแ แแแแแชแแแแ แแแแ แแ แจแแแแแ แแแแแแฎแแแ แแแแแ แแแแแแแชแแแแ. แจแแแแซแแแแ แกแฌแ แแคแแ แจแแชแแแแแ แแแแแชแแแแ แแแแ แแ แจแแแแแ แแแแแแฎแแแ แแแแแแแชแแแแ. แแ แแแชแ แแแแแแแแแแ, แ แแแแแแแแช แฉแแขแแแ แแแก แแแแแชแแแแ แแแแแก แกแ แฃแแแแ แแฎแแแ แแแแกแขแแ แ แแฎแแแ แกแฅแแแแ, แแก แแ แแก แแแ แแแแขแ, แแฃ แแฅแแแ แแแฅแแ แกแฅแแแแก แแแ แแจแ แแแแแชแแแแ แแแแ, แ แแแแ แแชแแ Mongo, แแแแ แแ แแก แแแแแช แแ แแ แแก แแแแแแ แแแแชแแแ. แแฃ แแแแแขแแแแแ แแแแฎแแแแ แแ แแแฅแแ, แแแแแแแแ แงแฃแ แแแฆแแแแกแแแแก!
แ แแแแแแแแ แ แแแแแแ ๐
แแแแแแแแ, แ แแ แแแ แฉแแ แฉแแแแแแ. แแแแฌแแแ แฉแแแแ แกแขแแขแแแแ? แแกแฃแ แ แแแฎแแ แฃแคแ แ แกแแแแขแแ แแกแ แจแแแแแ แกแ? แแฎแแ แ แแแแแแญแแ แแ แจแแแแแแแก แแแแแแแกแแแแ แแ แแแแแแ แแแแกแแแแก แ แแแแแแแแแชแแแ, , แกแแฌแงแแกแ แแแแแก แกแแ แแแ แแแแก แฃแแแแแแฃแ แ แแแแแแแ, แ แแแแแแช แฉแแแ แแแแ แแแแแแแแแแแ แแฅแแแแแแแก: (แฎแแแแแกแแฌแแแแแแ RAID1 แแ RAID10-แแ, 24 แแแ แแแแแแ แแ 40 แแ-แแแ DDR4).
Dell R730xd 2-แฏแแ แแแคแแ Equinix Tier IV แแแแแชแแแแ แชแแแขแ แจแ แแแกแขแแ แแแแจแ? แฒแฎแแแแ แแฅ แแแแแ แแแแแแแจแ! Dell R420 - 2x E5-2430 2.2Ghz 6C 128GB DDR3 2x960GB SSD 1Gbps 100TB - $99-แแแ! แฒฌแแแแแแฎแ แ แแฆแแชแแก แจแแกแแฎแแ
แฌแงแแ แ: www.habr.com