Scripting en Linux (I): Introducción.

Descubre
el Poder de Automatizar Tareas
Muy buenas lector, soy Mariona, nueva colaboradora en ComputerNewAge. Este es un primer post
de introducción al scripting en GNU/Linux, una área nueva que aún no se ha abordado en este
blog, y que te dotará de un poder enorme a la hora de ejecutar tareas en el sistema de forma
totalmente automatizada.
Ésta es la guía de iniciación, en la que introduciré los conceptos más básicos y te presentaré un
ejemplo rápido para que veas la mecánica. En próximos posts profundizaré mucho más en la
construcción de scripts, de forma que aprendas a crear los tuyos propios de acuerdo a tus
necesidades. Vamos!
Anuncios

Object 1

Report this ad
Tabla de Contenidos:
1. Qué es el scripting
2. Ventajas de utilizar scripts
3. Bash scripting
4. Python scripting
5. Cuándo utilizar Bash
6. Cuándo utilizar Python
7. ¡Empieza a automatizar tareas con tus propios scripts!

Qué es el Scripting
Un script es un programa escrito para un entorno en tiempo de ejecución (run-time
environment), con el objetivo de automatizar la ejecución de una o varias tareas.
El primer lenguaje de scripting se remonta a los años 60. En aquella época los llamaban “job control
languajes” o lenguajes de control de tareas. Y es que los scripts eran simplemente una lista de
comandos para ahorrar a las personas tener que introducirlos manualmente cada vez que querían
realizar una misma tarea.
Cada script se presenta en forma de un documento de texto que contiene una lista de instrucciones
que deben ser ejecutadas. La naturaleza de los scripts nos permite escribirlos y editarlos con un
simple editor de texto, como puede ser Gedit mismo, en el caso de GNU/Linux.
En este sentido, los scripts son diferentes a una aplicación o programa, debido a que estos últimos
suelen ser bastante más complejos. Los scripts son, como digo, más bien un conjunto de
instrucciones que se dan a otros programas más avanzados, para que ejecuten ciertas tareas.
Ventajas de Utilizar Scripts
Los shell scripts son típicamente utilizados para la manipulación de archivos, ejecución de
programas o acciones del sistema, impresión de texto, etc. El objetivo principal, como ya he
comentado, es la automatización de tareas. A continuación te presento algunos ejemplos de
aplicación práctica de los scripts:
• Inicializar una tarea al “boot time” del sistema operativo, de manera que no tengas que
hacerlo tu manualmente.
• Abrir o cerrar múltiples aplicaciones de golpe.
• Analizar patrones en archivos de texto, extraer información, etc.

Los scripts también forman parte integral de cualquier sistema operativo. GNU/Linux, por ejemplo,
cuenta con multitud de scripts que se ejecutan en el inicio del sistema y que se encargan de hacer
comprobaciones, habilitar servicios, etc.

Bash Scripting
Bash scripting, o Bash/Shell scripting es un conjunto de comandos en la shell, escritos para
completar una determinada tarea. La Shell es una interfaz de programación para acceder al sistema
operativo. Bash, por su parte, es considerado como el lenguaje de comando más destacado de la
shell de Unix, frente a otros como sh, csh, dash, etc.
Si eres relativamente nuevo en el sistema operativo GNU/Linux y aun no estás muy dado al uso de
la terminal, Bash, etc., te recomiendo leer esta guía de introducción del uso de línea de comandos.
Dicho esto, veamos un primer ejemplo de un script rápido para ejecutar en Bash.
El primer paso, es abrir un fichero de texto en blanco. Para ello, puedes utilizar perfectamente la
aplicación nativa que venga en tu distribución. Una vez abierto, escribe esto en la primera línea:
echo "Hola Mundo"

Hecho esto, guarda el archivo como “script-test.sh” y dejalo en una carpeta de la que te acuerdes
luego, como puede ser Documentos.
El siguiente paso es ejecutar el script desde la terminal. Para ello, puedes abrir una ventana de
terminal, y situarte en la carpeta donde has guardado el fichero, indicando su ruta absoluta o
relativa. Si tienes dudas en esto, te recomiendo la lectura de este post. En el caso del ejemplo,
pondríamos esto:
cd Documentos

Una vez estando en el directorio que contiene el fichero, ya puedes ejecutar el script. Para ello,
escribe la siguiente sentencia:
bash script-test.sh

Hecho esto, verás que aparece, como output o salida, la línea de texto que has introducido en el
fichero, justo después de “echo”. Enhorabuena, ya has creado y ejecutado tu primer script!
Como te imaginarás, este script no tiene mucho sentido ni utilidad como tal. Solo se trata de un
primer ejemplo para que veas la mecánica. Más adelante aprenderás mucho más en detalle como
construir scripts con una utilidad real.

