# 二进制安装
NODE_EXPORTER_VERSION="1.7.0"
wget https://github.com/prometheus/node_exporter/releases/download/v${NODE_EXPORTER_VERSION}/node_exporter-${NODE_EXPORTER_VERSION}.linux-amd64.tar.gz
tar xvfz node_exporter-${NODE_EXPORTER_VERSION}.linux-amd64.tar.gz
sudo cp node_exporter-${NODE_EXPORTER_VERSION}.linux-amd64/node_exporter /usr/local/bin/

# Docker
docker run -d \
  --name=node-exporter \
  --net=host \
  --pid=host \
  -v "/:/host:ro,rslave" \
  prom/node-exporter:v1.7.0 \
  --path.rootfs=/host

# /etc/systemd/system/node_exporter.service
[Unit]
Description=Node Exporter
After=network.target

[Service]
Type=simple
User=prometheus
ExecStart=/usr/local/bin/node_exporter \
  --collector.systemd \
  --collector.processes \
  --web.listen-address=:9100
Restart=always

[Install]
WantedBy=multi-user.target

# 启用特定 collector
node_exporter \
  --collector.systemd \
  --collector.processes \
  --no-collector.wifi \
  --no-collector.infiniband

# 安装
MYSQL_EXPORTER_VERSION="0.15.1"
wget https://github.com/prometheus/mysqld_exporter/releases/download/v${MYSQL_EXPORTER_VERSION}/mysqld_exporter-${MYSQL_EXPORTER_VERSION}.linux-amd64.tar.gz
tar xvfz mysqld_exporter-${MYSQL_EXPORTER_VERSION}.linux-amd64.tar.gz
sudo cp mysqld_exporter-${MYSQL_EXPORTER_VERSION}.linux-amd64/mysqld_exporter /usr/local/bin/

-- 创建监控专用用户
CREATE USER 'exporter'@'localhost' IDENTIFIED BY 'password';

-- 授予权限
GRANT PROCESS, REPLICATION CLIENT, SELECT ON *.* TO 'exporter'@'localhost';

FLUSH PRIVILEGES;

# /etc/.mysqld_exporter.cnf
[client]
user=exporter
password=password
host=localhost
port=3306

mysqld_exporter \
  --config.my-cnf=/etc/.mysqld_exporter.cnf \
  --collect.info_schema.processlist \
  --collect.info_schema.innodb_metrics \
  --collect.global_status \
  --collect.global_variables \
  --collect.slave_status \
  --collect.engine_innodb_status

# 安装
REDIS_EXPORTER_VERSION="1.58.0"
wget https://github.com/oliver006/redis_exporter/releases/download/v${REDIS_EXPORTER_VERSION}/redis_exporter-v${REDIS_EXPORTER_VERSION}.linux-amd64.tar.gz
tar xvfz redis_exporter-v${REDIS_EXPORTER_VERSION}.linux-amd64.tar.gz
sudo cp redis_exporter /usr/local/bin/

# 启动
redis_exporter \
  --redis.addr=redis://localhost:6379 \
  --redis.password=password \
  --web.listen-address=:9121

# Docker
docker run -d \
  --name=redis-exporter \
  -p 9121:9121 \
  oliver006/redis_exporter:v1.58.0 \
  --redis.addr=redis://redis:6379

# 缓存命中率
redis_keyspace_hits_total / (redis_keyspace_hits_total + redis_keyspace_misses_total)

# 内存使用率
redis_used_memory_bytes / redis_memory_max_bytes

# 每秒命令处理数
rate(redis_commands_processed_total[5m])

