---
title: "Cómo instalar Wallabag con Docker en Ubuntu 24.04"
description: "Instala Wallabag con Docker Compose y MariaDB en Ubuntu 24.04, publícalo con Nginx y HTTPS y conéctalo a la extensión del navegador y a la app móvil."
category: "Productividad Self-Hosted"
language: es
source: https://cubepath.com/es/docs/productividad-self-hosted/instalacion-de-wallabag-leer-mas-tarde
updated: 2026-09-25
---

# Cómo instalar Wallabag con Docker en Ubuntu 24.04

Wallabag es una aplicación autoalojada para guardar artículos web y leerlos más tarde sin anuncios: extrae el contenido de la página, lo almacena en tu servidor y lo sincroniza con la extensión del navegador y las apps móviles. Es la alternativa natural a servicios como Pocket, que cerró en 2025. En esta guía desplegarás Wallabag con Docker Compose y MariaDB en Ubuntu 24.04, lo publicarás con Nginx y HTTPS y lo conectarás a tus clientes.

## Requisitos previos

- Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath, con al menos 1 GB de RAM.
- Un usuario no root con privilegios `sudo`.
- Docker Engine y el plugin Docker Compose instalados desde el repositorio oficial de Docker.
- Un subdominio, por ejemplo `leer.tu_dominio.com`, con un registro DNS `A` apuntando a la IP pública del servidor.
- Los puertos 80 y 443 accesibles desde Internet.

Sustituye `leer.tu_dominio.com` por tu subdominio real en todos los pasos.

## Paso 1: Preparar el directorio y los secretos

Crea el directorio del despliegue:

```bash
sudo mkdir -p /opt/wallabag
cd /opt/wallabag
```

Genera tres valores aleatorios: la contraseña de root de MariaDB, la del usuario de Wallabag y el secreto de la aplicación Symfony:

```bash
openssl rand -hex 24
openssl rand -hex 24
openssl rand -hex 32
```

Guárdalos en un archivo `.env`:

```bash
sudo nano /opt/wallabag/.env
```

```ini
DB_ROOT_PASSWORD=primer_valor_generado
DB_PASSWORD=segundo_valor_generado
APP_SECRET=tercer_valor_generado
DOMAIN=https://leer.tu_dominio.com
```

```bash
sudo chmod 600 /opt/wallabag/.env
```

## Paso 2: Crear el archivo de Docker Compose

El despliegue usa la imagen oficial `wallabag/wallabag` y MariaDB para los datos. En su primer arranque, el contenedor de Wallabag crea la base de datos y el usuario con la contraseña de root que le pases.

```bash
sudo nano /opt/wallabag/docker-compose.yml
```

```yaml
services:
  wallabag:
    image: wallabag/wallabag:latest
    container_name: wallabag
    restart: unless-stopped
    ports:
      - "127.0.0.1:8080:80"
    environment:
      MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}
      SYMFONY__ENV__DATABASE_DRIVER: pdo_mysql
      SYMFONY__ENV__DATABASE_HOST: db
      SYMFONY__ENV__DATABASE_PORT: "3306"
      SYMFONY__ENV__DATABASE_NAME: wallabag
      SYMFONY__ENV__DATABASE_USER: wallabag
      SYMFONY__ENV__DATABASE_PASSWORD: ${DB_PASSWORD}
      SYMFONY__ENV__DATABASE_CHARSET: utf8mb4
      SYMFONY__ENV__SECRET: ${APP_SECRET}
      SYMFONY__ENV__DOMAIN_NAME: ${DOMAIN}
      SYMFONY__ENV__SERVER_NAME: "Wallabag"
      SYMFONY__ENV__FOSUSER_REGISTRATION: "false"
      SYMFONY__ENV__FROM_EMAIL: wallabag@tu_dominio.com
      SYMFONY__ENV__MAILER_DSN: "null://null"
    volumes:
      - ./images:/var/www/wallabag/web/assets/images
    depends_on:
      db:
        condition: service_healthy

  db:
    image: mariadb:11.4
    container_name: wallabag-db
    restart: unless-stopped
    environment:
      MARIADB_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}
    volumes:
      - ./mysql:/var/lib/mysql
    healthcheck:
      test: ["CMD", "healthcheck.sh", "--connect", "--innodb_initialized"]
      interval: 10s
      start_period: 30s
      timeout: 5s
      retries: 10
```

