Hoe je n8n zelf op een Linux-VPS kunt hosten (stap voor stap)

Inleiding

n8n is een van de krachtigste open-source tools voor workflowautomatisering die momenteel beschikbaar zijn. In tegenstelling tot SaaS-alternatieven zoals Zapier of Make, geeft n8n je volledige controle over je gegevens en automatiseringen — maar alleen als je het zelf host. Een Linux VPS is hiervoor de ideale omgeving: altijd beschikbaar, betaalbaar en volledig onder jouw controle.

Deze handleiding leidt je door het volledige proces van het opzetten van een productieklaar, zelfgehost n8n-systeem op een Linux VPS. Je begint met een lege server en eindigt met een volledig beveiligde, SSL-ondersteunde n8n-implementatie met Docker, Nginx, PostgreSQL, geautomatiseerde back-ups en een versterkte beveiligingsconfiguratie.

Belangrijkste punten

• n8n op een VPS biedt je onbeperkte workflows, geen gebruikslimieten en volledig eigendom van je gegevens
• Docker is de aanbevolen installatiemethode voor eenvoudigere updates en isolatie
• PostgreSQL is de aanbevolen database voor productiewerkbelastingen (niet SQLite)
• Een reverse proxy (Nginx) met Let’s Encrypt SSL is vereist voor productiegebruik
• Je VPS moet minimaal 1 vCPU en 2 GB RAM hebben voor een soepele n8n-ervaring met PostgreSQL
• Regelmatige geautomatiseerde back-ups beschermen je workflowgegevens en inloggegevens

Wat is n8n?

n8n (uitgesproken als “n-acht-n”) is een open-sourceplatform voor workflowautomatisering waarmee je apps, API’s en diensten kunt koppelen met behulp van een visuele, op knooppunten gebaseerde editor. Het ondersteunt standaard meer dan 400 integraties en stelt je in staat om aangepaste JavaScript- of Python-code binnen workflows uit te voeren.

Het belangrijkste verschil tussen n8n en zijn concurrenten komt neer op drie zaken: eigendom, kosten en flexibiliteit.

**Eigendom: **Wanneer je n8n zelf host, verlaten je workflowgegevens, inloggegevens en uitvoeringslogboeken nooit je server. Voor teams die omgaan met gevoelige klantgegevens, financiële gegevens of bedrijfseigen logica is dit van enorm belang. Cloudplatforms slaan je automatiseringslogica op hun infrastructuur op, waarvoor hun beleid inzake gegevensbewaring en beveiligingsstatus gelden.

**Kosten: **Het n8n-cloudabonnement brengt kosten in rekening per workflowuitvoering, wat bij automatiseringen met een hoog volume snel oploopt. Een middelgroot team dat duizenden uitvoeringen per dag uitvoert, kan maandelijks honderden dollars kwijt zijn. Op je eigen VPS zijn de uitvoeringen, zodra je voor de server hebt betaald, onbeperkt en zonder extra kosten.

**Flexibiliteit: **Met zelfgehoste n8n kun je community-knooppunten installeren, willekeurige code binnen workflows uitvoeren, verbinding maken met interne diensten die niet toegankelijk zijn via het openbare internet, en elk aspect van de implementatie naar eigen wens configureren. Cloudabonnementen beperken veel van deze mogelijkheden.

Vereisten

Zorg ervoor dat je het volgende hebt voordat je begint:

• Een Linux-VPS met Ubuntu 22.04 of 24.04 (aanbevolen). Controleer of je provider Ubuntu aanbiedt bij het pakket dat je kiest, aangezien sommige instap-pakketten alleen andere distributies aanbieden
• Een niet-rootgebruiker met sudo-rechten
• Een domeinnaam die verwijst naar het IP-adres van je VPS (bijv. n8n.jouwdomein.com)
• SSH-toegang tot je server
• Basisvaardigheid in het gebruik van de Linux-opdrachtregel

De juiste VPS kiezen

De server die je kiest, heeft een directe invloed op de prestaties van n8n. Je hebt minimaal 1 vCPU, 2 GB RAM en 20 GB SSD-opslag nodig. Het extra RAM-geheugen ten opzichte van een minimale, op SQLite gebaseerde installatie is nodig omdat PostgreSQL, Nginx en n8n allemaal tegelijkertijd draaien.

