Docker容器入门_gpg: warning: unsafe ownership on homedir '/home/y

Docker容器技术

（一）、安装Docker

在Ubuntu系统中安装Docker的步骤如下：

1. 更新系统软件包列表：

   sudo apt update
   1

2. 安装依赖包，以支持使用HTTPS从仓库下载软件包：

   sudo apt install apt-transport-https ca-certificates curl software-properties-common
   1

3. 添加Docker官方的GPG密钥：

   curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
   1

   如果第三步提示：gpg：Warning：unsafe ownership on homedir ‘/home/g/.gnupg’

   • 这个警告是因为 gpg 发现 /home/g/.gnupg 目录的权限设置不安全。在安装 Docker 时，gpg 使用该目录来管理 GPG 密钥，确保软件包的安全性。

     为了修复这个问题，你需要更改 /home/g/.gnupg 目录的权限。执行以下命令，将该目录的所有权更改为当前用户：

     sudo chown -R $USER:$USER /home/g/.gnupg
     1

   • 执行完后重新执行第三步命令

4. 添加Docker的软件源：

   • 对于x86_64/AMD64架构的系统：

     echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
     1

   • 对于ARM64架构的系统：

     echo "deb [arch=arm64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
     1

5. 再次更新软件包列表：

   sudo apt update
   1

6. 安装Docker软件包：

   sudo apt install docker-ce
   1

7. 启动Docker服务：

   sudo systemctl start docker
   1

8. 确保Docker服务在系统启动时自动启动：

   sudo systemctl enable docker
   1

9. （可选）将当前用户添加到 docker 用户组，以便无需使用 sudo 命令运行 Docker：

   sudo usermod -aG docker $USER
   1

注意：完成上面的步骤后需要注销并重新登陆用户才能使用户组更改生效

查看是否安装成功

docker --version
1

（二）、初识Docker

1、Docker架构图

1. 分为三个部分：clients（客户端）、hosts（docker的核心）、registries（仓库）

   • clients发送指令给daemon实现操作
   • hosts分为：local host（本机）和remote host（远程机器）
     • 安装完docker后，docker会以daemon（守护进程）的形式存在
     • 在daemon（进程）里面有两部分内容：container（容器）和image（镜像）；container是根据image创建出来的动态实例；其中image是来源于registries
   • registries分为：官方仓库（服务器在国外，速度慢）和本地私有仓库（速度快，服务范围小）
     

2. 介绍

   • 镜像（image）：docker镜像（image），就相当于是一个root文件系统。比如官方镜像ubuntu16.04就是包含完整的一套ubuntu16.04最小系统的root文件系统
   • 容器（container）：镜像（image）和容器（container）的关系，就像是面向对象程序设计中的类和对象一样，镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等
   • **仓库（repository）：**仓库可以看成一个代码控制中心，用来保存镜像

2、配置Docker镜像加速

默认情况下，将从docker hub（https://hub.docker.com/）上下载docker镜像，但是速度慢，所以下边使用阿里云来加速

阿里云配置docker镜像加速

1. 进入阿里云官网，点击控制台，再点击左上角菜单，搜索容器镜像服务，在镜像工具中的镜像加速器

   每个人的加速地址都不同，并附有配置命令

   # 新建一个文件夹
   sudo mkdir -p /etc/docker
   
   # 并创建一个json文档，并写入内容
   sudo tee /etc/docker/daemon.json <<-'EOF'
   {
     "registry-mirrors": ["https://zkrkyri8.mirror.aliyuncs.com"]
   }
   EOF
   
   # 重新启动进程
   sudo systemctl daemon-reload
   
   # 重新启动docker服务
   sudo systemctl restart docker
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15

（三）、docker命令

1、docker服务相关命令

• 启动docker服务

  systemctl start docker
  1

• 停止docker服务

  systemctl stop docker
  1

• 重启docker服务

  systemctl restart docker
  1

• 查看docker服务状态

  systemctl status docker
  1

• 设置开机启动docker服务

  systemctl enable docker
  1

2、docker镜像相关命令

• 查看本地所有镜像

  docker images
  1

名称----版本号（最新本版会标识为latest）----id号----创建的时间----镜像的大小

• 查看本地所有镜像的id号

  docker images -q
  1

• 从网络中查找需要的镜像（以redis为例子）

  docker search redis
  1

