Triển khai ELK Stack bằng Docker Compose cho Cụm Elasticsearch 3 Node

Bài viết này hướng dẫn chi tiết cách thiết lập một cụm ELK (Elasticsearch, Logstash, Kibana) sử dụng Docker Compose, tập trung vào việc xây dựng một cụm Elasticsearch gồm 3 node để đảm bảo tính sẵn sàng cao và khả năng mở rộng. Chúng ta sẽ tận dụng Filebeat làm trình thu thập nhật ký, Logstash để xử lý dữ liệu và Kibana để trực quan hóa.

Tổng quan Kiến trúc Hệ thống

Luồng dữ liệu nhật ký được thiết lập như sau:

  1. Filebeat: Đóng vai trò là tác nhân thu thập nhật ký từ các nguồn khác nhau và gửi chúng đến Elasticsearch.
  2. Elasticsearch: Lưu trữ, lập chỉ mục và cho phép tìm kiếm/phân tích dữ liệu nhật ký. Cấu hình bao gồm 3 node để tăng cường khả năng chịu lỗi và hiệu suất.
  3. Kibana: Giao diện web để khám phá, trực quan hóa và theo dõi dữ liệu nhật ký được lưu trữ trong Elasticsearch.

Sơ đồ luồng dữ liệu:

+-----------------+       +----------------+
|                 |       |                |
|    Filebeat     |  -->  |  Elasticsearch |
|                 |       |                |
+-----------------+       +----------------+
                                  ^
                                  |
                          +---------------+
                          |               |
                          |    Kibana     |
                          |               |
                          +---------------+

Chuẩn bị Môi trường

Đảm bảo bạn đã cài đặt Docker và Docker Compose trên các máy chủ sẽ tham gia vào cụm ELK.

Cấu hình tệp hosts trên các node:

10.1.205.165  elk-node1
10.1.205.166  elk-node2
10.1.205.167  elk-node3

Triển khai Cụm Elasticsearch

Chúng ta sẽ sử dụng một phương pháp từng bước để thiết lập cụm 3 node. Ban đầu, chúng ta sẽ khởi tạo một node với khả năng tạo chứng chỉ và dữ liệu, sau đó đồng bộ chúng sang các node còn lại.

Bước 1: Khởi tạo cấu hình ban đầu trên elk-node1

  1. Tạo thư mục cấu hình: 
    mkdir -p /data/docker/elk
cd /data/docker/elk
mkdir -p es01/data es02/data es03/data kibana
chown 1000.1000 -R es01/data es02/data es03/data kibana
  2. Tạo tệp .env để chứa các biến môi trường: 
    # Password for the 'elastic' user (at least 6 characters)
ELASTIC_PASSWORD=YourStrongElasticPassword

# Password for the 'kibana_system' user (at least 6 characters)
KIBANA_PASSWORD=YourStrongKibanaPassword

# Version of Elastic products
STACK_VERSION=8.15.0

# Set the cluster name
CLUSTER_NAME=docker-cluster

# Set to 'basic' or 'trial' to automatically start the 30-day trial
LICENSE=basic

# Port to expose Elasticsearch HTTP API to the host
ES_PORT=9200

# Port to expose Kibana to the host
KIBANA_PORT=5601

# Increase or decrease based on the available host memory (in bytes)
MEM_LIMIT=1073741824
  3. Tạo tệp docker-compose.yml. Tệp này bao gồm một service setup để tạo chứng chỉ và cấu hình ban đầu cho cụm. 
    version: "2.2"

