MCP 服务器集成中心｜企业级安装、配置与最佳实践指南

{
  "mcpServers": {
    "server-name": {
      "command": "node",
      "args": ["server.js"],
      "env": {
        "SECURE_MODE": "true",
        "MAX_MEMORY": "256m"
      }
    }
  }
}

# docker-compose.yml - MCP 服务集群
version: '3.8'
services:
  mcp-gateway:
    image: mcp-gateway:latest
    ports:
      - "8080:8080"
    environment:
      - CLUSTER_MODE=true
      - LOAD_BALANCER=round_robin
    depends_on:
      - mcp-server-1
      - mcp-server-2
      - mcp-server-3
 
  mcp-server-1:
    image: mcp-server:latest
    environment:
      - SERVER_ID=server-1
      - REDIS_URL=redis://redis:6379
      - MAX_CONNECTIONS=100
    
  mcp-server-2:
    image: mcp-server:latest
    environment:
      - SERVER_ID=server-2  
      - REDIS_URL=redis://redis:6379
      - MAX_CONNECTIONS=100
 
  redis:
    image: redis:alpine
    command: redis-server --appendonly yes
    volumes:
      - redis-data:/data
 
  prometheus:
    image: prom/prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml

{
  "monitoring": {
    "enabled": true,
    "metrics": [
      "request_count",
      "response_time",
      "error_rate",
      "resource_usage"
    ],
    "exporters": ["prometheus", "datadog", "newrelic"]
  }
}

