在docker上调用宿主机硬件_docker

docker容器访问宿主机硬件及最佳实践

最新推荐文章于 2024-11-17 17:01:21 发布

最新推荐文章于 2024-11-17 17:01:21 发布 · 3.1k 阅读

文章标签：

#在docker上调用宿主机硬件

本文详细介绍了Docker的基础知识，包括容器与虚拟机的区别、Docker系统架构、安装步骤、镜像管理和容器管理。重点讨论了如何在Docker中调用宿主机硬件，探讨了容器编排工具docker-compose的使用，并介绍了镜像分层、容器间互联以及Docker网络和监控。此外，还涵盖了Docker仓库的使用，包括官方和私有仓库的管理。最后，展示了如何利用Docker部署Gitlab实例。

一、docker介绍

容器是隔离的环境中运行的一个进程,如果进程结束,容器就会停止，

容器的隔离环境，拥有自己的IP地址，系统文件，主机名，进程管理

（一）、容器和虚拟机的区别

虚拟机

硬件cpu支持(vt虚拟化),模拟计算硬件,走正常的开机启动

启动流程

bios开机自检--根据bios启动项--读取硬盘第一个扇区grub,uefi, centos7, 加载内核,启动系统第一个进程/sbin/init systemd

容器

不需要硬件cpu的支持,共用宿主机内核,启动容器的第一个进程

（二）、docker主要内容

docker是一个cs架构, docker主要内容:镜像容器仓库网络存储监控

docker是一个软件的打包技术

docker镜像官方仓库

Docker Hub

（三）、docker 命令分组

docker image 镜像命令

docker container 容器命令

docker volume 卷命令

docker network 网络命令

（四）、容器的作用

docker使用客户端-服务端（C/S）架构模式，使用远程API来管理和创建docker容器

docker容器通过docker镜像来创建

（五）、容器优势

启动快,性能高,损耗少,轻量级

持续集成、版本控制、可移植性、隔离性和安全性

二、docker系统架构

镜像（images）

Docker镜像是用于创建Docker容器的模板。

容器（Container）

容器是独立运行的一个或一组应用。

客户端（Client）

docker客户端通过命令行或者其他工具使用Docker API与Docker的守护进程通信。

主机（Host）

一个物理或者虚拟机的机器用于执行Docker守护进程和容器。

仓库（Registry）

Docker仓库用来保存镜像，可以理解为代码控制中的代码仓库。

Docker Hub提供了庞大的镜像集合供使用。

Docker Machine

Docker Machine是一个简化Docker安装命令的命令行工具，

通过一个简单的命令行即可在相应的平台上安装Docker，

比如VirtualBox、Digital Ocean、Microsoft Azure。

三、docker安装

环境准备

第一步：安装docker-ce

1、下载yum源

wget -O /etc/yum.repos.d/docker-ce.repo https://download.docker.com/linux/centos/docker-ce.repo

2、优化yum源

sed -i 's+download.docker.com+mirrors.tuna.tsinghua.edu.cn/docker-ce+' /etc/yum.repos.d/docker-ce.repo

3、下载docker

yum install docker-ce -y

第二步：启动docker

systemctl enable docker
systemctl start docker

第三步：验证（查看docker版本信息）

docker version

四、docker日常管理

（一）、docker镜像管理

docker镜像加速

1、编写指定文件daemon.json（默认不存在）

vim /etc/docker/daemon.json

{
    "registry-mirrors": [
        "https://registry.docker-cn.com"
    ]
}

2、重启docker服务

systemctl restart docker

2、管理命令

搜索镜像（优先选官方,stars数量多）

docker search php
#命令         镜像名称

