Naar de inhoud

Neon Postgres back-ups automatiseren met DBackup: de opzet van een bureau met 14 klantsites

UitlegMiguel Stevens19 oktober 202615 minuten lezen

In dit artikel

Een klant belt op een dinsdagochtend. Gisteren heeft iemand drie vacatures gewist, en ze moeten terug. Wat kan je dan doen? Bij een database op Neon hangt het antwoord af van één instelling die bijna niemand ooit bekeken heeft: hoe ver Neon terug kan in de tijd.

Bij ons staat dat venster op onze Neon-projecten op zes uur. Dat is genoeg voor een misklik van daarnet, en te weinig voor een fout die iemand pas na het weekend opmerkt. Daarom draaien we naast Neon een eigen back-upsysteem: DBackup, een zelf gehost programma dat elke nacht een kopie van elke klantendatabase naar aparte opslag in Europa zet.

Dit artikel beschrijft die opzet voor een bureau met één Neon-project per klant. Je krijgt de installatie, de instellingen die wij gekozen hebben en de cijfers van onze eigen instantie. Daarbovenop komen de punten die specifiek bij Neon horen: de verbinding die je moet kiezen en een valkuil die niet in de documentatie staat. Een back-upprogramma kan een database die naar nul schaalt de hele dag wakker houden.

Waarom Neon een eigen back-up nodig heeft

Neon heeft een herstelvenster: een periode waarin je terug kan naar elk moment. Dat is handig voor een misklik. Het is geen archief. Wat ouder is dan het venster, is weg, en wat in dezelfde account staat als de database, verdwijnt mee als die account een probleem heeft.

Een eigen back-up lost drie dingen op die het herstelvenster niet oplost.

  • Een langere geschiedenis. Een dagelijkse kopie voor de laatste week, een wekelijkse voor de laatste maand, een maandelijkse voor het laatste jaar.
  • Een andere plek. De kopieën staan bij een andere partij dan de database. Valt de ene weg, dan blijft de andere staan.
  • Eén overzicht. Bij veertien klanten wil je niet veertien keer in een andere console kijken of het goed ging. Je wil één plek, en een melding wanneer het niet goed ging.

Daar staat een prijs tegenover: je beheert nog een systeem. Het laatste hoofdstuk gaat over wanneer dat de moeite niet waard is.

Wat Neon doet, en waar DBackup begint

Het is geen keuze tussen die twee. Ze lossen verschillende problemen op, en wij gebruiken ze naast elkaar.

 Neon, het herstelvensterDBackup, de nachtelijke dump
Terug in de tijdTot het herstelvenster, bij ons zes uurTot 7 dagen, 4 weken, 12 maanden en 2 jaar
FijnheidElk moment binnen het vensterEén punt per nacht
Waar het staatBij Neon, in dezelfde account als de databaseBij een andere partij, in een bucket
Terugzetten naarEen Neon-branchElke PostgreSQL-server, ook buiten Neon
Past bijDe misklik van daarnetDe fout die niemand direct zag, en het verlies van een account

Wij werken met één Neon-project per klant. Dat houdt de rekentijd, de rechten en de back-ups per klant gescheiden, en het maakt een job per klant vanzelf logisch: veertien projecten, veertien jobs.

Wat DBackup is, in vijf begrippen

DBackup is een zelf gehoste webapplicatie voor het automatiseren van database-back-ups, onder de GNU General Public License. Het draait als één Docker-container met een eigen interface. Het ondersteunt PostgreSQL 12 tot en met 18, MySQL, MariaDB, MongoDB, SQLite, Microsoft SQL Server, Redis en een paar andere engines. De opslag kan een S3-compatibele bucket zijn, SFTP, FTP, SMB, WebDAV, Google Drive, Dropbox of OneDrive.

Je moet vijf begrippen kennen. De rest van het artikel gebruikt ze.

BegripWat het isBij ons
BronDe database (of map) waarvan je een kopie wilEen Postgres-project op Neon, per klant
BestemmingWaar de kopieën terechtkomenHetzner Object Storage
JobBron, bestemming, schema en instellingen samenEén job per klant, elke nacht om 02:00
RetentiebeleidHoe lang kopieën bewaard blijvenSlim bewaren: 7 / 4 / 12 / 2
KanaalWaar meldingen heen gaanEen webhook

Onze opzet in cijfers

