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>
	<!-- web服务依赖 -->
	<dependency>
	    <groupId>org.springframework.boot</groupId>
	    <artifactId>spring-boot-starter-web</artifactId>
	</dependency>
	<!-- nacos服务的注册和发现依赖 -->
	<dependency>
	    <groupId>com.alibaba.cloud</groupId>
	    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
	</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>
    <!--Spring Boot Web 依赖-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--Spring Cloud Alibaba  nacos 服务的注册和发现依赖-->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </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)，代码如下

<!-- 添加open feign -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</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 返回客户端，将信息流解析成为接口返回数据。

原文链接：https://blog.csdn.net/Skyhaohao/article/details/120382395