拉取镜像(下载镜像，注意版本）

docker pull httpd:latest
#命令       镜像名称:版本

推送镜像(上传镜像)

docker container commit nginx centos6.9_nginx:v1
#命令                    容器 名称  镜像名称:版本

查看镜像属性

docker image inspect centos:6.9
#命令                   镜像名称

导入镜像

docker image load -i docker_nginx.tar.gz 
#命令         导入      镜像路径

docker image import  docker_nginx.tar.gz 
#命令         导入

import导入：不会导入镜像的名称和版本

load导入：会导入镜像的名称和版本

导出镜像

docker save centos:7 -o /tmp/docker_centos7.tar.gz
#命令       镜像    导出   导出位置

查看本地镜像列表

docker image ls

删除镜像

docker image rm centos:6.9
#命令            镜像名称

删除所有镜像

docker rmi -f $(docker images -q)

给镜像打标签

docker image tag 026818835a64 oldboy:v1
#命令             镜像ID       镜像名称:版本

清理镜像

docker image prune

（二）、docker容器管理

创建并启动容器

docker  run -d  -p 80:80  --name web01 nginx:latest

-d #后台运行容器

-p #进行端口映射（宿主机端口:容器服务端口）

--name #指定容器名称

nginx:latest #镜像名称:版本

创建并进入容器

docker run -it centos:6.9 /bin/bash

-it #分配一个交互式终端

创建容器

docker container create --name web04 nginx:latest

--name #创建容器时指定容器名称，如果不指定，系统自动生成

nginx:latest #镜像名称:版本（必须指定）

启动容器

docker container start web03 
#命令                   容器名称

停止容器

docker container stop web03

重启容器

docker container restart web03

强制停止容器

docker container kill web03

显示容器相对于镜像的改变

docker diff web01

查看容器列表

docker ps -a -q

-a #查看所有容器，长格式显示

-q #只显示容器ID

-l #只显示最后一个容器

不加-a只查看挂起或者启动状态的容器

查看容器状态

docker stats

--no-stream #只显示一次的状态信息

删除容器

docker container rm web03 
docker container rm -f web03

-f #强制删除

批量删除所有容器：docker rm -f `docker ps -a -q`

清理容器

docker container prune

查看容器状态

docker inspect web02

查看容器日志

docker logs web02

进入正在运行的容器(分配一个新终端)

docker exec -it web /bin/bash

进入正在运行的容器(使用相同的终端)

偷偷离开的快捷键ctrl +p松开再按ctrl +q

docker container attach web01

docker端口映射

-p 宿主机端口:容器端口

docker  run -d  -p 80:80  --name web01 nginx:latest

-p 宿主机ip1:宿主机端口:容器端口 (多个容器同时使用80端口)

docker run -d -p 10.0.0.12:85:80 nginx:latest

-p 宿主机ip1::容器端口随机端口映射

docker run -d -p 10.0.0.12::80 --name web01 nginx:latest

-p 宿主机ip1::容器端口/udp 使用udp协议做随机端口映射

docker run -d -p 10.0.0.12::80/udp nginx:latest

-p 80:80 -p 3306:3306

docker run -d -p 10.0.0.12::80 -p 10.0.0.13::8080 --name web03 nginx:latest

-p 1111-1119:1111-1119 端口范围映射

docker run -d -p 90-95:70-75 --name web04 nginx:latest

-P 自动随机端口映射

docker run -d -P --name web05 nginx:latest

docker数据卷

指定宿主机目录挂载

docker run -d -P -v /opt/xiaoniao:/usr/share/nginx/html nginx:latest 
#命令               宿主机代码目录 :容器代码目录

创建随机数据卷挂载

docker run -d -p 81:80 --name web02 -v /usr/share/nginx/html nginx:latest 
#                                          容器目录

创建指定卷挂载

docker run -d -p 82:80 --name web03 -v oldboy:/usr/share/nginx/html nginx:latest
#                                      卷名称:容器目录

指定多个目录挂载

docker run -d -P --name web08  -v oldboy:/root -v oldgirl:/tmp nginx:latest

跟某一个容器挂载所有相同的卷

docker run -d -P --name web07 --volumes-from web06 nginx:latest
#命令                         指定和那个容器挂载相同的卷  容器名称 镜像名称

卷的存储位置：/var/lib/docker/volumes

挂载后在宿主机上改变数据，容器中的数据也会改变

五、制作docker镜像

（一）、制作原理

1、启动一个纯净的容器，在容器中安装服务

2、把安装好服务的容器提交为镜像

3、测试

（二）、手动制作docker镜像

制作单服务镜像（例：基于centos6系统的nginx镜像）

第一步：下载一个纯净的centos:6.9镜像

docker pull centos:6.9

第二步：导入镜像

docker image load -i centos:6.9

第三步：基于centos6.9启动容器

docker run -it -p 80:80 --name nginx centos:6.9 /bin/bash

第四步：在容器中优化yum源

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

第五步：下载nginx

yum install nginx -y

第六步：把安装好服务的容器,提交为镜像

docker container commit nginx centos6.9_nginx:v1

第七步：测试镜像的功能

docker container commit nginx centos6.9_nginx:v1

制作多服务镜像（基于centos6系统的nginx+ssh双服务的docker镜像）

第一步：基于centos6.9_nginx:v1镜像启动容器

docker run -it -p 88:80 -p 1022:22 --name nginx_sshd centos6.9_nginx:v1 /bin/bash

第二步：下载sshd服务

yum install openssh-server -y

第三步：重启sshd服务，生成密钥对

service sshd restart

第四步：修改root用户密码

echo '123456'|passwd --stdin root

第五步：创建初始命令脚本

vi /init.sh

#!/bin/bash

/usr/sbin/sshd
nginx -g 'daemon off;'

第六步：将安装好服务的容器提交为镜像

docker commit nginx_sshd centos6.9_nginx_ssh:v2

第七步：测试镜像功能

docker run -d -p 1024:22 -p 90:80 --name centos_2 centos6.9_nginx_ssh:v2 /bin/bash /init.sh
ssh root@10.0.0.12 -p 1024
curl -I 10.0.0.12:90

制作多服务镜像（基于centos6系统的kod网盘的镜像）

第一步：基于centos6.9_nginx:v1镜像启动容器

docker run -it -p 80:80 --name kod01 centos6.9_nginx:v1 /bin/bash

第二步：下载php服务

yum install php-fpm php-gd php-mbstring -y

第三步：修改PHP服务文件

vi /etc/php-fpm.d/www.conf

user = nginx
group = nginx

第四步：编写nginx配置文件

vi /etc/nginx/conf.d/default.conf

server {
    listen 80;
    server_name localhost;
    root /code;
    location / {
        index index.php index.html index.htm;
    }
    location ~ .php$ {
        fastcgi_pass 127.0.0.1:9000;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
                include fastcgi_params;
    }
}

第五步：创建站点目录

mkdir /code

第六步：上传代码文件

kodexplorer4.40.zip
docker cp kodexplorer4.40.zip kod01:/code

第七步：容器中解压代码文件

yum install unzip -y
unzip kodexplorer4.40.zip
chown -R nginx:nginx 、code

第八步：编写初始命令脚本

vi /init.sh

#!/bin/bash

service php-fpm start
nginx -g 'daemon off;'

第九步：把安装好服务的容器提交为镜像

docker commit kod01 kod:v1

第十步：测试镜像功能

docker run -d -p 92:80 --name kod03 kod:v1 /bin/bash /init.sh

（三）、自动制作docker镜像

dockerfile编写规范

dockerfile自动构建docker镜像的需要一个dockerfile文件，一个镜像一个dockerfile文件

dockerfile文件中的指令必须大写

dockerfile常用指令

指定基础镜像：FROM

制作镜像过程中需要的执行命令(安装服务)：RUN

容器启动的时候执行的初始命令，容易被替换(启动服务)：CMD

容器启动的时候执行的初始命令，不能被替换：ENTRYPOINT

PS：如果同时使用cmd和entrypoint，cmd命令将作为ENTRYPOINT命令的参数

把dockerfile当前目录下的文件拷贝到容器中（自动解压tar包）：ADD

把dockerfile当前目录下的文件拷贝到容器中（不解压tar包）：COPY

指定容器的默认工作目录：WORKDIR

镜像要暴露的端口：EXPOSE

持久化卷（生成随机的数据卷）：VOLUME

环境变量(ssh的密码,数据库的密码)：ENV

镜像的属性标签：LABEL

管理者标识：MAINTAINER

自动构建docker镜像步骤

1：手动制作一次docker镜像，记录历史命令

2：根据历史命令，编写dockerfile文件

可道云dockerfile编写步骤

前提：手动制作一次docker镜像，记录历史命令

第一步：创建指定目录

mkdir /opt/dockerfile/kod -p

第二步：在指定目录下获取所需文件

进入目录

cd /opt/dockerfile/kod

获取PHP配置文件

docker cp kod03:/etc/php-fpm.d/www.conf ./

获取nginx配置文件

docker cp kod03:/etc/nginx/conf.d/default.conf ./

获取初始化命令脚本文件

docker cp kod03:/init.sh ./

上传kod代码文件

kodexplorer4.40.zip

第三步：编写dockerfile

vim dockerfile

FROM centos6.9_nginx:v1
RUN yum install php-fpm php-gd php-mbstring -y
ADD www.conf /etc/php-fpm.d/www.conf
ADD default.conf /etc/nginx/conf.d/default.conf
RUN mkdir /code
WORKDIR /code
ADD kodexplorer4.40.zip .
RUN yum install unzip -y
RUN unzip kodexplorer4.40.zip
RUN chown -R nginx:nginx /code
ADD init.sh /init.sh
EXPOSE 80
VOLUME /code

CMD ["/bin/bash","/init.sh"]

第四步：提交docker文件，构建镜像

docker build -t file_kod:1 .

-t 指定镜像名称

第五步：测试镜像功能

创建容器

docker run -d -P --name file_kod01 file_kod:1

进入容器

docker exec -it file_kod01 /bin/bash

LNMP架构dockerfile编写

前提：手动制作一次docker镜像，记录历史命令

第一步：创建指定目录

mkdir /opt/dockerfile/wordpress -p

第二步：在指定目录下获取所需文件

进入目录

cd /opt/dockerfile/wordpress

获取PHP配置文件

docker cp wordpress:/etc/php-fpm.d/www.conf ./

获取nginx配置文件

docker cp workpress:/etc/nginx/conf.d/default.conf ./

获取初始化命令脚本文件

docker cp wordpress:/init.sh ./

上传wordpress代码文件

wordpress-5.3.2-zh_CN.tar.gz

第三步：编写dockerfile

FROM centos:7
RUN curl -o /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
RUN yum install nginx mariadb-server php-fpm php-mysql -y
RUN mysql_install_db --user=mysql --defaults-file=/etc/my.cnf
RUN tmp=`nohup mysqld_safe --defaults-file=/etc/my.cnf &` && sleep 5 && 
 mysql -e "create database wordpress;" && 
 mysql -e "grant all on wordpress.* to wordpress@localhost identified by '123456';"
ADD www.conf /etc/php-fpm.d/www.conf 
ADD nginx.conf /etc/nginx/nginx.conf
RUN  mkdir /code
WORKDIR /code/
ADD wordpress-4.9.4-zh_CN.zip .
RUN yum install unzip -y
RUN  unzip wordpress-4.9.4-zh_CN.zip 
RUN  mv wordpress/* .
RUN  chown -R nginx:nginx .
ADD init.sh /init.sh

CMD ["/bin/bash","/init.sh"]

第四步：提交docker文件，构建镜像

docker build -t file_wordpress:v1 .

第五步：测试镜像功能

创建容器

docker run -d -P --name file_wordpress file_wordpress:v1

进入容器

docker exec -it file_wordpress /bin/bash

dockerfile优化

a: 使用体积小的linux镜像alpine

alpine系统基础操作

b：尽可能的清理无用的缓存文件（尽可能把多个RUN合并）

c：修改dockerfile的时候，尽可能把修改的内容放在最后

d：使用.dockerignore忽略构建docker镜像时，不需要的文件

使用方法：

在dockerfile同级目录下创建 .dockerignore 文件，将一些在dockerfile中用不到的文件写入到 .dockerignore 文件中。这样dockerfile在构建镜像的时候会大大缩短构建时间

六、docler镜像的分层

（一）、docker镜像分层概念

一个docker镜像由多个可读的镜像层组成，然后运行的容器会在这个docker的镜像上面多加一层可写的容器层，任何的对文件的更改都只存在此容器层。因此任何对容器的操作均不会影响到镜像

（二）、镜像分层的优点

基本上每个软件都是基于某个镜像去运行的，因此一旦某个底层环境出了问题，就不需要去修改全部基于该镜像的软件的镜像，只需要修改底层环境的镜像。

这个好处也是最大好处，就是可以共享资源，其他相同环境的软件镜像都共同去享用同一个环境镜像，而不需要每个软件镜像要去创建一个底层环境。

节省空间

（三）、docker镜像分层原理

（四）、docker分层如何实现

如果需要获取某个文件，那么容器曾会从上到下去下一层的镜像层去获取文件，如果该层文件不存在，那么就会去下一镜像层去寻找，直到最后一层。

对于用户而言，用户面向的是一个叠加后的文件系统。

七、容器间互联

命令

docker run --link 正在运行容器的名字

例子：

dockerfile部署zabbix

docker run --name mysql-server -it 
      -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-compose）

（一）、功能

批量管理容器

（二）、docker-compose部署

第一步：优化epel源

curl -o /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo

第二步：下载docker-compose

yum -y install docker-compose

（三）、docker-compose常用命令

docker-compose up #前台启动容器

docker-compose up -d #后台启动容器

docker-compose down #停止并删除容器

docker-compose start #批量启动容器

docker-compose stop #批量停止容器

docker-compose restart #批量重启容器

（四）、docker-compose编写示例

第一步：创建项目目录

mkdir -p /opt/zabbix/docker-compose/

第二步：编写docker-compose文件

vim /opt/zabbix/docker-compose/docker-compose.yaml

version: '3'
#指定docker-compose版本，不同版本yaml配置文件语法不同
services:
   mysql-server:
     image: mysql:5.7
     restart: always
#设置容器的开机自启
     environment:
       MYSQL_ROOT_PASSWORD: root_pwd
       MYSQL_DATABASE: zabbix
       MYSQL_USER: zabbix
       MYSQL_PASSWORD: zabbix_pwd
     command: --character-set-server=utf8 --collation-server=utf8_bin
     
   zabbix-java-gateway:
     image: zabbix/zabbix-java-gateway:latest
     restart: always
     
   zabbix-server:
     depends_on:
       - mysql-server
     image: zabbix/zabbix-server-mysql:latest
     restart: always
     environment:
       DB_SERVER_HOST: mysql-server
       MYSQL_DATABASE: zabbix
       MYSQL_USER: zabbix
       MYSQL_PASSWORD: zabbix_pwd
       MYSQL_ROOT_PASSWORD: root_pwd
       ZBX_JAVAGATEWAY: zabbix-java-gateway
     ports:
       - "10051:10051"
       
   zabbix-web-nginx-mysql:
     depends_on:
       - zabbix-server
     image: zabbix/zabbix-web-nginx-mysql:latest
     ports:
       - "80:80"
     restart: always
     environment:
       DB_SERVER_HOST: mysql-server
       MYSQL_DATABASE: zabbix
       MYSQL_USER: zabbix
       MYSQL_PASSWORD: zabbix_pwd
       MYSQL_ROOT_PASSWORD: root_pwd

第三步：调用yaml文件批量启动容器

docker-compose  up  -d

九、docker仓库

（一）、docker容器三大核心间的关系

（二）、镜像地址

nginx:1.15 官方仓库的官方镜像

nginx/nginx:1.15 官方仓库的用户镜像

daocloud.io/nginx/nginx:1.15 私有仓库的镜像

（三）、官方仓库

第一步：官方页面注册官方账户账号

第二步：客户端登录官方仓库

docker login

第三步：给镜像打标签

docker tag wordpress:v1 maomaowo/wordpress:v1

第四步：将打好标签的镜像上传到官方仓库

docker push maomaowo/wordpress:v1

（四）、私有仓库docker-registry

私有仓库特点

功能弱，占用资源少

服务端启动私有仓库

docker run -d -p 5000:5000 --restart=always --name registry -v /opt/myregistry:/var/lib/registry registry

客户端上传镜像到私有仓库

第一步：第一次上传时编写配置文件

vim /etc/docker/daemon.json

{
  "registry-mirrors": ["https://registry.docker-cn.com"],
#镜像加速
  "insecure-registries": ["10.0.0.11:5000"]
#信任 10.0.0.11:5000地址的仓库
}

PS：第一次上传或下载时如果不编写 /etc/docker/daemon.json 文件会报错：

Trying to pull repository 10.0.0.11:5000/centos ...

Get https://10.0.0.11:5000/v1/_ping: http: server gave HTTP response to HTTPS client

第二步：重启docker服务

systemctl  restart docker

第三步：给镜像打标签

docker tag mysql:5.6.35 10.0.0.11:5000/mysql:5.6.35

第四步：上传镜像到私有仓库

docker push 10.0.0.11:5000/mysql:5.6.35

客户端从私有仓库下载镜像

第一步：第一次下载时编写配置文件

vim /etc/docker/daemon.json

{
  "registry-mirrors": ["https://registry.docker-cn.com"],
#镜像加速
  "insecure-registries": ["10.0.0.11:5000"]
#信任 10.0.0.11:5000地址的仓库
}

第二步：重启docker服务

systemctl  restart docker

第三步：下载镜像

docker image pull 10.0.0.11:5000/mysql:5.6.35

查看私有仓库镜像列表

浏览器页面访问

http://10.0.0.11:5000/v2/_catalog

查看镜像版本

http://10.0.0.11:5000/v2/mysql/tags/list

删除私有仓库中的镜像

第一步：进入docker registry的容器中

docker exec -it registry /bin/sh

第二步：删除repo

rm -fr /var/lib/registry/docker/registry/v2/repositories/nginx

第三步：清楚掉blob

registry garbage-collect /etc/docker/registry/config.yml

企业级私有仓库harbor(docker-compose)

harbor部署

第一步：优化epel源

curl -o /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo

第二步：下载docker-compose

yum -y install docker-compose

第三步：下载安装器并解压

https://github.com/goharbor/harbor/releases/download/v1.10.0/harbor-offline-installer-v1.10.0.tgz
tar xf harbor-offline-installer-v1.8.0.tgz

第四步：修改配置文件

cd  harbor

vim harbor.yml

#修改为以下信息
hostname: 10.0.0.12     #harbor服务器地址
harbor_admin_password: 123456     #登录密码

第五步：执行安装脚本

./install.sh

第六步：浏览器访问

10.0.0.12

用户名：admin

密码：123456

为harbor配置https证书

第一步：上传证书文件

blog.oldqiang.com.zip

cd /opt/cert
unzip blog.oldqiang.com.zip

第二步：编写harbor配置文件

vim /opt/harbor/harbor.yml

#修改IP地址为域名(配置https访问后，IP地址无法访问，必须使用域名访问)
hostname: blog.oldqiang.com
#注释掉所有HTTP信息
# http related config
#http:
 # port for http, default is 80. If https enabled, this port will redirect to https port
#  port: 80
#编写HTTPS访问信息（将多余注释删除，注意缩进关系）
# https related config
https:
  port: 443
  certificate: /opt/cert/Nginx/1_blog.oldqiang.com_bundle.crt    #证书文件绝对路径
  private_key: /opt/cert/Nginx/2_blog.oldqiang.com.key             #公钥文件绝对路径

第三步：重新执行安装脚本

cd /opt/harbor/
./install.sh

第四步：Windows配置hosts解析

10.0.0.12  blog.oldqiang.com

第五步：浏览器页面访问

blog.oldqiang.com

上传镜像到企业级私有仓库

第一步：配置域名劫持

vim /etc/hosts

10.0.0.12 blog.oldqiang.com

第二步：命令行登录仓库

docker login blog.oldqiang.com

用户名：admin

密码：123456

第三步：给镜像打标签

docker tag centos:7 blog.oldqiang.com/library/centos:7
#命令      镜像         仓库域名/项目名称/镜像名称

第四步：将打标签后的镜像上传

docker push blog.oldqiang.com/library/centos:7

镜像迁移（将私有仓库的镜像拉取到harbor）

登录harbor页面，点击仓库管理

填写相关信息，点击测试，成功后点击确定

创建同步规则

填写相关信息

同步镜像

十、docker基础网络

（一）、docker四种基础网络

bridge：默认类型 NAT模式

host： host类型，使用宿主机网络，使用宿主机网络，网络性能最高,容易端口冲突

container：容器类型。使用其他容器共用网络，k8s中使用

none：没有网络，上不了外网

（二）、创建自定义网络

docker network create -d bridge --subnet 172.18.0.0/16 --gateway 172.18.0.1 oldqiang
#命令                    指定网络类型  指定网段        指定网关            指定网络名称

（三）、跨宿主机网络通讯

1、跨宿主机容器间的通讯之macvlan

第一步：所有宿主机上创建macvlan网络

docker network create -d macvlan --subnet 10.0.0.0/24 --gateway 10.0.0.254 -o parent=eth0 macvlan_1
#命令                    指定网络类型      指定网段     指定网关           基于哪块网卡桥接 网络名称

第二步：不同宿主机创建容器

docker01

docker run -it --network macvlan_1 --ip 10.0.0.105 --name net01 alpine:latest /bin/sh
#                         指定网络类型    指定容器IP

docker02

docker run -it --network macvlan_1 --ip 10.0.0.106 --name nat01 alpine:latest /bin/sh

第三步：docker01容器互ping docker02容器

ping 10.0.0.105
ping 10.0.0.106

2、跨宿主机容器间的通讯之overlay

配置样例

第一步：在单独的节点上创建consul （docker03）（consul是用来存储IP地址分配信息的数据库）

docker run -d -p 8500:8500 -h consul --name consul progrium/consul -server -bootstrap
#                                           指定容器的主机名

第二步：docker01、02上修改daemon.json文件

docker01

vim /etc/docker/daemon.json

#修改为如下样式（注意格式）
{

  "registry-mirrors": ["https://registry.docker-cn.com"],
▽
  "insecure-registries": ["10.0.0.11:5000"],

  "cluster-store": "consul://10.0.0.128:8500",     #consul服务端IP地址:端口

  "cluster-advertise": "10.0.0.11:2376"     #客户端（本地）IP地址:端口
}

systemctl restart docker

docker01

vim /etc/docker/daemon.json

#修改为如下样式（注意格式）
{

  "registry-mirrors": ["https://registry.docker-cn.com"],

  "insecure-registries": ["10.0.0.11:5000"],

  "cluster-store": "consul://10.0.0.128:8500",     #consul服务端IP地址:端口

  "cluster-advertise": "10.0.0.12:2376"     #客户端（本地）IP地址:端口
}

systemctl restart docker

第三步：创建创建overlay网络

docker network create -d overlay --subnet 172.26.0.0/16 --gateway 172.26.0.1  ol1

第四步：启动容器测试

docker01

docker run -it --network ol1 --name oldboy01  alpine:latest  /bin/sh

ping oldboy02

docker02

docker run -it --network ol1 --name oldboy02  alpine:latest  /bin/sh

ping oldboy01

overlay网络通讯原理

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

每次创建overlay网络时，同时会自动创建名称为 docker_gwbridge 类型为bridge 的网络

eth1通过桥接到此网络实现访问外网，eth1的IP地址信息不会存储在consul中

十一、docker容器的监控

Prometheus架构图

Prometheus部署（docker01/02 被监控节点，docker03 监控服务端）

第一步：被监控节点部署

启动node-exporter

docker run -d   -p 9100:9100   -v "/:/host:ro,rslave"   --name=node_exporter   Quay   --path.rootfs /host
#                                                                                     容器的启动参数

启动cadvisor

docker run --volume=/:/rootfs:ro  --volume=/var/run:/var/run:rw --volume=/sys:/sys:ro --volume=/var/lib/docker/:/var/lib/docker:ro  -p 8080:8080 --detach=true --name=cadvisor google/cadvisor:latest

第二步：服务端部署Prometheus

1、下载Prometheus二进制包

2、解压二进制包

tar xf prometheus-2.12.0.linux-amd64.tar.gz

3、编辑配置文件

cd prometheus-2.12.0.linux-amd64/

vim prometheus.yml

# my global config
global:
  scrape_interval:     15s # Set the scrape interval to every 15 seconds. Default is every 1 minute.          #采集数据的间隔（全局配置）
  evaluation_interval: 15s # Evaluate rules every 15 seconds. The default is every 1 minute.
  # scrape_timeout is set to the global default (10s).

# Alertmanager configuration
alerting:
  alertmanagers:
  - static_configs:
    - targets:
      # - alertmanager:9093           #报警程序IP地址:端口

# Load rules once and periodically evaluate them according to the global 'evaluation_interval'.
rule_files:                 #Prometheus报警规则
  # - "first_rules.yml"
  # - "second_rules.yml"

# A scrape configuration containing exactly one endpoint to scrape:
# Here it's Prometheus itself.
scrape_configs:       #Prometheus监控节点配置信息
  # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
  - job_name: 'prometheus'          #默认监控本地服务状态
    static_configs:
    - targets: ['localhost:9090']
  - job_name: 'cadvisor'              #监控cadvisor信息
    static_configs:
    - targets: ['10.0.0.11:8080','10.0.0.12:8080']    #cadvisor节点信息
  - job_name: 'node_exporter'       #监控node_exporter信息
    static_configs:
    - targets: ['10.0.0.11:9100','10.0.0.12:9100']    #node_exporter节点信息

4、启动Prometheus

./prometheus --config.file="prometheus.yml"  &

第三步：服务端部署grafana

1、下载grafanar pm包

2、安装grafana

yum localinstall grafana-6.3.3-1.x86_64.rpm -y

3、启动grafana

systemctl start grafana-server.service 
systemctl enable grafana-server.service

#访问grafana http://10.0.0.13:3000，默认账号admin:admin

第四步：配置grafana，出图显示节点状态

1、配置数据源

2、导入dashboard文件

grafana_docker_dashboard.json

十二、docker部署gitlab

第一步：拉取gitlab镜像

docker search gitlab  #查看镜像
docker pull gitlab/gitlab-ce  #拉取

第二步：创建准备gitlab工作目录

#创建 config 目录

mkdir -p /home/gitlab/config

#创建 logs 目录

mkdir -p /home/gitlab/logs

#创建 dat 目录

mkdir -p /home/gitlab/data

第三步：启动gitlab容器

docker run --detach 
  --hostname 10.0.0.11 
  --publish 7001:443  --publish 7002:80  --publish 7003:22 
  --name gitlab 
  --restart always 
  --volume /home/gitlab/config:/etc/gitlab 
  --volume /home/gitlab/logs:/var/log/gitlab 
  --volume /home/gitlab/data:/var/opt/gitlab 
    gitlab/gitlab-ce

detach 指定容器运行于前台还是后台

hostname 指定主机地址，如果有域名可以指向域名

publish 指定容器暴露的端口，左边的端口代表宿主机的端口，右边代表容器的端口

name 容器名字

restart always 跟随docker服务启动

volume 数据卷，在docker中是最重要的一个知识点

第四步：修改gitlab.rb配置文件

vim /home/gitlab/config/gitlab.rb

#添加以下信息
external_url 'http://10.0.0.11'
gitlab_rails['gitlab_ssh_host'] = ''
gitlab_rails['gitlab_shell_ssh_port'] = 703

#配置gitlab通过smtp发送邮件
gitlab_rails['gitlab_email_enabled'] = true
gitlab_rails['gitlab_email_from'] = 'f332313959@163.com'
gitlab_rails['gitlab_email_display_name'] = 'china'
gitlab_rails['smtp_enable'] = true
gitlab_rails['smtp_address'] = "smtp.163.com"
gitlab_rails['smtp_port'] = 465
gitlab_rails['smtp_user_name'] = "f332313959@163.com"
gitlab_rails['smtp_password'] = "授权码"
gitlab_rails['smtp_domain'] = "网易"
gitlab_rails['smtp_authentication'] = "login"
gitlab_rails['smtp_enable_starttls_auto'] = true
gitlab_rails['smtp_tls'] = true

按照上面的方式，gitlab容器运行没有问题，但在gitlab上创建项目的时候，生成项目的URL访问地址是按容器的hostname来生成的，也就是容器的id。作为gitlab服务器，我们需要一个固定的URL访问，于是需要配置gitlab.rb

第五步：进入gitlab容器重启服务

docker exec -it gitlab /bin/bash  #进入gitlab容器服务
gitlab-ctl reconfigure  #重置gitlab客户端的命令

第六步：重启gitlab容器

docker restart gitlab

第七步：检查启动信息

 docker ps 
netstat -lnt

第八步：登录gitlab界面

这里直接访问：http://10.0.0.11:7002/，使用宿主ip地址访问映射端口

由于我们运行是使用数据卷参数进行运行的，宿主机的gitlab.rb文件修改，容器内的配置文件也会修改，但是容器的文件不会跟着生效，必须要进去容器里面进行命令执行，重置配置文件比较浪费时间，需要耐心等待，如果时间比较短说明成功率不高这里内存建议3G因为内存如果是1G这个命令执行不起来