docker容器从入门到精通

第1章 docker容器

1.1 什么是容器？

容器就是在隔离的环境运行的一个进程，如果进程停止，容器就会销毁。隔离的环境拥有自己的系统文件，ip地址，主机名等

1.2 容器和KVM虚拟化的区别

kvm虚拟化： 需要硬件的支持，需要模拟硬件，可以运行不同的操作系统，启动时间分钟级(开机启动流程)

• linux开机启动流程：
• bios开机硬件自检
• 根据bios设置的优先启动项 网卡 硬盘 u盘 光驱
• 读取mbr引导 UEFI(gpt分区) mbr硬盘分区信息，内核加载路径
• 加载内核
• 启动第一个进程init systemd
• 系统初始化完成
• 运行服务

容器：共用宿主机内核，容器的第一个进程直接运行服务，损耗少，启动快，性能高
容器虚拟化：不需要硬件的支持。不需要模拟硬件，共用宿主机的内核，启动时间秒级(没有开机启动流程)

总结：

（1）与宿主机使用同一个内核，性能损耗小；
（2）不需要指令级模拟；
（3）容器可以在CPU核心的本地运行指令，不需要任何专门的解释机制；
（4）避免了准虚拟化和系统调用替换中的复杂性；
（5）轻量级隔离，在隔离的同时还提供共享机制，以实现容器与宿主机的资源共享。

1.3 容器技术的发展过程：

• 1）:chroot技术，新建一个子系统（拥有自己完整的系统文件）
  参考资料：https://www.ibm.com/developerworks/cn/linux/l-cn-chroot/
  使用chroot监狱限制SSH用户访问指定目录和使用指定命令
  https://linux.cn/article-8313-1.html

• 2）：linux容器(lxc) linux container(namespaces 命名空间 隔离环境 及cgroups 资源限制)

cgroups 限制一个进程能够使用的资源。cpu，内存，硬盘io
kvm虚拟机：资源限制（1c 1G 20G）

• 安装epel源

  yum install epel-release -y

• 编译epel源配置文件

vi  /etc/yum.repos.d/epel.repo
[epel]
name=Extra Packages for Enterprise Linux 7 - $basearch
baseurl=https://mirrors.tuna.tsinghua.edu.cn/epel/7/$basearch
#mirrorlist=https://mirrors.fedoraproject.org/metalink?repo=epel-7&arch=$basearch
failovermethod=priority
enabled=1
gpgcheck=1
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-EPEL-7

[epel-debuginfo]
name=Extra Packages for Enterprise Linux 7 - $basearch - Debug
baseurl=https://mirrors.tuna.tsinghua.edu.cn/epel/7/$basearch/debug
#mirrorlist=https://mirrors.fedoraproject.org/metalink?repo=epel-debug-7&arch=$basearch
failovermethod=priority
enabled=0
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-EPEL-7
gpgcheck=1

[epel-source]
name=Extra Packages for Enterprise Linux 7 - $basearch - Source
baseurl=https://mirrors.tuna.tsinghua.edu.cn/epel/7/SRPMS
#mirrorlist=https://mirrors.fedoraproject.org/metalink?repo=epel-source-7&arch=$basearch
failovermethod=priority
enabled=0
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-EPEL-7
gpgcheck=1

• 安装lxc

yum install lxc-* -y
yum install libcgroup* -y
yum install bridge-utils.x86_64 –y  #创建桥接网卡的

• 桥接网卡

[root@controller ~]# cat /etc/sysconfig/network-scripts/ifcfg-eth0 
echo 'TYPE=Ethernet
BOOTPROTO=none
NAME=eth0
DEVICE=eth0
ONBOOT=yes
BRIDGE=virbr0' >/etc/sysconfig/network-scripts/ifcfg-eth0

[root@controller ~]# cat /etc/sysconfig/network-scripts/ifcfg-virbr0 
echo 'TYPE=Bridge
BOOTPROTO=static
NAME=virbr0
DEVICE=virbr0
ONBOOT=yes
IPADDR=10.0.0.11
NETMASK=255.255.255.0
GATEWAY=10.0.0.254
DNS1=223.5.5.5' >/etc/sysconfig/network-scripts/ifcfg-virbr0

