保姆教程 Docker 部署微服务项目

骑着牛的奇兵 2024-08-19 11:07:04 阅读 63

大家好,我是奇兵。

文章比较长,请耐心看完!

项目上线是每位学编程同学必须掌握的基本技能。之前我已经给大家分享过很多种上线单体项目的方法了,今天再出一期微服务项目的部署教程,用一种最简单的方法,带大家轻松部署微服务项目。

开始之前,先做个小调研啊,大家更喜欢看 “真实踩坑版” 的教程还是 “压缩纯净版” 的教程呢?

本期教程我还是保持自己一贯的风格,依然是保姆级教程,包含了一些踩坑过程和解决方案,大家跟着做就完事儿~

传统部署

对于这样一个项目,如果我们还用传统单机项目的部署方式,一个个打 jar 包、用 Java 命令来启动,会有哪些问题呢?

要一个个安装依赖,比如 MySQL 数据库、Redis、消息队列、Nacos,非常麻烦!

要一个个打 jar 包、一个个手动运行 jar 包,非常麻烦!

不方便集中观察所有服务的运行状态和资源占用情况

所以,为了解决这些问题,我们会选用一种更高效的微服务部署方式 —— Docker Compose。

Docker Compose 介绍

在介绍 Docker Compose 前,先简单介绍下 Docker。

Docker 是一种容器技术,允许开发者将应用程序和所有依赖项(如代码、库、配置等)制作为 <code>镜像。可以把镜像简单理解为软件安装包,可以在不同的计算机上通过它快速安装和启动应用程序(容器),这些程序独立隔离地运行,不受外部环境的影响。

图片

如果要部署微服务项目,可能要启动多个 Docker 容器,比如 MySQL 容器、用户服务容器等。这时就需要 Docker Compose 了。它是一个容器编排助手,用于集中管理多个 Docker 容器的启动和协同工作。可以在一个配置文件中集中定义所有容器以及它们的关系。然后,可以使用一行命令启动所有容器,而不需要手动运行多个命令。

图片

需要注意的是,Docker Compose 通常适用于把所有微服务部署在同一台服务器的场景,在真实的企业级项目中,往往会使用 K8S 等更专业的容器编排和自动化部署工具,更方便地在多个服务器上部署容器。

部署流程

了解了 Docker 和 Docker Compose 的作用后,我们来快速了解下部署流程,分为 2 大阶段 —— 本地部署和服务器部署。

一、本地部署

梳理服务部署表格

Maven 子父模块打包

Dockerfile 编写

编写环境依赖配置

编写服务配置

调整程序配置

测试访问

二、服务端部署

准备服务器

Docker Compose 安装

同步文件

获取 jar 包

服务启动

测试访问

一、本地部署

第一阶段是本地部署,也可以叫做部署准备。

强烈建议大家,比起直接操作线上服务器,最好是先在本地把所有的流程跑通,风险更低、效率更高。

这里我使用的是 Mac 操作系统,已经安装了 Docker Desktop 软件,管理 Docker 容器会更方便一些。

图片

对于本地没有 Docker 环境的同学,这一阶段仔细看一遍有个印象就足够了。可以直接拿我调试好的配置文件在服务器上部署,而不用自己调试。

图片

1.1、梳理服务部署表格

在部署微服务项目前,首先要规划好要部署哪些服务、以及各服务的关键信息,比如服务名称、版本号、占用端口号、关键配置等。

对于我的在线判题项目,梳理好的服务表格如下:

服务名称 英文名 端口号 版本号 服务类别
数据库 mysql 3306 v8 环境依赖
缓存 redis 6379 v6 环境依赖
消息队列 rabbitmq 5672, 15672 v3.12.6 环境依赖
注册中心 nacos 8848 v2.2.0 环境依赖
网关服务 gateway 8101 java 8 业务服务
用户服务 yuoj-backend-user-service 8102 java 8 业务服务
题目服务 yuoj-backend-question-service 8103 java 8 业务服务
判题服务 yuoj-backend-judge-service 8104 java 8 业务服务

