ClashX上級使用テクニック：プロキシツールのフルポテンシャルを解放

はじめに：上級テクニックの概要

ClashXの基本的な使い方をマスターした後、次のステップはこの強力なツールのポテンシャルをフルに活用する方法を学ぶことです。上級テクニックはプロキシパフォーマンスを向上させるだけでなく、より柔軟でインテリジェントなネットワークルーティングソリューションを構築します。

この記事では、スマートルーティング、自動化スクリプト、パフォーマンスチューニング、ルール最適化などの専門テクニックを含む、ClashXの上級使用方法を体系的に紹介します。これらのテクニックは、ある程度のClashX使用経験を持つ上級ユーザーに適しています。

スマートルーティング戦略

スマートルーティングの核心は、異なるトラフィック特性（ドメイン名、IP、地理的位置など）に基づいて、トラフィックを異なるプロキシノードまたは直接接続にルーティングすることです。これによりパフォーマンスの最適化、遅延の低減、地域制限の回避が可能になります。

複雑なドメインベースのルーティング

rules:
  # Line Level 1：Whitelist Direct（Highest Priority）
  - DOMAIN,localhost,DIRECT
  - DOMAIN-SUFFIX,local,DIRECT
  - DOMAIN-SUFFIX,lan,DIRECT

  # Line Level 2：Domestic Services Direct
  - DOMAIN-SUFFIX,alipay.com,DIRECT
  - DOMAIN-SUFFIX,baidu.com,DIRECT
  - DOMAIN-SUFFIX,taobao.com,DIRECT
  - DOMAIN-SUFFIX,qq.com,DIRECT

  # Line Level 3：Global Streaming
  - DOMAIN-SUFFIX,netflix.com,🎬 Streaming
  - DOMAIN-SUFFIX,youtube.com,🎬 Streaming
  - DOMAIN-SUFFIX,twitch.tv,🎬 Streaming
  - DOMAIN-KEYWORD,spotify,🎬 Streaming

  # Line Level 4：Gaming Acceleration
  - DOMAIN-SUFFIX,epicgames.com,🎮 Gaming
  - DOMAIN-SUFFIX,steampowered.com,🎮 Gaming

  # Line Level 5：Special Apps
  - DOMAIN-SUFFIX,telegram.org,💬 Instant Messaging
  - DOMAIN-SUFFIX,whatsapp.com,💬 Instant Messaging

  # FinalRules
  - GEOIP,CN,DIRECT
  - MATCH,🚀 Auto Select

きめ細かいIPベースのルーティング

rules:
  # Highest priority：Local Network IP Direct
  - IP-CIDR,192.168.0.0/16,DIRECT,no-resolve
  - IP-CIDR,10.0.0.0/8,DIRECT,no-resolve
  - IP-CIDR,172.16.0.0/12,DIRECT,no-resolve
  - IP-CIDR,127.0.0.0/8,DIRECT,no-resolve

  # China IP Direct
  - IP-CIDR,1.0.1.0/24,DIRECT,no-resolve
  - IP-CIDR,1.1.1.0/24,DIRECT,no-resolve

  # Specific IP ranges via proxy
  - IP-CIDR,8.8.8.0/24,🚀 Auto Select,no-resolve
  - IP-CIDR,1.1.1.0/24,🚀 Auto Select,no-resolve

  # FinalRules
  - MATCH,🚀 Auto Select

GeoIPベースの地理的ルーティング

rules:
  # China IP Direct
  - GEOIP,CN,DIRECT

  # US traffic -> US group Node
  - GEOIP,US,🇺🇸 US Node

  # Japan traffic -> Japan group Node
  - GEOIP,JP,🇯🇵 Japan Node

  # EU traffic -> EU nodes
  - GEOIP,DE,🇩🇪 EU nodes
  - GEOIP,FR,🇫🇷 EU nodes
  - GEOIP,GB,🇬🇧 EU nodes

  # Default proxy
  - MATCH,🚀 Auto Select

高度なポリシーグループ設定

ポリシーグループはノードの結合だけでなく、複雑なトラフィック制御と自動選択ロジックを実装できます。高度なポリシーグループ設定のマスターは、プロキシパフォーマンスを最適化する鍵です。

高度なフォールバックの使い方

