尚硅谷Docker实战教程学习总结文档
创始人
2024-05-25 04:23:09
0

目录

  • Docker与微服务实战(2022版)
  • 1、基础篇(零基础小白)
    • 1.1、Docker简介
      • 1.1.1、怎么去学习Docker
      • 1.1.2、是什么
        • 1.1.2.1、为什么会有docker的出现?
        • 1.1.2.2、docker理念
        • 1.1.2.3、为什么使用Docker?
        • 1.1.2.3、总结
      • 1.1.3、容器与虚拟机比较
        • 1.1.3.1、容器发展简史
        • 1.1.3.2、传统虚拟机技术
        • 1.1.3.3、容器虚拟化技术
        • 1.1.3.4、对比
      • 1.1.4、能干嘛
        • 1.1.4.1、技术职级变化
        • 1.1.4.2、开发/运维(DevOps)新一代开发工程师
          • 1.1.4.2.1、Docker的应用场景
        • 1.1.4.3、哪些企业在使用
      • 1.1.5、哪里下
        • 1.1.5.1、官网
    • 1.2、Docker安装
      • 1.2.1、前提说明
      • 1.2.2、Docker的基本组成
        • 1.2.2.2、Docker三件套
        • 1.2.2.2、Docker平台架构图解(入门版)
          • 1.2.2.2.1、架构图解
          • 1.2.2.2.2、Docker工作原理
      • 1.2.3、Docker平台架构图解(架构版)
        • 1.2.3.1、整体架构及底层通信原理简述
      • 1.2.4、Docker安装步骤
        • 1.2.4.1、Centos7安装Docker
          • 1.2.4.1.1、具体安装步骤
      • 1.2.5、阿里云镜像加速
        • 1.2.5.1、是什么
        • 1.2.5.2、获取一个加速连接地址
        • 1.2.5.3、粘贴脚本执行并重启docker
        • 1.2.5.4、docker run到底干了什么
        • 1.2.5.5、Docker底层原理
    • 1.3、Docker常用命令
      • 1.3.1、帮助启动类命令
      • 1.3.2、镜像命令
      • 1.3.3、容器命令
        • 1.3.3.1、新建启动容器
        • 1.3.3.2、列出当前所有运行的容器
        • 1.3.3.3、退出容器
        • 1.3.3.4、启动已停止运行的容器
        • 1.3.3.5、重启容器
        • 1.3.3.6、停止容器
        • 1.3.3.7、强制停止容器
        • 1.3.3.8、删除已停止的容器
        • 1.3.3.9、重点部分
          • 1.3.3.9.1、下载容器和启动守护式容器
          • 1.3.3.9.2、查看容器日志
          • 1.3.3.9.3、查看容器内运行的进程
          • 1.3.3.9.4、查看容器内部细节
          • 1.3.3.9.5、进入正在运行的容器并以命令行交互(重要)
          • 1.3.3.9.6、从容器内拷贝文件到主机上
          • 1.3.3.9.6、导入和导出容器
      • 1.3.4、常用命令小总结
    • 1.4、Docker镜像
      • 1.4.1、是什么
        • 1.4.1.1、什么是镜像
        • 1.4.1.2、分层的镜像
        • 1.4.1.3、UnionFS联合文件系统
        • 1.4.1.4、Docker镜像加载原理
        • 1.4.1.5、为什么Docker镜像采用这种分层结构呢?
      • 1.4.2、重点理解
      • 1.4.3、Docker镜像commit操作案列
        • 1.4.3.1、commit提交容器
        • 1.4.3.2、案例演示ubuntu安装vim
          • 1.4.3.2.1、从Hub上下载ubuntu镜像到本地并成功运行
          • 1.4.3.2.2、原始的默认ubuntu镜像是不带着vim
          • 1.4.3.2.3、命令的外网连通的情况下,安装vim
          • 1.4.3.2.4、安装完成后,commit我们自己的新镜像
          • 1.4.3.2.5、启动我们的新镜像并和原来的对比团
          • 1.4.3.2.6、小总结
    • 1.5、本地镜像发布到阿里云
      • 1.5.1、本地镜像发布到阿里云流程
      • 1.5.2、镜像的生成方法
      • 1.5.3、将本地镜像推送到阿里云
        • 1.5.3.1、阿里云开发者平台
        • 1.5.3.2、创建仓库镜像
        • 1.5.3.3、将镜像推送到阿里云
      • 1.5.4、将阿里云上的镜像下载到本地
    • 1.6、本地镜像发布到私有库
      • 1.6.1、本地镜像发布到私有库流程
      • 1.6.2、是什么
      • 1.6.3、将本地镜像推送到私有库
        • 1.6.3.1、下载镜像Docker Registry
        • 1.6.3.2、运行私有库Registry,相当于本地有个私有Docker hub
        • 1.6.3.3、案例演示创建一个新镜像,ubuntu安装ifconfig命令
        • 1.6.3.4、curl验证私服库上有什么镜像
        • 1.6.3.5、将新镜像ubuntu01:1.3修改符合私服规范的Tag
        • 1.6.3.6、修改配置文件使之支持http
        • 1.6.3.7、push推送到私服库团
        • 1.6.3.8、curl验证私服库上有什么镜像2
        • 1.6.3.9、pull到本地并运行
    • 1.7、Docker容器数据卷
      • 1.7.1、挂载容器卷记得加入权限
        • 1.7.2、是什么
      • 1.7.3、能干嘛
      • 1.7.4、数据卷案列
        • 1.7.4.1、宿主vs容器之间映射添加容器卷
        • 1.7.4.2、读写规则映射添加说明
        • 1.7.4.3、卷的继承和共享
          • 1.7.4.3.1、容器1完成与宿主机的映射
          • 1.7.4.3.2、容器2继承容器1的卷规则
    • 1.8、Docker常见安装简介
      • 1.8.1、总体步骤
      • 1.8.2、安装tomcat
      • 1.8.3、安装mysql
        • 1.8.3.1、Mysql安装运行--基础版
        • 1.8.3.2、Mysql安装运行--实战版
      • 1.8.4、安装redis
        • 1.8.4.1、常规安装redis--常规版
        • 1.8.4.2、常规安装redis--实战版
      • 1.8.5、安装Nginx
  • 2、高级篇(大厂进阶)
    • 2.1、Docker复杂安装详说
      • 2.1.1、安装mysql主从复制
        • 2.1.1.1、主从复制原理
        • 2.1.1.2、主从搭建步骤
      • 2.1.2、安装redis渠群(大厂面试题第4季-分布式存储案例真题)
        • 2.1.2.1、1~2亿条数据需要缓存,请问如何设计这个存储案例?
          • 2.1.2.1.1、哈希取余分区(安全隐患)
          • 2.1.2.1.2、一致性哈希算法
          • 2.1.2.1.3、分区哈希槽分区
        • 2.1.2.2、搭建3主3从redis集群扩缩容配置案例架构说明
        • 2.1.2.3、搭建3主3从redis集群扩缩容配置
          • 2.1.2.3.1、3主3从redis集群配置
          • 2.1.2.3.2、主从容错切换迁移案例
            • 2.1.2.3.2.1、数据读写存储
            • 2.1.2.3.2.2、容错切换迁移
          • 2.1.2.3.3、主从扩容案例切换迁移
          • 2.1.2.3.4、主从缩容案例
    • 2.2、DockerFile解析
      • 2.2.1、是什么
      • 2.2.2、DockerFile构建过程解析
        • 2.2.2.1、Dockerfile内容基础知识
        • 2.2.2.2、Docker执行Dockerfile的大致流程
        • 2.2.2.3、小总结
      • 2.2.3、DockerFile常用保留字指令
      • 2.2.4、案例
        • 2.2.4.1、自定义镜像mycentosjava8
        • 2.2.4.2、虚悬镜像
        • 2.2.4.3、家庭作业-自定义镜像myubuntu
      • 2.2.5、小总结
    • 2.3、Docker微服务实战
      • 2.3.1、通过IDEA新建一个普通微服务模块
      • 2.3.2、通过dockerfile发布微服务部署到docker容器
    • 2.4、Docker网络
      • 2.4.1、是什么
      • 2.4.2、常用基本命令
      • 2.4.3、能干嘛
      • 2.4.4、网络模式
        • 2.4.4.1、`bridge`
        • 2.4.4.2、host
      • 2.4.4.3、none
        • 2.4.4.4、container
        • 2.4.4.5、自定义网络
      • 2.4.5、Docker平台架构图解

Docker与微服务实战(2022版)

1、基础篇(零基础小白)

1.1、Docker简介

1.1.1、怎么去学习Docker

学习前的思路:

1.是什么

2.能干什么

3.去哪里下

4.怎么用

5.跑起来

1.1.2、是什么

1.1.2.1、为什么会有docker的出现?

没有Docker之前,从开发环境到测试环境再到运维的生产环境,容易出现本地开发没问题,到了测试和生产环境就出现不同程度的问题,这是由于开发人员自己电脑的环境各有不同,你开发的应用还要依赖某些配置文件,没有统一的标准,部署时需要安装不同的环境,扩容时需要新增一个容器,需要新装环境,扩容缩容都非常麻烦。有了Docker容器,就相当于有了一个标准化的解决方案,系统平滑移植,容器虚拟化技术。Docker可以把开发人员电脑里面的环境一模一样的复制一份放在服务器上,消除了不同应用环境不同的问题,开发在打包时将源码+配置+环境+版本打包成一个镜像文件放入到Docker容器里面。

1.1.2.2、docker理念

类比:VMware+centos7.iso => docker+gmall.镜像文件

Docker是基于Go语言实现的云开源项目。

Docker的主要目标是“Build,Ship and Run Any App,Anywhere”,也就是通过对应用组件的封装、分发、部署、运行等生命周期的管理,使用户的APP(可以是一个WEB应用或数据库应用等等)及其运行环境能够做到“一次镜像,处处运行”。

Linux容器技术的出现就解决了这样一个问题,而Docker就是在它的基础上发展过来的。将应用打成镜像,通过镜像成为运行在Docker容器上面的实例,而Docker容器在任何操作系统上都是一致的,这就实现了跨平台、跨服务器。只需要一次配置好环境,换到别的机子上就可以一键部署好,大大简化了操作。

1.1.2.3、为什么使用Docker?

为什么使用Docker?
①更轻量:基于容器的虚拟化,仅包含业务运行所需的runtime环境,CentOS/Ubuntu基础镜像仅170M;宿主机可部署100~1000个容器
②更高效:无操作系统虚拟化开销计算:轻量,无额外开销
存储:系统盘aufs/dmVoverlayfs;数据盘volume
网络:宿主机网络,NS隔离
③更敏捷、更灵活:
分层的存储和包管理,devops理念
支持多种网络配置

1.1.2.3、总结

docker解决了运行环境和配置问题的软件容器,方便做持续集成并有助于整体发布的容器虚拟化技术。

1.1.3、容器与虚拟机比较

1.1.3.1、容器发展简史

安装构建发展史:磁盘 -> 器械 -> 虚拟机 -> docker

docker可以存放静态网站、数据库、前端、消息中间件队列、动态数据源等。

1.1.3.2、传统虚拟机技术

虚拟机(virtual machine)就是带环境安装的一种解决方案。

它可以在一种操作系统里面运行另一种操作系统,比如在Windows10系统里面运行Linux系统CentOS7。应用程序对此毫无感知,因为虚拟机看上去跟真实系统一模一样,而对于底层系统来说,虚拟机就是一个普通文件,不需要了就删掉,对其他部分毫无影响。这类虚拟机完美的运行了另一套系统,能够使应用程序,操作系统和硬件三者之间的逻辑不变。

传统虚拟机技术基于安装在主操作系统上的虚拟机管理系统(如: VirtualBox和VMWare等),创建虚拟机(虚拟出各种硬件),在虚拟机上安装从操作系统,在从
操作系统中安装部署各种应用。-

虚拟机的缺点:①资源占用多;②冗余步骤多;③启动慢;

1.1.3.3、容器虚拟化技术

由于前面虚拟机存在某些缺点,Linux发展出了另一种虚拟化技术:

Linux容器(Linux Containers,缩写为LXC)
Linux容器是与系统其他部分隔离开的一系列进程,从另一个镜像运行,并由该镜像提供支持进程所需的全部文件。容器提供的镜像包含了应用的所有依赖项,因而在从开发到测试再到生产的整个过程中,它都具有可移植性和一致性。

Linux容器不是模拟一个完整的操作系统而是对进程进行隔离。有了容器,就可以将软件运行所需的所有资源打包到一个隔离的容器中。容器与虚拟机不同,不需要捆绑一整套操作系统,只需要软件工作所需的库资源和设置。系统因此而变得高效轻量并保证部署在任何环境中的软件都能始终如一地运行。

