docker学习

---

02-docker为什么出现

系统平滑移植，即容器虚拟化技术。

03-docker理念简介

04-docker是什么

基于Go语言实现的云开源项目

通过对应用组件的封装、分发、部署、运行等生命周期的管理，使用户的APP（可以是一个Web应用或数据库应用等等）及其运行环境能够做到“一次镜像，处处运行”。

05-传统虚拟机和容器的对比

06-docker能干吗解决什么问题

07-docker官网介绍

官网： docker官网：http://www.docker.com

仓库： Docker Hub官网：https://hub.docker.com/

Docker Hub——安装docker镜像的仓库

Docker 并非是一个通用的容器工具，它依赖于已存在并运行的 Linux 内核环境。

Docker 实质上是在已经运行的 Linux 下制造了一个隔离的文件环境，因此它执行的效率几乎等同于所部署的 Linux 主机。

因此，Docker 必须部署在 Linux 内核的系统上。如果其它系统想部署 Docker 就必须安装一个虚拟 Linux 环境。

1. 查看自己的内核

cat /etc/redhat-release

uname -r

08-docker三要素

1. 镜像（image）

Docker 镜像就是一个只读的模板。镜像可以用来创建 Docker 容器，一个镜像可以创建很多容器。它也相当于是一个root文件系统。相当于容器的“源代码”。

2. 容器（container）

Docker 利用容器独立运行一个或一组应用，应用程序或服务运行在容器里面，容器就类似于一个虚拟化的运行环境，容器是用镜像创建的运行实例。

可以把容器看做是一个简易版的Linux环境（包括root用户权限、进程空间、用户空间和网络空间）和运行在其中的应用程序。

3. 仓库（repository）

仓库是集中存放镜像文件的场所。类似于github。

国内一般用阿里云

09-docker平台入门图解

Docker 是一个C/S结构的系统，Docker守护进程运行在主机上，然后通过Socket连接从客户端访问，守护进程从客户端接受命令并管理运行在主机上的容器。

10-docker平台架构图解

Docker是一个C/S模式的架构，后端是一个松耦合架构，众多模块各司其职。

Docker运行的基本流程如下所示：

每个容器就是一个job

11-centos7上安装docker

安装网址：（centos7）

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

安装步骤：

1. 确定是centos7及以上版本：cat /etc/redhat-release

2. 卸载旧版本

   sudo yum remove docker \
                     docker-client \
                     docker-client-latest \
                     docker-common \
                     docker-latest \
                     docker-latest-logrotate \
                     docker-logrotate \
                     docker-engine
   

3. yum安装gcc相关

   yum -y install gcc
   yum -y install gcc-c++
   

4. 安装需要的软件包

   安装仓库：

   sudo yum install -y yum-utils
   
   # 这个得开外网，不要执行
   sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
   
   # 阿里云
   yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
   

5. 设置stable镜像仓库

   就是上面的那个阿里云仓库

6. 更新yum软件包索引

   yum makecache fast
   

7. 安装DOCKER CE

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

8. 启动docker

   sudo systemctl start docker
   

9. 测试

   检查docker是否成功启动：

   ps -ef| grep docker
   

   跑一个helloworld：

   sudo docker run hello-world
   

10. 卸载

    systemctl stop docker
    
    yum remove docker-ce docker-ce-cli containerd.io
    
    rm -rf /var/lib/docker
    
    rm -rf /var/lib/containerd
    

12-镜像加速器配置

https://promotion.aliyun.com/ntms/act/kubernetes.html

我的加速器地址：自己找

粘命令完事了

13-helloworld分析介绍3要素配合

docker run hello-world

本地没有镜像就会去远端下载镜像，运行完后容器自动终止。

1. run干了什么

此时，helloworld的镜像就存到了本地

14-为什么Docker会比VM虚拟机快

1. docker 有着比虚拟机更少的抽象层
2. docker 利用的是宿主机的内核，而不需要加载操作系统OS内核

15-帮助启动类命令

启动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

16-镜像命令

列出本地主机上的镜像：

sudo docker images

-a: 列出本地所有的镜像
-q: 只显示镜像ID

