SpringBoot中间件Docker

Docker(属于C/S架构软件)

简介与概述

1.Docker 是一个开源的应用容器引擎,基于 Go 语言 并遵从 Apache2.0 协议开源。

Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中,然后发布到任何流行的 Linux 机器上,也可以实现虚拟化。

2.  Docker的主要目标是‘build ,ship and run any app,anywhere’,也就是说通过对应用程序组件的封装,分发,部署,运行等生命周期的管理。使用户的app(可以是一个web应用程序或者数据库应用等)及其运行环境能够做到‘一次封装,到处运行’。

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

  1. 容器是完全使用沙箱机制,相互之间不会有任何接口(类似 iPhone 的 app),更重要的是容器性能开销极低。

5.Docker 从 17.03 版本之后分为 CE(Community Edition: 社区版) 和 EE(Enterprise Edition: 企业版),我们用社区版就可以了。

Docker实际上就是一个虚拟化轻量级linux服务器,可以解决我们在开发环境中运行配置问题。

为什么需要使用docker

Docker:虚拟化容器技术

Docker主要解决我们开发环境配置迁移的问题。

1.我们现在开发了一个javaweb项目,需要依赖很多环境配置 比如:Tomcat、JDK环境、Nginx、Redis环境等。

2.本地需要安装这些环境Tomcat、JDK环境、Nginx、Redis环境等,在打war包给运维部署在linux服务器,运维人员也需要在linux服务器上安装Tomcat、JDK环境、Nginx、Redis环境。

3.但是有时候可能会发生这些问题:我在本地运行环境没有问题,但是打包到Linux服务器运行总是遇到很多错误,大多数由于一些版本冲突影响。

4.所以在这时候我们就可以使用docker部署和安装软件就非常方便,直接将该springboot项目制作成一个镜像文件,镜像文件中包含jdk版本 tomcat版本信息  直接部署linux即可,减少依赖冲突概率。

看看linux安装mysql

在不同的linux内核中安装

Mysql很容易发生版本冲突的问题。

在对比docker安装mysql

docker pull mysql:5.7

docker create --name mysql3308 -e MYSQL_ROOT_PASSWORD=root -p 3308:3306 mysql:5.7

Docker最终解决了运行环境配置中的问题。----镜像文件底层封装好了

Springboot 核心思想----

使用docker的好处

  1. 简化配置 安装创建非常的方便
  2. 代码流水线(Code Pipeline)管理 传统项目部署可能需要经过很多环节,

容易产生版本的依赖冲突问题,Docker给应用提供了一个从开发到上线均一致的环境,让代码的流水线变得简单不少 SIT PRE PRD

  1. Devops 开发与运维一体化减少沟通的成本 (docker或者是k8s实现)
  2. 虚拟技术 快速部署
  3. 弹性扩容

Docker的核心三要素

  1. 仓库  专门存放我们镜像文件的  类似于  腾讯管家软件市场,app软件市场
  2. 镜像  类似于你的安装包(下一步运行 描述运行所需要的环境配置和依赖)

         Redis镜像,Tomcat镜像==>自动下载JDK镜像

镜像方式来源:

自己的项目(自己创建镜像文件)

第三方镜像来自于https://hub.docker.com/仓库

  1. 容器  运行我们镜像文件 自己独立的ip和网络信息化 虚拟化出一个轻量级的Liunx操作系统精简版本

应用场景

1.Web 应用的自动化打包和发布。

2.自动化测试和持续集成、发布。

3.在服务型环境中部署和调整数据库或其他的后台应用。

4.从头编译或者扩展现有的 OpenShift 或 Cloud Foundry 平台来搭建自己的 PaaS 环境。

容器与虚拟机区别

什么是虚拟机:在一台物理机器上,利用虚拟化技术,虚拟出来多个操作系统,每个操作系统之间是隔离的。


从下到上理解上图:

最下面的一层就是物理机,可以是服务器,设置是一台个人电脑;

电脑上需要安装操作系统,比如我们安装了win10的操作系统;

再往上就是虚拟机软件了,比如我们常用的VirtualBox、VMWare,它们的作用是模拟计算机硬件;继续向上,就是虚拟机模拟出来的操作系统了;在虚拟的操作系统中,安装所需的软件、组件等。比如我们需要在虚拟操作系统中安装JDK、Tomcat等;

最后就是具体的应用了,例如部署到Tomcat中。

Docker :Docker是开源的应用容器引擎


依然从下往上看:

最下面两层,概念同上。

往上,可以看做Docker容器的管理器。

依赖和应用都被打包成了Docker镜像。例如,JDK、Tomcat、应用都被打包在了一起,运行在Docker容器里,容器和容器间是隔离的。

Docker和虚拟机的区别

1.从两者的架构图上看,虚拟机是在硬件级别进行虚拟化,模拟硬件搭建操作系统;而Docker是在操作系统的层面虚拟化,复用操作系统,运行Docker容器

2.Docker的速度很快,秒级,而虚拟机的速度通常要按分钟计算。

3.Docker所用的资源更少,性能更高。同样一个物理机器,Docker运行的镜像数量远多于虚拟机的数量。

4.虚拟机实现了操作系统之间的隔离,Docker是进程之间的隔离,虚拟机隔离级别更高、安全性方面也更强。

5.虚拟机和Docker各有优势,不存在谁替代掉谁的问题,很多企业都采用物理机上做虚拟机,虚拟机中跑Docker的方式。

特性

容器

虚拟机

启动速度

秒级

分钟级别

硬盘使用

一般为MB

一般GB

性能

接近原生

弱于

系统支持量

单机支持上千个容器

一般几十个

隔离性

完全隔离

完全隔离

Docker官网

https://docs.docker.com/

Docker: Accelerated Container Application Development

Docker安装

Docker 要求 CentOS7 系统的内核版本在 3.10以上 ,查看本页面的前提条件来验证你的CentOS 版本是否支持 Docker

1、通过 uname -r 命令查看你当前的内核版本

uname -r

  1. 使用 root 权限登录 Centos。确保 yum 包更新到最新。

yum -y update

该过程大概需要维持10分钟左右

  1. 卸载旧版本(如果安装过旧版本的话)

yum remove docker docker-common docker-selinux docker-engine

  1. 安装需要的软件包, yum-util 提供yum-config-manager功能,另外两个是devicemapper驱动依赖的

yum install -y yum-utils device-mapper-persistent-data lvm2

  1. 设置yum

yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

6,可以查看所有仓库中所有docker版本,并选择特定版本安装

yum list docker-ce --showduplicates | sort -r

7.安装docker

sudo yum install -y docker-ce     #由于repo中默认只开启stable仓库,故这里安装的是最新稳定版18.03.1

8.启动并加入开机启动

systemctl start docker

systemctl enable docker

9.验证安装是否成功(clientservice两部分表示docker安装启动都成功了)

docker version

Docker快速入门

Docker核心名词

镜像文件

容器

仓库

镜像:简单理解为就是一个安装包,里面包含容器所需要运行的的基础文件和配置信息

,比如:redis镜像、mysql镜像等。

镜像的来源方式:

  1. 自己做镜像  比如(自己开发微服务项目)
  2. 拉取别人制作好的镜像, 例如 nginx、mysql、redis等。

容器: 容器就是镜像运行的实例,容器状态分为:初创建、运行、停止、暂停、

删除, 一个镜像可以创建多个不同的容器。

每个镜像文件都有自己独立ip信息---轻量级的linux服务器 虚拟化

比如:镜像就是类  容器就是实例对象

仓库: 仓库可以简单理解为,专门存储镜像文件仓库, 类似于 谷歌手机市场,统一在

谷歌手机市场下载开发者的安装包。

Docker 公开仓库地址: Docker hub

https://hub.docker.com/

Docker官方仓库:https://hub.docker.com/ ----访问比较慢

宿主机:当前win10操作系统


需要制作镜像文件(springboot项目)------类似于开发者开发安装应用程序打包

  1. 需要将我们制作好的镜像文件提交到docker仓库中-----开发者将自己的app应用程序发布安卓手机助手中。
  2. 本地需要拉去我们docker仓库中下载镜像文件,在交给我们容器运行---用户从app市场中下载安装包运行。

1.在需要制作镜像文件,将该镜像文件发布到docker仓库

docker仓库 dockerhub ----谷歌安卓手机市场   国内加速镜像

阿里云、网易、科大()----360、小米、华为。

  1. 从docker仓库下载镜像文件-----用户从手机市场中,下载软件。
  2. docker运行镜像文件----容器---独立ip访问信息-----端口号码映射

Docker下载镜像原理

Docker  pull 从远程docker 官方仓库下载 镜像,到本地,在使用容器运行该镜像。

注意的是:docker官方镜像仓库地址部署在国外,下载镜像可能比较慢,建议配置国内加速镜像

