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


---

# Agent Instructions: 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:

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

The question should be specific, self-contained, and written in natural language.
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.