运维工程师浅谈微服务springboot2.0的架构

现在微服务方兴未艾，从面试一些JAVA开发到做项目到上线的落地，说得比较多的就是微服务，今天就谈 一下关于现有的微服务框架springboot，从侧面了解一下微服务器的构架与运行原理：

一、知识点了解：

gradle教程，可以进行单元测试，打包，远程发布一个工具:

https://www.w3cschool.cn/gradle/6qo51htq.html

springboot，获取现有的框架结构：

https://start.spring.io/

maven国内加速源：

http://maven.aliyun.com/mvn/view

http://www.mvnjar.com/

二、springboot架构：

Eureka/Consul/Zookeeper：服务发现 ，服务注册
Hystrix：断路器，加载保护 
Zuul：智能路由，网关
Ribbon/Feign：客户端负载均衡
Turbine&hystrix-dashboard：集群监控 
Springcloud-config：配置中心，远程获取配置文件，支持热加载

zipkin：全链路跟踪

三、搭建微服务

1、搭建eureka-server服务sc-eureka-server

eureka-server作为服务发现的核心，第一个搭建，后面的服务都要注册到eureka-server上，意思是告诉eureka-server自己的服务地址是啥。当然还可以用zookeeper或者springconsul。

• 1.修改build.gradle文件

如果是maven项目请对应的修改pom.xml

//加入阿里的私服仓库地址
maven { url "http://maven.aliyun.com/nexus/content/groups/public/" }

以下依赖可以从https://start.spring.io/选择时，打包下载即可

//加入依赖  
compile('org.springframework.cloud:spring-cloud-starter-netflix-eureka-server')
//加入security，是因为访问eureka-server需要用户名和密码访问，为了安全
compile('org.springframework.boot:spring-boot-starter-security')

支持远程发布，gradle uploadArchives,以下为发布到本地：

 
- 2.修改 application.yml，建议用yml（位于src\main\resources）。

server:
  port: 8761
eureka:
  datacenter: trmap
  environment: product
  server:
      # 关闭自我保护
      enable-self-preservation: false
      # 清理服务器
      eviction-interval-timer-in-ms: 5000
  client:
    healthcheck:
      enabled: true
    service-url:
      defaultZone: http://root:booszy@localhost:8761/eureka/
    register-with-eureka: false
    fetch-registry: false
spring:
  security:
    basic:
      enabled: true
    user:
      name: root
      password: booszy

 

3.修改程序的主类，建议修改类名，要加如eureka的 @EnableEurekaServer 注解，然后运行main方法。

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

 

http://localhost:8761/ 这个是eureka-server的页面地址，密码在yml配置文件中，到这里，说明eureka-server搭建好了，简单吧，这一步一定要成功，否则后面的就不能继续进行下去了，后边基本类似。

2、搭建config-server服务sc-config-server

springcloud-config-server是用来将远程git仓库的配置文件动态拉下来，这样配置文件就可以动态的维护了。当然也可以选择本地仓库。

新建一个springboot项目，修改maven私服地址，并加入一下依赖。

1.修改build.gradle文件

2.修改application.yml文件

server:
  port: 8800
spring:
  security:
    basic:
      enabled: true
    user:
      name: root
      password: booszy
  application:
    name: sc-config-server
  cloud:
    config:
      server:
        git:
          uri: https://git.coding.net/yirenyishi/springcloud-config-profile
          searchPaths: '{application}'
eureka:
  client:
    service-url:
      defaultZone: http://root:booszy@localhost:8761/eureka/
  instance:
    prefer-ip-address: true
    instance-id: ${spring.application.name}:${spring.application.instance_id:${server.port}}
    appname: sc-config-server

3.修改启动类

修改启动类，要加入这三个注解，因为要注册到eureka-server上，所以需要@EnableDiscoveryClient这个注解

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

后运行启动springboot项目，等启动成功后访问eureka的页面，会发现sc-config-server已经注册到上面了，如果启动报错，请检查错误信息。

 

3、搭建服务提供者服务sc-provider

编写一个服务提供者，为下边的消费者提供服务，用到了spring-webflux(spring新出的非阻塞式框架)不是springmvc，当然你们公司用什么你还是继续用什么。

注意 ： 这里除了application.xml,还需要一个bootstrap.yml, 因为bootstrap.yml得加载顺序是在application.xml前边,服务注册和config配置必须放到bootstrap.yml。

修改build.gradle文件

增加一个jcenter下会有junit的包

 

2.编写配置文件bootstrap.yml

* 注意 ： 这里除了application.xml,还需要一个bootstrap.yml

application.xml我是放到远程仓库地址的，大家可以直接到我的远程仓库，根据项目名（sc-provider-config）查询。配置文件的仓库地址：点击访问。

