Docker_安装使用_容器镜像_Docker-compose_常用指令_网络配置_docker compose privileged=true

Docker

相关概念

微服务虽然具备各种各样的优势，但服务的拆分通用给部署带来了很大的麻烦。

• 分布式系统中，依赖的组件非常多，不同组件之间部署时往往会产生一些冲突。
• 在数百上千台服务中重复部署，环境不一定一致，会遇到各种问题。

Docker解决依赖的兼容问题：

• Docker允许开发中将应用、依赖、函数库、配置一起打包，形成可移植镜像

• Docker应用运行在容器中，使用沙箱机制，相互隔离。

Docker解决不同系统环境问题：

• Docker将用户程序与所需要调用的系统(比如Ubuntu)函数库一起打包。
• Docker运行到不同操作系统时，直接基于打包的函数库，借助于操作系统的Linux内核来运行。

Docker是一个快速交付应用、运行应用的技术，具备下列优势：

• 可以将程序及其依赖、运行环境一起打包为一个镜像，可以迁移到任意Linux操作系统。
• 运行时利用沙箱机制形成隔离容器，各个应用互不干扰。
• 启动、移除都可以通过一行命令完成，方便快捷。

系统结构

系统结构结构包括：

• 计算机硬件：例如CPU、内存、磁盘等
• 系统内核：所有Linux发行版的内核都是Linux，例如CentOS、Ubuntu、Fedora等。内核可以与计算机硬件交互，对外提供内核指令，用于操作计算机硬件。
• 系统应用：操作系统本身提供的应用、函数库。这些函数库是对内核指令的封装，使用更加方便。

计算机交互的流程如下：

1. 应用调用操作系统应用（函数库），实现各种功能。

2. 系统函数库是对内核指令集的封装，会调用内核指令。

3. 内核指令操作计算机硬件。

Docker架构

Docker组成概念：

• 镜像（Image）：Docker将应用程序及其所需的依赖、函数库、环境、配置等文件打包在一起，称为镜像。
• 容器（Container）：镜像中的应用程序运行后形成的进程就是容器，只是Docker会给容器进程做隔离，对外不可见。

DockerHub镜像库：

• DockerHub是一个官方的Docker镜像的托管平台。这样的平台称为Docker Registry。

• 国内也有类似于DockerHub的公开服务，比如 网易云镜像服务、阿里云镜像库等。

Docker是一个CS架构的程序，由两部分组成：

• 服务端(server)：Docker守护进程，负责处理Docker指令，管理镜像、容器等

• 客户端(client)：通过命令或RestAPI向Docker服务端发送指令。可以在本地或远程向服务端发送指令。

Docker安装

Docker分为CE和EE两大版本。CE即社区版（免费，支持周期 7 个月），EE即企业版，强调安全，付费使用，支持周期24个月。

Docker CE分为 stable、test和nightly三个更新频道。

1. 卸载(选做)，如果之前安装过旧版本的Docker，可以使用下面命令卸载：

yum remove docker \
docker-client \
docker-client-latest \
docker-common \
docker-latest \
docker-latest-logrotate \
docker-logrotate \
docker-selinux \
docker-engine-selinux \
docker-engine \
docker-ce
1
2
3
4
5
6
7
8
9
10
11

2. 首先需要Linux系统联网，安装yum工具。

yum install -y yum-utils \
device-mapper-persistent-data \
lvm2 --skip-broken
1
2
3

3. 更新本地镜像源：

# 设置 docker 增加镜像源 
yum-config-manager \
--add-repo \
https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

# 替换镜像源地址修改为阿里云镜像源地址
sed -i 's/download.docker.com/mirrors.aliyun.com\/docker-ce/g' /etc/yum.repos.d/docker-ce.repo

# 将软件包信息提前在本地索引缓存
yum makecache fast
1
2
3
4
5
6
7
8
9
10

4. 安装docker。

