Einrichtung eines Linux-Servers für wissenschaftliche Forschung

Kürzlich habe ich einen MiniPC in einen Server auf Basis von Ubuntu umgewandelt und ihn so konfiguriert, dass er den potenziellen Anforderungen zukünftiger Forschungsprojekte entspricht。

Da ich nur begrenzte Kenntnisse über Linux hatte, habe ich einige Zeit damit verbracht, mich einzuarbeiten und die Einrichtung zu dokumentieren – inklusive möglicher Probleme und deren Lösungen。

Einen neuen Benutzer mit Administratorrechten unter Ubuntu anlegen

Wenn Sie einen Ubuntu-Server (egal ob von einem Cloud-Anbieter oder selbst installiert) nutzen, wird standardmäßig ein Benutzerkonto erstellt。Dieser Benutzer kann mit sudo temporär Administratorrechte erhalten, ist aber kein echter Admin-Account。Um einen eigenen Benutzer mit denselben Rechten zu erstellen, gehen Sie wie folgt vor：

1. Neuen Benutzer mit Home-Verzeichnis und Shell anlegen

sudo useradd -d "/home/<user_name>" -m -s "/bin/bash" <user_name>

Parametererklärung：

-d "/home/<user_name>"：Setzt das Home-Verzeichnis。
-m：Erstellt das Home-Verzeichnis automatisch。
-s "/bin/bash"：Legt die Standardshell fest。

2. Dem neuen Benutzer Administratorrechte geben

Um einen Benutzer mit sudo-Rechten zu erstellen：

sudo useradd -d "/home/<user_name>" -m -s "/bin/bash" -G sudo <user_name>

-G sudo：Fügt den Benutzer der Gruppe sudo hinzu。

3. Passwort für den neuen Benutzer setzen

Standardmäßig hat der neue Benutzer kein Passwort。Setzen Sie eines mit：

sudo passwd <user_name>

Geben Sie das Passwort zweimal ein (es wird nichts angezeigt)。Danach kann der neue Benutzer mit sudo arbeiten。

Terminal-Optik verbessern

Ein schönes und funktionales Terminal erhöht die Arbeitsfreude。Ich empfehle zsh für ein ansprechendes Prompt。Details siehe frühere Anleitung。

Remote-Zugriff auf den Server aktivieren

Um von außerhalb auf den Ubuntu-Server zuzugreifen, installieren und konfigurieren Sie den SSH-Dienst und passen ggf. die Firewall an。

1. SSH-Server installieren und konfigurieren

Für grundlegenden SSH-Zugang genügt die Installation von openssh-server：

sudo apt update
sudo apt install openssh-server

Status prüfen：

sudo systemctl status ssh

Konfigurationstipps：
- Root-Login deaktivieren (empfohlen)：In /etc/ssh/sshd_config PermitRootLogin no setzen。
```
sudo nano /etc/ssh/sshd_config
```
```
PermitRootLogin no
```
- Zugelassene Benutzer einschränken：Mit AllowUsers nur bestimmten Benutzern SSH-Zugang erlauben。
```
AllowUsers <user_name>
```
- Nicht-Standard-Port verwenden (optional)：Port z.B. auf 2200 ändern。
```
Port 2200
```
- Automatische Trennung bei Inaktivität：
```
ClientAliveInterval 300
ClientAliveCountMax 2
```

Nach Änderungen SSH-Dienst neu starten：

sudo systemctl restart ssh

2. UFW-Firewall konfigurieren

Wenn UFW aktiviert ist, SSH-Port freigeben：

sudo ufw allow ssh

Bei geändertem Port (z.B. 2200)：

sudo ufw allow 2200/tcp

Firewall aktivieren und Status prüfen：

sudo ufw enable
sudo ufw status

3. SSH-Verbindung testen

Unter Windows empfiehlt sich PuTTY oder Windows Terminal。Verbindung testen：

telnet <remote_ip> <remote_port>

Ersetzen Sie <remote_ip> und <remote_port> entsprechend。

4. .Xauthority-Berechtigungsproblem beheben

Falls /home/<user_name>/.Xauthority falsche Rechte hat：

sudo chown <user_name>:<user_name> -R /home/<user_name>

Falls nötig, Datei neu anlegen：

sudo -u <user_name> touch /home/<user_name>/.Xauthority
sudo chown <user_name>:<user_name> /home/<user_name>/.Xauthority

5. Fail2Ban einrichten (empfohlen)

Zum Schutz vor Brute-Force-Angriffen：

sudo apt install fail2ban

Konfiguration in /etc/fail2ban/jail.local anpassen：

[sshd]
enabled = true
port = 22
maxretry = 5
bantime = 600