proxy-groups:
  # Primary layer: automatic speed test
  - name: "🇭🇰 Hong Kong primary node"
    type: url-test
    proxies:
      - "HK-001"
      - "HK-002"
      - "HK-003"
    url: "http://www.gstatic.com/generate_204"
    interval: 300
    tolerance: 50

  # Failover layer: monitor primary health
  - name: "🚀 Auto Select"
    type: fallback
    proxies:
      - "🇭🇰 Hong Kong primary node"
      - "🇯🇵 Japan backup node"
      - "🇸🇬 Singapore backup node"
      - "DIRECT"
    url: "http://www.gstatic.com/generate_204"
    interval: 300

ロードバランスの最適化

proxy-groups:
  # Consistent-hash load balancing：Same connection uses the same node
  - name: "⚖️ consistent hashing"
    type: load-balance
    proxies:
      - "HK-001"
      - "HK-002"
      - "HK-003"
      - "JP-001"
      - "JP-002"
    url: "http://www.gstatic.com/generate_204"
    interval: 300
    strategy: consistent-hashing

  # Round-robin load balancing：Switch nodes in sequence
  - name: "⚖️ round-robin"
    type: load-balance
    proxies:
      - "HK-001"
      - "HK-002"
      - "HK-003"
    url: "http://www.gstatic.com/generate_204"
    interval: 300
    strategy: round-robin

URLテストパラメータの調整

proxy-groups:
  # chained proxy：Traffic goes through two proxies Nodes
  - name: "🔗 double encryption"
    type: relay
    proxies:
      - "HK-001"
      - "JP-001"

  # Use case: chain proxy in high-risk networks
  - name: "🔐 extra secure"
    type: relay
    proxies:
      - "HK-001"
      - "SG-001"
      - "JP-001"

rules:
  - DOMAIN-SUFFIX,sensitive.com,🔗 double encryption

リレーチェーンプロキシ

proxy-groups:
  # Regional groups
  - name: "🇭🇰 Hong Kong"
    type: url-test
    proxies:
      - "HK-001"
      - "HK-002"
      - "HK-003"
    url: "http://www.gstatic.com/generate_204"
    interval: 300

  - name: "🇯🇵 Japan"
    type: url-test
    proxies:
      - "JP-001"
      - "JP-002"
    url: "http://www.gstatic.com/generate_204"
    interval: 300

  # Destination groups (streaming, gaming, etc.)
  - name: "🎬 Streaming"
    type: select
    proxies:
      - "🇭🇰 Hong Kong"
      - "🇯🇵 Japan"
      - "🇺🇸 US"

  # Global Select group
  - name: "🚀 Global Select"
    type: select
    proxies:
      - "🎬 Streaming"
      - "🇭🇰 Hong Kong"
      - "🇯🇵 Japan"
      - "DIRECT"

自動化とスクリプト

自動化スクリプトを通じて、設定の自動切り替え、サブスクリプションの更新、メンテナンスタスクの実行が可能になり、使用効率が大幅に向上します。

自動設定切り替え

#!/bin/bash

# ClashX config backup and restore script

CLASH_CONFIG_DIR="$HOME/.config/clash"
BACKUP_DIR="$HOME/.clash_backup"
BACKUP_DATE=$(date +%Y%m%d_%H%M%S)

# Create backup
backup_config() {
    mkdir -p "$BACKUP_DIR"
    cp "$CLASH_CONFIG_DIR/config.yaml" "$BACKUP_DIR/config_$BACKUP_DATE.yaml"
    echo "Config backed up to: $BACKUP_DIR/config_$BACKUP_DATE.yaml"
}

# Restore config
restore_config() {
    local latest_backup=$(ls -t "$BACKUP_DIR"/config_*.yaml | head -1)
    if [ -z "$latest_backup" ]; then
        echo "No backup file found"
        return 1
    fi
    cp "$latest_backup" "$CLASH_CONFIG_DIR/config.yaml"
    echo "Config restored"
}

# Reload config
reload_config() {
    curl -X PUT http://127.0.0.1:9090/configs -H "Content-Type: application/json" \
        -d "{\"path\": \"$CLASH_CONFIG_DIR/config.yaml\"}"
    echo "Config reloaded"
}

case "$1" in
    backup) backup_config ;;
    restore) restore_config ;;
    reload) reload_config ;;
    *) echo "Usage: $0 {backup|restore|reload}" ;;
esac

スケジュールタスクの自動化

#!/bin/bash

# Scheduled updates ClashX Rule providers

