Så här installerar du n8n på en Linux-VPS (steg för steg)

Inledning

n8n är ett av de mest kraftfulla verktygen för automatisering av arbetsflöden med öppen källkod som finns idag. Till skillnad från SaaS-alternativ som Zapier eller Make ger n8n dig full kontroll över dina data och automatiseringar – men bara om du själv står för driften. En Linux-VPS är den perfekta miljön för detta: alltid tillgänglig, prisvärd och helt under din kontroll.

Den här guiden leder dig genom hela processen för att konfigurera en produktionsklar, självhostad n8n-instans på en Linux-VPS. Du kommer att gå från en tom server till en helt säker, SSL-aktiverad n8n-installation med Docker, Nginx, PostgreSQL, automatiserade säkerhetskopior och en förstärkt säkerhetskonfiguration.

Viktiga punkter

• n8n på en VPS ger dig obegränsade arbetsflöden, inga användningsbegränsningar och full äganderätt till dina data
• Docker är den rekommenderade installationsmetoden för enklare uppdateringar och isolering
• PostgreSQL är den rekommenderade databasen för produktionsarbetsbelastningar (inte SQLite)
• En omvänd proxy (Nginx) med Let’s Encrypt SSL krävs för produktionsanvändning
• Din VPS bör ha minst 1 vCPU och 2 GB RAM för en smidig n8n-upplevelse med PostgreSQL
• Regelbundna automatiska säkerhetskopior skyddar dina arbetsflödesdata och inloggningsuppgifter

Vad är n8n?

n8n (uttalas ”n-åtta-n”) är en plattform för automatisering av arbetsflöden med öppen källkod som låter dig koppla samman appar, API:er och tjänster med hjälp av en visuell nodbaserad redigerare. Den stöder över 400 integrationer direkt och låter dig köra anpassad JavaScript- eller Python-kod inuti arbetsflödena.

Den viktigaste skillnaden mellan n8n och dess konkurrenter handlar om tre saker: äganderätt, kostnad och flexibilitet.

**Äganderätt: **När du själv hostar n8n lämnar dina arbetsflödesdata, inloggningsuppgifter och körloggar aldrig din server. För team som hanterar känslig kunddata, finansiella uppgifter eller företagsintern affärslogik är detta oerhört viktigt. Molnplattformar lagrar din automatiseringslogik på sin infrastruktur, vilket innebär att den omfattas av deras policyer för datalagring och säkerhetsnivå.

**Kostnad: **n8n:s molnplan debiterar per arbetsflödeskörning, vilket snabbt blir dyrt vid automatiseringar med hög volym. Ett medelstort team som kör tusentals körningar per dag kan spendera hundratals dollar varje månad. På din egen VPS är körningarna obegränsade utan extra kostnad, så snart du har betalat för servern.

**Flexibilitet: **Med n8n som du själv hostar kan du installera community-noder, köra valfri kod inuti arbetsflöden, ansluta till interna tjänster som inte är tillgängliga från det offentliga internet och konfigurera alla aspekter av driftsättningen efter eget tycke. Molnplanerna begränsar många av dessa möjligheter.

Förutsättningar

Innan du börjar, se till att du har:

• En Linux-VPS som kör Ubuntu 22.04 eller 24.04 (rekommenderas). Kontrollera att din leverantör erbjuder Ubuntu i det paket du väljer, eftersom vissa instegspaket endast erbjuder andra distributioner
• En icke-root-användare med sudo-behörighet
• Ett domännamn som pekar på din VPS-IP-adress (t.ex. n8n.dindomän.com)
• SSH-åtkomst till din server
• Grundläggande kunskaper om Linux-kommandoraden

Att välja rätt VPS

Vilken server du väljer har direkt inverkan på n8ns prestanda. Du behöver minst 1 vCPU, 2 GB RAM och 20 GB SSD-lagring. Det extra RAM-minnet jämfört med en minimal SQLite-baserad installation behövs eftersom PostgreSQL, Nginx och n8n alla körs samtidigt.

För team med flera användare, komplexa arbetsflöden i flera steg eller hög webhook-genomströmning bör du uppgradera till 2 vCPU och 4 GB RAM. Lagringsutrymmet bör vara minst 40 GB om du planerar att spara långa körloggar.

