Minería con 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 con CPU (algoritmo RandomX para Monero) y minería con GPU (KawPow, Ethash y otros). Esta guía cubre la implementación en servidores de Clore.ai.

Antes de empezar: Calcula siempre la rentabilidad antes de minar. Ten en cuenta los costes de alquiler de Clore.ai, las comisiones del pool y los precios actuales de las monedas. Usa una calculadora de rentabilidad de minería para asegurarte de que estás generando rendimientos positivos.

---

¿Qué es XMRig?

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

Función	Detalles
Minería con CPU	Monero (XMR) mediante RandomX — EL MEJOR caso de uso
Minería con GPU	KawPow (RVN), variantes de Ethash, Octopus
Algoritmos	RandomX, KawPow, Ethash, Autolykos2, Octopus y más
Stratum V2	Compatibilidad con el protocolo de pool moderno
Compatibilidad con TLS	Conexiones cifradas al pool
Licencia	GPL 3.0, código abierto

¿Por qué Clore.ai para XMRig?

• CPUs con gran cantidad de núcleos: Los servidores de Clore.ai suelen tener entre 32 y 128 núcleos de CPU — ideales para RandomX

• Precios spot: Alquila barato durante las horas de menor demanda

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

• Flexibilidad: Cambia de algoritmo o moneda según la rentabilidad

---

Primero comprueba la rentabilidad

¡Haz esto antes de gastar un solo céntimo en costes de alquiler!

La rentabilidad de la minería cambia a diario. Verifica siempre antes de empezar.

Calculadoras de rentabilidad

• minerstat.com/calc — multialgoritmo

• whattomine.com — completa

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

Cálculo rápido

Beneficio diario = (recompensa diaria en USD) - (coste diario de alquiler)

Ejemplo (Monero, servidor de 32 núcleos):
- Hashrate: ~32.000 H/s (1.000 H/s por núcleo)
- Recompensa diaria de 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 < la recompensa diaria

Cuándo 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 con GPU. ¡Calcula siempre primero!

---

Requisitos previos

Requisito	Detalles
Cuenta de Clore.ai	Con saldo CLORE
Cuenta del pool de minería	Crea una en supportXMR.com, MoneroOcean, etc.
Monedero Monero	Descárgalo en getmonero.org (para minar XMR)
Acceso SSH	Puerto 22

Crear un monedero Monero

# Opción 1: monedero 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 mywallet

# Opción 2: monedero GUI (máquina local)
# Descargar desde: https://www.getmonero.org/downloads/

Guarda la dirección de tu monedero — se parece a:

43xxxx...long string...xxxx

---

Paso 1: Alquila un servidor

Para minería con 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 un alto número de hilos de CPU

4. Puerto 22 es suficiente

5. Pide el servidor

Para minería con GPU (KawPow, Octopus)

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

2. Puertos necesarios: 22 solo

3. Solo GPU NVIDIA para minería CUDA

CPU frente a 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 con GPU, los servidores NVIDIA ofrecen mejor rendimiento.

---

Paso 2: Implementa XMRig mediante 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 con CPU (Monero)

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

Ejecutar minería con GPU (KawPow - Ravencoin)

docker run -d \\
  --name xmrig-gpu \\
  --restart unless-stopped \\
  --gpus all \\
  xmrig-miner \\
  -a kawpow \\
  -o rvn.2miners.com:6060 \\
  -u YOUR_RVN_WALLET.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 la 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": "YOUR_MONERO_WALLET_ADDRESS",
            "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 YOUR_MONERO_WALLET_ADDRESS con tu dirección real del monedero.

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: Habilita las páginas enormes (mejora del rendimiento)

RandomX se beneficia significativamente de las páginas enormes de 1 GB. Habilítalas en el host:

# Habilitar páginas enormes (ejecutar en el servidor de Clore.ai como root)
echo 1 > /proc/sys/vm/nr_hugepages

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

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

Impacto en el rendimiento: Las páginas enormes pueden aumentar el hashrate de Monero entre un 20 y un 50 % en algunas CPUs. Vale la pena activarlas si tienes acceso al sistema host.

---

Paso 5: Monitoriza la minería

Comprobar estado del contenedor

# Ver registros en tiempo real
docker logs xmrig -f

# Comprobar estadísticas mediante la API
curl http://localhost:9090/2/summary | python3 -m json.tool

