SpringCloudAlibaba-Nacos

SpringCloudAlibaba-Nacos

文章参考

SpringCloud Alibaba实战（6：nacos-server服务搭建）_三分恶的博客-CSDN博客_nacos server

nacos 实战（史上最全） - 疯狂创客圈 - 博客园 (cnblogs.com)

https://blog.csdn.net/weixin_43464964/article/details/123272248

什么是Nacos？

Nacos是阿里巴巴开源的一个动态服务发现、配置管理和服务管理平台。

官方网站：

什么是 Nacos

Nacos英文全称Dynamic Naming and Configuration Service，Na为naming/nameServer即注册中心,co为configuration即注册中心，service是指该注册/配置中心都是以服务为核心。

生态图

Nacos 无缝支持一些主流的开源生态，使用Nacos，可以简化服务发现、配置管理、服务治理及管理。

如果要把Nacas和SpringCloud Netflix的组件对标的话，那么：

Nacos = Eureka/Consule + Config + Admin

关于注册中心问题:既然有了Eureka ，为啥还要用Nacos？

与eureka对比

1 eureka 2.0闭源码了。

2 从官网来看nacos 的注册的实例数是大于eureka的,

3 因为nacos使用的raft协议,nacos集群的一致性要远大于eureka集群.

分布式一致性协议 Raft，与其他的分布式一致性算法比，Raft 相对比较简单并且易于实现

Raft 的数据一致性策略

Raft 协议强依赖 Leader 节点来确保集群数据一致性。即 client 发送过来的数据均先到达 Leader 节点，Leader 接收到数据后，先将数据标记为 uncommitted 状态，随后 Leader 开始向所有 Follower 复制数据并等待响应，

在获得集群中大于 N/2 个 Follower 的已成功接收数据完毕的响应后，Leader 将数据的状态标记为 committed，随后向 client 发送数据已接收确认，

在向 client 发送出已数据接收后，再向所有 Follower 节点发送通知表明该数据状态为committed。

关于配置中心问题:既然有了springcloud config，为啥还要用Nacos？

• springcloud config大部分场景结合git 使用, 动态变更还需要依赖Spring Cloud Bus 消息总线来通过所有的客户端变化.
• springcloud config不提供可视化界面
• nacos config使用长连接更新配置, 一旦配置有变动后，通知Provider的过程非常的迅速, 从速度上秒杀springcloud原来的config几条街,

目前的Spring Cloud Ailbaba 组件

• Nacos：一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。
• Sentinel：把流量作为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。
• AliCloud OSS: 阿里云对象存储服务（Object Storage Service，简称
  OSS），是阿里云提供的海量、安全、低成本、高可靠的云存储服务。您可以在任何应用、任何时间、任何地点存储和访问任意类型的数据。

Spring Cloud Alibaba 套件和Spring Cloud Netflix套件类比

• Nacos = Eureka/Consule + Config + Admin
• Sentinel = Hystrix + Dashboard + Turbine
• Dubbo = Ribbon + Feign
• RocketMQ = RabbitMQ
• Schedulerx = Quartz
• AliCloud OSS、AliCloud SLS 这三个应该是独有的

下载安装

Nacos Server下载地址：

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

standalone 单机模式

linux 下载的是 nacos-server-1.4.2.tar.gz

上传后解压

tar -xvf nacos-server-1.4.2.tar.gz

解压后进入 /nacos/bin 目录，启动服务

单机模式启动

sh startup.sh -m standalone

最后访问 http://192.168.2.128:8848/nacos 这里的ip换成你的ip；

如果是本地虚拟机，需要关防火墙

systemctl stop firewalld

最后打开页面可以看到登录页面

默认账号和密码为：nacos nacos

window 系统的解压 nacos-server-1.4.2.zip

进入 \nacos-server-1.4.2\nacos\bin 目录

然后 cmd 进入dos窗口

控制台输入命令 单机启动

startup.cmd -m standalone

一样的访问后台

http://192.168.233.128:8848/nacos

默认账号和密码为：nacos nacos

cluster 集群模式

测试环境，可以先用 standalone 模式，但是，生产环境可以使用 cluster 模式。

需要依赖 MySQL，然后改两个配置文件

conf/cluster.conf
conf/application.properties

1： cluster.conf，填入要运行 Nacos Server 机器的 ip

