15 comandos Linux para usar la Terminal como un Pro

Intro a la Linux CLI – Parte I

Hola Fronters, Gabriel aquí!!! Espero que estén muy bien!!! En este HowTo aprenderemos quince comandos (y uno extra al final), que nos convertirá en verdaderos SysAdmin Linux versátil en la terminal a nivel pro.

Linux hoy por hoy, y desde hace muchos años, ha sido el sistema operativo por excelencia en servidores. Quizás y sin temor a equivocarme, más del 90% de los servidores existentes en internet son Linux, pero ¿por qué esto?

Te daré cuatro razones fundamentales para argumentar este punto:

Altamente configurable: tanto el sistema operativo como sus herramientas
Es robusto y estable: siempre y cuando cumpla con el elemento anterior. Un servidor Linux que siempre falla, es un servidor que, en el 90% de los casos, está mal configurado.
Escalable y adaptable: la gran mayoría de los casos podremos ver que tanto el propio sistema operativo como las herramientas que puede estar utilizando en él, son sumamente adaptables, inclusive llegando a poder manipular el propio código fuente de los mismos para mejorar, adaptar o corregir aspectos relacionados con la funcionalidad y desempeño de las herramientas.
Es sumamente seguro: dado que la comunidad de Linux es tan amplia, cada vez que surge alguna vulnerabilidad notable en el sistema operativo o alguna herramienta, esta es atacada en tiempo récord por esta comunidad, por lo que los errores se corrigen en períodos de tiempo extra cortos.

Aquí el detalle en contra, para muchos, es la terminal, mejor conocida como la interface de línea de comandos o CLI (abreviatura de: command line interface). Pues se dice que es complicada, difícil, etc. Y bueno, si es verdad que la CLI no es para todo el mundo, tampoco es que es algo hiper complejo en sí. Todo depende de la complejidad de las tareas que deseemos realizar.

En esta oportunidad te voy a enseñar diez comandos, con los que te vas a empezar a mover rápidamente por la terminal como un chita. Toma en cuenta que cada comando tiene variaciones, especificidades, las cuales llamamos técnicamente atributos.

Cada atributo nos permite obtener información diferente del mismo comando, bien sea, más específica o más global y genérica; más completa o reducida. Todo es útil y dependiendo del tratamiento que vayamos a darle a esos datos para convertirla en nueva información, será necesario que aprendas al menos que existen esos atributos.

También podremos combinar comandos y así darle forma a la salida de información de dichos comandos. Sólo explicaré algunos aquí. Lo explicaré como si fuese para niños, por lo que si buscan algo más avanzado o al grano, aquí no es. Quiero hacer un HowTo para todos y no frustrarle la experiencia a posibles potenciales usuarios, pues no todos aprendemos igual.

Ahora sí, luego de tomarnos nuestro café respectivo, vamos a abrir la terminal y a aprender, vale!!

Comando pwd (Print Working Directory)

Con este comando sabremos cual es nuestra ubicación en nuestro sistema en ese momento:

# Al ejecutar el comando 'pwd'
pwd

# Nos devolverá la ruta en la que estamos actualmente
/home/gabrielw

Cuando cambiemos de directorio, obviamente cambiará de ruta de ubicación. Para ello utilizaremos el comando cd.

Comando cd (Change Directory)

Este tema es un poco extenso, así que buscaré la forma más simple de explicarlo.

Con el comando cd, lo que haremos justamente es cambiar nuestra ubicación dentro de nuestro sistema. Por ejemplo. Si nos encontramos en el directorio /home/gabrielw y decidimos entrar a otro directorio llamado practica, entonces lo haremos de la siguiente manera:

# Ejecutamos 'cd' + nombredirectorio
cd practica

# Ahora ejecutamos 'pwd' para comprobar en donde nos encontramos
pwd

# Y nos mostrará la ruta
/home/gabrielw/practica

Y cuando verifiquemos nos daremos cuenta ya estamos en dicha ubicación.

Ahora, es bueno manejar dos tipos de conceptos fundamentales en este tema de manipular o navegar en directorios del sistema: rutas absolutas y rutas relativas… Aquí la cosa puede sonar complicada, pero no lo es realmente como la pintan.

Manejar Rutas relativas y rutas absolutas con cd y otros comandos

Las rutas relativas son aquellas a las que podemos acceder tomando como referencia nuestra ubicación actual dentro del sistema. Y cuando hablo de poder acceder no hago énfasis en la posibilidad o facultad de hacerlo, sino en la modalidad o forma de hacerlo.

Pondré un ejemplo fácil:

Suponiendo que vivo en una urbanización, la que denominaremos urbanizacion, compuesto por varias parcelas y asumiendo que cada una de ellas. Yo vivo en la parcela dos y mi novia vive en la parcela cuatro. Estas parcelas las nombraremos abreviadamente con la letra p (minúscula) + número. Por ejm: p1, p2, p3, …, p10, etc.

