┌─────────────────────────────────────────────────────────────┐
│                    Logs Visualization 價值                   │
├─────────────────────────────────────────────────────────────┤
│  ✅ 集中管理：所有 Log 統一收集、儲存、查詢                    │
│  ✅ 快速搜尋：秒級查詢 TB 級 Log 資料                         │
│  ✅ 視覺化分析：Dashboard 呈現趨勢與異常                      │
│  ✅ 即時告警：異常 Log Pattern 自動通知                       │
│  ✅ 歷史回溯：完整保存，支援稽核與事故分析                     │
└─────────────────────────────────────────────────────────────┘

👤 使用者問：「昨天下午 3 點到 4 點，訂單服務有多少 Error？」

🤖 AI 轉換為 KQL：
service.name: "order-service" AND level: "ERROR" 
AND @timestamp >= "2026-01-26T15:00:00" 
AND @timestamp < "2026-01-26T16:00:00"

🤖 AI 分析結果：
「偵測到異常 Pattern：每週三 14:00-14:30 期間，
  payment-service 的 Connection Timeout 錯誤率上升 300%。
  建議檢查該時段是否有排程任務造成資源競爭。」

👤 問：「交易 TXN-20260127-001 為什麼失敗？」

🤖 AI 分析 Log 鏈路後回答：
「交易失敗根因：
  1. order-service 收到請求 (14:32:01.123)
  2. 呼叫 inventory-service 檢查庫存 (14:32:01.456)
  3. inventory-service 回應 timeout (14:32:06.789) ← 瓶頸
  4. order-service 拋出 ServiceUnavailableException
  
  建議：檢查 inventory-service 該時段的資源使用狀況」

┌─────────────────────────────────────────────────────────────┐
│                      Logstash Pipeline                       │
├─────────────┬─────────────────────────┬────────────────────┤
│   INPUT     │        FILTER           │      OUTPUT        │
├─────────────┼─────────────────────────┼────────────────────┤
│ • file      │ • grok (正規表達式解析)  │ • elasticsearch   │
│ • beats     │ • mutate (欄位修改)      │ • file            │
│ • tcp/udp   │ • date (時間解析)        │ • kafka           │
│ • kafka     │ • geoip (地理位置)       │ • stdout          │
│ • jdbc      │ • useragent             │ • email           │
└─────────────┴─────────────────────────┴────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│                    Elasticsearch Cluster                     │
├─────────────────────────────────────────────────────────────┤
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐         │
│  │  Master     │  │  Master     │  │  Master     │         │
│  │  Node 1     │  │  Node 2     │  │  Node 3     │         │
│  └─────────────┘  └─────────────┘  └─────────────┘         │
│         │               │               │                   │
│  ┌──────┴───────────────┴───────────────┴──────┐           │
│  │              Cluster State                   │           │
│  └──────────────────────────────────────────────┘           │
│                                                             │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐         │
│  │  Data       │  │  Data       │  │  Data       │         │
│  │  Node 1     │  │  Node 2     │  │  Node N     │         │
│  │  ┌───────┐  │  │  ┌───────┐  │  │  ┌───────┐  │         │
│  │  │Shard 0│  │  │  │Shard 1│  │  │  │Shard 2│  │         │
│  │  │Primary│  │  │  │Primary│  │  │  │Primary│  │         │
│  │  └───────┘  │  │  └───────┘  │  │  └───────┘  │         │
│  │  ┌───────┐  │  │  ┌───────┐  │  │  ┌───────┐  │         │
│  │  │Shard 1│  │  │  │Shard 2│  │  │  │Shard 0│  │         │
│  │  │Replica│  │  │  │Replica│  │  │  │Replica│  │         │
│  │  └───────┘  │  │  └───────┘  │  │  └───────┘  │         │
│  └─────────────┘  └─────────────┘  └─────────────┘         │
└─────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│                      Kibana 功能模組                         │
├──────────────┬──────────────┬──────────────┬───────────────┤
│   Discover   │  Visualize   │  Dashboard   │   Management  │
├──────────────┼──────────────┼──────────────┼───────────────┤
│ • Log 查詢   │ • 圖表建立   │ • 儀表板組合 │ • Index 管理  │
│ • 全文檢索   │ • 多種圖型   │ • 即時更新   │ • 使用者管理  │
│ • 時間篩選   │ • 聚合分析   │ • 分享匯出   │ • 空間管理    │
└──────────────┴──────────────┴──────────────┴───────────────┘

┌─────────────────────────────────────────────────────────────┐
│                  Production 架構設計原則                     │
├─────────────────────────────────────────────────────────────┤
│  1. Master Node 獨立部署，不與 Data Node 混用               │
│  2. 至少 3 個 Master Node（避免腦裂）                       │
│  3. Data Node 使用 SSD，提升 I/O 效能                       │
│  4. Logstash 部署 2+ 台，避免單點故障                       │
│  5. 考慮加入 Kafka 作為 Buffer Layer                        │
│  6. Kibana 前端加 Load Balancer                             │
└─────────────────────────────────────────────────────────────┘

# Grafana Alert 通知範本
alerting:
  notification_channels:
    - name: elk-deep-link
      type: webhook
      settings:
        url: "https://kibana.company.com/app/discover#/?_a=(query:(query_string:(query:'traceId:${traceId}')))"

┌─────────────────────────────────────────────────────────────┐
│                    版本選擇建議                              │
├─────────────────────────────────────────────────────────────┤
│  ✅ 三個元件使用「相同主版本號」（如都用 8.x）               │
│  ✅ 優先選擇最新的穩定版（非 RC / Beta）                    │
│  ✅ 參考 Elastic 官方 Support Matrix                        │
│  ⚠️  避免跨大版本混用（如 ES 8.x + Kibana 7.x）            │
└─────────────────────────────────────────────────────────────┘

