---
title: "Cómo instalar MinIO en Ubuntu 24.04 con HTTPS y Nginx"
description: "Instala MinIO como servicio systemd en Ubuntu 24.04, publícalo con Nginx y Let's Encrypt y crea buckets, usuarios y políticas S3 con el cliente mc."
category: "Almacenamiento y Copia de Seguridad Avanzada"
language: es
source: https://cubepath.com/es/docs/almacenamiento-y-copia-de-seguridad-avanzada/instalacion-de-minio-almacenamiento-de-objetos-compatible-con-s3
updated: 2026-09-25
---

# Cómo instalar MinIO en Ubuntu 24.04 con HTTPS y Nginx

MinIO es un servidor de almacenamiento de objetos compatible con la API de Amazon S3: cualquier aplicación, SDK o herramienta de copias de seguridad que hable S3 puede usarlo sin cambios. En este tutorial instalarás MinIO en un único servidor Ubuntu 24.04 como servicio systemd, lo publicarás con HTTPS detrás de Nginx y usarás el cliente `mc` para crear un bucket, un usuario con permisos limitados y una regla de caducidad de objetos.

> Nota: desde 2025 la edición comunitaria de MinIO (licencia AGPLv3) está en modo mantenimiento y su consola web solo incluye el explorador de objetos. La administración de usuarios y políticas se hace con `mc`, como en esta guía. Revisa el estado del proyecto en su repositorio antes de usarlo en producción.

## Requisitos previos

- Un servidor con Ubuntu 24.04 LTS de 64 bits (x86_64), por ejemplo un VPS de CubePath, con al menos 2 GB de RAM.
- Un usuario no root con privilegios `sudo` y UFW activo permitiendo SSH.
- Un disco o volumen para los datos. En esta guía se usa `/srv/minio/data`; si tienes un volumen adicional, móntalo en esa ruta antes de empezar.
- Dos nombres DNS con registro A apuntando a la IP del servidor: `minio.your_domain` para la API S3 y `console.your_domain` para la consola web. Sustituye **your_domain** por tu dominio en todos los comandos.

Esta guía despliega un nodo con una sola unidad. Es adecuado para desarrollo, copias de seguridad y cargas pequeñas, pero no ofrece redundancia de disco ni versionado de objetos, que en MinIO requieren un despliegue con varias unidades (erasure coding).

## Paso 1: Descargar el binario de MinIO

MinIO se distribuye como un único binario estático. Descárgalo en `/usr/local/bin`:

```bash
cd /tmp
curl -fLO https://dl.min.io/server/minio/release/linux-amd64/minio
sudo install -m 0755 minio /usr/local/bin/minio
```

Comprueba que se ejecuta:

```bash
minio --version
```

```output
minio version RELEASE.2025-... (commit-id=...)
Runtime: go1.24 linux/amd64
```

## Paso 2: Crear el usuario del servicio y el directorio de datos

MinIO no debe ejecutarse como root. Crea un usuario de sistema sin shell ni directorio personal y dale la propiedad del directorio de datos:

```bash
sudo groupadd --system minio-user
sudo useradd --system --no-create-home --shell /usr/sbin/nologin -g minio-user minio-user
sudo mkdir -p /srv/minio/data
sudo chown -R minio-user:minio-user /srv/minio
```

## Paso 3: Configurar las variables de entorno

El servicio lee su configuración de `/etc/default/minio`. Crea el archivo:

```bash
sudo nano /etc/default/minio
```

Añade este contenido, sustituyendo el usuario y la contraseña de administrador por valores propios. La contraseña debe tener al menos 8 caracteres; usa una larga y aleatoria (por ejemplo, generada con `openssl rand -base64 24`):

```ini
MINIO_ROOT_USER=minioadmin
MINIO_ROOT_PASSWORD=your_strong_password
MINIO_VOLUMES="/srv/minio/data"
MINIO_OPTS="--address :9000 --console-address :9001"
MINIO_SERVER_URL="https://minio.your_domain"
MINIO_BROWSER_REDIRECT_URL="https://console.your_domain"
```