Si yo quisiera ir hacia la casa de mi novia (p4); estando yo en mi casa (p2), sólo debo indicar que desde la ruta actual en la cual estoy ubicado, me dirija hacia el piso cuatro:

# Verificamos en cual piso (directorio) estamos:
pwd

# Nos indica que estamos en 'p2':
/home/urbanizacion/p2

# pero ahora queremos ir al 'p4', el comando cd hará las veces de nuestro ascensor:
cd p4/

# Verificamos ahora:
pwd

# La terminal nos dice ahora que estamos en 'p4' ahora =D
/home/urbanizacion/p4

Ahora, necesito ir de vuelta a mi casa. Para eso lo que debo hacer es devolverme, cierto?. Para devolverme utilizaré dos puntos consecutivos y un slash (no, no el guitarrista, sino el signo de slash o de barra, o división):

# Tenemos dos formas de hacerlo: mediante una ruta relativa:
cd ../p2

# Verificamos nuestra ruta actual, y...
pwd

# Y voilá!!!, ya estamos en la ruta deseada:
/home/urbanizacion/p2

Esto sería desplazarse dentro del sistema con rutas relativas, ya que a partir de mi ubicación actual, le estoy indicando al sistema hacia donde deseo ir. Esto implica un buen conocimiento de la estructura de directorios en la cual me estoy desplazando, o sino una verificación constante de esa estructura, tomando en cuenta los pasos que debo dar, desde mi ubicación de origen, hacia mi destino.

Estando en mi casa ya, recibo una llamada de mi madre, que vive en la parcela uno (p1). Necesita que la ayude con unas cosas y por lo tanto debo ir hasta allá.

Para eso hago lo siguiente:

# Podría utilizar la ruta absoluta, en la cual especificamos la ruta completa:
cd /home/urbanizacion/p1

# Siendo lo mismo que utilicemos la ruta relativa, tomando en cuenta de que nos encontramos
# en la ruta: /home/urbanizacion/p2, nos devolveríamos un paso, con 'cd ../ ' 
# y entraríamos a 'p1'
cd ../p1

Y llego a casa de mi madre. Esta es una ruta absoluta. Aquí no se tomará en cuenta mi ubicación actual, simplemente será relevante hacia donde quiero desplazarme. Sin más.

Algo importante que decir es que cualquiera de los dos métodos sirven para lo mismo y van a funcionar, sólo cambia su funcionamiento.

Ahora, cual de las dos es mejor o peor?, Depende de tus necesidades y practicidad. Porque si estás en una profundidad de diez directorios y requieres ir a otro directorio en otra ramificación, lo mejor sería utilizar rutas absolutas en vez de movilizarse diez pasos hacia atrás y luego avanzar uno o dos pasos hacia adelante. No tendría sentido. Para este caso sería mejor utilizar rutas absolutas.

Del mismo modo, tampoco tendría sentido utilizar rutas absolutas, si los directorios están contiguos, a uno, dos o incluso tres pasos, bien sea hacia delante o hacia atrás de tu ruta actual. aquí perfectamente podríamos utilizar rutas relativas.

Cuales serían las razones por las cuales puede fallar este comando?

Escribimos mal el nombre del directorio.
No tenemos permisos de acceso a ese directorio
El directorio al que deseamos acceder no está en la ruta especificada.

Para ello necesitaremos verificarlo con el comando ls.

Listar archivos con el Comando ls (listing)

Con el comando ls, podremos listar el contenido de los directorios del sistema. Y aplican los mismos mecanismos o formas de navegación entre directorios mediante rutas absolutas y relativas.

Es muy simple de utilizar y tiene algunos atributos importantes a considerar.

De esta forma podemos utilizar el comando ls y algunos de sus atributos:

# Listar todos los ficheros y directorios, sin detalle:
ls

# Listar todos los ficheros y directorios (+ ocultos), sin detalle:
ls -a

#  detalles de los ficheros / directorios:
ls -l

# O, si queremos incluir los ocultos:
ls -la

# Ver todos los archivos (+ ocultos), ordenados por fecha de modificación:
ls -lath

# Listar todos los ficheros y directorios con recursividad:
ls -R

# Listar todos los ficheros y directorios con detalle y recursividad:
ls -lR

# Igual que la anterior (+ ocultos):
ls -laR

# Igual que la anterior, por fecha de modificación (+ ocultos):
ls -lathR

Un ejemplo práctico de esto sería, tener que hacer un inventario de que tenemos en nuestra casa, entonces nos vamos a p2 y revisamos nuestra casa para ver que tenemos en ella:

# Vamos a nuestra parcela:
cd /home/urbanizacion/p2

# Listamos lo que hay en ella:
ls

# Vemos que tenemos nuestros ambientes o espacios:
alcoba1  alcoba2  alcoba3  banio1  banio2  cocina  recibo jardin

# E inventariamos lo que tenemos en recibo:
ls recibo/

