---
title: "Cómo instalar Docker en Ubuntu 24.04, Debian 12 y Rocky 9"
description: "Instala Docker Engine y Docker Compose desde el repositorio oficial en Ubuntu 24.04, Debian 12 o Rocky Linux 9, limita los logs y comprueba que funciona."
category: "Docker Kubernetes"
language: es
source: https://cubepath.com/es/docs/docker-kubernetes/instalacion-de-docker-en-linux
updated: 2026-09-25
---

# Cómo instalar Docker en Ubuntu 24.04, Debian 12 y Rocky 9

Docker Engine permite empaquetar una aplicación con todas sus dependencias en una imagen y ejecutarla como contenedor aislado en cualquier servidor Linux. En este tutorial instalarás Docker Engine, el plugin de Docker Compose y Buildx desde el repositorio oficial de Docker en Ubuntu 24.04, con las diferencias necesarias para Debian 12 y Rocky Linux 9. Al terminar tendrás Docker funcionando como servicio, con rotación de logs y un contenedor de prueba publicado en un puerto.

## Requisitos previos

Para seguir esta guía necesitas:

- Un servidor con Ubuntu 24.04 LTS, Debian 12 o Rocky Linux 9 de 64 bits (x86_64 o arm64), por ejemplo un VPS de CubePath.
- Un usuario no root con privilegios `sudo`.
- Al menos 1 GB de RAM y unos 10 GB libres en disco para imágenes y contenedores.

Los pasos 1 a 4 son para Ubuntu 24.04. Si usas Debian 12 o Rocky Linux 9, consulta la sección correspondiente más abajo y vuelve después al paso 5.

## Paso 1: Eliminar paquetes que entran en conflicto

Ubuntu incluye sus propios paquetes de Docker (`docker.io`, `docker-compose-v2`, `podman-docker`) que chocan con los oficiales. Elimínalos si están instalados; apt avisará de los que no lo estén y no pasa nada:

```bash
sudo apt remove docker.io docker-doc docker-compose docker-compose-v2 podman-docker containerd runc
```

Las imágenes y volúmenes que hubiera en `/var/lib/docker/` no se borran con este comando.

## Paso 2: Añadir el repositorio oficial de Docker

Instala las herramientas necesarias para descargar la clave del repositorio:

```bash
sudo apt update
sudo apt install ca-certificates curl
```

Descarga la clave GPG de Docker en `/etc/apt/keyrings`, el directorio estándar para claves de repositorios de terceros:

```bash
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc
```

Crea el archivo del repositorio en formato deb822. El nombre en clave de la versión (`noble` en Ubuntu 24.04) se lee de `/etc/os-release`:

```bash
sudo tee /etc/apt/sources.list.d/docker.sources > /dev/null <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Signed-By: /etc/apt/keyrings/docker.asc
EOF
```

Actualiza el índice y comprueba que el paquete `docker-ce` viene ahora del repositorio de Docker:

```bash
sudo apt update
apt-cache policy docker-ce
```

```output
docker-ce:
  Installed: (none)
  Candidate: 5:28.4.0-1~ubuntu.24.04~noble
  Version table:
     5:28.4.0-1~ubuntu.24.04~noble 500
        500 https://download.docker.com/linux/ubuntu noble/stable amd64 Packages
```

El número de versión será distinto; lo importante es que el origen sea `download.docker.com`.

## Paso 3: Instalar Docker Engine

Instala el motor, el cliente, containerd y los plugins de Buildx y Compose:

```bash
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
```

En Ubuntu y Debian el servicio se habilita y arranca automáticamente. Compruébalo:

```bash
sudo systemctl status docker
```

```output
● docker.service - Docker Application Container Engine
     Loaded: loaded (/usr/lib/systemd/system/docker.service; enabled; preset: enabled)
     Active: active (running) since Thu 2026-09-25 10:12:41 UTC; 20s ago
```

Pulsa `q` para salir.

## Paso 4: Probar la instalación

Ejecuta la imagen `hello-world`, que descarga una imagen mínima, arranca un contenedor e imprime un mensaje:

```bash
sudo docker run hello-world
```

```output
Hello from Docker!
This message shows that your installation appears to be working correctly.
```

Comprueba también que el plugin de Compose está disponible. Ahora se invoca como `docker compose` (con espacio), no como el antiguo binario `docker-compose`:

```bash
docker compose version
```

```output
Docker Compose version v2.39.2
```

## Instalación en Debian 12

En Debian el proceso es idéntico al de Ubuntu salvo la URL del repositorio y el nombre de la versión. Elimina los paquetes en conflicto:

```bash
sudo apt remove docker.io docker-doc docker-compose podman-docker containerd runc
```

Añade la clave y el repositorio apuntando a `linux/debian`:

```bash
sudo apt update
sudo apt install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc
```

```bash
sudo tee /etc/apt/sources.list.d/docker.sources > /dev/null <<EOF
Types: deb
URIs: https://download.docker.com/linux/debian
Suites: $(. /etc/os-release && echo "$VERSION_CODENAME")
Components: stable
Signed-By: /etc/apt/keyrings/docker.asc
EOF
```

Instala los paquetes igual que en el paso 3:

```bash
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
```

## Instalación en Rocky Linux 9

Rocky Linux 9 trae Podman y Buildah preinstalados en algunas imágenes, y sus dependencias chocan con `containerd.io`. Elimínalos si no los usas:

```bash
sudo dnf remove podman buildah runc
```

Añade el repositorio oficial de Docker para RHEL, que es el que corresponde a Rocky Linux:

```bash
sudo dnf -y install dnf-plugins-core
sudo dnf config-manager --add-repo https://download.docker.com/linux/rhel/docker-ce.repo
```

Instala los paquetes. dnf te pedirá aceptar la huella de la clave GPG; comprueba que coincide con `060A 61C5 1B55 8A7F 742B 77AA C52F EB6B 621E 9F35`:

```bash
sudo dnf install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
```

A diferencia de Ubuntu, en la familia RHEL el servicio no arranca solo. Habilítalo e inícialo:

```bash
sudo systemctl enable --now docker
```

Comprueba que está activo con `sudo systemctl status docker` y ejecuta `sudo docker run hello-world` como en el paso 4.

## Paso 5: Usar Docker sin sudo

Por defecto, el socket de Docker (`/var/run/docker.sock`) pertenece a root y al grupo `docker`. Si añades tu usuario a ese grupo podrás ejecutar `docker` sin `sudo`:

```bash
sudo usermod -aG docker $USER
```

> Advertencia: pertenecer al grupo `docker` equivale a tener acceso root en el servidor, porque cualquier miembro puede arrancar un contenedor que monte `/` del host. Añade solo usuarios de confianza.

El cambio de grupo se aplica al iniciar una nueva sesión. Cierra la sesión SSH y vuelve a conectarte, y comprueba que funciona sin `sudo`:

```bash
docker run --rm hello-world
```

Si ves de nuevo el mensaje `Hello from Docker!`, la configuración es correcta.

## Paso 6: Configurar la rotación de logs

El driver de logs por defecto (`json-file`) guarda todo lo que un contenedor escribe en stdout y stderr en `/var/lib/docker/containers/` sin límite de tamaño. Un contenedor con muchos logs puede llenar el disco en días. Limita el tamaño en la configuración del daemon:

```bash
sudo nano /etc/docker/daemon.json
```

```json
{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
  }
}
```

Con esto cada contenedor guarda como máximo tres archivos de 10 MB. Reinicia Docker para aplicar el cambio:

```bash
sudo systemctl restart docker
```

Verifica que el daemon ha leído la configuración:

```bash
docker info --format '{{.LoggingDriver}}'
```

```output
json-file
```

Si Docker no arranca tras el reinicio, casi siempre es un error de sintaxis en `daemon.json`; revisa el mensaje con `sudo journalctl -u docker -n 20`. Ten en cuenta que los límites solo se aplican a los contenedores creados después del cambio.

## Paso 7: Publicar un contenedor de prueba

Para comprobar que la red funciona, arranca Nginx y publica su puerto 80 en el puerto 8080 del servidor:

```bash
docker run -d --name test-nginx -p 8080:80 nginx
```

Comprueba que responde:

```bash
curl -I http://localhost:8080
```

```output
HTTP/1.1 200 OK
Server: nginx/1.29.1
Content-Type: text/html
```

> Importante: Docker escribe sus propias reglas de iptables y los puertos publicados con `-p` quedan accesibles desde Internet aunque UFW o firewalld no los permitan. Si un servicio solo debe ser accesible desde el propio servidor, publícalo en la interfaz local: `-p 127.0.0.1:8080:80`.

Elimina el contenedor de prueba:

```bash
docker rm -f test-nginx
```

## Solución de problemas

**`permission denied while trying to connect to the Docker daemon socket`**: tu usuario no está en el grupo `docker` o aún no has abierto una sesión nueva. Ejecuta `groups` y comprueba que aparece `docker`; si no, repite el paso 5 y vuelve a iniciar sesión.

**El servicio no arranca**: consulta el motivo con `sudo journalctl -u docker -n 50 --no-pager`. Las causas más habituales son un `daemon.json` con JSON inválido o restos de paquetes antiguos (`docker.io`) que no se eliminaron en el paso 1.

**`Bind for 0.0.0.0:8080 failed: port is already allocated`**: otro proceso o contenedor usa ese puerto. Averigua cuál con `sudo ss -tlnp | grep :8080` y elige otro puerto o detén el proceso.

**El disco se llena**: revisa cuánto ocupan imágenes, contenedores y volúmenes con `docker system df` y elimina lo que no se usa con `docker system prune`. Añade `--volumes` solo si sabes que no necesitas los datos de los volúmenes huérfanos.

## Actualizar Docker

Como Docker se instala desde un repositorio, se actualiza con el resto del sistema:

```bash
sudo apt update && sudo apt upgrade
```

En Rocky Linux usa `sudo dnf upgrade`. Los contenedores con política de reinicio (`--restart unless-stopped`) vuelven a arrancar solos tras la actualización.

## Conclusión

Has instalado Docker Engine, Buildx y Docker Compose desde el repositorio oficial, has configurado el acceso sin `sudo` y la rotación de logs, y has comprobado que los contenedores arrancan y publican puertos correctamente. Recuerda que los puertos publicados se saltan el firewall del sistema.

Como siguientes pasos puedes:

- Definir aplicaciones con varios contenedores en un archivo `compose.yaml` y gestionarlas con `docker compose up -d`.
- Crear tus propias imágenes con un `Dockerfile` y builds multietapa.
- Revisar las buenas prácticas de seguridad de Docker antes de llevar contenedores a producción.