Docker复习笔记

賑茗龙华

已于 2024-05-23 09:38:00 修改

阅读量719

点赞数 29

分类专栏： docker 文章标签： docker 笔记容器

于 2024-04-16 23:22:53 首次发布

本文链接：https://blog.csdn.net/SecartXiaoLong/article/details/137844651

版权

docker 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章目录

Docker

Docker

Docker的基本组成三要素：镜像 image、容器 container、仓库 repository

Docker的安装

卸载旧版本

旧版本的 Docker 采用docker或docker-engine。在尝试安装新版本之前卸载任何此类旧版本以及相关的依赖项。

1/	systemctl stop docker
2/	yum remove docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
3/	rm -rf /var/lib/docker
4/	rm -rf /var/lib/containerd
	
5/	sudo yum remove docker \
         docker-client \
         docker-client-latest \
         docker-common \
         docker-latest \
         docker-latest-logrotate \
         docker-logrotate \
         docker-engine

部署docker依赖

安装yum-utils软件包

sudo yum install -y yum-utils

本地索引缓存

$ yum makecache fast

安装Docker

sudo yum install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

[!NOTE]

docker-ce：Docker 引擎是 Docker 的核心组件，负责管理容器的生命周期、镜像的构建和管理等任务。

docker-ce-cli：Docker CLI 是用于与 Docker 守护进程通信的命令行工具，可以通过它来执行 Docker 相关的操作

containerd.io （容器运行时）是 Docker 引擎中的一个基础组件，负责管理容器的生命周期、容器与 Docker 引擎的交互等。

docker-buildx-plugin 是 Docker Buildx 插件，它是一个用于多平台构建和交叉编译的工具，可以让您在单个命令中构建多种架构的镜像。

docker-compose-plugin 是 Docker Compose 插件，它用于在单个配置文件中定义和管理多个 Docker 容器的运行。

安装旧版Docker

https://docs.docker.com/engine/install/

配置阿里云的docker-ce下载地址库
sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
展示所有版本的docker
yum list docker-ce --showduplicates | sort -r

sudo yum install docker-ce-24.0.6-1.el7 docker-ce-cli-24.0.6-1.el7 containerd.io docker-buildx-plugin docker-compose-plugin

启动docker

sudo systemctl start docker

查看是否安装成功

docker version

测试Docker运行

sudo docker run hello-world

设置存储库（阿里云）

sudo mkdir -p /etc/docker 
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://ndmnn1eo.mirror.aliyuncs.com"]
}
EOF
加载配置
sudo systemctl daemon-reload
重启docker
sudo systemctl restart docker

扩展：配置阿里云镜像加速

访问阿里云官网地址: www.aliyun.com，搜索容器镜像服务，管理控制台，镜像工具，找到镜像加速器并选择CentOS版本，找到加速器地址，到’设置存储库‘这一步，修改连接后重启

检测是否成功修改连接，查看倒数第二行数据连接

$ docker info

卸载Docker

1/	systemctl stop docker
2/	yum remove docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
3/	rm -rf /var/lib/docker
4/	rm -rf /var/lib/containerd
	
5/	sudo yum remove docker \
         docker-client \
         docker-client-latest \
         docker-common \
         docker-latest \
         docker-latest-logrotate \
         docker-logrotate \
         docker-engine

Docker命令

帮助启动类命令

启动docker

systemctl start docker

停止docker

systemctl stop docker

重启docker

systemctl restart docker

查看docker状态

systemctl status docker

开机启动

systemctl enable docker

查看docker概要信息

docker info

查看docker总体帮助文档

docker --help

查看docker命令帮助文档

docker 具体命令 --help
例如：docker cp --help

镜像命令

列出本地主机上的镜像

$ docker images
  
  OPTIONS说明：-a :列出本地所有的镜像（含历史映像层）
			-q :只显示镜像ID。

REPOSITORY   TAG   IMAGE ID   CREATED SIZE
REPOSITORY:表示镜像的仓库源
TAG:镜像的标签版本号
IMAGE ID:镜像ID
CREATED:镜像创建时间
SIZE:镜像大小

同一仓库源可以有多个TAG版本，代表这个仓库源的不同个版本，我们使用REPOSITORY:TAG来定义不同的镜像。

如果不指定一个镜像的版本标签，例如你使用ubuntu，docker将默认使用ubuntu:latest镜像

docker search 某个***镜像名字

docker search ***    某个***镜像名字
搜索镜像的命令

docker pull 某个***镜像名字

docker pull 镜像名字[:TAG]    拉取镜像

没有TAG就是最新版
示例：docker pull ubuntu  | docker pull redis:6.0.8

docker system df

docker system df 显示 Docker 系统中使用的磁盘空间

TYPE：表示资源的类型，例如Images（镜像）、Containers（容器）、Local Volumes（本地数据卷）等。
TOTAL：表示该类资源的总数。
ACTIVE：表示当前正在使用或活动的资源数量。
SIZE：表示该类资源占用的总磁盘空间大小。
RECLAIMABLE：表示可以回收的磁盘空间大小。这是指那些不再使用但仍然占用磁盘空间的资源所占用的空间，可以通过清理操作来释放。

docker stats 显示容器资源利用情况

这个命令可以显示包括CPU使用率、内存使用量、网络I/O等关键性能指标的信息。

docker rmi

docker rmi *** 删除某个镜像  docker rmi *** *** 删除多个镜像
docker rmi -f *** 强制删除某个镜像
docker rmi --no-prune  删除指定的 Docker 镜像，同时不会删除未标记的父镜像
docker rmi -f $(docker images -qa)

面试题:谈谈docker虚悬镜像是什么？

仓库名、标签都是的镜像，俗称虚悬镜像

容器命令

新建+启动容器

docker run[OPTIONS]IMAGE[COMMAND][ARG...]
示例：docker run -it --name=myu01 ubuntu bash
OPTIONS说明(常用):有些是一个减号，有些是两个减号
--name="容器新名字"：为容器指定一个名称；
-d：后台运行容器并返回容器ID，也即启动守护式容器（后台运行）
--restart=always  重启docker时会自动启动此容器
-i：以交互模式运行容器，通常与-t同时使用
-t：为容器重新分配一个伪输入终端，通常与-i同时使用；
也即启动交互式容器（前台有伪终端，等待交互）

