devbox
Gausst松鼠会
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

记录一次分布式微服务架构搭建过程_bladex架构图

作者：Gausst松鼠会 | 2024-03-23 17:12:47

赞

踩

bladex架构图

一、目标架构图

 
其中，nacos，nginx，mysql，mq，redis，gateway，服务均为集群模式。使用docker模拟集群分布。

 

  • Spring Boot 2.3.9.RELEASE
  • Spring Cloud H版
  • Cloud Alibaba 2.2.5.RELEASE
  • RabbitMq 3.7.14
  • Redis 5.0
  • mysql 5.7.*
  • Docker 18.09.0
  • JWT 0.9.0
  • Lombok 1.18.6
  • Maven 5.1



二、环境部署

所有的环境都是在服务器上用docker模拟分布式集群的方式搭建的



1.docker安装

 curl -sSL https://get.daocloud.io/docker | sh
在服务器终端中运行该指令



2.数据库



2.1docker安装mysql数据库5.7



2.1.1搭建单体数据库

1. 拉取 MySQL 镜像
docker pull mysql:5.7

2. 设置 MySQL 配置文件
将全部的配置文件和关联的文件夹统一放到 /opt/docker/mysql 中
创建 MySQL 配置文件文件夹
mkdir -p /opt/docker/mysql/conf.d
增加并修改配置文件 config-file.cnf
vim /opt/docker/mysql/conf.d/config-file.cnf
输入如下内容：

 

  1. [mysqld]
  2. # 设置表名不区分大小写 linux下默认是区分的，windows下默认不区分
  3. lower_case_table_names=1 
  4. #server-id=1
  5. datadir=/var/lib/mysql
  6. #socket=/var/lib/mysql/mysqlx.sock
  7. #symbolic-links=0
  8. # sql_mode=NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES 
  9. [mysqld_safe]
  10. log-error=/var/log/mysqld.log
  11. pid-file=/var/run/mysqld/mysqld.pid
 

3. 启动
 创建 MySQL 数据文件夹
 mkdir -p /opt/docker/mysql/var/lib/mysql
 启动，设置默认密码 root，TZ 设置容器的默认时区
 docker run —name mysql \
 —restart=always \
 -p 3306:3306 \
 -v /opt/docker/mysql/conf.d:/etc/mysql/conf.d \
 -v /opt/docker/mysql/var/lib/mysql:/var/lib/mysql \
 -e MYSQL_ROOT_PASSWORD=root \
 -e TZ=Asia/Shanghai \
 -d mysql:5.7
 

4. 修改密码
 

 

  1. docker exec -it mysql bash
  2. 进入 MySQL
  3. mysql -uroot -p
  4. 输入刚才我们设置的密码 root
  5. 授权
  6. mysql> GRANT ALL ON *.* TO 'root'@'%';
  7. 刷新权限
  8. mysql> flush privileges;
  9. 更新加密规则
  10. mysql> ALTER USER 'root'@'localhost' IDENTIFIED BY 'root' PASSWORD EXPIRE NEVER;
  11. 更新 root 密码
  12. mysql> ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY '123456';
  13. 刷新权限
  14. mysql> flush privileges;
  15. 查看用户
  16. mysql> use mysql;mysql> select user,host from user;
  17. 退出容器
  18. exit
 

有此条记录即成功
 

 
 navicat链接数据库测试，成功。
 

 



 2.1.2搭建主从mysql数据库，且读写分离
 

直接docker启动两个mysql容器，分别叫mysql-master和mysql-slave；从数据库映射到3302端口。
  
 进入主数据库，安装vim，编辑my.cnf文件如下
 

 

  1. [mysqld]
  2. log-bin=/var/log/mysql/mysql-bin
  3. server-id=1
  4. gtid_mode=ON
  5. enforce_gtid_consistency=1 # 强制执行GTID一致性。
 

 
 
如果省略server-id（或将其显式设置为默认值0），则主服务器拒绝来自从服务器的任何连接。如果省略server-id（或将其显式设置为默认值0），则主服务器拒绝来自从服务器的任何连接。
 

 

创建日志目录并赋予权限
 

 

  1. mkdir /var/log/mysql
  2. chown mysql.mysql /var/log/mysql
 

重启服务:systemctl restart mysqld
 创建一个专门用于复制数据的用户
 

每个从服务器需要使用MySQL 主服务器上的用户名和密码连接到主站。计划使用用户 repl 可以从任何主机上连接到 master 上进行复制操作, 并且用户 repl 仅可以使用复制的权限。
 

创建repl用户
CREATE USER 'repl'@'%' IDENTIFIED BY '123456789';
 用户名：repl
 主机：使用通配符%，允许任意远程主机登陆
 密码：123456789
 

对repl用户进行授权
GRANT REPLICATION SLAVE ON *.* TO 'repl'@'%';
 在从库测试用户有效性
mysql -urepl -p'123456789' -h192.168.0.101
 

之后再配置从库的my.cnf
 vim /etc/my.cnf
 

 

  1. [mysqld]
  2. server-id=2
  3. gtid_mode=ON
  4. enforce_gtid_consistency=1
  6. # 可选项, 把连接到 master 的信息存到数据库中的表中
  7. master-info-repository=TABLE
  8. relay-log-info-repository=TABLE
  9. read_only=1#可以设置只读
 