目前建議版本：8.12.x（2026 年 1 月）

# 1. 匯入 GPG Key
sudo rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch

# 2. 建立 Repo 檔案
sudo tee /etc/yum.repos.d/elasticsearch.repo << EOF
[elasticsearch]
name=Elasticsearch repository for 8.x packages
baseurl=https://artifacts.elastic.co/packages/8.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=1
autorefresh=1
type=rpm-md
EOF

# 3. 安裝 Elasticsearch
sudo yum install -y elasticsearch

# 4. 啟動服務
sudo systemctl daemon-reload
sudo systemctl enable elasticsearch
sudo systemctl start elasticsearch

# 5. 驗證安裝（需等待約 30 秒）
curl -X GET "localhost:9200" -u elastic:your_password

# 1. 安裝必要套件
sudo apt-get install -y apt-transport-https

# 2. 匯入 GPG Key
wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo gpg --dearmor -o /usr/share/keyrings/elasticsearch-keyring.gpg

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

# 4. 安裝
sudo apt-get update && sudo apt-get install -y elasticsearch

# 5. 啟動服務
sudo systemctl daemon-reload
sudo systemctl enable elasticsearch
sudo systemctl start elasticsearch

# 建立網路
docker network create elastic

# 啟動 Elasticsearch
docker run -d \
  --name elasticsearch \
  --net elastic \
  -p 9200:9200 \
  -p 9300:9300 \
  -e "discovery.type=single-node" \
  -e "xpack.security.enabled=false" \
  -e "ES_JAVA_OPTS=-Xms2g -Xmx2g" \
  docker.elastic.co/elasticsearch/elasticsearch:8.12.0

# 檢查服務狀態
sudo systemctl status elasticsearch

# 檢查 Cluster Health
curl -X GET "localhost:9200/_cluster/health?pretty"

# 預期輸出
{
  "cluster_name" : "elasticsearch",
  "status" : "green",
  "number_of_nodes" : 1,
  ...
}

# 1. 安裝 Logstash（使用前面建立的 Repo）
sudo yum install -y logstash

# 2. 建立基本設定檔
sudo tee /etc/logstash/conf.d/basic.conf << 'EOF'
input {
  beats {
    port => 5044
  }
}

filter {
  # 基本處理
}

output {
  elasticsearch {
    hosts => ["localhost:9200"]
    index => "logs-%{+YYYY.MM.dd}"
  }
}
EOF

# 3. 測試設定檔語法
sudo /usr/share/logstash/bin/logstash --config.test_and_exit -f /etc/logstash/conf.d/basic.conf

# 4. 啟動服務
sudo systemctl enable logstash
sudo systemctl start logstash

# 安裝（使用前面建立的 Repository）
sudo apt-get install -y logstash

# 設定與啟動同上

# 建立設定檔目錄
mkdir -p ~/logstash/pipeline

# 建立 Pipeline 設定
cat > ~/logstash/pipeline/logstash.conf << 'EOF'
input {
  beats {
    port => 5044
  }
}

output {
  elasticsearch {
    hosts => ["elasticsearch:9200"]
    index => "logs-%{+YYYY.MM.dd}"
  }
}
EOF

# 啟動 Logstash
docker run -d \
  --name logstash \
  --net elastic \
  -p 5044:5044 \
  -v ~/logstash/pipeline:/usr/share/logstash/pipeline \
  docker.elastic.co/logstash/logstash:8.12.0

# 檢查服務狀態
sudo systemctl status logstash

# 檢查 Log
sudo tail -f /var/log/logstash/logstash-plain.log

# 檢查 API（預設 9600）
curl -X GET "localhost:9600/_node/stats?pretty"

# 1. 安裝 Kibana
sudo yum install -y kibana

# 2. 設定連線 Elasticsearch
sudo tee -a /etc/kibana/kibana.yml << EOF
server.host: "0.0.0.0"
server.port: 5601
elasticsearch.hosts: ["http://localhost:9200"]
EOF

# 3. 啟動服務
sudo systemctl enable kibana
sudo systemctl start kibana

sudo apt-get install -y kibana

# 設定與啟動同上

docker run -d \
  --name kibana \
  --net elastic \
  -p 5601:5601 \
  -e "ELASTICSEARCH_HOSTS=http://elasticsearch:9200" \
  docker.elastic.co/kibana/kibana:8.12.0

# 檢查服務狀態
sudo systemctl status kibana

# 等待約 1-2 分鐘後，開啟瀏覽器
# http://your-server-ip:5601

# 查看錯誤日誌
sudo journalctl -u elasticsearch -f

# 常見原因 1：記憶體不足
# 解決：調整 JVM Heap
sudo vi /etc/elasticsearch/jvm.options
# 修改 -Xms 和 -Xmx（建議設為實體記憶體的 50%，但不超過 31GB）
-Xms2g
-Xmx2g

# 常見原因 2：檔案描述符限制
# 解決：增加限制
sudo tee -a /etc/security/limits.conf << EOF
elasticsearch soft nofile 65536
elasticsearch hard nofile 65536
EOF

# 常見原因 3：虛擬記憶體限制
# 解決：增加 mmap 數量
sudo sysctl -w vm.max_map_count=262144
# 永久生效
echo "vm.max_map_count=262144" | sudo tee -a /etc/sysctl.conf

