Nacos入门教程 - 从零开始学习服务注册发现与配置管理

目录

1. Nacos简介
2. 环境搭建
3. 服务注册与发现
4. 配置管理
5. Nacos控制台使用
6. Spring Cloud集成
7. Spring Boot集成
8. 命名空间和分组
9. 集群部署
10. 最佳实践与常见问题
11. 总结与进阶

---

点击这里👇🏻获取：100万QPS短链系统、复杂的商城微服务系统、智能翻译助手AI Agent、SaaS点餐系统、刷题吧小程序、商城系统、秒杀系统、AI项目、代码生成神器、苏三demo项目等 8 个项目的：项目源代码、开发教程和技术答疑

1. Nacos简介

Nacos（Naming and Configuration Service）是阿里巴巴开源的一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。

Nacos的核心功能：

• ✅ 服务注册与发现：提供服务注册、服务发现、服务健康检查等功能
• ✅ 配置管理：提供配置管理、配置推送、配置监听等功能
• ✅ 动态DNS服务：支持基于DNS的服务发现
• ✅ 服务管理：提供服务管理、流量管理、服务路由等功能

核心特点：

• 🚀 易于使用：提供简单易用的Web控制台
• 🔒 高可用：支持集群部署，保证高可用性
• 📦 轻量级：安装部署简单，资源占用少
• 🌐 多语言支持：支持Java、Go、Python等多种语言
• 🔄 动态配置：支持配置的动态更新和推送
• 📊 服务治理：提供服务管理、流量管理等功能

特性	Nacos	Eureka	Consul	Zookeeper
服务注册发现	✅	✅	✅	✅
配置管理	✅	❌	✅	❌
健康检查	✅	✅	✅	✅
多数据中心	✅	❌	✅	✅
一致性协议	AP/CP	AP	CP	CP
管理界面	✅	✅	✅	❌

┌─────────────────────────────────────────┐
│           Nacos Server (集群)            │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐│
│  │  Node 1  │  │  Node 2  │  │  Node 3  ││
│  └──────────┘  └──────────┘  └──────────┘│
└─────────────────────────────────────────┘
           ▲                    ▲
           │                    │
    ┌──────┴──────┐    ┌────────┴────────┐
    │             │    │                 │
┌───┴───┐    ┌───┴───┐│          ┌──────┴──────┐
│服务A  │    │服务B  ││          │   服务C     │
└───────┘    └───────┘│          └─────────────┘

• 微服务架构：作为服务注册中心和配置中心
• 云原生应用：支持Kubernetes、Docker等
• 分布式系统：服务发现和配置管理
• Spring Cloud项目：与Spring Cloud完美集成

---

2. 环境搭建

• JDK：JDK 1.8或更高版本
• Maven：3.2+（可选，用于编译源码）
• 操作系统：Linux、Unix、Mac、Windows

方式一：官方下载

访问Nacos官方GitHub：https://github.com/alibaba/nacos/releases

下载最新版本的压缩包：

• nacos-server-2.3.0.tar.gz（Linux/Unix/Mac）
• nacos-server-2.3.0.zip（Windows）

方式二：使用wget下载

# Linux/Mac
wget https://github.com/alibaba/nacos/releases/download/2.3.0/nacos-server-2.3.0.tar.gz

# 解压
tar -xzf nacos-server-2.3.0.tar.gz
cd nacos

Linux/Unix/Mac

# 进入nacos目录
cd nacos/bin

# 启动（standalone表示单机模式）
sh startup.sh -m standalone

# 或者
./startup.sh -m standalone

Windows

# 进入nacos目录
cd nacos\bin

# 启动（standalone表示单机模式）
startup.cmd -m standalone

启动成功标志

看到类似以下输出表示启动成功：

nacos is starting with standalone
nacos is starting，you can check the /Users/xxx/nacos/logs/start.out

点击这里👇🏻获取：100万QPS短链系统、复杂的商城微服务系统、智能翻译助手AI Agent、SaaS点餐系统、刷题吧小程序、商城系统、秒杀系统、AI项目、代码生成神器、苏三demo项目等 8 个项目的：项目源代码、开发教程和技术答疑

2.4 访问Nacos控制台

