20、Docker容器监控全攻略

最新推荐文章于 2025-10-15 03:42:54 发布

echo99

最新推荐文章于 2025-10-15 03:42:54 发布

阅读量38

点赞数

CC 4.0 BY-SA版权

分类专栏： Docker与Kubernetes实战指南文章标签： Docker监控容器监控 Docker日志收集

本文链接：https://blog.youkuaiyun.com/echo99/article/details/150052337

Docker与Kubernetes实战指南专栏收录该内容

20 篇文章 ¥499.90

订阅专栏¥69.90

会员秒杀 ¥9.9 重磅福利

超级会员免费看

Docker容器监控全攻略

1. 容器详细信息获取

在Docker的使用过程中，有时我们需要获取容器的详细信息，比如容器的创建时间、传递给容器的命令、端口映射情况以及容器的IP地址等。这时可以使用 docker inspect 命令。

以下是具体操作步骤：
1. 启动一个nginx容器：

$ docker run -d -p 80:80 nginx

使用 docker inspect 命令查看容器信息：

$ docker inspect kickass_babbage

输出结果示例：

[{
    "AppArmorProfile": "",
    "Args": [
        "-g",
        "daemon off;"
    ],
    "ExposedPorts": {
        "443/tcp": {},
        "80/tcp": {}
    },
    "NetworkSettings": {
        "IPAddress": "172.17.0.3"
    }
}]

docker inspect 命令还可以用于查看镜像信息：

$ docker inspect nginx

输出结果示例：

[{
    "Architecture": "amd64",
    "Author": "NGINX Docker Maintainers \"docker-maint@nginx.com\"",
    "Comment": "",
    "Config": {
        "AttachStderr": false,
        "AttachStdin": false,
        "AttachStdout": false,
        "Cmd": [
            "nginx",
            "-g",
            "daemon off;"
        ]
    }
}]

此外， docker inspect 命令有一个 --format 选项，可用于指定Go模板，从而提取容器或镜像的特定信息，而不是获取完整的JSON输出。例如，获取运行中容器的IP地址并检查其状态：

$ docker inspect -f '' kickass_babbage
172.17.0.3
$ docker inspect -f '' kickass_babbage
true

如果更喜欢使用其他Docker客户端，如 Docker-py ，也可以使用标准的Python字典表示法来访问容器和镜像的详细信息：

$ python
>>> from docker import Client
>>> c = Client(base_url="unix://var/run/docker.sock")
>>> c.inspect_container('kickass_babbage')['State']['Running']
True
>>> c.inspect_container('kickass_babbage')['NetworkSettings']['IPAddress']
u'172.17.0.3'

2. 运行中容器的使用统计获取

当我们有一个运行在Docker主机上的容器，并且想要监控其资源使用情况（如内存、CPU、网络）时，可以使用 docker stats 命令。该命令是在2015年2月10日引入的新API端点，在Docker 1.5及以上版本中可用。

操作步骤如下：
1. 启动一个Flask应用程序容器：

$ docker run -d -p 5000:5000 runseb/flask

使用 docker stats 命令查看容器的使用统计信息：

$ docker stats dreamy_mccarthy

输出示例：

CONTAINER           CPU %               MEM USAGE/LIMIT       MEM %               NET I/O
dreamy_mccarthy     0.03%               24.01 MiB/1.955 GiB   1.20%               648 B/648 B

由于 docker stats 命令返回的是一个数据流，需要使用 Ctrl - C 来终止数据流。

为了将这些统计信息用于进一步的可视化和分析，我们可以使用 curl 通过TCP请求访问Docker守护进程的stats API。具体步骤如下：
1. 配置本地Docker守护进程监听TCP端口2375。在Ubuntu系统上，编辑 /etc/default/docker 文件，添加以下内容：

DOCKER_OPTS="-H tcp://127.0.0.1:2375"

重启Docker守护进程：

$ sudo service docker restart

使用 curl 访问Docker远程API：

$ docker -H tcp://127.0.0.1:2375 run -d -p 5001:5000 runseb/flask
$ curl http://127.0.0.1:2375/containers/agitated_albattani/stats

如果喜欢使用Python，也可以使用 docker-py 来获取这些统计信息。示例Python脚本如下：

#!/usr/bin/env python
import json
import docker
import sys
cli = docker.Client(base_url='tcp://127.0.0.1:2375')
stats = cli.stats(sys.argv[1])
print json.dumps(json.loads(next(stats).rstrip('\n')), indent=4)

