服务雪崩、服务限流、服务熔断和服务降级

原创

青山师

修改于 2023-04-28 11:21:40

9300

修改于 2023-04-28 11:21:40

文章被收录于专栏：IT当时语_青山师_JAVA技术栈IT当时语_青山师_JAVA技术栈

服务雪崩、服务限流、服务熔断和服务降级

在分布式系统中，由于网络延迟、节点宕机等各种原因，会出现一些异常情况，如某个服务的响应时间变慢或者宕机。这时候如果不采取措施，可能导致整个系统的性能下降或者不可用。本文主要介绍如何使用服务雪崩、服务限流、服务熔断和服务降级等技术手段来解决这些异常情况。

服务雪崩

服务雪崩是指一个服务的不可用导致了其他服务也不可用，最终导致整个系统崩溃。通常发生在高并发场景下，例如秒杀活动、双十一购物节等。

解决方案及代码实践

针对服务雪崩的解决方案有：

限流：限制请求流量，防止瞬间请求过多的服务挤爆后端服务。
缓存：对于频繁读取的数据和结果进行缓存以减轻服务压力，并且通过缓存预热使得系统更加健壮。
超时重试：避免长时间等待请求超时，通过设置合理的超时时间并实现自动重试，可以减轻服务压力。
回退策略：在上游服务不可用的情况下，及时切换到备份方案，避免导致整个系统不可用。

以Spring Cloud为例，在实现限流、缓存、超时重试和回退策略时可以使用以下组件：

限流：可以使用Netflix的Hystrix组件进行熔断、降级、隔离和限流。
缓存：可以使用Redis等高性能缓存数据库，Spring Boot中提供了对多种缓存库的支持。
超时重试：可以使用Feign客户端和Netflix的Ribbon负载均衡器来设置超时时间并实现自动重试。
回退策略：可以使用Spring Cloud Config Server中心化管理配置信息，通过快速更改服务策略实现灰度升级或撤销操作。

限流

Spring Cloud中可以使用Netflix的Hystrix组件来实现限流功能。Hystrix通过熔断、降级、隔离和限流等机制来保护后端服务的稳定性。

步骤1：添加Hystrix依赖

在POM文件中添加Hystrix依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

步骤2：创建HystrixCommand

在需要进行限流的服务上添加@HystrixCommand注解，并实现对应的HystrixCommand类。HystrixCommand类需要继承HystrixCommand或HystrixObservableCommand类，并实现run()和fallback()方法。

run()方法：表示当服务正常调用时执行的逻辑。
fallback()方法：表示当服务调用失败时执行的逻辑。

例如，我们可以创建一个HelloService：

@Service
public class HelloService {
    
    @Autowired
    private RestTemplate restTemplate;
    
    @HystrixCommand(fallbackMethod = "helloFallback")
    public String hello() {
        return restTemplate.getForObject("http://service-provider/hello", String.class);
    }
    
    public String helloFallback() {
        return "hello world fallback";
    }
}

这里我们通过RestTemplate调用了另一个服务提供者的hello接口，并在hello方法上加了@HystrixCommand注解，指定了fallback方法为helloFallback()。

步骤3：配置Hystrix

在application.yml文件中添加以下配置：

hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 5000 # 超时时间
      circuitBreaker:
        requestVolumeThreshold: 10 # 请求阈值，超过这个阈值才会进行熔断计算
        sleepWindowInMilliseconds: 10000 # 熔断器打开后多长时间进入半开状态，尝试恢复调用服务的机会
        errorThresholdPercentage: 50 # 错误率，当错误率达到了这个值，将触发熔断

这里我们设置了超时时间、请求阈值、睡眠窗口和错误率等参数。这些参数可以根据实际情况进行调整。

缓存

Spring Cloud中提供了对多种缓存库的支持，如Redis、Ehcache等。

步骤1：添加依赖

在POM文件中添加相应的缓存库的依赖，如下所示：

<!-- Redis缓存 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<!-- Ehcache缓存 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

步骤2：配置缓存

在application.yml文件中配置缓存相关信息，如下所示：

spring:
  redis:
    host: localhost
    port: 6379
    password: 
    timeout: 10000
  cache:
    type: redis # 设置使用Redis作为缓存库

步骤3：使用缓存

