‘Docker基础

Docker基础概念

Docker核心概念

Docker大部分的操作都围绕着它的三大核心概念：镜像、容器和仓库。因此，准确把握这三大核心概念对于掌握Docker技术尤为重要。

Docker底层原理

为什么docker会比vm虚拟机快。

1.docker比虚拟机有更少的抽象层。

• docker并不是通过虚拟了硬件资源，而是直接使用物理机的硬件资源，所以速度很快。

2.docker使用了宿主机的内核，而不需要加载操作系统。

• vm创建虚拟机时直接创建整个操作系统。但docker不是，他是直接利用宿主机的操作系统，省略了返回过程。

Docker和虚拟机之间的不同

• 传统虚拟机，虚拟出一条硬件，运行一个完整的操作系统，然后在这个系统上安装和运行软件。
• Dokcer容器内应用直接运行在宿主机的内容，容器是没有自己的内核的，也没有虚拟我们的硬件，所以就轻便了很多
• 每个容器之间是相互隔离的，每个容器内有一个属于自己的文件系统，互不影响。

DevOps(开发，运维)

应用更快速的交付和部署

更快捷的升级和缩容

跟简单的系统运维

更高效的资源利用

Docker镜像的分层概念

• 镜像是什么
  • 是一种轻量级、可执行的独立软件包，它包含运行某个软件所需的所有内容，我们把应用程序和配置依赖打包好形成一个可交付的运行环境(包括代码、运行时需要的库、环境变量和配置文件等)，这个打包好的运行环境就是image镜像文件。
• 分层的镜像
  • 以我们的pull为例，在下载的过程中我们可以看到docker的镜像好像是在一层一层的在下载。
• UnionFS（联合文件系统）
  • UnionFS（联合文件系统）：Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。Union 文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。
  • 特性：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录
• Docker镜像加载原理
  • docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS。bootfs(boot file system)主要包含bootloader和kernel, bootloader主要是引导加载kernel, Linux刚启动时会加载bootfs文件系统，在Docker镜像的最底层是引导文件系统bootfs。这一层与我们典型的Linux/Unix系统是一样的，包含boot加载器和内核。当boot加载完成之后整个内核就都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs。
• Docker镜像层都是只读的，容器层是可写的
  • 当容器启动时，一个新的可写层被加载到镜像的顶部。 这一层通常被称作“容器层”，“容器层”之下的都叫“镜像层”

Docker的安装

Linux下载安装
http://get.daocloud.io/

安装docker环境依赖

yum install -y yum-utils device-mapper-persistent-data lvm2

yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
索引缓存

yum makecache fast

yum install docker-ce docker-ce-cli containerd.io -y

启动docker

systemctl start docker && systemctl enable docker

设置内核

vim /etc/sysctl.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
sysctl -p

一键安装

curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun

阿里云镜像加速器

如果不进行配置，很有可能会卡顿。这里建议使用阿里云镜像加速，免费的。

在阿里云中找到镜像加速，在路径/etc/docker/daemon.json 复制进去。

