PARTE 2

ADMINISTRACIÓN LINUX DESDE CONSOLA

En esta segunda parte se van a introducir los procedimientos más importantes de la administración
de un sistema Linux.

Administrar un sistema informático implica, entre otras muchas cosas, las siguientes tareas
esenciales:
- Crear y administrar usuarios y fijar sus privilegios.
- Instalar, y mantener actualizados los programas necesarios.
- Controlar y administrar los recursos críticos como la memoria RAM, o el espacio en
la memoria secundaria.
- Controlar los procesos que se corren en el sistema para evitar, por ejemplo, que
consuman demasiados recursos de CPU
- Garantizar la conectividad local y externa del sistema con criterios de calidad (QoS)

El Shell Linux

La administración habitual de un sistema Linux se realiza desde consola o terminal, es decir, a través
de la familiar pantalla negra de línea de comandos con indicativo, llamado “prompt”, a la que se
puede acceder esencialmente de tres maneras:

- Lanzando desde el escritorio Linux una aplicación de emulación de terminal.

- En local, usando una instalación Linux que arranque directamente a terminal. Las versiones
desktop de los sistemas operativos son más pesadas y no son las idóneas para montar servidores.

- En remoto, mediante una conexión IP con emulación de terminal. Es aconsejable que la aplicación
utilizada soporte un protocolo seguro, siendo en la actualidad ssh (secure Shell) un estándar de facto.

1
En las sesiones remotas el acceso estará (o debiera de estar) protegido por contraseña, por lo que
habrá que dispone de cuenta en el sistema.

Iniciada la sesión, las órdenes se introducen a continuación del prompt. Por eso, a esa línea inferior
del terminal se la conoce también por línea de comandos.

Como ejemplo, en la siguiente captura el prompt es la secuencia <MacBookPro:~ chema$>

En Windows el prompt es el conocido “C:>”. En linux puede adoptar varios formatos como veremos
a continuación.
A veces también se habla del “login prompt” para referirse al indicativo que aparece cuando nos
logeamos a un sistema remoto, y que nos solicita el nombre de usuario y la contraseña.

La sesión de consola es gestionada por el intérprete de comando, conocido por Shell en el argot
informático. El shell es el responsable de interpretar y ejecutar las órdenes que los usuarios
introducen por el terminal, o que son volcadas a un fichero para automatizar determinado proceso;
a este fichero se le llama script. En ambos casos han de ajustarse a una sintaxis concreta que viene
determinada por el shell utilizado, ya que en Linux, a lo contrario de las plataformas Windows, hay
varios shells, y el usuario elige en todo momento cuál quiere usar a través del comando
correspondiente.

A continuación se muestran los más extendidos, con el comando que los invoca, y su prompt
característico.
- Bourne Shell. El shell clásico. sh ~$
- Korn Shell. Otro clásico. Basado en el sh. ksh ~$
- Bourne-Again-Shell. Una derivación del anterior. bash ~$
-C Shell. Usado en desarrollo, no en admin. csh ~%
-TC Shell . Una evolución del csh tcsh ~%
-Z Shell. Lo mejor de los anteriores. zsh ~$

El shell inicial con el que se inicia consola puede ser fijado por el administrador del equipo. Por defecto
suele ser bash en prácticamente todos los sistemas
2
Desde un shell se puede invocar a otro. En todo momento se puede averiguar el shell activo mediante
el comando: echo $
Cuando se necesita introducir una secuencia repetitiva y/o grande de comandos, o se quiere
automatizar dicha entrada, éstos se pueden agrupar en un fichero denominado “script”, y al que se
acostumbra a dar la extensión “.sh” para evidenciar que es un fichero de script.
Los scripts se lanzan desde la consola para su procesamiento por el shell con el indicativo “dot”
(punto, ".")
ejemplo: ~$. miScript.sh
Otra característica muy interesante de los scripts es que se pueden anidar, de modo que unos
llamen a otros.

OPERADOR "." Y MODIFICADOR "."

No hay que confundir el operador punto para ejecutar scripts , con el modificador punto que activa
el atributo "Hidden" (oculto) de un fichero, o directorio.
Ejemplos:
~$touch .miScript.sh crea un fichero de script oculto.
~$mkdir .miDirectorio crea un directorio oculto.
~$. .miScript.sh ejecuta un fichero de script oculto.
~$mv miFichero.txt .miFichero.txt

El atributo de oculto añade un plus de seguridad a los ficheros y directorios importantes.

3
ADMINISTRAR PAQUETES SOFTWARE: apt y apt-get
______________________________________________________________________
El programa dpkg es la base del sistema de gestión de paquetes de Debian GNU/Linux. Fue creado

