Nacos 服务发现与配置管理完整指南

概述

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

核心特性

服务发现和服务健康监测：支持基于 DNS 和基于 RPC 的服务发现
动态配置服务：动态配置管理、配置推送、配置历史版本管理
动态 DNS 服务：动态 DNS 服务使得服务可以更容易地实现权重路由
服务及其元数据管理：管理数据中心的所有服务及元数据

应用场景

场景	描述	示例
微服务注册中心	服务自动注册与发现	SpringCloud 服务注册
配置中心	集中化配置管理	数据库连接、API 密钥
服务治理	流量管理、负载均衡	灰度发布、A/B 测试
多环境管理	开发、测试、生产环境隔离	环境配置隔离

💡 提示: Nacos 集服务发现、配置管理、服务治理于一体，是微服务架构的核心组件。

环境准备

系统要求

JDK 1.8+
Maven 3.2+
Docker 20.10+
内存：至少 2GB RAM
存储：至少 5GB 可用空间

架构组件

┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│   Service   │    │    Nacos    │    │   Config    │
│  Provider   │───▶│   Server    │◀───│   Client    │
└─────────────┘    └─────────────┘    └─────────────┘
                          │
                          ▼
                   ┌─────────────┐
                   │  Database   │
                   │ (MySQL/H2)  │
                   └─────────────┘

Docker 安装部署

1. 单机部署

独立模式（测试环境）

# 拉取 Nacos 镜像
docker pull nacos/nacos-server:v2.3.0

# 启动 Nacos 服务器（独立模式）
docker run -d \
  --name nacos-server \
  --restart=always \
  -p 8848:8848 \
  -p 9848:9848 \
  -p 9849:9849 \
  -e MODE=standalone \
  -e JVM_XMS=512m \
  -e JVM_XMX=512m \
  -e JVM_XMN=256m \
  -e PREFER_HOST_MODE=hostname \
  -v nacos_logs:/home/nacos/logs \
  -v nacos_data:/home/nacos/data \
  --log-driver json-file \
  --log-opt max-size=100m \
  --log-opt max-file=2 \
  nacos/nacos-server:v2.3.0

使用外部 MySQL 数据库

# 启动 MySQL 容器
docker run -d \
  --name nacos-mysql \
  --restart=always \
  -p 3306:3306 \
  -e MYSQL_ROOT_PASSWORD=nacos123 \
  -e MYSQL_DATABASE=nacos \
  -e MYSQL_USER=nacos \
  -e MYSQL_PASSWORD=nacos123 \
  -v mysql_data:/var/lib/mysql \
  mysql:8.0

# 启动 Nacos 服务器（连接 MySQL）
docker run -d \
  --name nacos-server \
  --restart=always \
  -p 8848:8848 \
  -p 9848:9848 \
  -p 9849:9849 \
  -e MODE=standalone \
  -e SPRING_DATASOURCE_PLATFORM=mysql \
  -e MYSQL_SERVICE_HOST=nacos-mysql \
  -e MYSQL_SERVICE_PORT=3306 \
  -e MYSQL_SERVICE_DB_NAME=nacos \
  -e MYSQL_SERVICE_USER=nacos \
  -e MYSQL_SERVICE_PASSWORD=nacos123 \
  -e MYSQL_SERVICE_DB_PARAM="characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=Asia/Shanghai" \
  -e JVM_XMS=512m \
  -e JVM_XMX=512m \
  -v nacos_logs:/home/nacos/logs \
  --link nacos-mysql:mysql \
  nacos/nacos-server:v2.3.0

2. 使用 Docker Compose 部署

创建 docker-compose.yml 文件：

version: '3.8'

