Minería XMRig

Mine Monero (XMR) y otras criptomonedas usando XMRig en los servidores GPU y CPU de Clore.ai.

XMRig es el minero de criptomonedas de código abierto más utilizado. Admite minería en CPU (algoritmo RandomX para Monero) y minería en GPU (KawPow, Ethash y otros). Esta guía cubre el despliegue en servidores de Clore.ai.

Antes de comenzar: Siempre calcula la rentabilidad antes de minar. Ten en cuenta los costos de alquiler de Clore.ai, las comisiones de la pool y los precios actuales de las monedas. Usa una calculadora de rentabilidad de minería para asegurarte de que estás obteniendo retornos positivos.

---

¿Qué es XMRig?

XMRig es un minero de alto rendimiento y multiplataforma para CPU y GPU:

Característica	Detalles
Minería en CPU	Monero (XMR) vía RandomX — MEJOR caso de uso
Minería en GPU	KawPow (RVN), variantes de Ethash, Octopus
Algoritmos	RandomX, KawPow, Ethash, Autolykos2, Octopus + más
Stratum V2	Soporte para protocolos modernos de pools
Soporte TLS	Conexiones encriptadas a pools
Licencia	GPL 3.0, código abierto

¿Por qué Clore.ai para XMRig?

• CPUs con muchos núcleos: Los servidores de Clore.ai a menudo tienen 32-128 núcleos de CPU — ideal para RandomX

• Precios spot: Alquila a bajo costo durante horas de menor demanda

• Sin inversión en hardware: Mina sin comprar ni mantener hardware

• Flexibilidad: Cambia de algoritmos o monedas según la rentabilidad

---

Verifica la rentabilidad primero

¡Haz esto antes de gastar un solo centavo en costos de alquiler!

La rentabilidad de la minería cambia diariamente. Verifica siempre antes de comenzar.

Calculadoras de rentabilidad

• minerstat.com/calc — multi-algoritmo

• whattomine.com — integral

• xmrig.com/docs/algorithms — referencia de hashrate

Cálculo rápido

Beneficio diario = (Recompensa diaria en USD) - (Costo diario de alquiler)

Ejemplo (Monero, servidor de 32 núcleos):
- Hashrate: ~32.000 H/s (1.000 H/s por núcleo)
- Recompensa diaria en XMR: ~0.001-0.003 XMR/día
- Precio de XMR (ejemplo): $160
- Ingresos diarios: $0.16-0.48
- Alquiler del servidor (32 núcleos, ~$0.20/h): $4.80/día

Resultado: NEGATIVO. Los servidores con muchos núcleos a menudo no son rentables para minería en solitario.

Mejor enfoque: Encuentra servidores baratos con muchos núcleos donde el alquiler < recompensa diaria

Cuando tiene sentido: Cuando encuentres un servidor con 64+ núcleos a $0.05-0.10/h, o servidores GPU a precios spot bajos para monedas minables en GPU. ¡Siempre calcula primero!

---

Prerrequisitos

Requisito	Detalles
Cuenta de Clore.ai	Con saldo CLORE
Cuenta en pool de minería	Crea en supportXMR.com, MoneroOcean, etc.
Cartera de Monero	Descarga en getmonero.org (para minería de XMR)
Acceso SSH	Puerto 22

Crear una cartera de Monero

# Opción 1: cartera CLI
wget https://downloads.getmonero.org/cli/linux64
tar xzf monero-linux-x64-*.tar.bz2
./monero-x86_64-linux-gnu-v*/monero-wallet-cli --generate-new-wallet micartera

# Opción 2: cartera GUI (equipo local)
# Descarga desde: https://www.getmonero.org/downloads/

Guarda la dirección de tu cartera — se ve así:

43xxxx...cadena larga...xxxx

---

Paso 1: Alquila un Servidor

Para minería en CPU (Monero/RandomX)

1. Ve a clore.ai → Marketplace

