docker

目录

• 1.Docker概述
  • 1.1Docker为什么会出现
  • 1.2传统打包方式与Docker打包方式的对比
• 2.Docker的历史
  • 2.1聊一聊docker
  • 2.2docker能做什么
• 3.Docker的安装
  • 3.1Docker的基本组成（名词概念）
    • 3.1.1Client(客户端)
    • 3.1.2Dockerhost（服务器）
      • iamges 镜像（类）
      • containers 容器（对象）
    • 3.1.3Registry（仓库）
  • 3.2安装docker
  • 3.3配置阿里云镜像加速
  • 3.4回顾HelloWorld流程
  • 3.5底层原理
• 4.docker的常用命令
  • docker命令
  • 4.1帮助命令
  • 4.2镜像命令
    • docker images 查看所有本地主机上的镜像
    • docker search 搜索镜像
    • docker pull 下载镜像
    • 删除镜像 docker rmi
  • 4.3容器命令
    • docker update 更新容器的设置
    • 新建容器并启动
    • 退出容器
    • 列出所有正在运行的容器 docker ps
    • 删除容器
    • 启动和停止容器的操作
    • 常用的其他命令
    • docker命令小结
• 5.安装练习
  • 5.1docker安装nginx
  • 5.2docker安装tomcat
  • 5.3部署ES+kibana
• 6.可视化
  • 6.1什么是portainer？
• 7.Docker镜像详解
  • 7.1镜像是什么？
  • 7.2Docker镜像加载原理
  • 7.3分层理解
  • 7.4commit镜像
• 8.容器数据卷
  • 8.1什么是容器数据卷
  • 使用数据卷
  • 实战：安装MySQL并同步数据
  • 具名挂载和域名挂载
  • 初识dockerfile
  • 数据卷容器
    • 多个mysql实现数据共享
• 9.DockerFile
  • 9.1DockerFile介绍
  • 9.2Dockerfile构建过程
• 表示注释
  • 9.3dockerfile的指令
  • 构建一个centos
• 10.Docker网络

1.Docker概述

1.1Docker为什么会出现

• 一款产品：开发--》上线，需要两套环境！应用环境，应用配置！

• 开发---运营之间产生问题：我在我的电脑上可以运行！版本更新导致服务不可用！对于运维就很难

• 开发即运维！

• 环境配置十分麻烦，每一个机器都要部署环境（集群Redis、ES、Hadoop。。。）---费时费力。

1.2传统打包方式与Docker打包方式的对比

• 原来发布一个项目是发布：jar（需要Redis，MySQL，JDK，ES环境），需要单独配置
• 现在发布一个项目是发布：jar+（Redis，MySQL，JDK，ES环境），发布一个整体（项目带上环境安装打包），不需要在进行二次配置
• 之前在服务器配置一个应用的环境例如Redis，MySQL，jdk，ES等配置超麻烦，不能跨平台
• 传统：开发--》jar，运维—》部署
• 现在：开发打包部署上线，一套流程做完
• docker给以上问题，提出了解决方案
  • 类比手机应用APK，docker：Java---jar（环境）---打包项目带上环境（镜像）----（docker仓库：“类比为商店或maven仓库”）---下载我们发布的镜像----直接运行即可
  • docker的思想来源于集装箱
    
    原来一些软件一起部署可能会发生冲突（比如端口冲突），各个应用之间是交叉的，共用一套环境
    如何解决？
    隔离：docker核心思想！类比于集装箱，所有应用打包装箱互相隔离，和集装箱一样，以后不用担心相互产生冲突
    -----docker通过隔离机制，可以将服务器利用到极致
    -----之前配置很麻烦的MySQL集群，redis集群就可以一键安装了

2.Docker的历史

