SpringCloud微服务注册中心：Nacos介绍，微服务注册，Ribbon通信，Ribbon负载均衡，Nacos配置管理详细介绍

微服务注册中心

注册中心可以说是微服务架构中的”通讯录“，它记录了服务和服务地址的映射关系。在分布式架构中，服务会注册到这里，当服务需要调用其它服务时，就这里找到服务的地址，进行调用。

微服务注册中心

服务注册中心（简称注册中心）是微服务框架的一个重要组件，在微服务架构里主要起到了协调者的一个作用，注册中心一般包括如下几个功能：

1. 注册发现：
   • 服务注册/反注册：保证服务提供者和服务调用者的信息
   • 服务订阅/取消订阅：服务调用者订阅服务提供者的信息，最好有实时推送的功能
   • 服务路由（可选）：具有筛选整合服务提供者的能力
2. 服务配置：
   • 配置订阅：服务提供者和服务调用者订阅微服务相关的配置
   • 配置下发：主动将配置托送给服务提供者和服务调用者
3. 服务监控检测：
   • 检测服务提供者的健康情况

常见的注册中心

• Zookeeper

  zookeeper它是一个分布式服务框架，是Apache Hadoop 的一个子项目，它主要是用来解决分布式应用中经常遇到的一些数据管理问题，如：统一命名服务、状态同步、集群管理、分布式应用配置项的管理等。简单来说zookeeper=文件系统+监听通知机制

• Eureka

  Eureka是Java语言上，基于Restful Api开发的服务注册与发现组件，SpringCloud Netflix 中的重要组件

• Consul

  Consul是由HashiCorp基于Go语言开发的支持多数据中心分布式高可用的服务发布和注册服务软件，采用Raft算法保证服务的一致性，并且支持健康检查

• Nacos

  Nacos是一个更易于构建云原生应用的动态服务发现，配置管理和服务平台，简单来说Nacos就是注册中心+配置中心的组合，提供简单易用的特征集，帮助我们解决微服务开发必会涉及到的服务注册与发现，服务配置，服务管理等问题。Nacos还是Spring Cloud Alibaba 组件之一，负责服务注册与发现

Eureka闭源影响：

在Eureka的GitHub上，宣布Eureka 2.x闭源。意味着如果开发者继续使用作为2.x分支上现有的工作时，自负风险

Nacos简介

Nacos致力于帮助您发现，配置和管理微服务。Nacos提供了一组简单易用的特征集，帮助您快速实现动态服务发现，服务配置，服务元数据及流量管理。Nacos的作用就是一个注册中心，用来管理注册上来的各个微服务

• Nacos下载地址

  https://github.com/alibaba/nacos/releases,下载zip格式的安装包，解压安装

• Nacos的启动

  命令启动：

  # 切换目录
  cd nacos/bin
  # 命令启动
  startup.cmd -m standalone
  1
  2
  3
  4

  双击启动startup.cmd 运行

  Nacos启动浏览器访问http://localhost:8848/nacos即可访问服务，默认的账号密码是nacos/nacos

项目中搭建Nacos

基于原来的项目搭建Nacos

• 将shop_product商品微服务注册到Nacos

实现步骤：

1. pom文件中添加Nacos依赖

   
   
   <dependency>
       <groupId>com.alibaba.cloudgroupId>
       <artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
   dependency>
   1
   2
   3
   4
   5
   6

2. 在启动类上添加@EnableDiscoveryClient注解

   @SpringBootApplication
   @EnableDiscoveryClient
   public class ShopOrderApplication {
       public static void main(String[] args) {       SpringApplication.run(ShopOrderApplication.class, args);
       }
   }
   1
   2
   3
   4
   5
   6

3. 在application.yaml中添加Nacos服务的地址

   server:
     port: 8081
   spring:
     application:
       name: service-product   # 注册到服务中心中的名字
     datasource:
       driver-class-name: com.mysql.cj.jdbc.Driver
       url: jdbc:mysql:///shop?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
       username: root
       password: 123456
     # 配置nacos
     cloud:
       nacos:
         discovery:
           server-addr: localhost:8848
           #server-addr: nacos服务地址:端口号
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16

4. 启动服务，观察Nacos的控制面板中是否有注册上来的商品微服务

   

   刷新nacos，能看到注册的微服务即注册成功

