Linux para desarrolladores: comandos que usarás todos los días

Si trabajas en desarrollo de software, tarde o temprano te encontrarás frente a una terminal de Linux. Puede ser en tu propia máquina, en un servidor en la nube, dentro de un contenedor Docker o en un pipeline de integración continua. Dominar los comandos de Linux para desarrolladores no es un lujo: es una habilidad que te ahorra horas de trabajo, te ayuda a depurar problemas más rápido y te hace sentir cómodo en cualquier entorno.

En esta guía repasamos los comandos que realmente usarás todos los días, explicados con ejemplos prácticos y pensados para quien programa, no para administradores de sistemas. No necesitas memorizarlos todos de golpe; lo importante es entender la lógica y volver a este artículo cuando lo necesites.

Por qué Linux es el entorno natural del desarrollador

La gran mayoría de los servidores del mundo ejecutan Linux. Las aplicaciones web que desarrollas probablemente se desplegarán en una distribución como Ubuntu, Debian o Alpine. Además, herramientas como Docker, Kubernetes, Node.js, Python, Go o Rust funcionan de forma nativa y fluida en este sistema. Aprender Linux significa reducir la distancia entre tu entorno de desarrollo y el de producción.

Otra ventaja es la automatización. Todo lo que haces con comandos puede convertirse en un script, y todo script puede ejecutarse de forma programada. Esa filosofía de combinar herramientas pequeñas para resolver problemas grandes es la esencia de la línea de comandos.

Navegación por el sistema de archivos

pwd: ¿dónde estoy?

El comando pwd (print working directory) muestra la ruta del directorio actual. Parece trivial, pero es útil cuando te pierdes entre carpetas.

$ pwd
/home/usuario/proyectos/mi-app

ls: listar contenido

Con ls ves los archivos de una carpeta. Sus opciones más útiles son:

ls -l      # formato largo con permisos, dueño y tamaño
ls -a      # incluye archivos ocultos (los que empiezan por punto)
ls -lh     # tamaños legibles (KB, MB, GB)
ls -lt     # ordena por fecha de modificación
ls -la     # combinación muy habitual

cd: moverse entre directorios

El comando cd cambia de directorio. Algunos atajos que ahorran muchas pulsaciones:

cd proyectos     # entra en la carpeta "proyectos"
cd ..            # sube un nivel
cd ~             # va a tu directorio personal
cd -             # vuelve al directorio anterior
cd /var/log      # ruta absoluta

Consejo: usa la tecla Tab para autocompletar nombres de carpetas y archivos. Es probablemente el atajo que más tiempo te ahorrará.

Crear, copiar, mover y borrar archivos

La gestión de archivos es el pan de cada día. Estos son los comandos esenciales:

mkdir nuevo-proyecto            # crea un directorio
mkdir -p src/components/ui      # crea toda la ruta, aunque no exista
touch index.js                  # crea un archivo vacío o actualiza su fecha
cp config.json config.bak       # copia un archivo
cp -r carpeta carpeta-copia     # copia un directorio completo
mv viejo.txt nuevo.txt          # renombra o mueve
rm archivo.txt                  # elimina un archivo
rm -r carpeta                   # elimina un directorio y su contenido

Ojo con rm: en Linux no existe papelera en la terminal. Un rm -rf mal escrito puede borrar horas de trabajo. Revisa siempre la ruta antes de pulsar Enter, y nunca ejecutes rm -rf / ni comandos que no entiendas copiados de internet.

Ver el contenido de archivos y logs

Como desarrollador pasarás mucho tiempo leyendo archivos de configuración y registros de errores. Estos comandos te permiten hacerlo sin abrir un editor:

cat archivo.txt        # muestra todo el archivo
less archivo.log       # navega por el archivo (q para salir)
head -n 20 app.log     # primeras 20 líneas
tail -n 50 app.log     # últimas 50 líneas
tail -f app.log        # sigue el archivo en tiempo real

