[ELK Stack] Ubuntu 22.04.3 모니터링 시스템 구축 feat.Docker & beat

 

 

 

Applied Elk Stack: Data Insights and Business Metrics with Collective Capability of Elasticsearch Log...

"이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."

 

 

 

🚀 Elastic Stack 구축

    🔽 개요

        📦 소개

이번에는 Linux Server들에 대한 자원 모니터링을 실시하고, 더불어 로그 분석도 할 수 있는 Elastic Stack(ELK)를 구축해 보려고 해요. 

ELK는 Elasticsearch, Logstash, Kibana라는 오픈 소스 프로젝트들을 하나로 뭉쳐 앞글자만 딴 것이에요.

Elasticsearch는 검색 분석 엔진이고, Logstash는 여러 소스에서 동시에 Data를 수집하여 변환한 뒤 Elasticsearch와 같은 stash로 전송하는 Server Side Data Pipeline이에요. Kibana는 사용자가 Elasticsearch에서 Chart와 Grahp를 이용하여 Data를 시각화할 수 있게 해 주는 도구에요.

Elastic Stack은 Elatic Stack이 발전한 도구에요.

최초 이 프로젝트는 Elasticsearch에서 영향을 받았다고 해요.
JSON 기반의 분산 오픈 소스 RESTFul 검색엔진으로 사용하기 쉽고, 확장 가능하고, 유연하며, 검색 분야에서는 사용자에게 많은 인기가 있는 도구이죠.

여기에 더불어 Logstash와 Kibana를 뭉쳐 하나의 서비스가 되었는데, 사용자 로그를 위해 Elasticsearch를 사용하고, 이것을 시각화 하고 싶다는 욕구에서 시작했어요.

그래서 강력한 수집 파이프라인인 Logstash와 유연한 시각화 도구 Kibana가 도입 되었다고 합니다.

또한, ELK에 Beat라는 것이 추가 되었는데, 이는 사용자들이 File을 추적하고 싶다는 요구를 했고, 이를 충족 시키기 위해 ELK Stack에 경량 단일 목적 데이터 수집기 제품인 Beat를 탄생 시켰다고 해요.

결국 ELK는 이러한 내용을 Log 및 Data 분석 도구에요.


1) ElasticSearch
  - ElasticSearch는 Lucene 기반으로 개발된 검색 엔진으로, Logstash를 통해 수신된 Data를 저장소에 저장하는 역할.
  - Web Interface와 Schema가 필요없는 JSON 문서를 갖춘 multitenant-capable full-text search 엔진 제공.
  - Data를 중심부에 저장하여 예상되는 항목을 검색하고, 예상치 못한 항목을 밝혀내는 기능.
  - 정형, 비정형, 위치정보, Metric 등 원하는 방법으로 다양한 유형의 검색을 수행하고, 결합.
  - 9200 Port.

2) Logstash
  - 오픈소스 서버 측 데이터 처리 파이프라인으로 다양한 소스에서 동시에 데이터를 수집하고,
     변환하여 stash 보관소로 전달.
  - 수집할 Log 선정 및 지정 대상 ElasticSearch에 Indexing하여 전달하는 역할.
  - Port 5044.

3) Kibana
  - Data 시각적으로 탐색, 실시간 분석 기능.
  - 시각화 담당 HTML + Javascript 엔진.
  - Port 5601

4) Beat
  - Server에 Agent로 설치하여 다양한 유형의 Data를 ElasticSearch 또는 Logstash에 전송하는 오픈 소스 데이터
     발송자.

 

ELK Stack은 ELK에 Beat가 추가되어 ELK Stack이라고 부르고 있어요.

1) Filebeat
  - File 전달 역할 (일반적으로 Log, .json Type의 File).

2) Auditbeat
  - Logstash 또는 Elastic Search로 Log를 보내기 전에 Linux Audit Framwork Data를 수집하고, File 무결성 Monitoring 역할.

3) Metricbeat
  - Logstash, Elastic Search로 직접 전송되기 전에 CPU, Memory 사용량, 부하 등의 System과 Service에서 Metric 수집하고, Network Data와 Process Data로부터 기타 Data 통계 수집.

4) Packetbeat
  - HTTP, DNS, Flows, DHCPv4, MySQL, TLS 등 Application 및 하위 Leve Protocol, Data Base 및 Key Storage의 Network Protocol 컬렉션 지원. 의심스러운 Network 접근 식별 기능

5) Heartbeat: Service 이용 가능 여부 판단하기 위하여 사용.

6) Winlogbeat: Windows Event Log 관리


최신 Major Release ELK Stack 8.0에는 다음과 같은 기능이 추가 되었어요.
  ∙ System Index 보호 강화
  ∙ 새로운 K-Nearest Neighbor(KNN) API
  ∙ 보안 기능 기본 활성화(HTTPS 및 인증)
  ∙ 7.x REST API 호환

 

설치하기 전에 주니쓰가 준비한 준비물은 아래와 같아요.

주니쓰는 Docker를 이용하여 각각 두 개의 VM 우분투 서버에 Elastic Search와 Kibana, Logstash를 설치해 볼게요.  

 

 

 

    🔽 ELK Stack

        📦 초기 환경 구성 - Elastic Search

최초 Docker(도커) 명령어를 이용하여 Elastic Search Container를 기동 시켜 줄건데, Shell Script(쉘 스크립트)를 만들어 작업해 볼게요.

cat elasticDockerRun.sh

 

#!/bin/bash

/docker/dockerManagement/docker-compose/elasticSearch/dockerRunShell.sh

docker exec -it junyss-elasticSearch bin/elasticsearch-plugin install analysis-nori

위 쉘 스크립트를 기동해 주면 dockerRunShell 이라는 쉘 스크립트가 기동 될거고, 그런 뒤 도커 컨테이너가 생성되면
그 컨테이너 내부에 nori를 설치할 수 있도록 스크립트를 만들어 주었어요.

