Docker学习笔记

发表于 | 更新于: | 分类于 | | 阅读次数:
字数统计: 10.4k | 阅读时长 ≈ 45

一、简介

Docker是一个开源的应用容器引擎，它是由 Go 语言 开发实现的轻量级容器技术，它是基于 Linux 内核的 cgroup，namespace，以及 AUFS 类的 Union FS 等技术，对进程进行封装隔离，属于 操作系统层面的虚拟化技术。由于隔离的进程独立于宿主和其它隔离的进程，因此也称其为容器。

Docker 架构

二、概念

1. 概要理解

Docker支持安装各种软件并做好配置后编译成镜像，最终可以直接运行镜像产生一个或多个运行于宿主机内核上的容器。为了形象的理解容器，可以简单的理解它为运行在操作系统上的独立沙箱系统，这些沙箱系统内部的文件系统和Linux的非常相似，事实上确是如此，因为Docker就是融合了Linux内核而实现的虚拟化技术，由于具有沙箱的特性，所以各个容器之间是隔离运行的、独立的、互不影响的，程序员甚至不用担心容器内部损坏或者崩溃导致宿主机出错，因为只要删除掉这些有问题的容器，而再运行相关的镜像又会得到全新的容器了，只要不进行数据挂载，整个过程甚至干净不留残余。

2. 核心内容

docker主机(Host)：或者称为docker宿主机，即安装了Docker程序的机器。

docker客户端(Client)：连接docker主机进行操作的程序。

docker镜像(Images)：是一个特殊的文件系统，除了提供容器运行时所需的程序、库、资源、配置等文件外，还包含了一些为运行时准备的一些配置参数（如匿名卷、环境变量、用户等）。镜像不包含任何动态数据，其内容在构建之后也不会被改变。

docker容器(Container)：运行镜像后产生的实例称为容器，实质是运行于独立的 命名空间的进程。

docker仓库(Registry)：集中存储、分发镜像的仓库服务系统，作用是允许用户上传、下载并管理镜像，包括公有仓库和私有仓库。

20180303165113

3. 对比传统虚拟机

特性 虚拟机的架构 容器的架构
启动 分钟级 秒级
性能 弱于原生 接近原生
硬盘使用 一般为GB 一般为MB
系统支持量 一般几十个 单机上千个容器

虚拟机的架构： 每个虚拟机都包括应用程序、必要的二进制文件和库以及一个完整的客户操作系统(Guest OS)，尽管它们被分离，它们共享并利用主机的硬件资源，将近需要十几个 GB 的大小。

容器的架构： 容器包括应用程序及其所有的依赖，但与其他容器共享内核。它们以独立的用户空间进程形式运行在宿主机操作系统上。他们也不依赖于任何特定的基础设施，Docker 容器可以运行在任何计算机上，任何基础设施和任何云上。

4. 优势

（1）快速的启动时间

由于Docker容器直接运行于宿主内核，无需启动完整的操作系统即可运行，因此可以做到秒级、甚至毫秒级的启动时间，这大大的节约了开发、测试、部署的时间。

（2）一致的运行环境

开发过程中一个常见的问题是环境一致性问题。由于不同物理机的开发环境不一致，经常出现安装了相同的软件但却有不同的运行效果现象，甚至有的环境下还会出现bug。而 Docker 的镜像提供了除内核外完整的运行时环境，确保了应用运行环境一致性，以至于不会再出现 “这段代码在我机器上没问题啊” 这类的问题。

（3）持续交付和部署

Docker可以一次创建或配置镜像，而可以在任意地方正常运行。即"一处构建，到处运行"。

（4）更方便的迁移

Docker 可以在很多平台上运行，无论是物理机、虚拟机、公有云、私有云，甚至是笔记本，其运行结果是一致的。因此用户可以很轻易的将在一个平台上运行的应用，迁移到另一个平台上，而不用担心运行环境的变化导致应用无法正常运行的情况。

（5）更轻量的维护和扩展

Docker 使用的分层存储以及镜像的技术，使得应用重复部分的复用更为容易，也使得应用的维护更新更加简单，基于基础镜像进一步扩展镜像也变得非常简单。此外，Docker 团队同各个开源项目团队一起维护了一大批高质量的 官方镜像，既可以直接在生产环境使用，又可以作为基础进一步定制，大大的降低了应用服务的镜像制作成本。

5. 分层存储

因为镜像包含操作系统完整的 root 文件系统，其体积往往是庞大的，因此在 Docker 设计时，就充分利用 Union FS 的技术，将其设计为分层存储的架构。所以严格来说，镜像并非是像一个 ISO 那样的打包文件，镜像只是一个虚拟的概念，其实际体现并非由一个文件组成，而是由一组文件系统组成，或者说，由多层文件系统联合组成。

镜像构建时，会一层层构建，前一层是后一层的基础。每一层构建完就不会再发生改变，后一层上的任何改变只发生在自己这一层。比如，删除前一层文件的操作，实际不是真的删除前一层的文件，而是仅在当前层标记为该文件已删除。在最终容器运行的时候，虽然不会看到这个文件，但是实际上该文件会一直跟随镜像。因此，在构建镜像的时候，需要额外小心，每一层尽量只包含该层需要添加的东西，任何额外的东西应该在该层构建结束前清理掉。

分层存储的特征还使得镜像的复用、定制变的更为容易。甚至可以用之前构建好的镜像作为基础层，然后进一步添加新的层，以定制自己所需的内容，构建新的镜像。

6. 容器存储层

镜像使用的是分层存储，容器也是如此。每一个容器运行时，是以镜像为基础层，在其上创建一个当前容器的存储层，我们可以称这个为容器运行时读写而准备的存储层为 容器存储层。

7. 数据卷

数据卷 是一个可供一个或多个容器使用的特殊目录，当容器内部的目录(文件)映射到宿主机的某目录(文件)时，那么就称这个宿主机的目录(文件)为数据卷。它绕过 UFS，可以提供很多有用的特性，如下：

  • 数据卷 可以在容器之间共享和重用
  • 对 数据卷 的修改会立马生效
  • 对 数据卷 的更新，不会影响镜像
  • 数据卷 默认会一直存在，即使容器被删除