PetroSky erbjuder NVMe-VPS-paket i Paris och Montreal, där n8n finns tillgängligt som en ”one-click”-applikation vid utcheckningen: ett installationsskript med öppen källkod distribuerar n8n med Docker Compose och konfigurerar HTTPS automatiskt via Caddy och Let’s Encrypt. Den här guiden beskriver den manuella metoden, som fungerar hos vilken leverantör som helst.

När du väljer en VPS-leverantör bör du också ta hänsyn till den geografiska placeringen. Placera din n8n-instans i den region som ligger närmast de tjänster som den oftast kommer att ansluta till – detta minskar API-fördröjningen vid körning av dina arbetsflöden.

Steg 1: Uppdatera din server

Anslut via SSH till din VPS och kör en fullständig systemuppdatering innan du installerar något:

    sudo apt update && sudo apt upgrade -y

Detta säkerställer att du har de senaste säkerhetsuppdateringarna och att alla systembibliotek är uppdaterade innan du lägger till Docker och annan programvara.

Starta om om en kärnuppdatering har installerats:

    sudo reboot

När du har anslutit dig via SSH igen skapar du en dedikerad systemanvändare för att köra n8n. Att köra tjänster som root utgör en säkerhetsrisk:

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

Steg 2: Installera Docker och Docker Compose

n8ns officiellt rekommenderade installationsmetod är Docker. Docker isolerar n8n och dess beroenden från resten av systemet, vilket gör uppdateringar och återställningar enkla.

Installera Docker med hjälp av det officiella skriptet:

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

I Dockers dokumentation anges att det förberedda skriptet inte rekommenderas för produktionsmiljöer, eftersom det installerar den senaste versionen utan att du kan välja version. Om du vill låsa Docker-versioner använder du istället metoden med apt-repositoriet från Dockers installationsguide för Ubuntu (docs.docker.com/engine/install/ubuntu/).

Lägg till din användare i Docker-gruppen så att du kan köra Docker-kommandon utan sudo:

    sudo usermod -aG docker $USER
    newgrp docker

Kontrollera att Docker fungerar som det ska:

    docker --version
    docker compose version

Båda kommandona ska returnera versionssträngar utan fel. Om Docker Compose inte hittas, installera det manuellt:

    sudo apt install docker-compose-plugin -y

Steg 3: Konfigurera PostgreSQL för produktion

Som standard använder n8n SQLite som databas. SQLite fungerar bra för personligt bruk och enkla arbetsflöden, men hanterar samtidiga skrivningar dåligt, vilket visar sig i form av fördröjningar och felmeddelanden om att ”databasen är låst” när många arbetsflöden körs samtidigt. För en produktionsmiljö är PostgreSQL det rätta valet.

Kör PostgreSQL i Docker tillsammans med n8n:

    mkdir ~/n8n && cd ~/n8n

Skapa en miljöfil för att lagra dina hemliga uppgifter på ett säkert sätt. Skriv aldrig in lösenord direkt i din compose-fil:

    nano ~/n8n/.env

Lägg till följande och ersätt platshållarvärdena med starka, unika lösenord:

    POSTGRES_USER=n8n
    POSTGRES_PASSWORD=ditt_starka_databaslösenord_här
    POSTGRES_DB=n8n
    N8N_ENCRYPTION_KEY=din_slumpmässiga_sträng_på_32_tecken_här

Skapa en säker krypteringsnyckel med:

    openssl rand -hex 16

Använd utdata som din N8N_ENCRYPTION_KEY. Denna nyckel krypterar inloggningsuppgifter som lagras i n8n – om du tappar bort den blir alla sparade inloggningsuppgifter omöjliga att återställa.

Steg 4: Skapa n8n-filen för Docker Compose

Skapa filen docker-compose.yml i din n8n-katalog:

    nano ~/n8n/docker-compose.yml

Klistra in följande konfiguration:

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
      retries: 10


  n8n:
    image: docker.n8n.io/n8nio/n8n
    restart: always
    ports:
      - "127.0.0.1:5678:5678"
    environment:
      - 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:

Konfigurationsanvisningar:

• Portbindningen 127.0.0.1:5678:5678 säkerställer att n8n endast är tillgängligt lokalt. Nginx hanterar all extern trafik – exponera aldrig port 5678 direkt mot internet.
• depends_on med villkoret service_healthy säkerställer att n8n väntar tills PostgreSQL är helt klart innan det startar. Utan detta kommer n8n att misslyckas vid första uppstarten om databasen ännu inte accepterar anslutningar.
• N8N_LOG_LEVEL=info ger dig användbara driftsloggar utan att överbelasta diskutrymmet på samma sätt som debug skulle göra.

Steg 5: Installera och konfigurera Nginx

Nginx fungerar som en omvänd proxy och vidarebefordrar HTTPS-trafik från port 443 till din n8n-container på port 5678. Den hanterar även SSL-avslutning, vilket innebär att n8n själv inte behöver hantera certifikat.

    sudo apt install nginx -y

Ta bort standardsajten och skapa ett nytt serverblock för n8n:

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

Klistra in följande:

    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 av;
        proxy_read_timeout 90s;
        client_max_body_size 50m;
    }
}

Map-blocket högst upp hanterar WebSocket-uppgraderingsrubriker korrekt. n8n använder WebSockets för realtidsuppdateringar i redigeraren, så den här konfigurationen är viktig – utan den kommer den visuella redigeraren inte att fungera korrekt.

Direktivet client_max_body_size 50m gör det möjligt för arbetsflöden att ta emot stora webhook-payloads. Standardgränsen i Nginx är 1 MB, vilket är för lite för arbetsflöden som hanterar filuppladdningar eller stora JSON-svar.

Aktivera konfigurationen och testa den:

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

Steg 6: Utfärda ett SSL-certifikat med Let’s Encrypt

Installera Certbot och Nginx-plugin:

    sudo apt install certbot python3-certbot-nginx -y

Begär ett certifikat för din domän:

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

Följ anvisningarna. När du blir tillfrågad om du vill omdirigera HTTP-trafik till HTTPS väljer du Ja (alternativ 2). Certbot uppdaterar automatiskt din Nginx-konfiguration för att hantera denna omdirigering och installerar hela certifikatkedjan.

Kontrollera att automatisk förnyelse är korrekt konfigurerad:

    sudo certbot renew --dry-run

Certbot installerar en systemd-timer som förnyar certifikaten automatiskt var 12:e timme. Certifikaten förnyas när de har mindre än 30 dagar kvar till utgångsdatumet. Du bör aldrig behöva förnya dem manuellt.

Steg 7: Starta n8n

Gå tillbaka till din n8n-katalog och starta alla tjänster:

    cd ~/n8n
    docker compose up -d

Docker hämtar PostgreSQL- och n8n-bilderna, skapar volymerna, startar först PostgreSQL, väntar tills hälsokontrollen har godkänts och startar sedan n8n. Denna process tar 1–3 minuter vid första körningen.

Kontrollera att båda containrarna körs:

    docker compose ps

Du bör se både postgres och n8n listade med statusen Up. Om n8n visar Restarting, kontrollera loggarna:

    docker compose logs n8n --tail=50

När båda containrarna är i gott skick öppnar du webbläsaren och navigerar till https://n8n.yourdomain.com. Du ombeds att skapa ett ägarkonto med en e-postadress och ett lösenord. Detta konto har fullständig administratörsåtkomst till din n8n-instans.

Steg 8: Konfigurera n8n så att det startar vid uppstart

Direktivet restart: always i din docker-compose.yml säkerställer att alla containrar startas om automatiskt vid krasch eller omstart av servern.

Kontrollera detta genom att starta om servern:

    sudo reboot

När du har anslutit dig via SSH igen, kontrollera att n8n startade om automatiskt:

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

Båda containrarna bör visas som aktiva utan någon manuell inblandning.

Steg 9: Konfigurera automatiska säkerhetskopior

Dina n8n-data – arbetsflöden, inloggningsuppgifter och körhistorik – finns på två ställen: PostgreSQL-databasen och Docker-volymen n8n_data (som lagrar krypteringsnycklar och viss konfiguration). Säkerhetskopiera båda regelbundet.

Skapa ett säkerhetskopieringsskript:

    nano ~/n8n/backup.sh

Klistra in följande:

    #!/bin/bash
    BACKUP_DIR="/home/n8nuser/backups"
    DATE=$(date +%Y-%m-%d_%H-%M)
    LOG_FILE="$BACKUP_DIR/backup.log"
