Docker从入门到精通！

课程来源：bilibili 遇见狂神说

docker英文文档网站：https://docs.docker.com/engine/install/centos/

一、理论与基础学习

前言、基础知识

docker隔离的核心技术是什么？

Linux中的namespace技术

介绍一下什么是namespace技术？

什么是守护进程？

“守护进程(daemon)是一类在后台运行的特殊进程，用于执行特定的系统任务。很多守护进程在系统引导的时候启动，并且一直运行直到系统关闭。另一些只在需要的时候才启动，完成任务后就自动结束。”

1、购买阿里云服务器

开通安全组

获取服务器的公网ip，修改实例名称

2、安装Docker-1

在本文中采用的系统为linux下的cent OS （7）

# 清楚一些不必要的内容，移除以前的docker版本
yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine
# 安装需要的依赖包
yum install -y yum-utils
# 设置镜像的仓库
yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo
## 建议选择国内的docker镜像源进行操作，现在选择的是阿里云
yum-config-manager \
	--add-repo \
	http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
## 更新yum软件包索引
yum makecache fast
# 安装docker-ce、容器等内容
yum install docker-ce docker-ce-cli containerd.io
## 查看可以安装的docker版本
yum list docker-ce --showduplicates | sort -r
## 可以选择自己想要的docker版本
yum install docker-ce-<VERSION_STRING> docker-ce-cli-<VERSION_STRING> containerd.io
# 启动docker
systemctl start docker
# 运行hello-world查看是否完成，见下图1
docker run hello-world
# 查看安装的docker版本，测试是否安装成功
docker version
# 通过docker images指令查看，见下图2
docker images

2、安装Docker-2

关于卸载docker

# 首先先从应用层面卸载内容，然后再从文件删除（Linux中万物都是文件）
yum remove docker-ce docker-ce-cli containerd.io
# 删除对应的文件内容
rm -rf /var/lib/docker
rm -rf /var/lib/containerd

配置阿里云容器镜像服务

登录自己的阿里云账号，产品与服务中选择容器镜像服务然后选择镜像工具中的镜像加速器

马赛克处填写自己的镜像加速地址

# 新建docker文件加
sudo mkdir -p /etc/docker

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

sudo systemctl daemon-reload
# 重启docker服务
sudo systemctl restart docker

3、了解Docker和Run

1、run images

2、查看本地是否有这个images

3、如果有，直接运行；如果否，去docker hub上下载，去4）

4、能否找到images，找到则执行2）；未找到images，就报错

4、底层原理

Docker是怎么工作的？

Docker是一个C/S结构的系统，Docker的守护jin运行在主机上。通过Socker从客户端访问！

Docker_Server收到Docker_Client的指令，就回执行在这俄格

Docker为什么是虚拟机更快?

docker比虚拟机拥有更少的抽象层

docker利用的是宿主机的内核，虚拟机需要Guest OS

所以说，新建一个容器的是狗，docker不需要重新加载一个操作系统内核，减少引导。

虚拟机加载一个新的Guest Os，分钟级别的，docker使用的宿主机的操作内核，秒级别。

5、Docker的常用命令

帮助命令

docker version   # 显示docker的基本信息
docker info      # 显示docker的详细信息
docker 命令 --help# 获取命令

镜像命令

docker images 查看所有本地的主机上的镜像

REPOSITORY    TAG       IMAGE ID       CREATED       SIZE
hello-world   latest    d1165f221234   5 weeks ago   13.3kB
# 解释
REPOSITORY 镜像的仓库源
TAG        镜像的标签
IMAGE ID   镜像的ID
CREATED    镜像的创建时间
SIEZ       镜像的大小
#  可选项
-a, --all     # 列出所有的镜像
-q, -quiet    # 只显示id

docker search 在docker hub上搜索镜像

NAME                              DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
mysql                             MySQL is a widely used, open-source relation…   10736     [OK]       
mariadb                           MariaDB Server is a high performing open sou…   4043      [OK]       

docker pull 下载镜像

# docker pull mysql 镜像名[:tag]
Using default tag: latest  # 不写TAG默认是最新的版本 
latest: Pulling from library/mysql
f7ec5a41d630: Pull complete  # 分层下载，docker image的核心
9444bb562699: Pull complete 
6a4207b96940: Pull complete 
181cefd361ce: Pull complete 
8a2090759d8a: Pull complete 
15f235e0d7ee: Pull complete 
d870539cd9db: Pull complete 
5726073179b6: Pull complete 
eadfac8b2520: Pull complete 
f5936a8c3f2b: Pull complete 
cca8ee89e625: Pull complete 
6c79df02586a: Pull complete 
Digest: sha256:6e0014cdd88092545557dee5e9eb7e1a3c84c9a14ad2418d5f2231e930967a38  # 签名信息
Status: Downloaded newer image for mysql:latest 
docker.io/library/mysql:latest  # 真实地址

