# Docker Container erstellen

## Container erstellen

### 1. Dockerfile erstellen

Ein `Dockerfile` definiert, wie dein Container aufgebaut sein soll. Erstelle ein neues Verzeichnis und eine Datei `Dockerfile`:

```bash
# Basis-Image wählen (z. B. Debian, Ubuntu oder Alpine)
FROM ubuntu:latest

# Update und Installation von Paketen
RUN apt update && apt install -y nano curl htop

# Standard-Shell setzen
CMD ["/bin/bash"]

```

```bash
# Basis-Image wählen (z. B. Debian, Ubuntu oder Alpine)
FROM ubuntu:latest

# Update und Installation von Paketen
RUN apt update && apt install -y nano curl htop iputils-ping iproute2 ethstatus vnstat btop htop sshfs wget sudo cifs-utils python3 python3-venv python3-pip git

# Standard-Shell setzen
CMD ["/bin/bash"]

```

### 2. Container bauen

Navigiere in das Verzeichnis, in dem dein `Dockerfile` liegt, und baue das Image:

```bash
docker build -t mein-linux-container .
```

### 3. Container starten

Starte den Container im interaktiven Modus:

```bash
docker run -it mein-linux-container
```

## Container CPU beschränken

### Option 1 - Begrenzung mit `--cpus` (empfohlen)

Da dein System **12 CPU-Kerne** hat und du dem Docker-Container **95% der Gesamtleistung** zuweisen möchtest, hast du zwei Möglichkeiten:

Du kannst den Container mit `--cpus` so starten:

```bash
docker run -it --cpus="11.4" mein-linux-container
```

🔹 **Erklärung:**

- 12 Kerne \* 95% = **11.4 Kerne**
- Der Container kann bis zu **11.4 Kerne nutzen**, aber nicht mehr.

Falls der Container bereits läuft, kannst du die Einstellung nachträglich setzen:

```bash
docker update --cpus="11.4" mein-linux-container
```

### Option 2 - Begrenzung mit `--cpu-quota` und `--cpu-period`

Falls du eine genauere Kontrolle möchtest:

```bash
docker run -it --cpu-quota=950000 --cpu-period=1000000 mein-linux-container
```

<div class="contain-inline-size rounded-md border-[0.5px] border-token-border-medium relative bg-token-sidebar-surface-primary dark:bg-gray-950" id="bkmrk-"><div class="overflow-y-auto p-4" dir="ltr">  
</div></div>🔹 **Erklärung:**

- `--cpu-period=1000000` → Definiert eine Zeitspanne von 1 Sekunde (1.000.000 Mikrosekunden).
- `--cpu-quota=950000` → Bedeutet, dass der Container in dieser Sekunde nur **950.000 Mikrosekunden** CPU-Zeit nutzen darf (also 95%).

Falls dein Container bereits läuft:

```bash
docker update --cpu-quota=950000 --cpu-period=1000000 mein-linux-container
```

### Option 3 - Begrenzung auf bestimmte Kerne mit `--cpuset-cpus`

Falls du den Container auf **11 von 12 Kernen** begrenzen möchtest:

```bash
docker run -it --cpuset-cpus="0-10" mein-linux-container
```

🔹 **Erklärung:**

- Der Container darf nur **CPU 0 bis CPU 10** nutzen (11 Kerne von 12).
- Dadurch wird die Leistung auf ca. **91.6%** begrenzt (11/12), was nahe an 95% liegt.

#### Fazit: Welche Methode solltest du nehmen?

✅ **Für eine einfache Begrenzung:**  
Nutze `--cpus="11.4"` → Leicht verständlich und flexibel.

✅ **Für eine exakte Kontrolle über CPU-Zeit:**  
Nutze `--cpu-quota=950000 --cpu-period=1000000`.

✅ **Falls du nur bestimmte Kerne zuweisen willst:**  
Nutze `--cpuset-cpus="0-10"` (≈91.6% Leistung).

## Container CPU beschränken ohne Datenverlust  


### Option 1 - Container mit `--rm` vermeiden

Falls du den Container mit `--rm` gestartet hast, wird er nach dem Beenden **gelöscht**.

Starte den Container stattdessen **ohne** `--rm`, damit er bestehen bleibt:

```bash
docker run -it --cpus="11.4" --name mein-linux-container mein-linux-container
```

🔹 **Erklärung:**

- `--name test_land_1_container` → Gibt dem Container einen **festen Namen**, damit du ihn später wiederfinden kannst.
- Nach `exit` bleibt der Container **bestehen**, aber **gestoppt**.

Starte ihn später wieder mit:

```bash
docker start -ai mein-linux-container
```

Falls du ihn nicht interaktiv starten willst:

```bash
docker start mein-linux-container
docker attach mein-linux-container
```

### Option 2 - Den Container committen (Änderungen dauerhaft speichern)

Falls du `sysbench` bereits installiert hast und den Container beenden möchtest, kannst du die Änderungen mit `docker commit` in ein **neues Image** speichern:

```bash
docker commit mein-linux-container mein-linux-container
```

🔹 **Erklärung:**

- Erstellt ein neues Image mit dem Namen `test_land_1_sysbench`, das alle Änderungen enthält.
- Danach kannst du es jederzeit mit folgendem Befehl starten:

```bash
docker run -it --cpus="11.4" mein-linux-container
```

Falls du möchtest, dass der Container **diese Änderungen auch nach dem Schließen speichert**, kannst du stattdessen `docker start` verwenden:

```bash
docker start -ai mein-linux-container
```

### Option 3 - Ein Dockerfile nutzen (Empfohlen für reproduzierbare Container)

Falls du `sysbench` immer in diesem Container haben willst, solltest du ein `Dockerfile` erstellen:

Erstelle eine Datei `Dockerfile`:

```bash
FROM ubuntu:latest
RUN apt update && apt install -y sysbench
CMD ["/bin/bash"]
```

 Baue das Image mit:

```bash
docker build -t mein-linux-container .
```

Starte den Container:

```bash
docker run -it --cpus="11.4" mein-linux-container
```

**Vorteile:**  
✅ Jedes Mal, wenn du das Image nutzt, ist `sysbench` bereits installiert.  
✅ Reproduzierbar – kannst du auf anderen Systemen wiederverwenden.

## Nützliche Pakete

#### Ping (ping 1.1.1.1):

```bash
apt-get install iputils-ping -y
```

#### ip tools (ip a):

```bash
apt install iproute2 -y
```