# Minage XMRig

Minez Monero (XMR) et d'autres crypto-monnaies en utilisant XMRig sur les serveurs GPU et CPU de Clore.ai.

{% hint style="info" %}
**XMRig** est le mineur de crypto-monnaie open-source le plus utilisé. Il prend en charge le minage CPU (algorithme RandomX pour Monero) et le minage GPU (KawPow, Ethash et autres). Ce guide couvre le déploiement sur les serveurs Clore.ai.
{% endhint %}

{% hint style="warning" %}
**Avant de commencer**: Calculez toujours la rentabilité avant de miner. Prenez en compte les coûts de location sur Clore.ai, les frais du pool et les prix actuels des pièces. Utilisez un calculateur de rentabilité de minage pour vous assurer que vous générez un rendement positif.
{% endhint %}

***

## Qu'est-ce que XMRig ?

XMRig est un mineur haute performance, multiplateforme pour CPU et GPU :

| Fonctionnalité  | Détails                                               |
| --------------- | ----------------------------------------------------- |
| **Minage CPU**  | Monero (XMR) via RandomX — MEILLEUR cas d'utilisation |
| **Minage GPU**  | KawPow (RVN), variantes Ethash, Octopus               |
| **Algorithmes** | RandomX, KawPow, Ethash, Autolykos2, Octopus + plus   |
| **Stratum V2**  | Support du protocole de pool moderne                  |
| **Support TLS** | Connexions chiffrées au pool                          |
| **Licence**     | GPL 3.0, open source                                  |

### Pourquoi Clore.ai pour XMRig ?

* **CPU avec grand nombre de cœurs**: Les serveurs Clore.ai ont souvent 32 à 128 cœurs CPU — idéal pour RandomX
* **Tarification spot**: Louez à bas prix pendant les heures creuses
* **Aucun investissement matériel**: Minez sans acheter ni entretenir du matériel
* **Flexibilité**: Changez d'algorithme ou de pièce selon la rentabilité

***

## Vérifiez la rentabilité d'abord

{% hint style="danger" %}
**Faites cela avant de dépenser le moindre centime en frais de location !**

La rentabilité du minage change quotidiennement. Vérifiez toujours avant de commencer.
{% endhint %}

### Calculatrices de rentabilité