Voor teams met meerdere gebruikers, complexe workflows met meerdere stappen of een hoge webhook-doorvoer, kun je upgraden naar 2 vCPU’s en 4 GB RAM. De opslagruimte moet minimaal 40 GB bedragen als je van plan bent om uitgebreide uitvoeringslogboeken bij te houden.

PetroSky biedt NVMe VPS-pakketten aan in Parijs en Montreal, waarbij n8n bij het afrekenen als ‘one-click’-applicatie beschikbaar is: een open-source installatiescript implementeert n8n met Docker Compose en stelt automatisch HTTPS in via Caddy en Let’s Encrypt. Deze handleiding behandelt de handmatige methode, die bij elke provider werkt.

Houd bij het kiezen van een VPS-provider ook rekening met de geografische locatie. Host je n8n-instantie in de regio die het dichtst bij de diensten ligt waarmee deze het vaakst verbinding zal maken — dit vermindert de API-latentie bij het uitvoeren van je workflows.

Stap 1: Werk je server bij

Maak via SSH verbinding met je VPS en voer een volledige systeemupdate uit voordat je iets installeert:

    sudo apt update && sudo apt upgrade -y

Zo zorg je ervoor dat je over de nieuwste beveiligingspatches beschikt en dat alle systeembibliotheken up-to-date zijn voordat je Docker en andere software toevoegt.

Start de server opnieuw op als er een kernelupdate is toegepast:

    sudo reboot

Nadat je opnieuw verbinding hebt gemaakt via SSH, maak je een speciale systeemgebruiker aan voor het draaien van n8n. Het draaien van services als root vormt een veiligheidsrisico:

    sudo adduser n8nuser
    sudo usermod -aG sudo n8nuser
    su - n8nuser

Stap 2: Installeer Docker en Docker Compose

De officiële, aanbevolen installatiemethode voor n8n is Docker. Docker isoleert n8n en de bijbehorende afhankelijkheden van de rest van je systeem, waardoor updates en rollbacks eenvoudig zijn.

Installeer Docker met behulp van het officiële hulpscript:

    curl -fsSL https://get.docker.com | sudo sh

In de documentatie van Docker wordt opgemerkt dat het gemakscript niet wordt aanbevolen voor productieomgevingen, omdat het de nieuwste release installeert zonder dat u een versie kunt kiezen. Als u Docker-versies wilt vastzetten, gebruik dan in plaats daarvan de apt-repository-methode uit de Ubuntu-installatiehandleiding van Docker (docs.docker.com/engine/install/ubuntu/).

Voeg je gebruiker toe aan de Docker-groep, zodat je Docker-opdrachten kunt uitvoeren zonder sudo:

    sudo usermod -aG docker $USER
    newgrp docker

Controleer of Docker correct werkt:

    docker --version
    docker compose version

Beide commando’s zouden zonder fouten de versienamen moeten weergeven. Als Docker Compose niet wordt gevonden, installeer het dan handmatig:

    sudo apt install docker-compose-plugin -y

Stap 3: PostgreSQL instellen voor productie

Standaard gebruikt n8n SQLite als database. SQLite is prima voor persoonlijk gebruik en lichte workflows, maar het kan slecht omgaan met gelijktijdige schrijfbewerkingen, wat zich uit in vertragingen en "database is locked"-fouten zodra er veel workflows tegelijkertijd draaien. Voor een productie-implementatie is PostgreSQL de juiste keuze.

Draai PostgreSQL binnen Docker naast n8n:

    mkdir ~/n8n && cd ~/n8n

Maak een omgevingsbestand aan om je geheimen veilig op te slaan. Codeer wachtwoorden nooit hard in je compose-bestand:

    nano ~/n8n/.env

Voeg het volgende toe en vervang de plaatshouderwaarden door sterke, unieke wachtwoorden:

    POSTGRES_USER=n8n
    POSTGRES_PASSWORD=je_sterke_db-wachtwoord_hier
    POSTGRES_DB=n8n
    N8N_ENCRYPTION_KEY=je_willekeurige_reeks_van_32_tekens_hier

Genereer een veilige versleutelingssleutel met:

    openssl rand -hex 16

Gebruik de uitvoer als je N8N_ENCRYPTION_KEY. Deze sleutel versleutelt de in n8n opgeslagen inloggegevens — als je deze kwijtraakt, zijn alle opgeslagen inloggegevens onherstelbaar.

