Guía de Instalación y Configuración de Mezon

The Live, Work, and Play Platform – High-performance · Lightweight · Real-time

Introducción

Mezon es una plataforma de comunicación en tiempo real con arquitectura nativa-first, utilizando io_uring, zero-copy I/O y WebRTC SFU personalizado en C para lograr latencia sub-milimétrica. No es un clon de Discord: es una plataforma completa con clientes nativos para cada plataforma que hablan el mismo protocolo binario mezon-protocol.

⚠️ Importante: Según la documentación oficial de mezon-bot-ai, el despliegue en producción usa native systemd + Ansible (no Docker). Local dev usa docker-compose.yml.

Prerrequisitos del Sistema

Plataforma	Requisitos
Web	Browser moderno (Chrome 90+, Firefox 88+, Safari 14+, Edge 90+)
Desktop	Windows 10+, macOS 10.15+, Ubuntu 18.04+
Mobile	iOS 13.0+, Android 8.0+ (API level 26+)
Development (web)	Node.js 18+, Yarn 1.22.4+, 4GB RAM mínimo

Requisitos para Producción (Self-Hosted)

Servicio	Versión Mínima	Notas
OS	Ubuntu 20.04+ / Debian 11+ / RHEL 8+	Kernel con soporte io_uring
PostgreSQL	14+	Con pgvector para AI features
Redis	7+	Para caché y colas
MinIO	2023.3+	S3-compatible object storage
Python	3.11+	Para services adicionales

Instalación Local (Desarrollo)

Paso 1: Clonar el Repositorio

# Clonar el repositorio principal
git clone https://github.com/mezonai/mezon.git
cd mezon

# O clonar tu fork para contribuciones
git clone https://github.com/YOUR_USERNAME/mezon.git
cd mezon

Paso 2: Instalar Dependencias

# Instalar todas las dependencias del proyecto
yarn install

# Esto instalará dependencias para todas las apps y librerías
# Puede tardar 3-5 minutos en la primera ejecución

Paso 3: Configurar Variables de Entorno

Aplicación Chat (`apps/chat/.env`)

# Crear archivo .env
touch apps/chat/.env

# Añadir variables
cat > apps/chat/.env << 'EOF'
# API Configuration
VITE_API_BASE_URL=http://localhost:3000/api
VITE_WS_URL=ws://localhost:3000/ws

# Authentication
VITE_JWT_SECRET=your-jwt-secret-key-here

# Feature Flags
VITE_ENABLE_AI_FEATURES=true
VITE_ENABLE_VOICE_CHAT=true

# Analytics (optional)
VITE_ANALYTICS_ID=your-analytics-id

# Debug Mode
VITE_DEBUG_MODE=true
EOF

Aplicación Admin (`apps/admin/.env`)

# Crear archivo .env
touch apps/admin/.env

# Añadir variables
cat > apps/admin/.env << 'EOF'
VITE_API_BASE_URL=http://localhost:3000/api
VITE_ADMIN_SECRET=your-admin-secret-key-here
EOF

Paso 4: Iniciar el Servidor de Desarrollo

# Iniciar aplicación chat
yarn dev:chat

# O iniciar aplicación admin
yarn dev:admin

# O iniciar todas las aplicaciones
yarn dev:all

Los servidores estarán disponibles en:

Chat: http://localhost:4200
Admin: http://localhost:4201

Instalación en Producción

Paso 1: Preparar el Sistema Operativo

# Actualizar paquetes
sudo apt update && sudo apt upgrade -y

# Instalar dependencias del sistema
sudo apt install -y \
    build-essential \
    git \
    curl \
    wget \
    ca-certificates \
    python3 \
    python3-pip \
    libpq-dev \
    redis-server

# Verificar io_uring (requerido para Linux)
cat /proc/sys/fs/io_uring/max_threads  # Debe ser > 0

Paso 2: Configurar PostgreSQL

# Instalar PostgreSQL
sudo apt install -y postgresql postgresql-contrib

# Iniciar y habilitar servicio
sudo systemctl enable postgresql
sudo systemctl start postgresql

# Crear base de datos para Mezon
sudo -u postgres psql << 'EOF'
CREATE DATABASE mezon_db;
CREATE USER mezon_user WITH PASSWORD 'your_secure_password';
GRANT ALL PRIVILEGES ON DATABASE mezon_db TO mezon_user;
EOF

# Instalar extensión pgvector (para AI features)
sudo -u postgres psql -d mezon_db << 'EOF'
CREATE EXTENSION IF NOT EXISTS vector;
EOF

