แฒจแแแแจแแแ. แแแ แแแแ: แแฃ แแแแแขแแ แแกแแแ Kubernetes-แแ แแแคแฃแซแแแแฃแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แฃแกแแคแ แแฎแแแแ, Sysdig-แแก แแก แจแแกแแแแจแแแแ แแแแแฎแแแแ แจแแกแแแแจแแแแ แกแแฌแงแแกแ แฌแแ แขแแแแ แแแแแแแแ แ แแแแแฌแงแแแขแแแแแแแแก แกแฌแ แแคแ แแแแแฎแแแแแกแแแแก. แแแ แแแแชแแแก แ แแแแ แช แแแแแแแฅแกแฃแ แกแแกแขแแแแแก แแแแ แแก แชแแแแแแ แแแแแแแจแแแแแกแแแ, แแกแแแ แแแแ แแ แฃแคแ แ แแแแ แซแแแแแฃแ แแแแฃแแแแฃแ แแแแแแแแแแก, แ แแแแแแแช แฌแงแแแขแแ แแแแแ แแขแฃแ แแ แแแแแแแก. แแ แแแแแแขแแ แแแจแ, แ แแแแ แช แงแแแแแแแแก, แแแฎแแ แฃแแ แแแฅแแแแแ แแแแแกแแแแแ แแฅแแแแ แแแแแชแแแแแแแก แจแแกแแฎแแ แแ แแแกแขแ แฃแแแแขแแแแก แแแแแงแแแแแแก แจแแกแแฎแแ แแ แแแแฎแแ แกแฎแแ แแ แแแฅแขแแแแก แแแฃแแแแ.

Kubernetes-แแก แฃแกแแคแ แแฎแแแแแก แแ แแแ แแแฃแแ แแ แแแฃแฅแขแแแ... แซแแแแแ แแแแ แ แแแแแแแแ, แแแแแแฃแแก แแฅแแก แกแแแฃแแแ แ แแแแแแแ, แคแแ แแแแแ แแ แแแชแแแแแแแ.
แกแฌแแ แแ แแแแขแแ แแแแแแฌแงแแแขแแ แจแแแแแฅแแแ แแก แกแแ แแ แจแแแแแขแแแ แ แแแแ แช แฆแแ แแแแแก แแ แแแฅแขแแแ, แแกแแแ แแแแแ แชแแฃแแ แแแแขแคแแ แแแแ แกแฎแแแแแกแฎแแ แแแแฌแแแแแแแแแกแแแ. แแแแแแแแแแแ, แ แแ แแก แแแแแฎแแแ แแแแ แแแแแขแแคแแชแแ แแ แแก, แแแแช แงแแแแแแ แกแแแแขแแ แแกแแ แแ แแแแแแแแแ แกแฌแแ แ แแแแแ แแฃแแแแแ แแฅแแแแ แแแแแ แแขแฃแแ Kubernetes แฃแกแแคแ แแฎแแแแแก แกแแญแแ แแแแแแแ แแแแแแแแแแ แ.
แแแขแแแแ แแ
แกแแแจแ แแแแแแแชแแแก แแแกแแแแแแแแแแแ, แแแกแขแ แฃแแแแขแแแ แแ แแแแแแแแฃแแแ แซแแ แแแแแ แคแฃแแฅแชแแแกแ แแ แแแแแแแชแแแก แแแฎแแแแแ. แแแแฆแแก แจแแแแแแ แกแแฅแชแแแแ:
- Kubernetes แแแแแกแแฎแฃแแแแแก แกแแแแแ แแแ แแ แกแขแแขแแแฃแ แ แแแแแแแ;
- แแแจแแแแแก แฃแกแแคแ แแฎแแแแ;
- Kubernetes แฅแกแแแแก แฃแกแแคแ แแฎแแแแ;
- แแแแแกแแฎแฃแแแแแก แแแแแฌแแแแแ แแ แกแแแแฃแแแแแแแก แแแ แแแ;
- Kubernetes แฃแกแแคแ แแฎแแแแแก แแฃแแแขแ;
- แงแแแแแกแแแแชแแแแ แแแแแ แชแแฃแแ แแ แแแฃแฅแขแแแ.
แแแแแ แแแแแแแแแ แกแแฅแแแแ:
Kubernetes แกแฃแ แแแแแแก แกแแแแแ แแแ
แฌแแแงแแแแ
- แกแแแขแ:
- แแแชแแแแแ: แฃแคแแกแ (Apache) แแ แแแแแ แชแแฃแแ แจแแแแแแแแแ

Anchore แแแแแแแแแแก แแแแขแแแแแ แแแแก แกแฃแ แแแแแก แแ แฃแจแแแแก แฃแกแแคแ แแฎแแแแแก แจแแแแฌแแแแแก แแแแฎแแแ แแแแแก แแแแ แแแแกแแแฆแแ แฃแ แแแแแขแแแแแ แแแงแ แแแแแแ.
แแแ แแ แแแแขแแแแแ แแก แกแฃแ แแแแแแก แฉแแแฃแแแแ แแแ แกแแแแแ แแแแกแ แชแแแแแแ แแแฃแชแแแแแแแกแแแแก CVE แแแแแชแแแแ แแแแแแแ, Anchore แแฎแแ แชแแแแแแก แแแแ แแแแแขแแแแ แจแแแแฌแแแแแก, แ แแแแ แช แแแกแ แกแแแแแ แแแแก แแแแแขแแแแก แแแฌแแแ: แแแแฌแแแแก Dockerfile-แก, แ แฌแแฃแแแแแแ แกแแแแแแแแก แแแแแแแแก, แแแแแงแแแแแฃแแ แแ แแแ แแแแ แแแแก แแแแแแก แแแแแขแแแก (npm, maven แแ แ.แจ. .), แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแแชแแแแแแแ แแ แแ แแแแแ แกแฎแแ.
แฌแแแแแ
- แกแแแขแ: (แแฎแแ Red Hat-แแก แแแฃแ แแแแแแก แฅแแแจ)
- แแแชแแแแแ: แฃแคแแกแ (Apache)

Clair แแงแ แแ แ-แแ แแ แแแ แแแแ แฆแแ แแแแแก แแ แแแฅแขแ แแแแแกแแฎแฃแแแแแก แกแแแแแ แแแแกแแแแก. แแแ แคแแ แแแ แแ แแก แชแแแแแแ, แ แแแแ แช แฃแกแแคแ แแฎแแแแแก แกแแแแแ แ Quay แแแแแกแแฎแฃแแแแแก แ แแแกแขแ แแก แฃแแแ (แแกแแแ CoreOS-แแแ - แแแแฎแ. แแแ แแแแแ)แแแแ แก แจแแฃแซแแแ CVE แแแคแแ แแแชแแแก แจแแแ แแแแแ แฌแงแแ แแแแแก แคแแ แแ แกแแแฅแขแ แแแแ, แแแ แจแแ แแก CVE-แกแแแชแแคแแแฃแ แ แกแแแแแแแ. Linux- แแแฃแชแแแแแแแแแก แแแแแฌแแแแแ, แ แแแแแแกแแช แฃแกแแคแ แแฎแแแแแก แแฃแแแแแ แแแแแ แแแแแแ Debian, Red Hat แแ Ubuntu.
Anchore-แแกแแแ แแแแกแฎแแแแแแแ, Clair แฃแแแ แแแแแก แงแแแแแกแ แงแฃแ แแแฆแแแแก แแแแฎแแแแแแก แแแฌแงแแแแแแแแก แแแแแแแ แแ แแแแแชแแแแแแก CVE-แแแแแ แจแแกแแแแแแกแแแแจแ. แแฃแแชแ, แแ แแแฃแฅแขแ แแแแฎแแแ แแแแแแก แกแแแแแแแแก แคแฃแแฅแชแแแแแก แแแคแแ แแแแแแก แจแแกแแซแแแแแแแแแก แแแแแแแขแแก แแ แแแแแ แแแแก แแแแแงแแแแแแ.
แแแแแ
- แกแแแขแ:
- แแแชแแแแแ: แฃแคแแกแ (Apache)

Dagda แแฎแแ แชแแแแแแก แแแแขแแแแแ แแก แกแฃแ แแแแแแก แกแขแแขแแแฃแ แแแแแแแก แชแแแแแแ แแแฃแชแแแแแแแก, แขแ แแแกแแแแก, แแแ แฃแกแแแแก, แแแแแ แแ แแแ แแแแแแกแ แแ แกแฎแแ แกแแคแ แแฎแแแแแกแแแแก.
แแ แ แแแแจแแแแแแแแแ แแแฎแแกแแแแแแแแ แแแแแกแฎแแแแแแก แแแแแแก แกแฎแแ แแกแแแแกแ แฎแแแกแแฌแงแแแแแกแแแ:
- แแก แแแแแแฃแ แแ แแแ แแแแแแแก , แแแฅแแแแแแก แแ แ แแฎแแแแ แ แแแแ แช แแแกแขแ แฃแแแแขแ แแแแขแแแแแ แแก แกแฃแ แแแแแแก แกแแแแแ แแแแกแแแแก, แแ แแแแ แ แแแแ แช แแแขแแแแ แฃแกแ.
- แแกแแแ แฃแแ แฃแแแแแงแแคแก แแแจแแแแแก แแแชแแแก Docker-แแก แแแแแแแกแแแ แ แแแแฃแ แแ แแจแ แแแแแแแแแแก แแแฆแแแแ แแ Falco-แกแแแ แแแขแแแ แแ แแแแ (แแฎแแแแ แฅแแแแแ) แฃแกแแคแ แแฎแแแแแก แแแแแแแแแแก แจแแแ แแแแแ แแแแขแแแแแ แแก แแฃแจแแแแแกแแก.
KubeXray
- แกแแแขแ:
- แแแชแแแแแ: แฃแคแแกแ (Apache), แแแแ แแ แแแแแฎแแแก แแแแแชแแแแแก JFrog Xray-แแแ (แแแแแ แชแแฃแแ แแ แแแฃแฅแขแ)

