ADMINISTRADOR LINUX Capítulo 06

(1)

(2)

Capítulo 06:

SHELL SCRIPTING

ÍNDICE

Shell Script

4

Empezando

5

Comando “echo”

6

Variables

7

Manejo de entradas y salidas

8

Variables predefinidas

9

Argumentos

9

Expresiones

11

Estructuras de control

12

Estructuras de decisión

13

Estructura de bucle

15

Funciones

16

Variables locales a la función

17

Ejercicios

18

Ejercicio N° 1

18

Ejercicio N° 2

19

Ejercicio N° 3

20

Ejercicio N° 4

21

Ejercicio N° 5

23

Ejercicio N° 6

24

Ejercicio N° 7

25

Ejercicio N° 8

26

Ejercicio N° 9

26

Ejercicio N° 10

27

Ejercicio N° 11

29

Ejercicio N° 12

29

Ejercicio N° 13

30

Ejercicio N° 14

31

(3)

Ejercicio N° 15

31

Ejercicio N° 16

32

Ejercicio N° 17

33

Ejercicio N° 18

34

Ejercicio N° 19

34

Ejercicio N° 20

35

Ejercicio N° 21

36

Ejercicio N° 22

36

Ejercicio N° 23

37

Ejercicio N° 24

39

Ejercicio N° 25

41

Suscribite a nuestro Facebook:

www.facebook.com/carreralinuxar

Suscribite a nuestro Blog:

blog.carreralinux.com.ar

Suscribite a nuestro Twitter:

twitter.com/CarreraLinuxAr

(4)

Capítulo 06:

SHELL SCRIPTING

Shell Script

Un shell script es un grupo de comandos, funciones y variables. Los shells scripts tienen la misma sintaxis de varios lenguajes de programación y son capaces de manejar las mismas tareas.

Hay dos tipos de scripts: los basados en bourne shell y los derivados de C.

A estos programas tenemos que escribirlos en un archivo de texto al que se le otorgamos luego permisos de ejecución. Una vez realizado este proceso podemos escribir en la terminal el nombre del archivo anteponiendo “./” y éste se ejecutará como un comando en el sistema.

Para escribir nuestros programas en shell usaremos cualquier clase de editor de texto, por ejemplo: Vi, nano o cualquier otro con el cuál estemos familiarizados.

En teoría un shell script es una forma de agrupar secuencias de comandos que corren sin necesidad de que los escribamos en el prompt. En la realidad pueden ser tan com-plejos como cualquier programa ejecutable.

Suscribite a nuestro Blog:

blog.carreralinux.com.ar

(5)

Empezando

Nuestro script debe comenzar con la siguiente línea conocida como sheabang:

#!/bin/bash

Los caracteres #! le indican al sistema que el primer argumento que sigue en la línea es

el interprete de comandos a utilizar para ejecutar este script. En este caso usamos el

shell /bin/bash. Esto quiere decir que se invocará al shell bash para interpretar estos

comandos y ejecutarlos, esta linea es importante ya que si compartimos este progra-ma con otro usuario y este no usa bash vamos a tener la certeza que la lógica va a ser interpretada con el shell adecuado en este ejemplo bash.

Otros intérpretes (o lenguajes interpretados) que nos podemos encontrar son php, python o perl. Si sucede que se encuentran con uno de estos tipos de script, notarán

que el sheabang empieza con, por ejemplo: #!/usr/bin/perl

Volviendo a bash, luego de esta línea escribiremos los comandos que queremos que ejecute nuestro script. ¡En breve veremos todo!

Una vez que el script ha sido terminado y guardado, tenemos que hacerlo ejecutable para poder correrlo. Para lograr esto en el sistema escribiremos el siguiente comando en la consola:

# chmod 755 script.sh

Después vamos a poder ejecutar el script escribiendo en la consola lo siguiente: #./script.sh

Recordemos que el ./ servía para reemplazar la ruta.

(6)

Ejemplo 1, sintaxis:

#!/bin/bash clear

echo “Ejecutando el comando ls...” ls /

echo “el comando se ejecuto con éxito!”

¿Qué hicimos?

1.- Limpiar la pantalla con el comando “clear”. 2.- Usar el comando “echo”.

3.- Ejecutar el comando “ls”. 4.- Ejecutar el comando “echo”.

Comando “echo”

Este comando permite imprimir caracteres en la terminal.

Si ejecutamos el siguiente comando; echo “hola”, él imprime en pantalla hola. # echo hola

hola

Para imprimir, por ejemplo un sonido, debemos usar el parámetro -e después de echo para poder tomar los caracteres de escape de bash.

# echo -e “\a” hola hola

Para colocar colores a los textos podemos usar la siguiente sintaxis: equipo1:~# echo -e “\\033[0;31m” hola “\\033[0;39m”; hola

(7)