为什么这里我要划分服务类别为 “环境依赖” 和 “业务服务” 呢?

因为在启动服务时,必须要先启动环境依赖,才能启动业务服务,否则就会报类似 “无法连接数据库” 之类的错误。

1.2、Maven 子父模块打包

对于微服务项目,我们通常是使用 Maven 的子父模块功能进行管理的。需要部署项目时,不用针对每个子服务单独执行 <code>mvn package 命令进行打包,而是可以一键打包所有服务

想要实现这个功能,需要给子父模块的依赖文件(pom.xml)进行一些配置,主要包括:

1)父模块配置

在父模块的 pom.xml 文件中引入 spring-boot-maven-plugin 即可,注意一定不要配置 configuration 和 repackage!

示例代码如下:

<plugin>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-maven-plugin</artifactId>

    <version>${spring-boot.version}</version>

</plugin>

2)子模块配置

修改所有需要启动 Spring Boot 的服务(用户服务、题目服务、判题服务、网关服务)的子模块 pom.xml 文件。

主要是增加 executions 配置,使用 spring-boot-maven-plugin 的 repackage 命令来构建子模块,从而自动在构建时将公共模块的依赖打入 jar 包。

示例代码如下:

<plugin>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-maven-plugin</artifactId>

    <executions>

        <execution>

            <id>repackage</id>

            <goals>

                <goal>repackage</goal>

            </goals>

        </execution>

    </executions>

</plugin>

1.3、Dockerfile 编写

Dockerfile 是定义 Docker 容器镜像构建过程的文件,包括容器镜像使用的基础环境、容器内的依赖和文件、容器的配置、启动命令等。

有了 Dockerfile,我们就能很轻松地制作出自己的容器镜像。

虽然 Dockerfile 的写法并不复杂,但我还是建议大家尽量不要自己写,直接去网上找个差不多的项目,复制粘贴别人的 Dockerfile 就足够了!

给大家提供 2 种常用的 Spring Boot 项目的 Dockerfile。

1)复制 jar 包版

思路:在本地打好 jar 包后,复制 jar 包到容器中运行

示例代码如下:

# 基础镜像

FROM openjdk:8-jdk-alpine

# 指定工作目录

WORKDIR /app

# 将 jar 包添加到工作目录,比如 target/yuoj-backend-user-service-0.0.1-SNAPSHOT.jar

ADD {本地 jar 包路径} . 

# 暴露端口

EXPOSE {服务端口号}

# 启动命令

ENTRYPOINT ["java","-jar","/app/{jar 包名称}","--spring.profiles.active=prod"]

2)Maven 打包版

思路:复制本地代码到容器中,在容器中使用 Maven 打包再运行

示例代码如下:

# 基础镜像

FROM maven:3.8.1-jdk-8-slim as builder

# 指定工作目录

WORKDIR /app

# 添加源码文件

COPY pom.xml .

COPY src ./src

# 构建 jar 包,跳过测试

RUN mvn package -DskipTests

# 启动命令

ENTRYPOINT ["java","-jar","/app/target/{jar 包名称}","--spring.profiles.active=prod"]

此处由于我们的微服务项目可以一键打好所有子服务的 jar 包,就没必要每个服务单独在容器中打包了,所以选择第一种方式的 Dockerfile。

我们需要给每个 Spring Boot 服务(用户服务、题目服务、判题服务、网关服务)都编写一个 Dockerfile,放到每个子服务的根目录下。

图片

以用户服务为例,示例代码如下:

<code># 基础镜像

FROM openjdk:8-jdk-alpine

  

# 指定工作目录

WORKDIR /app

  

# 将 jar 包添加到工作目录,比如 target/yuoj-backend-user-service-0.0.1-SNAPSHOT.jar

ADD target/yuoj-backend-user-service-0.0.1-SNAPSHOT.jar .

  

# 暴露端口

EXPOSE 8102

  

