Loki

distributor           #分发器。接收日志，根据一致性哈希路由到 ingester
ingester              #写入实例。内存接收日志，生成 chunk 日志块
consistent hash ring  #一致性哈希环。Loki 用于分片日志流的机制
replication factor    #复制因子。日志副本数量
quorum                #法定多数。写成功需要应答的副本数量
chunk                 #日志块。Loki存储日志的最小单元，租户+标签唯一
query-frontend        #查询前端。接收用户查询，拆分查询任务
query-scheduler       #查询调度器。分发子查询任务给 querier
querier               #查询器。执行实际查询，合并 ingester 与后端存储数据
backing store         #后端存储。对象存储，保存已经落盘的 chunk
deduplicates          #去重。处理多副本带来的重复日志
X-Scope-OrgID         #租户请求头。Loki 多租户识别标识

#启动两个容器生成日志
docker run -d --name mynginx -p 80:80 \
       --label service=nginx \
       --label env=prod \
       --label version=1.30.0 \
       ealen/echo-server:latest

docker run -d --name myapp -p 8080:80 \
       --label service=myapp \
       --label env=dev \
       --label ver1.0 \
       nbilal786/myapp:latest


# 安装 nerdctl 启动容器
apt install -y wget slirp4netns
cd /tmp
wget https://files.m.daocloud.io/github.com/containerd/nerdctl/releases/download/v2.3.4/nerdctl-2.3.4-linux-${ARCH}.tar.gz
tar -zxvf nerdctl-2.3.4-linux-${ARCH}.tar.gz
mv nerdctl /usr/local/bin/
chmod +x /usr/local/bin/nerdctl
sysctl -a  |grep ip_forward # 确认开启内核 IP 转发


# mynginx
nerdctl run -d --name mynginx -p 80:80 \
       --label service=nginx \
       --label env=prod \
       --label version=1.30.0 \
       ealen/echo-server:latest

# myapp
nerdctl run -d --name myapp -p 8080:80 \
       --label service=myapp \
       --label env=dev \
       --label ver=1.0 \
       nbilal786/myapp:latest

root@master01:~# kubectl  get pod
NAME                     READY   STATUS    RESTARTS       AGE
echo-647c98d9f-zrpdg     1/1     Running   0              29m
myapp-8b88f5cdd-5nbx4    1/1     Running   0              3m50s

#访问容器,生成容器日志
while true; do curl 10.103.236.202;sleep 1;do &
while true; do curl 10.103.236.202:8080;sleep 1;do &                                          

OS=$(uname -s | tr 'A-Z' 'a-z')
ARCH=$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/')
PLATFORM="$OS-$ARCH"
wget https://dl.minio.org.cn/server/minio/release/${PLATFORM}/minio

chmod +x minio
cp minio /usr/local/bin
#MINIO_ROOT_USER=admin MINIO_ROOT_PASSWORD=password ./minio server /mnt/data --console-address ":9001" --address ":9000"
# 9001 为管理控制台，9000 为 api 端口

# 编译功能完善的 minio
MINIO_VERSION=RELEASE.2025-04-22T22-12-26Z
git clone --depth 1 --branch ${MINIO_VERSION} https://github.com/minio/minio.git
cd minio
CGO_ENABLED=0 go build -o minio .
cp ./minio /usr/local/bin/
minio --version

# 生成存储和启动配置
mkdir /data/minio -pv
groupadd -r minio-user
useradd -M -r -g minio-user minio-user
chown minio-user:minio-user /data/minio

cat >/etc/default/minio<<EOF
MINIO_ROOT_USER=admin
MINIO_ROOT_PASSWORD=Admin@123456
MINIO_VOLUMES="/data/minio"
MINIO_OPTS="--console-address :9001 --address :9000"
EOF

cat >/lib/systemd/system/minio.service<<\EOF
[Unit]
Description=MinIO
Documentation=https://min.io/docs/minio/linux/index.html
Wants=network-online.target
After=network-online.target
AssertFileIsExecutable=/usr/local/bin/minio

[Service]
WorkingDirectory=/usr/local
User=minio-user
Group=minio-user
ProtectProc=invisible
EnvironmentFile=-/etc/default/minio
ExecStartPre=/bin/bash -c "if [ -z \"${MINIO_VOLUMES}\" ]; then echo \"Variable MINIO_VOLUMES not set in /etc/default/minio\"; exit 1; fi"
ExecStart=/usr/local/bin/minio server $MINIO_OPTS $MINIO_VOLUMES
Restart=always
LimitNOFILE=65536
TasksMax=infinity
TimeoutStopSec=infinity
SendSIGKILL=no

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload && systemctl enable --now  minio.service
systemctl status minio.service
journalctl -f -u minio.service

Access Key: d3qFSWw6zosYK4xyHeZC
Secret Key: iJ8gwfA5lZ3xhhf0n0EarjAkJgByNJKOnZWjJsUd

# 编译功能完善的 minio
MC_VERSION='RELEASE.2025-04-16T18-13-26Z'
git clone --depth 1 --branch ${MC_VERSION} https://github.com/minio/mc.git
cd mc
CGO_ENABLED=0 go build -o mc .
cp ./mc /usr/local/bin/
mc --version

# 配置客户端连接
echo 10.103.236.202  minio.jasper.org >> /etc/hosts
mc alias set minio http://minio.jasper.org:9000 d3qFSWw6zosYK4xyHeZC iJ8gwfA5lZ3xhhf0n0EarjAkJgByNJKOnZWjJsUd
mc alias ls minio

# 测试
mc admin info minio # 查看磁盘空间等信息
mc ls minio # 查看桶信息

LOKI_VERSION=3.7.8
OS=$(uname -s | tr 'A-Z' 'a-z')
ARCH=$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/')
PLATFORM="$OS-$ARCH"

wget https://github.com/grafana/loki/releases/download/v${LOKI_VERSION}/loki-${PLATFORM}.zip
unzip loki-${PLATFORM}.zip
install -m 755 loki-${PLATFORM}  /usr/local/bin/loki
loki --version

echo 10.103.236.202  minio.jasper.org >> /etc/hosts

mkdir -p /etc/loki

cat >/etc/loki/loki.yaml <<\EOF
auth_enabled: false

server:
  http_listen_port: 3100
  http_listen_address: 0.0.0.0
  log_level: info

