So installierst du die CryptPad Collaborative Office Suite auf Ubuntu 22.04
Cryptpad ist eine Open-Source-Office-Suite für die Zusammenarbeit, die eine Alternative zu Office 365 ist. Sie ermöglicht dir den Zugriff auf Büroanwendungen über den Webbrowser. Der Unterschied zwischen Cryptpad und Office 365 besteht darin, dass Cryptpad Ende-zu-Ende-verschlüsselt ist, was bedeutet, dass du Dokumente erstellen und mit anderen teilen kannst, ohne dass das Risiko besteht, dass persönliche Daten nach außen dringen. Zu den mit Cryptpad angebotenen Anwendungen gehören Rich Text, Tabellenkalkulationen, Code/Markdown, Kanban, Folien, Whiteboards und Formulare.
In diesem Tutorial erfährst du, wie du die Cryptpad Suite auf einem Ubuntu 22.04 Server installierst.
Voraussetzungen
- Ein Server mit Ubuntu 22.04 mit mindestens 2 GB RAM und 2 CPU-Kernen.
- Ein Nicht-Root-Benutzer mit sudo-Rechten.
- Zwei voll qualifizierte Domainnamen (FQDN) wie
example.comunddocs.example.com. - Stelle sicher, dass alles auf dem neuesten Stand ist.
$ sudo apt update $ sudo apt upgrade
- Einige wenige Pakete, die dein System benötigt.
$ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y
Einige dieser Pakete sind vielleicht schon auf deinem System installiert.
Schritt 1 – Firewall konfigurieren
Der erste Schritt besteht darin, die Firewall zu konfigurieren. Ubuntu wird standardmäßig mit ufw (Uncomplicated Firewall) ausgeliefert.
Überprüfe, ob die Firewall läuft.
$ sudo ufw status
Du solltest die folgende Ausgabe erhalten.
Status: inactive
Erlaube den SSH-Port, damit die Firewall die aktuelle Verbindung nicht unterbricht, wenn du sie aktivierst.
$ sudo ufw allow OpenSSH
Lasse auch HTTP- und HTTPS-Ports zu.
$ sudo ufw allow http $ sudo ufw allow https
Aktiviere die Firewall
$ sudo ufw enable Command may disrupt existing ssh connections. Proceed with operation (y|n)? y Firewall is active and enabled on system startup
Überprüfe den Status der Firewall erneut.
$ sudo ufw status
Du solltest eine ähnliche Ausgabe sehen.
Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere 80/tcp ALLOW Anywhere 443 ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6) 80/tcp (v6) ALLOW Anywhere (v6) 443 (v6) ALLOW Anywhere (v6)
Schritt 2 – Git installieren
Git ist bei Ubuntu 22.04 normalerweise vorinstalliert. Falls es aber nicht installiert ist, kannst du es mit dem folgenden Befehl installieren.
$ sudo apt install git -y
Überprüfe die Version von Git.
$ git --version git version 2.34.1
Führe die folgenden Befehle aus, um Git so zu konfigurieren, dass dein Name und deine E-Mail-Adresse hinzugefügt werden.
git config --global user.name "Your Name" git config --global user.email "youremail@domain.com"
Schritt 3 – Nodejs installieren
Wir werden den Node Version Manager (NVM) verwenden, um Nodejs zu installieren. Installiere das NVM-Skript mit dem folgenden Befehl.
$ curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.3/install.sh | bash
Die neueste Version von NVM findest du im GitHub Repository.
Um ihn zu benutzen, musst du deine .bashrc Datei als Quelle angeben.
$ source ~/.bashrc
Überprüfe die Liste der verfügbaren Node-Versionen.
$ nvm list-remote
Du wirst eine ähnliche Ausgabe erhalten.
.....
v18.9.0
v18.9.1
v18.10.0
v18.11.0
v18.12.0 (LTS: Hydrogen)
v18.12.1 (LTS: Hydrogen)
v18.13.0 (LTS: Hydrogen)
v18.14.0 (LTS: Hydrogen)
-> v18.14.1 (Latest LTS: Hydrogen)
v19.0.0
v19.0.1
v19.1.0
v19.2.0
v19.3.0
v19.4.0
v19.5.0
v19.6.0
v19.6.1
Installiere die neueste LTS-Version (v18.x oder) von Node zum Zeitpunkt der Erstellung dieses Tutorials.
$ nvm install lts/hydrogen
Überprüfe die Installation.
$ node -v v18.14.1
Schritt 4 – Installiere Bower
Bower ist ein Paketmanager für die von Cryptpad verwendeten Frontend-Komponenten. Installiere ihn mit dem folgenden Befehl.
$ npm install -g bower
Schritt 5 – Cryptpad installieren
Klone das Cryptpad GitHub Repository.
$ git clone https://github.com/xwiki-labs/cryptpad.git cryptpad
Wechsle in das Verzeichnis.
$ cd cryptpad
Wechsle das Repository auf die neueste Version.
$ git checkout $(git tag -l | grep -v 'v1.*$' | sort -V | tail -n 1)
Installiere Cryptpad mit den folgenden Befehlen.
$ npm install $ bower install
Erstelle die statischen Seiten von Cryptpad und aktiviere die Vorschau der Social Media Links mit dem folgenden Befehl.
$ npm run build
Schritt 6 – Cryptpad konfigurieren
Erstelle die Konfigurationsdatei anhand der mitgelieferten Beispieldatei.
$ cp /home/$USER/cryptpad/config/config.example.js /home/$USER/cryptpad/config/config.js
Öffne die Konfigurationsdatei zum Bearbeiten.
$ nano ~/cryptpad/config/config.js
Suche die Zeile httpUnsafeOrigin: 'http://localhost:3000', und ändere ihren Wert in deine Hauptdomain.
httpUnsafeOrigin: 'https://example.com',
Finde die Zeile // httpSafeOrigin: "https://some-other-domain.xyz",, entferne die Schrägstriche davor und ändere den Wert in deine Subdomain.
httpSafeOrigin: "https://docs.example.com",
Füge die folgende Zeile direkt unter der Variable httpSafeOrigin ein.
httpSafeOrigin: "https://docs.example.com",
adminEmail: "nama@example.com",
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Zur weiteren Konfiguration erstellst du eine Kopie der Datei ~/cryptpad/customize.dist/application_config.js im Verzeichnis ~/cryptpad/customize.
$ cp ~/cryptpad/customize.dist/application_config.js ~/cryptpad/customize
Öffne die Datei ~/cryptpad/customize/application_config.js, um sie zu bearbeiten.
$ nano ~/cryptpad/customize/application_config.js
Achte darauf, dass du alle Konfigurationen vor der Zeile return AppConfig; einfügst.
Um die unregistrierte Nutzung von Cryptpad zu deaktivieren, füge die folgende Zeile hinzu.
AppConfig.registeredOnlyTypes = AppConfig.availablePadTypes;
Füge Links zu den Seiten Datenschutzbestimmungen, Nutzungsbedingungen und Impressum hinzu.
// Privacy Policy AppConfig.privacy = 'https://example.com/privacy-policy/'; // Terms of Service AppConfig.terms = 'https://example.com/terms-of-service/'; // Imprint / Legal Notice AppConfig.imprint = 'https://example.com/imprint/';
Füge ein Passwortsalz hinzu, um Cryptpad zu sichern.
AppConfig.loginSalt = 'ggkljerthhkletho0the90hoserhtgse90rh4ohzisdofh90-43kbdf9009io';
Um die Mindestlänge des Passworts zu erhöhen, füge die folgende Zeile hinzu.
AppConfig.minimumPasswordLength = 10;
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst. Bevor wir Cryptpad starten, müssen wir zunächst Nginx installieren, ein SSL-Zertifikat erstellen und den Nginx-Server so konfigurieren, dass die Cryptpad-Domänen für den Zugriff vorbereitet sind.
Schritt 7 – Nginx installieren
Ubuntu 22.04 wird mit einer älteren Version von Nginx ausgeliefert. Um die neueste Version zu installieren, musst du das offizielle Nginx-Repository herunterladen.
Importiere den Signierschlüssel von Nginx.
$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \ | sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null
Füge das Repository für die stabile Version von Nginx hinzu.
$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg arch=amd64] \
http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list
Aktualisiere die System-Repositories.
$ sudo apt update
Installiere Nginx.
$ sudo apt install nginx
Überprüfe die Installation.
$ nginx -v nginx version: nginx/1.22.1
Starte den Nginx-Server.
$ sudo systemctl start nginx
Schritt 8 – SSL installieren
Wir müssen Certbot installieren, um das SSL-Zertifikat zu erstellen. Du kannst Certbot entweder über das Repository von Ubuntu installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.
Bei Ubuntu 22.04 ist Snapd standardmäßig installiert. Führe die folgenden Befehle aus, um sicherzustellen, dass deine Version von Snapd auf dem neuesten Stand ist. Vergewissere dich, dass deine Version von Snapd auf dem neuesten Stand ist.
$ sudo snap install core $ sudo snap refresh core
Installiere Certbot.
$ sudo snap install --classic certbot
Verwende den folgenden Befehl, um sicherzustellen, dass der Certbot-Befehl ausgeführt wird, indem du einen symbolischen Link zum Verzeichnis /usr/bin erstellst.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Führe den folgenden Befehl aus, um ein SSL-Zertifikat zu erzeugen.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d example.com -d docs.example.com
Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/example.com auf deinem Server für die Domains example.com und docs.example.com heruntergeladen.
Erstelle ein Diffie-Hellman-Gruppenzertifikat.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Um zu überprüfen, ob die SSL-Erneuerung einwandfrei funktioniert, führe einen Probelauf des Prozesses durch.
$ sudo certbot renew --dry-run
Wenn du keine Fehler siehst, ist alles in Ordnung. Dein Zertifikat wird automatisch erneuert.
Schritt 9 – Nginx konfigurieren
Öffne die Datei /etc/nginx/nginx.conf zum Bearbeiten.
$ sudo nano /etc/nginx/nginx.conf
Füge die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; ein.
server_names_hash_bucket_size 64;
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Erstelle und öffne die Datei /etc/nginx/conf.d/cryptpad.conf zum Bearbeiten.
$ sudo nano /etc/nginx/conf.d/cryptpad.conf
Füge den folgenden Code in die Datei ein.
server {
# Redirect any http requests to https
listen 80;
listen [::]:80;
server_name example.com docs.example.com;
return 301 https://$host$request_uri;
}
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
# CryptPad serves static assets over these two domains.
# `main_domain` is what users will enter in their address bar.
# Privileged computation such as key management is handled in this scope
# UI content is loaded via the `sandbox_domain`.
# "Content Security Policy" headers prevent content loaded via the sandbox
# from accessing privileged information.
# These variables must be different to take advantage of CryptPad's sandboxing techniques.
# In the event of an XSS vulnerability in CryptPad's front-end code
# this will limit the amount of information accessible to attackers.
set $main_domain "example.com";
set $sandbox_domain "docs.example.com";
# By default CryptPad allows remote domains to embed CryptPad documents in iframes.
# This behaviour can be blocked by changing $allowed_origins from "*" to the
# sandbox domain, which must be permitted to load content from the main domain
# in order for CryptPad to work as expected.
#
# An example is given below which can be uncommented if you want to block
# remote sites from including content from your server
set $allowed_origins "*";
# set $allowed_origins "https://${sandbox_domain}";
# CryptPad's dynamic content (websocket traffic and encrypted blobs)
# can be served over separate domains. Using dedicated domains (or subdomains)
# for these purposes allows you to move them to a separate machine at a later date
# if you find that a single machine cannot handle all of your users.
# If you don't use dedicated domains, this can be the same as $main_domain
# If you do, they can be added as exceptions to any rules which block connections to remote domains.
# You can find these variables referenced below in the relevant places
set $api_domain "example.com";
set $files_domain "example.com";
# nginx doesn't let you set server_name via variables, so you need to hardcode your domains here
server_name example.com docs.example.com;
# You'll need to Set the path to your certificates and keys here
# IMPORTANT: this config is intended to serve assets for at least two domains
# (your main domain and your sandbox domain). As such, you'll need to generate a single SSL certificate
# that includes both domains in order for things to work as expected.
ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/example.com/chain.pem;
# diffie-hellman parameters are used to negotiate keys for your session
# generate strong parameters using the following command
ssl_dhparam /etc/ssl/certs/dhparam.pem;
# Speeds things up a little bit when resuming a session
ssl_session_timeout 1d;
ssl_session_cache shared:MozSSL:10m;
ssl_session_tickets off;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
ssl_prefer_server_ciphers off;
# HSTS (ngx_http_headers_module is required) (63072000 seconds)
add_header Strict-Transport-Security "max-age=63072000; includeSubDomains" always;
# OCSP stapling
ssl_stapling on;
ssl_stapling_verify on;
resolver 8.8.8.8 8.8.4.4 valid=300s;
resolver_timeout 5s;
# verify chain of trust of OCSP response using Root CA and Intermediate certs
ssl_trusted_certificate /etc/ssl/certs/ca-certificates.crt;
# replace with the IP address of your resolver
resolver 8.8.8.8 8.8.4.4 1.1.1.1 1.0.0.1 9.9.9.9 149.112.112.112 208.67.222.222 208.67.220.220;
add_header X-XSS-Protection "1; mode=block";
add_header X-Content-Type-Options nosniff;
add_header Access-Control-Allow-Origin "${allowed_origins}";
# add_header X-Frame-Options "SAMEORIGIN";
# Opt out of Google's FLoC Network
add_header Permissions-Policy interest-cohort=();
# Enable SharedArrayBuffer in Firefox (for .xlsx export)
add_header Cross-Origin-Resource-Policy cross-origin;
add_header Cross-Origin-Embedder-Policy require-corp;
# Insert the path to your CryptPad repository root here
root /home/username/cryptpad;
index index.html;
error_page 404 /customize.dist/404.html;
# any static assets loaded with "ver=" in their URL will be cached for a year
if ($args ~ ver=) {
set $cacheControl max-age=31536000;
}
# This rule overrides the above caching directive and makes things somewhat less efficient.
# We had inverted them as an optimization, but Safari 16 introduced a bug that interpreted
# some important headers incorrectly when loading these files from cache.
# This is why we can't have nice things :(
if ($uri ~ ^(\/|.*\/|.*\.html)$) {
set $cacheControl no-cache;
}
# Will not set any header if it is emptystring
add_header Cache-Control $cacheControl;
# CSS can be dynamically set inline, loaded from the same domain, or from $main_domain
set $styleSrc "'unsafe-inline' 'self' https://${main_domain}";
# connect-src restricts URLs which can be loaded using script interfaces
# if you have configured your instance to use a dedicated $files_domain or $api_domain
# you will need to add them below as: https://${files_domain} and https://${api_domain}
set $connectSrc "'self' https://${main_domain} blob: wss://${api_domain} https://${sandbox_domain}";
# fonts can be loaded from data-URLs or the main domain
set $fontSrc "'self' data: https://${main_domain}";
# images can be loaded from anywhere, though we'd like to deprecate this as it allows the use of images for tracking
set $imgSrc "'self' data: blob: https://${main_domain}";
# frame-src specifies valid sources for nested browsing contexts.
# this prevents loading any iframes from anywhere other than the sandbox domain
set $frameSrc "'self' https://${sandbox_domain} blob:";
# specifies valid sources for loading media using video or audio
set $mediaSrc "blob:";
# defines valid sources for webworkers and nested browser contexts
# deprecated in favour of worker-src and frame-src
set $childSrc "https://${main_domain}";
# specifies valid sources for Worker, SharedWorker, or ServiceWorker scripts.
# supercedes child-src but is unfortunately not yet universally supported.
set $workerSrc "'self'";
# script-src specifies valid sources for javascript, including inline handlers
set $scriptSrc "'self' resource: https://${main_domain}";
# frame-ancestors specifies which origins can embed your CryptPad instance
# this must include 'self' and your main domain (over HTTPS) in order for CryptPad to work
# if you have enabled remote embedding via the admin panel then this must be more permissive.
# note: cryptpad.fr permits web pages served via https: and vector: (element desktop app)
set $frameAncestors "'self' https://${main_domain}";
# set $frameAncestors "'self' https: vector:";
set $unsafe 0;
# the following assets are loaded via the sandbox domain
# they unfortunately still require exceptions to the sandboxing to work correctly.
if ($uri ~ ^\/(sheet|doc|presentation)\/inner.html.*$) { set $unsafe 1; }
if ($uri ~ ^\/common\/onlyoffice\/.*\/.*\.html.*$) { set $unsafe 1; }
# everything except the sandbox domain is a privileged scope, as they might be used to handle keys
if ($host != $sandbox_domain) { set $unsafe 0; }
# this iframe is an exception. Office file formats are converted outside of the sandboxed scope
# because of bugs in Chromium-based browsers that incorrectly ignore headers that are supposed to enable
# the use of some modern APIs that we require when javascript is run in a cross-origin context.
# We've applied other sandboxing techniques to mitigate the risk of running WebAssembly in this privileged scope
if ($uri ~ ^\/unsafeiframe\/inner\.html.*$) { set $unsafe 1; }
# privileged contexts allow a few more rights than unprivileged contexts, though limits are still applied
if ($unsafe) {
set $scriptSrc "'self' 'unsafe-eval' 'unsafe-inline' resource: https://${main_domain}";
}
# Finally, set all the rules you composed above.
add_header Content-Security-Policy "default-src 'none'; child-src $childSrc; worker-src $workerSrc; media-src $mediaSrc; style-src $styleSrc; script-src $scriptSrc; connect-src $connectSrc; font-src $fontSrc; img-src $imgSrc; frame-src $frameSrc; frame-ancestors $frameAncestors";
# The nodejs process can handle all traffic whether accessed over websocket or as static assets
# We prefer to serve static content from nginx directly and to leave the API server to handle
# the dynamic content that only it can manage. This is primarily an optimization
location ^~ /cryptpad_websocket {
proxy_pass http://localhost:3000;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
# WebSocket support (nginx 1.4)
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection upgrade;
}
location ^~ /customize.dist/ {
# This is needed in order to prevent infinite recursion between /customize/ and the root
}
# try to load customizeable content via /customize/ and fall back to the default content
# located at /customize.dist/
# This is what allows you to override behaviour.
location ^~ /customize/ {
rewrite ^/customize/(.*)$ $1 break;
try_files /customize/$uri /customize.dist/$uri;
}
# /api/config is loaded once per page load and is used to retrieve
# the caching variable which is applied to every other resource
# which is loaded during that session.
location ~ ^/api/.*$ {
proxy_pass http://localhost:3000;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
# These settings prevent both NGINX and the API server
# from setting the same headers and creating duplicates
proxy_hide_header Cross-Origin-Resource-Policy;
add_header Cross-Origin-Resource-Policy cross-origin;
proxy_hide_header Cross-Origin-Embedder-Policy;
add_header Cross-Origin-Embedder-Policy require-corp;
}
# encrypted blobs are immutable and are thus cached for a year
location ^~ /blob/ {
if ($request_method = 'OPTIONS') {
add_header 'Access-Control-Allow-Origin' "${allowed_origins}";
add_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS';
add_header 'Access-Control-Allow-Headers' 'DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Content-Range,Range';
add_header 'Access-Control-Max-Age' 1728000;
add_header 'Content-Type' 'application/octet-stream; charset=utf-8';
add_header 'Content-Length' 0;
return 204;
}
add_header X-Content-Type-Options nosniff;
add_header Cache-Control max-age=31536000;
add_header 'Access-Control-Allow-Origin' "${allowed_origins}";
add_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS';
add_header 'Access-Control-Allow-Headers' 'DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Content-Range,Range,Content-Length';
add_header 'Access-Control-Expose-Headers' 'DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Content-Range,Range,Content-Length';
try_files $uri =404;
}
# the "block-store" serves encrypted payloads containing users' drive keys
# these payloads are unlocked via login credentials. They are mutable
# and are thus never cached. They're small enough that it doesn't matter, in any case.
location ^~ /block/ {
add_header X-Content-Type-Options nosniff;
add_header Cache-Control max-age=0;
try_files $uri =404;
}
# This block provides an alternative means of loading content
# otherwise only served via websocket. This is solely for debugging purposes,
# and is thus not allowed by default.
#location ^~ /datastore/ {
#add_header Cache-Control max-age=0;
#try_files $uri =404;
#}
# The nodejs server has some built-in forwarding rules to prevent
# URLs like /pad from resulting in a 404. This simply adds a trailing slash
# to a variety of applications.
location ~ ^/(register|login|settings|user|pad|drive|poll|slide|code|whiteboard|file|media|profile|contacts|todo|filepicker|debug|kanban|sheet|support|admin|notifications|teams|calendar|presentation|doc|form|report|convert|checkup)$ {
rewrite ^(.*)$ $1/ redirect;
}
# Finally, serve anything the above exceptions don't govern.
try_files /customize/www/$uri /customize/www/$uri/index.html /www/$uri /www/$uri/index.html /customize/$uri;
}
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Überprüfe die Syntax der Nginx-Konfigurationsdatei.
$ sudo nginx -t nginx: the configuration file /etc/nginx/nginx.conf syntax is ok nginx: configuration file /etc/nginx/nginx.conf test is successful
Starte den Nginx-Dienst neu.
$ sudo systemctl restart nginx
Schritt 10 – Erstellen eines Cryptpad Systemd-Dienstes
Öffne die Datei ~/cryptpad/docs/cryptpad.service zum Bearbeiten.
$ nano ~/cryptpad/docs/cryptpad.service
Ändere den Code darin so ab, dass er wie folgt aussieht. Achte auf den korrekten Pfad für die Node-Binärdatei und ersetze username durch deinen aktuell eingeloggten Linux-Benutzernamen.
[Unit] Description=CryptPad API server [Service] ExecStart=/home/username/.nvm/versions/node/v18.14.1/bin/node /home/username/cryptpad/server.js # modify to match the location of your cryptpad repository WorkingDirectory=/home/username/cryptpad Restart=always # Restart service after 10 seconds if node service crashes RestartSec=2 # Output to syslog StandardOutput=syslog StandardError=syslog SyslogIdentifier=cryptpad User=username Group=username # modify to match your working directory Environment='PWD="/home/username/cryptpad"' # systemd sets the open file limit to 4000 unless you override it # cryptpad stores its data with the filesystem, so you should increase this to match the value of `ulimit -n` # or risk EMFILE errors. LimitNOFILE=1000000 [Install] WantedBy=multi-user.target
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Kopiere die Datei in den Systemd-Ordner.
sudo cp ~/cryptpad/docs/cryptpad.service /etc/systemd/system/cryptpad.service
Starte den Service Daemon neu.
$ sudo systemctl daemon-reload
Aktiviere und starte den Cryptpad-Dienst.
$ sudo systemctl enable cryptpad --now
Überprüfe den Status des Dienstes.
$ suddo systemctl status cryptpad
Du wirst die folgende Ausgabe erhalten.
? cryptpad.service - CryptPad API server
Loaded: loaded (/etc/systemd/system/cryptpad.service; enabled; vendor preset: enabled)
Active: active (running) since Tue 2023-02-21 08:43:50 UTC; 1h 52min ago
Main PID: 8145 (node)
Tasks: 33 (limit: 2237)
Memory: 53.4M
CPU: 2.323s
CGroup: /system.slice/cryptpad.service
??8145 /home/navjot/.nvm/versions/node/v18.14.1/bin/node /home/navjot/cryptpad/server.js
??8158 /home/navjot/.nvm/versions/node/v18.14.1/bin/node lib/workers/db-worker
??8159 /home/navjot/.nvm/versions/node/v18.14.1/bin/node lib/workers/db-worker
Feb 21 08:43:50 nspeaks systemd[1]: Started CryptPad API server.
Feb 21 08:43:50 nspeaks cryptpad[8145]: Serving content for https://example.com/ via http://127.0.0.1:3000.
Schritt 11 – Cryptpad aufrufen und konfigurieren
Öffne die URL https://example.com in deinem Browser und du erhältst den folgenden Bildschirm.
Klicke auf die Schaltfläche “ Anmelden“, um ein Konto zu erstellen. Gib deine Anmeldedaten ein und klicke auf die Schaltfläche Anmelden, um dein Konto zu erstellen.
Du erhältst das folgende Bestätigungs-Pop-up. Klicke auf die rote Schaltfläche, um die Erstellung des Kontos abzuschließen.
Du bist nun eingeloggt und gelangst zum CryptDrive Dashboard.
Klicke auf das Benutzermenü in der oberen rechten Ecke und klicke auf die Option Einstellungen.
Du erhältst die folgende Einstellungsseite.
Kopiere den Wert des Public Signing Key, gehe zurück zum Terminal und öffne die Konfigurationsdatei.
$ nano ~/cryptpad/config/config.js
Suche die Variable adminKeys und füge den Schlüssel zwischen den eckigen Klammern ein, wie unten gezeigt.
adminKeys: ["[navjot@example.com/ygDc+0uabbCk6WqJYiIDO2B+gP6mYZ9FlQ94zL3UAoU=]"],
Speichere die Datei, indem du die Tastenkombination Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Starte den Cryptpad-Dienst neu.
$ sudo systemctl restart cryptpad
Dein Cryptpad-Büroprogramm ist jetzt einsatzbereit.
Schritt 12 – Cryptpad aktualisieren
Die Aktualisierung von Cryptpad ist ganz einfach: Du holst dir die neuesten Updates aus dem GitHub-Repository und führst dann die Node-Update-Befehle aus.
Der erste Schritt besteht darin, den Cryptpad-Dienst zu stoppen.
$ sudo systemctl stop cryptpad
Führe die folgenden Befehle aus, um Cryptpad zu aktualisieren.
$ cd ~/cryptpad $ git pull $ git checkout $(git tag -l | grep -v 'v1.*$' | sort -V | tail -n 1) $ npm update $ bower update
Starte den Cryptpad-Dienst.
$ sudo systemctl start cryptpad
Fazit
Damit ist unsere Anleitung zur Installation der Cryptpad Collaborative Office Suite auf einem Ubuntu 22.04 Server abgeschlossen. Wenn du noch Fragen hast, schreibe sie in die Kommentare unten.