Shell Script UNIX-LINUX-WINDOWS

BASH – Algunos SCRIPTS útiles, uso ciclo FOR en una linea.-

Publicada el 29/08/2025 por Gonzalo Reiser A.

1.- Realizar copia de programa a múltiples servidores :

for i in server1 server2; do scp checktrans.sh serv@$i:/u2/plug; done

1	for i in server1 server2; do scp checktrans.sh serv@$i:/u2/plug; done

2.- Grabar archivo “copia” al final del archivo “proceso.cfg” en múltiples servidores :

for i in server1 server2; do cat /u02/copia | ssh serv@$i 'cat >> /u02/proceso.cfg'; done

1	for i in server1 server2; do cat /u02/copia \| ssh serv@$i 'cat >> /u02/proceso.cfg'; done

3.- Reinicia proceso “nagioscl” en múltiples servidores :

for i in server1 server2; do ssh  serv@$i '/u02/bin/nagioscl restart'; done

1	for i in server1 server2; do ssh serv@$i '/u02/bin/nagioscl restart'; done

4.- Dividir un archivo grande en archivos de 200 líneas :

split -l 200 -d -a 2 servidores.txt servidores-

1	split -l 200 -d -a 2 servidores.txt servidores-

• -l 200: divide cada archivo en 200 líneas.

• -d: usa números en lugar de letras para los sufijos.

• -a 2: usa 2 dígitos en el sufijo (01, 02, …).

• servidores-: prefijo del archivo.

Si quiere que tengan, extensión .txt :

for f in servidores-??; do mv "$f" "$f.txt"; done

1	for f in servidores-??; do mv "$f" "$f.txt"; done

5.- Tomo la última línea del archivo “reporte.txt y elimino los ESPACIOS que pudiese tener delante y atrás del texto capturado :

cat reporte.txt | tail -n 1 | sed 's/^[[:space:]]*//;s/[[:space:]]*$//'

1	cat reporte.txt \| tail -n 1 \| sed 's/^[[:space:]]//;s/[[:space:]]$//'

6.- Con estas lineas proceso todos los argumentos que se le pasan a un script. Para este caso se pasan 4 valores separados por el signo punto y coma (;). Una vez asignado a las variables correspondientes, puedo trabajar con ellos :

for param in "$@"; do
  IFS='-' read -r fs valor1 valor2 valor3 valor4 <<< "$param"
# Aquí trabajo con los valores asignados a las variables.
Done

for param in "$@"; do

IFS='-' read -r fs valor1 valor2 valor3 valor4 <<< "$param"

# Aquí trabajo con los valores asignados a las variables.

Done

Publicado en Unix - Linux | Deja un comentario

BASH – Monitoreo File System (Plugins NAGIOS). UNIX-LINUX-SOLARIS-AIX.-

Publicada el 24/08/2025 por Gonzalo Reiser A.

Este plugin ha sido desarrollado con el objetivo de ayudar a quienes necesitan monitorear el uso de sistemas de archivos en servidores Unix-Linux-Solaris-Aix,.. Permite monitorear múltiples sistemas de archivos simultáneamente, evaluando: Uso de espacio (en porcentajes) -Umbral de Alerta WARNING – Umbral de alerta CRITICA – Umbral de alerta INODOS.

Uso de espacio (en porcentaje)
Umbral de alerta CRITICAL
Umbral de alerta, Uso de inodos

Cada sistema de archivos se pasa como parámetro al SCRIPTS, en el siguiente formato:

                           “/usr-95-98-90”

1	“/usr-95-98-90”

Los valores están separados por guion, el primero corresponde al File System a monitorear, el segundo al umbral WARNING (% de uso), el tercero al umbral CRITICO(% de uso) y el cuarto al umbral de uso INODOS. Al sobrepasar uno de estos umbrales, se gatilla la correspondiente alerta. Se pueden pasar múltiples parámetros, siguiendo este mismo formato.

Este plugin está diseñado para funcionar en todos los sistemas operativos tipo Unix, excluyendo Windows. Ha sido probado exitosamente en:

Linux
Solaris
AIX

Es adaptable según las necesidades específicas de cada entorno.

El orden de las alertas es el siguiente:

CRITICAL (prioridad máxima)
WARNING
OK (con valores informativos)

Esto permite una rápida identificación de problemas graves antes de revisar advertencias o estados normales. Como el plugin está en fase de prueba, agradeceré cualquier comentario, sugerencia o reporte de errores para seguir mejorándolo.

En la salida de la ejecución, muestra los valores obtenidos por cada File System Monitoreado, ya sean en estado OK, WARNING o CRITICO

#!/bin/bash
# Detectar el sistema operativo
OS_TYPE=$(uname)
if [[ "$OS_TYPE" == "Linux" ]]; then
     inodo="df -i"
     comdf="df -h"
elif [[ "$OS_TYPE" == "SunOS" ]]; then
     inodo="df -F ufs -o i "
     comdf="df -h"
elif [[ "$OS_TYPE" == "AIX" ]]; then
     inodo="df -g"
     comdf="df -g"
elif [[ "$OS_TYPE" == "Unix" ]]; then
     inodo="df -i"
     comdf="df -h"
else
     inodo="df -i"
     comdf="df -h"
fi

global_status=0
unset crit warn ok

# Procesar cada parametro
for param in "$@"; do
  IFS='-' read -r fs warning critical inode <<< "$param"

# Obtiene los valores del File System
  df_output=`$comdf "$fs" | grep "$fs"`
  used_percent=`echo "$df_output" | awk '{for(i=1;i<=NF;i++) if($i ~ /%$/) print $i}' | sed 's/%//'`
  avail_space=`echo "$df_output" | awk '{for(i=2;i<=NF;i++) if($i ~ /%$/) print $(i-1)}'`
  if [[ "$OS_TYPE" == "AIX" ]]; then
        used_percent=`echo $used_percent | cut -d" " -f1`
        avail_space=`echo $avail_space | cut -d" " -f1 | sed 's/$/G/'`
  fi
  free_percent=`expr 100 - $used_percent`

# Obtiene los valores de INODO
  df_inode=`$inodo "$fs" | grep "$fs"`

# Consulta si se obtuvieron valores en forma correcta
  if [[ $? -ne 0 ]] ; then
        inode_free_percent=99
     else
        inode_used_percent=`echo "$df_inode" | awk '{for(i=1;i<=NF;i++) if($i ~ /%$/) print $i}' | sed 's/%//'`
        if [[ "$OS_TYPE" == "AIX" ]]; then
              inode_used_percent=`echo $inode_used_percent | cut -d" " -f2`
        fi
        inode_free_percent=`expr 100 - $inode_used_percent`
  fi

  if [ "$used_percent" -ge "$critical" ] || [ "$inode_used_percent" -ge "$inode" ]; then
        crit=`echo "$crit $fs $avail_space($free_percent%)I-$inode_free_percent%"`
        global_status=2
     elif [ "$used_percent" -ge "$warning" ]; then
        warn=`echo "$warn $fs $avail_space($free_percent%)I-$inode_free_percent%"`
        global_status=1
     else
        ok=`echo "$ok $fs $avail_space($free_percent%)I-$inode_free_percent%"`
  fi

  crit=$(echo $crit)
  warn=$(echo $warn)
  ok=$(echo $ok)
done

if [ "$global_status" -eq 0 ]; then
    echo "OK=$ok"
    exit 0
fi

if [ "$global_status" -eq 1 ]; then
    if [ -n "$ok" ]; then
        echo "WAR=$warn OK=$ok"
    else
        echo "WAR=$warn"
    fi
    exit 1
fi

if [ "$global_status" -eq 2 ]; then
    output="CRIT=$crit"
    [ -n "$warn" ] && output="$output WAR=$warn"
    [ -n "$ok" ] && output="$output OK=$ok"
    echo "$output"
    exit 2
fi

# Si no se cumple ninguna condición
echo "Error: $global_status No definido"
exit 3

#!/bin/bash

# Detectar el sistema operativo

OS_TYPE=$(uname)