Limitaciones de Bash
Hasta aquí todo muy bien, pero llegan las limitaciones. Y es que Bash es un lenguaje de comando,
más que un lenguaje de programación como tal. A veces se abusa de Bash, tratándolo como si de un
lenguaje de programación se tratase, cosa que lleva a problemas como los siguientes:
• La sintaxis puede ser obscura. De acuerdo, si hace mucho que lees este blog, seguramente
estés mas familiarizado. Aún así, la cosa se puede complicar realmente mucho más.
• La única estructura de datos del lenguaje Bash es el string. Es verdad que existen formas de
trabajar los strings, como convertirlos a números para realizar operaciones aritméticas o
manipulaciones de fechas, pero las reglas suelen ser obscuras.
• Desperdicio de recursos. Para escribir determinadas órdenes (por ejemplo, para crear
aplicaciones cliente-servidor) el script se puede complicar mucho. En ese contexto, cuándo
empezamos a tratar Bash como un lenguaje de programación, se desperdician muchos
recursos del sistema.
Todas esas dificultades nos llevan a plantearnos alternativas a la hora de construir según que tipo de
scripts. Es por eso que quiero mencionar una de las alternativas más poderosas que tenemos en ese
sentido: Python.

Python Scripting
Python no es solo un lenguaje de scripting. A diferencia de Bash, es también un lenguaje de
programación de propósito general.
Y es que Python es utilizado en multitud de entornos y contextos, como en el desarrollo web, el data
science, el machine learning o la computación matemática. Su completísima oferta de librerias
constituye una poderosa herramienta para realizar casi cualquier cosa.
Python tiene una capacidad de Unit Testing mucho más robusta que Bash, además de que cuenta
con la propiedad añadida de la portabilidad. De este modo, si trabajas con Python podrás, en gran
medida, utilizar los scripts en diferentes sistemas operativos como Windows, algo que en Bash
estaría limitado a entornos Unix.
 Cuándo Utilizar Bash
La existencia de Python como lenguaje de scripting no tiene porqué desmerecer Bash. Cada uno
tiene sus pros y sus contras.
Bash, por ejemplo, resulta la mejor opción para tareas relacionadas con la administración del
sistema operativo, ya sea hacer comprobaciones periódicas, mover, copiar o renombrar ficheros, etc.
Algunos ejemplos de usos típicos de Bash son las equivalencias de archivos, comparación de
timestamps, ejecución de comandos “on-exit”, procesamiento de líneas de output, etc.
Ahora bien, si lo que queremos es analizar el contenido de archivos o realizar determinadas
operaciones matemáticas, ahí la cosa se complica.

Cuando Usar Python

Una de las principales ventajas de Python frente a Bash son las estructuras de datos. De este modo,
cualquier tarea que requiera el uso de vectores, matrices o diccionarios, está llamando a gritos el uso
de Python.
Otra de las áreas en las que Python se impone es en el user-interface. Python es un excelente
lenguaje para construir servidores locales o aplicaciones cliente servidor, por ejemplo.

Scripting en Linux (II): Bash. Introducción al

Entorno de Bash
Muy buenas. Ahí va el segundo post de la serie de Linux scripting. Si el primero fue básicamente un
artículo de introducción, en el que expliqué que es el scripting, así como las ventajas y desventajas
de los diferentes lenguajes que se utilizan (Bash o Python), ahora toca centrarnos en Bash.
En este post haré una breve introducción a Bash como lenguaje de scripting. Hablaremos más en
detalle del entorno de Bash (variables y funciones), y de los principales archivos de
configuración, donde se define la configuración Bash, tanto a nivel de sistema, como de usuario.
Anuncios

Object 2

Report this ad
Tabla de Contenidos:
1. Bash como lenguaje de scripting
2. El entorno de Bash. Las variables
3. Ficheros de configuración
4. Esto continua
Bash como Lenguaje de Scripting
En un artículo de introducción que hice sobre la terminal de Linux ya hablé bastante sobre Bash
como shell o interfaz de línea de comandos. De hecho, en este sentido es el interprete de
comandos utilizado por defecto en la mayoría de distribuciones GNU/Linux, además de macOS.
Pero, en realidad, Bash es también es un lenguaje interpretado muy utilizado para la creación de
scripts en Linux. Scripts que contienen una serie de instrucciones que se comunicarán con el Bash
para que este ejecute las acciones pertinentes.
Del mismo modo que tu, como usuario, te puedes comunicar con Bash y ordenarle una serie de
instrucciones a través de la terminal, como actualizar el sistema, instalar un paquete, crear un
directorio, y un larguísimo etcétera, con un script puedes ir un paso más allá, ya que
puedes agrupar muchas de esas ordenes en un mismo script, para que se ejecuten de forma
automatizada.
Como se desprende de todo esto, todos (o casi todos) los comandos de Bash que puedes introducir
por consola de forma manual, también los puedes incluir en un script. Esto tiene múltiples ventajas,
no solo de cara a la automatización de tareas, sino por el hecho de poder incluir estructuras
condicionales, bucles, etc.
Los scripts de Bash son de hecho muy utilizados para administradores de sistemas, programadores,
y, en general, para cualquier usuario de GNU/Linux que suela hacer un uso intensivo del sistema.

