TikTok矩阵系统开发实战：跨境出海多账号高效协同管理完整技术实现

原创于 2026-06-18 14:56:15 发布 · 240 阅读

本内容遵循CC 4.0 BY-SA版权协议

标签

#windows #个人开发 #tk矩阵 #运维 #自动化

TikTok矩阵系统是跨境出海团队实现海外多账号规模化运营的核心技术支撑。随着TikTok全球流量生态的成熟，越来越多出海品牌布局多账号矩阵，覆盖不同语种与区域受众，分散单一账号的运营风险。但手动管理模式效率低、易触发风控，我结合实际开发经验，拆解一套轻量化系统的实现方案与可运行代码。

一、TikTok矩阵系统的整体架构设计与核心模块

系统采用分层模块化设计，自上而下分为接入层、业务逻辑层、数据持久层与基础资源层，包含六大核心组件，各模块接口解耦便于迭代。最开始写的单体脚本难维护，后来重构为分层架构，以下是核心入口代码。

import os
import logging
from datetime import datetime
from typing import Dict, List, Optional

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
    handlers=[logging.FileHandler("matrix_system.log"), logging.StreamHandler()]
)
logger = logging.getLogger("TikTokMatrixSystem")

class TikTokMatrixSystem:
    def __init__(self, config_path: str = "config.yaml"):
        self.config = self._load_config(config_path)
        self.account_manager = None
        self.task_scheduler = None
        self.risk_engine = None
        self.content_distributor = None
        self.data_collector = None
        self.permission_control = None
        self.system_status = "init"
        self._init_modules()
        logger.info("系统核心模块初始化完成")

    def _load_config(self, config_path: str) -> Dict:
        try:
            import yaml
            with open(config_path, "r", encoding="utf-8") as f:
                config = yaml.safe_load(f)
            return config
        except FileNotFoundError:
            logger.error(f"配置文件不存在: {config_path}")
            raise

    def _init_modules(self) -> None:
        from account_manager import AccountManager
        from task_scheduler import TaskScheduler
        from risk_engine import RiskControlEngine
        from content_distributor import ContentDistributor
        from data_collector import DataCollector
        from permission_control import PermissionManager
        self.account_manager = AccountManager(self.config.get("account", {}))
        self.task_scheduler = TaskScheduler(self.config.get("scheduler", {}))
        self.risk_engine = RiskControlEngine(self.config.get("risk_control", {}))
        self.content_distributor = ContentDistributor(self.config.get("content", {}))
        self.data_collector = DataCollector(self.config.get("data", {}))
        self.permission_control = PermissionManager(self.config.get("permission", {}))
        self.system_status = "running"

    def start_system(self) -> None:
        if self.system_status != "running":
            logger.error("系统未完成初始化，无法启动")
            return
        self.task_scheduler.start()
        logger.info("系统已启动，任务调度器运行中")

    def stop_system(self) -> None:
        self.task_scheduler.shutdown()
        self.system_status = "stopped"
        logger.info("系统已停止")

    def get_system_status(self) -> Dict:
        return {
            "system_status": self.system_status,
            "account_count": self.account_manager.get_total_account_count(),
            "running_task_count": self.task_scheduler.get_running_task_num(),
            "last_heartbeat": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        }

if __name__ == "__main__":
    matrix_system = TikTokMatrixSystem()
    matrix_system.start_system()
    print(matrix_system.get_system_status())

二、多账号身份凭证的安全存储与批量管理

账号凭证是核心敏感数据，我之前图省事存明文差点出问题，后来改用AES对称加密存储Token，基于SQLite实现账号管理，支持批量导入、分组管理，从底层保障数据安全。

import sqlite3
import hashlib
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
from base64 import b64encode, b64decode
from typing import List, Dict, Optional

