转载

SpringCloud微服务部署

编辑推荐:
本文来自于csdn，本文详细介绍了SpringCloud的部署，主要从组件配置搭建，希望对您的学习有帮助。

微服务的其中一个特点就是有许许多的粒度小（功能单一，比如用户管理，短信发送管理，邮件发送管理，文件管理等）、能独立部署、扩展、运行的小应用，可以称为api,也就是服务提供者。api之间可以相互调用，但更多的是供app调用，比如学生管理系统，它是面向用户的，是许许多多功能的集合体，它需要调用许多api完成业务功能，所以这学生管理系统可以称为app。

eureka的作用

传统的单体应用开发，就是将api和app的代码全部集成在一起，在同一个进程中运行，对应java web通俗的说就是全部打包在一个war中部署在一个tomcat中运行。而微服务的每个api，app都拥有自己的进程，也就是都有自己的tomcat，某个api挂了，不影响其他api和app运行。

SpringCloud微服务部署

api是采取restfull风格暴漏出去的，所以app（api）调用api时，采取http://ip:端口这形式进行通讯。那么问题来了，如果有很多app都调用了某个api，如果api的ip或端口发生了更改，如果app中对api的ip和端口等信息是写在配置文件的，难道要通知每个app，说这个api的地址和端口变了，app要进行修改重新编译部署（这是举例子而已，实际情况有些企业对常量的配置可能写配置文件，也可能写数据库）。这太麻烦了，如果api的地址和端口有发生变化，app能及时获知自行变更，那就好了。还有个弊端，就是api是否挂了，也没法直观观察到。

所以，如果在app和api之间增加个服务管理中心，api像服务管理中心注册信息，app从服务管理中心获取api的信息，api有个唯一标识，api有变更的时候通知服务管理中心，服务管理中心通知相关的app或者app定时从服务管理中心获取最新的api信息，同时服务管理中心具有很高的稳定性、可靠性。

eureka就是为了这样的一个服务管理中心，下面是我根据自己的理解画的一张图。

SpringCloud微服务部署

下面这张是官方的架构图

SpringCloud微服务部署

1.Application Service 相当于服务提供者/api

2.Application Client 相当于服务消费者/app

3.Make Remote Call，其实就是实现服务的使用/比如httpClient,restTemplate

4.us-east-1 Eureka 集群服务

5.us-east-1c、us-east-1d、us-east-1e 就是具体的某个eureka

Eureka:

1. 是纯正的 servlet 应用，需构建成war包部署

2. 使用了 Jersey 框架实现自身的 RESTful HTTP接口

3. peer之间的同步与服务的注册全部通过 HTTP 协议实现

4. 定时任务(发送心跳、定时清理过期服务、节点同步等)通过 JDK 自带的 Timer 实现

5. 内存缓存使用Google的guava包实现

eureka集群搭建

和eureka类似功能的有zookeeper,etcd等。spring boot已经集成了eureka，所以我们可以像spring boot那样搭建环境，部署运行。

我是在window10下使用eclipse学习的。

准备工作。

在修改hosts文件，在最后面加上（位置：C:/Windows/System32/drivers/etc）

127.0.0.1 01.eureka.server

127.0.0.1 02.eureka.server

127.0.0.1 03.eureka.server

eclipse下创建个普通的maven项目eureka-server。

pom.xml

<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.fei.springcloud</groupId>

<artifactId>springcloud-eureka-server</artifactId>

<version>0.0.1-SNAPSHOT</version>

<description>eureka服务端</description>

<!-- 依赖仓库 设置从aliyun仓库下载 -->

<repositories>

<repository>

<id>alimaven</id>

<url>http://maven.aliyun.com/nexus/content/repositories/central/</url>

<snapshots>

<enabled>true</enabled>

</snapshots>

<releases>

<enabled>true</enabled>

</releases>

</repository>

</repositories>

<!-- 插件依赖仓库 -->

<pluginRepositories>

<pluginRepository>

<id>alimaven</id>

<url>http://maven.aliyun.com/nexus/content/repositories/central/</url>

<snapshots>

<enabled>true</enabled>

</snapshots>

<releases>

<enabled>true</enabled>

</releases>

</pluginRepository>

</pluginRepositories>

<properties>

<!-- 文件拷贝时的编码 -->

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

<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

<!-- 编译时的编码 -->

<maven.compiler.encoding>UTF-8</maven.compiler.encoding>

<java.version>1.8</java.version>