systemctl restart network

• 启动cgroup
  systemctl start cgconfig.service

##启动lxc

systemctl start lxc.service

• 创建lxc容器

方法1:
lxc-create -t download -n centos6 -- --server mirrors.tuna.tsinghua.edu.cn/lxc-images -d centos -r 6 -a amd64
方法2：
lxc-create -t centos -n test

• 为lxc容器设置root密码：

[root@controller ~]# chroot /var/lib/lxc/test/rootfs passwd   #切换根目录到容器里设置root密码
Changing password for user root.
New password: 
BAD PASSWORD: it is too simplistic/systematic
BAD PASSWORD: is too simple
Retype new password: 
passwd: all authentication tokens updated successfully.

• 为容器指定ip和网关

vi /var/lib/lxc/centos7/config   #默认的容器路径
lxc.network.name = eth0
lxc.network.ipv4 = 10.0.0.111/24
lxc.network.ipv4.gateway = 10.0.0.254

• 启动容器

lxc-start -n centos7

1.4 docker容器概念

Docker是通过内核虚拟化技术（namespaces及cgroups cpu、内存、磁盘io等）来提供容器的资源隔离与安全保障等。由于Docker通过操作系统层的虚拟化实现隔离，所以Docker容器在运行时，不需要类似虚拟机（VM）额外的操作系统开销，提高资源利用率。
namespace 资源隔离
cgroups 进程的资源限制
docker 初期把lxc二次开发，libcontainer

---

docker的主要目标是"Build,Ship and Run any App,Angwhere",构建，运输，处处运行
部署服务，环境问题
一次构建，处处运行
docker是一种软件的打包技术
构建：做一个docker镜像
运输：docker pull
运行：启动一个容器
每一个容器，他都有自己的系统文件rootfs.

---

docker解决了软件和操作系统环境之间的依赖，能够让独立服务或应用程序在不同的环境中，得到相同的运行结果。
docker镜像有自己的文件系统。
docker容器是一种轻量级、可移植、自包含的软件打包技术，使应用程序可以在几乎任何地方以相同的方式运行。开发人员在自己笔记本上创建并测试好的容器，无需任何修改就能够在生产系统的虚拟机、物理服务器或公有云主机上运行。

扫描二维码关注公众号，回复： 6335739 查看本文章

1.5 docker的安装

• 10.0.0.11：修改主机名和host解析 #为了节省时间，劫持阿里云为本地的仓库了

rm -fr /etc/yum.repos.d/local.repo
curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
wget -O /etc/yum.repos.d/docker-ce.repo https://mirrors.ustc.edu.cn/docker-ce/linux/centos/docker-ce.repo
sed -i 's#download.docker.com#mirrors.tuna.tsinghua.edu.cn/docker-ce#g' /etc/yum.repos.d/docker-ce.repo
yum install docker-ce -y

docker的主要组成部分

docker是传统的CS架构分为docker client和docker server,向mysql一样

1.6 命令:

[root@controller ~]# docker version #查看版本信息
Client:
 Version:   17.12.0-ce
 API version:   1.35
 Go version:    go1.9.2
 Git commit:    c97c6d6
 Built: Wed Dec 27 20:10:14 2017
 OS/Arch:   linux/amd64

Server:
 Engine:
  Version:  17.12.0-ce
  API version:  1.35 (minimum version 1.12)
  Go version:   go1.9.2
  Git commit:   c97c6d6
  Built:    Wed Dec 27 20:12:46 2017
  OS/Arch:  linux/amd64
  Experimental: false

[root@controller ~]# docker info #查看详细信息（如果要做监控可以在这里取值）
Containers: 0  #容器数量
 Running: 0    #正在运行数量
 Paused: 0     #暂停数量
 Stopped: 0    #停住退出的数量
Images: 0      #镜像数量

Server Version: 18.09.5         #版本
Storage Driver: overlay2        #存储驱动程序
 Backing Filesystem: xfs        #文件支持 xfs
 Supports d_type: true
 Native Overlay Diff: true
