Ako nainštalovať CryptPad Collaborative Office Suite na Ubuntu 22.04

Na tejto stránke

1. Predpoklady
2. Krok 1 - Nakonfigurujte bránu firewall
3. Krok 2 - Nainštalujte Git
4. Krok 3 - Nainštalujte Nodejs
5. Krok 4 - Nainštalujte Bower
6. Krok 5 - Nainštalujte Cryptpad
7. Krok 6 – Nakonfigurujte Cryptpad
8. Krok 7 - Nainštalujte Nginx
9. Krok 8 - Nainštalujte SSL
10. Krok 9 - Nakonfigurujte Nginx
11. Krok 10 – Vytvorte službu Cryptpad Systemd
12. Krok 11 - Prístup a konfigurácia Cryptpad
13. Krok 12 - Aktualizujte Cryptpad
14. Záver

Cryptpad je open-source kolaboratívny kancelársky balík, ktorý je alternatívou k Office 365. Umožňuje prístup k kancelárskym aplikáciám cez webový prehliadač. Rozdiel medzi Cryptpadom a Office 365 je v tom, že Cryptpad je šifrovaný end-to-end, čo znamená, že môžete vytvárať a zdieľať dokumenty s ostatnými bez rizika úniku osobných údajov. Aplikácie ponúkané s Cryptpad zahŕňajú formátovaný text, tabuľky, kód/označenie, Kanban, snímky, tabule a formuláre.

V tomto návode sa naučíte, ako nainštalovať sadu Cryptpad na server Ubuntu 22.04.

Predpoklady

Server so systémom Ubuntu 22.04 s minimálne 2 GB pamäte RAM a 2 jadrami CPU.

Používateľ bez oprávnenia root s oprávneniami sudo.

Dva plne kvalifikované názvy domén (FQDN) ako example.com a docs.example.com.

Uistite sa, že je všetko aktualizované.

$ sudo apt update
$ sudo apt upgrade

Niekoľko balíkov, ktoré váš systém potrebuje.

$ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y

Niektoré z týchto balíkov už môžu byť vo vašom systéme nainštalované.

Krok 1 - Nakonfigurujte bránu firewall

Prvým krokom je konfigurácia brány firewall. Ubuntu sa štandardne dodáva s ufw (Nekomplikovaný firewall).

Skontrolujte, či je spustený firewall.

$ sudo ufw status

Mali by ste dostať nasledujúci výstup.

Status: inactive

Povoľte port SSH, aby firewall pri jeho povolení neprerušil aktuálne pripojenie.

$ sudo ufw allow OpenSSH

Povoliť aj porty HTTP a HTTPS.

$ sudo ufw allow http
$ sudo ufw allow https

Povoľte bránu firewall

$ sudo ufw enable
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup

Znova skontrolujte stav brány firewall.

$ sudo ufw status

Mali by ste vidieť podobný výstup.

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)

Krok 2 - Nainštalujte Git

Git je zvyčajne predinštalovaný s Ubuntu 22.04, ale v prípade, že nie je nainštalovaný, nainštalujte ho spustením nasledujúceho príkazu.

$ sudo apt install git -y

Skontrolujte verziu Git.

$ git --version
git version 2.34.1

Spustením nasledujúcich príkazov nakonfigurujte Git tak, aby k nemu pridal vaše meno a e-mailovú adresu.

git config --global user.name "Your Name"
git config --global user.email "[email "

Krok 3 - Nainštalujte Nodejs

Na inštaláciu Nodejs použijeme Node Version Manager (NVM). Nainštalujte skript NVM pomocou nasledujúceho príkazu.

$ curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.3/install.sh | bash

Najnovšiu verziu NVM môžete získať z jeho úložiska GitHub.

Ak ho chcete použiť, potrebujete zdrojový kód súboru .bashrc.

$ source ~/.bashrc

Skontrolujte zoznam dostupných verzií uzla.

$ nvm list-remote

Získate podobný výstup.

.....
        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

Nainštalujte najnovšiu verziu LTS (v18.x alebo) Node v čase písania tohto návodu.

$ nvm install lts/hydrogen

Overte inštaláciu.

$ node -v
v18.14.1

Krok 4 - Nainštalujte Bower

Bower je správca balíkov pre frontendové komponenty, ktoré používa Cryptpad. Nainštalujte ho pomocou nasledujúceho príkazu.

$ npm install -g bower

Krok 5 - Nainštalujte Cryptpad

Naklonujte úložisko Cryptpad GitHub.

$ git clone https://github.com/xwiki-labs/cryptpad.git cryptpad

