Crawl4AI Docker 部署实战指南：从镜像运行到 REST API、Webhook 与 MCP 接入

Crawl4AI 的 deploy/docker 目录提供了一套开箱即用的容器化部署方案：基于 Gunicorn + Redis + Supervisor 的 API 服务，内置 Playground 调试界面、Python SDK 客户端、异步任务队列（含 Webhook 回调）以及 MCP（Model Context Protocol）端点。本文以仓库中的 deploy/docker/README.md 为主体骨架，结合 Dockerfile、docker-compose.yml、deploy/docker/config.yml 及服务器源码，完整讲解三种部署方式、Dockerfile 构建参数、API 请求结构规范、专项端点与监控配置，帮助读者把 Crawl4AI 以 REST 服务形式稳定跑在生产环境中。

前置条件

部署前确认本地环境满足以下要求：

• Docker 20.10.0 或更高版本并处于运行状态，需包含 docker compose（Docker Desktop 通常自带）；
• git，用于克隆仓库；
• 容器至少 4GB 可用内存（重度使用建议更多）；
• Python 3.10+（若使用 Python SDK）；
• Node.js 16+（若使用 Node.js 示例）。

可以用 docker info 检查 Docker 安装状态与可用资源。

部署方式一：直接拉取 Docker Hub 预构建镜像（推荐）

这是最快的路径，无需本地构建。

1. 拉取镜像

文档给出的最新稳定版标签为 0.8.6。镜像采用多架构 manifest 构建，Docker 会自动拉取匹配当前系统的版本：

# 拉取最新稳定版（0.8.6）
docker pull unclecode/crawl4ai:0.8.6

# 或使用 latest 标签
docker pull unclecode/crawl4ai:latest

注：仓库当前的 Dockerfile 中 C4AI_VER 已更新为 0.9.0，说明文档所述 0.8.6 对应的是文档编写时的发布标签；以 Docker Hub 实际可用标签为准。

2. 配置 LLM 环境变量

如果计划使用 LLM 功能（LLM 提取、语义策略等），在工作目录创建 .llm.env 文件：

cat > .llm.env << EOL
# OpenAI
OPENAI_API_KEY=sk-your-key

# Anthropic
ANTHROPIC_API_KEY=your-anthropic-key

# 按需添加其他提供商
# DEEPSEEK_API_KEY=your-deepseek-key
# GROQ_API_KEY=your-groq-key
# TOGETHER_API_KEY=your-together-key
# MISTRAL_API_KEY=your-mistral-key
# GEMINI_API_TOKEN=your-gemini-token
EOL

注意不要把 .llm.env 提交到版本控制系统。

3. 运行容器

基础运行（无 LLM）：

docker run -d \
  -p 11235:11235 \
  --name crawl4ai \
  --shm-size=1g \
  unclecode/crawl4ai:0.8.6

带 LLM 支持：

docker run -d \
  -p 11235:11235 \
  --name crawl4ai \
  --env-file .llm.env \
  --shm-size=1g \
  unclecode/crawl4ai:0.8.6

服务就绪后位于 http://localhost:11235，访问 /playground 可打开交互式测试界面。--shm-size=1g 是为 Chromium 提供共享内存，避免渲染崩溃。停止容器：

docker stop crawl4ai && docker rm crawl4ai

版本标签规则

• 镜像名：unclecode/crawl4ai
• 标签格式：LIBRARY_VERSION[-SUFFIX]（如 0.7.0-r1）；LIBRARY_VERSION 对应 crawl4ai Python 库的语义化版本，后缀用于发布候选与修订号；
• latest：指向最近的稳定版；
• 多架构：单一标签同时支持 linux/amd64 与 linux/arm64。

这一规则与 docker-compose.yml 中 image: ${IMAGE:-unclecode/crawl4ai:${TAG:-latest}} 的默认值一致。

部署方式二：Docker Compose

Compose 方式适合本地开发与测试。仓库根目录的 docker-compose.yml 内置了完整的安全加固配置，值得逐一了解：

• shm_size: "1gb"：私有 tmpfs 共享内存，替代直接挂载宿主机 /dev/shm；
• cap_drop: [ALL] + security_opt: no-new-privileges:true：最小权限；
• pids_limit: 512：限制进程数防资源滥用；
• read_only: true + tmpfs：只读根文件系统，仅 /tmp、/var/lib/redis、/var/lib/crawl4ai/outputs（0700 权限）、/home/appuser/.cache 可写；
• deploy.resources：内存上限 4G、预留 1G；
• healthcheck：每 30s 请求 /health，启动宽限期 40s。