2. Filtrar por Núcleos de CPU: Se prefieren 32+ núcleos

3. Busca servidores con alto número de hilos de CPU

4. Puerto 22 es suficiente

5. Ordena el servidor

Para minería en GPU (KawPow, Octopus)

1. Filtrar por GPU: RTX 3080+, RTX 4090 para mejor rendimiento

2. Puertos necesarios: 22 solo

3. Solo GPUs NVIDIA para minería CUDA

CPU vs GPU en Clore.ai: Clore.ai es principalmente un mercado de GPU. Para Monero (RandomX), los servidores dedicados de CPU pueden ser más baratos. Para monedas minables en GPU, los servidores NVIDIA ofrecen mejor rendimiento.

---

Paso 2: Desplegar XMRig vía Docker

Dockerfile personalizado

Crea un Dockerfile en el servidor:

FROM ubuntu:22.04

ENV DEBIAN_FRONTEND=noninteractive

# Instalar dependencias
RUN apt-get update && apt-get install -y \
    wget \
    libssl-dev \
    libhwloc-dev \
    libuv1-dev \
    build-essential \
    cmake \
    git \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /opt/xmrig

# Descargar la versión de XMRig
RUN wget https://github.com/xmrig/xmrig/releases/download/v6.21.3/xmrig-6.21.3-linux-static-x64.tar.gz \
    && tar xzf xmrig-*.tar.gz \
    && mv xmrig-*/xmrig . \
    && rm -rf xmrig-*.tar.gz xmrig-*/

# Crear directorio de configuración
RUN mkdir -p /etc/xmrig

ENTRYPOINT ["/opt/xmrig/xmrig"]

Construir imagen

docker build -t xmrig-miner .

Ejecutar minería en CPU (Monero)

docker run -d \
  --name xmrig-cpu \
  --restart unless-stopped \
  --privileged \
  xmrig-miner \
  -o pool.supportxmr.com:443 \
  -u TU_DIRECCIÓN_DE_CARTERA_MONERO \
  -p worker1 \
  -k \
  --tls \
  --cpu-max-threads-hint=100 \
  --log-file=/var/log/xmrig.log

Ejecutar minería en GPU (KawPow - Ravencoin)

docker run -d \
  --name xmrig-gpu \
  --restart unless-stopped \
  --gpus all \
  xmrig-miner \
  -a kawpow \
  -o rvn.2miners.com:6060 \
  -u TU_DIRECCIÓN_RVN.worker1 \
  --log-file=/var/log/xmrig.log

---

Paso 3: Método del archivo de configuración

Usar un archivo de configuración es más limpio que las banderas de línea de comandos.

Crear config.json

{
    "autosave": true,
    "background": false,
    "colors": true,
    "title": true,
    "api": {
        "id": null,
        "worker-id": "clore-worker-1",
        "port": 9090,
        "access-token": null,
        "restricted": true
    },
    "http": {
        "enabled": true,
        "host": "0.0.0.0",
        "port": 9090,
        "access-token": null,
        "restricted": true
    },
    "randomx": {
        "init": -1,
        "init-avx2": -1,
        "mode": "auto",
        "1gb-pages": false,
        "rdmsr": true,
        "wrmsr": true,
        "cache_qos": false,
        "numa": true,
        "scratchpad_prefetch_mode": 1
    },
    "cpu": {
        "enabled": true,
        "huge-pages": true,
        "huge-pages-jit": false,
        "hw-aes": null,
        "priority": null,
        "memory-pool": false,
        "yield": true,
        "max-threads-hint": 100,
        "asm": true,
        "argon2-impl": null,
        "astrobwt-max-size": 550,
        "astrobwt-avx2": false
    },
    "opencl": {
        "enabled": false,
        "cache": true,
        "loader": null,
        "platform": "AMD"
    },
    "cuda": {
        "enabled": true,
        "loader": null,
        "nvml": true
    },
    "log-file": null,
    "donate-level": 1,
    "donate-over-proxy": 1,
    "pools": [
        {
            "algo": null,
            "coin": "XMR",
            "url": "pool.supportxmr.com:443",
            "user": "TU_DIRECCIÓN_DE_CARTERA_MONERO",
            "pass": "worker1",
            "rig-id": null,
            "nicehash": false,
            "keepalive": true,
            "enabled": true,
            "tls": true,
            "tls-fingerprint": null,
            "daemon": false,
            "socks5": null,
            "self-select": null,
            "submit-to-origin": false
        }
    ],
    "print-time": 60,
    "health-print-time": 60,
    "dmi": true,
    "retries": 5,
    "retry-pause": 5,
    "syslog": false,
    "tls": {
        "enabled": false,
        "protocols": null,
        "cert": null,
        "cert_key": null,
        "ciphers": null,
        "ciphersuites": null,
        "dhparam": null
    },
    "dns": {
        "ipv6": false,
        "ttl": 30
    },
    "user-agent": null,
    "verbose": 0,
    "watch": true
}

