แตแ แฉแ แญแแตแต แ แฃแ แณแแแ แจแฅแ แ แ แตแฐแณแณแช แจแณแชแฉ แญแแต แตแแต แแแญ แแตแ แ แแ แแ แแแแฝ แญแฝแแแก-
- แณแฅแ แแแ แแ (แญแ แ แแ แญแฅ แแ แจแขแแ แแแต แ แฃแ แ แญแฅ แจแแ แแแญ แแ);
- แแแแแซ - แฐแ แแแต;
- แตแแน แฐแ แแฝแแฉ แแแตแ แแ.

แฅแแฐ แฅแแแฑ แจแแ, แแแ แแแญ แตแแฝ แจแฐแแณแฐแ แญแแแ, แฅแ แณแชแฉ แตแ แดแญแแซแ แแญแแฎแฝ แจแฐแแ แแ Helm แฐแ
แแแฑ แจแฐแ แ แ แฅแแฒแแ แฅแแดแต แแตแจแ แฅแแฐแแปแ.
- แซแแแแต แแญแ แจแจแฑแต แแซแจแ Helm แแ แแแต แฅแแฐแแ แ แ แญแฉแข แแ แ แญแแต แฝแแฎแฝ แญแแณแ แฅแ แ แตแญแแฐ-แแ แณแญ แแตแฅ แจแต แฅแแฐแแแ.
- แจแแแ แ แญแญแดแญแธแญแ แฅแแแแจแตแข แตแแฐแ แแแต แแแ แ แญแแต แแญแญแต แฅแ แแณแชแซแ แแญแ แแแตแแ แฅแแดแต แจแ แแ แฐแ แแแฑ แจแฐแ แ แ แแตแจแ แฅแแฐแแปแ แจแญแแแ แ แญแญแดแญแธแญ แณแญแจแณ แแ แแแ แ แญแฝแแแข
- แจ Helm แญแแแฝแ แฅแแแซแญ.
- แ แฃแ แจแแซแแฅแ แฅแซแ แจแแฐแแฑ แแ - แ แฒแฑ แจ Helm 3 แตแชแตแข
แ แแ
แฝแแ แแตแฅ แซแแต แแแ แแแฎแฝ แ Helm 2 แแญ แฐแแปแ แญแแแแข แญแ
แฅแตแ แ แ แแ แแ แ แแญแต แแญ แซแ แฅแ แแแแฃแตแ แ แแ แฅแจแฐแ แแแ แต แซแแ แแแฃ แฅแ แจแฐแ
แแแต แตแแถแฝแ แจแซแแ แตแชแต แแแข

แตแ แฐแแแชแแก- แ แแญแณแแฐแญ แซแฎแฎแญ (แฅ.แค.แ .)) แ 10 แแแณแต แฅแซแฐแ แแ, แญแแตแ แแแปแปแ แญแจแณแ แฅแ แฎแแดแแ แฐแแแแ . แ แแ แ แผแญแแตแณแญ แฅแแฐ แแแต แแช แแ แญแฐแซแ - แญแ แ แแแต แฅแซ แ แตแชแซแ แฅแ แจแแจแจแป แแแถแฝแ แจแแ แจแฅ แแแแแต แฃแแ แฐแ แแซแจแ แซแ แตแฅแแ แแแข แซแ แแแต แ แฆแญ แแณ แแญ แจแแแ แแ, แญแ แ แแญแตแ แจแแแ แญ แแแฎ แฅแตแจ แฅแซแ แตแจแต แแแ แแแญ แญแจแฐแณแ.
แผแญแแตแณแญ แตแแฝ แฅแ แ แแแต แฅแซแฐแ แซแ แ แแญ แฒแแ แฐแแฅแฎแแ แฐแแ แแฝ แซแแฐแแจแ แ แแแฌแฝแแฝแ แตแแแฐแฉ แแ แจแฐ แแแต แฅแ แแตแฅแตแฅ แแแฎแฝ แฅแแฒแจแฑ แแตแปแ แแแค แจแแแต แกแตแ แ แฒแแแแญ แญแแแแข แผแญแแตแณแญ แญแชแแถแแ แฅแแฒแธแฅ แแญแ แฅแแฒแแ แ แญแ แญแแฃ แแแญ แแ แตแแขแแฐแญแแซแญแ แ แแต แแแแแฝ แแแแแแญ แซแ แญแก แฅแ แ แฐแตแณ แแแต แญแฐแกแแณแแข
แแ
แญแ แจแฉแ แญแแตแต แฅแ แ (แปแญแต) แ แตแฐแณแณแช แแแข แแฐแแ แชแซแแฝแ แแฐ แจแฉแ แญแแตแต แญแแตแฐแญ แแแแฃแต แ แฃแ แจแแณแแ แฅแ แแแ แ แแ แแแแตแข

แจแฅแซแตแแ YAML แแแแซแแฝแ แจแแแ แญ แฅแ แตแแแฝ แแแแแซแแฝแ แจแแแ แจแ แแ แตแ แแแ
แซแ แฅแ แจแขแแฑแตแตแช แ แแซแจแฅ แฅแจแฐแแแแญแ แแแข
Helm แ แ แแ แแ แจแแแ แฅแ แณแแแ แแญแก แแแข
แแแ แแแ? แ แแแแต แ CNCF แตแแแฐแแแข แญแแแต แคแฐแ แตแแ แตแญแ แต แแ แฅแ แจแแฎแแญแถแฝ แฉแ แญแแตแตแฃ แแแฐdแฃ แแแแตแต แฅแ แแแฝ แแแ แฉแฃแแซ แแแข
แแแ แ แตแแแ แฅแแแณ แแแ แ แฃแ แฐแแณแ แแฎแแญแต แแ. แ แแแแช 2019 แแแแ แฅแแดแต แฐแ แแแฑ แจแฐแ แ แ แแตแจแ แฅแแณแแฅแ แแแซแต แตแแแญ แแฎแแญแฑ แ GitHub แแญ แ แแต แบแ แฎแจแฆแฝ แแ แจแแข แ แแแฆแต แแญ แจแแฑ แแตแฅ 12 แบแ แแ แฉแข
แฅแ แฐแแฝ แแแแ แญแแแแแฃ แตแแแ แฅแตแซแแ แฃแตแ แแแ แตแ แฅแแณแ แตแ แฐแ แแแฑ แแแ แญแ แ แแแข แฐแ แแแต แ แตแแแ แแ.
แจแฎแญ Helm แกแตแ แ แแญแญแฎแถแแต Azure แจแฐแฐแแ แแ แตแแแ แ แจแแแฝ แฅแ แ แฐแแจ แแแฉ แจแฐแจแแ แแฎแแญแต แแแข แจ Helm 3 Alpha 2 แ แแแ แแญ แ แแแฝ แแญ แแแแ แ แแฎแแญแฑ แแญ แ แฃแ แฅแ แฐแแฝ แฅแแณแ แญแ แแแ, แฅแ แแแแ แแแปแปแ แฅแ แแแปแปแ แแแแต แฅแ แแแ แต แ แแธแ.