cat dockerRunShell.sh

728x90

docker run -d \
--name junyss-elasticSearch \
--hostname junyss-elasticSearch \
-p 9200:9200 \
-p 9300:9300 \
-p 50000:50000 \
-e "discovery.type=single-node" \
-e "ES_JAVA_OPTS=-Xms1g -Xmx1g" \
-e bootstrap.memory_lock=true \
-e "xpack.security.enabled=true" \
-it -m 1GB \
--restart=unless-stopped \
docker.elastic.co/elasticsearch/elasticsearch:8.10.2

위와 같이 Elastic Search 8.10.2 컨테이너를 설치할 수 있도록 스크립트를 만들어 주었어요.

해당 쉘 스크립트에 chmod +x 명령어를 이용하여 실행 권한을 주어야 해요.

그런 뒤 elasticDockerRun.sh를 실행하면 Elastic Search가 설치될 거에요.



그런 뒤 해당 컨테이너에 접속하여 아래 명령어를 입력해 줍니다.

./bin/elasticsearch-setup-passwords interactive

그러면 Elastic Search 내에서 사용되는 계정에 대한 초기 비밀번호를 설정할 수 있어요.

 

 

 

 

        📦 초기 환경 구성 - Kibana

cat dockerRunCommand_kibana.sh

 

docker run -d \
--name junyss-kibana \
--hostname junyss-kibana \
-p 5601:5601 \
-e "ES_JAVA_OPTS=-Xms1g -Xmx1g" \
-it -m 1GB \
--restart=unless-stopped \
-v /docker/dirMapping/kibana/config:/usr/share/kibana/config \
docker.elastic.co/kibana/kibana:8.10.2

 

최초 위와 같이 명령어를 이용하여 kibana Container(컨테이너)를 기동해 주는데,
Shell Script를 만들어서 관리하고자 위와 같이 만들어 주었어요.

위 명령어를 통해 컨테이너를 백그라운드로 기동 시키고, Elasticsearch Java Option을 통해 최소 및 최대 Heap Memory Size를 각각 1GB로 설정해 주었어요.

그리고, -m Option을 통해 Container Memory Limit을 1GB로 설정해 주었어요.

 

/docker/dirMapping/kibana/config

위와 같이 Container 내부 디렉터리와 Host 디렉터리 매핑 시 들어갈 kibana.yml을 준비해 주었어요.

그런 뒤 키바나 도커를 기동 시키는 Shell Script에 실행 권한을 주고, 기동 시키면 기동이 된답니다.

 

 

 

 

        📦 초기 환경 구성 - Logstash

cat dockerRunCommand_logstash.sh

Logstash 역시 명령어로 컨테이너를 기동 시킬건데, 보다 편리한 관리를 위해 Shell Script로 만들어 주었어요.

키바나와 다른 점은 LS_JAVA_OPTS 부분인데, 환경 변수 설정 부분으로 Logstash의 Java Option을 설정하여 최소 및 최대 Heap Memory 크기를 각각 256MB로 설정하고, 병렬 Thread 수를 1로 설정해 준 부분이에요.

그리고, 컨테이너 Memory Limit을 256MB로 제한해 주었어요.

/docker/dirMapping/logstash/pipeline/logstash.conf

 

/docker/dirMapping/logstash/config

 

root@junyss-mng-service-ctn-host config(swift)# cat jvm.options
## JVM configuration

# Xms represents the initial size of total heap space
# Xmx represents the maximum size of total heap space

-Xms1g
-Xmx1g

################################################################
## Expert settings
################################################################
##
## All settings below this section are considered
## expert settings. Don't tamper with them unless
## you understand what you are doing
##
################################################################

## GC configuration
11-13:-XX:+UseConcMarkSweepGC
11-13:-XX:CMSInitiatingOccupancyFraction=75
11-13:-XX:+UseCMSInitiatingOccupancyOnly

## Locale
# Set the locale language
#-Duser.language=ko

# Set the locale country
#-Duser.country=KO

# Set the locale variant, if any
#-Duser.variant=

## basic

# set the I/O temp directory
#-Djava.io.tmpdir=$HOME

# set to headless, just in case
-Djava.awt.headless=true

# ensure UTF-8 encoding by default (e.g. filenames)
-Dfile.encoding=UTF-8

# use our provided JNA always versus the system one
#-Djna.nosys=true

# Turn on JRuby invokedynamic
-Djruby.compile.invokedynamic=true

## heap dumps

# generate a heap dump when an allocation from the Java heap fails
# heap dumps are created in the working directory of the JVM
-XX:+HeapDumpOnOutOfMemoryError

# specify an alternative path for heap dumps
# ensure the directory exists and has sufficient space
#-XX:HeapDumpPath=${LOGSTASH_HOME}/heapdump.hprof

## GC logging
#-Xlog:gc*,gc+age=trace,safepoint:file=@loggc@:utctime,pid,tags:filecount=32,filesize=64m

# log GC status to a file with time stamps
# ensure the directory exists
#-Xloggc:${LS_GC_LOG_FILE}

# Entropy source for randomness
-Djava.security.egd=file:/dev/urandom

# Copy the logging context from parent threads to children

 

 

root@junyss-mng-service-ctn-host config(swift)# cat log4j2.file.properties
status = error
name = LogstashPropertiesConfig

appender.console.type = Console
appender.console.name = plain_console
appender.console.layout.type = PatternLayout
appender.console.layout.pattern = [%d{ISO8601}][%-5p][%-25c]%notEmpty{[%X{pipeline.id}]}%notEmpty{[%X{plugin.id}]} %m%n

appender.json_console.type = Console
appender.json_console.name = json_console
appender.json_console.layout.type = JSONLayout
appender.json_console.layout.compact = true
appender.json_console.layout.eventEol = true

