Interfaz de línea de comandos

La interfaz de línea de comandos, traducción del inglés command-line interface o CLI es un método que permite a los usuarios dar instrucciones a algún programa informático por medio de una línea de texto simple. Debe notarse que los conceptos de CLI, shell y emulador de terminal no son lo mismo, aunque suelen utilizarse como sinónimos. - Wikipedia

Interprete de comandos o shell

Un intérprete de órdenes o de comandos, es un programa informático que tiene la capacidad de traducir las órdenes que introducen los usuarios, mediante un conjunto de instrucciones facilitadas por él mismo directamente al núcleo (o kernel) y al conjunto de herramientas/comandos/programas que forman el sistema operativo. Las órdenes se introducen siguiendo la sintaxis incorporada por dicho intérprete, dentro del entorno proporcionado por el emulador de terminal, mediante un inductor (prompt, en inglés) que espera a que le sean introducidos los comandos o instrucciones. - Wikipedia

Un interprete de comandos es conocido como shell en sistemas operativos basados en UNIX.

Una Shell de Unix o también shell, es el término usado en informática para referirse a un intérprete de comandos, el cual consiste en la interfaz de usuario tradicional de los sistemas operativos basados en Unix y similares como GNU/Linux. - Wikipedia

Las shells disponibles o instaladas en Slackware Linux están definidas en el archivo /etc/shells:

root@servidor:~# cat /etc/shells 
/bin/bash
/bin/tcsh
/bin/csh
/bin/ash
/bin/ksh
/bin/zsh

De las mostradas:

• bash: Bourne-Again Shell.
  • No confundir con sh o Bourne Shell.
• tcsh: TENEX C Shell.
• csh: C Shell.
• ash: Almquist Shell. Una variante de sh o Bourne Shell.
  • Existe una variante de ash conocida como dash (Debian Almquist Shell) disponible principalmente en sistemas GNU/Linux basados en la distribución Debian.
• ksh: KornShell.
• zsh: Z Shell.

La shell sh (o Bourne_Shell) sería considerada como la shell estándar en UNIX pero en GNU/Linux sería bash (o Bourne-Again Shell). Cabe mencionar que bash ofrece compatibilidad con sh, no así a la inversa.

Lo anterior se puede verificar de la siguiente manera:

root@servidor:~# file /bin/bash /bin/sh
/bin/bash: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, stripped
/bin/sh:   symbolic link to bash
root@servidor:~# ls -l /bin/bash /bin/sh
-rwxr-xr-x 1 root root 1037384 Jun 21 12:40 /bin/bash*
lrwxrwxrwx 1 root root       4 Aug 15 12:54 /bin/sh -> bash*

Consola virtual y emuladores de terminal

Cuando uno enciende la computadora y el sistema operativo termina de iniciarse nos ofrece la opción de iniciar sesión. Para iniciar sesión uno se autentifica con un usuario y una contraseña asociada a ese usuario. Si el usuario y la contraseña son las correctas se ejecuta una shell para que mediante ella ingresemos ordenes o comandos al sistema operativo:

El programa dentro del que se ejecuta la shell es conocido como consola virtual o terminal virtual. En Slackware Linux es el programa agetty:

root@servidor:~# which agetty
/sbin/agetty

Una vez autenticado como usuario root (imagen previa) se accede a la shell configurada para la cuenta de usuario root:

root@servidor:~# grep -E '^root' /etc/passwd
root:x:0:0::/root:/bin/bash

De igual forma cabe notar que existe un proceso principal (PID 1) dentro del sistema operativo quien es el que ejecuta a agetty conocido como init:

root@servidor:~# ps aux | grep init
root         1  0.0  0.1   4372  1352 ?        Ss   00:37   0:00 init [3

init ejecuta 6 veces a agetty por lo que contamos con 6 consolas virtuales, disponibles apretando los juego de teclas desde Ctrl + Alt + F1 hasta Ctrl + Alt + F6:

root@servidor:~# grep -E 'agetty.*linux' /etc/inittab 
c1:12345:respawn:/sbin/agetty --noclear 38400 tty1 linux
c2:12345:respawn:/sbin/agetty 38400 tty2 linux
c3:12345:respawn:/sbin/agetty 38400 tty3 linux
c4:12345:respawn:/sbin/agetty 38400 tty4 linux
c5:12345:respawn:/sbin/agetty 38400 tty5 linux
c6:12345:respawn:/sbin/agetty 38400 tty6 linux

root@servidor:~# ps aux | grep agetty
root       946  0.0  0.1  13280  1684 tty2     Ss+  00:38   0:00 /sbin/agetty 38400 tty2 linux
root       947  0.0  0.1  13280  1836 tty3     Ss+  00:38   0:00 /sbin/agetty 38400 tty3 linux
root       948  0.0  0.1  13280  1688 tty4     Ss+  00:38   0:00 /sbin/agetty 38400 tty4 linux
root       949  0.0  0.1  13280  1828 tty5     Ss+  00:38   0:00 /sbin/agetty 38400 tty5 linux
root       950  0.0  0.1  13280  1692 tty6     Ss+  00:38   0:00 /sbin/agetty 38400 tty6 linux

Cuando uno se encuentra en una interfaz gráfica de usuario se puede acceder a una shell mediante un emulador de terminal:

En la anterior imagen se puede observar en ejecución al emulador de terminal conocido como xterm. Cada xterm permite obtener una shell e ingresar más comandos, ya sea del sistema operativo o propios de la shell. En cada una de las ventanas de xterm se están ejecutan disintitos programas: pstree, uname, nano, ruby, ls, file, htop, etc.

Otros emuladores de terminal, para el uso dentro de un entorno gráfico o de escritorio, son:

• Konsole (konsole): usualmente encotrado en el entorno de escritorio KDE.
• GNOME Terminal (gnome-terminal): usualmente encontrado en el entorno de escritorio GNOME.
• Terminal de Xfce (xfce4-terminal): usualmente encontrado en el entorno de escritorio Xfce.
• rxvt-unicode (urxvt).

Bash

Una vez iniciada la sesión como usuario alumno (cuenta de usuario previamente creada) se encuentra uno ante la shell bash, en el directorio personal /home/alumno. Lo anterior pueden observarse mediante los siguientes comandos:

alumno@servidor:~$ echo $SHELL
/bin/bash
alumno@servidor:~$ pwd
/home/alumno
alumno@servidor:~$ echo $HOME
/home/alumno
alumno@servidor:~$ echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/games:/usr/lib64/kde4/libexec:/usr/lib64/qt/bin:/usr/share/texmf/bin

Dentro de nuestra sesión como usuario alumno podemos iniciar sesión como usuario root haciendo uso del comando su -:

alumno@servidor:~$ su -
Password: 
root@servidor:~# echo $SHELL
/bin/bash
root@servidor:~# pwd
/root
root@servidor:~# echo $HOME
/root
root@servidor:~# echo $PATH
/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/usr/games:/usr/lib64/kde4/libexec:/usr/lib64/qt/bin:/usr/share/texmf/bin

Archivos de configuración

Los archivos de configuración para el entorno, basado en el uso de Bash, en Slackware Linux son los siguientes:

• /etc/profile: archivo principal de configuración que lleva a cabo la interpretación de los archivos con extensión *.sh disponibles en el directorio /etc/profile.d.
• $HOME/.bash_profile: archivo personal de configuración interpretado por una shell de inicio de sesión (al iniciar el sistema operativo y obtener el prompt de login/password en la consola).
• $HOME/.bashrc: archivo personal de configuración interpretado al solicitar una shell interactiva (al iniciar una terminal como xterm, uxterm, konsole o xfce4-terminal).

Como usuario alumno

1. Crea el archivo $HOME/.bash_profile con el siguiente contenido:

   echo "$HOME/.bash_profile : Iniciando..."
   echo "$HOME/.bash_profile : Terminando..."
   

2. Crea el archivo $HOME/.bashrc con el siguiente contenido:

   echo "$HOME/.bashrc: Iniciando..."
   echo "$HOME/.bashrc: Terminando..."
   

Para más información:

• Ficheros de inicialización de bash
• Archivos de configuración para shells

Variables de entorno

El archivo $HOME/.bashrc nos permite, entre otras cosas, definir las variables de entorno, siendo PATH una variable de entorno muy importante ya que mediante su valor, una lista de directorios separados por dos puntos, bash encuentra la ubicación completa de cada comando que uno use. Puedes agregar la siguiente linea al archivo $HOME/.bashrc para modificar su valor actual y tener acceso a otros comandos instalados en el sistema sin la necesidad de escribir su ubicación completa:

export PATH="$HOME/.local/bin:$HOME/.local/sbin:/usr/sbin:/sbin:$PATH"

De igual forma otra variable que uno puede configurar es PS1. El prompt es la cadena de caracteres mediante la cual bash nos indica que está esperando el ingreso de algún comando a ejecutar cuando se apriete la tecla de Enter. Puedes agregar la siguiente linea, de igual forma, al archivo $HOME/.bashrc para modificar el valor de la variable de entorno PS1:

export PS1=" [\u@\h:\w] "

Al terminar el archivo $HOME/.bashrc tendrá el siguiente contenido:

echo "$HOME/.bashrc: Iniciando..."
export PATH="$HOME/.local/bin:$HOME/.local/sbin:/usr/sbin:/sbin:$PATH"
export PS1=" [\u@\h:\w] "
echo "$HOME/.bashrc: Terminando..."

Para más información:

• Variables de shell
• Como cambiar el prompt del shell por Sergio González D.
• Personalizar PS1 prompt de forma sencilla por Alejandro García
• http://bashrcgenerator.com, http://ezprompt.net, http://omar.io/ps1gen y https://scriptim.github.io/bash-prompt-generator/.

Shell scripts

Un script de shell es un archivo el cual contiene instrucciones/comandos propios del sistema operativo y/o del interprete de comandos bash. Un ejemplo, si ya modificaste la variable de entorno PATH:

1. Crea el archivo $HOME/.local/bin/saludar con el siguiente contenido:

   #!/bin/bash
   a=$1
   if [ -z "${a}" ]; then
     echo "¡Hola mundo!"
   else
     echo "¡Hola ${a}!"
   fi
   

2. Asigna permisos de ejecución a $HOME/.local/bin/saludar:

   alumno@servidor:~ $ chmod +x $HOME/.local/bin/saludar
   

3. Verifica que el comando saludar sea encontrado por la shell:

   alumno@servidor:~ $ which saludar
   /home/alumno/.local/bin/saludar
   

4. Ejecuta el comando saludar:

   alumno@servidor:~ $ saludar
   ¡Hola mundo!
   alumno@servidor:~ $ saludar MUNDO
   ¡Hola MUNDO!
   alumno@servidor:~ $ saludar $HOME
   ¡Hola /home/alumno!
   alumno@servidor:~ $ saludar $(whoami)
   ¡Hola alumno!
   alumno@servidor:~ $ saludar $(hostname)
   ¡Hola servidor!
   alumno@servidor:~ $ saludar $(which nano)
   ¡Hola /usr/bin/nano!
   

OBSERVACIÓN: $HOME/.local/bin forma parte de la variable de entorno PATH y $HOME/.local/bin/saludar tiene permisos de ejecución.

Lecturas

• Programación de Shell Scripts [PDF] por Diego Bottallo. OBSERVACIÓN: awk es un lenguaje de programación y sed un editor de flujo-de-texto, aún cuando uno los usa en el interprete de comandos no forman parte de Bash y pueden considerarse como uso avanzado de un interprete de comandos.
• Programación de scripts en Bash en xtech.com. OBSERVACIÓN: dialog y gdialog (así como zenity, yad o kdialog) permiten a un script de shell interacturar con el usuario mediante una interfaz gráfica y de igual forma pueden considerarse como uso avanzado de un interprete de comandos.
• Comandos Bash en Wikipedia.