# 查看所有容器资源使用
docker stats

# 查看指定容器
docker stats container_name

# 查看多个容器
docker stats container1 container2

# 单次输出（不持续刷新）
docker stats --no-stream

# 自定义格式
docker stats --format "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}"

# 简化输出
docker stats --format "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}"

# JSON格式
docker stats --format '{"name":"{{.Name}}","cpu":"{{.CPUPerc}}","mem":"{{.MemUsage}}"}'

# 只显示特定容器
docker stats --format "{{.Name}}: {{.CPUPerc}}" container1 container2

# 查看容器进程
docker top container_name

# 自定义ps选项
docker top container_name -o pid,user,%cpu,%mem,command

# 查看所有线程
docker top container_name -eLf

# 查看容器详细信息
docker inspect container_name

# 获取特定信息
docker inspect --format='{{.State.Pid}}' container_name
docker inspect --format='{{.HostConfig.Memory}}' container_name
docker inspect --format='{{.HostConfig.CpuShares}}' container_name

# 查看资源限制
docker inspect --format='{{json .HostConfig}}' container_name | jq

# 查看Docker磁盘使用
docker system df

# 输出示例
TYPE            TOTAL     ACTIVE    SIZE      RECLAIMABLE
Images          10        5         2.5GB     1.2GB (48%)
Containers      8         3         500MB     300MB (60%)
Local Volumes   15        10        1GB       500MB (50%)
Build Cache     0         0         0B        0B

# 详细信息
docker system df -v

# 实时监控Docker事件
docker events

# 过滤事件
docker events --filter type=container
docker events --filter event=start
docker events --filter container=nginx

# JSON格式
docker events --format '{{json .}}'

# 监控指定时间段
docker events --since 2026-05-10T14:00:00
docker events --until 2026-05-10T16:00:00

# 基本部署
docker run \
  --name=cadvisor \
  --volume=/:/rootfs:ro \
  --volume=/var/run:/var/run:ro \
  --volume=/sys:/sys:ro \
  --volume=/var/lib/docker/:/var/lib/docker:ro \
  --volume=/dev/disk/:/dev/disk:ro \
  --publish=8080:8080 \
  --detach=true \
  --privileged \
  --device=/dev/kmsg \
  gcr.io/cadvisor/cadvisor:latest

# 指定版本
docker run \
  --name=cadvisor \
  --volume=/:/rootfs:ro \
  --volume=/var/run:/var/run:ro \
  --volume=/sys:/sys:ro \
  --volume=/var/lib/docker/:/var/lib/docker:ro \
  --publish=8080:8080 \
  --detach=true \
  gcr.io/cadvisor/cadvisor:v0.47.0

# docker-compose.yml
version: '3.8'

services:
  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    container_name: cadvisor
    restart: unless-stopped
    ports:
      - "8080:8080"
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
      - /dev/disk/:/dev/disk:ro
    privileged: true
    devices:
      - /dev/kmsg:/dev/kmsg

# 启动
docker-compose up -d

# 查看状态
docker-compose ps

# 本地访问
http://localhost:8080

# 远程访问
http://server_ip:8080

# 获取所有容器
curl http://localhost:8080/api/v1.0/containers

# 获取指定容器
curl http://localhost:8080/api/v1.0/containers/<container_name>

# 获取Docker容器
curl http://localhost:8080/api/v1.0/docker/<container_id>

{
  "name": "/docker/nginx",
  "aliases": ["nginx", "a1b2c3d4e5f6"],
  "namespace": "docker",
  "spec": {
    "container_name": "nginx",
    "image": "nginx:latest"
  },
  "stats": [
    {
      "timestamp": "2026-05-10T14:32:15Z",
      "cpu": {
        "usage": {
          "total": 123456789,
          "per_cpu_usage": [12345678, 23456789, ...]
        }
      },
      "memory": {
        "usage": 67108864,
        "cache": 12345678,
        "rss": 54321098
      },
      "network": {
        "interfaces": [
          {
            "name": "eth0",
            "rx_bytes": 1234567,
            "tx_bytes": 2345678
          }
        ]
      }
    }
  ]
}

