Apache Tomcat与TensorFlow Serving集成：机器学习模型部署

在当今的AI应用开发中，如何高效地将训练好的机器学习模型部署到生产环境是一个关键挑战。Apache Tomcat作为广泛使用的Servlet容器，为Java Web应用提供了稳定的运行环境，而TensorFlow Serving则是谷歌推出的专门用于机器学习模型部署的高性能框架。本文将详细介绍如何将这两者无缝集成，构建一个高效、可靠的模型服务系统。## 集成架构概述Tomcat与Tenso...

郭沁熙

579人浏览 · 2025-11-05 00:30:22

郭沁熙 · 2025-11-05 00:30:22 发布

Apache Tomcat与TensorFlow Serving集成：机器学习模型部署

【免费下载链接】tomcat Apache Tomcat 项目地址: https://gitcode.com/gh_mirrors/tomcat10/tomcat

集成架构概述

Tomcat与TensorFlow Serving的集成采用前后端分离的架构模式，Tomcat作为前端请求入口，负责接收客户端请求并进行初步处理，然后将模型推理请求转发给TensorFlow Serving，最后将推理结果返回给客户端。这种架构的优势在于：

利用Tomcat成熟的Web服务能力处理HTTP请求、会话管理和安全控制
借助TensorFlow Serving的专业模型管理和推理优化能力，提供高性能的模型服务
两者各司其职，既保证了Web服务的稳定性，又确保了模型推理的高效性

环境准备

在开始集成之前，需要准备以下环境和工具：

软件依赖

Java Development Kit (JDK) 11或更高版本
Apache Tomcat 10.x
TensorFlow Serving 2.8.0或更高版本
Maven 3.6.x（用于项目构建）

项目结构

建议采用以下项目结构组织代码：

tomcat-tensorflow-demo/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/
│   │   │       └── example/
│   │   │           ├── controller/  # 请求处理控制器
│   │   │           ├── service/     # 业务逻辑服务
│   │   │           ├── client/      # TensorFlow Serving客户端
│   │   │           └── model/       # 模型相关类
│   │   ├── webapp/
│   │   │   ├── WEB-INF/
│   │   │   │   ├── web.xml         # Web应用配置
│   │   │   │   └── tomcat-web.xml  # Tomcat特定配置
│   │   │   └── index.jsp           # 示例页面
│   └── test/                       # 单元测试代码
├── pom.xml                         # Maven项目配置
└── README.md                       # 项目说明文档

Tomcat配置

需要对Tomcat进行一些基本配置，以确保其能够处理模型服务相关的请求：

调整conf/server.xml中的连接超时和最大线程数：

<Connector port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443"
           maxThreads="200" />

配置conf/context.xml以启用异步处理支持：

<Context asyncSupported="true">
    <!-- 其他配置 -->
</Context>

官方配置文档：conf/context.xml

TensorFlow Serving配置与启动

模型准备

首先，需要将训练好的TensorFlow模型导出为SavedModel格式，并按照TensorFlow Serving要求的目录结构进行组织：

models/
├── mnist/
│   ├── 1/
│   │   ├── saved_model.pb
│   │   └── variables/
│   │       ├── variables.data-00000-of-00001
│   │       └── variables.index

启动TensorFlow Serving

使用以下命令启动TensorFlow Serving，加载模型并监听指定端口：

tensorflow_model_server --port=8500 --model_name=mnist --model_base_path=/path/to/models/mnist

Tomcat中创建模型服务客户端

添加依赖

在Maven项目的pom.xml中添加以下依赖，用于实现与TensorFlow Serving的通信：