services:
  mysql:
    image: mysql:8.0
    container_name: nacos-mysql
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: nacos123
      MYSQL_DATABASE: nacos
      MYSQL_USER: nacos
      MYSQL_PASSWORD: nacos123
    ports:
      - "3306:3306"
    volumes:
      - mysql_data:/var/lib/mysql
      - ./nacos-mysql.sql:/docker-entrypoint-initdb.d/nacos-mysql.sql
    command:
      - --character-set-server=utf8mb4
      - --collation-server=utf8mb4_unicode_ci
      - --default-time-zone=+8:00
    networks:
      - nacos-network

  nacos:
    image: nacos/nacos-server:v2.3.0
    container_name: nacos-server
    restart: unless-stopped
    depends_on:
      - mysql
    environment:
      # 集群模式 (cluster) 或 单机模式 (standalone)
      MODE: standalone
      
      # 数据库配置
      SPRING_DATASOURCE_PLATFORM: mysql
      MYSQL_SERVICE_HOST: mysql
      MYSQL_SERVICE_PORT: 3306
      MYSQL_SERVICE_DB_NAME: nacos
      MYSQL_SERVICE_USER: nacos
      MYSQL_SERVICE_PASSWORD: nacos123
      MYSQL_SERVICE_DB_PARAM: "characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=Asia/Shanghai"
      
      # JVM 配置
      JVM_XMS: 512m
      JVM_XMX: 1g
      JVM_XMN: 256m
      
      # 网络配置
      PREFER_HOST_MODE: hostname
      
      # 启用鉴权
      NACOS_AUTH_ENABLE: true
      NACOS_AUTH_TOKEN: SecretKey012345678901234567890123456789012345678901234567890123456789
      NACOS_AUTH_IDENTITY_KEY: nacos
      NACOS_AUTH_IDENTITY_VALUE: nacos
      
      # 管理用户
      NACOS_AUTH_CACHE_ENABLE: false
      
    ports:
      - "8848:8848"
      - "9848:9848"
      - "9849:9849"
    volumes:
      - nacos_logs:/home/nacos/logs
      - nacos_data:/home/nacos/data
    logging:
      driver: json-file
      options:
        max-size: "100m"
        max-file: "2"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8848/nacos/v1/console/health/readiness"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s
    networks:
      - nacos-network

volumes:
  mysql_data:
  nacos_logs:
  nacos_data:

networks:
  nacos-network:
    driver: bridge

启动服务：

# 下载 Nacos MySQL 初始化脚本
wget https://raw.githubusercontent.com/alibaba/nacos/develop/distribution/conf/nacos-mysql.sql

# 启动服务
docker-compose up -d

# 查看日志
docker-compose logs -f nacos

# 停止服务
docker-compose down

3. 访问控制台

URL: http://localhost:8848/nacos
默认用户名: nacos
默认密码: nacos

基本概念

核心概念

概念	描述	示例
Service	服务	user-service, order-service
Instance	服务实例	192.168.1.100:8080
Cluster	集群	Beijing, Shanghai
Namespace	命名空间	dev, test, prod
Group	分组	DEFAULT_GROUP, APP_GROUP
DataId	配置ID	application.properties

层次结构

Namespace (命名空间)
├── Group (分组)
│   ├── Service (服务)
│   │   ├── Cluster (集群)
│   │   │   └── Instance (实例)
│   │   └── Config (配置)
│   └── ...
└── ...

服务发现

1. 服务注册

使用 REST API 注册服务

# 注册服务实例
curl -X POST 'http://localhost:8848/nacos/v1/ns/instance' \
  -d 'serviceName=user-service&ip=192.168.1.100&port=8080&weight=1.0&healthy=true&enabled=true&metadata={"version":"1.0","region":"beijing"}'

# 注册带集群的服务实例
curl -X POST 'http://localhost:8848/nacos/v1/ns/instance' \
  -d 'serviceName=user-service&ip=192.168.1.101&port=8080&clusterName=beijing&weight=2.0&healthy=true&enabled=true'

使用 Java SDK 注册服务

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

import java.util.Properties;

public class ServiceRegister {
    public static void main(String[] args) throws Exception {
        // 配置 Nacos 服务器地址
        Properties properties = new Properties();
        properties.setProperty("serverAddr", "localhost:8848");
        properties.setProperty("namespace", "public");
        
        // 创建命名服务
        NamingService namingService = NacosFactory.createNamingService(properties);
        
        // 创建服务实例
        Instance instance = new Instance();
        instance.setIp("192.168.1.100");
        instance.setPort(8080);
        instance.setWeight(1.0);
        instance.setClusterName("beijing");
        instance.setEnabled(true);
        instance.setHealthy(true);
        
        // 添加元数据
        instance.getMetadata().put("version", "1.0");
        instance.getMetadata().put("region", "beijing");
        
        // 注册服务实例
        namingService.registerInstance("user-service", instance);
        
        System.out.println("Service registered successfully");
        
        // 保持服务运行
        Thread.sleep(Long.MAX_VALUE);
    }
}