common:
  path_prefix: /data/loki
  # minio 对象存储
  storage:
    s3:
      endpoint: minio.jasper.org:9000
      bucketnames: loki
      access_key_id: d3qFSWw6zosYK4xyHeZC
      secret_access_key: iJ8gwfA5lZ3xhhf0n0EarjAkJgByNJKOnZWjJsUd
      # minio 使用 http
      insecure: true
      # 强制 path style
      s3forcepathstyle: true
  replication_factor: 1
  ring:
    kvstore:
      store: inmemory

# loki v3.x 推荐 TSDB 索引
schema_config:
  configs:
    - from: 2024-01-01
      # TSDB 索引
      store: tsdb
      # 对象存储改为 mino
      object_store: s3
      schema: v13
      index:
        prefix: index_
        period: 24h

# 写入组件
ingester:
  # WAL 仍然保留本地
  wal:
    enabled: true
    dir: /data/loki/wal
  chunk_idle_period: 5m
  max_chunk_age: 1h

# TSDB 压缩
compactor:
  # 本地临时目录
  working_directory: /data/loki/compactor
  compaction_interval: 10m
  retention_enabled: true
  # 删除请求存储
  delete_request_store: s3

limits_config:
  # 日志保存 30 天
  retention_period: 30d
  max_query_series: 10000
  ingestion_rate_mb: 10
  ingestion_burst_size_mb: 20

# 告警规则
ruler:
  alertmanager_url: http://127.0.0.1:9093
  storage:
    type: local
    local:
      directory: /etc/loki/rules
  rule_path: /data/loki/rules-temp
  ring:
    kvstore:
      store: inmemory
  enable_api: true
EOF

# 语法检查
loki -config.file=/etc/loki/loki.yaml -verify-config

auth_enabled: false                             #关闭Loki内置认证,不需要登录鉴权,内网环境使用

server:                                         #HTTP服务配置块
  http_listen_port: 3100                        #Loki对外HTTP端口,默认3100
  http_listen_address: 0.0.0.0                  #监听所有网卡,允许外部访问
  log_level: info                               #Loki自身日志输出级别info/debug/warn/error

common:                                         #公共配置,多个组件共享
  path_prefix: /data/loki                       #本地数据根目录,wal、临时文件存放根路径
  # minio 对象存储
  storage:                                      #对象存储配置,日志chunk、索引存 MinIO S3 兼容在储存
    s3:
      endpoint: minio.jasper.org:9000           #MinIO服务地址端口
      bucketnames: loki                         #MinIO桶名称,loki所有数据存在这个bucket
      access_key_id: d3qFSWw6zosYK4xyHeZC
      secret_access_key: iJ8gwfA5lZ3xhhf0n0EarjAkJgByNJKOnZWjJsUd
      # minio 使用 http
      insecure: true                            #true 使用http,关闭https证书校验
      # 强制 path style
      s3forcepathstyle: true                    #MinIO必须开启,使用path模式访问s3,不使用虚拟host模式
  replication_factor: 1                         #副本数,单机部署写1;集群部署大于1
  ring:                                         #一致性ring配置,单机使用内存存储ring信息
    kvstore:
      store: inmemory                           #ring元数据存内存,单机专用;集群改用etcd

# loki v3.x 推荐 TSDB 索引
schema_config:                                  #索引schema配置,定义索引存储格式
  configs:
    - from: 2024-01-01                          #该schema生效起始时间,早于该时间的数据不使用此配置
      # TSDB 索引
      store: tsdb                               #使用TSDB索引(Lokiv3推荐,替代原先boltdb-shippper)
      # 对象存储改为 mino
      object_store: s3                          #索引文件存放后端:s3(minio)
      schema: v13                               #schema版本号,v13适配tsdb
      index:
        prefix: index_                          #对象存储里索引文件名称前缀
        period: 24h                             #索引分片周期,每24小时生成一份独立索引

# 写入组件
ingester:                                       #ingester:接收日志写入,内存攒chunk,刷写到对象存储
  # WAL 仍然保留本地
  wal:
    enabled: true                               #开启WAL预写日志,宕机防止内存日志丢失
    dir: /data/loki/wal                         #WAL本地磁盘存储目录
  chunk_idle_period: 5m                         #chunk空闲5分钟,没有新数据就刷盘到对象存储
  max_chunk_age: 1h                             #chunk最长存活1小时,无论是否空闲强制刷盘

# TSDB 压缩
compactor:                                      #TSDB压缩组件,合并小索引块、执行数据过期删除
  # 本地临时目录
  working_directory: /data/loki/compactor       #compactor工作临时目录,压缩过程中间文件
  compaction_interval: 10m                      #压缩任务执行间隔,每10分钟跑一次压缩
  retention_enabled: true                       #开启数据过期清理,配合retention_period删除旧片日志
  # 删除请求存储
  delete_request_store: s3                      #删除请求记录保存到s3对象存储

limits_config:                                  #全局限流、配额、保存周期配置
  # 日志保存 30 天
  retention_period: 30d                         #全局日志保留时长30天,到期自动删除
  max_query_series: 10000                       #查询最大返回时序序列数量,防止大查询压垮loki
  ingestion_rate_mb: 10                         #单实例日志写入速率上限10MB/s
  ingestion_burst_size_mb: 20                   #写入突发流量上限20MB

# 告警规则
ruler:                             #ruler组件:加载告警规则,执行LogQL,产生告警推送给aalertmanager
  alertmanager_url: http://127.0.0.1:9093       #Alertmanager接收告警的地址
  storage:                                      #ruler规则文件存储配置
    type: local                                 #规则使用本地文件模式
    local:
      directory: /etc/loki/rules                #告警规则yam1文件存放目录
  rule_path: /data/loki/rules-temp              #ruler运行时临时缓存目录
  ring:
    kvstore:
      store: inmemory                           #ruler ring,单机内存存储
  enable_api: true                              #开启ruler http API,支持curl上传校验规则,调试用

# 查找当前版本的配置
/usr/local/bin/loki -help 2>&1 | grep -- '-ui\.'

# 带上配置文件再列 target
/usr/local/bin/loki -config.file=/etc/loki/loki.yaml -list-targets

# 加载后的 ui 块实际长什么样
/usr/local/bin/loki -config.file=/etc/loki/loki.yaml -print-config-stderr 2>&1 | grep -A 25 '^ui:'

