centos安装Docker与使用&&构建业务镜像挂载卷harbor仓库的高可用及网络模式和资源限制介绍

# 带指定版本号
docker search centos:7.2.1511 
# 不带版本号默认 latest
docker search centos

docker pull 仓库服务器:端口/项目名称/镜像名称:版本号

docker images

# 方法1
docker save centos -o /opt/centos.tar.gz
# 方法2
docker save centos > /opt/centos-1.tar.gz

tar xvf centos.tar.gz
cat manifest.json

docker load < /opt/centos.tar.gz

删除镜像

docker rmi centos

docker rm 容器 ID/容器名称

docker [OPTIONS] COMMAND

[COMMAND]
attach      此方式进入容器的操作都是同步显示的且 exit 后容器将被关闭
build       从Dockerfile构建一个镜像
commit      从容器的更改中创建一个新镜像
cp          在容器和本地文件系统之间复制文件/文件夹
create      创建新容器
diff        检查容器文件系统上文件或目录的更改
events      从服务器获取实时事件
exec        在运行的容器中运行命令
export      将容器的文件系统导出为tar包
history     显示镜像的历史
images      列出镜像
import      从tarball导入内容以创建文件系统镜像
info        显示整个系统的信息
inspect     返回Docker对象的底层信息
kill        停止一个或多个正在运行的容器
load        从tar包或标准输出加载镜像
login       Log in to a Docker registry
logout      Log out from a Docker registry
logs        获取容器的日志
pause       暂停一个或多个容器中的所有进程
port        列出容器的端口映射或特定映射
ps          列出正在运行的容器
pull        下载镜像
push        上传镜像
rename      重命令一个容器
restart     重启容器
rm          移除一个或多个容器
rmi         移除一个或多个镜像
run         在新容器中运行命令
save        将一个或多个图像保存到tar存档文件(默认情况下流到STDOUT)
search      在Docker仓库中搜索镜像
start       启动一个或多个处在停止状态的容器
stats       显示容器资源使用统计数据的实时流
stop        停止一个或多个正在运行的容器
tag         Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE
top         显示容器的运行进程
unpause     Unpause all processes within one or more containers
update      Update configuration of one or more containers
version     查看版本
wait        阻塞直到一个或多个容器停止，然后打印它们的退出代码

docker COMMAND --help
退出容器不注销：Ctrl + P + Q

docker run [选项] 镜像名 [shell 命令] [参数...]

-p list           指定容器的端口发布到主机
-P                将所有公开的端口发布到随机端口
--name string     为容器分配一个名称
-d                在后台运行容器并打印容器ID
-it               创建并进入容器
--rm              当容器退出时自动删除它

例如：

#docker run [镜像名] [shell 命令]
docker run centos /bin/echo 'hello wold'

docker run -it /centos bash

docker run -P /nginx

docker run -p 81:80 --name "nginx-test" nginx

方式 2：本地 IP:本地端口:容器端口

docker run -p 192.168.10.205:82:80 --name "nginx-test" /nginx

方式 3：本地 IP:本地随机端口:容器端口

docker run -p 192.168.10.205::80 --name "nginx-test" /nginx

方式 4：本机 ip:本地端口:容器端口/协议，默认为 tcp 协议

docker run -p 192.168.10.205:83:80/udp --name "nginx-test" /nginx

方式 5：一次性映射多个端口+协议：

docker run -p 86:80/tcp -p 443:443/tcp -p 53:53/udp --name "nginx-test" /nginx

5. 后台启动容器

docker run -d -P --name "nginx-test" /nginx

docker run -it --rm --name nginx-test /nginx

docker run -it --rm --dns 223.6.6.6 centos bash

docker ps [OPTIONS]

-a              显示所有容器(默认显示正在运行)
-f              根据提供的条件过滤输出
-n int          显示最后创建的n个容器(包括所有状态)(默认值-1)
-l              显示最新创建的容器(包括所有状态)
--no-trunc      不截断输出
-q              只显示数字id
-s              显示总文件大小

例：

docker ps

docker ps -a

docker rm [OPTIONS] CONTAINER [CONTAINER...]

-f        强制移除正在运行的容器(使用SIGKILL)
-l        删除指定链接
-v        删除与容器关联的卷

例：

docker rm -f 11445b3a84d3   # 11445b3a84d3是CONTAINER ID，通过docker ps 查询

docker rm -f `docker ps -aq -f status=exited`

docker rm -f $(docker ps -a -q)

docker logs [OPTIONS] CONTAINER

--details         显示提供给日志的额外细节
-f                跟踪日志输出
--since string    显示从时间戳开始的日志(如：42m表示42 分钟)
--tail string     从日志末尾显示的行数(默认为“all”)
-t                显示时间戳
--until string    在时间戳前显示日志(如：42m表示42 分钟)

例：

docker logs nginx-test-port3 #一次查看
docker logs -f nginx-test-port3 #持续查看

docker load [OPTIONS]

-i string   从tar存档文件中读取，而不是从STDIN中读取
-q          不输出

例：

docker load -i nginx.tar.gz

docker port CONTAINER [PRIVATE_PORT[/PROTO]]

docker port nginx-test

docker stop [OPTIONS] CONTAINER [CONTAINER...]

-t  int   等待stop几秒钟后再杀死它(默认为10)

例：

docker stop f821d0cd5a99

docker stop $(docker ps -a -q)

docker kill [OPTIONS] CONTAINER [CONTAINER...]

-s  string   发送到容器的信号(默认为“KILL”)

例：

docker kill $(docker ps -a -q)

docker start [OPTIONS] CONTAINER [CONTAINER...]

-a                      附加STDOUT/STDERR和转发信号
--detach-keys string    覆盖用于分离容器的键序列
-i                      将容器的STDIN

例：

docker start f821d0cd5a99

docker attach [OPTIONS] CONTAINER

--detach-keys string   覆盖用于分离容器的键序列
--no-stdin             不附加STDIN
--sig-proxy            代理所有接收到的进程信号(默认为true)

例：

docker attach 63fbc2d5a3ec

docker exec [OPTIONS] CONTAINER COMMAND [ARG...]

-d                        分离模式:在后台运行命令
--detach-keys string      覆盖用于分离容器的键序列
-e list                   设置环境变量
-i                        保持STDIN打开，即使没有连接
--privileged              为该命令授予扩展特权
-t                        分配一个pseudo-TTY
-u  string                用户名或UID(格式:< name| UID >[:<group|gid>])
-w  string                容器内的工作目录

docker exec -it centos-test /bin/bash

docker inspect [OPTIONS] NAME|ID ...

-f  string   使用给定的Go模板格式化输出

例：

# docker inspect -f "{{.State.Pid}}" centos-test3
5892

docker commit [OPTIONS] CONTAINER [REPOSITORY[:TAG]]

-a  string      作者
-c  list        对创建的映像应用Dockerfile指令
-m  string      提交消息
-p              提交期间暂停容器(默认为true)

例：

docker commit -a "chen" -m "nginx_yum_v1" --change="EXPOSE_80_443" f5f8c13d0f9f centos-nginx:v1

docker commit -m "nginx image" f5f8c13d0f9f jack/centos-nginx:v1

Docker 镜像与制作

Docker 镜像有没有内核？
从镜像大小上面来说，一个比较小的镜像只有十几 MB，而内核文件需要一百多兆，因此镜像里面是没有内核的，镜像在被启动为容器后将直接使用宿主机的内核，而镜像本身则只提供相应的 rootfs，即系统正常运行所必须的用户空间的文件系统，比如/dev/， /proc， /bin， /etc 等目录，所以容器当中基本是没有/boot目录的，而/boot 当中保存的就是与内核相关的文件和目录。

为什么没有内核？
由于容器启动和运行过程中是直接使用了宿主机的内核，所以没有直接调用过物理硬件，所以也不会涉及到硬件驱动，因此也用不上内核和驱动，另外有内核的那是虚拟机。

手动制作nginx镜像

Docker 制作类似于虚拟机的镜像制作，即按照公司的实际业务务求将需要安装的软件、相关配置等基础环境配置完成，然后将其做成镜像，最后再批量从镜像批量生产实例，这样可以极大的简化相同环境的部署工作， Docker 的镜像制作分为手动制作和自动制作(基于 DockerFile)，企业通常都是基于 Dockerfile 制作精细，其中手动制作镜像步骤具体如下：