注意：数据卷 的使用，类似于 Linux 下对目录或文件进行 mount，镜像中的被指定为挂载点的目录中的文件会隐藏掉，能显示看的是挂载的 数据卷。

按照 Docker 最佳实践的要求，容器不应该向其存储层内写入任何数据，容器存储层要保持无状态化。所有的文件写入操作，都应该使用 数据卷（Volume）、或者绑定宿主目录，在这些位置的读写会跳过容器存储层，直接对宿主（或网络存储）发生读写，其性能和稳定性更高。

数据卷的生存周期独立于容器，容器消亡，数据卷不会消亡。因此，使用数据卷后，容器删除或者重新运行之后，数据却不会丢失。

三、安装Docker

Docker 分为 CE 和 EE 两大版本。CE 即社区版，EE 即企业版，强调安全，付费使用。

1. 安装旧版本

centos7默认yum源头安装的Docker版本就是旧版本，旧版本的Docker称为 docker 或 docker-engine ，由于不在维护，故建议跳过直接安装新版本。

1
2
3
4
5
6
7
8
9
10
11
12
13
#1、检查内核版本，必须是3.10及以上
$ uname -r
#2、安装docker
$ yum install docker -y
#3、启动docker
$ systemctl start docker
$ docker -v
Docker version 1.12.6, build 3e8e77d/1.12.6
#4、开机启动docker
$ systemctl enable docker
Created symlink from /etc/systemd/system/multi-user.target.wants/docker.service to /usr/lib/systemd/system/docker.service.
#5、停止docker
$ systemctl stop docker

2. 安装新版本

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
#卸载旧版本，如果已安装这些程序，请卸载它们以及相关的依赖项
$ sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine
                                 
#安装新版docker yum源
$ yum install yum-utils -y
$ sudo yum-config-manager \
    --add-repo \
    https://mirrors.ustc.edu.cn/docker-ce/linux/centos/docker-ce.repo

#更新yum软件源缓存，并安装docker-ce。
$ sudo yum makecache fast
$ sudo yum update
$ sudo yum install docker-ce -y

#验证安装是否成功(有client和service两部分表示docker安装启动都成功了)
$ docker version

#启动并加入开机启动
$ sudo systemctl start docker
$ sudo systemctl enable docker

更多内容：

查看所有仓库中所有docker版本：yum list docker-ce --showduplicates | sort -r

安装指定版本：比如sudo yum install docker-ce-17.12.0.ce

新版docker安装好后命令自动补全会有些缺失，所以可以选择安装命令补全依赖工具。

1
2
3
4
5
6
#docker自动补齐需要依赖工具bash-complete，安装好后会得到文件为 /usr/share/bash-completion/bash_completion
$ sudo yum install -y bash-completion

#装好docker自动补齐依赖之后，要刷新下才能让其生效
$ sudo source /usr/share/bash-completion/bash_completion
$ sudo source /usr/share/bash-completion/completions/docker

3. 内网环境集群安装

（1）yum离线安装

如果内网中有一台服务器能够访问外网，可使用一下方式安装：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#在内网中可访问外网的服务器中下载清华的镜像源文件（要求这台服务器依软件赖环境纯净，最好没有安装过任何软件。目的是这台服务器的所有软件依赖一定要在其他内网服务器中都存在。）
$ wget -O /etc/yum.repos.d/docker-ce.repo https://download.docker.com/linux/centos/docker-ce.repo

$ sudo sed -i 's+download.docker.com+mirrors.tuna.tsinghua.edu.cn/docker-ce+' /etc/yum.repos.d/docker-ce.repo

$ yum update


$ sudo yum list docker-ce --showduplicates|sort -r

#下载docker安装的所有依赖到/tmp/docker-19.03目录
$ sudo yum install --downloadonly --downloaddir=/tmp/docker-19.03 docker-ce-19.03.8-3.el7 docker-ce-cli-19.03.8-3.el7

#复制下载好的/tmp/docker-19.03到目标服务器(比如192.168.0.13)
$ scp -r /tmp/docker-19.03/ root@192.168.0.13:/tmp/

#登录进目标服务器之后进入文件夹安装
$ ssh root@192.168.0.13
$ cd /tmp/docker-19.03/
$ yum install *.rpm
#启动并加入开机启动
$ sudo systemctl start docker
$ sudo systemctl enable docker

（2）完全离线安装

如果内网中所有服务器都不能访问外网，可使用一下方式安装：

下载安装包

在客户机中访问docker官网下载安装包：

安装包各版本下载地址：https://download.docker.com/linux/static/stable/x86_64/

这里下载的版本是：https://download.docker.com/linux/static/stable/x86_64/docker-19.03.5.tgz

安装运行

下载好安装包后通过ftp等客户端工具上传安装包到目标服务器，然后通过ssh客户端工具登录到该目标服务器执行如下命令：