# Y podemos ver lo que tenemos:
bar  mesa1  silla1  silla2  silla3  silla4  silla5  silla6  sofa1  sofa2  sofa3  telefonera  tv

# Excelente, pero vamos a ver lo que tenemos en toda la casa:
ls -R

# Y aquí vemos lo que contiene cada espacio de nuestra casa
.:
alcoba1  alcoba2  alcoba3  banio1  banio2  cocina  jardin  recibo

./alcoba1:
almohadas  cama  cobijas  estante  lampara  mesa  pantuflas  ropa  sabanas  toallas  tv  ventilador  zapatos

./alcoba2:
almohadas  cama  cobijas  estante  lampara  mesa  pantuflas  ropa  sabanas  toallas  tv  ventilador  zapatos

./alcoba3:
almohadas  cama  cobijas  estante  lampara  mesa  pantuflas  ropa  sabanas  toallas  tv  ventilador  zapatos

./banio1:
aromatizante  batas  calentador  dentrifico  detergentes  ducha  enguague  espejo  jabon  lavamanos  papel  regadera  retrete  shampoo  toallas

./banio2:
aromatizante  batas  calentador  dentrifico  detergentes  ducha  enguague  espejo  jabon  lavamanos  papel  regadera  retrete  shampoo  toallas

./cocina:
alimentos  batidor  estufa  horno  lavaplatos  mesita  nevera  platos  tazas  vajilla  vasos

./jardin:
arbol1  arbol10  arbol2  arbol3  arbol4  arbol5  arbol6  arbol7  arbol8  arbol9  planta1  planta10  planta2  planta3  planta4  planta5  planta6  planta7  planta8  planta9

./recibo:
bar  mesa1  silla1  silla2  silla3  silla4  silla5  silla6  sofa1  sofa2  sofa3  telefonera  tv

# Sin embargo, faltan cosas, veamos que tenemos escondido en las habitaciones:
ls -a alcoba*

ls -R
alcoba1:
.  ..  almohadas  cama  cobijas  estante  lampara  mesa  pantuflas  ropa  sabanas  toallas  tv  ventilador  zapatos

alcoba2:
.  ..  almohadas  cama  cobijas  estante  lampara  mesa  pantuflas  ropa  sabanas  toallas  tv  ventilador  zapatos

alcoba3:
.  ..  almohadas  .cajafuerte  cama  cobijas  estante  lampara  mesa  pantuflas  ropa  sabanas  toallas  tv  ventilador  zapatos


# Fijémonos que existe un objeto oculto, una cajafuerte, en la alcoba3, comienza por un punto:
.cajafuerte

# Vamos a revisar que tiene esa caja fuerte:
ls -lRa alcoba3/.cajafuerte

# Mostrándonos, después de la 3ra. línea lo que guarda .cajafuerte: 
total 12
drwxr-xr-x 2 gabrielw gabrielw 4096 Feb 11 21:18 .
drwxr-xr-x 3 gabrielw gabrielw 4096 Feb 11 21:25 ..
-rw-r--r-- 1 gabrielw gabrielw   94 Feb 11 22:08 ahorros  #ESTO!!! =D
-rw-r--r-- 1 gabrielw gabrielw   75 Feb 11 22:17 deudas   # Y ESTO TAMBIEN... =(

Ahora veremos otro comando sencillo que nos servirá para explorar más cosas y hacerlas más interesantes:

Comandos cat, more y less

Y no, cat no se trata de un gatito, sino de un comando que sirve principalmente para dos cosas:

Concatenar archivos existentes en un solo archivo
Mostrar contenido de archivos, generalmente planos y de poco contenido, de una sola pasada, es decir: sin paginación. Este es su uso más común.

Volviendo al ejemplo de la casa, podemos ver que tenemos dos archivos, que se llaman ahorros y deudas, respectivamente. Si queremos ver lo que dicen, los examinaremos uno a uno con el comando cat:

# Examinando el contenido del archivo ahorros:
cat alcoba3/.cajafuerte/ahorros

# Contenido del archivo ahorros:
Ahorros:                $3000.00
Fondos de Inversión:    $5000.00
Criptos:                $4000.00
Acciones:               $9000.00


# Examinando el contenido del archivo deudas:
cat alcoba3/.cajafuerte/deudas

# Contenido del archivo deudas:
Tratamientos medicos por pagar: $10000.00
Colegio:                        $1500.00
Condominio:                     $400.00
Miscelaneos:                    $550.00

# Ahora si queremos concatenar ambos archivos, vamos a la ruta en donde están ambos:
cd alcoba3/.cajafuerte

# Y los concatenamos de este modo: cat nombrearchivo1 nombrearchivo2 > nombrearchivoconcatenado
cat ahorros deudas > estadofinanciero

# Revisamos que exista el nuevo archivo concatenado estadofinanciero:
-rw-r--r-- 1 gabrielw gabrielw  94 Feb 11 22:08 ahorros
-rw-r--r-- 1 gabrielw gabrielw 109 Feb 11 22:36 deudas
-rw-r--r-- 1 gabrielw gabrielw 203 Feb 11 22:40 estadofinanciero    # AQUI ESTA!

