docker常用命令、镜像命令、容器命令、数据卷，使用dockerFile创建镜像，dockefile的语法规则。

一、docker常用命令？
1. 常用帮助命令 
    1.1 docker的信息以及版本号
/*
    docker info     查看docker的信息        images2 docker本身就是一个镜像。
    docker version  查看docker的版本号
*/        

    1.2 docker的启动，停止，重启，查看状态。
//    service docker start/stop/restart/status

    
二、镜像命令？

1. 列举出所有的镜像(本地镜像)
/*

    docker images
    
所拥有的参数:
    docker images --no-trunc
    docker images --no-trunc    --no-trunc:显示完整的镜像信息
    docker images -a            -a:列出本地所有的镜像(包括不完整/损坏的镜像信息)
    docker images -q            -q:只显示镜像的id
    docker images --qa            -qa:可以连用，显示出所有镜像id(包括不完整/损坏的镜像)/-q -a
    docker images --digests     --digests:显示镜像的摘要信息
    
所拥有的参数:
    REPOSITORY          TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
    hello-world         latest              9f5834b25059        8 months ago        1.84 kB

    1.    REPOSITORY:
                !目前为止!理解为镜像的名字
    2.    TAG:
                镜像的版本号
                如果下载镜像的时候不携带版本号默认为最新版(latest)
    3.    IMAGE ID:
                镜像的唯一标识符
    4.    CREATED:
                镜像所被创建的时间(镜像所被下载的时间)
    5.    VIRTUAL SIZE:
                该镜像占用本地硬盘的大小

*/    

2. 搜素镜像的命令？

//    docker search 镜像名
    

    1.1 搜索出详细的信息。    
        docker search --no-trunc 镜像名
//        docker search --no-trunc tomcat 
    
    2.    -s:列出收藏数不小于多少的镜像
//            docker search -s 50 tomcat
                         
    3.    --automated:只显示automated类型的镜像 也就是说忽略官方所提供的镜像                    
//        docker search --automated tomcat                 
                                        
    4.  混合使用。
//        docker search -s 50 --automated tomcat
    
            NAME                          DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
            tomcat                        Apache Tomcat is an open source implementa...   2524      [OK]       
            tomee                         Apache TomEE is an all-Apache Java EE cert...   67        [OK]       
            dordoka/tomcat                Ubuntu 14.04, Oracle JDK 8 and Tomcat 8 ba...   53                   [OK]
            bitnami/tomcat                Bitnami Tomcat Docker Image                     29                   [OK]

            NAME:镜像的名字
            
            DESCRIPTION:对于这个镜像的描述
            
            STARS:点赞数(收藏数)
            
            OFFICIAL:官方提供
            
            AUTOMATED:开发者提供
            
            命名规则:
                除了官方所提供的docker镜像之外，其他人提供的镜像必须要添加命名空间
                xxxx/tomcat:Seven/tomcat    


3. 下载(拉取)镜像 
    
        docker pull 镜像名。
//        docker pull tomcat:7         
            
        
        所拥有的参数:
                    docker pull tomcat:8
                    :8代表了tomcat的版本号，如果不写则下载就是最新的镜像
                如果下载镜像则会下载镜像的所有版本(最终使用到什么版本直接使用，不再需要下载)
                tomcat:6
                tomcat:5.0.1(默认下载的是第一个小版本)--->tomcat:5.22--->覆盖5.0.1版本
                tomcat:7
                tomcat:8
                tomcat:9
                ....
        

4 删除镜像？
    1.删除单个镜像
//        docker rmi 

    2.可以根据id进行删除
        docker rmi 9f5834b25059

    3.还可以根据镜像的名字进行删除
            如果根据镜像名字进行删除的时候不指定版本号，会怎么样？
            会删除这一类型的所有镜像    (会删除latest(包含了所有的版本))(如果下载的为latest版本，会把所有的版本全部下载)
            docker rmi 镜像名:版本号
//        docker rmi redis 
//        docker rmi tomcat:8
            
    4.所拥有的参数:
            -f:强制删除  还在启动中的。
//  docker rmi -f hello-world    
            
    5.删除多个镜像  
//    docker rmi -f tomcat:7 hello-world redis
        镜像和镜像之间用空格隔开即可

    6.删除所有的镜像
                -qa:获取所有的镜像的id
                获取到所有的镜像id
                根据id进行删除
//    docker rmi -f $(docker images -qa)    

5.保存镜像到本机(linux)硬盘
            docker save -o nginx.tar.gz(保存到本地硬盘上的名字) nginx(docker本地仓库中的名字)
//  docker save -o nginx.tar.gz nginx            
            会保存在光标所在的当前所在目录

            
6.把镜像导入到dicker本地仓库
//            docker load --input nginx.tar.gz
    
    该目录中必须要有nginx.tar.gz
            或者使用
//            docker load < nginx.tar.gz

