Archiv der Kategorie: Server

Update PHP auf Version 8 für nextcloudpi

Aktuelle php_Version prüfen

php -v

PHP8 installieren

apt-get -y install php8.0-fpm php8.0-mysql php8.0-xml php8.0-zip php8.0-mbstring php8.0-gd php8.0-curl php8.0-redis php8.0-intl php8.0-bcmath php8.0-gmp php8.0-imagick imagemagick

PHP8-konfiuration aktualisieren

Symbolischer Link auf die NCP-PHP-Konfiguration

ln -s /etc/php/7.4/fpm/conf.d/90-ncp.ini /etc/php/8.0/fpm/conf.d/90-ncp.ini
systemctl restart php8.0-fpm

image magick Modul aktivieren

phpenmod -v 8.0 imagick

Apache für PHP 8.0 einrichten

Apache für php8.0 konfigurieren

a2enmod proxy_fcgi setenvif
a2enconf php8.0-fpm

PHP 7.4 für apache deaktivieren

a2disconf php7.4-fpm

Apache neu starten

systemctl reload apache2

Aktuelle php_Version prüfen


php -v

wenn 8.0 nicht aktiviert ist, dann mit update-alternatives --config php auswählen.

Nextcloud APPs aktualisieren

cd /var/www/nextcloud
sudo -u www-data php ./occ app:update -all

UFW – uncomplicated firewall

Einzelne Ports freigeben

ufw allow 8200/tcp
ufw allow 1900/udp

IP-Bereich blockieren

ufw deny from 159.223.224.0/24

Einzelne Regeln löschen

Nach Nummer

Regeln mit Nummerierung anzeigen:
ufw status numbered

Regel nach Nummer „NUM“ löschen:
ufw delete NUM

nach Protokoll/Port

ufw delete allow http
ufw delete allow 80

Speicherort für die Regeln

/etc/ufw
/etc/ufw/user.rules
/etc/ufw/user6.rules

Auswerten der nextcloud.log

Das folgende Skript erst erstellt automatisch Deny-Regeln für die ufw auf Basis der Nextcloud-Logdatei. Das Script ist an die jeweilige Installation anzupassen und kann im ungünstigsten Fall auch berechtigte Benutzer aussperren.

#/bin/bash

# IP-Adressen mit fehlerhaften Nextcloud-Loginversuchen werden in ufw als "DENY" eingetragen und somit gesperrt
# Die Anzahl an ungültigen Login-Versuchen, die dabei ignoriert werden, kann mit der Variable "logcount" definiert werden.

# Variablen setzen
logcount="1,2,3"  # Suchparameter für sed zum Löschen der Login-Versuche mit der angegebenen Anzahl
nclogfile="/var/www/nextcloud/nextcloud.log"
tmpfile1="/tmp/ufw_addIPfromNC_IPoutNC.txt"
tmpfile2="/tmp/ufw_addIPfromNC_IPoutUFW.txt"
tmpfile3="/tmp/ufw_addIPfromNC_IPaddtoUFW.txt"
tmpfile4="/tmp/ufw_addIPfromNC_whois.txt"
logfile="/var/log/ufw_addIPfromNC.log"

# NC-Logdatei auslesen
echo "IP-Adressen mit mehr als $logcount Fehlanmeldungen aus der Nextclud-Logdatei auslesen ..."
tail -n 1000 "$nclogfile" | grep "Trusted domain error" | awk '{print $4}' | tr -d '\\"' | sed "/192.*$/d" | sort -g | sed 's/\.[^.]*$/./' | uniq -c | sed "/.* [$logcount] .*$/d" | awk '{print $2}' | tee "$tmpfile1"
#- Anmerkungen -# Letzten 1000 Zeilen der NC-Logdatei auslesen | Fehlerhafte Loginversuche suchen | IP-Adressen ermitteln (spalte 4) | \ und " löschen | IP 192.x löschen | sortieren | Letzter Block der IP löschen | gleiche zählen | Zeilen mit $logcount-Versuchen löschen | nur IP-Adressen (Spalte 2) | in tmp-File speichern

# ufw "DENY"_liste auslesen
echo "In ufw bereits geblockte IP-Adressen auslesen ..."
ufw status | grep "DENY"   | awk '{print $3}' | sort | sed 's/0\/24//g' | tee "$tmpfile2"
#- Anmerkungen -# ufw-Filterliste ausgeben | geblockte IPs | nur IP-Adresse | sortieren | "0/24" entfernen | in tmp-File speichern

# IP-Listen vergleichen
echo "Noch nicht geblockte IP-Adressen ermitteln ..."
diff "$tmpfile1" "$tmpfile2" | grep "<" | tr -d "< " | tee "$tmpfile3"

# Neue ufw-Regeln erstellen
echo "IP-Adressen in ufw eintragen ..."
while read IP; do
   IPrange=$IP"0/24"
   whois "$IP"1 > "$tmpfile4"
   IP_name=$(cat "$tmpfile4" | grep -i -m 1 netname | awk '{print $2, $3, $4, $5, $6}')
   IP_country=$(cat "$tmpfile4" | grep -i -m 1 country | awk '{print $2}')
   echo $IPrange" ("$IP_name"- country: "$IP_country")"
   echo "ufw deny from $IPrange"
   resp=$(ufw deny from "$IPrange")
   echo $resp
   echo $(date "+%Y.%m.%d %H:%M:%S")" ["$resp"] "$IPrange" ("$IP_name"- country: "$IP_country")" >> $logfile
done < "$tmpfile3"

# Temporäre Dateien löschen
rm "$tmpfile1" "$tmpfile2" "$tmpfile3" "$tmpfile4" 2> /dev/null

exit

PiHole auf einem „RaspberryPi Zero W“ installieren

Raspbian Lite herunterladen und auf SD-Karte installieren

Prinzipiell kann als Basis jedes Linuxsystem verwendet werden. Sehr klein und schlank ist Raspbian lite, das hier heruntergeladen werden kann:

https://www.raspberrypi.org/software/operating-systems/#raspberry-pi-os-32-bit

Dann das System entsprechend der Anleitung auf oben genannter Seite (z. B. mit Balena Etcher) installieren.

Karte auswerfen und neu mounten.

SSH und WLAN einrichten

SSH

Auf der Bootpartition der SD-Karte vor dem ersten Start die Datei ssh erzeugen:

touch ssh

Die Datei ssh kann leer bleiben. Diese aktiviert permanent den automatischen Start von SSH (und wird vom System nach dem ersten Start automatisch wieder gelöscht).

WLAN

