Docker入门

Docker安装

Docker的基本组成

安装Docker

环境准备

1.需要一点linux基础

2.CentOS7

3.Xshell连接远程服务器操作

环境查看

#系统内核3.10以上
[root@localhost /]# uname -r
3.10.0-693.el7.x86_64

安装

查看官方帮助文档https://docs.docker.com/engine/install/centos/

#1.卸载旧版本docker
$ sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine
#2.需要安装包
yum install -y yum-utils
#3.设置镜像仓库
yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo #默认是国外仓库
    yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo  #国内推荐一般使用阿里云镜像仓库
#更新软件包索引
yum makecache fast
#4.安装docker相关的资源
yum install docker-ce docker-ce-cli containerd.io
#5.启动docker
systemctl start docker
#6.使用docker version测试是否安装成功
docker version
#7.运行docker是某能拉取镜像hello-world
docker run hello-world
#8.查看一下下载的这个hello-world镜像
docker images

卸载docker

#1. 卸载依赖
yum remove docker-ce docker-ce-cli containerd.io
#删除资源
rm -rf /var/lib/docker
# /var/lib/docker  docker的默认工作路径

阿里云镜像加速

1.登录阿里云并打开下面界面选取容器镜像服务

2.选取你对应linux版本

3.在linux下依次运行一下命令

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://rh593cxk.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

回顾hellow-world流程

linux下运行hello-world镜像截图

docker拉取镜像的原理图：

底层原理

Docker是如何工作的?

Docker为什么比虚拟机快？

docker的常用命令

帮助命令

docker version    #查看docker版本信息
docker info        #查看docker系统级信息
docker [命令] --help    #查看命令说明

帮助文档地址：https://docs.docker.com/reference/

镜像命令

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

[root@localhost /]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
hello-world         latest              bf756fb1ae65        8 months ago        13.3kB
#解释
REPOSITORY          镜像仓库源
TAG                 镜像标签
IMAGE ID            镜像id
CREATED             镜像创建时间
SIZE                镜像大小
#可选项
-a   --all        #列出所有镜像
-q     --quiet     #只显示镜像id

docker search 镜像搜索

[root@localhost /]# docker search mysql
mysql                             MySQL is a widely used, open-source relation…   9958                [OK]                
mariadb                           MariaDB is a community-developed fork of MyS…   3642                [OK]                
mysql/mysql-server                Optimized MySQL Server Docker images. Create…   725                                     [OK]
#可选项，通过收藏过滤
--filter=STARS=3000       #搜索出来镜像就是stars大于3000的
[root@localhost /]# docker search mysql --filter=STARS=3000 
NAME                DESCRIPTION                                     STARS               OFFICIAL            AUTOMATED
mysql               MySQL is a widely used, open-source relation…   9958                [OK]                
mariadb             MariaDB is a community-developed fork of MyS…   3642                [OK]

docker pull 下载镜像

#指定版本下载
docker pull mysql:5.7

docker rmi删除镜像

docker rmi 镜像id         #删除指定镜像
docker rmi 镜像id 镜像id 镜像id         #删除多个镜像
docker rmi -f $(docker images -aq)    #删除全部镜像

容器命令

说明：我们有了镜像才可以创建容器，linux下载一个centos来测试学习

docker pull centos

新建容器启动

docker run [可选参数] [镜像名]
#参数说明
--name=“Name”        容器名字  tomcat01 tomcat02，用来区分容器
-d 
-it
-p
    -p ip:主机端口:容器端口
    -p 主机端口:容器端口（常用）
    -p 容器端口
-p  随机指定端口
#测试，启动并进入容器
#docker run -it centos 的意思是，为centos这个镜像创建一个容器
#-it就等于 -i和-t，这两个参数的作用是，为该docker创建一个伪终端，这样就可以进入到容器的交互模式（也就是直接进入到容器里面）
#后面的/bin/bash的作用是表示载入容器后运行bash ,docker中必须要保持一个进程的运行，要不然整个容器启动后就会马上kill itself，这个/bin/bash就表示启动容器后启动bash
[root@localhost /]# docker run -it centos /bin/bash
[root@481cfb6a514b /]# ls
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
#退出容器到主机
[root@481cfb6a514b /]# exit
exit

列出所有运行的容器

#docker ps 命令 [可选参数]
                    #列出当前正在运行的容器
                -a    #累出当前运行的容器+历史运行过的容器
                -n=?  #显示最近创建容器
                 -q   #只显示容器编号
