Nacos注册中心的安装及使用

1. 概述

• Nacos（DynamicNaming and Configuration Service）是一个应用于服务注册与发现、配置管理的平台。
• Nacos 致力于发现、配置和管理微服务。Nacos 提供了一组简单易用的特性集，可以快速实现动态服务发现、服务配置、服务元数据及流量管理。
• Nacos 可以更敏捷和容易地构建、交付和管理微服务平台。 Nacos 是构建以“服务”为中心的现代应用架构 (例如微服务范式、云原生范式) 的服务基础设施。

2. 关键特性

• 服务发现和服务健康监测
  • 动态服务发现对以服务为中心的（例如微服务和云原生）应用架构方式非常关键。Nacos支持DNS-Based和RPC-Based（Dubbo、gRPC）模式的服务发现。Nacos也提供实时健康检查，以防止将请求发往不健康的主机或服务实例。借助Nacos，您可以更容易地为您的服务实现断路器。
• 动态配置服务
  • 动态配置服务可以让您以中心化、外部化和动态化的方式管理所有环境的应用配置和服务配置。
  • 动态配置消除了配置变更时重新部署应用和服务的需要，让配置管理变得更加高效和敏捷。
  • 配置中心化管理让实现无状态服务变得更简单，让服务按需弹性扩展变得更容易。
• 动态 DNS 服务
  • 通过支持权重路由，动态DNS服务能让您轻松实现中间层负载均衡、更灵活的路由策略、流量控制以及简单数据中心内网的简单DNS解析服务。动态DNS服务还能让您更容易地实现以DNS协议为基础的服务发现，以消除耦合到厂商私有服务发现API上的风险。
• 服务及其元数据管理
  • Nacos 能让您从微服务平台建设的视角管理数据中心的所有服务及元数据，包括管理服务的描述、生命周期、服务的静态依赖分析、服务的健康状态、服务的流量管理、路由及安全策略、服务的 SLA 以及最首要的 metrics 统计数据。
• 官网：

  https://nacos.io/zh-cn/index.html
  

3. Nacos 的安装和配置

3.1 准备工作

• 首先，查看电脑是否已经配置JAVA_HOME环境变量
• 之后，确保MySQL版本在5.7以上（MariaDB10.5以上）

3.2 下载与安装

• 在官网下载Nacos，官网地址

  https://github.com/alibaba/nacos/releases
  

• 选择下载zip包
• 之后解压Nacos压缩文件，最好不要解压到中文目录下

3.3 初始化配置

• 登录MySQL，执行对应的脚本，命令为

  source  盘符:/nacos-mysql.sql
  

• 执行成功后，会创建一个名为 nacos_config 的数据库，会有多个表。
• 之后，打开 conf/application.properties 文件，基于当前环境，修改对应的内容

  #*************** Config Module Related Configurations ***************#
  ### If use MySQL as datasource:
  spring.datasource.platform=mysql
  
  ### Count of DB:
  db.num=1
  
  ### Connect URL of DB:
  db.url.0=jdbc:mysql://127.0.0.1:3306/nacos_config?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
  db.user.0=root
  db.password.0=root
  

4. Nacos服务的启动和访问

4.1 启动Nacos服务

• Linux启动命令(standalone代表着单机模式运行，非集群模式):

  ./startup.sh -m standalone
  

• Windows启动命令(standalone代表着单机模式运行，非集群模式):

  startup.cmd -m standalone
  

4.2 访问Nacos服务

• 访问如下网址，默认账号密码都是nacos

  http://localhost:8848/nacos
  

5. 服务注册与调用入门

5.1业务描述

• 创建两个项目Module分别为服务提供者和服务消费者，两者都要注册到NacosServer中(这个server本质上就是一个web服务，端口默认为8848)，然后服务提供者可以为服务消费者提供远端调用服务(例如支付服务为服务提供方，订单服务为服务消费方)，如图所示：

5.2 生产者服务创建及注册