El Entorno de Bash. Las Variables

El entorno shell en GNU/Linux y Unix consta de un gran conjunto de variables y funciones que
permanecen en segundo plano y almacenan información en la memoria del sistema (las variables) o
especifican ordenes de ejecución en determinadas situaciones (las funciones).
Centrándonos específicamente en las variables. podemos distinguir básicamente entre dos tipos de
variables:
• Variables Globales. Son aquellas que están disponibles de forma global en el sistema, y son
validas y accesibles desde todas las shell.
• Variables Locales. Son aquellas que solo son validas y están disponibles para la shell o
sesión actual. Son útiles para almacenar información más efímera, como puede ser, por
ejemplo, el directorio de trabajo actual

Listar Variables Existentes

Una de las formas más completas para conocer todas las variables y funciones que conforman el
entorno de Bash es a través del comando set. Si lo indicas tal cual, sin ningún argumento, te
ofrecerá un listado con todas las variables del sistema (globales y locales), así como las funciones
que confirman el entorno.
set

Si quieres ver únicamente un listado con las variables, puedes utilizar set con el argumento posix,
para indicar que set debe operar en modo POSIX. Esto excluirá del output el listado de las
funciones.
(set -o posix; set)

Si quieres centrarte en las variables globales, junto con los valores que contienen, puedes utilizar el
comando env o printenv. A diferencia del comando anterior, en este caso solo se listarán las
variables globales.
env

Para imprimir el valor de de una variable, puedes utilizar el comando printenv junto con el nombre
de la variable. En el caso de la variable SHELL, por ejemplo, quedaría así:
printenv SHELL

Por defecto, te imprimirá la ruta de Bash (/bin/bash), ya que es la shell que se utiliza por defecto en
la mayoría de distribuciones GNU/Linux.

Crear Nuevas Variables

A parte de las variables existentes en el entorno por defecto, puedes crear nuevas variables siempre
que lo necesites. Para crear una nueva variable en el entorno interactivo de Bash, tan solo necesitas
abrir una sesión nueva de terminal y teclear el siguiente comando, sustituyendo VAR_EJEMPLO
por el nombre que le quieres dar a tu nueva variable:
VAR_EJEMPLO=valor_ejemplo

Hecho esto, puedes imprimir el valor por consola utilizando el comando echo seguido del nombre
de la variable con el símbolo del dolar delante. Aquí tienes un ejemplo:
echo $VAR_EJEMPLO

Esto te imprimirá el mismo valor que le has asignado en el momento de su creación, es

decir, valor_ejemplo.
Es importante mencionar que todas las variables creados de esta manera se crean como variables
locales. Puedes comprobarlo tu mismo abriendo una nueva sesión de bash, y teclear el mismo
comando que antes:
echo $VAR_EJEMPLO

En este caso, no se imprimirá ningún valor, ya que la variable VAR_EJEMPLO es una variable
local, y, por lo tanto, solo existe en la sesión de shell desde la que ha sido creado.

Ficheros de Configuración
A continuación te presento los principales archivos de configuración que permiten el correcto
funcionamiento del entorno de ejecución de /bin/bash. Los archivos de configuración globales
(comunes a todos los usuarios del sistema) se suelen ubicar dentro del directorio /etc.
Paralelamente, en el directorio /home de cada usuario se encuentran los ficheros de configuración a
nivel particular de cada cuenta de usuario.
etc/profile
Este es el primer fichero que lee el sistema al iniciar el entorno de la shell. Se utiliza para establecer
el perfil del entorno de Bash (y otras shells compatibles) para todos los usuarios del sistema. Al ser
un fichero de configuración global, en un sistema con múltiples usuarios este archivo solo debería
ser editado por el administrador del sistema.
Puedes consultar su contenido con cualquier editor de archivos por consola como puede ser Nano
(aunque también podrías utilizar Gedit, si te es más sencillo). Si utilizas Nano para visualizarlo,
para salir sin guardar cambios debes utilizar la combinación de teclas CTRL-X e indicar, a
continuación, que no deseas guardar los cambios.
nano /etc/profile

El fichero /etc/profile tiene su contrapartida a nivel de usuario en el archivo .profile que se

encuentra en el directorio home de cada usuario.

etc/bash.bashrc
Este fichero no es automáticamente leído por el sistema, sino a partir de la referencia de él que se
incluye en /etc/profile.
Como antes, puedes leer su contenido con el editor de ficheros Nano. Eso si, hay que el nombre
del bash.bashrc es el que se utiliza en Debian, Ubuntu y derivados. En Red Hat y otras
distribuciones, el fichero se denomina simplemente bashrc.
nano /etc/bash.bashrc

Al igual que ocurre antes, el fichero /etc/bash.bashrc también tiene su contrapartida a nivel de cada
usuario. Este es el archivo .bashrc ubicado en la home de cada usuario.

