แงแแแแ แกแแ แแแ แแก แแแแขแคแแ แแ, แแฃแแแแช แงแแแแแแ แซแแแแ แ แแ แแแกแจแขแแแฃแ แ, แแ แแแแแงแแคแแแแแก แงแแแแ แกแแญแแ แแแแแก, แ แแแแ แช แแ แแก. แแแฃแฎแแแแแแ แแแแกแ, แ แแ Kubernetes แแแแแฃแแแแแแแแ แแจแแแแแแ แแ แแฃแจแแแแก, แแแก แจแแแซแแแแ แแ แฐแฅแแแแแก แกแฌแแ แ แแแฌแแแแแ, แ แแ แแงแแก แกแ แฃแแงแแคแแแ. แแฅแแแ แงแแแแแแแแก แแแแแแ แกแแแชแแแแฃแ แจแแแแฎแแแแแก, แ แแแแแแช แฃแแฃแแแแแแงแแคแก แแฅแแแแก แกแแญแแ แแแแแก, แแ แ แแแแแจแแช Kubernetes แแ แแแฃแจแแแแแก แแแแฃแแแกแฎแแแ แแแกแขแแแแชแแแจแ - แแแแแแแแแ, แแแแแชแแแแ แแแแแก แแฎแแ แแแญแแ แ แแ CD แแแแ แแชแแ.
แแฅ แฉแแแแแ แแแแแขแแแแแ, แแแคแแ แแแแแแแ แแ แกแฎแแ แกแแแแแแแแ แแ แแแแขแแแแแ แแก แแ แแแกแขแ แแกแแแแก, แ แแแแแกแแช แแฎแแ แก แฃแญแแ แก แคแแ แแ แกแแแแแแแแแแ. แแ แกแขแแขแแแจแ แฌแแ แแแแแแแแแ แแฅแแแแ 11 แกแแฃแแแแแกแ แ แแ, แ แแช แฉแแแ แแฆแแแแแฉแแแแ. แกแแแฃแแแ แแแแจแ Southbridge แแกแแแ แซแแแแแ แกแแแแขแแ แแกแแ แแ แฉแแแ แแแแแแแแ แแแแแแ แแ แแฅแขแแแฃแแแ แแแแแแแแแแแก - แแแแแแฆแแ แแกแแแ แฎแ แแฎแแแแจแ แแ แแฎแแแแแจแ แแ แแแฎแแ, แ แ แแ แแก แจแแแแแ. แแแแแแ แแ แแแแแแแ แจแแกแแแแจแแแแแ แจแแแแกแแแก Kubernetes-แแก แแแแแกแแแแ แแแแกแขแแ แก, แแแแ แแ แฎแแแก แจแแฃแฌแงแแแก แแแแแ แแขแฃแแ แแ แแแแแแแแแก แแแแแญแ แแก, แ แแแแแแแช แแ แแ แแก แแแแแ แแแแ แกแขแแแแแ แขแฃแแ Kubernetes แแแฌแแแแแแจแ.
แแแ แแแญแ: แแแแแขแแแแก แแแแแฏแแแแขแ
แแ แแแฅแขแ แแแฎแกแแแแ แแแแแขแแแแก แแแแแขแ (OPA) แกแแจแฃแแแแแแก แแแซแแแแ แจแแฅแแแแ แแแแแขแแแแแ แฆแ แฃแแแแแแแ แแแแแแแชแแแแแก แแแกแขแแแ Kubernetes-แจแ, แจแแฆแฌแแแแแแ แกแแ แแแกแแก แฅแกแแแแแแ. แแแ แแแญแ แแซแแแแก Kubernetes-แแก แแจแแแแแฃแ แฃแแแ แก แแแขแแแแขแฃแ แแ แแแแแฎแแ แชแแแแแก แแแแแขแแแ แแแแแก แแแแกแขแแ แจแ แแ แแกแแแ แฃแแ แฃแแแแแงแแคแก แแแแแกแแแแ แ แแแแแแแแก แแ แ แแกแฃแ แกแแก แจแแแแฌแแแแแก, แ แแแแแแช แแ แฆแแแแก แแแแแขแแแแก. แแ แงแแแแแคแแ แก แแแฃแจแแแแแก แจแแแแ แแแแ แแฎแแแ แแแฅแแแแแแ Kubernetes-แจแ, Webhooks-แแก แแแจแแแแแก แแแแแฏแแ แ, แ แแแแแแช แแแแฅแแแแแแแ แ แแกแฃแ แกแแแแก แจแแชแแแแกแแก. Gatekeeper-แแแ แแ แแแ, OPA แแแแแขแแแ แฎแแแแ แแฅแแแแ Kubernetes แแแแกแขแแ แแก แฏแแแแ แแแแแแแก แแแแแ แแ แแ แแแฌแแแ แแฃแแแแแ แแแแแแฎแแแแแแแแแก แแแ แแจแ.
แแ แแแแขแแชแแ: แแแ แขแแขแฃแแ Kubernetes แแแแกแขแแ แแแ
แแฃ แแกแฃแ แ แแแแแแแแกแแ แแแแแแแชแแ Kubernetes-แแ, แแแแ แแแแแแแชแแแก แแฅแแก Helm แกแฅแแแ, แ แแแแแแช แฌแแ แแแ แแแแก แแ แแแขแแแแขแแแแ แแแก แแ แแ แแชแแกแก. แแแแ แแ แ แ แแแฎแแแแ, แแฃ แแกแฃแ แ แแแฆแแ แแฅแแแแ Kubernetes แแแแกแขแแ แ แแกแ, แ แแแแ แช แแ แแก แแ แแแแคแแ แแแแแ แแแ แกแฎแแแแแ?
Gravity แแฆแแแก แแฃแแแ แแแขแแก แแแแกแขแแ แแแแก แแแแแแแ แแแแแก แแแแ แแแก, แแแ แ แแแกแขแ แแแก แแแแขแแแแแ แแก แกแฃแ แแแแแแกแแแแก แแ แแแจแแแแฃแแ แแแแแแแชแแแแแก แกแแฎแแแฌแแแแแแ "แแแแแแแชแแแก แแแแแขแแแ". แแกแแแ แแแแแขแ, แ แแแแแแช แแ แแก แฉแแแฃแแแแ แแแ แคแแแแ .tar
, แจแแฃแซแแแ แแแแกแขแแ แแก แแแแแแ แแแ แงแแแแแแ, แกแแแแช Kubernetes-แก แจแแฃแซแแแ แแแจแแแแ.
Gravity แแกแแแ แแแแกแขแฃแ แแแก, แ แแ แกแแแแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แ แแฅแชแแแ แแกแแแ, แ แแแแ แช แฌแงแแ แ, แแ แ แแ Kubernetes-แแก แแแ แแแ แกแแแแแแแแ แฎแแแแแกแแฌแแแแแแ. Gravity-แแก แคแแกแแแแ แแแ แกแแ แแกแแแ แแแแขแแแก แฃแกแแคแ แแฎแแแแแก แคแฃแแฅแชแแแแก, แแแ แจแแ แแก RBAC แแ แฃแกแแคแ แแฎแแแแแก แแแ แแแแขแ แแแแก แกแแแฅแ แแแแแแชแแแก แจแแกแแซแแแแแแแแก แกแฎแแแแแกแฎแแ แแแแกแขแแ แแแแก แแแแแแแแแแจแ.
แฃแแฎแแแก แแแแแแ แแแ แกแแแก, Gravity 7-แก, แจแแฃแซแแแ แแแแคแแ แแแแแก Gravity แแแแแกแแฎแฃแแแแ แแ แกแแแฃแ Kubernetes แแแแกแขแแ แจแ, แแแชแแแแ แแแแกแ, แ แแ แกแฃแ แแแแแแ แกแ แฃแแแแ แแฎแแแ แแแแกแขแแ แ แแแขแ แแแแแแก. Gravity 7-แก แแกแแแ แจแแฃแซแแแ แแแฃแจแแแก Gravity แแแแแกแแฎแฃแแแแแก แแแ แแจแ แแแงแแแแแฃแ แแแแกแขแแ แแแแแ. Gravity แแกแแแ แแฎแแ แก แฃแญแแ แก SELinux-แก แแ แแฃแจแแแแก แแจแแแแแฃแ แ Teleport SSH แแแ แแแญแแ.
แแแแแแ: แแแแขแแแแแ แแแแก แแแแแ แแฃแแแ แแแขแแก แแแแกแขแแ แจแ
แแแแขแแแแแ แแก แกแฃแ แแแแแแก แฃแแแขแแกแแแ แแแแแฃแแแ แกแแกแขแแแแแแ แแแแขแแแแแ แแก แแแกแขแแก แแแ แแ. แแฃแแชแ, แแแแฏแแ แกแแญแแ แแ แกแฃแ แแแแก แจแแฅแแแ แแแแขแแแแแ แแแแก แแแกแขแแจแ, แแแแแแแแแ, แกแแแแ แแแจแแแแฃแ แแแแขแแแแแ แจแ, แแ Kubernetes แแแแกแขแแ แจแ.
แแแแแแ แแจแแแแแก แแแแขแแแแแ แแแก แแแแขแแแแแ แแก แแแ แแแแจแ, แแแแ แแ แแ แแ แแก แแแแแแแแแแฃแแ แแแแขแแแแแ แแแแชแแแก แกแแ แแแกแแ, แ แแแแ แแชแแ Docker. แแแแก แแแชแแแแ, Kaniko แแแแแฆแแแก แคแแแแฃแ แกแแกแขแแแแก แกแแแแแแกแ แกแฃแ แแแแแแ, แแฌแแ แแแแแก แงแแแแ build แแ แซแแแแแแก แแแแฎแแแ แแแแแก แกแแแ แชแแจแ, แแแแฆแแแฃแแ แคแแแแฃแ แ แกแแกแขแแแแก แแแแแ, แแแแแแฃแแ แแ แซแแแแแแก แจแแแแแ แแฆแแแก แคแแแแฃแ แ แกแแกแขแแแแก แกแฃแ แแแก.
แจแแแแจแแแ: แแแแแแ แแแแแแแ แแ แแก (2020 แฌแแแก แแแแกแ, แแแแฎแ. แแแแ แแแแแแ) แแแ แแแฌแงแแแก Windows แแแแขแแแแแ แแแก.
Kubecost: Kubernetes-แแก แแแจแแแแแก แฆแแ แแแฃแแแแแก แแแ แแแแขแ แแแ
Kubernetes-แแก แแแแแแแกแขแ แแชแแแก แแแกแขแ แฃแแแแขแแแแก แฃแแแขแแกแแแ แคแแแฃแกแแ แแแฃแแแ แแแแแงแแแแแแก แแแ แขแแแแแแแ, แแแแแขแแ แแแแแ, แแแแจแ แฅแชแแแแก แแแแแแแแ แแ แ.แจ. แแแแ แแ แ แแช แจแแแฎแแแ แคแแกแก - แแแแแ แแแจแ แแ แแแแแแแจแ - แ แแช แแแแแแจแแ แแแฃแแแ Kubernetes-แแก แแแจแแแแแกแแแ?
แแฃแแแแแกแขแ แแแฃแจแแแแแก Kubernetes-แแก แแแ แแแแขแ แแแก แ แแแแฃแ แแ แแจแ, แ แแก แจแแแแแแแแช แแแแฆแแแ แแแแแฎแแแแฃแแ แฆแแ แแแฃแแแแแก แแแคแแ แแแชแแ แซแแ แแแแแ แฆแ แฃแแแแแแ แแ แแแแแแแ แแแจแ แแแจแแแแฃแแ แแแแกแขแแ แแแแแแ, แ แแแแแแแช แแแฉแแแแแแแ แแแคแแแ, แ แแแแแแช แแฉแแแแแแก แแแแแแฃแแ แแแแกแขแแ แแก แงแแแแแแแแฃแ แฆแแ แแแฃแแแแแก. RAM-แแก, CPU แแ แแแก, GPU แแ แแแกแแแก แฅแแแกแแกแขแแแแก แคแแกแแแ แแแงแแคแแแแ Kubernetes แแแแแแแแแขแแก แแแฎแแแแแ (แแแแขแแแแแ แ, แแแแ, แกแแ แแแกแ แแ แ.แจ.)
Kubecost แแกแแแ แแแแแขแ แแแแแก แแแแกแขแแ แฃแแ แ แแกแฃแ แกแแแแก แฆแแ แแแฃแแแแแก, แ แแแแ แแชแแ Amazon S3 แแแแแฃแแแแ, แแฃแแชแ แแก แจแแแแแคแแ แแแแแ AWS-แแ. แฆแแ แแแฃแแแแแก แแแแแชแแแแแ แจแแแซแแแแ แแแแแแแแแแก แแ แแแแแแก, แแกแ แ แแ แแฅแแแ แจแแแแซแแแแ แแแแแแงแแแแ แแแ แแแแกแขแแ แแก แฅแชแแแแก แแ แแแ แแแฃแแแ แจแแกแแชแแแแแแ.
Kubecost-แแก แแแแแงแแแแแ แฃแคแแกแแ, แกแแแแ 15 แแฆแแแแ แแฃแ แแแแแก แแแแแชแแแแแ แกแแแแแ แแกแแ แแฅแแแแแแแก. แแแแแขแแแแแ แคแฃแแฅแชแแแแแกแแแแก, แคแแกแแแ แแฌแงแแแ 199 แแแแแ แแแแ แแแแจแ 50 แแแแแซแแก แแแแแขแแ แแแแแกแแแแก.
KubeDB: แกแแแ แซแแแ แแแแแชแแแแ แแแแแก แแแจแแแแ Kubernetes-แแ
แแแแแชแแแแ แแแแแแ แแกแแแ แกแแแแแแ แ แแฃแแแ Kubernetes-แแ แแคแแฅแขแฃแ แแ แแแจแแแแ. แแฅแแแ แแแแแแ Kubernetes แแแแ แแขแแ แแแก MySQL, PostgreSQL, MongoDB แแ Redis-แแกแแแแก, แแแแ แแ แแแ แงแแแแแก แแฅแแ แแแแแแแแแแแแแ. แแกแแแ, แขแแแแฃแ แ Kubernetes แคแฃแแฅแชแแแแแก แแแแ แแแ แแแ แแแแแ แแ แฌแงแแแขแก แแแแแชแแแแ แแแแแก แกแแแชแแคแแแฃแ แแ แแแแแแแแก.
KubeDB แแแฎแแแ แแแแ แจแแฅแแแแ แแฅแแแแ Kubernetes แแแแชแฎแแแแแแแ แแแแแชแแแแ แแแแแแแก แแแ แแแแกแแแแก. แกแแ แแแแ แแ แแกแแแแแก แแแจแแแแ, แแแแแแ แแแ, แแแแแขแแ แแแแ, แกแแแแจแแขแแแ แแ แแแแแแ แแชแแฃแแ แแแแแชแแแแ แแแแแก แจแแฅแแแ แแแกแ แแแแแแแแแขแแแแ. แแแฎแแแ แแแแแแแแแกแฌแแแแ, แ แแ แคแฃแแฅแชแแแแแก แแฎแแ แแแญแแ แ แจแแแซแแแแ แแแแกแฎแแแแแแแแแแก แแแแแชแแแแ แแแแแก แแแฎแแแแแ. แแแแแแแแแ, แแแแกแขแแ แแก แจแแฅแแแ แแฃแจแแแแก PostgreSQL-แกแแแแก, แแแแ แแ แแ แ MySQL-แแกแแแแก (แฃแแแ แแ แกแแแแแก, แ แแแแ แช แกแฌแแ แแ แแฆแแแแจแแ dnbstd, แแแแฎแ. แแแแ แแแแแแ).
แแฃแแ-แแแแแฃแแ: แฅแแแกแแก แแแแแฃแแ แแฃแแแ แแแขแแแแกแแแแก
แกแขแ แแก แขแแกแขแแ แแแแก แงแแแแแแ แฃแจแแชแแแแ แแแแแแแ แแแแแแแ แจแแแแฎแแแแแแ แแแแ แแ. แแก แแ แแก แแแแ แแ Netflix-แแก Chaos Monkey-แแก แแแฆแแ, แฅแแแขแฃแ แ แกแแแแแแแ แ แแแกแขแ แฃแแแแขแ, แ แแแแแแช แจแแแแฎแแแแแ แแแจแแแก แแแ แขแฃแแแฃแ แแแแฅแแแแแก แแ แฌแแ แแแแแแก แแแแขแแแแแ แแแก, แ แแแ แแแแแแแแแ แแแก โแแแแฎแแแแแโ แฃแคแ แ แแแแซแแ แกแแกแขแแแแแแก แจแแฅแแแ. แแฃแแ-แแแแแฃแแ โ แแฃแแแ แแแขแแก แแแแกแขแแ แแแแกแแแแก แกแขแ แแก แขแแกแขแแ แแแแก แแแแแ แซแแ แแแแแ แแแแ แแแก แแแแฎแแ แชแแแแแแ. แแก แแฃแจแแแแก แจแแแแฎแแแแแแ แแแแแแแ แแ แแแแกแขแแ แจแ, แ แแแแแกแแช แแฅแแแ แแแแแจแแแแ แแ แแกแแแ แจแแแซแแแแ แแแแคแแแฃแ แแ แแแฃแแ แแงแแก แแแแกแแแแก, แ แแ แแแฃแจแแแก แแแแแ แแขแฃแ แแ แแจแ.
Kubernetes Ingress Controller AWS-แแกแแแแก
Kubernetes แฃแแ แฃแแแแแงแแคแก แแแ แ แแแขแแแ แแแแก แแแแแแกแแ แก แแ แแแแกแขแแ แฃแแ แฅแกแแแแก แกแแ แแแกแแแก แกแแ แแแกแแก แกแแจแฃแแแแแแ, แ แแแแแกแแช แแฌแแแแแ Ingress AWS แฃแแ แฃแแแแแงแแคแก แแแขแแแ แแแแก แแแแแแแแกแแแแก แคแฃแแฅแชแแแก, แแแแ แแ แแแขแแแแขแฃแ แแ แแ แแแแแจแแ แแแก แแแก Kubernetes-แแก แแแแแ แจแแกแแซแแแแแแแแแแแ. Kubernetes Ingress Controller AWS-แแกแแแแก แฎแฃแ แแแก แแ แฎแแ แแแแก.
แแก แแแขแแแแขแฃแ แแ แแแ แแแแก AWS แ แแกแฃแ แกแแแก แแแแกแขแแ แจแ แจแแแแแแแ แแแแแแฃแแ แแแแแฅแขแแกแแแแก, แฅแแแแก แแแขแแแ แแแแก แแแแแแกแแ แแแก แแฎแแแ แจแแแแกแแแแก แ แแกแฃแ แกแแแแกแแแแก แแ แฎแกแแแก แแแขแแแ แแแแก แแแแแแกแแ แแแก, แ แแแแกแแช แ แแกแฃแ แกแแแ แฌแแแจแแแแ. แแก แแงแแแแแก CloudFormation-แก, แ แแแ แฃแแ แฃแแแแแงแแก แแแแกแขแแ แแก แแแแแแแ แแแแ แแแแแแแแแแ แฃแแ. แแก แแกแแแ แแฎแแ แก แฃแญแแ แก CloudWatch Alarm-แแก แแแ แแแแขแ แแแก แแ แแแขแแแแขแฃแ แแ แแแ แแแแก แแแแกแขแแ แจแ แแแแแงแแแแแฃแ แกแฎแแ แแแแแแแขแแแก, แ แแแแ แแชแแ SSL แกแแ แแแคแแแแขแแแ แแ EC2 Auto Scaling Groups.
Kubespray: Kubernetes-แแก แแแขแแแแขแฃแ แ แแแกแขแแแแชแแ
แแฃแแแกแแ แแ แแแขแแแแขแแแแ แแแก แฌแแ แแแแแแกแแแแก แแแ Kubernetes แแแแกแขแแ แแก แแแกแขแแแแชแแแก, แขแแฅแแแแแก แกแแ แแแ แแแแ แแแงแแแแแแแแ แแแแแแ แกแแฏแแ แ แฆแ แฃแแแแแแแแ. แแก แแงแแแแแก Ansible-แก (แแแแ แแแข - แกแฃแ แแแแแกแแแแแ ) แแแแแแแแแแก แแแกแแจแแแแแ แแ แแฃแแแแแ แฃแแฆแ แแกแแ แฎแแแแแกแแฌแแแแแ แแแแกแขแแ แแก แจแแกแแฅแแแแแแ แแฅแแแแ แแ แฉแแแแแแก แฅแกแแแแก แแแแแแแขแแแแ (แ แแแแ แแชแแ Flannel, Calico แแ แกแฎแแแแ) แแฅแแแแก แแแแ แแ แฉแแฃแ แแแแฃแแแ แฃแ Linux แแแกแขแ แแแฃแชแแแแ, แ แแแแกแแช แแแแแกแขแแแแ แแแแ แแแแ แแขแฃแ แฃแ แกแแ แแแ แแแแ.
Skaffold: Iterative Development for Kubernetes
แฎแแ แแฉแ - Google-แแก แแ แ-แแ แแ แแแกแขแ แฃแแแแขแ, แ แแแแแแช แแแแแแงแแแแแ Kubernetes-แจแ CD แแแแแแแชแแแแแก แแ แแแแแแแแแกแแแแก. แ แแแแ แช แแ แแฅแแแ แจแแแขแแแ แชแแแแแแแแแก แกแแฌแงแแก แแแแจแ, skaffold แแแขแแแแขแฃแ แแ แแฆแแแแฉแแแก แแแแก, แแฌแงแแแก แแจแแแแแแแแแก แแ แแแแแ แแแแก แแ แแแคแ แแฎแแแแแ แ แแแแ แจแแชแแแแแก แจแแแแฎแแแแแจแ. Skaffold แแฃแจแแแแก แแแแแแแแ แแแแแแขแแก แแฎแแ แแก, แแแแขแแ แจแแแซแแแแ แแงแแก แแชแแ แ แแแกแขแแแแชแแแก แแ แแแแแฎแแแแแก แแ แแแแแแแแ. แแก แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แแ แกแแแฃแ CICD แแแแกแแแแแแแแแ แแ แแกแแแ แจแแฃแซแแแ แแแขแแ แคแแแกแ แแแแแแ แ แแแ แ แแแแกแขแ แฃแฅแชแแแก แฎแแแกแแฌแงแแแแแแ, แซแแ แแแแแแ Google-แแก Bazel-แแแ.
แขแแ แแแ: แฃแแแ แขแแแแกแ PaaS Kubernetes-แแ
แขแแ แแแ แแ แแก แแแแแแแชแแแก แแแแแแแแแแก แกแแกแขแแแ, แ แแแแแแช แแฌแแ แแแแแก แแแ แขแแ PaaS-แก Kubernetes-แแก แแแแแ. แแฃแแแแแแ แแ แแแแแแแแฃแ แแแแฎแแแ แแแแแแก แจแแฃแซแแแแ แแแแแแแแกแแ แแ แแแ แแแ แแแแแแแแ แกแแแฃแแ แแแแจแ แแ แกแแแฃแแ แแแแแแแชแแแแ. แแก แแแแแแแแแก แกแแฅแแแก แแ แแแแแแแแแแแกแแแแก, แ แแแแแแกแแช แแแแแแแแ แแแแแแแชแแแก แแ แแ แกแฃแ แ Kubernetes-แแแ แแ แแแก แงแแแแ แกแแ แแฃแแแกแแแ แแแแแแแแแแ.
Tilt: แแแแขแแแแแ แแก แแแแแฎแแแแแแแก แกแขแ แแแแแแ Kubernetes แแแแกแขแแ แแแจแ
TiltWindmill Engineering-แแก แแแแ แจแแแฃแจแแแแแฃแแ, แแแแแ แแแแ แชแแแแแแแแแก แกแฎแแแแแกแฎแแ Dockerfiles-แจแ แแ แจแแแแแ แแแแแแแแ แแแแแกแแแก แจแแกแแแแแแก แแแแขแแแแแ แแแก Kubernetes แแแแกแขแแ แจแ. แแ แกแแแแแแ, แแก แกแแจแฃแแแแแแก แแแซแแแแ แแแแแแฎแแแ แแฅแแแแ แฌแแ แแแแแแก แแแแกแขแแ แ แ แแแแฃแ แแ แแจแ แฃแแ แแแแ Dockerfiles-แแก แแแแแฎแแแแแ. Tilt แแจแแแแแฃแแแ แแแแกแขแแ แจแ, แฌแงแแ แแก แแแแ แแ แแก แงแแแแแคแแ แ, แ แแช แฃแแแ แจแแแชแแแแแก. แแฅแแแ แแกแแแ แจแแแแซแแแแ แแแแแแฆแแ แแแแกแขแแ แแก แฏแแแแ แแแแแแแก แกแฃแ แแแ แแ แแแแคแแฅแกแแ แแ แจแแชแแแแแก แแแ แแแแแ แแแ แแแแแ Tilt-แแแ, แ แแแ แแแฃแแแแ แแ แแฃแแแแก แฌแแแ แแแก แแแแแ แแแแก แแแแแแ.
PS แฉแแแ แแ แแแ แแฎแแ แแแแแแแงแแแแ แงแแแแ แแก แแแกแขแ แฃแแแแขแ Southbridge แแแแแแแแแแแ แฉแแแแ แชแแแแแกแแแงแแแ แ แฎแแแแแแ. แ แแแแฃแ แ แแ แแฅแขแแแแก แฌแแ แแแแแแแ แฃแแแ (แแแแแแ!) แแแแแ แแแแจแ แแคแแแแ แแแขแแแกแแฃแ แแฃแ แกแแแแ. แแฃแแแ แแแขแแก แแแแ 8 แฌแแแก 10โ2021 แแแแแ แแแแ แแ Kubernetes Mega 12โ14 แแแแแ แแแแ. แแแขแแแกแแแ, แฉแแแแช แแแแแแขแ แแแ แแคแแแแ แกแฌแแแแแก แแแแแ แแ แแแแ แแแฃแแแ แแแขแแแ แแฃแแ แแขแแแกแคแแ แ. แ แแแแ แ แแแฌแแแแแ แขแแฅแแแแแแแแแแช แแ แฃแแแ แแงแแก, แแกแแแ แแแ แฉแแแแแชแแแแแแ แชแแชแฎแแ แแแแแแแแฃแ แแแแฃแแแแแชแแแก แแ แแแแกแแแฃแแ แแแฃแ แแขแแแกแคแแ แแก, แ แแชแ แแแแแแแแแ แแแแ แแแ แแแแแแแ.
แฌแงแแ แ: www.habr.com