# 启动日志里 ui 相关的行
grep -i -E 'ui|cluster' /var/log/loki/loki.log | tail -40

mkdir -p /var/log/loki

cat >/lib/systemd/system/loki.service <<EOF
[Unit]
Description=Grafana Loki Log Aggregator Service
Documentation=https://grafana.com/docs/loki/latest
After=network-online.target

[Service]
Type=simple
User=root
ExecStart=/usr/local/bin/loki -config.file=/etc/loki/loki.yaml
Restart=always
RestartSec=5
StandardOutput=append:/var/log/loki/loki.log
StandardError=append:/var/log/loki/loki-error.log
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload && systemctl enable --now loki
systemctl status loki
journalctl -f -u loki

# 自动生成相关文件
root@master01:~/.jasper# ls /data/loki/
compactor  tsdb-shipper-active  tsdb-shipper-cache  wal

# 查看 loki 相关服务
root@master01:~/.jasper# curl -s http://127.0.0.1:3100/services
querier => Running
ingester => Running
query-frontend => Running
server => Running
query-scheduler-ring => Running
ring => Running
analytics => Running
query-scheduler => Running
rule-evaluator => Running
query-frontend-tripperware => Running
compactor => Running
store => Running
ingester-querier => Running
ruler => Running
cache-generation-loader => Running
memberlist-kv => Running
distributor => Running

root@master01:~/.jasper# curl -s http://127.0.0.1:3100/ready
Ingester not ready: waiting for 15s after being ready

root@master01:~/.jasper# curl -s http://127.0.0.1:3100/ready
ready

ALLOY_VERSION=1.19.2
OS=$(uname -s | tr 'A-Z' 'a-z')
ARCH=$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/')
PLATFORM="$OS-$ARCH"

wget https://github.com/grafana/alloy/releases/download/v${ALLOY_VERSION}/alloy-${PLATFORM}.zip
unzip alloy-${PLATFORM}.zip
install -m 755 alloy-${PLATFORM}  /usr/local/bin/alloy
alloy -v

# wget https://mirrors.tuna.tsinghua.edu.cn/grafana/apt/pool/main/g/grafana/grafana_13.2.2_34846740809_linux_arm64.deb
# dpkg -i grafana-enterprise-rpi_13.2.2_34846740809_linux_arm-6.deb
# systemctl enable --now grafana-server

GRAFANA_VERSION=13.2.2
GRAFANA_FULLVERSION=${GRAFANA_VERSION}_34846740809
OS=$(uname -s | tr 'A-Z' 'a-z')
ARCH=$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/')
PLATFORM="${OS}_${ARCH}"

wget https://dl.grafana.com/grafana-enterprise/release/${GRAFANA_VERSION}/grafana-enterprise_${GRAFANA_FULLVERSION}_${PLATFORM}.tar.gz
tar -zxvf grafana-enterprise_${GRAFANA_FULLVERSION}_${PLATFORM}.tar.gz \
    --strip-components=2  \
    -C /usr/local/bin
    grafana-${GRAFANA_VERSION}/bin/grafana
grafana -v


tar xf grafana-enterprise_${GRAFANA_FULLVERSION=}_linux_${ARCH}.tar.gz
mv grafana-${GRAFANA_VERSION} /usr/local/grafana

useradd -r -s /bin/false grafana
chown -R grafana:users /usr/local/grafana

mkdir -pv /etc/grafana/provisioning/{access-control,alerting,dashboards,datasources,notifiers,plugins}
mkdir -pv /var/log/grafana /var/lib/grafana/plugins

chown -R grafana:grafana /var/log/grafana /var/lib/grafana /etc/grafana/provisioning

cat <<\EOF>  /etc/grafana/grafana.ini
[server]
# 生成外部链接（分享链接、OAuth 回调、告警通知里的跳转 URL）
root_url = http://10.103.236.201:3000
EOF



cat >/lib/systemd/system/grafana-server.service <<\EOF
[Unit]
Description=Grafana Server
After=network.target

[Service]
Type=simple
User=grafana
Group=users
#Grafana 启动的硬性依赖 /usr/local/grafana/conf/defaults.ini
#生效顺序（后者覆盖前者）:
#  conf/defaults.ini  →  grafana.ini  →  GF_* 环境变量  →  命令行 cfg: 参数
Environment=GF_PATHS_HOME=/usr/local/grafana
Environment=GF_PATHS_CONFIG=/etc/grafana/grafana.ini
Environment=GF_PATHS_DATA=/var/lib/grafana
Environment=GF_PATHS_LOGS=/var/log/grafana
Environment=GF_PATHS_PLUGINS=/var/lib/grafana/plugins
Environment=GF_PATHS_PROVISIONING=/etc/grafana/provisioning
ExecStart=/usr/local/grafana/bin/grafana server \
   --homepath=${GF_PATHS_HOME} \
   --config=${GF_PATHS_CONFIG} \
   cfg:default.log.mode=console                            \
   cfg:default.paths.data=${GF_PATHS_DATA}                   \
   cfg:default.paths.logs=${GF_PATHS_LOGS}                   \
   cfg:default.paths.plugins=${GF_PATHS_PLUGINS}             \
   cfg:default.paths.provisioning=${GF_PATHS_PROVISIONING}
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload && systemctl enable --now grafana-server
systemctl status grafana-server
journalctl -u grafana-server -f
journalctl -u grafana-server -n 30 --no-pager | grep -i "config\|root_url\|listen"

ALERT_VERSION=0.34.1
OS=$(uname -s | tr 'A-Z' 'a-z')
ARCH=$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/')
PLATFORM="${OS}-${ARCH}"

wget https://github.com/prometheus/alertmanager/releases/download/v${ALERT_VERSION}/alertmanager-${ALERT_VERSION}.${PLATFORM}.tar.gz

tar -zxvf alertmanager-${ALERT_VERSION}.${PLATFORM}.tar.gz \
    --strip-components=1  \
    -C /usr/local/bin \
    alertmanager-${ALERT_VERSION}.${PLATFORM}/{alertmanager,amtool}

useradd -r -s /bin/false alertmanager

mkdir -pv /etc/alertmanager /data/alertmanager
chown -R alertmanager:alertmanager /etc/alertmanager /data/alertmanager


