> 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

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

{% 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 immer die Rentabilität, bevor Sie mit dem Mining beginnen. Berücksichtigen Sie die Mietkosten von Clore.ai, Pool-Gebühren und aktuelle Coin-Preise. Nutzen Sie einen Mining-Rentabilitätsrechner, um sicherzustellen, dass Sie positive Erträge erzielen.
{% endhint %}

***

## Was ist XMRig?

XMRig ist ein hochperformanter, 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 für modernes Pool-Protokoll           |
| **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 oft 32–128 CPU-Kerne — ideal für RandomX
* **Spot-Preise**: Mieten Sie günstig außerhalb der Spitzenzeiten
* **Keine Hardware-Investition**: Schürfen Sie, ohne Hardware zu kaufen und zu warten
* **Flexibilität**: Wechseln Sie Algorithmen oder Coins je nach Rentabilität

***

## Rentabilität zuerst prüfen

{% hint style="danger" %}
**Tun Sie dies, bevor Sie auch nur einen Cent an Mietkosten ausgeben!**

Die Mining-Rentabilität ändert sich täglich. Immer vor dem Start überprüfen.
{% endhint %}

### Rentabilitätsrechner

* [minerstat.com/calc](https://minerstat.com/calc) — mehrere Algorithmen
* [whattomine.com](https://whattomine.com) — umfassend
* [xmrig.com/docs/algorithms](https://xmrig.com/docs/algorithms) — Hashrate-Referenz

### 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 Kerne, ca. 0,20 $/Std.): 4,80 $/Tag

Ergebnis: NEGATIV. Server mit vielen Kernen sind für Solo-Mining oft nicht profitabel.

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

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

***

## Voraussetzungen

| Anforderung       | Details                                            |
| ----------------- | -------------------------------------------------- |
| Clore.ai-Konto    | Mit CLORE-Guthaben                                 |
| Mining-Pool-Konto | Erstellen Sie bei supportXMR.com, MoneroOcean usw. |
| Monero-Wallet     | Download auf 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 (lokaler Rechner)
# Download von: https://www.getmonero.org/downloads/
```

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

```
43xxxx...lange Zeichenkette...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 CPU-Thread-Anzahl
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-minbare Coins bieten NVIDIA-Server bessere Leistung.
{% endhint %}

***

## Schritt 2: XMRig per Docker bereitstellen

### Benutzerdefinierte Dockerfile

Erstellen Sie eine `Dockerfile` auf dem Server:

```dockerfile
FROM ubuntu:22.04

ENV DEBIAN_FRONTEND=noninteractive

# Abhängigkeiten installieren
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: Methode mit Konfigurationsdatei

Die Verwendung einer Konfigurationsdatei ist sauberer als Befehlszeilen-Flags.

### Erstelle `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 `IHRE_MONERO_WALLET_ADRESSE` mit Ihrer tatsächlichen 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 (Leistungssteigerung)

RandomX profitiert erheblich von 1-GB-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 1-GB-Huge-Pages (falls von der 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

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

{% hint style="info" %}
**Leistungsauswirkung**: Huge Pages können die Monero-Hashrate auf einigen CPUs um 20-50 % erhöhen. Lohnt sich, wenn Sie Zugriff auf das Host-System haben.
{% endhint %}

***

## Schritt 5: Mining überwachen

### Container-Status prüfen

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

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

### Beispielhafte Protokollausgabe

```
[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, die zu beobachten sind

| Metrik             | Bedeutung                                 |
| ------------------ | ----------------------------------------- |
| 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

Überprüfen Sie Ihren Fortschritt auf der Website Ihres Pools:

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

***

## Beliebte Mining-Pools

### Monero (XMR)-Pools

| Pool        | URL                         | Gebühr | Minimale 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-schürfbare 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 etwas Besonderes**: Es schaltet Ihren Miner automatisch jederzeit auf den profitabelsten Algorithmus um und zahlt dennoch in XMR aus. Ideal, um Erträge zu maximieren.
{% endhint %}

***

## MoneroOcean: Automatisches Profit-Switching

MoneroOcean mined 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:LEISTUNGSGEBÜHR" \
  --tls \
  --cpu-max-threads-hint=95
```

***

## Optimierungstipps

### CPU-Optimierung

```bash
# Alle CPU-Threads verwenden
--cpu-max-threads-hint=100

# CPU-Priorität festlegen (0=am niedrigsten, 5=am höchsten)
--cpu-priority=3

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

# AVX2 für schnelleres RandomX aktivieren
# (automatisch, wenn die CPU dies 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
}
```

***

## Sicherheitsaspekte

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

* Miner nach Möglichkeit nie als root ausführen
* Den XMRig-API-Port (9090) nicht öffentlich freigeben
* Verwenden Sie TLS-Verbindungen zu Pools (`--tls` Schalter)
* Halten Sie XMRig auf dem neuesten Stand, um Sicherheitslücken zu schließen
* Achten Sie auf ungewöhnliche CPU/GPU-Nutzungsspitzen
  {% endhint %}

### API-Endpunkt schützen

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

```bash
# Mit Token aufrufen
curl -H "Authorization: Bearer your-secret-token-here" \
     http://localhost:9090/2/summary
```

***

## Automatisiertes Profit-Überwachungsskript

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

WALLET="YOUR_WALLET_ADDRESS"
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

### Niedrige Hashrate

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

# Stellen Sie sicher, 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, falls blockiert
# Versuchen Sie: xmr.pool.minergate.com:443
```

### CUDA-Fehler

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

# Wenn fehlt, --gpus all zu docker run hinzufügen
docker stop xmrig-gpu
docker rm xmrig-gpu
# Mit --gpus all erneut ausführen
```

### Container startet immer wieder 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
# - Verbindungsaufbau zum Pool fehlgeschlagen
# - Syntaxfehler in der Konfigurationsdatei
```

***

## Rechtliche und ethische Hinweise

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

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

***

## Kurzübersicht

### Befehlszeilen-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`         | Entwickler-Spende deaktivieren    |

### Algorithmus-Referenz

| Algorithmus | Coin            | Beste Hardware |
| ----------- | --------------- | -------------- |
| rx/0        | Monero (XMR)    | CPU (RandomX)  |
| kawpow      | Ravencoin (RVN) | GPU            |
| autolykos2  | Ergo (ERG)      | GPU            |
| octopus     | 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-Marktplatz](https://clore.ai)

***

## Zusammenfassung

| Schritt | Aktion                                                |
| ------- | ----------------------------------------------------- |
| 1       | Rentabilität ZUERST berechnen                         |
| 2       | Monero-Wallet auf 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 % Hashrate-Boost      |
| 8       | Mining starten und über das Pool-Dashboard überwachen |

XMRig auf Clore.ai verschafft 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. ⛏️

***

## GPU-Empfehlungen für Clore.ai

| Anwendungsfall        | Empfohlene GPU   | Geschätzte Kosten bei Clore.ai |
| --------------------- | ---------------- | ------------------------------ |
| Mining für Einsteiger | RTX 3080 (10 GB) | $0.05–0.19/GPU/Stunde          |
| Optimales Mining      | RTX 3090 (24 GB) | 0,07–0,21 $/GPU/Stunde         |
| Hochleistungs-Mining  | RTX 4090 (24 GB) | 0,14–0,42 $/GPU/Stunde         |

> 💡 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, and the optional `goal` query parameter:

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