Dit zijn de instellingen en de cijfers van onze eigen instantie, zoals ze op 19 oktober 2026 stonden. We lezen ze uit via de API van DBackup (zie verderop), dus het zijn geen geschatte getallen.

OnderdeelWaarde
Jobs14, één per klant
BronPostgreSQL op Neon, verbinding rechtstreeks
BestemmingHetzner Object Storage
SchemaElke nacht om 02:00, tijdzone Europe/Brussels
CompressieGzip (13 van de 14 jobs)
RetentieSlim bewaren: 7 dagelijks, 4 wekelijks, 12 maandelijks, 2 jaarlijks
Naast de databaseBij de meeste jobs ook de geüploade bestanden van de site, in dezelfde run
MeldingenWebhook, enkel bij een mislukte of gedeeltelijke run
Tegelijk lopend1 job tegelijk, dus de nacht duurt ruim tien minuten
Duur van een runGemiddeld 54 seconden, de langste 282 (over de laatste twaalf runs per job)
Bewaard159 back-ups, samen 38 GB
Slaagpercentage, 30 dagen98%

Die 38 GB is grotendeels beeldmateriaal, niet database. De dumps zelf zijn klein: een gewone klantsite is een paar tientallen megabyte. Ook het geheugen valt mee. Het proces zat bij ons rond de 1 GB, dus een kleine server volstaat. De documentatie noemt geen minimum, meet het dus zelf.

DBackup installeren met Docker

Je hebt Docker Engine 20.10 of nieuwer nodig, met Compose v2. De images bestaan voor AMD64 en ARM64. Begin met twee geheimen. Het eerste versleutelt alle wachtwoorden die DBackup opslaat. Het tweede tekent de sessies van de gebruikers.

Terminalbash
# In de map naast je docker-compose.yml
echo "ENCRYPTION_KEY=$(openssl rand -hex 32)" >> .env
echo "BETTER_AUTH_SECRET=$(openssl rand -base64 32)" >> .env

Bewaar ENCRYPTION_KEY buiten de server

Verlies je de ENCRYPTION_KEY, dan zijn de opgeslagen wachtwoorden en de sleutels van je versleutelingsprofielen onleesbaar. Back-ups die met die profielen versleuteld zijn, kan je dan niet meer terugzetten. Er is geen herstelweg. Zet de sleutel in een wachtwoordbeheerder, niet alleen in het .env-bestand op de server.

Dit is het compose-bestand, gebaseerd op dat uit de documentatie, met de aanpassingen die je achter een reverse proxy nodig hebt.

docker-compose.ymlyaml
services:
  dbackup:
    image: skyfay/dbackup:latest
    restart: always
    stop_grace_period: 10m
    ports:
      - "3000:3000"
    environment:
      - ENCRYPTION_KEY=${ENCRYPTION_KEY}
      - BETTER_AUTH_SECRET=${BETTER_AUTH_SECRET}
      - BETTER_AUTH_URL=https://backup.jouwbureau.be
      - DISABLE_HTTPS=true
    volumes:
      - ./data:/data
      - ./tmp:/tmp

Wat elke regel doet, voor wie hem aanpast.

InstellingWaarom
BETTER_AUTH_URLHet adres waarop gebruikers de interface openen. Het wordt ook de basis voor de terugkeeradressen van single sign-on.
DISABLE_HTTPS=trueStandaard draait DBackup zelf op HTTPS met een zelfondertekend certificaat. Achter een reverse proxy geeft dat fouten (502 of een mislukte handshake), dus zet je dit op true en laat je de proxy het certificaat doen.
stop_grace_period: 10mDocker stopt een container na tien seconden. Een upgrade met databasemigraties heeft langer nodig. Een migratie die halverwege stopt, laat een mislukte migratie achter.
/dataDe databank van DBackup zelf (SQLite) en de certificaten. Dit is de enige map die je écht moet bewaren.
/tmpWerkruimte voor dumps. Bij mapbackups heb je ongeveer tweemaal de grootte van de bron nodig.

Start met docker compose up -d en open het adres. De eerste account die je aanmaakt, wordt SuperAdmin. Daarna loopt de Quick Setup je door een eerste bron, een eerste bestemming en een eerste job.

Wie mag erbij?