[root@localhost /]# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
[root@localhost /]# docker ps -a
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                     PORTS               NAMES
b15b3c7d483d        centos              "/bin/bash"         5 minutes ago       Exited (0) 8 seconds ago                       infallible_ardinghelli
481cfb6a514b        centos              "/bin/bash"         2 hours ago         Exited (0) 5 minutes ago                       exciting_sammet
9e0de3487965        bf756fb1ae65        "/hello"            4 hours ago         Exited (0) 4 hours ago                         suspicious_robinson

退出容器

exit    #直接退出容器
Ctrl + p + Q    #容器不停止退出

删除容器

docker rm 容器id        #删除指定容器，不能删除正在执行的容器，如果强制删除rm -f
docker rm -f $(docker images -aq) #强制删除所有容器
docker ps -a -q|xargs docker rm    #强制删除所有容器

启动和停止容器

docker start 容器id            #开启容器
docker restart 容器id            #重启容器
docker stop 容器id            #停止容器
docker kill 容器id            #强制停止容器

常用其他命令

后台启动容器

#命令docker run -d [镜像名]
docker run -d centos
#问题docker ps 后发现开启的centos容器停止了
#常见的坑：docker容器使用后台运行，就有必要有一个前台进程，docker发现没有应用，就自动停止了（容器没有对外提供服务）

查看日志

查看容器内部进程信息

#docker top 容器id
[root@localhost /]# docker top 74b98e2b58ce 
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                11505               11489               0                   21:55               ?                   00:00:00            /bin/bash

查看镜像原数据

#docker inspect 容器id
[root@localhost /]# docker inspect 74b98e2b58ce
[
    {
        "Id": "74b98e2b58ce17668d107537678bfb27b46f0b560febe12c09441f04b0ad0379",
        "Created": "2020-09-13T13:55:55.133386006Z",
        "Path": "/bin/bash",
        "Args": [],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 11505,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2020-09-13T13:55:57.25370239Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:0d120b6ccaa8c5e149176798b3501d4dd1885f961922497cd0abef155c869566",
        "ResolvConfPath": "/var/lib/docker/containers/74b98e2b58ce17668d107537678bfb27b46f0b560febe12c09441f04b0ad0379/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/74b98e2b58ce17668d107537678bfb27b46f0b560febe12c09441f04b0ad0379/hostname",
        "HostsPath": "/var/lib/docker/containers/74b98e2b58ce17668d107537678bfb27b46f0b560febe12c09441f04b0ad0379/hosts",
        "LogPath": "/var/lib/docker/containers/74b98e2b58ce17668d107537678bfb27b46f0b560febe12c09441f04b0ad0379/74b98e2b58ce17668d107537678bfb27b46f0b560febe12c09441f04b0ad0379-json.log",
        "Name": "/funny_keldysh",
        "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,
            "Capabilities": null,
            "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/632450a6583ca3e93ecd9cf689ac3f56983c77e111c668ee7ea1befcf62f4410-init/diff:/var/lib/docker/overlay2/295a3faa7fd7ddbf81b948e17667f4bb8be8e805176e2e075969d6f30a84f426/diff",
                "MergedDir": "/var/lib/docker/overlay2/632450a6583ca3e93ecd9cf689ac3f56983c77e111c668ee7ea1befcf62f4410/merged",
                "UpperDir": "/var/lib/docker/overlay2/632450a6583ca3e93ecd9cf689ac3f56983c77e111c668ee7ea1befcf62f4410/diff",
                "WorkDir": "/var/lib/docker/overlay2/632450a6583ca3e93ecd9cf689ac3f56983c77e111c668ee7ea1befcf62f4410/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "74b98e2b58ce",
            "Domainname": "",
            "User": "",
            "AttachStdin": true,
            "AttachStdout": true,
            "AttachStderr": true,
            "Tty": true,
            "OpenStdin": true,
            "StdinOnce": true,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
            ],
            "Cmd": [
                "/bin/bash"
            ],
            "Image": "centos",
            "Volumes": null,
            "WorkingDir": "",
            "Entrypoint": null,
            "OnBuild": null,
            "Labels": {
                "org.label-schema.build-date": "20200809",
                "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": "b7dea3086c89e9a055d11c4e5dc055d89d95b0cf8fdb37ff385c4ead0f7b92ff",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/b7dea3086c89",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "31a5179e24c36615c74ead28c1adbe229a6f290cfdff6d35444e2d96fa943c2e",
            "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": "08f35ada5fbb99d55506e2866abec35d63c788eb2485f9f0b6a3f569af255d08",
                    "EndpointID": "31a5179e24c36615c74ead28c1adbe229a6f290cfdff6d35444e2d96fa943c2e",
                    "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
                }
            }
        }
    }
]

