ÜBERSICHT - START - MENÜ

.
Lern-Videos
DokuWiki - Einführung
Format-Vorlagen & Syntax
NextCloud - ArbeitsTechniken
- NextCloud - HANDBUCH - BEDIENUNGSHINWEISE - MANUALS
Werkzeuge & Anleitungen

Nextcloud auf Ubuntu Server 20.04 LTS mit nginx, MariaDB, PHP, LetsEncrypt, Redis und Fail2ban - DecaTec - 2020-05-11

Nextcloud auf Ubuntu Server 20.04 LTS mit nginx, MariaDB, PHP, LetsEncrypt, Redis und Fail2ban

how-to-install-virtualbox-guest-additions-on-a-gui-less-ubuntu-server-host

Nextcloud mit ONLYOFFICE

von Carsten Rieger · Veröffentlicht 29. Dezember 2019 · Aktualisiert 6. April 2020 Nextcloud mit Only Office

Folgen Sie dieser Anleitung um ONLYOFFICE in ihre besthende Domäne zu integrieren und alle gebräuchlichen Officedokumente lesen, bearbeiten und erzeugen zu können. Egal ob Microsoft- oder Libre-Office. Sie müssen lediglich noch den TCP-Port 8443 in Ihrer Firewall (o. Router) öffnen:

Bereiten Sie im Anschluß an die Portfreigabe Ihren Server für die Verwendung von Docker vor. Entfernen Sie dafür die Standard Dockersoftware, installieren dann alle notwendigen Module nach und öffnen in der lokalen ufw zusätzlich zu Ihrer vorgeschalteten Firewall (o. Router) den TCP-Port 8443:

sudo -s apt remove docker docker-engine docker.io apt install apt-transport-https ca-certificates curl software-properties-common -y ufw allow 8443/tcp

Ubuntu: sed -i '$adeb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable' /etc/apt/sources.list curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

Debian: sed -i '$adeb [arch=amd64] https://download.docker.com/linux/debian stretch stable' /etc/apt/sources.list curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add -

Aktualisieren Sie Ihren Server und installieren dann Docker-CE:

apt update && apt install docker-ce -y

Stellen Sie sicher, dass Docker funktioniert. Führen Sie dazu das folgende Statement aus:

docker run hello-world

Wenn das funktioniert hat, dann beginnen Sie mit dem Download und der Installation des ONLYOFFICE Documentservers (latest):

docker pull onlyoffice/documentserver

Weitere Releases können Sie hier ermitteln und ggf. durch die Angabe des Releases eine dedizierte Version

Beispielsweise: docker pull onlyoffice/documentserver:5.4.2.46

herunterladen und verwenden.

Es werden ca. 650 MB heruntergeladen und verifiziert.

Im Anschluß daran wird der Webserver nginx angepasst:

nano /etc/nginx/nginx.conf

  Ergänzung:
  upstream onlyoffice-docker {
  server 127.0.0.1:8443;
  }