搜寻某个镜像：

sudo docker search 镜像名称

--limit: 只列出N个镜像，默认25个

拉取(下载)某个镜像：

sudo docker pull 镜像名称[:TAG]

查看镜像/容器/数据卷所占的空间：

sudo docker system df

删除某个镜像：

sudo docker rmi 某个镜像的ID或名字

-f: 强制删除单个
-f 镜像1 镜像2 ... : 强制删除多个
-f $(docker images -qa): 强制删除全部

docker的虚悬镜像：仓库名、标签都是的镜像，俗称虚悬镜像(dangling image)

17-ubuntu容器说明

18-容器命令A

新建+启动容器：

sudo docker run 镜像名

--name="容器的新名字": 为容器指定一个名称
-d: 后台运行容器并返回容器ID，即启动守护式容器(后台运行)
-i: 以交互模式运行容器，通常与 -t 同时使用
-t: 为容器重新分配一个伪输入终端，通常与 -i 同时使用，即启动交互式容器(前台有伪终端，等待交互)
-P: 随机端口映射，大写P
-p: 指定端口映射，小写p

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

sudo docker ps

-a: 列出当前所有正在运行的容器+历史上运行过的
-l: 显示最近创建的容器
-n: 显示最近n个创建的容器
-q: 静默模式，只显示容器编号

19-容器命令B

退出容器：

exit: 容器停止

ctrl+p+q: 容器不停止

启动已停止运行的容器：

sudo docker start 容器ID或容器名

重启容器：

sudo docker restart 容器ID或容器名

停止容器：

sudo docker stop 容器ID或容器名

强制停止容器：

sudo docker kill 容器ID或容器名

删除已停止的容器：

sudo docker rm 容器ID或容器名

-f: 强制删除

一次性删除多个容器实例：

sudo docker rm -f $(docker ps -a -q)
或
sudo docker ps -a -q | xargs docker rm

20-容器命令C

21-容器命令D

启动守护式容器：大部分场景下，我们希望 docker 的服务是在后台运行的，可以通过 -d 指定容器的后台运行模式。

sudo docker run -d 容器名

docker 容器后台运行，就必须有一个前台进程

容器运行的命令如果不是那些一直挂起的命令（比如运行top，tail），就会自动退出

一般建议 -it bash

redis、mysql建议 -d

看 redis 后台日志：

sudo docker logs 容器ID

查看某个容器里的运行的进程：

sudo docker top 容器ID

查看容器内部细节：

sudo docker inspect 容器ID

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

# 一般用 exec
sudo docker exec -it 容器ID bash  # 容器不会导致停止

sudo docker attach 容器ID

22-容器命令E

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

sudo docker cp 容器ID:容器内路径 目标主机路径

导入和导入容器：

export 导出容器的内容留作为一个 tar 归档文件[对应 import 命令]

import 从 tar 包中的内容创建一个新的文件系统再导入为镜像[对应 export 命令]

sudo docker export 容器ID > 文件名.tar

# 把 tar 包变成镜像
sudo cat 文件名.tar | docker import - 镜像用户/镜像名:镜像版本号

23-镜像的分层概念

镜像是一种轻量级、可执行的独立软件包，它包含运行某个软件所需的所有内容，我们把应用程序和配置依赖打包好形成一个可交付的运行环境(包括代码、运行时需要的库、环境变量和配置文件等)，这个打包好的运行环境就是image镜像文件。

只有通过这个镜像文件才能生成Docker容器实例。

UnionFS(联合文件系统)：Union文件系统是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下。Union文件系统是Docker镜像的基础。镜像可以通过分层来进行继承，基于基础镜像(没有父镜像)，可以制作各种具体的应用镜像。

特性：一次同时加载多个文件系统，但从外表看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录。

Docker镜像加载原理：

docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFs。

bootfs(boot file system)主要包含bootloader和kernel，bootloader主要是引导加载kernel，Linux刚启动时会加载bootfs文件系统，在Docker镜像的最底层是引导文件系统bootfs。这一层与我们典型的Linux/Unix系统是一样的，包含boot加载器和内核。当boot加载完成之后整个内核就都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs。

