ForHosting KIT · Outils pour développeurs

Calculateur capacité RAID

Voyez l'espace qu'un RAID vous laisse vraiment et combien de disques il peut perdre : quatre disques de 1000 GB en RAID 5 donnent 3000 GB utiles, 75 % d'efficacité et supportent une panne. Couvre les RAID 0, 1, 5, 6 et 10. Gratuit dans votre navigateur.

Gratuit
Fonctionne dans votre navigateur
Sans inscription
Vos données restent sur votre appareil

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Exemple résolu

Si vous saisissez

Niveau RAID: 5 GB
Nombre de disques: 4
Taille du disque: 1 000

Vous obtenez

Nom du RAID: RAID 5 GB
Minimum de disques: 3
Capacité brute: 4 000
Capacité utilisable: 3 000

Planifier un baie de stockage commence par une question simple : combien d’espace utile conservez-vous après striping, miroir ou parité, et combien de disques peuvent tomber en panne avant la perte de données. Ce calculateur de capacité RAID accepte un niveau (0, 1, 5, 6 ou 10), le nombre de disques membres identiques et la taille de chaque disque ; il renvoie la capacité brute, la capacité utile, le surcoût réservé aux miroirs ou à la parité, l’efficacité de stockage en pourcentage et la tolérance aux pannes comme nombre de disques que la disposition peut perdre. Les formules suivent les modèles classiques des manuels serveur, des tableurs homelab et des documents de dimensionnement : le RAID 0 utilise tous les disques sans redondance, le RAID 1 garde un disque d’espace utile avec une tolérance N−1, les RAID 5 et 6 cèdent un ou deux disques à la parité simple ou double, et le RAID 10 divise par deux la capacité pour des miroirs en bandes.

Ce que signifient capacité RAID, surcoût et tolérance aux pannes

La capacité brute est simplement le nombre de disques multiplié par la taille de chacun : chaque octet de chaque plateau ou SSD avant tout schéma RAID. La capacité utile est ce qu’un gestionnaire de volumes ou un contrôleur matériel présente après avoir réservé de l’espace pour miroirs ou parité.

Le surcoût est la différence : capacité que vous payez sans y stocker de données utilisateur uniques, qu’il s’agisse d’un jeu de miroirs complet en RAID 1, de l’équivalent d’un disque de parité distribuée en RAID 5, de deux disques de double parité en RAID 6, ou de la moitié du baie en RAID 10.

L’efficacité est l’utile divisée par la brute, en pourcentage : un RAID 5 à quatre disques de tailles égales est efficace à soixante-quinze pour cent et un RAID 10 à quatre disques à cinquante pour cent.

La tolérance aux pannes est le nombre de pannes concurrentes de membres que la disposition peut survivre tout en reconstruisant les données : zéro en RAID 0, N moins un pour un miroir RAID 1 à N voies, un en RAID 5, deux en RAID 6, et jusqu’à N sur deux en RAID 10 lorsque les pannes tombent une par paire miroir.

Ces chiffres supposent des tailles de disque identiques ; les contrôleurs réels dimensionnent souvent au plus petit membre, donc saisissez la taille effective par disque que vous utiliserez réellement. Le calculateur ne modélise ni hot spares, ni compression, ni thin provisioning, ni surcoût de système de fichiers, ni variantes RAID-Z constructeur : il répond aux chiffres classiques de capacité et de résilience que les planificateurs placent dans un BOM ou une demande de changement.

Choisissez le niveau selon le modèle de panne que vous acceptez, puis lisez capacité utile et surcoût ensemble pour que le coût par téraoctet utile soit honnête.

Quand ces chiffres de capacité font la différence

Les intégrateurs systèmes et les équipes de services managés ont besoin d’un oracle déterministe pour coter des baies afin que fiches commerciales, notes d’inventaire Ansible et portails clients s’accordent sur les téraoctets utiles pour le même SKU de disque et le même niveau. Les flux d’achats évaluent en lot RAID 5 contre RAID 6 contre RAID 10 pour un effectif fixe de disques sans rouvrir un tableur à chaque changement de SKU.

Les laboratoires de formation et la préparation aux certifications peuvent vérifier les réponses des élèves sur le surcoût et la tolérance sans déployer un simulateur de stockage complet. Une validation échouée ne consomme pas le solde. Des chiffres reproductibles de capacité utile et de tolérance aux pannes alignent BOM, runbooks et edge workers sans héberger votre propre arithmétique RAID.

Cas d’usage

Devis de capacité serveurs et SAN

Transformez le nombre de disques, la taille et le niveau RAID en capacité utile, surcoût et efficacité pour BOM et devis clients.

Planification homelab et montages

Comparez RAID 5, 6 et 10 avec les mêmes disques avant d’acheter : tolérance aux pannes et espace utile côte à côte.

Automatisation et contrôles d’inventaire

Validez la capacité d’array déclarée dans une CMDB ou des données Ansible par rapport aux formules classiques des niveaux 0, 1, 5, 6 et 10.