操作步骤

1. 克隆仓库并进入根目录；
2. 复制 LLM 环境模板到项目根目录：

cp deploy/docker/.llm.env.example .llm.env
# 编辑 .llm.env 填入 API Key

3. 三种启动方式：

# 方式 A：拉取 Docker Hub 预构建镜像（自动选择正确架构）
IMAGE=unclecode/crawl4ai:0.8.6 docker compose up -d

# 方式 B：本地构建并运行
docker compose up --build -d

# 方式 C：带全部特性（torch + transformers）构建
INSTALL_TYPE=all docker compose up --build -d

# 带 GPU 支持构建（仅限 AMD64 平台）
ENABLE_GPU=true docker compose up --build -d

4. 停止服务：docker compose down。

灵活的 LLM 提供商配置

Docker 服务端通过三个优先级层次决定使用哪个 LLM：

1. 环境变量 LLM_PROVIDER（最高优先级）：

   export LLM_PROVIDER="anthropic/claude-3-opus"
   # 或写入 .llm.env：LLM_PROVIDER=anthropic/claude-3-opus
   

2. 请求参数 provider（按请求覆盖）：

   {
     "url": "https://example.com",
     "provider": "groq/mixtral-8x7b"
   }
   

3. config.yml 默认值（兜底）：默认 openai/gpt-4o-mini，见 deploy/docker/config.yml。

系统会根据提供商自动选取对应的 API Key 环境变量，无需为每个 Key 单独配置路由。

部署方式三：手动本地构建

当需要直接掌控构建与运行流程时使用。

使用 buildx 构建镜像

# 构建当前架构并加载到 Docker
docker buildx build -t crawl4ai-local:latest --load .

# 多架构构建（发布用）
docker buildx build --platform linux/amd64,linux/arm64 -t crawl4ai-local:latest --load .

# 带构建参数
docker buildx build \
  --build-arg INSTALL_TYPE=all \
  --build-arg ENABLE_GPU=false \
  -t crawl4ai-local:latest --load .

运行容器

# 基础运行
docker run -d \
  -p 11235:11235 \
  --name crawl4ai-standalone \
  --shm-size=1g \
  crawl4ai-local:latest

# 带 LLM 支持（.llm.env 位于当前目录）
docker run -d \
  -p 11235:11235 \
  --name crawl4ai-standalone \
  --env-file .llm.env \
  --shm-size=1g \
  crawl4ai-local:latest

停止：docker stop crawl4ai-standalone && docker rm crawl4ai-standalone

Dockerfile 构建参数详解

所有构建行为都由 --build-arg 控制，参数定义在 Dockerfile 顶部：

参数	说明	默认值	可选值
INSTALL_TYPE	特性集	default	default / all / torch / transformer
ENABLE_GPU	GPU 支持（AMD64 安装 CUDA）	false	true / false
APP_HOME	容器内安装路径（高级）	/app	任意有效路径
USE_LOCAL	是否从本地构建上下文安装	true	true / false
GITHUB_REPO	USE_LOCAL=false 时克隆的仓库	仓库源码	任意 git URL
GITHUB_BRANCH	克隆分支	main	任意分支名

Python 版本由 FROM python:3.12-slim-bookworm 固定（见 Dockerfile）。

参数在源码中的实际行为

结合 Dockerfile 可以看到各参数的落地逻辑：

• INSTALL_TYPE=all：额外安装 torch、torchvision、torchaudio、scikit-learn、nltk、transformers、tokenizers，下载 NLTK 语料，并执行 python -m crawl4ai.model_loader 预拉取嵌入模型。这组依赖支撑 CosineStrategy 等高级提取策略，镜像体积显著增大，确认需要再开；
• INSTALL_TYPE=torch / transformer：分别只装 PyTorch 系或只装 Transformers 系；
• INSTALL_TYPE=default：最小安装，适合标准网页抓取与 Markdown 生成；
• ENABLE_GPU=true 且目标架构为 amd64 时安装 nvidia-cuda-toolkit（Dockerfile）；
• 平台特定优化：arm64 安装 libopenblas-dev，amd64 安装 libomp-dev（Dockerfile）。

构建最佳实践