进入当前正在运行的容器

#我们容器通常是后台运行的，需要进入容器，修改一些配置
#命令
docker exec -it 容器id /bin/bash
#测试
[root@localhost /]# docker exec -it 74b98e2b58ce /bin/bash
[root@74b98e2b58ce /]# ls
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
[root@74b98e2b58ce /]# ps -ef
UID         PID   PPID  C STIME TTY          TIME CMD
root          1      0  0 13:55 pts/0    00:00:00 /bin/bash
root         15      0  0 14:05 pts/1    00:00:00 /bin/bash
root         29     15  0 14:05 pts/1    00:00:00 ps -ef
#方式二
docker attach 容器id
#docker exec     #进入容器后开启一个新的终端，可以在里面操作（常用）
#docker attach  #进入容器正在执行的终端，不会启动新的进程

从容器内拷贝到主机

#docker cp 容器id:容器文件路径 主机目录路径
[root@74b98e2b58ce home]# touch test.java
[root@74b98e2b58ce home]# ls
test.java
[root@74b98e2b58ce home]# exit
exit
[root@localhost /]# cd home
[root@localhost home]# ls
redis-6.0.6.tar.gz  wise
[root@localhost home]# docker cp 74b98e2b58ce:/home/test.java /home
[root@localhost home]# ls
redis-6.0.6.tar.gz  test.java  wise

小结

$ docker --help                                                                                                   
  attach      将标准输入和标准输出连接到正在运行的容器                                        
  build       使用dockerfile文件创建镜像                                                                                
  commit      从容器的修改项中创建新的镜像
  cp          将容器的目录或文件复制到本地文件系统中
  create      创建一个新的镜像
  diff        检查容器文件系统的修改
  events      实时输出docker服务器中发生的事件
  exec        从外部运行容器内部的命令
  export      将容器的文件系统到处为tat文件包
  history     显示镜像的历史
  images      输出镜像列表
  import      从压缩为tar文件的文件系统中创建镜像
  info        显示当前系统信息、docker容器与镜像个数、设置信息等
  inspect     使用JSON格式显示容器与镜像的详细信息
  kill        向容器发送kill信号关闭容器
  load        从tar文件或标准输入中加载镜像
  login       登录docker注册服务器
  logout      退出docker注册服务器
  logs        输出容器日志信息
  pause       暂停容器中正在运行的所有进程
  port        查看容器的端口是否处于开放状态
  ps          输出容器列表
  pull        从注册服务器中拉取一个镜像或仓库
  push        将镜像推送到docker注册服务器
  rename      重命名一个容器
  restart     重启一个或多个容器
  rm          删除一个或多个容器，若没有指定标签则删除lastest标签。
  rmi         删除一个或多个镜像，若没有指定标签则删除lastest标签。                                                
  run         在一个新容器中中运行命令，用于指定镜像创建容器。
  save        将一个或多个镜像保存为tar包             
  search      从Docker Hub中搜索镜像
  start       启动一个或多个已经停止的容器
  stats       Display a live stream of container(s) resource usage statistics                                                      
  stop        停止一个或多个正在运行的容器
  tag         设置镜像标签
  top         显示容器中正在运行的进程信息
  unpause     重启pause命令暂停的容器
  update      更新一个或多个容器的配置
  version     显示docker版本信息
  wait        等待容器终止然后输出退出码

练习

安装nginx

# 1.命令行搜索nginx  推荐在dockerhub搜索https://hub.docker.com/ 可看到详细信息
docker search nginx
# 2.拉取nginx镜像到本地主机
docker pull nginx
#启动镜像 docker run -d --name [容器名称] -p [宿主机端口]:[容器内部端口]    -d后台运行
docker run -d --name nginx01 -p 3344:80
#查看启动的镜像
docker images
#在宿主机上访问nginx服务     也可以在外网测试访问http://192.168.91.130:3344/
curl localhost：3344
#进入nginx01容器
[root@localhost ~]# docker exec -it nginx01 /bin/bash
root@294af4025b29:/# where is nginx
bash: where: command not found
root@294af4025b29:/# whereis nginx
nginx: /usr/sbin/nginx /usr/lib/nginx /etc/nginx /usr/share/nginx
root@294af4025b29:/# cd /etc/nginx
root@294af4025b29:/etc/nginx# ls
conf.d    fastcgi_params    koi-utf  koi-win  mime.types  modules  nginx.conf  scgi_params    uwsgi_params  win-utf

