แแแแแ แแแแแแฎแแแแ Docker-แจแ แแ Kubernetes-แจแ แจแแกแแแแก แกแแคแฃแซแแแแแก, แจแแแแแ แแ แแแแแแฎแแแแ แแ แฎแแแกแแฌแงแแก, แ แแแแแแแช แจแแแซแแแแ แฃแกแแคแ แแฎแแ แแฅแแแก แแแแแงแแแแแฃแแ แฌแแ แแแแแแจแ: Grafana Loki แแ EFK แกแขแแแ (Elasticsearch + Fluent Bit + Kibana).
แกแขแแขแแแก แแแกแแแ แแ แแก แจแแแฃแแจแแ . แแฃ แแ แกแแแแแก แกแฃแ แแแแ แแ แแแ แฃแแแขแแก, แแฃ แแ แกแแแแแก แฌแแ แแแแแแก แกแแญแแ แแแแ, แจแแแแซแแแแ แแแแแ แแ แกแ แฃแแ แขแ แแแแแแ - แแแ แแแแกแขแ แแ แแแ แแฃแ แกแแ .
Docker แฎแ
Kubernetes แแแแแแ, แแแแแแแชแแแแ แแฃแจแแแแก แแแแแแจแ, แแแแ แแ แฃแคแ แ แแแแแ แแแแแแ, แแกแแแ แแแแแ แฉแแแฃแแแแ แแ แแฃแจแแแแแ Docker-แจแ. แแแแขแแ, แแฅแแแ แฃแแแ แแแแแแแคแแแฃแ แแ แแ แฎแแแแ แแกแ, แ แแ แจแแแแ แแแแ แแแ แแแ แแแแขแแแแแ แแแแแแ. แแแแขแแแแแ แแแ แแแจแแแแฃแแแ Docker-แแก แแแแ , แ แแช แแแจแแแแก, แ แแ แแฅแแแ แฃแแแ แแแแ แแแแแ, แ แแแแ แแ แแก แแแฌแงแแแแแ แฎแ-แขแงแแแแ Docker-แแก แแแแแแ.
แแแแแ แแแฅแแก, แงแแแแ แแแแแฎแแแแแ แแชแแก: แแแแแแแชแแแก แแฃแ แแแแ แฃแแแ แแแแฌแแ แแก stdout / stderr-แแ แแ แแ แ แแแแขแแแแแ แจแ. แแฃแ แแแแแแ แแ แแแแแแ Docker Daemon-แแก แแแแ แแ แแก แแฃแจแแแแก แแฃแกแขแแ แแ แแฃแ แแแแแแแแ, แ แแแแแแแช แแแแแแแแแ stdout/stderr-แแ. แแแ แแ แแแแกแ, แแแแขแแแแแ แแก แจแแแแแ แแแ แแแแก แฉแแฌแแ แ แกแแแกแแ แแ แแแแแแแแแ: แแแแขแแแแแ แ แจแแจแฃแแแแฃแแแ แแแแ แแ แแฃแ แแแแแแแ (แ แแแแแ แแแแ แแแแแแแแแ แแ แแ แแก Logrotate แแแแขแแแแแ แจแ) แแ Docker Daemon-แแ แแ แแชแแก แแ แแฃแ แแแแแก แจแแกแแฎแแ.
Docker-แก แแฅแแก แ แแแแแแแแ แแฃแ แแแแแก แแ แแแแแ แ แแ แแแแแแแขแ แแแแขแแแแแ แแแแก แจแแแ แแแแแแก แจแแกแแแ แแแแแแแ. แฃแคแแกแ Docker Community Edition (CE) แแฅแแก แแแแแแแ แแฃแ แแแแแก แแ แแแแแ แ, แแแแ แ แแแแแ แชแแฃแแ Docker Enterprise Edition (EE).
แแ แแ แแกแแแแก แแแแแแแงแแแแแแ Docker EE แแ แแฅแขแแแแจแ: Southbridge-แจแ แฉแแแ แแชแแแแแแ แแแแแชแแแ แฆแแ แแแแแก แแแแแฌแงแแแขแแแแแแแ แแ แแแแฎแแแ แแแแแก แแ แกแญแแ แแแแ Docker EE-แแก แแแแแขแแแแแ แคแฃแแฅแชแแแแแก แฃแแแขแแกแแแ.
แแฃแ แแแแแก แแ แแแแแ แแแ Docker CE-แจแ:
แแแแแแแแ แแแ - แแฃแ แแแแแก แฉแแฌแแ แ Docker Daemon แจแแแ แคแแแแแแแ;
json แคแแแแ - json-log-แแก แจแแฅแแแ แแแแแแฃแแ แแแแขแแแแแ แแก แกแแฅแแฆแแแแแจแ;
แแฃแ แแแแแ แแแฃแแ - แแฃแ แแแแจแ แแแ แแแแก แแแแแแแแ.
Docker logging แแแ แแแแขแ แแแ แแแแแแแแแฃแแแ daemon.json แคแแแแจแ.
"log-driver" แแแแ แแแฃแแแแแแก แแแแแแแขแก, แฎแแแ "log-opts" แแแแ แแแแกแแแฆแแ แแแก แแแก แแแ แแแแขแ แแแก. แแแแแ แแแงแแแแแ แแแแแแแแจแ แแแแแแแแฃแแแ โjson-fileโ แแแแฃแแ, แแฃแ แแแแแก แแแแแก แแแแแขแ แแ แแก โmax-sizeโ: โ10mโ; แคแแแแแแแก แ แแแแแแแแแก แจแแแฆแฃแแแ (แ แแขแแชแแแก แแแ แแแแขแ แแแ) โ โmax-fileโ: โ3โ; แแกแแแ แแแแจแแแแแแแแแ, แ แแแแแแแช แแแแ แแแแแ แแฃแ แแแแแแก.
แแฃแ แแแแแก แแ แแแแแ แแก แแแแแแ แแ แแแ แแแแขแ แแก แแแงแแแแแ แจแแกแแซแแแแแแแ แแ แซแแแแแแก แฎแแแแก แแแแฃแแแแฃแ แ แแ แแแ แแแแก แแแจแแแแแแ. แแก แแแแแกแแแแแแ, แแฃ แชแแแแ แแแแขแแแแแ แแก แแแจแแแแ แกแแญแแ แแ แกแฎแแ แแฃแ แแแแแก แแ แแแแแ แแ.
แแ, แ แแแแ แแแแแแงแฃแ แแแ แฎแ-แขแงแแก แกแฅแแแ Docker-แจแ:
แ แแแแ แแฃแจแแแแก แกแฅแแแ: แแฃแ แแแแแก แแ แแแแแ แ, แ แแแแ แแชแแ json-file, แฅแแแแก แคแแแแแแก. แแฃแ แแแแแก แจแแแแ แแแแแแแแ (Rsyslog, Fluentd, Logagent แแ แกแฎแแแแ) แแแ แแแแแแ แแ แคแแแแแแก แแ แแแแแแฅแแ แจแแกแแแแฎแแ Elastic, Sematext แแ แกแฎแแ แกแแชแแแแแจแ.
Kubernetes-แจแ แจแแกแแแแก แแแฎแแกแแแแแแแแแ
แแแแแ แขแแแแแฃแแ, Kubernetes-แจแ แญแ แแก แกแฅแแแ แแกแ แแแแแแงแฃแ แแแ: แแ แแก pod, แแแกแจแ แแฃแจแแแแก แแแแขแแแแแ แ, แแแแขแแแแแ แ แแแแแแแแก แแฃแ แแแแแแก stdout / stderr-แแ. แจแแแแแ Docker แฅแแแแก แคแแแแก แแ แฌแแ แก แแฃแ แแแแแแก, แ แแแแแแ แ แแขแแชแแ แจแแกแแซแแแแแแแ.
แแแแแแฎแแแแ Kubernetes-แจแ แจแแกแแแแก แแแฎแแกแแแแแแแแแ.
แจแแแแแฎแแ แแฃแ แแแแแแ แแแแแแแแแแแก แจแแ แแก. แแก แแ แแก แฌแแแแแแ แแแ แกแฌแแ แ แแแแแก แแแ แแแแขแ แแแแกแแแแก. แแฃ แแ แจแแแแแฎแแแ แแฃแ แแแแแแก แแแแแแแแแแแก แจแแ แแก, แแแจแแ แ แแแแกแแช แแแแแแแชแแแก แแฎแแแ แแแ แกแแ แแแแแฅแแแงแแแแแ, แฌแแแ แแฃแ แแแแแแ แแแแแแฌแแ แแแ, แแแแขแแแแแ แแก แแแแแขแแแ แแแ แแกแแแ แกแแแกแ แแฅแแแแ แแฃแ แแแแแแแก แแแแแ แแแแ. Kubernetes-แก แแฅแแก --previous แแแกแแฆแแแ, แแก แกแแจแฃแแแแแแก แแแซแแแแ แแแฎแแ แแแแแแแชแแแก แแฃแ แแแแแแ แแแแ Pod-แแก แแแแแขแแแ แแแแแแ, แแแแ แแ แแ แ แฃแคแ แ แฆแ แแแ.
แจแแแแ แแแแ แแฃแ แแแแแแ แงแแแแ แแแกแขแแแชแแแแแ. แแฃ แแแแ แแกแแ แแแกแแแ แฆแ แฃแแแแแจแแ แแแแแแแกแแแฃแแ, แแแจแแ แฆแ แฃแแแแแแแ แแ แแแแแแแ แ แแแกแฃแฎแแกแแแแแแแแ แกแแกแขแแแแก แแแแขแ แแแแ. แแฃ แแแแ แแกแแ แแแกแแแ แกแแแฃแแแ แแแแ แแขแแแ, แแแจแแ แแแแขแแแแแ แแแแแแ แแแ แแแแก แแแ แแ, แแฅแแแ แแกแแแ แฃแแแ แจแแแแ แแแแ แกแแกแขแแแแก แแฃแ แแแแแแ.
แแแ แ แแ แแ แกแแแแแแ แแแกแแฎแแ แฎแแแแแ แฎแแแกแแฌแงแแแแ, แ แแแแ แช แกแแกแขแแแแแแ, แแกแแแ แแแแ แแกแแ แแแกแแแแแแ แแฃแ แแแแแแแก แจแแกแแแ แแแแแแแ. แฉแแแฃแแแแ แแ, แแ แแ แแแกแขแ แฃแแแแขแ แแแ แแแแแแ แกแแกแขแแแแก แแฃแ แแแแแแก (แแแแแแแแแ, Rsyslog), แแแแ แ - แแฃแ แแแแแแก Docker-แแแ (แแแแแแแแแ, journal-bit แแ แแแ Docker แแฃแ แแแแแก แแ แแแแแ แ, แ แแแแแแช แแแแคแแแฃแ แแ แแแฃแแแ journald-แแ). แฉแแแ แจแแแแชแแแแ แแแแแแแแงแแแแแแแ journal-bit - แจแแแแ แแแแ แแฃแ แแแแแแ แ แแแแ แช แแแแขแแแแแ แแแแแแ (แแแฃแแแแแ Docker แแฃแ แแแแแก แแ แแแแแ แจแ, แ แแ แแญแแ แแแแแ แแฃแ แแแแแก แฉแแฌแแ แ แแฃแ แแแแจแ), แแกแแแ แกแแกแขแแแแแแ (CentOS 7-แก แฃแแแ แแฅแแก systemd แแ journald). แแแแแกแแแแแ แแฃแจแแแแก, แแแแ แแ แแ แ แกแ แฃแแงแแคแแแ. แแฃ แแแแ แ แแฃแ แแแแแ, journal-bit แแฌแงแแแก แฉแแแแ แฉแแแแก, แจแแขแงแแแแแแแแแ แแแแ แแแแ.
แแฅแกแแแ แแแแแขแแแ แแแแ แซแแแแ - แแ แกแฎแแ แแแ แแแแแแก. CentOS 7-แจแ แซแแ แแแแแ แกแแกแขแแแแก แแฃแ แแแแแแ (แจแแขแงแแแแแแแแแ, แแฃแแแขแ, แฃแกแแคแ แแฎแ) แแฃแแแแ แแแฃแแแ var-log-แจแ, แ แแแแ แช แคแแแแแแ. Docker แแกแแแ แจแแแซแแแแ แแแแคแแแฃแ แแ แแแฃแแ แแงแแก แแฃแ แแแแแแแก แจแแกแแแแฎแแ json แคแแแแแแจแ. แจแแกแแแแแแกแแ, CentOS 7-แแกแ แแ Docker-แแก แแ แคแแแแแแแก แแฌแงแแแ แจแแกแแซแแแแแแแ.
แแ แแแ แแแแแแแแแแแจแ ELK Stack แแแแแฌแงแแแขแ แแแแฃแแแ แฃแแ แแแฎแแ. แแก แแ แแก แ แแแแแแแแ แแแกแขแ แฃแแแแขแแก แแแแแแแแชแแ: Elasticsearch, Logstash แแ Kibana.
Elasticsearch แแแแฎแแแก แแฃแ แแแแแแก แแแแขแแแแแ แแแแแแ, Logstash แแแ แแแแแก แแฃแ แแแแแแก แแแกแขแแแชแแแแแแแ, Kibana แกแแจแฃแแแแแแก แแแซแแแแ แแแแแฃแจแแแแ แแแฆแแแฃแแ แแฃแ แแแแแแ แแ แจแแฅแแแแ แแ แแคแแแแแ แแแแแ แแแงแ แแแแแแ. ELK Stack แแฅแขแแฃแ แแ แแแแแแงแแแแแ แแแ แแแแฃแแ แแแ แแแแแก แแแแแแแแแแแจแ, แแแแ แแ, แฉแแแ แแแ แแ, แแแกแ แแ แ แแแแแก. แแแแแแแแแแแ แแแขแงแแแ แ แแขแแ.
แแแขแแแแแแชแแแแแแก แแแแแขแแแ. แแแแแแแก, แแแแแแแชแแแแแก, แแแแขแแแแแ แแแแก แแแจแแแแ แจแแกแแซแแแแแแแ แงแแแแแแ. แฃแคแ แ แแแขแแช, แแ แ แแแแแแแชแแแก แจแแแซแแแแ แฐแฅแแแแแก แ แแแแแแแแ แจแแแแฎแแแแ. แแฃแ แแแแแแ แแฌแแ แแแ แแแแแ แคแแ แแแขแจแ แแ แฃแแแ แแแแแแแ, แ แแแแ แ แ แแแแแแแ, แ แแก แฌแแ แก Pod, แ แ แกแแฎแแแแ แกแแแ แชแแจแแ. แแแแขแแ แแฃแ แแแแแแก แกแญแแ แแแแแ แแแขแแแแแแชแแแแแแก แแแแแขแแแ.
แแฃแ แแแแแแแก แแแแแแแแแแแ. แกแแกแแชแแแแ, แแแแ แแ แฎแ-แขแงแแก แแ แแแแแขแแ แแแแแก แกแแกแขแแแแก แจแแแแ แฉแฃแแแแแก แฆแแ แแแฃแแแแ แจแแแซแแแแ แแฆแแแแขแแแแแแก แซแแ แแแแแ แแแแแแแชแแแก แฆแแ แแแฃแแแแแก. แ แแแแกแแช แแฅแแแ แแแฅแแ แแแแแแ แแ แแกแแแแ แแแแกแ แแแ แ, แ แแแแแแแช แแแคแ แแแแแแ แฌแแแจแ, แแก แแฃแแแแ แแแ แฉแแแก, แแแแ แแ แแฅแแแ แแแแแช แฃแแแ แแชแแแแ แฎแแแ. แแ แแฆแแ แแก แแแแแแก แแ แ-แแ แแ แแแแ แแฃแ แแแแแแแก แแแ แฉแแแ.
แ แแแแ แช แฌแแกแ, แแฅแแแ แแ แแญแแ แแแแแ แงแแแแ แแฃแ แแแแแก แจแแแ แแแแแ แแ แจแแแแฎแแ, แกแแญแแ แแ แแฎแแแแ แแแฌแแแแก แแแแแแแแ แจแแกแแแแฎแแ - แแแแแแแแแ, แแฃแ แแแแแแ แกแขแแขแฃแกแแ "แแแคแ แแฎแแแแแ" แแ "แจแแชแแแแ". แแฃ แแกแแฃแแ แแแ nginx-แแ แแ ingress แแแแขแ แแแแ แแก แแฃแ แแแแแแแ, แแแจแแ แจแแกแแแแฎแแ แจแแแซแแแแ แแแแแแแแแแ แแฅแแแก แแฎแแแแ แแก, แแแกแ แกแขแแขแฃแกแแช แแแแกแฎแแแแแแแ 200-แแแ. แแแแ แแ แแก แแ แแ แแก แฃแแแแแ แกแแแฃแ แ แ แฉแแแ: แแฃ แ แแแแ แแ แแฌแงแแแ แแแแแแขแแแแก Nginx-แแก แแฃแ แแแแแแแ แแแงแ แแแแแแ, แแแจแแ แแจแแแ แแ แฆแแ แก แแแแ แจแแแ แแแแแ.
แแฃแ แแแแแแแก แแแฃแคแแฅแ แแแแแ แแแคแแแขแแ แ แแ แแ แแก แ แแแแแแแแแแฃแแ, แ แแแแแ แแแคแแแขแ แฃแแ แแแแแชแแแแแ แจแแแซแแแแ แแ แแงแแก แกแแแแแ แแกแ แแแ แแแแฃแ แ แแแแแแขแแแแกแแแแก. แแแแ แแก แแฎแ แแ, แจแแกแแซแแแ แแแแแแขแแแ แฃแแแ แแแแฎแแ แชแแแแแแก แแ แ แแแแแก แแแแแแ, แแ แแแแ แแแขแ แแแแก แจแแแ แแแแแแก แแแแแแ. แแแจแแ แแ แแแแแฌแแแ 200 แแแแแ แแกแแแแ แแแแกแ แฎแแแแก แจแแแแฎแแ. แแ แแ แแแแแแแ แแ แแก แแแคแแ แแแชแแแก แแแฆแแแ แขแ แแคแแแแกแ แแ แจแแชแแแแแแแก แจแแกแแฎแแ แจแแฆแฌแแแแก แแแแขแ แแแแ แแแแก แแแขแ แแแแแแแแ.
แแแแแแแ, แแฅ แกแแญแแ แแ แแแ แแแ แแแคแแฅแ แแแ: แ แแกแ แจแแแแฎแแ แแกแฃแ แ แแ แ แแแแแ แฎแแแก, แ แแแแแ แฌแแแแแฆแแแแ แจแแแแฎแแแแแจแ แฌแแ แแแแฅแแแแแ แกแแขแฃแแชแแ, แ แแแแกแแช แฎแ-แขแงแแก แกแแกแขแแแ แฃแคแ แ แแแข แ แแกแฃแ แกแก แแแแฆแแแก, แแแแ แ แแแแแแ แ แแ แแแฅแขแ.
แฏแแ แแ แแ แกแแแแแก แกแขแแแแแ แขแฃแแ แแแแแฌแงแแแขแ แญแ แแกแแแแก. แแแแแขแแ แแแแแกแแแ แแแแกแฎแแแแแแแ, แกแแแแช แแ แแก แแ แแแแแแก แแ แ-แแ แแ แงแแแแแแ แแแแ แชแแแแแฃแแ แแแแแฌแงแแแขแ, แแ แแ แกแแแแแก แกแขแแแแแ แขแ แฎแแแแแก แแฆแ แแชแฎแแแจแ.
แแ แแแฅแชแแแจแ แแแแแแฎแแแแแ แแ แแแกแขแ แฃแแแแขแก: แแ แแ แแแแฃแแแ แฃแแแ, แแแแ แ แแ แแแแฃแแแ แแแแก แแซแแแก. แแแ แแแ แแ แแ แแแ แกแฎแแแแแช, แแแแ แแ แแ แกแขแแขแแแจแ แแแ แแ แจแแแแฎแแแแ.
แแแแแ แแแแฎแแแฃแแ แงแแแแ แแแฎแแกแแแแแแแแก แแแแแแแแกแฌแแแแแแ, Kubernetes-แจแ แจแแกแแแ แแฎแแ แจแแแซแแแแ แฌแแ แแแแแแแแแ แแงแแก แจแแแแแแแแแ แแ:
แแแแขแแแแแ แแก แแฃแ แแแแ แ แฉแแแ, แแ แฃแแแแก, แแแแ แแ แฉแแแแแ แจแแแแ แแแแแแแ แแแแแขแ, แ แแแแแแช แแแฆแแแก แแฃแ แแแแแแก แแ แแแแแแแแก แจแแกแแแแฎแแ (แแแแแ แแแแจแ - Logging Backend-แจแ). แแแแแขแ แแฃแจแแแแก แแแแแแฃแ แแแแแซแแ แแ แฉแแแฃแแแแ แแ แแฃแจแแแแก Kubernetes-แแ.
แแฎแแ แแแแแฎแแแแ แฎแ-แขแงแแก แแแกแขแ แฃแแแแขแแแ.
แแ แแคแแแ แแแแ
แชแแขแ แฎแแแก แฌแแ แแแแแฉแแแ, แแแแ แแ แฃแแแ แกแแแแแแ แชแแแแแแ แแแฎแแ. แแแกแ แฃแแแ แแขแแกแแแแแ: แแแ แขแแแ แแแกแขแแแแชแแ, แแแแฎแแแ แก แแชแแ แ แ แแกแฃแ แกแแแก, แแ แกแแญแแ แแแแก Elasticsearch-แแก แแแกแขแแแแชแแแก, แ แแแแแ แแก แแแแฎแแแก แแแแแชแแแแแก TSDB-แจแ (แแ แแแก แกแแ แแแก แแแแแชแแแแ แแแแแจแ). แแแแ แกแขแแขแแแจแ แแแแฌแแ แ, แ แแ แแ แแแแแ แแแแฎแแแก แแแแแชแแแแแก แแกแแ แแแแแชแแแแ แแแแแจแ แแ แแก แแ แแก แแ แ-แแ แแ แแกแแแแกแแแ แแ แแ แแแฃแฅแขแก แจแแ แแก. แแแแแแแแแ แแแ แแ แแแขแแแชแแแแ, แ แแ แแแแ แแ แแก โแแ แแแแแ แฎแ-แขแงแแก แกแแแงแแ แแกแแแแกโ.
แแชแแ แ แแแแ แแกแแ TSDB-แแก แจแแกแแฎแแ แแแแแแแก, แแแกแแช แแ แแฅแแก แฌแแแแแฎแฃแแ : TSDB แจแแกแแแแจแแแ แกแแฅแแแก แแแแแแแก แแแแ แ แแแแแแแแแ แแแแแชแแแแแแก, แแ แแแก แกแแ แแแแแก แจแแกแแแแฎแแ, แแแแ แแ แแ แแ แแก แแแแแฃแแแแแแ แแ แซแแแแแแแแแ แจแแแแฎแแแกแแแแก. แแฃ แ แแแแ แแแแแแแ แแญแแ แแแแแ แแฃแ แแแแแแแก แจแแแแฎแแ แแ แแแแ แแแ แแแขแ แฎแแแก แแแแแแแแแแแจแ, แแแจแแ แฃแแฏแแแแกแแ แแแแ แแแแแชแแแแก แแแแคแแแฃแ แแชแแ แกแฎแแ แแแแแชแแแแ แแแแแจแ.
Loki-แก แแแแแ แแ แแ แฃแแแ แแขแแกแแแ แแก แแ แแก, แ แแ Grafana แแแแแแงแแแแแ แแแแแชแแแแ แแแแฃแแแแแแชแแแกแแแแก. แซแแแแแ แแแกแแฎแแ แฎแแแแแแ: แแ แแคแแแแจแ แแฃแงแฃแ แแแ แแแแแขแแ แแแแแก แแแแแชแแแแแก แแ แแแแแ แแแแแแแก แแแแแก แจแแแ แแแแแ แแแแแแแแแ แแแ แแแแแแก. แแฃแ แแแแแแ แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แแ แแคแแแแแแก แจแแกแแฅแแแแแแ.
แแแแแก แแ แฅแแขแแฅแขแฃแ แ แแกแ แแแแแแงแฃแ แแแ:
DaemonSet-แแก แแแแแงแแแแแแ แแแแแขแ แแแแแแแแแฃแแแ แงแแแแ แแแแกแขแแ แฃแ แกแแ แแแ แแ - Promtail แแ Fluent Bit. แแแแแขแ แแแ แแแแแก แแฃแ แแแแแแก. แแแแ แแแฆแแแก แแแ แแ แแแแฎแแแก แแแแแก TSDB-แจแ. แแแขแแแแแแชแแแแแ แแแฃแงแแแแแแแแ แแแแขแแแ แแฃแ แแแแแแก, แ แแช แแแกแแฎแแ แฎแแแแแแ: แจแแแแซแแแแ แแแคแแแขแ แแ แแแแแแแก, แกแแฎแแแแแแก แกแแแ แชแแก, แแแแขแแแแแ แแแแก แกแแฎแแแแแแก แแ แแขแแแแขแแแแก แแแฎแแแแแแแช แแ.
แแแแ แแฃแจแแแแก Grafana-แก แแแชแแแ แแแขแแ แคแแแกแจแ. Loki-แก แแฅแแก แกแแแฃแแแ แ แจแแแแแฎแแแก แแแ, แกแแฎแแแฌแแแแแแ LogQL, แ แแแแแแช แกแแฎแแแแแ แแ แกแแแขแแฅแกแแ แแกแแแแกแแ PromQL Prometheus-แจแ. Loki แแแขแแ แคแแแกแก แแฅแแก แแแแฎแแแแแแ แจแแแแแฎแแแแแแ แแแแแแจแแ แแแแ, แแแแขแแ แแ แแ แแก แแฃแชแแแแแแแ แแแแ แแแแแ แแ แชแแแแ.
แแแแ แแ แแคแแแแก แแแขแแ แคแแแกแจแ
แคแแแขแ แแแแก แแแแแงแแแแแแ Loki-แก แจแแฃแซแแแ แแแซแแแแแก แแแแแแ (โ400โ, โ404โ แแ แแแแแกแแแแ แ แกแฎแแ); แแแ แแแแก แแแฎแแ แแแแแ แแแแแซแแแแ; แแแคแแแขแ แแ แงแแแแ แแฃแ แแแแ, แ แแแแแแช แจแแแชแแแก แกแแขแงแแแก "แจแแชแแแแ". แแฃ แแฃแ แแแแก แแแแฌแแแแฃแแแแ, แแแแฎแกแแแแ แแแ แแแ แฆแแแแกแซแแแแแก แจแแกแแฎแแ แงแแแแ แแแคแแ แแแชแแแ.
Loki-แจแ แแ แแก แกแแแแแ แแกแ แฎแแแกแแฌแงแแแแ, แ แแแแแแแช แกแแจแฃแแแแแแก แแแซแแแแ แแแแแฆแแ แกแแญแแ แ แแฃแ แแแแแแ, แแฃแแชแ แแแ แแแแ แแแแฎแ แแ, แขแแฅแแแแฃแ แแ แจแแแซแแแแ แแแขแ แแงแแก. แแฎแแ แแแแ แแฅแขแแฃแ แแ แแแแแ แแแแ แแ แแแแฃแแแ แแแแก แแซแแแก.
แแแแกแขแแฃแ แ + แคแแฃแแแข แแแขแ + แแแแแแ (EFK แแแกแขแ)
EFK แกแขแแแ แแ แแก แฃแคแ แ แแแแกแแแฃแ แ, แแแแ แแ แแแแแแ แแ แแแแฃแแแ แฃแแ แญแ แแก แแแกแขแ แฃแแแแขแ.
แกแขแแขแแแก แแแกแแฌแงแแกแจแ แแแฎแกแแแแแ แแงแ ELK (Elasticsearch + Logstash + Kibana), แแแแ แแ แแก แกแขแแแ แแแซแแแแแแฃแแแ แแ แช แแฃ แแกแ แแ แแแฃแฅแขแแฃแแ แแ แแแแแ แแ แแก แ แแกแฃแ แกแแ แแแขแแแกแแฃแ แ Logstash-แแก แแแแ. แแแแก แแแชแแแแ, แแแ แแแแฌแงแแก แฃแคแ แ แแกแฃแแฃแฅแ แแ แแ แแแฃแฅแขแแฃแแ Fluentd-แแก แแแแแงแแแแแ แแ แชแแขแ แฎแแแก แจแแแแแ แแก แกแแแแจแแแแแจแ แแแแแแ. - แแแแแ แฃแคแ แ แแกแฃแแฃแฅแ แแ แแแแแ แฃแคแ แ แแ แแแฃแฅแขแแฃแแ แแแแแข-แแแแแฅแขแแ แ.
แแแแแแแแแ แแแแก แแฅแแแ, Fluent Bit 100-แฏแแ แฃแแแแแกแแ แจแแกแ แฃแแแแแจแ, แแแแ แ Fluentd: โแกแแแแช Fluentd แแแแฎแแแ แก 20 แแ RAM-แก, Fluent Bit แแแแฎแแแ แก 150 KBโ - แแแ แแแแแ แ แชแแขแแขแ แแแแฃแแแแขแแชแแแกแแแ. แแแแก แแแแแแแแกแฌแแแแแแ, Fluent Bit แฃแคแ แ แคแแ แแแ แแแแแแงแแแแแ.
Fluent Bit-แก แแฅแแก แแแแแแแ แคแฃแแฅแชแแแแ, แแแแ แ Fluentd, แแแแ แแ แแก แแแแชแแแก แซแแ แแแแ แกแแญแแ แแแแแแก, แแแแขแแ แฉแแแ แซแแ แแแแแแ แแแงแแแแแ Fluent Bit-แก.
แ แแแแ แแฃแจแแแแก EFK แกแขแแแ: แแแแแขแ แแแ แแแแแก แแฃแ แแแแแแก แงแแแแ แแแแแแแ (แฉแแแฃแแแแ แแ DaemonSet แแฃแจแแแแก แงแแแแ แแแแกแขแแ แฃแ แกแแ แแแ แแ) แแ แแแแแแแแก แแแ แกแแชแแแจแ (Elasticsearch, PostgreSQL แแ Kafka). แแแแแแ แฃแแ แแแแแ แกแแชแแแก แแ แแฅแแแแ แแฆแแแก แงแแแแ แกแแญแแ แ แแแคแแ แแแชแแแก.
แฌแแ แแแแแแแแก แแแคแแ แแแชแแแก แแแแฎแแแ แแแแแกแแแแก แแแกแแฎแแ แฎแแแแแ แแแ แแแขแแ แคแแแกแแ. แแ แแก แกแฅแแแแแ, แคแแแขแ แแแ แแ แกแฎแแ.
แแฃแ แแแแแแ แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แแแแแ แแแคแแก แจแแกแแฅแแแแแแ.
Fluent Bit แแแฎแแกแแแแแแแแแ
แแแแแแแแ Fluent Bit แฉแแแฃแแแแ แแ แแแแแแแแ แแกแแแก, แแแแ แ Logstash, แแแแแ แฃแคแ แ แแฎแแแก แแแแฎแแแแ แแแก. Fluent Bit แจแแแซแแแแ แแแแแแฃแ แแ แแแแงแแก 6 แแแแฃแแแ แแ แแแแแแแขแแแ แจแแแซแแแแ แแแแ แแแก แแแแแแ แ แแแแฃแแก, แ แแแแแแช แแคแแ แแแแแก Fluent Bit-แแก แจแแกแแซแแแแแแแแแก.
แจแแงแแแแแก แแแแฃแแ แแแ แแแแแก แแฃแ แแแแแแก แคแแแแแแแแแ, แกแแกแขแแแฃแ แ แกแแ แแแกแแแแแแ แแ แแฃแแแแช tcp-แกแแแแขแแแแ (แแฅแแแ แฃแแ แแแแ แฃแแแ แแแฃแแแแแ แกแแแแแแ แฌแแ แขแแแ แแ Fluent Bit แแแแฌแงแแแก แแฅ แฌแแกแแแแก). แแก แคแฃแแฅแชแแแแ แกแแแแแ แแกแแ แกแแกแขแแแแแแ แแ แแแแขแแแแแ แแแแแแ แแฃแ แแแแแแแก แจแแกแแแ แแแแแแแ.
แฌแแ แแแแแแจแ แฉแแแ แงแแแแแแ แฎแจแแ แแ แแแงแแแแแ แแแแแแแขแแแก (แจแแแซแแแแ แแแงแแแแแก แกแแฅแแฆแแแแแแ แแฃแ แแแแแแแ) แแ (แแแก แจแแฃแซแแแ แฃแแฎแ แแก, แ แแแแแ แกแแ แแแกแแแแแแ แฃแแแ แจแแแแ แแแแก แแฃแ แแแแแแ).
Parser แแแแฃแแ แแแแฅแแก แแฃแ แแแแแแ แกแแแ แแ แฎแแแแแแแ. แแแแฃแแแกแฎแแแแแ, Nginx แแฃแ แแแแแแ แแ แแก แกแขแ แแฅแแแ. แแแแแแแขแแก แแแแแงแแแแแแ, แแก แกแขแ แแฅแแแ แจแแแซแแแแ แแแ แแแแฅแแแแก JSON-แจแ: แแแแงแแแแ แแแแแแ แแ แแแแ แแแแจแแแแแแแแแ. JSON-แแแ แแฃแจแแแแ แแแแ แแ แฃแคแ แ แแแแแแแ, แแแแ แ แกแแแแแแแแ แแฃแ แแแแ, แ แแแแแ แแ แกแแแแแก แแแฎแแ แแกแฎแแแแก แฃแคแ แ แแแฅแแแแ แแแ แแแแขแแแ.
แคแแแขแ แแก แแแแฃแแ. แแ แแแแแแ, แแ แแกแแญแแ แ แแฃแ แแแแแแ แแฆแแแแคแฎแแ แแแ. แแแแแแแแแ, แแฃแ แแแแแแ แจแแกแแแแฎแแ แแแแแแแแแ แแฎแแแแ แแแแจแแแแแแแแ โแแแคแ แแฎแแแแแโ แแ แแแ แแแแฃแแ แแขแแแแขแแแแ. แแ แฉแแฃแแ แแฃแ แแแแแแ แแฃแคแแ แฃแแแ.
แแฃแคแแ แฃแแ แแแแฃแแ. Fluent Bit-แก แแฅแแก แแ แ แขแแแแก แแฃแคแแ แ: แแแฎแกแแแ แแแแก แแฃแคแแ แ แแ แแแกแแแก แแฃแคแแ แ. แแฃแคแแ แ แแ แแก แแฃแ แแแแแแแก แแ แแแแแแ แจแแแแฎแแ, แ แแแแแแช แกแแญแแ แแ แจแแชแแแแแแแก แแ แฌแแ แฃแแแขแแแแแแแก แจแแแแฎแแแแแจแ. แงแแแแแก แกแฃแ แก แแแแแแแก แแแแ แแขแแฃแแ แแแฎแกแแแ แแแ, แแแแขแแ แแกแแแ แฉแแแฃแแแแ แแ แแ แฉแแแแ แแแกแแแก แแฃแคแแ แก. แแแแ แแ แแแฎแกแแแแแ, แ แแ แแแกแแแ แแแแแกแแแแแแ, แแฃแ แแแแแแ แแแแแ แแขแแแ แแแแ แแแฎแกแแแ แแแแจแ.
แแแ แจแ แฃแขแแแแชแแแก/แแแแแแแแแแ แแแแฃแแ แจแแแชแแแก แแฃแ แแแแแแแก แแแแแแแแแก แฌแแกแแแก แแ แแแกแแแแ แแแแก. แ แแแแ แช แฃแแแ แแฆแแแแจแแแ, แแฃแ แแแแแแ แจแแแซแแแแ แแแแแแแแแแก Elasticsearch, PostgreSQL แแ, แแแแแแแแแ, Kafka.
แกแแแแขแแ แแกแแ, แ แแ แแฃแ แแแแแแ แจแแแซแแแแ แแแแแแแแแแก Fluent Bit-แแแ Fluentd-แจแ. แแแแแแแแ แแแ แแแแ แฃแคแ แ แแกแฃแแฃแฅแ แแ แแแแแแแแ แคแฃแแฅแชแแแแแแฃแ แแ, แจแแแแซแแแแ แแแกแ แแแจแแแแแแ แจแแแแ แแแแ แแฃแ แแแแแแ แแ แแแแแแแแแ แแกแแแ Fluentd-แจแ แแ แฃแแแ แแฅ, แแแแแขแแแแแ แแแแแแแขแแแแก แแแฎแแแ แแแแ, แแแแ แจแแแแแแแ แแแแฃแจแแแแแ แแ แแแแแแแแ แจแแกแแซแแแแแแแ แกแแชแแแแแจแ.
แแฃ แแฅแแแ แแแแ แแแ แแแแแแงแแแแ Elasticsearchโฆ
แแ แแแแแก, แแ แ แ แฉแแแ แแแแแแแก, แแแแช แแแแแแแก แแแแแแงแแแแก Elasticsearch แ แแแแ แช แแฃแ แแแแแก แกแแชแแแ แฌแแ แแแแแแจแ.
- แแแคแ แแฎแแแแแแแแก แแแงแแแแแ . แแก แแ แแแ แแแ แแแแแแ แแแก แแแแจแแแแแแแแ แจแแขแงแแแแแแแแแก แแฃแ แแแแแแแก แแแแแแ แแแแแแแแแ แแ แแแแแแแก แกแแแแแแแแแชแแแก แแแแแ แคแแกแขแแ แแ แกแฎแแ แแ แฎแแ. แแแ แแแแแ, แแ แช แแกแ แแแแ แฎแแแก แฌแแ .
- แแฃแ แแแแแแแก แ แแขแแชแแ แแแแ แแ แแแฃแ แแแแแก Elasticsearch API-แก. แแแแแ Elastic, แแ แแแชแแแจแ, แแฎแแ แแแแจแแแแแแแแ แแแแแฏแแแก แแแแแก แแแแแฅแกแแแแก แกแแชแแชแฎแแแก แแแ แแแแกแแแแก แแแกแแแ แแฎแแ แแก แฎแแแกแแฌแงแแแแแก แแแแแงแแแแแแก แแแ แแจแ. แแแแแแแ, แแแ แแแแก แแแแฎแแแก แจแแแแฎแแแก แแแ แ แแ แแฅแแก: แแแแแแแแ แกแแแแ แแฃแแแ, แ แแ แ แแแแ แแฃแ แแแแ แแแแญแแ แแแก แแ แ แแแแ แแก แจแแแแแ - แแฃ แแก แแแ แแแแช แแ แแขแแแฃแแแ, แแ แแแแ แแจแ แแฃแชแแแแแแแ แแแแฃแจแแแแแแ. แแฅแกแขแ แแแแแฃแ แจแแแแฎแแแแแแจแ, แซแแแแ แแฃแ แแแแแแ แจแแแซแแแแ แแแแ แฅแแแแแก แแ แแแแแแแแแแก แกแแแแ แแ แซแแแแแแแแแ แจแแแแฎแแแกแแแแก. แแแแแแ แกแแแชแแแแฃแ แ แแฃแ แแแแแแแก แจแแกแแฎแแ, แ แแแแแแแช แแแแแแแ 5 แฌแแแแแ แฃแแแ แแแแฎแแแแแแก. แแแ แแแแ แแ แแก แแ แจแแแฎแแแแ แแ, แแแแ แแ แแกแแ แแแคแแ แแแชแแแก แแ แแแแแแแแแแแแ แฉแแแฃแแแแ แแ แแฃแ แแแแแแแแ แแ แจแแกแแซแแแ แชแแ-แชแแแแ แจแแแแแแฎแ.
แแแแ แซแแแแแ แแฅแแแแ ...
แแแขแแ แ: แแแ แกแแ แแแ แแแแ, แแฃแแแ แแแขแแกแแก แกแแ แขแแคแแชแแ แแแฃแแ แแแแแแแกแขแ แแขแแ แ, แแ แแฅแขแแแแกแ แแแแแแแ แ แแแแแแแแแจแ , แกแแแแแ แ แแ แแฃแ แกแแก แจแแแฅแแแแแ .
แฌแงแแ แ: www.habr.com
