แฒจแแแแจแแแ. แแแ แแแแ: Kubernetes-แแก แแแฆแแแ GitLab-แจแ แแแแแฎแแแแแ แแ แ-แแ แ แแ แแแแแแ แคแแฅแขแแ แแ, แ แแแแแแช แฎแแแก แฃแฌแงแแแก แแแแแแแแแก แแ แแแก. แแฃแแชแ, แแแแ แแ แแแแ, GitLab.com แแแแแแ แกแแ แแแกแแก แแแคแ แแกแขแ แฃแฅแขแฃแ แ แแจแแแแ แแแ แขแฃแแแฃแ แแแแฅแแแแแแ แแ แแฎแแแแ แแแแฎแแแแแแ แแ แแ แฌแแแก แฌแแ แแแแฌแงแ แแแกแ แแแแ แแชแแ K8-แจแ, แ แแแแแแช แฏแแ แแแแแ แแ แแ แแก แแแกแ แฃแแแแฃแแ. แแแฎแแ แฃแแ แแแ แ แฌแแ แแแแแแแแแแ GitLab SRE แแแแแแ แแก แแแแ แกแขแแขแแแก แแแ แแแแแ แแแแก แจแแกแแฎแแ, แแฃ แ แแแแ แฎแแแแ แแก แแ แ แ แแแกแแแแแแก แแแแแแแแ แแ แแแฅแขแจแ แแแแแฌแแแ แแแแแแ แแแ.
แแแแฎแแแแแแ แแ แแ แฌแแแแ, แฉแแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแแแงแแคแแแแแ แแฎแแ แชแแแแแแก GitLab.com-แแ แแแจแแแแฃแแ แงแแแแ แกแแ แแแกแแก แแแแ แแชแแแก Kubernetes-แแ. แแ แแ แแแก แแแแแแแแแแแจแ, แฉแแแ แจแแแฎแแแแ แแแแแฌแแแแแแก, แ แแแแแแแช แแแแแแจแแ แแแฃแแแ แแ แ แแฎแแแแ แกแแ แแแกแแแแก แแแแแขแแแแกแแแ Kubernetes-แจแ, แแ แแแแ แแแ แแแแแแแ แแแ แแแแจแ แฐแแแ แแแฃแแ แแแแแแแแแแก แแแ แแแแกแแแ. แฉแแแ แแแแ แจแแกแฌแแแแแแ แฆแแ แแแฃแแ แแแแแแแแแแแ แแแแฎแแแฃแแ แแฅแแแแ แแ แกแขแแขแแแจแ.
GitLab.com-แแก แแแแแแแแแ, แแแกแ แกแแ แแแ แแแ แฆแ แฃแแแแจแ แแฃแจแแแแแแแ แแแ แขแฃแแแฃแ แแแแฅแแแแแแ. แแก แแแ แขแฃแแแฃแ แ แแแแฅแแแแแ แแแแ แแแแ แจแแค-แแแแ แแฃแแแก แแแแ แแ แแแแแกแขแแแแ แแแฃแแแ แฉแแแแ แแแแแงแแแแแแ . แแแแแชแฎแแแแก แแแแแฎแแแแแก แกแแญแแ แแแแแก แจแแแแฎแแแแแจแ, แจแแแแแแ แกแแ แแแ แแก แคแแแขแแก แฃแแ แแแแ แแแแแฎแแแแ แแแแ แแแแแ แแแฃแแ, แแแแแแแแแแ แฃแแ แแแแ CI แแแแกแแแแแแก แแแแแงแแแแแแ. แแก แแแแแแ - แแฃแแชแ แแแแ แแ แชแแขแ - แฃแแ แฃแแแแแงแแคแก, แ แแ GitLab.com แแงแแแแแก แแแแแ แแแกแขแแแแชแแแกแ แแ แแแแคแแแฃแ แแชแแแก แแ แแฅแขแแแแก, แ แแแแ แช แแคแแแแ แแแแฎแแแ แแแแแแก (แแแแแแแ แแฃแแ) GitLab-แแก แแแกแขแแแแชแแแแ แแแแกแแแแก แฉแแแแ Linux แแแแแขแแแแก แแแแแงแแแแแแ.
แฉแแแ แแแงแแแแแ แแ แแแแแแก, แ แแแแแ แซแแแแ แแแแจแแแแแแแแแแ แแแแแชแแแแ แงแแแแ แแก แแฌแฃแฎแแ แแแ แแ แกแแฎแแ แฃแแ, แ แแกแแช แกแแแแแแแแแแแก แ แแแแแ แฌแแแ แแแ แแแแแชแแแแ GitLab-แแก แแแแ แแกแแแแแก แแแกแขแแแแชแแแกแ แแ แแแแคแแแฃแ แแชแแแกแแก. แแก แแแแแแแ แแแ แแแแฃแแ แแแ แแแแแก แแแแแแแแแแแจแ แแแ แแแ แแฃแจแแแแแ, แแแแ แแ แ แแแแกแแช GitLab-แแ แแ แแแฅแขแแแแก แ แแแแแแแแแ 10 แแแแแแแก แแแแแแญแแ แแ, แแแแฎแแแแ, แ แแ แแก แแฆแแ แแแแแงแแคแแแแแก แฉแแแแก แกแแญแแ แแแแแแก แแแกแจแขแแแแ แแแแกแ แแ แแแแแ แแแแก แจแแกแแฎแแ.
แแแ แแแแ แแแแแฏแแแ Kubernetes-แแกแ แแ แฆแ แฃแแแแแแแ GitLab-แแกแแแ
แแ แแแฅแขแ 2017 แฌแแแก แจแแแฅแแแ แแแแแแแแแก GitLab แฆแ แฃแแแแแแแ แแแแแแแแแแกแแแแก แแ แแแแฎแแแ แแแแแแก แกแแจแฃแแแแแ แแแกแชแแก แแแแแแกแขแแแแ แแ GitLab Kubernetes แแแแกแขแแ แแแแ. แแแจแแ แฉแแแ แแแชแแแแ, แ แแ GitLab-แแก Kubernetes-แแ แแแแแขแแแ แแแแ แแแแ SaaS แแแแขแคแแ แแแก แแแกแจแขแแแฃแ แแแแก, แแแแแแ แขแแแแแก แแแแแแแแแแก แแ แแแแฃแแฏแแแแกแแแก แแแแแแแแแแ แ แแกแฃแ แกแแแแก แแคแแฅแขแฃแ แแแแก. แแแแแแ แแฃแแแ, แฉแแแแ แแแแแแแชแแแก แแ แแแแแ แคแฃแแฅแชแแ แแแแแแแแแแฃแแ แแงแ แแแแแแขแแแแแฃแ NFS แขแแฎแ แแแแ, แ แแแแช แจแแแแแแ แแแแแกแแแ แแแ แขแฃแแแฃแ แ แแแแฅแแแแแแแแ.
แฆแ แฃแแแแแแแ แแ Kubernetes-แแกแแแ แกแฌแ แแคแแแ แกแแจแฃแแแแแ แแแกแชแ แฉแแแแก แแแแแแแ แแแก แแแแแแแแแ แแขแแแแแ แแแ แแแแแกแแแ, แ แแแแแก แแ แแกแแช แฉแแแ แแแแแขแแแแ แแแแแแแชแแแก แแแแแแ แแ แแแแแแแแแแฃแแแแ แฅแกแแแแก แกแแชแแแแ แแ แแแแแแแ แซแแ แแฎแแแ แคแฃแแฅแชแแแแแก แจแแแฃแจแแแแแ. แแแก แจแแแแแ, แ แแช แฉแแแ แแแแแฌแงแแ แแแแ แแชแแแก แแแแแแแแ 2019 แฌแแแก แแแคแฎแฃแแจแ, แแ แจแแแฆแฃแแแแแแแแ แแแแ แ แแแแแแ แแ แแ GitLab.com-แแก Kubernetes-แจแ แแแแ แแชแแแก แแ แแชแแกแ แแฎแแ แแแ แแแ แแแแแแแแ แแแแก!
GitLab.com-แแก แแแฎแแกแแแแแแแแแ Kubernetes-แจแ
GitLab.com-แแกแแแแก แฉแแแ แแแงแแแแแ แแ แ แ แแแแแแฃแ GKE แแแแกแขแแ แก, แ แแแแแแช แแแ แแแแก แแแแแแแชแแแก แงแแแแ แขแ แแคแแแก. แแแแ แแชแแแก (แฃแแแ แ แแฃแแ) แกแแ แแฃแแแก แจแแกแแแชแแ แแแแแ, แฉแแแ แงแฃแ แแแฆแแแแก แแแแแฎแแแแแแ แกแแ แแแกแแแแ, แ แแแแแแแช แแ แแงแ แแแแแ แแแแแแแแ แแ แแแฎแกแแแ แแแแก แแ NFS-แก. GitLab.com แแงแแแแแก แฃแแแ แแขแแกแแ แแแแแแแแฃแ Rails แแแแแแแก แแแแแก แแ แฉแแแ แแแขแแ แแแ แขแ แแคแแแก แกแแแฃแจแแ แแแขแแแ แแแแก แแแฎแแกแแแแแแแแแแก แแแฎแแแแแ แกแฎแแแแแกแฎแแ แกแแแแแแ แฌแแ แขแแแแแแ, แ แแแแแแแช แแแแแแ แแแฃแแแ แกแแแฃแแแ แแแแแซแแแจแ.
แคแ แแแขแแแขแแก แจแแแแฎแแแแแจแ, แแก แขแแแแแ แแงแแคแ แแแแฎแแแแแแแ แแแ, API, Git SSH/HTTPS แแ Registry. Backend-แแก แจแแแแฎแแแแแจแ, แฉแแแ แแแแแฌแแแแแ แ แแแจแ แแ แกแแแฃแ แกแแแฃแจแแแแแก แกแฎแแแแแกแฎแแ แแแฎแแกแแแแแแแแแแก แแแฎแแแแแ, แแแแก แแแฎแแแแแ , แ แแแแแแช แกแแจแฃแแแแแแก แแแแซแแแแก แแแแแงแแแแ แกแแ แแแกแแก แแแแแก แแแแแแแ (SLOs) แกแฎแแแแแกแฎแแ แแแขแแแ แแแแกแแแแก.
แงแแแแ แแก GitLab.com แกแแ แแแกแ แแแแคแแแฃแ แแ แแแฃแแแ GitLab Helm-แแก แจแแฃแชแแแแแ แแแแแ แแแแก แแแแแงแแแแแแ. แแแแคแแแฃแ แแชแแ แฎแแ แชแแแแแแแ แฅแแแกแฅแแแแแจแ, แ แแแแแแ แแ แฉแแแแ แฉแแ แแแ แจแแกแแซแแแแแแแ, แ แแแแกแแช แฉแแแ แแแแแแแแแแแแ แแแแแแแขแแแ แกแแ แแแกแแแก แแแแกแขแแ แจแ. แแแฃแฎแแแแแแ แแแแกแ, แ แแ แฉแแแ แแแแแแฌแงแแแขแแ, แ แแ แแ แฉแแแ แแแ แฉแแแแ แแแแแแ แแ แกแแฎแแแแฌแแคแ แกแแ แแแกแ แแแแ แแชแแแจแ, แ แแแแ แแชแแ Redis, Postgres, GitLab Pages แแ Gitaly, Kubernetes-แแก แแแแแงแแแแแ แกแแจแฃแแแแแแก แแแแซแแแแก แ แแแแแแแฃแ แแ แจแแแแแชแแ แแ VM-แแแแก แ แแแแแแแแ, แ แแแแแแกแแช แจแแค แแแแแแแ แแแ แแแแก.
Kubernetes แแแแคแแแฃแ แแชแแแก แฎแแแแแแแแ แแ แแแ แแแ
แงแแแแ แแแ แแแแขแ แก แแแ แแแแก แแแแแ GitLab. แแแแกแแแแแก แแแแแแงแแแแแ แกแแแ แแแแคแแแฃแ แแชแแแก แแ แแแฅแขแ, แ แแแแแแช แแแคแฃแซแแแแฃแแแ Terraform-แกแ แแ Helm-แแ. แฉแแแ แแชแแแแแแ แแแแแแแงแแแแ แแแแแ GitLab, แ แแแแกแแช แแก แจแแกแแซแแแแแแแ, GitLab-แแก แแแกแแจแแแแแ, แแแแ แแ แแแแ แแขแแฃแแ แแแแชแแแแแ แแแแฅแแก แชแแแแ GitLab แแแกแขแแแแชแแ. แแก แกแแญแแ แแ แแแแก แฃแแ แฃแแแแแกแแงแแคแแ, แ แแ แแฅแแแ แแ แฎแแ แ แแแแแแแแแแฃแแ GitLab.com-แแก แฎแแแแแกแแฌแแแแแแแแแ GitLab.com-แแก แแแแแแแแแแกแ แแ แแแแแฎแแแแแแแก แจแแกแ แฃแแแแแกแแก.
แแแฃแฎแแแแแแ แแแแกแ, แ แแ แฉแแแแ แแแแกแแแแแแแ Kubernetes แแแแกแขแแ แแกแแแแก แแฃแจแแแแก แชแแแแ GitLab แแแกแขแแแแชแแแแ, แแ แแก แแแแแแแก แกแแชแแแแแแก แกแแ แแแแแ, แ แแแแแแแช แกแแฏแแ แแ แฎแแแแแกแแฌแแแแแแ แจแแแแแ แแแกแแแแ แแแแแ:
- โ GitLab.com-แแก แแแแคแแแฃแ แแชแแแก แฉแแ แฉแ GitLab Helm แแแแแ แแแแกแแแแก;
- - แจแแแชแแแก แกแแ แแแกแแแแก แแแแคแแแฃแ แแชแแแก, แ แแแแแแแช แแแ แแแแแ แแ แแ แแก แแแแแแจแแ แแแฃแแ GitLab แแแแแแแชแแแกแแแ. แแก แแแแชแแแก แแแแคแแแฃแ แแชแแแก แแแแแแแแกแ แแ แแแแกแขแแ แฃแแ แแแแแขแแ แแแแแกแแแแก, แแกแแแ แแแขแแแ แแ แแแฃแ แแแกแขแ แฃแแแแขแแแก, แ แแแแ แแชแแ PlantUML;
- โ Terraform แแแแคแแแฃแ แแชแแ Kubernetes-แแกแแแแก แแ แซแแแแ VM แแแคแ แแกแขแ แฃแฅแขแฃแ แแกแแแแก. แแฅ แแฅแแแ แแแแแแแคแแแฃแ แแ แแแ แแแแกแขแแ แแก แแแกแแจแแแแแ แกแแญแแ แ แงแแแแ แ แแกแฃแ แกแก, แแแ แจแแ แแก แแแแแ แแแแกแขแแ แก, แแแแแซแแแแก แแฃแแแแก, แกแแ แแแกแแก แแแแแ แแจแแแก แแ IP แแแกแแแแ แแแก แแแฏแแแจแแแก.
แชแแแแแแแแแแก แแแแฎแแ แชแแแแแแแกแแก แแแฉแแแแแแแ แกแแฏแแ แ แฎแแแ. แแแขแแแฃแ แ แแแแกแฎแแแแแแแก แแแฃแแแ, แ แแแแแกแแช SRE แแแแแแแแแแก แแแแกแขแแ แจแ แชแแแแแแแแแแก แจแแขแแแแแแ.
SRE-แกแแแแก แแแฃแแ แแฌแแแแก แแแขแแแฃแ แแแแกแฎแแแแแแแก GitLab-แแก แแแกแขแแแแชแแแจแ, แ แแแแแแช แแแแแแงแแแแแ แฌแแ แแแแแแกแแแแก แแ แ แแแแแแ แฌแแแแแ แจแแแฆแฃแแฃแแแ. แแก แกแแจแฃแแแแแแก แแซแแแแก แแแแแแจแ แแแแแแก แแ แกแแแแแแแแแแแก, แแแแ แแขแแฃแ แแ แแแฅแขแแ แฌแแแแแแก แแแ แแจแ (แ แแแแแแช แฆแแแ แแฎแแแแ SRE-แแแแกแแแแก), แแแฎแแ แจแแแแแแแแแแแฃแแ แแแแคแแแฃแ แแชแแแก แชแแแแแแแแแ. แกแแฏแแ แ GitLab แแแแแแแแแ แแก แแแแแกแแแแก แแแ แซแ แแแแแแแแแแ CI แแแแกแแแแแแแแก แแแแแแแแชแแแ, แฉแแแ แแแแแ แฉแฃแแแแ แแ แแแแ แกแแแฃแจแแ แแ แแชแแกแก แแ แฃแแ แฃแแแแแแงแแคแ GitLab.com-แแกแแแ แแแแแฃแแแแแแแแแแก แแแแคแแแฃแ แแชแแแก แแแแแฎแแแแแกแแแแก.
แ แ แแแแแ แแแแแ แแแแ แแชแแแก แแ แแก
แแแแแแแแแแแแแก แแ แแก แแแแ แแแแ แแแแแชแแแแแแ, แ แแ แฉแแแ แแแแแแ แแแแ แแฎแแ แแแแ แแชแแแก แแ แแแแแแแแแแก Kubernetes-แจแ.
1. แแแแ แแแแ แฎแแ แฏแแแ แฎแแแแแกแแฌแแแแแแแแก แแแแแแก แจแแ แแก แแแซแ แแแแแก แแแแ
แงแแแแแแฆแแฃแ แ แแแกแแแแก แกแขแแขแแกแขแแแ (แแแแขแ แแฆแแจแ) Git แกแแชแแแแก แคแแแขแแกแแแแก GitLab.com-แแ
Google แแแแแก แฅแกแแแก แ แแแแแแแแแ แงแแคแก. แแกแแแ, แแแแแก แแฎแ แแ, แแงแแคแ แฎแแแแแกแแฌแแแแแแแแก แแแแแแแ (AZ). Git แฐแแกแขแแแแ แแแแแแจแแ แแแฃแแแ แแแแ แ แแแแแแแแแ แแแแแชแแแแแแแ, แแแแขแแ แฉแแแแแแแก แแแแจแแแแแแแแแแ แฅแกแแแแก แแแกแแแแก แแแแขแ แแแ. แจแแแ แขแ แแคแแแแกแแแแก, แแแแแกแแแ แฃแคแแกแแ แแฎแแแแ แแ แจแแแแฎแแแแแจแ, แแฃ แแก แ แฉแแแ แแแแแ แฎแแแแแกแแฌแแแแแแแแก แแแแแจแ. แแ แกแขแแขแแแก แแแฌแแ แแก แแแแแแขแแกแแแแก, แฉแแแ แแแแกแแฎแฃแ แแแแ แแแแฎแแแแแแ 100 แขแ แแแแแชแแแก แฉแแแฃแแแแ แแ แกแแแฃแจแแ แแฆแแก (แแ แแก แแฎแแแแ Git แกแแชแแแแแแกแแแแก). แกแแ แแแกแแแ, แ แแแแแแแช แชแฎแแแ แแแแแแ แแแแแ แแแ แขแฃแแแฃแ แแแแฅแแแแแจแ แฉแแแแก แซแแแ VM-แแ แแแคแฃแซแแแแฃแ แขแแแแแแแแแจแ, แแฎแแ แแฃแจแแแแก แกแฎแแแแแกแฎแแ Kubernetes-แแก แแแแแแจแ. แแก แแแจแแแแก, แ แแ แแแแแแ แแ แขแ แแคแแแ, แ แแแแแแช แแแ แ แแงแ VM-แแก แแแแแแฃแ แ, แแแขแแแชแแฃแ แแ แจแแแซแแ แแแแแแแแ แแแฃแแแงแ แฎแแแแแกแแฌแแแแแแแแก แแแแแแแก แแแ แแ.
แ แแแแแแแแฃแ แ GKE แแแแกแขแแ แแแ แกแแจแฃแแแแแแก แแแซแแแแ แแแคแแ แแ แ แแแแแแแแ แฎแแแแแกแแฌแแแแแแแแก แแแแ แแแแแแขแแแแกแแแแก. แฉแแแ แแแแแแฎแแแแแ แจแแกแแซแแแแแแแแก แกแแ แแแกแแแแกแแแแก, แ แแแแแแแช แฌแแ แแแฅแแแแแ แแแแ แแแชแฃแแแแแก แขแ แแคแแแก. แแก แจแแแแชแแ แแแก แแแกแแแแก แฎแแ แฏแแแก แแแแกแขแแ แแก แแแแแก แแแแแแขแแแแก แจแแแแ แฉแฃแแแแแกแแก.
2. แแแแแขแแแ, แ แแกแฃแ แกแแแแก แแแแฎแแแแ แแ แแแกแจแขแแแแ แแแ
แ แแแแแแแแแก แแแแฃแจแแแแแแก แฌแแ แแแแแแก แขแ แแคแแแแก แ แแแแแแแแ registry.gitlab.com-แแ. แแแซแ แแแแ แแแแก แแฆแฌแแแก ~15:00 UTC.
แฉแแแแ แแแแ แแชแแแก แแกแขแแ แแ แแแแฌแงแ 2019 แฌแแแก แแแแแกแขแแจแ, แ แแแแกแแช แฉแแแ แแแแแแแขแแแแ แฉแแแแ แแแ แแแแ แกแแ แแแกแ, GitLab Container Registry, Kubernetes-แจแ. แแก แแแกแแแก แแ แแขแแแฃแแ, แแแฆแแแ แขแ แแคแแแแก แกแแ แแแกแ แแแ แแ แแ แฉแแแแแ แแงแ แแแ แแแแ แแแแ แแชแแแกแแแแก, แ แแแแแ แแก แแ แแก แแแฅแแแแฅแแแแแก แแ แแฅแแแ แแ แแแ แแแ, แแชแแ แ แแแ แ แแแแแแแแแแฃแแแแแ. แแแ แแแแ แแ แแแแแแ, แ แแแแแแช แฉแแแ แจแแแแฎแแแ, แแงแ แแแแแซแแแแก แแแฎแกแแแ แแแแก แแแแแแแแแแก แแแแ แแแแแกแแฎแแแแฃแแ แแแแแแแก แแแแ แ แแแแแแแแ. แแแแก แแแแ แแแแแแฌแแ แแแแฎแแแแแแแกแ แแ แแแแแขแแแแก แจแแชแแแ.
แแแแ แแแ, แ แแ แแแแแแแชแแแก แจแแแแฎแแแแแจแ, แกแแแแช แแแฎแกแแแ แแแแก แแแฎแแแ แแแ แแ แแแ แแแแแแแแแแแจแ แแแ แแแแ, แแแแฎแแแแแแแก แแแแแแแ แแแแจแแแแแแแแแแ (แแแฎแกแแแ แแแแก แแแฏแแแจแแ แแแแแแฃแ แแแแแ) แแ แแแฎแแแ แแแแก "แแแแแแจแแแแแฃแ แ" แแแแชแ แ แแแแแขแ แแแแแแฌแแแ แแแฏแแ แแแแแแ. (แแแฏแแ แแแ) แแแแแซแแแ แแ แแแแแกแแฎแแแแแก แแแฆแแแ แแแแ. แแ แแ แแแแแแแก แแแกแแแแแ แแแแแ, แแก แแงแ . แแก แแแแแแกแฃแคแแแแแ แแแฌแแแแก แแแแแซแแแแแแ แแ แฃแแ แฃแแแแแงแแคแแ แแแแแซแแแก แกแแกแแชแแชแฎแแ แชแแแแ, แ แแแแแแช แแ แแฎแแแแแ แแแแแแข แแแฌแแแแก แแแแแซแแ. แแฎแแ แฉแแแ แแแฌแงแแแ แแแแ แแชแแแก แแฃแแฃแฎแแ (แแ แแแแฅแแแก แแแแแขแฃแ แ) แแแแฎแแแแแกแ แแ แแฆแแ แฃแแ แแแแจแแแแแแแแแแ, แกแแญแแ แแแแแกแแแแแ แแแกแฌแแ แแแ แแแ.
3. แแแขแ แแแ แแ แแฃแ แแแแ
แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแแแงแแคแแแแแ แงแฃแ แแแฆแแแแก แแแแฎแแแแแแก แจแแงแแแแแแแแ, แจแแชแแแแแก แกแแฎแจแแ แแแ แแ แแแงแแแแแฃแแแแ แแแฏแแ แแแแแ (SLO) แแแแแแจแแ แแแฃแแแ .
แแแกแฃแแ แฌแแแก แแแแแแแแแแแจแ, แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแแแงแแคแแแแแแจแ แแ แ-แแ แแ แแแแแแ แ แแแแแแแ แแงแ SLO-แแแแแ แแแแแขแแ แแแแแกแ แแ แแฃแจแแแแแก แแแฃแแฏแแแแกแแแ. SLO-แแแแ แกแแจแฃแแแแแ แแแแแชแแก แแแกแแฎแฃแแแงแ แแแแแแแ แแแแแแแแฃแแแฃแ แ แกแแ แแแกแแแแกแแแแก, แ แแแแแแกแแช แงแฃแ แแแฆแแแแ แแแแแแ แแแแแแแ แแแแ แแชแแแก แแ แแก. แแแแ แแ แแ แแแฃแแฏแแแแกแแแฃแแ แแแแแแ แแแแแก แแแ แแแแแจแแช แแ, แงแแแแแแแแก แแ แแ แแก แจแแกแแซแแแแแแ แแ แแแแแแแแแก แแแฃแงแแแแแแแแ แแแแแฎแแ แแแขแ แแแแกแ แแ แกแแแแแแแแแชแแแก แแแแแงแแแแแแ. แแแแแแแแแ, แแแขแแแขแฃแ แแแแแ แแ แจแแชแแแแแก แกแแฎแจแแ แแแ แคแแแฃแกแแ แแแแ, แฉแแแ แกแ แฃแแแ แแ แแคแแ แแแ แแแแ แแชแแแจแ แแงแแคแ แกแแ แแแกแแก แแแแแงแแแแแแก แงแแแแ แจแแแแฎแแแแแก.
แแก แกแแแแแฎแ แแฆแแแฉแแแแแ แแฅแแ แแแ แแแแฃแแ แแแขแแแ แแแแก แแแแกแขแแ แจแ แแแแแขแแแแกแแแแแแ. แแแแกแแแฃแแ แแแแ แแฌแแแแ แแแฎแแ, แ แแแแกแแช แฉแแแ แแแแแแฌแแ แคแฃแแฅแชแแแแแก แจแแแแฌแแแแ, แ แแแแแแแแช แแแแฎแแแแแแแก แ แแแแแแแแ แแชแแ แ แแงแ, แแแแ แแ แฐแฅแแแแแ แซแแแแแ แกแแแชแแคแแแฃแ แ แแแแคแแแฃแ แแชแแแก แแแแแแแแแแฃแแแแแแ. แแแแ แแชแแแก แแ แ-แแ แแ แแแแแแ แ แแแแแแแแแ แแงแ แแแแแขแแ แแแแแก แแ แแก แแ แ แแฎแแแแ แแแขแ แแแแก แแแแแแแแกแฌแแแแแแก แแฃแชแแแแแแแแ, แแ แแแแ แแฃแ แแแแแแ แแ "แแ แซแแแ แแฃแแ". (แแก แแ แแก แแแแฎแแแแแแ แกแฅแแแแแ - แแแแฎแ. แแแ แแแแแ.) แจแแชแแแแแแ. แแฎแแ แแแแแแฃแแ แแแแ แแชแแแกแแแแก แฉแแแ แจแแแแขแแแ แแฃแ แแแแแก แแแแฎแแแแแแแก แแแขแแแฃแ แฉแแแแแแแแแแก (แจแแแแแฎแแแแ แแฃแ แแแแจแ) แแ แแแแแแแแ แแแแคแแ แแแแ แฃแแแแแก แแ แแชแแแฃแ แแแ, แ แแแแแแแช แจแแแซแแแแ แแแแแแแแแก แแ แแ แชแแแแแแ แแแแ แแแ, แแฃ แแ แแแแแแแแ แฌแแ แแแแฅแแแแแ.
แซแแแแ VM แแแคแ แแกแขแ แฃแฅแขแฃแ แแกแ แแ แแฎแแแ Kubernetes-แแ แแแคแฃแซแแแแฃแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแแ แแแแแฃแ แแ แแแแแ แแแแฎแแแแแแแก แจแแกแ แฃแแแแ แฃแแแแแแฃแ แแแแแฌแแแแแก แฌแแ แแแแแแแแแ. แแฌแแแ-แแ-แชแแแแก แแแแ แแชแแแกแแแ แแแแกแฎแแแแแแแ (แแแแแแแชแแแแแก แกแฌแ แแคแ แแแแแขแแแ โแ แแแแ แช แแ แแกโ แแฎแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแจแ; แแแขแ แแแขแแแแก แฌแแแแแฎแแ แจแแแแซแแแแ, แแแแแแแแแ, - แแแแฎแ. แแแ แแแแแ.), "แซแแแ" VM-แแแแ แแ Kubernetes-แแ แแแ แแแแแฃแ แ แแฃแจแแแแ แแแแแฎแแแก, แ แแ แแแแแขแแ แแแแแก แฎแแแกแแฌแงแแแแ แแงแแก แแแแกแแแแแ แแ แแแ แแแ แแแแกแแแ แแ แจแแแซแแแก แแแขแ แแแแก แแแแ แแแแแแแ แแ แ แฎแแแจแ. แแแแจแแแแแแแแแแ, แ แแ แแแแแแแงแแแแ แแแแแ แแแคแแแ แแ แแฃแ แแแแแก แแแแฎแแแแแแ, แ แแแ แแแแแฆแฌแแแ แแแแแแแแแแ แฃแ แแแแแแ แแแแแก แแแ แแแแแแแ แแแ แแแแจแ.
4. แขแ แแคแแแแก แแฎแแ แแแแกแขแแ แแ แแแแแ แแแ
GitLab.com-แแกแแแแก แกแแ แแแ แแแแก แแแฌแแแ แแซแฆแแแแแ . Canary Park แแแกแแฎแฃแ แแแ แฉแแแแก แจแแแ แแ แแแฅแขแแแก แแ แแกแแแ แจแแฃแซแแแ . แแแแ แแ แแก แซแแ แแแแแแ แจแแฅแแแแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแกแ แแ แแแแแแแชแแแจแ แแแแฎแแ แชแแแแแแฃแแ แชแแแแแแแแแแก แจแแกแแแแฌแแแแแแ. แแแ แแแแ แแแแ แแแฃแแ แกแแ แแแกแ แแแแฌแงแ แจแแแฆแฃแแฃแแ แ แแแแแแแแแก แจแแแ แขแ แแคแแแแก แแแฆแแแแ แแ แฉแแแ แแแแ แซแแแแแ แแ แแแแแแแก แแแแแงแแแแแแก, แ แแแ แฃแแ แฃแแแแแงแแก SLO-แแแแก แแแแแแงแแคแแแแแ แแแแกแขแแ แจแ แแแแแ แขแ แแคแแแแก แแแแแแแแแแแ.
แแแแ แแชแแแก แจแแแแฎแแแแแจแ, แแก แแแจแแแแก, แ แแ แแแแฎแแแแแแ แจแแแ แแ แแแฅแขแแแแ แฏแแ แแแแแแแแแ Kubernetes-แจแ, แจแแแแแ แแ แแขแแแแแ แแแแ แแแแแแแแแแ แ แขแ แแคแแแแก แแแแแ แฉแแ แแแฌแแแแ แแแแกแขแแ แแ HAProxy-แแก แแแจแแแแแแ backend-แแก แฌแแแแก แจแแชแแแแ. VMโแแแ Kubernetesโแจแ แแแแ แแชแแแก แแ แแก แแแแ แแแ, แ แแ แซแแแแแ แแแแแแแแแแ แแงแ แซแแแ แแ แแฎแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แจแแ แแก แขแ แแคแแแแก แแแแแแแกแแแแ แแแแแก แแแ แขแแแ แแแ แแ, แจแแกแแแแแแกแแ, แซแแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแแแแงแแคแแ แแแแ แฃแแแแแกแแแแก แแแแ แแชแแแแแ แแแ แแแแ แ แแแแแแแแ แแฆแแก แแแแแแแแแแแจแ.
5. แฌแแแฌแแแแก แกแแ แแแแ แแ แกแแแซแแแแ แแแแ แแ แแแแ แแแแแงแแแแแ
แแแแฅแแแก แแแจแแแแ แแแแแแแแแแ แจแแแแแแ แแ แแแแแแ: แ แแแกแขแ แแก แกแแ แแแกแแก แแแแแแ แกแฌแ แแคแแ แแแแฌแงแ, แแแแ แแ Sidekiq-แแกแแแแก แแแแแแแก แแแจแแแแ แแแกแญแแ แแ . Sidekiq pod-แแแแก แแแจแแแแแก แฎแแแแ แซแแแแ แแ แ แแ แแแแแแแ แแฅแชแ, แ แแแแกแแช แแแแแฌแงแแ แกแแแฃแจแแ แแแขแแแ แแแแก แแแแ แแชแแ Kubernetes-แจแ แแ แแฃแจแแแแแแกแแแแก, แ แแแแแแกแแช แกแญแแ แแแแแแแ แกแแแฃแจแแแแแแก แกแฌแ แแคแแ แแแแฃแจแแแแแ แแ แกแฌแ แแคแแ แแแกแจแขแแแแ แแแ.
แแ แจแแแแฎแแแแแจแ, แแแแแแแแแ แแงแ แแก, แ แแ แกแแแแ Kubernetes-แแก แฐแแ แแแแแขแแแฃแ แ Pod Autoscaler (HPA) แแแ แแแ แฃแแแแแแแแแ แขแ แแคแแแแก แแ แแแก, แแแแจแแแแแแแแแแ แแแแแแแแแแกแฌแแแแ แแแขแแแ แแแแก แแแฎแแกแแแแแแแแแ แแ แแแแแแงแแ แกแแแแแแ แแแ แขแแแแแแแ แแแแแแแ (แแแแกแแแฃแแ แแแแ แแแจแแ, แ แแแแกแแช แแแแฎแแแแ แแ แแแแแแแ แแ แแแฌแแแแแแ). แฉแแแแก แจแแแแฎแแแแแจแ แแแฎแแ แกแแแฃแจแแแแแแก แฃแแชแแ แ แแแขแแแ, แ แแแแช แแแแแแฌแแแ แกแฌแ แแคแ แแแกแจแขแแแแ แแแ, แ แแแแช แแแแแแฌแแแ CPU แ แแกแฃแ แกแแแแก แแแฏแแ แแแ แแแแแ, แกแแแแ แฉแแแ แแแฅแแแแ แแ แ แแแแแซแแก แแฃแแแก แแแกแจแขแแแแ แแแ.
แงแแแแแแแแก แแ แแก แชแแฃแแแแ, แ แแช แจแแแซแแแแ แแแขแ แแแแแแแงแแแแแ แแแแกแขแแ แแแแ, แแฃแแชแ, แ แแแแกแแช แแแแแแแแ แแแแแ แจแแแฎแแแแ แจแแกแ แฃแแแแแก แแ แแแแแแแแก, แแฎแแ แแแฌแงแแแ แแแแแแจแแแแแฃแ แ pod แแแฃแฏแแขแแ แแ แแแแชแแ แแแ แแแก แแแแแแแแแแแ, แงแฃแ แแแฆแแแแ แแแแแแแแแ แแแแแก SLO-แแแก. Sidekiq-แแก แกแแ แแแกแแกแแแแก แแแแแแแก แแแจแแแแ แกแแแ แซแแแแแแ แแแฉแฅแแ แแ แแ แแฎแแ แกแแจแฃแแแแ แแแแฎแแแแแแ 40 แฌแแแ แกแญแแ แแแแ. แแแแแแ แฏแแ แ แแแแ แช GitLab.com-แแ, แแกแแแ แฉแแแแ แแแแแแแ แแแแแ แแแกแขแแแแชแแแแแก แแแแฎแแแ แแแแแแแ, แ แแแแแแแช แแฃแจแแแแแ แแคแแชแแแแฃแ GitLab Helm แฉแแ แขแแแ.
แแแกแแแแ
แแแแแแฃแแ แกแแ แแแกแแก แแแแ แแชแแแก แจแแแแแ, แฉแแแ แแแแฎแแ แแแ Kubernetes-แแก แแแแแงแแแแแ แฌแแ แแแแแแจแ: แแแแแแแชแแแแแก แฃแคแ แ แกแฌแ แแคแ แแ แฃแกแแคแ แแฎแ แแแแ แชแแแแแ, แแแกแจแขแแแแ แแแ แแ แ แแกแฃแ แกแแแแก แฃแคแ แ แแคแแฅแขแฃแ แ แแแแแฌแแแแแ. แฃแคแ แ แแแขแแช, แแแแ แแชแแแก แฃแแแ แแขแแกแแแแแ แกแชแแแแแแ GitLab.com แกแแ แแแกแก. Helm-แแก แแคแแชแแแแฃแ แ แแแแแ แแแแก แงแแแแแ แแแฃแแฏแแแแกแแแ แกแแ แแแแแแแก แแแก แแแแฎแแแ แแแแแแก.
แแแแแ แแแฅแแก แแแแแฌแแแแ แฉแแแแ Kubernetes แแแแ แแชแแแก แแแแแแแแกแแแแแแแก แแแแแแ. แฉแแแ แแแแ แซแแแแแ แงแแแแ แแฎแแแ แกแแ แแแกแแก แแแแ แแชแแแก แแแแกแขแแ แจแ. แแแแแขแแแแแ แแแคแแ แแแชแแ แจแแแแซแแแแ แแฎแแแแ แจแแแแแ แแฃแแแแแแชแแแแจแ:
- ยซ";
- ยซ";
- .
PS แแแแ แแแแแแแกแแแ
แแกแแแ แฌแแแแแแฎแแ แฉแแแแก แแแแแแ:
- ยซ";
- ยซ";
- ยซ";
- ยซ".
แฌแงแแ แ: www.habr.com