Questions fréquentes

Quels niveaux RAID sont pris en charge ?

RAID 0 (bande), RAID 1 (miroir à N voies), RAID 5 (parité simple), RAID 6 (double parité) et RAID 10 (miroirs en bandes). D’autres niveaux comme RAID 50 ou ZFS RAID-Z sont hors périmètre.

Pourquoi le RAID 10 exige-t-il un nombre pair de disques ?

Le RAID 10 est construit à partir de paires miroir réunies en bandes.

Le champ unit convertit-il les GB en TB ?

Non. unit est une étiquette d’affichage optionnelle (défaut GB) renvoyée sur les champs de capacité. Convertissez vous-même les tailles avant l’appel si vous avez besoin d’une autre unité.

Combien de disques peuvent tomber en panne selon le niveau de RAID ?

Aucun en RAID 0, tous sauf un en RAID 1, un en RAID 5 et deux en RAID 6. Le RAID 10 supporte jusqu'à la moitié de ses disques, mais seulement si chaque panne touche une paire miroir différente.

Et si mes disques n'ont pas tous la même taille ?

Les chiffres supposent des disques identiques, et les contrôleurs réels alignent en général tous les membres sur le plus petit. Saisissez cette plus petite taille, l'espace que chaque disque apportera vraiment, pour obtenir des chiffres fiables.

Outils associés

Pour les développeurs — accès API

Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.

Endpoint

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

Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.

Appeler depuis votre 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)

Exemple de requête

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

Exemple de réponse

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

L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.

Tarifs

par requête$0.002

Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.

Erreurs

HTTP	Code	Signification
`401`	`unauthorized`	Clé API absente ou invalide : vérifiez l’en-tête Authorization.
`402`	`insufficient_balance`	Solde insuffisant : rechargez votre compte pour lancer cette tâche.
`404`	`unknown_type`	Type de tâche inconnu : vérifiez le champ type de votre requête.
`429`	`rate_limited`	Trop de requêtes : ralentissez la cadence, puis réessayez.

Notes techniques

La même arithmétique pure alimente le parcours gratuit du navigateur et l’API, de sorte que devis, runbooks et automatisation ne divergent jamais sur un RAID 5 à quatre disques ou un RAID 10 à six. Niveaux invalides, effectifs impairs en RAID 10 ou trop peu de membres échouent avec invalid_input au lieu d’inventer une capacité.

Contrat d’entrée, formules par niveau et comportement d’erreur

Minimums de membres : deux pour RAID 0 et RAID 1, trois pour RAID 5, quatre pour RAID 6, et quatre avec un effectif pair pour RAID 10. Formules avec N disques de taille S : en RAID 0 l’utile vaut N fois S et la tolérance zéro ; en RAID 1 l’utile vaut S avec tolérance N moins un ; en RAID 5 l’utile vaut (N moins un) fois S avec tolérance un ; en RAID 6 l’utile vaut (N moins deux) fois S avec tolérance deux ; en RAID 10 l’utile vaut (N sur deux) fois S avec tolérance N sur deux. Épinglez ces nombres dans les tests pour que les devis de capacité restent reproductibles entre runtimes. Envoyez un corps JSON avec trois champs obligatoires : raid_level (0, 1, 5, 6 ou 10 — nombres ou chaînes telles que raid5 et RAID-10 acceptés), disk_count (effectif entier des membres) et disk_size (capacité finie par disque dans l’unité choisie). Le champ optionnel unit vaut GB par défaut et n’est renvoyé que comme étiquette ; l’API ne convertit pas entre GB et TB. En cas de succès le corps inclut raid_level, raid_name, disk_count, disk_size, unit, min_disks, raw_capacity, usable_capacity, overhead_capacity, efficiency_percent, fault_tolerance, formula et notes. Champs manquants, disk_size non positif, disk_count non entier, niveaux non pris en charge, trop peu de disques ou effectif impair en RAID 10 échouent avec invalid_input et ne sont pas facturés. Exemple : raid_level cinq, quatre disques de mille GB donnent une brute de quatre mille, une utile de trois mille, un surcoût de mille, une efficacité de soixante-quinze pour cent et une tolérance de un.

Où une API de capacité RAID prouve sa valeur

Gardez les requêtes compactes, traitez unit comme une étiquette, et souvenez-vous que le temps de reconstruction, le risque d’URE et les limites du contrôleur sont hors de cet endpoint : associez le résultat de capacité à votre propre guidance opérationnelle.

Questions techniques

Comment calculer la capacité RAID utile ?

Envoyez raid_level (0, 1, 5, 6 ou 10), disk_count et disk_size. L’API renvoie usable_capacity, overhead_capacity, efficiency_percent et fault_tolerance avec les formules standard pour disques identiques.

Combien coûte le calculateur de capacité RAID ?

L’outil navigateur est gratuit. Les requêtes API utilisent le solde prépayé KIT à $0.002 par appel réussi ; une entrée invalide n’est pas facturée.

Consulter la documentation complète du KIT →