Docker入门学习_docker学习

一、docker是什么：

​ docker是基于go语言实现的云开源项目。主要目标是“build, ship and run any app, anywhere”，也就是通过对应用组件的封装、分发、部署、运行等生命周期的管理，使用户的应用及其运行环境能够做到“一次镜像，处处运行”。解决了运行环境和配置问题的软件容器，方便做持续集成并有助于整体发布的容器虚拟化技术。

二、docker的基本组成：

1、镜像（image）：

就是一个只读的模板。镜像可以用来创建docker容器。一个镜像可以创建多个docker容器。docker镜像文件类似java的类模板，而docker容器实例类似于java中new出来的实例对象。

2、容器（container）：

docker利用容器独立运行一个或一组应用，应用程序或服务运行在容器里，容器就类似一个虚拟的运行环境，容器是用镜像创建的运行实例。每个容器都是相互隔离的，保证平台的安全。

3、仓库（repository）：

是集中存放镜像文件的场所。仓库分为公开库和私有库。

三、docker安装（centOS7）

1、确定版本是centOS7及以上版本

cat /etc/redhat-release
1

2、卸载旧版本docker

yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine
1
2
3
4
5
6
7
8

3、yum安装gcc相关（虚拟机能连外网）

yum -y install gcc
1

yum -y install gcc-c++
1

4、安装需要的软件包

yum install -y yum-utils
1

5、设置stable镜像仓库

管网要求：（网络请求很慢）

yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
1

我们自己：（强烈推荐）

yum-config-manager --add-repo  http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
1

6、更新yum软件包索引

yum makechache fast
1

7、安装docker ce

 yum -y install docker-ce docker-ce-cli containerd.io docker-compose-plugin
1

8、启动docker

systemctl start docker
1

四、命令：

1、帮助启动类命令：

2、镜像命令：

3、容器命令：

五、镜像发布

1、本地镜像发布到阿里云

1.1、登陆阿里云，进入控制台-容器镜像服务-实例列表-个人实例

1.2、创建命名空间

1.3、创建镜像仓库

1.4、点击刚创建的镜像仓库mydemo，运行操作指南中的命令进行相关操作

2、本地镜像发布到私有库

2.1、下载私有库镜像

docker pull registry
1

2.2、运行私有库，相当于本地有一个私有docker hub

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

2.3、查询私服库存在的镜像：

curl -XGET http://192.168.100.2:5000/v2/_catalog
1

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

命令：docker tag [镜像名]:[标签名] [主机]:[端口]/[镜像名]:[标签名]

docker tag redis:1.1 192.168.100.2:5000/redis:1.1
1

2.5、修改配置文件daemon.json使其支持http

​ 2.5.1、编辑文件：vi /etc/docker/daemon.json

​ 2.5.2、添加内容：“insecure-registries”:[“192.128.100.2:5000”]

注：docker默认不允许http方式推送镜像，通过以上配置选项来取消这个限制。—>修改完成后如果不生效，建议重启docker

2.6、推送镜像到私服库

docker push 192.168.100.2:5000/redis:1.1
1

2.7、从私服库下载镜像

docker pull 192.168.100.2:5000/redis:1.1
1

六、容器卷

1、是什么：

​ 卷就是目录或者文件，存在于一个或多个容器中，由docker挂在到容器，但不属于联合文件系统，因此能绕过union file system提供一些用于持续存储或者数据共享的特性。

​ 卷的设计目的就是数据的持久化，完全独立于容易的生命周期，因此docker不会在容器删除时，删除其挂载的数据卷。（将docker容器内的数据保存进宿主机的磁盘中）

2、特性：

​ 2.1、数据卷可以在容器之间共享或重用数据

​ 2.2、卷中的更改可以直接实时生效

​ 2.3、数据卷中的更改不会包含在镜像的更新中

​ 2.4、数据卷的生命周期一直持续到没有容器使用它为止

3、创建带有容器卷的容器实例：

命令：docker run -d -p 5000:5000 -v [/宿主机绝对路径]:[/容器内目录] --privileged=true [镜像名]

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

4、查看是否挂载成功

命令：docker inspect [容器ID]

5、容器内读写规则：

​ 5.1、默认规则可读可写（容器内目录后不写或者加上 :rw）：

命令：docker run -d -p 5000:5000 -v [/宿主机绝对路径]:[/容器内目录]:rw --privileged=true [镜像名]