Docker加载镜像配置

https://hub.docker.com/search?q=redis&type=image ---在国外访问可能比较慢

国内从 DockerHub 拉取镜像有时会遇到困难,此时可以配置镜像加速器。Docker 官方和国内很多云服务商都提供了国内加速器服务,例如:

科大镜像:https://docker.mirrors.ustc.edu.cn/

网易:https://hub-mirror.c.163.com/

阿里云:https://<你的ID>.mirror.aliyuncs.com

七牛云加速器:https://reg-mirror.qiniu.com

当配置某一个加速器地址之后,若发现拉取不到镜像,请切换到另一个加速器地址。国内各大云服务商均提供了 Docker 镜像加速服务,建议根据运行 Docker 的云平台选择对应的镜像加速服务。

阿里云加速镜像配置

我的加速镜像:https://lq5fijxu.mirror.aliyuncs.com

阿里云镜像获取地址:https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors,登陆后,左侧菜单选中镜像加速器就可以看到你的专属地址了:

sudo mkdir -p /etc/docker

sudo tee /etc/docker/daemon.json <<-'EOF'

{

  "registry-mirrors": ["https://66mzqrih.mirror.aliyuncs.com"]

}

EOF

sudo systemctl daemon-reload

sudo systemctl restart docker

如何查看加速镜像安装成功

输入:docker info

Docker常用命令

docker --help  帮助命令

docker --version

docker -version

docker images

查看本地images 镜像缓存

docker images 查看本地镜像文件

docker rmi -f kibana:5.6.9 ---删除镜像文件

REPOSITORY 存储库名称

Tag  镜像的标签  不写版本号码 默认下载最新latest镜像

IMAGE ID  镜像id

CREATED 创建时间

SIZE 大小

docker images -a

docker images -q ---只显示镜像的id

docker images --digests ---显示镜像的摘要信息

docker images --no-trunc ---显示完整镜像信息

docker rmi tomcat(镜像文件名称)

docker search

docker search mysql

(mysql现阶段开发常用版本  不推荐5.6版本(2种安装方式)   推荐5.7版本8.0版本)

https://hub.docker.com/

docker search -s 30 mysql  列出点赞数超过30以上。

latest 表示为最新的镜像文件 mysql8.0版本

docker pull

latest -----tag 最新版本的镜像文件

docker pull nginx:latest --默认的情况下 下载最新版本的镜像  可以通过

https://hub.docker.com/_/nginx?tab=tags&page=1&ordering=last_updated

容器管理

查看容器信息

Docker  ps  获取到容器id

docker inspect  1e07cc5cc78d

运行容器
docker run

docker run -i(保持容器一直运行)-t(给容器一个伪终端)-d(后台运行,不直接进入容器) --name=tomcat9.2(给启动容器起名字)-p 8080:8080(宿主:docker容器)tomcat:9.2(启动的容器)  【参数】(加入容器初始化命令)

#通过 -it 启动的容器有两个特点 一创建就进入容器 exit退出容器 容器就会停止运行  ---交互式容器

#通过 -id 创建的容器 docker exec -it tomcat9.2(--name起的名称)进入容器 exit退出容器 容器不会停止运行   ---守护式容器

docker ps 查看正在运行的容器

docker ps -a 查看运行和已经运行关闭大的容器

docker stop tomcat8  关闭容器

docker start tomcat8 启动容器

docker rm tomcat8 删除容器

docker inspect tomcat8 查看容器信息

docker exec 参数  进入容器

docker run 运行原理

docker run boyatop

简单描述:首先会先从本地获取获取boyatop镜像文件,如果本地没有该镜像文件则会去

阿里云仓库查找该镜像文件,如果阿里云仓库也没有该镜像文件,则会报错找不到

镜像文件。

获取到镜像文件之后直接运行。

详细描述:

1.docker在本机缓存中  boyatop镜像文件,如果本地存在该镜像文件

,则以该镜像文件作为模板在容器中运行。

2.如果本地缓存中,没有boyatop镜像文件 则会从dockerhub 或者加速镜像中

查找,如果查找不到的话,则返回错误找不到该镜像。

  1. 如果能够查找到该镜像,则以该镜像作为模板运行。

每个容器都有自己独立的网络 ip信息 运行成功 就是一个轻量级linux操作系统

启动容器

docker start 容器id

停止容器

docker stop  容器id

删除容器

docker rm  容器id

进入容器中