# 启动命令

ENTRYPOINT ["java","-jar","/app/yuoj-backend-user-service-0.0.1-SNAPSHOT.jar","--spring.profiles.active=prod"]

建议先在本地利用 IDEA 开发工具调通镜像构建流程,确保每个 Dockerfile 都是可以成功制作镜像的:

图片

查看容器的启动日志,发现能够启动服务、看到 Spring 图标即可:

图片

1.4、编写环境依赖配置

接下来,我们就要编写 Docker Compose 的配置文件了,可以根据配置文件快速启动多个服务

之前我们已经梳理了服务部署表格,将服务划分为了 “环境依赖” 和 “业务服务”。

由于业务服务依赖 MySQL 等环境依赖,所以需要拆分 2 套 Docker Compose 的配置文件,分别为 <code>docker-compose.env.yml 环境配置和 docker-compose.service.yml 业务服务配置,保证先成功启动依赖,再启动服务。

学过 Docker Compose 的同学可能听说过 depends_on 配置,也能决定服务的启动顺序。但是千万注意,depends_on 并不会等待服务完全就绪,只是确保它们在启动时的顺序,并不稳定。

如何编写 Docker Compose 文件呢?

和 Dockerfile 一样,直接去网上找现成的 Docker Compose file,复制粘贴过来略做修改就能使用了~

再配合以下 2 个网站,完全无需记忆 Docker Compose 的写法!

Docker Compose file 官方文档:https://docs.docker.com/compose/compose-file/

搜索现成的 Docker 镜像:https://hub.docker.com/

当然,现在 AI 时代了,还有更简单的方式!

直接把我们整理好的服务部署需要喂给 GPT,让 AI 帮我们生成配置即可~

示例 prompt:

现在我需要用 docker compose 来部署 mysql 8(3306 端口)username=root,password=123456

redis 6(无密码,6379端口)、rabbitmq v.3.12.6( 5672 端口   password: guest,username: guest)、nacos 2.2.0(8848端口);还有 4 个本地的 springboot 服务(名称分别为:yuoj-backend-user-service 8102端口、yuoj-backend-question-service 8103端口、yuoj-backend-judge-service 8104端口、yuoj-backend-gateway 8101 端口),每个服务本地目录都有一个 Dockerfile,请帮我自动生成 docker compose 的 yml 配置文件,要求这些服务网络能够连通

效果还是非常不错的,只要你描述地足够清楚,生成的配置完全可用!

图片

由于这篇文章是教程嘛,我就带大家通过调试的方式一步步完成 Docker Compose 文件,最后会把完整的 Docker Compose 文件给大家分享出来,大家直接用就行了~

我们要分别在 Docker Compose 中定义 4 大基础依赖,包括 MySQL、Redis、RabbitMQ 和 Nacos。

1)MySQL

我们不仅要创建一个 MySQL 服务,还要在创建服务后自动创建我们需要的库表结构。

所以需要先准备数据库 SQL 脚本文件,里面包含了建库、建表语句,我们把它放在微服务项目根目录的 <code>mysql-init 文件夹中:

图片

由于要在本地启动 MySQL,还需要定义一个文件夹 <code>.mysql-data 来存放 MySQL 的持久化数据,防止容器重启后数据丢失。

做好这两点后,就可以编写 docker-compose.env.yml 文件了,先只写一个 MySQL 服务,示例代码如下:

关键配置的含义我都写到注释里了

version: '3'

services:

  mysql:

    image: mysql:8 # 使用的镜像

    container_name: yuoj-mysql # 启动的实例名称

    environment:

      MYSQL_ROOT_PASSWORD: 123456 # root 用户密码

    ports:

      - "3306:3306" # 端口映射

    volumes:

      - ./.mysql-data:/var/lib/mysql # 将数据目录挂载到本地目录以进行持久化

      - ./mysql-init:/docker-entrypoint-initdb.d # 自动执行启动脚本

    restart: always # 崩溃后自动重启

    networks:

      - mynetwork # 指定网络