-P：随机端口映射，大写P
-p：指定端口映射，小写p
docker run -p 9090:80 外界访问宿主机的9090端口映射访问容器的80端口

列出当前所有正在运行的容器

docker ps 列出所有正在运行的容器
-a：显示所有容器，包括未运行的容器。
-l：显示最近创建的容器。
-n：列出最近创建的 n 个容器。例如，docker ps -n 5 会列出最近创建的 5 个容器。
-q：静默模式，只显示容器编号（ID）。
-f：根据条件过滤显示的内容。例如，docker ps -f "status=exited" 会列出所有已退出的容器。
--format：指定返回值的模板文件，用于自定义输出格式。
示例：docker ps --format "{{.ID}}\t{{.Names}}\t{{.Status}}"  输出容器的 ID、名称和状态信息
--no-trunc：不截断输出，显示完整的容器 ID 和其他信息。
-s：显示总的文件大小，即容器所占用的磁盘空间。

退出容器

exit run进去容器 exit退出 ，容器停止
ctrl+p+q  退出，容器不停止

启动已停止运行的容器

docker start 容器ID或容器名字

重启容器

docker restart 容器ID或容器名

停止容器

docker stop 容器ID或容器名

强制停止容器

docker kill 容器ID或容器名

删除已停止的容器

--普通删除
docker rm 容器ID或容器名
（如果删除失败，确认是否是正在运行的，需要先stop再删除）
--强制删除
docker rm -f 容器ID或容器名
--一次性删除多个容器
docker rm -f$(docker ps -aq)
docker ps -a -q | xargs docker rm

重要

1、像ubuntu等需要交互的镜像容器必须使用docker run -it ** 等交互方式启动 ctrl+P+Q 形式转化为后台运行，不能使用docker -d *** 等后台方式启动，因为他会认为启动他没有事情做而自动停止 docker ps 查看不到 -d启动的容器

查看容器日志

docker logs 容器ID或容器名
docker logs -f 容器ID或容器名  
实时跟踪日志
docker logs --details 容器ID或容器名 
展示日志的额外详细信息
docker logs --since "2023-04-01" 容器ID或容器名
docker logs --since "30m" 容器ID或容器名
允许你指定一个时间戳或相对时间（如 "30m" 表示 30 分钟前），以仅显示从那时起的日志

查看容器内运行的进程

docker ps

查看容器内部细节

docker inspect 容器ID

进入正在运行的容器并以命令行交互

docker exec -it 容器ID或容器名 bashShell
docker atach 容器ID或容器名 

推荐使用exec exit退出不会关闭容器，attach进去后 exit关闭会把容器关闭
attach 直接进入容器启动命令的终端，不会启动新的进程，用exit退出，会导致容器的停止
exec是在容器中打开新的终端，并且可以启动新的进程，用exit退出，不会导致容器的停止

从容器内拷贝文件到主机上

docker cp 容器ID:容器内路径 目的主机路径
示例: docker cp (ubuntu的ID)d1ac07f54cc2:/tmp/a.txt /usr/local/

导入和导出容器 export import

export 导出容器的内容 作为一个tar归档文件
import 从tar包中的内容创建一个新的文件系统再导入为镜像

案例：docker export 容器ID > 文件名.tar
	 cat 文件名.tar | docker import - 镜像用户/镜像名:镜像版本号

Docker镜像 docker commit

docker commit 提交容器副本使之成为一个新的镜像
docker commit -m="提交的描述信息" -a="作者" 容器ID 要创建的目标镜像名:[标签名] 
示例：docker commit -m="vim cmd add ok" -a="first" 1c0dbe5d4a7d atxiaolong/myubuntu:4.11

本地镜像发布到阿里云

将镜像推送到阿里云

[!NOTE]

按照上面的将本地容器导出为新镜像
访问阿里云开发者平台-容器镜像服务-实例列表-个人实例-创建个人镜像仓库-按照提示的操作指令将本地镜像上传至云仓库中

阿里云操作指令

登录阿里云
docker login --username=用户名 registry.cn-hangzhou.aliyuncs.com
将本地镜像推送至仓库
docker login --username=secretxiaolong registry.cn-hangzhou.aliyuncs.com
docker tag Image Id registry.cn-hangzhou.aliyuncs.com/secretxiaolong/docker_test:镜像版本号   此处的Image Id是docker images里需要上传的iamge id
docker push registry.cn-hangzhou.aliyuncs.com/secretxiaolong/docker_test:镜像版本号
从仓库拉取镜像
$ docker pull registry.cn-hangzhou.aliyuncs.com/secretxiaolong/docker_test:镜像版本号

本地镜像发布到私有库

下载镜像

docker pull registry

运行私有库Registry

docker run -d -p 5000:5000 -v /xiaolong/myregistry/:/tmp/registry --privileged=true registry

将新镜像修改符合私服规范的Tag

docker tag 镜像:Tag Host:Port/Repository:Tag     此处的HOST是主机的IP不是Docker的Ip
示例:docker tag ifconfig:0411 10.88.26.31:5000/ifconfig:1.2

修改配置文件使之支持http

（/etc/docker/daemon.json) 这个后面一定要加一个’,’ 因为是json格式的！！！

如果不加这个那么

curl -XGET http://dockerIP:5000/v2/_catalog

会失败的加好这个之后才可以上传

（如果出现拒绝连接证明宿主机未安装nginx或未启动80端口)

加载配置
sudo systemctl daemon-reload
重启docker
sudo systemctl restart docker

push推送到本地私有库

docker push 172.17.0.1:5000/ifconfig:1.2

测试上传是否成功

curl -XGET http://172.17.0.1:5000/v2/_catalog

{"repositories":["ifconfig"]}

下拉镜像 pull到本地并运行

docker pull 172.17.0.1:5000/ifconfig:1.2

Docker容器数据卷

宿主与容器之间映射添加容器卷

--privileged=true  Docker挂载主机目录访问如果出现 cannot open directory : Permission denied
解决办法: 在挂载目录后多加一个--privileged=true参数即可

