LinuxParty

Inicio desactivadoInicio desactivadoInicio desactivadoInicio desactivadoInicio desactivado
 

Aclaremos algunos conceptos primero.

  1. Un shell es un programa que toma comandos y los entrega al sistema operativo para que se ejecuten.
  2. Un terminal es un programa que nos permite como usuarios finales interactuar con el shell. Un ejemplo de terminal es el terminal GNOME, como se muestra en la imagen a continuación.
Terminal Gnome Linux

Terminal de Gnome

Cuando comenzamos un shell, presenta un símbolo del sistema (también conocido como línea de comando), que nos dice que el shell está listo para comenzar a aceptar comandos de su dispositivo de entrada estándar, que generalmente es el teclado.

Linux proporciona una gama de opciones para shells, siendo las siguientes las más comunes:

bash Shell

Bash significa Bourne Again SHell y es el shell predeterminado del Proyecto GNU. Incorpora características útiles de Korn shell (ksh) y C shell (csh), ofreciendo varias mejoras al mismo tiempo. Este es el shell predeterminado utilizado por las distribuciones cubiertas en la certificación LFCS, y es el shell que usaremos en este tutorial.

sh Shell

Bourne SHell es el shell más antiguo y, por lo tanto, ha sido el shell predeterminado de muchos sistemas operativos tipo UNIX durante muchos años.

ksh Shell

El Korn SHell es un shell de Unix que fue desarrollado por David Korn en Bell Labs a principios de la década de 1980. Es retrocompatible con el shell Bourne e incluye muchas características del shell C.

Un script de shell no es más que un archivo de texto convertido en un programa ejecutable que combina comandos ejecutados por el shell uno tras otro.

Scripting básico de shell

Como se mencionó anteriormente, un script de shell nace como un archivo de texto sin formato. Por lo tanto, se puede crear y editar con nuestro editor de texto preferido. Es posible que desee considerar el uso de vi/m, que presenta resaltado de sintaxis para su conveniencia.

Escriba el siguiente comando para crear un archivo llamado myscript.sh y presione Entrar.

 # vim myscript.sh

La primera línea de un script de shell debe ser la siguiente (también conocida como shebang ).

 #!/bin/bash

"Le dice " al sistema operativo el nombre del intérprete que debe usarse para ejecutar el texto que sigue.

Ahora es el momento de agregar nuestros comandos. Podemos aclarar el propósito de cada comando, o la secuencia de comandos completa, agregando comentarios también. Tenga en cuenta que el shell ignora esas líneas que comienzan con un signo de número # (comentarios explicativos).

#!/bin/bash
echo Este es un artículo de Linux
echo Hoy es: $(date +%Y-%m-%d)

Una vez que el guión ha sido escrito y guardado, debemos hacerlo ejecutable.

# chmod 755 myscript.sh
o
# chmod a+x myscript

Antes de ejecutar nuestro script, necesitamos decir algunas palabras sobre la variable de entorno $PATH . Si corremos

echo $PATH

desde la línea de comandos, veremos el contenido de $PATH: una lista de directorios separados por dos puntos que se buscan cuando ingresamos el nombre de un programa ejecutable. Se llama una variable de entorno porque es parte del entorno del shell: un conjunto de información que está disponible para el shell y sus procesos secundarios cuando se inicia el shell.

Cuando escribimos un comando y presionamos Enter, el shell busca en todos los directorios listados en la variable $PATH y ejecuta la primera instancia que se encuentra. Veamos un ejemplo

/usr/lib64/qt-3.3/bin:/usr/local/bin:/usr/bin:/bin:/usr/local/sbin:/usr/sbin \
:/home/javier/.composer/vendor/bin:/home/javier/.local/bin:/home/javier/bin: \
/home/javier/bin/sbin:/home/javier/bin/kompozer

Variables de entorno

Si hay dos archivos ejecutables con el mismo nombre, uno en /usr/local/bin y otro en /usr/bin , el que está en el primer directorio se ejecutará primero, mientras que el otro no se tendrá en cuenta.

Si no hemos guardado nuestro script dentro de uno de los directorios listados en la variable $ PATH , necesitamos agregar ./ al nombre del archivo para ejecutarlo. De lo contrario, podemos ejecutarlo tal como lo haríamos con un comando regular.

# pwd
# ./myscript.sh
# cp myscript.sh ../bin
# cd ../bin
# pwd
# myscript.sh

Ejecutar script

Condicionales

Siempre que necesite especificar diferentes cursos de acción que se tomarán en un script de shell, como resultado del éxito o el fracaso de un comando, usará la construcción if para definir tales condiciones. Su sintaxis básica es:

if (si) CONDICIÓN; then (entonces)
	COMANDOS;
else (sino)
	OTROS COMANDOS 
fi

Donde CONDITION puede ser uno de los siguientes (aquí solo se citan las condiciones más frecuentes) y se evalúa como verdadero cuando:

  1. [-a archivo] → el archivo existe.
  2. [-d archivo] → el archivo existe y es un directorio.
  3. [-f archivo] → existe y es un archivo normal.
  4. [-u archivo] → el archivo existe y se establece su bit SUID (establecer ID de usuario).
  5. [-g archivo] → existe y su bit SGID está establecido.
  6. [-k archivo] → el archivo existe y se establece su bit fijo.
  7. [-r archivo] → el archivo existe y es legible.
  8. [-s archivo] → el archivo existe y no está vacío.
  9. [-w archivo] → el archivo existe y se puede escribir.
  10. [-x archivo] es verdadero si el archivo existe y es ejecutable.
  11. [cadena1 = cadena2] → las cadenas son iguales.
  12. [string1 != string2] → las cadenas no son iguales.

[int1 op int2] debe formar parte de la lista anterior, mientras que los elementos que siguen (por ejemplo, -eq -> es verdadero si int1 es igual a int2 .) deben ser una lista " secundaria " de [ int1 op int2 ] donde op es uno de los siguientes operadores de comparación.

  1. -eq -> es verdadero si int1 es igual a int2.
  2. -ne -> verdadero si int1 no es igual a int2.
  3. -lt -> verdadero si int1 es menor que int2.
  4. -le -> verdadero si int1 es menor o igual que int2.
  5. -gt -> verdadero si int1 es mayor que int2.
  6. -ge -> verdadero si int1 es mayor o igual que int2.

Para bucles

Este bucle permite ejecutar uno o más comandos para cada valor en una lista de valores. Su sintaxis básica es:

for item in SEQUENCE; do 
		COMMANDS; 
done

Donde item es una variable genérica que representa cada valor en SECUENCIA durante cada iteración.

Mientras bucles

Este bucle permite ejecutar una serie de comandos repetitivos siempre que el comando de control se ejecute con un estado de salida igual a cero (con éxito). Su sintaxis básica es:

while EVALUATION_COMMAND; do 
		EXECUTE_COMMANDS; 
done

Donde EVALUATION_COMMAND puede ser cualquier comando (s) que puede salir con un estado de éxito ( 0 ) o error (que no sea 0) , y EXECUTE_COMMANDS puede ser cualquier programa, script o construcción de shell, incluidos otros bucles anidados.

Poniendolo todo junto

Demostraremos el uso de la construcción if y el ciclo for con el siguiente ejemplo.

Determinar si un servicio se ejecuta en una distribución basada en systemd

Creemos un archivo con una lista de servicios que queremos monitorear de un vistazo.

 # cat myservices.txt

sshd
mariadb
httpd
crond
Firewalld

Script para monitorear servicios de Linux

Nuestro script de shell debería verse así.

    #!/bin/bash

    # Este script itera sobre una lista de servicios y
    # se utiliza para determinar si se están ejecutando o no.

    for service in $(cat myservices.txt); do
                echo "Testando: $service..."
                systemctl status $service | grep --quiet "running"
                if [ $? -eq 0 ]; then
                        echo $service "is [ACTIVO]"
                else
                        echo $service "is [INACTIVO or NO INSTALADO]"
                fi
    done

Script de Monitoreo de Servicio Linux

Vamos a explicar cómo funciona el script.

1) El bucle para leer el archivo myservices.txt es un elemento de LISTA. Ese elemento único se denota mediante la variable genérica denominada $service. La LISTA se completa con la salida de,

 # cat myservices.txt

2) El comando anterior está encerrado entre paréntesis y está precedido por un signo de dólar para indicar que debe evaluarse para completar la LISTA que repetiremos.

3) Para cada elemento de LIST (es decir, cada instancia de la variable de servicio), se ejecutará el siguiente comando.

# systemctl status $service | grep --quiet "running"

Esta vez necesitamos preceder nuestra variable genérica (que representa cada elemento en la LISTA ) con un signo de dólar para indicar que es una variable y, por lo tanto, se debe usar su valor en cada iteración. La salida se canaliza a grep.

La bandera –quiet se usa para evitar que grep muestre en la pantalla las líneas donde aparece la palabra en ejecución. Cuando eso sucede, el comando anterior devuelve un estado de salida de 0 (representado por $? En la construcción if), verificando así que el servicio se está ejecutando.