# 測試設定檔語法
sudo /usr/share/logstash/bin/logstash --config.test_and_exit -f /etc/logstash/conf.d/

# 查看詳細錯誤
sudo /usr/share/logstash/bin/logstash -f /etc/logstash/conf.d/ --log.level=debug

# 檢查 Elasticsearch 是否運作
curl -X GET "localhost:9200"

# 檢查 Kibana Log
sudo tail -f /var/log/kibana/kibana.log

# 確認設定
sudo cat /etc/kibana/kibana.yml | grep elasticsearch

# 常見原因：Security 啟用但未設定認證
# 解決：在 kibana.yml 加入
elasticsearch.username: "kibana_system"
elasticsearch.password: "your_password"

# 檢查磁碟使用
df -h

# 清理舊 Index（謹慎操作）
curl -X DELETE "localhost:9200/logs-2026.01.01"

# 設定自動清理（後續章節詳述）

#!/bin/bash
# elk-health-check.sh

echo "=== Elasticsearch Status ==="
systemctl status elasticsearch --no-pager
curl -s -X GET "localhost:9200/_cluster/health?pretty" 2>/dev/null || echo "ES not responding"

echo ""
echo "=== Logstash Status ==="
systemctl status logstash --no-pager
curl -s -X GET "localhost:9600/?pretty" 2>/dev/null || echo "Logstash not responding"

echo ""
echo "=== Kibana Status ==="
systemctl status kibana --no-pager
curl -s -X GET "localhost:5601/api/status" 2>/dev/null | grep -o '"state":"[^"]*"' || echo "Kibana not responding"

echo ""
echo "=== Disk Usage ==="
df -h | grep -E "Filesystem|/dev/"

echo ""
echo "=== Memory Usage ==="
free -h

/etc/elasticsearch/elasticsearch.yml    # 主設定檔
/etc/elasticsearch/jvm.options          # JVM 設定
/etc/elasticsearch/log4j2.properties    # Log 設定

# /etc/elasticsearch/elasticsearch.yml

# ======================== 叢集設定 ========================
cluster.name: prod-elk-cluster
node.name: es-node-01

# ======================== 節點角色 ========================
# 單節點模式
node.roles: [ master, data, ingest ]

# 多節點模式（依角色設定）
# Master Node: node.roles: [ master ]
# Data Node: node.roles: [ data ]

# ======================== 路徑設定 ========================
path.data: /var/lib/elasticsearch
path.logs: /var/log/elasticsearch

# ======================== 網路設定 ========================
network.host: 0.0.0.0
http.port: 9200
transport.port: 9300

# ======================== 叢集發現 ========================
# 單節點
discovery.type: single-node

# 多節點（列出所有 Master 候選節點）
# discovery.seed_hosts:
#   - 192.168.1.10:9300
#   - 192.168.1.11:9300
#   - 192.168.1.12:9300
# cluster.initial_master_nodes:
#   - es-master-01
#   - es-master-02
#   - es-master-03

# ======================== 安全性設定 ========================
xpack.security.enabled: true
xpack.security.enrollment.enabled: true
xpack.security.http.ssl.enabled: false  # 內網可關閉
xpack.security.transport.ssl.enabled: true

# /etc/elasticsearch/jvm.options.d/heap.options

# Heap Size（設為實體記憶體的 50%，但不超過 31GB）
-Xms16g
-Xmx16g

# GC 設定（ES 8.x 預設使用 G1GC）
# 通常不需修改

# 建立 Index Template（建議使用）
curl -X PUT "localhost:9200/_index_template/logs-template" -H 'Content-Type: application/json' -d'
{
  "index_patterns": ["logs-*"],
  "template": {
    "settings": {
      "number_of_shards": 3,
      "number_of_replicas": 1,
      "index.lifecycle.name": "logs-policy",
      "index.lifecycle.rollover_alias": "logs"
    },
    "mappings": {
      "properties": {
        "@timestamp": { "type": "date" },
        "message": { "type": "text" },
        "level": { "type": "keyword" },
        "service": { "type": "keyword" },
        "traceId": { "type": "keyword" }
      }
    }
  }
}'

┌─────────────────────────────────────────────────────────────┐
│                    Shard 規劃建議                           │
├─────────────────────────────────────────────────────────────┤
│  • 單一 Shard 建議大小：10-50 GB                            │
│  • 每個 Data Node 建議 Shard 數：< 1000                     │
│  • Shard 數 = (預估 Index 大小) / (單一 Shard 大小)          │
│                                                             │
│  範例：日誌量 100 GB/天                                     │
│  → 建議 Shard 數：100 / 30 ≈ 3-4 個 Primary Shard          │
└─────────────────────────────────────────────────────────────┘

/etc/logstash/
├── logstash.yml           # 主設定
├── pipelines.yml          # Pipeline 定義
├── jvm.options            # JVM 設定
└── conf.d/                # Pipeline 設定檔目錄
    ├── 01-input.conf
    ├── 02-filter.conf
    └── 03-output.conf

# /etc/logstash/conf.d/01-input.conf

# 從 Filebeat 接收
input {
  beats {
    port => 5044
    ssl => false
  }
}

# 從 Kafka 接收
input {
  kafka {
    bootstrap_servers => "kafka01:9092,kafka02:9092"
    topics => ["app-logs"]
    group_id => "logstash-consumer"
    codec => json
  }
}

# 從 TCP 接收（Log4j2）
input {
  tcp {
    port => 5000
    codec => json_lines
  }
}

# /etc/logstash/conf.d/02-filter.conf

