当前位置: 首页>移动开发>正文

92 dokcer

Docker

简介与概述
1.Docker 是一个开源的应用容器引擎,基于 Go 语言 并遵从 Apache2.0 协议开源。
Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中,然后发布到任何流行的 Linux 机器上,也可以实现虚拟化。

  1. Docker的主要目标是‘build ,ship and run any app,anywhere’,也就是说通过对应用程序组件的封装,分发,部署,运行等生命周期的管理。使用户的app(可以是一个web应用程序或者数据库应用等)及其运行环境能够做到‘一次封装,到处运行’。
    3.Linux容器技术的出现解决了这个问题。而docker就是基于他的基础上发展过来的。将应用运行到docker容器上面,而docker容器在任何操作系统上都是一致的,这就是实现跨平台跨服务器。只需要一次配置好环境,换到别的机子上就可以一键部署好,大大简化了操作。
  2. 容器是完全使用沙箱机制,相互之间不会有任何接口(类似 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
https://blog.csdn.net/qq_42097051/article/details/113726893 在不同的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给应用提供了一个从开发到上线均一致的环境,让代码的流水线变得简单不少
  3. Devops 开发与运维一体化减少沟通的成本 (docker或者是k8s实现)
  4. 虚拟技术 快速部署
  5. 弹性扩容
    应用场景
    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/
https://www.docker.com/
Docker安装

Docker 要求 CentOS7 系统的内核版本在 3.10以上 ,查看本页面的前提条件来验证你的CentOS 版本是否支持 Docker 。
建议安装 CentOS-7.6-x86_64-DVD-1810.iso Docker-CE-19.03.05
链接:https://pan.baidu.com/s/16noDp8m8B4w8w7f4hzEAzg
提取码:08yo
不要使用CentOS-7.6-1406-x86_64-DVD.iso,默认下载最新的docker的话 一直启动失败!
CentOS-7.6-x86_64-DVD-1810.iso 相关虚拟机:
1、安装所需的软件包
yum-utils提供了yum-config-manager 效用,并device-mapper-persistent-data和lvm2由需要 devicemapper 存储驱动程序。
sudo yum install -y yum-utils
device-mapper-persistent-data
lvm2
2.设置稳定的安装源(存储库)
sudo yum-config-manager
--add-repo
https://download.docker.com/linux/centos/docker-ce.repo

  1. 安装docker-ce-19.03.5
    我这里选择安装docker-ce-19.03.5版本,如果你在安装的时候查询到新的版本,只要按照格式安装就可以了,注意版本号。
    软件包名称是软件包名称(docker-ce)加上版本字符串(第二列),从第一个冒号(:)一直到第一个连字符,并用连字符(-)分隔。例如,docker-ce-19.03.5。
    yum install docker-ce-19.03.5 docker-ce-cli-19.03.5 containerd.io
    4.安装完成后,运行下面的命令,验证是否安装成功。
    docker -v 或者docker info

5.启动并加入开机启动
systemctl start docker
systemctl enable docker
如果启动docker 报错:sudo systemctl start docker Job for docker.service failed because the control process exited with error code. See “systemctl status docker.service” and “journalctl -xe” for details.
大多数是因为CentOS的版本安装存在些问题。
英文只能通过谷歌的搜索引擎---

Docker快速入门
Docker核心名词

镜像文件
容器
仓库

镜像:简单理解为就是一个安装包,里面包含容器所需要运行的的基础文件和配置信息
,比如:redis镜像、mysql镜像等。
镜像的来源方式:

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

容器: 容器就是镜像运行的实例,容器状态分为:初创建、运行、停止、暂停、
删除, 一个镜像可以创建多个不同的容器。

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

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

仓库: 仓库可以简单理解为,专门存储镜像文件仓库, 类似于 谷歌手机市场,统一在
谷歌手机市场下载开发者的安装包。
Docker 公开仓库地址: Docker hub
https://hub.docker.com/

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

宿主机:当前win7操作系统

  1. 需要制作镜像文件(springboot项目)------类似于开发者开发安装应用程序打包
  2. 需要将我们制作好的镜像文件提交到docker仓库中-----开发者将自己的app应用程序发布安卓手机助手中。
  3. 本地需要拉去我们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://66mzqrih.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
https://hub.docker.com/

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 mayikt

简单描述:首先会先从本地获取获取mayikt镜像文件,如果本地没有该镜像文件则会去
阿里云仓库查找该镜像文件,如果阿里云仓库也没有该镜像文件,则会报错找不到
镜像文件。
获取到镜像文件之后直接运行。
详细描述:
1.docker在本机缓存中 mayikt镜像文件,如果本地存在该镜像文件
,则以该镜像文件作为模板在容器中运行。
2.如果本地缓存中,没有mayikt镜像文件 则会从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镜像文件 在tomcatwebapps 目录中新增 mayikt文件夹 index.html
  3. 将当前容器内容根据模板制作为镜像文件

docker commit提交容器副本使之成为一个新的镜像
命令:docker commit -m=“提交的描述信息” -a=“作者” 容器ID 要创建的目标镜像名:[标签名]

  1. 安装一个tomcat8
    docker run -p 8081:8080 tomcat:8
  2. docker exec -it 3a06b4c779a8 bash
  3. cd webapps
  4. mkdir mayikt
  5. touch index.html
  6. echo "mayikt" >>index.html

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

1.根据当前容器作为模板制作为镜像文件
docker commit -m="mayikt tomcat" -a="mayikt" 3a06b4c779a8 mayikt-tomcat:1.0
2.在以当前自己制作的镜像文件运行
docker run -p 8088:8080 mayikt-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}

  2. 启动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 mayikt-tomcat -p 8081:8080 -d tomcat:8

