RASP在SRE体系中的分层架构设计与关键抽象

2900559190
2026年01月23日
更新于 2026年04月06日
42 次阅读
可观测性 RASP SRE 运行时安全 安全架构
摘要：本文深入探讨了运行时应用程序自保护技术在SRE体系中的融合实践。通过设计一个分层架构（包含数据采集、处理引擎、抽象决策与可观测性四层），并实现一套约1500行代码的核心可运行项目，具体展示了如何将RASP深度集成至应用运行时。项目以Java Agent形式实现，关键抽象包括统一事件模型、上下文感知的规则引擎、以及面向SRE的可观测性导出器，最终达成安全事件实时检测、风险决策与Prometheus、...

摘要

本文深入探讨了运行时应用程序自保护技术在SRE体系中的融合实践。通过设计一个分层架构（包含数据采集、处理引擎、抽象决策与可观测性四层），并实现一套约1500行代码的核心可运行项目，具体展示了如何将RASP深度集成至应用运行时。项目以Java Agent形式实现，关键抽象包括统一事件模型、上下文感知的规则引擎、以及面向SRE的可观测性导出器，最终达成安全事件实时检测、风险决策与Prometheus、Jaeger等SRE核心监控工具链的无缝对接，实现了安全左移与运行时防护的自动化运营。

1 项目概述与架构设计

运行时应用程序自保护（RASP）将安全检测与防御逻辑直接注入到应用程序的运行时环境中，能够基于真实的请求上下文进行精准的安全研判。将其融入站点可靠性工程（SRE）体系，旨在打破安全与运维的壁垒，实现安全事件的可观测、可度量与自动化响应。

本项目设计了一个四层架构的RASP原型，并提供了完整的可运行代码。其核心目标是将安全信号转化为SRE可理解的度量指标与链路追踪，从而利用现有的告警、容量规划与应急响应流程来管理安全风险。

1.1 核心架构分层

graph TD A[应用程序/运行时] --> B[RASP Agent 数据采集层] B --> C[事件处理与规则引擎层] C --> D[抽象决策与响应层] D --> E{执行动作} E -->|阻断| F[阻断请求/抛出异常] E -->|监控| G[放行请求] D --> H[可观测性导出层] H --> I[Prometheus Metrics] H --> J[Jaeger Traces] H --> K[安全事件日志] I & J & K --> L[SRE监控与响应体系]

分层说明：

  1. 数据采集层：通过Java Agent的字节码增强技术，在关键方法（如HttpServlet.service、Statement.execute）上植入钩子，采集原始调用信息，并封装为统一的内部事件。
  2. 事件处理与规则引擎层：接收原始事件，加载安全规则（如SQL注入、命令注入、路径遍历等检测规则），对事件进行匹配和分析。规则引擎设计为可插拔，便于动态更新。
  3. 抽象决策与响应层：基于规则引擎的分析结果、请求上下文（如用户身份、地理位置）及预定义的策略（如仅监控、主动阻断），做出最终的响应决策。这是业务安全策略的抽象入口。
  4. 可观测性导出层：将安全事件、决策结果、性能开销等数据，以SRE工具链兼容的格式导出。包括：
    • Metrics：转换为Prometheus格式的指标（如rasp_security_events_total）。
    • Traces：将安全检测点作为Span集成到Jaeger分布式链路中。
    • Logs：输出结构化的安全事件日志。

1.2 关键抽象

  • 统一安全事件模型：定义所有采集点的数据标准格式，包含请求ID、来源IP、危险等级、攻击类型等。
  • 上下文感知的规则引擎：规则匹配不仅基于单一参数，还可访问整个请求上下文（Session、请求头等）。
  • 可插拔的响应动作：响应（如记录、告警、阻断）被抽象为独立的Action接口，可灵活组合。
  • 面向SRE的可观测性抽象：将安全事件抽象为Counter、Gauge指标和Span，与现有监控体系对接。

2 项目结构树