1
2
3
4
5
6
7
8
9
10
#解压安装压缩包
$ tar xzvf docker-19.03.5.tgz
#拷贝安装
$ sudo cp docker/* /usr/bin/
#运行服务
$ dockerd &

#停止服务启动
$ ps -ef|grep dockerd
$ kill -9 1958 #这里的1958改成ps出来的pid

配置开机启动

1
2
3
4
5
6
#关闭selinux策略
$ vi /etc/selinux/config
SELINUX=disabled

#重启系统
$ reboot

配置docker.socket

1
$ vi /etc/systemd/system/docker.socket
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
[Unit]

Description=Docker Socket for the API

PartOf=docker.service

[Socket]

# If /var/run is not implemented as a symlink to /run, you may need to

# specify ListenStream=/var/run/docker.sock instead.

ListenStream=/run/docker.sock

SocketMode=0660

SocketUser=root

SocketGroup=docker

[Install]

WantedBy=sockets.target

配置docker.service

1
$ vi /etc/systemd/system/docker.service
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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
[Unit]

Description=Docker Application Container Engine

Documentation=https://docs.docker.com

After=network-online.target firewalld.service

Wants=network-online.target

[Service]

Type=notify

# the default is not to use systemd for cgroups because the delegate issues still

# exists and systemd currently does not support the cgroup feature set required

# for containers run by docker

ExecStart=/usr/bin/dockerd

ExecReload=/bin/kill -s HUP $MAINPID

# Having non-zero Limit*s causes performance problems due to accounting overhead

# in the kernel. We recommend using cgroups to do container-local accounting.

LimitNOFILE=infinity

LimitNPROC=infinity

LimitCORE=infinity

# Uncomment TasksMax if your systemd version supports it.

# Only systemd 226 and above support this version.

#TasksMax=infinity

TimeoutStartSec=0

# set delegate yes so that systemd does not reset the cgroups of docker containers

Delegate=yes

# kill only the docker process, not all processes in the cgroup

KillMode=process

# restart the docker process if it exits prematurely

Restart=on-failure

StartLimitBurst=3

StartLimitInterval=60s

[Install]

WantedBy=multi-user.target

启动服务

1
2
3
$ systemctl daemon-reload
$ systemctl start docker
$ systemctl enable docker

4. 修改 Docker 的默认存储路径

Docker 默认安装的情况下，会使用 /var/lib/docker/ 目录作为存储目录，用以存放拉取的镜像和创建的容器等。不过由于此目录一般都位于系统盘，遇到系统盘比较小，而镜像和容器多了后就容易尴尬，这里说明一下如何修改 Docker 的存储目录。

1
2
3
4
#可通过如下命令查看Docker的默认存储路径
$ docker info
#Docker Root Dir就是Docker的存储路径
Docker Root Dir: /var/lib/docker

假设/data1目录挂载点的磁盘空间比较大，需要将Docker的存储路径改为改目录，则可通过如下操作修改：

1
$ vi /etc/docker/daemon.json
1
2
3
4
5
6
7
{
    "registry-mirrors": [
        "https://docker.mirrors.ustc.edu.cn",
        "https://hub-mirror.c.163.com"
    ],
    "data-root": "/data1/docker/lib"
}
1
2
3
4
5
6
#然后重启 docker 服务
$ systemctl restart docker
#在执行就会看出存储路径已经修改了
$ docker info
#Docker Root Dir就是Docker的存储路径
Docker Root Dir: /data1/docker/lib

四、镜像下载加速

鉴于国内网络问题，Docker默认是从官方Docker Hub拉取 Docker 镜像十分缓慢，我们可以需要配置加速器来解决。

测速：https://github.com/docker-practice/docker-registry-cn-mirror-test/actions

编辑 /etc/docker/daemon.json（Linux） 或者 %programdata%\docker\config\daemon.json（Windows） 来配置 Daemon（如果文件不存在请新建该文件）。

1
$ vim /etc/docker/daemon.json

添加以下内容：

1
2
3
4
5
6
{
  "registry-mirrors": [
    "https://docker.mirrors.ustc.edu.cn",
    "https://hub-mirror.c.163.com"
  ]
}

可以配置多个加速镜像。由于镜像服务可能出现宕机，建议同时配置多个加速镜像。

1
2
3
4
5
6
#重新加载配制
$ systemctl daemon-reload
#重启docker
$ service docker restart
#检查加速器是否生效
$ docker info

如果方便建议使用aliyun的镜像

地址：https://cr.console.aliyun.com/cn-shenzhen/instances/mirrors

image-20200216144500211

五、镜像操作

https://hub.docker.com/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#检索	(去https://hub.docker.com上查看镜像的详细信息。eg：docker search redis)
$ docker  search 镜像关键字
#拉取	(name是镜像名，:tag是可选的，tag表示标签，多为软件的版本，默认是latest)
$ docker pull name[:tag]
#列出	(查看所有本地镜像)
$ docker images
#删除	(删除指定的本地镜像,image-id是镜像id)
$ docker rmi image-id

#查看镜像详细信息
$ docker inspect image-id

#镜像导出
$ docker save -o 打包文件名.tar 镜像id
#或者
$ docker save 镜像id > 文件名.tar

#镜像导入
$ docker load -i 打包文件名.tar
#或者
$ docker load < 打包文件名.tar

镜像导出并导入案例：

1
2
3
4
5
6
#例如，以下导出方式将会让docker load导入时的镜像没有名字(即<none>)
$ docker save -o redis.tar 7864316753
#因此，推荐使用镜像的名字进行导出，此方式导入时就有镜像名称了
$ docker save -o redis:5.0.2
#另外，如果已经是<none>的名称了，也可以通过以下命令重命名镜像名称
$ docker tag [镜像id] [新镜像名称]:[新镜像标签]

六、容器操作

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
#运行并创建一个容器
#-d表示守护态运行，即后台状态运行（可选）
#--name给容器自定义命名（可选）
#-p 端口映射（可选）
#-v 数据卷映射，即挂载物理主机文件/目录到容器里（可选）
docker run -d --name 容器名称 -p 主机端口:容器端口 -v 主机目录路径:容器目录路径  镜像名称

#关闭容器
docker stop 容器名称/容器id
#启动已经关掉的容器
docker start 容器名称/容器id
#重启容器
docker restart 容器名称/容器id

#删除指定容器
docker rm 容器名称/容器id
#强制删除当前所有容器
docker rm -f $(docker ps -a -q)


#容器列表（运行中）
docker ps
#容器列表（所有，包括停止的）
docker ps -a

#从主机拷贝文件到容器
docker cp 主机文件或目录 容器名称或容器id:容器文件或目录
#从容器拷贝文件到主机
docker cp 容器名称或容器id:容器文件或目录 主机文件或目录

#查看日志
docker logs 容器名称/容器id

小案例：

1
2
$ docker pull hello-world
$ docker run hello-world

2. 时间同步问题

1
2
3
4
5
##为了保证容器和宿主机之间的时间同步
#1、使用docker run运行容器时，添加如下参数-v /etc/localtime:/etc/localtime:ro  如下：
docker run -it -v /etc/localtime:/etc/localtime:ro centos
#2、如果容器已经运行则可以如下操作：
docker cp -L /usr/share/zoneinfo/Asia/Shanghai [容器名]:/etc/localtime

七、docker网络

Docker默认提供了3种网络模式，生成容器时不指定网络模式下默认使用bridge桥接模式。

1. host模式

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

1
docker run -d --name 容器名称 --net=host   镜像名称

2. container模式

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

1
docker run -d --name 容器名称 --net=container:容器名称或容器id   镜像名称

3. none模式

关闭网络功能，不进行任何网络设置

1
docker run -d --name 容器名称 --net=none   镜像名称

4. bridge模式

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

当Docker进程启动时，会在主机上创建一个名为docker0的虚拟网桥（网卡/路由器），此主机上启动的Docker容器都会连接到这个虚拟网桥上。虚拟网桥的工作方式和物理交换机类似，这样主机上的所有容器就通过交换机连在了一个二层网络中。

宿主机和Docker容器之间是可以进行网络连接的，同样的，Docker容器和容器之间只要是在一个虚拟网桥下，那么也可以直接进行网络连接。

1
2
#通过--net=bridge显示指定，默认就是bridge，也可以不设置
docker run -d --name 容器名称 --net=bridge   镜像名称

5. 自定义网络

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
##自定义创建名称为mynet的网络
#--driver bridge 桥接模式
#--subnet 192.168.0.0/16  子网掩码（网段） 范围192.168.0.2-192.168.255.255
#--gateway 192.168.0.1 网关
docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet

#删除网络
docker network rm mynet
#删除主机上全部未使用的网络
docker network prune

#查看当前Docker所有的网络模式
docker network ls

#查看自定义网络详细信息
docker network inspect mynet

#通过--net在启动容器时指定自定义网络
docker run -d --name 容器名称 --net mynet   镜像名称

#不同Docker网络之间的容器想要连接的话，需要把该容器注册到另一个容器所在的网络上
#如下假设centos01容器本来在默认的bridge上，想要让其和mynet网络下的容器互通，则需要把centos01注册到mynet中。
docker network connect mynet centos01
  • 默认docker0是无法Ping通容器名，而自定义网络可以Ping通容器名，推荐使用自定义网络
  • 在多个微服务部署到docker时，通过自定义网络方便统一的网络配置。

参考：https://blog.csdn.net/CSDN1csdn1/article/details/123961079

八、构建自定义镜像

方式1：上传程序到vps后构建

需求：构建一个能在tomcat容器里运行的war包程序镜像，并通过镜像创建一个实例容器。

由于依赖于tomcat容器，故需要先拉去tomcat镜像到本地。tomcat镜像主页：https://c.163yun.com/hub#/library/repository/info?repoId=3105

（1）拉取tomcat镜像到宿主机

1
$ docker pull hub.c.163.com/library/tomcat:latest

（2）上传war包

创建一个webdemo项目，并在这个webdemo项目的资源路径里添加一个index.jsp页面。

1
2
3
4
5
<html>
<body>
<h2>Hello World!</h2>
</body>
</html>

然后打包得到webdemo.war文件。并上传这个webdemo.war文件到vps的/root/project目录

（3）编写Dockerfile文件

1
2
#在/root/project下编写一个Dockerfile文件
$ vim Dockerfile
1
2
3
4
5
6
#继承于某个镜像
from hub.c.163.com/library/tomcat
#镜像所有者信息
MAINTAINER qcmoke qcmoke@gmail.com
#把程序copy到容器镜像当中，前面的参数是本地路径，后面的参数是容器镜像路径(可以到镜像主页得到tomcat的webapp路径)
COPY /root/project /usr/local/tomcat/webapps

（4）构建生成镜像

1
2
#在Dockerfile文件所在的目录，即/root/project里执行如下命令
$ docker build -t webdemo:latest .

（5）查看本地镜像仓库是否构建成功

1
$ docker images
1
2
3
REPOSITORY                     TAG                 IMAGE ID            CREATED                  SIZE
docker.io/tomcat               latest              aeea3708743f        Less than a second ago   529 MB
webdemo                        latest              10f75818641a        46 seconds ago           310 MB

（6）通过构建的镜像实例化一个容器并运行

1
$ docker run -d -p 8080:8080 webdemo:latest

（7）访问测试

访问index.jsp：http://192.168.222.131:8080/webdemo/index.jsp

image-20200215111413522

（8）其他

在用-d指定为后台启动的情况下，可以使用以下命令查看容器实时的日志情况：

1
$ docker logs -f 容器名称或者容器id

方式2：通过idea插件连接vps构建

（1）配置docker允许外网访问

在vps中配置docker允许外网访问

1
$ vim /usr/lib/systemd/system/docker.service

在ExecStart属性原来值的最后追加

1
-H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock

新版Docker CE配置如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
....
....
[Service]
Type=notify
# the default is not to use systemd for cgroups because the delegate issues still
# exists and systemd currently does not support the cgroup feature set required
# for containers run by docker
ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock
ExecReload=/bin/kill -s HUP $MAINPID
TimeoutSec=0
RestartSec=2
Restart=always
....
....

旧版Docker配置如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
[Service]
....
....
ExecStart=/usr/bin/dockerd-current \
          --add-runtime docker-runc=/usr/libexec/docker/docker-runc-current \
          --default-runtime=docker-runc \
          --exec-opt native.cgroupdriver=systemd \
          --userland-proxy-path=/usr/libexec/docker/docker-proxy-current \
          --init-path=/usr/libexec/docker/docker-init-current \
          --seccomp-profile=/etc/docker/seccomp.json \
          $OPTIONS \
          $DOCKER_STORAGE_OPTIONS \
          $DOCKER_NETWORK_OPTIONS \
          $ADD_REGISTRY \
          $BLOCK_REGISTRY \
          $INSECURE_REGISTRY \
          $REGISTRIES \
          -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock
....
....

（2）重新加载配置并重启Docker

1
2
$ systemctl daemon-reload
$ systemctl restart docker

（3）启动防火墙并开放2375端口

开放了防火墙2375端口用于远程连接

1
2
3
4
$ service firewalld start
$ firewall-cmd --permanent --add-port=2375/tcp
$ firewall-cmd --reload
$ firewall-cmd --list-all
  • 不需要另外开放容器映射到宿主机的端口。
  • 经操作发现，如果使用vmware的linux作为vps，不能直接关闭防火墙，开放相应的端口即可。

（4）创建一个springboot项目

image-20200216133115274

pom.xml

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
<?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>
    <groupId>com.example</groupId>
    <artifactId>demo-boot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <!--将其他模块的依赖一起打包生成可执行jar-->
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

DemoApplication.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author qcmoke
 */