名称----描述信息—评分（受欢迎程度）----是否为官方----是否是 “Automated Build” 自动构建的（基于最新代码构建）

• 拉取镜像（可以去docker的官网查看有哪些版本：https://hub.docker.com/）

  # 拉去最新版本，以redis为例子
  docker pull redis
  
  # 拉去指定版本，如redis7.0.12
  docker pull redis:7.0.12
  1
  2
  3
  4
  5

• 删除镜像（删除本地镜像）

  # 删除一个镜像，可以指定id号或者 名称:版本号
  docker rmi 镜像id号
  或
  docker rmi 名称:版本号
  
  # 删除所有镜像
  docker rmi `docker images -q`
  1
  2
  3
  4
  5
  6
  7

3、docker容器相关命令

• 创建容器

  # -i表示容器会一直运行（不会因为没有客户端连接而自动关闭），-t表示给容器分配一个伪终端，为容器起名字，并指定本地的镜像，进入容器的初始化实例（可以不加，相当于打开一个shell脚本窗口）
  docker run -it --name=c1 centos:latest /bin/bash
  1
  2

  通过 -it 创建的容器，创建完立马进入，退出则关闭容器；使用 -it 参数意味着你打开了一个交互式终端，这会保持容器处于一个交互式会话状态。因此，容器会一直运行，直到你在交互式终端中使用 exit 命令退出容器的交互式会话。
  

  # -d表示容器将在后台运行，并且不会打开一个交互式终端连接，即使输入exit也会一直在后台运行
  docker run -id --name=c2 centos:latest 
  1
  2

• 查看容器

  # 查看正在运行的容器
  docker ps
  
  # 查看所有容器
  docker ps -a
  1
  2
  3
  4
  5

  查看所有容器中，Up表示后台正在运行的容器，Exited表示没有在后台运行的容器
  

• 进入容器

  # 使用-it才能打开交互式终端，指定链接的容器，和指定打开的shell的路径
  docker exec -it c2 /bin/bash
  # 退出容器后，容器不会关闭
  1
  2
  3

  ---

参数总结说明：

• -i：保持容器运行。通常与-t同时使用。加入it这两个参数后，容器创建后自动进入容器中，退出容器后，容器自动关闭

• -t：为容器重新分配一个伪输入终端，通常与-i同时使用

• -d：以守护（后台）模式运行容器。创建一个容器在后台运行，需要使用docker exec进入容器。退出后，容器不会关闭

• -it创建的容器一般为称为交互式容器，-id创建的容器一般称为守护式容器

• --name：为创建的容器命名

  ---

• 启动容器（以c1为例）

  docker start c1
  1

• 关闭容器（以c2为例）

  docker stop c2
  1

• 删除容器

  # 删除c1这个容器(用容器名删除)
  docker rm c1
  
  # 删除所有容器(列出所有容器的id号并删除)
  docker rm `docker ps -aq`
  1
  2
  3
  4
  5

• 查看容器信息

  docker inspect c1
  1

（四）、容器的数据卷

1、概念

• 数据卷是宿主机中的一个目录或文件
• 当容器目录和数据卷目录绑定后，对方的修改会立即同步
• 一个数据卷可以被多个容器同时挂载
• 一个容器也可以被挂载多个数据卷
  

2、作用

• 容器数据持久化
• 外部机器和容器间通信
• 容器之间数据交换

3、配置数据卷

• 创建启动容器时，使用-v参数设置数据卷

  # -v 宿主机的目录（文件）:容器内目录（文件）
  docker run -it --name c1 -v /root/data:/root/data_container centos:latest
  1
  2

  注意：1.目录必须是绝对路径；2.如果目录不存在，会自动创建；3.可以挂载多个数据卷；
  

3.1、数据持久化

• 在容器内写入数据

  在容器内写入一个文件，在宿主机中的data文件下也会出现该文件
  

• 在容器内删除数据

  在容器内删除一个文件，在宿主机中的data文件下也会被删除
  

• 将容器删除，查看数据级的data文件夹是否还存在

  • 先写入一些数据
    

  • 删除c1这个容器

    可以看到容器删除后，宿主机中的data下边的文件还在
    

• 恢复c1这个容器（重新创建一个容器并与宿主机的文件挂载）
  

• 一个容器挂载多个目录

  \是换行继续写的意思

  docker run -it --name c4 -v ~/data1:/root/data1 \
  -v ~/data2:/root/data2 \
  -v ~/data3:/root/data3 centos:latest
  1
  2
  3