读写规则映射添加说明

docker run -it --privileged=true -v /宿主机绝对路径目录:/容器内目录:ro 镜像名
默认为rw  可以自修改为ro（read-only）
示例：docker run -it --privileged=true -v /mydocker/u:/tmp/u:ro --name u2 ubuntu

卷的继承和共享

docker run -it --privileged=true --volumes-from 父类 --name 新子类容器 ubuntu

示例：docker run -it --privileged=true --volumes-from u1 --name u2 ubuntu
这样父类子类和宿主机三者间对应u1创建时的容器卷对应关系就形成了一主两从的形式

Docker内软件常规安装简介

安装步骤

搜索镜像
拉取镜像
查看镜像
启动镜像——服务端口映射
停止容器
移除容器

安装tomcat

docker pull tomcat  拉去最新版tomcat
docker run -d -p 8080:8080 tomcat
此时http:localhost:8080是无法访问的404
因为最新版的tomcat里面的webapps里面是空的 需要进入容器将webapps删除，然后将webapps.dist修改为webapps，然后就可以访问了（外部访问请访问宿主机的8080）
如果不想修改webapps  可以降版测试
docker run -d -p 8080:8080 --name mytoncat8 billygoo/tomcat8-jdk8

安装mysql

docker run -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7
此处注意前面的3306是宿主机的要确认端口是否被占用
此处的123456为首次启动mysql容器设定的root密码 后面的是容器:TAG
MYSQL大坑（修改默认字符集）否则插入中文报错

实战篇
启动mysql
docker run -d -p 3306:3306 --privileged=true -v /zzyyuse/mysql/log:/varlog/mysql -v /zzyyuse/mysql/data:/var/lib/mysql -v /zzyyuse/mysql/conf:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=123456 --name mysql mysql:5.7

宿主机上修改mysql的conf使其支持utf8
vim /mysql/conf/my.cnf 
[client]
default_character_set=utf8
[mysqld]
collation_server = utf8_general_ci
character_set_server = utf8

重启mysql 
docker restart mysql
进入mysql 查看是否修改成功
show variables like '%character%';
此操作一定要在容器内执行 不要从外部软件执行。
下方应该为utf8 为修改正确； 如果有不对的，确认数据库是否为修改字符前创建的，可删除重建。

误删除容器后按照原有run启动命令会将新的mysql和旧的mysql数据实例，配置等读取，数据配置等回复还原。

安装redis

docker run -d -p 6379:6379 redis:TAG

复制一份redis.conf复制到后续宿主机的映射文件夹
修改开启redis密码：requirepass redis123456

开启外部链接  #注销掉
# bind 192.168.1.100 10.0.0.1
# bind 127.0.0.1

这个要设置为no或者把yes注释掉，因为该配置与docker run中的-d参数冲突，会导致启动失败
daemonize no

开启redis数据持久化 appendonly yes 可选
 
docker run -p 6379:6379 --name myr3 --privileged=true -v /app/redis/redis.conf:/etc/redis/redis.conf -v /app/redis/data:/data -d redis:6.0.8 redis-server /etc/redis/redis.conf

安装nginx

见后续大厂高级篇的portainer篇

高级大厂进修篇

mysql的主从复制搭建

新建主服务器容器实例3307

docker run -p 3307:3306 --name mysql-master \
-v /mydata/mysql-master/log:/var/log/mysql \
-v /mydata/mysql-master/data:/var/lib/mysql \
-v /mydata/mysql-master/conf:/etc/mysql \
-e MYSQL_ROOT_PASSWORD=root \
-d mysql:5.7

进入/mydata/mysql-master/conf目录下新建my.cnf

[mysqld]
## 设置server_id，同一局域网中需要唯一
server_id=101
## 指定不需要同步的数据库名称
binlog-ignore-db=mysql
## 开启二进制日志功能
log-bin=mall-mysql-bin
## 设置二进制日志使用内存大小（事务）
binlog_cache_size=1M
## 设置使用的二进制日志格式（mixed，statement，row）
binlog_format=mixed
## 二进制日志过期清理时间。默认值为0；表示不自动清理。
expire_logs_days=7
## 跳过主从复制中遇到的所有错误或指定类型的错误，避免slave端复制中断。
## 如：1062错误是指一些主键重复，1032错误是因为主从数据库数据不一致
slave_skip_errors=1062

修改完配置后重启master实例

docker restart mysql的TAGID

进入mysql-master容器

docker exec -it mysql的TAGID /bin/bash

master容器实例内创建数据同步用户

create user'slave'@'%'IDENTIFIED BY '123456';
GRANT REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'slave'@'%';

MySQL 8 版本设置账号要加一步：ALTER USER 'slave'@'%' IDENTIFIED WITH mysql_native_password BY '上面的密码';

新建从服务器容器实例3308

docker run -p 3308:3306 --name mysql-slave \
-v /mydata/mysql-slave/log:/var/log/mysql \
-v /mydata/mysql-slave/data:/var/lib/mysql \
-v /mydata/mysql-slave/conf:/etc/mysql \
-e MYSQL_ROOT_PASSWORD=root \
-d mysql:5.7

进入/mydata/mysql-master/conf目录下新建my.cnf

[mysqld]
## 设置server_id，同一局域网中需要唯一
server_id=102
## 指定不需要同步的数据库名称
binlog-ignore-db=mysql
## 开启二进制日志功能
log-bin=mall-mysql-slave1-bin
## 设置二进制日志使用内存大小（事务）
binlog_cache_size=1M
## 设置使用的二进制日志格式（mixed，statement，row）
binlog_format=mixed
## 二进制日志过期清理时间。默认值为0；表示不自动清理。
expire_logs_days=7
## 跳过主从复制中遇到的所有错误或指定类型的错误，避免slave端复制中断。
## 如：1062错误是指一些主键重复，1032错误是因为主从数据库数据不一致
slave_skip_errors=1062
## relay_log配置中继日志
relay_log=mall-mysql-relay-bin
## log_slave_updates表示slave将复制事件写进自己的二进制日志
log_slave_updates=1
## slave设置为只读（具有super权限的用户除外）
read_only=1

