springcloud篇】三. Eureka入门

最新推荐文章于 2024-07-12 10:58:27 发布

杰KaMi

最新推荐文章于 2024-07-12 10:58:27 发布

阅读量1.2k

点赞数 2

分类专栏： springcloud 文章标签： spring cloud eureka

本文链接：https://blog.csdn.net/TheNew_One/article/details/104911596

版权

springcloud 专栏收录该内容

18 篇文章 2 订阅

订阅专栏

Eureka入门

篇幅较长，请配合目录观看
项目准备
1. Eureka简介
2. Eureka单机版搭建
3. Eureka的服务端改造
4.Eureka的消费端改造
5. Eureka搭建高可用(HA)
6. Eureka自我保护机制

中国加油，武汉加油！

篇幅较长，请配合目录观看

项目准备

本案例基于springcloud篇】二. springcloud初识

1. Eureka简介

SpringCloud封装了Netflix公司开发的Eureka模块来实现服务注册和发现
在这里插入图片描述

Eureka：就是服务注册中心（可以是一个集群），对外暴露自己的地址
提供者：启动后向Eureka注册自己信息（地址，提供什么服务）
消费者：向Eureka订阅服务，Eureka会将对应服务的所有提供者地址列表发送给消费者，并且定期更新
心跳(续约)：提供者定期通过http方式向Eureka刷新自己的状态

2. Eureka单机版搭建

2.1 新建eureka-server-7001项目（Module-Maven）

在这里插入图片描述

2.2 站点工程导入springcloud的同一版本

<properties>
    <java.version>1.8</java.version>
    <!--spring-cloud版本 但是如果第一次使用的，Maven会下载一下-->
    <spring-cloud.version>Greenwich.SR1</spring-cloud.version>
</properties>

eureka-server-7001导入相关依赖

<dependencies>
   <!--eureka-server-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>

</dependencies>

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

2.3 编写eureka-server-7001程序入口

package com.wpj;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer //声明这个应用是一个EurekaServer
public class EurekaServer7001Application {
    public static void main(String[] args) {
         SpringApplication.run(EurekaServer7001Application.class,args);
    }
}

2.4 新建application.properties

# 配置端口
server.port=7001
# 配置程序应用名
spring.application.name=eureka-server-7001
# 配置eureka
eureka.instance.hostname=localhost
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false
eureka.client.service-url.defaultZone=http://${eureka.instance.hostname}:${server.port}/eureka

2.5 启动程序入口访问eureka的可视化界面

在这里插入图片描述

3. Eureka的服务端改造

3.1 springcloud-producer添加springcloud注解

<!-- Eureka客户端 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

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

3.2 springcloud-producer修改程序入口

package com.wpj;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

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

3.3 springcloud-producer添加application.properties配置

# 服务的名字，注册到注册中心的名字，后期消费者来根据名字调用服务 可以重复
spring.application.name=springcloud-producer
# EurekaServer地址
eureka.client.service-url.defaultZone=http://127.0.0.1:7001/eureka
# 当调用getHostname获取实例的hostname时，返回ip而不是host名称
eureka.instance.prefer-ip-address=true
# 指定自己的ip信息，不指定的话会自己寻找
eureka.instance.ip-address=127.0.0.1
# 执行当前服务的应用ID  不可以重复  标识的是每一个具体的的服务
eureka.instance.instance-id=springcloud-producer-8181

3.4 启动eureka-server-7001和springcloud-producer的程序入口并访问eureka

在这里插入图片描述

4.Eureka的消费端改造

4.1 springcloud-consumer添加springcloud注解

<!-- Eureka客户端 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

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

4.2 springcloud-consumer修改程序入口

package com.wpj;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

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

4.3 springcloud-consumer添加application.properties配置

spring.application.name=springcloud-consumer
# EurekaServer地址
eureka.client.service-url.defaultZone=http://127.0.0.1:7001/eureka
# 当调用getHostname获取实例的hostname时，返回ip而不是host名称
eureka.instance.prefer-ip-address=true
# 指定自己的ip信息，不指定的话会自己寻找
eureka.instance.ip-address=127.0.0.1
# 执行当前服务的应用ID  不可以重复  标识的是每一个具体的的服务
eureka.instance.instance-id=springcloud-consumer-8282

4.4 重启程序入口访问eureka

在这里插入图片描述

4.5 修改springcloud-consumer的Controller

package com.wpj.controller;

import com.wpj.bean.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.context.annotation.Scope;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.util.List;

@RestController
@Scope("prototype")
public class UserController {

    //后期会对这个程序进行优化
    @Resource
    private RestTemplate restTemplate;

