SpringCloud学习-实用篇03

最新推荐文章于 2024-07-25 21:38:09 发布

J___code

最新推荐文章于 2024-07-25 21:38:09 发布

阅读量1.4k

点赞数 1

分类专栏：框架学习文章标签： docker dockercompose dockerfile spring cloud

本文链接：https://blog.csdn.net/qq_41398418/article/details/130466039

版权

框架学习专栏收录该内容

33 篇文章 0 订阅

订阅专栏

以下内容的代码可见：SpringCloud_learn/day03

1.初识Docker

什么是Docker?

项目部署问题：大型项目组件较多，运行环境也较为复杂，部署时会碰到一些问题
依赖关系复杂，容易出现兼容性问题
开发、测试、生产环境有差异

Docker如何解决依赖的兼容问题？
将应用的Libs(函数库)、Deps(依赖)、配置与应用一起打包(在打好的应用包中既包含应用本身，也保护应用所需的Libs、Deps，操作系统无需再安装它们，进而解决不同应用间的兼容问题)
将每个应用放到一个隔离容器去运行，避免互相干扰

Docker解决操作系统环境差异：虽然解决了不同应用的兼容问题，但是开发、测试等环境存在差异，操作系统版本也有差异，该如何解决？

Docker将用户程序与所需要调用的系统(如Ubuntu)函数库一起打包
Docker运行到不同操作系统时，直接基于打包的函数库，借助于操作系统的Linux内核来运行

小结：

Docker如何解决大型项目依赖关系复杂，不同组件依赖的兼容性问题？
Docker允许开发中将应用、依赖、函数库、配置一起打包，形成可移植镜像
Docker应用运行在容器中，使用沙箱机制，相互隔离

Docker如何解决开发、测试、生产环境有差异的问题？
Docker镜像中包含完整运行环境，包括系统函数库，仅依赖系统的Linux内核，因此可以在任意Linux操作系统上运行

Docker是一个快速交付应用、运行应用的技术，具备下列优势：
可以将程序及其依赖、运行环境一起打包为一个镜像，可以迁移到任意Linux操作系统
运行时利用沙箱机制形成隔离容器，各个应用互不干扰
启动、移除都可以通过一行命令完成，方便快捷

tips:

要解决不同操作系统环境差异问题，必须先了解操作系统结构。以Ubuntu操作系统为例：

结构包括：

计算机硬件：例如CPU、内存、磁盘等
系统内核：所有Linux发行版的内核都是Linux，如CentOS等。内核可以与计算机硬件交互，对外提供内核指令，用于操作计算机硬件
系统应用：操作系统本身提供的应用、函数库。这些函数库是对内核指令的封装，使用更加方便

应用于计算机交互的流程如下：

应用调用操作系统应用(函数库)，实现各种功能
系统函数库是对内核指令集的封装，会调用内核指令
内核指令操作计算机硬件

Ubuntu和CentOS都是基于Linux内核，无非是系统应用不同，提供的函数库有差异。比如将一个Ubuntu版本的MySQL应用安装到CentOS系统，MySQL在调用Ubuntu函数库时会发现找不到或者不匹配导致报错

Docker与虚拟机

Docker可以让一个应用在任何操作系统中非常方便的运行。而虚拟机也能在一个操作系统中运行另外一个操作系统，保护系统中的任何应用，两者有什么差异？

虚拟机是在操作系统中模拟硬件设备，然后运行另一个操作系统，比如在Windows系统中运行Ubuntu系统进而使用具有的应用
Docker仅是封装函数库，并没有模拟完整的操作系统

综上上述，Docker和虚拟机存在以下差异：

Docker是一个系统进程；虚拟机是在操作系统中的操作系统

Docker体积小(硬盘占用为MB)、启动速度快(秒级)、性能好(接近原生)；虚拟机体积大(硬盘占用为GB)、启动速度慢(分钟级)、性能一般

Docker架构

镜像和容器：