<dependencies>
    <!-- Tomcat Servlet API -->
    <dependency>
        <groupId>jakarta.servlet</groupId>
        <artifactId>jakarta.servlet-api</artifactId>
        <version>5.0.0</version>
        <scope>provided</scope>
    </dependency>
    
    <!-- TensorFlow Serving gRPC客户端 -->
    <dependency>
        <groupId>io.grpc</groupId>
        <artifactId>grpc-netty-shaded</artifactId>
        <version>1.41.0</version>
    </dependency>
    <dependency>
        <groupId>io.grpc</groupId>
        <artifactId>grpc-protobuf</artifactId>
        <version>1.41.0</version>
    </dependency>
    <dependency>
        <groupId>io.grpc</groupId>
        <artifactId>grpc-stub</artifactId>
        <version>1.41.0</version>
    </dependency>
    
    <!-- JSON处理 -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.13.0</version>
    </dependency>
</dependencies>

Maven配置示例：res/maven/

创建TensorFlow Serving客户端

创建一个GRPC客户端类，用于与TensorFlow Serving进行通信：

package com.example.client;

import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import tensorflow.serving.PredictRequest;
import tensorflow.serving.PredictResponse;
import tensorflow.serving.PredictionServiceGrpc;
import org.tensorflow.framework.TensorProto;
import org.tensorflow.framework.TensorShapeProto;

import java.util.concurrent.TimeUnit;

public class TensorFlowServingClient {
    private final ManagedChannel channel;
    private final PredictionServiceGrpc.PredictionServiceBlockingStub blockingStub;
    
    public TensorFlowServingClient(String host, int port) {
        this.channel = ManagedChannelBuilder.forAddress(host, port)
                .usePlaintext()
                .build();
        this.blockingStub = PredictionServiceGrpc.newBlockingStub(channel);
    }
    
    public PredictResponse predict(PredictRequest request) {
        return blockingStub.predict(request);
    }
    
    public void shutdown() throws InterruptedException {
        channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
    }
    
    // 辅助方法：创建输入张量
    public static TensorProto createTensorProto(float[] data, int[] shape) {
        TensorShapeProto.Builder shapeBuilder = TensorShapeProto.newBuilder();
        for (int dim : shape) {
            shapeBuilder.addDim(TensorShapeProto.Dim.newBuilder().setSize(dim));
        }
        
        return TensorProto.newBuilder()
                .setDtype(org.tensorflow.framework.DataType.DT_FLOAT)
                .setTensorShape(shapeBuilder.build())
                .addFloatVal(data)
                .build();
    }
}

创建Servlet处理模型请求

模型服务Servlet

创建一个Servlet，作为模型服务的入口点，接收客户端请求并调用TensorFlow Serving进行模型推理：

package com.example.controller;

import com.example.client.TensorFlowServingClient;
import com.fasterxml.jackson.databind.ObjectMapper;
import jakarta.servlet.AsyncContext;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import tensorflow.serving.PredictRequest;
import tensorflow.serving.PredictResponse;
import org.tensorflow.framework.TensorProto;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

@WebServlet(urlPatterns = "/predict", asyncSupported = true)
public class PredictionServlet extends HttpServlet {
    private TensorFlowServingClient tfClient;
    private ObjectMapper objectMapper;
    
