Tag: Ubuntu

## Motivation
Ich habe schon seit langer Zeit einen virtuellen Server gemietet, auf dem ich verschiedene Dienste, wie zB Webseite und Mail, laufen lasse. Die Anwendungen laufen direkt auf dem Server und ich will sie schon seit langem in Container stecken. Das Betriebssystem ist mit Ubuntu 18.04 LTS hoffnungslos veraltet, aktuell ist 24.04 LTS.
Ein Upgrade von Ubuntu 18 auf 24 ist mit Risiko und vermutlich hohem Aufwand verbunden, da erfahrungsgemäß irgendetwas irgendwie anders funktioniert und mühevoll angepasst werden muss. Grade bei einer Upgradekette 18->20->22->24 kann so einiges schief gehen.
Den Server miete ich seit ein paar Jahren und inzwischen gibt es für das gleiche Geld bessere (virtuelle) Hardware.
Aus diesen Gründen plane ich, einen neuen virtuellen Server zu mieten und auf diesen umzuziehen.

## Wie es auf dem Neuen laufen soll
Auf dem neuen Server soll Ubuntu 24.04 LTS laufen.
Auf dem Linux System soll Docker installiert werden.
Die Docker Container sollen mit Portainer verwaltet werden.
Die Webseite der Portainer Verwaltung und die weiteren Dienste sollen über einen Reverse Proxy, beispielsweise Traefik, erreichbar sein.
Der Reverse Proxy soll den Zugriff ausschließlich verschlüsselt über HTTPS erlauben und entsprechend konfiguriert sein.
Das HTTPS Zertifikat soll von [Let's Encrypt](https://letsencrypt.org/) kommen.

## lokaler virtueller Server
Zuerst möchte ich einen lokalen virtuellen Server einrichten um auf diesem die Migration vorbereiten zu können. Dazu werde ich [Virtual Box](https://www.virtualbox.org/) von Oracle verwenden.

Vom Host System (also mein PC, auf dem Virtual Box läuft) aus soll der Zugriff auf die Webseite per Domain Name funktionieren, nicht nur über die IP. Idealerweise sollte die Verschlüsselung mit Let's Encrypt vorgenommen werden, um so realistisch wie möglich das spätere System vorzubauen.
Leider ist das nicht (mit vertretbarem Aufwand) möglich, daher werde ich alles ohne HTTPS aufsetzen.

### virtuellen Server aufsetzen
1. Oracle VirtualBox installieren
2. Neue virtuelle Maschine erzeugen
* 8 GB RAM
* 4 CPUs
* ISO: [Ubuntu 24.04.1 LTS](https://ubuntu.com/download/server)
* Unbeaufsichtigte Installation:
* Benutzername und Passwort
* Hostname: kaulbach
* Domain Name: local
3. In den Netzwerkadapter-Einstellungen der virtuellen Maschine auf "Bridged Adapter" (Brückenadapter) umstellen
4. nach der Installation einloggen und mittels ```ip a``` die IP-Adresse der VM identifizieren (192.168.178.47)
5. Auf dem Host System in der Datei ```C:\Windows\System32\drivers\etc\hosts``` hinzufügen:
192.168.178.47 kaulbach.local
192.168.178.47 traefik.kaulbach.local
192.168.178.47 portainer.kaulbach.local
6. Test auf dem Host System:
* ping 192.168.178.47
* ping kaulbach.local

### virtuellen Server einrichten
```bash
sudo apt update
sudo apt upgrade -y

# Spracheinstellungen ändern
sudo locale-gen de_DE.UTF-8
sudo update-locale LANG=de_DE.UTF-8

# Tastaturbelegung ändern
sudo dpkg-reconfigure keyboard-configuration

# Zeitzone festlegen
sudo timedatectl set-timezone Europe/Berlin

# SSH Server installieren
sudo apt install -y openssh-server
sudo systemctl start ssh
sudo systemctl enable ssh
```

## Installation von Docker, Traefik, Portainer

### 1. Docker installieren
1. **Paketliste aktualisieren**:
```bash
sudo apt update
sudo apt upgrade -y
```

2. **Abhängigkeiten installieren**:
```bash
sudo apt install -y ca-certificates curl gnupg
```

3. **Docker-Repository hinzufügen**:
```bash
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
```

4. **Docker installieren**:
```bash
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
```

5. **Docker-Dienst aktivieren**:
```bash
sudo systemctl enable docker
sudo systemctl start docker
```

6. **Rechte für den aktuellen Benutzer konfigurieren**:
```bash
sudo usermod -aG docker $USER
newgrp docker
```

### 2. Docker Compose installieren
Docker Compose ist bei neueren Docker-Versionen bereits als Plugin enthalten. Es kann direkt über den Docker-CLI-Befehl `docker compose` genutzt werden.

**Installation testen**:
```bash
docker compose version
```

### 3.0 Traefik Netzwerk anlegen
Alle mit dem Traefik Dienst verbundenen Container sollen im selben Netzwerk liegen:
```bash
docker network create traefik-net
```

### 3. Traefik installieren
1. **Arbeitsverzeichnis erstellen**:
```bash
mkdir ~/traefik && cd ~/traefik
```

2. **`docker-compose.yml` für Traefik erstellen**:
```bash
vim docker-compose.yml
```
Inhalt:
```yaml
services:
traefik:
image: traefik:v3.2
container_name: traefik
restart: always
ports:
- "80:80"
volumes:
- "/var/run/docker.sock:/var/run/docker.sock:ro"
- "./traefik.yml:/etc/traefik/traefik.yml:ro"
labels:
- "traefik.enable=true"
- "traefik.http.routers.traefik.rule=Host(`traefik.kaulbach.local`)"
- "traefik.http.routers.traefik.entrypoints=web"
- "traefik.http.services.traefik.loadbalancer.server.port=8080"

networks:
default:
name: traefik-net
external: true
```

3. **Traefik-Konfigurationsdatei erstellen**:
```bash
vim traefik.yml
```
Inhalt:
```yaml
entryPoints:
web:
address: ":80"

providers:
docker:
endpoint: "unix:///var/run/docker.sock"
exposedByDefault: false

api:
dashboard: true
insecure: true
```

4. **Container starten**:
```bash
docker compose up -d
# Log Files checken
docker logs traefik
```

5. **Subdomain eintragen**
Auf dem Host System in der Datei ```C:\Windows\System32\drivers\etc\hosts``` den Eintrag für die Subdomain "traefik.kaulbach.local" hinzufügen:
192.168.178.47 traefik.kaulbach.local

6. **Dashboard aufrufen**:
Das Traefik-Dashboard ist unter `http://traefik.kaulbach.local` erreichbar.

### 4. Webserver installieren
1. **Arbeitsverzeichnis erstellen**:
```bash
mkdir ~/web && cd ~/web
```

2. **Beispielseite erstellen**:
```bash
mkdir ~/web/html
echo "<h1>Hello, World! (c) DerIngo</h1>" > ~/web/html/index.html
```

3. **`docker-compose.yml` für den Webserver erstellen**:
```bash
vim docker-compose.yml
```
Inhalt:
```yaml
services:
nginx:
image: nginx
container_name: nginx
restart: always
labels:
- "traefik.enable=true"
- "traefik.http.routers.nginx.rule=Host(`kaulbach.local`)"
- "traefik.http.routers.nginx.entrypoints=web"
volumes:
- "/var/run/docker.sock:/var/run/docker.sock:ro"
- "./html:/usr/share/nginx/html:ro"

networks:
default:
name: traefik-net
external: true
```

4. **Traefik-Labels nutzen**:
- Die Labels im obigen Beispiel sorgen dafür, dass Traefik den Webserver unter `http://kaulbach.local` bereitstellt.

5. **Container starten**:
```bash
docker compose up -d
# Log Files checken
docker logs web
```

6. **Webseite aufrufen**:
Die Webseite ist unter `http://kaulbach.local` erreichbar.

### 5. Portainer installieren
1. **Arbeitsverzeichnis erstellen**:
```bash
mkdir ~/portainer && cd ~/portainer
```

2. **`docker-compose.yml` für Portainer erstellen**:
```bash
vim docker-compose.yml
```
Inhalt:
```yaml
services:
portainer:
image: portainer/portainer-ce:latest
container_name: portainer
restart: always
volumes:
- "/var/run/docker.sock:/var/run/docker.sock:ro"
- "./data:/data"
labels:
- "traefik.enable=true"
- "traefik.http.routers.portainer.rule=Host(`portainer.kaulbach.local`)"
- "traefik.http.routers.portainer.entrypoints=web"
- "traefik.http.services.portainer.loadbalancer.server.port=9000"

networks:
default:
name: traefik-net
external: true
```

3. **Traefik-Labels nutzen**:
- Die Labels im obigen Beispiel sorgen dafür, dass Traefik das Portainer Dashboard unter `http://portainer.kaulbach.local` bereitstellt.

4. **Container starten**:
```bash
docker compose up -d
# Log Files checken
docker logs portainer
```

5. **Subdomain eintragen**
Auf dem Host System in der Datei ```C:\Windows\System32\drivers\etc\hosts``` den Eintrag für die Subdomain "portainer.kaulbach.local" hinzufügen:
192.168.178.47 portainer.kaulbach.local

6. **Dashboard aufrufen**:
Das Traefik-Dashboard ist unter `http://portainer.kaulbach.local` erreichbar.

7. **Portainer konfigurieren**
* Passwort für den User "admin" festlegen: "adminpassword".
* Environment "local" ist bereits angelegt

### 6. ein weiterer Webserver
1. **Webserver anlegen und starten**:
```bash
mkdir -p ~/web2/html
echo "<h1>Hello vom geheimnisvollen 2. Server</h1>" > ~/web2/html/index.html
touch ~/web2/docker-compose.yml # mit Inhalt s.u. befüllen
cd ~/web2
docker compose up -d
```

2. **`docker-compose.yml` für den Webserver erstellen**:
```yaml
services:
nginx:
image: nginx
container_name: nginx2
restart: always
labels:
- "traefik.enable=true"
- "traefik.http.routers.nginx2.rule=PathPrefix(`/derzweite`)"
- "traefik.http.routers.nginx2.entrypoints=web"
volumes:
- "/var/run/docker.sock:/var/run/docker.sock:ro"
- "./html:/usr/share/nginx/html:ro"

networks:
default:
name: traefik-net
external: true
```

3. **`docker-compose.yml` des ersten Webservers anpassen**:
Der Router des ersten Webservers mit dem Host(`kaulbach.local`) wird auch auf /derzweite matchen.
Daher müssen wir die Regel für den Router des ersten Servers anpassen:
```- "traefik.http.routers.nginx.rule=PathPrefix(`/`) && !PathPrefix(`/derzweite`)"```

4. **Webseite aufrufen**:
Die Webseite ist unter `http://kaulbach.local/derzweite` erreichbar.

## Abschluß
Das Fundament ist gelegt, darauf aufbauend kann ich die Migration der einzelnen Anwendungen erarbeiten.
Der Code-Editor, bzw. die Anzeige des Codes, des "Markup Markdown"-Editors ist ziehmlich kaputt. Und das was man sieht, sieht hässlich aus. Ich habe auch schon ein Ticket erstellt, ob und wie man andere Code-Editoren wie CodeMirror Blocks einbinden kann.
Die Dateien habe ich in [GitHub](https://github.com/DerIngo/localvirtualserver) eingecheckt.