eureka:
  client:
    service-url:
      defaultZone: http://root:booszy@localhost:8761/eureka/
  instance:
    prefer-ip-address: true
    instance-id: ${spring.application.name}:${spring.application.instance_id:${server.port}}
    appname: sc-provider

spring:
  application:
    name: sc-provider
  cloud:
    config:
      discovery:
        enabled: true
        service-id: sc-config-server
      fail-fast: true
      username: root
      password: booszy
      profile: csdn

3.编写代码

编写主类

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

新建IndexController进行测试，这里只是为了测试，案例代码使用的是webflux，如果想使用springmvc，修改jar包依赖即可。

@RestController
@RequestMapping("test")
public class IndexController {
    //返回一个实体
    @GetMapping("{msg}")
    public Mono sayHelloWorld(@PathVariable("msg") String msg) {
        System.out.println("come on " + msg);
        return Mono.just("sc-provider receive : " +msg);
    }
    //返回一个列表
    @GetMapping("list")
    public Flux list() {
        List list = new ArrayList<>();
        list.add(8);
        list.add(22);
        list.add(75);
        list.add(93);
        Flux userFlux = Flux.fromIterable(list);
        return userFlux;
    }
}

运行springboot项目,去eureka-server查看，有没有注册上。

 

我们的sc-provider已经注册到eureka上了，访问接口，成功。

 

4、搭建消费者服务sc-consumer

消费者要访问服务提供者的服务，这里用的是通过RestTemplate/feign请求resetful接口，使用ribbon做客户端负载均衡，hystrix做错误处理，feign和ribbon二选一,案例中ribbon和feign都有，也可以都用。 
还是熟悉的配方，熟悉的味道，新建springboot项目，添加项目依赖。

1.修改build.gradle文件

compile('org.springframework.cloud:spring-cloud-starter-netflix-eureka-client')
compile('org.springframework.cloud:spring-cloud-starter-config')
compile('org.springframework.boot:spring-boot-starter-webflux')
compile('org.springframework.boot:spring-boot-starter-actuator')
compile('org.springframework.cloud:spring-cloud-starter-openfeign')
compile('org.springframework.cloud:spring-cloud-starter-netflix-hystrix')

2.修改bootstrap.yml文件

application.yml 在git仓库，请前往git仓库查看。

eureka:
  client:
    service-url:
      defaultZone: http://root:booszy@localhost:8761/eureka/
  instance:
    prefer-ip-address: true
    instance-id: ${spring.application.name}:${spring.application.instance_id:${server.port}}
    appname: sc-consumer

spring:
  application:
    name: sc-consumer
  cloud:
    config:
      discovery:
        enabled: true
        service-id: sc-config-server
      fail-fast: true
      username: root
      password: booszy
      profile: csdn
#新版配置，否则后面dashboard无法找到hystrix.stream
management:
  endpoints:
    web:
      exposure:
        include: '*'

3.编写代码

启动类代码

@RibbonClient 指定服务使用的负载均衡类型，name不指定服务则为所有的服务打开负载均衡，也可以在用yml中进行配置。 
@EnableHystrix 是支持hystrix打开断路器，在规定时间内失败参数超过一定参数，就会打开断路器，不会发起请求，而是直接进入到错误处理方法。

@EnableDiscoveryClient
@EnableFeignClients
@EnableCircuitBreaker
@EnableHystrix
@SpringBootApplication
public class Sb2scConsumerApplication {
    // ribbon需要配置，负载均衡
    @Autowired
    private RestTemplateBuilder builder;

    // ribbon需要配置，负载均衡
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return builder.build();
    }
    public static void main(String[] args) {
        SpringApplication.run(Sb2scConsumerApplication.class, args);
    }
}

1.ribbon案例

ribbon不需要单独依赖，新建 RibbonController 
ribbon一个坑，不能接受List类型，要使用数组接收。 
@HystrixCommand(fallbackMethod=”fallbackMethod”) 
如果请求失败，会进入fallbackMethod这个方法，fallbackMethod这个方法要求参数和返回值与回调他的方法保持一致。

@RestController
public class RibbonController {

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private LoadBalancerClient loadBalancerClient;

    @GetMapping("/ribbon/{wd}")
    @HystrixCommand(fallbackMethod="fallbackMethod")
    public Mono sayHelloWorld(@PathVariable("wd") String parm) {
        String res = this.restTemplate.getForObject("http://sc-provider/test/" + parm, String.class);
        return Mono.just(res);
    }