• 将shop_order订单微服务注册到Nacos

实现步骤：

1. 在pom文件添加nacos的依赖

   
   
   <dependency>
       <groupId>com.alibaba.cloudgroupId>
       <artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
   dependency>
   1
   2
   3
   4
   5
   6

2. 在启动类上添加@EnableDiscoveryClient注解

   @SpringBootApplication
   @EnableDiscoveryClient
   public class ShopOrderApplication {
       public static void main(String[] args) {       SpringApplication.run(ShopOrderApplication.class, args);
       }
   }
   1
   2
   3
   4
   5
   6

3. 在application.yaml中添加nacos服务的地址

   server:
     port: 8091
   spring:
   	application:
       name: service-order   # 注册到服务中心中的名字
     datasource:
       driver-class-name: com.mysql.cj.jdbc.Driver
       url: jdbc:mysql:///shop?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
       username: root
       password: 123456
     cloud:
       nacos:
         discovery:
           server-addr: 127.0.0.1:8848
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14

4. 启动服务，观察nacos的控制面板中是否有注册上来的订单微服务,同shop_product

服务调用Ribbon入门

经过以上的学习，已经实现了服务的注册和服务发现。当启动某个服务的时候，可以通过HTTP的形式将信息注册到注册中心，并且可以通过SpringCloud提供的工具获取注册中心的服务列表。但是服务之间的调用还存在很多的问题，如何更加方便的调用微服务，多个微服务的提供者如何选择，如何负载均衡等

Ribbon的概述

是Netflixfa 发布的一个负载均衡器，有助于控制 HTTP 和 TCP客户端行为。在 SpringCloud 中，Nacos一般配合Ribbon进行使用，Ribbon提供了客户端负载均衡的功能，Ribbon利用从Nacos中读取到的服务信息，在调用服务节点提供的服务时，会合理的进行负载。
在SpringCloud中可以将注册中心和Ribbon配合使用，Ribbon自动的从注册中心中获取服务提供者的列表信息，并基于内置的负载均衡算法，请求服务

Ribbon的主要作用

1. 服务调用

   基于Ribbon实现服务调用，是通过拉取到的所有服务列表组成(服务名-请求路径的)映射关系。借助RestTemplate最终进行调用

2. 负载均衡

   当有多个服务提供者时，Ribbon可以根据负载均衡的算法自动的选择需要调用的服务地址

基于Ribbon实现服务调用

需求：基于Ribbon实现订单调用商品的服务

实现步骤：

1. 坐标依赖

   在springcloud提供的服务发现的jar中已经包含了Ribbon的依赖。所以在这不需要子啊导入任何额外的坐标