networks:

  mynetwork: # 自定义网络,实现网络互通和隔离

写好配置文件后,可以直接在 IDEA 里执行 Docker Compose 文件,调试 MySQL 的运行:

图片

运行成功后,我们可以在本地成功连接数据库:

图片

2)Redis

Redis 服务的定义和启动操作和 MySQL 服务几乎一致,Redis 的 Docker Compose 配置示例代码如下:

<code>version: '3'

services:

  redis:

    image: redis:6

    container_name: yuoj-redis

    ports:

      - "6379:6379"

    networks:

      - mynetwork

    volumes:

      - ./.redis-data:/data # 持久化

networks:

  mynetwork:

然后在本地执行 Docker Compose 文件,启动 Redis 服务,并且尝试进入 Terminal 来调试 Redis:

图片

3)RabbitMQ

同 MySQL 和 Redis,RabbitMQ 的 Docker Compose 配置示例代码如下:

<code>version: '3'

services:

  rabbitmq:

    image: rabbitmq:3.12.6-management # 支持管理面板的消息队列

    container_name: yuoj-rabbitmq

    environment:

      RABBITMQ_DEFAULT_USER: guest

      RABBITMQ_DEFAULT_PASS: guest

    ports:

      - "5672:5672"

      - "15672:15672" # RabbitMQ Dashboard 端口

    volumes:

      - ./.rabbitmq-data:/var/lib/rabbitmq # 持久化

    networks:

      - mynetwork

networks:

  mynetwork:

本地执行 Docker Compose 文件,启动 RabbitMQ 服务,然后可以访问 localhost:15672 查看到管理面板,就表示启动成功了~

账号密码都是 guest

图片

4)Nacos

和其他服务一样,Nacos 也需要编写 Docker Compose 配置。

但是在选择 Nacos 镜像时必须要注意,建议选择支持 linux/arm64 架构的镜像版本,比如 <code>v2.2.0-slim,否则后面可能会无法运行:

图片

Nacos 示例配置文件如下:

<code>version: '3'

services:

  nacos:

    image: nacos/nacos-server:v2.2.0-slim

    container_name: yuoj-nacos

    ports:

      - "8848:8848"

    volumes:

      - ./.nacos-data:/home/nacos/data

    networks:

      - mynetwork

    environment:

      - MODE=standalone # 单节点模式启动

      - PREFER_HOST_MODE=hostname # 支持 hostname

      - TZ=Asia/Shanghai # 控制时区

networks:

  mynetwork:

然后在本地执行 Docker Compose 启动 Nacos,访问 localhost:8848/nacos 能够看到管理页面,就表示运行成功了~

管理页面的账号和密码默认都是 nacos

图片

完整 Docker Compose 文件

分别调试完上述服务后,我们把所有的配置拼在一起,就得到了完整的文件,文件名为 <code>docker-compose.env.yml。

完整代码如下:

version: '3'

services:

  mysql:

    image: mysql:8 # 使用的镜像

    container_name: yuoj-mysql # 启动的实例名称

    environment:

      MYSQL_ROOT_PASSWORD: 123456 # root 用户密码

    ports:

      - "3306:3306" # 端口映射

    volumes:

      - ./.mysql-data:/var/lib/mysql # 将数据目录挂载到本地目录以进行持久化

      - ./mysql-init:/docker-entrypoint-initdb.d # 启动脚本

    restart: always # 崩溃后自动重启

    networks:

      - mynetwork # 指定网络

  redis:

    image: redis:6

    container_name: yuoj-redis

    ports:

      - "6379:6379"

    networks:

      - mynetwork

    volumes:

      - ./.redis-data:/data # 持久化

  rabbitmq:

    image: rabbitmq:3.12.6-management # 支持管理面板的消息队列

    container_name: yuoj-rabbitmq

    environment:

      RABBITMQ_DEFAULT_USER: guest

      RABBITMQ_DEFAULT_PASS: guest

    ports:

      - "5672:5672"

      - "15672:15672" # RabbitMQ Dashboard 端口

    volumes:

      - ./.rabbitmq-data:/var/lib/rabbitmq # 持久化

    networks:

      - mynetwork

  nacos:

    image: nacos/nacos-server:v2.2.0-slim

    container_name: yuoj-nacos

    ports:

      - "8848:8848"

    volumes:

      - ./.nacos-data:/home/nacos/data

    networks:

      - mynetwork

    environment:

      - MODE=standalone # 单节点模式启动

      - PREFER_HOST_MODE=hostname # 支持 hostname

      - TZ=Asia/Shanghai # 控制时区