Estos son algunos de los colores que nos permite usar la terminal: el primero “\\033[0;31m” es el color rojo mientras que “\\033[0;39m” es el gris que usamos en

el prompt.

Variables

La asignación de variables se realiza simplemente indicando su nombre, un signo =, y

el valor, como en el siguiente ejemplo:

NOMBRE=”Luis”

El valor de una variable se toma anteponiendo un signo $ al nombre.

Si queremos imprimir en pantalla el valor de la variable nombre, tenemos que escribir en la terminal:

echo $NOMBRE

También podemos imprimir el valor de la variable limitándola con los caracteres “{“ y

“}”, esto nos da mayor libertad cuando la variable es incluida dentro de una cade-na de caracteres.

echo ${NOMBRE}

echo es el comando que nos permite enviar a la salida por pan-talla el valor de la variable pasada como argumento.

Este comando suele utilizarse si queremos testear en pantalla el progreso de un script o si deseamos que el usuario pueda ir ob-teniendo información mientras el script se ejecuta.

(8)

Manejo de entradas y salidas

La entrada/salida puede manejarse con los comandos echo y read. Con ellos el script podrá interactuar con el usuario, recibien-do datos de él y mostranrecibien-do en pantalla re-sultados.

Un ejemplo del uso de estos comandos sería el siguiente: #!/bin/bash

clear

echo -n “Por favor introduzca su nombre: “ read NOMBRE

echo -n “Introduzca ahora su apellido: “ read APELLIDO

echo -e “Bienvenido a Instituto Linux\\033[0;32m” ${NOMBRE} ${APE-LLIDO} “\\033[0;38m”

¿Qué hicimos?

1.- Borramos la pantalla

2.- Preguntamos el nombre del usuario

3.- Preguntamos el apellido

4.- Imprimimos el nombre y el apellido en color verde

También podríamos haber usado: read -p “Ingrese su apellido: “ APELLIDO

Suscribite a nuestro Twitter:

twitter.com/CarreraLinuxAr

(9)

Variables predefinidas

Veamos las variables ya definidas por el shell que podremos usar en nuestros scripts.

Descripción Variable

Número de argumentos $#

Todos los argumentos del Shell $*

Opciones suministradas al Shell

$-Valor de retorno del último comando ejecutado $?

Identificación del PID (número de proceso) $$

Argumentos

Los argumentos sirven para pasarle a un pro-grama o una función valores desde la línea de comando.

Sólo podemos pasar nueve argumentos.

Si por algún motivo queremos usar más de nueve lo vamos a poder hacer de la si-guiente forma: con el comando shift borramos el argumento N°1 transformando al

que hasta este momento era el N°2 en N°1, y así sucesivamente hasta que el N°9 se transforma en N°8 y deja uno libre para ser usado.

Como veremos en la tabla siguiente, si queremos hacer mención a todos los argu-mentos introducidos por pantalla podríamos hacer uso de la variable $*.

Si queremos indicar que debe utilizarse el primer argumento pasado tendremos que usar la variable $1, y así sucesivamente según el argumento que deseemos utilizar en nuestro script.

(10)

Significado Variable

Todos los argumentos $*

Cantidad de argumentos $#

Nombre del script $0

Primer argumento $1

Segundo argumento $2

Argumento ‘enésimo’ $n

Probemos con este ejemplo: #!/bin/sh

#

# Programa que recibe argumentos y los imprime por pantalla # echo “\$*: $*” echo “\$#: $#” echo “\$0: $0” echo “\$1: $1” echo “\$2: $2”

En la líneas de impresión (echo), para imprimir el símbolo “$” (pesos) se tiene que anteponer el símbolo “\” (contra barra), de lo contrario el shell lo va a interpretar como una varia-ble, y si ésta existe imprimirá su contenido.

Los argumentos que se pasan en el momento de invocar el script se asignan a las variables automáticas $1, $2, $3, etc...

Ejecución:

# ./script perro gato loro

$1 vale perro, $2 vale gato, $3 vale loro.

Suscribite a nuestro Blog:

blog.carreralinux.com.ar

(11)

En ocasiones se desea asignar a una variable el valor obtenido mediante la ejecución de otro comando. Esto se logra encerrando el comando entre $(comando) como

podemos ver en este nuevo ejemplo: horaydia=$(date)

Otras variables automáticas son $0 que contiene el nombre del script, y $# que

con-tiene la cantidad de argumentos ingresados durante la ejecución del script.

Expresiones

Como en cualquier lenguaje de programación, podemos evaluar expresiones y hacer depen-der de dicha evaluación la ejecución de un comando o secuencias de comandos.

El comando test devuelve verdadero o falso como resultado (usualmente se utiliza

con el comando if):

test “$nombre” = “Luis” (chequea igualdad)

Si deseamos chequear desigualdad debemos usar el operador != como en C:

test “$nombre” != “Carlos” (chequea desigualdad) Veamos otras opciones posibles:

· test $variable: chequea si la variable contiene algún dato, en cuyo caso devuelve verdadero.

· test -z $variable: chequea si la variable no contiene datos (longitud cero), en cuyo caso devuelve verdadero.

· test $VARIABLE1 -eq $VARIABLE2: chequea igualdad entre variables numéricas enteras, si son iguales devuelve verdadero.

· test $VARIABLE1 -ge $VARIABLE2: chequea si el primer valor es mayor o igual que el segundo, en cuyo caso devuelve verdadero.

· test $VARIABLE1 -gt $VARIABLE2: chequea si el primer valor es mayor que el se-gundo, en cuyo caso devuelve verdadero.

(12)

· test $VARIABLE1 -le $VARIABLE2: chequea si el primer valor es menor o igual que el segundo, en cuyo caso devuelve verdadero.

· test $VARIABLE1 -lt $VARIABLE2: chequea si el primer valor es menor que el se-gundo, en cuyo caso devuelve verdadero.

· test $VARIABLE1 -ne $VARIABLE2: chequea que los dos valores no sean iguales, en cuyo caso devuelve verdadero.

· test $archivo1 -nt $archivo2: chequea las fechas de modificación de dos archivos, devolviendo verdadero si el archivo1 es más nuevo que el archivo2.

· test -f $archivo: chequea si el archivo existe, en caso afirmativo devuelve verdadero.

· test -d $archivo: chequea si el archivo en cuestión es un directorio y si existe, en cuyo caso devuelve verdadero.

· test -r $archivo: chequea si tenemos permiso de lectura sobre el archivo, devolvien-do verdadero en caso afirmativo.

· test -w $archivo: chequea si tenemos permiso de escritura sobre el archivo, devol-viendo verdadero en caso afirmativo.

· test -x $archivo: chequea si tenemos permiso de ejecución sobre el archivo, devol-viendo verdadero en caso afirmativo.

· test -b $archivo: chequea si el archivo es un block device, devolviendo verdadero en caso afirmativo.

· test -c $archivo: chequea si el archivo es un character device, devolviendo verda-dero en caso afirmativo.

Estructuras de control

Dentro de las estructuras de control encontramos dos categorías:

· Estructuras de decisión

· Estructuras de bucle

(13)

Estructuras de decisión

Son las que nos permiten decidir por un camino entre dos ó más posibles dada una condición. Si la condición se evalúa como verdadera, se cumplirá el camino inmediato de secuencias, en caso de ser evaluada la condición como falsa, se ejecutará el bloque de secuencias alternativas.

Entre estas estructuras veremos dos, if y case:

if ... then ... else ... fi

Esta instrucción usa el status del último comando y condicionalmente ejecuta la si-guiente instrucción.

La sintaxis general es la siguiente:

if test then comandos else comandos fi Ejemplo: #!/bin/bash

echo -n Ingrese estado del tiempo: read tiempo

if [ $tiempo = lluvia ] then

echo $llueve else

echo lindo dia!!!! fi

(14)

Hay dos estructuras que permiten ejecutar un código si algo inmediatamente anterior ha ido bien, o lo contrario, ejecutarlo sólo si lo anterior ha ido mal.

&& (Permite un if...then rápido)

En realidad es un AND lógico.

test “$nombre” = “Luis” && echo “Hola Luis!”

Similar al anterior pero para el caso falso, en realidad es un XOR lógico.

test “$nombre” = “Luis” || echo “Ud. no es Luis!”

La forma de recordar qué produce cada estructura, es tener bien en claro que el shell sólo va a ejecutar lo estrictamente necesario para saber cómo termina la condición.

case .. in ... esac

Esta estructura evalúa el valor de una variable y ejecuta varias instrucciones en fun-ción de su valor. Es similar a usar varios “ifs” anidados. Si la variable no es igual a ninguno de los valores se ejecutan las instrucciones especificadas en el asterisco.

#!/bin/bash

echo -n Ingrese estado del tiempo: read ESTADO

case $ESTADO in lluvia)

echo llevar paraguas;; sol)

echo hoy esta lindo;; *)

echo Es un dia variable;; esac

(15)

Estructura de Bucle

Estas estructuras se utilizan para ejecutar un bloque de instrucciones un número dado ó un número de veces hasta que la condición se cumpla. Llamaremos bucle o ciclo a todo

proceso que se repite un cierto número de veces dentro de un script ó programa.

Dentro de estas estructuras encontramos while, until y for. while .. do ... done while do ... done while sleep 3 do

echo hola mundo. done until .. do ... done until do ... done until sleep 3 do

echo pasaron 3 segundos. done

(16)

La instrucción break termina la ejecución del bucle ocasionando la ejecución de la

instrucción done más cercana.

for .. in ... do ... done

Es otra de las estructuras importantes, presenta el for más o menos tradicional, es decir, dar un nombre de una variable y los valores por los que tiene que pasar:

for i in `ls /` do

file $i done

Funciones

Las funciones son un recurso esencial para la buena programación. Permiten escribir una sola vez una porción de código que se repita varias veces, y así lograr minimizar el margen de error y también la cantidad de líneas codificadas en el programa.

Para utilizarlas simplemente tendremos que hacer un llamado a la función. Las fun-ciones pueden estar dentro del mismo shell script, o en un archivo aparte.

Cuando se escriben las funciones en un archivo aparte, es muy importante utilizar el comando “.” (punto) para cargarlas en memoria. Si no se cargan en memoria de esta manera, las fun-ciones no estarán disponibles.

Suscribite a nuestro Twitter:

twitter.com/CarreraLinuxAr

(17)

Escribir la función en el archivo /root/funciones/arch.sh

#

# Funciones para manipulación de archivos #

evaluar() {

# A partir de aquí empieza la función file $1

#Termina la función }

Cuerpo principal del programa llamafuncion.sh

#

# Cargando las funciones en memoria # (Hay un espacio despues del .) . /root/funciones/func.sh for i in `ls /` do evaluar ${i} done Ejecución: # ./llamafuncion.sh

Variables locales a la función

Existe la posibilidad de utilizar variables locales a la función, esto significa que la variable solamente va a existir durante la ejecución de la función.

Para crear una variable local a la función se utiliza el operador “local <nombre_de_ variable>”.

(18)

Veamos como incluimos esta opción en una función: func () {

local x x=$1

echo “Dentro de la función \$x vale ($x)” }

echo “Antes de ejecutar la función \$x vale (${x})” func HOLA!!

echo “Después de ejecutar la función \$x vale (${x})”

Ejercicios

EJERCICIO N° 1

Limpia la pantalla y escribe hola. Pasos a seguir:

Abrimos un editor y tipiamos lo siguiente: #!/bin/bash

clear echo hola

Recordemos que en la primera línea siempre tenemos que incluir el intérprete al cuál se invocará para leer el archivo y ejecutar los comandos. Si olvidamos esta línea nuestros scripts no funcionarán. Guardamos los datos y nombramos al archivo como uno.sh. Le otorgamos permisos de ejecución y lo ejecutamos tipiando en la consola:

#./uno.sh

Veremos que después de ejecutarlo se escribe hola en la pantalla limpia.

01

02

(19)

EJERCICIO N° 2

Limpia la pantalla y escribe en ella los parámetros pasados cómo argumentos por el usuario. Veamos cómo crearlo:

Paso a paso:

En otro archivo llamado dos.sh tipiamos lo que detallamos a continuación: #!/bin/bash

clear

echo $1 $2 $3

Veamos en detalle la tercera línea de este ejemplo: echo $1 $2 $3

Como vimos en el ejemplo anterior el comando echo imprime por pantalla las variables $1 $2 $3 que corresponden a los tres primeros argumentos que el usuario escribe por pantalla al ejecutar el script.

Veamos cómo funciona exactamente: equipo1:~#./dos.sh hola como estas

Aquí hemos indicado que ejecute el script con la orden ./dos.sh y luego le hemos

pasado tres argumentos que serán tomados como variables de la siguiente forma:

· el primer argumento “hola” será la variable identificada como $1.

· el segundo argumento “como” será tomado como la variable $2.

· y el tercer argumento “estas” será de ahora en adelante la variable $3.

Al ejecutarlo escribirá en la pantalla lo siguiente: hola como estas

01

02

03

04 Suscribite a nuestro Blog:

blog.carreralinux.com.ar

(20)

EJERCICIO N° 3

En este ejemplo veremos cómo los parámetros pasados como argumentos al mo-mento de ejecutar el script son tomados como nuevas variables.

Abrimos un nuevo archivo de texto y lo llamamos tres.sh. En él escribiremos

lo siguiente: #!/bin/bash clear VARIABLE1=$1 VARIABLE2=$2 VARIABLE3=$3

echo Ud. Ingreso $VARIABLE1 read VARIABLE1

echo -n

Como podemos darnos cuenta, lo primero que hará este script al igual que los otros es limpiar la pantalla.

Al agregar en nuestro script las siguientes tres líneas: VARIABLE1=$1

VARIABLE2=$2 VARIABLE3=$3

...estamos indicando que los parámetros introducidos pasarán a formar parte de nue-vas variables llamadas: VARIABLE1, VARIABLE2 y VARIABLE3.

01

(21)

Estas variables serán utilizadas en el script de la siguiente forma: echo Ud. Ingreso $VARIABLE1

read VARIABLE1

echo -n

Si ejecutamos este script en pantalla de la siguiente forma: equipo1:~# ./tres.sh hola como estas

...escribirá por pantalla: Ud. Ingreso hola Ud. Ingreso como Ud. Ingreso estas

EJERCICIO N° 4

Este script es igual al anterior en cuanto a su escritura pero variará en la forma en la cual lo ejecutaremos. En el ejemplo anterior testeamos el script escribiendo ./tres. sh hola como estas, siendo estás tres palabras los parámetros pasados al script y

ejecutados como variables $1, $2, $3.

Veamos ahora qué sucede si no introducimos ningún parámetro al momento de la ejecución: #!/bin/bash clear VARIABLE1=$1 VARIABLE2=$2 VARIABLE3=$3

echo “Ingrese primer variable: “ read VARIABLE1

echo “Ingrese segunda variable: “ read VARIABLE2

(22)

echo “Ingrese tercer variable: “ read VARIABLE3

echo -n

Ejecución:

Veremos como la pantalla se limpia y el programa imprime en pantalla Ingrese primer variable.

En este momento tipiaremos hola, por ejemplo.

A continuación el script guardará el valor ingresado como $VARIABLE1 e

im-primirá en pantalla Ingrese segunda variable.

Tipiaremos cualquier palabra que se nos ocurra y será almacenada como $VA-RIABLE2.

Lo mismo haremos con la tercera variable. Una vez que nos haya pedido todos los valores, el script escribirá cada uno de los parámetros que hemos ingresado.

01

02

03

04

05 Suscribite a nuestro Twitter:

twitter.com/CarreraLinuxAr

Suscribite a nuestro Blog:

blog.carreralinux.com.ar

(23)

EJERCICIO N° 5

A partir de este ejercicio comenzaremos a utilizar ciclos condicionales sencillos. En este ejemplo se evaluará si el usuario ingresado es Luis. Si esta condición es cumplida el programa escribirá por pantalla “Bienvenido Luis”; si la condición no se cumpliera se imprimirá en pantalla usuario no valido.

#!/bin/bash

read -p “Ingrese nombre de usuario: “ USUARIO if [ ${USUARIO} = “Luis” ] ; then

echo Bienvenido ${USUARIO} else

echo Usuario no valido. fi

Ejecución:

Guardemos el archivo como cinco.sh, otorguémosle como hasta ahora

permi-sos de ejecución y probemos cómo funciona: #./cinco.sh

Nos devolverá “Bienvenido Luis” si el usuario ingresado es Luis y “Usuario no valido” cuando sea cualquier otro.

01

02 Suscribite a nuestro Blog:

blog.carreralinux.com.ar

Suscribite a nuestro Twitter:

twitter.com/CarreraLinuxAr

(24)

EJERCICIO N° 6

Al ejecutar este script se nos pedirá que ingresemos dos números. Una vez que lo ha-yamos hecho nuestro script nos dirá si son iguales. Si no lo son nos dirá si el número uno es mayor o menor que el número dos. Una vez que nos brinde esta información los sumará y nos dará el resultado total.

Veamos cómo es su sintaxis: #!/bin/bash

clear

read -p “Ingrese un numero : “ NUM1 read -p “Ingrese numero: “ NUM2 if [ $NUM1 -eq ${NUM2} ] ; then echo los numeros son iguales.

elif [ ${NUM1} -gt ${NUM2} ] ; then echo ${NUM1} \> ${NUM2}

else

echo ${NUM1} \< ${NUM2} fi

SUMA=$[${NUM1} + ${NUM2}]

echo ${NUM1} \+ ${NUM2} \= ${SUMA}

Ejecución: Ingrese un numero: 4 Ingrese numero: 5 4 < 5 4 + 5 = 9

01

02

(25)

EJERCICIO N° 7

Este script es de mucha utilidad para el Administrador de la red ya que nos permite sa-ber si un servicio está corriendo al momento de la ejecución. Podemos usar cualquie-ra de los servicios que estén en el directorio /etc/init.d. Probemos con el servicio ssh.

#!/bin/bash clear

read -p “Ingrese el nombre de un servicio: “ SERVICIO if ps aux | grep -v grep | grep ${SERVICIO}

then

echo “el servicio ${SERVICIO} esta corriendo” else

echo “el servicio ${SERVICIO} no esta corriendo” fi

Ejecución:

Guardemos este archivo como siete.sh y otorguémosle permisos de

ejecu-ción.

# ./siete.sh

Ingrese el nombre de un servicio ssh

root 953 0.0 0.4 3648 580 ? Ss Jun05 0:01 /usr/sbin/sshd jose 3078 0.0 0.3 2912 412 ? Ss Jun06 0:00 /usr/bin/ssh-agent x-session-manager

el servicio ssh esta corriendo

Probemos ahora el funcionamiento de este script con los otros servicios lista-dos.

01

02

03 Suscribite a nuestro Twitter:

twitter.com/CarreraLinuxAr

(26)

EJERCICIO N° 8

Al usar este script direccionaremos nuevamente la salida en pantalla del servicio a / dev/null para que no sea visible.

Veamos la nueva sintaxis: #!/bin/bash

clear

read -p “Ingrese el nombre de un servicio: “ SERVICIO if ps aux | grep -v grep | grep ${SERVICIO} > /dev/null then

echo el servicio ${SERVICIO} esta corriendo. else

echo el servicio ${SERVICIO} no esta corriendo. fi

Ejecución:

Guardémoslo como ocho.sh y ejecutémoslo para testearlo en pantalla.

casa:~# ./ocho.sh

Ingrese el nombre de un servicio ssh.

el servicio ssh esta corriendo.

EJERCICIO N° 9

Vamos a agregarle un poco más de complejidad al script anterior. Supongamos que queremos testear si un servicio está corriendo y deseamos que el resultado no se imprima en pantalla sino que se envíe por correo electrónico (mail) como un reporte.

01

02 Suscribite a nuestro Blog:

blog.carreralinux.com.ar

(27)

Veamos cómo sería la nueva sintaxis: #!/bin/bash

clear

read -p “Ingrese el nombre de un servicio: “ SERVICIO if ps aux | grep -v grep | grep ${SERVICIO} > /dev/null then

echo “el servicio ${SERVICIO} esta corriendo” > serv else

echo “el servicio ${SERVICIO} no esta corriendo” > serv fi

mail root@localhost -s “Estado del servicio ${SERVICIO}” < serv Como podemos observar en vez de imprimirse por pantalla se di-recciona nuevamente la salida a un archivo de texto que luego será el cuerpo de un mail a enviar al usuario root.

Podremos crear este script y ejecutarlo de modo automático cada hora y mantener-nos así permanentemente actualizados sobre el estado de los servicios del sistema.

EJERCICIO N° 10

En este ejemplo veremos como if puede usarse para realizar testeos en nuestro

Sis-tema. En este caso testeará si el parámetro ingresado es: un link, un directorio ó un archivo.

#!/bin/bash clear

if [ -z $1 ] ; then

echo debe ingresar un parametro. elif [ -L $1 ]; then

echo el parametro $1 es un link. elif [ -d $1 ] ; then

echo el parametro $1 es un directorio. elif [ -f $1 ]; then

(28)

echo el parametro $1 es un archivo. else

echo el parametro $1 no es un link. echo el parametro $1 no es un directorio echo el parametro $1 no es un archivo. fi

Ejecución:

Vamos a pasarle un archivo como parámetro: equipo1:~#./diez.sh ocho.sh

Si no ingresamos ningún parámetro sucederá lo siguiente: equipo1:~#./diez.sh

Debe ingresar un parámetro.

¿Qué sucede si el parámetro ingresado no cumple ninguna de las condiciones?

equipo1:~#./diez.sh hola

el parametro hola no es un link. el parametro hola no es un directorio el parametro hola no es un archivo.

01

02

03 Suscribite a nuestro Twitter:

twitter.com/CarreraLinuxAr

Suscribite a nuestro Blog:

blog.carreralinux.com.ar

(29)

EJERCICIO N° 11

Este ejemplo es similar al anterior pero en vez de usar “[“ usamos la palabra

reserva-da test

#!/bin/bash

echo “Ingrese valor a testear: “ read archivo

if test -f $archivo then

echo “Esto es un archivo” else

echo “Esto no es un archivo” if

EJERCICIO N° 12

Este script nos va a resultar muy útil ya que crearemos un programita que nos permita:

· crear un archivo

· ponerle nombre y extensión

· otorgarle permisos de ejecución

· escribir la primer línea #!/bin/bash

· abrir por nosotros el vim para que sigamos trabajando. Veamos la sintaxis para lograrlo:

#!/bin/bash

echo -n Ingrese el nombre y la extención del archivo read NOMBRE

EXT=.sh

touch ${NOMBRE}${EXT} chmod 755 ${NOMBRE}${EXT}

echo \#!/bin/bash >> ${NOMBRE}${EXT} vim ${NOMBRE${EXT}

Vamos a guardar este script con el nombre crear scripts.sh, ya que nos servirá para

(30)

EJERCICIO N° 13

En este ejemplo veremos cómo trabaja el ciclo case. Este ciclo como ya hemos visto evalúa una a una la variables y si ninguna de ellas corresponde cumple la condición que está luego del “*”.

En este caso si la variable $nomb no se corresponde con ninguno de los usuarios

ingresados escribirá por pantalla “Usuario no valido” y finalizará el ciclo.

Veamos su sintaxis:

#!/bin/bash

echo -n Ingrese su nombre: read NOMBRE

case ${NOMBRE} in juan)

echo Bienvenido ${NOMBRE} ;; pedro)

echo Bienvenido ${NOMBRE} ;; *)