重启从数据库服务
 systemctl restart mysqld
 开启Master-Slave主从复制
 进入Master库mysql客户端：输入show master status查看Master状态：
 

  1. change master to master_host='172.18.0.3',
  2. master_user='slave', 
  3. master_password='123456', 
  4. master_port=3306, 
  5. master_log_file='master-bin.000001', 
  6. master_log_pos=617, 
  7. master_connect_retry=30;
 

在从数据库中执行start slave;开启主从
show slave status \G查看主从状态。
 



 2.2执行nacos数据库的脚本
 

新建数据库nacos
 之后运行sql脚本
 脚本地址：nacos/nacos-mysql.sql at develop · alibaba/nacos · GitHub
 



 3.nacos集群搭建
 

  • docker拉取nacos镜像:docker pull nacos/nacos-server:2.0.3
  • 依次启动三个nacos服务，分别以8846，8847，8848端口启动
     下面是docker compose脚本
 

 

  1. version: "3"
  3. services: 
  4. nacos1:
  5. container_name: nacos-server01
  6. hostname: nacos-server01
  7. image: nacos/nacos-server:2.0.3
  8. environment: 
  9. - MODE=cluster
  10. - PREFER_HOST_MODE=hostname
  11. - NACOS_SERVERS=nacos-server01:8848 nacos-server02:8848 nacos-server03:8848
  12. - SPRING_DATASOURCE_PLATFORM=mysql
  13. - MYSQL_SERVICE_HOST=你的mysql 地址
  14. - MYSQL_SERVICE_PORT=3306
  15. - MYSQL_SERVICE_USER=root
  16. - MYSQL_SERVICE_PASSWORD=123456
  17. - MYSQL_SERVICE_DB_NAME=nacos
  18. - JVM_XMS=256m
  19. - JVM_XMX=256m
  20. - JVM_XMN=256m
  21. volumes: 
  22. - /home/nacos/cluster-logs/nacos-server01:/home/nacos/logs
  23. - /home/nacos/init.d:/home/nacos/init.d
  24. ports: 
  25. - 8846:8848
  26. - 9555:9555
  27. - 9847:9849
  28. restart: on-failure
  30. nacos2:
  31. container_name: nacos-server02
  32. hostname: nacos-server02
  33. image: nacos/nacos-server:2.0.3
  34. environment: 
  35. - MODE=cluster
  36. - PREFER_HOST_MODE=hostname
  37. - NACOS_SERVERS=nacos-server01:8848 nacos-server02:8848 nacos-server03:8848
  38. - SPRING_DATASOURCE_PLATFORM=mysql
  39. - MYSQL_SERVICE_HOST=你的mysql地址
  40. - MYSQL_SERVICE_PORT=3306
  41. - MYSQL_SERVICE_USER=root
  42. - MYSQL_SERVICE_PASSWORD=123456
  43. - MYSQL_SERVICE_DB_NAME=nacos
  44. - JVM_XMS=256m
  45. - JVM_XMX=256m
  46. - JVM_XMN=256m
  47. volumes: 
  48. - /home/nacos/cluster-logs/nacos-server02:/home/nacos/logs
  49. - /home/nacos/init.d:/home/nacos/init.d
  50. ports: 
  51. - 8847:8848
  52. - 9848:9849
  53. restart: on-failure
  55. nacos3:
  56. container_name: nacos-server03
  57. hostname: nacos-server03
  58. image: nacos/nacos-server:2.0.3
  59. environment: 
  60. - MODE=cluster
  61. - PREFER_HOST_MODE=hostname
  62. - NACOS_SERVERS=nacos-server01:8848 nacos-server02:8848 nacos-server03:8848
  63. - SPRING_DATASOURCE_PLATFORM=mysql
  64. - MYSQL_SERVICE_HOST=你的mysql地址
  65. - MYSQL_SERVICE_PORT=3306
  66. - MYSQL_SERVICE_USER=root
  67. - MYSQL_SERVICE_PASSWORD=123456
  68. - MYSQL_SERVICE_DB_NAME=nacos
  69. - JVM_XMS=128m
  70. - JVM_XMX=128m
  71. - JVM_XMN=128m
  72. volumes: 
  73. - /home/nacos/cluster-logs/nacos-server03:/home/nacos/logs
  74. - /home/nacos/init.d:/home/nacos/init.d
  75. ports: 
  76. - 8848:8848
  77. - 9849:9849
  78. restart: on-failure
 

 
 
8848端口是nacos后台管理界面的端口，9849端口是nacos集群之间互相通信需要的端口。 为了三个nacos的通信，必须映射到宿主机。
 

 

运行上面的docker文件，创建docker容器
docker-compose -f cluster-hostname.yaml up -d
 访问三个nacos服务，查看是否配置成功。
 

还要使用nignx来做nacos集群的负载均衡
 Nginx 的部署与其他服务部署略有不同，我们需要先启动一个 Nginx 容器实例，然后从容器事例中拷贝出 Nginx 的配置文件到指定目录，之后我们将复制出的配置文件与 Nginx 容器的数据卷进行挂载，从而达到可以在容器外部修改配置文件的目的。这么做是因为，如果直接挂载，那么容器实例中的的目录将会被外部的挂载所覆盖。这是官方 Nginx 镜像的一个小缺陷，注意一下就行了。
 

 

  1. 运行 Nginx 容器
  2. $ docker run --name temp-nginx -p 8080:8080 -d nginx:latest
  3. 在宿主机创建 Nginx 的挂载目录
  4. # 实际创建时以自己的机器环境为准
  5. $ mkdir -p <宿主机挂载目录>
  6. 拷贝容器中的配置到宿主机的挂载目录
  7. $ docker cp <Nginx容器ID>:/etc/nginx/ <宿主机挂载目录>
  8. 停止并删除容器实例
  9. $ docker stop <Nginx容器ID>
  10. $ docker rm <Nginx容器ID>
 

