Businessplan Mining-Farm 50 kW: CAPEX, OPEX & ROI Berechnung

Der Betrieb einer 50-kW-Mining-Farm ist das klassische Grenzscenario zwischen Haushaltssteckdose und kommerziellem Rechenzentrum. Einerseits lässt sich eine aktive Last von 50 kW noch in einer kleineren Gewerbeimmobilie oder einem privaten Objekt mit eigener Transformatorenstation realisieren. Andererseits sprechen wir hier von rund 14 bis 15 modernen ASIC-Minern, von denen jeder bis zu 3,5 kW Abwärme erzeugt, 15 bis 16 Ampère pro Phase zieht und einen Luftdurchsatz von 600 bis 800 Kubikmetern pro Stunde erfordert.

Dieser Leitfaden liefert den harten Praxis-Fahrplan zu Planung, Hardware-Beschaffung, elektrischer Verschaltung, Kühlung und Automatisierung einer 50-kW-Mining-Farm. Kein Marketing-Blabla, keine abstrakte Theorie oder akademisches Geschwafel, sondern reine Fakten, Hardware-Specs, Kabelquerschnitte, Grundwasser-Profile und einsatzerprobte Monitoring-Scripte.

1. Eckdaten und elektrische Infrastruktur

Das Fundament eines jeden Mining-Business sind die Stromkosten und die Zuverlässigkeit der Trafostation. Bei einer dauerhaften 24/7-Last von 50 kW muss der Nennstrom der Einspeisung beziehungsweise Vorsicherung einen Sicherheitszuschlag von 20 % aufweisen (gemäß NFPA/IEC-Standards für Dauerlasten).

I_total = P / (√3 · U · cosφ) = 50000 / (√3 · 380 · 0.95) ≈ 79.8 A

Unter Berücksichtigung des 1,25-Faktors muss der Hauptschalter beziehungsweise Vorsicherungsautomat auf mindestens 100 A (dreiphasig) ausgelegt sein.

Spezifikation des Hauptverteilers (Niederspannungs-Hauptverteilung 50 kW)

• Hauptschalter / Einspeisung: 3P 100 A (Auslösecharakteristik C, Schaltvermögen mind. 10 kA, z. B. Schneider Electric Acti9 oder ABB S200).
• Phasenlast-Ausgleich: Drei Phasen L1, L2, L3, streng symmetrisch aufgeteilt auf jeweils 5 Geräte pro Phase (bei 15 Geräten), um Schieflasten und unzulässige Neutralleiterströme zu verhindern.
• Kabeltrasse von Trafo zu Hauptverteiler: Kupferkabel NYY-J 4x25 mm² oder Aluminiumkabel NAYY-J 4x50 mm² bei Erdverlegung (unter Berücksichtigung eines Spannungsfalls von maximal 2 % auf 50 Metern).
• Absicherung der Abgänge: Für jeden ASIC ein dedizierter Leitungsschutzschalter 2P 20 A (Charakteristik C) plus halogenfreies, feuerbeständiges Kupferkabel NYM-J 3x2,5 mm² mit doppelter Isolierung.
• Erdungskonzept: Fundament- oder Ringerder nach TN-S- beziehungsweise TN-C-S-System mit einem Erdungswiderstand von unter 4 Ohm (bestehend aus drei verkupferten Kreuzerdstäben à 2,5 m im Dreieck eingeschlagen und verschweißt mit 40x4 mm Flachstahl).

2. Hardware-Auswahl und CAPEX (Investitionskosten)

Als Rechengrundlage nutzen wir den Industriestandard schlechthin: Bitmain Antminer S19k Pro / S21 oder die MicroBT Whatsminer M50/M60 Serie. Für eine saubere Auslastung von 50 kW ist die Bestückung mit 14 Einheiten des Antminer S21 (200 TH/s) bei einem typischen Verbrauch von ca. 3.500 W pro Gerät optimal.

• Gesamt-Hashrate: 14 · 200 TH/s = 2.800 TH/s = 2,8 PH/s
• Gesamtanschlussleistung: 14 · 3.500 W = 49 kW (passt perfekt unter die 50-kW-Grenze inklusive Lüftungs-Overhead).