แแแ แ Kubernetes แแตแฅ แ แญแซแณ แจแแฐแแ แชแซ แ แตแฐแณแฐแญ แฝแแฎแฝแ แญแแณแแข
- แจแแฐแแ แชแซ แแธแแซ. แ แแญแตแแจแต แแญ แฅแแฐ โแแแฃ แแแโ แซแ แแฐแแ แชแซ แฅแแณแ แฅแ แ แแแแแถแฝแ แซแแ แแแฃ แฅแ แ แแต แแญ แแธแ แญแแแแแข
- แฅแแแ แ แแฐแแ แชแซแแฝ แจแแตแฐแณแฐแญ แแญ แจแแแฃแแ แแตแฅแตแฅแแต แแตแฐแณแฐแญแข
- แ แแแฌแฝแ แจแฐแซแ แแญแ แจแฐแแจแ แ แแ แจแแซแแ แจแ แญแแต แกแฐแตแข แแแญ แญแแฅแแแฃ แแแแ แ แแ แตแฃ แฅแ แแแ แ แแ แซแแแ แฅแ แแแ แตแญแญแแ แฅแญแแแแฝแ แฅแ แแแฒแแฝแ แแแแฃแต แญแแญแซแแข
แฆแญแณ แแซแ แแแฝ แ แแ แแแแต แจแฐแฐแซแ แแ-แแแแญแต แฃ แแแถแแต แแญแ แแญแฆแคแต แ แแฐแ แ แจแฅแ แ แ แตแฐแณแณแช แฅแซ แแ แ แแ แแณแณแณ แ แแข แแแตแ แฃ แแจแแป แฃ แ แฐแแซแฉ แแฌแแฝ แแญ แซแ แฅแแแแฝ แฃ แแแฐแแ แชแซแแฝ แแณ แแจแ แฃ แ แแ แถแฝ แฃ แจแแ แจแต แฃแ แชแแฝ แฃ แจแแจแ แ แแ แฃ แแแฐ. Helm แญแ แแ แแ แแแแแต แฅแ แแแฐแแ แชแซแแฝ แฅแแฒแ แแ แญแแ แตแแแณแแข
แแตแฅแตแฅแแต แ แตแฐแณแฐแญ. แฅแ แฐแแณแณแญ แ แญแแต แ แแแฌแฝแแฝ แซแแแตแฃ แจแแซ แแซแแตแช แแตแจแ แซแตแแแแแข แ แฅแแถแฝ แจแแแกแต แจแแ แแแฃ แแแญ แแ แ แฅแแถแฝแ แแแแ แญ แจแซแตแแ แแแแต แแแแแ แญแฃ แแแ แจแแซแแญแ แแ แจแณแฅแ แแตแฅ แแ แแ แญแฝแแแข
แจแแฐแแ แชแซ แจแ แญแแต แแฐแต แ แตแฐแณแฐแญ - แ แฅแ แ แตแฐแซแจแต, แญแ แ แฃแ แ แตแฐแณแฝ แฅแ แซแแฐแแณ แฅแซแ แแ. แ แแ แแฐ แแแ แจแแฃแแต แแแ แแแข แจแแฐแแ แชแซแแ แจแ แญแแต แแฐแต แแจแณแฐแ แแ แจแฅแ แฅแ แจแฅแแ แฒแ แญ/แฒแฒ แฅแ แ แแแฌแฝแ แแฐแถแฝแ แแฐแแ แแซแณแญแ แแแฐแต แฅแแแแแแแข
Helm แฅแแฒแซแฐแญแ แญแแ แตแแแณแ-
- แแฐแแซแตแ แแตแฐแณแฐแญ, แจแแแแญ แฅแ แจแแปแปแซ แฝแแฐ-แแณแฅแ แซแตแฐแแแแ;
- แแแถ แแแแตแ แ แฐแณแซ แแแณ แแจแแแ;
- แแฐแแซแฉ แแแ แถแฝ แแแ แแแฝแ แญแ แแ;
- แฐแจแแช แจแแฐแแ แชแซ แแฐแปแแฝแ แซแญแ แฅแ แแแคแณแธแ แแแฝ แญแตแกแข
แ แฐแจแแชแ แแแ "แฃแตแชแแฝ" แ แแ - แ แญแแตแแ แแแ แ แแตแจแ แ แฐแฐแชแแฝ แแแญ แแซแฐแฑ แจแแฝแ แฅแ แ แ แฃแ แฅแ แฃแแญ แแแฎแฝแข แฐแฐแชแแฝ แ แฐแแฅแ แแปแ แญแฝแแ แฃ แฅแแฑ แ แฃแ แจแฐแแแ แแธแ แฅแ แจแฐแแแฐ แฅแ แแแ แ แซแตแแแแธแแแข แจแแ แแแญ แแฐแแ แญ แจแแแ แฅแแฐ แแแแ แฅแแฒแซแฐแญแแต แฅแแญแซแแแฃ แฅแ แจแแซ แแแแฃแต แแฐ แแญ แฅแแฒแจแแฉแตแข
แแแ แ แฆแตแต แแ แฝแแฐ-แแณแฆแฝ แแญ แจแฐแแ แจแฐ แแ-
- แแ แณ Repo - แแฅแญแตแ แ แแธแฃแซแ แแแ แจแแฝแ แจแแแชแซแแฝ แแแแซ แฅแ แตแญแตแญแข
- แจแ แแ แต - แแแตแ แจแแฐแแ แฉแต แฅแดแถแฝ (แฝแแแฃ แจแแฅแญ แฅแดแถแฝแฃ แแแฐ)แข
- แแแแ แแแฑแ แจแแญแแ แญแแแฝ แญแฐแ แตแฃแ, แฅแ แ แแต แแญ แแฐ แแแต แญแแแฃแ. แแแถแฝ แแณแฐแ แญแฝแแแฃ แ แแ แ แจแฐแฐแซแ แจแ แญแแต แกแฐแตแ แซแณแแแแก แ แแซแแ แต แแ แตแแฝ แฅแ แ แแปแปแซ แแแฃ แ แแแจแต แแญแ แ แแแแต แแญแข
Helm แ แญแญแดแญแธแญ
แตแแ แ แแณแฅ แฐแจแ แจแแแแ แจแแฐแ แฐแจแ แ แญแญแดแญแธแญ แซแณแซแแข

