Docker教程精要版

介绍

应用场景（作用）

安装特定软件无需考虑环境

什么是环境：比如运行一个软件，想自己用或者发给别人试试，需要tomcat、python，而tomcat又要安装java才能用，然后java可能还需要特定版本，不能过高也不能过低……
这些就叫环境。
除此之外，可能还涉及映射端口、文件夹设置、权限分配等，有的环境安错了甚至要重装系统，费时费力……
有了docker 就可以快速安装软件，不需要各种“教程”。甚至有时可以无视系统、硬件差异。

方便项目部署——集群、测试环境、换机器等等

项目可能需要安redis、mysql、nginx、tomcat才能用

• 避免换机器或者重置系统的时候 重复配置环境 快速部署 就像一个“windows镜像”。一般来说，开发只负责写代码，运维负责把代码部署到众多机器上（光代码不行 还得有环境）我们发布代码的时候，不光发布代码，还把环境也带上一起打包发布。
  运维这个角色就弱化了 不一样要有。
• 测试环境和线上环境 ，如果改了环境，要重复弄。以及，“我的电脑上可以用，你的为什么就不行”
• 集群多台机器的情况

有了docker后就可以这样的流程：我们开发代码，然后把运行环境一起打包，变成一个镜像，然后放到仓库中，之后不同的机器下载这个镜像，然后运行。

避免应用打架与同时安装多个版本的软件

docker图标 集装箱，隔离思想。
之前可能各个应用打架，比如共同占用一个端口，矛盾。而且可能一个崩溃了影响另一个。
而docker隔离后，一个在隔离的箱子中坏了不影响另一个
而且你还可以同时安装不同版本的软件，比如python2和python3 互相不影响

用完就丢 不影响系统运行速度

卸载也无残留，不像windows一些软件卸载了 还有残留文件

和虚拟机的不同：

虚拟机要安装整个系统，还得模拟硬件，笨重。比如开两个虚拟机，要模拟两套硬件、开两个系统。
而我们其实可能只是运行一个简单的软件，就得单独安个系统 开销太大 划不来。虚拟机还会安装很多你不需要的软件！
而容器共享操作系统和硬件资源。模拟的级别仅仅是（软件【如jdk、mysql等】+最核心的系统环境(4MB)）。有自己的文件存储，互相隔离。仅仅会安装你需要的软件。

名词解释

基本名词

• 打包:就是把你软件运行所需的依赖、第三方库、软件打包到一起，变成一个安装包
• 分发:你可以把你打包好的按装包"上传到一个镜像仓库，其他人可以非常方便的获取和安装
• 部署:拿着"安装包"就可以一个命令运行起来你的应用，自动模拟出一摸一样的运行环境，不管是在Windows/Mac/Linux。

镜像Image

只读性：Docker 镜像就是一个只读的模板。

例如：一个镜像可以包含一个完整的 ubuntu 操作系统环境、一个mysql运行环境等

静态性：镜像是用来创建 Docker 容器的，是静止的。而容器是运行状态，是动态的。就像是面向对象程序设计中的类和实例一样，镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等。
镜像可以理解为安装包，容器理解为打开的软件。

Docker 提供了一个很简单的机制来创建镜像或者更新现有的镜像，用户甚至可以直接从其他人那里下载一个已经做好的镜像来直接使用。

my:简而言之，镜像就像不同的组件，它们彼此相对独立，有的比较大类似程序包，有的小一些只是一个类，有的更小只是一个函数。这些组件是“只读”的，比如我们在写代码的时候，一般不会去改系统函数的底层实现，只是直接拿来用。利用这些组件，能够组装构建出一个应用（容器）。

容器Container

Docker 利用容器来运行应用。

容器是从镜像创建的运行实例。它可以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台。

*注：镜像是只读的，容器在启动的时候创建一层可写层作为最上层。

类似于一个轻量级的沙盒，可以将其看作一个极简的Linux系统环境（包括root权限、进程空间、用户空间和网络空间等），以及运行在其中的应用程序。Docker引擎利用容器来运行、隔离各个应用。容器是镜像创建的应用实例，可以创建、启动、停止、删除容器，各个容器之间是是相互隔离的，互不影响。注意：镜像本身是只读的，容器从镜像启动时，Docker在镜像的上层创建一个可写层，镜像本身不变。

