SpringCloud（二）Eureka服务注册与发现

最新推荐文章于 2023-01-27 20:36:35 发布
最新推荐文章于 2023-01-27 20:36:35 发布
阅读量368 收藏 1
点赞数
分类专栏： SpringCloud 文章标签： spring cloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/agululu/article/details/125668806
版权

（学习记录）

一、概述

1.什么是服务治理？

Spring Cloud 封装了 Netflix 公司开发的 Eureka 模块来实现服务治理。

在传统的rpc远程调用框架中，管理每个服务与服务之间依赖关系比较复杂，管理比较复杂，所以需要使用服务治理，管理服务于服务之间依赖关系，可以实现服务调用、负载均衡、容错等，实现服务发现与注册。

2.服务注册和发现

Eureka采用了CS的设计架构，Eureka Server 作为服务注册功能的服务器，它是服务注册中心。

而系统中的其他微服务，使用 Eureka的客户端连接到 Eureka Server并维持心跳连接。这样系统的维护人员就可以通过 Eureka Server 来监控系统中各个微服务是否正常运行。

注册：在服务注册与发现中，有一个注册中心（Eureka Server）。当服务器启动的时候，会把当前自己服务器的信息 比如 服务地址通讯地址等以别名方式注册到注册中心上。

发现：（消费者|服务提供者），以该别名的方式去注册中心上获取到实际的服务通讯地址，然后再实现本地RPC调用RPC远程调用框架核心设计思想：在于注册中心，因为使用注册中心管理每个服务与服务之间的一个依赖关系(服务治理概念)。在任何rpc远程框架中，都会有一个注册中心(存放服务地址相关信息(接口地址))

3.与Dubbo对比图

 4.两大组件

Eureka有两大组件：Eureka Sever和Eureka Client

Eureka Server提供服务注册服务

各个微服务节点通过配置启动后，会在Eureka Server中进行注册，这样Eureka Server中的服务注册表中将会存储所有可用服务节点的信息，服务节点的信息可以在界面中直观看到。

Eureka Client通过注册中心进行访问 

是一个Java客户端，用于简化Eureka Server的交互，客户端同时也具备一个内置的、使用轮询(round-robin)负载算法的负载均衡器。在应用启动后，将会向Eureka Server发送心跳(默认周期为30秒)。如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，Eureka Server将会从服务注册表中把这个服务节点移除（默认90秒）

    可以得出，在Eureka注册中心上面的服务节点，一旦由于某些原因失效，不会被马上删除。保证了CAP（一致性、可用性、容错性）原则的AP

 二、单体Eureka搭建

1.在之前的父工程下面，建立一个子工程module

工程名：cloud-eureka-server7001

此时7001是Eureka的服务端，注册中心

 1.1.配置pom.xml文件

<dependencies>
        <!--eureka-server-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
        <!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
        <dependency>
            <groupId>com.atguigu.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${project.version}</version>
        </dependency>
        <!--boot web actuator-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--一般通用配置-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
    </dependencies>

</project>

 1.2.配置application.yml

server:
  port: 7001

eureka:
  instance:
    hostname: localhost #eureka服务端的实例名称
  client:
    #false表示不向注册中心注册自己。
    register-with-eureka: false
    #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
    fetch-registry: false
    service-url:
    #设置与Eureka Server交互的地址查询服务和注册服务都需要依赖这个地址。
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

1.3.主启动类 

@SpringBootApplication
@EnableEurekaServer //开启Eureka服务
public class EurekaMain7001
{
    public static void main(String[] args)
    {
        SpringApplication.run(EurekaMain7001.class,args);
    }
}

1.4.测试

1.启动7001服务

2.http://localhost:7001/

 

 2.建立另一个子工程module提供者8001

工程名：cloud-provider-payment8001

服务的提供者：服务提供方将自身服务注册到Eureka，从而使服务消费方能够找到。作为Eureka Client存在

 2.1.配置pom.xml文件