cat <<\EOF>  /etc/alertmanager/alertmanager.yml
global:
  resolve_timeout: 1m
  # 邮件信息
  smtp_from: "xxxx@163.com"
  smtp_smarthost: "smtp.163.com:465"
  smtp_hello: "163.com"
  smtp_auth_username: "xxx@163.com"
  smtp_auth_password: "Nxxx" # 授权码
  smtp_require_tls: false
route:
  group_by: ['instance', 'cluster']
  group_wait: 10s
  group_interval: 10s
  repeat_interval: 10s
  receiver: 'email'
receivers:
  - name: 'email'
    email_configs:
    - to: 'xcwhome@163.com'
      send_resolved: true
      headers: {Subject: "[WARN] {{ .CommonLabels.alertname }}"}
inhibit_rules:
  - source_matchers: [severity="critical"]
    target_matchers: [severity="warning"]
    equal: [alertname, dev, instance]
EOF

# 语法检测
amtool check-config /etc/alertmanager/alertmanager.yml

cat >/lib/systemd/system/alertmanager.service <<\EOF
[Unit]
Description=Alertmanager Server
After=network.target

[Service]
Type=simple
User=grafana
Group=users
ExecStart=/usr/local/bin/alertmanager  \
   --config.file=/etc/alertmanager/alertmanager.yml \
   --storage.path=/data/alertmanager \
   --cluster.advertise-address=0.0.0.0:9093 \
   --data.retention=240h \
   --web.route-prefix=/ \
   --web.external-url=https://alert.jasper.org
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload && systemctl enable --now alertmanager
systemctl status alertmanager
journalctl -u alertmanager -f
journalctl -u alertmanager -f | grep -i "notify\|smtp"

# 重新加载配置
curl -X POST http://localhost:9093/-/reload

# 调用 api
curl --location --request POST 'http://10.103.236.201:9093/api/v2/alerts' \
--header 'Content-Type: application/json' \
--data-raw '[
    {
        "labels": {
            "alertname":"testAlert",
            "severity": "critical",
            "duty": "infra_op|fsy_rd"
        },
        "annotations": {
            "info": "The disk sda1 is running full2",
            "summary": "please check the instance example1"
        }
    }
]'

# 或者使用 amtool
amtool alert add alertname=TestEmail severity=critical service=inhouse-service \
    --annotation=summary="邮件通道测试" \
    --alertmanager.url=http://localhost:9093

# 添加告警规则文件
mkdir -p /etc/loki/rules/fake
cat >/etc/loki/rules/fake/alert-rule-demo1.yml <<EOF
groups:
  - name: http_response
    interval: 10s
    rules:
      - alert: HighPercentageError
        expr: |-
          sum(rate({filename="/var/log/flog/access_json.log", status=~"(4|5).."}[1m]))
          /
          sum(rate({filename="/var/log/flog/access_json.log"}[1m])) > 0.5
        for: 10s
        labels:
          serverty: warning
        annotations:
          summary: High request latency
  - name: nginx_availability
    interval: 10s
    rules:
      - alert: NginxToraffic
        expr: |
          absent_over_time({container="calico-node"}[1m])
        for: 10s
        labels:
          serverty: critical
          service: nginx
        annotations:
          summary: 'nginx 服务无日志'
          description: |
            nginx 1 分钟没有产生访问日志，
            可能服务异常或无法访问。
EOF

# 规则文件自动加载，无需重启 loki 服务，可能通过 API 查看告警规则生效
curl 10.103.236.201:3100/loki/api/v1/rules

curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-4
chmod 700 get_helm.sh
./get_helm.sh

helm repo add grafana-community https://grafana-community.github.io/helm-charts
helm repo update
kubectl create namespace loki

# 1.基础认证 2jptrlpa9kqig$64xvytroot
apt install apache2-utils -y
htpasswd -c .htpasswd lokiuser # 输入用户密码


kubectl create secret generic loki-basic-auth --from-file=.htpasswd -n loki
# 与 Loki 网关进行身份验证
kubectl create secret generic canary-basic-auth \
  --from-literal=username=canaryuser \
  --from-literal=password=9kqig$64xvytroot \
  -n loki

cat >values-monolithic.yaml<<\EOF
loki:
  commonConfig:
    # 单体模式只有 1 个实例，副本因子必须为 1，否则 ring 凑不齐 quorum 导致写入失败
    replication_factor: 1
  schemaConfig:
    configs:
      - from: "2024-04-01"
        store: tsdb
        object_store: s3
        schema: v13
        index:
          prefix: loki_index_
          period: 24h
  pattern_ingester:
    enabled: true
  limits_config:
    allow_structured_metadata: true
    volume_enabled: true
    retention_period: 672h # 28 days retention
  compactor:
    retention_enabled: true
    delete_request_store: s3
  rulerConfig:
    enable_api: true
    alertmanager_url: http://prom:9093

  querier:
    max_concurrent: 4

  storage:
    type: s3
    bucketNames:
      chunks: "loki-test"
      ruler: "loki-test"
    s3:
      # MinIO S3 API 端口是 9000（9001 是 console）
      endpoint: 10.0.0.101:9000
      # 注意：原文件里 AK/SK 写反了，已对调（MinIO AK 20 字符，SK 40 字符）
      accessKeyId: d3qFSWw6zosYK4xyHeZC
      secretAccessKey: iJ8gwfA5lZ3xhhf0n0EarjAkJgByNJKOnZWjJsUd
      s3ForcePathStyle: true
      # Allows insecure (HTTP) connections (true/false)
      insecure: true

deploymentMode: Monolithic

singleBinary:
  replicas: 1
  # 不要设 kind: Deployment —— chart 默认的 singleBinary.strategy 含 rollingUpdate.partition，
  # 那是 StatefulSet 专有字段，渲染进 Deployment.spec.strategy 会被 API schema 拒绝。
  persistence:
    enabled: true
    #storageClass: local-path
    #size: 10Gi

ingester:
  replicas: 0
querier:
  replicas: 0
queryFrontend:
  replicas: 0
queryScheduler:
  replicas: 0
distributor:
  replicas: 0
compactor:
  replicas: 0
indexGateway:
  replicas: 0

# Disable minio storage
minio:
  enabled: false

backend:
  replicas: 0
read:
  replicas: 0