192.168.100.155
192.168.100.156
192.168.100.157    

2:先数据备份，修改 /conf/application.properties ，加入 MySQL 配置

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?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
db.user.0=root
db.password.0=root

### Connection pool configuration: hikariCP
db.pool.config.connectionTimeout=30000
db.pool.config.validationTimeout=10000
db.pool.config.maximumPoolSize=20
db.pool.config.minimumIdle=2

3: 创建一个名为nacos的 database，将/conf/nacos-mysql.sql 中的表结构导入刚才创建的库中

用的是mysql 5.7的

CREATE DATABASE `nacos` CHARACTER SET 'utf8' COLLATE 'utf8_bin';

重新启动

随便新建配置

可以看到数据库里面有写入了数据，说明数据库配置有效

Nacos Server 的配置数据是存在哪里呢？

我们没有对 Nacos Server 做任何配置，那么数据只有两个位置可以存储：

• 内存
• 本地数据库

现在重启刚刚在运行的 Nacos Server，会发现刚才加的 nacos.properties 配置还在，说明不是内存存储的。

打开NACOS_PATH/data，会发现里边有个derby-data目录，我们的配置数据现在就存储在这个库中

Derby 是 Java 编写的数据库，属于 Apache 的一个开源项目

Nacos采用的一个Leader节点，多个Follower节点的集群架构，数据一致性算法采用的是Raft。

Nacos基本原理

Nacos作为注册中心分为server与client。

Server采用Java编写，为client提供注册发现服务与配置服务。而client可以用多语言实现，client与微服务嵌套在一起，nacos提供sdk和openApi，如果没有sdk也可以根据openApi手动写服务注册与发现和配置拉取的逻辑。

注册中心原理

服务注册方法：服务注册的策略的是每5秒向nacos server发送一次心跳，心跳带上了服务名，服务ip，服务端口等信息。同时 nacos server也会向client 主动发起健康检查，支持tcp/http检查。如果15秒内无心跳且健康检查失败则认为实例不健康，如果30秒内健康检查失败则剔除实例。

配置中心原理

实战案例

注册中心

新建一个maven 的 父工程 my-test 以及两个maven的子工程

cloud-provider-8001
cloud-consumer-8002

父工程的pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.ung</groupId>
    <artifactId>my-test</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>my-url</module>
        <module>my-encryptor</module>
        <module>cloud-provider-8001</module>
        <module>cloud-consumer-8002</module>
    </modules>
    <!--打包方式  pom-->
    <packaging>pom</packaging>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <spring-cloud-alibaba-version>2021.0.1.0</spring-cloud-alibaba-version>
        <spring-cloud-version>2021.0.1</spring-cloud-version>
        <spring-boot-version>2.6.3</spring-boot-version>
        <junit-version>4.12</junit-version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${spring-cloud-alibaba-version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--springCloud的依赖-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud-version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--SpringBoot-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot-version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit-version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

新建子模块 cloud-provider-8001 maven项目，将其加入到 父项目下作为子项目；

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>my-test</artifactId>
        <groupId>com.ung</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-provider-8001</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
    </dependencies>
</project>

新建 application.yml

server:
  port: 8001

spring:
  application:
    name: nacos-producer
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.2.124:8848

新建主启动类 ServiceProviderApplication

package com.ung.cloud;


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient
public class ProviderApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProviderApplication.class, args);
    }
}

controller接口

package com.ung.cloud.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class EchoController {

    @GetMapping(value = "/echo/{string}")
    public String echo(@PathVariable String string) {
        System.out.println("被调用了，参数是："+string);
        return "Hello Nacos Discovery " + string;
    }
}

新建 cloud-consumer-8002 模块

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>my-test</artifactId>
        <groupId>com.ung</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-consumer-8002</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>

        <!--ibbon目前已经停止维护，新版SpringCloud（2021.x.x）用LoadBalancer替代了Ribbon。
        Spring Cloud全家桶在Spring Cloud Commons项目中，添加了Spring cloud Loadbalancer作为新的负载均衡器，并且做了兼容
        Nacos 2021版本已经没有自带ribbon的整合，所以无法通过修改Ribbon负载均衡的模式来实现nacos提供的负载均衡模式
        ，需要引入另一个支持的jar包loadbalancer。 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-loadbalancer</artifactId>
        </dependency>

    </dependencies>