1. 按需选择 INSTALL_TYPE：绝大多数部署 default 即可；
2. 多架构用 buildx：推送到镜像仓库时使用 --platform 构建；
3. 容器安全基线：Dockerfile 内置了非 root 用户 appuser、只读 /app 目录（防止写入型自我提权）、沙箱化产物目录 /var/lib/crawl4ai/outputs（0700）以及内存/Redis/健康检查三重 HEALTHCHECK（Dockerfile）。

使用 API

服务默认监听 http://localhost:11235。

Playground 调试界面

http://localhost:11235/playground 提供内置 Web 界面，支持：

1. 使用主库的 Python 语法配置 CrawlerRunConfig 和 BrowserConfig；
2. 直接在界面上测试抓取；
3. 基于当前配置生成对应的 REST JSON 请求体。

这是把 Python 配置翻译为 JSON 请求体最省事的方式。

Python SDK 方式

import asyncio
from crawl4ai.docker_client import Crawl4aiDockerClient
from crawl4ai import BrowserConfig, CrawlerRunConfig, CacheMode

async def main():
    async with Crawl4aiDockerClient(base_url="http://localhost:11235", verbose=True) as client:
        # 若服务端启用了 JWT：await client.authenticate("[e-mail]")

        # 非流式抓取
        results = await client.crawl(
            ["https://httpbin.org/html"],
            browser_config=BrowserConfig(headless=True),
            crawler_config=CrawlerRunConfig(cache_mode=CacheMode.BYPASS)
        )
        if results and results.success:
            for result in results:  # 遍历 CrawlResultContainer
                print(f"URL: {result.url}, Success: {result.success}")

        # 流式抓取：client.crawl 返回异步生成器
        stream_config = CrawlerRunConfig(stream=True, cache_mode=CacheMode.BYPASS)
        async for result in await client.crawl(
            ["https://httpbin.org/html", "https://httpbin.org/links/5/0"],
            browser_config=BrowserConfig(headless=True),
            crawler_config=stream_config
        ):
            print(f"Streamed result: {result.url}, Success: {result.success}")

        # 获取完整 API schema
        schema = await client.get_schema()
        print(f"Schema received: {bool(schema)}")

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

Crawl4aiDockerClient 的实现位于 crawl4ai/docker_client.py。

直接 JSON 调用：配置对象类型包装规则

这是直接使用 REST API 最容易踩坑的地方：任何非原始值（配置对象、策略）都必须包装为 {"type": "ClassName", "params": {...}} 结构；字典值则包装为 {"type": "dict", "value": {...}}；枚举使用字符串值（如 cache_mode: "bypass"）。

CSS 提取策略示例：

{
    "crawler_config": {
        "type": "CrawlerRunConfig",
        "params": {
            "extraction_strategy": {
                "type": "JsonCssExtractionStrategy",
                "params": {
                    "schema": {
                        "type": "dict",
                        "value": {
                            "baseSelector": "article.post",
                            "fields": [
                                {"name": "title", "selector": "h1", "type": "text"},
                                {"name": "content", "selector": ".content", "type": "html"}
                            ]
                        }
                    }
                }
            }
        }
    }
}

完整 API 结构可访问 /schema 端点获取。

REST API 示例：简单抓取

import requests

browser_config_payload = {
    "type": "BrowserConfig",
    "params": {"headless": True}
}
crawler_config_payload = {
    "type": "CrawlerRunConfig",
    "params": {"stream": False, "cache_mode": "bypass"}  # 枚举用字符串值
}

crawl_payload = {
    "urls": ["https://httpbin.org/html"],
    "browser_config": browser_config_payload,
    "crawler_config": crawler_config_payload
}
response = requests.post(
    "http://localhost:11235/crawl",
    # headers={"Authorization": f"Bearer {token}"},  # JWT 启用时
    json=crawl_payload
)
print(f"Status Code: {response.status_code}")
print(response.json() if response.ok else response.text)

流式抓取（NDJSON）

/crawl/stream 以 NDJSON（每行一个 JSON 对象）逐条推送结果，遇到 {"status": "completed"} 表示流结束：

import json, httpx