​ 5.2、容器实例内部限制为只读（:ro）：

命令：docker run -d -p 5000:5000 -v [/宿主机绝对路径]:[/容器内目录]:ro --privileged=true [镜像名]

6、卷的继承

1、创建容器1

docker run -it -v /chenll/myregistry/:/tmp/u --privileged=true --name u1 ubuntu
1

2、创建容器2继承容器1的卷规则

命令：docker run -it --volumes-from [父类容器名] --privileged=true --name u2 ubuntu

docker run -it --volumes-from u1 --privileged=true --name u2 ubuntu
1

七、实操

1、安装mysql（主从复制）

1.1、新建主服务器容器3307

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

1.2、进入/chenll/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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

1.3、修改完配置文件后重启mater实例

docker restart mysql-master
1

1.4、进入mysql-master容器

docker exec -it mysql-master /bin/bash
1

mysql -uroot -p
##下一步输入密码：root
1
2

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

-- 创建用户
create user 'slave'@'%' identified by '123456';
-- 授权
grant replication slave,replication client on *.* to 'slave'@'%';
1
2
3
4

1.6、新建从服务器容器3308

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

1.7、进入/chenll/mydata/mysql-slave/conf目录下创建my.cnf，内容如下（直接复制）

[mysqld]

## 设置server_id，同一局域网中需要唯一

server_id=102

## 指定不需要同步的数据库名称

binlog-ignore-db=mysql 

## 开启二进制日志功能，以备Slave作为其它数据库实例的Master时使用

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

1.8、修改完配置文件后重启slave实例

docker restart mysql-slave
1

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

show master status;
1

1.10、进入mysql-slave容器

docker exec -it mysql-slave /bin/bash
1

mysql -uroot -p
#下一步输入密码：root
1
2

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

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

master_host：主数据库的IP地址；

master_port：主数据库的运行端口；

master_user：在主数据库创建的用于同步数据的用户账号；

master_password：在主数据库创建的用于同步数据的用户密码；

master_log_file：指定从数据库要复制数据的日志文件，通过查看主数据的状态，获取File参数；

master_log_pos：指定从数据库从哪个位置开始复制数据，通过查看主数据的状态，获取Position参数；

master_connect_retry：连接失败重试的时间间隔，单位为秒。

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

show slave status\G;
1

1.13、在从数据库开启主从同步

start slave;
1

1.14、验证主从效果

2、安装redis

2.1、下载redis

docker pull redis
1

2.2、宿主机创建数据卷共享目录

mkdir /chenll/myredis
1

2.3、复制一份redis.conf配置文件并修改

​ a、注释掉 #bind 127.0.0.1，允许redis外地连接

​ b、设置daemonize no，因为该配置和docker run中-d参数冲突，会导致容器一直启动失败

​ c、开启redis数据持久化 appendonly yes

2.4、创建容器

docker run -d -p 6379:6379 --privileged=true 

-v /chenll/myredis/redis.conf:/etc/redis/redis.conf 

-v /chenll/myredis/data:/data 

--name redis redis:6.0.8 redis-server /etc/redis/redis.conf
1
2
3
4
5
6
7

2.5、进入容器

docker exec -it redis /bin/bash
1

redis-cli
1

3、安装redis集群（3主3从）

3.1、创建6个docker容器redis实例

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

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

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

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

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

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

最终运行结果如下图：

3.2、进入其中一个容器，并构建主从关系

​ 3.2.1、进入：

docker exec -it redis-node-1 /bin/bash
1

​ 3.2.2、构建：

redis-cli --cluster create 192.168.100.2:6381 192.168.100.2:6382 192.168.100.2:6383 192.168.100.2:6384 192.168.100.2:6385 192.168.100.2:6386 --cluster-replicas 1
1

执行效果：

​ 3.3.3、输入yes

注意：集群环境进入命令 redis-cli -p 6381 -c，可防止路由失效，导致存取数据失败

4、redis主从扩容案例（4主4从）

4.1、新建6387、6388节点

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

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

4.2、进入6387容器实例内部

docker exec -it redis-node-7 /bin/bash
1

4.3、将新增的6387作为master节点加入集群

redis-cli --cluster add-node [自己实际IP地址]:6387 [自己实际IP地址]:6381