Scripting en Linux (III): Bash. Sintaxis Básica

del Lenguaje
Muy buenas. Ahí va el tercer post de la serie de Linux scripting. Si el primero fue básicamente un
artículo de introducción, en el que expliqué que es el scripting, así como las ventajas y desventajas
de los diferentes lenguajes que se utilizan (Bash o Python), en este segundo post me voy a
introducir lo que sería el scripting con Bash.
Esto es una guía práctica más que teórica. No pretende ser un manual exhaustivo del lenguaje, ya
que solamente cada apartado daría para varios artículos. El propósito es que adquieras las nociones
básicas y aprendas a utilizar las principales estructuras del lenguaje. Al final del artículo te enlazaré
alguna referencia por si quieres profundizar más en la sintaxis del lenguaje.
Anuncios
 Object 3

Report this ad
Tabla de Contenidos:
1. Comentarios
2. Impresión de texto
3. Entrada de texto
4. Variables. Declaración y llamada
5. Condicionales. Sentencias if .. then .. else
6. Bucles. Sentencias for .. do, while .. do
7. Esto continua

Comentarios
Los comentarios son una parte esencial en cualquier pieza de código. Son partes del código que no
se ejecutan. Sirven explicar el código de modo que sea fácilmente entendible para el ojo humano
que lo esté leyendo. Es una buena práctica utilizar comentarios, ya sea para que otras personas que
lo lean sean capaces de entender tu código, o incluso para ti mismo. En Bash puedes crear un
comentario escribiendo el texto que quieres comentar, detrás del símbolo#.
#Esto es un comentario en Bash.
<código>
#Este es otro comentario.

Al añadir # delante de una línea, lo que están haciendo es inhabilitarla para que no pueda ser
ejecutada por el interprete. A parte de para “explicar” el código, esta práctica también la puedes
utilizar para inhabilitar trozos de código que por el motivo que sea, no quieres que se ejecuten en
este momento.

Impresión de Texto
La impresión de texto por pantalla es otro de los clásicos en cualquier lenguaje de programación.
De hecho es por lo que se suele empezar a aprender la sintaxis de cualquier lenguaje de
programación, con el famoso “hola mundo”.
Para imprimir una cadena de texto en Bash, utilizaremos la sentencia echo seguida del texto que
quieres mostrar por pantalla entre comillas. La estructura general del uso de echo es la siguiente:
echo [opciones] [cadena de texto]

Partiendo de esta base teórica, si queremos ir a por el caso más simple, que sería la impresión de
una cadena de texto simple, sin el uso de ninguna opción de por medio, la sentencia quedaría de la
siguiente manera.
echo "Hola mundo"
Si quieres probar con otro ejemplo un poco menos simple, puedes utilizar el parámetro -e como
opción entre la sentencia echo y la cadena de texto. Si esto lo combinas con el uso del carácter \n
dentro de la cadena, conseguirás añadir una nueva línea en la salida del texto. Aquí tienes un
ejemplo:
echo -e "Esto es la primera línea. \nEsto es la segunda línea"

Esto, como digo, se corresponde con dos casos bastante simples. A partir de ahí, esto se puede ir
complicando tanto como quieras, sobretodo si empiezas a meterte con el uso de variables, o a
combinar más opciones opciones. Pero esto ya lo verás más adelante.

Entrada de Texto
Al igual que ocurre con las salidas de texto, también es muy común que en la ejecución del
programa, en algún punto el script requiera la introducción de texto por parte del usuario, por
ejemplo, para asignar el valor de alguna variable.
En Bash, para indicar que debemos parar la ejecución para leer un determinado texto ue introduzca
el usuario, lo más común es utilizar la sentencia read, seguido del nombre de la variable en la cual
quieres que se almacene el texto leído. Primero te muestro el formato general y luego veremos
algún ejemplo simple.
read [opciones] [variable]

Partiendo de esta base teórica, vamos a por un ejemplo simple, sin utilizar ninguna opción
adicional, en la que únicamente pediremos un determinado dato al usuario, y lo almacenaremos en
una variable.
echo "introduce tu edad"
read A

Visto este ejemplo, a continuación verás una variante de este mismo ejemplo, pero utilizando la
opción -p después de read. Esta opción te permitirá introducir el texto de salida informando al
usuario, sin necesidad de utilizar echo.
read -p "introduce tu edad" A

Como ves, en este ejemplo estamos haciendo exactamente lo mismo, pero al combinar la sentencia
con una determinada opción, podemos añadir funcionalidades adicionales.

Variables. Declaración y Llamada

Como cualquier otro lenguaje de programación, Bash también permite el uso de variables. Podemos
distinguir entre dos tipos de variables, las variables globales y las variables locales (o shell
variables).
La diferencia con otros lenguajes es que en Bash no se necesita declarar la variable previamente, ni
tampoco indicar el tipo de valor que tendrá. Para crear un variable, tan solo hay que indicar su
nombre, el operador igual, y el valor que le quieres asignar. Este puede ser un número, un carácter o
un string (cadena de caracteres).
#Crear una nueva variable en Bash
frase = "Este es mi primer script en Bash"
#Crear otra variable
edad = 25

