MinIO es un servidor de almacenamiento de objetos de alto rendimiento, compatible con la API de Amazon S3. Está diseñado para infraestructuras de nube privada y aplicaciones que requieren un manejo eficiente de datos no estructurados, como fotos, videos y archivos de respaldo.

1. Despliegue del Servidor MinIO

La forma más eficiente de poner en marcha MinIO es a través de contenedores. A continuación, se presentan dos métodos utilizando Docker.

Ejecución rápida mediante Docker CLI

docker run -p 9000:9000 -p 9090:9090 \
 --name servidor_minio \
 -d --restart=always \
 -e "MINIO_ROOT_USER=admin_user" \
 -e "MINIO_ROOT_PASSWORD=admin_password" \
 -v /opt/minio/data:/data \
 minio/minio server /data --console-address ":9090" -address ":9000"

Configuración avanzada con Docker Compose

Para entornos más estables, se recomienda el uso de un archivo docker-compose.yml:

version: '3.9'

services:
  storage:
    image: minio/minio:RELEASE.2023-03-20T20-16-18Z
    container_name: minio_service
    ports:
      - "9000:9000"  # Puerto para API S3
      - "9090:9090"  # Puerto para Interfaz Web (Console)
    environment:
      MINIO_ROOT_USER: minio_admin
      MINIO_ROOT_PASSWORD: minio_secret_password
      MINIO_VOLUMES: "/data"
    volumes:
      - persistence_data:/data
    command: server /data --console-address ":9090" --address ":9000"
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      interval: 15s
      timeout: 10s
      retries: 5

volumes:
  persistence_data:
    driver: local

Para iniciar el servicio en segundo pleno, ejecute:

docker compose up -d

2. Conceptos Operativos y Flujo de Trabajo

Una vez desplegado, se puede acceder al panel de administración mediante http://127.0.0.1:9090. En MinIO, la unidad básica de organización es el Bucket (Cubo), que funciona de manera similar a un directorio raíz.

• Organización por Buckets: Todos los objetos deben residir en un bucket. Se pueden definir políticas de acceso específicas para cada uno.
• Gestión de Archivos: La interfaz permite cargar, descargar y previsualizar objetos directamente.
• Ciclo de vida del enlace: Es posible generar URLs prefirmadas. Estas son direcciones temporales que permiten a aplicaciones externas acceder a archivos privados sin necesidad de credenciales globales, expirendo tras un teimpo configurado.

3. Integración con Python

Para interactuar de forma programática con MinIO, se utiliza la librería oficial de cliente. El siguiente script demuestra cómo inicializar el cliente, asegurar la existencia de un bucket y gestionar la carga de archivos.

import os
import uuid
from minio import Minio
from minio.error import S3Error

# Configuración de conexión
HOST_MINIO = "192.168.1.100:9000"
USUARIO = "minio_admin"
CLAVE = "minio_secret_password"
BUCKET_OBJETIVO = "recursos-app"
USAR_SSL = False

def inicializar_cliente():
    """Configura el cliente MinIO."""
    return Minio(
        HOST_MINIO,
        access_key=USUARIO,
        secret_key=CLAVE,
        secure=USAR_SSL
    )

def garantizar_bucket(cliente, nombre_bucket):
    """Verifica la existencia de un bucket o lo crea."""
    try:
        if not cliente.bucket_exists(nombre_bucket):
            cliente.make_bucket(nombre_bucket)
            print(f"Bucket '{nombre_bucket}' creado exitosamente.")
        else:
            print(f"El bucket '{nombre_bucket}' ya está listo.")
    except S3Error as err:
        print(f"Error al verificar bucket: {err}")

def procesar_y_subir(cliente, ruta_local):
    """Sube un archivo con un nombre único y retorna su URL temporal."""
    try:
        # Generar identificador único para evitar sobreescritura
        extension = os.path.splitext(ruta_local)[1]
        nombre_remoto = f"{uuid.uuid4().hex}{extension}"

        # Cargar el archivo
        cliente.fput_object(BUCKET_OBJETIVO, nombre_remoto, ruta_local)
        
        # Generar URL con validez de 24 horas
        url_acceso = cliente.presigned_get_object(
            BUCKET_OBJETIVO, 
            nombre_remoto
        )
        return url_acceso
    except S3Error as error:
        print(f"Fallo en la operación de almacenamiento: {error}")
        return None

if __name__ == "__main__":
    instancia_minio = inicializar_cliente()
    garantizar_bucket(instancia_minio, BUCKET_OBJETIVO)

    archivo_a_subir = "ejemplo_documento.pdf"
    if os.path.exists(archivo_a_subir):
        enlace_descarga = procesar_y_subir(instancia_minio, archivo_a_subir)
        print(f"Archivo disponible en: {enlace_descarga}")