# docker pull .io/library/mysql:latest 

# docekr pull mysql:5.7 # 下载指定版本的images
5.7: Pulling from library/mysql
f7ec5a41d630: Already exists   # 由于Linux的联合文件系统，某一些文件是可以实现共享
9444bb562699: Already exists 
6a4207b96940: Already exists 
181cefd361ce: Already exists 
8a2090759d8a: Already exists 
15f235e0d7ee: Already exists 
d870539cd9db: Already exists 
7310c448ab4f: Pull complete 
4a72aac2e800: Pull complete 
b1ab932f17c4: Pull complete 
1a985de740ee: Pull complete 
Digest: sha256:e42a18d0bd0aa746a734a49cbbcc079ccdf6681c474a238d38e79dc0884e0ecc
Status: Downloaded newer image

删除镜像

# docker rmi IMAGE_ID
# rmi => remove image
docker rmi -f IMAGE_ID # 删除指定的镜像
docker rmi -f IMAGE_ID IMAGE_ID IMAGE_ID # 删除多个镜像
docker rmi -f $(docker iamge -aq) # 删除全部的镜像

容器命令

说明： 有了镜像才可以做容器，先下载也给centos镜像作为测试学习

docker pull centos

新建容器并启动

docker run [可选参数] image
# 参数命名
--name='Name'   # 容器名字， 如mysql1，mysql2，用来区别不同的容器
-d              # 后台方式运行
-i              # 使用交互方式运行，进入容器检查看内容
-p              # 指定容器的端口
	-p ip:主机端口：容器端口
	-p 主机端口：容器端口
	-p 容器端口
	容器端口
-P              # 随机指定端口

# 启动并进入容器
REPOSITORY    TAG       IMAGE ID       CREATED        SIZE
mysql         5.7       450379344707   3 days ago     449MB
hello-world   latest    d1165f221234   5 weeks ago    13.3kB
centos        latest    300e315adb2f   4 months ago   209MB
[root@iZ2zeazmd74x8h83zuv6fcZ ~]# docker run -it centos /bin/bash
[root@4f6fb2ca9c2b /]# ls
# 退出当前容器
exit

列出所有的运行的容器

# docker ps  # 输出当前运行的容器
-a # 理出当前正在运行和历史中的容器
-n=？ # 输出最近的？个新建的容器
-q   # 只显示当前容器的编号
# docker ps -a
[root@iZ2zeazmd74x8h83zuv6fcZ /]# docker ps -a
CONTAINER ID   IMAGE         COMMAND       CREATED         STATUS                     PORTS     NAMES
4f6fb2ca9c2b   centos        "/bin/bash"   4 minutes ago   Exited (0) 2 minutes ago             kind_neumann
50e726de9d74   hello-world   "/hello"      3 hours ago     Exited (0) 3 hours ago               kind_noyce
fbfa57e6db5f   hello-world   "/hello"      7 hours ago     Exited (0) 7 hours ago               nice_fermat

退出容器

exit  # 容器停止并退出
Ctrl + p + q # 容器不停止退出

删除容器

docker rm # 容器id,不能删除正在运行的容器
docker rm -f $(docker ps -aq)  # 删除所有容器
docker ps -a -q|xargs docker rm # 删除所有容器，利用linux中的管道完成

启动和停止容器

docker start 容器id     # 启动容器
docker restart 容器id   # 重启容器
docker stop 容器id      # 暂停容器
docker kill 容器id      # 去掉容器

常用其他命令

后台启动容器

# 命令docker run -d 镜像名
docker run -d centos
问题docker ps：发现centos停止
# 常见的坑，docker容器使用后台运行，就必须要有一个前台进程，docker发现没有应用就会自动停止

查看日志

dockerlogs -t -f --tail 容器
# 自己编写一段脚本
docker run -d centos /bin/sh -c 'while true;do echo bandhus chen;sleep 1; done'
# 查看进行，可以看见容器centos在运行，并且有对应的容器id
docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS         PORTS     NAMES
644fad8d9ff5   centos    "/bin/sh -c 'while t…"   10 seconds ago   Up 9 seconds             intelligent_brahmagupta
# 由于上面写的脚本是循环脚本
# 读取文件日志
docker -tf --tail 10 644fad8d9ff5
-tf   # 显示日志
--tail number # 要显示的日志条数

查看容器中的进程信息

