轻量级云原生日志收集方案 Loki 中文入门指南

最新推荐文章于 2024-07-09 08:06:52 发布
最新推荐文章于 2024-07-09 08:06:52 发布
阅读量4.1k 收藏 4
点赞数
文章标签： docker 大数据 分布式 kubernetes python
原文链接：https://mp.weixin.qq.com/s?__biz=MzI3MTI2NzkxMA==&mid=2247516527&idx=1&sn=319b8f4c6b8e442b9103e4d84b14e6ba&chksm=eac6a046ddb1295011245a4ea0c9ba31ef52846d9f91a94b7ba31627308019cc45a4dbf72724&scene=126&&sessionid=0
版权

公众号关注 「奇妙的 Linux 世界」

设为「星标」，每天带你玩转 Linux ！

8e112186d4bffc025c9e0a70dc1e38a6.png

Hi，很高兴能够在掘金开发者的平台上为大家带来一套轻量级的 kubernetes 日志收集方案的相关介绍。我自己也在生产环境中使用过这套方案，令我意想不到的时它占用的 kubernetes 的资源相比与 ELK 这套方案真的是小巫见大巫。那接下来就跟随这篇文章开始学习它吧……

为什么要使用 Loki

这篇文章着重介绍了 grafana 公司开发的 loki 日志收集应用。Loki 是一个轻量级的日志收集、分析的应用，采用的是 promtail 的方式来获取日志内容并送到 loki 里面进行存储，最终在 grafana 的 datasource 里面添加数据源进行日志的展示、查询。

loki 的持久化存储支持 azure、gcs、s3、swift、local 这 5 中类型，其中常用的是 s3、local。另外，它还支持很多种日志搜集类型，像最常用的 logstash、fluentbit 也在官方支持的列表中。

那它有哪些优点呢？

  • 支持的客户端，如 Promtail，Fluentbit，Fluentd，Vector，Logstash 和 Grafana Agent

  • 首选代理 Promtail，可以多来源提取日志，包括本地日志文件，systemd，Windows 事件日志，Docker 日志记录驱动程序等

  • 没有日志格式要求，包括 JSON，XML，CSV，logfmt，非结构化文本

  • 使用与查询指标相同的语法查询日志

  • 日志查询时允许动态筛选和转换日志行

  • 可以轻松地计算日志中的需要的指标

  • 引入时的最小索引意味着您可以在查询时动态地对日志进行切片和切块，以便在出现新问题时回答它们

  • 云原生支持，使用 Prometheus 形式抓取数据

各日志收集组件简单对比

名称安装的组件优点
ELK/EFKelasticsearch、logstash、kibana、filebeat、kafka/redis支持自定义 grok 正则解析复杂日志内容；dashboard 支持丰富的可视化展示
Lokigrafana、loki、promtail占用资源小；grafana 原生支持；查询速度快 ;

Loki 工作方式解惑

日志解析格式

0897b6b4a1c8aa4a8822f33ef4d3be3b.jpeg

从上面的图中我们可以看到，它在解析日志的时候是以 index 为主的，index 包括时间戳和 pod 的部分 label（其他 label 为 filename、containers 等），其余的是日志内容。具体查询效果如下：

a2171a23a1bc8b505b6d9c25bdfec5e1.jpeg 756f24ee3580d2ae6cc137210458d1d7.jpeg

{app="loki",namespace="kube-public"} 为索引。

日志搜集架构模式

aef1e5b81a227bafb4bc33951b6372e0.jpeg在使用过程中，官方推荐使用 promtail 做为 agent 以 DaemonSet 方式部署在 kubernetes 的 worker 节点上搜集日志。另外也可以用上面提到的其他日志收集工具来收取，这篇文章在结尾处会附上其他工具的配置方式。

Loki 部署模式都有哪些呢

Loki 由许多组件微服务构建而成，微服务组件有 5 个。在这 5 个里面添加缓存用来把数据放起来加快查询。数据放在共享存储里面配置 memberlist_config 部分并在实例之间共享状态，将 Loki 进行无限横向扩展。在配置完 memberlist_config 部分后采用轮询的方式查找数据。为了使用方便官方把所有的微服务编译成一个二进制，可以通过命令行参数-target 控制，支持 all、read、write，我们在部署时根据日志量的大小可以指定不同模式。

all（读写模式）

服务启动后，我们做的数据查询、数据写入都是来自这一个节点。请看下面的这个图解：

8a877cf0369cc11ddc4a08c280db2da5.jpeg
read/write（读写分离模式）

在读写分离模式下运行时 fronted-query 查询会将流量转发到 read 节点上。读节点上保留了 querier、ruler、fronted，写节点上保留了 distributor、ingester。

b02f300de76b8ff84bbb7994b8d62d03.jpeg
微服务模式运行

微服务模式运行下，通过不同的配置参数启动为不同的角色，每一个进程都引用它的目标角色服务。

5467c1cd956acbfeb75ccf858f8cf1e0.jpeg
组件名称功能
分发器 / 调度器（distributor）验证数据合规；数据排序；hash 一致性；QPS 限制；转发；数据副本保证不丢失
收集器（ingester）时间戳排序；文件系统支持；WAL 预写；
查询前端（query-frontend）提供页面操作，向后端存储发出数据查询；查询队列（query-queueing）能够防止大数据量查询时触发 OOM；查询分割（query-split）可以分割大批量查询最后进行数据聚合
查询器 Querier使用 logql 语言在后端存储中查询日志
缓存将查询到的日志缓存起来共后续使用，如果数据不完整重新查询缺失的数据

大显身手之服务端部署

上面我们讲了那么多关于 loki 的介绍和它的工作模式，你也一定期待它是怎么部署的吧？！该怎么部署、部署在哪里、部署后怎么使用等等问题都会出现在你的脑海里。在部署之前你需要准备好一个 k8s 集群才行哦。那好，接下来耐着性子往下看……