在需要使用缓存的方法上添加@Cacheable注解即可。例如，我们可以将获取用户信息的方法进行缓存处理：

@Service
public class UserService {
    
    @Cacheable(value = "userCache", key = "#id")
    public User getUserById(Long id) {
        // 从数据库中查询用户信息
        return userRepository.findById(id).orElse(null);
    }
}

这里我们通过@Cacheable注解指定了缓存名称和缓存key，当同样的请求再次到达时就会从缓存中获取数据，从而提高服务的响应速度和性能。

超时重试

Spring Cloud中可以使用Feign客户端和Netflix的Ribbon负载均衡器来设置超时时间并实现自动重试。

步骤1：添加依赖

在POM文件中添加Feign和Ribbon依赖，如下所示：

<!-- Feign客户端 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

<!-- Ribbon负载均衡器 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>

步骤2：配置超时和重试策略

在application.yml文件中添加以下配置：

feign:
  client:
    config:
      default:
        connectTimeout: 5000 # 连接超时时间
        readTimeout: 5000 # 读取超时时间

ribbon:
  ConnectTimeout: 5000 # 连接超时时间
  ReadTimeout: 5000 # 读取超时时间
  MaxAutoRetriesNextServer: 3 # 最大重试次数
  MaxAutoRetries: 0 # 每个服务节点最大重试次数

这里我们设置了连接超时时间、读取超时时间和重试策略等参数。

步骤3：使用Feign客户端调用服务

在Feign客户端中添加相关的注解，例如：

@FeignClient("service-provider")
public interface HelloService {
    
    @GetMapping("/hello")
    String hello();
}

在需要调用服务的地方直接使用HelloService即可。

回退策略

Spring Cloud中可以使用Spring Cloud Config Server来实现回退策略。Config Server提供了中心化管理配置信息的能力，可以快速更改服务策略实现灰度升级或撤销操作。

步骤1：创建Spring Cloud Config Server

在POM文件中添加Spring Cloud Config Server依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-config-server</artifactId>
</dependency>

在启动类上添加@EnableConfigServer注解，开启Config Server功能。

在application.yml文件中配置Config Server相关信息，如下所示：

server:
  port: 8888

spring:
  cloud:
    config:
      server:
        git:
          uri: https://github.com/${GITHUB_ACCOUNT}/${REPO_NAME}

这里我们将配置信息存储在GitHub仓库中，通过uri指定仓库地址。

步骤2：创建Config Client

在需要使用配置信息的服务中添加Spring Cloud Config Client依赖和注解，如下所示：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>

配置信息：

spring:
  cloud:
    config:
      uri: http://localhost:8888 # Config Server的地址

hello:
  message: ${config.message:Hello world} # 读取Config Server中的配置信息

这里我们指定了Config Server的地址，并通过${config.xxx}的方式来读取配置信息。

步骤3：访问Spring Cloud Config Server

启动Config Server和Config Client后，在浏览器中访问http://localhost:8888/{application}/{profile}/{label}即可查看配置信息。

例如，访问http://localhost:8888/service-provider/default/master可以查看service-provider服务在default环境下的master分支上的所有配置信息。

步骤4：手动更改服务策略

在GitHub仓库中修改对应服务的配置信息，然后刷新Config Client即可实现实时更改服务策略。

步骤5：实现灰度升级

为了实现灰度升级，我们可以将不同版本的配置信息存储在不同的分支中，例如：

1.0.x分支：存储1.0版本的配置信息。
1.1.x分支：存储1.1版本的配置信息。

然后，在服务启动时读取对应分支的配置信息即可。例如：

spring:
  cloud:
    config:
      uri: http://localhost:8888 # Config Server的地址
      label: 1.1.x # 配置信息存储在1.1.x分支中

这样就可以在不停服的情况下实现灰度升级，从而保证服务的高可用性和稳定性。

步骤6：实现撤销操作

为了实现撤销操作，我们可以将当前稳定版本的配置信息存储在一个特定的分支中，例如：

stable分支：存储当前稳定版本的配置信息。

然后，在需要进行撤销操作时，将当前的配置信息替换为stable分支的配置信息即可。例如：

spring:
  cloud:
    config:
      uri: http://localhost:8888 # Config Server的地址
      label: stable # 配置信息存储在stable分支中