<maven.compiler.source>1.8</maven.compiler.source>

<maven.compiler.target>1.8</maven.compiler.target>

</properties>

<parent>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-parent</artifactId>

<version>1.5.2.RELEASE</version>

<relativePath />

</parent>

<dependencies>

<dependency>

<groupId>org.springframework.cloud</groupId>

<artifactId>spring-cloud-starter-eureka-server</artifactId>

</dependency>

</dependencies>

<dependencyManagement>

<dependencies>

<dependency>

<groupId>org.springframework.cloud</groupId>

<artifactId>spring-cloud-dependencies</artifactId>

<version>Dalston.RELEASE</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>

</project>

启动类Application.java

package com.fei.springcloud;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@EnableEurekaServer

@SpringBootApplication

public class Application {

public static void main(String[] args) {

SpringApplication.run(Application.class, args);

}

}

注意注解：@EnableEurekaServer，表明这是server服务

配置文件application.properties

logging.config=classpath:logback.xml

logging.path=d:/logs

##tomcat set###

# eureka的默认端口是8761

server.port=8081

server.session-timeout=60

###########

spring.application.name=eureka-server-01

####下面2个一定要false，因为这程序是要作为服务端

但是jar中存在eureka-client.jar，所以要false，否则启动会报错的

#是否注册到eureka

eureka.client.register-with-eureka=false

#是否获取注册信息

eureka.client.fetch-registry=false

#为了便于测试，取消eureka的保护模式，如果启动的话，

比如api提供者关闭了，但是eureka仍然保留信息

eureka.server.enable-self-preservation=false

#服务名称

eureka.instance.hostname=01.server.eureka

#eureka的服务地址，/eureka是固定的

eureka.client.serviceUrl.defaultZone=http://02.

server.eureka:8082/eureka/,http://03.server.eureka:8083/eureka/

注意：eureka.client.serviceUrl.defaultZone的配置，如果是01，则填写02、03的地址和端口；如果是02，则填写01、03的地址和端口，也就是说让01,02,03这3个eureka服务能相互间同步数据，如果是01->02->03->01,则api提供者注册信息到01时，01会同步数据到02，但02不会同步到03,01也不会同步到03，也就是说03缺数据了。看源码,服务的注册信息不会被二次传播，看PeerAwareInstanceRegistryImpl.java

SpringCloud微服务部署

启动01 eureka,然后修改application.properties,变为02 eureka的配置

logging.config=classpath:logback.xml

logging.path=d:/logs

##tomcat set###

# eureka的默认端口是8761

server.port=8082

server.session-timeout=60

###########

spring.application.name=eureka-server-02

####下面2个一定要false，因为这程序是要作为服务端，

但是jar中存在eureka-client.jar，所以要false，否则启动会报错的

#是否注册到eureka

eureka.client.register-with-eureka=false

#是否获取注册信息

eureka.client.fetch-registry=false

#为了便于测试，取消eureka的保护模式，如果启动的话，

比如api提供者关闭了，但是eureka仍然保留信息

eureka.server.enable-self-preservation=false

#服务名称

eureka.instance.hostname=02.server.eureka

#eureka的服务地址，/eureka是固定的

eureka.client.serviceUrl.defaultZone=http://01.server.

eureka:8081/eureka/,http://03.server.eureka:8083/eureka/

然后执行启动类，03也是一样的操作。

浏览器访问http://01.server.eureka:8081/（或者http://02.server.eureka:8082/，或者http://03.server.eureka:8083/）看到

SpringCloud微服务部署

api提供者

创建个普通的maven项目eureka-api,该api是个用户服务提供者。采取spring boot开发模式

SpringCloud微服务部署

pom.xml

<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.fei.springcloud</groupId>

<artifactId>springcloud-eureka-server</artifactId>

<version>0.0.1-SNAPSHOT</version>

<description>eureka服务端</description>

<!-- 依赖仓库 设置从aliyun仓库下载 -->

<repositories>

<repository>

<id>alimaven</id>

<url>http://maven.aliyun.com/nexus/content/repositories/central/</url>

<snapshots>

<enabled>true</enabled>

</snapshots>

<releases>

<enabled>true</enabled>

</releases>

</repository>

</repositories>

<!-- 插件依赖仓库 -->

<pluginRepositories>

<pluginRepository>

<id>alimaven</id>

<url>http://maven.aliyun.com/nexus/content/repositories/central/</url>

<snapshots>

<enabled>true</enabled>