仓库Repository

仓库是集中存放镜像文件的场所。有时候会把仓库和仓库注册服务器（Registry）混为一谈，并不严格区分。实际上，仓库注册服务器上往往存放着多个仓库，每个仓库中又包含了多个镜像，每个镜像有不同的标签（tag）。

仓库分为公开仓库（Public）和私有仓库（Private）两种形式。

最大的公开仓库是 Docker Hub，存放了数量庞大的镜像供用户下载。 国内的公开仓库包括 Docker Pool 等，可以提供大陆用户更稳定快速的访问。

当然，用户也可以在本地网络内创建一个私有仓库。

当用户创建了自己的镜像之后就可以使用 push 命令将它上传到公有或者私有仓库，这样下次在另外一台机器上使用这个镜像时候，只需要从仓库上 pull 下来就可以了。

注：Docker 仓库的概念跟 Git 类似，注册服务器可以理解为 GitHub 这样的托管服务。

安装

windows 子系统的特殊 看另一篇博客

看docker官方网站，不要看菜鸟教程那个 大坑


service docker start 似乎还要设置这个 不然显示deamon啥的？

ps
1 如果安装phpstudy 那么不要先安装docker 先安装了反而会报错 直接用xp官网那个docker版本的安装命令，会自动安装docker的。
2 xp面板中的文件管理是真实的路径地址！而非仅docker镜像内的。docker只映射了www和usr/local/phpstudy接口

简单示例——Hello world

最简单的容器

# 使用镜像运行容器
$ docker run ubuntu:15.10 /bin/echo "Hello world" #使用镜像进入容器 并使用命令
#以上命令完整的意思可以解释为：Docker 以 ubuntu15.10 镜像创建一个新容器，然后在容器里执行 bin/echo "Hello world"，然后输出结果。

启动交互式容器

上面的例子中，只能一次性把所以命令输入，但是很多时候 我们不想或者不能一次性输入所有命令
我们通过 docker 的两个参数 -i -t，让 docker 运行的容器实现"对话"的能力：

$ docker run -i -t ubuntu:15.10 /bin/bash   #可简写为-it
root@0123ce188bd8:/#

• -t: 在新容器内指定一个伪终端或终端。

• -i: 允许你对容器内的标准输入 (STDIN) 进行交互。

注意第二行 root@0123ce188bd8:/#，此时我们已进入一个 ubuntu15.10 系统的容器
然后 我们在容器内查看文件

root@0123ce188bd8:/# ls
bin  boot  dev  etc  home  lib  lib64  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
root@0123ce188bd8:/# 

退出容器

我们可以使用exit 或者ctr+D 退出容器

后台容器

有时，我们希望退出容器后，容器还在运行，比如使用服务器,可使用-d参数

$ docker run -d ubuntu:15.10 /bin/sh -c "while true; do echo hello world; sleep 1; done"

但是 如果使用-it进行后台容器交互的话，就有了前台进程。怎么防止停止没讲 后面看或者再搜

我们怎么知道容器是否在运行呢？上的ps是查看容器是否运行的，下面是具体介绍

查看容器

docker ps
CONTAINER ID        IMAGE                  COMMAND              ...  
5917eac21c36        ubuntu:15.10           "/bin/sh -c 'while t…"    ...

输出详情介绍：

• CONTAINER ID: 容器 ID。

• IMAGE: 使用的镜像。

• COMMAND: 启动容器时运行的命令。

• CREATED: 容器的创建时间。

• STATUS: 容器状态，有7种：

  • created（已创建）
  • restarting（重启中）
  • running 或 Up（运行中）
  • removing（迁移中）
  • paused（暂停）
  • exited（停止）
  • dead（死亡）

PORTS: 容器的端口信息和使用的连接类型（tcp\udp）。

NAMES: 自动分配的容器名称。

查看标准输出

在宿主主机内使用 docker logs 命令，查看容器内的标准输出：

$ docker logs 2b1b7a428627
# 会看到一排又一排的hello world

停止容器

#停止容器
$ docker stop 容器名

命令介绍

sudo docker为固定前缀.或者先sudo su 在root下操作 之后不再说明了
docker 命令 --help 查看帮助

镜像

本章其实可以一个一个代码框 不用标题

搜索镜像

