大家好，最近在尝试为微服务架构引入自动化测试时，发现一个普遍痛点：为存量服务添加测试，尤其是集成测试和端到端测试，往往需要侵入性地修改大量代码，不仅工作量大，还可能引入新的风险。有没有一种方法，能够在不改动一行业务代码的情况下，对服务进行运行、测试和问题发现呢？答案是肯定的。本文将围绕一种“无代码变更”的测试理念，结合当前流行的工具链，为你拆解一套完整的实战方案。无论你是负责维护复杂微服务系统的架构师，还是希望提升项目测试覆盖率的开发工程师，都能从本文中找到可直接落地的思路和工具。

1. 核心概念：什么是“无代码变更”的测试？

在深入实践之前，我们首先要明确“无代码变更”（No Code Changes）测试的核心思想。这并不是指完全不用写代码，而是指 测试逻辑和测试代码本身不侵入、不修改被测试的服务（System Under Test, SUT）的源代码 。

1.1 传统测试的痛点

传统的单元测试、集成测试通常需要：

  1. 代码侵入 ：在业务代码中引入测试框架的注解（如 @Test ）、Mock 工具或为了测试而设计的特殊分支逻辑。
  2. 环境依赖 ：测试严重依赖本地或 CI 环境的具体配置，难以复现生产环境的交互。
  3. 维护成本高 ：业务代码一旦重构，与之耦合的测试代码也需要同步修改，否则就会“红”。
  4. 覆盖不全 ：Mock 虽然能隔离依赖，但也可能掩盖了服务间真实交互（如网络、序列化、版本兼容性）导致的问题。

1.2 “无代码变更”测试的优势

这种测试范式将测试视为一个 外部观察者和驱动者 ：

  • 黑盒/灰盒测试 ：将服务视为一个整体，通过其公开的 API（HTTP/gRPC 接口、消息队列消费者等）进行驱动和验证。
  • ** sidecar 或代理模式**：利用服务网格（如 Istio）、API 网关或专门的测试代理，在流量层面对请求和响应进行拦截、记录、重放和断言。
  • 契约测试与流量录制 ：通过捕获生产或测试环境的真实流量，生成测试用例，用于后续的回放测试，确保服务行为的一致性。
  • 无需重新编译部署 ：测试用例的更新独立于服务部署流程，可以实现更快速的测试迭代。

其核心价值在于 将测试活动与开发活动解耦 ，让测试专家或质量保障团队能够基于运行时的行为来保障质量，而不必深陷于业务代码的实现细节中。

2. 环境准备与工具选型

要实现无代码变更的测试，我们需要一套工具链的支持。以下是一个基于当前技术趋势的推荐组合，我们将以 Python 微服务为例进行演示，但思路适用于任何语言。

2.1 基础运行环境

  • 操作系统 ：Linux / macOS / WSL2 (Windows)。本文示例基于 Ubuntu 22.04。
  • 容器运行时 ：Docker 20.10+ 与 Docker Compose v2。这是隔离服务依赖的关键。
  • 编程语言 ：Python 3.9+。我们的示例服务将使用 FastAPI 编写。
  • 包管理 ： pip 及 venv 虚拟环境。

2.2 核心测试工具介绍

我们将重点使用两类工具：

  1. 服务交互工具 ：用于驱动和观测服务。这里我们引入 MCP (Model Context Protocol) Server 的概念。虽然 MCP 最初是为 AI 模型提供上下文而设计，但其 标准化数据源连接 的思想非常适合用来构建一个统一的“服务测试适配层”。我们可以创建一个轻量级 MCP Server，将服务的 API 封装成标准资源（Resources）和工具（Tools），供测试脚本调用。
  2. 测试执行与断言框架 ： Pytest 。它是 Python 生态的事实标准，功能强大，插件丰富。

2.3 示例项目结构预览

在开始前，我们先看下最终的项目结构，以便有一个全局观： 

no-code-change-test-demo/
├── docker-compose.yaml          # 定义被测服务及其依赖（如数据库）
├── services/                    # 被测服务源代码（我们“不修改”的部分）
│   └── user_service/
│       ├── app.py
│       ├── models.py
│       ├── requirements.txt
│       └── Dockerfile
├── test_adapter/               # “无代码变更”测试适配层（MCP Server）
│   ├── mcp_server.py
│   ├── requirements.txt
│   └── Dockerfile
└── tests/                      # 外部测试套件
    ├── conftest.py
    ├── test_user_service.py
    └── requirements.txt