    @Autowired
    private DiscoveryClient client;

    @RequestMapping("/list")
    public List<User> list(){
        //远程服务的调用地址  Conssumer地址
        List<String> services = client.getServices();
        System.out.println("注册中心上服务列表有:"+services);
        //前方高能
        List<ServiceInstance> instances = client.getInstances("springcloud-producer");
        for(ServiceInstance element:instances){
            System.out.println(element.getServiceId()+"\t"+element.getHost()+"\t"+element.getPort()+"\t" +element.getUri());
        }
        ServiceInstance instance = instances.get(0);//下标也不会越界，因为就一个服务
        // 获取ip和端口信息
        String url = "http://"+instance.getHost() + ":" + instance.getPort()+"/list";
        //String url="http://127.0.0.1:8181/list";
        return this.restTemplate.getForObject(url,List.class);
    }

}

4.6 重启程序入口访问Controller

在这里插入图片描述

5. Eureka搭建高可用(HA)

5.1 基于eureka-server-7001新建2个新module

5.1.1 导包

5.1.2 修改application.properties

5.1.3 编写程序入口

在这里插入图片描述

5.2 修改本地host文件C:\Windows\System32\drivers\etc\hosts

127.0.0.1 eureka.7001.com
127.0.0.1 eureka.7002.com
127.0.0.1 eureka.7003.com
在这里插入图片描述

5.3 三个Eureka注册中心修改application.properties

5.3.1 eureka-server-7001

# 配置端口
server.port=7001
# 配置程序应用名
spring.application.name=eureka-server-7001
# 配置eureka
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false
eureka.instance.hostname=eureka-server-7001
eureka.client.service-url.defaultZone=http://eureka.7002.com:7002/eureka,http://eureka.7003.com:7003/eureka

53.2 eureka-server-7002

# 配置端口
server.port=7002
# 配置程序应用名
spring.application.name=eureka-server-7002
# 配置eureka
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false

eureka.instance.hostname=eureka-server-7002
eureka.client.service-url.defaultZone=http://eureka.7001.com:7001/eureka,http://eureka.7003.com:7003/eureka

5.6.3 eureka-server-7003

# 配置端口
server.port=7003
# 配置程序应用名
spring.application.name=eureka-server-7003
# 配置eureka
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false

eureka.instance.hostname=eureka-server-7003
eureka.client.service-url.defaultZone=http://eureka.7001.com:7001/eureka,http://eureka.7002.com:7002/eureka

5.4 启动三个Eureka的程序入口

在这里插入图片描述

5.5 修改springcloud-producer和springcloud-consumer的application.propereties

eureka.client.service-url.defaultZone=http://eureka.7001.com:7001/eureka,http://eureka.7002.com:7002/eureka,http://eureka.7003.com:7003/eureka

5.6 启动springcloud-producer和springcloud-consumer的程序入口

在这里插入图片描述

5.7 停掉EurekaServer7001（注意浏览器缓存）

在这里插入图片描述

6. Eureka自我保护机制

自我保护模式正是一种针对网络异常波动的安全保护措施，使用自我保护模式能使Eureka集群更加的健壮、稳定的运行。
默认情况下，Eureka Client会定时的向 Eureka Server端发送心跳包，默认是30s发送一次，目的是告诉 Eureka Server当前客户端实例还处于存活状态，如果Eureka server在一定时间内没有收到实例的心跳，便会把该实例从注册表中删除（默认是90秒）,但是，如果短时间内丢失大量的实例心跳，便会触发Eureka server的自我保护机制的 ,默认自我保护机制处于开启状态，当一分钟内收到的心跳数大量减少时，会触发该保护机制。可以在eureka管理界面看到Renews threshold和Renews(last min)，当Renews(last min)（最后一分钟收到的心跳数）小于Renews threshold（心跳阈值）的时候，如果某个服务实例宕机掉，触发保护机制，会出现红色的警告

6.1 为什么要自我保护

当一个服务未按时进行心跳续约时，在生产环境下，因为网络延迟等原因，心跳失败实例的比例很有可能超标，但是此时就把服务剔除列表并不妥当，因为服务可能没有宕机。Eureka就会把当前实例的注册信息保护起来，不予剔除。生产环境下这很有效，保证了大多数服务依然可用。
为了防止在一定时间内，Eureka Client与Eureka Server在网络不同的情况下，Eureka Server误将Eureka Client服务剔除，这个机制是为了对服务进行保护。

6.2 开启和关闭Eureka保护机制的场景

6.2.1 开发环境关闭