write:
  replicas: 0

# 节点只有 ~3.2Gi 可用内存，chunks-cache 默认请求 9830Mi 永远调度不上，单体模式下关掉
chunksCache:
  enabled: false
resultsCache:
  enabled: false

# 入口 svc 走 Cilium LB IPAM（default-pool: 10.0.0.10-50）+ L2 announcement
gateway:
  service:
    type: LoadBalancer
    # 固定 LB IP（Cilium LB IPAM 专用注解），避免 svc 重建后地址漂移
    #annotations:
    #  io.cilium/lb-ipam-ips: "10.0.0.12"
EOF

# config.alloy
cat >config.alloy<<\EOF
// ============================================================================
// Grafana Alloy 采集配置
//   A. Kubernetes Pod 容器日志  (/var/log/pods)
//   B. 宿主机 systemd journal   (kubelet / containerd / sshd / 内核 等)
//   C. 公共处理 + 写入 Loki
//
// 本文件由外部 ConfigMap `alloy-config` 挂载，不在 Helm values 里。
// 修改后：
//   kubectl create cm alloy-config -n alloy --from-file=config.alloy=config.alloy \
//     --dry-run=client -o yaml | kubectl apply -f -
// config-reloader 边车会自动触发 Alloy 热加载，不需要重启 Pod。
// ============================================================================

// ############################################################################
// A. Pod 容器日志
// ############################################################################

// 只发现「本节点」的 Pod。DaemonSet 每实例各管各的节点，用 field selector
// 在 API Server 侧过滤，避免每个实例都拉全集群 Pod 列表。
// K8S_NODE_NAME 由 Helm chart 自动注入 (fieldRef: spec.nodeName)。
discovery.kubernetes "pods" {
  role = "pod"
  selectors {
    role  = "pod"
    field = "spec.nodeName=" + sys.env("K8S_NODE_NAME")
  }
}

discovery.relabel "pod_logs" {
  targets = discovery.kubernetes.pods.targets

  rule {
    source_labels = ["__meta_kubernetes_namespace"]
    target_label  = "namespace"
  }
  rule {
    source_labels = ["__meta_kubernetes_pod_name"]
    target_label  = "pod"
  }
  rule {
    source_labels = ["__meta_kubernetes_pod_container_name"]
    target_label  = "container"
  }
  // 注意: role=pod 的节点元标签是 __meta_kubernetes_pod_node_name,
  //       不是 __meta_kubernetes_node_name（后者取不到值）
  rule {
    source_labels = ["__meta_kubernetes_pod_node_name"]
    target_label  = "node"
  }
  // job = <namespace>/<container>
  rule {
    source_labels = ["__meta_kubernetes_namespace", "__meta_kubernetes_pod_container_name"]
    separator     = "/"
    target_label  = "job"
  }

  // ---- 服务名（研发最常用的过滤维度）----
  // pod 名带 ReplicaSet 哈希，每次发版都变，不适合。
  // regex "(.+)" 的作用是「源标签为空时不覆盖」——默认 regex 是 (.*)，
  // 空值也会匹配并把目标标签置空。
  rule {
    source_labels = ["__meta_kubernetes_pod_label_app"]
    regex         = "(.+)"
    target_label  = "app"
  }
  // 标准标签优先级更高，存在则覆盖上面的
  rule {
    source_labels = ["__meta_kubernetes_pod_label_app_kubernetes_io_name"]
    regex         = "(.+)"
    target_label  = "app"
  }

  // containerd 路径: /var/log/pods/<ns>_<pod>_<uid>/<container>/<n>.log
  rule {
    source_labels = ["__meta_kubernetes_pod_uid", "__meta_kubernetes_pod_container_name"]
    separator     = "/"
    action        = "replace"
    replacement   = "/var/log/pods/*$1/*.log"
    target_label  = "__path__"
  }
}

local.file_match "pod_logs" {
  path_targets = discovery.relabel.pod_logs.output
}

loki.source.file "pod_logs" {
  targets    = local.file_match.pod_logs.targets
  forward_to = [loki.process.cri.receiver]
}