rootfs(root file system)，在bootfs之上，包含的就是典型Linux系统中的**/dev**, /proc, /bin, /etc 等标准目录和文件。rootfs就是各种不同操作系统的发行版，比如centos等等。

镜像分层最大的一个好处就是共享资源，方便复制迁移，就是为了复用。

镜像层是只读的，容器层是可写的。当容器启动时，一个新的可写层通常被称作“容器层”，“容器层”之下都叫“镜像层”。

24-commit命令

提交容器副本使之成为一个新的镜像：

sudo docker commit
sudo docker commit -m="提交的描述信息" -a="作者" 容器ID 要创建的目标镜像名:[标签名]

25-本地镜像发布到阿里云

26-docker私有库简介

27-新镜像推送私有库案例

默认情况下，仓库被创建在容器的 /var/lib/registry 目录下，建议使用容器卷映射，方便宿主机联调。

docker 默认不允许 http 方式推送镜像，需要通过配置选项来取消这个限制。修改完不生效，建议重启docker。

28-容器数据卷是什么

将docker容器内的数据保存进宿主机的磁盘中

容器卷操作：

# 增加容器卷
sudo docker volume create 容器卷名称

# 查看所有容器卷
sudo docker volume ls

# 删除不被使用的容器卷
sudo docker volume prune

run的时候，容器卷记得加入：

--privileged=true # 使容器内的root拥有所有权限

29-容器数据卷能干嘛

特点：

1. 数据卷可在容器之间共享或重用数据
2. 卷中的更改可以直接实时生效
3. 数据卷中的更改不会包含在镜像更新中
4. 数据卷的生命周期一直持续到没有容器使用它为止

30-容器卷和主机互通互联

1. 宿主机vs容器之间映射添加容器卷

   docker run -it --privileged=true -v /宿主机绝对路径目录(或者数据卷名称):/容器内目录 镜像名
   
   # -v 可以挂载多个
   

   查看数据卷是否挂在成功：

   docker inspect 容器ID
   

   容器和宿主机之间数据共享

31-容器卷ro和rw读写规则

容器里的只读：

docker run -it --privileged=true -v /宿主机绝对路径目录(或者数据卷名称):/容器内目录:ro 镜像名

宿主机可以写东西，但容器内不行

32-容器卷之间的继承

docker run -it --privileged=true --volumes-from 父类 --name 容器名 镜像名

33-docker上安装常用软件说明

1. 搜索镜像：search
2. 拉取镜像：pull
3. 查看镜像：docker images
4. 启动镜像：docker run
5. 停止容器：docker stop
6. 移除容器：docker rm

34-tomcat安装

1. docker hub 上面查找tomcat镜像

2. 从docker hub上拉取tomcat镜像到本地

3. docker images查看是否有拉取到的tomcat

4. 使用tomcat镜像创建容器实例

   

5. 访问tomcat首页

6. 免修改版说明

   docker pull billygoo/tomcat8-jdk8
   
   docker run -d -p 8080:8080 --name mytomcat8 billygoo/tomcat8-jdk8
   

35-mysql安装

1. search

2. pull 指定版本的mysql

3. docker run --name 容器名 --privileged=true -p 3306:3306 -e MYSQL_ROOT_PASSWORD=mysql的root密码 -d -v 指定数据卷/data:/var/lib/mysql -v 指定数据卷/log:/var/log/mysql -v 指定数据卷/conf:/etc/mysql/conf.d 镜像名
   

高级版(解决中文乱码)：

上面步骤三；

容器内 cd 指定数据卷/conf，新建my.cnf；

vim my.cnf;

输入：

[client]
default_character_set=utf8
[mysqld]
collation_server = utf8_general_ci
character_set_server = utf8

改完重启容器：docker restart 容器名

docker安装完MYSQL并run出容器后，建议请先修改完字符集编码后再新建mysql库-表-插数据

36-redis常规安装

redis:6.0.8

端口：6379

容器卷记得加入 --privileged=true

构建redis容器实例：