三、容器命令？
1.通过镜像新建并启动容器
        docker run 镜像的名字:版本号    
        //    docker run centos:7        
        
    1.    所拥有的参数:
        --name="":给容器起一个名字，如果不使用该参数则会随机名字
        docker run -it --name=xxx 镜像名。
        //    docker run -it --name=zhou_centos centos:7
            
    2.    -d:后台运行(守护式进程)    
                
    3.    -i:与以交互模式运行容器(交互式进程),一般情况下-i和-t连用(-it)
    //    docker run -it centos:7
    
    //    docker run -it --name=zhou_centos centos:7
    
    // exit 退出
     
    4.-t:给容器打开一个新的终端(命令行)
                
    5.-P(大写):随机端口号运行
                    tomcat所默认的端口号为8080，当使用-P启动的时候，为了防止端口号被占用，docker会默认随机指定一个端口号(6060)，然后把指定的这个端口号(6060)指向tomcat所默认的端口号(8080)
                    当使用浏览器访问的时候8080端口号会失效，必须要是用docker所随机出的端口号进行访问！！！
                
    6.-p(小写):指定端口号运行
    //            docker run -it -p 8081:8080 tomcat:8
 
2.显示所有正在运行的docker容器
            docker ps 
            所拥有的参数:
                -a:显示所有的容器信息
                //docker ps -a 
                
                -q:只显示容器的id
                //docker ps -q
                
                -l:显示最近创建过的一个容器
                //docker ps -l 
                
                -n:显示最近创建过的n个容器
                //docker ps -n 3            3个容器
 
3.退出容器
            exit:退出并停止容器(让容器直接停止，不在后台进行运行)
            crtl+P+Q:退出容器但是不停止容器运行(让容器在后台继续运行) 

4.启动容器(启动已经停止的容器)
            docker start 容器的名字/容器的id
            //    docker start f65b45607510
            //  docker start centos:7
            
            只能把容器作为后台运行，没有办法开启交互式

5.重启容器
            docker restart 容器的名字/容器的id
            //    docker restart f65b45607510
6.停止容器
            docker stop 容器的名字/容器的id
            //    docker stop f65b45607510
            
7.强制停止容器
            docker kill 容器的名字/容器的id
            //    docker kill f65b45607510
            

8.删除已经停止的容器(强制删除使用-f)
            删除单个容器根据id来操作。
                docker rm 容器的id
            //    docker rm f65b45607510    
            
            强制删除使用-f 
            //  docker rm  -f f65b45607510
            
            删除多个容器
            //    docker rm -f $(docker ps -qa)
            
            删除多个容器    获取使用
            //    docker ps -qa | xargs docker rm -f

9.启动守护式容器 后台运行！！！
            docker run -d 镜像名
            // docker run -d centos:7
            
            启动该模式的容器后，该容器为一个挂起状态，需要使用的时候直接唤醒，如果不需要使用则直接可以删除，并且这种启动的好处在于不占用系统内存
            一般情况下大批量的启动容器的时候需要(1500个容器)
            
            如果启动的容器都是交互式，每一个容器就会占用内存，虽然每一个容器内存占用很小，启动到第1300个的时候内存被占满了，剩下的容器无法启动，按需加载(先把这1500个容器全部启动为守护式，最终需要用到哪些然后进行唤醒(java代码))

10.查看容器日志(一般报错的时候才会使用,运维查看)
            docker logs -f -t --tail=条数 容器的id
        //    docker logs -f -t --tail=5     c65ccc378bb8  

11.查看容器内部运行的进程
            docker top 容器的id
            // docker top  f65b45607510    
            
            
            查看当前容器在本机系统的信息

12.查看容器的详细信息(数据卷的时候会用到)
            docker inspect 容器的id
            //    docker inspect f65b45607510
            
13.重新【以交互】的形式进入到正在运行的容器中? 交互式重新启动？

            不会打开新的终端，也就是说不会启动新的进程(仍然是老的进程)，直接返回所要访问的结果
        1.    docker exec -it 容器的id    
            //    docker exec -it f65b45607510
            
                需求:
                    查看id为96cc01843e9c的容器中根目录下所有的信息
                    cd /
                    ll
                
            //        docker exec -it 96cc01843e9c ls -l
                    docker只会安装基础版的linux(按需加载，需要到什么样的工具或者配置文件才会加载)
    
            重新打开新的终端，开启新的进程
        2.    docker attach 容器的id
            //    docker attach f65b45607510
                

14.把容器中的文件复制到主机上
    1.    现在虚拟机上创建 /home/apps/66.txt 文件


    2.    在另一个中终端上打开，docker 。 在主机上操作。
            docker cp 容器的id:容器的路径 主机的路径    
        //    docker cp e62c23a8029d:/home/apps/66.txt /home/apps/    

        