@RestController
@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @RequestMapping("/hello")
    public Object hello() {
        return "hello docker!";
    }
}

application.yml

1
2
server:
  port: 8080

Dockerfile

1
2
3
4
5
6
7
8
9
FROM openjdk:8u212-jre
#存放持久化数据的目录
VOLUME /tmp
#要复制到容器中的问件
ADD target/demo-boot-0.0.1-SNAPSHOT.jar /demo-boot.jar
#docker容器启动时执行的命令
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/demo-boot.jar"]
#启动端口号(容器中的)
EXPOSE 8080

（5）编译项目生成jar包

image-20200216134810561

（6）配置远程docker插件连接

默认新版的idea自带有这个插件，如果没有直接到插件中心安装即可。

image-20200216133850397

（7）然后配置DockerFile

image-20200216132351344

image-20200216134320278

（8）运行docker插件

运行插件部署镜像到vps，并通过镜像创建一个实例容器

image-20200216140432811

（9）访问测试

最后访问: http://192.168.222.132:8080/hello

image-20200216141102237

九、docker compose

1. 简介

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

地址：https://github.com/docker/compose

使用一个 Dockerfile 模板文件，可以让用户很方便的定义一个单独的应用容器。然而，在日常工作中，经常会碰到需要多个容器相互配合来完成某项任务的情况。Compose 允许用户通过一个单独的 docker-compose.yml 模板文件来定义一组相关联的应用容器为一个项目。