services:
  setup:
    image: docker.elastic.co/elasticsearch/elasticsearch:${STACK_VERSION}
    volumes:
      - ./certs:/usr/share/elasticsearch/config/certs
    user: "0"
    command: >
      bash -c '
        if [ x${ELASTIC_PASSWORD} == x ]; then echo "Set the ELASTIC_PASSWORD environment variable"; exit 1; fi;
        if [ x${KIBANA_PASSWORD} == x ]; then echo "Set the KIBANA_PASSWORD environment variable"; exit 1; fi;
        if [ ! -f config/certs/ca.zip ]; then
          echo "Creating CA";
          bin/elasticsearch-certutil ca --silent --pem -out config/certs/ca.zip;
          unzip config/certs/ca.zip -d config/certs;
        fi;
        if [ ! -f config/certs/certs.zip ]; then
          echo "Creating certs";
          echo -ne "instances:\n  - name: es01\n    dns:\n      - es01\n      - localhost\n    ip:\n      - 127.0.0.1\n  - name: es02\n    dns:\n      - es02\n      - localhost\n    ip:\n      - 127.0.0.1\n  - name: es03\n    dns:\n      - es03\n      - localhost\n    ip:\n      - 127.0.0.1\n" > config/certs/instances.yml;
          bin/elasticsearch-certutil cert --silent --pem -out config/certs/certs.zip --in config/certs/instances.yml --ca-cert config/certs/ca/ca.crt --ca-key config/certs/ca/ca.key;
          unzip config/certs/certs.zip -d config/certs;
        fi;
        echo "Setting file permissions";
        chown -R root:root config/certs;
        find . -type d -exec chmod 750 \{\} \;;
        find . -type f -exec chmod 640 \{\} \;;
        echo "Waiting for Elasticsearch availability";
        until curl -s --cacert config/certs/ca.crt https://es01:9200 | grep -q "missing authentication credentials"; do sleep 30; done;
        echo "Setting kibana_system password";
        until curl -s -X POST --cacert config/certs/ca.crt -u "elastic:${ELASTIC_PASSWORD}" -H "Content-Type: application/json" https://es01:9200/_security/user/kibana_system/_password -d "{\"password\":\"${KIBANA_PASSWORD}\"}" | grep -q "^{}"; do sleep 10; done;
        echo "All done!";
      '
    healthcheck:
      test: ["CMD-SHELL", "[ -f config/certs/es01/es01.crt ]"]
      interval: 1s
      timeout: 5s
      retries: 120

  es01:
    depends_on:
      setup:
        condition: service_healthy
    image: docker.elastic.co/elasticsearch/elasticsearch:${STACK_VERSION}
    volumes:
      - ./certs:/usr/share/elasticsearch/config/certs
      - ./es01/data:/usr/share/elasticsearch/data:rw
    ports:
      - ${ES_PORT}:9200
    restart: always
    environment:
      - node.name=es01
      - cluster.name=${CLUSTER_NAME}
      - cluster.initial_master_nodes=es01,es02,es03
      - discovery.seed_hosts=es02,es03
      - ELASTIC_PASSWORD=${ELASTIC_PASSWORD}
      - bootstrap.memory_lock=true
      - xpack.security.enabled=true
      - xpack.security.http.ssl.enabled=true
      - xpack.security.http.ssl.key=certs/es01/es01.key
      - xpack.security.http.ssl.certificate=certs/es01/es01.crt
      - xpack.security.http.ssl.certificate_authorities=certs/ca/ca.crt
      - xpack.security.transport.ssl.enabled=true
      - xpack.security.transport.ssl.key=certs/es01/es01.key
      - xpack.security.transport.ssl.certificate=certs/es01/es01.crt
      - xpack.security.transport.ssl.certificate_authorities=certs/ca/ca.crt
      - xpack.security.transport.ssl.verification_mode=certificate
      - xpack.license.self_generated.type=${LICENSE}
    mem_limit: ${MEM_LIMIT}
    ulimits:
      memlock:
        soft: -1
        hard: -1
    healthcheck:
      test: ["CMD-SHELL", "curl -s --cacert config/certs/ca.crt https://localhost:9200 | grep -q 'missing authentication credentials'"]
      interval: 10s
      timeout: 10s
      retries: 120

  es02:
    depends_on:
      - es01
    image: docker.elastic.co/elasticsearch/elasticsearch:${STACK_VERSION}
    volumes:
      - ./certs:/usr/share/elasticsearch/config/certs
      - ./es02/data:/usr/share/elasticsearch/data:rw
    restart: always
    environment:
      - node.name=es02
      - cluster.name=${CLUSTER_NAME}
      - cluster.initial_master_nodes=es01,es02,es03
      - discovery.seed_hosts=es01,es03
      - ELASTIC_PASSWORD=${ELASTIC_PASSWORD}
      - bootstrap.memory_lock=true
      - xpack.security.enabled=true
      - xpack.security.http.ssl.enabled=true
      - xpack.security.http.ssl.key=certs/es02/es02.key
      - xpack.security.http.ssl.certificate=certs/es02/es02.crt
      - xpack.security.http.ssl.certificate_authorities=certs/ca/ca.crt
      - xpack.security.transport.ssl.enabled=true
      - xpack.security.transport.ssl.key=certs/es02/es02.key
      - xpack.security.transport.ssl.certificate=certs/es02/es02.crt
      - xpack.security.transport.ssl.certificate_authorities=certs/ca/ca.crt
      - xpack.security.transport.ssl.verification_mode=certificate
      - xpack.license.self_generated.type=${LICENSE}
    mem_limit: ${MEM_LIMIT}
    ulimits:
      memlock:
        soft: -1
        hard: -1
    healthcheck:
      test: ["CMD-SHELL", "curl -s --cacert config/certs/ca.crt https://localhost:9200 | grep -q 'missing authentication credentials'"]
      interval: 10s
      timeout: 10s
      retries: 120

  es03:
    depends_on:
      - es02
    image: docker.elastic.co/elasticsearch/elasticsearch:${STACK_VERSION}
    volumes:
      - ./certs:/usr/share/elasticsearch/config/certs
      - ./es03/data:/usr/share/elasticsearch/data:rw
    restart: always
    environment:
      - node.name=es03
      - cluster.name=${CLUSTER_NAME}
      - cluster.initial_master_nodes=es01,es02,es03
      - discovery.seed_hosts=es01,es02
      - ELASTIC_PASSWORD=${ELASTIC_PASSWORD}
      - bootstrap.memory_lock=true
      - xpack.security.enabled=true
      - xpack.security.http.ssl.enabled=true
      - xpack.security.http.ssl.key=certs/es03/es03.key
      - xpack.security.http.ssl.certificate=certs/es03/es03.crt
      - xpack.security.http.ssl.certificate_authorities=certs/ca/ca.crt
      - xpack.security.transport.ssl.enabled=true
      - xpack.security.transport.ssl.key=certs/es03/es03.key
      - xpack.security.transport.ssl.certificate=certs/es03/es03.crt
      - xpack.security.transport.ssl.certificate_authorities=certs/ca/ca.crt
      - xpack.security.transport.ssl.verification_mode=certificate
      - xpack.license.self_generated.type=${LICENSE}
    mem_limit: ${MEM_LIMIT}
    ulimits:
      memlock:
        soft: -1
        hard: -1
    healthcheck:
      test: ["CMD-SHELL", "curl -s --cacert config/certs/ca.crt https://localhost:9200 | grep -q 'missing authentication credentials'"]
      interval: 10s
      timeout: 10s
      retries: 120

  kibana:
    depends_on:
      es01:
        condition: service_healthy
      es02:
        condition: service_healthy
      es03:
        condition: service_healthy
    image: docker.elastic.co/kibana/kibana:${STACK_VERSION}
    volumes:
      - ./certs:/usr/share/kibana/config/certs
      - ./kibana/data:/usr/share/kibana/data:rw
    ports:
      - ${KIBANA_PORT}:5601
    environment:
      - SERVERNAME=kibana
      - ELASTICSEARCH_HOSTS=https://es01:9200
      - ELASTICSEARCH_USERNAME=kibana_system
      - ELASTICSEARCH_PASSWORD=${KIBANA_PASSWORD}
      - ELASTICSEARCH_SSL_CERTIFICATEAUTHORITIES=config/certs/ca.crt
    mem_limit: ${MEM_LIMIT}
    healthcheck:
      test: ["CMD-SHELL", "curl -s -I http://localhost:5601 | grep -q 'HTTP/1.1 302 Found'"]
      interval: 10s
      timeout: 10s
      retries: 120
  4. Khởi chạy Docker Compose: 
    docker-compose up -d
  5. Truy cập Kibana qua trình duyệt tại https://elk-node1:5601 với người dùng elastic và mật khẩu đã đặt trong tệp .env.
  6. Sau khi xác nhận mọi thứ hoạt động, dừng cụm: 
    docker-compose down

