从零开始搭建公司微服务授权架构技术栈（3种模式），这架构稳的一批...

Posted 程序员闪充宝

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了从零开始搭建公司微服务授权架构技术栈（3种模式），这架构稳的一批...相关的知识，希望对你有一定的参考价值。

为什么微服务中的授权更困难？

让我们以某个授权场景为例，这是一个用于编辑文档的应用程序。它很简单，但应该能说明问题：

  • 有用户、组织和文档。

  • 用户在组织中拥有角色，包括成员和管理员。

  • 文档属于组织。

  • 如果用户在组织中的角色为成员，则可以阅读文档。

  • 如果用户在组织中的角色为管理员，则可以阅读或编辑文档。

    • 在一个单体应用中，用一种清晰的方式表达这种逻辑并不太难。当你需要检查用户是否可以阅读文档时，你可以检查该文档属于哪个组织，加载该组织中用户的角色，并检查该角色是成员还是管理员。这些检查可能需要额外的一两行 SQL 语句，但数据都在一个地方。

    当你将应用程序拆分为不同的服务时，会发生什么情况？也许你已经剥离了一个新的“文档服务”——现在，检查特定文档的读权限需要检查位于该服务数据库之外的用户角色。文档服务如何访问它所需要的角色数据？

    模式 1：将数据留在原处

    通常，最简单的解决方案是将数据留在原处，并让服务在需要时请求它所需要的数据。对于上述问题，你可能认为这是最明显的解决方案。

    你可以将数据模型和逻辑分开，这样文档服务就可以控制向哪个角色授予哪些文档相关的权限（管理员可以编辑，成员可以读取，等等），然后用户服务公开一个 API 来获取组织中用户的角色。有了这个 API，权限检查可以像这样进行:

    模式 2：请求网关

    解决授权数据问题的一个优雅的解决方案是将用户角色包含在对服务（这些服务可能需要做出授权决策）的请求中。如果文档服务在请求中获得有关于用户角色的信息，那么它可以基于这些信息做出自己的授权决策。

    模式 3：集中存放所有授权数据

    另一种解决方案是将所有授权数据和逻辑放在一个地方，与需要实施授权的所有服务分开。实现此模式的最常见方法是构建专用的“授权服务”。然后，当其他服务需要执行权限检查时，它们会转向询问授权服务：

    在这个模型中，文档服务根本不关心用户的角色：它只需要询问授权服务，用户是否可以编辑文档，或者用户是否可以查看文档。授权服务本身包含做出该决策所需的所有内容（包括角色数据）。

    这可能非常有吸引力：你现在有一个负责授权的系统，这符合微服务的哲学。以这种方式进行责任分离有一些好处：团队中的其他开发人员不需要关心授权是如何工作的。因为它是独立的，所以你对授权服务所做的任何优化都有助于加速整个系统的其余部分。

    当然，这种责任分离是有代价的。现在，所有授权数据都必须保存在一个地方。决策中可能使用的所有内容都必须保存在一个集中式服务中，这些内容包括用户在组织中的身份、文档与其组织的关系。要么授权服务成为该数据的唯一真实来源，要么必须将数据从应用程序复制并同步到该中心（可能性更大）。授权系统必须理解作为所有权限基础的整个数据模型：组、共享、文件夹、来宾、项目。如果这些模型经常改变，授权系统可能成为新的开发任务的瓶颈。任意微服务中的任何更改都可能需要对授权服务进行更新，从而打破你在最初转向微服务时可能寻求的关注点分离效果。

    还有其他因素会使授权服务变得棘手：部署这一负责保护每个请求的服务意味着你要负责实现高可用和低延迟。如果系统出现故障，则所有请求都会被拒绝。如果授权系统系统的响应很慢，那么每个请求都很慢。

    谷歌的 Zanzibar 论文概述了这种模式的一种实现，但它也带来了挑战。你必须将所有数据以“元组”的形式插入到 Zanzibar 中（Alice 拥有这个文档，这个文件夹包含另一个文件夹，等等）。由于它限制了可以存储的数据，有些规则实际上不能仅用 Zanzibar 来表示，例如一些必须与时间、请求上下文有关的规则，或者依赖于某种计算的规则。有人将这些称之为“基于属性”的规则。例如，用户每周只允许创建 10 个文档，或者管理员可以将某些文件夹设置为“只读”，以防止对其中文档的编辑。在这些情况下，开发人员必须在 Zanzibar 之外编写自己的策略逻辑。

    集中式授权存在的挑战往往会阻止大多数团队采用这种模式。采用该模式的应用往往有很多服务和足够复杂的数据模型，接受授权服务本身增加的复杂性对它们来说是有意义的。例如，为了从单体应用向微服务转型，Airbnb 建立了一个名为 Himeji 的授权服务以支持他们的授权模式。已经有一个专门的工程师团队为它工作了两年，而且可能会无限期地工作下去。

    但是，如果你能够去除一些这类开销，那么对于许多使用微服务架构的团队来说，集中式授权服务可能是一个很有吸引力的选择。我的团队正在努力构建一个授权服务，力求避免集中所有授权数据的挑战。如果这是你所面临的问题，请联系我们。

    5你应该用哪一个?

    当与工程师团队交谈时，我的指导意见总是“围绕应用程序构建授权，而不是反过来。”对于简单系统，维护大量额外基础设施代价高昂，最好将数据保存在其所在的位置，并将服务与专用 api 放在一起。某些应用程序可以通过基本用户角色（可使用 GWT）扩展到大规模，在这种情况下，授权网关可能是最佳的。一些拥有各种产品、授权模式和用户类型的公司可能更愿意将其数据集中到专用的授权服务中。

    如果你对讨论你的授权系统感兴趣——例如你正在考虑进行一些重构，或者只是对它的工作方式不太满意，请与我们联系。你可以与 Oso 工程师安排 1x1 讨论，或者加入我们的 slack。我们喜欢讨论授权。

    如果你曾经对混乱的授权系统感到沮丧，或者和我一样喜欢好的分布式系统问题，欢迎加入我们团队！我们正在招聘，来帮助我们推动进一步的思考。

    原文链接：

    https://www.osohq.com/post/microservices-authorization-patterns

    往期推荐

    SpringBoot+ Dubbo + Mybatis + Nacos +Seata整合来实现Dubbo分布式事务，绝了！

    最详细的 Intellij IDEA 中使用 Debug 教程

    SpringBoot 定时任务动态管理通用解决方案

    Spring Cloud与Dubbo优缺点详解

    12 个适合做外包项目的开源后台管理系统

    整理了35个快速开发平台，前后端都有 ，接私活拿来即用，非常方便！

    从零开始搭建公司SpringCloud架构技术栈（史上最细），这套架构绝了！

    
 
    作者：Anakki
    
 
    来源：blog.csdn.net/qq_29519041/article/details/85238270
    
 
    上一篇：Maven官宣：干掉Maven和Gradle！推出更强更快更牛逼的新一代构建工具，炸裂！
    
 
    一、微服务基础
    
 
    1.什么是SpringCloud？
    
 
    SpringCloud官网：https://spring.io/projects/spring-cloud（个人建议是用谷歌浏览器访问官网打开中文翻译粗略把官网读一遍）
    
 
    个人理解：
    
 
    以前的服务器就好像，一个会语数外全能的老师，为学生提供服务，这个老师生病了，那全校停课。现在微服务流行后，学校有了数学教研组，语文教研组，外语教研组，每个教研组有一群老师具体负责某科的教学，缺了谁，学校都照样运转。
    
 
    而这个变化中，那些改变历史的程序员就是把一个服务器中的众多服务，或好几台服务器中的众多服务，分类出来，解耦合出来，把他们类似的功能交给同一个集群来做，把互相耦合在一起的功能剥离出来，按业务，按功能来把他们作为一个个微服务放在服务器上，而这个服务器就只提供一个服务，或较少的服务。让一个超大的服务逻辑，解耦合为一个个小服务，均匀的分布在各自的服务器中。微服务就微在这。
    
 
    每个教研组就是一个微服务集群。他们提供同样的服务，而注册中心Eureka就是这个存放这个教研组老师名单的地方，学生们想先访问这个注册中心获取教师名单，然后根据相应的负载方法去访问各自老师。不至于让集群中某一老师累死也不至于让某一老师闲死。
    
 
    而Zuul网关呢，就是学校的门卫，某些学生来学校找谁，它负责指引（路由），并且通过一些非常简单的配置，达到阻拦一些人进入（身份验证），或者控制想学数学的人只能去数学教研组，不能去核能教研组学怎么造原子弹（权限验证）。
    
 
    那Hystrix熔断器呢，可以把它当成学校的志愿者，当一个教研组集体罢课后，学生找不到老师了，这些志愿者及时的告诉来访问的学生，相应的结果，异常信息等，免得大量的学生在学校等待，这些志愿者赶快把这些等待的学生梳理出去，学生一直在学校等待，那其他需要学生的学校，也会等待学生，最后造成大面积的学校瘫痪。这里学生我们看成一个个请求。熔断器就是把某事故的蔓延即使熔断了。
    
 
    当然这些组件也是微服务需要注册到Eureka注册中心
    
 
    那SpringCloud就可以看成是这个学校了。众多上面提到的组件相当于都是这个学校的各职能部门。
    
 
    二、微服务的搭建
    
 
    ps:  博主基于Maven+idea搭建。
    
 
    另外SpringCloud需要基于springboot搭建。
    
 
    引入Spring Boot相关依赖：这里的springboot用的是1.5.7版本；引入Spring Cloud相关依赖：这里为 Edgware.SR5
    
 
    2.1 工程初始化配置
    
 
    在Idea中创建工程：File -> New ->Project
    
 
    
 
    点击   Empty Project -> Next
    
 
    
 
    项目命名 -> 项目位置
    
 
    
 
    选择模组 modules ->next
    
 
    
 
    进入新的窗口后，开始配置Maven，打开设置 setting
    
 
    
 
    
 
    因为我之前做过配置，因此只需要改变框1的路径，如第一次配置需要自己找到你maven放置的位置，以及settings.xml，repository的位置，实在不会的百度  maven集成idea
    
 
    
 
    3个框选择完毕后点击 ok
    
 
    接下来新建module
    
 
    
 
    这里可能会出现加载不出archetype list的问题
    
 
    
 
    用了网上的所有解决办法花了3个小时解决都没用，重启之后竟然可以了····你敢信？？？？？小时候网吧网管的至理名言都忘了！！重启一下嘛！！
    
 
    出来之后 选择quickstart ->下一步
    
 
    
 
    名字自己想 想好后，复制一下你想好的  ArtifactId点击Next，groupId为组织名 也是自己想一个，一般为公司网址反写。另外搜索公众号互联网架构师后台回复“2T”，获取一份惊喜礼包。
    
 
    
 
    粘贴后下一步
    
 
    
 
    提供注册服务的服务器pom.xml配置如下：
    
 
    <?xml version="1.0" encoding="UTF-8"?>
 
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
 
  <groupId>com.yun</groupId>
  <artifactId>springcloud-eureka-server</artifactId>
  <version>1.0-SNAPSHOT</version>
 
  <name>springcloud-eureka-server</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>
 
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>
 
  <!--引入springboot-parent父项目-->
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.7.RELEASE</version>
  </parent>
 
  <dependencies>
    <!--引入springcloud的euekea server依赖-->
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
    </dependency>
 
  </dependencies>
 
 
  <!--指定下载源和使用springcloud的版本-->
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-dependencies</artifactId>
        <version>Edgware.SR5</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>
