🍻 正在加载今日诗词....

SpringCloud Alibaba入门到精通（十四）- 服务注册和配置中心Nacos

阅读数： 次
原创 字数统计: 6.3k字   |   预计阅读时长≈ 29分钟

此文章主要讲解 springcloud 中的服务注册和配置中心 Nacos 的相关知识。

Spring Cloud Alibaba

Github 官网：https://github.com/alibaba/spring-cloud-alibaba

概述

之所以有 Spring CloudAlibaba，是因为Spring Cloud Netflix项目进入维护模式。

不是不更新了，是不会开发新组件了，所以，某些组件都有代替版了，比如 Ribbon 由 Loadbalancer 代替等等。

支持的功能

服务限流降级：默认支持 Servlet、Feign、RestTemplate、Dubbo 和 RocketMQ 限流降级功能的接入，可以在运行时通过控制台实时修改限流降级规则，还支持查看限流降级 Metrics 监控。

服务注册与发现：适配 Spring Cloud 服务注册与发现标准，默认集成了 Ribbon 的支持。

分布式配置管理：支持分布式系统中的外部化配置，配置更改时自动刷新。

消息驱动能力：基于 Spring Cloud Stream 为微服务应用构建消息驱动能力。

阿里云对象存储：阿里云提供的海量、安全、低成本、高可靠的云存储服务。支持在任何应用、任何时间、任何地点存储和访问任意类型的数据。

分布式任务调度：提供秒级、精准、高可靠、高可用的定时(基于 Cron 表达式)任务调度服务。同时提供分布式的任务执行模型，如网格任务。网格任务支持海量子任务均匀分配到所有 Worker (schedulerx-client)上执行。

这几乎可以将之前的 Spring Cloud NetFlix 代替。

怎么玩

1
2
3
4
5
6
7
8
<!--spring cloud Alibaba-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-alibaba-dependencies</artifactId>
    <version>2.1.0.RELEASE</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>

具体组件:

Nacos 简介

为什么叫 Nacos？

  • 前四个字母为 Naming 和 Configuration 的前两个字母，最后的 s 为 Service。

Nacos 是什么？

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

  • Nacos：Dynamic Naming and Configuration Service。

  • Nacos 就是注册中心和配置中心的结合，换言之 Nacos=Eureka+Config+Bus。

Nacos 能干嘛？

  • 替代Eureka做服务注册中心。

  • 替代Config做服务配置中心。

去哪里下？

各种注册中心比较

C（Consistency）：一致性

A（Availability）：可用性

P（Partition tolerance）：分许容错性

服务注册和发现 CAP 模型 控制台管理 社区活跃度
Eureka AP 支持 低（2.x 版本闭源）
Zookeeper CP 不支持 中
Consul CP 支持 高
Nacos AP 支持 高

据说 Nacos 在阿里内部有超过 10 万的实例运行，已经过了类似双十一等各种大型流量的考验。

安装和运行

安装

准备工作

  • 本地安装有JDK8和Maven3.x环境。

下载

运行

  • 解压缩安装包。

  • 直接在 bin 目录下，使用startup.cmd -m standalone命令启动 Nacos。以单机模式启动。

  • 命令运行成功后直接访问 http://localhost:8848/nacos （默认用户名和密码为nacos/nacos）。

image-20210121122307564

  • 登录成功，结果页面：

image-20210121122358830

Nacos 作为服务注册中心

记得在父工程中引入 Spring Cloud Alibaba 依赖

1
2
3
4
5
6
7
8
<!--spring cloud Alibaba-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-alibaba-dependencies</artifactId>
    <version>2.1.0.RELEASE</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>

基于 Nacos 的服务提供者

新建 Module

cloudalibaba-provider-payment9001

POM 文件

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
<?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>spring_cloud_atguigu_2020</artifactId>
        <groupId>com.itjing.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloudalibaba-provider-payment9001</artifactId>

    <dependencies>
        <!-- springcloud alibaba nacos 依赖 -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!-- springboot整合Web组件 -->
        <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>

        <!-- 日常通用jar包，导入了mybatis记得配置数据库url-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- 引入自己定义的api通用包-->
        <dependency>
            <groupId>com.itjing.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${project.version}</version>
        </dependency>
    </dependencies>