KubeXray แฃแกแแแแก แแแแแแแแแก Kubernetes API แกแแ แแแ แแแแ แแ แแงแแแแแก แแแขแแแแแแชแแแแแก JFrog Xray-แแแ, แ แแแ แฃแแ แฃแแแแแงแแก แแฎแแแแ แแแแแแแแแแแ แฌแแกแแแแก แจแแกแแแแแแกแ แแแแแแแก แแแจแแแแ.
KubeXray แแ แ แแฎแแแแ แแแแฌแแแแก แแฎแแ แแ แแแแแฎแแแแฃแ แแแแขแแแแแ แแแก แแแแแแแแแแกแแก (แแกแแแแกแ แแแจแแแแแก แแแแขแ แแแแ แ Kubernetes-แจแ), แแ แแแแ แแแแแแแฃแ แแ แแแแฌแแแแก แแแจแแแแฃแ แแแแขแแแแแ แแแก แฃแกแแคแ แแฎแแแแแก แแฎแแ แแแแแขแแแแแแแ แจแแกแแแแแแกแแแแจแ, แฌแแจแแแก แ แแกแฃแ แกแแแก, แ แแแแแแแช แแแฃแแแแแแแ แแแฃแชแแแ แกแฃแ แแแแแแ.
แกแแแแ
- แกแแแขแ:
- แแแชแแแแแ: แฃแคแแกแ (Apache) แแ แแแแแ แชแแฃแแ แแแ แกแแแแ

Snyk แแ แแก แแ แแฉแแแฃแแแแ แแแ แแแฃแชแแแแแแแก แกแแแแแ แ, แ แแแแแ แแก แแแแแ แแขแฃแแแ แแแแแแ แแกแแฎแแแก แแแแแแแแ แแแแก แแ แแชแแกแก แแ แแแฌแแแแฃแ แแแฃแแแ, แ แแแแ แช "แแ แกแแแแแ แแแแแฌแงแแแขแ" แแแแแแแแแ แแแแกแแแแก.
Snyk แแแ แแแแแ แแแแแจแแ แแแก แแแแแก แกแแชแแแแแก, แแแแแแแแแแก แแ แแแฅแขแแก แแแแแคแแกแขแก แแ แแแแแแแแแแก แแแแแ แขแแ แแแฃแ แแแแก แแแ แแแแแ แแ แแ แแแแ แแแแแ แแแแแแแแแแฃแแแแแแแแ แแ แแแ. Snyk แแฎแแ แก แฃแญแแ แก แแแแ แแแแฃแแแ แฃแ แแ แแแ แแแแ แแแแก แแแแก แแ แจแแฃแซแแแ แคแแ แฃแแ แแแชแแแแแแก แ แแกแแแแแก แแแแแขแแคแแชแแ แแแ.
แฌแแ แแแแแแ
- แกแแแขแ:
- แแแชแแแแแ: แฃแคแแกแ (AGPL)

Trivy แแ แแก แแแ แขแแแ, แแแแ แแ แซแแแแ แ แแแฃแชแแแแแแแก แกแแแแแ แ แแแแขแแแแแ แแแแกแแแแก, แ แแแแแแช แแแแแแแ แแแขแแแ แแ แแแแ CI/CD แแแแกแแแแแจแ. แแแกแ แแฆแกแแแแจแแแแ แแแฎแแกแแแแแแแแแ แแแกแขแแแแชแแแกแ แแ แแฃแจแแแแแก แกแแแแ แขแแแ: แแแแแแแชแแ แจแแแแแแ แแ แแ แแ แแแแแแกแแแแ แแ แแ แกแแญแแ แแแแก แแแแแชแแแแ แแแแแก แแ แแแแแขแแแแ แแแแแแแแแแแแแก แแแกแขแแแแชแแแก.
Trivy-แแก แกแแแแ แขแแแแก แแแแฃแกแ แแ แแก แแก, แ แแ แแฅแแแ แฃแแแ แแแแ แแแแแ, แ แแแแ แแแแแแแแแแแ แแ แแแแแแแแแแแแ แจแแแแแแแ JSON แคแแ แแแขแจแ, แ แแแ Kubernetes-แแก แฃแกแแคแ แแฎแแแแแก แกแฎแแ แแแกแขแ แฃแแแแขแแแแ แแแแแแงแแแแ แแกแแแ.
Runtime แฃแกแแคแ แแฎแแแแ Kubernetes-แจแ
Falco
- แกแแแขแ:
- แแแชแแแแแ: แฃแคแแกแ (Apache)

Falco แแ แแก แแแกแขแ แฃแแแแขแแแแก แแแแ แแแ แฆแ แฃแแแแแแแ แแแจแแแแแก แแแ แแแแก แฃแแ แฃแแแแแกแแงแแคแแ. แแ แแแฅแขแแก แแฏแแฎแแก แแแฌแแแ .
Sysdig แแแกแขแ แฃแแแแขแแแแก แแแแแงแแแแแ แแแ แแแแก แแแแแแ แกแแแฃแจแแแ Linux แกแแกแขแแแฃแ แ แแแ แแแแก แแ แแคแแแแ แแแแกแ แแ แแแแแขแแ แแแแแก แกแแจแฃแแแแแแ, Falco แกแแกแขแแแแก แฅแชแแแแจแ แฆแ แแ แฉแแฎแแแแแก แกแแจแฃแแแแแแก แแซแแแแ. แแแก แแแจแแแแแก แฌแแกแแแแก แซแ แแแแก แจแแฃแซแแแ แกแแแญแแ แแฅแขแแแแแแก แแฆแแแฉแแแ แแแแแแแชแแแแจแ, แแแแขแแแแแ แแแจแ, แซแแ แแแแ แฐแแกแขแกแ แแ Kubernetes-แแก แแ แแแกแขแ แแขแแ แจแ.
Falco แฃแแ แฃแแแแแงแแคแก แกแ แฃแ แแแแญแแแ แแแแแแแก แแฃแจแแแแแก แแ แแก แแ แกแแคแ แแฎแแก แแแแแแแแแแจแ แแ แแแแแแแแกแแแแแก Kubernetes-แแก แแแแแซแแแแ แกแแแชแแแแฃแ แ แแแแแขแแแแก แแแแแแแแแแ. แจแแแแแแ, แแ แแ แแก แกแแญแแ แ แแแแขแแแแแ แแแแก แจแแชแแแ แแแแจแ แแแกแแแ แแฎแแ แแก แแแแแก แจแแงแแแแแ แแ แแแแ แแแแ แแแ แแก แแแแขแแแแแ แแแแก แแแแแขแแแแ.
แฃแกแแคแ แแฎแแแแแก แฉแแ แฉแแแแ Linux แแแจแแแแแก แแ แแแกแแแแก