# Y ahora revisamos el contenido del archivo estadofinanciero:
cat estadofinanciero 
Ahorros:                $3000.00
Fondos de Inversión:    $5000.00
Criptos:                $4000.00
Acciones:               $9000.00

Tratamientos medicos por pagar: $10000.00
Colegio:                        $1500.00
Condominio:                     $400.00
Miscelaneos:                    $550.00

# Y efectivamente tenemos ambos archivos concatenados

Sin embargo, nos dimos cuenta revisando bien que nuestra .cajafuerte guardaba otro archivo oculto, que se llama .recetario, el cual contiene las recetas de la familia:

-rw-r--r-- 1 gabrielw gabrielw   94 Feb 11 22:08 ahorros
-rw-r--r-- 1 gabrielw gabrielw  109 Feb 11 22:36 deudas
-rw-r--r-- 1 gabrielw gabrielw  203 Feb 11 22:40 estadofinanciero
-rw-r--r-- 1 gabrielw gabrielw 9706 Feb 11 23:12 .recetario

Es un archivo muy grande, puesto que pesa 9706 bytes y para ser solo texto se considera un archivo con una buena cantidad de líneas. En caso de que lo visualicemos con cat, sólo nos mostrará las últimas líneas que entren en la pantalla, por lo tanto no nos servirá. Para esos casos utilizaremos more y less.

El comando more nos sirve para visualizar un archivo con paginación. Es medianamente versátil, sin embargo una de sus limitaciones es que al paginar, toma la pantalla como un bloque de visualización y luego debemos presionar la tecla SPACE o barra espaciadora para pasar a la siguiente página. En las nuevas revisiones de more, permite ahora visualizar el porcentaje de contenido mostrado y ahora, poder retroceder y avanzar con las teclas direccionales flechas arriba | abajo. Sin duda una función muy esperada

# Ejecutando el comando more para visualizar el archivo '.recetario':
more .recetario

Y se vería así:

Imagen: Visualización archivo con el comando more

También podemos utilizar el comando less, el cual hace relativamente lo mismo, pero a diferencia de more, el desplazamiento se da línea por línea:

# Ejecutando el comando 'less' para visualizar el archivo '.recetario':
less .recetario

Y se vería así:

Imagen: Visualización archivo con el comando less

Para salir de ambos comandos, tanto en el caso de more como el de less, se debe presionar la letra q.

Leyendo textos y buscando coincidencias con grep

El comando grep nos permite buscar en uno o varios textos, coincidencias en cadenas de caracteres y hacer filtrados en la salida de comandos o muestra de archivos. Utilizaremos atributo de recursividad (-r), para que explore todos los archivos en los cuales encuentre la coincidencia y el atributo (-i), para ignorar las mayúsculas y minúsculas (ignore case):

Sus casos de uso pueden ser los siguientes:

# Si queremos cuales archivos contienen la palabra tratamiento en la ruta actual (.)
grep -ri "tratamiento" .

# Si queremos cuales archivos contienen la palabra tratamiento en ruta absoluta
grep -ri "tratamiento" /home/urbanizacion/p2/alcoba3/.cajafuerte/deudas/

# O en una ruta relativa, suponiendo que estamos en la ruta '/home/urbanizacion/p2':
grep -ri "tratamiento" ./alcoba3/.cajafuerte/deudas/

Este será el resultado:

En otro caso de uso, cuando ya especificamos el archivo a procesar, utilizaremos el comando cat y luego utilizaremos una tubería (pipe, en inglés) para procesar la salida del primer comando, con el segundo comando, que en este caso será grep y poder filtrar la salida con la condición dada. Pronto escribiré un artículo sobre tuberías.

La salida sería algo así:

# Ejecutar 'cat' en el archivo '.recetario' y ver cuantas veces aparece la palabra 'huevos':
cat .recetario | grep "huevos"

Y esta será la salida:

Imagen: filtrar la salida de un texto o comando con grep

Sin embargo podemos hacer esto también con comandos visualizadores en tiempo real, como el caso de head y tail.

Comandos head y tail

Con head podemos ver las primeras líneas de un archivo y con tail podemos ver las últimas líneas de un archivo. Entre uno y otro el más útil a los efectos de visualización en tiempo real es el comando tail, puesto que tiene un atributo que nos permite ver como se van agregando líneas sin necesidad de cerrar y volver a abrir el archivo. Muy útil a la hora de ver logs del sistema.

Se utiliza de la siguiente manera:

# Mostrará al primeras 10 líneas del archivo '.recetario':
head .recetario

# Mostrará al primeras 50 líneas del archivo '.recetario':
head -50 .recetario

# Mostrará al últimas 10 líneas del archivo '.recetario':
tail .recetario

# Mostrará al últimas 50 líneas del archivo '.recetario':
tail -50 .recetario

