---
title: "Python y entornos virtuales con venv en Ubuntu 24.04"
description: "Instala Python 3 en Ubuntu 24.04, crea entornos virtuales con venv, gestiona dependencias con pip y requirements.txt y ejecuta una app con Gunicorn y systemd."
category: "Despliegue de Aplicaciones"
language: es
source: https://cubepath.com/es/docs/despliegue-de-aplicaciones/instalacion-de-python-y-entornos-virtuales-venv
updated: 2026-09-25
---

# Python y entornos virtuales con venv en Ubuntu 24.04

Un entorno virtual de Python (`venv`) es un directorio con su propio intérprete y sus propios paquetes, separado del Python del sistema. Así cada proyecto tiene sus dependencias y versiones sin interferir con otros proyectos ni con las herramientas de Ubuntu que dependen de Python. En este tutorial instalarás Python 3 en Ubuntu 24.04, crearás un entorno virtual, gestionarás dependencias con `pip` y `requirements.txt` y, al final, ejecutarás una pequeña aplicación Flask con Gunicorn como servicio de systemd usando ese entorno.

## Requisitos previos

- Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath.
- Un usuario no root con privilegios `sudo`.
- Conocimientos básicos de la línea de comandos.

## Paso 1: Instalar Python 3, pip y venv

Ubuntu 24.04 incluye Python 3.12 como `python3`, pero el módulo `venv` y `pip` vienen en paquetes aparte. Actualiza el índice de paquetes e instálalos:

```bash
sudo apt update
sudo apt install python3 python3-venv python3-pip
```

Si vas a instalar paquetes que compilan extensiones en C (por ejemplo `psycopg2` sin binarios, o `mysqlclient`), añade también las cabeceras y el compilador:

```bash
sudo apt install python3-dev build-essential
```

Comprueba las versiones instaladas:

```bash
python3 --version
python3 -m pip --version
```

```output
Python 3.12.3
pip 24.0 from /usr/lib/python3/dist-packages/pip (python 3.12)
```

> Nota: en Ubuntu 24.04 no existe el comando `python`, solo `python3`. Dentro de un entorno virtual activado sí podrás usar `python` y `pip` directamente.

## Paso 2: Entender por qué pip no instala paquetes en el sistema

Ubuntu 24.04 aplica el PEP 668: el Python del sistema está marcado como gestionado externamente, de modo que `pip` se niega a instalar paquetes fuera de un entorno virtual para no romper las herramientas del sistema. Puedes comprobarlo:

```bash
python3 -m pip install requests
```

```output
error: externally-managed-environment

This environment is externally managed
To install Python packages system-wide, try apt install
python3-xyz, where xyz is the package you are trying to
install.
```

Tienes tres opciones correctas:

| Necesidad | Solución |
|---|---|
| Dependencias de un proyecto | Un entorno virtual con `python3 -m venv` (este tutorial) |
| Una herramienta de línea de comandos (por ejemplo `httpie` o `black`) | `pipx`, que crea un entorno aislado por herramienta |
| Una librería que usan scripts del sistema | El paquete de apt, como `python3-requests` |

No uses `--break-system-packages` ni `sudo pip install`: pueden sobrescribir módulos de los que depende el propio Ubuntu.

## Paso 3: Crear y activar un entorno virtual

Crea un directorio para el proyecto y, dentro de él, un entorno virtual llamado `.venv`. Este nombre es una convención que reconocen la mayoría de editores y herramientas:

```bash
mkdir ~/miproyecto
cd ~/miproyecto
python3 -m venv .venv
```

El comando crea `.venv/` con un intérprete enlazado al del sistema, su propio `pip` y un directorio `site-packages` vacío. Activa el entorno:

```bash
source .venv/bin/activate
```

El prompt muestra ahora el nombre del entorno. Comprueba que `python` y `pip` apuntan al entorno y no al sistema:

```bash
which python
pip --version
```

```output
/home/your_user/miproyecto/.venv/bin/python
pip 24.0 from /home/your_user/miproyecto/.venv/lib/python3.12/site-packages/pip (python 3.12)
```

Actualiza `pip` dentro del entorno. Esto solo afecta a este proyecto:

```bash
python -m pip install --upgrade pip
```

Para salir del entorno usa `deactivate`. No hace falta tenerlo activado para usarlo: basta con llamar a los binarios por su ruta, por ejemplo `~/miproyecto/.venv/bin/python`. Eso es lo que harás más adelante en el servicio de systemd.

## Paso 4: Instalar paquetes y fijar las dependencias

Con el entorno activado, instala los paquetes del proyecto. Para el ejemplo final necesitas Flask y Gunicorn:

```bash
pip install flask gunicorn
```

Lista lo instalado y comprueba que no hay dependencias rotas:

```bash
pip list
pip check
```

```output
No broken requirements found.
```

Guarda las versiones exactas en `requirements.txt`. Este archivo se versiona junto al código para reproducir el mismo entorno en otro servidor:

```bash
pip freeze > requirements.txt
cat requirements.txt
```

```output
blinker==1.9.0
click==8.2.1
Flask==3.1.2
gunicorn==23.0.0
itsdangerous==2.2.0
Jinja2==3.1.6
MarkupSafe==3.0.2
packaging==25.0
Werkzeug==3.1.3
```

Las versiones que veas serán las más recientes en el momento de instalar.

El directorio `.venv` no se versiona: depende de la ruta y del intérprete de cada máquina. Si usas Git, exclúyelo:

```bash
echo ".venv/" >> .gitignore
```

Para reconstruir el entorno en otra máquina, o desde cero si se corrompe, borra el directorio y reinstala desde el archivo:

```bash
deactivate
rm -rf .venv
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
```

Si quieres separar las herramientas de desarrollo (pytest, linters) de las de producción, crea un `requirements-dev.txt` que empiece con la línea `-r requirements.txt` y añada el resto. En producción instalas solo `requirements.txt`.

## Paso 5: Usar otra versión de Python (opcional)

Un entorno virtual usa la versión del intérprete con que lo creas. Si tu proyecto necesita una versión distinta de la 3.12 del sistema, el PPA `deadsnakes` publica otras versiones para Ubuntu LTS que se instalan junto a la del sistema sin reemplazarla:

```bash
sudo apt install software-properties-common
sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt update
sudo apt install python3.13 python3.13-venv
```

Crea el entorno con ese intérprete concreto:

```bash
python3.13 -m venv .venv
.venv/bin/python --version
```

```output
Python 3.13.7
```

> Advertencia: nunca cambies el enlace `/usr/bin/python3` ni uses `update-alternatives` para apuntarlo a otra versión. Muchas herramientas de Ubuntu, como `apt` y `add-apt-repository`, dependen de la 3.12.

## Paso 6: Ejecutar una aplicación en producción con el entorno virtual

En producción el entorno virtual no se activa: el servicio llama directamente a los binarios de `.venv/bin`. Vas a desplegar una aplicación Flask mínima en `/srv/miapp`, ejecutada por un usuario sin privilegios.

Crea el usuario de sistema y el directorio de la aplicación:

```bash
sudo useradd --system --home-dir /srv/miapp --shell /usr/sbin/nologin miapp
sudo mkdir -p /srv/miapp
sudo chown miapp:miapp /srv/miapp
```

Crea el archivo de la aplicación:

```bash
sudo -u miapp nano /srv/miapp/app.py
```

```python
from flask import Flask

app = Flask(__name__)


@app.get("/")
def index():
    return {"status": "ok"}
```

Crea el entorno virtual como el usuario `miapp` e instala las dependencias. Si has copiado tu `requirements.txt` a `/srv/miapp`, usa `-r requirements.txt` en lugar de nombrar los paquetes:

```bash
sudo -u miapp python3 -m venv /srv/miapp/.venv
sudo -u miapp /srv/miapp/.venv/bin/pip install flask gunicorn
```

Crea la unidad de systemd:

```bash
sudo nano /etc/systemd/system/miapp.service
```

```ini
[Unit]
Description=Aplicación Flask miapp (Gunicorn)
After=network.target

[Service]
User=miapp
Group=miapp
WorkingDirectory=/srv/miapp
ExecStart=/srv/miapp/.venv/bin/gunicorn --workers 3 --bind 127.0.0.1:8000 app:app
Restart=on-failure

[Install]
WantedBy=multi-user.target
```

`app:app` significa "el objeto `app` del módulo `app.py`". Gunicorn escucha solo en `127.0.0.1`, porque lo habitual es poner delante un proxy inverso como Nginx. Una regla orientativa para `--workers` es dos por núcleo de CPU más uno.

Carga la unidad, habilítala y arráncala:

```bash
sudo systemctl daemon-reload
sudo systemctl enable --now miapp
sudo systemctl status miapp
```

```output
● miapp.service - Aplicación Flask miapp (Gunicorn)
     Loaded: loaded (/etc/systemd/system/miapp.service; enabled; preset: enabled)
     Active: active (running) since Thu 2026-09-25 10:20:14 UTC; 3s ago
```

Comprueba que responde:

```bash
curl http://127.0.0.1:8000/
```

```output
{"status":"ok"}
```

Para actualizar dependencias más adelante, instala el nuevo `requirements.txt` con el `pip` del entorno y reinicia el servicio:

```bash
sudo -u miapp /srv/miapp/.venv/bin/pip install -r /srv/miapp/requirements.txt
sudo systemctl restart miapp
```

## Solución de problemas

**`The virtual environment was not created successfully because ensurepip is not available`.** Falta el paquete `venv` de esa versión de Python. Instala `python3-venv` (o `python3.13-venv` si usas deadsnakes) y vuelve a crear el entorno.

**`ModuleNotFoundError` al ejecutar la aplicación.** El paquete está instalado en otro entorno o en ninguno. Comprueba qué intérprete se usa con `which python` y lista los paquetes con `pip list` desde ese mismo entorno. En systemd, revisa que `ExecStart` apunte a `.venv/bin/` y no a `/usr/bin/`.

**El entorno deja de funcionar tras mover el directorio del proyecto.** Los scripts de `.venv/bin` contienen rutas absolutas. No muevas ni copies un entorno virtual: bórralo y créalo de nuevo en la ruta nueva con `pip install -r requirements.txt`.

**El entorno se rompe tras actualizar Ubuntu a otra versión.** Si cambia la versión menor de Python (por ejemplo de 3.12 a 3.13), el enlace del entorno apunta a un intérprete que ya no existe. Recrea el entorno igual que en el caso anterior.

**El servicio no arranca.** Consulta el error de Gunicorn en el journal:

```bash
sudo journalctl -u miapp -n 50 --no-pager
```

## Conclusión

Has instalado Python 3 en Ubuntu 24.04, has creado un entorno virtual aislado, has fijado sus dependencias en `requirements.txt` y has ejecutado una aplicación con Gunicorn y systemd usando el intérprete del entorno sin activarlo. Como siguientes pasos puedes poner Nginx como proxy inverso delante de Gunicorn con un certificado TLS de Let's Encrypt, auditar las dependencias con `pip-audit` y automatizar el despliegue desde tu repositorio.