修改 Nginx 配置文件
 

位置：<宿主机挂载目录>/conf.d/default.conf
 

配置文件主要修改两个部分，一个是新增 upstream，通过负载均衡来配置 Nacos 服务的节点；第二个是修改 server 下的 location，在其中添加反向代理配置。另外，如果你的 Nginx 没有配置过 server_name，那么还需要修改 server 下的 server_name 配置。
 

完整配置文件如下：
 

 

  1. # 添加负载均衡配置
  2. upstream nacos {
  3. server 服务器地址:8846 weight=2 max_fails=2 fail_timeout=10s;
  4. server 服务器地址:8847 weight=2 max_fails=2 fail_timeout=10s;
  5. server 服务器地址:8848 weight=1 max_fails=2 fail_timeout=10s;
  6. }
  8. server {
  9. listen 80;
  10. listen [::]:80;
  11. # 修改为宿主机的 IP地址
  12. server_name 服务器地址;
  14. #access_log /var/log/nginx/host.access.log main;
  16. location / {
  17. # 添加代理配置
  18. proxy_pass http://nacos;
  19. proxy_set_header Host $host;
  20. proxy_set_header X-Real-IP $remote_addr;
  21. proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
  22. proxy_set_header REMOTE-HOST $remote_addr;
  23. add_header X-Cache $upstream_cache_status;
  24. add_header Cache-Control no-cache;
  26. #root /usr/share/nginx/html;
  27. #index index.html index.htm;
  28. }
  30. #error_page 404 /404.html;
  32. # redirect server error pages to the static page /50x.html
  33. #
  34. error_page 500 502 503 504 /50x.html;
  35. location = /50x.html {
  36. root /usr/share/nginx/html;
  37. }
  39. # proxy the PHP scripts to Apache listening on 127.0.0.1:80
  40. #
  41. #location ~ \.php$ {
  42. # proxy_pass http://127.0.0.1;
  43. #}
  45. # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
  46. #
  47. #location ~ \.php$ {
  48. # root html;
  49. # fastcgi_pass 127.0.0.1:9000;
  50. # fastcgi_index index.php;
  51. # fastcgi_param SCRIPT_FILENAME /scripts$fastcgi_script_name;
  52. # include fastcgi_params;
  53. #}
  55. # deny access to .htaccess files, if Apache's document root
  56. # concurs with nginx's one
  57. #
  58. #location ~ /\.ht {
  59. # deny all;
  60. #}
  61. }
 

编排 Nginx启动文件
 

 

  1. version: "3"
  3. services: 
  4. nacos-nginx: 
  5. container_name: nacos-nginx
  6. image: nginx:latest
  7. volumes: 
  8. - /home/naocs-nginx:/etc/nginx
  9. ##注意这里容器挂在的位置
  10. ports: 
  11. - 18848:80
  12. restart: on-failure
 

访问http://服务器ip:18848/nacos/ 查看效果
 



 4.构造生产者消费者服务测试
 



 4.1父工程创建
 

在本机上下载安装idea2021（具体方法baidu）
 新建父工程cloud-demo
 打开pom文件，在properties中控制整个项目的版本
 

 

  1. <properties>
  2. <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  3. <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  4. <java.version>1.8</java.version>
  5. <spring-cloud.version>Hoxton.SR8</spring-cloud.version>
  6. <mysql.version>5.1.47</mysql.version>
  7. <mybatis.version>2.1.1</mybatis.version>
  8. </properties>
 

依赖管理
 

 

  1. <dependencyManagement>
  2. <dependencies>
  3. <!-- springCloud -->
  4. <dependency>
  5. <groupId>org.springframework.cloud</groupId>
  6. <artifactId>spring-cloud-dependencies</artifactId>
  7. <version>${spring-cloud.version}</version>
  8. <type>pom</type>
  9. <scope>import</scope>
  10. </dependency>
  11. <!--nacos的管理依赖-->
  12. <dependency>
  13. <groupId>com.alibaba.cloud</groupId>
  14. <artifactId>spring-cloud-alibaba-dependencies</artifactId>
  15. <version>2.2.5.RELEASE</version>
  16. <type>pom</type>
  17. <scope>import</scope>
  18. </dependency>
  19. <!-- mysql驱动 -->
  20. <dependency>
  21. <groupId>mysql</groupId>
  22. <artifactId>mysql-connector-java</artifactId>
  23. <version>${mysql.version}</version>
  24. </dependency>
  25. <!--mybatis-->
  26. <dependency>
  27. <groupId>org.mybatis.spring.boot</groupId>
  28. <artifactId>mybatis-spring-boot-starter</artifactId>
  29. <version>${mybatis.version}</version>
  30. </dependency>
  31. </dependencies>
  32. </dependencyManagement>
  33. <dependencies>
  34. <dependency>
  35. <groupId>org.projectlombok</groupId>
  36. <artifactId>lombok</artifactId>
  37. </dependency>
  38. </dependencies>
 



 4.2生产者服务集群配置
 

