Comment dois-je déterminer l'utilisation actuelle du réseau?

Je veux afficher l'utilisation actuelle du réseau (utilisation de la bande passante) d'une interface d'une boîte Debian sur un site Web. Il n'est pas censé être très élaboré ou précis, juste un simple chiffre tel que "52 Mbit / s".

Les moniteurs de bande passante réseau typiques tels que iftopme ne permettent pas d'extraire simplement une telle valeur.

Comment puis-je le récupérer au mieux?

^{Par exemple, je suppose que je pourrais analyser /proc/net/devtoutes les quelques minutes. Je ne sais pas si c'est vraiment la meilleure façon de le faire.}

Je pense que ifstat vous aidera:

[root @ localhost ~] # ifstat -i eth0 -q 1 1
       eth0
 Ko / s en Ko / s en
 3390,26 69,69

La meilleure façon de le faire est simplement d'analyser /proc/net/dev(soyez averti que ce /procn'est pas portable). Voici un bashscript que j'ai rapidement assemblé et qui devrait être capable de le calculer:

#!/bin/bash

_die() {
    printf '%s\n' "$@"
    exit 1
}

_interface=$1

[[ ${_interface} ]] || _die 'Usage: ifspeed [interface]'
grep -q "^ *${_interface}:" /proc/net/dev || _die "Interface ${_interface} not found in /proc/net/dev"

_interface_bytes_in_old=$(awk "/^ *${_interface}:/"' { if ($1 ~ /.*:[0-9][0-9]*/) { sub(/^.*:/, "") ; print $1 } else { print $2 } }' /proc/net/dev)
_interface_bytes_out_old=$(awk "/^ *${_interface}:/"' { if ($1 ~ /.*:[0-9][0-9]*/) { print $9 } else { print $10 } }' /proc/net/dev)

while sleep 1; do
    _interface_bytes_in_new=$(awk "/^ *${_interface}:/"' { if ($1 ~ /.*:[0-9][0-9]*/) { sub(/^.*:/, "") ; print $1 } else { print $2 } }' /proc/net/dev)
    _interface_bytes_out_new=$(awk "/^ *${_interface}:/"' { if ($1 ~ /.*:[0-9][0-9]*/) { print $9 } else { print $10 } }' /proc/net/dev)

    printf '%s: %s\n' 'Bytes in/sec'  "$(( _interface_bytes_in_new - _interface_bytes_in_old ))" \
                      'Bytes out/sec' "$(( _interface_bytes_out_new - _interface_bytes_out_old ))"

    # printf '%s: %s\n' 'Kilobytes in/sec'  "$(( ( _interface_bytes_in_new - _interface_bytes_in_old ) / 1024 ))" \
    #                   'Kilobytes out/sec' "$(( ( _interface_bytes_out_new - _interface_bytes_out_old ) / 1024 ))"

    # printf '%s: %s\n' 'Megabits in/sec'  "$(( ( _interface_bytes_in_new - _interface_bytes_in_old ) / 131072 ))" \
    #                   'Megabits out/sec' "$(( ( _interface_bytes_out_new - _interface_bytes_out_old ) / 131072 ))"

    _interface_bytes_in_old=${_interface_bytes_in_new}
    _interface_bytes_out_old=${_interface_bytes_out_new}
done

Gardez à l'esprit que sleepcela ne prend pas en compte le temps nécessaire pour effectuer les opérations dans la boucle while, ce qui est (très légèrement) inexact. Sur ma machine à coppermine de 600 MHz, la boucle prend 0,011 seconde - une inexactitude négligeable pour la plupart des utilisations. Gardez également à l'esprit lorsque vous utilisez les sorties kilo-octets / mégabits (commentées), bash ne comprend que l'arithmétique entière.

Il existe des moniteurs de trafic réseau comme vnstat qui conserve des enregistrements mensuels de votre trafic, ou slurm qui prend ses valeurs directement de celles stockées dans le noyau. Il est disponible dans la plupart des dépôts distro.

Voici ce que je vois quand je cours slurm -i ra0:

Voici un script shell très simple pour calculer cela:

#!/bin/sh

dev=$1

grep -q "^$dev:" /proc/net/dev || exec echo "$dev: no such device"

read rx <"/sys/class/net/$dev/statistics/rx_bytes"
read tx <"/sys/class/net/$dev/statistics/tx_bytes"

while sleep 1; do
    read newrx <"/sys/class/net/$dev/statistics/rx_bytes"
    read newtx <"/sys/class/net/$dev/statistics/tx_bytes"

    # convert bytes to kbit/s: bytes * 8 / 1000 => bytes / 125
    echo "$dev  {rx: $(((newrx-rx) / 125)), tx: $(((newtx-tx) / 125))}"

    rx=$newrx
    tx=$newtx
done

il suffit de démarrer le script en passant le nom de l'interface, par exemple. ./shtraf eth1