Auf der Bootpartition der SD-Karte vor dem ersten Start die Datei wpa_supplicant.conf erzeugen:

vim wpa_supplicant.conf

mit folgendem Inhalt:

country=DE
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
ap_scan=1
network={
scan_ssid=1
ssid="wlanname"
psk="unserpasswort"
key_mgmt=WPA-PSK
}

Dabei wlanname und unserpasswort entsprechend der WLAN-Zugangsdaten anpassen.

Bei ersten Systemstart wird die Datei automatisch nach /etc/wpa_supplicant verschoben und kann dort bei Bedarf nachträglich jeder Zeit noch angepasst/korrigiert werden.

Hostname

Der Name kann von rasperrypi z.B. auf pihole abgeändert werden:

  • hostname pihole
  • In /etc/hosts anpassen
  • In /etc/hostname anpassen

Router einrichten

Hier am Beispiel der FitzBox 7490 Version 7.29

  • In den Netzwerkeinstellungen dem RaspberryPi einen eindeutigen Namen (z.B. PiHole) geben und insbesondere eine IP fest zuordnen.

Möglichkeit 1

Der Pi-Hole erfasst so jedes einzelne Gerät, das Gastnetz ist aber nicht betroffen.

  • Heimnetz - Netzwerk - Netzwerkeinstellungen
  • ganz unten: weitere Einstellungen
  • IPv4-Einstellungen
  • Bei Lokaler DNS-Server die IP das Pi-Hole eintragen
  • IPv6-Einstellungen
  • DNSv6-Server im Heimnetz abschalten oder die IPv6-Adresse des Pi-Hole eintragen

Möglichkeit 2

Die FritzBox leitet alle DNS-Abfragen über den Pi-Hole.

  • Diese IP dann unter Internet/Zugangsdaten/DNS-Server als Bevorzugter DNSv4-Server eintragen. Dort zusätzlich einen Alternativen DNSv4-Server (z.B. 8.8.8.8) eintragen, damit das Internet auch noch funktioniert, wenn der PiHole mal hängt oder nicht online ist.

Erste Start des RaspberryPi Zero

Die SD-Karte in den Raspberry einlegen, booten und per SSH einloggen:

ssh pi@pihole

Anstatt pihole muss ggf. der im Router eingestellte Namen bzw. IP-Adresse eingegeben werden.

Standard-Passwort bei Verwendung von Raspbian: raspberry

Neus passwort setzen:

passwd

SSH Root-Login

Sofern ein Root-Login möglich sein soll, muss zunächst ein Root-Passwort gesetzt werden:

sudo passwd

Sofern sich root über ein Passwort einloggen soll, muss in der Datei /etc/ssh/sshd_config folgender Eintrag gesetzt werden:

PermitRootLogin yes

… oder anstatt Passwort die sicherere Variante über Public-Key (siehe auch SSH):

PermitRootLogin prohibit-password

Danach den ssh-Server neu starten:

service ssh restart

Pi-Hole installieren und einrichten

PiHole kann durch ein Skript entsprechend der Anleitung unter https://github.com/pi-hole/pi-hole/#one-step-automated-install installiert werden:

wget -O ph.sh https://install.pi-hole.net 
bash ph.sh

oder:

curl -sSL https://install.pi-hole.net | bash

Alle notwendigen Konfigurationen werden während der Installation abgefragt. In der Regel sind die vorausgewählten Konfigurationen auch die Sinnvollsten.

Bei Bedarf kann das am Ende des Installationsprozesses angezeigte Passwort auch geändert werden:

pihole -a -p

Webinterface aufrufen

Den RaspberryPi neu booten und dann auf einem anderen Computer im Netz im Browser eingeben:

http://<IP des RaspberryPi>/admin

Dabei anstatt <IP des RaspberryPi> die zuvor fest vergebene IP eingeben.

Update

Sobald Updates für PiHole vorhanden sind, wird dies am unteren Rand des Webinterfaces angezeigt. Um ein Update für PiHole durchzuführen, muss folgender Befehl über die Konsole (Login z. B. über ssh) eingegeben werden:

pihole -up

Proxyserver

Einrichtung des Proxys für einen bestimmten Benutzer:  ~/.profile
Systemweite Einrichtung des Proxys: /etc/profile

Bei manchen Systemen wie z. B. Lubuntu müssen zusätzlich in die Dateies /etc/environment und /etc/apt/apt.conf.d/70debconf ergänzt werden. In /etc/environment werden die gleichen Eintragungen wie in der profile-Datei vorgenommen (jedoch ohne das führende „export“). Die Datei /etc/apt/apt.conf.d/70debconf wird wie folgt ergänzt (je nach System kann der Dateiname etwas variieren):

Acquire::http
 {
 Proxy "http://<Benutzername>:<Passwort>@<Proxy>:<Port>";
 }

Folgende Zeilen müssen am Ende der profile-Datei hinzugefügt werden:

export http_proxy=http://BENUTZER:PASSWORD@SERVER-IP_ODER_NAME:PORT
export https_proxy=http://BENUTZER:PASSWORD@SERVER-IP_ODER_NAME:PORT
export ftp_proxy=http://BENUTZER:PASSWORD@SERVER-IP_ODER_NAME:PORT
export no_proxy=localjost
export HTTP_PROXY=$http_proxy
export HTTPS_PROXY=$https_proxy
export FTP_PROXY=$ftp_proxy
export NO_PROXY=$no_proxy

Sofern keine Logindaten benötigt werden, kann „BENUTZER:PASSWORD@“ weggelassen werden.

 

xampp

xampp ist eine PHP-Entwicklungsumgebung mit Datenbank.

Download unter: https://www.apachefriends.org/de/index.html

Die Installation von xampp

Die heruntergeladene Datei ausführbar machen und starten. xampp wird nach /opt/lampp istalliert
mit /opt/lampp/xampp start starten
mit http://localhost/ testen
In der Datei /opt/lampp/etc/httpd.cond die Einträge User und Group auf den entsprechenden Linux-User anpassen, sonst geht kein FTP beim Installieren von Plugins

xampp beim Systemstart starten
Runlevel mit who -r herausfinden

In den entsprechenden Runlevel wechseln: cd /etc/rc2.d
Links erstellen:

ln -s /opt/lampp/lampp S99lampp
ln -s /opt/lampp/lampp K01lampp

Wenn ein in htdocs installiertes Programm meldet „php not found“ hilft:

export PATH=$PATH:/opt/lampp/bin

Seafile

SeaFile und OwnCloud