我们的目标是： tests/ 目录下的测试代码，通过 test_adapter/ 这个适配层，去测试 services/ 里运行起来的真实 user_service ，而不需要改动 services/user_service/ 下的任何业务代码。

3. 创建被测服务（示例）

为了演示，我们创建一个简单的用户管理服务。记住，这部分代码在后续测试中将被视为“只读”的。

文件： services/user_service/app.py 

from fastapi import FastAPI, HTTPException, Depends
from pydantic import BaseModel
from typing import List, Optional
import asyncpg
import os

app = FastAPI(title="User Service")

# Pydantic 模型
class UserCreate(BaseModel):
    username: str
    email: str

class UserResponse(BaseModel):
    id: int
    username: str
    email: str

# 依赖项：获取数据库连接
async def get_db():
    DATABASE_URL = os.getenv("DATABASE_URL", "postgresql://postgres:password@db:5432/users")
    conn = await asyncpg.connect(DATABASE_URL)
    try:
        yield conn
    finally:
        await conn.close()

@app.on_event("startup")
async def startup():
    # 启动时创建表（生产环境应用迁移工具）
    conn = await asyncpg.connect(os.getenv("DATABASE_URL", "postgresql://postgres:password@db:5432/users"))
    await conn.execute('''
        CREATE TABLE IF NOT EXISTS users (
            id SERIAL PRIMARY KEY,
            username VARCHAR(50) UNIQUE NOT NULL,
            email VARCHAR(100) UNIQUE NOT NULL
        )
    ''')
    await conn.close()

@app.get("/users", response_model=List[UserResponse])
async def list_users(conn=Depends(get_db)):
    rows = await conn.fetch("SELECT id, username, email FROM users ORDER BY id")
    return [UserResponse(**row) for row in rows]

@app.get("/users/{user_id}", response_model=UserResponse)
async def get_user(user_id: int, conn=Depends(get_db)):
    row = await conn.fetchrow("SELECT id, username, email FROM users WHERE id = $1", user_id)
    if not row:
        raise HTTPException(status_code=404, detail="User not found")
    return UserResponse(**row)

@app.post("/users", response_model=UserResponse, status_code=201)
async def create_user(user: UserCreate, conn=Depends(get_db)):
    try:
        # 注意：这里故意没有做输入验证（如邮箱格式），用于后续测试发现问题的演示
        row = await conn.fetchrow(
            "INSERT INTO users (username, email) VALUES ($1, $2) RETURNING id, username, email",
            user.username, user.email
        )
        return UserResponse(**row)
    except asyncpg.exceptions.UniqueViolationError:
        raise HTTPException(status_code=400, detail="Username or email already exists")

@app.delete("/users/{user_id}", status_code=204)
async def delete_user(user_id: int, conn=Depends(get_db)):
    result = await conn.execute("DELETE FROM users WHERE id = $1", user_id)
    if result == "DELETE 0":
        raise HTTPException(status_code=404, detail="User not found")

文件： services/user_service/requirements.txt 

fastapi==0.104.1
uvicorn[standard]==0.24.0
asyncpg==0.29.0
pydantic==2.5.0

文件： services/user_service/Dockerfile 

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

这个服务提供了用户的增删改查接口，并连接到一个 PostgreSQL 数据库。它存在一些潜在问题（如缺少输入验证），我们将通过外部测试来发现它们。

4. 构建测试适配层（MCP Server）

这是实现“无代码变更”测试的关键。我们将创建一个简单的 MCP Server，它本质上是一个 HTTP 服务器，提供了标准化的接口来操作 user_service 。测试脚本将通过调用这个 MCP Server 的工具来间接驱动被测服务。

文件： test_adapter/mcp_server.py 

import json
import httpx
from typing import Any, List
from mcp.server import Server, NotificationOptions
from mcp.server.models import InitializationOptions
import mcp.server.stdio
import asyncio

# 被测试服务的基地址
SERVICE_BASE_URL = "http://user_service:8000"