修改完配置后重启slave实例

docker restart mysql的TAGID

在主数据库中查看主从同步状态

show master status;

进入mysql-slave容器

docker exec -it 从数据库的TAGid /bin/bash

在从数据库中配置主从复制

change master to master_host='172.17.0.1',master_user='slave',master_password='123456',master_port=3307,master_log_file='mall-mysql-bin.000001',master_log_pos=617,master_connect_retry=30;

master_host: 主数据库的IP地址；
master_port: 主数据库的运行端口；
master_user: 在住数据库创建的用于同步数据的用户账号；
master_password: 在主数据库创建的用于同步数据的用户密码；
master_log_file: 指定从数据库要复制数据的日志文件，通过查看主数据的状态，获取File参数；
master_log_pos: 制定从数据库从哪个位置开始复制数据，通过查看主数据的状态，获取Position参数；
master_connect_retry:连接失败重试的时间间隔，单位为秒。

在从数据库库中查看主从同步状态

show slave status \G;

在从数据库中开启主从同步

start slave;

查看从数据库状态发现已经同步

show slave status \G;
如果出现问题请查看 change master to 配置，stop slave后重新执行即可生效。

主从复制测试

主机

从机

安装redis集群（大厂面试题第四季-分布式存储）

1~2亿条数据需要缓存，请问如何设计这个存储案例

哈希取余算法

算法介绍：2亿条记录就是2亿个k,v，我们单机不行必须要使用分布式多机，假设有三台机器构成一个集群，用户每次读写操作都是根据公式：hash(key)%N个机器台数，计算出哈希值，用来决定数据映射到哪一个节点上。

优点：简单粗暴，直接有效，只需要预估好数据规划好节点，例如3台、8台、10台，就能保证一段时间的数据支撑，使用Hash算法让固定的一部分请求落到同一台服务器上，这样每台服务器固定处理一部分请求（并维护这些请求的信息），起到负载均衡+分而治之的作用。

缺点：不管扩缩，每次数据变动导致节点有变动，映射关系需要重新计算，在服务器个数固定不变时没有问题，如果需要弹性扩容或故障停机的情况下，原来的取模公式就会发生变化：Hash(key)/3会变成Hash(key)/?。此时地址经过某个redis机器宕机了，由于台数数量变化，会导致hash取余全部数据重新洗牌。

一致性哈希算法

算法介绍：一致性哈希算法必然有个hash函数并按照算法产生hash值，这个算法的所有可能哈希值会构建成一个全量集，这个集合可以形成一个hash空间[0,2^32-1]，这个是一个线性空间，但是在算法中，我们通过适当的逻辑控制将它首尾相连形成一个环形空间。

3大步骤：算法构建一致性哈希环服务器IP节点映射 key落到服务器的落键规则

优点：容错性扩张性加入和删除节点只影响哈希环中顺时针方向的相邻的节点，对其他节点无影响

缺点：数据倾斜数据的分布和节点的位置有关系

哈希槽分区

算法介绍：一种在分布式系统中实现数据分片和负载均衡的技术。其核心思想是将数据按照哈希函数的结果分配到多个哈希槽中，每个槽对应一个物理节点或服务器。这种分区方式能够解决数据倾斜和均匀分配的问题，通过引入哈希槽这一中间层，管理数据和节点之间的关系，使得数据移动更为便捷

优点：在Redis这样的高性能键值存储系统中，哈希槽是其分布式集群的核心组件之一。通过哈希槽分区，Redis能够实现数据的均匀分布和高效访问，满足分布式缓存、消息队列、排行榜等多种应用场景的需求

缺点：数据的分布和节点的位置有关，因为这些节点不是均匀地分布在哈希环上的，所以数据在进行存储时可能达不到完全均匀分布的效果。因此，在实际应用中，需要根据具体的业务需求和系统环境来选择合适的分区策略和参数设置。

redis集群配置

新建6个redis-docker容器实例

docker run -d --name redis-node1 --net host --privileged=true -v /data/redis/share/redis-node-1:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6381

docker run -d --name redis-node2 --net host --privileged=true -v /data/redis/share/redis-node-2:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6382

docker run -d --name redis-node3 --net host --privileged=true -v /data/redis/share/redis-node-3:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6383

docker run -d --name redis-node4 --net host --privileged=true -v /data/redis/share/redis-node-4:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6384

docker run -d --name redis-node5 --net host --privileged=true -v /data/redis/share/redis-node-5:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6385

docker run -d --name redis-node6 --net host --privileged=true -v /data/redis/share/redis-node-6:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6386

进入容器redis-node-1并为6台机器构建集群关系

docker exec -it redisnode1的TAG /bin/bash

//需要进入redis容器内才可以执行，且ip为主机真实ip，因为端口都映射到了虚拟机的redis
redis-cli --cluster create 10.88.25.146:6381 10.88.25.146:6382 10.88.25.146:6383 10.88.25.146:6384 10.88.25.146:6385 10.88.25.146:6386 --cluster-replicas 1

--cluster-replicas 1: 这部分指定了每个主节点有一个从节点。因为总共有 6 个节点，所以这个参数会导致前三个节点作为主节点，后三个节点作为这些主节点的从节点。这种设置增加了集群的可用性和容错性，因为如果某个主节点故障，它的从节点可以接管其工作。

在执行这个命令后，redis-cli 会自动进行以下操作：
将每个节点添加到集群中。
为每个主节点分配哈希槽（默认是 16384 个哈希槽）。
将从节点设置为对应主节点的副本。

链接进入6381作为切入点，查看集群状态

docker exec -it 6381的TAG /bin/bash
redis-cli -p 6381
查看集群状态
cluster-info
查看集群节点信息
cluster nodes
根据从节点slave后面跟着的id去查找master节点前面的id去匹配关系
可以查看到目前的是 1-6 2-5 -3-4

主从容错切换迁移/扩缩案例

数据读写存储 redis-cli -p 6381 -c