// containerd 行格式: <RFC3339Nano> <stdout|stderr> <F|P> <message>
// stage.cri 提取时间戳与 stream，并拼回被切分的长行(P/F)
loki.process "cri" {
  forward_to = [loki.process.common.receiver]

  stage.cri { }

  // ---- 多行合并（对所有 Pod 日志生效，不需要任何标注）----
  // firstline 覆盖的格式：
  //   2026-09-30T10:00:00 / 2026-09-30 10:00:00   ISO 时间戳（Java、Spring 等）
  //   10.0.0.1 - - [...]                           access log，IP 开头
  //   {"time":...}                                 JSON
  //   level=info ts=...                            logfmt（Loki/Alloy 各组件）
  //   I0930 10:00:00                               klog（k8s 组件）
  //   2026/09/30 10:00:00                          nginx error log
  //
  // 新增服务如果日志行首格式不在上面这几类里，它的每一行都会被当成续行
  // 合并到上一条——排查「某服务日志糊成一坨」时先查这里。max_lines 是兜底。
  stage.multiline {
    firstline     = "^(\\d{4}-\\d{2}-\\d{2}[ T]\\d{2}:\\d{2}:\\d{2}|\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}[ :]|\\{|[a-z_]+=|[IWEF]\\d{4} \\d{2}:\\d{2}:\\d{2}|\\d{4}/\\d{2}/\\d{2} \\d{2}:\\d{2}:\\d{2})"
    // 1s 而不是 3s：multiline 要等下一行或超时才能确定边界，这个等待加在
    max_wait_time = "1s"
    max_lines     = 200
  }

  // 日志来源分类：pod（应用容器） vs systemd（宿主机系统服务）
  stage.static_labels {
    values = {
      source = "pod",
    }
  }

  // ---- JSON access log 的级别：由 HTTP 状态码映射 ----
  //
  // selector 用【行过滤器】限定范围，只让「行首是 { 且含 status 字段」的行进来。
  stage.match {
    // LogQL 的行过滤器【只接受双引号字符串】，写反引号会在 reload 时报
    // "unexpected IDENTIFIER, expecting STRING"，而 alloy validate 查不出来。
    // 这里只筛「行首是 {」，status 字段是否存在交给下面的 template 判断——
    // init 容器也输出 JSON，但没有 status。
    selector = "{source=\"pod\"} |~ \"^\\\\{\""

    stage.json {
      expressions = {
        status = "status",
        host   = "host",
      }
    }

    // stage.json 提取出来的数字在 extracted map 里是 float64，
    // 先 printf 成整数字符串再 atoi，直接把 float64 喂给 atoi 会失败。
    stage.template {
      source   = "level"
      // .status 不存在时输出空串，stage.labels 会跳过空值、不打这个标签。
      // 用 sprig 的 int 而不是 printf+atoi：stage.json 提取出的 status
      // 实测是字符串而非 float64，printf "%.0f" 会失败得到 0，
      // 结果 404 被错判成 info。int 对字符串和浮点都能转。
      template = "{{ if .status }}{{ $s := .status | int }}{{ if ge $s 500 }}error{{ else if ge $s 400 }}warn{{ else }}info{{ end }}{{ end }}"
    }

    // ---- host 标签：保留真实值 ----
    //
    // $host 取自请求的 Host 头，任何人都能任意制造——实测发
    // evil.example.com / scanner-test.cn / 1.2.3.4 这些无关 Host，
    // 虽然 Gateway 都返回 404，$host 照样被记进 access log。
    //
    // 【刻意不做白名单归一化】。曾经把白名单外的值归成 _other 来控制基数，
    // 但那样等于把「谁在扫、扫的什么域名」这条安全线索丢掉——
    // evil.example.com 和 scanner-test.cn 变成同一个值，看不出任何东西。
    // access log 的价值之一就是暴露异常访问，不该在采集端提前丢弃。
    //
    // 基数风险改用「护栏 + 监控」应对：
    //   - 这里截断到 253 字符（域名理论最大长度），防止恶意构造的超长 Host
    //     顶破 Loki 的 max_label_value_length(2048) 导致整批写入被拒
    //   - 配套告警 GatewayHostCardinalityHigh 盯住 host 基数，
    //     真被扫了能及时发现（见 loki/parts/loki-alerts.yaml）
    stage.template {
      source   = "host_label"
      template = "{{ if .host }}{{ .host | trunc 253 }}{{ end }}"
    }

    stage.labels {
      values = {
        level = "",
        // 标签名 host，取值来自上面截断过的 host_label
        host  = "host_label",
      }
    }
  }
}

// ############################################################################
// B. 宿主机 systemd journal
//    Ubuntu 26.04 未启用 rsyslog，kubelet/containerd/sshd/内核 日志全在 journald
// ############################################################################

discovery.relabel "journal" {
  targets = []

  // systemd unit 全名，精确过滤用：{unit="kubelet.service"}
  rule {
    source_labels = ["__journal__systemd_unit"]
    target_label  = "unit"
  }
  rule {
    source_labels = ["__journal__hostname"]
    target_label  = "node"
  }
  // 非 systemd 托管的来源（内核等）靠这个区分
  rule {
    source_labels = ["__journal_syslog_identifier"]
    target_label  = "syslog_identifier"
  }
  // syslog 优先级: emerg/alert/crit/err/warning/notice/info/debug
  rule {
    source_labels = ["__journal_priority_keyword"]
    target_label  = "level"
  }

  // ---- 让系统服务也有 app 标签 ----
  // 否则 Grafana 里按「服务」筛选时完全找不到 kubelet/containerd 这类日志。
  // 先取 unit 全名兜底，再用去掉 .service 后缀的短名覆盖，
  // 这样下拉框里看到的是 kubelet / containerd，而不是 kubelet.service。
  rule {
    source_labels = ["__journal__systemd_unit"]
    regex         = "(.+)"
    target_label  = "app"
  }
  rule {
    source_labels = ["__journal__systemd_unit"]
    regex         = "(.+)\\.service"
    target_label  = "app"
  }
}

loki.source.journal "host" {
  path = "/var/log/journal"

  // 只读取最近 1 分钟内的条目。
  // Alloy 的 positions 存在 /tmp/alloy（emptyDir），Pod 重启即丢失，
  // 因此每次启动都从「当前时刻附近」开始，不会回灌 152MB 历史。
  max_age = "1m"

  relabel_rules = discovery.relabel.journal.rules

  // namespace 用 _system 占位：Grafana 看板普遍用 namespace=~"$namespace" 过滤，
  // 而 LogQL 的 =~".+" 要求标签存在且非空。不给 namespace 的话，
  // 系统日志在所有按命名空间筛选的面板里都会消失。
  labels = {
    job       = "systemd-journal",
    source    = "systemd",
    namespace = "_system",
  }

  forward_to = [loki.process.common.receiver]
}

// ############################################################################
// C. 公共处理 —— Pod 日志与 journal 两条路径都必须经过这里
// ############################################################################

loki.process "common" {
  forward_to = [loki.write.default.receiver]

  // 多行合并【不在这里】——它只作用于 pod 路径，放在 loki.process "cri" 里。
  // 原因：systemd journal 的消息体 100% 不匹配时间戳行首，
  // 在这条公共路径上做合并会把宿主机日志糊成一坨。

  stage.static_labels {
    values = {
      project     = "jp",
      environment = "test",
    }
  }
}

// ############################################################################
// D. 写入 Loki
// ############################################################################

loki.write "default" {
  endpoint {
    url       = "http://loki-gateway.loki.svc.cluster.local/loki/api/v1/push"
    tenant_id = "jasper"    // 等价于请求头 X-Scope-OrgID
  }
}
EOF

# value 
cat >values-alloy.yaml <<\EOF
# ==============================================================================
# Grafana Alloy - 日志采集 (DaemonSet)
#   A. Kubernetes Pod 容器日志  /var/log/pods
#   B. 宿主机 systemd journal   /var/log/journal
# 输出: http://loki-gateway.loki.svc.cluster.local (集群内 ClusterIP)，租户 jasper
# chart: alloy-1.13.0 / app: v1.20.0
#
# 采集配置【不在本文件里】，由外部 ConfigMap `alloy-config` 提供，
# 源文件是同目录的 config.alloy。修改流程：
#
#   vi config.alloy
#   kubectl create cm alloy-config -n alloy \
#     --from-file=config.alloy=config.alloy \
#     --dry-run=client -o yaml | kubectl apply -f -
#
# config-reloader 边车监听 /etc/alloy 并调用 Alloy 的 /-/reload，
# 配置会自动热加载，不需要 helm upgrade，也不需要重启 Pod。
# ==============================================================================

