Shell Script UNIX-LINUX-WINDOWS

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

LINUX – Manejo de errores en scripts bash.-

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

En los scripts bash , se deben utilizar diferentes métodos para detectar y manejar los posibles errores que pudiesen ocurrir durante la ejecución de nuestros scripts bash.

1.- En Bash, cada ejecución de un comando devuelve un Código de salida al finalizar su ejecución. Un código 0 (cero) indica que el comando se ejecuto en forma correcta. Cualquier código diferente, indica que ocurrió algún error en su ejecución. –

#!/bin/bash
mkdir /prueba/test01
if [ $? -ne 0 ]; then
     echo "Error: Falló al crear el directorio."
     exit 1
fi

#!/bin/bash

mkdir /prueba/test01

if [ $? -ne 0 ]; then

echo "Error: Falló al crear el directorio."

exit 1

2.- Dentro de un scripts bash, el comando “set -e” le indica que salga inmediatamente (detenga la ejecución) si es que encuentra un código de salida diferente a 0 (cero).- Con esto nos evitamos verificar el estado de salida de cada comando ejecutado, dentro del script :

#!/bin/bash
set -e
mkdir /prueba/test01
echo "Directorio creado exitosamente."

#!/bin/bash

set -e

mkdir /prueba/test01

echo "Directorio creado exitosamente."

3.- Mediante el comando TRAP, el cual sirve para interceptar señales y errores. Se puede especificar TRAP para ejecutar comandos específicos. En el siguiente ejemplo, TRAP captura cualquier error (señalizado por la palabra clave ERR) y ejecuta el código de manejo de errores especificado.

# Capturar señal Ctrl+C (SIGINT)
trap "echo 'Operación cancelada'; exit" SIGINT
# Limpiar al salir
trap "echo 'Limpiando...'; rm -f /tmp/archivo_temp.$$" EXIT
# Ignorar señal
trap "" SIGTERM
# Restablecer comportamiento predeterminado
trap - SIGINT

# Capturar señal Ctrl+C (SIGINT)

trap "echo 'Operación cancelada'; exit" SIGINT

# Limpiar al salir

trap "echo 'Limpiando...'; rm -f /tmp/archivo_temp.$$" EXIT

# Ignorar señal

trap "" SIGTERM

# Restablecer comportamiento predeterminado

trap - SIGINT

#!/bin/bash
trap 'echo "Ocurrió un error en la línea $LINENO. Código de salida: $?. Saliendo..."; exit 1;' ERR
mkdir /prueba/test01
echo "Directorio creado exitosamente."

#!/bin/bash

trap 'echo "Ocurrió un error en la línea $LINENO. Código de salida: $?. Saliendo..."; exit 1;' ERR

mkdir /prueba/test01

echo "Directorio creado exitosamente."

4.- En lugar de mostrar el error por consola, se pueden redirigir a un archivo de salida para poder revisar posteriormente.

#!/bin/bash
exec 2>error_log.txt
mkdir /prueba/test01
if [ $? -ne 0 ]; then
     echo "Error: Falló al crear el directorio."
     exit 1
fi
echo "Directorio creado exitosamente."

#!/bin/bash

exec 2>error_log.txt

mkdir /prueba/test01

if [ $? -ne 0 ]; then

echo "Error: Falló al crear el directorio."

exit 1

echo "Directorio creado exitosamente."

5.- Se puede crear una función personalizada para manejar diferentes tipos de errores, lo que añadirá flexibilidad a tus scripts.-

#!/bin/bash
handle_error() {
   echo "Error en la línea $1"
   exit 1
}
trap 'handle_error $LINENO' ERR
mkdir /prueba/test01
echo "Directorio creado exitosamente."

#!/bin/bash

handle_error() {

echo "Error en la línea $1"

exit 1

}

trap 'handle_error $LINENO' ERR

mkdir /prueba/test01

echo "Directorio creado exitosamente."