De documentatie raadt aan de interface enkel via een lokaal netwerk of een VPN te openen. Zet je hem toch op een publiek adres, schakel dan tweestapsverificatie of single sign-on in, gebruik sterke wachtwoorden en beperk de toegang per IP-adres waar het kan. Hij kent je databasewachtwoorden.

Eén beperking om te weten: DBackup is bedoeld als één instantie. Het gebruikt een SQLite-bestand, en twee containers op dezelfde map geven de fout “database is locked”. Wil je hoge beschikbaarheid, dan is dit het verkeerde gereedschap.

De bestemming: Hetzner Object Storage

We bewaren de kopieën op Hetzner Object Storage, in Europa en los van de database zelf. DBackup heeft er een eigen bestemmingstype voor. Eerst maak je in de Hetzner-console een bucket en een toegangssleutel. De geheime sleutel toont Hetzner maar één keer, dus kopieer hem meteen.

  1. Ga in DBackup naar Vault, dan Credentials, en maak een profiel van het type ACCESS_KEY met de sleutels van Hetzner.
  2. Ga naar Connections, dan Destinations, en kies een nieuwe bestemming van het type Hetzner Object Storage.
  3. Vul de velden in zoals in de tabel hieronder.
  4. Klik op Test connection en bewaar.
VeldWat je invult
Regionfsn1 (Falkenstein, de standaard). Ook mogelijk: nbg1, hel1 en ash. De laatste ligt in de Verenigde Staten, dus kies voor klantgegevens een Europese regio.
BucketDe naam van je bucket
LoginHet ACCESS_KEY-profiel van daarnet
FolderVerplicht, anders dan bij andere S3-bestemmingen. Laat je het leeg, dan krijg je de fout “path prefix is required”.

Het adres van de bucket stelt DBackup zelf samen. Per job maakt het een map met daarin het archief (een .tar) en twee kleine bestanden ernaast: een index en een .meta.json met onder meer de controlesom.

Een Neon-database als bron toevoegen

Een bron bestaat uit een host, een poort en een login. De databasenaam staat niet op de bron. Die kies je later in de job. Per Neon-project maak je één bron, dus bij ons veertien.

Een eigen gebruiker met leesrechten

Gebruik niet het eigenaarsaccount dat Neon bij een nieuw project aanmaakt. Maak een gebruiker die enkel kan lezen. DBackup maakt de dump met pg_dump en heeft niet meer nodig dan SELECT. Voer dit uit in de SQL-editor van de Neon-console of met psql.

Eén keer uit te voeren, per databasesql
CREATE USER dbackup WITH PASSWORD 'kies-iets-lang';
GRANT CONNECT ON DATABASE mijndatabase TO dbackup;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO dbackup;
GRANT SELECT ON ALL SEQUENCES IN SCHEMA public TO dbackup;
ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT SELECT ON TABLES TO dbackup;

Wil je alle databases van een server in één bron, geef de gebruiker dan de rol pg_read_all_data (Postgres 14 of nieuwer).

Rechtstreeks verbinden, niet via de pooler

Bij Neon krijg je twee hostnamen per project. Die met -pooler in de naam loopt via PgBouncer in transaction mode. Dat is bedoeld voor je applicatie, niet voor pg_dump: een dump gebruikt instellingen die in die modus niet werken en eindigt met een fout. Neon zegt dat zelf in zijn backup-handleiding. Gebruik de hostnaam zonder -pooler.

Veld in DBackupWaarde
How DBackup connectsDirect
Hostep-naam-12345.c-5.eu-central-1.aws.neon.tech, dus zonder -pooler
Port5432
LoginEen USERNAME_PASSWORD-profiel met de gebruiker hierboven

De Postgres-bron heeft geen veld voor SSL. Neon laat enkel versleutelde verbindingen toe, en bij ons werkt dit zonder extra instelling op alle veertien bronnen. De documentatie van DBackup zegt er niets over, dus test de verbinding altijd met de knop Test connection voor je een job maakt.

De job: schema, retentie en meldingen

Een job koppelt een bron aan een bestemming. Je maakt hem onder Jobs, dan Create Job. De onderdelen die ertoe doen, in de volgorde van het formulier:

Databases kiezen

De knop Load haalt de lijst met databases van de server op. Een Neon-project heeft standaard twee databases: neondb en de systeemdatabase postgres. Laat je de selectie leeg, dan neemt DBackup beide. Kies liever enkel je eigen database. Bij ons was de dump van postgres 9,5 kB, dus je wint geen ruimte, maar wel een dump en een verbinding per nacht.