async def test_stream_crawl(token: str = None):
    url = "http://localhost:11235/crawl/stream"
    payload = {
        "urls": ["https://httpbin.org/html", "https://httpbin.org/links/5/0"],
        "browser_config": {
            "type": "BrowserConfig",
            "params": {
                "headless": True,
                "viewport": {"type": "dict", "value": {"width": 1200, "height": 800}}
                # viewport 这类字典必须包 type:dict
            }
        },
        "crawler_config": {
            "type": "CrawlerRunConfig",
            "params": {"stream": True, "cache_mode": "bypass"}
        }
    }
    async with httpx.AsyncClient() as client:
        async with client.stream("POST", url, json=payload, timeout=120.0) as response:
            response.raise_for_status()
            async for line in response.aiter_lines():
                if line:
                    data = json.loads(line)
                    if data.get("status") == "completed":
                        print("Stream completed.")
                        break
                    print(f"Streamed Result: {json.dumps(data, indent=2)}")

专项端点

除核心的 /crawl 与 /crawl/stream 外，服务端还提供一组功能端点：

• POST /html：抓取并返回面向 schema 提取优化的预处理 HTML。请求体仅需 {"url": "https://example.com"}；
• POST /screenshot：截取整页 PNG 截图。参数：
  • screenshot_wait_for：截图前等待秒数（默认 2）；
  • output_path：截图保存路径（推荐）。

  {"url": "https://example.com", "screenshot_wait_for": 2,
   "output_path": "/path/to/save/screenshot.png"}
  

• POST /pdf：为指定 URL 生成 PDF，output_path 可选但推荐：

  {"url": "https://example.com", "output_path": "/path/to/save/document.pdf"}
  

• POST /execute_js：在页面上顺序执行 JavaScript 片段并返回完整抓取结果：

  {
    "url": "https://example.com",
    "scripts": [
      "return document.title",
      "return Array.from(document.querySelectorAll('a')).map(a => a.href)"
    ]
  }
  

  注意：这些端点对应 server.py 中同名路由，且均被注册为 MCP 工具（下文）。

异步任务与 Webhook 回调

对于长时间抓取或不希望占用长连接的场景，使用任务队列端点。

工作原理

1. POST /crawl/job 提交任务（可带可选 webhook_config）；
2. 立即收到 task_id；
3. 任务在后台执行（队列参数见 deploy/docker/config.yml：最多 1000 个排队任务、4 个并发 worker）；
4. 完成后服务端向 webhook 地址 POST 通知；
5. 如通知中不含数据，再用 GET /crawl/job/{task_id} 获取结果。

重试策略为指数退避：5 次尝试，1s → 2s → 4s → 8s → 16s。

快速示例

curl -X POST http://localhost:11235/crawl/job \
  -H "Content-Type: application/json" \
  -d '{
    "urls": ["https://example.com"],
    "webhook_config": {
      "webhook_url": "https://myapp.com/webhooks/crawl-complete",
      "webhook_data_in_payload": false
    }
  }'
# 响应: {"task_id": "crawl_a1b2c3d4"}

Webhook 收到的通知：

{
  "task_id": "crawl_a1b2c3d4",
  "task_type": "crawl",
  "status": "completed",
  "timestamp": "2025-10-21T10:30:00.000000+00:00",
  "urls": ["https://example.com"]
}

随后拉取结果：curl http://localhost:11235/crawl/job/crawl_a1b2c3d4

通知中直接携带数据

设置 webhook_data_in_payload: true，完整抓取结果（markdown、html、links、metadata）直接随通知到达，省去二次请求。

Webhook 认证头

{
  "urls": ["https://example.com"],
  "webhook_config": {
    "webhook_url": "https://myapp.com/webhooks/crawl",
    "webhook_data_in_payload": false,
    "webhook_headers": {
      "X-Webhook-Secret": "your-secret-token",
      "X-Service-ID": "crawl4ai-prod"
    }
  }
}

实现层面对自定义头有严格清洗：deploy/docker/webhook.py 中 sanitize_webhook_headers 限制最多 20 个自定义头、头名必须匹配 ^[A-Za-z0-9-]{1,64}$、禁用 Authorization/Cookie/Host 等敏感与逐跳头、拒绝 CRLF 注入——用户提供的头不可能伪造系统头。

全局默认 Webhook

在 config.yml 中配置默认回调后，未带 webhook_config 的任务自动使用它（见 deploy/docker/config.yml 的 webhooks 段）：

webhooks:
  enabled: true
  default_url: "https://myapp.com/webhooks/default"
  data_in_payload: false
  retry:
    max_attempts: 5
    initial_delay_ms: 1000
    max_delay_ms: 32000
    timeout_ms: 30000

轮询模式（不用 Webhook）

