Cómo preparar un entorno Linux para desarrollo: guía práctica para dejar tu sistema listo para programar de verdad

Introducción

Instalar Linux es solo el principio. Tener un sistema encendido no significa todavía tener un entorno de desarrollo cómodo, ordenado y realmente útil para trabajar todos los días.

De hecho, aquí es donde mucha gente se queda a medias.

Instalan Ubuntu o la distribución que les gusta, abren la terminal, ponen dos o tres herramientas, clonan un repositorio y ya sienten que “más o menos está listo”. El problema es que, cuando llega el trabajo real,

empiezan a aparecer pequeñas fricciones por todas partes:

• faltan paquetes básicos
• la terminal no está cómoda
• Git no está configurado
• PHP o Node no están bien instalados
• MySQL no está listo
• el editor no está fino
• no hay estructura clara de proyectos
• faltan alias, utilidades y herramientas de debugging
• hay problemas de permisos
• cada proyecto acaba montado distinto

Y al final eso se nota. No solo en productividad, también en orden mental.

Preparar un entorno Linux para desarrollo no consiste en instalar absolutamente todo lo que existe. Consiste en montar una base sólida, limpia y práctica para trabajar mejor. Una base que te permita abrir el equipo, entrar a tu terminal y sentir que tienes un sistema preparado para construir, probar, depurar y desplegar con comodidad.

Este post está pensado justo para eso.

Aquí vamos a recorrer cómo dejar Linux listo para desarrollar de verdad, con una visión práctica y realista. Hablaremos de actualización del sistema, terminal, estructura de trabajo, utilidades esenciales, Git, SSH, editores, runtimes, bases de datos, contenedores, navegador, depuración, seguridad básica y algunos hábitos que hacen una diferencia enorme cuando empiezas a trabajar en serio.

Da igual si vas a desarrollar con:

• PHP
• MySQL
• JavaScript
• TypeScript
• Node
• Python
• Bash
• APIs
• herramientas internas
• automatización
• proyectos personales
• un blog
• un panel
• una Raspberry Pi
• o incluso un stack mixto

La idea aquí es darte una base de entorno Linux realmente útil y profesional, sin humo y sin instalar cosas por moda.

Qué significa realmente tener un entorno Linux listo para desarrollo

Un entorno de desarrollo no es solo “tener un editor”.

Es el conjunto de herramientas, configuraciones y hábitos que hacen que trabajar en tu sistema sea más cómodo, más rápido y más consistente.

Un entorno bien preparado debería ayudarte a:

• abrir proyectos rápido
• trabajar cómodo en terminal
• usar Git sin fricciones
• tener tus runtimes listos
• instalar dependencias sin dolor
• probar servicios locales
• conectarte por SSH cuando haga falta
• levantar bases de datos
• depurar con más claridad
• automatizar tareas repetitivas
• mantener cierto orden entre proyectos

Dicho de otra manera: no se trata solo de programar, sino de preparar el terreno para que programar fluya mucho mejor.

Primer paso: actualizar el sistema antes de empezar a montar cosas

Parece obvio, pero conviene decirlo. Antes de instalar herramientas de desarrollo, actualiza el sistema.

En entornos basados en Debian o Ubuntu, lo normal sería:

sudo apt update
sudo apt upgrade

Esto ayuda a:

• tener paquetes al día
• evitar bugs conocidos
• reducir problemas de compatibilidad
• arrancar desde una base más limpia

Si acabas de instalar la distribución, este paso es casi obligado. No conviene empezar a meter herramientas encima de un sistema desactualizado.

También es buen momento para comprobar si necesitas drivers, codecs o algún ajuste básico de hardware si trabajas en un equipo de escritorio o portátil.

Instala herramientas básicas del sistema que vas a usar constantemente

Antes de pensar en stacks concretos, conviene montar una base de utilidades generales.

Muchas veces, estas herramientas son más importantes en el día a día que el lenguaje principal del proyecto.

Algunas muy útiles suelen ser:

• curl
• wget
• git
• htop
• tree
• unzip
• zip
• build-essential
• ca-certificates
• software-properties-common
• gnupg
• lsb-release

Un ejemplo típico en Ubuntu podría ser:

sudo apt install -y curl wget git htop tree unzip zip build-essential ca-certificates software-properties-common gnupg lsb-release

Esto no significa que esa lista sea sagrada, pero sí te deja una base muy cómoda para trabajar.

Por qué importan estas herramientas

• curl te ayuda a probar APIs, endpoints y descargas
• wget es útil para descargas desde terminal
• git es imprescindible
• htop te ayuda a vigilar procesos
• tree mejora la visualización de directorios
• unzip y zip resuelven tareas frecuentes
• build-essential ayuda cuando ciertas dependencias necesitan compilarse