Docker容器是在操作系统层面上实现虚拟化,直接复用本地主机的操作系统,而传统虚拟机则是在硬件层面实现虚拟化。与传统的虚拟机相比,Docker优势体现为启动速度快、占用体积小。

1.1.3.4、对比

比较了Docker和传统虚拟化方式的不同之处:

①传统虚拟机技术是虚拟出一套硬件后,在其上运行一个完整操作系统,在该系统上再运行所需应用进程;
②容器内的应用进程直接运行于宿主的内核,容器内没有自己的内核且也没有进行硬件虚拟。因此容器要比传统虚拟机更为轻便。
③每个容器之间互相隔离,每个容器有自己的文件系统,容器之间进程不会相互影响,能区分计算资源。

1.1.4、能干嘛

1.1.4.1、技术职级变化

coder(编码) -> programmer(程序员) -> software enginner(软件工程师) -> DevOps enginner(开发/运维工程师)

1.1.4.2、开发/运维(DevOps)新一代开发工程师

一次构建、随处运行:

①更快速的应用交付和部署
传统的应用开发完成后,需要提供一堆安装程序和配置说明文档,安装部署后需根据配置文档进行繁杂的配置才能正常运行。Docker化之后只需要交付少量容器镜像文件,在正式生产环境加载镜像并运行即可,应用安装配置在镜像里已经内置好,大大节省部署配置和测试验证时间。

②更便捷的升会和扩缩容
随着微服务架构和Docker的发展,大量的应用会通过微服务方式架构,应用的开发构建将变成搭乐高积木一样,每个Docker容器将变成一块“积木”,应用的升级将变得非常容易。当现有的容器不足以支撑业务处理时,可通过镜像运行新的容器进行快速扩容,使应用系统的扩容从原先的天级变成分钟级甚至秒级。

③更简单的系统运维
应用容器化运行后,生产环境运行的应用可与开发、测试环境酌应用高度一致,容器会将应用程序相关的环境和状态完全封装起来,不会因为底层基础架构和操作系统的不一致性给应用带来影响,产生新的BUG。当出现程序异常时,也可以通过测试环境的相同容器进行快速定位和修复。

④更高效的计算资源利用
Docker是内核级虚拟化,其不像传统的虚拟化技术一样需要额外的Hypervisor支持,所以在一台物理机上可以运行很多个容器实列,可大大提升物理服务器的CPU和内存的利用率。

1.1.4.2.1、Docker的应用场景

Docker借鉴了标准集装箱的概念。标准集装箱将货物运往世界各地,Docker将这个模型运用到自己的设计中,唯一不同的是:集装箱运输货物,而Docker运输软件。

1.1.4.3、哪些企业在使用

新浪、美团、蘑菇街、、、、

1.1.5、哪里下

1.1.5.1、官网

docker官网

Docker Hub官网:安装docker镜像的仓库

1.2、Docker安装

1.2.1、前提说明

Centos Docker安装

Docker并非是一个通用的容器工具,它依赖于已存在并运行的Linux内核环境。
Docker实质上是在已经运行的Linux下制造了一个隔离的文件环境,因此它执行的效率几乎等同于所部署的Linux主机。因此,Docker必须部署在Linux内核的系统上。如果其他系统想部署Docker就必须安装一个虚拟Linux环境。
在Windows上部署Docker的方法都是先安装一个虚拟机,并在安装Linux系统的的虚拟机中运行Docker。

前提条件

目前,CentOS仅发行版本中的内核支持Docker。Docker运行在CentOS 7(64-bit)上,要求系统为64位、Linux系统内核版本为3.8以上,这里选用Centos7.x。

查看自己的内核

uname命令用于打印当前系统相关信息(内核版本号、硬件架构、主机名称和操作系统类型等)。
[ root@zzyy ~]# cat /etc/redhat- release
centos Linux release 7.4.1708 ( core)
[root@zzyy ~]#
[root@zzyy ~]# uname - r
3.10.o- 693.el7.x86_64
[root@zzyy ~]#

1.2.2、Docker的基本组成

1.2.2.2、Docker三件套

镜像(image)

Docker镜像(lmage)就是一个只读的模板。镜像可以用来创建Docker容器,一个镜像可以创建很多容器
它也相当于是一个root文件系统。比如官方镜像centos:7 就包含了完整的一套centos:7最小系统的 root文件系统。
相当于容器的“源代码”,docker镜像文件类似于Java的类模板,而docker容器实例类似于java中new出来的实例对象
容器与镜像的关系类型于面向对象编程中的对象与类:
Docker->容器、镜像;面向对象->对象、类;

容器(container)

①从面向对象角度
Docker利用容器〈Container)独立运行的一个或一组应用,应用程序或服务运行在容器里面,容器就类似于一个虚拟化的运行环境,容器是用镜像创建的运行实例。就像是Java中的类和实例对象一样,镜像是静态的定义,容器是镜像运行时的实体。容器为镜像提供了一个标准的和隔离的运行环境,它可以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台。

②从淘宝镜像角度
可以把容器看做是一个简易版的Linux环境(包括root用户权限、进程空间、用户空间和网络空间等)和运行在其中的应用程序。

仓库(repository)

仓库(Repository)是集中存放镜像文件的场所。
类似于
Maven仓库,存放各种jar包的地方;
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客户端创建一个对应的运行实例,也就是我们的容器
仓库
*就是放一堆镜像的地方,我们可以把镜像发布到仓库中,需要的时候再从仓库中拉下来就可以了。

1.2.2.2、Docker平台架构图解(入门版)

1.2.2.2.1、架构图解

Client 客户端;DOCKER_HOST Docker宿主机;Docker daemon Docker引擎;Containers Docker容器;Images 镜像;Registry 仓库;

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PO8IlAGG-1676019262305)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230128151230611.png)]

1.2.2.2.2、Docker工作原理

Docker是一个Client-Server结构的系统,Docker守护进程运行在主机上,然后通过Socket连接从客户端访问,守护进程从客户端接受命令并管理运行在主机上的容器。容器,是一个运行时环境,就是我们前面说到的集装箱。可以对比mysql演示对比讲解。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8lyeVNeG-1676019262306)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230128151953370.png)]

1.2.3、Docker平台架构图解(架构版)

1.2.3.1、整体架构及底层通信原理简述

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 Registy 中下载镜像,并通过镜像管理驱动Graph driver将下载镜像以Graph的形式存储。
5.当需要为Docker创建网络环境时,通过网络管理驱动Network driver创建并配置Docker容器网络环境。
6.当需要限制Docker容器运行资源或执行用户指令等操作时,则通过Exec driver来完成。
7.Libcontainer是一项独立的容器管理包,Network driver以及Exec driver都是通过Libcontainer来实现具体对容器进行的操作。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wp5kJt7P-1676019262306)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230128153029468.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wCjMUOYB-1676019262307)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230128153124694.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BFr2nNqb-1676019262307)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230128153155500.png)]

1.2.4、Docker安装步骤

注意:下面所有linux命令中,如果你发现有的命令前面加了 sudo,这是使用管理员的权限来进行安装,你如果是管理员账户不加 sudo 也可以。

1.2.4.1、Centos7安装Docker

地址:https://docs.docker.com/engine/install/centos/

1.2.4.1.1、具体安装步骤

1.确定你是CentOS7及以上版本

cat /etc/redhat-release

2.卸载旧版本

sudo yum remove docker \docker-client \docker-client-latest \docker-common \docker-latest \docker-latest-logrotate \docker-logrotate \docker-engine

3.yum安装gcc相关

# 确保CentOS7能上网
# 安装编译环境
yum -y install gcc
yum -y install gcc-c++

4.安装需要的软件包

sudo yum install -y yum-utils

5.设置stable镜像仓库

# 采用下面第二个命令,此命令连接国外的仓库,容易出现网络错误(Errno 14\Errno 12)
# 官网国外的仓库:不推荐
sudo yum-config-manager \--add-repo \https://download.docker.com/linux/centos/docker-ce.repo
# 阿里云、网易云仓库:推荐
sudo yum-config-manager \--add-repo \https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

6.更新yum软件包索引

yum makecache fast

7.安装DOCKER CE

# 安装最新版本(指定版本 例如: docker-ce: - docker-ce-18.09.1)
sudo yum install docker-ce docker-ce-cli containerd.io docker-compose-plugin

8.启动Docker

sudo systemctl start docker# 查看docker进程
ps -ef|grep docker
# 查看docker版本
docker version

9.测试

# 启动hello-world镜像(首次运行可能找不到,它会自己去镜像仓库拉一个)
sudo docker run hello-world

10.卸载

# 停止Docker服务
sudo systemctl stop docker# 卸载 Docker Engine、CLI、containerd 和 Docker Compose 软件包
sudo yum remove docker-ce docker-ce-cli containerd.io docker-compose-plugin docker-ce-rootless-extras# 删除所有镜像、容器和仓库
sudo rm -rf /var/lib/docker
sudo rm -rf /var/lib/containerd

1.2.5、阿里云镜像加速

也可以采用网易云、华为云等

1.2.5.1、是什么

地址:https://promotion.aliyun.com/ntms/act/kubernetes.html

注册一个属于自己的阿里云账号(可以复用支付宝淘宝账号)

1.2.5.2、获取一个加速连接地址

可以直接搜索容器镜像服务,也可以通过下面路径寻找。

路径:弹性计算 -> 容器镜像服务 -> 镜像工具 -> 镜像加速器

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Pkk8coVK-1676019262307)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230129084601300.png)]

注意:一定要配置自己的不要直接采用本图片地址

1.2.5.3、粘贴脚本执行并重启docker

找到阿里云当前页面下方CentOS里面的命令复制执行

注意:也可以直接修改daemon配置文件 /etc/docker/daemon.json 使用阿里云镜像加速

# 创建文件夹
sudo mkdir -p /etc/docker# 配置阿里云镜像加速(每个人使用的加速地址不同,将下面的加速地址更换为自己的阿里云镜像加速地址)
sudo tee /etc/docker/daemon.json <<-'EOF'
{
"registry-mirrors": ["https://3a17pv1d.mirror.aliyuncs.com"]
}
EOF# 重启daemon
sudo systemctl daemon-reload# 重启docker服务
sudo systemctl restart docker# 测试启动hello-world镜像
sudo docker run hello-world

1.2.5.4、docker run到底干了什么

第一步:本地查找镜像,如果找到了直接运行,如果没找到进行第二步;

第二步:在镜像仓库去拉一个镜像,拉到本地运行。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qZGjL2nk-1676019262308)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230129091617094.png)]

注意:这里前面配置了阿里云镜像,就不会从Docker Hub上去找镜像了,就会从 阿里云镜像 上寻找下载镜像。

1.2.5.5、Docker底层原理

为什么Docker会比VM虚拟机快?

(1)docker有着比虚拟机更少的抽象层
由于docker不需要Hypervisor(虚拟机)实现硬件资源虚拟化,运行在docker容器上的程序直接使用的都是实际物理机的硬件资源。因此在CPU、内存利用率上docker将会在效率上有明显优势。
(2)docker利用的是宿主机的内核,而不需要加载操作系统OS内核
当新建一个容器时,docker不需要和虚拟机一样重新加载一个操作系统内核。进而避免引寻、加载操作系统内核返回等比较费时费资源的过程,当新建一个虚拟机时,虚拟机软件需要加载OS,返回新建过程是分钟级别的。而docker由于直接利用宿主机的操作系统,则省略了返回过程,因此新建一个docker容器只需要几秒钟。

Docker容器虚拟机(VM)
操作系统与宿主机共享OS宿主机OS上运行虚拟机OS
存储大小镜像小,便于存储和传输镜像庞大(vmdk、vdi等)
运行性能几乎无额外性能损失操作系统额外的CPU、内存损耗
移植性轻便、灵活,适应于Linux笨重,与虚拟技术耦合度高
硬件亲和性面向软件开发者面向硬件运维者
部署速度快速,秒级较慢,10秒以上

1.3、Docker常用命令

1.3.1、帮助启动类命令

# 启动docker
systemctl start docker# 停止docker
systemctl stop docker# 重启docker 
ststemctl restart docker# 查看docjer状态(active 活动状态;inactive 失活状态)
systemctl status docker# 开机启动
systemctl enable docker# 查看docker概要信息
docker info# 查看docker总体帮助文档
docker --help#查看docker命令帮助文档
docker 具体命令 --help

1.3.2、镜像命令

# 列出本地主机上的镜像
docker images [OPTIONS]

OPTIONS说明:
-a:列出本地所有的镜像(含历史镜像层)
-q:只显示镜像ID
-qa :合并使用上面两个

表头各项说明:
REPOSITORY:表示镜像仓库源
TAG:镜像标签版本号
IMAGE ID:镜像ID
CREATED:镜像创建时间
SIZE:镜像大小