下载镜像并初始化系统：
基于某个基础镜像之上重新制作，因此需要先有一个基础镜像，本次使用官方提供的 centos 镜像为基础：

1. docker下载centos镜像，并运行进入

进入容器

进入容器后，更改yun源

yum安装nginx与常用工具

修改nginx配置，关闭后台运行

退出容器

5. 提交为镜像：在宿主机基于容器 ID 提交为镜像

带 tag 的镜像提交：
提交的时候标记 tag 号：
标记 tag 号，生产当中比较常用，后期可以根据 tag 标记创建不同版本的镜像以及创建不同版本的容器。

docker image ls

7. 从自己镜像启动容器，因为本机用的是云主机，没有备案和域名，所以使用4433端口映射

8. 访问测试

容器端口映射成功

Dockerfile介绍

DockerFile 可以说是一种可以被 Docker 程序解释的脚本， DockerFile 是由一条条的命令组成的，每条命令对应 linux 下面的一条命令， Docker 程序将这些DockerFile 指令再翻译成真正的 linux 命令，其有自己的书写方式和支持的命令， Docker 程序读取 DockerFile 并根据指令生成 Docker 镜像，相比手动制作镜像的方式， DockerFile 更能直观的展示镜像是怎么产生的，有了 DockerFile，当后期有额外的需求时，只要在之前的 DockerFile 添加或者修改响应的命令即可重新生成新的 Docke 镜像，避免了重复手动制作镜像的麻烦。

FROM 指定基础镜像

定制镜像，需要先有一个基础镜像，在这个基础镜像上进行定制。FROM 就是指定基础镜像，必需放在有效指令的第一行

怎么选择合适的镜像呢？官方有nginx、redis、mysql、httpd、tomcat等服务类的镜像，也有操作系统类，如：centos、ubuntu、debian等。

例：

MAINTAINER 指定维护者信息

格式

RUN 执行命令

RUN 指令是用来执行命令的。shell命令功能丰富，所以RUN 指令经常用来调用shell指令。

格式

第一种不用多说，第二种方式：RUN ["/bin/bash", "-c", "echo hello world"]
Dockerfile中，每一个指令都会创建一层镜像，RUN写多了，创建的镜像层数就会增多，所以一般RUN 指令的写法为

CMD 启动容器时执行的命令

指定启动容器时执行的命令，每个 Dockerfile 只能有一条 CMD 命令。如果指定了多条命令，只有最后一条会被执行。

支持三种格式

如果用户启动容器时候指定了运行的命令，则会覆盖掉 CMD 指定的命令。

EXPOSE 分配端口号

告诉 Docker 服务端容器暴露的端口号，供互联系统使用。在启动容器时需要通过 -P，Docker 主机会自动分配一个端口转发到指定的端口

格式

ENV 环境变量

指定一个环境变量，会被后续 RUN 指令使用，并在容器运行时保持。

格式

ADD 复制/解压

该命令将复制指定的 <src> 到容器中的 <dest>。其中<src> 可以是Dockerfile所在目录的一个相对路径；也可以是一个 URL；还可以是一个 tar 文件（自动解压为目录）

格式

COPY 复制

复制本地主机的 <src>（为 Dockerfile 所在目录的相对路径）到容器中的 <dest>

格式

当使用本地目录为源目录时，推荐使用 COPY

ENTRYPOINT 容器启动后执行的命令

配置容器启动后执行的命令，并且不可被 docker run 提供的参数覆盖。

两种格式：

每个 Dockerfile 中只能有一个 ENTRYPOINT，当指定多个时，只有最后一个起效

VOLUME 挂载点

创建一个可以从本地主机或其他容器挂载的挂载点，一般用来存放数据库和需要保持的数据等

格式

USER 指定用户名

指定运行容器时的用户名或 UID，后续的 RUN 也会使用指定用户

格式

例如：

要临时获取管理员权限可以使用 gosu，而不推荐 sudo。

WORKDIR 工作目录

为后续的 RUN、CMD、ENTRYPOINT 指令配置工作目录

格式

ONBUILD

配置当所创建的镜像作为其它新创建镜像的基础镜像时，所执行的操作指令。

格式

使用 ONBUILD 指令的镜像，推荐在标签中注明，例如 ruby:1.9-onbuild

构建镜像

格式

构建时，目录内除了构建所需要的文件，不要有其它文件

mkdir -pv /opt/dockerfile/web/nginx

vim /opt/dockerfile/web/nginx/Dockerfile
#Nginx web image

FROM centos:latest

RUN yum install epel-release -y
RUN yum install nginx -y && rm -rf /usr/share/nginx/html/*
ADD html.tar.gz /usr/share/nginx/html/
#copy 

EXPOSE 80 443 8080

CMD ["/usr/sbin/nginx","-g","daemon off;"]

vi /opt/dockerfile/web/nginx/index.html

<h1> docker nginx test, nginx container by dockerfile</h1>

tar czvf html.tar.gz index.html

docker build -t chenjb/centos-nginx /opt/dockerfile/web/nginx/

docker images

docker run -it -d -p 80:80 --name "nginx-test" chenjb/centos-nginx

docker ps

# curl 127.0.0.1:8355
<h1> docker nginx test, nginx container by dockerfile</h1>

DockerFile 制作编译版 nginx 镜像：

下载镜像并初始化系统：

目录结构按照业务类型或系统类型等方式划分，方便后期镜像比较多的时候进行分类

编写 Dockerfile：

生成的镜像的时候会在执行命令的当前目录查找 Dockerfile 文件，所以名称不可写错，而且 D 必须大写
My Dockerfile
"#"为注释，等于 shell 脚本的中#
除了注释行之外的第一行，必须是 From xxx (xxx 是基础镜像)

准备源码包与配置文件：

配置nginx文件，并关闭后台运行添加配置 daemon off

nginx 源码包

执行镜像构建

4. 开始构建：可以清晰看到各个步骤执行的具体操作

构建成功了

5. 查看是否生成本地镜像，如果构建时出错可能会导致生成名字为none的镜像，使用命令删除即可

6. 从镜像启动容器

 docker run -d -p 80:80 --name mak1e-nginx peterhx/nginx-make-1.16.1:v1  /usr/sbin/nginx

访问 web 界面

制作 tomcat 镜像：

基于官方提供的 centos 7.6. 基础镜像构建 JDK 和 tomcat 镜像，先构建 JDK 镜像，然后再基于 JDK 镜像构建 tomcat 镜像。

1、先构建 JDK 镜像

下载基础镜像 Centos：

执行构建 JDK 镜像：

编辑Dockerfile

# JDK Base Images
FROM centos:latest

ADD jdk-8u212-linux-x64.tar.gz /usr/local/src/
RUN ln -sv /usr/local/src/jdk1.8.0_212 /usr/local/jdk
ADD profile /etc/profile
ENV JAVA_HOME /usr/local/jdk
ENV JRE_HOME $JAVA_HOME/jre
ENV CLASSPATH $JAVA_HOME/lib/:$JRE_HOME/lib/
ENV PATH $PATH:$JAVA_HOME/bin

RUN rm -rf /etc/localtime       && ln -snf /usr/share/zoneinfo/Asia/Shanghai/etc/localtime       && echo "Asia/Shanghai" > /etc/timezone

上传 JDK 压缩包和 profile 文件：
将 JDK 压缩包上传到 Dockerfile 当前目录，然后执行构建：

profile文件内容，（最下边声明的环境变量，其他的一样）

# cat profile
###########################

# System wide environment and startup programs, for login setup
# Functions and aliases go in /etc/bashrc

# It's NOT a good idea to change this file unless you know what you
# are doing. It's much better to create a custom.sh shell script in
# /etc/profile.d/ to make custom changes to your environment, as this
# will prevent the need for merging in future updates.

pathmunge () {
    case ":${PATH}:" in
        *:"$1":*)
            ;;
        *)
            if [ "$2" = "after" ] ; then
                PATH=$PATH:$1
            else
                PATH=$1:$PATH
            fi
    esac
}


if [ -x /usr/bin/id ]; then
    if [ -z "$EUID" ]; then
        # ksh workaround
        EUID=`/usr/bin/id -u`
        UID=`/usr/bin/id -ru`
    fi
    USER="`/usr/bin/id -un`"
    LOGNAME=$USER
    MAIL="/var/spool/mail/$USER"
fi

# Path manipulation
if [ "$EUID" = "0" ]; then
    pathmunge /usr/sbin
    pathmunge /usr/local/sbin
else
    pathmunge /usr/local/sbin after
    pathmunge /usr/sbin after
fi

HOSTNAME=`/usr/bin/hostname 2>/dev/null`
HISTSIZE=1000
if [ "$HISTCONTROL" = "ignorespace" ] ; then
    export HISTCONTROL=ignoreboth
else
    export HISTCONTROL=ignoredups
fi

export PATH USER LOGNAME MAIL HOSTNAME HISTSIZE HISTCONTROL

# By default, we want umask to get set. This sets it for login shell
# Current threshold for system reserved uid/gids is 200
# You could check uidgid reservation validity in
# /usr/share/doc/setup-*/uidgid file
if [ $UID -gt 199 ] && [ "`/usr/bin/id -gn`" = "`/usr/bin/id -un`" ]; then
    umask 002