* [minerstat.com/calc](https://minerstat.com/calc) — multi-algorithme
* [whattomine.com](https://whattomine.com) — complet
* [xmrig.com/docs/algorithms](https://xmrig.com/docs/algorithms) — référence de hashrate

### Calcul rapide

```
Profit journalier = (Récompense journalière en USD) - (Coût de location journalier)

Exemple (Monero, serveur 32 cœurs) :
- Hashrate : ~32 000 H/s (1 000 H/s par cœur)
- Récompense XMR journalière : ~0,001-0,003 XMR/jour
- Prix XMR (exemple) : 160 $
- Revenu journalier : 0,16 $ - 0,48 $
- Location du serveur (32 cœurs, ~0,20 $/h) : 4,80 $/jour

Résultat : NÉGATIF. Les serveurs à grand nombre de cœurs ne sont souvent pas rentables pour le minage solo.

Meilleure approche : Trouvez des serveurs bon marché à grand nombre de cœurs où la location < récompense journalière
```

{% hint style="success" %}
**Quand cela a du sens**: Lorsqu'on trouve un serveur avec 64+ cœurs à 0,05-0,10 $/h, ou des serveurs GPU à bas prix spot pour des pièces exploitables par GPU. Calculez toujours d'abord !
{% endhint %}

***

## Prérequis

| Exigence                 | Détails                                            |
| ------------------------ | -------------------------------------------------- |
| Compte Clore.ai          | Avec solde CLORE                                   |
| Compte de pool de minage | Créez-en un sur supportXMR.com, MoneroOcean, etc.  |
| Portefeuille Monero      | Téléchargez sur getmonero.org (pour le minage XMR) |
| Accès SSH                | Port 22                                            |

### Créer un portefeuille Monero

```bash
# Option 1 : portefeuille 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

# Option 2 : portefeuille GUI (machine locale)
# Téléchargement depuis : https://www.getmonero.org/downloads/
```

Enregistrez votre adresse de portefeuille — elle ressemble à :

```
43xxxx...longue chaîne...xxxx
```

***

## Étape 1 : Louer un serveur

### Pour le minage CPU (Monero/RandomX)

1. Aller à [clore.ai](https://clore.ai) → **Place de marché**
2. Filtrer par **Cœurs CPU**: 32+ cœurs préférés
3. Recherchez des serveurs avec un grand nombre de threads CPU
4. Port **22** est suffisant
5. Commandez le serveur

### Pour le minage GPU (KawPow, Octopus)

1. Filtrer par **GPU**: RTX 3080+, RTX 4090 pour de meilleures performances
2. Ports nécessaires : **22** seulement
3. GPU NVIDIA uniquement pour le minage CUDA

{% hint style="info" %}
**CPU vs GPU sur Clore.ai**: Clore.ai est principalement un marché GPU. Pour Monero (RandomX), les serveurs CPU dédiés peuvent être moins chers. Pour les pièces exploitables par GPU, les serveurs NVIDIA offrent de meilleures performances.
{% endhint %}

***

## Étape 2 : Déployer XMRig via Docker

### Dockerfile personnalisé

Créez un `Dockerfile` sur le serveur :

```dockerfile
FROM ubuntu:22.04

ENV DEBIAN_FRONTEND=noninteractive

# Installer les dépendances
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

# Télécharger la release 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-*/

# Créer le répertoire de configuration
RUN mkdir -p /etc/xmrig

ENTRYPOINT ["/opt/xmrig/xmrig"]
```

### Construire l'image

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

### Exécuter le minage CPU (Monero)

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

### Exécuter le minage 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 VOTRE_PORTEFEUILLE_RVN.worker1 \
  --log-file=/var/log/xmrig.log
```

***

## Étape 3 : Méthode du fichier de configuration

Utiliser un fichier de config est plus propre que les options en ligne de commande.

### Créer `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": "VOTRE_ADRESSE_PORTEFEUILLE_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
}
```

Remplacez `VOTRE_ADRESSE_PORTEFEUILLE_MONERO` par votre adresse de portefeuille réelle.

### Exécuter avec le fichier de config

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

***

## Étape 4 : Activer les Huge Pages (amélioration des performances)

RandomX bénéficie considérablement des huge pages de 1 Go. Activez-les sur l'hôte :

```bash
# Activer les huge pages (exécuter sur le serveur Clore.ai en root)
echo 1 > /proc/sys/vm/nr_hugepages

# Pour les huge pages de 1 Go (si pris en charge par le CPU)
mkdir -p /mnt/hugepages-1g
mount -t hugetlbfs -o pagesize=1G none /mnt/hugepages-1g
echo 4 > /proc/sys/vm/nr_hugepages

# Rendre persistant
echo "vm.nr_hugepages = 128" >> /etc/sysctl.conf
sysctl -p
```

{% hint style="info" %}
**Impact sur les performances**: Les huge pages peuvent augmenter le hashrate Monero de 20 à 50 % sur certains CPU. Cela vaut la peine de les activer si vous avez accès au système hôte.
{% endhint %}

***

## Étape 5 : Surveiller le minage

### Vérifier l'état du conteneur

```bash
# Voir les logs en temps réel
docker logs xmrig -f

# Vérifier les stats via l'API
curl http://localhost:9090/2/summary | python3 -m json.tool
```

### Exemple de sortie de log

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

### Principales métriques à surveiller

| Métrique        | Ce que cela signifie                              |
| --------------- | ------------------------------------------------- |
| H/s (hashrate)  | Vitesse de minage — plus c'est élevé, mieux c'est |
| Parts acceptées | Travail valide soumis au pool                     |
| Parts rejetées  | Travail invalide — devrait être proche de 0       |
| Latence         | Vitesse de connexion au pool                      |

### Tableau de bord du pool

Vérifiez votre progression sur le site de votre 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 minage populaires

### Pools Monero (XMR)

| Pool        | URL                         | Frais | Paiement min. (Min Payout) |
| ----------- | --------------------------- | ----- | -------------------------- |
| 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                  |

### Pièces exploitables par GPU

| Pièce                  | Algorithme | Exemple 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 est spécial**: Il bascule automatiquement votre mineur vers l'algorithme le plus rentable à un moment donné, tout en payant en XMR. Idéal pour maximiser les rendements.
{% endhint %}

***

## MoneroOcean : basculement automatique pour le profit

MoneroOcean mine automatiquement l'algorithme le plus rentable :

```bash
docker run -d \
  --name xmrig-mo \
  --restart unless-stopped \
  --privileged \
  xmrig-miner \
  --algo=rx/0 \
  -o gulf.moneroocean.stream:443 \
  -u VOTRE_PORTEFEUILLE_MONERO \
  -p "VOTRE_WORKER:PERFORMANCE_FEE" \
  --tls \
  --cpu-max-threads-hint=95
```

***

## Conseils d'optimisation

### Optimisation CPU

```bash
# Utiliser tous les threads CPU
--cpu-max-threads-hint=100

# Définir la priorité CPU (0 = plus bas, 5 = plus haut)
--cpu-priority=3

# Désactiver le yield (ne pas partager le CPU avec d'autres processus)
--no-yield

# Activer AVX2 pour accélérer RandomX
# (automatique si le CPU le prend en charge)
```

### Optimisation GPU (CUDA)

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

### Minage double (CPU + GPU)

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

***

## Considérations de sécurité

{% hint style="warning" %}
**Liste de vérification de sécurité pour le minage :**

* Ne lancez jamais de mineurs en root si possible
* N'exposez pas le port API XMRig (9090) publiquement
* Utilisez des connexions TLS aux pools (`--tls` option)
* Maintenez XMRig à jour pour corriger les vulnérabilités
* Surveillez les pics d'utilisation CPU/GPU inhabituels
  {% endhint %}

### Protéger le point de terminaison API

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

```bash
# Accès avec token
curl -H "Authorization: Bearer votre-token-secret-ici" \
     http://localhost:9090/2/summary
```

***

## Script automatisé de surveillance de la rentabilité

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

WALLET="VOTRE_ADRESSE_PORTEFEUILLE"
RENTAL_COST_PER_HOUR=0.50  # Votre coût Clore.ai en USD

while true; do
  # Obtenir le hashrate actuel
  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): Coût horaire : \$${RENTAL_COST_PER_HOUR}"
  
  # Vérifier les parts acceptées
  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): Parts acceptées : ${ACCEPTED}"
  
  sleep 300  # Vérifier toutes les 5 minutes
done
```

***

## Dépannage

### Faible hashrate

```bash
# Vérifier l'allocation CPU dans le conteneur
docker exec xmrig cat /proc/cpuinfo | grep processor | wc -l

# Assurez-vous que les huge pages sont activées
cat /proc/sys/vm/nr_hugepages

# Vérifier le throttling thermique
watch -n1 "sensors 2>/dev/null | grep temp || cat /sys/class/thermal/thermal_zone*/temp"
```

### Problèmes de connexion

```bash
# Tester la connectivité au pool
curl -k telnet://pool.supportxmr.com:443

# Utiliser un pool alternatif si bloqué
# Essayez : xmr.pool.minergate.com:443
```

### Erreurs CUDA

```bash
# Vérifier l'accès GPU dans le conteneur
docker exec xmrig-gpu nvidia-smi

# Si manquant, ajoutez --gpus all au docker run
docker stop xmrig-gpu
docker rm xmrig-gpu
# Relancer avec --gpus all
```

### Le conteneur redémarre en boucle

```bash
# Vérifier le code de sortie
docker inspect xmrig --format='{{.State.ExitCode}}'

# Voir les logs détaillés
docker logs xmrig --since 5m

# Causes courantes :
# - Adresse de portefeuille invalide
# - Connexion au pool échouée
# - Erreur de syntaxe dans le fichier de config
```

***

## Notes légales et éthiques

{% hint style="info" %}
**Considérations importantes :**

1. **Vérifiez les ToS de Clore.ai**: Assurez-vous que le minage est autorisé sur vos serveurs loués
2. **Conformité fiscale**: La crypto-monnaie minée peut être un revenu imposable dans votre juridiction
3. **Rentabilité**: Le minage cloud est souvent non rentable — faites vos calculs d'abord
4. **Effet réseau**: Le minage contribue à la sécurité de la blockchain (contribution positive)
   {% endhint %}

***

## Référence rapide

### Options en ligne de commande

| Option                     | Description                   |
| -------------------------- | ----------------------------- |
| `-o URL`                   | Adresse du pool               |
| `-u ADDRESS`               | Adresse du portefeuille       |
| `-p WORKER`                | Nom du worker                 |
| `-a ALGO`                  | Algorithme (rx/0 pour Monero) |
| `--tls`                    | Activer le chiffrement TLS    |
| `-k`                       | Connexion keepalive           |
| `--cpu-max-threads-hint=N` | Utiliser N% des threads CPU   |
| `--donate-level=0`         | Désactiver la donation au dev |

### Référence des algorithmes

| Algorithme | Pièce           | Meilleur matériel |
| ---------- | --------------- | ----------------- |
| rx/0       | Monero (XMR)    | CPU (RandomX)     |
| kawpow     | Ravencoin (RVN) | GPU               |
| autolykos2 | Ergo (ERG)      | GPU               |
| octopus    | Conflux (CFX)   | GPU               |
| etchash    | ETC             | GPU               |

***

## Liens utiles

* [XMRig GitHub](https://github.com/xmrig/xmrig)
* [Documentation XMRig](https://xmrig.com/docs)
* [Calculateur WhatToMine](https://whattomine.com)
* [Pool MoneroOcean](https://moneroocean.stream)
* [Pool SupportXMR](https://supportxmr.com)
* [Clore.ai Marketplace](https://clore.ai)

***

## Résumé

| Étape | Action                                                          |
| ----- | --------------------------------------------------------------- |
| 1     | Calculez la rentabilité EN PREMIER                              |
| 2     | Créez un portefeuille Monero sur getmonero.org                  |
| 3     | Inscrivez-vous à un pool de minage                              |
| 4     | Louez un serveur (cœurs CPU pour XMR, GPU pour les autres)      |
| 5     | Construisez l'image Docker XMRig                                |
| 6     | Configurez config.json avec le portefeuille et le pool          |
| 7     | Activez les pages énormes pour un gain de hashrate de 20 à 50 % |
| 8     | Démarrez le minage et surveillez via le tableau de bord du pool |

XMRig sur Clore.ai vous donne accès à du matériel de minage haute performance à la demande. Utilisez-le stratégiquement — minez lorsque les prix sont élevés et que les coûts de location sont bas. Faites toujours les calculs d'abord. ⛏️

***

## Recommandations GPU Clore.ai

| Cas d’utilisation        | GPU recommandé  | Coût estimé sur Clore.ai |
| ------------------------ | --------------- | ------------------------ |
| Minage d'entrée de gamme | RTX 3080 (10GB) | ≈0,08 $/GPU/heure        |
| Minage optimal           | RTX 3090 (24GB) | \~$0.12/gpu/hr           |
| Minage haute performance | RTX 4090 (24GB) | \~$0.70/gpu/hr           |

> 💡 Tous les exemples de ce guide peuvent être déployés sur [Clore.ai](https://clore.ai/marketplace) serveurs GPU. Parcourez les GPU disponibles et louez à l’heure — sans engagement, avec accès root complet.


---

# 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-fr/crypto-et-minage/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.