echo Usuario no valido ;; esac

Suscribite a nuestro Twitter:

twitter.com/CarreraLinuxAr

Suscribite a nuestro Blog:

blog.carreralinux.com.ar

(31)

EJERCICIO N° 14

Este ejemplo es igual que el anterior pero en este caso evaluaremos los meses del año. Veamos su sintaxis:

#!/bin/bash

echo Ingrese Número de mees: read MES

case ${MES} in

echo Este es el mes de ${MES} ;; *)

echo Mes no valido. ;; esac

EJERCICIO N° 15

En este script vamos a crear una calculadora que sume, reste, multiplique y divida. Veamos cómo escribiremos su sintaxis:

#!/bin/bash

read -p “Ingrese primer número: “ N1

read -p “Ingrese operación (+,-,x,/): “ OPER read -p “Ingrese segundo número: “ N2

case $OPER in +) TOTAL=$[$N1 + $N2] echo $N1 \+ $N2 \= $TOTAL;; -) TOTAL=$[$N1 - $N2] echo $N1 \- $N2 \= $TOTAL;; /) if [ $N2 -eq 0 ]; then

(32)

else TOTAL=$[$N1 / $N2] echo $N1 \/ $N2 \= $TOTAL fi ;; x) TOTAL=$[$N1 * $N2] echo $N1 \* $N2 \= $TOTAL;; *)