Stap 4: Maak het n8n Docker Compose-bestand aan

Maak het bestand docker-compose.yml aan in je n8n-map:

    nano ~/n8n/docker-compose.yml

Plak de volgende configuratie:

services:
  postgres:
    image: postgres:16-alpine
    restart: always
    environment:
      - POSTGRES_USER=${POSTGRES_USER}
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
      - POSTGRES_DB=${POSTGRES_DB}
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -h localhost -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
      interval: 5s
      timeout: 5s
      herhalingen: 10


  n8n:
    image: docker.n8n.io/n8nio/n8n
    herstart: altijd
    poorten:
      - "127.0.0.1:5678:5678"
    omgeving:
      - N8N_HOST=n8n.yourdomain.com
      - N8N_PORT=5678
      - N8N_PROTOCOL=https
      - NODE_ENV=production
      - WEBHOOK_URL=https://n8n.yourdomain.com/
      - GENERIC_TIMEZONE=Europe/London
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_PORT=5432
      - DB_POSTGRESDB_DATABASE=${POSTGRES_DB}
      - DB_POSTGRESDB_USER=${POSTGRES_USER}
      - DB_POSTGRESDB_PASSWORD=${POSTGRES_PASSWORD}
      - N8N_ENCRYPTION_KEY=${N8N_ENCRYPTION_KEY}
      - EXECUTIONS_MODE=regular
      - N8N_LOG_LEVEL=info
    volumes:
      - n8n_data:/home/node/.n8n
    depends_on:
      postgres:
        condition: service_healthy


volumes:
  postgres_data:
  n8n_data:

Opmerkingen bij de configuratie:

• De poortbinding 127.0.0.1:5678:5678 zorgt ervoor dat n8n alleen lokaal toegankelijk is. Nginx verwerkt al het externe verkeer — stel poort 5678 nooit rechtstreeks bloot aan het internet.
• `depends_on` met de voorwaarde `service_healthy` zorgt ervoor dat n8n wacht tot PostgreSQL volledig gereed is voordat het wordt gestart. Zonder deze instelling zal n8n bij de eerste opstart mislukken als de database nog geen verbindingen accepteert.
• N8N_LOG_LEVEL=info levert nuttige operationele logbestanden op zonder de schijfruimte te overspoelen, zoals bij ‘debug’ het geval zou zijn.

Stap 5: Nginx installeren en configureren

Nginx fungeert als een reverse proxy en stuurt HTTPS-verkeer van poort 443 door naar je n8n-container op poort 5678. Het zorgt ook voor SSL-terminatie, wat betekent dat n8n zelf geen certificaten hoeft te beheren.

    sudo apt install nginx -y

Verwijder de standaardsite en maak een nieuw serverblok aan voor n8n:

    sudo rm /etc/nginx/sites-enabled/default
    sudo nano /etc/nginx/sites-available/n8n

Plak het volgende:

    map $http_upgrade $connection_upgrade {
        default upgrade;
        ''      close;
    }
server {
    listen 80;
    server_name n8n.yourdomain.com;


    location / {
        proxy_pass http://127.0.0.1:5678;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        chunked_transfer_encoding on;
        proxy_buffering off;
        proxy_cache uit;
        proxy_read_timeout 90s;
        client_max_body_size 50m;
    }
}

Het map-blok bovenaan verwerkt WebSocket-upgrade-headers correct. n8n gebruikt WebSockets voor realtime updates in de editor, dus deze configuratie is belangrijk — zonder deze instelling werkt de visuele editor niet correct.

De directive `client_max_body_size 50m` zorgt ervoor dat workflows grote webhook-payloads kunnen ontvangen. De standaardlimiet van Nginx is 1 MB, wat te klein is voor workflows die bestandsuploads of grote JSON-responsen verwerken.

Schakel de configuratie in en test deze:

    sudo ln -s /etc/nginx/sites-available/n8n /etc/nginx/sites-enabled/
    sudo nginx -t
    sudo systemctl reload nginx

Stap 6: Een SSL-certificaat aanvragen met Let’s Encrypt

Installeer Certbot en de Nginx-plugin:

    sudo apt install certbot python3-certbot-nginx -y

Vraag een certificaat aan voor je domein:

    sudo certbot --nginx -d n8n.yourdomain.com