新建module：service-provider1
 修改pom文件，在resources中新建application.yml文件。新建启动类。写一个简单的接口，如下。
 

 

  1. server:
  2. port: 9001
  3. spring:
  4. datasource:
  5. url: jdbc:mysql://10.245.153.168:3306/cloud_order?useSSL=false
  6. username: root
  7. password: 123456
  8. driver-class-name: com.mysql.jdbc.Driver
  9. application:
  10. name: service-provider
  11. cloud:
  12. nacos:
  13. server-addr: 10.245.153.168:18848 # nacos服务地址
  15. @SpringBootApplication
  16. @EnableDiscoveryClient
  17. public class TestServiceMain {
  18. public static void main(String[] args) {
  19. SpringApplication.run(TestServiceMain.class,args);
  20. }
  21. }
  23. @RestController
  24. public class TestController {
  26. @GetMapping(value = "/test/gethello")
  27. public String getHello(){
  28. return "hello,service provider 1";
  29. }
  30. }
 

再仿照service-provider1创造项目service-provider2。记得修改端口为9002
 



 4.3消费者服务配置
 

很简单就是用openfeign同步调用生产者的接口。不要忘记也将消费者注册进nacos。
 



 4.4上传到服务器
 

使用的docker来运行springboot程序
 maven clear;
 maven install;
 将jar包命名为service-provider1，service-provider2，上传到服务器，用指令sudo rz。
 之后拉取一个有java运行环境的镜像。
 

 

  1. docker run -d --name service-provider1 -p 9001:9001 -p 19001:19001 \
  2. -v /mydata/service-provider1.jar:/usr/app.jar java:8 \
  3. java -jar -Xms256m -Xmx256m /usr/app.jar
  5. docker run -d --name service-provider2 -p 9002:9002 -p 19002:19002 \
  6. -v /mydata/service-provider2.jar:/usr/app.jar java:8 \
  7. java -jar -Xms256m -Xmx256m /usr/app.jar
 



 5.GateWay网关集群
 

由于是测试，就先搭建一个集群，里面运行两个网关服务
 



 5.1新建项目
 

module名：gateway
 选择本机的jdk1.8，创建一个空白的maven项目。设置项目坐标gav，其中groupid为父工程groupid
  
 在pom文件中导入依赖
 

 

  1. <dependencies>
  2. <!--nacos服务注册发现依赖-->
  3. <dependency>
  4. <groupId>com.alibaba.cloud</groupId>
  5. <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  6. </dependency>
  7. <!--网关gateway依赖-->
  8. <dependency>
  9. <groupId>org.springframework.cloud</groupId>
  10. <artifactId>spring-cloud-starter-gateway</artifactId>
  11. </dependency>
  12. </dependencies>
 

编写application.yml文件,启动的端口为10010
 

 

  1. server:
  2. port: 10010
  3. logging:
  4. level:
  5. cn.itcast: debug
  6. pattern:
  7. dateformat: MM-dd HH:mm:ss:SSS
  8. spring:
  9. application:
  10. name: gateway
  11. cloud:
  12. nacos:
  13. server-addr: 10.245.153.168:18848 # nacos地址
  14. gateway:
  15. routes:
  16. default-filters:
  17. - AddRequestHeader=Truth,Itcast is freaking awesome!
  18. - AddRequestHeader=origin,gateway
 

创建主启动类
  
 写一个权限过滤器组件
 

 

  1. @Component
  2. public class AuthorizeFilter implements GlobalFilter, Ordered {
  3. @Override
  4. public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
  5. // 1.获取请求参数
  6. ServerHttpRequest request = exchange.getRequest();
  7. MultiValueMap<String, String> params = request.getQueryParams();
  8. // 2.获取参数中的 authorization 参数
  9. String auth = params.getFirst("authorization");
  10. // 3.判断参数值是否等于 admin
  11. if ("admin".equals(auth)) {
  12. // 4.是，放行
  13. return chain.filter(exchange);
  14. }
  15. // 5.否，拦截
  16. // 5.1.设置状态码
  17. exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
  18. // 5.2.拦截请求
  19. return exchange.getResponse().setComplete();
  20. }
  22. @Override
  23. public int getOrder() {
  24. return -1;
  25. }
  26. }
 

在创建一个几乎完全相同的子项目gateway2，但是启动端口为10011，服务名不要改动
 

在两个网关服务中的yml文件里新增路由配置：
 



 5.2启动测试
 

启动编写的网关集群，查看nacos服务列表
  
 通过网关访问下我们的服务提供者


 可见服务调用默认为轮询策略
 



 5.3上传jar包到服务器测试
 

将gateway与gateway2进行一些maven install来生成jar包，然后用rz指令上传的服务器
  
 我们都知道jar是运行在java环境中，所以只要容器中有java环境就可以运行jar包，镜像方式运行的原理也是如此。因此我们基于java镜像就可以实现jar包运行。
 拉取java镜像
docker pull java:8
 之后使用docker运行jar包
 

 

  1. docker run -d --name gateway1 -p 10010:10010 \
  2. -v /mydata/gateway1.jar:/usr/app.jar java:8 \
  3. java -jar -Xms256m -Xmx256m /usr/app.jar
  5. docker run -d --name gateway2 -p 10011:10011 \
  6. -v /mydata/gateway2.jar:/usr/app.jar java:8 \
  7. java -jar -Xms256m -Xmx256m /usr/app.jar
 