接口暴露概念

这样操作，我们每次需要修改nginx配置文件时，都需要进入容器内部。十分麻烦，我们要可以在容器外部提供映射路径，达到在容器修改文件名，容器内部就可以自动修改？-v数据卷！！

docker安装tomcat

#官方推荐使用
#这个命令一般用作测试，容器用完即删除tomcat镜像及容器（不建议使用）
docker run -it --rm tomcat:9.0
#下载启动
docker pull tomcat
#启动运行
docker run -d --name tomcat01 -p 3355:8080 tomcat
#测试访问
curl localhost:3355
#进入tomcat容器
docker exec -it tomcat /bin/bash

docker部署es+kibana

#es暴露端口很多
#es十分耗费内容
#es的数据一般需要放置到安全目录！挂载
#--net somenetwork  ？网络配置
#启动es
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2
#启动了  linux就很卡    docker stats 查看cpu状态
#测试访问es是否成功
curl localhost:9200
#关闭es，增加内存限制，修改配置文件  -e环境配置参数
docker run -d --name elasticsearch03 -p 9200:9200 -p 9300:9300 -e ES_JAVA_OPTS="-Xms256m -Xmx512m" elasticsearch:7.6.2

使用kibana连接es?网络如何能连接过去

可视化

portainer

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

什么portainer？

Docker图形化界面管理工具！提供一个后台面板供我们操作！！

访问测试：

http://[ip]:8088/

首次登陆需要注册用户，给admin用户设置密码：

单机版这里选择local即可，选择完毕，点击Connect即可连接到本地docker：

注意：该页面上有提示需要挂载本地 /var/run/docker.socker与容器内的/var/run/docker.socker连接。因此，在启动时必须指定该挂载文件。

首页：

容器列表：

点击容器列表中的容器名Name，即可查看容器详情：

并且在容器详情页可以使用该容器创建镜像：

镜像列表（在镜像列表可以直接pull一个镜像，可以从远程pull，也可以从私有库中pull。从私有库中pull，需要将私有库的地址提前进行配置，这个在后面会说）：

点击镜像ID，即可查看镜像详情信息，在详情信息页面，除了镜像的一些信息外，还可以对该镜像进行打标签tag操作，然后将镜像push到远程仓库或者私有仓库中。

仓库管理页面（该界面可以查看配置的镜像仓库列表，同时可以添加仓库，添加成功之后，即可在image镜像页面进行pull、push操作。）：

添加镜像仓库：

Docker镜像讲解

镜像是什么

Docker镜像加载原理

UnionFS（联合文件系统）

我们下载的时候看到的一层层就是这个！！

Docker镜像加载原理

分层理解

理解：

特点

commit镜像

docker commit   #提交自己的镜像成为一个新的镜像
#命令和git类似
docker commit -m="提交的描述信息" -a="作者" 容器id 目标镜像名:[版本号]

实战测试：

#启动一个默认tomcat
docker run -it -p 8080:8080 tomcat
#发现这个默认的tomcat是没有webapps应用的，原因：官方的镜像默认webapps下面没有文件
#自己将webapps.dist下的文件全部拷贝进webapps文件夹中
root@6cfecdae0d23:/usr/local/tomcat# cp -r webapps.dist/* webapps
#将操作过的tomcat容器commit提交成一个镜像！我们以后就可以使用我们修改过的镜像
docker commit -m="mytomcat" 6cfecdae0d23 tomcat02

容器数据卷

什么是容器数据卷

docker的理念回顾

使用数据卷

方式一：直接用命令挂载 -v

docker run -v 主机目录:容器目录  
#测试
docker run -it -v /home/ceshi:/home centos /bin/bash
#查看容器挂载情况
docker inspect b5d89da9ec01

测试数据是否同步

容器退出后，修改主机的同步目录下的东西，一样可以同步到容器中

实战：安装MySQL

#获取镜像
docker pull mysql:5.7
#运行容器，需要数据挂载！   
#安装启动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
#启动成功后，我们本地使用navicat工具连接数据库
#在本地连接的数据库上创建数据库和表，测试主机挂载的目录数据是否挂载成功

具名挂载和匿名挂载

