Kom igång
Alla inläggGUIDE · 7 MIN LÄSNING

Publicera din Node.js-app på Rivervos webbhotell (Next.js och Nuxt).

RT
Rivervo Team · Rivervo
·
29 april 2026
·
Uppdaterad 13 november 2026
Node
ON SHARED HOSTING

Många tror att Node.js-appar måste ligga på en VPS. Det behöver de inte — alla Rivervos webbhotellspaket har Node.js och Python i webbplatsmenyn, som startar en Phusion Passenger-process för din app bakom samma Apache som betjänar dina andra sidor.

Den här guiden går igenom hela flödet för de två vanligaste ramverken: Next.js och Nuxt 3. Slutresultatet: din app på https://dindoman.se (eller valfri underdomän), som körs i en riktig Node.js-process, klarar omstarter och kan startas om med ett klick.

Har du aldrig lagt ut en Node-app på ett webbhotell förut är det startfilen som alla fastnar på — Passenger behöver ett enda startskript som drar igång ditt ramverk. Vi ger dig ett för varje ramverk nedan; kopiera och klistra in, inga ändringar behövs.

Det här behöver du innan du börjar

  • Ett webbhotellspaket hos Rivervo (vilket som helst — Node.js-appar fungerar i alla paket)
  • Node.js v20 eller nyare lokalt för att bygga din app
  • Den byggda appen, klar att laddas upp (vi går igenom det per ramverk)
  • Tillgång till filhanteraren eller SFTP på ditt konto (båda fungerar)

Du behöver inte root, sudo, systemd eller en konfiguration för omvänd proxy. Passenger sköter allt det.

Steg 1 — bygg din app lokalt

Du ska ladda upp en byggd app, inte källkoden. Panelen installerar beroenden, men den kompilerar inte React och kör inte en Vite-build. Gör det på din egen dator först.

Next.js:

npm ci
npm run build

Det ger .next/ (det byggda resultatet). Kör inte next start här — vi startar den från startfilen om en stund.

Nuxt 3:

npm ci
npm run build

Det ger .output/ (Nuxts universella build-katalog). Samma sak — kör ingenting än.

Steg 2 — ladda upp rätt filer

Du behöver inte ladda upp node_modules/. Panelen installerar beroendena åt dig. Du behöver inte heller git eller build-cacher.

Ladda upp till ditt konto, helst till en sökväg utanför public_html (t.ex. /home/<konto>/myapp/). Varför utanför? Passenger monterar public_html på adressens rot automatiskt, och lägger du appkoden där blir den synlig.

RamverkLadda uppHoppa över
Next.js.next/, public/, package.json, package-lock.json, next.config.js, din server.cjs (nedan)node_modules/, .git/, .env.local
Nuxt 3.output/, package.json, package-lock.json, din server.cjs (nedan)node_modules/, .nuxt/, .git/, källkatalogerna pages/, components/

Två sätt att få upp filerna:

  • Webbplats → Filer → ladda upp en zip-fil → packa upp den är enklast om din uppkoppling är ostadig.
  • SFTP (FileZilla, Cyberduck, rsync) går snabbare vid upprepade uppladdningar. Server, port, användare och lösenord finns under Webbplats → SSH och SFTP.

Steg 3 — lägg till startfilen

Det här är filen som Passenger kör när en förfrågan kommer in. Lägg den bredvid package.json i din appmapp.

För Next.js — server.cjs

const next = require('next')
const http = require('http')
 
const port = process.env.PORT || 3000
const dev = process.env.NODE_ENV !== 'production'
const app = next({ dev, dir: __dirname })
const handle = app.getRequestHandler()
 
app.prepare().then(() => {
  http.createServer((req, res) => handle(req, res)).listen(port, () => {
    console.log(`Next.js server listening on port ${port}`)
  })
})

Vad den gör:

  • Laddar Next och pekar den på aktuell katalog (där din .next/ och package.json ligger).
  • Bygger en hanterare för förfrågningar från Nexts interna router.
  • Startar en HTTP-server på porten som Passenger tilldelar (process.env.PORT).
  • Faller tillbaka på 3000 vid lokal testning.

dev räknas fram automatiskt från NODE_ENV — välj läget Production i panelen (det gör vi i steg 4) så körs Next i produktionsläge.

För Nuxt 3 — server.cjs

import('./.output/server/index.mjs').then(({ createApp }) => {
  createApp().then(({ app }) => {
    const port = process.env.PORT || 3000
    app.listen(port, () => {
      console.log(`Nuxt server listening on port ${port}`)
    })
  })
})

Vad den gör:

  • Importerar dynamiskt Nuxts .output/server/index.mjs (startpunkten som npm run build skapar).
  • Använder createApp() för att bygga H3-serverinstansen.
  • Lyssnar på porten som Passenger tilldelar.

Den dynamiska import() är avsiktlig — .mjs-moduler kan inte laddas med require(), men en .cjs-fil kan importera dem dynamiskt. Det är det renaste mönstret som fungerar i Passengers startprogram.

Steg 4 — skapa applikationen i panelen

Öppna ditt projekt → Webbplats → Node.js och Python → Node.js-applikation.