--name: 指定容器名称
-p:指定容器端口号
-d:指定容器后台运行
docker run --name mayikt-tomcat tomcat

docker run --name mayikt-tomcat1 -p 8081:8080 tomcat
8081(容器外部或者linux虚拟机访问的端口号 宿主机)
8080 容器内部的端口号
docker run --name mayikt-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-mayikt -p 8080:80 nginx 默认前台启动
docker run --name nginx-mayikt -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
  2. 进入到容器
    docker exec -it mysql3308 bash
  3. mysql连接
    mysql -uroot –p
    Docker运行底层原理
  4. 首先启动docker systemctl start docker
  5. 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

https://github.com/CentOS/sig-cloud-instance-images/blob/b2d195220e1c5b181427c3172829c23ab9cd27eb/docker/Dockerfile

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-----jdk环境

Tomcat docker File:
https://github.com/docker-library/tomcat/blob/385e8403a38fab7097d4c3fed2484caba7dfd099/8.5/jdk8/openjdk-slim-buster/Dockerfile

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

进入tomcat 容器----/data
redis容器/data
/
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文件打包成一个镜像文件 交给我们容器执行

https://github.com/CentOS/sig-cloud-instance-images/blob/b2d195220e1c5b181427c3172829c23ab9cd27eb/docker/Dockerfile

定制CentOS镜像
FROM centos
MAINTAINER mayikt-yushengjun
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文件;
    A. 继承我们的jdk环境
    B. 将我们本地的jar包拷贝到容器中
    C. Java -jar

  3. 将dockerfile文件打包成镜像文件;

  4. 运行该镜像文件即可;

将springboot项目打包
mvn clean package
制作dockerfile文件

基础镜像使用java

FROM java:8

作者

MAINTAINER www.mayikt.com

VOLUME 指定了临时文件目录为/tmp。

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

VOLUME /tmp

将jar包添加到容器中并更名为mayikt.jar

ADD mayikt-thymeleaf-1.0-SNAPSHOT.jar mayikt.jar

运行jar包