por Ian Jackson en 1993. Se utiliza para instalar, quitar, y proporcionar información sobre
los paquetes .deb.
dpkg es en sí misma una herramienta de bajo nivel; se necesita un frontal (Frontend) de alto nivel

para descargar los paquetes desde repositorios en Internet, o resolver conflictos complejos en las
dependencias de paquetes (una dependencia es cuando paquete necesita de parte o la totalidad de
otro). Debian cuenta con APT para esta tarea.

APT (Advanced Package Tool) es la herramienta del proyecto Debian, encargada de gestionar
paquetes y que está compuesta de diferentes utilidades diseñadas para realizar las diferentes
tareas: instalar, desinstalar, actualizar (upgrade).

Mientras dpkg se limita a instalar determinado paquete, apt, que es un sistema de gestión de
paquetes inteligente, instalará todas las librerías, e incluso otros paquetes, que hagan falta para su
funcionamiento. Del mismo modo, cuando se desinstala un paquete con apt, se analizarán y
eliminarán del sistema todas las librerías y paquetes asociados al mismo, y que ya no hagan falta. A
esto se denomina resolver dependencias.

APT admite en la actualidad 3 interfaces con el usuario: la tradicional apt-get, su equivalente

corta, apt (*) y aptitude
aptitude es un UI (interfaz de usuario) interactiva, que se puede invocar desde consola
simplemente con: ~$aptitude. No tiene demasiado interés práctico y no se usará.
A continuación se muestra una batería de opciones que cubren prácticamente todas las necesidades.
>apt install miPaquete : instala miPaquete
>apt remove miPaquete : desinstala miPaquete
>apt update : actualiza la lista de paquetes y versiones disponibles
>apt upgrade : actualización estándar de los paquetes instalados
>apt dist-upgrade : actualización inteligente de paquetes (ver aclaración)
>apt show miPaquete : muestra info y dependencias de paquete
>apt search miPaquete : busca en repositorios miPaquete
>apt list miPaquete : busca en cache local miPaquete
>apt list --upgradeable : muestra paquetes actualizables (después de update). <-u>
>apt list --installed : muestra paquetes instalados y sus versiones. <-i>

4
ACTIVIDADES

Ejercicio resuelto: crear el script miScript.sh que realice las siguientes tareas:
- Muestre la fecha (date)
- Muestre el contenido del directorio con información extendida (ls -ls)
- Cree la carpeta prueba_1 (mk prueba_1)
- Cree la carpeta oculta prueba_2 (mk .prueba_2)
- Cree el fichero oculto miFichero.txt dentro de la carpeta anterior
o cd .prueba_2
o touch .miFichero.txt
SOLUCIÓN:

Fases:
1. Se invoca el editor nano desde consola asignándole ya un nombre al fichero de trabajo
( ~$nano miScript.sh)

2. Se añaden las diferentes órdenes, línea a línea

3.

4. Se salva el contenido (^X)

5. Se ejecuta el script ( ~$. miScript.sh)

Ejercicio propuesto: crear dos scripts de manera que uno invoque al otro
Sugerencia: en base al ejercicio anterior, crear un segundo script que cuando se invoque deshaga las
acciones del primero (eliminar carpetas y fichero).

Comprobar la equivalencia

A RECORDAR: las siguientes instrucciones son equivalentes, solo que dpkg obliga a que el
paquete esté ya descargado, mientras que los apt se basan en repositorios de Internet

~$ dpkg -i miPaquete.deb
~$ apt install miPaquete
~$ apt-get install miPaquete
5
EL SISTEMA DE ARCHIVOS Y USUARIOS EN LINUX

DERECHOS Y ATRIBUTOS DE UN FICHERO: CHMOD, CHOWN, CHGRP

En Linux no hay diferencia entre un fichero y un directorio, ambos son tratados como archivos. No
obstante se les adjudica un atributo, un bit, que determina si es un directorio (d), un acceso directo,
denominado en Linux enlace simbólico (l) o un fichero (-)

En Linux todo fichero tiene asociado alguno(s) de los siguientes derechos: lectura, escritura y
ejecución. Los atributos R, W y X, son bits que se asocian al fichero y que hacen referencia a estos
derechos, con el siguiente alcance:
• Lectura (R): Permite que el contenido del fichero o directorio pueda ser visualizado o listado (con órdenes
como ls, cat, cp etc.)
• Escritura (W): Permite modificar el contenido del archivo. El archivo se puede editar, por ejemplo con el editor nano;
en el caso de un directorio, a este se le puede incorporar/suprimir nuevos ficheros.
• Ejecución (X): concede derecho de ejecución al archivo, como si de un programa ordinario se tratase.