2. 安装

在 Linux 上的也安装十分简单，从 官方 GitHub Release 处直接下载编译好的二进制文件即可。

例如，在 Linux 64 位系统上直接下载对应的二进制包。

1
2
3
4
5
$ sudo curl -L https://github.com/docker/compose/releases/download/1.24.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

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

$ docker-compose --version

因为 Docker Compose 存放在 GitHub，可能网络不太稳定。你也可以通过执行下面的命令，高速安装 Compose。该加速通道由 DaoCloud 提供：http://get.daocloud.io/#install-compose

1
2
3
$ sudo curl -L https://get.daocloud.io/docker/compose/releases/download/1.24.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
$ sudo chmod +x /usr/local/bin/docker-compose
$ docker-compose --version

3. 卸载

如果是二进制包方式安装的，删除二进制文件即可。

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

4. 编排文件

在任意目录创建compose编排配置文件：docker-compose.yml

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
## docker-compose.yml文件的版本
version: '3.1'
services:                     # compose管理的服务
  redis:
    image: redis              # 指定镜像
    container_name: redis-1   # 容器名称
    restart: always           # 开机自动启动
    ports:                    # 端口映射
      - 6379:6379
    volumes:                  # 目录映射
      - /micro-cloud-erp/redis/conf:/usr/local/etc/redis
      - /micro-cloud-erp/redis/data:/data
    command: redis-server --requirepass qcmoke123456 --appendonly yes #执行的命令; requirepass来指定远程登录密码; appendonly来指定是否开启持久化策略
    #command: redis-server /usr/local/etc/redis/redis.conf --appendonly yes

  mysql:
    image: mysql:5.7.24
    container_name: mysql-1
    ports:
      - 3306:3306
    environment:                          # 环境变量
      MYSQL_ROOT_PASSWORD: qcmoke123456   # 设置数据库root密码
    restart: always
    volumes:
      - /micro-cloud-erp/mysql/data:/var/lib/mysql
      #当 MySQL 服务启动时会以/etc/mysql/my.cnf为配置文件，而该文件会导入/etc/mysql/conf.d目录中所有以.cnf为后缀的文件。
      #这些文件会拓展或覆盖 /etc/mysql/my.cnf 文件中的配置。因此创建以.cnf结尾的配置文件并挂载至MySQL容器中的/etc/mysql/conf.d目录即可。
      #在本项目中只要在docker-compose up前上传my.cnf文件到宿主机的/micro-cloud-erp/mysql/conf.d/my.cnf目录即可。如果在docker-compose up后的话，需要重启mysql容器才能重新加载到自定义的配置文件。
      - /micro-cloud-erp/mysql/conf.d:/etc/mysql/conf.d

  nacos:
    image: nacos/nacos-server
    container_name: nacos-standalone
    environment:
      - MODE=standalone
    ports:
      - 8848:8848

下面是compose编排配置文件中使用到的mysql配置文件：my.cnf

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
[mysql]
# 设置mysql客户端默认字符集
default-character-set=utf8

[mysqld]
# 设置3306端口
port = 3306
# 设置mysql的安装目录
# basedir=/var/lib/mysql
# 设置 mysql数据库的数据的存放目录，如果是MySQL 8+ 不需要以下配置，系统自己生成即可，否则有可能报错
# datadir=/var/lib/mysql/data
# 允许最大连接数
max_connections=20
# 服务端使用的字符集默认为8比特编码的latin1字符集
character-set-server=utf8
# 创建新表时将使用的默认存储引擎
default-storage-engine=INNODB
# 最大连接数
max_connections=500