# 指定时间范围
curl "http://localhost:8080/api/v1.0/containers/nginx?start=2026-05-10T14:00:00Z&end=2026-05-10T15:00:00Z"

# 指定采样数
curl "http://localhost:8080/api/v1.0/containers/nginx?num_stats=60"

import requests
import json

class CadvisorClient:
    def __init__(self, host='localhost', port=8080):
        self.base_url = f"http://{host}:{port}/api/v1.0"
    
    def get_containers(self):
        """获取所有容器"""
        resp = requests.get(f"{self.base_url}/containers")
        return resp.json()
    
    def get_container_stats(self, container_name):
        """获取容器统计"""
        resp = requests.get(f"{self.base_url}/containers/{container_name}")
        data = resp.json()
        
        if data.get('stats'):
            latest = data['stats'][-1]
            return {
                'cpu_usage': latest['cpu']['usage']['total'],
                'memory_usage': latest['memory']['usage'],
                'network_rx': latest['network']['interfaces'][0]['rx_bytes'],
                'network_tx': latest['network']['interfaces'][0]['tx_bytes']
            }
        return None

# 使用示例
client = CadvisorClient()
containers = client.get_containers()
for name in containers:
    stats = client.get_container_stats(name)
    if stats:
        print(f"{name}: CPU={stats['cpu_usage']}, MEM={stats['memory_usage']}")

#!/bin/bash
# cadvisor_monitor.sh

CADVISOR_URL="http://localhost:8080"

# 获取容器列表
get_containers() {
    curl -s $CADVISOR_URL/api/v1.0/containers | jq -r 'keys[]'
}

# 获取容器CPU使用率
get_cpu_usage() {
    local container=$1
    curl -s $CADVISOR_URL/api/v1.0/containers/$container | \
        jq '.stats[-1].cpu.usage.total'
}

# 获取容器内存使用
get_memory_usage() {
    local container=$1
    curl -s $CADVISOR_URL/api/v1.0/containers/$container | \
        jq '.stats[-1].memory.usage'
}

# 监控所有容器
for container in $(get_containers); do
    cpu=$(get_cpu_usage $container)
    mem=$(get_memory_usage $container)
    echo "$container: CPU=$cpu, MEM=$mem"
done

# docker-compose-monitoring.yml
version: '3.8'

services:
  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    container_name: cadvisor
    restart: unless-stopped
    ports:
      - "8080:8080"
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
    privileged: true
    devices:
      - /dev/kmsg:/dev/kmsg

  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    restart: unless-stopped
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--storage.tsdb.retention.time=30d'

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    restart: unless-stopped
    ports:
      - "3000:3000"
    volumes:
      - grafana_data:/var/lib/grafana
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin

volumes:
  prometheus_data:
  grafana_data:

# prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'cadvisor'
    static_configs:
      - targets: ['cadvisor:8080']

# 启动所有服务
docker-compose -f docker-compose-monitoring.yml up -d

# 查看状态
docker-compose -f docker-compose-monitoring.yml ps

# 查看日志
docker-compose -f docker-compose-monitoring.yml logs -f

# 容器CPU使用率
rate(container_cpu_usage_seconds_total{image!=""}[5m]) * 100

# 按容器分组
sum(rate(container_cpu_usage_seconds_total{image!=""}[5m])) by (name) * 100

# 容器内存使用
container_memory_usage_bytes{image!=""}

# 内存使用率
container_memory_usage_bytes{image!=""} / container_spec_memory_limit_bytes{image!=""} * 100

# 接收速率
rate(container_network_receive_bytes_total{image!=""}[5m])

# 发送速率
rate(container_network_transmit_bytes_total{image!=""}[5m])

# 读取速率
rate(container_fs_reads_bytes_total{image!=""}[5m])