Reemplaza TU_DIRECCIÓN_DE_CARTERA_MONERO con tu dirección de cartera real.

Ejecutar con archivo de configuración

docker run -d \
  --name xmrig \
  --restart unless-stopped \
  --privileged \
  -v $(pwd)/config.json:/etc/xmrig/config.json \
  xmrig-miner \
  --config=/etc/xmrig/config.json

---

Paso 4: Habilitar Huge Pages (Mejora de rendimiento)

RandomX se beneficia significativamente de las huge pages de 1GB. Habilítalas en el host:

# Habilitar huge pages (ejecutar en el servidor Clore.ai como root)
echo 1 > /proc/sys/vm/nr_hugepages

# Para huge pages de 1GB (si la CPU lo soporta)
mkdir -p /mnt/hugepages-1g
mount -t hugetlbfs -o pagesize=1G none /mnt/hugepages-1g
echo 4 > /proc/sys/vm/nr_hugepages

# Hacer persistente
echo "vm.nr_hugepages = 128" >> /etc/sysctl.conf
sysctl -p

Impacto en el rendimiento: Las huge pages pueden aumentar el hashrate de Monero entre un 20-50% en algunas CPU. Vale la pena habilitarlas si tienes acceso al sistema host.

---

Paso 5: Monitorizar la minería

Comprobar el estado del contenedor

# Ver registros en tiempo real
docker logs xmrig -f

# Consultar estadísticas vía API
curl http://localhost:9090/2/summary | python3 -m json.tool

Salida de registro de ejemplo

[2024-03-01 10:15:23.456]  miner    speed 10s/60s/15m 31.2k 31.4k 31.1k H/s max 32.1k H/s
[2024-03-01 10:15:30.123]  net      accepted (1/0) diff 200001 (123 ms)
[2024-03-01 10:16:00.789]  miner    speed 10s/60s/15m 31.5k 31.3k 31.2k H/s max 32.1k H/s

Métricas clave a vigilar

Métrica	Qué significa
H/s (hashrate)	Velocidad de minería — más alto es mejor
Shares aceptadas	Trabajo válido enviado a la pool
Shares rechazadas	Trabajo inválido — debería estar cerca de 0
Latencia	Velocidad de conexión a la pool

Panel de la pool

Consulta tu progreso en el sitio web de tu pool:

• SupportXMR: https://supportxmr.com/#/dashboard?wallet=YOUR_ADDRESS

• MoneroOcean: https://moneroocean.stream/#/dashboard?wallet=YOUR_ADDRESS

• 2Miners: https://xmr.2miners.com/account/YOUR_ADDRESS

---

Pools de minería populares

Pools de Monero (XMR)

Pool	URL	Comisión	Pago mínimo
SupportXMR	pool.supportxmr.com:443	0.6%	0.1 XMR
MoneroOcean	gulf.moneroocean.stream:443	0%	0.003 XMR
Pool de XMRig	pool.xmrig.com:443	1%	0.01 XMR
MineXMR	pool.minexmr.com:4444	1%	0.004 XMR