3. 监听Docker主机上的事件

如果想要监控Docker主机上的事件，如镜像的取消标签和删除以及容器的生命周期事件（如创建、销毁、杀死），可以使用 docker events 命令。

操作步骤如下：

$ docker events --help

输出：

Usage: docker events [OPTIONS]
Get real time events from the server
  -f, --filter=[]    Provide filter values (i.e., 'event=stop')
  --help=false       Print usage
  --since=""         Show all events created since timestamp
  --until=""         Stream events until this timestamp

可以使用 --since 或 --until 选项来选择特定时间范围内的事件。例如：

$ docker events --since 1427890602

输出示例：

2015-04-01T12:17:04....9393146cb55e5bc9f04e20eb5a0622b3e26aae7: untag
2015-04-01T12:17:09....d5266f8777bfba4974ac56e3270e7760f6f0a81: untag
2015-04-01T12:17:22....d5266f8777bfba4974ac56e3270e7760f6f0a85: untag
2015-04-01T12:17:23....66f8777bfba4974ac56e3270e7760f6f0a81253: delete
2015-04-01T12:17:23....e9b5a793523481a0a18645fc77ad53c4eadsfa2: delete
2015-04-01T12:17:23....878585defcc1bc6f79d2728a13957871b345345: delete

也可以使用 docker-py 来获取事件列表。示例Python脚本如下：

#!/usr/bin/env python
import json
import docker
import sys
cli = docker.Client(base_url='unix://var/run/docker.sock')
events = cli.events(since=sys.argv[1], until=sys.argv[2])
for e in events:
    print e

4. 获取容器的日志

当有一个运行中的容器，并且想要从主机访问容器内进程的日志时，可以使用 docker logs 命令。

操作步骤如下：
1. 启动一个nginx容器：

$ docker run -d -p 80:80 nginx

查看容器列表：

$ docker ps

输出示例：

CONTAINER ID    IMAGE           ...  PORTS                         NAMES
dd0e926c4015    nginx:latest    ...  443/tcp, 0.0.0.0:80->80/tcp   gloomy_mclean

使用 docker logs 命令查看容器日志：

$ docker logs gloomy_mclean

输出示例：

192.168.34.1 - - [10/Mar/2015:10:12:35 +0000] "GET / HTTP/1.1" 200 612 "-" ...

如果想要获取连续的日志流，可以使用 -f 选项：

$ docker logs -f gloomy_mclean

此外，还可以使用 docker top 命令监控容器内运行的进程：

$ docker top gloomy_mclean

输出示例：

UID         PID         PPID     ...    CMD
root        5605        4732     ...    nginx: master process nginx -g daemon off;
syslog      5632        5605     ...    nginx: worker process

5. 使用Logspout收集容器日志

虽然可以使用 docker logs 命令获取单个容器的日志，但如果想要收集运行在多个Docker主机上的容器的日志并进行聚合，可以使用Logspout。

操作步骤如下：
1. 在一个Docker主机上安装Logspout以收集nginx容器的日志。首先拉取所需的镜像：

$ docker pull nginx
$ docker pull gliderlabs/logspout

启动nginx容器：

$ docker run -d --name webserver -p 80:80 nginx

启动Logspout容器，挂载Docker Unix套接字，并指定syslog端点：

$ docker run -d --name logspout -v /var/run/docker.sock:/tmp/docker.sock \
             gliderlabs/logspout syslog://192.168.34.11:5000

在 192.168.34.11 主机上使用Logstash容器收集日志。首先拉取Logstash镜像：

$ docker pull ehazlett/logstash

创建Logstash配置文件 logstash.conf ：

input {
  tcp {
    port => 5000
    type => syslog
  }
}
filter {
  if [type] == "syslog" {
    grok {
      match => { "message" => "%{SYSLOGTIMESTAMP:syslog_timestamp} \
      %{SYSLOGHOST:syslog_hostname} %{DATA:syslog_program}(?:\[%{POSINT:syslog_pid}\])?: \
      %{GREEDYDATA:syslog_message}" }
      add_field => [ "received_at", "%{@timestamp}" ]
      add_field => [ "received_from", "%{host}" ]
    }
    syslog_pri { }
    date {
      match => [ "syslog_timestamp", "MMM  d HH:mm:ss", "MMM dd HH:mm:ss" ]
    }
  }
}
output {
  stdout { codec => rubydebug }
}