# 命令docker top 容器id
[root@iZ2zeazmd74x8h83zuv6fcZ ~]# docker top 644fad8d9ff5
UID                 PID                 PPID                C                   STIME               TTY             
root                8472                8451                0                   18:59               ?                   
root                9215                8472                0                   19:10               ?          
# docker 
[root@iZ2zeazmd74x8h83zuv6fcZ ~]# docker inspect 644fad8d9ff5
[
    {
        "Id": "644fad8d9ff501337abc078f4649bad5da9a92ec7c4d03c2ad5176b4a5bff41e",
        "Created": "2021-04-13T10:59:49.295975424Z",
        "Path": "/bin/sh",
        "Args": [
            "-c",
            "while true;do echo bandhus chen;sleep 1;done"
        ],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 8472,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2021-04-13T10:59:49.69763237Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:300e315adb2f96afe5f0b2780b87f28ae95231fe3bdd1e16b9ba606307728f55",
        "ResolvConfPath": "/var/lib/docker/containers/644fad8d9ff501337abc078f4649bad5da9a92ec7c4d03c2ad5176b4a5bff41e/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/644fad8d9ff501337abc078f4649bad5da9a92ec7c4d03c2ad5176b4a5bff41e/hostname",
        "HostsPath": "/var/lib/docker/containers/644fad8d9ff501337abc078f4649bad5da9a92ec7c4d03c2ad5176b4a5bff41e/hosts",
        "LogPath": "/var/lib/docker/containers/644fad8d9ff501337abc078f4649bad5da9a92ec7c4d03c2ad5176b4a5bff41e/644fad8d9ff501337abc078f4649bad5da9a92ec7c4d03c2ad5176b4a5bff41e-json.log",
        "Name": "/intelligent_brahmagupta",
        "RestartCount": 0,
        "Driver": "overlay2",
        "Platform": "linux",
        "MountLabel": "",
        "ProcessLabel": "",
        "AppArmorProfile": "",
        "ExecIDs": null,
        "HostConfig": {
            "Binds": null,
            "ContainerIDFile": "",
            "LogConfig": {
                "Type": "json-file",
                "Config": {}
            },
            "NetworkMode": "default",
            "PortBindings": {},
            "RestartPolicy": {
                "Name": "no",
                "MaximumRetryCount": 0
            },
            "AutoRemove": false,
            "VolumeDriver": "",
            "VolumesFrom": null,
            "CapAdd": null,
            "CapDrop": null,
            "CgroupnsMode": "host",
            "Dns": [],
            "DnsOptions": [],
            "DnsSearch": [],
            "ExtraHosts": null,
            "GroupAdd": null,
            "IpcMode": "private",
            "Cgroup": "",
            "Links": null,
            "OomScoreAdj": 0,
            "PidMode": "",
            "Privileged": false,
            "PublishAllPorts": false,
            "ReadonlyRootfs": false,
            "SecurityOpt": null,
            "UTSMode": "",
            "UsernsMode": "",
            "ShmSize": 67108864,
            "Runtime": "runc",
            "ConsoleSize": [
                0,
                0
            ],
            "Isolation": "",
            "CpuShares": 0,
            "Memory": 0,
            "NanoCpus": 0,
            "CgroupParent": "",
            "BlkioWeight": 0,
            "BlkioWeightDevice": [],
            "BlkioDeviceReadBps": null,
            "BlkioDeviceWriteBps": null,
            "BlkioDeviceReadIOps": null,
            "BlkioDeviceWriteIOps": null,
            "CpuPeriod": 0,
            "CpuQuota": 0,
            "CpuRealtimePeriod": 0,
            "CpuRealtimeRuntime": 0,
            "CpusetCpus": "",
            "CpusetMems": "",
            "Devices": [],
            "DeviceCgroupRules": null,
            "DeviceRequests": null,
            "KernelMemory": 0,
            "KernelMemoryTCP": 0,
            "MemoryReservation": 0,
            "MemorySwap": 0,
            "MemorySwappiness": null,
            "OomKillDisable": false,
            "PidsLimit": null,
            "Ulimits": null,
            "CpuCount": 0,
            "CpuPercent": 0,
            "IOMaximumIOps": 0,
            "IOMaximumBandwidth": 0,
            "MaskedPaths": [
                "/proc/asound",
                "/proc/acpi",
                "/proc/kcore",
                "/proc/keys",
                "/proc/latency_stats",
                "/proc/timer_list",
                "/proc/timer_stats",
                "/proc/sched_debug",
                "/proc/scsi",
                "/sys/firmware"
            ],
            "ReadonlyPaths": [
                "/proc/bus",
                "/proc/fs",
                "/proc/irq",
                "/proc/sys",
                "/proc/sysrq-trigger"
            ]
        },
        "GraphDriver": {
            "Data": {
                "LowerDir": "/var/lib/docker/overlay2/7c18b5d372631c762562c842cafb8f7ac4c8e1f647ac71256aea400bf8d906a5-init/diff:/var/lib/docker/overlay2/468e11f2a421f1b89c42f3401ed21a18f824f477ac1f46aaa7731a6d25ef9608/diff",
                "MergedDir": "/var/lib/docker/overlay2/7c18b5d372631c762562c842cafb8f7ac4c8e1f647ac71256aea400bf8d906a5/merged",
                "UpperDir": "/var/lib/docker/overlay2/7c18b5d372631c762562c842cafb8f7ac4c8e1f647ac71256aea400bf8d906a5/diff",
                "WorkDir": "/var/lib/docker/overlay2/7c18b5d372631c762562c842cafb8f7ac4c8e1f647ac71256aea400bf8d906a5/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "644fad8d9ff5",
            "Domainname": "",
            "User": "",
            "AttachStdin": false,
            "AttachStdout": false,
            "AttachStderr": false,
            "Tty": false,
            "OpenStdin": false,
            "StdinOnce": false,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
            ],
            "Cmd": [
                "/bin/sh",
                "-c",
                "while true;do echo bandhus chen;sleep 1;done"
            ],
            "Image": "centos",
            "Volumes": null,
            "WorkingDir": "",
            "Entrypoint": null,
            "OnBuild": null,
            "Labels": {
                "org.label-schema.build-date": "20201204",
                "org.label-schema.license": "GPLv2",
                "org.label-schema.name": "CentOS Base Image",
                "org.label-schema.schema-version": "1.0",
                "org.label-schema.vendor": "CentOS"
            }
        },
        "NetworkSettings": {
            "Bridge": "",
            "SandboxID": "68c6ee90cb7fce04e482c37254ce14bbfb6c2d3900bdcf350babfe359db8fe43",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/68c6ee90cb7f",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "ea72ab495d9d7745a391266709fdf4fe871c8ca87492b7840415c89fad33f691",
            "Gateway": "172.17.0.1",
            "GlobalIPv6Address": "",
            "GlobalIPv6PrefixLen": 0,
            "IPAddress": "172.17.0.2",
            "IPPrefixLen": 16,
            "IPv6Gateway": "",
            "MacAddress": "02:42:ac:11:00:02",
            "Networks": {
                "bridge": {
                    "IPAMConfig": null,
                    "Links": null,
                    "Aliases": null,
                    "NetworkID": "7f0d0d0c10910c494b7470326dbd04d4f1c418e18a2aad77fcf3486f5876a290",
                    "EndpointID": "ea72ab495d9d7745a391266709fdf4fe871c8ca87492b7840415c89fad33f691",
                    "Gateway": "172.17.0.1",
                    "IPAddress": "172.17.0.2",
                    "IPPrefixLen": 16,
                    "IPv6Gateway": "",
                    "GlobalIPv6Address": "",
                    "GlobalIPv6PrefixLen": 0,
                    "MacAddress": "02:42:ac:11:00:02",
                    "DriverOpts": null
                }
            }
        }
    }
]
# 可以发现进程号和id之间有关联性