redis-cli --cluster add-node 192.168.100.2:6387 192.168.100.2:6381
1

6387 就是将要作为master新增节点

6381 就是原来集群节点里面的领路人，相当于6387拜拜6381的码头从而找到组织加入集群

4.4、检查集群情况（第1次）

redis-cli --cluster check 真实ip地址:6381

redis-cli --cluster check 192.168.100.2:6381
1

4.5、重新分配槽号

redis-cli --cluster reshard IP地址:端口号

redis-cli --cluster reshard 192.168.100.2:6381
1

4096：16384 / 4，平均每台分配的槽位数量

node id：分配给6397，需要输入6387的ID

后续输入yes，开始分配槽位

4.6、检查集群情况（第2次）

redis-cli --cluster check 192.168.100.2:6381
1

发现：6381、6382、6383三个旧节点分别匀出1364个槽位给新节点6387

4.7、为主节点6387分配从节点6388

redis-cli --cluster add-node ip:新slave端口 ip:新master端口 --cluster-slave --cluster-master-id 新主机节点ID

redis-cli --cluster add-node 192.168.100.2:6388 192.168.100.2:6387 --cluster-slave --cluster-master-id ffc8e85b3d9b58bfe98e31a256a1cb312a721163
1

-------这个是6387的编号，按照自己实际情况

4.8、检查集群情况（第3次）

redis-cli --cluster check 192.168.100.2:6381
1

5、redis主从缩容案例

5.1、检查集群情况，获取从节点6388的ID（第1次）

redis-cli --cluster check 192.168.100.2:6381
1

5.2、在集群中删除从节点6388

redis-cli --cluster del-node ip:从机端口 从机6388节点ID

redis-cli --cluster del-node 192.168.100.2:6388 6395110bfa44bc502ffd47f3fe209d677da35940
1

5.3、将主节点6387的槽位清空，重新分配

redis-cli --cluster reshard 192.168.100.2:6381
1

5.4、检查集群情况（第2次）

redis-cli --cluster check 192.168.100.2:6381
1

5.5、删除主节点6387

redis-cli --cluster del-node ip:端口 6387节点ID

redis-cli --cluster del-node 192.168.100.2:6387 ffc8e85b3d9b58bfe98e31a256a1cb312a721163
1

5.6、检查集群情况（第3次）

redis-cli --cluster check 192.168.100.2:6381
1

八、Dockerfile解析

1、是什么

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

2、Dockerfile内容基础知识

2.1、每条保留字指令都必须为大写字母且后面要跟随至少一个参数

2.2、指令按照从上到下，顺序执行

2.3、#表示注释

2.4、每条指令都会创建一个新的镜像层并对镜像进行提交

3、Dockerfile的大致流程

3.1、docker从基础镜像运行一个容器

3.2、执行一条指令并对容器作出修改

3.3、执行类似docker commit的操作提交一个新的镜像层

3.4、docker再基于刚提交的镜像运行一个新容器

3.5、执行dockerfile中的下一条指令直到所有指令都执行完成

4、Dockerfile常用保留字指令（大写）

构建指令：

docker build -t [新镜像名]:[标签名] .
1

注意：上面标签名后面有个空格和 .

5、虚悬镜像dangling iamge

5.1、是什么

docker构建或删除过程出现异常，导致镜像的仓库和标签名都是< none >。

5.2、查看虚悬镜像

docker image ls -f dangling=true
1

5.3、删除虚悬镜像

docker image prune
1

6、Dockerfile发布微服务到docker容器

6.1、准备一个可运行的微服务，并打成jar包

6.2、编写Dockerfile文件

# 基础镜像使用java

FROM java:8

# 作者

MAINTAINER chenll

# VOLUME 指定临时文件目录为/tmp，在主机/var/lib/docker目录下创建了一个临时文件并链接到容器的/tmp

VOLUME /tmp

# 将jar包添加到容器中并更名为chenll_docker.jar

ADD docker_boot-0.0.1-SNAPSHOT.jar chenll_docker.jar

# 运行jar包

RUN bash -c 'touch /chenll_docker.jar'

ENTRYPOINT ["java","-jar","/chenll_docker.jar"]

#暴露6001端口作为微服务

EXPOSE 6001
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

6.3、jar包和Dockerfile文件放在同一个目录下，并运行命令

docker build -t chenll_docker:1.0.0 .
1

6.4、启动