    public Mono fallbackMethod(@PathVariable("wd") String parm) {
        return Mono.just("fallback");
    }

运行springboot项目，先看有没有注册到eureka-server上。 

注册成功后，访问接口，测试是否正确。

ribbon使用就是这么简单，ribbon是springboot自带，所以不需要单独添加依赖。

2.feign案例

在实际开发中，feign使用的还是挺多的，feign底层还是使用了ribbon。废话不多说，直接上步骤，在服务消费者中使用feign访问服务提供者。

1配置文件

ribbon:
  ReadTimeout:  30000
  ConnectTimeout:  15000
hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 10000

feign的默认请求超时时间是1s，所以经常会出现超时的问题，这里我设置的是10s，因为我的数据库服务器在美国，所以有时候请求会比较慢。ribbon的请求时间也要设置，因为feign用的是ribbon。这里贴的是application.yml文件中的一小段

2 编码

1、主类注解

@EnableFeignClients 
@EnableCircuitBreaker 
@EnableHystrix

这三个都要，hystrix主要作用是断路器，会进如fein的fallback中。 主类代码在上面已经贴出来了

2、编写feign接口，MFeignClient.class

name是指要请求的服务名称。这里请求的是服务提供者 
fallback 是指请求失败，进入断路器的类，和使用ribbon是一样的。 
configuration 是feign的一些配置，例如编码器等。

@FeignClient(name = "sc-provider",fallback = MFeignClientFallback.class, configuration = MFeignConfig.class)
public interface MFeignClient {
    // 这是被请求微服务的地址，也就是provider的地址
    @GetMapping(value = "/test/{msg}")
    String sayHelloWorld(@PathVariable("msg") String msg);

    @GetMapping(value = "/test/list")
    List list();

    @GetMapping(value = "/test/list")
    Integer[] array();
}

3 MFeignConfig.class feign的配置

这里配置了feign的打印日志等级

@Configuration
public class MFeignConfig {
    @Bean
    Logger.Level feignLoggerLevel() {
        return Logger.Level.FULL;
    }
}

4 MFeignClientFallback.class ，断路器回调方法

断路器要实现上边定义的MFeignClient接口，请求失败，进入断路器时，会回调这里的方法。

@Component
public class MFeignClientFallback implements MFeignClient{
    @Override
    public String sayHelloWorld(String msg) {
        return "fallback";
    }

    @Override
    public List list() {
        return new ArrayList<>();
    }

    @Override
    public Integer[] array() {
        return new Integer[0];
    }
}

5 在controller中使用feign

@RestController
public class FeignController {

    @Autowired
    private MFeignClient feignClient;

    @GetMapping("/feign/{wd}")
    public Mono sayHelloWorld(@PathVariable("wd") String parm) {
        String result = feignClient.sayHelloWorld(parm);
        return Mono.just(result);
    }

    @GetMapping("/feign/list")
    public Flux list() {
        List list = feignClient.list();
        Flux userFlux = Flux.fromIterable(list);
        return userFlux;
    }

    @GetMapping("/feign/array")
    public Flux array() {
        Integer[] arrays = feignClient.array();
        Flux userFlux = Flux.fromArray(arrays);
        return userFlux;
    }
}

5、用zuul做路由转发和负载均衡

这些微服务都是隐藏在后端的，用户是看不到，或者不是直接接触，可以用nginx或者zuul进行路由转发和负载均衡，zuul负载均衡默认用的是ribbon。

1.修改build.gradle文件

