Neuer Server

[Akira]

Habe mal Claude gefragt wie man so was macht:

Ich erkläre dir, wie du ein Software-RAID unter Debian 13 mit `mdadm` erstellst.

## Voraussetzungen

Zuerst mdadm installieren, falls noch nicht vorhanden:

```bash
sudo apt update
sudo apt install mdadm
```

## Schritte zur RAID-Erstellung

**1. Festplatten identifizieren:**

```bash
lsblk
# oder
sudo fdisk -l
```

**2. Festplatten partitionieren (falls nötig):**

Falls deine Festplatten noch nicht partitioniert sind, nutze `fdisk` oder `parted`. Für RAID solltest du den Partitionstyp auf "Linux raid autodetect" setzen (Typ `fd` in fdisk).

```bash
sudo fdisk /dev/sdb
# Partition erstellen, Typ auf fd setzen
```

**3. RAID-Array erstellen:**

Die Syntax variiert je nach RAID-Level:

**RAID 0 (Striping, keine Redundanz):**
```bash
sudo mdadm --create /dev/md0 --level=0 --raid-devices=2 /dev/sdb1 /dev/sdc1
```

**RAID 1 (Spiegelung):**
```bash
sudo mdadm --create /dev/md0 --level=1 --raid-devices=2 /dev/sdb1 /dev/sdc1
```

**RAID 5 (Striping mit Parität, min. 3 Festplatten):**
```bash
sudo mdadm --create /dev/md0 --level=5 --raid-devices=3 /dev/sdb1 /dev/sdc1 /dev/sdd1
```

**RAID 10 (gespiegelte Stripes, min. 4 Festplatten):**
```bash
sudo mdadm --create /dev/md0 --level=10 --raid-devices=4 /dev/sdb1 /dev/sdc1 /dev/sdd1 /dev/sde1
```

**4. Erstellungsfortschritt überwachen:**

```bash
cat /proc/mdstat
# oder
sudo mdadm --detail /dev/md0
```

**5. Dateisystem erstellen:**

```bash
sudo mkfs.ext4 /dev/md0
```

**6. Array mounten:**

```bash
sudo mkdir /mnt/raid
sudo mount /dev/md0 /mnt/raid
```

**7. RAID-Konfiguration speichern:**

Dies ist wichtig, damit das Array nach einem Neustart erkannt wird:

```bash
sudo mdadm --detail --scan | sudo tee -a /etc/mdadm/mdadm.conf
sudo update-initramfs -u
```

**8. Zur /etc/fstab hinzufügen für automatisches Mounten:**

```bash
echo '/dev/md0 /mnt/raid ext4 defaults 0 2' | sudo tee -a /etc/fstab
```

## Nützliche Verwaltungsbefehle

**Array-Status prüfen:**
```bash
sudo mdadm --detail /dev/md0
cat /proc/mdstat
```

**Array stoppen:**
```bash
sudo umount /mnt/raid
sudo mdadm --stop /dev/md0
```

**Array wieder zusammensetzen:**
```bash
sudo mdadm --assemble /dev/md0 /dev/sdb1 /dev/sdc1
```

**Defekte Festplatte entfernen:**
```bash
sudo mdadm /dev/md0 --fail /dev/sdb1 --remove /dev/sdb1
```

**Neue Festplatte hinzufügen (für redundante Arrays):**
```bash
sudo mdadm /dev/md0 --add /dev/sde1
```

Welches RAID-Level planst du zu verwenden? Dann kann ich dir spezifischere Hinweise geben.

[Dorena Verne]

Also nochmal, ICH WILL KEIN RAID, habe ich doch grad geschrieben, ich will zwei einzelne Platten...

[Akira]

Also nochmal, ICH WILL KEIN RAID, habe ich doch grad geschrieben, ich will zwei einzelne Platten...

Tschuldigung !!!

[Dorena Verne]

Halb so wild, habe so auch noch genug zu tun, das mit den Platten eilt nicht.

[nihal]

...
Ich gehe davon aus, die Diskussion dreht sich um ein Software RAID. Bei Hardware RAID gilt das alles nicht.
Hetzner hat das System so konfiguriert, dass Mirroring RAID 1 eingestellt ist.
...