当你使用redis-cli -p 6381 启动redis时  你是单机进入的  如果设置的key hash算法后大于自身的范围 例如图片的已经是12706了 所以会报错 要求你去6383去设置key
所以为了解决这个问题 可以使用 redis-cli -p 6381 -c 使用集群模式连接redis
此时再去设置set k1 v1 会自动根据集群形式将key value 存放到对应的节点redis上

查看集群情况

 redis-cli --cluster check 10.88.25.146:6382

主从容错切换

当docker stop redis-node1
redis1节点宕机后，对应的从节点6会自动上位为主节点

当旧的主节点redis1节点恢复重启后，redis1还是slave  redis6是master且 6是1的master

如果想恢复原来的1是主机 6是从机的样子  需要停止现有的主机redis6  使redis1上位为主机 然后再启动redis6  就恢复原有1是6的主机样子

主从扩容案例

从原有的3主3从扩容为4主4从

新增两台redis 6387 6388

新增两台redis  6387 6388
docker run -d --name redis-node7 --net host --privileged=true -v /data/redis/share/redis-node7:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6387

docker run -d --name redis-node8 --net host --privileged=true -v /data/redis/share/redis-node8:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6388

进入6387容器实例内部

docker exec -it redis-node7 /bin/bash

将新增的6387作为master加入集群

redis-cli --cluster add-node 自己的主机ip:6387 自己实际ip的地址:6381

查看集群情况

重新分配槽号

redis-cli --cluster reshard 主机的ip:6381

How many slots do you want to move (from 1 to 16384)? 4096
这一行的意思是询问您想要移动多少个槽位。在这里，您输入了 4096，表示您想要从其他节点移动 4096 个槽位到目标节点。

What is the receiving node ID? ee7ca7fa0c51dca6458305338b96bd3a63960bb1
这一行的意思是询问您想要将槽位移动到哪个节点。在这里，您输入了 ee7ca7fa0c51dca6458305338b96bd3a63960bb1，这是目标节点的 ID。这个节点目前没有分配任何槽位，因此它将是接收槽位的节点。

Source node #1: all
这一行的意思是询问您想要从哪些源节点移动槽位。在这里，您输入了 all，表示您想要从所有其他节点中移动槽位。如果您只想从特定的节点移动槽位，您应该输入那些节点的 ID

检查集群情况第二次

每个节点都是相同的4096个节点
发现新增节点的槽位是前面三个节点分别拆出一部分组成的新槽位
重新分配的成本太高，所以前面三家各自匀出来一部分，从6381/6382/6383三个旧节点分别匀出1364个槽位给到新节点6387

面试点：不是全部洗牌，而是各自取一部分去给到最新的节点

为主节点6387增加从节点6388

redis-cli --cluster add-node 主机真实IP:6388 主机真实IP:6387 --cluster-slave --cluster-master-id ee7ca7fa0c51dca6458305338b96bd3a63960bb1

检查集群情况第三次

在容器内: redis-cli --cluster check 主机IP:6381
在redis里:cluster noedes

主从缩容案例

必须要先删除从节点     再删除主节点

集群下面删除node节点

redis-cli --cluster del-node 主机IP:6388 节点ID
示例: redis-cli --cluster del-node 10.88.25.146:6388 881c3e523925fd2243623cdd2fa0a325f51da8c8

检查一下集群信息

将6387的槽号清空，重新分配，本例将清出来的槽号都给到6381

redis-cli --cluster reshard 主机IP:6381
示例:redis-cli --cluster reshard 10.88.25.146:6381
指定集群中的一个节点为切入点

How many slots do you want to move (from 1 to 16384)? 4096
4096 是指想要移动的槽位数量

接收这些槽位的节点ID：
What is the receiving node ID? 30d42706a18f2a11d7ce3e9fb2c9cc6feb31c5cc

你输入了 30d42706a18f2a11d7ce3e9fb2c9cc6feb31c5cc，这是节点 10.88.25.146:6381 的ID。
之后，你需要指定源节点ID，这些源节点包含了你想要移动的槽位

Source node #1: ee7ca7fa0c51dca6458305338b96bd3a63960bb1  
Source node #2: done
你指定了 ee7ca7fa0c51dca6458305338b96bd3a63960bb1 作为源节点ID，并且输入 done 表示你已经输入了所有源节点ID。

检查集群信息

redis-cli --cluster check 主机IP:6381

删除6387redis节点

redis-cli --cluster del-node 主机IP:6387 6387的ID
示例:redis-cli --cluster del-node 10.88.25.146:6387 ee7ca7fa0c51dca6458305338b96bd3a63960bb1

检查集群情况第三次

redis-cli --cluster check 主机IP:6381
示例:redis-cli --cluster check 10.88.25.146:6381

DockerFile解析

DockerFile简介：

DockerFile是用来构建Docker镜像的文本文件，是由一条条构建镜像所需的指令和参数构建的脚本。

Dockerfile官网:https://docs.docker.com/engine/reference/builder/

构建三步骤：

编写Dockerfile文件——docker build命令构建镜像——docker run依照镜像运行容器实例

DockerFile的内容基础知识

每条保留字指令都必须为大写字母且后面要跟随至少一个参数
指令按照从上到下，顺序执行
#表示注释
每条指令都会创建一个新的镜像层并对镜像进行提交

Docker执行Dockerfile的大致流程

docker从基础镜像运行一个容器
执行一条指令并对容器做出修改
执行类似docker commit的操作提交一个新的镜像层
docker再基于刚才提交的镜像运行一个新容器
执行dockerfile中的下一条指令直到所有指令都执行完成

DockerFile中的常用保留字指令

FROM

基础镜像，当前新镜像是基于哪个镜像的，指定一个已经存在的镜像作为模版，第一条必须是FROM

示例 FROM ubuntu || FROM centos:7

MAINTAINER

镜像维护者的姓名和邮箱地址

MAINTAINER = “zzyyzzyybs@126.com”

LABEL

MAINTAINER在Docker1.13后已被遗弃，可使用LABEL

LABEL maintainer=“zzyyzzyybs@126.com”

RUN

容器构建时需要运行的命令

两种格式{shell格式 exec格式}

RUN是在docker build时运行

EXPOSE

当前容器对外暴露的端口

WORKDIR