Het schema

Je kiest uit uurlijks, dagelijks, wekelijks, maandelijks of een cron-expressie. Wij gebruiken 0 2 * * *: elke nacht om 02:00. DBackup leest dat in de tijdzone die je onder Settings, dan General instelt. De standaard is UTC. Zet haar op de jouwe, anders loopt alles een of twee uur anders dan je denkt.

De documentatie spreekt zichzelf hier tegen: de ene pagina zegt dat je de omgevingsvariabele TZ moet zetten, een andere pagina zegt dat die geen effect heeft op het schema. Vertrouw op de instelling in de interface.

Let op: een gemiste run wordt niet ingehaald. Stond de server om 02:00 uit, dan is er die nacht geen back-up. Je merkt dat niet aan een foutmelding, maar aan het ontbreken van een run. Daarvoor bestaat de opslagmelding “back-up ontbreekt” (zie hieronder).

Retentie: slim bewaren

Retentie stel je in per bestemming. Je kan enkel het laatste aantal kopieën houden, of “slim” bewaren, in lagen die bij elkaar opgeteld worden. Wij gebruiken het beleid 7 / 4 / 12 / 2.

LaagAantalBetekenis
Dagelijks7De nieuwste back-up van elk van de laatste 7 dagen
Wekelijks4De nieuwste van elk van de laatste 4 weken
Maandelijks12De nieuwste van elk van de laatste 12 maanden
Jaarlijks2De nieuwste van elk van de laatste 2 jaar

De lagen tellen bij elkaar op. Je houdt zo hooguit vijfentwintig kopieën per klant in plaats van driehonderdvijfenzestig per jaar, met toch een punt per week, per maand en per jaar om naar terug te keren.

Retentie verwijdert, en er is geen prullenbak

Verwijderde back-ups zijn weg. Begin met een ruim beleid en maak het later strakker. Heb je een kopie die je zeker wil houden, vergrendel haar dan: een vergrendelde back-up wordt nooit opgeruimd. Doe dat ook voor je een job hernoemt. Na een hernoeming past het beleid zich toe op de oude map, en de eerste run kan dan veel opruimen.

Compressie

Wij kiezen Gzip. Brotli is de andere keuze. Voor Postgres kan pg_dump zelf comprimeren. DBackup comprimeert de dump dan niet nog eens, enkel wanneer de dumpcompressie op “geen” staat.

Meldingen

Maak onder Connections, dan Channels, een kanaal aan voor Discord, Slack, Teams, Telegram, ntfy, e-mail of een gewone webhook. Per job kies je bij welke uitkomst dat kanaal iets stuurt: geslaagd, gedeeltelijk of mislukt.

Wij sturen alleen bij gedeeltelijk en mislukt, via een webhook. Een melding bij elke geslaagde run betekent veertien berichten per nacht, en na een week lees je ze niet meer. Eén bericht dat er alleen is wanneer er iets mis is, leest iedereen.

Naast de meldingen per job heeft DBackup meldingen op systeemniveau, en een paar daarvan staan bewust uit. Zet ze onder Settings, dan Notifications, op het volgende.

GebeurtenisStandaardOns advies
Een systeemtaak misluktAanAan laten
Een restore mislukt of is klaarAanAan laten
Verbinding offlineAanAan laten, maar zie het hoofdstuk over Neon
Opslag: back-up ontbreekt (standaard na 48 uur)Uit, per bestemmingAanzetten. Dit vangt de gemiste run op.
Opslag: bijna vol of groeit snelUit, per bestemmingAanzetten
Integriteitscontrole misluktAanAan laten, en de controle zelf aanzetten

Neon schaalt naar nul, tot je back-up hem wakker houdt

Dit is het deel dat je nergens in de documentatie vindt. Neon zet een database na vijf minuten zonder verbindingen uit en start hem weer bij de volgende verbinding. Je betaalt rekentijd enkel wanneer hij aan staat. Voor een klantsite die weinig bezoek heeft, is dat het hele voordeel van Neon.

Een back-upprogramma maakt verbinding met je databases. Gebeurt dat te vaak, dan komt de database niet meer in slaap. Bij ons duurt één wake ongeveer zes minuten rekentijd. We hebben dat gemeten op de lijst met bewerkingen die Neon per project bijhoudt.

