Oracle Cloud Free Tier: cómo alojo aplicaciones web en producción por 0 $/mes (para siempre)

Por qué existe la capa gratuita de Oracle Cloud (y por qué es legítima)

Voy a abordar el elefante en la habitación: sí, es realmente gratis. Para siempre. No "gratis durante 12 meses" como AWS. No "gratis con 200 $ en créditos que caducan" como Azure. El nivel Always Free de Oracle es una asignación permanente que no caduca, no se actualiza automáticamente y no te sorprende con una factura.

¿Por qué hace esto Oracle? Porque llegan tarde al juego de la nube y necesitan que los desarrolladores prueben su plataforma. Su apuesta es que un cierto porcentaje escalará a niveles de pago. Pero aunque nunca gastes un céntimo, los recursos Always Free siguen siendo tuyos.

Esto es lo que obtienes:

2 VMs AMD Micro - 1 OCPU, 1 GB de RAM cada una (o 1 VM ARM con hasta 4 OCPUs y 24 GB de RAM en Ampere A1)
200 GB de almacenamiento en bloque en total entre todas las VMs
10 TB/mes de transferencia de datos saliente
Dirección IPv4 pública incluida
2 bases de datos autónomas (20 GB cada una)
10 GB de almacenamiento de objetos

Para un portfolio personal, un proyecto paralelo, un entorno de staging o incluso una app de producción con poco tráfico, esto es más que suficiente.

Paso 1: Crea tu cuenta y tu VM

Regístrate en cloud.oracle.com. Necesitarás una tarjeta de crédito para la verificación de identidad, pero no se te cobrará nada, y puedes permanecer en el nivel Always Free indefinidamente.

Crea una instancia de cómputo:

Ve a Compute → Instances → Create Instance
Elige Ubuntu 22.04 (o 24.04) como imagen
Selecciona la forma VM.Standard.E2.1.Micro (elegible para Always Free) o la VM.Standard.A1.Flex (Ampere ARM, hasta 4 OCPU gratis)
En la sección de red, asegúrate de que Assign a public IPv4 address esté marcado
Sube tu propia clave pública SSH (más sobre esto a continuación)
Haz clic en Create

La VM estará lista en unos 60 segundos. Anota la IP pública: esa es la dirección permanente de tu servidor.

Paso 2: Claves SSH - Sube las tuyas propias (Esto es crítico)

Oracle te da la opción de generar un par de claves SSH durante la creación de la VM y descargar la clave privada. No uses esta opción.

¿Por qué? Por tres razones:

Las claves generadas en el navegador tienen la costumbre de romperse. Varios usuarios han informado de que las claves SSH generadas por Oracle dejan de funcionar al cabo de un tiempo: a veces tras un reinicio de la VM, a veces de forma aleatoria. Cuando tu clave deje de funcionar y la conexión serie de la consola sea tu único recurso, lamentarás no haber usado tu propia clave.
Deberías ser dueño de tus claves. Tu clave privada SSH debería residir en ~/.ssh/ en tu máquina, generada por ti, respaldada por ti. Una clave que se generó en un navegador, se descargó una vez y se guardó en tu carpeta de Descargas es un incidente de seguridad esperando a suceder.
Integración CI/CD. Si quieres que GitHub Actions despliegue en tu servidor (y lo quieres), necesitas la clave privada almacenada como secreto de GitHub. Empezar con tu propia clave hace que esto sea sencillo.

Genera un par de claves en tu máquina local si aún no tienes uno:

# Genera una clave ED25519 (moderna, rápida, segura)
ssh-keygen -t ed25519 -C "your-email@example.com"

# O RSA 4096 si necesitas mayor compatibilidad
ssh-keygen -t rsa -b 4096 -C "your-email@example.com"

# Copia la clave pública (pégala en el formulario de Oracle)
cat ~/.ssh/id_ed25519.pub

Pega el contenido de tu archivo .pub en el campo de clave SSH durante la creación de la VM. Eso es todo. Tu clave, tu control, sin sorpresas.

Paso 3: Abre los puertos (La parte que Oracle vuelve confusa)

Aquí es donde la mayoría de la gente se atasca. Te conectarás por SSH a tu VM, instalarás nginx y descubrirás que el puerto 80 es inalcanzable desde el mundo exterior. La razón: Oracle tiene dos cortafuegos, y necesitas abrir ambos.

Cortafuegos 1: Listas de seguridad de Oracle Cloud (nivel VCN)

Este es el cortafuegos a nivel de nube. Navega a:

Networking → Virtual Cloud Networks → tu VCN
Security Lists → Default Security List
Add Ingress Rules:

# Regla de entrada para HTTP
Source CIDR:   0.0.0.0/0
IP Protocol:   TCP
Destination Port Range: 80

# Regla de entrada para HTTPS
Source CIDR:   0.0.0.0/0
IP Protocol:   TCP
Destination Port Range: 443

Firewall 2: iptables dentro de la VM

Las imágenes de Ubuntu de Oracle vienen con reglas de iptables que bloquean todo el tráfico entrante excepto SSH. Incluso después de abrir la lista de seguridad de la nube, tu servidor rechazará las conexiones HTTP hasta que abras el firewall a nivel de sistema operativo:

# Abrir el puerto 80 (HTTP) y el 443 (HTTPS)
sudo iptables -I INPUT -p tcp --dport 80 -j ACCEPT
sudo iptables -I INPUT -p tcp --dport 443 -j ACCEPT

# Guardar las reglas para que persistan tras los reinicios
sudo apt-get install -y iptables-persistent
sudo netfilter-persistent save

Ambos firewalls deben estar abiertos. Esto hace tropezar a todo el mundo la primera vez. Si tu sitio no carga, comprueba primero la lista de seguridad de la nube y después iptables.

Paso 4: La configuración completa del servidor (Un solo script)

Este es el script de arranque que utilizo. Instala Python, nginx, configura Gunicorn como servicio de systemd y configura nginx como proxy inverso, todo en una sola ejecución:

#!/usr/bin/env bash
set -euo pipefail

# Instalar Python 3.12
sudo add-apt-repository -y ppa:deadsnakes/ppa
sudo apt-get update -qq
sudo apt-get install -y python3.12 python3.12-venv \
    python3.12-dev build-essential nginx

# Abrir el firewall
sudo iptables -I INPUT -p tcp --dport 80 -j ACCEPT
sudo iptables -I INPUT -p tcp --dport 443 -j ACCEPT
sudo apt-get install -y iptables-persistent
sudo netfilter-persistent save

# Clonar tu proyecto
APP_DIR="$HOME/myapp"
git clone git@github.com:you/your-repo.git "$APP_DIR"

# Crear un virtualenv e instalar las dependencias
python3.12 -m venv "$APP_DIR/.venv"
"$APP_DIR/.venv/bin/pip" install -r "$APP_DIR/requirements.txt"

# Crear un servicio systemd para Gunicorn
sudo tee /etc/systemd/system/myapp.service > /dev/null <<EOF
[Unit]
Description=My App (Gunicorn)
After=network.target

[Service]
User=ubuntu
Group=www-data
WorkingDirectory=$APP_DIR
EnvironmentFile=$APP_DIR/.env
ExecStart=$APP_DIR/.venv/bin/gunicorn myapp.wsgi:application \\
    --workers 2 --bind unix:/run/myapp.sock
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target
EOF

# Configurar el proxy inverso de nginx
sudo tee /etc/nginx/sites-available/myapp > /dev/null <<EOF
server {
    listen 80;
    server_name _;
    client_max_body_size 20M;

    location /static/ {
        alias $APP_DIR/staticfiles/;
        expires 30d;
    }

    location / {
        proxy_pass http://unix:/run/myapp.sock;
        proxy_set_header Host \$host;
        proxy_set_header X-Real-IP \$remote_addr;
        proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
    }
}
EOF

sudo ln -sf /etc/nginx/sites-available/myapp /etc/nginx/sites-enabled/
sudo rm -f /etc/nginx/sites-enabled/default
sudo nginx -t && sudo systemctl reload nginx

# Habilitar e iniciar
sudo systemctl enable myapp && sudo systemctl start myapp
echo "Done. Visit http://$(curl -s ifconfig.me)"

Paso 5: SSL con Let's Encrypt (HTTPS gratuito)

Una vez que el DNS de tu dominio apunte a la IP pública de la VM de Oracle, añadir HTTPS lleva dos comandos:

sudo apt-get install -y certbot python3-certbot-nginx
sudo certbot --nginx -d yourdomain.com

# Auto-renewal is set up automatically via systemd timer
# Verify with:
sudo certbot renew --dry-run

Certbot modifica tu configuración de nginx para escuchar en el 443 con el certificado y redirige el puerto 80 a HTTPS. SSL gratuito, renovado automáticamente cada 90 días, cero mantenimiento.

Paso 6: CI/CD con GitHub Actions