</project>
    
 
    点击Import Changes
    
 
    
 
    等待右下角加载springcloud的依赖
    
 
    
 
    2.2 Springboot的搭建 以及提供注册服务 的 服务配置
    
 
    创建resources文件夹
    
 
    
 
    并设置作为资源根目录，之后文件变成这样之后文件夹变成有黄色的横杠
    
 
    
 
    在resources下新建文件，文件名为application.yml    （对是yml  不是xml ，博主第一次学习时，还以为是其他博主打错了，踩了一个小坑）
    
 
    
 
    配置yml，注意：如果只配置前两行端口号信息会报错
    
 
    
 
    server:
  port: 8700 # 端口自己决定
  
# 指定当前eureka客户端的注册地址，也就是eureka服务的提供方，当前配置的服务的注册服务方
eureka:
  client:
    service-url:
      defaultZone: http://$eureka.instance.hostname:$server.port/eureka
    register-with-eureka: false #自身 不在向eureka注册
    fetch-registry: false  #启动时禁用client的注册
  instance:
    hostname: localhost
 
#指定应用名称
spring:
  application:
    name: eureka-server
    
 
    知识补充：
    
 
    
 
    开发springboot的入口类 EurekaServerApplication.java
    
 
    
 
    EurekaServerApplication.java
    
 
    package com.yun;
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
 