Wat DBackup standaard doet

De documentatie noemt de systeemtaken van DBackup. Twee ervan maken verbinding met je bronnen.

SysteemtaakStandaardschemaVerbindt met je databases
Health checksElke minuutJa, een ping per bron
Database versionsElk uurJa, leest versie, databases en groottes
Storage statisticsElk uurNee, enkel de bestemming
Backups page cacheElk uurNee, enkel de bestemming
Configuration backupDagelijks 03:00, standaard uitNee, DBackup zelf
Integrity checkZondag 04:00, standaard uitNee, de bestemming

De documentatie zegt niets over databases die naar nul schaalt. Dat een ping elke minuut zo'n database wakker houdt, is onze eigen conclusie en geen documentatie. Het volgt uit hoe Neon werkt: een verbinding is een verbinding.

Wat wij gemeten hebben

Bij ons stonden beide taken ingesteld op één keer per dag, om 01:00. Op de bewerkingenlijst van onze Neon-projecten zagen we daardoor elke dag twee wakes per database. De eerste om 23:00 UTC was van die twee systeemtaken, en de tweede, kort na middernacht UTC, was de back-up zelf.

De back-up heeft een reden. De twee systeemtaken hadden die niet, want elke back-uprun test de verbinding met de bron toch al wanneer hij begint. Een kapotte verbinding merk je dus aan een mislukte run, en daar krijg je een melding van. Daarom hebben we beide taken uitgezet.

Wat je inlevert

Zonder de health checks toont DBackup geen live status van je verbindingen, en de melding “verbinding offline” komt niet meer. Zonder de versietaak verversen de lijst met databases, hun groottes en de versiegeschiedenis in de Database Explorer niet meer. Tabellen openen blijft werken, want dat leest live. Back-ups en restores hangen er niet van af.

Daarmee hoort de back-up zelf het enige te zijn dat je databases elke dag wakker maakt: één wake per database per dag. Zo tel je dat zelf, met de Neon CLI:

Aantal wakes per dag voor één Neon-projectbash
neon operations list \
  --project-id jouw-project-id \
  --org-id jouw-org-id \
  --limit 1000 --output json \
  | jq -r '.[] | select(.action=="start_compute") | .created_at[0:10]' \
  | sort | uniq -c

Een database zonder bezoek en met alleen een nachtelijke back-up hoort op één wake per dag te komen. Zie je er tientallen, dan is er iets anders dat verbinding maakt. Dat kan een cron zijn, een monitor, of een crawler die op een pagina komt die bij elk bezoek een query doet.

Een back-up die je niet getest hebt

Een back-up die niet terug te zetten is, bestaat niet. DBackup helpt daar op drie manieren bij, en geen ervan is een volledige test.

Wat DBackup controleert

  • Bij elke upload berekent het een controlesom (SHA-256) en bewaart die in het .meta.json-bestand.
  • Je kan een back-up in de interface handmatig laten controleren: het vergelijkt dan de bestemming met die som.
  • De systeemtaak Integrity check doet dat op schema voor je kopieën. Hij staat standaard uit en draait dan op zondag om 04:00. Zet hem aan.

Dat bewijst dat het bestand niet beschadigd is. Het bewijst niet dat de inhoud terug te zetten is. Een automatische test die een kopie echt terugzet in een lege database, vonden we niet in de documentatie.

Zelf een restore testen

Doe dit één keer voor je op de back-ups vertrouwt, en daarna een keer per halfjaar.

  1. Maak in Neon een tijdelijke branch (zie hieronder). Een branch bevat een kopie van de echte data, dus verwijder hem na de test.
  2. Voeg die branch als tweede bron toe in DBackup, met de directe hostnaam van de branch.
  3. Kies bij Backups de nieuwste kopie en klik op Restore. Kies de nieuwe bron en zet de optie “Restore as a copy” aan, zodat de database een nieuwe naam krijgt.
  4. Open de site met de testdatabase als verbinding en kijk of de pagina's, de gebruikers en de bijlagen er zijn.
  5. Verwijder de testbron en de branch weer.
Een tijdelijke Neon-branch maken en weer verwijderenbash
neon branches create --project-id jouw-project-id --name restore-test
# ...restore in DBackup en nakijken...
neon branches delete restore-test --project-id jouw-project-id