注意:同一仓库源可以有多个TAG版本,代表这个仓库源的不同个版本,我们使用REPOSITORY:TAG来定义不同的镜像。如果你不指定一个镜像的版本标签,例如你只使用ubuntu,docker将默认使用ubuntu:latest镜像

# 搜索云仓库相关镜像(默认是docker Hub,这里配置了阿里云就会从阿里云镜像仓库获取,下面的都是一样)
docker search [某个xxx镜像的名字] [OPTIONS]

OPTIONS说明:
–limit:只列出N个镜像,默认25个
例:docker search --limit 5 redis (只查询5个redis的镜像)

表头各项说明:
NAME:镜像名称
DESCRIPTION:镜像说明
STARS:点赞数量
OFFICAL:是否是官方的
AUTOMATED:是否是自动构建

# 从云仓库拉取镜像到本地
docker pull [某个xxx镜像名字] [:TAG]

注意:没有TAG版本号就默认拉取最新版本(latest 表示最新版本号)

例:docker pull redis:6.0.8(拉取6.0.8版本的redis镜像)

# 查看镜像/容器/数据券所占用的空间
docker system df

表头各项说明:
TYPE:类型(Images 镜像;Containers 容器;Local Volums 本地券;Build Cache 构建缓存)
TOTAL:总数
ACTIVE:活动的数量
SIZE:大小
RECLAIMABLE:可回收的

# 删除本地镜像
docker rmi [某个xxx镜像名称ID]# 删除单个镜像 -f:强制删除
docker rmi -f [镜像ID]
# 删除多个镜像
docker rmi -f [镜像名1]:TAG [镜像名2]:TAG
#删除全部镜像
docker rmi -f $(docker images -qa)

面试题:谈谈docker虚悬镜像是什么?

是什么:仓库名、标签都是的镜像,俗称虚悬镜像dangling image
长什么样:[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cjM8Q8EY-1676019262308)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230129104444173.png)]产生原因:①构建时候因为编写错误导致;②删除的时候;
操作:对于这样的虚悬镜像一定要删除。

1.3.3、容器命令

有镜像才能创建容器,这是根本前提(下载一个centos或者ubuntu镜像演示)这里在docker里面安装一个最新版的Ubuntu镜像进行演示操作,Ubuntu镜像比较小只有70多兆

1.3.3.1、新建启动容器

# 使用run关键词来生成实例
docker run [OPTIONS] IMAGE [COMMAND][ARG...]

OPTIONS说明:有些是一个减号,有些是两个减号
–name=容器新名字:为容器指定一个新名称;
-d:后台运行并返回容器ID,也即启动守护式容器(后台运行);
-i:以交互模式运行容器,通常与t同时使用 -it;
-t:为容器重新分配一个伪输入终端,通常与-i同时使用;
也即启动交互式容器(前台有伪终端,等待交互);
例如:使用镜像ubuntu:latest以交互模式启动一个容器,在容器内执行/bin/bash命令。

docker run -it ubuntu:latest /bin/bash
返回了一个容器ID
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7rqwpWpZ-1676019262308)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230129142442265.png)]

参数说明
-i:交互式操作。
-t:终端。
ubuntu:ubuntu镜像,centos镜像同理。
/bin/bash:放在镜像名后的是命令,这里我们希望有个交互式Shell,因此用的是/bin/bash。要退出终端,直接输入exit:

-P:随机端口映射,大写P
-p:指定端口映射,小写p

参数说明
-p hostPort:containerPort端口映射 -p 8080:80
-p ip:hostPort:containerPort配置监听地址 -p 10.0.0.100:8080:80
-p ip:hostPort随机分配端口 -p 10.0.0.100::80
-p hostPort:containerPort:udp指定协议 -p 8080:80:tcp
-p 81:80 -p443:443指定多个

1.3.3.2、列出当前所有运行的容器

# 列出当前所有运行的容器
docker ps [OPTIONS]

OPTIONS参数说明(常用):
-a:列出当前所有正在运行的容器+历史上运行过的
-I:显示最近创建的容器。
-n:显示最近n个创建的容器 docker ps -n 2。
-q:静默模式,只显示容器编号。

1.3.3.3、退出容器

# run关键词进入容器,使用exit退出,容器停止
exit# run关键词进入容器,ctrl+p+q退出,容器不停止
ctrl+p+q

1.3.3.4、启动已停止运行的容器

# 启动已停止的容器
docker run [容器ID或者容器名]

1.3.3.5、重启容器

# 重启容器
docker restart 容器ID或者容器名

1.3.3.6、停止容器

# 停止容器
docker stop 容器ID或者容器名

1.3.3.7、强制停止容器

# 强制停止容器
docker kill 容器ID或者容器名

1.3.3.8、删除已停止的容器

# 删除已停止的容器,注意`docker rmi`是删除镜像
docker rm 容器ID#一次性删除多个容器实例 -f 强制删除 $()替换命令
docker rm -f $(docker ps -a -q)
或者使用管道符 xargs 可变参数
docker ps -a -q | xargs docker rm

1.3.3.9、重点部分

1.3.3.9.1、下载容器和启动守护式容器

有镜像才能创建容器,这是根本前提(下载一个Redis6.0.8镜像演示)

启动守护式容器(后台服务器)
在大部分的场景下,我们希望docker的服务是在后台运行我们可以过-d指定容器的后台运行模式。

# 后台运行模式(启动守护式容器)启动redis容器
docker run -d [容器名]
## 解释说明
#使用镜像centos:latest以后台模式启动一个容器
docker rgn -d centos问题:然后docker ps -a进行查看,会发现`容器已经退出`
很重要的要说明的一点: `Docker容器后台运行,就必须有一个前台进程.``
容器运行的命令如果不是那些`一直挂起的命令`(比如运行top,tail),就是会自动退出的。
这个是docker的机制问题,比如你的web容器,我们以nginx为例,正常情况下,
我们配置启动服务只需要启动响应的service即可。例如service nginx start.
但是,这样做,nginx为后台进程模式运行,就导致docker前台没有运行的应用,这样的容器后台启动后,会立即自杀因为他觉得他没事可做了.
所以,最佳的解决方案是,`将你要运行的程序以前台进程的形式运行,常见就是命令行模式,表示我还有交互操作,别中断,o(n_n)O哈哈~`

redis前后台启动演示

# 前台交互式启动
docker run -it --name=redis01 redis:6.0.8# 后台守护式启动
docker run -d --name=redis01 redis:6.0.8
1.3.3.9.2、查看容器日志
# 查看容器日志
docker logs [容器ID]
1.3.3.9.3、查看容器内运行的进程
# 查看容器内运行的进程
docker top [容器ID]
1.3.3.9.4、查看容器内部细节
# 查看容器内部细节
docker inspect 容器ID
1.3.3.9.5、进入正在运行的容器并以命令行交互(重要)
#进入正在运行的容器并以命令行交互(推荐使用第一个)
docker exec -it [容器ID] /bin/bash 
或者
docker attach [容器ID] /bin/bash 

exec与attach的区别
attach 直接进入容器启动命令的终端,不会启动新的进程用exit退出,会导致容器的停止。
exec是在容器中打开新的终端,并且可以启动新的进程用exit退出,不会导致容器的停止。

1.3.3.9.6、从容器内拷贝文件到主机上
# 从容器内拷贝文件到主机上 容器->主机
docker cp [容器ID]:[容器内路径] [目的主机路径]
1.3.3.9.6、导入和导出容器
# export导出容器的内容留作为一个tar归档文件[对应import命令]
docker export [容器ID]>[文件名].tar# import 从tar包中的内容创建一个新的文件系统再导入为镜像[对应export]
cat [文件名].tar|docker import -[镜像用户]/[镜像名]:[镜像版本号] 

注意:导出的.tar文件就在当前操作目录下,导入的镜像用户可以随便写

1.3.4、常用命令小总结

#当前shell 下attach 连接指定运行镜像
attach #Attach to a running container#通过Dockerfile定制镜像
build #Build an image from a Dockerfile#提交当前容器为新的镜像
commit #Create a new image from a container changes#从容器中拷贝指定文件或者目录到宿主机中
cp #Copy files/folders from.the containers filesystem to the host path #创建一个新的容器,同run,但不启动容器
create #Create a new container#查看docker容器变化
diff #Inspect changes on a container's filesystem #从docker服务获取容器实时事件
events #Get real time events from the server#在已存在的容器上运行命令
exec #Run a command in an existing container #导出容器的内容流作为一个tar归档文件[对应import]
export #Stream the contents of a container as a tar archive #展示一个镜像形成历史
history #Show the history of an image#列出系统当前镜像
images #List images#从tar包中的内容创建一个新的文件系统映像[对应export]
import #Create a new filesystem image from the contents of a tarball

1.4、Docker镜像

1.4.1、是什么

1.4.1.1、什么是镜像

镜像
是一种轻量级、可执行的独立软件包,它包含运行某个软件所需的所有内容,我们把应用程序和配置依赖打包好形成一个可交付的运行环境(包括代码、运行时需要的库、环境变量和配置文件等),这个打包好的运行环境就是image镜像文件。
只有通过这个镜像文件才能生成Docker容器实例(类似Java中new出来一个对象)。

1.4.1.2、分层的镜像

以我们的pu为例,在下载的过程中我们可以看到docker的镜像好像是在一层一层的在下载

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HWCFJMWy-1676019262309)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230130085009210.png)]

1.4.1.3、UnionFS联合文件系统

UnionFS(联合文件系统):Union文件系统(UnionFS)是一种分层、轻量级并且高性能的文件系统,它支持对文件系统的修改作为一次提交来一层层的叠加,同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual
filesystem)。Union文件系统是Docker镜像的基础。镜像可以通过分层来进行继承,基于基础镜像(没有父镜像),可以制作各种具体的应用镜像。

特性:一次同时加载多个文件系统,但从外面看起来,只能看到一个文件系统,联合加载会把各层文件系统叠加起来,这样最终的文件系统会包含所有底层的文件和目录.

1.4.1.4、Docker镜像加载原理

Docker镜像加载原理:
docker的镜像实际上由一层一层的文件系统组成,这种层级的文件系统UnionFS。
bootfs(boot fle system)主要包含bootloader和kernel, bootloader主要是引导加载kernel, Linux刚启动时会加载bootfs文件系统,在Docker镜像的最底层是引导文件系统bootfs。这一层与我们典型的LinuxUnix系统是一样的,包含boot加载器和内核。当boot加载完成之后整个内核就都在内存中了,此时内存的使用权已由bootfs转交给内核,此时系统也会卸载bootfs。

rootfs (root fle system),在bootfs之上。包含的就是典型Linux系统中的/dev, /proc, bin, letc等标准目录和文件。roots就是各种不同的操作系统发行版,比如Ubuntu,Centos等等。

平时我们安装进虚拟机的CentOS都是好几个G,为什么docker这里才200M? ?
对于一个精简的OS,rootfs可以很小,只需要包括最基本的命令、工具和程序库就可以了,因为底层直接用Host的kernel,自己只需要提供rootfs就行了。由此可见对于不同的linux发行版, bootfs基本是一致的, rootfs会有差别,因此不同的发行版可以公用
bootfs。

1.4.1.5、为什么Docker镜像采用这种分层结构呢?

镜像分层最大的一个好处就是共享资源,方便复制迁移,就是为了复用。

比如说有多个镜像都从相同的 base镜像构建而来,那么Docker Host只需在磁盘上保存一份base镜像;同时内存中也只需加载一份base镜像,就可以为所有容器服务了。而且镜像的每一层都可以被共享。

1.4.2、重点理解

Docker镜像层都是只读的,容器层是可写的
当容器启动时一个新的可写层被加载到镜像的顶部。
这一层通常被称作“容器层”,“容器层"之下的都叫“镜像层”。

当容器启动时,一个新的可写层被加载到镜像的顶部。这一层通常被称作“容器层”,“容器层”之下的都叫“镜像层”。
所有对容器的改动。无论添加、删除、还是修改文件都只会发生在容器层中。只有容器层是可写的,容器层下面的所有镜像层都是只读的。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ke4cbqQt-1676019262309)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230130101346430.png)]

1.4.3、Docker镜像commit操作案列

docker commit提交容器副本使之成为一个新的镜像

1.4.3.1、commit提交容器

# commit提交修改后的容器
docker commit -m="[提交的描述信息]" -a="[作者]" [容器ID要创建的目标镜像名]:[标签名]

1.4.3.2、案例演示ubuntu安装vim

1.4.3.2.1、从Hub上下载ubuntu镜像到本地并成功运行
# 下载ubuntu镜像(latest最新版本)
docker pull ubuntu:latest# 运行ubuntu
docker run -it ubuntu /bin/bash
1.4.3.2.2、原始的默认ubuntu镜像是不带着vim

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gVuFGLhn-1676019262309)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230130104928946.png)]

1.4.3.2.3、命令的外网连通的情况下,安装vim
# 更新本地软件包管理器里面的软件列表
apt-get update# 安装vim
apt-get -y install vim

注意:如果更新软件管理包的时候出现报错,这是由于连接的国外的源 可以将阿里的软件源(这里直接修改dns–/etc/resolv.conf文件的nameserver对应IP没有用,需要在daemon.json里面配置dns)

# 退出ubuntu容器
Ctrl+q+p# 修改`/etc/docker/daemon.json`文件
vim /etc/docker/daemon.json
# 修改为
{
"registry-mirrors": ["https://r8ureogc.mirror.aliyuncs.com"],
"dns": ["114.114.114.114","8.8.8.8"]
}# 重启docker镜像
systemctl restart docker# 查看ubuntu容器ID,找到刚刚停止的ubuntu容器ID
docker ps -a# 重启ubuntu容器
docker restart [上一步查询到的容器ID]# 进入ubuntu容器
docker exec -it [容器ID] /bin/bash# 再次执行更新软件管理器软件列表
apt-get update# 安装vim
apt-get -y install vim

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mMURjzly-1676019262309)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230130150416714.png)]

1.4.3.2.4、安装完成后,commit我们自己的新镜像
# 提交修改后的ubuntu镜像
docker commit -m="add vim bash" -a="hippoDocker" [容器ID] hippoDocker/ubuntu01:1.3# 查看本地镜像仓库多了一个`hippoDocker/ubuntu01`的镜像
docker images

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-COvj8nvJ-1676019262310)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230130151947674.png)]

1.4.3.2.5、启动我们的新镜像并和原来的对比团
# 启动新提交的ubuntu镜像
docker run -it --name=ubuntu01 [镜像ID] /bin/bash

该镜像已经有了vim

1.4.3.2.6、小总结

Docker中的镜像分层,支持通过扩展现有镜像,创建新的镜像。类似Java继承于一个Base基础类,自己再按需扩展。
新镜像是从base镜像一层一层叠加生成的。每安装一个软件,就在现有镜像的基础上增加一层.

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yMzjTBU5-1676019262310)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230130152614793.png)]

1.5、本地镜像发布到阿里云

1.5.1、本地镜像发布到阿里云流程

阿里云ESC Docker生态:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aqEdVUBm-1676019262310)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230201101903484.png)]

1.5.2、镜像的生成方法

基于当前容器创建一个新的镜像,新功能增强,具体可以查看1.4.3

# commit提交修改后的容器
docker commit -m="[提交的描述信息]" -a="[作者]" [容器ID要创建的目标镜像名]:[标签名]

除此之外还可以使用DockerFile,具体可以看高级篇

1.5.3、将本地镜像推送到阿里云

本次推送1.4.3案例生成的的ubuntu镜像

1.5.3.1、阿里云开发者平台

https://promotion.aliyun.com/ntms/act/kubernetes.html

位置:左上角产品与服务 -> 容器与中间件 -> 容器服务与镜像 -> 个人实例

1.5.3.2、创建仓库镜像

创建命名空间:
过程忽略…(hippodocker)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DsfDYYRd-1676019262310)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230201110754948.png)]

创建镜像仓库:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xSENN0fn-1676019262311)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230201111033620.png)]

选择本地仓库创建

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PEmPfM9n-1676019262311)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230201111445515.png)]

得到了登录阿里云、拉取镜像、推送镜像的命令

1.5.3.3、将镜像推送到阿里云

复制命令推送修改后的镜像到阿里云仓库(命令地址:仓库镜像 -> 管理)

# 登录阿里云(每个人的命令有所差异)
$ docker login --username=你的坏男孩 registry.cn-hangzhou.aliyuncs.com# 将修改后的镜像推到阿里云仓库
$ docker tag [镜像ID] registry.cn-hangzhou.aliyuncs.com/hippodocker/ubuntu01:[镜像版本号]
$ docker push registry.cn-hangzhou.aliyuncs.com/hippodocker/ubuntu01:[镜像版本号]

注意:如果登录过程中报错Error response from daemon: Get "https://registry.cn-hangzhou.aliyuncs.com/v2/": unauthorized: authentication required ,请设置固定密码,还有注意用户名尽量不使用中文名,我这里后面已经改过,如果有**号,请替换成你的阿里云账号名称
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CKcQTWwO-1676019262320)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230201151046153.png)]

1.5.4、将阿里云上的镜像下载到本地

先删除本地修改后的ubuntu镜像,再从Registry中拉取刚刚上传的ubuntu镜像,没有登录阿里云需要先登录阿里云,可以参考上一步登录阿里云

# 查看本地镜像仓库
$ docker images# 删除本地修改后的ubuntu镜像
$ docker rmi -f [镜像ID]# 从阿里云仓库拉取ubuntu01镜像
$ docker pull registry.cn-hangzhou.aliyuncs.com/hippodocker/ubuntu01:[镜像版本号]# 再次查看本地镜像仓库,是否已经有了拉取的镜像
$ docker images# 运行刚刚拉取下来的镜像
$ docker run -it [镜像ID] /bin/bash#测试`vim`没有问题
$ vim

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OHs1QYqp-1676019262320)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230201161244133.png)]

1.6、本地镜像发布到私有库

1.6.1、本地镜像发布到私有库流程

阿里云ESC Docker生态:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-35tZde3f-1676019262320)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230201101903484.png)]

1.6.2、是什么

Docker Registry

1.官方Dofker Hub地址: https:/hub.docker.coml,中国大`陆访问太慢了且准备被阿里云取代的趋势,不太主流。
2.Dockerhub、阿里云这样的公共镜像仓库可能不太方便,涉及机密的公司不可能提供镜像给公网,所以需要创建一个本地私人仓库供给团队使用,基于公司内部项目构建镜像。