启动成功后，访问：http://localhost:8848/nacos

默认账号密码：

• 用户名：nacos
• 密码：nacos

Linux/Unix/Mac

cd nacos/bin
sh shutdown.sh

Windows

cd nacos\bin
shutdown.cmd

修改端口

编辑 nacos/conf/application.properties：

# 修改端口（默认8848）
server.port=8848

修改数据库（使用MySQL）

1. 创建数据库

CREATE DATABASE IF NOT EXISTS nacos_config DEFAULT CHARACTER SET utf8mb4;

2. 导入初始化脚本

执行 nacos/conf/mysql-schema.sql 脚本：

mysql -u root -p nacos_config < nacos/conf/mysql-schema.sql

3. 修改配置文件

编辑 nacos/conf/application.properties：

# 使用MySQL数据库
spring.datasource.platform=mysql

# 数据库连接数
db.num=1

# 数据库配置
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

# 停止
sh shutdown.sh

# 启动
sh startup.sh -m standalone

---

3. 服务注册与发现

步骤1：创建Spring Boot项目

使用Spring Initializr创建项目，或手动创建Maven项目。

步骤2：添加依赖

在 pom.xml 中添加Nacos依赖：

<?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>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.14</version>
        <relativePath/>
    </parent>

    <groupId>com.example</groupId>
    <artifactId>nacos-provider</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>2021.0.8</spring-cloud.version>
        <spring-cloud-alibaba.version>2021.0.5.0</spring-cloud-alibaba.version>
    </properties>

    <dependencies>
        <!-- Spring Boot Web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

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

        <!-- Spring Boot Test -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <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>
        </dependencies>
    </dependencyManagement>
</project>

步骤3：配置文件

创建 application.yml：

server:
  port: 8081

spring:
  application:
    name: nacos-provider
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
        namespace: public
        group: DEFAULT_GROUP
        # 服务实例权重（0-1）
        weight: 1.0
        # 是否启用
        enabled: true

步骤4：启用服务发现

在主类上添加 @EnableDiscoveryClient 注解：

package com.example.provider;

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

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

步骤5：创建Controller

package com.example.provider.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProviderController {
    
    @Value("${server.port}")
    private String port;
    
    @GetMapping("/hello/{name}")
    public String hello(@PathVariable String name) {
        return "Hello " + name + ", I'm from port " + port;
    }
    
    @GetMapping("/info")
    public String info() {
        return "Provider Service Info - Port: " + port;
    }
}

步骤6：启动服务

运行主类，服务会自动注册到Nacos。

步骤1：添加依赖

与提供者相同的依赖配置。

步骤2：配置文件

创建 application.yml：

server:
  port: 8082

spring:
  application:
    name: nacos-consumer
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
        namespace: public
        group: DEFAULT_GROUP

步骤3：启用服务发现

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

步骤4：使用RestTemplate调用服务

package com.example.consumer.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
public class ConsumerController {
    
    @Autowired
    private RestTemplate restTemplate;
    
    @Autowired
    private DiscoveryClient discoveryClient;
    
    @GetMapping("/hello/{name}")
    public String hello(@PathVariable String name) {
        // 方式1：使用服务名调用（需要配置LoadBalancer）
        String url = "http://nacos-provider/hello/" + name;
        return restTemplate.getForObject(url, String.class);
    }
    
    @GetMapping("/services")
    public List<ServiceInstance> getServices() {
        // 获取所有服务实例
        return discoveryClient.getInstances("nacos-provider");
    }
}

步骤5：配置RestTemplate和LoadBalancer

package com.example.consumer.config;

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

@Configuration
public class RestTemplateConfig {
    
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

步骤6：添加LoadBalancer依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>

步骤1：添加依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

步骤2：启用Feign

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

步骤3：创建Feign客户端

package com.example.consumer.feign;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient(name = "nacos-provider")
public interface ProviderFeignClient {
    
    @GetMapping("/hello/{name}")
    String hello(@PathVariable String name);
    
    @GetMapping("/info")
    String info();
}

步骤4：使用Feign客户端

package com.example.consumer.controller;

import com.example.consumer.feign.ProviderFeignClient;
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.RestController;

@RestController
public class ConsumerController {
    