</project>

YML 文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
server:
  port: 9001

spring:
  application:
    name: nacos-payment-provider
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 # 配置Nacos的地址

# 暴露监控端点
management:
  endpoints:
    web:
      exposure:
        include: '*'

主启动类

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

业务逻辑

1
2
3
4
5
6
7
8
9
10
11
@RestController
public class PaymentController {

    @Value("${server.port}")
    private String serverPort;

    @GetMapping(value = "/payment/nacos/{id}")
    public String payment(@PathVariable(value = "id") Integer id) {
        return "Nacos的注册中心的端口是：" + serverPort + "，id是：" + id;
    }
}

测试

启动 9001

访问： http://localhost:8848/nacos/ ，查看注册情况

image-20210121124302824

再次新建提供者

Nacos 自带负载均衡机制

为了演示 nacos 的负载均衡，参照 9001 新建 9002

或者可以拷贝虚拟端口映射：

image-20210121124934503

基于 Nacos 的服务消费者

新建 Module

cloudalibaba-consumer-order80

POM 文件

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
<?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>spring_cloud_atguigu_2020</artifactId>
        <groupId>com.itjing.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloudalibaba-consumer-order80</artifactId>

    <dependencies>
        <!-- springcloud alibaba nacos 依赖 -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!-- springboot整合Web组件 -->
        <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>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- 引入自己定义的api通用包-->
        <dependency>
            <groupId>com.itjing.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${project.version}</version>
        </dependency>
    </dependencies>
</project>

YML 文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
server:
  port: 80

spring:
  application:
    name: nacos-order-consumer
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 # 配置Nacos的地址

# 暴露监控端点
management:
  endpoints:
    web:
      exposure:
        include: '*'

# 消费者将要去访问的微服务名称（成功注册进nacos的微服务提供者）
service-url:
  nacos-user-service: http://nacos-payment-provider

主启动类

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

业务逻辑

配置类

nacos 底层也是 ribbon，需要注入ReatTemplate

1
2
3
4
5
6
7
8
9
@Configuration
public class ApplicationContextConfig {

    @Bean
    @LoadBalanced // 负载均衡
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

Controller

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@RestController
@Slf4j
public class OrderController {

    @Value("${service-url.nacos-user-service}")
    private String serverURL;

    @Resource
    private RestTemplate restTemplate;

    @GetMapping("/consumer/nacos/{id}")
    public String orderId(@PathVariable("id") Long id) {
        return restTemplate.getForObject(serverURL + "/payment/nacos/" + id, String.class);
    }
}

测试

  1. 启动两个提供者 9001/9002
  2. 启动消费者 80

测试访问： http://localhost/consumer/nacos/1 ，成功，并且实现了负载均衡。

各种服务注册中心对比

Nacos 生态图

image-20210121131825784

Nacos 服务发现实例模型

image-20210121131908066

Nacos 和其他注册中心特性对比

image-20210121131949281

Nacos 支持 AP 和 CP 模式的切换

概述

  • 如果不需要存储服务级别的信息且服务实例是通过 Nacos Client 注册，并能够保持心跳上报，那么就可以选择 AP 模式。当前主流的服务如 Spring Cloud 和 Dubbo 服务，都适用于 AP 模式，AP 模式为了服务的可用性而减弱了一致性，因此 AP 模式下只支持临时实例。

  • 如果需要在服务级别编辑或者存储配置信息，那么 CP 是必须，K8s 服务和 DNS 服务则使用于 CP 模式。CP 模式下支持注册服务化实例，此时则是以 Raft 协议为集群运行模式，该模式下注册实例之前必须先注册服务，如果服务不存在，则会返回错误。

模式切换

  • Nacos 集群默认支持的 CAP 原则中的 AP 原则，但是也可以支持 CP 原则，切换命令如下：
1
curl -X PUT '$NACOS_SERVER:8848/nacos/v1/ns/operator/switches?entry=serverMode&value=CP'
  • 同时微服务的 bootstrap.properties 需要配置如下选择指明注册为临时/永久实例（AP 模式不支持数据一致性，所以只支持服务注册的临时实例，CP 模式支持服务注册的永久实例）。
1
2
#false为永久实例，true表示临时实例开启，注册为临时实例
spring.cloud.nacos.discovery.ephemeral=false

Nacos 配置中心

Nacos 作为服务配置中心的基础配置

新建 Module

cloudalibaba-nacos-config3377

POM 文件

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
29
30
31
32
33
34
35
<?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>spring_cloud_atguigu_2020</artifactId>
        <groupId>com.itjing.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloudalibaba-nacos-config3377</artifactId>