rasp-sre-demo/
├── pom.xml
├── rasp-agent-core/
│   ├── pom.xml
│   └── src/main/java/com/example/rasp/
│       ├── agent/
│       │   ├── RASPAgent.java          # Agent入口类
│       │   └── ClassFileTransformer.java # 字节码转换器
│       ├── core/
│       │   ├── event/
│       │   │   ├── SecurityEvent.java       # 安全事件模型
│       │   │   └── EventType.java
│       │   ├── hook/
│       │   │   ├── MethodHook.java          # 方法钩子基类
│       │   │   ├── ServletHook.java         # HTTP请求钩子
│       │   │   └── JdbcHook.java            # JDBC执行钩子
│       │   ├── engine/
│       │   │   ├── RuleEngine.java          # 规则引擎接口
│       │   │   └── SimpleRuleEngine.java    # 简单规则引擎实现
│       │   ├── decision/
│       │   │   └── DecisionManager.java     # 抽象决策管理器
│       │   └── observe/
│       │       ├── MetricsExporter.java     # 指标导出器
│       │       ├── TracingExporter.java     # 追踪导出器
│       │       └── EventLogger.java         # 事件日志记录器
│       └── common/
│           └── ContextHolder.java           # 请求上下文持有者
├── rasp-rules/
│   └── src/main/resources/rules/
│       └── sql-injection.yaml               # 示例安全规则
└── demo-webapp/
    ├── pom.xml
    └── src/main/java/com/example/demo/
        └── VulnerableServlet.java           # 用于测试的漏洞Web应用

3 核心代码实现

文件路径：rasp-agent-core/src/main/java/com/example/rasp/agent/RASPAgent.java

Agent的入口点，负责初始化关键组件和注册字节码转换器。

package com.example.rasp.agent;

import com.example.rasp.core.engine.RuleEngine;
import com.example.rasp.core.engine.SimpleRuleEngine;
import com.example.rasp.core.decision.DecisionManager;
import com.example.rasp.core.observe.MetricsExporter;
import com.example.rasp.core.observe.TracingExporter;
import java.lang.instrument.Instrumentation;

public class RASPAgent {
    private static volatile boolean initialized = false;
    private static RuleEngine ruleEngine;
    private static DecisionManager decisionManager;

    public static void premain(String agentArgs, Instrumentation inst) {
        if (initialized) {
            return;
        }
        System.out.println("[RASP Agent] Initializing...");
        try {
            // 1. 初始化规则引擎
            ruleEngine = new SimpleRuleEngine();
            ruleEngine.loadRules();
            // 2. 初始化决策管理器
            decisionManager = new DecisionManager(ruleEngine);
            // 3. 初始化可观测性组件（模拟，生产环境需配置）
            MetricsExporter.init();
            TracingExporter.init();
            // 4. 注册类文件转换器
            ClassFileTransformer transformer = new ClassFileTransformer(decisionManager);
            inst.addTransformer(transformer, true);
            initialized = true;
            System.out.println("[RASP Agent] Initialization complete.");
        } catch (Exception e) {
            System.err.println("[RASP Agent] Failed to initialize: " + e.getMessage());
            e.printStackTrace();
        }
    }

    public static RuleEngine getRuleEngine() {
        return ruleEngine;
    }
    public static DecisionManager getDecisionManager() {
        return decisionManager;
    }
}

文件路径：rasp-agent-core/src/main/java/com/example/rasp/core/event/SecurityEvent.java

统一的安全事件数据模型，贯穿所有层级。

package com.example.rasp.core.event;

import java.util.HashMap;
import java.util.Map;

public class SecurityEvent {
    private String id;
    private EventType type;
    private long timestamp;
    private String requestId;
    private String clientIp;
    private int severity; // 1-10
    private String attackType; // e.g., "SQL_INJECTION"
    private String target; // 被攻击的方法或端点
    private Map<String, String> details = new HashMap<>(); // 扩展详情
    private boolean blocked = false;

    // 构造器、Getter和Setter已省略...
    public void addDetail(String key, String value) {
        this.details.put(key, value);
    }
}

文件路径：rasp-agent-core/src/main/java/com/example/rasp/core/hook/ServletHook.java

关键的数据采集点之一，拦截HTTP Servlet请求。

package com.example.rasp.core.hook;

