2. 程式人生 > >Spring Boot + Eureka 實現微服務負載均衡

Spring Boot + Eureka 實現微服務負載均衡

阿新 • • 發佈：2018-12-31

1，什麼是Eureka，什麼是服務註冊與發現


      Spring Boot作為目前最火爆的web框架。那麼它與Eureka又有什麼關聯呢？

  1. Eureka是Netflix開源的一個RESTful服務，主要用於服務的註冊發現。
  2. Eureka由兩個元件組成：Eureka伺服器和Eureka客戶端。Eureka伺服器用作服務註冊伺服器。
  3. Eureka客戶端是一個java客戶端，用來簡化與伺服器的互動、作為輪詢負載均衡器，並提供服務的故障切換支援。
  4. Netflix在其生產環境中使用的是另外的客戶端，它提供基於流量、資源利用率以及出錯狀態的加權負載均衡。

2，先建立一個Eureka-Server服務註冊中心
    

    這裡需要用到spring-cloud的Eureka模組，他是一個服務的註冊和發現模組

      如圖我們先new一個Spring-boot工程引入Eureka Server


        




Next>>>>Finish完成

我們來看看構建好的Eureka-Server的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.eureka</groupId>
    <artifactId>server</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

 
    <name>server</name>
    <description>Demo project for Spring Boot</description>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
</parent>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Finchley.RC2</spring-cloud.version>
    </properties>
    <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>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </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>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>
</project>

    我們看到這裡與普通的Spring-boot專案不同的是，這裡引用了一個Eureka-Server包。
    那麼我們怎麼使用它呢，怎麼啟動它呢？

    

    這裡只需要啟動一個註解就可以啦，我們在Spring-Boot工程的啟動類上加>>>>>>
    @EnableEurekaServer
    程式碼如下：
package com.eureka.server;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
/**
 * 啟動一個服務註冊中心
 */
@EnableEurekaServer
@SpringBootApplication
public class ServerApplication {

    public static void main(String[] args) {
        SpringApplication.run(ServerApplication.class, args);
}
}
差點忘了，我們還需要配置application.yml

Eureka是一個高可用的元件，每一個例項註冊之後需要向註冊中心傳送心跳包，在預設情況下erureka server也是一個eureka client ,必須要指定一個 server。

eureka server的配置檔案appication.yml：


server:
  port: 8081 #服務註冊中心埠號
eureka:
  instance:
    hostname: 127.0.0.1 #服務註冊中心IP地址
client:
    registerWithEureka: false #是否向服務註冊中心註冊自己
fetchRegistry: false #是否檢索服務
serviceUrl: #服務註冊中心的配置內容，指定服務註冊中心的位置
defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
我們來啟動一下吧



我們在瀏覽器上輸入http://127.0.0.1:8081/飛機直達

我們可以看到它的視覺化介面

細心的朋友會發現，這裡沒有發現服務？？？No instance available

why？  因為我們還沒有服務向註冊中心註冊服務，所以找不到啊。

3，先建立一個Eureka-Client客戶端也就是服務提供者

        客戶端在向註冊中心它會提供一些元資料，例如主機和埠，URL，主頁等。Eureka server 從    每        個client例項接收心跳訊息。 如果心跳超時，則通常將該例項從註冊server中刪除。       

    建立客戶端和服務端差不多，只是啟動註解有點不一樣，還有yml配置檔案

      





Next>>>Finish完成啦

開啟會發現pom.xml其實和Server註冊中心的類似


<?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.eureka</groupId>
    <artifactId>provider</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
    <name>provider</name>
    <description>Demo project for Spring Boot</description>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
</parent>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Finchley.RC2</spring-cloud.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <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>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>
</project>
怎麼證明它是Client呢
很簡單
在Spring-boot的啟動類上通過註解@EnableEurekaClient 表明自己是一個eurekaclient.


package com.eureka.provider;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.Map;
/**
 * Eureka客戶端
 */
@RestController
@EnableEurekaClient
@SpringBootApplication
public class ProviderApplication {

    public static void main(String[] args) {
        SpringApplication.run(ProviderApplication.class, args);
}