Cuando un usuario crea un fichero, una carpeta, o un enlace simbólico, el sistema no solo le asigna
el atributo de tipo (d,-,l) , sino también una triada de tres atributos con los permisos RWX sobre él.
Cada uno de estos tres grupos corresponde a los permisos del:
- usuario o propietario que lo creó
- de su grupo de pertenencia
- del resto de los usuarios.

Los atributos RWX de usuario, grupo y resto, se expresan en decimal a partir de sus bits y de su
peso, según muestra el siguiente ejemplo:
Ejemplo: fichero con permisos R y W para su propietario, y de R para su grupo
RWX RWX RWX Atributo decimal fichero
110 100 --- à 640
6
A la vista del ejemplo anterior es fácil deducir que el permiso máximo sobre un fichero es 777.-
No debiera ahora ser complicado entender la estructura que devuelve el comando ls
~$ ls -l

Algunas deducciones:
1. Solo a.out es un fichero (-), los demás son directorios (d). No hay enlaces simbólicos.
2. Todos los directorios ofrecen permiso RWX para el propietario PI, pero solo RX para el grupo PI y
el resto de los usuarios.
Los permisos de usuario, grupo y otros, que por defecto otorga Linux, pueden ser alterados en
cualquier momento posterior mediante los 3 comandos siguientes:

CHMOD: cambia permisos de fichero o directorio.

chmod <valor_decimal_permisos> <fichero>
chmod <ugo +/- rwx> <fichero>
Ejemplos: $ chmod 777 a.out
$ chmod uo+rw a.out ; añade permiso RW a user/otros.
$ chmod g-W a.out ; quita permiso W a grupo
CHOWN: cambia propietario de fichero o directorio
chown <propietario> <fichero/dir>
Ejemplo: $ chown ricardo backup

CHGRP: cambia grupo de pertenencia de fichero o directorio

chgrp <grupo> <fichero/dir>
Ejemplo: $ chgrp STI Notas
7
GESTIÓN DEL ESPACIO LIBRE EN DISCO: df,du

Es conveniente tener cierto dominio previo de los comandos: find, grep y cat

1. AUDITAR ESPACIO
El espacio total y consumido, en las diferentes unidades montadas (discos HD y USB, unidades
DVD, tarjetas SD, discos RAM etc), y que reciben el nombre de sistema de ficheros, se valora con
df (disk free).
Veamos una salida típica:
~$ df -h ; averigua con man el cometido de -h
S.ficheros Tamaño Usados Disp Uso% Montado en
/dev/root 13G 2,7G 8,9G 24% /
devtmpfs 459M 0 459M 0% /dev
tmpfs 20M 1,9M 19M 10% /tmp/log

/dev/root representa la unidad física donde está instalado el sistema Linux. En este caso una SD
con 13GB libres para el Sistema, de los cuales se han consumido ya 2.7G (24%).

Los diferentes tmpfs son sistemas de archivo temporales, generalmente unidades RAM, es decir,
bloques de RAM que se gestionan como si fuesen memoria secundaria.

La columna "Montado en" indica la ruta absoluta en la que fueron montados los diferentes
sistemas de ficheros, y que serán accesibles mediante cd

Ejemplo: de acceso a pincho USB:

~$cd /dev/usb-00000
Por otro lado con du (disk usage), se podrá conocer lo que consume cada estructura de información
dentro de un sistema de archivos, no solo el consumo que reporta df.

Ejemplo: recursos consumidos por los elementos de una carpeta (y sus subcarpetas).
~$du -h Elecrow-LCD35/ -h: unidades amigables
8,0K Elecrow-LCD35/.git/info
8,0K Elecrow-LCD35/.git/logs/refs/heads
8,0K Elecrow-LCD35/.git/logs/refs/remotes/origin
~$ du -hs Elecrow-LCD35/ -s: salida compacta
16,0k Elecrow-LCD35/
8
2. CACHE DE PAQUETES INSTALADOS

Con el tiempo, los paquetes instalables, y sus actualizaciones, se van depositando en determinada
carpeta del disco, pudiendo comprometer su espacio libre, especialmente si es una SD.

Para auditar el espacio ocupado en estos menesteres usaremos el comando du (disk usage) aplicado
a la carpeta usada por APT.
~$du -sh /var/cache/apt/archives
Confirmada la conveniencia de reducir este espacio, APT contempla varias órdenes:

~$sudo apt-get autoclean (a)

~$sudo apt-get clean (b)
~$sudo apt-get autoremove (c)

(a) Elimina de la caché los paquetes .deb con versiones anteriores a las de los programas instalados.
(b) Elimina todos los paquetes de la caché. El único inconveniente es que si se necesitase reinstalar
un paquete, hay que volver a descargarlo.
(c) Borra paquetes huérfanos, aquellos instalados como consecuencias de dependencias asociadas a
otro paquete principal, y que ya fue desinstalado, o cuya instalación fue interrumpida.