指定在创建容器后，终端默认登录进来的一个工作目录

USER

指定该镜像以什么样的用户去执行，如果不指定，默认为root

ENV

用来在构建镜像过程中设置环境变量

示例：
ENV MY_PATH /usr/mytest
此时环境变量就配置上了 MY_PATH 是 /usr/mytest
比如： WODIR $MY_PATH

ADD

将宿主机目录下的文件拷贝进镜像且自动处理URL和解压tar压缩包

COPY

类似ADD，拷贝文件和目录到镜像中。

将从构建上下文目录中<源路径>的文件/目录复制到新的一层的镜像内的<目标路径>位置

COPY src dest == COPY [“src”,“desc”] == <src源路径>: 源文件或者源目录 == <dest 目标路径>: 容器内的指定路径，该路径不用事先创建好，会自动创建。

VOLUME

容器数据卷，用于数据保存和持久化工作

CMD

指定容器启动后的要干的内容

一个Dockerfile里可以有多个CMD，但是只有最后一个CMD会生效，前面的CMD会被docker run之后的参数替换

CMD和RUN的区别
CMD是在docker run时运行的
RUN时再docker build时运行的

ENTRYPOINT

也是用来制定一个容器启动时要运行的命令

类似于CMD指令，但是ENTRYPOINT不会被docker run后面的命令覆盖，而且这些命令行参数会被当做参数送给ENTRYPOINT指令指定的程序。

Dockerfile安装带组件的centos

要求：centos7镜像具备vim+ifconfig+jdk8

编写:编写Dockerfile文件

在docker1.13版本之后MAINTAINER保留字指令已经被遗弃，可以使用：LABEL maintainer=“zzyyzzyybs@126.com”

vim /myfile/Dockerfile
---------------------------------------------------------
# 使用官方的基础镜像
FROM centos

# 使用LABEL代替MAINTAINER，因为MAINTAINER已被弃用  
LABEL maintainer="zzyy<zzyybs@126.com>"  

# 定义环境变量
ENV MYPATH /usr/local

# 设置工作目录
WORKDIR $MYPATH

#安装vim编辑器
#RUN yum -y install vim
#安装ifconfig命令查看网络IP
#RUN yum -y install net-tools
#安装java8及lib库
#RUN yum -y install glibc.i686
# 上面这些应该优化一下，安装软件包时尽量合并为一个RUN命令，减少镜像层数  
RUN yum install -y \  
    vim \  
    net-tools \  
    glibc.i686 && \  
    yum clean all && \  
    rm -rf /var/cache/yum 

# 创建Java安装目录
RUN mkdir /usr/local/java

#ADD 是相对路径jar，把jdk-8u411-linux-x64.tar.gz添加到容器中，安装包必须和Dockerfile文件在同一位置
ADD jdk-8u411-linux-x64.tar.gz /usr/local/java/
#配置java环境变量
ENV JAVA_HOME /usr/local/java/jdk1.8.0_411
ENV JRE_HOME $JAVA_HOME/jre
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib:$CLASSPATH
ENV PATH $JAVA_HOME/bin:$PATH

EXPOSE 80

CMD echo $MYPATH
CMD echo "success--------------ok"
CMD /bin/bash
------------------------------------------------------

里面的    yum clean all && \  
    rm -rf /var/cache/yum  做一下解释

在Dockerfile中添加yum clean all和rm -rf /var/cache/yum这两步是为了优化构建出的Docker镜像的大小和性能。以下是具体的原因：

减小镜像大小：当你使用yum安装软件包时，YUM会下载并缓存这些软件包的元数据以及软件包本身到/var/cache/yum目录下。如果不清理这些缓存，它们会被包含在最终构建的Docker镜像中，从而增加了镜像的大小。通过执行yum clean all命令，你可以删除所有YUM缓存，确保这些不必要的文件不会被包含在最终的镜像中。

提高构建性能：在构建Docker镜像时，每一层都是基于前一层创建的。如果某一层的文件被后续层修改了（比如删除了一些文件），这些修改实际上是在新的层中创建了一个文件系统的差异，而不是直接修改原有的文件。因此，如果不清理YUM缓存，这些缓存文件会在每一层中都存在，占用了额外的磁盘空间，并且可能会增加构建时间，因为Docker需要处理这些额外的文件。

保持镜像的整洁：除了优化大小和性能外，清理缓存还可以让镜像保持整洁和一致。这样，其他人在查看或使用你的Dockerfile时，可以更容易地理解镜像的构建过程，并减少不必要的混淆。

因此，在Dockerfile的RUN指令中通常包含yum clean all和rm -rf /var/cache/yum这两个步骤，以确保构建的Docker镜像既小又高效。这已经成为了Dockerfile编写的一个常见最佳实践。

构建：

docker build -t 新镜像名字:TAG . [注意，此处TAG后面要跟随一个空格和点]

如果此处一直报yum源错误，请修改centos的版本可以尝试centos:7

运行：

docker run -it 新镜像名字:TAG /bin/bash

自己手动复习一遍-做一个ubuntu的Dockerfile

（可以装一个jdk、vim、网络工具）

vim Dockerfile
--------------------------------------
FROM ubuntu

LABEL maintainer = "secretxiaolong@163.com"

ENV MYPATH /usl/local

WORKDIR $MYPATH

RUN apt-get update && \ 
    apt-get -y install vim \
    net-tools 

RUN mkdir /usr/local/java

COPY jdk-8u411-linux-x64.tar.gz /usr/local/java/

RUN cd /usr/local/java && \
    tar -xzvf jdk-8u411-linux-x64.tar.gz && \
    rm jdk-8u411-linux-x64.tar.gz 

ENV JAVA_HOME /usr/local/java/jdk1.8.0_411
ENV JRE_HOME $JAVA_HOME/jre
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib:$CLASSPATH
ENV PATH $JAVA_HOME/bin:$PATH

EXPOSE 80

CMD echo $MYPATH
CMD echo "success-----"
CMD /bin/bash

虚悬镜像

简介：仓库名、标签都是的镜像，俗称dangling image

构建:Dockerfile:

FROM ubuntu

CMD echo ‘action is success’

