Invitado.
Usuario Nivel 1
Sin registro. El progreso se guarda localmente. Exporta tu código para jugar en otro dispositivo.
INSIGNIAS GANADAS
Práctica de Terminal Linux en Línea — Aprende Haciendo.
Domina los comandos esenciales de Linux y supera objetivos claros a través de un juego gratuito y un simulador interactivo.
Ruta de Aprendizaje Interactiva y Objetivos de Terminal.
Tu ruta completa de aprendizaje de Linux con objetivos estructurados. Haz clic en cualquier nodo desbloqueado para abrir tu espacio de trabajo interactivo.
1. Conceptos Básicos del Sistema de Archivos
¿Quién soy y dónde estoy?
Imagínese entrar en una biblioteca enorme y oscura con millones de libros, pero no tiene un mapa y ni siquiera puede recordar su propia etiqueta con su nombre. Antes de poder buscar algo, necesita saber quién es y dónde se encuentra. ¡En el shell de Linux, comenzamos exactamente con las mismas preguntas! - El comando `whoami` imprime el nombre de usuario con el que está conectado actualmente. - El comando `pwd` (imprimir directorio de trabajo) actúa como un GPS y le muestra la ruta exacta de la carpeta donde se encuentra actualmente.
Navegar y enumerar archivos
Ahora que sabes dónde estás, ¿cómo miras a tu alrededor y te mueves a una habitación diferente en esta biblioteca digital? En Linux, hacemos esto usando dos comandos simples: - `ls`: Es como encender las luces de una habitación para ver todos los archivos y carpetas que hay dentro. - `cd <path>`: abreviatura de "cambiar directorio", esto le permite atravesar una puerta hacia otra carpeta. Para especificar dónde desea ir, puede usar rutas **absolutas** (comenzando desde la raíz `/` del sistema, como `/var/log`) o rutas **relativas** (según dónde se encuentre ahora, como usar `..` para regresar a la carpeta principal).
Estructura de directorios de Linux y FHS
Cada sistema Linux sigue una jerarquía de sistema de archivos estándar que comienza desde el directorio raíz `/`. A diferencia de Windows (que usa letras de unidad como `C:` o `D:`), Linux unifica todos los archivos y el almacenamiento en `/`. Aquí hay directorios clave del sistema que todo usuario de Linux debería conocer: - `/` (Raíz): La carpeta principal de nivel superior de todo el sistema. - `/etc`: Contiene configuraciones del sistema (por ejemplo, `/etc/hosts`, `/etc/passwd`). - `/var`: contiene datos variables que cambian con el tiempo (registros, spool, cachés como `/var/log`). - `/home`: Carpetas personales del usuario (por ejemplo, `/home/learner`). - `/tmp`: Área de almacenamiento temporal para archivos transitorios. - `/usr`: Utilidades de usuario, aplicaciones y bibliotecas del sistema.
Creación de directorios
Imagine que su escritorio está lleno de papeles sueltos y necesita carpetas físicas para mantener todo ordenado. En Linux, organizamos archivos creando carpetas (directorios) usando el comando `mkdir` (crear directorio). Al ejecutar `mkdir code` se crea una carpeta nueva llamada "código" justo donde estás. Puede crear carpetas en cualquier parte del sistema de archivos dándole a `mkdir` una ruta relativa o absoluta.
Directorios anidados y opciones
Imagínese intentar construir un conjunto de muñecos anidados, pero tiene que construir los más externos antes de poder construir el más pequeño del interior. De forma predeterminada, `mkdir` es así: se niega a crear una carpeta en el interior de carpetas que aún no existen. Para evitar la molestia de crear carpetas una por una, usamos un interruptor: - La opción `-p` (o `--parents`) le dice a `mkdir` que cree automáticamente las carpetas principales que faltan en su camino hacia la carpeta final. Por ejemplo, `mkdir -p workspace/src/utils` crea `workspace`, `workspace/src` y `workspace/src/utils`, todo en un solo comando. **Por qué esto es importante**: Si ejecuta `mkdir workspace/src/utils` sin `-p` y `workspace` y `workspace/src` aún no existen, obtendrá: `mkdir: cannot create directory 'workspace/src/utils': No such file or directory`. El indicador `-p` soluciona este problema creando automáticamente todas las carpetas principales que faltan.
Limpiar la pantalla
¿Alguna vez te has sentido abrumado cuando tu escritorio está cubierto de notas y papeles desordenados? Su terminal puede quedar igualmente abarrotada. Cuando lo haga, puedes borrar todo el texto antiguo y empezar de nuevo. - El comando `clear` limpia la pantalla visible, deslizando la salida anterior fuera de la vista para que tengas un lienzo nuevo y en blanco en la parte superior de la terminal.
Cómo encontrar ayuda de Shell
Cuando compras un nuevo juego de mesa, normalmente echas un vistazo al libro de reglas o a la tarjeta de referencia para ver qué movimientos están permitidos. ¡En nuestro emulador de terminal, tienes una hoja de referencia incorporada! - El comando `help` enumera todos los comandos que admite este simulador, junto con detalles sobre si admite canalización o redireccionamiento de salidas.
2. Manipulación de Archivos
Crear archivos vacíos
Imagínese que quiere empezar a escribir una nueva entrada en el diario, pero primero necesita una hoja de papel en blanco. En Linux, tomamos un archivo de texto nuevo y vacío usando el comando `touch`. - El comando `touch` crea un archivo nuevo y vacío si aún no existe (como ejecutar `touch draft.txt` para crear `draft.txt`). Si el archivo ya existe, simplemente actualiza la marca de tiempo de la "última modificación" del archivo sin cambiar su contenido. Pongamos un archivo en nuestra carpeta de nuevos proyectos.
Lectura del contenido del archivo
Piense en abrir una carpeta, sacar una página de texto y sostenerla para leerla. En Linux, leemos archivos instantáneamente sin abrir un editor de texto pesado usando el comando `cat` (concatenar). - El comando `cat` imprime todo el contenido de un archivo directamente en la pantalla de su terminal. Por ejemplo, ejecutar `cat notes.txt` le permite ver lo que está escrito dentro de `notes.txt` de inmediato.
Echando un vistazo a los archivos (cabeza y cola)
Ahora que puedes leer un archivo completo con `cat`, ¿qué pasa si el archivo tiene miles de líneas y solo quieres ver la parte superior o inferior? Volcar un archivo enorme con `cat` inunda tu pantalla. En lugar de eso, usamos `head` y `tail` para mirar los bordes. - El comando `head` muestra las primeras 10 líneas de un archivo de forma predeterminada. Puede cambiar esto usando `-n <number>` (por ejemplo, `head -n 5 log.txt` para las primeras 5 líneas). - El comando `tail` muestra las últimas 10 líneas de forma predeterminada y admite la misma opción `-n`. - Fundamentalmente, `tail -f` (seguir) monitorea un archivo en tiempo real, mostrando nuevas líneas a medida que el sistema las escribe. Esta es la herramienta favorita de los administradores de sistemas para ver registros en vivo.
Desplazamiento interactivo de archivos (menos y más)
Echar un vistazo a la parte superior e inferior de un archivo con `head` y `tail` es excelente, pero ¿qué sucede si necesita explorar un archivo de configuración largo página por página? Para eso están los buscapersonas como `less` y `more`. - Los buscapersonas cargan archivos de forma interactiva, mostrando una página de texto a la vez para evitar la desaceleración del sistema en archivos grandes. - `less` es la opción moderna, que le permite desplazarse hacia adelante y hacia atrás usando las teclas de flecha, buscar texto con `/` y salir presionando `q`. - `more` es un buscapersonas más antiguo y simple que solo se desplaza hacia adelante.
Manejo de espacios en nombres de archivos
Si le dice a un robot que "pinte mi dormitorio de azul", necesita saber si "mi dormitorio" es un solo lugar o si "mi" y "dormitorio" son dos instrucciones diferentes. Linux usa espacios para separar los comandos de sus argumentos. Entonces, si ejecuta `mkdir my folder`, Linux cree que desea crear dos carpetas separadas: una llamada "mi" y otra llamada "carpeta". - Para decirle a Linux que un nombre con espacios es un solo elemento, debemos encerrarlo entre comillas (`"my folder"` o `'my folder'`) o usar una barra invertida para escapar del espacio (`my\ folder`).
Escritura y sobrescritura de archivos
Si desea escribir un mensaje en una pizarra, primero limpie la pizarra por completo y luego escriba las nuevas palabras. En Linux, escribimos mensajes en archivos usando el operador `>` (redirección de salida). - El comando `echo "message"` normalmente imprime texto en la pantalla. - Al agregar el símbolo `>`, redirigimos ese texto a un archivo. Por ejemplo, `echo "Hi" > greeting.txt` escribe "Hola" en `greeting.txt`. Si el archivo ya tiene texto, `>` lo sobrescribe completamente con el nuevo mensaje.
Agregar a archivos
En lugar de limpiar la pizarra, ¿qué sucede si solo desea agregar una nueva línea en la parte inferior? En Linux, agregamos texto al final de un archivo sin tocar el contenido existente usando el operador `>>` (añadir redirección). - El operador `>>` agrega el nuevo texto al final del archivo. Por ejemplo, `echo "New Line" >> logs.txt` agrega "Nueva línea" al final de `logs.txt` mientras mantiene seguros todos sus registros antiguos.
Copiar y mover archivos
Imagínese reorganizar su habitación: a veces desea hacer una fotocopia de un documento para guardarlo en otro cajón, y otras veces simplemente desea tomar una carpeta y deslizarla en un nuevo estante o cambiar su etiqueta. Hacemos esto en Linux con comandos simples: - `cp <source> <destination>` crea un duplicado idéntico de un archivo en una nueva ubicación. - `mv <source> <destination>` mueve un archivo a una nueva carpeta o cambia el nombre del archivo si lo mantiene en la misma carpeta (por ejemplo, `mv old.txt new.txt`).
Comodines y operaciones con múltiples archivos
Imagine que tiene una pila de carpetas etiquetadas "log_monday", "log_tuesday" y "log_wednesday" y desea abrirlas y leerlas todas a la vez sin escribir cada nombre. ¡Linux te permite usar **comodines** como atajos de búsqueda! - El símbolo `*` coincide con cualquier carácter de cualquier longitud. Por ejemplo, `cat log_*` lee todos los archivos que comienzan con "log_". - El símbolo `?` actúa como marcador de posición de un solo carácter. Por ejemplo, `log_?.txt` coincide con `log_1.txt` pero ignorará `log_12.txt`.
Eliminación de archivos y carpetas
Cuando limpia su escritorio físico, puede tirar los papeles viejos a una papelera de reciclaje donde podrá recuperarlos si cometió un error. En Linux, no hay red de seguridad: cuando eliminas algo del terminal, ¡desaparece para siempre! - El comando `rm` elimina archivos. - Debido a que las carpetas pueden contener otros archivos, `rm` no eliminará una carpeta de forma predeterminada. Debe agregar el indicador `-r` (recursivo) para indicarle a Linux que se sumerja y elimine la carpeta junto con todo lo que contiene. **Por qué esto es importante**: Si ejecuta `rm downloads` sin `-r` cuando `downloads` es una carpeta, obtendrá: `rm: cannot remove 'downloads': Is a directory`. El indicador `-r` le dice a Linux que elimine recursivamente la carpeta y todo lo que contiene.
3. Tuberías y Filtrado
Introducción a Tuberías y WC
Imagine una línea de montaje donde un trabajador envuelve un producto e inmediatamente se lo entrega al siguiente trabajador para que lo empaque en una caja, sin necesidad de almacenamiento intermedio. En Linux, conectamos comandos exactamente así usando una **tubería** (`|`). - Una tubería (`|`) dirige la salida de un comando directamente a la entrada del siguiente comando. Por ejemplo, `ls | wc -l` enumera archivos e inmediatamente pasa esa lista a `wc -l` (recuento de palabras - líneas), que los cuenta sobre la marcha sin necesidad de archivos temporales. **Por qué esto es importante**: si ejecuta `wc` sin `-l`, genera tres números separados: líneas, palabras y bytes (por ejemplo, ` 5 10 85`). Esto dificulta su uso en canalizaciones o scripts que necesitan un recuento limpio de un solo número. El indicador `-l` limita la salida solo al recuento de líneas.
Clasificación y búsqueda de cartas únicas
Imagínese clasificar una baraja de cartas donde hay duplicados esparcidos por todas partes. Para detectar y eliminar duplicados fácilmente, primero debes agrupar las tarjetas idénticas. En Linux, el comando `uniq` filtra las líneas repetidas, pero tiene un inconveniente: **¡solo detecta duplicados que están uno al lado del otro**! - Para eliminar todos los duplicados de una lista desordenada, primero debes ordenar las líneas usando `sort` y luego pasar el resultado a `uniq`. Por ejemplo, `sort raw.txt | uniq` organiza y limpia la lista de una sola vez.
Filtrado con grep
Imagínese revisar un enorme libro de registro de mil páginas para encontrar cada vez que ocurrió un error del sistema. ¡Hacer esto manualmente llevaría horas! En Linux, utilizamos `grep` como nuestra lupa digital para buscar palabras o patrones específicos al instante. - El comando `grep` filtra archivos o texto canalizado, imprimiendo solo las líneas que coinciden con su palabra de búsqueda. Por ejemplo, ejecutar `grep "ERROR" logs.txt` escanea el archivo y extrae solo las líneas que contienen "ERROR".
4. Redirección y Seguridad
Cambio de permisos de archivos
Imagine administrar una empresa donde solo los gerentes pueden firmar cheques, los empleados pueden leer horarios y los visitantes solo pueden mirar el letrero de la tienda. En Linux, controlamos quién puede leer, escribir o ejecutar archivos usando un sistema de seguridad de números (llamado representación octal): - `7` = Acceso completo: Lectura + Escritura + Ejecutar (`rwx`) - `6` = Modificar acceso: Lectura + Escritura (`rw-`) - `5` = Acceso de lectura y ejecución: Leer + Ejecutar (`r-x`) - `4` = Acceso de sólo lectura: Lectura (`r--`) Aplicamos estas configuraciones con `chmod <octal> <file>`. Por ejemplo, `chmod 755 script.sh` le permite ejecutar el script, mientras que otros solo pueden leerlo y ejecutarlo. Tenemos un script llamado `deploy.sh` que actualmente está bloqueado. ¡Hagámoslo ejecutable!
Archivos ocultos y configuraciones
Piense en un cajón secreto debajo de su escritorio donde guarda la configuración del sistema para que no abarrote su espacio de trabajo principal. En Linux, creamos archivos ocultos simplemente comenzando sus nombres con un punto (`.`). - Estos archivos de puntos (como `.bashrc` o `.config`) almacenan las preferencias del usuario y las configuraciones detrás de escena. - Un comando `ls` estándar no los mostrará. Para echar un vistazo a estos archivos ocultos, debe agregar el indicador `-a` (todos), ejecutando `ls -a`. **Por qué esto es importante**: Si ejecuta `ls` sin `-a`, los archivos ocultos (cuyos nombres comienzan con `.`) se omiten por completo del resultado. No verá archivos importantes como `.config_names` y podría pensar que faltan. La bandera `-a` le dice a `ls` que enumere todos los archivos, incluidos los ocultos.
Cambio de propiedad del archivo
Imagínese comprar una casa y tener que registrar oficialmente la escritura con el nombre de un nuevo propietario. En Linux, cada archivo y carpeta tiene un propietario oficial y un grupo. Si necesita entregar la propiedad de un archivo a otra persona (como el administrador del sistema), utilice el comando `chown` (cambiar propietario). - Dado que cambiar quién es el propietario de un archivo es una acción de seguridad delicada, debe anteponerle el prefijo `sudo` para ejecutarlo con privilegios administrativos. Por ejemplo, `sudo chown root reports.csv` asigna el archivo al usuario "root".
Firewalls de Linux (ufw e iptables)
Imagínese vivir en un edificio de apartamentos seguro donde un guardia de seguridad se encuentra en la entrada verificando las identificaciones y bloqueando a los visitantes no autorizados. En Linux, un **firewall** actúa como guardia de seguridad para sus puertos de red. - El comando `ufw` (Firewall sin complicaciones) es una interfaz fácil de usar para administrar reglas de firewall. La ejecución de `sudo ufw status` muestra si el firewall está activo y qué puertos (como el puerto 22 para SSH o el puerto 80 para servidores web) están abiertos. - El comando `iptables` es la herramienta Netfilter tradicional de bajo nivel que en realidad bloquea o redirige paquetes. La ejecución de `sudo iptables -L` enumera las cadenas de seguridad activas y las reglas de coincidencia de paquetes.
5. Superusuario y Paquetes
Privilegios de superusuario (sudo)
Imagine trabajar en su computadora con una cuenta estándar para evitar la eliminación accidental de archivos críticos del sistema operativo. Cuando necesita instalar software o modificar la configuración del sistema, su computadora solicita autorización de administrador. En Linux, utilizamos `sudo` (abreviatura de "superusuario") como nuestra tarjeta de acceso administrativa. - El usuario `root` es la cuenta de administrador maestro con control total sobre el sistema. - Los usuarios estándar no pueden leer archivos confidenciales (como la base de datos de contraseñas `/etc/shadow`). Al escribir `sudo` antes de un comando, lo ejecuta con poderes de administrador temporal para evitar estos bloqueos.
Administración de paquetes (apt)
Piense en instalar aplicaciones en su teléfono inteligente usando App Store o Google Play Store. Es seguro, curado y automatizado. En Linux, utilizamos una tienda de aplicaciones de línea de comandos llamada administrador de paquetes para buscar e instalar software de forma segura. - En los sistemas Ubuntu/Debian, el administrador de paquetes estándar es `apt` (Herramienta de empaquetado avanzada). - La instalación de software cambia las carpetas de todo el sistema, por lo que siempre debe autorizarlo usando `sudo`. Por ejemplo, `sudo apt install tree` descarga e instala el "árbol" del visualizador de directorios.
Búsqueda de paquetes (búsqueda apta)
Antes de instalar software en Linux, ¿cómo descubre qué paquetes están disponibles en el repositorio? En Linux, usamos `apt search` para consultar el catálogo de software por palabra clave. - El comando `apt search <keyword>` escanea las descripciones del repositorio y enumera los paquetes de software coincidentes junto con sus versiones. - A diferencia de `apt install`, la búsqueda en repositorios de paquetes solo lee archivos de índice del catálogo local y **no** requiere privilegios de superusuario (`sudo`).
Purga de paquetes (apt purge)
Al desinstalar software en Linux, el estándar `apt remove` desinstala los archivos binarios de la aplicación, pero deja los archivos de configuración del sistema en caso de que los reinstale más adelante. Para eliminar completamente un paquete de software Y borrar todos los archivos de configuración asociados, usamos `apt purge` (o `apt remove --purge`). - El comando `sudo apt purge <package>` elimina la aplicación y borra todos los archivos de configuración restantes. - Debido a que la purga modifica carpetas y archivos de configuración de todo el sistema, requiere privilegios de superusuario (`sudo`).
Administración de paquetes de Debian (dpkg)
Si bien `apt` automatiza la descarga y resolución de dependencias de paquetes desde los repositorios, ¿qué sucede si ya descargó un archivo de paquete `.deb` manualmente y desea inspeccionarlo o instalarlo? En Linux, usamos `dpkg` (Paquete Debian) para interactuar directamente con los paquetes. - El comando `dpkg -l` enumera todos los paquetes actualmente instalados en su sistema Debian/Ubuntu. - El comando `dpkg -s <package>` muestra información de estado, versión y arquitectura de un paquete específico.
Administradores de paquetes RedHat (yum y dnf)
No todos los entornos Linux están basados en Debian/Ubuntu. Si trabaja en sistemas RedHat, Fedora o CentOS, no encontrará `apt` o `dpkg`. En su lugar, administrará paquetes utilizando administradores de paquetes `yum` más antiguos o `dnf` (Dandified YUM) modernos. - El comando `dnf check-update` (o `yum check-update`) se conecta a los repositorios de RedHat para buscar actualizaciones de paquetes disponibles. - El comando `dnf install <package>` busca e instala programas similares a `apt install`.
6. Disco y Recursos del Sistema
Comprobación del espacio en disco (df)
Imagínese intentar descargar un videojuego enorme y obtener un error de "almacenamiento lleno", pero no está seguro de qué unidad de disco es el cuello de botella. En Linux, verificamos la capacidad de almacenamiento de nuestro sistema usando el comando `df` (disco libre). - El comando `df` muestra el espacio total, utilizado y disponible en todas las unidades conectadas. - Al ejecutar `df -h` (agregando el indicador `-h` para "legible por humanos"), verá el almacenamiento en gigabytes (G) y megabytes (M) amigables en lugar de confusos recuentos de bloques, lo que facilita detectar qué unidad (como `/` o `/home`) está llena. **Por qué esto es importante**: si ejecuta `df` sin `-h`, los tamaños se muestran en números sin formato de bloques de 1K (por ejemplo, `49258284` en lugar de `47G`), lo cual es extremadamente difícil de leer y calcular para un humano. La bandera `-h` formatea estos tamaños en gigabytes (G) y megabytes (M) aptos para humanos.
Encontrar tamaños de directorio (du)
Una vez que sepa *qué* unidad está llena, ¿cómo puede encontrar la carpeta específica que está acaparando todo su espacio? ¿Es tu carpeta de descargas o tal vez algún caché oculto? Resolvemos este misterio usando el comando `du` (uso del disco). - `du <directory>` enumera el tamaño de una carpeta y cada subcarpeta dentro de ella. - `du -sh <directory>` (donde `-s` significa "resumen" y `-h` significa "legible por humanos") calcula e imprime un tamaño total único y limpio para esa carpeta específica. **Por qué esto es importante**: si ejecuta `du` sin `-s`, arrojará una enorme pared de texto que enumera cada subdirectorio y archivo individual de forma recursiva, en lugar de proporcionar un único resumen. La bandera `-s` resume el tamaño total de la carpeta y `-h` la hace legible para humanos.
Comprobación del uso de la memoria (gratis)
Imagine que su computadora portátil comienza a retrasarse, las páginas web se congelan y el cambio de aplicaciones se siente terriblemente lento. Esto generalmente significa que su computadora se está quedando sin memoria activa (RAM). En Linux, podemos comprobar cuánto espacio para respirar tiene nuestro sistema usando el comando `free`. - El comando `free` muestra la memoria física (RAM) y el espacio de intercambio total, utilizado y disponible. - Agregar el indicador `-h` (ejecutando `free -h`) formatea los tamaños de memoria en gigabytes (GB) y megabytes (MB) fáciles de leer para que pueda saber si un programa está consumiendo todos sus recursos. **Por qué esto es importante**: si ejecuta `free` sin `-h`, el uso de memoria se imprime en kilobytes sin procesar (por ejemplo, `16323456` en lugar de `16G`), lo cual es difícil de interpretar rápidamente. La bandera `-h` escala automáticamente los números a gigabytes (G) o megabytes (M) para facilitar la lectura.
Tiempo de actividad del sistema y detalles del kernel
Imagínese solucionar problemas de un servidor que comenzó a comportarse mal y necesita saber si se reinició recientemente, o verificar exactamente qué versión del sistema operativo se está ejecutando. Podemos consultar estos detalles del sistema en segundos: - El comando `uptime` le indica exactamente cuánto tiempo ha estado funcionando su máquina desde su último arranque, junto con qué tan ocupada ha estado (carga del sistema). - El comando `uname -a` (nombre de Unix) imprime un informe completo del kernel de su sistema, el nombre de la plataforma y la arquitectura de la máquina. **Por qué esto es importante**: si ejecuta `uname` sin `-a`, solo genera el nombre básico del sistema operativo (por ejemplo, `Linux`). Omite detalles críticos como la versión del kernel, el nombre de la plataforma y la arquitectura del procesador. El indicador `-a` imprime todos los detalles disponibles del sistema en un solo informe.
Visualización de detalles de la CPU (lscpu)
Al solucionar problemas de rendimiento del sistema o implementar aplicaciones de alta demanda, necesita conocer las capacidades de la CPU de su sistema. En Linux, leemos información detallada sobre la arquitectura de la CPU usando el comando `lscpu`. - El comando `lscpu` muestra detalles del procesador, como el modelo de CPU, el proveedor, la velocidad del reloj, la cantidad de núcleos, los detalles de Hyper-Threading y los tamaños de caché, directamente desde el sistema de archivos del kernel.
Estadísticas de E/S y CPU (iostat)
Cuando una base de datos o una aplicación web se ejecuta lentamente, ¿cómo se determina si el problema es un cuello de botella de la CPU o un disco duro lento? En Linux, monitoreamos las métricas de rendimiento de entrada/salida del sistema usando `iostat`. - El comando `iostat` muestra estadísticas de informes sobre el uso de la CPU y el rendimiento de lectura/escritura del dispositivo activo, lo que le ayuda a identificar la congestión del disco.
7. Gestión de Procesos
Listado de procesos en ejecución (ps)
Piense en su sistema operativo como una oficina ocupada donde a cada empleado (o programa en ejecución) se le asigna una etiqueta de nombre única llamada ID de proceso (PID). En Linux, llamamos a estos programas activos **procesos** y los enumeramos usando el comando `ps`. - La ejecución de `ps` por sí sola solo muestra los programas que se ejecutan dentro de la ventana de terminal actual. - La ejecución de `ps aux` actúa como un registro de oficina principal, enumerando cada programa activo que se ejecuta en todo el sistema, quién lo inició y cuánta CPU y memoria está usando. **Por qué esto es importante**: Si ejecuta `ps` sin `aux`, solo verá los procesos ejecutándose en su ventana de terminal actual (generalmente solo `bash` y `ps`). No verá servicios en segundo plano, procesos del sistema ni programas ejecutados por otros usuarios. Las opciones `aux` revelan todos los procesos en ejecución en todo el sistema.
Monitor de proceso interactivo (arriba)
Imagínese mirar una fotografía estática de una carretera en lugar de mirar una cámara de tráfico en vivo. Mientras que `ps` le brinda una instantánea rápida de lo que se está ejecutando en este momento, `top` le permite ver el rendimiento de su sistema en vivo. - El comando `top` inicia un panel interactivo en tiempo real que se actualiza cada pocos segundos. Muestra el uso de la CPU, los promedios de carga y clasifica dinámicamente los procesos con mayor uso de recursos que se ejecutan en este momento exacto.
Listado de archivos abiertos (lsof)
En sistemas tipo Unix, "todo es un archivo". Esto significa que no sólo los archivos y carpetas de texto, sino también los sockets de red, el hardware del sistema y los procesos se tratan como archivos. Para saber a qué archivos acceden qué programas en ejecución, utilizamos `lsof` (Listar archivos abiertos). - Al ejecutar `lsof` se muestra una lista completa de todos los archivos abiertos, junto con el ID del proceso (PID) y el comando que los abrió. - Por ejemplo, ejecutar `lsof -i` enumera todos los archivos/sockets de red, lo cual es extremadamente útil para descubrir qué proceso está escuchando en un puerto de red específico (como el puerto 80).
Detener procesos no autorizados (eliminar)
Imagina que una aplicación de tu teléfono se congela, bloquea completamente la pantalla y necesitas cerrarla a la fuerza para que todo vuelva a funcionar sin problemas. En Linux, detenemos los programas que se comportan mal o se congelan usando el comando `kill` seguido del ID de proceso (PID) del programa. - Al ejecutar `kill 1234` se envía una solicitud cortés pidiendo al programa que guarde su trabajo y lo cierre. - Si se congela e ignora la solicitud cortés, `kill -9 1234` obliga al sistema operativo a apagarlo instantáneamente. Tenemos un proceso fuera de control con PID `9999` acaparando toda nuestra CPU en este momento. ¡Apaguémoslo!
Ejecutando trabajos en segundo plano
Imagínese intentar copiar una carpeta enorme a una unidad USB, pero mientras se copia, desea seguir trabajando y escribiendo otros comandos en la misma ventana. En Linux, podemos ejecutar tareas que consumen mucho tiempo en "segundo plano" para que no bloqueen nuestra línea de comandos. - Agregar un signo `&` al final de un comando (como `sleep 100 &`) le indica al terminal que lo ejecute en segundo plano y le devuelva el mensaje inmediatamente. - El comando `jobs` muestra lo que se está ejecutando actualmente en segundo plano. - El comando `fg` (primer plano) devuelve una tarea en segundo plano al centro del escenario.
Amabilidad del proceso (nice & renice)
En una oficina ocupada, algunas tareas de baja prioridad (como presentar recibos) pueden esperar, mientras que las solicitudes de alta prioridad deben manejarse de inmediato. Linux gestiona la prioridad del proceso utilizando valores de **amabilidad** que van desde -20 (prioridad más alta) a 19 (prioridad más baja). - El comando `nice` inicia un proceso con una prioridad personalizada. P.ej. `nice -n 10 sleep 5` inicia un comando de suspensión con una prioridad educada de 10. - El comando `renice` altera la prioridad de programación de un proceso que ya se está ejecutando. Por ejemplo, `sudo renice +5 9999` reduce la prioridad del proceso 9999.
Reanudación de trabajos en segundo plano (bg)
Ya vimos cómo iniciar una tarea en segundo plano usando `&` y recuperarla usando `fg`. Pero, ¿qué pasa si inicia un comando sin `&` o lo suspende con `Ctrl+Z`? ¡Puedes reanudarlo en segundo plano usando `bg`! - El comando `bg` reanuda los trabajos suspendidos, permitiéndoles ejecutarse en segundo plano sin bloquear el indicador de terminal.
8. Diagnóstico de Redes
Prueba de conectividad (ping)
Imagínese intentar cargar una página web, pero su navegador gira sin cesar, dejándolo preguntándose si el Wi-Fi de su hogar está desconectado o si el sitio web se ha bloqueado. En Linux, probamos nuestra conexión de red básica usando el comando `ping`. - El comando `ping` envía pequeños paquetes de datos a un servidor (como `google.com`) y mide cuántos milisegundos se necesitan para recibir una respuesta. - En Linux, `ping` seguirá ejecutándose para siempre de forma predeterminada. Para detenerlo después de algunos intentos, usamos el indicador `-c` (recuento), ejecutando `ping -c 3 google.com`. **Por qué esto es importante**: si ejecuta `ping google.com` sin `-c`, continuará enviando paquetes e imprimiendo resultados infinitamente. Tendrá que interrumpirlo manualmente con `Ctrl+C` para ejecutar cualquier otro comando. El indicador `-c 3` detiene el comando automáticamente después de enviar exactamente 3 paquetes.
Interfaces de red e IP local
Imagine configurar una impresora de red o compartir archivos con la computadora de un amigo en el mismo Wi-Fi y necesitar saber la dirección IP local de su máquina. En Linux, inspeccionamos nuestro hardware de red y nuestras IP usando el comando `ip`. - Al ejecutar `ip addr` (o simplemente `ip a`) se imprime una lista de todos sus dispositivos de interfaz de red (como `eth0` para Ethernet por cable o `wlan0` para inalámbricos) junto con sus direcciones IP locales asignadas.
Comprobación de interfaces (ifconfig)
Antes de que el moderno conjunto de comandos `ip` se convirtiera en estándar, los administradores de sistemas Linux dependían de `ifconfig` (configurador de interfaces) para ver y administrar interfaces de red. - El comando `ifconfig` muestra las interfaces de red activas, la configuración de IP local, los detalles de la máscara de red y las direcciones MAC de hardware. Aunque está obsoleto en algunas distribuciones más nuevas, sigue siendo ampliamente utilizado en servidores heredados.
Conexiones de red (nmcli)
En las estaciones de trabajo y servidores Linux modernos, las interfaces de red son administradas por un demonio del sistema llamado NetworkManager. En lugar de editar manualmente los archivos de configuración, configuramos los detalles de la red usando `nmcli`. - El comando `nmcli` (NetworkManager CLI) le permite inspeccionar conexiones de hardware, estados de dispositivos y redes Wi-Fi activas.
Estadísticas de conexión y socket (netstat & ss)
Al configurar una base de datos o un servidor web, debe verificar que el servicio se esté ejecutando y escuchando en el puerto correcto, y verificar si se han establecido conexiones no autorizadas. Hacemos esto usando `netstat` o `ss`. - El comando `netstat` (estadísticas de red) es una herramienta clásica para mostrar conexiones TCP y puertos de escucha. P.ej. `netstat -tuln` enumera los puertos de escucha TCP/UDP. - El comando `ss` (estadísticas de sockets) es la alternativa moderna y más rápida a `netstat` que muestra detalles de conexión de sockets directamente desde el espacio de nombres del kernel.
Seguimiento de rutas de paquetes (traceroute)
Cuando una página web no se carga, ¿cómo identifica si el problema está en el enrutador de su hogar, su proveedor de servicios de Internet (ISP) o el servidor de destino? En Linux, rastreamos paquetes usando `traceroute`. - El comando `traceroute` enumera cada puerta de enlace (salto) del enrutador que atraviesa un paquete en su camino hacia un servidor remoto, junto con la latencia de respuesta para cada salto.
Descarga de archivos web (curl)
Imagine querer descargar un archivo o tomar el código de un script de configuración directamente desde un servidor web sin abrir un navegador y hacer clic en el botón "Descargar". En Linux, recuperamos datos web usando `curl` (abreviatura de "URL del cliente"). - Al ejecutar `curl <url>` se descarga el contenido de la página y se imprime directamente en la pantalla. - Para guardar el contenido descargado como un archivo en lugar de mostrarlo, lo emparejamos con la redirección `>` o el indicador de salida `-o`.
9. Búsqueda de Archivos
Búsqueda de archivos por nombre (buscar)
Imagine perder un archivo de texto importante en algún lugar de su carpeta de usuario y tener que buscar en docenas de directorios anidados uno por uno. En Linux, evitamos la búsqueda manual utilizando la utilidad `find` como un motor de búsqueda ultrarrápido en todo el sistema. - El comando `find` busca en árboles de directorios según el nombre, el tamaño, el tipo o la fecha. - La sintaxis es `find <where> -name "<pattern>"`. Por ejemplo, `find . -name "*.txt"` busca en el directorio actual y en todas las subcarpetas archivos que terminen en `.txt`. **Por qué esto es importante**: Si ejecuta `find . "*.log"` sin `-name`, obtendrá el error: `find: paths must precede expression: '*.log'`. El indicador `-name` es necesario para especificar que el patrón posterior debe compararse con los nombres de archivo.
Comprobación del historial de comandos
Imagine que escribió un comando de diagnóstico de red largo y complejo hace diez minutos y ahora necesita ejecutarlo nuevamente, pero no recuerda las opciones o la sintaxis exactas. En lugar de rascarte la cabeza o escribirlo todo, ¡Linux lo recuerda por ti! - El comando `history` muestra una lista numerada de todos los comandos que has ejecutado recientemente. - Puede volver a ejecutar rápidamente cualquier elemento escribiendo un signo de exclamación seguido de su número de lista (como `!42` para volver a ejecutar el comando n.° 42).
Páginas del manual de consulta
Imagínese intentar utilizar un nuevo comando, pero no está seguro de qué indicadores admite o cómo se deben formatear sus entradas. En lugar de buscar en línea, Linux tiene un manual de usuario completo y oficial integrado directamente en la terminal. - El comando `man` (manual) seguido de cualquier nombre de utilidad (por ejemplo, `man ls`) abre una guía de referencia detallada. - Dentro de la guía, te desplazas con las teclas de flecha, buscas con "/" y presionas `q` para cerrar el manual y regresar al mensaje.
10. Servicios y Systemd
Servicios de control (systemctl)
Imagine alojar un sitio web en su computadora, pero los visitantes reciben el error "No se puede acceder al sitio" porque el programa del servidor web en segundo plano no se está ejecutando. En Linux, los procesos en segundo plano que se inician automáticamente y se ejecutan en segundo plano (como bases de datos, firewalls o servidores web) se denominan **servicios** y los administramos usando `systemctl`. - El comando `systemctl status <service>` comprueba si un servicio está activo o detenido. - Dado que iniciar o detener un servicio afecta a todos los usuarios y a la seguridad del sistema, debe usar `sudo` para ejecutar comandos como `sudo systemctl start <service>` o `sudo systemctl stop <service>`.
Registro del sistema (journalctl)
Ahora que puede iniciar y detener servicios en segundo plano con `systemctl`, ¿cómo soluciona los problemas cuando fallan? La utilidad `journalctl` le permite inspeccionar los registros del sistema generados por los servicios administrados por systemd. - De forma predeterminada, `journalctl` muestra todos los registros del sistema. Debido a que esto puede ser enorme, los filtramos para mantenernos enfocados. - La opción `-u <service>` filtra los registros para mostrar solo mensajes de un servicio específico (por ejemplo, `journalctl -u apache2`). - La opción `-n <number>` muestra solo las entradas más recientes (por ejemplo, `journalctl -n 5` para los últimos 5 registros). - El indicador `-f` (seguir) muestra los registros en tiempo real a medida que se escriben.
11. Edición de Texto en Terminal
Edición de archivos de configuración (nano)
Imagine conectarse mediante SSH a un servidor remoto en la nube donde no tiene un escritorio gráfico ni un cursor y necesita corregir rápidamente una línea en un archivo de configuración. En estos escenarios, debe utilizar un editor de texto de terminal como `nano`. - Al ejecutar `nano <filename>` se carga un editor de texto simple y liviano directamente dentro de la ventana de shell. - Los accesos directos siempre se muestran en la parte inferior de la pantalla: presione `Ctrl+O` para escribir (guardar) sus cambios y `Ctrl+X` para salir del editor.
12. Scripts Shell y Automatización
Escribiendo tu primer script Bash
Imagina tener una lista de 20 tareas que debes ejecutar todas las mañanas. Escribirlos manualmente es tedioso y deja lugar a errores tipográficos. En Linux, agrupamos comandos en un archivo llamado script de shell para poder ejecutarlos todos a la vez. - Cada script comienza con un "shebang" (`#!/bin/bash`) en la primera línea para indicarle al sistema qué intérprete de shell usar para ejecutar el archivo. - Después de guardar el script, lo hace ejecutable otorgándole permiso de ejecución a través de `chmod 755 script.sh` y luego ejecutándolo con `./script.sh`.
Variables y argumentos ($1)
Imagine crear un mensaje de bienvenida personalizado para un sitio web. ¡No querrás escribir un guión separado para el nombre de cada cliente! En su lugar, escribe un script que toma un nombre como entrada cuando lo ejecuta. - En los scripts bash, variables como `$1`, `$2`, etc. retienen los "argumentos" o entradas que pasa en la línea de comando. - Por ejemplo, ejecutar `./greet.sh Alice` significa que `$1` dentro del script contendrá automáticamente el texto "Alice". De manera similar, `$#` realiza un seguimiento de cuántas entradas proporcionó el usuario.
Lógica condicional (if/else)
Imagine crear un script que procese un informe CSV, pero falla si el archivo del informe no existe realmente en el disco. Para evitar errores, escribimos scripts que toman decisiones usando lógica condicional `if/else`. - Comprobamos condiciones entre paréntesis: `if [ -f "$1" ]; then ... fi`. - El indicador `-f` comprueba si una ruta apunta a un archivo, mientras que `-d` comprueba si es un directorio. El script bifurca sus acciones dependiendo de si la condición se evalúa como verdadera o falsa.
Automatización con bucles
Imagine que tiene una carpeta de 100 archivos de registro y necesita hacer una copia de seguridad de cada uno de ellos. Copiarlos individualmente sería agotador. En Linux, usamos bucles `for` para repetir la misma acción en una lista completa de elementos automáticamente. - Un bucle `for` (como `for file in *.txt; do ... done`) itera sobre cada elemento que coincide con un patrón, procesándolos uno tras otro en una fracción de segundo.
Lógica reutilizable (funciones bash)
Ha escrito bucles y condicionales para automatizar acciones en scripts. Pero a medida que sus scripts crecen, copiar y pegar la misma lógica una y otra vez hace que sea difícil mantenerlos. En bash, podemos agrupar comandos en funciones reutilizables. - Para definir una función, la declaramos por su nombre seguido de paréntesis y llaves: `log_msg() { echo "msg"; }`. - Las funciones pueden recibir argumentos como los scripts de shell, a los que se accede utilizando los parámetros de posición local `$1`, `$2`, etc. dentro del cuerpo de la función. - Para llamar a una función, simplemente use su nombre como cualquier otro comando: `log_msg "Backup started"`.
Programación de tareas (crontab)
Ahora que ha escrito scripts de shell sólidos, no querrá iniciar sesión a medianoche solo para ejecutar su asistente de respaldo. Linux proporciona el servicio `cron` para ejecutar comandos o scripts automáticamente en momentos específicos. - El servicio cron verifica una tabla de programación llamada `crontab`. - Cada programación cron tiene 5 campos que representan la hora: `minute hour day-of-month month day-of-week` seguido del comando. - Por ejemplo, `30 2 * * * /path/to/script.sh` ejecuta un script todos los días a las 2:30 a.m. - Usamos `crontab -l` para enumerar nuestros trabajos cron activos y `crontab <filename>` para cargar programaciones desde un archivo.
13. Procesamiento Avanzado de Texto
Edición de secuencias con sed
Imagine que tiene un archivo de volcado de base de datos enorme y necesita reemplazar todas las apariciones de una dirección IP de servidor anterior por una nueva. Abrirlo en un editor podría congelar su computadora. En Linux, editamos secuencias de texto sobre la marcha usando `sed` (abreviatura de "editor de secuencias"). - La sintaxis básica es `sed "s/old/new/g" file.txt` para buscar y reemplazar texto. - Agregar el indicador `-i` (in situ) guarda los reemplazos directamente en el archivo, en lugar de simplemente imprimir el texto modificado en la pantalla. **Por qué esto es importante**: Si ejecuta `sed "s/port=80/port=8080/g" server.conf` sin `-i`, solo imprimirá el texto modificado en la pantalla de su terminal. El archivo real permanece completamente sin cambios. El indicador `-i` (in situ) es necesario para guardar los cambios directamente en el archivo.
Extracción de datos con awk
Imagine recibir una hoja de cálculo grande guardada como texto sin formato, donde las columnas están separadas por comas o espacios, y solo necesita extraer la primera columna de datos. En Linux, analizamos columnas estructuradas de texto utilizando el potente lenguaje `awk`. - De forma predeterminada, `awk` divide las líneas por espacios en blanco, asignando la columna 1 a `$1`, la columna 2 a `$2`, y así sucesivamente. - El indicador `-F` le permite especificar un separador personalizado (como `-F:` para dos puntos). Por ejemplo, `awk -F: '{print $1}' /etc/passwd` extrae solo los nombres de usuario de una lista separada por dos puntos. **Por qué esto es importante**: Si ejecuta `awk '{print $1}' /etc/shadow` sin `-F:`, `awk` dividirá las líneas por espacios en blanco (el valor predeterminado) en lugar de dos puntos. Dado que las líneas del archivo de sombra no tienen espacios, la línea completa se trata como un solo campo, imprimiendo los detalles completos del hash de cada usuario. La bandera `-F:` obliga a `awk` a dividir columnas por dos puntos.
Traducir y cortar datos
Imagine trabajar con una hoja de cálculo CSV de fechas y nombres de transacciones. Desea extraer solo la primera columna (fechas) y convertir todo el texto a letras mayúsculas para mantener la coherencia. En Linux, podemos combinar herramientas de análisis ligeras en una canalización: - El comando `cut` corta columnas específicas del texto estructurado. Por ejemplo, `cut -d, -f1` divide líneas por comas (`-d,`) y extrae la primera columna (`-f1`). - El comando `tr` (traducir) transforma caracteres de la entrada estándar, como intercambiar caracteres en minúsculas por mayúsculas (`tr "a-z" "A-Z"`). **Por qué esto es importante**: Si ejecuta `cut reports.csv` sin `-d,` y `-f1`, obtendrá: `cut: you must specify a list of bytes, characters, or fields`. Si especifica `-f1` pero omite `-d,`, el valor predeterminado es tabulaciones, lo que significa que no dividirá un archivo CSV y simplemente imprimirá la línea completa. El indicador `-d,` define la coma como separador de columnas y `-f1` le indica que extraiga solo la primera columna.
14. Entorno y Usuarios
Gestión de variables de entorno
Imagine que está implementando una aplicación web y necesita saber si se debe ejecutar en un entorno limitado de "desarrollo" local seguro o conectarse a la base de datos de "producción" en vivo. En Linux, pasamos configuraciones como esta a programas en ejecución usando **variables de entorno**. - Usamos el comando `export` para definir una variable para que cualquier programa iniciado por nuestro shell pueda leerla. Por ejemplo, __CÓDIGO1__. - Para comprobar o mostrar el valor de una variable, anteponemos su nombre con un signo de dólar: `echo $APP_ENV`.
Archivos y compresión (tar)
Imagine que tiene una carpeta que contiene 500 registros del servidor y desea enviarla por correo electrónico a un colega o hacer una copia de seguridad en el almacenamiento en la nube. Enviar 500 archivos individuales es lento e ineficiente. En Linux, los comprimimos en un único archivo compacto tipo zip usando `tar` (abreviatura de "archivo de cinta"). - Creamos archivos comprimidos usando banderas: `-c` (crear), `-z` (comprimir con gzip), `-v` (lista detallada de archivos) y `-f` (especificar nombre de archivo). Por ejemplo, `tar -czvf backup.tar.gz folder/` agrupa y comprime el directorio. **Por qué esto es importante**: Si ejecuta `tar -cz logs.tar.gz logs` sin `-f`, obtendrá: `tar: Refusing to write archive contents to terminal`. El indicador `-f` es fundamental porque le dice a `tar` que escriba la salida en un archivo en lugar de enviar datos de archivo binarios sin procesar directamente a su terminal. Los indicadores `-c` y `-z` también son necesarios para crear y comprimir el archivo respectivamente.
Compresión de archivos (gzip y gunzip)
Imagine que tiene un único archivo de texto que contiene un conjunto de datos masivo y desea reducir su tamaño para ahorrar espacio en el disco o acelerar el uso compartido. En Linux, comprimimos archivos individuales usando `gzip` y los restauramos usando `gunzip`. - El comando `gzip <filename>` comprime un archivo y lo reemplaza con una versión comprimida que termina en `.gz` (por ejemplo, `backup.txt` se convierte en `backup.txt.gz`). - El comando `gunzip <filename.gz>` descomprime el archivo restaurando la versión original.
Archivar con zip y descomprimir
Mientras que `tar` y `gzip` son estándar en Linux, `zip` es el formato de archivo más común en el mundo multiplataforma (Windows/macOS). En Linux, empaquetamos y comprimimos archivos en archivos zip usando `zip` y los extraemos usando `unzip`. - El comando `zip <archive.zip> <files>` crea un archivo zip. - El comando `unzip <archive.zip>` extrae los archivos del archivo.
Compresión alternativa (bzip2 y xz)
Más allá de `gzip` y `zip`, Linux admite otros formatos de compresión optimizados para relaciones de compresión más altas a expensas de la velocidad de la CPU. Estos son `bzip2` (bz2) y `xz` (xz). - El comando `bzip2 <file>` comprime un archivo y genera `<file>.bz2`. - El comando `xz <file>` utiliza compresión LZMA sin pérdidas para crear `<file>.xz`, lo que produce tamaños de archivo excepcionalmente pequeños, lo que lo hace ideal para las versiones del kernel de Linux.
Inspeccionando el entorno
Imagina que estás intentando depurar un script que sigue fallando porque no puede encontrar la ruta de un programa, o quieres ver qué cuenta de usuario está activa en esta terminal. En Linux, todas estas configuraciones de toda la sesión se almacenan juntas. - El comando `env` imprime un directorio completo de todas las variables de entorno actualmente cargadas en su sesión activa, lo que le permite verificar las configuraciones de una sola vez.
Encontrar comandos (cuáles)
Ahora que está familiarizado con las variables de entorno activas como `PATH` (que almacena los directorios donde Linux busca comandos), ¿cómo puede encontrar la ruta exacta del archivo del programa que se ejecuta cuando escribe `ls` o `grep`? Usamos `which` para localizar binarios de comandos. - El comando `which` busca las carpetas enumeradas en su variable `$PATH` e imprime la ruta absoluta del binario ejecutado cuando se ejecuta el comando (por ejemplo, `which ls` genera `/bin/ls`). - Esto es útil para encontrar dónde está instalada una herramienta o resolver conflictos entre múltiples versiones de la misma herramienta.
Atajos de Shell personalizados (alias)
Escribir comandos largos con múltiples indicadores puede resultar agotador. En Linux, podemos crear accesos directos personalizados llamados alias. Por ejemplo, puede asignar `ll` para ejecutar `ls -la` automáticamente. - Para crear un alias temporal, ejecute `alias name='command'` (por ejemplo, `alias ll='ls -la'`). - Ejecutar `alias` sin argumentos enumera todos los alias activos en la sesión actual. - Para que los alias sean permanentes durante los reinicios, normalmente se escriben en los archivos de configuración `.bashrc` o `.bash_profile`.
15. Sistema de Archivos Avanzado
Creación de enlaces (ln -s)
Imagine que tiene un archivo de configuración enterrado en lo profundo de una carpeta anidada, digamos `/var/www/html/configs/app/settings.conf`, pero necesita editarlo constantemente. En lugar de escribir la ruta larga de la carpeta cada vez, desea un acceso directo rápido en el escritorio. En Linux, hacemos esto creando enlaces. - **Enlace físico**: un clon directo que apunta a los datos del archivo sin procesar. Si elimina el archivo original, el enlace aún funciona. - **Enlace simbólico (enlace suave)**: un acceso directo basado en ruta (al igual que los accesos directos de Windows). Si elimina el archivo original, el enlace se rompe. Los creamos usando `ln -s target link_name`. **Por qué esto es importante**: si ejecuta `ln logs/app.log app_link.log` sin `-s`, creará un vínculo físico en lugar de un acceso directo simbólico. Si los archivos residen en diferentes particiones del disco, obtendrá: `ln: failed to create hard link: Invalid cross-device link`. El indicador `-s` crea un enlace simbólico flexible (acceso directo) que funciona en diferentes unidades y directorios.
Procesamiento de resultados de búsqueda (xargs)
Imagine que realizó una búsqueda que arrojó 100 archivos temporales y ahora desea eliminarlos todos. El resultado de la búsqueda es solo una lista de nombres de texto en su pantalla. ¿Cómo ingresa esos nombres como entradas directas al comando de eliminación? En Linux, salvamos esta brecha usando `xargs`. - El comando `xargs` (ejecutar argumentos) toma líneas de entrada estándar (como la lista de archivos de `find`) y las alimenta una por una como argumentos para otro comando. - Por ejemplo, `find . -name "*.tmp" | xargs rm` encuentra todos los archivos temporales y los elimina todos de una sola vez.
16. Acceso Remoto y Admin de Usuarios
Administración de usuarios (useradd & passwd)
Hasta ahora, ha estado trabajando como usuario `learner`. Pero en los servidores del mundo real, los administradores de sistemas deben administrar varias cuentas. Aprendamos cómo agregar nuevos usuarios y establecer sus contraseñas. - El comando `useradd` crea una nueva cuenta de usuario. Dado que la creación de cuentas afecta la seguridad del sistema, debe ejecutarse con privilegios de superusuario (por ejemplo, `sudo useradd deployer`). - El comando `passwd` establece o cambia la contraseña de un usuario. Ejecute como `sudo passwd deployer` para establecer la contraseña del usuario del implementador.
Administrar usuarios (adduser y userdel)
Mientras que `useradd` es una utilidad de bajo nivel que simplemente registra los detalles del usuario en archivos de configuración del sistema, los sistemas Debian/Ubuntu proporcionan un script interactivo de alto nivel llamado `adduser` que automatiza la creación de carpetas de inicio, la configuración de contraseñas y la inicialización de entornos de shell. Por el contrario, `userdel` elimina limpiamente las cuentas de usuario. - La ejecución de `sudo adduser tester` lo guía a través de la configuración del usuario de forma interactiva. - Al ejecutar `sudo userdel tester` se elimina la cuenta de usuario.
Visualización de identidades de usuario (id)
Al solucionar errores de permisos, debe verificar el contexto exacto del identificador de usuario y grupo en el que se está ejecutando. Hacemos esto usando `id`. - Al ejecutar `id` se imprime el ID de usuario (UID) del usuario actual, el ID de grupo principal (GID) y todas las listas de grupos suplementarios. - Ejecutar `id <username>` consulta información para un usuario específico.
Administración de grupos (groupadd y grupos)
En Linux, los usuarios se organizan en **grupos** para compartir permisos fácilmente. Por ejemplo, todos los desarrolladores pueden pertenecer a un grupo denominado `developers`. Esto nos permite compartir archivos con todo el equipo a la vez. - El comando `groupadd` crea un nuevo grupo. Dado que se trata de una configuración del sistema, requiere privilegios de superusuario (por ejemplo, `sudo groupadd developers`). - El comando `groups [username]` enumera todos los grupos a los que pertenece un usuario. Ejecutar sin argumentos, muestra grupos para el usuario actual.
Eliminación de grupos (groupdel)
Cuando los equipos de proyecto reorganizan o desmantelan servicios, se deben limpiar los grupos de seguridad correspondientes. En Linux, eliminamos grupos usando `groupdel`. - El comando `groupdel <group_name>` elimina permanentemente un grupo de los archivos de configuración del sistema, lo que requiere privilegios de superusuario.
Cambio de contextos de seguridad (su)
Ahora que ha creado la cuenta `deployer`, ¿cómo inicia sesión localmente para probar su entorno? En Linux, usamos el comando `su` (usuario sustituto) para cambiar de cuenta sin cerrar sesión. - El comando `su <username>` cambia el shell del terminal actual a la sesión de ese usuario. - Cuando se cambia, ejecutar `whoami` reflejará el nuevo nombre de usuario. - Para regresar a la sesión de su cuenta de usuario original, escriba `exit` o presione `Ctrl+D`.
Secure Shell Access (ssh)
Cambiar de usuario localmente es útil, pero en la computación en la nube, los servidores viven en centros de datos remotos. Para conectarnos a ellos de forma segura a través de la red, utilizamos `ssh` (Secure Shell). - El comando `ssh` cifra la conexión entre su máquina y un host remoto para evitar escuchas ilegales. - Sintaxis: `ssh user@hostname` o `ssh user@ip_address` (por ejemplo, `ssh admin@192.168.1.100`). - La primera conexión le pedirá que verifique la autenticidad del host remoto mostrando una huella digital ECDSA única. **Nota:** Dado que se trata de un entorno limitado basado en navegador, no existe un servidor remoto real al que conectarse. La ejecución de este comando le mostrará el patrón de salida esperado del mundo real (verificación del host, conexión, sesión) al instante, en lugar de una sesión interactiva en vivo real. En una terminal real, ssh lo colocaría en un shell remoto genuinamente separado hasta que escriba `exit`.
Transferencia segura de archivos (scp)
Ahora que sabe cómo iniciar sesión en un servidor remoto a través de SSH, ¿cómo se copia un archivo local (como un archivo de respaldo)? El comando `scp` (copia segura) copia archivos de forma segura entre hosts usando SSH internamente. - La sintaxis es `scp source_path user@host:destination_path`. - Por ejemplo, `scp log.txt admin@192.168.1.100:/tmp/` copia el archivo `log.txt` local a la carpeta remota `/tmp/`. **Nota:** Al igual que con ssh, aquí no hay un servidor remoto real: ejecutar este comando confirma que su archivo local existe y le muestra el resultado de transferencia esperado, pero en realidad no envía datos a ninguna parte.
Who Am I and Where Am I?.
Referencia de Comandos
Lista de Verificación
Pistas Reveladas
File Explorer
¿Qué es BashQuest?
Plataforma gratuita de práctica de terminal Linux en línea y juego interactivo. Ejecuta comandos reales en un sistema de archivos simulado con validación al instante.
¿Qué es BashQuest?
BashQuest es una plataforma gratuita de práctica de terminal Linux en línea y un juego de aprendizaje de bash creado para el aprendizaje práctico. A diferencia de cursos en video pasivos, BashQuest te enseña escribiendo comandos reales directamente en una terminal interactiva.
BashQuest funciona como una terminal Linux completa en línea, pero con objetivos de aprendizaje estructurados. El entorno es 100% seguro y corre enteramente en tu navegador.
Por qué creé este proyecto.
Cuando empecé a aprender Linux, temía ejecutar el comando equivocado y romper mi sistema. Quería crear el mejor recurso de aprendizaje: una terminal en línea sin riesgos donde cualquiera pueda aprender Linux gratis sin instalar máquinas virtuales.
La forma más rápida de dominar Linux es la repetición con estructura. Desarrollas memoria muscular real: escribiendo comandos, leyendo salidas de terminal e iterando hasta lograr el resultado exacto.
Práctica de Terminal Linux en Línea con Respuesta Inmediata
El aprendizaje de la terminal Linux es más rápido y duradero cuando practicas los comandos de inmediato. BashQuest ofrece una terminal interactiva donde ejecutas comandos reales sobre un sistema de archivos virtual.
Una Terminal Linux Virtual para un Aprendizaje Efectivo
BashQuest funciona como una terminal Linux completa en línea, pero con objetivos de aprendizaje estructurados. El entorno es 100% seguro y corre enteramente en tu navegador.
Por qué la Práctica Práctica Mejora la Retención
La forma más rápida de dominar Linux es la repetición con estructura. Desarrollas memoria muscular real: escribiendo comandos, leyendo salidas de terminal e iterando hasta lograr el resultado exacto.
Lo que aprenderás.
Nuestro plan de estudios progresivo abarca 16 conjuntos de habilidades fundamentales de administración de Linux:
Conceptos Básicos del Sistema de Archivos
Manipulación de Archivos
Tuberías y Filtrado
Redirección y Seguridad
Superusuario y Paquetes
Disco y Recursos del Sistema
Gestión de Procesos
Diagnóstico de Redes
Búsqueda de Archivos
Servicios y Systemd
Edición de Texto en Terminal
Scripts Shell y Automatización
Procesamiento Avanzado de Texto
Entorno y Usuarios
Sistema de Archivos Avanzado
Acceso Remoto y Admin de Usuarios
Herramientas y Utilidades Web de Linux
Utilidades interactivas para calcular permisos chmod, programar cron jobs, probar expresiones regulares y generar comandos.
Chmod calculator
Octal & symbolic output
chmod 000 [file]Cron job explainer
Plain-English translation
Command synthesizer
Pick a task, get the command
Select a task above to see the command.
—