1. 简介

1.1 了解Nacos

Nacos 是一个更易于构建云原生应用的动态服务注册与发现、配置管理和服务管理平台。

  • 通过 Nacos Server 和 spring-cloud-starter-alibaba-nacos-config 实现配置的动态变更。
  • 通过 Nacos Server 和 spring-cloud-starter-alibaba-nacos-discovery 实现服务的注册与发现。
  • Nacos 可以看作 Spring Cloud Eureka + Spring Cloud Config 的整合。

    1.2 了解Nacos-Config

    Nacos 提供用于存储配置和其他元数据的 key/value 存储，为分布式系统中的外部化配置提供服务器端和客户端支持。使用 Spring Cloud Alibaba Nacos Config，可以在 Nacos Server 集中管理你 Spring Cloud 应用的外部属性配置。

Spring Cloud Alibaba Nacos Config 是 Config Server 和 Client 的替代方案，客户端和服务器上的概念与 Spring Environment 和 PropertySource 有着一致的抽象，在特殊的 bootstrap 阶段，配置被加载到 Spring 环境中。当应用程序通过部署管道从开发到测试再到生产时，您可以管理这些环境之间的配置，并确保应用程序具有迁移时需要运行的所有内容。

官方文档：https://github.com/alibaba/spring-cloud-alibaba/wiki/Nacos-config

1.3 了解Nacos-Discover

服务发现是微服务架构体系中最关键的组件之一。Nacos Discovery 可以帮助您将服务自动注册到 Nacos 服务端并且能够动态感知和刷新某个服务实例的服务列表。除此之外，Nacos Discovery 也将服务实例自身的一些元数据信息-例如 host，port, 健康检查URL，主页等内容注册到 Nacos。

