Minage XMRig

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

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.

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.

---

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

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.

Calculateurs de rentabilité

• minerstat.com/calc — multi-algorithme

• whattomine.com — complet

• 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

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 !

---

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

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

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.

---

Étape 2 : Déployer XMRig via Docker

Dockerfile personnalisé

Créez un Dockerfile sur le serveur :

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

docker build -t xmrig-miner .

Exécuter le minage CPU (Monero)

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)

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

{
    "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

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 :

# 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

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.

---

Étape 5 : Surveiller le minage

Vérifier l'état du conteneur

# 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

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.

---

MoneroOcean : basculement automatique vers la rentabilité

MoneroOcean mine automatiquement l'algorithme le plus rentable :

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

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

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

Minage double (CPU + GPU)

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

---

Considérations de sécurité

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

Protéger le point de terminaison de l’API

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

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

---

Script automatisé de surveillance de la rentabilité

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

# 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

# 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

# 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

# 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

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)

---

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

• Documentation d’XMRig

• Calculateur WhatToMine

• Pool MoneroOcean

• Pool SupportXMR

• Marketplace 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 des serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, accès root complet.