appender.rolling.type = RollingFile
appender.rolling.name = plain_rolling
appender.rolling.fileName = ${sys:ls.logs}/logstash-plain.log
appender.rolling.filePattern = ${sys:ls.logs}/logstash-plain-%d{yyyy-MM-dd}-%i.log.gz
appender.rolling.policies.type = Policies
appender.rolling.policies.time.type = TimeBasedTriggeringPolicy
appender.rolling.policies.time.interval = 1
appender.rolling.policies.time.modulate = true
appender.rolling.layout.type = PatternLayout
appender.rolling.layout.pattern = [%d{ISO8601}][%-5p][%-25c]%notEmpty{[%X{pipeline.id}]}%notEmpty{[%X{plugin.id}]} %m%n
appender.rolling.policies.size.type = SizeBasedTriggeringPolicy
appender.rolling.policies.size.size = 100MB
appender.rolling.strategy.type = DefaultRolloverStrategy
appender.rolling.strategy.max = 30
appender.rolling.avoid_pipelined_filter.type = PipelineRoutingFilter

appender.json_rolling.type = RollingFile
appender.json_rolling.name = json_rolling
appender.json_rolling.fileName = ${sys:ls.logs}/logstash-json.log
appender.json_rolling.filePattern = ${sys:ls.logs}/logstash-json-%d{yyyy-MM-dd}-%i.log.gz
appender.json_rolling.policies.type = Policies
appender.json_rolling.policies.time.type = TimeBasedTriggeringPolicy
appender.json_rolling.policies.time.interval = 1
appender.json_rolling.policies.time.modulate = true
appender.json_rolling.layout.type = JSONLayout
appender.json_rolling.layout.compact = true
appender.json_rolling.layout.eventEol = true
appender.json_rolling.policies.size.type = SizeBasedTriggeringPolicy
appender.json_rolling.policies.size.size = 100MB
appender.json_rolling.strategy.type = DefaultRolloverStrategy
appender.json_rolling.strategy.max = 30
appender.json_rolling.avoid_pipelined_filter.type = PipelineRoutingFilter

appender.routing.type = PipelineRouting
appender.routing.name = pipeline_routing_appender
appender.routing.pipeline.type = RollingFile
appender.routing.pipeline.name = appender-${ctx:pipeline.id}
appender.routing.pipeline.fileName = ${sys:ls.logs}/pipeline_${ctx:pipeline.id}.log
appender.routing.pipeline.filePattern = ${sys:ls.logs}/pipeline_${ctx:pipeline.id}.%i.log.gz
appender.routing.pipeline.layout.type = PatternLayout
appender.routing.pipeline.layout.pattern = [%d{ISO8601}][%-5p][%-25c] %m%n
appender.routing.pipeline.policy.type = SizeBasedTriggeringPolicy
appender.routing.pipeline.policy.size = 100MB
appender.routing.pipeline.strategy.type = DefaultRolloverStrategy
appender.routing.pipeline.strategy.max = 30

rootLogger.level = ${sys:ls.log.level}
rootLogger.appenderRef.console.ref = ${sys:ls.log.format}_console
rootLogger.appenderRef.rolling.ref = ${sys:ls.log.format}_rolling
rootLogger.appenderRef.routing.ref = pipeline_routing_appender

# Slowlog

appender.console_slowlog.type = Console
appender.console_slowlog.name = plain_console_slowlog
appender.console_slowlog.layout.type = PatternLayout
appender.console_slowlog.layout.pattern = [%d{ISO8601}][%-5p][%-25c] %m%n

appender.json_console_slowlog.type = Console
appender.json_console_slowlog.name = json_console_slowlog
appender.json_console_slowlog.layout.type = JSONLayout
appender.json_console_slowlog.layout.compact = true
appender.json_console_slowlog.layout.eventEol = true

appender.rolling_slowlog.type = RollingFile
appender.rolling_slowlog.name = plain_rolling_slowlog
appender.rolling_slowlog.fileName = ${sys:ls.logs}/logstash-slowlog-plain.log
appender.rolling_slowlog.filePattern = ${sys:ls.logs}/logstash-slowlog-plain-%d{yyyy-MM-dd}-%i.log.gz
appender.rolling_slowlog.policies.type = Policies
appender.rolling_slowlog.policies.time.type = TimeBasedTriggeringPolicy
appender.rolling_slowlog.policies.time.interval = 1
appender.rolling_slowlog.policies.time.modulate = true
appender.rolling_slowlog.layout.type = PatternLayout
appender.rolling_slowlog.layout.pattern = [%d{ISO8601}][%-5p][%-25c] %m%n
appender.rolling_slowlog.policies.size.type = SizeBasedTriggeringPolicy
appender.rolling_slowlog.policies.size.size = 100MB
appender.rolling_slowlog.strategy.type = DefaultRolloverStrategy
appender.rolling_slowlog.strategy.max = 30

appender.json_rolling_slowlog.type = RollingFile
appender.json_rolling_slowlog.name = json_rolling_slowlog
appender.json_rolling_slowlog.fileName = ${sys:ls.logs}/logstash-slowlog-json.log
appender.json_rolling_slowlog.filePattern = ${sys:ls.logs}/logstash-slowlog-json-%d{yyyy-MM-dd}-%i.log.gz
appender.json_rolling_slowlog.policies.type = Policies
appender.json_rolling_slowlog.policies.time.type = TimeBasedTriggeringPolicy
appender.json_rolling_slowlog.policies.time.interval = 1
appender.json_rolling_slowlog.policies.time.modulate = true
appender.json_rolling_slowlog.layout.type = JSONLayout
appender.json_rolling_slowlog.layout.compact = true
appender.json_rolling_slowlog.layout.eventEol = true
appender.json_rolling_slowlog.policies.size.type = SizeBasedTriggeringPolicy
appender.json_rolling_slowlog.policies.size.size = 100MB
appender.json_rolling_slowlog.strategy.type = DefaultRolloverStrategy
appender.json_rolling_slowlog.strategy.max = 30

