ForHosting KIT · Entwickler-Tools

RAID-Kapazitätsrechner

Sehen Sie, wie viel Platz ein RAID tatsächlich lässt und wie viele Platten ausfallen dürfen: Vier Platten mit 1000 GB in RAID 5 ergeben 3000 GB nutzbar, 75 % Effizienz und überstehen einen Ausfall. Für RAID 0, 1, 5, 6 und 10. Kostenlos in Ihrem Browser.

Kostenlos
Läuft in Ihrem Browser
Ohne Anmeldung
Ihre Daten bleiben auf Ihrem Gerät

Im Browser ausführen – kostenlos API ansehen

Nutzen Sie es über WebAPIE-MailTelegramApp bald

Rechenbeispiel

Wenn Sie eingeben

RAID-Level: 5 GB
Anzahl der Festplatten: 4
Festplattengröße: 1.000

Erhalten Sie

RAID-Name: RAID 5 GB
Mindestanzahl Festplatten: 3
Bruttokapazität: 4.000
Nutzbare Kapazität: 3.000

Die Planung eines Speicherarrays beginnt mit einer einfachen Frage: wie viel nutzbaren Speicher behalten Sie nach Striping, Spiegelung oder Parität, und wie viele Festplatten dürfen ausfallen, bevor Daten verloren gehen. Dieser RAID-Kapazitätsrechner nimmt eine RAID-Stufe (0, 1, 5, 6 oder 10), die Anzahl identischer Mitgliedsplatten und die Größe jeder Platte entgegen und liefert Rohkapazität, nutzbare Kapazität, für Spiegel oder Parität reservierten Overhead, Speichereffizienz in Prozent sowie Fehlertoleranz als Anzahl der Platten, die das Layout verlieren darf. Die Formeln entsprechen den klassischen Lehrbuchmodellen aus Serverbauten, Homelab-Tabellen und Kapazitätsplanungen: RAID 0 nutzt alle Platten ohne Redundanz, RAID 1 behält eine Platte nutzbaren Speicher mit Fehlertoleranz N−1, RAID 5 und 6 opfern eine bzw. zwei Platten für einfache oder doppelte Parität, und RAID 10 halbiert die Kapazität für gestreifte Spiegel.

Was RAID-Kapazität, Overhead und Fehlertoleranz bedeuten

Die Rohkapazität ist schlicht die Anzahl der Platten mal die Größe jeder Platte: jedes Byte auf jedem Spindle oder SSD vor jedem RAID-Layout. Die nutzbare Kapazität ist das, was ein Volume-Manager oder Hardware-Controller nach dem Reservieren von Speicher für Spiegel oder Parität präsentiert.

Overhead ist die Differenz — Kapazität, die Sie bezahlen, auf der Sie aber keine einzigartigen Nutzerdaten ablegen — sei es ein voller Spiegelsatz in RAID 1, das Äquivalent einer Platte verteilter Parität in RAID 5, zwei Platten doppelter Parität in RAID 6 oder die Hälfte des Arrays in RAID 10. Effizienz ist nutzbar geteilt durch roh, als Prozent: ein Vier-Platten-RAID-5 gleicher Größe ist fünfundsiebzig Prozent effizient und ein Vier-Platten-RAID-10 fünfzig Prozent.

Fehlertoleranz ist die Anzahl gleichzeitiger Mitgliederausfälle, die das Layout noch übersteht und Daten rekonstruieren kann: null bei RAID 0, N minus eins bei einem N-Wege-RAID-1-Spiegel, eins bei RAID 5, zwei bei RAID 6 und bis zu N durch zwei bei RAID 10, wenn Ausfälle je ein pro Spiegelpaar treffen. Diese Zahlen setzen identische Plattengrößen voraus; reale Controller dimensionieren oft nach dem kleinsten Mitglied, geben Sie also die effektive Größe pro Platte an, die Sie tatsächlich nutzen.

Der Rechner modelliert weder Hot Spares noch Kompression, Thin Provisioning, Dateisystem-Overhead oder herstellerspezifische RAID-Z-Varianten — er liefert die klassischen Kapazitäts- und Resilienzzahlen, die Planer in ein BOM oder einen Change-Request schreiben. Wählen Sie die Stufe nach dem Ausfallmodell, das Sie akzeptieren, und lesen Sie nutzbare Kapazität und Overhead gemeinsam, damit die Kosten pro nutzbarem Terabyte ehrlich sind.