Logging Driver: json-file       #日志记录json格式
Cgroup Driver: cgroupfs         #cgroupfs进程资源限制

• docker主要组件有：镜像、容器、仓库, 网络，存储

• 启动容器必须需要一个镜像，仓库中只存储镜像

手动安装Nginx步骤繁琐：
nginx.org官网下载Nginx源码包wget
创建Nginx用户
编译安装
./config....
修改配置文件，
启动

1.6 启动一个nginx容器

• ##配置docker镜像加速

vi /etc/docker/daemon.json
{
  "registry-mirrors": ["https://registry.docker-cn.com"]
}   

• ##启动80端口

  docker run -d -p 80:80 nginx
  run（创建并运行一个容器）
  -d 放在后台
  -p 端口映射
  nginx 是docker镜像的名字
  本地没有的镜像默认会尝试去官方pull

docker的镜像管理
官方仓库hub.docker.com
docker search ——搜索镜像

• 选镜像的建议：

  1，优先考虑官方
  2，stars数量多的有限选择

1.7 获取镜像

docker pull（push）
镜像加速器：阿里云加速器，daocloud加速器，中科大加速器，Docker 中国官方镜像加速：https://registry.docker-cn.com

pull官方： docker pull centos:6.8（如果没有指定版本，默认会下载最新版）可以去hub.docker.com官网查看版本
pull私有： docker pull daocloud.io/huangzhichong/alpine-cn:latest

• ##配置docker镜像加速

vi /etc/docker/daemon.json
{   
  "registry-mirrors": ["https://registry.docker-cn.com"]
}   

• ##第三方docker镜像仓库，使用方法：

docker pull index.tenxcloud.com/tenxcloud/httpd:latest

1.8 镜像管理

查看镜像
docker images docker image ls
删除镜像
docker rmi 例子：docker image rm centos:latest
导出镜像
docker save 例子：docker image save centos > docker-centos7.4.tar.gz
导入镜像
docker load 例子：docker image load -i docker-centos7.4.tar.gz
例2：docker load -i docker-centos7.4.tar.gz

镜像命令总结：

docker search ——搜索镜像
docker pull（push）——拉取推送镜像
docker images ——查看所有镜像
docker rmi xxx ——删除镜像
docker save xxx——导出镜像
docker load -i xxx ——导入镜像
docker commit —提交导出为镜像
docker commit 容器id或者容器的名字 新的镜像名字[:版本号可选]
docker build -t centos6.9_ssh:v3 /centos6.9_ssh/Dockerfile
dockerfile构建镜像 –t 起个名字：版本 dockerfile文件路径
docker image history kod:v6 ——查看镜像的构建历史

=========================================================

1.9 docker容器管理

启动容器

    docker run image_name
    docker run -it image_name CMD
    docker run ==== docker create  + docker start
    docker run -d -p 80:80 nginx:latest

run（创建并运行一个容器）
-d 放在后台
-p 端口映射
-P 随机端口映射
-v 源地址(宿主机):目标地址(容器) 详细：https://www.jianshu.com/p/e605de64e9f9
-e 指定环境变量值xxx=yyy
-h 设置容器的主机名 默认为ID号

docker run -it --name centos6 centos:6.9 /bin/bash

-it 进入容器 分配交互式的终端
--name 指定容器的名字
/bin/sh覆盖容器的初始命令（默认/bin/bash）

停止容器

    docker stop CONTAINER_ID

杀死容器

    docker kill container_name

查看容器进程列表

docker ps             #显示运行的容器
docker ps -q          #只显示进程ID号 
docker ps -a           #显示所有容器进程状态
docker ps -a -l             #显示最后一个容器状态
docker ps -a --no-trunc   #完整显示所有容器状态

进入容器 (目的：调试，排错)

docker exec  （会分配一个新的终端tty）
docker exec [OPTIONS] CONTAINER COMMAND [ARG...]

用法：