Para llamar una variable, tan solo debes introducir el nombre de la misma, con el símbolo $ al
inicio. Ahora verás como llamar una variable dentro de echo, para que el programa escriba su valor
como salida de texto.
#Imprimir el valor de una variable
echo $frase
#Imprimir el valor de una variable dentro de una frase
echo Tengo $edad años

Esto es uno de los casos más simples. Un poco más adelante verás como llamar una variable dentro
de otro tipo de estructuras más complejas, como condicionales o bucles, para que se ejecute una
determinada pieza de código en función del valor de la misma.

Condicionales. Sentencias if .. then .. else

Las estructuras condicionales, junto con las estructuras de iterativas que verás después, son las
principales estructuras de control de flujo que tenemos en casi todos los lenguajes de programación.
En según que tipo de scripts, es muy común que tengas que utilizarlas.
En el caso de las estructuras condicionales, la más utilizada es el if .. then .. else. El formato general
consiste primero en introducir en una línea la sentencia if seguida de la condición (entre corchetes)
y acabando con ;. A continuación se utiliza el then en una nueva línea, y debajo va el código que se
ejecuta, si se cumple la condición indicada arriba. Se puede incorporar un else (de manera
opcional) junto con el código a ejecutar en caso de que no se cumpla la condición. Para cerrar el
ciclo, terminaremos con un fi.
if [condición];
then
<código>
else
<código>
fi

Esta es el formato general. Partiendo de esa regla, vamos a ver algún ejemplo simple para que te
hagas mejor a la idea. En ese caso, haremos que el usuario adivine entre si en un lanzamiento de
dados, aparece cara o cruz (siendo “cara” la opción correcta definida por el programa).
echo "En un lanzamiento de dados, indica cara o cruz"
read A
if [ $A = "cara" ];
then
echo "Acertaste"
fi

Como ves, este ha sido un ejemplo muy simple, pero la condición, así como el código que se
ejecuta luego, pueden llegar a ser mucho más complejos.
 Bucles. Sentencias for .. do, while .. do
De igual modo que ocurre con las estructuras condicionales, las construcciones de iteración son otro
gran clásico. En este caso hay dos sentencias diferentes que podemos utilizar. Por un lado tenemos
el for .. do, y por otro lado el while .. do.
La sintaxis en ambos casos es simple. Empezando por el for .. do, tenemos primero a la
sentencia for seguida de la condición o rango de ejecución. En una línea aparte se indica la
sentencia do, y justo debajo el código que se ejecutará mientras estemos dentro del rango. Al
finalizar el código de ejecución, se indica la sentencia done en una nueva línea, para cerrar el bucle.
for <condición>
do
<código>
done

Este es formato general de la construcción for .. do.

Scripting en Linux (IV): Bash. Como Crear y

Ejecutar Tu Primer Script
Muy buenas. Ahí va otro post de la serie de Linux Scripting. Ahora que ya conoces más el entorno
de bash, y la sintaxis básica del lenguaje (sino puedes revisar los primeros posts de la serie), en este
post verás como crear y ejecutar tu primer script en Bash.
Como verás, no me centraré tanto en el script como tal (verás ejemplos mucho más completos e
interesantes en próximos artículos), sino en revisar el circuito completo que debes realizar, desde
construir el script en si, establecer los permisos de ejecución, y ejecutarlo de manera manual.
¡Vamos allá!
Anuncios

Object 4

Report this ad
Tabla de Contenidos:
1. Como crear un script en Bash
2. Establecer permisos de ejecución al fichero
3. Ejecutar el script de forma manual
4. Continuación

Como Crear un Script en Bash

Para crear un script en Bash tan solo debes abrir una hoja en blando con tu editor de texto
favorito, y escribir las sentencias que se deben ejecutar. Como editor de texto puedes utilizar:
 • Un editor de texto gráfico. Te puede servir perfectamente el que venga con tu entorno de
escritorio (por ejemplo, Gedit en GNOME), pero puedes instalar otro más completo, como
Geany.
• Un editor de texto por consola. Si tienes cierta experiencia con el manejo de la terminal,
también puedes utilizar un editor de texto por consola como puede ser Nano o Vim (este
ultimo bastante más complicado de utilizar).
Una vez seleccionado el editor, empieza el proceso de escribir el script. En mi caso, utilizaré Nano
como editor de texto para construir el script, y lo guardaré en el directorio Documentos. Si quieres
hacerlo como yo, tan solo tienes que abrir una ventana de terminal y ejecutar la siguiente orden.
nano Documentos/mi-primer-script.sh