{
“registry-mirrors”: [“https://zamu0pih.mirror.aliyuncs.com“]
}
systemctl daemon-reload
systemctl restart docker

Docker run hello-world

当docker run 执行后，这个run都干了什么。

Docker命令

可以使用命令在dockerhub上进行搜索，默认也是dockerhub上搜索。

帮助类命令

docker version                 #镜像信息
docker 命令 --help           #查看帮助文档
docker info                   #docker信息

镜像命令

docker images    #列出本地镜像
REPOSITORY    TAG       IMAGE ID       CREATED        SIZE
wuhu/nginx      v1        04066b822951   24 hours ago   375MB

REPOSITORY：镜像仓库名称
TAG：镜像标签
IMAGE：镜像ID
CREATED：镜像创建时间
SIZE：大小

-a 列出所有镜像

-q 只显示镜像的ID

docker search centos        #搜索镜像        
--filter=START=3000 
docker pull centos:tag        #拉取/下载镜像
docker rmi -f neginx        #删除镜像
docker rmi -f ${docker images -aq} #递归删除所有镜像
systemctl daemon-reload && systemctl restart docker        #重启docker
docker load -i /root/centos.tar.gz            #解压镜像
docker save -o test.tar.gz centos:latest    #打包镜像

查看docker统计信息

docker system df
TYPE            TOTAL     ACTIVE    SIZE      RECLAIMABLE
Images          3         1         185.5MB   185.5MB (99%)
Containers      3         0         0B        0B
Local Volumes   0         0         0B        0B
Build Cache     0         0         0B        0B

容器类命令

拉取和运行

docker pull centos        #拉取镜像，有镜像才能运行容器
docker run [可选参数] images
#参数说明
--name="Name"    容器名称，nginx，tomcat1。
-d                后台运行
-it                使用交互方式运行/进入容器查看内容
-p                指定容器端口， 80:80
-P                随机指定端口
docker run -it centos /bin/bash    #以前台交互的模式启动并进入容器
docker run -d centos #以后台守护式启动
Ctrl + P + Q #退出容器并在后台运行

列出运行的容器

docker ps    #列出当前正在运行的容器
-a            #列出全部容器
-n [数字]        #列出最近的n个容器
-q            #只显示容器的编号

退出容器

exit        #退出容器
ctrl+P+Q    #退出并继续运行容器

删除容器

docker rmi 容器id                   #删除指定容器,但无法删除正在运行的容器
docker rmi -rf 容器id              #强制删除
docker rmi -f $(docker ps -aq)    #递归删除所有启动/启动过的容器
docker ps -a|xargs docker rmi    #递归删除所有容器

启动和停止容器

docker start|restart|stop|kill 容器id #启动|重启|停止|杀掉 容器

后台部署应用

docker run -d centos
#docker ps 会发现centos停止了！！！
#docker容器后台运行必须要有一个前台进程，docker发现没有应用就会自动停止。
#例如：nginx容器启动后，发现自己没有提供服务，就会立刻停止。

查看日志

docker logs 容器ID                #查看容器日志
docker logs -tf --tail 10 容器ID    #查看容器前10行的日志
--tail number    #显示日志条数

查看容器的进程信息

docker top 容器ID

查看镜像的源数据

docker inspect 容器ID

进入当前正在运行的容器

docker exec -it 容器ID /bin/bash    #以交互形式进入容器，类似新开一个界面
#exec 使用exit进入退出不会停止
docker attach -it 5d8e48e4b792     #进入正在运行的容器命令行
#attach 退出了会停止容器

镜像的保存与导入

docker save -o test.tar myapp:v0.1        #保存镜像
docker save fe8c52043b39 > test.tar        #保存镜像
#此时就会创建一个tar包，其中就是镜像文件
docker load < test.tar        #导入镜像
docker load -i test.tar        #导入镜像
#将tar包导入，就可以运行使用了。

容器文件拷贝到主机上

#在主机上输入该命令
docker cp 容器ID:文件路径    目的主机路径

容器备份与解压

备份运行时的容器镜像

docker export 517d619c4d55 > test.tar    #将你的整个容器做成tar备份
cat test.tar | docker import - test/redis:0.1    #将tar备份文件转换为可用镜像

命令总结

Docker部署应用

基于镜像启动容器

docker pull nginx                 #下载nginx镜像
docker run -d -p 80:80 nginx    #在后台运行nginx服务
curl localhost:80                 #查看是否启动成功

-d 在后台运行

-p 物理机80端口:容器实例的80端口 可以理解为绑定操作

访问正在运行的容器

docker exec -it 5d8e48e4b792 /bin/bash
exit #退出容器

/bin/bash:伪解析

类似进入到另一台虚拟机中，这台虚拟机运行的Nginx服务，通过上面命令进入了’虚拟机‘，所以也可以使用linxu中的命令！不建议docker中跑docker。

停掉容器

docker stop 5d8e48e4b792

搭建tomcat

#官方的下载
docker run -it --rm tomcat:9.0    #用完就删了，适合做测试
#下载，启动

Docker构建镜像

创建镜像文件

基于dockerfile构建镜像

docker pull centos            #拉取镜像源文件
mkdir dockerfile            #创建目录
cd !$                        #进入目录
vim dockerfile                #编辑dockerfile文件
FROM centos            #镜像源文件
MAINTAINER    LiAo    #镜像作者
RUN yum install wget -y        #执行命令
RUN yum install nginx -y
COPY index.html /usr/share/nginx/html/        #拷贝
EXPOSE 80        #端口
ENTRYPOINT ["/usr/sbin/nginx","-g","daemon off;"]        #当镜像启动时，执行的命令

构建镜像

docker build -t="liao/nginx:v1" . #以当前文件创建dockerfile镜像
docker run -d -p 80 --name html2 liao/nginx:v1 #运行容器镜像

• FROM：基础镜像，必须是可以下载下来的
• MAINTAINER：指定镜像的作者信息
• RUN：指定在当前镜像构建中运行的命令，包含两种模式
  • shell:
    • RUN yum install wget -y
  • exec模式：
    • RUN [“/bin/bash”,”-C”,”echo hello”]
• EXPOSE：声明端口。docker run 时 -P 会自动分配端口给容器端口
• CMD：为启动的容器指定默认要运行的程序，程序运行结束，容器也就结束。会被dockerrun命令行参数指令所覆盖。
• ENTRYPOINT：和cmd类似，但是不会被覆盖。并且命令行参数会被当做参数送给ENTRYPOINT指令的程序。如果指令较多，只有最后一个生效。
• COPY：复制命令。从目录中复制文件或者目录到指定路径
• ENV：定义环境变量
• ARG：和ENV差不多，但是作用域不一样。ARG只对Dockerfile内有效。只在docker run时有效。

Docker 镜像仓库

本地镜像发布到阿里云

创建自己的docker镜像容器，并且添加到阿里云。将阿里云当成了镜像仓库。

容器镜像服务 (aliyun.com)

创建个人实例

1.创建命名空间

命名空间可以自己随便输入，但是不能和别人重名，并且一个账号最多创建三个。

2.创建镜像仓库

创建镜像仓库，前面创建的命名空间就起作用了。

名称也是随便创建，摘要就是介绍信息。

3.添加镜像

创建成功后，按照阿里云上面的教程复制粘贴即可。就比如将镜像推动到Registry。按照要求输入即可。

注意：此处让输入的密码是设置的docker镜像密码，而不是阿里云密码。

搭建私有仓库

1.创建并运行本地镜像仓库

docker pull registry    #拉取镜像仓库容器
docker run -d -p 5000:5000 -v /liao/registry:/tmp/registry --privileged=true registry    #启动容器
curl -XGET http://192.168.200.135:5000/v2/_catalog    #查看容器是否启动成功

2.运行并创建新的容器

docker run -it 8f061e1523c3        #运行容器
docker commit -m="test" -a="里奥" d1c5a1cc1f13 ubuntu03:0.3    #创建新的容器
cat /etc/docker/daemon.json        #查看并添加本地仓库
{
  "registry-mirrors": ["https://zamu0pih.mirror.aliyuncs.com"],
  "insecure-registries": ["192.168.200.135:5000"]
}

3.添加到本地仓库

docker tag ubuntu03:0.3 192.168.200.135:5000/ubuntu033    #给镜像修改为合乎规范的标签
docker push 192.168.200.135:5000/ubuntu033    #push镜像
curl -XGET http://192.168.200.135:5000/v2/_catalog    #查看是否成功
{"repositories":["ubuntu033"]}

commit镜像

docker commit    提交容器成为一个新的副本，而不是覆盖他
#命令和git类似
docker commit -m="提交的信息" -a="作者" 容器id 目标镜像名:[TAG]
docker run -d --name=nginx1 -p 3316:80 nginx    #启动容器
#在容器里添加/删除一些文件做测试
docker commit -a="liao" -m="add txt" 08ba95feea02 tomcat02:v0.1
#打包镜像

Docker容器数据卷

想让容器与机器时间实现数据共享的技术。比如：数据可持久化，一些数据可以存储在本地。卷技术，可以挂载目录。但容器卷不属于联合文件系统，因此能够绕过Union File System提供一些用于持续存储或共享数据的特性将一些数据目录等挂载。卷的设计目的就是数据的持久化，完全独立于容器的生存周期，因此Docker不会在容器删除时删除其挂载的数据卷

如果是CentOS7安全模块会比之前系统版本加强，不安全的会先禁止，所以目录挂载的情况被默认为不安全的行为，在SELinux里面挂载目录被禁止掉了额，如果要开启，我们一般使用—privileged=true命令，扩大容器的权限解决挂载目录没有权限的问题，也即使用该参数，container内的root拥有真正的root权限，否则，container内的root只是外部的一个普通用户权限。

Docker挂载主机目录访问如果出现cannot open directory .: Permission denied

解决办法：在挂载目录后多加一个—privileged=true参数即可

容器卷能干嘛

将运用与运行的环境打包镜像，run后形成容器实例运行 ，但是我们对数据的要求希望是持久化的Docker容器产生的数据，如果不备份，那么当容器实例删除后，容器内的数据自然也就没有了。为了能保存数据在docker中我们使用卷。

特点：

1：数据卷可在容器之间共享或重用数据

2：卷中的更改可以直接实时生效，爽

3：数据卷中的更改不会包含在镜像的更新中

4：数据卷的生命周期一直持续到没有容器使用它为止

使用数据卷

docker run -it -v /home/ceshi:/home centos /bin/bash
#-v 挂载 
#将机器的/home/ceshi目录与/home建立连接。此时ceshi和home文件会同步
docker inspect c7436a235910    #查看是否挂载成功

创建数据卷的容器

#创建⼀个数据卷容器
docker create -v /data1 --name v-data1 nginx        # -v [容器数据卷⽬录]
#创建两个容器，同时挂载数据卷容器
docker run --volumes-from v-data1 -dti --name v01 nginx        #--volumes-from [数据卷容器id/name]
docker run --volumes-from v-data1 -dti --name v02 nginx

数据卷的映射规则

docker run -it --privileged=true -v /root/test:/tmp/myDockerData:rw ubuntu    #只给文件读写权限
rw:    读写
ro:    只读

卷的继承

有些时候可能要多开很多个镜像容器，但是容器卷很多时候要写很长，挨个写非常麻烦。所以这里有卷的继承。

docker run -it --privileged=true -v /tmp/u:tmp/docker/u --name u1 ubuntu        #新开一个容器，设置容器卷并且设置名称为u1
docker run -it --privileged=true -volume-form u1 --name u2 ubuntu    #新开一个容器，继承u1的容器卷配置。

如果u1(父容器)挂掉，u2(子容器)没任何影响，还是可以继续同步数据的。那怕突然间u1容器停止工作了，之后u1容器再打开，还是会自动同步数据文件的。

匿名挂载

FROM centos
VOLUME ["volume01","volume02"]        #挂载卷
CMD echo "---end---"
CMD /bin/bash
docker inspect 容器ID                    #查看硬盘.
#生成镜像
docker build -f /dockers/dockerfile1 -t="liao/centos" .

当创建镜像的时候，可以添加这样一行命令，就会自动挂载硬盘。

Docker基础示例

搭建nginx

docker search nginx    #搜索nginx
docker pull nginx    #拉取最新的nginx镜像
docker run -d --name nginxtest -p 3344:80 nginx        #在后台运行nginx镜像，命名为nginxname，容器的80端口绑定机器的3344端口。
docker ps            #查看是否启动
docker exec -it nginxtest /bin/bash    #进入容器

问题：如果需要修改nginx的配置，需要进入的容器的内部？！非常麻烦，如何在容器外部修改文件，使得内部也能修改。

答：使用数据卷技术

搭建tomcat

docker run -it tomcat:9.0    #运行并安装tomcat
docker run -it --rm tomcat:9.0        #运行并安装tomcat并且用完就删。
docker pull tomcat         #拉取tomcat
docker run -d -p 3355:8080 --name tomcat01 tomcat    #运行tomcat
docker exec -it tomcat01 /bin/bash                    #进入tomcat01容器
#此时访问网页没有任何东西，因为新版默认不再显示初始页面webapps是空的。此时可以将webapps.dist的内容复制到webapps中。

当然也有老版本的不需要修改：

docker pull billygoo/tomcat8-jdk8

docker run -d -p 8080:8080 --name mytomcat8 billygoo/tomcat8-jdk8

搭建Mysql

简单版

1.拉取镜像并运行镜像

docker pull mysql:5.7    #拉取镜像
docker run -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7    #启动镜像容器。
-e MYSQL_ROOT_PASSWORD=123456    #设置mysql密码

2.进入数据库创建数据

docker exec -it bd22a0c2dfe9 /bin/bash    #进入容器
mysql -uroot -p123456                    #进入容器中的mysql
create database db01;
use db01;
create table aa(id int,name varchar(20));
insert into aa values(1,"liao");

3.修改docker默认字符集编码

上面插入了 “liao” 是可以的。但是插入汉字就不行了，因为默认编码需要修改。

SHOW VARIABLES LIKE 'character%';    #查看默认字符
#在/var/mlysql/conf中创建my.cnf
[client]
default_character_set=utf8
[mysqld]
collation_server = utf8_general_ci
character_set_server = utf8

实战版

1.创建新的mysql容器

docker run -d -p 3306:3306 --privileged=true -v /liao/mysql/log:/var/log/mysql -v /liao/mysql/data:/var/lib/mysql -v /liao/mysql/conf:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=123456  --name mysql mysql:5.7

2.设置中文并重启

vim /liao/mysql/conf/my.cnf    #编辑该文件并添加如下内容
[client]
default_character_set=utf8
[mysqld]
collation_server = utf8_general_ci
character_set_server = utf8
docker restart mysql    #重启mysql容器使得配置生效。

搭建redis

1.拉取镜像并启动容器

docker pull redis:6.0.8        #拉取容器镜像
docker run -d -p 6379:6379 redis:6.0.8    #启动容器 
#进入容器
redis-cil    #代表没问题

2.设置自己的配置文件

mkdir -p /app/redis        #创建配置文件文件夹，数据卷要用
cd /app/redis            #进入文件夹
vim redis.conf            #生成配置文件，配置信息可以从网上或者容器里找。
docker run  -p 6379:6379 --name myr3 --privileged=true -v /app/redis/redis.conf:/etc/redis/redis.conf -v /app/redis/data:/data -d redis:6.0.8 redis-server /etc/redis/redis.conf
#启动容器

Docker高级

Mysql主从搭建

1.新建主从服务器容器实例 3307

docker run -p 3307:3306 --name mysql-master \
-v /mydata/mysql-master/log:/var/log/mysql \
-v /mydata/mysql-master/data:/var/lib/mysql \
-v /mydata/mysql-master/conf:/etc/mysql \
-e MYSQL_ROOT_PASSWORD=root  \
-d mysql:5.7

2.创建配置文件

cd /mydata/mysql-master/conf    #进入配置文件
vim my.cnf        #创建文件
[mysqld]
## 设置server_id，同一局域网中需要唯一
server_id=101 
## 指定不需要同步的数据库名称
binlog-ignore-db=mysql  
## 开启二进制日志功能
log-bin=mall-mysql-bin  
## 设置二进制日志使用内存大小（事务）
binlog_cache_size=1M  
## 设置使用的二进制日志格式（mixed,statement,row）
binlog_format=mixed  
## 二进制日志过期清理时间。默认值为0，表示不自动清理。
expire_logs_days=7  
## 跳过主从复制中遇到的所有错误或指定类型的错误，避免slave端复制中断。
## 如：1062错误是指一些主键重复，1032错误是因为主从数据库数据不一致
slave_skip_errors=1062
docker restart mysql-master    #重启容器

3.配置主从信息

docker exec -it mysql-master /bin/bash        #进入容器
mysql -uroot -proot                #进入数据库
CREATE USER 'slave'@'%' IDENTIFIED BY '123456';        #创建数据同步用户
GRANT REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'slave'@'%';

4.新建从服务器容器实例3308

docker run -p 3308:3306 --name mysql-slave \
-v /mydata/mysql-slave/log:/var/log/mysql \
-v /mydata/mysql-slave/data:/var/lib/mysql \
-v /mydata/mysql-slave/conf:/etc/mysql \
-e MYSQL_ROOT_PASSWORD=root  \
-d mysql:5.7

5.创建配置文件

vim /mydata/mysql-slave/conf/my.cnf        #创建配置文件
[mysqld]
## 设置server_id，同一局域网中需要唯一
server_id=102
## 指定不需要同步的数据库名称
binlog-ignore-db=mysql  
## 开启二进制日志功能，以备Slave作为其它数据库实例的Master时使用
log-bin=mall-mysql-slave1-bin  
## 设置二进制日志使用内存大小（事务）
binlog_cache_size=1M  
## 设置使用的二进制日志格式（mixed,statement,row）
binlog_format=mixed  
## 二进制日志过期清理时间。默认值为0，表示不自动清理。
expire_logs_days=7  
## 跳过主从复制中遇到的所有错误或指定类型的错误，避免slave端复制中断。
## 如：1062错误是指一些主键重复，1032错误是因为主从数据库数据不一致
slave_skip_errors=1062  
## relay_log配置中继日志
relay_log=mall-mysql-relay-bin  
## log_slave_updates表示slave将复制事件写进自己的二进制日志
log_slave_updates=1  
## slave设置为只读（具有super权限的用户除外）
read_only=1
docker restart mysql-slave    #重启容器

6.配置主从复制

docker exec -it mysql-slave /bin/bash    #进入容器
mysql -uroot -proot    #进入数据库
change master to master_host='宿主机ip', master_user='slave', master_password='123456', master_port=3307, master_log_file='mall-mysql-bin.000001', master_log_pos=617, master_connect_retry=30;
show master status;        #在数据库中查看主从同步状态
show slave status \G;    #在从数据库中查看主从同步状态
start salve;            #在从数据库中开启主从同步

Portainer可视化面板

docker run -d -p 8088:9000 \
> --restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer

Dockerfile

1：每条保留字指令都必须为大写字母且后面要跟随至少一个参数

2：指令按照从上到下，顺序执行

3：#表示注释

4：每条指令都会创建一个新的镜像层并对镜像进行提交

构建流程：

1. docker从基础镜像运行一个容器
2. 执行一条命令并对容器做出修改
3. 执行类似docker commit的操作提交一个新的镜像层
4. docker再基于刚提交的镜像运行一个新容器
5. 执行dockerfile中的下一条命令知到所有命令都执行完毕

从应用软件的角度来看，Dockerfile、Docker镜像与Docker容器分别代表软件的三个不同阶段，

• Dockerfile是软件的原材料

• Docker镜像是软件的交付品

• Docker容器则可以认为是软件镜像的运行态，也即依照镜像运行的容器实例

Dockerfile面向开发，Docker镜像成为交付标准，Docker容器则涉及部署与运维，三者缺一不可，合力充当Docker体系的基石。

dockerfile命令

CMD和ENTRYPOINT的区别

CMD：追加命令是直接占用了CMD整个占位符

CMD常用来写在最后，然后用来启动服务。比如安装好了tomcat，最后用CMD启动脚本。

#运行完镜像后，执行ls -a命令
FROM centos
CMD ["ls","-a"]
docker build -t centos-test:v0.1 -f Dockerfile .    #构建镜像
docker run -d 7149c87c748f        #此时运行就是启动了centos 并且在其中执行命令ls -a    
docker run -d 7149c87c748f /bin/bash    #此时运行就是启动了centos,并且在其中执行命令 /bin.bash

ENTRYPOINT：追加命令只是占用了“-a”的占位符

FROM centos
ENTRYPOINT ["mc.sh","start"]
docker run -d 7149c87c748f    #此时运行就是启动了centos，并且默认执行mc.sh的start内部脚本    mc.sh start
docker run -d 7149c87c748f log    #此时运行就是启动centos，并且执行了mc.sh的log内部脚本        mc.sh log

实例：构建centos

1.创建文件并准备需要用到的安装包

mkdir -p /root/dockerfile    #创建文件夹
cd /root/dockerfile
vim Dockerfile    #创建Dockerfile,这里D要大写
FROM centos        #指定使用的镜像
MAINTAINER liao        #指定作者
ENV MYPATH /usr/local    #创建变量
WORKDIR $MYPATH        #设置工作路径
RUN yum install -y vim net-tools glibc.i686        #安装工具包
RUN mkdir /usr/local/java    #创建文件夹
ADD jdk-17_linux-x64_bin.tar.gz /usr/local/java    #添加并解压压缩包到指定文件夹
ENV JAVA_HOME /usr/local/java/jdk-17.0.2    #设置变量
ENV JRE_HOME /usr/local/java/jre
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib:$CLASSPATH
ENV PATH $JAVA_HOME/bin:$PATH
EXPOSE 80    #设置端口
CMD echo $MYPATH
CMD echo "success-----------ok"
CMD /bin/bash

虚悬镜像node

在构建或者删除镜像的时候出现了错误，导致镜像仓库和标签都为none。

docker images ls -f dangling=true #查看所有的虚悬镜像

docker image prune #删除所有的虚悬镜像

实例：构建tomcat

1. 准备tomcat压缩包和jdk压缩包
   
2. 编写dockerfile文件
   ```shell FROM centos #指定基础包 MAINTAINER liao1182350036@qq.com #作者信息 COPY readme.txt /usr/local/readm.txt #复制文件到容器路径 /usr/local/readm.txt

ADD jdk-8u301-linux-x64.tar.gz /usr/local/ #添加并解压文件到 /usr/local/ ADD apache-tomcat-8.5.70.tar.gz /usr/local/

RUN yum install vim net-tools -y

ENV MYPATH /usr/local #配置环境变量 WORKDIR $MYPATH #设置工作目录

ENV JAVA_HOME /usr/local/jdk1.8.0_301 #设置变量 ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar ENV CATALINA_HOME /usr/local/apache-tomcat-8.5.70 ENV CATLINA_BASH /usr/local/apache-tomcat-8.5.70 ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

EXPOSE 8080

CMD /usr/local/apache-tomcat-8.5.70/bin/startup.sh && tail -F /usr/local/apache-tomcat-8.5.70.tar.gz/bin/logs/catalina.out

3.  启动镜像  
```shell
docker run -d -p 9090:8080 --name tomcats123 -v /dockers1/tomcat/:/usr/local/apache-tomcat-8.5.70/webapps/tomcat -v /dockers1/tomcatlogs/:/usr/local/apache-tomcat-8.5.70/logs da668652083f

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
</web-app>

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
   <title>docker</title>
</head>
<body>
   <h3>hello,docker</h3>
   <%
       System.out.println("hello, dockerlogs");
   %>
</body>
</html>

未完成案例:创建服务器

FROM centos:centos7
MAINTAINER LiAo
RUN curl -o /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-7.repo && \
yum install -y java
ADD Paper-1.12.2_log4j2Fixed.jar /usr/local/
WORKDIR /usr/local/
RUN echo "java -Xms256M -Xmx1024M -jar -XX:+AggressiveOpts Paper-1.12.2_log4j2Fixed.jar" > start.sh && \
chmod u+x start.sh && \
./start.sh
RUN sed -i "s/eula=false/eula=true/g" eula.txt
RUN sed -i "s/online-mode=true/online-mode=false/g" server.properties
EXPOSE 25565
CMD ./start.sh        #因为要启动时打开，所以使用CMD

Docker微服务实战

Docker网络★

关于virbr0网卡

在CentOS7的安装过程中如果有选择相关虚拟化的的服务安装系统后，启动网卡时会发现有一个以网桥连接的私网地址的virbr0网卡(virbr0网卡：它还有一个固定的默认IP地址192.168.122.1)，是做虚拟机网桥的使用的，其作用是为连接其上的虚机网卡提供 NAT访问外网的功能。

我们之前学习Linux安装，勾选安装系统的时候附带了libvirt服务才会生成的一个东西，如果不需要可以直接将libvirtd服务卸载，yum remove libvirt-libs.x86_64。

docker启动后，会有一个虚拟网桥，docker0

Docker网络模式

docker network ls    #列出网络

docker network create liao_network    #创建网络
docker network rm liao_network    #删除网络

docker network inspect bridge    #查看网络数据源

Docker网络能干嘛

容器间的互联和通信以及端口映射

容器IP变动时候可以通过服务名直接网络通信而不受到影响

网络模式(详细)

bridge模式：使用—network bridge指定，默认使用docker0

host模式：使用—network host指定

none模式：使用—network none指定

container模式：使用—network container:NAME或者容器ID指定

场景举例：

新建容器u1 u2 分配了02和03ip段。如果u2宕机了，新建了u3，此时u3的ip又是03了，但是u3此时又不是跑u2服务的话。就出问题了。

Bridge

Docker 服务默认会创建一个 docker0 网桥（其上有一个 docker0 内部接口），该桥接网络的名称为docker0，它在内核层连通了其他的物理或虚拟网卡，这就将所有容器和本地主机都放到同一个物理网络。Docker 默认指定了 docker0 接口 的 IP 地址和子网掩码，让主机和容器之间可以通过网桥相互通信。

• Docker使用Linux桥接，在宿主机虚拟一个Docker容器网桥(docker0)，Docker启动一个容器时会根据Docker网桥的网段分配给容器一个IP地址，称为Container-IP，同时Docker网桥是每个容器的默认网关。因为在同一宿主机内的容器都接入同一个网桥，这样容器之间就能够通过容器的Container-IP直接通信。
• docker run 的时候，没有指定network的话默认使用的网桥模式就是bridge，使用的就是docker0。在宿主机ifconfig,就可以看到docker0和自己create的networketh0，eth1，eth2……代表网卡一，网卡二，网卡三……，lo代表127.0.0.1，即localhost，inet addr用来表示网卡的IP地址
• 网桥docker0创建一对对等虚拟设备接口一个叫veth，另一个叫eth0，成对匹配。
  • 整个宿主机的网桥模式都是docker0，类似一个交换机有一堆接口，每个接口叫veth，在本地主机和容器内分别创建一个虚拟接口，并让他们彼此联通（这样一对接口叫veth pair）；
  • 每个容器实例内部也有一块网卡，每个接口叫eth0；
  • docker0上面的每个veth匹配某个容器实例内部的eth0，两两配对，一一匹配。

通过上述，将宿主机上的所有容器都连接到这个内部网络上，两个容器在同一个网络下,会从这个网关下各自拿到分配的ip，此时两个容器的网络是互通的。

Host

直接使用宿主机的 IP 地址与外界进行通信，不再需要额外进行NAT 转换。

容器将不会获得一个独立的Network Namespace， 而是和宿主机共用一个Network Namespace。容器将不会虚拟出自己的网卡而是使用宿主机的IP和端口。

docke启动时总是遇见标题中的警告

docker启动时指定—network=host或-net=host，如果还指定了-p映射端口，那这个时候就会有此警告，并且通过-p设置的参数将不会起到任何作用，端口号会以主机端口号为主，重复时则递增。可以直接无视/不使用-p/使用network=host。

会发现我们网关IP啥都没。

none

就是没有网络。在none模式下，并不为Docker容器进行任何网络配置。 也就是说，这个Docker容器没有网卡、IP、路由等信息，只有一个lo需要我们自己为Docker容器添加网卡、配置IP等。使用情况较少。
使⽤none模式，Docker容器拥有⾃⼰的Network Namespace，但并不为Docker容器进行任何网络配置。这个Docker容器没有网卡、IP、路由等信息。需要我们自己为 Docker容器添加网卡卡、配置IP等。
这种⽹络模式下容器只有lo回环⽹络，没有其他⽹卡。none模式可以在容器创建时通过— network=none来指定。这种类型的⽹络没有办法联⽹，封闭的⽹络能很好的保证容器的安全性。

container

新建的容器和已经存在的一个容器共享一个网络ip配置而不是和宿主机共享。新创建的容器不会创建自己的网卡，配置自己的IP，而是和一个指定的容器共享IP、端口范围等。同样，两个容器除了网络方面，其他的如文件系统、进程列表等还是隔离的。
但是容器之间不能有相同的ip和相同的端口。
简单来说就是两个容器AB都使用A容器的eth0网卡连接的网络。

如果A容器无了，B容器的网络也就无了。

自定义网络模式

如果使用默认网桥网络，容器之间能用ip进行互相通信，但是不能通过—name设置的名称通信。

但是创建了自定义网络就不一样了，就可以使用设置的名称通信了。

docker network create liao_network    #创建网络
#此时开启两个容器，设置网卡为liao_network。就可以使用名称互相ping通了

自定义网络本身就维护好了主机名和ip的对应关系（ip和域名都能通）

Docker Compose

Compose 是 Docker 公司推出的一个工具软件，可以管理多个 Docker 容器组成一个应用。你需要定义一个 YAML 格式的配置文件docker-compose.yml，写好多个容器之间的调用关系。然后，只要一个命令，就能同时启动/关闭这些容器

1. Dcokerfile build run 手动操作，并且一次是单个容器。
2. 可以使用Docker Compose轻松高效管理多个容器，定义运行多个容器。
3. Docker Compose 并不是docker自带的，只是他的开源项目，需要自行安装

下载

1. 下载

   curl -L https://get.daocloud.io/docker/compose/releases/download/1.29.2/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

2. 赋予权限

   chmod +x /usr/local/bin/docker-compose

github下载

https://github/docker/compose/releases/tags 选择最新版
下载docker-compose-linux-x86_64
chmod +x docker-compose-linux-x86_64
mv docker-compose-linux-x86_64 /usr/bin/docker-compose

docker-compose核心概念

• 一个文件
  • dockercompose-yml
• 两个要素
  • 服务——一个个应用容器实例，比如订单微服务、库存微服务、mysql容器、nginx容器或者redis容器
  • 工程——由一组关联的应用容器组成的一个完整业务单元，在 docker-compose.yml 文件中定义。

compose使用三个步骤

• 编写Dockerfile定义各个微服务应用并构建出对应的镜像文件
• 使用 docker-compose.yml 定义一个完整业务单元，安排好整体应用中的各个容器服务。
• 最后，执行docker-compose up命令 来启动并运行整个应用程序，完成一键部署上线

compose常用命令

compose编排服务

编写流程：

版本号——服务——容器名称——镜像——端口映射——环境变量——数据卷——设置自启——是否暴露端口——是否需要依赖——是否执行命令

1.编写服务

version: "3.8"        #设置版本
services:    #compose中的容器叫做服务，所以这里写service
 tomcat01:    #容器(服务)名称
  container_name: tomcat1    #指定一个容器的名称 类似 --name
  image: tomcat        #指定将要run的容器镜像    
  ports:            #指定映射的端口号 类似-p
    - "8080:8080"    #端口添加冒号，方便识别
 mysql01:
  image: mysql:5.7
  ports:
   - "3306:3306"
  environment:    #设置环境变量 类似-e
   - "MYSQL_ROOT_PASSWORD=root"
  volumes:        #代表当前的容器和宿主机指定数据卷 类似于 -v
   - /root/mydatabase:/var/lib/mysql
   - mysqlData:/var/lib/test
volumes:
 mysqlData:        #声明数据卷别名

2.启动编排的服务

docker-compose up -d    #启动服务，以后台方式启动。

3.其他指令

Compose 模板文件 - Docker —— 从入门到实践 (gitbook.io)

• build 指令 通过docker-compose 在启动容器之前现根据dockerfile构建镜像，然后根据构建镜像启动容器。
  • 当然有时候文件并不是Dockerfile，我们就需要添加额外参数：context dockerfile
• command 覆盖容器启动后默认执行的命令
• container_name 用来指定docker-compose启动容器名称 不推荐
• depends_on 解决容器的依赖，启动先后的问题。比如有些服务必须要用mysql，设置后会先启动mysql，再启动当前的服务，但也不是完全启动只是一个优先级。
• cgroup_parent 指定父 cgroup 组，意味着将继承该组的资源限制。
• devices 指定设备映射关系。和volumes有点类似
• dns 自定义 DNS 服务器。可以是一个值，也可以是一个列表。
• tmpfs 挂载一个 tmpfs 文件系统到容器。
• env_file 从文件中获取环境变量，可以为单独的文件路径或列表。
  如果通过 docker-compose -f FILE 方式来指定 Compose 模板文件，则 env_file 中变量的路径会基于模板文件路径。
  如果有变量名称与 environment 指令冲突，则按照惯例，以后者为准。
• expose 暴露端口，但不映射到宿主机，只被连接的服务访问。仅可以指定内部端口为参数
• extra_hosts 类似 Docker 中的 --add-host 参数，指定额外的 host 名称映射信息。会在启动后的服务容器中 /etc/hosts 文件中添加两条条目。
• labels 为容器添加 Docker 元数据（metadata）信息。例如可以为容器添加辅助说明信息。
• networks 用来指定容器使用网桥。 如果没有会自动创建。类似 —network
• secrets 存储敏感数据，例如 mysql 服务密码。
• sysctls 配置容器内核参数。
• user 指定容器中运行应用的用户名。
• privileged: true 允许容器中运行一些特权命令。
• restart: always 指定容器退出后的重启策略为始终重启。该命令对保持服务始终运行十分有效，在生产环境中推荐配置为 always 或者 unless-stopped。

version: "3.8"
services:
    apps:
     builds: /root/test        #填写有dockerfile的文件夹,进行构建镜像并运行
    liaoblog:
     builds:
      context: ./    #用来指定Dockerfile上下文目录
      dockerfile: liaodockerfile    #填写dockerfile文件名称
      depends_on:     #设置依赖的服务
       - apps
      dns: 114.114.114.114    #设置DNS
      network:    #设置网卡信息，如果没有会自动创建
       - liaonet
      lables:    #添加一条提示信息。
       "这是一条提示信息"
      command: ["ls -l"]    #当容器运行完毕后执行的命令 类似 CMD []

compose命令说明

命令使用说明

docker-compose up

• 他将尝试自动完成包括构建镜像，重新创建服务，启动服务，并关联服务相关容器的一系列操作。
• 链接的服务都将会被自动启动，除非已经处于运行转态
• 大部分时候都可以通过该命令来启动一个项目
• 默认情况，up都是显示在前台，会打印控制台的所有信息
• Ctrl+c 停止命令 所有容器将会停止
• 后面加上 -d 则是后台运行。此时看不到输出信息，需要自行用其他命令看容器是否启动
• 如果服务都存在，up命令则是尝试停止容器，并且重新创建。

docker-compose down

• 关闭所有容器
• 会停止up所启动的容器，并移除网络

docker-compose exec

• 进入指定容器 docker-compose exec tomcat bash
• 和命令 docker exec -it tomcat bash 一样

docker-compose ps

• 列出项目中目前的所有容器

docker-compose restart

• 重启项目中的服务
• -t 秒数 在指定时间后重启

docker-compose rm

• 删除项目中所有容器，建议先stop 再删除。
• -f 强制删除，不建议
• -v 删除服务的数据卷 很少会用到

docker-compose top

• 查看各个服务器内运行的进程

docker-compose unpause/pause

• 恢复/暂停项目中的服务
• 后面加上 【服务ID 】对某个服务进行操作

docker-compose logs

• 查看项目的服务运行日志
• 也可以查看指定服务ID的运行日志，-f 实时显示

Portainer

https://www.portainer.io/
一个第三方开源的项目，一款轻量级的应用，提供了图像化界面，将docker引擎所有容器进行可视化的展示。包括单机和集群环境。集群了建议k8s。

Protainer安装与配置

docker pull portainer/portainer        #获取镜像
docker run -d -p 8000:8000 -p 9000:9000 --name=protainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer    #启动镜像

从浏览器进入ip:9000,设置密码，本地local登录。

选择Local本地

该页面就是docker system df命令图形化。

操作容器

查看容器

创建容器

私有Harbor搭建

Docker容器应用的开发和运行离不开可靠的镜像管理，虽然Docker官方也提供了公共的镜像仓库，但是从安全和效率等方面考虑,部署我们私有环境内的Registry也是非常必要的。Harbor是由VMware公司开源的企业级的Docker Registry管理项目，它包括权限管理(RBAC)、LDAP、日志审核、管理界面、自我注册、镜像复制和中文支持等功能。

功能介绍

Harbor安装

Harbor官网 https://goharbor.io/
按照官网的流程来下载安装即可。

到github或者镜像网站，下载harbor安装包。https://github.com/goharbor/harbor/releases

cd /usr/local/
tar -zxf harbor-offline-installer-v2.5.0.tgz        #解压
cp harbor.yml.tmpl harbor.yml        #复制一份配置文件

1.生成CA证书私钥。

openssl genrsa -out ca.key 4096

2.生成CA证书。

openssl req -x509 -new -nodes -sha512 -days 3650 \
 -subj "/C=CN/ST=Beijing/L=Beijing/O=example/OU=Personal/CN=192.168.218.170" \        #CN= 这里写域名或者你的IP
 -key ca.key \
 -out ca.crt

3.生成服务器证书

生成CA证书私钥。

openssl genrsa -out 192.168.218.170.key 4096            #写域名或者你的IP

生成证书签名请求(CSR)。

openssl req -sha512 -new \
    -subj "/C=CN/ST=Beijing/L=Beijing/O=example/OU=Personal/CN=192.168.218.170" \
    -key 192.168.218.170.key \
    -out 192.168.218.170.csr

生成x509 v3扩展文件。

cat > v3.ext <<-EOF
authorityKeyIdentifier=keyid,issuer
basicConstraints=CA:FALSE
keyUsage = digitalSignature, nonRepudiation, keyEncipherment, dataEncipherment
extendedKeyUsage = serverAuth
subjectAltName = IP:192.168.218.170
EOF

使用v3.ext文件来为您的Harbor主机生成证书。

openssl x509 -req -sha512 -days 3650 \
    -extfile v3.ext \
    -CA ca.crt -CAkey ca.key -CAcreateserial \
    -in 192.168.218.170.csr \
    -out 192.168.218.170.crt

4.向Harbor和Docker提供证书

将服务器证书和密匙复制到Harbor主机上的证书文件夹中。

mkdir -p /data/cert/    #创建文件
cp 192.168.218.170.crt /data/cert/
cp 192.168.218.170.key /data/cert/

将 192.168.218.170.crt 转换为 192.168.218.170.cert, 供Docker使用。

openssl x509 -inform PEM -in 192.168.218.170.crt -out 192.168.218.170.cert

将服务器证书、密钥和CA文件复制到Harbor主机的Docker证书文件夹中。您必须首先创建适当的文件夹。

cp 192.168.218.170.cert /etc/docker/certs.d/192.168.218.170/
cp 192.168.218.170.key /etc/docker/certs.d/192.168.218.170/
cp ca.crt /etc/docker/certs.d/192.168.218.170/

5.修改配置文件并安装启动

systemctl restart docker        #重启docker
#需要修改的：
hostname: 192.168.218.170
certificate: /data/cert/192.168.218.170.crt
  private_key: /data/cert/192.168.218.170.key
  external_url: https://192.168.218.170
data_volume: /data/harbor
sh install.sh        #即可自动安装
#其本身就是使用docker安装，所以会生成docker-compose
#会占用443 80 1514 端口。

使用浏览器访问：
用户名：admin
密码： Harbor12345

Harbor使用

创建项目

项目名称：无要求，上传镜像时需要写
访问级别：当项目设为公开后，任何人都有此项目下镜像的读权限。命令行用户不需要“docker login”就可以拉取此项目下的镜像。
存储容量：-1时为无上限。
镜像代理：开启此项，以使得该项目成为目标仓库的镜像代理.仅支持DockerHub,Docker Registry, Harbor,Aws ECR,AzureACR,Quay 和Google GCR类型的仓库

创建用户

给项目添加用户

登录到harbor并推送镜像

docker login 192.168.218.170 --username=test1    #登录Harbor服务器并使用test1账号
Password: 
WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store
Login Succeeded
docker tag nginx:latest 192.168.218.170/test1/nginx:1.0    #生成新的镜像样式
docker push 192.168.218.170/test1/nginx:1.0            #因为前面已经登录了账号，所以此时推送直接推送到了Harbor中。

从harbor拉取镜像

docker rmi 192.168.218.170/test1/nginx:1.0        #删除制作的镜像
docker pull 192.168.218.170/test1/nginx@sha256:ee89b00528ff4f02f2405e4ee221743ebc3f8e8dd0bfd5c4c20a2fa2aaa7ede3    #直接拉取
#因为是本地 速度很快。

CIG容器监控系统

CAdvisor+InfluxDB+Granfana

docker stats        #查看当前运行中容器的状态
CONTAINER ID   NAME        CPU %     MEM USAGE / LIMIT     MEM %     NET I/O           BLOCK I/O         PIDS
4e50294f3b5a   nginx1      0.00%     1.984MiB / 1.777GiB   0.11%     2.24kB / 1.62kB   8.19kB / 15.4kB   3
64006c9c8bcf   protainer   0.00%     12.52MiB / 1.777GiB   0.69%     554kB / 6.63MB    0B / 4.58MB       9
#容器ID                名称                    CPU占用        使用内存/分配内存                占用百分比        I/O

我们需要可视化界面查看容器状态
docker stats 就可以看到很多信息，并且一般小公司就够用了
但是
docker stats 统计结果只能是当前宿主机的全部容器，数据资料是实时的，没有地方存储、没有健康指标过线预警等功能。

CAdvisor 收集

CAdvisor是一个容器资源监控工具,包括容器的内存,CPU,网络IO,磁盘Io等监控同时提供了一个WEB页面用于查看容器的实时运行状态。CAdvisor默认存储2分钟的数据,而且只是针对单物理机。不过，CAdvisor提供了很多数据集成接口,支持InfluxDB,Redis,Kafka,Elasticsearch等集成,可以加上对应配置将监控数据发往这些数据库存储起来。

InfluxDB 存储

Granfana 分析

虽然有三个，但是并不需要我们逐个搭建，只需要compose。

version: '3.1'
volumes:
        grafana_data: {}
services:
        influxdb:
          image: tutum/influxdb:0.9
          restart: always
          environment:
            - PRE_CREATE_DB=cadvisor
          ports:
            - "8083:8083"
            - "8086:8086"
          volumes:
            - ./data/influxdb:/data
        cadisor:
          image: google/cadvisor
          links:
            - influxdb:influxsrv
          command:
            - storage_driver=influxdb
            - storage_driver_db=cadvisor
            - storage_driver_host=influxsrv:8086
          restart: always
          ports:
            - "8080:8080"
          volumes:
            - /:/rootfs:ro
            - /var/run:/var/run:rw
            - /sys:/sys:ro
            - /var/lib/docker/:/var/lib/docker:ro
        grafana:
          user: "104"
          image: grafana/grafana
          user: "104"
          restart: always
          links: 
            - influxdb:influxsrv
          ports:
            - "3000:3000"
          volumes:
            - grafana_data:/var/lib/grafana
          environment:
            - HTTP_USER=admin
            - HTTP_PASS=admin
            - INFLUXDB_HOST=influxsrv
            - INFLUXDB_PORT=8086
            - INFLUXDB_NAME=cadvisor
            - INFLUXDB_USER=root
            - INFLUXDB_PASS=root