แแกแแแ แแแ แแแแก แแแแแแ แแ แแ แแแ Linux แฉแแ แฉแแแแ แแ แฌแแ แแแแแแแแแ โKubernetes-แแก แฃแกแแคแ แแฎแแแแแก แแแกแขแ แฃแแแแขแแแกโ แขแ แแแแชแแฃแแ แแแแแแแ, แแแแ แแ แแแแ แฎแกแแแแแ แฆแแ แก, แ แแแแแ แแกแแแ แแแแจแแแแแแแแ แแแแแแแขแก แฌแแ แแแแแแแแแ แแแจแแแแแก แแ แแก แฃแกแแคแ แแฎแแแแแก แแแแขแแฅแกแขแจแ, แ แแแแแแช แจแแแแก Kubernetes Pod-แแก แฃแกแแคแ แแฎแแแแแก แแแแแขแแแแจแ (PSP).
แแแแญแแแก แฃแกแแคแ แแฎแแแแแก แแ แแคแแแก แแแแขแแแแแ แจแ แแแจแแแแฃแ แแ แแชแแกแแแก, แแแแกแแแฆแแ แแแก แคแแแแฃแ แ แกแแกแขแแแแก แแ แแแแแแแแแแก, แฅแกแแแจแ แฌแแแแแแก แฌแแกแแแก, แแแแแแแแแแแแแก แแแแแแจแแ แแแแก แแ แ.แจ. แแก แแ แแก แกแแกแขแแแ, แ แแแแแแช แแแคแฃแซแแแแฃแแแ แกแแแแแแแแฃแแ แฌแแแแแแก แแแแขแ แแแแ (MAC). แกแฎแแ แกแแขแงแแแแแ แ แแ แแแฅแแแ, แแก แฎแแแก แฃแจแแแก แแแ แซแแแฃแแ แแแฅแแแแแแแแแก แจแแกแ แฃแแแแแก.
แแแซแแแแ แแแฃแแ แฃแกแแคแ แแฎแแแแ Linux () แแ แแก แแแ แแแแก แแแคแแ แแแแแฃแแ แฃแกแแคแ แแฎแแแแแก แแแแฃแแ. Linux, แแแแแแ แแ แแกแแแฅแขแแ AppArmor-แแก แแกแแแแกแ แแ แฎแจแแ แแ แแแกแแแ แจแแแแ แแแฃแแ. SELinux แแก AppArmor-แก แแฆแแแแขแแแ แกแแแซแแแแ แแ, แแแฅแแแแแแแแ แแ แแแ แกแแแแแแแแชแแแก แแแ แแแแขแแแแ. แแแก แแแแแแแแแแแแแก แจแแ แแกแแ แฃแคแ แ แฎแแแแ แซแแแแ แกแฌแแแแแก แแ แแชแแกแ แแ แแแแ แแแแ แกแแ แแฃแแ.
แแ seccomp-bpf แกแแจแฃแแแแแแก แแแซแแแแ แแแคแแแขแ แแ แกแแกแขแแแฃแ แ แแแ แแแ, แแแแแแแแ แแแแ แจแแกแ แฃแแแแ, แ แแแแแแแช แแแขแแแชแแฃแ แแ แกแแจแแจแแ แกแแแแแ OS-แกแแแแก แแ แแ แแ แแก แกแแญแแ แ แแแแฎแแแ แแแแแก แแแแแแแชแแแแแก แแแ แแแแฃแ แ แแฃแจแแแแแกแแแแก. Seccomp แแแ แแแแฃแแฌแแแแ แฐแแแแก Falco-แก, แแฃแแชแ แแแ แแ แแชแแก แแแแขแแแแแ แแแแก แกแแแชแแคแแแ.
Sysdig แฆแแ แฌแงแแ แ
- แกแแแขแ:
- แแแชแแแแแ: แฃแคแแกแ (Apache)

Sysdig แแ แแก แกแ แฃแแ แแแกแขแ แฃแแแแขแ แแแแแแแแก, แแแแแแแกแขแแแแกแ แแ แแแแแ แแแแกแแแแก. Linux-แกแแกแขแแแแแ (แแกแแแ แแฃแจแแแแก Windows ะธ macOS, แแแแ แแ แจแแแฆแฃแแฃแแ แคแฃแแฅแชแแแแแแฃแ แแแแ). แแแกแ แแแแแงแแแแแ แจแแกแแซแแแแแแแ แแแขแแแฃแ แ แแแคแแ แแแชแแแก แจแแแ แแแแแแก, แแแแแแแฌแแแแแกแ แแ แกแแกแแแแ แแแ แแฅแกแแแ แขแแแแกแแแแก. (แแ แแแแแแแแกแขแแแ) แแแแแก แกแแกแขแแแ แแ แแแกแแ แแแจแแแแฃแแ แแแแแกแแแแ แ แแแแขแแแแแ แ.
Sysdig แแกแแแ แแฎแแ แก แฃแญแแ แก แแแแขแแแแแ แแแแก แแแจแแแแแก แแ Kubernetes แแแขแแแแแแชแแแแแก, แแแแขแแแก แแแแแขแแแแ แแแแแแแแแแแแแก แแ แแขแแแแขแแแก แกแแกแขแแแแก แฅแชแแแแก แงแแแแ แแแคแแ แแแชแแแก, แ แแแแแแช แแแ แแแแแก. แแฃแแแ แแแขแแก แแแแกแขแแ แแก แแแแแแแแก แ แแแแแแแแ แแแ แแ แกแแแแแก Sysdig-แแก แแแแแงแแแแแแ: แจแแแแซแแแแ แจแแแกแ แฃแแแ แแ แแจแ แแแแแฆแแแ แแ แแแฃแจแแแ ncurses-แแ แแแคแฃแซแแแแฃแแ แแแขแแ แแฅแขแแฃแแ แแแขแแ แคแแแกแ แแแแฃแแแก แแแแแงแแแแแแ .
Kubernetes แฅแกแแแแก แฃแกแแคแ แแฎแแแแ
แแแแ แแขแ
- แกแแแขแ:
- แแแชแแแแแ: แแแแแ แชแแฃแแ

Aporeto แแแแแแแแแ "แฃแกแแคแ แแฎแแแแแก แฅแกแแแแแแ แแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแกแแแ แแแแชแแแแแแแแฃแแ". แแก แแแจแแแแก, แ แแ Kubernetes แกแแ แแแกแแแ แแฆแแแแ แแ แ แแฎแแแแ แแแแแแฃแ ID-แก (แแแฃ ServiceAccount-แจแ Kubernetes-แจแ), แแ แแแแ แฃแแแแแ แกแแแฃแ ID/แแแแแก แแแแแแญแแก, แ แแแแแแช แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แฃแกแแคแ แแฎแแ แแ แฃแ แแแแ แแแแแแแจแแ แแแฃแแแ แแแแแกแแแแ แกแฎแแ แกแแ แแแกแแแ, แแแแแแแแแ OpenShift แแแแกแขแแ แจแ.
Aporeto-แก แจแแฃแซแแแ แจแแฅแแแแก แฃแแแแแแฃแ แ ID แแ แ แแฎแแแแ Kubernetes/แแแแขแแแแแ แแแแกแแแแก, แแ แแแแ แฐแแกแขแแแแกแแแแก, แฆแ แฃแแแแแแแ แคแฃแแฅแชแแแแแกแแแแก แแ แแแแฎแแแ แแแแแแแกแแแแก. แแ แแแแแขแแคแแแแขแแ แแแแแแ แแ แแแแแแแกแขแ แแขแแ แแก แแแแ แแแแแแแแแ แฅแกแแแแก แฃแกแแคแ แแฎแแแแแก แฌแแกแแแแก แแแแ แแแแแแ แแแแแแแแแแ แ, แแแแฃแแแแแชแแแแ แแแแจแแแแ แแ แแแแแแแแแแ.
แแแแแแ
- แกแแแขแ:
- แแแชแแแแแ: แฃแคแแกแ (Apache)

Calico แฉแแแฃแแแแ แแ แแแแแแแแแฃแแแ แแแแขแแแแแ แแแแก แแ แแแกแขแ แแขแแ แแก แแแกแขแแแแชแแแก แแ แแก, แ แแช แกแแจแฃแแแแแแก แแแซแแแแ แจแแฅแแแแ แแแ แขแฃแแแฃแ แ แฅแกแแแ, แ แแแแแแช แแ แแแแแแแแแ แแแแแจแแ แแแก แแแแขแแแแแ แแแก. แฅแกแแแแก แแ แซแแ แแแแแ แคแฃแแฅแชแแแก แแแ แแ, Calico แแ แแแฅแขแ แแฃแจแแแแก Kubernetes Network Policies-แแแ แแ แฅแกแแแแก แฃแกแแคแ แแฎแแแแแก แแ แแคแแแแแแก แกแแแฃแแแ แแแแแแแฅแขแแแ, แแฎแแ แก แฃแญแแ แก แแแแ แฌแแ แขแแแแแแก ACL-แแแก (แฌแแแแแแก แแแแขแ แแแแก แกแแแแก) แแ แแแแขแแชแแแแ แแแคแฃแซแแแแฃแ แฅแกแแแแก แฃแกแแคแ แแฎแแแแแก แฌแแกแแแก Ingress แแ Egress แขแ แแคแแแแกแแแแก.
แชแแแแฃแแ
- แกแแแขแ:
- แแแชแแแแแ: แฃแคแแกแ (Apache)