    @Autowired
    private ProviderFeignClient providerFeignClient;
    
    @GetMapping("/hello/{name}")
    public String hello(@PathVariable String name) {
        return providerFeignClient.hello(name);
    }
}

1. 启动Nacos服务器
2. 启动服务提供者
3. 启动服务消费者
4. 访问Nacos控制台：http://localhost:8848/nacos
5. 在"服务管理" -> "服务列表"中可以看到注册的服务

---

4. 配置管理

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

创建 bootstrap.yml（优先级高于application.yml）：

spring:
  application:
    name: nacos-config-demo
  cloud:
    nacos:
      config:
        server-addr: localhost:8848
        namespace: public
        group: DEFAULT_GROUP
        file-extension: yaml
        # 共享配置
        shared-configs:
          - data-id: shared-config.yaml
            group: SHARED_GROUP
            refresh: true
        # 扩展配置
        extension-configs:
          - data-id: ext-config.yaml
            group: EXT_GROUP
            refresh: true

1. 登录Nacos控制台
2. 进入"配置管理" -> "配置列表"
3. 点击"+"按钮创建配置
4. 填写配置信息：
   • Data ID：nacos-config-demo.yaml（格式：${spring.application.name}.${file-extension}）
   • Group：DEFAULT_GROUP
   • 配置格式：YAML
   • 配置内容：

     server:
       port: 8080
     
     app:
       name: nacos-config-demo
       version: 1.0.0
       description: Nacos配置管理示例

5. 点击"发布"

方式1：使用@Value注解

package com.example.config.controller;

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.RestController;

@RestController
@RefreshScope  // 支持动态刷新
public class ConfigController {
    
    @Value("${app.name}")
    private String appName;
    
    @Value("${app.version}")
    private String appVersion;
    
    @Value("${app.description}")
    private String appDescription;
    
    @GetMapping("/config")
    public String getConfig() {
        return String.format("App Name: %s, Version: %s, Description: %s", 
            appName, appVersion, appDescription);
    }
}

方式2：使用@ConfigurationProperties

package com.example.config.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.stereotype.Component;

@Component
@RefreshScope
@ConfigurationProperties(prefix = "app")
public class AppConfig {
    private String name;
    private String version;
    private String description;
    
    // getter/setter
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public String getVersion() {
        return version;
    }
    
    public void setVersion(String version) {
        this.version = version;
    }
    
    public String getDescription() {
        return description;
    }
    
    public void setDescription(String description) {
        this.description = description;
    }
}

使用：

@RestController
public class ConfigController {
    
    @Autowired
    private AppConfig appConfig;
    
    @GetMapping("/config")
    public AppConfig getConfig() {
        return appConfig;
    }
}

方式1：使用@RefreshScope

在需要刷新的Bean上添加 @RefreshScope 注解：

@Component
@RefreshScope
public class ConfigBean {
    @Value("${app.name}")
    private String appName;
}

方式2：使用@NacosConfigListener

package com.example.config.listener;

import com.alibaba.nacos.api.config.annotation.NacosConfigListener;
import org.springframework.stereotype.Component;

@Component
public class ConfigListener {
    
    @NacosConfigListener(dataId = "nacos-config-demo.yaml", groupId = "DEFAULT_GROUP")
    public void onConfigChange(String newConfig) {
        System.out.println("配置发生变化: " + newConfig);
        // 处理配置变更
    }
}

创建不同环境的配置

在Nacos控制台创建多个配置：

1. 开发环境：

   • Data ID: nacos-config-demo-dev.yaml
   • Group: DEFAULT_GROUP

2. 测试环境：

   • Data ID: nacos-config-demo-test.yaml
   • Group: DEFAULT_GROUP

3. 生产环境：