class AESEncryptor:
    def __init__(self, secret_key: str):
        self.key = hashlib.sha256(secret_key.encode("utf-8")).digest()
        self.block_size = AES.block_size

    def encrypt(self, plain_text: str) -> str:
        cipher = AES.new(self.key, AES.MODE_CBC)
        ct_bytes = cipher.encrypt(pad(plain_text.encode("utf-8"), self.block_size))
        iv = b64encode(cipher.iv).decode("utf-8")
        ct = b64encode(ct_bytes).decode("utf-8")
        return f"{iv}:{ct}"

    def decrypt(self, cipher_text: str) -> str:
        try:
            iv, ct = cipher_text.split(":")
            iv = b64decode(iv)
            ct = b64decode(ct)
            cipher = AES.new(self.key, AES.MODE_CBC, iv)
            pt = unpad(cipher.decrypt(ct), self.block_size)
            return pt.decode("utf-8")
        except Exception as e:
            raise ValueError(f"凭证解密失败: {str(e)}")

class AccountManager:
    def __init__(self, config: Dict):
        self.db_path = config.get("db_path", "accounts.db")
        self.encryptor = AESEncryptor(config.get("encrypt_secret", "default_secret"))
        self._init_db()

    def _init_db(self) -> None:
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        cursor.execute("""
            CREATE TABLE IF NOT EXISTS tiktok_accounts (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                account_id TEXT UNIQUE NOT NULL,
                username TEXT NOT NULL,
                region TEXT NOT NULL,
                group_name TEXT DEFAULT 'default',
                encrypted_token TEXT NOT NULL,
                status TEXT DEFAULT 'active',
                create_time TEXT NOT NULL,
                last_login_time TEXT,
                remark TEXT
            )
        """)
        conn.commit()
        conn.close()

    def add_account(self, account_info: Dict) -> bool:
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            encrypted_token = self.encryptor.encrypt(account_info["token"])
            cursor.execute("""
                INSERT INTO tiktok_accounts 
                (account_id, username, region, group_name, encrypted_token, create_time, remark)
                VALUES (?, ?, ?, ?, ?, ?, ?)
            """, (
                account_info["account_id"], account_info["username"],
                account_info["region"], account_info.get("group_name", "default"),
                encrypted_token, datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                account_info.get("remark", "")
            ))
            conn.commit()
            return True
        except sqlite3.IntegrityError:
            logger.warning(f"账号已存在: {account_info['account_id']}")
            return False
        finally:
            conn.close()

    def batch_import_accounts(self, account_list: List[Dict]) -> Dict:
        success, failed = 0, 0
        for acc in account_list:
            if self.add_account(acc): success += 1
            else: failed += 1
        return {"success": success, "failed": failed}

    def get_account_by_id(self, account_id: str) -> Optional[Dict]:
        conn = sqlite3.connect(self.db_path)
        conn.row_factory = sqlite3.Row
        cursor = conn.cursor()
        cursor.execute("SELECT * FROM tiktok_accounts WHERE account_id = ?", (account_id,))
        row = cursor.fetchone()
        conn.close()
        if not row: return None
        account = dict(row)
        account["token"] = self.encryptor.decrypt(account["encrypted_token"])
        del account["encrypted_token"]
        return account

    def get_total_account_count(self) -> int:
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        cursor.execute("SELECT COUNT(*) FROM tiktok_accounts WHERE status = 'active'")
        count = cursor.fetchone()[0]
        conn.close()
        return count

三、自动化任务调度引擎的实现逻辑

任务调度是自动化运营的核心，最早用循环加 sleep 时间不准还容易阻塞，后来换成APScheduler做内核，加入错峰执行策略，支持任务重试与完整日志追溯。

import time
import random
from apscheduler.schedulers.background import BackgroundScheduler
from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
from typing import Dict, List
from datetime import datetime, timedelta