Bước 2: Đồng bộ cấu hình và chứng chỉ sang các node khác

Trên elk-node1, sử dụng rsync để sao chép các tệp cần thiết sang elk-node2 và elk-node3.

# Trên elk-node1:
# Tạo thư mục tương ứng trên node 2 và 3 trước
rsync -avz /data/docker/elk/.env elk-node2:/data/docker/elk/.env
rsync -avz /data/docker/elk/docker-compose.yml elk-node2:/data/docker/elk/docker-compose.yml
rsync -avz /data/docker/elk/certs/ elk-node2:/data/docker/elk/certs/
rsync -avz /data/docker/elk/es02/ elk-node2:/data/docker/elk/es02/

rsync -avz /data/docker/elk/.env elk-node3:/data/docker/elk/.env
rsync -avz /data/docker/elk/docker-compose.yml elk-node3:/data/docker/elk/docker-compose.yml
rsync -avz /data/docker/elk/certs/ elk-node3:/data/docker/elk/certs/
rsync -avz /data/docker/elk/es03/ elk-node3:/data/docker/elk/es03/

Bước 3: Cấu hình và Khởi chạy từng Node Elasticsearch

Đối với mỗi node (elk-node1, elk-node2, elk-node3), chúng ta cần điều chỉnh tệp docker-compose.yml để chỉ chạy node tương ứng và các dịch vụ phụ thuộc cần thiết.