• 2010年，几个搞IT的年轻人在美国成立了一家公司dotcloud
  • 最开始是做一些pass的云计算服务！
  • pass：linux虚拟机有关的容器技术
  • 他们将自己的技术（容器化技术）命名就是docker！
  • docker为什么这么火？十分轻巧
    • 在容器技术出来之前，我们都是使用虚拟机技术！
    • 在windows中按钻过一个vmware，通过这个软件我们可以虚拟出一台或则多台电脑！十分笨重
    • docker的容器技术也是一种虚拟化技术
      vm: x需要一个原生镜像（一个电脑）产生隔离：需要多台虚拟机 几个G 几分钟启动
产生隔离: 镜像（最核心的环境 4M+jdk+mysql）十分小巧，运行镜像就可以了(其余部件都是使用宿主机的) 几M 开机秒级启动

2.1聊一聊docker

• docker是基于go语言开发的开源项目
  官网
  官方文档docker的文档是超级详细的！
  仓库地址（docker hub） git push pull 镜像

2.2docker能做什么

之前的虚拟机技术：运行环境（lib）公用

虚拟机技术缺点：

1. 资源占用十分多
2. 冗余步骤多
3. 启动很慢

lib： 运行环境
kernel：内核

容器化技术：单独的运行环境（lib）

容器化技术不是模拟的一个完整的操作系统

比较Docker和虚拟机技术的不同

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

DevOps（开发、运维）

应用更快速的交互和部署
传统：一堆帮助文档，安装程序
Docker：一键运行打包镜像发布测试，一键运行

• 满足应用更快速的交互和部署
• 便捷的额升级和扩缩容
  更便捷的升级和扩容

• 使用了docker之后，部署应用就像搭积木一样
  比如项目打包为一个镜像，扩展服务器A！（性能到瓶颈了需要做负载均衡），服务器B（直接在服务器b上一键运行服务器A所在的镜像），就被扩展起来了，而不需要一个个的配置环境，
• 一个虚拟机能运行很多个容器，容器之间也能交互
  更简单的系统运维
  在容器化之后，我们的开发，测试环境都是高度一致的。
  更高效的计算支援利用
  1核2g的服务器可以运行几十个redis
  docker是内核级别的虚拟化，可以在一个物理机上运行很多的容器实例！服务器的性能可以被压榨到极致

3.Docker的安装

3.1Docker的基本组成（名词概念）

客户端的指令要在服务器运行，进入docker deamon（docker的守护进程），守护进程运行指令要首先通过images（镜像），镜像好比Java的class，而运行起来后产生的容器就相当于类运行产生的对象，通过多个容器可以搭载一个集群，但是本质上还是通过镜像来运行的，而镜像支援来自于网络仓库

3.1.1Client(客户端)

docker build 构建一个容器
docker pull 拉取一个容器
docker run 运行一个容器

3.1.2Dockerhost（服务器）

docker daemon（docker的守护进程）main方法（不是很恰当）

iamges 镜像（类）

docker镜像就好比是一个模板，可以通过这个模板来创建容器服务，tomcat镜像>run>romcat01容器(提供服务器)，可以通过这个镜像创建多个容器。（最终服务运行就是在容器中的）

containers 容器（对象）

docker利用容器技术，独立运行一个或则一组应用，通过镜像来创建的。容器可以 启动、停止、删除

目前就可以把这个容器理解为一个简易的linux系统

3.1.3Registry（仓库）

存储image镜像
仓库分为公有仓库和私有仓库
docker hub类似于git hub

docker hub（默认是国外的）
阿里云、腾讯云等等。。。都有容器服务器（配置镜像加速）

3.2安装docker

环境准备

1. 需要会一点点的Linux基础
2. CentOS 7
3. 使用Xshell连接远程服务器进行操作

环境查看

#系统内核是 3.10以上的
[root@izbp1cu6acsu857v0gt1v5z ~]# uname -r
3.10.0-1127.19.1.el7.x86_64

系统版本

安装

查看帮助文档

