如何在Mininet中配置服务器核心等资源？

嘿，很高兴能帮你搞定这个问题！我来一步步拆解怎么在Mininet里限制服务器的CPU资源，同时搭建起加权轮询（Weighted Round Robin）的负载均衡环境：

1. 给Mininet主机设置CPU资源限制 #

Mininet本身支持在创建主机时直接指定CPU资源占比，也可以用系统命令限制单个进程的CPU使用，两种方式结合起来更灵活：

方式1：创建主机时指定CPU份额 #

在定义Mininet拓扑时，给addHost()方法加上cpu参数，这个参数是相对于单个物理核心的比例（比如你的机器是4核，cpu=0.5就代表用掉半个核心的算力，cpu=2.0就是用满2个核心）：

from mininet.net import Mininet

net = Mininet()
# 服务器1：分配50%的单核心算力
server1 = net.addHost('server1', cpu=0.5)
# 服务器2：分配100%的单核心算力（权重更高）
server2 = net.addHost('server2', cpu=1.0)

方式2：用cpulimit限制Express进程的CPU #

如果需要更精准地控制单个Express服务器进程的CPU使用，可以在启动服务时用cpulimit命令：

# 在Mininet主机里执行，限制node进程最多使用50%的CPU
cpulimit -l 50 node your-express-server.js &

2. 搭建加权轮询负载均衡环境 #

接下来需要一个负载均衡器来按照权重分配请求，你可以自己用Python写一个轻量的负载均衡脚本，这里给你一个简单的实现示例：

第一步：构建Mininet完整拓扑 #

from mininet.net import Mininet
from mininet.node import Controller
from mininet.cli import CLI

def setup_lb_topology():
    net = Mininet(controller=Controller)
    
    # 添加负载均衡器主机
    lb = net.addHost('lb')
    # 添加带CPU限制的服务器
    s1 = net.addHost('s1', cpu=0.5)
    s2 = net.addHost('s2', cpu=1.0)
    
    # 添加交换机并连接所有节点
    switch = net.addSwitch('sw1')
    net.addLink(lb, switch)
    net.addLink(s1, switch)
    net.addLink(s2, switch)
    
    net.start()
    
    # 在服务器上启动Express服务（记得替换成你的服务路径）
    s1.cmd('cd /home/your-project && cpulimit -l 50 node server.js &')
    s2.cmd('cd /home/your-project && cpulimit -l 100 node server.js &')
    
    # 在负载均衡器上启动加权轮询脚本
    lb.cmd('python3 /home/your-project/weighted-rr-lb.py &')
    
    # 启动Mininet命令行，方便调试
    CLI(net)
    net.stop()

if __name__ == '__main__':
    setup_lb_topology()

第二步：编写加权轮询负载均衡脚本 #

创建weighted-rr-lb.py，实现基于权重的请求转发：

import socket

# 服务器列表：(IP地址, 服务端口, 权重值)
# 这里的IP是Mininet自动分配的，你可以在Mininet CLI里用`ifconfig`查看
servers = [
    ('10.0.0.2', 3000, 1),  # s1，权重1
    ('10.0.0.3', 3000, 2)   # s2，权重2（会收到两倍于s1的请求）
]

current_idx = 0
current_weight_count = 0

def get_next_server():
    global current_idx, current_weight_count
    current_weight_count += 1
    # 如果当前服务器的权重已经用完，切换到下一个
    if current_weight_count > servers[current_idx][2]:
        current_weight_count = 1
        current_idx = (current_idx + 1) % len(servers)
    return servers[current_idx]

# 启动负载均衡监听端口8080
lb_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
lb_socket.bind(('0.0.0.0', 8080))
lb_socket.listen(5)

print("Weighted Round Robin LB started on port 8080")

while True:
    client_conn, client_addr = lb_socket.accept()
    # 获取下一个要转发的服务器
    server_ip, server_port, _ = get_next_server()
    
    # 连接到目标服务器并转发请求
    server_conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_conn.connect((server_ip, server_port))
    
    # 简单实现请求-响应转发（实际生产环境需要处理双向数据流和异常）
    req_data = client_conn.recv(1024)
    server_conn.send(req_data)
    res_data = server_conn.recv(1024)
    client_conn.send(res_data)
    
    server_conn.close()
    client_conn.close()

3. 验证效果 #

• 检查CPU资源限制：在Mininet CLI里输入s1 top，可以看到node进程的CPU占用率是否符合你设置的限制（比如50%左右）。
• 验证负载均衡：多次用curl访问负载均衡器的8080端口（比如在Mininet里执行lb curl http://localhost:8080），然后查看两个服务器的日志，应该能看到s2收到的请求数量大约是s1的2倍，符合权重设置。

内容的提问来源于stack exchange，提问作者Amir