文章目录
- [实战1. Mysql 容器化安装](#实战1. Mysql 容器化安装)
-
- [1.1 查找Mysql镜像](#1.1 查找Mysql镜像)
- [1.2 拉取镜像](#1.2 拉取镜像)
- [1.3 查看启动用例](#1.3 查看启动用例)
- [1.4 进入容器登录](#1.4 进入容器登录)
- [1.5 释放空间](#1.5 释放空间)
- [实战2. Redis 容器化安装：Redis 容器创建](#实战2. Redis 容器化安装：Redis 容器创建)
-
- [2.1 下载 redis 镜像](#2.1 下载 redis 镜像)
- [2.2 启动容器](#2.2 启动容器)
- [2.3 设置key](#2.3 设置key)
- [2.4 配置链接](#2.4 配置链接)
- [2.5 查看key](#2.5 查看key)
- [2.6 退出容器](#2.6 退出容器)
- [实战3. C++容器制作](#实战3. C++容器制作)
-
- [3.1 中科大源](#3.1 中科大源)
- [3.2 下载 Ubuntu 镜像](#3.2 下载 Ubuntu 镜像)
- [3.3 启动容器](#3.3 启动容器)
- [3.4 配置国内镜像源加速](#3.4 配置国内镜像源加速)
- [3.5 安装 gcc vim](#3.5 安装 gcc vim)
- [3.6 编辑代码](#3.6 编辑代码)
- [3.7 编译代码](#3.7 编译代码)
- [3.8 在容器中运行](#3.8 在容器中运行)
- [3.9 清理容器](#3.9 清理容器)
- [实战4. SpringBoot 容器制作](#实战4. SpringBoot 容器制作)
-
- [4.1 编写 demo](#4.1 编写 demo)
-
- [4.1.1 创建 maven 项目](#4.1.1 创建 maven 项目)
- [4.1.2 编写主函数构建 Spring 容器](#4.1.2 编写主函数构建 Spring 容器)
- [4.1.3 编写控制器](#4.1.3 编写控制器)
- [4.1.4 使用 maven 打包生成 jar 包](#4.1.4 使用 maven 打包生成 jar 包)
- [4.1.5 测试 jar 包是否可用](#4.1.5 测试 jar 包是否可用)
- [4.1.6 上传到 Linux 服务器备用](#4.1.6 上传到 Linux 服务器备用)
- [4.2 制作容器](#4.2 制作容器)
-
- [4.2.1 下载 Ubuntu 镜像](#4.2.1 下载 Ubuntu 镜像)
- [4.2.2 启动容器](#4.2.2 启动容器)
- [4.2.3 配置国内镜像源加速](#4.2.3 配置国内镜像源加速)
- [4.2.4 安装 jdk](#4.2.4 安装 jdk)
- [4.2.5 打开新的 shell 窗口，将 jar 拷贝到容器里面](#4.2.5 打开新的 shell 窗口，将 jar 拷贝到容器里面)
- [4.2.6 查看容器中文件](#4.2.6 查看容器中文件)
- [4.2.7 启动 java 服务](#4.2.7 启动 java 服务)
- [4.2.8 通过浏览器访问页面](#4.2.8 通过浏览器访问页面)
- [4.2.9 释放资源](#4.2.9 释放资源)
- [实战5. 容器资源更新](#实战5. 容器资源更新)
-
- [5.1 我们运行一个 nginx](#5.1 我们运行一个 nginx)
- [5.2 查看资源变化](#5.2 查看资源变化)
- [5.3 更新最大内存](#5.3 更新最大内存)
- [5.4 再次查看内存](#5.4 再次查看内存)
- [5.5 停止容器](#5.5 停止容器)
- [6. 常见问题](#6. 常见问题)
-
- [6.1 docker create、docker start 和 docker run 有什么区别？](#6.1 docker create、docker start 和 docker run 有什么区别？)
- [6.2 docker import 和 docker load 有什么区别？](#6.2 docker import 和 docker load 有什么区别？)
- [6.3 docker rm & docker rmi & docker prune 的差异？](#6.3 docker rm & docker rmi & docker prune 的差异？)
实战1. Mysql 容器化安装
1.1 查找Mysql镜像
进入
mysql的镜像网站，查找mysql的镜像
可以看到有这么多的 tag
1.2 拉取镜像
我们选择使用最多的
5.7版本，拉取镜像
shell
root@yudukai:~# docker pull mysql:5.7
5.7: Pulling from library/mysql
df9a4d85569b: Pull complete
1c56c3d4ce74: Pull complete
ffc89e9dfd88: Pull complete
20e4dcae4c69: Pull complete
90986bb8de6e: Pull complete
e9f03a1c24ce: Pull complete
68c3898c2015: Pull complete
6b95a940e7b6: Pull complete
ae71319cb779: Pull complete
43d05e938198: Pull complete
064b2d298fba: Pull complete
96889c47a44a: Download complete
9eb6a52b8441: Download complete
Digest: sha256:4bc6bc963e6d8443453676cae56536f4b8156d78bae03c0145cbe47c2aad73bb
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7
root@yudukai:~# 1.3 查看启动用例
我们知道
msyql的默认端口是3306，而且有密码，查看官网的启动用例：
docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag指定了
mysql的密码信息
shell
#启动一个 msyql，并指定密码和端口开放
docker run --name mysql -e MYSQL_ROOT_PASSWORD=123456 -p 8200:3306 -d mysql:5.7
shell
root@yudukai:~# docker run --name mysql -e MYSQL_ROOT_PASSWORD=123456 -p 8200:3306 -d mysql:5.7
ff0060468c8245406b2400992399859d1fa3ca3616b4ad4941fd30443e50ee27
root@yudukai:~# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
ff0060468c82 mysql:5.7 "docker-entrypoint.s..." 19 seconds ago Up 16 seconds 33060/tcp, 0.0.0.0:8200->3306/tcp, [::]:8200->3306/tcp mysql
root@yudukai:~# 1.4 进入容器登录
我们进入容器登录，可以看到我们已经可以正常登录
msyql了
shell
root@yudukai:~# docker exec -it mysql bash
bash-4.2# mysql -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 2
Server version: 5.7.44 MySQL Community Server (GPL)
Copyright (c) 2000, 2023, Oracle and/or its affiliates.
Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
mysql> show databases;
+--------------------+
| Database |
+--------------------+
| information_schema |
| mysql |
| performance_schema |
| sys |
+--------------------+
4 rows in set (0.00 sec)
mysql> 如果我们对外开放了
8200端口，没有防火墙的话，我们可以通过GUI工具远程登录到界面上，进行图形化操作。
1.5 释放空间
shell
docker stop mysql
docker rm mysql实战2. Redis 容器化安装：Redis 容器创建
2.1 下载 redis 镜像
shell
root@yudukai:~# docker pull redis:7.0
7.0: Pulling from library/redis
a2318d6c47ec: Pull complete
73586727588c: Pull complete
b59068c7715f: Pull complete
96796a2514ff: Pull complete
b8c430d0189b: Pull complete
fcf1b4feeffd: Pull complete
bcec16c47e35: Pull complete
4f4fb700ef54: Pull complete
28736f73c42f: Download complete
b161831c5131: Download complete
Digest: sha256:352c1fdadc91926edda08f45aeb3f27f37194c2f14101229c0523a11195c96e3
Status: Downloaded newer image for redis:7.0
docker.io/library/redis:7.0
root@yudukai:~#2.2 启动容器
启动
redis容器
shell
docker run --name redis -p 8300:6379 -d redis:7.0
shell
root@yudukai:~# docker run --name redis -p 8300:6379 -d redis:7.0
69f2cc84e484da1b412e1a18228911fea7338879880b63b502fd825045436054
root@yudukai:~# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
69f2cc84e484 redis:7.0 "docker-entrypoint.s..." 5 seconds ago Up 4 seconds 0.0.0.0:8300->6379/tcp, [::]:8300->6379/tcp redis
root@yudukai:~# 2.3 设置key
进入容器，设置一个
key
shell
root@yudukai:~# docker exec -it redis bash
root@69f2cc84e484:/data# redis-cli
127.0.0.1:6379> set mykey 1
OK
127.0.0.1:6379> get mykey
"1"
127.0.0.1:6379> 如果开通了防火墙，我们可以通过可视化工具连接上，可视化工具下载地址：https://gitee.com/qishibo/AnotherRedisDesktopManager/releases
2.4 配置链接
2.5 查看key
2.6 退出容器
shell
docker stop redis
docker rm redis实战3. C++容器制作
3.1 中科大源
3.2 下载 Ubuntu 镜像
shell
root@yudukai:~# docker pull ubuntu:22.04
22.04: Pulling from library/ubuntu
98c4455a9898: Pull complete
398a0d4d3425: Download complete
Digest: sha256:5ec03bb3441e8b0bf3b4f9cd4629a1ae763010dc3035bb8da3ae6cf026486401
Status: Downloaded newer image for ubuntu:22.04
docker.io/library/ubuntu:22.04
root@yudukai:~# 3.3 启动容器
shell
root@yudukai:~# docker run --name mygcc -it ubuntu:22.04 bash
root@669148f4e3b2:/# 3.4 配置国内镜像源加速
shell
root@669148f4e3b2:/# sed -i 's@//.*archive.ubuntu.com@//mirrors.ustc.edu.cn@g' /etc/apt/sources.list
root@669148f4e3b2:/# 3.5 安装 gcc vim
shell
apt update
apt install gcc vim -y
shell
# 出问题的话就清理一下代理
unset http_proxy
unset https_proxy
unset all_proxy3.6 编辑代码
shell
root@669148f4e3b2:/# mkdir src
root@669148f4e3b2:/# cd src
root@669148f4e3b2:/src# vim demo.c输入以下内容：
c
#include <stdio.h>
int main()
{
printf("hello docker!\n");
return 0;
} 3.7 编译代码
shell
root@669148f4e3b2:/src# gcc demo.c -o demo3.8 在容器中运行
shell
root@669148f4e3b2:/src# ./demo
hello docker!
root@669148f4e3b2:/src# 退出容器
shell
root@669148f4e3b2:/src# exit
exit
root@yudukai:~# 这个时候可以看到我们的容器已经退出了，如果想再次进入使用 docker restart 就可以恢复容器
3.9 清理容器
shell
docker stop mygcc
docker rm mygcc实战4. SpringBoot 容器制作
4.1 编写 demo
使用
Spring Boot创建一个简单的demo， 在浏览器输出hello docker!。
首先下载idea，然后打开
点击new project
点击create
4.1.1 创建 maven 项目
选择 Spring Boot 2.x 的第一个发布版本 2.0.2.RELEASE，在 pom.xml 中添加 spring-boot 依赖
xml
<?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
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>springboot-demo</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<!-- 项目的 pom 定义继承自 SpringBoot 的父 pom -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.2.RELEASE</version>
</parent>
<!-- Web 项目，添加 spring-boot-starter-web 依赖即可，版本号由父 pom 已经定义好了，此处省略 -->
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
<!-- 添加 spring boot 项目构建插件 -->
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project> 添加这些：
先双击clean
再双击package
结束后也可以点一下这个
4.1.2 编写主函数构建 Spring 容器
java
package com.bittech.boot;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class ExampleApplication {
public static void main(String[] args) {
SpringApplication.run(ExampleApplication.class, args);
}
} 写好后看一下是否可以正常运行
4.1.3 编写控制器
编写ExampleApplication类
java
package com.bit;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/hello")
public class ExampleApplication {
@RequestMapping("")
public String index(){
return "hello I am from docker!";
}
}然后我们运行main函数
打开浏览器输入：
shell
http://127.0.0.1:8080/hello
4.1.4 使用 maven 打包生成 jar 包
再次点击
clean和package。
生成的 jar 包位于项目根路径下的 target 目录
4.1.5 测试 jar 包是否可用
然后进入路径
在这里打开终端
启动容器后， 访问 localhost:8080/hello 查看运行结果， 确认 jar 包可用。
4.1.6 上传到 Linux 服务器备用
shell
root@yudukai:~/108/spring_demo# pwd
/root/108/spring_demo
root@yudukai:~/108/spring_demo# ls
dockerdemo-1.0-SNAPSHOT.jar
root@yudukai:~/108/spring_demo# 4.2 制作容器
4.2.1 下载 Ubuntu 镜像
shell
docker pull ubuntu:22.04 4.2.2 启动容器
shell
root@139-159-150-152:/data/myworkdir/container# docker run -p 8080:8080 --name myjava -it ubuntu:22.04 bash
root@50d527b8343e:/#4.2.3 配置国内镜像源加速
shell
root@50d527b8343e:/# sed -i 's@//.*archive.ubuntu.com@//mirrors.ustc.edu.cn@g' /etc/apt/sources.list
root@50d527b8343e:/#4.2.4 安装 jdk
shell
apt update
apt install -y openjdk-8-jdk4.2.5 打开新的 shell 窗口，将 jar 拷贝到容器里面
shell
docker cp ./dockerdemo-1.0-SNAPSHOT.jar myjava:/app.jar
4.2.6 查看容器中文件
shell
root@fc2847def31b:/# ls
bin boot dev etc home lib lib32 lib64 libx32 media mnt opt proc root run sbin srv sys tmp usr var
root@fc2847def31b:/# ll
total 15820
drwxr-xr-x 1 root root 4096 Oct 8 05:59 ./
drwxr-xr-x 1 root root 4096 Oct 8 05:59 ../
-rwxr-xr-x 1 root root 0 Oct 8 05:53 .dockerenv*
-rw-r--r-- 1 root root 16125894 Oct 8 05:51 app.jar
lrwxrwxrwx 1 root root 7 Sep 24 14:05 bin -> usr/bin/
drwxr-xr-x 2 root root 4096 Apr 18 2022 boot/
drwxr-xr-x 5 root root 360 Oct 8 05:53 dev/
drwxr-xr-x 1 root root 4096 Oct 8 05:58 etc/
drwxr-xr-x 2 root root 4096 Apr 18 2022 home/
lrwxrwxrwx 1 root root 7 Sep 24 14:05 lib -> usr/lib/
lrwxrwxrwx 1 root root 9 Sep 24 14:05 lib32 -> usr/lib32/
lrwxrwxrwx 1 root root 9 Sep 24 14:05 lib64 -> usr/lib64/
lrwxrwxrwx 1 root root 10 Sep 24 14:05 libx32 -> usr/libx32/
drwxr-xr-x 2 root root 4096 Sep 24 14:05 media/
drwxr-xr-x 2 root root 4096 Sep 24 14:05 mnt/
drwxr-xr-x 2 root root 4096 Sep 24 14:05 opt/
dr-xr-xr-x 262 root root 0 Oct 8 05:53 proc/
drwx------ 2 root root 4096 Sep 24 14:12 root/
drwxr-xr-x 1 root root 4096 Oct 8 05:57 run/
lrwxrwxrwx 1 root root 8 Sep 24 14:05 sbin -> usr/sbin/
drwxr-xr-x 2 root root 4096 Sep 24 14:05 srv/
dr-xr-xr-x 13 root root 0 Oct 8 05:53 sys/
drwxrwxrwt 1 root root 4096 Oct 8 05:58 tmp/
drwxr-xr-x 1 root root 4096 Sep 24 14:05 usr/
drwxr-xr-x 1 root root 4096 Sep 24 14:12 var/
root@fc2847def31b:/# 4.2.7 启动 java 服务
shell
java -jar ./app.jar
4.2.8 通过浏览器访问页面
注意确保防火墙打开
ctrl+c退出服务，exit退出容器
4.2.9 释放资源
shell
docker stop myjava
docker rm myjava实战5. 容器资源更新
5.1 我们运行一个 nginx
shell
docker run -d --name mynginx5 -p 80:80 nginx:1.22.0我们可以通过 docker top 查看容器中有哪些进程，添加 aux，可以看到占用的内存和 CPU 信息
shell
root@yudukai:~/108/spring_demo# docker top mynginx5 aux
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 1796754 0.1 0.0 8920 5548 ? Ss 14:09 0:00 nginx: master process nginx -g daemon off;
systemd+ 1796829 0.0 0.0 9308 2524 ? S 14:09 0:00 nginx: worker process
systemd+ 1796830 0.0 0.0 9308 2524 ? S 14:09 0:00 nginx: worker process
systemd+ 1796831 0.0 0.0 9308 2524 ? S 14:09 0:00 nginx: worker process
systemd+ 1796832 0.0 0.0 9308 2524 ? S 14:09 0:00 nginx: worker process
root@yudukai:~/108/spring_demo# 5.2 查看资源变化
通过
docker stats可以看到资源的动态变化
shell
root@yudukai:~/108/spring_demo# docker stats
CONTAINER ID NAME CPU % MEM USAGE / LIMIT MEM % NET I/O BLOCK I/O PIDSf3e319361a69 mynginx5 0.00% 4.766MiB / 7.763GiB 0.06% 726B / 126B 807kB / 12.3kB 5
58109926ba0a mynginx004 0.00% 3.934MiB / 7.763GiB 0.05% 34.3kB / 126B 0B / 4.1kB 5c9e86c4f9bf3 mynginx003 0.00% 3.969MiB / 7.763GiB 0.05% 34.3kB / 126B 12.3kB / 4.1kB 5
c42b26328912 mynginx001 0.00% 4MiB / 7.763GiB 0.05% 34.3kB / 126B 12.3kB / 4.1kB 5
8c523baaa860 boring_torvalds 0.00% 4.711MiB / 7.763GiB 0.06% 34.2kB / 126B 20.5kB / 4.1kB 5
ea63b99ba74d mywebsite2 0.00% 4.02MiB / 7.763GiB 0.05% 34.1kB / 126B 1.15MB / 4.1kB 5
^Croot@yudukai:~/108/spring_demo# 5.3 更新最大内存
我们通过
docker update更新docker的最大内存
shell
root@yudukai:~/108/spring_demodocker update -m 300m --memory-swap 600m mynginx5
mynginx5
root@yudukai:~/108/spring_demo# 5.4 再次查看内存
我们通过
docker stats再次查看可以看到内存已经被限制到300m了
shell
root@yudukai:~/108/spring_demo# docker stats
CONTAINER ID NAME CPU % MEM USAGE / LIMIT MEM % NET I/O BLOCK I/O PIDSf3e319361a69 mynginx5 0.00% 4.766MiB / 300MiB 1.59% 866B / 126B 807kB / 12.3kB 5
58109926ba0a mynginx004 0.00% 3.934MiB / 7.763GiB 0.05% 34.3kB / 126B 0B / 4.1kB 5c9e86c4f9bf3 mynginx003 0.00% 3.969MiB / 7.763GiB 0.05% 34.3kB / 126B 12.3kB / 4.1kB 5
c42b26328912 mynginx001 0.00% 4MiB / 7.763GiB 0.05% 34.3kB / 126B 12.3kB / 4.1kB 5
8c523baaa860 boring_torvalds 0.00% 4.711MiB / 7.763GiB 0.06% 34.2kB / 126B 20.5kB / 4.1kB 5
ea63b99ba74d mywebsite2 0.00% 4.02MiB / 7.763GiB 0.05% 34.1kB / 126B 1.15MB / 4.1kB 5
^Croot@yudukai:~/108/spring_demo#
shell
root@yudukai:~/108/spring_demo# docker exec -it mynginx5 bash
# 我们在容器中执行一个命令，打满 cpu
root@f3e319361a69:/# for i in $(seq 1 $(nproc)); do dd if=/dev/zero of=/dev/null & done
[1] 43
[2] 44
[3] 45
[4] 46
root@f3e319361a69:/# exit
exit
root@yudukai:~/108/spring_demo#
shell
#说明：
#cat /proc/cpuinfo |grep "physical id" | wc -l 可以获得 CPU 的个数, 我们将其表示为 N
#seq 1 N 用来生成１到Ｎ之间的数字
#for i in seq 1 N; 就是循环执行命令,从１到Ｎ
#dd if=/dev/zero of=/dev/null 执行 dd 命令, 输出到/dev/null, 实际上只占用 CPU, 没有 IO 操作
#由于连续执行Ｎ个(Ｎ是 CPU 个数)的 dd 命令, 且使用率为 100%, 这时调度器会调度每个 dd 命令在不同的 CPU 上处理，最终就实现所有ＣＰＵ占用率 100%
shell
CONTAINER ID NAME CPU % MEM USAGE / LIMIT MEM % NET I/O BLOCK I/O PIDSf3e319361a69 mynginx5 398.31% 5.516MiB / 300MiB 1.84% 936B / 126B 848kB / 16.4kB 9
58109926ba0a mynginx004 0.00% 3.934MiB / 7.763GiB 0.05% 34.3kB / 126B 0B / 4.1kB 5c9e86c4f9bf3 mynginx003 0.00% 3.969MiB / 7.763GiB 0.05% 34.3kB / 126B 12.3kB / 4.1kB 5
c42b26328912 mynginx001 0.00% 4MiB / 7.763GiB 0.05% 34.3kB / 126B 12.3kB / 4.1kB 5
8c523baaa860 boring_torvalds 0.00% 4.711MiB / 7.763GiB 0.06% 34.2kB / 126B 20.5kB / 4.1kB 5
ea63b99ba74d mywebsite2 0.00% 4.02MiB / 7.763GiB 0.05% 34.1kB / 126B 1.15MB / 4.1kB 5
^Croot@yudukai:~/108/spring_demo# 执行命令配置只能使用 10%的 cpu
shell
docker update --cpu-period=100000 --cpu-quota=10000 mynginx5可以看到 cpu 已经只能到 10%左右了
shell
CONTAINER ID NAME CPU % MEM USAGE / LIMIT MEM % NET I/O BLOCK I/O PIDSf3e319361a69 mynginx5 9.50% 5.516MiB / 300MiB 1.84% 936B / 126B 848kB / 16.4kB 9
58109926ba0a mynginx004 0.00% 3.934MiB / 7.763GiB 0.05% 34.3kB / 126B 0B / 4.1kB 5c9e86c4f9bf3 mynginx003 0.00% 3.969MiB / 7.763GiB 0.05% 34.3kB / 126B 12.3kB / 4.1kB 5
c42b26328912 mynginx001 0.00% 4MiB / 7.763GiB 0.05% 34.3kB / 126B 12.3kB / 4.1kB 5
8c523baaa860 boring_torvalds 0.00% 4.711MiB / 7.763GiB 0.06% 34.2kB / 126B 20.5kB / 4.1kB 5
ea63b99ba74d mywebsite2 0.00% 4.02MiB / 7.763GiB 0.05% 34.1kB / 126B 1.15MB / 4.1kB 5
^Croot@yudukai:~/108/spring_demo# 5.5 停止容器
停止容器，释放资源
shell
docker stop mynginx5
docker rm mynginx56. 常见问题
6.1 docker create、docker start 和 docker run 有什么区别？
docker create：命令从Docker映像创建一个全新的容器。但是，它不会立即运行它。
docker start：命令将启动任何已停止的容器。如果使用
docker create命令创建容器，则可以使用此命令启动它。
docker run：命令是创建和启动的组合，因为它创建了一个新容器并立即启动它。实际上，如果
docker run命令在您的系统上找不到上述映像，它可以从Docker Hub中提取映像。
6.2 docker import 和 docker load 有什么区别？
想要了解
docker load与docker import命令的区别，还必须知道docker save与docker export命令：
docker save images_name：将一个镜像导出为文件，再使用docker load命令将文件导入为一个镜像，会保存该镜像的的所有历史记录。比docker export命令导出的文件大，很好理解，因为会保存镜像的所有历史记录。docker export container_id：将一个容器导出为文件，再使用docker import命令将容器导入成为一个新的镜像，但是相比docker save命令，容器文件会丢失所有元数据和历史记录，仅保存容器当时的状态，相当于虚拟机快照。既可以使用
docker load命令来导入镜像库存储文件到本地镜像库，也可以使用docker import命令来导入一个容器快照到本地镜像库。两者的区别在于容器快照将会丢弃所有的历史记录和元数据信息，而镜像存储文件将保存完整记录，体积也会更大。
6.3 docker rm & docker rmi & docker prune 的差异？
docker rm：删除一个或多个容器docker rmi：删除一个或多个镜像docker prune：用来删除不再使用的docker对象