# docker-ce为社区免费版本。
yum install docker-ce docker-ce-cli containerd.io docker-compose-plugin

# 开启docker服务
systemctl start docker 

# 测试docker是否可用
docker run hello-world
1
2
3
4
5
6
7
8

5. 卸载docker。

# 第一步先关闭docker服务
systemctl stop docker
# 第二部卸载docker软件包
yum remove docker-ce docker-ce-cli containerd.io
# 第三步删除相关残留文件
rm -rf /var/lib/docker
rm -rf /var/lib/containerd
1
2
3
4
5
6
7

Docker使用

• 配置Linux开放端口(学习环境)。

# Docker应用需要用到各种端口，逐一去修改防火墙设置。非常麻烦，因此建议直接关闭防火墙！
# 关闭
systemctl stop firewalld
# 禁止开机启动防火墙
systemctl disable firewalld
1
2
3
4
5

• docker系统服务类指令。

# 启动 docker 服务
systemctl start docker  
# 停止 docker 服务
systemctl stop docker 
# 重启 docker 服务
systemctl restart docker 
# 开机启动 docker 服务
systemctl enable docker		
# 查看动 docker 服务信息
docker info
# 查看 docker 版本
docker -v  
# 查看 docker 系统情况
docker system df
# 查看 docker 容器情况(网络、磁盘等信息)
docker stats
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• 配置docker镜像源加速。

# 配置镜像加速
# 阿里镜像：https://o99wo4tm.mirror.aliyuncs.com
sudo mkdir -p /etc/docker

sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://o99wo4tm.mirror.aliyuncs.com"]
}
EOF

sudo systemctl daemon-reload
sudo systemctl restart docker
1
2
3
4
5
6
7
8
9
10
11
12

image 镜像

镜像概念

概念：

1. docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS。
2. 镜像是一种轻量级、可执行的独立软件包，它包含运行某个软件所需的所有内容，把应用程序和配置依赖打包好形成一个可交付的运行环境(包括代码、运行时需要的库、环境变量和配置文件等)。

镜像获取流程：

镜像名称组成：

• 语法：[repository]:[tag]。
• 未指定tag时，默认是latest，代表最新版本的镜像。

镜像查询

# 列出本地主机上的镜像
docker images
# 列出本地主机上所有镜像
docker images -a
# 列出本地主机上的镜像ID
docker image -q

# 参数说明：
# -a 列出本地所有镜像，含历史映像层
# -q 只显示镜像ID

# 查看docker镜像、容器、数据卷占用空间
docker system df
1
2
3
4
5
6
7
8
9
10
11
12
13

镜像拉取

例子(从DockerHub中拉取一个nginx镜像并查看):

1. 首先去镜像仓库搜索nginx镜像，比如DockerHub。

2. 根据查看到的镜像名称，拉取自己需要的镜像，通过命令：docker pull nginx。

3. 通过命令：docker images 查看拉取到的镜像。

4. 也可以通过指令：docker search nginx 查找镜像。

保存镜像

1. 查看docker save的语法。

docker save --help
# 命令格式
docker save -o [保存的目标文件名称] [镜像名称]
1
2
3

2. 使用docker save导出镜像到磁盘(nginx为例)。

docker save -o nginx.tar nginx:latest
# or
docker save nginx:latest > nginx.tar
1
2
3

删除镜像

docker rmi imageID/imageName:tag		# 删除镜像
docker rmi -f imageID/imageName:tag		# 强制删除镜像
docker rmi -f $(docker images -aq)		# 强制删除所有镜像
1
2
3

导入镜像

# 先删除本地镜像，后运行命令，加载本地文件。
docker load -i imageFileName
# or
docker load < imageFileName
1
2
3
4

镜像标签

# 对 oldImageName:tag 镜像打标签，生成 newImageName:tag 镜像
docker tag oldImageName:tag newImageName:tag
1
2

虚悬镜像