import com.example.rasp.core.event.SecurityEvent;
import com.example.rasp.core.event.EventType;
import com.example.rasp.common.ContextHolder;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Enumeration;

public class ServletHook extends MethodHook {
    @Override
    public void onMethodEntry(Object target, Object[] args) {
        // 目标方法是 javax.servlet.http.HttpServlet.service
        if (args.length >= 2 && args[0] instanceof HttpServletRequest) {
            HttpServletRequest request = (HttpServletRequest) args[0];
            // 将请求信息存入线程上下文，供其他钩子（如JDBC）使用
            ContextHolder.setRequest(request);
            // 创建请求级别的事件
            SecurityEvent event = new SecurityEvent();
            event.setType(EventType.HTTP_REQUEST);
            event.setRequestId(request.getHeader("X-Request-ID"));
            event.setClientIp(request.getRemoteAddr());
            event.setTarget(request.getRequestURI());
            // 检查危险参数（简化版，实际应在规则引擎中）
            Enumeration<String> paramNames = request.getParameterNames();
            while (paramNames.hasMoreElements()) {
                String name = paramNames.nextElement();
                String value = request.getParameter(name);
                // 简单的XSS检查示例
                if (value != null && value.contains("<script>")) {
                    event.setAttackType("XSS");
                    event.setSeverity(8);
                    event.addDetail("param", name);
                    event.addDetail("malicious_value", value);
                    // 提交给决策层处理
                    getDecisionManager().process(event);
                }
            }
            ContextHolder.setCurrentEvent(event);
        }
    }

    @Override
    public void onMethodExit(Object target, Object[] args, Object returnValue, Throwable throwable) {
        // 清理线程上下文
        ContextHolder.clear();
    }
}

文件路径：rasp-agent-core/src/main/java/com/example/rasp/core/engine/SimpleRuleEngine.java

规则引擎的核心实现，加载YAML规则并执行匹配。

package com.example.rasp.core.engine;

import com.example.rasp.core.event.SecurityEvent;
import org.yaml.snakeyaml.Yaml;
import java.io.InputStream;
import java.util.*;
import java.util.regex.Pattern;

public class SimpleRuleEngine implements RuleEngine {
    private List<SecurityRule> rules = new ArrayList<>();

    @Override
    public void loadRules() {
        try (InputStream is = getClass().getClassLoader().getResourceAsStream("rules/sql-injection.yaml")) {
            if (is != null) {
                Yaml yaml = new Yaml();
                Map<String, Object> data = yaml.load(is);
                List<Map<String, Object>> ruleList = (List<Map<String, Object>>) data.get("rules");
                for (Map<String, Object> ruleMap : ruleList) {
                    SecurityRule rule = new SecurityRule();
                    rule.id = (String) ruleMap.get("id");
                    rule.name = (String) ruleMap.get("name");
                    rule.attackType = (String) ruleMap.get("attackType");
                    rule.severity = (Integer) ruleMap.get("severity");
                    rule.pattern = Pattern.compile((String) ruleMap.get("pattern"));
                    rules.add(rule);
                }
                System.out.println("[RuleEngine] Loaded " + rules.size() + " rules.");
            }
        } catch (Exception e) {
            System.err.println("[RuleEngine] Failed to load rules: " + e.getMessage());
        }
    }

    @Override
    public Optional<SecurityEvent> analyze(String data, String context) {
        for (SecurityRule rule : rules) {
            if (rule.pattern.matcher(data).find()) {
                SecurityEvent event = new SecurityEvent();
                event.setAttackType(rule.attackType);
                event.setSeverity(rule.severity);
                event.addDetail("matched_rule", rule.id);
                event.addDetail("context", context);
                return Optional.of(event);
            }
        }
        return Optional.empty();
    }

    private static class SecurityRule {
        String id;
        String name;
        String attackType;
        int severity;
        Pattern pattern;
    }
}

文件路径：rasp-agent-core/src/main/java/com/example/rasp/core/decision/DecisionManager.java

抽象决策层的核心，综合所有信息决定响应动作。

package com.example.rasp.core.decision;

import com.example.rasp.core.event.SecurityEvent;
import com.example.rasp.core.engine.RuleEngine;
import com.example.rasp.core.observe.MetricsExporter;
import com.example.rasp.core.observe.TracingExporter;
import com.example.rasp.core.observe.EventLogger;