El comando tail -f es imprescindible para depurar aplicaciones en vivo: mientras reproduces un error en tu app, ves cómo aparecen los mensajes en el log al instante. Si el archivo es muy grande, less es mejor que cat, porque no carga todo en pantalla. Dentro de less, pulsa / seguido de un texto para buscar.

Buscar archivos y texto: find y grep

grep: buscar texto dentro de archivos

grep es probablemente el comando que más usarás después de cd y ls. Busca patrones de texto y muestra las líneas que coinciden.

grep "error" app.log                 # líneas que contienen "error"
grep -i "error" app.log              # ignora mayúsculas/minúsculas
grep -n "TODO" src/main.py           # muestra el número de línea
grep -r "fetchUsers" ./src           # búsqueda recursiva en un proyecto
grep -rn "API_KEY" --include="*.js"  # solo en archivos .js
grep -v "debug" app.log              # excluye líneas con "debug"
grep -c "404" access.log             # cuenta coincidencias

Para proyectos grandes, existe una alternativa más rápida llamada ripgrep (rg), que respeta el archivo .gitignore y ofrece resultados casi instantáneos. Vale la pena instalarla.

find: localizar archivos

Mientras grep busca dentro de los archivos, find los localiza por nombre, tipo, tamaño o fecha.

find . -name "*.log"                    # archivos .log desde el directorio actual
find . -type d -name "node_modules"     # directorios llamados node_modules
find . -type f -size +100M              # archivos mayores de 100 MB
find . -mtime -1                        # modificados en las últimas 24 horas
find . -name "*.tmp" -delete            # encuentra y elimina

Un caso muy común: limpiar carpetas node_modules antiguas para recuperar espacio, o localizar un archivo de configuración cuya ubicación no recuerdas.

Tuberías y redirecciones

La verdadera potencia de la terminal aparece cuando combinas comandos. El símbolo | (pipe o tubería) toma la salida de un comando y la usa como entrada del siguiente.

cat access.log | grep "500" | wc -l          # cuántos errores 500 hay
ls -l | grep ".js"                           # solo archivos JavaScript
history | grep "docker"                      # busca en tu historial
ps aux | grep node                           # procesos de Node en ejecución
cat usuarios.txt | sort | uniq               # ordena y elimina duplicados

Las redirecciones guardan la salida en archivos:

echo "Hola" > saludo.txt        # sobrescribe el archivo
echo "Mundo" >> saludo.txt      # añade al final
comando 2> errores.txt         # redirige solo los errores
comando > salida.txt 2>&1     # redirige salida y errores juntos

Otros comandos útiles para procesar texto son wc (contar líneas y palabras), sort, uniq, cut, awk y sed. Con ellos puedes analizar logs o transformar datos sin escribir un programa completo.

Permisos y usuarios

Los errores de tipo “Permission denied” son habituales. Para entenderlos, ejecuta ls -l y observa la primera columna, por ejemplo -rwxr-xr--. Los tres bloques indican los permisos del propietario, del grupo y del resto de usuarios: lectura (r), escritura (w) y ejecución (x).

chmod +x script.sh          # hace el archivo ejecutable
chmod 755 script.sh         # propietario: todo; resto: lectura y ejecución
chmod 644 config.txt        # propietario: lectura/escritura; resto: lectura
chown usuario:grupo archivo # cambia propietario y grupo
sudo comando                # ejecuta con privilegios de administrador

Usa sudo solo cuando sea necesario. Ejecutar npm install o pip install con sudo suele generar problemas de permisos más adelante. Evita también el temido chmod 777: da acceso total a todo el mundo y casi nunca es la solución correcta.

Gestión de procesos

Cuando tu servidor de desarrollo se queda colgado o un puerto está ocupado, necesitas saber manejar procesos.

ps aux                    # lista todos los procesos
top                       # monitor en tiempo real (q para salir)
htop                      # versión más cómoda de top
kill 1234                 # pide al proceso 1234 que termine
kill -9 1234              # lo fuerza a terminar
pkill node                # termina procesos por nombre
lsof -i :3000             # qué proceso usa el puerto 3000