#搜索镜像 也可网络浏览器搜索  
docker search 包名

两个小而美的镜像

ps 虽然这两个都很小 但是如果我们软件多的时候 实际上不用很在意 因为后面会讲到 多个软件会复用底层容器 不会很多的存储开销。但是还是推荐 主要的用centos 应用小的用alpine

BusyBox

BusyBox 是大工具箱，压缩集成了很多Linux命令和工具的软件。笔者ubuntu虚拟机上就有这个工具，/usr/bin/busybox，才2.1M，使用时直接在busybox后面跟随命令即可。

笔者pull一个BusyBox镜像，发现镜像才1.23MB，甚至都没有bash。但是BusyBox没有包管理工具，也有加了包管理工具opkg的progrium/busybox镜像，但是镜像就稍大了。

alpine

第二个小而美的Docker镜像就是alpine，镜像有5.61MB，相比BusyBox镜像，有更广泛的软件包。alpine是轻型 Linux 发行版，提供了包管理工具 apk。

注：alpine本意是阿尔卑斯、高山的，在软件中是是精简版的意思
Alpine介绍
Alpine 操作系统是一个面向安全的轻型 Linux 发行版。目前 Docker 官方已开始推荐使用 Alpine 替代之前的 Ubuntu 做为基础镜像环境。这样会带来多个好处。包括镜像下载速度加快，镜像安全性提高，主机之间的切换更方便，占用更少磁盘空间等。

Alpine的特点：

小巧：基于Musl libc和busybox，和busybox一样小巧，最小的Docker镜像只有5MB；
安全：面向安全的轻量发行版；
简单：提供APK包管理工具，软件的搜索、安装、删除、升级都非常方便。
适合容器使用：由于小巧、功能完备，非常适合作为容器的基础镜像。
闲话少叙，来一睹她的真容：

[root@master ~]# docker images
REPOSITORY     TAG         IMAGE ID            CREATED             SIZE
alpine         latest      a187dde48cd2        16 hours ago        5.6MB

可以看到alpine镜像只有5.6MB，而ubuntu镜像则近百MB，centos镜像近三百MB，Alpine的体积优势非常明显。

！但是好像有个大坑 没有glibc ，c运行库

拉取(下载)镜像

#拉取(下载)镜像
#pull命令 用于从仓库获取需要的镜像  如果不指定版本 下载的就是最新版
sudo docker pull ubuntu:12.04  //从官方镜像仓库获取
sudo docker pull dl.dockerpool.com:5000/ubuntu:12.04  #从指定仓库获取镜像
# 下载的时候 会分层下载！ 比如下载mysql5.7 和8  下完5.7再下8的时候 ，有的依赖镜像下载过了 就不会再下载了，但是最终显示的时候 只有一个
# 官方镜像都比较大  我们可以自己做

查看镜像

#列出镜像
$ docker images
# 第一个参数是来自哪个仓库 第二个参数是指定具体信息 如版本  第三个参数是镜像的唯一身份id 
REPOSITORY       TAG      IMAGE ID      CREATED      VIRTUAL SIZE
ubuntu           12.04    74fe38d11401  4 weeks ago  209.6 MB
ubuntu           precise  74fe38d11401  4 weeks ago  209.6 MB
ubuntu           14.04    99ec81b80c55  4 weeks ago  266 MB
mysql            5.6      f2e8d6c772c0  3 weeks ago  324.6 MB

使用镜像运行容器

#使用镜像进入容器 并使用命令
$ docker run ubuntu:15.10 /bin/echo "Hello world" 
#以上命令完整的意思可以解释为：Docker 以 ubuntu15.10 镜像创建一个新容器，然后在容器里执行 bin/echo "Hello world"，然后输出结果。

修改镜像

#修改镜像，先进入容器 修改后 再commit提交(本质是将容器持久化为我们自定义的镜像！)
$ sudo docker run -t -i training/sinatra /bin/bash #使用镜像生成容器
# 干一些事情 比如下载软件 命令省略
$ exit #退出容器
# 提交镜像commit命令  -m是提交的自定义信息 用于提示  -a是指定更新的用户信息；之后是用来创建镜像的容器的 ID；
# 最后的参数是指定目标镜像的仓库名（冒号前）和 tag 信息（冒号后）。创建成功后会返回这个镜像的 ID 信息。
$ sudo docker commit -m "安装了软件" -a "Docker Newbee" 0b2616b0e5a8 ouruser/sinatra:v2