docker run -p 6379:6379 --name redis111 --privileged=true -v /var/lib/docker/volumes/redis_volume/redis_conf/redis.conf:/etc/redis/redis.conf -v /var/lib/docker/volumes/redis_volume/redis_data:/data -d redis:6.0.8 redis-server /etc/redis/redis.conf

修改宿主机的配置文件，然后restart容器，进行测试redis是否使用的是我们自己设置的配置文件

37-高级篇简介

38-mysql主从复制docker版

docker 复杂安装

安装mysql主从复制：

安装主mysql：

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

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

# 建立一个用户
CREATE USER 'slave'@'%' IDENTIFIED BY '111111';
# 给用户授权
GRANT REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'slave'@'%';

安装从mysql：

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

配置从机my.cnf文件

重启从机

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

show master status;

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

change master to master_host='124.222.159.107',master_user='slave',master_password='111111',master_port=3307,master_log_file='mall-mysql-bin.000001',master_log_pos=711,master_connect_retry=30;

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

show slave status \G;

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

start slave;

主从复制测试：

主数据库建库、建表、插数据；从数据库查询数据。

39-分布式存储之哈希取余算法

假设有3台机器构成一个集群，用户每次读写操作都是根据公式：

hash(key) % N 个机器台数，计算出hash值，用来决定数据映射到哪一个节点上。

优点：

简单粗暴，使用Hash算法让固定的一部分请求落到同一台服务器上，这样每台服务器固定处理一部分请求（并维护这些请求的信息），起到负载均衡+分而治之的作用。

缺点：

原来规划好的节点，进行扩容或缩容就比较麻烦了，并且扩容或缩容导致原来的取模公式发生变化。

40-分布式存储之一致性哈希算法

设计目标：

为了解决分布式缓存数据变动和映射问题，某个机器宕机了，分母数量改变，自然取余数就不行了。

3大步骤：

1. 算法构建一致性哈希环；
2. 服务器IP节点映射；
3. key落到服务器的落键规则。

优点：

1. 容错性：

一个服务器挂了，受影响的数据仅仅是此服务器到其环空间中前一台服务器。

2. 扩展性：

缺点：

**一致性哈希算法的数据倾斜问题：**如果服务节点太少，容易因为节点分布不均匀而造成数据倾斜（被缓存的对象大部分集中缓存在某一台服务器上）问题，例如系统中只有两台服务器。

41-分布式存储之哈希槽算法

解决均匀分配的问题，在数据和节点之间又加入了一层，把这层称为哈希槽（slot），用于管理数据和节点之间的关系，现在就相当于节点上放的是槽，槽里放的是数据。

槽解决的是粒度问题，相当于把力度变大，这样便于数据移动。

一个集群只能有16384个槽，编号(0~16383)。

slot=CRC16(key) % 16384

为什么mod16384？

额。。。暂时还看不懂

42-3主3从redis集群配置

1. 关闭防火墙，启动docker后台服务

2. 新建6个docker容器实例

   docker run -d --name redis-node-1 --net host --privileged=true -v /var/lib/docker/volumes/redis_volume/redis-node-1:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6381
   docker run -d --name redis-node-2 --net host --privileged=true -v /var/lib/docker/volumes/redis_volume/redis-node-2:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6382
   docker run -d --name redis-node-3 --net host --privileged=true -v /var/lib/docker/volumes/redis_volume/redis-node-3:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6383
   docker run -d --name redis-node-4 --net host --privileged=true -v /var/lib/docker/volumes/redis_volume/redis-node-4:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6384
   docker run -d --name redis-node-5 --net host --privileged=true -v /var/lib/docker/volumes/redis_volume/redis-node-5:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6385
   docker run -d --name redis-node-6 --net host --privileged=true -v /var/lib/docker/volumes/redis_volume/redis-node-6:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6386
   
   docker run -d --name redis-node-7 --net host --privileged=true -v /var/lib/docker/volumes/redis_volume/redis-node-7:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6387
   docker run -d --name redis-node-8 --net host --privileged=true -v /var/lib/docker/volumes/redis_volume/redis-node-8:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6388
   

   

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

   1. 进入容器，进redis的命令：redis-cli -p 6381

   2. 构建主从关系

      redis-cli --cluster create 124.222.159.107:6381 124.222.159.107:6382 124.222.159.107:6383 124.222.159.107:6384 124.222.159.107:6385 124.222.159.107:6386 --cluster-replicas 1
      
      --cluster-replicas 1 # 表示为每个master创建一个slave节点
      

      效果：

      

   3. 一切ok的话，3主3从搞定

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

   1. 查看节点状态
   2. cluster info
   3. cluster nodes