logger.slowlog.name = slowlog
logger.slowlog.level = trace
logger.slowlog.appenderRef.console_slowlog.ref = ${sys:ls.log.format}_console_slowlog
logger.slowlog.appenderRef.rolling_slowlog.ref = ${sys:ls.log.format}_rolling_slowlog
logger.slowlog.additivity = false

logger.licensereader.name = logstash.licensechecker.licensereader
logger.licensereader.level = error

# Silence http-client by default
logger.apache_http_client.name = org.apache.http
logger.apache_http_client.level = fatal

# Deprecation log
appender.deprecation_rolling.type = RollingFile
appender.deprecation_rolling.name = deprecation_plain_rolling
appender.deprecation_rolling.fileName = ${sys:ls.logs}/logstash-deprecation.log
appender.deprecation_rolling.filePattern = ${sys:ls.logs}/logstash-deprecation-%d{yyyy-MM-dd}-%i.log.gz
appender.deprecation_rolling.policies.type = Policies
appender.deprecation_rolling.policies.time.type = TimeBasedTriggeringPolicy
appender.deprecation_rolling.policies.time.interval = 1
appender.deprecation_rolling.policies.time.modulate = true
appender.deprecation_rolling.layout.type = PatternLayout
appender.deprecation_rolling.layout.pattern = [%d{ISO8601}][%-5p][%-25c]%notEmpty{[%X{pipeline.id}]}%notEmpty{[%X{plugin.id}]} %m%n
appender.deprecation_rolling.policies.size.type = SizeBasedTriggeringPolicy
appender.deprecation_rolling.policies.size.size = 100MB
appender.deprecation_rolling.strategy.type = DefaultRolloverStrategy
appender.deprecation_rolling.strategy.max = 30

logger.deprecation.name = org.logstash.deprecation, deprecation
logger.deprecation.level = WARN
logger.deprecation.appenderRef.deprecation_rolling.ref = deprecation_plain_rolling
logger.deprecation.additivity = false

logger.deprecation_root.name = deprecation
logger.deprecation_root.level = WARN
logger.deprecation_root.appenderRef.deprecation_rolling.ref = deprecation_plain_rolling
logger.deprecation_root.additivity = false

 

 

root@junyss-mng-service-ctn-host config(swift)# cat log4j2.properties
status = error
name = LogstashPropertiesConfig

appender.console.type = Console
appender.console.name = plain_console
appender.console.layout.type = PatternLayout
appender.console.layout.pattern = [%d{ISO8601}][%-5p][%-25c]%notEmpty{[%X{pipeline.id}]}%notEmpty{[%X{plugin.id}]} %m%n

appender.json_console.type = Console
appender.json_console.name = json_console
appender.json_console.layout.type = JSONLayout
appender.json_console.layout.compact = true
appender.json_console.layout.eventEol = true

rootLogger.level = ${sys:ls.log.level}
rootLogger.appenderRef.console.ref = ${sys:ls.log.format}_console

 

cat logstash.yml

http.host: "0.0.0.0"
xpack.monitoring.elasticsearch.hosts: [ "http://{Elastic Search IP}:9200" ]

## X-Pack security credentials
xpack.monitoring.enabled: true
xpack.monitoring.elasticsearch.username: elastic
xpack.monitoring.elasticsearch.password: PASSWORD

 

 

cat pipelines.yml

 

# This file is where you define your pipelines. You can define multiple.
# For more information on multiple pipelines, see the documentation:
#   https://www.elastic.co/guide/en/logstash/current/multiple-pipelines.html

- pipeline.id: main
  path.config: "/usr/share/logstash/pipeline"

 

 

root@junyss-mng-service-ctn-host config(swift)# cat startup.options
################################################################################
# These settings are ONLY used by $LS_HOME/bin/system-install to create a custom
# startup script for Logstash and is not used by Logstash itself. It should
# automagically use the init system (systemd, upstart, sysv, etc.) that your
# Linux distribution uses.
#
# After changing anything here, you need to re-run $LS_HOME/bin/system-install
# as root to push the changes to the init script.
################################################################################

# Override Java location
#JAVACMD=/usr/bin/java

# Set a home directory
LS_HOME=/usr/share/logstash

# logstash settings directory, the path which contains logstash.yml
LS_SETTINGS_DIR=/etc/logstash

# Arguments to pass to logstash
LS_OPTS="--path.settings ${LS_SETTINGS_DIR}"

# Arguments to pass to java
LS_JAVA_OPTS=""

# pidfiles aren't used the same way for upstart and systemd; this is for sysv users.
LS_PIDFILE=/var/run/logstash.pid

# user and group id to be invoked as
LS_USER=logstash
LS_GROUP=logstash

# Enable GC logging by uncommenting the appropriate lines in the GC logging
# section in jvm.options
LS_GC_LOG_FILE=/var/log/logstash/gc.log

# Open file limit
LS_OPEN_FILES=16384

# Nice level
LS_NICE=19

# Change these to have the init script named and described differently
# This is useful when running multiple instances of Logstash on the same
# physical box or vm
SERVICE_NAME="logstash"
SERVICE_DESCRIPTION="logstash"

# If you need to run a command or script before launching Logstash, put it
# between the lines beginning with `read` and `EOM`, and uncomment those lines.
###
## read -r -d '' PRESTART << EOM
## EOM

 

위와 같이 Logstash 관련 구성 파일들을 미리 생성해서 넣어두고,
컨테이너와 디렉터리 매핑을 통해 전달 될 수 있도록 설정해 주었어요.