</snapshots>

<releases>

<enabled>true</enabled>

</releases>

</pluginRepository>

</pluginRepositories>

<properties>

<!-- 文件拷贝时的编码 -->

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

<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

<!-- 编译时的编码 -->

<maven.compiler.encoding>UTF-8</maven.compiler.encoding>

<java.version>1.8</java.version>

<maven.compiler.source>1.8</maven.compiler.source>

<maven.compiler.target>1.8</maven.compiler.target>

</properties>

<parent>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-parent</artifactId>

<version>1.5.2.RELEASE</version>

<relativePath />

</parent>

<dependencies>

<dependency>

<groupId>org.springframework.cloud</groupId>

<artifactId>spring-cloud-starter-eureka</artifactId>

</dependency>

</dependencies>

<dependencyManagement>

<dependencies>

<dependency>

<groupId>org.springframework.cloud</groupId>

<artifactId>spring-cloud-dependencies</artifactId>

<version>Dalston.RELEASE</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>

</project>

它和eureka 服务端，有个依赖是不一样的。

application.properties

logging.config=classpath:logback.xml

logging.path=d:/logs

##tomcat set###

# eureka的默认端口是8761

server.port=9081

server.session-timeout=60

###########

spring.application.name=api-user-server

#像eureka服务注册信息时，使用ip地址，默认使用hostname

eureka.instance.preferIpAddress=true

#服务的instance-id默认默认值是${spring.cloud.client.hostname

:${spring.aplication.name}

:${spring.application.instance_id:${server.port}} ，

#也就是机器主机名:应用名称:应用端口

eureka.instance.instance-id=${spring.cloud.client.ipAddress}:${server.port}

#eureka的服务地址

eureka.client.serviceUrl.defaultZone=http://01.server.eureka:8081/eureka/

Application.java

package com.fei.springcloud;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@EnableEurekaClient

@SpringBootApplication

public class Application {

public static void main(String[] args) {

SpringApplication.run(Application.class, args);

}

}

@EnableEurekaClient，不管是消费者还是提供者，对应eureka server来说都是客户端client

写个普通的controller，UserProvider.java.提供个根据id获取用户信息的接口

package com.fei.springcloud.provider;

import javax.servlet.http.HttpServletRequest;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.PathVariable;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

@RestController

@RequestMapping("/user")

public class UserProvider {

@GetMapping(value="/find/{id}")

public String find(@PathVariable("id") String id,HttpServletRequest request){

//实际项目中，这里可以使用JSONObject，返回json字符串

//为了便于测试消费者app的负载均衡，返回服务端端口

String s = "张三"+" 服务端端口："+request.getLocalPort();

return s;

}

}

执行Application.java,将application.properties的端口修改为9082，再次执行

浏览器访问http://01.server.eureka:8081/

SpringCloud微服务部署

Application就是文件中定义的spring.application.name=api-user-server，它会自动转为大写

app消费者

在Spring Cloud Netflix中，使用Ribbon实现客户端负载均衡，使用Feign实现声明式HTTP客户端调用——即写得像本地函数调用一样.

SpringCloud微服务部署

ribbo负载均衡的app消费者

创建个普通的maven项目eureka-app-ribbo.

pom.xml

<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.fei.springcloud</groupId>

<artifactId>springcloud-eureka-app-ribbo</artifactId>

<version>0.0.1-SNAPSHOT</version>

<description>eureka消费者ribbo</description>

<!-- 依赖仓库 设置从aliyun仓库下载 -->

<repositories>

<repository>

<id>alimaven</id>

<url>http://maven.aliyun.com/nexus/content/repositories/central/</url>

<snapshots>

<enabled>true</enabled>

</snapshots>

<releases>

<enabled>true</enabled>

</releases>

</repository>

</repositories>

<!-- 插件依赖仓库 -->

<pluginRepositories>

<pluginRepository>

<id>alimaven</id>

<url>http://maven.aliyun.com/nexus/content/repositories/central/</url>

<snapshots>

<enabled>true</enabled>

</snapshots>

<releases>

<enabled>true</enabled>

</releases>

</pluginRepository>

</pluginRepositories>

<properties>

<!-- 文件拷贝时的编码 -->

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

<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

<!-- 编译时的编码 -->

<maven.compiler.encoding>UTF-8</maven.compiler.encoding>

<java.version>1.8</java.version>

<maven.compiler.source>1.8</maven.compiler.source>

<maven.compiler.target>1.8</maven.compiler.target>

