Kör en FerretDB-databasserver med Podman utan root

Det här sätter du upp

FerretDB är en databas som talar MongoDB:s protokoll, så appar, drivrutiner och verktyg som är gjorda för MongoDB, som mongosh och mongodump, fungerar med den. Under ytan sparar den dokumenten i PostgreSQL, via tillägget DocumentDB. Den här guiden sätter upp den som din egen databasserver: inloggningar för dig och din app, TLS för varje anslutning, inställningar anpassade efter servern, åtkomst bara från servern själv och via WireGuard, och nattliga säkerhetskopior.

FerretDB utvecklas av FerretDB Inc. och är öppen källkod under licensen Apache 2.0. Tillägget DocumentDB, som Microsoft startade, är öppen källkod under MIT-licensen. MongoDB är ett varumärke som tillhör MongoDB, Inc. FerretDB är inte MongoDB och gör inte allt som MongoDB gör. Steg 9 listar det vi saknade. Behöver din app de funktionerna använder du MongoDB självt.

FerretDB:s senaste version är 2.7.0, från november 2025. När vi tittade på projektets GitHub-sida den 14 oktober 2026 hade huvudgrenen bara fått uppdaterade beroenden sedan dess, senast i februari 2026, så projektet verkar stilla. Kolla sidan efter nya versioner innan du bygger på det.

Som standard skickar FerretDB anonym användningsstatistik till beacon.ferretdb.com, med början en timme efter att den har startat, och letar efter nya versioner. Steg 4 stänger av båda.

Här körs FerretDB som en pod under en egen användare som heter ferretdb, från avbilderna som FerretDB ger ut: en med PostgreSQL 17 och DocumentDB, och en med FerretDB själv. Den ligger inte bakom Caddy: en databas är ingen webbplats, och bara dina appar ska nå den.

Varje steg nedan har körts på en nyinstallerad Melonslab VC-P Alloy (2 vCPU, 8 GB) med Debian 13:

• FerretDB 2.7.0 startade med PostgreSQL 17.6 och DocumentDB 0.107.0, och tog bara emot anslutningar med TLS och lösenord. En klient utan TLS, en klient som inte litade på certifikatet och ett fel lösenord nekades.
• En testapp på en annan maskin i WireGuard-nätet anslöt till 10.8.0.1 med Python och skrev och läste dokument. Från internet fick porten inget svar.
• 100 000 dokument lästes in, och aggregeringar, joins, textsökning, geografiska frågor och flera sorters index fungerade. Steg 9 listar det som inte gjorde det.
• En nattlig säkerhetskopia återställdes två gånger: dumpen med mongorestore till en ny databas, och kopian av PostgreSQL till en tom volym. Båda kom tillbaka kompletta, med sina index.
• En uppdatering från FerretDB 2.5.0 till 2.7.0, med stegen i steg 11, gick igenom i en separat testpod. Serverns certifikat förnyades, och allt startade igen av sig självt efter en omstart av servern.

Efter en omstart använde hela servern 570 MB minne, och 800 MB efter frågor mot de 100 000 dokumenten. FerretDB själv använde omkring 10 MB. PostgreSQL:s cache tar mer allteftersom den fylls med din data, upp till de 2 GB som ställs in i steg 4.

Innan du börjar

Du behöver:

• en server uppsatt som i Podman-guiden, med ufw påslaget som i säkerhetsguiden;
• WireGuard på servern med tunneladressen 10.8.0.1, och varje appserver tillagd som en enhet, som i Lägg till fler enheter. På en appserver skickar AllowedIPs = 10.8.0.1/32 bara databasens trafik genom tunneln.

Körs din app på en annan server hos Melonslab läser du först Anslut två servrar: två servrar i samma nät kan inte nå varandra direkt. Ingen DNS-post behövs: apparna ansluter till tunneladressen.

Exemplen använder 203.0.113.10 för databasserverns publika adress, 10.8.0.2 för appservern i tunneln, och appdb och appuser för appens databas och inloggning. Byt ut dem mot dina egna genomgående.

1. Skapa användaren

Som root:

useradd -m -s /bin/bash ferretdb
loginctl enable-linger ferretdb
machinectl shell ferretdb@

Allt fram till steg 6 körs som ferretdb.

2. Skapa ett certifikat

Apparna kontrollerar med ett certifikat att de pratar med din databas. En publik certifikatutfärdare som Let's Encrypt utfärdar bara certifikat för publika namn, och apparna når databasen på en privat adress. Därför gör du en egen liten certifikatutfärdare och ger dess certifikat till dina appar:

mkdir -p ~/tls && cd ~/tls
umask 077
openssl req -x509 -newkey ec -pkeyopt ec_paramgen_curve:P-256 -noenc -days 3650 -subj "/CN=FerretDB CA" -keyout ca.key -out ca.crt
openssl req -new -newkey ec -pkeyopt ec_paramgen_curve:P-256 -noenc -subj /CN=ferretdb -keyout server.key -out server.csr
echo "subjectAltName=DNS:localhost,IP:127.0.0.1,IP:10.8.0.1" > server.ext
openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key -days 825 -extfile server.ext -out server.crt
chmod 644 ca.crt
cd

• ca.crt är certifikatutfärdarens eget certifikat. Det är inte hemligt: dina appar får en kopia.
• ca.key signerar certifikat som dina appar kommer att lita på. Förvara den säkert. Du kan också flytta den från servern och ta tillbaka den när serverns certifikat ska förnyas.
• server.crt och server.key är databasens certifikat, giltigt för localhost, 127.0.0.1 och tunneladressen 10.8.0.1 i 825 dagar. Steg 11 visar hur du förnyar det.

3. Skapa hemligheterna

openssl rand -hex 24 | tr -d '\n' | podman secret create ferretdb-pg-password -
podman secret create ferretdb-tls-cert ~/tls/server.crt
podman secret create ferretdb-tls-key ~/tls/server.key

Den första är lösenordet för postgres, PostgreSQL:s superanvändare. Du behöver aldrig skriva in det. De två andra ger FerretDB dess certifikat och nyckel. Podman lagrar dem, inte filerna nedan.

4. Definiera podden

mkdir -p ~/.config/containers/systemd ~/initdb

När databasen skapas gör PostgreSQL en roll som FerretDB arbetar som. Skapa ~/initdb/30-ferretdb-role.sh:

# Runs once, when the database is created: the PostgreSQL role FerretDB works as
psql -v ON_ERROR_STOP=1 -U postgres -d postgres -c "CREATE ROLE ferretdb LOGIN IN ROLE documentdb_admin_role"

chmod 644 ~/initdb/30-ferretdb-role.sh
cd ~/.config/containers/systemd

Skapa ferretdb.pod:

[Pod]
PodName=ferretdb
# Room for PostgreSQL's parallel queries (the default is 64 MB)
ShmSize=256m
# Reachable on this server and over WireGuard only, never on the public address
PublishPort=127.0.0.1:27017:27017
PublishPort=10.8.0.1:27017:27017

[Install]
WantedBy=default.target

Skapa ferretdb-pg.container:

[Container]
ContainerName=ferretdb-pg
Image=ghcr.io/ferretdb/postgres-documentdb:17-0.107.0-ferretdb-2.7.0
Pod=ferretdb.pod
Volume=ferretdb-pg:/var/lib/postgresql/data
Volume=%h/initdb/30-ferretdb-role.sh:/docker-entrypoint-initdb.d/30-ferretdb-role.sh:ro
Environment=POSTGRES_USER=postgres POSTGRES_DB=postgres POSTGRES_PASSWORD_FILE=/run/secrets/ferretdb-pg-password
Secret=ferretdb-pg-password
# Sized for 2 vCPU and 8 GB of memory
Exec=postgres -c shared_buffers=2GB -c effective_cache_size=6GB -c work_mem=16MB -c maintenance_work_mem=512MB -c random_page_cost=1.1
HealthCmd=pg_isready -h 127.0.0.1 -U postgres
HealthInterval=10s
Notify=healthy

[Service]
Restart=always
TimeoutStartSec=300

Och ferretdb.container:

[Unit]
Requires=ferretdb-pg.service
After=ferretdb-pg.service

[Container]
ContainerName=ferretdb
Image=ghcr.io/ferretdb/ferretdb:2.7.0
Pod=ferretdb.pod
Environment=FERRETDB_POSTGRESQL_URL=postgres://ferretdb@127.0.0.1:5432/postgres
# TLS only: no listener without encryption
Environment=FERRETDB_LISTEN_ADDR=- FERRETDB_LISTEN_TLS=:27017
Environment=FERRETDB_LISTEN_TLS_CERT_FILE=/run/secrets/ferretdb-tls-cert FERRETDB_LISTEN_TLS_KEY_FILE=/run/secrets/ferretdb-tls-key
Environment=FERRETDB_TELEMETRY=disable
Secret=ferretdb-tls-cert,uid=1000
Secret=ferretdb-tls-key,uid=1000

[Service]
Restart=always

Vad inställningarna gör:

• Båda containrarna delar poddens nätverk, så FerretDB når PostgreSQL på 127.0.0.1:5432 inne i podden. PostgreSQL:s port publiceras inte, så ingenting utanför podden kan nå den.
• Inne i podden släpper PostgreSQL in lokala anslutningar utan lösenord, som avbilden ställer in det. DocumentDB behöver det: den öppnar anslutningar till sig själv för sina bakgrundsjobb och för vissa frågor. När vi krävde lösenord där misslyckades textsökning, reguljära uttryck och flera aggregeringar med fe_sendauth: no password supplied.
• FerretDB arbetar i PostgreSQL som rollen ferretdb, som kan läsa och skriva dokument men inte är superanvändare. Inloggningarna i steg 5 avgör bara vem som får ansluta. Det som görs sedan görs som ferretdb.
• FERRETDB_LISTEN_ADDR=- stänger av lyssnaren utan kryptering, och FERRETDB_LISTEN_TLS lägger TLS-lyssnaren på port 27017, den port som MongoDB-klienter väntar sig.
• FERRETDB_TELEMETRY=disable stänger av användningsstatistiken och versionskontrollen.
• uid=1000 låter FerretDB, som körs som användare 1000 i sin container, läsa sitt certifikat och sin nyckel.
• Avbildernas taggar är låsta, eftersom en uppdatering kräver ett steg för hand (steg 11).

Raden Exec anpassar PostgreSQL efter 8 GB minne, som i PostgreSQL-guiden:

• shared_buffers är PostgreSQL:s egen cache. En fjärdedel av minnet är den vanliga utgångspunkten, eftersom resten används av systemets filcache, som PostgreSQL också läser via.
• effective_cache_size reserverar ingenting. Den talar om för planeraren hur stor del av datan som troligen finns i minnet, filcachen inräknad.
• work_mem är vad en sortering eller join får använda innan den skriver till disk. En komplicerad fråga kan använda den flera gånger om, så håll den måttlig.
• maintenance_work_mem snabbar upp VACUUM och när index byggs.
• random_page_cost = 1.1 talar om för planeraren att slumpvisa läsningar är billiga på SSD-lagring.
• ShmSize i podden ger PostgreSQL 256 MB delat minne för parallella frågor, i stället för Podmans 64 MB.

Starta den:

systemctl --user daemon-reload
systemctl --user start ferretdb-pod

Första starten laddar ner omkring 1,8 GB avbilder, och PostgreSQL tar en stund på sig att skapa sin databas. Den är klar när det här skriver ut active:

systemctl --user is-active ferretdb

5. Skapa inloggningarna

FerretDB har inga egna användare: en inloggning är en roll i PostgreSQL med ett lösenord. Gör en åt dig själv, admin, och en åt appen, med lösenorden som hemligheter:

for u in admin appuser; do
  openssl rand -hex 24 | tr -d '\n' | podman secret create ferretdb-$u-password -
  printf "CREATE ROLE %s LOGIN PASSWORD '%s';\n" $u "$(podman secret inspect --showsecret --format '{{.SecretData}}' ferretdb-$u-password)" | podman exec -i ferretdb-pg psql -U postgres
done

Båda skriver ut CREATE ROLE. Lösenorden går till psql på dess indata, så de syns inte i listan över processer. För att se ett, till exempel för att ge det till appen:

podman secret inspect --showsecret --format '{{.SecretData}}' ferretdb-appuser-password

Vad en inloggning får göra. FerretDB 2.7 har inga roller eller behörigheter: när den väl är inloggad kan varje inloggning läsa och skriva i varje databas. Vi kontrollerade: appuser kunde läsa och ändra en annan apps databas, och rollerna du ger createUser, som read, ignorerades. De två inloggningarna skiljer sig alltså bara åt i lösenordet: appens kan bytas eller tas bort utan att du låser ute dig själv. Får två appar inte se varandras data ger du var och en en egen FerretDB, med egen användare, pod och port.

Inloggningar skapas med psql, som ovan. createUser i mongosh misslyckas med permission denied to create role, eftersom FerretDB arbetar som ferretdb, som inte får skapa roller. Det är meningen: när FerretDB arbetade som superanvändaren postgres, som i FerretDB:s egna exempel, blev varje användare som skapades med createUser superanvändare i PostgreSQL.

Använd mongosh. Avbilden mongo har mongosh, mongodump och mongorestore. mongosh skickar användningsstatistik till MongoDB som standard, och en liten inställningsfil stänger av det. Skapa den, och ett alias som kör mongosh i podden:

printf 'mongosh:\n  forceDisableTelemetry: true\n' > ~/mongosh.conf
chmod 644 ~/mongosh.conf
echo "alias mongosh='podman run --rm -it --pod ferretdb -v ~/tls/ca.crt:/ca.crt:ro -v ~/mongosh.conf:/etc/mongosh.conf:ro docker.io/library/mongo:9.0 mongosh'" >> ~/.bashrc
source ~/.bashrc
mongosh "mongodb://admin@localhost:27017/?tls=true&tlsCAFile=/ca.crt"

Första gången laddas avbilden mongo ner, omkring 1,1 GB. mongosh frågar efter lösenordet och varnar för att This server or service appears to be an emulation of MongoDB, vilket stämmer. exit tar dig ut.

6. Släpp in dina appservrar

Gå tillbaka till root med exit. Podden lyssnar på tunneladressen 10.8.0.1, som bara finns när WireGuard är igång. Startar podden först vid uppstart misslyckas den med Cannot assign requested address. Låt program lyssna på en adress innan den finns:

echo "net.ipv4.ip_nonlocal_bind = 1" > /etc/sysctl.d/60-nonlocal-bind.conf
sysctl --system

Öppna sedan port 27017 bara i tunneln:

ufw allow in on wg0 to any port 27017 proto tcp
ss -tlnp | grep 27017

LISTEN 0      128         10.8.0.1:27017      0.0.0.0:*    users:(("pasta.avx2",pid=1170,fd=7))
LISTEN 0      128        127.0.0.1:27017      0.0.0.0:*    users:(("pasta.avx2",pid=1170,fd=6))

Bara tunneladressen och 127.0.0.1: ingenting lyssnar på den publika adressen. Vi stoppade WireGuard och startade om podden: utan inställningen misslyckades den, med den startade podden och tog emot anslutningar så fort WireGuard var tillbaka.

7. Kontrollera vad andra ser

Från en dator som inte är med i tunneln provar du den publika adressen:

nc -vz -w 10 203.0.113.10 27017

nc: connect to 203.0.113.10 port 27017 (tcp) timed out: Operation now in progress

Ingenting lyssnar där, och ufw kastar försöket utan att svara. Där FerretDB lyssnar tar den bara emot TLS och lösenord. Vi provade med mongosh på servern utan TLS, utan certifikatutfärdaren och med fel lösenord:

MongoServerSelectionError: connection <monitor> to 127.0.0.1:27017 closed
MongoNetworkError: unable to get local issuer certificate
MongoServerError: Authentication failed.

Från appservern fick PyMongo utan TLS connection closed på samma sätt.

8. Anslut från en app

Kopiera ~/tls/ca.crt från databasservern till appservern, här till /opt/notes/ca.crt. Appens anslutningssträng är:

mongodb://appuser:PASSWORD@10.8.0.1:27017/appdb?tls=true&tlsCAFile=/opt/notes/ca.crt

appdb på slutet är databasen som appen använder som standard. FerretDB skapar den första gången appen skriver till den. Lösenorden från steg 5 är hexadecimala. Ett eget lösenord med tecken som @, : eller / måste procentkodas i strängen.

Ett exempel i Python, med PyMongo, MongoDB:s egen drivrutin för Python. På appservern, med Debian 13:

apt install -y python3-pymongo

Skapa /opt/notes/notes.py:

import datetime
import os

from pymongo import MongoClient

client = MongoClient(os.environ["MONGODB_URI"])
notes = client.get_default_database().notes

notes.insert_one({"text": "Hello from the app", "at": datetime.datetime.now(datetime.UTC)})
for note in notes.find().sort("at", -1).limit(3):
    print(note["text"])
print(notes.count_documents({}), "notes in total")

MONGODB_URI='mongodb://appuser:PASSWORD@10.8.0.1:27017/appdb?tls=true&tlsCAFile=/opt/notes/ca.crt' python3 /opt/notes/notes.py

Hello from the app
1 notes in total

Samma kod körs oförändrad mot MongoDB. Det är bara anslutningssträngen som skiljer. I en riktig app förvarar du strängen bland appens egna hemligheter, inte i koden.

9. Det här gör inte FerretDB

Vi körde samma tester mot FerretDB 2.7.0 och MongoDB 9.0. De här gav samma resultat på båda: att lägga in och ändra dokument, findOneAndUpdate, bulkWrite, att skapa unika, sammansatta, partiella, wildcard-, text-, TTL- och 2dsphere-index, sökning med $text, reguljära uttryck, och aggregeringsstegen $group, $lookup (även med en pipeline), $unwind, $facet, $bucket, $graphLookup, $setWindowFields, $unionWith, $sample, $densify, $out och $merge.

De här fungerade inte i FerretDB:

• Transaktioner godtogs men gjorde ingenting: ett dokument som skrevs i en transaktion syntes för andra före commit, och fanns kvar efter abortTransaction.
• Change streams (watch()) misslyckades med Stage $changeStream is not supported yet.
• Roller och behörigheter: varje inloggning kan göra allt (steg 5).
• Vyer skapades, men gav inga dokument.
• Collation: en sökning utan hänsyn till versaler med collation({locale: "sv", strength: 2}) hittade ingenting.
• Schemavalidering: en validator med $jsonSchema godtogs, men dokument som bröt mot den sparades ändå.
• Capped collections fortsatte att växa förbi sitt max, och en time series-samling blev en vanlig samling.
• Dolda index, collMod, profileraren och mapReduce misslyckades. $where misslyckades också, som det gör i MongoDB 9.0 som standard.
• Flytt från MongoDB: mongorestore av en dump från MongoDB återställde dokumenten men inte indexen (se Felsökning).

Många appar använder inget av det här. Innan du flyttar en app kör du dess egna tester mot FerretDB.

10. Säkerhetskopiera

Säkerhetskopiera på två sätt: mongodump skriver varje databas i MongoDB:s format, som du kan återställa till FerretDB eller till MongoDB, och pg_basebackup kopierar PostgreSQL:s data, inloggningarna inräknade. Som ferretdb skapar du ~/bin/ferretdb-backup:

mkdir -p ~/bin ~/.config/systemd/user

#!/bin/sh
# Dump every database with mongodump, copy PostgreSQL's data, and keep 14 days
set -e
umask 077
dir=$HOME/backup
day=$(date +%F)
mkdir -p "$dir"
podman run --rm --pod ferretdb --secret ferretdb-admin-password \
  -v "$HOME/tls/ca.crt:/ca.crt:ro" -v "$dir:/backup" \
  --entrypoint sh docker.io/library/mongo:9.0 -c '
    umask 077
    printf "password: %s\n" "$(cat /run/secrets/ferretdb-admin-password)" > /tmp/auth.yaml
    mongodump --quiet --config=/tmp/auth.yaml --gzip --archive=/backup/mongodump-'"$day"'.gz \
      --uri="mongodb://admin@localhost:27017/?tls=true&tlsCAFile=/ca.crt"'
podman exec ferretdb-pg pg_basebackup -U postgres -D - -Ft -X fetch --checkpoint=fast | gzip > "$dir/postgres-$day.tar.gz"
find "$dir" -type f -mtime +13 -delete

Lösenordet når mongodump i en fil i den tillfälliga containern, inte på dess kommandorad. Containern ärver inte skriptets umask 077, så den sätter en egen: utan den kunde alla användare på servern läsa dumpen. Kör det varje natt med en tjänst och en timer. Skapa ~/.config/systemd/user/ferretdb-backup.service:

[Unit]
Description=Back up FerretDB

[Service]
Type=oneshot
ExecStart=%h/bin/ferretdb-backup

Och ~/.config/systemd/user/ferretdb-backup.timer:

[Unit]
Description=Back up FerretDB every night

[Timer]
OnCalendar=*-*-* 02:30
Persistent=true

[Install]
WantedBy=timers.target

Slå på den, och kör den en gång direkt:

chmod 755 ~/bin/ferretdb-backup
systemctl --user daemon-reload
systemctl --user enable --now ferretdb-backup.timer
systemctl --user start ferretdb-backup.service
ls -l ~/backup

-rw------- 1 ferretdb ferretdb  2613984 Oct 14 02:01 mongodump-2026-10-14.gz
-rw------- 1 ferretdb ferretdb 11035086 Oct 14 02:01 postgres-2026-10-14.tar.gz

För våra 100 000 testdokument tog det 8 sekunder. Kopiera ~/backup från servern varje natt, till exempel med restic, och håll den privat: den innehåller all din data och inloggningarnas lösenordshashar.

Testa att återställa dumpen. Återställ en databas under ett nytt namn, bredvid den riktiga:

podman run --rm --pod ferretdb -v ~/tls/ca.crt:/ca.crt:ro -v ~/backup:/backup \
  --entrypoint mongorestore docker.io/library/mongo:9.0 \
  --uri="mongodb://admin:ADMIN_PASSWORD@localhost:27017/?tls=true&tlsCAFile=/ca.crt" \
  --gzip --archive=/backup/mongodump-2026-10-14.gz \
  --nsInclude='appdb.*' --nsFrom='appdb.*' --nsTo='appdb_restore.*'

125014 document(s) restored successfully. 0 document(s) failed to restore.

Vår appdb_restore hade samma 100 000 ordrar och 5 000 kunder som appdb, och samma index. Ta bort den med db.getSiblingDB("appdb_restore").dropDatabase() i mongosh. Administratörens lösenord står på kommandoraden här, så kör det när ingen annan är inloggad på servern.

Återställ kopian av PostgreSQL. Den lägger tillbaka hela databasservern som den var, inloggningarna inräknade, till exempel efter en misslyckad uppdatering. Till en tom volym:

systemctl --user stop ferretdb-pod
podman volume rm ferretdb-pg
podman volume create ferretdb-pg
gunzip -c ~/backup/postgres-2026-10-14.tar.gz | podman volume import ferretdb-pg -
systemctl --user start ferretdb-pod

PostgreSQL spelar upp det lilla den skrev under kopieringen, och startar. Vår hade alla 100 000 dokument, och textsökningen fungerade. Kopian fungerar bara med samma huvudversion av PostgreSQL, här 17. Dumpen fungerar med vilken som helst.

11. Uppdatera

FerretDB och DocumentDB släpps tillsammans, och varje version av FerretDB anger vilken PostgreSQL-avbild som hör till. 2.7.0 var den senaste när vi testade. Vi körde samma steg från 2.5.0 till 2.7.0 i en separat testpod. Som ferretdb tar du först en säkerhetskopia:

systemctl --user start ferretdb-backup.service

Byt taggarna i båda filerna, ferretdb-pg.container och ferretdb.container, till den nya versionen, och starta om:

systemctl --user daemon-reload
systemctl --user restart ferretdb-pod

När systemctl --user is-active ferretdb skriver ut active, som i steg 4, uppdaterar du tillägget i databasen och startar om FerretDB:

podman exec ferretdb-pg psql -U postgres -d postgres -c 'ALTER EXTENSION documentdb UPDATE;'
systemctl --user restart ferretdb

ALTER EXTENSION skriver ut ALTER EXTENSION. I vårt test läste FerretDB 2.7.0 den gamla datan redan innan. SELECT extversion FROM pg_extension WHERE extname = 'documentdb' visade 0.106-0 före och 0.107-0 efter, alla dokument fanns kvar, och nya skrivningar fungerade. Läs versionsinformationen på FerretDB:s GitHub-sida före varje uppdatering. En ny huvudversion av PostgreSQL i avbilden skulle kräva att datan flyttas med mongodump och mongorestore. Det har vi inte testat.

Avbilden mongo för verktygen uppdateras inte av sig själv. podman pull docker.io/library/mongo:9.0 hämtar dess senaste 9.0-version.

Förnya certifikatet innan det går ut, om ungefär två år. openssl x509 -enddate -noout -in ~/tls/server.crt visar datumet. Gör ett nytt med samma utfärdare, så att apparna inte behöver ändras:

cd ~/tls
umask 077
openssl req -new -newkey ec -pkeyopt ec_paramgen_curve:P-256 -noenc -subj /CN=ferretdb -keyout server.key -out server.csr
openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key -days 825 -extfile server.ext -out server.crt
podman secret create --replace ferretdb-tls-cert ~/tls/server.crt
podman secret create --replace ferretdb-tls-key ~/tls/server.key
systemctl --user restart ferretdb

Vi testade det en gång: appen anslöt igen med sin gamla ca.crt.

Felsökning

Podden startar inte efter en omstart, och loggen visar Failed to bind port 27017 (Cannot assign requested address). Podden startade före WireGuard. Lägg till inställningen från steg 6, och kör sedan systemctl --user reset-failed och systemctl --user start ferretdb-pod som ferretdb.

MongoServerSelectionError: connection <monitor> to ... closed. Klienten anslöt utan TLS. Lägg till tls=true och tlsCAFile i anslutningssträngen.

unable to get local issuer certificate. Klienten litar inte på certifikatet. Kontrollera att tlsCAFile pekar på kopian av ca.crt.

permission denied to create role. Du använde createUser i mongosh. Skapa inloggningar med psql, som i steg 5.

fe_sendauth: no password supplied. PostgreSQL kräver lösenord inne i podden, vilket DocumentDB inte kan ge. Låt avbildens egen pg_hba.conf vara som den är.

Failed: stat /backup/...: permission denied från mongorestore. Avbilden mongo kör kommandon som börjar med mongo som sin egen användare, som inte kan läsa ~/backup. Behåll --entrypoint mongorestore, som i steg 10.

mongorestore av en dump från MongoDB slutar med Failed: ... createIndex.collation is not implemented yet. MongoDB 9.0 sparar collation: { locale: "simple" } med varje index, och det tar FerretDB 2.7 inte emot. I vårt test återställdes alla dokument, men inga index utom _id. Textindex misslyckades på samma sätt, med Currently only textIndexVersion 2 is supported. Återställ med --noIndexRestore tillagt, och skapa sedan indexen igen med createIndex i mongosh, utan collation. db.collection.getIndexes() i MongoDB listar dem.

En appserver väntar och får timeout. Kontrollera med wg show att WireGuard är igång på båda sidor, och med ufw status att regeln från steg 6 finns.