核心功能：

  • 服务注册：Nacos Client 会通过发送 REST 请求的方式向 Nacos Server 注册自己的服务，提供自身的元数据，比如 ip 地址、端口等信息。Nacos Server 接收到注册请求后，就会把这些元数据信息存储在一个双层的内存 Map 中。
  • 服务心跳：在服务注册后，Nacos Client 会维护一个定时心跳来持续通知 Nacos Server，说明服务一直处于可用状态，防止被剔除。默认 5s 发送一次心跳。
  • 服务同步：Nacos Server 集群之间会互相同步服务实例，用来保证服务信息的一致性。
  • 服务发现：服务消费者（Nacos Client）在调用服务提供者的服务时，会发送一个REST请求给Nacos Server，获取上面注册的服务清单，并且缓存在Nacos Client本地，同时会在Nacos Client本地开启一个定时任务定时拉取服务端最新的注册表信息更新到本地缓存
  • 服务健康检查：Nacos Server会开启一个定时任务用来检查注册服务实例的健康情况，对于超过15s没有收到客户端心跳的实例会将它的healthy属性置为false(客户端服务发现时不会发现)，如果某个实例超过30秒没有收到心跳，直接剔除该实例(被剔除的实例如果恢复发送心跳则会重新注册)

    1.4 部署Nacos

    1、访问地址：https://nacos.io/zh-cn/docs/quick-start.html
    2、单机启动 Nacos：sh startup.sh -m standalone
    3、配置 nacos 自启动： ```shell

    vim /etc/systemd/system/nacos.service

    [Unit] Description=nacos After=network.target

[Service] Type=forking ExecStart=/opt/nacos/bin/startup.sh -m standalone ExecReload=/opt/nacos/bin/shutdown.sh ExecStop=/opt/nacos/bin/shutdown.sh PrivateTmp=true

[Install] WantedBy=multi-user.target

给与777权限

chmod 777 /opt/nacos/bin/startup.sh

配置java路径 vi /opt/nacos/bin/startup.sh

[ ! -e “$JAVA_HOME/bin/java” ] && JAVA_HOME=/opt/jdk8

[ ! -e “$JAVA_HOME/bin/java” ] && JAVA_HOME=$HOME/jdk/java

[ ! -e “$JAVA_HOME/bin/java” ] && JAVA_HOME=/usr/java

[ ! -e “$JAVA_HOME/bin/java” ] && JAVA_HOME=/opt/taobao/java

[ ! -e “$JAVA_HOME/bin/java” ] && unset JAVA_HOME

systemctl daemon-reload #先进行文件生效配置 systemctl enable nacos.service #设置为开机启动 systemctl start nacos.service #启动nacos服务

  1. <a name="wAYwB"></a>
  2. # 2. 快速上手
  3. <a name="M5ED1"></a>
  4. ## 2.1 引入依赖
  5. ```xml
  6. <?xml version="1.0" encoding="UTF-8"?>
  7. <project xmlns="http://maven.apache.org/POM/4.0.0"
  8.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  9.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <groupId>com.xuwei</groupId>
  13.     <artifactId>springcloudalibaba-nacos</artifactId>
  14.     <packaging>pom</packaging>
  15.     <version>1.0-SNAPSHOT</version>
  17.     <properties>
  18.         <java.version>1.8</java.version>
  19.         <spring.cloud.alibaba.version>2.2.7.RELEASE</spring.cloud.alibaba.version>
  20.         <spring.cloud.version>Hoxton.SR12</spring.cloud.version>
  21.         <spring.boot.version>2.3.12.RELEASE</spring.boot.version>
  22.     </properties>
  24.     <dependencies>
  25.         <dependency>
  26.             <groupId>org.projectlombok</groupId>
  27.             <artifactId>lombok</artifactId>
  28.         </dependency>
  30.         <!-- SpringCloud Alibaba Nacos Config -->
  31.         <dependency>
  32.             <groupId>com.alibaba.cloud</groupId>
  33.             <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
  34.         </dependency>
  36.         <dependency>
  37.             <groupId>com.alibaba.cloud</groupId>
  38.             <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  39.         </dependency>
  41.         <dependency>
  42.             <groupId>org.springframework.boot</groupId>
  43.             <artifactId>spring-boot-starter-web</artifactId>
  44.         </dependency>
  46.         <dependency>
  47.             <groupId>org.springframework.boot</groupId>
  48.             <artifactId>spring-boot-starter</artifactId>
  49.         </dependency>
  51.         <dependency>
  52.             <groupId>org.springframework.boot</groupId>
  53.             <artifactId>spring-boot-starter-test</artifactId>
  54.         </dependency>
  56.     </dependencies>
  58.     <!-- 版本管理，通过dependency完成继承 -->
  59.     <dependencyManagement>
  61.         <dependencies>
  62.             <!-- Spring Cloud Alibaba版本管理-->
  63.             <dependency>
  64.                 <groupId>com.alibaba.cloud</groupId>
  65.                 <artifactId>spring-cloud-alibaba-dependencies</artifactId>
  66.                 <version>${spring.cloud.alibaba.version}</version>
  67.                 <type>pom</type>
  68.                 <scope>import</scope>
  69.             </dependency>
  71.             <!-- Spring Cloud 版本管理 -->
  72.             <dependency>
  73.                 <groupId>org.springframework.cloud</groupId>
  74.                 <artifactId>spring-cloud-dependencies</artifactId>
  75.                 <version>${spring.cloud.version}</version>
  76.                 <type>pom</type>
  77.                 <scope>import</scope>
  78.             </dependency>
  80.             <!-- SpringBoot 版本管理 -->
  81.             <dependency>
  82.                 <groupId>org.springframework.boot</groupId>
  83.                 <artifactId>spring-boot-dependencies</artifactId>
  84.                 <version>${spring.boot.version}</version>
  85.                 <type>pom</type>
  86.                 <scope>import</scope>
  87.             </dependency>
  88.         </dependencies>
  89.     </dependencyManagement>
  91.     <build>
  92.         <finalName>${project.artifactId}</finalName>
  93.         <plugins>
  94.             <plugin>
  95.                 <groupId>org.springframework.boot</groupId>
  96.                 <artifactId>spring-boot-maven-plugin</artifactId>
  97.                 <executions>
  98.                     <execution>
  99.                         <goals>
  100.                             <goal>repackage</goal>
  101.                         </goals>
  102.                     </execution>
  103.                 </executions>
  104.             </plugin>
  105.         </plugins>
  106.     </build>
  109. </project>