省略 webhook_config 即可，通过 GET /crawl/job/{task_id} 轮询，响应中 status 取值为 "processing" / "completed" / "failed"。任务数据在 Redis 中按 task_ttl_seconds（默认 3600 秒）过期。

LLM 提取任务

/llm/job 走同一套 Webhook 体系：

curl -X POST http://localhost:11235/llm/job \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/article",
    "q": "Extract the article title, author, and main points",
    "provider": "openai/gpt-4o-mini",
    "webhook_config": {
      "webhook_url": "https://myapp.com/webhooks/llm-complete",
      "webhook_data_in_payload": true,
      "webhook_headers": {"X-Webhook-Secret": "your-secret-token"}
    }
  }'
# 响应: {"task_id": "llm_1234567890"}

与抓取任务的关键差异：task_type 为 "llm_extraction"；结果位于 data.extracted_content；仅接受单个 URL（非数组）；支持 schema 参数做结构化提取。

更多客户端示例（TypeScript 客户端、Flask webhook 处理器、失败处理）见 deploy/docker/WEBHOOK_EXAMPLES.md。

MCP（Model Context Protocol）支持

Crawl4AI 服务端内置 MCP 层，可让 MCP 兼容客户端（如 Claude Code）直接把抓取能力当工具调用。服务端通过 deploy/docker/mcp_bridge.py 的 attach_mcp() 在启动时挂载 MCP 路由（见 deploy/docker/server.py），内部工具调用经 loopback 转发到自身受鉴权保护的 HTTP 端点，并附带短期 data-scope 服务令牌。

MCP 端点

• SSE：http://localhost:11235/mcp/sse
• WebSocket：ws://localhost:11235/mcp/ws
• Schema：http://localhost:11235/mcp/schema

接入 Claude Code

claude mcp add --transport sse c4ai-sse http://localhost:11235/mcp/sse
claude mcp list

可用 MCP 工具

与源码中 @mcp_tool 装饰的七个路由一一对应（deploy/docker/server.py 起）：

工具	功能
md	网页内容生成 Markdown
html	提取预处理 HTML
screenshot	页面截图
pdf	生成 PDF
execute_js	在页面执行 JavaScript
crawl	多 URL 批量抓取
ask	基于库上下文（BM25 检索）回答 Crawl4AI 用法问题

测试 MCP 连接

仓库自带 WebSocket 测试脚本：

python tests/mcp/test_mcp_socket.py

（另有 tests/mcp/test_mcp_sse.py 用于 SSE 通道。）

监控与可观测性

• GET /health：快速健康检查，例如 curl http://localhost:11235/health；
• GET /metrics：Prometheus 指标端点（config.yml 中 observability.prometheus.enabled: True 开启）；
• GET /schema：完整 API schema。

容器 HEALTHCHECK 除探活 /health 外还检查内存是否低于 2GB 以及 Redis 是否可达（Dockerfile），配合 Compose 的 healthcheck 可用于自动重启策略。

服务端配置：config.yml 深度解析

容器内配置从 /app/config.yml 加载，默认由 deploy/docker/config.yml 在构建时复制进去。以仓库当前实际文件为准，各段含义如下：

app:
  title: "Crawl4AI API"
  host: "127.0.0.1"   # 默认 loopback；非 loopback 绑定需要凭据
  port: 11235
  reload: False
  workers: 1
  timeout_keep_alive: 300

llm:
  provider: "openai/gpt-4o-mini"  # 可被 LLM_PROVIDER 环境变量覆盖

redis:
  host: "localhost"
  port: 6379
  db: 0
  password: ""
  task_ttl_seconds: 3600  # 任务数据 TTL，0 为禁用（不推荐）

limits:                 # 资源治理（DoS 防护），0 表示不限制
  max_body_bytes: 10485760  # 10 MiB 请求体上限（超出 413）
  max_pages: 100          # 深度抓取页数预算
  max_depth: 5            # 深度抓取深度上限
  wall_clock_s: 0         # 单次抓取墙钟期限（超时 504）
  queue:
    maxsize: 1000         # 后台队列上限（满则 503）
    workers: 4            # 并发后台 worker
    per_principal: 0      # 单调用方并发上限（超限 429）

rate_limiting:
  enabled: True
  default_limit: "1000/minute"
  trusted_proxies: []
  storage_uri: "memory://"  # 生产环境多容器建议 "redis://localhost:6379"