    <dependencies>
        <!--nacos-config-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>
        <!--nacos-discovery-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!--web + actuator-->
        <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>
    </dependencies>
</project>

YML 文件

  • Nacos 和 Spring Cloud Config 一样，在项目初始化的时候，要保证先从配置中心进行配置拉取，拉取配置之后，才能保证项目的正常启动。

  • SpringBoot 中配置文件的加载时存在优先级顺序的，bootstrap 优先级高于 application。

bootstrap.yml ，系统级别的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
server:
  port: 3377
spring:
  application:
    name: nacos-config-client
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 # nacos作为服务注册中心
      config:
        server-addr: localhost:8848 # nacos作为服务配置中心
        file-extension: yaml # 指定yaml格式的配置

management:
  endpoints:
    web:
      exposure:
        include: '*'

application.yml ，用户自定义的

1
2
3
spring:
  profiles:
    active: dev # 表示开发环境

以上两个文件放在一起，表明从 nacos 上拉取 dev 环境的配置文件。

主启动类

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

Controller

1
2
3
4
5
6
7
8
9
10
11
12
@RestController
@RefreshScope  //支持Nacos的动态刷新
public class ConfigClientController {

    @Value("${config.info}")
    private String configInfo;

    @GetMapping("/config/info")
    public String getConfigInfo(){
        return configInfo;
    }
}

向 Nacos 中添加配置信息

  • Nacos 中的 dataId 的组成格式和 Spring Cloud 中的配置文件的匹配规则。

    image-20210121135824112

    1
    ${prefix}-${spring.profiles.active}.${file-extension}

  • 官方地址。

image-20210121134449139

从上面可以看到重要的一点，配置文件的名称第二项，spring.profiles.active 是依据当前环境的 profile 属性值的，也就是这个值如果是 dev，即开发环境，它就会读取 dev 的配置信息，如果是 test，测试环境，它就会读取 test 的配置信息，就是从 spring.profile.active 值获取当前应该读取哪个环境下的配置信息。

则根据之前的配置文件， Nacos 的 Data Id 应为：nacos-config-client-dev.yaml

image-20210121135217231

新建配置：

image-20210121135344895

image-20210121135523044

测试

启动 cloudalibaba-nacos-config3377 的主启动类

调用接口查看： http://localhost:3377/config/info

自带动态刷新

修改 Nacos 中的 yaml 配置文件，再次调用查看配置的接口，就会发现配置已经刷新。

这样以后就不用在项目中建立配置中心了，客户端直接刷新了。

Nacos 作为服务配置中心的分类配置

问题：多项目多环境问题

问题 1

  • 在实际开发中，通常一个系统会准备：dev开发环境，test测试环境，prod生产环境。如何保证指定环境启动时服务能正确读取到 Nacos 上相应环境的配置文件？

问题 2

  • 一个大型分布式微服务会有很多微服务子项目，每个微服务服务又都会有相应的开发环境、测试环境、预发布环境、正式环境等等，如果对这些微服务配置进行管理？

Nacos 图形化界面管理

配置列表

image-20210121141504661

命名空间

image-20210121141539625

Namespace+Group+DataId 什么关系，为什么这么设计？

Namespace+Group+DataId 是什么？

  • Namespace+Group+DataId 类似于 Java 里面的 package（包名）和类名。

  • 最外层的 namespace 是可以用于区分部署环境的，Group 和 DataId 逻辑上区分两个目标对象。

Namespace+Group+DataId 的关系以及设计的意图

image-20210121142031151

  • 默认情况下，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，就是微服务的实例。

三种方案加载配置

DataID 方案

  1. 指定 spring.profile.active 和配置文件的 DataID 来使不同环境下读取不同的配置（常用）
  2. 默认空间+默认分组+新建 dev 和 test 两个 DataID：
  • 新建 dev 配置 DataID
  • 新建 test 配置 DataID

image-20210121142931950

