# Minería XMRig

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

{% hint style="info" %}
**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.
{% endhint %}

{% hint style="warning" %}
**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.
{% endhint %}

***

## ¿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

{% hint style="danger" %}
**¡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.
{% endhint %}

### Calculadoras de rentabilidad

* [minerstat.com/calc](https://minerstat.com/calc) — multi-algoritmo
* [whattomine.com](https://whattomine.com) — integral
* [xmrig.com/docs/algorithms](https://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
```

{% hint style="success" %}
**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!
{% endhint %}

***

## 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

```bash
# 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](https://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

{% hint style="info" %}
**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.
{% endhint %}

***

## Paso 2: Desplegar XMRig vía Docker

### Dockerfile personalizado

Crea un `Dockerfile` en el servidor:

```dockerfile
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

```bash
docker build -t xmrig-miner .
```

### Ejecutar minería en CPU (Monero)

```bash
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)

```bash
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`

```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

```bash
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:

```bash
# 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
```

{% hint style="info" %}
**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.
{% endhint %}

***

## Paso 5: Monitorizar la minería

### Comprobar el estado del contenedor

```bash
# 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 |

{% hint style="info" %}
**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.
{% endhint %}

***

## MoneroOcean: Cambio automático por beneficio

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

```bash
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

```bash
# 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)

```json
"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)

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

***

## Consideraciones de seguridad

{% hint style="warning" %}
**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
  {% endhint %}

### Proteger el endpoint API

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

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

***

## Script automatizado de monitorización de beneficios

```bash
#!/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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

{% hint style="info" %}
**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)
   {% endhint %}

***

## 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](https://github.com/xmrig/xmrig)
* [Documentación de XMRig](https://xmrig.com/docs)
* [Calculadora WhatToMine](https://whattomine.com)
* [Pool MoneroOcean](https://moneroocean.stream)
* [Pool SupportXMR](https://supportxmr.com)
* [Mercado de Clore.ai](https://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](https://clore.ai/marketplace) servidores GPU. Navega las GPUs disponibles y alquila por hora — sin compromisos, acceso root completo.