Valkuilen bij het terugzetten

ValkuilWat er gebeurt
Zelfde server, zelfde naamDe bestaande data wordt overschreven. Gebruik een kopie als je twijfelt.
Rollen en rechtenEen restore neemt eigenaars en rechten niet mee (--no-owner --no-acl). Maak de gebruikers op een nieuwe server zelf opnieuw aan.
Oudere serverEen back-up terugzetten op een oudere versie weigert DBackup. Op dezelfde of een nieuwere versie kan het.
Versleutelde back-up, sleutel kwijtNiemand kan hem openen. Er is geen achterdeur.

Versleuteling en het herstelpakket

Een dump van een klantendatabase bevat klantgegevens. Zet daarom versleuteling aan: DBackup gebruikt AES-256-GCM en een sleutel per archief, en dat kan per job. Je maakt een versleutelingsprofiel onder Vault en kiest het in de job.

Maak daarna het herstelpakket (Recovery Kit): een zip met je sleutel en een Node.js-script, dbackup-recover.js. Daarmee open je een back-up zonder DBackup, op elke computer met Node 18 of nieuwer. Dat is de reden dat je het hebt. Draait je back-upserver niet meer, dan heb je met dit pakket nog altijd toegang tot je kopieën.

Een back-up openen zonder DBackupbash
node dbackup-recover.js --list    ./backup-map
node dbackup-recover.js --extract ./backup-map ./uitgepakt
node dbackup-recover.js --decrypt ./backup.enc ./uitgepakt

Bewaar het pakket offline, bijvoorbeeld in een wachtwoordbeheerder, en nooit naast de back-ups. Wie het pakket heeft, kan alle kopieën lezen. Het script heeft ook het .meta.json-bestand van de back-up nodig. Dat blijft leesbaar, ook bij een versleutelde back-up, en toont onder meer de namen van de databases.

De back-up van de back-upserver

Je hebt nu een systeem dat alles bewaart, behalve zichzelf. Gaat de server kapot, dan ben je je bronnen, bestemmingen, jobs, gebruikers en schema's kwijt. Die zitten in het SQLite-bestand in /data.

DBackup heeft hier een systeemtaak voor: Configuration backup. Hij staat standaard uit. Zet hem aan. Hij maakt dagelijks om 03:00 een gecomprimeerde, versleutelde kopie van de hele configuratie, bewaart de laatste tien en schrijft ze naar een bestemming die jij kiest. Een versleutelingssleutel is verplicht.

Die kopie bevat ook de ENCRYPTION_KEY en het BETTER_AUTH_SECRET van de instantie. Op een nieuwe server heb je dus geen van beide nodig: je installeert DBackup, kiest bij de eerste start “Restore a backup” en geeft de kopie en de sleutel van die kopie. Bewaar die sleutel dus apart, met het herstelpakket.

Een upgrade is het andere moment waarop je de configuratie kan verliezen. Kopieer de map data/db (met de -wal en -shm-bestanden) voor je upgradet, en volg het logboek tot er “All migrations have been successfully applied” staat.

De API: controleren zonder de interface

DBackup heeft een REST-API. Je maakt een sleutel onder Users & Groups, dan API keys. Hij begint met dbackup_ en wordt één keer getoond. De sleutel heeft maximaal de rechten van de gebruiker die hem maakt, en je kiest zelf een kleiner stel. Voor controle volstaat leesrecht op jobs.

Sla de sleutel niet op in een bestand. Op een Mac zet je hem in de sleutelhanger:

Sleutel bewaren en gebruiken (macOS)bash
security add-generic-password -a "$USER" -s dbackup-api-key -w
# plak de sleutel wanneer erom gevraagd wordt

KEY=$(security find-generic-password -a "$USER" -s dbackup-api-key -w)
curl -s -H "Authorization: Bearer $KEY" \
  https://backup.jouwbureau.be/api/dashboard/stats

De laatste regel geeft een overzicht terug. Dit is het antwoord van onze eigen instantie, op de dag dat we dit schreven:

GET /api/dashboard/statsjson
{
  "success": true,
  "data": {
    "totalJobs": 14,
    "activeSchedules": 14,
    "success24h": 14,
    "failed24h": 0,
    "totalSnapshots": 159,
    "totalStorageBytes": 38123072349,
    "successRate30d": 98
  }
}