user www-data; … } http { server_names_hash_bucket_size 64; upstream onlyoffice-docker { server 127.0.0.1:8443; } upstream php-handler { server unix:/run/php/php7.4-fpm.sock; } …

Überprüfen Sie die /etc/nginx/ssl.conf bzgl. der Verwendung von TLS v. 1.2, welches von ONLYOFFICE zwingend benötigt wird:

… ssl_protocols TLSv1.3 TLSv1.2; ssl_ciphers 'TLS-CHACHA20-POLY1305-SHA256:TLS-AES-256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA512:DHE-RSA-AES256-GCM-SHA512:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES256-GCM-SHA384'; ssl_ecdh_curve X448:secp521r1:secp384r1:prime256v1; …

Starten Sie den Webserver nginx und PHP neu:

service php7.4-fpm restart && service nginx restart

Erzeugen Sie neue Ordner und kopieren Ihre SSL-Zertifikate (bspw. Let’s Encrypt Zertifikate) hinein:

mkdir -p /app/onlyoffice/DocumentServer/data/certs
cp /etc/letsencrypt/rsa-certs/privkey.pem /app/onlyoffice/DocumentServer/data/certs/onlyoffice.key
cp /etc/letsencrypt/rsa-certs/fullchain.pem /app/onlyoffice/DocumentServer/data/certs/onlyoffice.crt
cp /etc/ssl/certs/dhparam.pem /app/onlyoffice/DocumentServer/data/certs/dhparam.pem
chmod 400 /app/onlyoffice/DocumentServer/data/certs/onlyoffice.key

oder

mkdir -p /app/onlyoffice/DocumentServer/data/certs
cp /etc/nginx/ssl/zertifikat-privkey-aw.pem /app/onlyoffice/DocumentServer/data/certs/onlyoffice.key
cp /etc/nginx/ssl/zertifikat-fullchain-pubkey-aw.pem /app/onlyoffice/DocumentServer/data/certs/onlyoffice.crt
cp /etc/ssl/certs/dhparam.pem /app/onlyoffice/DocumentServer/data/certs/dhparam.pem
chmod 400 /app/onlyoffice/DocumentServer/data/certs/onlyoffice.key

Hinweis:

Dieser Schritt muss nach jeder Zertifikatserneuerung wiederholt werden und könnte bspw. durch ein per CRONJOB automatisiertes Skript (exemplarisch renewal.sh) ausgeführt werden:

nano /root/renewal.sh

#!/bin/bash
sudo -u acmeuser "/home/acmeuser/.acme.sh"/acme.sh --cron --home "/home/acmeuser/.acme.sh"
/usr/sbin/service nginx stop
/usr/sbin/service mysql restart
/usr/sbin/service redis-server restart
/usr/sbin/service php7.4-fpm restart
/usr/bin/docker restart ONLYOFFICEDOCKER
/usr/sbin/service nginx restart
exit 0

chmod +x /root/renewal.sh
(crontab -l ; echo "@weekly /root/renewal.sh 2>&1") | crontab -u root -

Starten Sie nun den ONLYOFFICE-Dockercontainer mit dem folgenden Einzeiler. Passen Sie dazu bitte ‚yoursecret ‚nach Ihrem Bedarf an.

docker run --name=ONLYOFFICEDOCKER -i -t -d -p 8443:443 -v /app/onlyoffice/DocumentServer/data:/var/www/onlyoffice/Data -e JWT_ENABLED='true' -e JWT_SECRET='yoursecret' --restart=always onlyoffice/documentserver

bzw.

docker run --name=ONLYOFFICEDOCKER -i -t -d -p 8443:443 -v /app/onlyoffice/DocumentServer/data:/var/www/onlyoffice/Data -e JWT_ENABLED='true' -e JWT_SECRET='lkmsh2020#' --restart=always onlyoffice/documentserver

Warten Sie einen kurzen Moment ab und überprüfen dann die Erreichbarkeit des ONLYOFFICE-Servers:

https://your.dedyn.io:8443/

bzw.

https://archiv-werkzeuge.de:8443/

Wählen Sie sich in Ihre Nextcloud als Administrator ein und aktivieren dort die ONLYOFFICE-App.

Wechseln Sie in die Einstellungen und tragen Ihre Nextcloud-Domäne (https://your.dedyn.io:8443) inkl. des TCP-Ports 8443 ein. Setzen Sie zudem das von Ihnen vergebene Passwort ‚yoursecret‚.

Ab sofort können Sie Ihre Office-Dokumente lesen, bearbeiten und auch neue Officedokumente direkt in Ihrer Nextcloud erzeugen:

Wie aktualisieren Sie den Dockercontainer?

Stop:

docker stop ONLYOFFICEDOCKER

Entfernen:

docker rm ONLYOFFICEDOCKER

Aktualisierung laden:

docker pull onlyoffice/documentserver

Neustart

docker run –name=ONLYOFFICEDOCKER -i -t -d -p 8443:443 -v /app/onlyoffice/DocumentServer/data:/var/www/onlyoffice/Data -e JWT_ENABLED='true' -e JWT_SECRET='yoursecret' –restart=always onlyoffice/documentserver

Die Installation Ihres Nextcloudservers und der ONLYOFFICE Suite wurde erfolgreich abgeschlossen und so wünsche ich Ihnen viel Spaß mit Ihren Daten in Ihrer privaten Cloud. Über eine Spende würden sich meine Frau, meine Zwillinge und ich sehr freuen!

DatenAustausch - Netzwerk-Freigaben mit Samba - DecaTec IT - 27-05-2019

Wenn man einen eigenen Home-Server betreibt, dann wird man diesen oftmals auch als zentrale Stelle zur Ablage von Dateien verwenden. Damit jeder Rechner im Netzwerk Zugriff auf diese Dateien hat, muss der Server diese Daten per Netzwerk-Freigaben bereit stellen.

In einem reinen Linux-Netzwerk würde man hier vermutlich NFS verwenden. Oftmals hat man es jedoch mit gemischten Netzwerken zu tun. Hier müssen neben Linux- auch Windows- oder Mac-Clients Zugriff auf die Netzwerk-Freigaben haben. Hier nutzt man dann am besten das SMB-Protokoll, welches auf allen Plattformen unterstützt wird. Als Server-Implementierung steht unter Linux das Softwareprojekt Samba zur Verfügung.

Dieser Artikel zeigt, wie auf Ubuntu Server 18.04 LTS eine Samba-Server installiert und konfiguriert werden kann. Allerdings können alle Schritte auch auf andere Distributionen übertragen werden.

Eine wichtige Anforderung bei Netzwerk-Shares ist immer auch die Freigabe für mehrere Benutzer: Auf eine Freigabe sollen u.U. mehrere Benutzer Schreib- und Leserechte haben. Dies wird in diesem Artikel durch das Setzen von ACLs bzw. Setzen von Gruppen-Rechten gelöst.

  1 Installation Samba
  2 Benutzer hinzufügen
  3 Verzeichnisse für Netzwerk-Shares vorbereiten
      3.1 Rechte für mehrere Benutzer setzen – Variante 1: Per ACL
      3.2 Rechte für mehrere Benutzer setzen – Variante 2: Per Gruppe
  4 Samba Konfiguration
      4.1 Allgemeine Einstellungen
      4.2 Freigabe für einen Benutzer
      4.3 Freigabe für mehrere Benutzer – Variante 1: ACL
      4.4 Freigabe für mehrere Benutzer – Variante 2: Gruppen
      4.5 Konfiguration der Freigaben abschließen
  5 Einbinden der Netzwerk-Shares
      5.1 Linux
          5.1.1 Temporärer Zugriff auf die Freigaben per Datei-Manager
          5.1.2 Temporäres Einbinden per Kommandozeile
          5.1.3 Dauerhaftes Mounten per fstab
      5.2 Windows
          5.2.1 Temporärer Zugriff auf die Freigaben per Explorer
          5.2.2 Dauerhaftes Einbinden unter Windows
  6 Fazit
  7 Links

Zunächst wird das System auf dem neusten Stand gebracht:

apt-get update && apt-get upgrade -V && apt-get dist-upgrade && apt-get autoremove

Anschließend kann Samba installiert werden:

apt-get install samba-common samba

Das Paket samba-common sollte auf jeden Fall mit installiert werden, da dies wichtige Tools (wie z.B. smbpasswd) beinhaltet.

Damit ein Benutzer später auf die Samba-Netzwerk-Freigaben zugreifen kann, muss dieser Benutzer zunächst einmal angelegt werden. Wichtig ist ist in diesem Zusammenhang, dass der Benutzer sowohl als System-Benutzer, als auch als Samba-Benutzer angelegt werden muss.

Wenn es den Benutzer noch nicht als System-Benutzer gibt, dann wird dieser angelegt und danach ein Passwort für den Benutzer hinterlegt:

adduser bob

Alternative: Normalerweise legt man diese Benutzer nur an Home-Server an, damit diese später Zugriff auf die Samba-Freigaben haben. In diesem Fall macht es keinen Sinn, dass sich diese Benutzer direkt am System anmelden. Hier kann man den User folgendermaßen anlegen, so dass sich dieser nicht am Server selbst anmelden kann:

adduser --no-create-home --disabled-login --shell /bin/false bob

Anschließend wird noch ein Passwort für den System-Benutzer hinterlegt:

passwd bob

Anschließend muss der entsprechende User noch als Samba-User angelegt und aktiviert werden:

smbpasswd -a bob

Empfehlenswert ist hier, das gleiche Passwort wie schon für den System-Benutzer zu vergeben, dies ist jedoch nicht zwingend erforderlich.

Für jeden weiteren Benutzer ist der Vorgang zu wiederholen. Neben Bob gibt es in diesem Artikel als weiteren User auch Alice:

adduser --no-create-home --disabled-login --shell /bin/false alice
passwd alice
smbpasswd -a alice

Als nächstes werden beispielhaft drei Verzeichnisse vorbereitet, die später im Netzwerk verfügbar sein sollen. Auf das erste Verzeichnis sollte nur der Benutzer Bob Zugriff haben, daher werden anschließend gleich die entsprechenden Besitzrechte gesetzt:

mkdir -p /media/hdd1/networkshares/bob
chown -R bob /media/hdd1/networkshares/bob

Das gleiche wird für ein Verzeichnis für Alice wiederholt:

mkdir -p /media/hdd1/networkshares/alice
chown -R alice /media/hdd1/networkshares/alice

Ein drittes Verzeichnis soll nachher für beide Benutzer zur Verfügung stehen. Hier wird lediglich das Verzeichnis erzeugt:

mkdir -p /media/hdd1/networkshares/shared

Nun haben wir allerdings ein Problem mit den Verzeichnisrechten: Beide Benutzer sollen hier Vollzugriff haben. Per chown kann allerdings nur ein User als Owner definiert werden.

Hier gibt es nun zwei Varianten, wie die entsprechenden Rechte gesetzt werden können: Per ACL oder per Gruppen.

3.1 - Rechte für mehrere Benutzer setzen – Variante 1: Per ACL

ACL (Access Control List) ergänzen das normale Rechtesystem von Linux. Man kann sich dies als zusätzliche „Schicht“ über dem normalen Rechtesystem vorstellen. Dies ist eine einfache Möglichkeit, Benutzern/Gruppen gezielt Zugriffsrechte auf Dateien und Verzeichnisse zu geben bzw. zu entziehen.

Hinweis: Beim Setzen der Rechte über ACLs gestaltet sich die Konfiguration der Netzwerk-Shares über Samba im weiteren Verlauf etwas einfacher. Daher ist dies meine bevorzugte Variante.

ACL wird während der Installation von Ubuntu Server automatisch installiert. Wenn dies nicht der Fall sein sollte, dann kann das zu einem späteren Zeitpunkt nachgeholt werden:

apt-get install acl

Nun können ACLs für das Verzeichnis gesetzt werden, auf das später beide Benutzer Zugriff haben sollen:

setfacl -R -d -m u:bob:rwx,u:alice:rwx /media/hdd1/networkshares/shared

Dieser Befehl bewirkt folgendes:

Die Rechte werden rekursiv gesetzt (-R).
Mittels -d wird ein Default gesetzt, der auch bei zukünftig angelegten Dateien und Verzeichnissen wirkt.
Mit dem Parameter -m werden evtl. bereits vorhandene Rechte modifiziert und nicht einfach überschrieben.
Die genauen Rechte für einen User werden z.B. durch u:bob:rwx gesetzt: Hier sollen die Benutzer Bob und Alice Vollzugriff auf das Verzeichnis haben.

Ein weiteres Setzen der Rechte über chown/chmod ist nicht erforderlich.

3.2 - Rechte für mehrere Benutzer setzen – Variante 2: Per Gruppe

Für die zweite Variante nutzen wir Gruppen um die entsprechenden Rechte zu setzen.

Hinweis: Die Variante mit Gruppen macht die Einrichtung der Netzwerk-Shares später etwas komplizierter. Daher bevorzuge ich mittlerweile die erste Variante (ACL) zum Setzen der Rechte.

Beide Benutzer werden dazu in eine Gruppe aufgenommen. Dann wird der Gruppe die entsprechenden Besitzrechte gegeben und anschließend per chmod die passenden Zugriffsrechte gesetzt:

addgroup bobundalice
usermod -aG bobundalice bob
usermod -aG bobundalice alice
chown -R bob:bobundalice /media/hdd1/networkshares/shared
chmod -R 775 /media/hdd1/networkshares/shared

Bleibt eigentlich nur noch die Einrichtung des Samba-Servers. Die Konfiguration befindet sich in folgender Datei:

nano /etc/samba/smb.conf

4.1 - Allgemeine Einstellungen

Zunächst werden in der Sektion [Global] ein paar Werte gesetzt. map to guest ist meist schon vorhanden, die anderen Werte werden einfach darunter eingefügt:

map to guest = never
security = user
encrypt passwords = true
invalid users root

Im einzelnen wird damit folgendes konfiguriert:

map to guest = never deaktiviert den Gast-Zugriff auf den Samba-Server. Ohne diese Einstellung könnte man sich am Samba-Server auch als Gast anmelden.
security = user gibt an, dass die Authentifizierung am Samba-Server mittels Username/Passwort erfolgt.
encrypt passwords = true sorgt dafür, dass Passwörter nur verschlüsselt übertragen werden.
invalid users root deaktiviert den Zugriff auf die Samba-Shares für den Root-User.

Section [global] für "archiv-werkzeuge.de":

[global]
	usershare allow guests = no
	workgroup = LKMSH
	server string = %h server (Samba, Ubuntu)
	map to guest = never
	panic action = /usr/share/samba/panic-action %d
	log file = /var/log/samba/log.%m
	pam password change = yes
	encrypt passwords = true
	obey pam restrictions = yes
	unix password sync = yes
	server role = standalone server
	write raw = no
  
	security = user
       invalid users root
	passwd chat = *Enter\snew\s*\spassword:* %n\n *Retype\snew\s*\spassword:* %n\n *password\supdated\ssuccessfully* .
	max log size = 1000
	logging = file
	read raw = no
	passwd program = /usr/bin/passwd %u
	os level = 20

Weiter unten in der Konfigurations-Datei findet man Sektionen, mit den Drucker-Freigaben eingerichtet werden. Diese sind standardmäßig aktiv. Möchte man keine Drucker freigeben, dann kommentiert man die beiden Sektionen [printers] und [print$] am besten aus. Freigabe für einen Benutzer

Bob und Alice sollen jeweils eine eigene Freigabe haben, auf die kein anderer Benutzer Zugriff hat. Dazu werden in der smb.conf ganz am Ende folgende Blöcke eingefügt:

[bob]
valid users = bob
path = /media/hdd1/networkshares/bob
guest ok = no
writeable = yes

[alice]
valid users = alice
path = /media/hdd1/networkshares/alice
guest ok = no
writeable = yes

Folgende Angaben sind hier zu machen:

[bob]: Der Sektions-Name legt fest, wie die Freigabe heißen soll.Über diesen Namen werden die Netzwerk-Shares dann später auf den Client-Rechnern eingerichtet.
valid users: Hier werden die Benutzer festgelegt, welche Zugriff auf die Freigabe haben sollen. Bei Einzel-Freigaben ist dies auch immer nur ein User.
path: Legt den lokalen Pfad fest, auf dem die Freigabe auf den lokalen Rechner liegen soll.
guest ok = no: Hiermit wird festgelegt, dass sich Gäste nicht auf diese Freigabe verbinden können.writeable = yes: Dies wird nochmals explizit angegeben, dass der Benutzer unter valid users Schreibzugriff auf die Freigabe haben soll.

Für "archiv-werkzeuge.de" ⇒ Freigabe des Verzeichnisses "/var/www" wird folgender Eintrag angelegt:

[DatenArchiv]
valid users = adm_tjeckel
#Wir beschrÃ¤nken den Zugriff auf den User ''smbuser''
#valid users = @smbusers
#alternativ kann auch auf eine Benutzergruppe eingeschrÃ¤nkt werden
path = /var/www
public = no
browsable = yes
writable = yes
comment = smb restricted share
printable = no
guest ok = no
force user = www-data
force group = www-data

create mask = 0770
force create mode = 0770
security mask = 0770
force security mode = 0770

directory mask = 0770
force directory mode = 0770
directory security mask = 0770
force directory security mode = 0770

4.3 - Freigabe für mehrere Benutzer – Variante 1: ACL

Bei den Freigaben für mehrere Benutzer gibt es wieder zwei Varianten, abhängig davon, wie zuvor die Rechte auf Dateisystem-Ebene gesetzt wurden (ACL oder Gruppen).

Ich bevorzuge das Setzen der Rechte per ACL. In diesem Fall sieht die Konfiguration der Freigabe folgendermaßen aus. Der Name der Freigabe lautet hier shared:

[shared]
valid users = bob alice
path = /media/hdd1/networkshares/shared
guest ok = no
writeable = yes

Wie man sieht, unterscheidet sich diese Variante kaum von der Einrichtung einer Freigabe für einen einzelnen User. Es werden lediglich mehrere Benutzer unter valid users angegeben.

4.4 - Freigabe für mehrere Benutzer – Variante 2: Gruppen

Wenn keine ACLs gesetzt wurden, sondern beide Benutzer in eine Gruppe hinzugefügt wurden, müssen für das Konfigurieren der Freigabe ein paar zusätzliche Angaben gemacht werden:

[shared]
valid users = @bobundalice
path = /media/hdd1/networkshares/shared 
guest ok = no
write list = @bobundalice
directory mask = 0775
create mask = 0775

Folgendes gilt es hier zu beachten:

valid users: Hier wird die Gruppe der User angegeben, die Zugriff auf die Freigabe haben soll. Vor dem Gruppen-Namen muss dazu ein @ Symbol stehen.
write list: Hier wird wiederum die Gruppe angegeben, die Schreibzugriff auf die Freigabe haben soll.
directory mask/create mask: Hier werden die Datei- bzw. Verzeichnisrechte gesetzt, ähnlich wie beim Befehl chmod. Dies sorgt dafür, dass die Dateien mit den entsprechenden Rechten versehen werden, wenn diese (durch die Benutzer der Freigabe) erstellt werden.

4.5 - Konfiguration der Freigaben abschließen

Damit wäre die Konfiguration von Samba abgeschlossen. Mit folgenden Befehlen wird die aktuelle Konfiguration getestet und Samba anschließend neu gestartet:

testparm
service smbd restart

Falls die Firewall ufw auf dem System aktiv ist, muss hier noch eine Freigabe für Samba erfolgen. Am einfachsten funktioniert dies mit einem Applikations-Filter:

ufw allow from 192.168.178.0/24 to any app Samba

In diesem Beispiel erfolgt die Freigabe nur für das lokale Netzwerk (192.168.178.0/24). Damit haben nur Clients innerhalb des gleichen Netzwerks Zugriff auf die Samba-Freigaben.

Nach der Einrichtung von Samba können die Freigaben nun ganz einfach auf den Client-Rechnern eingebunden werden.

5.1 - Linux

Unter Linux kann die Freigabe entweder temporär oder dauerhaft eingebunden werden.

5.1.2 - Temporärer Zugriff auf die Freigaben per Datei-Manager

Auf die Freigaben kann man mit jedem Datei-Manager zugreifen, indem man in die Adressziele den SMB-Speicherort eingibt, z.B. 'smb://192.168.178.60'.

Direkter Zugriff auf die Freigaben (Manjaro/Thunar)

Hier werden alle Freigaben angezeigt. Bei einem Zugriff muss dann noch die Eingabe von Username/Passwort erfolgen.

5.1.3 - Temporäres Einbinden per Kommandozeile

Hier wird das Paket cifs-utils benötigt:

apt-get install cifs-utils

Damit nicht immer das Passwort beim Mounten der Freigabe eingegeben werden muss, sollte sich der entsprechende Nutzer in seinem Home-Verzeichnis eine Datei anlegen, in der Username und Passwort gespeichert ist:

cd ~
nano .smbcredentials

Der Inhalt der Datei ist dabei recht einfach:

username=<User>
password=<Password>

Auf diese Datei sollte nur der entsprechende User Zugriff haben:

sudo chmod 600 .smbcredentials

Als nächstes werden die Verzeichnisse angelegt, in die die Freigaben gemountet werden sollen:

mkdir -p /mnt/bob
mkdir -p /mnt/shared

Soll die Freigabe nun temporär gemountet werden, können dazu folgende Befehle genutzt werden:

mount -t cifs -o credentials=~/.smbcredentials //192.168.178.60/bob /mnt/bob
mount -t cifs -o credentials=~/.smbcredentials //192.168.178.60/shared /mnt/shared

Hier wird folgendes angegeben:

-o credentials=~/.smbcredentials: Hier werden Benutzername/Passwort mit der soeben angelegten Datei übergeben.
//192.168.178.60/bob: IP des Samba-Servers und Name der Freigabe, wie auf dem Samba-Server in der Datei smb.conf als Sektions-Name angegeben.
/mnt/bob: In diesen Ordner wird die Freigabe gemountet.

Ein Aushängen (unmount) der Freigabe kann folgendermaßen durchgeführt werden:

umount /mnt/bob

Auch nach einem Neustart des Systems ist die Freigabe aber wieder verschwunden.

5.1.3- Dauerhaftes Mounten per fstab

Die Freigaben können aber auch per fstab gemountet werden. Damit stehen die Freigaben dann direkt nach einem System-Neustart zur Verfügung:

nano /etc/fstab

Am Ende der Datei wird nun folgendes hinzugefügt (die bereits bestehenden Einträge in der Datei sollte man nicht verändern):

//192.168.178.60/bob /mnt/bob cifs credentials=/home/bob/.smbcredentials,noperm,_netdev,noauto,x-systemd.automount 0 0
//192.168.178.60/shared /mnt/shared cifs credentials=/home/bob/.smbcredentials,noperm,_netdev,noauto,x-systemd.automount 0 0

Das Einbinden erfolgt ähnlich wie schon beim temporären Einbinden, jedoch gibt es einige Unterschiede:

Die Pfadangabe für die Datei mit den Credentials muss absolut erfolgen.
Mit noperm wird angegeben, dass die Credentials nicht Client-seitig, sondern nur auf dem Server geprüft werden.
_netdev gibt an, dass der Mount abhängig von einer Netzwerk-Verbindung ist.
Die Parameter noauto,x-systemd.automount sorgen dafür, dass die Freigabe erst beim ersten Zugriff gemountet wird. Dies macht das Einbinden etwas effizienter.

Ob das Mounten erfolgreich durchgeführt werden kann, testet man anschließend mit folgendem Befehl (als Root-User):

mount -a

Nun stehen die Freigaben direkt nach dem Systemstart zur Verfügung.

5.2 - Windows

Auch unter Windows kann man die Freigaben temporär oder dauerhaft einbinden.

5.2.1 - Temporärer Zugriff auf die Freigaben per Explorer

Um im Explorer direkten Zugriff auf die Freigaben zu erhalten, gibt man einfach die entsprechende Adresse des Samba-Servers ein, z.B. \\192.168.178.60. Nach der Eingabe von Benutzername und Passwort werden die Freigaben angezeigt: Direkter Zugriff auf die Freigaben (Windows)

5.2.2 - Direkter Zugriff auf die Freigaben (Windows)

= Dauerhaftes Einbinden unter Windows =

Um die Eingaben dauerhaft einzubinden, nutzt man im Explorer einfach die Funktion Netzlaufwerk verbinden: Windows: Netzlaufwerk verbinden

Im zweiten Schritt werden die Daten des Netzlaufwerks angegeben: Windows: Verbindung mit Netzlaufwerk herstellen

Neben dem zuzuweisenden Laufwerks-Buchstaben und dem Netzwerk-Pfad der Freigabe sollte die Option Verbindung mit anderen Anmeldeinformationen herstellen gewählt werden. Anschließend gibt man Benutzername und Passwort des Linux/Samba-Users an.

Ein Samba-Server ist schnell auf einem Linux Server installiert. Die Konfiguration erfordert etwas Handarbeit. Gerade für Freigaben, die mehreren Benutzern zur Verfügung stehen sollen, sind zwei Varianten möglich (ACL und Bilden von Gruppen). Ich bevorzuge hier die Nutzung von ACLs, da das Konfigurieren der Freigaben bei Samba sehr viel einfacher erfolgen kann.

Wenn der Samba-Server fertig konfiguriert ist, steht dieser dauerhaft als Speicherort im Netzwerk zur Verfügung. Durch das weit verbreitete SMB-Protokoll können diese Freigaben dann auf beliebigen Systemen eingebunden werden.

Samba Homepage (englisch) |Samba (Software) (Wikipedia) Server Message Block (Wikipedia) Access Control List (Wikipedia)

02 - Installation und Konfiguration von PHP 7.4 (fpm) - NextCloud - DokuWiki

Das PHP Repository wurde bereits im vorherigen Kapitel eingerichtet und aktiviert, so dass wir direkt mit der Installation beginnen können.:

apt update && apt install php7.4-fpm php7.4-gd php7.4-mysql php7.4-curl php7.4-xml php7.4-zip php7.4-intl php7.4-mbstring  php7.4-sqlite3 php7.4-json php7.4-bz2 php7.4-ldap php-apcu php7.4-bcmath php7.4-gmp imagemagick php-imagick php-smbclient ldap-utils -y

Setzen Sie das richtige Datumsformat, um auch ein korrektes Logging zu ermöglichen:

timedatectl set-timezone Europe/Berlin

Bevor wir mit den Optimierungen von PHP beginnen sichern wir die Konfigurationsdateien:

cp /etc/php/7.4/fpm/pool.d/www.conf /etc/php/7.4/fpm/pool.d/www.conf.bak
cp /etc/php/7.4/cli/php.ini /etc/php/7.4/cli/php.ini.bak
cp /etc/php/7.4/fpm/php.ini /etc/php/7.4/fpm/php.ini.bak
cp /etc/php/7.4/fpm/php-fpm.conf /etc/php/7.4/fpm/php-fpm.conf.bak
cp /etc/ImageMagick-6/policy.xml /etc/ImageMagick-6/policy.xml.bak

Führen Sie nun alle nachfolgenden Optimierungen durch:

sed -i "s/;env\[HOSTNAME\] = /env[HOSTNAME] = /" /etc/php/7.4/fpm/pool.d/www.conf
sed -i "s/;env\[TMP\] = /env[TMP] = /" /etc/php/7.4/fpm/pool.d/www.conf
sed -i "s/;env\[TMPDIR\] = /env[TMPDIR] = /" /etc/php/7.4/fpm/pool.d/www.conf
sed -i "s/;env\[TEMP\] = /env[TEMP] = /" /etc/php/7.4/fpm/pool.d/www.conf
sed -i "s/;env\[PATH\] = /env[PATH] = /" /etc/php/7.4/fpm/pool.d/www.conf
sed -i "s/pm.max_children =.*/pm.max_children = 120/" /etc/php/7.4/fpm/pool.d/www.conf
sed -i "s/pm.start_servers =.*/pm.start_servers = 12/" /etc/php/7.4/fpm/pool.d/www.conf
sed -i "s/pm.min_spare_servers =.*/pm.min_spare_servers = 6/" /etc/php/7.4/fpm/pool.d/www.conf
sed -i "s/pm.max_spare_servers =.*/pm.max_spare_servers = 18/" /etc/php/7.4/fpm/pool.d/www.conf
sed -i "s/;pm.max_requests =.*/pm.max_requests = 1000/" /etc/php/7.4/fpm/pool.d/www.conf

sed -i "s/output_buffering =.*/output_buffering = 'Off'/" /etc/php/7.4/cli/php.ini
sed -i "s/max_execution_time =.*/max_execution_time = 3600/" /etc/php/7.4/cli/php.ini
sed -i "s/max_input_time =.*/max_input_time = 3600/" /etc/php/7.4/cli/php.ini
sed -i "s/post_max_size =.*/post_max_size = 10240M/" /etc/php/7.4/cli/php.ini
sed -i "s/upload_max_filesize =.*/upload_max_filesize = 10240M/" /etc/php/7.4/cli/php.ini
sed -i "s/;date.timezone.*/date.timezone = Europe\/\Berlin/" /etc/php/7.4/cli/php.ini

sed -i "s/memory_limit = 128M/memory_limit = 1024M/" /etc/php/7.4/fpm/php.ini
sed -i "s/output_buffering =.*/output_buffering = 'Off'/" /etc/php/7.4/fpm/php.ini
sed -i "s/max_execution_time =.*/max_execution_time = 3600/" /etc/php/7.4/fpm/php.ini
sed -i "s/max_input_time =.*/max_input_time = 3600/" /etc/php/7.4/fpm/php.ini
sed -i "s/post_max_size =.*/post_max_size = 10240M/" /etc/php/7.4/fpm/php.ini
sed -i "s/upload_max_filesize =.*/upload_max_filesize = 10240M/" /etc/php/7.4/fpm/php.ini
sed -i "s/;date.timezone.*/date.timezone = Europe\/\Berlin/" /etc/php/7.4/fpm/php.ini
sed -i "s/;session.cookie_secure.*/session.cookie_secure = True/" /etc/php/7.4/fpm/php.ini
sed -i "s/;opcache.enable=.*/opcache.enable=1/" /etc/php/7.4/fpm/php.ini
sed -i "s/;opcache.enable_cli=.*/opcache.enable_cli=1/" /etc/php/7.4/fpm/php.ini
sed -i "s/;opcache.memory_consumption=.*/opcache.memory_consumption=128/" /etc/php/7.4/fpm/php.ini
sed -i "s/;opcache.interned_strings_buffer=.*/opcache.interned_strings_buffer=8/" /etc/php/7.4/fpm/php.ini
sed -i "s/;opcache.max_accelerated_files=.*/opcache.max_accelerated_files=10000/" /etc/php/7.4/fpm/php.ini
sed -i "s/;opcache.revalidate_freq=.*/opcache.revalidate_freq=1/" /etc/php/7.4/fpm/php.ini
sed -i "s/;opcache.save_comments=.*/opcache.save_comments=1/" /etc/php/7.4/fpm/php.ini

sed -i '$aapc.enable_cli=1' /etc/php/7.4/mods-available/apcu.ini

sed -i "s/rights=\"none\" pattern=\"PS\"/rights=\"read|write\" pattern=\"PS\"/" /etc/ImageMagick-6/policy.xml
sed -i "s/rights=\"none\" pattern=\"EPS\"/rights=\"read|write\" pattern=\"EPS\"/" /etc/ImageMagick-6/policy.xml
sed -i "s/rights=\"none\" pattern=\"PDF\"/rights=\"read|write\" pattern=\"PDF\"/" /etc/ImageMagick-6/policy.xml
sed -i "s/rights=\"none\" pattern=\"XPS\"/rights=\"read|write\" pattern=\"XPS\"/" /etc/ImageMagick-6/policy.xml

Starten Sie nun beide Dienste, nginx und PHP, neu:

service php7.4-fpm restart

service nginx restart

Auch PHP ist nun bereits installiert und für Nextcloud optimiert. Starten wir nun mit der Installation und Konfiguration des Datenbankserver MariaDB.

03 - Installation und Konfiguration von PHP 7.1 (fpm) - InSoFa - FB-RE-KWG - KiTa-LEQ-MSH - phpMyEdit - FormGenerator

Fügen Sie dann die Softwarequellen für PHP 7.1 hinzu:

echo "deb http://ppa.launchpad.net/ondrej/php/ubuntu $(lsb_release -cs) main" | tee php.list
<code>

Um diesen Quellen vertrauen zu können nutzen wir die entsprechenden Schlüssel:

PHP-Key:

<code>
apt-key adv --recv-keys --keyserver hkps://keyserver.ubuntu.com:443 4F4EA0AAE5267A6C

PHP 7.1 installieren und konfigurieren:

apt update && apt install php7.1-fpm php7.1-gd php7.1-mysql php7.1-curl php7.1-xml php7.1-zip php7.1-intl php7.1-mbstring  php7.1-sqlite3 php7.1-json php7.1-bz2 php7.1-ldap php-apcu php7.1-bcmath php7.1-gmp imagemagick php-imagick php-smbclient ldap-utils -y

Setzen Sie das richtige Datumsformat, um auch ein korrektes Logging zu ermöglichen:

timedatectl set-timezone Europe/Berlin

Bevor wir mit den Optimierungen von PHP beginnen sichern wir die Konfigurationsdateien:

cp /etc/php/7.1/fpm/pool.d/www.conf /etc/php/7.1/fpm/pool.d/www.conf.bak
cp /etc/php/7.1/cli/php.ini /etc/php/7.1/cli/php.ini.bak
cp /etc/php/7.1/fpm/php.ini /etc/php/7.1/fpm/php.ini.bak
cp /etc/php/7.1/fpm/php-fpm.conf /etc/php/7.1/fpm/php-fpm.conf.bak
cp /etc/ImageMagick-6/policy.xml /etc/ImageMagick-6/policy.xml.bak

Führen Sie nun alle nachfolgenden Optimierungen durch:

sed -i "s/;env\[HOSTNAME\] = /env[HOSTNAME] = /" /etc/php/7.1/fpm/pool.d/www.conf
sed -i "s/;env\[TMP\] = /env[TMP] = /" /etc/php/7.1/fpm/pool.d/www.conf
sed -i "s/;env\[TMPDIR\] = /env[TMPDIR] = /" /etc/php/7.1/fpm/pool.d/www.conf
sed -i "s/;env\[TEMP\] = /env[TEMP] = /" /etc/php/7.1/fpm/pool.d/www.conf
sed -i "s/;env\[PATH\] = /env[PATH] = /" /etc/php/7.1/fpm/pool.d/www.conf
sed -i "s/pm.max_children =.*/pm.max_children = 120/" /etc/php/7.1/fpm/pool.d/www.conf
sed -i "s/pm.start_servers =.*/pm.start_servers = 12/" /etc/php/7.1/fpm/pool.d/www.conf
sed -i "s/pm.min_spare_servers =.*/pm.min_spare_servers = 6/" /etc/php/7.1/fpm/pool.d/www.conf
sed -i "s/pm.max_spare_servers =.*/pm.max_spare_servers = 18/" /etc/php/7.1/fpm/pool.d/www.conf
sed -i "s/;pm.max_requests =.*/pm.max_requests = 1000/" /etc/php/7.1/fpm/pool.d/www.conf

sed -i "s/output_buffering =.*/output_buffering = 'Off'/" /etc/php/7.1/cli/php.ini
sed -i "s/max_execution_time =.*/max_execution_time = 3600/" /etc/php/7.1/cli/php.ini
sed -i "s/max_input_time =.*/max_input_time = 3600/" /etc/php/7.1/cli/php.ini
sed -i "s/post_max_size =.*/post_max_size = 10240M/" /etc/php/7.1/cli/php.ini
sed -i "s/upload_max_filesize =.*/upload_max_filesize = 10240M/" /etc/php/7.1/cli/php.ini
sed -i "s/;date.timezone.*/date.timezone = Europe\/\Berlin/" /etc/php/7.1/cli/php.ini

sed -i "s/memory_limit = 128M/memory_limit = 1024M/" /etc/php/7.1/fpm/php.ini
sed -i "s/output_buffering =.*/output_buffering = 'Off'/" /etc/php/7.1/fpm/php.ini
sed -i "s/max_execution_time =.*/max_execution_time = 3600/" /etc/php/7.1/fpm/php.ini
sed -i "s/max_input_time =.*/max_input_time = 3600/" /etc/php/7.1/fpm/php.ini
sed -i "s/post_max_size =.*/post_max_size = 10240M/" /etc/php/7.1/fpm/php.ini
sed -i "s/upload_max_filesize =.*/upload_max_filesize = 10240M/" /etc/php/7.1/fpm/php.ini
sed -i "s/;date.timezone.*/date.timezone = Europe\/\Berlin/" /etc/php/7.1/fpm/php.ini
sed -i "s/;session.cookie_secure.*/session.cookie_secure = True/" /etc/php/7.1/fpm/php.ini
sed -i "s/;opcache.enable=.*/opcache.enable=1/" /etc/php/7.1/fpm/php.ini
sed -i "s/;opcache.enable_cli=.*/opcache.enable_cli=1/" /etc/php/7.1/fpm/php.ini
sed -i "s/;opcache.memory_consumption=.*/opcache.memory_consumption=128/" /etc/php/7.1/fpm/php.ini
sed -i "s/;opcache.interned_strings_buffer=.*/opcache.interned_strings_buffer=8/" /etc/php/7.1/fpm/php.ini
sed -i "s/;opcache.max_accelerated_files=.*/opcache.max_accelerated_files=10000/" /etc/php/7.1/fpm/php.ini
sed -i "s/;opcache.revalidate_freq=.*/opcache.revalidate_freq=1/" /etc/php/7.1/fpm/php.ini
sed -i "s/;opcache.save_comments=.*/opcache.save_comments=1/" /etc/php/7.1/fpm/php.ini

sed -i '$aapc.enable_cli=1' /etc/php/7.1/mods-available/apcu.ini

sed -i "s/rights=\"none\" pattern=\"PS\"/rights=\"read|write\" pattern=\"PS\"/" /etc/ImageMagick-6/policy.xml
sed -i "s/rights=\"none\" pattern=\"EPS\"/rights=\"read|write\" pattern=\"EPS\"/" /etc/ImageMagick-6/policy.xml
sed -i "s/rights=\"none\" pattern=\"PDF\"/rights=\"read|write\" pattern=\"PDF\"/" /etc/ImageMagick-6/policy.xml
sed -i "s/rights=\"none\" pattern=\"XPS\"/rights=\"read|write\" pattern=\"XPS\"/" /etc/ImageMagick-6/policy.xml

Starten Sie nun beide Dienste, nginx und PHP, neu:

service php7.1-fpm restart

service nginx restart

4. SSL-ZertifikatsErstellung mit LetsEncrypt

Webroot-Modus

acme.sh --issue -d netzwerk-kinderschutz-msh.de -d info.netzwerk-kinderschutz-msh.de --keylength 4096 -w /var/www/letsencrypt --key-file /etc/letsencrypt/rsa-certs/privkey.pem --ca-file /etc/letsencrypt/rsa-certs/chain.pem --cert-file /etc/letsencrypt/rsa-certs/cert.pem --fullchain-file /etc/letsencrypt/rsa-certs/fullchain.pem

acme.sh --issue -d netzwerk-kinderschutz-msh.de -d info.netzwerk-kinderschutz-msh.de --keylength ec-384 -w /var/www/letsencrypt --key-file /etc/letsencrypt/ecc-certs/privkey.pem --ca-file /etc/letsencrypt/ecc-certs/chain.pem --cert-file /etc/letsencrypt/ecc-certs/cert.pem --fullchain-file /etc/letsencrypt/ecc-certs/fullchain.pem

acme.sh --issue -d netzwerk-kinderschutz-msh.de -d *.netzwerk-kinderschutz-msh.de  --dns --yes-I-know-dns-manual-mode-enough-go-ahead-please

acme.sh --renew --force -d netzwerk-kinderschutz-msh.de -d *.netzwerk-kinderschutz-msh.de  --dns --yes-I-know-dns-manual-mode-enough-go-ahead-please

acme.sh --issue --force -d netzwerk-kinderschutz-msh.de -d *.netzwerk-kinderschutz-msh.de  --dns --keylength ec-384 --yes-I-know-dns-manual-mode-enough-go-ahead-please

cp /home/acmeuser/.acme.sh/netzwerk-kinderschutz-msh.de/netzwerk-kinderschutz-msh.de.cer /etc/letsencrypt/rsa-certs/cert.pem
cp /home/acmeuser/.acme.sh/netzwerk-kinderschutz-msh.de/netzwerk-kinderschutz-msh.de.key /etc/letsencrypt/rsa-certs/privkey.pem
cp  /home/acmeuser/.acme.sh/netzwerk-kinderschutz-msh.de/ca.cer /etc/letsencrypt/rsa-certs/chain.pem
cp /home/acmeuser/.acme.sh/netzwerk-kinderschutz-msh.de/fullchain.cer /etc/letsencrypt/rsa-certs/fullchain.pem

cp /home/acmeuser/.acme.sh/netzwerk-kinderschutz-msh.de_ecc/netzwerk-kinderschutz-msh.de.cer /etc/letsencrypt/ecc-certs/cert.pem
cp  /home/acmeuser/.acme.sh/netzwerk-kinderschutz-msh.de_ecc/netzwerk-kinderschutz-msh.de.key /etc/letsencrypt/ecc-certs/privkey.pem
cp  /home/acmeuser/.acme.sh/netzwerk-kinderschutz-msh.de_ecc/ca.cer /etc/letsencrypt/ecc-certs/chain.pem
cp /home/acmeuser/.acme.sh/netzwerk-kinderschutz-msh.de_ecc/fullchain.cer /etc/letsencrypt/ecc-certs/fullchain.pem

ACME.SH - DNS-Modus - Erstellung / Erneuerung von Wildcard-Zertifikaten

Eine weitere Möglichkeit, die für die Erstellung von Wildcard-Zertifikaten sogar zwingend ist, ist die Validierung der Domain via DNS-Eintrag. Dabei gibt acme.sh einen Text aus, der zur Zonendatei hinzugefügt werden muss. Großer Nachteil ist, dass Verlängerungen hier nur händisch möglich sind, denn der Text ändert sich regelmäßig. Das sieht dann beispielsweise so aus:

Wechseln Sie in die Shell des neuen Benutzers

su acmeuser

und requestieren (beantragen) die RSA-SSL-Zertifikate

acme.sh --issue --test -d netzwerk-kinderschutz-msh.de -d *.netzwerk-kinderschutz-msh.de --keylength 4096 --dns --yes-I-know-dns-manual-mode-enough-go-ahead-please --key-file /etc/letsencrypt/rsa-certs/privkey.pem --ca-file /etc/letsencrypt/rsa-certs/chain.pem --cert-file /etc/letsencrypt/rsa-certs/cert.pem --fullchain-file /etc/letsencrypt/rsa-certs/fullchain.pem

bzw. requestieren (beantragen) die ECDSA-SSL-Zertifikate

acme.sh --issue --test -d netzwerk-kinderschutz-msh.de -d *.netzwerk-kinderschutz-msh.de --keylength ec-384 --dns --yes-I-know-dns-manual-mode-enough-go-ahead-please --key-file /etc/letsencrypt/ecc-certs/privkey.pem --ca-file /etc/letsencrypt/ecc-certs/chain.pem --cert-file /etc/letsencrypt/ecc-certs/cert.pem --fullchain-file /etc/letsencrypt/ecc-certs/fullchain.pem

die folgende Meldung zeigt die notwendigen Schlüssel-Werte die unter: ionos.de > Domains & SSL > netzwerk-kinderschutz-msh.de > DNS-Record bearbeiten (Provider - VertragsVerwaltung) einzutragen sind

acmeuser@netzwerk-kinderschutz-msh:~$ acme.sh --issue --test -d netzwerk-kinderschutz-msh.de -d *.netzwerk-kinderschutz-msh.de --k                            eylength ec-384 --dns --yes-I-know-dns-manual-mode-enough-go-ahead-please --key-file /etc/letsencrypt/ecc-certs/privkey.pem --ca-f                            ile /etc/letsencrypt/ecc-certs/chain.pem --cert-file /etc/letsencrypt/ecc-certs/cert.pem --fullchain-file /etc/letsencrypt/ecc-cer                            ts/fullchain.pem
[Mon 23 Nov 2020 12:37:16 PM CET] Using ACME_DIRECTORY: https://acme-staging-v02.api.letsencrypt.org/directory
[Mon 23 Nov 2020 12:37:17 PM CET] Using CA: https://acme-staging-v02.api.letsencrypt.org/directory
[Mon 23 Nov 2020 12:37:17 PM CET] Multi domain='DNS:netzwerk-kinderschutz-msh.de,DNS:*.netzwerk-kinderschutz-msh.de'
[Mon 23 Nov 2020 12:37:17 PM CET] Getting domain auth token for each domain
[Mon 23 Nov 2020 12:37:20 PM CET] Getting webroot for domain='netzwerk-kinderschutz-msh.de'
[Mon 23 Nov 2020 12:37:20 PM CET] Getting webroot for domain='*.netzwerk-kinderschutz-msh.de'
[Mon 23 Nov 2020 12:37:20 PM CET] Add the following TXT record:
[Mon 23 Nov 2020 12:37:20 PM CET] Domain: '_acme-challenge.netzwerk-kinderschutz-msh.de'
[Mon 23 Nov 2020 12:37:20 PM CET] TXT value: 'eU4d8fvQ6NjLiowk2JbNrdIKECuTZiNBR9Qo5yJID8k'
[Mon 23 Nov 2020 12:37:20 PM CET] Please be aware that you prepend _acme-challenge. before your domain
[Mon 23 Nov 2020 12:37:20 PM CET] so the resulting subdomain will be: _acme-challenge.netzwerk-kinderschutz-msh.de
[Mon 23 Nov 2020 12:37:20 PM CET] Add the following TXT record:
[Mon 23 Nov 2020 12:37:20 PM CET] Domain: '_acme-challenge.netzwerk-kinderschutz-msh.de'
[Mon 23 Nov 2020 12:37:20 PM CET] TXT value: 'PqYsD2xq9TxqAoicelrOIGPGjBl4ZAxVg1bR9fgesZg'
[Mon 23 Nov 2020 12:37:20 PM CET] Please be aware that you prepend _acme-challenge. before your domain
[Mon 23 Nov 2020 12:37:20 PM CET] so the resulting subdomain will be: _acme-challenge.netzwerk-kinderschutz-msh.de
[Mon 23 Nov 2020 12:37:20 PM CET] Please add the TXT records to the domains, and re-run with --renew.
[Mon 23 Nov 2020 12:37:20 PM CET] Please add '--debug' or '--log' to check more details.
[Mon 23 Nov 2020 12:37:20 PM CET] See: https://github.com/acmesh-official/acme.sh/wiki/How-to-debug-acme.sh

Sind die Record-Einträge erfolgt, kann die Beantragung der SSL-Zertifikate (Muss für jeden Zertifikats-Typ wiederholt werden!) erfolgen und wird erfolgreich abgeschlosssen

acme.sh --issue -d netzwerk-kinderschutz-msh.de -d *.netzwerk-kinderschutz-msh.de --keylength ec-384 --dns --yes-I-know-dns-manual-mode-enough-go-ahead-please --key-file /etc/letsencrypt/ecc-certs/privkey.pem --ca-file /etc/letsencrypt/ecc-certs/chain.pem --cert-file /etc/letsencrypt/ecc-certs/cert.pem --fullchain-file /etc/letsencrypt/ecc-certs/fullchain.pem

acmeuser@netzwerk-kinderschutz-msh:~$ acme.sh --issue -d netzwerk-kinderschutz-msh.de -d *.netzwerk-kinderschutz-msh.de --keylengt                            h ec-384 --dns --yes-I-know-dns-manual-mode-enough-go-ahead-please --key-file /etc/letsencrypt/ecc-certs/privkey.pem --ca-file /et                            c/letsencrypt/ecc-certs/chain.pem --cert-file /etc/letsencrypt/ecc-certs/cert.pem --fullchain-file /etc/letsencrypt/ecc-certs/full                            chain.pem
[Mon 23 Nov 2020 12:45:37 PM CET] Using CA: https://acme-v02.api.letsencrypt.org/directory
[Mon 23 Nov 2020 12:45:37 PM CET] Multi domain='DNS:netzwerk-kinderschutz-msh.de,DNS:*.netzwerk-kinderschutz-msh.de'
[Mon 23 Nov 2020 12:45:37 PM CET] Getting domain auth token for each domain
[Mon 23 Nov 2020 12:45:40 PM CET] Getting webroot for domain='netzwerk-kinderschutz-msh.de'
[Mon 23 Nov 2020 12:45:40 PM CET] Getting webroot for domain='*.netzwerk-kinderschutz-msh.de'
[Mon 23 Nov 2020 12:45:40 PM CET] netzwerk-kinderschutz-msh.de is already verified, skip dns-01.
[Mon 23 Nov 2020 12:45:40 PM CET] *.netzwerk-kinderschutz-msh.de is already verified, skip dns-01.
[Mon 23 Nov 2020 12:45:40 PM CET] Verify finished, start to sign.
[Mon 23 Nov 2020 12:45:40 PM CET] Lets finalize the order.
[Mon 23 Nov 2020 12:45:40 PM CET] Le_OrderFinalize='https://acme-v02.api.letsencrypt.org/acme/finalize/94729019/6362094324'
[Mon 23 Nov 2020 12:45:42 PM CET] Downloading cert.
[Mon 23 Nov 2020 12:45:42 PM CET] Le_LinkCert='https://acme-v02.api.letsencrypt.org/acme/cert/04fd484ff785863cf89fd0b02151aaf4fca4                            '
[Mon 23 Nov 2020 12:45:42 PM CET] Cert success.
-----BEGIN CERTIFICATE-----
MIIE4zCCA8ugAwIBAgISBP1IT/eFhjz4n9CwIVGq9PykMA0GCSqGSIb3DQEBCwUA
MEoxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1MZXQncyBFbmNyeXB0MSMwIQYDVQQD
ExpMZXQncyBFbmNyeXB0IEF1dGhvcml0eSBYMzAeFw0yMDExMjMxMDQ1NDFaFw0y
MTAyMjExMDQ1NDFaMCcxJTAjBgNVBAMTHG5ldHp3ZXJrLWtpbmRlcnNjaHV0ei1t
c2guZGUwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAASDEWu7VyiyWyHVHU+bQMzhCI8G
pT4NZJDW/yyI6aqIptYe5gTQGE0KdFTgbqke6pKjRaTA7tcCa9y3SW/tmGYrYVAj
9mNdRZc+VxONPrCFGEbQ2QdlpNsYLBSaxePGty2jggKSMIICjjAOBgNVHQ8BAf8E
BAMCB4AwHQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMAwGA1UdEwEB/wQC
MAAwHQYDVR0OBBYEFO1+VX1Tg9dWvMiBjDrxM/CBB0VKMB8GA1UdIwQYMBaAFKhK
amMEfd265tE5t6ZFZe/zqOyhMG8GCCsGAQUFBwEBBGMwYTAuBggrBgEFBQcwAYYi
aHR0cDovL29jc3AuaW50LXgzLmxldHNlbmNyeXB0Lm9yZzAvBggrBgEFBQcwAoYj
aHR0cDovL2NlcnQuaW50LXgzLmxldHNlbmNyeXB0Lm9yZy8wRwYDVR0RBEAwPoIe
Ki5uZXR6d2Vyay1raW5kZXJzY2h1dHotbXNoLmRlghxuZXR6d2Vyay1raW5kZXJz
Y2h1dHotbXNoLmRlMEwGA1UdIARFMEMwCAYGZ4EMAQIBMDcGCysGAQQBgt8TAQEB
MCgwJgYIKwYBBQUHAgEWGmh0dHA6Ly9jcHMubGV0c2VuY3J5cHQub3JnMIIBBQYK
KwYBBAHWeQIEAgSB9gSB8wDxAHYA9lyUL9F3MCIUVBgIMJRWjuNNExkzv98MLyAL
zE7xZOMAAAF19OyBZgAABAMARzBFAiEAjPkr2FnkqyAou5eMMUC4hNPdaqwKGoE/
4IIQ18aFo9wCID/jVFTvyzIAIALYTuNg4pMCNko6hs5WEe+OxhPLcsZGAHcAb1N2
rDHwMRnYmQCkURX/dxUcEdkCwQApBo2yCJo32RMAAAF19OyB1gAABAMASDBGAiEA
9nfGYc79ffTLjohXWRvr478OiPGfzcavMchCHtkVwY4CIQDTKHQu8oHb5vMnSHF5
fC7mk+Rh0n8G0Msb7IgQH/IW4jANBgkqhkiG9w0BAQsFAAOCAQEAKWSCXrOEM2F8
tN3wJNM9YbvLDQrgYsC1PMB5rVGqGfBVd93eI6rS0beute4L8U26vPo4LQDcd22/
ehC0NZUQhdH4TBtozUwHIV8n4ydkX61Aoh7GPrVp0ugXpCAgaGoJy+SrGRhLA75w
6HdgnUmNGt9pzWNl16YE4UCyqrs3eQLBHvDKMnuOm7JgGbPo8zUTFA9lahFxg2j2
/C1tkPa+6peEUSE59aeq5WVpWI6/xG+HUaz1YblopJ6ZAXSwYwb54BB41p+9V0vM
c+8Tg5Xpg4Dif2CT70TVgcCWW+uL/0tF6jhgX+qHSJ6P3rTd8dx6knXBqzeuwx/a
PuR7ZH7siA==
-----END CERTIFICATE-----
[Mon 23 Nov 2020 12:45:42 PM CET] Your cert is in  /home/acmeuser/.acme.sh/netzwerk-kinderschutz-msh.de_ecc/netzwerk-kinderschutz-                            msh.de.cer
[Mon 23 Nov 2020 12:45:42 PM CET] Your cert key is in  /home/acmeuser/.acme.sh/netzwerk-kinderschutz-msh.de_ecc/netzwerk-kindersch                            utz-msh.de.key
[Mon 23 Nov 2020 12:45:42 PM CET] The intermediate CA cert is in  /home/acmeuser/.acme.sh/netzwerk-kinderschutz-msh.de_ecc/ca.cer
[Mon 23 Nov 2020 12:45:42 PM CET] And the full chain certs is there:  /home/acmeuser/.acme.sh/netzwerk-kinderschutz-msh.de_ecc/ful                            lchain.cer
[Mon 23 Nov 2020 12:45:42 PM CET] Installing cert to:/etc/letsencrypt/ecc-certs/cert.pem
[Mon 23 Nov 2020 12:45:42 PM CET] Installing CA to:/etc/letsencrypt/ecc-certs/chain.pem
[Mon 23 Nov 2020 12:45:42 PM CET] Installing key to:/etc/letsencrypt/ecc-certs/privkey.pem
[Mon 23 Nov 2020 12:45:42 PM CET] Installing full chain to:/etc/letsencrypt/ecc-certs/fullchain.pem

Die derzeit aktiven Zertifikate und die Ablaufzeiten listet folgender Befehl auf:

acme.sh --list

Verlassen Sie die Shell des neuen Benutzers

exit

StartenSie den WebServer und WEBMIN neu:

service nginx restart
service webmin restart

9. phpMyDump - Nginx-Server - Perl-Scripte ausführen

last updated June 5, 2020 in Categories Linux, Nginx, Ubuntu Linux ⇒ NGINX + PERL - HOW-To-DO - Modifikation TJ

The fcgiwrap is a simple server for running CGI apps over FastCGI. We can use it to provide clean CGI support to the nginx webserver. It is a lightweight server with zero-configuration options, making it possible to use the same pool to run different sites. This page explains how to install fcgiwrap on Ubuntu 20.04.

CGI means Common Gateway Interface, and it is one early method for creating dynamic pages. Another good example is telling your web servers to execute Unix programs and more. This tutorial assumes that you have installed and configured the Nginx server on Ubuntu Linux 20.04 LTS.

Installing fcgiwrap on Ubuntu 20.04

Open the terminal application and then type the following commands to update installed packages for security on Ubuntu 20.04:

$ sudo apt update
$ sudo apt upgrade

To install the fcgiwrap packages for Nginx, run the following command as root user or as sudo-user:

$ sudo apt install fcgiwrap

Turn on fcgiwrap service on Ubuntu 20.04

Use the systemctl command as follows:

$ sudo systemctl enable fcgiwrap
$ sudo systemctl start fcgiwrap
$ sudo systemctl status fcgiwrap

Terminal-Output:

● fcgiwrap.service - Simple CGI Server
     Loaded: loaded (/lib/systemd/system/fcgiwrap.service; indirect; vendor preset: enabled)
     Active: active (running) since Fri 2020-06-05 08:59:45 UTC; 1min 20s ago
TriggeredBy: ● fcgiwrap.socket
   Main PID: 113093 (fcgiwrap)
      Tasks: 1 (limit: 115783)
     Memory: 608.0K
     CGroup: /system.slice/fcgiwrap.service
             └─113093 /usr/sbin/fcgiwrap -f

Jun 05 08:59:45 utls-wp-mg-www-cbz systemd[1]: Started Simple CGI Server.

Configuring fcgiwrap for Nginx - virtualhost - 23_phpMyDump - Ausführen von .CGI bzw. .PL-Scripten

Folgenden Abschnitt für den 'Virtualhost' in '/etc/nginx/conf.d/00_LNKS_01_WIKI_AKTUELL_INTERNET_GATEWAY.conf' einfügen:

### phpMyDump - DatenBank-Sicherung  ##############################################################################################################################################
   
    location ^~ /23_phpMyDump/ {
             # Set max. size of a request (important for uploads to ownCloud)
             client_max_body_size 1G;
	      # Besides the timeout values have to be raised in nginx' owncloud config, these values have to be raised for the proxy as well
	      proxy_connect_timeout 300;
	      proxy_send_timeout 300;
	      proxy_read_timeout 300;
	      send_timeout 300;
	      proxy_set_header Host $host;
	      proxy_set_header X-Real-IP $remote_addr;
	      proxy_pass http://127.0.0.1:84;
	      proxy_redirect off;
	      }

Datei '/etc/nginx/conf.d/23_phpMyDump.conf' anlegen und folgende Zeilen hinzufügen:

server {
	server_name 127.0.0.1;
	listen 127.0.0.1:84;
      
	root /var/www/;
	
	location ^~ /23_phpMyDump {		
		 
	index       index.php index.html index.htm;

       auth_basic "Restricted"; # Ausgabe-Meldung bei Zugriff
       auth_basic_user_file /var/www/23_phpMyDump/.htpasswd; # Pfad zur .htpasswd-Datei

       access_log  /var/log/nginx/23_phpMyDump.access.log;
       error_log   /var/log/nginx/23_phpMyDump.error.log;
 
    
	location ~ \.php$ {
				try_files $uri =404;
                            
                            fastcgi_pass 127.0.0.1:9000; 
                            fastcgi_index  index.php;

				fastcgi_split_path_info ^(.+\.php)(/.+)$;
				include fastcgi_params;
			
				fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
				fastcgi_param PATH_INFO $fastcgi_path_info;
				
				fastcgi_connect_timeout 60;
				
				fastcgi_param PHP_VALUE "open_basedir=/var/www
						upload_max_filesize = 1G
						post_max_size = 1G
						max_execution_time = 3600";
		}

        ## Turn on /cgi-bin/ support to run CGI apps - alternativ ~ \.pl$ ##
       
        location ~ \.cgi$ {
		
                # Disable gzip (it makes scripts feel slower since they have to complete
                # before getting gzipped)
                gzip off;
 
                # Fastcgi socket
                fastcgi_pass  unix:/var/run/fcgiwrap.socket;
 
                # Fastcgi parameters, include the standard ones
                include /etc/nginx/fastcgi_params;
	         }
              
  
        # Adding the cache control header for js and css files
        # Make sure it is BELOW the PHP block
        location ~* \.(?:css|js)$ {
            try_files $uri /23_phpMyDump/$uri$is_args$args;
            proxy_set_header Cache-Control "public, max-age=7200";
            # Add headers to serve security related headers
            # Again use 'proxy_set_header' (not 'add_header') as the headers have to be passed through a proxy.
            proxy_set_header Strict-Transport-Security "max-age=15768000; includeSubDomains; preload;";
            proxy_set_header X-Content-Type-Options nosniff;
            proxy_set_header X-Frame-Options "SAMEORIGIN";
            proxy_set_header X-XSS-Protection "1; mode=block";
            proxy_set_header X-Robots-Tag none;
            proxy_set_header X-Download-Options noopen;
            proxy_set_header X-Permitted-Cross-Domain-Policies none;
            # Optional: Don't log access to assets
            access_log off;
        }

       location ~* ^/23_phpMyDump/(.+\.(jpg|jpeg|gif|css|png|js|ico|html|xml|txt))$ {
                       root /var/www/23_phpMyDump/;
               }
           
        

		
	}
}

Save and close the file. Reload or restart the Nginx server:

$ sudo nginx -t
$ sudo service nginx restart

Konfiguration 'MYOOS - phpMyDump' - ALLGEMEIN

In Konfigurations-Ansicht Multidump aktivieren sowie Auto-Löschen auf 7 einstellen.

Konfiguration 'MYOOS - phpMyDump' - crondump.cgi

Datei '/var/www/23_phpMyDump/cgi-bin/crondump.cgi' öffnen und Zeilen 28 bis 31 wie folgt ändern:

my $absolute_path_of_configdir="/var/www/23_phpMyDump/work/config/";
my $cgibin_path="/var/www/23_phpMyDump/cgi-bin"; # this is needed for MIME::Lite if it is in cgi-bin
my $default_configfile="myoosdumper.conf.php";

Konfiguration 'MYOOS - phpMyDump' - crontab einrichten => zeitgesteuertes Backup

Datei '/etc/crontab' öffnen und Zeile hinzufügen:

15 23 * * * perl /var/www/23_phpMyDump/cgi-bin/crondump.cgi -config=myoosdumper -html_output=0

10 - NextCloud im Iframe nutzen - Anpassung für KiTa-SozArb-DokSys

NextCloud anpassen Datei '/var/www/21_LNKS_22_kita-sozarb-nc/lib/public/AppFramework/Http/ContentSecurityPolicy.php' öffnen und in Zeile 79 und Zeile 93 folgende Ergänzungen vornehmen:

       /** @var array Domains from which iframes can be loaded */
	protected $allowedFrameDomains = [
       'https://*.netzwerk-kinderschutz-msh.de', 
       ];

       /** @var array Domains which can embed this Nextcloud instance */
	protected $allowedFrameAncestors = [
		'\'self\'',
              'https://*.netzwerk-kinderschutz-msh.de', 
	];

Nginx anpassen Datei '/etc/nginx/header.conf' öffnen und folgende Zeile hinzufügen:

add_header X-Frame-Options "allow-from https://*.netzwerk-kinderschutz-msh.de" always;
add_header X-Frame-Options "allow-from https://netzwerk-kinderschutz-msh.de" always;

11 - Nextcloud Talk mit eigenem TURN-Server (coturn)

99 NextCloud - Konfiguration anpassen

Modifizieren Sie die „.user.ini“

sudo -u www-data sed -i "s/output_buffering=.*/output_buffering='Off'/" /var/www/21_LNKS_05_NextCloud/.user.ini

und passen die Nextcloud-Apps als user www-data an

sudo -u www-data php /var/www/21_LNKS_05_NextCloud/occ app:disable survey_client

sudo -u www-data php /var/www/21_LNKS_05_NextCloud/occ app:disable firstrunwizard

sudo -u www-data php /var/www/21_LNKS_05_NextCloud/occ app:enable admin_audit

sudo -u www-data php /var/www/21_LNKS_05_NextCloud/occ app:enable files_pdfviewer

Nextcloud ist ab sofort voll einsatzfähig, optimiert und abgesichert. Starten Sie alle relevanten Services neu:

service nginx stop
service php7.4-fpm stop
service mysql restart
service php7.4-fpm restart
service redis-server restart
service nginx restart

Richten Sie einen Cronjob für Nextcloud als „www-data“ – Benutzer ein:

crontab -u www-data -e

Fügen Sie diese Zeile ein

*/5 * * * * php -f /var/www/21_LNKS_05_NextCloud/cron.php > /dev/null 2>&1

Speichern und schließen Sie dann die Datei und konfigurieren Sie den Nextcloud-Job von „Ajax“ zu „Cron“ mittels der Nextclouds CLI um:

sudo -u www-data php /var/www/21_LNKS_05_NextCloud/occ background:cron

PHPOffice - PDF-Werkzeuge - Generierung von Dokumenten (.docx / . xlsx / . pdf)

SystemVoraussetzungen:

composer ⇒ https://www.digitalocean.com/community/tutorials/how-to-install-and-use-composer-on-ubuntu-20-04-de PHPOFfice ⇒ https://github.com/PHPOffice

pdftk - Paket poppler-utils - Paket unoconv -Paket

NextCloud - Ergänzungen - Install-Manuals - C.Rieger

https://www.c-rieger.de/

[n/a: Keine Treffer]

Ubuntu-Server-20-LTS - ArbeitsSchritte-Installation