创建Dockerfile：

FROM ehazlett/logstash
COPY logstash.conf /etc/logstash.conf
ENTRYPOINT ["/opt/logstash/bin/logstash"]

构建Logstash镜像：

$ docker build -t logstash .

启动Logstash容器：

$ docker run -d --name logstash -p 5000:5000/udp log -f /etc/logstash.conf

当打开浏览器访问第一个Docker主机上的Nginx服务器时，日志将出现在Logstash容器中：

$ docker logs logstash

为了简化测试，可以克隆相关仓库并使用Vagrant启动两个Docker主机：

$ git clone https://github.com/how2dock/docbook.git
$ vagrant up
$ vagrant status

在Web服务器节点上运行nginx和Logspout容器：

$ vagrant ssh w
$ docker run --name nginx -d -p 80:80 nginx
$ docker run -d --name logspout -v /var/run/docker.sock:/tmp/docker.sock \
             gliderlabs/logspout syslog://192.168.34.11:5000

在elk节点上运行Logstash容器：

$ vagrant ssh elk
$ cd /vagrant
$ docker build -t logstash .
$ docker run -d --name logstash -p 5000:5000/udp log -f /etc/logstash.conf

6. 管理Logspout路由以存储容器日志

如果使用Logspout将日志流式传输到远程服务器，但想要修改端点，可以通过Logspout暴露的端口8000上的HTTP API来管理路由。

操作步骤如下：
1. 拉取包含curl的镜像并启动一个交互式容器：

$ docker pull tutum/curl
$ docker run -ti --link logspout:logspout tutum/curl /bin/bash

验证是否可以ping通Logspout容器：

root@c94a4eacb7cc:/# ping logspout

使用curl访问Logspout API：

root@c94a4eacb7cc:/# curl http://logspout:8000/logs

输出示例：

logspout|[martini] Started GET /logs for 172.17.0.12:38353
nginx|192.168.34.1 - - [10/Mar/2015:13:57:38 +0000] "GET / HTTP/1.1" 200  ...
nginx|192.168.34.1 - - [10/Mar/2015:13:57:43 +0000] "GET / HTTP/1.1" 200  ...

管理日志流的API暴露了 /routes 路由，可以使用标准的HTTP动词 GET 、 DELETE 和 POST 来列出、删除和更新流端点。例如：

root@1fbb2f9636a8:/# curl http://logspout:8000/routes

输出示例：

[
  {
    "id": "e508de0c9689",
    "target": {
      "type": "syslog",
      "addr": "192.168.34.11:5000"
    }
  }
]

root@1fbb2f9636a8:/# curl http://logspout:8000/routes/e508de0c9689

输出示例：

{
  "id": "e508de0c9689",
  "target": {
    "type": "syslog",
    "addr": "192.168.34.11:5000"
  }
}

root@1fbb2f9636a8:/# curl -X DELETE http://logspout:8000/routes/e508de0c9689
root@1fbb2f9636a8:/# curl http://logspout:8000/routes

输出示例：

[]

root@1fbb2f9636a8:/# curl -X POST \
                          -d '{"target": {"type": "syslog", \
                                          "addr": "192.168.34.11:5000"}}' \
                          http://logspout:8000/routes

输出示例：

{
  "id": "f60d30502654",
  "target": {
    "type": "syslog",
    "addr": "192.168.34.11:5000"
  }
}

root@1fbb2f9636a8:/# curl http://logspout:8000/routes

输出示例：

[
  {
    "id": "f60d30502654",
    "target": {
      "type": "syslog",
      "addr": "192.168.34.11:5000"
    }
  }
]

还可以创建一个路由到Papertrail，它可以自动备份到Amazon S3。

7. 使用Elasticsearch和Kibana存储和可视化容器日志

之前我们只使用Logstash接收日志并将其发送到stdout，现在可以进一步使用Elasticsearch来存储容器日志，并使用Kibana进行可视化和查询。

操作步骤如下：
1. 启动Elasticsearch和Kibana容器：

$ docker run --name es -d -p 9200:9200 -p 9300:9300 ehazlett/elasticsearch
$ docker run --name kibana -d -p 80:80 ehazlett/kibana

启动Logstash容器，并将其链接到Elasticsearch容器：

$ docker run -d --name logstash -p 5000:5000/udp \
             --link es:elasticsearch ehazlett/logstash \
             -f /etc/logstash.conf.sample

