แแ 20 แฌแแแแ แแแขแแ แแแฃแจแแแ IT-แจแ, แแแแ แแ แ แแขแแแฆแแช แแ แแกแแ แแก แแแแแแ แแแแขแแแแแ แแแแแ. แแแแ แแฃแแแ แแ แแแกแแแแ, แ แแแแ แแงแแแแ แกแขแ แฃแฅแขแฃแ แแ แแแฃแแ แแ แ แแแแ แแฃแจแแแแแแแ. แแแแ แแ แ แแแแแ แแ แแแ แแ แแฅแขแแแแจแ แแ แแกแแ แแก แจแแแฎแแแแ แแแแ , แแ แแแชแแแ แแฃแกแขแแ แ แแแแ แจแแแแขแ แแแแแ แแ แแแขแ แแแแแ แแแแ แแแแแขแแก แฅแแแจ แแ แกแแแฃแแ แแแฅแแแแแแแแ.
แแแแแช, แฌแแ แแแแแแแ แแ แแฅแแแแ, แ แแแแ แ แแงแ แแแแ แฃแกแแคแ แแฎแแแแ. แแแแ แแ แแแแแ แแ แแฎแแ, แแแแ แแ แแแแแแแ แแฆแแ แก แแ แแแแจแ แฉแแแ แฉแ แซแแแแ แกแแแฆแแ แ โแ แแแแ แช แฃแกแแคแ แแฎแแแแ แแแ แแแแ, แแแแแงแแแแแแแแแ แแชแแ แแแแโ. แแกแ แ แแ, แแ แแคแแฅแ แแแแ, แ แแ แ แแแแแ แแแแขแแแแแ แแแแ แงแแแแแคแ แแก แแแแแแแแ แแแแแแแ, แแแจแแ แฃแกแแคแ แแฎแแแแ แแฅ แแแแแแแ. แ แแแแ แช แแฅแแ, แแแ แแแแ แแแงแแแ.
แกแฌแ แแคแ แแแกแแฌแงแแแแ, แแแแ แแแแกแขแ แแ แแ แแฃแ แกแแแแ
แแฃแ แกแ, แ แแแแแกแแช แแกแฌแแแแแแแแ แจแแแแ แ. แแแ แขแ แแ แกแแ แแแแแ, แแแจแแแแ แแแแฌแงแ Docker แแแแขแแแแแ แแแแก แแฃแจแแแแแก แแ แแแแแแฃแ แแแแก แแฆแฌแแ แแ แแฃแแแ แแแขแแกแจแ แแแแแแแแแแกแแก. แแก แแงแ แกแ แฃแแแแ แแ แแฅแขแแแฃแแ แแแแแแแแแ - แกแขแฃแแแแขแแแก แฃแแแ แแแแงแแแแแแแแ Docker แแ microk8-แแแ แแแแแแแ แแแแฅแแแแแแ แแแแแแแแแแก แแแฌแงแแแแแแ - แจแแกแแแแจแแแแ แแแ แแแแก แแแกแแแแฎแแ, แแฃ แ แแแแ แฃแ แแแแ แแฅแแแแแแแ แฎแแแกแแฌแงแแแแ แแ แแแแแแแแแ, แแแแแแ แกแฃแกแขแ แฌแแ แขแแแแแ แแ, แ แแช แแแแแแ แแ, แจแแแชแแแแ แแแแ แแแแแแแแ.
แกแแแฌแฃแฎแแ แแ, แแแฃแฎแแแแแแ แแแแกแ, แ แแ แแฃแ แกแแแ แแแแแ แแแแ, แ แแ แแ แ แแฆแแก แจแแแแแ "แแ แแแชแ" แแแแฎแแแแแแ, แแแ แซแแแแแ, แ แแ แงแแแแแคแแ แ แแฎแแแแ แแแกแแฌแงแแกแ แแงแ แแ แแแแแ แแแแ แ แ แแ แแฅแแแแ แกแแกแฌแแแแ.
แกแแแแ แฉแแแฃแฆแ แแแแแแแ แฉแแแก แแแฆแแ แแแแแแ แแแแแแก, แแแแจแแแแแแแแแแ แแแแฎแกแแแ แ แ แแ แแก แแแแขแแแแแ แ. แแแแแแแแ แแแแก แกแแแงแแ แแจแ แแแ แแแแฃแ แแ แแแแแแแ, แ แแ แแฅแแแแก แแแ แกแแแแแฃแ แแแแฅแแแแแ แแแฌแแ แแแ แแแแ แแฃแจแแแแก แแแแแแฃแ แแ, แแแแ แแ แ แแชแ แชแแแแแแ แแแก แแแจแแแแแก แกแแแแ แกแแ แแแ แแ, แแก แฃแแ แแแแ แแ แแฃแจแแแแก. แแแแขแแแแแ แแแ แชแแแแแแแ แแแซแแแแ แแก แแ แแแแแแ แแแแแแแแ แแแแแแแแก แแฅแแแ แแแแฅแแแแแแก แแแฌแแแแแแ, แ แแแแแแ แแแแแขแแแ แจแแแแซแแแแ แแ แแ แกแแ แแแ แแแแ แแแแ แแแ, แแแแก แชแแแแ, แ แแ แแกแแแ แงแแแแแแแแก แแแฃแจแแแแแแ. แ แแแแ แช แกแแฎแแแ แแแแแแแแแแก, แแกแแแ แจแแแชแแแก แแแแก, แแแแแแแแแแแแก แแ แกแฎแแ แแ แแแ แแแฃแ แฃแแ แฃแแแแแงแแคแแก, แ แแแแแแช แกแแญแแ แแ แกแแแฃแจแแแก แจแแกแแกแ แฃแแแแแแ. แแแแ แ แแฎแ แแ, แแฃแแแ แแแขแแกแ แแ แแก
แฅแแแแแ แแแชแแแฃแแแ แฉแแแ แ แแแแแแแแ แแฆแแแฉแแแ แฌแแแแแ แแ แแฃแ แฏแ แแฃแแแแก แแแ แกแแแฅแขแแแแแแ.
แฌแแแแแ แแฃแแแ
แแแแขแแแแแ แแก แจแแแแแ แกแแก แฃแแแขแแกแแแ แแแแแก แ แแแแ แช root: แแก แแแจแแแแก, แ แแ แแฃ แแแแขแแแแแ แ แแแแแแแแแฃแแแ, แแฅแแแ แแแฅแแแแแ แกแ แฃแแ แฌแแแแแ แแแแขแแแแแ แแ. แแก แแแแจแแแแแแแแแ แแแแ แขแแแแแก แจแแแแแ แแแแแฏแแแก.
แแแแขแแแแแ แแก แจแแแแแ แฌแแแแแแแก แแแแแแขแแแแแ แกแแจแแจแแ: แแฃ แแฅแแแ แแแฅแแ root แแแแขแแแแแ แแก แจแแแแแ แแ แแกแแแ แแแแแแกแขแแแแ แแ Docker แแแแขแแแแแ แจแ, แ แแแแแกแแช แแฅแแก Docker แกแแแแขแ (/var/run/docker.sock), แแฅแแแ แแแฅแแ แแแขแแแชแแแแ แแแแแแแแแแแ แแแแแ แแแแกแขแแ แ, แแแ แจแแ แแก แฌแแแแแ แแแแแกแแแแ แกแฎแแ แแแแขแแแแแ แแ. แแกแแแ แฌแแแแแแก แแฆแแแแแ แจแแฃแซแแแแแแแ แฅแกแแแแก แแแแแแชแแแ แแ แกแฎแแ แกแแจแฃแแแแแแแแ.
แแแ แแแแก แชแแแแแแแ แฎแจแแ แแ แจแแแชแแแก แกแแแแฃแแแ แแแแแชแแแแแก: แฃแแแขแแก แจแแแแฎแแแแแจแ, แแแแแแแแแแ แแแแแแแแแ แแแ แแแแแก แแแแขแแแแแ แจแ แแแ แแแแฃแ แ แแแ แแแแก แชแแแแแแแแก แแแแแงแแแแแแ. แแกแ แ แแ, แแฃ แแฅแแแ แแแฅแแ แฌแแแแแ แแแแแ แแจแแ, แจแแแแซแแแแ แแแแแแแแแแ แแก แแแ แแแ แชแแแแแแแ, แ แแแ แแแแแแแแแแแ แแแแคแแ แแแแแ แแฅแแแแ แฃแคแแแแแแแกแแแแแแแ.
Docker API-แก แจแแฃแซแแแ แแแแ แ แแแคแแ แแแชแแแก แแแชแแแ: Docker API, แแแแฃแแแกแฎแแแแแ แแแแคแแแฃแ แแชแแแกแแก, แแฃแจแแแแก แแแขแแ แแแแชแแแก แแแ แแจแ แแ แจแแฃแซแแแ แแ แแแแแ แแแคแแ แแแชแแแก แฌแแ แแแแแ. Shodan-แแก แแแแแงแแแแแแ แจแแแแซแแแแ แแแ แขแแแแ แแแแแแ แฆแแ แแแ แขแแแแก แกแแ, แจแแแแแ แแแแฆแแ แแแขแแแฃแ แ แแแคแแ แแแชแแ แแแแกแขแแ แแก แจแแกแแฎแแ - แแ แแแแแ แซแแแแ แแแกแ แกแ แฃแแ แแแญแแ แ. แแแแก แจแแกแแฎแแ TrendMicro แฌแแ แก
แแฃแ แฏแ แแฃแแแ
แแ แแแแแแงแแแแ แแแแขแแแแแ แแก แจแแแแแแกแ, แ แแแแ แช root: แแแฃแฎแแแแแแ แแแแกแ, แ แแ root-แแก แกแแฎแแ แแแจแแแแ แฃแคแ แ แแแแแแแ, แแก แแ แฃแแแ แแแแแแแแ. แแแแก แแแชแแแแ, แแแฃแจแแแ แแแแแแแชแแแแ แแแแแขแแแ แแแแก แแแแแ แแแแ uid-แแก แฉแแแแแแแ, แแ --user แแคแชแแแก แแแแแงแแแแแแ CLI-แแแ แแแจแแแแแกแแก, แแ Dockerfile-แจแ USER-แแก แแแแแแแแแ.
แแ แแแฃแจแแแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแแกแขแแแแชแแ แแแแขแแแแแ แแแจแ: แแแแฅแแแก แงแแแแ แจแแขแแแ แ แแฆแแชแแก แแแ แแแแ แแฌแงแแแ. nmap-แแแ ifconfig-แแแ, แแแแแ Docker-แแแ (แแแแขแแแแแ แแก แจแแแแแ), แ แแแแแก แแแงแแแแแ แแแแขแแแแแ แจแ แฉแแแฃแแแแ แแแ แแแแแแแ แแงแ. แแแแแ แแแแแแแ, แแฅแแแ แงแแแแแแแแก แฃแแแ แแแแแแแแ แงแแแแ แแแแแฃแงแแแแแแแ แแแ แขแ. แแก แแกแแแ แฎแแแก แฃแจแแแก แกแแแแแขแ แแแ แแ แซแแแแแแแแก แแแแแชแแแแก, แ แแแแกแแช แแฅแแแแ แแแแฅแแแ แแแคแแชแแ แแแฃแแแ. แแ แแแ แแแแแแก แแแงแแแแแแก แแแแแแแ แแชแแแแแแก แแแ แแ, แฆแแ แก แแแ แฌแแฃแแแแ, แ แแ แแแแชแแแแก แจแแกแแกแ แฃแแแแแแ แกแแญแแ แ แแแแแแแชแแแแแก แแแแแแแแฃแ แ แ แแแแแแแแ แแแแแกแขแแแแ แแแฃแแแ แแแแแ แแแแขแแแแแ แจแ.
แแแแชแแแ แแแแแ .แฌแแแแ: แแก แแแชแฃแแ แฃแแแ แแงแแก, แ แแแแแ แแแแขแแแแแ แกแ แแ แแแแกแขแแ แก แจแแ แแก แแแแฃแแแแแชแแ แแฃแจแแแแแแ แแ แกแแแแขแแก แแแจแแแแแแ. แ แแแแแ แแ แแแแแ แแ แกแขแแขแแแจแ แแแขแแแแแแก แจแแกแฌแแแแ, แฌแแแแแแฎแแ
แแแแแแงแแแแ แแแแแ แแก แกแแแแฃแแแแแแแแ แแแ แแแแก แชแแแแแแแแก แแแชแแแแ: แแ แกแแแแแก แกแแแแฃแแแแแแแแ
แแฃ แกแขแแขแแแ แแแแฉแแแ แแฅแแแแ แแแขแแ แแกแ แแแแขแแแแแ แแแแก แแแแแ แ, แจแแแแซแแแแ แแแ แขแแแแ แแแแแแกแขแแแแ แแ Docker แแ microk8s (Kubernetes-แแก แแชแแ แ แแแ แกแแ).
แแแกแขแแแแชแแแก แจแแแแแ แจแแแแซแแแแ แฌแแกแแแ
แแฃ แแกแฃแ แ แแ แแญแแ แแแแแ Docker-แแก แงแแแแแกแแแแชแแแแ แแฃแ แกแแก แแแแแ, แ แแแแแจแแช แแ แแฅแขแแแฃแแ แแแแฎแกแแแแแแแแ แจแแแกแฌแแแแแแ แแแก แงแแแแ แแแกแขแ แฃแแแแขแก: แซแแ แแแแแ แแแกแขแ แแฅแชแแแแแแแ แฅแกแแแแก แแแ แแแแขแ แแแแแแ, แกแฎแแแแแกแฎแแ แแแแ แแชแแฃแ แกแแกแขแแแแแแแ แแ แแ แแแ แแแแ แแแแก แแแแแแแ แแฃแจแแแแแก แแแฃแแแกแแแแแแ, แแแจแแ แกแชแแแแ โ
แฌแงแแ แ: www.habr.com