Docker 命令笔记

docker pull ubuntu 下载ubuntu镜像

docker pull http://hub.c.163.com/public/ubuntu:14.04 指明地址和版本号下载

 

docker仓库地址：hub.docker.com 帐户：docker0325 密码：ZB.8860244 当出现timeout异常是应该没有登录hub.docker.com docker login

 

运行镜像

docker run -it ubuntu bash

 

查看镜像信息

docker images

images 子命令：

                -a, -all=true|false 列出全部的镜像文件（包括临时文件），默认为否

                --digests=ture|false 列出镜像的数字摘要值，默认为否

                -f, --filter=[] 过滤出全部的镜像。

                --format=="TEMPLATE" 控制输出的格式，如ID表明ID信息， Repository表明仓库信息

                --no-trunc=true|false 对输出结果中太长的部分是否进行截断，如镜像的ID信息，默认为是

                -q,--quiet=true|false 仅输出ID信息，默认为否

               

添加镜像标签

docker tag ubuntu:latest myubuntu:latest

 

查看镜像详细信息

docker inspect ubuntu:14.04

 

查看镜像历史

docker history ubuntu:14.04      

 

搜索镜像

docker search

                --automated=true|false 仅显示自动建立的镜像，默认为否

                --no-trunc=true|false 输出信息不截断显示，默认为否

                -s, --stars=X 指定仅显示评价为指定星级以上的镜像，默认为0

 

删除镜像

docker rmi ubuntu

               

查看本机全部容器

docker ps -a

 

建立镜像

基于已有镜像的容器建立

1：首先运行容器，docker run -it ubuntu:14.04 /bin/bash

2：修改容器内容，好比在容器里面添加一个文件 touch test

3:exit 退出容器，记住容器ID， 容器ID是 启动容器后，root@322ced3aaala   其中322ced3aaala 就是容器ID

4：建立新镜像， docker commit -m "Added a new file" -a "Docker Newbee" 322ced3aaala test:0.1

 

上传镜像

docker push user/ubuntu:0.1  用户user上传镜像ubuntu 版本0.1

 

新建并启动容器

docker run ubuntu /bin/echo 'Hello world'

 

守护态运行容器

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

8322eb713648fa4e8c1337a0960b3934f72bac115f21cb419003b3ed1546526a

启动容器时调整容器使用的cpu权重和容器使用的内存大小,-c 设置权重，-m 设置内存大小 --cpuset 能够绑定cpu --cpuset=0,1

docker run -d -c 1 -m 10m  ubuntu

docker run -d --cpuset-0,1 -m 10m ubuntu

 

查看容器输出的日志

docker logs 8322eb713648fa4e8c1337a0960b3934f72bac115f21cb419003b3ed1546526a     容器返回的id

 

终止容器

docker stop 8322eb713648fa4e8c1337a0960b3934f72bac115f21cb419003b3ed1546526a

 

查看全部容器ID

docker ps -qa

 

启动容器

docker start

 

重启容器

docker restartdocker

 

进入容器

docker exec -it 容器id /bin/bash

 

删除容器

docker rm 容器id  

docker rm -f 容器id -f 可删除正在运行的容器

 

docker 仓库地址：

                https://hub.docker.com

               

重启docker：

                service docker restart

 

搭建docker本地私有仓库，并上传本地镜像到私有仓库

1:docker run -d -p 5000:5000 registry ,下载registry容器，建立本地仓库，默认地址：/var/lib/registry   

                docker run -d -p 5000:5000 -v /opt/data/registry:/var/lib/registry registry  可指定仓库安装地址

2：先pull一个小镜像

                docker pull busybox

3:修改镜像的tag

                docker tag busybox 127.0.0.1:5000/busybox

4:将打了tag的镜像上传到私有仓库中

                docker push 127.0.0.1:5000/busybox

6：删除本地busybox镜像，从私有仓库pull下来该镜像

    docker pull 127.0.0.1/busybox

 

 

 