5. 操作命令

在docker-compose.yml所在的目录执行如下命令

1
2
3
4
5
6
7
8
#尝试自动完成包括构建镜像，（重新）创建服务，启动服务，并关联服务相关容器的一系列操作。相关的服务都将会被自动启动，除非已经处于运行状态。
$ docker-compose up
#以守护进程模式运行加-d选项
$ docker-compose up -d
 #此命令将会停止 up 命令所启动的容器，并移除网络
$ docker-compose down
#重启项目中的服务。
$ docker-compose restart [options] [SERVICE...]

十、Docker Swarm

Docker Swarm 是 Docker 的集群管理工具，或者说是资源管理工具。swarm 集群由管理节点（manager）和工作节点（work node）构成。

swarm mananger：负责整个集群的管理工作包括集群配置、服务管理等所有跟集群有关的工作。

work node：即图中的 available node，主要负责运行相应的服务来执行任务（task）。

注意：跟集群管理有关的任何操作，都是在管理节点上操作的。

准备6台linux服务器

manager-1：192.168.99.101

manager-2：192.168.99.102

manager-3：192.168.99.103

worker-1：192.168.99.201

worker-2：192.168.99.202

worker-3：192.168.99.203

1. 关闭所有服务器的防火墙

1
$ service firewalld stop

2. 初始化 swarm 集群

进行初始化的这台机器，就是集群的管理节点。

1
$ docker swarm init --advertise-addr 192.168.68.101

eg：

1
2
3
4
5
6
7
8
9
10
[root@localhost ~]# docker swarm init --advertise-addr 192.168.68.101
Swarm initialized: current node (w7xdf6see52t2t24x1ykedg5o) is now a manager.

To add a worker to this swarm, run the following command:

    docker swarm join \
    --token SWMTKN-1-04sl6nb0acbzzgvfrqycph4jtnyh0wcoix70gz44sjuaf66cwd-3xqtzzxymio3077xfki41od0e \
    192.168.68.101:2377

To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.

3. 添加worker节点

在manager节点下生成worker令牌，以让其他worker服务器加入

1
$ docker swarm join-token worker

eg：

1
2
3
4
5
6
[root@localhost ~]# docker swarm join-token worker
To add a worker to this swarm, run the following command:

    docker swarm join \
    --token SWMTKN-1-04sl6nb0acbzzgvfrqycph4jtnyh0wcoix70gz44sjuaf66cwd-3xqtzzxymio3077xfki41od0e \
    192.168.68.101:2377

然后在三台worker节点运行：

1
2
3
$ docker swarm join \
    --token SWMTKN-1-04sl6nb0acbzzgvfrqycph4jtnyh0wcoix70gz44sjuaf66cwd-3xqtzzxymio3077xfki41od0e \
    192.168.68.101:2377

4. 添加manager节点

在manager节点下生成manager令牌，以让其他manager服务器加入

1
$ docker swarm join-token manager

eg：

1
2
3
4
5
6
[root@localhost ~]# docker swarm join-token manager
To add a manager to this swarm, run the following command:

    docker swarm join \
    --token SWMTKN-1-04sl6nb0acbzzgvfrqycph4jtnyh0wcoix70gz44sjuaf66cwd-4nbcolan6w4akrs3zsbvrkqxe \
    192.168.68.101:2377

然后在三台manager节点运行如下命令：

1
2
3
$ docker swarm join \
    --token SWMTKN-1-04sl6nb0acbzzgvfrqycph4jtnyh0wcoix70gz44sjuaf66cwd-4nbcolan6w4akrs3zsbvrkqxe \
    192.168.68.101:2377

5. 查看所有管理的节点

manager-1运行命令查看所有管理的节点

1
$ docker node ls

eg：

1
2
3
4
5
6
7
8
[root@localhost ~]# docker node ls
ID                           HOSTNAME               STATUS  AVAILABILITY  MANAGER STATUS
dif8w8hp6pevz9k0owqkg6hjl    localhost.localdomain  Ready   Active        
j9jqdioy91olyxd8dfghgm8qc    localhost.localdomain  Ready   Active        
mfv24dim85bi7sd9wl589rhdf    localhost.localdomain  Ready   Active        Reachable
q1qayx19ebfg7oi8dv7e3mzyh    localhost.localdomain  Ready   Active        
rbeb5mykx83qpr6u8afriqx9z    localhost.localdomain  Ready   Active        Reachable
w7xdf6see52t2t24x1ykedg5o *  localhost.localdomain  Ready   Active        Leader

6. 创建集群服务

1
$ docker service create -p 80:80 --name my-nginx nginx

这时候将会在任意节点中选择一台通过docker创建nginx服务。我们可以在集群下任意一台服务器（manager或者worker节点）访问nginx服务都能访问到，因为swarm创建的服务使用的是swarm集群网络。

7. 查看服务集群情况

1
$ docker service ls

eg：

1
2
3
[root@localhost ~]# docker service ls
ID            NAME      MODE        REPLICAS  IMAGE
v1hn945nmyds  my-nginx  replicated  1/1       nginx:latest

REPLICAS：副本数量

8. 集群服务扩容

对my-nginx服务扩容为5个

第一种方式：

1
$ docker service update --replicas 5 my-nginx

eg:

1
2
3
4
5
[root@localhost ~]# docker service update --replicas 5 my-nginx
my-nginx
[root@localhost ~]# docker service ls
ID            NAME      MODE        REPLICAS  IMAGE
v1hn945nmyds  my-nginx  replicated  5/5       nginx:latest

第二种方式：

1
$ docker service scale my-nginx=5
1
2
3
4
5
[root@localhost ~]# docker service scale my-nginx=5
my-nginx scaled to 5
[root@localhost ~]# docker service ls
ID            NAME      MODE        REPLICAS  IMAGE
v1hn945nmyds  my-nginx  replicated  5/5       nginx:latest

update更多的应用场景在于image的升级导致的运行中的服务需要更新等等