3.2、容器数据交互

仅需将同一个数据卷挂载到两个或多个容器中即可实现容器的数据交互

• 容器c1和c3都挂载同一个数据卷
  

3.3、数据卷容器

如果每个容器都要来配置数据卷，那工作量会很大，因此将数据卷挂载在一个容器A中，其他容器来容器A取数据卷，相当于容器A保存数据卷的路径，并告诉其他容器

• 创建启动c3数据卷容器，使用-v参数设置数据卷

  # 这里不用写数据卷目录（系统会给你指定一个路径，也可以自己指定路径），只需要写容器目录（这里命名为volume）
  docker run -it --name c3 -v /volume centos:latest
  1
  2

• 创建启动c1 c2容器，使用--volumes-from参数设置数据卷

  docker run -it --name c1 --volumes-from c3 centos:latest
  docker run -it --name c2 --volumes-from c3 centos:latest
  1
  2

• 创建成功后，查看容器的详细信息，可以看到容器的数据卷都指向同一个目录

  docker inspect c1
  docker inspect c2
  docker inspect c3
  1
  2
  3

• 删除容器c3

  可以看到并不会影响到c1和c2
  

（五）、docker应用部署

1、MySQL部署

1.1、需求

• 在docker容器中部署MySQL，并通过外部mysql客户端操作MySQL Server

1.2、实现步骤

• 搜索mysql镜像
• 拉去mysql镜像
• 创建容器
• 操作容器中的mysql

1.3、MySQL部署说明

• 容器内的网络服务和外部机器不能直接通信

• 外部机器和宿主机可以通信；宿主机和容器可以通信

• 当容器中的网络服务需要被外部机器访问时，可以将容器中提供服务的端口映射到宿主机的端口上。外部机器访问宿主机的该端口，从而间接访问容器的服务
  

  注意：一般都是容器端口映射到宿主机相同的端口，这里为了更加直观的展示，所以宿主的3307映射容器的3306

1.4、开始部署

1. 搜索mysql镜像

   docker search mysql
   1

2. 拉取mysql镜像

   docker pull mysql:5.7
   1

3. 宿主机创建目录存储mysql，并进入

   mkdir ~/mysql
   cd ~/mysql
   1
   2

4. 正常情况下创建并使用mysql

   # 需要使用 -e 来给root用户设置密码
   docker run -id --name mysqltest -e MYSQL_ROOT_PASSWORD=your_password mysql:5.7
   # 该指令执行结束后，相当于在容器中创建了一个linux系统，并在linux系统中安装了mysql
   
   # 接下来进入正在运行mysql的容器中
   docker exec -it mysqltest bash
   
   # 输入链接数据库
   mysql -u root -p
   1
   2
   3
   4
   5
   6
   7
   8
   9

5. 创建容器，设置端口映射、目录映射

   docker run -id \
   -p 3307:3306 \
   --name c_mysql \
   -v $PWD/conf:/etc/mysql/conf.d \
   -v $PWD/logs:/logs \
   -v $PWD/data:/var/lib/mysql \
   -e MYSQL_ROOT_PASSWORD=root \
   mysql:5.7
   
   # 3307:3306，3307为宿主端口，3306为容器端口
   # 因为创建之前我们在宿主机中已经进入了mysql这个目录，所以$PWD是当前目录
   # conf是配置文件
   # logs是日志文件
   # data是数据文件
   # -e 设置数据库登陆密码
   
   
   # 进入c_mysql容器
   docker exec -it c_mysql bash
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19

6. 外部主机访问虚拟机容器中的mysql
   

1.5、报错处理

主机连接虚拟机中容器的mysql出现：ERROR 1129 (HY000): Host ‘192.168.1.200’ is blocked because of many connection errors; unblock with ‘mysqladmin flush-hosts’

# 在容器中的mysql输入以下命令，以清除被阻止的主机列表：
FLUSH HOSTS;
1
2

2、Tomcat部署

2.1、需求

• 再docker容器中部署Tomcat，并通过外部机器（的浏览器）访问Tomcat部署的项目

2.2、实现步骤

• 搜索Tomcat镜像
• 拉取Tomcat镜像

2.3、开始部署

# 搜索镜像
docker search tomcat

# 拉去镜像
docker pull tomcat