SSH-Verbindung zwischen Server und GitHub einrichten

So verbinden Sie Ihren Ubuntu-Server sicher mit GitHub：

1. Git installieren und prüfen

sudo apt install git
git --version

2. Git-Benutzerdaten konfigurieren

git config --global user.name "<github_account_name>"
git config --global user.email "<github_account_email>"

3. SSH-Schlüsselpaar generieren

ssh-keygen -C "<github_account_email>" -t rsa

Drücken Sie dreimal Enter, um Standardwerte zu übernehmen。

4. SSH-Public-Key zu GitHub hinzufügen

cat ~/.ssh/id_rsa.pub

Kopieren Sie den Inhalt und fügen Sie ihn unter GitHub → Settings → SSH and GPG keys → New SSH key ein。

5. Verbindung zu GitHub testen

ssh -T git@github.com

Bei Erfolg erscheint：

Hi <github_account_name>! You've successfully authenticated, but GitHub does not provide shell access.

6. Häufige Probleme und Lösungen

SSH-Key-Berechtigungen prüfen：

chmod 600 ~/.ssh/id_rsa
chmod 644 ~/.ssh/id_rsa.pub

Key zum SSH-Agent hinzufügen：

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_rsa

Python-Umgebung einrichten und verwalten

Miniforge

Für das Management von Python-Umgebungen empfehle ich Miniforge (leichtgewichtig, schnell, basiert auf conda-forge und Mamba)。

1. Miniforge installieren

Siehe Miniforge GitHub：

wget "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"
bash Miniforge3-$(uname)-$(uname -m).sh

Empfehlung：Installation in /usr/local/miniforge3 für gemeinsame Nutzung。
Bei ZSH：Pfad zu .zshrc hinzufügen：
```
export PATH="$usr/local/miniforge3/bin:$PATH"
```
Danach：source ~/.zshrc

2. Mamba initialisieren

/usr/local/miniforge3/bin/mamba init

Falls ZSH nicht automatisch erkannt wird, Konfiguration aus .bashrc übernehmen。

3. Umgebungen erstellen und verwalten

Empfohlen：Umgebungen als root anlegen。

Neue Umgebung erstellen

mamba create --name <new_env_name> python=3.11 --no-default-packages

Oder für private Umgebung：

mamba create --prefix /home/username/myenv python=3.11 --no-default-packages

Umgebung löschen

mamba remove --name <env_name> --all
mamba remove --prefix /path/to/directory --all

4. Häufig genutzte Pakete installieren

Nicht direkt im base-Environment arbeiten。Beispiel für Machine-Learning-Umgebung：

mamba create --name ml_env python=3.12 jupyterhub jupyterlab notebook notebook scipy numpy numpy
mamba activate ml_env
mamba install jupyter-lsp-python jupyterlab-lsp jupyterlab-git jupyterlab_execute_time

5. Schreibschutz für Umgebungen

Normale Nutzer können Systemumgebungen nicht aktualisieren：

mamba update --all

Fehlermeldung：

EnvironmentNotWritableError: The current user does not have write permissions to the target environment.
  environment location: /usr/local/miniforge3
  uid: 1000
  gid: 1000

Mit sudo kann ein Update durchgeführt werden：

sudo /usr/local/miniforge3/bin/mamba update --all

Poetry

Poetry ist ein effizientes Tool für das Management von Python-Projekten und Abhängigkeiten。

1. Poetry installieren

Python 3.7+ erforderlich。

curl -sSL https://install.python-poetry.org | python3 -

Pfad ggf. ergänzen：

export PATH="$HOME/.local/bin:$PATH"

Installation prüfen：

poetry --version

2. Neues Projekt anlegen

poetry new my_project

Struktur：

my_project/
├── my_project/
│   └── __init__.py
├── pyproject.toml
└── tests/
    └── __init__.py

Vorhandenes Projekt initialisieren：

cd existing_project
poetry init

3. Abhängigkeiten verwalten

Produktiv-Abhängigkeit hinzufügen：

poetry add requests

Entwickler-Abhängigkeit：

poetry add pytest --dev

Alle Abhängigkeiten installieren：

poetry install

4. Virtuelle Umgebung verwalten

Aktivieren：

poetry shell

Verlassen：exit

Pfad anzeigen：

poetry env info --path

Umgebung löschen：

poetry env remove python

5. Lock-Datei verwalten

Abhängigkeiten aktualisieren：

poetry update

Installieren gemäß Lock-Datei：

poetry install

6. Skripte und Befehle ausführen

Im virtuellen Environment：

poetry run python script.py
poetry run pytest

7. Python-Paket veröffentlichen