这样就可以在不停服的情况下实现快速撤销操作，从而避免因错误配置信息导致的生产事故。

综上所述，Spring Cloud提供了丰富的组件来帮助我们实现限流、缓存、超时重试和回退策略等功能。我们只需要按照步骤配置即可轻松集成这些组件，从而提高服务的稳定性、响应速度和性能。

服务限流

服务限流是指限制请求流量，以保护后端服务的稳定性。通常是通过设置请求速率、同时请求数、并发请求数等方式来限制服务的容量。

解决方案及代码实践

针对服务限流的解决方案有：

令牌桶算法：在一个固定容量的桶内存储一定数量的请求令牌，每个请求需要获取一个令牌才能执行，请求完成则释放令牌以供其他请求使用。
漏桶算法：在一个固定容量的桶中不断加入请求，请求会从桶底部以常量速率流出，当桶满时即拒绝请求。
计数器算法：设置请求速率、同时请求数、并发请求数等参数，并实现监控和统计服务。

以Netflix的Hystrix组件为例，可以通过以下方法实现服务限流：

在HystrixCommand或HystrixObservableCommand中使用Semaphore或线程池隔离机制来限制并发请求数。
针对调用频繁的服务，使用HystrixCircuitBreaker熔断器进行自动熔断处理。
使用HystrixThreadPoolProperties配置线程池大小，防止后端服务过载。

使用Semaphore或线程池隔离机制来限制并发请求数

在高并发场景下，系统资源有限，线程超过阈值会导致系统瘫痪或响应变慢。Semaphore或线程池隔离机制可以控制并发请求数量，避免因线程资源过度占用而导致的性能问题。

public class MyCommand extends HystrixCommand<String> {
    private final HttpClient httpClient;
    private final String url;
    private final Semaphore semaphore;
    public MyCommand(HttpClient httpClient, String url, Semaphore semaphore) {
        super(Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("MyGroup")).andCommandKey(HystrixCommandKey.Factory.asKey("MyCommand")));
        this.httpClient = httpClient;
        this.url = url;
        this.semaphore = semaphore;
    }
    @Override
    protected String run() throws Exception {
        semaphore.acquire();
        try {
            return httpClient.get(url);
        } finally {
            semaphore.release();
        }
    }
}

使用线程池隔离机制实现限流

public class MyCommand extends HystrixCommand<String> {
    private final HttpClient httpClient;
    private final String url;
    public MyCommand(HttpClient httpClient, String url) {
        super(Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("MyGroup")).andCommandKey(HystrixCommandKey.Factory.asKey("MyCommand")).andThreadPoolKey(HystrixThreadPoolKey.Factory.asKey("MyThreadPool")));
        this.httpClient = httpClient;
        this.url = url;
    }
    @Override
    protected String run() throws Exception {
        return httpClient.get(url);
    }
    @Override
    protected HystrixThreadPoolProperties.Setter getThreadPoolProperties() {
        HystrixThreadPoolProperties.Setter setter = HystrixThreadPoolProperties.Setter();
        setter.withCoreSize(10);
        return setter;
    }
}

使用HystrixCircuitBreaker熔断器进行自动熔断处理

熔断是一种自我保护机制，当服务超过预设的阈值时，断开或降级服务，避免资源占用或进一步的错误扩散

public class MyCommand extends HystrixCommand<String> {
    private final HttpClient httpClient;
    private final String url;
    public MyCommand(HttpClient httpClient, String url) {
        super(Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("MyGroup")).andCommandKey(HystrixCommandKey.Factory.asKey("MyCommand")).andThreadPoolKey(HystrixThreadPoolKey.Factory.asKey("MyThreadPool")));
        this.httpClient = httpClient;
        this.url = url;
    }
    @Override
    protected String run() throws Exception {
        return httpClient.get(url);
    }
    @Override
    protected HystrixCommandProperties.Setter getCommandProperties() {
        HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter();
        setter.withCircuitBreakerEnabled(true);
        setter.withCircuitBreakerRequestVolumeThreshold(10);
        setter.withCircuitBreakerErrorThresholdPercentage(50);
        setter.withCircuitBreakerSleepWindowInMilliseconds(5000);
        return setter;
    }
}

使用HystrixThreadPoolProperties配置线程池大小，防止后端服务过载