3. FICHEROS GRANDES ASOCIADOS A LOGS: truncate

Prácticamente todos los paquetes generan ficheros con información que permite al administrador
conocer determinados eventos, como errores, y otros estados operativos, y que reciben el nombre
genérico de logs porque su extensión suele ser .log

El tamaño de un log puede crecer de manera anormal si los eventos que refleja se repiten con mucha
frecuencia (por ejemplo errores sistemáticos). En principio no hay problema en restablecer su tamaño
a un valor deseado (a 0 bytes por ejemplo). El problema es localizar estos ficheros; uno de los
modificadores de la orden find es perfecto para esto. ~$find <path> -size +<tamaño>

Localizados así los ficheros candidatos no parece peligroso resetear su tamaño a 0 (no es lo mismo
que borrar el fichero!).
El comando truncate sirve para eso:
~$truncate -s <tamaño> <fichero>

9
Pero antes de hacer eso es prudente seguir una pauta:

1. Determinar a qué programa pertenece ese log

2. Crear una copia del fichero, p.e., ~$ cp fichero.log fichero.old
3. Poner el fichero original a tamaño cero: ~$truncate -s 0 fichero.log
4. Comprobar efectos secundarios en el programa afectado.
5. Si todo parece funcionar, borrar copia: ~$rm fichero.old

Ejemplo práctico 1 :

Localizar desde nuestro directorio actual todos los ficheros que pesen más de 500M
~$sudo find -size +500M
./.pm2/logs/homebridge-error.log

~$truncate -s 0 homebridge-error.log

Ejemplo práctico 2:

Se ha detectado, con df, un consumo anormal de espacio en disco, pero no se sabe qué ficheros son
los responsables. Una solución es ordenar una búsqueda de ficheros que pesen mucho , desde el raíz
del sistema, por ejemplo:

~$sudo find / -size +5G

Nota: Zoneminder es un paquete de videovigilancia que puede generar con facilidad logs > 10G!

Otra opción interesante es combinar los modificadores -name con -size, por ejemplo para buscar
ficheros con la extensión .log que ocupen más de determinado valor:

~$sudo find / -name *.log -size +10M

10
USUARIOS Y GRUPOS: adduser, deluser, usermod, addgroup, delgroup,
groups,gpasswd, id
_____________________________________________________________________
En la Parte I de este tutorial se avanzó la orden para la creación de nuevos usuarios: adduser.
Ahora se van a introducir algunos conceptos avanzados en la política de gestión de los usuarios del
sistema.
1. Eliminar a un usuario
2. Bloquear/desbloquear una cuenta
3. Establecer una fecha de caducidad para la cuenta
4. Ver usuarios del sistema
5. Cambiar el nombre de un usuario
6. Cambiar ubicación/nombre de directorio de usuario.
7. Cambiar la contraseña de un usuario
8. Asignar nuevos grupos a un usuario.
9. Añadir/quitar usuarios a un grupo. Miembros de un grupo.
10. ID de usuario/grupo. Miembros de un grupo.

Para la mayoría de estas tareas se usará una misma utilidad: chmod

1. Eliminar usuarios

La eliminación de usuarios es una operación crítica, y por tanto protegida.

Sintaxis: ~$ sudo deluser <usuario>

No obstante la orden anterior no elimina las carpetas de usuario, algo que no tiene mucho sentido.
La solución pasa por usar el modificador --remove-home.

Ejemplo: ~$ sudo deluser --remove-home alumnosSTI

Tambien puede ser interesante crear un fichero comprimido con el contenido del usuario
eliminado, y colocarlo en un determinado directorio. Así siempre hay la posibilidad de minimizar el
impacto del a eliminación. Veamos el proceso.
~$ sudo mkdir /home/exusuarios

~$ sudo deluser --remove-home --backup-to /home/exusuarios alumnosSTI

11
2. Bloquear/desbloquear una cuenta

Un procedimiento muy empleado para penalizar temporalmente a un usuario o mientras no se

resuelve algún trámite con su cuenta.

Sintaxis: ~$ sudo usermod -L <usuario> ; bloqueo

~$ sudo usermod -U <usuario> ; desbloqueo

Ejemplo: ~$ sudo usermod -L alumnosSTI

3. Establecer una fecha de caducidad para la cuenta

En determinados escenarios es necesario otorgar acceso al sistema a un usuario pero durante un

tiempo prefijado.

Sintaxis: ~$ sudo usermod --expiredate YYYY-MM-DD <usuario>

