# Los comandos de Linux más importantes Como la mayoría de los sistemas operativos modernos, Linux también incluye una **shell** a través de la cual se puede manejar el sistema con ayuda de las **líneas de comandos**: todos los ajustes que se realizan en la [interfaz gráfica (GUI)](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/que-es-una-gui/) también se pueden llevar a cabo en el denominado shell. Te mostramos los comandos más importantes y, además, te aclaramos sus funciones y posibles usos. ## Lista de los 50 comandos de Linux más importantes
Comando Descripción
sudo Ejecuta programas con los permisos de otros usuarios
ls Muestra el contenido del directorio como una lista
cd Navega por el árbol de ficheros
touch Crea un archivo nuevo
mkdir Crea un directorio
rm Borra archivo o directorio
rmdir Borra el directorio
mv Mueve archivos o directorios
cp Copia archivos o directorios
pwd Muestra el nombre del directorio
zip Escribir ficheros en archivos zip
unzip Extraer archivos de archivos zip
ln Crea un enlace simbólico
cat Agrupa contenido de varios archivos
grep Explora archivos de texto
diff Compara archivos o directorios
cmp Compara archivos a nivel de byte
tar Escribe y extrae archivos en el fichero tar
echo Muestra una cadena en la salida estándar
clear Limpia la ventana del terminal
ssh Conexión a otro ordeandor con *secure shell*
wget Descargar un archivo de Internet directamente
ping Comprueba la conexión de red
ftp, sftp Transferir archivos a través (S)FTP
ip Administra interfaces IP
apt/pacman/yum Descarga y gestiona paquetes de software
netstat Muestra el estado de las interfaces de red
traceroute Seguimiento de paquetes de datos
route Muestra y edita tablas de enrutamiento IP
dig Solicita información del DNS
mount/unmount Añade sistemas de archivos (set up/mount)
dd Copia archivos, particiones o discos por bits
chmod Gestiona los permisos de acceso
chown Administra derechos de propietario
adduser Agrega/modifica una cuenta de usuario
passwd Crea/ edita contraseñas para cuentas de usuario
groupadd Crea grupos de usuarios
chattr Gestiona los atributos de los archivos
lsattr Muestra los atributos del archivo
chgrp Administra los grupos de archivos y directorios
man Abre el manual
shutdown, reboot Apaga o reinicia el sistema
top Listado dinámico de los procesos en ejecución
lscpu Muestra información sobre el procesador
lshw Muestra información sobre el hardware
kill Interrumpe y finaliza un proceso con PID
killall Interrumpe y cierra procesos usando el nombre
nice Define las prioridades de los procesos
pgrep Busca el PID mediante un término de búsqueda
ps Muestra una lista de todos los procesos abiertos
### Comando de Linux sudo El [comando de Linux `sudo`](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/linux-sudo/) (*substitute user do*) puede establecer que la llamada al sistema se ejecute con los derechos de un usuario diferente de forma segura. Generalmente se requiere la contraseña del usuario que realiza la invocación. Cuando se introduce el comando sin indicar ningún nombre de usuario, se utiliza el superusuario root como usuario. ```bash sudo -u USUARIO LLAMADA ``` ### Comando de Linux ls El [comando `ls` de Linux](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/comando-ls-de-linux/) equivale a `list` y se utiliza para mostrar el contenido de un directorio (los nombres de todos sus archivos y carpetas). Esta es la sintaxis del comando: ```bash ls [OPCIONES] DIRECTORIO ``` Si no se añade a `ls` ningún directorio, el comando enumera el contenido del directorio en curso. Con ayuda de diferentes opciones se puede definir qué información se ha de mostrar y cómo. ### Comando cd de Linux El [comando de Linux `cd`](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/comando-cd-de-linux/) es la abreviatura de *change directory* y se utiliza para navegar por el directorio. La sintaxis de este comando sigue el esquema: ```bash cd [OPCIÓN] DIRECTORIO ``` Si no se indica ningún directorio concreto, `cd` cambia automáticamente al directorio principal del usuario. Si se acompaña de un guion (-), `cd` abre el directorio precedente. ### Comando touch de Linux El [comando `touch` de Linux](https://www.ionos.com/es-us/digitalguide/hosting/cuestiones-tecnicas/direccion-ip-en-linux/) puede usarse para modificar la fecha y la hora de los accesos o los cambios que han tenido lugar en un archivo. Si se utiliza en un archivo que no existe, este se crea automáticamente, lo que hace que este comando también se utilice para generar archivos vacíos. Para invocar a `touch` se tiene que seguir este esquema: ```bash touch [OPCIÓN] ARCHIVO ``` Si de lo que se trata es de cambiar la fecha y la hora de un archivo por una fecha determinada, se utiliza la opción `-t`, incluyendo la fecha en el formato `[AA]MMDDhhmm[.ss]`. Ejemplo: ```bash touch -t 1703231037 file.txt ``` La fecha y la hora del acceso y los cambios respecto a este archivo se han fijado en el 23 de marzo de 2017 a las 10:37 horas. Si se prefiere, el cambio se puede limitar a la fecha de acceso o de modificación con las opciones `-a` y `-m`. Si se utiliza sin la opción `-t` se sella automáticamente con la fecha y la hora actual. ### Comando de Linux mkdir El [comando de Linux `mkdir`](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/comando-mkdir-de-linux/) corresponde a *make directory* y permite a los usuarios de Linux crear directorios desde cero. Para crear un directorio en el fichero en curso escribe la siguiente sintaxis: ```bash mkdir [OPCIÓN] DIRECTORIO ``` Si se quiere crear un directorio nuevo en otro fichero diferente al actual, se ha de indicar la ruta absoluta o relativa al fichero. ### Comando rm en Linux El [comando `rm` en Linux](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/comando-rm-de-linux/) borra archivos o directorios de forma irreversible. Para ello se sigue la siguiente estructura: ```bash rm [OPCIONES] ARCHIVO/ DIRECTORIO ``` Para eliminar un directorio junto a todos sus subdirectorios se utiliza `rm` con la opción `-R` (*--recursive*): ### Comando en Linux rmdir Si hiciera falta borrar un determinado directorio, se utiliza el comando `rmdir` (*remove directory*) según la siguiente sintaxis: ```bash rmdir [OPCIÓN] DIRECTORIO ``` Con `rmdir`, sin embargo, solo se pueden borrar directorios vacíos. Si se quiere eliminar un fichero con todas sus carpetas y subcarpetas se utiliza el comando `rm` (*remove*) con la opción `-r`. En la Digital Guide, encontrarás otras formas de [eliminar un archivo de Linux](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/eliminar-archivos-en-linux/) o [eliminar un directorio de Linux](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/borrar-un-directorio-en-linux/). ### Comando mv en Linux El [comando de Linux `mv`](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/comando-mv-de-linux/) (*move*) copia un archivo o un directorio y borra el original. Si esto tiene lugar dentro del mismo directorio, `mv` puede utilizarse también para cambiar el nombre de los archivos. Para ello se sigue el siguiente esquema: ```none mv [OPCIÓN] ORIGEN DESTINO ``` ### Comando de Linux cp El [comando de Linux `cp`](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/comando-cp-de-linux/) (*copy*) se utiliza para copiar archivos o ficheros y sigue la siguiente sintaxis: ```bash cp [OPCIONES] ORIGEN DESTINO ``` El elemento ORIGEN es el que se ha de copiar y DESTINO se define a un archivo o un directorio donde se ha de alojar el elemento copiado. Si se define como DESTINO a un archivo que ya existe, el archivo origen reescribe su contenido. También se puede crear un archivo de destino nuevo. ### Comando pwd de Linux Utiliza el [comando de Linux `pwd`](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/comando-de-linux-pwd/) (*print working directory*) para mostrar el nombre del directorio de trabajo actual. La sintaxis del comando se muestra como sigue: ```bash pwd [OPCIONES] ``` ### Comando de Linux zip Utiliza el comando `zip` para comprimir varios ficheros en un archivo zip. La sintaxis del comando es: ```bash zip ARCHIVOS DESTINO ``` Con DESTINO se hace referencia al nombre o ruta de archivo ZIP resultante. Por su parte, ARCHIVOS muestra los nombres o rutas de los archivos que comprimir (separado por espacios). ### Comando de Linux unzip Puedes usar `unzip` para extraer algún archivo de archivos zip. La sintaxis es: ```bash unzip ARCHIVO.zip -d DESTINO ``` ARCHIVO hace referencia al archivo zip del que puedes extraer el archivo deseado. Si lo prefieres, puedes introducir con -d DESTINO un directorio de destino, donde se almacenan los archivos resultantes. De lo contrario, se depositan en el directorio actual. ### Comando de Linux ln El [comando de Linux `ln`](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/comando-ln-de-linux/) (*link*) crea un vínculo que lleva a un archivo o un directorio. Con ello se genera otra entrada a este archivo que permite acceder a él a través de una ruta diferente. Para invocar `ln` el comando ha de incluir, como mínimo, la ruta al archivo de origen. ```bash ln [OPCIONES] ruta/al/archivo de origen ``` En este caso, el enlace se crea en el directorio actual de trabajo sin cambiar de nombre. Otra alternativa consiste en indicar una ruta de destino y dar un nombre diferente al vínculo: ```bash ln [OPCIONES] ruta/al/archivo de origen ruta/al/enlace ``` ### Comando de Linux cat El [comando`cat` de Linux](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/linux-cat/) (*concatenate*) nace como herramienta para enlazar archivos y puede emplearse como pager para mostrar el contenido de los archivos en el terminal. Escribe `cat` con la siguiente sintaxis para leer y mostrar un archivo en la salida estándar `stdout`: ```bash cat OPCIONES ARCHIVOS ``` Si incluyes varios archivos, sepáralos mediantes espacios: ```bash cat OPCIONES ARCHIVO1 ARCHIVO2 ``` ### Comando de Linux grep Con el [comando de Linux grep](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/linux-comando-grep/) se pueden buscar archivos de texto tales como archivos de registro. Como patrón de búsqueda se pueden utilizar secuencias de caracteres o expresiones regulares. Utiliza `grep` según esta sintaxis: ```bash grep [OPCIONES] PATRÓN_DE_BÚSQUEDA [ARCHIVOS] ``` Si `grep` encuentra una cadena que se corresponde con el patrón dado, el terminal muestra el número de línea y especifica el nombre del archivo. Por regla general, `grep` se aplica a todos los archivos del directorio de trabajo actual. La opción `-r` permite la búsqueda recursiva en los subdirectorios. ### Comando de Linux diff Con el programa `diff` se cotejan dos archivos. También permite averiguar si dos directorios contienen los mismos archivos. Se le invoca con esta estructura: ```bash diff [OPCIONES] ARCHIVO1 ARCHIVO2 ``` ### Comando de Linux cmp A diferencia de `diff`, en `cmp` el cotejo tiene lugar byte por byte, lo que lo hace especialmente idóneo para archivos binarios. Invoca a `cmp` según la siguiente sintaxis: ```bash cmp [OPCIONES] ARCHIVO1 ARCHIVO2 ``` Si `cmp` encuentra diferencias, en el terminal se muestra el número de bytes y el de la línea del primer archivo que difiera. ### Comando de Linux tar El comando `tar` permite escribir ficheros y directorios de forma secuencial en un archivo `tar` y usarlos como backups si fuera necesario. A diferencia de lo que ocurre con el formato Zip propio de sistemas Windows, con `tar` los derechos de usuario de los ficheros guardados no se pierden tampoco después de descomprimirlos. Utiliza la siguiente sintaxis: ```bash tar [OPCIONES] ARCHIVOS ``` Si quieres crear un archivo nuevo, utiliza `tar` con las opciones `-c` (crear nuevo archivo) y `-f` (escribir un archivo en el fichero indicado o extraerlo de él). Para más información consulta nuestro artículo “[Programa de archivo tar: creación de backups y archivado de ficheros](https://www.ionos.com/es-us/digitalguide/servidores/herramientas/programa-de-archivo-tar-como-crear-backups-en-linux/)”. ### Comando de Linux echo Emplea el [comando de Linux `echo`](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/linux-echo/) para que el sistema muestre cadenas de caracteres por líneas en la salida estándar (que suele ser el terminal). La sintaxis básica del comando es: ```bash echo [OPCIONES] CADENA ``` ### Comando de Linux clear Con el comando `clear` se borran todos los comandos de la sesión. ```bash clear ``` El usuario recibe un terminal vacío con el prompt a la espera de órdenes. Los comandos introducidos anteriormente se guardan en el buffer de retroceso. También se puede limpiar la ventana de la consola con el atajo de teclado \[CTRL\] + \[L\] ### Comando de Linux ssh Con `ssh` puedes conectar tu ordenador a un ordenador externo mediante el protocolo SSH. De esta forma, te encontrarás en la shell de otro ordenador. La sintaxis es: ```bash ssh USUARIO@HOST ``` USUARIO y HOST se refieren al nombre de usuario con el que quieres iniciar sesión y a la dirección del ordenador externo. ### Comando de Linux wget Puedes usar el [comando de Linux `wget`](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/comando-wget-de-linux/) para descargar archivos de Internet. Para ello, aplica la siguiente sintaxis: ```bash wget [OPCIÓN] ENLACE ``` En ENLACE se indica la URL en la que se puede encontrar el archivo. Si lo deseas, puedes incluir el argumento opcional `-c` para continuar con una descarga que ha sido interrumpida. ### Comando de Linux ping Utiliza el [comando de Linux `ping`](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/comando-ping-de-linux/) para comprobar la disponibilidad de otros ordenadores en la red. Este comando sigue la siguiente sintaxis: ```bash ping [OPCIONES] DESTINO ``` Además de registrar la franja de tiempo que pasa entre el envío del paquete de datos y la recepción de la respuesta (Round trip time o RTT), `ping` también escribe la dirección IP del sistema de destino en el terminal. Con argumentos opcionales es posible establecer el número de paquetes o la franja temporal en segundos tras los cuales `ping` finaliza automáticamente. ### Comandos de Linux ftp o sftp Estos comandos permiten intercambiar archivos entre el sistema local y otro ordenador de la red. Para ello, se utiliza [FTP (File Transfer Protocol)](https://www.ionos.com/es-us/digitalguide/servidores/know-how/file-transfer-protocol/). Para establecer la conexión con el servidor FTP del ordenador de destino, usa `ftp` con la sintaxis que se muestra a continuación: ```bash ftp [OPCIONES] [HOST[PUERTO]] ``` El direccionamiento se realiza mediante el nombre de host o la dirección IP. Si se desea, se puede especificar un número de puerto. Utiliza FTP solo en aquellas redes en las que confíes, ya que este protocolo no es seguro. Por motivos de seguridad, es mejor optar por [SFTP (SSH File Transfer Protocol)](https://www.ionos.com/es-us/digitalguide/servidores/know-how/sftp-ssh-file-transfer-protocol/). El comando de Linux `sftp` funciona siguiendo el mismo principio que `ftp`, aunque en este caso la transferencia está cifrada. SFTP utiliza el estándar [Secure Shell (SSH)](https://www.ionos.com/es-us/digitalguide/servidores/herramientas/protocolo-ssh/), también sus métodos de autenticación. En este artículo, te explicamos cómo usar [claves SSH para una conexión de red más segura](https://www.ionos.com/es-us/digitalguide/servidores/seguridad/como-usar-las-claves-ssh-para-una-conexion-de-red/). ### Comando de Linux ip El programa de línea de comando `ip` forma parte del paquete de utilidades `iproute2`, con el cual se pueden consultar y configurar interfaces de red en el terminal. Esta es la sintaxis general del comando: ```bash ip [OPCIONES] OBJETO [COMANDO [ARGUMENTOS]] ``` Con ayuda de objetos, comandos de búsqueda y argumentos se puede definir qué acción se ejecuta con `ip`. El programa soporta objetos como `address` (dirección IP), `link` (interfaces de red), `route` (entrada en la tabla de enrutamiento) o `tunnel`, sobre el cual se pueden aplicar comandos de búsqueda como `add`, `change`, `del`, `list` o `show`. Si, por ejemplo, quieres invocar la dirección IP de una determinada interfaz de red (eth0), utiliza el comando `ip` con el objeto `address`, el comando `show` y el argumento `dev eth0`: ```bash ip address show dev eth0 ``` Descubre cómo [mostrar una dirección IP en Linux](https://www.ionos.com/es-us/digitalguide/hosting/cuestiones-tecnicas/direccion-ip-en-linux/) con más detalle en otro artículo de la Digital Guide. ### Comandos de Linux apt, pacman y yum Cada distribución de Linux dispone de un **administrador de paquetes** con el que puedes descargar y gestionar paquetes de software. La sintaxis para la instalación de la app es: ```bash apt install [PAQUETE] # Distribuciones basadas en Debian como Ubuntu pacman -S [PAQUETE] # Distribuciones basadas en Arch yum install [PAQUETE] # Distribuciones basadas en Red Hat ``` `[PAQUETE]` se corresponde con el nombre del paquete o programa que deseas instalar. En la mayoría de los casos, estos comandos se ejecutan con `sudo` en modo root. Para el resto de distribuciones, que usan otros administradores de paquetes, los comandos pueden diferir. Cada administrador también dispone de comandos para eliminar paquetes, así como para actualizar listas de paquetes y paquetes instalados, entre otros. En Ubuntu, los comandos se muestran como siguen: ```bash apt remove [PAQUETE] # eliminar paquete apt update # actualizar lista de paquetes apt upgrade # actualizar packages ``` ### Comando de Linux netstat El programa de líneas de comando `netstat` sirve para consultar el estado de las interfaces de red y se utiliza siguiendo esta sintaxis: ```bash netstat [OPCIONES] ``` Utilizado sin opción, el comando entrega todos los sockets abiertos en el terminal. También se pueden utilizar las siguientes opciones para consultar tablas de enrutamiento (`-r`), conexiones enmascaradas (`-M`) o mensajes de enlace de red (`-N`). Puedes encontrar más información en nuestro artículo “[Introducción a netstat](https://www.ionos.com/es-us/digitalguide/servidores/herramientas/una-introduccion-a-netstat/)“. ### Comandos de Linux traceroute Para rastrear la ruta de un paquete de datos IP entre tu sistema y un equipo de destino, puedes utilizar el comando [traceroute para seguir la ruta de los paquetes de datos](https://www.ionos.com/es-us/digitalguide/servidores/herramientas/usa-traceroute-y-sigue-la-pista-de-tus-paquetes-de-datos/). Haz uso del formato que aparece a continuación: ```bash traceroute [OPCIONES] NOMBRE_DEL_HOST ``` A través de `traceroute` se puede obtener información sobre el router y los nodos de Internet por los que pasa un paquete IP cuando se dirige a un ordenador de destino. Por ejemplo, para investigar la causa de un retraso. ### Comando de Linux route Con el comando `route` se pueden consultar y editar las tablas de IP routing del kernel. Se utiliza con esta sintaxis: ```bash route [OPCIONES] [add|del] [-net|-host] OBJETIVO ``` Si utilizas el comando sin opción se obtiene una tabla de enrutamiento completa del núcleo: ```bash route ``` Si quisieras añadir una ruta de enrutamiento a una red, utiliza la opción `add`: ```bash route add -net 10.0.0.0 ``` ### Comando de Linux dig `dig` constituye una herramienta de búsqueda con la cual pedir información a los servidores DNS y mostrarla en el terminal. Este comando se utiliza normalmente siguiendo este esquema para pedir la dirección IP y cualquier otra información en el DNS sobre un nombre de dominio: ```bash dig [@SERVIDOR] [DOMINIO] [TIPO] ``` SERVIDOR es el servidor DNS al cual se realiza la petición y donde se encuentra la información solicitada. Si no se indica un servidor, `dig` indaga en el servidor DNS estándar que figura en el archivo `/etc/resolv.conf`. DOMINIO equivale al nombre del dominio sobre el cual se busca la información almacenada en el DNS. Y TIPO permite determinar el tipo de petición: ANY (cualquier entrada), A (record IPv4 de un host) o AAA (record IPv6 de un host). El tipo estándar es A. ### Comando de Linux mount and unmount Con el fin de integrar un sistema de archivos en la estructura de directorios del sistema operativo utilizando el terminal, Linux ofrece para ello el comando `mount`. Esta es la sintaxis general de este comando: ```bash mount [OPCIONES] DISPOSITIVO MOUNTPOINT ``` DISPOSITIVO = aquí se escribe la ruta al archivo de dispositivo de la unidad que se quiere montar como partición. MOUNTPOINT = esta nomenclatura equivale al punto exacto en la estructura del directorio del sistema operativo en el cual se quiere integrar la nueva partición. Suele indicarse como ruta absoluta. Ejemplo: ```bash mount /dev/sdd /media/usb ``` El dispositivo `sdd` se encuentra en el directorio `/media/usb`. ### Comando de Linux dd El programa de línea de comando `dd` facilita un método de copia por el cual los datos se leen bit por bit desde un input file (`if`) y se describen en un output file (`of`). El comando se fundamenta en la siguiente sintaxis: ```bash dd if=Origen of=Destino [OPCIONES] ``` En él pueden indicarse como origen y destino tanto archivos independientes como particiones (/dev/sda1) o un dispositivo completo (/dev/sda). ```bash dd if=/dev/sda5 of=/dev/sdb1 ``` ### Comando de Linux chmod La llamada al sistema `chmod` (*change mode*) sirve para administrar los permisos en sistemas de archivos unixoides (ext2, ext3, ext4, reiser, xfs). La sintaxis general de chmod es: ```bash chmod [OPCIONES] MODO ARCHIVO ``` o ```bash chmod [OPCIONES] MODO DIRECTORIO ``` MODO corresponde a la forma de asignar los permisos que se aplica. Para saber cómo se crean y qué hay que tener en cuenta, lee nuestro artículo sobre el [reparto de permisos de acceso con chmod](https://www.ionos.com/es-us/digitalguide/servidores/know-how/asignacion-de-permisos-de-acceso-con-chmod/). Con ayuda de la opción `-R` se pueden ampliar los derechos de forma recursiva a las subcarpetas y a los archivos contenidos en un directorio. ### Comando de Linux chown La [comando de Linux `chown`](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/comando-chown-de-linux/) procede de *change owner* y permite configurar la propiedad de archivos y directorios. Este comando se utiliza basándose en la siguiente composición: ```bash chown [OPCIONES] [USUARIO][:[GRUPO]] ARCHIVO ``` o ```bash chown [OPCIONES] [USUARIO][:[ GRUPO]] DIRECTORIO ``` Con objeto de definir derechos de propietario para usuarios o grupos se dispone de cuatro combinaciones posibles. El propietario y el grupo de un fichero se definen según las indicaciones: ```bash chown [OPCIONES] nombre_propietario:grupos_archivos.txt ``` ```bash # El grupo se modifica en función de las indicaciones pero el usuario permanece invariable: chown [OPCIONES] :grupos_archivos.txt # Se define al propietario pero el grupo permanece invariable: chown [OPCIONES] propietario_archivos.txt # Se vuelve a definir al propietario y el grupo se define por el grupo estándar del usuario activo: chown [OPCIONES] nombre_propietario: archivo.txt # Los cambios se pueden extender a los subdirectorios con ayuda de la opción -R. ``` ### Comando de Linux adduser La opción más sencilla a la hora de crear una cuenta de usuario es la que ofrece el programa de líneas de comandos `adduser`. Se trata de un script de Perl basado en el [comando de Linux `useradd`](https://www.ionos.com/es-us/digitalguide/servidores/know-how/asignacion-de-permisos-de-acceso-con-chmod/) y ofrece las mismas funciones de forma de forma sencilla. El comando `adduser` requiere privilegios de root y sigue la sintaxis que aparece a continuación: ```bash adduser [OPCIONES] USUARIO ``` Si utilizas `adduser` sin opciones se crean automáticamente, además de una cuenta de usuario, el ID, el directorio por defecto y un grupo con su mismo nombre, como en este ejemplo: ```bash adduser test ``` A continuación, aparece un diálogo interactivo en el cual se pueden definir la contraseña y otros datos sobre el usuario, como su nombre real, el número de oficina, el número de teléfono, etc. ### passwd command in Linux Para cambiar la contraseña de un usuario o para definir, comprobar o cambiar intervalos de bloqueo utiliza el [comando de Linux `passwd`](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/comando-de-linux-passwd/) con la siguiente sintaxis: ```bash passwd [OPCIONES] USUARIO ``` Para cambiar la contraseña de otro usuario necesitas derechos de administrador. Escribiendo el comando `passwd` sin nombre de usuario puedes cambiar tu propia contraseña. Si de lo que se trata es de bloquear la contraseña de otro usuario, se utiliza el comando con la opción `-l` (*lock*). Otras opciones permiten definir una fecha de caducidad para contraseñas `(-x)`, así como intervalos de aviso `(-w)` y de inactividad `(-i)`. ### Comando de Linux groupadd El comando `groupadd` se utiliza para crear grupos de usuarios. Requiere derechos de administrador y se invoca siguiendo esta sintaxis: ```bash sudo groupadd [OPCIONES] GRUPO ``` Cada grupo que se crea obtiene un identificador de grupo único (GID). Los ID de grupo entre 0 y 99 están reservados para grupos del sistema. Para definir el GID de un nuevo grupo de usuarios se utiliza el comando con la opción `-g` (GID).Para crear un grupo de sistema se añade la opción `-r` (root). ### Comando de Linux chattr Con el programa `chattr` (*change attribute*) puedes asignar atributos a archivos o directorios. Utiliza `chattr` según la siguiente sintaxis para asignar un atributo: ```bash chattr [OPCIONES] +ATRIBUTO ARCHIVO ``` Para eliminar el atributo, sustituye el símbolo más por un símbolo menos. Por ejemplo, incluye el atributo `-i` (de inmutable) para blindar un archivo o un directorio frente a cambios. En el manual del programa `chattr`, podrás encontrar otros atributos y posibles opciones. ### Comando de Linux lsattr Si quieres ver qué atributos se definieron para un archivo o un directorio, puedes usar el comando `lsattr` (*list attributes*) según el esquema que sigue: ```bash lsattr [OPCIONES] ARCHIVO/DIRECTORIO ``` ### Comando de Linux chgrp El comando `chgrp` significa *change group* y se usa para cambiar el grupo de un archivo o un directorio, aunque se necesita estar en posesión de permisos de administrador para poder aplicarlo a un archivo o un fichero determinado. Además, solo se puede trabajar con los grupos a los cuales se pertenece. `chgrp` se utiliza siguiendo la siguiente estructura: ```bash chgrp [OPCIONES] GRUPO ARCHIVO ``` o ```bash chgrp [OPCIONES] GRUPO DIRECTORIO ``` La opción `-R` incluye en la operación a las subcarpetas y los archivos contenidos en un directorio. ### Comando de Linux man Con `man` se abren las páginas del manual (*man pages*) de tu distribución de Linux en la consola. Para ello se sigue el siguiente esquema: ```bash man [OPCIÓN] TEMA ``` Las man pages de Linux se distribuyen en 10 secciones temáticas: comandos de usuario, llamadas al sistema, biblioteca de funciones del lenguaje de programación C, formatos de archivo, archivos de configuración, juegos, miscelánea, comandos para administrar el sistema, funciones del kernel, comandos nuevos. ### Comando de Linux shutdown Los usuarios con permisos de administrador pueden utilizar el [comando shutdown de Linux](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/comandos-shutdown-de-linux/) para apagar el sistema. Su base la constituye la siguiente sintaxis: ```bash shutdown [OPCIONES] [TIEMPO] [MENSAJE] ``` Cuando se quiere apagar el sistema, existe la posibilidad de definir el momento exacto. Para ello, se puede introducir una hora exacta (`hh:mm`) o una cuenta atrás (`+m`). Otros usuarios activos en el sistema reciben un aviso de apagado que puede complementarse con un mensaje opcional. Si se añade al comando la opción `-r`, el sistema se reinicia después de apagarse. ### Comando top en Linux Con el comando `top` obtienes una lista dinámica de todos los procesos activos. Para ello utiliza este esquema: ```bash top [OPCIONES] ``` La salida de la información sobre los procesos se puede ajustar con ayuda de diversas opciones. El comando soporta, además, el uso de las siguientes teclas para ordenar la salida: - \[P\] = ordena la salida en función del uso de CPU - \[M\] = ordena la salida según el uso de memoria - \[N\] = ordena la salida numéricamente por PID - \[A\] = ordena la salida por edad - \[T\] = ordena la salida por tiempo utilizado de CPU - \[U USUARIO o UID\] = filtra la salida por el usuario Utiliza la tecla \[H\] para acudir a las páginas de ayuda y \[Q\] para abandonar la vista de los procesos. ### Comando de Linux lscpu Utiliza `lscpu` (*list cpu*) de esta forma para obtener datos sobre la CPU en la consola: ```bash lscpu [OPCIONES] ``` En el manual de tu sistema operativo puedes consultar todas las opciones que puedes utilizar con el comando. ### Comando de Linux lshw En este caso `lshw` equivale a *list hardware* y facilita información sobre los componentes de hardware. El comando `lshw` se utiliza siguiendo esta sintaxis: ```bash lshw [OPCIONES] ``` También este comando soporta diversas opciones con las cuales ajustar no solo el formato de salida (`-html`, `-xml`, -`short`, `-businfo`), sino también el detalle de la información de salida (`-sanitize` se usa para ocultar información sensible, p. ej.). ### Comando kill de Linux `kill` es un programa de la consola para cancelar y cerrar procesos. El comando se invoca según el siguiente esquema con una señal y el ID del proceso seleccionado: ```bash kill [OPCIONES] [-SEÑAL] PID ``` Las señales más habituales son: 1. `TERM`: impele a un proceso a que finalice por sí mismo (estándar) 2. `KILL`: fuerza la clausura de un proceso (por parte del sistema) 3. `STOP`: interrumpe un proceso 4. `CONT`: permite continuar un proceso interrumpido ### Comando de Linux killall En combinación con un término clave, el [comando de Linux `killall`](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/comando-killall-de-linux/) se utiliza para finalizar procesos cuyo nombre coincide exactamente con él (se cotejan los 15 primeros caracteres). ```bash killall [OPCIONES] [-SEÑAL] [PROCESO] ``` La opción `-e` (*--exact*) permite extender la comparación a todos los caracteres del nombre del proceso. ### Comando de Linux nice El comando `nice` asigna a un proceso durante el arranque un valor `nice` entre -20 y +19 que determina la forma como se distribuye la capacidad disponible del microprocesador. La franja mencionada equivale a los niveles de prioridad en Linux de 100 a 139. Un proceso con un valor `nice` de -20 tiene, de esta forma, una prioridad más elevada que un proceso con un valor `nice` de 19. Su sintaxis reza así: ```bash nice [OPCIÓN] [COMANDO] ``` Sin ninguna otra información, todos los procesos arrancan con un valor `nice` de 0. Con la opción `-n` se definen las prioridades de los procesos. Hay que tener en cuenta que las prioridades negativas solo se otorgan con derechos root. ### Comando de Linux pgrep El programa de la consola `pgrep` compara la lista de procesos activos con un término clave y, en caso de coincidencia, entrega los respectivos PID. La sintaxis básica de tal llamada es: ```bash pgrep [OPCIONES] Término ``` Por defecto, `pgrep` devuelve los PID de todos los procesos que contienen la palabra clave. Si la búsqueda se ha de delimitar a todas las coincidencias exactas, se utiliza la opción `-x`. Si además del PID también quieres solicitar el nombre del proceso, combina `pgrep` con la opción `-l`. De forma similar a `grep`, `pgrep` soporta palabras clave basadas en expresiones regulares. ### Comando de Linux con ps El [comando `ps`de Linux](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/comando-ps-de-linux/) entrega una lista de todos los procesos activos: ```bash ps [OPCIONES] ``` Si necesitas una salida más detallada utiliza `ps` con las opciones `-f` (detallado) o `-F` (muy detallado). En el manual del sistema operativo encuentras otras posibles opciones. ## Comandos de Linux adicionales de un vistazo ### Comandos básicos En esta categoría se incluyen todos los comandos de Linux básicos que se utilizan para **administrar el terminal**, con las que se puede limpiar la ventana de la consola, recuperar comandos anteriores desde la historia o finalizar la sesión. **1. exit** Con `exit` se finaliza la sesión actual y se cierra la consola. ```bash exit ``` También puedes usar el atajo de teclado \[Ctrl\] + \[D\] en su lugar. **2. help** El comando `help` se utiliza para mostrar una lista de todas las órdenes del sistema. Si introduces `help` en combinación con un comando shell obtienes una breve descripción del comando en cuestión. ```bash help COMMAND ``` **3. history** En Bash, los últimos 500 comandos introducidos en el terminal se guardan en el historial. Esta función sirve de ayuda al introducir órdenes en la consola y permite ejecutar de nuevo un comando introducido con anterioridad seleccionándolo con ayuda de las flechas del teclado y ejecutándolas de nuevo. También se puede examinar el historial en función de palabras clave con el atajo de teclado \[CTRL\] + \[R\]. Utilizando el comando sin opciones ni argumentos se obtiene la lista completa de comandos numerada. ```bash history ``` Para filtrar la salida se combina `history` a través de [Linux Pipe](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/pipes-linux/) con el programa `grep` (ver opciones de búsqueda) y una palabra clave. ```bash history | grep PALABRA CLAVE ``` ### Páginas de ayuda ¿No sabes cuáles son los pasos siguientes? A este respecto, Linux ofrece en el terminal páginas de ayuda y de documentación como las Unix Man Pages (Manual de Unix) y las páginas de información de GNU, las cuales contienen una exhaustiva descripción de todos los programas, comandos, archivos de configuración, formatos de archivo y funciones del kernel. Con el [comando de Linux `whatis`](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/comando-whatis-en-linux/) y `apropos` en la categoría de páginas de ayuda, cuentas con programas de líneas de comando que permiten examinar las páginas del manual del sistema operativo por palabras clave. **1. apropos**Con `apropos` se examinan los títulos y las descripciones de las páginas del manual de tu sistema operativo por palabras clave. Sigue el siguiente esquema: ```bash apropos [OPCIONES] PALABRA CLAVE ``` Este comando soporta diferentes opciones. Con la opción `-e` delimitas la búsqueda a correspondencias exactas, pero también puedes utilizar comodines (`-w` ‘TÉRMINO DE BÚSQUEDA’) y [expresiones regulares](https://www.ionos.com/es-us/digitalguide/paginas-web/creacion-de-paginas-web/regex/) (`-r`). **2. info** El comando`info` abre las páginas de información de GNU sobre un tema determinado. Normalmente equivalen al manual que se puede invocar con `man`, aunque a diferencia de este, contienen enlaces que facilitan la navegación en el manual. Utiliza esta sintaxis: ```bash info [OPCIÓN] TEMA ``` Si no indicas una opción ni un tema, accedes al menú principal del manual de GNU. **3. pinfo** Con `pinfo` cuentas con una versión del programa `info` que sigue el modelo del explorador de líneas de comandos Lynx y muestra las páginas de información con los enlaces destacados con colores. Para utilizar `pinfo` se sigue el mismo esquema sintáctico que con `info`: ```bash pinfo [OPCIONES] TEMA ``` **4. whatis**El programa `whatis` permite buscar por palabras clave en el manual. Para examinar el manual del sistema operativo en busca de una equivalencia exacta se llama al programa con el término de búsqueda. Si se encuentra una correspondencia, `whatis` responde con una breve descripción en el terminal. ```bash whatis [OPCIONES] PALABRA CLAVE ``` `whatis` (`-w '\*PALABRA CLAVE`) también soporta comodines y expresiones regulares (`-r`). ### Operaciones de directorio Se utilizan comandos de Linux para realizar operaciones en directorios, como crear, eliminar y gestionar directorios en tu sistema a través del terminal, así como para navegar por el árbol de directorios. Los comandos más importantes en esta categoría son `cd`, `ls`, `mkdir` y `rmdir`. ### Operaciones de Directorios Se utilizan comandos de Linux para realizar operaciones en directorios, como crear, eliminar y gestionar directorios en tu sistema a través del terminal, así como para navegar por el árbol de directorios. Los comandos más importantes en esta categoría son `cd`, `ls`, `mkdir` y `rmdir`. **1. chroot** El comando `chroot` (*change root*) se utiliza para ejecutar un comando en un directorio raíz diferente. Por ejemplo, `chroot` se utiliza para aislar programas críticos del resto del [sistema de archivos](https://www.ionos.com/es-us/digitalguide/servidores/know-how/sistemas-de-archivos/). Llamar al programa requiere privilegios de root y se basa en la siguiente fórmula: ```bash chroot DIRECTORIO COMANDO ``` **2. mkdirhier** Con `mkdirhier`, puedes crear jerarquías completas de directorios con una sola directiva de línea de comandos: ```bash mkdirhier [OPCIÓN] /home/user/directorio1/directorio2/directorio3 ``` Si ´directorio1´ y ´directorio2´ ya existen, ´mkdirhier´ solo crea ´directorio3´. De lo contrario, se crean los tres directorios. **3. tree** Mientras que `ls` solo lista el contenido de un directorio, el comando `tree` se puede utilizar para mostrar de forma recursiva toda la jerarquía de directorios como una estructura de árbol. El comando utiliza la siguiente sintaxis: ```bash tree [OPCIONES] [DIRECTORIO] ``` ### Operaciones en archivos Los comandos Linux de esta categoría permiten llevar a cabo diversas operaciones desde el terminal que atañen a los archivos y, utilizando comandos básicos como `cp`, `mv`, y `rm` , se pueden copiar, desplazar, renombrar o borrar archivos del sistema. **1. basename** Al comando `basename` se le indica una ruta a un archivo y devuelve su nombre sin la ruta. La sintaxis del comando se compone de: ```bash basename [OPCIONES] Ruta/al/archivo [SUFIJO] ``` El comando puede ser ampliado a varios archivos con diferentes opciones. **2. comm** Utiliza el comando `comm` para comparar por líneas archivos previamente ordenados (con `sort`, p. ej.). La invocación de este comando se fundamenta en la siguiente estructura sintáctica: ```bash comm [OPCIONES] ARCHIVO1 ARCHIVO2 ``` El comando `comm` soporta tres opciones: - -1 = ocultar líneas únicas del ARCHIVO1 - -2 = ocultar líneas únicas del ARCHIVO2 - -3 = ocultar todas las líneas que aparecen en ambos archivos **3. cut** El comando `cut` permite extraer el contenido de las líneas de texto de un archivo (log o CSV) por columnas. La sintaxis de este comando es: ```bash cut [OPCIONES] ARCHIVO ``` Para indicar la posición exacta del fragmento que se tiene que extraer se utilizan las opciones `-b` (posición de byte), `-c` (posición del carácter), `-d` (carácter de separación) y `-f` (campo). **4. dirname** `dirname` es lo contrario que `basename`: el comando permite extraer la parte de la ruta a un fichero sin mostrar su nombre. Su sintaxis es: ```bash dirname [OPCIONES]path/to/file ``` **5. file**Con `file` se puede obtener información sobre el tipo o formato de un archivo. Sigue el siguiente esquema: ```bash file [OPCIONES] ARCHIVO ``` **6. lsof** El [comando de Linux `lsof`](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/linux-lsof/) equivale a *list open files*, un programa de apoyo que muestra en el terminal información sobre los archivos abiertos ordenados en función del PID (ID de proceso). Para invocarlo se sigue el siguiente esquema: ```bash lsof [OPCIONES] ``` Dado que todos los sistemas tipo UNIX como Linux lo gestionan todo en archivos (“Everything is a file”), la lista que devuelve `lsof` es muy larga. Por eso suelen usarse opciones que concretan el resultado. **7. md5sum** Con ayuda del comando `md5sum` se pueden calcular y comprobar sumas de control MD5. **8. paste** De forma parecida a `cat`, el programa `paste` también muestra el contenido de los archivos en la salida estándar, pero mientras que `cat` los muestra de forma encadenada, `paste` los agrupa en columnas. El esquema básico de esta función es: ```bash paste [OPCIONES] ARCHIVO1 ARCHIVO2 ``` Con la opción `-d` se puede configurar individualmente el tipo de separador que se usa. Por defecto suele utilizarse la tabulación. Con la opción `-s` (de serial) se activa otro modo diferente en el cual todas las líneas del primer archivo de entrada se pegan en la primera línea de la salida. Los datos del resto de archivos de entrada se pegan a continuación en líneas de salida separadas. De esta forma, cada línea de la salida contiene únicamente el contenido de un archivo de entrada. **9. rename**`rename` permite cambiar el nombre de archivos y carpetas con ayuda de expresiones regulares (regex). Al contrario de `mv`, `rename` se presta así para modificar los nombres de varios archivos parcial o totalmente. La invocación de `rename` se realiza siguiendo el siguiente esquema: ```bash rename [OPCIONES] 'EXPRESIÓN_REGULAR' ARCHIVOS ``` En el caso de las sustituciones, las expresiones regulares siguen la siguiente sintaxis: ```bash s/PATRONDEBUSQUEDA/SUSTITUCIÓN/MODIFICADOR ``` **10. shred** `shred` es un comando que permite borrar archivos de forma permanente porque los reescribe de modo que, incluso contando con los mejores medios forenses, no se pueden restablecer. Este comando se invoca siguiendo este esquema básico: ```bash shred [OPCIONES] ARCHIVO ``` **11. sort** Con el comando `sort` se ordenan las listas de archivos y las salidas de programa en líneas numérica y alfabéticamente. Se invoca a `sort` siguiendo este esquema: ```bash sort [OPCIONES] ARCHIVO ``` Este método se puede complementar con opciones como `-n` (ordenar numéricamente), `-R` (ordenar de forma aleatoria) o `-r` (ordenar en orden inverso). **12. split** El comando `split` se utiliza para subdividir archivos. Sigue el siguiente esquema sintáctico: ```bash split [OPCIONES] [INPUT [PREFIJO]] ``` INPUT equivale al archivo que se ha de subdividir y PREFIJO hace las veces de prefijo del nombre del nuevo subarchivo. A la hora de cambiar su nombre se sigue el siguiente esquema: ```bash PREFIJOaa, PREFIJOab, PREFIJOac … ``` Si no se define ningún prefijo, `split` recurre al estándar `x`. Con la opción `-b` (bytes) se puede definir el tamaño de las partes en que se divide el archivo. Esto puede hacerse en bytes (b), kilobytes (k) o megabytes (m). Ejemplo: ```bash split -b 95m archivo.tgz split-archivo.tgz. ``` **13. stat** Con ayuda del comando `stat` (*status*) se puede obtener la fecha y la hora de los accesos y los cambios relativos a determinados archivos o directorios. Este comando sigue esta sintaxis: ```bash stat [OPCIONES] ARCHIVO ``` El formato de salida se puede configurar con opciones. **14. uniq** El comando `uniq` suele usarse junto con `sort` para limpiar líneas duplicqeqw en los archivos. En el siguiente ejemplo, se enlaza el comando `sort` con el comando `uniq` con la barra vertical (`|`) para seleccionar en primer lugar un archivo y a continuación para emitirlo sin líneas duplicadas: ```bash sort archivo.txt | uniq ``` ### Opciones de búsqueda Linux también dispone de diversos comandos para explorar el sistema desde el terminal. **1. find** Con `find` es posible [encontrar un archivo en Linux](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/comando-linux-find/). Se utiliza en base al siguiente esquema sintáctico: ```bash find [OPCIONES] [RUTA] [EXPRESIÓN_DE_BÚSQUEDA ][ACCIÓN] ``` El directorio que se indica en RUTA define el inicio de la búsqueda, de tal forma que se exploran tanto el directorio como sus subdirectorios. Si no se indica ninguno, `find` comienza a explorar desde el directorio en el que se está en ese momento (directorio actual). Las opciones permiten definir los criterios de búsqueda y las acciones. La acción predeterminada es `-print`, que muestra el resultado de la búsqueda en la salida estándar (normalmente la consola). Otras opciones permiten filtrar por nombre de archivo, tamaño de archivo, hora de acceso, etc. Estas opciones se enumeran en la página de manual correspondiente. **2. locate** El programa `locate` también permite buscar archivos desde el terminal, pero, al contrario que `find`, no se basa en el directorio de archivos, sino en una base de datos creada especialmente para ello y actualizada regularmente. Con ello `locate` entrega sus resultados mucho más rápido que `find`. Para buscar un determinado archivo en la base de datos se invoca a `locate` con esta sintaxis: ```bash locate PATRÓN_DE_BÚSQUEDA ``` El patrón puede contener metacaracteres que actúan de comodín (`*`). Si los escribes entre comillas el shell no los interpreta como metacaracteres de shell. **3. tre-agrep** También `tre-agrep` se utiliza para buscar cadenas de caracteres en los archivos de texto en base a patrones, pero, a diferencia de `grep`, no solo entrega coincidencias exactas, sino también resultados imprecisos (como cadenas que contienen pequeños errores tipográficos). El programa se apoya para ello en la biblioteca TRE. Su sintaxis coincide con la del comando grep: ```bash tre-agrep [OPCIONES] PATRÓN ARCHIVOS ``` Con las opciones se puede definir un número máximo de errores. En el ejemplo siguiente se indica el número máximo de errores que se toleran: ```bash tre-agrep -1 'Linux' test.txt ``` **4. updatedb**La búsqueda con `locate` solo es fiable si el archivo `/var/lib/locatedb` se mantiene constantemente actualizado. El comando `updatedb` permite actualizar la base de datos manualmente. Ten en cuenta que para ello necesitas derechos de administrador: ```bash Updatedb ``` **5. whereis** Con el comando `whereis` se pueden localizar los archivos binarios, de código fuente o del manual de ciertos programas. Su sintaxis general consiste en: ```bash whereis [OPCIONES] PROGRAMA ``` Con opciones se puede delimitar la búsqueda a ciertos tipos de archivo o directorio. **6. which** Para indagar el paradero del archivo binario de un programa se utiliza el comando `which`, el cual muestra la ruta al archivo. Este programa se invoca con la siguiente sintaxis: ```bash which [OPCIONES] PROGRAMA ``` En el modo estándar, `which` responde con el primer archivo que encuentra. Si se desea, la opción `-a` muestra todos los archivos que cumplen con el criterio de búsqueda. ### Información sobre los usuarios Utiliza los comandos de esta categoría para solicitar **información detallada sobre los usuarios registrados en el sistema**, así como sobre sus grupos y procesos. **1. finger** El comando `finger` muestra información sobre los usuarios y para ello se combina con el nombre del usuario en cuestión: ```bash finger [OPCIONES] [USUARIO] ``` Utiliza `finger` sin indicar un nombre de usuario para solicitar información sobre tu propia cuenta. **2. groups** Con `groups` el terminal enumera los grupos a los que pertenece una determinada cuenta de usuario. Cuando no se indica usuario, `groups` localiza todos los grupos a los que pertenece tu cuenta. Para ello, sigue el patrón que aparece: ```bash groups [OPCIONES] [USUARIO] ``` **3. id** El comando `id` entrega los códigos de los usuarios y grupos de la cuenta de usuario seleccionada. ```bash id [OPCIONES] [USUARIO] ``` Añadiendo opciones se puede limitar la búsqueda **4. last** Utiliza el comando `last` según el esquema que indicamos abajo para obtener una lista de los últimos usuarios que han iniciado una sesión, junto con la hora de su inicio y final de sesión: ```bash last [OPCIONES] [USUARIO] ``` Para ello, la consola solicita información del archivo `wtmp` en `/var/log/wtmp`. Si la búsqueda se refiere a una cuenta específica, se añade el nombre del usuario al comando. **5. w** En este caso, `w` devuelve una lista de todos los usuarios con sesión abierta y todos los procesos que están ejecutando. Si añades un nombre de usuario, la búsqueda se limita a este usuario: ```bash w [OPCIONES] [USUARIO] ``` De nuevo puedes personalizar la exhaustividad y el formato de la salida con opciones. **6. who** El comando `who` muestra información sobre los usuarios activos en ese momento en el sistema si se utiliza según esta sintaxis: ```bash who [OPCIÓN] [ARCHIVO] ``` Por defecto, `who` extrae los datos sobre el usuario actual del archivo `/var/run/utmp`, pero opcionalmente también se pueden indicar estos archivos a continuación como fuente de la información. **7. whoami** Utiliza el comando `whoami` para obtener tu propio nombre de usuario. ```bash whoami [OPCIONES] ``` ### Gestión de cuentas de usuario Linux ofrece toda una serie de programas con los cuales se pueden crear, eliminar y gestionar cuentas de usuario y grupos a través del terminal. Estos aparecen en el siguiente listado general de **comandos de Linux para la administración de cuentas de usuario**, categoría en la que también se incluyen los comandos que permiten abrir programas con los derechos de otros usuarios, incluidos los de administrador. **1. chfn** El comando `chfn`, equivalente a *change finger*, permite editar la información adicional de una cuenta de usuario, en la que se incluyen datos como el nombre real del usuario, el número de oficina y los números de teléfono privado y de trabajo. La sintaxis general de `chfn` sigue esta estructura: ```bash chfn [OPCIÓN "NUEVO VALOR"] [USUARIO] ``` Con las opciones `-f` (nombre real), `-r` (número de oficina), `-w` (número oficial) y `-h` (número privado) se define qué información del usuario se sustituye por un nuevo valor. **2. chsh** El comando `chsh` (*change Shell*) cambia el login shell de un usuario. Para ello se sigue el siguiente esquema: ```bash chsh [OPCIONES] USUARIO ``` Puedes utilizar la opción `-s` para cambiar el login shell de una cuenta de usuario. **3. deluser** El programa de líneas de comandos `deluser` borra todas las entradas de una cuenta de usuario de los archivos de cuentas del sistema. `deluser` solo se puede utilizar con derechos admin y se orienta por el siguiente esquema: ```bash deluser [OPCIONES] USUARIO ``` Si se tiene la intención de borrar todos los archivos del usuario en el directorio principal, entonces se utiliza el comando junto con la opción `--remove-home`, y si se trata de eliminar todos los archivos del usuario del sistema, se utiliza la opción `--remove-all-files`. **4. delgroup** El comando `delgroup` (*delete group*) se utiliza para borrar grupos de usuarios y requiere derechos root. Sigue esta sintaxis: ```bash delgroup [OPCIONES] GRUPO ``` **5. groupmod** Con `groupmod` se puede configurar tanto el nombre como el GID de un grupo de usuarios. El comando se utiliza como administrador siguiendo el siguiente esquema: ```bash groupmod OPCIONES GRUPO ``` Si utilizas `groupmod` con la opción `-g` puedes cambiar el GID y con la opción `-n`, el nombre del grupo. **6. newgrp** El comando newgrp (*new group*) es un comando que permite a los usuarios cambiar el ID de su grupo sin tener que cerrar e iniciar sesión de nuevo. La sintaxis general de este comando es: ```bash newgrp [-] [GRUPO] ``` Si `newgrp` se acompaña del parámetro opcional \[-\], tras el cambio de grupo tiene lugar un reinicio del entorno del usuario, como si se abriera una nueva sesión. Los usuarios que utilizan el comando sin indicar ningún grupo se ven desplazados al grupo estándar que se ha configurado en `/etc/passwd`. **7. su** El comando `su` también permite cambiar de usuario temporalmente para realizar llamadas al sistema con los permisos de otro usuario, pero a diferencia de `sudo`, en este caso las órdenes no se ejecutan directamente, sino que es necesario cambiar de identidad porque su no solicita la contraseña del usuario que invoca, sino la del usuario cuyos derechos se quieren suplantar. La sintaxis general del comando obedece a este orden: ```bash su [OPCIONES] [USUARIO] ``` Una solicitud sin nombre de usuario selecciona a `root` como usuario. **8. usermod** El comando `usermod` ofrece la posibilidad de editar cuentas ya creadas. Utiliza `usermod` con derechos raíz según el siguiente esquema: ```bash usermod [OPCIONES] USUARIO ``` Con ayuda de las opciones defines cuáles son los cambios que se han de realizar. Por ejemplo, con `-l NUEVO_NOMBRE` puedes cambiar el nombre de usuario. Para encontrar más opciones, accedede a la página correspondiente del manual. ### Gestión del sistema En esta categoría desciframos los comandos de Linux para la administración del sistema. Con ellos puedes, por ejemplo, reiniciar o apagar el sistema desde la consola e incluso programar estas acciones. **1. logger** Utiliza `logger` para la siguiente sintaxis: ```bash logger "MENSAJE" ``` El fichero de log del sistema se encuentra en `/var/log/syslog`. **2. reboot** `reboot` es un comando que permite reiniciar el sistema, para lo cual se necesita disponer de permisos root. ```bash reboot [OPCIONES] ``` **3. rtcwake** En el caso de `rtcwake`, se trata de un comando que permite programar el inicio, la suspensión y el apagado del ordenador. Se escribe así: ```bash rtcwake [OPCIONES] [MODO] [Tiempo] ``` En MODO selecciona el modo (`-m`) en que el sistema ha de entrar por un determinado periodo (`-s para tiempo en segundos`). Opcionalmente también puedes “despertar” al sistema en un punto definido (`-t para tiempo Unix`). ### Información del sistema Esta categoría recoge todos los programas de líneas de comandos con los cuales se **solicitan información y mensajes de estado** del sistema para hacerse una idea global de su estado general. **1. date** El comando `date` te permite conocer la fecha y la hora del sistema. ```bash date [OPCIONES] [FORMATO DE SALIDA] ``` Si al invocar un programa necesitas trabajar con una fecha concreta (`rtcwake`), la opción `-d` (fecha) te permite definirla. El comando soporta también otras opciones para cambiar el formato de fecha y hora. **2. df** Escribe el comando `df` (*disk free*) en el terminal siguiendo el esquema: ```bash df [OPCIONES] ``` Cuando se utiliza el comando combinado con un determinado archivo, el sistema responde con el espacio libre en disco en la partición donde se aloja el archivo. La opción `-l` (*local*) delimita `df` a sistemas de archivos locales. También soporta opciones con las cuales configurar el formato de salida. **3. dmesg** El programa `dmesg` (*display message*) muestra los mensajes de diagnóstico del buffer del kernel y permite localizar errores en el hardware o el driver. Utiliza `dmesg` con esta sintaxis: ```bash dmesg [OPCIONES] ``` La salida `dmesg` contiene todos mensajes generados en el arranque del sistema y es consecuentemente largo. Esto hace que se acompañe a menudo de un pager como `more`, `less`, or `tail`. **4. free** El comando `free` muestra la ocupación de la memoria con esta sintaxis: ```bash free [OPCIONES] ``` Como salida obtienes dos conceptos: `Mem` (*Memory*) y `Swap`. `free` también soporta la opción `–h`, con la que obtienes la información en un formato legible. **5. hostname** Utiliza el comando `hostname` con esta sintaxis para que el terminal muestre el nombre DNS del sistema. ```bash hostname [OPCIONES] ``` **6. uname** El comando `uname` significa `unix name` y se utiliza para solicitar información sobre el kernel. El comando soporta diversas opciones con las cuales filtrar la salida de la información. ```bash uname [OPCIONES] ``` **7. uptime** Para averiguar cuánto tiempo lleva el sistema ejecutándose desde el último arranque sin ser reiniciado, utiliza el comando `uptime` con esta sintaxis: ```bash Uptime ``` **8. vmstat** Con ayuda de la herramienta de control `vmstat` se puede solicitar información sobre la memoria virtual, acerca de procesos de escritura y lectura en el disco duro, así como sobre la actividad del procesador central. Introduce vmstat` con este esquema para obtener los valores medios desde el último arranque del sistema: ```bash vmstat [OPCIONES] ``` El comando `vmstat` también ofrece un modo de monitorización continuo con el cual se pueden solicitar los valores dentro de un intervalo de tiempo en segundos tan a menudo como sea necesario. ```bash vmstat [OPCIONES] [INTERVALO [REPETICIONES]] ``` ### Información del hardware Los comandos Linux englobados en esta categoría entregan **datos detallados sobre los componentes de hardware** sobre los que se ejecuta el sistema. **1. lspci** Utiliza `lscpu` (*list cpu*) de esta forma para obtener datos sobre la CPU en la consola. ```bash lscpu [OPCIONES] ``` En el manual de tu sistema operativo puedes consultar todas las opciones que puedes utilizar con el comando. **2. lsusb**Si quieres obtener información detallada sobre los dispositivos USB, entonces introduce el comando `lsusb` (*list usb*) en el terminal de esta forma: ```bash lsusb [OPCIONES] ``` En el manual del sistema operativo encuentras también las opciones compatibles con este comando. ### Gestión de procesos En Linux, se denominan procesos a las instancias de un programa en ejecución. Los siguientes comandos pertenecen al repertorio estándar de la gestión de procesos y **permiten supervisarlos cómodamente desde el terminal** e intervenir si es necesario. **1. chrt** Con `chrt` estamos ante un programa para el control avanzado de procesos que permite averiguar y configurar los atributos de tiempo real (reglas de scheduling o planificación de procesos y prioridades) de procesos activos o ejecutar comandos y sus argumentos con determinados atributos de tiempo real. Se escribe con esta sintaxis: ```bash chrt [OPCIONES] [PRIORIDAD] PID/COMANDO [ARGUMENTOS] ``` Para descifrar los atributos de tiempo real de procesos determinados utiliza `chrt` sin indicar ninguna prioridad junto con la opción `-p`. Con la ayuda de opciones, `chrt` también permite establecer o definir la regulación de la programación de procesos en ejecución o recién iniciados. Encontrará más información al respecto en la entrada man correspondiente. **2. ionice** El comando `ionice` se utiliza para influir sobre la prioridad de un proceso que utiliza la interfaz I/O del kernel. La sintaxis general del comando es: ```bash ionice [OPCIONES] COMANDO ``` Para poder invocar a `ionice` es necesario contar con permisos de administrador. El comando distingue tres clases de planificación y estas se transmiten con la opción `-c` y el valor, que puede ir del 1 al 3: - 1 = Real Time (tiempo real): la operación de E/S se ejecuta de inmediato. - 2 = Best Effort (mejor esfuerzo): la operación de E/S se ejecuta tan pronto como sea posible. - 3 = Idle (reposo): la operación de E/S solo se ejecuta cuando no haya ningún otro proceso que requiera tiempo de E/S. **3. nohup** Normalmente, cuando un usuario cierra una sesión en la consola con `exit`, por ejemplo, todos los procesos dependientes finalizan automáticamente. El [comando de Linux `nohup`](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/comando-de-linux-nohup/) (*no hangup*) disuelve a un proceso de la sesión en curso de forma que puede seguir activo aun cuando el usuario ha cerrado su sesión. ```bash nohup COMANDO ``` **4. pidof** En el caso del programa `pidof`, se obtiene de la consola los números de identificación de todos los procesos de un programa. Solicita los PID con `pidof` siguiendo este esquema: ```bash pidof [OPCIONES] PROGRAMA ``` Cuando solo se quiere obtener el ID del primer proceso, se combina `pidof` con la opción `-s` (*single shot*). **5. pdkill** Como `kill`, `pkill` también envía una señal a un proceso determinado, aunque el direccionamiento no tiene lugar solamente con el PID, sino con un término clave que se compara con el nombre de los procesos activos y puede ser formulado como expresión regular. `pkill` también envía la señal estándar TERM si no se define cualquier otra señal. La sintaxis general del comando reza: ```bash pkill [OPCIONES] [-SEÑAL] [TÉRMINO] ``` Gracias a diversas opciones, podemos limitar el comando a los procesos de un determinado usuario (`-U UID`), a los procesos hijo de un proceso padre (`-P PID`) o a los procesos recientes (`-n`) o a los más antiguos (`-o`). **6. pstree** Utiliza `pstree` para obtener una lista en forma de árbol de todos los procesos en activo en la actualidad. Sigue la siguiente sintaxis: ```bash pstree [OPCIONES] ``` Utilizando diversas opciones puedes definir el formato y la amplitud de la salida. **7. renice** El comando `renice` permite modificar la prioridad de un proceso activo. Se invoca con esta sintaxis: ```bash renice PRIORIDAD [OPCIONES] ``` **8. sleep**El comando sleep de Linux se utiliza para interrumpir por un periodo determinado de tiempo la sesión actual en la consola. La sintaxis general del comando reza: ```bash sleep CIFRA[SUFIJO] ``` Si invocas a `sleep` sin sufijo, la cifra indicada se interpreta como franja en segundos (s), pero también se cuenta con la posibilidad de interrumpir la sesión durante unos minutos (m), unas horas (h) o incluso durante días (d). **9. taskset** En el caso de `taskset` nos encontramos ante un comando para el control ampliado de procesos que se utiliza en sistemas con procesadores multinúcleo para asignar procesos o programas a los núcleos. Este comando se realiza con permisos de administrador y utiliza uno de los siguientes esquemas: ```bash taskset [OPCIONES] MÁSCARA ORDEN taskset [OPCIONES] -p PID ``` La asignación de procesos y órdenes a un núcleo de la CPU tiene lugar utilizando una máscara de bits hexadecimal. Dado que la asignación a través de máscaras de bits no es muy intuitiva, `taskset` se suele usar junto con la opción `-c` (--cpu-list), que permite una asignación numérica de los procesadores (es decir, 0, 5 7, 9-11). ### Pager Para mantener la perspectiva también en el caso de archivos de varias páginas, los comandos de esta categoría denominada **Pager** permiten seleccionar las partes que se quieren mostrar en el terminal e incluso hojear los archivos en el modo interactivo. **1. head** El [comando de Linux `head`](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/linux-head/) se utiliza para mostrar la primera parte de un archivo. Su sintaxis general reza así: ```bash head [OPCIONES] Archivo ``` Utiliza la opción `-n NÚMERO_LÍNEAS` para definir cuántas líneas, a partir de la primera, se han de mostrar en la consola. **2. less** El comando de Linux less muestra el contenido de un archivo de texto en la consola.Su sintaxis general es la siguiente: ```bash less [OPCIONES] ARCHIVO ``` La salida tiene lugar en modo interactivo de forma automática, lo que le permite al usuario hojear el documento o explorarlo con palabras clave. Con la techa \[Q\] se cierra el modo de lectura interactiva —en el manual del programa encuentras más atajos de teclado u opciones disponibles para este comando. **3. tail** Mientras que `head` muestra por defecto las 10 primeras líneas de un archivo, `tail` muestra las 10 últimas. Ambos pager se utilizan con el mismo esquema (ver `head`). ### Editores Con Linux no es necesario utilizar un programa de edición de textos para modificar archivos de configuración, editar fragmentos de código o escribir notas cortas, pues es posible abrir **editores de texto simples** en el terminal. A continuación, presentamos tres comandos que deberías conocer. **1. emacs** *Emacs* es un editor de texto multiplataforma que se puede ampliar con una interfaz de programación. Arranca por defecto con una interfaz gráfica de usuario, pero si se escribe la opción `--no-window-system` también puede abrirse en el terminal. ```bash emacs --no-window-system ``` Emacs cuenta con un tutorial integrado al que puedes acceder con el atajo de teclado \[CTRL\] + \[H\], \[T\]. **2. nano** *Nano* es un editor de texto basado en terminal. Aun cuando ofrece una paleta de funciones más reducida que otros editores comparables (como *Vim*), se diferencia de este por una mayor facilidad en el uso. Su sintaxis básica reza: ```bash nano [OPCIONES] ARCHIVO ``` El comando abre el archivo solicitado en una ventana de edición en el terminal. Si invocas a nano sin nombre de archivo se crea un archivo de texto nuevo que se almacena en el directorio actual. **3. vim** En el caso de Vim (*Vi Improved*) se trata de un desarrollo ulterior del editor *Vi* al que supera con numerosas extensiones, como el resaltado de sintaxis, un amplio sistema de ayuda, scripting nativo, autocompletado de código y una selección de texto visual. Este programa de código abierto ofrece diferentes modos operativos para la edición de archivos meramente de texto y se puede utilizar tanto en el terminal como en una aplicación portátil con interfaz gráfica de usuario (*GVim*). Su campo central de aplicación es la edición de código de programa. Iniciado en la consola, Vim se utiliza con el teclado. Normalmente se invoca al comando con un archivo de texto siguiendo este esquema: ```bash vim [OPCIONES] ARCHIVO ``` Vim ofrece con el programa `vimtutor`, que también se inicia en la línea de comandos, una introducción exhaustiva en Vim. Nuestro artículo sobre [editor de Linux Vim](https://www.ionos.com/es-us/digitalguide/servidores/herramientas/editores-linux-como-editar-codigo-con-vim/) sirve también para profundizar en la instalación del programa y en sus diferentes modos operativos. ### Gestión de redes También es posible **gestionar redes** en el terminal utilizando Linux. Ya se trate de examinar una conexión, de solicitar información al DNS, de configurar interfaces o de enviar archivos a otro ordenador, con los siguientes comandos basta una línea para llevar a cabo tu propósito. **1. arp** El comando `arp` permite abrir y editar la memoria caché del [ARP](https://www.ionos.com/es-us/digitalguide/servidores/know-how/arp-resolucion-de-direcciones-en-la-red/) de tu sistema operativo. Si lo utilizas sin modificador `arp`devuelve el contenido de la tabla del ARP en el terminal. ```bash arp [OPCIÓN] ``` Puedes usar distintas opciones para delimitar el resultado obtenido o para borrar y crear entradas: - `-a HOST` = Limitar la salida a las entradas de un determinado [host name](https://www.ionos.com/es-us/digitalguide/hosting/cuestiones-tecnicas/hostname/) o de una dirección IP: - `-s HOST DIRECCIÓN_MAC` = Crear una entrada ARP especificando el nombre de host y la dirección MAC - `-d HOST` = Borrar una entrada APR **2. iw** El programa `iw` se utiliza para configurar interfaces inalámbricas y se ha consolidado como la alternativa más reciente a `iwconfig`. Este comando se fundamenta en una sintaxis parecida a la de `ip`: ```bash iw [OPCIONES] OBJETO [COMANDO] ``` Algunos objetos que se pueden usar con iw son: - dev NOMBRE\_DE LA\_INTERFAZ = Interfaz de red - phy NOMBRE\_DEL\_DISPOSITIVO = Dispositivo inalámbrico (vía nombre) - phy#ÍNDICE\_DEL\_DISPOSITIVO = Dispositivo inalámbrico (vía índice) - reg = Agente regulatorio para configurar la región y el país En la entrada correspondiente del manual, se pueden acceder a una presentación de los comandos y las opciones. **3. nslookup** Como `dig`, `nslookup` también sirve para resolver nombres. El comando está disponible en dos modos operativos: interactivo y no interactiv. Para iniciar nslookup en el modo no interactivo se invoca el programa en combinación con un nombre de host o una direccion IP. ```bash nslookup [OPCIONES] [HOST/IP ] ``` Para iniciar el modo interactivo, se introduce el comando `nslookup` en el terminal sin ninguna información adicional y, a continuación, se incluyen los nombres de host o direcciones IP para mostrar las direcciones IP o los nombres de host asociados. Dado que el comando está **oficialmente obsoleto**, se recomienda a los usuarios que utilicen `dig` en su lugar. **4. rsync** El comando `rsync` permite sincronizar archivos de forma local o en una red. Con este fin se comparan primero el tamaño y la fecha de los cambios de los archivos en cuestión. La sintaxis del comando reza: ```bash rsync [OPCIONES] ORIGEN DESTINO ``` El comando `rsync` suele ejecutarse con la opción `-a`, que es la responsable de la copia de todos los subdirectorios así como de los enlaces simbólicos junto con los derechos de usuario. **5. scp** Con [el comando de Linux `scp`](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/scp-de-linux/) (*secure copy*) dispones de otro programa para transferir datos de forma segura en la red: `scp` copia datos de un ordenador a otro utilizando también para ello el protocolo de red SSH. El programa cliente funciona casi como la opción `cp`, aunque se utiliza en todos los sistemas con esta sintaxis: ```bash scp [OPCIONES] ARCHIVO [[user@]remote_host:]RUTA ``` A la indicación de la ruta del ordenador le preceden el nombre de usuario y el nombre del host remoto. Los archivos locales se pueden direccionar mediante rutas relativas o absolutas. Ejemplos: ```bash scp /home/max/images/image.jpg max@example.com:/home/max/archiv ``` Gracias a otras opciones puedes configurar el modo de la transferencia y el cifrado. **6. tty** El comando `tty` muestra el nombre de archivo del terminal definido como entrada estándar. La sintaxis general del comando reza: ```bash tty [OPCIONES] ``` ### Archivar y comprimir Linux facilita diversas tecnologías con el fin de comprimir y empaquetar archivos, aunque cabe tener en cuenta que **no siempre un proceso de archivado implica una compresión**. Por ejemplo, el programa para archivar ficheros `tar` suele utilizarse en combinación con programas de compresión como `gzip`, `bzip2` o `xz`. **1. gzip** En el caso de `gzip`, estamos ante un programa con el cual se pueden comprimir y descomprimir archivos cómodamente en el terminal. Su sintaxis general sigue esta estructura: ```bash gzip [OPCIONES] ARCHIVOS ``` Debes tener en cuenta que `gzip` borra por defecto el archivo original cuando lo empaqueta, algo que, por otro lado, puedes evitar con ayuda de la opción `-k`. El programa también puede ser empleado sobre varios archivos al mismo tiempo: cada archivo inicial se convierte a un archivo `gz` independiente entonces. Para escribir varios archivos en un fichero comprimido común se utiliza gzip junto con el programa de archivado `tar`. Si se trata de descomprimir un archivo gz, se combina el comando `gzip` con la opción `-d` o se utiliza el comando gunzip. **2. bzip2** Una alternativa popular a `gzip` lo constituye el programa de líneas de comandos `bzip2`. Utilizando la misma sintaxis que aquel, este se basa sin embargo en un proceso de compresión en tres fases que posibilita un mayor grado de compresión. Los archivos que han sido comprimidos con bzip2 llevan la terminación `.bz2`. Utiliza `bzip` con este esquema para comprimir archivos: ```bash bzip2 [OPCIONES] ARCHIVOS ``` `bzip2` también se puede aplicar en archivos `tar`. La descompresión tiene lugar aquí de forma análoga a `bzip` con la opción `-d`. **3. xz** El comando `xz` convierte archivos en el formato de compresión de datos homónimo. Para invocar el programa se sigue el mismo esquema que con `gzip` y `bzip2`. ```bash xz [OPCIONES] ARCHIVOS ``` Los archivos comprimidos con `xz` adoptan la terminación `.xz`. La descompresión tiene lugar también con la opción `-d` (como en `gzip` y `bzip`). De forma alternativa también se puede usar el comando `unxz`. Al igual que los archivos `gz` y `bz2`, los archivos `xz` tampoco se archivan. Cuando se quiere escribir varios archivos en el mismo archivo comprimido `xz` también se ha de recurrir a la herramienta de archivado `tar`. **4. cpio** `cpio` (*copy in, copy out*) es un programa de archivado con el que se escriben datos en un archivo (.cpio) y se extraen de él. ### Gestión de particiones Cuando se trabaja con Linux, para poder acceder a un sistema de ficheros residente en una partición diferente, este ha de estar integrado en la estructura de directorios del sistema operativo. A este procedimiento se le denomina “**montar**” una partición y puede llevarse a cabo en la interfaz gráfica de usuario. Utilizando el terminal de líneas de comandos, el usuario dispone también de programas como `lsblk`, `blkid` y `mount` , con los cuales puede solicitar datos sobre los dispositivos de bloque (*block devices*) conectados y montarlos o desmontarlos según la necesidad. **1. lsblk** Con el comando `lsglk` (*list block devices*) se obtiene una vista de todos los dispositivos y particiones incorporados al sistema operativo como esquema arbóreo (no tienen que estar necesariamente montados). ```bash lsblk [OPCIONES] ``` La salida se puede personalizar con ayuda de la opción `-o` (*--output*) y una lista de los atributos deseados para solicitar datos adicionales como el número de identificación (UUID), el tipo de sistema de archivos (FSTYPE) o el estado (STATE). En la configuración estándar no se tienen en cuenta los dispositivos vacíos, pero sí se deben incluir en la vista general se combina `lsblk` con la opción `-a` (*--all*). Para solicitar información sobre un determinado dispositivo se utiliza el siguiente esquema: ```bash lsblk [OPCIONES] DISPOSITIVO ``` **2. blkid** `blkid` también facilita información sobre los dispositivos conectados al hardware de forma similar a como lo hace `blk`. Usando el comando con el siguiente esquema se solicita el número de identificación (`UUID`) y el tipo de sistema de archivos (`TYPE`) de todos los dispositivos de bloque conectados: ```bash blkid [OPCIONES] ``` Con la opción `-o` y el valor `list` se obtiene la salida en forma de tabla. ```bash blkid -o list ``` ### Miscelánea A continuación, se describen algunos comandos que no se incluyen en ninguna de las categorías enumeradas hasta ahora. **1. alias** La interacción con el shell se realiza normalmente mediante comandos que pueden utilizarse para llamar a **programas de línea de comandos** del mismo nombre. Se utiliza una llamada a programa para cada acción que se quiera realizar a través del terminal. El [comando de Linux `alias`](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/comando-alias-de-linux/) te permite definir nombres cortos para las llamadas a programas. Utiliza `alias` siguiendo el esquema que se presenta a continuación: ```bash alias APODO = 'COMANDO' ``` Sustituye COMANDO con la línea de comandos, incluyendo las opciones. Esto enlazará la cadena insertada para el marcador de posición APODO. **2. at** Con el comando `at` según este esquema se programa la ejecución de una determinada orden: ```bash at FECHA HORA ``` A continuación, se indica el comando y se cierra el modo interactivo con \[CTRL\] + \[D\]. **3. cal**Utilizando `cal` según el esquema que sigue se obtiene una vista de calendario en el terminal: ```bash cal [OPCIONES] [[MES] Año] ``` **4. pr** Con el programa de líneas de comando `pr` se preparan archivos para su impresión. Sigue para ello la siguiente sintaxis: ```bash pr [OPCIONES] Archivo ``` En la configuración estándar `pr` genera una cabecera que contiene el nombre del archivo, la fecha actual y el número de página. **5. script** Con el comando `script` se puede grabar una sesión en el archivo `typescript`. Si en él figura una grabación de una sesión precedente, se sobrescribe. El registro de la sesión comienza automáticamente cuando se invoca el programa: ```bash script ``` Utiliza el atajo de teclado \[CTRL\] + \[D\] para finalizar la grabación.Si en lugar de `typescript`se prefiere registrar la sesión en un archivo diferente, se introduce el comando `script` junto con el nombre de archivo o la ruta. **6. seq** `seq` permite obtener una serie de números en la salida estándar, para lo cual se define un valor inicial, otro final y eventualmente el tipo de incremento. ```bash seq [OPCIONES] VALOR INICIAL INCREMENTO VALOR FINAL ``` **7. tasksel** Con el comando `tasksel` se obtiene soporte para la instalación de aplicaciones estándar como un servidor de correo, DNS, OpenSSH o LAMP. Si utilizas esta herramienta, todos los paquetes y programas necesarios para una determinada tarea se instalan automáticamente en la secuencia correcta. Con la opción ´–list-tasks´, ´tasksel´ muestra una lista de todas las aplicaciones estándar disponibles. ```bash tasksel --list-tasks ``` Si se desean obtener datos adicionales sobre una aplicación de la lista, se acompaña el comando de la opción `--task-desc` y la información correspondiente. Si deseas que el terminal muestre todos los paquetes que pertenecen a la tarea “mail-server”, utiliza el comando con la opción `--task-packages`. La instalación de todos los paquetes de una aplicación estándar se inicia con ayuda del subcomando `install`. Para ello necesitas derechos admin. **8. tee** Con el [comando de Linux `tee`](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/comando-tee-en-linux/) nos encontramos ante un comando con el cual se puede duplicar la salida de un programa. Con este fin se redirige una salida hacia la salida estándar y otra se escribe en el archivo indicado en el comando `tee`. Esta es su sintaxis: ```bash tee [OPCIONES] ARCHIVO ``` `tee` suele ir acompañado de la barra vertical (`|`) como operador: ```bash ls | tee ejemplo.txt ``` **9. time** Utiliza el comando `time` según el esquema que sigue para obtener información sobre el tiempo de ejecución de los programas que inicias en el terminal: ```bash time [OPCIONES] Comando [ARGUMENTOS] ``` **10. tr** Utiliza `tr` para borrar caracteres o sustituirlos por otros. Para ello `tr` lee el flujo de datos de la entrada estándar y los escribe en la salida estándar en función de la modificación deseada. En caso de sustitución, `tr` se utiliza con dos argumentos: ```bash tr OPCIÓN CANTIDAD1 CANTIDAD2 ``` El segundo argumento (CANTIDAD2) sustituye al primero (CANTIDAD1). Para borrar una secuencia de caracteres se utiliza la opción `-d` y se indica la secuencia como argumento. ```bash tr -d SECUENCIA ``` Este comando suele combinarse con los operadores mayor que o menor que para llevar a cabo los ajustes en los archivos. ```bash tr 'a-z' 'A-Z' < ejemplo1.txt > ejemplo2.txt ``` Aquí, `tr` lee el contenido del archivo `ejemplo1.txt`, sustituye las minúsculas de la a a la z por mayúsculas y escribe la salida en el archivo `ejemplo2.txt`. **11. wall** El comando `wall` permite enviar un mensaje a todos los usuarios activos en el sistema en un momento determinado. Para invocar al programa se escribe en la consola: ```bash wall ``` Confirma con \[Enter\] y escribe tu mensaje, que también puedes confirmar con \[Enter\] y enviar con el atajo de teclado \[CTRL\]+\[D\]. Todos los usuarios activos en ese momento en el sistema reciben la notificación en el terminal como mensaje broadcast. Ten en cuenta que para poder recibir mensajes de otros usuarios tienes que permitir su acceso de escritura a tu terminal. Utiliza para ello el comando `mesg`: Si quieres enviar contenido de un archivo a todos los usuarios activos, utiliza `wall` con un operador de redirección < y el nombre del archivo correspondiente: ```bash wall < NOMBRE DEL ARCHIVO ``` **12. watch** Con el comando `watch` se puede ejecutar un comando en periodos regulares y se le invoca por medio de la sintaxis: ```bash watch [OPCIONES] COMANDO ``` El intervalo de tiempo en el cual se ha de ejecutar el comando enviada con `watch` se define con la opción `-n` (en segundos). Se finaliza `watch` con la combinación \[CTRL\] + \[C\]. **13. wc** El [comando de Linux `wc`](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/comando-de-linux-wc/) (*word count*) proporciona la cantidad de líneas, palabras, letras, caracteres o bytes de un archivo de texto cuando se necesita. ```bash wc [OPCIONES] ARCHIVO ``` Si `wc` se escribe sin opción, la salida equivale al esquema `LÍNEAS PALABRAS CARACTERES ARCHIVO`, pero el comando soporta otras opciones con las que filtrar la salida: `-l (líneas)`, `-C (bytes)`, `-m (caracteres)`,`-L (longitud de la línea más larga)` y `-w (palabras)`. **14. xargs** El [comando de Linux `xargs`](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/comando-xargs-de-linux/) permite entregar la salida de un comando a otro comando como argumento. Generalmente se utiliza para ello la barra vertical (`|`) como operador de redirección. `xargs` se utiliza con esta sintaxis: ```bash COMANDO1 | xargs [OPCIONES] COMANDO2 ``` El comando `xargs` se utiliza, por ejemplo, con `find`: en el siguiente ejemplo, `find` determina todos los archivos del directorio actual que se ajustan al patrón `*.tmp` y emite sus nombres en la salida estándar, donde se entregan al comando `rm` como argumento. ```bash $ find . -name '*.tmp' | xargs rm ``` Esta lista de comandos de Linux no aspira a convertirse en una lista completa de todos ellos, sino que solo abarca los comandos estrictamente fundamentales y explica algunos ejemplos de su aplicación diaria en sistemas unixoides. Si buscas una descripción completa de todos estos comandos, así como de los demás, tendrás que dirigirte a las páginas del manual de tu sistema operativo, del cual encuentras una versión online en el proyecto [Linux man-pages](https://www.kernel.org/doc/man-pages/ "Linux man-pages project by Michael Kerrisk") de Michael Kerrisk. This is a markdown version of: [https://www.ionos.com/es-us/digitalguide/servidores/configuracion/comandos-de-linux-la-lista-fundamental/](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/comandos-de-linux-la-lista-fundamental/) for AI/LLM consumption.