docker run -d -p 6001:6001 --name=chenll_docker --net host  chenll_docker:1.0.0
1

九、docker network

1、基础命令：

docker network --help 查看所有命令

2、能干嘛

2.1、容器间的互联、通信以及端口映射

2.2、容器ID变动时可以通过服务名直接网络通信而不受到影响

3、网络模式

3.1、简介

3.2、bridge

​ Docker 服务默认会创建一个 docker0 网桥（其上有一个 docker0 内部接口），该桥接网络的名称为docker0，它在内核层连通了其他的物理或虚拟网卡，这就将所有容器和本地主机都放到同一个物理网络。Docker 默认指定了 docker0 接口 的 IP 地址和子网掩码，让主机和容器之间可以通过网桥相互通信。

​ 3.2.1、Docker使用Linux桥接，在宿主机虚拟一个Docker容器网桥(docker0)，Docker启动一个容器时会根据Docker网桥的网段分配给容器一个IP地址，称为Container-IP，同时Docker网桥是每个容器的默认网关。因为在同一宿主机内的容器都接入同一个网桥，这样容器之间就能够通过容器的Container-IP直接通信。

​ 3.2.2、docker run 的时候，没有指定network的话默认使用的网桥模式就是bridge，使用的就是docker0。在宿主机ifconfig,就可以看到docker0和自己create的network(后面讲)eth0，eth1，eth2……代表网卡一，网卡二，网卡三……，lo代表127.0.0.1，即localhost，inet addr用来表示网卡的IP地址

​ 3.2.3、网桥docker0创建一对对等虚拟设备接口一个叫veth，另一个叫eth0，成对匹配。

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

 3.2.3.2、每个容器实例内部也有一块网卡，每个接口叫eth0；

 3.2.3.3、docker0上面的每个veth匹配某个容器实例内部的eth0，两两配对，一一匹配。
1
2
3

通过上述，将宿主机上的所有容器都连接到这个内部网络上，两个容器在同一个网络下,会从这个网关下各自拿到分配的ip，此时两个容器的网络是互通的。

3.3、host

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

​ 容器将不会获得一个独立的Network Namespace， 而是和宿主机共用一个Network Namespace。容器将不会虚拟出自己的网卡而是使用宿主机的IP和端口。

3.4、none

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

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

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

3.5、container

​ 新建的容器和已经存在的一个容器共享一个网络ip配置而不是和宿主机共享。新创建的容器不会创建自己的网卡，配置自己的IP，而是和一个指定的容器共享IP、端口范围等。同样，两个容器除了网络方面，其他的如文件系统、进程列表等还是隔离的。

3.6、自定义网络

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

docker network create [网络名]
1

十、docker-compose容器编排

1、是什么

​ Compose 是 Docker 公司推出的一个工具软件，可以管理多个 Docker 容器组成一个应用。你需要定义一个 YAML 格式的配置文件docker-compose.yml，写好多个容器之间的调用关系。然后，只要一个命令，就能同时启动/关闭这些容器

2、能干嘛

​ docker建议我们每一个容器中只运行一个服务,因为docker容器本身占用资源极少,所以最好是将每个服务单独的分割开来但是这样我们又面临了一个问题？

​ 如果我需要同时部署好多个服务,难道要每个服务单独写Dockerfile然后在构建镜像,构建容器,这样累都累死了,所以docker官方给我们提供了docker-compose多服务部署的工具

​ 例如要实现一个Web微服务项目，除了Web服务容器本身，往往还需要再加上后端的数据库mysql服务容器，redis服务器，注册中心eureka，甚至还包括负载均衡容器等等。。。。。。

​ Compose允许用户通过**一个单独的docker-compose.yml模板文件（YAML 格式）**来定义一组相关联的应用容器为一个项目（project）。

​ 可以很容易地用一个配置文件定义一个多容器的应用，然后使用一条指令安装这个应用的所有依赖，完成构建。Docker-Compose 解决了容器与容器之间如何管理编排的问题。

3、安装

curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
1

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

docker-compose --version
1

4、卸载

rm /usr/local/bin/docker-compose
1

5、compose核心概念

5.1、一文件：docker-compose.yml

5.2、两要素：服务、工程

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

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

6、compose使用步骤

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

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

6.3、执行docker-compose up命令，启动并运行整个应用程序，完成一件部署上线

7、compose常用命令