Wo sich diese Kapazitätswerte auszahlen

Systembauer und Managed-Service-Teams brauchen ein deterministisches Orakel beim Angebotsprozess für Arrays, damit Verkaufstabellen, Ansible-Inventarnotizen und Kundenportale bei denselben Platten-SKUs und derselben Stufe dieselben nutzbaren Terabyte nennen. Beschaffungsabläufe bewerten RAID 5 versus RAID 6 versus RAID 10 bei fester Plattenzahl im Batch, ohne bei jedem SKU-Wechsel eine Tabelle neu zu öffnen. Schulungslabore und Zertifizierungsvorbereitung können Schülerantworten zu Overhead und Fehlertoleranz prüfen, ohne einen vollständigen Speichersimulator aufzusetzen.

Fehlgeschlagene Validierung wird nicht berechnet. Halten Sie Anfragen klein, behandeln Sie unit als Label und bedenken Sie, dass Rebuild-Zeit, URE-Risiko und Controller-Grenzen außerhalb dieses Endpunkts liegen — koppeln Sie das Kapazitätsergebnis mit Ihrer eigenen Betriebsanleitung. Reproduzierbare nutzbare Kapazität und Fehlertoleranz halten BOM, Runbooks und Edge-Worker ausgerichtet, ohne eigene RAID-Mathematik zu hosten.

Anwendungsfälle

Kapazitätsangebote für Server und SAN

Wandeln Sie Plattenanzahl, Größe und RAID-Stufe in nutzbare Kapazität, Overhead und Effizienz für BOM und Kundenangebote um.

Homelab- und Aufbau-Planung

Vergleichen Sie RAID 5, 6 und 10 mit denselben Laufwerken vor dem Kauf: Fehlertoleranz und nutzbarer Speicher nebeneinander.

Automatisierung und Inventarprüfungen

Prüfen Sie deklarierte Array-Kapazität in CMDB- oder Ansible-Daten gegen die klassischen Formeln der Stufen 0, 1, 5, 6 und 10.

Häufige Fragen

Welche RAID-Stufen werden unterstützt?

RAID 0 (Stripe), RAID 1 (N-Wege-Spiegel), RAID 5 (einfache Parität), RAID 6 (doppelte Parität) und RAID 10 (gestreifte Spiegel). Andere Stufen wie RAID 50 oder ZFS RAID-Z liegen außerhalb des Umfangs.

Warum braucht RAID 10 eine gerade Plattenanzahl?

RAID 10 besteht aus gespiegelten Paaren, die gestreift werden.

Wandelt das Feld unit GB in TB um?

Nein. unit ist ein optionales Anzeige-Label (Standard GB), das auf Kapazitätsfeldern zurückgegeben wird. Rechnen Sie Größen vor dem Aufruf selbst um, wenn Sie eine andere Einheit brauchen.

Wie viele Platten dürfen je RAID-Stufe ausfallen?

Keine bei RAID 0, alle bis auf eine bei RAID 1, eine bei RAID 5 und zwei bei RAID 6. RAID 10 übersteht bis zur Hälfte der Platten, aber nur, wenn jeder Ausfall ein anderes Spiegelpaar trifft.

Was, wenn meine Platten unterschiedlich groß sind?

Die Werte setzen gleich große Platten voraus, und echte Controller richten meist alle Mitglieder nach der kleinsten aus. Geben Sie diese kleinste Größe ein, also den Platz, den jede Platte wirklich beiträgt.

Für Entwickler — API-Zugang

Alles auf dieser Seite ist auch per API verfügbar. Dieser Abschnitt richtet sich an Teams, die es in ihre eigenen Systeme einbinden möchten; alle anderen nutzen einfach das Tool oben.

Endpunkt

POSThttps://api.kit.forhosting.com/dev/raid-capacity

Authentifizierung per Bearer-Token. Ein einziger POST stellt die Aufgabe in die Warteschlange; das Ergebnis erhalten Sie per Webhook oder über einen signierten Link.

Aufruf aus Ihrem Stack

curl -X POST https://api.kit.forhosting.com/dev/raid-capacity \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"raid_level":"5","disk_count":4,"disk_size":1000}'

