# 初始化项目
$ cd network-monitor
$ npm init -y
$ npm install express axios node-cron

# 创建网络监控工具代码
$ cat > app.js << 'EOF' const express = require('express'); const axios = require('axios'); const cron = require('node-cron'); const { exec } = require('child_process'); const app = express(); const port = 3000; // 监控目标 const targets = [ { name: 'Router', ip: '192.168.1.1', checkInterval: 60 }, { name: 'Switch', ip: '192.168.1.2', checkInterval: 60 }, { name: 'Web Server', ip: '192.168.1.100', checkInterval: 30 }, { name: 'API Server', ip: '192.168.1.101', checkInterval: 30 } ]; // 监控结果 const results = []; // 执行ping测试 function pingTarget(target) { return new Promise((resolve, reject) => {
exec(`ping -c 1 ${target.ip}`, (error, stdout, stderr) => {
if (error) {
resolve({
target: target.name,
ip: target.ip,
status: ‘down’,
error: error.message,
timestamp: new Date().toISOString()
});
} else {
const match = stdout.match(/time=(\d+\.\d+) ms/);
const latency = match ? parseFloat(match[1]) : 0;
resolve({
target: target.name,
ip: target.ip,
status: ‘up’,
latency: latency,
timestamp: new Date().toISOString()
});
}
});
});
}

// 执行监控
async function checkTarget(target) {
const result = await pingTarget(target);
results.push(result);
}

// 定时执行监控
targets.forEach(target => {
cron.schedule(`*/${target.checkInterval} * * * *`, () => {
checkTarget(target);
});
});

// 路由
app.get(‘/api/status’, (req, res) => {
res.json(results);
});

app.get(‘/api/targets’, (req, res) => {
res.json(targets);
});

app.listen(port, () => {
console.log(`Network monitoring tool listening at http://fgedudb:${port}`);
});
EOF

# 启动网络监控工具
$ node app.js

# 测试网络监控工具
$ curl http://fgedudb:3000/api/targets
[
{
“name”: “Router”,
“ip”: “192.168.1.1”,
“checkInterval”: 60
},
{
“name”: “Switch”,
“ip”: “192.168.1.2”,
“checkInterval”: 60
},
{
“name”: “Web Server”,
“ip”: “192.168.1.100”,
“checkInterval”: 30
},
{
“name”: “API Server”,
“ip”: “192.168.1.101”,
“checkInterval”: 30
}
]

$ curl http://fgedudb:3000/api/status
[
{
“target”: “Router”,
“ip”: “192.168.1.1”,
“status”: “up”,
“latency”: 1.0,
“timestamp”: “2026-04-03T10:00:00.000Z”
},
{
“target”: “Switch”,
“ip”: “192.168.1.2”,
“status”: “up”,
“latency”: 0.5,
“timestamp”: “2026-04-03T10:00:00.000Z”
},
{
“target”: “Web Server”,
“ip”: “192.168.1.100”,
“status”: “up”,
“latency”: 0.2,
“timestamp”: “2026-04-03T10:00:00.000Z”
},
{
“target”: “API Server”,
“ip”: “192.168.1.101”,
“status”: “up”,
“latency”: 0.3,
“timestamp”: “2026-04-03T10:00:00.000Z”
}
]

# 初始化项目
$ cd network-config
$ npm init -y
$ npm install commander ssh2

# 创建网络配置工具代码
$ cat > index.js << 'EOF' #!/usr/bin/env node const { program } = require('commander'); const { Client } = require('ssh2'); program .version('1.0.0') .description('网络设备配置工具'); // 连接设备 function connectDevice(host, username, password, commands) { return new Promise((resolve, reject) => {
const conn = new Client();
conn.on(‘ready’, () => {
console.log(`Connected to ${host}`);
conn.shell((err, stream) => {
if (err) reject(err);
let output = ”;
stream.on(‘data’, (data) => {
output += data;
});
stream.on(‘close’, () => {
conn.end();
resolve(output);
});
commands.forEach(cmd => {
stream.write(cmd + ‘\n’);
});
stream.write(‘exit\n’);
});
}).on(‘error’, (err) => {
reject(err);
}).connect({
host: host,
port: 22,
username: username,
password: password
});
});
}