Docker Registry是官方提供的工具,可以用于构建私有镜像仓库。

1.6.3、将本地镜像推送到私有库

1.6.3.1、下载镜像Docker Registry

下载专门搭建个人私服企业版本的Docker registry

# 下载镜像`registry`
$ docker pull registry 

1.6.3.2、运行私有库Registry,相当于本地有个私有Docker hub

默认情况,仓库被创建在容器的/varliblregistry目录下,建议自行用容器卷映射,方便于宿主机联调

# 运行私有库Registry `-d后台运行` `-p 端口映射5000 -> 5000` `-v 容器数据券`
$ docker run -d -p 5000:5000 -v /hippodocker/myregistry/:/tmp/registry --privileged=true registry

1.6.3.3、案例演示创建一个新镜像,ubuntu安装ifconfig命令

运行原生的ubuntu,里面没有ifconfig命令

# 运行原生ubuntu 
$ docker run -it ubuntu /bin/bas# 运行`ifconfig` 测试是否有安装(bash: ifconfig: command not found)
$ ifconfig# 执行更新软件管理器软件列表
$ apt-get update#安装`net-tools`
$ apt-get install net-tools# 再次测试`ifconfig`成功
$ ifconfig# 提交下载了`ifconfig`命令的ubuntu到本地仓库
$ docker commit -m="ifconfig cmd add" -a="hippodocker" [镜像ID] ubuntu02:1.2# 查看本地镜像仓库是否多了一个ubuntu02镜像
$ docker images# 停止刚刚运行的ubuntu
$ docker stop [镜像ID]# 启动新镜像与原来的对比
$ docker run -it [镜像ID] /bin/bash 

1.6.3.4、curl验证私服库上有什么镜像

对应的主机IP和端口对应你的CentOS虚拟机的IP与你Docker registry仓库映射外面的端口

# curl发送get请求查看私服库里面有哪些镜像(还未推送过应该是空的 {"repositories":[]})
$ curl -XGET http://[主机的IP]:5000/v2/_catalog

1.6.3.5、将新镜像ubuntu01:1.3修改符合私服规范的Tag

按照公式: docker tag 镜像:Tag Host:Port/Repository:Tag
自己host主机IP地址,填写你们自己的,不要粘贴错误

# 使用命令docker tag将ubuntu02:1.2这个镜像修改为[主机IP]:5000/ubuntu02:1.2
$ docker tag ubuntu02:1.2 [主机IP]:5000/ubuntu02:1.2# 查看本地镜像仓库
$ docker images

1.6.3.6、修改配置文件使之支持http

别无脑照着复制,registry-mirror配置的是国内阿里提供的镜像加速地址,不用加速的话访问官网的会很慢。

2个配置中团有个逗号,别漏了,这个配置是ison格式的。

# 查看`/etc/docker/daemon.json`文件
$ cat /etc/docker/daemon.json # vim编辑`/etc/docker/daemon.json`文件
$ vim /etc/docker/daemon.json#新增`"insecure-registries":["[主机IP]:5000"]`,总体样式如下,可能你会少一个`dns`的配置
{
"registry-mirrors": ["https://3a17pv1d.mirror.aliyuncs.com"],
"dns":["114.114.114.114","8.8.8.8"],
"insecure-registries":["192.168.175.135:5000"]
}# 保存退出编辑 
Esc -> :wq# 重启docker
$ systemctl restart docker # 运行私有库Registry `-d后台运行` `-p 端口映射5000 -> 5000` `-v 容器数据券`
$ docker run -d -p 5000:5000 -v /hippodocker/myregistry/:/tmp/registry --privileged=true registry

上述理由: docker默认不允许http方式推送镜像,通过配置选项来取消这个限制。=-=>修改完后如果不生效,建议重启docker。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IBDR0acL-1676019262321)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230202144241978.png)]

1.6.3.7、push推送到私服库团

# 推送镜像到registry仓库(后面这一节需要与你上面修改符合私服规范的Tag名称一样)
$ docker push [主机IP]:5000/ubuntu02:1.2

注意:出现报错Get "https://192.168.175.135:5000/v2/": http: server gave HTTP response to HTTPS client,是因为没有重启docker

1.6.3.8、curl验证私服库上有什么镜像2

# curl发送get请求查看私服库里面有哪些镜像(推送过ubuntu02 {"repositories":["ubuntu02"]})
$ curl -XGET http://[主机的IP]:5000/v2/_catalog

1.6.3.9、pull到本地并运行

# 删除本地下载了`ifconfig`的ubuntu镜像
$ docker rmi -f [镜像ID]# 拉取Dcoekr registry本地私服库的ubuntu02镜像
$ docker pull [主机ID]:5000/ubuntu02:1.2# 运行拉取的ubuntu02镜像
$ docker run -it [镜像ID] /bin/bash

1.7、Docker容器数据卷

1.7.1、挂载容器卷记得加入权限

坑:容器卷记得加入

--privileged=true

Docker挂载主机目录访问如果出现权限不够cannot open directory .: Permission denied
解决办法:在挂载目录后多加一个--privileged=true参数即可。

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

例:启动私有库Docker Registry挂载容器卷
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RzfqiGWE-1676019262321)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230202152720499.png)]

1.7.2、是什么

卷就是目录或文件,存在于一个或多个容器中,由docker挂载到容器,但不属于联合文件系统,因此能够绕过Union File System提供一些用于持续存储或共享数据的特性:
卷的设计目的就是数据的持久化,完全独立于容器的生存周期,因此Docker不会在容器删除时删除其挂载的数据卷

一句话:有点类似我们Redis里面的rdb和aof文件

将docker容器内的数据保存进宿主机的磁盘中

运行一个带有容器卷存储功能的容器实例

$ docker run -it --privileged=true -v /[宿主机绝对路径目录]:/[容器内目录] [镜像名] 

1.7.3、能干嘛

*将运用与运行的环境打包镜像,run后形成容器实例运行,但是我们对数据的要求希望是持久化

Docker容器产生的数据,如果不备份,那么当容器实例删除后,容器内的数据自然也就没有了。
为了能保存数据在docker中我们使用卷。

特点:
1:数据卷可在容器之间共享或重用数据
2:卷中的更改可以直接实时生效,爽
3:数据卷中的更改不会包含在镜像的更新中
4:数据卷的生命周期一直持续到没有容器使用它为止

1.7.4、数据卷案列

1.7.4.1、宿主vs容器之间映射添加容器卷

直接添加

# 启动镜像添加挂载数据卷命令格式
$ docker run -it --privileged=true -v /[宿主机绝对路径目录]:/[容器内目录] --name=[容器] [镜像名]# 启动ubuntu镜像挂载数据卷(`/tmp/host_data`	`/tmp/docker_data`)
$ docker run -it --privileged=true -v /tmp/host_data:/tmp/docker_data --name=ubuntu01  ubuntu# 进入`/tmp`文件里面多了一个`/docker_data`文件
$ cd tmp
$ ls# 进入`/docker_data`文件新建一个`dockerin.txt`文档
$ cd docker_data
$ touch dockerin.txt# 退出ubuntu容器
Ctrl + q + p# 进入`/tmp/host_data`再查看文件内是否多了`dockerin.txt`文档
$ cd /tmp/host_data
$ ls -l