แแแ แจแฉแ แญแแตแต แแญ แจแฐแซแซแ แแแญ แแแแ แแตแณแแตแ
แข แตแแแ
แฃ แซแ แจแฉแ แญแแตแต แญแแตแฐแญ (แ แซแต แแแแ) แแตแจแ แ แแฝแแแข แจ kube-apiserver แญแแ แ แแณแ แแญ แญแแซแแข แซแ Helm แฅแ Kubeconfig แ แแ. Helm แ แแต แตแแฝ แแแตแฎแฝ แซแแฃแ, แฅแญแตแ แญแฐแแ แจแปแ, Helm CLI utility, แ แฎแแแแฐแญ, แแแถแ, แแ แแฌแ แแญ แจแฐแซแ - แ แแแแแ แแญ.
แแ แญแ แ แ แ แญแฐแแ. แแแ แฒแแญ แจแแฃแ แจแ แแแแญ แ แซแ แ แแแข แ แญแแตแฐแญ แแตแฅ แจแแแแ แแแแต แญแแญแแแค แแญ แฅแแฐแแแ แแ แ แฉแ แญแแตแต แญแแตแฐแญ แแตแฅ แซแ แแฐแแ แชแซ แแแข
แแฃแฉ แจChart Repo แ แซแ แแ แณแแฝ แซแแ แแจแแป แแแข แฆแแดแแ แแจแแป แ แแฃ แฅแ แจแ แแต แฉแฃแแซ แแญแ แแฎแแญแต แจแแ แแจแแป แแแญ แญแฝแแแข
แแตแฐแแฅแญ
Helm แ แฐแ แ แแ แ แแแฌแฝแ แแซแ แตแแแแ แจแแแ แญแแแน แฅแแดแต แฅแแฐแแแแ แฅแแญแข
- แฅแจแฐแแแญแ แแแข
Helm installแฃ แแฐ แแจแแปแ (Chart Repo) แญแตแจแฑ แฅแ แจ Helm แแ แณ แซแแแข
- แจแแแ แแแแแซ (Helm CLI) แจแตแแแ แแแ แแแแต แฅแแณแแฆแต แแแแ แจ Kubeconfig แแญ แญแแแแแข
- แญแ แแ แแจแ แจแฐแจแฐแ แ แแ แแแแแซแ แฅแแฐ แแแแจแป แ แฅแ แญแแตแฐแญ แแตแฅ แจแแแแแ แฒแแญแ แญแ แ แณแแข
- Tiller Kube-apiserverแ แ แฉแ แญแแตแต แแตแฅ แตแญแแถแฝแ แแแแธแแฃ แ แแณแแต แแแฎแฝแ (แ แแแแแตแฃ แแตแฃ แ แแแฝแฃ แแตแฅแฎแฝแฃ แแแฐ) แญแแฅแซแแข
แ แแแ แ แ แ แแแญ แจแแแ แ แญแญแดแญแธแญ แ แ แ แแแญ แแแแฅ แจแแฝแแแ แจแฅแแต แฌแญแฐแญ แแแจแต แตแแแ แฅแแแณแตแ แแแแข แฅแ แจแแซ แฅแทแ แแแ แ แ แฅแแแญแซแแ.
แจแฅแแต แฌแญแฐแญ
แจแแแแชแซแ แฅแแ แฐแซแ แแฅแฅ แแ แแฉ แแฅแต แซแแ แคแแ แญ-แฐแ แแแแข. แฅแแฐ แจแแญแแแฅแฉ แ แซแแฃ แญแ แจ Helm CLI แจแ แตแฐแณแณแช แแณแจแป แซแแ แ แแ แแแข
แซแแฐแแแฐ แจแคแแ แญ แฐแ แแ แ แ แ แซแขแซ แจแแแ แจแแ แ แฐแ แแซแตแจแตแ แญแฝแแ. แฅแแฐแแ แ แญแแต แฐแ แแ แจแฐแแจ แ แแต แญแแจแแ, แแแณแ, แ Kubeconfig แ แแฅแฎแฝ แแตแฅ แ แ แแต แญแแตแฐแญ แตแ แฆแณ แแตแฐแซแจแ แญแฝแแ.
แ แฃแ แจแแซแตแฐแตแต แจแฅแแต แฌแญแฐแญ แ แฒแแญ แ แ แซแขแซ แ แแแ แญแแตแฐแญ แแตแฅ แจแแแญ แฅแ แแฐแญแตแ แต แจแแฝแ แแฐแต แแแ แญแฝแแแข แญแ แจแญแแตแฐแญแ แ แแณแจแแจแฅ แ แซแฃแข แจแแซแญ แจแตแญ แ แแแแญ แแญแ แแญแญแฎ แฐแญแชแต แแแ แญแฝแแแข
แแจแต แซแแฃ แแ แจแแ แแฐ แแ แฐแแณแ แแต แซแแ แจแฅแแต แแฉแแต Chart Repoแ แซแซแตแณแแข แ แแญแณแแ แฐแซแฒ แจแฐแแ แจ แแ แณ แฐแ แแแฑ แซแแฐแ แ แ แแฅแถแฝแ แแญแ แญแฝแแแฃ แฅแ แฅแฑแ แ แฅแแแต แ แแซแ แซแ แแ แแตแข แแญแ แจแฆแแดแแแ แจแแจแ แแต แซแแจแฑแตแ แแ แณ แแฐแซ แฅแ แแแณแ แ แแแฒ แแแญ แแแญ แแแ แญ แฅแ แฐแฐแซแฝแแฑแ แแซแณแตแ แญแฝแแแข

แจแฅแแแ
แแ แ แซแต แแแฝ แจแแแกแตแ แฅแแถแฝ แแแจแแจแ แฅแแแญแญ แฅแ แ แแแ แ แญแญแดแญแธแญ แแตแฅ แฝแแฎแฝ แจแต แฅแแณแ แฅแ แแแแฃแตแ แแแ แจแแแ แต แฆแณ แฅแแแญแญแข
แตแแแ แฅแแฐแแ แฃ แฐแจแแช แ แซแแตแ แฅแแจแแญ แฃ แแ แแแแ แแฐแจแณแ แ แซแแต แฅแแตแแแฅแข

Helm CLI แจChart Repo แแญ แญแแแแ, แจ Kubeconfig แแญ แญแแแแ แฅแ แตแซแ แแฐ แญแแตแฐแญ แแฐ แฒแแญ แ แซแ แญแฐแแแแ.
แฒแแญ แ แแแต แแแฎแฝ แญแแจแแแก-
- Tiller-deploy svc, แญแ แ แจแฐแแฐแ แ แแแแแต แจแแซแแแฅ;
- Tiller-deploy pod (แ แฒแซแแซแ แแตแฅ แ แ แแต แ แ แแตแฅ แ แ แแต แ แ), แแแ แญแแต แจแแฐแซแ แต, แญแ แ แญแแตแฐแญ แญแฐแญแณแ.
แจแฐแแซแฉ แแฎแถแฎแแฝ แฅแ แฅแ แถแฝ แแแแแแต แฅแ แ แแญ แญแแแ. แจแฐแ แแแต แฅแญแณ แ แแแญ แฅแ แ แฃแ แแแแต แ แแแก-
- Helm CLI แแฐ แแ แณ repo แจแแฐแญแตแ แต แแด: แแ แแฎแถแฎแ, แแจแแแซ แ แ แฅแ แแ แแตแจแ แฅแแฐแแปแ.
- Helm CLI, kubectl แ แ แแ แแ, แจแฒแแญ แแญ แจแแแแแ แต แแฎแถแฎแ. แญแ แ แญแแตแฐแญ แแตแฅ แจแฐแซแ แจ RPC แ แแแแญ แแแข
- แฒแแญ แฅแซแฑ แ แญแแตแฐแญ แแตแฅ แแแแฉ แฅแ แจแฉแค-แ แแฐแญแจแญ แแญ แแแแแ แแญแญแฎ แ แแแแแถแฝ แฐแฐแซแฝ แแแข

แฅแแแ
แ แแ แฆแณแแฝ แ แ
แฐแ แฐแจแฐแ แฅแแแซแญ.
แ แญ.แข.แฒ
RBAC แซแแแ แ แตแฐแแญ แตแ Helm แแญแ แ แญแแตแฐแญ แแตแฅ แตแแแ แตแแแแแแ แ แแแแแต แฐแ แแแต แแแซแต แแแ แแญแณ แจแแแแข
แญแ แจแ แญแฅ แแ แแญแญ แ แญแฐแแ แจแแแตแแ แแแญ แแ แฅแ แฐแแฝ แ แแแ RBACแ แ แแญแต แแตแฅ แฅแแณแ แฅแแณแแแแต แฅแญแแ แ แแ แแญแแซแฑแ แฅแ แแญแแญ แตแแแ แฅแ แฅแ แแแฎแฝแ แแแแญ แซแตแแแแแข แญแแ แฅแแ แญแ แ แฅแแตแณแฐแญแ แฅแแญแซแฝแแแ.