# 在宿主机中创建一个tomcat目录并进入
mkdir ~/tomcat
cd tomcat

# 创建容器，设置端口和目录映射
docker run -id --name c_tomcat8080 \
-p 8080:8080 \
-v $PWD:/usr/local/tomcat/webapps \
tomcat

# 进入容器
docker exec -it c_tomcat8080 /bin/bash

# 在/usr/local/tomcat/webapps下创建一个test目录并创建一个hello.html
echo '<h1> hello tomcat docker </h1>' > hello.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

使用外部设备的浏览器访问

3、Nginx部署

3.1、需求

• 在docker容器中部署Nginx，并通过外部机器访问Nginx

3.2、实现步骤

• 搜索Nginx镜像
• 拉去Nginx镜像
• 创建容器
• 测试访问

3.3、开始部署

# 搜索镜像
docker search nginx

# 拉去镜像
docker pull nginx

# 在宿柱机创建nginx目录用于存储nginx数据信息，并进入
mkdir ~/nginx
cd ~/nginx
# 在nginx下创建并进入conf目录
mkdir conf
cd conf
# 并将以下内容写入nginx.conf中
user nginx;
worker_processes 1;

error_log /var/log/nginx/error.log warn;
pid /var/run/nginx.pid;

events{
	worker_connections 1024;
}