应用镜像
lokigrafana/loki:2.5.0
promtailgrafana/promtail:2.5.0

AllInOne 部署模式

① k8s 部署

我们从 github 上下载的程序是没有配置文件的，需要提前将文件准备一份。这里提供了一份完整的 allInOne 配置文件，部分内容进行了优化。

配置文件内容如下所示
auth_enabled: false
target: all
ballast_bytes: 20480
server:
  grpc_listen_port: 9095
  http_listen_port: 3100
  graceful_shutdown_timeout: 20s
  grpc_listen_address: "0.0.0.0"
  grpc_listen_network: "tcp"
  grpc_server_max_concurrent_streams: 100
  grpc_server_max_recv_msg_size: 4194304
  grpc_server_max_send_msg_size: 4194304
  http_server_idle_timeout: 2m
  http_listen_address: "0.0.0.0"
  http_listen_network: "tcp"
  http_server_read_timeout: 30s
  http_server_write_timeout: 20s
  log_source_ips_enabled: true
  ## http_path_prefix如果需要更改，在推送日志的时候前缀都需要加指定的内容
  ## http_path_prefix: "/"
  register_instrumentation: true
  log_format: json
  log_level: info
distributor:
  ring:
    heartbeat_timeout: 3s
    kvstore:
      prefix: collectors/
      store: memberlist
      ## 需要提前创建好consul集群
    ##   consul:
    ##     http_client_timeout: 20s
    ##     consistent_reads: true
    ##     host: 127.0.0.1:8500
    ##     watch_burst_size: 2
    ##     watch_rate_limit: 2
querier:
  engine:
    max_look_back_period: 20s 
    timeout: 3m0s 
  extra_query_delay: 100ms 
  max_concurrent: 10 
  multi_tenant_queries_enabled: true
  query_ingester_only: false
  query_ingesters_within: 3h0m0s
  query_store_only: false
  query_timeout: 5m0s
  tail_max_duration: 1h0s
query_scheduler:
  max_outstanding_requests_per_tenant: 2048
  grpc_client_config:
    max_recv_msg_size: 104857600
    max_send_msg_size: 16777216
    grpc_compression: gzip
    rate_limit: 0
    rate_limit_burst: 0
    backoff_on_ratelimits: false
    backoff_config:
      min_period: 50ms
      max_period: 15s
      max_retries: 5 
  use_scheduler_ring: true
  scheduler_ring:
    kvstore:
      store: memberlist
      prefix: "collectors/"
    heartbeat_period: 30s
    heartbeat_timeout: 1m0s
    ## 默认第一个网卡的名称
    ## instance_interface_names
    ## instance_addr: 127.0.0.1
    ## 默认server.grpc-listen-port
    instance_port: 9095
frontend:
  max_outstanding_per_tenant: 4096
  querier_forget_delay: 1h0s
  compress_responses: true
  log_queries_longer_than: 2m0s
  max_body_size: 104857600
  query_stats_enabled: true
  scheduler_dns_lookup_period: 10s 
  scheduler_worker_concurrency: 15
query_range:
  align_queries_with_step: true
  cache_results: true
  parallelise_shardable_queries: true
  max_retries: 3
  results_cache:
    cache:
      enable_fifocache: false
      default_validity: 30s 
      background:
        writeback_buffer: 10000
      redis:
        endpoint: 127.0.0.1:6379
        timeout: 1s
        expiration: 0s 
        db: 9
        pool_size: 128 
        password: 1521Qyx6^
        tls_enabled: false
        tls_insecure_skip_verify: true
        idle_timeout: 10s 
        max_connection_age: 8h
ruler:
  enable_api: true
  enable_sharding: true
  alertmanager_refresh_interval: 1m
  disable_rule_group_label: false
  evaluation_interval: 1m0s
  flush_period: 3m0s
  for_grace_period: 20m0s
  for_outage_tolerance: 1h0s
  notification_queue_capacity: 10000
  notification_timeout: 4s
  poll_interval: 10m0s
  query_stats_enabled: true
  remote_write:
    config_refresh_period: 10s
    enabled: false
  resend_delay: 2m0s
  rule_path: /rulers
  search_pending_for: 5m0s
  storage:
    local:
      directory: /data/loki/rulers
    type: configdb
  sharding_strategy: default
  wal_cleaner:
    period:  240h
    min_age: 12h0m0s
  wal:
    dir: /data/loki/ruler_wal
    max_age: 4h0m0s
    min_age: 5m0s
    truncate_frequency: 1h0m0s
  ring:
    kvstore:
      store: memberlist
      prefix: "collectors/"
    heartbeat_period: 5s
    heartbeat_timeout: 1m0s
    ## instance_addr: "127.0.0.1"
    ## instance_id: "miyamoto.en0"
    ## instance_interface_names: ["en0","lo0"]
    instance_port: 9500
    num_tokens: 100
ingester_client:
  pool_config:
    health_check_ingesters: false
    client_cleanup_period: 10s 
    remote_timeout: 3s
  remote_timeout: 5s 
ingester:
  autoforget_unhealthy: true
  chunk_encoding: gzip
  chunk_target_size: 1572864
  max_transfer_retries: 0
  sync_min_utilization: 3.5
  sync_period: 20s
  flush_check_period: 30s 
  flush_op_timeout: 10m0s
  chunk_retain_period: 1m30s
  chunk_block_size: 262144
  chunk_idle_period: 1h0s
  max_returned_stream_errors: 20
  concurrent_flushes: 3
  index_shards: 32
  max_chunk_age: 2h0m0s
  query_store_max_look_back_period: 3h30m30s
  wal:
    enabled: true
    dir: /data/loki/wal 
    flush_on_shutdown: true
    checkpoint_duration: 15m
    replay_memory_ceiling: 2GB
  lifecycler:
    ring:
      kvstore:
        store: memberlist
        prefix: "collectors/"
      heartbeat_timeout: 30s 
      replication_factor: 1
    num_tokens: 128
    heartbeat_period: 5s 
    join_after: 5s 
    observe_period: 1m0s
    ## interface_names: ["en0","lo0"]
    final_sleep: 10s 
    min_ready_duration: 15s
