> 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-de/krypto-and-mining/xmrig.md).

# XMRig-Mining

Monero (XMR) und andere Kryptowährungen mit XMRig auf Clore.ais GPU- und CPU-Servern minen.

{% hint style="info" %}
**XMRig** ist der am weitesten verbreitete Open-Source-Kryptowährungs-Miner. Er unterstützt CPU-Mining (RandomX-Algorithmus für Monero) und GPU-Mining (KawPow, Ethash und andere). Diese Anleitung behandelt die Bereitstellung auf Clore.ai-Servern.
{% endhint %}

{% hint style="warning" %}
**Bevor Sie beginnen**: Berechnen Sie stets die Rentabilität vor dem Mining. Berücksichtigen Sie Clore.ai-Mietkosten, Pool-Gebühren und aktuelle Coin-Preise. Verwenden Sie einen Mining-Rentabilitätsrechner, um sicherzustellen, dass Sie positive Renditen erzielen.
{% endhint %}

***

## Was ist XMRig?

XMRig ist ein leistungsstarker, plattformübergreifender Miner für CPU und GPU:

| Funktion              | Details                                             |
| --------------------- | --------------------------------------------------- |
| **CPU-Mining**        | Monero (XMR) über RandomX — BESTER Anwendungsfall   |
| **GPU-Mining**        | KawPow (RVN), Ethash-Varianten, Octopus             |
| **Algorithmen**       | RandomX, KawPow, Ethash, Autolykos2, Octopus + mehr |
| **Stratum V2**        | Unterstützung moderner Pool-Protokolle              |
| **TLS-Unterstützung** | Verschlüsselte Pool-Verbindungen                    |
| **Lizenz**            | GPL 3.0, Open Source                                |

### Warum Clore.ai für XMRig?

* **CPUs mit hoher Kernanzahl**: Clore.ai-Server haben häufig 32–128 CPU-Kerne — ideal für RandomX
* **Spot-Preise**: Günstig während Nebenzeiten mieten
* **Keine Hardware-Investition**: Minen ohne Kauf und Wartung von Hardware
* **Flexibilität**: Wechseln Sie Algorithmen oder Coins basierend auf der Rentabilität

***

## Zuerst Rentabilität prüfen

{% hint style="danger" %}
**Tun Sie dies, bevor Sie einen Cent für Mietkosten ausgeben!**

Die Rentabilität beim Mining ändert sich täglich. Überprüfen Sie immer vor dem Start.
{% endhint %}

### Rentabilitätsrechner