#匿名挂载
[root@wise ~]# docker run -d -P --name nginx01 -v /etc/nginx nginx     #匿名挂载nginx01容器的/etc/nginx目录到本地
8be0810dda8d944fd0824464540dbbe97e735016bef164017803e3988a56193a
[root@wise ~]# docker volume ls                                            #查看卷的信息（得到匿名卷名）
DRIVER              VOLUME NAME
local               154a0daea7f7a93c7ebffe21e1213f892af8fa0eb1d870905eafa55e1c39a6aa
#具名挂载
[root@wise ~]# docker run -d -P --name nginx03 -v nginx03:/etc/nginx nginx     #具名挂载nginx03容器/etc/nginx目录到本地（卷名nginx03）
31fa291f376305dd950c10b34ed9689f4e2d1b989517a47f3face404eadaada0
[root@wise ~]# docker volume ls                                            #查看卷的信息（得到具名卷名）
DRIVER              VOLUME NAME
local               5ff0c8f210b4e99fc60f6e74c8e11dd776de37cb3cb2e39011a675d4993bcda9
local               154a0daea7f7a93c7ebffe21e1213f892af8fa0eb1d870905eafa55e1c39a6aa
local               515f03843e5682d8fef890885324596eecbe7c21f737fcdc936e19cc2469da01
local               nginx03                                                #具名卷名
#通过 -v 卷名：容器内路径
#查看卷挂载情况

所有docker容器的卷，没有指定主机路径的情况下，所有容器目录挂载在/var/lib/docker/volumes/xxx下

通过具名挂载方便找到我们的一个卷，大多数情况使用具名挂载

#匿名挂载 具名挂载 指定路径挂载
-v 容器内路径                 #匿名挂载
-v 容器名：容器内路径        #具名挂载
-v /宿主机路径：容器内路径        #指定路径挂载

拓展：

#通过 -v 容器内路径 ro rw 改变读写权限
#ro  read only 只读
#rw  readwrite 可读写
#一旦设置了容器权限，容器对我们挂载出来的内容就有了限定！（对容器内容来说）
docker run -d -P --name nginx03 -v nginx03:/etc/nginx:ro nginx
docker run -d -P --name nginx03 -v nginx03:/etc/nginx:rw nginx
#ro 即容器内部不能对这个路径进行写操作，这个路径只能在宿主机上操作

初识Dockerfile

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

通过这个脚本可以生成镜像，镜像是一层一层的，脚本一个个命令，每个命令就是一层！

#
[root@wise home]# ls
ceshi  mysql  wise
[root@wise home]# mkdir docker-teat-volume                        #创建测试目录
[root@wise home]# cd docker-teat-volume/
[root@wise docker-teat-volume]# vim dockerfile                    #在测试目录下编辑dockerfile（镜像创建脚本）
[root@wise docker-teat-volume]# cat dockerfile 
FROM centos
VOLUME ["volume01","volume02"]
CMD echo "-----end-------"
CMD /bin/bash
#docker build -f [docerfile文件目录] -t [生成的镜像名] .            #最后的.注意
[root@wise docker-teat-volume]# docker build -f dockerfile -t wise/centos .        #利用镜像创建脚本创建镜像
Sending build context to Docker daemon  2.048kB
Step 1/4 : FROM centos
 ---> 0d120b6ccaa8
Step 2/4 : VOLUME ["volume01","volume02"]
 ---> Running in 097824ceba71
Removing intermediate container 097824ceba71
 ---> 32fbbb6db1a7
Step 3/4 : CMD echo "-----end-------"
 ---> Running in 47ca999b5d93
Removing intermediate container 47ca999b5d93
 ---> d17fa7b9605c
Step 4/4 : CMD /bin/bash
 ---> Running in b9758e5f26e2
Removing intermediate container b9758e5f26e2
 ---> f3b2157173ae
Successfully built f3b2157173ae
Successfully tagged wise/centos:latest
[root@wise docker-teat-volume]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
wise/centos         latest              f3b2157173ae        11 seconds ago      215MB            #自己创建的镜像
tomcat              latest              f796d3d2c195        30 hours ago        647MB
nginx               latest              7e4d58f0e5f3        6 days ago          133MB
mysql               5.7                 ef08065b0a30        6 days ago          448MB
centos              latest              0d120b6ccaa8        5 weeks ago         215MB

#启动自己创建的镜像
docker run -it f3b2157173ae /bin/bash

这个卷的目录和外部一定有个同步的目录