# 首先使用下面的命令,查看容器ID(CONTAINER ID):

docker ps -a

# 然后用下面的命令进入容器,就可以使用bash命令浏览容器里的文件:

docker exec -it [CONTAINER ID] bash

# 有的镜像没有bash命令,可以用对应的shell,比如sh

docker exec -it [CONTAINER ID] sh

Docker 镜像原理

镜像是什么

基于docker安装tomcat服务器 是否需要配置jdk环境变量呢?

docker安装tomcat:8 --jdk8 配置环境变量

docker安装tomcat:9 --jdk9 配置环境变量

如何封装配置环境依赖的呢?

Dockerfile---文件

Tomcat 100mb

1.依赖于我们JDK 200mb

2.Linux服务器centos 200mb

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

镜像文件的组成通过 Union fs

运行我们tomcat镜像文件

tomcat镜像文件

  1. 依赖于我们JDK
  2. Linux服务器

为什么运行tomcat镜像文件,不需要配置jdk环境变量。

  1. tomcat镜像文件包含jdk依赖镜像 tomcat8-----jdk8镜像文件
  2. 底层dockerfile -----描述配置jdk环境
镜像加载的原理

Linux文件系统由bootfs和rootfs两部分组成

 bootfs:包含bootloader(引导加载程序)和 kernel(内核)

 rootfs: root文件系统,包含的就是典型 Linux 系统中的/dev,/proc,/bin,/etc等标准目录和文件

不同的linux发行版,bootfs基本一样,而rootfs不同,如ubuntu,centos等

Docker镜像底层实际上是有多个不同的联合文件系统组成的

最底层:bootfs,并使用宿主机的bootfs-复用

第二层:root文件系统rootfs,称为base image

Union fs

然后再往上可以叠加其他的镜像文件

统一文件系统(Union File System)技术能够将不同的层整合成一个文件系统,为这些层提供了一个统一的视角,隐藏多层的存在,我们看来只是存在一个文件系统。

所以当我们安装的tomcat镜像大小是600多MB 是因为里面还包含了jdk和centos的镜像

而centos镜像复用了宿主机的bootfs 下载的只有rootfs 所以小很多

所以tomcat>jdk(父镜像)->centos> 所以整个向外暴露就是600MB

镜像只读 当从一个镜像启动容器时, 所以docker会在镜像上面加载一个可读可写的文件系统作为容器运行。

https://hub.docker.com/_/tomcat

Docker Commit

主要作用:根据当前容器制作为镜像文件

流程:

  1. 从docker hub中下载一个tomcat8镜像文件;
  2. 运行tomcat8镜像文件 在tomcat webapps 目录中新增 boyatop文件夹 index.html
  3. 将当前容器内容根据模板制作为镜像文件

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

命令:docker commit -m=“提交的描述信息” -a=“作者” 容器ID 要创建的目标镜像名:[标签名]

  1. 安装一个tomcat8

docker run -p 8081:8080   tomcat:8

  1. docker exec -it 3a06b4c779a8   bash
  2. cd webapps
  3. mkdir boyatop
  4. touch index.html
  5. echo "boyatop" >>index.html

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

1.根据当前容器作为模板制作为镜像文件

docker commit -m="boyatop tomcat" -a="boyatop"  3a06b4c779a8 boyatop-tomcat:1.0

2.在以当前自己制作的镜像文件运行

docker run -p 8088:8080   boyatop-tomcat:1.0

Docker数据卷

基本的概念

数据卷就是宿主机上的一个文件或目录

当容器目录和数据卷(宿主机)目录绑定,双方修改会立即同步操作

一个数据卷可以被多个容器同时挂载

数据卷作用:容器数据的持久化 外部机器和容器间接通信 容器之间数据交换

使用 -v命令。

数据卷添加的方式

容器内与宿主机实现数据的共享

数据卷--添加两种方式

  1. 直接命令形式添加  docker run -it -v 宿主机绝对路径目录:容器内目录 镜像文件名称
  2. Dockerfile方式添加
安装Nginx实现负载均衡
挂载nginx html文件

https://hub.docker.com/search?q=nginx&type=image

  1. 创建挂载目录

mkdir -p /data/nginx/{conf,conf.d,html,logs}

  1. 启动docker容器

docker run --name nginx81 -d -p 81:80 -v /data/nginx/html:/usr/share/nginx/html nginx

-v /data/nginx/html 虚拟机目录 --挂载 容器目录 /usr/share/nginx/html