CLASH_HOME="$HOME/.config/clash"
API_URL="http://127.0.0.1:9090"
SECRET="your-secret-key"

# Update rule providers
update_rule_providers() {
    local providers=("reject" "proxy" "direct" "streaming")

    for provider in "${providers[@]}"; do
        echo "Updating rule provider: $provider"
        curl -X PUT "$API_URL/providers/rules/$provider" \
            -H "Authorization: Bearer $SECRET"
        sleep 2
    done

    echo "All rule providers have been updated"
}

# Check ClashX status
check_clash_status() {
    local response=$(curl -s -w "\n%{http_code}" "$API_URL/version")
    local http_code=$(echo "$response" | tail -n 1)

    if [ "$http_code" == "200" ]; then
        echo "ClashX is running normally"
        return 0
    else
        echo "ClashX status is abnormal, attempting restart"
        killall -9 ClashX 2>/dev/null || true
        sleep 2
        open /Applications/ClashX.app
        return 1
    fi
}

# Main function
main() {
    check_clash_status
    if [ $? -eq 0 ]; then
        update_rule_providers
    fi
}

main
                            

サブスクリプション更新の自動化

#!/usr/bin/env python3

import requests
import json
import yaml
from datetime import datetime

class ClashXManager:
    def __init__(self, api_url="http://127.0.0.1:9090", secret=None):
        self.api_url = api_url
        self.headers = {}
        if secret:
            self.headers["Authorization"] = f"Bearer {secret}"

    def get_proxies(self):
        """Get all proxy nodes"""
        response = requests.get(f"{self.api_url}/proxies", headers=self.headers)
        return response.json() if response.status_code == 200 else None

    def get_traffic_stats(self):
        """Get traffic statistics"""
        response = requests.get(f"{self.api_url}/traffic", headers=self.headers)
        return response.json() if response.status_code == 200 else None

    def test_proxy_speed(self, proxy_name, url="http://www.gstatic.com/generate_204"):
        """Test proxy speed"""
        test_url = f"{self.api_url}/proxies/{proxy_name}/delay?url={url}"
        response = requests.get(test_url, headers=self.headers)
        return response.json() if response.status_code == 200 else None

    def switch_proxy(self, group_name, proxy_name):
        """Switch proxy used by policy group"""
        data = json.dumps({"name": proxy_name})
        response = requests.put(
            f"{self.api_url}/proxies/{group_name}",
            data=data,
            headers={**self.headers, "Content-Type": "application/json"}
        )
        return response.status_code == 204

    def get_logs(self, level="info"):
        """Get logs"""
        response = requests.get(f"{self.api_url}/logs?level={level}", headers=self.headers)
        return response.json() if response.status_code == 200 else None

    def batch_test_proxies(self, proxy_names):
        """Batch Test proxy speed"""
        results = {}
        for proxy in proxy_names:
            result = self.test_proxy_speed(proxy)
            if result:
                results[proxy] = result.get("delay", -1)
        return results

# Usage example
if __name__ == "__main__":
    manager = ClashXManager(secret="your-secret-key")

    # Get proxy info
    proxies = manager.get_proxies()
    if proxies:
        print(json.dumps(proxies, indent=2, ensure_ascii=False))

    # Get traffic statistics
    stats = manager.get_traffic_stats()
    print(f"Upload: {stats['up']} B/s, Download: {stats['down']} B/s")

    # Batch test proxies
    proxy_names = ["HK-001", "JP-001", "US-001"]
    speeds = manager.batch_test_proxies(proxy_names)
    print("Proxy speed test results:")
    for proxy, speed in sorted(speeds.items(), key=lambda x: x[1]):
        print(f"  {proxy}: {speed}ms")

パフォーマンス最適化のヒント

基本設定を超えて、ClashXのパフォーマンスをさらに向上させ、リソース使用量を削減する多くのテクニックがあります。

DNS解決の最適化