打开浏览器，访问运行Kibana容器的Docker主机的端口80，将看到Kibana默认仪表盘。选择“1. Sample Dashboard”，将从索引中提取一些信息并构建一个基本仪表盘，应该可以看到访问Nginx服务器获得的日志。

需要注意的是，在上述解决方案中，Elasticsearch运行在单个容器中，如果杀死并删除该容器，Logspout流式传输的日志所创建的索引将不会持久化。建议挂载一个卷并进行备份，以持久化Elasticsearch数据。此外，如果需要更多的存储空间和高效的索引，应该在多个Docker主机上创建Elasticsearch集群。

8. 使用Collectd可视化容器指标

除了可视化应用程序日志，还可以使用Collectd来监控容器的指标，如CPU。

操作步骤如下：
使用两个Docker主机进行测试，一个主机（worker）运行四个容器：nginx容器用于生成虚拟日志到stdout，logspout容器将所有stdout日志路由到Logstash实例，一个生成合成负载的容器（如 borja/unixbench ）和一个collectd容器。另一个主机（monitor）运行四个容器：Logstash容器收集来自logspout的日志，Elasticsearch容器存储日志，Kibana容器可视化这些日志，以及Graphite容器。

在worker主机上，使用Docker Compose启动所有容器，YAML文件如下：

nginx:
  image: nginx
  ports:
   - 80:80
logspout:
  image: gliderlabs/logspout
  volumes:
   - /var/run/docker.sock:/tmp/docker.sock
  command: syslog://192.168.33.11:5000
collectd:
  build: .
  volumes:
   - /var/run/docker.sock:/var/run/docker.sock
load:
  image: borja/unixbench

collectd容器基于以下Dockerfile构建：

FROM debian:jessie
RUN apt-get update && apt-get -y install \
    collectd \
    python \
    python-pip
RUN apt-get clean
RUN pip install docker-py
RUN groupadd -r docker && useradd -r -g docker docker
ADD docker-stats.py /opt/collectd/bin/docker-stats.py
ADD docker-report.py /opt/collectd/bin/docker-report.py
ADD collectd.conf /etc/collectd/collectd.conf
RUN chown -R docker /opt/collectd/bin
CMD ["/usr/sbin/collectd","-f"]

在monitor主机上，使用Docker Compose启动所有容器，YAML文件如下：

es:
  image: ehazlett/elasticsearch
  ports:
   - 9300:9300
   - 9200:9200
kibana:
  image: ehazlett/kibana
  ports:
   - 8080:80
graphite:
  image: hopsoft/graphite-statsd
  ports:
   - 80:80
   - 2003:2003
   - 8125:8125/udp
logstash:
  image: ehazlett/logstash
  ports:
   - 5000:5000
   - 5000:5000/udp
  volumes:
   - /root/docbook/ch09/collectd/logstash.conf:/etc/logstash.conf
  links:
   - es:elasticsearch
  command: -f /etc/logstash.conf

当所有容器在两个主机上启动，并且网络和防火墙配置正确后，就可以访问worker主机端口80上的nginx容器、monitor主机端口8080上的Kibana仪表盘以及monitor主机端口80上的Graphite仪表盘。Graphite仪表盘将显示来自worker主机上所有容器的基本CPU指标。

以下是一个简单的mermaid流程图，展示了使用Collectd监控容器指标的流程：

graph LR
    A[Worker主机] --> B(nginx容器)
    A --> C(logspout容器)
    A --> D(collectd容器)
    A --> E(负载容器)
    B --> C
    C --> F[Monitor主机]
    F --> G(Logstash容器)
    F --> H(Elasticsearch容器)
    F --> I(Kibana容器)
    F --> J(Graphite容器)
    D --> J
    G --> H
    H --> I

综上所述，通过以上各种方法，可以全面地对Docker容器进行监控，包括获取容器详细信息、监控资源使用情况、监听事件、收集和管理日志以及可视化容器指标等。这些方法可以帮助我们更好地管理和维护Docker容器化的应用程序。

Docker容器监控全攻略

9. 各监控方法总结与对比

为了更清晰地了解不同监控方法的特点和适用场景，下面对前面介绍的各种监控方法进行总结和对比。