- แจแตแญ แฃแขแซ แ แ แ แRBAC. RBAC แ แแแแแแต แฃ แแแ แฅแฉ แฅแแฐแแ แฅแ แ แแญแต แแตแฅ แจแฅแฑ แแญ แฅแแดแต แฅแแฐแแแฉ แจแแซแณแฉ แฅแ
แ แ แฃแ แฅแ แ แตแฐแณแฝ แแณแแถแฝแ แญแญแแแข
แฒแแญ แฅแ แ แญแขแคแฒ แฅแแดแต แฅแแฐแแ แฉ แแแตแจแณแต แฅแแญแซแแแข แฒแแญ แ แ แแต แจแฐแแฐแ แจแ แแแแแต แแแซ แตแญ แ แญแแตแฐแญ แแตแฅ แญแฐแซแแข แ แฐแแแถแฃ RBAC แซแแฐแแแจ แญแ แจแ แแญ แฐแ แแ แญแแแแข แ แแ แจแณแ แแ แญ, แฒแแญ แ แตแฐแณแณแช แญแแแ. แแแ แแ แฅแ แแ แฒแแญ แแฐ แญแแตแฐแญแ SSH แแป แแ แจแแฃแแแข แ แฅแญแแฅ แญแ แฅแแแต แแแฃแตแแแ แจแแญ แฃแแ แฅแแ แแญ แซแแ แแฃแช แจแ แแแแแต แแแซ แญแแ แจแฐแแจ แแฉ แจแ แแแแแต แแแซ แแ แแ แญแฝแแแข
Helm แ แฒแซแตแแแฉ แฅแ แ แ แแแแฉ แแญ แแแแแชแซ แแ แฒแญแแต แจแ แแแแแฑแ แแแซ แ แแ แแ แแแแญ แญแฝแแแข --service-account. แญแ
แขแซแแต แจแแแแแแ แจแแฅแถแฝ แตแฅแตแฅ แฐแ แแ แฅแแตแตแ แแ แญแแ
แตแแแแข แฅแแแต แแ แฃ แฅแแฐแแ
แซแ โแแญแแแตโ แแแ แญ แ แแฅแแต-Role แฅแ RoleBindingแข

แฅแแฐ แ แแแณแฐแ แแ Helm แแฅแญแตแ แญแ
แ แ แซแฐแญแแแข แฅแญแตแ แแญแ แจแฉแ แญแแตแต แญแแตแฐแญ แ แตแฐแณแณแช แแแแ แแแแ แแ แแแแแต-แแแซ แจแฎแแต แฅแ แฎแแขแแฒแแ แตแฅแตแฅ แแแแแต แ แแฆแตแข
แฅแซแแ แจแแแณแ - โโแ Role แฅแ ClusterRole แแซแจแ แซแแ แแฉแแต แแแตแ แแ? แแฉแแฑ ClusterRole แจแแฐแซแ แแแแ แจแตแ แฆแณแแฝ แแแฃแจแแฐแ แ Roles แฅแ RoleBindings แ แฐแแจแฃแแแฉ แจแตแ แฆแณ แฅแป แญแฐแซแแข แแแชแซแแฝแ แแ แ แแแ แญแแตแฐแญ แฅแ แแแแ แจแตแ แฆแณแแฝ แแแแญ แแญแ แแฅแซแแณแแฑ แจแตแ แฆแณ แแจแฅแป แแแแญ แญแฝแแแข
RBAC แแ แตแแ แฝแแญ แฅแแฐแแแณ แแฅแแต แฐแแข แแแข แฅแ แฐแแฝ แแแแฃ แ แแซแณแแ แแแณแฃ แฃแแฅแ แฐแจแซแญแแต แ แญแฐแแ แฅแแ แซแแญแซแ (แแฅแแต แ แญแฐแแแ)แข แฅแ แกแตแแฝ แญแแตแฐแญ แจแ แ แฅแ Helmแ แจแฐแ แแแฃแ แแฐแจแฑ แแแฒแแฝแ แแแแญ แฅแ แ แแ แแแ แแตแฅ แซแแธแแ แแณแจแป แแแฐแฅ แ แญแปแแแฃแแญแแซแฑแ แแแ แจแแฐแซแ แต แจแฐแแฐแ แจแ แแแแแต แแแซ แตแแ แ แญแแตแฐแญ แแตแฅ แซแแตแ แแแแ แแฅแถแฝ แจแฑ แตแญ แญแแฅแซแแข , แ แแณแแต แแ แ แฃแ แจแแญแแฝ. แญแ แฅแแแต แแ - แฅแแฐ แแแตแฎแฝ แแญแ แซแฑ แฃ แฅแแฐ แแฐแฑ แฃ แแแ แฒแแญ แจแฅแแแแต แ แแฐ-แแณแฅ แจแแแ.
แแแแฃ แฒแแญแ แ แญแแตแฐแญ แแตแฅ แฅแ แแ แฅแแฒแซแแฑ แจแแซแตแฝแแ แฅแฉ แแแแต แ แแข แ แแ แแญ แแแ แฝแแญ แจแแ, Tiller แ แแแ แจแตแ แฆแณ แแแแญ แญแฝแแ. แตแแแ แฃ RBACแฃ Kubeconfig แฅแแฐ แ แแต แแ แแ แฅแ แจแแฉ Helm แแณแจแปแ แแแฐแฅ แญแฝแแแข
แญแ แ แญแแตแแแข

แแแณแแฃ แแฐแแซแฉ แกแตแแฝ แ แแต แซแแธแ แแแต Kubeconfigs (แแแต แจแตแ แฆแณแแฝ) แ แแก X แกแตแ แแแแต แกแตแ แฅแ แจแ แตแฐแณแณแช แญแแตแฐแญแข แจแ แตแฐแณแณแช แญแแตแฐแญ แจแซแฑ แจแแ แฐแ แฒแแญ แ แแแฃ แฅแฑแ แ แฉแค-แฒแตแฐแ แตแ แฆแณแฃ แ แฐแแณแณแญ แจแแ แจแ แแแแแต-แแแซแข แฅแ แแแแต แกแตแ แจแฐแแจ แจแตแ แฆแณแฃ แ แแแแแถแปแธแแ แแฐ แแฉ แจแตแ แฆแณ แแฐแแซแต แญแฝแแแข
แญแ แแฐแซ แจแแฝแ แ แซแแต แแแฃ แฒแแญ แ แฃแ แแญแ แตแแแแ แฃแแตแแ แ แฅแ แ แญแแซแแข แญแ แแฃแ แแแตแแแฝ แ แแฑ แแ.
แฒแแญแ แแจแฅแป แแแแแญ แแแแต แญแฐแแ แฅแ Kubeconfig แแกแตแ แฃแแฐแแจ แแแข แแญแ แแ แซแฃแขแ แ แแต แแแ แจแฅ แแแแต แญแฐแแ แดแญ แฃ แตแดแ แแ แฃ แแฎแณแญแฝแ (แแแ แแแญ แ แฐแแณแณแญ แญแแตแฐแญ แแญ แฅแแฐแแแ แ แ แซแฃแช แแ แฃ แแ แญแ แแจแแแ แญแฝแแ)แข
แณแชแซแฝแแ แ แแแ แแฃ แจRBAC แฅแแแญแญ แฅแ แตแ ConfigMaps แฅแแแแแญแข
ConfigMaps
แแแ ConfigMapsแ แฅแแฐ แจแแแฅ แแจแแปแ แญแ แแแแข แตแ แ แญแญแดแญแธแญ แตแแแแแญ แจแตแ แขแแ แตแ แแแถแฝแฃ แแ แฎแฝแฃ แฅแ แ แแแถ แแแแแฝแฃ แแแฐ แแจแแแฝแ แจแแซแจแแฝ แจแแแฅ แแณ แ แแแ แจแแข ConfigMaps แแแ แฅแ แ แแญ แญแแแแข
แจ ConfigMaps แแแ แฝแแญ แญแณแแแ - แ แแญแ แฐแจแ แฐแ แแแณแธแ แซแแฐแ แ แ แแธแ; แแตแฅแซแแแต แซแแ แแจแ แแจแแธแต แจแแญแปแ แแ. แฅแจแฐแแแแญแ แซแแแ แจแ แแแแแฑ แ แแญ แแแต แจแแญแแฃแแ แแแญ แแ แแ, แแแณแ, แจแญแแ แแแฝ. แ แแ แ Helm แ แฃแ แฐแแแ แจแแแ แแแแต ConfigMapsแ แจแแ แแ แแฐ แแตแฅแฎแฝ แแแจแญ แแแข
แญแ แ แฃแ แแแ แแ แจแแฐแจแแ. แจแฒแแญ แ แแฅแญแ แญแฝแฉ แฅแ แแจแแปแ แแตแฅแซแ แฅแแฐแแแ แญแแแนแข แจแแซ แแฅแซแแณแแฑ แแฐแแซแต ConfigMap แณแญแแ แแตแฅแญ แญแฐแญแตแแณแแข