# 写入速率
rate(container_fs_writes_bytes_total{image!=""}[5m])

# 限制CPU使用率为50%
docker run --cpus=0.5 nginx

# 限制CPU份额（相对权重）
docker run --cpu-shares=512 nginx

# 绑定到特定CPU核心
docker run --cpuset-cpus="0,1" nginx

# 限制内存为512MB
docker run --memory=512m nginx

# 限制内存和Swap
docker run --memory=512m --memory-swap=1g nginx

# 内存软限制
docker run --memory=512m --memory-reservation=256m nginx

# 限制块IO
docker run --device-read-bps=/dev/sda:1mb nginx
docker run --device-write-bps=/dev/sda:1mb nginx

# 限制IOPS
docker run --device-read-iops=/dev/sda:1000 nginx
docker run --device-write-iops=/dev/sda:1000 nginx

# 查看容器资源限制
docker inspect --format='{{.HostConfig.Memory}}' container_name
docker inspect --format='{{.HostConfig.CpuShares}}' container_name

# 查看资源使用
docker stats container_name

# 动态调整CPU份额
docker update --cpu-shares=1024 container_name

# 动态调整内存限制
docker update --memory=1g container_name

# 批量更新
docker update --cpu-shares=512 container1 container2

# alerts.yml
groups:
  - name: container_alerts
    rules:
      - alert: ContainerHighCPU
        expr: rate(container_cpu_usage_seconds_total{image!=""}[5m]) * 100 > 80
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "容器CPU使用率过高"
          description: "容器 {{ $labels.name }} CPU使用率超过80%"

      - alert: ContainerHighMemory
        expr: container_memory_usage_bytes{image!=""} / container_spec_memory_limit_bytes{image!=""} * 100 > 80
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "容器内存使用率过高"
          description: "容器 {{ $labels.name }} 内存使用率超过80%"

      - alert: ContainerRestarting
        expr: increase(container_restart_count[1h]) > 3
        labels:
          severity: critical
        annotations:
          summary: "容器频繁重启"
          description: "容器 {{ $labels.name }} 在过去1小时内重启超过3次"

# 安装
kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

# 验证
kubectl get pods -n kube-system | grep metrics-server

# 查看节点资源使用
kubectl top nodes

# 查看Pod资源使用
kubectl top pods

# 查看指定命名空间
kubectl top pods -n kube-system

# 查看Pod中容器资源使用
kubectl top pods --containers

# 使用Helm安装
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update

helm install kube-prometheus-stack prometheus-community/kube-prometheus-stack \
  --namespace monitoring \
  --create-namespace

# Pod CPU使用率
sum(rate(container_cpu_usage_seconds_total{namespace="default"}[5m])) by (pod) * 100

# Pod内存使用
sum(container_memory_usage_bytes{namespace="default"}) by (pod)

# Pod重启次数
sum(kube_pod_container_status_restarts_total{namespace="default"}) by (pod)

# 节点CPU使用率
(1 - avg(rate(node_cpu_seconds_total{mode="idle"}[5m])) by (instance)) * 100

# 节点内存使用率
(1 - node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) * 100

# 节点磁盘使用率
(1 - node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"}) * 100

# 查看日志
docker logs container_name

# 实时跟踪
docker logs -f container_name

# 最近100行
docker logs --tail 100 container_name

# 指定时间范围
docker logs --since 2026-05-10T14:00:00 container_name
docker logs --until 2026-05-10T15:00:00 container_name

# 带时间戳
docker logs -t container_name

{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
  }
}

# docker-compose-elk.yml
version: '3.8'