그런 뒤 컨테이너 기동 명령어가 들어있는 Script의 실행 권한을 주고, 실행하게 되면 컨테이너가 생성될 거에요.

 

docker ps -a

 

 

 

 

 

 

    🔽 초기 환경 구성 - Agent(beat)

wget -O - https://artifacts.elastic.co/GPG-KEY-elasticsearch | gpg --dearmor -o /etc/apt/keyrings/elasticsearch-keyring.gpg

최초 각 beat(비트)를 내려받기 위해서는 위와 같이 gpg Key를 내려 받아 주어야 해요.

1. wget -O - https://artifacts.elastic.co/GPG-KEY-elasticsearch   

  - wget: 웹에서 파일 내려 받을 때 사용하는 명령어. Elastci.co 웹 사이트에서 GPG-KEY_elasticsearch File
                내려 받기 위해 사용.

  - -O -: 내려 받기한 Data를 표준 출력(STDOUT)으로 출력하도록 지시. 즉, 내려받기한 Data를 화면에 출력.
  - " : Pipe 기호를 통해 이전 명령어의 결과를 다음 명령어의 입력으로 보내기 위해 사용.

2. gpg --dearmor -o /etc/apt/keyrings/elasticsearch-keyring.gpg

  - gpg: GNU Privacy Guard(GPG) 실행 시 사용. GPG는 암호화와 디지털 서명 다룰 때 사용.
  - --dearmor: GPG 키를 Decoding하여 Binary 형식에서 ASCII 형식으로 변환하기 위해 사용.
  - -o /etc/apt/keyrings/elasticsearch-keyring.gpg: Decoding된 GPG 키를 /etc/apt/keyrings 디렉터리에
     elasticsearch-keyring.gpg File로 저장하도록 지시. 이 Directory 와 File은 APT Package 관리자에서 사용되는
     GPG 키 저장 시 사용.

위 명령어는 Elastic.co의 GPG 키를 내려 받아 System(시스템)의 APT Package(패키지) 관리자에서 사용할 수 있도록 GPG 형식에서 ASCII 형식으로 변환하고, /etc/apt/keyrings/ Directory(디렉터리)에 elasticsearch-keyring.gpg File(파일)로 저장하게 하기 위한 명령어에요. 이를 통해 ElastciSearch와 관련된 패키지를 안전하게 설치하고, 업데이트할 수 있어요.

 

echo "deb [signed-by=/etc/apt/keyrings/elasticsearch-keyring.gpg] https://artifacts.elastic.co/packages/8.x/apt stable main" | tee /etc/apt/sources.list.d/elastic-8.x.list

위 명령어는 APT 패키지 관리자를 통해 ElasticSearch의 패키지를 설치하거나,
업데이트하기 위한 APT 저장소 추가 명령어에요.

1. echo "deb [signed-by=/etc/apt/keyrings/elasticsearch-keyring.gpg] https://artifacts.elastic.co/packages/8.x/apt stable main"  

  - echo: 인수로 전달된 문자열 표준 출력. ElasticSearch 패키지 저장소에 대한 APT Source 목록 정의를 위해 사용.
  - deb: Debian 패키지 형식 표현.
  - [signed-by=/etc/apt/keyrings/elasticsearch-keyring.gpg]: GPG 키가
     /etc/apt/keyrings/elasticsearch-keyring.gpg 파일로 서명되었음을 표현. 이것은 GPG 키의 유효성을 검증하여
     패키지의 무결성 보장.
  - https://artifacts.elastic.co/packages/8.x/apt: ElasticSearch 패키지 저장소의 URL.
  - stable: ElasticSearch 패키지 안정 버전 표현.
  - main: 저장소에서 사용한 Main Component 표현.

2. tee /etc/apt/sources.list.d/elastic-8.x.list

  - tee: 표준 입력에서 읽은 Data를 파일에 쓸 때 사용.
  - /etc/apt/sources.list.d/elastic-8.x.list: 앞에서 정의한 ElasticSearch 패키지 저장소 정보를 해당 파일에 쓰도록
    지시. 이 파일은 APT 패키지 관리자에게 사용 가능한 Source 목록 중 하나로 인식되며, 이 저장소에서 패키지 설치 및
    업데이트.

위 명령어는 ElastciSearch 패키지 저장소를 APT 패키지 관리자에 추가하고, 해당 저장소에서 제공하는 패키지를 시스템에 설치 및 업데이트 하기 위해 사용하는 명령어에요.

 

apt update

apt-get update && apt-get upgrade -y

 

그런 뒤 위와 같이 패키지를 최신화 하여 주었어요.

 

 

 

        📦 filebeat

apt install filebeat metricbeat auditbeat packetbeat

 

위와 같이 각 beat들을 먼저 설치해 줍니다.

vim /etc/filebeat/filebeat.yml [filebeat inputs]

 

28번째 줄에 enabled 부분을 true로 바꿔줍니다.

Paths 부분에는 Logging 하고자 하는 Log File에 위치를 명시해 주면 돼요.

vim /etc/filebeat/filebeat.yml [kibana]

setup.kibana:

  # Kibana Host
  # Scheme and port can be left out and will be set to the default (http and 5601)
  # In case you specify and additional path, the scheme is required: http://localhost:5601/path
  # IPv6 addresses should always be defined as: https://[2001:db8::1]:5601
  host: "192.168.20.253:5601"

115번째 줄에 Kibana의 IP주소를 적어주고, Kibana의 Port 번호를 명시해 줍니다.

 

vim /etc/filebeat/filebeat.yml [Elasticsearch Output]

 

output.elasticsearch:
  # Array of hosts to connect to.
  hosts: ["192.168.20.254:9200"]

  # Protocol - either `http` (default) or `https`.
  protocol: "http"

  # Authentication credentials - either API key or username/password.
  #api_key: "id:api_key"
  username: "elastic"
  password: "changeme"