2. 服务发现

使用 REST API 发现服务

# 查询服务实例列表
curl 'http://localhost:8848/nacos/v1/ns/instance/list?serviceName=user-service'

# 查询健康的服务实例
curl 'http://localhost:8848/nacos/v1/ns/instance/list?serviceName=user-service&healthyOnly=true'

# 查询指定集群的服务实例
curl 'http://localhost:8848/nacos/v1/ns/instance/list?serviceName=user-service&clusters=beijing'

使用 Java SDK 发现服务

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

import java.util.List;
import java.util.Properties;

public class ServiceDiscovery {
    public static void main(String[] args) throws Exception {
        Properties properties = new Properties();
        properties.setProperty("serverAddr", "localhost:8848");
        
        NamingService namingService = NacosFactory.createNamingService(properties);
        
        // 获取服务实例列表
        List<Instance> instances = namingService.getAllInstances("user-service");
        
        for (Instance instance : instances) {
            System.out.println("Instance: " + instance.getIp() + ":" + instance.getPort() + 
                             " Weight: " + instance.getWeight() + 
                             " Cluster: " + instance.getClusterName());
        }
        
        // 获取健康的服务实例
        List<Instance> healthyInstances = namingService.getAllInstances("user-service", true);
        System.out.println("Healthy instances count: " + healthyInstances.size());
        
        // 选择一个实例（负载均衡）
        Instance selectedInstance = namingService.selectOneHealthyInstance("user-service");
        System.out.println("Selected instance: " + selectedInstance.getIp() + ":" + selectedInstance.getPort());
    }
}

3. 服务健康检查

配置健康检查

// 设置健康检查
Instance instance = new Instance();
instance.setIp("192.168.1.100");
instance.setPort(8080);

// TCP 健康检查
instance.getMetadata().put("preserved.heart.beat.timeout", "15000");
instance.getMetadata().put("preserved.ip.delete.timeout", "30000");

// HTTP 健康检查
instance.getMetadata().put("preserved.heart.beat.interval", "5000");
instance.getMetadata().put("preserved.heart.beat.timeout", "15000");
instance.getMetadata().put("preserved.ip.delete.timeout", "30000");

namingService.registerInstance("user-service", instance);

配置管理

1. 发布配置

使用 REST API

# 发布配置
curl -X POST 'http://localhost:8848/nacos/v1/cs/configs' \
  -d 'dataId=application.properties&group=DEFAULT_GROUP&content=server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=123456'

# 发布 YAML 配置
curl -X POST 'http://localhost:8848/nacos/v1/cs/configs' \
  -d 'dataId=application.yml&group=DEFAULT_GROUP&type=yaml&content=server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test
    username: root
    password: 123456'

使用 Java SDK

import com.alibaba.nacos.api.NacosFactory;
import com.alibaba.nacos.api.config.ConfigService;

import java.util.Properties;

public class ConfigPublisher {
    public static void main(String[] args) throws Exception {
        Properties properties = new Properties();
        properties.setProperty("serverAddr", "localhost:8848");
        
        ConfigService configService = NacosFactory.createConfigService(properties);
        
        String dataId = "application.properties";
        String group = "DEFAULT_GROUP";
        String content = """
            server.port=8080
            spring.application.name=user-service
            spring.datasource.url=jdbc:mysql://localhost:3306/test
            spring.datasource.username=root
            spring.datasource.password=123456
            """;
        
        // 发布配置
        boolean result = configService.publishConfig(dataId, group, content);
        System.out.println("Publish config result: " + result);
        
        // 发布 YAML 配置
        String yamlContent = """
            server:
              port: 8080
            spring:
              application:
                name: user-service
              datasource:
                url: jdbc:mysql://localhost:3306/test
                username: root
                password: 123456
            """;
        
        boolean yamlResult = configService.publishConfig("application.yml", group, yamlContent, "yaml");
        System.out.println("Publish YAML config result: " + yamlResult);
    }
}

2. 获取配置

使用 REST API

# 获取配置
curl 'http://localhost:8848/nacos/v1/cs/configs?dataId=application.properties&group=DEFAULT_GROUP'