Cloud-Fileserver, der (insbesondere bei vielen kleinen Dateien) sehr viel schneller arbeitet als OwnCloud. Daher lohnt sich auch die Kombination, OwnCloud für die Synchronisation von Kalender, Aufgaben sowie Kontakte zu verwenden und Seafile für die Dateisynchronisation.

Eine sehr ausführliche Anleitung gibt es auch unter http://manual.seafile.com/deploy/using_mysql.html

SeaFile installieren

Die aktuelle Version kann unter http://seafile.com/en/download/ heruntergeladen werden. Für den Banana Pi mit Bananian als System kann das Server-Paket für den Raspberry Pi verwendet werden.

Die Installation erfolgt durch Entpacken in ein eigenes Verzeichnis z. B. unter /root

cd /root
mkdir seafile
# Die zuvor heruntergeladene Installationsdatei hier her kopieren
tar -xzf seafile-server_*
mkdir installed
mv seafile-server_* installed

Beim Entpacken wird der Symbolische Link seafile-server-latest erstellt, der auf das aktuelle Verzeichnis verweist. Bei einem Update muss dann das neue Archiv nur wie oben beschrieben entpackt werden und schon ist die neue Version installiert ohne dass die alte Version überschrieben wird. Auch die Einstellungen bleiben erhalten.

Abhängigkeiten installieren

Folgende Pakete werden für Seafile benötigt:

  • python 2.7
  • python-setuptools
  • python-imaging
  • python-mysqldb
apt-get update
apt-get install python2.7 python-setuptools python-imaging python-mysqldb

MySQL-Datenbanken erstellen

Zuvor muss MySQL vollständig eingerichtet sein. Dies wird im Kapitel zur Owncloud-Installation im Detail beschrieben.

Folgende SeaFile-Komponenten benötigen jeweils eine eigene Datenbank:

  • ccnet server
  • seafile server
  • seahub

Die einfachste Möglichkeit ist, das Konfigurationsscript setup-seafile-mysql.sh im aktuellen Seafile-Ordner zu verwenden:

/root/seafile/seafile-server-latest/setup-seafile-mysql.sh

Das Skript führt detailliert durch die gesamte Konfiguration. Hier ein Beispiel für eine lokale Installation:

-----------------------------------------------------------------
This script will guide you to setup your seafile server using MySQL.
Make sure you have read seafile server manual at
        https://github.com/haiwen/seafile/wiki
Press ENTER to continue
-----------------------------------------------------------------

What is the name of the server? It will be displayed on the client.
3 - 15 letters or digits
[ server name ] tuxcloud

What is the ip or domain of the server?
For example: www.mycompany.com, 192.168.1.101
[ This server's ip or domain ] 192.168.1.9

Which port do you want to use for the ccnet server?
[ default "10001" ] 10001

Where do you want to put your seafile data?
Please use a volume with enough free space
[ default "/root/seafile/seafile-data" ] /mnt/hdd/seafile

Which port do you want to use for the seafile server?
[ default "12001" ] 12001

Which port do you want to use for the seafile fileserver?
[ default "8082" ] 8082

-------------------------------------------------------
Please choose a way to initialize seafile databases:
-------------------------------------------------------

[1] Create new ccnet/seafile/seahub databases
[2] Use existing ccnet/seafile/seahub databases

[ 1 or 2 ] 1

What is the host of mysql server?
[ default "localhost" ] localhost

What is the port of mysql server?
[ default "3306" ] 3306

What is the password of the mysql root user?
[ root password ] 

verifying password of user root ...  done

Enter the name for mysql user of seafile. It would be created if not exists.
[ default "root" ] 

Enter the database name for ccnet-server:
[ default "ccnet-db" ] 

Enter the database name for seafile-server:
[ default "seafile-db" ] 

Enter the database name for seahub:
[ default "seahub-db" ] 

---------------------------------
This is your configuration
---------------------------------

    server name:            tuxcloud
    server ip/domain:       192.168.1.9
    ccnet port:             10001

    seafile data dir:       /mnt/hdd/seafile
    seafile port:           12001
    fileserver port:        8082

    database:               create new
    ccnet database:         ccnet-db
    seafile database:       seafile-db
    seahub database:        seahub-db
    database user:          root

Sollen viele Clients auf Seafile zugreifen, sollte zuvor ulimit erhöht werden:

ulimit -n 30000

Server starten

./seafile.sh start 
./seahub.sh start

Beim ersten Start von Seahub wird ein Admin-Account erstellt. Der User-Name bei Seafile ist immer eine E-Mail-Adresse.

Danach kann der erste Zugriff über einen Browser erfolgen:

http://192.168.1.9:8000/

 Beim Systemstart automatisch starten

Hierzu wird als root ein Init-Script erstellt (/etc/init.d/seafile-server):

#!/bin/bash
### BEGIN INIT INFO
# Provides: Seafile Server
# Required-Start: $remote_fs $syslog
# Required-Stop: $remote_fs $syslog
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Start Seafile-Daemon at boot time
# Description: Enable service provided by Seafile.
### END INIT INFO

export LC_ALL='de_DE.UTF-8'
 
# Change the value of "seafile_dir" to your path of seafile installation
seafile_dir=/root/seafile
script_path=${seafile_dir}/seafile-server-latest
seafile_init_log=${seafile_dir}/logs/seafile.init.log
seahub_init_log=${seafile_dir}/logs/seahub.init.log
 
# Change the value of fastcgi to true if fastcgi is to be used
fastcgi=false
# Set the port of fastcgi, default is 8000. Change it if you need different.
fastcgi_port=8000
 
case "$1" in
 start)
 ${script_path}/seafile.sh start >> ${seafile_init_log}
 if [ $fastcgi = true ];
 then
 ${script_path}/seahub.sh start-fastcgi ${fastcgi_port} >> ${seahub_init_log}
 else
 ${script_path}/seahub.sh start >> ${seahub_init_log}
 fi
 ;;
 restart)
 ${script_path}/seafile.sh restart >> ${seafile_init_log}
 if [ $fastcgi = true ];
 then
 ${script_path}/seahub.sh restart-fastcgi ${fastcgi_port} >> ${seahub_init_log}
 else
 ${script_path}/seahub.sh restart >> ${seahub_init_log}
 fi
 ;;
 stop)
 ${script_path}/seafile.sh $1 >> ${seafile_init_log}
 ${script_path}/seahub.sh $1 >> ${seahub_init_log}
 ;;
 *)
 echo "Usage: /etc/init.d/seafile {start|stop|restart}"
 exit 1
 ;;
esac

Dann das Script ausführbar machen und rc.d aktualisieren:

chmod 755 /etc/init.d/seafile-server
update-rc.d seafile-server defaults