镜像(Image)：

Docker将应用程序及其所需的依赖、函数库、环境、配置等文件打包在一起，称为镜像
即把一个应用在硬盘上的文件、及其运行环境、部分系统函数库文件一起打包形成的文件包，该文件包是只读的

容器(Container)：

镜像中的应用程序运行后形成的进程就是容器，只是Docker会给容器进程做隔离，对外不可见
即将这些文件中编写的程序、函数加载到内存中形成进程，只不过要隔离起来(比如图中的日志和数据都每个容器中都有自己的备份)

Docker和DockerHub：
DockerHub是一个Docker镜像的托管平台，称为Docker Registry
国内也有类似于DockerHub的公开服务，如网易云镜像服务、阿里云镜像库等

Docker架构：Docker是CS架构的程序，由两部分组成
服务端：Docker守护进程，负责处理Docker指令，管理和操作镜像、容器等
客户端：通过命令(本地)或RestAPI(远程)向Docker服务端发送指令，可在本地或远程向服务端发送指令

tips:

一切应用最终都是代码组成，都是硬盘中的一个个的字节形成的文件。只有运行时才会加载到内存，形成进程
一个镜像可以启动多次形成多个容器进程，比如下载一个QQ后将其在磁盘上的运行文件及其运行的操作系统依赖打包，形成QQ镜像，然后就可以多开QQ进行聊天

安装Docker

以Docker CE在CentOS上的安装为例：

卸载(可选)：

yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-selinux \
                  docker-engine-selinux \
                  docker-engine \
                  docker-ce

安装Docker：

# 安装yum工具
yum install -y yum-utils \
           device-mapper-persistent-data \
           lvm2 --skip-broken

# 设置Docker镜像源
yum-config-manager \
    --add-repo \
    https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
    
sed -i 's/download.docker.com/mirrors.aliyun.com\/docker-ce/g' /etc/yum.repos.d/docker-ce.repo

yum makecache fast

# 安装Docker 
yum install -y docker-ce

启动Docker：

# 关闭防火墙(Docker应用需要用到各种端口，逐一去修改防火墙设置)
systemctl stop firewalld
# 禁止开机启动防火墙
systemctl disable firewalld
# 启动Docker服务
systemctl start docker 
# 停止Docker服务
systemctl stop docker  
# 重启Docker服务
systemctl restart docker  
# 查看Docker版本
docker -v

配置镜像加速：参考阿里云的镜像加速文档https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors

2.Docker基本操作

镜像操作

镜像的名称组成：[repository]:[tag]，如mysql:5.7。没指定tag默认是latest，代表最新版本的镜像
镜像操作命令：
示例：

拉取、查看镜像：
# 根据在DockerHub查看到的镜像名称，拉取自己需要的镜像
docker pull nginx
# 查看拉取到的镜像
docker images
保存、导入镜像：
# 导出镜像到磁盘
docker save -o nginx.tar nginx:latest
# 加载镜像
# ①删除本地的nginx镜像
docker rmi nginx:latest
# ②加载本地文件
docker load -i nginx.tar
tips:

使用帮助文档查看命令的使用，如docker save --help

容器操作

容器相关命令：
容器保护三个状态：

运行：进程正常运行
暂停：进程暂停，CPU不再运行，并不释放内存
停止：进程终止，回收进程占用的内存、CPU等资源

命令具体含义：

docker run：创建并运行一个容器，处于运行状态
docker pause：让一个运行的容器暂停
docker unpause：让一个容器从暂停状态恢复运行
docker stop：停止一个运行的容器
docker start：让一个停止的容器再次运行
docker rm：删除一个容器
示例：

创建并运行一个容器：
# - docker run ：创建并运行一个容器
# --name : 给容器起一个名字
# -p ：将宿主机端口与容器端口映射，冒号左侧是宿主机端口，右侧是容器端口
# -d：后台运行容器
# nginx：镜像名称，例如nginx
docker run --name nginxContainer -p 80:80 -d nginx
进入容器，修改文件：

