java基础巩固-宇宙第一AiYWM：为了维持生计，架构知识+分+微序幕就此拉开之Docker(Docker概念：容器、镜像、仓库)、操作命令、Docker网络、分层、K8S＜-＞Docker~整起

---

一、为什么要搞这个Docker，咱们为啥要学，盖房子？

• 咱们做开发时，肯定会经常遇到这种情况：
  • 平时开发和上线需要不同的环境，或者不同的人的环境换个电脑环境就不行了。换个机器都要重新部署环境。比如咱们需要开发环境、测试环境和生产环境，这咋办，虽然咱们在springboot中不已经学了多环境通过配置文件切换嘛，但这个用的局限性太强
    
    
• 容器的故事：
  • 有一天，我来到一片空地，想建个房子，于是我搬石头、砍木头、画图纸，一顿操作，终于把这个房子盖好了。结果，我住了一段时间，想搬到另一片空地去。这时候，按以往的办法，我只能再次搬石头、砍木头、画图纸、盖房子。然后过了一段时间，我又想搬家，所以又得再次搬石头、砍木头、画图纸、盖房子…
  • 跌落悬崖、习得神功，可以把我盖好的房子复制一份，做成“镜像”，放在我的背包里。。想搬家时，等我到了另一片空地，就用这个“镜像”，复制一套房子，摆在那边，拎包入住，而不用再次搬石头、砍木头、画图纸、盖房子。
    • 那个放在包里的“镜像”，就是Docker镜像
      • 这个Docker镜像，是一个特殊的文件系统。它除了提供容器运行时所需的程序、库、资源、配置等文件外，还包含了一些为运行时准备的一些配置参数（例如环境变量）。镜像不包含任何动态数据，其内容在构建之后也不会被改变。【也就是说，每次变出房子，房子是一样的，但生活用品之类的，都是不管的。谁住谁负责添置。】
      • 每一个镜像可以变出一种房子。那么，我可以有多个镜像呀！
      • 并且很多个人之间可以交换镜像，你用我的，我用你的
    • 我的背包，就是Docker仓库。
      • 镜像多了，房子也多了，没人管这能成，有假房假人怎么办？。负责对Docker镜像进行管理的，是Docker Registry服务（类似仓库管理员）。Docker Registry服务对镜像的管理是非常严格的。最常使用的Registry公开服务，是官方的Docker Hub，这也是默认的 Registry，并拥有大量的高质量的官方镜像。。
    • 我在空地上，用神功造好的房子，就是一个Docker容器

---

二、Docker的镜像与容器

1.预备知识：虚拟（机）、容器（化）

• 在容器技术出现之前，公司往往是通过为每个开发人员提供一台或者多台虚拟机【虚拟机可以模拟出运行需要的硬件，相当于一个完整的OS，然后在这个系统上安装和运行各种软件】来充当开发测试环境。开发测试环境一般负载较低，大量的系统资源都被浪费在虚拟机本身的进程上了。Docker容器没有任何CPU和内存上的额外开销，很适合用来提供公司内部的开发测试环境。而且由于docker镜像可以很方便的在公司内部分享，这对开发环境的规范性也有极大的帮助。
  • 传统的物理机部署安装：部署速度很慢，成本很高（VM要安装OS，占用较大），受制于硬件（JVM出现解决了一部分问题，但是JVM自己也会受到限制），难以扩展与迁移（主机迁移，Window迁到Linux？）
  • 传统虚拟机占内存等资源很多，启动运行起来很慢，所以Docker应运而生
• 容器化的优势和好处：Terence Wong老师的The Benefits of Containerization
  • 容器化技术：更快的对应用进行部署安装、多个容器共享硬件资源。
  • 容器虚拟化的是操作系统而不是硬件【与虚拟机相比， 容器占用的空间较少（容器镜像大小通常只有几十兆），瞬间就能完成启动 。】，容器之间是共享同一套操作系统资源的【Docker是内核级别的虚拟化，可以在一个物理机上运行很多的容器实例。或者换句话说，容器内的应用进程直接运行于宿主的内核，容器内没有自己的内核，而且也没有进行硬件虚拟。因此容器要比传统虚拟机更为轻便。】。
    • 虚拟机技术是虚拟出一套硬件后，在虚拟出的硬件上运行一个完整操作系统，然后再在这个完整的OS上运行所需应用进程。因此容器的隔离级别会稍低一些【Docker并没有虚拟出硬件，而是容器内的应用们直接运行在宿主机的内核上（容器是没有自己的内核的）；虚拟机 (VM) 是一个物理硬件层抽象，用于将一台服务器变成多台服务器。 管理程序允许多个 VM 在一台机器上运行。每个 VM 都包含一整套操作系统、一个或多个应用、必要的二进制文件和库资源，因此 占用大量空间 。而且 VM 启动也十分缓慢 。】
    • 容器技术不需要虚拟出整个操作系统，只需要虚拟一个小规模的环境（类似“沙箱”）。它启动时间很快，几秒钟就能完成。而且，它对资源的利用率很高（一台主机可以同时运行几千个Docker容器）。此外，它占的空间很小，虚拟机一般要几GB到几十GB的空间，而容器只需要MB级甚至KB级。
  • 容器化的好处包括以下几点：
    • 容器补充了你的 DevOps 流程
      • DevOps 完善了开发人员和客户之间的每个流程，并鼓励更快的反馈循环、实验和学习。DevOps 是一种专注于敏捷性和自动化的实践。容器化是对DevOps的补充，因为可以更快地部署和测试软件，改善反馈循环。容器化也是微服务流行的一个主要因素，微服务可以提高软件架构的灵活性和敏捷性你可以使用容器化来加快开发新功能和获取反馈的时间。改善产品的反馈循环会带来更好的产品
    • 容器是可扩展的，可以有效地分配资源
      • 平台即服务 (PaaS) 解决方案和容器编排工具（如 Kubernetes）让开发人员可以大规模地操作容器。容器编排器可以根据需求和负载向上和向下扩展软件应用程序中的各个组件。这可以节省成本，因为组件仅在需要时运行。扩展还提高了可靠性，因为 容器编排器可以为应用程序的高需求部分分配足够的资源。
    • 容器是可移植的，所以你可以构建一次并在任何地方运行
      • 由于容器是可移植的，因此它们可以在任何基础架构上的任何位置运行，例如在云中、VM 或裸机上。要运行应用程序，容器会加载容器镜像。容器镜像是一个静态文件，其中包含在 IT 基础架构上运行进程的可执行代码。有针对不同用例的容器镜像，例如数据库、Web 服务器、操作系统等。容器镜像存储库是容器镜像的公共访问点，这使得它们可供开发人员使用，他们可以使用这些镜像加载容器。如果你想让应用程序使用容器，你可以确保你使用的任何 OCI 映像都可以在你的基础架构上运行，即使你的基础架构发生了变化
    • 应用更快速的交付和部署
      • 原来的传统的方式：一堆帮助文档，照着安装程序。用Docker后：打包镜像发布测试，都是一键运行。 Docker比VM快（因为VM要虚拟化出运行需要的硬件，然后在这个硬件上去跑服务），所以容器性能开销极低。
    • 更便捷的升级和扩缩容
      • 用了Docker后，部署应用和搭积木一样。比如做负载均衡，扩展某个服务器时直接把项目带环境直接打包为一个镜像，到另外的服务器上运行即可【我们可以方便地创建和使用容器，把自己的应用放入容器。容器还可以进行版本管理、复制、分享、修改，就像管理普通的代码一样。】
      • 轻量 : 在一台机器上运行的多个 Docker 容器可以共享这台机器的操作系统内核；它们能够迅速启动，只需占用很少的计算和内存资源。镜像是通过文件系统层进行构造的，并共享一些公共文件。这样就能尽量降低磁盘用量，并能更快地下载镜像。
    • 更简单的系统运维
      • 不会出现这个在我电脑上能用，在别的电脑上就用不了了【 容器化软件 Docker 容器基于开放式标准，能够在所有主流 Linux 版本、Microsoft Windows 以及包括 VM、裸机服务器和云在内的任何基础设施上运行。在任何环境中都能够始终如一地运行【Docker 的镜像提供了除内核外完整的运行时环境，确保了应用运行环境一致性，从而不会再出现 “这段代码在我机器上没问题啊” 这类问题；】。有没有想起来咱们的Java的跨平台特性呀。容器赋予了软件独立性，使其免受外在环境差异（例如，开发和预演环境的差异）的影响，从而有助于减少团队间在相同基础设施上运行不同软件时的冲突。】
      • 可以很轻易的将在一个平台上运行的应用，迁移到另一个平台上，而不用担心运行环境的变化导致应用无法正常运行的情况。迁移方便
      • 新建一个容器或者说启动这个容器的时候 , docker不需要像虚拟机一样重新加载一个操作系统内核 ,避免引导。虚拟机是加载GuestOS ,分钟级别的,而docker是利用宿主机的操作系统吗,省略了这个复杂的过程,秒级!【可以做到秒级、甚至毫秒级的启动时间。大大的节约了开发、测试、部署的时间。】
    • 更高效的计算资源利用
      • 善于处理集中爆发的服务器使用压力；弹性伸缩，快速扩展
