转载

在微服务领域Spring Boot自动伸缩如何实现

自动伸缩是每个人都想要的，尤其是在微服务领域。让我们看看如何在基于Spring Boot的应用程序中实现。

我们决定使用 Kubernetes 、 Pivotal Cloud Foundry 或 HashiCorp's Nomad 等工具的一个更重要的原因是为了让系统可以自动伸缩。当然，这些工具也提供了许多其他有用的功能，在这里，我们只是用它们来实现系统的自动伸缩。乍一看，这似乎很困难，但是，如果我们使用 Spring Boot 来构建应用程序，并使用 Jenkins 来实现 CI ，那么就用不了太多工作。

今天，我将向您展示如何使用以下框架/工具实现这样的解决方案：

Spring Boot
Spring Boot Actuator
Spring Cloud Netflix Eureka
Jenkins CI

它是如何工作的

每一个包含 Spring Boot Actuator 库的 Spring Boot 应用程序都可以在 /actuator/metrics 端点下公开 metric 。许多有价值的 metric 都可以提供应用程序运行状态的详细信息。在讨论自动伸缩时，其中一些 metric 可能特别重要： JVM 、CPU metric 、正在运行的线程数和HTTP请求数。有专门的 Jenkins 流水线通过按一定频率轮询 /actuator/metrics 端点来获取应用程序的指标。如果监控的任何 metric 【指标】低于或高于目标范围，则它会启动新实例或使用另一个 Actuator 端点 /actuator/shutdown 来关闭一些正在运行的实例。在此之前，我们需要知道当前有那些实践在提供服务，只有这样我们才能在需要的时候关闭空闲的实例或启动新的新例。

在微服务领域Spring Boot自动伸缩如何实现在讨论了系统架构之后，我们就可以继续开发了。这个应用程序需要满足以下要求：它必须有公开的可以优雅地关闭应用程序和用来获取应用程序运行状态 metric 【指标】的端点，它需要在启动完成的同时就完成在Eureka的注册，在关闭时取消注册，最后，它还应该能够从空闲端口池中随机获取一个可用的端口。感谢 Spring Boot ，只需要约五分钟，我们可以轻松地实现所有这些机制。

动态端口分配

由于可以在一台机器上运行多个应用程序实例，所以我们必须保证端口号不冲突。幸运的是， Spring Boot 为应用程序提供了这样的机制。我们只需要将 application.yml 中的 server.port 属性设置为 0 。因为我们的应用程序会在 Eureka 中注册，并且发送唯一的标识 instanceId ，默认情况下这个唯一标识是将字段 spring.cloud.client.hostname , spring.application.name 和 server.port 拼接而成的。

示例应用程序的当前配置如下所示。

可以看到，我通过将端口号替换为随机生成的数字来改变了生成 instanceId 字段值的模板。

spring:
  application:
    name: example-service
server:
  port: ${PORT:0}
eureka:
  instance:
    instanceId: ${spring.cloud.client.hostname}:${spring.application.name}:${random.int[1,999999]}

启用Actuator的Metric

为了启用 Spring Boot Actuator ，我们需要将下面的依赖添加到 pom.xml 。

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

我们还必须通过HTTP API将属性 management.endpoints.web.exposure.include 设置为 '*' 来暴露 Actuator 的端点。现在，所有可用的指标名称列表都可以在 /actuator/metrics 端点中找到，每个指标的详细信息可以通过 /actuator/metrics/{metricName} 端点查看。

优雅地停止应用程序

除了查看 metric 端点外， Spring Boot Actuator 还提供了停止应用程序的端点。然而，与其他端点不同的是，缺省情况下，此端点是不可用的。我们必须把 management.endpoint.shutdown.enabled 设为 true 。在那之后，我们就可以通过发送一个 POST 请求到 /actuator/shutdown 端点来停止应用程序了。

这种停止应用程序的方法保证了服务在停止之前从 Eureka 服务器注销。

启用Eureka自动发现

Eureka 是最受欢迎的发现服务器，特别是使用 Spring Cloud 来构建微服务的架构。所以，如果你已经有了微服务，并且想要为他们提供自动伸缩机制，那么 Eureka 将是一个自然的选择。它包含每个应用程序注册实例的IP地址和端口号。为了启用 Eureka 客户端，您只需要将下面的依赖项添加到 pom.xml 中。

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

正如之前提到的，我们还必须保证通过客户端应用程序发送到 Eureka 服务器的 instanceId 的唯一性。在“动态端口分配”中已经描述了它。