</properties>

<parent>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-parent</artifactId>

<version>1.5.2.RELEASE</version>

<relativePath />

</parent>

<dependencies>

<!-- 客户端负载均衡 -->

<dependency>

<groupId>org.springframework.cloud</groupId>

<artifactId>spring-cloud-starter-ribbon</artifactId>

</dependency>

<!-- eureka客户端 -->

<dependency>

<groupId>org.springframework.cloud</groupId>

<artifactId>spring-cloud-starter-eureka</artifactId>

</dependency>

<!-- spring boot实现Java Web服务 -->

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

</dependency>

</dependencies>

<dependencyManagement>

<dependencies>

<dependency>

<groupId>org.springframework.cloud</groupId>

<artifactId>spring-cloud-dependencies</artifactId>

<version>Dalston.RELEASE</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>

</project>

application.properties

logging.config=classpath:logback.xml

logging.path=d:/logs

##tomcat set###

# eureka的默认端口是8761

server.port=7081

server.session-timeout=60

###########

spring.application.name=app-user

#像eureka服务注册信息时，使用ip地址，默认使用hostname

eureka.instance.preferIpAddress=true

#服务的instance-id默认默认值是${spring.cloud.client.hostname}${spring.application.name}

:${spring.application.instance_id:${server.port}} ，

#也就是机器主机名:应用名称:应用端口

eureka.instance.instance-id=${spring.cloud.client.ipAddress}:${server.port}

#eureka的服务地址

eureka.client.serviceUrl.defaultZone=http://01.server.eureka:

8081/eureka/,http://02.server.eureka:8082/eureka/,

http://03.server.eureka:8083/eureka/

UserController.java

logging.config=classpath:logback.xml

logging.path=d:/logs

##tomcat set###

# eureka的默认端口是8761

server.port=7081

server.session-timeout=60

###########

spring.application.name=app-user

#像eureka服务注册信息时，使用ip地址，默认使用hostname

eureka.instance.preferIpAddress=true

#服务的instance-id默认默认值是${spring.cloud.client.hostname}

:${spring.application.name}:${spring.application.instance_id:${server.port}} ，

#也就是机器主机名:应用名称:应用端口

eureka.instance.instance-id=${spring.cloud.client.ipAddress}:${server.port}

#eureka的服务地址

eureka.client.serviceUrl.defaultZone=http://01.server.eureka:8081/eureka/

,http://02.server.eureka:8082/eureka/,http://03.server.eureka:8083/eureka/

使用restTemplate需要自己拼接url

启动类Application.java

package com.fei.springcloud;

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.client.RestTemplate;

@EnableEurekaClient

@SpringBootApplication

public class Application {

@Bean //定义REST客户端，RestTemplate实例

@LoadBalanced //开启负债均衡的能力

RestTemplate restTemplate() {

return new RestTemplate();

}

public static void main(String[] args) {

SpringApplication.run(Application.class, args);

}

}

eureka服务

SpringCloud微服务部署

浏览器访问http://127.0.0.1:7081/user/find

看到信息“张三 服务端端口：9081”，刷新浏览器看到“张三 服务端端口：9082”，说明的确是有负载均衡。

但是访问外网的时候，http://127.0.0.1:7081/user/test，也就是域名不在eureka注册过的，就不行了。

SpringCloud微服务部署

以后再研究下如何解决。

feign的app消费者

feign可以写个接口，加上相关的注解，调用的时候，会自动拼接url，调用者就像调用本地接口一样的操作。

Feign也用到ribbon，当你使用@ FeignClient，ribbon自动被应用。

像ribbo创建个项目，或者直接在ribbo项目修改都OK。

pom.xml 把ribbo的依赖修改为feign

<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.fei.springcloud</groupId>

<artifactId>springcloud-eureka-app-feign</artifactId>

<version>0.0.1-SNAPSHOT</version>

<description>eureka消费者feign</description>

<!-- 依赖仓库 设置从aliyun仓库下载 -->

<repositories>

<repository>

<id>alimaven</id>

<url>http://maven.aliyun.com/nexus/content

/repositories/central/</url>

<snapshots>

<enabled>true</enabled>

</snapshots>

<releases>

<enabled>true</enabled>

</releases>

</repository>

</repositories>

<!-- 插件依赖仓库 -->

<pluginRepositories>

<pluginRepository>

<id>alimaven</id>

<url>http://maven.aliyun.com/nexus/content/repositories/central/</url>

