Home | 簡體中文 | 繁體中文 | 雜文 | 知乎專欄 | Github | OSChina 博客 | 雲社區 | 雲棲社區 | Facebook | Linkedin | 視頻教程 | 打賞(Donations) | About
7.3. Spring Cloud Netflix
上一頁 第 7 章 Spring Cloud 下一頁
知乎專欄 ｜ 多維度架構 | 微信號 netkiller-ebook | QQ群：128659835 請註明“讀者”

7.3. Spring Cloud Netflix

7.3.1. Eureka Server

7.3.1.1. Maven

			
<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>cn.netkiller.spring.cloud</groupId>
	<artifactId>netflix.eureka.server</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>eureka.server</name>
	<url>http://maven.apache.org</url>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.7.RELEASE</version>
		<relativePath />
	</parent>

	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-netflix</artifactId>
				<version>1.3.5.RELEASE</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>

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

	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-surefire-plugin</artifactId>
				<configuration>
					<skip>true</skip>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>

7.3.1.2. Application

			
package cn.netkiller.spring.cloud.netflix.eureka.server;

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

@SpringBootApplication
@EnableEurekaServer
public class Application {
	public static void main(String[] args) {
		System.out.println("Hello World!");
		// new SpringApplicationBuilder(Application.class).web(true).run(args);
		SpringApplication.run(Application.class, args);
	}
}

7.3.1.3. application.properties

			
server.port=8761
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false
eureka.client.serviceUrl.defaultZone=http://localhost:${server.port}/eureka/

logging.level.com.netflix.eureka=OFF
logging.level.com.netflix.discovery=OFF

7.3.1.4. 檢查註冊伺服器

http://localhost:8761

7.3.2. Eureka Client

7.3.2.1. Maven

			
<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>cn.netkiller.spring.cloud</groupId>
	<artifactId>eureka.client</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>eureka.client</name>
	<url>http://maven.apache.org</url>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.7.RELEASE</version>
		<relativePath />
	</parent>
	
	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-netflix</artifactId>
				<version>1.3.5.RELEASE</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>
	
	<dependencies>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-config</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-eureka</artifactId>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-surefire-plugin</artifactId>
				<configuration>
					<skip>true</skip>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>

7.3.2.2. Application

			
package cn.netkiller.spring.cloud.eureka.client;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@Configuration
@EnableAutoConfiguration
@EnableEurekaClient
@RestController

public class Application {

	@RequestMapping("/")
	public String home() {
		return "Hello World";
	}

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

7.3.2.3. RestController

			
package cn.netkiller.spring.cloud.eureka.client;

import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestRestController {
	private static final Logger logger = LoggerFactory.getLogger(TestRestController.class);

	@RequestMapping("/")
	public String version() {
		logger.info("Hello!!!");
		return "Version: v1.0.0";
	}

	@RequestMapping(value = "/add", method = RequestMethod.GET)
	public Integer add(@RequestParam Integer a, @RequestParam Integer b) {
		Integer r = a + b;
		return r;
	}
	
	@RequestMapping("/greeting")
	public String greeting() {
		return "GREETING";
	}
}

7.3.2.4. application.properties

			
spring.application.name=test-service
server.port=8080
eureka.client.serviceUrl.defaultZone=http://localhost:8761/eureka/

7.3.2.5. 測試

首先確認客戶端已經註冊到 http://localhost:8761/

你可以啟動很多 Eureka 客戶端，相同的 spring.application.name 會歸為一組，為用戶提供負載均衡。

			
neo@MacBook-Pro ~ % curl http://localhost:8080/
Hello World

add 介面測試

			
curl http://localhost:8080/add.json?a=5&b=3

8

7.3.3. Feign client

7.3.3.1. Maven

			
<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>cn.netkiller.spring.cloud.netflix</groupId>
	<artifactId>feign.client</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>feign.client</name>
	<url>http://maven.apache.org</url>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.3.RELEASE</version>
		<relativePath />
	</parent>

	<dependencies>
		<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-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-eureka</artifactId>
			<version>1.3.1.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-feign</artifactId>
			<version>1.3.1.RELEASE</version>
		</dependency>
	</dependencies>
	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-surefire-plugin</artifactId>
				<configuration>
					<skip>true</skip>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>

7.3.3.2. Application

			
package cn.netkiller.spring.cloud.netflix.feign.client;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.feign.EnableFeignClients;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients
@RestController
public class Application {
	@Autowired
	private GreetingClient greetingClient;

	@RequestMapping("/get-greeting")
	public String greeting() {
		return greetingClient.greeting();
	}