Een job die je met de hand wil starten, bijvoorbeeld voor een grote wijziging, doe je zo. Het antwoord bevat een executionId. Daarmee vraag je de stand op tot de status Success, Partial of Failed is.

Een job starten en volgenbash
curl -X POST "https://backup.jouwbureau.be/api/jobs/JOB_ID/run" \
  -H "Authorization: Bearer $KEY"

curl "https://backup.jouwbureau.be/api/executions/EXECUTION_ID" \
  -H "Authorization: Bearer $KEY"

Een API-sleutel verloopt standaard na 90 dagen. Zet een herinnering in je agenda, want een controle die stilletjes ophoudt, merk je pas wanneer je haar nodig hebt.

Checklist voor je live gaat

StapGedaan als
Sleutels bewaardENCRYPTION_KEY en het herstelpakket staan in een wachtwoordbeheerder, niet alleen op de server
TijdzoneSettings, dan General, staat op jouw tijdzone
BronEen leesgebruiker, de directe hostnaam, en Test connection slaagt
JobEen eerste run is geslaagd en je ziet het archief in de bucket
RetentieRuim ingesteld, en de kopieën die je zeker wil houden zijn vergrendeld
MeldingenEen testbericht komt aan, en de melding “back-up ontbreekt” staat aan
SysteemtakenHealth checks en Database versions overwogen, Configuration backup en Integrity check aan
RestoreEén keer echt teruggezet in een testdatabase en nagekeken

Wanneer dit niet de juiste keuze is

Wij beheren veertien klanten. Voor wie minder heeft, is dit zwaarder dan het moet zijn. Vier gevallen waarin we het niet zouden doen.

  1. Je hebt één site. Een eigen server en een eigen opslag onderhouden voor één database is veel. Een geplande pg_dump naar een bucket doet 80 procent van het werk, en de back-upfunctie van je provider bijna al de rest.
  2. Niemand leest de meldingen. Een back-upsysteem dat faalt zonder dat iemand het hoort, is erger dan geen systeem, want het geeft zekerheid die er niet is.
  3. Je hebt een herstelpunt per minuut nodig. DBackup maakt dumps, geen doorlopende stroom van wijzigingen. Het fijnste herstelpunt is de laatste run: bij ons tot 24 uur terug. Heeft een klant een webshop met bestellingen per minuut, dan heb je het herstelvenster van je provider nodig, óf een andere aanpak.
  4. Je wil geen server beheren. De container is eenvoudig, maar iemand moet de upgrades doen, de schijf in de gaten houden en reageren wanneer het stopt. DBackup is één instantie. Valt die weg, dan valt het schema weg, tot jij hem terugzet.

In die gevallen is de back-upfunctie van je provider, aangevuld met een geplande dump, een goed antwoord. Draai je tientallen databases voor klanten die elk een eigen herstelverhaal verwachten, dan loont één plek waar je ze allemaal ziet.

Bouw je zelf voor andere bureaus, kijk dan op onze pagina voor bureaus.

Bronnen

  1. https://docs.dbackup.app/user-guide/installation
  2. https://docs.dbackup.app/user-guide/destinations/s3-hetzner
  3. https://docs.dbackup.app/user-guide/sources/postgresql
  4. https://docs.dbackup.app/user-guide/jobs/retention
  5. https://docs.dbackup.app/user-guide/security/recovery-kit
  6. https://docs.dbackup.app/user-guide/features/system-backup
  7. https://docs.dbackup.app/user-guide/features/api-keys
  8. https://docs.dbackup.app/developer-guide/advanced/healthcheck
  9. https://neon.com/docs/manage/backup-pg-dump
  10. https://neon.com/docs/connect/connection-pooling
  • Neon
  • PostgreSQL
  • DBackup
  • Back-ups
  • Hetzner

Deel dit artikel

LinkedInMail
Miguel

Geschreven door

Miguel

Oprichter & developer

Captain of this small ship. Twintig jaar in design, development en digitale strategie. Ik schrijf de code, bewaak het ontwerp en ben eindverantwoordelijk voor de kwaliteit.

Volg op LinkedIn

Volgende stap

Zit jouw vraag hier niet bij?

Vertel wat je van plan bent. Een half uur is genoeg om te weten of we de juiste partner zijn, en zo niet, dan zeggen we dat meteen.