docker exec -it  容器id或容器名字 /bin/bash（/bin/sh）
docker attach（使用同一个终端,会同步执行命令，不推荐）
docker attach [OPTIONS] CONTAINER

注意：

exec是进入新的容器，没有历史命令
attach 是进入原容器，有历史命令

退出容器快捷键:

Ctrl+p 松手Ctrl+q

删除容器

docker rm [xxx] -f 强制删除

批量删除容器

docker rm -f docker ps -a -q

container其他命令

commit —提交导出为镜像
cp ——复制文件（可以导出导入）
docker cp 本地路径 容器长ID:容器路径
diff ——对比容器和镜像多出哪些文件
ls ——看容器列表
pause ——挂起容器
unpause ——恢复挂起的容器
status ——查看状态

重启docker服务让容器自动启动：

方法一：docker run --restart=always #重启后容器从新运行
方法二：/etc/docker/daemon.json配置文件中加入 "live-restore": true #重启后容器接着运行

查看容器所有属性信息：

docker inspect 7967eac18443

查看容器的网络类型

docker network ls

总结：

docker容器内的第一个进程（初始命令）必须一直处于前台运行的状态（必须夯住），否则这个容器，就会处于退出状态！
docker exec -it 容器id或容器名字 /bin/bash #这就是初始命令
docker run -it --name centos6 centos:6.9 /bin/bash #使用-it启动并进入容器再Ctrl+p ,Ctrl+q退出也是处于夯住的状态。

业务在容器中运行：夯住，启动服务
Nginx 夯住命令： nginx -g 'daemon off;'
Sshd 夯住命令： /usr/sbin/sshd -D

docker容器的网络访问（端口映射）

docker0：172.17.0.1 jumpserver：172.17.0.2 nginx：172.17.0.3

启动docker服务后，默认自动会把内核转发参数开启为1
net.ipv4.ip_forward = 1

• 指定映射(docker 会自动添加一条iptables规则来实现端口映射)

  -p hostPort:containerPort
  -p host-ip:hostPort:containerPort 多个容器都想使用80端口方法如下：
  ifconfig eth0:1 10.0.0.111/24 up 创建辅助IP
  -p ip::containerPort(随机端口)
  -p hostPort:containerPort:udp
  -p 81:80 –p 443:443 可以指定多个-p

• 随机映射
  docker run -P （随机端口）

通过iptables来实现的端口映射

• DOCKER 给运行中的容器添加映射端口

  1、获得容器IP
  将container_name 换成实际环境中的容器名
  docker inspect container_name | grep IPAddress
  2、 iptable转发端口
  将容器的8000端口映射到docker主机的8001端口
  复制代码代码如下:
  iptables -t nat -A DOCKER -p tcp --dport 8001 -j DNAT --to-destination 172.17.0.19:8000

docker的数据卷管理

持久化

数据卷(文件或目录)
-v 卷名:/data
-v src（宿主机的目录）:dst（容器的目录）
数据卷容器
--volumes-from（跟某一个已经存在的容器挂载相同的卷）

• 注意：挂载文件需要写文件名

  基于多端口的多站点。

docker run -d -p 80:80 -p 81:81 -v /scc/xiaoniao:/usr/share/nginx/xiaoniao
docker cp 1bd345a4dbe2:/etc/nginx/conf.d/1.conf /tmp

================================================

手动将容器保存为镜像

docker commit 容器id或者容器的名字 新的镜像名字[:版本号可选]

• ####制作一个只支持sshd服务的镜像
  1):启动一个容器，并修改

  docker run -it -p 1022:22 centos:6.8 /bin/bash
  yum install openssh-server -y
  echo 'root:123456'|chpasswd
  /etc/init.d/sshd start
  测试：ssh远程登录

2）：将修改后的容器，保存为镜像

docker commit friendly_swartz centos6-ssh:latest

3）测试新镜像，sshd是否可用

docker run -d -p 1122:22 centos6-ssh:latest /usr/sbin/sshd -D
ssh [email protected] -p 1122

• ####制作了一个支持sshd和httpd双服务的镜像
  1）：启动一个容器，并修改