Ejemplo: ~$ sudo usermod --expiredate 2019-12-31 alumnosSTI

4. Ver cuentas de usuario del sistema

No existe un método directo para obtener una lista de las cuentas de usuario del sistema. Para
empezar, algunas aplicaciones crean cuentas como si fuesen usuarios ordinarios, por lo que el
número de cuentas de usuario puede ser inferior al de cuentas reales.

Se abordará el problema mediante un procedimiento indirecto. Linux mantiene un fichero muy

importante con las contraseñas de usuarios; es el fichero /etc/passwd.

Si se observa su contenido: ~$ sudo cat /etc/passwd,

se observa que ciertas cuentas tienen asignados directorios en /home. Esas serán las cuentas de
usuario. Ya solo tendremos que encontrar una manera de filtrar su contenido para que solo
muestre las líneas que contienen /home. Este es justamente el cometido del comando grep

Sintaxis ~$ grep <cadena_a_buscar> <fichero>

~$ grep /home /etc/passwd

Resultado:

12
5. Cambiar el nombre de usuario de una cuenta

Sintaxis: ~$ sudo usermod -l <nuevo_login> <usuario>

Ejemplo: ~$ sudo usermod -l alumnosSTI alumnos

En el siguiente login el prompt reflejará su nueva identidad. La contraseña

por supuesto que seguirá siendo la misma.

6. Cambiar ubicación/nombre de directorio de usuario

Por defecto, Linux asigna dentro de su filesystem al usuario <nombre> el directorio

/home/<nombre>.

Cuando se cambia el nombre de una cuenta, Linux le sigue asignando el directorio que tenía con la
identidad anterior. Esto puede despistar y no es conveniente. Por ejemplo, el usuario alumnos
después del cambio en la sección anterior es alumnosSTI, pero su directorio sigue reflejando su
anterior identidad:

El procedimiento para solucionarlo es muy simple,

~$ sudo usermod -md /path/<nuevo_directorio> <usuario>

-m se encarga de mover todo el contenido de su viejo directorio al nuevo.

-d indica path absoluto y nombre del nuevo directorio de usuario.

Se aconseja conservar como path: /home

Solucionemos el problema:
~$ sudo usermod -md /home/alumnosSTI alumnosSTI

7. Cambio de contraseña

~$ sudo passwd <usuario>

Ejemplo:

13
8. Asignar nuevos grupos a un usuario. usermod,

Linux gestiona los usuarios del sistema dentro de entidades organizativas mayores que reciben el
nombre de GRUPOS. Esto no es nada novedoso, un centro de enseñanza también gestiona a sus
alumnos en unidades grupales, o una empresa a sus trabajadores en departamentos. La idea es la
misma.

Cuando se crea un usuario nuevo, Linux siempre crea a la par un nuevo grupo, asignándole el mismo
nombre que el de usuario. Por supuesto que el administrador puede con posterioridad asignar o
quitar pertenencias a otros grupos del sistema, incluso crear grupos nuevos sin usuarios asignados.

Obsérvese la siguiente captura del proceso de creación del usuario "alumno". En la segunda línea
se reporta la creación del grupo "alumno"

Una vez creado un nuevo usuario, una de las tareas habituales es añadirlo al grupo de sudoers
mediante el comando general de gestión de usuarios: usermod

Se utilizan los dos modificadores -a (append) y -G (group):

~$sudo usermod -aG sudo alumno

Así, el usuario alumno que pertenecía ya al grupo alumno, asignado durante la creación de la
cuenta, ahora pertenece también al grupo sudo.

Un grupo también se puede crear de manera directa, sin necesidad de estar asociado a una cuenta
de usuario. El comando equivalente a adduser es en este caso addgroup.
~$sudo addgroup sti
Ahora se podría asociar este nuevo grupo al usuario alumno
~$sudo usermod -aG sti alumno
Es importante incluir el -a o de lo contrario el nuevo grupo reemplazará a todos los demás excepto
al asignado durante la creación del usuario.
Un grupo se puede eliminar mediante ~$delgroup <nombre_grupo>.
Se puede consultar los grupos a los que pertenece determinado usuario mediante el comando
~$groups <usuario>
Si se omite <usuario>, se mostrarán los grupos para el usuario activo.

14
9. Añadir /quitar usuarios a un grupo: gpasswd, getent group
Esta interesante utilidad da mucho juego para gestionar la pertenencia a los grupos de los
diferentes usuarios, aunque su función primaria, y la que justifica su nombre, es la de asignar una
contraseña a un grupo.

Sintaxis: $gpasswd <modificadores> <usuario> <grupo>

Sus dos modificadores principales son:

-a ; añadir un usuario a un grupo
-d ; eliminar un usuario de un grupo
-r ; elimina contraseña a grupo.

Ejemplos: $gpasswd video ; asigna paswd a video

$gpasswd -a juan sudo
$gpasswd -d alumnos impresora

Puede ser muy interesante averiguar los usuarios que son miembros de un grupo:
Sintaxis: ~$getent group <grupo>
Ejemplo: ~$getent group sudo

10. ID de usuario y de grupo.

En realidad todos los usuarios y grupos en Linux son gestionados, no por su nombre, si no por un
identificador numérico único que los etiqueta de manera inequívoca.
El comando id permite consultar estos identificadores o IDs de determinado usuario. El grupo
efectivo o principal de un usuario (gid) es el que se le asigna cuando se crea su cuenta.

Sintaxis: ~$id <usuario> ~$id -G <usuario> ~$id -g <usuario>

Ejemplo: ~$id alumnosSTI

uid UserID Identifica a un usuario 1002

gid GroupID Identifica al grupo efectivo del usuario 1002
grupos Relación de los grupos a los que pertenece 1002, 27

15
REDIRECTORES Y DESCRIPTORES: >, <, &

En Linux, los símbolos ‘>’ y ‘<’, además de su significado matemático, sirven para gestionar los
flujos de entrada/salida que generan los programas y los comandos.

- el símbolo > después de una orden, indica a qué dispositivo se ha de dirigir el resultado de la
misma.
- El símbolo < en cambio, sirve para que la orden tome sus datos de entrada del dispositivo
especificado.

Un fichero tiene la consideración de disposito, y por tanto las siguientes sentencias están
permitidas.

>ls -l >miSalida.txt :lista un directorio y lo vuelca a fichero

>cat <miSalida.txt :asigna un fichero como entrada de cat

Los descriptores son cadenas que empiezan por &. Representan los dispositivos de E/S del sistema.
Por defecto hay definidos 3:

a. &0 : dispositivo de entrada estándar, stdin, asignado por defecto al teclado

b. &1 : dispositivo de salida estándar, stdout, asignado por defecto a la consola
c. &2 : dispositivo de error estándar, stderr, asignado por defecto a la consola.

0 - stdin 1 - stdout 2 - stderr.

Los descriptores pueden ser utilizados en conjunción con los redirectores para organizar las E/S.

Ejemplo 1 : las 2 líneas siguientes son equivalentes porque la segunda redirige la salida a &1, que
por defecto es la pantalla.

>sudo find / -name miFichero

>sudo find / -name miFichero >&1

16
Pero los dispositivos estándar de E/S pueden modificarse, el siguiente ejemplo lo aclara.

Ejemplo 2: find necesita privilegios de administrador para entrar en determinados directorios, por
eso casi siempre se utiliza en conjunción con sudo. En caso contrario genera tantos errores como
directorios le nieguen su entrada.
La sentencia siguiente reasigna &2 (stderr) al fichero errorOut, por lo que por pantalla ya no se
mostrarán los errores generados

find / -name *.db-wal 2>errorOut

17
PROCESOS Y TRABAJOS EN LINUX

La multitarea (Multitasking) es la habilidad de un único procesador de dar la apariencia de

estar realizando varias tareas a la vez. Lo que en realidad ocurre, es que el procesor cambia de
una tarea a otra tan rápidamente, que parece estar realizando todas las tareas al mismo
tiempo. A este proceso se le llama cambio de contexto.

El multihilo (Multithreading) consiste en dividir el trabajo de un programa en diferentes hilos

de ejecución que se corren en procesadores o núcleos separados. Obliga pues a que la
arquitectura sea multinúcleo o multiprocesador. Es un paralelismo puro, aunque por desgracia
las dependencias funcionales entre los hilos introducen tiempos muertos mientras unos hilos
esperan a que terminen otros de los que tienen que recibir información.

Un proceso es cualquier programa en ejecución, y que demanda

como mínimo memoria RAM y tiempo de CPU. De manera más
académica se dice que un proceso es una instancia de un
programa.
Si un usuario arranca por ejemplo 3 terminales con su respectivo
shell, habrá creado 3 procesos diferentes que el sistema operativo
debe gestionar.

Los procesos pueden arrancarse automáticamente durante el startup del sistema, ser lanzados por
otros procesos , o directamente por los usuarios cuando invocan determinados comandos.

Por ejemplo, Excel crea un proceso multihilo en un ordenador multinúcleo; un hilo puede tener
las tareas de visualizado de menús y lectura de la entrada del usuario, mientras otro hilo
mantiene las tareas de ejecución de las órdenes y la actualización de la hoja de cálculo. Este
enfoque aumenta la velocidad que se percibe en la aplicación, permitiendo que el programa pida la
orden siguiente antes de terminar la anterior.