# /etc/blackbox_exporter/config.yml
modules:
  http_2xx:
    prober: http
    timeout: 5s
    http:
      valid_http_versions: ["HTTP/1.1", "HTTP/2.0"]
      valid_status_codes: [200, 301, 302]
      method: GET
      follow_redirects: true
      preferred_ip_protocol: "ip4"
      tls_config:
        insecure_skip_verify: false

  http_post_2xx:
    prober: http
    http:
      method: POST
      valid_status_codes: [200, 201]

  tcp_connect:
    prober: tcp
    timeout: 5s

  icmp:
    prober: icmp
    timeout: 5s

  dns_resolve:
    prober: dns
    dns:
      query_name: "example.com"
      query_type: "A"
      valid_rcodes: ["NOERROR"]

blackbox_exporter \
  --config.file=/etc/blackbox_exporter/config.yml \
  --web.listen-address=:9115

scrape_configs:
  # HTTP 探测
  - job_name: 'blackbox-http'
    metrics_path: /probe
    params:
      module: [http_2xx]
    static_configs:
      - targets:
          - https://example.com
          - https://api.example.com/health
    relabel_configs:
      - source_labels: [__address__]
        target_label: __param_target
      - source_labels: [__param_target]
        target_label: instance
      - target_label: __address__
        replacement: blackbox:9115

  # ICMP 探测
  - job_name: 'blackbox-icmp'
    metrics_path: /probe
    params:
      module: [icmp]
    static_configs:
      - targets:
          - 10.0.0.1
          - 10.0.0.2
    relabel_configs:
      - source_labels: [__address__]
        target_label: __param_target
      - source_labels: [__param_target]
        target_label: instance
      - target_label: __address__
        replacement: blackbox:9115

  # TCP 探测
  - job_name: 'blackbox-tcp'
    metrics_path: /probe
    params:
      module: [tcp_connect]
    static_configs:
      - targets:
          - mysql:3306
          - redis:6379
    relabel_configs:
      - source_labels: [__address__]
        target_label: __param_target
      - source_labels: [__param_target]
        target_label: instance
      - target_label: __address__
        replacement: blackbox:9115

package main

import (
    "net/http"
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promhttp"
)

var (
    // 定义指标
    ordersTotal = prometheus.NewCounterVec(
        prometheus.CounterOpts{
            Namespace: "business",
            Subsystem: "orders",
            Name:      "created_total",
            Help:      "Total number of orders created",
        },
        []string{"channel", "status"},
    )

    orderAmount = prometheus.NewHistogramVec(
        prometheus.HistogramOpts{
            Namespace: "business",
            Subsystem: "orders",
            Name:      "amount_cents",
            Help:      "Order amount in cents",
            Buckets:   []float64{100, 500, 1000, 5000, 10000, 50000, 100000},
        },
        []string{"channel"},
    )

    queueLength = prometheus.NewGaugeVec(
        prometheus.GaugeOpts{
            Namespace: "business",
            Subsystem: "orders",
            Name:      "queue_length",
            Help:      "Current order processing queue length",
        },
        []string{"queue"},
    )
)

func init() {
    prometheus.MustRegister(ordersTotal, orderAmount, queueLength)
}

func main() {
    http.Handle("/metrics", promhttp.Handler())
    http.ListenAndServe(":9200", nil)
}

from prometheus_client import start_http_server, Counter, Gauge, Histogram
import time
import psutil

# 定义指标
CPU_TEMP = Gauge('hardware_cpu_temperature_celsius', 'CPU temperature')
DISK_IO = Counter('hardware_disk_reads_total', 'Total disk reads', ['device'])
REQUEST_LATENCY = Histogram(
    'custom_request_duration_seconds',
    'Request latency',
    buckets=[0.01, 0.05, 0.1, 0.5, 1, 5]
)

def collect_metrics():
    """定期采集指标"""
    while True:
        # CPU 温度
        temps = psutil.sensors_temperatures()
        if 'coretemp' in temps:
            CPU_TEMP.set(temps['coretemp'][0].current)
        
        # 磁盘 IO
        io = psutil.disk_io_counters()
        DISK_IO.labels(device='sda')._value.set(io.read_count)
        
        time.sleep(15)

if __name__ == '__main__':
    start_http_server(9200)
    collect_metrics()