class TaskScheduler:
    def __init__(self, config: Dict):
        self.config = config
        jobstores = {'default': SQLAlchemyJobStore(url='sqlite:///jobs.db')}
        self.scheduler = BackgroundScheduler(jobstores=jobstores, timezone='Asia/Shanghai')
        self.min_interval = config.get("min_interval_seconds", 300)
        self.max_interval = config.get("max_interval_seconds", 900)

    def add_publish_task(self, account_id: str, content_id: str, publish_time: datetime) -> str:
        job_id = f"publish_{account_id}_{content_id}_{int(time.time())}"
        self.scheduler.add_job(
            func=self._execute_publish_task, trigger='date',
            run_date=publish_time, args=[account_id, content_id],
            id=job_id, replace_existing=True
        )
        return job_id

    def add_cycle_collect_task(self, account_list: List[str], cycle_hours: int = 24) -> str:
        job_id = f"collect_cycle_{int(time.time())}"
        self.scheduler.add_job(
            func=self._execute_collect_task, trigger='interval',
            hours=cycle_hours, args=[account_list], id=job_id, replace_existing=True
        )
        return job_id

    def _execute_publish_task(self, account_id: str, content_id: str) -> None:
        delay = random.randint(self.min_interval, self.max_interval)
        time.sleep(delay)
        try:
            from content_distributor import ContentDistributor
            distributor = ContentDistributor()
            distributor.publish_content(account_id, content_id)
        except Exception as e:
            logger.error(f"账号 {account_id} 发布失败: {str(e)}，10分钟后重试")
            self.scheduler.add_job(
                func=self._execute_publish_task, trigger='date',
                run_date=datetime.now() + timedelta(minutes=10),
                args=[account_id, content_id],
                id=f"retry_{account_id}_{content_id}_{int(time.time())}"
            )

    def _execute_collect_task(self, account_list: List[str]) -> None:
        for acc_id in account_list:
            time.sleep(random.randint(60, 180))
            try:
                from data_collector import DataCollector
                DataCollector().collect_account_data(acc_id)
            except Exception as e:
                logger.error(f"账号 {acc_id} 采集失败: {str(e)}")

    def start(self) -> None:
        if not self.scheduler.running:
            self.scheduler.start()

    def shutdown(self) -> None:
        self.scheduler.shutdown(wait=False)

    def get_running_task_num(self) -> int:
        return len(self.scheduler.get_jobs()) if self.scheduler.running else 0

四、账号行为风控与环境隔离机制

风控是系统的生命线，我之前所有账号共用IP导致批量限流，踩了大坑。现在实现了代理池、设备指纹、随机间隔三大能力，每个账号绑定独立环境，降低关联风险。

import random
import requests
from fake_useragent import UserAgent
from typing import Dict, List, Optional

class ProxyPool:
    def __init__(self, proxy_list: List[str]):
        self.proxies = proxy_list
        self.used_map = {}

    def get_proxy(self, account_id: str) -> Optional[Dict]:
        if account_id not in self.used_map:
            if not self.proxies: return None
            self.used_map[account_id] = random.choice(self.proxies)
        proxy_str = self.used_map[account_id]
        return {"http": f"http://{proxy_str}", "https": f"http://{proxy_str}"}

class DeviceFingerprint:
    def __init__(self):
        self.ua_generator = UserAgent()

    def generate_fingerprint(self, account_id: str) -> Dict:
        seed = hash(account_id)
        random.seed(seed)
        fingerprint = {
            "user_agent": self.ua_generator.random,
            "device_model": random.choice(["iPhone 14", "Samsung S24", "Xiaomi 14"]),
            "os_version": random.choice(["iOS 17.4", "Android 14"]),
            "app_version": random.choice(["32.5.0", "32.4.1", "32.3.0"]),
            "language": random.choice(["en-US", "es-ES", "fr-FR"]),
            "timezone": random.choice(["America/New_York", "Europe/London"])
        }
        random.seed()
        return fingerprint