Volg de instructies. Wanneer u wordt gevraagd of u HTTP-verkeer wilt omleiden naar HTTPS, kiest u Ja (optie 2). Certbot werkt uw Nginx-configuratie automatisch bij om deze omleiding af te handelen en installeert de volledige certificaatketen.

Controleer of de automatische verlenging correct is geconfigureerd:

    sudo certbot renew --dry-run

Certbot installeert een systemd-timer die certificaten automatisch elke 12 uur vernieuwt. Certificaten worden vernieuwd wanneer ze binnen 30 dagen na de vervaldatum vallen. U hoeft ze nooit handmatig te vernieuwen.

Stap 7: Start n8n

Ga terug naar je n8n-map en start alle services:

    cd ~/n8n
    docker compose up -d

Docker haalt de PostgreSQL- en n8n-images op, maakt de volumes aan, start eerst PostgreSQL, wacht tot de gezondheidscontrole is geslaagd en start vervolgens n8n. Dit proces duurt bij de eerste keer 1–3 minuten.

Controleer of beide containers actief zijn:

    docker compose ps

Je zou zowel postgres als n8n moeten zien staan met de status Up. Als n8n de status Restarting weergeeft, controleer dan de logbestanden:

    docker compose logs n8n --tail=50

Zodra beide containers in orde zijn, open je je browser en ga je naar https://n8n.yourdomain.com. Je wordt gevraagd om een eigenaarsaccount aan te maken met een e-mailadres en wachtwoord. Dit account heeft volledige beheerdersrechten voor je n8n-instantie.

Stap 8: Configureer n8n om bij het opstarten te starten

De richtlijn `restart: always` in je `docker-compose.yml` zorgt ervoor dat alle containers automatisch opnieuw opstarten bij een crash of het opnieuw opstarten van de server.

Controleer dit door je server opnieuw op te starten:

    sudo reboot

Nadat je opnieuw verbinding hebt gemaakt via SSH, controleer je of n8n automatisch weer is opgestart:

    docker compose -f ~/n8n/docker-compose.yml ps

Beide containers zouden nu zonder enige handmatige tussenkomst als actief moeten worden weergegeven.

Stap 9: Automatische back-ups instellen

Je n8n-gegevens — workflows, inloggegevens en uitvoeringsgeschiedenis — staan op twee plaatsen: de PostgreSQL-database en het n8n_data Docker-volume (waarin versleutelingssleutels en bepaalde configuratiegegevens worden opgeslagen). Maak regelmatig een back-up van beide.

Maak een back-upscript:

    nano ~/n8n/backup.sh

Plak het volgende:

    #!/bin/bash
    BACKUP_DIR="/home/n8nuser/backups"
    DATE=$(date +%Y-%m-%d_%H-%M)
    LOG_FILE="$BACKUP_DIR/backup.log"
# Controleer eerst of de back-upmap bestaat
mkdir -p "$BACKUP_DIR"


# PostgreSQL dumpen
DUMP_FILE="$BACKUP_DIR/n8n_db_$DATE.sql"
docker compose -f /home/n8nuser/n8n/docker-compose.yml exec -T postgres \
  pg_dump -U n8n n8n > "$DUMP_FILE"


# Controleer of de dump is gelukt en niet leeg is
if [ $? -ne 0 ] || [ ! -s "$DUMP_FILE" ]; then
    echo "FOUT: Database-back-up mislukt op $DATE" >> "$LOG_FILE"
    rm -f "$DUMP_FILE"
    exit 1
fi


# Maak een back-up van de versleutelingssleutel en de omgevingsvariabelen
cp /home/n8nuser/n8n/.env "$BACKUP_DIR/n8n_env_$DATE.bak"
# Maak een back-up van het n8n_data-volume (instantieconfiguratie en geïnstalleerde community-knooppunten)
docker run --rm -v n8n_n8n_data:/data -v "$BACKUP_DIR":/backup alpine \
  tar czf /backup/n8n_data_$DATE.tar.gz -C /data .


# De databasedump comprimeren
gzip "$DUMP_FILE"


# Bewaar alleen de back-ups van de afgelopen 7 dagen
find "$BACKUP_DIR" -name "*.sql.gz" -mtime +7 -delete
find "$BACKUP_DIR" -name "*.bak" -mtime +7 -delete
find "$BACKUP_DIR" -name "n8n_data_*.tar.gz" -mtime +7 -delete