Prepnite sa do adresára.

$ cd cryptpad

Prepnite úložisko na najnovšiu verziu.

$ git checkout $(git tag -l | grep -v 'v1.*$' | sort -V | tail -n 1)

Nainštalujte Cryptpad pomocou nasledujúcich príkazov.

$ npm install
$ bower install

Vytvorte statické stránky Cryptpad a povoľte ukážky odkazov na sociálne médiá pomocou nasledujúceho príkazu.

$ npm run build

Krok 6 - Nakonfigurujte Cryptpad

Vytvorte konfiguračný súbor pomocou poskytnutého vzorového súboru.

$ cp /home/$USER/cryptpad/config/config.example.js /home/$USER/cryptpad/config/config.js

Otvorte konfiguračný súbor na úpravu.

$ nano ~/cryptpad/config/config.js

Nájdite riadok httpUnsafeOrigin: 'http://localhost:3000' a zmeňte jeho hodnotu na svoju hlavnú doménu.

httpUnsafeOrigin: 'https://example.com',

Nájdite riadok // httpSafeOrigin: "https://some-other-domain.xyz" a odkomentujte ho odstránením lomiek pred ním a zmeňte jeho hodnotu na svoju subdoménu.

httpSafeOrigin: "https://docs.example.com",

Pridajte nasledujúci riadok priamo pod premennú httpSafeOrigin.

httpSafeOrigin: "https://docs.example.com",
    adminEmail: "[email ",

Uložte súbor stlačením Ctrl + X a po zobrazení výzvy zadajte Y.

Pre ďalšiu konfiguráciu vytvorte kópiu ~/cryptpad/customize.dist/application_config.js v adresári ~/cryptpad/customize.

$ cp ~/cryptpad/customize.dist/application_config.js ~/cryptpad/customize

Na úpravu otvorte súbor ~/cryptpad/customize/application_config.js.

$ nano ~/cryptpad/customize/application_config.js

Nezabudnite pridať všetky konfigurácie pred riadok return AppConfig;.

Ak chcete zakázať neregistrované používanie Cryptpadu, pridajte nasledujúci riadok.

AppConfig.registeredOnlyTypes = AppConfig.availablePadTypes;

Pridajte odkazy na stránky Zásady ochrany osobných údajov, Podmienky poskytovania služby a Impresum.

// 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/';

Pridajte soľ hesla na zabezpečenie Cryptpadu.

AppConfig.loginSalt = 'ggkljerthhkletho0the90hoserhtgse90rh4ohzisdofh90-43kbdf9009io';

Ak chcete zvýšiť minimálnu dĺžku hesla, pridajte nasledujúci riadok.

AppConfig.minimumPasswordLength = 10;

Uložte súbor stlačením Ctrl + X a po zobrazení výzvy zadajte Y. Pred spustením Cryptpadu musíme najprv nainštalovať Nginx, vytvoriť SSL certifikát a nakonfigurovať server Nginx, aby pripravil domény Cryptpadu na prístup.

Krok 7 - Nainštalujte Nginx

Ubuntu 22.04 sa dodáva so staršou verziou Nginx. Ak chcete nainštalovať najnovšiu verziu, musíte si stiahnuť oficiálne úložisko Nginx.

Importujte podpisový kľúč Nginx.

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

Pridajte úložisko pre stabilnú verziu Nginx.

$ 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

Aktualizujte systémové úložiská.

$ sudo apt update

Nainštalujte Nginx.

$ sudo apt install nginx

Overte inštaláciu.

$ nginx -v
nginx version: nginx/1.22.1

Spustite server Nginx.

$ sudo systemctl start nginx

Krok 8 - Nainštalujte SSL

Na vygenerovanie certifikátu SSL musíme nainštalovať Certbot. Certbot môžete nainštalovať pomocou úložiska Ubuntu alebo získať najnovšiu verziu pomocou nástroja Snapd. Budeme používať verziu Snapd.

Ubuntu 22.04 sa štandardne dodáva s nainštalovaným Snapd. Spustite nasledujúce príkazy, aby ste sa uistili, že vaša verzia Snapd je aktuálna. Uistite sa, že vaša verzia aplikácie Snapd je aktuálna.

$ sudo snap install core
$ sudo snap refresh core

Nainštalujte Certbot.

$ sudo snap install --classic certbot

Pomocou nasledujúceho príkazu zaistite spustenie príkazu Certbot vytvorením symbolického odkazu na adresár /usr/bin.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Spustite nasledujúci príkaz na vygenerovanie certifikátu SSL.

$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email  -d example.com -d docs.example.com