if [[ "$OS_TYPE" == "Linux" ]]; then

inodo="df -i"

comdf="df -h"

elif [[ "$OS_TYPE" == "SunOS" ]]; then

inodo="df -F ufs -o i "

comdf="df -h"

elif [[ "$OS_TYPE" == "AIX" ]]; then

inodo="df -g"

comdf="df -g"

elif [[ "$OS_TYPE" == "Unix" ]]; then

inodo="df -i"

comdf="df -h"

else

inodo="df -i"

comdf="df -h"

global_status=0

unset crit warn ok

# Procesar cada parametro

for param in "$@"; do

IFS='-' read -r fs warning critical inode <<< "$param"

# Obtiene los valores del File System

df_output=`$comdf "$fs" | grep "$fs"`

used_percent=`echo "$df_output" | awk '{for(i=1;i<=NF;i++) if($i ~ /%$/) print $i}' | sed 's/%//'`

avail_space=`echo "$df_output" | awk '{for(i=2;i<=NF;i++) if($i ~ /%$/) print $(i-1)}'`

if [[ "$OS_TYPE" == "AIX" ]]; then

used_percent=`echo $used_percent | cut -d" " -f1`

avail_space=`echo $avail_space | cut -d" " -f1 | sed 's/$/G/'`

free_percent=`expr 100 - $used_percent`

# Obtiene los valores de INODO

df_inode=`$inodo "$fs" | grep "$fs"`

# Consulta si se obtuvieron valores en forma correcta

if [[ $? -ne 0 ]] ; then

inode_free_percent=99

else

inode_used_percent=`echo "$df_inode" | awk '{for(i=1;i<=NF;i++) if($i ~ /%$/) print $i}' | sed 's/%//'`

if [[ "$OS_TYPE" == "AIX" ]]; then

inode_used_percent=`echo $inode_used_percent | cut -d" " -f2`

inode_free_percent=`expr 100 - $inode_used_percent`

if [ "$used_percent" -ge "$critical" ] || [ "$inode_used_percent" -ge "$inode" ]; then

crit=`echo "$crit $fs $avail_space($free_percent%)I-$inode_free_percent%"`

global_status=2

elif [ "$used_percent" -ge "$warning" ]; then

warn=`echo "$warn $fs $avail_space($free_percent%)I-$inode_free_percent%"`

global_status=1

else

ok=`echo "$ok $fs $avail_space($free_percent%)I-$inode_free_percent%"`

crit=$(echo $crit)

warn=$(echo $warn)

ok=$(echo $ok)

done

if [ "$global_status" -eq 0 ]; then

echo "OK=$ok"

exit 0

if [ "$global_status" -eq 1 ]; then

if [ -n "$ok" ]; then

echo "WAR=$warn OK=$ok"

else

echo "WAR=$warn"

exit 1

if [ "$global_status" -eq 2 ]; then

output="CRIT=$crit"

[ -n "$warn" ] && output="$output WAR=$warn"

[ -n "$ok" ] && output="$output OK=$ok"

echo "$output"

exit 2

# Si no se cumple ninguna condición

echo "Error: $global_status No definido"

exit 3

El el siguiente ejemplo lo lanzaremos para monitorear 3 File system en un determinado servidor SOLARIS y muestra el detalle de salida :

./monfilesys.sh "/-95-98-95" "/usr01-85-90-90" "/tmp-95-98-95"

1	./monfilesys.sh "/-95-98-95" "/usr01-85-90-90" "/tmp-95-98-95"

En el detalle indica que el FS «/usr01» tiene 2.2 Gigas libres, correspondiente al 11% y de inodos el 94% disponible. Aquí se gatillo la alerta WANING (WAR). Después aparecen los otros 2 File System, los cuales están dentro de los parámetros normales.-

WAR=/usr01 2.2G(11%)I-94% OK=/ 1.2G(12%)I-81% /tmp 61G(95%)I-99%

1	WAR=/usr01 2.2G(11%)I-94% OK=/ 1.2G(12%)I-81% /tmp 61G(95%)I-99%