# 获取配置历史版本
curl 'http://localhost:8848/nacos/v1/cs/history?dataId=application.properties&group=DEFAULT_GROUP'

使用 Java SDK

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

import java.util.Properties;
import java.util.concurrent.Executor;

public class ConfigConsumer {
    public static void main(String[] args) throws Exception {
        Properties properties = new Properties();
        properties.setProperty("serverAddr", "localhost:8848");
        
        ConfigService configService = NacosFactory.createConfigService(properties);
        
        String dataId = "application.properties";
        String group = "DEFAULT_GROUP";
        
        // 获取配置
        String content = configService.getConfig(dataId, group, 5000);
        System.out.println("Config content: " + content);
        
        // 添加配置监听器
        configService.addListener(dataId, group, new Listener() {
            @Override
            public Executor getExecutor() {
                return null;
            }
            
            @Override
            public void receiveConfigInfo(String configInfo) {
                System.out.println("Config changed: " + configInfo);
            }
        });
        
        // 保持监听
        Thread.sleep(Long.MAX_VALUE);
    }
}

3. 配置监听

实时配置更新

import com.alibaba.nacos.api.config.listener.AbstractConfigChangeListener;
import com.alibaba.nacos.api.config.listener.ConfigChangeEvent;

public class ConfigChangeListener extends AbstractConfigChangeListener {
    @Override
    public void receiveConfigChange(ConfigChangeEvent event) {
        for (ConfigChangeItem item : event.getChangeItems()) {
            System.out.println("Config change: " + item.getKey() + 
                             " from " + item.getOldValue() + 
                             " to " + item.getNewValue());
        }
    }
}

// 使用监听器
configService.addListener(dataId, group, new ConfigChangeListener());

命名空间管理

1. 创建命名空间

# 创建命名空间
curl -X POST 'http://localhost:8848/nacos/v1/console/namespaces' \
  -d 'customNamespaceId=dev&namespaceName=开发环境&namespaceDesc=开发环境配置'

curl -X POST 'http://localhost:8848/nacos/v1/console/namespaces' \
  -d 'customNamespaceId=test&namespaceName=测试环境&namespaceDesc=测试环境配置'

curl -X POST 'http://localhost:8848/nacos/v1/console/namespaces' \
  -d 'customNamespaceId=prod&namespaceName=生产环境&namespaceDesc=生产环境配置'

2. 使用命名空间

// 在不同命名空间中操作
Properties devProperties = new Properties();
devProperties.setProperty("serverAddr", "localhost:8848");
devProperties.setProperty("namespace", "dev");

Properties prodProperties = new Properties();
prodProperties.setProperty("serverAddr", "localhost:8848");
prodProperties.setProperty("namespace", "prod");

ConfigService devConfigService = NacosFactory.createConfigService(devProperties);
ConfigService prodConfigService = NacosFactory.createConfigService(prodProperties);

// 在开发环境发布配置
devConfigService.publishConfig("app.properties", "DEFAULT_GROUP", "env=dev");

// 在生产环境发布配置
prodConfigService.publishConfig("app.properties", "DEFAULT_GROUP", "env=prod");

集群部署

1. 集群配置

创建 docker-compose-cluster.yml：

version: '3.8'