else
    umask 022
fi

for i in /etc/profile.d/*.sh /etc/profile.d/sh.local ; do
    if [ -r "$i" ]; then
        if [ "${-#*i}" != "$-" ]; then 
            . "$i"
        else
            . "$i" >/dev/null
        fi
    fi
done

unset i
unset -f pathmunge

export JAVA_HOME=/usr/local/jdk
export TOMCAT_HOME=/apps/tomcat
export PATH=$JAVA_HOME/bin:$JAVA_HOME/jre/bin:$TOMCAT_HOME/bin:$PATH
export CLASSPATH=.$CLASSPATH:$JAVA_HOME/lib:$JAVA_HOME/jre/lib:$JAVA_HOME/lib/tools.jar

执行构建

cat build-command.sh 
#!/bin/bash
docker build -t centos-jdk1.8:v1 .

2、从 JDK 镜像构建 tomcat-8 镜像

编辑Dockerfile文件

上传 tomcat 压缩包：apache-tomcat-8.5.42.tar.gz
通过脚本构建 tomcat 基础镜像

# cat build-command.sh 
#!/bin/bash
docker build -t tomcat85:v1 .

验证镜像构建完成

构建业务镜像 app1：

准备 Dockerfile：

准备自定义 myapp 页面：

准备容器启动执行脚本：

 vim run_tomcat.sh

#!/bin/bash
echo "10.10.10.10 tom.test.com" >> /etc/hosts
echo "nameserver 223.5.5.5" > /etc/resolv.conf
su - www -c "/apps/tomcat/bin/catalina.sh start"
su - www -c "tail -f /etc/hosts"

运行命令或执行脚本构建Tomcat-app1镜像

 cat build-command.sh 
#!/bin/bash
docker build -t tomcat85-app1:v1 .

查看镜像

从镜像启动容器测试：

制作 haproxy 镜像：

准备 Dockerfile：

准备 haproxy 源码文件:haproxy-2.0.5.tar.gz
准备run_haproxy.sh脚本

准备 haproxy 配置文件：

6. 准备构建脚本：

7. 从镜像启动容器：

本地镜像上传至官方 docker 仓库：

将自制的镜像上传至 docker 仓库； https://hub./

准备账户：
登录到 docker hub 创建官网创建账户，登录后点击 settings 完善账户信息,填写账户基本信息
在虚拟机使用自己的账号登录

查看认证信息：
#登录成功之后会在当前目录生成一个隐藏文件用于保存登录认证信息

[root@Server1 ~]# cat /root/.docker/config.json
{
    "auths": {
        "https://index./v1/": {
            "auth": "cGV0ZXJoeDo5NjExMjFoeC4="
        },
        "registry.cn-beijing.aliyuncs.com": {
            "auth": "NTgzMzQzNjM2QHFxLmNvbTo5NjExMjFoeA=="
        }
    },
    "HttpHeaders": {
        "User-Agent": "Docker-Client/19.03.8 (linux)"
    }
}

查看镜像 ID

根据规定的格式给镜像修改tag版本号并上传到docker仓库中

docker tag a187dde48cd2 peterhx/alpine-test:alpine123
docker push peterhx/alpine-test:alpine123

上传完成

7. 到 docker 官网验证

8. 更换到其他 docker 服务器下载镜像

从镜像启动一个容器

docker 仓库之分布式 Harbor

Harbor 是一个用于存储和分发 Docker 镜像的企业级 Registry 服务器,由vmware 开源，其通过添加一些企业必需的功能特性，例如安全、标识和管理等，扩展了开源 Docker Distribution。作为一个企业级私有 Registry 服务器，Harbor 提供了更好的性能和安全。提升用户使用 Registry 构建和运行环境传输镜像的效率。 Harbor 支持安装在多个 Registry 节点的镜像资源复制，镜像全部保存在私有 Registry 中，确保数据和知识产权在公司内部网络中管控，另外，Harbor 也提供了高级的安全特性，诸如用户管理，访问控制和活动审计等。

官网地址： https://vmware./harbor/cn/，
官方 github 地址：https://github.com/vmware/harbor

Harbor 功能官方介绍：

基于角色的访问控制：用户与 Docker 镜像仓库通过“项目”进行组织管理，一个用户可以对多个镜像仓库在同一命名空间（project）里有不同的权限。镜像复制：镜像可以在多个 Registry 实例中复制（同步）。尤其适合于负载均衡，高可用，混合云和多云的场景。图形化用户界面：用户可以通过浏览器来浏览，检索当前 Docker 镜像仓库，管理项目和命名空间。

AD/LDAP： Harbor 可以集成企业内部已有的 AD/LDAP，用于鉴权认证管理。

审计管理：所有针对镜像仓库的操作都可以被记录追溯，用于审计管理。国际化：已拥有英文、中文、德文、日文和俄文的本地化版本。更多的语言将会添加进来。RESTful API - RESTful API ：提供给管理员对于 Harbor 更多的操控, 使得与其它管理软件集成变得更容易。

部署简单：提供在线和离线两种安装工具，也可以安装到 vSphere 平台(OVA 方式)虚拟设备。

安装 Harbor：

下载地址：
https://github.com/goharbor/harbor/releases

安装文档：
https://github.com/vmware/harbor/blob/master/docs/installation_guide.md

本次使用 harbor 版本 1.2.2 离线安装包，具体名称为 harbor-offline-installer-v1.7.5.tgz

下载 Harbor 安装包：

方式1：下载离线安装包：https://github.com/goharbor/harbor/releases

方式2：下载在线安装包

配置安装 Harbor：

在另一台云主机的机器（内网IP为：192.168.0.59）上安装harbor仓库

解压

下载docker-compose

安装docker-compose时报错，缺少依赖及python的开发环境，yum install -y gcc python-devel 即可

修改harbor的配置文件，最终配置如下，只修改前两个即可，其余的根据需要修改

docker-compose.yml 文件，用于配置数据目录等配置信息

5. 运行当前目录下的脚本开始安装

后期修改配置：

如果 harbor 运行一段时间之后需要更改配置，则步骤如下：这里顺便修改一下harbor仓库的访问的默认端口
1. 先停止 harbor：

2. 编辑 harbor.cfg 进行相关配置：（修改之前一定要记得先copy一份）

① 这里修改了两个端口 80改为888，443改为了4433

② 修改完之后还要修改一个文件

# pwd
/usr/local/harbor/common/templates/registry
[root@Server2 registry]# ls
config.yml  config.yml.bak  root.crt
[root@Server2 registry]# vim config.yml

url后加上修改后的默认端口，保存退出

③ 修改docker的启动文件

#vim /usr/lib/systemd/system/docker.service  修改如下一行
ExecStart=/usr/bin/dockerd --insecure-registry=x.x.x.x:888

修改后重新加载并重启服务

systemctl daemon-reload && systemctl restart docker.service

3. prepare

登录测试一下，登录成功

常见的2个报错信息解答：

（1）Error response from daemon: Get https://192.168.0.59/v1/users/: dial tcp 192.168.0.59:443: getsockopt: connection refused

（2）Error response from daemon: Get https://192.168.0.59:888/v1/users/: http: server gave HTTP response to HTTPS client

报这2个错误的都是如下2个原因：

1、是端口错了！

2、未在docker启动文件中添加--insecure-registry信任关系！

大多数这个错误是第2个原因，因为你没有添加信任关系的话，docker默认使用的是https协议，所以端口不对(443)，会报连接拒绝这个错误；

或者提示你 "服务器给HTTPS端的是HTTP响应" 这个错误，因为你没添加端口信任，服务器认为这是默认的https访问，返回的却是http数据！

解决方法：

正确的添加信任关系包括端口号：

--insecure-registry=192.168.0.59:888

一定要把主机与端口同时添加进去！

继续

查看本地的镜像

2. 查看本地端口

3. web 浏览器访问 Harbor 管理界面

如果可以正常登录就说明之前的配置没毛病，下面就可上传镜像了

配置 docker 使用 harbor 仓库上传下载镜像：

编辑 docker 配置文件：
注意：如果我们配置的是 https 的话，本地 docker 就不需要有任何操作就可以访问 harbor 了，在第一台主机的docker启动文件中也添加上内网harbor仓库的地址

在ExecStart追加

重启 docker 服务：

验证能否登录 harbor：

从server1导入一个小镜像，

验证镜像导入成功（至少要有个镜像，没有的话按照上面导入）

镜像打 tag：
> 修改 images 的名称，不修改成指定格式无法将镜像上传到 harbor 仓库，格式为: HarborIP/项目名/image 名字:版本号：

首先要新建一个项目，进入项目里，右侧推送镜像，按照指定格式进行修改才能上传到此项目中来

查看镜像

docker images

修改镜像的tag号因为使用的端口不一样，如果是443端口就不需要带端口号，不过目前也还没有配置加密证书所以还得带着端口号才可以

docker tag alpine:latest X.X.X.X:888/alpine/alpine-test2:v4

将镜像 push 到 harbor：因为默认上传时使用加密的传输方式也就是https，这里因为修改了端口所以有些区别

格式为： docker push 镜像名:版本

push 完成
harbor 界面验证镜像上传成功
验证镜像信息

从 harbor 下载镜像并启动容器：

更改 docker 配置文件：
目前凡是需要从 harbor 镜像服务器下载 image 的 docker 服务都要更改，不更改的话无法下载：

重启 docker：

3. 查看下载命令：

执行下载：

验证镜像下载完成

启动容器：

7. 成功启动，并可以正常使用

实现 harbor 高可用：

Harbor 支持基于策略的 Docker 镜像复制功能，这类似于 MySQL 的主从同步，其可以实现不同的数据中心、不同的运行环境之间同步镜像，并提供友好的管理界面，大大简化了实际运维中的镜像管理工作，已经有用很多互联网公司使用harbor 搭建内网 docker 仓库的案例，并且还有实现了双向复制的案列，本文将实现单向复制的部署：
1. 新部署一台 harbor2 服务器192.168.0.36
过程见前一节

验证从 harbor 登录，harbor2

主 harbor :192.168.0.59

复制的原理是从源harbor上推到目标harbor，所以下面的配置是要在之前创建的harbor上配置。
主harbor：192.168.0.59
从harbor：192.168.0.36

主 harbor:创建目标
主 harbor:测试连接成功后，确定

从 harbor2:创建一个 alpine 项目：
与主 harbor1 项目名称保持一致：
主 harbor:配置复制
主 harbor:点击复制,新建规则：
主 harbor:编辑同步策略
主 harbor:查看镜像同步状态
从 harbor:查看镜像是否同步成功

测试从 harbor 镜像下载和容器启动：

编辑 docker 配置文件：

vim /lib/systemd/system/docker.service

在ExecStart追加

其中 192.168.0.36/59 是我们部署 Harbor 的地址，即 hostname 配置项值。配置完后需要重启 docker 服务。

重启 docker 服务：

从 harbor 项目设置为公开：
docker 客户端下载镜像

docker 客户端从镜像启动容器：

docker run -it 192.168.0.36:888/alpine/alpine111:v10 sh

 如果可以从新harbor2上拉取镜像并运行，就说明harbor已经高可用且同步成功

至此，高可用模式的 harbor 仓库部署完毕

Docker 数据管理

如果运行中的容器修如果生成了新的数据或者修改了现有的一个已经存在的文件内容，那么新产生的数据将会被复制到读写层进行持久化保存，这个读写层也就是容器的工作目录，此即“写时复制(COW) copy on write”机制
在这里插入图片描述

数据类型：

Docker 的镜像是分层设计的，底层是只读的，通过镜像启动的容器添加了一层可读写的文件系统，用户写入的数据都保存在这一层当中，如果要将写入的数据永久生效，需要将其提交为一个镜像然后通过这个镜像在启动实例，然后就会给这个启动的实例添加一层可读写的文件系统，目前 Docker 的数据类型分为两种，一是数据卷，二是数据容器，数据卷类似于挂载的一块磁盘，数据容器是将数据保存在一个容器上
在这里插入图片描述

查看指定 PID 的容器信息

在这里插入图片描述

LowerDir： image 镜像层(镜像本身，只读)
UpperDir：容器的上层(读写)
MergedDir：容器的文件系统，使用 Union FS（联合文件系统）将 lowerdir 和
WorkDir：容器在宿主机的工作目录

什么是数据卷(data volume)：

数据卷实际上就是宿主机上的目录或者是文件，可以被直接 mount 到容器当中使用。

实际生成环境中，需要针对不同类型的服务、不同类型的数据存储要求做相应的规划，最终保证服务的可扩展性、稳定性以及数据的安全性。

如下图：
在这里插入图片描述

左侧是无状态的 http 请求服务，右侧为有状态。
下层为不需要存储的服务，上层为需要存储的部分服务

创建 APP 目录并生成 web 页面：

此 app 以数据卷的方式，提供给容器使用，比如容器可以直接宿主机本地的 web_app，而需要将代码提前添加到容器中，此方式适用于小型 web 站点。

在宿主机或容器修改数据

mkdir /data/app
echo "docker volume Pages1" > /data/app/index.html

启动容器并验证数据：

启动两个容器， web1 容器和 web2 容器，分别测试能否在容器内访问到宿主机的添加的数据。
注意使用 -v 参数，将宿主机目录映射到容器内部， web2 的 ro 标示在容器内对该目录只读，默认是可读写的：

数据卷的特点及使用：

1、数据卷是宿主机的目录或者文件，并且可以在多个容器之间共同使用。
2、在宿主机对数据卷更改数据后会在所有容器里面会立即更新。
3、数据卷的数据可以持久保存，即使删除使用使用该容器卷的容器也不影响。
4、在容器里面的写入数据不会影响到镜像本身。

文件挂载：
文件挂载用于很少更改文件内容的场景，比如 nginx 的配置文件、 tomcat 的配置文件等

数据卷使用场景：
1、日志输出
2、静态 web 页面
3、应用配置文件
4、多容器间目录或文件共享

如何一次挂载多个目录

启动容器

数据卷容器：

数据卷容器功能是可以让数据在多个 docker 容器之间共享，即可以让 B 容器访问 A 容器的内容，而容器 C 也可以访问 A 容器的内容，\

即先要创建一个后台运行的容器作为 Server，用于卷提供，这个卷可以为其他容器提供数据存储服务，其他使用此卷的容器作为 client 端：

启动一个卷容器 Server：

先启动一个容器，并挂载宿主机的数据目录：
将宿主机的 catalina.sh 启动脚本和 chen 的 web 页面，分别挂载到卷容器 server端，然后通过 server 端共享给 client 端使用。

启动两个端容器 Client

其实实质就是把挂载在其它容器的卷，再挂到其它容器上

测试访问 web 页面

三个容器访问到的数据是一样的

进入其它一个容器，修改网站的默认测试页面

5. 验证宿主机数据

关闭卷容器 Server 测试能否启动新容器：

停止了卷服务的容器，还可以从这个卷服务容器启动新的容器

测试删除源卷容器 Server 创建容器

测试之前的容器是否正常——已经运行的容器不受任何影响
之前已启动的容器不受影响

重新创建容器卷 Server

创建出 volume server 之后，就可以创建基于 volume server 的新容器。

在当前环境下，即使把提供卷的容器 Server 删除，已经运行的容器 Client 依然可以使用挂载的卷，因为容器是通过挂载访问数据的，但是无法创建新的卷容器客户端，但是再把卷容器 Server 创建后即可正常创建卷容器 Client，

此方式可以用于线上共享数据目录等环境，因为即使数据卷容器被删除了，其他已经运行的容器依然可以挂载使用

数据卷容器可以作为共享的方式为其他容器提供文件共享，类似于 NFS 共享，可以在生产中启动一个实例挂载本地的目录，然后其他的容器分别挂载此容器的目录，即可保证各容器之间的数据一致性。

十五：

主要介绍docker网络相关知识，docker服务安装完成之后，至少在每个主机机会生成一个名称为docker0的网卡
其IP地址都是172.17.0.1/16，并且会生成某种不同类型的网络，如下图：

docker结合负载实现网站高可用：

整体规划图：
下图为一个小型的网络架构图，其中nginx使用docker运行
在这里插入图片描述

服务器名	系统	ip
服务器1	centos 7.6	192.168.99.101
服务器2	centos 7.6	192.168.99.102
码头工人1	Ubuntu的04.04	192.168.99.22
码头工人2	Ubuntu的04.04	192.168.99.23

1.安装并配置keepalived

Server1安装

启动

Server2安装

配置

启动

2.安装并配置haproxy

各服务器配置内核参数

Server1配置haproxy

Server2配置haproxy

3. docker服务器启动nginx容器并验证

dcoekr1启动Nginx容器
docker1：192.168.99.22

# 先下载nginx镜像

docker pull nginx
docker run --name nginx-web1 -d -p 81:80 nginx

验证网络访问
在这里插入图片描述

docker2启动nginx容器
docker2：192.168.99.23

# 先下载nginx镜像

docker pull nginx
docker run --name nginx-web1 -d -p 81:80 nginx

验证网络访问
在这里插入图片描述

访问VIP
Server1 haproxy状态页面：192.168.99.101：9999 / haproxy-status
Server2 haproxy状态页面：192.168.99.102：9999 / haproxy-status

容器之间的互联

通过容器名称互联：

即在同一个主机上的容器之间可以通过自定义的容器名称相互访问，某个业务前端静态页面是使用nginx，动态页面使用的是tomcat，由于容器在启动的时候其内部IP地址是DHCP随机分配的，所以如果通过内部访问的话，自定义名称是相对比较固定的，因此比较适用于此场景。

先创建第一个容器，后续会使用到这个容器的名称：

查看当前主机文件内容

[root@Server1 ~]# docker exec -it app1 bash
root@260fea18537b:/# cat /etc/hosts
127.0.0.1    localhost
::1    localhost ip6-localhost ip6-loopback
fe00::0    ip6-localnet
ff00::0    ip6-mcastprefix
ff02::1    ip6-allnodes
ff02::2    ip6-allrouters
172.17.0.2    260fea18537b

创建第二个容器

查看第二个容器的主机文件内容

检测通信

ping app1

可能需要先安装ping工具

通过自定义容器别名互联：

上一步骤中，自定义的容器名称可能后期会发生变化，那么一旦名称发生变化，程序之间也要随之发生变化，此类程序通过容器名称进行服务调用，但是容器名称发生变化之后再使用之前的名称肯定是无法成功调用，每次都进行更改的话又比较麻烦，因此可以使用自定义别名的方式解决，即容器名称可以随意更容易，只要不更改别名即可，具体如下：
命令格式：

启动第三个容器

查看当前容器的主机

检查自定义别名通信

ping web1

docker网络类型：

docker的网络使用docker network ls命令看到有一种类型，下面将介绍每一种类型的具体工作方式：
使用参数–net=网络类型指定，而不指定替代就是bridge模式。

查看当前docke的网卡信息：

网桥：可以，使用自定义IP
主机：不获取IP直接使用物理机IP，并监听物理机IP监听端口
无：没有网络

（1）主机模式：使用参数–net = host指定。
启动的容器如果指定了使用主机模式，那么新创建的容器不会创建自己的虚拟网卡，而是直接使用托管机的网卡和IP地址，因此在容器里面查看到的IP信息就是宿主机的信息，

访问容器的时候直接使用主机机IP +容器端口即可，不过容器的其他资源他们必须文件系统，系统进程等还是和主机保持隔离。模式的网络性能最高，但是各个容器之间的端口不能相同，适用于运行容器端口比较固定的业务。

为避免端口冲突，先删除所有的容器：

2. 启动一个新容器，并指定网络模式为主机

3. 访问
主机机验证因为是主机模式，所以直接访问主机机的IP：192.168.0.36
访问到的是nginx的默认首页

主机模式不支持端口映射，当指定端口映射的时候会提示如下警告信息：
使用主机网络模式时，将替换已指定的端口

（2）None模式：使用参数–net = none指定
在使用none模式后，Docker容器不会进行任何网络配置，其没有网卡，没有IP也没有路由，因此无法与外部通信，需要手动添加网卡配置IP等，所以极少使用

命令使用方式：

（3）容器模式：使用参数–net = container：name或ID

　　使用此模式创建的容器需要指定和一个已经存在的容器共享一个网络，而不是和容纳机共享网，新创建的容器不会创建自己的网卡也不会配置自己的IP，或者和一个已经存在的被指定的容器IP和端口范围，

因此该容器的端口不能和被指定的端口冲突，除了网络之外的文件系统，进展信息等仍保持相互隔离，两个容器的进展可以通过lo网卡及容器IP进行通信。

先起一个容器

另一个容器直接使用对方的网络

nginx的默认端口为80，而8080是tomcat的默认端口，所以，如果我们直接访问托宿主机的7070，应该是访问到tomcat的页面才对。如图

（4）bridge模式： docker的交替模式即不指定任何模式就是bridge模式，也是使用比较多的模式，此模式创建的容器会为每一个容器分配自己的网络IP等信息，且多个容器连接到一个虚拟网桥与外界通信在这里插入图片描述

查看bridge模式的信息

docker跨主机互联之简单实现：

跨主机互联是说A主机的容器可以访问B主机上的容器，但是可以保证各主机之间的网络是可以相互通信的，然后各容器才可以通过主机访问到对方的容器，实现原理是在主机做一个网络路由就可以实现A主机的容器访问B主机的容器的目的，

复杂的网络或者大型的网络可以使用google开源的k8s进行互联。

修改各主机机网段： Docker的替代网段是172.17.0.x / 24，而且每个主机机都是一样的，因此路由选择的路由就是各个主机的网络不能一致，具体如下：

服务器A：192.168.0.36
服务器B：192.168.0.59

服务器A更改网段

在ExecStart结尾追加--bip=10.10.0.1/24，ip是你想设置的网络的网关ip

重启docker服务

验证一个服务器网卡

ifconfig docker0

如果你的系统是Centos，需要打开ipforward

启动一个容器

添加静态路由（主机上）

route add -net 10.10.0.0/24 gw 192.168.0.59

iptables -A FORWARD -s 192.168.0.0/24 -j ACCEPT

服务器B更改网段

在ExecStart结尾追加--bip=10.20.0.1/24，注意不能跟服务器A一样

重启docker服务

验证网卡: ifconfig docker0

如果你的系统是Centos，需要打开ipforward规则转发

启动一个容器

添加静态路由

容器间互相ping测试
互连两台服务器分别启动两个容器进行测试：10.10.0.0网段是服务器A内的容器，10.20.0.0网段是服务器B内的容器

在另一台容器里反ping试一下

如果可以ping通就表示没有问题，两个不同宿主机上的容器可以互相通信了

创建自定义网络：

可以基于docker命令创建自定义网络，自定义网络可以自定义IP地域和网关等信息。

帮助

创建自定义docker网络

查看网络

使用自定义网络创建容器

[root@Server1 ~]# docker run -itd --net=my-net centos-nginx:v1 bash
[root@Server1 ~]# docker exec -it 25d2c84d58bd bash
[root@25d2c84d58bd /]# yum install -y net-tools &> /dev/null
[root@25d2c84d58bd /]# ifconfig eth0

创建默认网络容器

如何与使用交替网络的容器通信：
现在有一个docker0（10.10.0.0/24）网络一个自定义的my-net（10.100.0.0/24）网络，每个网络上分别运行了不同数量的容器，那么怎么才能让位于不同网络的容器可以相互通信呢？那就是修改防火墙规则条目
保存下iptbales

修改iptables.sh

# vim iptables.sh

把DOCKER-ISOLATION-STAGE-2除了RETURN结尾的都注释了

重新导入修改后的iptables规则

经过以上的配置，目前就已经实现了不通网络间的通信

十六、Docker资源限制

官网：https://docs./config/containers/resource_constraints/

默认情况下，容器没有资源限制，可以使用主机内核调度程序允许的尽可能多的给定资源， Docker 提供了控制容器可以限制容器使用多少内存或 CPU 的方法，设置 docker run 命令的运行时配置标志。
其中许多功能都要求宿主机的内核支持 Linux 功能，要检查支持，可以使用docker info 命令，如果内核中禁用了某项功能，可能会在输出结尾处看到警告，

如下所示：

对于 Linux 主机，如果没有足够的内容来执行其他重要的系统任务，将会抛出OOM (Out of Memory Exception,内存溢出、内存泄漏、内存异常), 随后系统会开始杀死进程以释放内存，凡是运行在宿主机的进程都有可能被 kill，包括 Dockerd和其它的应用程序，如果重要的系统进程被 Kill,会导致和该进程相关的服务全部宕机。

产生 OOM 异常时， Dockerd 尝试通过调整 Docker 守护程序上的 OOM 优先级来减轻这些风险，以便它比系统上的其他进程更不可能被杀死，但是容器的 OOM优先级未调整，这使得单个容器被杀死的可能性比 Docker 守护程序或其他系统进程被杀死的可能性更大，不推荐通过在守护程序或容器上手动设置--oomscore-adj 为极端负数，或通过在容器上设置--oom-kill-disable 来绕过这些安全措施。

OOM 优先级机制：

linux 会为每个进程算一个分数，最终他会将分数最高的进程 kill。

/proc/PID/oom_score_adj :范围为-1000 到 1000，值越高越容易被宿主机 kill掉，如果将该值设置为-1000，则进程永远不会被宿主机 kernel kill。

/proc/PID/oom_adj :范围为-17 到+15，取值越高越容易被干掉，如果是-17，则表示不能被 kill，该设置参数的存在是为了和旧版本的 Linux 内核兼容。

/proc/PID/oom_score :这个值是系统综合进程的内存消耗量、 CPU 时间(utime + stime)、存活时间(uptime - start time)和 oom_adj 计算出的，消耗内存越多分越高，存活时间越长分越低。

容器的内存限制：

Docker 可以强制执行硬性内存限制，即只允许容器使用给定的内存大小。
Docker 也可以执行非硬性内存限制，即容器可以使用尽可能多的内存，除非内核检测到主机上的内存不够用了。

--oom-score-adj：宿主机 kernel 对进程使用的内存进行评分，评分最高的将被宿主机内核 kill 掉，可以指定一个容器的评分制但是不推荐手动指定。
--oom-kill-disable：对某个容器关闭 oom 机制。

内存限制参数：

-m, --memory：容器可以使用的最大内存量，如果设置此选项，则允许的最内存值为 4m （4 兆字节）。
--memory-swap：容器可以使用的交换分区大小，必须要在设置了物理内存限制的前提才能设置交换分区的限制
--memory-swappiness：设置容器使用交换分区的倾向性，值越高表示越倾向于使用 swap 分区，范围为 0-100， 0 为能不用就不用， 100 为能用就用。
--kernel-memory：容器可以使用的最大内核内存量，最小为 4m，由于内核内存与用户空间内存隔离，因此无法与用户空间内存直接交换，因此内核内存不足的容器可能会阻塞宿主主机资源，这会对主机和其他容器或者其他服务进程产生影响，因此不要设置内核内存大小。
--memory-reservation：允许指定小于--memory 的软限制，当 Docker 检测到主机上的争用或内存不足时会激活该限制，如果使用--memory-reservation，则必须将其设置为低于--memory 才能使其优先。因为它是软限制，所以不能保证容器不超过限制。
--oom-kill-disable 默认情况下，发生 OOM 时， kernel 会杀死容器内进程，但是可以使用--oom-kill-disable 参数，可以禁止 oom 发生在指定的容器上，即仅在已设置-m选项的容器上禁用 OOM，如果-m 参数未配置，产生 OOM 时，主机为了释放内存还会杀死系统进程。

swap 限制：

--memory-swap：只有在设置了 --memory 后才会有意义。使用 Swap,可以让容器将超出限制部分的内存置换到磁盘上， WARNING：经常将内存交换到磁盘的应用程序会降低性能。

不同 --memory-swap 的设置会产生不同的效果:
值为正数，那么--memory 和--memory-swap 都必须要设置， --memory-swap 表示你能使用的内存和 swap 分区大小的总和，例如： --memory=300m, --memory-swap=1g, 那么该容器能够使用 300m 内存和 700m swap，即--memory 是实际物理内存大小值不变，而 swap 的实际大小计算方式为

如果设置为 0:则忽略该设置，并将该值视为未设置，即未设置交换分区。

如果等于--memory 的值，并且--memory 设置为正整数: 容器无权访问 swap 即也没有设置交换分区。

如果设置为 unset:如果宿主机开启了 swap，则实际容器的swap 值为 2x( --memory)，即两倍于物理内存大小，但是并不准确(在容器中使用free 命令所看到的 swap 空间并不精确，毕竟每个容器都可以看到具体大小，但是宿主机的 swap 是有上限而且不是所有容器看到的累计大小)。
如果设置为-1：如果宿主机开启了 swap，则容器可以使用主机上 swap 的最大空间。

动态修改容器内存，先计算出所需要的内存的字节数：如268435456(256M)，只能调大不能调小

9fa20d824b18... 是容器ID

内存限制验证：

假如一个容器未做内存使用限制，则该容器可以利用到系统内存最大空间，默认创建的容器没有做内存资源限制。

#测试镜像

docker pull lorel/docker-stress-ng

查看帮助

或者这样也行

内存大小硬限制

查看docker状态

启动两个工作进程，每个工作进程最大允许使用内存 256M，且宿主机不限制当前容器最大内存：

--vm 启动多少个进程
--vm-bytes 为每个进程分配的内存

宿主机限制容器最大内存使用：

宿主机 cgroup 验证：

宿主机基于 cgroup 对容器进行内存资源的大小限制
注：通过 echo 命令可以改内存限制的值，但是可以在原基础之上增大内存限制，缩小内存限制会报错 write error: Device or resource busy

内存大小软限制：

宿主机 cgroup 验证：

返回的软限制结果

关闭 OOM 机制

docker run -it --rm -m 256m --oom-kill-disable       --name c4 lorel/dockerstress-ng --vm 2 --vm-bytes 256M

交换分区限制

宿主机 cgroup 验证：

容器的 CPU 限制

一个宿主机，有几十个核心的 CPU，但是宿主机上可以同时运行成百上千个不同的进程用以处理不同的任务，多进程共用一个 CPU 的核心依赖计数就是为可压缩资源，即一个核心的 CPU 可以通过调度而运行多个进程，但是同一个单位时间内只能有一个进程在 CPU 上运行，那么这么多的进程怎么在 CPU 上执行和调度的呢？

实时优先级： 0 - 99

非实时优先级(nice)： -20 - 19，对应 100 - 139 的进程优先级

Linux kernel 进程的调度基于 CFS(Completely Fair Scheduler)，完全公平调度

CPU 密集型的场景：优先级越低越好，计算密集型任务的特点是要进行大量的计算，消耗 CPU 资源，比如计算圆周率、数据处理、对视频进行高清解码等等，全靠 CPU 的运算能力。

IO 密集型的场景：优先级值高点，涉及到网络、磁盘 IO 的任务都是 IO 密集型任务，这类任务的特点是 CPU 消耗很少，任务的大部分时间都在等待 IO 操作完成（因为 IO 的速度远远低于 CPU 和内存的速度），比如 Web 应用，高并发，数据量大的动态网站来说，数据库应该为 IO 密集型。

磁盘的调度算法

默认情况下，每个容器对主机 CPU 周期的访问权限是不受限制的，但是我们可以设置各种约束来限制给定容器访问主机的 CPU 周期，大多数用户使用的是默认的 CFS 调度方式，在 Docker 1.13 及更高版本中，还可以配置实时优先级。

参数：

--cpus ：指定容器可以使用多少可用 CPU 资源，例如，如果主机有两个 CPU，并且设置了--cpus =“1.5”，那么该容器将保证最多可以访问 1.5 个的 CPU(如果是 4 核 CPU，那么还可以是 4 核心上每核用一点，但是总计是 1.5 核心的CPU)，这相当于设置--cpu-period =“100000”和--cpu-quota =“150000”
主要在 Docker 1.13 和更高版本中使用，目的是替代--cpu-period 和--cpuquota 两个参数，从而使配置更简单，最大不能超出宿主机的 CPU 总核心数(在操作系统看到的 CPU 超线程后的数值)。

分配给容器的 CPU 超出了宿主机 CPU 总数。

--cpu-period：(CPU 调度周期)设置 CPU 的 CFS 调度程序周期，必须与--cpuquota 一起使用，默认周期为 100 微秒
--cpu-quota：在容器上添加 CPU CFS 配额，计算方式为 cpu-quota/cpu-period的结果值，早期的 docker(1.12 及之前)使用此方式设置对容器的 CPU 限制值，==新版本 docker(1.13 及以上版本)通常使用--cpus 设置此值。==

--cpuset-cpus：用于指定容器运行的 CPU 编号，也就是我们所谓的绑核。
--cpuset-mem：设置使用哪个 cpu 的内存，仅对非统一内存访问(NUMA)架构有效。
--cpu-shares：用于设置 cfs 中调度的相对最大比例权重,cpu-share 的值越高的容器，将会分得更多的时间片(宿主机多核 CPU 总数为 100%，假如容器 A 为1024，容器 B 为 2048，那么容器 B 将最大是容器 A 的可用 CPU 的两倍 )，默认的时间片 1024，最大 262144。

测试 CPU 限制

未限制容器 CPU
对于一台四核的服务器，如果不做限制，容器会把宿主机的 CPU 全部占完。
分配 4 核 CPU 并启动 4 个工作线程

在宿主机使用 dokcer top 命令查看容器运行状态

容器运行状态：

在宿主机查看 CPU 限制参数：

限制容器 CPU
只给容器分配最多两核宿主机 CPU 利用率

宿主机 cgroup 验证

每核心 CPU 会按照 1000 为单位转换成百分比进行资源划分， 2 个核心的 CPU 就是 200000/1000=200%， 4 个核心 400000/1000=400%，以此类推

宿主机 CPU 利用率

将容器运行到指定的 CPU 上

容器运行状态

docker stats

基于 cpu—shares 对 CPU 进行切分
启动两个容器， c13 的--cpu-shares 值为 1000， c14 的--cpu-shares为 500，观察最终效果， --cpu-shares 值为 1000 的 c13 的 CPU 利用率基本是--cpu-shares 为 500 的 c14 的两倍：

验证容器运行状态

docker stats

宿主机 cgroup 验证

动态修改 CPU shares 值：
--cpu-shares 的值可以在宿主机 cgroup 动态修改，修改完成后立即生效，其值可以调大也可以减小。

验证修改后的容器运行状态 docker stats

十七

单机编排之Docker撰写：

当在主机启动主机的容器时候，如果都是手动操作会觉得比较麻烦而且容器出错，这个时候推荐使用docker单机编排工具docker-compose，docker-compose是docker容器的一种单机编排服务，docker- compose是一个管理多个容器的工具，可以解决容器之间的依赖关系，就像启动一个nginx前端服务的时候会调用后端的tomcat，那就得先启动tomcat，但是启动tomcat容器还需要依赖数据库，则那就还得先启动数据库，docker-compose就可以解决这样的嵌套依赖关系，其完全可以替代docker run对容器进行创建，启动和停止。

docker-compose项目是Docker官方的开源项目，负责实现对Docker容器放置的快速编排，docker-compose将所管理的容器分为三层，分别是工程（项目），服务以及容器

github地址https://github.com/docker/compose

基础环境准备：

服务器1 ：192.168.99.21，港口服务器2：192.168.99.22，
docker -compose 下面开始在服务器1上安装harbor和创建nginx，tomcat，haproxy大量备用
在这里插入图片描述

配置安装港口：

下载Harbor离线安装包：

解压

下载docker-compose
Ubuntu：

中心：

修改配置文件，最终配置如下

安装

./install.sh

编辑docker配置文件：
注意：如果我们配置的是https的话，本地docker就不需要任何任何操作就可以访问Harbor了

其中192.168.99.21是我们部署Harbor的地址，即hostname配置项值。配置完后需要重启docker服务。

重启docker服务：

systemctl daemon-reload
systemctl restart docker

重启docker-compose

docker-compose restart

验证能否登录Harbor：

docker login 192.168.99.21

https://docs./compose/reference/官方文档

制作nginx镜像

下载概述并初始化系统：

编写Dockerfile：

准备网页

构建镜像

查看是否生成新镜像

docker images

从总体启动容器

访问网络界面
打标签：

在港口管理界面创建项目（需要先创建项目再上传高层）
将向前推到港口：

发布完成

制作JDK环境

执行完善JDK的方针：

编辑Dockerfile

准备环境变量文件

vim profile

构建

打标记

在港口页面上创建jdk项目
将全面上传到Harbor（以下有讲）

从JDK整合重构tomcat

编辑Dockerfile文件

发布tomcat压缩包：apache-tomcat-8.5.45.tar.gz

通过脚本构建tomcat基础之上

验证合并重建完成

docker images

进行打上标签

在港口页面上创建tomcat项目
发布

构建tomcat-app业务运营：

准备Dockerfile：

准备自定义myapp页面：

准备容器启动执行脚本run_tomcat.sh：

构建

查看镜像

docker images

给Tomcat打标签

推送

制作haproxy补充：

准备Dockerfile：

准备run_haproxy.sh脚本

准备haproxy.cfg配置文件：

调度到初步nginx服务的81端口

准备haproxy原始文件：haproxy-2.0.5.tar.gz

# tree /opt/dockerfile/app/haproxy
/opt/dockerfile/app/haproxy
├── Dockerfile
├── haproxy-2.0.5.tar.gz
├── haproxy.cfg
└── run_haproxy.sh

准备编制脚本：

给通用打标签

港口创建haproxy项目
推送到仓库

docker push 192.168.99.21/haproxy/haproxy:v1

从docker compose启动临时容器

换成server2继续：

安装docker-18.09.9
过程略
下载docker-compose
Ubuntu：

Centos：

验证 docker-compose 版本

查看 docker-compose 帮助

docker-compose --help

编辑 docker 配置文件：

vim /lib/systemd/system/docker.service

在ExecStart追加

重启 docker 服务：

测试连接

docker login 192.168.99.21

在这里插入图片描述

目录可以在任意目录，推荐放在有意义的位置。如：

单个容器的 docker compose 文件：
编写一个 yml 格式的配置 docker-compose 文件，启动一个 nginx 服务

service-nginx-web：服务名
image：镜像名
container_name：容器名
expose：开放端口
post：宿主机映射端口
volume：数据卷挂载

启动容器

docker-compose up -d

不加是 d 前台启动

启动完成

查看容器进程

docker-compose ps

在这里插入图片描述

web 访问测试

启动多个容器

docker pull 192.168.99.21/tomcat/mytomcat-app:v1

编辑配置文件

重启容器

docker-compose stop
docker-compose up -d

web 访问测试
重启/停止/启动单个指定容器

写容器的 service 名称，则是指定。
不指定则是所有

重启所有容器：

实现Nginx反向代理Tomcat

创建nginx配置文件

创建nginx配置文件

创建网页

创建haproxy配置文件

nginx-web1:80 这里写的是容器内部的端口，所以nginx容器开放的什么端口就写多少，默认80。因为没有对宿主机映射，所以可以不会端口冲突。
nginx-web1 是容器名

准备tomcat配置文件

cd /opt/app
mkdir -p tomcat/conf

vim tomcat/conf/server.xml
<?xml version="1.0" encoding="UTF-8"?>
<!--
  Licensed to the Apache Software Foundation (ASF) under one or more
  contributor license agreements.  See the NOTICE file distributed with
  this work for additional information regarding copyright ownership.
  The ASF licenses this file to You under the Apache License, Version 2.0
  (the "License"); you may not use this file except in compliance with
  the License.  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
-->
<!-- Note:  A "Server" is not itself a "Container", so you may not
     define subcomponents such as "Valves" at this level.
     Documentation at /docs/config/server.html
 -->
<Server port="8005" shutdown="SHUTDOWN">
  <Listener className="org.apache.catalina.startup.VersionLoggerListener" />
  <!-- Security listener. Documentation at /docs/config/listeners.html
  <Listener className="org.apache.catalina.security.SecurityListener" />
  -->
  <!--APR library loader. Documentation at /docs/apr.html -->
  <Listener className="org.apache.catalina.core.AprLifecycleListener" SSLEngine="on" />
  <!-- Prevent memory leaks due to use of particular java/javax APIs-->
  <Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" />
  <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />
  <Listener className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" />

  <!-- Global JNDI resources
       Documentation at /docs/jndi-resources-howto.html
  -->
  <GlobalNamingResources>
    <!-- Editable user database that can also be used by
         UserDatabaseRealm to authenticate users
    -->
    <Resource name="UserDatabase" auth="Container"
              type="org.apache.catalina.UserDatabase"
              description="User database that can be updated and saved"
              factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
              pathname="conf/tomcat-users.xml" />
  </GlobalNamingResources>

  <!-- A "Service" is a collection of one or more "Connectors" that share
       a single "Container" Note:  A "Service" is not itself a "Container",
       so you may not define subcomponents such as "Valves" at this level.
       Documentation at /docs/config/service.html
   -->
  <Service name="Catalina">

    <!--The connectors can use a shared executor, you can define one or more named thread pools-->
    <!--
    <Executor name="tomcatThreadPool" namePrefix="catalina-exec-"
        maxThreads="150" minSpareThreads="4"/>
    -->


    <!-- A "Connector" represents an endpoint by which requests are received
         and responses are returned. Documentation at :
         Java HTTP Connector: /docs/config/http.html
         Java AJP  Connector: /docs/config/ajp.html
         APR (HTTP/AJP) Connector: /docs/apr.html
         Define a non-SSL/TLS HTTP/1.1 Connector on port 8080
    -->
    <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />
    <!-- A "Connector" using the shared thread pool-->
    <!--
    <Connector executor="tomcatThreadPool"
               port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />
    -->
    <!-- Define a SSL/TLS HTTP/1.1 Connector on port 8443
         This connector uses the NIO implementation. The default
         SSLImplementation will depend on the presence of the APR/native
         library and the useOpenSSL attribute of the
         AprLifecycleListener.
         Either JSSE or OpenSSL style configuration may be used regardless of
         the SSLImplementation selected. JSSE style configuration is used below.
    -->
    <!--
    <Connector port="8443" protocol="org.apache.coyote.http11.Http11NioProtocol"
               maxThreads="150" SSLEnabled="true">
        <SSLHostConfig>
            <Certificate certificateKeystoreFile="conf/localhost-rsa.jks"
                         type="RSA" />
        </SSLHostConfig>
    </Connector>
    -->
    <!-- Define a SSL/TLS HTTP/1.1 Connector on port 8443 with HTTP/2
         This connector uses the APR/native implementation which always uses
         OpenSSL for TLS.
         Either JSSE or OpenSSL style configuration may be used. OpenSSL style
         configuration is used below.
    -->
    <!--
    <Connector port="8443" protocol="org.apache.coyote.http11.Http11AprProtocol"
               maxThreads="150" SSLEnabled="true" >
        <UpgradeProtocol className="org.apache.coyote.http2.Http2Protocol" />
        <SSLHostConfig>
            <Certificate certificateKeyFile="conf/localhost-rsa-key.pem"
                         certificateFile="conf/localhost-rsa-cert.pem"
                         certificateChainFile="conf/localhost-rsa-chain.pem"
                         type="RSA" />
        </SSLHostConfig>
    </Connector>
    -->

    <!-- Define an AJP 1.3 Connector on port 8009 -->
    <Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />


    <!-- An Engine represents the entry point (within Catalina) that processes
         every request.  The Engine implementation for Tomcat stand alone
         analyzes the HTTP headers included with the request, and passes them
         on to the appropriate Host (virtual host).
         Documentation at /docs/config/engine.html -->

    <!-- You should set jvmRoute to support load-balancing via AJP ie :
    <Engine name="Catalina" defaultHost="localhost" jvmRoute="jvm1">
    -->
    <Engine name="Catalina" defaultHost="localhost">

      <!--For clustering, please take a look at documentation at:
          /docs/cluster-howto.html  (simple how to)
          /docs/config/cluster.html (reference documentation) -->
      <!--
      <Cluster className="org.apache.catalina.ha.tcp.SimpleTcpCluster"/>
      -->

      <!-- Use the LockOutRealm to prevent attempts to guess user passwords
           via a brute-force attack -->
      <Realm className="org.apache.catalina.realm.LockOutRealm">
        <!-- This Realm uses the UserDatabase configured in the global JNDI
             resources under the key "UserDatabase".  Any edits
             that are performed against this UserDatabase are immediately
             available for use by the Realm.  -->
        <Realm className="org.apache.catalina.realm.UserDatabaseRealm"
               resourceName="UserDatabase"/>
      </Realm>

      <Host name="localhost"  appBase="/data/tomcat/webapps/app"
            unpackWARs="true" autoDeploy="true">

        <!-- SingleSignOn valve, share authentication between web applications
             Documentation at: /docs/config/valve.html -->
        <!--
        <Valve className="org.apache.catalina.authenticator.SingleSignOn" />
        -->

        <!-- Access log processes all example.
             Documentation at: /docs/config/valve.html
             Note: The pattern used is equivalent to using pattern="common" -->
        <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
               prefix="localhost_access_log" suffix=".txt"
               pattern="%h %l %u %t "%r" %s %b" />
      </Host>
    </Engine>
  </Service>
</Server>

准备tomcat动态页面

注意这里：因为nginx中位置配置的配置路径是tomcat-app，往tomcat调度的时候会带上这个路径，所以，挂载进去的路径也要与之匹配。即：要能够访问http：// tomcat -app1：8080 / tomcat-app，才能通过nginx来调度

动态页面示例

创建docker-compose.yml

最终文件目录

测试访问

http://192.168.99.22/tomcat-app/showhost.jsp
在这里插入图片描述

以上就是Docke容器大部分的使用情景及功能实现

centos安装Docker与使用&&构建业务镜像挂载卷harbor仓库的高可用及网络模式和资源限制介绍

Docker版本选择：

Docker安装

下载rpm包安装：

Centos yum源安装：

Ubuntu安装

Docker命令

启动容器

更多命令

docker加快加速配置：

获取加速地址：

centos安装Docker与使用&&构建业务镜像挂载卷harbor仓库的高可用及网络模式和资源限制介绍

Docker版本选择：

Docker安装

下载rpm包安装：

Centos yum源安装：

Ubuntu安装

Docker命令

启动容器

更多命令

docker加快加速配置：

获取加速地址：

Docker命令与镜像管理：

docker常用命令示例

docker命令：

子命令帮助

run

ps

rm

logs

load

port

stop

kill

start

attach

exec

inspect

commit

Docker 镜像与制作

手动制作nginx镜像

Dockerfile介绍

FROM 指定基础镜像

MAINTAINER 指定维护者信息

RUN 执行命令

CMD 启动容器时执行的命令

EXPOSE 分配端口号

ENV 环境变量

ADD 复制/解压

COPY 复制

ENTRYPOINT 容器启动后执行的命令

VOLUME 挂载点

USER 指定用户名

WORKDIR 工作目录

ONBUILD

构建镜像

DockerFile 制作yum版 nginx 镜像：

下载镜像并初始化系统：

目录结构按照业务类型或系统类型等方式划分，方便后期镜像比较多的时候进行分类

编写 Dockerfile：

准备源码包与配置文件：

制作 tomcat 镜像：

1、先构建 JDK 镜像

2、从 JDK 镜像构建 tomcat-8 镜像

制作 haproxy 镜像：

本地镜像上传至官方 docker 仓库：

docker 仓库之分布式 Harbor

Harbor 功能官方介绍：

安装 Harbor：

下载 Harbor 安装包：

配置安装 Harbor：

后期修改配置：

继续

配置 docker 使用 harbor 仓库上传下载镜像：

从 harbor 下载镜像并启动容器：

实现 harbor 高可用：

测试从 harbor 镜像下载和容器启动：

Docker 数据管理

数据类型：

什么是数据卷(data volume)：

创建 APP 目录并生成 web 页面：

在宿主机或容器修改数据

启动容器并验证数据：

数据卷的特点及使用：

如何一次挂载多个目录

数据卷容器：

启动一个卷容器 Server：

重新创建容器卷 Server

十五：

docker结合负载实现网站高可用：

1.安装并配置keepalived