运行完后查看下效果
  

 可见，gateway网关运行在的docker上时，显示的ip为docker中的虚拟ip，可以在application.yml文件中添加属性：
spring.cloud.nacos.discovery.ip:外网ip来修改。
 



 5.4用nginx做负载均衡
 

类比做nacos集群的负载均衡，方法是一样的。
 需要注意的是nginx配置文件要挂在到gateway-nginx文件夹下，防止产生冲突。
 



 6.sentinel服务降级,流量控制
 



 6.1安装
 

拉取镜像
 docker pull bladex/sentinel-dashboard
 运行docker file
 

 

  1. docker run -dit \
  2. --name sentinel-nacos \
  3. -p 18858:8858 \
  4. --restart=always \
  5. -e NACOS_SERVER_ADDR=10.245.153.168:18848 \
  6. -e NACOS_USERNAME=nacos \
  7. -e NACOS_PASSWORD=nacos \
  8. -e NACOS_NAMESPACE=public \
  9. -e NACOS_GROUP_ID=SENTINEL_GROUP \
  10. bladex/sentinel-dashboard
 

访问http://你的ip:18858/ ， 输入用户名密码都是sentinel
 看看后台页面
  
 将之前的service-provider1项目进行sentinel流控，修改yml文件
 



 注意，由于我们的sentinel运行在服务器里的docker中，故要添加spring.cloud.sentinel.transport.client-ip属性，该属性为你的电脑的公网ip，也就是service-provider1项目运行在的主机的ip
 运行起项目，访问几次gethello接口

 添加一个流控规则，在看看访问接口的反应
 



 6.2持久化规则
 

当我们一旦重启sentinel应用,sentinel写的规则消失,生产环境需要将配置规则进行持久化。
 在我们之前建立的service-provider1项目中的pom文件里 ，添加依赖
  
 yml文件中，添加
 



 在nacos配置中心新增配置

注意属性的一一对应
 运行下sentinel，访问刚才添加配置的接口，规则成功

 再重启sentinel，发现规则还在。
 

 
 
只能通过Nacos修改规则配置，通过Dashboard修改规则配置不自动刷新Nacos配置，重启Dashboard后只保留Nacos中数据！！！
 

 



 6.4到目前为止的项目架构
 

 



 7.redis
 



 7.1redis集群方式
 

1.主从复制
 2.哨兵集群
 3.redis-cluster集群
 我们本次使用redis主从复制的形式搭建redis集群
 什么是主从复制？
 答：就是指将一台Redis服务器的数据，复制到其他的Redis服务器。前者称为主节点(master)，后者称为从节点(slave),数据的复制是单向的，只能由主节点到从节点。默认情况下，每台Redis服务器都是主节点，且一个主节点可以有多个从节点(或没有从节点)，但一个从节点只能有一个主节点。给大家个图来理解下：
  
 主从复制有什么作用？
 

答：①：数据冗余：主从复制实现了数据的热备份，是持久化之外的一种数据冗余方式。
 

②：故障恢复：当主节点出现问题时，可以由从节点提供服务，实现快速的故障恢复；实际上是一种服务的冗余。换句话说就是主服务器挂掉了，从服务器顶上去。
 

③：负载均衡：在主从复制的基础上，配合读写分离，可以由主节点提供写服务，由从节点提供读服务（即写Redis数据时应用连接主节点，读Redis数据时应用连接从节点），分担服务器负载；尤其是在写少读多的场景下，通过多个从节点分担读负载，可以大大提高Redis服务器的并发量。
 



 7.2开始搭建
 

目标：一主，一从，测试用
 先拉取镜像
 docker run —name redis-master -d -p 16379:6379 redis:latest
 docker run —name redis-master -d -p 16380:6379 redis:latest
 使用指令docker exec 和redis-cli
 分别进入两个redis数据库，查看ip信息输入info
 

 

  1. 172.17.0.4
  2. 172.17.0.5
 

我们把172.17.0.5作为随从数据库，在其reids终端中输入
 SLAVEOF 主ip 主端口（均是前面的ip与端口）
 之后再用info指令查看是否修改成功。
  
  
 



 7.3测试
 

我们在主节点设置一个属性 set name : why
 我们在从随从节点获取 get name ： why
 成功
  
 



 7.4进一步扩展
 

可以在部署哨兵模式或者分片集群模式。
 



 8.rabbitMQ消息队列
 



 8.1RabbitMQ安装（单机版）
 

在线拉取镜像
 

 

  1. docker pull rabbitmq:3-management
 

执行下面的命令来运行MQ容器
 

 

  1. docker run \
  2. -e RABBITMQ_DEFAULT_USER=admin \
  3. -e RABBITMQ_DEFAULT_PASS=123456 \
  4. --name mq \
  5. --hostname mq1 \
  6. -p 15672:15672 \
  7. -p 5672:5672 \
  8. -d \
  9. rabbitmq:3-management
 

启动成功后访问地址：http://服务器ip:15672
 按照上面的用户名密码登录
 

 



 8.2RabbitMQ安装（集群版）
 