แแตแขแฎแฝ แฅแซแณแธแ แฅแแแณ แฝแแฐ-แแณแฅ แฅแ แ แฃแ แ แตแฐแแแ แ แญแฐแแ แฅแแ แแจแซแจแฉ แญแฝแแ. แแแ แจแฉแ แญแแตแต แแแขแแฝ แฅแซแณแธแ แญแ
แแ แฅแซแฐแจแ แแแแธแแ แแจแณแต แฐแแข แแแข แจแตแชแต 1.10 แแแฎแฃ i.e. แ แแ แแฐแแฐแ แแแฃ แขแซแแต แ แ แฐแฃแฃแญ แฐแแแฃ แแตแฅแฎแฝแ แแแจแแธแต แตแญแญแแแแ แแจแแป แแแแแต แฐแฝแแแข แกแตแ แ แแ แแตแฅแฎแฝแแฃ แจแแแฐแฅ แแต แแญแ แแแฝ แ แซแแตแ แฐแฐแซแฝแแต แ แฐแปแ แแแแต แแแฐแซแจแต แแแแถแฝแ แฅแจแฐแซ แแแข
แจแแจแแป Helmแ แแฐ แแตแฅแฎแฝ แแตแฐแแแ แจแฐแปแ แแ, แฅแ แฅแแฑ, แ แฐแซแ, แ แแแจแแแแต แจแฐแ แ แ แแธแ.
แ แฅแญแแฅ แญแแซแ แจแแแฅ แแจแแป แแฐแฅ 1 แแฃ. แฅแแ แแแ แแแฐ แConfigMaps แจแฐแจแแแ แแจแแป แญแ แแแแข แฅแ แฅแแซแ แญแ แแแตแแ แฃ แแแฐ แฐแตแแ แจแแ แจแแแฅ แแซแญ แฅแแฐแแ แ แตแ แ แแ แญแข แ Reddit แแญ แตแแแ แแณแญ แ แตแฐแณแฝ แแญแญแต แ แ แฃ แแณแแแฑ แแจแจแป แญแ แ แ แตแแ แแฃแฅ แแแแแต แแญแ แฝแแแ แแแแ แฅ แฅแแญแซแแ .
แแ แณ Repos
แแ แณแแฝ แ แฃแ แ แแ แ แซแ แฐแแแญ แแธแ แฅแ "แ แแซแจแ แซแแ แฐแ" แแแญ แแแ แญแฝแแ, แ แฐแแญ แจแ แญแฒแฎแ แแแตแ แจแแ แแ แจแแ. แ แแแแชแซ แฐแจแ, แ แคแฝแฒแฒแ แ แฉแ แตแแแแแก แแจแแปแแฝ แฅแจแฐแแแแญแ แแ.
แ แฅแญแแ แแแต Helm Repoแ แ HTTPS แแญ แแแแฅ แ แแฆแต - แญแ แ แฃแ แฅแฉแ แ แแซแญ แฅแ แญแซแฝ แแแข
แตแฉแจแต แญแตแก แจแแ แณ แแญแ แแด. แดแญแแแแ แฅแแฐ แแแแ แแแ แแ. แญแ แ GitHub แแญ แจแแ แแแต แฐแแณแณแญ แแแญ แแ, แแฐแ แ แแแ แแฝแ แจแ แแฅ แฅแ แจแแ แแแแฝ แแญ. แซแแ แฉ แฅแ แฅแญแแ แ แญแแแฃ แ แตแแแแแนแ แแแแฝ แญแแแ แฅแ แแแแ แแแญ แ แแแจแ แญแ แ แฅแญแแฅ แจแฅแญแตแ แแ แณ แแแข
แ แฐแจแแชแ, แจแแแ แฐแแ แ TLSแ แญแฐแแแ (แ แ แแแแญ-แแ HTTP แตแแต แณแญแแ แจแแซ TLS)แข แแแแแแต แจแ แแแแญ แฅแ แจแฐแแ แ แแแแฝแ แแ แแ แตแฝแแแ แข แฅแแแฑแ แแแแแญ, แจแแซ แจแแตแญแญ แแจแแถแฝแ แตแแแแแต แฅแแฐแแ แ แญแแต แแดแ แ แแ แแแ. แ แแ แจแฑแฃ - Helm Repo for Helm 2 แ แแแแแแต แแแ แแณแชแซ - แฅแแฒแแ แแฐแจแณแ แแจแแแซแ แญแฐแแแ. แจแ แแ แแน แฅแ แธแฅ แซแ แจแแ แแฐแจแณแ แแจแแแซแ แแ แแ แญแฝแแแข
แฐแฐแชแ แ แแข แ Google Cloud Storage แแญ แจแปแญแต แชแแแฝแ แฅแแฒแซแตแฐแแแฑ แจแแซแตแฝแแแข แญแ แ แฃแ แแน แแ แฃ แฅแฉ แญแฐแซแ แฅแ แฐแ แแแฑ แจแฐแ แ แ แแ แฃ แแญแแซแฑแ แแแ แจแฐแแแนแต แแดแแฝ แฅแแฐแแ แฅแ แ แแญ แญแแแแข

แคแฝแฒแฒแแคแตแ แแญแ แฒแคแแคแตแ แซแแแฃ mTLS แ แฐแ แแ แฅแ แ แฐแแแฝแ แจแ แแ แแแแแต แแฐแจแณแ แแจแแแซแ แซแแแฃ แจ Helm CLI แฅแ Chart Repo แแญ แฐแ
แแแฑ แจแฐแ แ แ แจแแแแแต แฐแญแฅ แซแแแแข
gRPC แคแแ แญ
แแฃแฉ แฅแญแแ แ แฃแ แ แตแแแ แแ - แ แญแแตแฐแญ แแตแฅ แจแแแแแ แฒแแญแ แแแ แ แ แฅแ แ แ แแต แ แฉแ แ แแแแญ แแ แฃ แ แแ แ แฉแ แฃ แฅแฑ แซแฑ แแแฝ แ แซแแตแ แฅแจแฐแจแฐ แฅแ แ แแต แฐแ แแแแฐแ แญแแญแซแแข
แ แตแแตแ แฅแแณแแฉแต แฒแแญ gRPCแ แจแแซแแแฅ แ แแแแแต แแแฃแจแแแ แฐแแ แ แ gRPC แ แฉแ แญแแฃแแข แ แแฃแชแฃ แ แฅแญแแฅ TLS แฐแฐแแญแแแข แแแ แญแ แฐแฐแจแ แ แจแซแซแช แฅแซแ แแแฃ แแแแชแซ แแญ แแแแฉแ แแแแแ แญแแตแแแข
แแแญแต แฅแ แฅแแฒแซแแ แแแ แตแฃ TLS แ gRPC แแญ แฅแแฒแซแแ แฅแแญแซแแแข
แ แฅแ แ แตแฐแซแจแต แจ mTLS แแแ แณแแฝ แ แฐแแจ แญแ แฅแแ แฐแแข แแ แฅแ แ แฃแ แ แแแ แญแจแแแแ - แจ PQI แแ แจแฐ แแแต แญแแ แฉ แฃ แจแแตแญแญ แแจแแต แญแแ แฉ แฃ แฒแแญแ แซแตแแแฉ แฃ แจแแตแญแญ แแจแแฑแ แ แแแป แแ แซแตแฐแแแแข แจแแ แ แแ แ แฐแแ แจแ แจแแตแญแญ แแจแแต แฅแ แจแแ แแแ แฅแซแตแแ แ แแ แจแฅ แแแแ แจ Helm แตแแแแฝแ แแจแแแ แญแฝแแแข