下一步需要创建一个包含内嵌 Eureka 服务器的应用程序。为了实现这个功能，首先我们需要在 pom.xml 中添加下面这个依赖：

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

这个 main类 需要添加 @EnableEurekaServer 注解。

@SpringBootApplication
@EnableEurekaServer
public class DiscoveryApp {
    public static void main(String[] args) {
        new SpringApplicationBuilder(DiscoveryApp.class).run(args);
    }
}

默认情况下，客户端应用程序尝试使用 8761 端口连接 Eureka 服务器。我们只需要单独的、独立的 Eureka 节点，因此我们将禁用注册，并尝试从另一个 Eureka 服务器实例中获取服务列表。

spring:
  application:
    name: discovery-service
server:
  port: ${PORT:8761}
eureka:
  instance:
    hostname: localhost
  client:
    registerWithEureka: false
    fetchRegistry: false
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

我们将使用 Docker 容器来测试上面的自动伸缩系统，因此需要使用 Eureka 服务器来准备和构建 image 。

Dockerfile 和 image 的定义如下所示。

我们可以使用命令 docker build -t piomin/discovery-server:2.0 来进行构建。

FROM openjdk:8-jre-alpine
ENV APP_FILE discovery-service-1.0-SNAPSHOT.jar
ENV APP_HOME /usr/apps
EXPOSE 8761
COPY target/$APP_FILE $APP_HOME/
WORKDIR $APP_HOME
ENTRYPOINT ["sh", "-c"]
CMD ["exec java -jar $APP_FILE"]

为弹性伸缩构建一个Jenkins流水线

第一步是准备 Jenkins 流水线，负责自动伸缩。我们将创建 Jenkins 声明式流水线，它每分钟运行一次。可以使用 triggers 指令配置执行周期，它定义了自动化触发流水线的方法。我们的流水线将与 Eureka 服务器和每个使用 Spring Boot Actuator 的微服务中公开的 metric 端点进行通信。

测试服务的名称是 EXAMPLE-SERVICE ，它和定义在 application.yml 文件 spring.application.name 的属性值（大写字母）相同。被监控的 metric 是运行在Tomcat容器中的HTTP listener 线程数。这些线程负责处理客户端的HTTP请求。

pipeline {
    agent any
    triggers {
        cron('* * * * *')
    }
    environment {
        SERVICE_NAME = "EXAMPLE-SERVICE"
        METRICS_ENDPOINT = "/actuator/metrics/tomcat.threads.busy?tag=name:http-nio-auto-1"
        SHUTDOWN_ENDPOINT = "/actuator/shutdown"
    }
    stages { ... }
}

使用Eureka整合Jenkins流水线

流水线的第一个阶段负责获取在 discovery 服务器上注册的服务列表。 Eureka 发现了几个HTTP API端点。其中一个是 GET /eureka/apps/{serviceName} ，它返回一个给定服务名称的所有活动实例列表。我们正在保存运行实例的数量和每个实例 metric 端点的URL。这些值将在流水线的下一个阶段中被访问。

下面的流水线片段可以用来获取活动应用程序实例列表。 stage 名称是 Calculate 。我们使用 HTTP请求插件来发起HTTP连接。

stage('Calculate') {
 steps {
  script {
   def response = httpRequest "http://192.168.99.100:8761/eureka/apps/${env.SERVICE_NAME}"
   def app = printXml(response.content)
   def index = 0
   env["INSTANCE_COUNT"] = app.instance.size()
   app.instance.each {
    if (it.status == 'UP') {
     def address = "http://${it.ipAddr}:${it.port}"
     env["INSTANCE_${index++}"] = address
    }
   }
  }
 }
}
@NonCPS
def printXml(String text) {
 return new XmlSlurper(false, false).parseText(text)
}

下面是 Eureka API对我们的微服务的示例响应。响应 content-type 是 XML 。

在微服务领域Spring Boot自动伸缩如何实现

使用Spring Boot Actuator整合Jenkins流水线

Spring Boot Actuator 使用 metric 来公开端点，这使得我们可以通过名称和选择性地使用标签找到 metric 。在下面可见的流水线片段中，我试图找到 metric 低于或高于阈值的实例。如果有这样的实例，我们就停止循环，以便进入下一个阶段，它执行向下或向上的伸缩。应用程序的IP地址是从带有 INSTANCE_ 前缀的流水线环境变量获取的，这是在前一阶段中被保存了下来的。