@SpringBootApplication
@EnableEurekaServer //当前使用eureka的server
public class EurekaServerApplication 
    public static void main(String[] args) 
        SpringApplication.run(EurekaServerApplication.class,args);
    

    
 
    右键运行当前类：
    
 
    
 
    运行成功console画面
    
 
    
 
    尝试进入eureka管理界面 端口号为 yml里配置的（端口号自己设置 需要大于公用和保留的端口号）1024~65535
    
 
    一般我喜欢设置为 8700到8800之间
    
 
    如下  管理界面已经可以登录了。
    
 
    
 
    2.3 客户端client  提供真正服务的角色的配置， 它提供服务 在 服务注册方server （注册中心）进行注册
    
 
    同样新建module，选择quickstart点击下一步
    
 
    
 
    两个位置 置空
    
 
    
 
    取名 下一步
    
 
    
 
    注意这里要在根目录springcloud 下创建模组，content root 会默认在之前的模组之下创建模组 这样创建模组会出现问题并报错
    
 
 
    推荐这种配置方法  在content root下springcloud后改名字   如下图配置点下一步，红框处一般默认为上一个模组的文件目录名，需要改为你的模组名
    
 
    
 
    成功后为并列状态，如不为并列或报错请重新配置
    
 
    
 
    配置servicesupport的pom，与server的pom配置相同，只需要把第一个pom的1的方框处server改为client
    
 
    和第一个微服务同理 我们需要配置入口类 pom.xml  application.yml，因为是服务提供者，这里还需编写服务类controller
    
 
    application.yml
    
 
    server:
  port: 8701 # 服务提供方
 