docker run -d -p 1122:22 centos6-ssh:latest /usr/sbin/sshd -D
yum install httpd -y
/etc/init.d/httpd start

vi /init.sh
#!/bin/bash
/etc/init.d/httpd start
/usr/sbin/sshd -D

chmod +x /init.sh

2）：将修改后的容器，保存为镜像

docker commit 11bf5984784a centos6-httpd

3）测试新镜像，检测sshd和httpd是否可用

docker run -d -p 1222:22 -p 80:80 centos6-httpd:latest /init.sh

第2章 dockerfile自动构建docker镜像

类似ansible剧本，大小几kb
手动做镜像：大小几百M+
dockerfile 支持自定义容器的初始命令

• dockerfile主要组成部分：

  基础镜像信息 FROM centos:6.9
  制作镜像操作指令 RUN yum install openssh-server -y
  容器启动时执行指令 CMD ["/bin/bash"]
  文件传输 ADD inint.sh /init.sh

例1：

[root@oldboy centos6.9_ssh]# cat Dockerfile    脚本必须是这个名 
FROM  centos:6.9                
RUN yum install openssh-server –y   
RUN service sshd start
RUN echo '123456'|passwd --stdin root
CMD ["/usr/sbin/sshd","-D"]         #有参数用逗号隔开

#自动构建镜像：

[root@oldboy centos6.9_ssh]# docker build -t centos6.9_ssh:v3  /centos6.9_ssh/Dockerfile
                                    -t 起个名字:版本

例2：

[root@oldboy centos6.9_ssh]# cat Dockerfile 
FROM  centos:6.9
#默认一个RUN就会启动一个临时容器，然后就会覆盖之前的hosts解析
RUN echo '192.168.19.200 mirrors.aliyun.com' >>/etc/hosts && \ 
curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-6.repo && \
curl -o /etc/yum.repos.d/epel.repo http://192.168.19.200/repo/epel-6.repo && \
yum install openssh-server nginx  -y
RUN service sshd start
#在RUN里面启动的任何服务都是临时的，不会真正的启动
RUN echo '123456'|passwd --stdin root
ADD init.sh /init.sh
#ADD 把宿主机当前目录init.sh 传到容器根下面
CMD ["/bin/bash","/init.sh"]

[root@oldboy centos6.9_ssh]# cat init.sh 
#!/bin/bash
service nginx start
/usr/sbin/sshd -D

[root@oldboy centos6.9_ssh]# docker build -t centos6.9_ssh:v4  /centos6.9_ssh/Dockerfile

dockerfile常用指令：（要严格遵守大小写）

FROM 这个镜像的妈妈是谁？（指定基础镜像）
MAINTAINER 告诉别人，谁负责养它？（指定维护者信息，可以没有）
LABLE      描述，标签 (可以没有)

RUN 你想让它干啥（在命令前面加上RUN即可）
ADD 给它点创业资金（会自动解压tar不会解压zip包）  制作docker基础的系统镜像
WORKDIR 我是cd,今天刚化了妆（设置当前工作目录）
VOLUME 后跟容器需要持久化的目录（设置卷，挂载主机目录）
    持久化默认路径/var/lib/docker/volumes/以随机字符串命名的目录下
EXPOSE 它要打开的门是啥（指定对外的端口）(-P 随机端口)
CMD 奔跑吧，兄弟！（指定容器启动后的要干的事情）（容易被替换）

dockerfile其他指令：

COPY 复制文件（不会解压）rootfs.tar.gz
ENV  xxx=yyy环境变量(在启动容器时没有-e指定环境变量时默认用ENV环境变量)
ENTRYPOINT  容器启动后执行的命令（无法被替换，启容器的时候指定的命令，会被当成参数）

• dockerfile 例子：

  FROM scratch   #白手起家
  ADD centos7.tar.gz /
  CMD [“/bin/bash”,”init.sh”]

  完整的dockerfile构建过程：

  先手动构建镜像并测试成功
  基于历史命令编写dockerfile

[root@oldboy kod]# ls
default.conf  dockerfile  init.sh  kodexplorer4.37.zip