# 仓库名、标签皆为 <none> 的镜像，俗称 dangling image
# 查看虚悬镜像
docker image ls -f dangling=true
# 删除虚悬镜像
docker image prune
1
2
3
4
5

Container 容器

容器概念/状态

容器层概念：

• 当容器启动时，一个新的可写层被加载到镜像的顶部。这一层通常被称作容器层，容器层之下的都叫镜像层。
• 所有对容器的改动，论添加、删除、还是修改文件都只会发生在容器层中。只有容器层是可写的，容器层下面的所有镜像层都是只读的。

容器保护三个状态：

• 运行：进程正常运行。
• 暂停：进程暂停，CPU不再运行，并不释放内存。
• 停止：进程终止，回收进程占用的内存、CPU等资源。

查询/监控容器

# 列出目前所有的容器
docker ps -a 
# 查看完整的command的内容(导入容器时使用 command 命令)
docker ps --no-trunc 

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

# 查看容器日志
docker logs myNginx
# 查看容器内的进程
docker top myNginx
# 查看容器内部细节
docker inspect myNginx
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

创建/运行容器

# 前台交互式 - 创建并进入运行的容器
docker run -it ubuntu /bin/bash
# 很重要的要说明的一点: Docker 容器后台运行,就必须有一个前台进程。
# 容器运行的命令如果不是那些一直挂起的命令（比如运行 top），就是会自动退出的。
# 这个是docker的机制问题,比如你的 web 容器,我们以 nginx 为例。
# 正常情况下,我们配置启动服务只需要启动响应的 service 即可。
# 但是 nginx 为后台进程模式运行,就导致 docker 前台没有运行的应用。
# 这样的容器后台启动后,会立即自杀因为他觉得他没事可做了。
# 所以，最佳的解决方案是将你要运行的程序以前台进程的形式运行，常见就是命令行模式，表示还有交互操作。
1
2
3
4
5
6
7
8
9

# 后台守护式 - 创建并运行nginx容器
docker run --name myNginx -p 80:80 -d nginx
# 命令解读：
# docker run  创建并运行一个容器
# --name  给容器起一个名字，例如 myNginx
# -p  宿主机端口与容器端口映射，冒号左侧是宿主机端口，右侧是容器端口
# -d  容器后台运行
# -i  以交互模式运行容器，通常与 -t 同时使用
# -t  为容器重新分配一个伪输入终端，通常与 -i 同时使用
# --restart always  docker 服务启动后自动运行容器
# --restart unless-stopped  自动运行 docker 服务关闭前运行状态的容器
# --privileged=true  赋予 docker 容器内 root 用户真实管理员权限
# nginx  镜像名称，例如 nginx

# 虚拟机不稳定可能部分端口访问不了，可重启
reboot

# 运行停止的容器
docker start myNginx
# 重启容器
docker restart myNginx
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

进入/退出容器

# 进入 nginx 容器，并以命令行交互，会容器内打开新的终端
docker exec -it myNginx /bin/bash
# 进入 nginx 容器，并以命令行交互，使用容器本身终端
docker attach myNginx

# 退出容器：
# 若是创建时进入容器的情况，该命令会使容器停止
exit
# 在创建时进入容器的情况下退出，不会停止容器
ctrl+p+q
# 前台交互式启动时直接进入容器启动命令的终端，exit 退出会导致容器停止。
# 而 exec 会在容器内打开新的终端，exit 退出时不会导致容器停止。
1
2
3
4
5
6
7
8
9
10
11
12

停止/删除容器

# 停止容器
docker stop myNginx
# 强制停止容器
docker kill myNginx
# 恢复运行容器
docker unpause myNginx
# 停止运行容器
docker pause myNginx

# 删除某个容器
docker rm myNginx
# 强制删除某个容器
docker rm -f myNginx
# 强制删除所有容器
docker rm -f $(docker ps -aq)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

容器拷贝至主机

# 从容器内拷贝文件至主机目录（container:sourcedir tardir）
docker cp myNginx:/home/html/test.txt /mnt
1
2

