แฒจแแแแจแแแ. แแแ แแแแ: แแกแแคแแแแจแ แชแแแแแแ Tinder แกแแ แแแกแแก แแแแแแจแ แแแแแแแ แชแแขแ แฎแแแก แฌแแ แแแแแแแ แแก แ แแแแแแแแ แขแแฅแแแแฃแ แ แแแขแแแ แแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแก Kubernetes-แจแ แแแแ แแชแแแก แจแแกแแฎแแ. แแ แแชแแกแก แแแแฅแแแก แแ แ แฌแแแ แแแกแญแแ แแ แแ แจแแแแแแ K8-แแ แซแแแแแ แคแแ แแแแแกแจแขแแแแแแ แแแแขแคแแ แแแก แแแจแแแแ แแแฐแงแแ, แ แแแแแแช 200 แแแแก แแแแขแแแแแ แแ แแแแแแแกแแแฃแแ 48 แกแแ แแแกแแกแแแ แจแแแแแแ. แ แ แกแแแแขแแ แแกแ แกแแ แแฃแแแแแ แฌแแแฌแงแแแแ Tinder-แแก แแแแแแ แแแก แแ แ แ แจแแแแแแแแแแ แแแแแแแแ? แฌแแแแแแฎแแ แแก แแแ แแแแแ.
แ แแขแแ?
แแแแฅแแแก แแ แ แฌแแแก แฌแแ Tinder-แแ แแแแแฌแงแแแขแ แแแแแกแ แแแแขแคแแ แแแก Kubernetes-แจแ แแแแแขแแแ. Kubernetes แกแแจแฃแแแแแแก แแแกแชแแแก Tinder-แแก แแฃแแแก แแแแขแแแแแ แแ แแแ แแ แฌแแ แแแแแแแ แแแแแกแแแ แแแแแแแแฃแ แ แซแแแแกแฎแแแแแ แฃแชแแแแแ แแแแแแแแแแก แแแแ. (แฃแชแแแแแ แแแแแแแแแ). แแ แจแแแแฎแแแแแจแ, แแแแแแแชแแแแแก แจแแแ แแแ, แแแแ แแแแแแแแแ แแ แแแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แ แชแแแกแแฎแแ แแฅแแแแ แแแแกแแแฆแแ แฃแแ แแแแแ.
แฉแแแ แแกแแแ แแแซแแแแแ แแแแแกแแแแแก แแแกแจแขแแแฃแ แแแแกแ แแ แกแขแแแแแฃแ แแแแก แแ แแแแแแแกแแแแก. แ แแแแกแแช แกแแแแแ แแแ แแ แแขแแแฃแแ แแแฎแแ, แฎแจแแ แแ แแแแฌแแแแ แ แแแแแแแแ แฌแฃแแแก แแแแแแ แแฎแแแ EC2 แแแกแขแแแชแแแแแก แแแกแแขแ แแแแแแแแ. แฉแแแแแแแก แซแแแแแ แแแแแแแแแแ แแแฎแแ แแแแขแแแแแ แแแแก แแแจแแแแแก แแแแ แแ แฌแฃแแแแแก แแแชแแแแ แขแ แแแกแแแ แขแแก แกแแ แแแกแแก แแแฌแงแแแ แฌแแแแแจแ.
แแ แแชแแกแ แ แแฃแแ แแฆแแแฉแแแ. 2019 แฌแแแก แแแกแแฌแงแแกแจแ แฉแแแแ แแแแ แแชแแแก แแ แแก Kubernetes แแแแกแขแแ แแ แแแแฆแฌแแ แแ แแขแแแฃแ แแแกแแก แแ แแแแแฌแงแแ แกแฎแแแแแกแฎแแ แแ แแแแแแแแแก แจแแฏแแฎแแแ แขแ แแคแแแแก แแแชแฃแแแแแก, แแแแกแขแแ แแก แแแแแกแ แแ DNS-แแก แแแแ. แแ แแแแแ, แฉแแแ แแแแแแฌแงแแแขแแ แแแแ แ แกแแแแขแแ แแกแ แแ แแแแแแ, แ แแแแแแช แแแแแแจแแ แแแฃแแแ 200 แกแแ แแแกแแก แแแแ แแชแแแกแแแ แแ Kubernetes แแแแกแขแแ แแก แจแแแแ แฉแฃแแแแแกแแแ, แ แแแแแแช แจแแแแแแ 1000 แแแแแซแแกแแแ, 15000 pods แแ 48000 แแแจแแแแฃแแ แแแแขแแแแแ แแกแแแ.
แ แแแแ ?
2018 แฌแแแก แแแแแ แแแแ แฉแแแ แแแแแแ แแ แแแแ แแชแแแก แกแฎแแแแแกแฎแแ แแขแแแ. แฉแแแ แแแแแฌแงแแ แงแแแแ แฉแแแแ แกแแ แแแกแแก แแแแขแแแแแ แแแแชแแ แแ แแแแ แแแแแแแกแแแ Kubernetes-แแก แกแแขแแกแขแ แฆแ แฃแแแแแแ แแแ แแแแจแ. แแฅแขแแแแ แแแแ แแแแแฌแงแแ แงแแแแ แแ แกแแแฃแแ แกแแ แแแกแแก แแแแแแฃแ แ แแแแ แแชแแ Kubernetes-แจแ. แแแแแแแแ แฌแแแก แแแ แขแแกแแแแก แฉแแแ แแแแแกแ แฃแแแ แแแแ แแชแแ แแ แแฎแแ Tinder แแแแขแคแแ แแ แแฃแจแแแแก แแฅแกแแแฃแแแฃแ แแ Kubernetes-แแ.
แกแฃแ แแแแแแก แแแแแ Kubernetes-แแกแแแแก
แฉแแแ แแแแฅแแก 30-แแ แแแขแ แฌแงแแ แ แแแแแก แกแแชแแแ แแแแ แแกแแ แแแกแแแแกแแแแก, แ แแแแแแแช แแฃแจแแแแแ Kubernetes แแแแกแขแแ แแ. แแ แกแแชแแแแแจแ แแแแ แแฌแแ แแแ แกแฎแแแแแกแฎแแ แแแแแ (แแแแแแแแแ, Node.js, Java, Scala, Go) แแ แแ แแ แแแแแ แแแแกแแแแก แแ แแแแแ แแแจแแแแแก แแแ แแแแจแ.
Build แกแแกแขแแแ แจแแฅแแแแแแ แแแแกแแแแแก, แ แแ แฃแแ แฃแแแแแงแแก แกแ แฃแแแ แแแแคแแแฃแ แแ แแแแแ โแแแแกแขแ แฃแฅแชแแแก แแแแขแแฅแกแขแโ แแแแแแฃแแ แแแแ แแกแแ แแแกแแกแแแแก. แแก แฉแแแฃแแแแ แแ แจแแแแแแ Dockerfile-แแกแ แแ แญแฃแ แแแก แแ แซแแแแแแแแก แกแแแกแแแ. แแแแ แจแแแแแ แกแ แกแ แฃแแแแ แแแแคแแแฃแ แแ แแแแแแ แแ แแแแแแ แแฃแแแ, แงแแแแ แแก แแแแกแขแ แฃแฅแชแแแก แแแแขแแฅแกแขแ แแฌแแ แแแ แกแขแแแแแ แขแแแแแฃแแ แคแแ แแแขแแก แแแฎแแแแแ. แแแแกแขแ แฃแฅแชแแแก แแแแขแแฅแกแขแแแแก แกแขแแแแแ แขแแแแชแแ แกแแจแฃแแแแแแก แแซแแแแก แแ แ แแแแกแขแ แฃแฅแชแแฃแ แกแแกแขแแแแก แแแฃแแแแแแแแก แงแแแแ แแแแ แแกแแ แแแกแก.
แกแฃแ แแแ 1-1. แกแขแแแแแ แขแแแแแฃแแ แแจแแแแแแแแแก แแ แแชแแกแ Builder แแแแขแแแแแ แแก แแแจแแแแแแ
แแแฅแกแแแแแฃแ แ แแแแแแแแแแ แฃแแแแแก แแแกแแฆแฌแแแแ แแแจแแแแแแก แจแแ แแก (แแแจแแแแแก แแแ แแแ) แแแแแ แแแแแแก แแ แแชแแกแ แแแแแแงแแแแแ แจแแแฃแจแแแแแแกแ แแ แขแแกแขแแ แแแแก แแ แแก. แฉแแแ แซแแแแแ แกแแแแขแแ แแกแ แแแแแฌแแแแแก แฌแแแแจแ แแฆแแแแฉแแแแ: แฉแแแ แฃแแแ แจแแแแแแฃแจแแแแแแแ แแแ, แ แแแ แฃแแ แฃแแแแแแงแแ แกแแแจแแแแแแ แแแ แแแแก แแแแแแแแแแ แฃแแแแ แแแแ แแแแขแคแแ แแแแ. แแแแก แแแกแแฆแฌแแแแ, แจแแแ แแแแก แงแแแแ แแ แแชแแกแ แฎแแ แชแแแแแแแ แกแแแชแแแแฃแ แแแแขแแแแแ แจแ. แแฆแแแจแแแแแแแก.
แแแกแ แแแแขแแแแแ แแก แแแแฎแแ แชแแแแแแ แแแแแฎแแแแ แแแแแ แแก แแแฌแแแแแ แขแแฅแแแแแก. Builder แแแแแแแแ แแแแแ แแฆแแแก แแแแแแแแ แแแ แแแแฎแแแ แแแแแก ID-แก แแ แกแแแแฃแแแแแแแแก (แ แแแแ แแชแแ SSH แแแกแแฆแแแ, AWS แกแแ แแแคแแแแขแแแ แแ แ.แจ.), แ แแแแแแแช แกแแญแแ แแ แแแ แแแ Tinder แกแแชแแแแแจแ แฌแแแแแแกแแแแก. แแก แแแแแขแแแแแก แแแแแแแแ แแ แแแขแแแแแแแก, แ แแแแแแแช แจแแแชแแแก แฌแงแแ แแแแก, แ แแแ แแฃแแแแ แแแแ แจแแแแแฎแแก แแแแกแขแ แฃแฅแชแแฃแแ แแ แขแแคแแฅแขแแแ. แแก แแแแแแแ แแฃแแฏแแแแกแแแก แจแแกแ แฃแแแแแก, แ แแแแแ แแก แแแแแ แแชแฎแแแก Builder-แแก แแแแขแแแแแ แกแ แแ แแแกแแแแซแแแก แจแแ แแก แแแแแฃแแ แแ แขแแคแแฅแขแแแแก แแแแแ แแแแก แแฃแชแแแแแแแแแก. แจแแแแฎแฃแแ แแแแกแขแ แฃแฅแชแแแก แแ แขแแคแแฅแขแแแแก แฎแแแแฎแแ แแแแแงแแแแแ แจแแกแแซแแแแแแแ แแแแแขแแแแแ แแแแคแแแฃแ แแชแแแก แแแ แแจแ.
แแแแแแ แแ แกแแ แแแกแแกแแแแก, แฉแแแ แฃแแแ แจแแแแแฅแแแ แกแฎแแ แแแแขแแแแแ แ, แ แแแ แจแแแแแฅแแแ แแแแแแแแชแแแก แแแ แแแ แแแจแแแแแก แแ แแก (แแแแแแแแแ, Node.js bcrypt แแแแแแแแแแ แแแแแแ แแ แแแก แแแแขแคแแ แแแก แกแแแชแแคแแแฃแ แแแแแ แฃแ แแ แขแแคแแฅแขแแแก แแแกแขแแแแชแแแก แแ แแก). แจแแแแแแแก แแ แแชแแกแจแ, แแแแฎแแแแแแ แจแแแซแแแแ แแแแกแฎแแแแแแแแแแก แกแแ แแแกแแแก แจแแ แแก แแ แกแแแแแแ Dockerfile แจแแแแแแแแแ แคแ แแแแก แแ แแก.
Kubernetes แแแกแแขแฃแ แ แแ แฅแแขแแฅแขแฃแ แ แแ แแแแ แแชแแ
แแแแกแขแแ แแก แแแแแก แแแ แแแ
แฉแแแ แแแแแแฌแงแแแขแแ แแแแแแแงแแแแ kube-aws แแแกแแขแฃแ แ แแแขแแแแขแฃแ แ แแแแแแแแแแกแแแแก Amazon EC2 แแแกแขแแแชแแแแแ. แแแแแแแแแ แงแแแแแคแแ แ แแฃแจแแแแแ แแแแแซแแแแก แแ แ แกแแแ แแ แแฃแแจแ. แฉแแแ แกแฌแ แแคแแ แแแแฎแแแแ, แ แแ แกแแญแแ แแ แกแแแฃแจแแ แแแขแแแ แแแแแแก แแแแแฏแแแ แแแแแกแ แแ แแแกแขแแแชแแแก แขแแแแก แแแฎแแแแแ, แ แแกแฃแ แกแแแแก แฃแคแ แ แแคแแฅแขแฃแ แแ แแแแแงแแแแแแก แแแแแแ. แแแแแแ แแแแจแ แแแแแแแ แแแแแ, แ แแ แ แแแแแแแแ แแแขแแแ แแฃแแ แแ แแแแแซแแคแแแแ แฏแแจแแก แแแจแแแแ แฃแคแ แ แแ แแแแแแแ แแแแแ แแฆแแแฉแแแ แจแแกแ แฃแแแแแก แแแแแกแแแ แแกแแ, แแแแ แ แแแแ แแแแแแ แกแแแแแ แแแแ แ แแแแแแแแแ แแ แแซแแคแแก แแแแแแแแ.
แกแแแแแแ แฏแแแจแ แฉแแแ แแแแแแฌแงแแแขแแ:
- แ5.4x แแแแ โ แแแแแขแแ แแแแแกแแแแก (แแ แแแแแ);
- c5.4x แแแแ - Node.js แแแขแแแ แแแแกแแแแก (แแ แ แฎแ แแฎแแแแแ แแแขแแแ แแแ);
- c5.2x แแแแ - Java แแ Go-แกแแแแก (แแ แแแแแกแแ แแฃแแแแแ แแแขแแแ แแแ);
- c5.4x แแแแ โ แแแ แแแแก แแแแแแแกแแแแก (3 แแแแแซแ).
แแแแ แแชแแ
แซแแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแแแ Kubernetes-แจแ แแแแ แแชแแแก แแ แ-แแ แแ แแแกแแแแแแแแแแ แแแแแฏแ แแงแ แกแแ แแแกแแแก แจแแ แแก แแ แกแแแฃแแ แแแ แแแแแ แ แแแแฃแแแแแชแแแก แแแแแแแกแแแแ แแแแ แแฎแแ แแแขแแแ แแแแก แแแแแแกแแ แแแแ (แแแแกแขแแฃแ แ แแแขแแแ แแแแก แแแแแแกแแ แแแ (ELB). แแกแแแ แจแแแฅแแแ แแแ แขแฃแแแฃแ แ แแแ แซแ แฆแ แฃแแแแก แแแแแ แแขแฃแ แฅแแแฅแกแแแแ (VPC). แแก แฅแแแฅแกแแแ แแแแแแจแแ แแแฃแแ แแงแ Kubernetes VPC-แแแ. แแแแ แแแแแชแ แกแแจแฃแแแแแ แแแแฃแแแแแก แแขแแแแแ แแแแ แแแแ แแชแแ, แกแแ แแแกแแก แแแแแแแแแแฃแแแแแก แแแแแ แแขแฃแแ แ แแแแก แแแแแแแแกแฌแแแแแแก แแแ แแจแ.
แแก แกแแแแแแ แฌแแ แขแแแแแ แจแแแฅแแแ DNS แฉแแแแฌแแ แแแแก แจแแฌแแแแแ แแแแ แแแแก แแแแแงแแแแแแ, แ แแแแแแกแแช CNAME-แแแ แแแฃแแแแแแแแแ แงแแแแ แแฎแแ ELB-แแ. แแแแแกแแ แแแแแ, แฉแแแ แแแแแแแขแแ แแฎแแแ แฉแแแแฌแแ แ, แ แแแแแแช แแแฃแแแแแแก Kubernetes แกแแ แแแกแแก แแฎแแ ELB-แแ, แฌแแแแ 0. แจแแแแแ แฉแแแ แแแแแงแแแแ แฉแแแแฌแแ แแก แแแแ แแแแก Time To Live (TTL) 0-แแ. แแแแก แจแแแแแ, แซแแแแ แแ แแฎแแแ แฌแแแ แแงแ. แแแแ แแแ แแแฃแแแ แแ แแ แกแแแแแแแ แแแขแแแ แแแแก 100% แแแแแแแแแแแ แแฎแแ แกแแ แแแ แก. แแแแแ แแแแก แแแกแ แฃแแแแแก แจแแแแแ, TTL แแแแจแแแแแแแ แแแแ แฃแแแ แฃแคแ แ แแแแฅแแแขแฃแ แแแแแแ.
Java แแแแฃแแแแ, แ แแแแแแแช แฉแแแ แแแฅแแแแ, แจแแแซแแแ แแแฃแแแแแแแแแ แแแแแ TTL DNS-แก, แแแแ แแ Node แแแแแแแชแแแแก แแ แจแแแซแแแ. แแ แ-แแ แแแ แแแแแแแ แแ แแแแแฌแแ แ แแแแจแแ แแก แแฃแแแก แแแแแก แแแฌแแแ แแ แจแแแฎแแแ แแแแแฏแแ แจแ, แ แแแแแแช แแฃแแแแก แแฎแแแแแ แงแแแแ 60 แฌแแแจแ. แแ แฉแแฃแแแ แแแแแแแแ แแแฃแจแแแ แซแแแแแ แแแ แแแ แแ แจแแกแ แฃแแแแแก แจแแกแแแฉแแแแ แแแแ แแแแชแแแก แแแ แแจแ.
แแแแแแแแแแแ
แฅแกแแแแก แฅแกแแแแแแก แกแแแฆแแ แแแ
8 แฌแแแก 2019 แแแแแแ แก, แแแแแแแแแกแแก, Tinder-แแก แแแแขแคแแ แแ แแแฃแแแแแแแแ แฉแแแแแแ แแ. แแ แแแแแ แแแ แ แแแแขแคแแ แแแก แจแแงแแแแแแแก แจแแฃแกแแแแแ แแ แแแก แกแแแแกแฃแฎแแ, แแแแกแขแแ แจแ แแแแแซแแแแก แแ แแแแแซแแแแก แ แแแแแแแแ แแแแแแ แแ. แแแแ แแแแแแฌแแแ ARP แฅแแจแแก แแแแฌแฃแ แแ แงแแแแ แฉแแแแก แแแแแซแแ.
แแ แกแแแแแก แกแแแ Linux แแแ แแแแขแ, แ แแแแแแช แแแแแแจแแ แแแฃแแแ ARP แฅแแจแแแ:
()
gc_thresh3 - แแก แ แแฃแแ แแฆแแแ แแ. แแฃแ แแแแจแ โแแแแแแแแแแก แชแฎแ แแแแก แแแแแญแแ แแแแแกโ แฉแแแแฌแแ แแแแก แแแแแฉแแแ แแแจแแแแแ, แ แแ แกแแแฅแ แแแฃแแ แแแแแแก แจแแแ แแแแแแก (GC) แจแแแแแแแช แแ, แแ แแงแ แกแแแแแ แแกแ แแแแแแ ARP แฅแแจแ แแแแแแแแ แฉแแแแฌแแ แแก แจแแกแแแแฎแแ. แแ แจแแแแฎแแแแแจแ, แแแ แแแแ แฃแแ แแแแ แแแแแแแแ แแแแแขแ แแแแแแแแ.
แฉแแแ แแแงแแแแแ แ แแแแ แช แฅแกแแแแก แฅแกแแแแแ Kubernetes-แจแ. แแแแแขแแแ แแแแแแชแแแ VXLAN-แแก แกแแจแฃแแแแแแ. VXLAN แแ แแก L2 แแแแ แแแ, แ แแแแแแช แแฆแแแ แแฃแแแ L3 แฅแกแแแแก แแแแแ. แขแแฅแแแแแแแ แแงแแแแแก MAC-in-UDP (MAC Address-in-User Datagram Protocol) แแแแแคแกแฃแแแชแแแก แแ แกแแจแฃแแแแแแก แแซแแแแก แฅแกแแแแก แแ-2 แคแแแแก แกแแแแแแขแแแแก แแแคแแ แแแแแแก. แกแแขแ แแแกแแแ แขแ แแ แแขแแแแแ แคแแแแแฃแ แ แแแแแชแแแแ แชแแแขแ แแก แฅแกแแแจแ แแ แแก IP แแแฃแก UDP.
แกแฃแ แแแ 2-1. แคแแแแแแแก แแแแแ แแแ ()
แกแฃแ แแแ 2-2. VXLAN แแแแแขแ ()
Kubernetes-แแก แแแแแแฃแแ แแฃแจแ แแแแแซแ แแแแแงแแคแก แแแ แขแฃแแแฃแ แแแกแแแแ แแแ แแแแแแก /24 แแแฆแแแ แฃแคแ แ แแแแ /9 แแแแแแแแ. แแแแแแฃแแ แแแแแซแแกแแแแก แแก แแ แแก แแ แแ แฉแแแแฌแแ แ แแแ แจแ แฃแขแแแแชแแแก แชแฎแ แแแจแ, แแ แแ แฉแแแแฌแแ แ ARP แชแฎแ แแแจแ (flannel.1 แแแขแแ แคแแแกแแ) แแ แแ แแ แฉแแแแฌแแ แ แแแแแ แแแแก แชแฎแ แแแจแ (FDB). แแกแแแ แแแแขแแแ แแแ แแแแ แแฃแจแ แแแแแซแแก แแแจแแแแแกแแก แแ แงแแแแแ แแฎแแแ แแแแแซแแก แแฆแแแฉแแแแกแแก.
แแแ แแ แแแแกแ, node-pod (แแ pod-pod) แแแแฃแแแแแชแแ แกแแแแแแแ แแแแแก แแแขแแ แคแแแกแแก แแแจแแแแแแ eth0 (แ แแแแ แช แแแฉแแแแแแแ แแแแแ แคแแแแแแแก แแแแแ แแแแจแ). แแก แแฌแแแแก แแแแแขแแแแ แฉแแแแฌแแ แก ARP แชแฎแ แแแจแ แแแแแแฃแแ แจแแกแแแแแแกแ แฌแงแแ แแกแ แแ แแแแแจแแฃแแแแแก แฐแแกแขแแกแแแแก.
แฉแแแแก แแแ แแแแจแ แแ แขแแแแก แแแแฃแแแแแชแแ แซแแแแแ แแแแ แชแแแแแฃแแแ. Kubernetes-แจแ แกแแ แแแกแแก แแแแแฅแขแแแแกแแแแก แแฅแแแแแ ELB แแ Kubernetes แแ แแแแกแขแ แแ แแแก แแแแแแฃแ แแแแแซแก ELB-แจแ. ELB-แ แแ แแคแแ แ แแชแแก แแแแแแแก แจแแกแแฎแแ แแ แแ แฉแแฃแแ แแแแแซแ แจแแแซแแแแ แแ แแงแแก แแแแแขแแก แกแแแแแแ แแแแแจแแฃแแแแ. แกแแฅแแ แแแแจแแ, แ แแ แ แแแแกแแช แแแแแซแ แแฆแแแก แแแแแขแก ELB-แแแ, แแก แแแแแฎแแแแแก แแแก แฌแแกแแแแก แแแแแแแแกแฌแแแแแแ. iptables แแแแแ แแขแฃแแ แกแแ แแแกแแกแแแแก แแ แจแแแแฎแแแแแ แแ แฉแแแก แแแแก แกแฎแแ แแแแแซแแ.
แฌแแ แฃแแแขแแแแแแแก แแ แแก แแแแกแขแแ แจแ แแงแ 605 แแแแแซแ. แแแแแ แฉแแแแแแแแแ แแแแแแแแแก แแแแ, แแก แกแแแแแ แแกแ แแงแ แแแแจแแแแแแแแก แแแกแแซแแแแแ gc_thresh3, แ แแแแแแช แแแแฃแแแกแฎแแแแแ. แ แแแแกแแช แแก แแแฎแแแแ, แแ แ แแฎแแแแ แแแแแขแแแแก แแแ แแแ แแฌแงแแแ, แแ แแแแ แแแแแ Flannel แแแ แขแฃแแแฃแ แ แแแกแแแแ แแแแแก แกแแแ แชแ /24 แแแฆแแแ แฅแ แแแ ARP แชแฎแ แแแแแแ. Node-pod แแแแฃแแแแแชแแ แแ DNS แแแแฎแแแแแแ แจแแฌแงแแแขแแแแ (DNS แแแแแแแกแแแฃแแแ แแแแกแขแแ แจแ; แฌแแแแแแฎแแ แแแแแแแแแแแ แแ แกแขแแขแแแจแ แแแขแแแแแแกแแแแก).
แแ แแ แแแแแแแก แแแแแกแแญแ แแแแ, แแฅแแแ แฃแแแ แแแแแ แแแ แแแแจแแแแแแแแแ gc_thresh1, gc_thresh2 ะธ gc_thresh3 แแ แแแแแขแแแ แแแ Flannel, แ แแแ แฎแแแแฎแแ แแแแ แแแแกแขแ แแ แแ แแแแแ แแฃแแ แฅแกแแแแแ.
DNS-แแก แแแฃแแแแแแแ แกแแแแแ แแแ
แแแแ แแชแแแก แแ แแชแแกแจแ แฉแแแ แแฅแขแแฃแ แแ แแแงแแแแแแแ DNS-แก แขแ แแคแแแแก แกแแแแ แแแแแ แแ แกแแ แแแกแแแแก แแขแแแแแ แแแแ แแแแแกแแขแแแแ แซแแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแแแ Kubernetes-แจแ. แฉแแแ แแแแแงแแแแ แจแแแแ แแแแ แแแแแแ TTL แแแแจแแแแแแแแแ แแแแแแจแแ แแแฃแแ RecordSets Route53-แจแ. แ แแแแกแแช แซแแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แ แแฃแจแแแแแ EC2 แแแกแขแแแชแแแแแ, แฉแแแแ แแแแแแฌแงแแแขแแก แแแแคแแแฃแ แแชแแ แแแฃแแแแแแแ Amazon DNS-แแ. แฉแแแ แแก แแแแแกแแแแแ แแแแแฆแแ แแ แแแแแแ TTL-แแก แแแแแแแ แฉแแแแก แกแแ แแแกแแแแ แแ แแแแแแแแก แกแแ แแแกแแแแ (แ แแแแ แแชแแ DynamoDB) แแแแฌแแแแ แจแแฃแแฉแแแแแแ แแแ แฉแ.
แ แแแแกแแช แฉแแแ แแแแแแแขแแแแ แกแแ แแแกแแแ Kubernetes-แจแ, แแฆแแแแแฉแแแแ, แ แแ DNS แแแฃแจแแแแแแ 250 แแแแก แแแแฎแแแแแก แฌแแแจแ. แจแแแแแแ, แแแแแแแชแแแแแ แแแแฌแงแแก แแฃแแแแแ แแ แกแแ แแแแฃแแ แแ แแแก แแแแฌแฃแ แแ DNS แแแแฎแแแแแแแกแแแแก. แแก แแแฎแแ DNS แแ แแแแแแแ แแก แแแขแแแแแแชแแแกแ แแ CoreDNS-แแ แแแแแ แแแแก แฌแแ แแแฃแแแแแแแ แแชแแแแแแแก แแแฃแฎแแแแแแ (แ แแแแแแช แแแแแก แแแขแแแ แแแแก แแ แแก แแแแฆแฌแแ 1000 แแแแก, แ แแแแแแช แแฃแจแแแแก 120 แแแ แแแแ).
แกแฎแแ แจแแกแแซแแ แแแแแแแแแกแ แแ แแแแแฌแงแแแขแแแแแแแแก แจแแกแฌแแแแแกแแก แฉแแแ แแฆแแแแแฉแแแแ , แแฆแฌแแ แก แ แแกแแก แแแ แแแแแก, แ แแแแแแแช แแแแแแแแก แแฎแแแแแ แแแแแขแแก แคแแแขแ แแชแแแก แฉแแ แฉแแแ แฅแกแแแแก แคแแแขแ แ Linux-แจแ. แฉแแแ แแแแ แแแคแแฅแกแแ แแแฃแแ แขแแแแแฃแขแแแ, แแแแ แ แแ แแชแฎแแแแแแ แแ แแแ แฉแแกแแ_แฉแแแจแแแ Flannel แแแขแแ แคแแแกแจแ แจแแแกแแแแแแแแแ แกแขแแขแแแก แแแกแแแแแแก.
แแ แแแแแแ แฉแแแแแ แฌแงแแ แแกแ แแ แแแแแจแแฃแแแแแก แฅแกแแแแก แแแกแแแแ แแแก แแแ แแแแแก (SNAT แแ DNAT) แแ แชแฎแ แแแจแ แจแแแแแแ แจแแงแแแแแก แแขแแแแ. แแแแขแ แขแ แแแ. แแ แ-แแ แแ แแแแแกแแแแแ, แ แแแแแแช แจแแแแแแแแ แแแแแฎแแแแแแแ แแ แกแแแแแแแแแแแก แแแแ แแงแ แจแแแแแแแแแแแฃแแ, แแงแ DNS-แแก แแแแแขแแแ แแแแแ แแฃแจแ แแแแแซแจแ. แฒแ แจแแแแฎแแแแแจแ:
- SNAT แแ แแ แแก แกแแญแแ แ, แ แแแแแ แขแ แแคแแแ แ แฉแแแ แแแแแซแแก แจแแแแแ. แแ แแ แแก แกแแญแแ แ แแแขแแ แคแแแกแแก แแแจแแแแแแ แแแแแขแแแ eth0.
- DNAT แแ แแ แแก แกแแญแแ แ, แ แแแแแ แแแแแจแแฃแแแแแก IP แแ แแก แแแแแแฃแ แ แแแแแซแแกแแแแก แแ แแ แ แจแแแแฎแแแแแ แจแแ แฉแแฃแแ แแแแ แฌแแกแแแแก แแแฎแแแแแ iptables.
แฉแแแ แแแแแแฌแงแแแขแแ แแ แแแแแแแแก แแแแ แฉแแ. CoreDNS แแงแ แแแแแแแแแฃแแ, แ แแแแ แช DaemonSet Kubernetes-แจแ แแ แฉแแแ แแแแแแฎแแ แชแแแแแ แแแแแแแแ แแแ แแแแแซแแก DNS แกแแ แแแ แ rezv.conf แแแแแแฃแแ แแแแ แแ แแจแแก แแแงแแแแแแ --แแแกแแขแฃแ แ-dns แแฃแแแแแ แแฃแแแแแขแโ. แแก แแแแแกแแแแแ แแคแแฅแขแฃแ แ แแฆแแแฉแแแ DNS-แแก แแ แแแก แแแแฌแฃแ แแแกแแแแก.
แแฃแแชแ, แฉแแแ แแแแแช แแแแแแแฎแแ แแแแแขแแก แแแแแ แแแ แแ แแ แแชแฎแแแแแก แแ แแ แฉแแกแแ_แฉแแแจแแแ แคแแแแแแแก แแแขแแ แคแแแกแจแ. แแก แแแแ แซแแแแ แแแแแกแแแแแก แแแแฎแแ แชแแแแแแแก แจแแแแแ, แ แแแแแ แฉแแแ แจแแแซแแแแ SNAT แแ/แแ DNAT-แแก แแฆแแแคแฎแแ แ แแฎแแแแ DNS แขแ แแคแแแแกแแแแก. แ แแแแแก แแแ แแแแแ แจแแแแ แฉแฃแแแแฃแแ แแงแ แกแฎแแ แขแแแแก แแแซแ แแแแแกแแแแก. แกแแแแแแแแ แแ, แฉแแแแ แแแแแขแแแแก แฃแแแขแแกแแแ แแ แแก TCP แแ แแฃ แแ แแแแแแ แฌแแ แแแแฅแแแแแ, แแกแแแ แฃแแ แแแแ แฎแแแแฎแแ แแแแแแชแแแ. แฉแแแ แแแแแ แแชแแแแแแ แแแแแแแ แจแแกแแคแแ แแกแ แแแแแฌแงแแแขแ แงแแแแ แขแแแแก แขแ แแคแแแแกแแแแก.
Envoy-แแก แแแแแงแแแแแ แฃแแแแแกแ แแแขแแแ แแแแก แแแแแแแแกแแแแกแแแแก
แ แแแแกแแช แฉแแแ แแแแแแแขแแแแ backend แกแแ แแแกแแแ Kubernetes-แจแ, แฉแแแ แแแแแฌแงแแ แขแแแฏแแ แแแแแแก แจแแ แแก แแแฃแฌแแแแกแฌแแ แแแแแ แแแขแแแ แแแแ. แฉแแแ แแฆแแแแแฉแแแแ, แ แแ HTTP Keepalive-แ แแแแแแฌแแแ ELB แแแแจแแ แแแแก แแแแแแแแ แงแแแแแ แแแแแแแแแแก แแแ แแแ แแแ แแแแแแแแ. แแแ แแแแ, แขแ แแคแแแแก แฃแแแขแแกแ แแแฌแแแ แแแแแ แ แฎแแแแแกแแฌแแแแแ แแแแแแแแก แแชแแ แ แแ แแชแแแขแจแ. แแแ แแแแ แแแแแกแแแแแ, แ แแแแแแช แฉแแแ แแแแแแชแแแแ, แแงแ MaxSurge-แแก 100%-แแ แแแงแแแแแ แแฎแแ แแแแแแแแแแแ แฃแแ แแกแ แกแชแแแแ แแกแแแแก. แแคแแฅแขแ แแฆแแแฉแแแ แฃแแแแจแแแแแ แแ แแ แแแแ แกแแแฅแขแแฃแแ แฃแคแ แ แแแแ แแแแแแแแแแก แแแแแกแแแ แแกแแ.
แแแแแ แแ แแ แแแแแกแแแแแ, แ แแแแแแช แฉแแแ แแแแแแแงแแแแ, แแงแ แแ แแขแแแฃแแ แกแแ แแแกแแแแกแแแแก แ แแกแฃแ แกแแแแก แแแแฎแแแแแก แฎแแแแแแฃแ แแ แแแแ แแ. แแ แจแแแแฎแแแแแจแ, แแแฎแแแแแแ แแแแแแแกแแแฃแ แขแแขแแแก แแฅแแแแแ แแแขแ แแแแแแ แแแแแแ แแ แแแแกแแแแก, แแแแ แ แกแฎแแ แแซแแแ แแฃแแแแแแแ แจแแแแ แแแแ. แแก แแ แช แแ แซแแแแแแแแ แแแ แกแแแฅแขแแแแจแ แแแฃแจแแแแแก, แ แแแแแ แ แแกแฃแ แกแแแแก แแแแแ แแแ แแฅแแแแ. แแแ แแ แแแแกแ, แฉแแแแ Node แแแแแแแชแแแแ แแงแ แแ แแแแแแแแแแ แแ, แจแแกแแแแแแกแแ, แจแแแซแแ แแฎแแแแ แแ แแ แแแ แแแแก แแแแแงแแแแแ. แแ แแแแแ แแ แ แแแแฃแ แ แแแแแกแแแแแ แแงแ แฃแแแแแกแ แแแขแแแ แแแแก แแแแแแแแกแแแแก แแแแแงแแแแแ.
แฉแแแ แแแแ แฎแแแแ แแแแแแแแ แกแ แฃแแแ แแแแแคแแกแแ . แแ แกแแแฃแแแ แแแแแ แแแแ แแแแแชแ แกแแจแฃแแแแแ, แซแแแแแ แจแแแฆแฃแแฃแแแ แแแแแแแแงแแแแแแแ แแ แแงแแกแแแ แ แจแแแแแ แแแแแฆแแ. Envoy แแ แแก แแแฆแแแ แฎแแ แแกแฎแแก, แฆแแ แแแแแก, แคแแแแก XNUMX แแ แแฅแกแ, แ แแแแแแช แจแแฅแแแแแแ แแแแ SOA แแแแแแแชแแแแแกแแแแก. แแแก แจแแฃแซแแแ แแแแแฎแแ แชแแแแแก แแแขแแแ แแแแก แแแแแแแแกแแแแก แแแฌแแแแแ แขแแฅแแแแ, แแแ แจแแ แแก แแแขแแแแขแฃแ แ แแแแแแแ แแแแแ แชแแแแ, แแแแแ แแแแแแแ แแ แแแแแแแฃแ แ แกแแฉแฅแแ แแก แจแแแฆแฃแแแ. (แฒจแแแแจแแแ. แแแ แแแแ: แแแแก แจแแกแแฎแแ แแแขแ แจแแแแซแแแแ แฌแแแแแแฎแแ แแฅ แแกแขแแแก แจแแกแแฎแแ, แ แแแแแแช แแแคแฃแซแแแแฃแแแ แแแกแแแแแ.)
แฉแแแ แแแแแฆแแ แจแแแแแแ แแแแคแแแฃแ แแชแแ: แแฅแแแแแ Envoy sidecar แแแแแแฃแแ แแแแแกแแแแก แแ แแ แแ แแแ แจแ แฃแขแแกแแแแก แแ แแแแแแแจแแ แแ แแแแกแขแแ แ แแแแขแแแแแ แแแ แแแแแแแแ แแแแ แแแ แขแแก แกแแจแฃแแแแแแ. แแแขแแแชแแฃแ แ แแแกแแแแแก แจแแกแแแชแแ แแแแแ แแ แแชแแ แ แแแ แขแงแแแก แ แแแแฃแกแแก แจแแกแแแแ แฉแฃแแแแแแ, แฉแแแ แแแแแแแงแแแแ Envoy-แแก แคแ แแแข-แแ แแฅแกแ แแแแแแแแก แคแแแขแ, แแ แแ แฎแแแแแกแแฌแแแแแแแแก แแแแแจแ (AZ) แแแแแแฃแแ แกแแ แแแกแแกแแแแก. แแกแแแ แแงแ แแแแแแแแแ แฉแแแแ แแ แ-แแ แแ แแแแแแ แแก แแแแ แแแฌแแ แแ แฃแแ แแแ แกแแ แแแกแแก แแฆแแแฉแแแแก แซแ แแแแก, แ แแแแแแช แฃแแ แแแแ แแแ แฃแแแแแ แแแแแแฃแ AZ-แจแ แแแชแแแฃแแ แกแแ แแแกแแกแแแแก แแแแแแแแก แกแแแก.
Service front-Envoys-แแ แจแแแแแ แแแแแแงแแแ แกแแ แแแกแแก แแฆแแแฉแแแแก แแแฅแแแแแแ แแ แแ แแแแแ แ แแแแกแขแแ แแ แแ แแแ แจแ แฃแขแแ. แฉแแแ แแแแแงแแแแ แแแแแแแขแฃแ แ แแแแแแ, แแแแแแ แแแ แแแแแ แแแแแแก แงแแแแ แแแ แแแแขแ แ แแ แแแแแแแขแแ แฎแแแแฎแแแ แชแแแก แแแแแแแแฃแ แ แแแแคแแแฃแ แแชแแ, แ แแแ แแแแแแฎแแแ แแก แชแแแแแฃแแ แฌแแ แฃแแแขแแแแแแแกแ แแ แจแแฃแคแแ แฎแแแแแ แแแแแแแแแแก แฃแแ แฃแแแแแกแแงแแคแแ. แฉแแแ แแแแแแแแกแแ TCP ELB แแแแแแฃแแ แแ แกแแ แแแกแแก แฌแแแ แแแฉแแก แฌแแ. แแแจแแแแช แแ, แแฃ keepalive แฉแแแแ แแแแแแ แ แแ แแฅแกแ แคแแแแแแ แแงแ แฉแแ แฉแแแแแ แแแแแแ แ Envoy pods-แแ, แแกแแแ แแแแแช แแฎแแ แฎแแแแแแ แแแขแแแ แแแแก แแแแ แแ แฃแแแแแกแแ แแแฃแแแแแแแแแ แแ แแแแคแแแฃแ แแ แแแฃแแ แแงแแแแ, แ แแ แแแแแแแแแกแแ minimum_request backend-แจแ.
แแแแแแแแแแกแแแแก, แฉแแแ แแแแแแแงแแแแ preStop แแแฃแญแ, แ แแแแ แช แแแแแแแชแแแก แแแแแจแแแแ, แแกแแแ แแแแ แแแแ แแแ แแก แแแแแแแ. แแแฃแญแแ แแแแแฃแจแแ แจแแชแแแแ แแแแแแแกแขแ แแขแแ แแก แกแแแแแแ แฌแแ แขแแแแก แกแขแแขแฃแกแแก แจแแแแฌแแแแแจแ, แ แแแแแแช แแแแแแ แแแแก แแแแ แแแแ แแแ แแก แแแแขแแแแแ แแ แแ แชแแขแ แฎแแแ แแแแซแแแ, แ แแแ แแฅแขแแฃแ แ แแแแจแแ แแแ แจแแฌแงแแแก.
แแ แ-แแ แแ แแแแแแ, แ แแก แแแแแช แฉแแแ แจแแแซแแแแ แแกแ แกแฌแ แแคแแ แแแแแแแแแแแแ, แแ แแก แแแขแแแฃแ แ แแแขแ แแแแก แแแแ, แ แแ แฉแแแ แจแแแซแแแแ แแแแแแแ แแแขแแแ แแ แแแ แแ แแแแแแก แขแแแแฃแ แแแกแขแแแแชแแแจแ. แแแแ แแแแแชแ แกแแจแฃแแแแแ แแแแแแฎแ แแฃแกแขแแ แ แ แฎแแแแแแ แแแจแแ, แ แแแแกแแช แฉแแแ แแแ แแแฃแแแ แแแแแ แแแแคแแแฃแ แแชแแแก แแแ แแแแขแ แแแก แแ แแแแแแแแแฌแแแแแแแ แขแ แแคแแแก.
แจแแแแแแแ แแงแแกแแแ แ แแ แแจแแแ แ แแงแ. แฉแแแ แแแแแฌแงแแ แงแแแแแแ แแแฃแแแแแแกแแแแแ แกแแ แแแกแแแแ แแ แแ แแ แแแกแแแแก แแก แแฃแจแแแแก แแแแกแขแแ แจแ 12 แงแแแแแแ แแแแจแแแแแแแแแ แกแแ แแแกแแก แฌแแ. แฌแแแก แฉแแแ แแแแแแแแ แกแ แฃแ แกแแ แแแกแฃแ แฅแกแแแแ แแแแแกแแแแก แฃแคแ แ แแแฌแแแแแ แกแแ แแแกแแก แแฆแแแฉแแแแ, แแแแ แแกแฅแแแแก แแแฌแงแแแขแแ, แแแ แ แแแแแแแแแแ, แกแแฉแฅแแ แแก แจแแแฆแฃแแแแ แแ แแแแแแแแแ.
แกแฃแ แแแ 3-1. แแ แแ แกแแ แแแกแแก CPU แแแแแแ แแแแชแแ Envoy-แแ แแแแแกแแแแกแแก
แฒกแแแแแแ แจแแแแแ
แแ แแแแแชแแแแแแแกแ แแ แแแแแขแแแแแ แแแแแแแแแก แแแจแแแแแแ แฉแแแ แจแแแฅแแแแแ แซแแแแ แ แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแฃแแแ, แ แแแแแกแแช แแฅแแก แซแแแแ แ แฃแแแ แแแ แแแแ Kubernetes แแแแกแขแแ แแแแก แแแแแแแแก, แแแแแแแแแแกแ แแ แแฅแกแแแฃแแขแแชแแแก แกแคแแ แแจแ. Tinder-แแก แงแแแแ แแแแแแแ แก แแฎแแ แแฅแแก แชแแแแ แแ แแแแแชแแแแแแ, แ แแ แจแแคแฃแแแก แแแแขแแแแแ แแแ แแ แแแแแแแแกแแก แแแแแแแชแแแแ Kubernetes-แจแ.
แ แแแแกแแช แซแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแแ แแแแแขแแแแแ แกแแแซแแแแ แแก แกแแญแแ แแแแ แแแฉแแแ, แฉแแแ แแแแแแฌแแ แ แแแแแแแแ แฌแฃแแแก แแแแแแ แแฎแแแ EC2 แแแกแขแแแชแแแแแก แแแกแแจแแแแแ. แแฎแแ แแแแขแแแแแ แแแ แแฌแงแแแแ แแฃแจแแแแแก แแ แแฌแงแแแแ แขแ แแคแแแแก แแแแฃแจแแแแแแก แฌแฃแแแแแก แแแชแแแแ แฌแแแแแจแ. แแ แแแแแฏแแ แแแ แแแแขแแแแแ แแก แแแแแแแแ แแ แ EC2 แแแแแแแแแ แแกแแแ แฃแแ แฃแแแแแงแแคแก แแแฃแแฏแแแแกแแแฃแ แฐแแ แแแแแขแแแฃแ แแแแชแแแขแ แแชแแแก. แจแแแแแแ, แฉแแแ แแแ แแแแแแแ แแแ EC2019 แฎแแ แฏแแแแก แแแแจแแแแแแแแ แจแแแชแแ แแแแก 2 แฌแแแก แแแกแฃแ แฌแแแแแ แจแแแแ แแแแ.
แแแแ แแชแแแก แแแแฅแแแก แแ แ แฌแแแ แแแกแญแแ แแ, แแแแ แแ แฉแแแ แแแแแกแ แฃแแแ 2019 แฌแแแก แแแ แขแจแ. แแแแแแแ Tinder แแแแขแคแแ แแ แแฃแจแแแแก แแฅแกแแแฃแแแฃแ แแ Kubernetes-แแก แแแแกแขแแ แแ, แ แแแแแแช แจแแแแแแ 200 แกแแ แแแกแแกแแแ, 1000 แแแแแซแแกแแแ, 15 แแแแแกแแแ แแ 000 แแแจแแแแฃแแ แแแแขแแแแแ แแกแแแ. แแแคแ แแกแขแ แฃแฅแขแฃแ แ แแฆแแ แแ แแก แแแแ แแชแแฃแแ แแฃแแแแแแก แแ แแแแแ แแ แกแคแแ แ. แงแแแแ แฉแแแแ แแแแแแแ แ แแแแแ แแแก แแ แแแกแฃแฎแแกแแแแแแแแแก แแ แแแแแขแ แแแแแก แแแแ แแแแแแแชแแแแแก แจแแฅแแแแกแ แแ แแแแแ แแแแก แแ แแชแแกแก แแฎแแแแ แแแแแก แแแแแงแแแแแแ.
PS แแแแ แแแแแแแกแแแ
แแกแแแ แฌแแแแแแฎแแ แกแขแแขแแแแแก แกแแ แแ แฉแแแแก แแแแแแ:
- ยซ".
- ยซ".
- ยซ".
- ยซ".
- ยซ".
- ยซ".
- ยซ".
- ยซ".
- ยซ".
- ยซ".
แฌแงแแ แ: www.habr.com