当我们在使用微服务框架做项目开发的时候，如果注册中心是Eureka，因为会频繁的重启本地开发环境，调试和修改代码，但是不会频繁的重启Eureka Server，所以建议在测试环境、本地开发环境时关闭Eureka的自我保护机制，，如果触发了保护机制，则旧的服务实例没有被删除，这时请求有可能跑到旧的实例中，而该实例已经关闭了，这就导致请求错误，影响开发测试效率；

6.2.2 生产环境开启

Linux—>Docker容器化部署—>K8S
在微服务各个节点部署到生产环境了之后，建议开启Eureka自我保护环境，这一点还是比较重要的，因为在生产环境，并不会频繁的重启，而且有时在短时间内可能会发生服务与服务之间网络故障、重启Eureka Client客户端服务实例等其他原因导致通讯中断，所以一定要把自我保护机制打开，否则网络一旦终端，就无法恢复，导致误删除服务节点，造成生产故障；

6.2 如何关闭Eureka自我保护机制

Eureka自我保护机制默认是开启的，如果如果需要关闭自我保护机制，按照下述方式： enable-self-preservation: false 开关关闭掉，然后修改客户端和服务端相关参数，保证异常服务能及时剔除；

# 关闭eureka的自我保护机制
eureka.server.enable-self-preservation=false

6.3 Eureka配置

6.3.1 服务端配置

# 关闭eureka的自我保护机制
eureka.server.enable-self-preservation=false 
# 配置Eureka Server清理无效节点的时间间隔（单位毫秒，默认60*1000毫秒,即60秒）
eureka.server.eviction-interval-timer-in-ms=60000

6.3.2 客户端配置

# eureka服务端在接受到实例的最后一次发出的心跳后，需要等待多久才可以将此删除，单位为秒（默认为90s），超过时间则剔除（客户端会按照此规则向Eureka服务端发送心跳检测包）
eureka.instance.lease-renewal-interval-in-seconds=90
# eureka客户端需要多长时间发送心跳给eureka服务端，单位为秒（默认为30s）,（客户端会按照此规则向Eureka服务端发送心跳检测包）
eureka.instance.lease-expiration-duration-in-seconds=30

6.3.2.1 消费端

# 表示eureka client间隔多久去拉取服务器注册信息,默认为30秒
eureka.client.registry-fetch-interval-seconds=30

6.4 Eureka优雅停服

由于eureka的自我保护机制，直接对服务进行停止会使得eureka serve进入自我保护模式。服务并不会从列表中删除。
首先将服务开启自我保护，然后让对应的服务具有优雅停服的功能，比如provider服务

需要再服务中添加 actuator.jar 包

<!--监控依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

application.properties

# 暴漏shutdown端点服务
management.endpoints.web.exposure.include=shutdown
management.endpoint.shutdown.enabled=true

6.4.1 使用postman

http://127.0.0.1:8181/actuator/shutdown

6.4.2 导包

<dependency>
   <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.8</version>
</dependency>

6.4.1 添加工具类

package com.wpj;

import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.net.URI;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * @program: springcloud-eureka-consumer
 * @description: httpClient工具类
 */
public class HttpClientUtil {
    public static String doGet(String url, Map<String, String> param) {

        // 创建Httpclient对象
        CloseableHttpClient httpclient = HttpClients.createDefault();

        String resultString = "";
        CloseableHttpResponse response = null;
        try {
            // 创建uri
            URIBuilder builder = new URIBuilder(url);
            if (param != null) {
                for (String key : param.keySet()) {
                    builder.addParameter(key, param.get(key));
                }
            }
            URI uri = builder.build();

            // 创建http GET请求
            HttpGet httpGet = new HttpGet(uri);

            // 执行请求
            response = httpclient.execute(httpGet);
            // 判断返回状态是否为200
            if (response.getStatusLine().getStatusCode() == 200) {
                resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
                httpclient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return resultString;
    }

    public static String doGet(String url) {
        return doGet(url, null);
    }

    public static String doPost(String url, Map<String, String> param) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            // 创建参数列表
            if (param != null) {
                List<NameValuePair> paramList = new ArrayList<>();
                for (String key : param.keySet()) {
                    paramList.add(new BasicNameValuePair(key, param.get(key)));
                }
                // 模拟表单
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList, "utf-8");
                httpPost.setEntity(entity);
            }
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        return resultString;
    }

    public static String doPost(String url) {
        return doPost(url, null);
    }

    public static String doPostJson(String url, String json) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            // 创建请求内容
            StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
            httpPost.setEntity(entity);
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        return resultString;
    }

    public static void main(String[] args) {
        String url = "http://127.0.0.1:8181/actuator/shutdown";
        //该url必须要使用dopost方式来发送
        HttpClientUtil.doPost(url);
    }
}