elk-node1 (Cấu hình tương tự như Bước 1, nhưng loại bỏ service setup và chỉ định es01)

Chỉnh sửa docker-compose.yml trên elk-node1:

  • Bỏ comment phần setup và các dependency của es01.
  • Đảm bảo es01 có cấu hình đúng, bao gồm network_mode: host và extra_hosts.
  • Chỉ chạy es01 và kibana.
version: "2.2"

services:
  es01:
    container_name: es01
    image: docker.elastic.co/elasticsearch/elasticsearch:${STACK_VERSION}
    volumes:
      - ./certs:/usr/share/elasticsearch/config/certs
      - ./es01/data:/usr/share/elasticsearch/data:rw
    ports:
      - ${ES_PORT}:9200
      - 9300:9300
    restart: always
    network_mode: host
    extra_hosts:
	  - "es01:10.1.205.165"
      - "es02:10.1.205.166"
      - "es03:10.1.205.167"
    environment:
      - node.name=es01
      - cluster.name=${CLUSTER_NAME}
      - cluster.initial_master_nodes=es01,es02,es03
      - discovery.seed_hosts=es02,es03
      - ELASTIC_PASSWORD=${ELASTIC_PASSWORD}
      - bootstrap.memory_lock=true
      - xpack.security.enabled=true
      - xpack.security.http.ssl.enabled=true
      - xpack.security.http.ssl.key=certs/es01/es01.key
      - xpack.security.http.ssl.certificate=certs/es01/es01.crt
      - xpack.security.http.ssl.certificate_authorities=certs/ca/ca.crt
      - xpack.security.transport.ssl.enabled=true
      - xpack.security.transport.ssl.key=certs/es01/es01.key
      - xpack.security.transport.ssl.certificate=certs/es01/es01.crt
      - xpack.security.transport.ssl.certificate_authorities=certs/ca/ca.crt
      - xpack.security.transport.ssl.verification_mode=certificate
      - xpack.license.self_generated.type=${LICENSE}
    mem_limit: ${MEM_LIMIT}
    ulimits:
      memlock:
        soft: -1
        hard: -1
    healthcheck:
      test: ["CMD-SHELL", "curl -s --cacert config/certs/ca.crt https://localhost:9200 | grep -q 'missing authentication credentials'"]
      interval: 10s
      timeout: 10s
      retries: 120

  kibana:
    depends_on:
      es01:
        condition: service_healthy
    image: docker.elastic.co/kibana/kibana:${STACK_VERSION}
    volumes:
      - ./certs:/usr/share/kibana/config/certs
      - ./kibana/data:/usr/share/kibana/data:rw
    ports:
      - ${KIBANA_PORT}:5601
    environment:
      - SERVERNAME=kibana
      - ELASTICSEARCH_HOSTS=https://es01:9200
      - ELASTICSEARCH_USERNAME=kibana_system
      - ELASTICSEARCH_PASSWORD=${KIBANA_PASSWORD}
      - ELASTICSEARCH_SSL_CERTIFICATEAUTHORITIES=config/certs/ca.crt
    mem_limit: ${MEM_LIMIT}
    healthcheck:
      test: ["CMD-SHELL", "curl -s -I http://localhost:5601 | grep -q 'HTTP/1.1 302 Found'"]
      interval: 10s
      timeout: 10s
      retries: 120