# Mostrará al últimas líneas del archivo '.recetario' en 
# tiempo real, es decir si otra persona escribe en el 
# archivo, nosotros podremos ver los cambios al momento 
# de guardarse | escribirse. Útil para revisar logs
tail -f .recetario

Encontrar elementos con find

Con el comando find podemos encontrar archivos o directorios que cumplan con una o varias condiciones. Es una herramienta muy útil porque a través de este comando podemos dar instrucciones con las coincidencias que encontremos.

Hagamos un ejemplo práctico, con el mismo caso que hemos estado realizando. En la parcela de mi madre, siendo esta la parcela 1 (o p1), supongamos que mi madre tiene una gata llamada Lola. Siempre se escapa Lola porque, como todos los gatos, suelen ser muy escurridizos e independientes.

Entonces, nos valdremos de nuestras habilidades para encontrarlo 😉

# Nos iremos a la entrada de nuestra parcela y comenzaremos a Lola, revisando una por una:
cd /home/urbanizacion

# Verificamos ubicación (para que nos familiaricemos siempre a verificar):
pwd

# Y efectivamente sí estamos en la entrada de nuestra urbanización:
/home/urbanizacion

# Vamos a buscar a Lola, nuestra estrategia será la siguiente:
# 1.- Luego del comando find, el punto (.) indicaremos que a partir
#     de esa ubicacion empiece a buscar a Lola
# 2.- Con el atributo -name, indicamos el nombre del elemento que
#     estamos buscando, en este caso Lola
# 3.- Ahora sí, a buscar a Lola:
find . -name "lola"

# No la encontramos, utilizaremos un comodín para ver que
# coincidencias podemos encontrar con su nombre:
find . -iname "*lola"

# Y podemos ver que encontramos la casa de Lola pero está vacía:
./p1/jardin/casa_lola

# Entonces eso me lleva a pensar que quizás estamos llamando mal
# a Lola, puesto que hemos estado escribiendo mal su nombre (lola).
# En este caso, tenemos dos opciones:
# 1.- Escribimos el nombre propio con la primera letra L mayúscula, o
# 2.- Reemplazamos el atributo -name por -iname y este ignorará todas
#     las mayúsculas y minúsculas en las coincidencias del patrón de
#     búsqueda: Lola, lola, lOlA,lOLa, LolA y todas las combinaciones
#     serán válidas:
find . -iname "*lola"

# Y voilá, hemos encontrado a Lola!!... Estaba en la parcela 9
./p1/jardin/casa_lola
./p9/Lola      # AQUI ESTA =D

Ahora, con find también podemos ejecutar acciones que afectarán a ese elemento, que en este caso es Lola.

Por ejemplo:

# Cuando encontremos a Lola, salga un mensaje por pantalla con las
# posibles coincidencias:
find . -iname "*lola" -exec echo "Aquí encontramos a Lola: " {} \;

# Y veremos esto, como respuesta:
Aquí encontramos a Lola:  ./p1/jardin/casa_lola
Aquí encontramos a Lola:  ./p9/Lola

# Pero aquí tenemos que cerrar nuestra búsqueda un poco. Lo primero
# que haremos es quitar el comodín o 'wildcard' en nuestra cadena de
# búsqueda. 

# Lo segundo es especificar, qué tipo de elemento es 'Lola' y lo
# haremos con el atributo '-type', y clasificándolo de esta forma:
#
# 1.- Si es un elemento simple: como un gato, un perro, una persona, etc,
#     lo clasificaremos como archivo, fichero o file, y será de tipo 'f'.
# 2.- Si es un elemento contenedor, cuya capacidad le permite guardar a
#     otros elementos dentro de sí, bien sea simples o no, lo clasificaremos
#     como directorio, carpeta o folder, y será de tipo 'd':
find . -type f -iname "lola" -exec echo "Aquí encontramos a Lola: " {} \;

# Y la respuesta a este comando será más cerrada y precisa:
Aquí encontramos a Lola:  ./p9/Lola

# Ahora bien, ya la encontramos, lo que queremos es devolverla a su casa,
# que está en el jardin de la 'p1', cierto? Para eso utilizaremos el comando mv:
find . -type f -iname "lola" -exec mv -v {} ./p1/jardin/casa_lola/ \;

# Y ya habremos llevado a Lola a su casa

Veámoslo aquí:

Imagen: llevando a Lola a su casa, con los comandos find y mv

Ahora para cerrar, veremos los comandos mv (move) en mayor profundidad y el comando cp (copy).

Moviendo y copiando elementos con mv y cp

Ahora hablaremos sobre los comandos mv y cp.

El comando mv nos ayuda a mover elementos, bien sea archivos o directorios, de una ubicación a otra. También nos sirve para renombrar elementos, dentro de la misma ubicación o en la ubicación de destino de nuestro elemento. Veamos algunas formas de sintaxis de mv:

# Suponiendo que tenemos esta estructura, compuesta de
# seis (6) directorios y cuatro (4) archivos:
.
├── dir1
├── dir2
├── dir3
├── dir4
├── dir5
├── dir6
├── archivo1
├── archivo2
├── archivo3
└── archivo4

# Para mover un archivo de una ruta a otra:
mv archivo1 dir2/

# Al verificar nuevamente, tendremos nuestro 'archivo1' en el 'dir1':
ls -l dir1/

# Y constataremos que efectivamente lo ha movido:
-rw-r--r-- 1 gabrielw gabrielw 0 Feb 12 13:28 archivo1

# Podemos hacer lo mismo, con el 'archivo2' hacia el 'dir2',
# esta vez agregándole el atributo '-v' para ver la salida
# de lo que hace el comando:
mv -v archivo2 dir2/

# Y nos dirá que es lo que ha realizado, mover el 'archivo2' al 'dir2':
renamed 'archivo2' -> 'dir2/archivo2'

# Verificamos 'dir2':
ls -l dir2/

# Y efectivamente lo ha movido:
-rw-r--r-- 1 gabrielw gabrielw 0 Feb 12 13:28 archivo2

# Ahora nuestra estructura va quedando así:
.
├── dir1
│   └── archivo1
├── dir2
│   └── archivo2
├── dir3
├── dir4
├── dir5
├── dir6
├── archivo3
└── archivo4

# Moveremos el 'dir6' dentro del 'dir2', esto lo haremos con el atributo force (--force o -f):
mv -f dir6 dir2/

# O también podemos utilizar el atributo verbose (--verbose o -v):
mv -vf dir6 dir2/

# Y nos dirá que hicimos en el sistema:
renamed 'dir6' -> 'dir2/dir6'

# Efectivamente movimos el dir6 adentro del 'dir2' sin alterar su nombre.
# Ahora hagamos lo mismo con el 'dir5' y lo moveremos al 'dir4' y lo renombraremos
# de una vez llamándolo 'antiguodir5'
mv -vf dir5 dir4/antiguodir5

# Y vemos la salida del comando:
renamed 'dir5' -> 'dir4/antiguodir5'

# Y así, al verificar nuestro 'dir4':
ls -l dir4/

# Vemos nuestro dir5 renombrado:
drwxr-xr-x 2 gabrielw gabrielw 4096 Feb 12 13:28 antiguodir5

Ahora con el comando cp, lo que haremos es crear duplicados de uno o varios archivos o ficheros, de una ubicación a otra, o en una misma ubicación, siempre y cuando cambiemos el nombre de los mismos. Su sintaxis es similar a la de cp:

# Volviendo a suponiendo que tenemos esta estructura, compuesta de
# seis (6) directorios y cuatro (4) archivos:
.
├── dir1
├── dir2
├── dir3
├── dir4
├── dir5
├── dir6
├── archivo1
├── archivo2
├── archivo3
└── archivo4

# Para copiar el 'archivo1' de la ruta actual a 'dir2':
cp archivo1 dir2/

# Al verificar nuevamente, tendremos nuestro 'archivo1' en el 'dir1':
ls -l dir1/

# Y constataremos que efectivamente lo ha copiado:
-rw-r--r-- 1 gabrielw gabrielw 0 Feb 12 14:28 archivo1

# Podemos hacer lo mismo, con el archivo2 hacia el 'dir2',
# esta vez agregándole el atributo '-v' para ver la salida
# de lo que hace el comando:
cp -v archivo2 dir2/

# Y nos dirá que lo ha realizado, copiar el 'archivo2' al 'dir2':
'archivo2' -> 'dir2/archivo2'

# Verificamos 'dir2':
ls -l dir2/

# Y efectivamente lo ha copiado:
-rw-r--r-- 1 gabrielw gabrielw 0 Feb 12 14:28 archivo2

# Ahora nuestra estructuranos dice que dentro de 'dir1' está el duplicado
# del archivo1 con su mismo nombre y dentro de 'dir2' está el duplicado de
# archivo2. A su vez, los elementos 'archivo1' y 'archivo2' siguen estando 
# ahí en el directorio raíz donde están los demás elementos:
.
├── dir1
│   └── archivo1    # DUPLICADO DE ARCHIVO1
├── dir2
│   └── archivo2    # DUPLICADO DE ARCHIVO2
├── dir3
├── dir4
├── dir5
├── dir6
├── archivo3        # ARCHIVO1 MATRIZ
└── archivo4        # ARCHIVO2 MATRIZ

# Ahora copiaremos el 'dir6' dentro del 'dir2', esto lo haremos 
# con el atributo force (--recursive, -R o -r):
cp -R dir6 dir2/

# O también podemos utilizar el atributo verbose (--verbose o -v):
cp -Rv dir6 dir2/

# Y nos dirá que hicimos en el sistema:
'dir6' -> 'dir2/dir6'

# Efectivamente copiamos el dir6 adentro del dir2 sin alterar su nombre.
# Ahora hagamos lo mismo con el dir5 y lo copiaremos al dir4 y lo renombraremos
# de una vez llamándolo duplicadodir5
cp -Rv dir5 dir4/duplicadodir5