storage_config:
  boltdb:
    directory: /data/loki/boltdb 
  boltdb_shipper:
    active_index_directory: /data/loki/active_index
    build_per_tenant_index: true
    cache_location: /data/loki/cache 
    cache_ttl: 48h
    resync_interval: 5m
    query_ready_num_days: 5
    index_gateway_client:
      grpc_client_config:
  filesystem:
    directory: /data/loki/chunks
chunk_store_config:
  chunk_cache_config:
    enable_fifocache: true
    default_validity: 30s
    background:
      writeback_buffer: 10000
    redis:
      endpoint: 192.168.3.56:6379
      timeout: 1s
      expiration: 0s 
      db: 8 
      pool_size: 128 
      password: 1521Qyx6^
      tls_enabled: false
      tls_insecure_skip_verify: true
      idle_timeout: 10s 
      max_connection_age: 8h
    fifocache:
      ttl: 1h
      validity: 30m0s
      max_size_items: 2000
      max_size_bytes: 500MB
  write_dedupe_cache_config:
    enable_fifocache: true
    default_validity: 30s 
    background:
      writeback_buffer: 10000
    redis:
      endpoint: 127.0.0.1:6379
      timeout: 1s
      expiration: 0s 
      db: 7
      pool_size: 128 
      password: 1521Qyx6^
      tls_enabled: false
      tls_insecure_skip_verify: true
      idle_timeout: 10s 
      max_connection_age: 8h
    fifocache:
      ttl: 1h
      validity: 30m0s
      max_size_items: 2000
      max_size_bytes: 500MB
  cache_lookups_older_than: 10s 
## 压缩碎片索引
compactor:
  shared_store: filesystem
  shared_store_key_prefix: index/
  working_directory: /data/loki/compactor
  compaction_interval: 10m0s
  retention_enabled: true
  retention_delete_delay: 2h0m0s
  retention_delete_worker_count: 150
  delete_request_cancel_period: 24h0m0s
  max_compaction_parallelism: 2
  ## compactor_ring:
frontend_worker:
  match_max_concurrent: true
  parallelism: 10
  dns_lookup_duration: 5s 
## runtime_config 这里没有配置任何信息
## runtime_config:
common:
  storage:
    filesystem:
      chunks_directory: /data/loki/chunks
      fules_directory: /data/loki/rulers
  replication_factor: 3
  persist_tokens: false
  ## instance_interface_names: ["en0","eth0","ens33"]
analytics:
  reporting_enabled: false
limits_config:
  ingestion_rate_strategy: global
  ingestion_rate_mb: 100
  ingestion_burst_size_mb: 18
  max_label_name_length: 2096
  max_label_value_length: 2048
  max_label_names_per_series: 60
  enforce_metric_name: true
  max_entries_limit_per_query: 5000
  reject_old_samples: true
  reject_old_samples_max_age: 168h
  creation_grace_period: 20m0s
  max_global_streams_per_user: 5000
  unordered_writes: true
  max_chunks_per_query: 200000
  max_query_length: 721h
  max_query_parallelism: 64 
  max_query_series: 700
  cardinality_limit: 100000
  max_streams_matchers_per_query: 1000 
  max_concurrent_tail_requests: 10 
  ruler_evaluation_delay_duration: 3s 
  ruler_max_rules_per_rule_group: 0
  ruler_max_rule_groups_per_tenant: 0
  retention_period: 700h
  per_tenant_override_period: 20s 
  max_cache_freshness_per_query: 2m0s
  max_queriers_per_tenant: 0
  per_stream_rate_limit: 6MB
  per_stream_rate_limit_burst: 50MB
  max_query_lookback: 0
  ruler_remote_write_disabled: false
  min_sharding_lookback: 0s
  split_queries_by_interval: 10m0s
  max_line_size: 30mb
  max_line_size_truncate: false
  max_streams_per_user: 0

## memberlist_conig模块配置gossip用于在分发服务器、摄取器和查询器之间发现和连接。
## 所有三个组件的配置都是唯一的，以确保单个共享环。
## 至少定义了1个join_members配置后，将自动为分发服务器、摄取器和ring 配置memberlist类型的kvstore
memberlist:
  randomize_node_name: true
  stream_timeout: 5s 
  retransmit_factor: 4
  join_members:
  - 'loki-memberlist'
  abort_if_cluster_join_fails: true
  advertise_addr: 0.0.0.0
  advertise_port: 7946
  bind_addr: ["0.0.0.0"]
  bind_port: 7946
  compression_enabled: true
  dead_node_reclaim_time: 30s
  gossip_interval: 100ms
  gossip_nodes: 3
  gossip_to_dead_nodes_time: 3
  ## join:
  leave_timeout: 15s
  left_ingesters_timeout: 3m0s 
  max_join_backoff: 1m0s
  max_join_retries: 5
  message_history_buffer_bytes: 4096
  min_join_backoff: 2s
  ## node_name: miyamoto
  packet_dial_timeout: 5s
  packet_write_timeout: 5s 
  pull_push_interval: 100ms
  rejoin_interval: 10s
  tls_enabled: false
  tls_insecure_skip_verify: true
schema_config:
  configs:
  - from: "2020-10-24"
    index:
      period: 24h
      prefix: index_
    object_store: filesystem
    schema: v11
    store: boltdb-shipper
    chunks:
      period: 168h
    row_shards: 32
