---
title: "Cómo instalar y configurar Kopia Backup en Ubuntu 24.04"
description: "Instala Kopia en Ubuntu 24.04 desde su repositorio oficial, crea un repositorio cifrado en S3, define la retención y programa snapshots diarios con systemd."
category: "Herramientas de Servidor"
language: es
source: https://cubepath.com/es/docs/herramientas-de-servidor/instalacion-y-configuracion-de-kopia-backup
updated: 2026-09-25
---

# Cómo instalar y configurar Kopia Backup en Ubuntu 24.04

Kopia es una herramienta de copias de seguridad de código abierto que crea snapshots cifrados, comprimidos y deduplicados de tus directorios y los guarda en un almacenamiento local, SFTP o de objetos (S3, Backblaze B2, Google Cloud Storage y otros). En este tutorial instalarás Kopia en Ubuntu 24.04 desde su repositorio oficial, crearás un repositorio cifrado en un bucket compatible con S3, configurarás compresión, exclusiones y retención, programarás copias diarias con un temporizador de systemd y restaurarás archivos para comprobar que todo funciona.

## Requisitos previos

- Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath.
- Un usuario no root con privilegios `sudo`.
- Un bucket S3 o compatible con S3 vacío, con una clave de acceso (access key y secret key) con permisos de lectura y escritura. Más adelante verás las variantes para Backblaze B2, SFTP y disco local.

Los comandos de Kopia se ejecutan como root (con `sudo -i`), porque la copia necesita leer archivos de todo el sistema y la configuración del repositorio queda en el perfil de root (`/root/.config/kopia/`).

## Paso 1: Instalar Kopia desde el repositorio oficial

Kopia publica paquetes para Debian y Ubuntu en su propio repositorio APT. Descarga la clave de firma en `/etc/apt/keyrings`:

```bash
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://kopia.io/signing-key | sudo gpg --dearmor -o /etc/apt/keyrings/kopia-keyring.gpg
```

Añade el repositorio:

```bash
echo "deb [signed-by=/etc/apt/keyrings/kopia-keyring.gpg] http://packages.kopia.io/apt/ stable main" | sudo tee /etc/apt/sources.list.d/kopia.list
```

Instala el paquete:

```bash
sudo apt update
sudo apt install kopia
```

Comprueba la versión instalada:

```bash
kopia --version
```

```output
0.21.1 build: ... from: kopia/kopia
```

Tu número de versión puede ser distinto.

## Paso 2: Crear un repositorio cifrado en S3

El repositorio es el destino donde Kopia guarda los datos cifrados. Kopia lee las credenciales de S3 de las variables `AWS_ACCESS_KEY_ID` y `AWS_SECRET_ACCESS_KEY` y la contraseña del repositorio de `KOPIA_PASSWORD`, lo que evita dejarlas en el historial de la shell como argumentos. Abre una shell de root y expórtalas:

```bash
sudo -i
export AWS_ACCESS_KEY_ID=your_access_key
export AWS_SECRET_ACCESS_KEY=your_secret_key
export KOPIA_PASSWORD=your_strong_repository_password
```

Crea el repositorio. `--prefix` permite compartir un bucket entre varios servidores, cada uno en su propia ruta:

```bash
kopia repository create s3 \
  --bucket=your-bucket \
  --endpoint=s3.amazonaws.com \
  --region=us-east-1 \
  --prefix=servidor1/
```

Para un proveedor compatible con S3, cambia `--endpoint` y `--region` por los del proveedor. Si todo va bien, Kopia crea el repositorio y se conecta a él:

```output
Initializing repository with:
  block hash:          BLAKE2B-256-128
  encryption:          AES256-GCM-HMAC-SHA256
  splitter:            DYNAMIC-4M-BUZHASH
Connected to repository.
```

Comprueba el estado de la conexión:

```bash
kopia repository status
```

Al conectarse, Kopia guarda la configuración en `/root/.config/kopia/repository.config` y, por defecto, también la contraseña, de modo que los siguientes comandos (y el temporizador de systemd) no la vuelven a pedir.