# Y vemos la salida del comando:
'dir5' -> 'dir4/duplicadodir5'

# Y así, al verificar nuestro 'dir4':
ls -l dir4/

# Vemos nuestro 'dir5' renombrado:
drwxr-xr-x 2 gabrielw gabrielw 4096 Feb 12 14:29 duplicadodir5

# Por último, para verificar los cambios, haremos esta visualización
# de los cambios realizados:
.
├── dir1
│   └── archivo1        # DUPLICADO DE ARCHIVO1
├── dir2
│   ├── dir6            # DUPLICADO DE DIR6
│   └── archivo2        # DUPLICADO DE ARCHIVO2
├── dir3
├── dir4
│   └── duplicadodir5  # DUPLICADO DE DIR5 CON NOMBRE MODIFICADO DUPLICADODIR5
├── dir5               # MATRIZ DE DIR5
├── dir6               # MATRIZ DE DIR6
├── archivo1
├── archivo2
├── archivo3
└── archivo4

# Por último, y para terminar esta práctica, tomaremos todos los archivos (solo los archivos), y los copiaremos en el 'dir1', pero supongamos que el archivo1 que está en el 'dir1' es diferente al archivo1 que está en nuestro directorio de trabajo raíz y, por ende, no quiero perder su contenido, lo que haremos es confirmar la copia de cada archivo utilizando el atributo de interactividad (--interactive o -i):

# Verifiquemos, antes de procesar la copia, el contenido de ambos archivos:
find . -iname "archivo1" -print -exec cat {} \;

# Y efectivamente, tienen contenidos distintos:
./archivo1
archivo 1 de raiz: Hola Pepe
./dir1/archivo1
Archivo 1 de dir1: Hola Juan

# Ahora si haremos la copia, utilizando un wildcard, con esto tomará a todos
# los archivos, del 1 al 4, pero antes confirmará si encuentra coincidencias:
cp -iv archivo* dir1/

# Al ejecutar, nos preguntará si deseamos sustituir el 'archivo1' que tenemos
# en el 'dir1' con el 'archivo1' que está junto con los otros que estamos copiando:
# al llegar a la pregunta, responderemos 'y' o 'n' según sea el caso. En el 
# nuestro, será 'n':
cp: overwrite 'dir1/archivo1'? n
'archivo2' -> 'dir1/archivo2'
'archivo3' -> 'dir1/archivo3'
'archivo4' -> 'dir1/archivo4'

# Verificamos si los otros archivos se copiaron (a modo de comprobación):
ls -l dir1/

# Resultado de la existencia de los archivos:
total 4
-rw-r--r-- 1 gabrielw gabrielw 29 Feb 12 14:52 archivo1
-rw-r--r-- 1 gabrielw gabrielw  0 Feb 12 15:08 archivo2
-rw-r--r-- 1 gabrielw gabrielw  0 Feb 12 15:08 archivo3
-rw-r--r-- 1 gabrielw gabrielw  0 Feb 12 15:08 archivo4

# Nuestra estructura queda así:
.
├── dir1
│   ├── archivo1
│   ├── archivo2
│   ├── archivo3
│   └── archivo4
├── dir2
│   ├── dir6
│   └── archivo2
├── dir3
├── dir4
│   └── duplicadodir5
├── dir5
├── dir6
├── archivo1
├── archivo2
├── archivo3
└── archivo4

# Y volvemos a verificar si efectivamente se mantuvo intacto el contenido de 'dir1/archivo1':
find . -iname "archivo1" -print -exec cat {} \;

# Y efectivamente, no se perdió nada =D
./archivo1
archivo 1 de raiz: Hola Pepe
./dir1/archivo1
Archivo 1 de dir1: Hola Juan

Eliminar archivos y directorios con rm

El comando rm (remove), es una utilidad que nos va a permitir eliminar archivos o directorios que no necesitemos. Es una herramienta muy poderosa y peligrosa, así que hay ser muy cuidadosos en su uso, por si no queremos eliminar algo importante o incluso destruir nuestro sistema.

Su modo de uso es:

# Para eliminar un archivo:
rm archivo1

# Para eliminar un archivo, con el modo verbose activado:
rm -v archivo1

# Y nos saldrá un mensaje diciendo:
removed 'archivo1'

# Para eliminar un directorio, en este caso eliminaremos 'dir3':
rm -r dir3/

# También sirve, forzando el eliminado del directorio y en modo verbose:
rm -rfv dir3/

# Eliminar directorio 'dir1' interactivamente (confirmando cada eliminación)
# y con modo verbose:
rm -riv dir1/