Esto te abrirá un fichero vacío con Nano, en la misma ventana de la terminal. Ahí ya puedes
empezar a escribir el contenido del script.
Como primer paso, para indicarle al sistema que la Shell que va a interpretar el fichero es Bash,
debes empezar siempre escribiendo esta sentencia como primera línea:
#!/bin/bash

Una vez indicada esta primera línea, ya puedes empezar a escribir el contenido en si del script.
Tratándose de un primer script, voy a hacer un ejemplo sencillo, que consistirá en preguntarle al
usuario si quiere actualizar el equipo, y, en función de su respuesta, ejecutar una serie de comandos
para comprobar actualizaciones, e instalar los paquetes que se puedas actualizar.
El script, al completo, quedaría como te muestro debajo. Como dije, en este post no me he querido
centrar en el script en si, sino en el proceso completo, desde la creación, hasta establecer que se
ejecuta durante el inicio del sistema.
#!/bin/bash

sudo apt update

sudo apt upgrade
sudo apt autoremove

echo "Todo bien! Hasta luego"

exit

Este es un script muy simple, pero ya nos sirve para el propósito de esta guía. Basicamente aplica
tres comandos consecutivos que se encargan de buscar si hay actualizaciones en el equipo,
instalarlas en caso de que las haya, y, a continuación, buscar paquete que ya no son necesarios, por
tal de eliminarlos. El hecho de tener ese script preparado, te permite que, con solo ejecutarlo, se
realicen esas tres tareas de golpe.
Una vez finalizado, puedes guardar el fichero con la combinación de teclas CTRL-O. Como ya le
hemos dado un nombre al principio, puedes confirmarlo con Intro, ya ya tendrás el archivo
guardado con los últimos cambios. Para cerrar el fichero y salir de Nano, debes utilizar la
combinación de teclad CTRL-X.
 Ahora que ya tienes el script diseñado, tan solo debes guardar el fichero con un nombre, y
terminarlo con la extensión “.sh”. En mi caso, lo he nombrado como “mi-primer-script.sh”, y lo he
guardado, de momento, en el directorio Documentos de mi Home.

Establecer Permisos de Ejecución al Fichero

Anuncios

Object 5

Report this ad
Ahora que tienes el fichero creado, si intentas ejecutarlo verás que no podrás. Esto es debido a que
cualquier fichero nuevo que se crea y se ubica en el directorio personal de usuario, tiene el
siguiente esquema de permisos:
- rw- r-- r--

Esto significa que, el usuario propietario del fichero solo tiene permisos de lectura y edición sobre
el archivo, mientras que el resto de usuarios solo tendrás privilegios de lectura sobre él.
Para poder ejecutar el script desde tu cuenta de usuario, debes añadir los permisos de ejecución para
el propietario del fichero. El resto de permisos los puedes dejar iguales. Esto lo puedes abriendo una
ventana de terminal y ejecutando la siguiente sentencia:
sudo chmod +x Documentos/mi-primer-script.sh

Como ves, he puesto la ruta relativa del fichero, que se encuentra dentro del directorio Documentos.
Hecho esto, ya podrás ejecutar el script sin problema desde tu cuenta de usuario.

Ejecutar el Script de Forma Manual

Para ejecutar manualmente un script de Bash, el primer paso es abrir una ventana de terminal y
situarte en la carpeta donde guardas el fichero, cosa que puedes hacer con el comando cd, seguido
de la ruta (absoluta o relativa) del directorio donde se guarda.
cd Documentos

Una vez te has situado en el directorio correcto, que en mi caso es Documentos, ya puedes ejecutar
el script de forma manual, con la sentencia que pongo a continuación.
./mi-primer-script.sh

Dentro del script, he puesto algunas sentencias con el “sudo” delante (ya que los comandos para
actualizar el sistema requieren permisos de administrador), verás, durante la ejecución del mismo,
en algún momento se te preguntarán por tus credenciales de usuario.
Otra opción es ejecutar la misma sentencia anterior con el “sudo” delante ya de entrada, para que a
lo largo del script ya dispongas del token que te permite ejecutar ordenes como root.
 Scripting en Linux (V): Bash. Ejecutar un
Script en el Inicio o Apagado
Muy buenas. Ahí va otro post de la serie de Linux Scripting. Ahora que ya conoces más el entorno
de bash, y la sintaxis básica del lenguaje (sino puedes revisar los primeros posts de la serie), en este
post verás como crear y ejecutar tu primer script en Bash.
Como verás, no me centraré tanto en el script como tal (verás ejemplos mucho más completos e
interesantes en próximos artículos), sino en revisar el circuito completo que debes realizar, desde
construir el script en si, establecer los permisos de ejecución, y ejecutarlo de manera manual.
¡Vamos allá!
Anuncios

Object 6

Report this ad
Tabla de Contenidos:
1. Primeros pasos: preparar el script
2. Método 1: utilizar Cron y Crontab
3. Método 2: crear un servicio en systemd
4. Método 3: utilizar /etc/rc.d/rc.local
5. Continuación