在RabbitMQ的官方文档中，讲述了两种集群的配置方式：
 

  • 普通模式：普通模式集群不进行数据同步，每个MQ都有自己的队列、数据信息（其它元数据信息如交换机等会同步）。例如我们有2个MQ：mq1，和mq2，如果你的消息在mq1，而你连接到了mq2，那么mq2会去mq1拉取消息，然后返回给你。如果mq1宕机，消息就会丢失。
  • 镜像模式：与普通模式不同，队列会在各个mq的镜像节点之间同步，因此你连接到任何一个镜像节点，均可获取到消息。而且如果一个节点宕机，并不会导致数据丢失。不过，这种方式增加了数据同步的带宽消耗。
 

我们先来看普通模式集群，我们的计划部署两节点的mq集群：
 | mq1 | 15672 —-> 15672 | 5672 —-> 5672 |
 | mq2 | 15673 —-> 15672 | 5673 —-> 5672 |
 集群中的节点标示默认都是：rabbit@[hostname]，因此以上三个节点的名称分别为：
 
 

获取cookie值
 RabbitMQ底层依赖于Erlang，而Erlang虚拟机就是一个面向分布式的语言，默认就支持集群模式。集群模式中的每个RabbitMQ 节点使用 cookie 来确定它们是否被允许相互通信。
 要使两个节点能够通信，它们必须具有相同的共享秘密，称为Erlang cookie。cookie 只是一串最多 255 个字符的字母数字字符。
 每个集群节点必须具有相同的 cookie。实例之间也需要它来相互通信。
 我们先在之前启动的mq容器中获取一个cookie值，作为集群的cookie。执行下面的命令：
 

 

  1. docker exec -it mq cat /var/lib/rabbitmq/.erlang.cookie
 

可以看到cookie值如下：
  
 HGANYJSVWWMCPJXVSYHG
 接下来，停止并删除当前的mq容器，我们重新搭建集群。
 在/tmp目录新建一个配置文件 rabbitmq.conf：
 

 

  1. cd /tmp
  2. # 创建文件
  3. touch rabbitmq.conf
 

文件内容如下：
 

 

  1. loopback_users.guest = false
  2. listeners.tcp.default = 5672
  3. cluster_formation.peer_discovery_backend = rabbit_peer_discovery_classic_config
  4. cluster_formation.classic_config.nodes.1 = rabbit@mq1
  5. cluster_formation.classic_config.nodes.2 = rabbit@mq2
 

再创建一个文件，记录cookie
 

 

  1. # 创建cookie文件
  2. touch .erlang.cookie
  3. # 写入cookie
  4. echo "HGANYJSVWWMCPJXVSYHG" > .erlang.cookie
  5. # 修改cookie文件的权限
  6. chmod 600 .erlang.cookie
 

准备目录,mq1、mq2：
 

 

  1. cd /tmp
  2. # 创建目录
  3. mkdir mq1 mq2
 

然后拷贝rabbitmq.conf、cookie文件到mq1、mq2：
 

 

  1. # 进入/tmp
  2. cd /tmp
  3. # 拷贝
  4. cp rabbitmq.conf mq1
  5. cp rabbitmq.conf mq2
  6. cp .erlang.cookie mq1
  7. cp .erlang.cookie mq2
 

创建一个网络：
 

 

  1. docker network create mq-net
 

运行命令
 

 

  1. docker run -d --net mq-net \
  2. -v ${PWD}/mq1/rabbitmq.conf:/etc/rabbitmq/rabbitmq.conf \
  3. -v ${PWD}/.erlang.cookie:/var/lib/rabbitmq/.erlang.cookie \
  4. -e RABBITMQ_DEFAULT_USER=whycast \
  5. -e RABBITMQ_DEFAULT_PASS=123456 \
  6. --name mq1 \
  7. --hostname mq1 \
  8. -p 5672:5672 \
  9. -p 15672:15672 \
  10. rabbitmq:3-management
 

 

  1. docker run -d --net mq-net \
  2. -v ${PWD}/mq2/rabbitmq.conf:/etc/rabbitmq/rabbitmq.conf \
  3. -v ${PWD}/.erlang.cookie:/var/lib/rabbitmq/.erlang.cookie \
  4. -e RABBITMQ_DEFAULT_USER=whycast \
  5. -e RABBITMQ_DEFAULT_PASS=123456 \
  6. --name mq2 \
  7. --hostname mq2 \
  8. -p 5673:5672 \
  9. -p 15673:15672 \
  10. rabbitmq:3-management
 

测试
 在mq1这个节点上添加一个队列：
 

 

如图，在mq2控制台也都能看到：
 

 
 
到此为止，普通版集群已经部署成功，但是普通模式集群不进行数据同步，每个MQ都有自己的队列、数据信息（其它元数据信息如交换机等会同步）。例如我们有2个MQ：mq1，和mq2，如果你的消息在mq1，而你连接到了mq2，那么mq2会去mq1拉取消息，然后返回给你。如果mq1宕机，消息就会丢失。
 

 



 8.3仲裁队列
 

从RabbitMQ 3.8版本开始，引入了新的仲裁队列，他具备与镜像队里类似的功能，但使用更加方便。
 在任意控制台添加一个队列，一定要选择队列类型为Quorum类型。
  
 因为仲裁队列默认的镜像数为5。如果你的集群有7个节点，那么镜像数肯定是5；而我们集群只有2个节点，因此镜像数量就是2.
 此时停掉mq1，mq2中还存在该队列。
 



 9.Oauth2.0鉴权
 