echo Ingrese una operación valida !!!!!!!!!. ;; esac

Guardemos este archivo como calculadora.sh y probémoslo.

equipo1:~$ ./calculadora.sh Ingrese primer número: 4

Ingrese operación (+,-,x,/): + Ingrese segundo número: 5 4 + 5 = 9

EJERCICIO N° 16

En este ejemplo vamos a trabajar con el ciclo select que nos va a permitir ver un

menú y seleccionar de él la opción que más nos guste. #!/bin/sh

echo “¿Cuál es tu sistema operativo favorito?” select VAR in “RedHat” “SuSe” “Debian” “Otro”; do break

done

echo “Has seleccionado $VAR”

(33)

EJERCICIO N° 17

En este ejemplo vamos a hacer un menú en el cuál podremos seleccionar el número 1 y que se ejecute el comando ls del directorio /, seleccionando 2 saludar al usuario

logueado y seleccionando 3 saldrá. #!/bin/bash

echo -e “\\033[0;32m Este es nuestro menú \\033[0;38m” OPCIONES=”Listar Saludar Salir”

select VAR in $OPCIONES ; do case $VAR in

Listar)

echo Ejecutando ls del directorio / ls /

echo Comando ejecutado. ;;

Saludar)

echo -e Usuario logueado: “\\033[0;32m” $USER “\\033[0;38m” ;;

Salir)

echo -e Saliendo

echo -e Gracias por haber usado el menu exit

;; esac done

Suscribite a nuestro Twitter:

twitter.com/CarreraLinuxAr

Suscribite a nuestro Blog:

blog.carreralinux.com.ar

(34)

EJERCICIO N° 18

En este ejercicio vamos a tratar de escribir en la pantalla diez veces la palabra Linux.

Para eso vamos a ejecutar un comando que se llama “seq 1 10”. Este genera una lista

de números entre 1 y 10.

Una vez generada esta lista se la pasaremos a la variable llamada i. El ciclo for la

re-correrá en toda su extensión. #!/bin/bash

for i in $(seq 1 10) do

echo linux done

echo Acabo de escribir linux 10 veces

EJERCICIO N° 19

El ciclo for guarda en una variable “i” tantas posiciones como líneas devuelva el

co-mando ejecutado y a cada una de esas posiciones les aplica la orden que está dentro de “do” y “done” como ya vimos en el ejemplo anterior.

En este caso le pediremos que liste todo lo que hay en el directorio /tmp y nos diga

uno a uno cuál es el valor que va tomando “i”.

#/bin/bash cd /tmp

for i in $(ls /tmp) do

echo el valor que toma i es = $i done

(35)

Ejecución:

equipo1:~#./veintiuno.sh

el valor que toma i es = backup

el valor que toma i es = comandostipeados.txt el valor que toma i es = comandotipeados.txt el valor que toma i es = dcopcTLd0s

el valor que toma i es = fer1

el valor que toma i es = install.log

el valor que toma i es = install.log.syslog el valor que toma i es = pepe

el valor que toma i es = pepe.txt el valor que toma i es = pp

el valor que toma i es = pp2

el valor que toma i es = session_mm.sem el valor que toma i es = sql.txt

el valor que toma i es = v839400

el valor que toma i es = webalizer-2.01-10

el valor que toma i es = webalizer-2.01-10-src.tgz el valor que toma i es = xf86config-ZBYsxg-4

EJERCICIO N° 20

En el siguiente ejemplo se buscará saber cuáles de los servicios del sistema operativo están activos. La información obtenida será enviada a root por email.

Sintaxis:

#!/bin/bash cd /etc/init.d

for i in $(ls /etc/init.d) do

if ps aux | grep -v grep |grep $i >/dev/null then

(36)

else

echo $i CAIDO >> mail.txt fi

done

mail root@localhost -s “Estado de los Servicios” < mail.txt

EJERCICIO N° 21

En este ejercicio vamos a pedirle al usuario que ingrese una letra. Si la letra que in-gresa es distinta a s le escribiremos hola en la pantalla. Si por el contrario, ingresa la

letra s le diremos que salió del ciclo.

#!/bin/bash clear

read -p “Ingrese una letra: “ LETRA while [ $LETRA != s ]

do

echo -e “\n” hola la letra ingresada es $LETRA read -p “Ingrese una letra : “ LETRA

clear done

echo Ud. Salio del ciclo porque presiono $LETRA

EJERCICIO N° 22

Veamos otro ejemplo. Se ejecuta un ls del directorio “/”. Como al hacerlo estaremos un buen rato esperando, colocaremos una condición para que termine el ciclo en un momento dado. En este caso usaremos un contador en 0 y cuando llegue a 3 saldre-mos del script.

#!/bin/bash clear

CONTADOR=0

(37)

do

echo -e Voy a ejecutar el comando ls del directorio / ls /

CONTADOR=$[$CONTADOR + 1] done

echo Se ejecuto el comando ls $CONTADOR veces

EJERCICIO N° 23

En este ejemplo vamos a modificar un script que ya realizamos para hacerlo más efi-ciente. Supongamos que queremos crear un archivo, pero queremos que el usuario tenga la libertad de llamarlo como lo desee. Nosotros de todas formas seremos quie-nes le otorguemos la extensión “.sh”, escribiremos dentro “#!/bin/bash” y abriremos

el archivo con el comando vim.

Es importante que anticipemos en nuestro script que exista un archivo con el nombre que el usuario le ha otorgado y por lo tanto le daremos la oportunidad de abrirlo pre-sionando la letra s ó de salir del ciclo presionando la letra n.

#!/bin/bash clear

read -p “Ingrese un nombre para el archivo a crear: “ ARCH if [ -z $ARCH ]; then

echo Alerta!

echo El nombre no puede estar vacio. else

EXT=.sh

NARCH=${ARCH}${EXT}

if [ -f $NARCH ]; then

echo El archivo $NARCH EXISTE

echo -n Abrirlo de todas formas $s\/n$

read OP

if [ $OP = s ] ; then

vim $NARCH

(38)

elif [ $OP = n ] ; then

exit else

while ( [ $OP != s ] || [ $OP != n ]) do

echo -n Debe ingresar $s\/n$:

read OP case $OP in s) vim $NARCH exit;; n) exit ;; *)