  1. 通过 spring.profile.active 属性就能进行多环境下配置文件的读取

image-20210121143320250

Group 方案

通过 Group 实现环境区分，新建配置指定不同 Group

image-20210121144207568

image-20210121144354499

在 bootstrap.yml 中的 config 下增加一条 group 的配置即可

image-20210121145409117

Namespace 方案

新建 dev/test 的 Namespace，会自动给创建的命名空间分配命名空间ID。

image-20210121145709091

image-20210121145741846

可以看到多出了两个命名空间。

image-20210121145938444

image-20210121150621097

dataid、group、namespace 三者关系如下：

（不同的 dataid，是相互独立的，不同的 group 是相互隔离的，不同的 namespace 也是相互独立的）

Nacos 集群和持久化配置（重要）

官网说明

官网地址

官网集群架构图

image-20210121151556045

Nacos 集群架构图理解

image-20210121151724863

说明

单机版的 Nacos 持久化配置

  • Nacos 默认自带的是嵌入式数据库derby，不方便观察数据存储的基本情况，需要将数据源由 derby 切换到 MySQL。

  • derby 切换到 MySQL 的步骤：

    • 安装 MySQL 数据库，版本要求 5.6.5+。
    • 初始化 MySQL 数据库，数据库的 sql 脚本在nacos/conf/nacos-mysql.sql文件中

  • 修改conf/application.properites文件，增加支持 MySQL 数据源配置（目前只支持MySQL），添加 MySQL 的数据源的 URL、用户和密码等。

    1
    2
    3
    4
    5
    6
    spring.datasource.platform=mysql

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

  • 启动 Nacos

Linux 版 Nacos+MySQL 生产环境配置

准备工作

  • Nginx：1 个。

  • Nacos Server：3 个。

  • MySQL：1 个（IP 地址为 192.168.32.100，端口是 3306）。

  • Centos7：3 个（IP 地址分别为 192.168.32.100、192.168.32.101 和 192.168.32.102）。

逻辑架构图

image-20210121154017591

在每个 Centos7 系统中下载 Linux 版本的 Nacos

点我下载

1
2
3
cd /opt
wget https://github.91chifun.workers.dev//https://github.com/alibaba/nacos/releases/download/1.3.2/nacos-server-1.3.2.tar.gz
tar -zxvf nacos-server-1.3.2.tar.gz

数据库环境

将 nacos-mysql.sql 文件导入到每个 CentOS7 系统的 MySQL 数据库中

持久化配置

在每个 CentOS7 系统上的 Nacos 的conf/application.properties文件中加入如下的配置：

1
2
3
4
5
6
7
# 在最后一行添加
spring.datasource.platform=mysql

db.num=1
db.url.0=jdbc:mysql://192.168.32.100:3306/nacos_config?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true
db.user=root
db.password=123456

集群配置

  • 在每个 CentOS7 系统上的 Nacos 的conf目录，复制cluster.conf.example文件，并改名为cluster.conf：
1
cp cluster.conf.example cluster.conf
  • 修改每个 CentOS7 系统上的 Nacos 的conf/cluster.conf文件，并添加如下的配置，指定哪几个节点是 Nacos 集群：
  • 前面的 ip 地址不能写 127.0.0.1，必须是用 Linux 命令 hostname -i 能够识别的 ip
1
2
3
192.168.32.100:8848
192.168.32.101:8848
192.168.32.102:8848
  • 分别启动各个 Nacos 服务。
1
2
/opt/nacos/bin
./startup.sh

修改 Nginx 的配置文件并启动 Nginx

  • nginx.conf
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
#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 nacos {
        server 192.168.32.100:8848;

        server 192.168.32.101:8848;