# 卸载旧的版本
$  yum remove docker 
                  docker-client 
                  docker-client-latest 
                  docker-common 
                  docker-latest 
                  docker-latest-logrotate 
                  docker-logrotate 
                  docker-engine

# 需要的安装包
$  yum install -y yum-utils

# 设置镜像的仓库
$  yum-config-manager 
    --add-repo 
    https://download.docker.com/linux/centos/docker-ce.repo ##默认是国外的，非常慢
    http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo  /推荐使用阿里云镜像
    

# 卸载旧的版本
$ yum install -y yum-utils

# 更新yum软件包索引
 yum makecache fast

# 安装docker相关的   docker-ce是社区版的   ee 企业版
$ yum install docker-ce docker-ce-cli containerd.io

# 启动docker
$ systemctl start docker

# 查看docker版本
$ docker version

# 测试docker
$ docker run hello-world

# 查看下载的镜像
$ docker images

# 卸载依赖
yum -y remove docker-ce docker-ce-cli containerd.io

#删除目录（资源）
rm -rf /var/lib/docker  docker的默认工作（资源）路径

3.3配置阿里云镜像加速

1. 找到容器镜像服务
2. 找到镜像加速地址
   
3. 配置使用

sudo mkdir -p /etc/docker    //新建一个docker

sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://4s1c1hdi.mirror.aliyuncs.com"]
}
EOF     配置镜像地址

sudo systemctl daemon-reload    镜像重启

sudo systemctl restart docker   docker重启

3.4回顾HelloWorld流程

3.5底层原理

docker是怎么工作的？
docker是一个client-server结构的系统，docker的守护进程运行在主机上，通过Socket从客户端访问！
DockerServer接收到Docker-Client的指令，就会执行这个命令

Docker为什么比虚拟机快？

1. docker有着比虚拟机更少的抽象层
2. docker利用是宿主机的内核VM需要GuestOS
   所以说，新建一个容器的时候，docker不需要像虚拟机一样重新加载一个操作系统内核，避免引导。虚拟机是加载GuestOS，分钟级别的，而docker是利用宿主机的操作系统，省略了复杂的过程，是秒级启动
   

4.docker的常用命令

推荐一个docker命令大全

docker命令

docker启动

systemctl start docker
service docker start
重启docker服务

systemctl restart docker
sudo service docker restart
关闭docker

systemctl stop docker
service docker stop
查看是否启动成功

docker ps -a

4.1帮助命令

docker version      //显示docker的版本信息
docker info			//显示docker的系统信息，包括镜像和容器的数量
docker 命令 --help  //万能命令

帮助文档地址

4.2镜像命令

docker images 查看所有本地主机上的镜像

[root@izbp1cu6acsu857v0gt1v5z ~]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
mysql               latest              db2b37ec6181        2 weeks ago         545MB
hello-world         latest              bf756fb1ae65        10 months ago       13.3kB

# 解释
REPOSITORY   镜像的仓库源
TAG			 镜像的标签
IMAGE ID	 镜像的ID
CREATED		 镜像的创建时间
SIZE		 镜像的大小

#可以选项
  -a, --all             Show all images (default hides intermediate images)  列出所有镜像  ------常用
      --digests         Show digests   //格式化
  -f, --filter filter   Filter output based on conditions provided
      --format string   Pretty-print images using a Go template
      --no-trunc        Don't truncate output
  -q, --quiet           Only show numeric IDs   只显示镜像的id------常用

docker search 搜索镜像

# 可选项
## 通过收藏来过滤
docker search mysql --filter=STARS=3000   搜索出来的镜像就是STARS大于3000的

docker pull 下载镜像

默认最新版本