# fluentd.conf
<source>
  @type tail
  path /var/log/mcp/*.log
  pos_file /var/log/fluentd/mcp.log.pos
  tag mcp.server
  format json
</source>
 
<match mcp.**>
  @type elasticsearch
  host elasticsearch
  port 9200
  index_name mcp-logs
</match>

# prometheus-alerts.yml
groups:
- name: mcp.rules
  rules:
  - alert: MCPServerDown
    expr: up{job="mcp-server"} == 0
    for: 30s
    labels:
      severity: critical
    annotations:
      summary: "MCP Server {{ $labels.instance }} is down"

{
  "auth": {
    "provider": "oauth2",
    "client_id": "${OAUTH_CLIENT_ID}",
    "client_secret": "${OAUTH_CLIENT_SECRET}",
    "scopes": ["mcp:read", "mcp:write", "mcp:admin"],
    "token_endpoint": "https://auth.company.com/oauth/token"
  }
}

# rbac-config.yml
roles:
  - name: mcp-viewer
    permissions:
      - "mcp:read"
      - "mcp:list"
  
  - name: mcp-operator
    permissions:
      - "mcp:read"
      - "mcp:write"
      - "mcp:execute"
  
  - name: mcp-admin
    permissions:
      - "mcp:*"
 
users:
  - username: "developer@company.com"
    roles: ["mcp-operator"]
  - username: "admin@company.com"
    roles: ["mcp-admin"]

{
  "tls": {
    "enabled": true,
    "cert_file": "/etc/ssl/certs/mcp-server.crt",
    "key_file": "/etc/ssl/private/mcp-server.key",
    "min_version": "1.2",
    "cipher_suites": [
      "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
      "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"
    ]
  }
}

# kubernetes-network-policy.yml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: mcp-server-isolation
spec:
  podSelector:
    matchLabels:
      app: mcp-server
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: claude-code
    ports:
    - protocol: TCP
      port: 8080

{
  "mcpServers": {
    "brave-search": {
      "command": "brave-mcp-server",
      "args": ["--config", "/etc/mcp/brave.json"],
      "env": {
        "BRAVE_API_KEY": "${BRAVE_API_KEY}",
        "LOG_LEVEL": "info",
        "METRICS_ENABLED": "true"
      },
      "timeout": 30000,
      "retries": 3
    },
    
    "database-cluster": {
      "command": "database-mcp-server",
      "args": ["--cluster-mode"],
      "env": {
        "DB_CLUSTER_ENDPOINTS": "postgres://db1:5432,postgres://db2:5432",
        "CONNECTION_POOL_SIZE": "20",
        "QUERY_TIMEOUT": "30000",
        "CIRCUIT_BREAKER_ENABLED": "true"
      },
      "healthCheck": {
        "enabled": true,
        "interval": 30000,
        "timeout": 5000
      }
    },
    
    "github-enterprise": {
      "command": "github-mcp-server",
      "args": ["--enterprise"],
      "env": {
        "GITHUB_ENTERPRISE_URL": "https://github.company.com",
        "GITHUB_TOKEN": "${GITHUB_ENTERPRISE_TOKEN}",
        "WEBHOOK_SECRET": "${GITHUB_WEBHOOK_SECRET}",
        "AUTO_APPROVE_DEPENDABOT": "true"
      }
    },
    
    "aws-production": {
      "command": "aws-mcp-server",
      "args": ["--profile", "production"],
      "env": {
        "AWS_REGION": "us-west-2",
        "AWS_ROLE_ARN": "arn:aws:iam::123456789012:role/MCPServerRole",
        "AWS_STS_DURATION": "3600",
        "RESOURCE_TAGGING": "Environment=Production,Team=DevOps"
      }
    }
  },
  
  "security": {
    "authentication": {
      "enabled": true,
      "provider": "saml",
      "sso_url": "https://sso.company.com"
    },
    "encryption": {
      "at_rest": true,
      "in_transit": true,
      "key_rotation": "quarterly"
    }
  },
  
  "monitoring": {
    "prometheus": {
      "enabled": true,
      "port": 9090,
      "path": "/metrics"
    },
    "logging": {
      "level": "info",
      "format": "json",
      "output": "syslog"
    }
  },
  
  "performance": {
    "connection_pooling": true,
    "request_batching": true,
    "cache": {
      "enabled": true,
      "ttl": 300,
      "max_size": "100MB"
    }
  }
}

# 检查 MCP 服务器状态
curl -v http://localhost:8080/health
 
# 查看连接配置
mcp status --verbose
 
# 测试网络连接
telnet mcp-server 8080

# 验证 API 密钥
echo $GITHUB_TOKEN | base64 -d
 
# 检查权限范围
gh auth status --show-token
 
# 刷新令牌
mcp auth refresh --server github

# 查看资源使用情况
docker stats mcp-server
 
# 分析慢查询
mcp debug --slow-queries --threshold 5000ms
 
# 生成性能报告
mcp profile --duration 60s --output profile.json

# 实时监控 MCP 日志
tail -f /var/log/mcp/server.log | jq '.'
 
# 过滤错误日志
grep -E "ERROR|FATAL" /var/log/mcp/*.log
 
# 分析请求模式
awk '{print $7}' /var/log/mcp/access.log | sort | uniq -c | sort -nr

// 启用详细日志记录
process.env.DEBUG = 'mcp:*';
 
// 性能追踪
const { performance } = require('perf_hooks');
const start = performance.now();
// ... MCP 操作
const duration = performance.now() - start;
console.log(`Operation took ${duration}ms`);

# 创建新项目
mkdir my-mcp-server && cd my-mcp-server
npm init -y
 
# 安装依赖
npm install @anthropic/mcp-sdk express typescript @types/node
 
# 初始化 TypeScript
npx tsc --init

// src/server.ts
import { Server } from '@anthropic/mcp-sdk/server';
import { StdioClientTransport } from '@anthropic/mcp-sdk/client/stdio';
 
class CustomMCPServer extends Server {
  constructor() {
    super({
      name: 'my-custom-server',
      version: '1.0.0',
      description: 'Custom MCP server for specific business needs'
    });
 
    this.addTool({
      name: 'custom-operation',
      description: 'Performs custom business operation',
      inputSchema: {
        type: 'object',
        properties: {
          action: { type: 'string' },
          parameters: { type: 'object' }
        },
        required: ['action']
      },
      handler: this.handleCustomOperation.bind(this)
    });
  }
 
  async handleCustomOperation(args: any): Promise<any> {
    const { action, parameters } = args;
    
    switch (action) {
      case 'process-data':
        return await this.processData(parameters);
      case 'generate-report':
        return await this.generateReport(parameters);
      default:
        throw new Error(`Unknown action: ${action}`);
    }
  }
 
  private async processData(params: any): Promise<any> {
    // 实现数据处理逻辑
    return { status: 'success', result: params };
  }
 
  private async generateReport(params: any): Promise<any> {
    // 实现报告生成逻辑
    return { status: 'success', report_id: 'RPT-001' };
  }
}
 
// 启动服务器
const server = new CustomMCPServer();
const transport = new StdioClientTransport();
server.connect(transport);

{
  "name": "my-custom-server",
  "command": "node",
  "args": ["dist/server.js"],
  "env": {
    "NODE_ENV": "production",
    "LOG_LEVEL": "info",
    "API_TIMEOUT": "30000"
  },
  "restart": {
    "enabled": true,
    "max_retries": 3,
    "backoff": "exponential"
  }
}

interface MCPPlugin {
  name: string;
  version: string;
  initialize(server: Server): Promise<void>;
  cleanup(): Promise<void>;
}
 
class PluginManager {
  private plugins: MCPPlugin[] = [];
 
  async loadPlugin(plugin: MCPPlugin): Promise<void> {
    await plugin.initialize(this.server);
    this.plugins.push(plugin);
  }
 
  async unloadAllPlugins(): Promise<void> {
    for (const plugin of this.plugins) {
      await plugin.cleanup();
    }
    this.plugins = [];
  }
}

interface Middleware {
  name: string;
  process(request: any, response: any, next: Function): Promise<void>;
}
 
class AuthMiddleware implements Middleware {
  name = 'auth';
 
  async process(request: any, response: any, next: Function): Promise<void> {
    const token = request.headers.authorization;
    if (!await this.validateToken(token)) {
      throw new Error('Unauthorized');
    }
    next();
  }
 
  private async validateToken(token: string): Promise<boolean> {
    // 实现令牌验证逻辑
    return true;
  }
}

class ConnectionPool {
  private connections: Map<string, any> = new Map();
  private maxConnections = 10;
  private timeout = 30000;
 
  async getConnection(key: string): Promise<any> {
    let connection = this.connections.get(key);
    
    if (!connection || this.isConnectionStale(connection)) {
      connection = await this.createConnection();
      this.connections.set(key, connection);
    }
    
    return connection;
  }
 
  async releaseConnection(key: string): Promise<void> {
    const connection = this.connections.get(key);
    if (connection) {
      await connection.close();
      this.connections.delete(key);
    }
  }
 
  private async createConnection(): Promise<any> {
    // 实现连接创建逻辑
    return {};
  }
 
  private isConnectionStale(connection: any): boolean {
    return Date.now() - connection.lastUsed > this.timeout;
  }
}

interface CacheConfig {
  ttl: number;
  maxSize: number;
  strategy: 'lru' | 'fifo' | 'lfu';
}
 
class MCPCache {
  private cache: Map<string, any> = new Map();
  private config: CacheConfig;
 
  constructor(config: CacheConfig) {
    this.config = config;
  }
 
  async get(key: string): Promise<any> {
    const item = this.cache.get(key);
    
    if (!item || this.isExpired(item)) {
      return null;
    }
    
    item.lastAccessed = Date.now();
    return item.value;
  }
 
  async set(key: string, value: any): Promise<void> {
    if (this.cache.size >= this.config.maxSize) {
      this.evict();
    }
    
    this.cache.set(key, {
      value,
      created: Date.now(),
      lastAccessed: Date.now()
    });
  }
 
  private isExpired(item: any): boolean {
    return Date.now() - item.created > this.config.ttl;
  }
 
  private evict(): void {
    // 根据策略驱逐缓存项
    const oldestKey = Array.from(this.cache.keys())[0];
    this.cache.delete(oldestKey);
  }
}

# Fork 官方仓库
git clone https://github.com/anthropic/mcp-servers
 
# 创建功能分支
git checkout -b feature/my-enhancement
 
# 提交代码
git commit -m "feat: add new functionality"
 
# 创建 Pull Request
gh pr create --title "Add new MCP server" --body "Description"