结果:退出容器在ubuntu容器中建的文件会自动映射容器外面主机里面也有容器与宿主机实现了数据互通共享

# 查看容器是否挂载数据卷成功( "Mounts"属性)
$ docker inspect [容器ID]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PlwXH4PR-1676019262321)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230203093050005.png)]

1.7.4.2、读写规则映射添加说明

默认读写,直接省略了读写参数rw,rw -> read write

#挂载数据卷,默认读写`rw` 
$ docker run -it --privileged=true -v/[宿主机绝对路径目录]:/[容器内目录]:rw 镜像名

容器只能读取不能写入数据同步给宿主机参数ro,ro -> read only

#挂载数据卷,只读取数据`ro`
$ docker run -it --privileged=true -v/[宿主机绝对路径目录]:/[容器内目录]:ro 镜像名

1.7.4.3、卷的继承和共享

1.7.4.3.1、容器1完成与宿主机的映射
# 运行容器1
$ docker run -it --privileged=true -v /tmp/host_data:/tmp/docker_data --name=ubuntu01  ubuntu /bin/bash# 进入`/tmp/docker_data`
$ cd /tmp/docker_data# 创建`ubuntu01.txt`
$ touch ubuntu01.txt
$ ls -l
1.7.4.3.2、容器2继承容器1的卷规则
# 继承容器卷命令模板(--name后面可以不写等号直接一个空格)(`/bin/bash`可以不写)
$ docker run -it -- privile=true --volumes-from [父类] -- name [子类容器运行的名称] ubuntu /bin/bash# 进入`/tmp/docker_data`
$ cd /tmp/docker_data# 查看所有文件,里面有容器1创建的文件
$ ls -l

注意:停止容器1后容器2修改文件,宿主机的文件依旧会同步,启动容器1后,容器卷依旧会进行同步

1.8、Docker常见安装简介

1.8.1、总体步骤

搜索镜像 -> search

拉取镜像 -> pull

查看镜像 -> images

启动镜像 -> run
注意服务端口映射

停止容器 -> stop

移除容器 -> rm

1.8.2、安装tomcat

# docker,hub上面查找tomcat镜像
$ docker search tomcat# 从docker hub上拉取tomcat镜像到本地
$ docker pull tomcat# docker images查看是否有拉取到的tomcat
$ docker images tomcat# 使用tomcat镜像创建容器实例(也叫运行镜像)(-d 后台运行)
$ docker run -d -p 8080:8080 --name tomcat01 tomcat

访问猫首页

问题:访问localhost:8080,报错404
解决:①可能没有映射端口或者没有关闭防火墙;②把webapps.dist目录换成webapps。

# 进入tomcat控制台(路径:/usr/local/tomcat)
$ docker exec -it [tomcat镜像ID] /bin/bash# 查看是否有webpps文件夹(存在,但是里面没有文件)
$ ls -l# 删除webapps
$ rm -r webapps # 修改webapps.dist为webapps
$ mv webapps.dist webapps# 再次查看文件
$ ls -l

再次访问localhost:8080正常

免修改版说明

# 下载安装了jdk的tomcat8
$ docker pull billygoo/tomcat8-jdk8# 运行刚刚下载的tomcat8不用修改文件就可以直接使用
$ docker run -d -p 8080:8080 --name tomcat8 billygoo/tomcat8-jdk8

1.8.3、安装mysql

1.8.3.1、Mysql安装运行–基础版

# docker hub上面查找mysql镜像
$ docker search mysql# 从docker hub上(阿里云加速器)拉取mysql镜像到本地标签为5.7
$ docker pull mysql:5.7
$ docker images mysql:5.7#查看宿主机是否有mysql实例运行
$ ps -ef|grep mysql# 使用mysql5.7镜像创建容器(也叫运行镜像)(-e 指定环境,设置root账户密码`my-secret-pw`)
$ docker run -p 3306:3306 --name [镜像别名] -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:[版本]# 查看mysql是否启动成功
$ docker ps

简单版使用,建库建表插入数据

# 进入mysql容器
$ docker exec -it [容器ID] /bin/bash# 登录mysql账户,输入密码(密码为上面启动设置的密码)
$ mysql -uroot -p# 查看数据库
$ show databases;# 创建数据库
$ create database db01;# 使用数据库`db01`
$ use db01;# 创建数据表
$ create table t1(id int,name varchar(20));# 插入数据
$ insert into t1 values(1,'hippoDocker');

外部win11客户端连接运行在dokcer上的mysql容器实例服务

没有问题,正常连接,新建的数据库数据表都存在

# 在win11客户端新建查询
# 插入两条数据(第一条成功,第二条报错:`1366 - Incorrect string value: '\xE5\xBCXAOxE4xB8\x89' for column 'name' at row 1`)
insert into t1 values(2,'zhangsan');
insert into t1 values(3,'李四');

问题1:插入中文数据报错
原因:docker上默认字符集编码隐患

# docker里面的mysql容器实例查看,内容如下:
$ sHoW VARIABLES LIKE 'character%';

外部客户端编码为utf8mb4,内部容器编码格式为latin1

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9SHxyHya-1676019262321)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230203143745079.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3wy4YTNE-1676019262322)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230203143834010.png)]

问题2:如果容器删除了,里面mysql的数据怎么办?
原因:启动没有挂载容器数据卷。

1.8.3.2、Mysql安装运行–实战版

# 删除停止上面运行的mysql容器
$ docker rm -f [容器ID]# 启动mysql容器(-d:后台运行	-p:端口映射	--privileged:容器数据卷权限 -v:日志、数据、配置的容器数据卷 -e:指定环境)
$ docker run -d -p 3306:3306 --privileged=true -v /hippodocker/mysql/log:/var/log/mysql -v /hippodocker/mysql/data:/var/lib/mysql -v /hippodocker/mysql/conf:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 mysql:5.7# 进入`/hippodocker/mysql/conf`路径
$ cd /hippodocker/mysql/conf# 查看里面是否有配置文件
$ ls -l# 新建`my.cnf`
$ vim my.conf# 添加以下内容解决乱码问题(退出编辑:Esc -> :wq)
[client]
default_character_set=utf8
[mysqld]
collation_server = utf8_general_ci
character_set_server = utf8# 查看`my.cnf`文件内容
$ cat my.cnf# 重新启动mysql容器实例
$ docker restart [容器ID]# 进入mysql容器
$ docker exec -it [容器ID] /bin/bash# 登录mysql账户,输入密码(密码为上面启动设置的密码)
$ mysql -uroot -p# 查看字符编码
$ sHoW VARIABLES LIKE 'character%';# 重新建库建表加数据测试中文数据
# 查看数据库
$ show databases;# 创建数据库
$ create database db01;# 使用数据库`db01`
$ use db01;# 创建数据表
$ create table t1(id int,name varchar(20));# 插入数据
$ insert into t1 values(1,'hippoDocker');# win11客户端远程连接mysql新建查询(中文字符数据插入成功)
$ insert into t1 values(2,'张三');

结论:

之前的DB无效

修改字符集操作+重启mysql容器实例

之后的DB有效,需要新建

结论: 1.docker安装完MySQL并run出容器后,建议请先修改完字符集编码后再新建mysql库-表-插数据;
2.当mysql容器删除后,只要宿主机的数据不删,下次重新启动mysql容器,继续挂载原来指定的容器数据卷,宿主机原来报错的数据就会同步到mysql容器中。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-h0SICwP5-1676019262322)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230203161003220.png)]

1.8.4、安装redis

1.8.4.1、常规安装redis–常规版

# docker hub上面查找redis镜像
$ docker search redis# 从docker hub上(阿里云加速器)拉取redis镜像到本地标签为6.0.8
$ docker pull redis:6.0.8
$ docker images redis:6.0.8#查看宿主机是否有mysql实例运行
$ ps -ef|grep redis# 使用redis6.0.8镜像创建容器
$ docker run -d -p 6379:6379 --name [镜像别名] redis:6.0.8# 查看mysql是否启动成功
$ docker ps# 进入redis控制台
$ docker exec -it [容器ID] /bin/bash# 进入redis客户端
$ redis-cli

问题:1.没有挂载容器数据卷;2.没有redis.conf配置文件。

1.8.4.2、常规安装redis–实战版

命令提醒:容器卷记得加入权限--privileged=true

# 删除停止上面运行的redis容器
$ docker rm -f [容器ID]# 新建目录`/app/redis`
$ mkdir -p /app/redis# 找一个`redis.conf`模板放入`/app/redis`目录中(没有就在一个默认的就行)
$ cp [原redis.conf文件位置] /app/redis/# 修改`redis.conf`以下配置
# 1.开启redis验证密码(可选)
$ requirepass 123
# 2.注释掉`bind 127.0.0.1`,运行外部客户端连接
$ # bind 127.0.0.1
# 3.将daemonize yes注释起来或者daemonize no设置,因为该配置和docker run中-d参数冲突,会导致容器一直启动失败
$ daemonize no
# 4.开启redis数据持久化 appendonly yes(可选)
$ appendonly yes
# 5.关闭redis保护模式 protected-mode no(可选)
$ protected-mode no# 启动redis容器(-d:后台运行	-p:端口映射	--privileged:容器数据卷权限 -v:配置、数据的容器数据卷 redis-server /etc/redis/redis.conf:指定配置文件启动redis,类似原来的`/bin/bash` )
$ docker run -d -p 6379:6379 --privileged=true -v /app/redis/redis.conf:/etc/redis/redis.conf -v /app/redis/data:/data --name redis01 redis:6.0.8 redis-server /etc/redis/redis.conf# 进入redis容器
$ docker exec -it [容器ID] /bin/bash# 进入redis客户端
$ redis-cli# 查看里面是否有配置文件
$ ls -l# 添加数据获取数据测试
$ set k1 v1
$ get k1
$ ping# 获取redis第16个数据库(如果没有第16个数据,会报错超出索引)
$ select 16# 退出redis容器修改`/app/redis/redis.conf`配置文件 databases数据库为10,默认16个
$ databases 10# 重启redis容器,查看redis配置文件是否生效
$ docker restart [容器ID]## 进入redis容器
$ docker exec -it [容器ID] /bin/bash# 进入redis客户端
$ redis-cli# 获取redis第16个数据库(报错超出索引`( error)ERR DB index is out of range`)
$ select 16# 测试win11的redis客户端连接redis(没有问题)

1.8.5、安装Nginx

见高级篇–Docker轻量级可视化工具Portainer

2、高级篇(大厂进阶)

2.1、Docker复杂安装详说

2.1.1、安装mysql主从复制

2.1.1.1、主从复制原理

概念:主从复制是用来建立一个和 主数据库完全一样的数据库环境称为从数据库;主数据库一般是准实时的业务数据库。

后端MYSQL数据库只有一台时候,会有以下问题:

1、单点故障服务不可用
2、无法处理大量的并发数据请求
3、数据丢失

优点:

1、如果主节点出现故障,那么我们就直接将服务切到从节点,来保证服务立马可用。
2、如果并发请求特别大的时候,我们可用进行读写分离操作,让主库负责写,从库负责读。
3、如果主库数据丢失,但从库还保存一份,减少数据丢失的风险。

原理:

(1) Master的更新事件(update、insert、delete)会按照顺序写入bin-log中。当Slave连接到Master的后,Master机器会为Slave开启

binlog dump线程,该线程会去读取bin-log日志

(2) Slave连接到Master后,Slave库有一个I/O线程 通过请求binlog dump thread读取bin-log日志,然后写入从库的relay log日志中。

(3) Slave还有一个 SQL线程,实时监控 relay-log日志内容是否有更新,解析文件中的SQL语句,在Slave数据库中去执行。

2.1.1.2、主从搭建步骤

①新建主服务器容器实例3307

# 启动主服务器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

②进入/mydata/mysql-master/conf目录下新建my.cnf

