网站建设与开发考试,wordpress 主题next,dede 更新网站地图,泰州网络营销目录说明docker简介为什么是docker容器与虚拟机比较容器发展简史传统虚拟机技术容器虚拟化技术docker能干什么带来技术职级的变化开发/运维#xff08;Devops)新一代开发工程师Docker应用场景why docker#xff1f;docker的优势docker和dockerHub官网Docker安装CentOS Docker…
目录说明docker简介为什么是docker容器与虚拟机比较容器发展简史传统虚拟机技术容器虚拟化技术docker能干什么带来技术职级的变化开发/运维Devops)新一代开发工程师Docker应用场景why dockerdocker的优势docker和dockerHub官网Docker安装CentOS Docker安装docker查看自己的内核安装阿里云镜像加速永远的HelloWorldDocker的基本组成镜像image容器container仓库repository小总结Docker平台架构图解Docker工作原理整体架构及底层通信原理简述Docker运行的基本流程底层原理为什么Docker会比VM虚拟机快Docker常用命令帮助启动类命令镜像命令docker imagesdocker searchdocker pulldocker system df 查看镜像/容器/数据卷所占用的空间docker rmi 删除镜像docker虚悬镜像容器命令新建启动容器启动守护式容器后台服务器docker ps列出当前所有正在运行的容器退出容器启动已停止运行的容器docker logs查看容器日志docker top查看容器内运行的进程docker inspect查看容器内部细节审查容器docker exec进入正在运行的容器并以命令行交互docker cp从容器内拷贝文件到主机上导入和导出容器总结Docker镜像Docker镜像加载原理为什么Docker镜像要采用分层结构Docker镜像commit操作案例本地镜像发布到阿里云本地镜像发布到阿里云流程镜像生成的方法将本地镜像推送到阿里云将阿里云上的镜像下载到本地本地镜像发布到私有库本地镜像发布到私有库流程Docker容器数据卷使用特性数据卷案例宿主vs容器之间映射添加容器卷读写规则映射添加说明卷的集成和共享Docker常规安装简介安装tomcat安装mysql安装redisdocker复杂安装安装mysql主从复制安装redis集群(cluster)主从容错切换迁移案例容错切换迁移主从扩容案例DockerFile解析DockerFile是什么DockerFile构建过程解析DockerFile内容基础知识Docker执行DockerFile的大致流程小总结DockerFile常用保留字指令小总结自定义镜像mycentosjava8目标编写构建运行虚悬镜像家庭作业自定义myubuntuDocker网络Docker 网络是什么docker不启动默认网络情况docker启动后网络情况常用基本命令All 命令docker network ls查看网络查看网络源数据删除网络能干嘛网络模式总体介绍容器实例内默认网络IP生产规则案例说明bridge案例两两匹配验证Host是什么案例none是什么案例container自定义网络Docker平台架构图解Docker轻量级可视化工具Portainerdocker安装说明
docker全解仅以作者【在读大学生】视角去认识学习使用docker且以使用为主学习底层为辅进行书写欢迎读者斧正。
docker简介
为什么是docker
Docker的出现得以打破过去「程序即应用」的观念。透过镜像(images)将作业系统核心除外运作应用程式所需要的系统环境由下而上打包达到应用程式跨平台间的无缝接轨运作。【docker理念】解决了运行环境和配置问题的软件容器方便持续继承并有助于整体发布的容器虚拟化技术。
容器与虚拟机比较
容器发展简史 传统虚拟机技术 虚拟机virtual machine就是带环境安装的一种解决方案。 它可以在一种操作系统里面运行另一种操作系统比如在Windows10系统里面运行Linux系统CentOS7。应用程序对此毫无感知因为虚拟机看上去跟真实系统一模一样而对于底层系统来说虚拟机就是一个普通文件不需要了就删掉对其他部分毫无影响。这类虚拟机完美的运行了另一套系统能够使应用程序操作系统和硬件三者之间的逻辑不变。 虚拟机的缺点 资源占用多冗余步骤多启动慢
容器虚拟化技术
由于前面虚拟机存在某些缺点Linux发展出了另一种虚拟化技术
Linux容器(Linux Containers缩写为 LXC)
Linux容器是与系统其他部分隔离开的一系列进程从另一个镜像运行并由该镜像提供支持进程所需的全部文件。容器提供的镜像包含了应用的所有依赖项因而在从开发到测试再到生产的整个过程中它都具有可移植性和一致性。
Linux 容器不是模拟一个完整的操作系统 而是对进程进行隔离。有了容器就可以将软件运行所需的所有资源打包到一个隔离的容器中。
容器与虚拟机不同不需要捆绑一整套操作系统 只需要软件工作所需的库资源和设置。系统因此而变得高效轻量并保证部署在任何环境中的软件都能始终如一地运行。 传统虚拟机技术是虚拟出一套硬件后在其上运行一个完整操作系统在该系统上再运行所需应用进程 容器内的应用进程直接运行于宿主的内核容器内没有自己的内核且也没有进行硬件虚拟 。因此容器要比传统虚拟机更为轻便。 每个容器之间互相隔离每个容器有自己的文件系统 容器之间进程不会相互影响能区分计算资源。
docker能干什么
带来技术职级的变化
coder - programmer - software engineer - DevOps engineer
开发/运维Devops)新一代开发工程师
一次构建、随处运行更快速的应用交付和部署更便捷的升级和扩缩容更简单的系统运维更高效的计算资源利用
Docker应用场景 Docker 借鉴了集装箱的概念集装箱将货物运往世界各地Docker将这个模型运用到自己的设计中唯一不同的是集装箱运输货物而Docker运输软件。
why docker docker的优势 docker和dockerHub官网
dockerdockerdockerHubdockerHub
Docker安装
CentOS Docker安装docker
建议安装在linux系统上以使用最广泛的centos为例。Docker运行在CentOS 764-bit上要求系统为64位Linux系统内核版本为3.8以上这里选用Centos7.x。
查看自己的内核
uname 命令用于打印当前系统相关信息内核版本号硬件架构主机名称和操作系统类型等 uname - r3.10.0-1160.el7.x86_64查看发行版本 cat /etc/redhat-releaseCentOS Linux release 7.9.2009 (Core)安装
参考官网docker for linux
卸载旧版本docker如果未安装可以跳过)
# 卸载旧版本docker命令
$ sudo yum remove docker docker-client docker-client-latest docker-common docker-latest docker-latest-logrotate docker-logrotate docker-engine yum安装gcc相关命令
# yum安装gcc相关命令
yum -y install gcc
yum -y install gcc-c安装 yum-utils 包
# 官网要求
yum install -y yum-utils设置stable镜像仓库
# 推荐使用 使用阿里的 docker 镜像仓库国外的镜像仓库是比较慢的
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo更新yum软件包索引
# 更新yum软件包索引
yum makecache fast安装DOCKER CE 引擎
# 命令
yum -y install docker-ce docker-ce-cli containerd.io启动docker
# 启动命令
systemctl start docker测试
# 测试
docker version docker run hello-world卸载【卸载命令不是安装步骤里的】
# 卸载命令
systemctl stop docker
yum remove docker-ce docker-ce-cli containerd.io
rm -rf /var/lib/docker
rm -rf /var/lib/containerd阿里云镜像加速
地址https://cr.console.aliyun.com/cn-wulanchabu/instances/mirrors
获得加速器地址连接
登陆阿里云开发者平台点击控制台选择容器镜像服务获取加速器地址粘贴脚本直接执行
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json -EOF
{registry-mirrors: [你的专属容器镜像加速地址]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker永远的HelloWorld
# 命令
docker run hello-worldDocker的基本组成
镜像image Docker 镜像Image就是一个 只读 的模板。镜像可以用来创建 Docker 容器 一个镜像可以创建很多容器 。 它也相当于是一个root文件系统。比如官方镜像 centos:7 就包含了完整的一套 centos:7 最小系统的 root 文件系统。 相当于容器的“源代码”。
容器container 从面向对象角度 Docker 利用容器Container独立运行的一个或一组应用应用程序或服务运行在容器里面容器就类似于一个虚拟化的运行环境 容器是用镜像创建的运行实例 。就像是Java中的类和实例对象一样镜像是静态的定义容器是镜像运行时的实体。容器为镜像提供了一个标准的和隔离的运行环境 它可以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台 从镜像容器角度 可以把容器看做是一个简易版的 *Linux* 环境 包括root用户权限、进程空间、用户空间和网络空间等和运行在其中的应用程序。
仓库repository 仓库Repository是 集中存放镜像 文件的场所。 类似于github仓库存放各种git项目的地方 Docker公司提供的官方registry被称为Docker Hub存放各种镜像模板的地方。 仓库分为公开仓库Public和私有仓库Private两种形式。 最大的公开仓库是 Docker Hub(https://hub.docker.com/) 存放了数量庞大的镜像供用户下载。国内的公开仓库包括阿里云 、网易云等
小总结 需要正确的理解仓库/镜像/容器这几个概念: Docker 本身是一个容器运行载体或称之为管理引擎。我们把应用程序和配置依赖打包好形成一个可交付的运行环境这个打包好的运行环境就是image镜像文件。只有通过这个镜像文件才能生成Docker容器实例(类似Java中new出来一个对象)。 image文件可以看作是容器的模板。Docker 根据 image 文件生成容器的实例。同一个 image 文件可以生成多个同时运行的容器实例。 镜像文件 image 文件生成的容器实例本身也是一个文件称为镜像文件。 容器实例 一个容器运行一种服务当我们需要的时候就可以通过docker客户端创建一个对应的运行实例也就是我们的容器 。 仓库就是放一堆镜像的地方我们可以把镜像发布到仓库中需要的时候再从仓库中拉下来就可以了。
Docker平台架构图解 Docker工作原理
Docker是一个Client-Server结构的系统Docker守护进程运行在主机上 然后通过Socket连接从客户端访问守护进程从客户端接受命令并管理运行在主机上的容器 。
容器是一个运行时环境就是我们前面说到的集装箱可以对比mysql演示对比讲解 整体架构及底层通信原理简述
Docker是一个C/S模式的架构后端是一个松耦合架构众多模块各司其职
Docker运行的基本流程
用户是使用Docker Client 与Docker Daemon 建立通信并发送请求给后者。Docker Daemon 作为Docker架构中的主体部分首先提供Docker Server 的功能时期可以接受 Docker Client的请求。Docker Engine 执行Docker内部的一些列工作每一项工作都是以一个Job的形式的存在。Job的运行过程中当需要容器镜像是则从Docker Register中下载镜像并通过镜像管理驱动Graph driver 将下载镜像以Graph的形式存储。当需要为Docker创建网络环境时通过网络驱动Network driver创建并配置Docker容器网络环境。当需要限制Docker容器运行资源或执行用户指令等操作时则通过Exec driver来完成。Libcontainer是一项独立的容器管理包Network driver以及Exec driver都是通过Libcontainer来实现具体容器进行的操作。 底层原理为什么Docker会比VM虚拟机快 docker有着比虚拟机更少的抽象层 由于docker不需要Hypervisor(虚拟机)实现硬件资源虚拟化,运行在docker容器上的程序直接使用的都是实际物理机的硬件资源。因此在CPU、内存利用率上docker将会在效率上有明显优势。 docker利用的是宿主机的内核,而不需要加载操作系统OS内核 当新建一个容器时,docker不需要和虚拟机一样重新加载一个操作系统内核。进而避免引寻、加载操作系统内核返回等比较费时费资源的过程,当新建一个虚拟机时,虚拟机软件需要加载OS,返回新建过程是分钟级别的。而docker由于直接利用宿主机的操作系统,则省略了返回过程,因此新建一个docker容器只需要几秒钟。 Docker常用命令
帮助启动类命令
# 启动命令
systemctl start docker
# 停止命令
systemctl stop docker
# 重启命令
systemctl restart docker
# 查看docker状态
systemctl status docker
# 开机启动
systemctl enable docker
# 查看 docker 概要信息
docker info
# 查看docker 总体帮助文档
docker --help
# 查看docker命令帮助文档
docker 具体命令 --help镜像命令
docker images
# 列出本地主机上的镜像
docker images 各个选项说明:
REPOSITORY表示镜像的仓库源TAG镜像的标签版本号IMAGE ID镜像IDCREATED镜像创建时间SIZE镜像大小
同一仓库源可以有多个 TAG版本代表这个仓库源的不同个版本使用 REPOSITORY:TAG 来定义不同的镜像。
如果你不指定一个镜像的版本标签例如你只使用 ubuntudocker 将默认使用 ubuntu:latest 镜像
OPTIONS 说明
-a : 列出本地所有的镜像含历史映像层 -q只显示镜像ID
docker search
# 网站
https://hub.docker.com
# 命令
docker search [OPTIONS]镜像名字
# OPTIONS说明
# --limit 只列出N个镜像默认25个
docker search --limit 5 redisdocker pull
# 下载镜像
docker pull 镜像名字[:TAG]
docker pull 镜像名字 # 没有TAG就是最新版本 等价于
docker pull 镜像名字latest
docker pull ubuntu docker system df 查看镜像/容器/数据卷所占用的空间
docker system dfdocker rmi 删除镜像
# 删除单个
docker rmi -f 镜像ID# 删除多个
docker rmi -f 镜像名1:TAG 镜像名2:TAG# 删除全部
docker rmi -f $(docker images -qa)docker虚悬镜像
仓库名称标签都是的镜像俗称虚悬镜像dangling image
容器命令
有镜像才能创建容器这是根本前提我目前是在windows系统上开启VM虚拟机安装了一个centos7又在其上安装了docker利用docker创建了一个centos7.5的容器。 新建启动容器
docker run [OPTIONS] IMAGE [COMMAND] [ARG...]OPTIONS说明常用
–name“容器新名字” 为容器指定一个名称-d: 后台运行容器并返回容器ID也即启动守护式容器(后台运行)-i以交互模式运行容器通常与 -t 同时使用-t为容器重新分配一个伪输入终端通常与 -i 同时使用 也即 启动交互式容器(前台有伪终端等待交互)-P: 随机 端口映射大写P-p: 指定 端口映射小写p 启动守护式容器后台服务器
在大部分的场景下我们希望docker的服务是在后台运行的我们可以通过 -d 指定容器的后台运行模式。
docker run -d 容器名
# 使用镜像centos:latest以后台模式启动一个容器
docker run -d centos 问题然后docker ps -a 进行查看, 会发现容器已经退出。
注意Docker容器后台运行,就必须有一个前台进程容器运行的命令如果不是那些 一直挂起的命令 比如运行toptail就会自动退出的。
这个是docker的机制问题,以nginx为例正常情况下, 配置启动服务只需要启动响应的service即可。例如service nginx start或者systemctl start nginx 这样做,nginx为后台进程模式运行,就导致docker前台没有运行的应用, 这样的容器后台启动后,会立即自杀因为他觉得他没事可做了. 所以最佳的解决方案是, 将你要运行的程序以前台进程的形式运行常见就是命令行模式表示我还有交互操作别中断。
# 前台交互式启动
docker run -it redis:6.0.8
# 后台交互式启动
docker run -d redis:6.0.8docker ps列出当前所有正在运行的容器
# 列出当前所有正在运行的容器
docker ps [OPTIONS]
# OPTIONS说明
-a : 列出当前所有 正在运行 的容器 历史上运行过 的
-l :显示最近创建的容器。
-n显示最近n个创建的容器。
-q :静默模式只显示容器编号。 OPTIONS说明
-a : 列出当前所有 正在运行 的容器 历史上运行过 的-l :显示最近创建的容器。-n显示最近n个创建的容器。-q :静默模式只显示容器编号。
退出容器
# 两种退出方式
# 1、run进去容器exit退出容器停止
exit
# 2、run进去容器ctrlpq退出容器不停止
ctrlpq启动已停止运行的容器
# 启动已停止运行的容器
docker start 容器ID或者容器名
# 重启容器
docker restart 容器ID或者容器名
# 停止容器
docker stop 容器ID或者容器名
# 强制停止容器
docker kill 容器ID或容器名
# 删除已停止的容器
docker rm 容器ID
# 一次性删除多个容器实例
docker rm -rf $(docker ps -a -q)docker ps -a -q | xargs docker rmdocker logs查看容器日志
# 查看容器日志
docker logs 容器IDdocker top查看容器内运行的进程
# 查看容器内运行的进程
docker top 容器IDdocker inspect查看容器内部细节审查容器
# 查看容器内部细节
docker inspect 容器IDdocker exec进入正在运行的容器并以命令行交互
# 进入容器
docker exec -it 容器ID bashShell
docker exec -it 16dhh212 bash# 重新进入
docker attach 容器ID区别
attach 直接进入容器启动命令的终端不会启动新的进程用exit退出会导致容器的停止。exec 是在容器中打开新的终端并且可以启动新的进程用exit退出不会导致容器的停止。
docker cp从容器内拷贝文件到主机上
# 容器 - 主机
docker cp 容器ID:容器内路径 目的主机路径导入和导出容器
Export 导出容器的内容留作为一个tar归档文件[对应import命令]import 从tar 包中的内容创建一个新的文件系统再导入为镜像[对应export]
# 导出
docker export 容器ID 文件.tar # 导入
cat 文件名.tar | docker import -镜像用户/镜像名:镜像版本号总结 attach Attach to a running container # 当前 shell 下 attach 连接指定运行镜像
build Build an image from a Dockerfile # 通过 Dockerfile 定制镜像
commit Create a new image from a container changes # 提交当前容器为新的镜像
cp Copy files/folders from the containers filesystem to the host path #从容器中拷贝指定文件或者目录到宿主机中
create Create a new container # 创建一个新的容器同 run但不启动容器
diff Inspect changes on a containers filesystem # 查看 docker 容器变化
events Get real time events from the server # 从 docker 服务获取容器实时事件
exec Run a command in an existing container # 在已存在的容器上运行命令
export Stream the contents of a container as a tar archive # 导出容器的内容流作为一个 tar 归档文件[对应 import ]
history Show the history of an image # 展示一个镜像形成历史
images List images # 列出系统当前镜像
import Create a new filesystem image from the contents of a tarball # 从tar包中的内容创建一个新的文件系统映像[对应export]
info Display system-wide information # 显示系统相关信息
inspect Return low-level information on a container # 查看容器详细信息
kill Kill a running container # kill 指定 docker 容器
load Load an image from a tar archive # 从一个 tar 包中加载一个镜像[对应 save]
login Register or Login to the docker registry server # 注册或者登陆一个 docker 源服务器
logout Log out from a Docker registry server # 从当前 Docker registry 退出
logs Fetch the logs of a container # 输出当前容器日志信息
port Lookup the public-facing port which is NAT-ed to PRIVATE_PORT # 查看映射端口对应的容器内部源端口
pause Pause all processes within a container # 暂停容器
ps List containers # 列出容器列表
pull Pull an image or a repository from the docker registry server # 从docker镜像源服务器拉取指定镜像或者库镜像
push Push an image or a repository to the docker registry server # 推送指定镜像或者库镜像至docker源服务器
restart Restart a running container # 重启运行的容器
rm Remove one or more containers # 移除一个或者多个容器
rmi Remove one or more images # 移除一个或多个镜像[无容器使用该镜像才可删除否则需删除相关容器才可继续或 -f 强制删除]
run Run a command in a new container # 创建一个新的容器并运行一个命令
save Save an image to a tar archive # 保存一个镜像为一个 tar 包[对应 load]
search Search for an image on the Docker Hub # 在 docker hub 中搜索镜像
start Start a stopped containers # 启动容器
stop Stop a running containers # 停止容器
tag Tag an image into a repository # 给源中镜像打标签
top Lookup the running processes of a container # 查看容器中运行的进程信息
unpause Unpause a paused container # 取消暂停容器
version Show the docker version information # 查看 docker 版本号
wait Block until a container stops, then print its exit code # 截取容器停止时的退出状态值 Docker镜像
【镜像】
是一种轻量级、可执行的独立软件包它包含运行某个软件所需的所有内容
我们把应用程序和配置依赖打包好形成一个可交付的运行环境(包括代码、运行时需要的库、环境变量和配置文件等)
这个打包好的运行环境就是image镜像文件。只有通过这个镜像文件才能生成Docker容器实例。【分层镜像】
以我们的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。 rootfs (root file system) 在bootfs之上 。包含的就是典型 Linux 系统中的 /dev, /proc, /bin, /etc 等标准目录和文件。rootfs就是各种不同的操作系统发行版比如UbuntuCentos等等。 对于一个精简的OSrootfs可以很小只需要包括最基本的命令、工具和程序库就可以了因为底层直接用Host的kernel自己只需要提供 rootfs 就行了。由此可见对于不同的linux发行版, bootfs基本是一致的, rootfs会有差别, 因此不同的发行版可以公用bootfs。
为什么Docker镜像要采用分层结构 镜像分层最大的一个好处就是共享资源方便复制迁移就是为了复用。 比如说有多个镜像都从相同的 base 镜像构建而来那么 Docker Host 只需在磁盘上保存一份 base 镜像 同时内存中也只需加载一份 base 镜像就可以为所有容器服务了。而且镜像的每一层都可以被共享。 Docker镜像层都是只读的容器层是可写的当容器启动时一个新的可写层被加载到镜像的顶部。这一层通常被称作容器层“容器层之下的都叫镜像层”。 所有对容器的改动 - 无论添加、删除、还是修改文件都只会发生在容器层中。只有容器层是可写的容器层下面的所有镜像层都是只读的。 Docker镜像commit操作案例
docker commit 提交容器副本使之成为一个新的镜像docker commit -m提交的描述信息 -a作者 容器ID 要创建的目标镜像名:[标签名]运行一个乌班图
docker pull -it ubuntu容器内安装vim
apt-get update apt-get -y install vim 容器内commit
docker commit -madd vim -aGeneralzy 容器ID Generalzy/Ubuntu:0.0.1启动新镜像可以正常使用vim命令了
docker images
# 以bash进去
docker run -it 镜像ID bash本地镜像发布到阿里云
本地镜像发布到阿里云流程 镜像生成的方法
基于当前容器创建一个新的镜像新功能增强
docker commit [OPTIONS]容器ID [REPOSOTORY[:TAG]]OPTIONS说明 -a :提交的镜像作者 -m :提交时的说明文字
将本地镜像推送到阿里云
# 用户名登录
docker login --username${username} registry.cn-hangzhou.aliyuncs.com
password:# 将镜像ID打标签 标签格式一般为: dockerHub地址/用户名/镜像名:版本号
# 等同于将go mod init github.com/Generalzy/项目名
docker tag cea1bb40441c registry.cn-hangzhou.aliyuncs.com/atguiguwh/myubuntu:1.1 # 推到dockerHub
docker push registry.cn-hangzhou.aliyuncs.com/atguiguwh/myubuntu:1.1 将阿里云上的镜像下载到本地
# 点名道姓下载刚才自己推上去的镜像
docker pull registry.cn-hangzhou.aliyuncs.com/atguiguwh/myubuntu:1.1 本地镜像发布到私有库
本地镜像发布到私有库流程 下载镜像Docker Registry docker pull registry 运行私有库Registry相当于本地有个私有库Docker hub docker run -d -p 5000:5000 -v /zzyyuse/myregistry/:/tmp/registry --privilegedtrue registry 默认情况仓库被创建在容器的/var/lib/registry目录下建议自行用容器卷映射方便于宿主机联调 从Hub上下载ubuntu镜像到本地并成功运行原始Ubuntu镜像是不带着ifconfig命令的 docker run -ti ubuntu bash
# 安装ifconfig
apt-get update
apt-get install net-tools 安装完成后commit我们自己的新镜像 docker commit -m 提交的描述信息 -a 作者 容器 ID 要创建的目标镜像名 :[ 标签名 ]
在容器外执行记得
docker commit -m ifconfig cmd add -a zzyy a69d7c825c4f zzyyubuntu:1.2 curl验证私服库上有什么镜像 curl -XGET http://192.168.111.162:5000/v2/_catalog 将新镜像zzyyubuntu:1.2修改符合私服规范的Tag 按照公式 docker tag 镜像:Tag Host:Port/Repository:Tag
使用命令 docker tag 将zzyyubuntu:1.2 这个镜像修改为 你的IP:5000/zzyyubuntu:1.2 docker tag zzyyubuntu:1.2 你的IP:5000/zzyyubuntu:1.2 修改配置文件使之支持http vim命令新增如下内容vim /etc/docker/daemon.json
{registry-mirrors: [阿里云加速镜像] , insecure-registries: [你的仓库IP:5000] } docker默认不允许http方式推送镜像通过配置选项来取消这个限制。 push推送到私服库 docker push 私服IP:5000/zzyyubuntu:1.2 curl验证私服库上有什么镜像 curl -XGET http://私服IP:5000/v2/_catalog pull到本地并运行 docker pull 你的IP/zzyyubuntu:1.2 Docker容器数据卷
Docker挂载主机目录访问 如果出现cannot open directory .: Permission denied
解决办法在挂载目录后多加一个--privilegedtrue参数即可
如果是CentOS7安全模块会比之前系统版本加强不安全的会先禁止所以目录挂载的情况被默认为不安全的行为 在SELinux里面挂载目录被禁止掉了额如果要开启我们一般使用--privilegedtrue命令扩大容器的权限解决挂载目录没有权限的问题也即使用该参数container内的root拥有真正的root权限否则container内的root只是外部的一个普通用户权限。
使用
# 将docker容器内的数据保存进宿主机的磁盘中
# 运行一个带有容器卷存储功能的容器实例
docker run -it --privilegedtrue -v /宿主机绝对路径目录:/容器内目录 镜像名特性
将运用与运行的环境打包镜像run后形成容器实例运行 但是我们对数据的要求希望是 持久化的
Docker容器产生的数据如果不备份那么当容器实例删除后容器内的数据自然也就没有了。 为了能保存数据在docker中我们使用卷。
特点 1数据卷可在容器之间共享或重用数据 2卷中的更改可以直接实时生效。 3数据卷中的更改不会包含在镜像的更新中 4数据卷的生命周期一直持续到没有容器使用它为止
数据卷案例
宿主vs容器之间映射添加容器卷
直接命令添加
# docker run -it -v /宿主机目录:/容器内目录
docker run -it --name myu3 --privilegedtrue -v /tmp/myHostData:/tmp/myDockerData ubuntu /bin/bash 查看数据卷是否挂成功
docker inspect 容器ID 容器和宿主机之间数据共享
1. docker修改主机同步获得
2. 主机修改docker同步获得
3. docker容器stop主机修改docker容器重启看数据是否同步。读写规则映射添加说明
读写(默认)
docker run -it --privilegedtrue -v /宿主机绝对路径目录:/容器内目录:rw 镜像名只读容器实例内部被限制只能读取不能写
docker run -it --privilegedtrue -v /宿主机绝对路径目录:/容器内目录:ro 镜像名卷的集成和共享
容器1完成和宿主机的映射
docker run -it --privilegedtrue -v /mydocker/u:/tmp --name u1 ubuntu 容器2集成容器1的卷规则
docker run -it --privilegedtrue --volumes-from 父类 --name u2 ubuntuDocker常规安装简介
安装tomcat
# 命令
docker search tomcat# 命令
docker pull tomcat# 命令
docker images tomcat# 命令
docker run -it -p 8080:8080 tomcat可能出现404 的情况解决
可能没有映射端口或者没有关闭防火墙进入容器把webapps.dist 目录换成webapps
安装mysql
# 命令
docker search mysql# 命令
docker pull mysql:5.7# 命令 参考https://hub.docker.com/_/mysql
docker run -p 3306:3306 -e MYSQL_ROOT_PASSWORD123456 -d mysql:5.7 # 进入容器
docker exec -it 容器ID /bin/bash
mysql -uroot -p实战版
#1、新建mysql容器实例
docker run -d -p 3306:3306 --privilegedtrue -v /zzyyuse/mysql/log:/var/log/mysql -v /zzyyuse/mysql/data:/var/lib/mysql -v /zzyyuse/mysql/conf:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD123456 --name mysql mysql:5.7 #2、新建my.cnf 通过容器卷同步给MySQL容器实例
[client]
default_character_setutf8
[mysqld]
collation_server utf8_general_ci
character_set_server utf8 #3、重新启动mysql容器实例在重新进入并查看字符编码
docker restart mysql
docker exec -it mysql_bash
show variables like character%;#4、再新建库新建表再插入中文测试
完全正常#5、结论
之前的DB 无效
修改字符集操作重启mysql容器实例
之后的DB 有效需要新建
结论 docker安装完MySQL并run出容器后建议请先修改完字符集编码后再新建mysql库-表-插数据 #6、假如将当前容器实例删除再重新来一次之前建的db01实例还有吗trytry安装redis
# 拉去镜像
docker pull redis:6.0.8
# 查看镜像
docker images# 启动命令
docker run -d -p 6379:6379 redis:6.0.8
# docker ps
# 后台启动
docker exec -it CONTAINER ID /bin/bash# 在CentOS宿主机下新建目录/app/redis
mkdir -p /app/redis# 将一个redis.conf文件模板拷贝进 /app/redis目录下
mkdir -p /app/redis
cp /myredis/redis.conf /app/redis/
cp /app/redis# /app/redis 目录下修改redis.conf
# 修改redis.conf文件
1. 开启redis验证 可选
requirepass 123
2. 允许redis外地连接 必须
3. 注释掉 # bind 127.0.0.1
# 注释daemonize no
将daemonize yes注释起来或者 daemonize no设置因为该配置和docker run中-d参数冲突会导致容器一直启动失败
# 开启redis数据持久化
appendonly yes 可选 # 使用redis6.0.8 镜像创建容器(也叫运行镜像)
docker run -p 6379:6379 --name myr3 --privilegedtrue -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主从复制
# 新建主服务器容器实例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_PASSWORDroot \
-d mysql:5.7 # 进入/mydata/mysql-master/conf目录下新建my.cnf
[mysqld]
## 设置server_id同一局域网中需要唯一
server_id101
## 指定不需要同步的数据库名称
binlog-ignore-dbmysql
## 开启二进制日志功能
log-binmall-mysql-bin
## 设置二进制日志使用内存大小事务
binlog_cache_size1M
## 设置使用的二进制日志格式mixed,statement,row
binlog_formatmixed
## 二进制日志过期清理时间。默认值为0表示不自动清理。
expire_logs_days7
## 跳过主从复制中遇到的所有错误或指定类型的错误避免slave端复制中断。
## 如1062错误是指一些主键重复1032错误是因为主从数据库数据不一致
slave_skip_errors1062
## 设置utf8
collation_server utf8_general_ci
## 设置server字符集
character_set_server utf8
[client]
default_character_setutf8 # 修改完配置后重启master实例
docker restart mysql-master# 进入mysql-master容器
docker exec -it mysql-master /bin/bash
mysql -uroot -proot# maser容器实例内创建数据同步用户
# 创建同步用户
CREATE USER slave% IDENTIFIED BY 123456;
# 同步用户授权
GRANT REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO slave%;# 新建从服务容器实例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_PASSWORDroot \
-d mysql:5.7 # 进入/mydata/mysql-slave/conf目录下新建my.cnf
# 添加配置文件
[mysqld]
## 设置server_id同一局域网中需要唯一
server_id102
## 指定不需要同步的数据库名称
binlog-ignore-dbmysql
## 开启二进制日志功能以备Slave作为其它数据库实例的Master时使用
log-binmall-mysql-slave1-bin
## 设置二进制日志使用内存大小事务
binlog_cache_size1M
## 设置使用的二进制日志格式mixed,statement,row
binlog_formatmixed
## 二进制日志过期清理时间。默认值为0表示不自动清理。
expire_logs_days7
## 跳过主从复制中遇到的所有错误或指定类型的错误避免slave端复制中断。
## 如1062错误是指一些主键重复1032错误是因为主从数据库数据不一致
slave_skip_errors1062
## relay_log配置中继日志
relay_logmall-mysql-relay-bin
## log_slave_updates表示slave将复制事件写进自己的二进制日志
log_slave_updates1
## slave设置为只读具有super权限的用户除外
read_only1
## 设置utf8
collation_server utf8_general_ci
## 设置server字符集
character_set_server utf8
[client]
default_character_setutf8 # 修改完配置后重启slave实例
docker restart mysql-slave# 在主数据库中查看主从同步状态
show master status;# 进入mysql-slave容器
docker exec -it mysql-slave /bin/bash
mysql -uroot -proot# 在从数据库中配置主从复制
change master to master_host宿主机ip, master_userslave, master_password123456, master_port3307, master_log_filemall-mysql-bin.000001, master_log_pos617, master_connect_retry30; # 在从数据库中查看主从同步状态
show slave status\G;# 在从数据库中开启主从同步
start slave;
# 查看从数据库状态发现已经同步安装redis集群(cluster)
关闭防火墙启动docker后台服务
systemctl start docker新建6个docker容器redis实例
# 创建并运行docker容器实例
docker run
# 容器名字
--name redis-node-6
# 使用宿主机的IP和端口默认
--net host
# 获取宿主机root用户权限
--privilegedtrue
# 容器卷宿主机地址:docker内部地址
-v /data/redis/share/redis-node-6:/data
# redis镜像和版本号
redis:6.0.8
# 开启redis集群
--cluster-enabled yes
# 开启持久化
--applendonly yes docker run -d --name redis-node-1 --net host --privilegedtrue -v /data/redis/share/redis-node-1:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6381 docker run -d --name redis-node-2 --net host --privilegedtrue -v /data/redis/share/redis-node-2:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6382 docker run -d --name redis-node-3 --net host --privilegedtrue -v /data/redis/share/redis-node-3:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6383 docker run -d --name redis-node-4 --net host --privilegedtrue -v /data/redis/share/redis-node-4:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6384 docker run -d --name redis-node-5 --net host --privilegedtrue -v /data/redis/share/redis-node-5:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6385 docker run -d --name redis-node-6 --net host --privilegedtrue -v /data/redis/share/redis-node-6:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6386 进入容器redis-node-1并为6台机器构建集群关系
# 进入容器
docker exec -it redis-node-1 /bin/bash
# 注意进入docker容器后才能执行一下命令且注意自己的真实IP地址
redis-cli --cluster create 192.168.111.147:6381 192.168.111.147:6382 192.168.111.147:6383 192.168.111.147:6384 192.168.111.147:6385 192.168.111.147:6386 --cluster-replicas 1
# --cluster-replicas 1 表示为每个master创建一个slave节点 4. 连接进入6318作为切入点查看集群状态
redis cluster inforedis cluster nodes主从容错切换迁移案例
数据读写存储
redis-cli -p 6381 -c查看集群信息
redis-cli --cluster check 192.168.111.147:6381 容错切换迁移
主6381和从机切换先停止主机6381
6381主机停了对应的真实从机上位
6381作为1号主机分配的从机以实际情况为准具体是几号机器就是几号再次查看集群信息6381宕机了6385上位成为了新的master。 先还原之前的3主3从
# 先启6381
docker start redis-node-1
# 再停6385
docker stop redis-node-5
# 再起6385
docker start redis-node-5
主从机器分配情况一实际情况为准查看集群状态
redis-cli --cluster check 自己IP:6381主从扩容案例
新建6387、6388两个节点新建后启动查看是否8节点
docker run -d --name redis-node-7 --net host --privilegedtrue -v /data/redis/share/redis-node-7:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6387 docker run -d --name redis-node-8 --net host --privilegedtrue -v /data/redis/share/redis-node-8:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6388 docker ps 进入6387容器实例内部
docker exec -it redis-node-7 /bin/bash将新增的6387节点(空槽号)作为master节点加入原集群
将新增的6387作为master节点加入集群
redis-cli --cluster add-node 自己实际IP地址: 6387 自己实际IP地址: 6381
6387 就是将要作为master新增节点
6381 就是原来集群节点里面的领路人相当于6387拜拜6381的码头从而找到组织加入集群 检查集群情况第1次
redis-cli --cluster check 真实ip地址:6381
# 例如
redis-cli --cluster check 192.168.111.147:6381 重新分派槽号
重新分派槽号
命令:redis-cli --cluster reshard IP地址:端口号
redis-cli --cluster reshard 192.168.111.147:6381 检查集群情况第2次
redis-cli --cluster check 真实ip地址:6381 为什么6387是3个新的区间以前的还是连续
重新分配成本太高所以前3家各自匀出来一部分从6381/6382/6383三个旧节点分别匀出1364个坑位给新节点6387 为主节点6387分配从节点6388
命令redis-cli --cluster add-node ip:新slave端口 ip:新master端口 --cluster-slave --cluster-master-id 新主机节点IDredis-cli --cluster add-node 192.168.111.147:6388 192.168.111.147:6387 --cluster-slave --cluster-master-id e4781f644d4a4e4d4b4d107157b9ba8144631451-------这个是6387的编号按照自己实际情况 检查集群情况第3次
redis-cli --cluster check 192.168.111.147:6382 DockerFile解析
DockerFile是什么
DockerFile是用来构建Docker镜像的文本文件是有一条条构建镜像所需的指令和参数构成的脚本。 构建三步骤
1、编写DockerFile文件
2、docker build命令构建镜像
3、docker run 依镜像运行容器实例DockerFile构建过程解析
DockerFile内容基础知识
1. 每条保留字指令都必须为大写字母且后面跟随至少一个参数
2. 指令按照从上到下顺序执行
3. #表示注释
4. 每条指令都会创建一个新的镜像层并对镜像进行提交。Docker执行DockerFile的大致流程
1. docker从技术镜像运行一个容器
2. 执行一条指令比鞥对容器做出修改
3. 执行类似docker commit 的操作提交一个新的镜像层
4. docker 在基于刚提交的镜像运行一个新容器
5. 执行dockerfile中的下一条指令直到所有执行执行完成。小总结
从应用软件的角度来看Dockerfile、Docker镜像与Docker容器分别代表软件的三个不同阶段
Dockerfile是软件的原材料
Docker镜像是软件的交付品
Docker容器则可以认为是软件镜像的运行态也即依照镜像运行的容器实例
Dockerfile面向开发Docker镜像成为交付标准Docker容器则涉及部署与运维三者缺一不可合力充当Docker体系的基石。 Dockerfile需要定义一个DockerfileDockerfile定义了进程需要的一切东西。Dockerfile涉及的内容包括执行代码或者是文件、环境变量、依赖包、运行时环境、动态链接库、操作系统的发行版、服务进程和内核进程(当应用进程需要和系统服务和内核进程打交道这时需要考虑如何设计namespace的权限控制)等等; Docker镜像在用Dockerfile定义一个文件之后docker build时会产生一个Docker镜像当运行 Docker镜像时会真正开始提供服务; Docker容器容器是直接提供服务的。
DockerFile常用保留字指令
参考tomcat8的dockerfile入门
https://github.com/docker-library/tomcat
From
基础镜像当前新镜像是基于哪个镜像的指定一个已经存在的镜像作为模板第一条必须是fromMANINTAINER
镜像维护者的姓名和邮箱地址
Run
容器构建时需要运行的命令
两种格式
shell格式
命令行命令等同于在终端操作的shell命令exec格式 RUN是在docker build时运行
EXPOSE
当前容器对外暴露出的端口
WORKDIR
指定在创建容器后。终端默认登录的进来工作目录一个落脚点。
USER
指定该镜像以什么样的用户去执行如果都不指定默认是root
ENV
用来在构建镜像过程中设置环境变量
ENV MY_PATH /usr/mytest
这个环境变量可以在后续的任何RUN指令中使用这就如同在命令前面指定了环境变量前缀一样
也可以在其它指令中直接使用这些环境变量 比如WORKDIR $MY_PATH ADD
将宿主机目录下的文件拷贝进镜像且会自动处理URL和解压tar压缩包
COPY
类似ADD拷贝文件和目录到镜像中。将从构建上下文目录中源路径的文件/目录复制到新的一层镜像内的目标路径位置
COPY src destCOPY[src,dest]src源路径源文件或源目录dest目标路径: 容器内的指定路径该路径不用事先建好路径不存在的话会自动创建。VOLUME
容器数据卷用于数据保存和持久化的工作
CMD
指定容器启动后的要干的事情。
【注意】
Dockerfile 中可以由多个CMD指令但是只有最后一个生效CMD会被docker run 之后的参数替换。参考官网Tomcat的dockerfile演示讲解
官网最后一行命令
EXPOSE 8080CMD [catalina.sh,run]我们演示自己的覆盖操作
docker run -it -p 8080:8080 容器ID /bin/bash他和前面RUN命令的区别
CMD 是在 docker run 时运行。RUN 是在docker build 时运行ENTRYPOINT 也是用来指定一个容器启动时要运行的命令 类似于CMD指令但是ENTRYPOINT不会被docker run 后面的命令覆盖而且这些命令行参数会被当作参数送给ENTRYPOINT指令指定的程序。 命令格式和案例说明
命令格式ENTRYPOINT[executeable,param1,param2,...]ENTRYPOINT 可以和CMD一起用一般是 变参 才会使用 CMD 这里的CMD等于是在给 ENTRYPOINT 传参。当制定了 ENTRYPOINT 后CMD的含义就发生了变化不再是直接运行其命令而是将 CMD 的内容作为参数传递给 ENTRYPOINT 指定他两个组合会变成ENTRYPOINT CMD
案例如下假设已通过 Dockerfile 构建了 nginx:test 镜像优点在执行docker run 的时候可以指定 ENTRYPOINT 运行所需的参数。
注意如果Dockerfile 中如果存在多个 ENTRYPOINT 指令进最后一个生效。
小总结 自定义镜像mycentosjava8
目标
Centos7镜像具备 vim ifconfig jdk8
编写
# 创建DockerFile
vim DockerfileFROM centos
MAINTAINER zzyyzzyybs126.com ENV MYPATH /usr/local
WORKDIR $MYPATH #安装vim编辑器
RUN yum -y install vim
#安装ifconfig命令查看网络IP
RUN yum -y install net-tools
#安装java8及lib库
RUN yum -y install glibc.i686
RUN mkdir /usr/local/java
#ADD 是相对路径jar,把jdk-8u171-linux-x64.tar.gz添加到容器中,安装包必须要和Dockerfile文件在同一位置
ADD jdk-8u171-linux-x64.tar.gz /usr/local/java/
#配置java环境变量
ENV JAVA_HOME /usr/local/java/jdk1.8.0_171
ENV JRE_HOME $JAVA_HOME/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 构建
docker build -t 新镜像名字: TAG例如docker build -t centosjava8:1.5 .【注意】
上面TAG 后面有个空格有个点运行
docker run -it 新镜像名字:TAGdocker run -it centosjava8:1.5 /bin/bash 虚悬镜像
仓库名标签都是 none 的镜像俗称dangling image
Dockerfile
vim Dockerfilefrom ubuntu
CMD echo hello world 构建
docker build .查看
docker image ls -f danglingtrue
命令结果如下图删除
docker image prune 虚悬镜像已经市区存在价值可以删除家庭作业自定义myubuntu
# 编写
准备编写DockerFile文件
vim Dockerfile
----------------------
FROM ubuntu
MAINTAINER zzyyzzyybs126.com ENV MYPATH /usr/local
WORKDIR $MYPATH RUN apt-get update
RUN apt-get install net-tools
#RUN apt-get install -y iproute2
#RUN apt-get install -y inetutils-ping EXPOSE 80 CMD echo $MYPATH
CMD echo install inconfig cmd into ubuntu success--------------ok
CMD /bin/bash
------------------------
# 构建
docker build -t 新镜像名字:TAG#运行
docker run -it 新镜像名字:TAGDocker网络 Docker 网络是什么
docker不启动默认网络情况
ens 33
lo
virbr0在CentOS7的安装过程中如果有 选择相关虚拟化的的服务安装系统后 启动网卡时会发现有一个以网桥连接的私网地址的virbr0网卡(virbr0网卡它还有一个固定的默认IP地址192.168.122.1)是做虚拟机网桥的使用的其作用是为连接其上的虚机网卡提供 NAT访问外网的功能。 我们之前学习Linux安装勾选安装系统的时候附带了libvirt服务才会生成的一个东西如果不需要可以直接将libvirtd服务卸载
yum remove libvirt-libs.x86_64 docker启动后网络情况
查看docker网络模式命令
常用基本命令
All 命令 docker network ls查看网络
docker network ls查看网络源数据
docker network inspect XXX网络名字删除网络
docker network rm XXX网络名字能干嘛
容器间的互联和通信以及端口映射
容器IP变动时候可以通过服务名直接网络通信而不受到影响网络模式
总体介绍
bridge模式使用--network bridge指定默认使用docker()host模式使用 --network host指定none模式使用 --network none指定container模式使用 --network container:Name或者容器ID指定容器实例内默认网络IP生产规则
先启动两个ubuntu容器实例 docker inspect 容器ID or 容器名字 关闭u2实例新建u3查看ip变化
案例说明
bridge
Docker 服务默认会创建一个 docker0 网桥其上有一个 docker0 内部接口该桥接网络的名称为docker0它在 内核层 连通了其他的物理或虚拟网卡这就将所有容器和本地主机都放到 同一个物理网络 。Docker 默认指定了 docker0 接口 的 IP 地址和子网掩码 让主机和容器之间可以通过网桥相互通信。 # 查看 bridge 网络的详细信息并通过 grep 获取名称项
docker network inspect bridge | grep name ifconfig 案例
1 Docker使用Linux桥接在宿主机虚拟一个Docker容器网桥(docker0)Docker启动一个容器时会根据Docker网桥的网段分配给容器一个IP地址称为Container-IP同时Docker网桥是每个容器的默认网关。因为在同一宿主机内的容器都接入同一个网桥这样容器之间就能够通过容器的Container-IP直接通信。 2 docker run 的时候没有指定network的话默认使用的网桥模式就是bridge使用的就是docker0 。在宿主机ifconfig,就可以看到docker0和自己create的network(后面讲)eth0eth1eth2……代表网卡一网卡二网卡三…… lo代表127.0.0.1即localhost inet addr用来表示网卡的IP地址 3 网桥docker0创建一对对等虚拟设备接口一个叫veth另一个叫eth0成对匹配。 3.1 整个宿主机的网桥模式都是docker0类似一个交换机有一堆接口每个接口叫veth在本地主机和容器内分别创建一个虚拟接口并让他们彼此联通这样一对接口叫veth pair 3.2 每个容器实例内部也有一块网卡每个接口叫eth0 3.3 docker0上面的每个veth匹配某个容器实例内部的eth0两两配对一一匹配。 通过上述将宿主机上的所有容器都连接到这个内部网络上两个容器在同一个网络下,会从这个网关下各自拿到分配的ip此时两个容器的网络是互通的。 【代码】
docker run -d -p 8081:8080 --name tomcat81 billygoo/tomcat8-jdk8docker run -d -p 8082:8080 --name tomcat82 billygoo/tomcat8-jdk8两两匹配验证 Host
是什么
直接使用宿主机的IP地址与外界进行通信不再需要额外进行NAT转换。
案例
说明
容器将 不会获得 一个独立的Network Namespace 而是和宿主机共用一个Network Namespace。 容器将不会虚拟出自己的网卡而是使用宿主机的IP和端口。
代码
警告
docker run -d -p 8083:8080 --network host --name tomcat83 billygoo/tomcat8-jdk8正确
docker run -d --network host --name tomcat83 billygoo/tomcat8-jdk8无之前的配对显示了看容器实例内部 没有设置-p的端口映射了如何访问启动的tomcat83
http://宿主机IP:8080/ 在CentOS里面用默认的火狐浏览器访问容器内的tomcat83看到访问成功因为此时容器的IP借用主机的
所以容器共享宿主机网络IP这样的好处是外部主机与容器可以直接通信。none
是什么
禁用网络功能只有lo标识就是127.0.0.1表示本地回环
案例
docker run -d -p8084:8080 --network none --name tomcat84 billygoo/tomcat8-jdk8
container
一、是什么
container⽹络模式
新建的容器和已经存在的一个容器共享一个网络ip配置而不是和宿主机共享。新创建的容器不会创建自己的网卡配置自己的IP而是和一个指定的容器共享IP、端口范围等。同样两个容器除了网络方面其他的如文件系统、进程列表等还是隔离的。
二、❎案例
docker run -d -p 8085:8080 --name tomcat85 billygoo/tomcat8-jdk8docker run -d -p 8086:8080 --network container:tomcat85 --name tomcat86 billygoo/tomcat8-jdk8运行结果dockerError response from daemon: conflicting optisons: port ...........# 相当于tomcat86和tomcat85公用同一个ip同一个端口导致端口冲突 三、✅案例2
Alpine操作系统是一个面向安全的轻型 Linux发行版docker run -it --name alpine1 alpine /bin/shdocker run -it --network container:alpine1 --name alpine2 alpine /bin/sh运行结果验证共用搭桥 假如此时关闭alpine1再看看alpine2
自定义网络
三、案例
【before】
案例
docker run -d -p 8081:8080 --name tomcat81 billygoo/tomcat8-jdk8docker run -d -p 8082:8080 --name tomcat82 billygoo/tomcat8-jdk8上述成功启动并用docker exec进入各自容器实例内部
问题
1. 按照IP地址ping是OK的
2. 按照服务名ping结果???ping tocmat82Name or service not known【after】
案例
自定义桥接网络,自定义网络默认使用的是桥接网络bridge新建自定义网络新建容器加入上一步新建的自定义网络
docker run -d -p 8081:8080 --network zzyy_network --name tomcat81 billygoo/tomcat8-jdk8docker run -d -p 8082:8080 --network zzyy_network --name tomcat82 billygoo/tomcat8-jdk8互相ping测试
1、自定义网络本身就维护好了主机名和ip的对应关系ip和域名都能通
2、自定义网络本身就维护好了主机名和ip的对应关系ip和域名都能通
3、自定义网络本身就维护好了主机名和ip的对应关系ip和域名都能通Docker平台架构图解
从其架构和运行流程来看Docker 是一个 C/S 模式的架构后端是一个松耦合架构众多模块各司其职。 Docker 运行的基本流程为 1 用户是使用 Docker Client 与 Docker Daemon 建立通信并发送请求给后者。
2 Docker Daemon 作为 Docker 架构中的主体部分首先提供 Docker Server 的功能使其可以接受 Docker Client 的请求。
3 Docker Engine 执行 Docker 内部的一系列工作每一项工作都是以一个 Job 的形式的存在。
4 Job 的运行过程中当需要容器镜像时则从 Docker Registry 中下载镜像并通过镜像管理驱动 Graph driver将下载镜像以Graph的形式存储。
5 当需要为 Docker 创建网络环境时通过网络管理驱动 Network driver 创建并配置 Docker 容器网络环境。
6 当需要限制 Docker 容器运行资源或执行用户指令等操作时则通过 Execdriver 来完成。
7 Libcontainer是一项独立的容器管理包Network driver以及Exec driver都是通过Libcontainer来实现具体对容器进行的操作。Docker轻量级可视化工具Portainer
docker安装
安装
docker run -d -p 8000:8000 -p 9000:9000 --name portainer --restartalways -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer 2/ 第一次登录需创建admin访问地址xxx.xxx.xxx.xxx:9000
用户名直接用默认admin
密码记得8位随便你写 设置admin用户和密码后首次登陆选择local选项卡后本地docker详细信息展示