Notas sobre la configuración:

- `SYMFONY__ENV__DOMAIN_NAME` debe ser la URL pública con `https://`. Wallabag la usa para generar enlaces, imágenes y feeds.
- `SYMFONY__ENV__FOSUSER_REGISTRATION: "false"` desactiva el registro público; las cuentas se crean desde el panel de administración.
- `MAILER_DSN` con `null://null` desactiva el correo. Si quieres enviar correos, usa un DSN SMTP como `smtp://usuario:contraseña@smtp.tu_proveedor.com:587`.
- El puerto se publica solo en `127.0.0.1`, porque el acceso público pasará por Nginx.

## Paso 3: Arrancar Wallabag

```bash
sudo docker compose up -d
```

El primer arranque tarda algo más porque el contenedor crea el esquema de la base de datos. Sigue los logs hasta que se detengan los mensajes de instalación y aparezca el arranque del servidor web:

```bash
sudo docker compose logs -f wallabag
```

Pulsa `Ctrl+C` para salir y comprueba el estado de los servicios:

```bash
sudo docker compose ps
```

```output
NAME             IMAGE                      STATUS
wallabag         wallabag/wallabag:latest   Up 1 minute
wallabag-db      mariadb:11.4               Up 1 minute (healthy)
```

El endpoint `/api/info` es público y devuelve la versión instalada:

```bash
curl -s http://127.0.0.1:8080/api/info
```

```output
{"appname":"wallabag","version":"2.6.13","allowed_registration":false}
```

El número de versión dependerá de la imagen descargada.

## Paso 4: Publicar Wallabag con Nginx y HTTPS

Instala Nginx y Certbot:

```bash
sudo apt update
sudo apt install -y nginx certbot python3-certbot-nginx
```

Crea el bloque de servidor:

```bash
sudo nano /etc/nginx/sites-available/wallabag
```

```nginx
server {
    listen 80;
    listen [::]:80;
    server_name leer.tu_dominio.com;

    # Permite importar archivos de exportación grandes
    client_max_body_size 50M;

    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_read_timeout 120s;
    }
}
```

Activa el sitio y recarga Nginx:

```bash
sudo ln -s /etc/nginx/sites-available/wallabag /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx
```

Si usas UFW, permite SSH y el tráfico web:

```bash
sudo ufw allow OpenSSH
sudo ufw allow 'Nginx Full'
sudo ufw enable
```

Obtén el certificado:

```bash
sudo certbot --nginx -d leer.tu_dominio.com
```

Verifica el acceso por HTTPS:

```bash
curl -s https://leer.tu_dominio.com/api/info
```

```output
{"appname":"wallabag","version":"2.6.13","allowed_registration":false}
```

## Paso 5: Cambiar la contraseña por defecto

La imagen de Docker crea un usuario inicial llamado `wallabag` con la contraseña `wallabag`. Cámbiala antes de nada:

1. Abre `https://leer.tu_dominio.com` e inicia sesión con `wallabag` / `wallabag`.
2. Ve a **Configuración > Contraseña** y define una contraseña robusta.
3. En **Configuración > Información del usuario** cambia el correo, y en **Configuración > Ajustes** selecciona el idioma Español.

Este usuario es administrador. Desde **Gestión de usuarios** (menú lateral) puedes crear cuentas para otras personas, ya que el registro público está desactivado.

Prueba a guardar un artículo con el botón **+** de la barra superior pegando la URL de cualquier página. En unos segundos aparecerá en **Sin leer** con el texto extraído y las imágenes descargadas en el servidor.

## Paso 6: Crear un cliente de API y probarlo

La extensión del navegador, las apps y cualquier script se autentican con OAuth2. Crea un cliente en **Gestión de clientes API** (menú del usuario), pulsa **Crear un nuevo cliente**, dale un nombre y copia el **ID de cliente** y el **secreto de cliente**.

Pide un token de acceso con tus credenciales:

```bash
curl -s -X POST https://leer.tu_dominio.com/oauth/v2/token \
  -d grant_type=password \
  -d client_id='tu_client_id' \
  -d client_secret='tu_client_secret' \
  -d username='tu_usuario' \
  -d password='tu_contraseña'
```

```output
{"access_token":"ZGJmNTA2MDdmYTdmNWFiZjcxOWY3MjgxNz...","expires_in":3600,"token_type":"bearer","scope":null,"refresh_token":"..."}
```