class ServiceTestAdapter:
    """适配器，封装对被测服务的所有操作"""
    def __init__(self):
        self.client = httpx.AsyncClient(base_url=SERVICE_BASE_URL, timeout=30.0)

    async def list_users(self) -> List[dict]:
        """调用 /users 接口"""
        resp = await self.client.get("/users")
        resp.raise_for_status()
        return resp.json()

    async def get_user(self, user_id: int) -> dict:
        """调用 /users/{id} 接口"""
        resp = await self.client.get(f"/users/{user_id}")
        if resp.status_code == 404:
            return {"error": "User not found"}
        resp.raise_for_status()
        return resp.json()

    async def create_user(self, username: str, email: str) -> dict:
        """调用 POST /users 接口"""
        payload = {"username": username, "email": email}
        resp = await self.client.post("/users", json=payload)
        if resp.status_code == 400:
            return {"error": "Duplicate username or email"}
        resp.raise_for_status()
        return resp.json()

    async def delete_user(self, user_id: int) -> dict:
        """调用 DELETE /users/{id} 接口"""
        resp = await self.client.delete(f"/users/{user_id}")
        if resp.status_code == 404:
            return {"error": "User not found"}
        resp.raise_for_status()
        return {"status": "deleted"}

async def main():
    adapter = ServiceTestAdapter()
    server = Server("user-service-test-adapter")

    @server.list_tools()
    async def handle_list_tools() -> list:
        """向客户端（测试脚本）声明本 Server 提供的工具"""
        return [
            {
                "name": "list_users",
                "description": "获取所有用户列表",
                "inputSchema": {
                    "type": "object",
                    "properties": {}
                }
            },
            {
                "name": "get_user",
                "description": "根据ID获取用户详情",
                "inputSchema": {
                    "type": "object",
                    "properties": {
                        "user_id": {"type": "integer", "description": "用户ID"}
                    },
                    "required": ["user_id"]
                }
            },
            {
                "name": "create_user",
                "description": "创建新用户",
                "inputSchema": {
                    "type": "object",
                    "properties": {
                        "username": {"type": "string", "description": "用户名"},
                        "email": {"type": "string", "description": "邮箱"}
                    },
                    "required": ["username", "email"]
                }
            },
            {
                "name": "delete_user",
                "description": "删除用户",
                "inputSchema": {
                    "type": "object",
                    "properties": {
                        "user_id": {"type": "integer", "description": "用户ID"}
                    },
                    "required": ["user_id"]
                }
            }
        ]

    @server.call_tool()
    async def handle_call_tool(name: str, arguments: dict) -> dict:
        """执行客户端（测试脚本）调用的工具"""
        if name == "list_users":
            result = await adapter.list_users()
        elif name == "get_user":
            result = await adapter.get_user(arguments["user_id"])
        elif name == "create_user":
            result = await adapter.create_user(arguments["username"], arguments["email"])
        elif name == "delete_user":
            result = await adapter.delete_user(arguments["user_id"])
        else:
            raise ValueError(f"Unknown tool: {name}")
        # 将结果格式化为 MCP 要求的格式
        return {
            "content": [{"type": "text", "text": json.dumps(result, ensure_ascii=False)}]
        }

    async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
        await server.run(
            read_stream,
            write_stream,
            InitializationOptions(
                server_name="user-service-test-adapter",
                server_version="0.1.0",
                capabilities=server.get_capabilities(
                    notification_options=NotificationOptions(),
                    experimental_capabilities={},
                ),
            ),
        )

if __name__ == "__main__":
    asyncio.run(main())

文件： test_adapter/requirements.txt 

mcp==0.1.0
httpx==0.25.1

文件： test_adapter/Dockerfile 

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["python", "mcp_server.py"]

这个 MCP Server 启动后，会通过 stdio 与客户端通信。我们需要一个客户端来连接它并发送指令。在测试中，我们将使用 mcp 包的客户端库。

5. 编写外部测试套件

现在，我们可以在完全独立的空间里编写测试了。测试代码只依赖于 test_adapter 提供的标准化工具接口。

文件： tests/requirements.txt 

pytest==7.4.3
pytest-asyncio==0.21.1
mcp==0.1.0
httpx==0.25.1

文件： tests/conftest.py 

import pytest
import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
import subprocess
import time
import os

@pytest.fixture(scope="session")
def docker_compose_up():
    """启动整个 Docker Compose 环境（包括服务、数据库和测试适配器）"""
    compose_file = os.path.join(os.path.dirname(__file__), '..', 'docker-compose.yaml')
    subprocess.run(["docker-compose", "-f", compose_file, "up", "-d"], check=True)
    # 等待服务就绪
    time.sleep(10)
    yield
    # 测试结束后关闭环境
    subprocess.run(["docker-compose", "-f", compose_file, "down"], check=True)