Ejemplo de salida de registro

[2024-03-01 10:15:23.456]  minero    velocidad 10s/60s/15m 31.2k 31.4k 31.1k H/s máx 32.1k H/s
[2024-03-01 10:15:30.123]  red      aceptada (1/0) diff 200001 (123 ms)
[2024-03-01 10:16:00.789]  minero    velocidad 10s/60s/15m 31.5k 31.3k 31.2k H/s máx 32.1k H/s

Métricas clave a vigilar

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

Panel del 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 XMRig	pool.xmrig.com:443	1%	0.01 XMR
MineXMR	pool.minexmr.com:4444	1%	0.004 XMR

Monedas minables con 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. Excelente para maximizar los rendimientos.

---

MoneroOcean: cambio automático a la opción más rentable

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 YOUR_MONERO_WALLET \\
  -p "YOUR_WORKER:PERFORMANCE_FEE" \\
  --tls \\
  --cpu-max-threads-hint=95

---

Consejos de optimización

Optimización de CPU

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

# Establecer la prioridad de la CPU (0=más baja, 5=más alta)
--cpu-priority=3

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

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

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 de la API de XMRig (9090)

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

• Mantén XMRig actualizado para corregir vulnerabilidades

• Monitorea picos inusuales de uso de CPU/GPU

Proteger el endpoint de la API

"api": {
    "port": 9090,
    "access-token": "your-secret-token-here",
    "restricted": true
}

# Acceder con token
curl -H "Authorization: Bearer your-secret-token-here" \
     http://localhost:9090/2/summary

---

Script automatizado de monitoreo de ganancias

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

WALLET="YOUR_WALLET_ADDRESS"
RENTAL_COST_PER_HOUR=0.50  # Tu costo de Clore.ai en USD

while true; do
  # Obtener el 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): Costo 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

Hashrate bajo

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

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

# Comprobar limitación térmica
watch -n1 "sensors 2>/dev/null | grep temp || cat /sys/class/thermal/thermal_zone*/temp"

Problemas de conexión

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

# Usa un pool alternativo si está bloqueado
# Prueba: xmr.pool.minergate.com:443

Errores de CUDA

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

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

El contenedor sigue reiniciándose

# 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 la billetera inválida
# - Falló la conexión con el pool
# - Error de sintaxis en el archivo de configuración

---

Notas legales y éticas

Consideraciones importantes:

1. Consulta los Términos de servicio 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 a menudo no es rentable — haz tus cálculos primero

4. Efecto de 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 del pool
-u ADDRESS	Dirección de la billetera
-p WORKER	Nombre del worker
-a ALGO	Algoritmo (rx/0 para Monero)
--tls	Habilitar cifrado TLS
-k	Conexión keepalive
--cpu-max-threads-hint=N	Usa N% de los hilos de CPU
--donate-level=0	Deshabilitar la 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
octopus	Conflux (CFX)	GPU
etchash	ETC	GPU

---

Enlaces útiles

• GitHub de XMRig

• Documentación de XMRig

• Calculadora WhatToMine

• Pool MoneroOcean

• Pool SupportXMR

• Marketplace de Clore.ai

---

Resumen

Paso	Acción
1	Calcula la rentabilidad PRIMERO
2	Crea una billetera de Monero en getmonero.org
3	Regístrate en un pool de minería
4	Alquila un servidor (núcleos de CPU para XMR, GPU para otros)
5	Construye la imagen Docker de XMRig
6	Configura config.json con la billetera y el pool
7	Habilita huge pages para un aumento del hashrate de 20-50%
8	Inicia la minería y monitorea mediante el panel del pool

XMRig en Clore.ai te da acceso a hardware de minería de alto rendimiento bajo demanda. Úsalo estratégicamente — mina cuando los precios sean altos y los costos de alquiler bajos. Haz siempre los cálculos primero. ⛏️

---

Recomendaciones de GPU para Clore.ai

Caso de uso	GPU recomendada	Costo estimado en Clore.ai
Minería básica	RTX 3080 (10GB)	$0.05–0.19/gpu/hr
Minería óptima	RTX 3090 (24GB)	$0.07–0.21/gpu/hr
Minería de alto rendimiento	RTX 4090 (24GB)	$0.14–0.42/gpu/hr

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