• 虚拟机与Docker容器两者可以和谐共存。虚拟机更擅长于彻底隔离整个运行环境。例如，云服务提供商通常采用虚拟机技术隔离不同的用户。而 Docker 通常用于隔离不同的应用 ，例如前端，后端以及数据库。
  
  • 两者比较：
    
    • 虚拟机和Docker都属于虚拟化技术【将计算机的各种[实体资源如CPU、内存、磁盘空间、网络适配器进行抽象为不同的形式或者大小，然后用户可以比原本的配置更好的方式来应用这些电脑硬件资源。这些资源的新虚拟部分是不受现有资源的架设方式，地域或物理配置所限制。一般所指的虚拟化资源包括计算能力和数据存储】

2.Docker、镜像、容器

• Docker：【Docker官网】
  • Docker 是在Linux 容器里运行应用的、创建容器的、开源工具，是一种轻量级的“虚拟机”。Docker也是一个开源的应用容器引擎【Docker本身并不是容器，它是工具，是开源的应用容器引擎】。【Docker:提供了标准的应用打包方式，是一个容器化的平台】
    • 世界领先的软件容器平台【Docker 使用 Google 公司推出的 Go 语言 进行开发实现，基于 Linux 内核 提供的 CGroup 功能和 namespace 来实现的，以及 AUFS 类的 UnionFS 等技术，使用沙箱机制对进程进行封装隔离，属于操作系统层面的虚拟化技术。 由于隔离的进程独立于宿主和其它的隔离的进程，因此也称其为容器】
    • Docker核心：隔离，不同的集装箱，不同的镜像放在不同的容器中
      • Docker对进程进行封装隔离，属于操作系统层面的虚拟化技术。 由于隔离的进程独立于宿主和其它的隔离的进程，因此也称其为容器。【每个容器间是相互隔离的，每个容器都有自己的一个专属于自己的文件系统】
      • Docker 赋予应用的隔离性不仅限于进程或者容器之间彼此隔离，还独立于底层的基础设施。Docker 默认提供最强的隔离，因此 应用出现问题，也只是单个容器的问题，而不会波及到整台机器。
  • Docker 技术是基于 LXC（Linux container- Linux 容器）虚拟容器技术的。一种操作系统层虚拟化（Operating system–level virtualization）技术，为 Linux 内核容器功能的一个用户空间接口。它将应用软件系统打包成一个软件容器（Container），内含应用软件本身的代码，以及所需要的操作系统核心和库。通过统一的名字空间和共用 API 来分配不同软件容器的可用硬件资源，创造出应用程序的独立沙箱运行环境，使得 Linux 用户可以容易的创建和管理系统或应用容器。LXC 技术主要是借助 Linux 内核中提供的 CGroup 功能和 namespace 来实现的，通过 LXC 可以为软件提供一个独立的操作系统运行环境。
    
    
    • LXC 技术主要是借助 Linux 内核中提供的 CGroup 功能和 namespace 来实现的：namespace
      
    • LXC 技术主要是借助 Linux 内核中提供的 CGroup 功能和 namespace 来实现的:CGroup
      
    • 2010年，几个搞IT的年轻人，在美国旧金山成立了一家名叫“dotCloud”的公司。这家公司主要提供基于PaaS的云计算技术服务。具体来说，是和LXC有关的容器技术。后来，dotCloud公司将自己的容器技术进行了简化和标准化，并命名为——Docker。Docker和容器技术为什么会这么火爆？说白了，就是因为它“轻”。
  • Docker架构：
    
    • Docker 运行过程也就是去仓库把镜像拉到本地，然后用一条命令把镜像运行起来变成容器。所以，我们也常常将 Docker 称为码头工人或码头装卸工，这和 Docker 的中文翻译搬运工人如出一辙。
      
    • 容器的生命周期：四个圆圈内的生命周期：stopped【created、Exited】、running【Up】、Paused、deleted【看不见，删了就没了，看不见这个状态名字】
      
    • docker是怎么工作的：
      
      
      
      
    • 我想安装一个xxx，那么我从client发一个docker pull xxx给docker daemon，docker daemon接收到docker pull xxx之后，先在Docker_Host本机内寻找有没有xxx镜像，有，直接docker run xxx实例化出容器并运行。没有就去远程仓库拉来镜像然后实例化出容器
    • Docker是一个C-S结构的系统，Docker的守护进程运行在主机上，客户端通过Socket访问Docker，当DockerServer接收到Docker-Client的指令就会执行这个命令
  • 如果要把容器作为开发机使用，需要解决的是远程登录容器和容器内进程管理问题。
  • Docker可以实现，项目的代码（的jar包或者war包）带上项目运行所需要的环境，一起打个包到一个轻量级、可移植的容器中，然后发布到任何流行的Linux机器上，这个打出来的比较齐全的包叫做镜像【容器镜像是轻量的、可执行的独立软件包 ，包含软件运行所需的所有内容：代码、运行时环境、系统工具、系统库和设置。】
• 镜像
  
  • 镜像（image）：（镜像本质上是一个分层的、静态文件、构建完之后只读的文件系统。镜像是一种轻量级、可执行的独立软件包,用来打包软件运行环境和基于运行环境开发的软件,它包含运行某个软件所需的所有内容,包括代码、运行时、库、环境变量和配置文件。所有的应用,直接打包docker镜像,就可以直接跑起来!）docker镜像就相当于一个模板（咱们Java中的全局唯一的Class模板），可以通过这个镜像模板来创建容器服务（或者说通过这个镜像可以创建多个容器），最终服务运行或者说项目运行就是在容器中的。本质上那些按照镜像创建出来的多个容器都是通过镜像来进行运行的。
    • 买一台电脑，人家卖家给咱送的碟片，不就相当于人家送给咱们一个装着OS镜像的片子嘛
  • 镜像(Image) : Docker 镜像(Image) ,就相当于是一个root文件系统【除了提供容器运行时所需的程序、库、资源、配置等文件外，还包含了一些为运行时准备的一些配置参数（如匿名卷、环境变量、用户等）。 镜像不包含任何动态数据，其内容在构建之后也不会被改变。】【操作系统分为内核和用户空间。对于 Linux 而言，内核启动后，会挂载 root 文件系统为其提供用户空间支持。而 Docker 镜像（Image），就相当于是一个 root 文件系统。】。比如官方镜像ubuntu:16.04就包含了完整的一套Ubuntu16.04最小系统的root文件系统。
    • 最底层的那一层是Linux系统【尺寸很小】。所以说明，每个由镜像创建出来的容器都可以算是一个小的Linux系统，所以才有了下面的docker exec -it…这个命令。
      
      • 比如mysql的
        
        
  • 有了镜像才可以创建容器
    
    
  • 如何得到镜像:
    • 从远程仓库下载、朋友拷贝给你
    • 自己制作一个镜像,有两种方法：【镜像不能传输，但是可以将镜像转成为压缩文件：docker save -o 压缩文件名称 镜像名称:版本号;压缩文件还原为镜像：docker load -i 压缩文件名称】
      • 方式一：docker commit 容器id 镜像名称:版本号
      • 方式二【常用DockerFile】：使用DockerFile构建或者说制作镜像，将镜像中的服务打包
  • Docker镜像加载原理：UnionFS (联合文件系统)。我们下载的时候看到界面上显示的一层层就是这个UnionFS (联合文件系统)!
    
    
    • Linux文件系统由bootfs和rootfs两部分组成
      
      • bootfs:包含bootloader (弓|导加载程序)和kernel (内核)
      • rootfs: rnot文件系统， 包含的就是典型Linux系统中的/dev,/proc, /bin, /etc等标准目录和文件
        • 不同的linux发行版，bootfs基本一样,而rootfs不同，如ubuntu、centos等
      • Linux上可用的存储引擎有AUFS、Overlay2、 Device Mapper、Btrfs 以及ZFS。顾名思义,每种存储引擎都基于Linux 中对应的文件系统或者块设备技术,并且每种存储引擎都有其独有的性能特点。
        • Docker在Windows上仅支持windowsfilter 一种存储引擎,该引擎基于NTFS文件系统之上实现了分层和CoW[1]。
    • UnionFS (联合文件系统) : Union文件系统( UnionFS)是一种分层、 轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加 ，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。Union 文件系统是Docker镜像的基础。镜像可以通过分层来进行继承，基于基础镜像(没有父镜像)，可以制作各种具体的应用镜像。【分层存储的特征还使得镜像的复用、定制变的更为容易。甚至可以用之前构建好的镜像作为基础层，然后进一步添加新的层，以定制自己所需的内容，构建新的镜像】
      
      • 镜像构建时，会一层层构建，前一层是后一层的基础。每一层构建完就不会再发生改变，后一层上的任何改变只发生在自己这一层。 比如，删除前一层文件的操作，实际不是真的删除前一层的文件，而是仅在当前层标记为该文件已删除。在最终容器运行的时候，虽然不会看到这个文件，但是实际上该文件会一直跟随镜像。因此，在构建镜像的时候，需要额外小心，每一层尽量只包含该层需要添加的东西，任何额外的东西应该在该层构建结束前清理掉。
      • 一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统,联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录
        • 这种情况下，上层镜像层中的文件覆盖了底层镜像层中的文件。这样就使得文件的更新版本作为一个新镜像层添加到镜像当中。Docker通过存储引擎(新版本采用快照机制)的方式来实现镜像层堆栈,并保证多镜像层对外展示为统一的文件系统。
          
      • 所有的Docker镜像都起始于一个基础镜像层 ,当进行修改或增加新的内容时,就会在当前镜像层之上,创建新的镜像层。
        
        • 在添加额外的镜像层时，镜像始终保持是当前所有镜像的组合
          
      • 并且，Docker镜像都是只读的,当容器启动时, 一个新的可写层被加载到镜像的顶部!。这一层就是我们通常说的容器层,容器之下的都叫镜像层!
        
        • 比如，拉取了tomcat的镜像之后。
          
    • 说明镜像是分层的：
      
      • 镜像为什么要分层呢：
        
      • 分层了之后，底层的东西我上层的就可以共享，就可以节省资源
        
• 容器
  • 啥叫个容器,桶?缸?,咱们平时生活中接触的不就是这些存放东西的地方嘛。再专业一点，咱们玩的Docker就是将软件【项目的代码（的jar包或者war包）带上项目运行所需要的环境】打包成为标准化单元并用于开发、交付和部署。【我们现在所说的容器存放的东西可能更偏向于应用比如网站、程序甚至是系统环境。】容器是一个轻量级、可移植的计算环境，具有独立运行所需的所有必要文件。容器化是使应用程序可作为容器运行的过程。容器就是镜像运行起来提供服务器的东西
    • 一旦应用程序可以作为容器运行，无论用于执行容器的基础设施如何，它都会以相同的方式运行。容器加载了在容器内运行特定应用程序的容器镜像。你将需要容器化来构建现代应用程序，从设置数据库到加载不同的操作系统以访问深度学习平台。
    • 容器的实质是进程，但与直接在宿主执行的进程不同，容器进程运行于属于自己的独立的 命名空间。镜像使用的是分层存储，容器也是分层存储。【容器存储层的生存周期和容器一样，容器消亡时，容器存储层也随之消亡。因此，任何保存于容器存储层的信息都会随容器删除而丢失。】
  • 容器就是将软件打包成标准化单元，以用于开发、交付和部署。标准化三个字体现在下面几点：
    • 容器镜像是轻量的、可执行的独立软件包 ，包含软件运行所需的所有内容：代码、运行时环境、系统工具、系统库和设置。
      • Docker利用容器技术，独立运行一个或者一组应用【镜像（Image）和容器（Container）的关系，就像是面向对象程序设计中的 类 和 实例 一样，镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等 。】。其实就可以把容器看作是一个简易的linux系统
    • 容器化软件适用于基于 Linux 和 Windows 的应用，在任何环境中都能够始终如一地运行
    • 容器赋予了软件独立性，使其免受外在环境差异（例如，开发和预演环境的差异）的影响，从而有助于减少团队间在相同基础设施上运行不同软件时的冲突。
      • Docker 能够自动执行重复性任务，例如搭建和配置开发环境，从而解放了开发人员以便他们专注在真正重要的事情上：构建杰出的软件。用户可以方便地创建和使用容器，把自己的应用放入容器。容器还可以进行版本管理、复制、分享、修改，就像管理普通的代码一样。

3.容器数据卷

• 之前咱们用docker，是想要把项目的应用和环境打包成为一个镜像，但是存在一个问题，就是咱们的数据此时如果都在容器中，如果咱们删除容器数据就跟着一块没了。所以需要数据持久化到本地，所以容器之间可以有一个数据共享的技术可以将Docker容器中产生的数据同步到本地，这就是卷技术，来实现目录的挂载，将我们容器内的目录挂载到Linux上面
  
  • 按照 Docker 最佳实践的要求，容器不应该向其存储层内写入任何数据 ，容器存储层要保持无状态化。所有的文件写入操作，都应该使用数据卷（Volume）、或者绑定宿主目录，在这些位置的读写会跳过容器存储层，直接对宿主(或网络存储)发生读写，其性能和稳定性更高。数据卷的生存周期独立于容器，容器消亡，数据卷不会消亡。因此， 使用数据卷后，容器可以随意删除、重新 run ，数据却不会丢失。
    
• （数据卷就是宿主机中的一个目录或文件，没个啥，只是这个得跟容器的目录或者文件来通过-v参数进行映射，来实现容器内数据的持久化和同步操作，容器之间可以数据共享）
• 数据卷的三个作用：
  • 容器数据的持久化
    • 但是如果一旦持久化到了本地，此时本地的数据是不会删除的
      
  • 外部机器和容器间通信
    • 一个容器也可以被挂载多个数据卷
    • 一个数据卷目录，可以被多个容器同时挂载：
      • 这样一来，不仅防止了各个容器删除时产生的数据持久化问题
      • 也解决了容器之间想要交互，就可以通过共同挂载的这个数据卷目录进行交互
      • 当容器目录和数据卷目录绑定后，对方的修改会立即同步
  • 容器之间数据交换【容器之间配置信息的传递，数据卷容器的生命周期一直持续到没有容器使用为止（没有子类了，子类就是挂载在父类身上的）。你这个子类被杀掉了，其他子类的数据还是有的（因为本质上，其实都是从父类拷贝来的副本，而已，只要父类一直在，就可以）】
    
    
    • 方式一：多个容器挂载同一个数据卷【直接使用命令来挂载 docker run -it -v 主机目录： 容器内目录】
      
      
      • 适用于要挂载的容器比较少：docker run --name 容器名demo -v 宿主机路径：容器内挂载路径 镜像名称 写法比较麻烦
      • 好处就是，以后不用去容器内修改，可以在本地修改之后，容器内会自动同步
      • 比如：安装MySQL:【MySQL数据持久化问题：容器删掉，挂载到本地的数据卷（数据）还在，相当于实现了数据持久化】
        
    • 方式二：数据卷容器：–volumn-from相当于extends,继承的意思【创建一个容器, 挂载一个目录，让其他容器继承自该容器( --volume-from)。】
      • 【适用于要挂载的容器比较多】第一步创建共享容器，用-v定义好挂载点：docker create --name 共享容器名 -v 宿主机路径：容器内挂载路径 镜像名称 /bin/true；第二步共享容器挂载点，也就是用这个挂载点去挂载想要白嫖或者共享这个共享容器（内东西）的容器们：docker run --volumn-from 共享容器名 --name 容器名demo -d 镜像名称【之后想修改挂载点，就去修改共享容器内的挂载路径就行，其实这玩意跟配置中心是一个道理】
• 具名挂载和匿名挂载（常用）:
  • 匿名挂载:就是懒，不起名字
    
  • 具名挂载：我们通过名挂载可以方便的找到我们的一个卷,大多数情况在使用的‘具名挂载
    

4.仓库（repository）

• 仓库就是存放镜像的地方，仓库分为公有仓库和私有仓库
  • 镜像构建完成后，可以很容易的在当前宿主上运行，但是， 如果需要在其它服务器上使用这个镜像，我们就需要一个集中的存储、分发镜像的服务，Docker Registry 就是这样的服务。一个 Docker Registry 中可以包含多个仓库（Repository）；每个仓库可以包含多个标签（Tag）；每个标签对应一个镜像。所以说：镜像仓库是 Docker 用来集中存放镜像文件的地方类似于我们之前常用的代码仓库【通常，一个仓库会包含同一个软件不同版本的镜像，而标签就常用于对应该软件的各个版本 。我们可以通过<仓库名>:<标签>的格式来指定具体是这个软件哪个版本的镜像。如果不给出标签，将以 latest 作为默认标签.。】。

5.Docker网络

• 你拉一个tomcat镜像并实例化出容器，此时是不能直接访问8080的。需要做 端口映射【中间通过docker-proxy完成，你可以netstat -tulpn】。相当于把宿主机开放的映射端口XXX当一个中介来顶替8080。原来http://localhost:8080就变成了http://localhost:XXX
  • 端口映射命令：docker run -p 6666:8080 ：把宿主机开放的映射端口6666当一个中介来顶替8080，http://localhost:8080就变成了http://localhost:6666
• 我们每安装一个或者说每启动一个docker容器,docker就会给docker容器分配一个ip，并且我们只要安装了docker，就会有一个网卡
  
  • 容器产生的或者说带来的网卡都是一对一对的，比如在host模式下：
    • Docker 使用了Linux 的Namespace 技术来进行资源隔离，如PID Namespace隔离进程，Mount Namespace隔离文件系统，Network Namespace 隔离网络等。
    • 一个Docker 容器一般会分配一个独立的Network Namespace。一个Network Namespace 提供了一份独立的网络环境，包括网卡，路由，iptable 规则等都与其他Network Namespace 隔离。
  • Docker中的所有网络接口都是虚拟的，因为虚拟的转发效率高
• Docker网络模式有哪些？
  • host模式：使用 --net=host 指定，相当于VMware 中的桥接模式，与宿主机在同一个网络中，但是没有独立IP地址。如果启动容器的时候使用host 模式，那么这个容器将不会获得一个独立的Network Namespace ，而是和宿主机共用一个Network Namespace 。容器将不会虚拟出自己的网卡，配置自己的IP等，而是使用宿主机的IP和端口.此时容器不再拥有隔离的、独立的网络栈。不拥有所有端口资源
    
    • Docker 使用了Linux 的Namespace 技术来进行资源隔离，如PID Namespace隔离进程，Mount Namespace隔离文件系统，Network Namespace 隔离网络等。
    • 一个Docker 容器一般会分配一个独立的Network Namespace。一个Network Namespace 提供了一份独立的网络环境，包括网卡，路由，iptable 规则等都与其他Network Namespace 隔离。
  • container模式：使用–net=contatiner:NAME_or_ID 指定，这个container模式指定新创建的容器和已经存在的一个容器共享一个Network Namespace，而不是和宿主机共享。新创建的容器不会创建自己的网卡，配置自己的IP，而是和一个指定的容器共享IP，端口范围等 。可以在一定程度上节省网络资源，容器内部依然不会拥有所有端口。
    
    • 同样，两个容器除了网络方面，其他的如文件系统，进程列表等还是隔离的。两个容器的进程可以通过lo网卡设备通信
  • none模式:使用 --net=none指定。使用none 模式，docker 容器有自己的network Namespace ，但是并不为Docker 容器进行任何网络配置。也就是说，这个Docker 容器没有网卡，ip， 路由等信息。这种网络模式下，容器只有lo 回环网络，没有其他网卡。该容器将完全独立于网络，用户可以根据需要为容器添加网卡。此模式拥有所有端口。（none网络模式配置网络）特殊情况下才会用到，一般不用
    • 这种类型没有办法联网，但是封闭的网络能很好的保证容器的安全性。
  • bridge 模式：相当于Vmware中的 nat 模式，容器使用独立network Namespace，并连接到docker0虚拟网卡。通过docker0网桥以及iptables nat表配置与宿主机通信，此模式会为每一个容器分配Network Namespace、设置IP等，并将一个主机上的 Docker 容器连接到一个虚拟网桥上。
    
    • 当Docker进程启动时，会在主机上创建一个名为docker0的虚拟网桥，此主机上启动的Docker容器会连接到这个虚拟网桥上。虚拟网桥的工作方式和物理交换机类似，这样主机上的所有容器就通过交换机连在了一个二层网络中。从docker0子网中分配一个IP给容器使用，并设置docker0的IP地址为容器的默认网关。
      • Docker0（桥接模式：使用的技术是evth-pair技术，evth-pair就是一对虚拟设备接口，都是成对出现的，一段连着协议，一段彼此相连。所以正因为这个特性，evth-pair通常用来充当一个桥梁，连接各种虚拟网络设备）
        • Docker使用的是Linux的桥接模式，宿主机中是一个Docker容器的网桥Docker0，所有的东西都会经过这个Docker0,只要你启动一个容器，不指定网络时就会给咱们分配到Docker0这里
        • 容器和容器之间是可以ping通的。所有的容器不指定网络的情况下都是docker0来帮忙进行路由（中转的）转发的，docker会给我们的容器分配一个默认的可用IP
    • 在主机上创建一对虚拟网卡veth pair设备。veth设备总是成对出现的，它们组成了一个数据的通道，数据从一个设备进入，就会从另一个设备出来。因此，veth设备常用来连接两个网络设备。
      • Docker将veth pair 设备的一端放在新创建的容器中，并命名为eth0（容器的网卡），另一端放在主机中， 以veth*这样类似的名字命名，并将这个网络设备加入到docker0网桥中。可以通过 brctl show 命令查看。容器之间通过veth pair进行访问。使用 docker run -p 时，docker实际是在iptables做了DNAT规则，实现端口转发功能。可以使用iptables -t nat -vnL 查看。
    • 网络连通问题：一个容器两个ip地址。
      
      
      • 因为docker0有缺陷，所以可以使用“--link”以及自定义网络来解决docker0的缺点，但是–link用起来不方便，所以用自定义网络，自定义的网络docker都已经帮我们维护好了对应的关系，很方便
        
        • –link就是我们在hosts配置中增加了一个hosts映射
          
        • 比如，创建一个名字叫my-bridge-demo网桥：docker network create -d bridge my-bridge-demo，
          • 将网桥my-bridge-demo分别和我想要连接上的俩主角连起来，不就相当于俩主角连接起来了嘛：docker network connect my-bridge-demo 主角A；docker cetwork connect my-bridge-demo 主角B；这里的主角A和主角B都代表的是两个主角容器的容器名称哦
        • 可以你link我，我link你，就可以双向通信了，但这也太麻烦了，得用Bridge网桥实现双向通信了【网桥另一个作用就是在网络角度对容器进行分组】
      • 通过–link可以解决网络联通问题：不咋使用了，因为这个–link不适用docker0，docker0问题（–link不支持容器名连接访问）
        • 通过自定义网络：我们自定义的网络docker都已经帮我们维护好了对应的关系,推荐我们平时这样使用网络!
          
          • 创建自定义网络
            
          • 创建自定义网络好处:
            • redis -不同的集群使用不同的网络,保证集群是安全和健康的
            • mysql -不同的集群使用不同的网络,保证集群是安全和健康的

6.Docker 主要组成项目（还有其他项目，但这些是主要的）

• Docker 是管理容器的最流行的工具，Docker创造了一个很好用的工具来处理容器也叫 Docker【Docker 可以轻松地构建容器镜像，从 Docker Hub 中拉取镜像，创建、启动和管理容器。实际上，当你用 Docker 运行一个容器时实际上是通过 Docker 守护程序、containerd 和 runc 来运行它。】
  
  • docker-cli：这是一个命令行工具，它是用来完成 docker pull，build, run, exec 等命令进行交互
  • containerd：这是一个 管理和运行容器的守护进程。它推送和拉动镜像，管理存储和网络，并监督容器的运行
    
  • runc：这是低级别的容器运行时间（实际创建和运行容器的东西）。它包括 libcontainer，一个用于创建容器的基于 Go 的本地实现。
    
• 目前的容器工具中，Docker 只是其中之一，其他著名的容器工具还包括：
  • Podman
  • LXC
  • containerd
  • Buildah

三、Docker实践：容器、镜像相关命令

• Docker常用命令:查询官方文档https://docs.docker.com/reference/或者docker 命令 --help【Docker常用操作记录：记得常翻菜鸟或者官方文档】

  docker version //显示docker的版本信息,安装好docker，用docker version查看
  docker info   //显示docker的系统信息，包括镜像和容器的数量
  docker 命令 --help
  docker images  //查询所有本机的主机上的镜像
  	REPOSITORY:镜像的仓库源
  	TAG:镜像的标签
  	IMAGE ID:镜像的id
  	CREATED:镜像的创建时间
  	SIZE:镜像的大小
  

1.Docker安装

• 看看我机子上的Docker的安装情况：
  
  • 安装之前卸载前面安装的版本，或者初始化一下阿里云
    
  • 镜像加速器：
    
  • 安装好后，可以docker pull hello-world，docker run hello-world。docker pull hello-world中的docker就是由client提供的api【Docker是基于C/S的，client和server可以不用安装到一台服务器上】
    

2.Docker：容器、镜像常用命令

• 镜像相关操作命令：hub.docker.com上多查查有没有这个版本号
  • docker images //查询所有本机的主机上的镜像【docker image -q:查看所有镜像id,用于删除所有镜像】
    
    • REPOSITORY:镜像的仓库源
    • TAG:镜像的标签
    • IMAGE ID:镜像的id
    • CREATED:镜像的创建时间
    • SIZE:镜像的大小
  • docker search xxx:和咱在docker hub上搜索是一样的：【从网络中搜索需要的镜像:docker search xxx】
    
    • Docker Hub提供了一个流行的容器镜像列表。一些顶级容器镜像是：
      
  • docker pull 下载镜像：docker pull xxx:tag :从远程仓库拉去xxx这个镜像。不加:tag标记那么拉取的就是latest
    
    • 拉取镜像:从Docker仓库下载镜像到本地，镜像名称格式为名称:版本号,如果版本号不指定则是最新的版本。如果不知道镜像版本可以docker hub搜索对应镜像查看
    • 指定版本下载时需要先查好，你指定的这个版本能不能用
      
      • tag去hub.docker上找去
      • latest代表使用最多的版本，而不是按照时间排序的
  • 删除镜像：docker rmi -f 容器id
    
    • docker rmi <-f> 镜像名:tag。-f就像按下电源键强行关机一样
    • 删除指定id的本地镜像:docker rmi IMAGE_ID
    • docker rmi docker images -q # 删除所有本地镜像
  • commit镜像：保存当前容器的状态，通过commit提交，获得一个镜像；相当于咱们VM时的快照
    
• 容器相关命令：
  • docker create：只创建容器，但不运行
  • 新建容器并启动
    
    
    • 启动和停止容器
      
    • 启动docker服务：systemctl start docker
    • 停止docker服务:systemctl stop docker
    • 重启docker服务:systemctl restart docker
    • 查看docker服务状态:systemctl status docker
    • 开机启动docker服务:systemctl enable docker
    • uname -r查一下系统内核：3.10.0-693.2.2.el7.x86_64
      
    • cat /etc/os-release查一下系统版本：
      
    • 创建并启动容器：docker run 参数：【一个Docker镜像，咱们是通过run命令将镜像变成一个容器】
      • 当利用 docker run 来创建容器时， Docker 在后台的标准运行过程是：
        
        
  • 进入正在运行的容器:docker exec [-it] 容器id 命令。eg:docker exec -it 07abshcbcns /bin/bash
    
    • exec表示在对应容器中执行命令
    • -it表示采用交互方式执行命令
    • exit退出此时的容器内置linux系统【docker所有的镜像和容器都存储在/var/lib/docker目录下。无特殊需要别改这个目录】
  • docker ps:查看正在运行的镜像
    
  • 退出容器：
    
  • 删除容器
    • docker rm <-f> 容器id:删除对应容器id的容器，-f代表强制删除
    • docker rm -f 镜像id，-f就像按下电源键强行关机一样
      
  • 查看日志
    
  • 查看进程信息
    
  • 查看镜像元数据：docker inspect 容器id【docker inspect 容器id：查询对应容器的元数据，IP地址等】
    
    

3.Docker安装常见的东西：mysql、redis、nginx

• Docker安装MySQL
  
• Tomcat
  
• Redis:
  
• Nginx:在Docker容器中部署Nginx,并通过外部机器访问Nginx.
  • 实现步骤：
    • 搜索Nginx镜像
    • 拉取Nginx镜像
      
    • 创建容器
      
    • 测试访问
      

四、DockerFile

• Dockerfile是一个包含了很多用来组合镜像的命令的文本文档，Docker通过读取Dockerfile中的组合镜像的命令按部就班的自动生成镜像。
  • Dockerfile就是用来构建docker镜像的构建文件，也就是一个命令脚本。通过这个脚本可以生成镜像（镜像是一层一层的，脚本是一个个的命令，每个命令都是一层）
  • DockerFile构建文件的常用指令：Docker Hub中99%镜像都是从这个基础镜像过来的FROM scratch ,然后配置需要的软件和配置来进行的构建
    

    FROM        #基础镜镜像，一切从这里开始构建
    MAINTAINER  #镜像是谁写的，姓名+邮箱
    RUN         #镜像构建时需要运行的命令
    ADD         #步骤: tomcat镜像，这个tomcat压缩包! 添加内容
    WORKDIR     #镜像的工作目录
    VOLUME      #挂载的目录
    EXPOST      #保留端口配置
    CMD         #指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代
    ENTRYPOINT  #指定这个容器启动的时候要运行的命令，可以追加命令
    ONBUILD    #当构建一个被继承DockerFile 这个时候就会运行ONBUILD 的指令。触发指令。
    COPY       #类似ADD，将我们文件拷贝到镜像中
    ENV        #构建的时候设置环境变量!
    

    • FROM tomcat:latest ：设置基准镜像，从哪来，从哪个镜像之上进行扩展呢？
      • 每个镜像通过dockerfile构建时都会涉及dockerfile的这几个内置命令，每一个内置命令运行时都会产生一个临时容器，这个临时容器是可以被复用的【构建镜像1的过程中由于会执行dockerfile的内置命令产生了ABC三个临时容器，要是别人构建自己的镜像时也会用到AB临时容器，就会显示Using cache...，那不就方便的很了嘛】，复用的原因就是Docker的镜像分层，内置命令执行一步就相当于汉堡包加上一层。
      • FROM scratch:从0开始构建，不依赖于任何基准镜像
      • 尽量使用官方提供的基准镜像，然后在这个基础上扩展出自己想要的镜像，别的野路子来的谁知道有没有病毒
    • MAINTAINER xxx :由xxx来维护这个镜像，说明性的信息，没啥实际用处
      • LABEL version = “…” 说明性的信息，没啥实际用处，就跟代码注释一样
    • WORKDIR /XX/XX/… :切换工作目录，意思就是以后咱们就在这个目录下面玩耍
      • 如果当前目录不存在，WORKDIR会自动创建
      • 尽量使用绝对路径
    • ADD xxx yyyy :将指定的目录xxx中所有文件复制到镜像目录yyyy下
      • ADD 可以替换为COPY；ADD还可以解压缩
    • ENV ，设置环境常量：ENV JAVA_HOME /usr/local/…
    • Dockerfile提供RUN、ENTRYPOINT、CMD三个命令来执行，三个的区别就是执行时机不同。
      • RUN：在Build构建时执行命令
        • SHELL下：RUN yum install -y vim
        • SHELL与EXEC的区别是SHELL会在当前进程中创建一个子进程来执行新命令，子进程执行完直接返回父进程，父进程不受影响照常执行，而EXEC会用当前命令对应的新EXEC进程直接替换当前进程，不会返回之前父进程的进程环境，但是保持PID不变。官方推荐使用EXEC来执行命令
        • EXEC下：EXEC [“yum”, “install”,“-y”,“vim”]
        • 比如构建redis镜像时：RUN [“yum”, “install”, “-y”, “gcc”, “gcc-c++”, “net-tools”, “make”]
      • ENTRYPOINT:容器启动时执行的命令
        • 咱们写多个ENTRYPOINT时，Dockerfile只会执行最后一个ENTRYPOINT，最后一个ENTRYPOINT一定会被执行
        • ENTRYPOINT跟CMD同时出现时两个会被合并执行
          
      • CMD：容器启动时执行默认的命令或参数
        • Dockerfile中出现多个CMD命令，只有最后一个CMD会被执行，不一定会被执行【当创建容器时附加了其他命令后这个CMD对应的命令就不会被执行】
        • CMD可以从外界传参进来，也就是说可以从外面传新东西进来替换原来的旧命令【如果再用上ENTRYPOINT，是不是就可以玩一些骚的呀，一些指令的排列组合骚起来吧】
  • DockerImages
    • 通过DockerFile构建生成的镜像，最终发布和运行的产品
    • 比如构建一个自己的centos；
      
      • 构建步骤：
        
        • docker build -t 机构/镜像名 :tag Dockerfile目录
          
          • docker build就是来对dockerfile进行解析从而生成我们所需要的镜像的
          • -t 后面跟的是生成的镜像的名称【这个名称包含三部分：组织机构或者个人ID/你要起的镜像名字、tag就是版本不指明就是latest【咱们自己玩，不就是1.0，2.0，…】、docker build对哪个目录下的dockerfile进行构建呢【.，可以代表当前目录】】
    • DockerFile构建文件,部署springboot项目：
      

五、Docker Compose

• 官方文档：https://docs.docker.com/compose/compose-file/

  • docker-compose安装与卸载：

• 为什么要用Docker Compose
  

  • 咱们的多个服务肯定有多个环境呀，所以咱们用compose-compose一键启动整个项目（编排、打包多个/微服务环境）
  • Docker Compose就是**用来批量容器编排。轻松管理容器**（定义运行多个容器）

• Docker Compose安装使用步骤

  • 安装卸载：Compose是Docker官方的开源项目，需要安装才能使用
    
  • 使用：【容器编排工具：单机多容器部署工具，通过yml文件定义多容器部署规则】
    
    • 容器很多，配置文件很多时，容器间还有很复杂的依赖关系【先运行哪个再运行哪个…】，就需要借助外力了。
      • 单机多容器使用Docker Compose
      • 集群下的多容器使用K8s
    • docker-compose.yaml：用来定义整个服务（所需要的环境），需要的环境。（以前都是单个docker run启动容器，但是有了docker-compose之后，通过docker-compose编写yaml配置文件、可以一键启动或者停止所有服务）

      version: "3.9"  # optional since v1.27.0
      services:
      		web:  #服务1
      				images: #本服务下载镜像用的（images镜像）是
      				build: .#本服务用的，build生成的命令
      				restart:always
      				environment:  #环境配置，里面是键值对
      				depends_on:
      					 - ppp  #代表依赖顺序，就比如说，咱们web项目是不是依赖数据库呀，那这里就给咱们web服务依赖一个db,表示得先启动db才能正确或者成功启动咱们的web项目
      				ports:  #暴露的端口8000，对应的是咱们容器内的端口5000
      					 - "8000:5000"
      				volumes:  #挂载的数据卷到哪里
      					 - .:/code
      					 - logvolume01:/var/log
      				links:   #连接到Redis服务，所以docker启动时会根据配置文件先启动redis服务再启动web服务
      					 - redis
      		redis:  #服务2
      				image: redis
      		xxx1:  #服务3
      		...
      		xxx2:  #服务4
      		...
      		...
      volumes:   #挂载，用来容器间数据共享和持久化的
      		logvolume01: {}  #全局配置
      networks:
      configs:  
      

      • docker-compose.yaml只有三层：
        • 第一层：version
        • 第二层：services:服务。有服务1、服务2…。各个服务中有各自的配置（就是咱们原来对docker的一些配置），看下面代码
          • service:应用，比如web应用、redis应用，单个容器
        • 第三层：其他配置，比如网络配置、容器卷挂载、全局规则
          • 项目：所有的应用打包会生成一个完整的项目，也就是一组关联的容器

---

六、K8S入门

• 就在Docker容器技术被炒得热火朝天之时，大家发现，如果想要将Docker应用于具体的业务实现，是存在困难的——编排、管理和调度等各个方面，都不容易。于是，人们迫切需要一套管理系统，对Docker及容器进行更高级更灵活的管理。就在这个时候，K8S出现了。。
  • K8S：https://www.kubernetes.org.cn/k8s。
    • Docker、Podman 的目标不是容器的编排，编排可以使用更加专业的 Kubernetes、OpenShift、Rancher 等
    • K8S作用：
      • 自动化容器的部署和复制、随时扩缩容器规模、提供容器分组已经容器间的负载均衡，实时监控可发现故障
      • 挂掉了，K8S就会重新创建一个容器
  • K8S架构中的重点
    
    • Kubernetes Master(主节点)：独立的物理机
      • 由这个Master大哥向其他节点发送创建或者管理容器的命令，由其他容器进行实操
    • Node:宿主机
    • Pod，K8S中控制的最小单元。根据项目不同POD分割的粒度也不同
      • POD是容器的容器，可以包含很多Container
      • Pause是POD中的一个容器，经常作为中间商【POD内部各个容器通过localhost加上不同端口号就可以互相联系喽】，或者共享空间【共享数据或网络】
      • 一个POD就是一个进程
      • POD之间无法直接通信，需要通过Service
    • Service：联通不同主机上的POD，对外暴露应用的组件，一个内置的负载均衡器【统一应用入口】
      • 底层是通过kube-proxy组件【底层采用的通信协议是flannel网络组件】
      • k8s内置暴露服务的方案有两个：
        • 第一种：通过node节点的端口对外暴露内部的service服务。小应用用
        • 第二种：通过service后台关联到对应的服务，然后service与宿主机某一个端口进行绑定，再对外提供统一的交互入口。集群下用
      • Rinted实现对外提供service负载均衡，将原始IP重定向转发新的目标IP
    • Label:说明性标签
    • Replication Controller复制控制器：对POD进行实时监控，控制POD副本数量
    • Web UI Dashboard是一个可视化Web控制台页面【节点名称、关于环境的信息，节点占用的资源、节点中创建的容器】
      • 实际界面用的很少，还是用Deployment部署脚本文件多【Deployment部署脚本文件各个参数解析：https://blog.csdn.net/hhf799954772/article/details/121425425】
      • Deployment脚本文件部署相关命令：
        • kubectl create -f 部署yml文件 ：创建部署，根据yml规则在集群中创建多个pod
          • kubectl是kubenetes命令行工具，提供指令，跟docker中的各个命令开始最前面的那个docker一样，带头大哥或者说开头大哥
        • kubectl apply -f yml的文件路径 ：更新部署配置，修改集群中pod数量
          • 这个命令经常用于比如咱们集群中有俩tomcat，突然由于业务需要得增加一个tomcat变为三个
        • kubectl get pod [-o wide] ：查看已部署pod
        • kubectl describe pod pod名称 ：查看Pod详细信息，你这个pod在哪个节点上呀…
        • kubectl logs [-f] pod名称 ：查看pod输出日志
        • kubectl delete deployment[service 部署]服务名称：删除部署(Deployment)|服务（service）
      • NFS（network File System），采用远程过程调用RPC机制实现的文件传输，【NFS，通过在每一个节点上形成挂载点，这个挂载点可以当作一个本地目录，然后在yml中指定这个挂载点跟咱们pod中的容器中哪个路径对应，这不就把POD内的容器的路径挂载到NFS中了嘛，实现统一管理与修改啥的】实现文件共享，就跟配置中心差不多，方便统一修改管理配置，我修改的时候不用去每一个POD中的容器中改，在这个NFS中的挂载点这里统一修改，对应的POD容器自动就同步修改了
      • 资源限定：意思就是咱们创建的这个容器到底使用多少内存、CPU等资源。在resource下通过request和limit两个选项限定资源
        • request代表需要的意思，当前容器运行最低需要的资源【要想系统运行，你此时必须给我保证1核CPU、500Mi内存空闲才行】
          • CPU不一定是个整数，CPU的单位是核
        • limit，防止资源滥用，最多可以使用多少CPU、内存资源
  • k8s就是 基于容器的集群管理平台，它的全称，是kubernetes。一个K8S系统，通常称为一个K8S集群（Cluster）。
    • 这个集群主要包括两个部分：
      
      • 一个Master节点（主节点）：Master节点主要还是负责管理和控制
        
      • 一群Node节点（计算节点）：Node节点是工作负载节点，里面是具体的容器。
        
    • 可以利用三台虚拟机搭建一个一主两节点的集群，跟着手册或者命令仔细点，没个啥
      • 利用Kubeadm对K8S的镜像进行快速构建，部署
      • kubelet运行在所有节点上，负责启动POD和容器，以系统服务的形式出现
      • kubectl是kubenetes命令行工具，提供指令，跟docker中的各个命令开始最前面的那个docker一样，带头大哥或者说开头大哥
        • 启动节点的k8s服务：systemctl start kubelet；设置开机启动k8s服务：systemctl enable kubelet
  • 最终要实现的，涉及到的这些容器，随时可以创建，也可以随时销毁。还能够在不停机的情况下，随意变大，随意变小，随意变强，随意变弱，在性能和功耗之间动态平衡。5G时代，核心网采用微服务架构，也是和容器完美搭配——单体式架构（Monolithic）变成微服务架构（Microservices），相当于一个全能型变成N个专能型。每个专能型，分配给一个隔离的容器，赋予了最大程度的灵活。。
  • K8s “弃用 Docker”。
    • K8s 的发展史
      
      
    • 面对挑战，Docker 采取了“断臂求生”的策略，推动自身重构，Docker将原有单一架构的 Docker Engine 拆分成多个模块，其中 Docker daemon 部分捐赠给 CNCF【作为 CNCF 的托管项目，containerd 必须符合 CRI 标准】，containerd 形成
      
      • 由于 Docker 的“固执”，此时 K8s 中有两条调用链：
        
    • Docker 只是 containerd 在 Docker Engine 中调用，对外的接口保持不变，也就是说不兼容 CRI
      • Docker，Kubernetes 等工具来运行一个容器时,会调用容器运行时（CRI）比如 containerd，CRI-O,通过容器运行时（CRI）来完成容器的创建、运行、销毁等实际工作。【这些容器运行时都遵循了 OCI 规范，并通过 runc 来实现与操作系统内核交互来完成容器的创建和运行】
        
        • Docker 使用的是 containerd 作为其运行时；
        • Kubernetes 支持 containerd，CRI-O 等多种容器运行时
          
    • 2018 年 Kubernetes 1.10 发布时，containerd 也更新到 1.1 版本，正式与 Kubernetes 集成。一些性能测试数据，从这些数据可以看出，相比当时的 Docker 18.03，containerd1.1Pod 启动延迟降低了 20% 左右，CPU 使用率降低了 68%，内存使用率降低了 12%，这样可观的性能提升对云厂商来说是非常有诱惑力的。
    • 弃用Docker的dockershim：
      
      • 2020 年，K8s 1.20 终于正式向 Docker “宣战”：kubelet将弃用 Docker 支持，并将在未来的版本中完全移除。但由于 Docker 几乎已经成为容器技术的代名词，而且 K8s 已经使用 Docker 多年，该公告在传播时很快“变味了”，“kubelet 将弃用 Docker 支持”被简化为更吸人眼球的东西 “K8s 将弃用”Docker”。
        • 其实只是“弃用 dockershim ”，也就是dockershim搬出kubelet，并不是“弃用 Docker”的软件产品。
        • Dockershim：
          • 在 Kubernetes 包括一个名为 dockershim 的组件，使它能够支持 Docker。但 Docker 由于比 Kubernetes 更早，没有实现 CRI，所以这就是 dockershim 存在的原因，dockershim 支持将 Docker 被硬编码到 Kubernetes 中。随着容器化成为行业标准，Kubernetes 项目增加了对额外运行时的支持，比如通过 Container Runtime Interface (CRI) 容器运行时接口来支持运行容器。因此 dockershim 成为了 Kubernetes 项目中的一个异类，对 Docker 和 dockershim 的依赖已经渗透到云原生计算基金会（CNCF）生态系统中的各种工具和项目中，导致代码脆弱。2022 年 4 月 dockershim 将会从 Kubernetes 1.24 中完全移除。今后 Kubernetes 将取消对 Docker 的直接支持，而倾向于只使用实现其容器运行时接口的容器运行时，这可能意味着使用 containerd 或 CRI-O。这并不意味着 Kubernetes 将不能运行 Docker 格式的容器。containerd 和 CRI-O 都可以运行 Docker 格式（实际上是 OCI 格式）的镜像，它们只是无需使用 docker 命令或 Docker 守护程序。
    • K8s 原本计划用一年时间完成“弃用 Docker”的工作，但它确实低估了 Docker 的基础。1.23版本还是没能移除dockershim，只好延期半年。最后，1.24版本从kubelet中删除了dockershim的代码。
      • 虽然 K8s 不再包含dockershim，Docker 已经接管了这部分代码并构建了一个名为cri-dockerd的项目，该项目也同样工作，将 Docker Engine 适配为 CRI 接口，这样就kubelet可以通过它再次操作Docker，就好像它从来没有发生过一样。
    • Docker 镜像实际上是以 Open Container Initiative（OCI）格式打包的镜像。从 Docker Hub 或其他注册中心拉出一个镜像，你应该能够用 docker 命令使用它，或在 Kubernetes 集群上使用，或用 podman 工具以及任何其他支持 OCI 镜像格式规范的工具。
    • 但是呢，如果K8s直接使用containerd来操作容器，那么它就是一个独立于Docker的工作环境，两者都无法访问对方管理的容器和镜像。换句话说，使用docker ps命令将不会看到K8s中运行的容器。这对一些人来说可能需要花一点时间来适应并使用新工具crictl，但用于查看容器和镜像的子命令仍然是相同的，例如ps,images等，不难适应（如果你一直在用kubectl管理K8s，这个没有影响）。
• Docker 的未来
  • 作为容器技术的奠基人，没有人可以质疑 Docker 的历史地位。虽然 K8s 默认不再绑定 Docker，但 Docker 仍然可以以其他形式与 K8s 共存。
    • 首先，由于容器镜像格式已经标准化（OCI规范，Open Container Initiative），Docker镜像在K8s中仍然可以正常使用，不需要改变原有的开发测试和CI/CD流程。我们仍然可以拉取 Docker Hub，或者编写一个 Dockerfile 来打包应用程序。
    • 其次，Docker是一个完整的软件产品线，不仅仅是containerd，它还包括镜像构建、分发、测试等很多服务，甚至连K8s都内置于Docker Desktop中。就容器开发的便利性而言，Docker暂时还难以被取代。大多数云原生开发人员可以继续在这个熟悉的环境中工作，使用Docker来开发在K8s中运行的应用程序。Docker虽然在容器编排大战中败下阵来，被K8s挤到了墙角，但依然具有很强的生命力。多年积累的众多忠实用户和大量应用形象是其最大的资本和后盾。足以支持它在另一条不与 K8s 正面交锋的道路上。
  • 既然谈到了未来，那么看看码农翻身刘老师的一篇文章，里面某些话可能对咱们的未来方向的把握有引导意义。
    • 码农翻身老师的引导文章，在云原生时代的持续集成、云原生提倡“基础设施即代码 (Infrastructure as Code)【通过代码来定义基础设施，并且被版本管理系统所管理，对应到持续集成中，即 Pipline as Code】”、腾讯云CODING CI 3.0 则通过简单的 YAML 文件解决了两个问题、基于容器的CI设计

巨人的肩膀：

官方文档：https://docs.docker.com/get-docker/
官方手册：https://docs.docker.com/engine/
构建一个自己的centos；（创建一个tomcat镜像https://www.bilibili.com/video/BV1og4y1q7M4?p=30&spm_id_from=pageDriver）
https://javaguide.cn/tools/docker/docker-in-action.html
云原生技术社区
Tony老师
K8S中文社区
Java基基老师的Docker容器部署相关文章
码农翻身老师