// 配置设备
program
.command(‘configure ‘)
.description(‘配置网络设备’)
.action(async (host, username, password) => {
try {
const commands = [
‘configure terminal’,
‘interface GigabitEthernet0/0’,
‘ip address 192.168.1.1 255.255.255.0’,
‘no shutdown’,
‘exit’,
‘interface GigabitEthernet0/1’,
‘ip address 192.168.2.1 255.255.255.0’,
‘no shutdown’,
‘exit’,
‘router ospf 1’,
‘network 192.168.1.0 0.0.0.255 area 0’,
‘network 192.168.2.0 0.0.0.255 area 0’,
‘exit’,
‘exit’,
‘write memory’
];
const output = await connectDevice(host, username, password, commands);
console.log(‘Configuration completed successfully’);
console.log(output);
} catch (error) {
console.error(‘Error configuring device:’, error.message);
}
});

// 备份配置
program
.command(‘backup ‘)
.description(‘备份网络设备配置’)
.action(async (host, username, password, file) => {
try {
const commands = [
‘show running-config’
];
const output = await connectDevice(host, username, password, commands);
const fs = require(‘fs’);
fs.writeFileSync(file, output);
console.log(`Configuration backed up to ${file}`);
} catch (error) {
console.error(‘Error backing up configuration:’, error.message);
}
});

// 执行命令
program.parse(process.argv);
EOF

# 测试网络配置工具
$ chmod +x index.js
$ ./index.js –version
1.0.0

$ ./index.js backup 192.168.1.1 admin password config.txt
Connected to 192.168.1.1
Configuration backed up to config.txt

$ cat config.txt
Building configuration…

Current configuration : 1000 bytes
!
version 15.0
!
hostname Router
!
interface GigabitEthernet0/0
ip address 192.168.1.1 255.255.255.0
no shutdown
!
interface GigabitEthernet0/1
ip address 192.168.2.1 255.255.255.0
no shutdown
!
router ospf 1
network 192.168.1.0 0.0.0.255 area 0
network 192.168.2.0 0.0.0.255 area 0
!
end

# 初始化项目
$ cd network-troubleshoot
$ npm init -y
$ npm install express

# 创建网络故障排查工具代码
$ cat > app.js << 'EOF' const express = require('express'); const { exec } = require('child_process'); const app = express(); const port = 3000; // 执行命令 function executeCommand(command) { return new Promise((resolve, reject) => {
exec(command, (error, stdout, stderr) => {
if (error) {
resolve({ error: error.message, stdout: stdout, stderr: stderr });
} else {
resolve({ stdout: stdout, stderr: stderr });
}
});
});
}

// 路由
app.get(‘/api/ping/:ip’, async (req, res) => {
const ip = req.params.ip;
const result = await executeCommand(`ping -c 4 ${ip}`);
res.json(result);
});

app.get(‘/api/traceroute/:ip’, async (req, res) => {
const ip = req.params.ip;
const result = await executeCommand(`traceroute ${ip}`);
res.json(result);
});

app.get(‘/api/netstat’, async (req, res) => {
const result = await executeCommand(‘netstat -tuln’);
res.json(result);
});

app.get(‘/api/ifconfig’, async (req, res) => {
const result = await executeCommand(‘ifconfig’);
res.json(result);
});

app.listen(port, () => {
console.log(`Network troubleshooting tool listening at http://fgedudb:${port}`);
});
EOF

# 启动网络故障排查工具
$ node app.js

# 测试网络故障排查工具
$ curl http://fgedudb:3000/api/ping/8.8.8.8
{
“stdout”: “PING 8.8.8.8 (8.8.8.8) 56(84) bytes of data.\n64 bytes from 8.8.8.8: icmp_seq=1 ttl=118 time=10.0 ms\n64 bytes from 8.8.8.8: icmp_seq=2 ttl=118 time=10.0 ms\n64 bytes from 8.8.8.8: icmp_seq=3 ttl=118 time=10.0 ms\n64 bytes from 8.8.8.8: icmp_seq=4 ttl=118 time=10.0 ms\n\n— 8.8.8.8 ping statistics —\n4 packets transmitted, 4 received, 0% packet loss, time 3003ms\nrtt min/avg/max/mdev = 10.000/10.000/10.000/0.000 ms\n”,
“stderr”: “”
}