使用dockerfile创建镜像

#使用dockerfile创建镜像  后面会详细将dockerfile
$ docker build   # 具体的用到在查
# 从本地文件导入创建镜像
$ docker import

导出镜像到本地

#导出镜像到本地
docker save
#从本地加载镜像（和上面创建不同 这里是直接加载）
docker load

移除镜像

# 移除镜像
# 如果要移除本地的镜像，可以使用 docker rmi 命令。注意 docker rm 命令是移除容器。
# 注意：在删除镜像之前要先用 docker rm 删掉依赖于这个镜像的所有容器。

容器

启动容器

语法

docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

常用OPTIONS说明：

• -d: 后台运行容器，并返回容器ID；
  不加这一个默认直接进入容器，之后如果退出则会连着容器一起挂起（暂停运行）。
• -i: 以交互模式运行容器，通常与 -t 同时使用
• -t: 为容器重新分配一个伪输入终端，通常与 -i 同时使用；
  同时使用it之后，你就可以进入到这个容器里面,就像在一台新的Linux主机中了。
• -p: 指定端口映射，格式为：主机(宿主)端口:容器端口；
  非常常用，从容器外访问容器内服务的主要方式（后面会详细讲 先有个印象即可）。
• –name=“nginx-lb”: 为容器指定一个名称；
• -m :设置容器使用内存最大值；
• -e username=“ritchie”: 设置环境变量；
  上面这两个设置比较进阶一点。之后还会讲到。
• –volume , -v: 绑定一个卷（后面会详细讲 先有个印象即可）。
  格式为主机目录:容器目录，这条命令也是非常有用的，如果不绑定目录，那么在删除容器的时候，里面的所有数据也一起删除了。但如果使用了挂载卷的话，直接存在宿主机对应文件夹中，下次开启容器还能直接使用。通常用于存一些配置文件、数据什么的。

# 启动容器
# 这里我们希望有个交互式 Shell，因此用的是 /bin/bash。
$ docker run -it ubuntu /bin/bash

# -P:将容器内部使用的网络端口随机映射到我们使用的主机上。
docker run -d -P training/webapp 
# 手动设置不一样的端口
docker run -d -p 5000:5000 training/webapp python app.py
# 用完后删除容器  一般用于测试
docker run -rm training/webapp 

#根据id启动容器 
$ docker start b750bbbcfd88  

查看容器

# 查看所有容器（镜像不运行的话不会显示）
$ docker ps -a  #不带a只会显示运行中的
CONTAINER ID   IMAGE                        COMMAND                  CREATED         STATUS                    PORTS                    NAMES
3c1430cb92c2   redislabs/redismod:preview   "docker-entrypoint.s…"   4 minutes ago   Up 4 minutes              0.0.0.0:6379->6379/tcp   redismod
7aa772a6fb51   hello-world                  "/hello"                 11 hours ago    Exited (0) 11 hours ago                            frosty_feynman
# image是镜像名称 name是容器的名称如果没写 一般好像是会自动分配
# port前面的是物理机器的端口（0.0.0.0后跟着的），后面的是容器内部使用的端口（没有ip协议）再后面的是协议 这样 我们就可以在外部通过32769端口访问容器内的服务器了
# 如果是docker port命令则相反  前面的是内部 后面的是外部。   而ps是前面的是外部 后面的是内部

进入容器

后面跟name

# 进入后台容器！

# 在使用 -d 参数时，容器启动后会进入后台。此时想要进入容器，可以通过以下指令进入：
# docker attach
# docker exec：推荐大家使用 docker exec 命令，因为此退出容器终端，不会导致容器的停止。

导出容器

#导出容器（快照） docker export
 $ docker export 1e560fca3906 > ubuntu.tar
 # 导入容器（快照） docker import
 $ cat docker/ubuntu.tar | docker import - test/ubuntu:v1

删除容器

#删除容器
$ docker rm -f 1e560fca3906

查看容器内的进程

# 查看容器内的进程
docker top 容器名

将容器持久化为镜像的看容器那

实例

运行一个python web服务器容器