Khởi chạy: docker-compose up -d

elk-node2 (Chỉ chạy es02)

Chỉnh sửa docker-compose.yml trên elk-node2:

  • Loại bỏ service setup và kibana.
  • Cấu hình es02 với network_mode: host và extra_hosts, đảm bảo discovery.seed_hosts bao gồm các node khác (es01, es03).
  • Thêm một service giả test_es01 để đảm bảo es01 đã sẵn sàng trước khi es02 khởi động.
version: "2.2"

services:
  test_es01:
    image: docker.elastic.co/elasticsearch/elasticsearch:${STACK_VERSION}
    volumes:
      - ./certs:/usr/share/elasticsearch/config/certs
    user: "0"
    extra_hosts:
      - "es01:10.1.205.165"
      - "es02:10.1.205.166"
      - "es03:10.1.205.167"
    restart: always
    network_mode: host
    command: >
      bash -c '
        sleep infinity
      '
    healthcheck:
      test: ["CMD-SHELL", "curl -s --cacert config/certs/ca.crt https://es01:9200 | grep -q 'missing authentication credentials'"]
      interval: 10s
      timeout: 10s
      retries: 120

  es02:
    depends_on:
      test_es01:
        condition: service_healthy
    container_name: es02
    image: docker.elastic.co/elasticsearch/elasticsearch:${STACK_VERSION}
    extra_hosts:
      - "es01:10.1.205.165"
      - "es02:10.1.205.166"
      - "es03:10.1.205.167"
    ports:
      - ${ES_PORT}:9200
      - 9300:9300
    volumes:
      - ./certs:/usr/share/elasticsearch/config/certs
      - ./es02/data:/usr/share/elasticsearch/data:rw
    restart: always
    environment:
      - node.name=es02
      - cluster.name=${CLUSTER_NAME}
      - cluster.initial_master_nodes=es01,es02,es03
      - discovery.seed_hosts=es01,es03
      - ELASTIC_PASSWORD=${ELASTIC_PASSWORD}
      - bootstrap.memory_lock=true
      - xpack.security.enabled=true
      - xpack.security.http.ssl.enabled=true
      - xpack.security.http.ssl.key=certs/es02/es02.key
      - xpack.security.http.ssl.certificate=certs/es02/es02.crt
      - xpack.security.http.ssl.certificate_authorities=certs/ca/ca.crt
      - xpack.security.transport.ssl.enabled=true
      - xpack.security.transport.ssl.key=certs/es02/es02.key
      - xpack.security.transport.ssl.certificate=certs/es02/es02.crt
      - xpack.security.transport.ssl.certificate_authorities=certs/ca/ca.crt
      - xpack.security.transport.ssl.verification_mode=certificate
      - xpack.license.self_generated.type=${LICENSE}
    mem_limit: ${MEM_LIMIT}
    ulimits:
      memlock:
        soft: -1
        hard: -1
    healthcheck:
      test: ["CMD-SHELL", "curl -s --cacert config/certs/ca.crt https://localhost:9200 | grep -q 'missing authentication credentials'"]
      interval: 10s
      timeout: 10s
      retries: 120