Son pequeñas piezas que suman mucho.

Organiza tu espacio de trabajo desde el principio

Uno de los mejores hábitos que puedes tener es decidir desde temprano cómo vas a organizar tus proyectos.

No dejes que cada repositorio acabe en cualquier rincón del sistema.

Una estructura simple y útil puede ser algo como:

• un directorio general para proyectos
• subcarpetas por tipo o cliente
• una zona para scripts personales
• una zona para pruebas o laboratorios

Por ejemplo:

mkdir -p ~/Projects
mkdir -p ~/Projects/clientes
mkdir -p ~/Projects/personal
mkdir -p ~/Projects/labs
mkdir -p ~/scripts

Esto parece pequeño, pero mejora mucho el orden.

Cuando todo vive disperso entre Descargas, Escritorio y rutas aleatorias, el entorno se vuelve caótico más rápido de lo que parece.

Configura bien tu terminal: va a ser una de tus herramientas principales

Si vas a desarrollar en Linux, la terminal no es algo opcional ni decorativo. Va a formar parte de tu flujo de trabajo diario.

Por eso merece la pena dejarla cómoda.

Hay tres niveles aquí:

• shell
• prompt
• configuración de uso

Elegir entre Bash o Zsh

Bash sigue siendo una base excelente y está en todas partes. Muchísima gente trabaja toda su carrera con Bash sin problema.

Zsh también es muy popular por su experiencia más amigable, sobre todo si te interesa:

• autocompletado más rico
• mejor experiencia de prompt
• plugins
• personalización más cómoda

No hace falta caer en una guerra religiosa.

Si estás empezando, Bash está bien. Si quieres una experiencia algo más rica, Zsh puede gustarte mucho.

Ajusta tu archivo de configuración de shell

Si usas Bash, mirarás tu .bashrc.

Si usas Zsh, tu .zshrc.

Ahí puedes ir añadiendo cosas como:

• alias
• variables de entorno
• funciones pequeñas
• mejoras de prompt
• paths personalizados

Por ejemplo, alias útiles:

alias ll='ls -lah'
alias gs='git status'
alias gp='git pull'
alias ..='cd ..'
alias ...='cd ../..'

Esto no es imprescindible, pero sí hace la terminal mucho más agradable.

Añade alias que realmente uses, no una colección infinita

Un error común es copiar 80 alias de internet y luego no usar ni la mitad.

Mejor pocos, buenos y tuyos.

Ejemplos útiles para desarrollo:

• ll para listar con detalle
• gs para git status
• ga para git add
• gc para git commit
• artisan o phpunit si usas Laravel o PHP a menudo
• alias para ir rápido a tus carpetas de proyectos

Por ejemplo:

alias cdp='cd ~/Projects'
alias cdlabs='cd ~/Projects/labs'

Ese tipo de detalles te ahorra muchísimo tiempo a largo plazo.

Deja el prompt claro y útil

Tu prompt debería ayudarte a ver cosas como:

• usuario
• equipo
• ruta actual
• rama Git si aplica

No hace falta convertirlo en una nave espacial RGB.

Lo importante es que sea claro y útil.

Si trabajas con muchos repositorios, ver la rama Git en el prompt ayuda mucho a evitar errores.

Configura Git bien desde el principio

Git no es opcional en un entorno moderno de desarrollo. Aunque trabajes solo, te conviene muchísimo tenerlo bien configurado.

Configuración básica inicial

Normalmente querrás definir:

• nombre
• correo
• editor por defecto

Ejemplo:

git config --global user.name "Tu Nombre"
git config --global user.email "tu@email.com"
git config --global core.editor "nano"

O si usas VS Code:

git config --global core.editor "code --wait"

Configuraciones muy útiles

Puedes añadir también cosas como:

git config --global init.defaultBranch main
git config --global pull.rebase false

No son obligatorias, pero ayudan a dejar Git más alineado con flujos modernos.

Prepara tus claves SSH para Git y servidores

Esto es muy importante si vas a trabajar con:

• GitHub
• GitLab
• VPS
• servidores propios
• despliegues remotos

Generar una clave SSH te evita depender siempre de contraseña y mejora mucho el flujo.

Ejemplo:

ssh-keygen

Luego podrás usar esa clave para:

• autenticarte en servidores
• conectarte a proveedores Git
• firmar o acceder a repositorios privados si hace falta

Conviene guardar bien:

• tu clave privada protegida
• tu clave pública lista para copiar al servicio que la necesite

Esto es una base muy seria para un entorno Linux profesional.