Docker 多容器的数据共享 两种方式1：数据卷方式 ，直接将本地文件夹挂载到容器。 2 数据卷容器，建立特定容器提供数据供其余容器挂载

 

建立数据卷

 建立数据卷：挂载一个主机目录做为数据卷

docker run -d -P --name web -v /src/webapp:/opt/webapp:ro training/webapp python app.py  ro是只读,默认权限是读写

 

建立数据卷容器

docker run -it -v /dbdata --name dbdata ubuntu

 

启动两个容器  挂载数据卷容器

docker run -it --volumes-from dbdata --name db1 ubuntu

docker run -it --volumes-from dbdata --name db2 ubuntu

 

 

备份数据卷容器里面的数据卷

未学习

 

恢复数据卷的数据到容器里

未学习

 

 

容器端口映射（外部访问容器，映射真实端口到容器）

                                docker run -d -P training/webapp python app.py    -p（小写）须要指定端口， -P（大写）随机分配端口映射

                                docker run -d -p 5000:5000 training/webapp python app.py

                绑定多个端口,屡次使用-p

                                docker run -d -p 5000:5000 -p 3000:80 training/webapp python app.py

                映射到指定地址的指定端口

                                docker run -d -p 127.0.0.1:5000:5000 training/webapp python app.py

                映射到指定地址的任意端口,绑定192.168.22.146的任意一个端口到容器的5000端口

                                docker run -d -p 192.168.22.146::5000 training/webapp python app.py

 

查看docker容器端口映射配置

docker port 容器名

 

容器互联机制（多容器内互相访问）

                1:首先建立一个数据库容器

                docker run -d  --name db  training/postgres

                2:建立web容器并 link 数据库容器,link name:alias

                docker run -d -P --name web --link db:db traning/webapp python.py

                3：此时进入web 容器，可使用  ping db 来测试容器是否相通   ubuntu 安装ping 命令  apt-get install -yqq inetutils-ping

               

查看容器的公开信息,使用env 可查看web容器链接到db容器的配置信息

docker run --rm --name web2 --link db:db training/webapp eny

 

使用Dockerfile建立镜像,sshd:dockerfile 是镜像名：版本号 ,千万注意最后的那个.不能丢掉

docker build -it sshd:dockerfile .

 

 

容器映射本地目录,-p映射端口，-e 设置环境变量, -v将www文件夹映射到容器中的/var/www apache:ubuntu 是镜像名

 

docker run -i -d -p 80:80 -e APACHE_SERVERNAME=test -v `pwd`/www:/var/www apache:ubuntu

 

 

Dockerfile 指令说明：

 

                FROM   指定所建立镜像的基础镜像

                MAINTAINER   指定维护者信息

                RUN   运行指令

                CMD   指定启动容器时默认执行的命令

                LABEL  指定生成镜像的元数据标签信息

                EXPOSE   声明镜像内服务所监听的端口

                ENV   指定环境变量

                ADD   复制指定的<src>路径下的内容到容器中的<dest>路径下,<src>能够为URL，若是为tar文件，会自动解压到<dest>路径下

                COPY   复制本地主机的<src>路径下的内容到镜像中的<dest>路径下，通常状况下推荐使用COPY，而不是ADD

                ENTRYPOINT 指定镜像的默认入口

                VOLUME 建立数据卷挂载点

                USER   指定运行容器时的用户名或者UID

                WORKDIR  配置工做目录

                ARG  指定镜像内使用的参数（例如版本号信息）

                ONBUILD 配置当所建立的镜像做为其余镜像的基础镜像时，所执行的建立操做指令。

                STOPSIGNAL  容器退出的信号值

                HEALTHCHECK  如何进行健康检查

                SHELL   指定使用shell时的默认shell类型

 

 

               

Docker容器为镜像添加SSH服务

方式一：

安装openssh服务，基于Commit方式

 

运行容器：