filter {
  # 解析 Java Log（Log4j2 Pattern）
  if [type] == "java-app" {
    grok {
      match => { 
        "message" => "%{TIMESTAMP_ISO8601:timestamp} %{LOGLEVEL:level} \[%{DATA:thread}\] %{JAVACLASS:class} - %{GREEDYDATA:logMessage}"
      }
    }
    
    # 解析時間
    date {
      match => [ "timestamp", "yyyy-MM-dd HH:mm:ss.SSS" ]
      target => "@timestamp"
      timezone => "Asia/Taipei"
    }
    
    # 移除原始 timestamp 欄位
    mutate {
      remove_field => [ "timestamp" ]
    }
  }
  
  # 解析 JSON 格式 Log
  if [type] == "json-log" {
    json {
      source => "message"
    }
  }
  
  # 新增欄位
  mutate {
    add_field => { "environment" => "production" }
  }
  
  # 敏感資料遮蔽
  mutate {
    gsub => [
      # 遮蔽身分證字號
      "message", "[A-Z][12]\d{8}", "***MASKED***",
      # 遮蔽信用卡號
      "message", "\d{4}-\d{4}-\d{4}-\d{4}", "****-****-****-****"
    ]
  }
}

# /etc/logstash/conf.d/03-output.conf

output {
  # 輸出至 Elasticsearch
  elasticsearch {
    hosts => ["http://es-node-01:9200", "http://es-node-02:9200"]
    index => "logs-%{[service]}-%{+YYYY.MM.dd}"
    user => "logstash_writer"
    password => "${ES_PASSWORD}"
    
    # 效能調校
    action => "index"
    document_type => "_doc"
  }
  
  # 除錯用：同時輸出至 Console
  if [level] == "ERROR" {
    stdout {
      codec => rubydebug
    }
  }
}

# /etc/logstash/conf.d/java-app-pipeline.conf

input {
  beats {
    port => 5044
  }
}

filter {
  # 解析 Spring Boot Log
  grok {
    match => {
      "message" => "%{TIMESTAMP_ISO8601:timestamp}\s+%{LOGLEVEL:level}\s+%{NUMBER:pid}\s+---\s+\[%{DATA:thread}\]\s+%{JAVACLASS:logger}\s+:\s+%{GREEDYDATA:logMessage}"
    }
  }
  
  # 解析時間
  date {
    match => ["timestamp", "yyyy-MM-dd HH:mm:ss.SSS"]
    target => "@timestamp"
    timezone => "Asia/Taipei"
  }
  
  # 處理多行 Exception Stack Trace
  if [logMessage] =~ /Exception|Error/ {
    mutate {
      add_tag => ["exception"]
    }
  }
  
  # 新增 Metadata
  mutate {
    add_field => {
      "app_name" => "%{[fields][app_name]}"
      "env" => "%{[fields][env]}"
    }
    remove_field => ["timestamp", "host", "agent", "ecs", "input", "log"]
  }
}

output {
  elasticsearch {
    hosts => ["http://localhost:9200"]
    index => "app-logs-%{[app_name]}-%{+YYYY.MM.dd}"
  }
}

# /etc/kibana/kibana.yml

# ======================== Server 設定 ========================
server.port: 5601
server.host: "0.0.0.0"
server.name: "kibana-prod"

# ======================== Elasticsearch 連線 ========================
elasticsearch.hosts: ["http://es-node-01:9200", "http://es-node-02:9200"]
elasticsearch.username: "kibana_system"
elasticsearch.password: "your_secure_password"

# ======================== 安全性設定 ========================
# 啟用加密通訊（正式環境建議）
# server.ssl.enabled: true
# server.ssl.certificate: /path/to/kibana.crt
# server.ssl.key: /path/to/kibana.key

# ======================== 日誌設定 ========================
logging.root.level: info
logging.appenders.default:
  type: file
  fileName: /var/log/kibana/kibana.log
  layout:
    type: json

# ======================== 本地化設定 ========================
i18n.locale: "zh-TW"

# ======================== 其他設定 ========================
# 預設首頁
server.defaultRoute: "/app/discover"

# 查詢 Timeout
elasticsearch.requestTimeout: 30000

curl -X POST "localhost:5601/api/data_views/data_view" \
  -H "kbn-xsrf: true" \
  -H "Content-Type: application/json" \
  -d '{
    "data_view": {
      "title": "app-logs-*",
      "timeFieldName": "@timestamp"
    }
  }'

<!-- logback-spring.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <property name="LOG_PATH" value="/var/log/myapp"/>
    <property name="APP_NAME" value="order-service"/>
    
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${LOG_PATH}/${APP_NAME}.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${LOG_PATH}/${APP_NAME}.%d{yyyy-MM-dd}.log</fileNamePattern>
            <maxHistory>7</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %level [%thread] %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    
    <!-- JSON 格式（推薦） -->
    <appender name="JSON_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${LOG_PATH}/${APP_NAME}-json.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${LOG_PATH}/${APP_NAME}-json.%d{yyyy-MM-dd}.log</fileNamePattern>
            <maxHistory>7</maxHistory>
        </rollingPolicy>
        <encoder class="net.logstash.logback.encoder.LogstashEncoder">
            <customFields>{"app_name":"${APP_NAME}","env":"prod"}</customFields>
        </encoder>
    </appender>
    
    <root level="INFO">
        <appender-ref ref="JSON_FILE"/>
    </root>
</configuration>

# /etc/filebeat/filebeat.yml

