> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/cripto-y-mineria/xmrig.md).

# Minería con 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 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.
{% endhint %}

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

***

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

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

### Calculadoras de rentabilidad

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

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

***

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

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

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

***

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

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

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

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

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

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

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

***

## Paso 5: Monitoriza la minería

### Comprobar estado del contenedor

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

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

***

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

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

***

## Consejos de optimización

### Optimización de CPU

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

```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 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
  {% endhint %}

### Proteger el endpoint de la API

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

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

***

## Script automatizado de monitoreo de ganancias

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

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

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

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

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

***

## Notas legales y éticas

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

***

## 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](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)
* [Marketplace de Clore.ai](https://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](https://clore.ai/marketplace) servidores GPU. Explora las GPUs disponibles y alquila por hora: sin compromisos, acceso root completo.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/cripto-y-mineria/xmrig.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.