进入Nginx容器
# - docker exec ：进入容器内部，执行一个命令
# -it : 给当前进入的容器创建一个标准输入、输出终端，允许我们与容器交互
# mn ：要进入的容器的名称
# bash：进入容器后执行的命令，bash是一个linux终端交互命令
docker exec -it mn bash
修改HTML文件内容
# 进入nginx的HTML所在目录
cd /usr/share/nginx/html
# 容器内没有vi命令，无法直接修改
sed -i -e 's#Welcome to nginx#testDocker#g' -e 's#<head>#<head><meta charset="utf-8">#g' index.html
tips:

默认情况下，容器是隔离环境，直接访问宿主机的80端口肯定访问不到容器中的nginx。使用-p参数将容器的80与宿主机的80关联起来，当访问宿主机的80端口时就会被映射到容器的80：

因为镜像只有必须的依赖、函数库、环境、配置等，所以容器运行时没有vi编辑器

数据卷(容器数据管理)

在修改nginx的html页面时需要进入nginx内部，并且因为没有vi编辑器，修改文件也很麻烦，这是因为容器与数据(容器内文件)耦合带来的后果。为了解决该问题需要使用到数据卷

什么是数据卷？
数据卷(volume)是一个虚拟目录，指向宿主机文件系统中的某个目录
将容器与数据分离，解耦合，方便操作容器内数据，保证数据安全
完成数据卷挂载后对容器的一切操作都会作用在其对应的宿主机目录(比如操作宿主机的/var/lib/docker/volumes/html目录等于操作容器内的/usr/share/nginx/html目录)

数据卷操作命令：docker volume [COMMAND]
# 创建数据卷
docker volume create html
# 查看所有数据
docker volume ls
# 查看数据卷详细信息(通过其中的MountPoint可以查看到关联的宿主机目录是哪个)
docker volume inspect html
示例：给nginx挂载数据卷：需求还是创建一个nginx容器并修改容器内的html目录下的index.html内容
# 创建容器并挂载数据卷到容器内的HTML目录(把html目录所在位置/usr/share/nginx/html挂载到html数据卷上)
docker run --name mn -v html:/usr/share/nginx/html -p 80:80 -d nginx
# 进入html数据卷所在位置，并修改HTML内容
# ①查看html数据卷的位置，为/var/lib/docker/volumes/html
docker volume inspect html
# ②进入该目录
cd /var/lib/docker/volumes/html/_data
# ③修改文件(因为在本机上操作html，所以可使用vi编辑器)
vi index.html
tips:

容器不仅可以挂载数据卷，也可直接挂载到宿主机目录上：

带数据卷模式：宿主机目录 --> 数据卷 —> 容器内目录
直接挂载模式：宿主机目录 —> 容器内目录
数据卷挂载耦合度低，由docker来管理目录，但目录较深，不好找
直接挂载耦合度高，需要自己管理目录，不过目录容易寻找查看

将不同容器中的文件挂载到相同宿主机目录下即可完成数据共享

3.Dockerfile自定义镜像

镜像结构

以MySQL为例来观察**镜像(即在系统函数库、运行环境基础上，添加应用程序文件、配置文件、依赖文件等组合，然后编写好启动脚本打包在一起形成的文件，构建镜像就是实现上述打包的过程)**的组成结构：

Dockerfile语法

什么是Dockerfile？
构建自定义的镜像时，并不需要一个个文件去拷贝，打包。只需要告诉Docker镜像的组成，需要哪些BaseImage、需要拷贝什么文件、需要安装什么依赖、启动脚本是什么，将来Docker会帮助构建镜像，而描述上述信息的文件即Dockerfile文件
Dockerfile即一个文本文件，其中包含一个个的指令，用指令来说明要执行什么操作来构建镜像。每一个指令都会形成一层Layer