Investitionskosten-Tabelle (CAPEX)

3. Kühlung und Lüftung: Thermodynamische Auslegung

Der klassische Anfängerfehler: Ein normaler Raumklimaanlage installieren. Eine Klimaanlage entfeuchtet und kühlt über einen Kältekreislauf, aber für 50 kW thermische Last bräuchte man eine monströse 150.000-BTU-Anlage, die mal eben 15 bis 18 kW Extrastrom frisst.

Mining wird ausschließlich über eine mechanische Zu- und Abluftlüftung (Direktlüftung / Frischluftspülung) gekühlt.

Berechnung des Luftvolumenstroms

Formel für den benötigten Luftdurchsatz:

Q = P_dissip / (ρ · c_p · ΔT)

Wobei:

• P_dissip = 49.000 W (Abwärme)
• ρ = 1,2 kg/m³ (Luftdichte bei 20 °C)
• c_p = 1.005 J/(kg·K) (spezifische Wärmekapazität der Luft)
• ΔT = 15 °C (zulässiger Temperaturanstieg zwischen Zuluft und Abluft)

Q = 49000 / (1.2 · 1005 · 15) ≈ 2.708 m³/s = 9.750 m³/h

Unter Einberechnung des Druckverlusts der groben Filtermatten (G4) sollte man Lüfter mit einer Gesamtleistung von mindestens 12.000 bis 14.000 m³/h einplanen.

Zonentrennung (Heiß-/Kaltgang-Prinzip)

• Kaltgang: Gesteuerte Frischluftzufuhr von außen durch eine Filterwand. Hier herrscht ein leicht erhöhter statischer Druck.
• Heißgang: Die ASIC-Miner sind passgenau in eine luftdichte Trennwand (Rack mit Luftleitblechen / Shrouds) eingebaut. Die internen Miner-Lüfter blasen die Abluft direkt in eine isolierte Rückkammer, von wo aus ein leistungsstarker Industrie-Abluftventilator sie nach draußen bläst.

4. OPEX und Betriebskosten (Monatliche Kalkulation)

Die laufenden Betriebskosten stützen sich auf drei Kernsäulen: Stromkosten, Hallenmiete, Internetanbindung und Instandhaltung.

Wir kalkulieren mit einem durchschnittlichen Gewerbestrompreis von 0,07 $ pro kWh.

Monatliche Stromkostenkalkulation

• Stundenverbrauch: 49 kW (Miner) + 1,5 kW (Lüftung & Netzwerk) = 50,5 kW
• Tagesverbrauch: 50,5 · 24 = 1.212 kWh
• Monatsverbrauch (30,5 Tage): 1.212 · 30,5 = 36.966 kWh
• Stromkosten pro Monat: 36.966 · 0,07 $ = 2.587,62 $

Fixe monatliche Betriebsausgaben (OPEX)

5. Ertragsprognose, ROI (Amortisation) und Finanzmodell

Für die Umsatzprognose dienen die Bitcoin-Netzwerkschwierigkeit und der Block-Reward im Jahr 2026 als Basis. Angenommen, 1 TH/s erwirtschaftet täglich ca. 0,042 $ (vor Stromabzug, bei einem BTC-Kurs von ~65.000 $).

Einnahmenkalkulation (Revenue)

• Gesamter Hashrate: 2.800 TH/s
• Tagesumsatz: 2.800 · 0,042 $ = 117,60 $
• Monatsumsatz (30,5 Tage): 117,60 $ · 30,5 = 3.586,80 $

Nettogewinn (EBITDA / Net Profit)

• Net Profit/mo = Einnahmen (3.586,80 $) - OPEX (3.077,62 $) = 509,18 $ (bei besserem TH/s-Yield steigt der Ertrag; bei einem BTC-Kurs von 90.000 $ skaliert der Gewinn linear nach oben).