通过控制线程池的大小，确保系统正常运行，并避免因线程资源过度占用导致的性能问题。

public class MyCommand extends HystrixCommand<String> {
    private final HttpClient httpClient;
    private final String url;
    public MyCommand(HttpClient httpClient, String url) {
        super(Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("MyGroup")).andCommandKey(HystrixCommandKey.Factory.asKey("MyCommand")).andThreadPoolKey(HystrixThreadPoolKey.Factory.asKey("MyThreadPool")));
        this.httpClient = httpClient;
        this.url = url;
    }
    @Override
    protected String run() throws Exception {
        return httpClient.get(url);
    }
    @Override
    protected HystrixThreadPoolProperties.Setter getThreadPoolProperties() {
        HystrixThreadPoolProperties.Setter setter = HystrixThreadPoolProperties.Setter();
        setter.withCoreSize(10);
        setter.withMaxQueueSize(20);
        setter.withQueueSizeRejectionThreshold(10);
        return setter;
    }
}

服务熔断

服务熔断是指在一定时间内，如果服务的错误率或超时率达到一定阈值，则暂时关闭服务并快速返回错误结果，避免资源浪费和请求失败。通常是通过实时监控服务状态来实现服务熔断的。

解决方案及代码实践

针对服务熔断的解决方案有：

实时监控：对服务的状态进行实时监控，并设置阈值来判断是否需要进行熔断处理。
自动恢复：在熔断结束后，在一定时间范围内判断服务状态是否正常，如正常则自动恢复服务。
手动恢复：当服务被熔断后，需要手动触发对服务的检测和恢复操作。

以Spring Cloud中的Hystrix组件为例，可以通过以下方法实现服务熔断：

使用@HystrixCommand注解来声明熔断方法，并设置fallback方法。
在熔断方法中设置阈值、错误率等参数来触发服务熔断。
在fallback方法中返回默认结果或者使用备份方案来保证系统的稳定性。

服务降级

服务降级是指在异常情况下，将服务的功能进行缩减或者关闭部分功能，以保障主要功能的正常运行。通常是在服务出现瓶颈或者不可用时进行服务降级。

解决方案及代码实践

针对服务降级的解决方案有：

降级策略：设置合理的降级策略，例如从高优先级到低优先级依次关闭服务的某些功能。
备份方案：当服务不可用时，及时切换到备份方案或者提供默认结果保证系统的稳定性。
手动控制：通过调整配置信息实现手动控制服务的状态和功能。

以Spring Cloud中的Hystrix组件为例，可以通过以下方法实现服务降级：

在@HystrixCommand注解中设置fallbackMethod属性来指定服务的降级方法。
在降级方法中返回默认结果或者使用备份方案来保证系统的稳定性。
使用HystrixCommandGroupKey、HystrixCommandKey等配置Hystrix熔断器的相关参数。

以上是关于服务雪崩、服务限流、服务熔断和服务降级的内容介绍和解决方案。在实际开发过程中，我们需要根据具体业务场景和技术需求来选择合适的方案，加强架构设计和监控，提高服务的可靠性和稳定性。

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

spring cloud

feign

hystrix

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

登录后参与评论

0 条评论

热度

服务雪崩、服务限流、服务熔断和服务降级

服务雪崩、服务限流、服务熔断和服务降级

服务雪崩、服务限流、服务熔断和服务降级

服务雪崩

解决方案及代码实践

限流

步骤1：添加Hystrix依赖

步骤2：创建HystrixCommand

步骤3：配置Hystrix

缓存

步骤1：添加依赖

步骤2：配置缓存

步骤3：使用缓存

超时重试

步骤1：添加依赖

步骤2：配置超时和重试策略

步骤3：使用Feign客户端调用服务

回退策略

步骤1：创建Spring Cloud Config Server

步骤2：创建Config Client

步骤3：访问Spring Cloud Config Server

步骤4：手动更改服务策略

步骤5：实现灰度升级

步骤6：实现撤销操作

服务限流

解决方案及代码实践

使用Semaphore或线程池隔离机制来限制并发请求数

使用HystrixCircuitBreaker熔断器进行自动熔断处理

使用HystrixThreadPoolProperties配置线程池大小，防止后端服务过载

服务熔断

解决方案及代码实践

服务降级

解决方案及代码实践

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