Dockerfile中的常见指令：
示例：基于Ubuntu镜像构建一个新镜像并运行一个java项目

构建Dockerfile文件：
# 指定基础镜像
FROM ubuntu:16.04
# 配置环境变量，JDK的安装目录
ENV JAVA_DIR=/usr/local

# 拷贝jdk和java项目的包
COPY ./jdk8.tar.gz $JAVA_DIR/
COPY ./docker-demo.jar /tmp/app.jar

# 安装JDK
RUN cd $JAVA_DIR \
 && tar -xf ./jdk8.tar.gz \
 && mv ./jdk1.8.0_144 ./java8

# 配置环境变量
ENV JAVA_HOME=$JAVA_DIR/java8
ENV PATH=$PATH:$JAVA_HOME/bin

# 暴露端口
EXPOSE 8090
# 入口，java项目的启动命令
ENTRYPOINT java -jar /tmp/app.jar
构建镜像和容器：
# -t表示为该镜像取的名称，"."代表要识别当前目录下的Dockerfile文件
docker build -t javaweb:1.0 .

# 启动容器
docker run --name web -p 8090:8090 -d javaweb:1.0
tips:

Dockerfile的第一行必须是FROM(即从一个基础镜像来构建)，并且基础镜像可以是基本操作系统，如Ubuntu，也可是其他已制作好的镜像，如java:8-alpine

4.DockerCompose

DockerCompose可以基于Compose文件帮助快速的部署分布式应用，无需手动一个个创建和运行容器

初识DockerCompose

Compose文件是一个文本文件，通过指令定义集群中的每个容器如何运行(可以简单理解为将多个docker run命令写到一个文件，只是语法稍有差异)：

version: "3.8" # Compose文件的版本

services: 
  # 运行一个基于mysql:5.7.25镜像构建的容器，并且挂载了两个目录
  mysql:
    image: mysql:5.7.25
    environment:
     MYSQL_ROOT_PASSWORD: 123 
    volumes:
     - "/tmp/mysql/data:/var/lib/mysql"
     - "/tmp/mysql/conf/hmy.cnf:/etc/mysql/conf.d/hmy.cnf"
  # 运行一个基于docker build临时构建的镜像容器，映射端口时8090
  web:
    build: .
    ports:
     - "8090:8090"

# 运行一个基于mysql:5.7.25镜像构建的容器，并且挂载了两个目录
docker run
  --name mysq1 \
  -e MYSQL ROOT PASSWORD=123 \
  -p3306:3306\
  -v /tmp/mysq1/conf/hmy.cnf:/etc/mysq1/conf.d/hmy.cnf \
  -v /tmp/mysql/data:/var/lib/mysql \
  -d \
  mysq1:5.7.25
  
# 运行一个基于docker build临时构建的镜像容器，映射端口时8090
# ①构建镜像
docker build -t web:1.0.
# ②运行容器
docker run --name web -p 8090:8090 -d web:1.0

安装DockerCompose

以CentOS 7安装DockerCompose为例：

下载：

curl -L https://github.com/docker/compose/releases/download/1.23.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

修改文件权限：

chmod +x /usr/local/bin/docker-compose

下载Base自动补全：

curl -L https://raw.githubusercontent.com/docker/compose/1.29.1/contrib/completion/bash/docker-compose > /etc/bash_completion.d/docker-compose

部署微服务集群

将SpringCloud学习-实用篇02的微服务集群利用DockerCompose进行部署，代码见day03/cloud-demo，具体步骤如下：

编写Dockerfile和DockerCompose文件：在day03/cloud-demo目录及其子目录下已经放置相应文件

修改地址：将day02/cloud-demo中的order-service、user-service、gateway服务的mysql、nacos地址修改为基于容器名的访问
spring:
  application:
    name: gateway  # 服务名称
  cloud:
    nacos:
#      server-addr: localhost:80 # nacos地址(即在Nginx中配置的代理地址)
      server-addr: nacos:80 # nacos地址(在Docker中进行部署)