@pytest.fixture(scope="session")
async def mcp_session(docker_compose_up):
    """创建并连接到测试适配器 MCP Server 的会话"""
    # 通过 stdio 连接到运行在容器中的 MCP Server
    # 这里我们使用 `docker exec` 来与容器内的进程交互，模拟 stdio 连接
    # 注意：这是一个简化的示例，实际生产可能需要更复杂的进程间通信管理
    server_params = StdioServerParameters(
        command="docker",
        args=["exec", "-i", "no-code-change-test-demo-test-adapter-1", "python", "mcp_server.py"]
    )
    
    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            yield session

文件： tests/test_user_service.py 

import pytest
import json

@pytest.mark.asyncio
async def test_list_users_empty(mcp_session):
    """测试初始状态下用户列表为空"""
    result = await mcp_session.call_tool("list_users", {})
    content_text = result.content[0].text
    user_list = json.loads(content_text)
    assert isinstance(user_list, list)
    assert len(user_list) == 0

@pytest.mark.asyncio
async def test_create_and_get_user(mcp_session):
    """测试创建用户并查询"""
    # 创建用户
    create_result = await mcp_session.call_tool(
        "create_user",
        {"username": "alice", "email": "alice@example.com"}
    )
    create_data = json.loads(create_result.content[0].text)
    assert "id" in create_data
    assert create_data["username"] == "alice"
    user_id = create_data["id"]

    # 查询用户
    get_result = await mcp_session.call_tool("get_user", {"user_id": user_id})
    get_data = json.loads(get_result.content[0].text)
    assert get_data["id"] == user_id
    assert get_data["email"] == "alice@example.com"

    # 再次查询用户列表
    list_result = await mcp_session.call_tool("list_users", {})
    list_data = json.loads(list_result.content[0].text)
    assert len(list_data) == 1
    assert list_data[0]["username"] == "alice"

@pytest.mark.asyncio
async def test_create_duplicate_user(mcp_session):
    """测试创建重复用户时的错误处理（发现服务潜在问题）"""
    # 第一次创建
    await mcp_session.call_tool(
        "create_user",
        {"username": "bob", "email": "bob@example.com"}
    )
    # 第二次创建相同用户名
    result = await mcp_session.call_tool(
        "create_user",
        {"username": "bob", "email": "another@example.com"}
    )
    error_data = json.loads(result.content[0].text)
    # 这里我们发现服务返回了 {“error”: “Duplicate username or email”}
    # 这是一个符合预期的业务逻辑错误，测试通过
    assert "error" in error_data
    assert "Duplicate" in error_data["error"]

@pytest.mark.asyncio
async def test_create_user_with_invalid_email(mcp_session):
    """测试无效邮箱格式（发现服务输入验证缺失的问题）"""
    # 服务代码中没有验证邮箱格式，这个请求会成功，这暴露了一个问题！
    result = await mcp_session.call_tool(
        "create_user",
        {"username": "charlie", "email": "not-an-email"}
    )
    data = json.loads(result.content[0].text)
    # 断言会失败，因为服务接受了无效邮箱。
    # 这个测试用例的目的就是为了“发现”这个服务缺陷。
    # 在真实场景中，我们可以将此作为Bug记录。
    # 暂时注释掉这个断言，因为我们已知服务有缺陷。
    # assert “error” in data  # 这行应该失败，说明服务需要加强输入验证
    print(f"[问题发现] 服务接受了无效邮箱格式: ‘not-an-email’。建议服务端添加邮箱格式验证。")

@pytest.mark.asyncio
async def test_delete_user(mcp_session):
    """测试删除用户"""
    # 先创建一个用户
    create_result = await mcp_session.call_tool(
        "create_user",
        {"username": "david", "email": "david@example.com"}
    )
    user_id = json.loads(create_result.content[0].text)["id"]

    # 删除用户
    delete_result = await mcp_session.call_tool("delete_user", {"user_id": user_id})
    delete_data = json.loads(delete_result.content[0].text)
    assert delete_data["status"] == "deleted"

    # 验证用户已删除
    get_result = await mcp_session.call_tool("get_user", {"user_id": user_id})
    get_data = json.loads(get_result.content[0].text)
    assert "error" in get_data
    assert get_data["error"] == "User not found"