    /**
     * 假如這個客戶端要提供一個getUser的方法
     * @return
*/
@GetMapping(value = "/getUser")
    @ResponseBody
public Map<String,Object> getUser(@RequestParam Integer id){
        Map<String,Object> data = new HashMap<>();
data.put("id",id);
data.put("userName","admin");
data.put("from","provider-A");
        return data;
}

}

雖然加好了@EnableEurekaClient，總感覺差點什麼，對了，配置檔案yml

eureka:
  client:
    serviceUrl: #註冊中心的註冊地址
defaultZone: http://127.0.0.1:8081/eureka/
server:
  port: 8082  #服務埠號
spring:
  application:
    name: service-provider #服務名稱--呼叫的時候根據名稱來呼叫該服務的方法
我們來啟動看看吧


我們看到這個客戶端已經向註冊中心註冊服務了，那麼我們開啟Eureka-server飛機直達



我們看到我們啟動的服務是不是加進去了呢

我們看到我們的服務是不是加進去了呢。

那麼有人會問，那一大堆飆紅的什麼意思啊。因為註冊的服務都是高可用的，這裡只檢測到一個服務，產生的預警，不影響使用，等下我們啟動多個例項就不會了。

我們先來測試下客戶端的方法是否可用   飛機直達

顯然是沒有問題，那麼我們提供好了服務，sei來消費呢？

下面我們就來建立一個消費者

為了更簡單易懂，我還是一步一步出圖吧。



來，貼上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.eureka</groupId>
    <artifactId>consumer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
    <name>consumer</name>
    <description>Demo project for Spring Boot</description>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
</parent>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Finchley.RC2</spring-cloud.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <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>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>
</project>
主要是啟動類，裡面內容就豐富啦，都在註釋裡

package com.eureka.consumer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.annotation.Bean;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import java.util.HashMap;
import java.util.Map;
/**
 * Eureka客戶端-消費者
 */
@RestController
@EnableEurekaClient
@SpringBootApplication
public class ConsumerApplication {

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

    /**
     * 例項化RestTemplate
     * @return
*/
@LoadBalanced
    @Bean
public RestTemplate rest() {
        return new RestTemplate();
}

    /**
     * Rest服務端使用RestTemplate發起http請求,然後得到資料返回給前端----gotoUser是為了區分getUser怕小夥伴暈頭
     * @param id
* @return
*/
@GetMapping(value = "/gotoUser")
    @ResponseBody
public Map<String,Object> getUser(@RequestParam Integer id){
        Map<String,Object> data = new HashMap<>();
/**
         * 小夥伴發現沒有，地址居然是http://service-provider
         * 居然不是http://127.0.0.1:8082/
         * 因為他向註冊中心註冊了服務，服務名稱service-provider,我們訪問service-provider即可
         */
data = restTemplate.getForObject("http://service-provider/getUser?id="+id,Map.class);
        return data;
}


}

配置檔案和
eureka:
  client:
    serviceUrl: #註冊中心的註冊地址
defaultZone: http://127.0.0.1:8081/eureka/
server:
  port: 8083  #服務埠號
spring:
  application:
    name: service-consumer #服務名稱--呼叫的時候根據名稱來呼叫該服務的方法

我們啟動看看效果吧



看看我們的提供者和消費者是不是都進來了


那麼我們看看我們消費者的方法是否可用  飛機直達


哈哈，是不是很神奇

下面介紹個更神奇的東西--實現微服務負載均衡


我們把服務提供者複製一個工程出來，我們再做下小小的修改，看看是否能實現負載均衡。

我們需要修改兩個檔案

一個是啟動類，改了哪些呢？看看就曉得咯

package com.eureka.provider;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.Map;
/**
 * Eureka客戶端
 */
@RestController
@EnableEurekaClient
@SpringBootApplication
public class ProviderApplication {

    public static void main(String[] args) {
        SpringApplication.run(ProviderApplication.class, args);
}


    /**
     * 假如這個客戶端要提供一個getUser的方法
     * @return
*/
@GetMapping(value = "/getUser")
    @ResponseBody
public Map<String,Object> getUser(@RequestParam Integer id){
        Map<String,Object> data = new HashMap<>();
data.put("id",id);
data.put("userName","admin");
data.put("from","provider-B");//改這裡是為了讓大家更能理解它負載均衡的機制
return data;
}

}