Monedas minables en GPU

Moneda	Algoritmo	Ejemplo de pool
Ravencoin (RVN)	KawPow	rvn.2miners.com:6060
Ergo (ERG)	Autolykos2	erg.2miners.com:8888
Conflux (CFX)	Octopus	cfx.2miners.com:4040
Ethereum Classic (ETC)	Etchash	etc.2miners.com:1010

MoneroOcean es especial: Cambia automáticamente tu minero al algoritmo más rentable en cada momento, mientras sigue pagando en XMR. Ideal para maximizar retornos.

---

MoneroOcean: Cambio automático por beneficio

MoneroOcean mina automáticamente el algoritmo más rentable:

docker run -d \
  --name xmrig-mo \
  --restart unless-stopped \
  --privileged \
  xmrig-miner \
  --algo=rx/0 \
  -o gulf.moneroocean.stream:443 \
  -u TU_DIRECCIÓN_DE_CARTERA_MONERO \
  -p "TU_TRABAJADOR:COMISIÓN_POR_RENDIMIENTO" \
  --tls \
  --cpu-max-threads-hint=95

---

Consejos de optimización

Optimización de CPU

# Usar todos los hilos de CPU
--cpu-max-threads-hint=100

# Establecer prioridad de CPU (0=mínima, 5=máxima)
--cpu-priority=3

# Desactivar yield (no compartir CPU con otros procesos)
--no-yield

# Habilitar AVX2 para RandomX más rápido
# (automático si la CPU lo soporta)

Optimización de GPU (CUDA)

"cuda": {
    "enabled": true,
    "loader": null,
    "nvml": true,
    "devices": [
        {
            "index": 0,
            "threads": 512,
            "blocks": 0,
            "bfactor": 0,
            "bsleep": 0,
            "affinity": -1
        }
    ]
}

Minería dual (CPU + GPU)

"cpu": {
    "enabled": true,
    "max-threads-hint": 100
},
"cuda": {
    "enabled": true,
    "nvml": true
}

---

Consideraciones de seguridad

Lista de verificación de seguridad para minería:

• Nunca ejecutes mineros como root si es posible

• No expongas públicamente el puerto API de XMRig (9090)

• Usa conexiones TLS a las pools (--tls bandera)

• Mantén XMRig actualizado para parchear vulnerabilidades

• Monitorea picos inusuales en el uso de CPU/GPU

Proteger el endpoint API

"api": {
    "port": 9090,
    "access-token": "tu-token-secreto-aquí",
    "restricted": true
}

# Acceso con token
curl -H "Authorization: Bearer tu-token-secreto-aquí" \
     http://localhost:9090/2/summary

---

Script automatizado de monitorización de beneficios

#!/bin/bash
# monitor-mining.sh

WALLET="TU_DIRECCIÓN_DE_CARTERA"
RENTAL_COST_PER_HOUR=0.50  # Tu coste en Clore.ai en USD

while true; do
  # Obtener hashrate actual
  HASHRATE=$(curl -s http://localhost:9090/2/summary | \
             python3 -c "import sys,json; d=json.load(sys.stdin); print(d['hashrate']['total'][0])")
  
  echo "$(date): Hashrate: ${HASHRATE} H/s"
  echo "$(date): Coste por hora: \$${RENTAL_COST_PER_HOUR}"
  
  # Comprobar shares aceptadas
  ACCEPTED=$(curl -s http://localhost:9090/2/summary | \
             python3 -c "import sys,json; d=json.load(sys.stdin); print(d['results']['shares_good'])")
  echo "$(date): Shares aceptadas: ${ACCEPTED}"
  
  sleep 300  # Comprobar cada 5 minutos
done

---

Solución de problemas

Bajo hashrate