Bauen：

poetry build

Auf PyPI veröffentlichen：

poetry publish --build

Für Test-PyPI：

poetry publish --repository testpypi

Im Folgenden eine Anleitung zur Einrichtung einer R-Umgebung für ökonometrische Analysen。

R-Umgebung unter Ubuntu für Ökonometrie einrichten

R eignet sich hervorragend für ökonometrische Analysen, Regressions- und Zeitreihenanalysen。

1. R installieren

Für die neueste Version CRAN-Repository hinzufügen：

sudo apt update
sudo apt install software-properties-common dirmngr -y

GPG-Key hinzufügen：

wget -qO- https://cloud.r-project.org/bin/linux/ubuntu/marutter_pubkey.asc | sudo tee -a /etc/apt/trusted.gpg.d/cran_ubuntu_key.asc

Key prüfen (optional)：

gpg --show-keys /etc/apt/trusted.gpg.d/cran_ubuntu_key.asc

CRAN-Repository hinzufügen：

sudo add-apt-repository "deb https://cloud.r-project.org/bin/linux/ubuntu $(lsb_release -cs)-cran40/"

R und Dev-Pakete installieren：

sudo apt install r-base r-base-dev -y

2. RStudio installieren

RStudio ist eine leistungsfähige IDE für R。Installationsanleitung siehe RStudio-Website。

RStudio Server herunterladen。

Installieren：

sudo dpkg -i rstudio-server-<version>.deb

Status prüfen：
```
sudo systemctl status rstudio-server
```

Danach erreichbar unter http://<your-server-ip>:8787。

3. Ökonometrie-Pakete installieren

Systemabhängigkeiten installieren：

sudo apt-get install build-essential libssl-dev libcurl4-openssl-dev libxml2-dev

R-Konsole starten：

sudo R

Pakete installieren：

chooseCRANmirror(graphics = FALSE)
install.packages(c("tidyverse", "data.table", "broom", "plm", "forecast", "lmtest", "sandwich", "stargazer"))

Weitere Pakete：

install.packages(c("AER", "urca", "vars"))
install.packages(c("quantmod", "TTR", "zoo", "xts"))

4. GitHub-Token für private Pakete

Token generieren：

usethis::create_github_token()

Token in R speichern：

gitcreds::gitcreds_set()

5. Beispiel：Paneldatenregression mit `plm`

library(plm)

data("Produc", package = "plm")
pdata <- pdata.frame(Produc, index = c("state", "year"))

fe_model <- plm(log(gsp) ~ log(pcap) + log(hwy) + log(water) + log(util), data = pdata, model = "within")
summary(fe_model)

Sonstige Hinweise

1. Daten synchronisieren

Mit rsync Daten effizient übertragen。Details siehe dieses Tutorial。

rsync -r /path/to/sync/ <username>@<remote_host>:<destination_directory>

Fortschritt großer Dateien überwachen：

watch -n <time_interval> du -sh /path/to/large/file

2. Standard-Schriftarten installieren

Microsoft TrueType-Fonts installieren：

sudo apt install msttcorefonts
rm -rf ~/.cache/matplotlib

3. Treiber-/Bibliotheksversionen stimmen nicht überein

Fehler bei nvidia-smi：

Failed to initialize NVML: Driver/library version mismatch

Siehe Stack Overflow-Lösung：

Server neu starten：
```
sudo reboot
```

Nvidia-Treiber neu installieren：

sudo apt purge nvidia* libnvidia*
sudo ubuntu-drivers install
sudo reboot

4. Nvidia-Treiber aktualisieren

Alte Treiber entfernen：

sudo apt purge *nvidia* -y
sudo apt remove *nvidia* -y
sudo rm /etc/apt/sources.list.d/cuda*
sudo apt autoremove -y && sudo apt autoclean -y
sudo rm -rf /usr/local/cuda*

Empfohlene Treiberversion suchen und installieren：

ubuntu-drivers devices
sudo apt install libnvidia-common-550-server libnvidia-gl-550-server nvidia-driver-550-server -y

Neustart und Prüfung：

sudo reboot now

Bei Fehler：

NVIDIA-SMI has failed because it couldn't communicate with the NVIDIA driver.

Kernel-Header neu installieren und neu starten。

5. Kernel-Header und GCC

Kernel-Header neu installieren：

sudo apt install --reinstall linux-headers-$(uname -r)
sudo reboot

GCC-Version aktualisieren：

Wenn Fehler auftreten, GCC auf Version 12 aktualisieren：
```
sudo apt-get install gcc-12
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-12 12
```
Kernel-Header erneut installieren und Server neu starten。Danach sollte nvidia-smi funktionieren。