docker build .

示例：

查看本地全部虚悬镜像：

docker images ls -f dangling=true

删除本地全部虚悬镜像:

docker image prune

Docker 微服务实战

1、通过IDEA新建一个普通微服务模块

IDEA新建MODULE（如果使用jdk1.8，Springboot 顶部server URL 修改为https://start.aliyun.com/，输入name:docker_boot,指定jdk，选择java8，NEXT，FINISH。

修改pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.13</version>
        <relativePath/>
    </parent>

    <groupId>com.atguigu.docker</groupId>
    <artifactId>docker_boot</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <junit.version>4.12</junit.version>
        <log4j.version>1.2.17</log4j.version>
        <lombok.version>1.16.18</lombok.version>
        <mysql.version>5.1.47</mysql.version>
        <druid.version>1.1.16</druid.version>
        <mapper.version>4.1.5</mapper.version>
        <mybatis.spring.boot.version>1.3.0</mybatis.spring.boot.version>
    </properties>

    <dependencies>
        <!--SpringBoot通用依赖模块-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--test-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>3.1.0</version>
            </plugin>
        </plugins>
    </build>

</project>

修改application.properties

# 应用服务 WEB 访问端口
server.port=6001

查看确认主启动

package com.atguigu.docker;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DockerBootApplication
{
    public static void main(String[] args)
    {
        SpringApplication.run(DockerBootApplication.class, args);
    }
    
}

创建业务类

package com.atguigu.docker.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import java.util.UUID;

/**
 * @auther zzyy
 * @create 2021-10-25 17:43
 */
@RestController
public class OrderController
{
    @Value("${server.port}")
    private String port;

    @RequestMapping("/order/docker")
    public String helloDocker()
    {
        return "hello docker"+"\t"+port+"\t"+ UUID.randomUUID().toString();
    }

    @RequestMapping(value ="/order/index",method = RequestMethod.GET)
    public String index()
    {
        return "服务端口号: "+"\t"+port+"\t"+UUID.randomUUID().toString();
    }
}

2、通过dockerfile发布微服务部署到docker容器

IDEA里面搞定服务jar包

选择右侧maven，自己的项目，Lifrcycle-package-run

编写Dockerfile

 FROM java:8

VOLUME /tmp

ADD docker_boot-0.0.1-SNAPSHOT.jar zzyy_docker.jar

RUN bash -c 'touch /zzyy_docker.jar'
ENTRYPOINT ["java","-jar","/zzyy_docker.jar"]

EXPOSE 6001

打包镜像

docker build -t zzyy_docker:1.6 .

运行容器

docker run -d -p 6001:6001 zzyy_docker

Docker网络

是什么

docker启动后会在主机上有一个docker0的虚拟网桥。

默认创建三大网络模式：docker network ls

常用基本命令

All命令:

连接至别的网络

docker network connect命令是用于将Docker容器连接到某个网络中，或者与其他容器建立连接。容器可以使用容器名或者容器ID进行连接。当容器IP变化时，Docker会自动维护映射关系。此外，docker network connect命令还支持为容器在网络范围内添加一个别名，这样可以在网络内部使用别名来引用容器

创建网络

docker network create aa_network

查看网络

docker network ls

查看网络源数据

docker network inspect XXX网络名字

删除网络

docker network rm XXX网络名字

删除无用网络

docker network prune
docker network prune命令用于删除所有未被任何容器使用的Docker网络

网络模式

总体介绍

bridge

–network bridge

为每一个容器分配、设置IP等，并将容器连接到每一个docker0虚拟网桥，默认为该模式

host

容器将不会虚拟出自己的网卡，配置自己的IP等，而是使用宿主机的IP和端口

none

容器有独立的Network namespace，但并没有对其进行任何网络设置，如分配veth pair 和网桥连接，IP等

container

新创建的容器不会创建自己的网卡和配置自己的IP，而是和一个指定的容器共享IP、端口范围等。

容器实例内默认网络IP生产规则

docker容器内部的ip是有可能会发生改变的

例如当启动第二个容器时docker分配的网络是172.17.0.2

当第二台服务器宕机后，启动第三台容器时，仍旧分配172.17.0.2

案例说明

bridge

整个宿主机的网桥模式都是docker0，类似一个交换机有一堆接口，每个接口叫veth。在本地主机和容器内分别创建一个虚拟接口，并让他们彼此联通；（这样一对接口叫 veth pair）

每个容器的网络是独立的，拥有自己的网卡eth0，和主机的veth匹配，两个容器在同一个网络下，会从这个网关下各自拿到分配的ip，此时两个容器的网络是互通的。

两两匹配原则：

当docker启动两个tomcat容器后，查看宿主机的网络可以看到有新增的两个容器网络配置：

进入容器tomcat81后查看网络发现出现235的eth0和宿主机的docker0的veth234相对应

进入容器tomcat83后查看网络发现出现239的eth0和宿主机的docker0的veth238相对应

host

直接使用宿主机的IP地址与外界通信，容器将不会获得一个独立的Network Namespace，而是和宿主机共用一个Network Namespace，容器将不会虚拟出自己的网卡而是使用宿主机的IP和端口。

docker run -d --net host --name tomcat80 tomcat8

none

在none模式下，并不为Docker容器进行任何网络配置。

也就是说，这个Docker容器没有网卡、IP、路由等信息，只有一个lo

需要我们自己为Docker容器添加网卡、配置IP等

container

新创建的容器不会创建自己的网卡和配置自己的IP，而是和一个制定的容器共享IP、端口范围等。

同样，两个容器除了网络方面，其他的如文件系统、进程列表等还是隔离的。

自定义网络

首先查看自身docker网络

然后创建自定义网络

使用–network zzyy_network 启动容器

docker run -d -p 8081:8080 --network zzyy_network --name tomcat81 billygoo/tomcat8-jdk8
docker run -d -p 8082:8080 --network zzyy_network --name tomcat82 billygoo/tomcat8-jdk8

在同一自定义网络桥段内可以通过ping容器名连接（但建议还是通过ping ip形式）

Docker-Compose容器编排

Docker-Compose下载安装