Wichtiger Hinweis zur ROI-Sensitivität bei Strompreis und Kurs:
Fällt der Strompreis auf 0,05 $ / kWh, sinken die Strom-OPEX auf 1.848,30 $, wodurch der Nettogewinn auf 1.248,50 $ monatlich steigt. Das drückt die Amortisationszeit von katastrophalen Werten auf gesunde 35 bis 40 Monate. Mining zu gewerblichen Strompreisen jenseits von 0,065 bis 0,07 $/kWh ohne Bullrun oder hocheffiziente Hardware bewegt sich direkt im Hochrisikobereich.

6. Automatisierung & Steuerung: Python-Monitoring-Skript (CGMiner / CGMiner API)

Ein echter Engineer klickt sich nicht manuell durch die Web-Oberflächen von 14 Geräten. Alle modernen ASIC-Miner (Antminer, Whatsminer) unterstützen das CGMiner-API-Protokoll (auf Basis von JSON über TCP-Sockets).

Unten findest du ein produktionserprobtes Python-Skript für das Farm-Pool-Monitoring. Das Skript fragt alle 14 ASICs im lokalen Netzwerk parallel ab, sammelt Hashrate sowie Chiptemperaturen ein und feuert bei Leistungseinbrüchen oder Überhitzung sofort einen Alarm via Telegram raus.

#!/usr/bin/env python3
"""
ASIC-Miner-Farm-Monitoring via CGMiner API (Port 4028).
Features:
  * Fragt alle Geräte parallel ab;
  * Antminer (Key "command") und Whatsminer (Key "cmd") — Typ wird in MINERS definiert;
  * Alarme: Offline, Hashrate-Drop, Überhitzung, Temperaturfelder fehlen;
  * Deduplizierung: Dasselbe Event wird nicht öfter als alle REPEAT_MINUTES gesendet;
  * Entwarnung, sobald das Problem behoben ist;
  * Problembestätigung über CONFIRM_CYCLES aufeinanderfolgende Polls (Schutz vor Fehlalarmen);
  * Zustand wird in einer Datei gespeichert, läuft somit sauber im Loop sowie via cron (--once).
Konfiguration über Umgebungsvariablen:
  TG_BOT_TOKEN, TG_CHAT_ID              — Pflichtfelder
  TEMP_THRESHOLD (Standard: 85)         — Chiptemperaturlimit, °C
  HASHRATE_WARN_TH (Standard: 170)      — Minimale Hashrate, TH/s
  POLL_INTERVAL_SEC (Standard: 60)      — Abfrageintervall im Loop-Modus
  REPEAT_MINUTES (Standard: 60)         — Wiederholungsintervall für denselben Alarm
  CONFIRM_CYCLES (Standard: 2)          — Anzahl aufeinanderfolgender Polls zur Problembestätigung
Ausführung:
  python3 asic_monitor.py               # Endlosschleife
  python3 asic_monitor.py --once        # Einmaliger Durchlauf (für cron / systemd timer)
WICHTIG: Port 4028 darf nur aus dem lokalen Netzwerk erreichbar sein.
Niemals nach draußen ins Public Internet exposen!
"""
import json
import logging
import os
import socket
import sys
import time
from concurrent.futures import ThreadPoolExecutor
import requests
# --------------------------------------------------------------------------
# Konfiguration
# --------------------------------------------------------------------------
# (ip, typ): "antminer" oder "whatsminer"
MINERS = [(f"192.168.1.{i}", "antminer") for i in range(101, 115)]  # .101 - .114
# Beispiel für eine gemischte Farm:
# MINERS[0] = ("192.168.1.101", "whatsminer")
API_PORT = 4028
SOCKET_TIMEOUT = 3.0
TG_BOT_TOKEN = os.environ.get("TG_BOT_TOKEN", "")
TG_CHAT_ID = os.environ.get("TG_CHAT_ID", "")
TEMP_THRESHOLD = float(os.environ.get("TEMP_THRESHOLD", "85"))
HASHRATE_WARN_TH = float(os.environ.get("HASHRATE_WARN_TH", "170"))
POLL_INTERVAL_SEC = int(os.environ.get("POLL_INTERVAL_SEC", "60"))
REPEAT_MINUTES = int(os.environ.get("REPEAT_MINUTES", "60"))
CONFIRM_CYCLES = int(os.environ.get("CONFIRM_CYCLES", "2"))
STATE_FILE = os.environ.get("STATE_FILE", "asic_monitor_state.json")
# Präfixe für Antminer-Chiptemperatur-Keys in der `stats`-Antwort.
# Mit der eigenen Firmware abgleichen: `stats` ausführen und reale Keys prüfen.
ANTMINER_TEMP_PREFIXES = ("temp2_", "temp_chip")
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s %(levelname)s %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S",
)
log = logging.getLogger("asic_monitor")
# --------------------------------------------------------------------------
# Telegram
# --------------------------------------------------------------------------
def send_telegram(text: str) -> bool:
    """Sendet eine Nachricht ohne parse_mode (dynamischer Text zerschießt kein Markdown).
    Gibt True zurück, wenn Telegram die Nachricht erfolgreich angenommen hat."""
    if not TG_BOT_TOKEN or not TG_CHAT_ID:
        log.error("TG_BOT_TOKEN / TG_CHAT_ID nicht gesetzt, Alarm verworfen: %s", text)
        return False
    url = f"https://api.telegram.org/bot{TG_BOT_TOKEN}/sendMessage"
    try:
        r = requests.post(url, json={"chat_id": TG_CHAT_ID, "text": text}, timeout=10)
        if not r.ok:
            log.error("Telegram gab %s zurück: %s", r.status_code, r.text[:200])
        return r.ok
    except requests.RequestException as e:
        log.error("Fehler beim Senden an Telegram: %s", e)
        return False