Paso 3: Configurar Redis

# Instalar Redis
sudo apt install -y redis-server

# Iniciar y habilitar servicio
sudo systemctl enable redis-server
sudo systemctl start redis-server

# Configurar persistencia
cat > /etc/redis/redis.conf << 'EOF'
bind 127.0.0.1
protected-mode yes
maxmemory 2gb
maxmemory-policy allkeys-lru
appendonly yes
appendfilename "appendonly.aof"
save 900 1
save 300 10
save 60 10000
EOF

# Reiniciar Redis con nueva configuración
sudo systemctl restart redis-server

Paso 4: Configurar MinIO (Object Storage)

# Instalar MinIO
curl -LO https://dl.min.io/server/minio/release/linux-amd64/minio
chmod +x minio
sudo mv minio /usr/local/bin/

# Iniciar MinIO con systemd
cat > /etc/systemd/system/minio.service << 'EOF'
[Unit]
Description=MinIO Object Storage
After=network.target

[Service]
User=minio
Group=minio
ExecStart=/usr/local/bin/minio server /data --console-address ":9001"
Restart=always
Environment="MINIO_ROOT_USER=admin"
Environment="MINIO_ROOT_PASSWORD=your_secure_password"

[Install]
WantedBy=multi-user.target
EOF

# Crear usuario y directorio MinIO
sudo useradd -r -s /bin/false minio
sudo mkdir -p /data
sudo chown -R minio:minio /data

# Habilitar y iniciar servicio
sudo systemctl enable minio
sudo systemctl start minio

Paso 5: Configurar Aplicación Mezon (C/SFU)

# Clonar repositorio principal
git clone https://github.com/mezonai/mezon.git
cd mezon

# Instalar dependencias del servidor
yarn install

# Configurar variables de entorno para producción
cat > .env.production << 'EOF'
# Server Configuration
MEZON_SERVER_URL=https://tu-dominio.com
MEZON_WS_URL=wss://tu-dominio.com/ws

# Database
DATABASE_URL=postgresql://mezon_user:your_secure_password@localhost:5432/mezon_db

# Redis
REDIS_URL=redis://localhost:6379

# MinIO S3
MINIO_ENDPOINT=http://localhost:9000
MINIO_ACCESS_KEY=admin
MINIO_SECRET_KEY=your_secure_password

# JWT
JWT_SECRET=your-production-jwt-secret-key-here

# Security
MEZON_E2EE_ENABLED=true
MEZON_ZERO_KNOWLEDGE=true

# Feature Flags
ENABLE_AI_MODERATION=true
ENABLE_REALTIME_TRANSLATION=true
EOF

Paso 6: Iniciar Servicios con Systemd

# Crear servicio para Mezon Server
cat > /etc/systemd/system/mezon-server.service << 'EOF'
[Unit]
Description=Mezon Real-time Communication Server
After=network.target postgresql redis minio

[Service]
Type=simple
User=mezon
WorkingDirectory=/path/to/mezon
ExecStart=yarn start:production
Restart=always
RestartSec=5
Environment="NODE_ENV=production"
Environment="MEZON_SERVER_URL=https://tu-dominio.com"
Environment="DATABASE_URL=postgresql://mezon_user:your_secure_password@localhost:5432/mezon_db"
Environment="REDIS_URL=redis://localhost:6379"

[Install]
WantedBy=multi-user.target
EOF

# Crear usuario mezon
sudo useradd -r -s /bin/false mezon
sudo chown -R mezon:mezon /path/to/mezon

# Habilitar y iniciar servicio
sudo systemctl enable mezon-server
sudo systemctl start mezon-server

Configuración de Entorno

Variable	Descripción	Ejemplo
`MEZON_SERVER_URL`	URL pública del servidor	`https://tu-dominio.com`
`DATABASE_URL`	Conexión PostgreSQL	`postgresql://user:pass@host:5432/db`
`REDIS_URL`	Conexión Redis	`redis://localhost:6379`
`MINIO_ENDPOINT`	Endpoint MinIO S3	`http://localhost:9000`
`JWT_SECRET`	Clave secreta JWT (mínimo 32 chars)	`your-secure-jwt-secret-key-here`
`MEZON_E2EE_ENABLED`	Habilitar E2EE	`true`
`ENABLE_AI_MODERATION`	Moderación AI	`true`

Generar JWT Secret Seguro

# Generar clave segura para JWT (mínimo 32 caracteres)
openssl rand -base64 32