kurze zusammenfassung: es ging darum die zweite ssd zu formatieren und dann zu mounten. mit fdisk -l wurde jedoch nur eine /etc/sda angezeigt, bei zwei platten müsste eine sdb vorhanden sein. daher ging ich davon aus, das es ein raid ist und dort wird die 2. bei fdisk nicht angezeigt.
daraufhin wurde mit cat /proc/mdstat mal getestet ob es ein raid ist.
mein mint sagt mir:
Personalities : [linear] [raid0] [raid1] [raid6] [raid5] [raid4] [raid10]
unused devices: <none>
und debian so:
cat: /proc/mdstat: Datei oder Verzeichnis nicht gefunden

[Akira]

kurze zusammenfassung: es ging darum die zweite ssd zu formatieren und dann zu mounten. mit fdisk -l wurde jedoch nur eine /etc/sda angezeigt, bei zwei platten müsste eine sdb vorhanden sein. daher ging ich davon aus, das es ein raid ist und dort wird die 2. bei fdisk nicht angezeigt.

War für mich auch nur logisch. Ich hab sämtliche Server mit RAID ausgerüstet. Hat mir schon mehrere Male da "Leben gerettet".

parted ist noch ein cooles Programm:

Code:

(parted) print all                                                        
Model: Samsung SSD 990 EVO 2TB (nvme)
Disk /dev/nvme0n1: 2000GB
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Disk Flags:

Number  Start   End     Size    File system  Name  Flags
1      1049kB  2000GB  2000GB  btrfs


Model: WDC PC SN730 SDBPNTY-1T00-1006 (nvme)
Disk /dev/nvme1n1: 1024GB
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Disk Flags:

Number  Start   End     Size    File system     Name                          Flags
1      1049kB  274MB   273MB   fat32           EFI system partition          msftdata
2      274MB   290MB   16.8MB                  Microsoft reserved partition  msftres
3      290MB   326GB   325GB   ntfs            Basic data partition          msftdata
4      326GB   329GB   3198MB  fat32                                         boot, esp
5      329GB   973GB   644GB   btrfs
7      973GB   1023GB  50.3GB  linux-swap(v1)                                swap
6      1023GB  1024GB  753MB   ntfs                                          hidden, diag


Model: Unknown (unknown)
Disk /dev/zram0: 32.9GB
Sector size (logical/physical): 4096B/4096B
Partition Table: loop
Disk Flags:

Number  Start  End     Size    File system     Flags
1      0.00B  32.9GB  32.9GB  linux-swap(v1)

Alles auf der console

[Dorena Verne]

Puh, ein Monsterdump von der Größe 900GB.
Habe mit ChatGPT einen Plan erarbeitet und angeschubst, der Import läuft nun.

Code:

GROSSEN MYSQL/MARIADB-DUMP VON WINDOWS NACH DEBIAN IMPORTIEREN

Voraussetzungen

-   Windows-Server mit dump.sql (z. B. D:.sql)
-   Debian-Server mit ausreichend Speicher
-   MariaDB installiert
-   Root-Zugriff
-   Stabile Netzwerkverbindung

1. Windows-Freigabe einrichten

-   Laufwerk D: freigeben (z. B. Freigabename: d)
-   Benutzer: Administrator (Leserechte ausreichend)

2. Debian: Freigabe mounten

Pakete installieren: apt install -y cifs-utils screen

Mountpunkt: mkdir -p /mnt/windowsdump

Mounten: mount -t cifs //WINDOWS_IP/d /mnt/windowsdump -o
username=Administrator,vers=3.0

3. MariaDB vorbereiten

Datenbank anlegen: mysql -u root -p CREATE DATABASE griddb; EXIT;

Konfigurationsdatei: nano /etc/mysql/mariadb.conf.d/99-bigimport.cnf

Inhalt: [mysqld] max_allowed_packet=1G net_read_timeout=600
net_write_timeout=600 wait_timeout=28800 interactive_timeout=28800

MariaDB neu starten: systemctl restart mariadb

4. Import abbruchfest starten

screen -S sqlimport mysql –max_allowed_packet=1G -u root -p griddb <
/mnt/windowsdump/dump.sql