43-redis集群读写error说明

主从容错切换迁移案例：

1. 数据读写存储

   1. 启动6机构成的集群并通过exec进入

   2. 对6381新增两个key

   3. 防止路由失效加参数 -c 并新增两个key

      redis-cli -p 6381 -c
      

      效果：

      

      一直在自动重定向：

      

   4. 查看集群信息

      redis-cli --cluster check 124.222.159.107:6381
      

2. 容错切换迁移(自动的)

   

   

   老领导(master, fail)回来秒变奴隶(slave)

   再把现在的master停了，slave就重新上位了

44-redis集群读写路由增强正确案例

直接看43章

45-查看集群信息cluster check

直接看43章

46-主从容错切换迁移

直接看43章

47-主从扩容需求分析

3主3从扛不住了，所以变成4主4从(6387，6388)

48-主从扩容案例演示

1. 新建6387、6388两个节点+新建后启动+查看是否8节点

2. 进入6387容器实例内部

3. 将新增的6387节点(空槽号)作为master节点加入原集群

   redis-cli --cluster add-node 124.222.159.107:6387 124.222.159.107:6381
   
   6387 就是将要作为master新增节点
   6381 就是原来集群节点里面的领路人
   

   效果：

   

4. 检查集群情况第1次

   redis-cli --cluster check 124.222.159.107:6381
   

5. 重新分派槽号

   redis-cli --cluster reshard 124.222.159.107:6381
   

6. 检查集群情况第2次

7. 为主节点6387分配从节点6388

   redis-cli --cluster add-node 124.222.159.107:6388 124.222.159.107:6387 --cluster-slave --cluster-master-id 新master的id
   

8. 检查集群情况第3次

49-主从缩容需求分析

流量高峰下去了，所以缩容

删掉6387和6388

步骤：

1. 先清除从节点6388；
2. 清出来的槽号重新分配；
3. 再删除6387；
4. 恢复成3主3从

50-主从缩容案例演示

目的：6387和6388下线

1. 检查集群情况第1次，获得6388的节点ID

   redis-cli --cluster check 124.222.159.107:6381
   

2. 将6388删除，从集群中将4号从节点6388删除

   redis-cli --cluster del-node 124.222.159.107:6388 从机6388节点ID
   

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

   redis-cli --cluster reshard 124.222.159.107:6381
   

4. 检查集群情况第2次

5. 将6387删除

   redis-cli --cluster del-node 124.222.159.107:6387 6387节点ID
   

6. 检查集群情况第3次

51-分布式存储案例小总结

52-Dockerfile简介

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

构建三步骤：

1. 编写Dockerfile文件
2. docker build命令构建镜像
3. docker run依镜像运行容器实例

53-Dockerfile构建过程解析

Dockerfile 内容基础知识：

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

Docker执行Dockerfile的大致流程：

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

54-Dockerfile保留字简介

• FROM： 继承的父类，指定一个已存在的镜像作为模板

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

• RUN：

  • 容器构建时需要运行的命令
  • 两种格式：
    • shell格式
    • exec格式
  • RUN 是在docker build时运行

• EXPOSE： 当前容器对外暴露出的端口

• WORKDIR： 指定在创建容器后，终端默认登陆进来的工作目录，一个落脚点

• USER： 指定该镜像以什么样的用户去执行，默认root

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

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

• COPY：

  • 类似ADD，拷贝文件和目录到镜像中
  • 将从构建上下文目录中<源路径>的文件/目录复制到新的一层的镜像内的<目标路径>位置
    • COPY src dest
    • COPY [“src”, “dest”]
    • <src源路径>：源文件或者源目录
    • <dest目标路径>：容器内的指定路径，该路径不用事先建好