142번째 줄에 Elastic Search IP와 Port 번호를 적어주고, 통신시 사용되는 Protocol을 145번째 줄에 작성해 주었어요.
그리고, 149~150번째에는 Elastic Search 계정을 입력해 줍니다.

 

vim /etc/filebeat/filebeat.yml [Logging]

logging.level: info
logging.to_files: true
logging.files:
  path: /var/log/filebeat
  name: filebeat
  keepfiles: 7
  permissions: 0640

filebeat에 대한 Log를 남기기 위해 위와 같이 작성해 주었어요.

 

filebeat setup -e -E output.logstash.enabled=false -E output.elasticsearch.hosts=['Elastic Search IP:9200'] -E setup.kibana.host=Kibana IP:5601

주니는 Elastic Search와 Kibana, Logstash가 다른 서버에 따로 설치 되어 있기 때문에 위 명령어를 사용해 주었어요.

위 명령어는 filebeat를 설정하고, 실행하는 명령어로 Elastic Search와 Kibana와의 통합을 설정하는데,
사용하는 명령어에요.

 

1. filebeat setup

  - setup: filebeat 초기 설정 구성 및 필요한 자원 생성.
  - -e: 명령어를 실행할 때, Logging을 활성화하고, filebeat Log 표시를 위해 사용.

2. -E output.logstash.enabled=false:

  - -E: filebeat 설정 지정을 위해 사용. output.logstash.enabled=false를 통해 Logstash를 통한 출력을 비활성화하고,
           Logstash로 데이터 전송 방지. 즉, 데이터를 Logstash를 거치지 않고, 바로 Elastic Search에 저장.

3. -E output.elasticsearch.hosts=['Elastic Search IP':'Elastic Search Port']: Elastic Search로의 출력 지정.

4. -E setup.kibana.host=Kibana IP:Kibana Port: Kibana Host 지정하여 filebeat를 Kibana와 연동

만약 모두 같은 서버에 설치 되어 있다면 아래 명령어를 입력하면 돼요.

filebeat setup -e  # -e : debug mode

 

 

systemctl enable --now filebeat

위 명령어를 통해 filebeat를 부팅 시 자동으로 서비스되게 서비스에 등록해 주고, 바로 Daemon(데몬)을 기동 시켜 주었어요.

 

 

Kibana: Analytics -> Discover

위와 같이 Kibana에 접속하여 왼쪽 Navigator에서 Analytics에 Discover를 들어가 줍니다.

 

 

그럼 위와 같이 filebeat-* 가 생긴걸 확인할 수 있어요.

위와 같이 Log를 확인할 수 있어요.

 

 

 

 

        📦 metricbeat

패키지는 위 filebeat에서 설치했기 때문에 이미 설치가 되어 있는 상태에요.

vim /etc/metricbeat/metricbeat.yml [kibana]

setup.kibana:

  # Kibana Host
  # Scheme and port can be left out and will be set to the default (http and 5601)
  # In case you specify and additional path, the scheme is required: http://localhost:5601/path
  # IPv6 addresses should always be defined as: https://[2001:db8::1]:5601
  host: "192.168.20.253:5601"

Kibana의 IP주소를 적어주고, Kibana의 Port 번호를 명시해 줍니다.

 

vim /etc/metricbeat/metricmeat.yml [Elasticsearch Output]

 

output.elasticsearch:
  # Array of hosts to connect to.
  hosts: ["192.168.20.254:9200"]

  # Protocol - either `http` (default) or `https`.
  protocol: "http"

  # Authentication credentials - either API key or username/password.
  #api_key: "id:api_key"
  username: "elastic"
  password: "changeme"

 

Elastic Search IP와 Port 번호를 적어주고, 통신시 사용되는 Protocol을 작성해 주었어요.
그리고, Elastic Search 계정을 입력해 줍니다.

 

 

vim /etc/metricbeat/metricmeat.yml [Logging]

 

logging.level: info
logging.to_files: true
logging.files:
  path: /var/log/metricbeat
  name: metricbeat
  keepfiles: 7
  permissions: 0640

 

metricbeat에 대한 Log를 남기기 위해 위와 같이 작성해 주었어요.

 

metricbeat modules list

 

위와 같이 모니터링 대상 서비스에 대해 모듈 목록을 확인할 수 있어요.

 

# 모듈 추가
metricbeat modules enable <module-name>

# 모듈 제거
metricbeat modules disable <module-name>

 

system은 기본적으로 추가가 되어 있고, 위와 같이 모니터링 하고자 하는 것들을 추가해 줄 수 있어요.

 

metricbeat test config

 

metricbeat test modules

 

 

metricbeat test output

 

위와 같이 정상적으로 통신이 되는지 test 해볼 수 있어요.

 

metricbeat setup -e -E output.logstash.enabled=false -E output.elasticsearch.hosts=['엘라스틱 서치 IP:9200'] -E setup.kibana.host=키바나 IP:5601

주니는 Elastic Search와 Kibana, Logstash가 다른 서버에 따로 설치 되어 있기 때문에 위 명령어를 사용해 주었어요.

위 명령어는 metricbeat를 설정하고, 실행하는 명령어로 Elastic Search와 Kibana와의 통합을 설정하는데,
사용하는 명령어에요.

 

만약 모두 같은 서버에 설치 되어 있다면 아래 명령어를 입력하면 돼요.

metricbeat setup -e

 

systemctl enable --now metricbeat

위 명령어를 통해 metricbeat를 부팅 시 자동으로 서비스되게 서비스에 등록해 주고,
바로 Daemon(데몬)을 기동 시켜 주었어요.

Kibana: Analytics -> Discover

위와 같이 metricmeat-*가 생긴걸 확인할 수 있어요.

Kibana: Analytics -> Dashboard