Khởi chạy: docker-compose up -d

elk-node3 (Chỉ chạy es03)

Chỉnh sửa docker-compose.yml trên elk-node3:

  • Tương tự elk-node2, loại bỏ setup và kibana.
  • Cấu hình es03 với network_mode: host và extra_hosts, đảm bảo discovery.seed_hosts bao gồm es01, es02.
  • Thêm service giả test_es02 để đợi es02 sẵn sàng.
version: "2.2"

services:
  test_es02:
    image: docker.elastic.co/elasticsearch/elasticsearch:${STACK_VERSION}
    volumes:
      - ./certs:/usr/share/elasticsearch/config/certs
    user: "0"
    extra_hosts:
      - "es01:10.1.205.165"
      - "es02:10.1.205.166"
      - "es03:10.1.205.167"
    restart: always
    network_mode: host
    command: >
      bash -c '
        sleep infinity
      '
    healthcheck:
      test: ["CMD-SHELL", "curl -s --cacert config/certs/ca.crt https://es02:9200 | grep -q 'missing authentication credentials'"]
      interval: 10s
      timeout: 10s
      retries: 120

  es03:
    depends_on:
      test_es02:
        condition: service_healthy
    container_name: es03
    image: docker.elastic.co/elasticsearch/elasticsearch:${STACK_VERSION}
    volumes:
      - ./certs:/usr/share/elasticsearch/config/certs
      - ./es03/data:/usr/share/elasticsearch/data:rw
    restart: always
    environment:
      - node.name=es03
      - cluster.name=${CLUSTER_NAME}
      - cluster.initial_master_nodes=es01,es02,es03
      - discovery.seed_hosts=es01,es02
      - ELASTIC_PASSWORD=${ELASTIC_PASSWORD}
      - bootstrap.memory_lock=true
      - xpack.security.enabled=true
      - xpack.security.http.ssl.enabled=true
      - xpack.security.http.ssl.key=certs/es03/es03.key
      - xpack.security.http.ssl.certificate=certs/es03/es03.crt
      - xpack.security.http.ssl.certificate_authorities=certs/ca/ca.crt
      - xpack.security.transport.ssl.enabled=true
      - xpack.security.transport.ssl.key=certs/es03/es03.key
      - xpack.security.transport.ssl.certificate=certs/es03/es03.crt
      - xpack.security.transport.ssl.certificate_authorities=certs/ca/ca.crt
      - xpack.security.transport.ssl.verification_mode=certificate
      - xpack.license.self_generated.type=${LICENSE}
    mem_limit: ${MEM_LIMIT}
    ulimits:
      memlock:
        soft: -1
        hard: -1
    healthcheck:
      test: ["CMD-SHELL", "curl -s --cacert config/certs/ca.crt https://localhost:9200 | grep -q 'missing authentication credentials'"]
      interval: 10s
      timeout: 10s
      retries: 120

Khởi chạy: docker-compose up -d

Sau khi khởi chạy tất cả các node, kiểm tra trạng thái cụm bằng cách truy cập https://elk-node1:9200/_cluster/health?pretty (sử dụng mật khẩu elastic).

Thiết lập Filebeat

Filebeat sẽ được cấu hình để gửi nhật ký trực tiếp đến Elasticsearch.

1. Cấu hình Filebeat

Trên các máy chủ cần thu thập nhật ký, đặt tệp cấu hình filebeat.yml.