Detach: CTRL + A, dann D

5. Kontrolle

ps aux | grep mysql

Import beendet, wenn mysql-Prozess verschwindet.

6. Abschluss

umount /mnt/windowsdump

Typische Fehler

-   ERROR 2006: max_allowed_packet erhöhen
-   Internet-Abbruch: immer screen verwenden
-   Unknown database: CREATE DATABASE ausführen

[Pius Noel]

Du schreibst, dass du kein Raid haben willst. Falls du aber nicht sicher bist, ob die zweite Festplatte in einem Hardware-Raid eingebunden ist oder nicht, dann würde ich dir raten, die Angelgenheit nicht auf die lange Bank zu schieben. Das Auflösen eines Raids ohne Datenverlust ist nämlich nicht unbedingt trivial. Mit lspci sollte auch sichtbar sein, ob ein Raid-Controller vorhanden ist oder nicht.

Falls kein Hardware-Raid vorhanden ist, finde ich das auch merkwürdig, dass die Festplatte mit fdisk -l nicht angezeigt wird. Da würde ich mich an den Support des Hosters wenden.

[Gau Hax]

Huhu ... dann schreibe ich mal hier, wie ich das mit neuen Festplatten mache, bei mir ( NEIN KEIN RAID

Liste der gräte ausgeben
Richtige Festplatte raus suchen ... leer und nicht eingebunden

lsblk -f | lsblk | fdisk -l namen und mountpoints

die Ausgabe sollte etwa so aussehen ... beinhalten
NAME FSTYPE FSVER LABEL UUID FSAVAIL FSUSE% MOUNTPOINTS
sda
├─sda1 ext4 1.0 ...
sdb ....

mit " cfdisk " etwas besser als gpart
als root ohne "sudo"
wäre die zweite Platte im System

sudo cfdisk /dev/sdb

am unteren Rand sind alle Möglichkeiten, wechseln mit den Pfeil recht = Links zu wählen sind
jederzeit auf Ende oder " Strg + C " zum abbrechen ohne Änderungen

im Freien Bereich, dann auf " Neu " gehen, und die grösse wählen. Automatisch ist der gesamte freie Bereich für eine Partition
nach dem erstellen, Automatisch ist " Linux Dateisystem " kann auf " Typ " geändert werden
Wenn man sich sicher ist, wähle " Schreiben " Ab hier sind Änderungen an der Festplatte gemacht worden.
mit " Speichern " und " Ende " verlassen

im Anschluss die neue(n) Partitionen formatieren

mkfs.ext4 /dev/sdb1

Ich persönlich teste dann noch mal, ob alles richtig gelaufen ist

mkdir -p /mnt/test

und die neue Partition mounten

mount /dev/sdb1 /mnt/test

mit " touch " kann man den zugriff auf die Platte testen
legt eine neue leere Datei an

touch /mnt/test/test.tmp
ll /mnt/test/

drwxr-xr-x 2 root root 4096 Jan 25 18:20 ./
drwxr-xr-x 3 root root 4096 Jan 25 18:18 ../
-rw-r--r-- 1 root root 0 Jan 25 18:20 test.tmp

Das sollte als Ergebnis rauskommen

Jetzt noch mal testen ob alles Sauber ist
mit " e2fsck " kann man die neue Partition testen
umount /dev/sdb1
e2fsck -f /dev/sdb1

Wenn bis hier keine Fehler aufgetreten sind, dann die neue Platte fest ins System einbinden
Das geht, in dem man sie fest in die "fstab" einträgt
ich benutze dafür immer " nano " bin kein "vi" fan

nano /etc/fstab

und wie sie jetzt genau eingetragen wird, da scheiden sich die Geister
Ich bin ein fan von "by-uuid"

/dev/disk/by-uuid/"UUID-DER-NEUEN-PARTITION" /backup ext4 defaults 0 1

alternativ geht auch ( so man ein Lable vergeben hat )

LABEL=BACKUP /backup ext4 defaults 0 1

Und wenn das jetzt gespeichert wird, dann sollte, so kein Tipfehler bei ist, beim nächsten Systemstart, die neue Partition automatisch unter " /backup " zu finden sein.

dann kann auch die " test.tmp " gelöscht werden