9. 删除集群服务

1
$ docker service rm my-nginx

这时候所有副本都会被删除

10. 修改服务

比如修改nginx服务镜像版本为1.9.5

1
$ docker service update --image nginx:1.9.5 my-nginx
1
2
3
4
5
6
7
8
9
10
11
12
[root@localhost ~]# docker service ps my-nginx
ID            NAME            IMAGE         NODE                   DESIRED STATE  CURRENT STATE                ERROR  PORTS
kzg8qncaal9a  my-nginx.1      nginx:1.9.5   localhost.localdomain  Running        Running about a minute ago          
er55pvmd8fn6   \_ my-nginx.1  nginx:latest  localhost.localdomain  Shutdown       Shutdown about a minute ago         
kv3t6poxh3rb  my-nginx.2      nginx:1.9.5   localhost.localdomain  Running        Running about a minute ago          
tuzkxmb0th6x   \_ my-nginx.2  nginx:latest  localhost.localdomain  Shutdown       Shutdown about a minute ago         
edt0tg6tg120  my-nginx.3      nginx:1.9.5   localhost.localdomain  Running        Running about a minute ago          
qfwlzj8hb3gl   \_ my-nginx.3  nginx:latest  localhost.localdomain  Shutdown       Shutdown about a minute ago         
bb9kjj3n81yx  my-nginx.4      nginx:1.9.5   localhost.localdomain  Running        Running about a minute ago          
spx8ybz9wlph   \_ my-nginx.4  nginx:latest  localhost.localdomain  Shutdown       Shutdown about a minute ago         
vs4akco7zpls  my-nginx.5      nginx:1.9.5   localhost.localdomain  Running        Running about a minute ago          
qtaqq0jout6k   \_ my-nginx.5  nginx:latest  localhost.localdomain  Shutdown       Shutdown about a minute ago

11. 服务回滚

1
$ docker service update --rollback

十一、综合案例

步骤：软件镜像（安装程序）—> 运行镜像 —> 产生一个容器（正在运行的软件）。

1. 安装nginx

1
2
3
4
5
6
7
8
9
10
11
12
#拉取(下载)镜像
$ docker pull hub.c.163.com/library/nginx:latest

#根据镜像实例化一个容器并运行，运行好后访问http://192.168.222.131:8080
$ docker run -d --name nginx1 -p 8080:80 nginx

#可以进入容器内部执行命令(里面的文件系统和原生linux的一样)
$ docker exec -it nginx1 bash
#在容器里执行命令查看nginx命令的位置
$ which nginx
#退出容器
$ exit

2. 安装tomcat

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
#1、搜索镜像
$ docker search tomcat

#2、拉取(下载)镜像
#$ docker pull tomcat
#这里使用的是网易镜像站的，网址：https://c.163yun.com/hub#/home
$ docker pull hub.c.163.com/library/tomcat

#3、根据镜像实例化一个容器并运行
# 选项：-d：表示后台运行；-p: 表示将主机的端口映射到容器的一个端口，如-p 主机端口:容器内部的端口。
# 启动一个做了端口映射的tomcat,假设虚拟机ip为192.168.222.132,那么启动容器后访问http://192.168.222.132:8080
$ docker run -d --name mytomcat -p 8080:8080 hub.c.163.com/library/tomcat

#4、查看运行中的容器
$ docker ps

#5、查看当前所有容器
$ docker ps -a

#6、 停止运行中的容器
$ docker stop mytomcat

#7、启动容器
$ docker start mytomcat

#8、删除一个容器(需要先停止运行中的容器)
$ docker rm mytomcat

#9、查看容器的日志 docker logs container-name或者container-id
$ docker logs mytomcat

更多命令参看https://docs.docker.com/engine/reference/commandline/docker/可以参考每一个镜像的文档

3. 安装mysql

（1）获取镜像

1
2
docker pull mysql
#docker pull mysql:5.7 #指定版本用	:标签（版本号）

（2）启动镜像

1
2
3
4
5
6
#简单方式
$ docker run --name mysql01 -e MYSQL_ROOT_PASSWORD=123456 -d mysql

#做端口映射的启动方式：
$ docker run -p 3306:3306 --name mysql02 -e MYSQL_ROOT_PASSWORD=123456 -d mysql
#docker run -p 3306:3306 --name mysql5_7 -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7

几个其他的高级操作

1
2
3
4
5
$ docker run --name mysql03 -v /conf/mysql:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag
#指定mysql的一些配置参数
#docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci
#把mysqldocker容器的/etc/mysql/conf.d目录挂载到宿主机的/conf/mysql目录
#改mysql的配置文件就只需要把mysql配置文件放在自定义的文件夹下（/conf/mysql）

mysql完整案例

1
2
3
4
$ docker pull mysql:5.7
$ mkdir /opt/mysql/conf -p
$ mkdir /opt/mysql/data -p
$ vim /opt/mysql/conf/my.cnf
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
## my.cnf
[mysql]
# 设置mysql客户端默认字符集
default-character-set=utf8

[mysqld]
# 设置3306端口
port = 3306
# 设置mysql的安装目录
# basedir=/var/lib/mysql
# 设置 mysql数据库的数据的存放目录，如果是MySQL 8+ 不需要以下配置，系统自己生成即可，否则有可能报错
datadir=/var/lib/mysql/data
# 允许最大连接数
max_connections=20
# 服务端使用的字符集默认为8比特编码的latin1字符集
character-set-server=utf8
# 创建新表时将使用的默认存储引擎
default-storage-engine=INNODB
# 最大连接数
max_connections=500
1
2
3
#运行mysql实例
$ docker run -d --name mysql  -p 3306:3306 -v /opt/mysql/conf:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=123456  mysql:5.7
$ docker run -d --name mysql  -p 3306:3306 -v /opt/mysql/conf:/etc/mysql/conf.d -v /opt/mysql/data:/var/lib/mysql/data -e MYSQL_ROOT_PASSWORD=123456  mysql:5.7

