แแแแแ แแขแฃแแ แแแแแแแชแแแกแแแแก Kubernetes แแแแกแขแแ แแก แแแจแแแแแกแแก, แแฅแแแ แฃแแแ แแแกแแแแแ, แ แแก แฃแฅแแแแก แแแแแ แแแแแแแชแแ, แแแแแแกแ แแ แแแแแแแแแ แแแ แแ แ แแกแฃแ แกแก. แแ แแแคแแ แแแชแแแก แกแแจแฃแแแแแแ แจแแแแซแแแแ แแแแฌแงแแ แแ แฅแแขแแฅแขแฃแ แฃแแ แแแแแฌแงแแแขแแแแแแก แแแฆแแแ แแ, แแแ แซแแ, แแแแแ แแขแฃแแ Ingress แแแแขแ แแแแ แแก แแ แฉแแแ, แ แแแแแก แ แแแแแแแแแช แแฆแแก แฃแแแ แแแแแ. แแแแกแแแแแก, แ แแ แแแแแฆแแ แซแแ แแแแแ แฌแแ แแแแแแแ แฎแแแแแกแแฌแแแแแ แแแ แแแแขแแแแก แจแแกแแฎแแ แแ แแแแแ แกแขแแขแแแก/แแแแฃแแแแขแแชแแแก แแแแแแก แแแ แแจแ แแ แ.แจ., แฉแแแ แแแแแแแแแแ แแก แแแแแฎแแแแ, แแแ แจแแ แแก แซแแ แแแแแ (แฌแแ แแแแแแกแแแแก แแแแ) Ingress แแแแขแ แแแแ แแแ.
แแแแแแแแแแแ, แ แแ แแก แแแแฎแแแ แแแ แแแแแแแแก แแ แฅแแขแแฅแขแฃแ แฃแแ แแแแแฌแงแแแขแแก แแ แฉแแแแจแ - แงแแแแ แจแแแแฎแแแแแจแ, แแก แแแฎแแแแ แแแแกแแแแแ แฌแแ แขแแแ แฃแคแ แ แแแขแแแฃแ แ แแแคแแ แแแชแแแก แแแแแแแแแกแ แแ แแ แแฅแขแแแฃแแ แแฅแกแแแ แแแแแขแแแแกแแแแก. แแแ แ แฉแแแ แจแแแแกแฌแแแแแ แกแฎแแ แแกแแแแกแ แแแกแแแแแ แฅแกแแแจแ แแ, แ แแช แแ แฃแแแ แฃแชแแแฃแ แ แแงแแก, แแแ แแแแแแแ แแ แแ แแแข-แแแแแแแแ แกแ แฃแแ แแ แ แแช แแแแแแ แแ - แกแขแ แฃแฅแขแฃแ แแ แแแฃแแ - แแแแแฎแแแแ. แแแแแ, แจแแแแกแแ แแก แฎแแ แแแแ!
แแ แแขแแ แแฃแแแแ
แแ แแแชแแแจแ, แแแแกแแแแแก, แ แแ แแแแแแแแ แจแแแแ แแแ แแ แแแแฆแแ แ แแแแ แกแแกแแ แแแแแ แจแแแแแ, แแฅแแแ แฃแแแ แแแกแแแแแ แแ แ แแฎแแแแ แกแแแแแ, แแ แแแแ แแฅแแแแแ แแ แแขแแ แแฃแแแแแก แแแแแ แแขแฃแแ แฉแแแแแแแแแแ, แ แแแแแแช แแแแกแแแฆแแ แแแก แแแแแแแก แแแฅแขแแ แก. Ingress / Kubernetes-แแก แแแแแงแแแแแแก แงแแแแ แจแแกแแซแแ แจแแแแฎแแแแแก แแแแแแแแแแแแก แแแ แแจแ, แฉแแแ แจแแแแชแแแแ แแแแแแงแแ แงแแแแแแ แแแแแแ แแแแฎแแแแแแ แแแแขแ แแแแ แแแแกแแแแก - แแแแแแแแแ, แ แแ แแแแแกแแแแ แจแแแแฎแแแแแจแ แแแแแฌแแแ แชแแ-แชแแแแ แจแแแกแฌแแแแแ แแฅแแแแ แงแแแแ แกแแแชแแคแแแ แแ แแแขแแแ.
แแแแ แแ แแแแแฌแงแแ แแ แแแฎแแกแแแแแแแแแแ, แ แแแแแแแช แแแแแแแ แแแชแแแแ แแแฎแแ, แ แแ แแกแแแ แแแแแ แแแแแ แงแแแแ แแแแแฌแงแแแขแแจแ แแ แแ แแแแแฎแแแแแ:
- แกแแ แแแกแแแแก แแแแแแแฃแ แ แแฆแแแฉแแแ (แกแแ แแแกแแก แแฆแแแฉแแแ);
- SSL แจแแฌแงแแแขแ;
- แแแแกแแแแขแแแแแ แแฃแจแแแแ.
แแฎแแ แจแแแแ แแแแกแแแแก:
แแฎแแ แแแญแแ แแแ แแฅแแแแ
แจแแ แฉแแแแก แแ แ-แแ แแ แคแฃแแแแแแแขแฃแ แ แแ แแขแแ แแฃแแ. แแฅแแแแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแ แจแแแซแแแแ แแ แแแฃแจแแแก แกแขแแแแแ แขแฃแ HTTP-แแ, แแ แจแแแซแแแแ แแแแแฎแแแแก แแ แแแ แแฃแแแ แ แแแแแแแแ แแ แแขแแแแแแ แแฃแจแแแแ. แแฃ แแฅแแแแ แกแแฅแแ แแ แแกแขแแแแแ แขแฃแแแ, แแฃแชแแแแแแแ แแแแแแแแแกแฌแแแแ แแก แคแแฅแขแแ แ, แ แแแ แแแแแแแแแแแ แแ แแแแแฌแแแ แแแแกแขแแ แแก แฎแแแแฎแแแ แแแแคแแแฃแ แแชแแ. แงแแแแ แแแแขแ แแแแ แแกแแแแก, แแฎแแ แแแญแแ แแแ แแ แแขแแแแแแแแก แกแแ แแแแกแฎแแแแแแแ.
แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแ แแแ แแแจแ
แแ แกแแแแแก แแแแแแแชแแแแแก แ แแแแแแแแ แแแ แแแชแแ, แ แแแแแแแแช แแแคแฃแซแแแแฃแแแ แแแแขแ แแแแ แ. แแแแฃแแแ แฃแแแ nginx, traefik, haproxy, envoy. แแแแแแแ, แแแก แจแแแซแแแแ แแ แฐแฅแแแแแก แแแแ แแแแแแแ แแแแแ, แแฃ แ แแแแ แฎแแแแ แขแ แแคแแแแก แแแฆแแแ แแ แแแแแชแแแ, แแแแ แแ แงแแแแแแแแก แกแแกแแ แแแแแแ แแแชแแแแ แแแขแแแชแแฃแ แ แแแฃแแแกแแแ แแ แแแฎแแกแแแแแแแแแ แแแแก แจแแกแแฎแแ, แแฃ แ แ แแ แแก โแฅแฃแแแก แฅแแแจโ.
แแแซแ แแแแแก แแแ แจแ แฃแขแแแแชแแ
แ แแก แกแแคแฃแซแแแแแแ แจแแกแแซแแแแแแ แแแแแฌแงแแแขแแแแแแก แแแฆแแแ แแแแแ แแขแฃแ แกแแ แแแกแแ แแแซแ แแแแแก แแแแแ แแฃแแแแแก แจแแกแแฎแแ? แฉแแแฃแแแแ แแ, แแก แแ แแก แแแกแแแแซแแแ แแ แแแแแแ, แแแแ แแ แแ แกแแแแแก แแแแแขแแแแแ แจแแกแแซแแแแแแแแแ.
แกแแฎแแแแ แกแแแ แชแ แแแแกแขแแ แจแ
แกแแฎแแแแ แกแแแ แชแ (แกแแฎแแแแ แกแแแ แชแ) - Kubernetes-แจแ แ แแกแฃแ แกแแแแก แแแแแแฃแ แแ แแแงแแคแแก แจแแกแแซแแแแแแแ (แแแแแแแแแ, แกแชแแแแแ, แฌแแ แแแแแ แแ แ.แจ.). แแ แแก Ingress แแแแขแ แแแแ แแแ, แ แแแแแแแช แชแแแแ แฃแแแ แแงแแก แแแแแกแขแแแแ แแแฃแแ แแแแแแฃแ แกแแฎแแแแ แกแแแ แชแแจแ (แแ แจแแแแแ แแแก แจแแฃแซแแแ แขแ แแคแแแแก แแแ แแแ แแฎแแแแ แแ แกแแแ แชแแก แแฃแฉแฅแแแแแแ). แแ แแ แแก แแกแแแแแแช (แแ แแแแ แแจแแแ แ แฃแแ แแแแแกแแแ), แ แแแแแแแช แแฃแจแแแแแ แแแแแแแฃแ แแ แแแแแ แแแแกแขแแ แแกแแแแก - แแแแจแ แขแ แแคแแแ แแแแแ แแฃแแแ แแแแกแขแแ แแก แแแแแกแแแแ แแแฌแแแแ, แกแแฎแแแแแแก แกแแแ แชแแก แแแฃแฎแแแแแแ.
แแแแฃแจแแแ แแแแแ แแแแแแแกแแแแก
แ แแแแ แแ แแก แแแแแ แแฃแแ แขแ แแคแแแ แแแแแแแชแแแก, แกแแ แแแกแแแแก แฏแแแกแแฆ แแแแแแแแแแแ? แแ แกแแแแแก แแแ แแแแขแ แแแ แแฅแขแแฃแ แ แแ แแแกแแฃแ แ แจแแแแฌแแแแแ, แแแแแแแ แแแแ, แแแแแ แแแแแแแแ (แแแแแขแแแแแ แแแคแแ แแแชแแแกแแแแก แแฎแแแแ, แแแแแแแแแ,
แแแแแแแแกแแแแก แแแแแ แแแแแแ
แแแแ แ แแแ แแแแขแแ: แขแ แแแแชแแฃแแแแแ
แแแแแแขแแคแแแแชแแ
แ แ แแแขแแ แแแแชแแแก แกแฅแแแแแก แฃแญแแ แก แแฎแแ แก แแแแขแ แแแแ แ? แซแแ แแแแแ, แแแแฏแแกแขแ, oauth, แแแ แ แแแขแแ แแขแแขแ - แแคแแฅแ แแ, แแก แแแ แแแแขแแแ แแแชแแแแ แฃแแแ แแงแแก. แแก แแแแจแแแแแแแแแ แแ แแขแแ แแฃแแแ, แแฃ แแ แกแแแแแก แแ แแแแแ แแแแแแแแแ แแก (แแ/แแ แฃแแ แแแแ แแแ แแแ) แแแ แงแฃแแ, แ แแแแแแแแช แฌแแแแแ แฎแแแแ Ingress-แแก แแแจแแแแแแ.
แแแซแ แแแแแก แแแแแฌแแแแแ
แแฎแแ แก แฃแญแแ แก แแฃ แแ แ แแแแขแ แแแแ แ แขแ แแคแแแแก แแแแแฌแแแแแแก แแกแแ แกแแงแแแแแแแแ แแแแแงแแแแแฃแ แแแฅแแแแแแแแก, แ แแแแ แแชแแ แแแแแ แแก แแแจแแแแ (แแแแแ แ), A/B แขแแกแขแแ แแแ, แขแ แแคแแแแก แแกแแฎแแ (แแแ แแแ แแแ/แแแฉแ แแแแแ)? แแก แแแ แแแแช แแขแแแแแแฃแแ แแแแแ แแแแแแแชแแแแแกแแแแก, แ แแแแแแแช แกแแญแแ แแแแแ แขแ แแคแแแแก แแฃแกแข แแ แแฃแกแข แแแแแฏแแแแขแก แแ แแแฃแฅแขแแฃแแ แขแแกแขแแ แแแแกแแแแก, แแ แแแฃแฅแขแแก แจแแชแแแแแแแก แแแแแ แแแแก แแแ แแจแ (แแ แแแแแแแแฃแ แ แแแแแแแ แแแ), แขแ แแคแแแแก แแแแแแแก แแ แ.แจ.
แคแแกแแแแ แแแแแฌแแ แ
แแ แแก แแฃ แแ แ แคแแกแแแแ แแแ แแแแขแ แแแแขแ แแแแ แแกแแแแก, แแแคแแ แแแแแฃแแ แคแฃแแฅแชแแแแแ แแแแ แแ/แแ แขแแฅแแแแฃแ แ แแฎแแ แแแญแแ แแ?
แแแแฎแแแ แแแแแก แแ แแคแแแฃแแ แแแขแแ แคแแแกแ (Web UI)
แแ แแก แ แแแแ GUI แแแแขแ แแแแ แแก แแแแคแแแฃแ แแชแแแก แกแแแแ แแแแแ? แซแแ แแแแแแ โแแแฎแแ แฎแแแฃแแแแแกแแแแกโ แแ/แแ แแแแแแแก, แแแกแแช แแแ แแแแฃแแ แชแแแแแแแแแแก แจแแขแแแ แกแญแแ แแแแ Ingress'a-แก แแแแคแแแฃแ แแชแแแจแ, แแแแ แแ โแฃแแโ แจแแแแแแแแแแ แแฃแจแแแแ แแแฃแฎแแ แฎแแแแแแ. แแก แจแแแซแแแแ แแงแแก แกแแกแแ แแแแแ, แแฃ แแแแแแแแแ แแแก แกแฃแ แ แฉแแแขแแ แแ แแแ แแแแฃแแ แแฅแกแแแ แแแแแขแแแ แขแ แแคแแแแก แจแแกแแฎแแ.
JWT แแแแแแแชแแ
JSON แแแ-แขแแแแแแแแก แฉแแจแแแแแฃแแ แแแแแแแชแแแก แแ แกแแแแแ แแแขแแ แแแแชแแแกแ แแ แแแแฎแแแ แแแแแก แแแแ แแแแแแแชแแแแแ แแแกแแแแกแขแฃแ แแแแแ.
แแแแคแแแฃแ แแชแแแก แแแ แกแแแแแแแแชแแแก แจแแกแแซแแแแแแแแแ
แจแแแแแแแก แแแคแแ แแแแแ แแ แแแแแแแ, แ แแ แแฅแแแแแ แแแฅแแแแแแแแ, แ แแแแแแแช แกแแจแฃแแแแแแก แแแซแแแแ แแแแแแขแแ แแฅแแแแ แกแแแฃแแแ แ แแแ แแฅแขแแแแแ, แแ แแจแแแ แแ แ.แจ. แกแขแแแแแ แขแฃแแ แแแแคแแแฃแ แแชแแแก แจแแแแแแแแจแ.
แซแแ แแแแแ DDOS แแแชแแแก แแแฅแแแแแแแแ
แแแ แขแแแ แแแแแแแแแแก แแแแแขแแก แแแแแ แแแแแแ แแ แฃแคแ แ แ แแฃแแ แขแ แแคแแแแก แคแแแขแ แแชแแแก แแแ แแแแขแแแ แแแกแแแแ แแแแแก, แแแแ แ แกแแแแแก, แฅแแแงแแแแแก แแ แ.แจ.
แแแแแฎแแแแ แแแแแ
Ingresses-แแก แแแแฎแแแแแแแก แแแแแขแแ แแแแแก, แแแแแงแฃแ แแก แแแแแแแแกแ แแ แแแแแ แแแแก แจแแกแแซแแแแแแแ แแแแแ แแขแฃแ แกแแ แแแกแแแแ / แแแแแแแ แแ, แแแแแแฃแ แแ, แกแแ แแแกแแแก / แแแแแแก แจแแ แแกแแช.
WAF
แแฎแแ แแแญแแ แ
แแแแขแ แแแแ แแแ
แแแแแแขแ แแแแแแแแ แกแแ แฉแแแแงแแแแแแ แแแแก แกแแคแฃแซแแแแแ
แจแแแแกแแแ แแฃแแแ แแแขแแกแแกแแแ
แกแแแขแ:
แแแชแแแแแ: Apache 2.0
แแก แแ แแก Kubernetes-แแก แแคแแชแแแแฃแ แ แแแแขแ แแแแ แ แแ แจแแแฃแจแแแแแฃแแแ แกแแแแแแแแแแแก แแแแ . แชแฎแแแแ, แกแแฎแแแแแแ แแแแแแแแแแ แ, แแก แแแคแฃแซแแแแฃแแแ nginx-แแ แแ แแแกแแแก Lua แแแแแแแขแแแแก แกแฎแแแแแกแฎแแ แแแแ แแแแ, แ แแแแแแแช แแแแแแงแแแแแ แแแแแขแแแแแ แคแฃแแฅแชแแแแแก แแแแกแแฎแแ แชแแแแแแแแ. แแแแแ nginx-แแก แแแแฃแแแ แแแแกแ แแ แแแแขแ แแแแ แแ แแแแแงแแแแแแกแแก แแแกแจแ แแแแแแแแฃแ แ แแแแแคแแแแชแแแแแก แแแแ, แแก แแแ แแแแขแ แจแแแซแแแแ แแงแแก แงแแแแแแ แแแ แขแแแ แแ แแแ แขแแแ แแแแคแแแฃแ แแชแแ แกแแจแฃแแแ แแแแแแ แแกแแแแก (แแแ แแแแแชแแแแแแแ).
Ingress แแแแ NGINX Inc.
แกแแแขแ:
แแแชแแแแแ: Apache 2.0
nginx แแแแแแแแแ แแแแก แแคแแชแแแแฃแ แ แแ แแแฃแฅแขแ. แแฅแแก แคแแกแแแแ แแแ แกแแ แแแคแฃแซแแแแฃแแ
แฃแคแแกแ แแแ แกแแ แแแแจแแแแแแแแแ แจแแแชแแ แแ, แแแ แจแแ แแก แแคแแชแแแแฃแ แแแแขแ แแแแ แแแ แจแแแแ แแแแแแช แแ (แแแแแ Lua แแแแฃแแแแแก แแ แแ แกแแแแแแก แแแแ). แแแแแแ แแฃแแแ, แคแแกแแแแก แแฅแแก แกแแแแแแ แคแแ แแ แแแแแขแแแแแ แคแฃแแฅแชแแแแแ แแแ: แ แแแแฃแ แแ แแจแ แแแขแ แแแ, JWT แแแแแแแชแแ, แแฅแขแแฃแ แ แฏแแแแ แแแแแแแก แจแแแแฌแแแแ แแ แกแฎแแ. แแแแจแแแแแแแแแ แฃแแแ แแขแแกแแแ NGINX Ingress-แแแ แจแแแแ แแแแ แแ แแก TCP/UDP แขแ แแคแแแแก แกแ แฃแแ แแฎแแ แแแญแแ แ (แแ แกแแแแแแแแแแแก แแแ แกแแแจแแช!). แแแแฃแกแ -
แแแแ แแแแ แแกแ
แกแแแขแ:
แแแชแแแแแ: Apache 2.0
แแ แแแฃแฅแขแ แจแแแฃแจแแแแแฃแแ Kong Inc. แแ แแแ แกแแแจแ: แแแแแ แชแแฃแแ แแ แฃแคแแกแ. nginx-แแ แแแคแฃแซแแแแฃแแ, แ แแแแแแช แแแคแแ แแแแแ Lua แแแแฃแแแแแก แแแแ แ แแแแแแแแแ.
แแแแแแแแ แแแแแ แแก แแ แแแแขแแ แแแฃแแ แแงแ API แแแแฎแแแแแแแก แแแแฃแจแแแแแแกแ แแ แแแ แจแ แฃแขแแแแชแแแแ, แ.แ. แ แแแแ แช API Gateway, แแแแ แแ แแ แแ แแแกแแแแก แแก แแแฎแแ แกแ แฃแแคแแกแแแแแ Ingress แแแแขแ แแแแ แ. แซแแ แแแแแ แฃแแแ แแขแแกแแแแแ: แแแแ แ แแแแแขแแแแแ แแแแฃแแ (แแแ แจแแ แแก แแแกแแแ แแฎแแ แแก แแแแแแแแแ แแแแก แแแแฃแแ), แ แแแแแแ แแแกแขแแแแชแแ แแ แแแแคแแแฃแ แแชแแ แแแ แขแแแแ แแ แ แแแแแแ แแแฎแแแ แแแแ แแแแแ แแแแแ แแแแแขแแแแแ แคแฃแแฅแชแแแแแก แคแแ แแ แกแแแฅแขแ แ. แแฃแแชแ, แฉแแจแแแแแฃแแ แคแฃแแฅแชแแแแ แฃแแแ แแแแแแแแแแก แแแแ แจแแกแแซแแแแแแแแก. แกแแแฃแจแแแก แแแแคแแแฃแ แแชแแ แฎแแแแ CRD แ แแกแฃแ แกแแแแก แแแแแงแแแแแแ.
แแ แแแฃแฅแขแแก แแแแจแแแแแแแแแ แแแฎแแกแแแแแแแแ - แแ แแกแ แแ แแแแแ แแแแขแฃแ แจแ แแฃแจแแแแ (แกแแฎแแแแแแก แฏแแแ แแแแแ แกแแแ แชแแก แแแชแแแแ) แกแแแแแแแ แแแแแ: แแแแแกแแแแก แแก แแแแแแแแแแแแ แแแแแแงแฃแ แแแ (แแฅแแแ แฃแแแ แจแแฅแแแแ แแ แแแฃแแแแ แแแแแแฃแแ แแแแขแฃแ แแกแแแแก), แแแฆแแชแแกแแแแก แแ แแก แแ แแก แคแฃแแฅแชแแ ( แะพแแแแแแชแแแก แฃแคแ แ แแแฆแแแ แแแแ, แ แแแแ แช แแฃ แแ แแ แแแแขแ แแแแ แ แแแขแแฎแแแแ, แแแจแแ แแ แแแแแแ แจแแแแแคแแ แแแแแ แแฎแแแแ แแแแ แแกแฅแแแแ).
แขแ แแแคแแแ
แกแแแขแ:
แแแชแแแแแ: MIT
แแ แแฅแกแ, แ แแแแแแช แแแแแแแแ แแแแแ แจแแแฅแแแ แแแแ แแกแแ แแแกแแแแกแ แแ แแแแ แแแแแแแฃแ แ แแแ แแแแก แแแแฎแแแแแก แแแ แจแ แฃแขแแแแชแแแกแแแ แแฃแจแแแแแกแแแแก. แแฅแแแแ แแแแแแแแแแ แ, แแแแ แ แกแแกแแ แแแแแ แคแฃแแฅแชแแ: แแแแคแแแฃแ แแชแแแก แแแแแฎแแแแ แกแแแ แแแ แแแแแขแแแ แแแแก แแแ แแจแ, แแแแ แ แแแแแแแแแ แแแแแแแแกแแแแก แแแแแแแแแก แแฎแแ แแแญแแ แ, แแแ แแแขแแ แคแแแกแ, แแแขแ แแแแก แแแแแแแแแแ, แกแฎแแแแแกแฎแแ แแ แแขแแแแแแแแก แแฎแแ แแแญแแ แ, REST API, แแแแแ แแก แแแแแจแแแแแแ แแ แแ แแแแแ แกแฎแแ. แแแแแ แแ แแ แแแ แแ แคแฃแแฅแชแแแ Let's Encrypt แกแแ แแแคแแแแขแแแแก แแฎแแ แแแญแแ แ. แแแแฃแกแ แแ แแก แแก, แ แแ แแแฆแแแ แฎแแแแแกแแฌแแแแแแแแก (HA) แแ แแแแแแแแแกแแแแก, แแแแขแ แแแแ แก แแแกแญแแ แแแแ แกแแแฃแแแ แ KV แจแแแแฎแแแก แแแกแขแแแแชแแ แแ แแแแแแจแแ แแแ.
HAProxy
แกแแแขแ:
แแแชแแแแแ: Apache 2.0
HAProxy แแแแ แฎแแแแ แชแแแแแแแ, แ แแแแ แช แแ แแฅแกแ แแ แขแ แแคแแแแก แแแแแแกแแ แ. แ แแแแ แช Kubernetes แแแแกแขแแ แแก แแแฌแแแ, แแก แแแแแแแแแ "แ แแแ" แแแแคแแแฃแ แแชแแแก แแแแแฎแแแแแก (แขแ แแคแแแแก แแแแแ แแแแก แแแ แแจแ), แกแแ แแแกแแก แแฆแแแฉแแแแก DNS-แแ แแแคแฃแซแแแแฃแแ, แแแแแแแฃแ แ แแแแคแแแฃแ แแชแแแก แแแแแงแแแแแแ API. แจแแแซแแแแ แแแแแแแแแแ แแงแแก แแแแคแแแฃแ แแชแแแก แจแแแแแแแก แกแ แฃแแแ แแแ แแแแ CM-แแก แจแแชแแแแ, แแกแแแ แแแกแจแ Sprig แแแแแแแแแแแก แคแฃแแฅแชแแแแแก แแแแแงแแแแแแก แจแแกแแซแแแแแแแ. แแแแแแแ, แแแแแฌแงแแแขแแก แซแแ แแแแแ แแฅแชแแแขแ แแแแแแแ แแแฆแแ แกแแฉแฅแแ แแแ, แแแก แแแขแแแแแแชแแแแ แแ แแแฎแแแ แแแฃแ แ แแกแฃแ แกแแแจแ แแคแแฅแขแฃแ แแแแแ. แแแแขแ แแแแ แแก แฃแแแ แแขแแกแแแ แแ แแก แกแฎแแแแแกแฎแแ แแแแแแแแกแแแแก แแแแแแแแแก แ แแแแ แแฃแแ แ แแแแแแแแแก แแฎแแ แแแญแแ แ.
Voyager
แกแแแขแ:
แแแชแแแแแ: Apache 2.0
แแแคแฃแซแแแแฃแแแ HAproxy แแแแขแ แแแแ แแ, แ แแแแแแช แแแแแชแแแแแ แแแฃแแแ, แ แแแแ แช แฃแแแแแ แกแแแฃแ แ แแแแแฌแงแแแขแ, แ แแแแแแช แแฎแแ แก แฃแญแแ แก แคแฃแแฅแชแแแแแก แคแแ แแ แกแแแฅแขแ แก แแ แแแแแแแ แแแแก แแแ แ แแแแแแแแแแ. แจแแแแแแแแแแแฃแแแ L7 แแ L4 แขแ แแคแแแแก แแแแแแแแกแแแแก แจแแกแแซแแแแแแแ แแ แแแแแแแแแแจแ TCP L4 แขแ แแคแแแแก แแแแแแแแกแแแ แจแแแซแแแแ แแฌแแแแก แแแแแฌแงแแแขแแก แแ แ-แแ แ แแแแแแ แแแฎแแกแแแแแแแแก.
แแแแขแฃแ แ
แกแแแขแ:
แแแชแแแแแ: Apache 2.0
แแก แแแแแกแแแแแ แแ แแ แแก แแแคแฃแซแแแแฃแแ แแฎแแแแ แแแแแแกแแ: แแก แจแแแแฃแจแแแ แแ แแแแแแแแ แแ แแแแฃแแแ แฃแแ แแ แแฅแกแแก แแแขแแ แแแแแ. แแแแจแแแแแแแแแ แแแฎแแกแแแแแแแแแ Ingress-แแก แ แแกแฃแ แกแแแแก แแแแขแ แแแแก แแแแแงแแคแแก แจแแกแแซแแแแแแแ IngressRoute CRD แ แแกแฃแ แกแแแแก แแแแแงแแแแแแ. แแ แแแแแแแชแแแแแกแแแแก, แ แแแแแแกแแช แแฅแแ แแ แแแแแ แแแแแแแแ แแแแก แแฃแแแ, แ แแแแแแแช แแงแแแแแแ แแแแแ แแแแกแขแแ แก, แแก แฎแแแก แฃแฌแงแแแก แแแแแแแ แแแ แงแฃแแแแจแ แขแ แแคแแแแแ แแฃแจแแแแแก แฃแกแแคแ แแฎแแแแแก แแแฅแกแแแแแแชแแแก แแ แแแ แแแชแแแก แจแแชแแแแแแแกแแแ Ingress แ แแกแฃแ แกแแแแก แจแแชแแแแกแแก.
แแก แแกแแแ แแแแแแแแแแก แแแแแแแแกแแแแก แแแแแแแแแก แแแคแแ แแแแแฃแ แแแแแแแฅแขแก (แแ แกแแแแแก แแแแฎแแแแแแแก แแกแแฎแแ, แแแขแแแแขแฃแ แ แแแแแแ แแแ, แแแแฎแแแแแแแก แกแแฉแฅแแ แแก แจแแแฆแฃแแแ แแ แแ แแแแแ แกแฎแแ), แขแ แแคแแแแก แแแแแแแก แแแขแแแฃแ แ แแแแแขแแ แแแแ แแ แฌแแ แฃแแแขแแแแแแ. แจแแกแแซแแแ, แแแแแแกแแแแก แแแแจแแแแแแแแแ แแแแแ แแฅแแแแ แฌแแแแแแแ แกแแกแแแแแก แแฎแแ แแแญแแ แแก แแ แแ แกแแแแแ (แแฃแแชแ แกแแแฃแจแแ
แแกแขแแ แแแแ แแกแ
แกแแแขแ:
แแแชแแแแแ: Apache 2.0
แงแแแแแกแแแแชแแแแ แกแแ แแแกแฃแแ แฅแกแแแแก แแแแแฌแงแแแขแ, แ แแแแแแช แแ แ แแฎแแแแ Ingress แแแแขแ แแแแ แแ, แ แแแแแแช แแแ แแแแก แจแแแแแแแแ แขแ แแคแแแก แแแ แแแแ, แแ แแแแ แแแแแขแ แแแแแก แแแแ แขแ แแคแแแก แแแแกแขแแ แจแ. แฅแฃแแแก แฅแแแจ, Envoy แแแแแแงแแแแแ แ แแแแ แช แแแแ แแแแ แแแ แแก แแ แแฅแกแ แแแแแแฃแแ แกแแ แแแกแแกแแแแก. แแ แกแแแแแแ, แแก แแ แแก แแแแ แแแแแแแแ, แ แแแแแกแแช โแงแแแแแคแ แแก แแแแแแแแ แจแแฃแซแแแโ แแ แแแกแ แแแแแแ แ แแแแแ แแแฅแกแแแแแฃแ แ แแแ แแแแแแแแ, แแแคแแ แแแแแ, แฃแกแแคแ แแฎแแแแ แแ แแแแญแแแ แแแแแแ. แแแกแแแ แแ แแแ แจแแแแซแแแแ แแแแ แแแฃแแแ แแ แขแ แแคแแแแก แแแ แจแ แฃแขแ, แฌแแแแแ แแแแฆแแ แแแขแแ แแแแชแแ แกแแ แแแกแแแก แจแแ แแก, แแแแแแแแกแแแ, แแแแแขแแ แแแแ, แแแแแ แแก แแแแแจแแแแ แแ แแ แแแแแ แกแฎแแ. แฌแแแแแแฎแแ แแแขแ แแกแขแแแก แจแแกแแฎแแ แกแขแแขแแแแแก แกแแ แแแจแ "
แกแแแแแแแแ แแ แกแ แฃแแฃแคแแแแแแแ แแแฉแ
แกแแแขแ:
แแแชแแแแแ: Apache 2.0
แแแแแ แแ แแ แแแแแกแแแแแ, แ แแแแแแช แแแคแฃแซแแแแฃแแแ Envoy-แแ. แแแก แแฅแแก แฃแคแแกแ แแ แแแแแ แชแแฃแแ แแแ แกแแแแ. แแก แแแแแชแแแแแ แแแฃแแแ, แ แแแแ แช "แกแ แฃแแแ แแจแแแแแฃแ แ Kubernetes", แ แแช แแแแฅแแก แจแแกแแแแแแกแ แฃแแแ แแขแแกแแแแแแก (แแญแแแ แ แแแขแแแ แแชแแ K8s แแแแกแขแแ แแก แแแแแแแแแแ แแ แแ แแแฃแแแแแแ).
แจแแแแ แแแ แแแแแแ
แแกแ แ แแ, แกแขแแขแแแก แแฃแแแแแแชแแ แแ แแก แแก แฃแแแ แแแแแ แ แชแฎแ แแแ:
แแแก แจแแฃแซแแแ แแแแฌแแแแฃแแแก แฃแคแ แ แแฎแแ แกแแแแฎแแแแ แแ แแกแแแ แฎแแแแแกแแฌแแแแแแ แคแแ แแแขแจแ
แจแแฏแแแแแ
แแ แกแขแแขแแแก แแแแแแแ แฃแคแ แ แกแ แฃแแงแแคแแแ แแแแแแ (แแฃแแชแ, แแ แแแแแแ แจแแแแฎแแแแแจแ แแแแแฌแฃแ แแแ!) แแแแก แจแแกแแฎแแ, แแฃ แ แ แแ แฉแแแแแ แฃแแแ แแแแแแแแ แแฅแแแแก แแแแแ แแขแฃแ แจแแแแฎแแแแแจแ. แ แแแแ แช แงแแแแแแแแก, แแแแแแฃแ แแแแขแ แแแแ แก แแฅแแก แแแแแกแ แแแแแแแแ แแ แฃแแ แงแแคแแแ แแฎแแ แแแแโฆ
Kubernetesโ แแก แแแแกแแแฃแ แ Ingress แแแ แแแ แแแกแ แฎแแแแแกแแฌแแแแแแแแกแ แแ แแแแแกแขแฃแ แแแแกแแแแก, แกแแแแแ แแกแแ แแแแแแ แ แแแฎแแกแแแแแแแแแแ - แแแแแแแ, แแก แฃแแแ แแงแแก โแกแแแแแ แแกแ แแแแแแแแกแแแแกโ. แแฃแแชแ, แแฃ แแแแ แแแแแ แแแแฎแแแแแแ แกแขแแแแแฃแ แแแแก, แคแฃแแฅแชแแแแแก แแแแแกแ แแ แแแแแแแแ แแแแก แแแแแ แ, แงแฃแ แแแฆแแแ แฃแแแ แแแแฅแชแแแ Ingress-แก NGINX Plus-แแ แแ แคแแกแแแแ แแแแแฌแแ แแ. แแแแแก แแฅแแก แแแแแแแขแแแแก แฃแแแแแ แแกแ แแแแ แแแ (แแ, แจแแกแแแแแแกแแ, แแแ แแแแ แแแฌแแแแแฃแแ แจแแกแแซแแแแแแแแแ) แแ แคแแกแแแ แแแ แกแแแจแ แแแแแ แฃแคแ แ แแแขแแ. แแแก แแฅแแก API Gateway-แแ แแฃแจแแแแแก แฃแแแ แแแ แจแแกแแซแแแแแแแ, แแแแแแแฃแ แ แแแแคแแแฃแ แแชแแ, แ แแแแแแช แแแคแฃแซแแแแฃแแแ CRD แ แแกแฃแ แกแแแแ, แแกแแแ Kubernetes-แแก แซแแ แแแแ แกแแ แแแกแแแแ.
แแแแแแแแกแแแแกแ แแ แแแขแแ แแแแชแแแก แแแแแแแแแก แแแแ แแแแ แแแแฎแแแแแแแ, แแแแแฎแแแแ Traefik-แกแ แแ HAProxy-แก. แแก แแ แแก แฆแแ แแแแแก แแ แแแฅแขแแแ, แฌแแแแแก แแแแแแแแแแแจแ แแแแแกแขแฃแ แแแฃแแ, แซแแแแแ แกแขแแแแแฃแ แ แแ แแฅแขแแฃแ แแ แแแแแแแแ แแแแแ. Contour แฃแแแ แ แแแแแแแแ แฌแแแแ แแแแแแแแ, แแแแ แแ แแก แฏแแ แแแแแ แซแแแแแ แแฎแแแแแแ แแแ แแแแแแงแฃแ แแแ แแ Envoy-แแ แแแแแขแแแฃแแแ แแฎแแแแ แซแแ แแแแแ แคแฃแแฅแชแแแแ. แแฃ แแ แกแแแแแก แแแแฎแแแแแแ แแแแแแแชแแแก แฌแแ WAF-แแก แแ แกแแแแแแก / แฉแแจแแแแแแก แจแแกแแฎแแ, แงแฃแ แแแฆแแแ แฃแแแ แแแแฅแชแแแ แแแแแ Ingress-แก Kubernetes-แแแ แแ HAProxy-แแแ.
แแ แแแฎแแกแแแแแแแแแแ แงแแแแแแ แแแแแแ แ แแ แแก Envoy-แแ แแแแแฃแแ แแ แแแฃแฅแขแแแ, แแแแกแแแฃแแ แแแแ แแกแขแแ. แ แแแแ แช แฉแแแก, แแก แแ แแก แงแแแแแกแแแแชแแแแ แแแแแฌแงแแแขแ, แ แแแแแกแแช "แจแแฃแซแแแ แงแแแแแคแ แแก แแแแแแแแ", แ แแช, แแฃแแชแ, แแกแแแ แแแจแแแแก แแแแจแแแแแแแแแ แแแฆแแ แจแแกแแแแก แแแ แแแ แก แแแแคแแแฃแ แแชแแแก / แแแจแแแแแก / แแแแแแแกแขแ แแชแแแกแแแแก, แแแแ แ แกแฎแแ แแแแแฌแงแแแขแแแแแแแ.
แฉแแแ แแแแ แฉแแแ แแ แแฆแแแแ แแแงแแแแแ Ingress-แก Kubernetes-แแกแแแ, แ แแแแ แช แกแขแแแแแ แขแฃแ แแแแขแ แแแแ แก, แ แแแแแแช แคแแ แแแก แกแแญแแ แแแแแแแก 80-90%-แก. แแก แแ แแก แกแแแแแแ แกแแแแแแ, แแแ แขแแแ แแแแคแแแฃแ แแชแแ แแ แแแคแแ แแแแแ. แแแแแแแ, แแแแแ แแขแฃแแ แแแแฎแแแแแแแก แแ แแ แกแแแแแแก แจแแแแฎแแแแแจแ, แแก แฃแแแ แแแแ แแแก แแแแกแขแแ แแแแก/แแแแแแแชแแแแแก แฃแแแขแแกแแแแก. แแแแแ แฃแแแแแ แกแแแฃแ แ แแ แจแแแแ แแแแ แแแ แขแแแ แแ แแแฃแฅแขแแแแแแ แจแแแซแแแแ แ แแแแแแแแแแฃแแ แแงแแก Traefik แแ HAProxy.
PS
แแกแแแ แฌแแแแแแฎแแ แฉแแแแก แแแแแแ:
- "แฃแแ แฃแแแ แแแแ แแกแแ แแแกแแแก Istio-แกแแแ แแ แแแ":
แแแฌแแแ 1 (แซแแ แแแแแ แแแฎแแกแแแแแแแแแแก แจแแกแแแแแ) ,แแแฌแแแ 2 (แแแ แจแ แฃแขแแแแชแแ, แแแซแ แแแแแก แแแแขแ แแแ) ,แแแฌแแแ 3 (แแแแแแขแแคแแแแชแแ แแ แแแขแแ แแแแชแแ) ; - ยซ
Kubernetes-แแก แ แฉแแแแแ แแ แฎแ แแแแแ: แแแ แแแแฃแแ แจแแชแแแแแแแก แแแแ แแแแ NGINX Ingress-แจแ "; - ยซ
Kubernetes-แแก แ แฉแแแแแ แแ แฎแ แแแแแ: แฌแแแแแ แแแแแแแแแ แกแแแขแแแแ ".
แฌแงแแ แ: www.habr.com