filebeat.inputs:
  - type: log
    enabled: true
    paths:
      - /var/log/myapp/*-json.log
    json.keys_under_root: true
    json.add_error_key: true
    fields:
      app_name: order-service
      env: production
    fields_under_root: true

output.logstash:
  hosts: ["logstash-server:5044"]
  loadbalance: true

# 監控設定
monitoring.enabled: true
monitoring.elasticsearch:
  hosts: ["http://es-server:9200"]

# /etc/logstash/conf.d/spring-boot.conf

input {
  beats {
    port => 5044
  }
}

filter {
  # JSON Log 已經由 Filebeat 解析，只需要額外處理
  
  # 確保 @timestamp 正確
  if [timestamp] {
    date {
      match => ["timestamp", "ISO8601"]
      target => "@timestamp"
      timezone => "Asia/Taipei"
    }
    mutate {
      remove_field => ["timestamp"]
    }
  }
  
  # 解析 Stack Trace（如果有的話）
  if [stack_trace] {
    mutate {
      add_tag => ["has_stacktrace"]
    }
  }
  
  # 移除不需要的欄位
  mutate {
    remove_field => ["agent", "ecs", "host", "input", "log"]
  }
}

output {
  elasticsearch {
    hosts => ["http://es-node-01:9200", "http://es-node-02:9200"]
    index => "app-logs-%{[app_name]}-%{+YYYY.MM.dd}"
    user => "logstash_writer"
    password => "${ES_PASSWORD}"
  }
}

# 1. 檢查 Filebeat 是否讀取到 Log
sudo filebeat test output

# 2. 檢查 Logstash 是否收到資料
curl -s localhost:9600/_node/stats/pipelines | jq '.pipelines.main.events'

# 3. 檢查 Elasticsearch 是否有資料
curl -s "localhost:9200/app-logs-order-service-*/_count" | jq '.count'

# 4. 在 Kibana 查詢
# 開啟 Discover，選擇對應的 Index Pattern

# 啟用 System Module
sudo filebeat modules enable system

# 啟用 Nginx Module
sudo filebeat modules enable nginx

# 設定 Module
sudo vi /etc/filebeat/modules.d/nginx.yml

# 載入 Dashboard
sudo filebeat setup -e

# 重啟 Filebeat
sudo systemctl restart filebeat

1. 建立 Line Chart：
   - Data View: app-logs-*
   - Y-axis: Count
   - X-axis: @timestamp (Date Histogram, 1 minute)
   - Breakdown: level (Top values)

2. 建立 Metric：
   - Data View: app-logs-*
   - Filter: level: ERROR
   - Aggregation: Count
   - Time range: Last 1 hour

3. 建立 Data Table：
   - Data View: app-logs-*
   - Filter: level: ERROR
   - Columns: @timestamp, service, message
   - Sort: @timestamp DESC

# 基本語法
欄位名稱: 值

# 範例
level: ERROR
service: order-service
message: "timeout"

# 萬用字元
message: timeout*
message: time?ut

# 正規表達式
message: /[Ee]rror.*/

# 模糊搜尋
message: tiemout~2

# 範圍搜尋
response_time: [100 TO 500]
@timestamp: [2026-01-01 TO 2026-01-31]

# 權重
message: error^2 OR warning^1

# 1. 查詢特定交易的完整鏈路
traceId: "abc123" AND (service: order-service OR service: payment-service)

# 2. 查詢今日所有 5xx 錯誤
response_code: [500 TO 599] AND @timestamp >= now/d

# 3. 查詢特定時段的慢查詢
response_time >= 3000 AND @timestamp >= "2026-01-27T10:00:00" AND @timestamp <= "2026-01-27T11:00:00"

# 4. 排除健康檢查 Log
NOT (request_path: "/health" OR request_path: "/actuator/*")

# 5. 查詢含有 Exception 的 Log
message: *Exception* OR stack_trace: *

1. 在 Discover 輸入：orderId: "ORD-20260127-001"
2. 展開時間範圍確保涵蓋交易時間
3. 排序：@timestamp ASC（依時間正序）
4. 新增顯示欄位：service, level, message, duration
5. 找到 ERROR Log，檢視 Stack Trace

查詢步驟：

1. 設定時間範圍為告警觸發前後 30 分鐘

2. 查詢 Error Log：
   level: ERROR AND @timestamp >= "2026-01-27T10:00:00"

3. 聚合分析 Error 類型：
   - 開啟 Lens
   - X-axis: @timestamp
   - Breakdown: error_type
   - 識別最多的 Error 類型

4. 深入特定 Error：
   error_type: "ConnectionTimeoutException" AND service: payment-service

5. 關聯 Metrics：
   在 Grafana 檢查同時段 payment-service 的 Connection Pool 使用率

查詢語法：
userId: "U12345" AND action: * AND @timestamp >= now-7d

顯示欄位：
- @timestamp
- action
- ip_address
- request_path
- response_code

匯出步驟：
1. 在 Discover 執行查詢
2. 設定顯示欄位
3. 點擊 Share → CSV Reports
4. 選擇 Generate CSV
5. 下載並提供稽核單位

# Grafana Alert 觸發時間：2026-01-27 14:30:00
# 目標服務：inventory-service
# 觀察到 CPU > 90%

Kibana 查詢：
service: inventory-service AND @timestamp >= "2026-01-27T14:25:00" AND @timestamp <= "2026-01-27T14:35:00"

可能發現：
- 大量 DEBUG Log 輸出
- 重複的 SQL Query
- GC Log 頻繁
- Exception 大量拋出