打包：使用maven打包工具将项目中的day03/cloud-demo中每个微服务都打包为app.jar

<build>
    <finalName>app</finalName>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>
拷贝jar包到部署目录：将打包好的app.jar拷贝到day03/cloud-demo中的每个对应的子目录中
部署：将day03/cloud-demo上传至虚拟机，利用docker-compose up -d来部署

tips：

在day03/cloud-demo的DockerCompose文件中：
nacos：作为注册中心和配置中心
image: nacos/nacos-server：基于nacos/nacos-server镜像构建
environment：环境变量
MODE: standalone：单点模式启动

ports：端口映射，这里暴露了8848端口

mysql：数据库
image: mysql:5.7.25：镜像版本是mysql:5.7.25
environment：环境变量
MYSQL_ROOT_PASSWORD: 123：设置数据库root账户的密码为123

volumes：数据卷挂载，这里挂载了mysql的data、conf目录

userservice、orderservice、gateway：基于Dockerfile临时构建的

微服务要部署为docker容器，则每个容器间互联不是通过IP地址，而是通过容器名
不同微服务打包成相同名称的jar包不会冲突，因为生成的jar是在不同的target文件夹下的
要将项目下的每个微服务都打包，直接需要执行项目的package指令即可，无需一个个微服务单独执行该指令
部署过程中因为nacos启动较慢，所以会导致另外的微服务无法正常部署，此时需要重新部署未成功启动的服务：
docker-compose restart gateway userservice orderservice

5.Docker镜像仓库

镜像仓库(DockerRegistry)有公共的和私有的两种形式：

公共仓库：例如Docker官方的Docker Hub，国内有网易云镜像服务、DaoCloud镜像服务、阿里云镜像服务等
私有仓库：除了使用公开仓库外，用户还可以在本地搭建私有DockerRegistry(企业自己的镜像最好是采用私有仓库来实现)

搭建私有镜像仓库

简化版镜像仓库：Docker官方的Docker Registry是一个基础版本的Docker镜像仓库，具备仓库管理的完整功能，但没有图形化界面，搭建方式比较简单
docker run -d \
    --restart=always \
    --name registry	\
    -p 5000:5000 \
    -v registry-data:/var/lib/registry \
    registry
带有图形化界面版本：

编写DockerCompose文件：
version: '3.0'
services:
  registry:
    image: registry
    volumes:
      - ./registry-data:/var/lib/registry
  ui:
    image: joxit/docker-registry-ui:static
    ports:
      - 8080:80
    environment:
      - REGISTRY_TITLE=psj私有仓库
      - REGISTRY_URL=http://registry:5000
    depends_on:
      - registry
部署DockerCompose：执行docker-compose up -d
访问私有仓库：即访问http://IP地址:8080
tips：

搭建镜像仓库可以基于Docker官方提供的Docker Registry来实现
私服采用的是http协议，默认不被Docker信任，需要在daemon.json文件中完成以下配置：
# 打开要修改的文件
vi /etc/docker/daemon.json
# 添加内容：
"insecure-registries":["http://IP地址:8080"]
# 重加载
systemctl daemon-reload
# 重启docker
systemctl restart docker

向镜像仓库推送镜像

推送镜像到私有镜像服务必须先tag，步骤如下：

重新tag本地镜像，名称前缀为私有仓库的地址：
docker tag nginx:latest IP地址:8080/nginx:1.0
推送镜像：
docker push IP地址:8080/nginx:1.0 

从镜像仓库拉取镜像

docker pull IP地址:8080/nginx:1.0

参考

黑马程序员SpringCloud框架P42-P60

Dockerfile中的指令参考官网：https://docs.docker.com/engine/reference/builder/

DockerCompose的详细语法参考官网：https://docs.docker.com/compose/compose-file/

官方提供的DockerRegistry：https://hub.docker.com/_/registry