        server 192.168.32.103:8848;
    }
    # -----------修改-----------------
    server {
        # -----------修改-----------------
        listen       8089;
        # -----------修改-----------------
        server_name  localhost;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        location / {
            root   html;
            index  index.html index.htm;
        }
        # -----------修改-----------------
        location ^~ /nacos{
            proxy_pass http://nacos;

            # nginx非80端口处理

            proxy_set_header        Host $host:$server_port;

            # 获取真实IP

            proxy_set_header        X-Real-IP $remote_addr;

            # 获取代理者的真实ip

            proxy_set_header       X-Forwarded-For        $proxy_add_x_forwarded_for;

            # 解决getScheme，isSecure，sendRedirect

            proxy_set_header X-Forwarded-Scheme  $scheme;

            client_max_body_size    1000m;

            client_body_buffer_size 128k;

            proxy_connect_timeout   90;

            proxy_send_timeout      90;

            proxy_read_timeout      90;

            proxy_buffer_size       4k;

            proxy_buffers           4 32k;

            proxy_busy_buffers_size 64k;

            proxy_temp_file_write_size 64k;

        }
        # -----------修改-----------------
        #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;
    #    }
    #}

}

在一台 Linux 上搭建伪集群

1、由于学习配置的问题，这里只能在一台机器上搭建伪集群。

2、下载安装 Nacos 的 Linux 版安装包，解压

3、进入 mysql，执行 nacos 自带的 sql 文件

4、修改配置文件，切换为我们的 mysql，即 conf/application.properties，和上面一样

5、修改 conf/cluster.conf，指定哪几个节点是 Nacos 集群，这里使用 3333/4444/5555 作为三个 Nacos 节点监听的端口

1
2
3
192.168.111.144:3333
192.168.111.144:4444
192.168.111.144:5555

6、模拟三台 nacos 服务，编辑 nacos 的 startup 启动脚本，使他能够支持不同的端口启动多次

1597812716080

修改 startup.sh，内容如下：

1597812799242

1597813020494

1597815675706

7、nginx 配置，修改nginx.conf

​

8、启动 Nacos

1
2
3
./startup.sh -p 3333
./startup.sh -p 4444
./startup.sh -p 5555

9、启动 nginx

10、测试，访问 192.168.111.144:1111，如果可以进入 nacos 的 web 界面，就证明安装成功了

11、新建配置测试，在 Linux 服务器查看 mysql 是否插入一条记录

12、将微服务注册到 Nacos 集群

13、启动微服务，进入 Nacos 界面，可以看到，已经注册成功

image-20210121163939239

14、总结

image-20210121164102621

Docker 搭建集群

官方教程地址：点我跳转

单服务器部署集群

1、从 git 上下载 nacos-docker 项目，本地目录为/opt/nacos-docker

1
2
3
4
5
6
7
8
# 如果linux上没有 git ，需要安装
yum -y install git

# 克隆项目，官方的github下载太慢
git clone https://github.com/nacos-group/nacos-docker.git /opt/nacos-docker

# 可以使用国内gitee的下载
git clone https://gitee.com/BetterMe1125/nacos-docker.git /opt/nacos-docker

2、安装 docker-compose（ docker 提供的一个命令行工具，用来定义和运行由多个容器组成的应用）

1
2
3
4
5
# 官方
sudo curl -L "https://github.com/docker/compose/releases/download/1.27.4/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

# 这个可能快点
curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.5/docker-compose-`uname -s`-`uname -m`  > /usr/local/bin/docker-compose

image-20210104145125137

3、给 docker-compose 授权

1
[root@iz2ze4lfnjztrjppyfbqo1z bin]# chmod +x /usr/local/bin/docker-compose

image-20210104145337254

4、运行 nacos-docker 脚本