Publicado en Unix - Linux | Deja un comentario

LINUX – Scripts BASH para obtener valor Uf Dolar Euro Utm desde web Banco Central Chile.

Publicada el 05/08/2025 por Gonzalo Reiser A.

Utilizo estos valores para algunos cálculos en aplicaciones. Me permite obtener los valores del día actual.-

#!/bin/bash
fecha=`date +"%d-%m-%Y"`
uf=`curl -s "https://www.bcentral.cl/inicio" | grep "option value" | grep -e "UF" | cut -d"\"" -f2`
dolar=`curl -s "https://www.bcentral.cl/inicio" | grep "option value" | grep -e "LAR" | cut -d"\"" -f2`
euro=`curl -s "https://www.bcentral.cl/inicio" | grep "option value" | grep -e "EURO" | cut -d"\"" -f2`
utm=`curl -s "https://www.bcentral.cl/inicio" | grep "option value" | grep -e "UTM" | cut -d"\"" -f2`
echo ""
echo " BANCO CENTRAL DE CHILE $fecha Valores ==> EURO=$euro UTM=$utm DOLAR=$dolar UF=$uf"
echo ""
exit

#!/bin/bash

fecha=`date +"%d-%m-%Y"`

uf=`curl -s "https://www.bcentral.cl/inicio" | grep "option value" | grep -e "UF" | cut -d"\"" -f2`

dolar=`curl -s "https://www.bcentral.cl/inicio" | grep "option value" | grep -e "LAR" | cut -d"\"" -f2`

euro=`curl -s "https://www.bcentral.cl/inicio" | grep "option value" | grep -e "EURO" | cut -d"\"" -f2`

utm=`curl -s "https://www.bcentral.cl/inicio" | grep "option value" | grep -e "UTM" | cut -d"\"" -f2`

echo ""

echo " BANCO CENTRAL DE CHILE $fecha Valores ==> EURO=$euro UTM=$utm DOLAR=$dolar UF=$uf"

echo ""

exit

Le doy permisos de ejecución al Script : chmod u+x valores.sh Luego al ejecutarlo obtengo el siguiente resultado : (puedo trabajar con los valores por separado)

[desa@monster]$ ./valores_bcentral.sh

 BANCO CENTRAL DE CHILE 05-08-2025 Valores ==> EURO=1.115,81 UTM=68.647 DOLAR=964,28 UF=39.153,69

[desa@monster]$ ./valores_bcentral.sh

BANCO CENTRAL DE CHILE 05-08-2025 Valores ==> EURO=1.115,81 UTM=68.647 DOLAR=964,28 UF=39.153,69

Publicado en Unix - Linux | Deja un comentario

LINUX – Medir tiempo de ejecución SCRIPT BASH.

Publicada el 31/07/2025 por Gonzalo Reiser A.

En la administración de sistemas y el desarrollo de software, a menudo se necesita medir el tiempo para evaluar el rendimiento de una tarea o un programa. Aunque el tiempo se mide en segundos, puede ser difícil de interpretar si el valor es muy grande. Para facilitar su lectura, es útil convertir los segundos a un formato más convencional, como hora:minuto:segundo (HH:MM:SS).

Aquí hay cinco razones por las que sería una buena idea medir el tiempo de los scripts:

Optimización del rendimiento: Al medir el tiempo de ejecución de los scripts, puedes identificar los cuellos de botella y áreas de mejora en tu código. Esto te permite optimizar el rendimiento y reducir el tiempo de ejecución, lo que es especialmente importante en aplicaciones de tiempo crítico o de alto rendimiento.
Comparación de soluciones: A menudo, hay varias formas de abordar un problema en la programación. Al medir el tiempo de ejecución de diferentes soluciones, puedes comparar su eficiencia y elegir la mejor opción en términos de velocidad y rendimiento.
Monitoreo del rendimiento a lo largo del tiempo: Medir el tiempo de ejecución de los scripts de manera regular te permite llevar un registro del rendimiento a lo largo del tiempo. Esto puede ser útil para detectar degradaciones en el rendimiento a medida que se introducen cambios en el código o en el entorno de ejecución, permitiendo así solucionar problemas antes de que se vuelvan críticos.
Establecer expectativas realistas: Al conocer el tiempo de ejecución de tus scripts, puedes establecer expectativas realistas para los usuarios finales y otros miembros del equipo en cuanto a cuánto tiempo tomará completar ciertas tareas. Esto también puede ayudar en la planificación de recursos y en la evaluación de la viabilidad de ciertas características o soluciones.
Identificación de problemas de escalabilidad: Cuando un script se ejecuta con diferentes tamaños de entrada o en diferentes entornos o simplemente la carga de trabajo aumento con el tiempo, el tiempo de ejecución puede variar significativamente. Medir el tiempo de ejecución en estas situaciones te ayuda a identificar problemas de escalabilidad y a tomar decisiones informadas sobre cómo manejar la carga de trabajo y la distribución de recursos en función de la demanda y el rendimiento esperados.

Para calcular el tiempo de ejecución de un script Bash, puedes usar el comando time antes de ejecutar el script. Este comando mostrará el tiempo real, el tiempo de usuario y el tiempo del sistema empleado en la ejecución.

time ./ejecutime.sh

real    6m18.009s
user    0m0.005s
sys     0m0.003s

time ./ejecutime.sh

real 6m18.009s

user 0m0.005s

sys 0m0.003s

O ejecutar el siguiente SCRIPT :

#!/bin/bash
hora_ini=`date +"%T"`
## Aquí ejecutas el script que deseas calcular el tiempo de ejecución
sleep 378
## Lo mismo lo puedes hacer lanzado un script.....
hora_fin=`date +"%T"`
segu_ini=$(date -d "$hora_ini" +%s)
segu_fin=$(date -d "$hora_fin" +%s)
hora_dif=$((segu_fin - segu_ini))
hora_tra=$(date -d @$hora_dif -u +%H:%M:%S)
hora_num=$((hora_dif/3600))
minu_num=$(((hora_dif % 3600)/60))
segu_num=$((hora_dif % 60))
echo "HORA INICIO      : $hora_ini"
echo "HORA TERMINO     : $hora_fin"
echo "TIEMPO EJECUCION : $hora_tra"
echo ""
echo "EL PROCESO DEMORO $hora_num HRS CON $minu_num MINS Y $segu_num SEGS EN EJECUTARSE."
exit

#!/bin/bash

hora_ini=`date +"%T"`

## Aquí ejecutas el script que deseas calcular el tiempo de ejecución

sleep 378

## Lo mismo lo puedes hacer lanzado un script.....

hora_fin=`date +"%T"`

segu_ini=$(date -d "$hora_ini" +%s)

segu_fin=$(date -d "$hora_fin" +%s)

hora_dif=$((segu_fin - segu_ini))

hora_tra=$(date -d @$hora_dif -u +%H:%M:%S)

hora_num=$((hora_dif/3600))

minu_num=$(((hora_dif % 3600)/60))

segu_num=$((hora_dif % 60))

echo "HORA INICIO : $hora_ini"

echo "HORA TERMINO : $hora_fin"

echo "TIEMPO EJECUCION : $hora_tra"

echo ""

echo "EL PROCESO DEMORO $hora_num HRS CON $minu_num MINS Y $segu_num SEGS EN EJECUTARSE."

exit

Al ejecutarlo, mostraría el siguiente resultado :

HORA INICIO      : 20:40:32
HORA TERMINO     : 20:46:50
TIEMPO EJECUCION : 00:06:18

EL PROCESO DEMORO 0 HRS CON 6 MINS Y 18 SEGS EN EJECUTARSE.

HORA INICIO : 20:40:32

HORA TERMINO : 20:46:50

TIEMPO EJECUCION : 00:06:18

EL PROCESO DEMORO 0 HRS CON 6 MINS Y 18 SEGS EN EJECUTARSE.

Publicado en Unix - Linux | Deja un comentario

Formas de ejecutar Múltiples Comandos a Través de una conexión SSH.

Publicada el 27/05/2025 por Gonzalo Reiser A.