Elige y configura bien tu editor o IDE

Aquí no hay una verdad única, pero sí conviene decidir tu herramienta principal y dejarla bien montada.

Opción muy habitual: Visual Studio Code

Si usas VS Code, conviene dejarlo listo con:

• extensiones del lenguaje que más uses
• Git integrado
• linting
• formateo automático
• tema legible
• terminal integrada cómoda

Por ejemplo, según tu stack, podrías necesitar:

• PHP Intelephense
• Prettier
• ESLint
• extensiones de Docker
• Python
• GitLens
• MySQL o SQL tools
• Markdown tools

La clave es no instalar 200 extensiones “por si acaso”.

Instala las que realmente mejoran tu flujo.

Otras opciones válidas

• Neovim o Vim si te gusta un enfoque más terminal
• JetBrains si tu stack y flujo lo justifican
• Sublime Text si quieres algo ligero
• incluso micro o nano para cosas puntuales

Pero normalmente conviene tener un editor principal bien afinado.

Instala el stack que sí vas a usar, no veinte stacks a la vez

Este es un punto importante. Mucha gente al preparar Linux para desarrollo instala:

• PHP
• Node
• Python
• Ruby
• Go
• Java
• Docker
• tres gestores de bases de datos
• cuatro versiones de todo

y termina con un sistema confuso, inflado y difícil de mantener.

Mejor decide tu base principal.

Como tú trabajas mucho con backend, PHP, MySQL, Linux, automatización y herramientas internas, un entorno muy sensato podría priorizar:

• PHP
• Composer
• MySQL o MariaDB
• Node y npm si te hace falta para frontend o tooling
• Git
• Docker opcional según tu flujo
• alguna utilidad de testing y APIs

Preparar PHP correctamente

Si PHP forma parte de tu stack, no basta con instalar “php” y ya.

Conviene pensar en:

• versión adecuada
• CLI
• extensiones necesarias
• Composer
• integración con tu editor
• posibles múltiples versiones si haces mantenimiento de varios proyectos

Instalar PHP CLI y módulos comunes

En Ubuntu, una base razonable puede incluir:

• php-cli
• php-mysql
• php-mbstring
• php-xml
• php-curl
• php-zip
• php-intl

Dependiendo del proyecto, también podrías necesitar:

• php-gd
• php-bcmath
• php-soap
• php-imagick

Comprobar que está bien instalado

php -v

Y para ver módulos:

php -m

Eso ayuda mucho cuando algo no funciona y no sabes si falta una extensión.

Instala Composer si trabajas con PHP moderno

Composer es básico para la gestión de dependencias en PHP.

Con él podrás:

• instalar librerías
• gestionar paquetes
• levantar proyectos existentes
• seguir flujos modernos de desarrollo

Una vez instalado, comprueba:

composer --version

Conviene que Composer esté accesible desde terminal y bien integrado en tu entorno.

Preparar MySQL o MariaDB para desarrollo

Si vas a trabajar con bases de datos localmente, conviene dejar un motor instalado y probado.

Qué necesitas mínimo

• servidor MySQL o MariaDB
• cliente de línea de comandos
• usuario con permisos razonables
• alguna base de pruebas

Comprobar servicio

Por ejemplo:

systemctl status mysql

o el servicio equivalente si usas MariaDB.

Crear una base o usuario de pruebas

Conviene que tu entorno local tenga:

• una base de datos sandbox
• usuarios pensados para desarrollo
• no depender siempre de root para todo

Esto te ayuda a reproducir mejor entornos reales.

Node.js y npm: aunque no seas frontend puro, seguramente los usarás

Incluso si tu stack principal no es JavaScript, hoy muchas herramientas dependen de Node:

• bundlers
• herramientas de frontend
• Vite
• scripts de build
• utilidades varias
• extensiones y pipelines

Tener Node bien instalado evita muchos dolores de cabeza.

Comprueba instalación

node -v
npm -v

Y si trabajas con varios proyectos distintos, puede interesarte más adelante usar un gestor de versiones como nvm.

Eso ayuda mucho cuando una app pide una versión y otra pide otra distinta.

Python: aunque no sea tu stack principal, suele ser útil

Python aparece bastante en:

• automatización
• scripts auxiliares
• herramientas del sistema
• proyectos rápidos
• pequeños pipelines

Por eso no está de más tenerlo listo.

Comprueba:

python3 --version
pip3 --version

No hace falta convertir Python en protagonista, pero sí tenerlo disponible puede ayudarte mucho.

Instala herramientas para trabajar con APIs

Si haces backend, integración o pruebas, conviene tener herramientas cómodas para APIs.