Primer Paso. Preparar Script

Como punto de partida, y antes de empezar con lo importante, voy a suponer que parto del script
que creamos en el post anterior de esta serie, que básicamente se encarga de comprobar si hay
actualizaciones en el equipo, e indicar en un fichero de log la fecha y hora de ejecución del script
(esto me lo he puesto solo para comprobar, una vez arrancado el sistema, que se ha ejecutado
correctamente).
#!/bin/bash
sudo apt update
echo "script ejecutado - $(date)" >> /home/test/Documentos/log-script.txt
exit

El script, para esta prueba, lo he guardado en Documentos, dentro de mi directorio personal.

Recuerda también que, como explico en el post anterior, tenemos que proporcionar permisos de
ejecución a este fichero.
Hecho todo esto, paso ya a detallar los diferentes métodos que puedes utilizar para ejecutar este
script de forma automática, en cada inicio o apagado del equipo.
Método 1: Utilizar Cron y Crontab
Cron es una herramienta que se utiliza en GNU/Linux y Unix, y que sirve para programar la
ejecución de comandos o scripts en el sistema, en base a una fecha y hora específicas. Cron
permanece siempre activo y en segundo planto. Esto lo puedes comprobar fácilmente a través del
servicio o demonio asociado a Cron, que se denomina crond.
Por otra parte, tenemos al fichero Crontab, que es básicamente donde indica toda la relación de
scripts y/o comandos que deben ejecutarse de forma automática, en base a la fecha y hora
asignadas. Para ver y editar ese fichero, se utiliza el comando crontab, que facilita esa gestión sin
tener que utilizar la ruta del fichero.
Lo primero sería visualizar el contenido de ese fichero en tu sistema. Para ello puedes utilizar el
comando que te dejo a continuación. Como podemos tener un fichero Crontab a nivel de usuario,
puedes visualizar el que está asociado a tu cuenta de usuario (sin poner “sudo” delante), o el que
está asociado a root, que sería el que aplica al conjunto del sistema (anteponiendo “sudo” delante):
sudo crontab -l

En una instalación limpia, lo más probable es que la salida del comando te indique que el fichero
está vacío. En mi caso, por ejemplo, me ha salido el output que te muestro a continuación, que
básicamente indica que no hay ninguna tabla específica asociada al usuario root.
no crontab for root - using an empty one

El siguiente paso, por tanto, es rellenar el fichero con la tarea que quieres que se ejecute de forma
automática, e indicar el contexto de ejecución. Para ello, debes hacer uso del siguiente comando:
sudo crontab -e

A continuación se te preguntará, en primer lugar, que tipo de editor quieres utilizar para editar el
fichero. Yo he indicado la opción 1, que es la que corresponde a Nano, ya que es el editor por
consola que conozco mejor y que me parece más simple e intuitivo de utilizar. Lo siguiente que
verás es la interfaz del editor Nano por pantalla, y ya solo queda empezar a editar el fichero.
Para ello, debes especificar cada tarea a ejecutar en una linea aparte, y siguiendo el siguiente
formato:
* * * * * orden-ejecución

Los asteriscos van separados por un espacio y sirven para indicar el contexto de ejecución. Puedes
sustituir cada uno de ellos con el valor correspondiente en cada uno de estos casos:
• Minuto. Indicar un valor de 0 a 59.
• Hora. Indicar un valor de 0 a 23.
• Día del més. Indicar un valor de 1 a 31.
• Mes. Indicar un valor de 1 a 12.
• Día de la semana. Indicar un valor de 0 (domingo) a 6 (sábado).

Otra opción para indicar el contexto de ejecución es sustituir todos los asteriscos por una sola
palabra reservada, que no necesariamente tenga que estar relacionada con un hito de calendario.
Existen varias de ellas, pero la que nos interesa en nuestro caso es la siguiente:
 • @reboot. Ejecución una sola vez durante el arranque

La ultima parte es la orden de ejecución, que basicamente es el comando que debe ejecutarse, o
bien, como ocurre en este caso, la ruta del script que queremos ejecutar. Con todo esto, la línea que
tienes que añadir en tu fichero crontab quedaría así:
@reboot /home/test/Documentos/scripts/mi-primer-script.sh

Con esto ya tienes el fichero crontab configurado para ejecutar el script en cada arranque del
sistema. Antes de dar por bueno el proceso, queda la tarea de comprobar que el servicio asociado
a Cron esté habilitado, de lo contrario, no se ejecutaría ninguna de las tareas que especificases en
crontab.
Esto, en un contexto de systemd, puedes hacerlo con el comando que te indico a continuación.
Recuerda que, en Debian, Ubuntu y otras distros derivadas, el servicio se denomina cron, pero en
otros sistemas como Fedora o CentOS, el nombre correcto del servicio es crond.
sudo systemctl status cron.service

Lo más habitual es que te indique que el servicio está activo. Si por lo que fuera, te indicase lo
contrario, puedes habilitarlo con el siguiente comando:
sudo systemctl enable cron.service