> Importante: guarda la contraseña del repositorio fuera del servidor, por ejemplo en un gestor de contraseñas. Sin ella no podrás restaurar nada, y Kopia no tiene forma de recuperarla.

Cierra la sesión y abre otra con `sudo -i` para que las claves exportadas no queden en el entorno:

```bash
exit
```

### Otros tipos de repositorio

Si no usas S3, el resto del tutorial es idéntico. Solo cambia el comando de creación:

| Destino | Comando |
|---|---|
| Backblaze B2 | `kopia repository create b2 --bucket=your-bucket --key-id=your_key_id --key=your_application_key` |
| SFTP | `kopia repository create sftp --host=backup.your_domain --username=your_user --path=/backups/kopia --keyfile=/root/.ssh/id_ed25519 --known-hosts=/root/.ssh/known_hosts` |
| Disco local o NFS | `kopia repository create filesystem --path=/mnt/backup/kopia` |

Un repositorio en el mismo disco del servidor no protege frente a la pérdida del servidor. Úsalo solo para pruebas o sobre un disco o NAS independiente.

## Paso 3: Configurar compresión, exclusiones y retención

Las políticas definen cómo se comporta cada snapshot. La política global se aplica a todos los directorios y cada directorio puede sobrescribirla.

Activa la compresión zstd, que ofrece un buen equilibrio entre ratio y CPU. Los archivos que ya están comprimidos (imágenes, vídeo, zip) apenas ganan espacio, pero Kopia los procesa igualmente:

```bash
sudo -i
kopia policy set --global --compression=zstd
```

Define cuántos snapshots se conservan. Kopia aplica esta retención automáticamente cada vez que crea un snapshot:

```bash
kopia policy set --global \
  --keep-latest=10 \
  --keep-hourly=0 \
  --keep-daily=14 \
  --keep-weekly=8 \
  --keep-monthly=12 \
  --keep-annual=2
```

Excluye lo que no necesitas copiar. Las reglas de exclusión siguen la sintaxis de `.gitignore` y se aplican al directorio indicado:

```bash
kopia policy set /var/www --add-ignore=node_modules --add-ignore='*.log' --add-ignore=cache/
```

Revisa la política efectiva de un directorio:

```bash
kopia policy show /var/www
```

La salida muestra cada ajuste y de qué política lo hereda (`inherited from (global)` o `defined for this target`).

## Paso 4: Crear el primer snapshot

Crea snapshots de los directorios que quieres proteger. En este ejemplo, la configuración del sistema y el contenido web:

```bash
kopia snapshot create /etc /var/www
```

```output
Snapshotting root@servidor1:/etc ...
Created snapshot with root k8a1f... and ID 1c2d3e... in 2s
Snapshotting root@servidor1:/var/www ...
Created snapshot with root k5b7c... and ID 4f5a6b... in 11s
```

El primer snapshot sube todos los datos. Los siguientes solo suben los bloques que han cambiado. Lista los snapshots existentes:

```bash
kopia snapshot list
```

```output
root@servidor1:/etc
  2026-09-25 10:21:04 UTC k8a1f... 2.1 MB drwxr-xr-x files:1532 dirs:215 (latest-1,daily-1,weekly-1,monthly-1,annual-1)

root@servidor1:/var/www
  2026-09-25 10:21:07 UTC k5b7c... 83.4 MB drwxr-xr-x files:1523 dirs:188 (latest-1,daily-1,weekly-1,monthly-1,annual-1)
```

Entre paréntesis aparecen las reglas de retención por las que se conserva cada snapshot.

## Paso 5: Programar snapshots diarios con systemd

`kopia snapshot create --all` crea un snapshot nuevo de todos los directorios que ya tienen al menos uno, así que no hace falta repetir la lista de rutas en el servicio. Crea la unidad:

```bash
nano /etc/systemd/system/kopia-backup.service
```