# Comprobar la asignación de CPU en el contenedor
docker exec xmrig cat /proc/cpuinfo | grep processor | wc -l

# Asegurarse de que las huge pages estén habilitadas
cat /proc/sys/vm/nr_hugepages

# Comprobar throttling térmico
watch -n1 "sensors 2>/dev/null | grep temp || cat /sys/class/thermal/thermal_zone*/temp"

Problemas de conexión

# Probar conectividad con la pool
curl -k telnet://pool.supportxmr.com:443

# Usar pool alternativa si está bloqueada
# Probar: xmr.pool.minergate.com:443

Errores CUDA

# Verificar acceso a la GPU en el contenedor
docker exec xmrig-gpu nvidia-smi

# Si falta, añade --gpus all al docker run
docker stop xmrig-gpu
docker rm xmrig-gpu
# Volver a ejecutar con --gpus all

El contenedor se reinicia continuamente

# Comprobar el código de salida
docker inspect xmrig --format='{{.State.ExitCode}}'

# Ver registros detallados
docker logs xmrig --since 5m

# Causas comunes:
# - Dirección de cartera inválida
# - Conexión a la pool fallida
# - Error de sintaxis en el archivo de configuración

---

Notas legales y éticas

Consideraciones importantes:

1. Consulta los ToS de Clore.ai: Asegúrate de que la minería esté permitida en tus servidores alquilados

2. Cumplimiento fiscal: La criptomoneda minada puede ser ingreso sujeto a impuestos en tu jurisdicción

3. Rentabilidad: La minería en la nube suele ser no rentable — haz tus cálculos primero

4. Efecto en la red: La minería contribuye a la seguridad de la blockchain (contribución positiva)

---

Referencia rápida

Banderas de línea de comandos

Bandera	Descripción
-o URL	Dirección de la pool
-u DIRECCIÓN	Dirección de cartera
-p WORKER	Nombre del trabajador
-a ALGO	Algoritmo (rx/0 para Monero)
--tls	Habilitar cifrado TLS
-k	Conexión keepalive
--cpu-max-threads-hint=N	Usar N% de hilos de CPU
--donate-level=0	Desactivar donación al desarrollador

Referencia de algoritmos

Algoritmo	Moneda	Mejor hardware
rx/0	Monero (XMR)	CPU (RandomX)
kawpow	Ravencoin (RVN)	GPU
autolykos2	Ergo (ERG)	GPU
pulpo	Conflux (CFX)	GPU
etchash	ETC	GPU

---

Enlaces útiles

• XMRig GitHub

• Documentación de XMRig

• Calculadora WhatToMine

• Pool MoneroOcean

• Pool SupportXMR

• Mercado de Clore.ai

---

Resumen

Paso	Acción
1	Calcule la rentabilidad PRIMERO
2	Cree una billetera Monero en getmonero.org
3	Regístrese en un pool de minería
4	Alquile un servidor (núcleos de CPU para XMR, GPU para otros)
5	Construya la imagen Docker de XMRig
6	Configure config.json con la billetera y el pool
7	Habilite huge pages para un aumento del 20-50% en el hashrate
8	Inicie la minería y supervise a través del panel del pool

XMRig en Clore.ai le da acceso a hardware de minería de alto rendimiento a demanda. Úselo estratégicamente: mine cuando los precios sean altos y los costos de alquiler bajos. Siempre haga los cálculos primero. ⛏️

---

Recomendaciones de GPU en Clore.ai

Caso de uso	GPU recomendada	Coste estimado en Clore.ai
Minería de nivel inicial	RTX 3080 (10GB)	~$0.08/gpu/hora
Minería óptima	RTX 3090 (24GB)	~$0.12/gpu/hr
Minería de alto rendimiento	RTX 4090 (24GB)	~$0.70/gpu/hr

💡 Todos los ejemplos en esta guía pueden desplegarse en Clore.ai servidores GPU. Navega las GPUs disponibles y alquila por hora — sin compromisos, acceso root completo.