2.2 修改配置文件

  1. server:
  2.   port: 8081
  4. spring:
  5.   application:
  6.     name: order-service
  7.   cloud:
  8.     nacos:
  9.       discovery:
  10.         # 服务注册地址
  11.         server-addr: 192.168.58.50:8848
  12.       config:
  13.         # 配置中心地址
  14.         server-addr: 192.168.58.50:8848
  15.         # 配置文件格式
  16.         file-extension: yml
  17.         # 共享配置
  18.         shared-configs:
  19.           - application-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}
  20.         namespace: 3616bfe4-0d14-4ede-bfd6-6245e39b3952

3. 使用Nacos-Config

3.1 加载配置文件

以前，我们是在 application.yaml 文件中配置项目的一些必要信息，比如数据库信息等，有了 nacos 之后，我们可以将这些信息配置到 nacos 中，每次从 nacos 中读取配置。nacos 中的配置文件支持两种格式：properties(默认) 和 yaml，定位格式为：服务名-环境名.后缀。

举例：读取 Nacos 配置文件中的数据库信息，输出查询结果。

如果存在 nacos 读取不到配置文件的问题，可能解决方案：①重启 nacos ②nacos 指定命名空间 ③ maven clean、install。

1、在 nacos 中新建命名空间，在 test 空间下配置文件 order-service.properties（简单案例）、order-service-dev.yaml（真实项目-ruoyi-system）。

  1. spring: 
  2.   redis:
  3.     host: 192.168.58.50
  4.     port: 6379
  5.     password: 12345

2、新建 bootstrap.properties 文件。

  1. server.port=8081
  2. spring.application.name=order-service
  3. spring.cloud.nacos.config.server-addr=192.168.58.50:8848
  4. spring.cloud.nacos.config.namespace=3616bfe4-0d14-4ede-bfd6-6245e39b3952

3、新建 bootstrap.yaml 文件。

  1. server:
  2.   port: 8081
  4. spring:
  5.   application:
  6.     name: order-service
  7.   profiles:
  8.     active: dev
  9.   cloud:
  10.     nacos:
  11.       discovery:
  12.         # 服务注册地址
  13.         server-addr: 192.168.58.50:8848
  14.       config:
  15.         # 配置中心地址
  16.         server-addr: 192.168.58.50:8848
  17.         # 配置文件格式
  18.         file-extension: yml
  19.         # 共享配置
  20.         shared-configs:
  21.           - application-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}
  22.         namespace: 3616bfe4-0d14-4ede-bfd6-6245e39b3952

4、修改启动类代码，查看结果。

  1. @SpringBootApplication
  2. public class SpringcloudalibabaNacosApplication {
  4.     public static void main(String[] args) {
  5.         ConfigurableApplicationContext applicationContext = SpringApplication.run(SpringcloudalibabaNacosApplication.class, args);
  6.         String redisHost = applicationContext.getEnvironment().getProperty("spring.redis.host");
  7.         String redisPort = applicationContext.getEnvironment().getProperty("spring.redis.port");
  8.         System.err.println("redisHost :"+redisHost+"; redisPort: "+redisPort);
  9.     }
  11. }

image.png
5、浏览器访问：http://192.168.58.50:8848/nacos/v1/cs/configs?dataId=order-service-dev.yml&group=DEFAULT_GROUP&namespace=3616bfe4-0d14-4ede-bfd6-6245e39b3952

3.2 实现配置动态刷新

3.2.1 @Value属性动态刷新

Nacos Config 默认支持配置的动态更新，需要在 Bean 的声明类标注 @RefreshScope，那么应用订阅某个 Nacos 配置后，当配置内容变化时，Refresh Scope Beans 中的绑定配置的属性将有条件的更新。

1、使用 @RefreshScope标注类，并在方法中输出获取的属性值。
2、修改配置文件中的参数，重新输出，查看值是否动态刷新。

  1. @RefreshScope
  2. @RestController
  3. public class TestController {
  5.     @Value("${spring.redis.host}")
  6.     private String redisHost;
  8.     @Value("${spring.redis.port}")
  9.     private String redisPort;
  11.     @GetMapping("/test")
  12.     public String test() {
  13.         System.out.println("redisHost：" + redisHost +  ", redisPort：" + redisPort);
  14.         return "test";
  15.     }
  16. }