	public static void main(String[] args) {
		SpringApplication.run(Application.class, args);
		System.out.println("Hello World!");
	}
}

7.3.3.3. interface

			
package cn.netkiller.spring.cloud.netflix.feign.client;

import org.springframework.cloud.netflix.feign.FeignClient;
import org.springframework.web.bind.annotation.RequestMapping;

@FeignClient("test-service")
public interface GreetingClient {
	@RequestMapping("/greeting")
	String greeting();
}

@FeignClient("test-service") 是 Eureka Client application.properties 中的 spring.application.name 配置項

@RequestMapping("/greeting") 是 Eureka Client RestController 中的 @RequestMapping

7.3.3.4. application.properties

			
spring.application.name=spring-cloud-eureka-feign-client
server.port=8088
#eureka.client.register-with-eureka=false
#eureka.client.fetch-registry=false
eureka.client.serviceUrl.defaultZone=http://localhost:8761/eureka/
feign.compression.response.enabled=true
feign.compression.request.enabled=true
feign.compression.request.mime-types=text/xml,application/xml,application/json
feign.compression.request.min-request-size=2048

7.3.3.5. 測試

			
$ curl -s http://localhost:8088/get-greeting.json

GREETING

7.3.3.6. fallback

			
@FeignClient(value = "restful-api-service", fallback = UserServiceFeignClientFallback.class)
public interface UserServiceFeignClient {
@RequestMapping(value = "/api/user/{id}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
    User getUser(@PathVariable("id") int id);

    @RequestMapping(value = "/api/user/search/findByName?name={name}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
    User findUserByName(@PathVariable("name") String name);

    @RequestMapping(value = "/api/user/search/findByAddress?address={address}", method = RequestMethod.GET)
    String findUserByAddress(@PathVariable("address") String address);
}
			
			
			
@Component
public class UserServiceFeignClientFallback implements UserServiceFeignClient {

    @Override
    public User getUser(int id) {
        return new User("getUser.Fallback", "feignClient return");
    }

    @Override
    public User findUserByName(String name) {
        return new User("findUserByName.Fallback", "feignClient return");
    }

    @Override
    public String findUserByAddress(String address) {
        return "fallback";
    }
}

7.3.4. 為 Eureka Server 增加用戶認證

7.3.4.1. Maven

				
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-security</artifactId>
		</dependency>

7.3.4.2. application.properties

				security.user.name=eureka
				security.user.password=s3cr3t

7.3.4.3. Eureka Client

				spring.application.name=restful-api-service
				eureka.client.serviceUrl.defaultZone=http://eureka:s3cr3t@localhost:8761/eureka/

7.3.4.4. Feign Client

				eureka.client.serviceUrl.defaultZone=http://eureka:s3cr3t@localhost:8761/eureka/

7.3.5. Eureka 配置項

7.3.5.1. /eureka/apps

			
neo@MacBook-Pro-Neo ~ % curl http://localhost:8761/eureka/apps
<applications>
  <versions__delta>1</versions__delta>
  <apps__hashcode></apps__hashcode>
</applications>

Spring Cloud Eureka 配置參數說明

			
Eureka Client 配置項（eureka.client.*）

org.springframework.cloud.netflix.eureka.EurekaClientConfigBean

參數名稱	說明	預設值
eureka.client.enabled

用於指示Eureka客戶端已啟用的標誌

true

eureka.client.registry-fetch-interval-seconds

指示從eureka伺服器獲取註冊表信息的頻率（s）

30

eureka.client.instance-info-replication-interval-seconds

更新實例信息的變化到Eureka服務端的間隔時間，（s）

30

eureka.client.initial-instance-info-replication-interval-seconds

初始化實例信息到Eureka服務端的間隔時間，（s）

40
eureka.client.eureka-service-url-poll-interval-seconds

詢問Eureka Server信息變化的時間間隔（s），預設為300秒	300
eureka.client.eureka-server-read-timeout-seconds

讀取Eureka Server 超時時間（s），預設8秒	
8

eureka.client.eureka-server-connect-timeout-seconds

連接Eureka Server 超時時間（s），預設5秒	
5

eureka.client.eureka-server-total-connections

獲取從eureka客戶端到所有eureka伺服器的連接總數,預設200個

200

eureka.client.eureka-server-total-connections-per-host

獲取從eureka客戶端到eureka伺服器主機允許的連接總數，預設50個

50

eureka.client.eureka-connection-idle-timeout-seconds

連接到 Eureka Server 空閒連接的超時時間（s），預設30	
30

eureka.client.registry-refresh-single-vip-address

 

指示客戶端是否僅對單個VIP的註冊表信息感興趣，預設為null

null
eureka.client.heartbeat-executor-thread-pool-size

心跳保持綫程池初始化綫程數，預設2個	2
eureka.client.heartbeat-executor-exponential-back-off-bound

心跳超時重試延遲時間的最大乘數值，預設10

10
eureka.client.serviceUrl.defaultZone

可用區域映射到與eureka伺服器通信的完全限定URL列表。每個值可以是單個URL或逗號分隔的備用位置列表。(http://${eureka.instance.hostname}:${server.port}/eureka/)

 

eureka.client.use-dns-for-fetching-service-urls

指示eureka客戶端是否應使用DNS機制來獲取要與之通信的eureka伺服器列表。當DNS名稱更新為具有其他伺服器時，eureka客戶端輪詢eurekaServiceUrlPollIntervalSeconds中指定的信息後立即使用該信息。

false
eureka.client.register-with-eureka

指示此實例是否應將其信息註冊到eureka伺服器以供其他服務發現，預設為false

True
eureka.client.prefer-same-zone-eureka

實例是否使用同一zone裡的eureka伺服器，預設為true，理想狀態下，eureka客戶端與服務端是在同一zone下

true
eureka.client.log-delta-diff

是否記錄eureka伺服器和客戶端之間在註冊表的信息方面的差異，預設為false

false
eureka.client.disable-delta

指示eureka客戶端是否禁用增量提取

false
eureka.client.fetch-remote-regions-registry

逗號分隔的區域列表，提取eureka註冊表信息

 
eureka.client.on-demand-update-status-change

客戶端的狀態更新到遠程伺服器上，預設為true

true

eureka.client.allow-redirects

指示伺服器是否可以將客戶端請求重定向到備份伺服器/集群。如果設置為false，則伺服器將直接處理請求。如果設置為true，則可以將HTTP重定向發送到具有新伺服器位置的客戶端。

false

eureka.client.availability-zones.*

獲取此實例所在區域的可用區域列表（在AWS數據中心中使用）。更改在運行時在registryFetchIntervalSeconds指定的下一個註冊表獲取周期生效。

 
eureka.client.backup-registry-impl

獲取實現BackupRegistry的實現的名稱，該實現僅在eureka客戶端啟動時第一次作為後備選項獲取註冊表信息。 對於需要額外的註冊表信息彈性的應用程序，可能需要這樣做，否則它將無法運行。

 
eureka.client.cache-refresh-executor-exponential-back-off-bound

在發生一系列超時的情況下，它是重試延遲的最大乘數值。

10

eureka.client.cache-refresh-executor-thread-pool-size

緩存刷新綫程池初始化綫程數量	
2

eureka.client.client-data-accept

客戶端數據接收的名稱	full
eureka.client.decoder-name

解碼器名稱	 
eureka.client.dollar-replacement

eureka伺服器序列化/反序列化的信息中獲取“$”符號的替換字元串。預設為“_-”

 
eureka.client.encoder-name

編碼器名稱	 
eureka.client.escape-char-replacement

eureka伺服器序列化/反序列化的信息中獲取“_”符號的的替換字元串。預設為“__“

 
eureka.client.eureka-server-d-n-s-name

獲取要查詢的DNS名稱來獲得eureka伺服器，此配置只有在eureka伺服器ip地址列表是在DNS中才會用到。預設為null

null

eureka.client.eureka-server-port

獲取eureka伺服器的連接埠，此配置只有在eureka伺服器ip地址列表是在DNS中才會用到。預設為null

null

eureka.client.eureka-server-u-r-l-context

表示eureka註冊中心的路徑，如果配置為eureka，則為http://ip:port/eureka/，

在eureka的配置檔案中加入此配置表示eureka作為客戶端向註冊中心註冊，從而構成eureka集群。此配置只有在eureka伺服器ip地址列表是在DNS中才會用到，預設為null

null

eureka.client.fetch-registry

客戶端是否獲取eureka伺服器註冊表上的註冊信息，預設為true

true

eureka.client.filter-only-up-instances

是否過濾掉非up實例，預設為true	
true

eureka.client.g-zip-content

當服務端支持壓縮的情況下，是否支持從服務端獲取的信息進行壓縮。預設為true

 
eureka.client.property-resolver

屬性解析器	 
eureka.client.proxy-host

獲取eureka server 的代理主機名	
null

eureka.client.proxy-password

獲取eureka server 的代理主機密碼

null

eureka.client.proxy-port

獲取eureka server 的代理主機連接埠

null

eureka.client.proxy-user-name

獲取eureka server 的代理用戶名

null

eureka.client.region

獲取此實例所在的區域（在AWS數據中心中使用）。

us-east-1

eureka.client.should-enforce-registration-at-init

client 在初始化階段是否強行註冊到註冊中心

false

eureka.client.should-unregister-on-shutdown

client在shutdown情況下，是否顯示從註冊中心註銷

true

服務實例配置項（eureka.instance.*）

org.springframework.cloud.netflix.eureka.EurekaInstanceConfigBean

參數名稱	說明	預設值
eureka.instance.appname

註冊到註冊中心的應用名稱	
unknown

eureka.instance.a-s-g-name

註冊到註冊中心的應用所屬分組名稱（AWS伺服器）	null
eureka.instance.app-group-name

註冊到註冊中心的應用所屬分組名稱

null
eureka.instance.data-center-info

指定服務實例所屬數據中心	
 

eureka.instance.instance-enabled-onit

指示是否應在eureka註冊後立即啟用實例以獲取流量

false
eureka.instance.non-secure-port

http通信連接埠	
80

eureka.instance.non-secure-port-enabled

是否啟用HTTP通信連接埠	ture
eureka.instance.secure-port

HTTPS通信連接埠	
443

eureka.instance.secure-port-enabled

是否啟用HTTPS通信連接埠	false
eureka.instance.secure-virtual-host-name

服務實例安全主機名稱（HTTPS）	unknown
eureka.instance.virtual-host-name

該服務實例非安全註解名稱（HTTP）	unknown
eureka.instance.secure-health-check-url

該服務實例安全健康檢查地址（URL），絶對地址	
 

eureka.instance.lease-renewal-interval-in-seconds

該服務實例向註冊中心發送心跳間隔（s）	
30

eureka.instance.lease-expiration-duration-in-seconds

指示eureka伺服器在刪除此實例之前收到最後一次心跳之後等待的時間（s）

90

eureka.instance.metadata-map.*

 

 

eureka.instance.ip-address

該服務實例的IP地址	null
eureka.instance.prefer-ip-address

是否優先使用服務實例的IP地址，相較于hostname	false
eureka.instance.status-page-url

該服務實例的狀態檢查地址（url），絶對地址	null
eureka.instance.status-page-url-path

該服務實例的狀態檢查地址，相對地址	
/actuator/info

eureka.instance.home-page-url

該服務實例的主頁地址（url），絶對地址	
 

eureka.instance.home-page-url-path

該服務實例的主頁地址，相對地址	
/

eureka.instance.health-check-url

該服務實例的健康檢查地址（url），絶對地址	
null

eureka.instance.health-check-url-path

該服務實例的健康檢查地址，相對地址	
/actuator/health

eureka.instance.instance-id

該服務實例在註冊中心的唯一實例ID	
 

eureka.instance.hostname

該服務實例所在主機名	
 

eureka.instance.namespace

獲取用於查找屬性的命名空間。 在Spring Cloud中被忽略。

eureka

eureka.instance.environment

該服務實例環境配置	
 

eureka.instance.default-address-resolution-order

預設地址解析順序	
 

eureka.instance.initial-status

該服務實例註冊到Eureka Server 的初始狀態	up
eureka.instance.registry.default-open-for-traffic-count

【Eureka Server 端屬性】預設開啟通信的數量	
1

eureka.instance.registry.expected-number-of-renews-per-min

【Eureka Server 端屬性】每分鐘續約次數	
1

Eureka Server 配置項（eureka.server.*）

org.springframework.cloud.netflix.eureka.server.EurekaServerConfigBean

參數名稱	說明	預設值
eureka.server.enable-self-preservation

啟用自我保護機制，預設為true	true
eureka.server.eviction-interval-timer-in-ms

清除無效服務實例的時間間隔（ms），預設1分鐘	
60000

eureka.server.delta-retention-timer-interval-in-ms

清理無效增量信息的時間間隔（ms），預設30秒	
30000

eureka.server.disable-delta

禁用增量獲取服務實例信息	false
eureka.server.log-identity-headers

是否記錄登錄日誌	true
eureka.server.rate-limiter-burst-size

限流大小	
10

eureka.server.rate-limiter-enabled

是否啟用限流	false
eureka.server.rate-limiter-full-fetch-average-rate

平均請求速率	
100

eureka.server.rate-limiter-throttle-standard-clients

是否對標準客戶端進行限流	false
eureka.server.rate-limiter-registry-fetch-average-rate

服務註冊與拉取的平均速率	
500

eureka.server.rate-limiter-privileged-clients

信任的客戶端列表	
 

eureka.server.renewal-percent-threshold

15分鐘內續約服務的比例小於0.85，則開啟自我保護機制，再此期間不會清除已註冊的任何服務（即便是無效服務）

0.85

eureka.server.renewal-threshold-update-interval-ms

更新續約閾值的間隔（分鐘），預設15分鐘	
15

eureka.server.response-cache-auto-expiration-in-seconds

註冊信息緩存有效時長（s），預設180秒	
180

eureka.server.response-cache-update-interval-ms

註冊信息緩存更新間隔（s），預設30秒	
30

eureka.server.retention-time-in-m-s-in-delta-queue

保留增量信息時長（分鐘），預設3分鐘	
3

eureka.server.sync-when-timestamp-differs

當時間戳不一致時，是否進行同步	true
eureka.server.use-read-only-response-cache

是否使用只讀緩存策略	true
 

自定義工具設置

 

eureka.server.json-codec-name

Json編解碼器名稱	
 

eureka.server.property-resolver

屬性解析器名稱	
 

eureka.server.xml-codec-name

Xml編解碼器名稱	
 

Eureka Server 集群配置

 

eureka.server.enable-replicated-request-compression

複製數據請求時，數據是否壓縮	false
eureka.server.batch-replication

節點之間數據複製是否採用批處理	false
eureka.server.max-elements-in-peer-replication-pool

備份池最大備份事件數量，預設1000	
1000

eureka.server.max-elements-in-status-replication-pool

狀態備份池最大備份事件數量，預設1000	
1000

eureka.server.max-idle-thread-age-in-minutes-for-peer-replication

節點之間信息同步綫程最大空閒時間（分鐘）	
15

eureka.server.max-idle-thread-in-minutes-age-for-status-replication

節點之間狀態同步綫程最大空閒時間（分鐘）	
10

eureka.server.max-threads-for-peer-replication

節點之間信息同步最大綫程數量	
20

eureka.server.max-threads-for-status-replication

節點之間狀態同步最大綫程數量	
1

eureka.server.max-time-for-replication

節點之間信息複製最大通信時長（ms）	
30000

eureka.server.min-available-instances-for-peer-replication

集群中服務實例最小數量，-1 表示單節點	
-1

eureka.server.min-threads-for-peer-replication

節點之間信息複製最小綫程數量	
5

eureka.server.min-threads-for-status-replication

節點之間信息狀態同步最小綫程數量	
1

eureka.server.number-of-replication-retries

節點之間數據複製時，可重試次數	
5

eureka.server.peer-eureka-nodes-update-interval-ms

節點更新數據間隔時長（分鐘）	
10

eureka.server.peer-eureka-status-refresh-time-interval-ms

節點之間狀態刷新間隔時長（ms）	
30000

eureka.server.peer-node-connect-timeout-ms

節點之間連接超時時長（ms）	
200

eureka.server.peer-node-connection-idle-timeout-seconds

節點之間連接後，空閒時長（s）	
30

eureka.server.peer-node-read-timeout-ms

幾點之間數據讀取超時時間（ms）	
200

eureka.server.peer-node-total-connections

集群中節點連接總數	
1000

eureka.server.peer-node-total-connections-per-host

節點之間連接，單機最大連接數量	
500

eureka.server.registry-sync-retries

節點啟動時，嘗試獲取註冊信息的次數	
500

eureka.server.registry-sync-retry-wait-ms

節點啟動時，嘗試獲取註冊信息的間隔時長（ms）	
30000

eureka.server.wait-time-in-ms-when-sync-empty

在Eureka伺服器獲取不到集群裡對等伺服器上的實例時，需要等待的時間（分鐘）

5

7.3.5.2. Eureka instance 配置項

			
#服務註冊中心實例的主機名
eureka.instance.hostname=localhost
#註冊在Eureka服務中的應用組名
eureka.instance.app-group-name=
#註冊在的Eureka服務中的應用名稱
eureka.instance.appname=
#該實例註冊到服務中心的唯一ID
eureka.instance.instance-id=
#該實例的IP地址
eureka.instance.ip-address=
#該實例，相較于hostname是否優先使用IP
eureka.instance.prefer-ip-address=false
 
#用於AWS平台自動擴展的與此實例關聯的組名，
eureka.instance.a-s-g-name=
#部署此實例的數據中心
eureka.instance.data-center-info=
#預設的地址解析順序
eureka.instance.default-address-resolution-order=
#該實例的環境配置
eureka.instance.environment=
#初始化該實例，註冊到服務中心的初始狀態
eureka.instance.initial-status=up
#表明是否只要此實例註冊到服務中心，立馬就進行通信
eureka.instance.instance-enabled-onit=false
#該服務實例的命名空間,用於查找屬性
eureka.instance.namespace=eureka
#該服務實例的子定義元數據，可以被服務中心接受到
eureka.instance.metadata-map.test = test
 
#服務中心刪除此服務實例的等待時間(秒為單位),時間間隔為最後一次服務中心接受到的心跳時間
eureka.instance.lease-expiration-duration-in-seconds=90
#該實例給服務中心發送心跳的間隔時間，用於表明該服務實例可用
eureka.instance.lease-renewal-interval-in-seconds=30
#該實例，註冊服務中心，預設打開的通信數量
eureka.instance.registry.default-open-for-traffic-count=1
#每分鐘續約次數
eureka.instance.registry.expected-number-of-renews-per-min=1
 
#該實例健康檢查url,絶對路徑
eureka.instance.health-check-url=
#該實例健康檢查url,相對路徑
eureka.instance.health-check-url-path=/health
#該實例的主頁url,絶對路徑
eureka.instance.home-page-url=
#該實例的主頁url,相對路徑
eureka.instance.home-page-url-path=/
#該實例的安全健康檢查url,絶對路徑
eureka.instance.secure-health-check-url=
#https通信連接埠
eureka.instance.secure-port=443
#https通信連接埠是否啟用
eureka.instance.secure-port-enabled=false
#http通信連接埠
eureka.instance.non-secure-port=80
#http通信連接埠是否啟用
eureka.instance.non-secure-port-enabled=true
#該實例的安全虛擬主機名稱(https)
eureka.instance.secure-virtual-host-name=unknown
#該實例的虛擬主機名稱(http)
eureka.instance.virtual-host-name=unknown
#該實例的狀態呈現url,絶對路徑
eureka.instance.status-page-url=
#該實例的狀態呈現url,相對路徑
eureka.instance.status-page-url-path=/status

7.3.5.3. Eureka client 配置項

			
#該客戶端是否可用
eureka.client.enabled=true
#實例是否在eureka伺服器上註冊自己的信息以供其他服務發現，預設為true
eureka.client.register-with-eureka=false
#此客戶端是否獲取eureka伺服器註冊表上的註冊信息，預設為true
eureka.client.fetch-registry=false
#是否過濾掉，非UP的實例。預設為true
eureka.client.filter-only-up-instances=true
#與Eureka註冊服務中心的通信zone和url地址
eureka.client.serviceUrl.defaultZone=http://${eureka.instance.hostname}:${server.port}/eureka/
 
#client連接Eureka服務端後的空閒等待時間，預設為30 秒
eureka.client.eureka-connection-idle-timeout-seconds=30
#client連接eureka服務端的連接超時時間，預設為5秒
eureka.client.eureka-server-connect-timeout-seconds=5
#client對服務端的讀超時時長
eureka.client.eureka-server-read-timeout-seconds=8
#client連接all eureka服務端的總連接數，預設200
eureka.client.eureka-server-total-connections=200
#client連接eureka服務端的單機連接數量，預設50
eureka.client.eureka-server-total-connections-per-host=50
#執行程序指數回退刷新的相關屬性，是重試延遲的最大倍數值，預設為10
eureka.client.cache-refresh-executor-exponential-back-off-bound=10
#執行程序緩存刷新綫程池的大小，預設為5
eureka.client.cache-refresh-executor-thread-pool-size=2
#心跳執行程序回退相關的屬性，是重試延遲的最大倍數值，預設為10
eureka.client.heartbeat-executor-exponential-back-off-bound=10
#心跳執行程序綫程池的大小,預設為5
eureka.client.heartbeat-executor-thread-pool-size=5
# 詢問Eureka服務url信息變化的頻率（s），預設為300秒
eureka.client.eureka-service-url-poll-interval-seconds=300
#最初複製實例信息到eureka伺服器所需的時間（s），預設為40秒
eureka.client.initial-instance-info-replication-interval-seconds=40
#間隔多長時間再次複製實例信息到eureka伺服器，預設為30秒
eureka.client.instance-info-replication-interval-seconds=30
#從eureka伺服器註冊表中獲取註冊信息的時間間隔（s），預設為30秒
eureka.client.registry-fetch-interval-seconds=30
 
# 獲取實例所在的地區。預設為us-east-1
eureka.client.region=us-east-1
#實例是否使用同一zone裡的eureka伺服器，預設為true，理想狀態下，eureka客戶端與服務端是在同一zone下
eureka.client.prefer-same-zone-eureka=true
# 獲取實例所在的地區下可用性的區域列表，用逗號隔開。（AWS）
eureka.client.availability-zones.china=defaultZone,defaultZone1,defaultZone2
#eureka服務註冊表信息裡的以逗號隔開的地區名單，如果不這樣返回這些地區名單，則客戶端啟動將會出錯。預設為null
eureka.client.fetch-remote-regions-registry=
#伺服器是否能夠重定向客戶端請求到備份伺服器。 如果設置為false，伺服器將直接處理請求，如果設置為true，它可能發送HTTP重定向到客戶端。預設為false
eureka.client.allow-redirects=false
#客戶端數據接收
eureka.client.client-data-accept=
#增量信息是否可以提供給客戶端看，預設為false
eureka.client.disable-delta=false
#eureka伺服器序列化/反序列化的信息中獲取“_”符號的的替換字元串。預設為“__“
eureka.client.escape-char-replacement=__
#eureka伺服器序列化/反序列化的信息中獲取“$”符號的替換字元串。預設為“_-”
eureka.client.dollar-replacement="_-"
#當服務端支持壓縮的情況下，是否支持從服務端獲取的信息進行壓縮。預設為true
eureka.client.g-zip-content=true
#是否記錄eureka伺服器和客戶端之間在註冊表的信息方面的差異，預設為false
eureka.client.log-delta-diff=false
# 如果設置為true,客戶端的狀態更新將會點播更新到遠程伺服器上，預設為true
eureka.client.on-demand-update-status-change=true
#此客戶端只對一個單一的VIP註冊表的信息感興趣。預設為null
eureka.client.registry-refresh-single-vip-address=
#client是否在初始化階段強行註冊到服務中心，預設為false
eureka.client.should-enforce-registration-at-init=false
#client在shutdown的時候是否顯示的註銷服務從服務中心，預設為true
eureka.client.should-unregister-on-shutdown=true
 
# 獲取eureka服務的代理主機，預設為null
eureka.client.proxy-host=
#獲取eureka服務的代理密碼，預設為null
eureka.client.proxy-password=
# 獲取eureka服務的代理連接埠, 預設為null
eureka.client.proxy-port=
# 獲取eureka服務的代理用戶名，預設為null
eureka.client.proxy-user-name=
 
#屬性解釋器
eureka.client.property-resolver=
#獲取實現了eureka客戶端在第一次啟動時讀取註冊表的信息作為回退選項的實現名稱
eureka.client.backup-registry-impl=
#這是一個短暫的×××的配置，如果最新的×××是穩定的，則可以去除，預設為null
eureka.client.decoder-name=
#這是一個短暫的編碼器的配置，如果最新的編碼器是穩定的，則可以去除，預設為null
eureka.client.encoder-name=
 
#是否使用DNS機制去獲取服務列表，然後進行通信。預設為false
eureka.client.use-dns-for-fetching-service-urls=false
#獲取要查詢的DNS名稱來獲得eureka伺服器，此配置只有在eureka伺服器ip地址列表是在DNS中才會用到。預設為null
eureka.client.eureka-server-d-n-s-name=
#獲取eureka伺服器的連接埠，此配置只有在eureka伺服器ip地址列表是在DNS中才會用到。預設為null
eureka.client.eureka-server-port=
#表示eureka註冊中心的路徑，如果配置為eureka，則為http://x.x.x.x:x/eureka/，在eureka的配置檔案中加入此配置表示eureka作為客戶端向註冊中心註冊，從而構成eureka集群。此配置只有在eureka伺服器ip地址列表是在DNS中才會用到，預設為null
eureka.client.eureka-server-u-r-l-context=

7.3.5.4. Eureka Server配置項

			
#服務端開啟自我保護模式。無論什麼情況，服務端都會保持一定數量的服務。避免client與server的網絡問題，而出現大量的服務被清除。
eureka.server.enable-self-preservation=true
#開啟清除無效服務的定時任務，時間間隔。預設1分鐘
eureka.server.eviction-interval-timer-in-ms= 60000
#間隔多長時間，清除過期的delta數據
eureka.server.delta-retention-timer-interval-in-ms=0
#過期數據，是否也提供給client
eureka.server.disable-delta=false
#eureka服務端是否記錄client的身份header
eureka.server.log-identity-headers=true
#請求頻率限製器
eureka.server.rate-limiter-burst-size=10
#是否開啟請求頻率限製器
eureka.server.rate-limiter-enabled=false
#請求頻率的平均值
eureka.server.rate-limiter-full-fetch-average-rate=100
#是否對標準的client進行頻率請求限制。如果是false，則只對非標準client進行限制
eureka.server.rate-limiter-throttle-standard-clients=false
#註冊服務、拉去服務列表數據的請求頻率的平均值
eureka.server.rate-limiter-registry-fetch-average-rate=500
#設置信任的client list
eureka.server.rate-limiter-privileged-clients=
#在設置的時間範圍類，期望與client續約的百分比。
eureka.server.renewal-percent-threshold=0.85
#多長時間更新續約的閾值
eureka.server.renewal-threshold-update-interval-ms=0
#對於緩存的註冊數據，多長時間過期
eureka.server.response-cache-auto-expiration-in-seconds=180
#多長時間更新一次緩存中的服務註冊數據
eureka.server.response-cache-update-interval-ms=0
#緩存增量數據的時間，以便在檢索的時候不丟失信息
eureka.server.retention-time-in-m-s-in-delta-queue=0
#當時間戳不一致的時候，是否進行同步
eureka.server.sync-when-timestamp-differs=true
#是否採用只讀緩存策略，只讀策略對於緩存的數據不會過期。
eureka.server.use-read-only-response-cache=true
 
################server 自定義實現的配置#####################33
#json的轉換的實現類名
eureka.server.json-codec-name=
#PropertyResolver
eureka.server.property-resolver=
#eureka server xml的編解碼實現名稱
eureka.server.xml-codec-name=
 
################server node 與 node 之間關聯的配置#####################33
#發送複製數據是否在request中，總是壓縮
eureka.server.enable-replicated-request-compression=false
#指示群集節點之間的複製是否應批處理以提高網絡效率。
eureka.server.batch-replication=false
#允許備份到備份池的最大複製事件數量。而這個備份池負責除狀態更新的其他事件。可以根據內存大小，超時和複製流量，來設置此值得大小
eureka.server.max-elements-in-peer-replication-pool=10000
#允許備份到狀態備份池的最大複製事件數量
eureka.server.max-elements-in-status-replication-pool=10000
#多個服務中心相互同步信息綫程的最大空閒時間
eureka.server.max-idle-thread-age-in-minutes-for-peer-replication=15
#狀態同步綫程的最大空閒時間
eureka.server.max-idle-thread-in-minutes-age-for-status-replication=15
#服務註冊中心各個instance相互複製數據的最大綫程數量
eureka.server.max-threads-for-peer-replication=20
#服務註冊中心各個instance相互複製狀態數據的最大綫程數量
eureka.server.max-threads-for-status-replication=1
#instance之間複製數據的通信時長
eureka.server.max-time-for-replication=30000
#正常的對等服務instance最小數量。-1表示服務中心為單節點。
eureka.server.min-available-instances-for-peer-replication=-1
#instance之間相互複製開啟的最小綫程數量
eureka.server.min-threads-for-peer-replication=5
#instance之間用於狀態複製，開啟的最小綫程數量
eureka.server.min-threads-for-status-replication=1
#instance之間複製數據時可以重試的次數
eureka.server.number-of-replication-retries=5
#eureka節點間間隔多長時間更新一次數據。預設10分鐘。
eureka.server.peer-eureka-nodes-update-interval-ms=600000
#eureka服務狀態的相互更新的時間間隔。
eureka.server.peer-eureka-status-refresh-time-interval-ms=0
#eureka對等節點間連接超時時間
eureka.server.peer-node-connect-timeout-ms=200
#eureka對等節點連接後的空閒時間
eureka.server.peer-node-connection-idle-timeout-seconds=30
#節點間的讀數據連接超時時間
eureka.server.peer-node-read-timeout-ms=200
#eureka server 節點間連接的總共最大數量
eureka.server.peer-node-total-connections=1000
#eureka server 節點間連接的單機最大數量
eureka.server.peer-node-total-connections-per-host=10
#在服務節點啟動時，eureka嘗試獲取註冊信息的次數
eureka.server.registry-sync-retries=
#在服務節點啟動時，eureka多次嘗試獲取註冊信息的間隔時間
eureka.server.registry-sync-retry-wait-ms=
#當eureka server啟動的時候，不能從對等節點獲取instance註冊信息的情況，應等待多長時間。
eureka.server.wait-time-in-ms-when-sync-empty=0
 
################server 與 remote 關聯的配置#####################33
#過期數據，是否也提供給遠程region
eureka.server.disable-delta-for-remote-regions=false
#回退到遠程區域中的應用程序的舊行為 (如果已配置) 如果本地區域中沒有該應用程序的實例, 則將被禁用。
eureka.server.disable-transparent-fallback-to-other-region=false
#指示在伺服器支持的情況下, 是否必須為遠程區域壓縮從尤里卡伺服器獲取的內容。
eureka.server.g-zip-content-from-remote-region=true
#連接eureka remote note的連接超時時間
eureka.server.remote-region-connect-timeout-ms=1000
#remote region 應用白名單
eureka.server.remote-region-app-whitelist.
#連接eureka remote note的連接空閒時間
eureka.server.remote-region-connection-idle-timeout-seconds=30
#執行remote region 獲取註冊信息的請求綫程池大小
eureka.server.remote-region-fetch-thread-pool-size=20
#remote region 從對等eureka加點讀取數據的超時時間
eureka.server.remote-region-read-timeout-ms=1000
#從remote region 獲取註冊信息的時間間隔
eureka.server.remote-region-registry-fetch-interval=30
#remote region 連接eureka節點的總連接數量
eureka.server.remote-region-total-connections=1000
#remote region 連接eureka節點的單機連接數量
eureka.server.remote-region-total-connections-per-host=50
#remote region抓取註冊信息的存儲檔案，而這個可靠的存儲檔案需要全限定名來指定
eureka.server.remote-region-trust-store=
#remote region 儲存的檔案的密碼
eureka.server.remote-region-trust-store-password=
#remote region url.多個逗號隔開
eureka.server.remote-region-urls=
#remote region url.多個逗號隔開
eureka.server.remote-region-urls-with-name.
 
################server 與 ASG/AWS/EIP/route52 之間關聯的配置#####################33
#緩存ASG信息的過期時間。
eureka.server.a-s-g-cache-expiry-timeout-ms=0
#查詢ASG信息的超時時間
eureka.server.a-s-g-query-timeout-ms=300
#服務更新ASG信息的頻率
eureka.server.a-s-g-update-interval-ms=0
#AWS訪問ID
eureka.server.a-w-s-access-id=
#AWS安全密鑰
eureka.server.a-w-s-secret-key=
#AWS綁定策略
eureka.server.binding-strategy=eip
#用於從第三方AWS 帳戶描述自動擴展分組的角色的名稱。
eureka.server.list-auto-scaling-groups-role-name=
#是否應該建立連接引導
eureka.server.prime-aws-replica-connections=true
#服務端嘗試綁定候選EIP的次數
eureka.server.e-i-p-bind-rebind-retries=3
#服務端綁定EIP的時間間隔.如果綁定就檢查;如果綁定失效就重新綁定。若且唯若已經綁定的情況
eureka.server.e-i-p-binding-retry-interval-ms=10
#服務端綁定EIP的時間間隔.若且唯若服務為綁定的情況
eureka.server.e-i-p-binding-retry-interval-ms-when-unbound=
#服務端嘗試綁定route53的次數
eureka.server.route53-bind-rebind-retries=3
#服務端間隔多長時間嘗試綁定route53
eureka.server.route53-binding-retry-interval-ms=30
#
eureka.server.route53-domain-t-t-l=10

7.3.6. ribbon

7.3.6.1. 

			
@Configuration
public class RibbonConfigure {

    @LoadBalanced
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }

    //指定Ribbon使用隨機策略
    @Bean
    public IRule loadBalanceRule(){
        //return new RandomRule();
        List<Integer> ports = new ArrayList<>();
        ports.add(8081);
        return new CustomRule(ports);
    }
}

7.3.6.2. LoadBalancerClient 實例

7.3.6.2.1. application.properties
				
web.ribbon.listOfServers=localhost:7900,localhost:7901,localhost:7902
7.3.6.2.2. LoadBalancerClient 獲取伺服器列表
				
package cn.netkiller.openfeign.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.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {

	@Autowired
	private LoadBalancerClient loadBalancerClient;

	@GetMapping("/lb")
	public String LoadBalancer() {
		ServiceInstance serviceInstance = this.loadBalancerClient.choose("web");
		System.out.println("Server: " + serviceInstance.getServiceId() + ":" + serviceInstance.getHost() + ":"
				+ serviceInstance.getPort());

		return serviceInstance.toString();
	}

}

7.3.6.3. Ribbon 相關配置

			
spring.cloud.loadbalancer.ribbon.enabled=false
7.3.6.3.1. 內置負載均衡策略
				
provider.ribbon.NFLoadBalancerRuleClassName=com.netflix.loadbalancer.RandomRule				
				
				
				
RoundRobinRule
輪詢策略。Ribbon 預設採用的策略。若經過一輪輪詢沒有找到可用的 provider，其最多 輪詢 10 輪。若最終還沒有找到，則返回 null。

RandomRule
隨機策略，從所有可用的 provider 中隨機選擇一個。

RetryRule
重試策略。先按照 RoundRobinRule 策略獲取 provider，若獲取失敗，則在指定的時限內重試。預設的時限為 500 毫秒。

BestAvailableRule
最可用策略。選擇並發量最小的 provider，即連接的消費者數量最少的 provider。

AvailabilityFilteringRule
可用過濾算法。該算法規則是:過濾掉處于熔斷狀態的 provider 與已經超過連接極限的 provider，對剩餘 provider 採用輪詢策略。

ZoneAvoidanceRule
zone 迴避策略。根據 provider 所在 zone 及 provider 的可用性，對 provider 進行選擇。

WeightedResponseTimeRule
“權重響應時間”策略。根據每個 provider 的平均響應時間計算其權重，響應時間越快權重越大，被選中的機率就越高。在剛啟動時採用輪詢策略。後面就會根據權重進行選擇了。

7.3.7. 獲取 EurekaClient 信息

		
package cn.netkiller.sample;

import com.netflix.discovery.EurekaClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.annotation.Lazy;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Mono;

@SpringBootApplication
@EnableEurekaClient
@RestController
public class WebFluxApplication {

    @Autowired
    @Lazy
    private EurekaClient eurekaClient;

    @Value("${spring.application.name}")
    private String appName;

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

    @GetMapping("/client")
    public Mono<String> greeting() {
        String idInEureka = eurekaClient.getApplication(appName).getInstances().get(0).getId();
        return Mono.just(String.format("Hello from '%s'!", idInEureka));
    }

    @GetMapping("/client2")
    public Mono<String> greetingWithParam(@RequestParam(value = "id") Long id) {
        String idInEureka = eurekaClient.getApplication(appName).getInstances().get(0).getId();
        return Mono.just(String.format("Hello with param from '%s'!", idInEureka));
    }
}

7.3.8. Zuul

7.3.8.1. Maven

			
<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>cn.netkiller</groupId>
	<artifactId>zuul</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>zuul</name>
	<url>http://maven.apache.org</url>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.6.RELEASE</version>
		<relativePath /> <!-- lookup parent from repository -->
	</parent>
	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>Dalston.SR2</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>
	<dependencies>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-zuul</artifactId>
		</dependency>
	</dependencies>
</project>

7.3.8.2. EnableZuulProxy

			
package cn.netkiller.zuul;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

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

7.3.8.3. application.yml

			
server:
  port: 8765

logging:
  level:
    ROOT: INFO
    org.springframework.web: DEBUG

zuul:
  routes:
    restful:
      path: /restful/**
      url: http://api:password@api.netkiller.com:8080/restful

7.3.8.4. 負載均衡配置

			
zuul:
  routes:
    httpbin:
      path: /**
      serviceId: httpslb

httpslb:
  ribbon:
    listOfServers: api1.netkiller.org, api2.netkiller.cn

上一頁 上一級 下一頁
7.2. Spring Cloud Consol 起始頁 7.4. Openfeign