# 指定当前eureka客户端的注册地址,
eureka:
  client:
    service-url:
      defaultZone: http://$eureka.instance.hostname:8700/eureka
  instance:
    hostname: localhost
 
#当前服务名称
spring:
  application:
    name: eureka-service
    
 
    pom.xml:
    
 
    
 
    编写所提供的 服务controller：
    
 
    package com.yun;
 
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
@RequestMapping("/Hello")
public class Controller 
    @RequestMapping("/World")
    public String helloWorld(String s)
        System.out.println("传入的值为："+s);
        return "传入的值为："+s;
    

    
 
    入口类 并运行此微服务：
    
 
    package com.yun;
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
 
@SpringBootApplication
@EnableDiscoveryClient//代表自己是一个服务提供方
public class EurekaServiceApplication 
    public static void main(String[] args) 
        SpringApplication.run(EurekaServiceApplication.class,args);
    

    
 
    右键入口类名点击 run（当然开启此服务时需要先开启server服务 就是我们第一个编写的微服务）
    
 
    
 
    此时再进入服务注册的页面 http://localhost:8700/
    
 
    可以看见服务提供者已被注册进 服务注册者
    
 
    
 
    在直接访问一下服务提供者的 网络位置http://localhost:8701/Hello/World?s=小沛
    
 
    我们已经看见 可以访问了，证明此微服务可用。
    
 
    
 
    但是我们一般不直接调用所需的微服务，而是经过提供注册服务的服务器server，获取所需的服务提供者列表（为一个列表，此列表包含了能提供相应服务的服务器），他们也许是个集群，因此server会返回一个 ip+端口号的表，服务消费者通过相应算法访问这表上的不同服务器，这些服务器提供的是相同的服务，这种在服务消费者一方挑选服务器为自己服务的方式是一种客户端的负载均衡。
    
 
    目前博主所知的有 轮询和随机两种方式 访问这些服务器，轮询就是循环的意思，假如有3台服务器，访问方式就是1,2,3,1,2,3,1,2,3····，随机就是随机，回想一下random方法，一种无规律的方式。这两种方式都是为了，访问每个服务器的可能性尽量的相同。还有权重负载这种算法，意思就是 根据服务器负载能力的分配相应的服务。能力大的干得多。能力小的干得少。
    
 
    2.4 服务的调用方式
    
 
    
  
    第一种调用方式：restTemplate+ribbon
    
 
    
 
    
 
    
  
    第二种调用方式：feign
    
 
    
 
    
 
    2.4.1 restTemplate+ribbon
    
 
    ribbon是一种负载均衡的客户端，它是什么呢？请详读https://www.jianshu.com/p/1bd66db5dc46
    
 
    可以看见其中的一段如下：
    
 
    
  
    而客户端负载均衡和服务端负载均衡最大的不同点在于上面所提到服务清单所存储的位置。在客户端负载均衡中，所有客户端节点都维护着自己要访问的服务端清单，而这些服务端端清单来自于服务注册中心，比如上一章我们介绍的Eureka服务端。同服务端负载均衡的架构类似，在客户端负载均衡中也需要心跳去维护服务端清单的健康性，默认会创建针对各个服务治理框架的Ribbon自动化整合配置，比如Eureka中的org.springframework.cloud.netflix.ribbon.eureka.RibbonEurekaAutoConfiguration，Consul中的org.springframework.cloud.consul.discovery.RibbonConsulAutoConfiguration。在实际使用的时候，我们可以通过查看这两个类的实现，以找到它们的配置详情来帮助我们更好地使用它。
    
 
    
 
    接下来我们来搭建基于ribbon的客户端，他用于消费服务。
    
 
    同理先搭建springboot的环境
    
 
    与之前搭建servicesupport不同的是：
    
 
    第一步：现在pom中需要在dependencies中添加ribbon依赖
    
 
    <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-ribbon</artifactId>
        </dependency>
    
 
    第二步：yml如下配置：
    
 
    server:
  port: 8702 # 服务消费方
 