# 新建`/mydata/mysql-master/conf/my.conf`(添加以下内容)
$ vim /mydata/mysql-master/conf/my.conf[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

③修改完配置后重启master实例

#重启mysql-master实例
$ docker restart mysql-master

④进入mysql-master容器

# 进入mysql-master容器
$ docker exec -it mysql-master /bin/bash# 登录mysql(输入密码root)
$ mysql -uroot -p

⑤master容器实例内创建数据同步用户

# 创建`slave`用户-从机
CREATE USER 'slave'@'%' IDENTIFIED BY '123456';# 给`slave`用户授权
GRANT REPLICATION SLAVE,REPLICATION CLIENT ON *.* TO 'slave'@'%';

⑥新建从服务器容器实例3308

# 启动从服务器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

⑦进入/mydata/mysql-slave/conf目录下新建my.cnf

# 新建`/mydata/mysql-slave/conf/my.conf`(添加以下内容)
$ vim /mydata/mysql-slave/conf/my.conf[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表示siave将复制事件写进自己的二进制日志
log_slave_updates=1
##slave设置为只读(具有super权限的用户除外)
read_only=1

⑧修改完配置后重启slave实例

#重启mysql-slave实例
$ docker restart mysql-slave

⑨在主数据库中查看主从同步状态

# 查看主从同步状态
$ show master status;

⑩进入mysql-slave容器

# 进入mysql-master容器
$ docker exec -it mysql-slave /bin/bash# 登录mysql(输入密码root)
$ mysql -uroot -p

⑪在从数据库中配置主从复制

# 配置主从复制(主机IP,还有后面的用户密码等根据自己的写)(master_log_file名称是上面`show master status`得到的文件名称)
$ 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;

主从复制参数说明:

master_host:主数据库的IP地址;
master_port:主数据库的运行端口;
master_user:在主数据库创建的用于同步数据的用户账号;
master_password:在主数据库创建的用于同步数据的用户密码;
master_log_file:指定从数据库要复制数据的日志文件,通过查看主数据的状态,获取File参数;
master_log_pos:指定从数据库从哪个位置开始复制数据,通过查看主数据的状态,获取Position参数;
master_connect_retry:连接失败重试的时间间隔,单位为秒。

⑫在从数据库中查看主从同步状态

# 查看主从同步状态(`\G`不同的显示格式,`Slave_IO_Rinning:No  Slave_SQL_Running:No`)
$ show slave status \G;

⑬在从数据库中开启主从同步

# 开启主从同步
$ start slave;

⑭查看从数据库状态发现已经同步

# 查看主从同步状态(`\G`不同的显示格式,`Slave_IO_Rinning:Yes  Slave_SQL_Running:Yes`)
$ show slave status \G;

⑮主从复制测试

# 主机master新建库 -> 使用库 -> 新建表 -> 使用表
。。。。。。。(省略)# 从机slave使用库,没问题
。。。。。。。(省略)

2.1.2、安装redis渠群(大厂面试题第4季-分布式存储案例真题)

cluster(集群)模式-docker版
哈希槽分区进行亿级数据存储

2.1.2.1、1~2亿条数据需要缓存,请问如何设计这个存储案例?

回答:单机单台100%不可能,肯定是分布式存储,用redis如何落地?

上述问题阿里P6~P7工程案例和场景设计类必考题目,一般业界有3种解决方案

2.1.2.1.1、哈希取余分区(安全隐患)

2亿条记录就是2亿个k,v,我们单机不行必须要分布式多机,假设有3台机器构成一个集群,用户每次读写操作都是根据公式:hash(key) % N个机器台数,计算出哈希值,用来决定数据映射到哪一个节点上。

优点:简单粗暴,直接有效,只需要预估好数据规划好节点,例如13台、8台、10台,就能保证一段时间的数据支撑。使用Hash算法让固定的一部分请求落到同一台服务器上,这样每台服务器固定处理一部分请求(并维护这些请求的信息),起到负载均衡+分而治之的作用。

缺点:原来规划好的节点,进行扩容或者缩容就比较麻烦了额,不管扩缩,每次数据变动导致节点有变动,映射关系需要重新进行计算,在服务器个数固定不变时没有问题,如果需要弹性扩容或故障停机的情况下,原来的取模公式就会发生变化: Hash(key)/3会变成Hash(key)/?。此时地址经过取余运算的结果将发生很大变化,根据公式获取的服务器也会变得不可控。
某个redis机器宕机了,由于台数数量变化,会导致hash取余全部数据重新洗牌。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dXhu7bJd-1676019262322)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230207143528595.png)]

2.1.2.1.2、一致性哈希算法

背景:一致性哈希算法在1997年由麻省理工学院中提出的,设计目标是为了解决分布式缓存数据变动和映射问题,某个机器单机了,分母数量改变了,自然取余数不OK了。

能干嘛:提出一致性Hash解决方案。目的是当服务器个数发生变动时,尽量减少影响客户端到服务器的映射关系。

三大步骤:①算法构建一致性哈希环;②服务器lp节点映射;③key落到服务器的落键规则。

# 一致性哈希环
一致性哈希算法必然有个hash函数并按照算法产生hash值,这个算法的所有可能哈希值会构成一个全量集,这个集合可以成为一个hash空间[0,2^32-1],这个是一个线性空间,但是在算法中,我们通过适当的逻辑控制将它首尾相连(0=2^32)这样让:它逻辑上形成了一个环形空间。
它也是按照使用取模的方法,前面笔记介绍的节点取模法是对节点(服务器)的数量进行取模。而一致性Hash算法是对2^32取模,简单来说,一致性Hash算法将整个哈希值空间组织成一个虚拟的圆环,如假设某哈希函数H的值空间为0-2^32-1(即哈希值是一个32位无符号整形〉,整个哈希环如下图:整个空间按顺时针方向组织,圆环的正上方的点代表0,0点右侧的第一个点代表1,以此类推,2、3、4、……直到2^32-1,也就是说0点左侧的第一个点代表2^32-1,0和2^32-1在零点中方向重合,我们把这个由2^32个点组成的圆环称为Hash环。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q0uXRgha-1676019262322)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230207145253525.png)]

# 节点映射
将集群中各个IP节点映射到环上的某一个位置。
将各个服务器使用Hash进行一个哈希,具体可以选择服务器的IP或主机名作为关键字进行哈希。这样每台机器就能确定其在哈希环上的位置。假如4个节点NodeA、B、C、D,经过IP地址的哈希函数计算(hash(ip)),使用IP地址哈希后在环空间的位置如下:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0TZSIiof-1676019262323)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230207145739085.png)]

# key落到服务器的落键规则
当我们需要存储一个kv键值对时,首先计算key的hash值,hash(key)将这个key使用相同的函数Hash计算出哈希值并确定此数据在环上的位置,从`此位置沿环顺时针“行走”`,第一台遇到的服务器就是其应该定位到的服务器,并将该键值对存储在该节点上。
如我们有ObjectA、Object B、ObjectC、Object D四个数据对象,经过哈希计算后,在环空间上的位置如下:根据一致性Hash算法,数据A会被定为到Node A上,B被定为到Node B上,C被定为到Node C上,D被定为到Node D上。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kCvIvTdg-1676019262323)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230207150255294.png)]

优点:
①一致性哈希算法的容错性:假设Node C宕机,可以看到此时对象A、B、D不会受到影响,只有C对象被重定位到Node D。一般的,在一致性Hash算法中,如果一台服务器不可用,则受影响的数据仅仅是此服务器到其环空间中前一台服务器(即沿着逆时针方向行走遇到的第一台服务器)之间数据,其它不会受到影响。简单说,就是C挂了,受到影响的只是B、C之间的数据,并且这些数据会转移到D进行存储。
②一致性哈希算法的扩展性:数据量增加了,需要增加一台节点NodeX,X的位置在A和B之间,那收到影响的也就是A到X之间的数据,重新把A到X的数据录入到X上即可,不会导致hash取余全部数据重新洗牌。

缺点:一致性哈希算法的数据倾斜问题:一致性Hash算法在服务节点太少时,容易因为节点分布不均匀而造成数据倾斜(被缓存的对象大部分集中缓存在某一台服务器上)问题,例如系统中只有两台服务器。

总结:为了在节点数目发生改变时尽可能少的迁移数据。
将所有的存储节点排列在收尾相接的Hash环上,每个key在计算Hash后会顺时针找到临近的存储节点存放。而当有节点加入或退出时仅影响该节点在Hash环上顺时针相邻的后续节点。
优点
加入和删除节点只影响哈希环中顺时针方向的相邻的节点,对其他节点无影响。
缺点
数据的分布和节点的位置有关,因为这些节点不是均匀的分布在哈希环上的,所以数据在进行存储时达不到均匀分布的效果。

2.1.2.1.3、分区哈希槽分区

是什么:
为什么出现:解决一致性哈希算法的数据倾斜问题
哈希槽实质就是一个数组,数组[0,2^14-1]形成hash slot空间。
能干什么:解决均匀分配的问题,在数据和节点之间又加入了一层,把这层称为哈希槽(slat),用于管理数据和节点之间的关系,现在就相当于节点上放的是槽,槽里放的是数据。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QER7UX4a-1676019262323)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230207152208413.png)]
槽解决的是粒度问题,相当于把粒度变大了,这样便于数据移动。
哈希解决的是映射问题,使用key的哈希值来计算所在的槽,便于数据分配。
③多少个hash槽:一个集群只能有16384个槽,编号0-16383(0-2^14-1)。这些槽会分配给集群中的所有主节点,分配策略没有要求。可以指定哪些编号的槽分配给哪个主节点。集群会记录节点和槽的对应关系。解决了节点和槽的关系后,接下来就需要对key求哈希值,然后对18384取余,余数是几key就落入对应的槽里。slot = CRC16(key) % 16384。以槽为单位移动数据,因为槽的数目是固定的,处理起来比较容易,这样数据移动问题就解决了。

哈希槽计算:
Redis集群中内置了16384个哈希槽,redis会根据节点数量大致均等的将哈希槽映射到不同的节点。当需要在Redis集群中放置一个key-value时, redis 先对 key使用crc16算法算出一个结果,然后把结果对16384求余数,这样每个key都会对应一个编号在0-16383之间的哈希槽,也就是映射到某个节点上。如下代码,key之A、B在Node2, key之C落在Node3上。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BDijkqO6-1676019262323)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230207153002015.png)]

@Test
public void test(){
// import io.Lettuce.core.cluster.sLotHash;system.out.println(slotHash.getslot( key: "A"));//6373system.out.println(slotHash.getslot( key: "B"));//10374
system.out.println(slotHash.getslot( key: "c"));//14503system.out.println(slotHash.getslot( key:"hello"));//866
}

2.1.2.2、搭建3主3从redis集群扩缩容配置案例架构说明

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ip2j2wOQ-1676019262324)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230208090713301.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Hs9dnzE3-1676019262324)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230208094858250.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LQQAgUip-1676019262324)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230208104339173.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-W5zbZUQA-1676019262324)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230208163638471.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dJn4jQym-1676019262324)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230208163710569.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mHbtuI36-1676019262325)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230208163730711.png)]

2.1.2.3、搭建3主3从redis集群扩缩容配置

2.1.2.3.1、3主3从redis集群配置

①关闭防火墙+启动docker后台服务

# 关闭防火墙
$ systemctl start docker

②新建6个docker容器实例

# 启动6个redis容器
docker run -d --name redis-node-1 --net host --privileged=true -v /data/redis/share/redis-node-1:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6381docker run -d --name redis-node-2 --net host --privileged=true -v /data/redis/share/redis-node-2:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6382docker run -d --name redis-node-3 --net host --privileged=true -v /data/redis/share/redis-node-3:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6383docker run -d --name redis-node-4 --net host --privileged=true -v /data/redis/share/redis-node-4:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6384docker run -d --name redis-node-5 --net host --privileged=true -v /data/redis/share/redis-node-5:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6385docker run -d --name redis-node-6 --net host --privileged=true -v /data/redis/share/redis-node-6:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6386

命令分步解释

# 创建并运行docker容器实例
docker run
# 容器名字
--name redis-node-6O
# 使用宿主机的IP和端口,默认
--net host
# 获取宿主机root用户权限
--privileged=true
# 容器卷,宿王机地址:docker内部地址
-v /data/redis/share/redis-node-6:/data
# redis镜像和版本号
redis:6.0.8
# 开启redis集群
--cluster-enabled yes
# 开启持久化
--appendonly yes
# redis端口号
--port 6386

③进入容器redis-node-1并为6台机器构建集群关系

# 进入容器
docker exec -it redis-node-1 /bin/bash# 进入docker容器后执行(后面输入yes)
redis-cli --cluster create [redis容器主机IP]:6381 [redis容器主机IP]:6382 [redis容器主机IP]:6383 [redis容器主机IP]:6384 [redis容器主机IP]:6385 [redis容器主机IP]:6386 --cluster-replicas 1

–cluster-replicas 1表示为每个master创建一个slave节点,一主一从的创建,挂载的位置随机分配,创建好之后M代表主数据库,S代表从数据库

④链接进入6381作为切入点,查看集群状态

# 进入端口为6381的redis客户端
redis-cli -p 6381# 查看集群状态(`cluster_state:ok`状态 `cluster_slots_assigned:16384`槽位 `cluster_know_nodes:6`集群数量)
cluster info# 查看集群的节点信息(可查看具体挂载信息)
cluster nodes
2.1.2.3.2、主从容错切换迁移案例
2.1.2.3.2.1、数据读写存储

①启动6机构成的集群并通过exec进入

# 进入redis-node-1容器
docker exec -it redis-node-1 /bin/bash# 连接端口为6381的redis客户端(单机版,新增不在越槽位的数据会报错`(error) moved ....`)
redis-cli -p 6381# 查看所有key
keys*

②对6381新增两个key

