df muestra

-bash-4.1# df 
Sistema de ficheros 1K-blocks Usada Disponible Uso% Montado en 
/dev/sda3 1918217320 1783986384 36791092 98% /
tmpfs 16417312 0 16417312 0% /dev/shm 
/dev/sda1 482214 148531 308784 33% /boot 
/dev/sdb1 1922858352 1373513440 451669312 76% /disk2 

Necesito un script de bash una función que devuelve 1 si un particiones ser 100% completo.
cómo puede hacerse esto? ¿qué comandos puedo utilizar para analizar la salida de df?

  • puede ser df |grep 100%?
  • df | awk '$5=="100%" {print $1}' se imprimirá el sistema de archivos es de 100%.
  • Un útil limitar también puede ser utilizado: df -h | tail -n+2 | awk '$5 >= "90%" {print "warning: " $1 " at " $5}' Recuerde, el porcentaje y la disposición de df no incluye el sistema de reserva para usuarios no root (generalmente 5%).
InformationsquelleAutor user121196 | 2013-05-23

6 Comentarios

  1. 1

    Esto debe hacerlo:

    disks_space() {
        ! df -P | awk '{print $5}' | grep -Fqx '100%'
    }

    En otras palabras, compruebe si alguna de las líneas en la quinta columna de la POSIX df de salida contiene la cadena exacta «100%».

    • awk seguido por grep? Seguramente estás de broma.
    • Lo que quería transmitir, pero no, era que no suele ser necesario: ! df -P|awk '$5=="100%" {exit 1}' creo que también es más fácil de leer y de auto-documentación de magia grep opciones. Guardar un proceso y un tenedor de hoy 🙂
    • Yo normalmente expresan esta como ! df --portability | awk '{print $5}' | grep --fixed-strings --line-regexp --quiet '100%' para mejorar la legibilidad, pero no cada una de las encarnaciones de grep admite opciones largas. El comando es muy clara, pero a menudo sed, awk y perl comandos tienden a convertirse en ruido en la línea muy rápidamente.
  2. 1

    Probelm con el porcentaje es si es un terrabyte disco del 95% de que todavía puede ser una gran cantidad de concierto – se refieren a la parte inferior de secuencia de comandos para el espacio de disco real – el formato de 100 al final de la muestra en el ejemplo de alerta cuando se está por debajo de 100 MB a la izquierda en una partición

    diskspace.sh

    #!/bin/sh
    # set -x
    # Shell script to monitor or watch the disk space
    # It will send an email to $ADMIN, if the (free available) percentage of space is >= 90%.
    # -------------------------------------------------------------------------
    # Set admin email so that you can get email.
    ADMIN="root"
    # set alert level 90% is default
    ALERT=90
    # Exclude list of unwanted monitoring, if several partions then use "|" to separate the partitions.
    # An example: EXCLUDE_LIST="/dev/hdd1|/dev/hdc5"
    EXCLUDE_LIST="/auto/ripper"
    #
    #::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
    #
    function main_prog() {
    while read output;
    do
    echo $output
      usep=$(echo $output | awk '{ print $1}' | cut -d'%' -f1)
    
      partition=$(echo $output | awk '{print $2}')
    
      if [ $usep -ge $ALERT ] ; then
        if [ "$partition" == "/var" ]; then
                 # echo "Running out of space \"$partition ($usep%)\" on server $(hostname), $(date)"
                 echo "Running out of space \"$partition ($usep%)\" on server $(hostname), $(date)" |  mail -s "Alert: Almost out of disk space $usep%" $ADMIN
    
            # Extra bits  you may wish to do -    
            #for FILE in `find $partition -size +1G -print`
            #do
            #    echo $FILE
            #    DATE=`date  +%Y-%m-%d_%H%M`
            #    filename=`echo ${FILE##*/}`
            #    mkdir /mnt/san/$hostname
            #    echo cp $FILE /mnt/san/$(hostname)/$filename-$DATE
            #    #echo > $FILE
            #done
        fi
      fi
    done
    }
    if [ "$EXCLUDE_LIST" != "" ] ; then
      df -hP |  grep -vE "^[^/]|tmpfs|cdrom|${EXCLUDE_LIST}" | awk '{print $5 " " $6}' | main_prog
    else
      df -hP |  grep -vE "^[^/]|tmpfs|cdrom"| awk '{print $5 " " $6}' | main_prog
    fi

    O usted podría usar este estilo de verificación pongo en el lugar de nagios (utilizando snmp para conectarse a un host remoto)

    snmp_remote_disk_auto

    #!/bin/bash
    # This script takes:
    # <host> <community> <megs>
    snmpwalk="/usr/bin/snmpwalk"
    snmpget="/usr/bin/snmpget"
    function usage() { 
    echo "$0 localhost public 100"
    echo "where localhost is server"
    echo "public is snmp pass"
    echo "100 is when it reaches below a 100Mb"
    echo "-----------------------------------"
    echo "define threshold below limit specific for partitions i.e. boot can be 50mb where as /var I guess we want to catch it at around 1 gig so"
    echo "$0 localhost public  1024"
    }
    server=$1;
    pass=$2
    limit=$3;
    errors_found="";
    partitions_found="";
    lower_limit=10;
    graphtext="|"
    if [ $# -lt 3 ]; then
    usage;
    exit 1;
    fi
    # takes <size> <used> <allocation>
    calc_free() {
    echo "$1 $2 - $3 * 1024 /1024 /p" | dc
    }
    for partitions in $($snmpwalk -v2c -c $pass -Oq $server  hrStorageDescr|grep /|egrep -v "(/mnt|/home|/proc|/sys)"|awk '{print $NF}'); do
    if [[ $partitions =~ /boot ]]; then
    limit=$lower_limit;
    fi
    if result=$($snmpwalk -v2c -c $pass -Oq $server hrStorageDescr | grep "$partitions$"); then
    index=$(echo $result | sed 's/.*hrStorageDescr//' | sed 's/.*//')
    args=$($snmpget -v2c -c $pass -Oqv $server hrStorageSize$index hrStorageUsed$index hrStorageAllocationUnits$index | while read oid j ; do printf " $oid" ; done)
    free=$(calc_free$args)
    back_count=$(echo $partitions|grep -o "/"|wc -l)
    if [[ $back_count -ge 2 ]]; then
    gpartition=$(echo "/"${partitions##*/})
    else
    gpartition=$partitions;
    fi
    if [ "$free" -gt "$limit" ]
    then
    graphtext=$graphtext$gpartition"="$free"MB;;;0 "
    #graphtext=$graphtext$partitions"="$free"MB;;;0 "
    partitions_found=$partitions_found" $partitions ($free MB)"
    else
    graphtext=$graphtext$gpartition"="$free"MB;;;0 "
    #graphtext=$graphtext$partitions"="$free"MB;;;0 "
    errors_found=$errors_found" $partitions ($free MB)"
    fi
    else
    graphtext=$graphtext$gpartition"="0"MB;;;0 "
    #graphtext=$graphtext$partitions"="0"MB;;;0 "
    errors_found=$errors_found" $paritions does_not_exist_or_snmp_is_not_responding"
    fi
    done
    if [ "$errors_found" == "" ]; then
    echo "OK: $partitions_found$graphtext"
    exit 0
    else
    echo "CRITICAL: $errors_found$graphtext";
    exit 2;
    fi

    ./snmp_remote_disk_auto localhost public 100

    OK:  / (1879 MB) /var (2281 MB) /tmp (947 MB) /boot (175 MB)|/=1879MB;;;0 /var=2281MB;;;0 /tmp=947MB;;;0 /boot=175MB;;;0 
  3. 1

    No es un gran fan de la excesiva greps y awks como lo que realmente puede traer errores a lo largo del tiempo..

    Acabo de obtener la información de las carpetas que importa. A continuación se muestra un ejemplo de uso de stat que le dará la BYTES disponibles en una carpeta, a continuación, se convierte a MB (10**6). Yo más o menos probado esto en mi RHEL6.x sistema.

        folder_x_mb=$(($(stat -f --format="%a*%s" /folder_x)/10**6))    
    folder_y_mb=$(($(stat -f --format="%a*%s" /folder_y)/10**6))   
    folder_z_mb=$(($(stat -f --format="%a*%s" /folder_z)/10**6))     
    • El único problema con stat es que no refleja la 5% de reserva no está disponible para usuarios no root.
  4. 0

    ¿Algo como:

    df | perl -wne 'if(/(\d+)%\s+(.*)/){print "$2 at $1%\n" if $1>90}'

    Puede cambiar el umbral y en lugar de la impresión de que sólo puede salir:

    df | perl -wne 'if(/(\d+)%\s+(.*)/){exit 1 if $1>99}'
  5. 0

    Aquí es un simple script para comprobar si ya hay un disco que alcanzó su máxima capacidad y, si no se volvería /salida 1.

    #!/bin/sh
    CHECK=$(df -Ph | grep '100%' | xargs echo | cut -d' ' -f5)
    if [ "$CHECK" == "100%"]
    then
    echo 1
    else
    echo 0
    fi
  6. 0

    Intente esto: df -Ph | grep -v "Use%" | sed 's/%//g' | awk '$5 > LIMIT {print $1,$2,$3,$4,$5"%";}' | column -t'

    Devolverá todas las df -Ph las entradas que superan el LIMIT

    Por ejemplo, en mi estación de trabajo, df -Ph devuelve:

    Filesystem            Size  Used Avail Use% Mounted on
    /dev/cciss/c0d0p1      92G   32G   56G  37% /
    shmfs                  98G  304K   98G   1% /dev/shm
    192.168.1.1:/apache_cache  2.7T  851G  1.9T  32% /media/backup
    /dev/dm-4              50G   49G  1.1G  98% /lun1
    /dev/dm-7              247G  30G  218G  12% /lun2

    Digamos que yo quiero a la lista de los puntos de montaje que exceda del 20% de su capacidad.

    Yo uso df -Ph | grep -v "Use%" | sed 's/%//g' | awk '$5 > 20 {print $1,$2,$3,$4,$5"%";}' | column -t, y devuelve el siguiente:

    /dev/cciss/c0d0p1      92G   32G   56G  37% /
    192.168.1.1:/apache_cache  2.7T  851G  1.9T  32% /media/backup
    /dev/dm-4              50G   49G  1.1G  98% /lun1

    La column -t parte es aquí puramente para que la salida sea legible.

Dejar respuesta

Please enter your comment!
Please enter your name here