# --------------------------------------------------------------------------
# CGMiner API Interaktion
# --------------------------------------------------------------------------
def query_miner(ip: str, kind: str, command: str) -> dict:
    """Sendet einen Befehl an die CGMiner API. Bei Fehlern wird {"error": "..."} zurückgegeben."""
    key = "cmd" if kind == "whatsminer" else "command"
    try:
        with socket.create_connection((ip, API_PORT), timeout=SOCKET_TIMEOUT) as s:
            s.settimeout(SOCKET_TIMEOUT)
            s.sendall(json.dumps({key: command}).encode("utf-8"))
            chunks = []
            while True:
                chunk = s.recv(4096)
                if not chunk:
                    break
                chunks.append(chunk)
        text = b"".join(chunks).decode("utf-8", errors="ignore").replace("\x00", "")
        # Manche Firmwares liefern "}{" ohne Komma zwischen Objekten
        text = text.replace("}{", "},{")
        return json.loads(text)
    except Exception as e:  # Netzwerk, Timeout, ungültiges JSON
        return {"error": f"{type(e).__name__}: {e}"}
def to_float(value):
    """Zahl oder String mit Zahl -> float, sonst None."""
    try:
        return float(value)
    except (TypeError, ValueError):
        return None
def get_hashrate_th(summary: dict, kind: str):
    """Hashrate in TH/s oder None, falls das Feld fehlt."""
    try:
        s = summary["SUMMARY"][0]
    except (KeyError, IndexError, TypeError):
        return None
    if kind == "whatsminer":
        # MH/s -> TH/s. 5-Minuten-Durchschnitt falls vorhanden, sonst Gesamtdurchschnitt.
        for key in ("MHS 5m", "MHS av"):
            v = to_float(s.get(key))
            if v is not None:
                return v / 1_000_000.0
        return None
    # Antminer: GH/s -> TH/s. "GHS 5s" wird vermieden (zu unruhig).
    for key in ("rate_30m", "GHS av"):
        v = to_float(s.get(key))
        if v is not None:
            return v / 1000.0
    return None
def get_max_chip_temp(ip: str, kind: str, summary: dict):
    """Maximale Chiptemperatur oder None, falls Felder nicht gefunden wurden."""
    if kind == "whatsminer":
        try:
            s = summary["SUMMARY"][0]
        except (KeyError, IndexError, TypeError):
            return None
        temps = [to_float(s.get(k)) for k in ("Chip Temp Max", "Temperature")]
        temps = [t for t in temps if t]
        return max(temps) if temps else None
    stats = query_miner(ip, kind, "stats")
    try:
        info = stats["STATS"][1]
    except (KeyError, IndexError, TypeError):
        return None
    temps = []
    for k, v in info.items():
        if k.startswith(ANTMINER_TEMP_PREFIXES):
            t = to_float(v)
            if t:  # 0 = Board liefert keinen Wert
                temps.append(t)
    return max(temps) if temps else None