导出/导入容器

# 导出容器为 压缩包 文件形式
docker export ubuntu > my_ubuntu.tar.gz

# 导入容器（容器导入后生成 lxl/nginx:1.0 的镜像）
cat my_ubuntu.tar | docker import - lxl/ubuntu:1.0
# 运行新导入的镜像
docker run --name lxl_ubuntu -p 80:80 -d lxl/ubuntu:1.0

# 可能出现 docker: Error response from daemon: No command specified 错误
# 解决方案：查看具体的 command，然后将 command 加入到启动命令最后即可。
docker ps ---no-trunc
# 查询可知，原来的 ubuntu 容器的 command 为 bash
docker run --name lxl_ubuntu -p 80:80 -d lxl/ubuntu:1.0 /bin/bash
1
2
3
4
5
6
7
8
9
10
11
12
13

容器快照提交

# 新镜像是从 base 镜像一层一层叠加生成的。每安装一个软件，就在现有镜像的基础上增加一层。
# 需要迁移 docker 容器时，可提交容器为一个新的镜像

# 提交 myNginx 容器为镜像
docker commit -m="MyNginx 迁移镜像" -a="LXL" myNginx lxl_nginx/1.0

# 参数说明：
# -m 提交镜像的描述信息
# -a 作者信息 
1
2
3
4
5
6
7
8
9

数据卷管理

**数据卷（volume）**是一个虚拟目录，指向宿主机文件系统中的某个目录。一旦完成数据卷挂载，对容器的一切操作都会作用在数据卷对应的宿主机目录了。

数据卷操作

# 创建 html 数据卷
# 新建的数据卷默认会放在linux主机的位置为：/var/lib/docker/volumes 目录中
docker volume create html
# 查看所有数据卷
docker volume ls 
# 查看 html 数据卷详细信息卷
docker volume inspect html
# 删除html数据卷
docker volume rm html
# 删除未使用的数据卷
docker volume prune
1
2
3
4
5
6
7
8
9
10
11

挂载数据卷

# 创建容器时，挂载数据卷
docker run --name mn -p 8080:80 \
# 把宿主机的 /root/docker/html_data 挂载到容器内的 /root/html 目录
-v /root/docker/html_data:/root/html \
--privileged=true \ # 解析如下：
nginx

# 问题：出现 cannot open directory .: Permission denied 的错误
# 解决方案： 挂载目录后添加一个 --privileged=true 参数
# 原因：CentOS7安全模块会比之前系统版本加强，不安全的会先禁止，所以目录挂载的情况被默认为不安全的行为。
# 使用该参数，container内的root拥有真正的root权限，否则，container内的root只是外部的一个普通用户权限。
1
2
3
4
5
6
7
8
9
10
11

数据卷读写权限

# 默认的数据卷的读写权限为 读写(rw)
-v /root/docker/html_data:/root/html:rw 
# 等同于：
-v /root/docker/html_data:/root/html:

# 设置容器内挂载目录读写权限为 只读(ro)
docker run --name mn -p 8080:80 \
-v /root/docker/html_data:/root/html:ro \  
nginx
1
2
3
4
5
6
7
8
9

数据卷继承共享

# 启动 nginx 第一个容器 mn1，设置挂载到宿主机的 /root/docker/html_data 目录
docker run --name mn1 -p 8080:80 \
-v /root/docker/html_data:/root/html nginx

# 启动 nginx 第二个容器 mn2，继承 mn1 的数据卷挂载关系
docker run --name mn2 -p 8081:80 \
--volumes-from mn1 nginx

# mn1 与 mn1 共享 /root/docker/html_data 目录下的数据
1
2
3
4
5
6
7
8
9

自定义镜像

Docker镜像结构

镜像是将应用程序及其需要的系统函数库、环境、配置、依赖打包而成。

以MySQL为例，来看看镜像的组成结构：