3、查看控制台输出。
image.png
总结：当 Nacos Config 接收到服务端配置变更时，对应的 **@RefreshScope**Bean 生命周期回调方法会被调用，并且是先销毁，然后由重新初始化，这样可以避免出现重复初始化等操作。

3.2.2 @ConfigurationProperties属性动态刷新

1、新增 RedisConfig类，并标注 @RefreshScope和 @ConfigurationProperties。

  1. @Data
  2. @AllArgsConstructor
  3. @NoArgsConstructor
  4. @RefreshScope
  5. @ConfigurationProperties(prefix = "spring.redis")
  6. public class RedisConfig implements InitializingBean, DisposableBean {
  8.     // 这里名称要和配置文件中一致
  9.     private String host;
  10.     private String port;
  12.     @Override
  13.     public void afterPropertiesSet() throws Exception {
  14.         System.out.println("[afterPropertiesSet()] " + toString());
  15.     }
  17.     @Override
  18.     public void destroy() throws Exception {
  19.         System.out.println("[destroy()] " + toString());
  20.     }
  21. }

2、根据 @ConfigurationProperties的定义，RedisConfig类的属性绑定到了配置属性前缀 spring.redis。

  1. @RefreshScope
  2. @RestController
  3. @EnableConfigurationProperties(RedisConfig.class)
  4. public class TestController {
  6.     @Autowired
  7.     private RedisConfig redisConfig;
  9.     @Value("${spring.redis.host}")
  10.     private String redisHost;
  12.     @Value("${spring.redis.port}")
  13.     private String redisPort;
  15.     @GetMapping("/test")
  16.     public String test() {
  17.         System.out.println("redisHost：" + redisHost +  ", redisPort：" + redisPort);
  18.         return "test";
  19.     }
  21.     @PostConstruct
  22.     public void init() {
  23.         System.out.printf("[init] redis host : %s , port : %s%n", redisHost, redisPort);
  24.     }
  26.     @PreDestroy
  27.     public void destroy() {
  28.         System.out.printf("[destroy] redis host : %s , port : %s%n", redisHost, redisPort);
  29.     }
  30. }

3、修改配置文件，查看结果。
image.png
总结：当 User 数据发生改变时，User Bean 的生命周期方法不仅被调用，并且是先销毁，再初始化。

3.2.3 监听实现Bean属性动态刷新

1、如果我们想要自己实现监听器功能，除了需要用到 com.alibaba.nacos.api.config.listener.Listener标准的配置监听器接口（没有与 Spring 打通），还需要借助于 NacosConfigManager 这个 bean。

  1. @RefreshScope
  2. @RestController
  3. @EnableConfigurationProperties(RedisConfig.class)
  4. public class TestController {
  6.     ......
  8.     @Autowired
  9.     private NacosConfigManager nacosConfigManager;
  11.     ......
  13.     @Bean
  14.     public ApplicationRunner runner() {
  15.         return args -> {
  16.             String dataId = "order-service-dev.yml";
  17.             String group = "DEFAULT_GROUP";
  18.             // 通过NacosConfigManager Bean获取ConfigService
  19.             nacosConfigManager.getConfigService().addListener(dataId, group, new AbstractListener() {
  20.                 @Override
  21.                 public void receiveConfigInfo(String configInfo) {
  22.                     System.out.println("[Listener] " + configInfo);
  23.                     System.out.println("[Before User] " + redisConfig);
  25.                     // 将String内容转化为Properties对象，并将Properties属性值设置到对应的bean属性
  26.                     Properties properties = new Properties();
  27.                     try {
  28.                         properties.load(new StringReader(configInfo));
  29.                         String redisHost = properties.getProperty("spring.redis.host");
  30.                         String redisPort = properties.getProperty("spring.redis.port");
  31.                         int age = Integer.valueOf(properties.getProperty("user.age"));
  32.                         redisConfig.setHost(redisHost);
  33.                         redisConfig.setPort(redisPort);
  34.                     } catch (IOException e) {
  35.                         e.printStackTrace();
  36.                     }
  37.                     System.out.println("[After User] " + redisConfig);
  38.                 }
  39.             });
  40.         };
  41.     }
  42. }