還有就是yml配置檔案

eureka:
  client:
    serviceUrl: #註冊中心的註冊地址
defaultZone: http://127.0.0.1:8081/eureka/
server:
  port: 8088  #服務埠號--該埠不要衝突
spring:
  application:
    name: service-provider #服務名稱--呼叫的時候根據名稱來呼叫該服務的方法--名字絕對不能改，改了就訪問不到了

我們來啟動一下吧

看看Eureka-server後臺的效果    ServerA      ServerB    


這個叫做Service-provider是不是有兩個例項啊
那麼，我們分別訪問一下，看看效果怎麼樣



看到了嗎，8082埠，from是provider-A，8088埠，from是provider-B.


那麼我們訪問消費者的伺服器看看會出現什麼樣的情況呢  飛機直達



一開始是from A,你重新整理一下，誒？ 變成 from B了。
說明這個時候兩臺提供者在交替工作，從而達到了一個負載均衡的作用。

來來來，我給你畫個圖



每個微服務都是一個Eureka-Client，我們把每個app（SpringBootApplication）都向註冊中心註冊一個服務。
有時候，某個服務的工作量比較大的時候，我們可以多註冊幾個同名稱的微服務，從而讓他們交替工作，減輕單個服務的壓力。


寫到這裡就結束咯。

明天還要上班呢。

有哪裡不對的地方，希望大家幫忙指正。

我也在學習的道路上。



相關推薦

Spring Boot + Eureka 實現微服務負載均衡

1，什麼是Eureka，什麼是服務註冊與發現      Spring Boot作為目前最火爆的web框架。那麼它與Eureka又有什麼關聯呢？Eureka是Netflix開源的一個RESTful服務，主要用於服務的註冊發現。Eureka由兩個元件組成：Eureka伺服器和Eu

Spring Cloud+docker實現微服務負載均衡

網上關於微服務實現負載均衡有不同的實現方式,有用ribbon,也有用zuul的,本文用zuul來實現 一般也稱Spring Cloud Zuul為微服務中的閘道器服務 微服務主要包含註冊與發現服務，路由服務(閘道器服務)，配置服務，熔斷服務，降級服務等一系列的服務. 我們

編碼實現Spring Cloud微服務負載均衡呼叫（eureka、ribbon）

Spring 封裝、揉和了一批開源專案，其中以Netflix開源的為主，比如zuul、eureka、hystrix、robbin等；然後就有了現在的Spring cloud微服務架構。這也充分展現了Spring的揉合能力。 Spring cloud通過封裝使這

spring-boot-admin 配合eureka實現 微服務監控

admin server配置： pom依賴： <dependencies> <dependency> <groupId>org.springframework.boot</groupId>

spring cloud快速入門教程（六）程序間呼叫和微服務負載均衡（Feign）

RestTemplate是不是很簡單粗暴呢？還有更粗暴的，那就是Feign，很多人都用過Dubbo，Feign的用法跟他類似。 我們複用userService那個module去呼叫productService微服務中的getProduct介面，引入Feign的依賴包： &

使用spring boot+thymeleaf實現微信公眾號開發之js_sdk介面

1.使用微信的js-sdk介面首先要在自己的微信測試公眾號，或者是公眾號上面新增js安全域名。 2.在需要呼叫JS介面的頁面引入如下JS檔案，（支援https）：http://res.wx.qq.com/open/js/jweixin-1.4.0.js。 3.通過config介面注入許

Spring Boot2.0實現微服務呼叫

服務提供者：提供對應的介面實現方法 服務消費者：建立對應的方法介面（表明指向服務提供者），並在控制器中呼叫 ======================================= 服務提供者：   建立控制器（實現介面內容） @Res

idea+spring boot+dubbox搭建微服務SSM框架環境專案（maven-圖文並解）

       搭建專案之前可以先去我的第一篇微服務專案搭建之前的一些工作準備，中介軟體等的設定，這裡是連續建立，用的都是之前建立好的基礎，所以直接更著走了，第一篇微服務連結地址：https://blog.csdn.net/gaofengyan/article/