# 新增两个key(需要对应槽位进行插入数据,后面会提示存入哪一条redis容器)
set k1 v1
set k2 v2

③防止路由失效加参数-c并新增两个key

# 以集群的方式连接端口为6381的redis客户端(`-c`集群方式连接,新增越槽位的数据会重定向到对应的redis主机`redirected to ........`)
redis-cli -p 6381 -c

④查看集群信息

# 检测集群信息
redis-cli --cluster check [主机ID]:检查redis的容器端口
2.1.2.3.2.2、容错切换迁移

①主6381和从机切换,先停止主机6381

# 进入6381容器
docker exec -it redis-node-1 .bin/bash# 停止6381
exit# 查看正在运行的容器
docker ps# 停止`redis-node-1`容器
docker stop redis-node-1# 进入`redis-node-2`容器
docker exec -it redis-node-2 /bin/bash

②再次查看集群信息

# 启动6382客户端(`-c`集群方式)
redis-cli -p 6382 -c# 查看集群的节点信息(可查看具体挂载信息)(依旧存在6个节点,不过6381对应的从机slave自动切换成了master)
cluster nodes

6381宕机了,6384(这里只是6381对应的从机是6384,具体以自己实际的为准)上位成为了新的master。

③先还原之前的3主3从

# 重启redis-node-1容器
docker start redis-node-1# 进入redis-node-1容器
docker exec -it redis-node-1 /bin/bash# 以集群方式启动redis-node-1客户端
redis-cli -p 6381 -c# 查看集群节点信息(redis-node-1变成了从节点slave)
cluster nodes# 停止redis-node-1对应的主节点(我这里对应的redis-node-4,根据自己实际对应的节点)
docker stop redis-node-4# 启动redis-node-1对应的节点
docker start redis-node-4

总结:宕机前为master,宕机重启后就变成了slave,要想恢复为主节点,需要重启现在对应的主节点。

④查看集群状态

# 进入redis-node-1容器
docker exec -it redis-node-1 /bin/bash# 以集群方式启动redis-node-1客户端
redis-cli -p 6381 -c# 查看集群节点信息(redis-node-1变成了主节点master)
cluster nodes# 检测集群信息(与之前查看的一样,没有丢失数据)
redis-cli --cluster check [主机ID]:6381
2.1.2.3.3、主从扩容案例切换迁移

①新建6387、6388两个节点+新建后启动+查看是否8节点

# 新建6387、6388两个节点
docker run -d --name redis-node-7 --net host --privileged=true -v /data/redis/share/redis-node-7:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6387docker run -d --name redis-node-8 --net host --privileged=true -v /data/redis/share/redis-node-8:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6388# 查看所有运行的容器
docker ps

②进入6387容器实例内部

# 进入6387容器实例内部
docker exec -it redis-node-7 /bin/bash

③将新增的6387节点(空槽号)作为master节点加入原集群

# 将新增的6387节点(空槽号)作为master节点加入原集群(`add node`添加节点)
redis-cli --cluster add-node [自己实际P地址]:6387 [自己实际lP地址]:6381

将新增的6387作为master节点加入集群
redis-cli --cluster add-node 自己实际P地址:6387 自己实际lP地址:6381

6387就是将要作为master新增节点
6381就是原来集群节点里面的领路人,相当于6387拜拜6381的码头从而找到组织加入集群

④检查集群情况第1次

# 检查集群情况(后面端口可以随便写一个主节点端口6381、6382、6383、6384都可以,槽点为0 slots -> 0 slots,没有槽位)
redis- cli --cluster check [自己实际P地址]:6381

⑤重新分派槽号

# 给集群重新哈希分配槽号(先输入`4096`槽位,4096=16384/mster台数,均匀分配,
# 再次输入6387的ID,上面检查集群所查看到的ID,
# 最后输入`all`,全部分配)
redis-cli --cluster reshard [lP地址]:6371

重新分派槽号
命令:redis-cli --cluster reshard [lP地址]:[端口号]

⑥检查集群情况第2次

# 检查集群情况(槽点为`4096 slots -> 0 slots`,槽位发生变化,6381节点的槽位变成了[1365-5460],槽位大小发生变化,而6387的槽位为`slote:[0-1364],[5461-6826],[10923-12287]`三段分开的槽位,前面的每一个主节点均匀分配一点给了4397)
redis- cli --cluster check [自己实际P地址]:6381

槽号分派说明:
为什么6387是3个新的区间,以前的还是连续?
重新分配成本太高(有些key已经存在原来的槽点里面了),所以前3家各自匀出来一部分,从6381/6382/6383三个旧节点分别匀出1364个坑位给新节点6387。

⑦为主节点6387分配从节点6388

# 为主节点6387分配从节点6388
redis-cli --cluster add-node [自己主机的IP]:6388 [自己主机的IP]:6387 --cluster-slave --cluster-master-id [新主机节点ID]

命令: redis-cli --cluster add-node ip:新slave端口 ip:新master端口 --cluster-slave --cluster-master-id新主机节点ID

⑧检查集群情况第3次

# 检查集群情况(4个master,4个slote,4主4从)
redis- cli --cluster check [自己实际P地址]:6381
2.1.2.3.4、主从缩容案例

目的:6387和6388下线

①检查集群情况1获得6388的节点ID

# 检查集群情况(获取得到6388节点ID)
redis- cli --cluster check [自己实际P地址]:6381

②将6388删除,从集群中将4号从节点6388删除

# 节点6388删除
redis-cli --cluster del-node [自己主机IP]:[上一步获取到的6388节点ID]# 检查集群情况(没有了从节点6388节点)
redis- cli --cluster check [自己主机IP]:6381

命令: redis-cli --cluster del-node ip:从机端口从机6388节点ID

③将6387的槽号清空,重新分配,本例将清出来的槽号都给6381

# # 给集群重新哈希分配槽号(操作的是整个集群,并不是只处理6381)
# (先输入`4096`槽位,6387节点的所有槽位
# 再次输入`6381的ID`,上面检查集群所查看到的ID,用6381来接收清理多出来的槽号,
# 再输入`6387的ID`,指定需要清理槽号的节点,
# 最后输入`done`,全部清理)
redis-cli --cluster reshard [自己主机IP]:6381

注意:可以多次分配,不用一次都分配4096个槽位

④检查集群情况第二次

# 检查集群情况(4096个槽位都指给6381,它变成了8192个槽位,相当于全部都给6381了,不然要输入3次,一锅端
)
redis- cli --cluster check [自己实际P地址]:6381

⑤将6387删除

# 删除6387节点
redis-cli --cluster del-node [自己主机IP]:[从机端口6387节点ID]

检查集群情况第三次

# 检查集群情况(没有了从节点6387节点)
redis- cli --cluster check [自己实际P地址]:6381

2.2、DockerFile解析

2.2.1、是什么

是什么

Dockerfile是用来构建Docker镜像的文本文件,是由一条条构建镜像所需的指令和参数构成的脚本。

概述

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3MNxBOuu-1676019262325)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230209085546141.png)]

官网

https://docs.docker.com/engine/reference/builder/

构建三步骤

编写DockerFile文件 -> docker build 命令构建镜像 -> docker run 依镜像运行容器实例

2.2.2、DockerFile构建过程解析

2.2.2.1、Dockerfile内容基础知识

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

②指令按照从上到下,顺序执行

③#表示注释

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

2.2.2.2、Docker执行Dockerfile的大致流程

①dogker从基础镜像运行一个容器

②执行一条指令并对容器作出修改

③执行类似docker commit的操作提交一个新的镜像层

④docker再基于刚提交的镜像运行一个新容器

⑤执行dockerfile中的下一条指令直到所有指令都执行完成

2.2.2.3、小总结

从应用软件的角度来看,Dockerfile、Docker镜像与Docker容器分别代表软件的三个不同阶段,
–Dockerfile是软件的原材料
–Docker镜像是软件的交付品
–Docker容器则可以认为是软件镜像的运行态,也即依照镜像运行的容器实例
Dockerfile面向开发,Docker镜像成为交付标准,Docker容器则涉及部署与运维,三者缺一不可,合力充当Docker体系的基石。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cri8c7q9-1676019262325)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230209152824825.png)]

1、Dockerfile,需要定义一个Dockerfile,Dockerile定义了进程需要的一切东西。Dockerfle涉及的内容包括执行代码或者是文件、环境变量、依赖包、运行时环境、动态链接库、操作系统的发行版、服务进程和内核进程(当应用进程需要和系统服务和内核进程打交道,这时需要考虑如何设计namespace的权限控制)等等;
2、Docker镜像,在用Dockerfle定义一个文件之后,docker buildm时会产生一个Docker镜像,当运行Docker镜像时会真正开始提供服务;
3、Docker容器,容器是直接提供服务的。

2.2.3、DockerFile常用保留字指令

参考tomcat8的dockerfile入门
https://github.com/docker-library/tomcat

# 基础镜像,当前新镜像是基于哪个镜像的,指定一个已经存在的镜像作为模板,第一条必须是from
FROM
# 镜像维护者的姓名和邮箱地址
MAINTAINER
# (1)容器构建时需要运行的命令;(2)两种格式:shell格式、exec格式;(3)RUN是在docker build时运行;
RUN # shell格式
# <命令行命令>等同于,在终端操作的shell命令。
RUN <命令行命令># shell格式
# RUN [ "./test.php" , "dev", "offline"]等价于RUN ./test.php dev offline
RUN [“可执行文件”,“参数1”,“参数2]
# 当前容器对外暴露出的端口
EXPOSE
# 指定在创建容器后,终端默认登陆的进来工作目录,一个落脚点
WORKDIR
# 指定该镜像以什么样的用户去执行,如果都不指定,默认是root
USER
# 用来在构建镜像过程中设置环境变量
ENVENV MY_PATH /usr/mytest
这个环境变量可以在后续的任何RUN指令中使用,这就如同在命令前面指定了环境变量前缀一样;
也可以在其它指令中直接使用这些环境变量,
比如: WORKDIR SMY PATH
# 将宿主机目录下的文件拷贝进镜像且会自动处理uRL和解压tar压缩包
ADD
# 类似ADD,拷贝文件和具录到镜像中。
# 将从构建上下文目录中源路径>的文件/目录复制到新的层的镜像内的<目标路径>位置
COPYCOPY src dest
cOPY ["src" , "dest"]
# :源文件或者源目录
# :容器内的指定路径,该路径不用事先建好,
# 容器数据卷,用于数据保存和持久化工作
VOLUME
# 指定容器启动后的要干的事情
CMDCMD容器启动命令
CND指令的格式和RUN相似,也是两种格式:
shell格式:CMD <命令>
exec格式:CMD ["可执行文件”,"参数1",“参数2"...]
参数列表格式: CMD ["参数1",“参数2"...]。在指定了 ENTRYPOINT 指令后,用 CMD 指定具体的参数。注意:
(1)Dockerfile中可以有多个cMD指令,但只有最后一个生效,CMD会被docker run之后的参数替换
(2)参考官网Tomcat的dockerfile演示讲解
(1)最后一行命令:
EXPOSE 8080
CMD ["catalina.sh", "run"]
(2)演示自己的覆盖操作
docker run -it -p 8080:808057800e5b1cbfl `/bin/ bash`
`/bin/ bash`:覆盖操作它和前面RUN命令的区别:
CMD是在docker run时运行。
RUN是在docker build时运行。
# 用来指定一个容器启动时要运行的命令
ENTRYPOINT类似于 CMD 指令,但是ENTRYPOINT不会被docker run后面的命令覆盖,而且这些命令行参数会被当作参数送给ENTRYPOINT指令指定的程序命令格式和案例说明:
命令格式:ENTRYPOINT [ "" , "" , "",...]
ENTRYPOINT 可以和CMD一起用,一般是变参才会使用CMD,这里的CMD等于是在给ENTRYPOINT传参。
当指定了 ENTRYPOINT 后, CMD 的含义就发生了变化,不再是直接运行其命令而是将CMD的内容作为参数传递给 ENTRYPOINT 指令,他两个组合会变成  ""
案例如下:假设已通过Dockerfile构建了nginx:test镜像:
FROM nginx
ENTRYPOINT [ "nginx", "-c"]#定参
CMD ["/etc/nginx/nginx.conf"]#变参

小总结

BUILDBothRUN
FROMWORKIRCMD
MAINTAINERUSERENV
COPYEXPOSE
ADDVOLUME
RUNENTRYPOINT
ONBUILD
.dockerignore

2.2.4、案例

2.2.4.1、自定义镜像mycentosjava8

①要求

#Centos7镜像具备vim+ifconfig+jdk8#JDK的下载镜像地址
官网:https://www.oracle.com/java/technologies/downloads/#java8
https://mirrors.yangxingzhen.com/jdk/
下载 x64 xxx.tar.gz版本

编写

# 编写Dockerfile文件(首字母大写D)
FROM centos #基础镜像
MAINTAINER hippoDocker #指定作者和邮箱ENV MYPATH /usr/local #指定环境变量`MYPATH`,登录后进去`/usr/local`地址
WORKDIR $MYPATH #终端默认登陆的进来工作目录`MYPATH`RUN yum -y install vim #安装vim编辑器
RUN yum -y install net-tools #安装ifconfig查看网络IP
RUN yum -y install glibc.i686 #安装java8及lib库
RUN mkdir /user/local/java #创建`java`文件夹
ADD jdk-8u361-linux-x64.tar.gz /user/local/java #ADD是相对路径jar,把jdk-8u171-linux-x64.tar.gz添加到容器中,安装包必须要和Dockerfile文件在同一位置
ENV JAVA_HOME /usr/local/java/jdk1.8.0_361 #配置java环境变量
ENV JRE_HOME $JAVA_HOME/jre
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_PATH/lib:$CLASSPATH
ENV PATH $JAVA_HOME/bin:$PATHEXPOSE 80 #对外暴露端口CMD echo $MYPATH #打印`MYPATH`路径
CMD echo "success---------ok" #打印成功的信息
CMD /bin/bash #伪终端

构建

# 构建镜像命令格式(注意`TAG`后面有一个空格,有个点)
docker build -t [新镜像名字]:TAG .# 1、将新建的`Dockerfile`文件和下载的`jdk-8u361-linux-x64.tar.gz`文件放入`/myfile`文件中
。。。。此处代码省略# 查看路径
pwd# 查看文件
ll# 2、`/myfile`路径下构建新镜像(`centosjava8`:自定义的镜像名字,`1.8`:版本号)
docker build -t centosjava8:1.8 .# 3、新构建的镜像
docker images

运行

# 运行新构建的`centosjava8`镜像
docker run -it centosjava8:1.5 /bin/bash# 测试`vim`
vim# 测试`ifconfig`
ifconfig# 测试java环境
java -version

UnionFS(联合文件系统〉:Union文件系统(UnionFS)是一种分层、轻量级并且高性能的文件系统,它支持对文件系统的修改作为一次提交来一层层的叠加,同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual
filesystem)。Union文件系统是Docker镜像的基础。镜像可以通过分层来进行继承,基于基础镜像(没有父镜像〉,可以制作各种具体的应用镜像。

特性:一次同时加载多个文件系统,但从外面看起来,只能看到一个文件系统,联合加载会把各层文件系统叠加起来,这样最终的文件。

2.2.4.2、虚悬镜像

是什么

仓库名、标签都是的镜像,俗称dangling image。

构建出虚悬镜像的案例

# Dockerfile文件内容
FROM ubuntu
CMD echo `action is success`
# 构建(会打印`action is success`构建成功)
docker build . # 查看所有镜像(镜像名称、TAG版本都会显示``)
docker images# 查看docker引擎上面的所有虚悬镜像
docker images ls -f dangling=true# 删除虚悬镜像(输入`y`)
docker images prune

2.2.4.3、家庭作业-自定义镜像myubuntu

编写:准备编写DockerFile文件

FROM ubuntu
MAINTAINER hippoDockerENV MYPATH /usr/local
WORKDIR $MYPATHRUN apt-get update
RUN apt-get install net-toolsEXPOSE 80CMD echo $MYPATH
CMD echo "install ipconfig success!"
CMD /bin/bash

构建:docker build -t [新镜像名字]:TAG .

# 构建新的myubuntu镜像
docker build myubuntu:TAG

运行:docker run -it [新镜像名字]:TAG

# 运行自己构建的镜像
docker run -it myubuntu:TAG

2.2.5、小总结

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dwulPN4p-1676019262326)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230210112729986.png)]