curl

Ya lo mencionamos antes, pero merece insistir:

curl es básico.

Postman o Insomnia

Si prefieres entorno gráfico, alguna de estas herramientas puede venirte muy bien para:

• probar endpoints
• guardar colecciones
• revisar cabeceras
• hacer pruebas rápidas de autenticación

No es obligatorio, pero sí muy útil.

Docker: úsalo si encaja con tu flujo, no por moda

Docker puede ser muy útil para:

• levantar servicios aislados
• reproducir entornos
• montar stacks rápidos
• probar versiones diferentes
• trabajar en equipos con consistencia

Pero no es obligatorio para todo el mundo ni para todo proyecto.

Cuándo sí compensa

• trabajas con varios servicios
• necesitas reproducibilidad
• compartes entorno con otros
• haces despliegues o pruebas más profesionales
• quieres aislar dependencias

Cuándo no hace falta correr

• tus proyectos son pequeños
• tu flujo actual local es simple y estable
• todavía estás consolidando tu stack principal

Si lo usas, conviene aprenderlo bien y no convertirlo en otra capa de caos.

Ten una estrategia clara para archivos .env y variables de entorno

Muchos proyectos modernos dependen de variables de entorno.

Eso significa que tu entorno Linux debe manejar con cierta claridad cosas como:

• credenciales
• hosts
• puertos
• claves de APIs
• modos debug
• rutas especiales

Conviene:

• no hardcodear credenciales en scripts
• usar .env cuando el proyecto lo necesite
• no subir archivos sensibles al repositorio
• entender cómo exportar variables en shell si hace falta

Esto mejora mucho la higiene del entorno de desarrollo.

Instala y usa herramientas de búsqueda y navegación que mejoren tu flujo

Cuando trabajas mucho con terminal, algunas utilidades hacen una diferencia enorme.

Por ejemplo:

• grep
• find
• ripgrep si quieres búsquedas más cómodas y rápidas
• fzf si te gusta búsqueda interactiva
• bat como alternativa más amable a cat
• ncdu para explorar uso de disco

No necesitas todo desde el primer día, pero algunas de estas herramientas te dan mucha agilidad.

Ajusta el navegador para desarrollo, no solo para navegar

Tu navegador también forma parte del entorno de desarrollo.

Conviene tener claro:

• cuál vas a usar para pruebas
• cómo abrir DevTools rápido
• si usarás varios perfiles
• si necesitas extensiones concretas

Por ejemplo, puede ser útil tener:

• un perfil para desarrollo
• otro para uso personal
• extensiones mínimas y útiles
• limpieza de caché controlada cuando haga falta

Esto parece menor, pero ayuda bastante cuando haces debugging web.

Prepara una base mínima de debugging

Si desarrollas de verdad, no todo será escribir código. También tendrás que depurar.

Tu entorno debería ayudarte a:

• ver logs fácilmente
• seguir procesos
• leer errores
• revisar puertos
• probar servicios
• entender qué consume recursos

Herramientas y hábitos útiles:

• tail -f para logs
• journalctl para servicios
• htop para procesos
• ss -tulpn para puertos
• curl para endpoints
• php -S o servidores locales si aplican
• logs claros en tus proyectos

Un entorno de desarrollo serio no solo te ayuda a construir, también a entender qué falla.

Piensa en permisos y propiedad de archivos desde el principio

Especialmente si trabajas con:

• PHP
• servidores locales
• contenedores
• scripts
• proyectos clonados
• carpetas compartidas

Los permisos pueden volverse una molestia si no tienes una base sana.

Buenas ideas:

• no trabajar todo como root
• revisar propietarios de proyectos
• entender cuándo hace falta chmod y cuándo no
• no abrir permisos de forma absurda solo “para que funcione”

Es preferible entender el problema a resolver que tirar un 777 y seguir adelante.

Ten una carpeta de scripts personales

Esto aporta muchísimo valor con el tiempo.

Puedes guardar scripts para:

• levantar proyectos
• hacer backups rápidos
• reiniciar entornos
• limpiar caches
• abrir carpetas
• consultar IP
• comprobar servicios
• automatizar pequeñas rutinas

Por ejemplo:

mkdir -p ~/scripts

Y luego añadir esa ruta a tu PATH si te interesa.

Eso convierte pequeñas soluciones personales en parte real de tu entorno.

Usa cron o aliases solo cuando aporten valor real

No hace falta automatizar todo ni crear alias para todo comando existente.

Pero sí conviene detectar tareas repetitivas que merecen simplificarse.

Por ejemplo:

• levantar una app con varios pasos
• actualizar dependencias de forma recurrente
• revisar logs concretos
• abrir tus proyectos habituales