6. 编排与运行：Docker Compose 配置

最后，我们需要一个 docker-compose.yaml 将服务、数据库和测试适配器编排起来，形成一个完整的、可测试的运行环境。

文件： docker-compose.yaml 

version: '3.8'
services:
  db:
    image: postgres:15-alpine
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: password
      POSTGRES_DB: users
    ports:
      - "5432:5432"
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 5
    volumes:
      - postgres_data:/var/lib/postgresql/data

  user_service:
    build: ./services/user_service
    ports:
      - "8000:8000"
    environment:
      DATABASE_URL: postgresql://postgres:password@db:5432/users
    depends_on:
      db:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/docs"]
      interval: 10s
      timeout: 5s
      retries: 5

  test_adapter:
    build: ./test_adapter
    depends_on:
      user_service:
        condition: service_healthy
    # 不暴露端口，通过 stdio 与测试进程通信

volumes:
  postgres_data:

运行测试：

  1. 确保在项目根目录（ no-code-change-test-demo/ ）。
  2. 启动整个环境并运行测试： 
    # 方式一：使用 pytest 直接运行（需要本地安装 pytest 和 mcp 客户端库）
# 首先，启动基础设施
docker-compose up -d db user_service test_adapter
# 然后，在另一个终端运行测试
cd tests
pip install -r requirements.txt
pytest -v
# 测试结束后，关闭环境
docker-compose down

# 方式二：编写一个集成脚本（推荐）
# 可以创建一个 run_tests.sh 脚本，顺序执行上述命令

运行测试后，你将看到测试通过或失败。关键在于， test_create_user_with_invalid_email 这个测试用例会“发现”我们服务中缺少邮箱格式验证的问题，而 我们从未修改过 services/user_service/app.py 中的代码 。测试通过适配器与真实服务交互，实现了问题的发现。

7. 常见问题与排查思路

在实践“无代码变更”测试模式时，你可能会遇到以下典型问题：

问题现象 可能原因 排查思路与解决方案
MCP Server 启动失败或连接超时 1. 依赖未正确安装。
2. Docker 容器内网络不通。
3. stdio 通信配置错误。 		1. 检查 test_adapter/requirements.txt 是否安装。
2. 在 test_adapter 容器内使用 curl http://user_service:8000/health 测试连通性。
3. 简化测试，先直接用 httpx 在 Python 脚本中调用服务 API，确保基础通信正常，再引入 MCP。
测试运行时找不到 user_service 主机 Docker Compose 网络配置问题，测试进程不在 Docker 网络内。 确保测试执行环境（如 pytest ）与 user_service 在同一 Docker 网络。最佳实践是 将测试本身也容器化 ，在 docker-compose.yaml 中添加一个 test_runner 服务，使用 depends_on 和相同网络。
测试结果不稳定（Flaky Tests） 1. 服务或数据库状态未在测试间隔离。
2. 异步操作超时时间设置过短。
3. 存在竞态条件。 		1. 每个测试用例必须独立 。在 conftest.py 的 session fixture 中初始化数据库（如清空表），或在每个测试用例前后清理数据。
2. 在 httpx.AsyncClient 和 MCP 客户端中增加合理的超时配置。
3. 使用更确定的等待条件，而非 time.sleep 。
MCP 工具调用返回格式错误 MCP Server 中 handle_call_tool 返回的数据格式不符合 MCP 协议。 严格遵循 MCP 协议规范。返回的字典必须包含 content 字段，且 content 是列表，列表中的每一项是 {"type": "text", "text": “...”} 的格式。使用 json.dumps 确保序列化正确。
无法模拟某些边界条件或异常 无代码变更测试是黑盒/灰盒，难以直接注入某些异常（如模拟数据库连接失败）。 采用混合策略：
1. 使用服务虚拟化（Service Virtualization） ：将某些依赖服务（如数据库、第三方API）替换为可控制的模拟器（如 WireMock, Mountebank）。
2. 流量录制与回放 ：在生产或测试环境录制真实流量，在测试中回放，以覆盖难以构造的复杂场景。

8. 最佳实践与工程建议