- `MINIO_OPTS` fija el puerto de la API S3 (9000) y el de la consola (9001). No los abrirás en el firewall: Nginx será el único punto de entrada.
- `MINIO_SERVER_URL` y `MINIO_BROWSER_REDIRECT_URL` indican a MinIO las URL públicas que usarán los clientes.

Protege el archivo, ya que contiene la contraseña de administrador:

```bash
sudo chown root:minio-user /etc/default/minio
sudo chmod 640 /etc/default/minio
```

## Paso 4: Crear el servicio systemd

Crea la unidad de systemd:

```bash
sudo nano /etc/systemd/system/minio.service
```

```ini
[Unit]
Description=MinIO object storage
Documentation=https://github.com/minio/minio
Wants=network-online.target
After=network-online.target
AssertFileIsExecutable=/usr/local/bin/minio

[Service]
Type=notify
User=minio-user
Group=minio-user
EnvironmentFile=/etc/default/minio
ExecStart=/usr/local/bin/minio server $MINIO_OPTS $MINIO_VOLUMES
Restart=always
LimitNOFILE=65536
TasksMax=infinity
TimeoutStopSec=infinity
SendSIGKILL=no

[Install]
WantedBy=multi-user.target
```

Las variables se escriben sin llaves (`$MINIO_OPTS`) para que systemd las separe en argumentos. Recarga systemd y arranca el servicio:

```bash
sudo systemctl daemon-reload
sudo systemctl enable --now minio
```

Comprueba el estado:

```bash
sudo systemctl status minio --no-pager
```

```output
● minio.service - MinIO object storage
     Loaded: loaded (/etc/systemd/system/minio.service; enabled; preset: enabled)
     Active: active (running) since ...
```

Verifica que la API responde en local con el endpoint de salud:

```bash
curl -I http://127.0.0.1:9000/minio/health/live
```

```output
HTTP/1.1 200 OK
```

Si el servicio no arranca, revisa el registro con `sudo journalctl -u minio -n 50`.

## Paso 5: Publicar MinIO con Nginx y Let's Encrypt

Instala Nginx y Certbot:

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

Crea un sitio con dos bloques `server`, uno para la API y otro para la consola:

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

```nginx
server {
    listen 80;
    server_name minio.your_domain;

    # Sin límite de tamaño ni buffering: los objetos pueden ser grandes
    client_max_body_size 0;
    proxy_buffering off;
    proxy_request_buffering off;
    ignore_invalid_headers off;

    location / {
        proxy_set_header Host $http_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_http_version 1.1;
        proxy_set_header Connection "";
        chunked_transfer_encoding off;
        proxy_connect_timeout 300;
        proxy_pass http://127.0.0.1:9000;
    }
}

server {
    listen 80;
    server_name console.your_domain;

    client_max_body_size 0;

    location / {
        proxy_set_header Host $http_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;
        # La consola usa WebSockets
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_pass http://127.0.0.1:9001;
    }
}
```

Activa el sitio, comprueba la sintaxis y recarga Nginx:

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

Abre HTTP y HTTPS en el firewall y solicita los certificados. Certbot modifica el sitio para servir HTTPS y redirigir HTTP:

```bash
sudo ufw allow 'Nginx Full'
sudo certbot --nginx -d minio.your_domain -d console.your_domain
```

Comprueba la API desde tu equipo o desde el propio servidor:

```bash
curl -I https://minio.your_domain/minio/health/live
```

```output
HTTP/2 200
```

Abre `https://console.your_domain` en el navegador e inicia sesión con `MINIO_ROOT_USER` y `MINIO_ROOT_PASSWORD`.

## Paso 6: Instalar y configurar el cliente mc

`mc` es el cliente de línea de comandos de MinIO. Instálalo con el nombre `mcli` para no chocar con Midnight Commander, que en Ubuntu también usa el comando `mc`:

```bash
cd /tmp
curl -fLO https://dl.min.io/client/mc/release/linux-amd64/mc
sudo install -m 0755 mc /usr/local/bin/mcli
```

Registra un alias con las credenciales de administrador:

```bash
mcli alias set myminio https://minio.your_domain minioadmin your_strong_password
```

```output
Added `myminio` successfully.
```