实列运用
/*
    在docker上运行一个Tomcat？

1.    pull一个tomcat8的镜像
            docker pull tomcat:8
            
            4.1.1.指定端口号运行(小写的p)
                docker run -it -p 8081:8848 tomcat:8
                
            4.1.2.随机端口号运行 (大写的p)
                docker run -it -P tomcat:8
                通过docker ps命令查看随机指定的端口号
                
        
2.通过容器创建镜像
            docker commit -a="作者" -m="描述" 容器的id 新的镜像的名字:新镜像的版本号
            (！！！！！所有的过程不能停止容器！！！！！)
            需求:
                创建新的tomcat镜像(不带example文件夹，也就是说tomcat主页面上点击exampl按钮的时候会进入404页面)
                
            4.2.1.先启动tomcat8容器
                docker run -it -p 8081:8080 tomcat:8
                
            4.2.2.再打开一个新的终端并且进入到正在启动中的tomcat容器中
                docker exec -it 容器的id(9462ab070461) /bin/bash(docker所提供的常规命令，支持系统的命令行(无论是什么系统)),bash文件就是操作系统所提供的基础命令
                
            4.2.3.删除example目录
                rm -rf example
                现在容器已经变成没有example目录的新tomcat容器
                
            4.2.4.根据新的容器创建一个新的镜像并且放到docker的本地仓库中
                docker commit -a="seven" -m="this is tomcat server‘s contianer without example" 9462ab070461 seven/tomcat:20

*/                    

四、数据卷(在容器中存在)

//        把容器中的数据持久化到本机的硬盘中，做数据共享
        宿主机(本机linux系统)
        需求:
            把本机中/home/hostData文件夹和容器中的/home/containerData文件夹进行数据共享
            
        5.1.把数据持久化到主机中
            docker run -it -v /主机的路径(/home/hostData):/容器的路径(/home/containerData) 镜像名
        
        5.2.查看是否配置成功
            docker inspect 容器的id
            "Volumes": {
                "/home/containerData": "/home/hostData"
            }
            "Binds": [
                "/home/hostData:/home/containerData"
            ]
        
        思考问题:
            把容器停掉，修改主机上的文件，那么容器会自动同步么？
                5.2.1.停止容器
                    exit
                5.2.2.修改主机上的文件
                5.2.3.再次启动容器
                    docker attach 容器的id(6ffba5256bee)
                容器会一直监视主机目录的变化(容器停止后就不再监视)
                当容器重新启动，就直接启动监听，一旦监听到主机目录和容器的目录数据不一致，则会自动同步(需要一些时间)
        
        5.3.实现带权限的持久化数据
            主机可以任意修改目录数据，但是容器不能修改！
            主机有读和写的权限，但是容器只有读的权限
            思考问题:
                读写分离
                当docker中部署了mysql集群(读写分离)，写的数据可以持久化到本机硬盘中，但是读的mysql服务器并不能对主机的硬盘拥有写的操作
            docker run -it -v /主机的路径:/容器的路径:ro(read only) 镜像的名字
            查看是否配置成功:
                "VolumesRW": {
                    "/home/containerData2": false
                }
                
//    !!!!!!!开发docker其实就是编写dockerFile!!!!!!!!


五、使用dockerFile创建镜像
    需求:
            通过dockerFile创建centos7镜像(容器中的containerData2和containerData3和主机中的hostData做数据共享)
        6.1.在home目录下创建dockerfiles文件夹
            mkdir dockerfiles
            
        6.2.在dockerfiles文件夹中创建Dockerfile文件
            touch Dockerfile
            
        6.3.编写Dockerfile文件
            FROM centos:7(当前的环境为centos7)
            VOLUME ["/home/containerData3","/home/hostData3"](顺序我忘了，如果写反了你们自己更正)
            CMD /bin/bash
            
        6.4.执行创建命令
            docker build -f /home/dockerfiles/Dockerfile -t 创建的镜像名称:版本号 .
            "."就代表了当前所在目录，如果Dockerfile就在你当前的所在目录直接使用"."即可
            如果Dockerfile没有在你的当前目录，需要指向docker所在的目录
                docker build -f /home/dockerfiles/Dockerfile -t 创建的镜像名称:版本号 /home/dockerfiles
                
        6.5.启动镜像创建容器
            docker run -it centos_seven:7

六、dockefile的语法规则
        7.1.FROM 基础镜像，当前新镜像是基于哪个镜像的。
        7.2.MAINTAINER 镜像维护者的姓名和邮箱地址
        7.3.RUN 容器构建时需要运行的命令
        7.4.EXPOSE 当前容器对外暴露出的端口号
        7.5.WORKDIR 指定在创建容器后，终端默认登录的进来的工作目录，落脚点，默认是根目录/
        7.6.ENV 用来在构建镜像过程中设置环境变量
        7.7.ADD 将宿主机目录下的文件拷贝进镜像且ADD命令会自动处理URL和解压tar压缩包
        7.8.COPY 类似ADD，拷贝文件和目录到镜像中。eg. COPY src dest or COPY ["src","desc"]
        7.9.VOLUME 数据容器卷，用于数据保存和持久化工作。
        7.10.CMD指定一个容器启动时要运行的命令。DockerFile中可以有多个CMD指令，但只有最后一个生效，CMD会被docker run 之后的参数替换
        7.11.ENTRYPOINT 指定一个容器启动时要运行的命令。目的和CMD一样，但docker run 之后的参数会追加而不是替换。
        7.12.ONBUILD 当构建一个被继承的DockerFile时运行命令，父镜像在被子继承后父镜像的ONBUILD被触发