   • Data ID: nacos-config-demo-prod.yaml
   • Group: DEFAULT_GROUP

配置文件

spring:
  application:
    name: nacos-config-demo
  profiles:
    active: dev  # 指定环境
  cloud:
    nacos:
      config:
        server-addr: localhost:8848
        namespace: public
        group: DEFAULT_GROUP
        file-extension: yaml
        # 根据环境动态加载配置
        # Data ID格式: ${spring.application.name}-${spring.profiles.active}.${file-extension}

---

5. Nacos控制台使用

查看服务列表

1. 登录Nacos控制台
2. 进入"服务管理" -> "服务列表"
3. 可以看到所有注册的服务

服务详情

点击服务名称，可以查看：

• 服务实例列表
• 实例健康状态
• 实例元数据
• 服务权重

服务操作

• 下线服务：将服务实例从注册中心移除
• 上线服务：重新注册服务实例
• 编辑服务：修改服务元数据
• 删除服务：删除服务（谨慎操作）

创建配置

1. 进入"配置管理" -> "配置列表"
2. 点击"+"按钮
3. 填写配置信息
4. 点击"发布"

配置格式

支持以下格式：

• YAML：推荐使用
• JSON
• XML
• Properties
• Text

配置操作

• 编辑：修改配置内容
• 克隆：复制配置
• 删除：删除配置
• 历史版本：查看配置历史
• 监听查询：查看哪些应用在监听此配置

创建命名空间

1. 进入"命名空间"
2. 点击"新建命名空间"
3. 填写命名空间信息：
   • 命名空间ID：唯一标识
   • 命名空间名：显示名称
   • 描述：描述信息

使用命名空间

在配置文件中指定命名空间：

spring:
  cloud:
    nacos:
      discovery:
        namespace: your-namespace-id
      config:
        namespace: your-namespace-id

查看集群

1. 进入"集群管理"
2. 可以看到所有节点信息

节点信息

• 节点IP：节点地址
• 节点状态：健康状态
• 角色：Leader/Follower
• 操作：查看详情、下线节点等

---

6. Spring Cloud集成

<properties>
    <spring-cloud.version>2021.0.8</spring-cloud.version>
    <spring-cloud-alibaba.version>2021.0.5.0</spring-cloud-alibaba.version>
</properties>

<dependencies>
    <!-- Nacos Discovery -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    
    <!-- Nacos Config -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    </dependency>
    
    <!-- OpenFeign -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>
    