services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.7.0
    container_name: elasticsearch
    environment:
      - discovery.type=single-node
      - xpack.security.enabled=false
    ports:
      - "9200:9200"
    volumes:
      - elasticsearch_data:/usr/share/elasticsearch/data

  logstash:
    image: docker.elastic.co/logstash/logstash:8.7.0
    container_name: logstash
    volumes:
      - ./logstash.conf:/usr/share/logstash/pipeline/logstash.conf
    depends_on:
      - elasticsearch

  kibana:
    image: docker.elastic.co/kibana/kibana:8.7.0
    container_name: kibana
    ports:
      - "5601:5601"
    environment:
      - ELASTICSEARCH_HOSTS=http://elasticsearch:9200
    depends_on:
      - elasticsearch

volumes:
  elasticsearch_data:

# 实时监控
docker stats

# 导出到文件
docker stats --no-stream > /tmp/docker_stats_$(date +%Y%m%d_%H%M%S).txt

# 使用cAdvisor
docker run -d --name cadvisor \
  -p 8080:8080 \
  -v /:/rootfs:ro \
  -v /var/run:/var/run:ro \
  -v /sys:/sys:ro \
  -v /var/lib/docker/:/var/lib/docker:ro \
  gcr.io/cadvisor/cadvisor:latest

# 1. 检查容器资源使用
docker stats container_name

# 2. 检查容器进程
docker top container_name

# 3. 检查容器日志
docker logs --tail 100 container_name

# 4. 进入容器排查
docker exec -it container_name bash

# 5. 检查资源限制
docker inspect --format='{{json .HostConfig}}' container_name | jq

# 1. 查看当前资源使用
docker stats --no-stream

# 2. 分析资源分配
docker inspect --format='{{.Name}}: CPU={{.HostConfig.CpuShares}}, MEM={{.HostConfig.Memory}}' $(docker ps -q)

# 3. 调整资源限制
docker update --cpu-shares=256 --memory=256m container_name

# 4. 监控调整效果
docker stats

# 1. 使用docker stats
docker stats --format "table {{.Name}}\t{{.NetIO}}"

# 2. 使用cAdvisor
curl http://localhost:8080/api/v1.0/containers/nginx | jq '.stats[-1].network'

# 3. 使用iftop（需要进入容器）
docker exec -it container_name iftop

# 1. 查看容器文件系统
docker exec -it container_name df -h

# 2. 查看容器层大小
docker system df

# 3. 查看卷使用
docker volume ls
docker system df -v

# 4. 清理未使用资源
docker system prune

# 每天收集资源使用
docker stats --no-stream > /tmp/stats_$(date +%Y%m%d).txt

# 分析趋势
# CPU平均使用率
# 内存峰值使用率
# 网络流量趋势

# 检查日志
docker logs cadvisor

# 检查挂载
ls -la /var/run/docker.sock

# 权限问题
docker run --privileged ...

# 检查cAdvisor是否运行
docker ps | grep cadvisor

# 检查Prometheus配置
cat prometheus.yml

# 手动测试
curl http://cadvisor:8080/metrics

# 检查cgroup版本
cat /proc/self/cgroup

# 检查Docker版本
docker version

# 更新cAdvisor
docker pull gcr.io/cadvisor/cadvisor:latest

# 基本监控
docker stats                    # 所有容器
docker stats container_name     # 指定容器
docker stats --no-stream        # 单次输出

# 进程监控
docker top container_name       # 容器进程

# 事件监控
docker events                   # 实时事件

# 资源使用
docker system df                # 磁盘使用

# 启动cAdvisor
docker run -d --name cadvisor \
  -p 8080:8080 \
  -v /:/rootfs:ro \
  -v /var/run:/var/run:ro \
  -v /sys:/sys:ro \
  -v /var/lib/docker/:/var/lib/docker:ro \
  gcr.io/cadvisor/cadvisor:latest

# API调用
curl http://localhost:8080/api/v1.0/containers
curl http://localhost:8080/api/v1.0/containers/nginx

# CPU限制
docker run --cpus=0.5 nginx
docker run --cpu-shares=512 nginx

# 内存限制
docker run --memory=512m nginx
docker run --memory=512m --memory-swap=1g nginx

# 动态调整
docker update --cpu-shares=1024 container_name
docker update --memory=1g container_name