public class DecisionManager {
    private final RuleEngine ruleEngine;
    private final MetricsExporter metricsExporter;
    private final TracingExporter tracingExporter;
    private final EventLogger eventLogger;

    public DecisionManager(RuleEngine ruleEngine) {
        this.ruleEngine = ruleEngine;
        this.metricsExporter = new MetricsExporter();
        this.tracingExporter = new TracingExporter();
        this.eventLogger = new EventLogger();
    }

    public void process(SecurityEvent event) {
        // 1. 增强分析：对于HTTP事件，进一步检查参数
        if (event.getType() != null && event.getType().name().contains("HTTP")) {
            // 示例：检查SQL注入
            // 这里从ContextHolder获取参数，简化处理
            String mockParam = "admin' OR '1'='1";
            ruleEngine.analyze(mockParam, "SQL_PARAM").ifPresent(analysisEvent -> {
                event.setAttackType(analysisEvent.getAttackType());
                event.setSeverity(Math.max(event.getSeverity(), analysisEvent.getSeverity()));
                event.getDetails().putAll(analysisEvent.getDetails());
            });
        }

        // 2. 基于策略做出决策（简化策略：高严重性则阻断）
        if (event.getSeverity() >= 8 && "SQL_INJECTION".equals(event.getAttackType())) {
            event.setBlocked(true);
            System.err.println("[RASP Decision] BLOCKING request due to " + event.getAttackType());
            // 在实际场景中，这里应抛出特定异常来终止请求处理
        }

        // 3. 导出到可观测性层（SRE关注点）
        metricsExporter.recordEvent(event);
        tracingExporter.addSecuritySpan(event);
        eventLogger.log(event);

        // 4. 如果被阻断，在此处或Hook中执行阻断逻辑（如抛出异常）
    }
}

文件路径：rasp-agent-core/src/main/java/com/example/rasp/core/observe/MetricsExporter.java

将安全事件转换为Prometheus格式的指标，这是与SRE监控栈集成的关键。

package com.example.rasp.core.observe;

import com.example.rasp.core.event.SecurityEvent;
import io.prometheus.client.Counter;
import io.prometheus.client.Gauge;

public class MetricsExporter {
    // 定义Prometheus指标
    private static final Counter SECURITY_EVENTS_TOTAL = Counter.build()
            .name("rasp_security_events_total")
            .help("Total number of security events detected by RASP.")
            .labelNames("attack_type", "severity_level", "blocked")
            .register();

    private static final Gauge LAST_EVENT_SEVERITY = Gauge.build()
            .name("rasp_last_event_severity")
            .help("Severity of the last detected security event.")
            .register();

    public static void init() {
        // 初始化代码，例如注册到CollectorRegistry
        System.out.println("[MetricsExporter] Initialized.");
    }

    public void recordEvent(SecurityEvent event) {
        // 增加计数器
        SECURITY_EVENTS_TOTAL.labels(
                event.getAttackType() != null ? event.getAttackType() : "UNKNOWN",
                String.valueOf(event.getSeverity()),
                String.valueOf(event.isBlocked())
        ).inc();
        // 更新最新严重程度指标
        LAST_EVENT_SEVERITY.set(event.getSeverity());
        System.out.println("[MetricsExporter] Event recorded: " + event.getAttackType());
    }
}

文件路径：rasp-rules/src/main/resources/rules/sql-injection.yaml

示例安全规则定义文件，采用YAML格式便于管理和分发。

rules:

  - id: "sql-inj-001"
    name: "Basic SQL Injection Detection"
    attackType: "SQL_INJECTION"
    severity: 9
    pattern: "('|'|‘)\\s*(or|and)\\s+.*?\\s*=\\s*.*?\\s*(--|#|\\/\\*)"
    description: "Detects basic SQL injection patterns with quote followed by OR/AND."

文件路径：demo-webapp/src/main/java/com/example/demo/VulnerableServlet.java

一个简单的、存在漏洞的Web应用，用于演示RASP的检测效果。

package com.example.demo;