<snapshots>

<enabled>true</enabled>

</snapshots>

<releases>

<enabled>true</enabled>

</releases>

</pluginRepository>

</pluginRepositories>

<properties>

<!-- 文件拷贝时的编码 -->

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

<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

<!-- 编译时的编码 -->

<maven.compiler.encoding>UTF-8</maven.compiler.encoding>

<java.version>1.8</java.version>

<maven.compiler.source>1.8</maven.compiler.source>

<maven.compiler.target>1.8</maven.compiler.target>

</properties>

<parent>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-parent</artifactId>

<version>1.5.2.RELEASE</version>

<relativePath />

</parent>

<dependencies>

<!-- Feign实现声明式HTTP客户端 -->

<dependency>

<groupId>org.springframework.cloud</groupId>

<artifactId>spring-cloud-starter-feign</artifactId>

</dependency>

<!-- eureka客户端 -->

<dependency>

<groupId>org.springframework.cloud</groupId>

<artifactId>spring-cloud-starter-eureka</artifactId>

</dependency>

<!-- spring boot实现Java Web服务 -->

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

</dependency>

</dependencies>

<dependencyManagement>

<dependencies>

<dependency>

<groupId>org.springframework.cloud</groupId>

<artifactId>spring-cloud-dependencies</artifactId>

<version>Dalston.RELEASE</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>

</project>

application.properties和上面一样

logging.config=classpath:logback.xml

logging.path=d:/logs

##tomcat set###

# eureka的默认端口是8761

server.port=7081

server.session-timeout=60

###########

spring.application.name=app-user

#像eureka服务注册信息时，使用ip地址，默认使用hostname

eureka.instance.preferIpAddress=true

#服务的instance-id默认默认值是${spring.cloud.client.hostname}

:${spring.application.name}:${spring.application.instance_id:${server.port}} ，

#也就是机器主机名:应用名称:应用端口

eureka.instance.instance-id=${spring.cloud.client.ipAddress}:${server.port}

#eureka的服务地址

eureka.client.serviceUrl.defaultZone=http://01.server.eureka

8081/eureka/,http://02.server.eureka:8082/eureka/,

http://03.server.eureka:8083/eureka/

增加个UserService.java接口类

package com.fei.springcloud.service;

import org.springframework.cloud.netflix.feign.FeignClient;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.PathVariable;

@FeignClient("API-USER-SERVER")

public interface UserService {

@GetMapping(value="/user/find/{id}")

String find(@PathVariable("id") String id);

}

UserController.java

package com.fei.springcloud.controller;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.ResponseBody;

import com.fei.springcloud.service.UserService;

@Controller

@RequestMapping("/user")

public class UserController {

@Autowired

private UserService userService;

@GetMapping(value = "/find")

@ResponseBody

public String find() {

//url中对应api提供者的名称，全大写

String s = userService.find("123");

return s;

}

}

浏览器访问http://127.0.0.1:7081/user/find，得到信息“张三 服务端端口：9081”，刷新，得到“张三 服务端端口：9082”，Feign也用到ribbon，当你使用@ FeignClient，ribbon自动被应用。所以也会负载均衡

ribbo负载均衡策略选择

SpringCloud微服务部署

AvailabilityFilteringRule：过滤掉那些因为一直连接失败的被标记为circuit tripped的后端server，并过滤掉那些高并发的的后端server（active connections 超过配置的阈值） | 使用一个AvailabilityPredicate来包含过滤server的逻辑，其实就就是检查status里记录的各个server的运行状态

RandomRule：随机选择一个server

BestAvailabl：选择一个最小的并发请求的server，逐个考察Server，如果Server被tripped了，则忽略

RoundRobinRule：roundRobin方式轮询选择， 轮询index，选择index对应位置的server

WeightedResponseTimeRule：根据响应时间分配一个weight(权重)，响应时间越长，weight越小，被选中的可能性越低

RetryRule：对选定的负载均衡策略机上重试机制，在一个配置时间段内当选择server不成功，则一直尝试使用subRule的方式选择一个可用的server

ZoneAvoidanceRule：复合判断server所在区域的性能和server的可用性选择server

ResponseTimeWeightedRule：作用同WeightedResponseTimeRule，二者作用是一样的，ResponseTimeWeightedRule后来改名为WeightedResponseTimeRule

在app消费者的application.properties配置文件中加入

#ribbo负载均衡策略配置，默认是依次轮询

