# XMRig माइनिंग

Clore.ai के GPU और CPU सर्वरों पर XMRig का उपयोग करके Monero (XMR) और अन्य क्रिप्टोकरेंसी खोदें।

{% hint style="info" %}
**GPU-त्वरित रिमोट गेमिंग** XMRig सबसे व्यापक रूप से उपयोग किया जाने वाला ओपन-सोर्स क्रिप्टोकरेंसी माइनर है। यह CPU माइनिंग (Monero के लिए RandomX एल्गोरिथ्म) और GPU माइनिंग (KawPow, Ethash और अन्य) का समर्थन करता है। यह गाइड Clore.ai सर्वरों पर तैनाती को कवर करता है।
{% endhint %}

{% hint style="warning" %}
**शुरू करने से पहले**:Mining शुरू करने से पहले हमेशा लाभप्रदता की गणना करें। Clore.ai किराये की लागत, पूल फीस, और वर्तमान कॉइन कीमतों को ध्यान में रखें। सकारात्मक रिटर्न सुनिश्चित करने के लिए किसी माइनिंग लाभप्रदता कैलकुलेटर का उपयोग करें।
{% endhint %}

***

## XMRig क्या है?

XMRig CPU और GPU के लिए एक उच्च-प्रदर्शन, क्रॉस-प्लेटफॉर्म माइनर है:

| फ़ीचर           | विवरण                                                       |
| --------------- | ----------------------------------------------------------- |
| **CPU माइनिंग** | RandomX के माध्यम से Monero (XMR) — सर्वश्रेष्ठ उपयोग मामला |
| **GPU माइनिंग** | KawPow (RVN), Ethash वैरिएंट्स, Octopus                     |
| **एल्गोरिथ्म**  | RandomX, KawPow, Ethash, Autolykos2, Octopus + और अधिक      |
| **Stratum V2**  | आधुनिक पूल प्रोटोकॉल समर्थन                                 |
| **TLS समर्थन**  | एन्क्रिप्टेड पूल कनेक्शन                                    |
| **लाइसेंस**     | GPL 3.0, खुला स्रोत                                         |

### XMRig के लिए Clore.ai क्यों?

* **उच्च-कोर-काउंट CPU**: Clore.ai सर्वरों में अक्सर 32-128 CPU कोर होते हैं — RandomX के लिए आदर्श
* **स्पॉट प्राइसिंग**: ऑफ-पीक घंटों में सस्ता किराया लें
* **कोई हार्डवेयर निवेश नहीं**: हार्डवेयर खरीदे बिना और मेंटेन किए बिना माइन करें
* **लचीलापन**: लाभप्रदता के आधार पर एल्गोरिथ्म या कॉइन बदलें

***

## पहले लाभप्रदता जाँचें

{% hint style="danger" %}
**किराये पर खर्च करने से पहले यह करें!**

माइनिंग की लाभप्रदता दैनिक बदलती रहती है। शुरू करने से पहले हमेशा सत्यापित करें।
{% endhint %}

### लाभप्रदता कैलकुलेटर