首先对 cluster-hostname.yaml 进行修改

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
version: '3'
services:
  nacos1:
    hostname: nacos1
    container_name: nacos1
    image: nacos/nacos-server:1.1.4
    environment:
      - MODE=cluster # 集群模式
      - NACOS_SERVERS=nacos1:8848 nacos2:8848 nacos3:8848
      - PREFER_HOST_MODE=hostname
      - SPRING_DATASOURCE_PLATFORM=mysql
      - MYSQL_MASTER_SERVICE_HOST=47.94.217.177 # mysql数据库对应的ip
      - MYSQL_MASTER_SERVICE_PORT=3306 # mysql数据库对应的端口
      - MYSQL_MASTER_SERVICE_DB_NAME=nacos_config
      - MYSQL_MASTER_SERVICE_USER=root
      - MYSQL_MASTER_SERVICE_PASSWORD=123456
      - MYSQL_DATABASE_NUM=1 # 数据源为1个
      - JVM_XMS=128m
      - JVM_XMX=128m
      - JVM_XMN=128m
    volumes:
      - ./cluster-logs/nacos1:/home/nacos/logs
      - ./init.d/custom.properties:/home/nacos/init.d/custom.properties
    ports:
      - '8848:8848'
      - '9555:9555'
    restart: on-failure

  nacos2:
    hostname: nacos2
    image: nacos/nacos-server:1.1.4
    container_name: nacos2
    environment:
      - MODE=cluster # 集群模式
      - NACOS_SERVERS=nacos1:8848 nacos2:8848 nacos3:8848
      - PREFER_HOST_MODE=hostname
      - SPRING_DATASOURCE_PLATFORM=mysql
      - MYSQL_MASTER_SERVICE_HOST=47.94.217.177 # mysql数据库对应的ip
      - MYSQL_MASTER_SERVICE_PORT=3306 # mysql数据库对应的端口
      - MYSQL_MASTER_SERVICE_DB_NAME=nacos_config
      - MYSQL_MASTER_SERVICE_USER=root
      - MYSQL_MASTER_SERVICE_PASSWORD=123456
      - MYSQL_DATABASE_NUM=1 # 数据源为1个
      - JVM_XMS=128m
      - JVM_XMX=128m
      - JVM_XMN=128m
    volumes:
      - ./cluster-logs/nacos2:/home/nacos/logs
      - ./init.d/custom.properties:/home/nacos/init.d/custom.properties
    ports:
      - '8849:8848'
    restart: on-failure
  nacos3:
    hostname: nacos3
    image: nacos/nacos-server:1.1.4
    container_name: nacos3
    environment:
      - MODE=cluster # 集群模式
      - NACOS_SERVERS=nacos1:8848 nacos2:8848 nacos3:8848
      - PREFER_HOST_MODE=hostname
      - SPRING_DATASOURCE_PLATFORM=mysql
      - MYSQL_MASTER_SERVICE_HOST=47.94.217.177 # mysql数据库对应的ip
      - MYSQL_MASTER_SERVICE_PORT=3306 # mysql数据库对应的端口
      - MYSQL_MASTER_SERVICE_DB_NAME=nacos_config
      - MYSQL_MASTER_SERVICE_USER=root
      - MYSQL_MASTER_SERVICE_PASSWORD=123456
      - MYSQL_DATABASE_NUM=1 # 数据源为1个
      - JVM_XMS=128m
      - JVM_XMX=128m
      - JVM_XMN=128m
    volumes:
      - ./cluster-logs/nacos3:/home/nacos/logs
      - ./init.d/custom.properties:/home/nacos/init.d/custom.properties
    ports:
      - '8850:8848'
    restart: on-failure

如果您的服务器内存资源足够（大于 4G），则可以直接运行。

否则会出现三台 nacos 机器疯狂重启的情况，这是我们可以选择增加内存资源或者修改 nacos 运行配置，修改内存大小。

JVM 参数根据自己服务器调整。nacos默认就2G，不设置的话容器就会不断重启，还非常卡。找了蛮久才发现是这个原因。

部署命令：

1
2
3
4
cd /opt/nacos-docker

# 使用 example/cluster-hostname.yaml 构建集群
docker-compose -f example/cluster-hostname.yaml up

5、停止、启动

1
2
3
4
# 停止
docker-compose -f ./example/cluster-hostname.yaml stop
# 启动
docker-compose -f ./example/cluster-hostname.yaml start

启动成功后 我们可以访问 nacos 控制台 http://xxxx:8848/nacos/ ，默认用户名和密码都是 nacos。

多台服务器通过 ip 部署集群