# --------------------------------------------------------------------------
# Überprüfung eines einzelnen Geräts
# --------------------------------------------------------------------------
def check_miner(ip: str, kind: str) -> dict:
    """Gibt {issue_key: alert_text} für aktive Probleme zurück."""
    issues = {}
    summary = query_miner(ip, kind, "summary")
    if "error" in summary:
        # Offline: Weitere Checks sind sinnlos
        return {"offline": f"⚠️ {ip}: API nicht erreichbar ({summary['error']})"}
    th = get_hashrate_th(summary, kind)
    if th is None:
        issues["parse"] = f"❌ {ip}: Konnte Hashrate nicht aus summary auslesen (Firmware/Typ prüfen)"
    elif th < HASHRATE_WARN_TH:
        issues["hashrate"] = f"📉 {ip}: Hashrate bei {th:.1f} TH/s (Schwellenwert {HASHRATE_WARN_TH:.0f})"
    temp = get_max_chip_temp(ip, kind, summary)
    if temp is None:
        issues["temp_keys"] = f"❓ {ip}: Temperaturfelder nicht gefunden, Keys in stats prüfen"
    elif temp > TEMP_THRESHOLD:
        issues["temp"] = f"🔥 {ip}: Überhitzung, Chips bei {temp:.0f}°C (Schwellenwert {TEMP_THRESHOLD:.0f})"
    return issues
# --------------------------------------------------------------------------
# State & Deduplizierung
# --------------------------------------------------------------------------
def load_state() -> dict:
    try:
        with open(STATE_FILE, encoding="utf-8") as f:
            return json.load(f)
    except (OSError, ValueError):
        return {"sent": {}, "streak": {}}
def save_state(state: dict) -> None:
    try:
        tmp = STATE_FILE + ".tmp"
        with open(tmp, "w", encoding="utf-8") as f:
            json.dump(state, f)
        os.replace(tmp, STATE_FILE)
    except OSError as e:
        log.error("Konnte Zustand nicht speichern: %s", e)
def run_cycle(state: dict) -> None:
    sent, streak = state["sent"], state["streak"]
    now = time.time()
    with ThreadPoolExecutor(max_workers=len(MINERS)) as pool:
        results = list(pool.map(lambda m: (m[0], check_miner(*m)), MINERS))
    for ip, issues in results:
        # 1) Aktive Probleme
        for key, text in issues.items():
            sid = f"{ip}|{key}"
            streak[sid] = streak.get(sid, 0) + 1
            if streak[sid] < CONFIRM_CYCLES:
                continue
            last = sent.get(sid)
            if last is None or now - last >= REPEAT_MINUTES * 60:
                if send_telegram(text):
                    sent[sid] = now
        # 2) Behobene Probleme
        prefix = f"{ip}|"
        for sid in [s for s in list(streak) if s.startswith(prefix)]:
            key = sid[len(prefix):]
            if key in issues:
                continue
            streak.pop(sid, None)
            if sid in sent:  # Nur Entwarnung senden, wenn zuvor ein Alarm rausging
                if send_telegram(f"✅ {ip}: Problem „{key}“ behoben"):
                    sent.pop(sid, None)
    ok = sum(1 for _, i in results if not i)
    log.info("Abfrage abgeschlossen: %d/%d fehlerfrei", ok, len(results))
    save_state(state)
# --------------------------------------------------------------------------
def main() -> None:
    state = load_state()
    state.setdefault("sent", {})
    state.setdefault("streak", {})
    if "--once" in sys.argv:
        run_cycle(state)
        return
    log.info("Starte Monitoring: %d Geräte, Intervall %d s", len(MINERS), POLL_INTERVAL_SEC)
    while True:
        try:
            run_cycle(state)
        except Exception:
            log.exception("Unbehandelte Ausnahme im Abfrage-Loop")
        time.sleep(POLL_INTERVAL_SEC)