• 创建服务提供者工程(module名为sca-provider），继承parent工程(01-sca),其pom.xml文件内容如下：

  <dependencies>
  	
  	<dependency>
  	    <groupId>org.springframework.bootgroupId>
  	    <artifactId>spring-boot-starter-webartifactId>
  	dependency>
  	
  	<dependency>
  	    <groupId>com.alibaba.cloudgroupId>
  	    <artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
  	dependency>
  dependencies>
  

• 创建并修改配置文件application.yml(或者application.properties)，实现服务注册，关键代码如下：

  server:
     port: 8081
  spring:
    application:
      name: sca-provider
    cloud:
      nacos:
        discovery:
          server-addr: localhost:8848
  

  • 服务名不要使用下划线(“_”),应使用横杠(“-”),这是规则。
• 创建启动类

  package com.lofasp;
  
  import lombok.extern.slf4j.Slf4j;
  import org.springframework.beans.factory.annotation.Value;
  import org.springframework.boot.SpringApplication;
  import org.springframework.boot.autoconfigure.SpringBootApplication;
  import org.springframework.cloud.context.config.annotation.RefreshScope;
  import org.springframework.web.bind.annotation.GetMapping;
  import org.springframework.web.bind.annotation.PathVariable;
  import org.springframework.web.bind.annotation.RestController;
  
  /**
   * @Author Sky-haohao
   * @Date 2021/9/15 10:43
   * @Version 1.0
   */
  @Slf4j
  @SpringBootApplication
  public class ProviderApplication {
      public static void main(String[] args) {
          SpringApplication.run(ProviderApplication.class, args);
      }
  }
  

• 定义处理请求的控制层对象和方法ProviderController：

  package com.lofasp.controller;
  
  import lombok.extern.slf4j.Slf4j;
  import org.springframework.beans.factory.annotation.Value;
  import org.springframework.cloud.context.config.annotation.RefreshScope;
  import org.springframework.web.bind.annotation.GetMapping;
  import org.springframework.web.bind.annotation.PathVariable;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RestController;
  
  /**
   * @Author Sky-haohao
   * @Date 2021/9/17 14:07
   * @Version 1.0
   */
  
  /** - @RefreshScope 注解用于告诉spring，一旦配置中心数据发生变化
   * 自动重新创建它描述的类的实例*/
  @Slf4j
  @RefreshScope
  @RestController
  public class ProviderController {
  
      // 内部类不能放static
      public  ProviderController() {
          System.out.println("ProviderController()");
      }
  
      // 此属性会在对象构建时初始化
      // 服务器启动时会将所有的配置信息(配置文件或配置中心) 读取到 Environment 对象
      // @Value用于告诉spring从 Environment 对象中，读取配置信息
      // 将读取到的配置内容赋值给对象的属性
      @Value("${logging.level.com.lofasp:debug}")
      private String logLevel;
  
      @GetMapping("/provider/doGetLevel")
      public String doGetLogLevel(){
          //日志的输出会随着配置中心日志级别的更新进行调整
          log.trace("==log.trace==");//跟踪
          log.debug("==log.debug==");//调试
          log.info("==log.info==");//常规信息
          log.warn("==log.warn==");//警告
          log.error("==log.error==");//错误信息
          return "log level is : " + logLevel;
      }
  
  
      // @Value读取application.yml 中的配置
      // 要读取的配置需要写在 ${} 这个表达式中
      // ${} 表达式中 ":" 后面的内容是默认值，当没有读到server.port的值时，补充
      @Value("${server.port:8080}")
      private String server;
      /**
       * 基于此方法，实现一个字符串的回显
       * echo 回显
       * rest 属于一种软件架构编码风格，可以基于这种风格定义URL
       * 访问http://localhost:8081/provider/echo/nacos
       * @return
       */
      @GetMapping("/provider/echo/{msg}")
      public String doRestEcho1(@PathVariable("msg") String msg){
          /*try {
              System.out.println("开始睡觉!!!");
              Thread.sleep(5000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }*/
  
          // 需求：通过配置中心动态日志级别设置，控制日志信息的输出
          // 常用日志级别：trace < debug < info < warn < error
          // 很多系统的默认日志级别是info，调试程序通常会用debug
          // {} 表示占位符，后面的内容会填充到占位符中，可以写多个
          log.info("doRestEcho1 start:{}",System.currentTimeMillis());
          return server + "say hello" + msg;
      }
  }
  

• 启动启动类，然后刷先nacos服务，检测是否服务注册成功，如图所示
  
• 打开浏览器，输入地址http://localhost:8081/provider/echo/sca，进行访问
  

5.3 消费者服务发现及调用

• 创建服务消费者（module名为sca-consumer），继承parent工程（01-sca），其pom.xml文件内容如下：

  <dependencies>
      
      <dependency>
          <groupId>org.springframework.bootgroupId>
          <artifactId>spring-boot-starter-webartifactId>
      dependency>
      
      <dependency>
          <groupId>com.alibaba.cloudgroupId>
          <artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
      dependency>	
  dependencies>
  

• 修改配置文件application.yml，关键代码如下：

  server:
    port: 8090
  spring:
    application:
      name: sca-consumer
    cloud:
      nacos:
        discovery:
          server-addr: localhost:8848
  

• 创建启动类并实现服务消费

  package com.lofasp;
  
  /**
   * @Author Sky-haohao
   * @Date 2021/9/15 14:17
   * @Version 1.0
   */
  
  /**
   * 服务消费方对象的启动类
   * 业务描述：
   *      当客户端(浏览器，手机app) 向服务消费方发起请求时，
   *      服务消费方调用服务提供方的api，进而获取服务提供方的数据
   * 例如： 我们访问一个订单模块数据(例如我的订单)，订单模块中还要呈现商品信息
   */
  @SpringBootApplication
  public class ConsumerApplication {
      public static void main(String[] args) {
          SpringApplication.run(ConsumerApplication.class, args);
      }
  
      /**
       * 构建RestTemplate对象，并将此对象将给spring管理
       * 后续我们会通过此对象进行远程服务调用
       * @return
       */
      @Bean
      public RestTemplate restTemplate(){
          System.out.println("===restTemplate()===");
          return new RestTemplate();
      }
  
      @RestController
      public class ConsumerController{
  
          @Value("${spring.application.name}")
          private String appName;
  
          @Autowired
          private RestTemplate restTemplate;
          
          //http://ip:port/consumer/doRestEcho1
          @GetMapping("/consumer/doRestEcho1")
          public String doRestEcho1(){
              //调用服务提供方API(http://ip:port/path)
              //1.定义要调用的API
              String url = "http://localhost:8081/provider/echo/" + appName;
              // System.out.println("request url:"+url);
              //2.谁去访问这个API restTemplate
              return restTemplate.getForObject(url, String.class);
          }
  }
  

• 启动消费者服务，输入地址http://localhost:8090/consumer/doRestEcho1进行访问
  

6. 服务负载均衡设计及实现

6.1 入门案例

• 一个服务实例可以处理请求是有限的,假如服务实例的并发访问比较大,我们会启动多个服务实例,让这些服务实例采用一定策略均衡(轮询,权重,随机,hash等)的处理并发请求,在Nacos中服务的负载均衡(Nacos客户端负载均衡)是如何应用的?

• 修改ConsumerController类

  • 注入LoadBalancerClient对象,并添加doRestEcho2方法,然后进行服务访问

  /**
      * 负载均衡客户端对象
      */
     @Autowired
     private LoadBalancerClient loadBalancerClient;
     
     /**
      * 负载均衡方式调用
      * http://ip:port/consumer/doRestEcho2
      * @return
      */
     @GetMapping("/consumer/doRestEcho2")
     public String doRestEcho2(){
         //1.从注册中心获取服务实例
         ServiceInstance instance = loadBalancerClient.choose("sca-provider");
         //2.基于RestTemplate进行服务实例调用
         String ip = instance.getHost();  //获取IP地址
         int port = instance.getPort();  //获取端口号
         //String url = "http://" + ip + ":" + port + "/provider/echo/" + appName;
         //可变参数的写法
         String url = String.format("http://%s:%s/provider/echo/%s", ip,port,appName);
         return restTemplate.getForObject(url, String.class);
     }
  

• 打开Idea服务启动配置，修改并发运行选项，如图所示：
  
  

• 修改sca-provider的配置文件端口，分别以8081，8082端口方式进行启动。

  server:
    port: 8082
  spring:
    application:
      name: sca-provider
    cloud:
      nacos:
        server-addr: localhost:8848
  

• 启动成功以后，访问nacos的服务列表，检测服务是否成功注册，如图所示：
  

• 启动sca-consumer项目模块，打开浏览器访问

  • 网址 http://localhost:8090/consumer/doRestEcho2
  • 反复刷新，会发现8081和8082端口轮流调用
    

• 这里多个实例并发提供服务的方式为负载均衡，这里的负载均衡实现默认是因为Nacos集成了Ribbon来实现的，Ribbon配合RestTemplate，可以非常容易的实现服务之间的访问。

• Ribbon是Spring Cloud核心组件之一，它提供的最重要的功能就是客户端的负载均衡(客户端可以采用一定算法,例如轮询访问，访问服务端实例信息)，这个功能可以让我们轻松地将面向服务的REST模版请求自动转换成客户端负载均衡方式的服务调用。

6.2 @LoadBalanced注解

• 当使用RestTemplate进行远程服务调用时，假如需要负载均衡,可以在RestTemplate对象构建时，使用@LoadBalanced对构建RestTemplate的方法进行修饰，例如在ConsumerApplication中构建RestTemplate对象：

  @Bean
  @LoadBalanced
  public RestTemplate loadBalancedRestTemplate(){
      return new RestTemplate();
  }
  

• 在需要RestTemplate实现负载均衡调用的地方进行依赖注入.例如在ConsumerController类中添加loadBalancedRestTemplate属性

  @Autowired
  private RestTemplate loadBalancedRestTemplate;
  

• 接下来，可以在对应的服务端调用方的方法内，基于RestTemplate借助服务名进行服务调用， 例如：

  @GetMapping("/consumer/doRestEcho3")
  public String doRestEcho03(){
      String serviceId = "sca-provider";
      // 定义一个url
      String url = String.format("http://%s/provider/echo/%s",serviceId,appName);
      // 服务的调用
      return loadBalancedRestTemplate.getForObject(url, String.class);
  }
  

• RestTemplate在发送请求的时候会被LoadBalancerInterceptor拦截，它的作用就是用于RestTemplate的负载均衡，LoadBalancerInterceptor将负载均衡的核心逻辑交给了loadBalancer，核心代码如下所示(了解):

  public ClientHttpResponse intercept(final HttpRequest request, 
      final byte[] body, final ClientHttpRequestExecution execution) throws IOException {
  	final URI originalUri = request.getURI();
  	String serviceName = originalUri.getHost();
  	return this.loadBalancer.execute(serviceName, 
      requestFactory.createRequest(request, body, execution));
  }
  

  • @LoadBalanced注解是属于Spring，而不是Ribbon的，Spring在初始化容器的时候，如果检测到Bean被@LoadBalanced注解，Spring会为其设置LoadBalancerInterceptor的拦截器。

6.3 Ribbon负载均衡策略(了解)

• 基于Ribbon方式的负载均衡，Netflix默认提供了七种负载均衡策略，对于SpringCloud Alibaba解决方案中又提供了NacosRule策略，默认的负载均衡策略是轮训策略。如图所示：
  
  • 当系统提供的负载均衡策略不能满足我们需求时，我们还可以基于IRule接口自己定义策略.

7. 基于Feign的远程服务调用

7.1 背景分析

• 服务消费方基于rest方式请求服务提供方的服务时，一种直接的方式就是自己拼接url，拼接参数然后实现服务调用，但每次服务调用都需要这样拼接，代码量复杂且不易维护，此时Feign诞生。

7.2 Feign是什么

• Feign 最早是由 Netflix 公司进行维护的，后来 Netflix 不再对其进行维护，最终 Feign 由一些社区进行维护，更名为 OpenFeign。
• Feign 是一种声明式Web服务客户端，底层封装了对Rest技术的应用,通过Feign可以简化服务消费方对远程服务提供方法的调用实现。如图所示：

7.3 Feign应用实践

• 在服务消费方，添加项目依赖(SpringCloud团队基于OpenFeign研发了starter)，代码如下

  
  <dependency>
      <groupId>org.springframework.cloudgroupId>
      <artifactId>spring-cloud-starter-openfeignartifactId>
  dependency>
  

• 在启动类上添加@EnableFeignClients注解，代码如下：

  @EnableFeignClients
  @SpringBootApplication
  public class ConsumerApplication {…}
  

• 定义Http请求API，基于此API借助OpenFeign访问远端服务，代码如下：

  package com.lofasp.service;
  
  /**
   * @Author Sky-haohao
   * @Date 2021/9/16 10:46
   * @Version 1.0
   */
  
  import com.lofasp.factory.RemoteProviderFallbackFactory;
  import org.springframework.cloud.openfeign.FeignClient;
  import org.springframework.web.bind.annotation.GetMapping;
  import org.springframework.web.bind.annotation.PathVariable;
  
  /**
   * 定义用于实现远程provider服务调用的service接口
   * 其中：
   *      1.@FeignClient用于描述远程服务调用接口
   *      2.name = "sca-provider" 为 你要远程调用的服务名
   *      3.contentId 为 当前 bean的名称，假如没有指定contentId，默认会
   *          采用@FeignClient注解中的name属性指定的名字作为bean的名字
   *      4.fallbackFactory 用于定义服务调用超时等现象发生时,一种应对措施或处理机制
   */
  @FeignClient(name = "sca-provider",contextId = "remoteProviderService")
  public interface RemoteProviderService {
  
      @GetMapping("/provider/echo/{msg}") //前提是远端需要有这个服务
      public String echoMessage(@PathVariable("msg") String msg);
  }//consumer.controller-->Feign interface-->remote call
  //起步依赖,自动配置-autoconfiguration,监控监控-actuator,嵌入式(WEB-tomcat)
  

  • 其中，@FeignClient描述的接口底层会为其创建实现类。
• 创建FeignConsumerController中并添加feign访问，代码如下：

  package com.lofasp.controller;
  
  import com.lofasp.service.RemoteProviderService;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.web.bind.annotation.GetMapping;
  import org.springframework.web.bind.annotation.PathVariable;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RestController;
  
  /**
   * @Author Sky-haohao
   * @Date 2021/9/16 10:55
   * @Version 1.0
   */
  @RestController
  @RequestMapping("/consumer")
  public class FeignConsumerController {
  
      @Autowired
      private RemoteProviderService remoteProviderService;
  
      /**
       * 执行远程服务调用
       * 访问： browser -> consumer -> provider
       *      1.browser
       *          http://localhost:8090/consumer/echo/cgb
       *      2.consumer
       *          http://sca-provider/provider/echo/cgb
       */
      @GetMapping("/echo/{msg}")
      public String doRestEcho(@PathVariable("msg") String msg){
          return remoteProviderService.echoMessage(msg);
      }
  }
  

• 启动消费者服务，在浏览器中直接通过feign客户端进行访问，如图所示（反复刷新检测其响应结果）：

7.4 Feign配置进阶实践

• 一个服务提供方通常会提供很多资源服务，服务消费方基于同一个服务提供方写了很多服务调用接口，此时假如没有指定contextId，服务启动就会失败，例如假如在服务消费方再添加一个如下接口，消费方启动时就会启动失败，例如：

  package com.lofasp.service;
  
  import org.springframework.cloud.openfeign.FeignClient;
  
  /**
   * @Author Sky-haohao
   * @Date 2021/9/16 14:12
   * @Version 1.0
   */
  @FeignClient(name = "sca-provider")
  public interface RemoteOtherService {
  }
  

  • 会出现启动异常:

    The bean 'optimization-user.FeignClientSpecification', defined in null, could not be registered. A bean with that name has already been defined in null and overriding is disabled.
    

    • 即 提示有一个同名的bean已经被定义了
  • 此时我们需要为远程调用服务接口指定一个contextId,作为远程调用服务的唯一标识即可,例如:

    @FeignClient(name = "sca-provider",contextId = "remoteOtherService")
    public interface RemoteOtherService {
    }
    

7.4 具体的容错方案

• 当我们在进行远程服务调用时,假如调用的服务突然不可用了或者调用过程超时了,怎么办呢?一般服务消费端会给出具体的容错方案,例如:
• 定义FallbackFactory接口的实现,代码如下:

  package com.lofasp.factory;
  
  import com.lofasp.service.RemoteProviderService;
  import feign.hystrix.FallbackFactory;
  import lombok.extern.slf4j.Slf4j;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.stereotype.Component;
  
  /**
   * @Author Sky-haohao
   * @Date 2021/9/16 14:31
   * @Version 1.0
   */
  // @Slf4j
  @Component
  public class RemoteProviderFallbackFactory implements FallbackFactory<RemoteProviderService> {
      /** 如果不定义该 Logger 对象，可以直接使用lombok提供的 @Slf4j 注解*/
      private static final Logger log = LoggerFactory.getLogger(RemoteProviderFallbackFactory.class);
      private static final int FAIL = 500;
      @Override
      public RemoteProviderService create(Throwable throwable) {
          log.error("用户服务调用失败:{}", throwable.getMessage());
  
          /* 初始写法
          return new RemoteProviderService() {
              @Override
              public String echoMessage(String msg) {
                  //给运维人员发消息
                  return "服务忙,稍等片刻再访问,状态码"+ FAIL + ",信息：" + throwable.getMessage();
              }
          };*/
  
          /** lambda 表达式的写法 */
          return msg -> "服务忙,稍等片刻再访问,状态码"+ FAIL + ",信息：" + throwable.getMessage();
      }
  }
  

• 在Feign访问接口中应用FallbackFactory对象,例如:

  @FeignClient(name = "sca-provider",contextId = "remoteProviderService",fallbackFactory = RemoteProviderFallbackFactory.class)
  

• 在配置文件application.yml中添加如下配置,启动feign方式调用时的服务中断处理机制

  feign:
    hystrix:
      enabled: true # 开启feign方式调用时，服务调用超时等问题
  

• 在服务提供方对应的方法中添加Thread.sleep(500000)模拟耗时操作,然后启动服务进行访问测试

7.5 Feign 调用过程分析

• Feign应用过程分析（底层逻辑先了解）：
  • 通过 @EnableFeignCleints 注解告诉springcloud,启动 Feign Starter 组件。
  • Feign Starter 在项目启动过程中注册全局配置，扫描包下所由@FeignClient注解描述的接口，然后由系统底层创建接口实现类(JDK代理类)，并构建类的对象，然后交给spring管理(注册 IOC 容器)。
  • 接口被调用时被动态代理类逻辑拦截，将 @FeignClient 请求信息通过编码器生成 Request对象，基于此对象进行远程过程调用。
  • 请求对象经Ribbon进行负载均衡，挑选出一个健康的 Server 实例（instance）。
  • 通过 Client 携带 Request 调用远端服务返回请求响应。
  • 通过解码器生成 Response 返回客户端，将信息流解析成为接口返回数据。