Comprueba la conexión y el estado del servidor:

```bash
mcli admin info myminio
```

```output
●  minio.your_domain
   Uptime: 10 minutes
   Version: ...
   Network: 1/1 OK
   Drives: 1/1 OK
```

## Paso 7: Crear un bucket y subir objetos

Crea un bucket llamado `backups` y sube un archivo de prueba:

```bash
mcli mb myminio/backups
echo "hola minio" > /tmp/prueba.txt
mcli cp /tmp/prueba.txt myminio/backups/
mcli ls myminio/backups
```

```output
Bucket created successfully `myminio/backups`.
...
[2026-09-25 10:12:03 UTC]    11B STANDARD prueba.txt
```

Para sincronizar un directorio completo usa `mcli mirror`, que solo copia los archivos nuevos o modificados:

```bash
mcli mirror /var/www myminio/backups/www
```

## Paso 8: Crear un usuario con acceso limitado

Las aplicaciones no deben usar las credenciales de administrador. Crea una política que solo permita trabajar dentro del bucket `backups`:

```bash
nano ~/backups-rw.json
```

```json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:ListBucket", "s3:GetBucketLocation"],
      "Resource": ["arn:aws:s3:::backups"]
    },
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject", "s3:PutObject", "s3:DeleteObject"],
      "Resource": ["arn:aws:s3:::backups/*"]
    }
  ]
}
```

Registra la política, crea el usuario `appbackup` y asóciale la política. Sustituye `app_secret_key` por una clave secreta larga y aleatoria:

```bash
mcli admin policy create myminio backups-rw ~/backups-rw.json
mcli admin user add myminio appbackup app_secret_key
mcli admin policy attach myminio backups-rw --user appbackup
```

Verifica los permisos con un alias que use el nuevo usuario. Debe poder listar `backups` y recibir un error de acceso al intentar crear otro bucket:

```bash
mcli alias set appminio https://minio.your_domain appbackup app_secret_key
mcli ls appminio/backups
mcli mb appminio/otro-bucket
```

```output
[2026-09-25 10:12:03 UTC]    11B STANDARD prueba.txt
mcli: <ERROR> Unable to make bucket `appminio/otro-bucket`. Access Denied.
```

Con estas credenciales (endpoint `https://minio.your_domain`, clave de acceso `appbackup` y su clave secreta) ya puedes configurar cualquier cliente S3, como rclone, restic o el SDK de AWS.

## Paso 9: Borrar objetos antiguos automáticamente

Las reglas de ciclo de vida (ILM) eliminan objetos pasado un tiempo. Esta regla borra los objetos del prefijo `tmp/` a los 7 días:

```bash
mcli ilm rule add --prefix "tmp/" --expire-days 7 myminio/backups
mcli ilm rule ls myminio/backups
```

La salida muestra la regla con el prefijo `tmp/`, estado `Enabled` y 7 días hasta la caducidad.

## Solución de problemas

- **`systemctl status` muestra `failed` y el registro dice que la contraseña es demasiado corta**: `MINIO_ROOT_PASSWORD` necesita al menos 8 caracteres. Corrígela en `/etc/default/minio` y ejecuta `sudo systemctl restart minio`.
- **Error `file access denied` al arrancar**: el directorio de datos no pertenece a `minio-user`. Repite `sudo chown -R minio-user:minio-user /srv/minio`.
- **Las subidas grandes fallan con `413 Request Entity Too Large`**: falta `client_max_body_size 0;` en el bloque `server` de la API en Nginx.
- **Errores de firma (`SignatureDoesNotMatch`) a través del proxy**: Nginx debe enviar la cabecera `Host $http_host` sin modificar, como en la configuración del paso 5.

## Conclusión

Tienes MinIO funcionando como servicio systemd, accesible por HTTPS a través de Nginx, con un bucket, un usuario de aplicación limitado a ese bucket y una regla de caducidad. Como siguientes pasos puedes configurar restic o rclone para enviar copias de seguridad a este bucket, montar un despliegue con varias unidades para disponer de redundancia y versionado, o replicar el bucket a otro servidor con `mcli mirror --watch`.