[root@oldboy kod]# cat dockerfile 
FROM centos:6.9   #基础镜像
RUN curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-6.repo && \
curl -o /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-6.repo  && \
yum install nginx php-fpm php-mbstring php-gd unzip -y

ADD kodexplorer4.37.zip /usr/share/nginx/html/  #ADD解压tar包，不解压zip包
WORKDIR  /usr/share/nginx/html/   #设置为工作目录
RUN unzip kodexplorer4.37.zip
RUN chmod -R 777 /usr/share/nginx/html/
VOLUME /usr/share/nginx/html/data   #把容器此目录挂载到默认/var/lib/docker/volumes/路径下

ENV SSH_PASS 123456      #实际并没有用到，演示写法，启动容器时没有-e指定变量时，默认为123456
ADD init.sh /init.sh
ADD default.conf /etc/nginx/conf.d/default.conf
EXPOSE 80     #开放80端口，启动时加-P参数
CMD ["/bin/bash","/init.sh"]   #初始命令

[root@oldboy kod]# cat init.sh 
#!/bin/bash
service php-fpm start
nginx -g 'daemon off;'

镜像层级关系

在编写dockerfile时，多次往里加入内容，文件之前内容没有变动的话就是基于原有镜像的叠加构建。此时速度很快，相当于走了缓存
如果文件之前内容发生变化，就会在变化位置起新的分层，走新的分支从而减低效率

查看镜像的构建历史

docker image history kod:v6

docker镜像的分层（相当于kvm 链接克隆，写时复制的特性）
镜像分层的好处：

复用,节省磁盘空间，相同的内容只需加载一份到内存。
修改dockerfile之后，再次构建速度快

容器间的互联

#--link 是单方向的！！！
    docker run -d -p 80:80 --name oldboy nginx
    docker run -it --link oldboy:web01 qstack/centos-ssh /bin/bash
                --link 所连接的容器名:起个别名 跟自己镜像   

使用docker运行zabbix-server

先上传镜像：

docker-mysql-5.7.tar.gz  zabbix-java-gateway.tar.gz  zabbix-web-nginx-mysql.tar.gz
zabbix-server-mysql.tar.gz

导入镜像：

[root@oldboy docker]# cat zabbix.sh
#!/bin/bash
for n in `ls *`
do 
docker load -i $n 
done

启动：

docker run --name mysql-server -t \
      -e MYSQL_DATABASE="zabbix" \
      -e MYSQL_USER="zabbix" \
      -e MYSQL_PASSWORD="zabbix_pwd" \
      -e MYSQL_ROOT_PASSWORD="root_pwd" \
      -d mysql:5.7 \
      --character-set-server=utf8 --collation-server=utf8_bin

docker run --name zabbix-java-gateway -t \
      -d zabbix/zabbix-java-gateway:latest

docker run --name zabbix-server-mysql -t \
      -e DB_SERVER_HOST="mysql-server" \
      -e MYSQL_DATABASE="zabbix" \
      -e MYSQL_USER="zabbix" \
      -e MYSQL_PASSWORD="zabbix_pwd" \
      -e MYSQL_ROOT_PASSWORD="root_pwd" \
      -e ZBX_JAVAGATEWAY="zabbix-java-gateway" \
      --link mysql-server:mysql \
      --link zabbix-java-gateway:zabbix-java-gateway \
      -p 10051:10051 \
      -d zabbix/zabbix-server-mysql:latest

docker run --name zabbix-web-nginx-mysql -t \
      -e DB_SERVER_HOST="mysql-server" \
      -e MYSQL_DATABASE="zabbix" \
      -e MYSQL_USER="zabbix" \
      -e MYSQL_PASSWORD="zabbix_pwd" \
      -e MYSQL_ROOT_PASSWORD="root_pwd" \
      --link mysql-server:mysql \
      --link zabbix-server-mysql:zabbix-server \
      -p 80:80 \
      -d zabbix/zabbix-web-nginx-mysql:latest

第三章 docker registry（私有仓库）

上传仓库包并导入到容器