Manche Systeme starten den Server nach einen Reboot nicht, da Apache noch nicht läuft. Daher kann der Start über einen Cron-Job nachgeholt werden (Eintrag in /etc/crontab):

@reboot sleep 60 && service seafile-server start

Mitgelieferte Skripte

seaf-gc.sh

Seafile verwaltet die Dateien in Datenblöcken. Alte Datenblöcke von gelöschten Dateien und Bibliotheken werden jedoch nicht automatisch gelöscht, wodurch der von Seafile benötigte Speicher immer mehr anwächst. Somit empfiehlt es sich, unnötige Datenblöcke löschen zu lassen. Hierzu muss nur das Skript seaf-gc.sh im Seafile-Ordner gestartet werden:

/root/seafile/seafile-server-latest/seaf-gc.sh

Das entfernen unnötiger Datenblöcke ist z. B. vor dem Erstellen eines Backups zu empfehlen (siehe Kapitel Backup).

seaf-fsck.sh

Nach einem Systemabsturz kann die Dateistruktur von Seafile defekt sein. hierzu gibt es ein eigenes Script, das fehlerhafte Strukturen reparieren kann:

/root/seafile/seafile-server-latest/seaf-fsck.sh

reset-admin.sh

Wenn man das Admin-Passwort vergessen hat oder der Admin-Account nicht mehr richtig funktioniert, kann mit dem Tool reset-admin.sh der Admin-Account zurückgesetzt werden.

/root/seafile/seafile-server-latest/reset-admin.sh

seaf-fuse.sh

Stellt die Dateistruktur aller User und Bibliotheken in einem Verzeichnis dar, das mit dem Script seaf-fuse.sh gemountet wird. Allerdings besteht auf dieses Verzeichnis nur lesender Zugriff.

mkdir /mnt/seafile-fuse
/root/seafile/seafile-server-latest/seaf-fuse.sh start /mnt/seafile-fuse

Unmounten geht wie folgt:

/root/seafile/seafile-server-latest/seaf-fuse.sh stop

Backup

Anbei ein Skript für ein Backup mit MySQL und storeBackup. Zunächst wird der Seafile-Server gestoppt, damit im Backup ein definierter Zustand gespeichert wird. Dann werden unnötige Datenblöcke gelöscht (seaf-gc.sh) und die Datenbanken gesichert.
Als Backup-Programm wird storeBackup verwendet. Die verwendete Konfigurationsdatei wird im Skript unter /root/bin/storeBackup/seafile.cfg gesucht. Da die Datenbanken zuvor in den Daten-Ordner von Seafile gesichert wurden, sind diese ebenfalls im Backup enthalten.
Am Ende wird der Seafile-Server wieder gestartet.

seafile=/mnt/hdd/seafile
[ -f "$seafile/database-backup" ] || mkdir -p "$seafile/database-backup"
service seafile-server stop
/root/seafile/seafile-server-latest/seaf-gc.sh
mysqldump --lock-tables -h localhost -u root -p<PASSWORT> ccnet-db   > "$seafile/database-backup/ccnet-db.bak"
mysqldump --lock-tables -h localhost -u root -p<PASSWORT> seafile-db > "$seafile/database-backup/seafile-db.bak"
mysqldump --lock-tables -h localhost -u root -p<PASSWORT> seahub-db  > "$seafile/database-backup/seahub-db.bak"
storeBackup -f /root/bin/storeBackup/seafile.cfg
service seafile-server start

Backup zurückspielen:

mysql -h localhost -u root -p<PASSWORT> ccnet-db   < ccnet-db.bak
mysql -h localhost -u root -p<PASSWORT> seafile-db < seafile-db.bak
mysql -h localhost -u root -p<PASSWORT> seahub-db  < seahub-db.bak

Update

Mit folgendem Script kann eine neue Version von Seafile automatisch eingespielt werden. Es muss lediglich die neue Versionsnummer eingegeben werden. Das Script ist für den Raspberry-Pi bzw. Banana-Pi geschrieben und muss für andere Systeme ggf. angepasst werden.

#! /bin/bash

# Variablen definieren
[ "$1" == "" ] && read -p "Bitte Version eingeben (z.B. 4.2.3): " ver || ver=$1
download_path=/root/Software
seafile_path=/root/seafile

# Seafile herunterladen
cd $download_path
wget https://github.com/haiwen/seafile-rpi/releases/download/v$ver/seafile-server_${ver}_pi.tar.gz 

# Seafile-Server entpacken ...
echo "seafile-server_${ver}_pi.tar.gz wird entpackt ..."
cd $seafile_path
tar -xzvf $download_path/seafile-server_${ver}_pi.tar.gz

# Seafile Server anhalten
echo "Seafile-Server wird angehalten ..."
service seafile-server stop

# Symbolischen Link aktualisieren ...
echo "Link seafile-server-latest neu setzen ..."
rm seafile-server-latest
ln -s $seafile_path/seafile-server-$ver seafile-server-latest

# Seafile neu starten
echo "Seafile-Server wird gestartet ..."
service seafile-server start
exit

NextCloud / ownCloud auf einem RaspberryPi / BananaPi

Download von NextCloudPi unter: https://ownyourbits.com/nextcloudpi/

oder händisch nach folgender Anleitung:

bananapiBetriebssystem auf SD-Karte installieren

Im Folgenden wird die Einrichtung mit Bananian, einer Debian-Variante für den BananaPi, gezeigt.

Download

wget http://dl.bananian.org/releases/bananian-latest.zip
unzip bananian-latest.zip

auf SD-Karte kopieren

Die SD-Karte muss min. 2 GB groß und Class 10 sein.

# SD-Karte einlegen, das Device der SD-Karte ermitteln
dmesg | tail          
# Gegebenenfalls die Karte unmounten
sudo umount /dev/<sd-card>
# Image kopieren (<sd-card> steht für z.B. sdd)
sudo dd if=bananian-<xxxx>.img of=/dev/<sd-card> bs=1M && sync

Erster Start von Bananian

SD Karte in den BananaPi einlegen und den BananaPi booten (einfach Stromversorgung einstecken).

Der Standard-Login ist „root“, das Standard-Passwort ist „Pi“. Dann die Grundkonfiguration durchführen:

bananian-config
bananian-update

Externe Festplatte einbinden (optional)

Device ermitteln:

fdisk -l

Im Folgenden wird davon ausgegangen, dass die Festplatte als Device /dev/sda eingebunden ist.

Festplatte partitionieren (mit parted):

select /dev/sda
mktable msdos
mkpart primary ext4 0% 100%
q