Ciertos sistemas operativos además de ser multitarea y multihilo, son multiusuario, es decir,
soportan sesiones simultáneas de varios usuarios. El Windows 10 ordinario no es multiusuario. En
cambio todos los Linux lo son.

18
PS / PIDOF/PGREP

ps (process status) Comando fundamental.

Reporta PID (Process ID) de los procesos, a quién pertenecen, nombre del aplicativo que los
creó etc. etc.

Admite muchos formatos y modificadores. Se indican los más habituales.

Sintaxis: $ps <-e><-u usuario><-e> <aux>

Ejemplo: $ps aux ; una amplísimo report de todos los procesos (ver top)
$ps ;muestra los procesos de consola de usuario
$ps 2567 ;muestra info de un proceso determinado.
$ps -u root ;muestra todos los procesos del usuario root
$ps -e l ; similar a aux, pero muetra prioridad y nice (ver nice)

pidof Indica el PID de un determinado proceso. Equivalente al comando pgrep

Ejemplos: $pidoff domoticz
$pgrep domoticz
KILL / PKILL

kill (matar), es otro comando fundamental. Se utiliza para enviar mensajes

administrativos a los procesos en segundo plano ejecutándose en el sistema.
Por defecto, el mensaje que se envía es la señal de terminación.
pkill (process kill). Actúa directamente sobre el PID
Sintaxis: $kill [-s] <PID>
$pkill <PID>
-s señal a enviar al proceso. Señal por defecto si no se especifica.
-9 fuerza la terminación inmediata de un proceso. Muy útil cuando se cuelga.
PID es el identificador del proceso (obtenido mediante ps/pidoff etc)
Ejemploa: $kill -9 3456 ; mata de inmediato el proceso con PID 3456
$pkill 3456

19
TOP

top (cima), muestra una vista dinámica de los recursos consumidos por los diferentes procesos
del sistema, además de proporcionar información administrativa de dichos procesos, como
su estado (S) prioridad (PR), nice (NI) o su PID.
Permite navegar con las teclas de flecha. Finaliza pulsando la tecla "Q".

Sintaxis: $ top <-u USUARIO>

Ejemplo: $ top -u alumno : solo visualiza procesos de alumno

En la siguiente tabla se muestra el significado de algunos de los campos.

Campo Descripción Ejemplo 1 Ejemplo 2

PID ID de proceso de cada tarea 1525 961
USER El propietario de una tarea Home Root
PR Prioridad de una tarea. Habitualmente 20 20 20
NI Valor nice de una tarea (-20<=nice<=+19) 0 0
VIRT Memoria virtual usada (kb) 1775 75972
RES Memoria física usada (kb) 100 51
SHR Memoria compartida usada (kb) 28 7952
Estado de un proceso:
R: corriendo en primer plano.
S: dormido interrumpible
S(TATUS) D: dormido ininterrumpible T S
T: parado (Stopped, CTR+Z)
Z: zombie. Terminado pero no liberado por
el proceso padre.

Por ejemplo en la captura anterior, solo los procesos zmc y top se están ejecutando (R).
Hay 4 procesos dormidos (S) a la espera de alguna señal, habitualmente de I/O, para despertar.
Un proceso tiene estado (D). Pertenece a root y es un proceso crítico (watchdog), de ahí que no
pueda ser "matado", ni por el superusuario.

20
NICE / RENICE

nice lanza un proceso con prioridad modificada. El nice es una constante comprendida entre
-20 y +19. Un nice negativo aumenta la prioridad de un proceso, un nice positivo la baja.
Solo superusuarios pueden ordenar un nice negativo (más prioridad).

Sintaxis: $nice -n <VALOR> PROGRAMA

Ejemplo: $nice -n -10 top ;ejecuta comando top con una prioridad
aumentada en 10 unidades
$nice ;indica modificador por defecto (0 habitualmente)

renice por su parte, modifica la prioridad de un proceso que ya se está ejecutando.

Sintaxis: $renice <VALOR_NICE> PID ; -20<=VALOR_NICE<=19

Ejemplo: $renice 10 5555 ; fija NICE en 10 para PID 5555

A nivel administrativo hay una situación en la que resulta especialmente interesante su empleo:
cuando los procesos de determinado usuario absorben demasiados recursos. El comando
contempla la posibilidad de reducir/aumentar la prioridad de TODOS los procesos de determinado
usuario.

Sintaxis: $renice <VALOR_NICE> -u <USUARIO>

Ejemplo: $top -u pi

$renice 12 -u alumno
$top -u pi

21
JOBS, FG, BG, &, CTR+Z