[root@oldboy ~]# rz registry.tar.gz
[root@oldboy ~]# docker load -i registry.tar.gz

启动registry仓库

docker run -d -p 5000:5000 --restart=always --name registry -v /opt/myregistry:/var/lib/registry  registry
--restart=always #重启docker时让改容器也启动起来

上传镜像到私有仓库：

a:给镜像打标签

docker  tag centos6-sshd:v3 10.0.0.11:5000/centos6-sshd:v3

b:上传镜像

docker push 10.0.0.11:5000/centos6-sshd:v3

如果遇到报错：

The push refers to repository [10.0.0.11:5000/centos6.9_ssh]
Get https://10.0.0.11:5000/v2/: http: server gave HTTP response to HTTPS client

解决方法：

vim  /etc/docker/daemon.json
{
  "insecure-registries": ["10.0.0.11:5000"]
}
systemctl restart docker

在别的服务器上测试：

docker run -it 10.0.0.11:5000/nginx:latest /bin/bash  #如果遇到报错就用上面的解决方法`

带basic认证的registry仓库

yum install httpd-tools –y   #生成用户密码命令包
mkdir /opt/registry-var/auth/ -p
htpasswd  -Bbn oldboy 123456  >> /opt/registry-var/auth/htpasswd

docker run -d -p 5000:5000 -v /opt/registry-var/auth/:/auth/ -v /opt/myregistry:/var/lib/registry -e "REGISTRY_AUTH=htpasswd" -e "REGISTRY_AUTH_HTPASSWD_REALM=Registry Realm" -e  "REGISTRY_AUTH_HTPASSWD_PATH=/auth/htpasswd" registry 

登陆认证仓库：

docker login 10.0.0.11:5000

想要批量多主机实现仓库认证就直接把上面这个登录后的认证目录scp到其他主机即可

取出仓库内镜像名称及版本信息：

想查看仓库内镜像的各项信息则去宿主机-v挂载持久性的目录下查看/opt/myregistry

wget -O- -q  --user=oldboy --password=123456   http://10.0.0.11:5000/v2/_catalog|jq .repositories[]
wget -O- -q  --user=oldboy --password=123456   http://10.0.0.11:5000/v2/busybox/tags/list|jq .tags[]
jq ——处理json格式的输出效果

删除仓库内的镜像：

1.先进入到仓库容器中

Docker exec –it zen_northcutt /binbash   #容器名称是随机的，进入后能Tab出registry就对了

2.进入启动容器时-v指定的目录下/var/lib/registry rm –rf 删除掉没用的镜像，
3.再执行registry garbage-collect /etc/docker/registry/config.yml #垃圾回收

第4章 docker-compose(单机版的容器编排工具)

相当于ansible剧本

yum install -y python2-pip（需要epel源）
##pip 加速
pip install -i  https://pypi.tuna.tsinghua.edu.cn/simple docker-compose 
#安装
pip install docker-compose（默认pypi源在国外）

##详细指令

http://www.jianshu.com/p/2217cfed29d7
https://www.jianshu.com/p/748416621013

cd wordpress/
vi docker-compose.yml    #必须是这个名，讲究缩进
version: '3'              #版本

services:
   db:                 #给服务起个名字
     image: mysql:5.7    #指定镜像，本地没有的话就会尝试pull下来
     volumes:
       - db_data:/var/lib/mysql  #挂载目录,宿主机:容器路径
     restart: always        #跟随容器启动服务
     environment:           #定义变量值
       MYSQL_ROOT_PASSWORD: somewordpress
       MYSQL_DATABASE: wordpress
       MYSQL_USER: wordpress
       MYSQL_PASSWORD: wordpress

   wordpress:
     depends_on:   #依赖:只有db起来后才执行
       - db
     image: wordpress:latest
     volumes:
       - web_data:/var/www/html
     ports:   #暴露随机的80端口映射  也可以80:80指定端口映射
       - "80"
     restart: always
     environment:
       WORDPRESS_DB_HOST: db:3306  #db是上面的服务名会解析成IP地址
       WORDPRESS_DB_USER: wordpress
       WORDPRESS_DB_PASSWORD: wordpress