# Kontrollera att säkerhetskopieringsmappen finns innan du gör något annat
mkdir -p "$BACKUP_DIR"


# Dumpa PostgreSQL
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"


# Kontrollera att dumpningen lyckades och att filen inte är tom
if [ $? -ne 0 ] || [ ! -s "$DUMP_FILE" ]; then
    echo "FEL: Databasbackup misslyckades den $DATE" >> "$LOG_FILE"
    rm -f "$DUMP_FILE"
    exit 1
fi


# Säkerhetskopiera krypteringsnyckeln och miljövariablerna
cp /home/n8nuser/n8n/.env "$BACKUP_DIR/n8n_env_$DATE.bak"
# Säkerhetskopiera volymen n8n_data (instanskonfiguration och installerade community-noder)
docker run --rm -v n8n_n8n_data:/data -v "$BACKUP_DIR":/backup alpine \
  tar czf /backup/n8n_data_$DATE.tar.gz -C /data .


# Komprimera databasdumpen
gzip "$DUMP_FILE"


# Behåll endast säkerhetskopior från de senaste 7 dagarna
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 "Säkerhetskopiering slutförd: n8n_db_$DATE.sql.gz" >> "$LOG_FILE"

Volymnamnet n8n_n8n_data kommer från att Docker Compose lägger till projektmappens namn (n8n) som prefix till volymen. Kontrollera ditt med docker volume ls.

Gör skriptet körbart och schemalägg det med cron:

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

Lägg till den här raden för att köra säkerhetskopieringen varje dag kl. 02:00:

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

För redundans utanför anläggningen kan du överväga att synkronisera din säkerhetskopieringskatalog till en S3-kompatibel objektlagringsleverantör med hjälp av rclone eller aws s3 sync.

Steg 10: Aktivera grundläggande säkerhetsförstärkning

Konfigurera en brandvägg

Installera UFW och tillåt endast de portar som din server behöver:

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

Kontrollera att reglerna är aktiva:

    sudo ufw status verbose

Du bör se att port 22 (SSH), 80 (HTTP) och 443 (HTTPS) är tillåtna. En varning: Docker skriver sina egna brandväggsregler och kringgår UFW för publicerade containerportar. Port 5678 förblir privat eftersom compose-filen binder den till 127.0.0.1, inte på grund av UFW, så ändra aldrig den bindningen till 0.0.0.0.

Inaktivera lösenordsautentisering för SSH

Om du använder SSH-nycklar (vilket du bör göra) ska du inaktivera lösenordsbaserad SSH-inloggning helt och hållet. Se först till att kontot n8nuser kan logga in med din nyckel. Kör följande från din lokala dator:

    ssh-copy-id n8nuser@din_server_ip

Redigera sedan SSH-serverns konfiguration:

    sudo nano /etc/ssh/sshd_config

Ange följande värden:

    PasswordAuthentication no
    PermitRootLogin no
    sudo systemctl restart ssh

På många Ubuntu-molnbilder anger en fil i /etc/ssh/sshd_config.d/ (ofta 50-cloud-init.conf) PasswordAuthentication yes, och den har företräde eftersom sshd använder det första värdet den läser. Kontrollera vilken inställning som faktiskt gäller:

    sudo sshd -T | grep -i passwordauthentication

Det bör visa passwordauthentication no. Om så inte är fallet, ändra värdet i överskrivningsfilen och starta om SSH igen.

Stäng inte din aktuella SSH-session förrän du har verifierat att nyckelbaserad inloggning fungerar i ett nytt terminalfönster.

Begränsa antalet förfrågningar till n8n-inloggningssidan

Lägg till hastighetsbegränsning för att bromsa brute-force-attacker mot n8n-inloggningsändpunkten.

**Viktigt: **Direktivet limit_req_zone måste placeras inuti http {}-blocket i din huvudkonfiguration för Nginx — inte inuti serverblocket. Öppna huvudkonfigurationen:

    sudo nano /etc/nginx/nginx.conf

Lägg till följande rad inuti det befintliga http {}-blocket:

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

Lägg sedan till detta location-block i din n8n-webbplatskonfiguration (/etc/nginx/sites-available/n8n) inuti serverblocket som lyssnar på port 443 (Certbot skapade det i steg 6), bredvid den befintliga location /. Nginx överför inte proxy-rubriker från location /, så de upprepas här:

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

