云计算百科
云计算领域专业知识百科平台
当前位置：网硕互联帮助中心 > 服务器百科 > 正文

常见的微服务架构介绍，包括包含缓存数据库redis，消息队列 RabbitMQ，日志管理ELK，使用docker服务容器，且采用热部署，搭建这个微服务器的安装配置 以及部署应用服务，日志监控，消息监控

2025-05-14 分类：服务器百科 阅读(2) 评论(0)

构建一个完整的微服务架构涉及多个组件和技术栈，下面是一个详细的指南，涵盖常见的微服务架构组件（如 Redis、RabbitMQ、ELK Stack、Docker、热部署等），以及如何配置和部署这些组件。

1. 微服务架构概述

微服务架构将应用程序分解为一组小的、独立的服务，每个服务运行在自己的进程中，并通过轻量级机制（通常是 HTTP API）进行通信。这些服务可以独立部署、扩展和维护。

常见微服务架构组件

  • 服务注册与发现：Eureka、Consul、Zookeeper
  • 配置中心：Spring Cloud Config、Apollo
  • API 网关：Spring Cloud Gateway、Kong
  • 服务调用：Feign、RestTemplate
  • 熔断器：Hystrix、Resilience4j
  • 缓存数据库：Redis
  • 消息队列：RabbitMQ、Kafka
  • 日志管理：ELK Stack（Elasticsearch, Logstash, Kibana）
  • 容器化：Docker
  • 编排工具：Kubernetes
  • 热部署：Spring Boot DevTools、JRebel

2. 使用的技术栈

  • 编程语言：Java (Spring Boot)
  • 缓存数据库：Redis
  • 消息队列：RabbitMQ
  • 日志管理：ELK Stack (Elasticsearch, Logstash, Kibana)
  • 容器化：Docker
  • 编排工具：Docker Compose (简化部署)
  • 热部署：Spring Boot DevTools

3. 微服务架构示例

假设我们有一个简单的微服务架构，包含以下服务：

  • User Service：用户管理服务
  • Order Service：订单管理服务
  • Product Service：产品管理服务
  • API Gateway：统一入口

3.1 服务注册与发现

使用 Eureka 作为服务注册与发现中心。

3.1.1 创建 Eureka Server

pom.xml

xml

<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>
</dependencies>

application.yml

yaml

server:
port: 8761

eureka:
client:
register-with-eureka: false
fetch-registry: false
service-url:
defaultZone: http://localhost:8761/eureka/

EurekaServerApplication.java

java

package com.example.eurekaserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {
public static void main(String[] args) {
SpringApplication.run(EurekaServerApplication.class, args);
}
}

3.2 API Gateway

使用 Spring Cloud Gateway 作为 API 网关。

3.2.1 创建 API Gateway 服务

pom.xml

xml

<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
</dependencies>

application.yml

yaml

server:
port: 8080