controller:
  type: daemonset
  tolerations:
  - key: node-role.kubernetes.io/control-plane
    operator: Exists
    effect: NoSchedule
  volumes:
    extra:
    - name: machine-id
      hostPath:
        path: /etc/machine-id
        type: File
crds:
  create: false
rbac:
  create: true
alloy:
  mounts:
    varlog: true
    extra:
    - name: machine-id
      mountPath: /etc/machine-id
      readOnly: true
  securityContext:
    runAsUser: 0
  resources:
    requests:
      cpu: 50m
      memory: 128Mi
    limits:
      memory: 256Mi
  configMap:
    create: false
    name: alloy-config
    key: config.alloy
service:
  enabled: true
  type: LoadBalancer
#  annotations:
#    io.cilium/lb-ipam-ips: 10.0.0.13
EOF

kubectl create namespace alloy --dry-run=client -o yaml | kubectl apply -f -

kubectl create configmap alloy-config -n alloy \
  --from-file=config.alloy=config.alloy \
  --dry-run=client -o yaml | kubectl apply -f -

helm upgrade --install alloy grafana/alloy \
  --namespace alloy --create-namespace \
  --values alloy/values-alloy.yaml \
  --wait --timeout 10m

kubectl get pods -n alloy -o wide

# config-events.alloy
cat >config-events.alloy<<\EOF
// ============================================================================
// Grafana Alloy 采集配置 —— Kubernetes Events
//
//   loki.source.kubernetes_events  ->  loki.relabel  ->  loki.process  ->  loki.write
//
// 为什么单独一个 Deployment 而不是并进 DaemonSet 的 config.alloy：
//   Events 是集群级资源，DaemonSet 的 5 个副本会各采一份，同一个事件进 Loki 5 条。
//
// 本文件由外部 ConfigMap `alloy-events-config` 挂载，不在 Helm values 里。
// 修改后：
//   kubectl create cm alloy-events-config -n alloy \
//     --from-file=config.alloy=config-events.alloy \
//     --dry-run=client -o yaml | kubectl apply -f -
// config-reloader 边车会自动触发热加载，不需要重启 Pod。
// ============================================================================

// Events 只在 etcd 里保留 1 小时（apiserver 未设 --event-ttl，取的默认值），
// 过期就永久查不到。收进 Loki 才能事后追溯。
//
// namespaces 留空 = 监听全部命名空间。
// 输出行是 logfmt，形如：
//   name=<对象名> kind=Pod reason=Scheduled type=Normal sourcehost=<节点>
//   reportingcontroller=kubelet msg="Successfully assigned ..."
loki.source.kubernetes_events "cluster" {
  job_name   = "kubernetes-events"
  log_format = "logfmt"
  forward_to = [loki.relabel.events.receiver]
}

loki.relabel "events" {
  forward_to = [loki.process.events.receiver]

  // ---- namespace 兜底 ----
  // 集群级对象（Node、PersistentVolume 等）的事件没有 namespace，
  rule {
    source_labels = ["namespace"]
    regex         = "^$"
    target_label  = "namespace"
    replacement   = "_cluster"
  }

  // Alloy 自动附加的 instance=loki.source.kubernetes_events.cluster 没有查询价值，
  // 丢掉以免多一个无意义的索引标签
  rule {
    regex  = "instance"
    action = "labeldrop"
  }
}

loki.process "events" {
  forward_to = [loki.write.default.receiver]

  // 从 logfmt 行里取出两个字段。注意这里只是放进「提取映射」供后面的 stage 用，
  // 不会自动变成标签——变成标签要显式经过 stage.labels。
  stage.logfmt {
    mapping = {
      "evt_type"   = "type",
      "sourcehost" = "",
    }
  }

  // ---- level ----
  // event 的 type 只有 Normal / Warning 两种，映射成现有体系里的 level，
  // 这样 events 能直接接入按 level 筛选的面板。基数只有 2，很安全。
  stage.template {
    source   = "level"
    template = "{{ if eq .evt_type \"Warning\" }}warn{{ else }}info{{ end }}"
  }

  // ---- node ----
  // kubelet 报的事件带 sourcehost；scheduler / 各种 controller 报的事件是集群级的，
  // 没有节点归属。和 namespace 同样的理由，空值要兜底，否则按节点筛选时会丢。
  stage.template {
    source   = "node"
    template = "{{ if .sourcehost }}{{ .sourcehost }}{{ else }}_cluster{{ end }}"
  }

  stage.labels {
    values = {
      level = "",
      node  = "",
    }
  }

  // source 与现有的 pod / systemd 并列，构成第三类日志来源。
  //
  // app 给一个固定值而不是取 reportingcontroller：后者有十几种取值，
  // 乘上 namespace 会把 stream 数抬高一个量级，而这套栈真正的风险是标签基数不是数据量。
  // 想按报告者过滤用 `| logfmt | reportingcontroller="kubelet"`，走解析器不增加基数。
  stage.static_labels {
    values = {
      source      = "kubernetes-events",
      project     = "jp",
      environment = "test",
      app         = "kubernetes-events",
    }
  }
}

loki.write "default" {
  endpoint {
    url       = "http://loki-gateway.loki.svc.cluster.local/loki/api/v1/push"
    tenant_id = "jasper"
  }
}
EOF

# value
cat >values-alloy-events.yaml<<\EOF
# ==============================================================================
# Grafana Alloy - Kubernetes Events 采集 (Deployment, 单副本)
#
# 输出: http://loki-gateway.loki.svc.cluster.local (集群内 ClusterIP)，租户 jasper
# chart: alloy-1.13.0 / app: v1.20.0（与 DaemonSet 那套同一个 chart 包）
#
# 采集配置【不在本文件里】，由外部 ConfigMap `alloy-events-config` 提供，
# 源文件是同目录的 config-events.alloy。修改流程：
#
#   vi config-events.alloy
#   kubectl create cm alloy-events-config -n alloy \
#     --from-file=config.alloy=config-events.alloy \
#     --dry-run=client -o yaml | kubectl apply -f -
#
# config-reloader 边车监听 /etc/alloy 并调用 Alloy 的 /-/reload，自动热加载。
# ==============================================================================