简单来说，镜像就是在系统函数库、运行环境基础上，添加应用程序文件、配置文件、依赖文件等组合，然后编写好启动脚本打包在一起形成的文件。

Dockerfile语法

Dockerfile就是一个文本文件，其中包含一个个的指令(Instruction)，用指令来说明要执行什么操作来构建镜像。每一个指令都会形成一层Layer。

更新详细语法说明，请参考官网文档。

构建并运行镜像

1. 基于Ubuntu构建Java项目，编辑Dockerfile文件。

# 举例：基于Ubuntu构建Java项目
# 指定基础镜像
FROM ubuntu:16.04
# 配置环境变量，JDK的安装目录
ENV JAVA_DIR=/usr/local
# 拷贝jdk和java项目的包
COPY ./jdk8.tar.gz $JAVA_DIR/
COPY ./docker-demo.jar /tmp/app.jar
# 安装JDK
RUN cd $JAVA_DIR \
 && tar -xf ./jdk8.tar.gz \
 && mv ./jdk1.8.0_144 ./java8
# 配置环境变量
ENV JAVA_HOME=$JAVA_DIR/java8
ENV PATH=$PATH:$JAVA_HOME/bin
# 暴露端口
EXPOSE 8090
# 使用 touch 将该文件的访问时间和修改时间为当前时间，不修改文件内容
RUN bash -c "touch /tmp/app.jar"
# 入口，java项目的启动命令
ENTRYPOINT java -jar /tmp/app.jar
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

2. 构建并运行镜像。

docker build -t javaweb:1.0 .
docker run --name javaweb -p 8090:8090 -d javaweb:1.0
1
2

Docker Network

网络原理

veth-pair技术：成对出现的虚拟设备接口，启动 docker 容器时，就会给该容器分配一个 ip，同时会生成两个网卡。一个网卡会放置于 docker 容器内，另一个会放置于宿主机上，两个网卡相互绑定用于通讯。

网络模式

1. host 模式：基于host模式，容器将不会获得一个独立的 network namespace，而是和宿主机共用一个 network namespace，容器将不会虚拟出自己的网卡等信息，而是使用宿主机的IP和端口。
2. container 模式：基于 container 模式，其实就是容器之间共享一个network namespace，而不是和宿主机共享。也就是说新创建的容器不会创建自己的网卡，配置自己的IP，而是和一个指定的容器共享网络环境，同样，两个容器除了网络方面相同之外，其他的包括文件系统，进程列表等还是隔离的。
3. none 模式：none 模式与其他模式都不同，这种模式 docker 容器会拥有自己独立的network namespace,但是呢，并不会为docker容骼进行任何网络配置，需要手动自定义。
4. bridge 桥接模式：是 docker 默认的网络模式，该模式宿主机会为每一个容器自动分配一个 network namespace，默认会将 docker 容器连接到一个虚拟网桥交换机 docker0 上。

自定义网络

作用：

1. 避免了由于 docker 容器重启更换 ip，导致的地址难以维护的问题。
2. 自定义网络本身维护好了主机名(容器名)与 ip 之间的对应关系，同一自定义网络下可以通过容器名称互 ping。
3. 自定义容器可使不同的集群使用不通的网络，保证了集群是安全和健康的。

原理：

1. 原本的桥接模式是使用 docker0 网卡作为路由，创建自定义网络为 bridge 模式后，该网络环境中的容器会使用新的网卡进行通讯。

网络命令

# 查看本机docker所有网络
docker network ls

# 创建网络  
# --driver 是网络模式
# --subnet是子网掩码，后面的/16表示可以生成6万多个ip
# --gateway是网关地址
docker network create networkName --driver bridge --subnet 192.168.0.1/16 --gateway 192.168.0.2 

# 将容器加入到当前网络
docker network connect networkName contaionName

# 断开容器的网络 （容器必须是运行状态才能断开连接）
docker network disconnect networkName contaionName