networks:

  mynetwork:

1.5、编写业务服务配置

用同样的方式,我们可以编写业务服务的 Docker Compose 文件,文件名称 docker-compose.service.yml

示例代码如下,其中需要格外关注的配置是 build 和 depends_on:

version: '3'

services:

  yuoj-backend-gateway:

    container_name: yuoj-backend-gateway

    build: # 服务的 Docker 构建文件位置

      context: ./yuoj-backend-gateway

      dockerfile: Dockerfile

    ports:

      - "8101:8101"

    networks:

      - mynetwork

  

  yuoj-backend-user-service:

    container_name: yuoj-backend-user-service

    build:

      context: ./yuoj-backend-user-service

      dockerfile: Dockerfile

    ports:

      - "8102:8102"

    networks:

      - mynetwork

    depends_on: # 本服务依赖的服务,控制启动先后顺序

      - yuoj-backend-gateway

  yuoj-backend-question-service:

    container_name: yuoj-backend-question-service

    build:

      context: ./yuoj-backend-question-service

      dockerfile: Dockerfile

    ports:

      - "8103:8103"

    networks:

      - mynetwork

    depends_on:

      - yuoj-backend-user-service

      - yuoj-backend-gateway

  yuoj-backend-judge-service:

    container_name: yuoj-backend-judge-service

    build:

      context: ./yuoj-backend-judge-service

      dockerfile: Dockerfile

    ports:

      - "8104:8104"

    networks:

      - mynetwork

    depends_on:

      - yuoj-backend-user-service

      - yuoj-backend-question-service

      - yuoj-backend-gateway

# 网络,不定义的话就是默认网络

networks:

  mynetwork:

1.6、调整程序配置

编写好上述配置文件后,本地尝试运行 Docker Compose 业务服务,结果发现:报错啦!依赖服务的地址访问不通!

这是由于之前我们的项目访问依赖服务时,全部是使用了固定的 IP 地址(比如 localhost),而容器内部的 localhost(或 127.0.0.1)通常指向容器本身,而不是宿主主机。所以为了在容器内访问其他服务,程序中应该使用服务名称而不是 localhost。

我们给每个 Spring Boot 服务都增加一套 prod 上线配置,在配置中更改服务调用地址。

用户服务、题目服务和判题服务的 application-prod.yml 配置修改如下:

# 生产环境配置文件

spring:

  # 数据库配置

  datasource:

    driver-class-name: com.mysql.cj.jdbc.Driver

    url: jdbc:mysql://mysql:3306/yuoj # localhost 改为 mysql

    username: root

    password: 123456

  # Redis 配置

  redis:

    database: 1

    host: redis # localhost 改为 redis

    port: 6379

    timeout: 5000

  cloud:

    nacos:

      discovery:

        server-addr: nacos:8848 # localhost 改为 nacos

  rabbitmq:

    host: rabbitmq # localhost 改为 rabbitmq

    port: 5672

    password: guest

    username: guest

Gateway 网关服务的配置修改如下:

spring:

  cloud:

    nacos:

      discovery:

        server-addr: nacos:8848 # localhost 改为 nacos

    gateway:

      routes:

        - id: yuoj-backend-user-service

          uri: lb://yuoj-backend-user-service

          predicates:

            - Path=/api/user/**

        - id: yuoj-backend-question-service

          uri: lb://yuoj-backend-question-service

          predicates:

            - Path=/api/question/**

        - id: yuoj-backend-judge-service

          uri: lb://yuoj-backend-judge-service

          predicates:

            - Path=/api/judge/**

  application:

    name: yuoj-backend-gateway

  main:

    web-application-type: reactive

server:

  port: 8101

knife4j:

  gateway:

    enabled: true

    strategy: discover

    discover:

      enabled: true

      version: swagger2

然后执行 mvn package 命令重新打包、执行 Docker Compose。

结果发现大多数服务都启动了,但是判题服务还有报错。

图片

这是因为程序在创建消息队列时存在硬编码的变量,指定了 host 为 "localhost",示例代码如下:

<code>ConnectionFactory factory = new ConnectionFactory();

factory.setHost("localhost");

Connection connection = factory.newConnection();

Channel channel = connection.createChannel();

String EXCHANGE_NAME = "code_exchange";

channel.exchangeDeclare(EXCHANGE_NAME, "direct");

举这个例子是为了告诉大家,在程序中尽量不要写固定 IP 或域名,全部改为动态读取配置文件,便于修改。

示例修改后的代码如下:

/**

 * 用于创建测试程序用到的交换机和队列(只用在程序启动前执行一次)

 */

@Slf4j

@Component

public class InitRabbitMqBean {

    @Value("${spring.rabbitmq.host:localhost}")

    private String host;

    @PostConstruct

    public void init() {

        try {

            ConnectionFactory factory = new ConnectionFactory();

            factory.setHost(host);

            Connection connection = factory.newConnection();

            Channel channel = connection.createChannel();

            String EXCHANGE_NAME = "code_exchange";

            channel.exchangeDeclare(EXCHANGE_NAME, "direct");

            // 创建队列,随机分配一个队列名称

            String queueName = "code_queue";

            channel.queueDeclare(queueName, true, false, false, null);

            channel.queueBind(queueName, EXCHANGE_NAME, "my_routingKey");

            log.info("消息队列启动成功");

        } catch (Exception e) {

            log.error("消息队列启动失败");

        }

    }

}

1.7、测试访问

修复上述问题后,所有服务都可以通过 Docker Compose 文件启动了。

然后我们访问 localhost:8101/doc.html 网关地址,能够看到 Swagger 聚合接口文档。

图片

依次调用用户注册 => 登录 => 获取登录用户信息 => 创建题目接口,全部执行成功。

至此,第一阶段就完成啦。

二、服务器部署

在第二阶段,我们的目标就是在真实的 Linux 服务器上部署微服务项目。有了第一阶段的准备,第二阶段简直可以说是易如反掌!

2.1、准备服务器

首先,我们要有一台 Linux 服务器。

选择服务器前,我们必须要评估下微服务项目的内存占用,千万别把服务器的内存买小了!

可以使用 Docker Desktop 直接查看内存占用,虚拟机内存大概占用了 8 个 G、容器实际内存占用了 4 个 G:

图片

那我们搞多少内存的服务器呢?

我猜很多同学会说 8 G,奈何我天生反骨,明知山有虎偏向虎山行(主要是想省 💰),我就搞一台 2 核 4 G 的服务器吧(发行版是 CentOS 7.9 Linux),咱们来猜一猜它够不够部署这套有 4 个业务服务的微服务项目呢?

咱们一起来见证下!

2.2、Docker Compose 安装

有了服务器后,直接参考 Docker Compose 官方文档来安装。这里我们使用 Docker Compose V2 版本,相比 V1 版本统一了命令,使用更方便:

Docker Compose V2 地址:https://docs.docker.com/compose/migrate/

Docker Compose Linux 安装:https://docs.docker.com/compose/install/linux/#install-using-the-repository

图片

安装过程很简单,跟着官方文档来就行了,主要包括以下几个步骤:

1)设定安装来源:

<code>sudo yum install -y yum-utils

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