待续
 

10.nginx 通过 keepalived 实现高可用
 



 10.1体系架构
 

在Keepalived + Nginx高可用负载均衡架构中，keepalived负责实现High-availability (HA) 功能控制前端机VIP（虚拟网络地址），当有设备发生故障时，热备服务器可以瞬间将VIP自动切换过来，实际运行中体验只有2秒钟切换时间，DNS服务可以负责前端VIP的负载均衡。
 nginx负责控制后端web服务器的负载均衡，将客户端的请求按照一定的算法转发给后端处理，而Real Server将响应直接返回给客户端。
 



 10.2简单原理
 

nginx-master、nginx-slave两台服务器均通过keepalived软件把你的网卡绑上一个虚拟IP（VIP）地址192.168.200.199，此VIP当前由谁承载着，服务就绑定在谁的网卡上，当nginx-master发生故障时，nginx-slave会通过keepalived配置文件中设置的心跳时间advert_int检查，无法获取nginx-master正常状态的话，keepalived首先会执行脚本来重启nginx-master，重启仍然失败，会切换到备机运行。nginx-slave会瞬间绑定VIP来接替nginx_master的工作，当nginx-master恢复后keepalived会通过priority参数判断优先权将虚拟VIP地址192.168.200.199重新绑定给nginx-master的网卡。
 



 10.3使用此方案的优越性
 

1.实现了可弹性化的架构，在压力增大的时候可以临时添加web服务器添加到这个架构里面去;
 2.upstream具有负载均衡能力，可以自动判断后端的机器，并且自动踢出不能正常提供服务的机器；
 3.相对于lvs而言，正则分发和重定向更为灵活。而Keepalvied可保证单个nginx负载均衡器的有效性，避免单点故障；
 4.用nginx做负载均衡，无需对后端的机器做任何改动。
 5.nginx部署在docker容器里，即大量地节约开发、测试、部署的时间，又可以在出现故障时通过镜像快速恢复业务。
 



 10.4部署
 

1.准备两台服务器，都安装好docker
 

2.docker pull nginx #这里获取的是最新的 nginx
 

3.创建文件夹用于使用自己定义的配置文件以及日志文件
 

 

  1. mkdir -p /mydata/docker/nginx # 配置文件
  2. #docker 起一个nginx来获取配置文件
  3. docker run --name temp-nginx -p 80:80 -d nginx:latest
  4. #拷贝配置文件
  5. $ docker cp temp-nginx:/etc/nginx/ /mydata/docker/
  7. 之后再删除刚才的容器
 