services:
  mysql:
    image: mysql:8.0
    container_name: nacos-mysql
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: nacos123
      MYSQL_DATABASE: nacos
      MYSQL_USER: nacos
      MYSQL_PASSWORD: nacos123
    volumes:
      - mysql_data:/var/lib/mysql
      - ./nacos-mysql.sql:/docker-entrypoint-initdb.d/nacos-mysql.sql
    networks:
      - nacos-cluster

  nacos1:
    image: nacos/nacos-server:v2.3.0
    container_name: nacos1
    restart: unless-stopped
    depends_on:
      - mysql
    environment:
      MODE: cluster
      NACOS_SERVERS: nacos1:8848,nacos2:8848,nacos3:8848
      SPRING_DATASOURCE_PLATFORM: mysql
      MYSQL_SERVICE_HOST: mysql
      MYSQL_SERVICE_PORT: 3306
      MYSQL_SERVICE_DB_NAME: nacos
      MYSQL_SERVICE_USER: nacos
      MYSQL_SERVICE_PASSWORD: nacos123
      JVM_XMS: 256m
      JVM_XMX: 512m
    ports:
      - "8848:8848"
      - "9848:9848"
    volumes:
      - nacos1_logs:/home/nacos/logs
    networks:
      - nacos-cluster

  nacos2:
    image: nacos/nacos-server:v2.3.0
    container_name: nacos2
    restart: unless-stopped
    depends_on:
      - mysql
    environment:
      MODE: cluster
      NACOS_SERVERS: nacos1:8848,nacos2:8848,nacos3:8848
      SPRING_DATASOURCE_PLATFORM: mysql
      MYSQL_SERVICE_HOST: mysql
      MYSQL_SERVICE_PORT: 3306
      MYSQL_SERVICE_DB_NAME: nacos
      MYSQL_SERVICE_USER: nacos
      MYSQL_SERVICE_PASSWORD: nacos123
      JVM_XMS: 256m
      JVM_XMX: 512m
    ports:
      - "8849:8848"
      - "9849:9848"
    volumes:
      - nacos2_logs:/home/nacos/logs
    networks:
      - nacos-cluster

  nacos3:
    image: nacos/nacos-server:v2.3.0
    container_name: nacos3
    restart: unless-stopped
    depends_on:
      - mysql
    environment:
      MODE: cluster
      NACOS_SERVERS: nacos1:8848,nacos2:8848,nacos3:8848
      SPRING_DATASOURCE_PLATFORM: mysql
      MYSQL_SERVICE_HOST: mysql
      MYSQL_SERVICE_PORT: 3306
      MYSQL_SERVICE_DB_NAME: nacos
      MYSQL_SERVICE_USER: nacos
      MYSQL_SERVICE_PASSWORD: nacos123
      JVM_XMS: 256m
      JVM_XMX: 512m
    ports:
      - "8850:8848"
      - "9850:9848"
    volumes:
      - nacos3_logs:/home/nacos/logs
    networks:
      - nacos-cluster

  nginx:
    image: nginx:alpine
    container_name: nacos-nginx
    restart: unless-stopped
    depends_on:
      - nacos1
      - nacos2
      - nacos3
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    networks:
      - nacos-cluster

volumes:
  mysql_data:
  nacos1_logs:
  nacos2_logs:
  nacos3_logs:

networks:
  nacos-cluster:
    driver: bridge

2. Nginx 负载均衡配置

创建 nginx.conf：

events {
    worker_connections 1024;
}