Cilium แแแแขแแแแแ แแแแกแแแแก firewall-แแก แคแฃแแฅแชแแแก แแกแ แฃแแแแก แแ แฃแแ แฃแแแแแงแแคแก แฅแกแแแแก แฃแกแแคแ แแฎแแแแแก แคแฃแแฅแชแแแแก, แ แแแแแแแช แแฃแแแแ แแแแ แแ แแก แแแ แแแแฃแแ Kubernetes-แแกแ แแ แแแแ แแกแแ แแแกแแแแก แกแแแฃแจแแ แแแขแแแ แแแแแแ. Cilium แแงแแแแแก แแฎแแ แแแ แแแฃแ แขแแฅแแแแแแแแก. Linux แแแแแชแแแแ แคแแแขแ แแชแแแก, แแแแแขแแ แแแแแก, แแแแแแแกแแแแ แแแแแกแ แแ แแแ แแฅแขแแ แแแแกแแแแก, แ แแแแแกแแช BPF (แแแ แแแแก แแแแแขแแก แคแแแขแ แ) แแฌแแแแแ.
Cilium-แก แจแแฃแซแแแ แแแแแแแแกแแก แฅแกแแแจแ แฌแแแแแแก แแแแแขแแแ แแแแขแแแแแ แแแแก ID-แแแแ แแแคแฃแซแแแแฃแแ Docker แแ Kubernetes แแขแแแแขแแแแกแ แแ แแแขแแแแแแชแแแแแแก แแแแแงแแแแแแ. Cilium แแกแแแ แแกแแแก แแ แคแแแขแ แแแก แกแฎแแแแแกแฎแแ แคแแแแก แแ แแขแแแแแแแก, แ แแแแ แแชแแ HTTP แแ gRPC, แ แแช แกแแจแฃแแแแแแก แแแซแแแแ แแแแกแแแฆแแ แแ REST แแแ แแแแก แแแแ แแแ, แ แแแแแแช แแแจแแแแฃแแ แแฅแแแแ, แแแแแแแแแ, Kubernetes-แแก แแ แแแแแแแแแแก แจแแ แแก.
แแกแขแแ
- แกแแแขแ:
- แแแชแแแแแ: แฃแคแแกแ (Apache)

Istio แคแแ แแแ แแ แแก แชแแแแแแ แกแแ แแแกแแก แฅแกแแแแก แแแ แแแแแแแก แแแแแ แแแแ แแแแขแคแแ แแแกแแแ แแแแแฃแแแแแแแแ แกแแแแแขแ แแแ แกแแแ แขแงแแก แแแแแแแแแแ แแ แงแแแแ แแแ แแฃแแ แกแแ แแแกแแก แขแ แแคแแแแก แแแ แจแ แฃแขแแ แแแแแแแฃแ แแ แแแแคแแแฃแ แแ แแแแแ Envoy แแ แแฅแกแแแแแก แแแจแแแแแแ. Istio แแงแแแแแก แงแแแแ แแแแ แแกแแ แแแกแแกแ แแ แแแแขแแแแแ แแแแก แแ แแแฌแแแแแ แฎแแแก แฅแกแแแแก แฃแกแแคแ แแฎแแแแแก แกแฎแแแแแกแฎแแ แกแขแ แแขแแแแแก แแแแกแแฎแแ แชแแแแแแแแ.
Istio-แก แฅแกแแแแก แฃแกแแคแ แแฎแแแแแก แจแแกแแซแแแแแแแแแ แแแแชแแแก แแแแญแแแ แแแแ TLS แแแจแแคแแ แแก แแแแ แแกแแ แแแกแแแก แจแแ แแก แแแแฃแแแแแชแแแแแก แแแขแแแแขแฃแ แแ แแแแแฎแแแแแกแแแแก HTTPS-แแแ แแ RBAC แแแแแขแแคแแแแชแแแกแ แแ แแแขแแ แแแแชแแแก แกแแแฃแแ แแแแจแ แแ แกแแแฃแ แกแแกแขแแแแก แแแแกแขแแ แจแ แกแฎแแแแแกแฎแแ แแแขแแแ แแแแก แจแแ แแก แแแแฃแแแแแชแแแก แแแกแแจแแแแแ/แฃแแ แกแแงแแคแแ.
แฒจแแแแจแแแ. แแแ แแแแ: Istio-แก แฃแกแแคแ แแฎแแแแแแ แแ แแแแขแแ แแแฃแแ แจแแกแแซแแแแแแแแแแก แจแแกแแฎแแ แแแขแ แแแคแแ แแแชแแแกแแแแก แฌแแแแแแฎแแ .
แแแคแฎแแ
- แกแแแขแ:
- แแแชแแแแแ: แแแแแ แชแแฃแแ

"Kubernetes Firewall"-แก แฃแฌแแแแแแ, แแก แแแแแกแแแแแ แฎแแแก แฃแกแแแแก แฅแกแแแแก แฃแกแแคแ แแฎแแแแแก แแฃแแแแแแ แแแแแแก แแแแแแแแก.
Kubernetes-แแก แกแฎแแ แแจแแแแแฃแ แ แฅแกแแแฃแ แ แแแแแฌแงแแแขแแแแแแแแก แแกแแแแกแแ, Tigera แแงแ แแแแแ แแแขแแแแแแชแแแแแก แแแแกแขแแ แจแ แกแฎแแแแแกแฎแแ แกแแ แแแกแแแแกแ แแ แแแแแฅแขแแแแก แแแแแขแแคแแชแแ แแแแกแแแแก แแ แฃแแ แฃแแแแแงแแคแก แกแแแฃแจแแ แแ แแแก แแ แแแแแแแแแก แแแแชแแแแแก, แจแแกแแแแแแกแแแแก แแฃแแแแ แจแแแแฌแแแแแก แแ แฅแกแแแแก แฎแแแแแแแแแก แแ แแแแ แฆแ แฃแแแแแแแ แแ แฐแแแ แแแฃแแ แแแแแแแแฃแ แ แแแแขแแแแแ แแ แแแฃแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแกแแแแก.
แขแ แแ แแแ
- แกแแแขแ:
- แแแชแแแแแ: แฃแคแแกแ (Apache)

Trireme-Kubernetes แแ แแก Kubernetes Network Policies แกแแแชแแคแแแแชแแแก แแแ แขแแแ แแ แแแ แแแแแ แ แแแแแแแแแขแแชแแ. แแแกแ แงแแแแแแ แแฆแกแแแแจแแแแ แแแแกแแแ แแก แแ แแก, แ แแ - แแกแแแแกแ Kubernetes แฅแกแแแฃแ แ แฃแกแแคแ แแฎแแแแแก แแ แแแฃแฅแขแแแแกแแแ แแแแกแฎแแแแแแแ - แแแก แแ แกแญแแ แแแแ แชแแแขแ แแแฃแ แ แกแแแแแขแ แแแ แกแแแ แขแงแ แแแแแก แแแแ แแแแแชแแแกแแแแก. แแก แแแแแฌแงแแแขแแก แขแ แแแแแแฃแ แแ แแแกแจแขแแแแ แแแแแก แฎแแแก. Trireme แแแแก แแฆแฌแแแก แแแแแแฃแ แแแแแซแแ แแแแแขแแก แแแงแแแแแแ, แ แแแแแแช แแแ แแแแแ แฃแแแแจแแ แแแแ TCP/IP-แแแกแแแแซแแแก แแแกแขแ.
แแแแแกแแฎแฃแแแแแก แแแแ แชแแแแแ แแ แกแแแแฃแแแแแแแก แแแ แแแ
แแ แแคแแแ
- แกแแแขแ:
- แแแชแแแแแ: แฃแคแแกแ (Apache)

Grafeas แแ แแก แฆแแ แแแแแก API แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแแฌแแแแแแก แฏแแญแแแก แแฃแแแขแแกแ แแ แแแ แแแแกแแแแก. แกแแแแแแกแ แแแแแแ, Grafeas แแ แแก แแแกแขแ แฃแแแแขแ แแแขแแแแแแชแแแแแแก แจแแแ แแแแแแกแ แแ แแฃแแแขแแก แแแกแแแแแแแกแแแแก. แแก แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แแ แแแแแแแชแแแก แจแแแแแ แฃแกแแคแ แแฎแแแแแก แกแแฃแแแแแกแ แแ แแฅแขแแแแกแแแ แจแแกแแแแแแกแแแแก แแแแแงแฃแ แแก แแแแแแแแกแแแแก.
แญแแจแแแ แแขแแแแก แแก แชแแแขแ แแแแแแแฃแแ แฌแงแแ แ แแแแแฎแแแ แแแแ แฃแแแกแฃแฎแแ แแแแฎแแแแก, แ แแแแ แแชแแ:
- แแแ แจแแแแ แแแ แแ แแแแฌแแ แ แฎแแแ แแแแแ แแขแฃแ แแแแขแแแแแ แก?
- แแแแแ แ แงแแแแ แฃแกแแคแ แแฎแแแแแก แกแแแแแ แแแ แแ แจแแแแฌแแแแ, แ แแแแแแช แกแแญแแ แแ แฃแกแแคแ แแฎแแแแแก แแแแแขแแแแ? แฒ แแแแกแแช? แ แ แจแแแแแแแ แแแฐแงแแ?
- แแแ แแแแแแแแกแ แแแ แฌแแ แแแแแแจแ? แ แ แแแแแ แแขแฃแแ แแแ แแแแขแ แแแ แแฅแแ แแแแแงแแแแแฃแแ แแแแแแแแแแก แแ แแก?
แขแแขแแจแ
- แกแแแขแ:
- แแแชแแแแแ: แฃแคแแกแ (Apache)