Dateisystem erstellen:

mkfs -t ext4 /dev/sda1 -V

In die fstab eintragen:

mkdir /mnt/hdd
echo "/dev/sda1 /mnt/hdd ext4 defaults 0 0" >> /etc/fstab
mount -a

Owncloud installieren

Repository einfügen und OwnCloud installieren

wget -O - http://download.opensuse.org/repositories/isv:ownCloud:community/Debian_8.0/Release.key | apt-key add -
echo "deb http://download.opensuse.org/repositories/isv:/ownCloud:/community/Debian_8.0/ /" > /etc/apt/sources.list.d/owncloud.list
apt-get update
apt-get install owncloud php-pear php-apc

Apache konfigurieren

Apache auf die .htaccess-Datei der Owncloud einstellen

In die Datei /etc/apache2/sites-enabled/000-default folgendes am Ende anfügen:

<Directory /var/www/owncloud>
 Options Indexes FollowSymLinks MultiViews
 AllowOverride All
 Order allow,deny
 Allow from all
</Directory>

Apache neu starten:

service apache2 reload

Maximale Dateigröße auf 2 GB anheben

In der Datei /var/www/owncloud/.htaccess folgende Zeilen anpassen:

php_value upload_max_filesize 2G
php_value post_max_size 2G

In der Datei /etc/php5/apache2/php.ini folgende Zeilen anpassen:

upload_max_filesize = 2G
max_file_uploads = 200
post_max_size = 2G

Cache aktivieren:

In der Datei /www/owncloud/config/config.php folgendes eintragen:

'memcache.local' => '\OC\Memcache\APC',

Apache neu starten:

a2enmod rewrite
a2enmod headers
service apache2 reload

SSL aktivieren

Zertifikate erstellen

Am besten in ein Verzeichnis wechseln, welches nur vom Root erreichbar ist, z. B. mit

cd /root
openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout server.key -out server.crt -reqexts v3_req -extensions v3_ca

Dateneingabe während der Zertifikaterstellung:

    • Country Name (Ländercode): = DE
    • State or Province Name (Bundesland): = <Bundesland>
    • Locality Name, eg. City (Stadt): = <Ort>
    • Organization Name (Firmenname): = Privat
    • Organizational Unit Name (Abteilung) = <Enter>
    • Common Name, eg. YOUR Name: = <domain> „Hier muss die Domain angegeben werden, über die der Server erreichbar ist (bei Nutzung eines DynDNS-Dienstes, die dort zugeteilte Adresse)“
    • Email Adress: = <E-Mail>
    • A challenge password: = <Enter>
  • An optional company name: = <Enter>
Apache anpassen

In der Datei /etc/apache2/sites-enabled/000-default folgende Zeichen am Ende der Datei hinzufügen:

<VirtualHost *:443>
        DocumentRoot /var/www
        ServerName tuxcloud
        SSLEngine on
        SSLCertificateFile /root/server.crt
        SSLCertificateKeyFile /root/server.key
</VirtualHost>

In der Datei /etc/apache2/sites-available/default folgende Zeichen am Ende der Datei hinzufügen:

<VirtualHost *:443>
        DocumentRoot /var/www
        ServerName tuxcloud
        SSLEngine on
        SSLCertificateFile /root/server.crt
        SSLCertificateKeyFile /root/server.key
</VirtualHost>

In der Datei /etc/apache2/sites-available/default-ssl folgende Einträge anpassen:

SSLCertificateKeyFile /root/server.key
SSLCertificateFile /root/server.crt

Apache-Konfiguration anpassen und testen:

a2enmod ssl
apache2ctl configtest

Hier sollte ein „Syntax OK“ herauskommen.

Apache neu starten:

service apache2 reload

MySQL installieren

MySQL ist deutlich schneller als SQLite und empfiehlt sich bei größeren Datenmengen.

Installation MySQL

apt-get install mysql-server

Während der Installation öffnet sich ein Fenster, für das root-Passwort, das an dieser Stelle definiert werden muss.

Installation PHPmyAdmin und Datenbank einrichten

apt-get install phpmyadmin

Während der Installation fragt phpMyAdmin, welchen Webserver verwendet werden soll. In unserem Fall ist das apache2. Weiterhin Passwort für den administrativen Benutzer von MySQL eingeben.

Dann die Datenbank für Owncloud einrichten:

http://<IP des Servers>/phpmyadmin

unter Datenbank neuen Namen „owncloud“ eingeben und Datenbank speichern.

Zugriff von außen (über das Internet)

Um über das Internet auf den Server zugreifen zu können braucht man eine feste Adresse. Diese kann man z.B. über spdns.de bekommen. Im Router wird dieser Dienst bei DynDNS eingetragen und eine Portweiterleitung von Port 443 (HTTPS) zum Server gemacht.

Owncloud einrichten

Erster Start

http://<IP des Servers>/owncloud/

Benutzer: root
Passwort: *****

Datenbank auf MySQL umstellen

cd /var/www/owncloud
su www-data
php occ db:convert-type --password="passwort" --all-apps mysql root localhost owncloud

Umstellung auf Cron

Aufräumen nicht nach jedem Seitenaufruf sondern über Cron (beschleunigt Seitenaufrufe):

EDITOR=vim.tiny && crontab -u www-data -e
*/15 * * * * php -f /var/www/owncloud/cron.php

Als Administrator im Web-Frontend unter „Administration“ von Ajax auf Cron umstellen.

Einbindung externer Speicher

Samba-Client installieren:

apt-get install smbclient

Als root in Owncloud die App „External storage support“ aktivieren und unter „Administration“ dann die benötigten Speicher einbinden.

E-Mail-Versand einrichten

Hier am Beispiel eines GMX-Accounts:

Als root unter „Administration“ die Mail-Daten eingeben

  • Sende-Modus: smtp
  • Verschlüsselung: TLS
  • Absender-Adresse: <Login> | gmx.de
  • Authentifizierung: „Anmelden“ und „Authentifizierung benötigt“
  • Adresse des Servers: mail.gmx.net:587
  • Zugangsdaten: <Login> | <Passwort>

In der Datei /var/www/owncloud/config/config.php sehen die Einträge so aus:

'mail_smtpmode' => 'smtp',
'mail_smtpsecure' => 'tls',
'mail_smtpauth' => 1,
'mail_smtphost' => 'mail.gmx.net',
'mail_smtpname' => '<Login>@gmx.de',
'mail_smtppassword' => '<Passwort>',
'mail_smtpport' => '587',
'mail_smtpauthtype' => 'LOGIN',
'mail_from_address' => '<Login>',
'loglevel' => '0',
'mail_domain' => 'gmx.de',