class RiskControlEngine:
    def __init__(self, config: Dict):
        self.proxy_pool = ProxyPool(config.get("proxy_list", []))
        self.fingerprint_generator = DeviceFingerprint()
        self.account_env = {}
        self.min_action_delay = config.get("min_action_delay", 15)
        self.max_action_delay = config.get("max_action_delay", 60)

    def get_account_request_config(self, account_id: str) -> Dict:
        if account_id not in self.account_env:
            self.account_env[account_id] = {
                "fingerprint": self.fingerprint_generator.generate_fingerprint(account_id),
                "proxy": self.proxy_pool.get_proxy(account_id),
                "last_action_time": 0
            }
        env = self.account_env[account_id]
        headers = {
            "User-Agent": env["fingerprint"]["user_agent"],
            "Accept-Language": env["fingerprint"]["language"],
            "X-Tiktok-App-Version": env["fingerprint"]["app_version"],
            "Referer": "https://www.tiktok.com/"
        }
        return {"headers": headers, "proxies": env["proxy"], "timeout": 30}

    def random_delay(self, account_id: str) -> None:
        time.sleep(random.randint(self.min_action_delay, self.max_action_delay))
        self.account_env[account_id]["last_action_time"] = time.time()

    def send_safe_request(self, account_id: str, method: str, url: str, **kwargs) -> requests.Response:
        self.random_delay(account_id)
        kwargs.update(self.get_account_request_config(account_id))
        try:
            response = requests.request(method, url, **kwargs)
            response.raise_for_status()
            return response
        except requests.RequestException as e:
            logger.warning(f"账号 {account_id} 请求异常: {str(e)}")
            raise

五、跨账号内容素材的同步与分发实现

内容分发模块支持批量同步素材，可按区域差异化配置文案标签。内置MD5去重机制避免重复内容被检测，支持错峰发布，适配不同区域的用户活跃时段。

import os
import hashlib
import json
import shutil
import time
import random
from typing import Dict, List, Optional
from datetime import datetime

class MaterialManager:
    def __init__(self, material_dir: str = "./materials"):
        self.material_dir = material_dir
        self.md5_map_path = os.path.join(material_dir, "material_md5.json")
        self._init_dir()
        self.md5_map = self._load_md5_map()

    def _init_dir(self) -> None:
        if not os.path.exists(self.material_dir):
            os.makedirs(self.material_dir)

    def _load_md5_map(self) -> Dict:
        if os.path.exists(self.md5_map_path):
            with open(self.md5_map_path, "r", encoding="utf-8") as f:
                return json.load(f)
        return {}

    def _save_md5_map(self) -> None:
        with open(self.md5_map_path, "w", encoding="utf-8") as f:
            json.dump(self.md5_map, f, ensure_ascii=False, indent=2)

    def calculate_md5(self, file_path: str) -> str:
        hash_md5 = hashlib.md5()
        with open(file_path, "rb") as f:
            for chunk in iter(lambda: f.read(4096), b""):
                hash_md5.update(chunk)
        return hash_md5.hexdigest()

    def add_material(self, file_path: str, material_info: Dict) -> Optional[str]:
        md5 = self.calculate_md5(file_path)
        if md5 in self.md5_map:
            return self.md5_map[md5]["material_id"]
        material_id = f"mat_{int(time.time())}_{random.randint(1000,9999)}"
        save_path = os.path.join(self.material_dir, f"{material_id}{os.path.splitext(file_path)[1]}")
        shutil.copy(file_path, save_path)
        self.md5_map[md5] = {
            "material_id": material_id, "file_path": save_path,
            "info": material_info, "create_time": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        }
        self._save_md5_map()
        return material_id

class ContentDistributor:
    def __init__(self, config: Dict = None):
        self.material_manager = MaterialManager()
        self.config = config or {}

    def render_content(self, template: str, account_info: Dict) -> str:
        content = template.replace("{username}", account_info["username"])
        content = content.replace("{region}", account_info["region"])
        tags = account_info.get("tags", [])
        random.shuffle(tags)
        content = content.replace("{tags}", " ".join([f"#{t}" for t in tags]))
        return content

    def publish_content(self, account_id: str, material_id: str) -> Dict:
        from account_manager import AccountManager
        account_info = AccountManager().get_account_by_id(account_id)
        if not account_info: raise ValueError(f"账号不存在: {account_id}")
        material_data = next((v for v in self.material_manager.md5_map.values() if v["material_id"] == material_id), None)
        if not material_data: raise ValueError(f"素材不存在: {material_id}")
        content_text = self.render_content(material_data["info"].get("template", ""), account_info)
        logger.info(f"账号 {account_id} 发布内容: {content_text[:50]}...")
        return {
            "status": "success", "account_id": account_id,
            "material_id": material_id, "publish_time": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        }

    def batch_publish(self, account_list: List[str], material_id: str, time_spread: int = 3600) -> List[Dict]:
        results = []
        for acc_id in account_list:
            time.sleep(random.randint(0, time_spread))
            try:
                results.append(self.publish_content(acc_id, material_id))
            except Exception as e:
                results.append({"account_id": acc_id, "status": "failed", "error": str(e)})
        return results