docker pull training/webapp  # 载入镜像
# 
docker run -d -P training/webapp python app.py #使用刚刚载入的镜像运行进入容器 运行py文件 
docker ps
CONTAINER ID        IMAGE               COMMAND             ...        PORTS                 
d3d5e39ed9d3        training/webapp     "python app.py"     ...        0.0.0.0:32769->5000/tcp

运行一个nginx服务器

# 首先去dockerhub搜索 或者 search镜像   推荐前一种
$ docker pull nginx   #记得选择合适的版本
$ docker run --name some-nginx -d -p 8080:80 nginx  
#--name后为你为这个容器指定的名称，因为你可能不止开启一个nginx 或者本来名字太长
# -d是后台运行
# -p 是映射端口，前面的是你物理机（宿主机）的端口，后面的是docker容器内部的端口
# nginx 是镜像名
$ curl localhost:8080 #可以测试开启是否成功 会显示nginx欢迎界面的html

记得看怎么看dockerHub上的镜像使用

运行es+Kibana

看狂神说视频

原理探究

镜像运行的本质——为什么centos才70mb?

https://www.cnblogs.com/Skybiubiu/p/15673175.html

问：Docker 镜像本质是什么？

答：是一个分层文件系统。
Linux文件系统由bootfs和rootfs两部分组成

bootfs：包含bootloader（引导加载程序）和kernel（内核）。
rootfs：root文件系统，包含的就是典型Linux系统中的/dev、/proc、/bin、/etc等标准目录和文件。
不同的Linux发行版，bootfs基本一样，而rootfs不同，如ubuntu和centos等。一个镜像
可以放在另一个镜像的上面，位于下面的镜像称为父镜像，最底部的镜像称为基础镜像。
当从一个镜像启动容器时，Docker会在最顶层加载一个读写文件系统作为容器（可写容器中保存着更改的数据）。

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

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

问：Docker 中一个tomcat镜像为什么有500MB，而一个tomcat安装包只有70多MB？

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

UnionFs(联合文件系统)

我们下载的时候看到的一层层就是这个!
UnionFS(联合文件系统):Union文件系统(UnionFs)是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加,同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into asingle virtualfilesystem)。Union 文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承,基于基础镜像(没有父镜像)，可以制作各种具体的应用镜像。

特性:一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录

Docker镜像加载原理

docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFs。bootfs(boot file system)主要包含bootloader和kernel, bootloader主要是引导加载kernel, Linux刚启动时会加载bootfs文件系统，在Docker镜像的最底层是bootfs。这一层与我们典型的Linux/Unix系统是一样的,包含boot加载器和内核。当boot加载完成之后整个内核就都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs。
黑屏–开机进入系统
rootfs (root file system),在bootfs之上。包含的就是典型 Linux 系统中的 /dev,/proc,/bin,/etc 等标准目录和文件。rootfs就是各种不同的操作系统发行版，比如Ubuntu，Centos等等。

docker文件分层

https://zhuanlan.zhihu.com/p/70424048

可以想象，像 ubuntu等基础镜像，体积必然不小。那么，思考以下几个问题：

我们基于同一个镜像（ubuntu 18.4）启动了两个容器，会占用两倍磁盘空间吗？
我们在容器内修改或者新建了某个文件，要修改原镜像吗？
我们基于某镜像（ubuntu 18.04）新建一个镜像（myubuntu），需要将原镜像文件全部拷贝到新镜像中吗？
首先，让我们尝试思考下，如果我们去做，该如何高效的解决这些问题？

问题 1，只要将同一个镜像文件加载到内存不同位置就行了，没必要在磁盘上存储多份，可以节省大量存储空间。
问题 2，我们可以参考 Linux 内核管理内存的 Copy-On-Write 策略，也即读时大家共用一份文件，如果需要修改再复制一份进行修改，而大部分文件是其实不会修改的，这样可以最大限度节省空间，提升性能。
问题 3，我们可以将镜像文件分为多个独立的层，然后新镜像文件只要引用基础镜像文件就可以了，这样可以节省大量空间。至于修改基础镜像文件的情况，参考问题 2 。
如果你能想到以上思路，那么恭喜你，因为 Docker 就是这么做的，你已经具备为写docker 写一套文件系统的实力了（哈哈哈哈，不要飘，还有大量技术细节需要思考）。