Un escenario clásico: intentas arrancar tu aplicación y aparece el error “address already in use”. Ejecutas lsof -i :3000, obtienes el PID del proceso que ocupa el puerto y lo cierras con kill. Problema resuelto en segundos.

Para ejecutar tareas largas sin bloquear la terminal, añade & al final del comando, o usa nohup para que siga funcionando aunque cierres la sesión. Para algo más robusto, consulta la sección de trucos de productividad sobre tmux.

Comandos de red y conexión remota

curl y wget

curl es la navaja suiza para probar APIs desde la terminal.

curl https://api.ejemplo.com/usuarios
curl -I https://midominio.com                    # solo cabeceras HTTP
curl -X POST https://api.ejemplo.com/login \
  -H "Content-Type: application/json" \
  -d '{"email":"a@b.com","password":"1234"}'
wget https://ejemplo.com/archivo.zip             # descarga un archivo

ping, ss y dig

ping -c 4 google.com      # comprueba conectividad
ss -tulpn                 # puertos en escucha y procesos asociados
dig midominio.com         # consulta DNS

ssh y scp

Conectarte a servidores remotos es parte esencial del trabajo diario:

ssh usuario@192.168.1.10               # conexión remota
ssh -i ~/.ssh/mi_clave.pem usuario@servidor
scp archivo.zip usuario@servidor:/home/usuario/   # copia al servidor
rsync -avz ./dist/ usuario@servidor:/var/www/app/ # sincroniza carpetas

Genera un par de claves con ssh-keygen -t ed25519 y evita depender de contraseñas. Además, puedes configurar alias de servidores en el archivo ~/.ssh/config para conectarte con un simple ssh produccion.

Gestores de paquetes

Instalar software desde la terminal es rápido y seguro. El comando depende de tu distribución:

Además del gestor del sistema, usarás gestores propios de cada lenguaje: npm o pnpm para JavaScript, pip para Python, cargo para Rust y go get para Go. Para mantener versiones distintas de un lenguaje, herramientas como nvm, pyenv o asdf son muy recomendables.

Git y Docker desde la terminal

Git: los comandos del día a día

git status                      # estado del repositorio
git add .                       # añade los cambios al área de preparación
git commit -m "Corrige bug de login"
git pull                        # trae cambios del remoto
git push                        # sube tus commits
git checkout -b feature/nueva   # crea y cambia a una rama nueva
git log --oneline --graph       # historial resumido
git diff                        # diferencias sin confirmar
git stash                       # guarda cambios temporalmente

Docker: contenedores sin dolor

docker ps                          # contenedores en ejecución
docker ps -a                       # todos, incluso los detenidos
docker images                      # imágenes locales
docker build -t mi-app .           # construye una imagen
docker run -d -p 8080:80 mi-app    # ejecuta en segundo plano
docker logs -f nombre-contenedor   # sigue los logs
docker exec -it nombre-contenedor bash   # entra en el contenedor
docker compose up -d               # levanta todos los servicios
docker system prune                # limpia recursos sin usar

Saber moverte dentro de un contenedor con docker exec es especialmente valioso: la mayoría de imágenes ligeras traen un sistema Linux mínimo, y todo lo que has aprendido en este artículo funciona allí igual.

Espacio en disco

Los discos llenos provocan fallos extraños: bases de datos que no escriben, builds que fallan, logs que no se generan. Estos dos comandos te darán la respuesta rápida:

df -h                          # espacio libre por partición
du -sh *                       # tamaño de cada elemento del directorio actual
du -h --max-depth=1 /var | sort -h   # quién ocupa más en /var
free -h                        # memoria RAM disponible

Trucos de productividad

Atajos de teclado en la terminal