if __name__ == "__main__":
    main()

7. Pre-Flight Checkliste (Engineering Abnahme)

• 1. Netz-Lasttest: Vor der Miner-Installation ein 50-kW-Heizgebläse 4 Stunden lang unter Last laufen lassen. Erwärmung der Klemmstellen am Hauptschalter und an den Sammelschienen per Pyrometer messen. Die Kontakttemperatur darf 65 °C nicht überschreiten.
• 2. Erdungsmessung: Elektrofachbetrieb/Messlabor beauftragen: Schleifenimpedanz (Netz-Innenwiderstand) und den Ausbreitungswiderstand der Erdungsanlage messen (muss < 4 Ohm betragen).
• 3. Zuluft-Check: Sicherstellen, dass der Strömungswiderstand der G4-Filterwand im Raum keinen Unterdruck erzeugt (die Tür zum Kaltgang muss bei laufendem Abluftgebläse ohne massiven Kraftaufwand aufgehen).
• 4. Watchdog-Konfiguration: Integrierte Hardware-Auto-Reboot-Funktionen in der Miner-Firmware (LUXOS, VNISH oder Stock) aktivieren – für den Fall von Pool-Abstürzen oder IP-Verlust.

Ausführung:

export TG_BOT_TOKEN="..." TG_CHAT_ID="..."
python3 asic_monitor.py

8. Rechtliche Strukturierung, PPA-Vertrag und internationale Finanzbuchhaltung

Der Betrieb einer 50-kW-Anlage in jeder beliebigen Jurisdiktion erfordert den offiziellen Status eines gewerblichen Stromverbrauchers. „Schwarzes“ Mining über eine haushaltsübliche Steckdose führt unweigerlich zu Abmahnungen des Energieversorgers, empfindlichen Bußgeldern wegen Überschreitung der Leistungsgrenzen und unzulässiger Netznutzung.

Strukturierungs- und Rechtsform

• Gründung der Betriebsgesellschaft (GmbH / LLC / Inc.): Die Anlage wird auf eine reguläre Gesellschaft mit beschränkter Haftung registriert. Dies ist zwingend erforderlich, um einen gewerblichen Mietvertrag für die Fläche und den Netzanschlussvertrag rechtssicher abzuschließen.
• PPA-Vertrag (Power Purchase Agreement): Das Kernpapier der Anlage ist der kommerzielle Stromliefervertrag (PPA) mit dem Grundversorger oder dem Betreiber der Umspannstation (Trafo). Im Vertrag werden folgende Punkte fixiert:
  • Zugewiesene Wirkleistung: 50 kW nach Zuverlässigkeitskategorie III (mit zulässiger permanenter 24/7-Dauerlast).
  • Eigentumsgrenze: 0,4 kV an den Niederspannungsschienen des Transformators.
  • Tarifstruktur: Fixierter kWh-Preis (Ziel < 0,065–0,07 USD).
• Hardware-Import (HS-Code 8471): Die Beschaffung der ASIC-Miner erfolgt über direkte B2B-Verträge. Der internationale Harmonisierte System-Code (HS-Code) für die Ausrüstung lautet 8471 50 000 0 (Datenverarbeitungseinheiten). Bei ordnungsgemäßer Zollabfertigung werden Einfuhrumsatzsteuer (VAT/GST) und Zölle entrichtet. Als Belege verbleiben die Zollanmeldungen (GTD/Einfuhrpapiere) und Handelsrechnungen, die die Herkunft der Anlagegüter nachweisen.
• Finanzbuchhaltung und Off-Ramping: Die Mining-Erträge werden im Pool in BTC generiert. Zur Deckung der monatlichen Betriebskosten (OPEX: Strom, Miete) dient ein institutionelles Unternehmenskonto (Corporate Account) bei einer Kryptobörse oder einem OTC-Desk mit erfolgreich durchlaufenem KYB-Prozess (Know Your Business). Die erzielten Fiat-Erlöse werden per Überweisung auf das Geschäftskonto eingezahlt, um die Stromrechnungen fristgerecht zu begleichen.