filebeat.config.modules:
  path: ${path.config}/modules.d/*.yml

output.elasticsearch:
  hosts: ["https://elk-node1:9200"] # Chỉ định một node để thiết lập ban đầu
  username: "filebeat_internal"
  password: "YOUR_SECURE_PASSWORD" # Thay bằng mật khẩu người dùng filebeat_internal
  ssl:
    enabled: true
    certificate_authorities: ["/etc/filebeat/certs/ca/ca.crt"] # Đường dẫn đến CA cert

setup.kibana:
  host: "elk-node1:5601"

logging.level: warning

Bạn cần sao chép thư mục certs từ cấu hình Elasticsearch sang thư mục cấu hình Filebeat (ví dụ: /etc/filebeat/certs).

2. Tạo người dùng và Role cho Filebeat

Sử dụng Kibana Dev Tools hoặc cURL để tạo người dùng và role cần thiết cho Filebeat để kết nối và ghi dữ liệu vào Elasticsearch:

# Tạo role
POST /_security/role/filebeat_writer
{
  "cluster": ["manage_index_templates", "monitor", "manage_ilm"],
  "indices": [
    {
      "names": ["filebeat-*"],
      "privileges": ["write", "create", "create_index", "manage"]
    }
  ],
  "applications": [
    {
      "application": "kibana-.kibana",
      "privileges": ["read", "write"],
      "resources": ["*"]
    }
  ]
}

# Tạo người dùng
POST /_security/user/filebeat_internal
{
  "password" : "YOUR_SECURE_PASSWORD", # Thay bằng mật khẩu mạnh
  "roles" : [ "filebeat_writer" ],
  "full_name" : "Filebeat Internal User"
}

3. Khởi chạy Filebeat

Cài đặt và khởi chạy Filebeat theo cách thông thường (sử dụng service hoặc chạy thủ công).

Cài đặt và Cấu hình Kibana

Phần cấu hình Kibana đã được tích hợp sẵn trong tệp docker-compose.yml của elk-node1.

Khi Kibana khởi động, nó sẽ kết nối tới cụm Elasticsearch. Đảm bảo bạn đã cấu hình đúng ELASTICSEARCH_HOSTS, ELASTICSEARCH_USERNAME và ELASTICSEARCH_PASSWORD trong tệp .env.

Xử lý Sự cố

  • Lỗi xác thực khi Kibana kết nối Elasticsearch: Kiểm tra lại mật khẩu kibana_system trong tệp .env và cấu hình trong docker-compose.yml của Kibana. Đảm bảo tệp chứng chỉ ca.crt được mount đúng cách.
  • Filebeat không gửi dữ liệu: Kiểm tra log của Filebeat để xem có lỗi kết nối tới Elasticsearch hay không. Xác minh lại thông tin đăng nhập và chứng chỉ SSL.
  • Quyền truy cập Elasticsearch: Đảm bảo các role và user (elastic, kibana_system, filebeat_internal) có đủ quyền để thực hiện các hành động cần thiết (ghi dữ liệu, tạo index template).

Quản lý Vòng đời Dữ liệu (ILM)

Để quản lý dung lượng lưu trữ, hãy cấu hình chính sách ILM trong Kibana.

1. Tạo Chính sách ILM

Ví dụ chính sách xóa dữ liệu sau 15 ngày:

PUT _ilm/policy/delete_after_15_days
{
  "policy": {
    "phases": {
      "hot": {
        "actions": {
          "rollover": {
            "max_age": "1d"
          }
        }
      },
      "delete": {
        "min_age": "15d",
        "actions": {
          "delete": {}
        }
      }
    }
  }
}

2. Áp dụng Chính sách vào Index Template

Cập nhật hoặc tạo index template để sử dụng chính sách ILM.

PUT _template/filebeat_template
{
  "index_patterns": ["filebeat-*"],
  "settings": {
    "index.lifecycle.name": "delete_after_15_days",
    "index.lifecycle.rollover_alias": "filebeat"
  }
}

Sau khi áp dụng, Filebeat sẽ tạo các index mới với alias filebeat và chính sách ILM sẽ tự động quản lý chúng.

Thẻ: docker docker-compose Elasticsearch kibana Filebeat

Đăng vào ngày 12 tháng 7 lúc 21:13

Thẻ Phổ Biến

©2026 Thành phố Cuồng loạn