table_manager:
  retention_deletes_enabled: false
  retention_period: 0s
  throughput_updates_disabled: false
  poll_interval: 3m0s
  creation_grace_period: 20m
  index_tables_provisioning:
    provisioned_write_throughput: 1000
    provisioned_read_throughput: 500
    inactive_write_throughput: 4
    inactive_read_throughput: 300
    inactive_write_scale_lastn: 50 
    enable_inactive_throughput_on_demand_mode: true
    enable_ondemand_throughput_mode: true
    inactive_read_scale_lastn: 10 
    write_scale:
      enabled: true
      target: 80
      ## role_arn:
      out_cooldown: 1800
      min_capacity: 3000
      max_capacity: 6000
      in_cooldown: 1800
    inactive_write_scale:
      enabled: true
      target: 80
      out_cooldown: 1800
      min_capacity: 3000
      max_capacity: 6000
      in_cooldown: 1800
    read_scale:
      enabled: true
      target: 80
      out_cooldown: 1800
      min_capacity: 3000
      max_capacity: 6000
      in_cooldown: 1800
    inactive_read_scale:
      enabled: true
      target: 80
      out_cooldown: 1800
      min_capacity: 3000
      max_capacity: 6000
      in_cooldown: 1800
  chunk_tables_provisioning:
    enable_inactive_throughput_on_demand_mode: true
    enable_ondemand_throughput_mode: true
    provisioned_write_throughput: 1000
    provisioned_read_throughput: 300
    inactive_write_throughput: 1
    inactive_write_scale_lastn: 50
    inactive_read_throughput: 300
    inactive_read_scale_lastn: 10
    write_scale:
      enabled: true
      target: 80
      out_cooldown: 1800
      min_capacity: 3000
      max_capacity: 6000
      in_cooldown: 1800
    inactive_write_scale:
      enabled: true
      target: 80
      out_cooldown: 1800
      min_capacity: 3000
      max_capacity: 6000
      in_cooldown: 1800
    read_scale:
      enabled: true
      target: 80
      out_cooldown: 1800
      min_capacity: 3000
      max_capacity: 6000
      in_cooldown: 1800
    inactive_read_scale:
      enabled: true
      target: 80
      out_cooldown: 1800
      min_capacity: 3000
      max_capacity: 6000
      in_cooldown: 1800
tracing:
  enabled: true
复制代码

注意 :

  • ingester.lifecycler.ring.replication_factor 的值在单实例的情况下为 1

  • ingester.lifecycler.min_ready_duration 的值为 15s，在启动后默认会显示 15 秒将状态变为 ready

3268b375f5f10c0e6c77638f7ae934f9.jpeg

  • memberlist.node_name 的值可以不用设置，默认是当前主机的名称

  • memberlist.join_members 是一个列表，在有多个实例的情况下需要添加各个节点的主机名 /IP 地址。在 k8s 里面可以设置成一个 service 绑定到 StatefulSets。

  • query_range.results_cache.cache.enable_fifocache 建议设置为 false，我这里设置成了 true

  • instance_interface_names 是一个列表，默认的为["en0","eth0"]，可以根据需要设置对应的网卡名称，一般不需要进行特殊设置。

创建 configmap

说明：将上面的内容写入到一个文件——>loki-all.yaml，把它作为一个 configmap 写入 k8s 集群。可以使用如下命令创建：

$ kubectl create configmap --from-file ./loki-all.yaml loki-all

可以通过命令查看到已经创建好的 configmap，具体操作详见下图49be3f6ec118c0d143e5d1eaeb8ce3ed.jpeg

创建持久化存储

在 k8s 里面我们的数据是需要进行持久化的。Loki 收集起来的日志信息对于业务来说是至关重要的，因此需要在容器重启的时候日志能够保留下来。那么就需要用到 pv、pvc，后端存储可以使用 nfs、glusterfs、hostPath、azureDisk、cephfs 等 20 种支持类型，这里因为没有对应的环境就采用了 hostPath 方式。

apiVersion: v1
kind: PersistentVolume
metadata:
  name: loki
  namespace: default
spec:
  hostPath:
    path: /glusterfs/loki
    type: DirectoryOrCreate
  capacity:
    storage: 1Gi
  accessModes:
    - ReadWriteMany
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: loki
  namespace: default
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 1Gi
  volumeName: loki
创建应用

准备好 k8s 的 StatefulSet 部署文件后就可以直接在集群里面创建应用了。

apiVersion: apps/v1
kind: StatefulSet
metadata:
  labels:
    app: loki
  name: loki
  namespace: default
spec:
  podManagementPolicy: OrderedReady
  replicas: 1
  selector:
    matchLabels:
      app: loki
  template:
    metadata:
      annotations:
        prometheus.io/port: http-metrics
        prometheus.io/scrape: "true"
      labels:
        app: loki
    spec:
      containers:
      - args:
        - -config.file=/etc/loki/loki-all.yaml
        image: grafana/loki:2.5.0
        imagePullPolicy: IfNotPresent
        livenessProbe:
          failureThreshold: 3
          httpGet:
            path: /ready
            port: http-metrics
            scheme: HTTP
          initialDelaySeconds: 45
          periodSeconds: 10
          successThreshold: 1
          timeoutSeconds: 1
        name: loki
        ports:
        - containerPort: 3100
          name: http-metrics
          protocol: TCP
        - containerPort: 9095
          name: grpc
          protocol: TCP
        - containerPort: 7946
          name: memberlist-port
          protocol: TCP
        readinessProbe:
          failureThreshold: 3
          httpGet:
            path: /ready
            port: http-metrics
            scheme: HTTP
          initialDelaySeconds: 45
          periodSeconds: 10
          successThreshold: 1
          timeoutSeconds: 1
        resources:
          requests:
            cpu: 500m
            memory: 500Mi
          limits:
            cpu: 500m
            memory: 500Mi
        securityContext:
          readOnlyRootFilesystem: true
        volumeMounts:
        - mountPath: /etc/loki
          name: config
        - mountPath: /data
          name: storage
      restartPolicy: Always
      securityContext:
        fsGroup: 10001
        runAsGroup: 10001
        runAsNonRoot: true
        runAsUser: 10001
      serviceAccount: loki
      serviceAccountName: loki
      volumes:
      - emptyDir: {}
        name: tmp
      - name: config
        configMap:
          name: loki
      - persistentVolumeClaim:
          claimName: loki
        name: storage