La pieza final: despliegues automatizados en cada push a main. Añade tu clave SSH privada como un secreto de GitHub (DEPLOY_SSH_KEY) y luego crea este workflow:

# .github/workflows/deploy.yml
name: Deploy
on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Deploy via SSH
        uses: appleboy/ssh-action@v1.0.3
        with:
          host: your-server-ip
          username: ubuntu
          key: ${{ secrets.DEPLOY_SSH_KEY }}
          script: |
            cd ~/myapp
            git pull origin main
            bash scripts/deploy.sh

Haces push a main, GitHub se conecta por SSH a tu VM de Oracle, extrae el código, ejecuta las migraciones, recopila los archivos estáticos y reinicia Gunicorn. CI/CD completo por 0 $.

Oracle Free Tier frente a AWS EC2 t2.micro: la comparación real

AWS ofrece una t2.micro en su capa gratuita, pero solo durante 12 meses. Después de eso, pagas. Déjame comparar ambas honestamente:

Oracle Free Tier    AWS t2.micro
                        ────────────────    ────────────
Price after year 1      $0 (forever)        ~$8.50/month
vCPUs                   1 OCPU              1 vCPU
RAM                     1 GB (or 24 GB ARM) 1 GB
Storage                 50 GB boot + 150 GB 8 GB (30 GB free)
Outbound transfer       10 TB/month         100 GB/month (then $0.09/GB)
Public IPv4             Included            $3.75/month (since Feb 2024)
Always Free             Yes                 No (12 months only)
ARM option (24GB RAM)   Yes (Ampere A1)     No (Graviton is paid)

Los números hablan por sí solos. Oracle te da más almacenamiento, 100 veces el ancho de banda, una IP pública gratuita y nunca caduca. La capa gratuita de AWS ya era tacaña, y desde que empezaron a cobrar 3,75 $/mes por las direcciones IPv4 públicas en febrero de 2024, mantener incluso una instancia EC2 detenida cuesta dinero.

La forma Ampere A1 ARM es el verdadero as en la manga. Puedes asignar hasta 4 OCPU y 24 GB de RAM en la capa Always Free. Eso no es una máquina de aficionado: es un servidor legítimo capaz de ejecutar simultáneamente una base de datos, una aplicación Django y una caché Redis.

Los detalles que nadie te cuenta

La capa gratuita de Oracle es excelente, pero tiene aristas afiladas:

Las instancias inactivas se reclaman. Oracle se reserva el derecho de detener las instancias Always Free que estén "inactivas" (de forma constante por debajo del 10% de uso de CPU y del 10% de uso de memoria). Ejecutar un servidor web ligero suele mantenerte por encima del umbral, pero tenlo en cuenta.
La disponibilidad es limitada. Las VM de la capa gratuita son populares. Si tu región está llena, no podrás crear una instancia nueva. Prueba distintos dominios de disponibilidad o regiones. Algunas personas automatizan la API de creación para reintentar hasta que se libere un hueco.
Las claves SSH generadas por Oracle no son fiables. Lo he dicho antes y lo repito: sube tu propia clave.
El doble cortafuegos. Lista de seguridad de la nube + iptables del sistema operativo. Abre ambos o pasarás una hora depurando por qué no se puede llegar a nginx.
Sin envío de correo. Oracle bloquea el SMTP saliente (puerto 25) en la capa gratuita. Usa en su lugar un servicio de correo transaccional como Mailgun, SendGrid o Resend.

Lo que ejecuto en mi VM gratuita de Oracle

Este mismo sitio web (el portafolio y el blog que estás leyendo ahora mismo) se ejecuta en una VM del Free Tier de Oracle Cloud. El stack:

Django 5.x + Wagtail 6.x: el CMS y la capa de aplicación
Gunicorn con 2 workers, gestionado por systemd
Nginx como proxy inverso con servicio de archivos estáticos
SQLite para la base de datos (perfectamente válido para un sitio personal)
Let's Encrypt para SSL gratuito
GitHub Actions para despliegues sin intervención

Coste mensual total: $0. Coste anual total: $0. El único componente de pago es el nombre de dominio.

El sitio carga rápido, gestiona todo el tráfico que necesito y se despliega automáticamente cuando hago push a main. Para un portafolio de desarrollador, un blog, un proyecto paralelo o un entorno de staging, el Free Tier de Oracle Cloud es la mejor oferta en computación en la nube. Sin letra pequeña.

El servidor más barato es el que no cuesta nada. El mejor servidor es el que controlas por completo. Oracle Free Tier es ambas cosas.