> 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-fr/crypto-et-minage/xmrig.md).

# Minage XMRig

Minez du Monero (XMR) et d'autres cryptomonnaies avec XMRig sur les serveurs GPU et CPU de Clore.ai.

{% hint style="info" %}
**XMRig** est le mineur de cryptomonnaie 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. Tenez compte des coûts de location de Clore.ai, des frais de pool et des prix actuels des monnaies. Utilisez un calculateur de rentabilité du minage pour vous assurer que vous générez un rendement positif.
{% endhint %}

***

## Qu'est-ce que XMRig ?

XMRig est un mineur multiplateforme hautes performances 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**          | Prise en charge d'un protocole de pool moderne        |
| **Prise en charge TLS** | Connexions chiffrées au pool                          |
| **Licence**             | GPL 3.0, open source                                  |

### Pourquoi Clore.ai pour XMRig ?

* **CPU à grand nombre de cœurs**: Les serveurs Clore.ai ont souvent 32 à 128 cœurs CPU — idéal pour RandomX
* **Tarifs spot**: Louez à moindre coût pendant les heures creuses
* **Pas d'investissement matériel**: Minez sans acheter ni entretenir de matériel
* **Flexibilité**: Basculez entre les algorithmes ou les monnaies selon la rentabilité

***

## Vérification de la rentabilité d'abord

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

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

### Calculateurs 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 quotidien = (Récompense quotidienne en USD) - (Coût quotidien de location)

Exemple (Monero, serveur 32 cœurs) :
- Hashrate : ~32 000 H/s (1 000 H/s par cœur)
- Récompense quotidienne XMR : ~0,001-0,003 XMR/jour
- Prix du XMR (exemple) : 160 $
- Revenus quotidiens : 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 en solo.

Meilleure approche : trouvez des serveurs bon marché à grand nombre de cœurs où la location < la récompense quotidienne
```

{% hint style="success" %}
**Quand cela a du sens**: Lorsque vous trouvez un serveur avec 64 cœurs ou plus à 0,05-0,10 $/h, ou des serveurs GPU à bas prix spot pour des monnaies minables sur GPU. Calculez toujours d'abord !
{% endhint %}

***

## Prérequis

| Exigence                 | Détails                                               |
| ------------------------ | ----------------------------------------------------- |
| Compte Clore.ai          | Avec un solde CLORE                                   |
| Compte du pool de minage | Créez-en un sur supportXMR.com, MoneroOcean, etc.     |
| Portefeuille Monero      | Téléchargez-le 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écharger depuis : https://www.getmonero.org/downloads/
```

Enregistrez votre adresse de portefeuille — elle ressemble à :

```
43xxxx...long string...xxxx
```

***

## Étape 1 : Louer un serveur

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

1. Accédez à [clore.ai](https://clore.ai) → **Place de marché**
2. Filtrer par **Cœurs CPU**: 32 cœurs ou plus préférés
3. Recherchez des serveurs avec un nombre élevé de threads CPU
4. Port **22** est suffisant
5. Passez commande du serveur

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

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

{% hint style="info" %}
**CPU vs GPU sur Clore.ai**: Clore.ai est principalement une place de marché GPU. Pour Monero (RandomX), les serveurs CPU dédiés peuvent être moins chers. Pour les monnaies minables sur 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 version 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-*/

# 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 YOUR_MONERO_WALLET_ADDRESS \\
  -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 YOUR_RVN_WALLET.worker1 \\
  --log-file=/var/log/xmrig.log
```

***

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

L'utilisation d'un fichier de configuration est plus propre que les options de ligne de commande.

### Créez un fichier `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
}
```

Remplacer `YOUR_MONERO_WALLET_ADDRESS` avec votre adresse de portefeuille réelle.

### Exécuter avec le fichier de configuration

```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 pages géantes (gain de performances)

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