---
kind: Service
apiVersion: v1
metadata:
  name: loki-memberlist
  namespace: default
spec:
  ports:
    - name: loki-memberlist
      protocol: TCP
      port: 7946
      targetPort: 7946
  selector:
    kubepi.org/name: loki
---
kind: Service
apiVersion: v1
metadata:
  name: loki
  namespace: default
spec:
  ports:
    - name: loki
      protocol: TCP
      port: 3100
      targetPort: 3100
  selector:
    kubepi.org/name: loki

在上面的配置文件中我添加了一些 pod 级别的安全策略，这些安全策略还有集群级别的 PodSecurityPolicy，防止因为漏洞的原因造成集群的整个崩溃，关于集群级别的 psp，可以详见官方文档[1]。

验证部署结果

43b8ada828d8466448d58d1cb4ae847e.jpeg当看到上面的 Running 状态时可以通过 API 的方式看一下分发器是不是正常工作，当显示 Active 时正常才会正常分发日志流到收集器（ingester)。

3e43c1707055fa9147ba15a3bc14400d.jpeg
② 裸机部署

将 loki 放到系统的 /bin/ 目录下，准备 grafana-loki.service 控制文件重载系统服务列表

[Unit]
Description=Grafana Loki Log Ingester
Documentation=https://grafana.com/logs/
After=network-online.target

[Service]
ExecStart=/bin/loki --config.file /etc/loki/loki-all.yaml
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/bin/kill -s TERM $MAINPID

[Install]
WantedBy=multi-user.target

重载系统列表命令，可以直接系统自动管理服务：

$ systemctl daemon-reload
## 启动服务
$ systemctl start grafana-loki
## 停止服务
$ systemctl stop grafana-loki
## 重载应用
$ systemctl reload grafana-loki

大显身手之 Promtail 部署

部署客户端收集日志时也需要创建一个配置文件，按照上面创建服务端的步骤创建。不同的是需要把日志内容 push 到服务端

① k8s 部署

创建配置文件
server:
  log_level: info
  http_listen_port: 3101
clients:
  - url: http://loki:3100/loki/api/v1/push
positions:
  filename: /run/promtail/positions.yaml
