1268 lines
79 KiB
HTML
1268 lines
79 KiB
HTML
<!DOCTYPE html>
|
||
<html lang="it">
|
||
<head>
|
||
<meta charset="UTF-8">
|
||
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||
<title>Guida al Simulatore RAID — Per Alunni</title>
|
||
<style>
|
||
@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;900&family=JetBrains+Mono:wght@400;600&display=swap');
|
||
|
||
:root {
|
||
--blue: #1a56db;
|
||
--blue-light: #e8f0fe;
|
||
--green: #057a55;
|
||
--green-light: #def7ec;
|
||
--yellow: #92400e;
|
||
--yellow-light: #fef3c7;
|
||
--red: #9b1c1c;
|
||
--red-light: #fde8e8;
|
||
--purple: #5521b5;
|
||
--purple-light: #edebfe;
|
||
--gray: #374151;
|
||
--gray-light: #f3f4f6;
|
||
--border: #e5e7eb;
|
||
--text: #111827;
|
||
--muted: #6b7280;
|
||
--mono: 'JetBrains Mono', 'Courier New', monospace;
|
||
}
|
||
|
||
* { box-sizing: border-box; margin: 0; padding: 0; }
|
||
|
||
body {
|
||
font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
|
||
font-size: 15px;
|
||
line-height: 1.7;
|
||
color: var(--text);
|
||
background: #fff;
|
||
max-width: 920px;
|
||
margin: 0 auto;
|
||
padding: 40px 32px 80px;
|
||
}
|
||
|
||
@media print {
|
||
body { padding: 20px; font-size: 13px; }
|
||
.page-break { page-break-before: always; }
|
||
h2 { page-break-after: avoid; }
|
||
}
|
||
|
||
/* ── Titolo copertina ── */
|
||
.cover {
|
||
text-align: center;
|
||
padding: 60px 20px 50px;
|
||
border-bottom: 3px solid var(--blue);
|
||
margin-bottom: 48px;
|
||
}
|
||
.cover .label {
|
||
display: inline-block;
|
||
background: var(--blue-light);
|
||
color: var(--blue);
|
||
font-size: 12px;
|
||
font-weight: 700;
|
||
letter-spacing: 1.5px;
|
||
text-transform: uppercase;
|
||
padding: 6px 16px;
|
||
border-radius: 999px;
|
||
margin-bottom: 20px;
|
||
}
|
||
.cover h1 {
|
||
font-size: 36px;
|
||
font-weight: 900;
|
||
color: var(--text);
|
||
line-height: 1.2;
|
||
margin-bottom: 16px;
|
||
}
|
||
.cover .subtitle {
|
||
font-size: 16px;
|
||
color: var(--muted);
|
||
max-width: 560px;
|
||
margin: 0 auto 24px;
|
||
}
|
||
.cover .meta {
|
||
font-size: 13px;
|
||
color: var(--muted);
|
||
}
|
||
|
||
/* ── Tipografia ── */
|
||
h2 {
|
||
font-size: 24px;
|
||
font-weight: 800;
|
||
color: var(--text);
|
||
margin: 48px 0 16px;
|
||
padding-bottom: 10px;
|
||
border-bottom: 2px solid var(--border);
|
||
counter-increment: section;
|
||
}
|
||
h2::before {
|
||
content: counter(section) ". ";
|
||
color: var(--blue);
|
||
}
|
||
h3 {
|
||
font-size: 18px;
|
||
font-weight: 700;
|
||
color: var(--text);
|
||
margin: 32px 0 10px;
|
||
}
|
||
h4 {
|
||
font-size: 15px;
|
||
font-weight: 700;
|
||
color: var(--gray);
|
||
margin: 20px 0 6px;
|
||
text-transform: uppercase;
|
||
letter-spacing: .5px;
|
||
font-size: 12px;
|
||
}
|
||
p { margin-bottom: 14px; }
|
||
ul, ol { padding-left: 22px; margin-bottom: 14px; }
|
||
li { margin-bottom: 6px; }
|
||
strong { font-weight: 700; }
|
||
em { font-style: italic; }
|
||
body { counter-reset: section; }
|
||
|
||
/* ── Callout box ── */
|
||
.callout {
|
||
display: flex;
|
||
gap: 12px;
|
||
padding: 14px 16px;
|
||
border-radius: 10px;
|
||
margin: 20px 0;
|
||
font-size: 14px;
|
||
line-height: 1.6;
|
||
}
|
||
.callout .icon { font-size: 18px; flex-shrink: 0; margin-top: 1px; }
|
||
.callout.info { background: var(--blue-light); border-left: 4px solid var(--blue); color: #1e3a8a; }
|
||
.callout.tip { background: var(--green-light); border-left: 4px solid #10b981; color: var(--green); }
|
||
.callout.warn { background: var(--yellow-light); border-left: 4px solid #f59e0b; color: var(--yellow); }
|
||
.callout.danger { background: var(--red-light); border-left: 4px solid #ef4444; color: var(--red); }
|
||
|
||
/* ── Blocchi di codice ── */
|
||
code {
|
||
font-family: var(--mono);
|
||
font-size: 13px;
|
||
background: var(--gray-light);
|
||
padding: 2px 6px;
|
||
border-radius: 5px;
|
||
color: #1e40af;
|
||
border: 1px solid var(--border);
|
||
}
|
||
pre {
|
||
font-family: var(--mono);
|
||
font-size: 13px;
|
||
background: #1e1e2e;
|
||
color: #cdd6f4;
|
||
padding: 16px 18px;
|
||
border-radius: 10px;
|
||
overflow-x: auto;
|
||
margin: 14px 0;
|
||
line-height: 1.7;
|
||
border: 1px solid #313244;
|
||
}
|
||
pre .comment { color: #6c7086; }
|
||
pre .ok { color: #a6e3a1; }
|
||
pre .warn { color: #f9e2af; }
|
||
pre .err { color: #f38ba8; }
|
||
pre .info { color: #89b4fa; }
|
||
pre .prompt { color: #cba6f7; }
|
||
|
||
/* ── Tabelle ── */
|
||
table {
|
||
width: 100%;
|
||
border-collapse: collapse;
|
||
margin: 16px 0 24px;
|
||
font-size: 14px;
|
||
}
|
||
th {
|
||
background: var(--gray-light);
|
||
text-align: left;
|
||
padding: 10px 14px;
|
||
font-weight: 700;
|
||
border: 1px solid var(--border);
|
||
color: var(--gray);
|
||
font-size: 13px;
|
||
text-transform: uppercase;
|
||
letter-spacing: .3px;
|
||
}
|
||
td {
|
||
padding: 9px 14px;
|
||
border: 1px solid var(--border);
|
||
vertical-align: top;
|
||
}
|
||
tr:nth-child(even) td { background: #fafafa; }
|
||
|
||
/* ── Schede RAID ── */
|
||
.raid-card {
|
||
border: 1px solid var(--border);
|
||
border-radius: 12px;
|
||
overflow: hidden;
|
||
margin: 28px 0;
|
||
}
|
||
.raid-card-header {
|
||
padding: 14px 18px;
|
||
font-weight: 800;
|
||
font-size: 17px;
|
||
display: flex;
|
||
align-items: center;
|
||
gap: 12px;
|
||
}
|
||
.raid-card-header .badge {
|
||
font-size: 11px;
|
||
font-weight: 700;
|
||
padding: 3px 10px;
|
||
border-radius: 999px;
|
||
text-transform: uppercase;
|
||
letter-spacing: .5px;
|
||
}
|
||
.raid-card-body { padding: 18px; }
|
||
.raid-card-body p { margin-bottom: 10px; }
|
||
|
||
.raid0-h { background: #fef9f0; }
|
||
.raid0-h .badge { background: #fde68a; color: #92400e; }
|
||
.raid1-h { background: #f0fdf4; }
|
||
.raid1-h .badge { background: #bbf7d0; color: #065f46; }
|
||
.raid5-h { background: #eff6ff; }
|
||
.raid5-h .badge { background: #bfdbfe; color: #1e40af; }
|
||
.raid6-h { background: #f5f3ff; }
|
||
.raid6-h .badge { background: #ddd6fe; color: #4c1d95; }
|
||
.raid10-h { background: #fdf2f8; }
|
||
.raid10-h .badge { background: #fbcfe8; color: #831843; }
|
||
|
||
/* ── Schede comando ── */
|
||
.cmd-card {
|
||
border: 1px solid var(--border);
|
||
border-radius: 10px;
|
||
margin: 20px 0;
|
||
overflow: hidden;
|
||
}
|
||
.cmd-card-head {
|
||
background: var(--gray-light);
|
||
padding: 10px 16px;
|
||
display: flex;
|
||
justify-content: space-between;
|
||
align-items: center;
|
||
gap: 12px;
|
||
border-bottom: 1px solid var(--border);
|
||
}
|
||
.cmd-card-head code {
|
||
font-size: 14px;
|
||
background: none;
|
||
border: none;
|
||
padding: 0;
|
||
color: #1e40af;
|
||
font-weight: 700;
|
||
}
|
||
.cmd-card-body {
|
||
padding: 14px 16px;
|
||
}
|
||
.cmd-row {
|
||
display: grid;
|
||
grid-template-columns: 120px 1fr;
|
||
gap: 6px 12px;
|
||
margin-bottom: 8px;
|
||
font-size: 14px;
|
||
}
|
||
.cmd-label {
|
||
font-weight: 700;
|
||
color: var(--muted);
|
||
font-size: 12px;
|
||
text-transform: uppercase;
|
||
letter-spacing: .4px;
|
||
padding-top: 2px;
|
||
}
|
||
|
||
/* ── Badge stato ── */
|
||
.status-badge {
|
||
display: inline-block;
|
||
padding: 3px 10px;
|
||
border-radius: 999px;
|
||
font-size: 12px;
|
||
font-weight: 700;
|
||
text-transform: uppercase;
|
||
letter-spacing: .5px;
|
||
}
|
||
.st-ok { background: var(--green-light); color: var(--green); }
|
||
.st-warn { background: var(--yellow-light); color: var(--yellow); }
|
||
.st-err { background: var(--red-light); color: var(--red); }
|
||
.st-info { background: var(--blue-light); color: var(--blue); }
|
||
.st-purple { background: var(--purple-light); color: var(--purple); }
|
||
|
||
/* ── Numbered steps ── */
|
||
.steps { counter-reset: step; }
|
||
.step {
|
||
counter-increment: step;
|
||
display: flex;
|
||
gap: 16px;
|
||
margin-bottom: 18px;
|
||
align-items: flex-start;
|
||
}
|
||
.step-num {
|
||
width: 32px;
|
||
height: 32px;
|
||
border-radius: 50%;
|
||
background: var(--blue);
|
||
color: white;
|
||
font-size: 14px;
|
||
font-weight: 800;
|
||
display: flex;
|
||
align-items: center;
|
||
justify-content: center;
|
||
flex-shrink: 0;
|
||
margin-top: 2px;
|
||
}
|
||
.step-content { flex: 1; }
|
||
.step-content strong { display: block; margin-bottom: 4px; font-size: 15px; }
|
||
|
||
/* ── Indice ── */
|
||
.toc { background: var(--gray-light); border-radius: 12px; padding: 24px 28px; margin-bottom: 40px; }
|
||
.toc h3 { margin: 0 0 14px; font-size: 16px; }
|
||
.toc ol { margin: 0; padding-left: 20px; }
|
||
.toc li { margin-bottom: 5px; font-size: 14px; }
|
||
.toc a { color: var(--blue); text-decoration: none; }
|
||
.toc a:hover { text-decoration: underline; }
|
||
|
||
hr.section { border: none; border-top: 2px solid var(--border); margin: 48px 0; }
|
||
</style>
|
||
</head>
|
||
<body>
|
||
|
||
<!-- COPERTINA -->
|
||
<div class="cover">
|
||
<div class="label">Guida per Alunni</div>
|
||
<h1>Simulatore RAID<br>Guida Completa all'Uso</h1>
|
||
<p class="subtitle">Manuale passo passo per imparare a gestire array RAID con il terminale simulato</p>
|
||
<p class="meta">Informatica di Sistema · ITIS · Versione simulatore v2.3</p>
|
||
</div>
|
||
|
||
<!-- INDICE -->
|
||
<div class="toc">
|
||
<h3>📋 Indice</h3>
|
||
<ol>
|
||
<li><a href="#s1">Introduzione</a></li>
|
||
<li><a href="#s2">Concetti teorici fondamentali</a></li>
|
||
<li><a href="#s3">I livelli RAID nel simulatore</a></li>
|
||
<li><a href="#s4">L'interfaccia del simulatore</a></li>
|
||
<li><a href="#s5">Avvio del simulatore</a></li>
|
||
<li><a href="#s6">Il terminale simulato</a></li>
|
||
<li><a href="#s7">Tutti i comandi disponibili</a></li>
|
||
<li><a href="#s8">Come diagnosticare e risolvere un problema RAID</a></li>
|
||
<li><a href="#s9">Stati dei dischi e del volume</a></li>
|
||
<li><a href="#s10">La documentazione integrata</a></li>
|
||
<li><a href="#s11">Il report finale</a></li>
|
||
<li><a href="#s12">Errori comuni da evitare</a></li>
|
||
<li><a href="#s13">Conclusione</a></li>
|
||
</ol>
|
||
</div>
|
||
|
||
|
||
<!-- ══════════════════════════════════════════════════════════ -->
|
||
<h2 id="s1">Introduzione</h2>
|
||
|
||
<p>Il <strong>Simulatore RAID</strong> è uno strumento didattico realizzato come pagina HTML autonoma, che non richiede alcuna installazione né connessione a internet. È pensato per imparare a gestire array RAID software in ambiente Linux, utilizzando un terminale simulato che riproduce i comandi reali del sistema operativo.</p>
|
||
|
||
<p>Il simulatore permette di sperimentare in modo sicuro tutte le situazioni che si possono incontrare nella gestione reale di un array RAID: la creazione dell'array, il guasto di un disco, la diagnosi del problema, la sostituzione del disco guasto e la ricostruzione dei dati. Tutte queste operazioni vengono eseguite attraverso comandi digitati nel terminale, esattamente come si farebbe su un vero server Linux.</p>
|
||
|
||
<h3>A cosa serve questo strumento</h3>
|
||
<p>Usare il simulatore permette di:</p>
|
||
<ul>
|
||
<li>Capire come funzionano i diversi livelli RAID (0, 1, 5, 6, 10) nella pratica;</li>
|
||
<li>Esercitarsi con i comandi <code>mdadm</code>, <code>smartctl</code>, <code>dmesg</code> e tutti gli altri strumenti Linux per la gestione dei dischi;</li>
|
||
<li>Imparare a leggere lo stato dell'array e interpretare i messaggi di sistema;</li>
|
||
<li>Praticare la procedura completa di recovery da un guasto senza rischiare dati reali;</li>
|
||
<li>Sviluppare un metodo di lavoro ordinato: prima diagnostica, poi azione.</li>
|
||
</ul>
|
||
|
||
<div class="callout info">
|
||
<div class="icon">💡</div>
|
||
<div>Il simulatore funziona completamente offline. Basta aprire il file HTML con qualsiasi browser moderno. Tutto il codice e i dati sono contenuti in un unico file.</div>
|
||
</div>
|
||
|
||
|
||
<!-- ══════════════════════════════════════════════════════════ -->
|
||
<h2 id="s2">Concetti teorici fondamentali</h2>
|
||
|
||
<h3>Che cos'è un RAID</h3>
|
||
<p><strong>RAID</strong> è l'acronimo di <em>Redundant Array of Independent Disks</em>, che significa "gruppo ridondante di dischi indipendenti". Si tratta di una tecnologia che consente di unire più dischi fisici in un unico volume logico, con lo scopo di aumentare le prestazioni, la capacità o la tolleranza ai guasti, oppure una combinazione di questi tre obiettivi.</p>
|
||
|
||
<p>L'idea di base è semplice: anziché avere un solo disco grande che, se si guasta, fa perdere tutti i dati, si usano più dischi in modo coordinato. A seconda di come vengono organizzati, il sistema può continuare a funzionare anche se uno o più dischi si guastano.</p>
|
||
|
||
<h3>Prestazioni, ridondanza e tolleranza ai guasti</h3>
|
||
<p>Questi tre concetti sono fondamentali per capire le differenze tra i livelli RAID:</p>
|
||
<ul>
|
||
<li><strong>Prestazioni:</strong> la velocità di lettura e scrittura dei dati. Alcuni livelli RAID distribuiscono i dati su più dischi, il che permette di leggere e scrivere in parallelo, aumentando la velocità.</li>
|
||
<li><strong>Ridondanza:</strong> la presenza di copie o informazioni di recupero dei dati. Grazie alla ridondanza, se un disco si guasta, i dati non vanno persi.</li>
|
||
<li><strong>Tolleranza ai guasti (fault tolerance):</strong> il numero massimo di dischi che possono guastarsi senza che l'array perda i dati. Un array con tolleranza 1 sopravvive al guasto di un solo disco; con tolleranza 2 può sopravvivere al guasto di due dischi contemporaneamente.</li>
|
||
</ul>
|
||
|
||
<div class="callout warn">
|
||
<div class="icon">⚠️</div>
|
||
<div><strong>Attenzione:</strong> il RAID non sostituisce il backup. Un array RAID protegge dai guasti hardware dei dischi, ma non protegge da cancellazioni accidentali, virus, incendi o altri tipi di perdita dei dati. Il backup rimane sempre necessario.</div>
|
||
</div>
|
||
|
||
<h3>Striping</h3>
|
||
<p>Lo <strong>striping</strong> (a strisce) è la tecnica di distribuire i dati in blocchi sequenziali su più dischi. Quando si scrive un file, i blocchi vengono scritti in parallelo su dischi diversi. Quando si legge, i blocchi vengono letti in parallelo. Il risultato è un aumento della velocità di trasferimento proporzionale al numero di dischi. Il lato negativo è che se un solo disco si guasta, tutti i dati dell'intero array sono persi, perché ogni file è spezzettato su più dischi e nessun disco contiene i dati completi.</p>
|
||
|
||
<h3>Mirroring</h3>
|
||
<p>Il <strong>mirroring</strong> (specchio) è la tecnica di copiare esattamente gli stessi dati su due o più dischi. Ogni dato scritto viene scritto su tutti i dischi in parallelo. In questo modo, se un disco si guasta, i dati sono ancora presenti sugli altri dischi. Il lato negativo è che si spreca capacità: con due dischi da 1 TB si ottiene solo 1 TB utile, perché l'altro disco è la copia esatta del primo.</p>
|
||
|
||
<h3>Parità</h3>
|
||
<p>La <strong>parità</strong> è una soluzione intermedia tra striping puro e mirroring. Invece di copiare tutti i dati, si calcola un'informazione di controllo chiamata appunto "parità" che permette di ricostruire i dati di un disco mancante. La parità viene calcolata con un'operazione logica chiamata XOR (OR esclusivo): se si conoscono tutti i blocchi tranne uno, si può ricostruire il blocco mancante combinando gli altri con la parità. Questo sistema permette di avere ridondanza sprecando meno spazio rispetto al mirroring.</p>
|
||
|
||
<h3>RAID software vs RAID hardware</h3>
|
||
<p>Il RAID può essere implementato in due modi:</p>
|
||
<ul>
|
||
<li><strong>RAID hardware:</strong> un controller fisico (una scheda dedicata) gestisce autonomamente i dischi, presentando al sistema operativo un unico volume logico. È trasparente al sistema operativo ed è molto performante, ma costa di più.</li>
|
||
<li><strong>RAID software:</strong> è il sistema operativo stesso a gestire i dischi. In Linux, il programma responsabile è <code>mdadm</code>. Il RAID software è meno costoso e più flessibile, ma utilizza risorse del processore per i calcoli di parità.</li>
|
||
</ul>
|
||
<p>Il simulatore riproduce il comportamento di un <strong>RAID software Linux</strong> gestito tramite <code>mdadm</code>.</p>
|
||
|
||
|
||
<!-- ══════════════════════════════════════════════════════════ -->
|
||
<h2 id="s3">I livelli RAID nel simulatore</h2>
|
||
|
||
<p>Il simulatore supporta cinque livelli RAID: 0, 1, 5, 6 e 10. Ognuno ha caratteristiche molto diverse. È importante conoscerle bene per capire cosa succede durante le simulazioni.</p>
|
||
|
||
<div class="raid-card">
|
||
<div class="raid-card-header raid0-h">
|
||
<span>RAID 0</span>
|
||
<span class="badge">Striping puro</span>
|
||
</div>
|
||
<div class="raid-card-body">
|
||
<p><strong>Definizione semplice:</strong> i dati vengono distribuiti a strisce su tutti i dischi dell'array. Non c'è alcuna ridondanza.</p>
|
||
<p><strong>Funzionamento:</strong> ogni blocco di dati viene scritto su un disco diverso in modo ciclico. Un file da 3 blocchi viene scritto: blocco 1 su sda, blocco 2 su sdb, blocco 3 su sdc. La lettura e la scrittura avvengono in parallelo su tutti i dischi.</p>
|
||
<table>
|
||
<tr><th>Parametro</th><th>Valore</th></tr>
|
||
<tr><td>Dischi minimi</td><td>2</td></tr>
|
||
<tr><td>Capacità utile</td><td>N × dimensione disco</td></tr>
|
||
<tr><td>Fault tolerance</td><td>0 (nessuna)</td></tr>
|
||
</table>
|
||
<p><strong>Vantaggi:</strong> massima velocità di lettura e scrittura; tutta la capacità dei dischi è utilizzabile.</p>
|
||
<p><strong>Svantaggi:</strong> se un solo disco si guasta, l'intero array è perso. I dati non sono recuperabili tramite RAID.</p>
|
||
<p><strong>Esempio pratico nel simulatore:</strong> con 3 dischi da 1 TB ottieni 3 TB utili, ma se uno si guasta l'array passa immediatamente a FAILED.</p>
|
||
<p><strong>Quando conviene:</strong> solo quando la velocità è l'unica priorità e si dispone di un backup completo e aggiornato. Non adatto per dati importanti.</p>
|
||
<div class="callout danger"><div class="icon">❌</div><div>RAID 0 non ha tolleranza ai guasti. Un guasto = dati persi. Serve sempre un backup separato.</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="raid-card">
|
||
<div class="raid-card-header raid1-h">
|
||
<span>RAID 1</span>
|
||
<span class="badge">Mirroring</span>
|
||
</div>
|
||
<div class="raid-card-body">
|
||
<p><strong>Definizione semplice:</strong> tutti i dati vengono copiati su ogni disco dell'array. Ogni disco è uno specchio identico degli altri.</p>
|
||
<p><strong>Funzionamento:</strong> ogni operazione di scrittura viene replicata su tutti i dischi contemporaneamente. In lettura, i dati possono essere letti da qualsiasi disco, il che può migliorare le prestazioni di lettura.</p>
|
||
<table>
|
||
<tr><th>Parametro</th><th>Valore</th></tr>
|
||
<tr><td>Dischi minimi</td><td>2</td></tr>
|
||
<tr><td>Capacità utile</td><td>1 × dimensione disco (indipendentemente dal numero di dischi)</td></tr>
|
||
<tr><td>Fault tolerance</td><td>N−1 (possono guastarsi tutti i dischi tranne uno)</td></tr>
|
||
</table>
|
||
<p><strong>Vantaggi:</strong> massima ridondanza; il sistema continua a funzionare anche se rimane un solo disco. Ottimo per dati critici di dimensioni contenute.</p>
|
||
<p><strong>Svantaggi:</strong> la capacità utile è quella di un singolo disco. Con 4 dischi da 1 TB si ha solo 1 TB utile.</p>
|
||
<p><strong>Esempio pratico nel simulatore:</strong> con 2 dischi da 1 TB si ottiene 1 TB utile; se sda si guasta, sdb contiene ancora tutti i dati.</p>
|
||
<p><strong>Quando conviene:</strong> per il disco del sistema operativo, per database di piccole dimensioni, per qualsiasi dati dove l'affidabilità è più importante della capacità.</p>
|
||
<div class="callout tip"><div class="icon">✅</div><div>RAID 1 con 2 dischi sopporta il guasto di un disco. Con più dischi la tolleranza aumenta, ma la capacità resta quella di un singolo disco.</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="raid-card">
|
||
<div class="raid-card-header raid5-h">
|
||
<span>RAID 5</span>
|
||
<span class="badge">Parità distribuita</span>
|
||
</div>
|
||
<div class="raid-card-body">
|
||
<p><strong>Definizione semplice:</strong> i dati vengono distribuiti su tutti i dischi insieme a informazioni di parità che permettono di ricostruire i dati in caso di guasto di un disco.</p>
|
||
<p><strong>Funzionamento:</strong> i dati vengono scritti a strisce su N−1 dischi; il disco rimanente contiene la parità (il risultato XOR degli altri blocchi). La parità è distribuita in modo rotante su tutti i dischi, evitando il collo di bottiglia di un singolo disco dedicato alla parità.</p>
|
||
<table>
|
||
<tr><th>Parametro</th><th>Valore</th></tr>
|
||
<tr><td>Dischi minimi</td><td>3</td></tr>
|
||
<tr><td>Capacità utile</td><td>(N−1) × dimensione disco</td></tr>
|
||
<tr><td>Fault tolerance</td><td>1 (un solo disco può guastarsi)</td></tr>
|
||
</table>
|
||
<p><strong>Vantaggi:</strong> buon bilanciamento tra prestazioni, capacità e ridondanza. È il livello RAID più diffuso per NAS e file server.</p>
|
||
<p><strong>Svantaggi:</strong> se due dischi si guastano contemporaneamente, l'array è FAILED e i dati sono persi. Il rebuild è lento con dischi grandi e mette sotto sforzo i dischi rimanenti.</p>
|
||
<p><strong>Esempio pratico nel simulatore:</strong> con 4 dischi da 1 TB si ottiene 3 TB utili. Se sdb si guasta, l'array è DEGRADED ma i dati sono ancora accessibili. Dopo aver aggiunto uno spare e ricostruito, si torna a OK.</p>
|
||
<p><strong>Quando conviene:</strong> per NAS domestici e di piccola impresa, file server, storage con 3–8 dischi.</p>
|
||
<div class="callout warn"><div class="icon">⚠️</div><div>Con RAID 5 e dischi molto grandi, durante il rebuild un secondo guasto porta a FAILED. Per array con dischi da 4+ TB, considera RAID 6.</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="raid-card">
|
||
<div class="raid-card-header raid6-h">
|
||
<span>RAID 6</span>
|
||
<span class="badge">Doppia parità</span>
|
||
</div>
|
||
<div class="raid-card-body">
|
||
<p><strong>Definizione semplice:</strong> come RAID 5, ma con due blocchi di parità (P e Q) invece di uno. Questo permette di sopravvivere al guasto di due dischi contemporaneamente.</p>
|
||
<p><strong>Funzionamento:</strong> due algoritmi di parità diversi (basati su campi di Galois) vengono usati per calcolare P e Q. Questi due blocchi di parità vengono distribuiti su tutti i dischi in modo rotante. Grazie a P e Q è possibile ricostruire i dati anche se mancano due dischi.</p>
|
||
<table>
|
||
<tr><th>Parametro</th><th>Valore</th></tr>
|
||
<tr><td>Dischi minimi</td><td>4</td></tr>
|
||
<tr><td>Capacità utile</td><td>(N−2) × dimensione disco</td></tr>
|
||
<tr><td>Fault tolerance</td><td>2 (due dischi possono guastarsi)</td></tr>
|
||
</table>
|
||
<p><strong>Vantaggi:</strong> tolleranza a due guasti contemporanei; ideale per array con molti dischi grandi dove il rebuild è lungo.</p>
|
||
<p><strong>Svantaggi:</strong> le scritture sono più lente rispetto a RAID 5; si perdono 2 dischi di capacità invece di 1.</p>
|
||
<p><strong>Esempio pratico nel simulatore:</strong> con 6 dischi da 1 TB si ottiene 4 TB utili. Con due dischi FAILED l'array è DEGRADED ma funzionante; il rebuild avviene un disco alla volta.</p>
|
||
<p><strong>Quando conviene:</strong> per storage enterprise, cloud, array con 8 o più dischi grandi, dove il tempo di rebuild può durare giorni e il rischio di un secondo guasto durante il rebuild è reale.</p>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="raid-card">
|
||
<div class="raid-card-header raid10-h">
|
||
<span>RAID 10</span>
|
||
<span class="badge">Stripe di mirror</span>
|
||
</div>
|
||
<div class="raid-card-body">
|
||
<p><strong>Definizione semplice:</strong> combina il mirroring (RAID 1) con lo striping (RAID 0). I dischi vengono prima organizzati in coppie mirror, poi le coppie vengono messe in stripe.</p>
|
||
<p><strong>Funzionamento:</strong> con 4 dischi, sda e sdb formano una coppia mirror (mirror 1), sdc e sdd formano un'altra coppia mirror (mirror 2). I dati vengono scritti in stripe su mirror 1 e mirror 2. Ogni disco ha un gemello che contiene esattamente gli stessi dati.</p>
|
||
<table>
|
||
<tr><th>Parametro</th><th>Valore</th></tr>
|
||
<tr><td>Dischi minimi</td><td>4 (numero pari)</td></tr>
|
||
<tr><td>Capacità utile</td><td>(N/2) × dimensione disco</td></tr>
|
||
<tr><td>Fault tolerance</td><td>1 per coppia mirror (purché non si guastino entrambi i dischi della stessa coppia)</td></tr>
|
||
</table>
|
||
<p><strong>Vantaggi:</strong> prestazioni eccellenti sia in lettura che in scrittura; rebuild molto più veloce rispetto a RAID 5/6 perché si copia da un mirror.</p>
|
||
<p><strong>Svantaggi:</strong> si usa solo il 50% della capacità; richiede almeno 4 dischi; costoso.</p>
|
||
<p><strong>Caso critico nel simulatore:</strong> se si guastano entrambi i dischi di una coppia mirror (es. sda e sdb), l'array diventa immediatamente FAILED, indipendentemente dalle altre coppie.</p>
|
||
<p><strong>Quando conviene:</strong> database SQL ad alto traffico, virtualizzazione, applicazioni che richiedono sia velocità che alta affidabilità.</p>
|
||
<div class="callout danger"><div class="icon">❗</div><div>In RAID 10, la perdita di entrambi i dischi di una coppia mirror causa FAILED dell'intero array. Questo è diverso da RAID 5/6 dove conta solo il numero totale di guasti.</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<h3>Livelli RAID storici (non usabili nel simulatore)</h3>
|
||
<p>Nella sezione documentazione del simulatore vengono citati anche RAID 2, 3 e 4. Questi sono livelli storici raramente usati oggi:</p>
|
||
<ul>
|
||
<li><strong>RAID 2:</strong> usava codici di Hamming per il controllo degli errori. Completamente obsoleto.</li>
|
||
<li><strong>RAID 3:</strong> simile a RAID 5 ma con un disco dedicato alla parità (non rotante). La parità fissa crea un collo di bottiglia. Obsoleto.</li>
|
||
<li><strong>RAID 4:</strong> come RAID 3 ma con blocchi più grandi. Anche questo obsoleto, sostituito da RAID 5.</li>
|
||
</ul>
|
||
<p>Questi livelli non sono simulabili nel laboratorio: servono solo per la cultura generale.</p>
|
||
|
||
<table>
|
||
<tr><th>Livello</th><th>Min dischi</th><th>Capacità utile</th><th>Fault tolerance</th><th>Uso tipico</th></tr>
|
||
<tr><td>RAID 0</td><td>2</td><td>N × size</td><td>0</td><td>Cache, editing video</td></tr>
|
||
<tr><td>RAID 1</td><td>2</td><td>1 × size</td><td>N−1</td><td>OS, database piccoli</td></tr>
|
||
<tr><td>RAID 5</td><td>3</td><td>(N−1) × size</td><td>1</td><td>NAS, file server</td></tr>
|
||
<tr><td>RAID 6</td><td>4</td><td>(N−2) × size</td><td>2</td><td>Enterprise, cloud</td></tr>
|
||
<tr><td>RAID 10</td><td>4 (pari)</td><td>(N/2) × size</td><td>1 per coppia</td><td>Database ad alto I/O</td></tr>
|
||
</table>
|
||
|
||
|
||
<!-- ══════════════════════════════════════════════════════════ -->
|
||
<h2 id="s4">L'interfaccia del simulatore</h2>
|
||
|
||
<p>Aprendo il file HTML nel browser, si vedono tre aree principali identificate da tre schede (tab) in alto: <strong>LAB</strong>, <strong>ESERCIZI</strong> e <strong>DOCUMENTAZIONE</strong>. In questa sezione vengono descritte tutte le parti visibili dell'interfaccia.</p>
|
||
|
||
<h3>Le tre schede principali</h3>
|
||
<ul>
|
||
<li><strong>🧪 LAB:</strong> è la scheda principale di lavoro. Contiene i controlli per creare l'array, la dashboard con lo stato e le statistiche, la griglia dei dischi e il terminale simulato.</li>
|
||
<li><strong>🎓 ESERCIZI:</strong> permette di generare una prova con un codice univoco e uno scenario casuale. Pensata per le verifiche in classe.</li>
|
||
<li><strong>📚 DOCUMENTAZIONE:</strong> contiene una guida teorica completa ai livelli RAID e le procedure di diagnosi e recovery, direttamente nel simulatore.</li>
|
||
</ul>
|
||
|
||
<h3>Il pulsante Teacher ON/OFF</h3>
|
||
<p>Accanto alle schede si trova il pulsante <strong>Teacher: OFF/ON</strong>. Quando è disattivato (stato normale per gli studenti), i dischi nella griglia non sono cliccabili e il comando <code>solution</code> non è disponibile. Quando viene attivato in modalità Teacher, diventa possibile cambiare manualmente lo stato dei dischi cliccandoci sopra, e il comando <code>solution</code> mostra la soluzione dello scenario.</p>
|
||
|
||
<h3>Sezione controlli (scheda LAB, colonna sinistra)</h3>
|
||
<p>Nella parte alta della colonna sinistra si trovano i controlli per configurare l'array:</p>
|
||
<ul>
|
||
<li><strong>Livello RAID:</strong> menu a tendina con le opzioni RAID 0, 1, 5, 6, 10. Permette di scegliere il tipo di array da simulare.</li>
|
||
<li><strong>Numero dischi:</strong> campo numerico (da 2 a 12). Il simulatore impone automaticamente il minimo richiesto dal livello RAID scelto, e per RAID 10 arrotonda al numero pari.</li>
|
||
<li><strong>Size disco (GB):</strong> dimensione in gigabyte di ogni disco. Tutti i dischi hanno la stessa dimensione.</li>
|
||
</ul>
|
||
|
||
<h3>Pulsanti principali</h3>
|
||
<ul>
|
||
<li><strong>Crea / Reset array:</strong> crea un nuovo array con i parametri selezionati, oppure resetta quello esistente. Azzera anche score, hints e azioni.</li>
|
||
<li><strong>Reset stati:</strong> riporta tutti i dischi allo stato OK senza ricreare l'array. Utile per tornare alla situazione iniziale senza perdere la configurazione.</li>
|
||
<li><strong>Guasto random:</strong> introduce un guasto casuale su uno dei dischi OK. Il tipo di guasto (FAILED, CRC, OVERHEAT, SLOW) viene scelto in modo casuale.</li>
|
||
<li><strong>Esercizio random:</strong> carica uno scenario di esercizio scelto casualmente tra quelli disponibili.</li>
|
||
</ul>
|
||
|
||
<h3>Dashboard — Capacità utile e Fault tolerance</h3>
|
||
<p>Subito sotto i controlli si trovano due riquadri statistici:</p>
|
||
<ul>
|
||
<li><strong>Capacità utile:</strong> mostra la capacità totale utilizzabile dell'array, calcolata in base al livello RAID, al numero di dischi e alla dimensione di ogni disco. La formula viene mostrata sotto il valore (es. <em>(N−1) × size</em> per RAID 5).</li>
|
||
<li><strong>Fault tolerance:</strong> mostra quanti dischi possono guastarsi senza perdere i dati. Per RAID 10 mostra "1 guasto per coppia (non nella stessa mirror)".</li>
|
||
</ul>
|
||
|
||
<h3>Stato del volume</h3>
|
||
<p>La barra di stato mostra lo stato attuale dell'array con una spia luminosa colorata e il testo STATUS:</p>
|
||
<ul>
|
||
<li><span class="status-badge st-ok">OK</span> — spia verde: array funzionante, nessun problema.</li>
|
||
<li><span class="status-badge st-warn">DEGRADED</span> — spia gialla: array funzionante ma con uno o più dischi guasti o rimossi. I dati sono ancora accessibili ma il sistema è a rischio.</li>
|
||
<li><span class="status-badge st-err">FAILED</span> — spia rossa: array non funzionante. I dati non sono accessibili.</li>
|
||
</ul>
|
||
<p>Accanto alla spia si trova una riga di testo più piccola che mostra i dettagli: livello RAID, numero di membri, dischi FAILED, dischi REMOVED, spares presenti e percentuale di rebuild se in corso.</p>
|
||
|
||
<h3>Telemetria (simulata)</h3>
|
||
<p>Il riquadro Telemetria mostra quattro valori che cambiano in tempo reale in base allo stato dei dischi:</p>
|
||
<ul>
|
||
<li><strong>Temperature avg:</strong> temperatura media dei dischi attivi. Sale se ci sono dischi in OVERHEAT.</li>
|
||
<li><strong>IOPS (sim):</strong> operazioni al secondo stimate. Diminuisce in caso di guasti, rebuild o dischi lenti.</li>
|
||
<li><strong>CRC errors:</strong> numero di errori CRC rilevati sui dischi. Aumenta se ci sono dischi in stato CRC.</li>
|
||
<li><strong>Reallocated:</strong> numero di settori ricollocati sui dischi. Aumenta su dischi FAILED.</li>
|
||
</ul>
|
||
|
||
<h3>Timer e verifica</h3>
|
||
<p>Il riquadro Verifica permette di impostare un timer per le verifiche a tempo:</p>
|
||
<ul>
|
||
<li><strong>5 min / 10 min:</strong> avvia un conto alla rovescia. Allo scadere del tempo appare un messaggio nel terminale con il punteggio finale.</li>
|
||
<li><strong>OFF:</strong> disattiva il timer.</li>
|
||
<li><strong>Score:</strong> punteggio accumulato completando le azioni corrette negli scenari.</li>
|
||
<li><strong>Hints used:</strong> numero di volte che è stato usato il comando <code>hint</code>. Ogni hint costa 3 punti.</li>
|
||
<li><strong>⬇ Scarica report:</strong> equivalente al comando <code>export</code> nel terminale. Scarica il report in formato .txt.</li>
|
||
</ul>
|
||
|
||
<h3>Griglia dei dischi</h3>
|
||
<p>La griglia mostra un riquadro per ogni disco dell'array. Ogni riquadro visualizza il nome del dispositivo (es. <code>/dev/sda</code>), lo stato del disco e, se in rebuild, una barra di avanzamento. Il colore del bordo indica lo stato: verde per OK, rosso per FAILED, giallo per rebuilding o OVERHEAT, grigio per REMOVED, blu per SPARE o CRC.</p>
|
||
|
||
<h3>Scenario</h3>
|
||
<p>Il riquadro Scenario mostra l'obiettivo dello scenario corrente, con la descrizione del problema e le azioni richieste. Quando si completa correttamente lo scenario, compare "✅ RISOLTO". Se la modalità Teacher è attiva, viene mostrata anche la soluzione.</p>
|
||
|
||
<h3>Parità RAID5 (visual)</h3>
|
||
<p>Accanto al terminale, questo riquadro mostra una rappresentazione testuale della distribuzione delle stripe di parità quando RAID 5 è selezionato. Utile per capire visivamente come funziona la parità rotante.</p>
|
||
|
||
<h3>Il terminale simulato</h3>
|
||
<p>Il terminale è l'elemento centrale del simulatore. Occupa la colonna destra della scheda LAB. Si presenta come una finestra nera con prompt dei comandi. I comandi vengono digitati nel campo di testo in basso e inviati con il tasto Invio o il pulsante "Invia". L'output appare in colori diversi a seconda del tipo di messaggio.</p>
|
||
|
||
<h3>Scheda ESERCIZI</h3>
|
||
<p>Nella scheda ESERCIZI si trovano due blocchi:</p>
|
||
<ul>
|
||
<li><strong>Genera prova:</strong> crea una prova con un codice univoco (es. <code>XK7M2P9Q</code>), uno scenario scelto a caso e un obiettivo. Il pulsante "Carica questa prova nel LAB" trasferisce lo scenario nel terminale.</li>
|
||
<li><strong>Dettagli prova:</strong> mostra il codice, lo scenario, il seed e l'obiettivo della prova generata.</li>
|
||
</ul>
|
||
|
||
|
||
<!-- ══════════════════════════════════════════════════════════ -->
|
||
<h2 id="s5">Avvio del simulatore: procedura base</h2>
|
||
|
||
<div class="steps">
|
||
<div class="step">
|
||
<div class="step-num">1</div>
|
||
<div class="step-content">
|
||
<strong>Aprire il file nel browser</strong>
|
||
Fare doppio clic sul file HTML. Si apre nel browser predefinito. Non è necessaria alcuna connessione a internet. La scheda attiva è LAB.
|
||
</div>
|
||
</div>
|
||
<div class="step">
|
||
<div class="step-num">2</div>
|
||
<div class="step-content">
|
||
<strong>Scegliere il livello RAID</strong>
|
||
Nel menu a tendina "Livello RAID" selezionare il livello desiderato: RAID 0, 1, 5, 6 o 10. La scelta influenza immediatamente la capacità utile e la fault tolerance visualizzate sotto.
|
||
</div>
|
||
</div>
|
||
<div class="step">
|
||
<div class="step-num">3</div>
|
||
<div class="step-content">
|
||
<strong>Impostare il numero di dischi</strong>
|
||
Nel campo "Numero dischi" inserire il numero di dischi desiderato (da 2 a 12). Il simulatore correggerà automaticamente il valore se è inferiore al minimo richiesto dal livello RAID scelto. Per RAID 10 il numero sarà arrotondato al pari.
|
||
</div>
|
||
</div>
|
||
<div class="step">
|
||
<div class="step-num">4</div>
|
||
<div class="step-content">
|
||
<strong>Impostare la dimensione del disco</strong>
|
||
Nel campo "Size disco (GB)" inserire la dimensione in gigabyte di ogni disco. Il valore predefinito è 1000 GB (1 TB). Tutti i dischi hanno la stessa dimensione.
|
||
</div>
|
||
</div>
|
||
<div class="step">
|
||
<div class="step-num">5</div>
|
||
<div class="step-content">
|
||
<strong>Creare l'array</strong>
|
||
Cliccare il pulsante <strong>Crea / Reset array</strong>. Il simulatore crea l'array con i parametri scelti. Nel terminale appare il messaggio "Array creato". Score e hints vengono azzerati.
|
||
</div>
|
||
</div>
|
||
<div class="step">
|
||
<div class="step-num">6</div>
|
||
<div class="step-content">
|
||
<strong>Leggere i valori iniziali</strong>
|
||
Osservare la dashboard: la capacità utile e la fault tolerance mostrano i valori calcolati. La spia deve essere verde e lo stato deve essere OK. La griglia mostra tutti i dischi con bordo verde e stato "OK".
|
||
</div>
|
||
</div>
|
||
<div class="step">
|
||
<div class="step-num">7</div>
|
||
<div class="step-content">
|
||
<strong>Verificare nel terminale</strong>
|
||
Digitare <code>cat /proc/mdstat</code> e premere Invio. L'output mostra lo stato dell'array, il livello RAID, tutti i dischi membri e lo stato [UUU...] (U = Up, _ = mancante, R = rebuilding). Con tutti i dischi OK si vedono solo "U".
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
<h3>Come interpretare gli stati OK, DEGRADED, FAILED</h3>
|
||
<p><strong>STATUS: OK</strong> — L'array funziona normalmente. Tutti i dischi sono operativi. I dati sono accessibili e la ridondanza è integra (per i livelli che ce l'hanno). Si può lavorare normalmente.</p>
|
||
<p><strong>STATUS: DEGRADED</strong> — L'array funziona ancora, ma uno o più dischi sono FAILED o REMOVED. I dati sono ancora accessibili, ma la ridondanza è ridotta o assente. Se si guasta un altro disco (nei livelli con tolleranza 1), si rischia il FAILED. Bisogna intervenire il prima possibile.</p>
|
||
<p><strong>STATUS: FAILED</strong> — L'array non funziona. I dati non sono accessibili. Il numero di guasti ha superato la tolleranza del livello RAID. L'unica soluzione è il restore da backup. I comandi di filesystem (mount, ls, cat) restituiscono errore.</p>
|
||
|
||
|
||
<!-- ══════════════════════════════════════════════════════════ -->
|
||
<h2 id="s6">Il terminale simulato</h2>
|
||
|
||
<p>Il terminale è lo strumento principale con cui si lavora nel simulatore. Riproduce il comportamento di un terminale Linux reale, con un prompt, la possibilità di digitare comandi, la cronologia con i tasti freccia e output a colori.</p>
|
||
|
||
<h3>Come si usa</h3>
|
||
<p>Il campo di inserimento si trova in basso nel riquadro del terminale, accanto al prompt. Il prompt mostra lo stato attuale dell'array nella forma <code>raidlab(OK)$</code> o <code>raidlab(DEGRADED)$</code> o <code>raidlab(FAILED)$</code>. Questo è un indicatore prezioso: il prompt stesso rivela lo stato dell'array.</p>
|
||
<p>Per inviare un comando si preme <strong>Invio</strong> oppure il pulsante "Invia". Per scorrere la cronologia dei comandi precedenti si usano i <strong>tasti freccia su e giù</strong>.</p>
|
||
|
||
<h3>Come leggere l'output</h3>
|
||
<p>L'output del terminale usa colori diversi con significato preciso:</p>
|
||
<ul>
|
||
<li><span style="color:#6c7086">Grigio/dimmed</span>: output normale di informazioni (stato array, elenco dischi, ecc.).</li>
|
||
<li><span style="color:#a6e3a1">Verde</span>: operazione completata con successo.</li>
|
||
<li><span style="color:#f9e2af">Giallo</span>: avviso (warning). Attenzione, qualcosa non va ma non è ancora critico.</li>
|
||
<li><span style="color:#f38ba8">Rosso</span>: errore. Il comando non ha avuto effetto o c'è un problema grave.</li>
|
||
<li><span style="color:#89b4fa">Blu/info</span>: informazione di sistema o messaggi di stato.</li>
|
||
</ul>
|
||
|
||
<p>I chip in cima al terminale mostrano lo stato del filesystem (<code>fs: none</code> → <code>fs: unmounted</code> → <code>fs: mounted@/mnt</code>) e lo stato dell'esercizio (<code>exercise: on/off</code>).</p>
|
||
|
||
<div class="callout info">
|
||
<div class="icon">💡</div>
|
||
<div>Se si digita un comando sbagliato, il terminale risponde con un messaggio in rosso che suggerisce di digitare <code>help</code>. Non preoccuparsi: i comandi errati non producono effetti collaterali.</div>
|
||
</div>
|
||
|
||
|
||
<!-- ══════════════════════════════════════════════════════════ -->
|
||
<h2 id="s7">Tutti i comandi disponibili</h2>
|
||
|
||
<p>Di seguito vengono descritti tutti i comandi realmente presenti nel simulatore, nel formato: cosa fa, quando si usa, esempio e risultato atteso.</p>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>help</code><span class="status-badge st-info">Utilità</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fa</div><div>Mostra l'elenco completo di tutti i comandi disponibili nel simulatore con una breve descrizione.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Quando usarlo</div><div>All'inizio di una sessione o quando non si ricorda la sintassi di un comando.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Esempio</div><div><code>help</code></div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Interpretazione</div><div>Non ha effetti sull'array. Serve solo come riferimento rapido.</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>clear</code><span class="status-badge st-info">Utilità</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fa</div><div>Cancella tutto il contenuto del terminale, pulendo lo schermo.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Quando usarlo</div><div>Quando il terminale è diventato troppo affollato e si vuole ricominciare con uno schermo pulito.</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>scenario list</code><span class="status-badge st-info">Scenari</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fa</div><div>Mostra l'elenco di tutti gli scenari disponibili nel simulatore, con i loro nomi identificativi.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Risultato atteso</div><div>Elenco di nomi come: <code>raid0_fail</code>, <code>raid1_onefail</code>, <code>raid5_1fail</code>, <code>raid5_2fail</code>, <code>raid6_2fail</code>, <code>raid10_pairfail</code>, <code>rebuild_interrupted</code>, <code>wrong_size_spare</code>, <code>crc_errors</code>, <code>overheat</code>.</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>scenario load <nome></code><span class="status-badge st-info">Scenari</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fa</div><div>Carica uno scenario specifico: configura l'array con i dischi e il guasto preimpostato dallo scenario, mostra l'obiettivo nel riquadro Scenario.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Esempio</div><div><code>scenario load raid5_1fail</code></div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Risultato atteso</div><div>L'array viene ricreato con la configurazione dello scenario: alcuni dischi potrebbero essere già FAILED. Nel riquadro Scenario appare l'obiettivo da raggiungere.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Interpretazione</div><div>Leggere sempre l'obiettivo dello scenario prima di iniziare. Capire cosa si deve fare prima di agire.</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>cat /proc/mdstat</code><span class="status-badge st-ok">Diagnosi</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fa</div><div>Legge il file virtuale del kernel che contiene lo stato di tutti gli array RAID attivi. È il primo comando da eseguire in qualsiasi situazione.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Quando usarlo</div><div>Sempre come primo passo: all'inizio, dopo un guasto, durante il rebuild, per monitorare lo stato.</div></div>
|
||
<pre><span class="prompt">raidlab(DEGRADED)$</span> cat /proc/mdstat
|
||
Personalities : [raid0] [raid1] [raid5] [raid6] [raid10]
|
||
md0 : active raid5 /dev/sda[U] /dev/sdb[F] /dev/sdc[U] /dev/sdd[U]
|
||
status=DEGRADED blocks=3000GB [ U_UU ]
|
||
|
||
unused devices: <none></pre>
|
||
<div class="cmd-row"><div class="cmd-label">Cosa guardare</div><div>La parola dopo <code>status=</code>: OK, DEGRADED o FAILED. Le lettere tra parentesi quadre: U = Up (funzionante), _ = mancante, R = in rebuild, F = FAILED, M = REMOVED. La riga <code>recovery =</code> con percentuale durante il rebuild.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Errori possibili</div><div>Nessun errore: il comando funziona sempre. Se lo stato è FAILED, si vede chiaramente nella riga status.</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>mdadm --detail /dev/md0</code><span class="status-badge st-ok">Diagnosi</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fa</div><div>Mostra informazioni dettagliate sull'array: livello RAID, dimensione, numero di dischi, dischi guasti, dischi rimossi, spares presenti, stato di ogni singolo disco.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Quando usarlo</div><div>Dopo cat /proc/mdstat per avere un quadro più dettagliato, o per identificare esattamente quale disco è guasto.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Sintassi alternativa</div><div>Funziona anche come: <code>mdadm /dev/md0 --detail</code></div></div>
|
||
<pre><span class="prompt">raidlab(DEGRADED)$</span> mdadm --detail /dev/md0
|
||
/dev/md0:
|
||
Version : 1.2 (sim)
|
||
Raid Level : raid5
|
||
Array Size : 3000 GB
|
||
Device Count : 4
|
||
Failed Disks : 1
|
||
Removed Disks : 0
|
||
Spare Disks : 0
|
||
State : DEGRADED
|
||
Fault Tolerance: 1 disk(s) (didattica)
|
||
|
||
Number State Device Size
|
||
0 OK /dev/sda 1000GB
|
||
1 FAILED /dev/sdb 1000GB
|
||
2 OK /dev/sdc 1000GB
|
||
3 OK /dev/sdd 1000GB</pre>
|
||
<div class="cmd-row"><div class="cmd-label">Cosa guardare</div><div>La riga <code>State</code>, il numero di <code>Failed Disks</code> e <code>Removed Disks</code>, e la tabella dei dischi per identificare quale dispositivo (es. /dev/sdb) è guasto.</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>mdadm --fail /dev/md0 /dev/sdX</code><span class="status-badge st-warn">Recovery</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fa</div><div>Marca manualmente un disco come FAILED all'interno dell'array. Simula il comando con cui si contrassegna un disco prima di rimuoverlo.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Quando usarlo</div><div>Quando si vuole rimuovere un disco che è ancora tecnicamente online ma si sa che è guasto. Nella pratica reale, mdadm può fare questo automaticamente; nel simulatore può essere necessario farlo a mano.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Esempio</div><div><code>mdadm --fail /dev/md0 /dev/sdb</code></div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Sintassi alternativa</div><div><code>mdadm /dev/md0 --fail /dev/sdb</code></div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Risultato atteso</div><div>Il disco passa a stato FAILED. Il messaggio nel terminale dice "sdb marcato FAILED". L'array passa a DEGRADED se era OK.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Errori possibili</div><div>Se il rebuild è in corso, il fail viene bloccato. Se il dispositivo non esiste nell'array, compare un messaggio di errore.</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>mdadm --remove /dev/md0 /dev/sdX</code><span class="status-badge st-warn">Recovery</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fa</div><div>Rimuove fisicamente il disco dall'array. Il disco passa allo stato REMOVED. L'array resta DEGRADED.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Quando usarlo</div><div>Dopo aver marcato il disco come FAILED, prima di aggiungere il disco sostitutivo.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Esempio</div><div><code>mdadm --remove /dev/md0 /dev/sdb</code></div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Sintassi alternativa</div><div><code>mdadm /dev/md0 --remove /dev/sdb</code></div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Risultato atteso</div><div>Il disco scompare dall'array attivo. Lo stato dell'array resta DEGRADED (non va a FAILED solo perché un disco è stato rimosso).</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Errori possibili</div><div>Non è possibile rimuovere un disco che non è in stato FAILED o REMOVED. Il rebuild deve essere fermo.</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>mdadm --add /dev/md0 /dev/sdX [--size N]</code><span class="status-badge st-warn">Recovery</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fa</div><div>Aggiunge un nuovo disco all'array come spare. Il disco compare nella griglia con stato SPARE e può essere usato per il rebuild.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Quando usarlo</div><div>Dopo aver rimosso il disco guasto, per aggiungere il disco sostitutivo prima di avviare il rebuild.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Esempio</div><div><code>mdadm --add /dev/md0 /dev/sde</code></div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Esempio con dimensione</div><div><code>mdadm --add /dev/md0 /dev/sdz --size 500</code> (aggiunge un disco da 500 GB)</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Risultato atteso</div><div>Il disco viene aggiunto come SPARE. Nel terminale: "aggiunto /dev/sde come SPARE (1000 GB)".</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Errori possibili</div><div>Se il disco ha una dimensione inferiore a quella dei dischi dell'array, il rebuild successivo fallirà con errore "spare too small".</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Interpretazione</div><div>Il nome del nuovo disco deve essere diverso da quelli già presenti. Si usa tipicamente /dev/sde, /dev/sdf, ecc. per i dischi sostitutivi.</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>mdadm --rebuild /dev/md0</code><span class="status-badge st-warn">Recovery</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fa</div><div>Avvia il processo di ricostruzione dell'array usando lo spare disponibile. Il disco spare diventa REBUILDING. I dati vengono ricostruiti progressivamente.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Quando usarlo</div><div>Dopo aver aggiunto uno spare con --add. Deve essere presente almeno uno spare e l'array non deve essere FAILED.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Esempio</div><div><code>mdadm --rebuild /dev/md0</code></div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Risultato atteso</div><div>Compare la barra di avanzamento sul disco in rebuild. Nel terminale si vedono messaggi con l'ETA stimato. Al termine il disco torna a stato OK e l'array a OK.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Errori possibili</div><div>Se non c'è uno spare, compare: "Nessuno SPARE presente. Usa: mdadm --add". Se l'array è FAILED, il rebuild non può partire.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Monitoraggio</div><div>Durante il rebuild si può usare <code>cat /proc/mdstat</code> per vedere la percentuale di avanzamento.</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>mdadm --stop-rebuild /dev/md0</code><span class="status-badge st-warn">Recovery</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fa</div><div>Interrompe un rebuild in corso. Il disco in rebuild torna a stato FAILED e il rebuild si azzera.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Quando usarlo</div><div>Per simulare un'interruzione controllata del rebuild (utile nello scenario rebuild_interrupted).</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Errori possibili</div><div>Se non c'è un rebuild attivo, compare: "mdadm: nessun rebuild attivo".</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>lsblk</code><span class="status-badge st-ok">Diagnosi</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fa</div><div>Mostra l'elenco di tutti i dispositivi a blocchi (dischi) con le loro dimensioni, tipi e punti di mount. Permette di vedere la struttura dell'array e dei dischi fisici.</div></div>
|
||
<pre><span class="prompt">raidlab(OK)$</span> lsblk
|
||
NAME SIZE TYPE MOUNTPOINT
|
||
sda 1000G disk
|
||
sdb 1000G disk (failed)
|
||
sdc 1000G disk
|
||
sdd 1000G disk
|
||
md0 3000G raid5 /mnt</pre>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>fdisk -l</code><span class="status-badge st-ok">Diagnosi</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fa</div><div>Mostra informazioni sulla struttura e la dimensione dei dispositivi. Utile per verificare la dimensione esatta di un disco prima di usarlo come spare.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Interpretazione</div><div>Prima di aggiungere un disco con --add, usare fdisk -l per verificare che la dimensione sia sufficiente rispetto ai dischi dell'array.</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>blkid</code><span class="status-badge st-ok">Diagnosi</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fa</div><div>Mostra UUID e tipo di filesystem dei dispositivi. Funziona solo dopo aver creato un filesystem con mkfs.ext4.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Risultato se nessun filesystem</div><div>Restituisce "(nessun filesystem)".</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>dmesg | tail</code><span class="status-badge st-ok">Diagnosi</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fa</div><div>Mostra gli ultimi 14 messaggi del kernel. Questi messaggi registrano eventi come guasti di disco, CRC errors, temperature critiche, avvio e fine del rebuild.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Quando usarlo</div><div>Quando si sospetta un problema ma non si sa ancora quale disco è coinvolto. I messaggi dmesg spesso indicano il dispositivo specifico (es. "/dev/sdb: UDMA CRC error count increased").</div></div>
|
||
<pre><span class="prompt">raidlab(DEGRADED)$</span> dmesg | tail
|
||
[14:22:01] WARN: /dev/sdb: disk FAILED (scenario)
|
||
[14:22:01] INFO: md0: created RAID5 with 4 disks</pre>
|
||
<div class="cmd-row"><div class="cmd-label">Interpretazione</div><div>Le righe con WARN o ERROR indicano problemi. Il nome del dispositivo (es. /dev/sdb) indica quale disco è coinvolto.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Attenzione</div><div>Il comando <code>dmesg</code> da solo (senza <code>| tail</code>) non è riconosciuto. Va digitato esattamente <code>dmesg | tail</code>.</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>smartctl -a /dev/sdX</code><span class="status-badge st-ok">Diagnosi</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fa</div><div>Mostra i dati SMART del disco specificato: salute generale, temperatura, settori ricollocati, settori in attesa, errori CRC. Permette di capire se il problema è fisico (disco guasto) o di cablaggio (solo CRC errors).</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Esempio</div><div><code>smartctl -a /dev/sdb</code></div></div>
|
||
<pre><span class="prompt">raidlab(DEGRADED)$</span> smartctl -a /dev/sdb
|
||
smartctl 7.4 /dev/sdb (sim)
|
||
Device Model: SIMDISK 7K2
|
||
|
||
SMART overall-health: FAILED!
|
||
|
||
5 Reallocated_Sector_Ct ... 210 <span class="err">← alto: disco guasto fisicamente</span>
|
||
197 Current_Pending_Sector ... 18 <span class="warn">← settori in attesa</span>
|
||
199 UDMA_CRC_Error_Count ... 0
|
||
194 Temperature_Celsius ... 33</pre>
|
||
<div class="cmd-row"><div class="cmd-label">Valori chiave da guardare</div><div>
|
||
<ul>
|
||
<li><strong>Reallocated_Sector_Ct > 0:</strong> settori ricollocati, segnale di disco che sta cedendo.</li>
|
||
<li><strong>UDMA_CRC_Error_Count alto + Reallocated = 0:</strong> probabile problema di cavo SATA, non del disco.</li>
|
||
<li><strong>Temperature_Celsius > 55°C:</strong> temperatura elevata, rischio guasto imminente.</li>
|
||
</ul>
|
||
</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Sostituzione X</div><div>Al posto di X indicare la lettera del disco: sda, sdb, sdc, ecc. Funziona anche per i dischi spare.</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>df -h</code><span class="status-badge st-ok">Filesystem</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fa</div><div>Mostra lo spazio disco disponibile, usato e totale, in formato leggibile. Funziona solo se il filesystem è stato creato e montato.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Errori possibili</div><div>Se il filesystem non è stato creato: "df: filesystem non creato". Se non è montato: "df: filesystem non montato".</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>mkfs.ext4 /dev/md0</code><span class="status-badge st-purple">Filesystem</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fa</div><div>Crea un filesystem ext4 sull'array RAID. Operazione distruttiva: cancella tutti i file esistenti.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Prerequisiti</div><div>L'array deve essere in stato OK o DEGRADED (non FAILED). Va eseguito una sola volta, dopo aver creato l'array per la prima volta.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Errori possibili</div><div>Se l'array è FAILED: "mkfs.ext4: I/O error: volume FAILED".</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>mount /dev/md0 /mnt</code><span class="status-badge st-purple">Filesystem</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fa</div><div>Monta il filesystem dell'array nella directory /mnt. Dopo questo comando i file sono accessibili tramite /mnt.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Prerequisiti</div><div>Il filesystem deve essere stato creato con mkfs.ext4. L'array non deve essere FAILED.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Errori possibili</div><div>"mount: nessun filesystem" se manca mkfs.ext4. "mount: I/O error" se l'array è FAILED.</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>umount /mnt</code><span class="status-badge st-purple">Filesystem</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fa</div><div>Smonta il filesystem. Dopo lo smount i file non sono più accessibili tramite /mnt. Funziona anche come <code>unmount /mnt</code>.</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>ls /mnt</code> · <code>touch /mnt/file</code> · <code>echo "testo" > /mnt/file</code> · <code>cat /mnt/file</code> · <code>rm /mnt/file</code><span class="status-badge st-purple">Filesystem</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fanno</div><div>Operazioni standard su file e directory nel filesystem montato. Funzionano solo se il filesystem è montato e l'array non è FAILED.</div></div>
|
||
<ul>
|
||
<li><code>ls /mnt</code> — elenca i file nella directory /mnt.</li>
|
||
<li><code>touch /mnt/file</code> — crea un file vuoto.</li>
|
||
<li><code>echo "testo" > /mnt/file</code> — scrive il testo nel file (le virgolette sono opzionali).</li>
|
||
<li><code>cat /mnt/file</code> — mostra il contenuto del file.</li>
|
||
<li><code>rm /mnt/file</code> — cancella il file.</li>
|
||
</ul>
|
||
<div class="cmd-row"><div class="cmd-label">Errori possibili</div><div>Tutti i comandi su file restituiscono "I/O error" se l'array è FAILED. I percorsi devono essere sotto /mnt.</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>report</code><span class="status-badge st-info">Utilità</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fa</div><div>Mostra nel terminale un report testuale completo della sessione: configurazione array, stato dischi, punteggio, hints usati, ultimi messaggi dmesg, cronologia delle azioni.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Quando usarlo</div><div>Prima di consegnare il lavoro o per rileggere tutto quello che è successo durante la sessione.</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>export</code><span class="status-badge st-info">Utilità</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fa</div><div>Scarica il report come file di testo (.txt) sul computer. Il file viene salvato automaticamente nella cartella di download del browser.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Quando usarlo</div><div>Al termine della sessione per consegnare il report al docente. Equivalente al pulsante "⬇ Scarica report" nella dashboard.</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>hint</code><span class="status-badge st-warn">Supporto</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fa</div><div>Fornisce un suggerimento contestuale sullo stato attuale dell'array. Il suggerimento cambia in base allo stato: FAILED, DEGRADED, o OK.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Costo</div><div>Ogni uso del hint costa 3 punti dallo score. Il numero di hints usati viene registrato nel report.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Interpretazione</div><div>Usare hint solo se davvero bloccati. In una verifica, troppi hint riducono significativamente il punteggio finale.</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>powerfail</code><span class="status-badge st-warn">Simulazione</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fa</div><div>Simula un'interruzione di corrente improvvisa. Se un rebuild è in corso, viene interrotto. Il disco in rebuild torna a stato FAILED.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Quando usarlo</div><div>Nello scenario rebuild_interrupted, per simulare il blackout che interrompe il rebuild. Poi si deve riavviare il rebuild.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Errori possibili</div><div>Se non c'è un rebuild attivo, compare: "POWER FAIL: nessun rebuild attivo".</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>conclude <testo></code><span class="status-badge st-info">Scenari</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fa</div><div>Registra una conclusione testuale per lo scenario corrente. Utilizzato negli scenari dove i dati sono persi (RAID0 fail, RAID5 2fail, RAID10 pairfail) e l'azione corretta è diagnosticare e concludere che serve un restore da backup.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Esempio</div><div><code>conclude restore da backup</code></div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Quando usarlo</div><div>Quando lo scenario richiede di riconoscere che l'array è FAILED e non recuperabile tramite RAID. Anche per scenari di errori non fatali come crc_errors e overheat.</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="cmd-card">
|
||
<div class="cmd-card-head"><code>solution</code><span class="status-badge st-err">Solo Teacher</span></div>
|
||
<div class="cmd-card-body">
|
||
<div class="cmd-row"><div class="cmd-label">Cosa fa</div><div>Mostra la sequenza di comandi corretta per risolvere lo scenario corrente.</div></div>
|
||
<div class="cmd-row"><div class="cmd-label">Disponibilità</div><div>Disponibile solo quando la modalità Teacher è attivata (pulsante Teacher: ON). In modalità normale per gli studenti, il comando restituisce un errore.</div></div>
|
||
</div>
|
||
</div>
|
||
|
||
|
||
<!-- ══════════════════════════════════════════════════════════ -->
|
||
<h2 id="s8">Come diagnosticare e risolvere un problema RAID</h2>
|
||
|
||
<p>Questa sezione descrive la procedura corretta da seguire ogni volta che si incontra un problema con un array RAID. Il principio fondamentale è: <strong>prima capire, poi agire</strong>. Mai modificare l'array prima di avere un quadro chiaro della situazione.</p>
|
||
|
||
<div class="steps">
|
||
<div class="step">
|
||
<div class="step-num">1</div>
|
||
<div class="step-content">
|
||
<strong>Primo controllo — leggere il prompt</strong>
|
||
Guardare il prompt del terminale: <code>raidlab(DEGRADED)$</code> o <code>raidlab(FAILED)$</code> indica immediatamente che c'è un problema. Guardare anche la spia colorata nella dashboard.
|
||
</div>
|
||
</div>
|
||
<div class="step">
|
||
<div class="step-num">2</div>
|
||
<div class="step-content">
|
||
<strong>Verificare lo stato con cat /proc/mdstat</strong>
|
||
<pre>cat /proc/mdstat</pre>
|
||
Leggere attentamente: qual è lo stato (OK/DEGRADED/FAILED)? Le lettere tra parentesi quadre mostrano quali dischi sono attivi (U), mancanti (_), in rebuild (R), guasti (F). Contare quanti dischi sono in stato anomalo.
|
||
</div>
|
||
</div>
|
||
<div class="step">
|
||
<div class="step-num">3</div>
|
||
<div class="step-content">
|
||
<strong>Ottenere i dettagli con mdadm --detail</strong>
|
||
<pre>mdadm --detail /dev/md0</pre>
|
||
Questo comando mostra esattamente quale disco (quale /dev/sdX) è guasto, il numero esatto di dischi FAILED e REMOVED, e il numero di spares disponibili.
|
||
</div>
|
||
</div>
|
||
<div class="step">
|
||
<div class="step-num">4</div>
|
||
<div class="step-content">
|
||
<strong>Leggere i messaggi del kernel</strong>
|
||
<pre>dmesg | tail</pre>
|
||
I messaggi dmesg forniscono informazioni sul tipo di errore: guasto I/O, CRC errors, temperatura critica. Spesso indicano il dispositivo esatto con un messaggio come "/dev/sdb: disk FAILED".
|
||
</div>
|
||
</div>
|
||
<div class="step">
|
||
<div class="step-num">5</div>
|
||
<div class="step-content">
|
||
<strong>Analizzare il disco guasto con smartctl</strong>
|
||
<pre>smartctl -a /dev/sdb</pre>
|
||
(sostituire sdb con il disco identificato al passo precedente). Guardare:
|
||
<ul>
|
||
<li>Health: FAILED! → disco fisicamente guasto, va sostituito.</li>
|
||
<li>UDMA_CRC_Error_Count alto + Reallocated = 0 → probabile problema di cavo, non del disco.</li>
|
||
<li>Temperature > 55°C → overheat, rischio guasto imminente.</li>
|
||
</ul>
|
||
</div>
|
||
</div>
|
||
<div class="step">
|
||
<div class="step-num">6</div>
|
||
<div class="step-content">
|
||
<strong>Decidere l'azione in base allo stato</strong>
|
||
Se l'array è FAILED (troppi guasti): non è possibile il rebuild RAID. L'unica soluzione è il restore da backup. Usare <code>conclude restore da backup</code>.
|
||
Se l'array è DEGRADED (guasti entro la tolleranza): procedere con la sostituzione del disco guasto.
|
||
</div>
|
||
</div>
|
||
<div class="step">
|
||
<div class="step-num">7</div>
|
||
<div class="step-content">
|
||
<strong>Rimuovere il disco guasto</strong>
|
||
<pre>mdadm --remove /dev/md0 /dev/sdb</pre>
|
||
Se il disco non è già marcato FAILED, marcarlo prima con <code>mdadm --fail /dev/md0 /dev/sdb</code>, poi rimuoverlo.
|
||
</div>
|
||
</div>
|
||
<div class="step">
|
||
<div class="step-num">8</div>
|
||
<div class="step-content">
|
||
<strong>Aggiungere il disco sostitutivo</strong>
|
||
<pre>mdadm --add /dev/md0 /dev/sde</pre>
|
||
Il nome del nuovo disco deve essere diverso da quelli già presenti. Il disco viene aggiunto come SPARE.
|
||
</div>
|
||
</div>
|
||
<div class="step">
|
||
<div class="step-num">9</div>
|
||
<div class="step-content">
|
||
<strong>Avviare il rebuild</strong>
|
||
<pre>mdadm --rebuild /dev/md0</pre>
|
||
Il rebuild inizia. Il disco spare diventa REBUILDING. Si vede la barra di avanzamento nella griglia.
|
||
</div>
|
||
</div>
|
||
<div class="step">
|
||
<div class="step-num">10</div>
|
||
<div class="step-content">
|
||
<strong>Monitorare il rebuild</strong>
|
||
<pre>cat /proc/mdstat</pre>
|
||
Eseguire questo comando periodicamente per monitorare la percentuale di avanzamento. Si vede la riga "recovery = X%" con il tempo stimato.
|
||
</div>
|
||
</div>
|
||
<div class="step">
|
||
<div class="step-num">11</div>
|
||
<div class="step-content">
|
||
<strong>Verifica finale</strong>
|
||
Al termine del rebuild, l'array torna a stato OK. Verificare con <code>cat /proc/mdstat</code> che lo stato sia tornato OK e che tutte le lettere tra parentesi siano "U". Nel riquadro scenario dovrebbe comparire "✅ RISOLTO".
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
|
||
<!-- ══════════════════════════════════════════════════════════ -->
|
||
<h2 id="s9">Stati dei dischi e del volume</h2>
|
||
|
||
<h3>Stati dei singoli dischi</h3>
|
||
<table>
|
||
<tr><th>Stato</th><th>Significato</th><th>Cosa fare</th></tr>
|
||
<tr><td><span class="status-badge st-ok">OK</span></td><td>Disco funzionante normalmente. Tutti i parametri SMART sono nella norma.</td><td>Nessuna azione necessaria.</td></tr>
|
||
<tr><td><span class="status-badge st-err">FAILED</span></td><td>Disco guasto. Non risponde correttamente o ha troppi settori danneggiati. I dati sul disco non sono più affidabili.</td><td>Rimuovere con --remove, poi sostituire con --add.</td></tr>
|
||
<tr><td><span class="status-badge" style="background:#e5e7eb;color:#374151">REMOVED</span></td><td>Disco rimosso dall'array tramite --remove. Fisicamente assente dall'array ma non ancora sostituito. L'array resta DEGRADED.</td><td>Aggiungere un disco sostitutivo con --add.</td></tr>
|
||
<tr><td><span class="status-badge st-info">SPARE</span></td><td>Disco aggiunto con --add ma non ancora usato per il rebuild. Pronto per essere utilizzato nella ricostruzione.</td><td>Avviare il rebuild con --rebuild.</td></tr>
|
||
<tr><td><span class="status-badge st-warn">REBUILDING</span></td><td>Disco in fase di ricostruzione. I dati vengono riscritti progressivamente su questo disco. L'array è DEGRADED durante il rebuild.</td><td>Attendere il completamento. Non spegnere il sistema durante il rebuild.</td></tr>
|
||
<tr><td><span class="status-badge st-info">SLOW</span></td><td>Disco che risponde lentamente. Degrada le prestazioni dell'intero array. Non è ancora guasto, ma è a rischio.</td><td>Monitorare con smartctl. Pianificare la sostituzione.</td></tr>
|
||
<tr><td><span class="status-badge st-warn">OVERHEAT</span></td><td>Temperatura critica (sopra i 55–60°C). Il disco rischia di guastarsi a breve. Il sistema segnala l'allarme termico.</td><td>Migliorare il raffreddamento. Pianificare la sostituzione preventiva. Usare conclude per registrare la diagnosi.</td></tr>
|
||
<tr><td><span class="status-badge st-purple">CRC</span></td><td>Errori CRC rilevati. Spesso indica un problema di cavo SATA o di connessione, non necessariamente del disco stesso.</td><td>Usare smartctl per controllare Reallocated_Sector_Ct. Se è 0, il problema è probabilmente il cavo. Usare conclude per registrare la diagnosi.</td></tr>
|
||
</table>
|
||
|
||
<h3>Stati del volume (array)</h3>
|
||
<table>
|
||
<tr><th>Stato</th><th>Significato</th><th>Accesso ai dati</th><th>Azione richiesta</th></tr>
|
||
<tr><td><span class="status-badge st-ok">OK</span></td><td>Tutti i dischi funzionanti, ridondanza integra.</td><td>Sì, normale.</td><td>Nessuna.</td></tr>
|
||
<tr><td><span class="status-badge st-warn">DEGRADED</span></td><td>Uno o più dischi guasti o rimossi, ma entro i limiti di tolleranza. La ridondanza è parzialmente o totalmente assente.</td><td>Sì, ma a rischio.</td><td>Intervenire il prima possibile. Sostituire il disco guasto e ricostruire.</td></tr>
|
||
<tr><td><span class="status-badge st-err">FAILED</span></td><td>Superata la tolleranza ai guasti. I dati non sono recuperabili tramite RAID.</td><td>No.</td><td>Restore da backup. Non è possibile il rebuild RAID.</td></tr>
|
||
</table>
|
||
|
||
<div class="callout danger">
|
||
<div class="icon">❗</div>
|
||
<div>Quando un array è FAILED, nel simulatore tutti i comandi di filesystem (mount, ls, cat, touch, ecc.) restituiscono un errore I/O. L'unica azione possibile è riconoscere la situazione e concludere che serve un restore da backup.</div>
|
||
</div>
|
||
|
||
|
||
<!-- ══════════════════════════════════════════════════════════ -->
|
||
<h2 id="s10">La documentazione integrata</h2>
|
||
|
||
<p>La scheda <strong>📚 DOCUMENTAZIONE</strong> contiene una guida teorica completa direttamente nel simulatore, organizzata in due pannelli selezionabili:</p>
|
||
|
||
<ul>
|
||
<li><strong>Guida completa RAID:</strong> spiega in dettaglio tutti i livelli RAID con diagrammi visivi della distribuzione dei blocchi, tabelle comparative e consigli su quando usare ciascun livello.</li>
|
||
<li><strong>Procedure complete:</strong> organizzata in quattro sezioni interne (Diagnosi RAID, Recovery RAID, Errori non fatali, Filesystem su RAID) con le procedure passo passo, esempi di output reali e spiegazioni dettagliate di ogni comando.</li>
|
||
</ul>
|
||
|
||
<p>Come si usa: fare clic sulla scheda DOCUMENTAZIONE in alto. Si apre il pannello "Guida completa RAID". Per accedere alle procedure, fare clic sul secondo pannello e poi navigare tra le quattro sezioni usando i pulsanti interni (🔍 5.1 Diagnosi RAID, 🔧 5.2 Recovery RAID, ecc.).</p>
|
||
|
||
<div class="callout tip">
|
||
<div class="icon">💡</div>
|
||
<div>La documentazione integrata è sempre disponibile durante il lavoro. Se si dimentica la sintassi di un comando o il significato di un errore SMART, si può consultare la documentazione senza uscire dal simulatore.</div>
|
||
</div>
|
||
|
||
|
||
<!-- ══════════════════════════════════════════════════════════ -->
|
||
<h2 id="s11">Il report finale</h2>
|
||
|
||
<p>Il report è un documento testuale che riassume l'intera sessione di lavoro. È uno strumento fondamentale per la valutazione in laboratorio.</p>
|
||
|
||
<h3>Come generare il report</h3>
|
||
<p>Ci sono due modi equivalenti:</p>
|
||
<ul>
|
||
<li>Digitare <code>report</code> nel terminale per visualizzarlo a schermo.</li>
|
||
<li>Digitare <code>export</code> oppure cliccare il pulsante "⬇ Scarica report" per scaricarlo come file .txt.</li>
|
||
</ul>
|
||
|
||
<h3>Cosa contiene il report</h3>
|
||
<ul>
|
||
<li>Timestamp (data e ora della generazione).</li>
|
||
<li>Codice prova (se è stata usata la funzione Genera prova).</li>
|
||
<li>Scenario caricato e modalità (LAB o EXERCISE).</li>
|
||
<li>Configurazione array: livello RAID, numero di dischi, dimensione, capacità, stato.</li>
|
||
<li>Punteggio finale e numero di hints usati.</li>
|
||
<li>Elenco di tutti i dischi con il loro stato finale.</li>
|
||
<li>Ultimi messaggi dmesg.</li>
|
||
<li>Cronologia completa di tutte le azioni eseguite nel terminale, con timestamp.</li>
|
||
</ul>
|
||
|
||
<h3>Quando va generato</h3>
|
||
<p>Generare il report al termine del lavoro, dopo aver completato lo scenario o risolto il problema. Il report deve essere consegnato insieme al codice prova (se presente) come prova del lavoro svolto.</p>
|
||
|
||
<div class="callout info">
|
||
<div class="icon">📋</div>
|
||
<div>La cronologia delle azioni nel report mostra esattamente l'ordine in cui sono stati digitati i comandi. Questo permette al docente di verificare se la procedura seguita è stata corretta.</div>
|
||
</div>
|
||
|
||
|
||
<!-- ══════════════════════════════════════════════════════════ -->
|
||
<h2 id="s12">Errori comuni da evitare</h2>
|
||
|
||
<h3>1. Confondere RAID 1 con RAID 10</h3>
|
||
<p>RAID 1 fa mirroring su tutti i dischi: con 4 dischi da 1 TB la capacità è 1 TB e la tolleranza è 3 guasti. RAID 10 divide i dischi in coppie mirror e le mette in stripe: con 4 dischi da 1 TB la capacità è 2 TB ma si tollera 1 solo guasto per coppia. Non sono la stessa cosa. In RAID 10, se si guastano entrambi i dischi della stessa coppia, l'array è FAILED anche se tutti gli altri dischi funzionano perfettamente.</p>
|
||
|
||
<h3>2. Non leggere mdstat prima di agire</h3>
|
||
<p>Molti studenti si precipitano a digitare comandi di recovery senza prima capire la situazione. Questo porta a operazioni errate. Il primo comando da eseguire è <em>sempre</em> <code>cat /proc/mdstat</code>, seguito da <code>mdadm --detail /dev/md0</code>. Solo dopo aver capito cosa è successo si può decidere l'azione corretta.</p>
|
||
|
||
<h3>3. Tentare il rebuild su un array FAILED</h3>
|
||
<p>Se l'array è FAILED, il rebuild non è possibile. Il simulatore lo impedisce con un messaggio di errore. Un array FAILED significa che i dati sono persi e serve il restore da backup. Non ha senso cercare di ricostruire: la soluzione corretta è usare <code>conclude restore da backup</code>.</p>
|
||
|
||
<h3>4. Usare i comandi fuori ordine</h3>
|
||
<p>La sequenza corretta per il recovery è: (1) diagnosi → (2) fail → (3) remove → (4) add → (5) rebuild. Saltare passaggi porta a errori. Ad esempio, non è possibile rimuovere un disco che non è stato prima marcato FAILED. Non è possibile avviare il rebuild senza uno spare. Non è possibile montare il filesystem se l'array è FAILED.</p>
|
||
|
||
<h3>5. Interpretare male la capacità utile</h3>
|
||
<p>La capacità utile non è mai uguale alla capacità totale dei dischi (tranne RAID 0). Con RAID 5 e 4 dischi da 1 TB si ottengono 3 TB (non 4 TB). Con RAID 6 e 6 dischi da 1 TB si ottengono 4 TB (non 6 TB). La capacità "persa" viene usata per la parità o il mirroring, ed è il prezzo da pagare per la ridondanza.</p>
|
||
|
||
<h3>6. Non distinguere CRC errors da guasto fisico</h3>
|
||
<p>Un disco con molti errori CRC ma Reallocated_Sector_Ct = 0 non è necessariamente guasto: il problema potrebbe essere il cavo SATA. Prima di sostituire un disco, analizzare attentamente i dati SMART. Sostituire un disco sano è uno spreco e non risolve il problema se il cavo è difettoso.</p>
|
||
|
||
<h3>7. Confondere DEGRADED con FAILED</h3>
|
||
<p>DEGRADED non significa che i dati sono persi. L'array DEGRADED funziona ancora e i dati sono accessibili. È una situazione di rischio, non di disastro. FAILED invece significa che i dati non sono accessibili. Non confondere i due stati porta a reazioni sbagliate: panico inutile su un DEGRADED, oppure indifferenza pericolosa (non intervenire tempestivamente).</p>
|
||
|
||
<h3>8. Aggiungere uno spare troppo piccolo</h3>
|
||
<p>Se si aggiunge un disco con dimensione inferiore a quella dei dischi dell'array, il rebuild fallirà con l'errore "spare too small". Prima di aggiungere un disco con --add, verificare sempre la dimensione con <code>fdisk -l</code> o con il parametro --size nel comando --add.</p>
|
||
|
||
|
||
<!-- ══════════════════════════════════════════════════════════ -->
|
||
<h2 id="s13">Conclusione</h2>
|
||
|
||
<p>Il simulatore RAID è uno strumento completo per imparare a gestire array RAID in modo pratico e sicuro. Attraverso l'uso del terminale simulato si acquisisce familiarità con i comandi reali di Linux e si sviluppa un metodo di lavoro ordinato e metodico.</p>
|
||
|
||
<p>I concetti fondamentali da ricordare al termine di questo percorso sono:</p>
|
||
<ul>
|
||
<li>Ogni livello RAID ha caratteristiche diverse in termini di capacità, prestazioni e tolleranza ai guasti. Conoscere queste differenze è essenziale per scegliere il livello giusto e per capire come comportarsi in caso di guasto.</li>
|
||
<li>La procedura di recovery segue sempre lo stesso ordine: diagnosi → identificazione → rimozione → sostituzione → rebuild → verifica. Non saltare mai i passi.</li>
|
||
<li>Il report finale è la documentazione del lavoro svolto. Va generato e consegnato al termine di ogni sessione.</li>
|
||
<li>Il RAID non sostituisce il backup. In caso di array FAILED, serve sempre un restore da backup esterno.</li>
|
||
</ul>
|
||
|
||
<p>Utilizzando regolarmente questo simulatore si diventerà più rapidi e sicuri nella gestione di situazioni reali, sviluppando quelle competenze pratiche che sono fondamentali per chi lavora nell'amministrazione di sistemi.</p>
|
||
|
||
<div class="callout tip">
|
||
<div class="icon">🎯</div>
|
||
<div>Consiglio finale: non imparare solo i comandi a memoria. Capire il <em>perché</em> di ogni passaggio è molto più utile. Perché si legge prima mdstat? Perché si rimuove il disco prima di aggiungerne uno nuovo? Ragionare sul metodo, non solo eseguire meccanicamente.</div>
|
||
</div>
|
||
|
||
<p style="text-align:center;margin-top:40px;color:var(--muted);font-size:13px">— Fine della guida — Simulatore RAID v2.3 · Informatica di Sistema</p>
|
||
|
||
</body>
|
||
</html>
|