แแแกแฃแแ แฌแแแก แแแแแก แจแแแแ แ แฃแกแฃแแ PostgreSQL แกแแแแแแแแแแแก แแแ แแแ แแแ แแแแแ แ แขแ แแแกแแแชแแ , แ แแแแแก แแ แแกแแช แแแกแ แแแแแแแแคแฃแซแแแแแแ แแแแแแแ แกแแแแฎแแแแแแ แแกแแฃแแ แ Flan-แแก แขแแฅแแแแฃแ แแแ แแฅแขแแ แก แแแแแขแ แ แกแขแแแแแ แแแก แแ DBMS-แแก แจแแกแแฎแแ Kubernetes-แแก แแแแขแแฅแกแขแจแ.
แฉแแแ แแแฅแแแงแแแแ แแ แแแกแแฃแกแแแก แซแแ แแแแแ แแแฌแแแแก แฉแแแแฌแแ แก แแ แแฅ แแแแแฅแแแงแแแแฃแแแ แกแ แฃแแ แแแแแ:
แแแแแชแแแแ แแแแแแ แแ แแฃแแแ แแแขแแแ
NS: แแฆแแก แแ แแแกแแฃแแ แแแ แแแแฃแฃแแแ แแ แแแแจแแแ แแฃแแฅแขแแแแ. แฉแแแ แแแแแแ แแแกแแฃแแ แแ Kubernetes-แแ. แแแชแ, แ แแ แแ แแแแแฌแแแแแ แแแแแชแแแแแแ แแแฅแแก. แแ แแฃแงแฃแ แ แแฅแแแแก แแแแแแแแก แแ แ แแแแแแแแ แแแแแแแก แฎแแแแฎแแ แแฃแงแฃแ แ แแแแแช... แแแแแ แแแ แแแแแ แกแแฅแแแแ แแแแแแแแแ: แ แแขแแ แกแแแ แแแ Postgres แแ MySQL K8-แแแจแ?
แแก: แแ แแแแฎแแแแ แชแแแกแแฎแ แแแกแฃแฎแ แแ แแ แกแแแแแก แแ แแ แช แจแแแซแแแแ แแงแแก. แแแแ แแ แแแแแแแ, แแก แแ แแก แกแแแแ แขแแแ แแ แแแฎแแ แฎแแแฃแแแแ... แแแขแแแชแแแแ. แงแแแแแก แกแฃแ แก แแแ แแฃแแ แกแแ แแแกแแแ.
NS: แ แแแแ แแฎแแแแ แกแแฎแแจแ?
แแก: แแแแฎ: แ แแแแ แช RDS, แงแแแแแแ.
NS: โแแ แกแแโ แแแ แแ แแแ แแ. แแแ แแแแแแแแแแจแ แงแแแแแคแแ แ แแแแแแแแแฃแแแ แกแฎแแแแแกแฎแแ แแแแแแแก. แ แแขแแ แแแจแแ, แแฃ แแก แแ แแก แแแแ แแแแแแแแ, แแ แแแแฆแแก แแแ แแแแแฌแงแแแขแ? แแแแแแแแแ, Nutanix-แก แแฅแแก แกแแแฃแแแ แ แแแแแแแแ แแแ, แกแฎแแ แแแแแแแแแแก (VMware...) แแฅแแ แแแแแ โRDS, แแฎแแแแ แกแแฎแแจแโ.
แแก: แแแแ แแ แฉแแแ แแกแแฃแแ แแแ แชแแแแ แแแแฎแแ แชแแแแแแแแ, แ แแแแแแช แแฎแแแแ แแแ แแแแฃแ แแแ แแแแแจแ แแแฃแจแแแแแก. แแ แแฃ แแกแแฃแแ แแแ Kubernetes-แแ, แแแจแแ แแ แแก แฃแแแ แแแแแ แ แแ แแแแแคแแ แแแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แ (แ แแช แจแแแซแแแแ แแงแแก K8-แแแจแ). แแ แกแแแแแแ, แแก แแ แแก แกแขแแแแแ แขแ API-แแแแกแแแแก แฆแ แฃแแแแจแ...
NS: แแก แแกแแแ แฃแคแแกแแ!
แแก: แแก แแ แช แแกแ แแแแจแแแแแแแแแแ. แแแแแกแฃแคแแแแ แแแแจแแแแแแแแแแ แแแแ แแก แแ แช แแฃ แแกแ แแแแ แกแแแแแแขแแกแแแแก. แกแฎแแ แ แแแแ แแแแจแแแแแแแแแ... แแแแแ แแแฎแกแแแ แแแฎแกแแแแแโ"?
NS: แแแแฎ.
แแก: แแแแฎแแแ, แ แแ แซแแแแแ แแ แแแ แแแแแ แแแแฆแแก. แแแแก แแแแแ, แ แแ แแ แแแแแแแแ: โแแแญแแแ, แแแแ แงแแแแ แแแแแชแแแแ แแแแ แแฃแแแ แแแขแแแจแ แจแแแแงแแแแแ!โ, แแแแ แแ แแแแแฌแงแแแขแ, แ แแ แแก แงแแแแแคแแ แ แกแแจแแแแแ แแแแแกแแแแแแแ แแงแ. แแแแ แแ แกแฃแ แกแฎแแ แ แแแแก แแฅแแ แแแแแแแ: โแแแฎแ แ แ แฎแแแแ, แ แ แแ แแแแแแแแแ แแ แ แแแแ แจแแแซแแแแ แแแแ แแแแแแ แแแ. แแแแแแแงแแแแ แแฃ แแ แ แแฎแแ Kubernetes แแแแแชแแแแ แแแแแแ? แฌแแ แแแแแ? แแแ แแ, แแฎแแแแ แแ แจแแแแฎแแแแแจแ, แแฃ แแแแฌแแแก... แแแ แแแแฃแแ แกแแฅแแแก แแแแแแ. แแแแ แแ แแแแแแแแแ แแแแกแแแแก แจแแแแซแแแ แแแฅแแ, แ แแ แแแแก แแแ แฉแแแ. แแแแแแแแแ แแแแกแแแแก แซแแแแแ แแแแจแแแแแแแแแแ แแแ แแแแก แจแแฅแแแแก/แฌแแจแแแก แแแแแแแแแโ.
NS: Dev-แจแ แแฃแแแกแฎแแแแ แแฃ แแ แ แงแแแแ แแแ แแแแก, แ แแแแแแช แแ แแ แแก แแแแแแฃแจแแแแแฃแแ? แแแแแแ, แฎแแ แแกแฎแโฆ
แแก: แแฃ แแกแแฃแแ แแแ แแแ แคแแก แกแขแแแแแแแ, แแแจแแ แแแแแ แแ แ, แ แแแแแ แแฅ แแแแฎแแแแแแ แกแแแชแแคแแแฃแ แแ. แแฃ แแกแแฃแแ แแแ แแแแกแแแฃแแ แแแฃแ แจแแแแฎแแแแแแแ, แ แแชแ แซแแแแแ แแแแ แแแแแชแแแแ แแแแแ แกแแญแแ แ แแแกแชแแแแ แแแแกแแแแก, แแแจแแ แแแแแ แแ แ... แแฃ แแก แกแขแแขแแแฃแ แ, แฎแแแแ แซแแแแ แแแ แแแแ, แแแจแแ แ แ แกแแ แแแแแแแ แแแแฅแแก แแแแแชแแแแ แแแแแก K8-แแแจแ?
NS: แแ แชแแ แแ. แแแแ แแ แกแแ แแฎแแแแแ แกแขแแขแแแฃแ แ แแแ แแแแก? แกแขแแขแแแฃแ แ แแแ แแแ แฎแแแ แแแซแแแแแแแ.
แแก: แแแแแแ แจแแแซแแแแ แแงแแก แกแขแแขแแแฃแ แ. แแแงแแแก แแแแแแขแแแ...
NS: แแ, แแแช แแแฅแแก. แแแแ แแ แแแแแแแ, แแฃ แแแฅแแก 10 แขแแแแขแ แแแแแชแแแแ แแแแ แแ 200 แแ แแแแแแ...
แแก: แซแแแแแ แแแแแ แ แกแแฅแแ แแแฅแแก! แแแกแชแแแแ แแแแกแแก แแ แแก แแ แแแฃแฅแขแแก แแแแแชแแแแ แแแแ, แ แแแแแจแแช แชแแแแแแแแแ แฎแแแแ. แแ แแ แแก แฆแแแแแ: "แแแแแขแแแ แฌแแ แแแแแแจแ". แแก แชแแแแแแแแแ - แแแแขแ - แแแแแขแแแฃแแแ (แ แแแแ แช แฉแแแก, แแกแแแ แฃแแ แแแแ แกแแแฅแ แแแแแแแฃแแแ API-แก แแแจแแแแแแ) แฌแแ แแแแแแจแ. แแก แซแแแแแ แแแแแขแแแฃแ แ แแแ แแแแขแแ.
NS: แแ แแแแแฎแแแก แกแขแแ แขแแแแแ แฎแแแแแจแ, แ แแแแแแแช แกแฎแแแแ RDS-แจแ แแ แแฃแแแแช แฐแแ แแแฃแจแ - แแก แแ แแก 2-3 แฌแแแก แฌแแแแแแแแ แแกแขแแ แแแแ - แแ แแกแแแ แแแแแแฌแแ แแ แแแแแแกแแงแ แแแก แแแแขแแแจแ. แแแแก แแแแ, แ แแ แแแแแชแแแแ แแแแ แฏแแ แแแแแ แแฎแแแแ 80 GBแ, แฎแแแ แแแแขแแแแ แแ แแก แแแแแแ. แจแแแแแ แแกแแแ แงแแแฃแแแแแ แแแแแขแแแแ แแแกแแแแก แงแแแแแกแแแแก, แ แแแ แแแ แฐแฅแแแแแ 3 แแแแแชแแแแ แแแแ แกแฎแแแแแกแฎแแ แแแแแแแแ แแแแก แแแแกแแฎแแ แชแแแแแแแแ. แแกแแช แฎแแแแ. แแ แแกแแแ แแแแแแแฎแ, แ แแ แแแ แแ แแจแแแแแ แแแกแชแแแแ แแแแจแ แแแแแ แแแ - แแก แซแแแแแ แแแแแแแแแแฃแแแ แแแแแแแแแแ. แแแแ แแ แแกแแแ แแแแแแแฎแ, แ แแ แแแ แซแแแแแ แแจแแแแแ แแ แฎแจแแ แแ แแ แแฅแแ แกแแแแแ แแกแ แแ แ แแ แฎแแแแแ. แแแแ แแ แกแแแแ แแ แแแแแแ แแแแแแแแ, แแแแแ แแแแแแ แแฃแแแ แแแขแแก แจแแกแแฎแแ. แกแฌแแ แแ แแแกแแแก, แ แแ แฏแแ แแ แแแแ แแ แแก แแ แแ?
แแก: แฌแแ แแแแแแจแ แแแแฅแแก แแชแแ แ แแแแแชแแแแ แแแแแแ. แฉแแแ แแกแแฃแแ แแแ แแแแแแ แแแแแแแแขแแแ แแแชแฃแแแแแแแ แแ แแ แแแ แแขแแแฃแ แกแแ แแแกแแแแ, แ แแกแแแแกแแช แซแแแแแ แแแแแแ แแแแแ แแกแแแแแก แแแแแแแแ (แแ แแกแแแ แกแแญแแ แแแแ แแ แแ แแก). แแ แแ แแแ แแแแ, แ แแ แแฃแแแ แแแขแแก แฅแแแจ แแ แแก แแแ แแแแฃแ แ แจแแแแฎแแ. แแก แแแแแชแแแแ แแแแ แแฃแจแแแแแ แแแ แขแฃแแแฃแ แแแแฅแแแแจแ - แแแ แแแแแแ VMware-แจแ, แจแแแแฎแแแก แกแแกแขแแแแก แแแแแ. แฉแแแ แแแแแแแแกแแ แแแ แแ แแฎแแ แฉแแแ แจแแแแแซแแแ แแแกแ แแแแแขแแแ แแแแฅแแแแแแ แแแแฅแแแแแ.
NS: แแ แแแแแก แแแแแชแแแแ แแแแแแ, 100 แแ-แแแ, แจแแกแแซแแแแแแแ แ แแแแแแแแ แฌแฃแแจแ แแแ แ แแแกแแแแแ แแ แแแ แ แฅแกแแแแ, แแ แ? 1 แแ/แฌแแแจแ แกแแฉแฅแแ แ แแฆแแ แแ แแก แแแแแขแแแฃแ แ.
แแก: แแแแฎ, แฎแแแแแแแ แแแแ แแชแแแกแแแแก แแก แแ แแแแแแ แแ แแ แแก.
NS: แแแ แแ, แฃแแ แแแแ แแ แแแแ แฃแแแ แแแคแแฅแ แแ. แแ แแฃ แแแแแแฎแแแแแ Kubernetes-แก แแ แแแ แแแแฃแ แแแ แแแแจแ, แ แ แฃแแแ แแแแแแแแแ? แแแแก แแแแแแแแจแ แแฎแแแแ แแ แฃแแฉแแจแ , แแ แแก แแแแแ แ แแแแแแแแ แแแ แแแแขแ. แแ แแ แกแแแแแก - แแก แแ แแก แฉแแแแ แแแ แแ แแแแแแแ แ แแแแแ แ แแกแแแแแแแแแ: แ แแกแแช แแกแแแ แแแแแแแแ แแ แกแแแแแแ แแ แแ แแก แแฎแแแแ แแ แแแแแ แแแแแฌแแแแแ (), แ แแแแแจแแช, แแแ แแ แแแแแ Postgres-แแกแ, แแแ แแกแแแ แแแแแฌแงแแแขแแก แฉแแแงแแแแแแแแ แกแแ แแแแ แแ แกแแจแฃแแแแแ, Envoy proxy...
แแก: แแแกแแแแ แ แแกแแแแก? แแแแแ แแขแฃแแแ แแฌแแแแกแฌแแ แแแ Postgres-แแก แขแ แแคแแแก?
NS: แแแแฎ. แแแฃ, แแกแแแ แแแแก แแกแ แฎแแแแแแ: แแฃ แแฅแแแ แแแฆแแแ Linux แแแกแขแ แแแฃแชแแแก แแ แแแ แแแก, แแแจแแ แฉแแแฃแแแแ แแแ PostgreSQL แแ แแก แแแ แแแ แแ แแแ แกแฃแ แ แแแแแแแแ แแแกแขแ แแแฃแชแแ, แ แแแแแแช แแฅแแแแ แฆแ แฃแแแแแแแ แแ แแแจแแแแฃแแ Kubernetes-แแ. แแกแแแ แแแ แแแแแแแแ แแแแแแแแแขแแแก (แกแแ แแแแ แแ แแกแแแแก แแ แ.แจ.) แแ แแกแฌแแ แแแแ แแแ แแกแ, แ แแ แแแ แแแ แแแฃแจแแแ.
แแก: แฒซแแแแแ แแแแแ แ! แแ แกแแแแแแ, แแก แแ แแก แแ แแแ แแแ แแฅแแแแ แกแแแฃแแแ แ แแแ แแฃแแ Postgres-แแก แจแแกแแฅแแแแแแ.
NS: Linux แแแกแขแ แแแฃแชแแแก แแฅแแก แแแ แแแแฃแแ แแ แแแแแแแแ: แ แแแแ แจแแแฅแแแแ แแ แแแแแ แแแ แแกแ, แ แแ แงแแแแ แแแแ แแขแฃแ แ แแงแแก แแฎแแ แแแญแแ แแแ. แแ แแแ แแฅแแ แแแแ, แ แแ แแแฃแจแแแแแแ แแฃแแแ แแแขแแกแจแ. แแ แแแชแ, แ แแ Zalando แแแแ แแขแแ แจแ แฉแแแ แแฎแแแฎแแ แแแแฎแแ แแแแจแแ แ AWS-แแแ แแ แแก แแฆแแ แแ แแก แซแแแแแ แแแ แแ. แแ แฃแแแ แแงแแก แแแแแฃแแ แแแแแ แแขแฃแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแกแแแ - แแแจแแ แ แ แแแ แ แแฅแแก?
แแก: แแฃแกแขแแ แแ แแแชแ แ แ แกแแขแฃแแชแแแจแ แแแฎแแแ แแแแแแแ, แแแแ แแ Kubernetes-แจแ แกแแชแแแ แแฎแแ แแกแแ แแแแแแแแฃแแ, แ แแ แจแแฃแซแแแแแแแ แแแกแแแก แกแแ แแแแ แแ แแกแแแก แแฆแแแ แแแแแแ แแแแแแแ. แชแแขแ แฎแแแก แฌแแ แกแขแแแแแ แขแจแ - แฃแแฎแแแก แแแ แกแแแจแ โ แฉแแแ แจแแแซแแแแ แแแแ แแแแก แแแแแฆแแแ, แแแแ แแ แกแแ แแ แแก แแแแแ แแแแ? แแแ แแแแ แแแแฎแ แแ, แงแแแแแคแแ แ แฏแแ แแแแแ แแกแ แแแแแแฃแแแ... แฉแแแ แแชแแแแแแ CSI-แก AWS, GCE, Azure, vSphere-แแก แแแแแ, แแแแ แแ แ แแแแ แช แแ แแแแฌแงแแแ แแแก แแแแแงแแแแแแก, แฎแแแแแ, แ แแ แฏแแ แแ แแ แแก แแแแ.
NS: แแแแขแแ แแแแฏแแ แแแแฌแแแก แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแแแแ. แแคแแฅแ แแ, แแก แฏแแ แแแแแ แแแ แแฃแแ แแขแแแแ - แแแแ แแ แขแแแแแแแแ. แจแแแแแฎแแ: แ แ แ แฉแแแแก แแแกแชแแแแแ แแฎแแแแแแแแก, แ แแแแแแกแแช แกแฃแ แ แกแชแแแแ PgSQL K8-แจแ? แ แแแแแ แแแแ แแขแแ แ แจแแแซแแแแ?
แแก: แแ แแแแแแ แแก แแ แแก, แ แแ Postgres แฉแแแแแแแก แแ แแก 3%. แฉแแแ แแกแแแ แแแแฅแแก Kubernetes-แจแ แกแฎแแแแแกแฎแแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แซแแแแแ แแแแ แกแแ, แแ แแ แแ แฉแแแแแแแแ แงแแแแแคแแ แก. แแแแแแแแแ, Elasticsearch. แแแแ แ แแแแ แแขแแ แแ: แแแแ แแฅแขแแฃแ แแ แแแแแ แแแแ, แแแแ แแ แ. แฉแแแ แจแแแแแฃแจแแแแ แแแแฎแแแแแแ แฉแแแแแแแก แแแแก แจแแกแแฎแแ, แแฃ แ แ แฃแแแ แฐแฅแแแแแก แแแแ แแขแแ แก, แ แแ แกแแ แแแแฃแแแ แแแแแฆแแ แแแ. แแแแ แแขแแ แจแ แกแแแชแแแแฃแ แแ Kubernetes-แแกแแแแก - แแ แ "แแแแ แแขแแ แจแ, แ แแ แ แแฆแแช แแแแแแแแก Amazon-แแก แแแ แแแแแจแ"... แกแแแแแแแแแแจแ, แฉแแแ แกแแแแแแ แคแแ แแแ (= แแแแฅแแแก แงแแแแ แแแแแแขแ) แแแงแแแแแ แแ แ แแแแ แแขแแ แก - (แแแก แจแแกแแฎแแ แกแขแแขแแแก แแแแ แแแแแแแฅแแแงแแแแ).
NS: แแ แแ แช MySQL-แกแแแแก? แแ แแแชแ, แ แแ Percona... แ แแแแแ แแกแแแ แแฎแแ แแฃแจแแแแแ MySQL, MongoDB แแ Postgres-แแ, แแแ แแแฃแฌแแแ แจแแฅแแแแ แ แแแแ แกแแฎแแก แฃแแแแแ แกแแแฃแ แ แแแแแฌแงแแแขแ: แงแแแแ แแแแแชแแแแ แแแแแกแแแแก, แงแแแแ แฆแ แฃแแแแแแแ แแ แแแแแแแ แแกแแแแก.
แแก: แฉแแแ แแ แแแฅแแแแ แแ แ, แ แแ แแแแแแฎแแแแ แแแแ แแขแแ แแแก MySQL-แแกแแแแก. แแก แแ แแ แแก แฉแแแแ แแแแแแ แ แแฅแชแแแขแ แแฎแแ. MySQL แแแ แแแ แแฃแจแแแแก แแแแแฃแแแแแแแแ. แ แแขแแ แแแแแแแงแแแแ แแแแ แแขแแ แ, แแฃ แแฅแแแ แจแแแแซแแแแ แฃแแ แแแแ แแแฃแจแแแ แแแแแชแแแแ แแแแ... แจแแแแซแแแแ แแแฃแจแแแ Docker แแแแขแแแแแ แ Postrges-แแ, แแ แจแแแแซแแแแ แแแฃแจแแแ แแแ แขแแแ แแแแ.
NS: แแแแแแช แแงแ แจแแแแแฎแแ. แแแแ แแขแแ แ แกแแแ แแแ แแ แแ แแก?
แแก: แแแแฎ, แฉแแแแแแ 100%-แก แแฅแแก PostgreSQL แแแจแแแแฃแแ แแแแ แแขแแ แแก แแแ แแจแ. แฏแแ แฏแแ แแแแ แแกแ. แฉแแแ แแฅแขแแฃแ แแ แแแงแแแแแ แแแแ แแขแแ แก Prometheus-แแกแ แแ Redis-แแกแแแแก. แฉแแแ แแแแฅแแก แแแแแแแ, แ แแ แแแแซแแแแแ แแแแ แแขแแ แ Elasticsearch-แแกแแแแก - แแก แแ แแก แแก, แแแแช แงแแแแแแ แแแขแแ โแชแแชแฎแแจแแโ, แ แแแแแ แแแกแฃแ แก แแแกแ แแแงแแแแแ Kubernetes-แจแ 100% แจแแแแฎแแแแแจแ. แแกแแแ, แ แแแแ แช แฉแแแ แแแแแแ แฃแแ แฃแแแแแแงแแ, แ แแ MongoDB แแกแแแ แงแแแแแแแแก แแแแแกแขแแแแ แแแฃแแแ Kubernetes-แจแ. แแฅ แฉแแแแแ แแแ แแแแฃแแ แกแฃแ แแแแแแ - แแ แแก แแแแชแแ, แ แแ แแ แจแแแแฎแแแแแแจแ แจแแแซแแแแ แ แแฆแแชแแก แแแแแแแแ. แฉแแแ แแ แช แแ แแฃแงแฃแ แแแแแ แแแกแขแแ แแกแก. แ แ แแฅแแ แฃแแแ, แฉแแแ แแแชแแ, แ แแ แแ แกแแแแแก แกแฎแแแแแกแฎแแ แแแ แแแแขแ, แแแแ แแ แกแแแแแแแแแแจแ แฉแแแ แแแแฅแแก แแแแแฃแแแแแแแแ.
DB แขแแกแขแแ แแแแกแแแแก Kubernetes-แจแ
NS: แแแแแแแแแ แขแแกแขแแ แแแแก แแแแแแ. แ แแแแ แแแแแคแแ แแแแแ แชแแแแแแแแแ แแแแแชแแแแ แแแแแจแ - DevOps-แแก แแแ แกแแแฅแขแแแแแแ. แแ แแก แแแแ แแกแแ แแแกแแแ, แแแแ แ แแแแแชแแแแ แแแแ, แ แแฆแแช แแชแแแแแ แกแแแฆแแช แแฃแแแแแแ. แ แแแแ แฃแแ แฃแแแแแแงแแ แแแ แแแแฃแ แ CI/CD แแกแ, แ แแ แงแแแแแคแแ แ แฌแแกแ แแแจแ แแงแแก DBMS แแแ แกแแแฅแขแแแแแแ. แ แแแแ แแ แแฅแแแแ แแแแแแแ?
แแก: แแ แแ แแแกแฃแฎแ แแ แจแแแซแแแแ. แ แแแแแแแแ แแแ แแแแขแแ. แแแ แแแแ แแ แแก แแแแแก แแแแ, แ แแแแแแช แแแแแแ แแแแแคแแ แแแแแ. แแฅแแแ แแแแแ แแฎแกแแแแ, แ แแ แแแแแแแแแแก แแแแกแฎแแแแแแฃแแ แแแแแแแแแแฃแแแแ แแฅแแ แแแแแแแแแ แกแ แแ แกแชแแแแแ แแ แแ แแแแแชแแแแ แแแแแก แแกแแแก แแ แกแแแแแแก แแแแแ แ.
NS: แแ GDPR-แแก แแแ แแแแแจแ, แแคแแฅแ แแ, แฃแคแ แ แแ แฃแคแ แ แคแ แแฎแแแแแแ... แจแแแแซแแแ แแแฅแแ, แ แแ แแแ แแแแจแ แฃแแแ แแแแฌแงแแก แฏแแ แแแแแแก แแแฌแแกแแแ.
แแก: แแแแ แแ แฎแจแแ แแ แจแแแแซแแแแ แแแฌแแ แแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแ, แ แแแแแแช แแแแแฆแแแก แแแแแแกแแงแ แแแก แฌแแ แแแแแแแแ แแ แแฃแแแแแแแแแก. แแ แแแฃแฅแขแแก แแแแแชแแแแแ แแแแฆแแแ (แกแแแแจแแขแ, แแแแแแกแแงแ แแแ, แแ แแแแแ แแกแแ...), แแแแ แแ แแแแแแแฃแ แแ. แแแแก แแแชแแแแ, แจแแแซแแแแ แแ แกแแแแแแแก แแแแแ แแ แแแแก แกแแ แแแขแแแ: แแก แจแแแซแแแแ แแงแแก แแแฌแงแแแแแแแแแ แแ แฃแแ แแแแ แกแแ แแแขแ, แ แแแแแแช แฅแแแแก แแแ แแแแแชแแแแ แแแแแก. แแ แแแแแแ แแ แแก: แ แแแแแแ แแ แ แกแญแแ แแแแ แกแแแแแแกแ แกแฃแ แแแแก แจแแฅแแแแก? แแ แ แแแแแแ แแ แ แกแญแแ แแแแ แแแก แแแแแแแแแแก แกแแกแฃแ แแแ แแแ แแแแจแ?
แฉแแแ แแแแแแแ แกแฅแแแแแแ: แแฃ แแแแแแขแก แแฅแแก แคแแฅแกแแ แแแฃแแ แแแแแชแแแแ แแแแ แแแ (แแแแแก แแแแแแแแฃแ แ แแแ แกแแ), แแแจแแ แฉแแแ แแแงแแแแแ แแแ แแแแฃแแแกแฎแแแแแ. แแฃ แฉแแแ แแกแแฃแแ แแแ แแแแแฎแแแแแก แแแ แแแแแ, แ แแแแกแแช แฉแแแ แแฅแแแแแแ แคแแแแแแก, แฉแแแ แแแแแแแแแกแแ แแแแแแแชแแแก แแแกแขแแแชแแ - แฉแแแ แแแแแคแแ แแแแแแ แแแขแแ แ แแแแแชแแแแ แแแแแก. แแแแ แแ แแแ แแแ แแแแแแแแ , แ แแแแกแแช แฉแแแ แแแฆแแแ แแแแแแกแแงแ แแแก แแ แแแฃแฅแชแแแแแ แแฆแแจแ แแ แแฎแแ (แฆแแแ) แแ แแแจแแแแแ Docker แแแแขแแแแแ แก PostgreSQL-แแ แแ MySQL-แแ แแ แแแขแแแ แแฃแแ แแแแแชแแแแแแ แแแกแแ แแแงแ แแแแแแ. แแฃ แแญแแ แแแแแ แแแแแชแแแแ แแแแแก 50-แฏแแ แแแคแแ แแแแแ แแ แกแฃแ แแแแแแ, แแก แแแแแแแ แกแแแแแแ แแแ แขแแแแ แแ แกแฌแ แแคแแ.
NS: แแแ แขแแแ แแแแแ แแแแ?
แแก: แแแแแชแแแแแ แแแแฎแแแ แแแ แแแแแ แแแแแ แแก แกแฃแ แแแจแ. แแแแ. แฉแแแ แแแแฅแแก แแแ แกแฃแ แแแ, แแฃแแชแ 100 GB. Docker-แจแ แคแแแแแแก แฌแงแแแแแแ, แฉแแแ แจแแแแแซแแแ แกแฌแ แแคแแ แแแแแแแแแกแแ แแก แกแฃแ แแแ แ แแแแแแฏแแ แแช แแแญแแ แแแแ. แแแแแแ แกแฃแแแแฃแ แแ, แแแแ แแ แแแ แแแ แแฃแจแแแแก.
NS: แแแ แ, แ แแชแ แขแแกแขแแ แแแ, แแก แแชแแแแแ แแแ แแแแแ แแแแแ แจแ, แแ แ? แแแแแแแแ แแ แฉแแฌแแ แ Docker-แจแ - แแแแแแแแแ แแ แแกแแ แฌแแแแ, แงแแแแแคแแ แ แแแ แแแแแ. แฒแแแกแ! แแ แแฅแแแ แฃแแแ แแงแแแแแ แแแก แกแ แฃแแแ?
แแก: แฒแแแ แฎแแแแก แแแแแแแแแแจแ.
NS: แฉแแแ แซแแแแแ แแกแแแแก แ แแฆแแชแแแแก โโแแแแแแแแ. แแฎแแแแ แฉแแแ แแ แแแงแแแแแ Docker-แแก แแกแแแก แฉแแฌแแ แแแ, แแ แแแแ แกแฎแแแก.
แแก: แแก แแ แแ แแก แแแแแแ. แแ Docker แแฃแจแแแแก แงแแแแแแ.
NS: แแแแ แแฃแแแ แแ. แแแแ แแ แฉแแแ แแกแแแ แแแแฅแแก แแแแฃแแแแ, แจแแแแซแแแแ แแแแแแแแ แกแฎแแแแแกแฎแแ แแแแฃแแ แแ แแแฃแจแแแ แกแฎแแแแแกแฎแแ แคแแแแฃแ แกแแกแขแแแแกแแแ. แ แ แแแแแแขแแ แแฅ. แแแกแขแแ แแกแแก แแฎแ แแแแ แฉแแแ แแ แงแแแแแคแแ แก แกแฎแแแแแแ แแ แแฃแงแฃแ แแแ. แแฎแแ แแแแแ แแก แแฎแ แแแแ แแแแแฎแแแ แแ แแแแแแแฎแ, แ แแ แงแแแแแคแแ แ แจแแแแแแก แแฃแจแแแแก. แแแแ แแ แแฃ แแแแแชแแแแ แแแแ แฃแแแ แแแแแ แแ, แแแแแแแแแ, 1 TB, แแแจแแ แแ แงแแแแแคแแ แก แแแแ แแ แ แกแญแแ แแแแ: แแแแ แแชแแแแ แฆแแแแ แแ แงแแแแแคแ แแก แฉแแงแ แ Docker-แจแ... แแ แแฃ 5 TB แฉแแงแ แแแแ Docker-แจแ... แแแฃ แงแแแแแคแแ แ แแแ แแแแแ?
แแก: แ แ แแแแกแฎแแแแแแแ: แแก แแ แแก แแแแแแแ, แแฎแแแแ แแแขแแแ แแ แแแแขแแแ.
NS: แแแแกแฎแแแแแแ แแกแแ: แแแแก แแแแแแแ แแแแแแกแแงแ แแแแก แแ แ แแกแขแแแ แแ แแแแก แแแแ?
แแก: แกแฃแแแช แแ แแ แแก แกแแญแแ แ. แแ แกแฃแ แแแแก แแแแแ แแ แแแแก แแแแแแแแ แจแแแซแแแแ แแแแกแฎแแแแแแฃแแ แแงแแก.
NS: แแแแแแ แแ แแแแแแขแแกแแแแก แฉแแแ แจแแแฅแแแแแ แแก แแกแ, แ แแ แแแแก แแแชแแแแ, แ แแ แ แแแฃแแแ แฃแแแ แจแแแฅแแแแ แกแแแแแแกแ แกแฃแ แแแ, แแฃแแแแแแ แแแแแฎแแ แแก. แแก แแ แกแแแแแแ แแ แแก แ แแแแแแ, แแแแ แแ แแก แแฆแแแก แแแแแชแแแแแก แแ แ แฃแจแฃแแแแ แแกแขแแขแแกแแแ, แแ แแแแ แแ แฅแแแแก แแแจแแแแแแ. แแ แแแแแ แแ แฅแแแ, แกแแแแช แงแแแแแแฆแ แแขแแแ แแแแ WAL-แแแ, แกแแแแช แฎแแแแ แกแแ แแแแ แแ แแกแแแแแก แแแแแฆแแแ... แจแแแแแ แแก WAL-แแแ แแชแแ แ แแแแแแแแแแแ (แกแแขแงแแแกแแขแงแแแ 1-2 แฌแแแแ) แแฆแฌแแแก แกแแแแแแกแ แกแฃแ แแแก. แฉแแแ แแแกแแแ แแแแแแ แแแแ แแแแแกแแแแ แ แแแแ - แแฎแแ แฉแแแ แแแแฅแแก แกแขแแแแแ แขแฃแแแ ZFS.
แแก: แแแแ แแ ZFS-แแ แแฅแแแ แจแแแแแคแแ แแแแแแ แแ แแ แแแแแซแแ.
NS: แแแแฎ. แแแแ แแ ZFS แแกแแแ แแฅแแก แฏแแแแกแแฃแ แ : แแแกแแแ แแ แแแ แจแแแแซแแแแ แแแแแแแแแแแแ แกแแแแจแแขแ แแ แแฃแแแแช (แแก แฏแแ แแแแแแแแแ แแ แแแแแแแชแแแ, แแแแ แแ...) แจแแแแซแแแแ แแแแแแแแแ แแแแขแ แแ แก แจแแ แแก PGDATA. แกแแแแแแแแแแจแ, แฉแแแ แแแแฅแแก แแแแแ แแ แแ แแแกแขแ แฃแแแแขแ, แ แแแแแแช แแแแแแแแแ แแ แแแแแแแฎแแแแแก แแกแแแ แแแแชแแแแแแกแแแแก. PostgreSQL แแฅแแก , แ แแแแแแช แแฃแจแแแแก แ แแแแ แช "แญแแแแแแ" rsync, แแแแแขแแแแแก แแแแ แ แแแแก, แ แแกแ แงแฃแ แแแแช แแ แแญแแ แแแแแ, แ แแแแแ แแฅ แแ แแคแแ แ แจแแชแแแแแ. แฉแแแ แจแแแแแซแแแ แแแแแแแแแ แกแฌแ แแคแ แกแแแฅแ แแแแแแชแแ แแ แกแแ แแแ แก แจแแ แแก แแ แแแแแแแฎแแแแ แแแแแ แแแแ.
แแกแ แ แแ, แแ, แฃแคแ แ DBA แแฎแ แแแแ, แฉแแแ แแชแแแแแแ แจแแแฅแแแแ แแแกแขแ แฃแแแแขแ, แ แแแแแแช แกแแจแฃแแแแแแก แแแแแชแแแก แแแแแแแแแ แแแแแ, แ แแช แแฅแแแ แแฅแแแ: แฉแแแ แแแแฅแแก แแ แแ แแแแแชแแแแ แแแแ, แแแแ แแ แแแแแแ แ แแฆแแชแแก แขแแกแขแแ แแแ 50-แฏแแ , แแแแฅแแแก แแ แแแ แแฃแแแ.
แแก: 50-แฏแแ แแแจแแแแก, แ แแ แแฅแแแ แฃแแแ แจแแฃแแแแแแ 50 Spot แแแกแขแแแชแแ.
NS: แแ แ, แงแแแแแคแแ แก แแ แ แแแแ แแขแแ แแแแแแแแ.
แแก: แแแแ แแ แ แแแแ แแแแคแแ แแแแแแ 50-แฏแแ , แแฃ แแก แแ แแ แแแแแชแแแแ แแแแ แแ แแก, แแแฅแแแ, แขแแ แแแแแขแ. แกแแแแ แแฃแแแ แแแก แกแญแแ แแแแ แแแ แแแแแ 256 GB แแแแ แแขแแฃแแ แแแฎแกแแแ แแแ?
NS: แแแแฎ, แฎแแแแแฎแแ แแแแ แแแฎแกแแแ แแแ แแญแแ แแแแแ - แแก แแแ แแแแฃแ แแ. แแแแ แแ แแก แแ แแก แแแแแแแแ แชแฎแแแ แแแแแแ. แฌแแ แแแแแแก แแแแฅแแแแก แแฅแแก 96 แแแ แแแ แแ 600 GB. แแแแแแ แแฃแแแ, แแแแแชแแแแ แแแแแกแแแแก แแแแแแงแแแแแ 32 แแแ แแแ (แแฎแแ 16 แแแ แแแแช แแ) แแ 100-120 แแ แแแฎแกแแแ แแแ.
แแก: แแ 50 แแแแแแแแแ แ แฏแแแแ?
NS: แแกแ แ แแ แแ แแก แแฎแแแแ แแ แแ แแแแแแแแแ แ, แจแแแแแ แแฃแจแแแแก Copy-on-Write (ZFS)... แฃแคแ แ แแแขแแแฃแ แแ แแแขแงแแแ.
แแแแแแแแแ, แฉแแแ แแแแฅแแก 10 TB แแแแแชแแแแ แแแแ. แแแ แแแแแแแแก แแแกแแ, ZFS-แแ แแกแแแ แจแแแฃแแจแ แแแกแ แแแแ 30-40 แแ แแชแแแขแแ. แแแแแแแแ แฉแแแ แแ แแแแแแแแ แแแขแแแ แแแแก แขแแกแขแแ แแแแก, แแแกแฃแฎแแก แแฃแกแขแ แแ แ แฉแแแแแแแก แแ แแ แแก แแแแจแแแแแแแแแ: แแแแแ, แแก แแงแแก 2-แฏแแ แฃแคแ แ แแแแ - แแก แแแ แแแ.
แจแแกแแซแแแแแแแแก แแแซแแแแ แแ แแแ แแแแกแขแแแก, QA, DBA แแ แ.แจ. แจแแแกแ แฃแแแ แขแแกแขแแ แแแ 1-2 แซแแคแจแ. แแแแแแแแแ, แแแ แจแแแซแแแแ แแฌแแ แแแแ แ แแแแ แกแแฎแแก แแแแ แแชแแ. แแแก แแ แกแญแแ แแแแ 10 แแแ แแแ แแ แแแ แแฃแแแ - แแแก แกแญแแ แแแแ 1 Postgres backend, 1 แแแ แแแ. แแแแฌแงแแแ แแแแ แแชแแ - แจแแกแแซแแแ แแแแแ แแแแฌแงแแแ, แจแแแแแ แแแแแงแแแแแฃแแ แแฅแแแแ แแแแ แ แแแ แแแ. แฉแแแ แแแแฅแแก 16-32 แแแ แแแ แแแแแงแแคแแแ, แแกแ แ แแ 10 แแแแแแแแ แแ แแแ แแฃแแแ แแฃแจแแแแก, แแ แแแแแแ แแ แแ แแก.
แ แแแแแ แคแแแแแฃแ แแ PGDATA แแแแแ, แแแแแแแก, แ แแ แฉแแแ แ แแแแฃแ แแ แแแขแงแฃแแแ Postgres-แก. แฎแ แแแ แแกแแแแ: แแแแแแแแแ, 10 Postgres แแ แแแ แแฃแแแ แแแจแแแแฃแแแ. แ แ แแ แแก แแ แแแแแแ แฉแแแฃแแแแ แแ? แฉแแกแแแก แแแฅแแแ 25%. แจแแกแแแแแแกแแ, แแก แแ แแก 200 GB. แแฅแแแ แแแ แจแแซแแแแ แแแแแแ แกแแแแ แแแขแแก แแแจแแแแแก, แ แแแแแ แแแฎแกแแแ แแแ แแแแแฌแฃแ แแแ.
แแแแ แแ แ แแฆแแช แแแแแแขแจแ แแแแฎแแแแ, แ แแ แแก แแ แแงแ แกแแญแแ แ: แฉแแแ แแแแแงแแแแ shared_buffers 2 แแ-แแ. PostgreSQL แแฅแแก , แแ แ แแแแฃแ แแ แแก แแ แแแแแ แแแ, แแแแช แแแแแแแแก แแฎแแแแก . แฉแแแ แแแแแงแแแแ 0,5 แขแ. แแ แแ แช แแ แแฅแแก แแแแจแแแแแแแ, แ แแ แแกแแแ แ แแแแฃแ แแ แแ แแ แกแแแแแแ: แแก แแกแ แแงแแแแแแแก แแแแแแแก, แแแแฅแแก แแกแแแ แแ แกแแแแแแ.
แจแแกแแแแแแกแแ, แ แแแแกแแช แฉแแแ แแแแแฌแแแแ แ แแแแ แกแแฎแแก แแแแ แแชแแแก, แฉแแแ แจแแแแแซแแแ แจแแแแแ แแแแ แงแแแแ แแแแแ - แแแแฎแแ, แ แแแแ แแแฎแแแแ แแก แฌแแ แแแแแแจแ. แฌแแแแแ แแฅ แแฅแแแแ แแแแกแฎแแแแแแฃแแ (แฃแคแ แ แแแแ), แแแแ แแ แแแแแชแแแแแ, แ แแแแแแกแแช แ แแแแฃแ แแ แแแแแฎแฃแแแแ แแ แแแแแ แแแแแแแ (แ แ แแ แแก JOIN-แแแ แแ แ.แจ.) แแฃแกแขแแ แแกแแแแแ แแแแแแแก, แ แแแแ แช แฌแแ แแแแแแจแ. แแ แแฅแแแ แจแแแแซแแแแ แแแฃแจแแแ แแ แแแแแ แแกแแแ แจแแแแฌแแแแ แแแ แแแแแฃแ แแ แแ แ แแแแฅแแแแแ.
แแก: แแ แคแแฅแ แแแ, แ แแ แแฅ แ แแแแแแแแ แแ แแแแแแแ? แแแ แแแแ แแ แแก แแแแแกแแแแแ, แ แแแแแแช แแฃแจแแแแก แแฎแแแแ PostgreSQL-แแ. แแก แแแแแแแ แซแแแแแ แแแ แซแแ, แแก แแ แแ แแก แแแแแแ. แแแแ แ แแ แแก แแก, แ แแ Kubernetes (แแ แงแแแแแคแแ แ, แ แแกแแช แแฎแแ แฆแ แฃแแแแแแแ แขแแฅแแแแแแแแแ แแแแ แแแแ) แแแแชแแแก แแแแ แแแแแซแก แแ แแก แแแแแซแแแ แแคแแแแ แฃแแแ. แแ แแฅแแแแก แจแแแแฎแแแแแจแ แแก แแ แแก แกแแฎแแแแฌแแคแแแแ แแแ, แแฃแแแแแ แแแแแซแ. แแก แ แแฆแแชแแแแ แแแแซแฃแแแแก แแแแคแแแฅแขแก.
NS: แแแ แแแแ, แแแแแแฎแแแแ, แแก แฌแแแแแ แแแกแขแแ แแกแแก แแแแแแแ. แแคแแฅแ แแ, แแฃ แฉแแแ แแแแฅแแแแ แ แแแแ แกแแฎแแก แแแ แแแแแ แ IO แแ แแฃแคแแ แฃแแ แแฃแแ แแแแฅแแแก แแแแแ แแแฎแกแแแ แแแแกแแแแก, แแก แแแแแแแ แแ แแแฃแจแแแแแก - แแแแแแแ แแแแกแฎแแแแแแฃแแ แแฅแแแแ. แแแแ แแ แแฎแแ แฉแแแ แแฎแแแแ Postgres-แแแ แแแฃแจแแแแ, แกแฎแแแแแ แแ แแคแแฅแ แแแ.
Kubernetes-แแก แจแแกแแฎแแ. แแฅแแแ แแแแแแ แแแแฃแแแแแแ แงแแแแแแ, แ แแ แฉแแแ แแแแฅแแก แแฃแแแแแ แแแแแชแแแแ แแแแ. แแฃ แแแกแขแแแชแแ แแแ แแแฎแแ แฎแแ, แแแแแแ แแ แแแกแแแก แจแแแแฎแแ. แแฅ แแกแแแ แแแแฅแแก แแแแแ แแแแขแคแแ แแ Kubernetes-แจแ แแ แแแแแแแแแขแ Postgres-แแแ แแ แแแ แชแแแแแ (แแฃแแชแ แแก แแฅแแแแ แแ แ แแฆแแก). แแแจแแกแแแแแ, แงแแแแแคแแ แ แแกแแ: แแแกแขแแแชแแ แแแแชแ, แแแแ แแ แฉแแแ แแแแแแแ แฉแแแแ แแแกแ PV แแ แฃแแ แแแแ แแแแฃแแแแจแแ แแแ แกแฎแแ (แแฎแแ) แแแกแขแแแชแแแก, แแแแฅแแก แแ แแคแแ แ แแแแฎแแแ แ.
แแก: แฉแแแ แแแแแแกแแฎแแแแแแ, แฉแแแ แแฅแแแแ แแแแแแก Kubernetes-แจแ. K8 - แแแแกแขแแฃแ แ: แแแแแซแแแ แจแแแแแแแแแ แกแแญแแ แแแแแกแแแแแ . แแแแชแแแแ แฃแแ แแแแ แจแแฅแแแแ แแแแ แแ แแฅแแแ, แ แแ แแแก แกแญแแ แแแแ X แแแแแแแแก แ แแกแฃแ แกแ, แจแแแแแ แแ K8s แแแแแ แแแแ แแแแแ. แแแแ แแ Kubernetes-แจแ แจแแแแฎแแแก แแฎแแ แแแญแแ แ แฏแแ แแแแแ แแ แแกแขแแแแแฃแ แแ: In (แแก แแแแแชแแแ แแแแแแแแ ะฝะตะดะตะปะธ แแแ แ) แแก แคแฃแแฅแชแแแแ แแฎแแแแ แแแขแ แแแฎแแ.
แแฅแแกแ แแแแแแ แแ แ แฌแแแแแ แแแแ - แแแข-แแแแแแแแ แกแขแแแแแฃแ แ แแแฎแแแแ, แแ แกแฃแแแช แแกแ แแแแแชแฎแแแแแแ. แจแแแแแ แกแแแแจแแขแแแแกแ แแ แแแแแก แจแแชแแแแก แจแแกแแซแแแแแแแ แแแแแแแแ แแแแแ แแแก แแฅแแแแก แแ แแแแแแแก. แแแแขแแ แ แแ แแแแ แแแฅแแก. แแแแฎ, แแก แจแแแซแแแแ แแ แแงแแก แซแแแแแ แกแฌแ แแคแ, แแแแ แแ แกแแฉแฅแแ แ แแแแแแแแแแฃแแแ แแแแแ, แแฃ แ แ แแ แแก "แฅแฃแแแก แฅแแแจ", แ แแแแแ แแแแแแ แ แแแแฎแแ แชแแแแแแแก แจแแฃแซแแแ แแแแแแแแ แแก แแ แแแแแแแแ แแก แฉแแฌแแ แ แแแกแแแก แฅแแแกแแกแขแแแแก แแแแแแ.
NS: แแกแแแ แแฃแชแแแแแแแแ แงแแแแ แซแ แแแแ (Amazon, Google...) แแแแฌแงแแก แแ แแแ แกแแแก แแฎแแ แแแญแแ แ - แแแแกแแช แแแ แแแแฃแแ แแ แ แกแญแแ แแแแ.
แแก: แฉแแแ แฏแแ แแ แแแงแแแแแ แแแ. แฉแแแ แแแงแแแแแ แฉแแแแก.
แแแแแแแแ แแแ แแแแแแแแ แแแ Kubernetes-แแกแแแแก
NS: แแแแกแแ แจแแแฎแแแแ แแแ แแกแแแ แกแฃแ แแแแ, แ แแชแ แแแแญแแ แแแแแ แงแแแแ แฏแแจแแก แแแงแแแแแ แแ แ แแแแฅแแแแแ แแ แแกแแแ แแแขแแ แ แขแแกแขแแก แแแแแแแแ. แแแแกแแแแแก, แ แแ แกแฌแ แแคแแ แแแแฆแแ แแแแชแแคแชแแแก แแขแแแชแแแฃแแแแ, แแแฎแแ, แ แแ แแแแแแแชแแ แแฃแจแแแแก Kubernetes-แจแ, แแแกแแ แแแแฅแแแแแแก แแแแแฃแแแก แแแแแงแแคแแก แแแ แแจแ. แแ แแก Minikube, แแ แ?
แแก: แแแฉแแแแแแ, แ แแ แแก แกแแฅแแ - แแ แ แแแแแซแแแ แแแแแแแแแฃแแ - แแฅแกแแแฃแแแฃแ แแ แแแแแแแแ แแ แแแแแแแแ แแแแก แแฎแแแ. แแ แแกแแแ แแแแฃแจแแก แแแแแแ แแ แแแแแแแแแแแ. แญแแแ , แแ แแก , . แฉแแแ แแแแแแแแ แ Kubernetes IN Docker-แแก แแแแแงแแแแแแกแแแ. แแฎแแ แแแแแฌแงแแ แแแกแแแ แแฃแจแแแแ แขแแกแขแแแแกแแแแก.
NS: แแแ แ แแแแแแ, แ แแ แแก แแงแ แแชแแแแแแ, แแแแแแแ แแ แงแแแแ แแแแ แแ แ แแแแแ แแก แกแฃแ แแแจแ. แแแแ แแ แแฆแแแฉแแแ, แ แแ แกแแฅแแ แกแฃแ แกแฎแแ แ แแแแแแ. แงแแแแ แจแแแแฎแแแแแจแ, แแ แแก แชแแแแ แแแแขแแแแแ แแแ, แชแแแแแฃแแ แแฃแแแแแ - แแฎแแแแ แแแแแ แจแ.
แแก: แแแแฎ. แแแแแแแ แกแแแแแแ แกแแฎแแแแกแ แแแแขแแชแแ, แแแแ แแ แแแ แ แแกแแแแ... แฉแแแ แแแแฅแแก แฃแขแแแแขแ แแแแแแแแแแกแแแแก - . แฉแแแ แแแแแแ แแแแฎแแแแ แแแ แแแแแ แ แแแแแ werf up: "แแแแแฆแแ แแแแแแแแ แแแ แแฃแแแ แแแขแแแ." แแ แจแแแแแ แแแฃแจแแแ แแแ แแแแแ แแฅ werf follow. แจแแแแแ แแแแแแแแแ แก แจแแแซแแแแ IDE-แแก แ แแแแฅแขแแ แแแ แแ แกแแกแขแแแแจแ แแแแฌแงแแแ แแ แแชแแกแ, แ แแแแแแช แฎแแแแแก แชแแแแแแแแแก แแ แแฆแแแแแแก แกแฃแ แแแแแก, แแแแแแแแฌแแแแแก แแแ แแแแแแแแ แแ K8-แแแแ. แแกแ แแแแแแ แแชแแแแ แแแแแแแแ แแแ แแแแแแแแ แแแแก แแ แแแแแแแก แแแแแแ แแแ.
Snapshots แแ แแแแแชแแแแ แแแแแก แแแแแแ แแแ K8s แ แแแแแแแจแ
NS: แแฃ แแแแฃแแ แฃแแแแแแ แแแแแ แแแ-แฉแแฌแแ แแก. แจแแแแแฉแแแ, แ แแ แฆแ แฃแแแแแก แแกแแแ แแฅแแ แแแแ แแแ. แแกแแแ แกแฎแแแแแแ แแ แแฃแจแแแแแ. แแแแแแแแแ, GCP-แจแ: แแฅแแแ แแแฅแแ แแ แแแแ แขแแ แแแแแขแแแแ แแแแแแแแ แจแแแ แแแแฃแแ แจแขแแขแแแแก แแฆแแแกแแแแแ แกแแแแแแ แแแ. แแแ แแแแฃแแแ แแฆแแ แแแแ แแแก. แแฅแแแ แแฆแแแ แแแกแแแก แแกแแก แแแกแแแแแ แกแแแแแแ แแแ แกแแแแจแแขแแแแ - แ แแแแแแแแ แฌแฃแแจแ แงแแแแแคแแ แ แแแแ แแ แแก, แแก แซแแแแแ แกแฌแ แแคแแ แแฃแจแแแแก, แแฎแแแแ แฅแแจแ แฃแแแ แจแแแแกแแก แแแฎแกแแแ แแแแจแ. แแแแ แแ แแก แแแแแแแ (แกแแแแจแแขแแแ) แแ แแก แแฎแแแ แขแแแแก แฃแแ แฃแแแแแงแแคแแก แแแแแแ. แแก แแแแแ แแ, แ แแชแ แแแแ แ แแแกแขแแแชแแแก แจแแฅแแแ แแญแแ แแแแแ.
แแแแ แแ แขแแกแขแแแแกแแแแก แแแฉแแแแแแ, แ แแ แกแแแแจแแขแแแ, แ แแแแแแแแช แแฅแแแ แกแแฃแแ แแแ Docker-แจแ แแ แแ แแกแแฃแแ แแ ZFS-แจแ, btrfs แแ LVM-แจแแช แแ... - แแกแแแ แกแแจแฃแแแแแแก แแแซแแแแ แแ แจแแฅแแแแ แแแแแแแแแ แแฎแแแ แแแแแชแแแแแ แแ แ แแแแฅแแแแแ. แฆแ แฃแแแแจแ, แแฅแแแ แแแแแช แแแแแแฎแแแ แแแ แงแแแแ แฏแแ แแ แแ แแแแแแแแแแ แแ แ แฌแแแแแก, แแ แแแแ แฌแฃแแแแก (แแ แจแแแแฎแแแแแจแ , แจแแกแแซแแแ แกแแแแ).
แแแแก แแแชแแแแ, แจแแแแซแแแแ แแแแฆแแ แแก แแแแแชแแแแแ แแ แ-แแ แฌแแแจแ, แฉแแแขแแ แแ แขแแกแขแ แแ แแแแแแแแแ แแแ. แแก แแแแ แแแ แฌแงแแแขแก แกแฎแแแแแกแฎแแ แแ แแแแแแแก. แแแ แแแ แจแแแแฎแแแแแจแ - แแแกแจแขแแแแ แแแ แแ แแฎแแแ แแกแแแแแก แแแฆแแแ, แฎแแแ แแแแ แแจแ - แขแแกแขแแแแกแแแแก.
แแก: แแ แแแแแแฎแแแแ. แแแชแฃแแแแแก แแแแแแ แแแแก แกแฌแแ แแ แแฃแจแแแแ แฆแ แฃแแแแก แแแแชแแแแ. แแ แแ แแฃแงแฃแ แแ แแแ แแแแฎแแ แชแแแแแแแก, แแแแ แแ แแแชแ, แ แแแแ แแแแแแแแ แแแแก แแแแ แแขแฃแ แแแ. แฉแแแ แแแแฅแแก Ceph, แแก แแซแแแแ แแแแแกแแแแ แคแแแแแฃแ แแแชแฃแแแแแก () แแแแแแแ แแแแแ แแ แแแแฆแแ แแแแ แ แขแแแ แแแแแ แแแฎแแกแแแแแแแแแแ แแแแฃแ แแแแแฌแแแจแ, "แแแ แแ แ.แจ. แแฅแแแ แฃแแแ แแแกแแแแแ, แ แแ แจแแแแแ แแ แแก แ แแฃแแ แแกแแ-แฉแแฌแแ แ. แ แแขแแ แแ แฃแแแ แแแแแแแแก แฆแ แฃแแแแแ แแแแแ? แแแ แฌแแฃแแแแฃแแ แแแ , แแกแแแ แแแ แแฃ แแ แแแแ แชแแแแแแแ แแแแก แแแแแแแแแก.
NS: แแแแ แแ แแแ แแแแแช แแแกแญแแ แแแแแ แฌแแแแแ, แแแแแแ แฌแแแ แแแกแขแแแชแแแก แแกแแแแฆแแแแแแ, แแฅ แแแแแ แแก แแแงแแแแแแ แแ แ.แจ.
แแก: แ แแขแแ แแ แแก แกแแญแแ แ แแแแแ แแแกแขแแแชแแแก แฌแแแแฌแแแ? แฉแแแ แแแแฅแแก แแแกแขแแแชแแ 32 แแแ แแแแ, 16... แแ แแแกแจแ แฏแแแแ - แแแแแแแแแ, แแแฎแ. แ แแชแ แแแฎแฃแแแก แจแแแฃแแแแแแแ, แแแกแขแแแชแแ แฃแแแ แแฌแแฃแแ แแฅแแแแ, แจแแแแแ แแ แฌแแแจแแแแ.
NS: แแแแฎ, แกแแแแขแแ แแกแแ, แแฃแแแ แแแขแแกแ แกแฃแ แกแฎแแ แแแแแแ แแแแแแแก. แฉแแแแ แแแแแชแแแแ แแแแ แแ แแ แแก K8-แจแ แแ แแแแฅแแก แแ แแ แแแแแแแแ. แแแแ แแ แแ แแแแ แขแแ แแแแแขแแแแ แแแแแชแแแแ แแแแแก แแแแแแ แแแแก แกแญแแ แแแแ แแ แแฃแแแขแแก แแ แ แฌแแแ.
แแก: แฒแแแแ แแ. แแแแ แแ แฉแแแ แกแแฌแงแแกแ แแแ แ แแก แแ แแก, แ แแ แแก แแ แแ แแก แแแแแแ แแแแแกแแแแแ. แแแแฎ, แแแแแ แแ, แแแแ แแ แแก แแฎแแแแ Postgres-แแกแแแแกแแ แจแแกแแคแแ แแกแ แแ แแฎแแแแ แแ แ แแแแแซแแ.
NS: แแก แจแแกแแคแแ แแกแแ แแ แ แแฎแแแแ Postgres-แแกแแแแก: แแก แแแแแแแ, แ แแแแ แช แแฆแแฌแแ แ, แแฎแแแแ แแแกแจแ แแแฃแจแแแแแก. แแแแ แแ แแฃ แฉแแแ แแ แแแฌแฃแฎแแแ แแแแแแแก แแ แฉแแแ แฃแแ แแแแ แแแญแแ แแแแ แงแแแแ แแแแแชแแแ แคแฃแแฅแชแแฃแ แ แขแแกแขแแ แแแแกแแแแก, แแแจแแ แแก แจแแกแแคแแ แแกแแ แแแแแกแแแแ แ DBMS-แแกแแแแก.
แแก: แแ แแแแแ แฌแแแก แฌแแ แฉแแแ แแแแแแแแแ แแกแแแแกแ แ แแ LVM แกแแแแจแแขแแแแ. แแก แแ แแก แแแแกแแแ. แแก แแแแแแแ แซแแแแแ แแฅแขแแฃแ แแ แแแแแแงแแแแแแแ. แกแแฎแแแแฌแแคแแแแ แแแ แแแแแซแแแ แแฎแแแแ แขแแแแแแแ. แ แแแแแ แแ แฃแแแ แฉแแแแแแแแ แแกแแแ, แงแแแแแแแแก แฃแแแ แแแฎแกแแแแแ แแกแแแ...
NS: แฎแแแแแ แแฅ แ แแแแ แฐแแแ แแแแก แจแแกแแซแแแแแแแแก? แแแฅแแแ, stateful แแ แแก แแ แแแแแ แ pod, แแก แแฃแจแแแแก แ แแแแแแแแ แแแแแแแแแ (แแแแ แ แขแแกแขแแ แ). แฉแแแ แแแแฅแแก แแ แแ แขแแแ, แแแแ แแ แคแแแแฃแ แ แกแแกแขแแแแก แฌแงแแแแแแ, แแแแแแแ แแแแแแฃแ แแ. แแฃ แแแแ แแแแชแแแ, แแแแ แแ แแแกแแ แแแ แฉแแแ, แแแแ แแแแแแก, แแแแแแแก แแแคแแ แแแชแแแก แงแแแแ แแแแแแก แจแแกแแฎแแ, แฎแแแแฎแแ แแแฆแแแก แงแแแแแคแแ แก แแ แแขแงแแแก: โแแ แแฅแแแแ แแแแแแแ แแแจแแแแฃแแ แแ แแแ แขแแแแ, แแแแแ แซแแแแ แแแแแแ แแฃแจแแแแโ.
แแก: แขแแฅแแแแฃแ แแ แแก แแแจแแแแก, แ แแ Kubernetes-แจแ แแก แแ แแก แแ แแ แแแแ, แ แแแแแก แคแแ แแแแแจแแช แฉแแแ แแแขแแ แแแ แแแแ Postgres-แก.
NS: แแแแฎ. แแแก แแฅแแก แแแแแขแ: แแแแฃแจแแแ, แ แแ แแแกแแแ แแ แแแ แแฃแแแ แแฃแจแแแแก แแ แแฃแแแขแแก 10 แแแแแแแแ. แแฃ แแแแญแแ แแแแแ 20, แฉแแแ แแแแแแแแฃแจแแแแแ แแแแ แ แแกแแ แแแแก. แฉแแแ แกแ แฃแแแ แแแแแฎแแแแ แแแก แแแแแแ แแแแก, แแแแ แ แกแ แฃแแ แขแแแแก แแแฆแแแแก แจแแแแแ, แแแก แแฅแแแแ แแแแแ 10 "แแฎแแแ" แแแแแ. แแแ แฎแแแแแ แแ แจแแกแแซแแแแแแแแก?
แแก: แแฅ แฃแกแแคแ แแฎแแแแแก แกแแแแแฎแแแ แฃแแแ แแแแแแแขแแ. แแ แขแแแแก แแ แแแแแแแชแแ แแฃแแแกแฎแแแแก, แ แแ แแ แแแแก แแฅแแก แแแฆแแแ แแ แแแแแแแแแแ (แจแแกแแซแแแแแแแแแ), แ แแแแแ แแแก แจแแฃแซแแแ แจแแแกแ แฃแแแก แแ แแกแขแแแแแ แขแฃแแ แแแแ แแชแแแแ แคแแแแฃแ แกแแกแขแแแแแ... แแแแ แแ แแแแแแ แแ: แแฏแแ แ, แ แแ แกแแจแฃแแแแแแแแแ แแแ แกแแแฅแขแแแแจแ แแกแแแ แแแแคแแฅแกแแ แแแแ แจแแแแฎแแแก Kubernetes-แจแ แแ แฆแ แฃแแแแแ แแกแแแ แแแแ แแแแแแก แขแแแแแแ แแแแคแแฅแกแแ แแแแ - แงแแแแแคแแ แ "แฃแแ แแแแ แแแฃแจแแแแแก". แแฅแแแแ แแแแแก แจแแชแแแ, แแแแแแ แแแ... แแ แแก แขแแแ - แแแแแแแ: โแแแแก แกแแคแฃแซแแแแแ แจแแฅแแแแ แแฎแแแโ แแ แฌแแ-แแแฎแแแ แแก แจแแแแแ แแแฆแแแ แแแแก, แ แแช แแแญแแ แแแแ.
NS: แแ แแ แแฏแแ แ แแ แแ แแ แแแฎแแแแ แ แฌแแแแก แแ แแแแแ แขแแ แแแแแขแ. Ceph-แแ แจแแ แแแแแแ แแแแแแ แแแแก, แแแแ แแ แฆแ แฃแแแแแแ แกแแฃแแ แแ. แแแแแแแ แฆแ แฃแแแแจแ, แจแแฅแแแแแ แแ แแแแแขแแ แแแแแขแ EBS แขแแแแก แแแแแ EC2-แแ แแ แแแฎแแ, แ แแแแ แ แแฅแแแแ แจแแกแ แฃแแแแ. แแแแก แ แแแแแแแแ แฌแแแ แแ แแแกแญแแ แแแแ. แซแแแแแ แแแแแขแแ แแกแแแก แ แแแแก แแแแฆแฌแแแแ แแ แแแแแก. แแแกแแแก แ แแกแแช แแแแแ, แแแแ แแ แแแฎแแ แแแแกแฎแแแแแแฃแแแ แแแงแ.
แแก: แแแ แแ, แแแแ แแ แแ แแแฅแแ แกแแจแฃแแแแแแแแแ แแแ แกแแแฅแขแแแแจแ แแ แแ แ แแแแแแแแแแแ แแแ แกแแแฅแขแแแแจแ. แฒ แแแแแแแแ แฌแแแก แแแแแแแแแแแจแ.
แแแแ แแขแแ แแก แจแแกแแฎแแ PostgreSQL Zalando-แแแ
แแ แจแแฎแแแแ แแก แจแฃแแจแ, แแแแฅแกแแ แแแแฃแแแแ, แงแแคแแแ แแแแแแแแแ แ Zalando-แแแ, แแกแแแ แจแแฃแแ แแแ แแ แแกแแฃแแ แ PostgreSQL แแแแ แแขแแ แแก แแกแขแแ แแแแ:
แแจแแแแแแ แแ, แ แแ แแ แแแแแก แแแแแแแ แแฎแแแ: แ แแแแ แช Postgres, แแกแแแ Kubernetes. แ แแแแกแแช 2017 แฌแแแก แแแแแฌแงแแ แแแแก แแแแแแแแ Zalando-แจแ, แแก แแงแ แแแแ, แ แแแแแก แแแแแแแแแช แงแแแแแก แกแฃแ แแ, แแแแ แแ แแ แแแแก. แงแแแแแก แฃแแแ แฐแฅแแแแ Kubernetes, แแแแ แแ แ แแแแกแแช แแแ แฐแแแแฎแแก, แ แ แฃแแแ แแแแแแแแแแแแ แแแแแชแแแแ แแแแแแแแ, แแแแแแแแแแกแแช แแ แแแกแฌแแแ , แ แแแแแแช แฅแแแแแแแแ K8-แแแก, แแกแ แแฅแแ:
โแแแแแแแ แแแ แแฃแ แกแแ แแแกแแแแ แแ แแแแแแงแแแแ แแกแแแ, แแฃ แแแฃแจแแแ แแแแแชแแแแ แแแแ Kubernetes-แจแ. แฌแแแแแฆแแแแ แจแแแแฎแแแแแจแ, แแฅแแแแ K8-แแแ แแแแแฌแงแแแขแแ, แแแแแแแแแ, แแแแแแฎแแแ แแแแแฎแแแแ, แแแแแ แแแ แงแแแแ แแแแแซแ แแ แแฅแแแแ แแแแแชแแแแแ แแแคแ แแแแแแ แจแแ แก, แจแแ แก.
แฉแแแ แแแแแแฌแงแแแขแแ แจแแแแแฅแแแ แแแแ แแขแแ แ, แ แแแแแแช, แแ แ แฉแแแแก แกแแฌแแแแแฆแแแแแแ, แแแแแฃแจแแแแก Postgres แแแแแชแแแแ แแแแแก Kubernetes-แจแ. แแ แฉแแแ แแแฅแแแแ แแแ แแ แแแแแแ - . แแก แแ แแก PostgreSQL-แแก แแแขแแแแขแฃแ แ แฉแแแแ แแแ, แ แแแแแแช แจแแกแ แฃแแแแฃแแแ แกแฌแแ แแ, แ.แ. etcd-แแก, แแแแกแฃแแแก แแ ZooKeeper-แแก แแแแแงแแแแแแ แแแแกแขแแ แแก แจแแกแแฎแแ แแแคแแ แแแชแแแก แจแแกแแแแฎแแ. แแกแแแ แกแแชแแแ, แ แแแแแแช แงแแแแแก, แแแแช แแแแแฎแแแก, โโแแแแแแแแแ, แ แ แแ แแก แแแแแแแแแแแ แแแแแ แ, แแแแแ แแแคแแ แแแชแแแก แแแกแชแแแก - แแแฃแฎแแแแแแ แแแแกแ, แ แแ แฉแแแ แแแแฅแแก แงแแแแแคแแ แ แแแแแฌแแแแแฃแแ - แแกแ, แ แแ แขแแแแ แแ แแงแแก แแแงแแคแแแ. แแแฃแก แแแฅแแแแ แแแกแแแแก.
แแแแแแแ, แแแแแแแแแก แแฃแชแแแแแแแแ แแแขแแแแขแฃแ แ แฃแแแแ แแกแแแแก แจแแกแแฎแแ แแแฉแแแ แจแแแ แแแแ แแขแฃแ แแก แแแแแชแแแแ แชแแแขแ แแแแ แฆแ แฃแแแแจแ แแแแ แแชแแแก แจแแแแแ. แฆแ แฃแแแแ แแแคแฃแซแแแแฃแแ แแงแ แกแแแฃแแ แแแแก PaaS (แแแแขแคแแ แแ-แ แแแแ แช แกแแ แแแกแ) แแแแแฌแงแแแขแแแ. แแก แแ แแก แฆแแ แฌแงแแ แ, แแแแ แแ แแแก แแแแฅแแแแแแแก แแแแ แจแ แแแ แแแกแญแแ แแ. แฒแ แฅแแ .
แแแแแแแแ แแแแแ, แแฃแแแ แแแขแแแ แแ แแ แกแแแแแแ. แฃแคแ แ แแฃแกแขแแ, แ แแแแกแแช แฉแแแแ แกแแแฃแแแ แ แแแแแฌแงแแแขแ แแแแแแแแ, K8 แฃแแแ แแ แกแแแแแแ, แแแแ แแ แแก แแแแแแแ แแแแแ แแงแ, แ แแ แแ แแงแ แจแแกแแคแแ แแกแ แฌแแ แแแแแแกแแแแก. แแก แแงแ, แฉแแแ แแแ แแ, 2015 แแ 2016 แฌแแแ. 2017 แฌแแแกแแแแก แแฃแแแ แแแขแแแ แแแข-แแแแแแแแ แแแแฌแแคแแแฃแแ แแแฎแแ - แแฅ แแแแ แแชแแแก แกแแญแแ แแแแ แแแฉแแแ.
แฉแแแ แฃแแแ แแแฅแแแแ แแแแแ แแก แแแแขแแแแแ แ. แแงแ PaaS, แ แแแแแแช แแงแแแแแแ Docker-แก. แ แแขแแ แแ แกแชแแแแ K8? แ แแขแแ แแ แแแฌแแ แ แกแแแฃแแแ แแแแ แแขแแ แก? แฉแแแแแแ แแแแขแแแแ แฉแแแแกแฃแแแ แแฃแ แแข แแแแแแแแแ แแก แแแแฌแงแ แ แแแแ แช แแ แแแฅแขแ แกแแแฃแแแ แ แแแแชแแแขแแแแ - "แแแแแจแ" - แแ แแ แแแฅแขแ "แแคแ แแแแ".
แแแแ แแ แแแแแแแ, แแแแแแแ แแแกแแฃแแ แ AWS-แแ. แ แแขแแ แแงแ แแกแขแแ แแฃแแ AWS แแแแแแจแแ แแแฃแแ แแแแ...
แ แแแแกแแช แ แแแแแก แแฌแแ แแแแแ Kubernetes-แจแ, แฃแแแ แแแกแแแแแ, แ แแ K8 แแ แแก แแกแแแ แกแแแฃแจแแ. แแก แแฃแแแแแแ แแแแแ แแแแ, แแฎแแแฌแแแ แแ แแ แแแแแ แ แแจแแแแ แแแแแช. แแฅแแแ แงแฃแ แแแฆแแแแ แฃแแแ แแแแแแแ แแแแแ แแฃแแแ แแแขแแก แงแแแแ แชแแแแแแแแก, แแแแ แฃแแแ แแงแแ แฉแแงแแแแแแ แแแกแจแ, แแฃ แ แแแ แแแฎแแแแ แแ แแแแแแ แ แแแแ แแฃแจแแแแก แแก แแแขแแแฃแ แแ - แจแแกแแซแแแ แแแแแ แแแขแ, แแแแ แ แแฅแแแ แแกแฃแ แ. แแก, แแ แแแชแแแจแ, แแฎแแแ แแแแแกแแแแ แแแแขแคแแ แแแก, แ แแแแแแแช แแฅแแแ แแฌแแ แแแแแ แแฅแแแแก แแแแแชแแแแ แแแแแแก...
แแกแ แ แแ, แ แแแแกแแช แฉแแแ แแแแแแแแแ แแแแชแฎแแแแแ, แฉแแแ แแแฅแแแแ Postgres แแแจแแแแฃแแ แแแ แ แขแแแแ (EBS แแ แจแแแแฎแแแแแจแ, แ แแแแแ แฉแแแ แแแฃแจแแแแแแ AWS-แแ). แแแแแชแแแแ แแแแ แแแแแแ แแ, แ แแฆแแช แแแแแแขแจแ แกแแญแแ แ แแแฎแแ แแแกแ แแแแแก แจแแชแแแ: แแแแแแแแแ, EBS-แแก แกแแฌแงแแกแ แแแแ แแงแ 100 TB, แแแแแชแแแแ แแแแ แแแแแแ แแ แแแกแแ, แแฎแแ แฉแแแ แแแแแแ แแแแแแแแแ EBS 200 TB. แฒ แแแแ ? แแแฅแแแ, แจแแแแซแแแแ แแแแแแแแ แแแแแงแ แ/แแฆแแแแแ แแฎแแ แแแกแขแแแชแแแแ, แแแแ แแ แแแแก แแแแ แแ แ แแแกแญแแ แแแแ แแ แจแแคแแ แฎแแแแก แแแ แแแแก แแแแชแแแก.
แแแแขแแ, แแ แแแแแแแ แแแแแก แจแแชแแแ, แ แแแแแแช แแแแ แแแแ EBS แแแแแงแแคแแก แแ แจแแแแแ แแฃแแแแแแแ แคแแแแฃแ แกแแกแขแแแแก แแแแแแงแแแแก แแฎแแแ แกแแแ แชแ. แฉแแแ แแก แแแแแแแแแ, แแแแ แแ แแ แแ แแก Kubernetes-แก แแ แฐแฅแแแแ API แแแแแก แจแแชแแแแก แแแแ แแชแแแกแแแแก. แแแก แจแแแแแ, แ แแช แฉแแแ แแแฃแจแแแแแแ AWS-แแ, แฉแแแ แแแแฌแแ แแ แแแแ แแแกแ API-แกแแแแก.
แแ แแแแ แแแจแแแ แฎแแแก, แ แแ แแแแแ แแแแแแแแ แกแฎแแ แแแแขแคแแ แแแแแกแแแแก. แแแแชแฎแแแแแแจแ แแ แแ แแก แแแแแจแแแแ, แ แแ แแแกแ แแแจแแแแ แแฎแแแแ AWS-แแแ แจแแกแแซแแแแแแ แแ แกแฎแแ แงแแแแแคแแ แแ แแก แแ แแแฃแจแแแแแก. แแแแแแแ, แแก แแ แแก แฆแแ แแแแแก แแ แแแฅแขแ: แแฃ แแแแแแก แกแฃแ แก แแแแฉแฅแแ แแก แแฎแแแ API-แก แแแแแงแแแแแแก แแแฉแแแ, แแแแแกแแแแแแแ. แญแแแ , แแแแงแแแแแ แแแแฎแแแแแแ - Zalando-แก แแฃแแแ แชแแแแแแก แแแ แกแแแแแแ แกแฌแ แแคแแ แฃแแแกแฃแฎแแก แแ แฎแแแ แจแแฃแฌแงแแก แแแแ แแขแแ แก. แ แแแแ แช แแแชแ, แแ แแแฅแขแ Google Summer of Code-แแ แแ แกแฎแแ แแกแแแแก แแแแชแแแขแแแแแแ. แแแแแแแ แซแแแแแ แแฅแขแแฃแ แแ แแฃแจแแแแก แแแแแ.
P.S. แแแแฃแกแ!
แแฃ แแแแแขแแ แแกแแแ PostgreSQL-แแกแ แแ Kubernetes-แแก แแแแ, แแแฎแแแ แแกแแแ แแแแแแแแแกแฌแแแแ, แ แแ แจแแแแแแ Postgres แกแแแจแแแแแ แจแแแแ แแแกแฃแ แแแแ แแก, แกแแแแช แแ แแแกแแฃแแ แ แแแแแแแแก แแแแฅแกแแแแ แ แแฃแแฃแจแแแแ แแแแแแแแแแ. แแแกแแแ แแแแแ แฎแแแแแกแแฌแแแแแแ .
PPS
แแกแแแ แฌแแแแแแฎแแ แฉแแแแก แแแแแแ:
- ยซ";
- ยซ";
- ยซ";
- ยซ".
แฌแงแแ แ: www.habr.com