Con esto si que ya tienes el script preparado para que se ejecute en cada arranque del sistema.

Método 2: Crear un Servicio en systemd

El segundo método que explicaré funciona dentro del contexto de systemd, por lo que solamente
será válido en el caso de que tu distribución haga uso de systemd como sistema de inicio
predeterminado.
Esto es muy probable que sea así, puesto que, a pesar de toda la controversia que ha traído, es el
sistema de inicio que han ido adoptando muchas de las distribuciones GNU/Linux más
populares, empezando por Fedora en 2011, y siguiendo con openSUSE, Ubuntu o Debian (junto
con todo el conjunto de derivadas de estas dos ultimas).
Aunque systemd nació originalmente como un sustituto de SysV, el sistema de inicio heredado de
los sistemas operativos Unix, systemd absorbe la gestión de muchos otros componentes del sistema,
con las ventajas y los problemas que ello conlleva. El tema da mucho de que hablar, pero nos
desviaríamos del alcance de este post.
Como systemd se encarga también de la gestión de servicios, puedes ejecutar un script en el inicio
creando un servicio a través de systemd que haga una llamada a tu script. Así pues, el primer paso
es crear el servicio. Para ello, puedes crear un fichero con cualquier editor de texto, y escribir lo
siguiente:
[Unit]
Description=Script service
After=network.target network-online.target
Wants=network-online.target
[Service]
ExecStart=/home/test/Documentos/mi-primer-script.sh
[Install]
WantedBy=multi-user-target

Como ves, el contenido consta de tres bloques (puede haber más, pero para este ejemplo me he
centrado en estos tres), con una serie de atributos o directivas en cada uno de ellos.
En el primer bloque es Unit, y en este ejemplo sencillo le he indicado las siguientes directivas
(puede tener muchas más según los requerimientos del servicio).
• Description. Puedes indicar una descripción simple del servicio. Aquí no hay mucho
misterio.
• After. Sirve para controlar el orden de ejecución. En este caso, por ejemplo, nos interesa que
el servicio se ejecute después de haber iniciado toda la capa de red. Lo tienes explicado
mucho más en detalle aquí.
• Wants. Esto viene a ser una versión ligera de Requires. Significa que systemd intentará
arrancar todas las unidades listadas aquí, en el momento de arrancar la unidad actual.
El segundo bloque es Service. bloque es donde se indica la ruta absoluta del fichero a ejecutar (que
en nuestro caso es el script que hemos creado en la primera parte del post).
• ExecStart. Aquí es donde debes indicar la tura completa, junto con los argumentos que
convengan, del comando o el script que quieres ejecutar. En este caso, simplemente
indicamos la ruta de nuestro primer script de prueba.
•

El tercer bloque que he utilizado es Install.

El fichero debes guardarlo con un nombre terminado con la extensión .service. y almacenarlo en el
directorio /etc.systemd/system. En mi caso lo he guardado como mi-primer-servicio.service.
El ultimo paso es habilitar el servicio para que inicie con cada inicio del sistema. Esto puedes
hacerlo con el siguiente comando (como ves, no hace falta indicar la extensión .service al final):
sudo systemctl enable mi-primer-servicio

También puedes iniciar un servicio de forma manual en cualquier momento. Para ello utiliza:
sudo systemctl start mi-primer-servicio

Además, en cualquier momento puedes comprobar que el servicio está cargado en el equipo. Para
ello escribe esto:
sudo systemctl status mi-primer-servicio

Como comprobación final, quedaría comprobar que, después del primer reinicio, el script se ha
ejecutado correctamente. Para ello puedes aprovecharte de el hecho que, en el propio script, hemos
escrito una línea en un fichero de log almacenado en documentos.

Método 3: Utilizar /etc/rc.d/rc.local

El último método es probablemente el más clásico, y que solía funcionar muy bien antes de la
llegada de systemd en gran parte de las distribuciones. Consiste básicamente en añadir las órdenes
que deseas ejecutar en el inicio del sistema, al final del fichero /etc/rc.d/rc.local.
Lo que ocurre es que, con la llegada de systemd, el fichero en cuestión de gobierna a través de un
servicio de systemd, que en muchos casos está inactivo. De hecho, esto puedes comprobarlo a
través del siguiente comando:
sudo systemctl status rc-local

Al hacer esto en Ubuntu 18.04 LTS, lo más probable es que obtengas una salida como la que me ha
aparecido a mi:
● rc-local.service - /etc/rc.local Compatibility
Loaded: loaded (/lib/systemd/system/rc-local.service; static; vendor preset:
Drop-In: /lib/systemd/system/rc-local.service.d
└─debian.conf
Active: inactive (dead)
Docs: man:systemd-rc-local-generator(8)

Esto indica que este servicio ya no se utiliza, por lo que el método que propongo a continuación no
podrás utilizarlo en tu sistema.