Para respaldar una base de datos PostgreSQL, ejecuta pg_dump -F c -f mibd.dump mibd. Para restaurarla, crea una base de datos vacía y ejecuta pg_restore -d nuevabd mibd.dump. Después, automatízalo, guarda copias fuera del servidor y prueba tus restauraciones.
Una base de datos guarda la parte de una aplicación que no puedes reconstruir: registros de clientes, pedidos, contenido e historial. Los servidores fallan, alguien ejecuta el DELETE equivocado, las actualizaciones salen mal y el ransomware cifra discos. Un respaldo probado es lo que convierte cualquiera de esos problemas en una molestia en lugar de un desastre.
Esta guía va más allá de lo básico que se cubre en PostgreSQL para Principiantes. Explica los tipos y formatos de respaldo, cómo restaurar una base de datos completa o una sola tabla, cómo respaldar PostgreSQL cuando corre en Docker, cómo automatizar y verificar los respaldos con un script y cuándo necesitas respaldos físicos.
Todos los comandos de esta guía se probaron en PostgreSQL 17, con la misma base de datos bookstore (con las tablas authors y books) de la guía para principiantes.
Respaldos Lógicos vs. Físicos
PostgreSQL admite dos tipos de respaldo:
| Respaldo lógico | Respaldo físico | |
|---|---|---|
| Herramientas | pg_dump, pg_dumpall | pg_basebackup, archivado de WAL, pgBackRest, Barman |
| Qué copia | Definiciones SQL y datos | Los archivos de datos del servidor, byte por byte |
| Alcance | Una base de datos (o todas, con pg_dumpall) | Todo el servidor (clúster) |
| Restaurar en otra versión | Sí (la misma o una más nueva) | No, solo la misma versión mayor |
| Restaurar una sola tabla | Sí | No |
| Recuperación a un punto en el tiempo | No | Sí, con archivado de WAL |
| Ideal para | Bases de datos pequeñas y medianas, migraciones, la mayoría de los proyectos | Bases de datos grandes, mínima pérdida de datos |
Para la mayoría de los sitios web, aplicaciones y bases de datos de negocios pequeños, los respaldos lógicos con pg_dump son el punto de partida correcto. Son sencillos, portátiles y fáciles de restaurar. El resto de esta guía se enfoca en ellos, con una sección sobre respaldos físicos al final.
Antes de Empezar: Conectarte sin Escribir la Contraseña
pg_dump, pg_restore y psql aceptan las mismas opciones de conexión:
| Opción | Significado | Valor predeterminado |
|---|---|---|
-h | Servidor (host) | Socket local |
-p | Puerto | 5432 |
-U | Usuario | Tu nombre de usuario del sistema operativo |
-d | Base de datos | El mismo nombre que el usuario |
En Ubuntu, la forma más fácil de usar estas herramientas en local es como el usuario del sistema postgres: sudo -u postgres pg_dump ....
Para scripts que se conectan con contraseña, guárdala en un archivo .pgpass en la carpeta personal del usuario que ejecuta el respaldo, en lugar de ponerla dentro del script:
localhost:5432:bookstore:backup_user:tu-contraseña
El formato es servidor:puerto:base_de_datos:usuario:contraseña. PostgreSQL ignora el archivo a menos que solo su dueño pueda leerlo, así que ejecuta chmod 600 ~/.pgpass.
Respaldar una Base de Datos con pg_dump
pg_dump crea una copia consistente de una base de datos, aunque la gente la esté usando. No bloquea a quienes leen ni a quienes escriben.
Formato SQL Plano
pg_dump -U postgres -d bookstore -f bookstore.sql
Esto crea un archivo de texto legible lleno de comandos SQL (CREATE TABLE, COPY, etc.). Puedes abrirlo en cualquier editor, lo que lo hace práctico para bases de datos pequeñas, revisiones de código y para mover datos entre sistemas.
Formato Personalizado (Recomendado)
pg_dump -U postgres -F c -f bookstore.dump bookstore
-F c crea un archivo comprimido que solo pg_restore puede leer. Es la mejor opción predeterminada porque te permite:
- restaurar todo o solo algunas tablas,
- restaurar con varios procesos en paralelo,
- ver el contenido antes de restaurar,
- y usar
--cleanpara reemplazar objetos existentes.
Los Cuatro Formatos
| Formato | Opción | Resultado | Se restaura con | Respaldo en paralelo |
|---|---|---|---|---|
| Plano | -F p (predeterminado) | Archivo de texto .sql | psql | No |
| Personalizado | -F c | Un solo archivo comprimido | pg_restore | No |
| Directorio | -F d | Una carpeta de archivos | pg_restore | Sí (-j) |
| Tar | -F t | Archivo .tar | pg_restore | No |
Para bases de datos grandes, el formato de directorio puede respaldar varias tablas a la vez:
pg_dump -U postgres -F d -j 4 -f bookstore_dir bookstore
-j 4 usa cuatro procesos en paralelo. Los datos de cada tabla quedan en su propio archivo comprimido dentro de bookstore_dir.
En PostgreSQL 16 y versiones posteriores también puedes elegir el método de compresión, por ejemplo --compress=zstd, que suele dar archivos más pequeños y comprimir más rápido que la opción predeterminada.
Lo que pg_dump No Incluye
pg_dump guarda una base de datos, incluidas sus tablas, datos, índices y los permisos sobre esos objetos. No guarda los roles (usuarios) ni sus contraseñas, ni los tablespaces, porque pertenecen a todo el servidor. Respáldalos por separado:
pg_dumpall -U postgres --globals-only -f roles.sql
Para respaldar todas las bases de datos del servidor y los roles en un solo archivo SQL plano, ejecuta pg_dumpall -U postgres -f all-databases.sql. Es práctico para servidores pequeños, pero solo genera SQL plano, así que pierdes la flexibilidad del formato personalizado.
Restaurar una Base de Datos
Restaurar un Respaldo SQL Plano
Crea una base de datos vacía y ejecuta el archivo con psql:
createdb -U postgres bookstore_restore
psql -U postgres -X -v ON_ERROR_STOP=1 -d bookstore_restore -f bookstore.sql
ON_ERROR_STOP=1 hace que psql se detenga en el primer error en lugar de seguir y dejarte con una base de datos restaurada a medias. -X omite tu configuración personal de psql para que no interfiera.
Restaurar un Respaldo Personalizado o de Directorio
createdb -U postgres bookstore_restore
pg_restore -U postgres -d bookstore_restore bookstore.dump
Para un respaldo de directorio, agrega procesos en paralelo para acelerar la restauración:
pg_restore -U postgres -j 4 -d bookstore_restore bookstore_dir
Opciones Útiles de pg_restore
| Opción | Qué hace |
|---|---|
-C | Crea la base de datos con su nombre original antes de restaurar (conéctate con -d postgres) |
--clean --if-exists | Elimina los objetos existentes antes de volver a crearlos |
--no-owner | No intenta asignar los dueños originales (útil en otro servidor) |
--no-privileges | Omite los comandos GRANT y REVOKE |
-j N | Restaura con N procesos en paralelo |
--list | Muestra el contenido del archivo sin restaurar nada |
-t tabla | Restaura solo una tabla |
Algunas situaciones comunes:
Volver a crear la base de datos con su nombre original, por ejemplo en un servidor nuevo:
pg_restore -U postgres -C -d postgres bookstore.dump
Si ya existe una base de datos llamada bookstore, esto falla con database "bookstore" already exists. Elimínala primero o restaura con otro nombre.
Sobrescribir una base de datos existente con el contenido del respaldo:
pg_restore -U postgres --clean --if-exists -d bookstore bookstore.dump
Esto elimina y vuelve a crear cada objeto del respaldo, así que todo lo que haya cambiado desde el respaldo se pierde. Si no estás seguro, haz un respaldo nuevo antes.
Mover una base de datos a otro servidor o proveedor de hosting, donde no existen los usuarios originales:
pg_restore -U postgres --no-owner --no-privileges -d bookstore bookstore.dump
Todos los objetos quedarán a nombre del usuario que hace la restauración. Vuelve a otorgar los permisos después.
Restaurar una Sola Tabla
Alguien borró las filas equivocadas de books y solo quieres recuperar esa tabla. Primero revisa qué contiene el respaldo:
pg_restore --list bookstore.dump
220; 1259 16395 TABLE public books postgres
3434; 0 16395 TABLE DATA public books postgres
3284; 2606 16402 CONSTRAINT public books books_pkey postgres
3285; 2606 16403 FK CONSTRAINT public books books_author_id_fkey postgres
(Salida abreviada.) Puedes restaurar solo esa tabla en una base de datos vacía con -t books, pero ten en cuenta que -t restaura solo la definición de la tabla y sus filas, no su secuencia, su llave primaria ni sus llaves foráneas.
La forma más segura es restaurar todo el respaldo en una base de datos temporal y copiar solo lo que necesitas:
createdb -U postgres bookstore_scratch
pg_restore -U postgres -d bookstore_scratch bookstore.dump
Después compara las dos bases de datos, copia con SQL las filas que faltan y elimina bookstore_scratch cuando termines. La base de datos en producción no se toca hasta que estés seguro.
Respaldar PostgreSQL en Docker
Si PostgreSQL corre en un contenedor (como en MySQL con Docker, pero con la imagen postgres), ejecuta las herramientas dentro del contenedor y guarda el resultado en tu equipo:
docker exec my-postgres pg_dump -U postgres -F c bookstore > bookstore.dump
Para restaurar, envía el archivo de vuelta. Usa -i (no -t) para que el archivo binario pase correctamente:
docker exec my-postgres createdb -U postgres bookstore_restore
docker exec -i my-postgres pg_restore -U postgres -d bookstore_restore < bookstore.dump
Cambia my-postgres por el nombre de tu contenedor (docker ps lo muestra). Copiar el volumen de datos del contenedor mientras la base de datos está funcionando no es un sustituto seguro, porque los archivos pueden copiarse en un estado inconsistente.
Automatizar los Respaldos con un Script
Un respaldo que tienes que acordarte de ejecutar es un respaldo que tarde o temprano olvidarás. Este script crea un respaldo, comprueba que el archivo se pueda leer y elimina los respaldos con más de 14 días:
#!/usr/bin/env bash
# Nightly PostgreSQL backup with verification and cleanup.
set -euo pipefail
DB_NAME="bookstore"
BACKUP_DIR="/var/backups/postgres"
KEEP_DAYS=14
STAMP=$(date +%F_%H%M)
FILE="$BACKUP_DIR/${DB_NAME}_${STAMP}.dump"
mkdir -p "$BACKUP_DIR"
# 1. Create the backup in custom format.
pg_dump -F c -f "$FILE" "$DB_NAME"
# 2. Make sure the file can be read back.
pg_restore --list "$FILE" > /dev/null
# 3. Delete backups older than KEEP_DAYS days.
find "$BACKUP_DIR" -name "${DB_NAME}_*.dump" -mtime +"$KEEP_DAYS" -delete
echo "Backup complete: $FILE ($(du -h "$FILE" | cut -f1))"
set -euo pipefail detiene el script en la primera falla, así que un pg_dump fallido nunca borra tus respaldos anteriores. Guárdalo como /usr/local/bin/pg-backup.sh, hazlo ejecutable y dale al usuario postgres una carpeta donde pueda escribir:
sudo chmod +x /usr/local/bin/pg-backup.sh
sudo mkdir -p /var/backups/postgres
sudo chown postgres:postgres /var/backups/postgres
Una prueba muestra algo como:
Backup complete: /var/backups/postgres/bookstore_2026-11-14_0200.dump (8.0K)
Prográmalo todas las noches a las 2 a. m. en el crontab del usuario postgres (sudo crontab -u postgres -e):
0 2 * * * /usr/local/bin/pg-backup.sh >> /var/log/pg-backup.log 2>&1
Crea primero el archivo de log y asígnalo al usuario postgres (sudo touch /var/log/pg-backup.log && sudo chown postgres /var/log/pg-backup.log). Revisa el log de vez en cuando, o configura una herramienta de monitoreo que te avise cuando deje de actualizarse. Si eres nuevo en la línea de comandos, la guía de la terminal de Linux explica chmod, chown y sudo.
Probar tus Restauraciones
pg_restore --list demuestra que el archivo no está dañado, pero no que contenga lo que necesitas. La única prueba real es restaurarlo. Este script restaura el respaldo más reciente en una base de datos temporal, revisa un conteo de filas y limpia al terminar:
#!/usr/bin/env bash
# Restore the newest backup into a scratch database and check it.
set -euo pipefail
BACKUP_DIR="/var/backups/postgres"
TEST_DB="restore_test"
LATEST=$(ls -t "$BACKUP_DIR"/bookstore_*.dump | head -n 1)
dropdb --if-exists "$TEST_DB"
createdb "$TEST_DB"
pg_restore -d "$TEST_DB" "$LATEST"
BOOKS=$(psql -d "$TEST_DB" -tAc "SELECT count(*) FROM books")
echo "Restored $LATEST: $BOOKS books"
dropdb "$TEST_DB"
Restored /var/backups/postgres/bookstore_2026-11-14_0200.dump: 4 books
Ejecútalo cada semana, de preferencia en otro servidor, y compara el conteo con lo que esperas. También mide cuánto tarda: el tiempo de restauración es más o menos el tiempo que tu aplicación estaría caída después de una falla.
Dónde Guardar los Respaldos: la Regla 3-2-1
Un respaldo en el mismo disco que la base de datos desaparece junto con ella. Sigue la regla 3-2-1:
- 3 copias de tus datos (la base de datos en uso y dos respaldos),
- en 2 tipos de almacenamiento distintos,
- con 1 copia fuera del sitio, como un almacenamiento de objetos en la nube u otra ubicación.
Además:
- Cifra los respaldos que salen del servidor. Un respaldo contiene todas las filas en texto legible, incluidos los datos personales. Usa almacenamiento cifrado o cifra el archivo antes de subirlo. Consulta Seguridad y Privacidad de Bases de Datos.
- Restringe el acceso. Solo el usuario de respaldos y los administradores deberían poder leer los archivos de respaldo.
- Conserva al menos una copia que no se pueda cambiar ni borrar desde el servidor, como un almacenamiento con versiones o bloqueo de objetos, para que un ransomware o un atacante no pueda eliminar también tus respaldos.
Respaldos Físicos y Recuperación a un Punto en el Tiempo
Los respaldos lógicos capturan la base de datos en un momento. Si respaldas cada noche a las 2 a. m. y el servidor falla a las 5 p. m., pierdes 15 horas de cambios. Si eso es demasiado, necesitas respaldos físicos.
pg_basebackup copia todos los archivos de datos del servidor mientras está funcionando:
pg_basebackup -U postgres -D /var/backups/postgres/base -F t -z -X stream -c fast -P
| Opción | Significado |
|---|---|
-D | Dónde escribir el respaldo |
-F t -z | Formato tar, comprimido |
-X stream | Incluye el WAL necesario para que el respaldo sea consistente |
-c fast | Empieza de inmediato en lugar de esperar el siguiente checkpoint programado |
-P | Muestra el progreso |
Sin -c fast, pg_basebackup puede parecer congelado durante varios minutos al inicio mientras espera un checkpoint.
Combinado con el archivado de WAL (guardar de forma continua los archivos del registro de escritura anticipada de PostgreSQL), un respaldo base permite la recuperación a un punto en el tiempo (PITR): restaurar el servidor a cualquier momento, como un minuto antes de que alguien ejecutara un DELETE equivocado. Configurarlo requiere ajustes en el servidor (archive_mode y archive_command) y un procedimiento de recuperación cuidadoso, así que la mayoría de los equipos usa una herramienta como pgBackRest o Barman, que se encargan del archivado, la retención y las restauraciones.
Si usas una base de datos administrada (como Amazon RDS, Google Cloud SQL, Azure o DigitalOcean), los snapshots automáticos y la PITR suelen venir incluidos. Revisa cuánto tiempo se conservan los respaldos y, aun así, haz tus propias copias con pg_dump para tener una fuera del proveedor.
¿Con Qué Frecuencia Deberías Respaldar?
Dos números te ayudan a decidir:
- RPO (Recovery Point Objective, punto de recuperación objetivo): cuántos datos puedes permitirte perder. Un respaldo nocturno significa hasta 24 horas.
- RTO (Recovery Time Objective, tiempo de recuperación objetivo): cuánto tiempo puedes estar fuera de servicio mientras restauras.
Un proyecto personal puede funcionar bien con un pg_dump cada noche. Una tienda en línea que recibe pedidos todo el día puede necesitar respaldos cada hora o PITR. Estas decisiones forman parte de un plan de recuperación ante desastres más amplio.
Problemas Comunes y Soluciones
| Problema | Causa y solución |
|---|---|
pg_dump: error: aborting because of server version mismatch | Tu pg_dump es más antiguo que el servidor. Usa el pg_dump de la misma versión de PostgreSQL o de una más nueva. |
pg_restore: error: input file appears to be a text format dump | Es un archivo SQL plano. Restáuralo con psql -f, no con pg_restore. |
role "app_user" does not exist al restaurar | Los roles no están en los respaldos de pg_dump. Restaura primero roles.sql o usa --no-owner --no-privileges. |
database "bookstore" already exists con -C | Elimina primero la base de datos o restaura en una nueva sin -C. |
Peer authentication failed for user "postgres" | En Ubuntu, ejecuta el comando como ese usuario del sistema: sudo -u postgres pg_dump .... |
| Los respaldos llenan el disco | Agrega limpieza a tu script (find ... -mtime +14 -delete) y vigila el espacio libre con df -h. |
Lista de Verificación de Respaldos
- Respalda con
pg_dump -F cal menos una vez al día - Respalda los roles con
pg_dumpall --globals-only - Automatízalo con un script y cron
- Verifica cada archivo con
pg_restore --list - Prueba una restauración completa con regularidad
- Guarda una copia cifrada fuera del sitio
- Elimina los respaldos antiguos de forma programada
- Respalda antes de cada cambio riesgoso o actualización
- Considera respaldos físicos y PITR si no puedes perder un día de datos
Conclusión
PostgreSQL hace que los respaldos sean sencillos: pg_dump -F c crea un respaldo consistente y comprimido de una base de datos, pg_dumpall --globals-only guarda los usuarios y pg_restore lo recupera todo, completo o por partes.
Las herramientas son la parte fácil. Lo que realmente protege tus datos es la rutina alrededor de ellas: automatiza los respaldos, revisa cada uno, guarda copias en otro lugar y restáuralos con regularidad. El día que necesitas un respaldo es el peor día para descubrir que no funciona.
Preguntas Frecuentes
¿pg_dump bloquea la base de datos?
No. Lee una copia consistente mientras los usuarios siguen leyendo y escribiendo. Solo bloquea las operaciones que cambian la estructura de las tablas, como ALTER TABLE, en las tablas que está respaldando en ese momento.
¿Cuál es el mejor formato para pg_dump?
Usa el formato personalizado (-F c) para la mayoría de los respaldos. Usa el formato de directorio (-F d -j N) para bases de datos grandes y SQL plano cuando necesites un archivo legible.
¿Puedo restaurar un respaldo en una versión más nueva de PostgreSQL?
Sí. Los respaldos de pg_dump se pueden restaurar en la misma versión mayor o en una más nueva, por lo que son una forma común de actualizar. Restaurar en una versión más antigua suele fallar.
¿Cómo respaldo todas las bases de datos a la vez?
Ejecuta pg_dumpall -f all-databases.sql, o recorre las bases de datos en un script y ejecuta pg_dump -F c para cada una, además de pg_dumpall --globals-only para los roles.
¿Copiar la carpeta de datos es un respaldo válido?
Solo si PostgreSQL está detenido, o si usas pg_basebackup o una herramienta diseñada para eso. Copiar los archivos de un servidor en funcionamiento puede producir un respaldo que no arranque.
¿Cuánto tiempo debo conservar los respaldos?
Depende de tus necesidades y de los requisitos legales. Un esquema común es conservar respaldos diarios por dos semanas, semanales por unos meses y mensuales por un año. Los respaldos antiguos siguen teniendo datos personales, así que elimínalos cuando ya no los necesites.