4. 安装rabbitmq

（1）获取镜像

1
2
#该版本包含了web控制页面
docker pull rabbitmq:management

（2）运行镜像

1
2
3
4
5
#方式一：默认用户名和密码都是guest
docker run -d --hostname my-rabbit --name rabbit -p 15672:15672 -p 5672:5672 rabbitmq:management

#方式二：设置用户名和密码
docker run -d --hostname my-rabbit --name rabbit -e RABBITMQ_DEFAULT_USER=user -e RABBITMQ_DEFAULT_PASS=password -p 15672:15672 -p 5672:5672 rabbitmq:management

（3）访问rabbitmq管理页面页面 http://ip:15672

5. 安装redis

创建redis配置文件

1
2
$ mkdir /home/redis/conf/  /home/redis/data/ -p
$ vim /home/redis/conf/redis.conf
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#节点端口
port 6379
#访问认证密码
requirepass 123456
#如果主节点开启了访问认证，从节点访问主节点需要认证的密码
masterauth 123456
#保护模式，默认值 yes，即开启。开启保护模式以后，需配置 bind ip 或者设置访问密码；关闭保护模式，外部网络可以直接访问；
protected-mode no
#是否以守护线程的方式启动（后台启动），默认 no；
daemonize no
#是否开启 AOF 持久化模式，默认 no；
appendonly yes
#是否开启集群模式，默认 no；
cluster-enabled no

该原始文件可从官网下载

bind 127.0.0.1 #注释掉这部分，这是限制redis只能本地访问

protected-mode no #默认yes，开启保护模式，限制为本地访问

daemonize no#默认no，改为yes意为以守护进程方式启动，可后台运行，除非kill进程，改为yes会使配置文件方式启动redis失败

databases 16 #数据库个数（可选），我修改了这个只是查看是否生效。。

dir ./ #输入本地redis数据库存放文件夹（可选）

appendonly yes #redis持久化（可选）

requirepass 密码 #配置redis访问密码

运行redis镜像

1
2
$ docker pull redis:5.0.7
$ docker run -p 6379:6379 --name redis -v /home/redis/conf/redis.conf:/etc/redis/redis.conf -v /home/redis/data:/data -d redis:5.0.7  redis-server /etc/redis/redis.conf --appendonly yes

配置防火墙

1
2
3
$ firewall-cmd --permanent --add-port=6379/tcp
$ firewall-cmd --reload
$ firewall-cmd --list-all

6. 安装zookeeper

1
2
3
$ docker run -d --name zookeeper --restart always -e JVMFLAGS="-Xmx1024m" -p 2181:2181 zookeeper
$ docker exec -it myZookeeper /bin/bash
$ /apache-zookeeper-3.6.2-bin/bin/zkCli.sh

https://hub.docker.com/r/wurstmeister/kafka/

7. 安装kafka

提前安装并启动zookeeper

1
2
3
4
5
6
7
8
9
10
# KAFKA_ADVERTISED_LISTENERS：外部代理地址(服务器物理机对外ip)；
# KAFKA_ZOOKEEPER_CONNECT：zookeeper连接地址
$ docker run --name kafka \
-p 9092:9092 \
-v /data/kafka:/kafka \
-e KAFKA_BROKER_ID=0 \
-e KAFKA_ZOOKEEPER_CONNECT=39.106.195.202:2181 \
-e KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://39.106.195.202:9092 \
-e KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092 \
-d  wurstmeister/kafka

8. 安装ubuntu

1
2
3
4
5
6
7
8
#-i 表示 interactive 可交互的，变即可以从标准输入与容器交互。-t 表示给容器分配一个虚拟终端。-d 这个参数表示的是在后台运行，即 –deamon。-v 挂载容器目录到宿主机指定目录
docker run --name ubuntu-test -itd -v /root/docker-temp:/root/docker-temp ubuntu
#进入容器内部
docker exec -it ubuntu-test /bin/bash
#更新软件源，这个步骤优先级最高，因为不更新很多组件安装不了
apt-get update
#安装常用工具
apt install telnet iputils-ping net-tools curl wget vim

9. 安装centos

1
2
3
4
5
6
7
8
9
docker pull centos:centos7
#-i 表示 interactive 可交互的，变即可以从标准输入与容器交互。-t 表示给容器分配一个虚拟终端。-d 这个参数表示的是在后台运行，即 –deamon。-v 挂载容器目录到宿主机指定目录
docker run -itd --name centos7-test -v /root/docker-temp:/root/docker-temp centos:centos7
#进入容器内部
docker exec -it centos7-test bash
#更新软件源
yum update
#安装常用工具
yum install telnet net-tools curl wget vim -y

十二、问题排错

(1)Error response from daemon: oci runtime error: container_linux.go:247: start....，原因是系统和docker版本不兼容。解决：执行yum update

(2)rying to pull repository docker.io/library/mysql ... Get https://registry-1.。解决：执行以下命令：

1
2
3
4
$ yum install bind-utils     #安装dig工具
$ dig @114.114.114.114 registry-1.docker.io
$ vi /etc/hosts
52.54.155.177 registry-1.docker.io

(3)[root@izuf6dskn3b7v2sly08bqtz ~]# docker pull mysql Using default tag: latest Trying to pull repository docker.io/library/mysql ... Get https://registry-1.docker.io/v2/: x509: certificate is valid for *.theranest.com, theranest.com, not registry-1.docker.io

解决：镜像加速解决

(3)执行docker-compose up -d后出现错误：ERROR: Failed to Setup IP tables: Unable to enable SKIP DNAT rule: (iptables failed: iptables --wait -t nat -I DOCKER -i br-950144d461c2 -j RETURN: iptables: No chain/target/match by that name. (exit status 1))

重启docker试试

1
2
$ systemctl stop docker
$ systemctl start docker

十三、参考

📚《Docker — 从入门到实践》



----------- 本文结束 -----------




如果你觉得我的文章对你有帮助，你可以打赏我哦~
0%