Cómo crear un entorno profesional para programar en Linux con Visual Studio Code, Docker y Git

Objetivo de esta guía: preparar una computadora Linux para desarrollar proyectos con una estructura ordenada, configuración compartida, control de versiones, contenedores y un entorno que otro integrante del equipo pueda reproducir.

Sistema utilizado: los pasos principales están orientados a Ubuntu 24.04 o 26.04 de 64 bits. Las mismas herramientas pueden utilizarse en Debian, Fedora, openSUSE, Arch Linux y otras distribuciones, adaptando el gestor de paquetes.

sudo apt update
sudo apt full-upgrade -y

sudo apt install -y 
ca-certificates 
curl 
wget 
gpg 
build-essential 
unzip 
jq 
tree

mkdir -p ~/proyectos
cd ~/proyectos

pwd

sudo apt install -y git

git --version

git config --global user.name "Nombre Apellido"
git config --global user.email "Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo."

git config --global init.defaultBranch main
git config --global core.editor "code --wait"
git config --global core.autocrlf input
git config --global fetch.prune true

git config --global --list

Buena práctica: utiliza una identidad profesional coherente. En proyectos empresariales puede ser necesario configurar un correo diferente únicamente dentro del repositorio.

git config user.name "Nombre Corporativo"
git config user.email "Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo."

git config --local --list

ls -la ~/.ssh

ssh-keygen -t ed25519 -C "Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo."

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

cat ~/.ssh/id_ed25519.pub

sudo apt install -y wget gpg

wget -qO- https://packages.microsoft.com/keys/microsoft.asc | 
sudo gpg --dearmor -o /usr/share/keyrings/microsoft.gpg

sudo tee /etc/apt/sources.list.d/vscode.sources > /dev/null <<'EOF'
Types: deb
URIs: https://packages.microsoft.com/repos/code
Suites: stable
Components: main
Architectures: amd64 arm64 armhf
Signed-By: /usr/share/keyrings/microsoft.gpg
EOF

sudo apt update
sudo apt install -y code

code --version

cd ~/proyectos
code .

Alternativa abierta: el código fuente de VS Code se publica bajo licencia MIT, pero la compilación oficial de Microsoft incluye personalizaciones propias. Quienes prefieran una compilación comunitaria pueden evaluar VSCodium, verificando previamente la compatibilidad de extensiones.

code --install-extension ms-vscode-remote.remote-containers
code --install-extension ms-azuretools.vscode-containers
code --install-extension EditorConfig.EditorConfig

code --install-extension dbaeumer.vscode-eslint
code --install-extension esbenp.prettier-vscode

sudo apt remove -y \
  docker.io \
  docker-compose \
  docker-compose-v2 \
  docker-doc \
  podman-docker \
  containerd \
  runc

sudo apt update
sudo apt install -y ca-certificates curl

sudo install -m 0755 -d /etc/apt/keyrings

sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg 
-o /etc/apt/keyrings/docker.asc

sudo chmod a+r /etc/apt/keyrings/docker.asc

sudo tee /etc/apt/sources.list.d/docker.sources > /dev/null <

sudo apt install -y \
  docker-ce \
  docker-ce-cli \
  containerd.io \
  docker-buildx-plugin \
  docker-compose-plugin

sudo systemctl enable --now docker

sudo docker run hello-world

docker --version
docker compose version
docker buildx version

sudo systemctl status docker --no-pager

getent group docker || sudo groupadd docker

sudo usermod -aG docker "$USER"

newgrp docker

docker run hello-world

Advertencia de seguridad: pertenecer al grupo docker concede privilegios equivalentes a root sobre el equipo. No añadas usuarios no confiables y evita ejecutar imágenes de procedencia desconocida. Docker también ofrece un modo rootless para escenarios que requieren mayor aislamiento.

cd ~/proyectos

mkdir -p mi-aplicacion/{src,tests,.vscode,.devcontainer}
cd mi-aplicacion

touch README.md
touch Dockerfile
touch compose.yaml
touch .gitignore
touch .dockerignore
touch .editorconfig
touch .env.example

tree -a

mi-aplicacion/
├── .devcontainer/
├── .vscode/
├── src/
├── tests/
├── .dockerignore
├── .editorconfig
├── .env.example
├── .gitignore
├── compose.yaml
├── Dockerfile
└── README.md

root = true

[*]
charset = utf-8
end_of_line = lf
insert_final_newline = true
trim_trailing_whitespace = true
indent_style = space
indent_size = 2

[*.py]
indent_size = 4

[*.md]
trim_trailing_whitespace = false

.env
.env.*
!.env.example

node_modules/
vendor/
.venv/
**pycache**/
*.pyc

dist/
build/
coverage/