六、多账号数据看板与运营指标采集

数据采集模块自动拉取粉丝数、播放量、点赞评论等核心指标，统一存到本地数据库，支持按时间分组统计，自动生成报表，省去了手动抄数据的繁琐。

import sqlite3
import random
from datetime import datetime, timedelta
from typing import Dict, List, Optional

class DataCollector:
    def __init__(self, config: Dict = None):
        self.db_path = config.get("db_path", "operation_data.db") if config else "operation_data.db"
        self._init_db()

    def _init_db(self) -> None:
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        cursor.execute("""
            CREATE TABLE IF NOT EXISTS account_daily_data (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                account_id TEXT NOT NULL,
                stat_date TEXT NOT NULL,
                followers_count INTEGER DEFAULT 0,
                total_views INTEGER DEFAULT 0,
                total_likes INTEGER DEFAULT 0,
                total_comments INTEGER DEFAULT 0,
                new_followers INTEGER DEFAULT 0,
                create_time TEXT NOT NULL,
                UNIQUE(account_id, stat_date)
            )
        """)
        conn.commit()
        conn.close()

    def collect_account_data(self, account_id: str) -> bool:
        mock_data = {
            "followers_count": random.randint(1000, 50000),
            "total_views": random.randint(10000, 500000),
            "total_likes": random.randint(500, 50000),
            "total_comments": random.randint(10, 5000),
            "new_followers": random.randint(0, 500)
        }
        stat_date = datetime.now().strftime("%Y-%m-%d")
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            cursor.execute("""
                INSERT OR REPLACE INTO account_daily_data
                (account_id, stat_date, followers_count, total_views, total_likes, total_comments, new_followers, create_time)
                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
            """, (
                account_id, stat_date, mock_data["followers_count"],
                mock_data["total_views"], mock_data["total_likes"],
                mock_data["total_comments"], mock_data["new_followers"],
                datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            ))
            conn.commit()
            return True
        except Exception as e:
            logger.error(f"账号 {account_id} 数据存储失败: {str(e)}")
            return False
        finally:
            conn.close()

    def get_account_trend(self, account_id: str, days: int = 7) -> List[Dict]:
        conn = sqlite3.connect(self.db_path)
        conn.row_factory = sqlite3.Row
        cursor = conn.cursor()
        start_date = (datetime.now() - timedelta(days=days)).strftime("%Y-%m-%d")
        cursor.execute("""
            SELECT * FROM account_daily_data 
            WHERE account_id = ? AND stat_date >= ? ORDER BY stat_date ASC
        """, (account_id, start_date))
        rows = cursor.fetchall()
        conn.close()
        return [dict(row) for row in rows]

七、团队协同权限的分级管控方案

多人运营需要权限分级，我们团队有不同角色，不可能全员开全权限。基于RBAC模型实现三级权限体系，不同角色对应不同操作范围，避免越权操作风险。

import sqlite3
import hashlib
from functools import wraps
from typing import Dict, List, Optional
from datetime import datetime

