แแแแแ แฏแแแ, แฐแแแ !
แแ แ แแ แแก แฉแแแ แแแ แแแแแแแ แจแแแแแแขแแแแ แแแแ แ แฃแกแฃแ แแแแแ แแ แแ แแแแแ แซแแแ แแแกแ แแแแแแแแ แแแแกแแแแก. แแแ แซแแ, แแแแแแแ แแแคแแแกแ แแ . แจแแกแแแฉแแแแ (แแ แกแแแแแแ แคแ แแฎแแแแ) แแก แแแแ Confluent แแแแแแ แฏแแ แแแแแ แแแกแฃแแ แฌแแแก แแฅแขแแแแแ แจแ แแแแแฅแแแงแแแ แแแแ แจแแแแ แแก แแแขแแ แแแแ. แแฆแแก แแแกแฃแ แก แแฅแแแแ แงแฃแ แแแฆแแแ แแแแแฅแชแแแ แแแฐแแ แแแแแ แแก แแแ แแแแแแ แแแแแฅแแแงแแแแฃแ แฃแแฎแแแก แกแขแแขแแแก, แ แแแแแแช, แแแ แแแแแ, แกแแแแฃแ แจแ แแแแฎแแแก แแแจแแแก แแแ แแจแ แแ แแ แแก, แแแแ แแ แฃแคแ แ แจแแแแแ แกแแแ แแแแ แแแแแฎแแแแแก แแแแแก, แแแ แแฎแแแแก แขแแฅแกแขแก แกแแแแขแแ แแกแ แแแฃแแแแแ. แแแฎแแแ, แแแแแแขแแแ "แฅแแแก แแแแแฃแแแก" แฃแคแแกแ แแแ แแแแแ, แแฃ แจแแแแซแแแแ!
แจแแกแแแแแ
Kubernetes แจแแฅแแแแแแ แแแฅแแแแฅแแแแแก แแ แแฅแแแ แกแแแฃแจแแ แแแขแแแ แแแแกแแแแก. แ แแแแ แช แฌแแกแ, แแกแแแ แแแขแแแ แแแแแ แฌแแ แแแแแแแแแแ แแแแ แแกแแ แแแกแแก แแ แฅแแขแแฅแขแฃแ แแก แกแแฎแแ, แแกแแแ แแกแฃแแฃแฅแ แฌแแแแ, แแแ แแแ แแญแ แแแ แฐแแ แแแแแขแแแฃแ แแ, แแแฐแงแแแแ 12-แคแแฅแขแแ แแแแ แแแแแแแชแแแแแก แแ แแแชแแแแแก แแ แจแแฃแซแแแแ แแฃแจแแแแ แแแแแ แแแแแแแแแ แแ แฅแแแกแแก แแแแแฃแแแแแแ.
แแแคแแ, แแแแแก แแฎแ แแ, แแ แกแแแแแแ แแแฅแแแแแแก แ แแแแ แช แแแแแฌแแแแแฃแแ แแแแแชแแแแ แแแแ. แแแแแแ แแ, แแฃแจแแแแแกแแก, แกแแฅแแ แฃแแแ แแฅแแแแแก แกแแฎแแแแฌแแคแแกแแแ แแ แแก แแแแ แแ แฃแคแ แ แแซแแแแ, แแแแ แ แแแแ แแกแแ แแแกแ. Kubernetes แแฎแแ แก แฃแญแแ แก แกแแฎแแแแฌแแคแ แแแขแแแ แแแแก, แแแแ แแ แ แแแแ แช Kelsey Hightower แแฆแแแจแแแแก แแ แขแแแขแจแ, แแแ แกแแคแ แแฎแแแแ แฃแแแ แแแแแงแ แแ:
แแแแแแ แแ แแแแแแแแ แคแแฅแ แแแก, แ แแ แแฃ Kubernetes-แก แแแแแแฅแชแแแ แกแแฎแแแแฌแแคแ แแแขแแแ แแแแก, แแก แแแฎแแแแ แกแ แฃแแแ แแแ แแฃแแ แแแแแชแแแแ แแแแ, แ แแแแแแช แแแแแฃแ แแแชแแแก แฃแฌแแแก RDS-แก. แแก แแ แแกแฌแแ แแ. แจแแกแแซแแแ, แแฃ แกแแแแแ แแกแแ แแแแ แก แแแฃแจแแแแแ, แแแแแแขแแแ แแแแแขแแแแ แแแแแแแแแขแแแก แแ แแแแแแแแแ SRE แแแแแแ แแแแก แแฃแแแก, แจแแซแแแแ Kubernetes-แแก แแแแแ แแแจแแแแ RDS.
แแ แงแแแแแแแแก แแแ แฉแแแ, แ แแ แงแแแแแก แแแแแแฉแแแแก แแแแกแแแฃแแ แแแฃแแ แกแแคแ แแฎแแแ Kubernetes-แแ แกแแฎแแแแฌแแคแ แแแขแแแ แแแแแแก แแแจแแแแแกแแก. แแแแแแแแแแแก แฃแแแขแแกแแแแก, แแแแช แแแแฎแฃแแแแก โแจแแแแซแแแ แแฃแแแ แแแขแแกแแ แกแแฎแแแแฌแแคแ แแแขแแแ แแแแก แแแจแแแแโ แแ แแฅแแก แกแแแแแ แแกแ แแแแแชแแแแแแ Kubernetes-แแแ แแ แฎแจแแ แแ แแ แแแขแแแ แแแแกแแแ แแแแแแจแแ แแแแ, แ แแแแช แแแแฎแฃแแแแแ.
แแแจ, แฃแแแ แแแ แแแ แแแคแแ Kubernetes-แแ? แกแแแแ แแกแแแ แ แแแแฎแแ: แแแฃแจแแแแแก แแฃ แแ แ แแแคแแ แฃแแแแแกแแ Kubernetes-แแก แแแ แแจแ? แกแฌแแ แแ แแแแขแแ, แแ แกแขแแขแแแจแ แแแแแ แฎแแแ แแแแฃแกแแ, แแฃ แ แแแแ แแแกแแแแ แแ แแแแแแแก แแแคแแ แแ แแฃแแแ แแแขแแแ แแ แ แ แแ แแแแแแแแ แจแแแซแแแแ แแแฐแงแแแก แแแ แแแแ แแแแแแแแก.
แแแกแ แฃแแแแแก แแ แ
แแแแแ แแแกแแฃแแ แแ แซแแ แแแแแแ - แแแแแ แแแจแแแแแก แแแ แแแแแ
แแ แแชแแกแ
แแแคแแแก แแ แแแแ แแแ CPU แแแแแแ แฃแแแแ แแ แแแ. TLS-แแ แจแแกแแซแแแ แจแแแแแฆแแก แแแ แแแแฃแแ แแแแแแแแแ. แแฃแแชแ, แแแคแแแก แแแแแแขแแแ แจแแแซแแแแ แแงแแก แฃแคแ แ แแแขแแแกแแฃแ แ CPU, แแฃ แแกแแแ แแงแแแแแแ แแแจแแคแแ แแก, แแแแ แแ แแก แแแแแแแแก แแ แแฎแแแแก แแ แแแแ แแแแ.
แแแฎแกแแแ แแแ
แแแคแแแก แแ แแแแ แแแ แแแฎแกแแแ แแแแก แญแแแแ. JVM heap แแแแ แฉแแแฃแแแแ แแ แจแแแแแคแแ แแแแแ 4-5 แแ-แแ, แแแแ แแ แแกแแแ แแแแญแแ แแแแแ แแแแ แ แกแแกแขแแแแก แแแฎแกแแแ แแแ, แ แแแแแ แแแคแแ แซแแแแ แแ แแงแแแแแก แแแแ แแแก แฅแแจแก. Kubernetes-แจแ แแแแงแแแแ แแแแขแแแแแ แแก แ แแกแฃแ แกแ แแ แจแแกแแแแแแกแแ แแแแแฎแแแแ แแแแแขแแแ.
แแแแแชแแแแ แจแแแแฎแแ
แแแแขแแแแแ แแแจแ แแแแแชแแแแ แจแแแแฎแแ แแคแแแแ แฃแแแ - แแแแแชแแแแแ แแแแ แแแแ แแแแแขแแแ แแแแกแแก. แแแคแแแก แแแแแชแแแแแแกแแแแก แจแแแแซแแแแ แแแแแแงแแแแ แขแแแ emptyDirแแ แแคแแฅแขแ แแกแแแแกแ แแฅแแแแ: แแฅแแแแ แแ แแแแ แแก แแแแแชแแแแแ แแแแแแ แแแแ แแแกแ แฃแแแแแก แจแแแแแ. แแฅแแแแ แจแแขแงแแแแแแแแแ แแแแแ แจแแแซแแแแ แแแแฎแแแแแแก แกแฎแแ แแ แแแแ แแแแ, แ แแแแ แช แแกแแแแ. แแแแขแแ, แแแแแขแแแ แแแแก แจแแแแแ, แฌแแ แฃแแแขแแแแแแ แแ แแแแ แแ แฏแแ แฃแแแ แแแแแแแ แแก แงแแแแ แแแแแชแแแ แแ แแ แแ แแชแแกแก แจแแแซแแแแ แแแแ แแ แ แแแกแญแแ แแแก.
แกแฌแแ แแ แแแแขแแ แฃแแแ แแแแแแงแแแแ แแแแแชแแแแ แแ แซแแแแแแแแแ แจแแแแฎแแ. แแแแแ แแก แแงแแก แแ แแแแแแแฃแ แ แแ แซแแแแแแแแแ แจแแแแฎแแ XFS แคแแแแฃแ แ แกแแกแขแแแแ แแ, แฃแคแ แ แแฃแกแขแแ, ext4. แแ แแแแแแงแแแแ NFS. แฒแ แจแแ แแแแแคแ แแฎแแแ. NFS แแแ แกแแแแ v3 แแ v4 แแ แแแฃแจแแแแแก. แแแแแแ, แแแคแแแก แแ แแแแ แ แแแแจแแแแ, แแฃ แแก แแแ แฌแแจแแแก แแแแแชแแแแ แแแ แแฅแขแแ แแแก NFS-แจแ โแกแฃแแแแฃแ แ แกแแฎแแแแก แแแแแ แฅแแแแแกโ แแ แแแแแแแก แแแแ. แแฃ แฏแแ แแแ แแแแแ แฌแแฃแแ, แซแแแแแ แคแ แแฎแแแแ . แแแแแชแแแแ แกแแชแแแ แฃแแแ แแงแแก แแ แแแแแแแฃแ แ, แ แแแ Kubernetes-แแ แจแแซแแแก แฃแคแ แ แแแฅแแแแแ แแแ แฉแแแก แแฎแแแ แแแแแซแ แแแแแขแแแ แแแแก แแ แแแแแขแแแแก แจแแแแแ.
แฅแกแแแ
แ แแแแ แช แแแแแฌแแแแแฃแแ แกแแกแขแแแแแแก แฃแแแขแแกแแแแก แจแแแแฎแแแแแจแ, แแแคแแแก แจแแกแ แฃแแแแ แแแแแ แแ แแก แแแแแแแแแแฃแแ แฅแกแแแแก แจแแงแแแแแแแก แแแแแแแแฃแ แแแแแแ แแ แแแแขแแ แฃแแแ แแแแแแแก แแแฅแกแแแแแฃแ แจแแแแ แฉแฃแแแแแแ. แแฃ แแชแแแแแ แงแแแแ แแ แแแแ แแก แฐแแกแขแแแแ แแ แ แแแแแซแแ, แ แแแแแ แแก แจแแแแชแแ แแแก แฎแแแแแกแแฌแแแแแแแแก. แแฃ แแฃแแแ แแแขแแก แแแแแซแ แแแ แชแฎแแแแ, แแแแแ แแแคแแแก แแแแกแขแแ แ แฉแแแจแแแแ. แแกแแแ, แแฃ แแแคแแแขแแแ แแแคแแแก แแแแกแขแแ แก แแแแ แแแแแชแแแแ แชแแแขแ แแแจแ. แแแแแ แแฎแแแ แแฃแแแ แแแขแแก แแแแกแขแแ แก. แแแ แแ แแแแแ แแแแกแ แแ แจแแแแฎแแแแแจแ แแ แแก แกแฎแแแแแกแฎแแ แฎแแแแแกแแฌแแแแแแแแก แแแแแแแก แแ แฉแแแ.
แแแแคแแแฃแ แแชแแ
แ แแแฃแแแ แฃแแ แแแแแคแแกแขแแแ
Kubernetes แแแแกแแแขแก แแฅแแก แแแแก แจแแกแแฎแแ, แแฃ แ แแแแ แฃแแแ แแแแแแแคแแแฃแ แแ แแ ZooKeeper แแแแแคแแกแขแแแแก แแแแแงแแแแแแ. แแแแแแแแ ZooKeeper แแ แแก แแแคแแแก แแแฌแแแ, แแก แแแ แแ แแแแแแแ แแแแกแแแแแก, แ แแ แแแแชแแแ แแฃแแแ แแแขแแก แชแแแแแแก แแฅ. แ แแแแ แช แแ แแแแก แแแแแแแ, แจแแแแซแแแแ แแแแแแงแแแแ แแแแแ แชแแแแแแ แแแคแแแก แแแแกแขแแ แแแ แแ แแแ.
- แฅแแแจ: pod แแ แแก แงแแแแแแ แแแขแแ แ แแแแแแแแแฃแแ แแ แแแฃแแ Kubernetes-แจแ. แแแแ แจแแแชแแแก แแฅแแแแก แกแแแฃแจแแ แแแขแแแ แแแแก แแ แแแแแ pod แจแแแกแแแแแแแ แแฅแแแแก แแแแกแขแแ แจแ แแ แกแแแฃแ แแ แแชแแกแก. แแแแ แจแแแชแแแก แแ แ แแ แแแข แแแแขแแแแแ แก. แแแแแแฃแแ ZooKeeper แกแแ แแแ แ แแแกแแแแแจแ แแ แแแแแแฃแแ แแ แแแแ แ แแแคแแแก แแแแกแขแแ แจแ แแแฃแจแแแแแก แชแแแแ แแแแจแ.
- StatefulSet: StatefulSet แแ แแก Kubernetes แแแแแฅแขแ, แ แแแแแแช แแแฃแจแแแแแก แแ แแแแ แแแขแแแ แแแแก แแ แแกแแแ แแแขแแแ แแแแแ แกแแญแแ แแแแก แแแแ แแแแแชแแแก. StatefulSets แแซแแแแ แแแ แแแขแแแแก แแแแแแแก แจแแแแแแแกแแแ แแ แแแ แฃแแแแแแฃแ แแแแกแแแ แแแแแแจแแ แแแแ.
- แฃแแแแ แกแแ แแแกแแแ: แกแแ แแแกแแแ แกแแจแฃแแแแแแก แแแซแแแแ แแแแแ แแแ แแแแแแแ แแแแแแขแแแแกแแแ แแแแแแฃแ แ แกแแฎแแแแก แแแแแงแแแแแแ. Kubernetes แแ แจแแแแฎแแแแแจแ แแแกแฃแฎแแกแแแแแแแแ แแแขแแแ แแแแก แแแแแแแแกแแแแแ. แแฃแแชแ, แ แแแแกแแช แคแฃแแฅแชแแแแแ แแแก แกแแฎแแแแฌแแคแ แแแขแแแ แแแแ, แ แแแแ แแชแแ ZooKeeper แแ Kafka, แแแแแแขแแแก แกแญแแ แแแแแ แแแแฃแแแแแชแแ แแแแแ แแขแฃแ แจแแแแฎแแแแแกแแแ. แกแฌแแ แแ แแฅ แแแแแแแแแ แฃแแแแ แกแแ แแแกแแแ: แแ แจแแแแฎแแแแแจแ แแแแแแขแก แแแแแช แแฅแแแแ แแแแแแฃแ แ แกแแฎแแแ, แแแแ แแ แแฅแแแ แแ แแแแแฌแแแ แฃแจแฃแแแแ แแแแแแ แแแแแแจแแ แแแ.
- แแ แซแแแแแแแแแ แจแแแแฎแแแก แแแชแฃแแแแ: แแก แขแแแแแ แกแแญแแ แแ แแแแแ แแแฎแกแแแแแ แแ แแแแแแแฃแ แ แแแแแแก แแฃแแแแแ แแแฎแกแแแ แแแแก แแแแคแแแฃแ แแชแแแกแแแแก.
แฌแแแก แแแแแแแแแ แแแแแคแแกแขแแแแก แงแแแแแกแแแแชแแแ แแแแแแแฅแขแก, แ แแแแแแช แแแแแฎแแแ แแแแ แแแแฌแงแแ Kafka-แแ Kubernetes-แแ.
แฉแแคแฎแฃแขแแก แกแฅแแแแแ
Helm แแ แแก แแแแแขแแก แแแแแฏแแ แ Kubernetes-แแกแแแแก, แ แแแแแแช แจแแแซแแแแ แจแแแแแแ แแ OS แแแแแขแแก แแแแแฏแแ แแแก, แ แแแแ แแชแแ yum, apt, Homebrew แแ Chocolatey. แแก แแแแแแแแแก แฌแแแแกแฌแแ แแแแกแแแฆแแ แฃแแ แแ แแแ แแแฃแแ แแแแแขแแแแก แแแกแขแแแแชแแแก, แ แแแแแแแช แแฆแฌแแ แแแแ Helm แกแฅแแแแแจแ. แแแ แแแ แจแแ แฉแแฃแแ Helm แกแฅแแแ แแแแแแแแแก แ แแฃแ แแแแชแแแแก, แแฃ แ แแแแ แกแฌแแ แแ แแแแแแแคแแแฃแ แแ แแ แงแแแแ แแแ แแแแขแ แ แแแคแแแก Kubernetes-แแ แแแแแกแแงแแแแแแแ. แแ แกแแแแแก แ แแแแแแแแ แแแคแแแก แแแแแ แแแ: แแคแแชแแแแฃแ แ แแแแแแ แแแแก , แแ แแก แแ แแ , แแแแแ แแ แแ - แแแ .
แแแแ แแขแแ แแแ
แแแแก แแแแ, แ แแ Helmโแก แแฅแแก แแแ แแแแฃแแ แแแแแแแแแแแแแ, แแแแแ แแ แแ แแแกแขแ แฃแแแแขแ แแซแแแก แแแแจแแแแแแแแ แแแแฃแแแ แแแแก: Kubernetes แแแแ แแขแแ แแแ. แแแแ แแขแแ แ แแ แ แแฎแแแแ แแคแฃแญแแแก แแ แแแ แแแฃแ แฃแแ แฃแแแแแงแแคแแก Kubernetes-แแกแแแแก, แแ แแแแ แแแซแแแแ แกแแจแฃแแแแแแก แแแแแแแแกแแ แแกแแแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแ แแ แแแ แแแ แแแ.
แกแแ แแแคแแแก แแ แ แแแแ แแขแแ แแ แแแฎแกแแแแแ. แฒแ แ - แแ แแ แแแแแแแ - . Strimzi-แแ แแแแแแแ แแฅแแแแ แแแคแแแก แแแแกแขแแ แ แแแแฅแแแแแแก แฌแฃแแแแจแ. แแ แแฅแขแแแฃแแแ แแ แแ แแก แกแแญแแ แ แแแแคแแแฃแ แแชแแ, แแแ แแ แแแแกแ, แแแแ แแขแแ แ แแแแแ แฃแแ แฃแแแแแงแแคแก แ แแแแแแแแ แกแแกแแแแแแแ แคแฃแแฅแชแแแก, แแแแแแแแแ, แฌแแ แขแแแแแแ แฌแแ แขแแแแแแ TLS แแแจแแคแแ แแก แแแแกแขแแ แจแ. Confluent แแกแแแ แฃแแ แฃแแแแแงแแคแก .
แแแฅแแแแแแ
แแแแจแแแแแแแแแแ, แ แแ แจแแแแแฌแแแ แจแแกแ แฃแแแแ แแฅแแแแ แแแคแแแก แแแกแขแแแชแแแก แจแแคแแกแแแแ. แแกแแแ แขแแกแขแแแ แแแแแฎแแแ แแแแ แแแแแแ แแแขแแแชแแฃแ แ แจแแคแแ แฎแแแแแ แแ แแแแแแแแแก แฌแแ แแแจแแแแแแ. แกแแแแแแแแ แแ, แแแคแแ แฃแแแ แแแแแแแแแ แจแแกแ แฃแแแแแก แขแแกแขแแ แแแแก แแ แแแกแขแ แฃแแแแขแก: kafka-producer-perf-test.sh ะธ kafka-consumer-perf-test.sh. แแแแแแงแแแแ แแกแแแ แแฅแขแแฃแ แแ. แชแแแแแกแแแแก, แจแแแแซแแแแ แแฎแแแแ แจแแแแแแแ แแฆแฌแแ แแแ แฏแแ แแ แแแกแ, แแ แคแแแฃแกแแ แแแ แแแแฎแแแแ Amazon MSK แกแขแแคแแ แแแแ แแแแก แแแแ .
แแแแ แแชแแแแแก
แแแแแขแแ แแแแ
แกแแกแขแแแแจแ แแแแญแแแ แแแแแแ แซแแแแแ แแแแจแแแแแแแแแแ - แฌแแแแแฆแแแแ แจแแแแฎแแแแแจแ แแแ แแแแแแแ แ แ แฎแแแแ แแแกแจแ. แแฆแแก แแ แกแแแแแก แแงแแ แ แฎแแแกแแฌแงแแแแแก แแแแ แแแ, แ แแแแแแช แฃแแ แฃแแแแแงแแคแก แแแขแ แแแแแ แแแคแฃแซแแแแฃแ แแแแแขแแ แแแแก แฆแ แฃแแแแก แแจแแแแแฃแ แกแขแแแจแ. แแ แแแแแแ แแ แ แแแแฃแแแ แฃแแ แแแกแขแ แฃแแแแขแแ แแ แแแแแ แแ แแ แแคแแแ. แแ แแแแแแก แจแแฃแซแแแ แจแแแแ แแแแก แแแขแ แแแ แฏแแแแก แงแแแแ แแ แแชแแกแแแแ (Kafka, Zookeeper, Kafka Connect) JMX แแฅแกแแแ แขแแแ แแก แแแแแงแแแแแแ - แฃแแแ แขแแแแกแ แแแแ. แแฃ แแแแแแขแแแ cAdvisor แแแขแ แแแแก, แจแแแแซแแแแ แฃแคแ แ แกแ แฃแแแ แแแแแแ, แแฃ แ แแแแ แแแแแแงแแแแแ แ แแกแฃแ แกแแแ Kubernetes-แจแ.
Strimzi-แก แแฅแแก Grafana-แก แแแคแแก แซแแแแแ แแแกแแฎแแ แฎแแแแแ แแแแแแแแ แแแคแแแกแแแแก. แแก แแกแแฎแแแก แซแแ แแแแ แแแขแ แแแก, แแแแแแแแแ, แแ แแกแแแแแ แแกแแ แแแแ แแแแแแฃแแ แกแแฅแขแแ แแแแก แแ แฎแแแแแ แแจแ แกแแฅแขแแ แแแแก แจแแกแแฎแแ. แแฅ แงแแแแแคแแ แ แซแแแแแ แแแแแแแ. แแก แแแขแ แแแ แแแกแแแก แ แแกแฃแ แกแแแแก แแแแแงแแแแแแกแ แแ แจแแกแ แฃแแแแแก แจแแกแแฎแแ แแแคแแ แแแชแแแก, แแกแแแ แกแขแแแแแฃแ แแแแก แแแแแแแขแแ แแแก. แแกแ แ แแ, แแฅแแแ แแแแฆแแแ แแแคแแแก แแแแกแขแแ แแก แซแแ แแแแ แแแแแขแแ แแแแก แแ แแคแ แแกแแแแก!
แฌแงแแ แ:
แแแ แแ แแฅแแแแแแ แแ แงแแแแแคแ แแก แแแแแขแแแ แแแแแแขแแก แแแแแขแแ แแแแแ (แแแขแ แแแ แแแแฎแแแ แแแแแแแ แแ แแฌแแ แแแแแแแแแ), แแกแแแ แแแขแแแขแฃแ แ แแแแแขแแ แแแแแ (แแแแกแแแแก แแ แกแแแแแก ) แแ แแแแแแแ แแแแแแแ แแแแแขแแ แแแแ - แแ แแแแแงแแแแแแกแแแแก .
แฎแ-แขแงแ
แจแแกแแแ แแแแแ แแ แแ แแแแจแแแแแแแแแ แแแแชแแแแ. แแแ แฌแแฃแแแแ, แ แแ แแฅแแแแ แแแคแแแก แแแกแขแแแแชแแแก แงแแแแ แแแแขแแแแแ แ แจแแกแฃแแแ stdout ะธ stderr, แแ แแกแแแ แแแ แฌแแฃแแแแ, แ แแ แแฅแแแแ Kubernetes แแแแกแขแแ แ แแแ แแแแแแแก แงแแแแ แแฃแ แแแแก แชแแแขแ แแแฃแ แ แญแ แแก แแแคแ แแกแขแ แฃแฅแขแฃแ แแจแ, แแแ. .
แคแฃแแฅแชแแฃแ แ แขแแกแขแแ แแแ
Kubernetes แแงแแแแแก แกแแชแแชแฎแแแกแฃแแแ แแแแแแแกแ แแ แแแแแงแแคแแแก แแแแแแแก, แ แแแ แจแแแแแฌแแแก, แแฃแจแแแแก แแฃ แแ แ แแฅแแแแ แซแแคแแแ แแแ แแแแฃแ แแ. แแฃ แกแแชแแชแฎแแแกแฃแแแ แแแแแแแก แจแแแแฌแแแแ แแแ แแแฎแแ แฎแแ, Kubernetes แจแแแฉแแ แแแก แแ แแแแขแแแแแ แก แแ แจแแแแแ แแแขแแแแขแฃแ แแ แแแแแขแแแ แแแแก แแแก, แแฃ แแแแแขแแแ แแแแก แแแแแขแแแ แจแแกแแแแแแกแแ แแแงแแแแแฃแแแ. แแฃ แแแแแงแแคแแแก แจแแแแฌแแแแ แแแ แแแฎแแ แฎแแ, Kubernetes แแแแแแ แแแก แแแแก แกแแ แแแกแแก แแแแฎแแแแแแแกแแแ. แแแ แแแแ, แแกแแ แจแแแแฎแแแแแแจแ แฎแแแแ แฉแแ แแแ แกแแแ แแแ แแฆแแ แแ แแก แกแแญแแ แ, แ แแช แแแแ แแแฃแกแแ.
แแแแแฎแแแแแแแก แแแแ แชแแแแแ
StatefulSets แแฎแแ แก แฃแญแแ แก แแแขแแแแขแฃแ แแแแแฎแแแแแแก: แแฃ แแแ แฉแแแ RollingUpdate แกแขแ แแขแแแแแก, แแแแแแฃแแ แแแคแแแก แฅแแแจ แ แแแ แแแแแแ แแแแแฎแแแแแ. แแ แแแแ แจแแคแแ แฎแแแแก แแ แ แจแแแซแแแแ แแฃแแแแแ แจแแแชแแ แแแก.
แกแแแแแ แแแ
แแแคแแแก แแแแกแขแแ แแก แกแแแแแ แแแ แแแแแแ แกแแฅแแ แแ แแ แแก. แแฃแแชแ, Kubernetes แซแแแแแ แแแแแแแแแก แแแแแแแก แแแกแจแขแแแแ แแแแก แแแ แแแแฃแแ แ แแแแแแแแแก แ แแแแแแแแแ, แ แแช แแแจแแแแก, แ แแ แจแแแแซแแแแ แแแแแแ แแชแแฃแแแ แแแแกแแแฆแแ แแ แแแแแแ แแแคแแแก แแ แแแแ แ, แ แแแแแแแช แแกแฃแ แ. แงแแแแแแ แ แแฃแแ แแ แจแแแแฎแแแแแจแ แแ แแก แกแแฅแขแแ แแแแก แแแแแแแฌแแแแแ แแแกแจแขแแแแก แแแแ แแแก แจแแแแแ แแ แจแแแชแแ แแแแแแ. แแแแแ แแ แแฎแแ, Kubernetes แแแแแฎแแแ แแแแ แแ แแแแชแแแแก แจแแกแ แฃแแแแแจแ.
แแแแแแแกแขแ แแชแแ
แแฅแแแแ แแแคแแแก แแแแกแขแแ แแก แแแแแแแกแขแ แแ แแแแกแแแ แแแแแแจแแ แแแฃแแ แแแแชแแแแแ, แ แแแแ แแชแแ แแแแแแแก แจแแฅแแแ แแ แกแแฅแขแแ แแแแก แแแแแแแฌแแแแแ, แจแแแซแแแแ แจแแกแ แฃแแแแก แแ แกแแแฃแแ shell แกแแ แแแขแแแแก แแแแแงแแแแแแ, แแ แซแแแแแแก แฎแแแแก แแแขแแ แคแแแกแแก แแแฎแกแแแ แแฅแแแแก pods-แจแ. แแฃแแชแ, แแก แแแแแกแแแแแ แแ แแ แแก แซแแแแแ แแแแแแ. Strimzi แแฎแแ แก แฃแญแแ แก แแแแแแแก แแแ แแแแก แกแฎแแ แแแแ แแขแแ แแก แแแแแงแแแแแแ. แแฅ แแ แแก แแแ แแแแฃแแ แแแฃแแฏแแแแกแแแแก แแแแแแ.
แ แแแแ แแแแแแก แแแแแ แแแ แแ ะฒะพััะฐะฝะพะฒะปะตะฝะธะต
แแฎแแ แแแคแแแก แฎแแแแแกแแฌแแแแแแแ แแกแแแ แแแแแแแแแแฃแแ แแฅแแแแ Kubernetes-แแก แฎแแแแแกแแฌแแแแแแแแแ. แแฃ แแฅแแแแ Kubernetes แแแแกแขแแ แ แแแ แชแฎแแแแ, แแแจแแ แฃแแ แแก แจแแแแฎแแแแแจแ, แแฅแแแแ แแแคแแแก แแแแกแขแแ แแช แฉแแแแ แแแแ. แแแ แคแแก แแแแแแแก แแแแแฎแแแ, แแก แแฃแชแแแแแแแ แแแฎแแแแ แแ แแฅแแแ แแแแแ แแแแ แแแแแชแแแแแก. แแ แขแแแแก แ แแกแแแก แจแแกแแแชแแ แแแแแ, แแฅแแแแแ แแแ แแ แกแแ แแแแ แแ แแแแชแแคแชแแ. แจแแแแซแแแแ แแแแแแงแแแแ MirrorMaker, แแแแแ แแ แแ แแแ แแแแขแแ แแแแแแงแแแแ S3 แแแแกแแแแแก, แ แแแแ แช แแก แแฆแฌแแ แแแแ แแแแแแแแแแ.
แแแกแแแแ
แแชแแ แ แแ แกแแจแฃแแแ แแแแแก แแแคแแแก แแแแกแขแแ แแแแแ แแฃแจแแแแแกแแก, แแแแแแแแแ แฆแแ แก Kubernetes-แแก แแแแแงแแแแแ, แ แแแแแ แแก แฃแแ แฃแแแแแงแแคแก แแแแแขแแแแ แแแฅแแแแแแแก แแ แแแแ แขแแแแแก แแแแ แแขแแ แแก แแแแแชแแแแแแแก. แแฃ แแฅแแแ แแแฅแแ แซแแแแแ แแแแจแแแแแแแแแ แแ แแคแฃแแฅแชแแฃแ แ แจแแงแแแแแแแก แแ/แแ แแแแขแแ แฃแแแ แแแแแแแก แแแแฎแแแแแแ, แแแจแแ แจแแกแแซแแแ แฃแแแแแกแ แแงแแก แแแแแแแแแแก แกแฎแแ แแแ แแแแขแ.
แฌแงแแ แ: www.habr.com