แ แแ
แแแแต แฅแซแตแแ แจแฅแ
แ แแญ แแแ แแฒแแญ แจแแแญแกแต แแแ แฅแซแแแฝ แฅแซแตแแ แญแจแแจแแ แข
แตแแแ แจแแแแแต แปแแแ แจแฒแแญ แแญ แ แจแแแ แแแฃ แตแ RBAC แฐแแซแจแ แฅแ แจ Kubernetes apiserver แแฅแถแฝแ แ แตแฐแซแญแแแแฃ แจแฅแฑ แแญ แแตแฐแแฅแญ แจแแแฅแญแ แตแ แแซ แ แแแแตแข
แจแฐแ แ แ Helm
แจแแจแจแปแแ แแตแ แฅแแแแจแต. แฐแแณแณแญ แแตแถแฝ แซแแต แฐแแณแณแญ แ แญแญแดแญแธแญ แแแข

แแแ แแแแแถแฝ แ แแ แ แฐแ
แ แ แ แจแแแด แแณแ แญแฝแแแก
- แ Chart Repo TLS แแญแ mTLS แฅแ แแฐแจแณแ auth แฅแแ แแแแ;
- mTLS แ Tiller, แฅแ แจ TLS แแญ แฅแแฐ gRPC แ แแแแแต แญแแแฃแ, แจแแตแญแญ แแจแแถแฝแ แฅแแ แแแแ;
- แญแแตแฐแญ แจRole แฅแ RoleBinding แแญ แแฉ แจแ แแแแแต แแแซ แญแ แแแแข
แญแแตแฐแฉแ แ แจแแฐแ แแแณ แ แตแ แฅแแแแแฃ แแแญ แแ แ แแต แฅแแ แฅแแฒแ แ แแก-
"แแแ แ แตแฐแแแ แแแตแ แ แแต แฅแป แแ - แจแ แ แฎแแแแฐแญแฃ แ แฎแแญแชแต แณแฅแ แแตแฅ แจแแแ แฅแ แ แแณแฐแฎแฝ แจแแ แ แ แข"
แแจแแ แแแแฃแ แญ แฅแ แ แฒแต แจแฅแแต แฌแญแฐแฎแฝแ แแแแแต แจแฐแแซแฉ แแแแถแฝ แ แแข แญแแ แฅแแ แฅแแแ แแญแฎแฝ แแฐแ แแแต แแฐแจแณแ แจแขแแฑแตแตแช แฐแจแแ แฅแแฐแแซแแ แฅแญแแ แ แแ.
แแญแป
แญแ แญแแ แจแฐแ แแแต แแญ แ แแฅแณ แจแฐแแแ แ แญแฐแแ, แแ แ แแแ แญแแแ. แฅแแต แฐแแฝ แจแแซแแแตแ แ แแณแแต แ แตแฐแณแฝ แแแฎแฝแ แ แณแญแแแแข แแแณแ, แแ แณแแฝแ แฅแแดแต แแแแ แฅแแฐแแปแ - แฆแแดแแ แฅแ แแฐแ แ แซแแแ.
แ แแ แซแแแซแ แแตแฅ แ แแ แแฐ 300 แจแแ แ แแ แณแแฝ แฅแ แแแต แฅแจแถแฝ แ แแก แจแฐแจแแ แฅแ แขแแฉแคแฐแญแข แ แตแฐแแฝแ แจแแซแฐแญแ แฐแ แจแขแแฉแฃแฐแญ แแฐ แแจแแแต แแ แซแ แ แจแฃแต แฅแแฐแแ แฅแ แจแจแ แแแฅแจแญ แแ แซแ แ แแแ แฅแแฐแแ แ แแ แ แซแแแแข แแแ แญแ แแแฎแแฒแจแต แฅแ แแแแฑแต แแแแแ แแแญ แแ แณแแฝแ แแแแแ แ แฃแ แฅแฉแ แแฃแชแซ แ แญแฐแแ แฃ แ แ แแต แแแ แแญแแซแต - แฅแ แแฝแ แ แแแฝ แแแณ แแแแ แจแแฝแแ แต แแญแณแ แ แญแฐแแแข
แแ แ แแแแแต แ แ , แญแ แ แแ แณแแฝแ แแแแแต แจแ แแ แ แแบ แซแฐแญแแแ. แจแแแ แ แแญแฃ แฅแ แฐแจแแช แจแแญ แแจแแปแแฝ แฅแ แแฐ 800 แจแแ แ แแซแชแแฝ แ แแข แ แฐแจแแชแแฃ แ แแ แแญแแซแต แแ แณแแฝแแ แแฐ แแจแแแต แแแญ แซแแแแ แแจแแปแแ แแแแแต แญแฝแแแข
hub.helm.sh แญแแญแฉ แฅแ แ แฅแจแ แฅแแตแแแข แญแ แ แแแแแต แ แแแ แแฎแแญแต แตแญ แแแฃ แฅแ แฅแญแตแ แจแแต แแแต แแแข แจแแ แฅแ แแแญแ แแปแปแ แจแแแ แ UI แฅแแณแ แแ แญแจแต แญแฝแแแข
แฅแแฒแแ แตแฉแจแตแแ แแฐแแ แแแณแฅ แฅแแแแแ แจแ แแแแแต แฐแแ แคแแ แญ แแ แฐแตแ แญแแต. แ แตแธแแช แฅแ แแแฝ แซแแแ แญแแตแแ, แแแญ แแ แแแ แจแแซแแฅแแธแแ แฝแแฎแฝ แญแแณแ. แ แแแ แแณแ แแฅแซแซแข