2、运行服务，修改配置文件，查看监听配置结果。

此处使用 yaml 结果不明显，建议使用 properties。

image.png

3.3 实现Nacos自定义配置

3.3.1 环境配置切换

多套环境配置，可以在 bootstrap.yml 文件中指定环境，但是在真正的项目实施过程中通常的做法是通过 -Dspring.profiles.active=<profile> 参数指定其配置来达到环境间灵活的切换。

3.3.2 自定义namespace

Namespace 的常用场景之一是不同环境的配置的区分隔离，例如开发测试环境和生产环境的资源（如配置、服务）隔离等。默认情况下使用的是 public，如果需要使用自定义的命名空间，可以通过以下配置来实现：

  1. spring.cloud.nacos.config.namespace=b3404bc0-d7dc-4855-b519-570ed34b62d7

3.3.3 自定义Group

默认使用的是 DEFAULT_GROUP ，如果需要自定义自己的 Group，可以通过以下配置来实现：

  1. spring.cloud.nacos.config.group=DEVELOP_GROUP

注：该配置必须放在 bootstrap.properties 文件中。并且在添加配置时 Group 的值一定要和 spring.cloud.nacos.config.group的配置值一致。

3.3.4 自定义扩展的Data ID

Nacos Config 从 0.2.1 版本后，可支持自定义 Data Id 的配置。关于这部分详细的设计可参考这里，案例如下：

  1. spring.application.name=opensource-service-provider
  2. spring.cloud.nacos.config.server-addr=127.0.0.1:8848
  4. # config external configuration
  5. # 1、Data Id 在默认的组 DEFAULT_GROUP,不支持配置的动态刷新
  6. spring.cloud.nacos.config.ext-config[0].data-id=ext-config-common01.properties
  8. # 2、Data Id 不在默认的组，不支持动态刷新
  9. spring.cloud.nacos.config.ext-config[1].data-id=ext-config-common02.properties
  10. spring.cloud.nacos.config.ext-config[1].group=GLOBALE_GROUP
  12. # 3、Data Id 既不在默认的组，也支持动态刷新
  13. spring.cloud.nacos.config.ext-config[2].data-id=ext-config-common03.properties
  14. spring.cloud.nacos.config.ext-config[2].group=REFRESH_GROUP
  15. spring.cloud.nacos.config.ext-config[2].refresh=true

3.3.5 配置优先级

Nacos Config 目前提供了三种配置能力从 Nacos 拉取相关的配置

  • A: 通过 spring.cloud.nacos.config.shared-dataids 支持多个共享 Data Id 的配置；
  • B: 通过 spring.cloud.nacos.config.ext-config[n].data-id 的方式支持多个扩展 Data Id 的配置；
  • C: 通过内部相关规则(应用名、应用名+ Profile )自动生成相关的 Data Id 配置；

当三种方式共同使用时，他们的一个优先级关系是：A < B < C

3.3.6 关闭Nacos-Config

有时候我们可能不会用到 nacos 的配置中心，可以直接关闭。

  1. spring.cloud.nacos.config.enabled = false

3.3.7 其他配置

Key 默认值 说明
spring.cloud.nacos.config.server-addr

| Nacos Server 启动监听的ip地址和端口 | | spring.cloud.nacos.config.name |

| 先取 prefix，再去 name，最后取 spring.application.name | | spring.cloud.nacos.config.prefix |

| 先取 prefix，再去 name，最后取 spring.application.name | | spring.cloud.nacos.config.encode |

| 读取的配置内容对应的编码 | | spring.cloud.nacos.config.group | DEFAULT_GROUP | 配置对应的组 | | spring.cloud.nacos.config.fileExtension | properties | 配置项对应的文件扩展名，目前支持 properties 和 yaml(yml) | | spring.cloud.nacos.config.timeout | 3000 | 客户端获取配置的超时时间(毫秒) | | spring.cloud.nacos.config.endpoint |

| 地域的某个服务的入口域名，通过此域名可以动态地拿到服务端地址 | | spring.cloud.nacos.config.namespace |

| 常用场景之一是不同环境的配置的区分隔离，例如开发测试环境和生产环境的资源（如配置、服务）隔离等 | | spring.cloud.nacos.config.accessKey |

