- Docker诞生背景
- Docker 介绍
- Docker安装与启动
- Docker底层原理
- Docker常用命令
- 2. 查看容器日志
- 3. 查看容器内运行的进程(图2)
- 4. 查看容器内部细节(图3)
- 5.进入正在运行的容器并进行交互(图4)
- 6. 重新进入容器(图5)
- 比较5与6的区别
- 7. 从容器内拷贝文件到宿主机(图6)
- Docker容器数据卷
- 通过-v命令直接添加 (需要在根目录下创建 containerData )，创建后修改容器内containerData 会同步到hostData ,反之亦是如此
docker run -it -v /hostData:/containerData 镜像名/ID - 创建只读权限的文件 , 容器内只能读取这个文件, 但是不能修改. ro: readonly （ro：只读，rw：可读可写）
docker run -it -v /宿主机绝路路径目录:/容器内目录:ro 镜像名 - 容器间数据卷
- DockerFile解析
- 表示注释
- 把宿主机当前上下文的c.txt拷贝到容器/usr/local/路径下
- 把java与tomcat添加到容器中
- 安装vim编辑器
- 设置工作访问时候的WORKDIR路径，登录落脚点
- 配置java与tomcat环境变量
- 容器运行时监听的端口
- 启动时运行tomcat
- ENTRYPOINT [“/usr/local/apache-tomcat-9.0.8/bin/startup.sh” ]
- CMD [“/usr/local/apache-tomcat-9.0.8/bin/catalina.sh”,”run”]
- 1. 以安装mysql5.6为例(不知道什么原因5.7下不来)
- 2. 运行镜像,启动容器(端口3306,root用户密码:root,运行镜像:mysql5.6)
- 3. 进入msql内部测试登录
- 4.连接数据库的图形化界面
- 5. 备份数据库数据,之后我们可以通过直接读取这个sql文件恢复数据
- 1.下载最新版redis镜像
- 2.运行镜像(redis端口2333, -d后的redis不加参数默认为redis:latest)
- 注意本地数据卷与容器内数据卷目录的对应
- 3.上传redis.conf到本地数据卷所在目录
- 4. 运行redis的cil——shell命令行
- 远程连接 docker redis
- 1.下载镜像
- 2.运行镜像
- 3.访问 (如下图)
- 测试 运行一个tomcat
- 查看容器内部网络地址
- 发现容器启动的时候会得到一个 eth0@if91 ip地址，docker分配！
- 思考？ linux能不能ping通容器内部！ 可以 容器内部可以ping通外界吗？ 可以！
- 获取tomcat01的ip 172.17.0.2
- 让tomcat02 ping tomcat01
- 结论：容器和容器之间是可以互相ping通
- -link示例：
- 运行一个tomcat03 —link tomcat02
- 3连接2
- 用tomcat03 ping tomcat02 可以ping通
- 2连接3
- 用tomcat02 ping tomcat03 ping不通
- docker network语法
- 我们直接启动的命令 —net bridge, 而这个就是我们得docker0
- bridge就是docker0
- docker0，特点：默认，域名不能访问。 —link可以打通连接，但是很麻烦！
- 我们可以 自定义一个网络
- —driver bridge
- —subnet 192.168.0.0/16 子网掩码
- —gateway 192.168.0.1 网关地址
- 创建网卡
- 通过脚本创建六个redis配置
- 通过脚本运行六个redis
- 1.复制jar和DockerFIle 到服务器
- 2.构建镜像
- 本文参考
Docker诞生背景
一款产品从开发到上线，从操作系统，到运行环境，再到应用配置。作为开发+运维之间的协作我们需要关心很多东西，这也是很多互联网公司都不得不面对的问题，特别是各种版本的迭代之后，不同版本环境的兼容，对运维人员都是考验 !
环境配置如此麻烦，换一台机器，就要重来一次，费力费时。很多人想到，能不能从根本上解决问题，软件可以带环境安装？也就是说，安装的时候，把原始环境一模一样地复制过来。
Docker镜像的设计，使得Docker得以打破过去”程序即应用” 的观念。透过镜像(images)将作业系统核心除外，运作应用程式所需要的系统环境，由下而上打包，达到应用程式跨平台间的无缝接轨运作。
Docker之所以发展如此迅速，也是因为它对此给出了一个标准化的解决方案!
Docker 介绍
Docker的主要目标是“Build，Ship and Run Any App, Anywhere”，也就是通过对应用组件的封装、分发、部署、运行等生命周期的管理, 使用户的APP（可以是一个WEB应用或数据库应用等等）及其运行环境能够做到“一次封装，到处运行”。
总结：Docker是解决运行环境和配置问题的软件容器 , 方便做持续集中并有助于整体发布的容器虚拟化技术
虚拟机技术与容器虚拟化技术
虚拟机技术虚拟机（virtual machine）就是带环境安装的一种解决方案。 它可以在一种操作系统里面运行另一种操作系统，比如在Windows 系统里面运行Linux 系统。 应用程序对此毫无感知，因为虚拟机看上去跟真实系统一模一样**缺点**:1 资源占用多 2 冗余步骤多 3 启动慢
容器虚拟化技术Linux 容器（Linux Containers，缩写为 LXC）。 Linux 容器不是模拟一个完整的操作系统，而是对进程进行隔离。 有了容器，就可以将软件运行所需的所有资源打包到一个隔离的容器中。 容器与虚拟机不同，不需要捆绑一整套操作系统，**只需要软件工作所需的核心库资源和设置。 系统因此而变得高效轻量**并保证部署在任何环境中的软件都能始终如一地运行。
二者区别1.传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统，在该系统上再运行所需应用进程。2.而容器内的应用进程直接运行于宿主机( 即:所在主机,下面统称宿主机 ) 的内核和硬件，容器内没有自己的内核， 也没有进行硬件虚拟。因此容器要比传统虚拟机更为轻便。3.每个容器之间互相隔离，每个容器有自己的文件系统 ，容器之间进程不会相互影响，能区分计算资源。
Docker官网地址 : https://www.docker.com
Docker社区官方: https://hub.docker.com/
Docker安装与启动
前提条件:
Docker支持以下CentOS版本：CentOS 7 (64-bit)系统内核版本为 3.10 以上，CentOS 6.5 (64-bit) 系统内核版本为 2.6.32-431 或者更高版本uname -r # 查看内核版本 （查到我的内核版本是 3.10.0-1160.el7.x86_64）cat /etc/redhat-release #查看虚拟机系统版本 （我的虚拟机版本CentOS Linux release 7.9.2009 (Core)）
- 安装依赖GCC（需要确保 虚拟机可以上外网 ）
yum -y install gccyum -y install gcc-c++
- 卸载旧版本
yum -y remove docker docker-common docker-selinux docker-engine官网版本
docker-client
docker-client-latest
docker-common
docker-latest
docker-latest-logrotate
docker-logrotate
docker-engine
- 安装需要的软件包
yum install -y yum-utils device-mapper-persistent-data lvm2
- 设置stable镜像仓库（正确推荐使用国内的阿里云镜像 ）
yum-config-manager --add-repo [http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo](http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo)
- 更新yum软件包索引
yum makecache fast
- 安装Docker CE
yum -y install docker-ce docker-ce-cli containerd.io
- Docker启动管理命令
systemctl start docker 启动dockersystemctl daemon-reload 重新载入后台启动进程service docker status 查看Docker容器状态
- 测试
docker version #查看版本docker run hello-world #通过运行 hello-world 映像来验证是否正确安装了docker images #查看docker容器已下载的镜像
到这里Docker就成功安装了！
Docker底层原理
Docker结构图
工作原理
Docker是一个Client-Server结构的系统，Docker守护进程运行在主机上，然后通过Socket连接从客户端访问，守护进程从客户端接受命令并管理运行在主机上的容器。容器，是一个运行时环境，就是我们前面说到的集装箱。
Docker为什么比VM虚拟机快
(1) docker有着比虚拟机更少的抽象层
由于docker不需要Hypervisor实现硬件资源虚拟化, 运行在docker容器上的程序直接使用的都是实际物理机的硬件资源。因此在CPU、内存利用率上docker将会在效率上有明显优势。
(2) docker利用的是宿主机的内核,而不需要Guest OS
因此,当新建一个容器时,docker不需要和虚拟机一样重新加载一个操作系统内核。因而避免引寻、加载操作系统内核返个比较费时费资源的过程,当新建一个虚拟机时,虚拟机软件需要加载Guest OS,返个新建过程是分钟级别的。而docker由于直接利用宿主机的操作系统,则省略了返个过程,因此新建一个docker容器只需要几秒钟。
Docker常用命令
帮助命令
docker version # 查看docker版本信息docker info # 查看docker所有安装信息docker --help # 查看docker帮助 ( 最为重要,学会利用帮助文档来学习 ,这是成为高手的必经之路!!! )
启动命令
systemctl start docker 启动dockersystemctl daemon-reload 重新载入后台启动进程service docker status 查看Docker容器状态
镜像命令
# 1.列出本地镜像(图1)docker images# option说明-a :列出所有镜像-q:只列出镜像id-digests :显示镜像的摘要信息--no-trunc :显示相信信息# 2.搜索某个镜像名字 (会在docker社区搜索相关的镜像, 而我们配置的阿里源只是帮我们同步了docker社区的镜像,图2)docker search# option说明- s显示收藏数不小于指定值的镜像--no-trunc :显示相信信息- automated :只列出automated类型的镜像# 3. 下载镜像(图3)docker pull 镜像的名字:[TAG](不写默认为 lasted)# 4. 删除镜像docker rmi -f 镜像名/镜像iddocker rmi -f $(docker images -qa ) 递归删除所有镜像（通过id)
图1
各个选项说明
- REPOSITORY：表示镜像的仓库源
- TAG：镜像的标签
- IMAGE ID：镜像ID
- CREATED：镜像创建时间
- SIZE：镜像大小
- 同一仓库源可以有多个 TAG，代表这个仓库源的不同个版本，我们使用 REPOSITORY:TAG 来定义不同的镜像。
- 如果你不指定一个镜像的版本标签，例如你只使用 ubuntu，docker 将默认使用 ubuntu:latest 镜像
容器命令
基础命令
我们要有镜像才可以创建容器，先下载一个centos镜像 (docke pull centos)# 1. 新建并启动容器docker run [OPTIONS] IMAGE [COMMOND] [ARGS...]# OPTIONS 说明--name="容器新名字": 为容器指定一个名称；-d: 后台运行容器，并返回容器ID，也即启动守护式容器；-i：以交互模式运行容器，通常与 -t 同时使用；-t：为容器重新分配一个伪输入终端，通常与 -i 同时使用；-P: 随机端口映射；-p: 指定端口映射，有以下四种格式ip:hostPort:containerPortip::containerPorthostPort:containerPort #最常用，如 -p 8080：8080containerPort# eg: 使用镜像centos:latest以交互模式启动并进入一个容器,在容器内执行/bin/bash命令。docker run -it centos /bin/bash 或 docker run -it 镜像id# 2. 查询当前正在运行的容器(类比虚拟中的查看进程)docker ps [OPTIONS]# OPTIONS说明（常用）：-a :列出当前所有正在运行的容器+历史上运行过的-l :显示最近创建的容器。-n：显示最近n个创建的容器。-q :静默模式，只显示容器编号。--no-trunc :不截断输出。# 3. 退出容器exit 容器停止后退出ctrl+p+q 容器不停止退出# 4 .启动容器docker start 容器ID/容器名# 5. 重启容器docker restart 容器ID/容器名# 6. 停止容器docker stop 容器ID/容器名# 7. 强制停止容器docker kill 容器ID/容器名# 8. 删除指定的容器(如果没有停止, 删除后会停止)docker rm 容器ID# 9. 删除多个容器(特别是第二种 ,先查询所有运行的进程, 然后通过管道传到后面的删除操作中)docker rm -f $(docker ps -a -q) 或 docker rm -f $(docker ps -aq)docker ps -a -q | xargs docker rm
其他重要命令
# 1. 启动守护式容器(后台运行)docker run -d 容器名# 使用镜像centos:latest以后台模式启动一个容器docker run -d centos
问``题``：通过``**docker ps -a**`` 进行查看, 会发现容器退出了？？？
- 因为 Docker容器后台运行, 就必须有一个前台进程，容器发现自己没有提供服务，就会自动停止。
- 容器运行的命令如果不是那些一直挂起的命令（比如运行top，tail），就是会自动退出的。这个是docker的机制问题。最佳的解决方案是,将你要运行的程序以前台进程的形式运行。
```java
2. 查看容器日志
docker logs -f -t —tail 容器ID
eg :(图1) docker run -d centos /bin/sh -c “while true;do echo hello testLogs;sleep 2;done” docker logs -tf —tail 10 02c81778b0e0
-t 是加入时间戳 -f 跟随最新的日志打印 —tail 数字 显示最后多少条
3. 查看容器内运行的进程(图2)
docker top 容器ID
4. 查看容器内部细节(图3)
docker inspect 容器ID
5.进入正在运行的容器并进行交互(图4)
docker exec -it 容器ID /bin/bash
6. 重新进入容器(图5)
docker attach 容器ID bashShell(不写的话默认 /bin/bash下)
比较5与6的区别
attach 直接进入容器启动命令终端, 不会启动新的线程 exec 是在容器中打开新的终端, 并且可以启动新的线程
7. 从容器内拷贝文件到宿主机(图6)
docker cp 容器ID:/容器内文件路径 /宿主机目的路径
<br />图1<br /><br />图2<br /><br />图3<br /><br />图4<br />图5<br /><br />图6<a name="YFXH4"></a>## Docker常用命令图解<a name="D4L9f"></a># Docker镜像<a name="vSvBo"></a>## 镜像 / UnionFS（联合文件系统）Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下。Union 文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承. 基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。<br />**特性**<br />一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录。- **Dcoker镜像都是****只读****的 , 当启动容器时, 一个新的可写层被加载到镜像的顶部这一层被称为"容器层", "容器层"执行的都称为"镜像层"。**<a name="5xXZq"></a>## Docker镜像加载原理docker的镜像实际上由一层一层的文件系统组成，这种层级的文件构成文件系统UnionFS。<br /><br />**bootfs(boot file system) 主要包含****bootloader****和****kernel**<br />bootloader主要作用是引导加载kernel, Linux刚启动时会加载bootfs文件系统，Docker镜像的最底层是bootfs。<br />这一层与典型的Linux/Unix系统是一样的，包含boot加载器和内核**kernel**。当boot加载完成之后整个内核就都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs。rootfs (root file system) ，在bootfs之上。包含的就是典型 Linux 系统中的 /dev, /proc, /bin, /etc 等标准目录和文件。rootfs就是各种不同的操作系统发行版，比如Ubuntu，Centos等等。对于一个精简的OS，rootfs可以很小，只需要包括最基本的命令、工具和程序库就可以了，因为底层直接用Host的kernel，自己只需要提供 rootfs 就行了。由此可见对于不同的linux发行版, bootfs基本是一致的, rootfs会有差别, 因此不同的发行版可以公用bootfs。<a name="OAcZd"></a>## Docker镜像Commit操作```java# 提交容器副本实质成为一个新的镜像docker commit -m="提交的描述信息" -a="作者" 容器ID 要创建的目标镜像名:[标签名]eg: 同时docker运行tomcat案例# 1. 创建交互式界面 ( 相当于前台启动)docker run -it -p 8888:8080 tomcat # 端口映射将8888作为docker的入口,映射到tomcat镜像的8080(图1,图2)docker run -it -P tomcat #自动端口映射(通过 docker ps查看端口, 图3)#后台启动(不会占用当前页面)docker run -d -p 8888:8080 tomcat# 2. 进入tomcat (如果前置启动,另开一个窗口 ,后置启动则直接进入)# 查看运行容器IDdocker ps# 进入根目录docker exec -it 容器ID /bin/bash/usr/local/tomcat# rm -rf webapps/docs/# 删除后访问tomcat ,可以看到访问主页下的文档出现404(图4)# 3. 提交容器副本实使之为一个新的镜像# 查看运行容器IDdocker ps# 提交容器docker commit -a="fred" -m="del tomcat docs" 容器ID tomcat:v1.2.. -a 为作者.. -m 描述.. tomcat:v1.2 发布版本名称# 查看镜像(图5)docker images# 4.同时启动新镜像并和原来的对比可以看到我们自己提交的新镜像也没有文档()但是我们重新下载的tomcat是有的
Docker容器数据卷
容器—宿主机数据卷
1.直接命令添加
通过-v命令直接添加 (需要在根目录下创建 containerData )，创建后修改容器内containerData 会同步到hostData ,反之亦是如此
docker run -it -v /hostData:/containerData 镜像名/ID
创建只读权限的文件 , 容器内只能读取这个文件, 但是不能修改. ro: readonly （ro：只读，rw：可读可写）
docker run -it -v /宿主机绝路路径目录:/容器内目录:ro 镜像名
2.通过DockerFile添加
Dockerfile是用来构建Docker镜像文件 ,是有一系列命令和参数构成的脚本。类比理解：
# 1. 宿主机根目录下创建mydocker文件夹并进入# 2. 在mydocker文件想创建DockerFile文件并编辑,内容如下(图1)# volume testFROM centosVOLUME ["/dataVolumeContainer1","/dataVolumeContainer2"]CMD echo "finished,--------success1"CMD /bin/bash说明：出于可移植和分享的考虑，用-v 主机目录:容器目录这种方法不能够直接在Dockerfile中实现。由于宿主机目录是依赖于特定宿主机的，并不能够保证在所有的宿主机上都存在这样的特定目录。3. 使用docker build命令创建一个镜像, 并挂载指定宿主机指定文件（Dockerfile一般位于构建上下文的根目录下，也可以通过-f指定到该文件的位置）docker build -f /mydocker/DockerFile -t 自定义新镜像名称 .4. 查看镜像docker images5.运行新镜像docker run -it 定义的新镜像ID /bin/bash6.通过镜像运行后生成的容器ID查看 (图2), 对应的主机映射的数据卷地址docker psdocker inspect 容器ID7.测试添加卷和主机是否互通有无在容器中创建文件, 看看主机中是否创建对应的文件#在dataVolumeContainer1创建一个文件，再去宿主机上dataVolumeContainer1对应的文件路径查看是否存在（图3）注意:Docker挂载主机目录(第3步)Docker访问出现cannot open directory .: Permission denied解决办法：在挂载目录后多加一个--privileged=true参数即可
图1
图2：查看运行的容器id相关信息 docker inspect 容器ID
图3 （测试添加卷和主机是否互通有无）
匿名挂载
(1）启动容器docker run -d -P --name nginx01 -v /etc/nginx nginx ``
-v 容器内路径
（2）查看所有卷的情况docker volume ls
【注】由上图可以看到，VOLUME NAME 有的是随机生成的字符串，对于这种就是匿名挂载，因为-v的时候只写了容器内的路径看，而没有写容器外的路径
具名挂载
(1) 启动容器docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx
核心语法：docker run -d -P --name `` -v 卷名：容器内路径 镜像ID 或 镜像名 /bin/bash
（2）查看一下这个卷docker volumn inspect juming-nginx 或 docker volumn inspect 容器ID
【注意】所有docker容器内的卷，没有指定目录的情况下都是在 /var/lib/docker/volumes/xxx
容器间数据卷
命名的容器挂载数据卷，其它容器通过挂载这个(父容器)实现数据共享；
挂载数据卷的容器，称之为数据卷容器。
实现步骤
# 1. 以上一步所建镜像为模板 ,首先启动一个父容器dc01 ,在创建容器的数据卷文夹中创建一个文件(图1)docker run -it --name dc01 zzyy/centostouch dc01_add.txt# 2. 创建子容器dc02,dc03继承自dc01 , 在创建容器的数据卷文夹中创建一个文件(图2)docker run -it --name dc02 --volumes-from dc01 zzyy/centostouch dc02_add.txtdocker run -it --name dc03 --volumes-from dc01 zzyy/centostouch dc01=3_add.txt# 3. 回到dc01可以看到所有数据都被共享了(图3)# 4. 删除dc01, dc02修改后dc03是否可访问,可以 (图4)# 5. 删除dc02dc03是否可以访问, 可以(图5)# 6. 新建dc04继承dc03是否可以访问, 可以(图6)结论容器之间配置信息的传递, 数据卷的生命周期一直持续到没有容器使用它为止
DockerFile解析
构建步骤
1.编写Dockerfile文件2.docker build3.docker run
Dockerfile格式
FROM scratchADD centos-8-container.tar.xz /LABEL org.label-schema.schema-version="1.0" \org.label-schema.name="CentOS Base Image" \org.label-schema.vendor="CentOS" \org.label-schema.license="GPLv2" \org.label-schema.build-date="20190927"CMD ["/bin/bash"]
Dockerfile语法
- docker从基础镜像运行一个容器
- 执行一条指令并对容器做出修改
- 执行类似docker commit 的操作提交一个新的镜像层
- docker 再基于刚提交的镜像运行一个新容器
- 执行dockerfile 中的下一条执行, 直至所有指令都完成
从应用软件的角度来看，Dockerfile、Docker镜像与Docker容器分别代表软件的三个不同阶段
- Dockerfile是软件的原材料
- Docker镜像是软件的交付品
- Docker容器则可以认为是软件的运行态
Dockerfile面向开发，Docker镜像成为交付标准，Docker容器则涉及部署与运维，三者缺一不可，合力充当Docker体系的基石。
1Dockerfile：需要定义一个Dockerfile，Dockerfile定义了进程需要的一切东西。Dockerfile涉及的内容包括执行代码或者是文件、环境变量、依赖包、运行时环境、动态链接库、操作系统的发行版、服务进程和内核进程(当应用进程需要和系统服务和内核进程打交道，这时需要考虑如何设计namespace的权限控制)等等;2Docker镜像：在用Dockerfile定义一个文件之后，docker build时会产生一个Docker镜像，当运行 Docker镜像时，会真正开始提供服务;3Docker容器：容器是直接提供服务的。
DockerFile保留字指令
CMD与ENTRYPOINT命令类似``，但也有些区别：
- 执行docker run如果带有其他命令参数，将会覆盖CMD指令。执行docker run如果带有其他命令参数，不会覆盖ENTRYPOINT指令，而是相当于在后面直接加命令。
- ENTRYPOINT指令，往往用于设置容器启动后的第一个命令，这对一个容器来说往往是固定的。
- CMD指令，往往用于设置容器启动的第一个命令的默认参数，这对一个容器来说可以是变化的。
- docker run
往往用于给出替换CMD的临时参数 DockerFile构建镜像文件（案例1）
我们安装的centos精简版是没有vim和ifconfig等命令的支持的，这里我们通过编写Dockerfile令其支持这些功能。
- 搜索centos镜像并下载
docker search centosdocker pull centos
- 编写创建一个文件( /mydoker/dockerfile_centos ), 编写Dockerfile ,内容如下 ``` FROM centos MAINTAINER timepauseqq_43371556@csdn.net
ENV MYPATH /usr/local WORKDIR $MYPATH
RUN yum -y install vim RUN yum -y install net-tools
EXPOSE 80
CMD echo $MYPATH CMD echo “install vim and ifconfig commond plug-in components success” CMD /bin/bash
3. **编译运行centos( 注意最后的空格和点号)**`docker build -f /mydoker/dockerfile_centos -t mycentos:1.3 .`4. 测试：#查看镜像是否新增<br />`docker images`<br />#解决镜像名<none><none>问题<br />`docker tag 镜像ID name:tag 如：docker tag f8ebaa92d089 mycentos:v1.1`<br />#运行制作的新镜像<br />`docker run -it mycentos:1.3`#在容器中使用vim 和 ifconfig指令<br />图1<br /><br />图2<a name="WTXhF"></a>## DockerFile构建镜像文件（案例2）<a name="mHinN"></a>### 自定义tomcat91. 创建存放生成镜像文件的目录`mkdir -p /myuse/mydocker/tomcat9`2. 创建相关文件(c.txt用于测试)`touch c.txt`3. 上传tomcat和jdk(一定要注意版本, 根据版本修改Dockerfile文件, 图1)3. 创建并编辑Dockerfile(需要提前下载centos)`vim Dockerfile`<br />Dockerfile
FROM centos MAINTAINER chychy@qq.com
把宿主机当前上下文的c.txt拷贝到容器/usr/local/路径下
COPY c.txt /usr/local/cincontainer.txt
把java与tomcat添加到容器中
ADD jdk-8u11-linux-x64.tar.gz /usr/local/ ADD apache-tomcat-9.0.27.tar.gz /usr/local/
安装vim编辑器
RUN yum -y install vim
设置工作访问时候的WORKDIR路径，登录落脚点
ENV MYPATH /usr/local WORKDIR $MYPATH
配置java与tomcat环境变量
ENV JAVA_HOME /usr/local/jdk1.8.0_11 ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.27 ENV CATALINA_BASE /usr/local/apache-tomcat-9.0.27 ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
容器运行时监听的端口
EXPOSE 8080
启动时运行tomcat
ENTRYPOINT [“/usr/local/apache-tomcat-9.0.8/bin/startup.sh” ]
CMD [“/usr/local/apache-tomcat-9.0.8/bin/catalina.sh”,”run”]
CMD /usr/local/apache-tomcat-9.0.27/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.27/bin/logs/catalina.out
5. 构建镜像(在存放这些文件的目录下,图2)# 如果Dockerfile文件名称就是Dockerfile,可以省略参数 -f /Dockerfile所在位置的书写<br />`docker build -t mytomcat9 .`6. 查看镜像并运行镜像( 图3，图4)`docker images #查看镜像`<br />`docker run -d -p 8080:8080 --name myt9 -v /myuse/mydocker/tomcat9/test:/usr/local/apache-tomcat-9.0.27/webapps/test -v /myuse/mydocker/tomcat9/tomcat9logs/:/usr/local/apache-tomcat-9.0.27/logs --privileged=true mytomcat9 #运行镜像`<br /> 【注意】这里配置了容器卷的映射,宿主机的test文件夹映射到tomcat的webapps目录下的test文件,且二者可以互通有无。 <br />`docker exec -it 容器ID /bin/bash` #进入容器根目录 ,可以访问相关页面7. 访问成功后, 添加jsp文件与web.xml文件( a.jsp用于访问测试 ,web.xml用于令jsp页面可以编译)`vim a.jsp`<br />`mkidr WEB-INF`<br />`vim /WEB-INF/web.xml`<br />**a.jsp**
<%@ page language=”java” contentType=”text/html; charset=UTF-8” pageEncoding=”UTF-8”%> <!DOCTYPE html PUBLIC “-//W3C//DTD HTML 4.01 Transitional//EN” “http://www.w3.org/TR/html4/loose.dtd">
—————-welcome—————— <=”i am in docker tomcat self “%><% System.out.println(“=============docker tomcat self”);%>
**web.xml**
<?xml version=”1.0” encoding=”UTF-8”?>
8. 重启服务, 访问a.jsp(图5)# 查看当前容器id`docker ps (查看当前容器ID) docker ps -a (查看所有运行过的容器ID)`# 重启服务`docker restart 容器ID`# 访问a.jsp页面图1<br /><br />图2<br /><br />图3<br /><br />图4<br /><br />图5<a name="YrFAd"></a># 发布镜像到阿里云1.登陆阿里云, 进入容器镜像服务(可以通过下方地址注册登录跳转到容器镜像服务)<br />[https://cr.console.aliyun.com/cn-hangzhou/instances/repositories](https://cr.console.aliyun.com/cn-hangzhou/instances/repositories)<br />2. 创建镜像仓库(图1)<br />3. 在docker中登陆 ,根据图2, 图3中的操作指南进行操作<br />4. 将正在运行的容器创建成一个镜像(图4) <br />`docker commit [OPTIONS]`<br />说明：<br />-a :提交的镜像作者；<br />-m :提交时的说明文字；<br />5.将镜像推送到阿里云的镜像仓库(最好是根据阿里云上的操作指南)<br />`docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/timepause/mydocker:[镜像版本号]`<br />`sudo docker push registry.cn-hangzhou.aliyuncs.com/timepause/mydocker:[镜像版本号]`<br />6. 搜索镜像 ,下载镜像(图5, 图6)<br />`docker pull (复制的)镜像地址`<br /><br />图1图2图3图4图5<br />图6<a name="RG7qn"></a># 通过Docker安装软件<a name="ppDj3"></a>## MySQL
1. 以安装mysql5.6为例(不知道什么原因5.7下不来)
docker pull mysql:5.6
2. 运行镜像,启动容器(端口3306,root用户密码:root,运行镜像:mysql5.6)
docker run -p 3306:3306 —name mysql -v /datebase/mysql/conf:/etc/mysql/conf.d -v /datebase/mysql/logs:/logs -v /datebase/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=root -d mysql:5.6
3. 进入msql内部测试登录
docker ps
进入mysql的当前目录下
docker exec -it MySQL运行成功后的容器ID/name /bin/bash
输入账号密码
mysql -u 账号 -p(然后根据提示输入密码)
4.连接数据库的图形化界面
Mysql 解决连接客户端时出现1251 client does not support …问题
ALTER USER ‘root’@’%’ IDENTIFIED WITH mysql_native_password BY ‘mysql密码’; ALTER USER ‘root’@’localhost’ IDENTIFIED WITH mysql_native_password BY ‘mysql密码’;
5. 备份数据库数据,之后我们可以通过直接读取这个sql文件恢复数据
docker exec myql服务容器ID sh -c ‘ exec mysqldump —all-databases -uroot -p”root” ‘ > /datebase/all-databases.sql
<a name="pJFR1"></a>## Redis
1.下载最新版redis镜像
docker pull redis
2.运行镜像(redis端口2333, -d后的redis不加参数默认为redis:latest)
注意本地数据卷与容器内数据卷目录的对应
docker run -p 2333:6379 -v /myuse/myredis/data:/data -v /myuse/myredis/conf/redis.conf:/usr/local/etc/redis/redis.conf -d redis redis-server /usr/local/etc/redis/redis.conf —appendonly yes
3.上传redis.conf到本地数据卷所在目录
本地数据卷坐在目录 : /myuse/myredis/conf 文件地址(太大了 ,这里放不下) : https://download.csdn.net/download/qq_43371556/11889084
4. 运行redis的cil——shell命令行
docker exec -it 运行着Rediis服务的容器ID redis-cli
远程连接 docker redis
docker exec -it redis_s redis-cli -h 192.168.1.100 -p 6379 -a your_password //如果有密码 使用 -a参数
<a name="4oHls"></a>## RabbitMQ
1.下载镜像
docker pull rabbitmq:3.7.7-management
2.运行镜像
docker run -d —name rabbitmq3.7.7 -p 5672:5672 -p 15672:15672 -v pwd/data:/var/lib/rabbitmq —hostname myRabbit -e RABBITMQ_DEFAULT_VHOST=/ -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=admin df80af9ca0c9
-d 后台运行容器； —name 指定容器名； -p 指定服务运行的端口（5672：应用访问端口；15672：控制台Web端口号）； -v 映射目录或文件； —hostname 主机名（RabbitMQ的一个重要注意事项是它根据所谓的 “节点名称” 存储数据，默认为主机名）； -e 指定环境变量；（RABBITMQ_DEFAULT_VHOST：默认虚拟机名；RABBITMQ_DEFAULT_USER：默认的用户名；RABBITMQ_DEFAULT_PASS：默认用户名的密码）
3.访问 (如下图)
http://ip:15672 账号 :admin 密码: admin
<a name="b741af20"></a># Docker网络原理<a name="y4Mfe"></a>## 理解Docker0学习之前清空下前面的docker 镜像、容器`$ docker rm -f $(docker ps -aq) # 删除全部容器 $ docker rmi -f $(docker images -aq) # 删除全部镜像`测试通过`ip addr`访问ip地址<br />**Docker 是如果处理容器网络访问的？**
测试 运行一个tomcat
$ docker run -d -P —name tomcat01 tomcat
查看容器内部网络地址
$ docker exec -it 容器id ip addr
发现容器启动的时候会得到一个 eth0@if91 ip地址，docker分配！
$ ip addr
1: lo:
思考？ linux能不能ping通容器内部！ 可以 容器内部可以ping通外界吗？ 可以！
$ ping 172.18.0.2 PING 172.18.0.2 (172.18.0.2) 56(84) bytes of data. 64 bytes from 172.18.0.2: icmp_seq=1 ttl=64 time=0.069 ms 64 bytes from 172.18.0.2: icmp_seq=2 ttl=64 time=0.074 ms
**原理**<br />1、我们每启动一个docker容器，docker就会给docker容器分配一个ip，我们只要按照了docker，就会有一个docker0桥接模式，使用的技术是veth-pair技术！(veth-pair参考：[https://www.cnblogs.com/bakari/p/10613710.html](https://www.cnblogs.com/bakari/p/10613710.html)）<br />再次测试 ip addr<br />再启动一个容器测试，发现又多了一对网络<br />`# 我们发现这个容器带来网卡，都是一对对的# veth-pair 就是一对的虚拟设备接口，他们都是成对出现的，一端连着协议，一端彼此相连# 正因为有这个特性 veth-pair 充当一个桥梁，连接各种虚拟网络设备的# OpenStac,Docker容器之间的连接，OVS的连接，都是使用evth-pair技术`<br />我们来测试下tomcat01和tomcat02是否可以ping通
获取tomcat01的ip 172.17.0.2
$ docker-tomcat docker exec -it tomcat01 ip addr
550: eth0@if551:
让tomcat02 ping tomcat01
$ docker-tomcat docker exec -it tomcat02 ping 172.17.0.2 PING 172.17.0.2 (172.17.0.2) 56(84) bytes of data. 64 bytes from 172.17.0.2: icmp_seq=1 ttl=64 time=0.098 ms 64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.071 ms
结论：容器和容器之间是可以互相ping通
**网络模型图**<br /><br />Docker中所有网络接口都是虚拟的，虚拟的转发效率高（内网传递文件）只要容器删除，对应的网桥一对就没了！<a name="9l1Ef"></a>## 自定义网络【推荐】**思考一个场景**：我们编写了一个微服务，database url=ip: 项目不重启，数据ip换了，我们希望可以处理这个问题，可以通过名字来进行访问容器？- **–link **可以实现容器名连接，但其本质是在hosts配置中添加映射，现在使用Docker已经不建议使用–link了！ 不适用docker0（docker0特点：默认，域名不能访问。 --link可以打通连接，但是很麻烦！docker0问题：不支持容器名连接访问！）
-link示例：
$ docker exec -it tomcat02 ping tomca01 # ping不通 ping: tomca01: Name or service not known
运行一个tomcat03 —link tomcat02
$ docker run -d -P —name tomcat03 —link tomcat02 tomcat 5f9331566980a9e92bc54681caaac14e9fc993f14ad13d98534026c08c0a9aef
3连接2
用tomcat03 ping tomcat02 可以ping通
$ docker exec -it tomcat03 ping tomcat02 PING tomcat02 (172.17.0.3) 56(84) bytes of data. 64 bytes from tomcat02 (172.17.0.3): icmp_seq=1 ttl=64 time=0.115 ms 64 bytes from tomcat02 (172.17.0.3): icmp_seq=2 ttl=64 time=0.080 ms
2连接3
用tomcat02 ping tomcat03 ping不通
- **自定义网络【推荐】**
docker network语法
docker network connect — Connect a container to a network create — Creates a new network with a name specified by the disconnect — Disconnects a container from a network inspect — Displays detailed information on a network ls — Lists all the networks created by the user prune — Remove all unused networks rm — Deletes one or more network
**网络模式**- bridge ：桥接 docker（默认，自己创建也是用bridge模式）<br />- none ：不配置网络，一般不用<br />- host ：和所主机共享网络<br />- container ：容器网络连通（用得少！局限很大）<br />自定义网络--测试
我们直接启动的命令 —net bridge, 而这个就是我们得docker0
bridge就是docker0
$ docker run -d -P —name tomcat01 tomcat 等价于 => docker run -d -P —name tomcat01 —net bridge tomcat
docker0，特点：默认，域名不能访问。 —link可以打通连接，但是很麻烦！
我们可以 自定义一个网络
—driver bridge
—subnet 192.168.0.0/16 子网掩码
—gateway 192.168.0.1 网关地址
$ docker network create —driver bridge —subnet 192.168.0.0/16 —gateway 192.168.0.1 mynet
$ docker network inspect mynet;
启动两个tomcat,再次查看网络情况
[root@izuf6hlvm1mj8gdbdctw0rz ~]# docker run -d -P —name tomcat-net-01 —net mynet tomcat d84b618132cb597df982508f14992b5c752dfebb12fcabb1f9ffe39ead356d6d
[root@izuf6hlvm1mj8gdbdctw0rz ~]# docker run -d -P —name tomcat-net-02 —net mynet tomcat 146ee8b0ad2d89d8e77870b9a93f5f1da742c2e9e696a9a3f798b8146607d5cf
在自定义的网络下，容器之间可以相互ping通！**既可以ping ip地址，也可以直接ping容器名称。**<br /><br />我们自定义的网络docker都已经帮我们维护好了对应的关系，推荐我们平时这样使用网络!**<br />**好处：**- redis -不同的集群使用不同的网络，保证集群是安全和健康的<br />- mysql-不同的集群使用不同的网络，保证集群是安全和健康的<br /><a name="Mfegi"></a>## 网络连通思考下图中的tomcat01和tomcat-net-01可以连通吗？<br />答案是不能！如下图所示<br />因为它们根本不在一个网段。那么怎么样才能让他们连通呢？<br />**答案**：假设要跨网络操作别人，就需要使用`docker network connect` 连通！<br /><br /><br />需要将容器和网络打通<br /><br />**`docker network connect mynet tomcat-01 #执行命令，将网络mynet和tomcat01打通`**此时查看一下mynet的信息`docker inspect mynet ` 发现tomcat01直接被写进了mynet的配置，分配了指定的ip<br />这次我们再去ping一下`docker exec -it tomcat-01 ping tomcat-net-01`，现在tomcat01已经可以ping通tomcat-net-01<br />而未打通网络的tomcat-02依旧连不通`docker exec -it tomcat-02 ping tomcat-net-01`<a name="NLVmU"></a>## <a name="lJScI"></a>## 补充： 计算机IP地址划分- 以常见的B类IP地址为例：B类IP地址范围128.1.0.1-191.254.255.254（二进制表示为：10000000 00000001 00000000 00000001 - 10111111 11111110 11111111 11111110）- 如**192**.**168**.**0**.**1 **一共四段，转换成二进制每段就是**8**位。192.168.0.1/8（表示仅最后一段可用，范围为192.168.0.1 - 192.168.0.254，最多可连254台主机，同理，192.168.0.1/16 或 192.168.0.1/24（分别表示最后2段 和 最后3段可用，可连最大物理主机数约为254*254，254*254*254）<a name="19cfC"></a>## 实战：部署Redis集群
创建网卡
docker network create redis —subnet 172.38.0.0/16
通过脚本创建六个redis配置
for port in $(seq 1 6);\ do \ mkdir -p /mydata/redis/node-${port}/conf touch /mydata/redis/node-${port}/conf/redis.conf cat << EOF >> /mydata/redis/node-${port}/conf/redis.conf port 6379 bind 0.0.0.0 cluster-enabled yes cluster-config-file nodes.conf cluster-node-timeout 5000 cluster-announce-ip 172.38.0.1${port} cluster-announce-port 6379 cluster-announce-bus-port 16379 appendonly yes EOF done
通过脚本运行六个redis
for port in $(seq 1 6);\ docker run -p 637${port}:6379 -p 1667${port}:16379 —name redis-${port} \ -v /mydata/redis/node-${port}/data:/data \ -v /mydata/redis/node-${port}/conf/redis.conf:/etc/redis/redis.conf \ -d —net redis —ip 172.38.0.1${port} redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf docker exec -it redis-1 /bin/sh #redis默认没有bash redis-cli —cluster create 172.38.0.11:6379 172.38.0.12:6379 172.38.0.13:6379 172.38.0.14:6379 172.38.0.15:6379 172.38.0.16:6379 —cluster-replicas 1
我们使用docker之后，所有的技术都会慢慢变得简单起来！<a name="icGOc"></a>## SpringBoot微服务打包Docker镜像1. 构建SpringBoot项目1. 打包运行 `mvn package`1. 编写DockerFile
FROM java:8 COPY *.jar /app.jar CMD [“—server.port=8080”] EXPOSE 8080 ENTRYPOINT [“java”,”-jar”,”app.jar”]
4. 构建镜像
1.复制jar和DockerFIle 到服务器
2.构建镜像
$ docker build -t 镜像名:tag .
```
- 发布运行(以后我们使用了Docker之后，给别人交付就是一个镜像即可！)
关于Docker更深入的技术（compose，swarm等）后面再学习补充！
本文参考
1.博客文章：https://blog.csdn.net/qq_43371556/article/details/102631158，https://blog.csdn.net/danggang0317/article/details/113408905
2.b站狂神说教学视频【墙裂推荐】：https://www.bilibili.com/video/BV1og4y1q7M4?p=32&t=168
若有收获，就点个赞吧
0 人点赞