2.3、Docker微服务实战

2.3.1、通过IDEA新建一个普通微服务模块

建Module

// 新建模块`docker_boot`

改POM


4.0.0org.springframework.bootspring-boot-starter-parent2.5.6com.hippoDocker.dockerdocker_boot0.0.1-SNAPSHOTUTF-81.81.8					1.8         2.1.2org.springframework.bootspring-boot-starter-weborg.springframework.bootspring-boot-starter-actuator< ! --test-->org.springframework.bootspring-boot-starter-testtest

写YML

server:port: 6001

主启动

package com.atguigu.docker;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.springBootApplication;@SpringBootApplication
public class DockerBootApplication{public static void main(string[]args){SpringApplication.run(DockerBootApplication.ciass,args);}
}

业务类

import java.util.UUID;/**
*@auther hippoDocker
*create 2023-02-10 17:43
*/
@RestController
public class OrderController{@Value("${server.port}")private String poft;@RequestMapping( "/order/docker")public String helloDocker(){return "hello docker"+"\t"+port+"\t"+ UUID.randomUUID().toString();}@RequestMapping(value ="/order/index" ,method = RequestMethod.GET)public String index(){return "服务端口号:"+"\t"+port+"\t"+UUID.randomUUID( ).toString();}
}

2.3.2、通过dockerfile发布微服务部署到docker容器

①IDEA工具里面搞定微服务jar包

通过maven将项目打包(package)成jar包docker_boot-0.0.1-SNAPSHOT.jar

②编写Dockerfile

# 基础镜像使用java
FROM java:8
# 作者邮箱
MAINTAINER hippodocker# VOLUME指定零时文件目录为`/temp`,在主机`/var/lib/docker`目录下创建一个临时文件并连接到容器的`/tmp`
VOLUME /tmp
# 将jar包添加到容器并更名为`hippodocker_docker.jar`
ADD docker_boot-0.0.1-SNAPSHOT.jar hippodocker_docker.jar
# 运行jar包
RUN bash -c `touch /hippodocker_docker.jar`
ENTRYPOINT ["java","-jar","/hippodocker_docker.jar"]
#暴露6001端口作为微服务
EXPOSE 6001

将微服务jar包和Dockerfile文件上传到同一个目录下/myfile

③构建镜像

# 构建镜像
docker build -t hippodocker_docker:1.6# 查看新构建的镜像
docker images

④运行容器

# 后台启动微服务镜像
docker run -d -p 6001:6001 hippodocker_docker:1.6# 如果启动发现防火墙端口未开,可以关闭防火墙再启动
systemctl stop firewalld
systemctl restart firewalld

⑤访问测试

# 通过`curl`访问测试
curl 127.0.0.1:6001/order/docker
curl 127.0.0.1:6001/order/index

2.4、Docker网络

2.4.1、是什么

docker不启动,默认网络情况

# 查看网络情况
ifconfigens33:宿主机网络(虚拟机的网络)
lo:本地回环链路(127.0.0.1)
virbr0:虚拟网桥(很少用)

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

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

docker启动后,网络情况

# 查看网络情况(多一个`docker0`网络)
ifconfigdocker0:虚拟网桥(docker中容器与容器之间通信的网络)
ens33:宿主机网络(虚拟机的网络)
lo:本地回环链路(127.0.0.1)
virbr0:虚拟网桥(很少用)# 查看docker容器网络
docker networt lsdocker默认创建3大网络模式:
bridge
host
none

2.4.2、常用基本命令

# 查看网络列表
docker network ls# 创建一个网络(默认网桥模式`bridge`)
docker network create [网络名称]# 删除所有网络
docker networt prune# 删除一个或多个网络
docker network rm [网络名称]# 查看网络数据源
docker network inspect [网络名称]

2.4.3、能干嘛

容器间的互联和通信以及端口映射。
容器lp变动时候可以通过服务名直接网络通信而不受到影响。

2.4.4、网络模式

总体介绍:

网络模式简介
bridge为每一个容器分配、设置IP等,并将容器连接到一个docker0
虚拟网桥,默认为该模式。
host容器将不会虚拟出自己的网卡,配置自己的IP等,而是使用宿主机的IP和端口。
none容器有独立的Network namespace,但并没有对其进行任何网络设置,如分配veth pair和网桥连接,IP等。
container新创建的容器不会创建自己的网卡和配置自己的lP、而是和—个指定的容器共享IP、端口范闱等。

bridge模式:使用--network bridge指定,默认使用docker0
host模式:使用--network host指定
none模式:使用--network none指定
container模式:使用--network container:NAME或者容器ID指定

容器实例内默认网络IP生产规则

说明:
1、先启动两个upuntu容器实例 docker run -it --name u1 ubuntu bash docker run -it --name u2 ubuntu bash
2、docker inspect容器ID or容器名字。
3、关闭u2实例,新建u3,查看ip变化。

结论:
docker容器内部的ip是有可能会发生改变的。

2.4.4.1、bridge

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

# 查看bridge网络的详细信息,并通过grep获取名称项
docker network inspect bridge | grep name

说明:
1、Docker使用Linux桥接,在宿主机虚拟一个Docker容器网桥(docker0),Docker启动一个容器时会根据Docker网桥的网段分配给容器一个IP地址,称为Container-IP,同时Docker网桥是每个容器的默认网关。因为在同一宿主机内的容器都接入同一个网桥,这样容器之间就能够通过容器的Container-IP直接通信。
2、docker run 的时候,没有指定network的话默认使用的网桥模式就是bridge,使用的就是docker0。在宿主机ifconfg,就可以看到docker0和自己creater的network(后面讲)eth0, eth1,eth2……代表网卡一,网卡二,网卡三…… 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,此时两个容器的网络是互通的。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KwDWacx1-1676019262326)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230210155426746.png)]

案例

# 启动两个tomcat容器 
docker run -d -p 8081:8080 --name tomcat81 hippodocker/tomcat8-jdk8
docker run -d -p 8082:8080 --name tomcat82 hippodocker/tomcat8-jdk8# 查看宿主机所有网络接口
ip addr# 进入容器查看网络接口
docker exec -it tomcat81 /bin/bash
ip addrdocker exec -it tomcat81 /bin/bash
ip addr

网络两两匹配

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GMeqqQpd-1676019262326)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230210163329935.png)]

2.4.4.2、host

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

说明
容器将不会获得一个独立的Network Namespace,而是和宿主机共用一个Network Namespace。容器将不会虚拟出自己的网卡而是使用宿主机的IP和端口
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zmxQVvOi-1676019262326)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230210163837957.png)]

案例

# 启动一个tomcat容器 (``--network host`:网络主机模式)
docker run -d -p 8083:8080 --network host --name tomcat83 hippodocker/tomcat8-jdk8问题:
docke启动时总是遇见标题中的警告原因:
docker启动时指定--network=host或-net=host,如果还指定了-p映射端口,那这个时候就会有此警告,并且通过-p设置的参数将不会起到任何作用,端口号会以主机端口号为主,重复时则递增。
解决:
解决的办法就是使用docker的其他网络模式,例如--network=bridge,这样就可以解决问题,或者直接无视。。。# 查看容器网络
docker inspect tomcat83 | tail -n 20

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-82pH2eMw-1676019262327)(C:\Users\LX\AppData\Roaming\Typora\typora-user-images\image-20230210164806539.png)]

没有设置-p的端口映射了,如何访问启动的tomcat83 ?
在CentOS里面用默认的火狐浏览器访问容器内的tomcat83看到访问成功,因为此时容器的IP借用主机的,所以容器共享宿主机网络IP,这样的好处是外部主机与容器可以直接通信。

2.4.4.3、none

73节

2.4.4.4、container

2.4.4.5、自定义网络

2.4.5、Docker平台架构图解

整体说明:

从其架构和运行流程来看,Docker是一个CIS模式的架构,后端是一个松耦合架构,众多模块各司其职。

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来实现具体对容器进行的操作。

整体架构:

见1.2.3.1

相关内容

热门资讯

监控摄像头接入GB28181平... 流程简介将监控摄像头的视频在网站和APP中直播,要解决的几个问题是:1&...
Windows10添加群晖磁盘... 在使用群晖NAS时,我们需要通过本地映射的方式把NAS映射成本地的一块磁盘使用。 通过...
protocol buffer... 目录 目录 什么是protocol buffer 1.protobuf 1.1安装  1.2使用...
在Word、WPS中插入AxM... 引言 我最近需要写一些文章,在排版时发现AxMath插入的公式竟然会导致行间距异常&#...
【PdgCntEditor】解... 一、问题背景 大部分的图书对应的PDF,目录中的页码并非PDF中直接索引的页码...
Fluent中创建监测点 1 概述某些仿真问题,需要创建监测点,用于获取空间定点的数据࿰...
educoder数据结构与算法...                                                   ...
MySQL下载和安装(Wind... 前言:刚换了一台电脑,里面所有东西都需要重新配置,习惯了所...
修复 爱普生 EPSON L4... L4151 L4153 L4156 L4158 L4163 L4165 L4166 L4168 L4...
MFC文件操作  MFC提供了一个文件操作的基类CFile,这个类提供了一个没有缓存的二进制格式的磁盘...