class PermissionManager:
    def __init__(self, config: Dict = None):
        self.db_path = config.get("db_path", "user_permission.db") if config else "user_permission.db"
        self._init_db()
        self.role_permissions = {
            "admin": ["account_manage", "task_manage", "content_manage", "data_view", "user_manage"],
            "operator": ["content_publish", "data_view", "account_view"],
            "viewer": ["data_view", "account_view"]
        }

    def _init_db(self) -> None:
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        cursor.execute("""
            CREATE TABLE IF NOT EXISTS system_users (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                username TEXT UNIQUE NOT NULL,
                password_hash TEXT NOT NULL,
                role TEXT NOT NULL DEFAULT 'viewer',
                assigned_accounts TEXT DEFAULT '',
                status TEXT DEFAULT 'active',
                create_time TEXT NOT NULL
            )
        """)
        conn.commit()
        conn.close()

    def add_user(self, username: str, password: str, role: str = "viewer", assigned_accounts: List[str] = None) -> bool:
        if role not in self.role_permissions:
            raise ValueError(f"不支持的角色: {role}")
        password_hash = hashlib.sha256(password.encode("utf-8")).hexdigest()
        accounts_str = ",".join(assigned_accounts) if assigned_accounts else ""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            cursor.execute("""
                INSERT INTO system_users (username, password_hash, role, assigned_accounts, create_time)
                VALUES (?, ?, ?, ?, ?)
            """, (username, password_hash, role, accounts_str, datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
            conn.commit()
            return True
        except sqlite3.IntegrityError:
            return False
        finally:
            conn.close()

    def check_permission(self, username: str, permission: str) -> bool:
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        cursor.execute("SELECT role FROM system_users WHERE username = ? AND status = 'active'", (username,))
        row = cursor.fetchone()
        conn.close()
        if not row: return False
        return permission in self.role_permissions.get(row[0], [])

def require_permission(permission: str):
    def decorator(func):
        @wraps(func)
        def wrapper(username: str, *args, **kwargs):
            if not PermissionManager().check_permission(username, permission):
                raise PermissionError(f"无权限执行此操作: {permission}")
            return func(username, *args, **kwargs)
        return wrapper
    return decorator

@require_permission("content_publish")
def operator_publish(username: str, account_id: str, material_id: str) -> Dict:
    return ContentDistributor().publish_content(account_id, material_id)

八、系统部署与生产环境稳定性优化

生产环境用Docker容器化部署，一键部署方便扩容。之前服务器重启导致系统停了大半天，之后加了进程守护和邮件告警，保障系统7*24小时稳定运行。

FROM python:3.10-slim
WORKDIR /app
RUN apt-get update && apt-get install -y --no-install-recommends build-essential libsqlite3-dev \
    && rm -rf /var/lib/apt/lists/*
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
COPY . .
RUN mkdir -p /app/data /app/logs /app/materials
ENV TZ=Asia/Shanghai
ENV PYTHONUNBUFFERED=1
COPY entrypoint.sh /app/entrypoint.sh
RUN chmod +x /app/entrypoint.sh
EXPOSE 8080
ENTRYPOINT ["/app/entrypoint.sh"]

#!/bin/bash
set -e
echo "启动TikTok矩阵系统..."
if [ ! -f /app/config.yaml ]; then
    cp /app/config.default.yaml /app/config.yaml
fi
python main.py &
MAIN_PID=$!
while true; do
    if ! kill -0 $MAIN_PID 2>/dev/null; then
        echo "主进程异常，正在重启..."
        python main.py &
        MAIN_PID=$!
    fi
    sleep 30
done

import smtplib
from email.mime.text import MIMEText
from datetime import datetime
from typing import Dict

class AlertMonitor:
    def __init__(self, config: Dict):
        self.alert_email = config.get("alert_email", "")
        self.smtp_config = config.get("smtp", {})

    def send_alert(self, title: str, content: str) -> None:
        if not self.alert_email or not self.smtp_config: return
        msg = MIMEText(content, "plain", "utf-8")
        msg["Subject"] = f"[系统告警] {title}"
        msg["From"] = self.smtp_config["user"]
        msg["To"] = self.alert_email
        try:
            server = smtplib.SMTP_SSL(self.smtp_config["host"], self.smtp_config["port"])
            server.login(self.smtp_config["user"], self.smtp_config["password"])
            server.sendmail(self.smtp_config["user"], [self.alert_email], msg.as_string())
            server.quit()
        except Exception as e:
            logger.error(f"告警发送失败: {str(e)}")

    def check_health(self, system_status: Dict) -> None:
        if system_status["system_status"] != "running":
            self.send_alert("系统状态异常", f"当前状态: {system_status['system_status']}")
        if system_status["running_task_count"] == 0:
            self.send_alert("无运行任务", "调度器无运行任务，请检查配置")

这套轻量化系统基本覆盖中小出海团队的多账号运营需求，各模块可根据业务场景灵活扩展。实际使用请遵守平台运营规则，合理使用自动化能力。