แฒจแแแแจแแแ. แแแ แแแแ: แแฃ แแแแแขแแ แแกแแแ Kubernetes-แแ แแแคแฃแซแแแแฃแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แฃแกแแคแ แแฎแแแแ, Sysdig-แแก แแก แจแแกแแแแจแแแแ แแแแแฎแแแแ แจแแกแแแแจแแแแ แกแแฌแงแแกแ แฌแแ แขแแแแ แแแแแแแแ แ แแแแแฌแงแแแขแแแแแแแแก แกแฌแ แแคแ แแแแแฎแแแแแกแแแแก. แแแ แแแแชแแแก แ แแแแ แช แแแแแแแฅแกแฃแ แกแแกแขแแแแแก แแแแ แแก แชแแแแแแ แแแแแแแจแแแแแกแแแ, แแกแแแ แแแแ แแ แฃแคแ แ แแแแ แซแแแแแฃแ แแแแฃแแแแฃแ แแแแแแแแแแก, แ แแแแแแแช แฌแงแแแขแแ แแแแแ แแขแฃแ แแ แแแแแแแก. แแ แแแแแแขแแ แแแจแ, แ แแแแ แช แงแแแแแแแแก, แแแฎแแ แฃแแ แแแฅแแแแแ แแแแแกแแแแแ แแฅแแแแ แแแแแชแแแแแแแก แจแแกแแฎแแ แแ แแแกแขแ แฃแแแแขแแแแก แแแแแงแแแแแแก แจแแกแแฎแแ แแ แแแแฎแแ แกแฎแแ แแ แแแฅแขแแแแก แแแฃแแแแ.
Kubernetes-แแก แฃแกแแคแ แแฎแแแแแก แแ แแแ แแแฃแแ แแ แแแฃแฅแขแแแ... แซแแแแแ แแแแ แ แแแแแแแแ, แแแแแแฃแแก แแฅแแก แกแแแฃแแแ แ แแแแแแแ, แคแแ แแแแแ แแ แแแชแแแแแแแ.
แกแฌแแ แแ แแแแขแแ แแแแแแฌแงแแแขแแ แจแแแแแฅแแแ แแก แกแแ แแ แจแแแแแขแแแ แ แแแแ แช แฆแแ แแแแแก แแ แแแฅแขแแแ, แแกแแแ แแแแแ แชแแฃแแ แแแแขแคแแ แแแแ แกแฎแแแแแกแฎแแ แแแแฌแแแแแแแแแกแแแ. แแแแแแแแแแแ, แ แแ แแก แแแแแฎแแแ แแแแ แแแแแขแแคแแชแแ แแ แแก, แแแแช แงแแแแแแ แกแแแแขแแ แแกแแ แแ แแแแแแแแแ แกแฌแแ แ แแแแแ แแฃแแแแแ แแฅแแแแ แแแแแ แแขแฃแแ Kubernetes แฃแกแแคแ แแฎแแแแแก แกแแญแแ แแแแแแแ แแแแแแแแแแ แ.
แแแขแแแแ แแ
แกแแแจแ แแแแแแแชแแแก แแแกแแแแแแแแแแแ, แแแกแขแ แฃแแแแขแแแ แแ แแแแแแแแฃแแแ แซแแ แแแแแ แคแฃแแฅแชแแแกแ แแ แแแแแแแชแแแก แแแฎแแแแแ. แแแแฆแแก แจแแแแแแ แกแแฅแชแแแแ:
- Kubernetes แแแแแกแแฎแฃแแแแแก แกแแแแแ แแแ แแ แกแขแแขแแแฃแ แ แแแแแแแ;
- แแแจแแแแแก แฃแกแแคแ แแฎแแแแ;
- Kubernetes แฅแกแแแแก แฃแกแแคแ แแฎแแแแ;
- แแแแแกแแฎแฃแแแแแก แแแแแฌแแแแแ แแ แกแแแแฃแแแแแแแก แแแ แแแ;
- Kubernetes แฃแกแแคแ แแฎแแแแแก แแฃแแแขแ;
- แงแแแแแกแแแแชแแแแ แแแแแ แชแแฃแแ แแ แแแฃแฅแขแแแ.
แแแแแ แแแแแแแแแ แกแแฅแแแแ:
Kubernetes แกแฃแ แแแแแแก แกแแแแแ แแแ
แฌแแแงแแแแ
- แกแแแขแ:
anchore.com - แแแชแแแแแ: แฃแคแแกแ (Apache) แแ แแแแแ แชแแฃแแ แจแแแแแแแแแ
Anchore แแแแแแแแแแก แแแแขแแแแแ แแแแก แกแฃแ แแแแแก แแ แฃแจแแแแก แฃแกแแคแ แแฎแแแแแก แจแแแแฌแแแแแก แแแแฎแแแ แแแแแก แแแแ แแแแกแแแฆแแ แฃแ แแแแแขแแแแแ แแแงแ แแแแแแ.
แแแ แแ แแแแขแแแแแ แแก แกแฃแ แแแแแแก แฉแแแฃแแแแ แแแ แกแแแแแ แแแแกแ แชแแแแแแ แแแฃแชแแแแแแแกแแแแก CVE แแแแแชแแแแ แแแแแแแ, Anchore แแฎแแ แชแแแแแแก แแแแ แแแแแขแแแแ แจแแแแฌแแแแแก, แ แแแแ แช แแแกแ แกแแแแแ แแแแก แแแแแขแแแแก แแแฌแแแ: แแแแฌแแแแก Dockerfile-แก, แ แฌแแฃแแแแแแ แกแแแแแแแแก แแแแแแแแก, แแแแแงแแแแแฃแแ แแ แแแ แแแแ แแแแก แแแแแแก แแแแแขแแแก (npm, maven แแ แ.แจ. .), แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแแชแแแแแแแ แแ แแ แแแแแ แกแฎแแ.
แฌแแแแแ
- แกแแแขแ:
coreos.com/clair (แแฎแแ Red Hat-แแก แแแฃแ แแแแแแก แฅแแแจ) - แแแชแแแแแ: แฃแคแแกแ (Apache)
Clair แแงแ แแ แ-แแ แแ แแแ แแแแ แฆแแ แแแแแก แแ แแแฅแขแ แแแแแกแแฎแฃแแแแแก แกแแแแแ แแแแกแแแแก. แแแ แคแแ แแแ แแ แแก แชแแแแแแ, แ แแแแ แช แฃแกแแคแ แแฎแแแแแก แกแแแแแ แ Quay แแแแแกแแฎแฃแแแแแก แ แแแกแขแ แแก แฃแแแ (แแกแแแ CoreOS-แแแ - แแแแฎแ. แแแ แแแแแ). Clair-แก แจแแฃแซแแแ แจแแแแ แแแแก CVE แแแคแแ แแแชแแ แแ แแแแแคแแ แแแแแ แฌแงแแ แแแแ, แแแ แจแแ แแก Linux-แแก แแแแแฌแแแแแแก แกแแแชแแคแแแฃแ แ แแแฃแชแแแแแแแก แกแแแแแก แฉแแแแแแ, แ แแแแแแแช แแแแฎแแแ Debian, Red Hat แแ Ubuntu แฃแกแแคแ แแฎแแแแแก แแฃแแแแแแก แแแแ .
Anchore-แแกแแแ แแแแกแฎแแแแแแแ, Clair แฃแแแ แแแแแก แงแแแแแกแ แงแฃแ แแแฆแแแแก แแแแฎแแแแแแก แแแฌแงแแแแแแแแก แแแแแแแ แแ แแแแแชแแแแแแก CVE-แแแแแ แจแแกแแแแแแกแแแแจแ. แแฃแแชแ, แแ แแแฃแฅแขแ แแแแฎแแแ แแแแแแก แกแแแแแแแแก แคแฃแแฅแชแแแแแก แแแคแแ แแแแแแก แจแแกแแซแแแแแแแแแก แแแแแแแขแแก แแ แแแแแ แแแแก แแแแแงแแแแแแ.
แแแแแ
- แกแแแขแ:
github.com/eliasgranderubio/dagda - แแแชแแแแแ: แฃแคแแกแ (Apache)
Dagda แแฎแแ แชแแแแแแก แแแแขแแแแแ แแก แกแฃแ แแแแแแก แกแขแแขแแแฃแ แแแแแแแก แชแแแแแแ แแแฃแชแแแแแแแก, แขแ แแแกแแแแก, แแแ แฃแกแแแแก, แแแแแ แแ แแแ แแแแแแกแ แแ แกแฎแแ แกแแคแ แแฎแแแแแกแแแแก.
แแ แ แแแแจแแแแแแแแแ แแแฎแแกแแแแแแแแ แแแแแกแฎแแแแแแก แแแแแแก แกแฎแแ แแกแแแแกแ แฎแแแกแแฌแงแแแแแกแแแ:
- แแก แแแแแแฃแ แแ แแแ แแแแแแแก
ClamAV , แแแฅแแแแแแก แแ แ แแฎแแแแ แ แแแแ แช แแแกแขแ แฃแแแแขแ แแแแขแแแแแ แแก แกแฃแ แแแแแแก แกแแแแแ แแแแกแแแแก, แแ แแแแ แ แแแแ แช แแแขแแแแ แฃแกแ. - แแกแแแ แฃแแ แฃแแแแแงแแคแก แแแจแแแแแก แแแชแแแก Docker-แแก แแแแแแแกแแแ แ แแแแฃแ แแ แแจแ แแแแแแแแแแก แแแฆแแแแ แแ Falco-แกแแแ แแแขแแแ แแ แแแแ (แแฎแแแแ แฅแแแแแ) แฃแกแแคแ แแฎแแแแแก แแแแแแแแแแก แจแแแ แแแแแ แแแแขแแแแแ แแก แแฃแจแแแแแกแแก.
KubeXray
- แกแแแขแ:
github.com/jfrog/kubexray - แแแชแแแแแ: แฃแคแแกแ (Apache), แแแแ แแ แแแแแฎแแแก แแแแแชแแแแแก JFrog Xray-แแแ (แแแแแ แชแแฃแแ แแ แแแฃแฅแขแ)
KubeXray แฃแกแแแแก แแแแแแแแแก Kubernetes API แกแแ แแแ แแแแ แแ แแงแแแแแก แแแขแแแแแแชแแแแแก JFrog Xray-แแแ, แ แแแ แฃแแ แฃแแแแแงแแก แแฎแแแแ แแแแแแแแแแแ แฌแแกแแแแก แจแแกแแแแแแกแ แแแแแแแก แแแจแแแแ.
KubeXray แแ แ แแฎแแแแ แแแแฌแแแแก แแฎแแ แแ แแแแแฎแแแแฃแ แแแแขแแแแแ แแแก แแแแแแแแแแกแแก (แแกแแแแกแ แแแจแแแแแก แแแแขแ แแแแ แ Kubernetes-แจแ), แแ แแแแ แแแแแแแฃแ แแ แแแแฌแแแแก แแแจแแแแฃแ แแแแขแแแแแ แแแก แฃแกแแคแ แแฎแแแแแก แแฎแแ แแแแแขแแแแแแแ แจแแกแแแแแแกแแแแจแ, แฌแแจแแแก แ แแกแฃแ แกแแแก, แ แแแแแแแช แแแฃแแแแแแแ แแแฃแชแแแ แกแฃแ แแแแแแ.
แกแแแแ
- แกแแแขแ:
snyk.io - แแแชแแแแแ: แฃแคแแกแ (Apache) แแ แแแแแ แชแแฃแแ แแแ แกแแแแ
Snyk แแ แแก แแ แแฉแแแฃแแแแ แแแ แแแฃแชแแแแแแแก แกแแแแแ แ, แ แแแแแ แแก แแแแแ แแขแฃแแแ แแแแแแ แแกแแฎแแแก แแแแแแแแ แแแแก แแ แแชแแกแก แแ แแแฌแแแแฃแ แแแฃแแแ, แ แแแแ แช "แแ แกแแแแแ แแแแแฌแงแแแขแ" แแแแแแแแแ แแแแกแแแแก.
Snyk แแแ แแแแแ แแแแแจแแ แแแก แแแแแก แกแแชแแแแแก, แแแแแแแแแแก แแ แแแฅแขแแก แแแแแคแแกแขแก แแ แแแแแแแแแแก แแแแแ แขแแ แแแฃแ แแแแก แแแ แแแแแ แแ แแ แแแแ แแแแแ แแแแแแแแแแฃแแแแแแแแ แแ แแแ. Snyk แแฎแแ แก แฃแญแแ แก แแแแ แแแแฃแแแ แฃแ แแ แแแ แแแแ แแแแก แแแแก แแ แจแแฃแซแแแ แคแแ แฃแแ แแแชแแแแแแก แ แแกแแแแแก แแแแแขแแคแแชแแ แแแ.
แฌแแ แแแแแแ
- แกแแแขแ:
github.com/knqyf263/trivy - แแแชแแแแแ: แฃแคแแกแ (AGPL)
Trivy แแ แแก แแแ แขแแแ, แแแแ แแ แซแแแแ แ แแแฃแชแแแแแแแก แกแแแแแ แ แแแแขแแแแแ แแแแกแแแแก, แ แแแแแแช แแแแแแแ แแแขแแแ แแ แแแแ CI/CD แแแแกแแแแแจแ. แแแกแ แแฆแกแแแแจแแแแ แแแฎแแกแแแแแแแแแ แแแกแขแแแแชแแแกแ แแ แแฃแจแแแแแก แกแแแแ แขแแแ: แแแแแแแชแแ แจแแแแแแ แแ แแ แแ แแแแแแกแแแแ แแ แแ แกแแญแแ แแแแก แแแแแชแแแแ แแแแแก แแ แแแแแขแแแแ แแแแแแแแแแแแแก แแแกแขแแแแชแแแก.
Trivy-แแก แกแแแแ แขแแแแก แแแแฃแกแ แแ แแก แแก, แ แแ แแฅแแแ แฃแแแ แแแแ แแแแแ, แ แแแแ แแแแแแแแแแแ แแ แแแแแแแแแแแแ แจแแแแแแแ JSON แคแแ แแแขแจแ, แ แแแ Kubernetes-แแก แฃแกแแคแ แแฎแแแแแก แกแฎแแ แแแกแขแ แฃแแแแขแแแแ แแแแแแงแแแแ แแกแแแ.
Runtime แฃแกแแคแ แแฎแแแแ Kubernetes-แจแ
Falco
- แกแแแขแ:
falco.org - แแแชแแแแแ: แฃแคแแกแ (Apache)
Falco แแ แแก แแแกแขแ แฃแแแแขแแแแก แแแแ แแแ แฆแ แฃแแแแแแแ แแแจแแแแแก แแแ แแแแก แฃแแ แฃแแแแแกแแงแแคแแ. แแ แแแฅแขแแก แแฏแแฎแแก แแแฌแแแ
Sysdig-แแก Linux-แแก แแแ แแแแก แแแแแก แแแกแขแ แฃแแแแขแแแแกแ แแ แกแแกแขแแแฃแ แ แแแ แแก แแ แแคแแแแ แแแแก แแแแแงแแแแแแ, Falco แแแซแแแแ แกแแจแฃแแแแแแก แฆแ แแแ แฉแแงแแแแแแ แกแแกแขแแแแก แฅแชแแแแจแ. แแแกแ แแแจแแแแแก แฌแแกแแแแก แซแ แแแแก แจแแฃแซแแแ แกแแแญแแ แแฅแขแแแแแแก แแฆแแแฉแแแ แแแแแแแชแแแแจแ, แแแแขแแแแแ แแแจแ, แซแแ แแแแ แฐแแกแขแกแ แแ Kubernetes-แแก แแ แแแกแขแ แแขแแ แจแ.
Falco แฃแแ แฃแแแแแงแแคแก แกแ แฃแ แแแแญแแแ แแแแแแแก แแฃแจแแแแแก แแ แแก แแ แกแแคแ แแฎแแก แแแแแแแแแแจแ แแ แแแแแแแแกแแแแแก Kubernetes-แแก แแแแแซแแแแ แกแแแชแแแแฃแ แ แแแแแขแแแแก แแแแแแแแแแ. แจแแแแแแ, แแ แแ แแก แกแแญแแ แ แแแแขแแแแแ แแแแก แจแแชแแแ แแแแจแ แแแกแแแ แแฎแแ แแก แแแแแก แจแแงแแแแแ แแ แแแแ แแแแ แแแ แแก แแแแขแแแแแ แแแแก แแแแแขแแแแ.
Linux แฃแกแแคแ แแฎแแแแแก แฉแแ แฉแแแแ แแแจแแแแแกแแแแก
Linux-แแก แแแ แแแแก แแก แแจแแแแแฃแ แ แฉแแ แฉแแแแ แแ แแ แแก โKubernetes แฃแกแแคแ แแฎแแแแแก แแแกแขแ แฃแแแแขแแแโ แขแ แแแแชแแฃแแ แแแแแแแ, แแแแ แแ แแแแ แแฆแแแจแแแ แฆแแ แก, แ แแแแแ แแกแแแ แแแแจแแแแแแแแแ แแแแแแแขแแ แแแจแแแแแก แฃแกแแคแ แแฎแแแแแก แแแแขแแฅแกแขแจแ, แ แแแแแแช แจแแแแก Kubernetes Pod แฃแกแแคแ แแฎแแแแแก แแแแแขแแแแจแ (PSP).
แฃแกแแคแ แแฎแแแแแก แแแซแแแแ แแแฃแแ Linux (
Sysdig แฆแแ แฌแงแแ แ
- แกแแแขแ:
www.sysdig.com/opensource - แแแชแแแแแ: แฃแคแแกแ (Apache)
Sysdig แแ แแก แกแ แฃแแ แแแกแขแ แฃแแแแขแ Linux แกแแกแขแแแแแแก แแแแแแแแก, แแแแแแแกแขแแแแกแ แแ แแแแแ แแแแกแแแแก (แแกแแแ แแฃแจแแแแก Windows-แแ แแ macOS-แแ, แแแแ แแ แจแแแฆแฃแแฃแแ แคแฃแแฅแชแแแแแ). แแก แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แแแขแแแฃแ แ แแแคแแ แแแชแแแก แจแแแ แแแแแแก, แแแแแแแฌแแแแแกแ แแ แกแแกแแแแ แแแ แแแแแแแแกแแแแก. (แแ แแแแแแแแกแขแแแ) แแแแแก แกแแกแขแแแ แแ แแแกแแ แแแจแแแแฃแแ แแแแแกแแแแ แ แแแแขแแแแแ แ.
Sysdig แแกแแแ แแฎแแ แก แฃแญแแ แก แแแแขแแแแแ แแแแก แแแจแแแแแก แแ Kubernetes แแแขแแแแแแชแแแแแก, แแแแขแแแก แแแแแขแแแแ แแแแแแแแแแแแแก แแ แแขแแแแขแแแก แกแแกแขแแแแก แฅแชแแแแก แงแแแแ แแแคแแ แแแชแแแก, แ แแแแแแช แแแ แแแแแก. แแฃแแแ แแแขแแก แแแแกแขแแ แแก แแแแแแแแก แ แแแแแแแแ แแแ แแ แกแแแแแก Sysdig-แแก แแแแแงแแแแแแ: แจแแแแซแแแแ แจแแแกแ แฃแแแ แแ แแจแ แแแแแฆแแแ
Kubernetes แฅแกแแแแก แฃแกแแคแ แแฎแแแแ
แแแแ แแขแ
- แกแแแขแ:
www.aporeto.com - แแแชแแแแแ: แแแแแ แชแแฃแแ
Aporeto แแแแแแแแแ "แฃแกแแคแ แแฎแแแแแก แฅแกแแแแแแ แแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแกแแแ แแแแชแแแแแแแแฃแแ". แแก แแแจแแแแก, แ แแ Kubernetes แกแแ แแแกแแแ แแฆแแแแ แแ แ แแฎแแแแ แแแแแแฃแ ID-แก (แแแฃ ServiceAccount-แจแ Kubernetes-แจแ), แแ แแแแ แฃแแแแแ แกแแแฃแ ID/แแแแแก แแแแแแญแแก, แ แแแแแแช แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แฃแกแแคแ แแฎแแ แแ แฃแ แแแแ แแแแแแแจแแ แแแฃแแแ แแแแแกแแแแ แกแฎแแ แกแแ แแแกแแแ, แแแแแแแแแ OpenShift แแแแกแขแแ แจแ.
Aporeto-แก แจแแฃแซแแแ แจแแฅแแแแก แฃแแแแแแฃแ แ ID แแ แ แแฎแแแแ Kubernetes/แแแแขแแแแแ แแแแกแแแแก, แแ แแแแ แฐแแกแขแแแแกแแแแก, แฆแ แฃแแแแแแแ แคแฃแแฅแชแแแแแกแแแแก แแ แแแแฎแแแ แแแแแแแกแแแแก. แแ แแแแแขแแคแแแแขแแ แแแแแแ แแ แแแแแแแกแขแ แแขแแ แแก แแแแ แแแแแแแแแ แฅแกแแแแก แฃแกแแคแ แแฎแแแแแก แฌแแกแแแแก แแแแ แแแแแแ แแแแแแแแแแ แ, แแแแฃแแแแแชแแแแ แแแแจแแแแ แแ แแแแแแแแแแ.
แแแแแแ
- แกแแแขแ:
www.projectcalico.org - แแแชแแแแแ: แฃแคแแกแ (Apache)
Calico แฉแแแฃแแแแ แแ แแแแแแแแแฃแแแ แแแแขแแแแแ แแแแก แแ แแแกแขแ แแขแแ แแก แแแกแขแแแแชแแแก แแ แแก, แ แแช แกแแจแฃแแแแแแก แแแซแแแแ แจแแฅแแแแ แแแ แขแฃแแแฃแ แ แฅแกแแแ, แ แแแแแแช แแ แแแแแแแแแ แแแแแจแแ แแแก แแแแขแแแแแ แแแก. แฅแกแแแแก แแ แซแแ แแแแแ แคแฃแแฅแชแแแก แแแ แแ, Calico แแ แแแฅแขแ แแฃแจแแแแก Kubernetes Network Policies-แแแ แแ แฅแกแแแแก แฃแกแแคแ แแฎแแแแแก แแ แแคแแแแแแก แกแแแฃแแแ แแแแแแแฅแขแแแ, แแฎแแ แก แฃแญแแ แก แแแแ แฌแแ แขแแแแแแก ACL-แแแก (แฌแแแแแแก แแแแขแ แแแแก แกแแแแก) แแ แแแแขแแชแแแแ แแแคแฃแซแแแแฃแ แฅแกแแแแก แฃแกแแคแ แแฎแแแแแก แฌแแกแแแก Ingress แแ Egress แขแ แแคแแแแกแแแแก.
แชแแแแฃแแ
- แกแแแขแ:
www.cilium.io - แแแชแแแแแ: แฃแคแแกแ (Apache)
Cilium แแแฅแแแแแแก แ แแแแ แช แแแแขแแแแแ แแแแก แแฃแฎแแ แ แแ แฃแแ แฃแแแแแงแแคแก แฅแกแแแแก แฃแกแแคแ แแฎแแแแแก แคแฃแแฅแชแแแแก, แ แแแแแแแช แแแ แแแแฃแแแ Kubernetes-แแกแ แแ แแแแ แแกแแ แแแกแแแแก แแแขแแแ แแแแแ. Cilium แแงแแแแแก Linux-แแก แแแ แแแแก แแฎแแ แขแแฅแแแแแแแแก, แกแแฎแแแฌแแแแแแ BPF (Berkeley Packet Filter) แแแแแชแแแแแแก แแแคแแแขแแ แแกแแแแก, แแแแแขแแ แแแแแกแแแแก, แแแแแแแกแแแแ แแแแแกแแแแก แแ แแแ แแฅแขแแ แแแแกแแแแก.
Cilium-แก แจแแฃแซแแแ แแแแแแแแกแแก แฅแกแแแจแ แฌแแแแแแก แแแแแขแแแ แแแแขแแแแแ แแแแก ID-แแแแ แแแคแฃแซแแแแฃแแ Docker แแ Kubernetes แแขแแแแขแแแแกแ แแ แแแขแแแแแแชแแแแแแก แแแแแงแแแแแแ. Cilium แแกแแแ แแกแแแก แแ แคแแแขแ แแแก แกแฎแแแแแกแฎแแ แคแแแแก แแ แแขแแแแแแแก, แ แแแแ แแชแแ HTTP แแ gRPC, แ แแช แกแแจแฃแแแแแแก แแแซแแแแ แแแแกแแแฆแแ แแ REST แแแ แแแแก แแแแ แแแ, แ แแแแแแช แแแจแแแแฃแแ แแฅแแแแ, แแแแแแแแแ, Kubernetes-แแก แแ แแแแแแแแแแก แจแแ แแก.
แแกแขแแ
- แกแแแขแ:
istio.io - แแแชแแแแแ: แฃแคแแกแ (Apache)
Istio แคแแ แแแ แแ แแก แชแแแแแแ แกแแ แแแกแแก แฅแกแแแแก แแแ แแแแแแแก แแแแแ แแแแ แแแแขแคแแ แแแกแแแ แแแแแฃแแแแแแแแ แกแแแแแขแ แแแ แกแแแ แขแงแแก แแแแแแแแแแ แแ แงแแแแ แแแ แแฃแแ แกแแ แแแกแแก แขแ แแคแแแแก แแแ แจแ แฃแขแแ แแแแแแแฃแ แแ แแแแคแแแฃแ แแ แแแแแ Envoy แแ แแฅแกแแแแแก แแแจแแแแแแ. Istio แแงแแแแแก แงแแแแ แแแแ แแกแแ แแแกแแกแ แแ แแแแขแแแแแ แแแแก แแ แแแฌแแแแแ แฎแแแก แฅแกแแแแก แฃแกแแคแ แแฎแแแแแก แกแฎแแแแแกแฎแแ แกแขแ แแขแแแแแก แแแแกแแฎแแ แชแแแแแแแแ.
Istio-แก แฅแกแแแแก แฃแกแแคแ แแฎแแแแแก แจแแกแแซแแแแแแแแแ แแแแชแแแก แแแแญแแแ แแแแ TLS แแแจแแคแแ แแก แแแแ แแกแแ แแแกแแแก แจแแ แแก แแแแฃแแแแแชแแแแแก แแแขแแแแขแฃแ แแ แแแแแฎแแแแแกแแแแก HTTPS-แแแ แแ RBAC แแแแแขแแคแแแแชแแแกแ แแ แแแขแแ แแแแชแแแก แกแแแฃแแ แแแแจแ แแ แกแแแฃแ แกแแกแขแแแแก แแแแกแขแแ แจแ แกแฎแแแแแกแฎแแ แแแขแแแ แแแแก แจแแ แแก แแแแฃแแแแแชแแแก แแแกแแจแแแแแ/แฃแแ แกแแงแแคแแ.
แฒจแแแแจแแแ. แแแ แแแแ: Istio-แก แฃแกแแคแ แแฎแแแแแแ แแ แแแแขแแ แแแฃแแ แจแแกแแซแแแแแแแแแแก แจแแกแแฎแแ แแแขแ แแแคแแ แแแชแแแกแแแแก แฌแแแแแแฎแแ
แแแคแฎแแ
- แกแแแขแ:
www.tigera.io - แแแชแแแแแ: แแแแแ แชแแฃแแ
"Kubernetes Firewall"-แก แฃแฌแแแแแแ, แแก แแแแแกแแแแแ แฎแแแก แฃแกแแแแก แฅแกแแแแก แฃแกแแคแ แแฎแแแแแก แแฃแแแแแแ แแแแแแก แแแแแแแแก.
Kubernetes-แแก แกแฎแแ แแจแแแแแฃแ แ แฅแกแแแฃแ แ แแแแแฌแงแแแขแแแแแแแแก แแกแแแแกแแ, Tigera แแงแ แแแแแ แแแขแแแแแแชแแแแแก แแแแกแขแแ แจแ แกแฎแแแแแกแฎแแ แกแแ แแแกแแแแกแ แแ แแแแแฅแขแแแแก แแแแแขแแคแแชแแ แแแแกแแแแก แแ แฃแแ แฃแแแแแงแแคแก แกแแแฃแจแแ แแ แแแก แแ แแแแแแแแแก แแแแชแแแแแก, แจแแกแแแแแแกแแแแก แแฃแแแแ แจแแแแฌแแแแแก แแ แฅแกแแแแก แฎแแแแแแแแแก แแ แแแแ แฆแ แฃแแแแแแแ แแ แฐแแแ แแแฃแแ แแแแแแแแฃแ แ แแแแขแแแแแ แแ แแแฃแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแกแแแแก.
แขแ แแ แแแ
- แกแแแขแ:
www.aporeto.com/opensource - แแแชแแแแแ: แฃแคแแกแ (Apache)
Trireme-Kubernetes แแ แแก Kubernetes แฅแกแแแแก แแแแแขแแแแก แกแแแชแแคแแแแชแแแก แแแ แขแแแ แแ แแแ แแแแแ แ แแแแฎแแ แชแแแแแแ. แงแแแแแแ แจแแกแแแฉแแแแ แแแแกแแแ แแก แแ แแก, แ แแ - แแแแกแฎแแแแแแแ Kubernetes-แแก แแกแแแแกแ แฅแกแแแแก แฃแกแแคแ แแฎแแแแแก แแ แแแฃแฅแขแแแแกแแแ - แแแก แแ แกแญแแ แแแแ แชแแแขแ แแแฃแ แ แแแแขแ แแแแก แแแแแแคแ แแแแแ แฅแกแแแแก แแแแ แแแแแชแแแกแแแแก. แแก แฎแแแก แแแแแกแแแแแก แขแ แแแแแแฃแ แแ แแแกแจแขแแแฃแ แก. Trireme-แจแ แแก แแแแฆแฌแแแ แแแแแขแแก แแแงแแแแแแ แแแแแแฃแ แแแแแซแแ, แ แแแแแแช แแแ แแแแแ แฃแแ แแแแแ แฐแแกแขแแก TCP/IP แกแขแแแก.
แแแแแกแแฎแฃแแแแแก แแแแ แชแแแแแ แแ แกแแแแฃแแแแแแแก แแแ แแแ
แแ แแคแแแ
- แกแแแขแ:
grafeas.io - แแแชแแแแแ: แฃแคแแกแ (Apache)
Grafeas แแ แแก แฆแแ แแแแแก API แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแแฌแแแแแแก แฏแแญแแแก แแฃแแแขแแกแ แแ แแแ แแแแกแแแแก. แกแแแแแแกแ แแแแแแ, Grafeas แแ แแก แแแกแขแ แฃแแแแขแ แแแขแแแแแแชแแแแแแก แจแแแ แแแแแแกแ แแ แแฃแแแขแแก แแแกแแแแแแแกแแแแก. แแก แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แแ แแแแแแแชแแแก แจแแแแแ แฃแกแแคแ แแฎแแแแแก แกแแฃแแแแแกแ แแ แแฅแขแแแแกแแแ แจแแกแแแแแแกแแแแก แแแแแงแฃแ แแก แแแแแแแแกแแแแก.
แญแแจแแแ แแขแแแแก แแก แชแแแขแ แแแแแแแฃแแ แฌแงแแ แ แแแแแฎแแแ แแแแ แฃแแแกแฃแฎแแ แแแแฎแแแแก, แ แแแแ แแชแแ:
- แแแ แจแแแแ แแแ แแ แแแแฌแแ แ แฎแแแ แแแแแ แแขแฃแ แแแแขแแแแแ แก?
- แแแแแ แ แงแแแแ แฃแกแแคแ แแฎแแแแแก แกแแแแแ แแแ แแ แจแแแแฌแแแแ, แ แแแแแแช แกแแญแแ แแ แฃแกแแคแ แแฎแแแแแก แแแแแขแแแแ? แฒ แแแแกแแช? แ แ แจแแแแแแแ แแแฐแงแแ?
- แแแ แแแแแแแแกแ แแแ แฌแแ แแแแแแจแ? แ แ แแแแแ แแขแฃแแ แแแ แแแแขแ แแแ แแฅแแ แแแแแงแแแแแฃแแ แแแแแแแแแแก แแ แแก?
แขแแขแแจแ
- แกแแแขแ:
in-toto.github.io - แแแชแแแแแ: แฃแคแแกแ (Apache)
In-toto แแ แแก แฉแแ แฉแ, แ แแแแแแช แจแแฅแแแแแแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแแฌแแแแแแก แแแแแ แฏแแญแแแก แแแแแแแแแแก, แแแแแแขแแคแแแแชแแแกแ แแ แแฃแแแขแแก แฃแแ แฃแแแแแกแแงแแคแแ. In-toto แแแคแ แแกแขแ แฃแฅแขแฃแ แแจแ แแแแแแแแแแกแแก, แฏแแ แแแแแกแแแฆแแ แแแ แแแแแ, แ แแแแแแช แแฆแฌแแ แก แแแแกแแแแแแก แกแฎแแแแแกแฎแแ แกแแคแแฎแฃแ แก (แกแแชแแแ, CI/CD แฎแแแกแแฌแงแแแแ, QA แแแกแขแ แฃแแแแขแแแ, แแ แขแแคแแฅแขแแแแก แจแแแแ แแแแแแแแ แแ แ.แจ.) แแ แแแแฎแแแ แแแแแแก (แแแกแฃแฎแแกแแแแแแ แแแ แแแก), แ แแแแแแกแแช แฃแคแแแแ แแฅแแ แแแแ แแแแชแแ แแแ.
In-toto แแแแแขแ แแแแแก แแแแแแก แจแแกแ แฃแแแแแก, แแแแฌแแแแก, แ แแ แฏแแญแแจแ แแแแแแฃแแ แแแแแแแแ แกแฌแแ แแ แจแแกแ แฃแแแแฃแแแ แแฎแแแแ แแแขแแ แแแแแฃแแ แแแ แกแแแแแแก แแแแ แแ แ แแ แแ แแแแฎแแ แชแแแแแแฃแแ แแ แแแแขแแ แแแแแฃแแ แแแแแแฃแแแชแแแแ แแ แแแฃแฅแขแแแ แแแซแ แแแแแก แแ แแก.
แแแ แขแแแ แแกแ
- แกแแแขแ:
github.com/IBM/portieris - แแแชแแแแแ: แฃแคแแกแ (Apache)
Portieris แแ แแก Kubernetes-แแก แแแจแแแแแก แแแแขแ แแแแ แ; แแแแแแงแแแแแ แแแแขแแแขแแก แแแแแแก แจแแแแฌแแแแแก แจแแกแแกแ แฃแแแแแแ. Portieris แแงแแแแแก แกแแ แแแ แก
แ แแแแกแแช แกแแแฃแจแแ แแแขแแแ แแแ แแฅแแแแแ แแ แแชแแแแแ Kubernetes-แจแ, Portieris แฉแแแแขแแแ แแแแก แฎแแแแแฌแแ แแก แแแคแแ แแแชแแแก แแ แแแแขแแแขแแก แแแแแแก แแแแแขแแแแก แแแแฎแแแแแแ แแแแขแแแแแ แแก แกแฃแ แแแแแแกแแแแก แแ, แกแแญแแ แแแแแก แจแแแแฎแแแแแจแ, แแขแแ แแแก แชแแแแแแแแแก JSON API แแแแแฅแขแจแ แแ แกแฃแ แแแแแแก แฎแแแแแฌแแ แแแ แแแ แกแแแแแก แแแกแแจแแแแแ.
Vault
- แกแแแขแ:
www.vaultproject.io - แแแชแแแแแ: แฃแคแแกแ (MPL)
Vault แแ แแก แฃแกแแคแ แแฎแ แแแแแฌแงแแแขแ แแแ แแแ แแแคแแ แแแชแแแก แจแแกแแแแฎแแ: แแแ แแแแแ, OAuth แแแจแแแแ, PKI แกแแ แแแคแแแแขแแแ, แฌแแแแแแก แแแแแ แแจแแแ, Kubernetes แกแแแแฃแแแแแแแแ แแ แ.แจ. Vault แแฎแแ แก แฃแญแแ แก แแแแ แแแฌแแแแแ แคแฃแแฅแชแแแก, แ แแแแ แแชแแ แแคแแแแ แฃแแ แฃแกแแคแ แแฎแแแแแก แแแจแแแแแก แแฏแแ แ แแ แแแกแแฆแแแแก แแ แฃแแแแก แแ แแแแแแแแ.
Helm แกแฅแแแแก แแแแแงแแแแแแ, Vault แจแแแซแแแแ แแแแแแแกแแแก แ แแแแ แช แแฎแแแ แแแแแแแแแ Kubernetes แแแแกแขแแ แจแ Consul-แแแ แแ แแแ, แ แแแแ แช backend แกแแชแแแ. แแแ แแฎแแ แก แฃแญแแ แก Kubernetes-แแก แแจแแแแแฃแ แ แแกแฃแ แกแแแก, แ แแแแ แแชแแ ServiceAccount แขแแแแแแแ แแ แจแแฃแซแแแ แแแแฅแแแแแก แ แแแแ แช แแแแฃแแแกแฎแแแแ แแแฆแแแแ Kubernetes แกแแแแฃแแแแแแแกแแแแก.
แฒจแแแแจแแแ. แแแ แแแแ: แกแฎแแแแ แจแแ แแก, แแฃแจแแ แแแแแแแแ HashiCorp-แแ, แ แแแแแแช แแแแแแ แแแก Vault-แก, แแแแแแชแฎแแแ แแแ แแแแฃแแ แแแฃแแฏแแแแกแแแแแ Vault-แแก แแแแแงแแแแแแจแ Kubernetes-แจแ แแ แแแ แซแแ, แแกแแแ แแฎแแแ Helm-แแก แกแฅแแแแก. แฌแแแแแแฎแแ แแแขแ แจแ
Kubernetes แฃแกแแคแ แแฎแแแแแก แแฃแแแขแ
แแฃแแ-แกแแแแ
- แกแแแขแ:
github.com/aquasecurity/kube-bench - แแแชแแแแแ: แฃแคแแกแ (Apache)
Kube-bench แแ แแก Go แแแแแแแชแแ, แ แแแแแแช แแแแฌแแแแก แแ แแก แแฃ แแ แ Kubernetes แฃแกแแคแ แแฎแแ แแแแแแแแแฃแแ แกแแแแแ แขแแกแขแแแแก แแแจแแแแแ
Kube-bench แแซแแแก แแ แแกแแแแแแ แแแแคแแแฃแ แแชแแแก แแแ แแแแขแ แแแก แแแแกแขแแ แแก แแแแแแแแแขแแแก แจแแ แแก (etcd, API, แแแแขแ แแแแ แแก แแแแแฏแแ แ แแ แ.แจ.), แคแแแแแ แฌแแแแแแก แกแแแญแแ แฃแคแแแแแแ, แแแฃแชแแแแ แแแแแ แแจแแแ แแ แฆแแ แแแ แขแแแ, แ แแกแฃแ แกแแแแก แแแแขแแแ, API แแแ แแแแก แ แแแแแแแแแก แจแแแฆแฃแแแแก แแแ แแแแขแ แแแ DoS แจแแขแแแแแแกแแแ แแแกแแชแแแแ. แแ แ.แจ.
แแฃแแ-แแแแแแแ แ
- แกแแแขแ:
github.com/aquasecurity/kube-hunter - แแแชแแแแแ: แฃแคแแกแ (Apache)
Kube-hunter แแแแแ แแแก แแแขแแแชแแฃแ แแแฃแชแแแแแแแแแ (แ แแแแ แแชแแ แแแแแก แแแกแขแแแชแแฃแ แ แจแแกแ แฃแแแแ แแ แแแแแชแแแแ แแแแแฆแแแแแแ) Kubernetes แแแแกแขแแ แแแจแ. Kube-hunter แจแแแซแแแแ แแแจแแแแฃแแ แแงแแก แ แแแแ แช แแแกแขแแแชแแฃแ แ แกแแแแแ แ - แแ แจแแแแฎแแแแแจแ แแก แจแแแคแแกแแแก แแแแกแขแแ แก แแแกแแแ แแฎแแ แแก แแแแแแแกแฎแแแแแก แแแแแแแฎแแแแแ - แแ แ แแแแ แช แแแกแแขแฃแ แ แแแแงแแคแแแแแ.
Kube-hunter-แแก แแแแแ แฉแแฃแแ แแแแกแแแแ แแแกแ โแแฅแขแแฃแ แ แแแแแ แแแแกโ แ แแแแแ, แ แแแแแก แแ แแกแแช แแก แแ แ แแฎแแแแ แแชแแแแแแก แแ แแแแแแแแก, แแ แแแแ แชแแแแแแก แแกแแ แแแแแแก แกแแแแแแ แแแแกแขแแ แจแ แแฆแแแฉแแแแแ แแแฃแชแแแแแแแ, แ แแแแช แจแแแซแแแแ แแแแแ แแแแงแแแแก แแแก แแฃแจแแแแแก. แแแแขแแ แแแแแแงแแแแ แกแแคแ แแฎแแแแ!
แแฃแแแแแขแ
- แกแแแขแ:
github.com/Shopify/kubeaudit - แแแชแแแแแ: แฃแคแแกแ (MIT)
Kubeaudit แแ แแก แแแแกแแแแก แฎแแแกแแฌแงแ, แ แแแแแแช แแแแแแแแ แแแแแ แจแแแฅแแแ Shopify-แจแ Kubernetes-แแก แแแแคแแแฃแ แแชแแแก แจแแกแแแแฌแแแแแแ แฃแกแแคแ แแฎแแแแแก แกแฎแแแแแกแฎแแ แกแแแแแฎแแแแ. แแแแแแแแแ, แแก แฎแแแก แฃแฌแงแแแก แแแแขแแแแแ แแแแก แแแแแขแแคแแชแแ แแแแก, แ แแแแแแแช แแฃแจแแแแแ แจแแฃแแฆแฃแแแแแ, แแฃแจแแแแก แ แแแแ แช root, แแแ แแขแแ แแงแแแแแแ แแ แแแแแแแแแแก แแ แแงแแแแแแ แแแแฃแแแกแฎแแแแ ServiceAccount-แก.
Kubeaudit แแฅแแก แกแฎแแ แกแแแแขแแ แแกแ แแแแกแแแแแ. แแแแแแแแแ, แแแก แจแแฃแซแแแ แแแแแแแแแแแก แแแแแแแแ แแแ YAML แคแแแแแแ, แ แแแ แแแแแแแแแก แแแแคแแแฃแ แแชแแแก แฎแแ แแแแแแ, แ แแแแช แจแแแซแแแแ แแแแแแฌแแแแก แฃแกแแคแ แแฎแแแแแก แแ แแแแแแแแ แแ แแแขแแแแขแฃแ แแ แแแแแแกแฌแแ แแก แแกแแแ.
แแฃแแแกแแช
- แกแแแขแ:
kubesec.io - แแแชแแแแแ: แฃแคแแกแ (Apache)
Kubesec แแ แแก แกแแแชแแแแฃแ แ แแแกแขแ แฃแแแแขแ, แ แแแแแแช แแแ แแแแแ แแกแแแแแ แแแก YAML แคแแแแแแก, แ แแแแแแแช แแฆแฌแแ แก Kubernetes แ แแกแฃแ แกแแแก, แแซแแแก แกแฃแกแข แแแ แแแแขแ แแแก, แ แแแแแแแแช แจแแแซแแแแ แแแแแแแ แแแแฎแแแแแก แฃแกแแคแ แแฎแแแแแแ.
แแแแแแแแแ, แแแก แจแแฃแซแแแ แแฆแแแแฉแแแแก pod-แแกแแแแก แแแแแญแแแฃแแ แแแแแญแแ แแแแฃแแ แแ แแแแแแแแแแ แแ แแแแแ แแแแแ, แแแแขแแแแแ แแก แแแจแแแแ root-แแ, แ แแแแ แช แแแแฃแแแกแฎแแแแ แแแแฎแแแ แแแแแ, แแแแแแจแแ แแแ แฐแแกแขแแก แฅแกแแแแก แกแแฎแแแแ แกแแแ แชแแจแ แแ แกแแจแแจแ แกแแแแแขแแแแแแ, แ แแแแ แแชแแ /proc
แฐแแกแขแ แแ แแแแแ แแก แกแแแแขแ. Kubesec-แแก แแแแแ แแ แแ แกแแแแขแแ แแกแ แคแฃแแฅแชแแ แแ แแก แแแแแแ แฎแแแแแกแแฌแแแแแ แแแแ แกแแ แแแกแ, แ แแแแแจแแช แจแแแแซแแแแ แแขแแแ แแแ YAML แแ แแแฃแงแแแแแแแแ แแแแแแแแแแแ แแแ.
แแแฎแกแแแแ แแแแแขแแแแก แแแแแขแ
- แกแแแขแ:
www.openpolicyagent.org - แแแชแแแแแ: แฃแคแแกแ (Apache)
OPA-แก (Open Policy Agent) แแแแชแแคแชแแ แแ แแก แฃแกแแคแ แแฎแแแแแก แแแแแขแแแแกแ แแ แฃแกแแคแ แแฎแแแแแก แกแแฃแแแแแกแ แแ แแฅแขแแแแก แแแแแงแแคแ แแแแแ แแขแฃแแ แแแจแแแแแก แแแแขแคแแ แแแกแแแ: Docker, Kubernetes, Mesosphere, OpenShift แแ แแแแ แแแแแกแแแแ แ แแแแแแแแชแแแ.
แแแแแแแแแ, แจแแแแซแแแแ แแแแแแแแกแแ OPA, แ แแแแ แช แแฃแแแ แแแขแแก แแแจแแแแแก แแแแขแ แแแแ แแก แกแแงแ แแแแ, แฃแกแแคแ แแฎแแแแแก แแแแแฌแงแแแขแแแแแแแแก แแแแแแแ แแแ แแแกแแ. แแ แแแแ, OPA แแแแแขแก แจแแฃแซแแแ แจแแแแแฌแแแก, แฃแแ แงแแก แแ แจแแชแแแแแก แแแแฎแแแแแแ แคแ แแแแก แแ แแก, แ แแช แฃแแ แฃแแแแแงแแคแก แฃแกแแคแ แแฎแแแแแก แแแแแแแแฃแ แแแ แแแแขแ แแแก. OPA-แก แฃแกแแคแ แแฎแแแแแก แแแแแขแแแ แแแฌแแ แแแแ แแแก แกแแแฃแแ แแแแจแ แแ แกแแแฃแ DSL แแแแแ, Rego.
แฒจแแแแจแแแ. แแแ แแแแ: แฉแแแ แแแแฌแแ แแ แแแขแ OPA (แแ SPIFFE) แจแแกแแฎแแ
แงแแแแแกแแแแชแแแแ แแแแแ แชแแฃแแ แแแกแขแ แฃแแแแขแแแ Kubernetes แฃแกแแคแ แแฎแแแแแก แแแแแแแแกแแแแก
แฉแแแ แแแแแแฌแงแแแขแแ แจแแแแแฅแแแ แชแแแแ แแแขแแแแ แแ แแแแแ แชแแฃแแ แแแแขแคแแ แแแแแกแแแแก, แ แแแแแ แแกแแแ, แ แแแแ แช แฌแแกแ, แแแแชแแแก แฃแกแแคแ แแฎแแแแแก แแ แแแแ แกแคแแ แแก. แแแแ แจแแกแแซแแแแแแแแแแก แแแแแแ แฌแแ แแแแแแแ แจแแแแซแแแแ แแแแฆแแ แชแฎแ แแแแแแ:
* แแแคแแ แแแแแฃแแ แแแแแแแแแแ แแ แกแแแแแแแแก แจแแแแแแแ แแแแแแแ แกแ แฃแแ
Aqua Security
- แกแแแขแ:
www.aquasec.com - แแแชแแแแแ: แแแแแ แชแแฃแแ
แแก แแแแแ แชแแฃแแ แแแกแขแ แฃแแแแขแ แแแแแฃแแแแแแแ แแแแขแแแแแ แแแแกแ แแ แฆแ แฃแแแแก แแแขแแแ แแแแกแแแแก. แฒแก แฃแแ แฃแแแแแงแแคแก:
- แแแแแกแแฎแฃแแแแแก แกแแแแแ แแแ แแแขแแแ แแ แแแฃแแ แแแแขแแแแแ แแก แ แแแกแขแ แแแ แแ CI/CD แแแแกแแแแแแแ;
- แแแจแแแแแก แแแชแแ แแแแขแแแแแ แแแจแ แชแแแแแแแแแแกแ แแ แกแฎแแ แกแแแญแแ แแฅแขแแแแแแแแก แซแแแแแ;
- แแแแขแแแแแ แ-แแจแแแแแฃแ แ firewall;
- แฃแกแแคแ แแฎแแแแ แกแแ แแแ แแก แแแ แแจแ แฆแ แฃแแแแแแ แกแแ แแแกแแแจแ;
- แจแแกแแแแแแกแแแแก แขแแกแขแแ แแแ แแ แแฃแแแขแ แจแแ แฌแงแแฃแแแ แแแแแแแแแแก แแฆแ แแชแฎแแแกแแแ.
แฒจแแแแจแแแ. แแแ แแแแ: แแกแแแ แแฆแกแแแแจแแแแแ, แ แแ แแ แกแแแแแแ แแ แแแฃแฅแขแแก แฃแคแแกแ แแแแแแแแแขแ แ.แฌ
แแแคแกแฃแแ 8
- แกแแแขแ:
capsule8.com - แแแชแแแแแ: แแแแแ แชแแฃแแ
Capsule8 แแแขแแแ แแ แแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแจแ แแแขแแฅแขแแ แแก แแแงแแแแแแ แแแแแแแแ แแ แแ แฆแ แฃแแแ Kubernetes แแแแกแขแแ แแ. แแก แแแขแแฅแขแแ แ แแแ แแแแแก แฐแแกแขแแก แแ แฅแกแแแแก แขแแแแแแขแ แแแก, แแแแแจแแ แแแก แแแก แกแฎแแแแแกแฎแแ แขแแแแก แจแแขแแแแแแแ.
Capsule8 แแฃแแแ แแแแแก แแแแชแแแแก แฎแแแแแก แแแแแแกแฎแแแแแก แแแ แแฃแ แแแแแแแแแแกแ แแ แแ แแแแแชแแแก แแฎแแแก แแแแแงแแแแแแ (0-แแฆแแแแ) แกแแกแฃแกแขแแแแ. Capsule8-แก แจแแฃแซแแแ แฃแกแแคแ แแฎแแแแแก แแแแแฎแแแแฃแแ แฌแแกแแแแก แฉแแแแขแแแ แแแ แแแ แแแแแ แแแขแแฅแขแแ แแแแ แแฎแแแ แแฆแแแฉแแแแแ แกแแคแ แแฎแแแแแกแ แแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แฎแแ แแแแแแแก แกแแแแกแฃแฎแแ.
แแแแแ แแแ
- แกแแแขแ:
www.cavirin.com - แแแชแแแแแ: แแแแแ แชแแฃแแ
Cavirin แแแฅแแแแแแก แ แแแแ แช แแแแแแแแแก แแฎแ แแแแ แแแแขแ แแฅแขแแ แ แฃแกแแคแ แแฎแแแแแก แกแขแแแแแ แขแแแจแ แฉแแ แแฃแแ แกแฎแแแแแกแฎแแ แกแแแแแแขแแกแแแแก. แแแก แแ แ แแฎแแแแ แจแแฃแซแแแ แกแฃแ แแแแแแก แกแแแแแ แแแ, แแ แแแแ แจแแฃแซแแแ แแแขแแแ แแ แแแ CI/CD แแแแกแแแแแจแ, แแแแแแแแก แแ แแกแขแแแแแ แขแฃแแ แกแฃแ แแแแแ, แกแแแแ แแกแแแ แแแฎแฃแ แฃแ แกแแชแแแแแจแ แแแฎแแแแแแแ.
Cavirin-แแก แฃแกแแคแ แแฎแแแแแก แแแแแแแฅแขแ แแงแแแแแก แแแแฅแแแฃแ แกแฌแแแแแแแก แแฅแแแแ แแแแแ แฃแกแแคแ แแฎแแแแแก แแแแแก แจแแกแแคแแกแแแแแ, แแแแแแแแแ แ แฉแแแแแก แฃแกแแคแ แแฎแแแแแก แแแกแแฃแแฏแแแแกแแแแแ แแ แฃแกแแคแ แแฎแแแแแก แกแขแแแแแ แขแแแแแ แจแแกแแแแแแกแแแแก แแแกแแฃแแฏแแแแกแแแแแ.
Google Cloud Security Command Center
- แกแแแขแ:
cloud.google.com/security-command-center - แแแชแแแแแ: แแแแแ แชแแฃแแ
Cloud Security Command Center แแฎแแแ แแแ แฃแกแแคแ แแฎแแแแแก แแฃแแแแแก แแแแแชแแแแแแก แจแแแ แแแแแแจแ, แกแแคแ แแฎแแแแแก แแแแแขแแคแแชแแ แแแแจแ แแ แแแ แแฆแแแคแฎแแ แแจแ, แกแแแแ แแกแแแ แแแแแแแแแ แแแแแแแแแก.
แ แแแแ แช แกแแฎแแแ แแแแแแแแแแก, Google Cloud SCC แแ แแก แแ แแแแแ แแแ แแแแก แแแแแแ, แ แแแแแกแแช แจแแฃแซแแแ แแแแแ แแแแแแก แแ แแแ แแแก แกแฎแแแแแกแฎแแ แฃแกแแคแ แแฎแแแแแก แแแแแ แแจแแแ, แแฅแขแแแแแแก แแฆแ แแชแฎแแแก แซแ แแแแแ แแ แแแกแแแ แแฎแแ แแก แฃแกแแคแ แแฎแแแแแก แกแแกแขแแแแแ แแ แแ, แชแแแขแ แแแแแแแฃแแ แฌแงแแ แแแแ.
Google Cloud SCC-แแก แแแแ แจแแแแแแแแแแแฃแแ แแแแกแแแแแ API แแแแแแแแแก แฃแกแแคแ แแฎแแแแแก แฆแแแแกแซแแแแแแแก แแแขแแแ แแ แแแแก, แ แแแแแแแช แแแแแก แกแฎแแแแแกแฎแแ แฌแงแแ แแแแ, แ แแแแ แแชแแ Sysdig Secure (แแแแขแแแแแ แแก แฃแกแแคแ แแฎแแแแ แฆแ แฃแแแแแแแ แแแแแแแชแแแแแกแแแแก) แแ Falco (แฆแแ แแแแแก แแแจแแแแแก แแ แแแก แฃแกแแคแ แแฎแแแแ).
แคแแแแแแ แแแกแแแแ (Qualys)
- แกแแแขแ:
layeredinsight.com - แแแชแแแแแ: แแแแแ แชแแฃแแ
Layered Insight (แแแแแแแ Qualys Inc-แแก แแแฌแแแ) แแแแแฃแแแ โแฉแแจแแแแแฃแแ แฃแกแแคแ แแฎแแแแแกโ แแแแชแแคแชแแแแ. แแแแแแแแ แแแแ แกแฃแ แแแแก แแแฃแชแแแแแแแก แกแแแแแ แแแแก แจแแแแแ, แกแขแแขแแกแขแแแฃแ แ แแแแแแแแกแ แแ CVE แจแแแแฌแแแแแก แแแแแงแแแแแแ, Layered Insight แชแแแแก แแแก แแแกแขแ แฃแแแแขแแ แแแฃแแ แกแฃแ แแแแ, แ แแแแแแช แแแแชแแแก แแแแแขแก, แ แแแแ แช แแแแแ แก.
แแก แแแแแขแ แจแแแชแแแก แแแจแแแแแก แฃแกแแคแ แแฎแแแแแก แขแแกแขแแแก แแแแขแแแแแ แแก แฅแกแแแแก แขแ แแคแแแแก, I/O แแแแแแแแแก แแ แแแแแแแชแแแก แแฅแขแแแแแแก แแแกแแแแแแแแแแแแ. แแแ แแ แแแแกแ, แแแก แจแแฃแซแแแ แแแแแฎแแ แชแแแแแก แฃแกแแคแ แแฎแแแแแก แแแแแขแแแแแ แจแแแแฌแแแแแแ, แ แแแแแแแช แแแแแแแแฃแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแแแแแแกแขแ แแขแแ แแก แแ DevOps แแฃแแแแแแก แแแแ .
NeuVector
- แกแแแขแ:
neuvector.com - แแแชแแแแแ: แแแแแ แชแแฃแแ
NeuVector แแแแฌแแแแก แแแแขแแแแแ แแก แฃแกแแคแ แแฎแแแแแก แแ แฃแแ แฃแแแแแงแแคแก แแแจแแแแแก แแแชแแแก แฅแกแแแแก แแฅแขแแแแแแกแ แแ แแแแแแแชแแแก แฅแชแแแแก แแแแแแแแ, แแแแแแฃแแ แแแแขแแแแแ แแกแแแแก แฃแกแแคแ แแฎแแแแแก แแแแแแแแฃแแแฃแ แ แแ แแคแแแแก แจแแฅแแแแ. แแแก แแกแแแ แจแแฃแซแแแ แแแแแฃแแแแแแแแ แแแแแแแแก แกแแคแ แแฎแแแแ, แกแแแญแแ แแฅแขแแแแแแก แแแแแแ แแแ แแแแแแแแ แแแ firewall แฌแแกแแแแก แจแแชแแแแ.
NeuVector-แแก แฅแกแแแฃแ แแแขแแแ แแชแแแก, แ แแแแแแช แชแแแแแแแ แ แแแแ แช Security Mesh, แจแแฃแซแแแ แฆแ แแ แแแแแขแแก แแแแแแแ แแ 7 แคแแแแก แแแคแแแขแแ แ แกแแ แแแกแแก แฅแกแแแจแ แแ แกแแแฃแแ แงแแแแ แฅแกแแแฃแ แ แแแแจแแ แแกแแแแก.
แกแขแแแ แแฅแกแ
- แกแแแขแ:
www.stackrox.com - แแแชแแแแแ: แแแแแ แชแแฃแแ
StackRox แแแแขแแแแแ แแก แฃแกแแคแ แแฎแแแแแก แแแแขแคแแ แแ แชแแแแแแก แแแคแแ แแก Kubernetes-แแก แแแแแแแชแแแแแก แแแแแ แกแแกแแชแแชแฎแแ แชแแแแ แแแแกแขแแ แจแ. แแ แกแแแจแ แกแฎแแ แแแแแ แชแแฃแแ แแแแขแคแแ แแแแแก แแกแแแแกแแ, StackRox แแฌแแ แแแแแก แแแจแแแแแก แแ แแคแแแก แแแแแแ แแแแฃแแ แแแแขแแแแแ แแก แฅแชแแแแก แกแแคแฃแซแแแแแ แแ แแแขแแแแขแฃแ แแ แแงแแแแแก แกแแแแแแแแแชแแแก แแแแแกแแแแ แ แแแแแฎแ แแก แจแแกแแฎแแ.
แแแ แแ แแแแกแ, StackRox แแแแแแแแแแก Kubernetes-แแก แแแแคแแแฃแ แแชแแแแก Kubernetes CIS แแ แกแฎแแ แฌแแกแแแแก แแแแแงแแแแแแ, แ แแแ แจแแแคแแกแแก แแแแขแแแแแ แแก แจแแกแแแแแแกแแแ.
Sysdig Secure
- แกแแแขแ:
sysdig.com/products/secure - แแแชแแแแแ: แแแแแ แชแแฃแแ
Sysdig Secure แแชแแแก แแแแแแแชแแแแก แแแแแ แแแแขแแแแแ แแกแ แแ Kubernetes-แแก แกแแกแแชแแชแฎแแ แชแแแแแก แแแแแแแแแแแจแ. แแก
Sysdig Secure แแแขแแแ แแ แแแแ CI/CD แแแกแขแ แฃแแแแขแแแแแ, แ แแแแ แแชแแ Jenkins แแ แแแแแขแ แแแแแก Docker-แแก แ แแแกแขแ แแแแ แแแขแแแ แแฃแ แกแฃแ แแแแแก, แ แแช แฎแแแก แฃแจแแแก แกแแฎแแคแแแ แกแฃแ แแแแแแก แฌแแ แแแแแแจแ แแแแแฉแแแแก. แแก แแกแแแ แฃแแ แฃแแแแแงแแคแก แงแแแแแกแแแแชแแแ แฃแกแแคแ แแฎแแแแแก, แแแ แจแแ แแก:
- ML-แแ แแแคแฃแซแแแแฃแแ แแแจแแแแแก แแ แแแก แแ แแคแแแแ แแแ แแ แแแแแแแแแแแก แแแแแแแแแ;
- แแแจแแแแแก แแแแแขแแแ, แ แแแแแแช แแแคแฃแซแแแแฃแแแ แกแแกแขแแแแก แแแแแแแแแแ, K8s-แแฃแแแขแแก API-แแ, แแ แแแแแแแ แกแแแแแ แแ แแแฅแขแแแแ (FIM - แคแแแแแแแก แแแแแแแแแแก แแแแแขแแ แแแแ; แแ แแแขแแฏแแแแแแ) แแ แฉแแ แฉแ
MITER AT&CK ; - แ แแแแแ แแแ แแ แแแชแแแแแขแแแแก แแแแแแ แแแ.
แแแแซแแ แแแแขแแแแแ แแก แฃแกแแคแ แแฎแแแแ
- แกแแแขแ:
www.tenable.com/products/tenable-io/container-security - แแแชแแแแแ: แแแแแ แชแแฃแแ
แแแแขแแแแแ แแแแก แแแแแฉแแแแแแ, Tenable แคแแ แแแ แแงแ แชแแแแแแ แแแแฃแกแขแ แแแจแ, แ แแแแ แช แแแแแแแแ Nessus-แแก แฃแแแ, แแแฃแชแแแแแแแแ แแแแแ แแแแกแ แแ แฃแกแแคแ แแฎแแแแแก แแฃแแแขแแก แแแแฃแแแ แฃแแ แแแกแขแ แฃแแแแขแ.
Tenable Container Security แแงแแแแแก แแแแแแแแแก แแแแแแฃแขแแ แฃแแ แฃแกแแคแ แแฎแแแแแก แแฅแกแแแ แขแแแแก CI/CD แแแแกแแแแแแก แแแฃแชแแแแแแแก แแแแแชแแแแ แแแแแแแแ, แแแแแ แแ แแแ แแแแแแก แแฆแแแฉแแแแก แกแแแชแแแแแแแแฃแ แแแแแขแแแแแ แแ แฃแกแแคแ แแฎแแแแแก แกแแคแ แแฎแแแแแก แแแแแกแแญแ แแแแ แ แแแแแแแแแชแแแแแแ แแแขแแแ แแ แแแแกแแแแก.
Twistlock (Palo Alto Networks)
- แกแแแขแ:
www.twistlock.com - แแแชแแแแแ: แแแแแ แชแแฃแแ
Twistlock แแแแก แแแ แชแแแแแก, แ แแแแ แช แแแแขแคแแ แแแก, แ แแแแแแช แแ แแแแขแแ แแแฃแแแ แฆแ แฃแแแแแแ แกแแ แแแกแแแกแ แแ แแแแขแแแแแ แแแแ. Twistlock แแฎแแ แก แฃแญแแ แก แกแฎแแแแแกแฎแแ แฆแ แฃแแแแแแ แแ แแแแแแแ แแแก (AWS, Azure, GCP), แแแแขแแแแแ แแแแก แแ แแแกแขแ แแขแแ แแแก (Kubernetes, Mesospehere, OpenShift, Docker), แกแแ แแแ แแก แแแ แแจแ แแแจแแแแแก, mesh frames แแ CI/CD แแแกแขแ แฃแแแแขแแแก.
แแแ แแ แฉแแแฃแแแแ แแแ แกแแฌแแ แแแก แแแแแก แฃแกแแคแ แแฎแแแแแก แขแแฅแแแแแกแ, แ แแแแ แแชแแ CI/CD แแแแกแแแแแแก แแแขแแแ แแชแแ แแ แแแแแกแแฎแฃแแแแแก แกแแแแแ แแแ, Twistlock แแงแแแแแก แแแแฅแแแฃแ แกแฌแแแแแแแก แแแแขแแแแแ แแกแแแแก แกแแแชแแคแแแฃแ แ แฅแชแแแแแ แจแแแแแแแแแกแ แแ แฅแกแแแแก แฌแแกแแแแก แจแแกแแฅแแแแแแ.
แ แแแแแแแแ แฎแแแก แฌแแ Twistlock แแงแแแ Palo Alto Networks-แแ, แ แแแแแแช แคแแแแก Evident.io แแ RedLock แแ แแแฅแขแแแก. แฏแแ แฏแแ แแแแ แฃแชแแแแแ, แแแแแ แแขแฃแแแ แ แแแแ แแฅแแแแ แแก แกแแแ แแแแขแคแแ แแแก แแแขแแแ แแ แแแ
แแแแฎแแแ แแ Kubernetes-แแก แฃแกแแคแ แแฎแแแแแก แแแกแขแ แฃแแแแขแแแแก แกแแฃแแแแแกแ แแแขแแแแแแก แจแแฅแแแแก!
แฉแแแ แแชแแแแแแ, แ แแ แแก แแแขแแแแแ แแแฅแกแแแแแฃแ แแ แกแ แฃแแงแแคแแแ แแแแฎแแแแ แแ แแแแกแแแแก แแฅแแแแ แแแฎแแแ แแแ แแแญแแ แแแแ! แฒแแแแแแแแจแแ แแแ (
แแฅแแแ แแกแแแ แจแแแแซแแแแ แแแแแแฌแแ แแ แฉแแแแ
PS แแแแ แแแแแแแกแแแ
แแกแแแ แฌแแแแแแฎแแ แฉแแแแก แแแแแแ:
- ยซ
แจแแกแแแแแ Kubernetes แฅแกแแแแก แแแแแขแแแแจแ แฃแกแแคแ แแฎแแแแแก แแ แแคแแกแแแแแแแแแกแแแแก "; - ยซ
Docker แแ Kubernetes แฃแกแแคแ แแฎแแแแแกแแแแ แแแ แซแแแแแแ แ แแแ แแแแจแ "; - ยซ
9 แกแแฃแแแแแกแ แแ แแฅแขแแแ Kubernetes แฃแกแแคแ แแฎแแแแแกแแแแก "; - ยซ
11 แแแ, แ แแแ (แแ ) แแแฎแแ แแฃแแแ แแแขแแก แฐแแแแก แแกแฎแแแ แแแ "; - ยซ
OPA แแ SPIFFE แแ แแก แแ แ แแฎแแแ แแ แแแฅแขแ CNCF-แจแ แฆแ แฃแแแแแแแ แแแแแแแชแแแแแก แฃแกแแคแ แแฎแแแแแกแแแแก ".
แฌแงแแ แ: www.habr.com