<Login> ist der Teil der Mailadresse vor dem @.

Kalender und Kontakte aktivieren

Im Administrationsmenü unter Apps/PIM Calendar und Contacts aktivieren.

Synchronisierung einrichten

Kontakte

Android

CADroid installieren und Zertifikate importieren
CardDAV-Sync free installieren
CardDAV-Konto hinzufügen
Server: https://<Server>/owncloud/remote.php/carddav

CardDAV-Kontakte können mit der APP „Contact Editor free“ (oder Pro-Version) bearbeitet werden.

Thunderbird/Icedove

Das Plugin „SOGo Connector“ installieren (unter Debian für Icedove über die Paketverwaltung „xul-ext-sogo-connector“ installieren).
Dann im Adressbuch über „File > New > Remote Addressbook“ hinzufügen. Die benötigte URL bekommt man über das OwnCloud-Frontend im Browser: APP Kontakte > Einstellungssymbol links unten > CardDAV-Link“.

Das AddOn CategoryManager erlaubt es die in ownCloud erstellen Gruppen zu synchronisieren

Kalender

Android

„CalDAV Sync Free Beta“ installieren
CalDAV-Konto in der Kalender-APP hinzufügen
Server: https://<Server>/owncloud/remote.php/caldav

Thunderbird/Icedove

neuer Kalender -> im Netzwerk -> CalDAV
https://<Server>/owncloud/remote.php/caldav/calendars/<user>/<kalender>
Offline-Unterstützung

Aufgaben

Hierzu muss in der Owncloud zusätzliche die APP „Tasks“ installiert werden:
Download unter https://apps.owncloud.com/content/show.php/Tasks?content=164356
entpacken und auf den Server hochladen in: /var/www/owncloud/apps
danach im Web-Frontend als root die App „Tasks“ aktivieren

Android

Synchronisation über CalDAV-Sync und Tasks von Marten Gajda.

Notizen

Mit qownnotes lassen sich auch Notizen wie in evernote oder onenote speichern und synchronisieren. Das passende git-repository ist: https://github.com/pbek/QOwnNotes

Zunächst muss im owncloud/apps-Verzeichnis die App qownnotesapi installiert werden.
https://github.com/pbek/qownnotesapi
Für den Desktop gibt es einen Client: http://www.qownnotes.org/

Android

Über F-Droid kann man sich unter https://f-droid.org/app/org.aykit.MyOwnNotes die passende App herunterladen.

Backup anlegen

Sicherung der Daten auf einen USB-Datenträger:

Mit blkid die UUID des USB-Datenträgers herausfinden. (Hier z.B. 7963a8a2-92e8-4050-9c8a-a84a06415824)
Ein Verzeichnis anlegen: mkdir /media/backup

Die Datei /etc/fstab erweitern:

 UUID=7963a8a2-92e8-4050-9c8a-a84a06415824 /media/backup ext4 defaults 0 2

in /root/ die Datei backup.sh anlegen. Inhalt:

#Backup-ownCloud
 tar -czvf "/media/backup/owncloud_$(date +"%Y%m%d").tar.gz" /var/www/owncloud
#Datenbank-Backup
 mysqldump --lock-tables -h localhost -u root -passwort owncloud > "/media/backup/owncloud-db_$(date +"%Y%m%d").bak"
#alte Dateien löschen
 find "/media/backup/" -type f -name "*-db_*.bak" -mtime +6 -exec rm -f {} \;
 find "/media/backup/" -type f -name "*.tar.gz" -mtime +6 -exec rm -f {} \;

ausführbar machen chmod +x backup.sh

In cron eintragen (alle Daten, die älter als 4 Tage sind, werden Nachts um 2:00 Uhr gelöscht):

crontab -e
 0 2 * * * /root/backup.sh

reboot

Einbindung per WebDAV

https://www.meinedomain.de/remote.php/webdav

Pfad zum Datenspeicher ändern

Der Pfad zum Datenspeicher (data) steht in /var/www/owncloud/config/config.php

Nach der Anpassung der Webserver neustarten: service apache2 restart

Update auf owncloud 9

Wenn nach dem Update weiterhin der Wartungsmodus angezeigt wird:
In der Datei /var/www/owncloud/config/config.php
maintenancemode => false auf true setzen

Evtl. müssen die in /var/www/owncloud die Dateien
phpinfo.inf und apache.pem gelöscht werden.

Damit die Aufgabenplanung wieder funktioniert muss die aktuelle Version von tasks von Hand heruntergeladen und ins Verzeichnis apps/tasks entpackt werden.
Download: https://github.com/owncloud/tasks/archive/DAVclient.zip

Backup

Mit calcardbackup lassen sich Adressbücher und Kontakte einfach sichern.

Android

ownCloud Client Zugriff auf den Cloudspeicher (F-Droid)
DAVdroid – Kalendersynchronisation (F-Droid)
o
wnCloud Client Zugriff auf den Cloudspeicher (GooglePlaystore)
CalDAV Sync Free
– zur Kalendersynchronisation (GooglePlaystore)

Webmin

Mit dem Programm Webmin kann man einen Server sehr bequem und komfortabel über den Browser administrieren.

Download unter: http://www.webmin.com

Das Programm muss auf dem Server installiert werden. Dann kann man mit dem Browser unter der Adresse: https://servername:10000/ auf Webmin zugreifen. Nach Anmeldung als root stellt das Webinterface umfangreiche Verwaltungsmöglichkeiten zur Verfügung.

Für Dansguardian gibt auch ein Modul, das aber erst nachinstalliert werden muss.

Download unter: http://sourceforge.net/projects/dgwebminmodule/

Server mit Squid als transparentem Proxy

Installation eines Debian-Serves mit zwei Netzwerkkarten
(eth0 = extern, eth1 = internes Netzwerk)
Der Server stellt einen Squis als transparenten Proxy (Das bedeutet, dass alle angeschlossenen Geräte ohne weitere Konfiguration zwangsweise über den Squid-Proxy laufen.) zur Verfügung und beinhaltet dansguardian als Jugendschutz.

Debian herunterladen (am besten das netinstall-image): Download Debian und das Image entweder auf CD brennen oder per unetbootin oder YUMI auf einen USB-Stick übertragen.