# 建立 ILM Policy
curl -X PUT "localhost:9200/_ilm/policy/logs-policy" -H 'Content-Type: application/json' -d'
{
  "policy": {
    "phases": {
      "hot": {
        "min_age": "0ms",
        "actions": {
          "rollover": {
            "max_age": "1d",
            "max_size": "50gb"
          },
          "set_priority": {
            "priority": 100
          }
        }
      },
      "warm": {
        "min_age": "7d",
        "actions": {
          "forcemerge": {
            "max_num_segments": 1
          },
          "shrink": {
            "number_of_shards": 1
          },
          "set_priority": {
            "priority": 50
          }
        }
      },
      "cold": {
        "min_age": "30d",
        "actions": {
          "freeze": {},
          "set_priority": {
            "priority": 0
          }
        }
      },
      "delete": {
        "min_age": "90d",
        "actions": {
          "delete": {}
        }
      }
    }
  }
}'

# 列出所有 Index
curl -s "localhost:9200/_cat/indices?v&s=index"

# 刪除特定日期的 Index
curl -X DELETE "localhost:9200/app-logs-*-2026.01.01"

# 刪除 30 天前的 Index（使用 Curator 或腳本）
#!/bin/bash
# cleanup-old-indices.sh

DAYS_TO_KEEP=30
DATE_THRESHOLD=$(date -d "-${DAYS_TO_KEEP} days" +%Y.%m.%d)

curl -s "localhost:9200/_cat/indices/logs-*?h=index" | while read index; do
  index_date=$(echo $index | grep -oP '\d{4}\.\d{2}\.\d{2}')
  if [[ "$index_date" < "$DATE_THRESHOLD" ]]; then
    echo "Deleting $index"
    curl -X DELETE "localhost:9200/$index"
  fi
done

# elasticsearch.yml 效能相關設定

# 索引 Refresh 間隔（寫入量大時可增加）
index.refresh_interval: 30s

# 索引 Buffer 大小
indices.memory.index_buffer_size: 20%

# Thread Pool 設定
thread_pool.write.queue_size: 1000
thread_pool.search.queue_size: 1000

# 1. 避免 wildcard 開頭查詢
❌ message: *error*
✅ message: error*

# 2. 使用 filter 而非 query（不計算分數，可快取）
curl -X GET "localhost:9200/logs-*/_search" -H 'Content-Type: application/json' -d'
{
  "query": {
    "bool": {
      "filter": [
        { "term": { "level": "ERROR" } },
        { "range": { "@timestamp": { "gte": "now-1h" } } }
      ]
    }
  }
}'

# 3. 限制返回欄位
curl -X GET "localhost:9200/logs-*/_search" -H 'Content-Type: application/json' -d'
{
  "_source": ["@timestamp", "level", "message"],
  "query": { "match_all": {} },
  "size": 100
}'

# logstash.yml

# Pipeline 設定
pipeline.workers: 4          # 通常設為 CPU 核心數
pipeline.batch.size: 250     # 批次大小
pipeline.batch.delay: 50     # 批次等待時間 (ms)

# 輸出 Buffer
output.elasticsearch.bulk_max_size: 5000

# Cluster Health
curl -s "localhost:9200/_cluster/health?pretty"

# 預期結果
{
  "status": "green",        # green/yellow/red
  "number_of_nodes": 3,
  "active_primary_shards": 50,
  "active_shards": 100,
  "unassigned_shards": 0    # 應為 0
}

# Node Stats
curl -s "localhost:9200/_nodes/stats?pretty" | jq '.nodes | to_entries[] | {
  name: .value.name,
  heap_used_percent: .value.jvm.mem.heap_used_percent,
  disk_available: .value.fs.total.available_in_bytes
}'

# Index Stats
curl -s "localhost:9200/_cat/indices?v&h=index,health,docs.count,store.size"

# 使用 elasticsearch_exporter
# docker-compose.yml

version: '3'
services:
  elasticsearch-exporter:
    image: prometheuscommunity/elasticsearch-exporter:latest
    command:
      - '--es.uri=http://elasticsearch:9200'
    ports:
      - "9114:9114"

# prometheus.yml

scrape_configs:
  - job_name: 'elasticsearch'
    static_configs:
      - targets: ['elasticsearch-exporter:9114']

┌─────────────────────────────────────────────────────────────┐
│                    升級前檢查清單                            │
├─────────────────────────────────────────────────────────────┤
│  □ 1. 確認目標版本與現有版本的相容性                        │
│  □ 2. 閱讀 Release Notes 與 Breaking Changes                │
│  □ 3. 備份 Elasticsearch Index                              │
│  □ 4. 備份設定檔（elasticsearch.yml、logstash.conf 等）     │
│  □ 5. 備份 Kibana Saved Objects（Dashboard、Visualization） │
│  □ 6. 測試環境先行升級驗證                                  │
│  □ 7. 準備回滾計畫                                          │
│  □ 8. 通知相關人員維護時間                                  │
│  □ 9. 確認有足夠磁碟空間                                    │
│  □ 10. 確認 Cluster Health 為 green                         │
└─────────────────────────────────────────────────────────────┘

# 查看目前版本
curl -s "localhost:9200" | jq '.version.number'
curl -s "localhost:5601/api/status" | jq '.version.number'

# 檢查 Elastic 官方 Support Matrix
# https://www.elastic.co/support/matrix

# 重要：三個元件應使用相同主版本
# ✅ ES 8.12 + Logstash 8.12 + Kibana 8.12
# ❌ ES 8.12 + Logstash 7.17 + Kibana 8.12

# 1. 建立 Snapshot Repository
curl -X PUT "localhost:9200/_snapshot/backup_repo" -H 'Content-Type: application/json' -d'
{
  "type": "fs",
  "settings": {
    "location": "/mnt/backup/elasticsearch"
  }
}'

