springCloud学习【1】之注册中心Eureka&Nacnos

ゝ一纸荒年。 2024-03-25 20:28 63阅读 0赞

#### 文章目录 ####

*  前言
 *  零 环境准备
 *  一 微服务总体学习框架
 *  二 微服务架构演变
 *   *  2.1 单体架构
     *  2. 2 分布式架构
     *  2.3 总结
 *  三 认识微服务
 *   *  3.1 微服务结构
     *  3.2 SpringCloud
 *  四 服务拆分和远程调用
 *   *  4.1 服务拆分原则
     *  4.2 服务拆分示例
     *  4.3 远程调用实现
     *  4.4 服务调用关系
 *  五 Eureka注册中心
 *   *  5.1 远程调用的问题
     *  5.2 Eureka的结构和作用
     *  5.3 EurekaServer使用实践
     *   *  5.3.1 搭建EurekaServer
         *  5.3.2 服务注册
         *  5.3.3 服务发现
 *  六 Ribbon负载均衡
 *   *  6.1 负载均衡原理源码探究
     *   *  6.1.1 LoadBalancerIntercepor
         *  6.1.2 LoadBalancerClient
     *  6.2 负载均衡策略IRule
     *  6.3 总结
     *  6.4 负载均衡策略
     *   *  6.3.1 自定义负载均衡策略
     *  6.4 饥饿加载
 *  七 Nacos注册中心
 *   *  7.1 Windows安装Nacos
     *   *  7.1.1 下载安装包\[nacos-server-1.4.1\](https://github.com/alibaba/nacos/releases/tag/1.4.1)
         *  7.1.2 解压
         *  7.1.3 端口配置
         *  7.1.4 启动
         *  7.1.5 成功效果
         *  7.1.6 访问
     *  7.2 服务注册到nacos
     *  7.3 服务分级存储模型
     *   *  7.3.1 给user-service配置集群
         *  7.3.2 同集群优先的负载均衡
     *  7.4 权重配置
     *  7.5 环境隔离
 *  八 Nacos与Eureka的对比

## 前言 ##

*  本文是作者的学习笔记，其中的操作，经过亲手实践。所以，并不是粘贴文档笔记的水文！！！
 *  由于是学习的记录，所以并不会像官方的笔记一样，面面俱到，操作详细！！
 *  需要深入学习的朋友，建议参看黑马教程！！

## 零 环境准备 ##

*  JDK1.8+
 *  MYSQL
 *  Maven
 *  IDEA
 *  网络
 *  电脑要求：
    
     *  内存：16+
     *  cpu：主频可达3.+即可

## 一 微服务总体学习框架 ##

*  星辰大海，我亦往矣！  
    ![在这里插入图片描述][6fdf5a46a21c47e5838c1b4e2267fb48.png]  
    ![在这里插入图片描述][4183e0ee19234dad88c2c0689a795031.png]  
    ![在这里插入图片描述][5507e58bd11a4f17a0760329fc52d32e.png]

## 二 微服务架构演变 ##

### 2.1 单体架构 ###

*  **单体架构**：将业务的所有功能集中在一个项目中开发，打成一个包部署。
 *  **优点**：
    
     *  架构简单
     *  部署成本低
 *  **缺点**：
    
     *  耦合度高（维护困难、升级困难）  
        ![在这里插入图片描述][12e7da03df40411e9c0096d221b21f70.png]

### 2. 2 分布式架构 ###

*  **分布式架构**：根据业务功能对系统做拆分，每个业务功能模块作为独立项目开发，称为一个服务。  
    ![在这里插入图片描述][dd1bcf91550e48998cb0f26639c38bcb.png]
 *  **优点：**
    
     *  降低服务耦合
     *  有利于服务升级和拓展
 *  **缺点：**
    
     *  服务调用关系错综复杂

### 2.3 总结 ###

<table> 
 <thead> 
  <tr> 
   <th>架构</th> 
   <th>优点</th> 
   <th>缺点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>单体架构</td> 
   <td>架构简单，成本低</td> 
   <td>耦合度高，升级维护困难</td> 
  </tr> 
  <tr> 
   <td>分布式架构</td> 
   <td>耦合度低，方便拓展和升级</td> 
   <td>服务调用关系复杂</td> 
  </tr> 
 </tbody> 
</table>

## 三 认识微服务 ##

*  **微服务是一种经过良好架构设计的分布式架构方案。**
 *  微服务架构特征：
    
     *  单一职责：微服务拆分粒度更小，每一个服务都对应唯一的业务能力，做到单一职责，避免重复业务开发
     *  面向服务：微服务对外暴露业务接口
     *  自治：团队独立、技术独立、数据独立、部署独立
     *  隔离性强：服务调用做好隔离、容错、降级，避免出现级联问题
 *  微服务的上述特性其实是在给分布式架构制定一个标准，进一步降低服务之间的耦合度，提供服务的独立性和灵活性。做到高内聚，低耦合。  
    ![在这里插入图片描述][2cbf04b1370e4e3ea726959d2d058100.png]

### 3.1 微服务结构 ###

*  微服务这种方案需要技术框架来落地，全球的互联网公司都在积极尝试自己的微服务落地技术。在国内最知名的就是SpringCloud和阿里巴巴的Dubbo。  
    ![在这里插入图片描述][069ed5d7fcb645e49a914487e2d2538a.png]
 *  企业的使用情况：  
    ![在这里插入图片描述][d1158c2beeb04a08a3c9b931a12cc4a8.png]

### 3.2 SpringCloud ###

*  [SpringCloud][]是目前国内使用最广泛的微服务框架。
 *  SpringCloud集成了各种微服务功能组件，并基于SpringBoot实现了这些组件的自动装配，从而提供了良好的开箱即用体验。
 *  其中常见的组件包括:  
    ![在这里插入图片描述][834734529e194d9e8890507494d2c4b4.png]
 *  `SpringCloud`底层是依赖于`SpringBoot`的，并且有版本的兼容关系，如下：  
    ![在这里插入图片描述][2c2fd864544c4347a7142258c2c2c032.png]

## 四 服务拆分和远程调用 ##

### 4.1 服务拆分原则 ###

1.  单一职责：不同微服务，不要重复开发相同业务
2.  数据独立：不要访问其它微服务的数据库
3.  面向服务：将自己的业务暴露为接口，供其它微服务调用  
    ![在这里插入图片描述][22a94343e1ac4f60ae8901a01ca089ed.png]

### 4.2 服务拆分示例 ###

*  `cloud-demo`：父工程，管理依赖
    
     *  `order-service`：订单微服务，负责订单相关业务
     *  `user-service`：用户微服务，负责用户相关业务  
        ![在这里插入图片描述][2584590f107345f4a9b74047a8434b07.png]

### 4.3 远程调用实现 ###

*  案例需求：  
    ![在这里插入图片描述][d96273a801e04c97b9a732938541ffd3.png]
 *  远程调用方式分析
    
     *  需要在`order-service`中向`user-service`发起一个http的请求，调用`http://localhost:8081/user/{userId}`这个接口  
        ![在这里插入图片描述][631eb8130c16423496cf38f7c64055fe.png]

--------------------

*  微服务调用方式：
    
     *  基于RestTemplate发起的http请求实现远程调用
     *  http请求做远程调用是与语言无关的调用，只要知道对方的ip、端口、接口路径、请求参数即可。

--------------------

*  实现步骤：
    
    1.  注册一个`RestTemplate`的实例到Spring容器
    
        @SpringBootApplication
        public class OrderApplication {
              
        
            public static void main(String[] args) {
              
                SpringApplication.run(OrderApplication.class, args);
            }
        
            @Bean
            public RestTemplate restTemplate() {
              
                return new RestTemplate();
            }
        }
    
    1.  修改`order-service`服务中的`OrderService`类中的`queryOrderById`方法，根据`Order`对象中的`userId`查询`User`
    2.  将查询的`User`填充到`Orde`r对象，一起返回
    
        @Autowired
        private RestTemplate restTemplate;
        
        public Order queryOrderById(Long orderId) {
              
            // 1.查询订单
            Order order = orderMapper.findById(orderId);
            // 2.远程查询user
            // 2.1 url地址
            String url="http://localhost:8081/user/"+order.getUserId();
            // 2.2 发起调用
            User user = restTemplate.getForObject(url, User.class);
            // 3 存入order
            order.setUser(user);
        
            // 4.返回
            return order;
        }

### 4.4 服务调用关系 ###

*  服务提供者：一次业务中，被其它微服务调用的服务。（提供接口给其它微服务）
 *  服务消费者：一次业务中，调用其它微服务的服务。（调用其它微服务提供的接口）  
    ![在这里插入图片描述][9290142f2b52445abf3b495441373b2b.png]
 *  服务提供者与服务消费者的角色并不是绝对的，而是相对于业务而言。
 *  如果服务A调用了服务B，而服务B又调用了服务C：
    
     *  对于A调用B的业务而言：A是服务消费者，B是服务提供者
     *  对于B调用C的业务而言：B是服务消费者，C是服务提供者
     *  因此，服务B既可以是服务提供者，也可以是服务消费者。

## 五 Eureka注册中心 ##

### 5.1 远程调用的问题 ###

![在这里插入图片描述][eb18801ccf9c4ee898fb3ab7a5d50b3e.png]

*  服务调用出现的问题：
    
     *  **服务消费者该如何获取服务提供者的地址信息？**
     *  **如果有多个服务提供者，消费者该如何选择？**
     *  **消费者如何得知服务提供者的健康状态？**

### 5.2 Eureka的结构和作用 ###

*  这些问题都需要利用SpringCloud中的注册中心来解决，其中最广为人知的注册中心就是`Eureka`
 *  在Eureka架构中，微服务角色有两类：
 *  EurekaServer：服务端，注册中心
    
     *  记录服务信息
     *  心跳监控
 *  EurekaClient：客户端
    
     *  Provider：服务提供者，例如案例中的 user-service
        
         *  注册自己的信息到EurekaServer
         *  每隔30秒向EurekaServer发送心跳
     *  consumer：服务消费者，例如案例中的 order-service
        
         *  根据服务名称从EurekaServer拉取服务列表
         *  基于服务列表做负载均衡，选中一个微服务后发起远程调用
 *  其结构如下：  
    ![在这里插入图片描述][a11d75ceba09499a8d0bbf349aec9082.png]
 *  Eureka方案对于服务调用出现的问题的解答：
 *  **服务消费者(order-service)该如何获取服务提供者(user-service)的地址信息？**
    
     *  **服务注册**：`user-service`服务实例启动后，将自己的信息注册到`eureka-server`（Eureka服务端）。
     *  `eureka-server`保存服务名称到服务实例地址列表的映射关系
     *  **服务发现或服务拉取**：`order-service`根据服务名称，拉取实例地址列表。
 *  如果有多个服务提供者，消费者该如何选择？
    
     *  `order-service`从实例列表中利用负载均衡算法选中一个实例地址
     *  向该实例地址发起远程调用
 *  消费者如何得知服务提供者的健康状态？
    
     *  user-service会每隔一段时间（默认30秒）向eureka-server发起请求，报告自己状态，称为心跳
     *  当超过一定时间没有发送心跳时，eureka-server会认为微服务实例故障，将该实例从服务列表中剔除
     *  order-service拉取服务时，就能将故障实例排除了

>  *  注意：一个微服务，既可以是服务提供者，又可以是服务消费者，因此eureka将服务注册、服务发现等功能统一封装到了eureka-client端

### 5.3 EurekaServer使用实践 ###

*  步骤：  
    ![在这里插入图片描述][6a68ac23e4c4401998dbeefb890d4ca3.png]

#### 5.3.1 搭建EurekaServer ####

*  首先注册中心服务端：eureka-server，这必须是一个独立的微服务

1.  在父工程下，创建一个子模块`eureka-server`【普通maven模块即可】：
2.  引入eureka依赖
    
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
3.  在子模块`eureka-server`的java目录下编写启动类
    
        import org.springframework.boot.SpringApplication;
        import org.springframework.boot.autoconfigure.SpringBootApplication;
        import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
        
        @SpringBootApplication
        @EnableEurekaServer
        public class EurekaApplication {
              
            public static void main(String[] args) {
              
                SpringApplication.run(EurekaApplication.class, args);
            }
        }
4.  在子模块`eureka-server`的resource目录下，编写配置文件`application.yml`
    
        server:
          port: 10086 #服务端口
        spring:
          application:
            name: eureka-server # Eureka的服务名称
        eureka:
          client:
            service-url:
              defaultZone: http://127.0.0.1:10086/eureka #Eureka地址信息
5.  运行`EurekaApplication`main函数，启动服务  
    ![在这里插入图片描述][aa1c0a8407bc454bb2bc86f374f705e9.png]

#### 5.3.2 服务注册 ####

1.  引入依赖
    
     *  在`user-service`的`pom`文件中，引入下面的`eureka-client`依赖：
    
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
2.  配置文件
    
     *  在`user-service`中，修改`application.yml`文件，添加服务名称、`eureka`地址：
    
        spring:
          application:
            name: userservice
        eureka:
          client:
            service-url:
              defaultZone: http://127.0.0.1:10086/eureka
3.  启动多个user-service实例
    
     *  为了演示一个服务有多个实例的场景，我们添加一个SpringBoot的启动配置，再启动一个user-service。
     *  首先，复制原来的user-service启动配置：  
        ![在这里插入图片描述][32854b8ccf974b45baa6252377c987a3.png]  
        ![在这里插入图片描述][b9150a4bec6148f684b70772906c15e2.png]  
        ![在这里插入图片描述][5da978f6ed9348fbb2071d2645e92486.png]  
        ![在这里插入图片描述][4b79b2c79a2e4c78a9c9ccd74ca51414.png]
4.  启动两个user-service实例：  
    ![在这里插入图片描述][6bcf815f6bef4823ba684d075cace872.png]
5.  查看eureka-server管理页面：  
    ![在这里插入图片描述][ec9843135695423894b37d085248eef9.png]

#### 5.3.3 服务发现 ####

*  将order-service的逻辑修改：向eureka-server拉取user-service的信息，实现服务发现。

1.  引入依赖
    
     *  服务发现、服务注册统一都封装在eureka-client依赖，因此这一步与服务注册时一致。
     *  在order-service的pom文件中，引入下面的eureka-client依赖：
    
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
2.  配置文件
    
     *  服务发现也需要知道eureka地址，因此第二步与服务注册一致，都是配置eureka信息：
     *  在order-service中，修改application.yml文件，添加服务名称、eureka地址：
    
        spring:
          application:
            name: orderservice
        eureka:
          client:
            service-url:
              defaultZone: http://127.0.0.1:10086/eureka
3.  服务拉取和负载均衡
    
     *  在`eureka-server`中拉取`user-service`服务的实例列表，并且实现负载均衡。
     *  在`order-service`的`OrderApplication`中，给`RestTemplate`这个`Bean`添加一个`@LoadBalanced`注解：
    
        @Bean
        @LoadBalanced
        public RestTemplate restTemplate() {
              
            return new RestTemplate();
        }
4.  修改order-service服务中的cn.itcast.order.service包下的OrderService类中的queryOrderById方法。
    
     *  **修改访问的url路径，用服务名代替ip、端口：**
    
        public Order queryOrderById(Long orderId) {
              
            // 1.查询订单
            Order order = orderMapper.findById(orderId);
            // 2.远程查询user
            // 2.1 url地址
            //String url="http://localhost:8081/user/"+order.getUserId();
            String url="http://userservice/user/"+order.getUserId();
            // 2.2 发起调用
            User user = restTemplate.getForObject(url, User.class);
            // 3 存入order
            order.setUser(user);
        
            // 4.返回
            return order;
        
        }

*  **spring会自动帮助我们从eureka-server端，根据userservice这个服务名称，获取实例列表，而后完成负载均衡。**

## 六 Ribbon负载均衡 ##

*  SpringCloud底层其实是利用了一个名为Ribbon的组件，来实现负载均衡功能的。

### 6.1 负载均衡原理源码探究 ###

*  发出的请求明明是`http://userservice/user/102`，怎么变成了`http://localhost:8081`的呢？
 *  为什么只输入了service名称就可以访问了呢？之前还要获取ip和端口。
    
     *  显然有人帮我们根据service名称，获取到了服务实例的ip和端口。它就是`LoadBalancerInterceptor`，这个类会在对`RestTemplate`的请求进行拦截，然后从Eureka根据服务id获取服务列表，随后利用负载均衡算法得到真实的服务地址信息，替换服务id。

#### 6.1.1 LoadBalancerIntercepor ####

public class LoadBalancerInterceptor implements ClientHttpRequestInterceptor {
        
        private LoadBalancerClient loadBalancer;
        private LoadBalancerRequestFactory requestFactory;
    
        public LoadBalancerInterceptor(LoadBalancerClient loadBalancer, LoadBalancerRequestFactory requestFactory) {
        
            this.loadBalancer = loadBalancer;
            this.requestFactory = requestFactory;
        }
    
        public LoadBalancerInterceptor(LoadBalancerClient loadBalancer) {
        
            this(loadBalancer, new LoadBalancerRequestFactory(loadBalancer));
        }
    
        public ClientHttpResponse intercept(final HttpRequest request, final byte[] body, final ClientHttpRequestExecution execution) throws IOException {
        
            URI originalUri = request.getURI(); //http://user-service/user/102
            String serviceName = originalUri.getHost(); //user-service
            Assert.state(serviceName != null, "Request URI does not contain a valid hostname: " + originalUri);
            return (ClientHttpResponse)this.loadBalancer.execute(serviceName, this.requestFactory.createRequest(request, body, execution));
        }
    }

*  `intercept`方法，拦截了用户的`HttpRequest`请求，然后做了几件事：
    
     *  `request.getURI()`：获取请求uri，如： `http://user-service/user/102`
     *  `originalUri.getHost()`：获取uri路径的主机名，其实就是服务id，`user-service`
     *  `this.loadBalancer.execute()`：处理服务id，和用户请求。
 *  `this.loadBalancer`是`LoadBalancerClient`类型，继续跟入

#### 6.1.2 LoadBalancerClient ####

*  在`LoadBalancerClient`接口的实现类`RibbonLoadBalancerClient`中，可以看到`execute`方法：
    
        public <T> T execute(String serviceId, LoadBalancerRequest<T> request, Object hint) throws IOException {
              
                ILoadBalancer loadBalancer = this.getLoadBalancer(serviceId);
                Server server = this.getServer(loadBalancer, hint);
                if (server == null) {
              
                    throw new IllegalStateException("No instances available for " + serviceId);
                } else {
              
                    RibbonServer ribbonServer = new RibbonServer(serviceId, server, this.isSecure(server, serviceId), this.serverIntrospector(serviceId).getMetadata(server));
                    return this.execute(serviceId, (ServiceInstance)ribbonServer, (LoadBalancerRequest)request);
                }
            }
    
     *  `getLoadBalancer(serviceId)`：根据服务id获取`ILoadBalancer`，而`ILoadBalancer`会拿着服务id去eureka中获取服务列表并保存起来。
     *  `getServer(loadBalancer)`：利用内置的负载均衡算法，从服务列表中选择一个。

### 6.2 负载均衡策略IRule ###

*  在刚才的代码中，可以看到获取服务使通过一个`getServer`方法来做负载均衡:
    
        protected Server getServer(ILoadBalancer loadBalancer, Object hint) {
              
                return loadBalancer == null ? null : loadBalancer.chooseServer(hint != null ? hint : "default");
            }
 *  继续跟踪源码`chooseServer`方法，进入`ILoadBalancer`接口文件，打开`chooseServer`的继承类`BaseLoadBalancer`
    
        public Server chooseServer(Object key) {
              
            if (this.counter == null) {
              
                this.counter = this.createCounter();
            }
        
            this.counter.increment();
            if (this.rule == null) {
              
                return null;
            } else {
              
                try {
              
                    return this.rule.choose(key); //进行服务选择的就是这个rule
                } catch (Exception var3) {
              
                    logger.warn("LoadBalancer [{}]:  Error choosing server for key {}", new Object[]{
              this.name, key, var3});
                    return null;
                }
            }
        }
 *  探究`rule`的负载均衡策略  
    ![在这里插入图片描述][2fbeb6420b49401fa760a4a48d4c2ca1.png]

### 6.3 总结 ###

*  SpringCloudRibbon的底层采用了一个拦截器，拦截了RestTemplate发出的请求，对地址做了修改。  
    ![在这里插入图片描述][4d98d5d64c174729899c8e6ef4c150e6.png]
 *  基本流程如下：
    
     *  拦截我们的`RestTemplate`请求`http://userservice/user/101`
     *  `RibbonLoadBalancerClien`t会从请求url中获取服务名称，也就是`user-service`
     *  `DynamicServerListLoadBalancer`根据`user-service`到`eureka`拉取服务列表
     *  `eureka`返回列表，`localhost:8081、localhost:80821`
     *  `IRule`利用内置负载均衡规则，从列表中选择一个，例如`localhost:8081`
     *  `RibbonLoadBalancerClient`修改请求地址，用`localhost:8081`替代`userservice`，得到`http://localhost:8081/user/101`，发起真实请求

### 6.4 负载均衡策略 ###

*  负载均衡的规则都定义在IRule接口中，而IRule有很多不同的实现类：  
    ![在这里插入图片描述][35b2a5237b22423689c0d4c31902e4e1.png]
 *  不同规则的含义如下：

![在这里插入图片描述][c9d7529263d146638c2e6a05d577e912.png]

*  默认的实现就是ZoneAvoidanceRule，是一种轮询方案

#### 6.3.1 自定义负载均衡策略 ####

*  通过定义IRule实现可以修改负载均衡规则，有两种方式：
    
    1.  代码方式：在order-service中的OrderApplication类中，定义一个新的IRule：
    
        @Bean
        public IRule randomRule(){
              
            return new RandomRule();
        }
    
    1.  配置文件方式：在order-service的application.yml文件中，添加新的配置也可以修改规则：
    
        userservice: # 给某个微服务配置负载均衡规则，这里是userservice服务
          ribbon:
            NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule # 负载均衡规则

>  *  **注意**，一般用默认的负载均衡规则，不做修改。

--------------------

*  总结
 *  负载均衡自定义方式
    
     *  代码方式：配置灵活，但修改时需要重新打包发布
     *  配置方式：直观，方便，无需重新打包发布，但是无法做全局配置

### 6.4 饥饿加载 ###

*  Ribbon默认是采用懒加载，即第一次访问时才会去创建`LoadBalanceClient`，请求时间会很长。
 *  而饥饿加载则会在项目启动时创建，降低第一次访问的耗时，通过在服务消费者(order-service)的配置文件中配置开启饥饿加载：

ribbon:
      eager-load:
        enabled: true
        clients: userservice

*  饥饿加载
    
     *  开启饥饿加载
     *  指定饥饿加载的微服务名称

## 七 Nacos注册中心 ##

*  国内公司一般都推崇阿里巴巴的技术，比如注册中心，SpringCloudAlibaba也推出了一个名为Nacos的注册中心。

### 7.1 Windows安装Nacos ###

*  [Nacos][]是阿里巴巴的产品，现在是[SpringCloud][]中的一个组件。相比[Eureka][]功能更加丰富，在国内受欢迎程度较高。
 *  由于学习使用项目的SpringBoot的版本是`2.3.9.RELEASE`，为符合软件版本的兼容性，故采用[nacos-server-1.4.1][]
 *  开发阶段采用单机安装即可。

#### 7.1.1 下载安装包[nacos-server-1.4.1][] ####

![在这里插入图片描述][61c4a4315b3341c0a09979231e730b8c.png]

#### 7.1.2 解压 ####

*  **将这个包解压到任意非中文目录下。同时注意，路径中不要包含特殊字符，否则，会出现一些莫名其妙的错误！**  
    ![在这里插入图片描述][033730c48809479e80c1edd76c4299f8.png]
    
     *  bin：启动脚本
     *  conf：配置文件

#### 7.1.3 端口配置 ####

*  Nacos的默认端口是8848，如果你电脑上的其它进程占用了8848端口，请先尝试关闭该进程。
 *  **如果无法关闭占用8848端口的进程**，也可以进入nacos的conf目录，修改配置文件中的端口：  
    ![在这里插入图片描述][7ff235c945034100bdfdf736d82a7e5a.png]
 *  修改其中的内容：  
    ![在这里插入图片描述][902560264d6a47278451de5b648a9ce4.png]

#### 7.1.4 启动 ####

*  启动非常简单，进入bin目录：
 *  方式一：在bin目录下，进入终端，运行命令`startup.cmd -m standalone`。(默认情况下，nacos是集群的方式启动，这里使用单机模式启动即可)

startup.cmd -m standalone

*  方式二：修改`bin/startup.cmd`文件，设置启动模式为单机模式  
    ![在这里插入图片描述][5dc03572127049c8b26df9bd7ed78829.png]

#### 7.1.5 成功效果 ####

![在这里插入图片描述][351cb5ac87b24e2fa9cd9473d45f0ec7.png]

#### 7.1.6 访问 ####

*  在浏览器输入地址：http://127.0.0.1:8848/nacos即可：  
    ![在这里插入图片描述][572be5d446514bf78f9880cf83c6fe5f.png]
 *  默认的账号和密码都是nacos，进入后：  
    ![在这里插入图片描述][af3e15239d704e0c84ccd989ab2f468d.png]

### 7.2 服务注册到nacos ###

*  Nacos是SpringCloudAlibaba的组件，而SpringCloudAlibaba也遵循SpringCloud中定义的服务注册、服务发现规范。因此使用Nacos和使用Eureka对于微服务来说，并没有太大区别。
 *  主要差异在于：
    
     *  依赖不同
     *  服务地址不同

1.  引入依赖
    
     *  在cloud-demo父工程的pom文件中的`<dependencyManagement>`中引入SpringCloudAlibaba的依赖：
    
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>2.2.6.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    
     *  然后在user-service和order-service中的pom文件中引入nacos-discovery依赖：
    
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
2.  配置nacos地址
    
     *  在`user-service`和`order-service`的`application.yml`中修改`application.yml`文件，添加服务名称，`nacos`地址
     *  user-service
    
        spring:
          application:
            name: userservice
          cloud:
            nacos:
              server-addr: localhost:8848
    
     *  order-service
    
        spring:
        	  application:
        	    name: orderservice
        	  cloud:
        	    nacos:
        	      server-addr: localhost:8848
3.  重启
    
     *  重启微服务后，登录nacos管理页面，可以看到微服务信息：  
        ![在这里插入图片描述][c2299f698b1d4a0db9a3a853bdee8e7a.png]

### 7.3 服务分级存储模型 ###

*  一个**服务**可以有多个**实例**，例如我们的user-service，假如这些实例分布于全国各地的不同机房,可以有:
    
     *  127.0.0.1:8081，在上海机房
     *  127.0.0.1:8082，在上海机房
     *  127.0.0.1:8083，在杭州机房
 *  Nacos就将同一机房内的实例 划分为一个**集群**。user-service是服务，一个服务可以包含多个集群:  
    ![在这里插入图片描述][0786cca5709b48499fd99dee55b471d6.png]
 *  微服务互相访问时，应该尽可能访问同集群实例，因为本地访问速度更快。当本集群内不可用时，才访问其它集群。例如：  
    ![在这里插入图片描述][656c05687b544566aba7ca7829502576.png]
 *  杭州机房内的order-service应该优先访问同机房的user-service。

--------------------

#### 7.3.1 给user-service配置集群 ####

1.  给user-service配置集群
    
     *  修改user-service的application.yml文件，添加集群配置：
    
        spring:
          cloud:
            nacos:
              server-addr: localhost:8848
              discovery:
                cluster-name: HZ # 集群名称
    
     *  重启两个user-service实例后，可以在nacos控制台看到下面结果：  
        ![在这里插入图片描述][448f5807e4fc48a19bb3cd7b7e2e18f6.png]
2.  再次复制一个user-service启动配置，添加属性：
    
        -Dserver.port=8083 -Dspring.cloud.nacos.discovery.cluster-name=SH
    
     *  具体操作方式，同Eureka服务注册
3.  启动UserApplication3后再次查看nacos控制台：  
    ![在这里插入图片描述][a47bea6d7ca34d4482f70d40e20b927c.png]

#### 7.3.2 同集群优先的负载均衡 ####

*  默认的`ZoneAvoidanceRule`并不能实现根据同集群优先来实现负载均衡。因此Nacos中提供了一个`NacosRule`的实现，可以优先从同集群中挑选实例。

1.  给order-service配置集群信息
    
        spring:
          cloud:
            nacos:
              server-addr: localhost:8848
              discovery:
                cluster-name: HZ # 集群名称
2.  修改负载均衡规则
    
     *  修改order-service的application.yml文件，修改负载均衡规则：
    
        userservice:
          ribbon:
            NFLoadBalancerRuleClassName: com.alibaba.cloud.nacos.ribbon.NacosRule # 负载均衡规则

### 7.4 权重配置 ###

*  实际部署中会出现这样的场景：
    
     *  服务器设备性能有差异，部分实例所在机器性能较好，另一些较差，我们希望性能好的机器承担更多的用户请求。
     *  但默认情况下NacosRule是同集群内随机挑选，不会考虑机器的性能问题。
     *  因此，Nacos提供了权重配置来控制访问频率，权重越大则访问频率越高。

--------------------

*  在nacos控制台，找到user-service的实例列表，点击编辑，即可修改权重：
    
     *  **注意**：如果权重修改为0，则该实例永远不会被访问  
        ![在这里插入图片描述][52fb4f8631a541028dd967dcb4d68c48.png]

### 7.5 环境隔离 ###

*  服务划分、实例划分是基于业务的划分
 *  环境的变化的划分（如生产环境、开发环境、测试环境的隔离）
 *  Nacos环境隔离：
    
     *  namespace来实现环境隔离功能。
     *  nacos中可以有多个namespace，每个namespace都有唯一的id
     *  namespace下可以有group、service等
     *  不同namespace的服务不可见  
        ![在这里插入图片描述][77f5f2864fa0475c848ef0bac32384b8.png]

1.  创建namespace
    
     *  默认情况下，所有service、data、group都在同一个namespace，名为public：  
        ![在这里插入图片描述][bc87e75521874649bfa6b3d0b19ba234.png]
     *  可以点击页面新增按钮，添加一个namespace  
        ![在这里插入图片描述][6263cc61ca53466e990c213962832eba.png]  
        ![在这里插入图片描述][53efe43073d949b288acec88dc5cfd84.png]

*  在页面看到一个新的namespace：  
    ![在这里插入图片描述][b8ca2840fa4643fd91719017941a31b6.png]

1.  给微服务配置namespace
    
     *  给微服务配置namespace只能通过修改配置来实现。修改order-service的application.yml文件：
    
        spring:
          cloud:
            nacos:
              server-addr: localhost:8848
              discovery:
                cluster-name: HZ
                namespace: 492a7d5d-237b-46a1-a99a-fa8e98e4b0f9 # 命名空间，填ID
2.  重启order-service后，访问控制台，可以看到下面的结果：  
    ![在这里插入图片描述][ea6da9b4405d4b2f9b49ff010ef63002.png]  
    ![在这里插入图片描述][a1d3266785834f79957d9532527dc764.png]

>  *  此时访问order-service，因为namespace不同，会导致找不到userservice，控制台会报错

## 八 Nacos与Eureka的对比 ##

*  Nacos的服务实例分为两种类型：
    
     *  临时实例：如果实例宕机超过一定时间，会从服务列表剔除，默认的类型。
     *  非临时实例：如果实例宕机，不会从服务列表剔除，也可以叫永久实例。
 *  配置一个服务实例为永久实例：
    
        spring:
          cloud:
            nacos:
              discovery:
                ephemeral: false # 设置为非临时实例
 *  Nacos和Eureka整体结构类似，服务注册、服务拉取、心跳等待，但是也存在一些差异：  
    ![在这里插入图片描述][48f7952d354e4b21b75404e378af069d.png]
 *  Nacos与eureka的共同点
    
     *  都支持服务注册和服务拉取
     *  都支持服务提供者心跳方式做健康检测
 *  Nacos与Eureka的区别
    
     *  Nacos支持服务端主动检测提供者状态：临时实例采用心跳模式，非临时实例采用主动检测模式
     *  临时实例心跳不正常会被剔除，非临时实例则不会被剔除
     *  Nacos支持服务列表变更的消息推送模式，服务列表更新更及时
     *  Nacos集群默认采用AP(保证可用性、分区容错性)方式，当集群中存在非临时实例时，采用CP(保证一致性、分区容错性)模式；Eureka采用AP方式，且不支持切换。

>  *  AOP理论
>     
>      *  Consistency：一致性
>      *  Availability：可用性
>      *  Partition Tolerance：分区容错性

[6fdf5a46a21c47e5838c1b4e2267fb48.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/ff6e81a93de84afa8d66cb31ee871efa.png
[4183e0ee19234dad88c2c0689a795031.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/88cde39ea4154323b9b6d074d07b5b14.png
[5507e58bd11a4f17a0760329fc52d32e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/a7bbd8100d50462b8ed138b21ff0098b.png
[12e7da03df40411e9c0096d221b21f70.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/50dbd3a192f041d48f8f698081b34f99.png
[dd1bcf91550e48998cb0f26639c38bcb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/0ab0e093cc574789b5e6e508320729a6.png
[2cbf04b1370e4e3ea726959d2d058100.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/9fe544251f9f436cabc252b4e502c9bb.png
[069ed5d7fcb645e49a914487e2d2538a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/e99a156a99a649a3b4aed9e566de2e3f.png
[d1158c2beeb04a08a3c9b931a12cc4a8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/003691f1917b4028acddb377e5b45155.png
[SpringCloud]: https://spring.io/projects/spring-cloud
[834734529e194d9e8890507494d2c4b4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/ce185dbaf51a42fab385cef6737e96b2.png
[2c2fd864544c4347a7142258c2c2c032.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/a2d17239d6084b6996f3676568c7908a.png
[22a94343e1ac4f60ae8901a01ca089ed.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/09aa244996034c3f8d7fdac5bd8dbefd.png
[2584590f107345f4a9b74047a8434b07.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/5b9f7a3141ce45a694e28b18bdae2232.png
[d96273a801e04c97b9a732938541ffd3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/19ed458cfd9d4ffd84a9490a04ea54a5.png
[631eb8130c16423496cf38f7c64055fe.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/2714958c118c4ba3abf88ea4ac2dd6d6.png
[9290142f2b52445abf3b495441373b2b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/a49fd500b7394abfa9e1ffe7c64f9ab9.png
[eb18801ccf9c4ee898fb3ab7a5d50b3e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/0532ee3de9e046919b4f9b68e84d1257.png
[a11d75ceba09499a8d0bbf349aec9082.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/dcd429b91310487a8738a0e13de2176b.png
[6a68ac23e4c4401998dbeefb890d4ca3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/251a7f9eeb684bef93a10fa2032238d8.png
[aa1c0a8407bc454bb2bc86f374f705e9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/029b032b287047e287aeab5a142ea7ac.png
[32854b8ccf974b45baa6252377c987a3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/36e02e84e051412c83eadfbcdc7c974f.png
[b9150a4bec6148f684b70772906c15e2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/b12a828233f446c78ed8e9fe900ac67b.png
[5da978f6ed9348fbb2071d2645e92486.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/32a7edbe012446fbaaabe392bf15df5f.png
[4b79b2c79a2e4c78a9c9ccd74ca51414.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/3a388ca1090a4de7b0625df24c336de2.png
[6bcf815f6bef4823ba684d075cace872.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/158df9dd18994791b106255f2b9ea8cf.png
[ec9843135695423894b37d085248eef9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/773f920c1d1c4dffb3a29a9f455a584c.png
[2fbeb6420b49401fa760a4a48d4c2ca1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/f5ea0cc966f94ff6b05e9d6a54a3fe88.png
[4d98d5d64c174729899c8e6ef4c150e6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/d745e307fc024e8282e9c2cefa4aa115.png
[35b2a5237b22423689c0d4c31902e4e1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/050d659c658c43fcb26745130b7dad9a.png
[c9d7529263d146638c2e6a05d577e912.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/3c22e7c2433c4d87a12ec6300a8fe0f9.png
[Nacos]: https://nacos.io/
[Eureka]: https://github.com/Netflix/eureka
[nacos-server-1.4.1]: https://github.com/alibaba/nacos/releases/tag/1.4.1
[61c4a4315b3341c0a09979231e730b8c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/3c72958bf8a248409e28edf39d3a506c.png
[033730c48809479e80c1edd76c4299f8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/2d13d236ff7643979e44b59f168ae05a.png
[7ff235c945034100bdfdf736d82a7e5a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/166ecec0034c4929b4cf61397443ab21.png
[902560264d6a47278451de5b648a9ce4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/e7ef982b2b84459b839db91844e742c3.png
[5dc03572127049c8b26df9bd7ed78829.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/8418af038d3148ae8df7eccf4fdefee6.png
[351cb5ac87b24e2fa9cd9473d45f0ec7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/3a7bcbe47d8347b5a304839033f15c97.png
[572be5d446514bf78f9880cf83c6fe5f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/461364da629144fa8326408312dcbfbb.png
[af3e15239d704e0c84ccd989ab2f468d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/5b920e75a6de45fb9ce2549394abb7e1.png
[c2299f698b1d4a0db9a3a853bdee8e7a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/20c1f3cd50304a26bf2a305f66244722.png
[0786cca5709b48499fd99dee55b471d6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/97efe9f3b9e14cdf806a124cedb62de0.png
[656c05687b544566aba7ca7829502576.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/83bf7059ce864244910a1c4338d07963.png
[448f5807e4fc48a19bb3cd7b7e2e18f6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/d8fd1c255e0d4cc0be868d6ee49e198c.png
[a47bea6d7ca34d4482f70d40e20b927c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/bc776fa62ac742e5a328ea9d74f835c4.png
[52fb4f8631a541028dd967dcb4d68c48.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/9a23c8212516425a89349e55b1464e18.png
[77f5f2864fa0475c848ef0bac32384b8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/b6f578f62dbf4abd83ab62d97d1a32f5.png
[bc87e75521874649bfa6b3d0b19ba234.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/be62e6fc60fa4c308645fe53b106a659.png
[6263cc61ca53466e990c213962832eba.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/476f84b4bbce4fe7b09d7abca9732032.png
[53efe43073d949b288acec88dc5cfd84.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/f19375aa947c41b1a70b51cefa4ec58d.png
[b8ca2840fa4643fd91719017941a31b6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/0cc7bfbf3ee44f98a877f1718bfa46b5.png
[ea6da9b4405d4b2f9b49ff010ef63002.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/dece6a02755d46eaa9c2f848c6f04223.png
[a1d3266785834f79957d9532527dc764.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/f948c51c8b0b47b8a8e05e99adf45802.png
[48f7952d354e4b21b75404e378af069d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/0cd5d58c288c4221bfc6d706bb63996f.png