    compile('org.springframework.cloud:spring-cloud-starter-netflix-eureka-client')
    compile('org.springframework.cloud:spring-cloud-starter-config')
    compile('org.springframework.cloud:spring-cloud-starter-netflix-zuul')
    compile('org.springframework.boot:spring-boot-starter-actuator')

2.修改bootstrap.yml

还是原来的配方，application.yml在git仓库

eureka:
  client:
    service-url:
      defaultZone: http://root:booszy@localhost:8761/eureka/
  instance:
    prefer-ip-address: true
    instance-id: ${spring.application.name}:${spring.application.instance_id:${server.port}}
    appname: sc-zuul

spring:
  application:
    name: sc-zuul
  cloud:
    config:
      discovery:
        enabled: true
        service-id: sc-config-server
      fail-fast: true
      username: root
      password: booszy
      profile: csdn

3.启动类

@RefreshScope这个注解是当application.yml配置文件发生变化的时候，不需要手动的进行重启，调用localhost:8400/refresh,就会加载新的配置文件，当然正在访问的客户并不影响还是使用旧的配置文件，因为不是重启，后来的用户会使用新的配置文件。注意这块的刷新要用post请求。

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

启动springboot项目，访问eureka-server 

这时候，我们就要通过zuul访问微服务了，而不是直接去访问微服务。 
应该访问地址http://localhost:8400/sc-consumer/feign/list，这块你要换成你的zuul地址。

但是有些人就会说，这样以后用户请求会不会太长，比较反感，所以可以通过配置进行修改访问地址。

zuul:
  routes:
    springcloud-consumer-config: /consumer/**
    springcloud-provider-config: /provider/**

在application.yml中加入这样一段配置，其实就是nginx中的反向代理，使用一下简短的可以代理这个微服务。这个时候我们就可以这样去访问了http://localhost:8400/consumer/feign/list，是不是简短了很多 

6、用hystrix-turbine-dashboard 做集群监控

项目在生产环境中，每个服务的访问量都不通，有些服务的访问量比较大，有时候有些服务挂了，不能继续服务，需要重启的时候，我们并不知道，所以这时候就需要使用hystrix-turbine-dashboard做一个监控，监控所有的微服务，可以看到这个接口实时访问量，和健康状况。 
新建一个springboot项目，老套路，加入如下依赖

1 添加依赖

compile('org.springframework.cloud:spring-cloud-starter-netflix-eureka-client')
compile('org.springframework.boot:spring-boot-starter-actuator')
compile('org.springframework.cloud:spring-cloud-starter-netflix-hystrix')
compile('org.springframework.cloud:spring-cloud-starter-netflix-hystrix-dashboard')
compile('org.springframework.cloud:spring-cloud-starter-netflix-turbine')

2 修改application.yml配置文件 
注意：是application.yml，这里不需要bootstrap.yml

server:
  port: 8900
eureka:
  client:
    service-url:
      defaultZone: http://root:booszy@localhost:8761/eureka/
  instance:
    prefer-ip-address: true
    instance-id: ${spring.application.name}:${spring.application.instance_id:${server.port}}
    appname: sc-dashboard
turbine:
  aggregator:
    clusterConfig: default
  appConfig: sc-consumer
  clusterNameExpression: "'default'"
spring:
  application:
    name: sc-dashboard
#management:
#  endpoints:
#    web:
#      exposure:
#        include: '*'

appConfig 后面是要检测的注册在eureka上的服务名，必须要有

3 修改主类

@EnableTurbine ，@EnableHystrixDashboard 一个都不能少

@EnableDiscoveryClient
@SpringBootApplication
@EnableTurbine
@EnableHystrixDashboard
public class Sb2scDashboardApplication {
    public static void main(String[] args) {
        SpringApplication.run(Sb2scDashboardApplication.class, args);
    }
}

4 访问测试

这块的端口是8900，访问地址http://localhost:8900/hystrix，看到的是下面的页面。 

然后在那个网址的输入框里输网址http://localhost:8900/turbine.stream，点击monitor stream。刚打开的时候可能是空的，什么也没有，这并不表示你已经错了。这时候你访问消费者服务的接口，例如访问http://localhost:8400/consumer/feign/list，多访问几次，然后看控制台有没有出现一个监控面板，没有就等会刷新一次，如果一直不出现，应该是配置有问题。

7、使用sleuth+zipkin 实现链路追踪服务

在使用微服务的时候，我们发现，有时候排错不好排查，所以就给大家整个这个链路追踪，很方便知道是哪一个服务调用哪一个服务出现了问题。因为有些项目可能服务比较多。

1 添加依赖

新建一个springboot项目 
虽然其他服务调用zipkin不是从eureka上动态过去服务地址，而是硬编码，但是这块还是考虑吧zipkin注册到eureka上。

如果提示log4j有冲突，要排除依赖

configurations {
    compile.exclude module: 'log4j'
    compile.exclude module: 'slf4j-log4j12'
    compile.exclude module: 'spring-boot-starter-logging'
}

2 修改application配置文件

server:
  port: 9411
spring:
  application:
    name: sc-sc-zipkin
  profiles:
    active: csdn
eureka:
  client:
    service-url:
      defaultZone: http://root:booszy@localhost:8761/eureka/
  instance:
    prefer-ip-address: true
    instance-id: ${spring.application.name}:${spring.application.instance_id:${server.port}}
    appname: sc-zipkin
management:
  metrics:
    web:
      server:
        auto-time-requests: false

3 主类注解添加

@EnableZipkinServer 主要是这个注解 
启动服务后访问http://localhost:9411,就可以打开zipkin的控制台页面，这时候应该是什么都没有

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

4 其他服务中调用

这里我们在消费者服务和提供者服务里都加入如下依赖

compile('org.springframework.cloud:spring-cloud-starter-sleuth')
compile('org.springframework.cloud:spring-cloud-starter-zipkin')

然后修改配置文件，bootstrap.yml、 
这块zipkin的地址是硬编码的，目前还没发现怎么从服务注册中心eureka上动态获取，以后有解决方案，会更新帖子 
sleuth这个是配置提取率，可以配置也可以不配置

spring:
  zipkin:
    base-url: http://localhost:9411
  sleuth:
    sampler:
      percentage: 1.0

启动服务，然后访问消费者服务的接口，这时候访问zipkin的控制台http://localhost:9411

点击依赖分析，可以看到调用服务链，因为这块只涉及到两个服务，所以只有两个，在实际生产环境中，这块可能有很多，到时候看起来就特别直观了。