将“无代码变更”测试成功融入开发流程，需要遵循一些最佳实践：

  1. 测试适配层标准化 ：将 MCP Server 或类似的适配器进行封装和标准化，使其能够方便地接入不同的服务。可以考虑定义一套通用的“服务测试协议”，规定工具的名称、输入输出格式。
  2. 测试即基础设施 ：将测试环境（包括服务、数据库、测试适配器）的搭建完全代码化（如本文的 Docker Compose）。确保任何开发者都能通过一条命令（ docker-compose up && pytest ）启动完整环境并运行测试。
  3. 测试数据管理 ：
    • 独立与可重复 ：每个测试用例必须独立，不依赖其他用例的执行顺序或数据状态。使用事务或在测试前后清理数据库。
    • 数据工厂 ：在测试套件中创建辅助函数（如 create_test_user ），用于生成符合业务规则的测试数据，避免在测试用例中硬编码。
  4. 健康检查与就绪等待 ：在 Docker Compose 或测试启动脚本中，务必为服务（尤其是数据库）配置 healthcheck ，并在测试前等待服务完全就绪，避免因服务未启动导致的连接失败。
  5. 分层测试策略 ：“无代码变更”测试（通常是集成测试、端到端测试）是测试金字塔的上层。它不能替代底层的单元测试。正确的策略是：
    • 单元测试 ：针对函数、类内部的逻辑，快速、隔离。
    • 集成测试（无代码变更） ：验证服务间、服务与数据库的集成是否正确。
    • 契约测试 ：确保服务提供者与消费者之间的接口约定不被破坏。
    • 端到端测试 ：验证关键用户旅程。
  6. 持续集成（CI）集成 ：将这套测试流程集成到 CI/CD 流水线中。每次代码提交或合并请求，都自动启动 Docker 环境并运行无代码变更测试，确保新增功能或修改没有破坏现有服务的集成行为。
  7. 监控与告警 ：测试不仅是 CI 中的一环，也可以作为生产环境监控的补充。可以定期在生产环境的隔离沙箱中运行无代码变更的冒烟测试，作为系统健康度的一个指标。

通过以上步骤，我们构建了一个从概念到实践的完整闭环。你不仅学会了如何在不修改业务代码的情况下为服务添加测试，更重要的是掌握了一种将测试与开发解耦、以 API 和协议为中心的可持续测试架构思想。这套方法尤其适用于维护大型、复杂的微服务系统，能够显著降低测试维护成本，并更早地发现服务集成层面的问题。接下来，你可以尝试将这套模式应用到自己的项目中，从其中一个相对独立的服务开始，逐步构建起整个系统的“无代码变更”测试防护网。

# 集成测试
Logo
亚马逊云科技技术品牌专区

更多推荐

open-code-review Codex 插件教程：对话式调用评审技能指南

本文是一份面向新手的 **open-code-review Codex 插件教程**，教你在 Codex 中通过对话式方式调用 open-code-review 的 AI 代码评审技能。open-code-review 是阿里巴巴开源的 AI 代码评审工具，采用"确定性流水线 + LLM Agent"混合架构，内置多语言评审规则（NPE、线程安全、XSS、SQL 注入等），可在 Codex 里用一

avatar 亚马逊云科技技术品牌专区

OBS Studio 完整指南：免费开源录屏与直播软件从零上手

想做一场像模像样的直播，或者把屏幕内容录成教程视频，但一想到商用软件的订阅费就有些犹豫？其实你不需要花一分钱。OBS Studio 是一款免费开源的直播与录屏软件，支持 Windows、macOS 和 Linux，采集、混音、编码、推流、录制，一条流水线全包了。## 先搞清楚 OBS Studio 是什么OBS Studio 是一个"场景化"的采集合成工具：你把摄像头、窗口、浏览器、图片、

avatar 亚马逊云科技技术品牌专区

如何用MediaCrawler爬取小红书抖音数据？7大平台爬虫从安装到实战完整指南

MediaCrawler 是一个支持小红书、抖音、快手、B站、微博、百度贴吧、知乎的开源自媒体数据采集工具。它能按关键词、按帖子、按创作者主页三种方式抓取笔记/视频内容、评论甚至二级评论，并把结果存成 JSON、CSV、Excel 或数据库。适合做市场调研、竞品监控、内容选题的运营人员，以及想要现成爬虫框架而不想从零写 JS 逆向的开发者。## 从一次"手动抄数据"说起想象这个场景：你负责

avatar 亚马逊云科技技术品牌专区