$ curl http://fgedudb:3000/api/traceroute/8.8.8.8
{
“stdout”: “traceroute to 8.8.8.8 (8.8.8.8), 30 hops max, 60 byte packets\n 1 192.168.1.1 (192.168.1.1) 1.0 ms 1.0 ms 1.0 ms\n 2 10.0.0.1 (10.0.0.1) 5.0 ms 5.0 ms 5.0 ms\n 3 100.64.0.1 (100.64.0.1) 10.0 ms 10.0 ms 10.0 ms\n 4 8.8.8.8 (8.8.8.8) 15.0 ms 15.0 ms 15.0 ms\n”,
“stderr”: “”
}

# 初始化项目
$ cd network-security
$ npm init -y
$ npm install express

# 创建网络安全工具代码
$ cat > app.js << 'EOF' const express = require('express'); const { exec } = require('child_process'); const app = express(); const port = 3000; // 执行命令 function executeCommand(command) { return new Promise((resolve, reject) => {
exec(command, (error, stdout, stderr) => {
if (error) {
resolve({ error: error.message, stdout: stdout, stderr: stderr });
} else {
resolve({ stdout: stdout, stderr: stderr });
}
});
});
}

// 路由
app.get(‘/api/nmap/:ip’, async (req, res) => {
const ip = req.params.ip;
const result = await executeCommand(`nmap -sV ${ip}`);
res.json(result);
});

app.get(‘/api/firewall’, async (req, res) => {
const result = await executeCommand(‘iptables -L’);
res.json(result);
});

app.get(‘/api/ports’, async (req, res) => {
const result = await executeCommand(‘netstat -tuln’);
res.json(result);
});

app.get(‘/api/sshd-config’, async (req, res) => {
const result = await executeCommand(‘cat /etc/ssh/sshd_config’);
res.json(result);
});

app.listen(port, () => {
console.log(`Network security tool listening at http://fgedudb:${port}`);
});
EOF

# 启动网络安全工具
$ node app.js

# 测试网络安全工具
$ curl http://fgedudb:3000/api/nmap/192.168.1.100
{
“stdout”: “Starting Nmap 7.80 ( https://nmap.org ) at 2026-04-03 10:00:00 CST\nNmap scan report for 192.168.1.100\nHost is up (0.0000070s latency).\n\nPORT STATE SERVICE VERSION\n22/tcp open ssh OpenSSH 8.0 (protocol 2.0)\n80/tcp open http nginx 1.18.0\n443/tcp open ssl/https nginx 1.18.0\n3306/tcp open mysql MySQL 8.0.23\n\nService detection performed. Please report any incorrect results at https://nmap.org/submit/ .\nNmap done: 1 IP address (1 host up) scanned in 0.10 seconds\n”,
“stderr”: “”
}

$ curl http://fgedudb:3000/api/firewall
{
“stdout”: “Chain INPUT (policy DROP)\ntarget prot opt source destination\nACCEPT tcp — anywhere anywhere tcp dpt:ssh\nACCEPT tcp — anywhere anywhere tcp dpt:http\nACCEPT tcp — anywhere anywhere tcp dpt:https\nACCEPT all — anywhere anywhere state RELATED,ESTABLISHED\nACCEPT all — anywhere anywhere\n\nChain FORWARD (policy DROP)\ntarget prot opt source destination\n\nChain OUTPUT (policy ACCEPT)\ntarget prot opt source destination\n”,
“stderr”: “”
}

# 初始化项目
$ cd network-toolkit
$ npm init -y
$ npm install express commander ssh2

# 创建工具代码
$ cat > index.js << 'EOF' #!/usr/bin/env node const { program } = require('commander'); const { Client } = require('ssh2'); const { exec } = require('child_process'); program .version('1.0.0') .description('网络运维工具包'); // 连接设备 function connectDevice(host, username, password, commands) { return new Promise((resolve, reject) => {
const conn = new Client();
conn.on(‘ready’, () => {
console.log(`Connected to ${host}`);
conn.shell((err, stream) => {
if (err) reject(err);
let output = ”;
stream.on(‘data’, (data) => {
output += data;
});
stream.on(‘close’, () => {
conn.end();
resolve(output);
});
commands.forEach(cmd => {
stream.write(cmd + ‘\n’);
});
stream.write(‘exit\n’);
});
}).on(‘error’, (err) => {
reject(err);
}).connect({
host: host,
port: 22,
username: username,
password: password
});
});
}

// 执行命令
function executeCommand(command) {
return new Promise((resolve, reject) => {
exec(command, (error, stdout, stderr) => {
if (error) {
resolve({ error: error.message, stdout: stdout, stderr: stderr });
} else {
resolve({ stdout: stdout, stderr: stderr });
}
});
});
}

