Categories
Linux

Lokaler virtueller Server

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 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 von Oracle verwenden.

graph TD G[Portainer Webinterface] --> F H[Website: Nginx] --> F I[Mailserver: Postfix/Dovecot] --> F F[Traefik] --> E E[Portainer] --> D D[Docker] --> C C[Ubuntu 24.04 LTS] --> B B[VirtualBox] --> A A[Host System: PC]

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
    • 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

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:

    sudo apt update
    sudo apt upgrade -y
  2. Abhängigkeiten installieren:

    sudo apt install -y ca-certificates curl gnupg
  3. Docker-Repository hinzufügen:

    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:

    sudo apt update
    sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
  5. Docker-Dienst aktivieren:

    sudo systemctl enable docker
    sudo systemctl start docker
  6. Rechte für den aktuellen Benutzer konfigurieren:

    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:

docker compose version

3.0 Traefik Netzwerk anlegen

Alle mit dem Traefik Dienst verbundenen Container sollen im selben Netzwerk liegen:

docker network create traefik-net

3. Traefik installieren

  1. Arbeitsverzeichnis erstellen:

    mkdir ~/traefik && cd ~/traefik
  2. docker-compose.yml für Traefik erstellen:

    vim docker-compose.yml

    Inhalt:

    
    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:

entryPoints:
  web:
    address: ":80"

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

api:
  dashboard: true
  insecure: true
  1. Container starten:

    docker compose up -d
    # Log Files checken
    docker logs traefik
  2. 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

  3. Dashboard aufrufen: Das Traefik-Dashboard ist unter http://traefik.kaulbach.local erreichbar.

4. Webserver installieren

  1. Arbeitsverzeichnis erstellen:

    mkdir ~/web && cd ~/web
  2. Beispielseite erstellen:

    mkdir ~/web/html
    echo "<h1>Hello, World! (c) DerIngo</h1>" > ~/web/html/index.html
  3. docker-compose.yml für den Webserver erstellen:

    vim docker-compose.yml

    Inhalt:

    
    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
  1. Webseite aufrufen: Die Webseite ist unter http://kaulbach.local erreichbar.

5. Portainer installieren

  1. Arbeitsverzeichnis erstellen:

    mkdir ~/portainer && cd ~/portainer
  2. docker-compose.yml für Portainer erstellen:

    vim docker-compose.yml

    Inhalt:

    
    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
  1. 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

  2. Dashboard aufrufen: Das Traefik-Dashboard ist unter http://portainer.kaulbach.local erreichbar.

  3. Portainer konfigurieren

    • Passwort für den User "admin" festlegen: "adminpassword".
    • Environment "local" ist bereits angelegt

6. ein weiterer Webserver

  1. Webserver anlegen und starten:

    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:

    
    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.<br>
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.<br>
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.<br>
Die Dateien habe ich in [GitHub](https://github.com/DerIngo/localvirtualserver) eingecheckt.
Categories
Development

Windows Sandbox

Ich möchte ein Programm aus dem Internet testen und es dazu in einer abgeschotteten Umgebung laufen lassen, damit alles, was das Programm in dieser Sandbox anstellt keinerlei Auswirkungen auf das umgebende System hat.

Vor vielen Jahren hatte ich schon einmal das Programm Sandboxie verwendet, um einen Browser in einer isolierten Umgebung laufen zu lassen.

Eine andere Alternative wäre es, ein virtuelles System mittels VMware oder VirtualBox aufzusetzen und Windows zu installieren, bzw. eine virtuelle Entwickler Maschine von Microsoft zu verwenden. Das hatte ich in der Vergangenheit öfters verwendet, das funktioniert sehr gut, ist aber auch etwas aufwändiger.

Für Windows 10 und 11 Pro (bzw. Enterprise, was ich verwende) gibt es inzwischen eine einfacherer Alternative: Die Windows Sandbox, die direkt in das Betriebssystem integriert ist. Und diese Sandbox möchte ich jetzt testen.

Installation

Ich verwende Windows 10 Enterprise und die Virtualisierungsfunktionen im BIOS sind aktiviert.

Um Sandbox mit PowerShell zu aktivieren, öffnen ich PowerShell als Administrator, und führe den folgenden Befehl aus:

Enable-WindowsOptionalFeature -FeatureName "Containers-DisposableClientVM" -All -Online

Anschließend ist ein Neustart erforderlich, um den Vorgang abzuschließen.

Nach dem Neustart ist die Windows-Sandbox im Startmenü zu finden:

Verwendung

Aus dem Startmenü heraus Windows Sandbox starten:

Per Copy&Paste lassen sich Dateien vom Host in das Sandbox Fenster kopieren. Per Drag&Drop funktioniert es leider nicht.
Alternativ lassen sich die benötigten Dateien auch innerhalb der Sandbox herunterladen, so wie im nachfolgenden Beispiel.

Test

In der Sandbox den Browser öffnen, die zu installierende Software suchen und herunterladen. In meinem Test wird es der foxit PDF Editor sein.

Ich entscheide mich für die Version: PDF EDITOR PRO 13

Nach dem Herunterladen und Installieren wird noch eine "Microsoft Edge WebView2" Komponente benötigt. Diese lässt sich bequem innerhalb der Sandbox installieren.

Sobald die Komponente installiert ist lässt sich der PDF Editor in der kostenlosen Testversion starten.

Ich teste den PDF Editor. [TODO nächster Post]

Nach Abschluss der Test kann ich die Sandbox wieder schließen. Dabei gehen alle Daten verloren, so dass beim nächsten Start der Sandbox wieder ein frisches System zur Verfügung steht.

Fazit

Die Windows Sandbox ist ein tolles, leicht zu bedienendes Tool, um schnell Software oder dubiose Webseiten zu testen.

Dass am Ende immer alle Daten gelöscht werden hat den Vorteil, dass man beim nächsten Start mit einem frischen System neu starten kann.
Aber es ist auf der anderen Seite auch ein Nachteil, dass man keine Software dauerhaft speichern kann, um sie bei der nächsten Verwendung wieder verwenden zu können. Beispielsweise wenn ich einen bestimmten Browser mit ausgewählten Erweiterungen verwenden möchte.

Ich weiß nicht mehr ganz genau, wie das mit Sandboxie war, soweit ich mich erinnern kann, wurde zB der Browser in Sandboxie installiert und und konnte dann direkt aufgerufen werden, wie eine normale Anwendung. Ob die Einstellungen, Browserverlauf etc. gespeichert wurden weiß ich nicht mehr.

Mit einer richtigen virtuellen Maschine ist man flexibler: Windows und Lieblingssoftware installieren und einrichten, VM herunterfahren und dann die virtuelle Festplatte auf nicht persistent stellen. Dann startet man immer mit seiner eigenen vorkonfigurierten Umgebung, kann ebenfalls nach herzenslust testen und nach einem Neustart ist alles wieder frisch.
In der Praxis ist das aber nicht immer ganz so unproblematisch: Es gibt immer wieder neue Windows und Software Updates, die dann nach einem Neustart im Hintergrund gezogen und ggf. sogar installiert werden. Das kann man sicherlich auch anders konfigurieren, ist aber wieder weiterer Aufwand. Oder man startet regelmäßig neu, nachdem man die virtuelle Festplatte auf persistent umgestellt hat, installiert alle Updates, fährt herunter und dann wieder die virtuelle Festplatte auf nicht persistent umstellen. Wenn man aber nur alle paar Monate die VM verwenden möchte, ist man uU genausolange mit updaten beschäftigt, wie man sie für das Testen verwenden möchte. Da ist dann die Windows Sandbox doch schneller und unkomplizierter.