http {
    upstream nacos-cluster {
        server nacos1:8848;
        server nacos2:8848;
        server nacos3:8848;
    }
    
    server {
        listen 80;
        
        location /nacos {
            proxy_pass http://nacos-cluster;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }
    }
}

SpringCloud 集成

1. 添加依赖

<dependencies>
    <!-- Spring Cloud Alibaba Nacos Discovery -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    
    <!-- Spring Cloud Alibaba Nacos Config -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    </dependency>
</dependencies>

2. 服务提供者配置

application.yml

server:
  port: 8080

spring:
  application:
    name: user-service
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
        namespace: dev
        group: DEFAULT_GROUP
        cluster-name: beijing
        metadata:
          version: 1.0
          region: beijing
      config:
        server-addr: localhost:8848
        namespace: dev
        group: DEFAULT_GROUP
        file-extension: yml
        refresh-enabled: true

management:
  endpoints:
    web:
      exposure:
        include: "*"

bootstrap.yml

spring:
  application:
    name: user-service
  cloud:
    nacos:
      config:
        server-addr: localhost:8848
        namespace: dev
        group: DEFAULT_GROUP
        file-extension: yml
        shared-configs:
          - data-id: common.yml
            group: DEFAULT_GROUP
            refresh: true
        extension-configs:
          - data-id: user-service-dev.yml
            group: DEFAULT_GROUP
            refresh: true

3. 服务消费者配置

@RestController
@RefreshScope
public class UserController {
    
    @Autowired
    private DiscoveryClient discoveryClient;
    
    @Autowired
    private LoadBalancerClient loadBalancerClient;
    
    @Value("${user.name:default}")
    private String userName;
    
    @GetMapping("/users")
    public String getUsers() {
        // 服务发现
        List<ServiceInstance> instances = discoveryClient.getInstances("user-service");
        if (!instances.isEmpty()) {
            ServiceInstance instance = instances.get(0);
            String url = "http://" + instance.getHost() + ":" + instance.getPort() + "/users";
            // 调用服务
        }
        
        return "Users from " + userName;
    }
    
    @GetMapping("/discovery")
    public List<ServiceInstance> discovery() {
        return discoveryClient.getInstances("user-service");
    }
}

4. 配置自动刷新

@Component
@RefreshScope
public class ConfigProperties {
    
    @Value("${database.url:default}")
    private String databaseUrl;
    
    @Value("${redis.host:localhost}")
    private String redisHost;
    
    // getter 和 setter
}

API 接口

1. 服务发现 API

# 注册服务实例
POST /nacos/v1/ns/instance
Parameters: serviceName, ip, port, weight, enabled, healthy, metadata, clusterName, namespaceId

# 注销服务实例
DELETE /nacos/v1/ns/instance
Parameters: serviceName, ip, port, clusterName, namespaceId

# 修改服务实例
PUT /nacos/v1/ns/instance
Parameters: serviceName, ip, port, weight, enabled, healthy, metadata, clusterName, namespaceId

# 查询服务实例列表
GET /nacos/v1/ns/instance/list
Parameters: serviceName, namespaceId, clusters, healthyOnly

# 查询服务实例详情
GET /nacos/v1/ns/instance
Parameters: serviceName, ip, port, namespaceId, clusterName

# 发送服务实例心跳
PUT /nacos/v1/ns/instance/beat
Parameters: serviceName, ip, port, namespaceId, clusterName

2. 配置管理 API

# 发布配置
POST /nacos/v1/cs/configs
Parameters: dataId, group, content, type

# 获取配置
GET /nacos/v1/cs/configs
Parameters: dataId, group

# 删除配置
DELETE /nacos/v1/cs/configs
Parameters: dataId, group

# 监听配置
POST /nacos/v1/cs/configs/listener
Parameters: Listening-Configs (特殊格式)

3. 命名空间 API

# 查询命名空间列表
GET /nacos/v1/console/namespaces

# 创建命名空间
POST /nacos/v1/console/namespaces
Parameters: customNamespaceId, namespaceName, namespaceDesc

# 修改命名空间
PUT /nacos/v1/console/namespaces
Parameters: namespace, namespaceShowName, namespaceDesc

# 删除命名空间
DELETE /nacos/v1/console/namespaces
Parameters: namespaceId

监控与运维

1. 健康检查

# 检查 Nacos 服务器状态
curl http://localhost:8848/nacos/actuator/health

# 检查服务注册情况
curl http://localhost:8848/nacos/v1/ns/operator/servers

# 查看集群节点状态
curl http://localhost:8848/nacos/v1/ns/operator/cluster/states

2. 监控指标

# 获取系统指标
curl http://localhost:8848/nacos/v1/ns/operator/metrics

# 查看服务数量
curl http://localhost:8848/nacos/v1/ns/catalog/services

# 查看配置数量
curl http://localhost:8848/nacos/v1/cs/configs?search=accurate&pageNo=1&pageSize=10

3. 日志管理

# 查看 Nacos 日志
docker logs -f nacos-server

# 进入容器查看详细日志
docker exec -it nacos-server /bin/bash
tail -f /home/nacos/logs/nacos.log
tail -f /home/nacos/logs/access.log

安全配置

1. 启用认证

# 在 docker-compose.yml 中配置
environment:
  NACOS_AUTH_ENABLE: true
  NACOS_AUTH_TOKEN: SecretKey012345678901234567890123456789012345678901234567890123456789
  NACOS_AUTH_IDENTITY_KEY: nacos
  NACOS_AUTH_IDENTITY_VALUE: nacos

2. 用户管理

# 创建用户
curl -X POST 'http://localhost:8848/nacos/v1/auth/users' \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d 'username=admin&password=admin123'

# 创建角色
curl -X POST 'http://localhost:8848/nacos/v1/auth/roles' \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d 'role=admin&username=admin'

# 分配权限
curl -X POST 'http://localhost:8848/nacos/v1/auth/permissions' \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d 'role=admin&resource=*&action=*'

3. SSL 配置

# HTTPS 配置
environment:
  NACOS_SERVER_PORT: 8848
  NACOS_SSL_ENABLED: true
  NACOS_SSL_KEY_STORE: /path/to/keystore.p12
  NACOS_SSL_KEY_STORE_PASSWORD: password
  NACOS_SSL_KEY_STORE_TYPE: PKCS12

性能优化

1. JVM 参数优化

# 内存配置
-e JVM_XMS=2g \
-e JVM_XMX=2g \
-e JVM_XMN=1g \

# GC 配置
-e JVM_OPTS="-XX:+UseG1GC -XX:MaxGCPauseMillis=200 -XX:+UnlockExperimentalVMOptions -XX:+UseCGroupMemoryLimitForHeap"

2. 数据库优化

-- MySQL 配置优化
[mysqld]
innodb_buffer_pool_size = 1G
innodb_log_file_size = 256M
max_connections = 1000
query_cache_size = 128M

3. 网络优化

# 网络配置优化
environment:
  NACOS_SERVER_IP: 0.0.0.0
  PREFER_HOST_MODE: ip
  NACOS_SERVERS: "nacos1:8848,nacos2:8848,nacos3:8848"

常见问题

问题1：服务注册失败

现象: 服务无法注册到 Nacos 原因: 网络不通或配置错误 解决方案:

# 检查网络连通性
curl http://localhost:8848/nacos/v1/ns/operator/servers

# 检查配置
spring.cloud.nacos.discovery.server-addr=localhost:8848

问题2：配置不生效

现象: 配置更新后应用没有获取到最新配置原因: 未启用配置刷新或命名空间错误 解决方案:

spring:
  cloud:
    nacos:
      config:
        refresh-enabled: true
        namespace: correct-namespace

问题3：集群脑裂

现象: 集群节点状态异常原因: 网络分区或时钟不同步 解决方案:

# 检查集群状态
curl http://localhost:8848/nacos/v1/ns/operator/cluster/states

# 同步时钟
ntpdate -s time.nist.gov

问题4：内存溢出

现象: Nacos 服务器 OOM 原因: JVM 内存配置不当 解决方案:

# 调整内存配置
-e JVM_XMS=2g -e JVM_XMX=4g -e JVM_XMN=1g

问题5：数据库连接失败

现象: Nacos 无法连接数据库原因: 数据库配置错误或数据库未就绪 解决方案:

# 检查数据库配置
environment:
  MYSQL_SERVICE_HOST: mysql
  MYSQL_SERVICE_PORT: 3306
  MYSQL_SERVICE_DB_NAME: nacos
  MYSQL_SERVICE_USER: nacos
  MYSQL_SERVICE_PASSWORD: nacos123

⚠️ 注意: 在生产环境中，建议使用集群模式部署并启用认证，定期备份配置数据。

概述

核心特性

应用场景

环境准备

系统要求

架构组件

Docker 安装部署

1. 单机部署

独立模式（测试环境）

使用外部 MySQL 数据库

2. 使用 Docker Compose 部署

3. 访问控制台

基本概念

核心概念

层次结构

服务发现

1. 服务注册

使用 REST API 注册服务

使用 Java SDK 注册服务

2. 服务发现

使用 REST API 发现服务

使用 Java SDK 发现服务

3. 服务健康检查

配置健康检查

配置管理

1. 发布配置

使用 REST API

使用 Java SDK

2. 获取配置

使用 REST API

使用 Java SDK

3. 配置监听

实时配置更新

命名空间管理

1. 创建命名空间

2. 使用命名空间

集群部署

1. 集群配置

2. Nginx 负载均衡配置

SpringCloud 集成

1. 添加依赖

2. 服务提供者配置

application.yml

bootstrap.yml

3. 服务消费者配置

4. 配置自动刷新

API 接口

1. 服务发现 API

2. 配置管理 API

3. 命名空间 API

监控与运维

1. 健康检查

2. 监控指标

3. 日志管理

安全配置

1. 启用认证

2. 用户管理

3. SSL 配置

性能优化

1. JVM 参数优化

2. 数据库优化

3. 网络优化

常见问题

问题1：服务注册失败

问题2：配置不生效

问题3：集群脑裂

问题4：内存溢出

问题5：数据库连接失败

相关文章

服务发现对比

消息中间件

数据库技术

运维部署

监控运维

其他中间件

相关阅读