Vyššie uvedený príkaz stiahne certifikát do adresára /etc/letsencrypt/live/example.com na vašom serveri pre domény example.com a docs. example.com.

Vygenerujte certifikát Diffie-Hellman group.

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

Ak chcete skontrolovať, či obnovenie SSL funguje správne, vykonajte proces nasucho.

$ sudo certbot renew --dry-run

Ak nevidíte žiadne chyby, všetko je nastavené. Váš certifikát sa automaticky obnoví.

Krok 9 - Nakonfigurujte Nginx

Otvorte súbor /etc/nginx/nginx.conf na úpravu.

$ sudo nano /etc/nginx/nginx.conf

Pridajte nasledujúci riadok pred riadok include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Uložte súbor stlačením Ctrl + X a po zobrazení výzvy zadajte Y.

Vytvorte a otvorte súbor /etc/nginx/conf.d/cryptpad.conf na úpravu.

$ sudo nano /etc/nginx/conf.d/cryptpad.conf

Vložte do nej nasledujúci kód.

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;
}

Uložte súbor stlačením Ctrl + X a po zobrazení výzvy zadajte Y.

Overte syntax konfiguračného súboru Nginx.

$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Reštartujte službu Nginx.

$ sudo systemctl restart nginx

Krok 10 – Vytvorte službu Cryptpad Systemd

Na úpravu otvorte súbor ~/cryptpad/docs/cryptpad.service.

$ nano ~/cryptpad/docs/cryptpad.service

Upravte kód v ňom tak, aby sa podobal nasledujúcemu. Zaistite správnu cestu k binárnemu uzlu a nahraďte používateľské meno svojím aktuálne prihláseným používateľským menom v systéme Linux.

[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

Uložte súbor stlačením Ctrl + X a po zobrazení výzvy zadajte Y.

Skopírujte súbor do priečinka Systemd.

sudo cp ~/cryptpad/docs/cryptpad.service /etc/systemd/system/cryptpad.service

Znovu načítajte servisného démona.

$ sudo systemctl daemon-reload

Povoľte a spustite službu Cryptpad.

$ sudo systemctl enable cryptpad --now

Skontrolujte stav služby.

$ suddo systemctl status cryptpad

Dostanete nasledujúci výstup.

? 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.

Krok 11 - Prístup a konfigurácia Cryptpad

Otvorte adresu URL https://example.com vo svojom prehliadači a zobrazí sa nasledujúca obrazovka.

Kliknutím na tlačidlo Zaregistrovať sa si vytvorte účet. Zadajte svoje poverenia a kliknutím na tlačidlo Zaregistrovať sa si vytvorte účet.

Zobrazí sa nasledujúce vyskakovacie okno s potvrdením. Kliknutím na červené tlačidlo dokončite vytváranie účtu.

Budete prihlásení a dostanete sa na ovládací panel CryptDrive.

Kliknite na ponuku Používateľ v pravom hornom rohu a kliknite na možnosť Nastavenia.

Dostanete nasledujúcu stránku nastavení.

Skopírujte hodnotu Verejného podpisového kľúča a vráťte sa do terminálu a otvorte konfiguračný súbor.

$ nano ~/cryptpad/config/config.js

Nájdite premennú adminKeys a vložte kľúč medzi hranaté zátvorky, ako je znázornené nižšie.

adminKeys: ["[[email /ygDc+0uabbCk6WqJYiIDO2B+gP6mYZ9FlQ94zL3UAoU=]"],

Uložte súbor stlačením Ctrl + X a po zobrazení výzvy zadajte Y.

Reštartujte službu Cryptpad.

$ sudo systemctl restart cryptpad

Váš kancelársky balík Cryptpad je pripravený na použitie.

Krok 12 - Aktualizujte Cryptpad

Aktualizácia Cryptpadu je pomerne jednoduchšia a zahŕňa načítanie najnovších aktualizácií z úložiska GitHub a následné spustenie príkazov na aktualizáciu uzla.

Prvým krokom je zastavenie služby Cryptpad.

$ sudo systemctl stop cryptpad

Ak chcete aktualizovať Cryptpad, spustite nasledujúce príkazy.

$ cd ~/cryptpad
$ git pull
$ git checkout $(git tag -l | grep -v 'v1.*$' | sort -V | tail -n 1)
$ npm update
$ bower update

Spustite službu Cryptpad.

$ sudo systemctl start cryptpad

Záver

Týmto sa končí náš návod na inštaláciu balíka Cryptpad Collaborative Office Suite na server Ubuntu 22.04. Ak máte nejaké otázky, napíšte ich do komentárov nižšie.