修改每个服务器中 nacos 的 cluster-ip.yaml ，每换一个服务器就把 NACOS_SERVER_IP 改一下就好了

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
29
30
31
version: '3'
services:
  nacos:
    container_name: nacos1
    image: nacos/nacos-server:1.1.4
    networks:
      - nacos_net
    environment:
      - MODE=cluster # 集群模式
      - NACOS_SERVERS=IP1:8848 IP2:8848 IP3:8848 # IP1,IP2是对应的服务器外网,PORT1,PORT2是对应的nacos服务端口
      - NACOS_SERVER_IP=当前服务器IP # 服务器外网
      - SPRING_DATASOURCE_PLATFORM=mysql
      - MYSQL_MASTER_SERVICE_HOST=xxx.xxx.xx.xx# mysql数据库对应的ip
      - MYSQL_MASTER_SERVICE_PORT=3306 # mysql数据库对应的端口
      - MYSQL_MASTER_SERVICE_DB_NAME=nacos_config
      - MYSQL_MASTER_SERVICE_USER=root
      - MYSQL_MASTER_SERVICE_PASSWORD=123456
      - MYSQL_DATABASE_NUM=1 # 数据源为1个
      - JVM_XMS=256m
      - JVM_XMX=256m
      - JVM_XMN=256m
    volumes:
      - ./cluster-logs/nacos:/home/nacos/logs
      - ./init.d/custom.properties:/home/nacos/init.d/custom.properties
    ports:
      - '8848:8848'
      - '9555:9555'
    restart: on-failure
networks:
  nacos_net:
    driver: bridge

部署命令：

1
docker-compose -f cluster-ip.yaml up -d

nginx 配置

nginx-compose.yaml

1
2
3
4
5
6
7
8
9
10
11
12
13
nginx:
  restart: always
  image: nginx:1.17
  container_name: nginx
  ports:
    - nginx端口号:映射端口号
  volumes:
    - /home/nginx/nginx.conf:/etc/nginx/nginx.conf
  ulimits:
    nproc: 65535
    nofile:
      soft: 65535
      hard: 65535

nginx.conf 配置文件，主要是改 http 中的配置

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
user  nginx;
worker_processes  1;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       /etc/nginx/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  /var/log/nginx/access.log  main;

    sendfile        on;

    keepalive_timeout  65;



    upstream cluster{
    	# 此处三个修改成对应的ip
        server nacos1的IP:port weight=1 max_fails=2 fail_timeout=30s;
		server nacos2的IP:port weight=1 max_fails=2 fail_timeout=30s;
		server nacos3的IP:port weight=1 max_fails=2 fail_timeout=30s;
    }

    server{
        listen nginx端口号; # 此处修改
        server_name nginx的IP; # 此处修改

		large_client_header_buffers 4 16k;     # 读取大型客户端请求头的缓冲区的最大数量和大小
        client_max_body_size 300m;     #设置nginx能处理的最大请求主体大小。
        client_body_buffer_size 128k;  #请求主体的缓冲区大小。

		fastcgi_connect_timeout 300;
		fastcgi_send_timeout 300;
        fastcgi_read_timeout 300;
		fastcgi_buffer_size 64k;
        fastcgi_buffers 8 32k;
        fastcgi_busy_buffers_size 128k;
		fastcgi_temp_file_write_size 64k;

	location / {
	    proxy_pass http://cluster;
	}
    }
    include /etc/nginx/conf.d/*.conf;
}

这样就可以通过 nginx的IP:port/nacos 来访问 nacos 集群啦。

将微服务注册到 Nacos 集群

1
2
3
4
5
6
7
spring:
  application:
    name: SYSTEM-SERVICE
  cloud:
    nacos:
      discovery:
        server-addr: # 这里写nginx的IP:port即可，由nginx转发到其中某个节点

参考文章：

https://www.freesion.com/article/9674637134/

https://blog.csdn.net/weixin_43993065/article/details/105607999

本文作者： LiJing
发布时间： 2021-01-21
最后更新： 2024-06-24
本文标题： SpringCloud Alibaba入门到精通（十四）- 服务注册和配置中心Nacos
本文链接： https://blog-yilia.xiaojingge.com/posts/32dc53e7.html
版权声明： 本作品采用 CC BY-NC-SA 4.0 许可协议进行许可。转载请注明出处！
知识共享许可协议
赏

谢谢你请我吃糖果

支付宝
微信
本站总访问量次 | 本站访客数人

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

喜欢看书、打代码、吃吃吃！我从没被谁知道，所以也没被谁忘记。在别人的回忆中生活，并不是我的目的。我只不过是自己一个人在努力罢了。