# 2. 建立 Snapshot
curl -X PUT "localhost:9200/_snapshot/backup_repo/pre-upgrade-$(date +%Y%m%d)?wait_for_completion=true"

# 3. 備份 Kibana Saved Objects
curl -X POST "localhost:5601/api/saved_objects/_export" \
  -H "kbn-xsrf: true" \
  -H "Content-Type: application/json" \
  -d '{"type": ["dashboard", "visualization", "index-pattern", "search"]}' \
  > kibana-saved-objects-backup.ndjson

# 4. 備份設定檔
tar -czvf elk-config-backup-$(date +%Y%m%d).tar.gz \
  /etc/elasticsearch \
  /etc/logstash \
  /etc/kibana \
  /etc/filebeat

# 適用於同一大版本升級（如 8.10 → 8.12）

# 1. 關閉 Shard Allocation
curl -X PUT "localhost:9200/_cluster/settings" -H 'Content-Type: application/json' -d'
{
  "persistent": {
    "cluster.routing.allocation.enable": "primaries"
  }
}'

# 2. 停止非必要索引（可選）
curl -X POST "localhost:9200/_flush/synced"

# 3. 停止節點
sudo systemctl stop elasticsearch

# 4. 升級套件
sudo yum update elasticsearch
# 或
sudo apt-get update && sudo apt-get install elasticsearch

# 5. 啟動節點
sudo systemctl start elasticsearch

# 6. 等待節點加入叢集
curl -s "localhost:9200/_cat/nodes?v"

# 7. 重新啟用 Shard Allocation
curl -X PUT "localhost:9200/_cluster/settings" -H 'Content-Type: application/json' -d'
{
  "persistent": {
    "cluster.routing.allocation.enable": null
  }
}'

# 8. 等待 Cluster 回到 green
watch -n 5 'curl -s localhost:9200/_cluster/health | jq .'

# 9. 對下一個節點重複步驟 1-8

# 1. 停止 Logstash
sudo systemctl stop logstash

# 2. 升級套件
sudo yum update logstash

# 3. 驗證設定檔相容性
sudo /usr/share/logstash/bin/logstash --config.test_and_exit -f /etc/logstash/conf.d/

# 4. 啟動 Logstash
sudo systemctl start logstash

# 5. 驗證
curl -s localhost:9600 | jq '.version'

# 1. 停止 Kibana
sudo systemctl stop kibana

# 2. 升級套件
sudo yum update kibana

# 3. 啟動 Kibana
sudo systemctl start kibana

# 4. 等待啟動完成（可能需要 1-2 分鐘）
tail -f /var/log/kibana/kibana.log

# 5. 驗證
curl -s localhost:5601/api/status | jq '.version'

# 1. 停止節點
sudo systemctl stop elasticsearch

# 2. 降級套件
sudo yum downgrade elasticsearch-8.10.0

# 3. 還原設定檔
sudo tar -xzvf elk-config-backup-*.tar.gz -C /

# 4. 還原資料（如果需要）
curl -X POST "localhost:9200/_snapshot/backup_repo/pre-upgrade-*/_restore?wait_for_completion=true"

# 5. 啟動服務
sudo systemctl start elasticsearch

# 匯入備份的 Saved Objects
curl -X POST "localhost:5601/api/saved_objects/_import?overwrite=true" \
  -H "kbn-xsrf: true" \
  --form file=@kibana-saved-objects-backup.ndjson

# elasticsearch.yml

xpack.security.enabled: true
xpack.security.enrollment.enabled: true

# 傳輸層加密
xpack.security.transport.ssl.enabled: true
xpack.security.transport.ssl.verification_mode: certificate
xpack.security.transport.ssl.keystore.path: elastic-certificates.p12
xpack.security.transport.ssl.truststore.path: elastic-certificates.p12

# HTTP 層加密（正式環境建議）
xpack.security.http.ssl.enabled: true
xpack.security.http.ssl.keystore.path: http.p12

# 建立應用程式開發者角色
curl -X PUT "localhost:9200/_security/role/app_developer" -H 'Content-Type: application/json' -d'
{
  "indices": [
    {
      "names": ["app-logs-*"],
      "privileges": ["read", "view_index_metadata"],
      "query": {
        "bool": {
          "filter": [
            { "term": { "env": "dev" } }
          ]
        }
      }
    }
  ],
  "applications": [
    {
      "application": "kibana-.kibana",
      "privileges": ["feature_discover.read", "feature_dashboard.read"],
      "resources": ["*"]
    }
  ]
}'

# 建立使用者
curl -X POST "localhost:9200/_security/user/dev_user" -H 'Content-Type: application/json' -d'
{
  "password": "secure_password",
  "roles": ["app_developer"],
  "full_name": "開發人員",
  "email": "dev@company.com"
}'

┌─────────────────────────────────────────────────────────────┐
│                    角色設計建議                              │
├──────────────┬──────────────────────────────────────────────┤
│ 角色         │ 權限範圍                                     │
├──────────────┼──────────────────────────────────────────────┤
│ elk_admin    │ 完整管理權限，可建立/刪除 Index              │
│ ops_team     │ 可查看所有環境 Log，可建立 Dashboard         │
│ dev_team     │ 只能查看 dev/sit 環境 Log                    │
│ security     │ 可查看所有 Log，特別是 Security 相關         │
│ auditor      │ 唯讀權限，可匯出報表                         │
│ business     │ 只能查看特定 Dashboard，無 Discover 權限     │
└──────────────┴──────────────────────────────────────────────┘