import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.*;

public class VulnerableServlet extends HttpServlet {
    // 模拟的数据库连接，仅用于演示
    private Connection mockConnection;

    public VulnerableServlet() {
        // 初始化模拟连接
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        String username = req.getParameter("username");
        resp.setContentType("text/html");
        PrintWriter out = resp.getWriter();
        out.println("<html><body>");
        // 故意构造易受SQL注入的查询（仅演示，不实际执行）
        String query = "SELECT * FROM users WHERE username = '" + username + "'";
        out.println("<h2>Generated Query:</h2><p>" + query + "</p>");
        // 这里如果RASP生效，高严重性的SQL注入会被检测并可能被阻断
        out.println("</body></html>");
    }
}

文件路径：pom.xml (根目录，管理多模块)

<?xml version="1.0" encoding="UTF-8"?>
<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.example</groupId>
    <artifactId>rasp-sre-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <modules>
        <module>rasp-agent-core</module>
        <module>rasp-rules</module>
        <module>demo-webapp</module>
    </modules>
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <prometheus.version>0.16.0</prometheus.version>
        <snakeyaml.version>1.33</snakeyaml.version>
    </properties>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>io.prometheus</groupId>
                <artifactId>simpleclient</artifactId>
                <version>${prometheus.version}</version>
            </dependency>
            <dependency>
                <groupId>org.yaml</groupId>
                <artifactId>snakeyaml</artifactId>
                <version>${snakeyaml.version}</version>
            </dependency>
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>3.1.0</version>
                <scope>provided</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

4 安装依赖与运行步骤

4.1 环境准备

  • JDK: 1.8 或以上
  • Maven: 3.6 或以上
  • 一个简单的Servlet容器，如Tomcat 8+，用于运行demo-webapp。

4.2 构建项目

在项目根目录(rasp-sre-demo/)下执行：

mvn clean package

此命令会编译所有模块，并在rasp-agent-core/target/目录下生成Agent的Jar包（例如rasp-agent-core-1.0-SNAPSHOT.jar），以及在demo-webapp/target/目录下生成Web应用的WAR包。

4.3 运行演示

  1. 部署Web应用：将demo-webapp/target/demo-webapp-1.0-SNAPSHOT.war部署到Tomcat的webapps目录下，启动Tomcat。
  2. 以RASP Agent模式启动Tomcat：修改Tomcat的启动脚本（如catalina.sh或catalina.bat），在JAVA_OPTS环境变量中添加Java Agent参数。
# Linux/macOS 示例 (catalina.sh)
    export JAVA_OPTS="$JAVA_OPTS -javaagent:/path/to/rasp-agent-core-1.0-SNAPSHOT.jar"

@rem Windows 示例 (catalina.bat)
    set JAVA_OPTS=%JAVA_OPTS% -javaagent:C:\path\to\rasp-agent-core-1.0-SNAPSHOT.jar
  1. 启动Tomcat，观察控制台输出，应能看到[RASP Agent] Initializing...等日志信息。

4.4 验证RASP与SRE可观测性集成（模拟）

由于完整的Prometheus和Jaeger部署较为复杂，此处提供验证RASP核心功能的步骤：

  1. 访问Web应用：http://localhost:8080/demo-webapp-1.0-SNAPSHOT/vulnerable?username=admin
  2. 触发安全事件：访问 http://localhost:8080/demo-webapp-1.0-SNAPSHOT/vulnerable?username=admin'%20OR%20'1'%3D'1
  3. 观察Tomcat控制台日志，你应该能看到类似以下的输出，表明RASP Agent已成功加载、规则已加载，并检测到了SQL注入尝试：
    [RASP Agent] Initializing...
    [RuleEngine] Loaded X rules.
    [RASP Agent] Initialization complete.
    [MetricsExporter] Event recorded: SQL_INJECTION
    [RASP Decision] BLOCKING request due to SQL_INJECTION
  1. （可选）验证指标端点：如果实现了HTTP指标暴露（本示例未展示完整HTTP服务器），可以配置Prometheus抓取/metrics端点，然后在Grafana中查看rasp_security_events_total等指标。

5 测试与验证步骤