Un entorno bueno no es el que tiene más automatización, sino el que elimina fricciones reales.

Crea una base mínima de seguridad incluso en local

Aunque sea tu máquina de desarrollo, sigue siendo buena idea mantener ciertos hábitos:

• actualizaciones
• SSH seguro si usas acceso remoto
• no dejar credenciales por todos lados
• proteger tus claves privadas
• no subir .env o secretos al repo
• usar firewall si el contexto lo justifica
• tener cierto orden en servicios expuestos

Esto es especialmente importante si desarrollas también en equipos que salen de casa, comparten red o hacen pruebas remotas.

Si trabajas con varios proyectos, piensa en consistencia

Uno de los problemas clásicos en desarrollo es que cada proyecto se monta distinto:

• uno usa PHP 8.1
• otro PHP 8.2
• uno con MySQL local
• otro con Docker
• uno con variables distintas
• otro sin documentación mínima

Cuanta más consistencia puedas mantener, mejor.

Por ejemplo:

• misma estructura de carpetas
• misma estrategia de .env
• mismos atajos básicos
• misma forma de iniciar servicios
• mismos estándares de logs o scripts

Esto reduce mucho el desgaste mental.

Documenta tu propio entorno

Esto casi nadie lo hace al principio, pero ayuda muchísimo.

No hace falta escribir un tratado. Basta con guardar algo como:

• qué herramientas principales instalaste
• qué versiones usas
• dónde viven tus proyectos
• alias importantes
• rutas útiles
• puertos frecuentes
• cómo levantas tus stacks
• qué dependencias usas más

Cuando cambias de equipo o reinstalas, esto te ahorra horas.

Ejemplo de setup razonable para un backend developer con Linux

Si pienso en un setup muy sensato para alguien que hace backend, PHP, MySQL, Linux y automatización, me imagino algo así:

• sistema actualizado
• terminal cómoda con Bash o Zsh
• alias básicos útiles
• Git configurado con SSH
• VS Code bien montado
• PHP CLI + extensiones necesarias
• Composer
• MySQL o MariaDB local
• Node y npm por tooling
• Python disponible
• curl, htop, tree, unzip, build-essential
• carpeta ~/Projects
• carpeta ~/scripts
• logs y debugging básicos claros
• navegador listo para pruebas
• backups o al menos estrategia de respaldo mínima de tus proyectos y configuraciones

Eso ya deja un entorno muy funcional.

Errores comunes al preparar Linux para desarrollo

1. Instalar demasiadas cosas “por si acaso”

Terminas con un entorno inflado y confuso.

2. No organizar proyectos desde el principio

Luego todo vive desperdigado.

3. Dejar Git sin configurar bien

Y perder tiempo en cada commit o conexión.

4. No preparar SSH

Y depender siempre de contraseñas o flujos incómodos.

5. No ajustar la terminal

Y trabajar con una experiencia más torpe de lo necesario.

6. Usar root para resolver problemas de permisos

Mala costumbre que luego trae más caos.

7. No documentar nada

Y tener que reconstruir el entorno desde cero mentalmente cada vez.

8. Querer montar el “setup perfecto” antes de empezar

Mejor un entorno bueno y útil hoy que un supuesto entorno ideal que nunca terminas.

Una estrategia inteligente: empieza simple, mejora con uso real

Este punto es importante.

No necesitas dejar tu entorno “perfecto” en un solo día.

De hecho, muchas de las mejores mejoras aparecen después de usar el sistema:

• detectas qué repites mucho
• qué alias te faltan
• qué scripts te ahorrarían tiempo
• qué extensión sí aporta y cuál sobra
• qué stack realmente usas
• qué herramientas nunca tocas

Por eso, una buena estrategia es:

1. montar una base sólida
2. trabajar de verdad
3. refinar a partir del uso real

Eso suele dar mejores resultados que copiar un setup enorme de otra persona.

Conclusión:

Preparar un entorno Linux para desarrollo no se trata de instalar veinte herramientas y presumir setup. Se trata de construir un sistema que te ayude a trabajar mejor.

Un buen entorno de desarrollo en Linux debería darte:

• orden
• comodidad
• velocidad
• consistencia
• capacidad de depuración
• herramientas adecuadas para tu stack
• menos fricción en lo cotidiano

Si cuidas la terminal, Git, SSH, tus runtimes, tu editor, tus utilidades básicas y una estructura sensata de trabajo, Linux se convierte en una plataforma de desarrollo potentísima.

Y lo mejor es que no hace falta montarlo todo de golpe. Basta con empezar bien y mejorar con intención.