• VOLUME： 数据卷，用于数据保存和持久化工作

• CMD：

  • 指定容器启动后的要干的事情
  • 注意
    • Dockerfile中可以有多个CMD命令，但只有最后一个生效，CMD会被docker run之后的参数替换
  • 与RUN命令的区别
    • CMD是在docker run时运行
    • RUN是在docker build时运行

• ENTRYPOINT：

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

  • 类似于CMD，但不会被docker run后面的参数覆盖，并且这些参数会被当作参数送给ENTRYPOINT指令指定的程序

55-centos之Dockerfile需求说明

56-centos之Dockerfile案例演示

57-虚悬镜像

查看本地所有虚悬镜像：

docker image ls -f dangling=true

删除虚悬镜像：

docker image prune

58-新建微服务工程(Go)

运行命令：

GOOS=linux GOARCH=amd64 go build main.go

59-Dockerfile发布微服务部署到docker容器

1. IDEA工具里面搞定微服务jar包
2. 编写Dockerfile
   1. Dockerfile内容
   2. 将微服务jar包和Dockerfile文件上传到同一个目录下/mydocker
3. 构建镜像
   1. docker build -t 项目名:标签名
   2. 打包成镜像文件
4. 运行容器
5. 访问测试

60-测试容器上的微服务

61-docker network简介

docker 启动会产生一个名为 docker0 的虚拟网桥。

62-docker network常用命令

查看docker网络模式命令：

docker network ls

效果：

默认创建3大网络模式：bridge(主要使用)、host、none

创建docker网络(默认bridge模式)：

docker network create 网络名

查看网络源数据：

docker network inspect 网络名

删除网络：

docker network rm 网络名

所有命令：

63-docker network能干吗

• 容器间的互联和通信以及端口映射
• 容器IP变动时候可以通过服务名直接网络通信而不受影响

64-docker network网络模式有几种

bridge

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

host

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

none

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

container

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

总体介绍：

• bridge模式：使用–network bridge指定，默认使用docker0
• host模式：使用–network host指定
• none模式：使用–network none指定
• container模式：使用–network container:NAME或者容器ID指定

65-docker network底层ip和容器映射变化

底层的网络是会变动的。

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

66-docker network之bridge

检查某个网络：

docker network inspect 网络名

查看bridge网络的详细信息，并通过grep获取名称项：

docker network inspect bridge | grep name

两两匹配

67-docker network之host

直接使用宿主机的IP地址与外界进行通信，不再需要额外进行NAT转换。

与宿主机共用一个Network Namespace

68-docker network之none

禁用网络功能，只有lo标识(就是127.0.0.1标识本地回环)。

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

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

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

69-docker network之container

新建的容器和已存在的一个容器共享一个网络ip配置而不是和宿主机共享。

70-docker network之自定义网络

避免docker容器的ip地址动态变化

由于在同一个网段，所以ip互相ping能够ping通，但服务ping不通

引入自定义网络后，服务名即便ip不相同也可以互相ping

一定要写死服务名，但不能写死IP

问题结论：

自定义网络本身就维护好了主机名和ip的对应关系（ip和域名都能ping通）

71-compose是什么能干嘛

Docker-Compose是Docker官方的开源项目，负责实现对Docker容器集群的快速编排。

Compose可以管理多个Docker容器组成一个应用。

你需要定义一个yaml文件来作为配置文件，即docker-compose.yml，写好多个容器之间的调用关系。

然后，只要一个命令，就能同时启动/关闭这些容器。

docker建议每一个容器中只运行一个服务。

但这样会导致，每部署一个服务就要写一个Dockerfile文件，然后构建镜像、构建容器，十分不方便。

所以，官方提供了docker-compose多服务部署的工具。

Compose允许用户通过一个单独的docker-compose.yml模板文件，来定义一组相关联的应用容器为一个项目。

72-compose下载安装步骤

官网：https://docs.docker.com/compose/compose-file/compose-file-v3/

官网下载：https://docs.docker.com/compose/install/