dns:
  enable: true
  listen: 0.0.0.0:53
  enhanced-mode: fake-ip  # Better performance, but slightly lower compatibility

  # Fake-IP address pool configuration
  fake-ip-range: 198.18.0.1/16

  # Domains to exclude when using Fake-IP
  fake-ip-filter:
    - "*.lan"
    - "*.local"
    - "*.internal"
    - localhost.ptlogin2.qq.com
    - "*.qq.com"
    - "*.tencent.com"

  # Primary DNS servers (fast for mainland China lookups)
  nameserver:
    - 119.29.29.29  # DNSPod (CN)
    - 223.5.5.5     # AliDNS (CN)
    - https://doh.pub/dns-query  # DoH is more secure

  # Fallback DNS (used when primary DNS fails)
  fallback:
    - https://1.1.1.1/dns-query    # Cloudflare DoH
    - https://dns.google/dns-query  # Google DoH
    - https://9.9.9.9/dns-query     # Quad9 DoH

  # Domain-specific DNS (key optimization)
  nameserver-policy:
    # Use domestic DNS for domestic domains
    "geosite:cn":
      - 119.29.29.29
      - 223.5.5.5

    # Use global DNS for international domains
    "geosite:geolocation-!cn":
      - https://1.1.1.1/dns-query
      - https://dns.google/dns-query

    # DNS for specific domains
    "domain:example.com":
      - 119.29.29.29

    "domain:google.com":
      - https://8.8.8.8/dns-query

接続の最適化

general:
  # Outbound interface
  interface-name: en0

  # Enable concurrent TCP connections
  tcp-concurrent: true

  # UDP connection timeout (milliseconds)
  udp-timeout: 300

  # Idle connection timeout
  keep-alive-interval: 15

  # SOCKS5 UDP support
  socks-version: 5

# Advanced performance tuning parameters
experimental:
  # Enable interface detection
  interface-name: en0

  # Ignore domains that fail to resolve (reduces retries)
  ignore-resolve-fail: true
                            

リソース使用の最適化

Rule types performance (fast → slow):
1. IP-CIDR/IP6-CIDR (fastest, O(1) lookup)
   Time: ~0.1ms

2. DOMAIN-SUFFIX (fast, trie lookup)
   Time: ~0.2-0.5ms

3. DOMAIN (medium, exact match)
   Time: ~0.3-0.8ms

4. DOMAIN-KEYWORD (slower, substring match)
   Time: ~1-2ms

5. GEOIP (slower, requires IP database lookup)
   Time: ~2-5ms

6. RULE-SET (depends on rule-set size)
   Time: ~0.5-5ms

ルールの最適化とメンテナンス

整理されメンテナンスされたルールは、ClashXの長期的な安定性を確保する鍵です。以下はプロフェッショナルなルール管理テクニックです。

ルールプロバイダーの使用

rule-providers:
  # Ad BlockingRules
  reject:
    type: http
    behavior: domain
    url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/reject.txt"
    path: ./ruleset/reject.yaml
    interval: 86400  # Update once every 24 hours

  # Proxy rules
  proxy:
    type: http
    behavior: domain
    url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/proxy.txt"
    path: ./ruleset/proxy.yaml
    interval: 86400

  # DirectRules
  direct:
    type: http
    behavior: domain
    url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/direct.txt"
    path: ./ruleset/direct.yaml
    interval: 86400

  # Streaming rules
  streaming:
    type: http
    behavior: domain
    url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/streaming.txt"
    path: ./ruleset/streaming.yaml
    interval: 86400

  # Apple Rules
  apple:
    type: http
    behavior: domain
    url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/apple.txt"
    path: ./ruleset/apple.yaml
    interval: 86400

  # Google Rules
  google:
    type: http
    behavior: domain
    url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/google.txt"
    path: ./ruleset/google.yaml
    interval: 86400

  # China IP rules
  cncidr:
    type: http
    behavior: ip
    url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/cncidr.txt"
    path: ./ruleset/cncidr.yaml
    interval: 86400

  # Global IP rules
  lancidr:
    type: http
    behavior: ip
    url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/lancidr.txt"
    path: ./ruleset/lancidr.yaml
    interval: 86400

# Use rule providers
rules:
  # Local NetworkDirect
  - RULE-SET,lancidr,DIRECT

  # Ad Blocking
  - RULE-SET,reject,REJECT

  # DirectRules
  - RULE-SET,direct,DIRECT

  # Streaming
  - RULE-SET,streaming,🎬 Streaming

  # Apple
  - RULE-SET,apple,🍎 Apple Services

  # Google
  - RULE-SET,google,🔍 Google Services

  # China IP
  - RULE-SET,cncidr,DIRECT

  # Proxy rules
  - RULE-SET,proxy,🚀 Auto Select

  # FinalRules
  - MATCH,🚀 Auto Select

ルールメンテナンスのベストプラクティス

#!/usr/bin/env python3

import requests
import yaml
from pathlib import Path