แญแแฒแญ แแฐแแ แชแซแ แแแแต แจแแแแแแ แต แจแฉแ แญแแตแต แญแแตแฐแญ แ แ - แแญแตแแจแตแข แ แ แ แแแญ แแแ แฐแแฃแญ แจแแแฅ แแณ แซแตแแแแแข แฅแ แจแฐแแซแฉ แแแตแแแฝ แ แ, แแแณแ, แจแซแตแแ แจแแแแตแต แแ แ แแแแแต แแแแญ แญแฝแแ. แญแ
แ แฃแ แแน แ แญแฐแแ, แแแญ แแ แฅแ แฐแแฝ แซแฐแญแแณแ.
แแแฝแฃ แแญ แฅแแฐ แฅแ แ Chainstackแฃ แฅแแฐ MySQL แแญแ PostgreSQL แซแ แจแแฐแณแฐแฉ แจแแแฅ แแณแแฝแ แแ แแแแฎแปแธแ แญแ แแแแข แแแ แแ แจแแจแ แแถแปแฝแ แ แฐแแ แแตแฅ แจแแแแข
แแ แฝแแญ แฐแแ แจแก แ แแแแแณแฝแแ แจแณแณ แคแ แแญ แแแแแตแฃ แจแแแฅ แแณ แฃแแ แแแ แญแฃ แแตแญแญแแฑแ แแตแฐแแแ แฅแ แฅแแฐแแแ แแตแฐแณแฐแญ แ แแฅแแข แญแ แแ แฅแแแ แแ แ แตแญแแต แ แตแฐแณแณแชแ แแญแ แ แแแขแ แ แฅแ แญแจแแแแแข แฅแ แฅแแต แแฐแแ แชแซแแฝ แฒแแฉ แแแ แฝแแญ แ แญแแญแ. แ แฃแ แฅแ แฒแแ, แฅแแญ แซแตแแแแแณแ. แฅแแฐแแ แ แญแแต แแจแ แ แ - แฅแฑ แจแ แแแแแต แฐแแ แแแข แแแแฅ แจแฐแแ แญแแตแฐแญ แแฉ แแแแ แฅแแตแตแ แแ แฅแ แจแ แ แซแขแ แแฅแแตแ แ แฐแแ แ แฉแ แฅแแตแณแแ แญแแ แตแแแแฃ แแญ แฅแแฐ แคแแ แญ แแแข แญแ แแ แแแตแจแ, แจ Kubernetes แคแฐแ แแณแชแซแแฝแ แแ แแ แญแฝแแ.
แ แฃแ แแแ แแแข แแแณแแฃ แจแแฐแณแฐแจแ MySQL แ Azure แจแแ แจแณแ แฐแจแ แแญ (แญแ แแแแญ แญแฝแแ) แแ แจแ แญแฝแแแข แจ Azure แคแแ แญแ แ แแ แแ แจแแจแ แแฑ แญแแ แญแ แแ แแแแแต แญแแแแแข แ แแ แแตแฅ แฃแแ แแแฃแต แ แซแตแแแแแตแ, แฐแฐแชแ แแแ แฐแ แซแ แแ. แแแณแแฃ OSBA (Azure plugin) แแตแญแญแแฑแ แแฐ แ แแแแแฑ แญแแแณแ แฅแ แแแแ แซแตแฐแแแแแข แจแณแแ MySQL แแญ แแญแตแแจแตแ แแ แแ แตแฝแแแ แฃ แจแแฐแณแฐแฉ แจแแแฅ แแณแแฝแ แจแญแถ แ แแแตแฐแแแต แฅแ แ แแตแฅแ แตแ แแ แ แแแแแถแฝ แ แตแจแแ แข
แแแ แ แ แแต แ แฉแ แ แแแแแถแฝแ แแแฐแแซแต แจแแซแตแฝแ แฅแ แ แแ แ แฉแ แฐแแ แจแฐแแ แ แ แซแขแแฝแ แแฅแถแฝ แจแแ แ แฅแแฐ แแซ แญแ แซแ แแแต แฅแแฝแแแแข
แจแฅแซแตแแ แแแแ แแปแ แฅแ แญแ แ แแ แณแชแญ แ แแแฃแญ แแญ แแ แแ แญแฝแแแข แจแแซ แ แแแ แแฎแญแแฌแต แญแแแต แ แ แซแขแ แจแซแตแ แฐแฐแช แญแแญแแณแแข แญแ แ แ แซแแต แฅแแตแตแแญแฉ แฅแแญแซแแแฃ แ แฐแแญ แตแแ แฐแจแ แซแแ แฅแ แฒแชแฃ แตแดแ แแ แแญแ แ แ แแแญ แแ แจแฐ แแแต แแ แแต แฃแ แช แ แแฅแแต แแฐแแซแต แจแแตแแแ แจแแแข แญแ แแฅแญแตแ แฆแแฌแฝแแฝ แแญแ DevOps แ แญแแต แแแ แซแฐแญแแแแข
แแแ แแฐแ แฒแ แจแ แแตแฉแต แแแต แแแข helm-gcs แฐแฐแชแแแ แแ แณแแฝแ แแแจแแธแต แแแ-แฃแแฒแแฝแ (แจแแแญ แแจแแป) แฅแแตแตแ แแ แญแแ แตแแแแข

แฅแฑแ แแ แแ แแแแแญ แ แซแต แตแแแแฝแ แฅแป แซแตแแแแแณแ
- แฐแฐแชแแ แซแ;
- แ แตแแณแ;
- แ gcp แแตแฅ แจแแแแแ แแฐ แฃแแฒแ แจแแแตแฐแแ แแแแต แซแแแ;
- แฐแแ แจแฆแฝแ แ แแฐแ แ แแแแต แแฐแ.
แแ แฑ แจแแฒแ แแดแ แแแแต แฅแ แ แแญ แญแแแ. แจแแแจแแ แจแ แแแแแต แแแซแฃ แจแแแข แแแซ แแ แแ แตแฝแแแ แข แ แฃแ แแน แแ แฅแ แแแฅแซแต แแแ แแช แ แญแ แญแ แ. แแญ แฅแแฐ แฅแ, แจแฆแแต-แ แแฃ แแแตแแแ แจแแซแตแฐแแแ แจแแ, แญแ แ แฐแแญ แแตแแแฝ แกแตแแฝ แ แฃแ แแน แญแแแ.
แ แแซแฎแฝ
แแแ แจแ แแแแแต แ แตแฐแณแฐแญ แแแตแ แฅแป แ แญแฐแแแข แตแ แฅแฑ แฅแ แฅแซแแแฝ แ แ, แแแ แ แแ แถแตแฐแแ แตแชแต แ แแฅแแต แจแแณแจแ. แ แฅแญแแฅ แ แแซแฎแฝ แ แ.
แฅแแแ แแฉ แแแตแแแฝ แแแ แญแฝแแ, แแแณแ, Ksonnet แแญแ Metaparticle. แฅแ แแแแแญแณแธแ แฐแแณแณแญ แแแแแฝ แจแฅแญแตแแ แญแแฒแญ แจแแ แจแฐ แแแต แ แตแฐแณแฐแญ แแณแชแซแแฝ (แแปแแฃ แดแซแแญแแฃ แผแแฃ แแแฐ) แแ แแ แญแฝแแแข
แ แแจแจแปแ แ แแต แแแตแ แ แ , แฐแแณแ แแณแธแ แฅแจแจแแจ แแ.
แฆแแฌแฐแญ แแแแ แแณแฐแฅแ แต แจแแแฃ แจแแฐแแ แจแแแ แ แแซแญ แแแข
แ CNCF แฅแ Kubernetes แจแ แแ แฐแแแ แแ แฃ แแแญ แแ แจแแแฃแต แฅแแ แแต แ แฃแ แจแ แซแ แแแฃ แจแ แแ แแฎแแซแ แแตแจแ แฅแ แแแแซแแฝแ แ แตแแน แแแแฝ แซแตแแแแแณแแข
แฅแแฐ แจแแ แฃ แตแซแแ แซแ แจแฐแแซแฉ แฐแจแแชแแฝ แ แแข แ แญแแตแ แ แฃแ แแแ แซแฐแญแแณแ, แแแณแ, แแแจแซ แ แซแฃแขแ แแแฐแแซแต Helm แจแแแญ แฅแ แจแแตแแแญ แแฐแตแ แซแแแแ. แแญแ แฐแชแแฝ แฅแแธแแแแข
แแแ แแแญ แจแแแแ แต แแตแแ แแ แณ แญแธแแแข