[root@wise ~]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                               NAMES
01fd9626dc99        f3b2157173ae        "/bin/bash"              3 minutes ago       Up 3 minutes                                            priceless_pasteur
[root@wise ~]# docker inspect 01fd9626dc99            #查看容器的挂载情况

测试一下刚才的文件是否同步出去

这种方式我们未来使用的十分多，因为我们通常会自己构建镜像！

假设构建镜像的时候没有挂载卷，要手动镜像挂载 -v 卷名：容器名

数据卷容器

多个mysql同步数据

#启动3个容器，通过我们自己刚才写的镜像启动
#启动容器1并进入
run -it --name docker01 wise/centos
#启动容器2并用--volumes-from和容器1数据卷实现同步
docker run -it --name docker02 --volumes-from docker01 wise/centos
#启动容器2并用--volumes-from和容器1数据卷实现同步
docker run -it --name docker03 --volumes-from docker01 wise/centos

测试：

#docker02和docker03都挂载了docker01的数据卷，所有如何删除容器docker01
#测试发现docker02和docker03和宿主机直接的数据卷目录数据依然能正常双向绑定

我所理解的容器间的数据卷同步

                                                                 **注意**

如果需要同步的目录时，容器中这个目录本来以后存在文件，则需要把这些文件先拷贝到宿主机对应的同步目录下，再使用挂载，否则容器内此目录的所有文件会被清空

DockerFile

DockerFile介绍

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

构建步骤：

1.编写一个dockerfile文件

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

3.docker run 镜像

4.docker push 发布镜像（DockerHub，阿里云镜像仓库）

打开官网dockerhub

点进其中一个版本（发现镜像就是一个dockerfile文件）

Dockerfile构建过程

基础知识：

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

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

3.# 表示注释

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

Dockerfile指令

From          #基础镜像，一切从这里开始构建
MAINTAINER    #镜像是谁写的，姓名加邮箱
RUN              #镜像构建的时候需要运行的命令
ADD              # 如建tomcat镜像，这里需要添加tomcat压缩包
WORKDIR       #镜像的工作目录
VOLUME        #挂载的目录
EXPOSE          #暴露端口配置
CMD           #指定这个容器启动的时候要运行的命令
ENTRYPOINT    #指定这个容器启动的时候要运行的命令，可以追加命令
ONBUILD       #当构建一个被继承的dockerfile 这个时候会运行ONBUILD指令
COPY          #类似ADD，将我们文件拷贝到镜像中
ENV           #构建的时候设置环境变量

实战测试

DockerHub中99%镜像都是从这个基础镜像过来的 FROM scratch

创建自己的centos

#创建dockerfile脚本文件
FROM centos
MAINTAINER    wise<1376053924qq.com>
ENV MYPATH /usr/local
WORKDIR $MYPATH
RUN yum -y install vim
RUN yum -y install net-tools
EXPOSE 80 
CMD echo $MYPATH
CMD echo  "--------end----------"
CMD /bin/bash
#运行dockerfile脚本文件建立自定义镜像
docker build - f dockerfile-centos -t mycentos:1.0 .
#查看生成的镜像
[root@wise mydockerfile]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
mycentos            1.0                 250259b80eb4        40 minutes ago      295MB
#运行镜像
docker run -it mycentos:1.0
#输入vim和ifconfig命令测试自定义镜像是否成功添加vim和net-tools工具

CMD和ENTRYPOINT区别

CMD                    #指定这个容器启动的时候运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT          #指定这个容器启动的时候要运行的命令，可以追加命令

测试CMD

测试ENTRYPOINT

实战：Tomcat镜像

1.准备生成镜像需要的文件 tomcat压缩包，jdk的压缩压缩包

发布自己的镜像

DockerHub

#先注册一个dockerhub账号
docker login -u [DockerHub用户名]       #登录docker账号
docker push [镜像名]:[镜像版本号tag]      #push到远程镜像

阿里云镜像

1.登录阿里云并找到容器镜像服务

2.创建命名空间

3.创建镜像仓库

4.浏览镜像信息

#提交本地镜像到阿里云镜像服务器三个步骤  全部命令修改[]内的内容即可          
docker login --username=wiserzc registry.cn-hangzhou.aliyuncs.com                        #登录阿里云账号
docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/wise_kongjian/wise:[镜像版本号]     #确定发布哪个镜像
docker push registry.cn-hangzhou.aliyuncs.com/wise_kongjian/wise:[镜像版本号]             #push镜像到远程阿里云镜像服务器

这个自定义的仓库，所以具体命令最好查看官方文档

小结：

Docker网络