2. 工程改造

   服务消费者（服务的调用者）

   在注入RestTemplate的方法上添加注解==@LoadBalanced==注解

   @Configuration
   public class RestTemplateConfig {
       @Bean
       @LoadBalanced
       public RestTemplate getRestTemplate(){
           return new RestTemplate();
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8

   通过服务名称消费使用

   @RestController
   @RequestMapping("/order")
   public class OrderController {
       @Autowired(required = false)
       private IOrderService orderService;
   
       @Autowired(required = false)
       private RestTemplate restTemplate;
   
       // 模拟下订单业务
       @RequestMapping("/save/{pid}")
       public Order order (@PathVariable("pid") int pid) {
           // 调用商品的微服务
           String url = "service-product";
           Product product = restTemplate.getForObject("http://"+ url +"/product/" + pid, Product.class);
   
           // 创建订单
           Order order = new Order();
           order.setUid(1);
           order.setUsername("测试用户");
           order.setPid(pid);
           order.setPname(product.getPname());
           order.setPprice(product.getPprice());
           order.setNumber(1);
           orderService.save(order);
           return order;
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28

   注意：restTemplate.getForObject(“http://商品服务名称/product/1”+pid，Product.class)

   这里的商品服务名称是：注册商品服务时的名称，即shop_product的yaml配置文件中的application.name

   路径是根据shop_product中通过id查询商品的路径编写

服务调用Ribbon高级

负载均衡概述

在搭建网对时，如果单节点的 web服务性能和可靠性都法达到要求；或者是在使用外网服务时，经常担心被人攻破，一不小就会有打开外网端口的情况，通常这时加人负载有就能有效
决服务问题。
负载均衡是一种基础的网络服务，其原理是通过运行在前面的负载均衡服务，按照指定的负载均衡算法，将流量分雷到后端服务集群上，从而为系统提供并行扩展的能力。
负载均衡的应用场景包括流量包、转发规则以及后端服务，由于该服务有内外网隔离，健康检查功能，能够有效提供系统的安全性和可用性。

负载均衡分类

1. 客户端负载均衡

   先发送请求到负载均衡服务器或者软件，然后通过负载均衡算法，在多个服务器之间选择一个进行访问;即在服务器端再进行负载均衡算法分配

2. 服务端负载均衡

   客户端会有一个服务器地址列表，在发送请求前通过负载均衡算法选择一个服务器，然后进行访问，这是客户端负载均衡，即在客户端就进行负载均衡算法分配

基于Ribbon实现负载均衡

需求：实现订单和商品之间的客户端负载均衡

实现步骤：

1. 先搭建多服务实例（即水平拓展）

   订单服务需要调商品服务，所以需要再启动一个shop-product微服务，设置端口号为8082

   

2. 启动两个shop_product和shop_order

   发送多次请求，可以在调用的product服务中打印内容，查看控制台打印内容，Ribbon默认的负载均衡策略是轮询的方式

负载均衡的策略

Ribbion内置了多种负载均衡策略，内部负责负载均衡的顶级接口为com.netflix.loadbalancer.IRule

• com.netflix.loadbalancer.RoundRobinRule：以轮询的方式进行负载均衡
• com.netflix.loadbalancer.RandomRule：随机策略
• com.netflix.loadbalancer.RetryRule：重试策略
• com.netflix.loadbalancer.WeightedResponseTimeRule：权重策略。会计算每个服务的权重，越高的被调用的可能性越大
• com.netflix.loadbalancer.BestAvailableRule：最佳策略。遍历所有的服务实例，过滤掉故障实例，并返回请求数最小的实力返回
• com.netflix.loadbalancer.AvailabilityFilteringRule：可用过滤策略。过滤掉故障和请求次数超过阈值的服务实例，再从剩下的实例中轮询调用
• ZoneAvoidanceRule：以区域可用的服务器为基础进行服务器的选择。使用Zone对服务器进行分类，这个Zone可以理解为一个机房，一个机架等，而后再对Zone内的多个服务做轮询

自定义指定负载均衡策略

方式一，全局设置：

定义一个新的IRule：

@Bean
public IRule randomRule(){
    return new RandomRule();  // 随机策略
}
1
2
3
4

方式二，局部设置：

在yaml配置文件中配置：

在shop_order（客户端配置文件中）的yaml文件中配置被调用的服务，需要调用的服务器名称和策略

server:
  port: 8091
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql:///shop?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
    username: root
    password: 123456
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
# 配置随机策略
# 需要调用的服务器名称
service-product:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule
    # 随机策略完全路径
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Nacos配置管理

Nacos除了可做注册中心，同样可以做配置管理来使用

统一配置管理

当微服务部署的实例越来越多，达到数十、数百时，逐个修改微服务配置就会让人抓狂，而且很容易出错我们需要一种统一配置管理方案，可以集中管理所有实例的配置。

Nacos一方面可以将配置集中管理，另一方面可以在配置变更时，即使通知微服务，实现配置的热更新

在业界中常见的服务配置中心如下：

• **Apollo：**由携程开源的分布式配置中心。特点很多：配置更新之后可以实时生效，支持灰度发布功能，并且能对所有的配置进行版本管理、操作审计等功能，提供开放平台API。并且
  料也写的很详细
• **Disconf：**由百度开源的分布式配置中心。它是基于Zookeeper来实现配置变更后实时通知和生效的
• **SpringCloud Config：**Spring Cloud中带的配置中心组件。它和Spring是无缝集成，使用起来非常方便，并且它的配置存储支持Git，不过它没有可视化的操作界面，配置的生效也不是实时的，需要重启或去刷新
• **Nacos：**SpringCloud alibaba技术栈中的一个组件，前面我们已经使用它做过服务注册中心。其实它也继承了服务配置的功能，我们可以直接使用它作为服务配置中心

在nacos中添加配置文件

nacos配置中心新建配置起名规范：

服务名称-环境简称.文件后缀：shop_order-dev.yaml

从微服务拉取配置

微服务要拉取nacos中管理的配置，并且与本地的application.yaml配置合并，才能完成项目启动

spring引入了一种新的配置文件：boostrap.yaml文件，会在application.yaml之前被读取，流程：

配置实现步骤

1. 引入nacos-config依赖

   
   <dependency>
       <groupId>com.alibaba.cloudgroupId>
       <artifactId>spring-cloud-starter-alibaba-nacos-configartifactId>
   dependency>
   1
   2
   3
   4
   5

2. 添加bootstrap.yaml

   不能使用原来的application.yaml作为配置问价你，新建一个bootstrap.yaml作为配置文件

   server:
     port: 8091
   spring:
     application:
       name: service-order
     cloud:
       nacos:
         config:
           server-addr: 127.0.0.1:8848  #nacos 中心地址
           file-extension: yaml # 配置文件格式
     profiles:
       active: dev  #环境表示，开发环境
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12

   配置文件优先级（由高到低）：

   bootstrap.properties–>bootstrap.yaml–>application.properties–>application.yaml

3. 在nacos中添加配置：service-order-dev

   

4. 测试：

   模拟下单业务，正常下单即成功

配置热更新

最终目的是修改nacos中的配置后，微服务中无需重启即可让配置文件生效，也就是配置热更新。实现热更新两种方式：

在配置中心添加配置（随便起的键值对为了看效果）

config:
	env: test 
1
2

• 方式一

  只需要在需要动态读取配置的类上添加==@RefreshScope==注解就可以

  @RestController
  @RequestMapping("/order")
  @RefreshScope // 动态读取配置
  public class OrderController {
     @Value("${config.env}")
    private String appName;
    
    @GetMapping("/nacos-config-test")
    public String nacosConfigTest(){
      return appName;
    }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12

• 方式二

  硬编码方式

  @Value(("${config.env}"))
  private String env;
  @Autowired
  private ConfigurableApplicationContext applicationContext;
  
  @GetMapping("nacos-config-test2")
  public String nacosConfigTest2(){
    return applicationContext.getEnvironment().getProperty("config.env");
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9

当在配置中心中修改了config.env键值对，服务不需要重新启动，即可拿到修改后的值

配置共享

配置共享即抽取相同的配置

同服务内配置共享

实现步骤：

1. 新建一个以service-order命名的配置文件，然后将其所有环境的公共配置放在里面

   

2. 新建一个名为service-order-test.yaml配置存放测试环境的配置

3. 新建一个名为service-order-dev.yaml配置存放开发环境的配置

4. 在两个环境文件中配置独有信息

5. 添加测试方法

   修改bootstrap.yaml中的环境看字符串打印的内容

   profiles:
       active: dev  #环境表示，开发环境
       #active：test
   1
   2
   3

   @Value(("${config.env}"))
   private String env;
   
   @GetMapping("/nacos-config-test3")
   public String nacosConfigTest3(){
       return env;
   }
   1
   2
   3
   4
   5
   6
   7

不同微服务共享配置

不同服务之间实现配置共享的原理类似于文件引入，就是定义一个公共配置，然后在当前配置中引入

1. 在nacos中定义一个DataID为all-service.yaml（随便起）的配置，用于所有微服务共享

   spring:
     datasource:
       driver-class-name: com.mysql.cj.jdbc.Driver
       url: jdbc:mysql:///shop?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
       username: root
       password: 123456
     cloud:
       nacos:
         discovery:
           server-addr: 127.0.0.1:8848
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10

2. 修改bootstrap.yaml

   server:
     port: 8091
   spring:
     application:
       name: service-order
     cloud:
       nacos:
         config:
           server-addr: 127.0.0.1:8848  #nacos 中心地址
           file-extension: yaml # 配置文件格式
           shared-dataids: all-service.yaml  #配置要引入的配置
           refreshable-dataids: all-service.yaml # 配置要实现动态配置刷新的配置
     profiles:
       active: dev  #环境表示，开发环境
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14

3. 启动商品微服务测试

配置共享的优先级

当nacos、服务本地同时出现相同属性时，优先级有高低之分：