4.在 /mydata/docker/nginx 目录下修改配置文件: vi nginx.conf，再修改conf.d下的default.conf文件
 

 

  1. user root;
  2. worker_processes auto;
  4. error_log /var/log/nginx/error.log notice;
  5. pid /var/run/nginx.pid;
  8. events {
  9. worker_connections 1024;
  10. }
  13. http {
  14. include /etc/nginx/mime.types;
  15. default_type application/octet-stream;
  17. log_format main '$remote_addr - $remote_user [$time_local] "$request" '
  18. '$status $body_bytes_sent "$http_referer" '
  19. '"$http_user_agent" "$http_x_forwarded_for"';
  21. access_log /var/log/nginx/access.log main;
  23. sendfile on;
  24. #tcp_nopush on;
  26. keepalive_timeout 65;
  28. #gzip on;
  30. include /etc/nginx/conf.d/*.conf;
  31. }
 

 

  1. upstream gateway {
  2. server 10.245.153.169:10010 weight=1 max_fails=2 fail_timeout=5s;
  3. server 10.245.153.169:10011 weight=1 max_fails=2 fail_timeout=5s;
  4. }
  6. server {
  7. listen 80;
  8. listen [::]:80;
  9. # 修改为宿主机的 IP地址
  10. server_name 10.245.153.169;
  12. #access_log /var/log/nginx/host.access.log main;
  14. location / {
  15. # 添加代理配置
  16. proxy_pass http://gateway;
  17. proxy_set_header Host $host;
  18. proxy_set_header X-Real-IP $remote_addr;
  19. proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
  20. proxy_set_header REMOTE-HOST $remote_addr;
  21. add_header X-Cache $upstream_cache_status;
  22. add_header Cache-Control no-cache;
  24. #root /usr/share/nginx/html;
  25. #index index.html index.htm;
  26. }
  28. #error_page 404 /404.html;
  30. # redirect server error pages to the static page /50x.html
  31. #
  32. error_page 500 502 503 504 /50x.html;
  33. location = /50x.html {docker
  34. root /usr/share/nginx/html;
  35. }
  37. # proxy the PHP scripts to Apache listening on 127.0.0.1:80
  38. #
  39. #location ~ \.php$ {
  40. # proxy_pass http://127.0.0.1;
  41. #}
  43. # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
  44. #
  45. #location ~ \.php$ {
  46. # root html;
  47. # fastcgi_pass 127.0.0.1:9000;
  48. # fastcgi_index index.php;
  49. # fastcgi_param SCRIPT_FILENAME /scripts$fastcgi_script_name;
  50. # include fastcgi_params;
  51. #}
  53. # deny access to .htaccess files, if Apache's document root
  54. # concurs with nginx's one
  55. #
  56. #location ~ /\.ht {
  57. # deny all;
  58. #}
  59. }
 

5.在 /mydata/docker/nginx/html 目录下创建首页(仅仅是后面用来判断请求落在了哪个机器上，主机和备机能区分开就行): vi index.html
Master machine
 

6.启动nginx
 

 

  1. docker run --name nginx-master --privileged=true --restart=always -p 80:80 \
  2. -v /mydata/docker/nginx:/etc/nginx \
  3. -v /mydata/docker/nginx/html:/usr/share/nginx/html \
  4. -d nginx:latest
  6. docker run --name nginx-slave --privileged=true --restart=always -p 80:80 \
  7. -v /mydata/docker/nginx:/etc/nginx \
  8. -v /mydata/docker/nginx/html:/usr/share/nginx/html \
  9. -d nginx:latest
 

由于都是启动的80端口，故可以直接用ip+接口名来访问
  
 可见，成功代理。
 下面就要引入keepalived进行高可用
 7.安装keepalived插件
 这里不用docker，直接在服务器终端里输入以下指令
yum install keepalived -y
 进入/etc/keepalived/下 vi keepalived.conf
 下面是运行着nginx-master容器的服务器的配置
 

 

  1. global_defs {
  2. notification_email {
  3. acassen@firewall.loc
  4. failover@firewall.loc
  5. sysadmin@firewall.loc
  6. }
  8. notification_email_from Alexandre.Cassen@firewall.loc #定义利用什么邮箱发送邮件
  9. smtp_server smtp.163.com #定义邮件服务器信息
  10. smtp_connect_timeout 30 #定义邮件发送超时时间
  11. router_id 10.245.153.168 #（重点参数）局域网keppalived主机身份标识信息(每台唯一)
  12. script_user root #添加运行健康检查脚本的用户
  13. enable_script_security #添加运行健康检查脚本的组
  14. }
  16. vrrp_script chk_http_port {
  17. script "/usr/local/src/nginx_check.sh" #表示将一个脚本信息赋值给变量check_web,down机后就运行这个文件
  18. interval 5 #检测脚本执行的间隔
  19. weight -20 #监测失败，则相应的vrrp_instance的优先级会减少20个点，这样主服务器会切换
  20. }
  22. vrrp_instance VI_1 {
  23. state MASTER #keepalived角色描述信息，备份服务器上将 MASTER 改为 BACKUP
  24. interface ens192 #将虚拟ip用于那块网卡
  25. virtual_router_id 51 #主、备机的 virtual_router_id 必须相同
  26. priority 100 #主、备机取不同的优先级，主机值较大，备份机值较小取90
  27. advert_int 1 #主服务器组播包发送间隔时间
  29. authentication { # 主备主机之间的认证表示信息
  30. auth_type PASS #采用明文认证机制
  31. auth_pass 1111 #编写明文密码
  32. }
  33. virtual_ipaddress {
  34. 服务器所在网段未分配的ip地址 #设置虚拟ip地址信息，此参数备节点设置和主节点相同
  35. }
  36. track_script {
  37. chk_http_port #调用执行脚本
  38. }
  39. }
 

添加检查nginx状态的脚本vim /usr/local/src/nginx_check.sh
 

 

  1. #!/bin/bash
  3. # 传入容器名称
  4. containerName=nginx-slave
  5. currTime=`date +"%Y-%m-%d %H:%M:%S"`
  7. # 查看进程是否存在
  8. exist=`docker inspect --format '{{.State.Running}}' ${containerName}`
  10. if [ "${exist}" != "true" ]; then
  11. pkill keepalived #杀死所有keepalived服务进程
  13. # 记录
  14. echo "${currTime} docker容器宕机，容器名称：${containerName}" >> /mnt/xvde1/ms_ctynyd/scripts/wbwf_monitor.log
  16. fi
 

 
 
一定要给这个脚本文件可执行权限（看到变成可执行的颜色），执行命令：chmod u+x /usr/local/src/nginx_check.sh
 

 

之后，在两台服务器上分别执行systemctl restart keepalived.service命令。开启keepalived插件。
 访问我们之前设置的虚拟ip发现可以访问成功
 

之后shutdown掉一个nginx，看看keepalived插件能否进行vip的迁移。还能够访问到我们的服务，成功。
 



 11.jmeter进行压力测试
 



 11.1测试最外层nginx转发能力
 

 

 
 
压力配置均以上图所示进行。
 

 

访问虚拟ip，两个nginx+keepalived，来进行转发请求。
  
 5000个线程的请求有14个超时未连接
 

 

直接通过网关访问请求
  
 请求异常率大幅降低，但是响应时间最大值非常高
 

从上面两组测试对比可以知道，处理请求并发量受到nginx集群转发速度的影响。
 上网查阅资料找到，可以在nginx.conf中修改nginx处理并发请求的能力
  
 图中worker_connection值本来是1024，修改成为8192，再次测试查看结果。

 异常率降低到零。说明1s内5000线程量的请求完全可以接受。
 提高到两万

 提高到三万


 这是异常率变高，且请求响应时间大幅增加。
 



 11.2测试mq集群抗压能力

                

        
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/296506
推荐阅读
相关标签
Copyright ©  2003-2013 www.wpsshop.cn  版权所有，并保留所有权利。

  
闽ICP备14008679号