const res = await fetch("https://api.kit.forhosting.com/dev/raid-capacity", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "raid_level": "5",
    "disk_count": 4,
    "disk_size": 1000
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/dev/raid-capacity",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "raid_level": "5",
    "disk_count": 4,
    "disk_size": 1000
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/raid-capacity", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"raid_level":"5","disk_count":4,"disk_size":1000}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"raid_level":"5","disk_count":4,"disk_size":1000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/raid-capacity", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Beispiel-Anfrage

{
  "raid_level": "5",
  "disk_count": 4,
  "disk_size": 1000
}

Beispiel-Antwort

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev.raid_capacity",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

Die API arbeitet asynchron: Sie erhalten sofort eine task_id. Polling ist mit 1 Anfrage pro Sekunde erlaubt.

Preis

pro Anfrage$0.002

Der Preis steht auf der Seite – keine Tokens, keine Credits. Fehlgeschlagene Aufgaben werden nicht berechnet.

Fehler

HTTP	Code	Bedeutung
`401`	`unauthorized`	Der API-Schlüssel fehlt oder ist ungültig – prüfen Sie den Authorization-Header (Bearer).
`402`	`insufficient_balance`	Ihr Guthaben reicht für diese Aufgabe nicht aus – Aufladungen verfallen nicht.
`404`	`unknown_type`	Unbekannter Aufgabentyp – prüfen Sie das Feld „type“ gegen den Katalog.
`429`	`rate_limited`	Zu viele Anfragen – warten Sie kurz; Polling ist mit 1 Anfrage pro Sekunde erlaubt.

Technische Hinweise

Dieselbe reine Arithmetik speist den kostenlosen Browserpfad und die API, sodass Angebote, Runbooks und Automatisierung bei einem Vier-Platten-RAID-5 oder einem Sechs-Platten-RAID-10 nicht auseinanderlaufen. Ungültige Stufen, ungerade Anzahlen bei RAID 10 oder zu wenige Mitglieder scheitern mit invalid_input statt erfundener Kapazität.

Eingabevertrag, Formeln je Stufe und Fehlerverhalten

Mindestmitglieder: zwei für RAID 0 und RAID 1, drei für RAID 5, vier für RAID 6 und vier mit gerader Anzahl für RAID 10. Formeln mit N Platten der Größe S: bei RAID 0 ist nutzbar N mal S und Fehlertoleranz null; bei RAID 1 nutzbar S mit Fehlertoleranz N minus eins; bei RAID 5 nutzbar (N minus eins) mal S mit Fehlertoleranz eins; bei RAID 6 nutzbar (N minus zwei) mal S mit Fehlertoleranz zwei; bei RAID 10 nutzbar (N durch zwei) mal S mit Fehlertoleranz N durch zwei. Verankern Sie diese Zahlen in Tests, damit Kapazitätsangebote über Runtimes hinweg reproduzierbar bleiben. Senden Sie einen JSON-Body mit drei Pflichtfeldern: raid_level (0, 1, 5, 6 oder 10 — Zahlen oder Zeichenketten wie raid5 und RAID-10 sind zulässig), disk_count (ganzzahlige Mitgliederzahl) und disk_size (endliche Kapazität pro Platte in der gewählten Einheit). Optionales unit ist standardmäßig GB und wird nur als Label zurückgegeben; die API rechnet nicht zwischen GB und TB um. Bei Erfolg enthält der Body raid_level, raid_name, disk_count, disk_size, unit, min_disks, raw_capacity, usable_capacity, overhead_capacity, efficiency_percent, fault_tolerance, formula und notes. Fehlende Felder, nicht positive disk_size, nicht ganzzahliges disk_count, nicht unterstützte Stufen, zu wenige Platten oder ungerade RAID-10-Anzahl scheitern mit invalid_input und werden nicht abgerechnet. Beispiel: raid_level fünf, vier Platten zu tausend GB ergeben roh viertausend, nutzbar dreitausend, Overhead tausend, Effizienz fünfundsiebzig Prozent und Fehlertoleranz eins.

Technische Fragen

Wie berechne ich nutzbare RAID-Kapazität?

Senden Sie raid_level (0, 1, 5, 6 oder 10), disk_count und disk_size. Die API liefert usable_capacity, overhead_capacity, efficiency_percent und fault_tolerance mit Standardformeln für identische Platten.

Was kostet der RAID-Kapazitätsrechner?

Das Browser-Werkzeug ist kostenlos. API-Anfragen nutzen vorausbezahltes KIT-Guthaben zu $0.002 pro erfolgreichem Aufruf; ungültige Eingabe wird nicht berechnet.

Vollständige KIT-Dokumentation lesen →