    <!-- LoadBalancer -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-loadbalancer</artifactId>
    </dependency>
</dependencies>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <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>
    </dependencies>
</dependencyManagement>

bootstrap.yml

spring:
  application:
    name: spring-cloud-nacos-demo
  profiles:
    active: dev
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
        namespace: public
        group: DEFAULT_GROUP
        enabled: true
      config:
        server-addr: localhost:8848
        namespace: public
        group: DEFAULT_GROUP
        file-extension: yaml
        refresh-enabled: true
        # 共享配置
        shared-configs:
          - data-id: common-config.yaml
            group: SHARED_GROUP
            refresh: true

添加Gateway依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>

配置路由

spring:
  cloud:
    gateway:
      routes:
        - id: provider-route
          uri: lb://nacos-provider
          predicates:
            - Path=/api/provider/**
          filters:
            - StripPrefix=2

---

7. Spring Boot集成

如果项目不使用Spring Cloud，可以直接使用Nacos SDK。

添加依赖

<dependency>
    <groupId>com.alibaba.nacos</groupId>
    <artifactId>nacos-client</artifactId>
    <version>2.3.0</version>
</dependency>

服务注册

package com.example.nacos;

import com.alibaba.nacos.api.NacosFactory;
import com.alibaba.nacos.api.exception.NacosException;
import com.alibaba.nacos.api.naming.NamingService;
import com.alibaba.nacos.api.naming.pojo.Instance;

public class NacosServiceRegistry {
    
    public static void main(String[] args) throws NacosException {
        // 创建NamingService
        NamingService namingService = NacosFactory.createNamingService("localhost:8848");
        
        // 注册服务实例
        Instance instance = new Instance();
        instance.setIp("127.0.0.1");
        instance.setPort(8080);
        instance.setWeight(1.0);
        instance.setHealthy(true);
        
        namingService.registerInstance("my-service", "DEFAULT_GROUP", instance);
        
        System.out.println("服务注册成功");
    }
}

服务发现

package com.example.nacos;

import com.alibaba.nacos.api.NacosFactory;
import com.alibaba.nacos.api.exception.NacosException;
import com.alibaba.nacos.api.naming.NamingService;
import com.alibaba.nacos.api.naming.pojo.Instance;

import java.util.List;

public class NacosServiceDiscovery {
    
    public static void main(String[] args) throws NacosException {
        // 创建NamingService
        NamingService namingService = NacosFactory.createNamingService("localhost:8848");
        
        // 获取服务实例列表
        List<Instance> instances = namingService.getAllInstances("my-service", "DEFAULT_GROUP");
        
        for (Instance instance : instances) {
            System.out.println("服务实例: " + instance.getIp() + ":" + instance.getPort());
        }
    }
}

配置管理

package com.example.nacos;

import com.alibaba.nacos.api.NacosFactory;
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.config.listener.Listener;
import com.alibaba.nacos.api.exception.NacosException;

public class NacosConfigManager {
    
    public static void main(String[] args) throws NacosException {
        // 创建ConfigService
        ConfigService configService = NacosFactory.createConfigService("localhost:8848");
        
        // 获取配置
        String config = configService.getConfig("my-config", "DEFAULT_GROUP", 5000);
        System.out.println("配置内容: " + config);
        
        // 监听配置变化
        configService.addListener("my-config", "DEFAULT_GROUP", new Listener() {
            @Override
            public void receiveConfigInfo(String configInfo) {
                System.out.println("配置发生变化: " + configInfo);
            }
            
            @Override
            public Executor getExecutor() {
                return null;
            }
        });
        
        // 发布配置
        boolean published = configService.publishConfig("my-config", "DEFAULT_GROUP", "config content");
        System.out.println("配置发布: " + published);
    }
}

---

8. 命名空间和分组

命名空间用于实现配置和服务的数据隔离。

使用场景

• 环境隔离：开发、测试、生产环境
• 租户隔离：多租户系统
• 项目隔离：不同项目使用不同命名空间

配置方式

spring:
  cloud:
    nacos:
      discovery:
        namespace: dev-namespace-id  # 命名空间ID
      config:
        namespace: dev-namespace-id

分组用于在同一个命名空间内对配置和服务进行分组。

使用场景

• 应用分组：不同应用使用不同分组
• 配置分组：相关配置放在同一分组

配置方式

spring:
  cloud:
    nacos:
      discovery:
        group: MY_GROUP
      config:
        group: MY_GROUP

# 开发环境
spring:
  profiles:
    active: dev
  cloud:
    nacos:
      discovery:
        namespace: dev-namespace
        group: DEFAULT_GROUP
      config:
        namespace: dev-namespace
        group: DEFAULT_GROUP

# 生产环境
spring:
  profiles:
    active: prod
  cloud:
    nacos:
      discovery:
        namespace: prod-namespace
        group: DEFAULT_GROUP
      config:
        namespace: prod-namespace
        group: DEFAULT_GROUP

---

9. 集群部署

                    ┌─────────────┐
                    │   Nginx     │
                    │  (负载均衡)  │
                    └──────┬──────┘
                           │
        ┌──────────────────┼──────────────────┐
        │                  │                  │
   ┌────┴────┐       ┌─────┴─────┐      ┌─────┴─────┐
   │ Node 1  │       │  Node 2   │      │  Node 3   │
   │ 8848    │       │  8848     │      │  8848     │
   └─────────┘       └───────────┘      └───────────┘
        │                  │                  │
        └──────────────────┼──────────────────┘
                           │
                    ┌──────┴──────┐
                    │   MySQL     │
                    │  (数据库)    │
                    └─────────────┘

步骤1：准备MySQL数据库

CREATE DATABASE IF NOT EXISTS nacos_config DEFAULT CHARACTER SET utf8mb4;

导入初始化脚本：

mysql -u root -p nacos_config < nacos/conf/mysql-schema.sql

步骤2：修改配置文件

编辑 nacos/conf/application.properties：

# 数据库配置
spring.datasource.platform=mysql
db.num=1
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

步骤3：配置集群节点

编辑 nacos/conf/cluster.conf：

# 集群节点配置
192.168.1.10:8848
192.168.1.11:8848
192.168.1.12:8848

步骤4：启动集群

在每个节点上执行：

cd nacos/bin
sh startup.sh

步骤5：配置Nginx负载均衡

编辑 nginx.conf：

upstream nacos-cluster {
    server 192.168.1.10:8848;
    server 192.168.1.11:8848;
    server 192.168.1.12:8848;
}

server {
    listen 8848;
    server_name localhost;
    
    location / {
        proxy_pass http://nacos-cluster;
    }
}

spring:
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.1.10:8848,192.168.1.11:8848,192.168.1.12:8848
      config:
        server-addr: 192.168.1.10:8848,192.168.1.11:8848,192.168.1.12:8848

---

10. 最佳实践与常见问题

• ✅ 使用YAML格式，更易读

• ✅ 合理使用命名空间和分组

• ✅ 配置要有版本管理

• ✅ 敏感信息加密存储

• ✅ 服务名使用小写和连字符

• ✅ 合理设置服务权重

• ✅ 实现健康检查

• ✅ 服务下线要优雅

• ✅ 使用集群部署

• ✅ 合理设置缓存

• ✅ 避免频繁配置变更

• ✅ 使用连接池

Q1: 服务注册失败

可能原因：

• Nacos服务器未启动
• 网络连接问题
• 配置错误

解决方法：

1. 检查Nacos服务器状态
2. 检查网络连接
3. 检查配置文件

Q2: 配置不生效

可能原因：

• 未添加@RefreshScope注解
• Data ID配置错误
• 命名空间或分组不匹配

解决方法：

1. 添加@RefreshScope注解
2. 检查Data ID格式：${spring.application.name}.${file-extension}
3. 检查命名空间和分组配置

Q3: 服务发现失败

可能原因：

• 服务未注册
• 服务已下线
• 负载均衡配置错误

解决方法：

1. 检查服务是否注册成功
2. 检查服务健康状态
3. 检查LoadBalancer配置

Q4: 集群节点无法通信

可能原因：

• 防火墙阻止
• 网络不通
• cluster.conf配置错误

解决方法：

1. 检查防火墙设置
2. 检查网络连通性
3. 检查cluster.conf配置

健康检查

@Component
public class NacosHealthIndicator implements HealthIndicator {
    
    @Autowired
    private NamingService namingService;
    
    @Override
    public Health health() {
        try {
            // 检查Nacos连接
            namingService.getServerStatus();
            return Health.up().build();
        } catch (Exception e) {
            return Health.down().withDetail("error", e.getMessage()).build();
        }
    }
}

日志配置

logging:
  level:
    com.alibaba.nacos: INFO
    com.alibaba.cloud.nacos: DEBUG

---

11. 总结与进阶

通过本教程，你已经掌握了：

• ✅ Nacos的基本概念和架构
• ✅ 环境搭建和配置
• ✅ 服务注册与发现
• ✅ 配置管理
• ✅ Spring Cloud集成
• ✅ 集群部署

1. 源码学习

   • Nacos服务注册发现原理
   • 配置管理实现机制
   • 一致性协议（Raft）

2. 高级特性

   • 服务治理
   • 流量管理
   • 服务路由
   • 服务降级

3. 性能优化

   • 集群优化
   • 缓存策略
   • 连接池优化

4. 安全加固

   • 认证授权
   • 数据加密
   • 访问控制

• 官方文档：https://nacos.io/zh-cn/docs/what-is-nacos.html
• GitHub：https://github.com/alibaba/nacos
• Spring Cloud Alibaba：https://github.com/alibaba/spring-cloud-alibaba

1. 搭建完整的微服务项目
2. 实现多环境配置管理
3. 部署Nacos集群
4. 实现服务治理功能

---

结语

Nacos作为服务注册中心和配置中心，在微服务架构中发挥着重要作用。通过本教程的学习，相信你已经掌握了Nacos的核心功能和使用方法。

记住：

• 多实践：理论结合实践，多动手操作
• 理解原理：理解服务注册发现和配置管理的原理
• 关注最佳实践：遵循最佳实践，避免常见问题
• 持续学习：关注Nacos新特性和更新

祝你学习愉快，编程顺利！ 🚀

---

本教程由Java突击队学习社区编写，如有问题欢迎反馈。