9. Logistik und Hardware-Abnahme

Das Gesamtgewicht von 14 Antminer S21 in der Originalverpackung beträgt ca. 230–250 kg.

Eingangskontrollprotokoll (QC bei Lieferung)

• 1. Sichtprüfung der Verpackung: Überprüfung der Siegel und äußerer Kartonbeschädigungen.
• 2. Shaker-Test (Kühlerprüfung): Durch heftige Vibrationen beim Transport aus China können sich Befestigungsschrauben lösen oder einzelne Chip-Kühlkörper abfallen (insbesondere bei Gebrauchtgeräten). Das Gerät wird vorsichtig geschüttelt – im Inneren dürfen keine Teile klappern.
• 3. Widerstandsmessung (Cold Test): Vor dem Anlegen von 220 V wird per Multimeter geprüft, ob auf den Versorgungsbussen der Hashboards ein Kurzschluss vorliegt (der Widerstand der VDD-Leitung muss den Herstellervorgaben entsprechen, im Bereich von einigen Dutzend Ohm liegen).
• 4. Testbench (15 Minuten): Sequenzielles Hochfahren in einem isolierten Stromkreis. Kontrolle des Erreichens der Ziel-Hashrate (200 TH/s), der Antwort aller 3 Boards (3/3 Boards detected) und des Fehlens defekter Chips (HW Errors < 0,5 %).

10. Sicherheit und Netzwerk-Isolierung

Eine 50-kW-Farm ist sowohl für Diebstahl vor Ort als auch für Cyberangriffe (Stratum-Traffic-Interception, Einschleusung von Miner-Malware) ein attraktives Ziel.

Netzwerktopologie-Schema:
[ Internet (WAN) ]
          &│
     [ 4G/LTE Backup ]
           &│
   ┌───────┴────────┐
   │ Router / WAF │ (MikroTik / OPNsense)
   │ Firewall │ ── WireGuard VPN (Nur Fernzugriff)
   └───────┬────────┘
           │ (Isoliertes VLAN 10.0.10.0/24)
  ┌────────┼─────────────────┬─────────────────┐
  │        │                 │                 │
[ASIC 1] [ASIC 2] ...    [ASIC 14]     [Script Node]
10.0.10.101 10.0.10.102  10.0.10.114    10.0.10.250 (Python Watchdog)

Netzwerkparameter

• Vollständige WAN-Isolierung: Die ASICs befinden sich in einem geschlossenen VLAN-Segment ohne öffentliche IP-Adresse.
• Port 4028 geschlossen (CGMiner API): Der Zugriff auf den Metrik-Port ist ausschließlich für die IP-Adresse des internen Überwachungsservers freigegeben.
• Stratum/TLS-Verschlüsselung: Die Weiterleitung des Traffics zum Pool (Stratum V2 oder Stratum over TLS) schließt Man-in-the-Middle-Angriffe (MitM) zur Wallet-Umleitung auf ISP-Ebene aus.

11. Ingenieurs-Fazit (Deployment-Checkliste)

• 1. Elektrik: Kabelquerschnitt VVGng-LS 3x2,5 mm² für jede C19-Steckdose prüfen, alle Klemmen in der Hauptverteilung (HV) nach 48 Stunden Volllastbetrieb mit dem Drehmomentschlüssel nachziehen.
• 2. Lüftung: Temperaturdifferenz zwischen Zuluft und Abluft messen. Bei $\Delta T > 18^\circ\text{C}$ werden die Abluftventilatoren über einen Frequenzumrichter (VFD) auf eine höhere Stufe geschaltet.
• 3. Monitoring: Automatisiertes ASIC-Überwachungsskript mit Alarmierung bei einem Hashrate-Abfall unter 170 TH/s einrichten.
• 4. Finanzrisikomanagement: Break-Even-Schwellen unter Berücksichtigung eines potenziellen Netzschwierigkeitswachstums von 15–20 % pro Jahr kalkulieren.