echo Operacion no valida;; esac

done fi

else

echo \#!/bin/bash > $NARCH chmod 711 $NARCH

vim $NARCH

fi

Suscribite a nuestro Twitter:

twitter.com/CarreraLinuxAr

Suscribite a nuestro Blog:

blog.carreralinux.com.ar

(39)

EJERCICIO N° 24

Veamos un ejemplo del ciclo until.

La condición se evalúa al principio y ni bien coincide es-cribe por pantalla y sale del ciclo. Si no coincide continúa evaluando cada 7 segundos hasta que es verdadera.

Sintaxis:

#/bin/bash

until who | grep prueba do

sleep 7

echo Entro en sesion done

Funciones:

Las funciones son archivos que contienen sintaxis de script pero que se reutilizan muchas veces en diferentes programas.

Si el archivo tiene sólo un script se lo llama función, si tiene más de uno se lo denomina librería.

Ahora vamos a escribir una función en un archivo al que llamaremos funcion1.

Dentro de este archivo estará el código que después se transformará en la función llamada testear:

testear () { clear

if [ -z $1 ] ; then

echo debe ingresar un parametro. elif [ -L $1 ]; then

echo el parametro $1 es un link. elif [ -d $1 ] ; then

(40)

elif [ -f $1 ]; then

echo el parametro $1 es un archivo. else

echo el parametro $1 no es un link. echo el parametro $1 no es un directorio echo el parametro $1 no es un archivo. fi

}

Observemos que el nombre de la función va seguido de un doble paréntesis y después de una {. Cuando la función termina es necesario que cerremos la llave }.

Sigamos ahora con un script que cargará primero en memoria el archivo llamado fun-cion1 y luego aplicará la función testear a la variable “i” del ciclo for.

Sintaxis: #!/bin/bash . /root/funcion1 cd /tmp for i in `ls /tmp` do testear $i done

Prestemos atención a la primera línea del script. Hay un “.” seguido de un espacio; esto hace que se cargue el archivo

funcion1 en memoria y después se le aplica testear a la va-riable $i.

(41)

EJERCICIO N° 25

En este ejemplo realizaremos un backup del directorio /home. Lo guardaremos en /tmp con el nombre back-fecha-home.tar.gz.

Sintaxis:

#!/bin/bash

tar czvf /tmp/back-`date +%d-%m-%y`-home.tar.gz /home echo Listo el backup.

No deje de preguntarle a su tutor cualquier duda asociada a este tema. Es realmente un tema central en el trabajo del administra-dor de redes, ya que facilita su trabajo y reduce los tiempos de ejecución.