แกแแกแขแแแแกแแแ แกแ แฃแแคแแกแแแแแ แแฃแจแแแแแกแแแแก แแแแจแแแแแแแแแแ แแ แซแแแแแแก แฎแแแแก แแแแฃแแแแฃแ แ แกแแจแฃแแแแแแแแก แชแแแแ: Kubernetes-แแก แจแแแแฎแแแแแจแ แแก แแ แแก kubectl. แแแแ แแก แแฎแ แแ, แแแ แแแ แจแแแฃแจแแแแแฃแ, แแแแแ แแแฃแ แแ แแคแแแฃแ แแแขแแ แคแแแกแแแก แจแแฃแซแแแแ แจแแกแ แฃแแแแะพแฉแแแฃแแแแ แแแ แแแแชแแแแแแก แฃแแแขแแกแแแ แแ แฎแกแแแก แแแแแขแแแแ แจแแกแแซแแแแแแแแแก แกแแกแขแแแแแแก แแฃแจแแแแแกแแแแก.
แจแแ แจแแ แแแแแแแฅแแแงแแแ แแแ แแแแแ
แแแแแแแแ แฉแแแ แแแแกแแฎแฃแ แแแแ Kubernetes-แแก แแ แแแแ แแแแกแขแแ แก แกแฎแแแแแกแฎแแ แแแแแก, แฉแแแ แแกแแแ แแแแแขแแ แแกแแแฃแแ แแแ แ, แ แแ แแแแฃแแแฃแ แ แแแกแขแ แฃแแแแขแ แแแแแฌแแแแ แฉแแแแก แแแแฎแแแ แแแแแแก. แจแแกแแคแแ แแกแ แแแขแแ แคแแแกแแก แแ แฉแแแแกแแก, แฉแแแแแแแก แแแแแแ แ แแงแ แจแแแแแแ แคแฃแแฅแชแแแแ:
- แแแแฎแแแ แแแแแก แฃแคแแแแแแแก แแแคแแ แแแชแแแชแแแก แแฎแแ แแแญแแ แ (RBAC);
- แกแแฎแแแแ แกแแแ แชแแก แแแแแแแ แแแแแก แแแแฃแแแแแแชแแ แแ แกแขแแแแแ แขแฃแแ Kubernetes แแ แแแแขแแแแแ (Deployment, StatefulSet, Service, Cronjob, Job, Ingress, ConfigMap, Secret, PVC);
- แแแแแก แจแแแแแ แแ แซแแแแแแก แฎแแแแแ แฌแแแแแแก แแแฆแแแ;
- แแแแแแแก แแฃแ แแแแแแแก แแแแแแแแแ แแแ;
- แแฎแแแแ แแแแแแแแก แกแขแแขแฃแกแ (
describe status
); - แฌแแแฌแแแแก แแแชแแแแแ.
แกแฎแแ แคแฃแแฅแชแแแแ, แ แแแแ แแชแแ แแแฎแแแ แแแฃแแ แ แแกแฃแ แกแแแแก แแแฎแแ (แแแแแแแก / แแแแขแ แแแแ แแแแก / แกแแฎแแแแแแก แกแแแ แชแแก แแแแขแแฅแกแขแจแ), K8s แแ แแแแขแแแแแแก แจแแฅแแแ/แ แแแแฅแขแแ แแแ, แแ แแ แแก แ แแแแแแแขแฃแ แ แฉแแแแก แกแแแฃแจแแ แแ แแชแแกแแ.
แฉแแแ แแแแแฌแงแแแ แแแแแฎแแแแแก แแแแกแแแฃแ แ Kubernetes Dashboard-แแ, แ แแแแแแช แฉแแแแ แกแขแแแแแ แขแแ. แแแแแแแแ แแกแแคแแแ แแ แแแแก (แ แแช แแแจแแแแก, แ แแ Kubernetes-แก แกแฃแ แฃแคแ แ แแแขแ แแฎแแแ GUI แแฅแแก), แฉแแแ แแกแแแ แแแกแแฃแแ แแแ แแแก แแแแแแแแแแ แแแขแแ แแแขแแแแแแ, แกแขแแขแแแก แแแแแก แจแแแแฏแแแแแ แงแแแแแคแแ แก แจแแแแ แแแแ แชแฎแ แแแจแ.
NB: แแแแแฎแแแแแจแ, แฉแแแ แแ แแแแแแแแ แแแ แแ แแแแแฌแงแแแขแแแแแแแก, แ แแแแแแแช แฃแแแ แแแแแฎแแแแแ
1. Kubernetes Dashboard
-
แแแแฃแแแแขแแชแแแก แแแแ แแ ; -
แกแแชแแแ (8000+ GitHub แแแ แกแแแแแแ); - แแแชแแแแแ: Apache 2.0;
- แแแแแแ: โแฃแแแแแ แกแแแฃแ แ แแแ แแแขแแ แคแแแกแ Kubernetes แแแแกแขแแ แแแแกแแแแก. แแก แแแแฎแแแ แแแแแแก แกแแจแฃแแแแแแก แแซแแแแก แแแ แแแ แแ แแแแแแแ แแ แแ แแแแแแแแ แแแแกแขแแ แจแ แแแจแแแแฃแแ แแแแแแแชแแแแ, แแกแแแ แแแ แแแ แแแแแ แแแแกแขแแ แ.โ
แแก แแ แแก แแแแแแ แแแแแจแแฃแแแแแก แแแแแแ, แ แแแแแแช แแแคแแ แฃแแแ Kubernetes-แแก แแแขแแ แแแแก แแแแ แแคแแชแแแแฃแ แแแแฃแแแแขแแชแแแจแ (แแแแ แแ
Kubernetes Dashboard-แแก แแแแแแ แแแฎแแกแแแแแแแแแก แจแแ แแก:
- แแแแแแแชแแ: K8-แแแแก แซแแ แแแแแ แแแแแฅแขแแแแก แแแฎแแ แกแแฎแแแแ แกแแแ แชแแก แแแแขแแฅแกแขแจแ.
- แแฃ แแฅแแแ แแแฅแแ แแแแแแแกแขแ แแขแแ แแก แฃแคแแแแแแ, แแแแแแ แแฉแแแแแแก แแแแแซแแแก, แกแแฎแแแแ แกแแแ แชแแแแก โโแแ แแฃแแแแ แขแแแแแก. แแแแแซแแแแกแแแแก แฎแแแแแกแแฌแแแแแแ แกแขแแขแแกแขแแแ แแแฎแกแแแ แแแแก, แแ แแชแแกแแ แแก, แ แแกแฃแ แกแแแแก แแแแแฌแแแแแแก, แแแขแ แแแแก, แกแขแแขแฃแกแแก, แแแแแแแแแแก แแ แ.แจ.
- แกแแฎแแแแ แกแแแ แชแแจแ แแแแแแแแแฃแแ แแแแแแแชแแแแแก แแแฎแแ แแแแ แขแแแแก แแแฎแแแแแ (Deployment, StatefulSet แแ แ.แจ.), แแแ แจแแ แแก แฃแ แแแแ แแแแแแ (ReplicaSet, Horizontal Pod Autoscaler), แแแแแแ แแ แแแ แกแแแแแแแแแฃแแ แกแขแแขแแกแขแแแ แแ แแแคแแ แแแชแแ.
- แแฎแแแแ แกแแ แแแกแแแ แแ แจแแแแกแแแแแ, แแกแแแ แแแแ แฃแ แแแแ แแแแแแ แแแแแแแแ แแ แกแแแแแแ แฌแแ แขแแแแแแแ.
- แคแแแแแก แแแแแฅแขแแแแก แแ แกแแชแแแแแแก แแแฎแแ: แแฃแแแแแ แแแชแฃแแแแ แแ แแฃแแแแแ แแแชแฃแแแแแก แแแแฎแแแแ.
- ConfigMap แแ Secret แแแฎแแ แแ แ แแแแฅแขแแ แแแ.
- แแฃแ แแแแแแแก แแแฎแแ.
- แแ แซแแแแแแก แฎแแแแก แฌแแแแแ แแแแขแแแแแ แแแจแ.
แแแแจแแแแแแแแแ แแแแแ (แแฃแแชแ, แฉแแแแแแแก แแ แ) แแ แแก แแก, แ แแ แแ แแ แกแแแแแก แแฃแแขแแแแแกแขแแ แฃแแ แแฃแจแแแแแก แแฎแแ แแแญแแ แ. แแ แแแฅแขแ แแฅแขแแฃแ แแ แแ แแก แจแแแฃแจแแแแแฃแแ แกแแแแแแแแแแแก แแแแ แแ แแแแ แฉแฃแแแแก แจแแกแแแแแแก แคแฃแแฅแชแแแแก Kubernetes API-แแก แแฎแแแ แแแ แกแแแแแกแ แแ แกแแแชแแคแแแแชแแแแแก แแแแแจแแแแแ: แแแแแแแก แฃแแฎแแแกแ แแแ แกแแ แแ แแก
2. แแแแแฅแขแแแ
-
แกแแแขแแก ; -
แแ แแแแแขแแชแแ ; -
แกแแชแแแ (~4800 GitHub แแแ แกแแแแแแ); - แแแชแแแแแ: MIT;
- แแแแแแ: "Kubernetes IDE".
แแ แแแฅแขแ แแแแแแแแแฃแแแ, แ แแแแ แช แกแ แฃแแ แแแขแแแ แแ แแแฃแแ แแแแแแแแ แแแแก แแแ แแแ (IDE) Kubernetes-แแกแแแแก. แฃแคแ แ แแแขแแช, แแก แแแขแแแแแแ แแแฃแแแ แแแแ แแแแกแขแแ แแแ แแ แแแแจแ แแแจแแแแฃแแ แแแแ แ แแแแแแแแแก แแแแแแแแ แแฃแจแแแแแกแแแแก (แแแขแแกแขแแ แแแฃแแแ 25 แแแแแ).
แแแแแแก แซแแ แแแแแ แแแฎแแกแแแแแแแแแ/ แจแแกแแซแแแแแแแแแ:
- แแแแแฃแแแแแแแแ แแแแแแแชแแ, แ แแแแแแช แแ แกแแญแแ แแแแก แแ แแคแ แแก แแแกแขแแแแชแแแก แแแแกแขแแ แแก แจแแแแแ (แฃแคแ แ แแฃแกแขแแ, แแ แแแแแแก แแแแแฎแแแแแ แงแแแแ แแแขแ แแแแก แแแฆแแแ, แแแแ แแ แแแแกแแแแก แจแแกแแซแแแแแแแ แแแแแงแแแแแฃแแ แแฅแแแก แแ แกแแแฃแแ แแแกแขแแแแชแแแช). "แแแแแแ แ" แแแกแขแแแแชแแ แฎแแ แชแแแแแแแ แแแ แกแแแแแฃแ แแแแแแฃแขแแ แแ, แ แแแแแแช แแฃแจแแแแก Linux, macOS แแ Windows.
- แแ แแแแ แแแแกแขแแ แฃแแ แแแแแฏแแแแขแ (แแฎแแ แแแญแแ แแแแ แแกแแแแ แแแแกแขแแ แ).
- แแแกแแขแฃแ แ แแแแแแแ แแแแแก แแแแฃแแแแแแชแแ แ แแแแฃแ แแ แแจแ.
- แ แแกแฃแ แกแแแแก แแแแแงแแแแแแก แแ แแคแแแแแ แแ แขแแแแแแชแแแแ แแกแขแแ แแแ, แ แแแแแแช แแคแฃแซแแแแ แฉแแจแแแแแฃแ แแ แแแแแแก.
- แฌแแแแแ แแแแขแแแแแ แแแแก แแ แซแแแแแแก แฎแแแแ แแ แแแแกแขแแ แฃแ แแแแแซแแแแ.
- แกแ แฃแแ แแฎแแ แแแญแแ แ Kubernetes RBAC-แแกแแแแก.
แแแแแแแแ แ แแแแแจแแแแ -
Lens แแ แแก แแแแ แ แงแแแแแแ แแแแฃแแแ แฃแแ แแ แแแฅแขแ GitHub-แแ GUI-แแแ Kubernetes แแแขแแแแ แแแแแ, แ แแแแแแช โแแแ แแแแกโ แแฎแแแแ แแแแแ Kubernets Dashboard-แก. แงแแแแ แกแฎแแ แฆแแ แแแแแก แแแแแฌแงแแแขแ, แ แแแแแแช แแ แแ แแก CLI* แแแขแแแแ แแแแแ, แแแแจแแแแแแแแแ แฉแแแแ แฉแแแ แแแแฃแแแ แแแแก.
* แแฎแแแแ K9-แแแแก แจแแกแแฎแแ แแแแแฎแแแแแก แแแแฃแก แแแฌแแแจแ.
3. แแฃแแแ แแแขแแแ
-
แกแแแขแแก ; -
แแแแแแกแขแ แแชแแ ; แกแแชแแแ (แแฎแแแแ แแแแฃแแแแขแแชแแ) (200+ GitHub แแแ แกแแแแแแ);- แแแชแแแแแ: แกแแแฃแแ แแแ;
- แแแแแแ: "แแแแกแขแแ แแแแก แแแ แแแ แแแแแแแแแ."
แแก แแ แแก แกแแแฃแแ แแแแก แแ แแแ แแแ, แ แแแแแแช แแแแแกแขแแแแ แแแฃแแแ แแแ แกแแแแแฃแ แแแแแแฃแขแแ แแ (แแฎแแ แแแญแแ แแแแ Linux, macOS, Windows). แแแกแ แแแขแแ แแแ แแแแแ แแแแแแ แแ แซแแแแแแก แฎแแแแก แแแแฃแแแแฃแ แ แแ แแแ แแแแก แกแ แฃแ แฉแแแแชแแแแแแก แแ แแแกแแแ แแ แแแ - แแ แแ แแก แกแแญแแ แ แแ แซแแแแแแแแก แแแแแฎแกแแแ แแแ แแ แกแแฉแฅแแ แแก แแแฏแแ แแแแ แแแช แแ.
แฎแแแกแแฌแงแแก แแ แ-แแ แแ แกแแแแขแแ แแกแ แแแฎแแกแแแแแแแแแ Helm แกแฅแแแแแแก แฉแแจแแแแแฃแแ แแฎแแ แแแญแแ แ, แฎแแแ แแ แ-แแ แแ แแแแแ แแ แแก แแแแแแแชแแแก แจแแกแ แฃแแแแแก แแแขแ แแแแก แแแแแแแแแ.
Kubernetic-แแก แซแแ แแแแแ แแแฎแแกแแแแแแแแแ:
- แแแแกแขแแ แแก แกแขแแขแฃแกแแก แแแกแแฎแแ แฎแแแแแ แฉแแแแแแ. แแ แแ แแแ แแแ แงแแแแ แแแแแแจแแ แแแฃแแ แแแกแแขแฃแ แ แแแแแฅแขแแกแ แแ แแแแ แแแแแแแแแแฃแแแแแก แกแแแแฎแแแแ; แฌแแแแแ/แแฌแแแแ แแแแแงแแคแแแก แกแขแแขแฃแกแ แงแแแแ แแแแแฅแขแแกแแแแก; แแแกแแขแฃแ แ แกแขแแขแฃแกแแก แแแฎแแแก แ แแแแแ แ แแแแฃแ แแ แแจแ แกแขแแขแฃแกแแก แแแแแฎแแแแแ.
- แกแฌแ แแคแ แแแฅแแแแแแแก แฆแแแแแแแ แแแแแแแชแแแก แฌแแกแแจแแแแแ แแ แแแกแจแขแแแแ แแแแกแแแแก.
- แแ แแแแ แแแแกแขแแ แฃแแ แแฃแจแแแแแก แแฎแแ แแแญแแ แ.
- แแแ แขแแแ แแฃแจแแแแ แกแแฎแแแแ แกแแแ แชแแแแแแ.
- Helm แกแฅแแแแแแก แแ Helm แกแแชแแแแแแก แแฎแแ แแแญแแ แ (แแแ แจแแ แแก แแแ แซแ). แกแฅแแแแแแก แแแกแขแแแแชแแ แแ แแแ แแแ แแแ แแแขแแ แคแแแกแจแ.
แแ แแแฃแฅแขแแก แแแแแแแแแแแ แฆแแ แแแฃแแแแ แแ แแก แแ แแฏแแ แแแ แแแแแฎแแ 30 แแแ แแก แแแแแแแแ แแแกแ แแแแแงแแแแแแกแแแแก แแ แแ แแแแแแแแแก แแแแ แแแแแกแแแแ แ แ แแแแแแแแแก แกแแฎแแแแ แกแแแ แชแแกแ แแ แแแแกแขแแ แแแแกแแแแก.
4. แแฃแแแแแฃแกแ
-
แกแแแขแแก ; -
แแ แแแแแขแแชแแ ; -
แกแแชแแแ (~500 GitHub แแแ แกแแแแแแ); - แแแชแแแแแ: Apache 2.0
- แแแแแแ: "Kubevious แฎแแแก Kubernetes แแแแกแขแแ แแแก, แแแแแแแชแแแก แแแแคแแแฃแ แแชแแแก แแ แกแขแแขแฃแกแแก แงแฃแ แแแแก แฃแกแแคแ แแฎแ แแ แแแแแแแ แแแกแแแแแแ."
แแ แแแฅแขแแก แแแแแ แจแแฅแแแแก แแแกแขแ แฃแแแแขแ, แ แแแแแแช แจแแฅแแแแแแ แแแแกแขแแ แจแ แแแแแแแแแฃแแ แแแแแแแชแแแแแก แแแแคแแแฃแ แแชแแแก แแแแแแแแกแ แแ แแแแแ แแแแกแแแแก. แแแขแแ แแแแ แฃแแแ แแแแแก แงแแแแแกแ แงแฃแ แแแฆแแแ แแแแแแฎแแแแแก แแ แคแฃแแฅแชแแแแแก แแแแฎแแ แชแแแแแแแแ, แฃแคแ แ แแแแแ แกแแแแแฎแแแก แแแแแแแแแแแ แแแขแแแแก.
Kubevious-แแก แซแแ แแแแแ แแแฎแแกแแแแแแแแแ แแ แคแฃแแฅแชแแแแ:
- แแแแกแขแแ แฃแแ แแแแฃแแแแแแชแแ แแแแแแแชแแแแ แแ แแแแขแแ แแแฃแแ แแแแ: แแแขแแ แคแแแกแจแ แแแแแแจแแ แแแฃแแ แแแแแฅแขแแแ แแแฏแแฃแคแแแฃแแแ, แแแ แแ แฅแแแจแ แแแคแแ แแแแฃแแ.
- แแแแแแแแแแฃแแแแแแแก แแแแฃแแแฃแ แ แฉแแแแแแ แแแแคแแแฃแ แแชแแแแจแ แแ แแแแ แชแแแแแแแแแแก แแแกแแแแฃแ แ แจแแแแแแแ.
- แแแแกแขแแ แแก แแแแคแแแฃแ แแชแแแก แจแแชแแแแแแแก แฉแแแแแแ: แแขแแแแขแแแแก แแ แแกแฌแแ แแ แแแแแงแแแแแ, แแแแแขแแแแแฃแแ แแแ แขแแแ แแ แ.แจ. (แกแฎแแแแ แจแแ แแก, แแฃ แแแแแขแแ แแกแแแ แแก แคแฃแแฅแชแแ, แงแฃแ แแแฆแแแ แแแแฅแชแแแ
Polaris แ แแแแแก แจแแกแแฎแแแแช แฉแแแแฃแแแ แแแฌแแ แแแ .) - แฌแแแ แแฃแแฅแขแแก แแแ แแ, แจแแกแแซแแแแแแแ แแแขแแแชแแฃแ แแ แกแแจแแจแ แแแแขแแแแแ แแแแก แแฆแแแฉแแแ, แ.แ. แซแแแแแ แแแแ แ แแ แแแแแแแแแแแก แแฅแแแ (แแขแ แแแฃแขแแแ
hostPID
,hostNetwork
,hostIPC
, แแแแแdocker.sock
แแ แ.แจ). - แแแแกแขแแ แแก แแแคแแ แแแแแฃแแ แกแแซแแแแ แกแแกแขแแแ (แแ แ แแฎแแแแ แแแแแฅแขแแแแก แกแแฎแแแแแแ, แแ แแแแ แแแแ แแแแกแแแแแแ).
- แจแแกแแซแแแแแแแแแแก แแแแแแแแแกแ แแ แ แแกแฃแ แกแแแแก แแแขแแแแแแชแแแก แแแกแขแ แฃแแแแขแแแ.
- แฉแแแแแขแแแแแฃแแ โแแ แแแก แแแแฅแแแโ (แแแแแฅแขแแแแก แแแแคแแแฃแ แแชแแแก แฌแแแ แชแแแแแแแแแแก แแแฎแแแก แจแแกแแซแแแแแแแ).
- RBAC แแแแแฏแแแแขแ แ แแแแแแก, RoleBindings, ServiceAccounts-แแก แฃแ แแแแ แแแแแแแจแแ แแแฃแแ แชแฎแ แแแแ.
- แแฃแจแแแแก แแฎแแแแ แแ แ แแแแกแขแแ แแแ.
แแ แแแฅแขแก แซแแแแแ แแแแแ แแกแขแแ แแ แแฅแแก (แแแ แแแแ แแแแแจแแแแ แจแแแแ 11 แฌแแแก 2020 แแแแแ แแแแก) แแ แ แแแแ แช แฉแแแก, แแงแ แแ แกแขแแแแแแแแชแแแก แแ แแแแแแแแ แแแแก แจแแแแแแแแก แแแ แแแแ. แแฃ แฌแแแ แแแ แกแแแแ แฎแจแแ แแ แแแแแแแแแ, แแแจแแ แฃแแฎแแแกแ แแแแแจแแแแ (
5. Kubewise
-
แแ แแแฅแขแแก แแแแ แแ ; - แแแชแแแแแ: แกแแแฃแแ แแแ (แแแแแแฅแชแแแ Open Source);
- แแแแแแ: "แฃแแ แแแ แแ แแแแแแแแขแคแแ แแแแแ แแแแแแขแ Kubernetes-แแกแแแแก."
VMware-แแก แแฎแแแ แแ แแแฃแฅแขแ, แ แแแแแแช แแแแแแแแ แแแแแ แจแแแฅแแแ แจแแแ แฐแแแแแแแแก แคแแ แแแแแจแ (2019 แฌแแแก แแแแแกแจแ). แแแแแแขแแแแแฃแแแ แแแ แกแแแแแฃแ แแแแแแฃแขแแ แแ, แแฃแจแแแแก แกแแคแฃแซแแแแแ
Kubewise-แแก แซแแ แแแแแ แแแฎแแกแแแแแแแแแ:
- แแแขแแ แคแแแกแแก แฃแ แแแแ แแฅแแแแแแ แงแแแแแแ แฎแจแแ แแ แแแแแงแแแแแฃแ Kubernetes แแ แแแฃแแแแแแ: แแแแแซแแแแแ, แกแแฎแแแแ แกแแแ แชแแแแแแ แแ แ.แจ.
- แแ แแแแแ kubeconfig แคแแแแแก แแฎแแ แแแญแแ แ แกแฎแแแแแกแฎแแ แแแแกแขแแ แแแแกแแแแก.
- แขแแ แแแแแแ แแแ แแแแก แชแแแแแแก แแแงแแแแแแก แจแแกแแซแแแแแแแแ
KUBECONFIG
. - แจแแฅแแแแแ แแแ แแแแฃแแ kubeconfig แคแแแแแแ แแแชแแแฃแแ แกแแฎแแแแแแก แกแแแ แชแแกแแแแก.
- แฃแกแแคแ แแฎแแแแแก แแแคแแ แแแแแฃแแ แคแฃแแฅแชแแแแ (RBAC, แแแ แแแแแ, แกแแ แแแกแแก แแแแแ แแจแแแ).
แฏแแ แฏแแ แแแแ แแ แแแฅแขแก แแฅแแก แแฎแแแแ แแ แแ แแแแแจแแแแ - แแแ แกแแ
6. OpenShift แแแแกแแแ
-
OpenShift แแแแฃแแแแขแแชแแแก แแแแงแแคแแแแแ ; -
แกแแชแแแ (~150 GitHub แแแ แกแแแแแแ); - แแแชแแแแแ: Apache 2.0;
- แแแแแแ: "UI OpenShift แแแแกแขแแ แแแแกแแแแก".
แแแแกแแ แแแฃแฎแแแแแแ, แ แแ แแก แแแ แแแขแแ แคแแแกแ แแ แแก OpenShift แแแแแฌแแแแแแก แแแฌแแแ (แแก แแแแแกแขแแแแ แแแฃแแแ แแฅ แแแแแงแแแแแแ
OpenShift Console แฃแแแ แแแแ แฎแแแแ แแแแฃแจแแแแแแก แแ แแชแแกแจแแ, แแแแขแแ แแแก แแฅแแก แแ แแแแแ แคแฃแแฅแชแแ. แฉแแแ แแฆแแแแจแแแแ แแแแแแ แแแก:
- แกแแแ แแ แแแขแแ แคแแแกแแก แแแแแแแ - แแแแกแแแจแ แแ แกแแแฃแแ แจแแกแแซแแแแแแแแแแก แแ แ "แแแ แกแแแฅแขแแแ": แแแแแแแกแขแ แแขแแ แแแแกแแแแก แแ แแแแแแแแแ แแแแกแแแแก. แ แแแแแ แแแแแแแแแ แแก แแแ แกแแแฅแขแแแ แแฏแแฃแคแแแก แแแแแฅแขแแแก แแแแแแแแแ แแแแกแแแแก แฃแคแ แ แแแกแแแแแ แคแแ แแแ (แแแแแแแชแแแแแก แแแฎแแแแแ) แแ แแแแฎแแแแแแก แแแขแแ แคแแแกแก แแกแแแ แขแแแแฃแ แ แแแแชแแแแแแก แแแแแญแ แแแ, แ แแแแ แแชแแ แแแแแแแชแแแแแก แแแงแแแแแ, แแฌแงแแแแก/แแแแแแแแแแก แกแขแแขแฃแกแแก แแแแแงแฃแ แแก แแแแแแแ แแ แแแแแก แ แแแแฅแขแแ แแแแช แแ Eclipse Che-แแก แแแจแแแแแแ.
- แกแแแฃแจแแ แแแขแแแ แแแแก, แฅแกแแแแก, แจแแแแฎแแแก, แฌแแแแแแก แฃแคแแแแแแแก แแแ แแแ.
- แกแแแฃแจแแ แแแขแแแ แแแแก แแแแแแฃแ แ แแแแแฏแแแ แแ แแแฅแขแแแแ แแ แแแแแแแชแแแแแ. แแ แ-แแ แ แฃแแฎแแแก แแแแแชแแแแจแ - v4.3 -
แแแแแฉแแแ แแแแกแแแฃแแ แแแฃแแ แแ แแแฅแขแแก แแแคแ, แ แแแแแแช แแฉแแแแแแก แฉแแแฃแแแแ แแ แแแแแชแแแแแก (แแแแแแแแแแก แ แแแแแแแแ แแ แกแขแแขแฃแกแแแ, แแแแแแ แแ แ.แจ.; แ แแกแฃแ แกแแแแก แแแฎแแแ แแแ แแ แกแฎแแ แแแขแ แแแ) แแ แแแฅแขแแก แแแฌแแแแ. - แแแแแฎแแแแฃแแแ แแแแกแขแแ แแก แแแแแแแ แแแแแก, แแแกแจแ แแแแฎแแแ แ แชแแแแแแแแแแก (แแแแแแแแแแก) แฉแแแแแแแก แ แแแแฃแ แแ แแจแ; แแฃแ แแแแแแแก แแแแแแแแแ แแแ.
- แแฎแแแแ แแแแแขแแ แแแแแก แแแแแชแแแแแ Prometheus, Alertmanager แแ Grafana-แก แกแแคแฃแซแแแแแ.
- แฌแแ แแแแแแแแแ แแแแ แแขแแ แแแแก แแแแแฏแแแแขแ
แแแแ แแขแแ แฐแแแ . - แแแ แแแ build-แแแ, แ แแแแแแแช แแแแแก Docker-แแก แแแจแแแแแแ (แแแแกแแแฆแแ แฃแแ แกแแชแแแแแแ Dockerfile-แแ),
S2I แแ แแแแแแแแฃแ แ แแแ แ แแแแฃแแแแฃแ แ แกแแจแฃแแแแแแแ.
NB: แจแแแแ แแแแก แกแฎแแแแ แแ แแแแแแแขแแ Kubernetes แแแกแขแ แแแฃแชแแ (แแแแแแแแแ, แแแชแแแแแแ แแแแแแแแ แชแแแแแแ
แแแแฃแก
1. Portainer on Kubernetes แแแขแแจแ
-
แกแแแขแแก ; -
แกแแชแแแ (~100 GitHub แแแ แกแแแแแแ); - แแแชแแแแแ: Zlib(?) (แแแแแ แแจแแแแแ แแ แแแฅแขแแกแแแแก).
แแ แแแฅแขแ Portainer-แแก แแฃแแแแกแแแ, แ แแแแแแแช แจแแแแฃแจแแแ แแแแแ แกแแฎแแแฌแแแแแแก แแแแฃแแแ แฃแแ แแแขแแ แคแแแกแ Docker-แแแ แแฃแจแแแแแกแแแแก. แแแแแแแแ แแ แแแฅแขแ แแแแแแแแ แแแแก แแแ แแฃแ แแขแแแแแ (แแแ แแแแ แแ แแ แแแแแ แแ แแแขแ แแแ แกแแ
2. แงแแแฃแแแก แแแแแแ
-
แกแแแขแแก ; - แแแชแแแแแ: แกแแแฃแแ แแแ;
- แแแแแแ: "Visual Kubernetes Editor".
แแก แแฎแแแแแแ แแ แแแกแแขแแแแก แแแแแแแชแแ แแแแแแ แแกแแฎแแแก Kubernetes-แแก แ แแกแฃแ แกแแแแก แแแแฃแแแแแแชแแแก แแ แแแ แแแแก แ แแแแฃแ แแ แแจแ แแแ แขแแแ drag & drop แแแขแแ แคแแแกแแ. แแแแแแแ แแฎแแ แแแญแแ แแแ แแแแแฅแขแแแแ Pod, Service, Deployment, StatefulSet, PersistentVolume, PersistentVolumeClaim, ConfigMap แแ Secret. แแแแ แแกแแแ แฐแแแ แแแแแแ แฐแแแแแก แแฎแแ แแแญแแ แแก. แแแแแแ แ แแแแฃแกแ แแ แแก แแแแแก แกแแแฎแแแแ (แแก แแแกแแแแแแแแแ
3.k9s
-
แกแแแขแแก ; -
แแแแแแกแขแ แแชแแ ; -
แกแแชแแแ (~7700 GitHub แแแ แกแแแแแแ); - แแแชแแแแแ: Apache 2.0;
- แแแแแแ: "แแแแกแแแแก แแแขแแ แคแแแกแ Kubernetes-แแกแแแแก, แ แแแแแแช แกแแจแฃแแแแแแก แแแซแแแแ แแแ แแแ แแฅแแแแ แแแแกแขแแ แ แกแขแแแแ."
แแ แแแ แแแ แแฎแแแแ แแแแแฎแแแแแก แแแแฃแก แแแฌแแแจแ แแงแ แแ แแแแแแแ, แ แแ แแก แแแแแแแแแ แแแแกแแแแก GUI-แก. แแแแกแแแ, แแแขแแ แแแแ แกแแขแงแแแกแแขแงแแแ แแแแแฆแแก แแแฅแกแแแฃแแ แขแแ แแแแแแแแแ, แจแแกแแแแแแแก แแ แ แแฎแแแแ แแแกแแฎแแ แฎแแแแแ แแแขแแ แคแแแกแ, แแ แแแแ 6 แฌแแแแกแฌแแ แแแแกแแแฆแแ แฃแแ แแแแ แแ แแแแแแแขแฃแ แแก แแแแกแแฎแแแแแแแกแ แแ แแ แซแแแแแแแแก แแแแแกแแแแก แแแฌแแแแแ แกแแกแขแแแ. แแแแ แกแแคแฃแซแแแแแแ แแแแแแแ แแ แจแแแแแคแแ แแแแแแแ แแฎแแแแ แแแ แแแแแแแ: k9s แแแฎแแกแแแแแแแแแ แกแแกแแแแแแแแ แจแแแแแแญแแแแแ: แ แแกแฃแ แกแแแแก แแแแแฏแแแแขแ, แแแแกแขแแ แแก แแแแแแแ แแแแแก แฉแแแแแแ, แ แแกแฃแ แกแแแแก แฉแแแแแแ แแแ แแ แฅแแฃแ แฌแแ แแแแแแแแแแแแแจแ แแแแแแแแแแฃแแแแแแแ, แแฃแ แแแแแแแก แแแฎแแ, RBAC แแฎแแ แแแญแแ แ, แจแแกแแซแแแแแแแแแแก แแแคแแ แแแแแ แแแแแแแขแแแแก แกแแจแฃแแแแแแ... แแก แงแแแแแคแแ แ แแแกแแฉแแแ แแ. K8s แคแแ แแ แกแแแแแแแแแแแกแแแแก: แแ แแแฅแขแแก GitHub แแแ แกแแแแแแแแแก แ แแแแแแแแ แแแแฅแแแก แแกแแแแแ แแแ แแแ, แ แแแแ แช แแคแแชแแแแฃแ แ Kubernetes Dashboard!
4. แแแแแแแชแแแก แแแ แแแแก แแแแแแแแ
แแ แแแแแฎแแแแแก แแแแแก - แชแแแแ แแแแ แแแขแแแแ แแ. แแแ แแแแชแแแแ แแ แแแ แแแขแแ แคแแแกแก, แ แแแแแแแช แจแแฅแแแแแแ แแ แ Kubernetes แแแแกแขแแ แแแแก แงแแแแแกแแแแชแแแแ แแแ แแแแกแแแแก, แแ แแแแ แแแแจแ แแแแแแแแแฃแแแก แแแ แแแแกแแแแก.
แแแแแฎแกแแแแแแ, แแ แ-แแ แแ แงแแแแแแ แแแแฌแแคแแแฃแแ แแ แคแแ แแแ แแแแ แชแแแแแฃแแ แแแกแขแ แฃแแแแขแ Kubernetes-แจแ แ แแฃแแ แแแแแแแชแแแแแก แแแแแแแแแแกแแแแก แแ แแก Helm. แแแกแ แแ แกแแแแแแก แแแ แแแแจแ แแแแ แแแแ แแ แแแแแ แแแแแขแ (Helm charts) แแแ แขแแแ แแแแแแแแแแกแแแแก
4.1. แแแแแแฃแแแ แฃแแ
-
แกแแชแแแ (1300+ GitHub แแแ แกแแแแแแ); - แแแชแแแแแ: Apache 2.0;
- แแแแแแ: โแแแ แแแแแแแชแแ แแ แแแแ แกแแชแแแจแ Helm แกแฅแแแแแแก แแแกแแซแแแแแแ แแ แแฆแแแกแแฉแแแแ. แแแกแแฎแฃแ แแแ แฐแแแแแก แฐแแแแก แแ แแแฅแขแแก แกแแคแฃแซแแแแก.
Helm-แแก แแแขแแ แแ แแก แแแแแแแแ แแแ แแแแแกแขแแแแ แแแฃแแแ Kubernetes-แจแ แแ แแฃแจแแแแก แแแแแ แแแแกแขแแ แจแ, แแกแ แฃแแแแก แแแแแแแแแก. แแฃแแชแ, แแแแแแแ แแ แแแฅแขแ แแแแฅแแแก แแ แแ แแก แแแแแแแแ แแแฃแแ. แแแกแ แแแแแแ แ แแแแแแแ แฐแแแ แฐแแแแก แแ แกแแแแแแก แแฎแแ แแแญแแ แ. แกแฎแแ แกแแญแแ แแแแแกแแแแก, แแแขแแ แแแ แ แแแแแแแแแชแแแก แฃแฌแแแแ Kubeapps-แก (แแฎ. แฅแแแแแ) แแ Red Hat Automation Broker-แก (OpenShift-แแก แแแฌแแแ, แแแแ แแ แแกแแแ แแฆแแ แแแแแ แแแแ).
4.2. Kubeapps
แกแแแขแแก ;-
แแ แแแแแขแแชแแ ; -
แกแแชแแแ (~2100 GitHub แแแ แกแแแแแแ); - แแแชแแแแแ: Apache 2.0
- แแแแแแ: "แแฅแแแแ แแแแแชแฎแแแแก แแแคแ Kubernetes-แแกแแแแก."
แแ แแแฃแฅแขแ Bitnami-แแแ, แ แแแแแแช แแกแแแ แแแแแแขแแแแแฃแแแ Kubernetes แแแแกแขแแ แจแ, แแแแ แแ แแแแกแฎแแแแแแแ Monocular-แแกแแแ แแแ แซแ แกแแชแแแแแแแ แแฃแจแแแแแก แแแแแแแแ แแแแ แแฅแชแแแขแแ.
Kubeapps-แแก แซแแ แแแแแ แคแฃแแฅแชแแแแ แแ แแแฎแแกแแแแแแแแแ:
- แแฎแแแแ แแ แแแแแแกแขแแแแ แแ Helm แกแฅแแแแแ แกแแชแแแแแแแแ.
- แจแแแแแฌแแแ, แแแแแแฎแแแ แแ แฌแแจแแแแ Helm-แแ แแแคแฃแซแแแแฃแแ แแแแแแแชแแแแ, แ แแแแแแแช แแแแแกแขแแแแ แแแฃแแแ แแแแกแขแแ แแ.
- แกแแแแแ แแ แแแ แแแ แแแแแ แแแแแแก แกแแชแแแแแแก แแฎแแ แแแญแแ แ (แแฎแแ แแแญแแ แแแแ ChartMuseum แแ JFrog Artifactory).
- แแแ แ แกแแ แแแกแแแแก แแแฎแแ แแ แแฃแจแแแแ - แกแแ แแแกแแแแก แแแขแแแแแแแแ แแ แกแแ แแแก แแ แแแแ แแแแแแ.
- แแแแแกแขแแแแ แแแฃแแ แแแแแแแชแแแแแก แแแแแฅแแแงแแแแ Service Catalog Bindings แแแฅแแแแแแแก แแแแแงแแแแแแ.
- แแแแแแขแแคแแแแชแแแกแ แแ แฃแคแแแแแแแก แแแแแฏแแแแก แแฎแแ แแแญแแ แ RBAC-แแก แแแแแงแแแแแแ.
แจแแแแฏแแแแแแแ แชแฎแ แแแ
แฅแแแแแ แแแชแแแฃแแแ แจแแแแฏแแแแแแแ แชแฎแ แแแ, แ แแแแแจแแช แจแแแแชแแแแ แจแแฏแแแแแ แแ แแแ แแแแชแแ แแ แกแแแฃแแ แแแแฃแแแฃแ แ แแแขแแ แคแแแกแแแแก แซแแ แแแแแ แแแฎแแกแแแแแแแแแแก แจแแแแ แแแแก แแแกแแแแแแแแแแแ:
(แชแฎแ แแแแก แแแแแแ แแแ แกแแ
แแแกแแแแ
Kubernetesโแแก GUIโแแแ แกแแแแแแ แกแแแชแแคแแแฃแ แ แแ แแฎแแแแแแ แแ แแแจแแ. แแฃแแชแ, แแก แซแแแแแ แแฅแขแแฃแ แแ แแแแแ แแแแ: แฃแแแ แจแแกแแซแแแแแแแ แ แแแแ แช แกแแแแแแ แแแแฌแแคแแแฃแแ แแแแแฌแงแแแขแแแแแแแแก แแแแแ, แแกแแแ แซแแแแแ แแฎแแแแแแ แแ, แ แแแแแแกแแช แฏแแ แแแแแ แแฅแแ แแแกแแจแแแแแแแ. แแกแแแ แแแกแแฎแฃแ แแแแแ แกแฎแแแแแกแฎแแ แแแแแแแชแแแแก, แแแแแแแแแแแ แคแฃแแฅแชแแแแกแ แแ แแแ แแแแแแแก แแแแฅแแแก แงแแแแ แแแแแแแแแแก. แแแแแแแแแแแ, แ แแ แแก แแแแแฎแแแแ แแแแแฎแแแ แแแแ แแแ แฉแแแ แแแกแขแ แฃแแแแขแ, แ แแแแแแช แกแแฃแแแแแกแแ แจแแแกแแแแแแแ แแฅแแแแก แแแแแแแแแแ แกแแญแแ แแแแแแก.
PS
แฒแแแแแแแ
แแกแแแ แฌแแแแแแฎแแ แฉแแแแก แแแแแแ:
- ยซ
Kubernetes Web View-แแก แแแแชแฎแแแแแ (แแ แกแฎแแ แแแ UI-แแแแก แแแแแ แแแแแฎแแแแ Kubernetes-แแกแแแแก) "; - ยซ
Kubernetes Dashboard แแ GitLab แแแแฎแแแ แแแแแแแก แแแขแแแ แแชแแ "; - ยซ
Polaris แแแแแแ แแ Kubernetes-แแก แแแแกแขแแ แแแแก แฏแแแแ แแแแแแแก แจแแกแแแแ แฉแฃแแแแแแ "; - ยซ
kubebox แแ แกแฎแแ แญแฃแ แแแแ Kubernetes-แแกแแแแก ".
แฌแงแแ แ: www.habr.com