Medium booten und Debian installieren:

  1. Install
  2. Sprache auswählen
  3. Land auswählen
  4. Tastatur auswählen
  5. primäre Netzwerkkarte (eth0) auswählen
  6. Rechnername vergeben
  7. Domainname (bei lokalem Netzwerk egal)
  8. Root Passwort
  9. Benutzername
  10. Anmeldename des Benutzers
  11. Passwort des Benutzers
  12. Partitionierung:
    – Platte auswählen
    – Alle Dateien auf eine Platte
  13. Grundsystem wird installiert
  14. Spiegelserver auswählen
  15. evtl. Proxydaten eingeben
  16. Softwareauswahl treffen:
    – SSH-Server
    – Standard-Systemwerkzeuge
  17. GRUB in den Master Boot Record (MBR) installieren
  18. Installation abgeschlossen – weiter – Neustart wird ausgelöst

Am neuen System anmelden weitere Software installieren:

apt-get install squid vim dansguardian dnsmasq

Konfiguration der Datei /etc/network/interfaces:

# loopback-Interface nicht löschen
auto lo
iface lo inet loopback

# LAN / automatische Konfiguration über DHCP
auto eth0
iface eth0 inet dhcp

# internes LAN mit statischer Konfiguration (interner Adressbereich von 192.168.3.20 - 192.168.3.200)
auto eth1
iface eth1 inet static
address 192.168.3.1
netmask 255.255.255.0
broadcast 192.168.3.255

# vorhandene Regeln und Ketten zuerst löschen (Restart-Funktionalität)
up /sbin/iptables -F
up /sbin/iptables -X
up /sbin/iptables -t nat -F

# Maskieren der LAN-Schnittstelle, Port-Forwarding & Nat aktivieren
up iptables -A FORWARD -o eth0 -i eth1 -s 192.168.0.0/24 -m conntrack --ctstate NEW -j ACCEPT
up iptables -A FORWARD -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
up iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE 
up iptables -t nat -A PREROUTING -i eth1 -p tcp --dport 80 -j REDIRECT --to-port 8080
up sysctl -w net.ipv4.ip_forward=1 

# dnsmasq neu starten
up /etc/init.d/dnsmasq restart

Die Datei /etc/dnsmasq.conf mit folgendem Inhalt erstellen.

# DHCP-Server aktiv für Interface
interface=eth1

# DHCP-Server nicht aktiv für Interface
no-dhcp-interface=eth0

# IP-Adressbereich / Lease-Time
dhcp-range=interface:eth1,192.168.3.20,192.168.3.200,infinite

Konfiguration des Squid: /etc/squid/squid.conf

# aktivieren der Apache log emulation (zur Zugriffs Überwachung):
emulate_httpd_log on

# setze den Hostnamen: 
visible_hostname proxyserver

# ändere die Zeile http_port 3128 folgendermaßen:
http_port 3128 transparent

Konfiguration des Dansguardian: /etc/dansguardian/dansguardian.conf

UNCONFIGURED auskommentieren: 
# UNCONFIGURED

In /etc/dansguardian/dansguardianf1.conf

setze naughtynesslimit = 100

System neu starten (reboot) – Fertig!

squid

Internetfilter über squid im Netzwerk einrichten:
Hier speziell für de Musterlösung des Landes Baden Württemberg beschrieben, funktioniert aber analog in jedem anderen Linux-Netzwerk auch.

In die Datei /etc/squid/squid.conf nach dem Punkt
# Standard acls
und vor
# Erlaube einen direkten Zugriff auf GServer03, Astaro-Box und auf weitere Maschinen in der DMZ
folgenden Code eingeben:

#Lehrer-PC freigeben
 acl LehrerPC src "/etc/squid/lehrerpc.acl"
 http_access allow LehrerPC

#Internetseiten sperren
 acl bad url_regex "/etc/squid/squid-block.acl"
 http_access deny bad

Die Datei lehrerpc.acl im Verzeichnis /etc/squid/ anlegen und die nicht zu filternden IP-Adressen eintragen:

10.1.253.254/255.255.255.255
10.1.254.249/255.255.255.255

Die Datei squid-block.acl im Verzeichnis /etc/squid/ erstellen und die zu sperrenden Internetseiten eintragen:

 youtube
 facebook
 ...

Diese Dateien sollten immer auf dem Server direkt editiert werden. Dort steht als Editor vim zur Verfügung. Alternativ kann der Dateimanager mc und der dort eingebeaute Editor (F4) verwendet werden.

Samba

Windows-Freigaben unter Linux

Windows-Freigabe mounten:

sudo mount -t cifs //192.168.11.1/Allgemein /media/netzwerk -o user=<Samba-User>

Server

/etc/init.d/samba restart startet den Samba-Server neu

Alle Einstellungen befinden sich in /etc/samba/

Benutzer anlegen

smbpasswd -a user legt Benutzer an oder ändert das passwort
smbpasswd -x user löscht den User in Samba
smbpasswd -d user deaktiviert den User in Samba
smbpasswd -e user aktiviert den User in Samba

Es können in Samba nur Benutzer angelegt werden, die im System bereits als Linux-User angelegt sind!

Informationen zu Samba-User anzeigen

Übersicht über alle angelegten User:

pdbedit -L

Detailinformationen zu einem User:

pdbedit -L -v -u USERNAME

/etc/samba/smbusers

Weist den Linux-Benutzern Alias-Namen zu, die für den Login verwendet werden können:
Petri = Winuser meldet den Windows-User „Winuser“ als Linux-User „Petri“ an.

Konfigurationsdatei

/etc/samba/smb.conf

[global]
    workgroup = tuxnet
    printcap cache time = 750
    cups options = raw
    printer admin = @ntadmin, root, administrator
    username map = /etc/samba/smbusers
    map to guest = Bad User
    include = /etc/samba/dhcp.conf
    logon path = \\%L\profiles\.msprofile
    logon home = \\%L\%U\.9xprofile
    logon drive = P:
    restrict anonymous = yes
    domain master = yes
    preferred master = yes
    max protocol = NT
    ldap ssl = No
    server signing = Auto
    ldap idmap suffix = ou=Idmap
    ldap machine suffix = ou=Computers
    ldap suffix = dc=example,dc=com
    printer name = hplaserjet5l
    hosts allow = 192.168.
    add machine script = /usr/sbin/useradd  -c Machine -d /var/lib/nobody -s /bin/false %m$
    domain logons = yes
    os level = 65
    security = user
    encrypt passwords = yes
    passdb backend = smbpasswd
[documents]
    comment = /home/petri/Documents
    path = /home/petri/Documents
    read only = no
    inherit acls = yes
    veto files = /aquota.user/groups/shares/
    valid users = petri
    guest ok = no
[ext]
    comment = /home/ext
    path = /home/ext
    read only = no
    inherit acls = yes
    veto files = /aquota.user/groups/shares/
    valid users = petri
    guest ok = no
