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 容器技术的发展过程：

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  #创建桥接网卡的
  • 桥接网卡
[[email protected] ~]# 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

[[email protected] ~]# 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密码：
[[email protected] ~]# 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容器是一种轻量级、可移植、自包含的软件打包技术，使应用程序可以在几乎任何地方以相同的方式运行。开发人员在自己笔记本上创建并测试好的容器，无需任何修改就能够在生产系统的虚拟机、物理服务器或公有云主机上运行。

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 命令:

[[email protected] ~]# 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

[[email protected] ~]# 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：

[[email protected] 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"]         #有参数用逗号隔开

#自动构建镜像：

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

例2：

[[email protected] 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"]

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

[[email protected] 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

[[email protected] kod]# ls
default.conf  dockerfile  init.sh  kodexplorer4.37.zip

[[email protected] 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"]   #初始命令

[[email protected] 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

导入镜像：

[[email protected] 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（私有仓库）

上传仓库包并导入到容器

[[email protected] ~]# rz registry.tar.gz
[[email protected] ~]# 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

原文地址：https://blog.51cto.com/14210157/2403897

时间： 2024-11-05 18:55:05

docker容器从入门到精通的相关文章

Docker小白从入门到精通专栏上线咯！

各位51CTO的博友们.IT同仁们,你们好!我是吴光科老师,很高兴能够在这里和大家一起来交流IT技术,不知不觉在IT运维行业已经从事了近10年. 曾在国企.京东.宜信等一线互联网公司担任过Linux运维架构师.运维经理,51CTO学院Linux特级讲师,担任国内多家知名社区&运维专家网站Linux版主. 擅长系统高并发.超万台级别的服务器维护.服务器性能调优.企业安全运维.Openstack.Docker.KVM及Kubernetes云计算.自动化运维等核心技术领域.长期从事国企机关.图吧.宜信

docker容器从入门到实战0826

##docker容器安装和配置### #docker的git-hub网站(账号rshare,密rshare520):https://github.com/login #docker官网hub仓库(账号flyer520,密码rhsare520):https://hub.docker.com #docker官网文档和镜像:https://docs.docker.com/samples/centos/ #docker官网的容器网络配置:https://docs.docker.com/engine/us

docker容器从入门到实战0826（笔记整理）

##docker容器安装和配置### #docker的git-hub网站(账号rshare,密rshare520):https://github.com/login #docker官网hub仓库(账号flyer520,密码rhsare520):https://hub.docker.com #docker官网文档和镜像:https://docs.docker.com/samples/centos/ #docker官网的容器网络配置:https://docs.docker.com/engine/us

Docker容器技术入门

虚拟化与容器 虚拟化 主机级虚拟化 Type-I Type-II 容器级虚拟化 FreeBSD jail, 2000 Linux VServer, 2001 KVM and lxc Architecture LXC Linux Namespaces Namespaces UTS namespaces:主机名与域名 Mount namespaces:挂载点 IPC namespaces:信号量.消息队列和共享内存 PID namespaces:进程号 Network namespaces:网络设备

Docker从入门到精通系列(1)---第一个web应用

本文为minimicall原创文章,转载需注明出处:http://blog.csdn.net/minimicall 在继<阿里云部署Docker>之后,我决定系统的出一系列<Docker从入门到精通>的深度记录文章,这源于有一天图灵出版社的一个编辑联系我,问我有没有兴趣写Docker方面的书籍进行出版. 本文的目标是建立一个Docker web app.这样,你就可以直观的感受,docker是如何部署一个web应用. 首先,我们建立一个空目录来存放我们需要的文件. 我们建立的是一个

在线培训 | Docker容器部署与管理入门

容器技术凭借其轻量化和快速部署的特性,被越来越多企业开发者赞誉,近两年来发展态势可谓炙手可热. 去年一年,Kubernetes的流行度持续快速上升,我们有理由相信在不远的未来,Kubernetes将成为通用的基础设施标准. 开源的全栈化企业级容器管理平台Rancher,凭借优异的基础设施服务管理能力和强大的容器协调能力,让用户在生产环境中的容器部署.运行与管理工作变得更加简单.加上Rancher创造性的纳管来自不同基础架构的Kubernetes集群的能力,为企业在生产环境落地Docker与Kub

Docker容器部署与管理入门培训，你需要的前期准备都在这里！

容器技术凭借其轻量化和快速部署的特性,被越来越多企业开发者赞誉,近两年来发展态势可谓炙手可热. 去年一年,Kubernetes的流行度持续快速上升,我们有理由相信在不远的未来,Kubernetes将成为通用的基础设施标准. 开源的全栈化企业级容器管理平台Rancher,凭借优异的基础设施服务管理能力和强大的容器协调能力,让用户在生产环境中的容器部署.运行与管理工作变得更加简单.加上Rancher创造性的纳管来自不同基础架构的Kubernetes集群的能力,为企业在生产环境落地Docker与Kub

要入门URLOS应用开发 首先要了解docker容器的使用方法

URLOS本是基于docker容器运行,在入门URLOS开发之前,我们首先需要掌握docker的相关基础知识,本篇就以docker容器的基本使用方法为例,快速的让大家对docker有一个全面的印象. Docker简介 Docker 是一个开源的应用容器引擎,基于Go语言并遵从Apache2.0协议开源. Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级.可移植的容器中,然后发布到任何流行的 Linux 机器上,也可以实现虚拟化. 容器是完全使用沙箱机制,相互之间不会有任何接口(类似

云计算学习路线图课件：学Docker容器怎样快速入门？

"云计算"作为未来网络甚至未来计算机行业的发展趋势,得到了广泛重视.越来越多的人想通过学习云计算收获高薪,学习云计算的过程中会接触到Docker容器,这究竟是为什么?如何快速高效的学好Docker容器.进而学好云计算呢? docker就像一个集装箱一样,里面放着自己所需要的应用程序.docker内部使用的是Linux容器技术,并且提供一个完整的文件系统,独立的网络环境. docker 和vm虚拟机的主要区别在于,vm虚拟机启动之前需要制定好资源,例如CPU,内存,硬盘等,这会占用了一些