docker run -it ubuntu:14.04 /bin/bash

 

                               

                                apt-get update

                                apt-get install openssh-server -y

                                mkdir -p /var/run/sshd

                               

                                启动ssh服务

                                /usr/sbin/sshd -D &

                               

                                此时查看容器的22端口

                                netstat -tunlp

                               

                                修改SSH服务的安全登录配置，取消pam登录限制

                                 sed -ri 's/session required pam_loginuid.so/#session required pam_loginuid.so/g' /etc/pam.d/sshd

               

                                建立.ssh目录，并将须要登录的公钥信息(通常为本地主机用户目录下的.ssh/id_rsa.pub文件，可由ssh-keygen -t rsa 命令生成)复制到authorized_keys文件中

                                mkdir root/.ssh

                                vi /root/.ssh/authorized_keys

                               

                                建立自动启动SSH服务的可执行文件run.sh

                                vi /run.sh

                                 #!/bin/bash

                                 /usr/sbin/sshd -D

                                 

                                 添加权限

                                 chmod +x run.sh

                                 

                                 退出容器 exit

                                 

                                 保存镜像

                                 docker commit 容器id sshd:ubuntu

 

                                在宿主机就可使用 ssh 宿主机ip -p 10022 实现免密登录容器了。

 

方式二：

                安装openssh,使用Dockerfile建立               

                                1：首先建立工做目录

                                                mkdir sshd_ubuntu

                                2:建立Dockerfile和run.sh文件

                                                touch Dockerfile run.sh

                                3:编写run.sh

                                #!/bin/bash

                                /usr/sbin/sshd -D

                                4:在宿主机上生成SSH密钥对，并建立authorized_keys文件

                                ssh-keygen -t rsa

                                cat ~/.ssh/id_rsa.pub >authorized_keys

                                5:编写Dockerfile文件

                                                #设置继承镜像

                                                FROM ubuntu:14.04

 

                                                #做者信息

                                                MAINTAINER docer_user （binbin.zhang）

 

                                                #下面开始 运行更新命令

                                                RUN apt-get update

 

                                                #安装ssh服务

                                                RUN apt-get install -y openssh-server

                                                RUN mkdir -p /var/run/sshd

                                                RUN mkdir -p /root/.sshd

                                                #取消pam限制

                                                RUN sed -ri 's/session required pam_loginuid.so/#session required pam_loginuid.so/g' /etc/pam.d/sshd

 

                                                #复制配置文件到相应位置，并赋予脚本可执行权限

                                                ADD authorized_keys /root/.ssh/authorized_keys

                                                ADD run.sh /run.sh

                                                RUN chmod 755 /run.sh

 

                                                #开放端口

                                                EXPOSE 22

 

                                                #设置自启动命令

                                                CMD ["/run.sh"]

                                6：建立镜像

                                在sshd_ubuntu文件夹下执行：

                                docker build -t sshd:dockerfile .

                                看到Successfully built $镜像id ，说明建立成功

                                7：测试镜像，运行容器,经过 docker logs 容器id 可查看启动log

                                docker run -d -p 10122:22 sshd:dockerfile

                                8:在宿主机执行 ，192.168.22.147是个人宿主机ip

                                ssh 192.168.22.147 -p 10122

                                成功登录到容器后，说明镜像建立没问题。

                               

                               