echo "Back-up voltooid: n8n_db_$DATE.sql.gz" >> "$LOG_FILE"

De volumenaam n8n_n8n_data is afkomstig van Docker Compose, dat de naam van de projectmap (n8n) als voorvoegsel aan het volume toevoegt. Controleer de naam van uw volume met docker volume ls.

Maak het script uitvoerbaar en plan het in met cron:

    chmod +x ~/n8n/backup.sh
    crontab -e

Voeg deze regel toe om de back-up elke dag om 02:00 uur uit te voeren:

    0 2 * * * /home/n8nuser/n8n/backup.sh >> /home/n8nuser/backups/backup.log 2>&1

Voor redundantie op een externe locatie kun je overwegen om je back-upmap te synchroniseren met een S3-compatibele objectopslagprovider met behulp van rclone of aws s3 sync.

Stap 10: Basisbeveiliging inschakelen

Een firewall instellen

Installeer UFW en sta alleen de poorten toe die je server nodig heeft:

    sudo ufw allow OpenSSH
    sudo ufw allow 'Nginx Full'
    sudo ufw enable

Controleer of de regels actief zijn:

    sudo ufw status verbose

Je zou moeten zien dat poort 22 (SSH), 80 (HTTP) en 443 (HTTPS) zijn toegestaan. Een kanttekening: Docker schrijft zijn eigen firewallregels en omzeilt UFW voor gepubliceerde containerpoorten. Poort 5678 blijft privé omdat het compose-bestand deze koppelt aan 127.0.0.1, niet vanwege UFW, dus wijzig die koppeling nooit naar 0.0.0.0.

Schakel wachtwoordverificatie voor SSH uit

Als je SSH-sleutels gebruikt (wat je zou moeten doen), schakel dan het inloggen via SSH met een wachtwoord volledig uit. Zorg er eerst voor dat het account `n8nuser` kan inloggen met je sleutel. Voer vanaf je lokale computer het volgende uit:

    ssh-copy-id n8nuser@your_server_ip

Bewerk vervolgens de configuratie van de SSH-server:

    sudo nano /etc/ssh/sshd_config

Stel de volgende waarden in:

    PasswordAuthentication no
    PermitRootLogin no
    sudo systemctl restart ssh

Op veel Ubuntu-cloudimages staat in een bestand in /etc/ssh/sshd_config.d/ (vaak 50-cloud-init.conf) PasswordAuthentication yes ingesteld, en deze instelling heeft voorrang omdat sshd de eerste waarde gebruikt die het leest. Controleer welke instelling daadwerkelijk van kracht is:

    sudo sshd -T | grep -i passwordauthentication

Er zou ‘passwordauthentication no’ moeten verschijnen. Als dat niet het geval is, wijzig dan de waarde in het override-bestand en start SSH opnieuw op.

Sluit je huidige SSH-sessie niet af voordat je hebt gecontroleerd of inloggen met een sleutel werkt in een nieuw terminalvenster.

Beperk het aantal verzoeken naar de n8n-inlogpagina

Voeg een snelheidsbeperking toe om brute-force-aanvallen op het n8n-inlog-eindpunt te vertragen.

**Belangrijk: **De richtlijn `limit_req_zone` moet in het `http {}`-blok in je hoofdconfiguratiebestand van Nginx staan — niet in het `server`-blok. Open het hoofdconfiguratiebestand:

    sudo nano /etc/nginx/nginx.conf

Voeg deze regel toe binnen het bestaande http {}-blok:

    http {
        ...
        limit_req_zone $binary_remote_addr zone=n8n_login:10m rate=5r/m;
        ...
    }