监控方法	功能	操作步骤	适用场景
`docker inspect`	获取容器或镜像的详细信息，如创建时间、命令、端口映射、IP地址等	1. 启动容器；2. 使用 `docker inspect` 命令查看信息；3. 可使用 `--format` 选项提取特定信息；4. 也可用 `Docker - py` 获取信息	需要详细了解容器或镜像配置时
`docker stats`	监控运行中容器的资源使用情况，如内存、CPU、网络	1. 启动容器；2. 使用 `docker stats` 命令查看统计信息；3. 可通过 `curl` 或 `docker - py` 访问API获取信息	实时监控容器资源使用，进行性能调试时
`docker events`	监控Docker主机上的事件，如镜像操作和容器生命周期事件	1. 使用 `docker events` 命令获取事件流；2. 可使用 `--since` 和 `--until` 选项选择特定时间范围；3. 可用 `docker - py` 获取事件列表	关注Docker系统的各种事件，进行系统审计时
`docker logs`	获取容器内进程的日志	1. 启动容器；2. 使用 `docker logs` 命令查看日志；3. 可使用 `- f` 选项获取连续日志流；4. 可用 `docker top` 监控容器内进程	排查容器内应用程序问题，查看日志时
Logspout	收集多个Docker主机上的容器日志并聚合	1. 拉取相关镜像；2. 启动nginx和Logspout容器；3. 配置Logstash并启动容器；4. 可使用Vagrant简化测试	管理分布式环境下的容器日志时
Logspout路由管理	修改Logspout的日志流端点	1. 拉取包含curl的镜像并启动交互式容器；2. 验证与Logspout容器的连接；3. 使用curl访问Logspout API；4. 使用HTTP动词管理路由	需要调整日志存储位置或添加新的存储端点时
Elasticsearch和Kibana	存储和可视化容器日志	1. 启动Elasticsearch和Kibana容器；2. 启动Logstash容器并链接到Elasticsearch；3. 访问Kibana仪表盘查看日志	对容器日志进行深入分析和可视化展示时
Collectd	可视化容器指标，如CPU	1. 使用两个Docker主机；2. 在worker主机上使用Docker Compose启动相关容器；3. 在monitor主机上使用Docker Compose启动相关容器；4. 访问相关仪表盘查看指标	监控容器的性能指标，进行容量规划时

10. 监控方案的选择与组合

在实际应用中，需要根据具体的需求和场景选择合适的监控方案，有时可能需要组合使用多种方法。

基础监控 ：对于简单的开发和测试环境， docker inspect 和 docker stats 可以满足基本的监控需求。通过 docker inspect 可以了解容器的配置信息， docker stats 可以实时监控容器的资源使用情况。
事件监控 ：在生产环境中，需要关注Docker系统的各种事件，如容器的创建、销毁和镜像的操作。此时可以使用 docker events 来监听这些事件，及时发现异常情况。
日志管理 ：对于分布式环境下的多个容器，使用Logspout收集和聚合日志，再结合Elasticsearch和Kibana进行存储和可视化是一个不错的选择。这样可以方便地对日志进行分析和查询，快速定位问题。
性能监控 ：如果需要监控容器的性能指标，如CPU、内存等，可以使用Collectd。它可以将指标发送到Graphite仪表盘，直观地展示容器的性能状况。

以下是一个mermaid流程图，展示了根据不同需求选择监控方案的过程：

graph LR
    A[监控需求] --> B{简单监控}
    B -- 是 --> C[docker inspect和docker stats]
    B -- 否 --> D{事件监控}
    D -- 是 --> E[docker events]
    D -- 否 --> F{日志管理}
    F -- 是 --> G[Logspout + Elasticsearch + Kibana]
    F -- 否 --> H{性能监控}
    H -- 是 --> I[Collectd + Graphite]
    H -- 否 --> J[根据具体情况选择]

11. 监控的注意事项与最佳实践

在进行Docker容器监控时，还需要注意以下事项和遵循一些最佳实践。

资源占用 ：监控工具本身也会占用一定的系统资源，尤其是在大规模的容器环境中。因此，需要合理选择监控工具和配置监控频率，避免对系统性能产生过大影响。
数据持久化 ：对于重要的监控数据，如日志和指标，需要进行持久化存储。例如，使用Elasticsearch存储日志时，要考虑挂载卷和备份数据，以防止数据丢失。
安全性 ：在配置监控工具时，要注意安全性。例如，在使用 curl 访问Docker远程API时，要确保网络安全，避免数据泄露。
自动化 ：可以使用脚本或自动化工具来定期执行监控任务，如定期收集日志、生成报表等。这样可以提高监控效率，减少人工操作。