spring:
application:
name: api-gateway
cloud:
gateway:
routes:
– id: user-service
uri: lb://user-service
predicates:
– Path=/users/**
– id: order-service
uri: lb://order-service
predicates:
– Path=/orders/**
– id: product-service
uri: lb://product-service
predicates:
– Path=/products/**
eureka:
client:
service-url:
defaultZone: http://localhost:8761/eureka/

ApiGatewayApplication.java

java

package com.example.apigateway;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
public class ApiGatewayApplication {
public static void main(String[] args) {
SpringApplication.run(ApiGatewayApplication.class, args);
}
}

3.3 User Service

3.3.1 创建 User Service

pom.xml

xml

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
</dependency>
</dependencies>

application.yml

yaml

server:
port: 0

spring:
application:
name: user-service
datasource:
url: jdbc:h2:mem:testdb
driver-class-name: org.h2.Driver
username: sa
password:
jpa:
hibernate:
ddl-auto: update
show-sql: true

eureka:
client:
service-url:
defaultZone: http://localhost:8761/eureka/

User.java

java

package com.example.userservice.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private String email;

// Getters and Setters
}

UserRepository.java

java

package com.example.userservice.repository;

import com.example.userservice.model.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
}

UserController.java

java

package com.example.userservice.controller;

import com.example.userservice.model.User;
import com.example.userservice.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/users")
public class UserController {

@Autowired
private UserRepository userRepository;

@GetMapping
public List<User> getAllUsers() {
return userRepository.findAll();
}

@PostMapping
public User createUser(@RequestBody User user) {
return userRepository.save(user);
}
}

UserServiceApplication.java

java

package com.example.userservice;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
public class UserServiceApplication {
public static void main(String[] args) {
SpringApplication.run(UserServiceApplication.class, args);
}
}

3.4 Order Service 和 Product Service

Order Service 和 Product Service 的结构与 User Service 类似，只需更改 application.yml 中的服务名称和端口。

Order Service application.yml

yaml

server:
port: 0

spring:
application:
name: order-service
datasource:
url: jdbc:h2:mem:testdb
driver-class-name: org.h2.Driver
username: sa
password:
jpa:
hibernate:
ddl-auto: update
show-sql: true

eureka:
client:
service-url:
defaultZone: http://localhost:8761/eureka/

Product Service application.yml

yaml

server:
port: 0

spring:
application:
name: product-service
datasource:
url: jdbc:h2:mem:testdb
driver-class-name: org.h2.Driver
username: sa
password:
jpa:
hibernate:
ddl-auto: update
show-sql: true

eureka:
client:
service-url:
defaultZone: http://localhost:8761/eureka/

4. 使用 Redis 作为缓存数据库

4.1 添加 Redis 依赖

在每个服务的 pom.xml 中添加 Redis 依赖：

xml

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

4.2 配置 Redis

在 application.yml 中配置 Redis 连接：

yaml

spring:
redis:
host: localhost
port: 6379

4.3 使用 Redis 进行缓存

在 User Service 中使用 Redis 进行缓存示例：

UserCacheService.java

java

package com.example.userservice.service;

import com.example.userservice.model.User;
import com.example.userservice.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class UserCacheService {

@Autowired
private UserRepository userRepository;

@Cacheable(value = "users", key = "#id")
public User getUserById(Long id) {
return userRepository.findById(id).orElse(null);
}
}

UserServiceApplication.java 启用缓存：

java

package com.example.userservice;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
@EnableCaching
public class UserServiceApplication {
public static void main(String[] args) {
SpringApplication.run(UserServiceApplication.class, args);
}
}

5. 使用 RabbitMQ 作为消息队列

5.1 添加 RabbitMQ 依赖

在每个服务的 pom.xml 中添加 RabbitMQ 依赖：

xml

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

5.2 配置 RabbitMQ

在 application.yml 中配置 RabbitMQ 连接：

yaml

spring:
rabbitmq:
host: localhost
port: 5672
username: guest
password: guest

5.3 使用 RabbitMQ 发送和接收消息

在 Order Service 中发送消息示例：

OrderService.java

java

package com.example.orderservice.service;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class OrderService {

@Autowired
private AmqpTemplate amqpTemplate;

public void sendOrder(String order) {
amqpTemplate.convertAndSend("orderQueue", order);
}
}

在 User Service 中接收消息示例：

UserReceiver.java

java

package com.example.userservice.receiver;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class UserReceiver {

@RabbitListener(queues = "orderQueue")
public void receiveMessage(String order) {
System.out.println("Received order: " + order);
}
}

6. 使用 ELK Stack 进行日志管理

6.1 安装 ELK Stack

使用 Docker Compose 安装 ELK Stack：

docker-compose.yml

yaml

version: '3'
services:
elasticsearch:
image: docker.elastic.co/elasticsearch/elasticsearch:7.10.2
container_name: elasticsearch
environment:
– discovery.type=single-node
ports:
– "9200:9200"
– "9300:9300"

logstash:
image: docker.elastic.co/logstash/logstash:7.10.2
container_name: logstash
volumes:
– ./logstash/pipeline:/usr/share/logstash/pipeline/
ports:
– "5044:5044"
depends_on:
– elasticsearch

kibana:
image: docker.elastic.co/kibana/kibana:7.10.2
container_name: kibana
ports:
– "5601:5601"
depends_on:
– elasticsearch

logstash/pipeline/logstash.conf

conf

input {
beats {
port => 5044
}
}

output {
elasticsearch {
hosts => ["http://elasticsearch:9200"]
index => "%{[@metadata][beat]}-%{[@metadata][version]}-%{+YYYY.MM.dd}"
}
}

启动 ELK Stack：

bash

docker-compose up -d

6.2 配置 Spring Boot 应用程序使用 Filebeat

在每个 Spring Boot 应用程序中添加 Filebeat 配置：

filebeat.yml

yaml

filebeat.inputs:
– type: log
enabled: true
paths:
– /var/log/*.log

output.logstash:
hosts: ["logstash:5044"]

在 Docker Compose 文件中添加 Filebeat 服务：

docker-compose.yml

yaml

version: '3'
services:
# 其他服务…

filebeat:
image: docker.elastic.co/beats/filebeat:7.10.2
container_name: filebeat
volumes:
– ./filebeat/filebeat.yml:/usr/share/filebeat/filebeat.yml
– /var/log:/var/log
depends_on:
– logstash

7. 使用 Docker 容器化服务

7.1 创建 Dockerfile

为每个服务创建 Dockerfile。以 User Service 为例：

Dockerfile

Dockerfile

FROM openjdk:17-jdk-slim
VOLUME /tmp
COPY target/user-service.jar user-service.jar
ENTRYPOINT ["java", "-jar", "/user-service.jar"]

7.2 构建 Docker 镜像

在每个服务目录下构建 Docker 镜像：

bash

mvn clean package
docker build -t user-service .

7.3 使用 Docker Compose 部署服务

创建 docker-compose.yml 文件来定义所有服务：

docker-compose.yml

yaml

version: '3'
services:
eureka-server:
image: eureka-server:latest
ports:
– "8761:8761"
networks:
– microservices-network

api-gateway:
image: api-gateway:latest
ports:
– "8080:8080"
networks:
– microservices-network
depends_on:
– eureka-server

user-service:
image: user-service:latest
networks:
– microservices-network
depends_on:
– eureka-server
– redis
– rabbitmq

order-service:
image: order-service:latest
networks:
– microservices-network
depends_on:
– eureka-server
– redis
– rabbitmq

product-service:
image: product-service:latest
networks:
– microservices-network
depends_on:
– eureka-server
– redis
– rabbitmq

redis:
image: redis:6.2
ports:
– "6379:6379"
networks:
– microservices-network

rabbitmq:
image: rabbitmq:3-management
ports:
– "5672:5672"
– "15672:15672"
networks:
– microservices-network

elasticsearch:
image: docker.elastic.co/elasticsearch/elasticsearch:7.10.2
container_name: elasticsearch
environment:
– discovery.type=single-node
ports:
– "9200:9200"
– "9300:9300"
networks:
– microservices-network

logstash:
image: docker.elastic.co/logstash/logstash:7.10.2
container_name: logstash
volumes:
– ./logstash/pipeline:/usr/share/logstash/pipeline/
ports:
– "5044:5044"
depends_on:
– elasticsearch
networks:
– microservices-network

kibana:
image: docker.elastic.co/kibana/kibana:7.10.2
container_name: kibana
ports:
– "5601:5601"
depends_on:
– elasticsearch
networks:
– microservices-network

filebeat:
image: docker.elastic.co/beats/filebeat:7.10.2
container_name: filebeat
volumes:
– ./filebeat/filebeat.yml:/usr/share/filebeat/filebeat.yml
– /var/log:/var/log
depends_on:
– logstash
networks:
– microservices-network

networks:
microservices-network:
driver: bridge

7.4 构建并启动所有服务

构建所有服务的 Docker 镜像：

bash

docker-compose build

启动所有服务：

bash

docker-compose up -d

8. 配置负载均衡

8.1 使用 Nginx 作为负载均衡器

创建一个 Nginx 配置文件来负载均衡 API Gateway 实例。

nginx.conf

nginx

events {
worker_connections 1024;
}

http {
upstream api-gateway {
server api-gateway-1:8080;
server api-gateway-2:8080;
# 可以根据需要添加更多 API Gateway 实例
}

server {
listen 80;

location / {
proxy_pass http://api-gateway;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
}
}

8.2 使用 Docker Compose 启动 Nginx

在 docker-compose.yml 中添加 Nginx 服务：

yaml

version: '3'
services:
# 其他服务…

nginx:
image: nginx:latest
container_name: nginx
ports:
– "80:80"
volumes:
– ./nginx/nginx.conf:/etc/nginx/nginx.conf
depends_on:
– api-gateway
networks:
– microservices-network

启动所有服务后，Nginx 将会自动将请求分发到多个 API Gateway 实例，实现负载均衡。

9. 日志监控与消息监控

9.1 日志监控

使用 ELK Stack 进行日志管理。通过 Kibana 的可视化界面，可以实时查看和分析日志数据。

9.1.1 查看日志
  • 打开浏览器，访问 http://localhost:5601。
  • 登录 Kibana 后，选择“Discover”选项卡。
  • 选择相应的索引模式（如 filebeat-*），即可查看所有日志。
    • 9.1.2 创建仪表盘
  • 在 Kibana 中选择“Dashboard”选项卡。
  • 点击“Create new dashboard”，然后添加各种图表和可视化组件。
  • 通过这些图表可以监控日志中的错误、警告等信息。

    • 9.2 消息监控

    使用 RabbitMQ Management Plugin 监控 RabbitMQ 中的消息队列。

    9.2.1 启用 RabbitMQ 管理插件

    在 Docker Compose 文件中已经启用了 RabbitMQ 管理插件，可以通过以下命令手动启用：

    bash

    docker exec -it rabbitmq rabbitmq-plugins enable rabbitmq_management

    9.2.2 访问 RabbitMQ 管理界面
  • 打开浏览器，访问 http://localhost:15672。
  • 使用默认的用户名和密码 guest/guest 登录。
  • 在管理界面中可以查看队列状态、消息数量、消费者连接等信息。

    • 10. 热部署配置

    热部署允许在不重启应用程序的情况下更新代码。这里我们使用 Spring Boot DevTools 来实现热部署。

    10.1 添加 DevTools 依赖

    在每个 Spring Boot 应用程序的 pom.xml 中添加 DevTools 依赖：

    xml

    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
    </dependency>

    10.2 配置 IDE 支持

    10.2.1 IntelliJ IDEA
  • 打开项目设置，进入“Build, Execution, Deployment” -> “Compiler”。
  • 勾选“Build project automatically”。
  • 按下 Ctrl + Shift + A，输入“Registry”，打开 Registry 设置。
  • 勾选 compiler.automake.allow.when.app.running。
    • 10.2.2 Eclipse
  • 打开 Window -> Preferences -> General -> Workspace。
  • 勾选“Build automatically”。

    • 10.3 测试热部署

  • 修改任意服务中的代码（例如 UserController.java）。
  • 保存修改后，Spring Boot 应用程序会自动重新加载更改的部分。
  • 访问相关接口，验证新代码是否生效。

    • 11. 总结

    通过上述步骤，我们构建了一个完整的微服务架构，涵盖了服务注册与发现、API 网关、缓存数据库 Redis、消息队列 RabbitMQ、日志管理 ELK Stack、容器化 Docker、负载均衡 Nginx 以及热部署等功能。这个架构不仅能够满足高并发、分布式系统的开发需求，还提供了强大的监控和运维能力，确保系统的稳定性和可扩展性。

    赞(0)
    未经允许不得转载：网硕互联帮助中心 » 常见的微服务架构介绍，包括包含缓存数据库redis，消息队列 RabbitMQ，日志管理ELK，使用docker服务容器，且采用热部署，搭建这个微服务器的安装配置 以及部署应用服务，日志监控，消息监控
    分享到： 更多 (0)
    标签：

    相关推荐

    评论 抢沙发

    评论前必须登录！

     

    热门标签

    服务器(3306)运维(1968)linux(984)网络(419)美国站群服务器(308)香港云服务器(305)租用香港服务器(301)香港服务器(298)香港站群服务器租用(298)租用香港站群服务器(294)香港服务器租用(293)人工智能(290)香港站群服务器(289)美国云服务器(286)香港VPS(280)美国服务器租用(279)美国服务器(276)java(246)python(236)ubuntu(193)c++(184)数据库(176)前端(174)windows(172)开发语言(159)docker(156)tcp/ip(152)ssh(137)网络协议(121)nginx(117)

    置顶推荐

    热门文章

    最新文章