进入当前正在运行的容器

# 进入容器修改一些内容
# 命令一
docker exec -it 644fad8d9ff5 /bin/bash
[root@644fad8d9ff5 /]# ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 10:59 ?        00:00:00 /bin/sh -c while true;do echo ban
root      1147     0  0 11:18 pts/0    00:00:00 /bin/bash
root      1232     1  0 11:20 ?        00:00:00 /usr/bin/coreutils --coreutils-pr
root      1233  1147  0 11:20 pts/0    00:00:00 ps -ef
# 命令二
docker attach 644fad8d9ff5 # 直接进入程序
# 正在执行代码
exec # 进入容器后开启新的终端
attach # 进入容器正在执行的终端

从容器内复制内容到宿主机上

[root@iZ2zeazmd74x8h83zuv6fcZ ~]# docker run -it centos /bin/bash
# 开启一个新的centos服务
# 从docker内部复制文件，哪怕docker不再运行也是可以
docker cp dockerid:/home/bin/xxx /home
# 将dockerid的容器中 home文件下的bin中内容复制到宿主机的home文件下

6、小结

可视化命令大全

可视化操作：

portainer是docker的图形化界面管理工具

docker run -d -p 8088:9000 --restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer

(记得要在阿里云的安全组开通8088权限，也可以尝试在内网访问端口)

curl localhost:8088

二、实操开始！

1、Docker安装Nginx

Nginx 负责负载均衡和反向代理

# 搜索镜像 search
docker search nginx
# 下载镜像 pull
docker pull nginx
# 查看镜像是否下载成功
docker images
# 运行下载好的nginx
docker run -d --name nginx01 -p 3344:80 nginx
-d 后台运行
--name nickname
-p 宿主机端口：容器内端口
# 本机测试
curl localhost:3344
# 出现如下界面，则表示nginx安装完成

可能会出现的问题：1、在ECS上没有配置自己的安全组规则。

如何实现宿主机和容器的挂载？

2、Docker安装Tomcat

# 官方的时候
docker run -it --rm tomcat:9.0
# 表示停止了容器之后，容器直接删除。

# 直接下载
docker pull tomcat
# 
docker run -d -p 3355:8080 --name tomcat01 tomcat
# 如下表示正常搭建镜像tomcat

表示找到对应的服务器，但是无法正常访问而已。

# 进入容器
docker exec -it tomcat01 /bin/bash
# 发现问题：1）Linux命令缺少；2）没有webapps 这是阿里云的镜像的原因，默认最小的镜像，将一些不必要的镜像剔除掉。