* [minerstat.com/calc](https://minerstat.com/calc) — Multi-Algorithmus
* [whattomine.com](https://whattomine.com) — umfassend
* [xmrig.com/docs/algorithms](https://xmrig.com/docs/algorithms) — Referenz für Hashrate

### Schnelle Rechnung

```
Täglicher Gewinn = (Tägliche Belohnung in USD) - (Tägliche Mietkosten)

Beispiel (Monero, 32-Kern-Server):
- Hashrate: ~32.000 H/s (1.000 H/s pro Kern)
- Tägliche XMR-Belohnung: ~0,001–0,003 XMR/Tag
- XMR-Preis (Beispiel): $160
- Täglicher Umsatz: $0,16–0,48
- Servermiete (32-Kern, ~ $0,20/Std.): $4,80/Tag

Ergebnis: NEGATIV. Server mit hoher Kernanzahl sind beim Solo-Mining oft nicht rentabel.

Besserer Ansatz: Finden Sie günstige Server mit hoher Kernanzahl, bei denen die Miete < tägliche Belohnung ist
```

{% hint style="success" %}
**Wann es Sinn macht**: Wenn Sie einen Server mit 64+ Kernen zu $0,05–0,10/Std. finden oder GPU-Server zu niedrigen Spot-Preisen für GPU-minierbare Coins. Immer zuerst rechnen!
{% endhint %}

***

## Voraussetzungen

| Anforderung       | Details                                            |
| ----------------- | -------------------------------------------------- |
| Clore.ai-Konto    | Mit CLORE-Guthaben                                 |
| Mining-Pool-Konto | Erstellen bei supportXMR.com, MoneroOcean usw.     |
| Monero-Wallet     | Herunterladen unter getmonero.org (für XMR-Mining) |
| SSH-Zugriff       | Port 22                                            |

### Erstellen Sie eine Monero-Wallet

```bash
# Option 1: CLI-Wallet
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: GUI-Wallet (lokale Maschine)
# Herunterladen von: https://www.getmonero.org/downloads/
```

Speichern Sie Ihre Wallet-Adresse — sie sieht aus wie:

```
43xxxx...lange Zeichenfolge...xxxx
```

***

## Schritt 1: Server mieten

### Für CPU-Mining (Monero/RandomX)

1. Gehe zu [clore.ai](https://clore.ai) → **Marktplatz**
2. Filtern nach **CPU-Kerne**: 32+ Kerne bevorzugt
3. Suchen Sie nach Servern mit hoher Anzahl an CPU-Threads
4. Port **22** ist ausreichend
5. Bestellen Sie den Server

### Für GPU-Mining (KawPow, Octopus)

1. Filtern nach **GPU**: RTX 3080+, RTX 4090 für beste Leistung
2. Benötigte Ports: **22** nur
3. Nur NVIDIA-GPUs für CUDA-Mining

{% hint style="info" %}
**CPU vs GPU auf Clore.ai**: Clore.ai ist hauptsächlich ein GPU-Marktplatz. Für Monero (RandomX) können dedizierte CPU-Server günstiger sein. Für GPU-minierbare Coins bieten NVIDIA-Server bessere Leistung.
{% endhint %}

***

## Schritt 2: XMRig über Docker bereitstellen

### Benutzerdefiniertes Dockerfile

Erstellen Sie eine `Dockerfile` auf dem Server:

```dockerfile
FROM ubuntu:22.04

ENV DEBIAN_FRONTEND=noninteractive

# Installiere Abhängigkeiten
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-Release herunterladen
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-*/

# Konfigurationsverzeichnis erstellen
RUN mkdir -p /etc/xmrig

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

### Image bauen

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

### CPU-Mining ausführen (Monero)

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

### GPU-Mining ausführen (KawPow - Ravencoin)

```bash
docker run -d \
  --name xmrig-gpu \
  --restart unless-stopped \
  --gpus all \
  xmrig-miner \
  -a kawpow \
  -o rvn.2miners.com:6060 \
  -u IHRE_RVN_WALLET.worker1 \
  --log-file=/var/log/xmrig.log
```

***

## Schritt 3: Konfigurationsdatei-Methode

Die Verwendung einer Konfigurationsdatei ist sauberer als Kommandozeilen-Flags.

### Erstellen `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": "IHRE_MONERO_WALLET_ADRESSE",
            "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
}
```

Ersetzen Sie `IHRE_MONERO_WALLET_ADRESSE` durch Ihre tatsächliche Wallet-Adresse.

### Mit Konfigurationsdatei ausführen

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

***

## Schritt 4: Huge Pages aktivieren (Performance-Boost)

RandomX profitiert erheblich von 1GB Huge Pages. Auf dem Host aktivieren:

```bash
# Huge Pages aktivieren (als root auf dem Clore.ai-Server ausführen)
echo 1 > /proc/sys/vm/nr_hugepages

# Für 1GB Huge Pages (falls vom CPU unterstützt)
mkdir -p /mnt/hugepages-1g
mount -t hugetlbfs -o pagesize=1G none /mnt/hugepages-1g
echo 4 > /proc/sys/vm/nr_hugepages

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

{% hint style="info" %}
**Leistungsimpact**: Huge Pages können die Monero-Hashrate bei einigen CPUs um 20–50 % erhöhen. Es lohnt sich, sie zu aktivieren, wenn Sie Zugriff auf das Host-System haben.
{% endhint %}

***

## Schritt 5: Mining überwachen

### Container-Status prüfen

```bash
# Echtzeit-Logs anzeigen
docker logs xmrig -f

# Statistiken über die API prüfen
curl http://localhost:9090/2/summary | python3 -m json.tool
```

### Beispiel-Log-Ausgabe

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

### Wichtige Kennzahlen zum Überwachen

| Metrik             | Was es bedeutet                           |
| ------------------ | ----------------------------------------- |
| H/s (Hashrate)     | Mining-Geschwindigkeit — höher ist besser |
| Akzeptierte Shares | Gültige Arbeit an den Pool gesendet       |
| Abgelehnte Shares  | Ungültige Arbeit — sollte nahe 0 liegen   |
| Latenz             | Pool-Verbindungsgeschwindigkeit           |

### Pool-Dashboard

Prüfen Sie Ihren Fortschritt auf der Website Ihres Pools:

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

***

## Beliebte Mining-Pools

### Monero (XMR) Pools

| Pool        | URL                         | Gebühr | Min. Auszahlung |
| ----------- | --------------------------- | ------ | --------------- |
| 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       |

### GPU-minierbare Coins

| Coin                   | Algorithmus | Pool-Beispiel        |
| ---------------------- | ----------- | -------------------- |
| 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 ist speziell**: Es wechselt Ihren Miner automatisch zum jeweils profitabelsten Algorithmus, zahlt aber weiterhin in XMR. Großartig zur Maximierung der Rendite.
{% endhint %}

***

## MoneroOcean: Automatisches Profit-Switching

MoneroOcean minet automatisch den profitabelsten Algorithmus:

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

***

## Optimierungstipps

### CPU-Optimierung

```bash
# Verwenden Sie alle CPU-Threads
--cpu-max-threads-hint=100

# Setzen Sie die CPU-Priorität (0=niedrigst, 5=höchst)
--cpu-priority=3

# Yield deaktivieren (CPU nicht mit anderen Prozessen teilen)
--no-yield

# AVX2 für schnelleres RandomX aktivieren
# (automatisch, wenn CPU es unterstützt)
```

### GPU-Optimierung (CUDA)

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

### Dual Mining (CPU + GPU)

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

***

## Sicherheitsüberlegungen

{% hint style="warning" %}
**Sicherheits-Checkliste fürs Mining:**

* Führen Sie Miner nach Möglichkeit niemals als root aus
* Setzen Sie den XMRig-API-Port (9090) nicht öffentlich aus
* Verwenden Sie TLS-Verbindungen zu Pools (`--tls` Flag)
* Halten Sie XMRig aktuell, um Sicherheitslücken zu schließen
* Überwachen Sie ungewöhnliche CPU-/GPU-Auslastungsspitzen
  {% endhint %}

### API-Endpunkt schützen

```json
"api": {
    "port": 9090,
    "access-token": "ihr-geheimer-token-hier",
    "restricted": true
}
```

```bash
# Zugriff mit Token
curl -H "Authorization: Bearer ihr-geheimer-token-hier" \
     http://localhost:9090/2/summary
```

***

## Automatisiertes Profit-Überwachungs-Skript

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

WALLET="IHRE_WALLET_ADRESSE"
RENTAL_COST_PER_HOUR=0.50  # Ihre Clore.ai-Kosten in USD

while true; do
  # Aktuelle Hashrate abrufen
  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): Stündliche Kosten: \$${RENTAL_COST_PER_HOUR}"
  
  # Akzeptierte Shares prüfen
  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): Akzeptierte Shares: ${ACCEPTED}"
  
  sleep 300  # Alle 5 Minuten prüfen
done
```

***

## Fehlerbehebung

### Geringe Hashrate

```bash
# CPU-Zuweisung im Container prüfen
docker exec xmrig cat /proc/cpuinfo | grep processor | wc -l

# Sicherstellen, dass Huge Pages aktiviert sind
cat /proc/sys/vm/nr_hugepages

# Auf thermisches Throttling prüfen
watch -n1 "sensors 2>/dev/null | grep temp || cat /sys/class/thermal/thermal_zone*/temp"
```

### Verbindungsprobleme

```bash
# Pool-Konnektivität testen
curl -k telnet://pool.supportxmr.com:443

# Alternativen Pool verwenden, wenn blockiert
# Versuch: xmr.pool.minergate.com:443
```

### CUDA-Fehler

```bash
# GPU-Zugriff im Container überprüfen
docker exec xmrig-gpu nvidia-smi

# Falls fehlt, --gpus all zum docker run hinzufügen
docker stop xmrig-gpu
docker rm xmrig-gpu
# Erneut mit --gpus all ausführen
```

### Container startet ständig neu

```bash
# Exit-Code prüfen
docker inspect xmrig --format='{{.State.ExitCode}}'

# Detaillierte Logs anzeigen
docker logs xmrig --since 5m

# Häufige Ursachen:
# - Ungültige Wallet-Adresse
# - Pool-Verbindung fehlgeschlagen
# - Syntaxfehler in der Konfigurationsdatei
```

***

## Rechtliche und ethische Hinweise

{% hint style="info" %}
**Wichtige Überlegungen:**

1. **Clore.ai ToS prüfen**: Stellen Sie sicher, dass Mining auf Ihren gemieteten Servern erlaubt ist
2. **Steuerkonformität**: Geminte Kryptowährung kann in Ihrer Jurisdiktion steuerpflichtiges Einkommen sein
3. **Rentabilität**: Cloud-Mining ist häufig unrentabel — rechnen Sie zuerst
4. **Netzwerkeffekt**: Mining trägt zur Sicherheit der Blockchain bei (positive Wirkung)
   {% endhint %}

***

## Kurze Referenz

### Kommandozeilen-Flags

| Flag                       | Beschreibung                     |
| -------------------------- | -------------------------------- |
| `-o URL`                   | Pool-Adresse                     |
| `-u ADRESSE`               | Wallet-Adresse                   |
| `-p WORKER`                | Worker-Name                      |
| `-a ALGO`                  | Algorithmus (rx/0 für Monero)    |
| `--tls`                    | TLS-Verschlüsselung aktivieren   |
| `-k`                       | Keepalive-Verbindung             |
| `--cpu-max-threads-hint=N` | Verwenden Sie N% der CPU-Threads |
| `--donate-level=0`         | Dev-Spende deaktivieren          |

### Algorithmus-Referenz

| Algorithmus | Coin            | Beste Hardware |
| ----------- | --------------- | -------------- |
| rx/0        | Monero (XMR)    | CPU (RandomX)  |
| kawpow      | Ravencoin (RVN) | GPU            |
| autolykos2  | Ergo (ERG)      | GPU            |
| Oktopus     | Conflux (CFX)   | GPU            |
| etchash     | ETC             | GPU            |

***

## Nützliche Links

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

***

## Zusammenfassung

| Schritt | Aktion                                                |
| ------- | ----------------------------------------------------- |
| 1       | Zuerst die Rentabilität berechnen                     |
| 2       | Monero-Wallet bei getmonero.org erstellen             |
| 3       | Bei einem Mining-Pool registrieren                    |
| 4       | Server mieten (CPU-Kerne für XMR, GPU für andere)     |
| 5       | XMRig Docker-Image bauen                              |
| 6       | config.json mit Wallet und Pool konfigurieren         |
| 7       | Huge Pages aktivieren für 20–50% mehr Hashrate        |
| 8       | Mining starten und über das Pool-Dashboard überwachen |

XMRig auf Clore.ai gibt Ihnen Zugriff auf leistungsstarke Mining-Hardware auf Abruf. Nutzen Sie es strategisch – minen Sie, wenn die Preise hoch und die Mietkosten niedrig sind. Rechnen Sie immer zuerst nach. ⛏️

***

## Clore.ai GPU-Empfehlungen

| Anwendungsfall        | Empfohlene GPU  | Geschätzte Kosten auf Clore.ai |
| --------------------- | --------------- | ------------------------------ |
| Mining für Einsteiger | RTX 3080 (10GB) | \~0,08 $/GPU/Stunde            |
| Optimales Mining      | RTX 3090 (24GB) | \~$0.12/gpu/hr                 |
| Hochleistungs-Mining  | RTX 4090 (24GB) | \~$0.70/gpu/hr                 |

> 💡 Alle Beispiele in diesem Leitfaden können bereitgestellt werden auf [Clore.ai](https://clore.ai/marketplace) GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.


---

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

```
GET https://docs.clore.ai/guides/guides_v2-de/krypto-and-mining/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.