spring boot admin 實現對服務的監控

service端: 專案依賴: <dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactI

Spring Cloud+Spring Boot+Mybatis+shiro +微服務 企業分散式微服務雲架構技術分享

1.   介紹Commonservice-system是一個大型分散式、微服務、面向企業的JavaEE體系快速研發平臺，基於模組化、服務化、原子化、熱插拔的設計思想，使用成熟領先的無商業限制的主流開源技術構建。採用服務化的元件開發模式，可實現複雜的業務功能。提供驅動式開發模式

小馬哥Spring Boot系列+Java 微服務實踐

03Java 微服務實踐 - Spring Boot 系列（三）web篇（中）.ts04Java 微服務實踐 - Spring Boot 系列（四）Web篇（下）.ts13Java 微服務實踐 - Spring Boot 系列（十三）WebSocket.ts19Java 微服

SpringCloud微服務負載均衡與閘道器

1、使用ribbon實現負載均衡ribbon是一個負載均衡客戶端 類似nginx反向代理，可以很好的控制htt和tcp的一些行為。Feign預設集成了ribbon。 啟動兩個會員服務工程，埠號分別為8762、8763，訂單服務使用負載均衡策略輪訓到會員服務介面。   在上一篇SpringC

springcloud+eureka 實現微服務-------------------入門程式

在寫程式碼之前先了解幾個概念。 單系統架構 將業務邏輯層、資料庫訪問層、控制層放入在一個專案中。 優點:適合於個人或者小團隊開發，不適合大團隊開發。 分散式專案架構 根據業務需求進行拆分成N個子系統，多個子系統相互協作才能完成業務流程子系統之間通訊使用R

【微服務】之四：輕鬆搞定SpringCloud微服務-負載均衡Ribbon

對於任何一個高可用高負載的系統來說，負載均衡是一個必不可少的名稱。在大型分散式計算體系中，某個服務在單例的情況下，很難應對各種突發情況。因此，負載均衡是為了讓系統在效能出現瓶頸或者其中一些出現狀態下可以進行分發業務量的解決方案。在SpringCloud 體系當中，加入了Netflix公司的很多優秀產品，其中

基於keepalive+LVS的高可用叢集來實現web服務負載均衡叢集的架構

架構環境： RedHat Linux Enterprise 5.8           keepalive                        LVS-DR 注意：1、事先配置好yum源，利用yum進行相關的軟體安裝，其可以很好的解決依賴關係

maven+spring boot搭建簡單微服務

專案需要使用spring boot，所以自學了幾天，僅提供給新手，請根據文件檢視…該專案僅是測試專案，並不完善和嚴謹，只實現了需要使用的基本功能。寫該部落格一是希望能夠幫助剛學習的新人，二是加深自己的印象，如果忘了也可以再看看，有些片段是從其他部落格學習來的，如

微服務負載均衡 —— ribbon

pan 配置 spl ima 超時 服務 軟件 ribbon 9.png 負載均衡是系統高可用、緩解網絡流量和處理能力擴容的重要手段，廣義的負載均衡指的是服務端負載均衡，如硬件負載均衡（F5）和軟件負載均衡（Nginx）。負載均衡設備會維護一份可用的服務器的信息，當

Spring Boot 動態切換資料來源二——負載均衡

如果僅僅是master-slave模式可以參考我前邊的文章Spring Boot HikariCP整合多資料來源。 這篇文章也是在那個基礎上修改的，上篇文章中的多資料來源是有限制的，哪條sql使用哪個資料庫必須在程式碼中寫死。現在針對這點做優化，真正的整合

Spring Cloud OAuth 實現微服務內部Token傳遞的原始碼解析

背景分析 1.客戶端攜帶認證中心發放的token,請求資源伺服器A（Spring Security OAuth 發放Toke

Eureka + Ribbon實現微服務的服務發現和負載均衡

目錄 1:原理結構圖 2:搭建Eureka Server服務註冊中心 3：搭建Eureka Provider (服務提供者，即Eureka Client) 4：搭建 Eurka-Consumer 1:原理結構圖 2:搭建Eureka Server服務註冊中心 建