    @Override
    public void init() {
        // 初始化TensorFlow Serving客户端
        String tfHost = getServletContext().getInitParameter("tensorflow.serving.host");
        int tfPort = Integer.parseInt(getServletContext().getInitParameter("tensorflow.serving.port"));
        this.tfClient = new TensorFlowServingClient(tfHost, tfPort);
        this.objectMapper = new ObjectMapper();
    }
    
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) {
        // 启用异步处理
        AsyncContext asyncContext = request.startAsync();
        
        // 在异步线程中处理请求
        new Thread(() -> {
            try {
                // 解析请求数据
                Map<String, Object> requestData = objectMapper.readValue(
                        request.getInputStream(), HashMap.class);
                
                // 准备模型输入
                float[] inputData = parseInputData(requestData);
                TensorProto inputTensor = TensorFlowServingClient.createTensorProto(
                        inputData, new int[]{1, 784});
                
                // 创建预测请求
                PredictRequest predictRequest = PredictRequest.newBuilder()
                        .setModelSpec(tensorflow.serving.ModelSpec.newBuilder()
                                .setName("mnist")
                                .setSignatureName("serving_default"))
                        .putInputs("input", inputTensor)
                        .build();
                
                // 调用TensorFlow Serving进行预测
                PredictResponse response = tfClient.predict(predictRequest);
                
                // 处理预测结果
                Map<String, Object> result = processPredictionResult(response);
                
                // 返回结果
                response.setContentType("application/json");
                response.setCharacterEncoding("UTF-8");
                objectMapper.writeValue(response.getWriter(), result);
                
            } catch (Exception e) {
                response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
                try {
                    response.getWriter().write("预测失败: " + e.getMessage());
                } catch (IOException ioException) {
                    ioException.printStackTrace();
                }
            } finally {
                // 完成异步处理
                asyncContext.complete();
            }
        }).start();
    }
    
    private float[] parseInputData(Map<String, Object> requestData) {
        // 解析输入数据的实现
        // ...
    }
    
    private Map<String, Object> processPredictionResult(PredictResponse response) {
        // 处理预测结果的实现
        // ...
    }
    
    @Override
    public void destroy() {
        try {
            tfClient.shutdown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Servlet示例代码参考：webapps/examples/WEB-INF/classes/HelloWorldExample.java

Web应用配置

在web.xml中配置Servlet和应用参数：

<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee
                             https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
         version="5.0">
    
    <context-param>
        <param-name>tensorflow.serving.host</param-name>
        <param-value>localhost</param-value>
    </context-param>
    <context-param>
        <param-name>tensorflow.serving.port</param-name>
        <param-value>8500</param-value>
    </context-param>
    
    <servlet>
        <servlet-name>PredictionServlet</servlet-name>
        <servlet-class>com.example.controller.PredictionServlet</servlet-class>
        <async-supported>true</async-supported>
    </servlet>
    <servlet-mapping>
        <servlet-name>PredictionServlet</servlet-name>
        <url-pattern>/predict</url-pattern>
    </servlet-mapping>
</web-app>

部署与测试

构建与部署

使用Maven构建WAR包：

mvn clean package

将生成的WAR包部署到Tomcat的webapps目录：

cp target/tomcat-tensorflow-demo.war $CATALINA_HOME/webapps/

启动Tomcat：

$CATALINA_HOME/bin/startup.sh

Tomcat启动脚本：RUNNING.txt

测试模型服务

可以使用curl命令或Postman等工具测试部署的模型服务：

curl -X POST http://localhost:8080/tomcat-tensorflow-demo/predict \
  -H "Content-Type: application/json" \
  -d '{"image": [0.0, 0.0, ..., 0.0]}'

预期响应：

{
  "predictions": [0.01, 0.02, 0.95, 0.01, ...],
  "predicted_class": 2,
  "confidence": 0.95
}

性能优化策略

Tomcat性能调优

线程池配置：根据服务器CPU核心数调整线程池大小

<Executor name="tomcatThreadPool" namePrefix="catalina-exec-"
          maxThreads="200" minSpareThreads="20" maxIdleTime="60000"/>
<Connector executor="tomcatThreadPool" port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000" redirectPort="8443"/>

启用NIO2协议：提高异步I/O性能

<Connector port="8080" protocol="org.apache.coyote.http11.Http11Nio2Protocol"
           connectionTimeout="20000" redirectPort="8443"/>

压缩配置：启用响应压缩减少网络传输量

<Connector ...>
    <Compression className="org.apache.catalina.filters.CompressionFilter"
                 compression="on"
                 compressionMinSize="2048"
                 noCompressionUserAgents="gozilla, traviata"
                 compressableMimeType="text/html,text/xml,text/plain,application/json"/>
</Connector>

压缩过滤器示例：webapps/examples/WEB-INF/classes/CompressionFilter.java

TensorFlow Serving优化

模型批处理：启用批处理以提高吞吐量

tensorflow_model_server --port=8500 --model_name=mnist --model_base_path=/path/to/models/mnist \
  --enable_batching --batching_parameters_file=batch_config.txt

资源限制：合理分配CPU和内存资源

docker run -p 8500:8500 --memory=8g --cpus=4 tensorflow/serving \
  --model_name=mnist --model_base_path=/models/mnist

模型优化：使用TensorFlow Lite或TensorRT优化模型

监控与日志

Tomcat访问日志

配置Tomcat访问日志记录模型服务请求：

<Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
       prefix="localhost_access_log" suffix=".txt"
       pattern="%h %l %u %t &quot;%r&quot; %s %b &quot;%{Referer}i&quot; &quot;%{User-Agent}i&quot; %D" />

日志配置：conf/logging.properties

TensorFlow Serving监控

TensorFlow Serving提供了Prometheus指标接口，可以通过--monitoring_config_file参数启用：

tensorflow_model_server --port=8500 --model_name=mnist --model_base_path=/path/to/models/mnist \
  --monitoring_config_file=monitoring_config.txt

监控配置示例：

prometheus_config {
  enable: true,
  path: "/monitoring/prometheus"
}

安全考虑

请求认证与授权

在Tomcat中配置基于角色的访问控制，保护模型服务API：

配置用户和角色：编辑conf/tomcat-users.xml

<tomcat-users>
  <role rolename="model_user"/>
  <user username="api_user" password="secure_password" roles="model_user"/>
</tomcat-users>

配置安全约束：在web.xml中添加

<security-constraint>
  <web-resource-collection>
    <web-resource-name>Model Service</web-resource-name>
    <url-pattern>/predict</url-pattern>
  </web-resource-collection>
  <auth-constraint>
    <role-name>model_user</role-name>
  </auth-constraint>
</security-constraint>

<login-config>
  <auth-method>BASIC</auth-method>
  <realm-name>Model Service Realm</realm-name>
</login-config>

安全配置文档：webapps/docs/security-howto.xml

数据加密

配置Tomcat以启用HTTPS，确保传输数据的安全：

<Connector port="8443" protocol="org.apache.coyote.http11.Http11NioProtocol"
           maxThreads="150" SSLEnabled="true">
  <SSLHostConfig>
    <Certificate certificateKeystoreFile="conf/keystore.jks"
                 certificateKeystorePassword="changeit"
                 type="RSA" />
  </SSLHostConfig>
</Connector>

SSL配置指南：webapps/docs/ssl-howto.xml

总结与展望

本文详细介绍了Apache Tomcat与TensorFlow Serving的集成方案，包括架构设计、环境配置、代码实现、性能优化和安全考虑等方面。通过这种集成方式，我们可以充分利用Tomcat的Web服务能力和TensorFlow Serving的模型管理优势，构建一个高效、可靠的机器学习模型服务系统。

未来，可以进一步探索以下方向：

动态模型路由：根据请求参数动态选择不同版本或类型的模型
模型缓存机制：在Tomcat中实现热点模型的本地缓存，减少对TensorFlow Serving的请求
自动扩展：结合Kubernetes等容器编排平台，实现基于负载的自动扩展
A/B测试框架：支持同时部署多个模型版本，进行A/B测试和模型效果比较

希望本文能够帮助开发者更好地理解和应用Tomcat与TensorFlow Serving的集成技术，为AI应用的生产部署提供有力支持。

官方文档：webapps/docs/ 项目教程：README.md

【免费下载链接】tomcat Apache Tomcat 项目地址: https://gitcode.com/gh_mirrors/tomcat10/tomcat

ModelEngine社区

更多推荐

从崩溃到自愈：Temporal+MCP-Agent构建永不中断的AI工作流

你是否遇到过AI工作流执行到90%突然崩溃的绝望？训练了数小时的模型因服务器重启前功尽弃？团队协作时因某人未及时审批导致整个流程停滞？本文将展示如何通过Temporal与MCP-Agent的深度集成，彻底解决这些痛点，构建真正企业级的可靠AI工作流系统。读完本文你将掌握：- 3行代码实现工作流故障自愈- 零停机升级正在运行的AI任务- 跨团队协作的工作流信号机制- 从本地开发到生产集群