# Logstash - 敏感資料遮蔽

filter {
  # 遮蔽身分證字號
  mutate {
    gsub => [
      "message", "[A-Z][12]\d{8}", "[ID_MASKED]"
    ]
  }
  
  # 遮蔽信用卡號
  mutate {
    gsub => [
      "message", "\b\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}\b", "[CARD_MASKED]"
    ]
  }
  
  # 遮蔽 Email
  mutate {
    gsub => [
      "message", "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}", "[EMAIL_MASKED]"
    ]
  }
  
  # 移除敏感欄位
  mutate {
    remove_field => ["password", "token", "secret"]
  }
}

# elasticsearch.yml

xpack.security.audit.enabled: true
xpack.security.audit.logfile.events.include:
  - access_denied
  - authentication_failed
  - connection_denied
  - tampered_request
  - run_as_denied
  - anonymous_access_denied

┌─────────────────────────────────────────────────────────────┐
│                    網路安全建議                              │
├─────────────────────────────────────────────────────────────┤
│  1. Elasticsearch 9200/9300 port 不對外開放                 │
│  2. Kibana 透過 Reverse Proxy（Nginx）對外                  │
│  3. 啟用 HTTPS（TLS 1.2+）                                  │
│  4. 使用防火牆限制來源 IP                                   │
│  5. 定期更換 Password 與 Token                              │
│  6. 啟用 Audit Log 並保存至少 1 年                          │
│  7. 敏感資料在寫入前遮蔽，不依賴查詢時過濾                  │
└─────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│                    ELK 導入常見踩雷點                        │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  1. ❌ Log 量估算錯誤                                       │
│     → 正確做法：先在測試環境測量實際 Log 量                  │
│                                                             │
│  2. ❌ 沒有設定 ILM，Index 無限成長                         │
│     → 正確做法：上線前就設定 ILM Policy                      │
│                                                             │
│  3. ❌ 所有 Log 都收集                                      │
│     → 正確做法：過濾無用 Log（DEBUG、Health Check）          │
│                                                             │
│  4. ❌ Shard 數量設定不當                                   │
│     → 正確做法：單一 Shard 10-50 GB，依資料量計算            │
│                                                             │
│  5. ❌ 沒有監控 ELK 本身                                    │
│     → 正確做法：用 Prometheus 監控 ELK 元件                  │
│                                                             │
│  6. ❌ 直接在 Production 調整設定                           │
│     → 正確做法：先在測試環境驗證                             │
│                                                             │
│  7. ❌ 忽略 Security 設定                                   │
│     → 正確做法：上線前啟用認證與加密                         │
│                                                             │
│  8. ❌ 沒有備份策略                                         │
│     → 正確做法：定期 Snapshot + 設定檔版控                   │
│                                                             │
│  9. ❌ Logstash 與 Application 部署在同一台                 │
│     → 正確做法：Filebeat 在 App Server，Logstash 獨立部署    │
│                                                             │
│  10. ❌ 使用純文字 Log 格式                                 │
│      → 正確做法：使用 JSON 格式，減少解析成本                │
│                                                             │
└─────────────────────────────────────────────────────────────┘

{
  "@timestamp": "2026-01-27T14:30:00.123+08:00",
  "level": "INFO",
  "logger": "com.company.order.OrderService",
  "thread": "http-nio-8080-exec-1",
  "message": "Order created successfully",
  "service": "order-service",
  "env": "prod",
  "host": "app-server-01",
  "traceId": "abc123def456",
  "spanId": "789xyz",
  "userId": "U12345",
  "orderId": "ORD-20260127-001",
  "duration": 150,
  "extra": {
    "orderAmount": 1500,
    "productCount": 3
  }
}

👤 使用者問：「昨天有多少訂單失敗？失敗的主要原因是什麼？」

🤖 AI 轉換為查詢：
1. 計算失敗訂單數：
   service: order-service AND level: ERROR AND @timestamp >= now-1d/d AND @timestamp < now/d
   → Aggregation: Count

2. 分析失敗原因：
   service: order-service AND level: ERROR AND @timestamp >= now-1d/d
   → Aggregation: Terms on error_type field

📊 AI 整理結果：
「昨天共有 156 筆訂單失敗，主要原因：
  1. PaymentTimeout: 78 筆 (50%)
  2. InventoryNotAvailable: 45 筆 (29%)
  3. UserNotFound: 33 筆 (21%)
  
  建議：優先調查 Payment Service 的連線問題」

# 範例：將 Error Log 整理給 AI 分析

Prompt：
"""
以下是系統錯誤日誌，請分析可能的根因並提供解決建議：

[2026-01-27 14:30:01] ERROR OrderService - Failed to process order
  java.net.SocketTimeoutException: Read timed out
    at java.net.SocketInputStream.read(SocketInputStream.java:123)
    at com.company.payment.PaymentClient.charge(PaymentClient.java:89)
    at com.company.order.OrderService.processOrder(OrderService.java:45)

[2026-01-27 14:30:02] WARN ConnectionPool - Pool exhausted, waiting for connection
  pool_size: 10, active: 10, waiting: 5

[2026-01-27 14:30:03] ERROR PaymentClient - Connection refused to payment-service:8080
"""

AI 回應：
「根據日誌分析，問題可能是：
1. Payment Service 連線池耗盡（10 個連線全部用完）
2. Payment Service 可能過載或當機

建議行動：
1. 檢查 payment-service 健康狀態
2. 增加 Connection Pool 大小
3. 設定適當的 Connection Timeout
4. 考慮加入 Circuit Breaker 機制」