http{
	include /etc/nginx/mime.types;
	default_type application/octet-stream;
	log_format main '$remote_addr - $remote_user [$time_local] "$request"'
					'$status $body_bytes_sent "$http_referer"'
					'"$http_user_agent" "$http_x_forwarded_for"';
	access_log /var/log/nginx/access.log main;
	
	sendfile on;
	#tcp_nopush on;
	
	keepalive_timeout 65;
	
	#gzip on;
	
	include /etc/nginx/conf.d/*.conf;
}

# 创建容器，设置端口和目录映射
docker run -id --name c_nginx80 \
-p 80:80 \
-v $PWD/conf/nginx.conf:/etc/nginx/nginx.conf \
-v $PWD/logs:/var/log/nginx \
-v $PWD/html:/usr/share/nginx/html \
nginx

# 在宿主机器或容器的html目录下写入一个index.html（命名为index.html，直接访问会当作第一个页面显示）
echo "<h1> hello </h1>" > index.html
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

4、Redis部署

# 搜索镜像
docker search redis

# 拉去镜像
docker pull redis:5.0

# 创建容器，设置端口映射
docker run -id --name c_redis6379 -p 6379:6379 redis:5.0

# 使用外部机器连接redis
./redis-cli.exe -h ip地址 -p 6379
1
2
3
4
5
6
7
8
9
10
11

（六）、Dockerfile

1、镜像原理

1.1、操作系统组成部分：

• 进程调度子系统
• 进程通行子系统
• 内存管理子系统
• 设备管理子系统
• 文件管理子系统
• 网络通信子系统
• 作业控制子系统

1.2、Linux文件系统由bootfs和rootfs两部分组成

• bootfs：包含bootloader（引导加载程序）和kernel（内核）
• rootfs：root文件系统，包含的就是典型Linux系统中的/dev,/proc,/bin,/etc等标准目录和文件
• 不同的额linux发行版，bootfs基本一样，而rootfs不同，如ubuntu，centos等
  

1.3、原理

• docker镜像是由特殊的文件系统叠加而成
• 最底端是bootfs，并使用宿主机的bootfs
• 第二层是root文件系统rootfs，称为base image
• 然后再往上可以叠加其他的镜像文件

以上的技术称为：统一文件系统技术

• 统一文件系统技术能够将不同的层整合成一个文件系统，为这些层提供了一个统一的视角，这样就隐藏了多层的存在，在用户的角度看来，只存在一个文件系统（镜像只能读，不能修改）
  

• 一个镜像可以放在另外一个镜像的上面。位于下面的镜像称为父镜像，最底部的镜像称为基础镜像

• 当从一个镜像启动容器时，docker会在最顶层加载一个读写文件系统作为容器（可以修改）

思考：

1. docker镜像的本质是什么？

• 是一个分层文件系统

2. docker中一个centos镜像为什么只有200MB，而一个centos操作系统的iso文件要几个G？

• centos的iso镜像文件包含bootfs和rootfs，而docker的centos镜像复用操作系统的bootfs，只有rootfs和其他镜像层

3. docker中一个tomcat镜像为什么有500MB，而一个tomcat安装包只有70MB？

• 由于docker中镜像是分层的，tomcat虽然只有70多MB，但他叶需要依赖于父镜像和基础镜像，所有整个对外暴露的tomcat镜像大小500MB

2、镜像制作

docker镜像如何制作？

1. 容器转为镜像（该方法除了目录挂载外，其他目录下的改动文件都会一起包含在新的 镜像中）

# 容器转镜像
docker commit 容器id 镜像名称:版本号

# 镜像压缩
docker save -o 压缩文件名称 镜像名称:版本号

# 镜像解压
docker load -i 压缩文件名称
1
2
3
4
5
6
7
8

3、Dockerfile

Dokcerfile概念

• dockerfile是一个文本文件
• 包含一条条的指令
• 每一条指令构建一层，基于基础镜像，最终构建出一个新的镜像
• 对于开发人员：可以为开发团队提供一个完全一致的开发环境
• 对于测试人员：可以直接拿开发时所构建的镜像或者通过dockerfile文件构建一个新的镜像开始工作
• 对于运维人员：在部署时，可以实现应用的无缝移植

FROM centos:7
MAINTAINER JoyWon
RUN yum apt-get install vim
CMD ["bin/bash"]

解释：
FROM：指定父镜像
MAINTAINER：作者信息
RUN：执行什么指令
CMD：执行linux的指令，启动容器的命令
1
2
3
4
5
6
7
8
9
10

• 具体写法参考：Dochub：https://hub.docker.com，搜索需要部署的镜像—点击版本号进入即可查看配置dockefile

4、dockerfile关键字

5、Dockerfile案例

需求：

自定义centos7镜像，要求：

1. 默认登陆路径为 /usr
2. 可以使用vim（默认系统没安装vim）

实现步骤：

1. 定义父镜像：FROM centos:7
2. 定义作者信息：MAINTAINER JoyWon <joywon888@gmail.com>
3. 执行安装vim命令：RUN yum insatll -y vim
4. 定义默认的工作目录：WORKDIR /usr
5. 定义容器启动执行命令：CMD/bin/bash

将以上信息写入文件(centos_dockerfile)后执行

docker build -f ./centos_dockerfile -t 新的镜像名:版本号
1

进入容器可以验证下vim是否安装成功

（七）、Docker服务编排

1、简介

docker compose是一个编排多容器分布式部署的工具，提供命令集管理容器化应用的完整开发周期，包括服务构建，启动和停止。使用步骤：

1. 利用dockerfile定义运行环境镜像
2. 使用docker-compose.yml定义组成应用的各服务
3. 运行docker-compose up启动应用

2、docker compose安装使用

安装docker compose

# compose目前已经完全支持Linux、Mac、Windows，在安装compose之前需要先安装docker。以编译好的二进制包方式安装在Linux系统中
curl -L https://github.com/docker/compose/releases/download/1.22.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose

# 设置文件可执行权限
chmod +x /usr/local/bin/docker-compose

# 查看版本信息
docker-compose --version
1
2
3
4
5
6
7
8

3、卸载docker compose

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

4、使用

略过

（八）、docker私有仓库

1、搭建

# 拉取私有仓库镜像
docker pull registry

# 启动私有仓库容器
docker run -id --name registry -p 5000:5000 registry

# 打开浏览器，输入地址http://私有仓库服务器ip:5000/v2/_catalog，看到{"repositories":[]}表示私有仓库搭建成功

# 修改daemon.json
vim /etc/docker/daemon.json
# 在上述文件中添加一个key，保存退出。此步用于让docker信任私有仓库地址；私有仓库服务器ip是宿主机的ip
{"insecure-registries":["私有仓库服务器ip:5000"]}

# 重启docker服务
systemctl restart docker
docker start registry
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2、上传镜像

# 标记镜像为私有仓库的镜像（打个标签），“私有仓库服务器ip:5000/centos:7”是一个image的名字
docker tag centos:7 私有仓库服务器ip:5000/centos:7

# 上传标记的镜像
docker push 私有仓库服务器ip:5000/centos:7
1
2
3
4
5

3、拉去镜像

# 这里的pull不是去公网拉去的，是去容器中拉取的，即使docker images中的该镜像被删除也能拉去下来
docker pull 私有仓库服务器ip:5000/centos:7
1
2