Uso

Jerarquía del sistema de archivos

openSUSE cumple (en la medida de lo posible) con el Filesystem Hierarchy Standard, por lo que uno puede encontrar lo siguiente en la ráiz (/):

root@servidor:~# tree -F -L 1 /
/
├── bin/
├── boot/
├── dev/
├── etc/
├── home/
├── lib/
├── lib64/
├── lost+found/
├── mnt/
├── opt/
├── proc/
├── root/
├── run/
├── sbin/
├── selinux/
├── srv/
├── sys/
├── tmp/
├── usr/
└── var/

20 directories, 0 files

Cabe mencionar lo siguiente:

• /bin, /sbin, /usr/bin y /usr/sbin: directorios donde se instalan los ejecutables o comandos.

• /etc: directorio donde se instalan los archivos de configuración de distintos programas, así como propios del sistema operativo

  • /etc/rc.d y/o /etc/init.d: directorios donde se encuentran scripts de shell para administrar procesos, servicios o demonios en el sistema operativo.

    IMPORTANTE: actualmente el uso de estos directorios (y cualquier archivo en su interior) está desaconsejado. openSUSE, al igual que otras distribuciones GNU/Linux, hacen uso de systemd.

    systemd es un sistema de inicio nuevo creado por Lennart Poettering, Kay Sievers y muchos otros. systemd se encarga de todo el proceso de inicio del sistema operativo. - https://es.opensuse.org/Systemd

• /lib y /lib64: directorios donde se instalan las librerias o bibliotecas (archivos con extensión .so o .a) usados por los programas instalados.

• /opt: directorio donde se instalan aquellos programas que no cumplan con el Filesystem Hierarchy Standard. Por lo general estos programas no son instalados desde su código fuente si no que se obtiene un archivo comprimido (ZIP, RAR, TAR, TAR.GZ, TAG.BZ2, etc) el cual tiene todo lo necesario para ejecutar el programa una vez descomprimido. Ejemplo de estos pueden ser juegos como Xonotic, AssaultCube, Warsow, Urban Terror o Red Eclipse.

• /usr/local: directorio donde se instalan aquellos programas que cumplan con el Filesystem Hierarchy Standard pero que no formen parte oficial del sistema operativo.

   root@servidor:~# tree -F -L 1 /usr/local
   /usr/local/
   ├── bin/
   ├── games/
   ├── include/
   ├── lib/
   ├── lib64/
   ├── man/
   ├── sbin/
   ├── share/
   └── src/
  
   9 directories, 0 files
  

  Como puede observarse su estructua se asemeja al de la ráiz (/) pero con directorios vacíos.

Grupos y cuentas de usuario

Los archivos /etc/group y /etc/passwd indican los grupos y las cuentas de usuarios, respectivamente, que existen en el sistema operativo:

• /etc/group

   root@servidor:~# cut -d ':' -f 1 /etc/group | column
   root                    tftp                    tty
   shadow                  at                      ntp
   dialout                 nogroup                 bin
   utmp                    nobody                  rtkit
   users                   man                     scard
   messagebus              mail                    pulse
   sshd                    lp                      pulse-access
   tape                    daemon                  ntadmin
   polkitd                 wheel                   postfix
   nscd                    trusted                 maildrop
   systemd-journal         kmem                    avahi
   systemd-timesync        audio                   nm-openvpn
   systemd-coredump        disk                    sddm
   systemd-network         video                   adm
   input                   cdrom                   svn
   mysql                   lock
  

• /etc/passwd

   root@servidor:~# cut -d ':' -f 1 /etc/passwd | column
   at                      nobody                  sddm
   avahi                   nscd                    sshd
   bin                     ntp                     statd
   daemon                  polkitd                 systemd-coredump
   lp                      postfix                 systemd-network
   mail                    pulse                   systemd-timesync
   man                     root                    tftp
   messagebus              rpc                     antonio
   mysql                   rtkit                   svn
   nm-openvpn              scard
  

La cuenta de usuario root es de tipo administrador y algunas de las cosas permitidas y realizadas como usuario root son:

• Reiniciar/detener el sistema operativo
• Administrar grupos y cuentas de usuario:
  • Crear, eliminar, modificar grupos así como usuarios y la información/contraseña establecida para cada uno.
• Administrar los sistemas de archivos:
  • Montar/desmontar particiones de un dispotivo de almacenamiento, así como darles formato ("formatear").