Dockerfile 安装Apache

                                1:建立一个apache_ubuntu的工做目录，在其中建立Dockerfile文件，run.sh文件和sample文件夹

                                                mkdir apache_ubuntu

                                                cd apache_ubuntu

                                                touch Dockerfile run.sh

                                                mkdir sample

                                2:编写Dockerfile文件      

 

                                                #设置继承自用户建立的sshd镜像

                                                FROM sshd:dockerfile

                                                                                               

                                                #建立者的基本信息

                                                MAINTAINER docker_user (binbin.zhang)

                                                                                               

                                                #设置环境变量，全部操做都是非交互式的

                                                ENV DEBIAN_FRONTEND noninteractive

                                                                                               

                                                #安装

                                                RUN apt-get -yq install apache2 &&\

                                                                                rm -rf /var/lib/apt/lists/*

                                                #设置系统的时区，由于在web应用中常常会用到时区这个系统变量。

                                                RUN echo "Asia/Shanghai" > /etc/timezone && \

                                                                                 dpkg-reconfigure -f noninteractive tzdata

                                                                                               

                                                ##添加用户的脚本，并设置权限，这会覆盖以前放在这个位置的脚本

                                                ADD run.sh /run.sh

                                                RUN chmod 755 /*.sh

                                                                                               

                                                #添加一个示例的web站点，删掉默认安装在apache文件夹下面的文件，并将用户添加的示例用软链接 连接到 /var/www/html 目录下面

                                                RUN mkdir -P /var/lock/apache2 && mkdir -P /app && rm -fr /var/www/html && ln -s /app /var/www/html

                                                                                               

                                                copy sample/ /app

                                                                                               

                                                #设置apache 相关的一些变量，在容器启动的时候可使用-e参数替代

                                                ENV APACHE_RUN_USER www-data

                                                ENV APACHE_RUN_GROUP www-data

                                                ENV APACHE_LOG_DIR /var/log/apache2

                                                ENV APACHE_PID_FILE /var/run/apache2.pid

                                                ENV APACHE_RUN_DIR /var/run/apache2

                                                ENV APACHE_LOCK_DIR /var/lock/apache2

                                                ENV APACHE_SERVERADMIN admin@localhost

                                                ENV APACHE_SERVERNAME localhost

                                                ENV APACHE_SERVERALIAS docker.localhost

                                                ENV APACHE_DOCUMENTROOT /var/www

                                                                                               

                                                #设置端口

                                                EXPOSE 80

                                                                                               

                                                WORKDIR /app

                                                                                               

                                                CMD ["/run.sh"]

                                3：在sample文件夹下新建index.html

                                                <!DOCTYPE html>

                                                <html>

                                                                <body>

                                                                                <p>Hello Docker!</p>

                                                                </body>

                                                </html>

                                4:编写run.sh脚本，脚本内容是启动apache服务

                                                #!/bin/bash

                                                exec apache2 -D FOREGROUND

                                5:编译镜像

                                                docker build -t apache:ubuntu .

                                5：运行镜像 经过 docker logs 容器id 可查看启动log

                                                docker run -d -P apache:ubuntu

                                6:测试

                                                ssh 127.0.0.1:80

                                               

                                               

Dockerfile 安装Nginx

                                1:建立工做目录

                                                mkdir nginx_ubuntu

                                                cd nginx_ubuntu

                                                touch Dockerfile run.sh

                                2:编写Dockerfile文件

                                                #设置继承自建立的sshd镜像

                                                FROM sshd:dockerfile

                                               

                                                #设置建立者的基本信息

                                                MAINTAINER binbin (bbz17640380550@163.com)

                                               

                                                #安装nginx,设置nginx以非daemon启动

                                                RUN \

                                                                apt-get install -y nginx && \

                                                                rm -rf /var/lib/apt/lists/* && \

                                                                echo "\ndaemon off;" >> /etc/nginx/nginx.conf && \

                                                                chown -R www-data:www-data /var/lib/nginx

                                                               

                                                #设置系统时区

                                                RUN echo "Asia/Shanghai" > /etc/timezone && \

                                                    dpkg-reconfigure -f noninteractive tzdata

                                               

                                                #添加脚本，设置权限。

                                                ADD run.sh /run.sh

                                                RUN chmod 755 /*.sh

                                               

                                                #定义能够被挂载的目录，分别是虚拟主机的挂载目录，证书目录，配置目录和日志目录

                                                VOLUME ["/etc/nginx/sites-enabled","/etc/nginx/certs","/etc/nginx/conf.d","/var/log/nginx"]

                                               

                                                #定义工做目录

                                                WORKDIR /etc/nginx

                                               

                                                #定义输出命令

                                                CMD ["/run.sh"]

                                               

                                                #定义输出端口

                                                EXPOSE 80

                                                EXPOSE 443

                                               

                                3:编写run.sh脚本文件      

                                                #!/bin/bash

                                                /usr/sbin/sshd &

                                                /usr/sbin/nginx

                               

                                4:编译建立nginx镜像

                                                docker build  -t nginx:stable .

                               

                                5:运行nginx镜像 经过 docker logs 容器id 可查看启动log

                                                docker run -d -P nginx:stable

                                6:查看自动映射的端口

                                                docker ps

                                7:检查

                                                curl 127.0.0.1:$映射80的端口

                                               

                                               

Dockerfile 安装Tengine 淘宝的加强版nginx

                                1:建立工做目录：

                                                mkdir tengine_ubuntu

                                                touch Dockerfile

                                2:编写Dockerfile文件

                               

                                                #继承咱们建立的sshd镜像

                                                FROM sshd:dockerfile

                                               

                                                #建立者信息

                                                MAINTAINER binbin.zhang(bbz17640380550@163.com)

                                               

                                                #安装编译环境

                                                RUN apt-get install -y build-essential debhelper make autoconf automake patch

                                                RUN apt-get install -y dpkg-dev fakeroot pbuilder gnupg dh-make libssl-dev libpcre3-dev git-core

                                               

                                                #设置系统时区

                                                RUN echo "Asia/Shanghai" > /etc/timezone && \

                                                    dpkg-reconfigure -f noninteractive tzdata

                                                               

                                                #建立Nginx用户

                                                RUN adduser --disabled-login --gecos 'Tengine' nginx

                                               

                                                # tengine 安装的shell脚本

                                                WORKDIR /home/nginx

                                                RUN su nginx -c 'git clone https://github.com/alibaba/tengine.git'

                                               

                                                WORKDIR /home/nginx/tengine

                                                RUN su nginx -c 'mv package/debian .'

                                               

                                                ENV DEB_BUILD_OPTIONS nocheck

                                               

                                                RUN su nginx -c 'dpkg-buildpackage -rfakeroot -uc -b'

                                               

                                                WORKDIR /home/nginx

                                                RUN dpkg -i tengine_2.0.2-1_amd64.deb

                                               

                                                #定义挂载的目录

                                                VOLUME ["/data","/etc/nginx/sites-enabled","/var/log/nginx"]

                                               

                                                #让Nginx运行在非Daemo模式

                                                RUN echo "\ndaemon off;" >> /etc/nginx/nginx.conf

                                               

                                                #定义工做目录

                                                WORKDIR /etc/nginx

                                               

                                                #添加脚本，设置权限。

                                                ADD run.sh /run.sh

                                                RUN chmod 755 /*.sh

                                               

                                                #定义输出命令

                                                CMD ["/run.sh"]

                                               

                                                #定义输出端口

                                                EXPOSE 80

                                                EXPOSE 443

                                               

                                3:编写run.sh文件

                                                #!/bin/bash

                                                /usr/sbin/sshd &

                                                /usr/sbin/nginx

                                4:编译dockfile文件 建立镜像

                                                docker build -t nginx:alibaba .

                                5:启动容器，并查看端口映射信息 经过 docker logs 容器id 可查看启动log

                                docker run -d -P nginx:alibaba

                                docker ps

                                6:测试容器

                                curl 127.0.0.1:映射80的端口

 

Dockerfile 安装 Tomcat                  

                                1:准备jdk1.8，和tomcat8.5

                                2:建立工做目录

                                 mkdir tomcat8.5_jdk1.8

                                 touch Dockerfile run.sh

                                 将jdk1.8和tomcat8.5 cp 到此目录

                                此时目录结构，Dockerfile apache-tomcat-8.5.32 jdk1.8.0_181 run.sh

                               

                                3:编写Dockerfile文件

                                                #继承咱们建立的sshd镜像

                                                FROM sshd:dockerfile

                                               

                                                #做者信息

                                                MAINTAINER binbin.zhang(bbz17640380550@163.com)

                                               

                                                ##设置环境变量,全部操做都是非交互式的

                                                ENV DEBIAN_FRONTEND noninteractive

                                               

                                                #设置系统时区

                                                RUN echo "Asia/Shanghai" > /etc/timezone && \

                                                    dpkg-reconfigure -f noninteractive tzdata

                                               

                                                #安装跟Tomcact用户认证相关的软件

                                                RUN apt-get install -yq --no-install-recommends wget pwgen ca-certificates && \

                                                                apt-get clean && \

                                                                rm -rf /var/lib/apt/lists/*

                                                               

                                                #设置tomcat的环境变量，如有其余的环境变量须要设置，也能够在这里添加

                                                ENV CATALINA_HOME /tomcat

                                                ENV JAVA_HOME /jdk

                                               

                                                #复制tomcat 和 jdk 文件到镜像中

                                                ADD apache-tomcat-8.5.32 /tomcat

                                                ADD jdk1.8.0_181 /jdk

                                               

                                                ADD run.sh /run.sh

                                               

                                                RUN chmod +x /*.sh

                                                RUN chmod +x /tomcat/bin/*.sh

                                                RUN chmod +x /jdk/bin/*

                                               

                                                EXPOSE 8080

                                                CMD["/run.sh"]

                                               

                                4:编写run.sh

                                                #!/bin/bash

                                                /usr/sbin/sshd -D &

                                                exec ${CATALINA_HOME}/bin/catalina.sh run

                                5:编译dockfile文件，建立镜像        

                                                docker build -t tomcat8.5:jdk1.8

                                6:启动tomcat容器 经过 docker logs 容器id 可查看启动log

                                                docker run -d -P tomcat8.5:jdk1.8

                                7:查看端口映射

                                                docker ps

                                                                                               

                                                                                               

Docker 安装 rabbitmq

                                docker pull rabbitmq:management

                                docker run -d --name rabbit -p 15672:15672 -p 5672:5672 -v /var/lib/rabbitmq:/var/lib/rabbitmq -v /var/log/rabbitmq:/var/log/rabbitmq  rabbitmq:management

                               

Docker 安装 Jenkins   ps(-u 是讲执行命令的用户权限内置到容器里，0是root用户的id  -d是以守护进程方式运行，-p绑定端口， -v挂载宿主机文件夹) 

                                docker run -d -u 0 -p 8081:8080 -p 50000:50000 -v /var/lib/jenkins:/var/jenkins_home jenkins

                               

Docker 安装GitLab

                                docker run -d --detach  --hostname gitlab.example.com --publish 443:443 --publish 80:80 --publish 23:23  --name gitlab --restart always  --volume /srv/gitlab/config:/etc/gitlab  --volume /src/gitlab/logs:/var/log/gitlab --volume /srv/gitlab/data:/var/opt/gitlab  gitlab/gitlab-ce:latest

                               

                                登陆用户名：root

                               

Docker 安装Redis

                               

                                1:docker run --name redis-container -d redis

                                2:进入redis容器

                                docker exec -it 容器id /bin/bash

                                3:查看容器运行时间和内存情况,环境变量（命令分别是：uptime,free,env）

                                4：运行redis 客户端

                                docker run -it --link redis-container:db --entrypoint redis-cli redis -h db

                               

Docker 核心技术：

1：Linux操做系统的命名空间

利用Linux操做系统的命名空间的特性，Docker实现了每一个容器都有本身的命名空间，运行在其中的应用都像是在独立的操做系统环境中同样。命名空间机制保证了容器之间彼此互不影响。

                1-1：进程命名空间：

每一个进程命名空间有一套本身的进程号管理方法。进程命名空间是一个父子关系的结构，子空间中的进程对于父空间的进程是可见的。

例如查看Docker 主进程的进程号是8137

ps -ef|grep docker

root      8137  1200  0 08:51 ?        00:00:00 docker-containerd-shim -namespace moby -workdir /var/lib/docker/containerd/daemon/io.containerd.runtime.v1.linux/moby/adfd7a83fae0e705d49732a8178bdfc153bfa4d45aad69461e4c18aa42c9fbfe -address /var/run/docker/containerd/docker-containerd.sock -containerd-binary /usr/bin/docker-containerd -runtime-root /var/run/docker/runtime-runc

此时运行一个容器例如：docker run -d ubuntu /bin/sh -c "while true:do echo hello world;sleep 1;done"

查看新建容器的进程,能够看到当前的进程的父进程号是8137

ps -ef|grep while

root      8153  8137  0 08:51 ?        00:00:00 /bin/sh -c while true;do echo hello world;sleep 1;done

                1-2:网络命名空间

物理主机的物理网卡 经过网桥的方式将每一个容器的虚拟网口 链接在一块儿。实现了网络命名空间的隔离

                1-3：IPC命名空间

Linux常见的进程间交互方法-》IPC ,容器中进程交互也采用了IPC，同一个IPC命名空间内的进程能够彼此可见，容许进行交互，不一样空间的进程则没法交互。

                1-4：挂载命名空间

挂载命名空间容许不一样命名空间的进程看到的文件结构不一样，这样每一个命名空间中的进程所看到的文件目录彼此被隔离。

                1-5：UTS命名空间

容许每一个容器拥有独立的主机名和域名，从而能够虚拟出一个独立主机名和网络空间的环境，默认状况下容器ID，就是容器的主机名。

                1-6：用户命名空间

每一个容器能够有不一样的用户和组id，每一个容器内部均可以有root用户，但和宿主机的root不在一个命名空间。

 

2：控制组

控制组是Linux内核的一个特性。主要用来对共享资源的隔离，限制，审计等等、

                2-1：资源限制

                主要是能够限制容器使用宿主机内存的上限

                2-2：优先级

                能够指定某个容器使用cpu的优先级。

                2-3：资源审计

                用来统计系统实际上把多少资源用到合适的目的上，可使用cpuacct子系统记录某个进程使用的cpu时间

                2-4：隔离

                为组隔离命名空间，这样一个组不会看到另外一个组的进程，网络链接和文件系统

                2-5：控制C

                挂起，恢复，重启动等操做。

                安装Docker后，用户能够在 /sys/fs/cgroup/memory/docker 目录下看到对Docker组应用的各类限制。

好比：memory_limit_in_bytes 文件是配置对Docker用户组中的全部进程使用的物理内存总量的限制，能够改变文件内容进行对内存总量限制的修改。

3：联合文件系统

Docker镜像自身是由多个文件层组成，每一层有惟一编号。

经过docker history ubuntu:14.04 能够看到ubuntu14.04镜像 有哪些层组成的。

Docker全部的存储都在Docker目录下，以ubuntu为例，在/var/lib/ubuntu 其中aufs目录是文件系统所在，aufs中存储着Docker镜像相关数据和信息。

新版本的docker文件系统已经被Overlay取代了。

 

4：Linux网络虚拟化

                网络建立的过程

                1：建立一对虚拟接口，分别放到本地主机和新容器的命名空间上。

                2：本地主机的一端虚拟借口链接到默认的docker0的网桥上，并具备一个以veth开头的惟一名字。例如veth1234

                3:容器一端的虚拟接口将放到新建立的容器中，并修更名字做为eth0,这个接口只在容器的命名空间可见

                4：从网桥可用地址段中获取一个空闲地址分配给容器的eth0,并配置默认路由网关为docker0网卡的内部接口docker0的ip地址。

 

Docker 搭建私有仓库几大要素  这部分我没有详细实践，具体可自行百度，或者查看《Docker技术入门与实战》第18章

                 使用Nginx代理私有仓库的容器地址，让其余机器能够访问私有仓库。

                 对私有仓库进行用户名密码认证（基于Nginx）

                 证书认证，可经过openssl本身生成证书或者从网上申请证书。我的以为 通常公司不须要证书认证。

                 

 

Docker 安全防御检测工具：

                1:Docker Bench：按照CIS Docker 规范包括主机配置，Docker引擎，配置文件权限，镜像管理，容器运行时环境，安全项等六大方面进行扫描检查。

                使用方法：docker run -it --net host --pid host --cap-add audit_control -v /var/lib:/var/lib -v /var/run/docker.sock:/var/run/docker.sock -v /usr/lib/systemd:/usr/lib/systemd -v /etc:/etc --label docker_bench_security docker/docker-bench-security

               

                2:clair：对容器的文件层进行扫描从而发现漏洞 使用方法不介绍了，自行百度吧很简单。

               

Docker 高级网络功能：

                这部分我也不作详细解释了。

                正常状况下使用docker 建立容器时 默认的网络便可。  若是真的须要配置容器的DNS 主机名或者网桥之类的。看看《Docker技术入门与实战》的第20章吧,当工具书来使用就能够了。

               

Docker 构建跨主机容器网络：

                实现这个功能，须要利用libnetwor插件，在libnetwork的网络方案中，要实现跨主机容器网络须要一个网络信息管理机制，一个键值数据库便可。例如，Consul,Etcd,Zookeeper等工具均可以知足。

1：配置网络信息管理数据库

 以Consul为例，启动一个progrium/consul容器，并映射服务到本地的8500端口

            docker run -d -p 8500:8500 -h consul progrium/consul -server -bootstrap

2：配置Docker主机

启动两台Docker主机n1和n2，分别安装好最新的docker-enginne ,确保这两台主机之间能够经过IP地址互相访问，另外，都能访问到数据库节点的8500端口。

配置主机的Docker服务启动选项：

DOCKER_OPTS=“$DOCKER_OPTS –cluster-store=consul://<CONSUL_NODE>:8500  --cluster-advertise=eth0:2376”

重启docker服务

sudo service doker restart

 

3:建立网络

在任意一个节点上建立网络multi,例如在n1上执行命令。

 docker network create -d overlay multi

建立成功后，能够同时在n1和n2上查看到新的网络multi的信息

docker network ls

4：测试网络

1：在n1上启动一个容器c1，经过--net选项制定连接到multi网络上，查看网络信息，其中一个接口eth0已经连接到multi的网络上。

在n1上执行:docker run -it –name=c1 –net=multi busybox

2：在n2上启动一个容器c2,一样链接到multi网络上，经过ping c1进行测试

在n2上执行：docker run -it –name=c2 -net=multi busybox

            ping  c1

若是能够ping通，说明跨主机容器网络已经构建完成了。

 

 

Docker 开源项目(简单介绍  详细信息须要去github了解，或者自行百度)

1：Etcd-----高可用的键值数据库

2：Docker三剑客之Docker Machine

            Docker Machine负责使用Docker的第一步，在多种平台上快速安装Docker环境。它支持多种平台，让用户能够在很短期内搭建一套Docker主机集群。

3：Docker三剑客之Docker Compose

            Docker Compose它可让用户经过编写一个简单的模板文件，快速的建立和管理基于Docker容器的应用集群

4：Docker 三剑客之Docker Swarm

                Docker Swarm提供容器集群服务，使用它能够将多个Docker 主机封装为单个大型的虚拟主机，快速打造一套容器云平台。

5：Mesos-----优秀的集群资源调度平台

                Mesos项目是源自UC Berkeley对集群资源进行抽象和管理的开源项目，相似于操做系统内核，用户可使用它很容易地实现分布式应用的自动化调度。

6：Kubernetes--------生产级容器集群平台（K8S）

                打算详细看一下《Kubernetes 权威指南》  我有pdf，若有须要私信我吧  bbz17640380550@163.com

一张图总结Docker命令：