검색:Metricbeat System Overview ECS

 

 

Metricbeat System Overview ECS -> System Overview

이미 주니는 몇 개의 서버를 등록해놨기 때문에 위와 같이 호스트 개수가 4개로 찍히고 있고, 위에서 등록한 서버 호스트 junyss-os-controller가 보이는걸 확인할 수 있어요.

Metricbeat System Overview ECS -> Host Overview(junyss-os-controller)

 

Metricbeat System Overview ECS -> Host Overview(junyss-os-controller)

 

Metricbeat System Overview ECS -> Host Overview(junyss-os-controller)

 

Metricbeat System Overview ECS -> Host Overview(junyss-os-controller)

위와 같이 서버 사용량에 대해 다양한 확인을 할 수 있어요.

 

 

 

 

        📦 auditbeat

패키지는 위 filebeat에서 설치했기 때문에 이미 설치가 되어 있는 상태에요.

vim /etc/auditbeat/auditbeat.yml [kibana]

 

setup.kibana:

  # Kibana Host
  # Scheme and port can be left out and will be set to the default (http and 5601)
  # In case you specify and additional path, the scheme is required: http://localhost:5601/path
  # IPv6 addresses should always be defined as: https://[2001:db8::1]:5601
  host: "192.168.20.253:5601"

 

vim /etc/auditbeat/auditbeat.yml [Elasticsearch Output]

 

# ---------------------------- Elasticsearch Output ----------------------------
output.elasticsearch:
  # Array of hosts to connect to.
  hosts: ["192.168.20.254:9200"]

  # Protocol - either `http` (default) or `https`.
  protocol: "http"

  # Authentication credentials - either API key or username/password.
  #api_key: "id:api_key"
  username: "elastic"
  password: "password"

 

vim /etc/auditbeat/auditbeat.yml [Logging]

logging.level: info
logging.to_files: true
logging.files:
  path: /var/log/auditbeat
  name: auditbeat
  keepfiles: 7
  permissions: 0640

위에 다른 비트들과 동일하게 설정 파일을 구성해 주었어요.

 

auditbeat setup -e -E output.logstash.enabled=false -E output.elasticsearch.hosts=['엘라스틱 서치 IP:9200'] -E setup.kibana.host=키바나 IP:5601

 

systemctl enable --now auditbeat

위와 같이 auditbeat 데몬을 기동 시키고, 서비스에 등록해 주었어요.

 

Kibana -> Discover

키바나에 위와 같이 auditbeat-*가 생긴걸 확인할 수 있어요.

 

검색: Auditbeat System System Overview ECS

키바나에 Dashboards에서 위와 같이 검색하면 감사 관련 모니터링을 할 수 있어요.

 

Auditbeat System Overview ECS -> System Overview

 

 

 

 

 

        📦 packetbeat

패키지는 위 filebeat에서 설치했기 때문에 이미 설치가 되어 있는 상태에요.

vim /etc/packetbeat/packetbeat.yml [kibana]

setup.kibana:

  # Kibana Host
  # Scheme and port can be left out and will be set to the default (http and 5601)
  # In case you specify and additional path, the scheme is required: http://localhost:5601/path
  # IPv6 addresses should always be defined as: https://[2001:db8::1]:5601
  host: "192.168.20.253:5601"

 

vim /etc/packetbeat/packetbeat.yml [Elasticsearch Output]

 

output.elasticsearch:
  # Array of hosts to connect to.
  hosts: ["192.168.20.254:9200"]

  # Protocol - either `http` (default) or `https`.
  protocol: "http"

  # Authentication credentials - either API key or username/password.
  #api_key: "id:api_key"
  username: "elastic"
  password: "changeme"

 

vim /etc/packetbeat/packetbeat.yml [Logging]

logging.level: info
logging.to_files: true
logging.files:
  path: /var/log/packetbeat
  name: packetbeat
  keepfiles: 7
  permissions: 0640

 

위 내용도 다른 비트처럼 동일하게 수정해 주었어요.

 

packetbeat setup -e -E output.logstash.enabled=false -E output.elasticsearch.hosts=['엘라스틱 서치 IP:9200'] -E setup.kibana.host=키바나 IP:5601

systemctl enable --now packetbeat

packetbeat도 서비스에 등록하고, 기동 시켜 줍니다.

 

키바나에 Discover에 위와 같이 packetbeat-*가 만들어진걸 확인할 수 있어요.

 

 

검색: Packetbeat Overview ECS

Dashboards에서 위와 같이 검색을 하여 Dashboard를 확인해 줄게요.

 

위와 같이 Network 관련 모니터링을 할 수 있게 되었어요.

 

 

 

 

        📦 heartbeat-elastic

apt install heartbeat-elastic

최초 위와 같이 패키지를 설치해 줍니다.

vim /etc/heartbeat/heartbeat.yml [Heartbeat]

 

- type: icmp
  schedule: '59 * * * * * *'
  hosts:
    - "192.168.0.2"
    - "192.168.0.3"
    - "192.168.0.4"
    - "192.168.20.2"
    - "192.168.20.3"
    - "192.168.20.4"
    - "192.168.20.5"
    - "192.168.20.251"
    - "192.168.20.252"
    - "192.168.20.254"
    - "192.168.30.2"
  id: junyss-icmp-service
  name: Junyss ICMP Service

최초 위와 같이 Ping Test를 이용하여 해당 서버가 살아있는지 확인할 대상 서버의 IP를 작성해 주었어요.

schedule에는 Linux Crontab 방식으로 작동 시간을 설정해 주었는데,
주니는 매 59분 마다 동작하도록 설정해 주었어요.

 

vim /etc/heartbeat/heartbeat.yml [Heartbeat]

위 내용은 tcp를 이용하여 MariaDB가 정상적으로 구동중인지 확인하기 위한 부분이에요.