上传一个 html 放入到  /data/nginx/html

docker run --name nginx81 -d -p 81:80 -v /data/nginx/html:/usr/share/nginx/html nginx

-v /data/nginx/html: linux虚拟机目录

/usr/share/nginx/html 容器中html目录

nginx .conf文件和日志文件

docker run --name nginx81 -d -p 81:80 -v /data/nginx/html:/usr/share/nginx/html \

-v /data/nginx/conf/nginx.conf:/etc/nginx/nginx.conf \

-v /data/nginx/logs:/var/log/nginx  nginx

\反斜杠  表示换行

/usr/share/nginx/html

/usr/share/nginx/conf

/usr/share/nginx/log

Docker实战部署软件
安装Tomcat服务器

docker run -p 8081:8080   tomcat:8

-p 8081 :8080    容器外部(linux虚拟机访问端口8081):8080(容器端口号)

docker ps  获取tomcat正在运行的容器id 进入到中

docker exec -it 1210e05f1a59 bash

docker run -p 8081:8080   tomcat:8

-p 8081:8080  8081(linux虚拟机访问的端口号):8080(容器内部中端口号)

docker run -p 8081:8080 -d   tomcat:8 后台启动 ---每次运行都会创建一个新的容器

docker run --name boyatop-tomcat  -p 8081:8080  -d   tomcat:8

--name: 指定容器名称

-p:指定容器端口号

-d:指定容器后台运行

docker run --name boyatop-tomcat    tomcat

docker run --name boyatop-tomcat1  -p 8081:8080  tomcat

8081(容器外部或者linux虚拟机访问的端口号 宿主机)

8080 容器内部的端口号

docker run --name boyatop-tomcat2022  -p 8081:8080 -d   tomcat:8

-d 后台启动

前台启动与后台启动的区别

前台启动会打印启动日志信息

后台启动不会打印启动日志信息

安装Nginx实现静态服务

Docker run 运行容器

--name nginx-test:容器名称。

-p 8080:80  端口进行映射,将本地 8080 端口映射到容器内部的 80 端口。

-d nginx: 设置容器在在后台一直运行。

docker  ps --- 正在运行的容器

docker ps -a 显示所有的容器 包括为运行的容器

docker ps 容器id

docker run --name nginx-boyatop -p 8080:80 nginx   默认前台启动

docker run --name nginx-boyatop -p 8080:80 -d nginx   后台启动方式

前台与后台启动区别:

前台启动:会展示容器启动的日志信息-----

后台启动:不会展示启动日志信息

8080:80 8080 虚拟机本地端口 ---浏览器访问 80 容器内部端口

 Elk+kafka---

 systemctl stop firewalld

安装MySQL5.7

1.查询mysql版本

docker search mysql

2.下载MySQL5.7版本

docker pull mysql:5.7  (这里选择的是第一个mysql镜像, :5.7选择的5.7版本)

3.等待下载完成、创建MySQL容器

docker create --name mysql3308 -e MYSQL_ROOT_PASSWORD=root -p 3308:3306 mysql:5.7

 创建容器名称为mysql3308,密码为root

  1. 启动容器

docker start mysql3308

  1. 进入到容器

docker exec -it mysql3308 bash

  1. mysql连接

mysql -uroot –p

Docker运行底层原理
  1. 首先启动docker systemctl start docker
  2. Docker是一个CS架构的系统,docker守护进程运行在主机上,让后通过socket连接

从客户端访问,守护进程从客户端接收命令管理运行在主机上的容器。

ps aux | grep 'docker'

网站“bs”CS

数据卷volumes-from

容器间传递共享数据volumes-from

启动容器报错了如何解决?

先改为前台启动如果没有问题的情况下,在修改为后台启动。

容器与容器局域网

DockerFile 解析

一个镜像文件到底是如何创建?

  1. dockerfile 描述出镜像文件需要的一些依赖配置和环境变量 执行命令
  2. 将我们dockerfile 文件打包成一个镜像文件
  3. 直接使用我们的容器运行到该镜像文件。

  1. 需要手动编写一个dockerfile文件
  2. 将该dockerfile  docker build 自定义成一个镜像文件
  3. docker run 运行容器

Centos镜像文件

docker run -it centos

sig-cloud-instance-images/docker/Dockerfile at b2d195220e1c5b181427c3172829c23ab9cd27eb · CentOS/sig-cloud-instance-images · GitHub

DockerFile编写规范

A.#描述注释