class RuleManager:
    """Dynamic rule management tool"""

    def __init__(self, config_path):
        self.config_path = Path(config_path)
        self.config = self._load_config()

    def _load_config(self):
        """Load configuration file"""
        with open(self.config_path, 'r', encoding='utf-8') as f:
            return yaml.safe_load(f)

    def _save_config(self):
        """Save configuration file"""
        with open(self.config_path, 'w', encoding='utf-8') as f:
            yaml.dump(self.config, f, allow_unicode=True, default_flow_style=False)

    def add_rule(self, rule_text, position=None):
        """Add a new rule"""
        if 'rules' not in self.config:
            self.config['rules'] = []

        if position is None:
            # Add near the end (before the MATCH rule)
            position = len(self.config['rules']) - 1

        self.config['rules'].insert(position, rule_text)
        self._save_config()
        print(f"Rule added: {rule_text}")

    def remove_rule(self, keyword):
        """Remove rules by keyword"""
        if 'rules' not in self.config:
            return

        original_count = len(self.config['rules'])
        self.config['rules'] = [
            r for r in self.config['rules']
            if keyword not in r
        ]
        removed_count = original_count - len(self.config['rules'])
        self._save_config()
        print(f"Removed {removed_count} rules")

    def update_rule_provider(self, provider_name, new_url):
        """Update rule provider URL"""
        if 'rule-providers' not in self.config:
            self.config['rule-providers'] = {}

        if provider_name in self.config['rule-providers']:
            self.config['rule-providers'][provider_name]['url'] = new_url
            self._save_config()
            print(f"Rule provider {provider_name} updated")
        else:
            print(f"Rule provider {provider_name} does not exist")

    def list_rules(self, limit=20):
        """List rules"""
        if 'rules' not in self.config:
            return

        rules = self.config['rules'][-limit:]
        for i, rule in enumerate(rules, 1):
            print(f"{i}. {rule}")

# Usage example
manager = RuleManager(Path.home() / '.config/clash/config.yaml')

# Add a new rule
manager.add_rule("DOMAIN-SUFFIX,example.com,DIRECT")

# List rules
manager.list_rules(10)

# Update rule providers
manager.update_rule_provider("proxy", "https://new-url.com/proxy.yaml")
                            

実践シーン設定

異なる使用シーンに基づいて、直接参照して使用できるいくつかの完全な設定ソリューションを紹介します。

開発環境設定

proxy-groups:
  # Dedicated policy group for streaming
  - name: "🎬 Streaming"
    type: select
    proxies:
      - "🇭🇰 Hong Kong Node"  # Broad catalog
      - "🇯🇵 Japan Node"  # Low latency
      - "🇺🇸 US Node"  # Newest releases
      - DIRECT

  # Dedicated Netflix group
  - name: "🍿 Netflix"
    type: url-test
    proxies:
      - "HK-Netflix-01"
      - "US-Netflix-01"
    url: "https://www.netflix.com/nrdp/v6/www/user"
    interval: 300
    tolerance: 100

rules:
  # Streaming platforms routing
  - DOMAIN-SUFFIX,netflix.com,🍿 Netflix
  - DOMAIN-SUFFIX,nflxso.net,🍿 Netflix
  - DOMAIN-SUFFIX,youtube.com,🎬 Streaming
  - DOMAIN-SUFFIX,youtu.be,🎬 Streaming
  - DOMAIN-SUFFIX,hulu.com,🎬 Streaming
  - DOMAIN-SUFFIX,disneyplus.com,🎬 Streaming
  - DOMAIN-KEYWORD,spotify,🎬 Streaming
                            

ゲーム最適化設定

proxy-groups:
  # Gaming group: prioritize low latency
  - name: "🎮 Gaming"
    type: url-test
    proxies:
      - "HK-Game-01"
      - "SG-Game-01"
      - "JP-Game-01"
    url: "http://www.gstatic.com/generate_204"
    interval: 300
    tolerance: 30  # Games are latency-sensitive, so keep tolerance low

rules:
  # Steam
  - DOMAIN-SUFFIX,steampowered.com,🎮 Gaming
  - DOMAIN-SUFFIX,steamcommunity.com,🎮 Gaming

  # Epic Games
  - DOMAIN-SUFFIX,epicgames.com,🎮 Gaming
  - DOMAIN-SUFFIX,unrealengine.com,🎮 Gaming

  # other gaming Platforms
  - DOMAIN-SUFFIX,battlenet.com,🎮 Gaming
  - DOMAIN-SUFFIX,playstation.com,🎮 Gaming
                            