security:
  enabled: true
  jwt_enabled: false
  api_token: ""          # 设置后 /token 端点需要该密钥才能签发 JWT
  https_redirect: false
  trusted_hosts: ["*"]
  cors_allow_origins: [] # 默认拒绝，需显式列出来源
  headers:
    x_content_type_options: "nosniff"
    x_frame_options: "DENY"
    content_security_policy: "default-src 'self'"
    strict_transport_security: "max-age=63072000; includeSubDomains"

crawler:
  memory_threshold_percent: 95.0
  rate_limiter:
    enabled: true
    base_delay: [1.0, 2.0]   # dispatcher 请求间隔（秒）
  timeouts:
    stream_init: 30.0
    batch_process: 300.0
  pool:
    max_pages: 40           # 全局页面池许可
    idle_ttl_sec: 300       # 空闲回收
  browser:
    kwargs:
      headless: true
      text_mode: true
    extra_args:
      - "--no-sandbox"
      - "--disable-dev-shm-usage"
      - "--disable-gpu"
      - "--disable-software-rasterizer"

logging:
  level: "INFO"
  format: "%(asctime)s - %(name)s - %(levelname)s - %(message)s"

observability:
  prometheus:
    enabled: True
    endpoint: "/metrics"
  health_check:
    endpoint: "/health"

webhooks:
  enabled: true
  default_url: null
  data_in_payload: false
  retry:
    max_attempts: 5
    initial_delay_ms: 1000
    max_delay_ms: 32000
    timeout_ms: 30000
  headers:
    User-Agent: "Crawl4AI-Webhook/1.0"

要点说明：

• app.host 默认 127.0.0.1，暴露到 0.0.0.0 必须配置凭据（CRAWL4AI_API_TOKEN），启动鉴权守卫会拒绝无凭据的非 loopback 绑定（deploy/docker/config.yml 注释）；
• redis.task_ttl_seconds 防止任务结果无限累积占内存，可用环境变量 REDIS_TASK_TTL 覆盖；
• limits 段是 DoS 防护层，每项设为 0 可回退到不限制；
• security.enabled: true 为当前默认，jwt_enabled 默认关闭，需要认证时将其设为 true 并设置 SECRET_KEY 环境变量；api_token 用于保护 JWT 签发端点。

自定义配置

方法一：构建前修改 —— 编辑本地克隆中的 deploy/docker/config.yml 再执行构建，修改会被打入镜像。

方法二：运行时挂载（推荐用于自定义部署） —— 将本地完整配置文件挂载覆盖容器内配置：

docker run -d -p 11235:11235 \
  --name crawl4ai-custom-config \
  --env-file .llm.env \
  --shm-size=1g \
  -v $(pwd)/my-custom-config.yml:/app/config.yml \
  unclecode/crawl4ai:latest

或在 Compose 服务定义中加 volumes: - ./my-custom-config.yml:/app/config.yml。注意挂载文件会完全替换默认配置，必须包含所有必要段落。

配置建议

1. 安全优先：生产环境保持 security.enabled: true，trusted_hosts 用具体域名代替通配符，保留速率限制，启用 HTTPS 重定向前确认前置反向代理已做 TLS；
2. 资源管理：按实际内存调整 memory_threshold_percent；按内容规模与网络条件调整 timeouts；多容器部署用 Redis 作为限流存储；
3. 监控：需要指标就保留 Prometheus 端点；开发用 DEBUG、生产用 INFO 日志级别；定期跑健康检查；
4. 性能调优：rate_limiter.base_delay 从保守值起步，大内容场景上调 batch_process 超时，按首字节响应情况调整 stream_init。

小结

围绕 deploy/docker 部署目录，Crawl4AI 提供了一条完整的容器化服务链路：三种部署路径（Docker Hub 镜像、Compose、手动 buildx 构建）覆盖从快速试用到完全定制的各阶段；REST API 通过 {"type": ..., "params": ...} 类型包装约定将 Python 配置对象无损序列化，并配套 Playground 一键生成请求体；/crawl/job、/llm/job 任务队列加指数退避 Webhook 让长时间任务可异步化；MCP 端点把七个数据面工具直接暴露给 AI 客户端；config.yml 则集中管理速率限制、资源上限、安全头与队列参数。仓库内 tests/docker/ 与 deploy/docker/tests/ 下还有大量可直接运行的集成与测试脚本，可作为各端点的行为验证参考。