scrape_configs:
  - job_name: kubernetes-pods
    pipeline_stages:
      - cri: {}
    kubernetes_sd_configs:
      - role: pod
    relabel_configs:
      - source_labels:
          - __meta_kubernetes_pod_controller_name
        regex: ([0-9a-z-.]+?)(-[0-9a-f]{8,10})?
        action: replace
        target_label: __tmp_controller_name
      - source_labels:
          - __meta_kubernetes_pod_label_app_kubernetes_io_name
          - __meta_kubernetes_pod_label_app
          - __tmp_controller_name
          - __meta_kubernetes_pod_name
        regex: ^;*([^;]+)(;.*)?$
        action: replace
        target_label: app
      - source_labels:
          - __meta_kubernetes_pod_label_app_kubernetes_io_instance
          - __meta_kubernetes_pod_label_release
        regex: ^;*([^;]+)(;.*)?$
        action: replace
        target_label: instance
      - source_labels:
          - __meta_kubernetes_pod_label_app_kubernetes_io_component
          - __meta_kubernetes_pod_label_component
        regex: ^;*([^;]+)(;.*)?$
        action: replace
        target_label: component
      - action: replace
        source_labels:
        - __meta_kubernetes_pod_node_name
        target_label: node_name
      - action: replace
        source_labels:
        - __meta_kubernetes_namespace
        target_label: namespace
      - action: replace
        replacement: $1
        separator: /
        source_labels:
        - namespace
        - app
        target_label: job
      - action: replace
        source_labels:
        - __meta_kubernetes_pod_name
        target_label: pod
      - action: replace
        source_labels:
        - __meta_kubernetes_pod_container_name
        target_label: container
      - action: replace
        replacement: /var/log/pods/*$1/*.log
        separator: /
        source_labels:
        - __meta_kubernetes_pod_uid
        - __meta_kubernetes_pod_container_name
        target_label: __path__
      - action: replace
        regex: true/(.*)
        replacement: /var/log/pods/*$1/*.log
        separator: /
        source_labels:
        - __meta_kubernetes_pod_annotationpresent_kubernetes_io_config_hash
        - __meta_kubernetes_pod_annotation_kubernetes_io_config_hash
        - __meta_kubernetes_pod_container_name
        target_label: __path__

用上面的内容创建一个 configMap，方法同上

创建 DaemonSet 文件

Promtail 是一个无状态应用不需要进行持久化存储只需要部署到集群里面就可以了，还是同样的准备 DaemonSets 创建文件。

kind: DaemonSet
apiVersion: apps/v1
metadata:
  name: promtail
  namespace: default
  labels:
    app.kubernetes.io/instance: promtail
    app.kubernetes.io/name: promtail
    app.kubernetes.io/version: 2.5.0
spec:
  selector:
    matchLabels:
      app.kubernetes.io/instance: promtail
      app.kubernetes.io/name: promtail
  template:
    metadata:
      labels:
        app.kubernetes.io/instance: promtail
        app.kubernetes.io/name: promtail
    spec:
      volumes:
        - name: config
          configMap:
            name: promtail
        - name: run
          hostPath:
            path: /run/promtail
        - name: containers
          hostPath:
            path: /var/lib/docker/containers
        - name: pods
          hostPath:
            path: /var/log/pods
      containers:
        - name: promtail
          image: docker.io/grafana/promtail:2.3.0
          args:
            - '-config.file=/etc/promtail/promtail.yaml'
          ports:
            - name: http-metrics
              containerPort: 3101
              protocol: TCP
          env:
            - name: HOSTNAME
              valueFrom:
                fieldRef:
                  apiVersion: v1
                  fieldPath: spec.nodeName
          volumeMounts:
            - name: config
              mountPath: /etc/promtail
            - name: run
              mountPath: /run/promtail
            - name: containers
              readOnly: true
              mountPath: /var/lib/docker/containers
            - name: pods
              readOnly: true
              mountPath: /var/log/pods
          readinessProbe:
            httpGet:
              path: /ready
              port: http-metrics
              scheme: HTTP
            initialDelaySeconds: 10
            timeoutSeconds: 1
            periodSeconds: 10
            successThreshold: 1
            failureThreshold: 5
          imagePullPolicy: IfNotPresent
          securityContext:
            capabilities:
              drop:
                - ALL
            readOnlyRootFilesystem: false
            allowPrivilegeEscalation: false
      restartPolicy: Always
      serviceAccountName: promtail
      serviceAccount: promtail
      tolerations:
        - key: node-role.kubernetes.io/master
          operator: Exists
          effect: NoSchedule
        - key: node-role.kubernetes.io/control-plane
          operator: Exists
          effect: NoSchedule
创建 promtail 应用
$ kubectl apply -f promtail.yaml

使用上面这个命令创建后就可以看到服务已经创建好了。接下来就是在 Grafana 里面添加 DataSource 查看数据了。42e40c6c8af7b1601cdab82eef4464b2.jpeg

② 裸机部署

如果是裸机部署的情况下，需要对上面的配置文件做一下稍微的改动，更改 clients 得地址就可以，文件存放到 /etc/loki/ 下，例如改成：

clients:
  - url: http://ipaddress:port/loki/api/v1/push

添加系统开机启动配置，service 配置文件存放位置 /usr/lib/systemd/system/loki-promtail.service 内容如下

[Unit]
Description=Grafana Loki Log Ingester
Documentation=https://grafana.com/logs/
After=network-online.target

[Service]
ExecStart=/bin/promtail --config.file /etc/loki/loki-promtail.yaml
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/bin/kill -s TERM $MAINPID

[Install]
WantedBy=multi-user.target

启动方式同上面服务端部署内容

Loki in DataSource

添加数据源

具体步骤 : Grafana->Setting->DataSources->AddDataSource->Loki

注意点： http 的 URL 地址，应用、服务部署在哪个 namespace 下，就需要指定它的 FQDN 地址，它的格式是 ServiceName.namespace。如果默认在 default 下、创建的端口号是 3100，就需要填写为 http://loki:3100，这里为什么不写 IP 地址而写成服务的名字，是因为在 k8s 集群里面有个 dns 服务器会自动解析这个地址。90fe2a2ebd892c19acf884c179f9d590.jpeg

查找日志信息

54ab0446c5df9da6d34d1a87a480d717.jpeg
页面展示 .png

其他客户端配置

Logstash 作为日志收集客户端

安装插件

在启动 Logstash 后我们需要安装一个插件，可以通过这个命令安装 loki 的输出插件，安装完成之后可以在 logstash 的 output 中添加信息。

$ bin/logstash-plugin install logstash-output-loki
添加配置进行测试

完整的 logstash 配置信息，可以参考官网给出的内容LogstashConfigFile[2]

output {
  loki {
    [url => "" | default = none | required=true]
    [tenant_id => string | default = nil | required=false]
    [message_field => string | default = "message" | required=false]
    [include_fields => array | default = [] | required=false]
    [batch_wait => number | default = 1(s) | required=false]
    [batch_size => number | default = 102400(bytes) | required=false]
    [min_delay => number | default = 1(s) | required=false]
    [max_delay => number | default = 300(s) | required=false]
    [retries => number | default = 10 | required=false]
    [username => string | default = nil | required=false]
    [password => secret | default = nil | required=false]
    [cert => path | default = nil | required=false]
    [key => path | default = nil| required=false]
    [ca_cert => path | default = nil | required=false]
    [insecure_skip_verify => boolean | default = false | required=false]
  }
}

或者采用 logstash 的 http 输出模块，配置如下：

output {
    http {
        format => "json"
        http_method => "post"
        content_type => "application/json"
        connect_timeout => 10
        url => "http://loki:3100/loki/api/v1/push"
        message => '"message":"%{message}"}'
    }
}

Helm 安装

如果你想简便安装的话，可以采用 helm 来安装。helm 将所有的安装步骤都进行了封装，简化了安装步骤。对于想详细了解 k8s 的人来说，helm 不太适合。因为它封装后自动执行，k8s 管理员不知道各组件之间是如何依赖的，可能会造成误区。 废话不多说，下面开始 helm 安装

添加 repo 源

$ helm repo add grafana https://grafana.github.io/helm-charts

更新源

$ helm repo update

部署

默认配置
$ helm upgrade --install loki grafana/loki-simple-scalable
自定义 namespace
$ helm upgrade --install loki --namespace=loki grafana/loki-simple-scalable
自定义配置信息
$ helm upgrade --install loki grafana/loki-simple-scalable --set "key1=val1,key2=val2,..."

故障解决方案

502 BadGateWay

  • loki 的地址填写不正确

    • http://LokiServiceName

    • http://LokiServiceName.namespace

    • http://LokiServiceName.namespace:ServicePort

    • 在 k8s 里面，地址填写错误造成了 502。检查一下 loki 的地址是否是以下内容：

    • grafana 和 loki 在不同的节点上，检查一下节点间网络通信状态、防火墙策略

Ingester not ready: instance xx:9095 in state JOINING

  • 耐心等待一会，因为是 allInOne 模式程序启动需要一定的时间。

too many unhealthy instances in the ring

  • 将 ingester.lifecycler.replication_factor 改为 1，是因为这个设置不正确造成的。这个在启动的时候会设置为多个复制源，但当前只部署了一个所以在查看 label 的时候提示这个。

Data source connected, but no labels received. Verify that Loki and Promtail is configured properly

  • promtail 无法将收集到的日志发送给 loki，许可检查一下 promtail 的输出是不是正常；

  • promtail 在 loki 还没有准备就绪的时候把日志发送过来了，但 loki 没有接收到。如果需要重新接收日志，需要删除 positions.yaml 文件，具体路径可以用 find 查找一下位置；

  • promtail 忽略了目标日志文件或者配置文件错误造成的无法正常启动；

  • promtail 无法在指定的位置发现日志文件 配置文件参考 1[3]。

引用链接

[1]

官方文档: https://link.juejin.cn?target=https%3A%2F%2Fkubernetes.io%2Fdocs%2Fconcepts%2Fsecurity%2Fpod-security-policy%2F

[2]

LogstashConfigFile: https://link.juejin.cn?target=https%3A%2F%2Fwww.elastic.co%2Fguide%2Fen%2Flogstash%2Fcurrent%2Fconfiguration-file-structure.html

[3]

配置文件参考 1: https://link.juejin.cn?target=https%3A%2F%2Fgrafana.com%2Fdocs%2Floki%2Flatest%2Fconfiguration%2F%23server

本文转载自：「掘金」，原文：https://url.hi-linux.com/Pzl4W，版权归原作者所有。欢迎投稿，投稿邮箱: editor@hi-linux.com。

d052554a6425fd76ab82e7bd980819e2.gif

最近，我们建立了一个技术交流微信群。目前群里已加入了不少行业内的大神，有兴趣的同学可以加入和我们一起交流技术，在 「奇妙的 Linux 世界」 公众号直接回复 「加群」 邀请你入群。

617f9d814a199c4275149a8a13fadb74.png

你可能还喜欢

点击下方图片即可阅读

a6dcae146cb5db1f040a4cf26bac36f8.png

如何使用 Headscale ( Tailscale 开源版 ) 快速搭建一个私有专属的 P2P 内网穿透网络

cca37abe56ccda46377dce88667464fc.png
点击上方图片，『美团|饿了么』外卖红包天天免费领

5d8d407c5bbbda01a20de70a83500164.png

更多有趣的互联网新鲜事，关注「奇妙的互联网」视频号全了解！

运维之美
关注
Loki 分布式日志中心服务
又逢乱世
09-13 1197
分布式日志中心 Loki + Promtail + Grafana
一文读懂轻量日志收集系统Loki工作原理
weixin_43749805的博客
07-05 474
Loki 是由 Grafana Labs 开发的日志聚合系统，设计目标是提供一种高效、低成本的日志收集和查询解决方案。与传统的日志系统（如 ELK Stack）不同，Loki 不会对日志内容进行索引，而是仅对日志的元数据进行索引，这使得 Loki 更加节省存储空间和计算资源。与 Prometheus 兼容：Loki 的设计理念与 Prometheus类似，用户可以使用相似的查询语言（LogQL）来查询日志数据。高效的存储：通过避免对日志内容进行索引，Loki能够显著减少存储和处理日志数据所需的资源。
性能优越的轻量级日志收集工具，微软、亚马逊都在用
代码界的扛把子
04-26 1221
ELK日志收集系统大家都知道，但是还有一种日志收集系统EFK，肯定有很多朋友不知道！这里的F指的是Fluentd，它具有Logstash类似的日志收集功能，但是内存占用连Logstash的十分之一都不到，性能优越、非常轻巧。本文将详细介绍Fluentd的使用，主要用来收集SpringBoot应用的日志，希望对大家有所帮助！ Fluentd 简介 Fluentd是一款开源的日志收集功能，致力于为用户搭建统一的日志收集层，和Elasticsearch、Kibana一起使用可以搭建EFK日志收集系统。什么是统
轻量级云原生日志收集方案 Loki
云原生实验室
10-27 1327
❝本文转自掘金，原文：https://juejin.cn/post/7150469420605767717，版权归原作者所有。欢迎投稿，投稿请添加微信好友：cloud-native-yangHi，很高兴能够在掘金开发者的平台上为大家带来一套轻量级的 kubernetes 日志收集方案的相关介绍。我自己也在生产环境中使用过这套方案，令我意想不到的时它占用的 kubernetes 的资源相比与 ELK...
Loki 日志收集系统
yaohong
05-27 2656
一.系统架构 二.组成部分 Loki 的日志堆栈由 3 个组件组成： promtail：用于采集日志、并给每条日志流打标签，每个节点部署，k8s部署模式下使用daemonset管理。 loki：用于存储采集的日志， 并根据标签查询日志流。单节点部署，一般和监控组件部署在同一节点。 Grafana：提供界面，实现日志的可视化查询。安装监控组件会默认部署grafana，与监控组件共用gra...
轻量级日志系统——Loki
wzpny的博客
06-21 4182
Loki是团队最新的开源项目，是一个水平可扩展，高可用性，多租户的日志聚合系统。它的设计非常经济高效且易于操作，因为它不会为日志内容编制索引，而是为每个日志流编制一组标签。项目受 Prometheus启发，官方的介绍就是：，类似于Prometheus的日志系统。
Java—Loki日志收集
ClancyLv的博客
04-30 1120
Loki 是一个受 Prometheus 启发的水平可扩展、高度可用的多租户日志聚合系统。它的设计非常具有成本效益且易于操作。它不索引日志的内容，而是为每个日志流编制一组标签。。
loki安装包，轻量级的日志收集系统
03-10
loki是轻量级的日志收集系统，部署简单轻量，支持LogQL，配合grafana做展示，支持丰富的日志分析查询功能。
轻量级日志监控平台LOKI
06-16
Loki是受Prometheus启发由Grafana Labs团队开源的水平可扩展，高度可用的多租户日志聚合系统。 开发语言: Google Go。它的设计具有很高的成本效益，并且易于操作。使用标签来作为索引，而不是对全文进行检索，也就是...
Loki 轻量级日志可视化
12-19
Loki，作为一款轻量级的日志聚合系统，由Prometheus团队开发，旨在为现代微服务架构提供高效且经济的解决方案。本文将深入探讨Loki的核心特性、工作原理以及如何与其他组件如Grafana和Promtail集成，以实现强大的...
再见笨重的ELK！这套轻量级日志收集方案要火！
weixin_57907028的博客
07-21 791
摘要 之前一直使用的日志收集方案是ELK，动辄占用几个G的内存，有些配置不好的服务器有点顶不住！最近发现一套轻量级日志收集方案： Loki+Promtail+Grafana（简称LPG）， 几百M内存就够了，而且界面也挺不错的，推荐给大家！ 简介 LPG日志收集方案内存占用很少，经济且高效！它不像ELK日志系统那样为日志建立索引，而是为每个日志流设置一组标签。下面分别介绍下它的核心组件： Promtail：日志收集器，有点像Filebeat，可以收集日志文件中的日志，并把收集到的数据推送到Loki中
springboot+Loki+Loki4j+Grafana搭建轻量级日志系统
最新发布
08-06
springboot+Loki+Loki4j+Grafana搭建轻量级日志系统
Loki —— 分布式系统轻量级日志收集器
Genius only means hard-working all one's life.
06-21 506
promtail安装（作为日志上报组件运行在应用节点上，每个需要收集日志的节点都要配置）grafana配置loki。
轻量级日志收集系统 Grafana+Loki+Promtail
manongwangziqi的博客
04-10 775
编写日志流选择器后，您可以通过编写搜索表达式进一步过滤结果。搜索表达式可以文本或正则表达式。~ line 与正则表达式不匹配。|~ line 匹配正则表达式。= line 不包含字符串。|= line 包含字符串。~：不要正则表达式匹配。\=~：正则表达式匹配。
MiaomiaoYM：一个轻量级、高效且易用的日志收集系统
gitblog_00022的博客
04-05 301
MiaomiaoYM：一个轻量级、高效且易用的日志收集系统 去发现同类优质开源项目:https://gitcode.com/ 项目简介 是一个开源的日志收集系统，它专注于提供简单、快速和可扩展的日志管理和分析能力。此项目由Python编写，利用Flask框架构建后端服务，前端使用Vue.js进行开发，让用户在Web界面上就能方便地查看、搜索与分析日志数据。 技术分析 架构设计 MiaomiaoYM...
grafana Loki 轻量级日志收集系统
热门推荐
weixin_44316575的博客
12-02 1万+
Loki 日志系统 Loki 概述 Grafana Loki Loki的第一个稳定版本于2019年11月19日发布 是 Grafana Labs 团队最新的开源项目 是一个水平可扩展，高可用性，多租户的日志聚合系统 Loki 特性 不对日志进行全文索引（vs ELK技） 通过存储压缩非结构化日志和仅索引元数据，Loki 操作起来会更简单，更省成本 通过使用与 Prometheus 相同的标签记录流对日志进行索引和分组，使得日志的扩展和操作效率更高 特别适合储存 Kubernetes Pod 日志; 诸
告别沉重的ELK，这套轻量级的日志系统值得你拥有
码农code之路
07-09 394
来源：源话编程（gh_289d0f98fdae）在软件开发中，日志系统扮演着至关重要的角色。它不仅帮助开发者调试程序，还能在生产环境中监控应用状态。本文将讲解如何使用 Loki、Loki4j、Grafana 和 Spring Boot 搭建一个轻量级、简单、易用的 Java 日志系统。系统组件概览什么是 Loki？Loki 是由 Grafana Labs 开源的一款高可用、高扩展性、多租户的日志聚...
Loki轻量级日志系统
Kammingo的博客
04-07 819
Promtail是代理，负责收集日志并将其发送给Loki。 Loki是主服务器，负责存储日志和处理查询。 Grafana用于查询和显示日志。 步骤一、下载启动Loki # wget https://github.com/grafana/loki/releases/download/v2.0.0/loki-linux-amd64.zip # unzip loki-linux-amd64.zip # mkdir -p /usr/local/loki # mv loki-linux-amd64 /usr/loca
K8s部署轻量级日志收集系统EFK（elasticsearch + filebeat + kibana）
ζั͡山 ั͡有扶苏 ั͡✾的博客
10-11 2806
Pod 的选择基于标签。这个pod一次运行了两个容器，分别是kibanah和elasticsearch，并且把elasticsearch容器中的/usr/share/elasticsearch/data目录下的内容，挂载到了es-pv-claim下，我们可以在第三步中的NFS服务器共享目录中找到挂载的数据。点击侧边栏，选择discover，就能看到Filebeat收集到的容器日志，可以按照自己的需求进行日志筛选。的 Pod，这些 Pod 的端口 9200 和 9300 将被公开，并且可以通过相应的。
Loki日志系统：轻量级可视化解决方案
资源摘要信息:"Loki轻量级日志可视化是一个专注于提供快速、可扩展、多租户的日志聚合的系统，适用于处理高可用性和大规模的日志数据。Loki能够高效地处理大量数据，且资源消耗相对较低，非常适合于那些需要处理大量...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值