Guarda el `access_token` en una variable y úsalo para añadir un artículo por la API:

```bash
export WALLABAG_TOKEN='valor_de_access_token'
curl -s -X POST https://leer.tu_dominio.com/api/entries.json \
  -H "Authorization: Bearer $WALLABAG_TOKEN" \
  -d url='https://www.debian.org/intro/about'
```

La respuesta es el artículo guardado en JSON, con su `id`, título y contenido. El token caduca en una hora; para renovarlo se usa `grant_type=refresh_token` con el `refresh_token` recibido.

## Paso 7: Conectar la extensión del navegador y la app móvil

La extensión **wallabagger** está disponible para Firefox y para navegadores basados en Chromium. Tras instalarla, abre sus opciones y configura:

1. **URL de Wallabag**: `https://leer.tu_dominio.com`.
2. **ID de cliente** y **secreto de cliente** del cliente de API del Paso 6 (puedes crear uno específico para la extensión).
3. Tu usuario y contraseña. Pulsa **Obtener token** y comprueba que la conexión se marca como correcta.

Desde ese momento, al pulsar el icono de la extensión, la página actual se guarda en tu instancia.

Las apps oficiales de wallabag para Android e iOS piden la URL del servidor, el usuario y la contraseña, y descargan los artículos para leerlos sin conexión.

## Paso 8: Feeds, importación y copias de seguridad

**Feeds.** En **Configuración > Feeds** genera un token para obtener feeds Atom privados de tus artículos sin leer, destacados o archivados, que puedes seguir desde cualquier lector RSS.

**Importar.** El menú **Importar** admite, entre otros, exportaciones de otra instancia de wallabag, Instapaper, Pinboard y marcadores de Firefox o Chrome.

**Exportar.** Cada lista de artículos (sin leer, destacados, una etiqueta) se puede exportar en EPUB, PDF, CSV, JSON, TXT o XML desde el icono de exportación.

**Copias de seguridad.** Los datos están en MariaDB y en `/opt/wallabag/images`. Vuelca la base de datos:

```bash
cd /opt/wallabag
source <(sudo grep DB_ROOT_PASSWORD .env)
sudo docker compose exec -T db mariadb-dump -uroot -p"$DB_ROOT_PASSWORD" wallabag | sudo tee /opt/wallabag/wallabag.sql > /dev/null
ls -lh /opt/wallabag/wallabag.sql
```

Copia `wallabag.sql` y el directorio `images` a un almacenamiento externo.

## Paso 9: Actualizar Wallabag

Descarga la imagen nueva, recrea el contenedor y aplica las migraciones de base de datos que traiga la versión:

```bash
cd /opt/wallabag
sudo docker compose pull
sudo docker compose up -d
sudo docker compose exec wallabag /var/www/wallabag/bin/console doctrine:migrations:migrate --env=prod --no-interaction
```

## Solución de problemas

**Las imágenes o los enlaces apuntan a `http://` o a `127.0.0.1:8080`.** `SYMFONY__ENV__DOMAIN_NAME` no coincide con la URL pública. Corrige `DOMAIN` en `.env`, recrea el contenedor con `sudo docker compose up -d` y limpia la caché:

```bash
sudo docker compose exec wallabag /var/www/wallabag/bin/console cache:clear --env=prod
```

**Algunos artículos se guardan vacíos o sin texto.** Wallabag descarga la página desde el servidor, así que las webs con muro de pago, que requieren JavaScript o que bloquean peticiones automatizadas no se pueden extraer. Comprueba que el servidor alcanza la web con `curl -I https://sitio-del-articulo` y, si responde bien, el problema es la extracción de esa web en concreto.

**La extensión devuelve un error al obtener el token.** Revisa que el ID y el secreto de cliente son los del Paso 6, que la URL empieza por `https://` sin barra final y que `curl -s https://leer.tu_dominio.com/api/info` responde desde tu equipo.

## Conclusión

Tienes Wallabag funcionando con MariaDB, publicado con HTTPS y conectado a la extensión del navegador y a la app móvil. Como siguientes pasos, configura un `MAILER_DSN` real para poder restablecer contraseñas, activa la autenticación en dos pasos en **Configuración** y programa el volcado del Paso 8 con un temporizador de systemd.