| 当要上阿里云时，阿里云上面的一个云账号名 | | spring.cloud.nacos.config.secretKey |

| 当要上阿里云时，阿里云上面的一个云账号密码 | | spring.cloud.nacos.config.contextPath |

| Nacos Server 对外暴露的 context path | | spring.cloud.nacos.config.clusterName |

| 配置成Nacos集群名称 | | spring.cloud.nacos.config.sharedDataids |

| 共享配置的 DataId, “,” 分割 | | spring.cloud.nacos.config.refreshableDataids |

| 共享配置中需要动态刷新的 DataId, “,” 分割 | | spring.cloud.nacos.config.extConfig |

| 属性是个集合，内部由ConfigPOJO 组成。Config有 3 个属性，分别是dataId,group以及refresh |

4. 使用Nacos-Discovery

4.1 案例说明

创建两个服务 order、stock，模拟两个服务调用，实现调用远程服务像本地服务一样丝滑。

4.2 服务创建

1、创建两个服务 order、stock，修改端口和服务名称。
2、在 order 服务启动类上引入 RestTemplate 这个 bean。
3、在 order 服务中创建 add 方法，使用 restTemplate 调用 stock 服务的 reduce 方法。

  1. @RestController
  2. @RequestMapping("/order")
  3. public class OrderController {
  5.     @Autowired
  6.     private RestTemplate restTemplate;
  8.     @RequestMapping("/add")
  9.     public String add() {
  10.         System.out.println("add success");
  11.         String msg = restTemplate.getForObject("http://localhost:8082/stock/reduce", String.class);
  12.         return "add success "+msg;
  13.     }
  14. }

4、测试，成功！但是这种 ip:端口是写死在代码里的，需要优化！

4.3 服务调用

1、在 RestTemplate 上加上 @LoadBalance 注解，开启负载均衡。
2、修改服务调用方式，改用 服务名称 来调用其他服务。

  1. @RestController
  2. @RequestMapping("/order")
  3. public class OrderController {
  5.     @Autowired
  6.     private RestTemplate restTemplate;
  8.     @RequestMapping("/add")
  9.     public String add() {
  10.         System.out.println("add success");
  11.         String msg = restTemplate.getForObject("http://stock-service/stock/reduce", String.class);
  12.         return "add success "+msg;
  13.     }
  14. }

4.4 注解@LoadBalanced

@LoadBalanced：开启负载均衡（默认轮询），加了@LoadBalanced注解，使用 RestTemplateCustomizer对所有标注了 @LoadBalanced 的 RestTemplate Bean添加了一个LoadBalancerInterceptor 拦截器。利用 RestTemplate 的拦截器，spring 可以对 restTemplate bean进行定制，加入 loadbalance拦截器进行ip:port的替换，也就是将请求的地址中的服务逻辑名转为具体的服务地址。另外当 spring 容器中有多个相同类型的 bean 的时候，可以通过 @LoadBalanced来进行区分，以便在注入的时候明确表明你要注入具体的哪个 bean，消除歧义。

4.5 其他配置

配置项 Key 默认值 说明
服务端地址 spring.cloud.nacos.discovery.server-addr Nacos Server 启动监听的 ip 地址和端口
服务名 spring.cloud.nacos.discovery.service ${spring.application.name} 注册的服务名
权重 spring.cloud.nacos.discovery.weight 1 取值范围 1 到 100，数值越大，权重越大
网卡名 spring.cloud.nacos.discovery.network-interface
注册的服务名
注册的 IP 地址 spring.cloud.nacos.discovery.ip 优先级最高
注册的端口 spring.cloud.nacos.discovery.port -1 默认情况下不用配置，会自动探测
命名空间 spring.cloud.nacos.discovery.namespace 常用场景之一是不同环境的注册的区分隔离，例如开发测试环境和生产环境的资源（如配置、服务）隔离等
AccessKey spring.cloud.nacos.discovery.access-key 当要上阿里云时，阿里云上面的一个云账号名
SecretKey spring.cloud.nacos.discovery.secret-key 当要上阿里云时，阿里云上面的一个云账号密码
Metadata spring.cloud.nacos.discovery.metadata 使用 Map 格式配置，用户可以根据自己的需要自定义一些和服务相关的元数据信息
日志文件名 spring.cloud.nacos.discovery.log-name
集群 spring.cloud.nacos.discovery.cluster-name DEFAULT Nacos 集群名称
接入点 spring.cloud.nacos.discovery.endpoint 地域的某个服务的入口域名，通过此域名可以动态地拿到服务端地址
是否集成 Ribbon ribbon.nacos.enabled true 一般都设置成 true 即可
是否开启 Nacos Watch spring.cloud.nacos.discovery.watch.enabled