Starta om Nginx för att tillämpa ändringarna:

    sudo nginx -t && sudo systemctl reload nginx

Detta begränsar varje IP-adress till ungefär 5 inloggningsförsök per minut, med en liten tolerans för tillfälliga toppar.

Håll n8n och PostgreSQL uppdaterade

Hämta och starta om med de senaste bilderna regelbundet:

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

Docker hämtar de senaste n8nio/n8n- och postgres-bilderna och startar om endast de containrar för vilka en nyare version finns tillgänglig.

För produktion bör du överväga att låsa n8n-bilden till en specifik versionstagg (docker.n8n.io/n8nio/n8n:<version>, hämtad från n8ns release notes) och uppgradera medvetet, så att en rutinmässig hämtning aldrig hoppar över en huvudversion innan du har läst ändringsloggen.

Felsökning av vanliga problem

n8n-containern startar om hela tiden

Kontrollera containerloggarna omedelbart efter att omstartsloopen har börjat:

    docker compose logs n8n --tail=100

Vanliga orsaker:

• Fel vid databasanslutning: Kontrollera att PostgreSQL fungerar som det ska med docker compose ps. Kontrollera att POSTGRES_PASSWORD i din .env-fil stämmer överens med det lösenord som databasen initialiserades med.
• Krypteringsnyckel saknas eller har ändrats: Om N8N_ENCRYPTION_KEY inte är inställt eller har ändrats efter den första körningen kan n8n inte dekryptera lagrade inloggningsuppgifter och kommer att krascha.
• Otillräckligt RAM-minne: PostgreSQL och n8n kan tillsammans använda 1–1,5 GB RAM-minne. Kontrollera tillgängligt minne med `free -h`.

Webhooks fungerar inte

Webhooks kräver att n8n är nåbart från internet på din domän. Kontrollera:

1. Din domäns DNS A-post pekar på din VPS-IP: dig n8n.yourdomain.com
2. Nginx körs: sudo systemctl status nginx
3. Port 443 är öppen: sudo ufw status
4. Miljövariabeln WEBHOOK_URL stämmer exakt överens med din offentliga domän, inklusive den avslutande snedstrecken

n8n-redigeraren laddas inte korrekt

Om den visuella redigeraren laddas men visar en tom arbetsflödesyta eller om realtidsuppdateringarna slutar fungera, har WebSocket-anslutningen misslyckats. Kontrollera att blocket $http_upgrade finns i din Nginx-konfiguration och att du använder variabeln $connection_upgrade — inte den bokstavliga strängen ”upgrade” — i raden proxy_set_header Connection.

SSL-certifikatfel

Om Certbot misslyckas med ett domänvalideringsfel, kontrollera att port 80 är tillgänglig från internet:

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

Om begäran går ut kan det bero på att din VPS-leverantörs brandvägg blockerar port 80. Kontrollera brandväggsreglerna i molnkonsolen utöver UFW.

Slutsats

Att själv driva n8n på en Linux-VPS ger dig en produktionsklar plattform för automatisering av arbetsflöden utan exekveringsbegränsningar, fullständig dataintegritet och flexibiliteten att köra vilken integration du än behöver. Den installation som beskrivs i den här guiden – Docker, PostgreSQL, Nginx-reversproxy, Let’s Encrypt SSL, automatiserade säkerhetskopior och säkerhetsförstärkning – är samma stack som används i produktionsmiljöer och ger dig en stabil, säker grund att bygga vidare på.

Till skillnad från en minimal installation med Docker-kommandot `run` är denna konfiguration byggd för att klara omstarter av servern, hantera samtidiga arbetsflödeskörningar och återhämta sig smidigt efter fel. Dina inloggningsuppgifter är krypterade, dina data säkerhetskopieras varje natt och din inloggningsändpunkt är hastighetsbegränsad för att skydda mot brute force-attacker.

När din instans är igång kan du utforska n8ns inbyggda noder för databaser, API:er, webhooks och AI-integrationer för att omedelbart börja automatisera dina arbetsflöden. Det självhostade communityforumet på community.n8n.io är också en utmärkt resurs för idéer till arbetsflöden, felsökning av noder och tips om driftsättning.