</project>

application.yml 端口是8002

server:
  port: 8002

spring:
  application:
    name: nacos-consumer
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.2.124:8848

新建主启动类ServiceConsumerApplication

package com.ung.cloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient
public class ConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class, args);
    }
}

package com.ung.cloud.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class RestTemplateConfig {

    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

NacosController

使用 restTemplate 来调用发起服务调用

package com.ung.cloud.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;


@RestController
public class NacosController {

    @Autowired
    private LoadBalancerClient loadBalancerClient;

    @Autowired
    private RestTemplate restTemplate;

    @Value("${spring.application.name}")
    private String appName;

    @GetMapping("/echo/app-name")
    public String echoAppName() {
        //使用 LoadBalanceClient 和 RestTemolate 结合的方式来访问
        ServiceInstance serviceInstance = loadBalancerClient.choose("nacos-producer");
        String url = String.format("http://%s:%s/echo/%s", serviceInstance.getHost(), serviceInstance.getPort(), appName);
        System.out.println("request url:" + url);
        return restTemplate.getForObject(url, String.class);
    }
}

启动两个服务，可以在nacos看到成功注册

向8082 consumer 发起请求，可以看到成功调用

http://localhost:8002/echo/app-name

返回

Hello Nacos Discovery nacos-consumer

配置中心

基本概念

Profile

Java项目一般都会有多个Profile配置，用于区分开发环境，测试环境，准生产环境，生成环境等，每个环境对应一个properties文件（或是yml/yaml文件），然后通过设置 spring.profiles.active 的值来决定使用哪个配置文件。

Nacos Config的作用就把这些文件的内容都移到一个统一的配置中心，即方便维护又支持实时修改后动态刷新应用。

例如

spring:
  application:
    name: sharding-jdbc-provider
  jpa:
    hibernate:
      ddl-auto: none
      dialect: org.hibernate.dialect.MySQL5InnoDBDialect
      show-sql: true
  profiles:
     active: sharding-db-table    # 分库分表配置文件
    #active: atomiclong-id    # 自定义主键的配置文件
    #active: replica-query    # 读写分离配置文件

Data ID

当使用Nacos Config后，Profile的配置就存储到Data ID下，即一个Profile对应一个Data ID

Data ID的拼接格式：${prefix} - ${spring.profiles.active} . ${file-extension}

• prefix 默认为 spring.application.name 的值，也可以通过配置项 spring.cloud.nacos.config.prefix 来配置
• spring.profiles.active 取 spring.profiles.active 的值，即为当前环境对应的 profile
• file-extension 为配置内容的数据格式，可以通过配置项 spring.cloud.nacos.config.file-extension 来配置

Group

Group 默认为 DEFAULT_GROUP，可以通过 spring.cloud.nacos.config.group 来配置，当配置项太多或者有重名时，可以通过分组来方便管理

最后就和原来使用springcloud一样通过@RefreshScope 和@Value注解即可

通过Nacos的console 去增加配置

首先要在nacos中配置相关的配置，打开Nacos配置界面，依次创建2个Data ID

• nacos-config-demo-dev.yaml 开发环境的配置
• nacos-config-demo-test.yaml 测试环境的配置

1. nacos-config-demo-dev.yaml

   foot:
     bar: dev value is hallo dev!
   

2. nacos-config-demo-test.yaml

   foot:
     bar: test!!!
   

使用Nacos Config Client组件

cloud-service-provider 模块新增 config 依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>cloud-alibaba</artifactId>
        <groupId>com.ung</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-service-provider</artifactId>
    <dependencies>
        <!--config 依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--discovery 依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
    </dependencies>

</project>

新增 bootstrap.yml 配置文件

spring:
  application:
    name: nacos-config-demo-provider
  profiles:
    active:  dev
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.2.124:8848
      config:
        server-addr: 192.168.2.124:8848
        prefix: nacos-config-demo
        group: DEFAULT_GROUP
        file-extension: yaml
server:
  port: 18083

新增接口 ConfigGetController

@RefreshScope //支持Nacos的动态刷新功能。

package com.ung.cloud.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/config")
@RefreshScope //支持Nacos的动态刷新功能。
public class ConfigGetController {


    @Value("${foot.bar:empty}")
    private String bar;


    @Value("${spring.datasource.username:empty}")
    private String dbusername;

    //获取配置的内容
    @RequestMapping(value = "/bar", method = RequestMethod.GET)
    public String getBar() {
        return "bar is :" + bar;
    }

    //获取配置的内容
    @RequestMapping(value = "/dbusername", method = RequestMethod.GET)
    public String getDbusername() {
        return "db username is :" + bar;
    }
}

启动服务

访问链接 http://192.168.2.124:18083/config/bar

可以看到读取的是dev的配置信息

在页面在线修改配置文件

在不重新启动服务的基础上，会动态的刷新，再次请求链接

http://192.168.2.124:18083/config/bar

可以实现动态刷新配置内容

分类配置

多环境多项目管理

问题1：实际开发中，通常一个系统会准备dev开发环境test测试环境prod生产环境。如何保证指定环境启动时服务能正确读取到Nacos上相应环境的配置文件呢？
问题2：一个大型分布式微服务系统会有很多微服务子项目，每个微服务项目又都会有相应的开发环境、测试环境、预发环境、正式环境…那怎么对这些微服务配置进行管理呢？

Nacos的服务管理设计思路

Namespace+Group+Data ID三者关系？为什么这么设计？

类似Java里面的package名和类名 最外层的namespace是可以用于区分部署环境的，Group和DataID逻辑上区分两个目标对象。
三者情况
默认情况：

Namespace=public，

Group=DEFAULT_GROUP,

默认Cluster是DEFAULT Nacos默认的命名空间是public，Namespace主要用来实现隔离。

比方说我们现在有三个环境：开发、测试、生产环境，我们就可以创建三个Namespace，不同的Namespace之间是隔离的。
Group默认是DEFAULT_GROUP，Group可以把不同的微服务划分到同一个分组里面去 Service就是微服务；
一个Service可以包含多个Cluster（集群），Nacos默认Cluster是DEFAULT，Cluster是对指定微服务的一个虚拟划分。
比方说为了容灾，将Service微服务分别部署在了杭州机房和广州机房，这时就可以给杭州机房的Service微服务起一个集群名称（HZ），给广州机房的Service微服务起一个集群名称（GZ），还可以尽量让同一个机房的微服务互相调用，以提升性能。
最后是Instance，就是微服务的实例。

指定active和配置文件的DataID来实现环境区分

之前已经有 两个配置的 DataID

• nacos-config-demo-dev.yaml 开发环境的配置
• nacos-config-demo-test.yaml 测试环境的配置

修改项目里的 bootstrap.yml 配置文件，切换active 再重新启动

spring:
  application:
    name: nacos-config-demo-provider
  profiles:
#    active:  dev
    active:  test
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.2.124:8848
      config:
        server-addr: 192.168.2.124:8848
        prefix: nacos-config-demo
        group: DEFAULT_GROUP
        file-extension: yaml
server:
  port: 18083

通过Group实现环境区分

新建 nacos-config-demo-info.yaml 的Data ID在 DEV_GROUP 分组下

nacos-config-demo-dev.yaml

DEV_GROUP

foot:
  bar: DEV_GROUP !

再新建一个 TEST_GROUP 组 也是 nacos-config-demo-info.yaml

TEST_GROUP

foot:
  bar: TEST_GROUP  !

可以看到配置的 列表

最后在项目的配置文件 bootstrap.yml 里修改

切换到 DEV_GROUP 的 active是info

访问链接 http://192.168.2.124:18083/config/bar

返回的结果就是 DEV_GROUP 下的 info 设置的信息

通过不同的命名空间实现环境的区分

命名空间下新建两个命名空间，一个dev，一个test，然后使用唯一的命名空间id来实现读取不同的环境配置

最后看到列表有两个自定义的命名空间

在dev下新建配置(yaml 格式)

nacos-config-demo-dev.yaml

foot:
  bar: nacos-config-demo-dev.yaml from dev命名空间DEFAULT_GROUP组

在新建 DEV_GROUP 和 TEST_GROUP 的配置

最后可以看到在dev空间下有三个组，每个组的ID都是 nacos-config-demo-dev.yaml

最后在项目的bootstrap.yml 文件指定空间

这里的 36d8f48e-50ae-4e1b-a4fe-376a7fefc19d 就是 dev空间的 命名空间ID

通过切换组，可以获取在 dev空间下的配置

http://192.168.2.124:18083/config/bar

可以看到结果返回的就是对应组的配置信息；

总结

使用Namespace+Group+Data ID的方式可以灵活的实现环境配置，三层是最为合理的

举个简单的例子，我们开发中开发完成后可能要有自测，内外网环境等等的配置信息，通过在nacos上配置不同的组就可以时间环境的动态切换，而进入测试部门后又需要不同的测试环境，这时可以用上命名空间，另外命名空间还可以用于服务隔离，当我们不同的服务集群环境下配置信息不同时，可以用不同的命名空间来分配，类似于java程序中的（工程、模块、包），缺一不可。

nacos集群搭建

参考 http://t.csdn.cn/NAVmD

要搭建集群的话，那么肯定是不能用内嵌的数据库，不然数据无法共享。所以，集群搭建的时候我们需要将Nacos对接Mysql进行数据存储。

集群模式跟我们平时进行扩容是一样的，可以通过Nginx转发到多个节点，最前面挂一个域名即可

IP规划

通常如果我们只是为了体验的话，直接在本地起动3个实例就可以了，没必要真的去搞三台服务器，下面我们就以在本地的方式来搭建集群。 将Nacos的解压包复制分成3份，分别是:

nacos
nacos1
nacos2

进入nacos的conf目录，编辑application.properties文件，增加数据库配置

# 指定数据源为Mysql
spring.datasource.platform=mysql

# 数据库实例数量
db.num=1
db.url.0=jdbc:mysql://localhost:3306/nacos?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true
db.user=root
db.password=root

复制代码同样的步骤进入nacos1和nacos2操作一遍，

唯一需要修改的就是application.properties文件中的server.port，默认nacos的server.port=8848，

我们在本地启动三个实例，那么端口肯定会冲突，所以其他2个实例的端口我们需要进行修改，比如nacos1修改成8847，nacos2修改成8846。
数据库配置信息好了后，我们需要将对应的数据库和表进行初始化，数据库脚本在conf目录下的nacos-mysql.sql中，执行即可。

最后一步需要配置一份集群节点信息，配置文件在conf目录下的cluster.conf.example文件，我们进行重命名成cluster.conf。 然后编辑cluster.conf文件，增加3个节点的信息，格式为IP:PORT，三个目录都一致即可。

127.0.0.1:8848
127.0.0.1:8847
127.0.0.1:8846

启动的话直接到bin目录下，执行./startup.sh就可以了，默认就是集群模式，不需要加任何参数

集群的使用

nacos集群的使用一般有4种方式：

• http://ip1:port/openAPI 直连ip模式，不同的节点，则需要修改ip才可以使用。
• http://VIP:port/openAPI VIP模式高可用，客户端vip即可，VIP下面挂server真实ip，部署比较麻烦，需要部署vip（keepalive）。
• http://nacos.com:port/openAPI 域名模式，可读性好，而且换ip方便，在host文件配置本地域名即可。
• http://反向代理:port/openAPI 反向代理模式

nginx反向代理

upstream nacos_server {
  server 127.0.0.1:8848;
  server 127.0.0.1:8847;
  server 127.0.0.1:8846;
}

server {
listen 8648;
   server_name localhost;
  #charset koi8-r;
  #access_log logs/host.access.log main;
  location / {
     proxy_pass http://nacos_server;
     index index.html index.htm;
   }
}

官网文档部署

https://nacos.io/zh-cn/docs/deployment.html

持久化配置（使用Mysql）

为了保证数据不丢失，每次重启后上次的数据还在，Nacos需要做数据持久化，当然他默认的也有数据持久化的方式。
Nacos自带了小型的derby数据库，在集群环境下每个Nacos使用自带的数据库会出现数据不一致问题，Nacos提供了方式可以将derby切换为Mysql。

1、新建数据库

在master数据库上新建 nacos 数据库，然后执行/conf/nacos-mysql.sql 中的表结构导入刚才创建的库中

用的是mysql 5.7的

CREATE DATABASE `nacos` CHARACTER SET 'utf8' COLLATE 'utf8_bin';

2、修改配置文件

修改Nacos目录 \nacos\conf 的配置文件application.properties，添加以下配置代表使用Mysql做Nacos数据库（注意配置信息需要修改为自己的）

建议提前备份好

cp application.properties application.properties.bk

添加自己的配置

spring.datasource.platform=mysql

db.num=1
db.url.0=jdbc:mysql://192.168.2.128:3301/nacos?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true
db.user=root
db.password=root

3、修改集群配置

我们用同一台服务器，3333，4444，5555这三个不同的端口来配置集群
将cluster.conf.example复制为cluster.conf，修改集群配置

cp -r cluster.conf.example cluster.conf

修改文件

 vi cluster.conf

输入i打开编辑模式，输入如下内容，注意修改IP为自己linux服务器的ip(ip不能写127.0.0.1)

192.168.2.128:3333
192.168.2.128:4444
192.168.2.128:5555

按ESC 后按 :wq 保存退出

4、修改nacos的启动命令，修改startup.sh脚本

同一台机器上集群启动时，还使用startup.sh就不知道要启动哪一台nacos，因此，我们要修改nacos的启动脚本，给他添加一个 -p 端口的参数，让nacos能根据端口区分启动哪一个
先进入 /bin目录下 先将原启动脚本备份

 cp startup.sh startup.sh.bk

接下来编辑 /bin 目录下的 startup.sh 文件

建议先下载出来，在windos上操作再上传

$OPTARG代表的是-x后跟的参数

修改后

修改启动的命令

拉到最下面，找到图中行

我们在启动命令上加上启动时指定端口，也就是获取我们上面输入的那个端口
修改后，-Dserver.port的意思是指定端口启动，${PORT}是获取我们上面第一步配置的-p参数

-Dserver.port=${PORT}

编辑好后保存退出
这时，我们输入以下命令就可以指定3333端口启动nacos了

./startup.sh -p 3333

Linux下Nginx配置负载分发

配置nginx 需要修改 nginx.conf 文件

先备份 nginx.conf

我这里用的是docker容器的nginx，直接操作挂载的文件就行；

cp nginx.conf nginx.conf.bk

修改配置

建议下载下来在win操作

#user  nobody;
worker_processes  1;

#error_log  logs/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;

#pid        logs/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       mime.types;
    default_type  application/octet-stream;

    #log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
    #                  '$status $body_bytes_sent "$http_referer" '
    #                  '"$http_user_agent" "$http_x_forwarded_for"';

    #access_log  logs/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  65;

    #gzip  on;
	
	upstream cluster{
		server 192.168.248.128:3333;
		server 192.168.248.128:4444;
		server 192.168.248.128:5555;
	}

    server {
        listen       1111;
        server_name  localhost;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        location / {
           # root   html;
           # index  index.html index.htm;
		   proxy_pass http://cluster;
        }

        #error_page  404              /404.html;

        # redirect server error pages to the static page /50x.html
        #
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }

        # proxy the PHP scripts to Apache listening on 127.0.0.1:80
        #
        #location ~ \.php$ {
        #    proxy_pass   http://127.0.0.1;
        #}

        # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
        #
        #location ~ \.php$ {
        #    root           html;
        #    fastcgi_pass   127.0.0.1:9000;
        #    fastcgi_index  index.php;
        #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
        #    include        fastcgi_params;
        #}

        # deny access to .htaccess files, if Apache's document root
        # concurs with nginx's one
        #
        #location ~ /\.ht {
        #    deny  all;
        #}
    }


    # another virtual host using mix of IP-, name-, and port-based configuration
    #
    #server {
    #    listen       8000;
    #    listen       somename:8080;
    #    server_name  somename  alias  another.alias;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}


    # HTTPS server
    #
    #server {
    #    listen       443 ssl;
    #    server_name  localhost;

    #    ssl_certificate      cert.pem;
    #    ssl_certificate_key  cert.key;

    #    ssl_session_cache    shared:SSL:1m;
    #    ssl_session_timeout  5m;

    #    ssl_ciphers  HIGH:!aNULL:!MD5;
    #    ssl_prefer_server_ciphers  on;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}

}

进入 nacos的 bin目录下

分别执行 启动nacos

./startup.sh -p 3333

./startup.sh -p 4444

./startup.sh -p 5555

最后启动 jps 查看启动情况

最后请求链接 http://192.168.2.128:3333/nacos 可以看到正常页面

启动nginx

指定配置文件启动

./nginx -c /usr/local/nginx/conf/nginx.conf

最后访问nginx的链接

http://192.168.2.128:1111/nacos

成功登录后添加配置，可以在数据库看到新加的配置