```bash
# Activer les pages géantes (exécutez sur le serveur Clore.ai en tant que root)
echo 1 > /proc/sys/vm/nr_hugepages

# Pour des pages géantes de 1 Go (si prises 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 permanent
echo "vm.nr_hugepages = 128" >> /etc/sysctl.conf
sysctl -p
```

{% hint style="info" %}
**Impact sur les performances**: Les pages géantes 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
# Afficher les journaux en temps réel
docker logs xmrig -f

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

### Exemple de sortie de journal

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

### Indicateurs clés à surveiller

| Indicateur      | 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 — doit être proche de 0          |
| Latence         | Vitesse de connexion au pool                      |

### Tableau de bord du pool

Vérifiez votre progression sur le site web 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 minimum |
| ----------- | --------------------------- | ----- | ---------------- |
| SupportXMR  | pool.supportxmr.com:443     | 0.6%  | 0.1 XMR          |
| MoneroOcean | gulf.moneroocean.stream:443 | 0%    | 0.003 XMR        |
| XMRig Pool  | pool.xmrig.com:443          | 1%    | 0.01 XMR         |
| MineXMR     | pool.minexmr.com:4444       | 1%    | 0.004 XMR        |

### Monnaies minables sur GPU

| Coin                   | 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 particulier**: Il bascule automatiquement votre mineur vers l'algorithme le plus rentable à tout moment, tout en payant en XMR. Idéal pour maximiser les rendements.
{% endhint %}

***

## MoneroOcean : basculement automatique vers la rentabilité

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 YOUR_MONERO_WALLET \\
  -p "YOUR_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=la plus basse, 5=la plus élevée)
--cpu-priority=3

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

# Activer AVX2 pour un RandomX plus rapide
# (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 contrôle de sécurité du minage :**

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

### Protéger le point de terminaison de l’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="YOUR_WALLET_ADDRESS"
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): Taux de hachage : ${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 taux de hachage

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

# Vérifier que les huge pages sont activées
cat /proc/sys/vm/nr_hugepages

# Vérifier le bridage 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é
# Essayer : xmr.pool.minergate.com:443
```

### Erreurs CUDA

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

# Si nécessaire, ajoutez --gpus all à docker run
docker stop xmrig-gpu
docker rm xmrig-gpu
# Relancer avec --gpus all
```

### Le conteneur redémarre sans cesse

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

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

# Causes courantes :
# - Adresse de portefeuille invalide
# - Échec de la connexion au pool
# - Erreur de syntaxe dans le fichier de configuration
```

***

## Remarques juridiques et éthiques

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

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

***

## Référence rapide

### Options de 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 aux développeurs |

### Référence des algorithmes

| Algorithme | Coin            | Matériel recommandé |
| ---------- | --------------- | ------------------- |
| rx/0       | Monero (XMR)    | CPU (RandomX)       |
| kawpow     | Ravencoin (RVN) | GPU                 |
| autolykos2 | Ergo (ERG)      | GPU                 |
| octopus    | Conflux (CFX)   | GPU                 |
| etchash    | ETC             | GPU                 |

***

## Liens utiles

* [GitHub d’XMRig](https://github.com/xmrig/xmrig)
* [Documentation d’XMRig](https://xmrig.com/docs)
* [Calculateur WhatToMine](https://whattomine.com)
* [Pool MoneroOcean](https://moneroocean.stream)
* [Pool SupportXMR](https://supportxmr.com)
* [Marketplace Clore.ai](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 d’XMRig                                 |
| 6     | Configurez config.json avec le portefeuille et le pool             |
| 7     | Activez les huge pages pour un gain de hashrate de 20 à 50 %       |
| 8     | Démarrez le minage et surveillez-le 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 quand les prix sont élevés et les coûts de location sont faibles. 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 (10 Go) | $0.05–0.19/gpu/hr        |
| Minage optimal           | RTX 3090 (24 Go) | 0,07–0,21 $/gpu/h        |
| Minage haute performance | RTX 4090 (24 Go) | 0,14–0,42 $/gpu/h        |

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


---

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