[pdf]
    comment = PDF creator
    path = /var/tmp
    printable = yes
    print command = /usr/bin/smbprngenpdf -J '%J' -c %c -s %s -u '%u' -z %z
    create mask = 0600
[printers]
    comment = All Printers
    path = /var/tmp
    printable = yes
    create mask = 0600

Client

Windows-Freigabe mounten

von Hand:

  1. Paket „samba-client“ installieren
  2. mkdir Zielverzeichnis
  3. mount -t smbfs -o username=user,password=passwort,gid=users,fmask=0664,dmask=0775 //Server/Freigabe/ Zielverzeichnis 

automatisch beim Start:

Zeile in /etc/fstab einfügen:

//Server/Freigabe /mnt/Zielverzeichnis cifs nofail,x-systemd.automount,x-systemd.requires=network-online.target,x-system.device-timeout=20,iocharset=utf8,credentials=/root/.smbpasswd/serverxy 0 0

Passwortdatei/root/.smbpasswd/serverxy mit folgendem Inhalt erstellen :

username = Name
password = Passwort

Rechte anpassen: chmod 600 /etc/smbpasswd

Windows-Freigabe mounten per GUI unter KDE (Samba, LISa): 

Pakete „kdenetwork3-lisa“, „kdenetwork3-lan“, „kdebase3-samba“, „samba-client“ installieren:

sudo apt-get install kdenetwork3-lisa kdenetwork3-lan kdebase3-samba samba-client

Kontrollzentrum/Internet & Netzwerk/Netzwerk-Browser starten

Windows-Ressourcen und LISa-Dämon konfigurieren

su 
rclisa start 
insserv lisa

SMB-Protokoll-Versionen

Das SMB-Protokoll existiert in den Versionen 1.0, 2.0, 2.1 und 3.0, die untereinander nicht vollständig kompatibel sind. Eine Kommunikation kommt nur zustande, wenn sich beide Partner auf eine gemeinsame Version einigen. Dazu ist es manchmal erforderlich, die zu verwendende Version anzugeben.

Neue Kernel-Versionen erfordern, dass mann beim mounten die Samba-Version 1.0 explizit angeben muss. Dies ist z. B. bei Freigaben der FritzBox der Fall.  Herzu wird beim mount-Befehl zusätzlich die Option vers=1.0 angeben.

sudo mount -t cifs -o vers=1.0,username=<user>,password=<passwrd> //fritz.nas/FREIGABE MOUNTPOINT

Ansonsten gibt es noch die Versionen: 2.0, 2.1 und 3.0

rdate

Uhrzeit mit Zeitserver synchronisieren rdate -s timeserver
Deutsche Timeserver

  • ptbtime1.ptb.de
  • ptbtime2.ptb.de
  • ntp1.t-online.de
  • ntp0.fau.de
  • ntps1-0.cs.tu-berlin.de
  • ntps1-1.cs.tu-berlin.de
  • rustime01.rus.uni-stuttgart.de
  • de.pool.ntp.org

IP-Adressen

Intranet:

  • 10.0.0.0 – 10.255.255.255 (A-Netz)
  • 169.254.0.0 – 169.254.255.255 (Automatic Private IP Adressing)
  • 172.16.0.0 – 172.31.255.255 (B-Netz)
  • 192.168.0.0 – 192.168.255.255 (C-Netz)

Masken zur Darstellung von IP-Bereichen:

Weiterlesen

Serverinstallation

Am Beispiel eines ubuntu-Servers:

Download von ubuntu-server-64bit: http://www.ubuntu.com/start-download?distro=server&bits=64&release=lts

Das heruntergeladene ISO-File entweder auf CD brennen oder mit http://www.pendrivelinux.com auf einen USB-Stick installieren.

Installation:

  1. Von CD oder USB-Stick booten
  2. „Server installieren“ anwählen
  3. deutsche Sprache auswählen (auch wenn die Übersetzung nicht vollständig ist, das System nimmt dann eben englisch)
  4. Tastaturbelegung deutsch
  5. Server-Namen vergeben
  6. Benutzerkonto: dieser Benutzer hat root-Rechte! Erst vollständiger Name, dann Anmeldename.
  7. Passworteingabe für Benutzer
  8. Verschlüsselung: nein
  9. Zeitzone wählen
  10. Partitionierung: Geführt, gesamte Platte und LVM (Logical Volume Manager) einrichten ist meist das Beste
    • Platte wählen
    • in der Regel die gesamte Volume Group verwenden
    • Änderungen auf die Festplatten schreiben
  11. Das Grundsystem wird nun installiert
  12. Proxy (falls benötigt) festlegen
  13. die Paketverwaltung (apt) wird konfiguriert
  14. Sicherheitsaktualisierungen automatisch installieren
  15. Serverauswahl:
    • OpenSSH server (für Fernzugriff)
    • DNS server
    • LAMP server (Apache, MySQL, PHP)
    • Mail server
    • PostgreSQL database
    • Print server
    • Samba file server
    • Tomcat Java server
    • Virtual Machine host
  16. Die ausgewählte Software wird nun installiert
  17. evtl. neues Passwort für MySQL root-Benutzer vergeben – nur bei Installation von LAMP
  18. Der GRUB-Bootloader wird installiert. In der Regel in den MBR (Master Boot Record) installieren.
  19. Die Installation ist nun abgeschlossen. Es wird automatisch neu gebootet. Bootmedium entfernen.
  • Nach dem ersten Start des neuen Systems sollte zunächst ein Update ausgeführt werden.
    • sudo apt-get update
    • sudo apt-get upgrade
  • evtl. eine einfache grafische Oberfläche installieren: sudo apt-get install xfce4 Die grafische Oberfläche wird mit startx aufgerufen.
    Über das Anwendungsmenü kann die grafische Oberfläche wieder beendet werden.
    Sollten in der grafischen Oberfläche einmal die Taskleisten verschwunden sein, so macht man einen Rechtsklick auf den Desktop, ruft den Terminal auf und gibt folgenden Befehl ein:
    xfce4-panel &
  • Tipp: Für die Arbeit in der Konsole ist der mc (midnight commander -ein Norton Commander Clone – 2-Fenster-Modus) sehr praktisch: sudo apt-get install mc
  • Um mittels Webinterface arbeiten zu können, muss noch ein Browser für die grafische Oberfläche installiert werden: sudo apt-get install firefox
  • Will man einen guten Überblick über zu installierende Pakete haben, installiert man synaptic für die grafische Oberfläche: sudo apt-get install synaptic