Verificación Posterior

Paso 1: Verificar Servicios

# Verificar PostgreSQL
sudo systemctl status postgresql

# Verificar Redis
sudo systemctl status redis-server

# Verificar MinIO
sudo systemctl status minio

# Verificar Mezon Server
sudo systemctl status mezon-server

Paso 2: Pruebas de Conexión

# Conectar a PostgreSQL
psql -h localhost -U mezon_user -d mezon_db -c "SELECT version();"

# Conectar a Redis
redis-cli ping  # Debe responder: PONG

# Verificar MinIO Console
curl http://localhost:9001/minio/health/live

# Verificar API de Mezon
curl https://tu-dominio.com/api/health

Paso 3: Verificar Configuración de Seguridad

# Verificar TLS en ruta
openssl s_client -connect tu-dominio.com:443 -starttls http

# Verificar headers de seguridad
curl -I https://tu-dominio.com | grep -i "strict-transport-security"
curl -I https://tu-dominio.com | grep -i "x-frame-options"

Actualización, Rollback y Backup

Actualización de Mezon

# Pull cambios del repositorio
cd /path/to/mezon
git pull origin main

# Instalar nuevas dependencias
yarn install

# Reiniciar servicio
sudo systemctl restart mezon-server

# Verificar estado después de actualización
sudo systemctl status mezon-server
curl https://tu-dominio.com/api/health

Rollback a Versión Anterior

# Revertir cambios (si hay issues post-upgrade)
git checkout HEAD~1  # Volver al commit anterior
yarn install
sudo systemctl restart mezon-server

Backup de Datos

# Backup completo PostgreSQL
pg_dump -h localhost -U mezon_user -d mezon_db > /backups/mezon_db_$(date +%Y%m%d_%H%M%S).sql

# Backup Redis (RDB)
redis-cli BGSAVE  # Crea snapshot en /var/lib/redis/dump.rdb

# Backup MinIO buckets específicos
mc alias set mezon http://localhost:9001 admin your_secure_password
mc mb --ignore-existing mezon/channels
mc cp --recursive mezon/channels/* /backup/channels/

Script de Backup Automatizado

#!/bin/bash
# /usr/local/bin/mezon-backup.sh

BACKUP_DIR="/backups/mezon"
DATE=$(date +%Y%m%d_%H%M%S)

mkdir -p $BACKUP_DIR

# PostgreSQL backup
pg_dump -h localhost -U mezon_user -d mezon_db > "$BACKUP_DIR/db_$DATE.sql"

# Redis snapshot
redis-cli BGSAVE

# MinIO bucket backup
mc alias set mezon http://localhost:9001 admin your_secure_password
mc cp --recursive mezon/channels/* "$BACKUP_DIR/channels_$DATE/"

# Comprimir backups
tar -czf "$BACKUP_DIR/mezon_backup_$DATE.tar.gz" \
    "$BACKUP_DIR/db_$DATE.sql" \
    "$BACKUP_DIR/channels_$DATE/"

# Mantener solo últimos 7 días de backups
find /backups/mezon -name "*.sql" -mtime +7 -delete
find /backups/mezon -name "*.tar.gz" -mtime +7 -delete

echo "Backup completado: $BACKUP_DIR/mezon_backup_$DATE.tar.gz"

Errores Habituales

1. "Module not found" Errors

# Solución: Reinstalar dependencias
yarn install --force

# Verificar node_modules
ls -la node_modules | head -20

2. "Permission denied" (macOS/Linux)

# Solución: Corregir permisos
sudo chown -R $USER:$USER /path/to/mezon
chmod -R 755 /path/to/mezon/node_modules

3. Port Already in Use

# Verificar qué proceso usa el puerto
lsof -i :4200
netstat -tulpn | grep :4200

# Cambiar puerto o matar proceso
sudo kill -9 
# O editar .env y cambiar puerto

4. io_uring no disponible (Linux)

# Verificar soporte io_uring
cat /proc/sys/fs/io_uring/max_threads

# Si es 0, habilitar:
echo "fs.io_uring.max_threads=128" >> /etc/sysctl.conf
sysctl -p

5. Database Connection Failed

# Verificar conexión PostgreSQL
psql -h localhost -U mezon_user -d mezon_db -c "SELECT 1;"

# Verificar credenciales en .env
cat apps/chat/.env | grep DATABASE_URL

Seguridad

Configuración de Seguridad Recomendada

# Habilitar TLS para producción
cat > /etc/mezon/tls.conf << 'EOF'
SSL_ENABLED=true
SSL_CERT_FILE=/path/to/cert.pem
SSL_KEY_FILE=/path/to/key.pem
SSL_MIN_VERSION=TLSv1.2
EOF

# Configurar CORS
cat >> apps/chat/.env << 'EOF'
VITE_CORS_ALLOWED_ORIGINS=https://tu-dominio.com
VITE_CORS_ALLOWED_METHODS=GET,POST,PUT,DELETE
EOF

# Habilitar E2EE
cat > .env.production << 'EOF'
MEZON_E2EE_ENABLED=true
MEZON_ZERO_KNOWLEDGE=true
EOF

# Configurar rate limiting
cat >> apps/chat/.env << 'EOF'
VITE_RATE_LIMIT_WINDOW_MS=60000
VITE_RATE_LIMIT_MAX_REQUESTS=100
EOF

Hardening de PostgreSQL

# Deshabilitar superuser remoto
sudo -u postgres psql << 'EOF'
ALTER USER postgres PASSWORD 'new_secure_password';
REVOKE ALL ON DATABASE mezon_db FROM postgres;
GRANT CONNECT ON DATABASE mezon_db TO mezon_user;
GRANT USAGE ON SCHEMA public TO mezon_user;
GRANT ALL ON ALL TABLES IN SCHEMA public TO mezon_user;
EOF

# Configurar pg_hba.conf para autenticación segura
cat >> /etc/postgresql/*/main/pg_hba.conf << 'EOF'
# TYPE  DATABASE        USER            ADDRESS                 METHOD
host    all             mezon_user      127.0.0.1/32            scram-sha-256
host    all             mezon_user      ::1/128                 scram-sha-256
EOF