* [minerstat.com/calc](https://minerstat.com/calc) — बहु-एल्गोरिथ्म
* [whattomine.com](https://whattomine.com) — व्यापक
* [xmrig.com/docs/algorithms](https://xmrig.com/docs/algorithms) — हैशरेट संदर्भ

### त्वरित गणित

```
दैनिक लाभ = (दैनिक पुरस्कार USD में) - (दैनिक किराये की लागत)

उदाहरण (Monero, 32-कोर सर्वर):
- हैशरेट: ~32,000 H/s (प्रति कोर ~1,000 H/s)
- दैनिक XMR पुरस्कार: ~0.001-0.003 XMR/दिन
- XMR कीमत (उदाहरण): $160
- दैनिक राजस्व: $0.16-0.48
- सर्वर किराया (32-कोर, ~$0.20/घंटा): $4.80/दिन

परिणाम: नकारात्मक। उच्च-कोर सर्वर अक्सर सोलो माइनिंग के लिए लाभकारी नहीं होते।

बेहतर तरीका: सस्ता उच्च-कोर-संख्या सर्वर खोजें जहाँ किराया < दैनिक पुरस्कार हो
```

{% hint style="success" %}
**जब यह तर्कसंगत होता है**: जब आप $0.05-0.10/घंटा पर 64+ कोर वाला सर्वर पाते हैं, या GPU-माइन करने योग्य कॉइन्स के लिए GPU सर्वर कम स्पॉट कीमतों पर मिलते हैं। हमेशा पहले गणना करें!
{% endhint %}

***

## पूर्व-आवश्यकताएँ

| आवश्यकता         | विवरण                                            |
| ---------------- | ------------------------------------------------ |
| Clore.ai खाता    | CLORE बैलेंस के साथ                              |
| माइनिंग पूल खाता | supportXMR.com, MoneroOcean, आदि पर बनाएं।       |
| Monero वॉलेट     | डाउनलोड करें: getmonero.org (XMR माइनिंग के लिए) |
| SSH पहुंच        | पोर्ट 22                                         |

### Monero वॉलेट बनाएं

```bash
# विकल्प 1: 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

# विकल्प 2: GUI वॉलेट (लोकल मशीन)
# डाउनलोड करें: https://www.getmonero.org/downloads/
```

अपने वॉलेट एड्रेस को सुरक्षित रखें — यह इस तरह दिखता है:

```
43xxxx...लंबा स्ट्रिंग...xxxx
```

***

## चरण 1: सर्वर किराये पर लें

### CPU माइनिंग के लिए (Monero/RandomX)

1. जाएँ [clore.ai](https://clore.ai) → **मार्केटप्लेस**
2. फ़िल्टर करें **CPU कोर**: 32+ कोर प्राथमिकता
3. ऊंचे CPU थ्रेड काउंट वाले सर्वर देखें
4. पोर्ट **22** पर्याप्त है
5. सर्वर ऑर्डर करें

### GPU माइनिंग के लिए (KawPow, Octopus)

1. फ़िल्टर करें **GPU**: सर्वश्रेष्ठ प्रदर्शन के लिए RTX 3080+, RTX 4090
2. आवश्यक पोर्ट: **22** केवल
3. CUDA माइनिंग के लिए केवल NVIDIA GPU

{% hint style="info" %}
**Clore.ai पर CPU बनाम GPU**: Clore.ai मुख्य रूप से एक GPU मार्केटप्लेस है। Monero (RandomX) के लिए समर्पित CPU सर्वर अक्सर सस्ता हो सकते हैं। GPU-माइन योग्य कॉइन्स के लिए NVIDIA सर्वर बेहतर प्रदर्शन देते हैं।
{% endhint %}

***

## चरण 2: Docker के माध्यम से XMRig तैनात करें

### कस्टम Dockerfile

एक बनाएं `Dockerfile` सर्वर पर:

```dockerfile
FROM ubuntu:22.04

ENV DEBIAN_FRONTEND=noninteractive

# निर्भरता इंस्टॉल करें
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

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

# कॉन्फ़िग डायरेक्टरी बनाएं
RUN mkdir -p /etc/xmrig

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

### इमेज बनाएं

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

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

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

***

## चरण 3: कॉन्फ़िगरेशन फ़ाइल विधि

कमान्ड-लाइन फ्लैग्स की तुलना में कॉन्फ़िग फ़ाइल अधिक साफ़-सुथरी होती है।

### बनाएँ `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
}
```

बदलिए `YOUR_MONERO_WALLET_ADDRESS` अपने वास्तविक वॉलेट पते से बदलें।

### कॉन्फ़िग फ़ाइल के साथ चलाएँ

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

***

## चरण 4: Huge Pages सक्षम करें (प्रदर्शन बूस्ट)

RandomX को 1GB huge pages से काफी लाभ मिलता है। होस्ट पर सक्षम करें:

```bash
# Huge pages सक्षम करें (Clore.ai सर्वर पर root के रूप में चलाएँ)
echo 1 > /proc/sys/vm/nr_hugepages

# 1GB huge pages के लिए (यदि CPU द्वारा समर्थित हो)
mkdir -p /mnt/hugepages-1g
mount -t hugetlbfs -o pagesize=1G none /mnt/hugepages-1g
echo 4 > /proc/sys/vm/nr_hugepages

# स्थायी बनाएं
echo "vm.nr_hugepages = 128" >> /etc/sysctl.conf
sysctl -p
```

{% hint style="info" %}
**प्रदर्शन प्रभाव**: कुछ CPUs पर Huge pages Monero हैशरेट को 20-50% तक बढ़ा सकते हैं। यदि आपको होस्ट सिस्टम तक पहुंच है तो सक्षम करना लाभकारी है।
{% endhint %}

***

## चरण 5: माइनिंग की निगरानी करें

### कंटेनर स्थिति जांचें

```bash
# वास्तविक समय लॉग देखें
docker logs xmrig -f

# API के माध्यम से आँकड़े जांचें
curl http://localhost:9090/2/summary | python3 -m json.tool
```

### नमूना लॉग आउटपुट

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

### देखने के लिए प्रमुख मीट्रिक्स

| मीट्रिक       | इसका क्या अर्थ है                          |
| ------------- | ------------------------------------------ |
| H/s (हैशरेट)  | माइनिंग की गति — अधिक बेहतर है             |
| स्वीकृत शेयर  | पूले को जमा किया गया मान्य कार्य           |
| अस्वीकृत शेयर | अमान्य कार्य — यह लगभग 0 के पास होना चाहिए |
| लेटेंसी       | पूल कनेक्शन की गति                         |

### पूल डैशबोर्ड

अपने पूल की वेबसाइट पर अपनी प्रगति जांचें:

* **SupportXMR**: `https://supportxmr.com/#/dashboard?wallet=YOUR_ADDRESS`
* **MoneroOcean**: `https://moneroocean.stream/#/dashboard?wallet=YOUR_ADDRESS`
* **2Miners**: `https://xmr.2miners.com/account/YOUR_ADDRESS`

***

## लोकप्रिय माइनिंग पूल

### Monero (XMR) पूल

| पूल         | URL                         | शुल्क | न्यूनतम भुगतान |
| ----------- | --------------------------- | ----- | -------------- |
| SupportXMR  | pool.supportxmr.com:443     | 0.6%  | 0.1 XMR        |
| MoneroOcean | gulf.moneroocean.stream:443 | 0%    | 0.003 XMR      |
| XMRig पूल   | pool.xmrig.com:443          | 1%    | 0.01 XMR       |
| MineXMR     | pool.minexmr.com:4444       | 1%    | 0.004 XMR      |

### GPU-माइन योग्य कॉइन्स

| कॉइन                   | एल्गोरिथ्म | पूर्ला उदाहरण        |
| ---------------------- | ---------- | -------------------- |
| 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 खास है**: यह स्वचालित रूप से आपके माइनर को किसी भी समय सबसे अधिक लाभदायक एल्गोरिथ्म पर स्विच कर देता है, फिर भी भुगतान XMR में करता है। रिटर्न अधिकतम करने के लिए अच्छा है।
{% endhint %}

***

## MoneroOcean: ऑटो-प्रॉफिट स्विचिंग

MoneroOcean स्वचालित रूप से सबसे अधिक लाभदायक एल्गोरिथ्म माइन करता है:

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

***

## अनुकूलन टिप्स

### CPU अनुकूलन

```bash
# सभी CPU थ्रेड्स का उपयोग करें
--cpu-max-threads-hint=100

# CPU प्राथमिकता सेट करें (0=सबसे निम्न, 5=सबसे उच्च)
--cpu-priority=3

# Yield अक्षम करें (अन्य प्रक्रियाओं के साथ CPU साझा न करें)
--no-yield

# तेज़ RandomX के लिए AVX2 सक्षम करें
# (यदि CPU समर्थित है तो स्वचालित)
```

### GPU अनुकूलन (CUDA)

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

### ड्यूल माइनिंग (CPU + GPU)

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

***

## सुरक्षा विचार

{% hint style="warning" %}
**माइनिंग सुरक्षा जाँच सूची:**

* संभावित होने पर कभी भी माइनर्स को root के रूप में न चलाएँ
* XMRig API पोर्ट (9090) को सार्वजनिक रूप से उजागर न करें
* पूल्स के साथ TLS कनेक्शन का उपयोग करें (`--tls` फ्लैग)
* कमजोरियों को ठीक करने के लिए XMRig को अपडेट रखें
* असामान्य CPU/GPU उपयोग स्पाइक्स के लिए निगरानी करें
  {% endhint %}

### API एंडपॉइंट की सुरक्षा करें

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

```bash
# टोकन के साथ पहुँच
curl -H "Authorization: Bearer your-secret-token-here" \
     http://localhost:9090/2/summary
```

***

## स्वचालित प्रॉफिट मॉनिटरिंग स्क्रिप्ट

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

WALLET="YOUR_WALLET_ADDRESS"
RENTAL_COST_PER_HOUR=0.50  # आपका Clore.ai लागत USD में

while true; do
  # वर्तमान हैशरेट प्राप्त करें
  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): Hourly cost: \$${RENTAL_COST_PER_HOUR}"
  
  # स्वीकृत शेयर जाँचें
  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): Accepted shares: ${ACCEPTED}"
  
  sleep 300  # हर 5 मिनट पर जाँच करें
done
```

***

## समस्या निवारण

### कम हैशरेट

```bash
# कंटेनर में CPU आवंटन जाँचें
docker exec xmrig cat /proc/cpuinfo | grep processor | wc -l

# सुनिश्चित करें कि huge pages सक्षम हैं
cat /proc/sys/vm/nr_hugepages

# थर्मल थ्रॉटलिंग के लिए जाँच करें
watch -n1 "sensors 2>/dev/null | grep temp || cat /sys/class/thermal/thermal_zone*/temp"
```

### कनेक्शन समस्याएँ

```bash
# पूल कनेक्टिविटी का परीक्षण करें
curl -k telnet://pool.supportxmr.com:443

# अगर ब्लॉक है तो वैकल्पिक पूल उपयोग करें
# प्रयास करें: xmr.pool.minergate.com:443
```

### CUDA त्रुटियाँ

```bash
# कंटेनर में GPU पहुँच सत्यापित करें
docker exec xmrig-gpu nvidia-smi

# यदि गायब है, तो docker run में --gpus all जोड़ें
docker stop xmrig-gpu
docker rm xmrig-gpu
# --gpus all के साथ फिर से चलाएँ
```

### कंटेनर बार-बार रिस्टार्ट हो रहा है

```bash
# exit कोड जांचें
docker inspect xmrig --format='{{.State.ExitCode}}'

# विस्तृत लॉग देखें
docker logs xmrig --since 5m

# सामान्य कारण:
# - अमान्य वॉलेट पता
# - पूल कनेक्शन विफल
# - कॉन्फ़िग फ़ाइल सिंटैक्स त्रुटि
```

***

## कानूनी और नैतिक नोट्स

{% hint style="info" %}
**महत्वपूर्ण विचार:**

1. **Clore.ai ToS जांचें**: सुनिश्चित करें कि आपके किराए पर लिए गए सर्वरों पर माइनिंग की अनुमति है
2. **कर अनुपालन**: खनन की गई क्रिप्टोकरेंसी आपके क्षेत्राधिकार में कर योग्य आय हो सकती है
3. **लाभप्रदता**: क्लाउड माइनिंग अक्सर लाभहीन होती है — पहले अपना गणित करें
4. **नेटवर्क प्रभाव**: माइनिंग ब्लॉकचेन सुरक्षा में योगदान देती है (सकारात्मक योगदान)
   {% endhint %}

***

## त्वरित संदर्भ

### कमान्ड-लाइन फ्लैग्स

| फ्लैग                      | विवरण                           |
| -------------------------- | ------------------------------- |
| `-o URL`                   | पूल पता                         |
| `-u ADDRESS`               | वॉलेट पता                       |
| `-p WORKER`                | वर्कर नाम                       |
| `-a ALGO`                  | एल्गोरिथ्म (Monero के लिए rx/0) |
| `--tls`                    | TLS एन्क्रिप्शन सक्षम करें      |
| `-k`                       | कनेक्शन को जीवित रखें           |
| `--cpu-max-threads-hint=N` | CPU थ्रेड्स का N% उपयोग करें    |
| `--donate-level=0`         | डेव डोनेशन अक्षम करें           |

### एल्गोरिथ्म संदर्भ

| एल्गोरिथ्म | कॉइन            | सर्वश्रेष्ठ हार्डवेयर |
| ---------- | --------------- | --------------------- |
| rx/0       | Monero (XMR)    | CPU (RandomX)         |
| kawpow     | Ravencoin (RVN) | GPU                   |
| autolykos2 | Ergo (ERG)      | GPU                   |
| ऑक्टोपस    | Conflux (CFX)   | GPU                   |
| etchash    | ETC             | GPU                   |

***

## उपयोगी लिंक

* [XMRig GitHub](https://github.com/xmrig/xmrig)
* [XMRig दस्तावेज़](https://xmrig.com/docs)
* [WhatToMine कैलकुलेटर](https://whattomine.com)
* [MoneroOcean पूल](https://moneroocean.stream)
* [SupportXMR पूल](https://supportxmr.com)
* [Clore.ai मार्केटप्लेस](https://clore.ai)

***

## सारांश

| कदम | क्रिया                                                      |
| --- | ----------------------------------------------------------- |
| 1   | पहले लाभप्रदता की गणना करें                                 |
| 2   | getmonero.org पर Monero वॉलेट बनाएं                         |
| 3   | किसी माइनिंग पूल पर पंजीकरण करें                            |
| 4   | सर्वर किराए पर लें (XMR के लिए CPU कोर, अन्य के लिए GPU)    |
| 5   | XMRig Docker इमेज बनाएं                                     |
| 6   | वॉलेट और पूल के साथ config.json कॉन्फ़िगर करें              |
| 7   | 20-50% हैशरेट बढ़ोतरी के लिए ह्यूज पेज सक्षम करें           |
| 8   | माइनिंग शुरू करें और पूल डैशबोर्ड के माध्यम से निगरानी करें |

Clore.ai पर XMRig आपको मांग पर उच्च-प्रदर्शन माइनिंग हार्डवेयर तक पहुंच देता है। रणनीतिक रूप से इसका उपयोग करें — जब कीमतें अधिक हों और किराये की लागत कम हो तब माइन करें। हमेशा पहले गणना कर लें। ⛏️

***

## Clore.ai GPU सिफारिशें

| उपयोग केस             | सिफारिश की गई GPU | Clore.ai पर अनुमानित लागत |
| --------------------- | ----------------- | ------------------------- |
| प्रवेश-स्तरीय माइनिंग | RTX 3080 (10GB)   | \~$0.08/जीपीयू/घं         |
| उत्तम माइनिंग         | RTX 3090 (24GB)   | \~$0.12/gpu/hr            |
| उच्च-प्रदर्शन माइनिंग | RTX 4090 (24GB)   | \~$0.70/gpu/hr            |

> 💡 इस गाइड के सभी उदाहरण तैनात किए जा सकते हैं [Clore.ai](https://clore.ai/marketplace) GPU सर्वरों पर। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण रूट एक्सेस।