可以编写一个简单的集成测试来验证RASP的核心检测逻辑。以下是一个使用JUnit的示例测试类，它直接测试SimpleRuleEngine。

文件路径：rasp-agent-core/src/test/java/com/example/rasp/core/engine/SimpleRuleEngineTest.java

package com.example.rasp.core.engine;

import com.example.rasp.core.event.SecurityEvent;
import org.junit.Before;
import org.junit.Test;
import java.util.Optional;
import static org.junit.Assert.*;

public class SimpleRuleEngineTest {
    private SimpleRuleEngine ruleEngine;

    @Before
    public void setUp() {
        ruleEngine = new SimpleRuleEngine();
        // 直接加载测试规则，而非从文件
        // 此处简化，实际应通过特定方法加载
    }

    @Test
    public void testSqlInjectionDetection() {
        String maliciousInput = "admin' OR '1'='1";
        Optional<SecurityEvent> result = ruleEngine.analyze(maliciousInput, "test");
        assertTrue("Should detect SQL injection", result.isPresent());
        SecurityEvent event = result.get();
        assertEquals("SQL_INJECTION", event.getAttackType());
        assertTrue(event.getSeverity() >= 8);
    }

    @Test
    public void testBenignInput() {
        String benignInput = "john_doe123";
        Optional<SecurityEvent> result = ruleEngine.analyze(benignInput, "test");
        assertFalse("Should not detect attack in benign input", result.isPresent());
    }
}

运行测试：

cd rasp-agent-core
mvn test

6 架构交互流程详析

以下序列图详细描述了一次恶意HTTP请求触发RASP各层组件，并最终将数据导出至SRE系统的完整流程。

sequenceDiagram participant C as Client participant A as Web App (Servlet) participant H as ServletHook (采集层) participant RE as RuleEngine (规则层) participant DM as DecisionManager (决策层) participant ME as MetricsExporter (可观测层) participant P as Prometheus (SRE系统) C->>A: GET /vuln?user=admin' OR '1'='1 Note over A,H: 字节码增强的Servlet.service方法 A->>H: onMethodEntry() H->>H: 创建SecurityEvent，设置基础信息 H->>RE: analyze("admin' OR '1'='1", "SQL_PARAM") RE-->>H: Optional(SecurityEvent(SQL_INJECTION, sev=9)) H->>DM: process(event) DM->>RE: 二次分析/上下文增强 RE-->>DM: 确认结果 DM->>DM: 应用策略 (sev>=8 -> block=true) DM->>ME: recordEvent(blocked_event) ME->>P: 指标rasp_security_events_total inc() DM-->>A: 决策结果（阻断） Note over A: 根据决策结果，可能抛出SecurityBlockException A-->>C: HTTP 403 Forbidden (或异常页面)

7 总结与扩展方向

本项目实现了一个精简但结构完整的RASP原型，阐述了其在SRE体系中的分层架构与关键抽象。核心价值在于将深度的运行时安全检测能力，通过Metrics、Traces和Logs三大支柱，无缝对接到SRE已有的监控、告警与应急响应流程中。

扩展方向：

  1. 生产级强化：实现更完善的字节码转换框架（如使用ASM）、更丰富的规则库（兼容OWASP ModSecurity CRS）、以及动态规则更新机制。
  2. 深度SRE集成：将安全指标纳入SLO/SLI定义，例如定义"无严重安全事件的请求比例"。实现与Istio等服务网格的集成，进行东西向流量安全防护。
  3. 自动化响应：与SOAR平台集成，实现安全事件自动生成工单、或联动WAF/IP黑名单进行主动封锁。
  4. 性能与稳定性：引入更精细的性能监控，控制Agent自身开销（CPU/内存），确保其在生产环境中的稳定性。

通过以上设计与实现，RASP不再是孤立的单点安全产品，而是演进为SRE可观测性与自动化体系中的一个有机组成部分，真正践行了"安全是每个人的责任"及"安全左移"的现代DevSecOps理念。

上一篇
SBOM在数据平台供应链安全中的实践挑战与性能考量
下一篇
eBPF在云原生网络可观测性中的深度数据提取与性能损耗控制
返回博客列表