// 网络设备管理
program
.command(‘device ‘)
.description(‘管理网络设备’)
.action(async (action, host, username, password) => {
switch (action) {
case ‘configure’:
try {
const commands = [
‘configure terminal’,
‘interface GigabitEthernet0/0’,
‘ip address 192.168.1.1 255.255.255.0’,
‘no shutdown’,
‘exit’,
‘exit’,
‘write memory’
];
const output = await connectDevice(host, username, password, commands);
console.log(‘Configuration completed successfully’);
} catch (error) {
console.error(‘Error configuring device:’, error.message);
}
break;
case ‘backup’:
try {
const commands = [‘show running-config’];
const output = await connectDevice(host, username, password, commands);
const fs = require(‘fs’);
const filename = `config-${host}.txt`;
fs.writeFileSync(filename, output);
console.log(`Configuration backed up to ${filename}`);
} catch (error) {
console.error(‘Error backing up configuration:’, error.message);
}
break;
case ‘status’:
try {
const commands = [‘show interfaces status’];
const output = await connectDevice(host, username, password, commands);
console.log(output);
} catch (error) {
console.error(‘Error checking status:’, error.message);
}
break;
default:
console.log(‘Invalid action’);
}
});

// 网络诊断
program
.command(‘diagnose ‘)
.description(‘网络诊断’)
.action(async (action, target) => {
switch (action) {
case ‘ping’:
const pingResult = await executeCommand(`ping -c 4 ${target}`);
console.log(pingResult.stdout);
break;
case ‘traceroute’:
const tracerouteResult = await executeCommand(`traceroute ${target}`);
console.log(tracerouteResult.stdout);
break;
case ‘nmap’:
const nmapResult = await executeCommand(`nmap -sV ${target}`);
console.log(nmapResult.stdout);
break;
default:
console.log(‘Invalid action’);
}
});

// 网络状态
program
.command(‘status’)
.description(‘显示网络状态’)
.action(async () => {
const ifconfigResult = await executeCommand(‘ifconfig’);
console.log(‘Network Interfaces:’);
console.log(ifconfigResult.stdout);

const netstatResult = await executeCommand(‘netstat -tuln’);
console.log(‘\nListening Ports:’);
console.log(netstatResult.stdout);
});

// 执行命令
program.parse(process.argv);
EOF

# 测试工具
$ chmod +x index.js
$ ./index.js –version
1.0.0

$ ./index.js status
Network Interfaces:
eth0: flags=4163 mtu 1500
inet 192.168.1.100 netmask 255.255.255.0 broadcast 192.168.1.255
inet6 fe80::215:5dff:fe00:1 prefixlen 64 scopeid 0x20 ether 00:15:5d:00:00:01 txqueuelen 1000 (Ethernet)
RX packets 10000 bytes 10000000 (9.5 MiB)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 10000 bytes 10000000 (9.5 MiB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0

lo: flags=73 mtu 65536
inet 127.0.0.1 netmask 255.0.0.0
inet6 ::1 prefixlen 128 scopeid 0x10
loop txqueuelen 1000 (Local Loopback)
RX packets 1000 bytes 100000 (97.6 KiB)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 1000 bytes 100000 (97.6 KiB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0

Listening Ports:
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address Foreign Address State
tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN
tcp 0 0 0.0.0.0:80 0.0.0.0:* LISTEN
tcp 0 0 0.0.0.0:443 0.0.0.0:* LISTEN
tcp6 0 0 :::22 :::* LISTEN
tcp6 0 0 :::80 :::* LISTEN
tcp6 0 0 :::443 :::* LISTEN

$ ./index.js diagnose ping 8.8.8.8
PING 8.8.8.8 (8.8.8.8) 56(84) bytes of data.
64 bytes from 8.8.8.8: icmp_seq=1 ttl=118 time=10.0 ms
64 bytes from 8.8.8.8: icmp_seq=2 ttl=118 time=10.0 ms
64 bytes from 8.8.8.8: icmp_seq=3 ttl=118 time=10.0 ms
64 bytes from 8.8.8.8: icmp_seq=4 ttl=118 time=10.0 ms

— 8.8.8.8 ping statistics —
4 packets transmitted, 4 received, 0% packet loss, time 3003ms
rtt min/avg/max/mdev = 10.000/10.000/10.000/0.000 ms