B.指令必须要大写,后面至少需要带至少一个参数;

C.指令是按照从上到下,顺序执行;

DockerFile指令

  1. FROM 指定父镜像:  基于哪个镜像image构建  指定基础镜像,必须为第一个命令
  2. MAINTAINER :维护者
  3. RUN: 容器创建的时候执行一段命令   构建镜像时执行的命令
  4. ADD: 将本地文件添加到容器中,tar类型文件会自动解压(网络压缩资源不会被解压),可以访问网络资源,类似wget
  5. COPY:功能类似ADD,但是是不会自动解压文件,也不能访问网络资源
  6. CMD:构建容器后调用,也就是在容器启动时才进行调用。 .sh执行文件
  7. ENV: 设置环境变量
  8. EXPOSE: 指定于外界交互的端口
  9. VOLUME  用于指定持久化目录
  10. WORKDIR 设置进入容器时的路径

Tomcat docker File:

tomcat/8.5/jdk8/openjdk-slim-buster/Dockerfile at 385e8403a38fab7097d4c3fed2484caba7dfd099 · docker-library/tomcat · GitHub

https://github.com/docker-library/redis/blob/231905d0841f52ee4f3a5b8b42d62cd6d14a1a93/6.2/Dockerfile

DockerFile案例

Base镜像(scratch) docker hub中的镜像都是通过base镜像中安装和配置需要的软件构建的。

构建自己centos镜像

docker run -it centos

  1. 需求定制修改centos根目录;
  2. 实现支持vim插件;

yum -y install vim

  1. 需要自己制作一个dockerfile文件
  2. 继承docker hub中的centos
  3. 在docker hubcentos 上加入以下两个功能

A.进入容器中 默认访问目录/usr

B.实现支持vim插件

需要将该dockerfile文件打包成一个镜像文件 交给我们容器执行

sig-cloud-instance-images/docker/Dockerfile at b2d195220e1c5b181427c3172829c23ab9cd27eb · CentOS/sig-cloud-instance-images · GitHub

定制CentOS镜像

FROM  centos

MAINTAINER boyatop-shizhaoyang

ENV  MYPATH /usr

WORKDIR $MYPATH

RUN yum -y install vim

EXPOSE 80

CMD /bin/bash

Dockerfile→使用docker 将该Dockerfile实现打包成镜像文件→

容器运行该镜像文件。

docker build---将该Dockerfile实现打包成镜像文件

将该dockerfile文件上传到linux服务器中

使用docker build -f Dockerfile -t mycs:1 .

Dockerfile ------配置文件

mycs----打包镜像文件名称

1 tag 版本号码

docker run -it mycs:1

将springboot项目打包部署
  1. 基于docker原生方式 部署我们的springboot项目

Dockerfile

2.dockercompose----- 容器编排技术

springboot项目----变成镜像文件---容器运行

  1. 将我们springboot项目---打成一个jar包

2.定义dockerfile文件-----描述出springboot项目 配置依赖和环境变量

JDK

注意:springboot内置嵌入我们的tomcat服务器 所以不需要额外的tomcat容器来

运行。

原生方式运行我们的jar包

Java- jar指令

  1. 需要先将我们外部jar,拷贝到容器中
  2. 容器运行成功执行java -jar

2.将该dockerfile文件打包成镜像文件

  1. 将springboot项目打包;
  2. 制作dockerfile文件;
  1. 继承我们的jdk环境
  2. 将我们本地的jar包拷贝到容器中
  3. Java -jar

  1. 将dockerfile文件打包成镜像文件;
  2. 运行该镜像文件即可;

将springboot项目打包

mvn clean package

制作dockerfile文件
# 基础镜像使用java

  FROM java:8

  # 作者

  MAINTAINER www.boyatop.com

  # VOLUME 指定了临时文件目录为/tmp# 其效果是在主机 /var/lib/docker 目录下创建了一个临时文件,并链接到容器的/tmp

  VOLUME /tmp

  # jar包添加到容器中并更名为boyatop.jar

  ADD boyatop-thymeleaf-1.0-SNAPSHOT.jar boyatop.jar

  # 运行jarRUN bash -c 'touch /boyatop.jar'

  ENTRYPOINT 
上一篇:【星汇极客】单片机竞赛之2024睿抗机器人大赛-火线速递赛道(持续更新)


下一篇:计算机毕业设计 网上体育商城系统的设计与实现 Java实战项目 附源码+文档+视频讲解