```ini
[Unit]
Description=Kopia snapshot of all known sources
Wants=network-online.target
After=network-online.target

[Service]
Type=oneshot
ExecStart=/usr/bin/kopia snapshot create --all --no-progress
Nice=10
IOSchedulingClass=idle
```

Crea el temporizador para ejecutarlo cada noche a las 03:00:

```bash
nano /etc/systemd/system/kopia-backup.timer
```

```ini
[Unit]
Description=Nightly Kopia snapshot

[Timer]
OnCalendar=*-*-* 03:00:00
RandomizedDelaySec=15m
Persistent=true

[Install]
WantedBy=timers.target
```

`Persistent=true` lanza la copia al arrancar si el servidor estaba apagado a la hora programada. Recarga systemd, prueba el servicio a mano y activa el temporizador:

```bash
systemctl daemon-reload
systemctl start kopia-backup.service
journalctl -u kopia-backup.service -n 20 --no-pager
systemctl enable --now kopia-backup.timer
```

Comprueba la próxima ejecución:

```bash
systemctl list-timers kopia-backup.timer
```

```output
NEXT                        LEFT     LAST                        PASSED UNIT              ACTIVATES
Fri 2026-09-26 03:04:51 UTC 16h left Thu 2026-09-25 10:30:12 UTC 2s ago kopia-backup.timer kopia-backup.service
```

El mantenimiento del repositorio (compactar índices y liberar espacio de datos que ya no usa ningún snapshot) se ejecuta automáticamente desde el usuario que creó el repositorio. Puedes ver cuándo se ejecutó por última vez con:

```bash
kopia maintenance info
```

## Paso 6: Verificar y restaurar

Comprueba que los datos del repositorio se pueden leer. Esta orden verifica los metadatos de todos los snapshots y descarga y descifra un 5 % de los archivos elegidos al azar:

```bash
kopia snapshot verify --verify-files-percent=5
```

Para restaurar, localiza primero el ID del snapshot con `kopia snapshot list /var/www`. Restaura un snapshot completo en un directorio temporal, sin tocar los datos originales:

```bash
kopia restore k5b7c... /root/restore-www
```

Para recuperar un único archivo, añade la ruta dentro del snapshot:

```bash
kopia restore k5b7c.../html/index.php /root/index.php
```

Sustituye `k5b7c...` por el ID completo del snapshot. También puedes montar un snapshot como sistema de archivos de solo lectura para explorarlo. El comando se queda en primer plano hasta que pulses `Ctrl+C`:

```bash
mkdir -p /mnt/kopia
kopia mount k5b7c... /mnt/kopia
```

Desde otra terminal podrás navegar por `/mnt/kopia` con las herramientas habituales.

## Solución de problemas

**`invalid repository password`.** La contraseña no coincide con la que usaste al crear el repositorio. Vuelve a conectar con `kopia repository connect s3 --bucket=your-bucket --prefix=servidor1/ ...` e introduce la correcta.

**El servicio de systemd pide contraseña o falla con `repository not connected`.** El servicio se ejecuta como root y usa `/root/.config/kopia/repository.config`. Si conectaste el repositorio con otro usuario, repite el `kopia repository connect` como root.

**Un archivo no aparece en el snapshot.** Revisa las exclusiones con `kopia policy show /ruta`. Para quitar una, usa `kopia policy set /ruta --remove-ignore='patrón'`.

**El repositorio crece aunque borres snapshots.** El espacio se libera en el siguiente mantenimiento completo, que por defecto se ejecuta cada 24 horas. Consulta el estado con `kopia maintenance info`.

## Conclusión

Tienes Kopia instalado desde su repositorio oficial, con un repositorio cifrado en S3, compresión, exclusiones, una política de retención y snapshots diarios programados con systemd. Como siguientes pasos, añade nuevas rutas con un primer `kopia snapshot create` para que el temporizador las incluya, conecta la aplicación de escritorio KopiaUI al mismo repositorio para restaurar con interfaz gráfica y haz una restauración completa en otro servidor de vez en cuando para validar el proceso.