In-toto แแ แแก แฉแแ แฉแ, แ แแแแแแช แจแแฅแแแแแแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแแฌแแแแแแก แแแแแ แฏแแญแแแก แแแแแแแแแแก, แแแแแแขแแคแแแแชแแแกแ แแ แแฃแแแขแแก แฃแแ แฃแแแแแกแแงแแคแแ. In-toto แแแคแ แแกแขแ แฃแฅแขแฃแ แแจแ แแแแแแแแแแกแแก, แฏแแ แแแแแกแแแฆแแ แแแ แแแแแ, แ แแแแแแช แแฆแฌแแ แก แแแแกแแแแแแก แกแฎแแแแแกแฎแแ แกแแคแแฎแฃแ แก (แกแแชแแแ, CI/CD แฎแแแกแแฌแงแแแแ, QA แแแกแขแ แฃแแแแขแแแ, แแ แขแแคแแฅแขแแแแก แจแแแแ แแแแแแแแ แแ แ.แจ.) แแ แแแแฎแแแ แแแแแแก (แแแกแฃแฎแแกแแแแแแ แแแ แแแก), แ แแแแแแกแแช แฃแคแแแแ แแฅแแ แแแแ แแแแชแแ แแแ.
In-toto แแแแแขแ แแแแแก แแแแแแก แจแแกแ แฃแแแแแก, แแแแฌแแแแก, แ แแ แฏแแญแแจแ แแแแแแฃแแ แแแแแแแแ แกแฌแแ แแ แจแแกแ แฃแแแแฃแแแ แแฎแแแแ แแแขแแ แแแแแฃแแ แแแ แกแแแแแแก แแแแ แแ แ แแ แแ แแแแฎแแ แชแแแแแแฃแแ แแ แแแแขแแ แแแแแฃแแ แแแแแแฃแแแชแแแแ แแ แแแฃแฅแขแแแ แแแซแ แแแแแก แแ แแก.
แแแ แขแแแ แแกแ
- แกแแแขแ:
- แแแชแแแแแ: แฃแคแแกแ (Apache)

Portieris แแ แแก Kubernetes-แแก แแแจแแแแแก แแแแขแ แแแแ แ; แแแแแแงแแแแแ แแแแขแแแขแแก แแแแแแก แจแแแแฌแแแแแก แจแแกแแกแ แฃแแแแแแ. Portieris แแงแแแแแก แกแแ แแแ แก (แฉแแแ แแแแแก แแแแฌแแ แแ แแแก แจแแกแแฎแแ - แแแแฎแ. แแแ แแแแแ) แ แแแแ แช แญแแจแแแ แแขแแแแก แฌแงแแ แ แกแแแแ แแ แฎแแแแแฌแแ แแแ แแ แขแแคแแฅแขแแแแก แแแกแแแแกแขแฃแ แแแแแ (แแแฃ แแแแขแแแชแแแฃแแ แแแแขแแแแแ แแก แกแฃแ แแแแแ).
แ แแแแกแแช แกแแแฃแจแแ แแแขแแแ แแแ แแฅแแแแแ แแ แแชแแแแแ Kubernetes-แจแ, Portieris แฉแแแแขแแแ แแแแก แฎแแแแแฌแแ แแก แแแคแแ แแแชแแแก แแ แแแแขแแแขแแก แแแแแแก แแแแแขแแแแก แแแแฎแแแแแแ แแแแขแแแแแ แแก แกแฃแ แแแแแแกแแแแก แแ, แกแแญแแ แแแแแก แจแแแแฎแแแแแจแ, แแขแแ แแแก แชแแแแแแแแแก JSON API แแแแแฅแขแจแ แแ แกแฃแ แแแแแแก แฎแแแแแฌแแ แแแ แแแ แกแแแแแก แแแกแแจแแแแแ.
Vault
- แกแแแขแ:
- แแแชแแแแแ: แฃแคแแกแ (MPL)

Vault แแ แแก แฃแกแแคแ แแฎแ แแแแแฌแงแแแขแ แแแ แแแ แแแคแแ แแแชแแแก แจแแกแแแแฎแแ: แแแ แแแแแ, OAuth แแแจแแแแ, PKI แกแแ แแแคแแแแขแแแ, แฌแแแแแแก แแแแแ แแจแแแ, Kubernetes แกแแแแฃแแแแแแแแ แแ แ.แจ. Vault แแฎแแ แก แฃแญแแ แก แแแแ แแแฌแแแแแ แคแฃแแฅแชแแแก, แ แแแแ แแชแแ แแคแแแแ แฃแแ แฃแกแแคแ แแฎแแแแแก แแแจแแแแแก แแฏแแ แ แแ แแแกแแฆแแแแก แแ แฃแแแแก แแ แแแแแแแแ.
Helm แกแฅแแแแก แแแแแงแแแแแแ, Vault แจแแแซแแแแ แแแแแแแกแแแก แ แแแแ แช แแฎแแแ แแแแแแแแแ Kubernetes แแแแกแขแแ แจแ Consul-แแแ แแ แแแ, แ แแแแ แช backend แกแแชแแแ. แแแ แแฎแแ แก แฃแญแแ แก Kubernetes-แแก แแจแแแแแฃแ แ แแกแฃแ แกแแแก, แ แแแแ แแชแแ ServiceAccount แขแแแแแแแ แแ แจแแฃแซแแแ แแแแฅแแแแแก แ แแแแ แช แแแแฃแแแกแฎแแแแ แแแฆแแแแ Kubernetes แกแแแแฃแแแแแแแกแแแแก.
แฒจแแแแจแแแ. แแแ แแแแ: แกแฎแแแแ แจแแ แแก, แแฃแจแแ แแแแแแแแ HashiCorp-แแ, แ แแแแแแช แแแแแแ แแแก Vault-แก, แแแแแแชแฎแแแ แแแ แแแแฃแแ แแแฃแแฏแแแแกแแแแแ Vault-แแก แแแแแงแแแแแแจแ Kubernetes-แจแ แแ แแแ แซแแ, แแกแแแ แแฎแแแ Helm-แแก แกแฅแแแแก. แฌแแแแแแฎแแ แแแขแ แจแ .
Kubernetes แฃแกแแคแ แแฎแแแแแก แแฃแแแขแ
แแฃแแ-แกแแแแ
- แกแแแขแ:
- แแแชแแแแแ: แฃแคแแกแ (Apache)

Kube-bench แแ แแก Go แแแแแแแชแแ, แ แแแแแแช แแแแฌแแแแก แแ แแก แแฃ แแ แ Kubernetes แฃแกแแคแ แแฎแแ แแแแแแแแแฃแแ แกแแแแแ แขแแกแขแแแแก แแแจแแแแแ .
Kube-bench แแซแแแก แแ แแกแแแแแแ แแแแคแแแฃแ แแชแแแก แแแ แแแแขแ แแแก แแแแกแขแแ แแก แแแแแแแแแขแแแก แจแแ แแก (etcd, API, แแแแขแ แแแแ แแก แแแแแฏแแ แ แแ แ.แจ.), แคแแแแแ แฌแแแแแแก แกแแแญแแ แฃแคแแแแแแ, แแแฃแชแแแแ แแแแแ แแจแแแ แแ แฆแแ แแแ แขแแแ, แ แแกแฃแ แกแแแแก แแแแขแแแ, API แแแ แแแแก แ แแแแแแแแแก แจแแแฆแฃแแแแก แแแ แแแแขแ แแแ DoS แจแแขแแแแแแกแแแ แแแกแแชแแแแ. แแ แ.แจ.
แแฃแแ-แแแแแแแ แ
- แกแแแขแ:
- แแแชแแแแแ: แฃแคแแกแ (Apache)

Kube-hunter แแแแแ แแแก แแแขแแแชแแฃแ แแแฃแชแแแแแแแแแ (แ แแแแ แแชแแ แแแแแก แแแกแขแแแชแแฃแ แ แจแแกแ แฃแแแแ แแ แแแแแชแแแแ แแแแแฆแแแแแแ) Kubernetes แแแแกแขแแ แแแจแ. Kube-hunter แจแแแซแแแแ แแแจแแแแฃแแ แแงแแก แ แแแแ แช แแแกแขแแแชแแฃแ แ แกแแแแแ แ - แแ แจแแแแฎแแแแแจแ แแก แจแแแคแแกแแแก แแแแกแขแแ แก แแแกแแแ แแฎแแ แแก แแแแแแแกแฎแแแแแก แแแแแแแฎแแแแแ - แแ แ แแแแ แช แแแกแแขแฃแ แ แแแแงแแคแแแแแ.
Kube-hunter-แแก แแแแแ แฉแแฃแแ แแแแกแแแแ แแแกแ โแแฅแขแแฃแ แ แแแแแ แแแแกโ แ แแแแแ, แ แแแแแก แแ แแกแแช แแก แแ แ แแฎแแแแ แแชแแแแแแก แแ แแแแแแแแก, แแ แแแแ แชแแแแแแก แแกแแ แแแแแแก แกแแแแแแ แแแแกแขแแ แจแ แแฆแแแฉแแแแแ แแแฃแชแแแแแแแ, แ แแแแช แจแแแซแแแแ แแแแแ แแแแงแแแแก แแแก แแฃแจแแแแแก. แแแแขแแ แแแแแแงแแแแ แกแแคแ แแฎแแแแ!
แแฃแแแแแขแ
- แกแแแขแ:
- แแแชแแแแแ: แฃแคแแกแ (MIT)