FältVärde
Version20 eller nyare
LägeProduction
Mappmyapp i din hemkatalog (dit du laddade upp filerna)
Adressdindoman.se (eller en underdomän som app.dindoman.se)
Startfilserver.cjs

Klicka på Skapa. En Node.js-miljö skapas under ~/nodevenv/myapp/20/.

Installera beroenden

När appen har skapats klickar du på Installera beroenden (npm install) på den och följer utskriften. Om det misslyckas:

  • Kontrollera att package.json ligger i applikationens rot (inte i en undermapp).
  • För Next.js: kontrollera att next finns under dependencies, inte devDependencies (en produktionsinstallation hoppar över utvecklingsberoenden).
  • För Nuxt: även nuxt ska vara ett vanligt beroende.

Lägg till miljövariabler

Appens Inställningar → Miljövariabler → Lägg till en variabel. Läget Production sätter redan NODE_ENV=production.

För Next.js-appar som läser värden vid körning (databasadresser, API-nycklar) lägger du till dem här. Skicka inte med en .env-fil med hemligheter — appens miljövariabler är rätt ställe.

När du sparar inställningarna startas appen om, så de nya variablerna gäller direkt.

Steg 5 — kontrollera

Besök din applikations adress. Du ska se din app.

Ser du en felsida från Passenger, fäll ut den och titta längst ner — där finns nästan alltid en tydlig stackspårning. De två vanligaste:

Error: Cannot find module 'next' — npm install kördes inte, eller kördes i fel mapp. Klicka på Installera beroenden (npm install) igen.

Error: ENOENT: no such file or directory, open '.next/...' — du laddade upp källkoden men inte den byggda katalogen .next/. Bygg lokalt och ladda upp igen.

Så publicerar du uppdateringar

Upprepa steg 1 och 2 och klicka på Starta om på appen. Konkret:

1. Bygg lokalt      npm run build
2. Ladda upp        .next/ eller .output/, plus ändrad källkod/konfiguration
3. Panelen          Starta om appen

Ändrar du package.json, klicka på Installera beroenden (npm install) innan du startar om. Föredrar du kommandoraden? Webbplats → Terminal: appens kort visar kommandot för att gå in i dess miljö.

Vanliga fallgropar

WebSockets: Passenger hanterar HTTP/1.1 och HTTP/2. WebSocket-uppgradering fungerar för de inbyggda routerna i Next.js och Nuxt. Använder du en separat WebSocket-server (ws, socket.io) delar den samma port och startas via samma server.cjs — ingen extra konfiguration.

Filuppladdningar / gränser för body-parser i next.config.js: Passengers standardgräns för en förfrågans innehåll är 10 MB. Laddar du upp stora filer kan du höja passenger_max_request_size via .htaccess i public_html:

PassengerMaxRequestSize 52428800

(50 MB i byte.)

Cron-jobb: behöver din app bakgrundsjobb (utskick av nyhetsbrev, schemalagda exporter), kör dem inte i webbprocessen. Använd Webbplats → Cron-jobb för att köra ett Node-skript direkt:

/home/<konto>/nodevenv/myapp/20/bin/node /home/<konto>/myapp/scripts/send-newsletter.js

Processminne: Passenger startar om din app om den går över kontots RAM-gräns (beror på ditt paket). En typisk Next.js- eller Nuxt-app använder under 100 MB i vila. Slår du i taket, profilera med process.memoryUsage() och leta efter läckor innan du drar slutsatsen att du behöver ett större paket.

Egna domäner och HTTPS: adressen du anger för appen är den som Passenger binder. SSL ordnas automatiskt — ingen extra konfiguration. För en annan domän eller en underdomän lägger du först till den under Webbplats → Domäner och väljer den sedan som appens adress.

Node-version: listan Version visar alla installerade versioner; byt i appens Inställningar.

När du inte ska köra Node på ett webbhotell

Helt ärligt — Node.js på webbhotell fungerar utmärkt för portfoliosidor, bloggar, marknadsföringssidor, små SaaS-gränssnitt och interna verktyg. Det har svårt med:

  • API:er med hög genomströmning (>50 förfrågningar/s över tid) — du märker kontots CPU-gräns
  • Appar med mycket WebSocket-trafik och tusentals samtidiga anslutningar
  • Appar som startar arbetsprocesser (köhanterare, skrapor) — Passengers processbudget per konto gör det krångligt
  • Allt som kräver systemd, Docker eller root-åtkomst

För sådant är vår VPS rätt väg — full root, egen kärna, kör vad du vill. Men för de flesta Next.js- och Nuxt-appar som inte tar emot enorma mängder trafik är den här guiden allt du behöver.

Kort sagt

  1. npm run build lokalt
  2. Ladda upp .next/ (Next) eller .output/ (Nuxt) + package.json + server.cjs
  3. Webbplats → Node.js och Python → Node.js-applikation → mappen, startfil server.cjs, läge Production
  4. Installera beroenden (npm install), sedan Starta om

Krånglar något, skicka in ett ärende — klistra in felsidan från Passenger så pekar vi ut raden.

— Rivervo-teamet