# 查看网络的详细信息
docker network inspect networkName/networkId

# 删除网络
docker network rm networkName/networkId

# 删除所有未使用的网络
docker network prune --f

# 启动容器时，指定网络环境(billygoo/tomcat8-jdk8为例)
docker run -d -p 8080:8080 --network mynetwork --name tomcat billygoo/tomcat8-jdk8
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

Docker-Compose

相关概念

Docker Compose可以基于Compose文件帮我们快速的部署分布式应用，而无需手动一个个创建和运行容器！Compose允许用户通过一个单独的 docker-compose.yml 模板文件（YAML 格式）来定义一组相关联的应用容器为一个项目（project）。可以很容易地用一个配置文件定义一个多容器的应用，然后使用一条指令安装这个应用的所有依赖，完成构建。Docker-Compose 解决了容器与容器之间如何管理编排的问题。

编排文件

yml 文件案例如下：

version: "3"
services:
	web:
		build: ./dir
		# 通过当前目录下的 Dockerfile 文件构建服务镜像
		# build:
		# 	context: .
		# 	dockerfile: Dockerfile
		# 	args:
     # 		argfirst: 1	# 对应 Dockerfile 文件中的 ARG 参数
    	ports:
    	# 端口映射，与 network_mode: host 不兼
    		- "80:80"
		networks: 
		# 指定容器所属网络
			- mynetwork 
		depends_on: 
		# 依赖于其他服务，需等待其他服务先启动成功后，在执行该服务启动
			- redis
			- mysql
		container_name: webApp	
		# 不指定时，容器名默认为：dirName_serverName_index
		restart: always
		# 指定重启策略
	redis:
		image: redis:6.0.8
		ports:
			- "6379:6379"
		volumes:
		# 容器卷挂载
			- /app/redis/redis.conf:/etc/redis/redis.conf
			- /app/redis/data:/data
		networks: 
			- mynetwork
		command: redis-server /etc/redis/redis.conf
	mysql:
		image: mysql:8.0.27
		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:
			- mynetwork
		command: 
		# 容器启动命令，对应 Dockerfile 中的 RUN 指令
			--default-authentication-plugin=mysql_native_password
			# 解决外部无法访问
networks: 
	mynetwork: 
		driver: bridge
		# 指定该网络所要使用的驱动：
		# bridge：表示桥接，Docker在单个主机上默认使用bridge网络。
		# overlay：在一个 swarm 中的多个节点之间创建一个命名网络。
		config:
			- subnet: 192.168.0.0/16
			# 子网掩码，即前16位为网段
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
62
63
64
65

应用安装

# 安装
curl -L https://github.com/docker/compose/releases/download/1.23.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

# 授权
chmod +x /usr/local/bin/docker-compose

# 安装自动补全依赖工具 bash-complete（可选），需重启 docker
yum install -y bash-completion
systemctl restart docker

# 下载 docker-composer 自动补齐脚本，并重加载该文件
curl -L https://raw.githubusercontent.com/docker/compose/1.29.1/contrib/completion/bash/docker-compose > /etc/bash_completion.d/docker-compose
source /etc/bash_completion.d/docker-compose

# 如果这里出现错误，需要修改自己的hosts文件：
echo "199.232.68.133 raw.githubusercontent.com" >> /etc/hosts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

常用命令