# Reiniciar PostgreSQL
sudo systemctl restart postgresql

Hardening de Redis

# Configurar Redis para producción
cat > /etc/redis/redis-security.conf << 'EOF'
bind 127.0.0.1
protected-mode yes
requirepass your-secure-redis-password
maxmemory 2gb
maxmemory-policy allkeys-lra
appendonly yes
save 900 1
save 300 10
save 60 10000
EOF

# Reiniciar Redis
sudo systemctl restart redis-server

FAQ

¿Mezon es self-hosted?

Sí, pero el despliegue en producción usa native systemd + Ansible (no Docker) según la documentación oficial de mezon-bot-ai. Local dev usa docker-compose.yml.

¿Qué es io_uring?

io_uring es una API de I/O asíncrona para Linux que permite operaciones de E/S eficientes sin syscalls costosos. Mezon-sfu usa io_uring end-to-end con buffers de anillo para ingress y IORING_OP_SEND_ZC para egress.

¿Qué es zero-copy?

Zero-copy significa que los datos se mueven sin copiar entre buffers. Mezon usa AF_XDP (con io_uring fallback) para pipeline de media zero-copy, habilitando fan-out eficiente a miles de suscriptores con mínimo overhead de CPU.

¿Mezon es open source?

Sí, todo el código fuente está disponible en GitHub:

Servidor (C): mezonai/mezon
SFU (C): mezonai/mezon-sfu
Media Engine (libmezia C11)
Clientes (Rust, Swift, Kotlin, React)

Todos los repositorios son públicos.

¿Puedo usar Docker para producción?

No según la documentación oficial. El despliegue en producción usa native systemd + Ansible con Postgres+pgvector, Redis, MinIO y Python services como procesos nativos (no Docker). Local dev usa docker-compose.yml.

¿Cómo verifico que la instalación es segura?

Verificar TLS 1.3 en ruta de medios
Confirmar E2EE habilitado (MEZON_E2EE_ENABLED=true)
Validar arquitectura zero-knowledge
Revisar headers de seguridad HTTP
Auditar permisos de archivos sensibles

¿Dónde encontrar más documentación?

Recursos y Documentación Oficial

Recurso	URL
Documentación Oficial	https://mezon.ai/docs/
Repositorio Principal	https://github.com/mezonai/mezon
Desktop App	https://github.com/mezonai/mezon-desktop
iOS App	https://github.com/mezonai/mezon-ios
Android App	https://github.com/mezonai/mezon-android
SDK Developer	https://mezon.ai/docs/developer/mezon-sdk/
Blog: Why Mezon SFU	https://mezon.ai/blogs/why-mezon-sfu/

Guía de Instalación y Configuración de Mezon - Plataforma de Comunicación en Tiempo Real