RUN bash -c 'touch /mayikt.jar'
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/mayikt.jar"]

暴露8080端口

EXPOSE 8080

打包成镜像文件
docker build -f Dockerfile -t mayikt-member:1 .
docker build -f Dockerfile -t mayikt-member:1 .
启动容器
docker run -p 8070:8080 mayikt-member:1

访问测试

Docker Compose

Sit pre prd环境
为什么需要使用Docker Compose
Docker Compose 容器编排技术

容器编排技术

1.现在我们有一个springboot项目,需要依赖Redis、mysql5.7、nginx。
如果使用docker原生部署的话,则需要安装Redis、mysql5、nginx容器,在才可以启动我们springboot项目,这样的话部署项目的流程非常复杂,所以需要引入我们的
Docker compose实现容器编排技术。

基本的概念
Docker-Compose项目是Docker官方的开源项目,负责实现对Docker容器集群的快速编排。
Docker-Compose将所管理的容器分为三层,分别是工程(project),服务(service)以及容器(container)。
开发一个springboot项目---大工程

  1. 依赖mysql
  2. 依赖redis
  3. 依赖zk
    等。
    需要在docker-compose.yml 配置项目工程依赖环境配置

Docker-Compose运行目录下的所有文件(docker-compose.yml,extends文件或环境变量文件等)组成一个工程,若无特殊指定工程名即为当前目录名。一个工程当中可包含多个服务,每个服务中定义了容器运行的镜像,参数,依赖。一个服务当中可包括多个容器实例,Docker-Compose并没有解决负载均衡的问题,因此需要借助其它工具实现服务发现及负载均衡。

Docker-Compose的工程配置文件默认为docker-compose.yml,可通过环境变量COMPOSE_FILE或-f参数自定义配置文件,其定义了多个有依赖关系的服务及每个服务运行的容器。

Compose 中有两个重要的概念:

服务 (service) :一个应用的容器,实际上可以包括若干运行相同镜像的容器实例。
项目 (project) :由一组关联的应用容器组成的一个完整业务单元,在 docker-compose.yml 文件中定义。
一个项目可以由多个服务(容器)关联而成,Compose 面向项目进行管理,通过子命令对项目中的一组容器进行便捷地生命周期管理。

Compose 项目由 Python 编写,实现上调用了 Docker 服务提供的 API 来对容器进行管理。因此,只要所操作的平台支持 Docker API,就可以在其上利用 Compose 来进行编排管理。

Docker-Compose分成三层
1.项目层 springboot项目依赖于我们的mysql redis、nginx等 一个项目是由多个容器组成的。
2.服务层 运行一个镜像的实例 ---

Compose环境安装(离线安装)

  1. 访问docker compose github 官网
  1. docker-compose-Linux-x86_64 上传到服务器中,然后执行如下命令将其移动到/usr/local/bin/目录中 并且更名为docker-compose
    mv docker-compose-Linux-x86_64 /usr/local/bin/docker-compose
  2. 执行如下命令:添加可执行的权限
    sudo chmod +x /usr/local/bin/docker-compose
  3. 验证docker-compose
    docker-compose -v

Compose常用命令
docker-compose -h # 查看帮助

docker-compose up # 创建并运行所有容器
docker-compose up -d # 创建并后台运行所有容器
docker-compose -f docker-compose.yml up -d # 指定模板
docker-compose down # 停止并删除容器、网络、卷、镜像。

docker-compose logs # 查看容器输出日志
docker-compose pull # 拉取依赖镜像
dokcer-compose config # 检查配置
dokcer-compose config -q # 检查配置,有问题才有输出

docker-compose restart # 重启服务
docker-compose start # 启动服务
docker-compose stop # 停止服务

Compose入门案例

流程:

  1. 需要定义一个docker-compose.yml文件----工程
  2. 需要在docker-compose文件配置依赖服务
  3. docker-compose up 执行该文件
  1. 创建一个docker-compose.yml;
  2. 定制docker-compose 内容;
  3. 运行 docker-compose up ;