Kubeaudit แแ แแก แแแแกแแแแก แฎแแแกแแฌแงแ, แ แแแแแแช แแแแแแแแ แแแแแ แจแแแฅแแแ Shopify-แจแ Kubernetes-แแก แแแแคแแแฃแ แแชแแแก แจแแกแแแแฌแแแแแแ แฃแกแแคแ แแฎแแแแแก แกแฎแแแแแกแฎแแ แกแแแแแฎแแแแ. แแแแแแแแแ, แแก แฎแแแก แฃแฌแงแแแก แแแแขแแแแแ แแแแก แแแแแขแแคแแชแแ แแแแก, แ แแแแแแแช แแฃแจแแแแแ แจแแฃแแฆแฃแแแแแ, แแฃแจแแแแก แ แแแแ แช root, แแแ แแขแแ แแงแแแแแแ แแ แแแแแแแแแแก แแ แแงแแแแแแ แแแแฃแแแกแฎแแแแ ServiceAccount-แก.
Kubeaudit แแฅแแก แกแฎแแ แกแแแแขแแ แแกแ แแแแกแแแแแ. แแแแแแแแแ, แแแก แจแแฃแซแแแ แแแแแแแแแแแก แแแแแแแแ แแแ YAML แคแแแแแแ, แ แแแ แแแแแแแแแก แแแแคแแแฃแ แแชแแแก แฎแแ แแแแแแ, แ แแแแช แจแแแซแแแแ แแแแแแฌแแแแก แฃแกแแคแ แแฎแแแแแก แแ แแแแแแแแ แแ แแแขแแแแขแฃแ แแ แแแแแแกแฌแแ แแก แแกแแแ.
แแฃแแแกแแช
- แกแแแขแ:
- แแแชแแแแแ: แฃแคแแกแ (Apache)

Kubesec แแ แแก แกแแแชแแแแฃแ แ แแแกแขแ แฃแแแแขแ, แ แแแแแแช แแแ แแแแแ แแกแแแแแ แแแก YAML แคแแแแแแก, แ แแแแแแแช แแฆแฌแแ แก Kubernetes แ แแกแฃแ แกแแแก, แแซแแแก แกแฃแกแข แแแ แแแแขแ แแแก, แ แแแแแแแแช แจแแแซแแแแ แแแแแแแ แแแแฎแแแแแก แฃแกแแคแ แแฎแแแแแแ.
แแแแแแแแแ, แแแก แจแแฃแซแแแ แแฆแแแแฉแแแแก pod-แแกแแแแก แแแแแญแแแฃแแ แแแแแญแแ แแแแฃแแ แแ แแแแแแแแแแ แแ แแแแแ แแแแแ, แแแแขแแแแแ แแก แแแจแแแแ root-แแ, แ แแแแ แช แแแแฃแแแกแฎแแแแ แแแแฎแแแ แแแแแ, แแแแแแจแแ แแแ แฐแแกแขแแก แฅแกแแแแก แกแแฎแแแแ แกแแแ แชแแจแ แแ แกแแจแแจแ แกแแแแแขแแแแแแ, แ แแแแ แแชแแ /proc แฐแแกแขแ แแ แแแแแ แแก แกแแแแขแ. Kubesec-แแก แแแแแ แแ แแ แกแแแแขแแ แแกแ แคแฃแแฅแชแแ แแ แแก แแแแแแ แฎแแแแแกแแฌแแแแแ แแแแ แกแแ แแแกแ, แ แแแแแจแแช แจแแแแซแแแแ แแขแแแ แแแ YAML แแ แแแฃแงแแแแแแแแ แแแแแแแแแแแ แแแ.
แแแฎแกแแแแ แแแแแขแแแแก แแแแแขแ
- แกแแแขแ:
- แแแชแแแแแ: แฃแคแแกแ (Apache)

OPA-แก (Open Policy Agent) แแแแชแแคแชแแ แแ แแก แฃแกแแคแ แแฎแแแแแก แแแแแขแแแแกแ แแ แฃแกแแคแ แแฎแแแแแก แกแแฃแแแแแกแ แแ แแฅแขแแแแก แแแแแงแแคแ แแแแแ แแขแฃแแ แแแจแแแแแก แแแแขแคแแ แแแกแแแ: Docker, Kubernetes, Mesosphere, OpenShift แแ แแแแ แแแแแกแแแแ แ แแแแแแแแชแแแ.
แแแแแแแแแ, แจแแแแซแแแแ แแแแแแแแกแแ OPA, แ แแแแ แช แแฃแแแ แแแขแแก แแแจแแแแแก แแแแขแ แแแแ แแก แกแแงแ แแแแ, แฃแกแแคแ แแฎแแแแแก แแแแแฌแงแแแขแแแแแแแแก แแแแแแแ แแแ แแแกแแ. แแ แแแแ, OPA แแแแแขแก แจแแฃแซแแแ แจแแแแแฌแแแก, แฃแแ แงแแก แแ แจแแชแแแแแก แแแแฎแแแแแแ แคแ แแแแก แแ แแก, แ แแช แฃแแ แฃแแแแแงแแคแก แฃแกแแคแ แแฎแแแแแก แแแแแแแแฃแ แแแ แแแแขแ แแแก. OPA-แก แฃแกแแคแ แแฎแแแแแก แแแแแขแแแ แแแฌแแ แแแแ แแแก แกแแแฃแแ แแแแจแ แแ แกแแแฃแ DSL แแแแแ, Rego.
แฒจแแแแจแแแ. แแแ แแแแ: แฉแแแ แแแแฌแแ แแ แแแขแ OPA (แแ SPIFFE) แจแแกแแฎแแ .
แงแแแแแกแแแแชแแแแ แแแแแ แชแแฃแแ แแแกแขแ แฃแแแแขแแแ Kubernetes แฃแกแแคแ แแฎแแแแแก แแแแแแแแกแแแแก
แฉแแแ แแแแแแฌแงแแแขแแ แจแแแแแฅแแแ แชแแแแ แแแขแแแแ แแ แแแแแ แชแแฃแแ แแแแขแคแแ แแแแแกแแแแก, แ แแแแแ แแกแแแ, แ แแแแ แช แฌแแกแ, แแแแชแแแก แฃแกแแคแ แแฎแแแแแก แแ แแแแ แกแคแแ แแก. แแแแ แจแแกแแซแแแแแแแแแแก แแแแแแ แฌแแ แแแแแแแ แจแแแแซแแแแ แแแแฆแแ แชแฎแ แแแแแแ:

* แแแคแแ แแแแแฃแแ แแแแแแแแแแ แแ แกแแแแแแแแก แจแแแแแแแ แแแแแแแ แกแ แฃแแ .
Aqua Security
- แกแแแขแ:
- แแแชแแแแแ: แแแแแ แชแแฃแแ

แแก แแแแแ แชแแฃแแ แแแกแขแ แฃแแแแขแ แแแแแฃแแแแแแแ แแแแขแแแแแ แแแแกแ แแ แฆแ แฃแแแแก แแแขแแแ แแแแกแแแแก. แฒแก แฃแแ แฃแแแแแงแแคแก:
- แแแแแกแแฎแฃแแแแแก แกแแแแแ แแแ แแแขแแแ แแ แแแฃแแ แแแแขแแแแแ แแก แ แแแกแขแ แแแ แแ CI/CD แแแแกแแแแแแแ;
- แแแจแแแแแก แแแชแแ แแแแขแแแแแ แแแจแ แชแแแแแแแแแแกแ แแ แกแฎแแ แกแแแญแแ แแฅแขแแแแแแแแก แซแแแแแ;
- แแแแขแแแแแ แ-แแจแแแแแฃแ แ firewall;
- แฃแกแแคแ แแฎแแแแ แกแแ แแแ แแก แแแ แแจแ แฆแ แฃแแแแแแ แกแแ แแแกแแแจแ;
- แจแแกแแแแแแกแแแแก แขแแกแขแแ แแแ แแ แแฃแแแขแ แจแแ แฌแงแแฃแแแ แแแแแแแแแแก แแฆแ แแชแฎแแแกแแแ.
แฒจแแแแจแแแ. แแแ แแแแ: แแกแแแ แแฆแกแแแแจแแแแแ, แ แแ แแ แกแแแแแแ แแ แแแฃแฅแขแแก แฃแคแแกแ แแแแแแแแแขแ แ.แฌ , แ แแแแแแช แกแแจแฃแแแแแแก แแแซแแแแ แแแแกแแแแแ แแ แแแแขแแแแแ แแก แกแฃแ แแแแแ แแแฃแชแแแแแแแกแแแแก. แแแกแ แจแแกแแซแแแแแแแแแแก แจแแแแ แแแ แคแแกแแแ แแแ แกแแแแแแ แแ แแก แฌแแ แแแแแแแแแ .
แแแคแกแฃแแ 8
- แกแแแขแ:
- แแแชแแแแแ: แแแแแ แชแแฃแแ