API-USER-SERVER.ribbon.NFLoadBalancerRuleClassName=com.

netflix.loadbalancer.RandomRule

其中API-USER-SERVER是api服务提供者的服务名称，也就是说，可以给每个不同的api服务提供者配置不同的复制均衡策略，验证就不贴图了

完整的代码

负载均衡策略在消费端配置的缺点

在上面的例子中，ribbon的负载均衡是在消费端完成的。流程是这样的：提供者服务A集群，启动2个进程A1，A2，都注册到eureka,app消费端根据api服务者名称获取到A1,A2的具体连接地址，ribbon就对A1,A2进行负载均衡。

缺点：

1） 如果所有的app消费端的配置策略不好，导致绝大部分的请求都到A1，那A1的压力就大了。也就是说负载策略不是有api提供者所控制的了（这里就不说A1,A2所在的服务器哪个性能更好了，因为如果app/api都是在Docker中运行，k8s负责资源调配的话，可以认为每个服务的进程所在的docker配置是一样的，比如A服务对应的A1,A2系统环境是一致的，B服务对应的B1,B2,B3系统环境是一致的，只是所对应的宿主机服务器估计不一样而已）。

2）如果api提供者需要开放给第三方公司的时候，总不能把A1,A2告诉第三方吧，说我们这A服务集群了，有A1,A2,你随意吧。

我们实际项目中的做法，都是每个提供者服务都有自己的nginx管理自己的集群，然后把nginx的域名提供给app消费者即可。之所以每个服务提供者都有自己的nginx，是因为docker被k8s管控的时候，ip都是变化的，需要更新到nginx中。如果A,B都共用一个nginx，那A重构建部署的时候，A1,A2的ip变化了，需要更新到nginx中去，那如果导致nginx出现问题了，岂不是影响到B的使用了，所以A,B都有自己的nginx。那spring cloud没有解决方案了吗？有。spring cloud集成了zuul,zuul服务网关，不但提供了和nginx一样的反向代理功能，还提供了负载均衡、监控、过滤等功能，在后面学习zuul的时候，我们再学习。

SpringCloud微服务部署

docker+k8s实现的devOps平台（paas平台），构建好镜像后，部署的时候，k8s负责调控资源，将docker分配到不同的节点服务器，同时将docker的ip相关信息更新到nginx。这是自动化的，不需要开发人员手动操作docker，nginx配置。

原文  http://www.uml.org.cn/wfw/201810261.asp
正文到此结束
所属分类： Java 编程技术

热门推荐

相关文章

阿里云首购8折
说给你听

本文目录
随机标签
书籍教程
springboot-demo Java入门教程 bootstrap3 CSS Apache基础教程 php ionic 教程 Python mysql教程 eclipse Ubuntu VPS系统配置 AngularJS 教程 MongoDB教程 Struts2教程 Redis教程 Spring教程 Git教程 Jenkins进阶系列 openfire参考指南 Java设计模式 HBase教程 Maven教程 hibernate教程 Docker 教程 memcached教程 Quartz指南 Hive教程 Ant教程 ANTLR教程 SpringCloud java实例教程 springcloud-demo XStream教程 Hazelcast教程 Elastic-Job-Lite 深入浅出MyBatis SVN教程 ibaties教程 rabittmq教程 solr教程 Hadoop教程 WebService CXF学习 JPA教程 ActiveMQ中文指南 java-demo Java内存模型 dubbo教程 python3-demo Linux入门视频教程
近期评论
  1. 1 Spring Cloud Consul实现选举机制
  2. 2 Spring Boot集成ShedLock实现分布式定时任务
  3. 3 利用oss进行数据库和网站图片备份
  4. 4 Spring Cloud Stream实现数据流处理
  5. 5 Python3访问MySQL数据库快速入门Demo
  6. 6 Github开源项目作者可以免费申请 JetBrains 全家桶
  7. 7 Spring Cloud Vault快速入门Demo
  8. 8 Spring Cloud Gateway快速入门Demo
  9. 9 Spring Cloud Contract快速入门Demo
  10. 10 Spring Cloud Consul快速入门Demo
网站信息
  • 文章总数：82,714 篇
  • 文件总数：284,287 个
  • 标签总数：2,393 个
  • 分类总数：85 个
  • 留言数量：2,560 条
  • 在线人数：688 人
  • 运行天数：4,408天
  • 最后更新：2024年11月21日23点
Loading...

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

[HBLOG]公众号 HBLOG HBLOG