Nextcloud Talk-/Signaling - Server v. 2.x mit Nextcloud Recording-Backend

Mit Nextcloud und dem High Performance Backend (HPB: Nextcloud Talk-App und Nextcloud Signaling-Server), können Sie Präsentationen, Desktopsharing, Videokonferenzen, Telefonate und Chats – alles mit Ihrer selbstgehosteten Nextcloud – sicher und datenschutzkonform anbieten und federiert mit anderen Anwendern anderer Cloudinstanzen kommunizieren. Zudem können Sie Ihre Meetings mittels des Nextcloud Recordingservers aufzeichnen und über die Nextcloud bereitstellen.

Zögern Sie nicht länger und zeigen Sie WhatsApp, Skype, Teams und Anderen, wie sichere Kommunikation einfach funktioniert.

Ein dedizierter Server, basierend auf Ubuntu 24.x LTS (x86_64) oder Debian 12 (x86_64) wird sowohl aus Last-, als auch aus Performancegründen benötigt.

Der Signalingserver ist über eine eigene (Sub-)Domain aus dem Internet erreichbar und sollte diese Mindestvoraussetzungen erfüllen: Ubuntu 24.x LTS o. Debian 12, 4 CPU Cores, 16GB RAM und 1GBit/s (up/down).

Auch auf schwächerer Hardware lässt sich der Signaling Server betreiben, es kann allerdings zu Einbußen bzgl. der Performance und der Konferenzteilnehmeranzahl kommen.

Letzte Aktualisierungen:

» 21. Januar 2025
– Ab sofort mit Nextcloud Recording Server

Hinweis:
Wir empfehlen aus Performance- und Kompatibilitätsgründen drei separate Server!
Also einen dedizierten Nextcloud Server, einen dedizierten Nextcloud Signaling-Server mit Recording Backend und einen dedizierten coturn-Server.

Beginnen wir nun und melden uns per SSH und als Benutzer mit sudo-Berechtigungen am System an.

sudo -s

Tragen Sie Ihre öffentliche/statische IP-Adresse und ihre Domäne in die Datei /etc/hosts ein:

nano /etc/hosts

...
127.0.1.1 ihre-signaling.domain.de ihre-recording.domain.de
...
<öffentliche IP-Adresse> ihre-signaling.domain.de ihre-recording.domain.de

Öffnen Sie den Port 80/tcp und Port 443/tcp in Ihrer UFW (Firewall),

ufw allow 80/tcp comment "LetsEncrypt"
ufw allow 443/tcp comment "Nextcloud HPB"
ufw allow 32769:65535/udp comment "Nextcloud HPB"

Für die Einrichtung der benötigten Komponenten werden unterschiedliche Keys benötigt. In Ergänzung zum coturn-Secret generieren wir noch vier weitere Keys:

Schlüssel	Befehl zum Generieren
TURN/static-auth-secret (siehe coturn-Anleitung » …`coturn-secret`)	openssl rand -hex 32
JANUS-API-KEY	openssl rand -base64 16
HASH-KEY	openssl rand -hex 16
BLOCK-KEY	openssl rand -hex 16
Nextcloud-SECRET-KEY	openssl rand -hex 16
INTERNAL-SECRET	openssl rand -hex 32
RECORDING-SECRET	openssl rand -hex 32

Wir fahren mit der Installation notwendiger Softwarereleases fort:

git
go 1.23.4
make
protobuf-compiler >= 3

cd /usr/local/src

UBUNTU 24 (x86_64):
wget http://ubuntu-master.mirror.tudos.de/ubuntu/pool/universe/libs/libsrtp2/libsrtp2-1_2.5.0-3build1_amd64.deb

DEBIAN 12 (x86_64):
wget http://ftp.de.debian.org/debian/pool/main/libs/libsrtp2/libsrtp2-1_2.6.0-1_amd64.deb

UBUNTU 24 und DEBIAN 12:
wget https://go.dev/dl/go1.23.4.linux-amd64.tar.gz
tar -xvf go1.23.4.linux-amd64.tar.gz
mv go /usr/local

Öffnen Sie die Datei

nano /root/.bashrc

und fügen Sie Folgendes am Ende ein:

[…]
export GOROOT=/usr/local/go
export GOPATH=$HOME/go
export PATH=$GOPATH/bin:$GOROOT/bin:$PATH

Schließen Sie die Datei und lesen Sie diese neu ein:

source /root/.bashrc

Fahren Sie fort:

apt install -y libnspr4 libnss3 socat
dpkg -i libsrtp2*.deb

Um den Sgnaling-Server installieren zu können müssen wir diesen selbst Kompilieren:

apt install -y git make protobuf-compiler
cd /etc/
git clone https://github.com/strukturag/nextcloud-spreed-signaling.git
cd /etc/nextcloud-spreed-signaling
make build

Nach wenigen Minuten ist der build abgeschlossen und die Konfiguration wird angepasst:

cd /etc/nextcloud-spreed-signaling
cp server.conf.in server.conf
nano server.conf

Die gesamte server.conf-Datei soll ohne die Defaultwerte wie folgt aussehen:

[http]
listen = 127.0.0.1:8080
[https]
certificate = /etc/nginx/ssl/server.crt
key = /etc/nginx/ssl/server.key
[app]
debug = false
[sessions]
hashkey = <hash-key>
blockkey = <block-key>
[clients]
internalsecret = <internal-secret>
[backend]
backends = backend1
allowall = false
secret = <nextcloud-secret-key>
timeout = 10
connectionsperhost = 8
[backend1]
url = https://ihre-nextcloud.domain.de
secret = <nextcloud-secret-key>
[nats]
url = nats://localhost:4222
[mcu]
type = janus
url = ws://127.0.0.1:8188
[turn]
apikey = <janus-api-key>
secret = <TURN/static-auth-secret>
servers = turn:ihre-coturn.domain.de:443?transport=udp,turn:ihre-coturn.domain.de:443?transport=tcp
[geoip]
[geoip-overrides]
[stats]

Speichern und verlassen Sie diese Datei. Es folgt die Janus Installation

apt install -y janus

gefolgt von der Konfiguration

nano /etc/janus/janus.jcfg

Passen Sie die Konfiguration wie folgt an:

nat: {
stun_server = ihre-coturn.domain.de"
stun_port = 443
...
full_trickle = true
...
turn_rest_api_key = "<JANUS-API-KEY>"
...

Janus wird nur lokal angesprochen und daher wie folgt konfiguriert:

nano /etc/janus/janus.transport.http.jcfg

...
interface = "lo"
...

Ebenfalls für den Websocket

nano /etc/janus/janus.transport.websockets.jcfg

...
ws_interface = "lo"
...

Um sowohl NATS als auch das Recording Backend verwenden zu können, bereiten wir das System noch für Docker-CE vor:

apt remove docker docker-engine docker.io

apt install -y apt-transport-https ca-certificates curl software-properties-common

Ubuntu:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

DEBIAN:

curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/debian $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Ubuntu und Debian:

apt update && apt install -y docker-ce

Laden Sie nun NATS und das Nextcloud Recording-Backend als Docker herunter:

docker pull nats:latest

docker run --name=NATSSERVER-NC -d -p 4222:4222 -ti --restart=always nats:latest

docker pull nextcloud/aio-talk-recording

docker run -d --name NextcloudRecording -e HPB_DOMAIN=ihre-signaling.domain.de -e NC_DOMAIN=ihre-nextcloud-domain.de -e RECORDING_SECRET=<recording-secret> -e INTERNAL_SECRET=<internal-secret> -e TZ=Europe/Berlin -p 127.0.0.1:1234:1234 --restart=always nextcloud/aio-talk-recording

Richten wir nun den Webserver ein.

curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor | sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

UBUNTU:

echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg] http://nginx.org/packages/mainline/ubuntu `lsb_release -cs` nginx" | sudo tee /etc/apt/sources.list.d/nginx.list

DEBIAN:

echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg] http://nginx.org/packages/mainline/debian `lsb_release -cs` nginx" | sudo tee /etc/apt/sources.list.d/nginx.list

UBUNTU und DEBIAN:

apt update && apt install -y ssl-cert ca-certificates nginx socat jq

systemctl enable nginx.service

openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

mv /etc/nginx/nginx.conf /etc/nginx/nginx.conf.bak && touch /etc/nginx/nginx.conf

nano /etc/nginx/nginx.conf

Kopieren Sie den gesamten nachfolgenden Inhalt in die Datei:

user www-data;
worker_processes auto;
pid /var/run/nginx.pid;
events {
  worker_connections 2048;
  multi_accept on; use epoll;
  }