# Salir al primer error
set -e
# Detectar uso de variables no definidas
set -u
# Propagar errores en tuberías
set -o pipefail
# Todo junto (recomendado para scripts robustos)
set -euo pipefail
# Función de error
function error_salida() {
    local linea=$1
    local mensaje=$2
    echo "Error en línea $linea: $mensaje" >&2
    exit 1
}
# Usar trap para capturar errores con información de línea
trap 'error_salida ${LINENO} "$BASH_COMMAND"' ERR

# Salir al primer error

set -e

# Detectar uso de variables no definidas

set -u

# Propagar errores en tuberías

set -o pipefail

# Todo junto (recomendado para scripts robustos)

set -euo pipefail

# Función de error

function error_salida() {

local linea=$1

local mensaje=$2

echo "Error en línea $linea: $mensaje" >&2

exit 1

}

# Usar trap para capturar errores con información de línea

trap 'error_salida ${LINENO} "$BASH_COMMAND"' ERR

Publicado en Unix - Linux | Deja un comentario

LINUX – Script array asociativo para analizar LOG y contar direcciones IP.

Publicada el 30/04/2025 por Gonzalo Reiser A.

Este scripts BASH lee un archivo de LOG y contabiliza las direcciones IP encontradas. Al final muestra un resumen con el total de apariciones de cada Dirección IP encontrada en el archivo de LOG :

#!/bin/bash

# Nombre del archivo de registro
logfile="archivo.log"

# Array asociativo para almacenar las direcciones IP y sus conteos
ip_counts=([ ]="0")

# Leer el archivo de registro línea por línea
while IFS= read -r line;
do
  # Buscar direcciones IP en cada línea usando expresiones regulares
  if [[ $line =~ ([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}) ]]; then
    ip=${BASH_REMATCH[1]}
    # Incrementar el conteo para la dirección IP encontrada
    ip_counts[$ip]=$((ip_counts[$ip]+1))
  fi
done < "$logfile"

# Imprimir el resumen de las direcciones IP y sus conteos
echo "Resumen de direcciones IP:"
echo "--------------------"
for ip in "${!ip_counts[@]}"; do
  echo "$ip: ${ip_counts[$ip]}"
done

#!/bin/bash

# Nombre del archivo de registro

logfile="archivo.log"

# Array asociativo para almacenar las direcciones IP y sus conteos

ip_counts=([ ]="0")

# Leer el archivo de registro línea por línea

while IFS= read -r line;

# Buscar direcciones IP en cada línea usando expresiones regulares

if [[ $line =~ ([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}) ]]; then

ip=${BASH_REMATCH[1]}

# Incrementar el conteo para la dirección IP encontrada

ip_counts[$ip]=$((ip_counts[$ip]+1))

done < "$logfile"

# Imprimir el resumen de las direcciones IP y sus conteos

echo "Resumen de direcciones IP:"

echo "--------------------"

for ip in "${!ip_counts[@]}"; do

echo "$ip: ${ip_counts[$ip]}"

done

Explicación del script:

#!/bin/bash: Línea shebang que especifica que el script debe ejecutarse con bash.
logfile="archivo.log": Variable que contiene el nombre del archivo de registro. Cambia «archivo.log» por el nombre de tu archivo.
ip_counts=([ ]="0"): Inicializa un array asociativo llamado ip_counts. La clave es la dirección IP y el valor es el conteo (inicializado en 0).
while IFS= read -r line: Bucle que lee el archivo de registro línea por línea.
if [[ $line =~ ([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}) ]]: Expresión regular que busca direcciones IP en cada línea. Ajusta la expresión regular si tus direcciones IP tienen un formato diferente.
ip=${BASH_REMATCH[1]}: Asigna la dirección IP encontrada a la variable ip.
ip_counts[$ip]=$((ip_counts[$ip]+1)): Incrementa el conteo para la dirección IP en el array asociativo.
for ip in "${!ip_counts[@]}": Bucle que itera sobre las claves del array asociativo (las direcciones IP).
echo "$ip: ${ip_counts[$ip]}": Imprime la dirección IP y su conteo.

Publicado en Unix - Linux | Deja un comentario

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.

LINUX – Manejo de errores en scripts bash.-

LINUX – Script array asociativo para analizar LOG y contar direcciones IP.

Comentarios recientes

Archivos