Minage XMRig

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

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.

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.

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

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.

Calculatrices de rentabilité

minerstat.com/calc — multi-algorithme
whattomine.com — complet
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

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 !

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

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

Aller à clore.ai → Place de marché
Filtrer par Cœurs CPU: 32+ cœurs préférés
Recherchez des serveurs avec un grand nombre de threads CPU
Port 22 est suffisant
Commandez le serveur

Pour le minage GPU (KawPow, Octopus)

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

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.

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

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

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`

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

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 :

# 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

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.

Étape 5 : Surveiller le minage

Vérifier l'état du conteneur

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

Pool XMRig

pool.xmrig.com:443

0.01 XMR

MineXMR

pool.minexmr.com:4444

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

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.

MoneroOcean : basculement automatique pour le profit

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 VOTRE_PORTEFEUILLE_MONERO \
  -p "VOTRE_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 = 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)

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

Protéger le point de terminaison 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="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

# 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

# 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

# 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

# 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

Considérations importantes :

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

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

Résumé

Étape

Action

Calculez la rentabilité EN PREMIER

Créez un portefeuille Monero sur getmonero.org

Inscrivez-vous à un pool de minage

Louez un serveur (cœurs CPU pour XMR, GPU pour les autres)

Construisez l'image Docker XMRig

Configurez config.json avec le portefeuille et le pool

Activez les pages énormes pour un gain de hashrate de 20 à 50 %

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

PrécédentPrésentation SuivantPrésentation

Mis à jour il y a 1 jour

Ce contenu vous a-t-il été utile ?

hashtagQu'est-ce que XMRig ?

hashtagPourquoi Clore.ai pour XMRig ?

hashtagVérifiez la rentabilité d'abord

hashtagCalculatrices de rentabilité

hashtagCalcul rapide

hashtagPrérequis

hashtagCréer un portefeuille Monero

hashtagÉtape 1 : Louer un serveur

hashtagPour le minage CPU (Monero/RandomX)

hashtagPour le minage GPU (KawPow, Octopus)

hashtagÉtape 2 : Déployer XMRig via Docker

hashtagDockerfile personnalisé

hashtagConstruire l'image

hashtagExécuter le minage CPU (Monero)

hashtagExécuter le minage GPU (KawPow - Ravencoin)

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

hashtagCréer config.json

hashtagExécuter avec le fichier de config

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

hashtagÉtape 5 : Surveiller le minage

hashtagVérifier l'état du conteneur

hashtagExemple de sortie de log

hashtagPrincipales métriques à surveiller

hashtagTableau de bord du pool

hashtagPools de minage populaires

hashtagPools Monero (XMR)

hashtagPièces exploitables par GPU

hashtagMoneroOcean : basculement automatique pour le profit

hashtagConseils d'optimisation

hashtagOptimisation CPU

hashtagOptimisation GPU (CUDA)

hashtagMinage double (CPU + GPU)

hashtagConsidérations de sécurité

hashtagProtéger le point de terminaison API

hashtagScript automatisé de surveillance de la rentabilité

hashtagDépannage

hashtagFaible hashrate

hashtagProblèmes de connexion

hashtagErreurs CUDA

hashtagLe conteneur redémarre en boucle

hashtagNotes légales et éthiques

hashtagRéférence rapide

hashtagOptions en ligne de commande

hashtagRéférence des algorithmes

hashtagLiens utiles

hashtagRésumé

hashtagRecommandations GPU Clore.ai

Qu'est-ce que XMRig ?

Pourquoi Clore.ai pour XMRig ?

Vérifiez la rentabilité d'abord

Calculatrices de rentabilité

Calcul rapide

Prérequis

Créer un portefeuille Monero

Étape 1 : Louer un serveur

Pour le minage CPU (Monero/RandomX)

Pour le minage GPU (KawPow, Octopus)

Étape 2 : Déployer XMRig via Docker

Dockerfile personnalisé

Construire l'image

Exécuter le minage CPU (Monero)

Exécuter le minage GPU (KawPow - Ravencoin)

Étape 3 : Méthode du fichier de configuration

Créer `config.json`

Exécuter avec le fichier de config

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

Étape 5 : Surveiller le minage

Vérifier l'état du conteneur

Exemple de sortie de log

Principales métriques à surveiller

Tableau de bord du pool

Pools de minage populaires

Pools Monero (XMR)

Pièces exploitables par GPU

MoneroOcean : basculement automatique pour le profit

Conseils d'optimisation

Optimisation CPU

Optimisation GPU (CUDA)

Minage double (CPU + GPU)

Considérations de sécurité

Protéger le point de terminaison API

Script automatisé de surveillance de la rentabilité

Dépannage

Faible hashrate

Problèmes de connexion

Erreurs CUDA

Le conteneur redémarre en boucle

Notes légales et éthiques

Référence rapide

Options en ligne de commande

Référence des algorithmes

Liens utiles

Résumé

Recommandations GPU Clore.ai