Capsule8 แแแขแแแ แแ แแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแจแ แแแขแแฅแขแแ แแก แแแงแแแแแแ แแแแแแแแ แแ แแ แฆแ แฃแแแ Kubernetes แแแแกแขแแ แแ. แแก แแแขแแฅแขแแ แ แแแ แแแแแก แฐแแกแขแแก แแ แฅแกแแแแก แขแแแแแแขแ แแแก, แแแแแจแแ แแแก แแแก แกแฎแแแแแกแฎแแ แขแแแแก แจแแขแแแแแแแ.
Capsule8 แแฃแแแ แแแแแก แแแแชแแแแก แฎแแแแแก แแแแแแกแฎแแแแแก แแแ แแฃแ แแแแแแแแแแกแ แแ แแ แแแแแชแแแก แแฎแแแก แแแแแงแแแแแแ (0-แแฆแแแแ) แกแแกแฃแกแขแแแแ. Capsule8-แก แจแแฃแซแแแ แฃแกแแคแ แแฎแแแแแก แแแแแฎแแแแฃแแ แฌแแกแแแแก แฉแแแแขแแแ แแแ แแแ แแแแแ แแแขแแฅแขแแ แแแแ แแฎแแแ แแฆแแแฉแแแแแ แกแแคแ แแฎแแแแแกแ แแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แฎแแ แแแแแแแก แกแแแแกแฃแฎแแ.
แแแแแ แแแ
- แกแแแขแ:
- แแแชแแแแแ: แแแแแ แชแแฃแแ

Cavirin แแแฅแแแแแแก แ แแแแ แช แแแแแแแแแก แแฎแ แแแแ แแแแขแ แแฅแขแแ แ แฃแกแแคแ แแฎแแแแแก แกแขแแแแแ แขแแแจแ แฉแแ แแฃแแ แกแฎแแแแแกแฎแแ แกแแแแแแขแแกแแแแก. แแแก แแ แ แแฎแแแแ แจแแฃแซแแแ แกแฃแ แแแแแแก แกแแแแแ แแแ, แแ แแแแ แจแแฃแซแแแ แแแขแแแ แแ แแแ CI/CD แแแแกแแแแแจแ, แแแแแแแแก แแ แแกแขแแแแแ แขแฃแแ แกแฃแ แแแแแ, แกแแแแ แแกแแแ แแแฎแฃแ แฃแ แกแแชแแแแแจแ แแแฎแแแแแแแ.
Cavirin-แแก แฃแกแแคแ แแฎแแแแแก แแแแแแแฅแขแ แแงแแแแแก แแแแฅแแแฃแ แกแฌแแแแแแแก แแฅแแแแ แแแแแ แฃแกแแคแ แแฎแแแแแก แแแแแก แจแแกแแคแแกแแแแแ, แแแแแแแแแ แ แฉแแแแแก แฃแกแแคแ แแฎแแแแแก แแแกแแฃแแฏแแแแกแแแแแ แแ แฃแกแแคแ แแฎแแแแแก แกแขแแแแแ แขแแแแแ แจแแกแแแแแแกแแแแก แแแกแแฃแแฏแแแแกแแแแแ.
Google Cloud Security Command Center
- แกแแแขแ:
- แแแชแแแแแ: แแแแแ แชแแฃแแ

Cloud Security Command Center แแฎแแแ แแแ แฃแกแแคแ แแฎแแแแแก แแฃแแแแแก แแแแแชแแแแแแก แจแแแ แแแแแแจแ, แกแแคแ แแฎแแแแแก แแแแแขแแคแแชแแ แแแแจแ แแ แแแ แแฆแแแคแฎแแ แแจแ, แกแแแแ แแกแแแ แแแแแแแแแ แแแแแแแแแก.
แ แแแแ แช แกแแฎแแแ แแแแแแแแแแก, Google Cloud SCC แแ แแก แแ แแแแแ แแแ แแแแก แแแแแแ, แ แแแแแกแแช แจแแฃแซแแแ แแแแแ แแแแแแก แแ แแแ แแแก แกแฎแแแแแกแฎแแ แฃแกแแคแ แแฎแแแแแก แแแแแ แแจแแแ, แแฅแขแแแแแแก แแฆแ แแชแฎแแแก แซแ แแแแแ แแ แแแกแแแ แแฎแแ แแก แฃแกแแคแ แแฎแแแแแก แกแแกแขแแแแแ แแ แแ, แชแแแขแ แแแแแแแฃแแ แฌแงแแ แแแแ.
Google Cloud SCC-แแก แแแแ แจแแแแแแแแแแแฃแแ แแแแกแแแแแ API แแแแแแแแแก แฃแกแแคแ แแฎแแแแแก แฆแแแแกแซแแแแแแแก แแแขแแแ แแ แแแแก, แ แแแแแแแช แแแแแก แกแฎแแแแแกแฎแแ แฌแงแแ แแแแ, แ แแแแ แแชแแ Sysdig Secure (แแแแขแแแแแ แแก แฃแกแแคแ แแฎแแแแ แฆแ แฃแแแแแแแ แแแแแแแชแแแแแกแแแแก) แแ Falco (แฆแแ แแแแแก แแแจแแแแแก แแ แแแก แฃแกแแคแ แแฎแแแแ).
แคแแแแแแ แแแกแแแแ (Qualys)
- แกแแแขแ:
- แแแชแแแแแ: แแแแแ แชแแฃแแ

Layered Insight (แแแแแแแ Qualys Inc-แแก แแแฌแแแ) แแแแแฃแแแ โแฉแแจแแแแแฃแแ แฃแกแแคแ แแฎแแแแแกโ แแแแชแแคแชแแแแ. แแแแแแแแ แแแแ แกแฃแ แแแแก แแแฃแชแแแแแแแก แกแแแแแ แแแแก แจแแแแแ, แกแขแแขแแกแขแแแฃแ แ แแแแแแแแกแ แแ CVE แจแแแแฌแแแแแก แแแแแงแแแแแแ, Layered Insight แชแแแแก แแแก แแแกแขแ แฃแแแแขแแ แแแฃแแ แกแฃแ แแแแ, แ แแแแแแช แแแแชแแแก แแแแแขแก, แ แแแแ แช แแแแแ แก.
แแก แแแแแขแ แจแแแชแแแก แแแจแแแแแก แฃแกแแคแ แแฎแแแแแก แขแแกแขแแแก แแแแขแแแแแ แแก แฅแกแแแแก แขแ แแคแแแแก, I/O แแแแแแแแแก แแ แแแแแแแชแแแก แแฅแขแแแแแแก แแแกแแแแแแแแแแแแ. แแแ แแ แแแแกแ, แแแก แจแแฃแซแแแ แแแแแฎแแ แชแแแแแก แฃแกแแคแ แแฎแแแแแก แแแแแขแแแแแ แจแแแแฌแแแแแแ, แ แแแแแแแช แแแแแแแแฃแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแแแแแแกแขแ แแขแแ แแก แแ DevOps แแฃแแแแแแก แแแแ .
NeuVector
- แกแแแขแ:
- แแแชแแแแแ: แแแแแ แชแแฃแแ

NeuVector แแแแฌแแแแก แแแแขแแแแแ แแก แฃแกแแคแ แแฎแแแแแก แแ แฃแแ แฃแแแแแงแแคแก แแแจแแแแแก แแแชแแแก แฅแกแแแแก แแฅแขแแแแแแกแ แแ แแแแแแแชแแแก แฅแชแแแแก แแแแแแแแ, แแแแแแฃแแ แแแแขแแแแแ แแกแแแแก แฃแกแแคแ แแฎแแแแแก แแแแแแแแฃแแแฃแ แ แแ แแคแแแแก แจแแฅแแแแ. แแแก แแกแแแ แจแแฃแซแแแ แแแแแฃแแแแแแแแ แแแแแแแแก แกแแคแ แแฎแแแแ, แกแแแญแแ แแฅแขแแแแแแก แแแแแแ แแแ แแแแแแแแ แแแ firewall แฌแแกแแแแก แจแแชแแแแ.
NeuVector-แแก แฅแกแแแฃแ แแแขแแแ แแชแแแก, แ แแแแแแช แชแแแแแแแ แ แแแแ แช Security Mesh, แจแแฃแซแแแ แฆแ แแ แแแแแขแแก แแแแแแแ แแ 7 แคแแแแก แแแคแแแขแแ แ แกแแ แแแกแแก แฅแกแแแจแ แแ แกแแแฃแแ แงแแแแ แฅแกแแแฃแ แ แแแแจแแ แแกแแแแก.
แกแขแแแ แแฅแกแ
- แกแแแขแ:
- แแแชแแแแแ: แแแแแ แชแแฃแแ