version: '3.0'
services:
tomcat: ##服务名称
image: tomcat:8 #镜像文件名称
ports:
- 8080:8080

Compose模板文件
version: '3.0'
services:
tomcat80: ##服务名称
#container_name: tomcat8080 指定容器名称
image: tomcat:8 #镜像文件名称 run images
ports: ###端口号的映射 -p
- 8080:8080
volumes: ## 数据源 宿主机与容器数据共享 -v
- /usr/tomcat/webapps:/usr/local/tomcat/webapps
networks: ###定义网络的桥
- mayikt

tomcat81: ##服务名称
#container_name: tomcat8080 指定容器名称
image: tomcat:8 #镜像文件名称
ports: ###端口号的映射
- 8081:8080
volumes: ## 数据源 宿主机与容器数据共享
- /usr/tomcat/webapps:/usr/local/tomcat/webapps
networks:
- mayikt
networks: ## 定义服务的桥
mayikt:

Compose常用命令

docker-compose ps 列出项目中所有的容器
docker-compose stop 停止docker-compose
docker-compose logs 查看容器中日志信息
docker-compose pull 拉取服务依赖的镜像

Compose常用配置

Image 镜像名称;
Build 根据docker file 打包 成镜像;
Context 指定docker file文件位置;
Commond 使用command可以覆盖容器启动后默认执行的命令;
Container_name 容器名称;
depends_on 指定依赖那个服务;
Ports 映射的端口号;
extra_hosts 会在/etc/hosts文件中添加一些记录;
Volumes 持久化目录;
volumes_from 从另外一个容器挂在数据卷;
Dns 设置dns

Compose部署springboot项目
定义Compose文件
version: "3.0"
services:
mysql: # mysql服务
image: mysql:5.7
command: --default-authentication-plugin=mysql_native_password #解决外部无法访问
ports:
- "3306:3306" #容器端口映射到宿主机的端口
environment:
MYSQL_ROOT_PASSWORD: 'root'
MYSQL_ALLOW_EMPTY_PASSWORD: 'no'
MYSQL_DATABASE: 'mayikt'
MYSQL_USER: 'mayikt'
MYSQL_PASSWORD: 'mayikt'
networks:
- mayikt_web
mayikt-web: #自己单独的springboot项目
hostname: mayikt
build: ./ #需要构建的Dockerfile文件
ports:
- "38000:8080" #容器端口映射到宿主机的端口
depends_on: #web服务依赖mysql服务,要等mysql服务先启动
- mysql
networks:
- mayikt_web
networks: ## 定义服务的桥
mayikt_web:

Spring项目配置
spring:
profiles:
active: prd
datasource:
url: jdbc:mysql://mysql:3306/mayikt?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
username: root
password: root
driver-class-name: com.mysql.jdbc.Driver
server:

端口号

port: 8080
servlet:
##设置springboot项目访问路径
context-path: /mayikt

演示效果
http://192.168.163.129:38000/mayikt/insertUser?userName=mayikt&userAge=22

Docker可视化工具使用
Portainer
Portainer是一款Docker可视化管理工具,允许我们在网页中方便的查看和管理Docker容器。
要使用Portainer很简单,运行下面两条命令即可。这些命令会创建一个Portainer专用的卷,然后在8000和9000端口创建容器并运行。

启动:
docker run -d -p 9000:9000 --name=portainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer

CentOS Docker 安装
docker rm 92 dokcer,(docker ps -aq) docker stop,第1张(docker ps -q) & docker rm 92 dokcer,(docker ps -aq) ---删除所有的容器 docker rmi,第2张(docker images -q)
docker network ls
Linux关闭防火墙命令
systemctl stop firewalld


https://www.xamrdz.com/mobile/4m51995440.html

相关文章: