NC with Compose

1. Install

1.1 Create a project

Create a directory:

mkdir -p /var/compose/nc3
cd /var/compose/nc3/

Download the config file compose.yaml:

wget https://linux-cli.fs.al/apps/part3/compose.yaml

compose.yaml

services:
  db:
    image: postgres:alpine
    restart: unless-stopped
    volumes:
      - ./db:/var/lib/postgresql/data
    env_file: db.env
    environment:
      - POSTGRES_DB=${DB_NAME:-nc3db}
      - POSTGRES_USER=${DB_USER:-nc3user}
      - POSTGRES_PASSWORD=${DB_PASS:-nc3pass}

  redis:
    image: redis:alpine
    restart: unless-stopped

  app:
    image: nextcloud:fpm-alpine
    restart: unless-stopped
    volumes:
      - ./www:/var/www/html
    env_file: db.env
    environment:
      - POSTGRES_HOST=db
      - POSTGRES_DB=${DB_NAME:-nc3db}
      - POSTGRES_USER=${DB_USER:-nc3user}
      - POSTGRES_PASSWORD=${DB_PASS:-nc3pass}
      - REDIS_HOST=redis
    depends_on:
      - db
      - redis

  nginx:
    image: nginx:alpine
    restart: unless-stopped
    ports:
        - 127.0.0.1:8088:80
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./www:/var/www/html
    depends_on:
      - app

Download nginx.conf:

wget https://linux-cli.fs.al/apps/part3/nginx.conf

nginx.conf

worker_processes auto;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;


events {
    worker_connections  1024;
}


http {
    upstream php-handler {
        server app:9000;
    }

    include mime.types;
    default_type  application/octet-stream;
    types {
        text/javascript mjs;
        #application/wasm wasm;
    }

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    # Prevent nginx HTTP Server Detection
    server_tokens   off;

    keepalive_timeout  65;

    # Set the `immutable` cache control options only for assets with a cache busting `v` argument
    map $arg_v $asset_immutable {
        "" "";
    default ", immutable";
    }

    #gzip  on;

    server {
        listen 80;

        # HSTS settings
        # WARNING: Only add the preload option once you read about
        # the consequences in https://hstspreload.org/. This option
        # will add the domain to a hardcoded list that is shipped
        # in all major browsers and getting removed from this list
        # could take several months.
        #add_header Strict-Transport-Security "max-age=15768000; includeSubDomains; preload;" always;

        # set max upload size and increase upload timeout:
        client_max_body_size 512M;
        client_body_timeout 300s;
        fastcgi_buffers 64 4K;

        # The settings allows you to optimize the HTTP2 bandwidth.
        # See https://blog.cloudflare.com/delivering-http-2-upload-speed-improvements/
        # for tuning hints
        client_body_buffer_size 512k;

        # Enable gzip but do not remove ETag headers
        gzip on;
        gzip_vary on;
        gzip_comp_level 4;
        gzip_min_length 256;
        gzip_proxied expired no-cache no-store private no_last_modified no_etag auth;
        gzip_types application/atom+xml text/javascript application/javascript application/json application/ld+json application/manifest+json application/rss+xml application/vnd.geo+json application/vnd.ms-fontobject application/wasm application/x-font-ttf application/x-web-app-manifest+json application/xhtml+xml application/xml font/opentype image/bmp image/svg+xml image/x-icon text/cache-manifest text/css text/plain text/vcard text/vnd.rim.location.xloc text/vtt text/x-component text/x-cross-domain-policy;

        # Pagespeed is not supported by Nextcloud, so if your server is built
        # with the `ngx_pagespeed` module, uncomment this line to disable it.
        #pagespeed off;

        # HTTP response headers borrowed from Nextcloud `.htaccess`
        add_header Referrer-Policy                      "no-referrer"       always;
        add_header X-Content-Type-Options               "nosniff"           always;
        add_header X-Frame-Options                      "SAMEORIGIN"        always;
        add_header X-Permitted-Cross-Domain-Policies    "none"              always;
        add_header X-Robots-Tag                         "noindex, nofollow" always;
        add_header X-XSS-Protection                     "1; mode=block"     always;

        # Remove X-Powered-By, which is an information leak
        fastcgi_hide_header X-Powered-By;

        # Path to the root of your installation
        root /var/www/html;

        # Specify how to handle directories -- specifying `/index.php$request_uri`
        # here as the fallback means that Nginx always exhibits the desired behaviour
        # when a client requests a path that corresponds to a directory that exists
        # on the server. In particular, if that directory contains an index.php file,
        # that file is correctly served; if it doesn't, then the request is passed to
        # the front-end controller. This consistent behaviour means that we don't need
        # to specify custom rules for certain paths (e.g. images and other assets,
        # `/updater`, `/ocm-provider`, `/ocs-provider`), and thus
        # `try_files $uri $uri/ /index.php$request_uri`
        # always provides the desired behaviour.
        index index.php index.html /index.php$request_uri;

        # Rule borrowed from `.htaccess` to handle Microsoft DAV clients
        location = / {
            if ( $http_user_agent ~ ^DavClnt ) {
                return 302 /remote.php/webdav/$is_args$args;
            }
        }

        location = /robots.txt {
            allow all;
            log_not_found off;
            access_log off;
        }

        # Make a regex exception for `/.well-known` so that clients can still
        # access it despite the existence of the regex rule
        # `location ~ /(\.|autotest|...)` which would otherwise handle requests
        # for `/.well-known`.
        location ^~ /.well-known {
            # The rules in this block are an adaptation of the rules
            # in `.htaccess` that concern `/.well-known`.

            location = /.well-known/carddav { return 301 /remote.php/dav/; }
            location = /.well-known/caldav  { return 301 /remote.php/dav/; }

            location /.well-known/acme-challenge    { try_files $uri $uri/ =404; }
            location /.well-known/pki-validation    { try_files $uri $uri/ =404; }

            # Let Nextcloud's API for `/.well-known` URIs handle all other
            # requests by passing them to the front-end controller.
            return 301 /index.php$request_uri;
        }

        # Rules borrowed from `.htaccess` to hide certain paths from clients
        location ~ ^/(?:build|tests|config|lib|3rdparty|templates|data)(?:$|/)  { return 404; }
        location ~ ^/(?:\.|autotest|occ|issue|indie|db_|console)                { return 404; }

        # Ensure this block, which passes PHP files to the PHP process, is above the blocks
        # which handle static assets (as seen below). If this block is not declared first,
        # then Nginx will encounter an infinite rewriting loop when it prepends `/index.php`
        # to the URI, resulting in a HTTP 500 error response.
        location ~ \.php(?:$|/) {
            # Required for legacy support
            rewrite ^/(?!index|remote|public|cron|core\/ajax\/update|status|ocs\/v[12]|updater\/.+|ocs-provider\/.+|.+\/richdocumentscode(_arm64)?\/proxy) /index.php$request_uri;

            fastcgi_split_path_info ^(.+?\.php)(/.*)$;
            set $path_info $fastcgi_path_info;

            try_files $fastcgi_script_name =404;

            include fastcgi_params;
            fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
            fastcgi_param PATH_INFO $path_info;
            fastcgi_param HTTPS on;

            fastcgi_param modHeadersAvailable true;         # Avoid sending the security headers twice
            fastcgi_param front_controller_active true;     # Enable pretty urls
            fastcgi_pass php-handler;

            fastcgi_intercept_errors on;
            fastcgi_request_buffering off;

            fastcgi_max_temp_file_size 0;
        }

        # Serve static files
        location ~ \.(?:css|js|mjs|svg|gif|ico|jpg|png|webp|wasm|tflite|map|ogg|flac)$ {
            try_files $uri /index.php$request_uri;
            add_header Cache-Control "public, max-age=15778463$asset_immutable";
            add_header Referrer-Policy                   "no-referrer"       always;
            add_header X-Content-Type-Options            "nosniff"           always;
            add_header X-Frame-Options                   "SAMEORIGIN"        always;
            add_header X-Permitted-Cross-Domain-Policies "none"              always;
            add_header X-Robots-Tag                      "noindex, nofollow" always;
            add_header X-XSS-Protection                  "1; mode=block"     always;
            access_log off;     # Optional: Don't log access to assets

            location ~ \.wasm$ {
                default_type application/wasm;
            }
        }

        location ~ \.(otf|woff2?)$ {
            try_files $uri /index.php$request_uri;
            expires 7d;         # Cache-Control policy borrowed from `.htaccess`
            access_log off;     # Optional: Don't log access to assets
        }

        # Rule borrowed from `.htaccess`
        location /remote {
            return 301 /remote.php$request_uri;
        }

        location / {
            try_files $uri $uri/ /index.php$request_uri;
        }
    }
}

Create the config file db.env:

cat << _EOF_ > db.env
DB_NAME=nc3db
DB_USER=nc3user
DB_PASS=nc3pass
_EOF_

Start the project:

docker compose up -d

ls
ls db/
ls www/

docker compose ls
docker compose ps

1.2 Setup reverse proxy

Create a site configuration on nginx:

cd /etc/nginx/sites-available/
cp nc2 nc3
sed -i nc3 -e 's/nc2/nc3/g'
nano nc3

Make sure to use the correct port on proxy_pass:

proxy_pass http://127.0.0.1:8088;

Enable it:

cd ../sites-enabled/
ls ../sites-available/nc3
ln -s ../sites-available/nc3 .
ls -l

Get an SSL certificate:

certbot certonly --webroot -w /var/www \
    -d nc3.user1.fs.al \
    -m dashohoxha@gmail.com --agree-tos

certbot certificates

Reload nginx:
```
nginx -t
systemctl reload nginx
```

1.3 Installation wizard

Open in browser https://nc3.user1.fs.al and complete the installation.

2. Improve

4.1 Setup cron

To run cron jobs, create the script cron.sh:

cat << '_EOF_' > /var/compose/nc3/cron.sh
#!/bin/bash
docker compose \
    --project-directory /var/compose/nc3 \
    exec -u www-data app \
    php cron.php
_EOF_

Try it:

nano cron.sh
chmod +x cron.sh
./cron.sh

Then edit crontab with crontab -e and append this line:

*/5 * * * * /var/compose/nc3/cron.sh

4.2 Use `occ`

Try to run php occ as user www-data, inside the container of the service app:
```
docker compose exec -u www-data app php occ
```

Let's create the script occ.sh for running this command:

cat << '_EOF_' > occ.sh
#!/bin/bash
docker compose \
    --project-directory /var/compose/nc3 \
    exec -u www-data app \
    php occ "$@"
_EOF_

nano occ.sh
chmod +x occ.sh
./occ.sh

Create a script that fixes some configuration problems:

cat << '_EOF_' > config.sh
#!/bin/bash -x
./occ.sh config:system:set overwriteprotocol --value=https
./occ.sh config:system:set default_phone_region --value=AL
./occ.sh config:system:set maintenance_window_start --value=1 --type=integer
./occ.sh maintenance:repair --include-expensive
./occ.sh db:add-missing-indices
_EOF_

nano config.sh
chmod +x config.sh
./config.sh

2.3 Enable HSTS

Edit nginx.conf and uncomment the line add_header Strict-Transport-Security:
```
cd /var/compose/nc3/
nano nginx.conf
```
Restart the service nginx:
```
docker compose restart nginx
```

3. Maintenance

3.1 Backup

Create a backup script:

cat << '_EOF_' > ~/nc3-backup.sh
#!/bin/bash -x

occ="
  docker compose
      --project-directory /var/compose/nc3/
      exec -u www-data app
      php occ
"

$occ maintenance:mode --on
tar cfz ~/nc3-$(date +%Y%m%d).tgz -C /var/compose/ nc3/
$occ maintenance:mode --off
_EOF_

Make a backup:

cd
nano nc3-backup.sh
chmod +x nc3-backup.sh
./nc3-backup.sh
ls -lh
tar tvfz nc3-20250210.tgz | less

3.2 Restore

Remove NC3:

cd /var/compose/nc3/
docker compose down
cd ..
rm -rf nc3
ls

Restore from the backup:

ls ~/nc3-*.tgz
tar xfz /root/nc3-20250210.tgz -C /var/compose/
ls /var/compose/
cd /var/compose/nc3/
ls
docker compose up -d
./occ.sh maintenance:mode --off

3.3 Update

Create a script:

cat << '_EOF_' > update.sh
#!/bin/bash -x
cd /var/compose/nc3/

# update docker images
docker compose pull
docker compose up -d

# update nextcloud
docker compose stop nginx
./occ.sh upgrade
./occ.sh app:update --all
./occ.sh db:add-missing-indices
./occ.sh db:convert-filecache-bigint
docker compose start nginx
_EOF_

Update:

nano update.sh
chmod +x update.sh
./update.sh

4. More

4.1 Misc

Docker monitoring and clean up:

docker compose stats
docker stats

docker image prune
docker system prune

More tutorials about docker compose:

4.2 Use Postgres `16`

If we check the overview of the admin settings, (https://nc3.user1.fs.al/settings/admin/overview) we will notice that it is reporting that PostgreSQL <= 16 is suggested for the latest version of NextCloud, while we have used the latest PostgreSQL version (17). Let's try to fix this.

From the page https://hub.docker.com/_/postgres we can figure out that we want to use the image postgres:16-alpine, instead of postgres:alpine.

First correction attempt:

docker compose down
sed -i compose.yaml \
    -e 's/postgres:alpine/postgres:16-alpine/'
head compose.yaml
docker compose up db

We will notice error messages because the data files on the directory db/ have been created by Postgres 17, and are not compatible with Postgres 16:

db-1  | PostgreSQL Database directory appears to contain a database;
        Skipping initialization
db-1  | 
db-1  | FATAL:  database files are incompatible with server
db-1  | DETAIL:  The data directory was initialized by PostgreSQL version 17,
                 which is not compatible with this version 16.7.
db-1 exited with code 1

Stop it with Ctrl+c.

Switch back to the previous version of Postgres and make a dump of the database:

sed -i compose.yaml \
    -e 's/postgres:16-alpine/postgres:alpine/'
head compose.yaml
docker compose up db -d
docker compose logs db -f

alias pg_dump='docker compose exec -u postgres db pg_dump'
alias pg_dump
pg_dump --clean -d nc3db > nc3db.sql

alias pg_dump='docker compose exec -u postgres db pg_dump -U nc3user'
alias pg_dump
pg_dump --clean -d nc3db > nc3db.sql

ls -lh nc3db.sql
nano nc3db.sql

Erase the current database and install NextCloud again, from scratch, based on the image postgres:16-alpine:
```
docker compose down db
rm -rf db/

sed -i compose.yaml \
    -e 's/postgres:alpine/postgres:16-alpine/'
head compose.yaml

mv www www.bak
docker compose up -d
```
Open https://nc3.user1.fs.al and finish the installation.

Run also the script config.sh.
```
./config.sh
```

Restore the database from the backup nc3db.sql:

alias psql='docker compose exec -u postgres db psql -U nc3user'
alias psql
cat nc3db.sql | psql -d nc3db

alias psql='docker compose exec -T -u postgres db psql -U nc3user'
alias psql
cat nc3db.sql | psql -d nc3db

Restore also the data from www.bak:

docker compose stop
mv www/data www/data.bak
cp -a www.bak/data www/
docker compose start

Check again https://nc3.user1.fs.al/settings/admin/overview

If everything is fine, then cleanup the backups:
```
rm -rf db.bak/ www.bak/
rm -rf www/data.bak/
rm nc3db.sql
```

1. Install​

1.1 Create a project​

1.2 Setup reverse proxy​

1.3 Installation wizard​

2. Improve​

4.1 Setup cron​

4.2 Use occ​

2.3 Enable HSTS​

3. Maintenance​

3.1 Backup​

3.2 Restore​

3.3 Update​

4. More​

4.1 Misc​

4.2 Use Postgres 16​