• Ctrl + R: búsqueda inversa en el historial de comandos.
• Ctrl + C: interrumpe el comando en ejecución.
• Ctrl + L: limpia la pantalla.
• Ctrl + A / Ctrl + E: salta al inicio o al final de la línea.
• !!: repite el último comando (muy útil como sudo !!).

Alias

Si repites un comando largo, crea un alias en tu archivo ~/.bashrc o ~/.zshrc:

alias ll='ls -lah'
alias gs='git status'
alias dc='docker compose'
alias ..='cd ..'

Después ejecuta source ~/.bashrc para aplicar los cambios.

Variables de entorno

export NODE_ENV=production      # define una variable
echo $NODE_ENV                  # muestra su valor
env                             # lista todas las variables
printenv PATH                   # muestra una variable concreta

tmux: sesiones persistentes

tmux te permite tener varias terminales dentro de una sola ventana y mantenerlas activas aunque te desconectes del servidor. Es ideal para trabajar por SSH: inicias una sesión con tmux new -s trabajo, te desconectas con Ctrl + B y luego D, y vuelves después con tmux attach -t trabajo.

Documentación integrada

Cuando dudes sobre un comando, usa man comando para ver el manual completo, o comando --help para una referencia rápida. Si prefieres ejemplos prácticos, la herramienta tldr ofrece resúmenes sencillos con los usos más comunes.

Cómo practicar y aprender más rápido

Leer comandos no es suficiente: hay que usarlos. Te recomendamos instalar una distribución como Ubuntu en una máquina virtual, usar WSL2 si trabajas en Windows, o simplemente abrir la terminal de tu Mac, que comparte muchos comandos con Linux. Intenta resolver tus tareas cotidianas desde la terminal durante una semana: renombrar archivos, buscar en el código, revisar logs, subir cambios con Git. Notarás que la velocidad llega sola.

También es buena idea escribir pequeños scripts en Bash para automatizar tareas repetitivas, como preparar un entorno de desarrollo, hacer copias de seguridad o desplegar una aplicación. Cada script que escribas reforzará lo aprendido y te dará una base sólida para trabajar con DevOps y con la nube.

Preguntas frecuentes

¿Necesito Linux para ser desarrollador?

No es obligatorio, pero sí muy recomendable conocerlo. Puedes programar en Windows o macOS, aunque tarde o temprano tendrás que interactuar con servidores y contenedores Linux. Con WSL2 en Windows o la terminal de macOS puedes practicar la mayoría de estos comandos.

¿Qué distribución de Linux es mejor para empezar?

Ubuntu es la opción más popular por su gran comunidad y documentación. Debian ofrece estabilidad, Fedora incluye software más reciente y Linux Mint resulta muy amigable para quienes vienen de Windows.

¿Cuál es la diferencia entre Bash y Zsh?

Ambos son intérpretes de comandos (shells). Bash es el estándar en la mayoría de distribuciones; Zsh, que usa macOS por defecto, ofrece mejor autocompletado y personalización, especialmente con frameworks como Oh My Zsh. Los comandos de este artículo funcionan igual en los dos.

¿Cómo evito borrar archivos por error?

Usa rm -i para que te pida confirmación, revisa la ruta con ls antes de borrar y mantén tus proyectos bajo control de versiones con Git. Instalar herramientas como trash-cli también te permite enviar archivos a una papelera desde la terminal.

Conclusión

Dominar la terminal de Linux es una inversión que se paga sola. Los comandos de navegación, búsqueda, permisos, procesos, red, Git y Docker que hemos repasado cubren la gran mayoría de situaciones que enfrentarás como desarrollador. No intentes aprenderlo todo de una vez: empieza por cd, ls, grep y tail -f, añade nuevos comandos a medida que los necesites y apóyate en man cuando tengas dudas.

Con práctica constante, la línea de comandos pasará de ser un obstáculo a convertirse en tu herramienta más rápida y poderosa. Guarda este artículo entre tus favoritos, compártelo con tu equipo y, sobre todo, abre la terminal y empieza a practicar hoy mismo.