Voeg vervolgens in de configuratie van je n8n-site (/etc/nginx/sites-available/n8n) dit `location`-blok toe binnen het `server`-blok dat luistert op poort 443 (door Certbot aangemaakt in stap 6), naast de bestaande `location /`. Nginx neemt geen proxy-headers mee vanuit `location /`, dus worden ze hier herhaald:

    location /rest/login {
        limit_req zone=n8n_login burst=5 nodelay;
        proxy_pass http://127.0.0.1:5678;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

Laad Nginx opnieuw om de wijzigingen toe te passen:

    sudo nginx -t && sudo systemctl reload nginx

Hiermee wordt elk IP-adres beperkt tot ongeveer 5 inlogpogingen per minuut, met een kleine tolerantie voor pieken.

Houd n8n en PostgreSQL up-to-date

Haal regelmatig de nieuwste images op en start ze opnieuw op:

    cd ~/n8n
    docker compose pull
    docker compose up -d

Docker haalt de nieuwste n8nio/n8n- en postgres-images op en start alleen de containers opnieuw op waarvoor een nieuwere versie beschikbaar is.

Overweeg voor productieomgevingen om de n8n-image aan een specifieke versietag te koppelen (docker.n8n.io/n8nio/n8n:<versie>, afkomstig uit de release-opmerkingen van n8n) en bewust te upgraden, zodat een routinematige pull nooit een hoofdversie overslaat voordat je de changelog hebt gelezen.

Problemen oplossen

De n8n-container start steeds opnieuw op

Controleer de containerlogs onmiddellijk nadat de herstartlus begint:

    docker compose logs n8n --tail=100

Veelvoorkomende oorzaken:

• Fout bij databaseverbinding: Controleer met `docker compose ps` of PostgreSQL in orde is. Controleer of het `POSTGRES_PASSWORD` in je `.env`-bestand overeenkomt met het wachtwoord waarmee de database is geïnitialiseerd.
• Versleutelingssleutel ontbreekt of is gewijzigd: Als N8N_ENCRYPTION_KEY niet is ingesteld of na de eerste keer draaien is gewijzigd, kan n8n de opgeslagen inloggegevens niet ontsleutelen en zal het programma crashen.
• Onvoldoende RAM: PostgreSQL en n8n kunnen samen 1–1,5 GB RAM gebruiken. Controleer het beschikbare geheugen met `free -h`.

Webhooks werken niet

Voor webhooks moet n8n via het internet bereikbaar zijn op uw domein. Controleer het volgende:

1. Het DNS A-record van je domein verwijst naar het IP-adres van je VPS: dig n8n.joudomein.com
2. Nginx draait: sudo systemctl status nginx
3. Poort 443 is open: sudo ufw status
4. De omgevingsvariabele WEBHOOK_URL komt exact overeen met uw openbare domein, inclusief de afsluitende schuine streep

De n8n-editor laadt niet correct

Als de visuele editor wel laadt maar een leeg workflow-canvas weergeeft of als realtime updates niet meer werken, is er een fout opgetreden in de WebSocket-verbinding. Controleer of het $http_upgrade-blok in uw Nginx-configuratie aanwezig is en of u de variabele $connection_upgrade gebruikt — niet de letterlijke tekenreeks “upgrade” — in de regel proxy_set_header Connection.

SSL-certificaatfouten

Als Certbot mislukt met een domeinvalidatiefout, controleer dan of poort 80 toegankelijk is vanaf het internet:

    curl -I http://n8n.yourdomain.com

Als het verzoek een time-out geeft, blokkeert de firewall van je VPS-provider mogelijk poort 80. Controleer naast UFW ook de firewallregels in de cloudconsole.

Conclusie

Door n8n zelf te hosten op een Linux-VPS beschikt u over een productieklaar platform voor workflowautomatisering zonder uitvoeringslimieten, met volledige gegevensprivacy en de flexibiliteit om elke gewenste integratie uit te voeren. De in deze handleiding beschreven configuratie — Docker, PostgreSQL, Nginx reverse proxy, Let’s Encrypt SSL, geautomatiseerde back-ups en beveiligingsversterking — is dezelfde stack die in productieomgevingen wordt gebruikt en biedt u een stabiele, veilige basis om op voort te bouwen.

In tegenstelling tot een minimale installatie via het Docker-commando `run`, is deze opzet zo ontworpen dat deze serverherstarts doorstaat, gelijktijdige workflowuitvoeringen aankan en op een soepele manier herstelt na storingen. Je inloggegevens zijn versleuteld, er wordt elke nacht een back-up van je gegevens gemaakt en je inlog-endpoint is beveiligd tegen brute-force-aanvallen door middel van een verwerkingslimiet.

Zodra je instantie draait, kun je de ingebouwde nodes van n8n voor databases, API’s, webhooks en AI-integraties verkennen om direct te beginnen met het automatiseren van je workflows. Het zelfgehoste communityforum op community.n8n.io is ook een uitstekende bron voor ideeën voor workflows, het oplossen van problemen met nodes en tips voor implementatie.