事实上，容器（container）和镜像（image）的最主要区别就是容器加上了顶层的读写层。所有对容器的修改都发生在此层，镜像并不会被修改，也即前面说的 COW(copy-on-write)技术。容器需要读取某个文件时，直接从底部只读层去读即可，而如果需要修改某文件，则将该文件拷贝到顶部读写层进行修改，只读层保持不变。

每个容器都有自己的读写层，因此多个容器可以使用同一个镜像，另外容器被删除时，其对应的读写层也会被删除（如果你希望多个容器共享或者持久化数据，可以使用 Docker volume）。

最后，执行命令 docker ps -s，可以看到最后有两列 size 和 virtual size。其中 size就是容器读写层占用的磁盘空间，而 virtual size 就是读写层加上对应只读层所占用的磁盘空间。如果两个容器是从同一个镜像创建，那么只读层就是 100%共享，即使不是从同一镜像创建，其镜像仍然可能共享部分只读层（如一个镜像是基于另一个创建）。因此，docker 实际占用的磁盘空间远远小于 virtual size 的总和。

架构

docker的架构设计分为三个组件：一个客户端，一个REST API和一个服务器（守护进程）：

• Client ：与REST API交互。主要目的是允许用户连接守护进程。
• REST API：充当客户端和服务器之间的接口，实现通信。
• 守护进程：负责实际管理容器 - 启动，停止等。守护进程监听来自docker客户端的API请求。

守护进程与内核关系非常密切。今天在Windows中，当您运行Windows Server容器时，守护进程在Windows中运行。当您切换到Linux容器模式时，守护程序实际上在名为Moby Linux VM的虚拟机内运行。随着Docker 即将发布，您将能够并行运行Windows Server容器和Linux容器，守护进程将始终作为Windows进程运行。

客户端不必与守护进程安装在同一个地方。例如，您可以在开发计算机上使用本地Docker客户端与Azure中的Docker进行通信。这使我们可以让WSL中的客户端与主机上运行的守护进程通信。

网络

docker是如何处理容器的网络的呢？

原理：比如路由器的地址是192.168.1.1，后面加入的设备是192.168.1.2，.1.3，而这些设备因为在一个网段下 是可以互相访问的！

上面展示的是虚拟网卡！

所以 容器之间 也能相互ping通！docker0相当于一个路由器，所有的请求都要经过这个路由器。

容器之间的通信 是这样进行的

这就是link技术

但是，反向不一定能ping通！这里的原理仅仅是，相当于host文件里写了一个配置 ，但是反过来的没有写。所以，现在以及不推荐使用–link了 也不推荐使用docker0了。我们想要自定义网络！


后面查啥叫网关 啥叫路由
通过自定义网络，可以不需要–link了 也不会反向不通了。

redis集群那个视频以后再看

容器数据卷——数据怎么存储、持久化与共享

docker主要是将应用和环境一起打包，但是数据并不属于此类。
1、我们发布镜像给别人的时候，肯定不希望数据也给别人
2、容器一删除，数据也没了。但是数据需要持久化，比如数据库数据和log
3、容器直接可能需要共享数据
4、比如nginx的配置文件，每次都要进doceer修改 ，而且（修改后 还要build run后才会生效 ----是么？）很麻烦 我们想要直接外部去改
解决这个的就是卷技术，实际就是目录挂载

# v就是挂载目录  顺序很好理解 因为docker是在外部运行的 当然是主机目录在前面
docker run -it -v 主机目录:容器目录
#-v可以写多个
docker run -it -v 主机目录:容器目录 -v 主机目录2:容器目录2

mysql的数据都在mysql的data目录下

大多数情况下 我们不想自定义目录，想让docker帮我们统一管理，这里就涉及到了匿名挂载和具名挂载
不写主机的文件地址，docker自动帮我们弄个目录 都在var/lib/docker/voloums/卷名/_data下
区别在于卷名是不是我们自己指定的还是docker帮我们生成的

注意具名挂载哪里 开头没有/ 带斜线的是绝对路径

这里的权限是针对容器来说的。
每次具名挂载容易出错 建议写dockerFile去操作
注意，数据卷不会提交到镜像中，那么如果我制定了比如配置文件，或者数据目录在外面，导致缺少目录、文件 不可用咋办？----应该是这样，不打包只是我们在容器层新修改的不会被打包进去，但是本身这个就有原始目录和文件，所以可以正常！