StackRox แแแแขแแแแแ แแก แฃแกแแคแ แแฎแแแแแก แแแแขแคแแ แแ แชแแแแแแก แแแคแแ แแก Kubernetes-แแก แแแแแแแชแแแแแก แแแแแ แกแแกแแชแแชแฎแแ แชแแแแ แแแแกแขแแ แจแ. แแ แกแแแจแ แกแฎแแ แแแแแ แชแแฃแแ แแแแขแคแแ แแแแแก แแกแแแแกแแ, StackRox แแฌแแ แแแแแก แแแจแแแแแก แแ แแคแแแก แแแแแแ แแแแฃแแ แแแแขแแแแแ แแก แฅแชแแแแก แกแแคแฃแซแแแแแ แแ แแแขแแแแขแฃแ แแ แแงแแแแแก แกแแแแแแแแแชแแแก แแแแแกแแแแ แ แแแแแฎแ แแก แจแแกแแฎแแ.
แแแ แแ แแแแกแ, StackRox แแแแแแแแแแก Kubernetes-แแก แแแแคแแแฃแ แแชแแแแก Kubernetes CIS แแ แกแฎแแ แฌแแกแแแแก แแแแแงแแแแแแ, แ แแแ แจแแแคแแกแแก แแแแขแแแแแ แแก แจแแกแแแแแแกแแแ.
Sysdig Secure
- แกแแแขแ:
- แแแชแแแแแ: แแแแแ แชแแฃแแ

Sysdig Secure แแชแแแก แแแแแแแชแแแแก แแแแแ แแแแขแแแแแ แแกแ แแ Kubernetes-แแก แกแแกแแชแแชแฎแแ แชแแแแแก แแแแแแแแแแแจแ. แแก แแแแขแแแแแ แแแ, แฃแแ แฃแแแแแงแแคแก แแแแฅแแแแแแชแแแแแแแแก แแแแแชแแแแแแก แแแฎแแแแแ, แแกแ แฃแแแแก แแ แแแก. แแฅแกแแแ แขแแแ แแแฌแงแแแแแแแแก แแแแแขแแคแแชแแ แแแแกแแแแก, แกแแคแ แแฎแแแแแก แแแแแแ แแแแกแแแแก, แแแแแขแแ แแแแกแแแแก แแ แแฃแแแขแแก แกแแฅแแแแแแแแก แแแแ แแกแแ แแแกแแแจแ.
Sysdig Secure แแแขแแแ แแ แแแแ CI/CD แแแกแขแ แฃแแแแขแแแแแ, แ แแแแ แแชแแ Jenkins แแ แแแแแขแ แแแแแก Docker-แแก แ แแแกแขแ แแแแ แแแขแแแ แแฃแ แกแฃแ แแแแแก, แ แแช แฎแแแก แฃแจแแแก แกแแฎแแคแแแ แกแฃแ แแแแแแก แฌแแ แแแแแแจแ แแแแแฉแแแแก. แแก แแกแแแ แฃแแ แฃแแแแแงแแคแก แงแแแแแกแแแแชแแแ แฃแกแแคแ แแฎแแแแแก, แแแ แจแแ แแก:
- ML-แแ แแแคแฃแซแแแแฃแแ แแแจแแแแแก แแ แแแก แแ แแคแแแแ แแแ แแ แแแแแแแแแแแก แแแแแแแแแ;
- แแแจแแแแแก แแแแแขแแแ, แ แแแแแแช แแแคแฃแซแแแแฃแแแ แกแแกแขแแแแก แแแแแแแแแแ, K8s-แแฃแแแขแแก API-แแ, แแ แแแแแแแ แกแแแแแ แแ แแแฅแขแแแแ (FIM - แคแแแแแแแก แแแแแแแแแแก แแแแแขแแ แแแแ; แแ แแแขแแฏแแแแแแ) แแ แฉแแ แฉแ ;
- แ แแแแแ แแแ แแ แแแชแแแแแขแแแแก แแแแแแ แแแ.
แแแแซแแ แแแแขแแแแแ แแก แฃแกแแคแ แแฎแแแแ
- แกแแแขแ:
- แแแชแแแแแ: แแแแแ แชแแฃแแ

แแแแขแแแแแ แแแแก แแแแแฉแแแแแแ, Tenable แคแแ แแแ แแงแ แชแแแแแแ แแแแฃแกแขแ แแแจแ, แ แแแแ แช แแแแแแแแ Nessus-แแก แฃแแแ, แแแฃแชแแแแแแแแ แแแแแ แแแแกแ แแ แฃแกแแคแ แแฎแแแแแก แแฃแแแขแแก แแแแฃแแแ แฃแแ แแแกแขแ แฃแแแแขแ.
Tenable Container Security แแงแแแแแก แแแแแแแแแก แแแแแแฃแขแแ แฃแแ แฃแกแแคแ แแฎแแแแแก แแฅแกแแแ แขแแแแก CI/CD แแแแกแแแแแแก แแแฃแชแแแแแแแก แแแแแชแแแแ แแแแแแแแ, แแแแแ แแ แแแ แแแแแแก แแฆแแแฉแแแแก แกแแแชแแแแแแแแฃแ แแแแแขแแแแแ แแ แฃแกแแคแ แแฎแแแแแก แกแแคแ แแฎแแแแแก แแแแแกแแญแ แแแแ แ แแแแแแแแแชแแแแแแ แแแขแแแ แแ แแแแกแแแแก.
Twistlock (Palo Alto Networks)
- แกแแแขแ:
- แแแชแแแแแ: แแแแแ แชแแฃแแ

Twistlock แแแแก แแแ แชแแแแแก, แ แแแแ แช แแแแขแคแแ แแแก, แ แแแแแแช แแ แแแแขแแ แแแฃแแแ แฆแ แฃแแแแแแ แกแแ แแแกแแแกแ แแ แแแแขแแแแแ แแแแ. Twistlock แแฎแแ แก แฃแญแแ แก แกแฎแแแแแกแฎแแ แฆแ แฃแแแแแแ แแ แแแแแแแ แแแก (AWS, Azure, GCP), แแแแขแแแแแ แแแแก แแ แแแกแขแ แแขแแ แแแก (Kubernetes, Mesospehere, OpenShift, Docker), แกแแ แแแ แแก แแแ แแจแ แแแจแแแแแก, mesh frames แแ CI/CD แแแกแขแ แฃแแแแขแแแก.
แแแ แแ แฉแแแฃแแแแ แแแ แกแแฌแแ แแแก แแแแแก แฃแกแแคแ แแฎแแแแแก แขแแฅแแแแแกแ, แ แแแแ แแชแแ CI/CD แแแแกแแแแแแก แแแขแแแ แแชแแ แแ แแแแแกแแฎแฃแแแแแก แกแแแแแ แแแ, Twistlock แแงแแแแแก แแแแฅแแแฃแ แกแฌแแแแแแแก แแแแขแแแแแ แแกแแแแก แกแแแชแแคแแแฃแ แ แฅแชแแแแแ แจแแแแแแแแแกแ แแ แฅแกแแแแก แฌแแกแแแแก แจแแกแแฅแแแแแแ.
แ แแแแแแแแ แฎแแแก แฌแแ Twistlock แแงแแแ Palo Alto Networks-แแ, แ แแแแแแช แคแแแแก Evident.io แแ RedLock แแ แแแฅแขแแแก. แฏแแ แฏแแ แแแแ แฃแชแแแแแ, แแแแแ แแขแฃแแแ แ แแแแ แแฅแแแแ แแก แกแแแ แแแแขแคแแ แแแก แแแขแแแ แแ แแแ แแแแ แแแขแแแแ.
แแแแฎแแแ แแ Kubernetes-แแก แฃแกแแคแ แแฎแแแแแก แแแกแขแ แฃแแแแขแแแแก แกแแฃแแแแแกแ แแแขแแแแแแก แจแแฅแแแแก!
แฉแแแ แแชแแแแแแ, แ แแ แแก แแแขแแแแแ แแแฅแกแแแแแฃแ แแ แกแ แฃแแงแแคแแแ แแแแฎแแแแ แแ แแแแกแแแแก แแฅแแแแ แแแฎแแแ แแแ แแแญแแ แแแแ! แฒแแแแแแแแจแแ แแแ () แแฃ แแฅแแแ แแแฅแแ แแฎแแแแแแแแแจแ แแแแแ แ แแแกแขแ แฃแแแแขแ, แ แแแแแแช แแแกแแฎแฃแ แแแก แแ แกแแแจแ แฉแแ แแแแก, แแ แแฆแแแแฉแแแ แจแแชแแแแแก/แแแซแแแแแแฃแ แแแคแแ แแแชแแแก.
แแฅแแแ แแกแแแ แจแแแแซแแแแ แแแแแแฌแแ แแ แฉแแแแ แแฎแแแ แแแแแแแ แฆแ แฃแแแแ แแจแแแแแฃแ แ แแแแกแแกแขแแแแแแ แแ แแกแขแแ แแแแแ แกแแแแขแแ แแกแ แแ แแแฅแขแแแแก แจแแกแแฎแแ Kubernetes แฃแกแแคแ แแฎแแแแแก แกแแแงแแ แแแแ.
PS แแแแ แแแแแแแกแแแ
แแกแแแ แฌแแแแแแฎแแ แฉแแแแก แแแแแแ:
- ยซ";
- ยซ";
- ยซ";
- ยซ";
- ยซ".
แฌแงแแ แ: www.habr.com