• 分层下载是docker iamges的核心，联合文件系统
  

  • 签名信息：（防伪标志）
    
  • 真实地址
    
    两个命令是等价的
    ![在这里插入图片描述](https://img-

也可以指定mysql版本

• docker pull 镜像名[:tag] 如果不写tag，默认就是最新版本
  blog.csdnimg.cn/20201111114900509.png#pic_center)

• 指定版本下载
  
  • 在帮助文档里查询支持的MySQL版本
    
• 分层下载的好处就是可以共用组件（用到了之前的联合文件系统）

删除镜像 docker rmi

• docker rmi -f 镜像id
• docker rmi -f $(docker images -aq)删除所有镜像
• docker rmi -f 镜像id 镜像id 镜像id 镜像id #删除多个镜像

4.3容器命令

docker update 更新容器的设置

docker update 容器id/容器名 --restart=always “设置该容器自动启动”

说明：我们有了镜像可以创建容器，
docker pull centos

新建容器并启动

docker rum [可选参数] image

# 参数说明
--name="name"	  name为容器名字    tomcat01，tomcat02，用来区分容器
--d  			  后台方式运行，
--i、p			  使用交互的方式运行，进入容器查看内容
--p				  指定容器的端口 -p 8080:8080和主机映射
		-p ip:主机端口：容器端口
		-p 主机端口：容器端口**（常用）**
		-p 容器端口
		容器端口
--P（大写）		  随机指定端口

# 测试，启动并进入容器
[root@izbp1cu6acsu857v0gt1v5z ~]# docker run -it centos /bin/bash
[root@9956160c8343 /]# ls #查看容器内的centos，是基础版本，很多命令都不完善
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var

退出容器

• exit：直接容器停止并退出
• Ctrl+P+Q #容器不停止退出

列出所有正在运行的容器 docker ps

• docker ps -a 查看曾经运行过的容器，包括现在正在运行的
• docker ps -a -n=？ 显示最近创建的？个容器
  
• docker ps -aq:显示所有当前容器的编号

删除容器

- docker rm 容器id					        删除指定容器，==不能删除正在运行的容器==
- docker rm -f $(docker ps -aq)        删除所有容器
- docker ps -a -q|xargs docker rm    删除所有容器

启动和停止容器的操作

docker start 容器id			启动容器
docker restart 容器id		重启容器
docker stop 容器id			停止容器
docker kill 容器id			强制停止当前容器

常用的其他命令

• 后台启动容器
  docker run -d 镜像名

  • 出现问题：发现centos 停止了
  • 常见的坑：
    docker 容器使用后台运行，就必须要有一个前台进程，docker发现没有应用了就会自动停止（容器启动后，发现自己没有提供服务，就会立即停止）

• 查看日志
  docker logs
  docker logs -ft --tail number(要查看的条数) 容器id
  docker logs -tf 容器id 显示所有日志

• 查看容器中进程信息 ps
  docker top 容器id
  
  pid：当前进程 ppid：父进程

• 查看容器的元数据
  docker inspect 容器id

• 进入一个正在运行中的容器

方式一

通常容器都是使用后台方式运行的，需要进入容器，修改一些配置
docker exec -it 容器id bashShell

方式2

docker attach 容器id

方式1和方式2的对比

docker exec进入容器后开启一个新的终端，可以在里面操作（常用）
docker attach：进入容器正在执行的终端，不会启动新的进程！
exec和attach的对比

• 从容器内拷贝文件到主机上
  docker cp 容器id：容器内路径 目的主机路径
  
  现在拷贝是一个手动过程，未来我们使用 -V 卷的技术，可以实现宿主机和容器的数据同步
  https://www.cnblogs.com/-wenli/p/13307542.html

docker命令小结

5.安装练习

5.1docker安装nginx

下载镜像
docker pull nginx

创建容器
docker run -d --name nginx01 -p 3309:80 nginx
-d 后台运行
--name 给容器命名
-p 宿主机端口：容器内端口

理解端口暴露的概念 -p

容器中操作nginx

docker exec -it nginx1 /bin/bash
whereis  nginx       //查看nginx的相关文件路径
nginx.conf在   /etc/nginx中

5.2docker安装tomcat

官方使用
$ docker run -it --rm tomcat:9.0
我们之前的启动都是后台，停止了之后，容器还是可以查到 ，docker run -it --rm一般用来测试，用完(输入ctrl+c)即删除 （删除容器）


思考问题：我们以后要部署项目，如果每次都要进入容器是不是十分麻烦？要是可以在容器外提供一个映射路径，就可以在外部部署webapps中的项目，就自动同步到内部就好了

5.3部署ES+kibana

• es 暴露的端口很多
• es 十分的消耗内存
• es的数据一般需要放置到安全目录！挂载
  $ docker run -d --name elasticsearch --net somenetwork -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:tag

--net somenetwork 网络配置

6.可视化

• Rancher（CI/CD再用）最佳选择
• portainer（先用这个）

6.1什么是portainer？

docker图形化界面管理工具！提供一个后台面板供我们操作！

输入ip+端口访问
Docker使用Portainer搭建可视化界面

7.Docker镜像详解

7.1镜像是什么？

镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它包含运行某个软件所需的所有内容，包括代码、运行时库、环境变量和配置文件。
所有的应用直接打包一个docker镜像，就可以直接运行起来

如何得到镜像？

• 从远程仓库下载
• 同事拷贝
• 自己制作一个DockerFile

7.2Docker镜像加载原理

UnionFS（联合文件系统）一步步的进行分层

下载的时候看到的一层层的就是这个

Docker镜像加载原理

为什么Docker比一般的虚拟机小很多？

7.3分层理解

为什么Docker镜像要采用这种分层的结构能？

理解

特点

Docker镜像都是只读，当容器启动时，一个新的可写层被加载到镜像的顶部！
这一层就是我们通常说的容器层，容器之下的都叫镜像层

如何提交自己的镜像？

7.4commit镜像

docker commit 提交容器成为一个新的镜像
命令和git原理类似
docker commit -m="提交的描述信息" -a="作者" 容器id 目标镜像民:[TAG]
实战测试

1. 启动一个默认的tomcat
2. 发现这个默认的tomcat是没有webapps应用，原因是官方的tomcat镜像的webapps下面默认是没有文件的！
3. 自己在webapps.dist拷贝进去基本文件
4. 将我们修改后的容器通过commit提交为一个镜像！我们以后就使用我们修改过的镜像即可，这就是我们自己修改过的镜像

学习方式：理解概念，但一定要时间，最后实践和理论相结合一次搞定

如果你想要保存当前容器的状态，就可以通过commit来提交，获得一个镜像
就好比我们以前学习VM时候的快照

到了这里才算入门docker

Docker数据卷，DockerFile，Docker网络是Docker的精髓

Docker Compose
Docker Swarm 集群部署
CI/CD Jenkins 流水线

8.容器数据卷

8.1什么是容器数据卷

docker理念回顾
将应用和环境打包成一个镜像！

数据？如果数据都在容器中，那么我们容器删除，数据就会丢失！需求：数据的可持续化
MySQL：容器删了，数据也就删除了需求：MySQL的数据可以存储在本地

容器之间可以有数据共享的技术！Docker容器中产生的数据，同步到本地

以上就是数据卷技术
目录的挂载，将我们容器内的目录，挂载到Linux上面

总结：容器数据的持久化和同步操作！容器间也是可以数据共享的

使用数据卷

只能在创建容器的时候创建数据卷

方式一：直接使用命令来挂载 -v （volum）

docker run -it -v 主机目录：容器内部目录 

# 测试
docker run -it -v /home/ceshi:/home centos /bin/bash

输入docker inspect 容器id 查看元数据

实战：安装MySQL并同步数据

思考：MySQL的数据持久化问题

# 获取镜像

#运行容器，需要做数据挂载  #安装启动mysql，需要配置密码

-d 后台运行
-p 端口映射
-v 卷挂载
-e 环境配置
--name 容器名字
docker run -itd -v /home/docker/mysql01/conf:/etc/mysql/conf.d -v /home/docker/mysql01/data:/var/lib/mysql -p 3308:3306 --name mysql01 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7

具名挂载和域名挂载

匿名挂载

docker run -d -p --name nginx01 -v /ect/nginx nginx

• 查看所有的volume的情况
  docker volume ls
  
• 这里发现，这种就是匿名挂载，我们在-v只写了容器内的路径，没有写容器外的路径，就像new了一个匿名内部类，类没有名字

具名挂载

所有的docker容器内的卷，没有指定目录的情况下都是在 /var/lib/docker/volumes/XXXX(卷名)/_data
我们通过具名挂载可以方便的找到我们的一个卷，大多数情况都使用具名挂载

如何确定是具名挂载还是匿名挂载，还是指定路径挂载

-v 容器内路径			#匿名挂载
-v 卷名：容器内路径		#具名挂载
-v /宿主机路径：容器内路径   #指定路径挂载

拓展：ro和rw

通过 -v 容器内路径：ro rw 改变读写权限
ro readonly 只能从宿主机来操作，容器内部无法操作
rw readwrite
一旦设定了容器权限，容器对我们挂载出来的内容就有限定了

docker run -d -p --name nginx02 -v juming-nginx:/etc/nginx:ro  nginx
docker run -d -p --name nginx02 -v juming-nginx:/etc/nginx:ro  nginx

初识dockerfile

在构建镜像的时候直接进行挂载
dockerfile就是用来构建镜像的构建文件！命令脚本！先体验一下！
通过这个脚本可以生成镜像，镜像是一层一层的，脚本是一个个的命令，每个命令都是一层

#创建一个dockerfile文件，名字可以随机，建议为Dockerfile
#文件中的内容  指令（大写）和参数
FROM centos
VOLUME ["volume01","volume02"]     匿名挂载
CMD echo "----end----"
CMD /bin/bash
这里的每个命令，都是镜像的一层

• 启动自己写的容器
  
  这个卷（volume01,02）和外部一定有一个同步的目录
  
  这种方式我们未来使用额十分多，因为我们通常会构建自己的镜像
  假设构建镜像是没有挂载卷，要手动镜像挂载 -v 卷名：容器内路径

数据卷容器

docker01

docker02: 继承docker01

当把docker01删除了，查看一下docker02和docker03是否可以访问这个文件
测试依旧可以访问

多个mysql实现数据共享

这样就可以实现两个容器数据同步

结论：

• 容器之间可以进行配置信息的传递，数据卷容器的生命周期一直持续到没有容器使用为止（实现共享的所有有关容器全部被删除为止）
• 但是一旦你持久化到了本地，这个时候，本地的数据是不会删除的！

9.DockerFile

9.1DockerFile介绍

dockerfile是用来构建docker镜像的文件！命令参数脚本！

构建步骤：

1. 编写一个dockerfile文件
2. docker build构建成为一个镜像
3. docker run 运行镜像
4. docker push 发布镜像（dockerHub，阿里云镜像仓库）
   查看一下官方是怎么做的
   
   
   很多官方的镜像都是基础包，很多功能没有，我们通常会自己搭建自己的镜像

9.2Dockerfile构建过程

基础知识：

1. 每个保留关键字指令都是必须是大写字母
2. 执行从上到下顺序执行

3. 表示注释

4. 每一个指令都会创建提交一个新的镜像层，并提交
   dockerfile是面向开发的，我们以后要发布项目，作镜像，就需要编写dockerfile文件

docker镜像逐渐成为了企业交互的标准

dockerfile：构建文件，定义了一切的步骤，源代码
dockerimages：通过dockerfile构建生成的镜像，最终发布和运行的产品，原来是kar war
docker容器：容器就是镜像运行起来提供服务的

9.3dockerfile的指令

构建一个centos

通过这个文件构建镜像

CMD 和 ENTRYPOINT的区别

10.Docker网络