# Su salida será así, dependiendo de la cantidad de ficheros y 
# confirmando con 'y' o 'n' cada una de los borrados:
rm: descend into directory 'dir1/'? y
rm: remove regular empty file 'dir1/archivo2'? y
removed 'dir1/archivo2'
rm: remove regular file 'dir1/archivo1'? y
removed 'dir1/archivo1'
rm: remove regular empty file 'dir1/archivo3'? y
removed 'dir1/archivo3'
rm: remove regular empty file 'dir1/archivo4'? y
removed 'dir1/archivo4'
rm: remove directory 'dir1/'? y
removed directory 'dir1/'

Crear archivos y directorios con touch mkdir

Con los comandos touch y mkdir, podemos crear archivos y directorios. Veamos como funciona touch:

# Para crear un archivo:
touch archivo1

# Crear varios archivos con distinto nombre:
touch archivo2 perro gato arbol auto avion

# Crear varios archivos con distinto nombre, pero misma raíz morfológica:
touch archivo{3,4,5,6}

# Al verificar:
ls -l

# Nos muestra:
-rw-r--r-- 1 gabrielw gabrielw 0 Feb 12 16:58 arbol
-rw-r--r-- 1 gabrielw gabrielw 0 Feb 12 16:58 archivo2
-rw-r--r-- 1 gabrielw gabrielw 0 Feb 12 16:57 archivo3
-rw-r--r-- 1 gabrielw gabrielw 0 Feb 12 16:57 archivo4
-rw-r--r-- 1 gabrielw gabrielw 0 Feb 12 16:57 archivo5
-rw-r--r-- 1 gabrielw gabrielw 0 Feb 12 16:57 archivo6
-rw-r--r-- 1 gabrielw gabrielw 0 Feb 12 16:58 auto
-rw-r--r-- 1 gabrielw gabrielw 0 Feb 12 16:58 avion
-rw-r--r-- 1 gabrielw gabrielw 0 Feb 12 16:58 gato
-rw-r--r-- 1 gabrielw gabrielw 0 Feb 12 16:58 perro

Estos archivos que se crean son vacíos. No tienen contenido alguno.

Ahora veamos como funciona mkdir:

# Crear un directorio, llamado 'documentos':
mkdir documentos

# Crear varios directorios con nombres distintos:
mkdir 2023-02-12 2023-02-11 2023-02-10

# Verificamos:
total 12
drwxr-xr-x 2 gabrielw gabrielw 4096 Feb 12 17:06 2023-02-10
drwxr-xr-x 2 gabrielw gabrielw 4096 Feb 12 17:06 2023-02-11
drwxr-xr-x 2 gabrielw gabrielw 4096 Feb 12 17:06 2023-02-12

# Crear varios directorios con distinto nombre, pero misma raíz morfológica:
mkdir alumno{1,2,3,4,5}

# Verificamos:
drwxr-xr-x 2 gabrielw gabrielw 4096 Feb 12 17:07 alumno1
drwxr-xr-x 2 gabrielw gabrielw 4096 Feb 12 17:07 alumno2
drwxr-xr-x 2 gabrielw gabrielw 4096 Feb 12 17:07 alumno3
drwxr-xr-x 2 gabrielw gabrielw 4096 Feb 12 17:07 alumno4
drwxr-xr-x 2 gabrielw gabrielw 4096 Feb 12 17:07 alumno5

BONUS: Consultar el manual de un comando con man

El comando man es, de seguro, el más útil de todos los comandos, pues es el manual o base de datos de todos los comandos y funciones, atributos y formas de uso de ese comando del cual tenemos dudas, y lo tenemos en forma de manual en nuestra terminal.

Para utilizarlo, sólo debemos hacer esto:

# Si queremos saber como ejecutar el el comando ls:
man ls

El comando man funciona con less como soporte de visualización, así que si queremos desplazarnos, solo utilizamos las flechas direccionales y para salir, presionamos la letra q.

Palabras finales y Cierre

Aprendimos como manejar estos diez comandos iniciales y así poder ir calentando los dedos y la mente a la hora de administrar nuestra terminal de Linux. Esto requiere práctica constante y empeño, cometeremos errores, así que es importante verificar siempre antes de ejecutar un comando.

Para finalizar este post, que creo que está bastante largo, pero es para leerlo y practicarlo con calma, sobre todo si estás de cero, o tienes ciertas dudas, con respecto a algunos de los tópicos, explicándolos de la forma como se lo explicaría a mis hijos, con calma y paciencia.

Les recomiendo crear directorios y generar sus ambientes de prácticas, crear máquinas virtuales con Virtualbox, ProxmoxVE o vmWare, tal y como lo explico en este post aquí, y luego ir pasando a explorar muchas más opciones, comandos y herramientas. Si te gusta el contenido del post, por favor difúndelo, comenta, comparte. Quizás conozcas a alguien que lo necesite, compártelo y aprendamos todos en esta bonita Comunidad.

Hasta Luego Fronters!!!

Referencias

Tecmin.com: 35 Practical Examples of Linux Find Command

Baeldung.com: Concatenating Text Files into a Single File in Linux

Tecmin.com: How to Use “mv” Command in Linux [9 Useful Examples]