<dependencies>
        <!--eureka-client-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency><!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
            <groupId>com.atguigu.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${project.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <!--mysql-connector-java-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--jdbc-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

2.2.application.yml

EurekaClient端yml设置

server:
  port: 8001

spring:
  application:
    name: cloud-payment-service
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型
    driver-class-name: org.gjt.mm.mysql.Driver              # mysql驱动包
    url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: 123456

eureka:
  client:
    #表示是否将自己注册进EurekaServer默认为true。
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
    fetchRegistry: true
    service-url:
      defaultZone: http://localhost:7001/eureka


mybatis:
  mapperLocations: classpath:mapper/*.xml
  type-aliases-package: com.atguigu.springcloud.entities    # 所有Entity别名类所在包

2.3.主启动

@SpringBootApplication
@EnableEurekaClient//开启Eureka的客户端服务，该服务启动，将会自动注册到注册中心
public class PaymentMain8001
{
    public static void main(String[] args)
    {
        SpringApplication.run(PaymentMain8001.class,args);
    }
}

2.4.测试 

1.先要启动EurekaServer-7001

2.再启动该服务8001

3.访问 http://localhost:7001/

     爆红部分是Eureka的自我保护机制触发。 

 2.5消费者order80同上，注意端口号不一样

通过访问80端口，从注册中心找到对应的服务，然后找到8001，返回结果。

  三、集群Eureka搭建

1.Eureka集群原理说明

微服务RPC远程服务调用最核心的是高可用，试想你的注册中心只有一个only one， 它出故障了那就呵呵(￣▽￣)"了，会导致整个为服务环境不可用。

所以搭建Eureka注册中心集群 ，实现负载均衡+故障容错
 

 

2.集群搭建 

参考7001新建module7002，工程名：cloud-eureka-server7002

 2.1配置pom.xml文件

<dependencies>
        <!--eureka-server-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
        <!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
        <dependency>
            <groupId>com.atguigu.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${project.version}</version>
        </dependency>
        <!--boot web actuator-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--一般通用配置-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
    </dependencies>

</project>

2.2在该yml之前做一下域名映射

找到C:\Windows\System32\drivers\etc路径下的hosts文件

修改映射配置添加进hosts文件：

                                      127.0.0.1  eureka7001.com

                                      127.0.0.1  eureka7002.com

2.3配置application.yml

修改7001yml

server:
  port: 7001


eureka:
  instance:
    hostname: eureka7001.com #eureka服务端的实例名称
  client:
    register-with-eureka: false     #false表示不向注册中心注册自己。
    fetch-registry: false     #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
    service-url:
      defaultZone: http://eureka7002.com:7002/eureka/

修改7002yml 

server:
  port: 7002


eureka:
  instance:
    hostname: eureka7002.com #eureka服务端的实例名称
  client:
    register-with-eureka: false     #false表示不向注册中心注册自己。
    fetch-registry: false     #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/

 二者相互注册相互守望：

个人问题：为什么defaultZone路径那里不写自己，要写对方，在单体的时候为什么又要写自己？

defaultZone其实就是Eureka客户端向服务端进行注册、访问的路径，之前陷入误区。端口为7001上面写着的是http7002；端口7002上挂着http7001。然后消费者|提供者的配置是http7002。以为当端口7001挂掉，消费者|提供者就访问不了，无法注册进入注册中心，其实不是。试验后还是可以注入进去，表名消费者和提供者是根据defaultZone找的，但是端口7002没有挂掉，当然可以注册进去。

总而言之：当端口7001挂掉，消费者和提供者可以注册进入端口7002，并且但是端口7002并没有注册进端口7001.相当于Server7001和Sever7002互相作为Client相互注册

 2.4主启动

@SpringBootApplication
@EnableEurekaServer //开启EurekaServer端
public class EurekaMain7002
{
    public static void main(String[] args)
    {
        SpringApplication.run(EurekaMain7002.class,args);
    }
}

 2.5测试

1.先要启动EurekaServer，7001/7002服务

2.再要启动服务提供者provider，8001

3.再要启动消费者，80

4.访问：http://eureka.com:7001/ 或者 http://eureka.com:7002/，出现两个服务都被注册进来表示成功

3.服务提供者8001的集群搭建

工程名：cloud-provider-payment8002

 3.1pom.xml文件和8001一样

3.2application.yml

server:
  port: 8002

spring:
  application:
    name: cloud-payment-service
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型
    driver-class-name: org.gjt.mm.mysql.Driver              # mysql驱动包
    url: jdbc:mysql://localhost:3306/db2019?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: 123456

eureka:
  client:
    #表示是否将自己注册进EurekaServer默认为true。
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
    fetchRegistry: true
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka  # 集群版
      #defaultZone: http://localhost:7001/eureka  # 单机版


mybatis:
  mapperLocations: classpath:mapper/*.xml
  type-aliases-package: com.atguigu.springcloud.entities    # 所有Entity别名类所在包

3.3主启动 

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

3.3修改8001/8002的Controller 

@RestController
@Slf4j
public class PaymentController
{
    @Value("${server.port}")
    private String serverPort;

    @Resource
    private PaymentService paymentService;

    @PostMapping(value = "/payment/create")
    public CommonResult create(@RequestBody Payment payment)
    {
        int result = paymentService.create(payment);
        log.info("*****插入操作返回结果:" + result);

        if(result > 0)
        {
            return new CommonResult(200,"插入成功,返回结果"+result+"\t 服务端口："+serverPort,payment);
        }else{
            return new CommonResult(444,"插入失败",null);
        }
    }

    @GetMapping(value = "/payment/get/{id}")
    public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id)
    {
        Payment payment = paymentService.getPaymentById(id);
        log.info("*****查询结果:{}",payment);
        if (payment != null) {
            return new CommonResult(200,"查询成功"+"\t 服务端口："+serverPort,payment);
        }else{
            return new CommonResult(444,"没有对应记录,查询ID: "+id,null);
        }
    }
}

3.4 修改80的Controller类和ApplicationContextConfig配置类

订单服务访问地址不能写死，因为此时的负载均衡没有做配置，提供者做了集群，消费者通过找服务名的方式，找到该服务下面的实例。

使用@LoadBalanced注解赋予RestTemplate负载均衡的能力，路径修改为服务名

@Configuration
public class ApplicationContextBean
{
    @Bean
    @LoadBalanced //使用@LoadBalanced注解赋予RestTemplate负载均衡的能力
    public RestTemplate getRestTemplate()
    {
        return new RestTemplate();
    }
}

3.5测试

1.先要启动EurekaServer，7001/7002服务 

2.再要启动服务提供者provider，8001/8002服务

3.访问：http://localhost/consumer/payment/get/id

4.结果：负载均衡效果达到，8001/8002端口交替出现

 四、服务发现Discovery

对于注册进eureka里面的微服务，可以通过服务发现来获得该服务的信息。

通过在主启动类上面加上：@EnableDiscoveryClient，开启

1.修改8001主启动类 

@SpringBootApplication
@EnableEurekaClient
@EnableDiscoveryClient //服务发现
public class PaymentMain8001
{
    public static void main(String[] args)
    {
        SpringApplication.run(PaymentMain8001.class,args);
    }
}

 2.修改Controller

@RestController
@Slf4j
public class PaymentController
{
    @Value("${server.port}")
    private String serverPort;

    @Resource
    private PaymentService paymentService;

    @Resource
    private DiscoveryClient discoveryClient;

    @PostMapping(value = "/payment/create")
    public CommonResult create(@RequestBody Payment payment)
    {
        int result = paymentService.create(payment);
        log.info("*****插入操作返回结果:" + result);

        if(result > 0)
        {
            return new CommonResult(200,"插入成功,返回结果"+result+"\t 服务端口："+serverPort,payment);
        }else{
            return new CommonResult(444,"插入失败",null);
        }
    }

    @GetMapping(value = "/payment/get/{id}")
    public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id)
    {
        Payment payment = paymentService.getPaymentById(id);
        log.info("*****查询结果:{}",payment);
        if (payment != null) {
            return new CommonResult(200,"查询成功"+"\t 服务端口："+serverPort,payment);
        }else{
            return new CommonResult(444,"没有对应记录,查询ID: "+id,null);
        }
    }

    @GetMapping(value = "/payment/discovery")
    public Object discovery()
    {
        List<String> services = discoveryClient.getServices();
        for (String element : services) {
            System.out.println(element);
        }

        List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");
        for (ServiceInstance element : instances) {
            System.out.println(element.getServiceId() + "\t" + element.getHost() + "\t" + element.getPort() + "\t"
                    + element.getUri());
        }
        return this.discoveryClient;
    }
}

3.测试 

1.先要启动EurekaServer

2.再启动8001主启动类，需要稍等一会儿

3.访问： http://localhost:8001/payment/discovery

4.结果：控制台打印出对应的信息

五、 Eureka自我保护

1.概述

保护模式主要用于一组客户端和Eureka Server之间存在网络分区场景下的保护。一旦进入保护模式.
Eureka Server将会尝试保护其服务注册表中的信息，不再删除服务注册表中的数据，也就是不会注销任何微服务。

看到以下，表名Eureka进入保护模式。

 

2.为什么会产生Eureka自我保护机制？

为了防止EurekaClient可以正常运行，但是 与 EurekaServer网络不通情况下，EurekaServer不会立刻将EurekaClient服务剔除

3. 什么是自我保护模式？

默认情况下，如果EurekaServer在一定时间内没有接收到某个微服务实例的心跳，EurekaServer将会注销该实例（默认90秒）。但是当网络分区故障发生(延时、卡顿、拥挤)时，微服务与EurekaServer之间无法正常通信，以上行为可能变得非常危险了——因为微服务本身其实是健康的，此时本不应该注销这个微服务。

Eureka通过“自我保护模式”来解决这个问题——当EurekaServer节点在短时间内丢失过多客户端时（可能发生了网络分区故障），那么这个节点就会进入自我保护模式。

在自我保护模式中，Eureka Server会保护服务注册表中的信息，不再注销任何服务实例。
它的设计哲学就是宁可保留错误的服务注册信息，也不盲目注销任何可能健康的服务实例。一句话讲解：好死不如赖活着

综上，自我保护模式是一种应对网络异常的安全保护措施。它的架构哲学是宁可同时保留所有微服务（健康的微服务和不健康的微服务都会保留）也不盲目注销任何健康的微服务。使用自我保护模式，可以让Eureka集群更加的健壮、稳定。

4.禁止自我保护

出厂默认，自我保护机制是开启的。

 关闭自我保护机制，保证不可用服务被及时踢除

server:
       enable-self-preservation: false

 Eureka客户端向服务端发送心跳的时间间隔，单位为秒(默认是30秒)

instance:
    lease-renewal-interval-in-seconds: 1

Eureka服务端在收到最后一次心跳后等待时间上限，单位为秒(默认是90秒)，超时将剔除服务

  instance:
    lease-expiration-duration-in-seconds: 2

 

agululu
关注
专栏目录
SpringCloud Eureka的服务注册与发现
Java_Pluto的博客
03-29 327
SpringCloud Eureka的服务注册与发现 一、Eureka简介 在传统应用中，组件之间的调用，通过有规范的约束的接口来实现，从而实现不同模块间良好的协作。但是被拆分成微服务后，每个微服务实例的网络地址都可能动态变化，数量也会变化，使得原来硬编码的地址失去了作用。需要一个中心化的组件来进行服务的登记和管理，为了解决上面的问题，于是出现了服务治理，就是管理所有的服务信息和状态，也就是我们所说的注册中心 1.1 注册中心 比如我们去做火车或者汽车，需要去买票乘车，只看我们有没有票（有没有服务），有就去
springcloud之eureka注册服务与发现
12-11
在Spring Cloud生态系统中，Eureka是核心组件之一，主要用于服务的注册与发现。Eureka的工作原理、使用方式以及源码分析对于理解微服务架构中的服务治理至关重要。下面将详细阐述Eureka的相关知识点。 1. **Eureka...
SpringCloud-Eureka服务注册与发现
爱笑的boy的博客
09-04 435
SpringCloud-Eureka服务注册与发现
SpringCloud中关于Eureka的了解--狂神说
weixin_44538225的博客
08-15 543
工具：idea Spring官网：https://spring.io/ 详细了解博客连接：https://blog.csdn.net/weixin_43591980/article/details/106255122 视频链接：https://www.bilibili.com/video/BV1jJ411S7xr 接着上一个博客写 1. 什么是Eureka Netflix在设计Eureka时，遵循的就是AP原则 Eureka是Netflix的一个子模块，也是核心模块之一。Eureka是一个基于REST的服
SpringCloud-Eureka(服务注册与发现)
MLn Blog
08-22 1322
Eureka是Netflix开发的服务发现框架，本身是一个基于REST的服务，主要用于定位运行在AWS域中的中间层服务，以达到负载均衡和中间层服务故障转移的目的。SpringCloud将它集成在其子项目spring-cloud-netflix中，以实现SpringCloud的服务发现功能。 一、Eureka简介及基本原理 Eureka包含两个组件：Eureka Server和Eureka Cli...
SpringCloud Eureka实现服务注册与发现
08-26
"SpringCloud Eureka实现服务注册与发现" Eureka是基于REST（具像状态传输）的服务，主要用于AWS云中定位服务，以实现中间层服务器的负载平衡和故障转移。Eureka Server是服务注册中心，负责管理服务实例的注册和...
01Spring Cloud Eureka：服务注册与发现1
08-04
在配置文件application.yml中添加Eureka注册中心的配置，然后使用IDEA的Run Dashboard来运行SpringCloud应用。 在微服务项目中，我们可以使用IDEA的Run Dashboard来启动多个服务，以便于管理。为了让服务注册到...
SpringCloud之服务注册与发现Spring Cloud Eureka实例代码
08-27
主要介绍了SpringCloud之服务注册与发现Spring Cloud Eureka实例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
SpringCloud基础概念与入门+SpringCloud核心组件Eureka服务注册与发现等全套教程
最新发布
08-04
SpringCloud核心组件Eureka服务注册与发现 SpringCloud核心组件Ribbon负载均衡 SpringCloud核心组件Feign声明式服务调用 SpringCloud核心组件Hystrix断路器与容错机制 SpringCloud核心组件ZuulAPI网关 SpringCloud...
spring cloud eureka服务注册与发现
09-24
spring cloud eureka服务与发现 ，后续还有spring cloud系列。
【SpringCloud06】SpringCloud Eureka 服务注册与发现
qq_45291280的博客
01-12 349
SpringCloud Eureka 服务注册与发现
Spring Cloud_Eureka服务注册与发现
Knight
01-27 569
Spring Cloud_Eureka服务注册与发现
SpringCloud之Eureka服务的注册与发现
Button的博客
12-14 1598
SpringCloud之Eureka服务的注册与发现
SpringCloud--Eureka服务的注册与发现
weixin_43700340的博客
04-15 440
一. Eureka基础知识 1.1 什么是服务治理 ● SpringCloud 封装了Netflix公司开发的Eureka 模块来实现服务治理【SpringCloud抄的Netflix作业】 ● 在传统的RPC远程调用框架中，管理每个服务与服务之间依赖关系比较复杂，所以服务之间依赖关系，可以实现服务调用，负载均衡，容错等，实现服务发现与注册 1.2 什么是服务注册与发现 Eureka采用了CS的设计架构，Eureka Server 作为服务注册功能的服务器，他是服务注册中心，而系统中的其他微服务，使用Eur
微服务 SpringCloud Eureka服务注册与发现
靖节先生的博客
01-26 795
微服务 springcloud Eureka服务注册与发现 一、概述 1、服务注册与发现 2、Eureka组成 3、Eureka依赖版本对比 4、访问效果 二、案例验证 application.yml配置 server: port: 80 spring: application: name: cloud-order-service eureka: client: #表示是否将自己注册进EurekaServer默认为true。 register-with-eur
【SpringCloud】——Eureka服务注册与发现
weixin_46146755的博客
03-12 1490
什么是服务治理？ Spring Cloud封装了Netflix公司开发的Euraka模块来实现服务治理 在传统的rpc远程调用框架中，管理每个服务与服务之间依赖关系比较复杂，管理比较复杂，所以需要使用服务治理，管理服务与服务之间依赖关系，可以实现服务调用、负载均衡、容错等，实现服务发现与注册 什么是服务注册与发现？ Eureka采用了CS的设计架构，Eureka Server作为服务注册功能的服务器，它是服务注册中心，而系统中的其他微服务，使用Euraka的客户端连接到Euraka Server并维持心跳.
springcloud笔记之eureka服务注册与发现
qq_41486775的博客
03-05 246
文章目录一、eureka是什么？二、使用步骤1.引入依赖2.编写配置文件3.开启主启动类总结 一、eureka是什么？ 官方解释: Eureka是Netflix开发的服务发现框架，本身是一个基于REST的服务，主要用于定位运行在AWS域中的中间层服务，以达到负载均衡和中间层服务故障转移的目的。SpringCloud将它集成在其子项目spring-cloud-netflix中，以实现SpringCloud的服务发现功能。 它的实现原理是这样的，eureka提供一个注册中心，这个注册中心就是用来注册服务的，服务
SpringCloud Eureka服务注册与发现实战教程
"SpringCloud之服务注册与发现Spring Cloud Eureka实例代码" 在微服务架构中，服务注册与发现是至关重要的组成部分，它使得服务能够互相找到并进行通信。Spring Cloud Eureka是Spring Cloud Netflix项目的一个子...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值