# 解决方案（不太了解tomcat）
# 进入镜像，发现在webapps.dist中存在一定的项目，可以将内容全部复制到webapps中
cp -r webapps.dist/* webapps/
# 再次访问主机号：3355，出现一下界面表示访问成功！

3、Docker 安装es+kibana

# es暴露的端口很多！
# es十分耗内存
# es的数据需要挂载在安全目录
# 启动es，占用比较大的内容
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e 'discovery.type=single-node' elasticsearch:7.6.2
# 查看cpu的状态
docker stats
# 测试es状态
curl localhost:9200
# 出现如下界面表示成功

# 重新运行es，并对内容村进行限制
docker run -d --name elasticsearch01 -p 9200:9200 -p 9300:9300 -e 'discovery.type=single-node' -e\
ES_JAVA_OPTS='-Xms 64m -Xmx512m' elasticsearch:7.6.2

三、提交镜像

# 开启tomcat
docker run -it -p 8080:8080 tomcat
# 进入tomcat文件
docker exec -it tomcat_id /bin/bash
# tomcat从webapps.dist复制文件
cp -r webapps.dist/* webapps/
# 然后访问主机：8080

# 提交镜像
docker commit -a='CC' -m='add test' `tomcat_id` tomcat02:1.0
docker images

四、容器数据卷

docker的理念回顾

将应用和环境打包成一个镜像！故数据不能存在镜像中，数据就会消失！

需求：数据可以持久化、数据可以存储在本地

容器之间可以有一个数据共享的技术！Docker容器中产生的数据，同步到本地！

这就是卷技术！目录的挂载，将我们的容器内的目录，挂载到Linux上面！

使用数据卷

# 使用命令来挂载 -v  volume（卷）
docker run -it -d -v 主机目录：容器内目录 -p 主机端口：容器端口 
# 测试(会在外部自动创建)
docker run -it -v /home/ceshi:/home centos /bin/bash
# 查看docker内容，看看挂载地址是否正确
docker inspect `centos_id` 

如果内外目录发生变化，就会同时发生变化。

可以在自己的服务器上测试是不是可以保定。

实战：安装MySQL

# Mysql数据挂载
docker -d -p 3306:3006 -v /home/mysql
# 安装启动mysql，需要配置密码（官方）
docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag
# 启动我们自己的mysql
docker run -d -p 3310:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7
# 一些启动配置
-d 后台运行
-p 端口映射
-v 卷挂载
-e 环境配置
--name 容器名字
# 利用本地的SQLlog软件测试远程的mysql访问，出现如下就代表通过测试。

连接上远程数据库后，

在可视化端口添加一个test数据库，可以发现在挂载目录可以看见

这样就可以实现数据的持久化操作。

具名改在和匿名挂载

# 匿名挂载
-v 容器内路径！
-P 随机映射端口
docker run -d -P --name nginx01 -v /etc/nginx nginx
# 查看所有volume的情况
docker volume ls
local     3b9b29ff7d2c6293e14b684ea3bb7b6fa5dca83ec6f261f94b88a4242d165962
local     517aa677f100b1d76cdc13d0c3f842f4feffe2254cfa7f8505dfd1b7b5a9f04d
# 这是发现，这种匿名挂载是因为我们run的时候没有给出对应的文件的外部挂载位置

# 具名挂载
docker run -d -P --name nginx02 -v juming:/etc/nginx nginx

# 查看具体的内容
docker inspect juming
# 可以查看到如下的对应内容，得到挂载地址

可以通过具名挂载，可以比较方便的找到我们的卷。

# 如何确定是具名挂载还是匿名挂载
-v 容器内路径  # 匿名挂载
-v 卷名：容器内路径 # 具名
-v 宿主机：容器内路径 # 指定路径挂载

# ro和rw  代表只读和读写
docker run -d -p --name nginx02 -v juming-nginx:/etc/nginx:ro nginx
docker run -d -p --name nginx02 -v juming-nginx:/etc/nginx:rw nginx
# 一旦这个设置了容器权限。容器对我们挂载的内容就是有限定了。
# ro只有宿主机可以操作。

五 、DockerFile

初试dockerfile

dockerfile就是用来构建docker镜像的构建文件！命令脚本！

通过这个脚本可以生成镜像，镜像是一层一层的

vim dockerfile01
# 指令（大写） 参数
FROM centos
VOLUME ['volume01','volume02']
CMD echo '----end-----'
CMD /bin/bash
#
docekr build -f  /home/docker-test-volume/dockerfile1 -t cjf/centos:1.0 .

出现上述内容表示安装成功，

# 可以通过 docker images查看内容
docker run -it images_id /bin/bash
ls # 后可以看到挂载的数据卷
docker inspect iamge_id

# 上述的挂载方式属于匿名挂载，
docker inspect `images_id`
# 查看对应的Mounts挂载内容

容器数据卷

多个mysql同步数据！

# 启动三个容器
docker run -it --name docker01 798d1b3782ce

# 建立新的镜像docker02 数据卷依赖docker01
docker run -it --name docker02 --volumes-from docker01 798d1b3782ce
# 运行成功后可以发现，在docker02中volume01中添加内容，也会同步部署到docker01中的内容上。
# 此时容器docker01相当于父容器，如果删除父容器仍然可以访问docker02，docker03中的volume01内的东西。

可以实现多个数据库数据共享。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qVhN0Fv3-1619160445881)(C:\Users\CJF\OneDrive\台式\md文件\image-20210415194353771.png)]

结论：

容器之间的配置信息的传递，数据卷容器的生命周期一直持续到没有容器使用为止。

Dockerfile进阶

dockerfile是用来构建docker镜像的文件！命令参数脚本！

构建步骤：

1、编写一个dockerfile文件

2、docker build构建成为一个镜像

3、docker run 运行镜像

4、docker push 发布镜像（Dockerhub、阿里云镜像仓库）

# 从dockerhub访问centos，可以发现在左下有Dockerfile访问文件，打开！

可以发现很多官方的镜像都是基础包，很多必须的内容是没有用的。

Dockerfile构建过程

基础知识：

1、每个保留关键字（指令）都是必须是大写字母

2、执行从上到下顺序执行

3、# 表示注释

4、每一个指令都会创建提交一个新的镜像层，并提交！

步骤：开发、部署、运维

DockerFile：构建文件，定义了一切的步骤，源代码！

Dockerimages: 通过DockerFile构建生成的镜像，最终发布和运行的产品，原来是通过jar或者ware发布

Docker容器：容器就是镜像运行起来提供服务的。

DockerFile的指令

FROM        # 基础镜像，一切从这里开始构建
MAINTAINER  # 告诉别人，镜像是谁写的，姓名+邮箱
RUN         # 镜像构建的时候需要运行的命令
ADD         # 步骤，给他一些支撑文件，给点资金支持！
WORKDIR     # 镜像的工作目录，可以指定
VOLUME      # 挂载的目录位置
EXPOSE      # 指定暴露端口
CMD         # 指定这个容器启动的时候要运行的命令，可以被替代
ENTRYPOINT  # 指定这个容器启动的时候要运行的命令，可以追加命令
ONBUILD     # 当构建一个被继承，这个是哦后就会触发ONBUILD，触发器
COPY        # 类似ADD，将文件拷贝到镜像中
ENV         # 构建的时候设置环境变量

实战1

# 镜像大部分都是从scratch开始的
# 创建一个自己的centos
# 在dockerfile中新建文件
FROM centos    # 基础镜像源
MAINTAINER cjf<None>  # 主要的维护者和邮箱
ENV MYPATH /usr/local   # 环境变量
WORKDIR $MYPATH        # 工作目录
RUN yum -y install vim   # 安装vim
RUM yum -y install net-tools  # 安装ifconfig
EXPOSE 80     # 暴露80端口号

CMD echo $MYPATH  # 输出MYPATH
CMD echo "----end------"   # 输出标识符
CMD /bin/bash   # 使用bash访问镜像

# 2、通过这个文件构建镜像
# 命令 docker build -f dockerfile文件路径 -t 镜像名:[tag]
docker build -f dockerfile01 -t mycentos:0.1 .
# 输出如下表示成功
Successfully built 8562c450dbcb
Successfully tagged mycentos:0.1
# 创建成功后
docker run -it mycentos:0.1 /bin/bash
# 进入对应的镜像中,测试刚才的命令

# 查看docker历史
docker history `image_id`

CMD和ENTRYPOINT之间的区别

# 可以设计一个最简单的dockerfile
FROM centos
CMD ["ls","-a"]
# build构建镜像
docker build -f dockerfile -t test .
# run运行
docker run `image_id`

# 如果向追加一个命令 -l  ls -al 会报错，
# 这是因为后续的指令会替换掉CMD中的对应内容

# 再创建一个dockerfile
FROM centos
ENTRYPOINT ["ls","-a"]
# build
# run
docker run `image_id` -l
# 可以发现不同CMD的报错，ENTRYPOINT的指令是可以补充在后面的
#  所以可以认为CMD不会覆盖，而ENTRYPOINT是通过替换来操作的。

Dockerfile中很多的命令都有相似之处，我们需要了解其中的区别，最好的方法就是对比之后发现结果。

实战2：Tomcat镜像

1、准备镜像文件tomcat压缩包，jdk的压缩包！

https://blog.csdn.net/doupeihua/article/details/51831947

https://pan.baidu.com/s/1O-QQ2VzdHv6PGP7WVy_1CA

2、编写Dockerfile，采用官方命名Dockerfile，build会自动寻找对应的内容

FROM centos
MAINTAINER CHENJUNFU<none>
COPY readme.md /usr/local/readme.md
ADD jdk-8u11-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.45.tar.gz /usrlocal/

RUN yum -y install vim

ENV MYPATH /usr/local
WORKDIR $MYPATH

ENV JAVA_HOME /usr/lcaol/jdk1.8.0_11
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.45
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.45
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

EXPOSE 8080
CMD /usr/local/apache-tomcat-9.0.45/bin/startup.sh && tail -F /url/local/apache-tomcat-9.0.45/bin/logs/catalina.out

3、Build

docker buid -t diytomcat  # 系统默认寻找Dockerfile

4、run

docker run -d -p 9090:8080 --name chenjunfutomcat -v /home/chenjunfu/test:/url/local/apache-tomcat-9.0.45/webapps/test -v /home/chenjunfu/tomcatlogs/:/local/apache-tocat-9.0.45/logs diytomcat

小结：

六、Docker网络

理解Docker0

# 回顾一下一些简单的命令
# 删除所有的镜像
docker rmi -f $(docekr images -aq)
# 删除所有容器
docker rm -f $(docekr ps -aq)
# 清空所有内容

# ip addr

三个不同的网络：

lo：本机回环地址

eth0：阿里云内网地址

docker0：本机地址

docker exec tomcat01 ip addr 
# 查看docker内部的网络号

# 可以测试一下本地的宿主机是否可以ping通
ping 172.17.0.2  # 发现可以通过ping指令
# 再次查看本地的ip addr
# 可以发现多出来了一个新的网络地址

# 新建一个tomcat02重新测试结果
docker run -d -P --name tomcat02 tomcat

原理

我们没启动一个docker容器，docker就会给docker容器分配一个ip，只要电脑中安装了docker，就会有一个网卡docker0桥接模式，使用的技术是veth-pair技术！

可以发现由容器带来的网卡是成对出现的，这是因为veth-pair导致的。

# veth就是一堆的虚拟设备结构，他们都是成对出现的，一段连接至协议，一段彼此相连，正因为这个特性，veth可以充当一个桥梁，连接各种虚拟网络设备。 
# 并且可以实现容器内部的网络互通 

结论：tomcat01和tomcat02是公用的路由器，docker0

所有的容器不指定网络的情况下，都是docker0路由的，docker会给我们容器分配一个可用的容器。

Docker使用的是Linux的桥接，宿主机是一个Docker容器的网桥。

Docker中所有的网络结构都是虚拟的，虚拟的转发效率高！

主要容器删除，虚拟端口就会被回收。

–link

# 思考一个场景，我们编写了一个微服务，database url=ip：，项目不重启，数据库ip换掉了，我们希望可以处理这个问题，可以用名字来进行访问容器？

docker exec -it tomcat02 ping tomcat01
ping: tomcat01: Name or service not known
# 这说明docker并不明白你再说什么，这应该如何解决呢？
# 使用--link可以实现两个镜像之间的互联
[root@iZ2zeazmd74x8h83zuv6fcZ home]# docker run -d -P --name tomcat03 --link tomcat02 tomcat
5f2de517f76e6d5d7ecc043f51645902a56e61cfa3fa4205ff886b3a78656631
[root@iZ2zeazmd74x8h83zuv6fcZ home]# docker exec -it tomcat03 ping tomcat02
PING tomcat02 (172.17.0.3) 56(84) bytes of data.
64 bytes from tomcat02 (172.17.0.3): icmp_seq=1 ttl=64 time=0.121 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=2 ttl=64 time=0.075 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=3 ttl=64 time=0.071 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=4 ttl=64 time=0.059 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=5 ttl=64 time=0.072 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=6 ttl=64 time=0.077 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=7 ttl=64 time=0.071 ms
^C
--- tomcat02 ping statistics ---
7 packets transmitted, 7 received, 0% packet loss, time 8ms
rtt min/avg/max/mdev = 0.059/0.078/0.121/0.018 ms
# 但是这是单向的，也就说tomcat02并不认识tomcat03

# 先查看一下03容器中有没有02的内容
docker inspect con_id | grep tomcat02
# 我们查看一下tomcat03的信息
docker inspect con_id 

# 查看hosts配置，在这里可以发现！
docker exec -it tomcat03 cat /etc/hosts

本质：所以–link就是再host配置中增加了对应的内容，就是一个host映射！现在已经不适用了（？学锤子）。

docker0问题：不支持容器名连接访问！

自定义网络

# 查看所有的docker网络

网络模式

bridge：桥接docker（默认，自己创建网络也是用这种模式）

none：不配置网络

host：和宿主机共享网络

container：容器网络连接，容器之间直接互联，局限很大！

# 清楚之前的所有容器，保证网络可以干净
docker rm -f $(docker ps -aq)
# 之前直接启动的命令，--net bridge，而这个就是我们的docker0
[root@iZ2zeazmd74x8h83zuv6fcZ home]# docker network create --driver bridge --subnet 192.168.0.0/24 --gateway 192.168.0.1 mynet
511821680cb2fa7d0cbcd118442f85f03e47442f5be4723c1c71b1839f01c812
[root@iZ2zeazmd74x8h83zuv6fcZ home]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
7f0d0d0c1091   bridge    bridge    local
8f4c8e773f52   host      host      local
511821680cb2   mynet     bridge    local
70e6c7bcf7a0   none      null      local

# 新建两个容器
docker run -d -P --name tomcat-net-02 --net mynet tomcat
docker run -d -P --name tomcat-net-01 --net mynet tomcat
# 这时候查看docker inspect mynet
# 就可查看出有多的网络

docker exec -it tomcat-net-01 ping tomcat-net-02
# 可以发现不适用--link也可以ping通！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RvSgejl0-1619160445897)(C:%5CUsers%5CCJF%5COneDrive%5C%E5%8F%B0%E5%BC%8F%5Cmd%E6%96%87%E4%BB%B6%5Cimage-20210416205701230.png)]

我们自定义的网络docker都已经帮我们维护好了对应的关系，推荐我们平时这样使用网络。

好处：

redis搭建自己的网络

mysql也搭建自己的网络

不同集群之间使用不用网络，网络内不互通，可以保证集群的正常部署。

网络联通

[root@iZ2zeazmd74x8h83zuv6fcZ home]# docker run -d -P --name tomcat01 tomcat
670beed9738d895fff82d9be92675a22883f0eba25952362671e4abb3b9803d5

[root@iZ2zeazmd74x8h83zuv6fcZ home]# docker run -d -P --name tomcat02 tomcat
3c44a145475275729ceddc9b0c23e23badb403651a527f3289549c825fe13f25
[root@iZ2zeazmd74x8h83zuv6fcZ home]# docker ps

CONTAINER ID   IMAGE     COMMAND             CREATED          STATUS          PORTS                                         NAMES
3c44a1454752   tomcat    "catalina.sh run"   3 seconds ago    Up 2 seconds    0.0.0.0:49161->8080/tcp, :::49161->8080/tcp   tomcat02
670beed9738d   tomcat    "catalina.sh run"   7 seconds ago    Up 6 seconds    0.0.0.0:49160->8080/tcp, :::49160->8080/tcp   tomcat01
b5e0cc231958   tomcat    "catalina.sh run"   21 minutes ago   Up 21 minutes   0.0.0.0:49159->8080/tcp, :::49159->8080/tcp   tomcat-net-02
cb955beb1c18   tomcat    "catalina.sh run"   21 minutes ago   Up 21 minutes   0.0.0.0:49158->8080/tcp, :::49158->8080/tcp   tomcat-net-01

[root@iZ2zeazmd74x8h83zuv6fcZ home]# docker exec -it 670beed9738d ping tomcat01
ping: tomcat01: Name or service not known

[root@iZ2zeazmd74x8h83zuv6fcZ home]# docker exec -it 670beed9738d ping 670beed9738d
PING 670beed9738d (172.17.0.2) 56(84) bytes of data.
64 bytes from 670beed9738d (172.17.0.2): icmp_seq=1 ttl=64 time=0.049 ms

# 将mynet与tomcat01容器连接在一起
docker network connect mynet tomcat01
[root@iZ2zeazmd74x8h83zuv6fcZ home]# docker network inspect mynet

实战！

由于我不了解什么是redis和springboot现在准备回炉重造！

七、应用篇

实战！安装属于自己的wordpress博客！

# 启动你的docker
system start docker 
# 安装mysql
docker run -itd -v -v /mydocker/mysql/conf:/etc/mysql/conf.d -v /mydocker/mysql/logs:/var/log/mysql
-v /mydocker/mysql/data:/var/lib/mysq -e MYSQL_ROOT_PASSWORD=111111 -p 3306:3306 --name=sql --restart=always mysql:5.7
# 注意！如果是第二次安装，可能会出现端口占用的问题，建议把-p 3306：3306的端口进行修改，例如 -p 3310：3306
docker run -itd -v /home/???????/wp:/var/www/html -p 80:80 --name=wp --restart=always wordpress
# 用本地的sqlyog访问一下远程的mysql，看看是否成功建立连接
# 并且登录进去新建一个对应名为wordpress的表

这时候可以登录浏览器访问自己的ip地址了！

常见问题：

1、觉得自己的主题不够好看？上传的压缩包很大怎么办？可能遇到的问题：上传的文件尺寸超过upload_max_filesize文件中定义的php.ini值。

# 找到对应的配置文件
find . -name '.htaccess'
# 出现如下内容
[root@iZ2zeazmd74x8h83zuv6fcZ wp]# find . -name '.htaccess'
./.htaccess
./wp-content/plugins/akismet/.htaccess
# 修改 .htaccess文件

然后就可以解决辽！