# 指定当前eureka客户端的注册地址,
eureka:
  client:
    service-url:
      defaultZone: http://$eureka.instance.hostname:8700/eureka
  instance:
    hostname: localhost
 
#当前服务名称
spring:
  application:
    name: eureka-consumer
    
 
    服务的消费方依旧需要在注册方8700端口去注册。配置当前服务消费方的端口8072，名字为eureka-consumer。另外搜索公众号互联网架构师后台回复“2T”，获取一份惊喜礼包。
    
 
    第三步：依旧需要启动类，因为它是一个springboot的架构：
    
 
    package com.yun;
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
 
 
@SpringBootApplication
@EnableDiscoveryClient //当前使用eureka的server
public class EurekaConsumerApplication 
    public static void main(String[] args) 
        SpringApplication.run(EurekaConsumerApplication.class,args);
    

    
 
    
 
    如上图：
    
 
    我们需要一个controller类来编写ribbon的代码。
    
 
    package com.yun.controller;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
 
@RestController
@RequestMapping("/Hello")
class ConsumerController 
    @Autowired
    private LoadBalancerClient loadBalancerClient;
    @Autowired
    private RestTemplate restTemplate;
    @RequestMapping("/Consumer")
    public String helloWorld(String s)
        System.out.println("传入的值为："+s);
        //第一种调用方式
        //String forObject = new RestTemplate().getForObject("http://localhost:8071/Hello/World?s=" + s, String.class);
 
        //第二种调用方式
        //根据服务名 获取服务列表 根据算法选取某个服务 并访问某个服务的网络位置。
        //ServiceInstance serviceInstance = loadBalancerClient.choose("EUREKA-SERVICE");
        //String forObject = new RestTemplate().getForObject("http://"+serviceInstance.getHost()+":"+serviceInstance.getPort()+"/Hello/World?s="+s,String.class);
 
        //第三种调用方式 需要restTemplate注入的方式
        String forObject = restTemplate.getForObject("http://EUREKA-SERVICE/Hello/World?s=" + s, String.class);
        return forObject;
    

    
 
    我们常用第三种调用方式。
    
 
    第一种是直接调用：不经过注册中心那服务列表，直接访问的servicesupport
    
 
    第二种：是根据服务名选择调用，如上图需要做如下注入
    
 
    
  
    @Autowired
        private LoadBalancerClient loadBalancerClient;
    
 
    
 
    如上图代码中第二种调用方法的代码所示。
    
 
    用服务名去注册中心获取服务列表，当前客户端底层会做随机算法的选取获得服务并访问。
    
 
    第三种需要一个@Bean的注解自动注入并直接调用restTemplate对象调用服务。底层调用模式与第二种调用方式一样。如下：
    
 
    package com.yun.beans;
 
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 Beans 
    //管理简单对象
    @Bean
    @LoadBalanced
    public RestTemplate getRestTemplate()
        return new RestTemplate();
    

    
 
    @Bean注解告诉工厂，这个方法需要自动注入。
    
 
    @LoadBalanced，表示需要做负载匀衡。
    
 
    然后如controller中一样注入一下restTemplate，并且使用他，区别是可以直接使用服务名访问了
    
 
    
  
    String forObject = restTemplate.getForObject("http://EUREKA-SERVICE/Hello/World?s=" + s, String.class);
    
 
    
 
    开始测试：
    
 
    1.运行server的启动类：
    
 
    2.运行servicesupport的启动类：
    
 
    3.运行serviceconsume的启动类：
    
 
    浏览器访问：
    
 
    
 
    8072为服务消费方的端口
    
 
    访问方法解析：
    
 
    • 访问服务消费方@RequestMapping指定的路径及消费方的端口来访问消费方的controller
    • controller根据服务名去server方获取获取服务列表，获取服务列表后根据随机的模式负载匀衡后去选择服务地址去访问servicesupport：如下图
    
 
    
 
    ----------    更新于星期日2018年12月30日 20：02    待续....---------
    
 
    待续...
    
 
    2.5   Eureka server的高可用配置
    
 
    点击下图配置
    
 
    
 
    
 
    接下来配置三台01,02,03的虚拟机参数
    
 
    01:8699
    
 
    
 
    02:8698
    
 
    
 
    03:8697
    
 
    
 
    之后点ok保存，可看见多出三个启动项
    
 
    
 
    接下来分别改注册端口号，defaultZone分别启动三个启动项
    
 
    打开server的yml配置，删掉前两行端口号配置（图中有错，请把instance 和hostname那两行删掉）
    
 
    
 
    配置好yml后点击启动
    
 
    
 
    同理，我们再次改动端口号为8699和8697后，把启动项改为02，之后启动（图中有错，请把instance 和hostname那两行删掉）
    
 
    
 
    同理把yml端口改为8699 和 8698后，把启动项改为03，之后启动（图中有错，请把instance 和hostname那两行删掉）
    
 
    
 
    启动后分别访问三个01，02，03端口，已经可以看见可以访问了。
    
 
    
 ‍
 ‍
 
 ‍
 ‍
 

    
 
    打开服务提供方的yml配置如下，把端口号改为三个中其中的一个。
    
 
    
 
    启动服务提供方之后，再次访问三个01，02，03我们会发现
    
 
    重点：即使服务提供方只注册了一个端口号8699，但是另外两个端口号，也能感知到服务提供方8701的存在了。如下图：
    
 
    
 
    
 
    
 
    接下来像服务消费方中添加服务注册者的端口号，这样在server挂掉任何一个的时候，都能有其他的server也能获取服务列表
    
 
    
 
    访问以下服务消费方，发现可以通过消费方调用server服务列表并且访问service了
    
 
    
 
    我么随便关闭其中两个server的副本，重启serviceconsume，再进行访问。必须重启serviceconsume才能清空缓存，清掉consume里面有的服务列表。
    
 
    
 
    上图发现即使关闭两台server后依旧可以访问，如下图，依旧从server中获取了服务列表，从中也能看见之后不用再获取服务列表了。
    
 
    
 
    但是当我们关掉所有server后。访问还是没问题，因为缓存了服务列表。
    
 
 
    但是让我们来重启一下serviceconsume，再访问就不行了。
    
 
    
 
    综上我们就完成了springcloud中server的高可用配置
    
 
    搭好了别忘点赞呀~
    
 
    相关阅读：2T架构师学习资料干货分享
    
 
    PS：如果觉得我的分享不错，欢迎大家随手点赞、转发、在看。
    以上是关于从零开始搭建公司微服务授权架构技术栈（3种模式），这架构稳的一批...的主要内容，如果未能解决你的问题，请参考以下文章
     

     从零开始搭建公司后台技术栈，这套架构绝了...
    

     从零开始搭建公司秒杀架构技术栈，绝了！细节都考虑到了！
    

     从零开始搭建公司后台技术栈
    

     从零开始学微服务06.微服务架构的建设思路
    

     从零开始学微服务06.微服务架构的建设思路
    

     从零开始学微服务07.微服务常用的开发框架