http {
  log_format criegerde escape=json
  '{'
    '"time_local":"$time_local",'
    '"remote_addr":"$remote_addr",'
    '"remote_user":"$remote_user",'
    '"request":"$request",'
    '"status": "$status",'
    '"body_bytes_sent":"$body_bytes_sent",'
    '"request_time":"$request_time",'
    '"http_referrer":"$http_referer",'
    '"http_user_agent":"$http_user_agent"'
  '}';
  server_names_hash_bucket_size 64;
  access_log /var/log/nginx/access.log criegerde;
  error_log /var/log/nginx/error.log warn;
  set_real_ip_from 127.0.0.1;
  real_ip_header X-Forwarded-For;
  real_ip_recursive on;
  include /etc/nginx/mime.types;
  default_type application/octet-stream;
  sendfile on;
  send_timeout 3600;
  tcp_nopush on;
  tcp_nodelay on;
  open_file_cache max=500 inactive=10m;
  open_file_cache_errors on;
  keepalive_timeout 65;
  reset_timedout_connection on;
  server_tokens off;
  resolver 127.0.0.53 valid=30s;
  resolver_timeout 5s;
  include /etc/nginx/conf.d/*.conf;
  }

und legen notwendige Verzeichnisse an:

mkdir -p /var/www/letsencrypt/.well-known/acme-challenge /etc/letsencrypt/rsa-certs /etc/letsencrypt/ecc-certs

Erstellen Sie die notwendigen vHost-Dateien an:

[ -f /etc/nginx/conf.d/default.conf ] && mv /etc/nginx/conf.d/default.conf /etc/nginx/conf.d/default.conf.bak

touch /etc/nginx/conf.d/default.conf
touch /etc/nginx/conf.d/http.conf
touch /etc/nginx/conf.d/ihre-signaling.domain.de.conf
touch /etc/nginx/conf.d/ihre-recording.domain.de.conf

nano /etc/nginx/conf.d/http.conf

Kopieren Sie alle nachfolgenden Zeilen in die Datei http.conf und passen die rot markierten Werte entsprechend Ihres Systems an:

server {
listen 80 default_server;
listen [::]:80 default_server;
server_name ihre-signaling.domain.de ihre-recording.domain.de;
root /var/www;
location ^~ /.well-known/acme-challenge {
default_type text/plain;
root /var/www/letsencrypt;
}
location / {
return 301 https://$host$request_uri;
}
}

Wechseln Sie in die signaling-vHost-Datei:

nano /etc/nginx/conf.d/ihre-signaling.domain.de.conf

und kopieren den nachfolgenden Text in diese Datei. Passen Sie die roten Werte an.

upstream signaling {
server 127.0.0.1:8080;
}
server {
listen 443 ssl;
listen [::]:443 ssl;
http2 on;
server_name ihre-signaling.domain.de;
ssl_certificate /etc/ssl/certs/ssl-cert-snakeoil.pem;
ssl_certificate_key /etc/ssl/private/ssl-cert-snakeoil.key;
ssl_trusted_certificate /etc/ssl/certs/ssl-cert-snakeoil.pem;
#ssl_certificate /etc/letsencrypt/rsa-certs/fullchain.pem;
#ssl_certificate_key /etc/letsencrypt/rsa-certs/privkey.pem;
#ssl_certificate /etc/letsencrypt/ecc-certs/fullchain.pem;
#ssl_certificate_key /etc/letsencrypt/ecc-certs/privkey.pem;
#ssl_trusted_certificate /etc/letsencrypt/ecc-certs/chain.pem;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
ssl_session_timeout 1d;
ssl_session_cache shared:SSL:50m;
ssl_session_tickets off;
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; 
ssl_prefer_server_ciphers on;
ssl_stapling on;
ssl_stapling_verify on;
location /standalone-signaling/ {
proxy_pass http://signaling/;
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}
location /standalone-signaling/spreed {
proxy_pass http://signaling/spreed;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "Upgrade";
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}
}

Wechseln Sie in die recording-vHost-Datei:

nano /etc/nginx/conf.d/ihre-recording.domain.de.conf

und kopieren den nachfolgenden Text in diese Datei. Passen Sie die roten Werte an.

upstream recording {
server 127.0.0.1:1234;
}
server {
listen 443 ssl;
listen [::]:443 ssl;
http2 on;
server_name ihre-recording.domain.de;
ssl_certificate /etc/ssl/certs/ssl-cert-snakeoil.pem;
ssl_certificate_key /etc/ssl/private/ssl-cert-snakeoil.key;
ssl_trusted_certificate /etc/ssl/certs/ssl-cert-snakeoil.pem;
#ssl_certificate /etc/letsencrypt/rsa-certs/fullchain.pem;
#ssl_certificate_key /etc/letsencrypt/rsa-certs/privkey.pem;
#ssl_certificate /etc/letsencrypt/ecc-certs/fullchain.pem;
#ssl_certificate_key /etc/letsencrypt/ecc-certs/privkey.pem;
#ssl_trusted_certificate /etc/letsencrypt/ecc-certs/chain.pem;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
ssl_session_timeout 1d;
ssl_session_cache shared:SSL:50m;
ssl_session_tickets off;
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; 
ssl_prefer_server_ciphers on;
ssl_stapling on;
ssl_stapling_verify on;
location /standalone-signaling/ {
proxy_pass http://signaling/;
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}
location / {
proxy_pass http://recording/;
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}
}

Starten Sie den Webserver neu

systemctl restart nginx.service

Stellen Sie sicher, dass Ihr Server sowohl über Port 80/TCP als auch über Port 443/TCP von außen erreichbar ist. Das Erstellen und Aktualisieren von Let’s Encryptzertifikaten erfolgt über http und Port 80. Für das Zertifikatshandling erstellen wir nun einen dedizierten Benutzer und fügen diesen der www-data Gruppe hinzu:

adduser --disabled-login acmeuser

usermod -a -G www-data acmeuser

Diesem technischen Benutzer erteilen wir noch die notwendigen Berechtigungen, um bei einer Zertifikatserneuerung den notwendigen Webserverstart initiieren zu können.

visudo

In der Mitte der Datei, unterhalb von

[..]
User privilege specification
root ALL=(ALL:ALL) ALL
[...]

tragen Sie die folgende Zeile ein:

acmeuser ALL=NOPASSWD: /bin/systemctl reload nginx.service

Mit STRG+X gefolgt von einem y speichern und verlassen Sie diese Datei.

Wechseln Sie in die Shell des neuen Benutzers (acmeuser) um die Zertifikatssoftware zu installieren und verlassen diese Shell danach wieder:

su - acmeuser

curl https://get.acme.sh | sh

exit

Passen Sie die entsprechenden Berechtigungen an, um die neuen Zertifikate darin speichern zu können:

chmod -R 775 /var/www/letsencrypt /etc/letsencrypt && chown -R www-data:www-data /var/www/ /etc/letsencrypt

Setzen Sie Let’s Encrypt als Standard CA.

su - acmeuser -c ".acme.sh/acme.sh --set-default-ca --server letsencrypt"

Wechseln Sie erneut in die Shell des neuen Benutzers

su - acmeuser

und requestieren (beantragen) die SSL-Zertifikate. Ersetzen Sie dabei ihre.domain.de und ihre-recording.domain.de mit Ihren Domain-Namen :

acme.sh --issue -d ihresignaling.domain.de -d ihre-recording.domain.de --server letsencrypt --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 --reloadcmd "sudo /bin/systemctl reload nginx.service"

acme.sh --issue -d ihresignaling.domain.de -d ihre-recording.domain.de --server letsencrypt --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 --reloadcmd "sudo /bin/systemctl reload nginx.service"

Verlassen Sie die Shell des neuen Benutzers

exit

Entfernen Sie Ihre bisher verwendeten Self-Signed-Zertifikate aus nginx und aktivieren Sie die neuen, vollwertigen und bereits gültigen SSL Zertifikate von Let’s Encrypt. Starten Sie dann den Webserver neu:

sed -i '/ssl-cert-snakeoil/d' /etc/nginx/conf.d/ihre-signaling.domain.de.conf
sed -i s/#\ssl/\ssl/g /etc/nginx/conf.d/ihre-signaling.domain.de.conf
sed -i '/ssl-cert-snakeoil/d' /etc/nginx/conf.d/ihre-recording.domain.de.conf
sed -i s/#\ssl/\ssl/g /etc/nginx/conf.d/ihre-recording.domain.de.conf

systemctl restart nginx.service

Nun starten wir den Signaling-Server. Beginnen wir mit Janus-Service:

systemctl start janus.service

Anschließend wird die Software initial und zum Testen manuell gestartet:

cd /etc/nextcloud-spreed-signaling

./bin/signaling --config server.conf

Startet die Anwendung fehlerfrei, so beenden wir diese (STRG+c) und richten sowohl einen technischen Benutzer, als auch einen neuen Systemdienst ein:

groupadd signaling
useradd --system --gid signaling --shell /usr/sbin/nologin --comment "Standalone signaling server for Nextcloud Talk." signaling

Die Konfigurationsdatei des Servers wird persistent gesichert, um auch bei Updates nicht überschrieben zu werden. Des Weiteren werden die entsprechenden Berechtigungen gesetzt:

mkdir -p /etc/signaling
cp server.conf /etc/signaling/server.conf
chmod 600 /etc/signaling/server.conf
chown signaling: /etc/signaling/server.conf

Der Dienst wird nun wie folgt erstellt:

nano /etc/nextcloud-spreed-signaling/dist/init/systemd/signaling.service

Bitte kopieren Sie den gesamten Text hinein:

[Unit]
Description=Nextcloud Talk signaling server
After=janus.service

[Service]
ExecStart=/etc/nextcloud-spreed-signaling/bin/signaling --config /etc/signaling/server.conf
User=signaling
Group=signaling
Restart=on-failure

# Makes sure that /etc/signaling is owned by this service
ConfigurationDirectory=signaling

# Hardening - see systemd.exec(5)
CapabilityBoundingSet=
ExecPaths=/etc/nextcloud-spreed-signaling/bin/signaling /usr/lib
LockPersonality=yes
MemoryDenyWriteExecute=yes
NoExecPaths=/
NoNewPrivileges=yes
PrivateDevices=yes
PrivateTmp=yes
PrivateUsers=yes
ProcSubset=pid
ProtectClock=yes
ProtectControlGroups=yes
ProtectHome=yes
ProtectHostname=yes
ProtectKernelLogs=yes
ProtectKernelModules=yes
ProtectKernelTunables=yes
ProtectProc=invisible
ProtectSystem=strict
RemoveIPC=yes
RestrictAddressFamilies=AF_INET AF_INET6 AF_UNIX
RestrictNamespaces=yes
RestrictRealtime=yes
RestrictSUIDSGID=yes
SystemCallArchitectures=native
SystemCallFilter=@system-service
SystemCallFilter=~ @privileged

[Install]
WantedBy=multi-user.target

Abschließend wird der Dienst am Server registriert und gestartet:

cp /etc/nextcloud-spreed-signaling/dist/init/systemd/signaling.service /etc/systemd/system/signaling.service
systemctl enable signaling.service && systemctl start signaling.service

Prüfen Sie, ob das HPB wie erwartet antwortet:

https://ihre-signaling.domain.de/standalone-signaling/api/v1/welcome

Die Antwort sollte wie folgt aussehen, die Version entspricht der verwendeten Version.

Die Version (in diesem Beispiel „47ad…“) können Sie bei Nextclouds GIT abgleichen.

Wechseln Sie nun in Ihre Nextcloud-Instanz und aktivieren respektive konfigurieren als Nextcloud-Administrator die Nextcloud-Talk-App wie folgt.

Signaling-Server:

* https://ihre-signaling.domain.de/standalone-signaling/
* Nextcloud-SECRET-KEY

STUN-Server:

* ihre-coturn.domain.de:443

TURN-Server:

* turn und turns
* ihre-coturn.domain.de:443
* TURN/coturn-static-auth-secret
* UDP und TCP

Recording-Backend

* https://ihre-recording.domain.de
* Recording-Secret

Um das System aktuell zu halten können Sie dieses update-Skript nutzen. Laden Sie es herunter

cd /root

wget -O update.sh -q https://codeberg.org/criegerde/nextcloud/raw/branch/master/skripte/hpb-update.sh

und markieren es als ausführbar.

chmod +x update.sh

Melden Sie sich als Benutzer mit sudo-Berechtigungen an und starten es dann wie folgt:

sudo -s

./update.sh

Sowohl Ihr Betriebssystem, als auch Ihr HPB-System werden aktualisiert und die Dienste neu gestartet.

Herzlichen Glückwunsch! Sie haben ihre Nextcloud um einen Signaling-Server und somit um die Nextcloud- Talk Funktionalitäten erfolgreich erweitert! Über Ihre Unterstützung (diese wird ordnungsgemäß versteuert!) würden sich meine Frau, meine Zwillinge und ich sehr freuen. Vorab vielen Dank!