多个容器共享数据—数据卷容器

首先新建一个容器，里面挂载两个目录，之后第二个容器”继承“第一个容器，就会自动使用容器1共享的目录卷共享文件。
volumes from命令
如果我们把容器1删了，文件依然在！

利用这个特性 可以做mysql的主从同步

容器持久化——commit export save Dockerfile的区别

https://zhuanlan.zhihu.com/p/152219012

commit用于对外发行的，特别是软件安装的包，可以分层下载。
export和save则更适合数据层或者纯自己的代码 不打算分享出去的。而数据其实更适合volume
一个会保留之前的记录，一个只记录现在的状态(没分层了)

Dockerfile——生成镜像的构筑文件

镜像是一层一层的，脚本的每一行就是一层！



上面的cmd那里 是一个cmd 块内只执行最后一个 但是可以写多个cmd块

由于-a 和-l是单独的命令 所以cmd执行-al只会执行后面的，想解决 用ENTRY—那个命令
工作目录是 我们希望别人进入docker进入的目录，因为每次都根目录很麻烦。而且，这个命令后的dockerFile命令 默认执行目录前缀就是这个工作目录，如果不存在，docker会帮你创建
ADD命令如果添加的是压缩包 docker会自动帮你解压，add后面可以跟两个参数 第一个是你要添加的文件 第二个是在镜像中的目录

实战-打包python代码

copy …那里 有两个参数，第一个是本地路径，第二个是目标路径，点代表当前目录下的所有文件，是将（以dockerfile本身的目录为相对路径）所有的程序拷贝到workdir的目录下
QUETION:那么 别人想用我们的镜像 这个copy怎么理解啊？？
run是创建镜像的时候使用的，cmd是运行容器的时候使用的

实战-构建自己的centos

官方的centos是简略版，很多命令没有，比如vim

根据file构建镜像

docker history可以看到镜像是怎么一步一步构建出来的，可以学习其他人的镜像怎么做的

Dockerfile

什么是 Dockerfile？

Dockerfile 是一个用来构建镜像的文本文件，文本内容包含了一条条构建镜像所需的指令和说明。

使用 Dockerfile 定制镜像

这里仅讲解如何运行 Dockerfile 文件来定制一个镜像，具体 Dockerfile 文件内指令详解，将在下一节中介绍，这里你只要知道构建的流程即可。

1、下面以定制一个 nginx 镜像（构建好的镜像内会有一个 /usr/share/nginx/html/index.html 文件）

在一个空目录下，新建一个名为 Dockerfile 文件，并在文件内添加以下内容：

FROM nginx
RUN echo '这是一个本地构建的nginx镜像' > /usr/share/nginx/html/index.html

2、FROM 和 RUN 指令的作用

FROM：定制的镜像都是基于 FROM 的镜像，这里的 nginx 就是定制需要的基础镜像。后续的操作都是基于 nginx。

RUN：用于执行后面跟着的命令行命令。有以下俩种格式：

shell 格式：

RUN <命令行命令>
# <命令行命令> 等同于，在终端操作的 shell 命令。

exec 格式：

RUN ["可执行文件", "参数1", "参数2"]
# 例如：
# RUN ["./test.php", "dev", "offline"] 等价于 RUN ./test.php dev offline

注意：Dockerfile 的指令每执行一次都会在 docker 上新建一层。所以过多无意义的层，会造成镜像膨胀过大。例如：

FROM centos
RUN yum -y install wget
RUN wget -O redis.tar.gz "http://download.redis.io/releases/redis-5.0.3.tar.gz"
RUN tar -xvf redis.tar.gz

以上执行会创建 3 层镜像。可简化为以下格式：

FROM centos
RUN yum -y install wget \
    && wget -O redis.tar.gz "http://download.redis.io/releases/redis-5.0.3.tar.gz" \
    && tar -xvf redis.tar.gz

如上，以 && 符号连接命令，这样执行后，只会创建 1 层镜像。

开始构建镜像
在 Dockerfile 文件的存放目录下，执行构建动作。

以下示例，通过目录下的 Dockerfile 构建一个 nginx:v3（镜像名称:镜像标签）。

注：最后的 . 代表本次执行的上下文路径，下一节会介绍。