2)安装 Docker 和 Docker Compose:

sudo yum install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

3)启动 Docker:

sudo systemctl start docker

4)测试 Docker:

systemctl status docker

sudo docker run hello-world

2.3、同步文件

接下来,我们需要把本地折腾好的微服务项目源码上传到服务器上,可以选择用 FTP 或 SSH 连接文件手动上传文件。

我这里使用 JetBrains 开发工具的远程部署功能,可以配置文件自动上传,步骤如下:

1)进入远程部署配置

图片

2)添加远程部署配置:

这里建议大家不要暴露自己的服务器 IP 啊,当你看到本文的时候,其实我已经把服务器的 IP 更换掉了哈哈哈哈哈哈哈哈!

图片

3)指定连接的服务器配置:

图片

4)配置本地文件和服务器文件路径映射:

图片

5)开启自动上传:

图片

6)首次需要手动上传文件。

上传前记得先删除无用的文件,然后右键项目根目录,点击部署上传代码:

图片

上传成功,在服务器对应路径(/code/yuoj-backend-microservice)下能看到已上传的文件列表:

图片

2.4、获取 jar 包

光把代码上传到服务器还是不够的,因为我们构建 Docker 镜像需要 jar 包。

有 2 种方式得到 jar 包:

本地执行 <code>mvn package 打好 jar 包,然后再上传

服务器上装 Maven,在服务器上打包

但是因为 jar 包比较大,频繁改动的话同步速度会比较慢,所以更建议第二种方式,步骤如下:

1)安装 Maven:

sudo yum install maven

2)安装好后,执行打包:

sudo mvn package

打包成功:

图片

2.5、服务启动

所有一切准备就绪,接下来就是使用 Docker Compose 命令分别启动环境依赖和业务服务啦。

1)启动环境依赖

先使用 docker compose 一行命令启动环境依赖:

<code>docker compose -f docker-compose.env.yml up

注意:

老版本使用 "docker-compose" 替代 "docker compose"

如果没有权限,命令前加上 "sudo"

然后喝杯咖啡,等待启动即可~

启动成功后,我们可以通过公网 IP 来尝试访问服务

先进入到云服务商的服务器配置页,修改服务器的防火墙配置,放通以下端口:

图片

然后像访问本地服务一样分别去访问 MySQL、Redis、RabbitMQ、Nacos 即可,应该都是成功的。

图片

由于进程在前台启动会影响我们的操作,所以先按 <code>ctrl + c 退出,加上 -d 参数让容器在后台启动:

sudo docker compose -f docker-compose.env.yml up -d

试着查看下 docker 容器的状态:

sudo docker stats

能够查看到所有容器的资源占用情况:

图片

实话说,我开始紧张了,不知道 4 G 的内存够不够撑。。。

2)启动业务服务

确保环境依赖都启动成功后,接下来启动业务服务:

<code>docker compose -f docker-compose.service.yml up

项目全部启动,看得很爽:

图片

正常来说,应该会启动成功;但如果运气背,可能会有失败,比如我这的网关服务就启动失败了。

如果某个服务启动失败,可以再次单独只启动它,比如网关服务:

<code>sudo docker compose -f docker-compose.service.yml up yuoj-backend-gateway

2.6、测试访问

最后,像验证本地微服务项目部署一样,访问线上网关的接口文档( http://你的服务器 IP:8101/doc.html ),依次调用用户注册 => 登录 => 获取登录用户信息 => 创建题目,全部成功~

图片

最后使用 <code>docker stats 命令查看 Docker 容器的状态,发现总共的内存占用大概 3 G,也就是说 4 G 内存的服务器是完全足够小型微服务项目的部署了~

图片

至此,微服务项目部署教程就结束了。

喜欢的话点点赞收藏一下谢谢



声明

本文内容仅代表作者观点,或转载于其他网站,本站不以此文作为商业用途
如有涉及侵权,请联系本站进行删除
转载本站原创文章,请注明来源及作者。