volumes:    #在宿主机上自动创建两个卷
    db_data:
    web_data:
默认卷存储路径：

#前台启动

docker-compose up

启动时自动创建一个以目录名命名的网络
#后台启动

docker-compose up -d

#起多个容器：

docker-compose scale wordpress=4

重启docker服务，容器全部退出的解决办法

方法一：

docker run  --restart=always  #重启后容器从新运行

方法二：

/etc/docker/daemon.json配置文件中加入 "live-restore": true  #重启后容器接着运行
docker server配置文件/etc/docker/daemon.json参考
{
 "registry-mirrors": ["http://b7a9017d.m.daocloud.io"],  #docker中国加速
 "insecure-registries":["10.0.0.11:5000"],
 "live-restore": true
}

第5章 Docker网络类型

四种网络类型：
启动容器时指定--network [选项]

none：不为容器配置任何网络功能，--net none
container：与另一个运行中的容器共享Network Namespace，--net container:[容器名或ID]（K8S）
host：与宿主机共享Network Namespace，不能和宿主机端口冲突。--net host
bridge：Docker设计的NAT网络模型 默认类型

5.1 Docker跨主机容器之间的通信macvlan

默认一个物理网卡，只有一个物理地址，虚拟多个mac地址

##创建macvlan网络

docker network ls  ——查看容器的网络使用类型
docker network create --driver macvlan --subnet 10.0.0.0/24 --gateway 10.0.0.254 -o parent=eth0 macvlan_1
#指定macvlan类型 指定网段 指定宿主机网关 跟宿主机的eth0网卡桥接  网络名称

##创建使用macvlan网络的容器

docker run -it --network macvlan_1 --ip=10.0.0.30  centos:6.9  /bin/bash

多个容器配置的IP不能相同
#配置成功后容器和宿主机是互通的，但是macvlan不能自己ping通自己的宿主机

5.2 Dcoker跨主机容器通信之overlay

http://www.cnblogs.com/CloudMan6/p/7270551.html

1）准备工作

每次自动分配IP都会记录到数据库中
consul：kv类型的存储数据库（key:value）

docker01、02上：

vim  /etc/docker/daemon.json
{
  "hosts":["tcp://0.0.0.0:2376","unix:///var/run/docker.sock"], #指定docker启动后监听2376端口，默认docker服务没有端口
  "cluster-store": "consul://10.0.0.11:8500",  #指定存储服务端主机及端口
  "cluster-advertise": "10.0.0.11:2376"  #指定节点信息，自己的IP端口
}

vim /usr/lib/systemd/system/docker.service
把-H fd:// 删掉
systemctl daemon-reload 
systemctl restart docker
docker01上：
docker run -d -p 8500:8500 -h consul --name consul progrium/consul -server -bootstrap
设置容器的主机名

浏览器访问8500端口

2）在11节点创建一个overlay网络

docker network create -d overlay --subnet 172.16.1.0/24 --gateway 172.16.1.254 ol1
#overlay为全局网络类型，主节点添加后，其他节点也会有

3）启动容器测试

docker run -it --network ol1 --name oldboy01  busybox /bin/bash

每个容器有两块网卡,eth0实现容器间的通讯,eth1实现容器访问外网

第6章 docker企业级镜像仓库harbor

第一步：安装docker和docker-compose
第二步：到github.com下载harbor-offline-installer-v1.3.0.tgz
第三步：上传到/opt,并解压
第四步：修改harbor.cfg配置文件
hostname = 10.0.0.11 #有域名就写域名
harbor_admin_password = 123456
第五步：进入harbor目录执行install.sh
第六步.进入浏览器访问，默认用户admin
创建项目scc推送镜像
docker tag SOURCE_IMAGE[:TAG] 10.0.0.11/scc/IMAGE[:TAG]
docker push 10.0.0.11/scc/IMAGE[:TAG] #下载不需要登录，上传需要登陆docker login 10.0.0.11

也可以实现主从高可用：

harbor配置远程pull镜像缓存服务: https://www.ilanni.com/?p=13492