5. Nacos集群部署

5.1 配置Nacos

1、准备3台 Nacos 服务器，这里为了省资源，放在一个服务器上，复制3份 nacos 安装包，修改为 nacos9001、nacos9002、nacos9003。
2、修改 conf\application.properties 的配置，使用外置数据源 要使用 mysql5.7+，并修改启动端口。

  1. spring.datasource.platform=mysql 
  2. db.num=1
  3. db.url.0=jdbc:mysql://127.0.0.1:3306/nacos?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
  4. db.user.0=root
  5. db.password.0=123456
  6. server.port=9001

3、将 conf\cluster.conf.example 改为 cluster.conf，添加节点配置：

  1. 192.168.58.100:9001
  2. 192.168.58.100:9002
  3. 192.168.58.100:9003

4、将配置同步到其他 nacos 目录中。
5、创建 mysql 数据库，名称为 nacos，sql文件位置：conf\nacos-mysql.sql。
6、如果出现内存不足：修改启动脚本（bin\startup.sh）的 jvm 参数。

  1. JAVA_OPT="${JAVA_OPT} -server -Xms512m -Xmx512m -Xmn256 -XX:MetaspaceSize=64m -XX:MaxMetaspaceSize=128m"

7、分别启动 nacos9001，nacos9002，nacos9003，可以从页面中获取到集群节点。

这里本来是三个节点，nacos9002 启动失败，直接下线。

image.png

5.2 配置Nginx

1、添加官方源仓库。

  1. yum install -y yum-utils
  2. yum-config-manager --add-repo https://openresty.org/package/centos/openresty.repo

2、安装 openresty。

  1. yum install -y openresty
  2. cd /usr/local/openresty/

3、修改 nginx 配置文件，添加以下内容：

  1. # vim nginx/conf/nginx.conf
  2. upstream nacoscluster {
  3.         server 192.168.58.100:9001;
  4.         server 192.168.58.100:9002;
  5.         server 192.168.58.100:9003;
  6.     }
  7.     server {
  8.         listen        8847;
  9.         server_name   localhost;
  11.         location /nacos/{
  12.             proxy_pass http://nacoscluster/nacos/;
  13.         }
  14.     }

Nacos入门 - 图6
4、启动 nginx，访问： http://192.168.58.100:8847/nacos/#/login。应用中的 nacos 配置可以修改为: server-addr: 192.168.58.100:8847

  1. cd nginx/sbin/
  2. ./nginx

5.3 prometheus+grafana监控Nacos

Nacos0.8.0 版本完善了监控系统，支持通过暴露 metrics 数据接入第三方监控系统监控 Nacos 运行状态。
1、搭建 Nacos 集群暴露 metrics 数据：配置 application.properties 文件，暴露 metrics 数据。

  1. management.endpoints.web.exposure.include=*

2、搭建 prometheus 采集 Nacos metrics 数据：

  1. # 下载prometheus安装包
  2. tar xvfz prometheus-*.tar.gz
  3. cd prometheus-*
  5. # 修改配置文件prometheus.yml采集Nacos metrics数据
  6. metrics_path: '/nacos/actuator/prometheus'
  7.     static_configs:
  8.       - targets: ['{ip1}:9001','{ip2}:9001','{ip3}:9002']
  10. # 启动prometheus服务
  11. ./prometheus --config.file="prometheus.yml"

3、搭建 grafana 图形化展示 metrics 数据，访问 grafana: http://{ip}:3000。

  1. sudo yum install https://s3-us-west-2.amazonaws.com/grafana-releases/release/grafana-5.2.4-1.x86_64.rpm
  2. sudo service grafana-server start