新版的docker compose会跟随下载docker随之下载，以plugns的形式安装，可以使用docker compose version的形式查看

登录官网查看Compose安装

https://docs.docker.com/compose/install/standalone/

1、要下载并安装独立的 Compose，请运行：
curl -SL https://github.com/docker/compose/releases/download/v2.27.0/docker-compose-linux-x86_64 -o /usr/local/bin/docker-compose
2、为docker-compose赋予可执行权限
chmod +x /usr/local/bin/docker-compose
3、验证测试是否安装成功
docker-compose --version

Compose核心概念

一文件

docker-compose.yml

两要素

服务(service) 一个个应用容器实例，比如订单微服务、库存微服务、mysql容器等

工程(project)由一组关联的应用容器组成的一个完整业务单元，在docker-compose.yml文件中定义

Compose使用的三个步骤

编写Dockerfile定义各个微服务应用并构建出对应的镜像文件

使用docker-compose.yml定义一个完整业务单元，安排好整体应用中的各个容器服务。

最后，执行docker-compose up命令来启动并运行整个应用程序，完成一键部署上线

Compose常用命令

docker-compose -h #查看帮助

docker-compose up #启动所有docker-compose服务

docker-compose up -d #启动所有docker-compose服务兵后台运行

docker-compose down #停止并删除容器、网络、卷、镜像

docker-compose exec yml里面的服务id #进入容器实例内部 docker-compose exec docker-compose.yml文件中写的服务id /bin/bash

docker-compose ps #展示当前docker-compose编排过的运行的所有容器

docker-compose top #展示当前docker-compose编排过的容器进程

docker-compose logs yml里面的服务id #查看容器输出日志

docker-compose config #检查配置

docker-compose comfig -q #检查配置，有问题才有输出

docker-compose restart #重启服务

docker-compose start #启动服务

docker-compose stop #停止服务

Compose编排微服务

version: "3"

services:
  microService:
        image: zzyy_docker:1.6
        container_name: ms01
        ports:
          - "6001:6001"
        volumes:
          - /app/microService:/data
        networks:
          - atguigu_net
        depends_on:
          - redis
          - mysql

  redis:
        image: redis:6.0.8
        ports:
          - "6379:6379"
        volumes:
          - /app/redis/redis.conf:/etc/redis/redis.conf
          - /app/redis/data:/data
        networks:
          - atguigu_net
        command: redis-server /etc/redis/redis.conf

  mysql:
        image: mysql:5.7
        environment:
          MYSQL_ROOT_PASSWORD: '123456'
          MYSQL_ALLOW_EMPTY_PASSWORD: 'no'
          MYSQL_DATABASE: 'db2021'
          MYSQL_USER: 'zzyy'
          MYSQL_PASSWORD: 'zzyy123'
        ports:
          - "3306:3306"
        volumes:
          - /app/mysql/db:/var/lib/mysql
          - /app/mysql/conf/my.cnf:/etc/my.cnf
          - /app/mysql/init:/docker-entrypoint-initdb.d
        networks:
          - atguigu_net
        command: --default-authentication-plugin=mysql_native_password #解决外部无法访问

networks:
   atguigu_net:

docker-compose up -d

docker network ls

docker-compose stop

Docker轻量级可视化工具Portainer

Portainer官网

https://www.portainer.io/

安装步骤

第一步

docker run -d -p 8000:8000 -p 9000:9000 --name portainer     --restart=always     -v /var/run/docker.sock:/var/run/docker.sock     -v portainer_data:/data     portainer/portainer

可以加上账号密码： --env ADMIN_USERNAME=admin --env ADMIN_PASS=12345678

第二步

访问ip：9000
portainer的客户网站
首次登录需要设定admin的密码（8位即可）
如果是本机监控选择local即可

第三步：可以在管理页面快速拉取创建容器

Docker容器监控之CAdvisor+InfluxDB+Grafana

CAdvisor监控收集+InfluxDB存储数据+Granfana展示图表

compose一键搭建

vim docker-compose.yml

version: '3.1'
 
volumes:
  grafana_data: {}
 
services:
 influxdb:
  image: tutum/influxdb:0.9
  restart: always
  environment: 
   - PRE_CREATE_DB=cadvisor
  ports: 
   - "8083:8083"
   - "8086:8086"
  volumes: 
   - ./data/influxdb:/data

 cadvisor:
  image: google/cadvisor
  links: 
   - influxdb:influxsrv
  command: -storage_driver=influxdb -storage_driver_db=cadvisor -storage_driver_host=influxsrv:8086
  restart: always
  ports: 
   - "8080:8080"
  volumes:
   - /:/rootfs:ro
   - /var/run:/var/run:rw
   - /sys:/sys:ro
   - /var/lib/docker/:/var/lib/docker:ro

 grafana:
  user: "104"
  image: grafana/grafana
  restart: always
  links:
   - influxdb:influxsrv
  ports:
   - "3000:3000"
  volumes:
   - grafana_data:/var/lib/grafana
  environment: 
   - HTTP_USER=admin
   - HTTP_PASS=admin
   - INFLUXDB_HOST=influxsrv
   - INFLUXDB_NAME=cadvisor
   - INFLUXDB_USER=root
   - INFLUXDB_PASS=root

先 检查排错
docker-compose config -q
后 启动测试
docker-compose up

测试

浏览CAdvisor收集服务，http://ip:8080/

浏览influxdb存储服务，http://ip:8083/

浏览grafana展现服务，http://ip:3000

使用admin、admin登录

然后添加数据源

賑茗龙华

关注

29
点赞
踩
24

收藏

觉得还不错? 一键收藏
0
评论
Docker复习笔记

搜索镜像拉取镜像查看镜像启动镜像——服务端口映射停止容器移除容器DockerFile是用来构建Docker镜像的文本文件，是由一条条构建镜像所需的指令和参数构建的脚本。Dockerfile官网:https://docs.docker.com/engine/reference/builder/为每一个容器分配、设置IP等，并将容器连接到每一个docker0虚拟网桥，默认为该模式首先查看自身docker网络然后创建自定义网络使用–network zzyy_network 启动容器。
复制链接

扫一扫