Un estado de salida diferente de 0 (lo que significa que la palabra en ejecución no se encontró en la salida de systemctl status $service ) indica que el servicio no se está ejecutando.

Script de Monitoreo de Servicios

Podríamos ir un paso más allá y verificar la existencia de myservices.txt antes de intentar ingresar al bucle for.

#!/bin/bash

# This script iterates over a list of services and
# is used to determine whether they are running or not.

if [ -f myservices.txt ]; then
    	for service in $(cat myservices.txt); do
            	systemctl status $service | grep --quiet "running"
            	if [ $? -eq 0 ]; then
                    	echo $service "is [ACTIVE]"
            	else
                    	echo $service "is [INACTIVE or NOT INSTALLED]"
            	fi
    	done
else
    	echo "myservices.txt is missing"
fi
Hacer ping a una serie de hosts de red o internet para obtener estadísticas de respuesta

Es posible que desee mantener una lista de hosts en un archivo de texto y usar una secuencia de comandos para determinar de vez en cuando si se pueden hacer ping o no (no dude en reemplazar el contenido de myhosts e inténtelo usted mismo).

El comando incorporado read shell le dice al ciclo while que lea myhosts línea por línea y asigna el contenido de cada línea al host variable, que luego se pasa al comando ping .

#!/bin/bash

# This script is used to demonstrate the use of a while loop

while read host; do
    	ping -c 2 $host
done < myhosts

Script para servidores de ping

Solución de problemas del sistema de archivos

Aunque Linux es un sistema operativo muy estable, si falla por algún motivo (por ejemplo, debido a un corte de energía), uno (o más) de sus sistemas de archivos no se desmontará correctamente y, por lo tanto, se verificará automáticamente si hay errores se reinicia

Además, cada vez que el sistema arranca durante un arranque normal, siempre verifica la integridad de los sistemas de archivos antes de montarlos. En ambos casos, esto se realiza utilizando una herramienta llamada fsck (" verificación del sistema de archivos ").

fsck no solo verificará la integridad de los sistemas de archivos, sino que también intentará reparar los sistemas de archivos corruptos si se le indica que lo haga. Dependiendo de la gravedad del daño, fsck puede tener éxito o no; cuando lo hace, las partes recuperadas de los archivos se colocan en el directorio perdido + encontrado , ubicado en la raíz de cada sistema de archivos.

Por último, pero no menos importante, debemos tener en cuenta que las inconsistencias también pueden ocurrir si intentamos extraer una unidad USB cuando el sistema operativo todavía está escribiendo en ella, e incluso puede provocar daños en el hardware.

La sintaxis básica de fsck es la siguiente:

# fsck [options] filesystem
Verificación de errores en un sistema de archivos e intento de reparación automática

Para verificar un sistema de archivos con fsck, primero debemos desmontarlo.

# mount | grep sdg1
# umount /mnt
# fsck -y /dev/sdg1

Verificar errores del sistema de archivos

Además del indicador -y , podemos usar la opción -a para reparar automáticamente los sistemas de archivos sin hacer preguntas, y forzar la verificación incluso cuando el sistema de archivos se ve limpio.

 # fsck -af /dev/sdg1

Si solo estamos interesados ​​en descubrir qué está mal (sin intentar arreglar nada por el momento), podemos ejecutar fsck con la opción -n , que generará los problemas del sistema de archivos en la salida estándar.

 # fsck -n /dev/sdg1

Dependiendo de los mensajes de error en la salida de fsck, sabremos si podemos intentar resolver el problema nosotros mismos o escalarlo a los equipos de ingeniería para realizar más comprobaciones en el hardware.

Fin del Artículo.

Por razones obvias, no es posible cubrir todos los aspectos de estos temas en un solo tutorial, y es por eso que esperamos que estos artículos lo hayan colocado en el camino correcto para probar cosas nuevas usted mismo y continuar aprendiendo.

Si tiene alguna pregunta o comentario, siempre son bienvenidos, así que no dude en enviarnos una línea a través del siguiente formulario.

Pin It

Escribir un comentario


Código de seguridad
Refescar



Redes:



 

Suscribete / Newsletter

Suscribete a nuestras Newsletter y periódicamente recibirás un resumen de las noticias publicadas.

Donar a LinuxParty

Probablemente te niegues, pero.. ¿Podrías ayudarnos con una donación?


Tutorial de Linux

Nos obligan a moslestarte con la obviedad de que este sitio utiliza Cookies. Ver política