controller:
  type: deployment
  replicas: 1
  ## 跑在 master 上：
  #tolerations:
  #- key: node-role.kubernetes.io/control-plane
  #  operator: Exists
  #  effect: NoSchedule
  #nodeSelector:
  #  node-role.kubernetes.io/control-plane: ""

crds:
  create: false

# chart 按 release 名生成 alloy-events 这一套 SA/ClusterRole/Binding，
# 与现有 alloy 的那套互不影响。events 的 get/list/watch 权限默认就包含。
rbac:
  create: true

alloy:
  # 只跟 API Server 打交道，不读宿主机文件：
  # 既不用挂 /var/log，也不需要 runAsUser: 0
  mounts:
    varlog: false
  resources:
    requests:
      cpu: 20m
      memory: 96Mi
    limits:
      memory: 192Mi
  configMap:
    create: false
    name: alloy-events-config
    key: config.alloy

# 调试用 kubectl port-forward 即可
service:
  enabled: true
  type: ClusterIP
EOF

kubectl create configmap alloy-events-config -n alloy \
  --from-file=config.alloy=config-events.alloy \
  --dry-run=client -o yaml | kubectl apply -f -

helm upgrade --install alloy-events grafana/alloy \
  --namespace alloy \
  --values values-alloy-events.yaml \
  --wait --timeout 10m

kubectl get pods -n alloy -o wide

lq /loki/api/v1/labels | jq .data

lq /loki/api/v1/label/node/values | jq .data          # 应列出全部 5 个节点
lq /loki/api/v1/label/unit/values | jq .data          # systemd unit，应含 kubelet.service
lq /loki/api/v1/label/project/values | jq .data       # 应为 ["jp"]
lq /loki/api/v1/label/environment/values | jq .data   # 应为 ["test"]

NOW=$(date +%s)
lq /loki/api/v1/query_range \
  --data-urlencode 'query={namespace="loki"}' \
  --data-urlencode "start=$((NOW-600))000000000" \
  --data-urlencode "end=${NOW}000000000" \
  --data-urlencode 'limit=1' | jq '.data.result[0].stream'

{
  "container": "ingester", "environment": "test", "filename": "/var/log/pods/...",
  "job": "loki/ingester", "namespace": "loki", "node": "node01.jasper.org",
  "pod": "loki-ingester-0", "project": "jp", "service_name": "ingester", "stream": "stderr"
}

curl -s http://10.0.0.13:12345/-/ready                      # 应返回 ready
curl -s http://10.0.0.13:12345/metrics | grep loki_write_sent_entries_total

lq /loki/api/v1/query --data-urlencode 'query=sum(count_over_time({job=~".+"}[2m]))'|jq .data.result[0]
lq /loki/api/v1/query --data-urlencode 'query=sum(count_over_time({job=~".+", project="jp", environment="test"}[2m]))' | jq .data.result[0]

logger -t label-test "verification $(date +%s)"
sleep 20
NOW=$(date +%s)
lq /loki/api/v1/query_range \
  --data-urlencode 'query={job="systemd-journal"} |= `verification`' \
  --data-urlencode "start=$((NOW-120))000000000" --data-urlencode "end=${NOW}000000000" \
  | jq '.data.result[0].stream'

kubectl port-forward -n loki svc/loki-ruler 3110:3100 &
curl -s -H 'X-Scope-OrgID: jasper' \
  http://127.0.0.1:3110/prometheus/api/v1/rules | jq -r \
  '.data.groups[].rules[] | "\(.name)  state=\(.state)  health=\(.health)"' | column -t

# 关闭
ss -lptn 'sport = :3110'

root@master01:~# jobs
[1]+  Running                    kubectl port-forward -n loki svc/loki-ruler 3110:3100 &

kill %1       # 按编号杀
#或者 fg %1 调回前台再 Ctrl-C。

pgrep -af 'port-forward.*loki-ruler'    # 先确认只匹配到这一个
pkill -f 'port-forward.*loki-ruler'

lq /loki/api/v1/query --data-urlencode 'query=sum by (namespace) (rate({namespace=~".+", namespace!="loki"} |~ `(?i)(^|[^a-z])(error|fatal|panic)([^a-z]|$)` [5m])) > 2'

kubectl create ns alert-test

kubectl apply -f - <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: error-spewer
  namespace: alert-test
spec:
  restartPolicy: Never
  containers:
  - name: spew
    # 用集群里已有的镜像，避免 docker.io 不可达
    image: docker.io/nginxinc/nginx-unprivileged:1.31-alpine
    command: ["/bin/sh","-c"]
    args:
      - |
        i=0
        #while [ $i -lt 3000 ]; do
        while [ $i -lt 9600 ]; do
          echo "ERROR simulated failure for alert verification seq=$i"
          i=$((i+1)); sleep 0.1
        done
    resources:
      requests: {cpu: 20m, memory: 32Mi}
      limits: {memory: 64Mi}
EOF

kubectl port-forward -n loki svc/loki-ruler 3110:3100 &

while true; do
  curl -s -H "X-Scope-OrgID: jasper" \
    http://127.0.0.1:3110/prometheus/api/v1/rules \
    | jq -r '.data.groups[].rules[]
             | select(.name=="HighErrorLogRate")
             | "\(.state) alerts=\(.alerts|length)"'
  sleep 50
done

pgrep -af 'port-forward.*loki-ruler'    # 先确认只匹配到这一个
pkill -f 'port-forward.*loki-ruler'

{
  "state": "firing",
  "labels": {"alertname": "HighErrorLogRate", "component": "workload",
             "namespace": "alert-test", "severity": "warning"},
  "value": "9.66e+00",
  "annotations": {"summary": "命名空间 alert-test 错误日志偏多"}
}

kubectl delete ns alert-test

kubectl logs -n loki deploy/loki-ruler --since=5m | grep "Error sending alerts"

kubectl logs -n loki -l app.kubernetes.io/component=query-frontend -f --tail=0 | grep org_id

kubectl port-forward -n loki --address 0.0.0.0 svc/loki-distributor 3100:3100 &
curl -s localhost:3100/ring        # ingester ring，应有 3 个 ACTIVE

pgrep -af 'port-forward.*loki-distributo'    # 先确认只匹配到这一个
pkill -f 'port-forward.*loki-distributo'