매일 1800초 간격으로 확인할 수 있도록 설정해 주었어요.

vim /etc/heartbeat/heartbeat.yml [Heartbeat]

그리고 위 내용은 http Protocol을 통해 서비스하는 서비스가 잘 동작중인지 확인하기 위한 부분이에요.

heartbeat.config.monitors:
  # Directory + glob pattern to search for configuration files
  path: ${path.config}/monitors.d/*.yml
  # If enabled, heartbeat will periodically check the config.monitors path for changes
  reload.enabled: true
  # How often to check for changes
  reload.period: 5s

# Configure monitors inline
heartbeat.monitors:
- type: icmp
  schedule: '59 * * * * * *'
  hosts:
    - "192.168.0.2"
    - "192.168.0.3"
    - "192.168.0.4"
    - "192.168.20.2"
    - "192.168.20.3"
    - "192.168.20.4"
    - "192.168.20.5"
    - "192.168.20.251"
    - "192.168.20.252"
    - "192.168.20.254"
    - "192.168.30.2"
  id: junyss-icmp-service
  name: Junyss ICMP Service

- type: tcp
  schedule: '@every 1800s'
  hosts:
    - "192.168.20.254:3306"
  mode: any
  id: junyss-tcp-service

- type: http
  # Set enabled to true (or delete the following line) to enable this monitor
  enabled: true
  # ID used to uniquely identify this monitor in Elasticsearch even if the config changes
  id: heartbeat_http_check_ID
  # Human readable display name for this service in Uptime UI and elsewhere
  name: Junyss HTTP Check With heartbeat Monitor
  # List of URLs to query
  urls:
    - "192.168.20.3:80"
    - "192.168.20.253:5601"
    - "192.168.20.254:9200"
  # Configure task schedule
  schedule: '@every 1800s'

 

 

vim /etc/heartbeat/heartbeat.yml [kibana]

 

setup.kibana:

  # Kibana Host
  # Scheme and port can be left out and will be set to the default (http and 5601)
  # In case you specify and additional path, the scheme is required: http://localhost:5601/path
  # IPv6 addresses should always be defined as: https://[2001:db8::1]:5601
  host: "192.168.20.253:5601"

 

 

vim /etc/heartbeat/heartbeat.yml [Elasticsearch Output]

 

output.elasticsearch:
  # Array of hosts to connect to.
  hosts: ["192.168.20.254:9200"]

  # Protocol - either `http` (default) or `https`.
  protocol: "http"

  # Authentication credentials - either API key or username/password.
  #api_key: "id:api_key"
  username: "elastic"
  password: "password"

 

 

vim /etc/heartbeat/heartbeat.yml [Logging]

반응형

logging.level: info
logging.to_files: true
logging.files:
  path: /var/log/heartbeat
  name: heartbeat
  keepfiles: 7
  permissions: 0640

 

위 내용은 다른 비트와 동일하게 변경해 주었어요.

 

 

heartbeat setup -e -E output.logstash.enabled=false -E output.elasticsearch.hosts=['엘라스틱 서치 IP:9200'] -E setup.kibana.host=키바나 IP:5601

 

 

systemctl enable --now heartbeat-elastic

위와 같이 heartbeat 데몬을 기동 시키고, 서비스에 등록해 주었어요.

 

 

heartbeat의 경우 다른 beat 처럼 Discover에 자동으로 등록되지 않아 직접 등록해 주어야 해요.

 

위와 같이 이름과 Index pattern을 등록하고, Timestamp field를 선택한 뒤
아래 Save data view to Kibana 버튼을 눌러줍니다.

 

 

그럼 위와 같이 heartbeat가 만들어 진걸 확인할 수 있어요.

 

 

왼쪽 Navigator에 Observability에 보면 Uptime Tab이 만들어졌을 거에요.

이제 위와 같이 등록했던 서비스들이 구동되고 있는지를 확인할 수 있어요.

 

 

 

 

 

 

        📦 Winlogbeat

https://www.elastic.co/kr/beats/winlogbeat

 

최초 위 사이트에서 윈도우용 beat를 내려 받아 줄게요.

 

 

위와 같이 내려 받기 해 주었어요.

 

 

beat 압축해제

 

압축해제 된 파일을 C:\ 밑에 넣어줍니다.

 

 

winlogbeat.yml

 

winlogbeat.yml [Kibana]

 

참고로 allow_older_version은 버전에 따른 호환 문제 발생을 방지하기 위해 넣어준 내용이에요.

 

winlogbeat.yml [Elasticsearch Outputs]

위의 리눅스의 각종 비트와 마찬가지로 yml 파일을 수정해 주었어요.

 

 

 

Power Shell을 위와 같이 관리자 권한으로 실행해 줍니다.

 

 

 

PowerShell.exe -ExecutionPolicy UnRestricted -File .\install-service-filebeat.ps1

 

.\winlogbeat.exe test config -c .\winlogbeat.yml -e

 

.\winlogbeat.exe setup -e

 

 

Start-Service winlogbeat

위 명령어로 beat를 실행해 주었어요.

 

 

 

키바나의 Discover에 가보면 위와 같이 winlogbeat-*가 생긴걸 확인할 수 있어요.

검색: Winlogbeat Overview

Dashboards에 위와 같이 Template이 생기었고, 위의 Template을 선택해 볼게요.

위와 같이 윈도우를 모니터링 할 수 있게 되었어요.

 

 

 

 

 

데이터 분석 플랫폼 구축과 활용 : Fluentd Elasticsearch Kibana를 이용한 로그 수집과 시각화

"이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."

 

 

 

 

 

🧐 참고 자료

Monitor Linux System Metrics with ELK Stack - kifarunix.com

 

Elastic 가이드 북 - Elastic 가이드북

 

Kibana - Elasticsearch 연동하면서 발생한 트러블 슈팅