En Linux, un JOB o trabajo, es un proceso que corre en consola. Antes de entrar en materia es
necesario adquirir unos conceptos esenciales relacionados con este asunto.

Existen dos planos de ejecución de un software: el primer plano (foreground, fg) y el segundo plano
(background, bg):

- El primer plano es lo que el usuario ve en su pantalla, permitiéndole interactuar con botones,

ventanas, campos de texto, imágenes, etc. Los cálculos mas comunes se realizan en el primer plano,
o hilo principal de la aplicación. Como la interacción con el usuario deja mucho tiempo de CPU libre,
la multitarea es muy efectiva en este plano.

- El Segundo plano es donde se procesan los hilos o la multitarea sin interacción con el usuario.
Mientas se muestra alguna pantalla, en el segundo plano se ejecutan las tareas pesadas; el usuario
no ve lo que ocurre, es donde se ejecutan los servicios de software, los enlaces de red, los
conexiones a bases de datos, los cálculos complejos, etc. Aquí las tareas pueden tardar el tiempo
que necesiten mientras el usuario interactúa con las tareas menos críticas del primer plano.

En un entorno de escritorio, cada ventana gestiona sus trabajos de manera independiente, y

podemos pasar de una ventana a otra a golpe de ratón. No tenemos la sensación de "estar
atrapados en determinado proceso".
En una sesión de consola en cambio, solo disponemos de una ventana. Cuando se lanza un proceso
desde ella, éste la acapara al 100% hasta que termine. La única posibilidad sería abrir otra sesión
de terminal y seguir trabajando en ella mientras no termine el proceso en la primera consola.

Afortunadamente Linux da la opción de elegir si queremos correr un proceso en primer o segundo

plano.
Recuérdese que un job o trabajo es un proceso más del sistema, con su PID, propietario, prioridad
etc., y por tanto pueden ser monitorizados con TOP/PS, y matados con KILL. Solo se diferencia
de un proceso ordinario en que se ha lanzado desde consola.

A continuación se van a introducir las órdenes correspondientes, su significado, y unos ejemplos

aclaratorios.
22
 Opción Descripción

jobs <-lp> <nom> Muestra los trabajos actuales.

<nom> indica el nombre del proceso. Por defecto se muestran
todos los procesos actuales.
-l formato largo que muestra jobID y PID
-p formato corto que muestra solo PID

bg jobID Continúa ejecutando en segundo plano un jobID que estaba

en estado dormido (S)

fg jobID Trae el jobID especificado a primer plano, con independencia

de que estuviese en estado (R) o (S).

programa & Ejecuta el programa en segundo plano

Control-Z Para el proceso que en ese momento se está ejecutando en
primer plano, y lo pone en estado (S), dormido.

Una técnica simple para poner en (S) un trabajo que se esté

corriendo en segundo plano, es traerlo al primer plano y
dormirlo con Ctrl Z

Control-C Mata el trabajo ejecutándose en primer plano.

Ejercicio Manipulación de trabajos en consola con sleep.

$ sleep <n> ejecutado desde consola la bloquea durante <n> segundos. El trabajo se está
corriendo en primer plano y por tanto toma posesión de la consola durante ese tiempo.
No obstante, si necesitásemos recuperar el control del terminal lo podemos hacer con CTR+Z. El
trabajo no se interrumpe, simplemente se pone en estado (S).
$ sleep <n>& lanza el trabajo en background y deja la consola liberada para otros trabajos.
$ fg jID trae a primer plano el jID de sleep.
Con estos conceptos generales entendidos, se debieran comprender los pasos en el siguiente
ejercicio:
1. lanzar en segundo plano 3 instancias de sleep, de 100, 200 y 300 segundos.
2. Comprobar estado con top.Los 3 jobs debieran estar como (S)
3. Traer el jID asociado a sleep 100 a primer plano. Dejarlo terminar
4. Traer el jID asociado a sleep 200 a primer plano. Pararlo
5. Comprobar estado con top.Uno debiera figurar con estadoo (T), de parado.
6. Reanudar en segundo plano sleep 200 y volver a comprobar estado con top

23
El ejercicio se realiza desde consola con usuario pi logeado.
1.

2. $ top -u pi

3.

4.

5.

6.

24
Ejercicios de repaso
______________________________________________________
Usuarios y grupos.

Aunque ~$groups <usuario> permite averiguar los grupos a los que pertenece
determinado usuario, se puede utilizar un método indirecto, análogo al utilizado para la obtención
de las cuentas de usuario.
La idea es pasar por grep <filtro> todos los grupos de la lista de grupos en /etc/group. Supóngase
que se desea averiguar los grupos a los que pertenece el usuario pi. Analícese la siguiente captura:

25