$ docker build -t nginx:v3 .

以上显示，说明已经构建成功。

上下文路径
上一节中，有提到指令最后一个 . 是上下文路径，那么什么是上下文路径呢？

$ docker build -t nginx:v3 .

上下文路径，是指 docker 在构建镜像，有时候想要使用到本机的文件（比如复制），docker build 命令得知这个路径后，会将路径下的所有内容打包。

解析：由于 docker 的运行模式是 C/S。我们本机是 C，docker 引擎是 S。实际的构建过程是在 docker 引擎下完成的，所以这个时候无法用到我们本机的文件。这就需要把我们本机的指定目录下的文件一起打包提供给 docker 引擎使用。

如果未说明最后一个参数，那么默认上下文路径就是 Dockerfile 所在的位置。

注意：上下文路径下不要放无用的文件，因为会一起打包发送给 docker 引擎，如果文件过多会造成过程缓慢。

指令介绍

Dockerfile 指令	说明
FROM	指定基础镜像，用于后续的指令构建。
MAINTAINER	指定Dockerfile的作者/维护者。（已弃用，推荐使用LABEL指令）
LABEL	添加镜像的元数据，使用键值对的形式。
RUN	在构建过程中在镜像中执行命令。
CMD	指定容器创建时的默认命令。（可以被覆盖）
ENTRYPOINT	设置容器创建时的主要命令。（不可被覆盖）
EXPOSE	声明容器运行时监听的特定网络端口。
ENV	在容器内部设置环境变量。
ADD	将文件、目录或远程URL复制到镜像中。
COPY	将文件或目录复制到镜像中。
VOLUME	为容器创建挂载点或声明卷。
WORKDIR	设置后续指令的工作目录。
USER	指定后续指令的用户上下文。
ARG	定义在构建过程中传递给构建器的变量，可使用 “docker build” 命令设置。
ONBUILD	当该镜像被用作另一个构建过程的基础时，添加触发器。
STOPSIGNAL	设置发送给容器以退出的系统调用信号。
HEALTHCHECK	定义周期性检查容器健康状态的命令。
SHELL	覆盖Docker中默认的shell，用于RUN、CMD和ENTRYPOINT指令。

指令详解

详细看菜鸟教程的

compose 组合运行镜像

我们希望启动多个容器，比如服务器一个，mysql一个 ，而非全部运行在一个容器中，这样 一个坏了 另一个还能正常用，修复起来也方便，为了打包实现这个 就要用到docker compose

如果你使用本地的dockerFile文件 那么就是用build . 如果你用dockerhub上的镜像 就是image
跑出来后 会有一个_1的后缀 这个是集群的概念 是一共的数量

Compose V2已经取代了原来的compose 具体百度

其他详细看菜鸟教程

其他

windows docker

windows10可用wsl2(windows 下的linux子系统)去运行docker

可视化界面

可以安装可视化界面 快捷操作 也是docker容器的方式安装

swarm集群—用于集群

其实可以直接学k8s了 但是比较swarm先出来 可以先学 加深理解

docker 和k8s的区别

k8s用于集群部署，并非docker的替代

迁移和备份数据

弄一个专门的容器来处理

注意事项

dockerhub要注意系统、处理器和版本 比如arm64 v8(mac) 就不能装普通处理器的docker镜像
compose启动docker可能不会报错，直接run能看到报错 比如上面架构不一样的

推荐与参考资料

音乐编程学院 https://www.bilibili.com/video/BV1s54y1n7Ev?from=search&seid=11902764066632228605&spm_id_from=333.337.0.0
https://www.bilibili.com/video/BV1og4y1q7M4?p=11&spm_id_from=pageDriver

深入检出！https://zhuanlan.zhihu.com/p/49912239 强烈推荐这个系列

进度

目前狂神说没看网络的最后那部分 和redis集群后面的
进阶的 实战微服务后面的没看

一些实战技巧 还没整理

停止docker镜像和删除 可能因为restart而重启 导致系统卡顿和删除不了 可以用docker kill xxx && docker rm xxx 去并行删除

有的镜像没有指定latest 必须指定版本号

有的镜像用的是sh 不是bash

docker pull registry.cn-shanghai.aliyuncs.com/suling/openwrt:latest 可以用这种形式指定从哪个仓库下载