• Administrar (configurar, iniciar y detener) procesos/servicios/demonios (servidor HTTP/SSH/FTP, SGBD, etc):
• Administrar software (paquetes) o actualizaciones del sistema operativo:

Como usuario root podemos obtener información sobre varios aspectos del sistema operativo mediante ciertos comandos, ejemplos:

• Versión del kernel Linux: uname -r
• Por cuanto tiempo ha estado en ejecución el sistema operativo: uptime
• Uso de RAM/swap: free -m
• Uso de sistemas de archivos/discos duros/particiones: df -h
• Usuarios existentes en el sistema operativo: cat /etc/passwd
• Usuarios autentificados ante el sistema operativo: who o w
• Dispositivos PCI detectados por el sistema operativo: lspci
• Interfaces de red identificadas: ip link show
• Información sobre la configuración de las interfaces de red: ip addr show
• Servidor DNS usado por el sistema operativo: cat /etc/resolv.conf
• Gateway (también conocido como Puerta de Salida o Puerta de Enlace): ip route show
• Servicios de red y puertos en espera de conexión (LISTEN): ss -plutn
• Conexiones externas de red (ESTABLISHED): ss -pautn
• Procesos que no están siendo ejecutados por el usuario root: ps aux | grep -Ev '^root'

A su vez, el usuario root puede llevar a cabo:

• Reiniciar el sistema operativo: shutdown -r now
• Detener el sistema operativo: shutdown -h now

Podrás encontrar un compendio de comandos (y ejemplos) en los siguientes enlaces:

• Listado de comandos Linux más útiles
• Tips: Más de 400 comandos para GNU/Linux que deberías conocer

La gran mayoría de comandos indicados en las anteriores páginas te servirán, exceptuando aquellos que tengan que ver con la administración/actualización de paquetes o repositorios (RPM, yum, DEB, apt-get, dpkg, pacman, etc) ya que es algo distintivo de las distribuciones de GNU/Linux (Red Hat, Fedora, Debian, Ubuntu, etc.) por su formato de paquetes y su sistema de gestión de paquetes.

La shell del usuario root es la shell Bash y su directorio personal es /root.

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 openSUSE están definidas en el archivo /etc/shells:

root@servidor:~# cat /etc/shells 
/bin/ash
/bin/bash
/bin/csh
/bin/dash
/bin/false
/bin/ksh
/bin/ksh93
/bin/mksh
/bin/pdksh
/bin/sh
/bin/tcsh
/bin/true
/bin/zsh
/usr/bin/csh
/usr/bin/dash
/usr/bin/ksh
/usr/bin/ksh93
/usr/bin/mksh
/usr/bin/passwd
/usr/bin/pdksh
/usr/bin/bash
/usr/bin/tcsh
/usr/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.
• dash: una variante de ash disponible principalmente en sistemas GNU/Linux basados en la distribución Debian.
• ksh: KornShell.
• pdksh: versión Dominio Publico de 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 1012528 Jun  4 04:35 /bin/bash
lrwxrwxrwx 1 root root       4 Jun  4 04:35 /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 openSUSE 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:/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 systemd:

root@servidor:~# ps aux | grep systemd
root  1  0.1  0.2 209972  7828 ?        Ss   20:24   0:04 /usr/lib/systemd/systemd --switched-root --system --deserialize 23

systemd es un conjunto de demonios o daemons de administración de sistema, bibliotecas y herramientas diseñados como una plataforma de administración y configuración central para interactuar con el núcleo del Sistema operativo GNU/Linux. systemd se puede utilizar como un sistema de inicio de Linux (el proceso init llamado por el núcleo o kernel de Linux para inicializar el espacio de usuario durante el proceso de arranque de Linux y gestionar posteriormente todos los demás procesos). - https://es.wikipedia.org/wiki/Systemd

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.

En la anterior imagen se puede observar en ejecución al emulador de terminal conocido como Konsole (konsole): usualmente encotrado en el entorno de escritorio KDE.

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

• 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
/home/alumno/bin:/usr/local/bin:/usr/bin:/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
/root/.local/bin:/sbin:/usr/sbin:/usr/local/sbin:/root/bin:/usr/local/bin:/usr/bin:/bin

Archivos de configuración

Los archivos de configuración para el entorno, basado en el uso de Bash, en openSUSE 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, o agrega al final si ya existe, el archivo $HOME/.bash_profile con el siguiente contenido:

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

2. Crea, o agrega al final si ya existe, 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 al final:

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
• Personalizar PS1 prompt de forma sencilla por Alejandro García

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.