1.- Usar comandos separados por punto y coma :

Este ejemplo cambiará al directorio /var/log, contará la cantidad de líneas que contienen “error” en el archivo syslog y mostrará las últimas 5 líneas del archivo syslog.

ssh user@host 'cd /var/log; grep "error" syslog | wc -l; tail -n 5 syslog'

1	ssh user@host 'cd /var/log; grep "error" syslog \| wc -l; tail -n 5 syslog'

2.- Usar comandos separados por doble ampersand :

Este ejemplo cambiará al directorio /var/log, creará un archivo comprimido de syslog como syslog.gz y eliminará el archivo syslog original solo si los comandos anteriores tuvieron éxito.

ssh user@host 'cd /var/log && gzip -c syslog > syslog.gz && rm syslog'

1	ssh user@host 'cd /var/log && gzip -c syslog > syslog.gz && rm syslog'

3.- Usar comandos separados por un solo ampersand :

Este ejemplo buscará todos los archivos .txt en el directorio raíz y guardará los resultados en archivos.txt, esperará 5 segundos e imprimirá “¡Terminado!”, todo en paralelo.

ssh user@host 'find / -name "*.txt" > archivos.txt & sleep 5 & echo "¡Terminado!"'

1	ssh user@host 'find / -name "*.txt" > archivos.txt & sleep 5 & echo "¡Terminado!"'

4.- Usar la agrupación de comandos :

Este ejemplo ejecutará dos grupos de comandos en paralelo: el primer grupo cambiará al directorio /var/log y guardará todas las líneas que contienen “error” del archivo syslog en errores.log, y el segundo grupo cambiará al directorio /var/tmp y mostrará el uso del disco para cada elemento.

ssh user@host '(cd /var/log; grep "error" syslog > errores.log) & (cd /var/tmp; du -sh *)'

1	ssh user@host '(cd /var/log; grep "error" syslog > errores.log) & (cd /var/tmp; du -sh *)'

5.- Usar una subcapa :

Este ejemplo cambiará al directorio /var/log, contará la cantidad de líneas que contienen “error” en el archivo syslog y mostrará las últimas 5 líneas del archivo syslog, todo dentro de una subcapa (Ejecutar una subcapa (subshell) en Bash ofrece varias ventajas, incluyendo la capacidad de modificar el entorno de forma temporal, ejecutar comandos en paralelo y aislar procesos. Las subcapas permiten crear entornos de ejecución independientes dentro de los scripts, lo que facilita la gestión de procesos y la ejecución de comandos sin afectar el entorno principal).

ssh user@host 'bash -c "cd /var/log; grep error syslog | wc -l; tail -n 5 syslog"'

1	ssh user@host 'bash -c "cd /var/log; grep error syslog \| wc -l; tail -n 5 syslog"'

6.- Ejecutar un script local de forma remota :

Para ejecutar un script local en el servidor remoto, se ejecuta de esta forma..

ssh user@host 'bash -s' < script_local.sh

1	ssh user@host 'bash -s' < script_local.sh

7.- Usar un Here Document :

Este ejemplo cambiará al directorio /var/log, contará la cantidad de líneas que contienen “error” en el archivo syslog y mostrará las últimas 5 líneas del archivo syslog en el host remoto.

ssh user@host << 'EOF'
cd /var/log
grep "error" syslog | wc -l
tail -n 5 syslog
EOF

ssh user@host << 'EOF'

cd /var/log

grep "error" syslog | wc -l

tail -n 5 syslog

EOF

Publicado en Unix - Linux | Deja un comentario

BASH – Algunos SCRIPTS útiles, uso ciclo FOR en una linea.-

BASH – Monitoreo File System (Plugins NAGIOS). UNIX-LINUX-SOLARIS-AIX.-

LINUX – Scripts BASH para obtener valor Uf Dolar Euro Utm desde web Banco Central Chile.

LINUX – Medir tiempo de ejecución SCRIPT BASH.

Formas de ejecutar Múltiples Comandos a Través de una conexión SSH.

Comentarios recientes

Archivos