stage('Metrics') {
steps {
script {
def count = env.INSTANCE_COUNT
for(def i=0;i 100)
return "UP"
else if (value.toInteger() < 20)
return "DOWN"
else
return "NONE"
}

关闭应用程序实例

在流水线的最后一个阶段，我们将关闭运行的实例，或者根据在前一阶段保存的结果启动新的实例。通过调用 Spring Boot Actuator 端点可以很容易执行停止操作。在接下来的流水线片段中，首先选择了 Eureka 实例。然后我们将发送 POST 请求到那个ip地址。

如果需要扩展应用程序，我们将调用另一个流水线，它负责构建 fat JAR 并让这个应用程序在机器上跑起来。

stage('Scaling') {
 steps {
  script {
   if (env.SCALE_TYPE == 'DOWN') {
    def ip = env["INSTANCE_0"] + env.SHUTDOWN_ENDPOINT
    httpRequest url: ip, contentType: 'APPLICATION_JSON', httpMode: 'POST'
   } else if (env.SCALE_TYPE == 'UP') {
    build job: 'spring-boot-run-pipeline'
   }
   currentBuild.description = env.SCALE_TYPE
  }
 }
}

下面是 spring-boot-run-pipeline 流水线的完整定义，它负责启动应用程序的新实例。它先从 git 仓库中拉取源代码，然后使用 Maven 命令编译并构建二进制的jar文件，最后通过在 java -jar 命令中添加 Eureka 服务器地址来运行应用程序。

pipeline {
    agent any
    tools {
        maven 'M3'
    }
    stages {
        stage('Checkout') {
            steps {
                git url: 'https://github.com/piomin/sample-spring-boot-autoscaler.git', credentialsId: 'github-piomin', branch: 'master'
            }
        }
        stage('Build') {
            steps {
                dir('example-service') {
                    sh 'mvn clean package'
                }
            }
        }
        stage('Run') {
            steps {
                dir('example-service') {
                    sh 'nohup java -jar -DEUREKA_URL=http://192.168.99.100:8761/eureka target/example-service-1.0-SNAPSHOT.jar 1>/dev/null 2>logs/runlog &'
                }
            }
        }
    }
}

扩展到多个机器

在前几节中讨论的算法只适用于在单个机器上启动的微服务。如果希望将它扩展到更多的机器上，我们将不得不修改我们的架构，如下所示。每台机器都有 Jenkins 代理运行并与 Jenkins master通信。如果想在选定的机器上启动一个微服务的新实例，我们就必须使用运行在该机器上的代理来运行流水线。此代理仅负责从源代码构建应用程序并将其启动到目标机器上。这个实例的关闭仍然是通过调用HTTP端点来完成。

在微服务领域Spring Boot自动伸缩如何实现

假设我们已经成功地在目标机器上启动了一些代理，我们需要对流水线进行参数化，以便能够动态地选择代理（以及目标机器）。

当扩容应用程序时，我们必须将代理标签传递给下游流水线。

build job:'spring-boot-run-pipeline', parameters:[string(name: 'agent', value:"slave-1")]

调用 流水线具体由那个标签下的代理运行，是由" ${params.agent} "决定的。

pipeline {
    agent {
        label "${params.agent}"
    }
    stages { ... }
}

如果有一个以上的代理连接到主节点，我们就可以将它们的地址映射到标签中。由于这一点，我们能够将从 Eureka 服务器获取的微服务实例的IP地址映射到与 Jenkins 代理的目标机器上。

pipeline {
    agent any
    triggers {
        cron('* * * * *')
    }
    environment {
        SERVICE_NAME = "EXAMPLE-SERVICE"
        METRICS_ENDPOINT = "/actuator/metrics/tomcat.threads.busy?tag=name:http-nio-auto-1"
        SHUTDOWN_ENDPOINT = "/actuator/shutdown"
        AGENT_192.168.99.102 = "slave-1"
        AGENT_192.168.99.103 = "slave-2"
    }
    stages { ... }
}

总结

在本文中，我演示了如何使用 Spring Boot Actuato metric 来自动伸缩 Spring Boot 应用程序。使用 Spring Boot 提供的特性以及 Spring Cloud Netflix Eureka 和 Jenkins ，您就可以实现系统的自动伸缩，而无需借助于任何其他第三方工具。本文也假设远程服务器上也是使用 Jenkins 代理来启动新的实例，但是您也可以使用 Ansible 这样的工具来启动。如果您决定从 Jenkins 运行 Ansible 脚本，那么将不需要在远程机器上启动 Jenkins 代理。