แ x-แแแ แแญ แ แแแแ แแแญ แแญ แจแแแ แแฅแฅแญแ แฐแจแ แแ แฃ แ y-แแแ แแญ แจแฉแ แญแแตแต แฐแแแ
แแต แฐแจแ แแแข Helm แตแชแต 2 แแแ แแญ แจแแ แฆแณ แญแแตแแ. แ แตแชแต 3, แ แฃแ แฅแ แ แญแฐแแ, แแแญ แแ แแแฑแ แแฅแฅแญ แฅแ แจแ แแฌแ แฐแแแ
แแต แฐแจแ แฐแปแฝแแ. แ Ksonnet แฐแจแ แซแ แแแตแแแฝ แ แแแ แจแแแ 2 แซแแฑ แแธแ. แแแญ แแ แ แแ
แแแ แแตแฅ แแ แแ แฅแแณแ แแแแ
แแแแจแณแธแ แ แแ แแ. แฅแญแแฅ แแแฃ แจแแ
แจแต แ แตแฐแณแณแชแ แ แฅแญแตแ แแฅแฅแญ แตแญ แญแแแแฃ แแ แแแ แจแฉแ แญแแตแต แฐแแแ
แ แญแฐแแแข
แจแฆแแฌแฐแญ แแแแ แแแ แจแฉแ แญแแตแต แฐแแแ แแ แฅแ แ แฃแ แ แแซแแญ แฅแ แ แฅแแแ แฅแแฒแซแตแฐแณแตแฉแต แญแแ แตแแแณแ (แแ แตแ แแแขแซ แฐแจแ แซแตแณแแฑ)แข แญแแแแต แญแ Helm แ แ แแ แแ แฅแ แ แ แฃแ แฅแ แแฐแแ แชแซแแฝแ แแแธแ แจแ แแ แแจแ แญแแ แแ แแต แแฉ แแฐแแ แชแซ แฅแ แแฅแฑ แ แตแฐแณแฐแญ แแแแ แญ แฐแตแแ แแแข
แแซแแแซแแฝ แ แแแ แแแฃแ แชแซแ แ แตแแน แซแปแฝแแ, แจแตแซ แแฐแตแ แซแแแ, แแญแ แ CI/CD แงแแงแแฝ แแญ แ แญแแฝแ แญแแจแก.
แจแแแ แจแแฐแแต
แฅแฉ แแแ Helm 3 แฅแจแแฃ แแ แจแแแ 3.0.0-alpha.2 แจแ แแ แตแชแต แ แตแแตแ แฐแแแแฃ แแแญแฉแต แญแฝแแแข แฅแฑ แ แฃแ แจแฐแจแแ แแ แฃ แแ แฐแแฃแซแแแฑ แ แแแ แแตแ แแแข
แแแ Helm 3 แซแตแแแแแณแ? แ แแแแชแซ แฐแจแ, แญแ แณแชแญ แแ แจแฒแแญ แแฅแแต, แฅแแฐ แ แซแ. แญแ แฅแญแตแ แแฐแ แฒแ แฅแแฐแฐแจแฑแต แ แแต แตแแ แฅแญแแ แแ, แแญแแซแฑแ แจแฅแ แแแแ แฐแ แแแต แ แแปแญ แแแ แแแญ แแแ แแ.
Helm 2 แฒแแ แญ, แฅแฑแ แ Kubernetes 1.8 แแญแ แจแแซ แแฐแ แฅแ, แฅแ แฝแแฐ-แแณแฆแฝ แซแแ แฐแ แแ แฉ. แแแณแแฃ แจCRD แฝแแฐ-แแณแฅ แ แแ แ แแแต แฅแจแฐแฐแแ แจ แแแฃ แฅแ แแแ แแแต แฒแ แญแฒ แญแ แแแแแ แฎแฝแ แแแจแแธแต. แฐแแ แแ แฅแป แแ แแ แฅแ แจแ แแแแฉแ แญแแ แ แแแ แ แ แจแแปแ แญแแแ. แ แแ แแฐแจแตแฃ แจแแแ แฎแฝ แฅแ แจแแฅแถแฝ แแญ แแแตแซแต แคแฐแ แจแฉแ แญแแตแต แตแแแแฝแ แฐแ แแแข แญแ แตแแ แฅแญแแ แแแข
แญแณแซแ แแ แแฌแ แจ OCI แแจแแปแแฝ แตแแ (แญแแต แฎแแดแญแแญ แขแแผแฒแญ)แข แญแ แตแแ แฐแแณแฝแแต แแแฃ แฅแ Helm แ แแแแแต แจแแแแแ แแ แณแแนแ แแแแ แ แแแข แแแณแ Docker Hub แฅแ แจ OCI แฐแจแแแฝแ แจแแฐแแแ แต แแฅแฅ แแญ แฐแญแทแแข แฅแจแแแตแฉ แ แญแฐแแแฃ แแ แแแแฃแต แญแแฒแญ แถแจแญ แแจแแป แ แ แซแขแแฝ แจแแแ แแ แณแแปแธแแ แฅแแตแณแตแฐแแแต แฅแตแ แแฐแกแ แญแฝแแแข
แ แจแซแซแชแ แณแชแญ แแฅแ แแแข แจแแ แตแแ, แตแญแชแแถแฝแ แแแปแ แฅแแฐ แดแแแแแ แแฐแญ. แฅแ แจแแ แตแแ แ แตแแ แ แญแฐแแแแฃ แแ แญแ แแ แ แแ แ แแซแญ แฃแ แช แญแแแแข แญแ แแ 3 แแ แ แจแแแซแแ - แแ แ แแ แแ แ แตแแแ แ แญแแแแข แตแแแ แฃ แแ แ แแ แแ แแปแ แจแแแแแฃ Goแ แจแแแฑแฃ แจแฅแแ แแแ แซแแ แญแแแแ แฅแ go-tmplแ แแแ แญแ แแแข
แ แแจแจแปแแฃ แ แฅแญแแ แแแต แจแแฐแแ แแแญ แแ แญแข schema แฅแ แฅแ แจแแแฅ แ แญแแต แแจแแแซ. แ int แแญแ string แแญ แแแ แฐแจแแช แฝแแฎแฝ แ แญแแฉแ, แแฎแ แ แตแญแฅ แฅแ แถแฝ แแ แ แแ แ แซแตแแแแ. แญแ แแ แแแแแฝ แ แแแ แฅแแฒแแแน แจแแซแตแฝแแ แจJSONS แฅแ แต แญแแฃแแข
แ แจแแฐแ แแแณ แฅแแฐแแ แญแ แซแ แญแตแฐแต-แฐแฎแญ แแดแ. แฅแฑ แ แตแแตแ แ แ แแฐ-แแณแฅ แฐแแแฟแ. แจ Helm 3 แ แญแแซแแ แญแแแจแฑ, แฅแ แแ แซแ แ แญแตแฐแถแฝ แฅแ แแแ แแแฝ แฅแ แแแฝ แแแฎแฝ แฅแแฐแฐแจแแฉ แซแซแ, แญแ แ แ แฃแ แแแ แฅแ แ แแ แ แฉแ, แจแแฐแแซแต แแฐแถแฝแ แฅแ แแฅแแฑ แแแฝ แแแฃแ แญแ แญแจแแซแ.
Helm 3 แแแแฃ แฐแ แแแฑ แจแฐแ แ แ แฅแ แจแ แแ แ แตแฐแณแฝ แญแแแแฃ Helm 2แ แตแแแแฐแตแแ แณแญแแ Kubernetes แจแ แแ แจแแ แฅแจแแ แแแข แ แแ แแ แจแต แแแ แจ Kubernetes แฅแตแแถแฝแ แแ แแ แฅแ แ แแฉ แแญ แแฉแ แญแแตแต แฅแฉ แ แตแฐแณแณแชแแฝแ แแแ แญ แญแฝแแแข
แแแ แแแซแ แแ แแแข แ แแญแณแแฐแญ แซแฎแฎแญ แญแแแญแแณแ- แ แแตแฎ แแตแฅ แจแแแต, แจแแฐแ แฅแ แจแ แ แซแญ แแฐแถแฝ แแ แฐแต แฎแแแจแแต แฅแแฐแแซแแต แฅแแตแณแแตแแณแแ แดแแดแแ แญ 30 แฅแ แฅแ แแต 1. แ แแแ แฅแตแจ แฆแแตแต 20 แตแจแต แแตแจแ แญแฝแแแข แฅแ แ แแแตแแ แแญ แตแแแต แแแต แญแแแฉแ แจ DevOps แ แแซแจแฅ แฐแแฃแซแต.
แจแฎแแแจแแต แฌแแแฝแ แฅแ แแแแฝแ แ แแญ แญแจแฐแ ะธ .
แแแญ: hab.com