# 查看帮助
docker-compose -h                          
# 启动所有 docker-compose 服务
docker-compose up
# 启动所有 docker-compose 服务并后台运行
docker-compose up -d                      
# 停止并删除容器、网络、卷、镜像。
docker-compose down
# 进入工程中指定服务的容器
docker-compose exec serviceID bash
# 当一个服务拥有多个容器时，可通过 --index 参数进入到该服务下的任何容器
docker-compose exec --index=1 serviceID bash
# 展示当前 docker-compose 编排过的运行的所有容器
docker-compose ps
# 展示当前 docker-compose 所有编排过的容器(或指定服务的容器)进程
docker-compose top [serviceID]
# 查看容器输出日志
docker-compose logs serviceID 
# 检查配置
docker-compose config
# 检查配置，有问题才有输出
docker-compose config -q  
# 重启所有服务(或指定服务的容器)
docker-compose restart [serviceID]
# 启动服务(或指定服务的容器)
docker-compose start [serviceID]   
# 停止服务(或指定服务的容器)
docker-compose stop [serviceID]
# 暂停工程中所有服务的容器(或指定服务的容器)
docker-compose pause [serviceID]
# 拉取工程中所有服务依赖(或指定服务的容器)的镜像
docker-compose pull [serviceID]
# 拉取镜像过程中不打印拉取进度信息
docker-compose pull -q
# 在工程中指定服务的容器上执行 echo "helloworld"
docker-compose run serviceID echo "helloworld"
# 通过发送 SIGKILL 信号停止工程中指定服务的容器
docker-compose kill serviceID
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

搭建私服仓库

1. 下载镜像 Docker Registry，并运行启动。

# 拉取 registry 镜像
docker pull registry
# 创建并启动 registry 容器
docker run -d \
--restart=always \		# 重启docker时自动开启容器
--privileged=true \ 	# 使容器内 root 账户具有全部权限(默认普通用户权限)
--name registry	\	
-p 5000:5000 \
-v /var/docker_data/registry:/var/lib/registry \
registry
1
2
3
4
5
6
7
8
9
10

2. 修改配置文件使其支持 http 上传镜像。

# 打开要修改的文件
vi /etc/docker/daemon.json
# 添加内容：
"insecure-registries":["http://192.168.142.131:8080"]
# 重加载
systemctl daemon-reload
# 重启 docker
systemctl restart docker
# 重启 registry
1
2
3
4
5
6
7
8
9

3. 测试 registry 是否可以访问，以查询镜像命令进行测试。

# 查询私服仓库的镜像
curl -XGET http://192.168.88.186:5000/v2/_catalog
1
2

4. 安装图形化界面。

# 拉取 joxit/docker-registry-ui:static 镜像
docker pull joxit/docker-registry-ui:static
# 创建并启动 ui 界面
docker run \
--name registry-ui \
-d \
-e REGISTRY_TITLE=LXL_REGISTRY \				# 命名私服仓库
-e REGISTRY_URL=http://192.168.88.186:5000 \	# 私服仓库地址
-p 8080:80 
joxit/docker-registry-ui:static
# 测试：访问 http://192.168.88.186:8080 查看 ui 是否安装成功
1
2
3
4
5
6
7
8
9
10
11

5. 将运行的 Nginx 为例，提交容器，并命名为规范格式。

# 提交 nginx 容器
docker commit -m="my_nginx" -a="LXL" nginx my_nginx:1.0
# 标签命令将 my_nginx 改名为规范格式
docker tag my_nginx:1.0 192.168.88.186:5000/my_nginx:1.0
1
2
3
4

6. 推送镜像到私服仓库。

docker push 192.168.88.186:5000/my_nginx:1.0
# 同时查询 registry 私服仓库镜像，看是否上传成功
curl -XGET http://192.168.88.186:5000/v2/_catalog
1
2
3

7. 使用 docker-compose 简化 registry/ui 的部署。

# 创建文件docker-compose.yml
cd var/docker_data/registry_up
touch docker-compose.yml
# 编辑文件
vi docker-compose.yml
# 添加以下内容
version: '3.0'
services:
  registry:
    image: registry
    volumes:
      - /var/docker_data/registry:/var/lib/registry
  registry-ui:
    image: joxit/docker-registry-ui:static 
    ports:
      - 8080:80
    environment:
      - REGISTRY_TITLE=LXLREGISTRY # 仓库名
      - REGISTRY_URL=http://192.168.88.186:5000
    depends_on:
      - registry
# 执行命令
docker-compose up -d 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23