.vscode/*
!.vscode/settings.json
!.vscode/extensions.json

.DS_Store
*.log

.git
.gitignore
.env
.vscode
.devcontainer
node_modules
.venv
__pycache__
coverage
dist
build
*.log

FROM python:3.13-slim

ARG USERNAME=developer
ARG USER_UID=1000
ARG USER_GID=1000

RUN groupadd --gid ${USER_GID} ${USERNAME} 
&& useradd --uid ${USER_UID} 
--gid ${USER_GID} 
--create-home ${USERNAME} 
&& apt-get update 
&& apt-get install -y --no-install-recommends 
git 
curl 
&& rm -rf /var/lib/apt/lists/*

WORKDIR /workspace

USER ${USERNAME}

CMD ["sleep", "infinity"]

id -u
id -g

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    working_dir: /workspace
    volumes:
      - .:/workspace
    command: sleep infinity
    ports:
      - "${APP_PORT:-8000}:8000"
    environment:
      APP_ENV: development

APP_PORT=8000
APP_ENV=development

cp .env.example .env

docker compose config
docker compose up -d --build

docker compose ps
docker compose logs -f

docker compose down

{
  "name": "Entorno profesional Linux",
  "dockerComposeFile": "../compose.yaml",
  "service": "app",
  "workspaceFolder": "/workspace",
  "shutdownAction": "stopCompose",
  "customizations": {
    "vscode": {
      "extensions": [
        "ms-azuretools.vscode-containers",
        "EditorConfig.EditorConfig"
      ],
      "settings": {
        "editor.formatOnSave": true,
        "files.insertFinalNewline": true,
        "files.trimTrailingWhitespace": true
      }
    }
  }
}

cd ~/proyectos/mi-aplicacion
code .

Dev Containers: Reopen in Container

{
  "editor.formatOnSave": true,
  "editor.rulers": [
    88
  ],
  "files.insertFinalNewline": true,
  "files.trimTrailingWhitespace": true,
  "terminal.integrated.defaultProfile.linux": "bash"
}

{
  "recommendations": [
    "ms-vscode-remote.remote-containers",
    "ms-azuretools.vscode-containers",
    "EditorConfig.EditorConfig"
  ]
}

git init -b main

git status
git add .

git commit -m "chore: crear entorno inicial de desarrollo"

git remote add origin Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo.:USUARIO/mi-aplicacion.git

git remote -v
git push -u origin main

git switch -c feature/pagina-inicial

git add .
git commit -m "feat: agregar página inicial"

git push -u origin feature/pagina-inicial

1. Actualizar la rama principal con los cambios del equipo.
2. Crear una rama corta para la nueva tarea.
3. Abrir el proyecto dentro del Dev Container.
4. Ejecutar la aplicación y sus dependencias con Docker Compose.
5. Programar y ejecutar pruebas.
6. Revisar los cambios con git diff.
7. Crear commits pequeños y descriptivos.
8. Publicar la rama y solicitar revisión.
9. Eliminar contenedores y recursos que ya no sean necesarios.

git switch main
git pull --ff-only

git switch -c feature/nueva-tarea

docker compose up -d --build
docker compose logs -f

git status
git diff

docker compose down

• No almacenes contraseñas, tokens o claves privadas en Git.
• Mantén .env dentro de .gitignore.
• Publica únicamente un archivo .env.example sin valores sensibles.
• No utilices imágenes Docker desconocidas o sin mantenimiento.
• Evita la etiqueta latest en proyectos que necesiten reproducibilidad.
• No montes /var/run/docker.sock dentro de contenedores no confiables.
• Ejecuta las aplicaciones como usuarios sin privilegios.
• Actualiza Linux, VS Code, Docker y las dependencias del proyecto.
• No utilices chmod 777 como solución general para problemas de permisos.
• Revisa el Dockerfile y los scripts antes de construir imágenes externas.

• Instalar Docker desde varios repositorios diferentes.
• Guardar proyectos como root y después tener problemas de permisos.
• Instalar todas las versiones de un lenguaje directamente en el sistema.
• Utilizar una sola rama Git para todo el desarrollo.
• Realizar commits gigantes con cambios no relacionados.
• Guardar dependencias descargadas dentro del repositorio.
• No documentar los comandos necesarios para iniciar el proyecto.
• Compartir el archivo .env con secretos reales.
• Crear contenedores sin límites ni estrategia de limpieza.
• Depender de configuraciones personales que el resto del equipo no posee.

¿Necesito instalar el lenguaje en mi sistema Linux?

No necesariamente. Puedes instalar Python, Node.js, Java, PHP o Go dentro del contenedor de desarrollo y mantener el sistema anfitrión más limpio.

¿Docker reemplaza a Git?

No. Git administra el código y su historial. Docker define el entorno en el que ese código se construye y ejecuta.

¿Docker Compose sirve solamente para producción?

No. Es especialmente útil en desarrollo para iniciar conjuntamente la aplicación, la base de datos, la caché y otros servicios mediante un archivo compartido.

¿Qué ventaja ofrece Dev Containers?

Permite que los integrantes del equipo utilicen versiones similares de compiladores, intérpretes, dependencias y extensiones, reduciendo diferencias entre computadoras.

¿Es seguro añadir mi usuario al grupo docker?

Es cómodo, pero el grupo concede privilegios equivalentes a root. Debe reservarse para usuarios de confianza o sustituirse por Docker Rootless cuando la política de seguridad lo requiera.

¿Debo subir la carpeta .vscode al repositorio?

Puede subirse cuando contiene configuraciones y extensiones útiles para todo el equipo. Las preferencias estrictamente personales deberían permanecer fuera del repositorio.

¿Puedo utilizar GitLab en lugar de GitHub?

Sí. Git es independiente de la plataforma remota. El mismo entorno funciona con GitHub, GitLab, Gitea, Forgejo, Bitbucket o un servidor Git propio.

¿Visual Studio Code es obligatorio?

No. Docker y Git también pueden utilizarse con VSCodium, Neovim, Emacs, IntelliJ IDEA, Eclipse u otros editores.

• Programación en Linux: herramientas, lenguajes y entornos que todo desarrollador debe conocer
• La mejor distribución Linux para programadores en 2026
• Cómo instalar Docker en Ubuntu paso a paso
• Los mejores IDE para programar sobre GNU/Linux

Conclusión editorial

El objetivo no es que “funcione en mi computadora”, sino que el mismo proyecto pueda abrirse, construirse, probarse y mantenerse de forma predecible en todo el equipo.