ストリーミングメディアの最適化

proxy-groups:
  # Download-only: prioritize bandwidth
  - name: "📥 Download Acceleration"
    type: load-balance
    proxies:
      - "HK-Download-01"
      - "HK-Download-02"
      - "US-Download-01"
    url: "http://www.gstatic.com/generate_204"
    interval: 300
    strategy: round-robin  # round-round-robin load balancing

rules:
  # Common download sites
  - DOMAIN-SUFFIX,github.com,📥 Download Acceleration
  - DOMAIN-SUFFIX,githubusercontent.com,📥 Download Acceleration
  - DOMAIN-SUFFIX,releases.ubuntu.com,📥 Download Acceleration
                            

高度な機能の探求

ClashXには多くの隠れた高度な機能があり、適切に活用すれば予想外の便利さをもたらします。

外部制御API

tun:
  enable: true
  stack: system  # Or gvisor (better performance but slightly lower compatibility)

  # DNS hijacking
  dns-hijack:
    - any:53
    - tcp://any:53

  # Automatic routing
  auto-route: true

  # Automatically detect interface
  auto-detect-interface: true

  # Specify network interface (optional)
  interface-name: en0

  # Optimized MTU size
  mtu: 9000
                            

TUNモードの高度な活用

#!/usr/bin/env python3

import requests
import json
import asyncio
from datetime import datetime

class ClashXDashboard:
    """Advanced ClashX Dashboard API usage"""

    def __init__(self, base_url="http://127.0.0.1:9090", secret=None):
        self.base_url = base_url
        self.headers = {"Content-Type": "application/json"}
        if secret:
            self.headers["Authorization"] = f"Bearer {secret}"

    def get_system_info(self):
        """Get system information"""
        response = requests.get(f"{self.base_url}/version", headers=self.headers)
        return response.json() if response.status_code == 200 else None

    def get_connections(self):
        """Get current connections"""
        response = requests.get(f"{self.base_url}/connections", headers=self.headers)
        return response.json() if response.status_code == 200 else None

    def get_traffic_stats(self):
        """Get traffic statistics"""
        response = requests.get(f"{self.base_url}/traffic", headers=self.headers)
        if response.status_code == 200:
            data = response.json()
            return {
                "upload": data["up"],
                "download": data["down"],
                "timestamp": datetime.now()
            }
        return None

    def change_mode(self, mode):
        """Switch mode: rule, global, direct"""
        valid_modes = ["rule", "global", "direct"]
        if mode not in valid_modes:
            return False

        data = json.dumps({"mode": mode})
        response = requests.put(
            f"{self.base_url}/configs",
            data=data,
            headers=self.headers
        )
        return response.status_code == 200

    def get_rules_info(self):
        """Get rule information"""
        response = requests.get(f"{self.base_url}/rules", headers=self.headers)
        return response.json() if response.status_code == 200 else None

    def test_url_latency(self, url, timeout=5000):
        """Test URL latency"""
        response = requests.get(
            f"{self.base_url}/configs/latency?url={url}&timeout={timeout}",
            headers=self.headers
        )
        return response.json() if response.status_code == 200 else None

    def get_proxy_latency(self, proxy_name, url="http://www.gstatic.com/generate_204"):
        """Test latency for a single proxy"""
        response = requests.get(
            f"{self.base_url}/proxies/{proxy_name}/delay?url={url}",
            headers=self.headers
        )
        return response.json() if response.status_code == 200 else None

# Usage example: real-time traffic monitoring
async def monitor_traffic():
    dashboard = ClashXDashboard(secret="your-secret")

    print("Starting traffic monitoring...")
    while True:
        stats = dashboard.get_traffic_stats()
        if stats:
            print(f"[{stats['timestamp']}] Upload: {stats['upload']:.2f} B/s, "
                  f"Download: {stats['download']:.2f} B/s")
        await asyncio.sleep(2)

# Run the monitor
# asyncio.run(monitor_traffic())
                            

カスタムルールセット

general:
  # Enable external controller
  external-controller: 0.0.0.0:9090

  # API access secret (strongly recommended)
  secret: "your-very-secure-secret-key-here"

  # CORS support
  external-ui: true

  # External UI URL
  external-ui-url: "https://clash.razord.top/"