安装步骤：

1. curl -SL https://github.com/docker/compose/releases/download/v2.18.1/docker-compose-linux-x86_64 -o /usr/local/bin/docker-compose
   

2. 开启可执行权限

   chmod +x /usr/local/bin/docker-compose
   

3. 查看是否安装成功

   docker-compose --version
   

卸载步骤：

rm /usr/local/bin/docker-compose(compose所在路径)

73-compose核心概念

一文件：

• docker-compose.yml

两要素：

• 服务(service)：一个个应用容器实例，比如订单微服务、库存微服务、mysql容器、nginx容器
• 工程(project)：有一组关联的应用容器组成的一个完整业务单元，在docker-compose.yml文件中定义。

三个步骤：

• 编写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 ps					# 展示当前docker-compose编排过的运行的所有容器
docker-compose top					# 展示当前docker-compose编排过的容器进程

docker-compose logs yml里面的服务id	 # 查看容器输出日志
docker-compose config				# 检查配置
docker-compose config -q			# 检查配置，有问题才有输出
docker-compose restart				# 重启服务
docker-compose start				# 启动服务
docker-compose stop					# 停止服务

74-微服务改造升级并生成新镜像

75-不用compose编排服务

76-使用compose编排服务

77-Portainer简介和安装

Portainer 是一款轻量级的应用，它提供了图形化界面，用于方便地管理Docker环境，包括单机环境和集群环境(建议k8s)。

官网：https://www.portainer.io/

https://www.portainer.io/v/ce-2.9/start/install/server/docker/linux

步骤：

下载：

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-ce

第一次登录需创建admin，访问地址：xxxx:9000

设置admin用户和密码后首次登陆

选择local选项卡后本地docker详细信息展示

78-Portainer常规操作

安装nginx

79-Portainer补充说明

–restart=always

意思是，docker重启了，portainer也会跟着重启

80-CIG容器重量级监测系统介绍

cAdvisor：监控、收集数据，只能存储2min的数据

InfluxDB：一种分布式数据库

Grafana：一个数据监控可视化平台

81-CIG结合Compose一键搭建监控平台

docker-compose.yml文件编写

官网直接replicate下来

启动docker-compose文件

82-CIG三平台登陆验证通过

输入socket就行，三个都有可视化界面

83-CIG添加panel

84-CIG配置监控业务规则

键部署上线

# 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 ps					# 展示当前docker-compose编排过的运行的所有容器
docker-compose top					# 展示当前docker-compose编排过的容器进程

docker-compose logs yml里面的服务id	 # 查看容器输出日志
docker-compose config				# 检查配置
docker-compose config -q			# 检查配置，有问题才有输出
docker-compose restart				# 重启服务
docker-compose start				# 启动服务
docker-compose stop					# 停止服务

74-微服务改造升级并生成新镜像

[外链图片转存中…(img-5IwUH5w7-1686195940407)]

75-不用compose编排服务

76-使用compose编排服务

[外链图片转存中…(img-52I7hDm1-1686195940407)]

77-Portainer简介和安装

Portainer 是一款轻量级的应用，它提供了图形化界面，用于方便地管理Docker环境，包括单机环境和集群环境(建议k8s)。

官网：https://www.portainer.io/

https://www.portainer.io/v/ce-2.9/start/install/server/docker/linux

步骤：

下载：

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-ce

第一次登录需创建admin，访问地址：xxxx:9000

设置admin用户和密码后首次登陆

选择local选项卡后本地docker详细信息展示

78-Portainer常规操作

安装nginx

79-Portainer补充说明

–restart=always

意思是，docker重启了，portainer也会跟着重启

80-CIG容器重量级监测系统介绍

cAdvisor：监控、收集数据，只能存储2min的数据

InfluxDB：一种分布式数据库

Grafana：一个数据监控可视化平台

81-CIG结合Compose一键搭建监控平台

docker-compose.yml文件编写

官网直接replicate下来

启动docker-compose文件

82-CIG三平台登陆验证通过

输入socket就行，三个都有可视化界面

83-CIG添加panel

84-CIG配置监控业务规则

85-终章，总结