Fullstackontwikkeling met Next.js 15 (App Router + Server Actions) · Les

Afwegingen tussen Node Runtime en Edge Runtime

Kies per route tussen Node en Edge op basis van cold starts, beschikbare API’s en geografische latentie.

Les 2 van 413 stappen

Afwegingen tussen Node Runtime en Edge Runtime is een gratis Fullstackontwikkeling met Next.js 15 (App Router + Server Actions)-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Fullstackontwikkeling met Next.js 15 (App Router + Server Actions). Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Fullstackontwikkeling met Next.js 15 (App Router + Server Actions) bevat in totaal 4 lessen.

Twee runtimes, één routehandler

In Next.js 15 draait elke routehandler (app/api/.../route.ts) op een van twee runtimes: de Node.js-runtime (de standaard) of de Edge-runtime.

Node-runtime — een volledige Node.js-server. Toegang tot alle Node-API's, npm-pakketten, het bestandssysteem en TCP-sockets.
Edge-runtime — een lichte, op V8 gebaseerde omgeving (alleen Web-API's) die op veel locaties dicht bij je gebruikers kan worden uitgevoerd.

Je kiest de runtime per route met één export, zodat verschillende eindpunten in dezelfde app verschillende runtimes kunnen gebruiken.

// app/api/hello/route.ts
import { NextResponse } from 'next/server';

// Opt this route into the Edge runtime
export const runtime = 'edge';

export async function GET() {
  return NextResponse.json({ message: 'Hello from the Edge' });
}

De standaard is Node

Als je runtime niet instelt, draait de routehandler op de Node.js-runtime. Dit is de veilige standaard voor het meeste fullstackwerk, omdat deze je database-drivers, ORM's (Prisma, Drizzle) en npm-bibliotheken ondersteunt.

Je kiest alleen voor Edge wanneer de specifieke voordelen daarvan (lage latentie, snelle koude starts, geografische spreiding) belangrijker zijn dan de API's die je daardoor niet kunt gebruiken.

// app/api/users/route.ts
import { NextResponse } from 'next/server';
import { db } from '@/lib/db'; // e.g. Prisma / Drizzle

// No runtime export => Node.js runtime (default)
export async function GET() {
  const users = await db.user.findMany();
  return NextResponse.json(users);
}

Koude starts: waarom Edge sneller aanvoelt

Een koude start is de vertraging wanneer een serverloze functie moet opstarten voordat deze een request kan verwerken.

Node-functies starten een Node.js-proces op — zwaardere en tragere koude starts (vaak tientallen tot honderden ms).
Edge-functies draaien in een V8-isolate die in ongeveer een milliseconde opstart — vrijwel zonder koude start.

Voor routes met weinig verkeer of piekverkeer (webhooks, authenticatiecontroles, omleidingen) voorkomt Edge de straf van de 'eerste request is traag' waar Node-functies last van kunnen hebben.

Geografische latentie

Serverloze Node-functies draaien meestal in één regio (de regio waarin je ze hebt geïmplementeerd). Een gebruiker in Tokio die een functie in Virginia aanroept, legt een volledige retourafstand rond de planeet af.

Edge-functies worden wereldwijd gerepliceerd en uitgevoerd op de locatie die het dichtst bij de gebruiker ligt. Voor latentiegevoelig werk dat weinig rekenkracht vereist, verkort dit de responstijd aanzienlijk.

Let op: als je Edge-functie vervolgens een database in één verre regio aanroept, heb je de latentie alleen verplaatst. Edge biedt vooral voordeel wanneer er weinig of geen gegevens uit de oorspronkelijke bron nodig zijn, of wanneer je een wereldwijd verspreide gegevensopslag gebruikt.

Wat Edge niet kan

De Edge-runtime stelt alleen Webstandaard-API's beschikbaar (fetch, Request, Response, crypto.subtle, TextEncoder, ...). Node-ingebouwde modules zijn niet beschikbaar.

Geen fs, geen net en geen onbewerkte TCP-sockets.
Pakketten met native/C++-add-ons werken niet.
Veel database-drivers die TCP gebruiken (de standaard pg, mysql2) werken niet rechtstreeks.

Als een route een bibliotheek importeert die deze mogelijkheden nodig heeft, houd je die route op Node.

// This FAILS on the Edge runtime:
// import fs from 'node:fs';   // 'fs' is not available
// import { Pool } from 'pg';  // raw TCP socket not supported

// Edge-friendly work uses Web APIs only:
export const runtime = 'edge';

export async function GET() {
  const data = await fetch('https://api.example.com/feed').then(r => r.json());
  return Response.json(data);
}

Databases op Edge

Omdat Edge geen onbewerkte TCP-verbindingen kan openen, bereik je databases via HTTP-gebaseerde drivers.

Neon serverless-driver (@neondatabase/serverless) — Postgres via HTTP/WebSocket.
Vercel Postgres / Turso (libSQL) / Upstash Redis — allemaal gebaseerd op HTTP-fetch.
Prisma met Accelerate of een serverloze adapter.

Als je stack een klassieke gepoolde TCP-verbinding gebruikt, hoort die route op Node.

// app/api/count/route.ts
import { neon } from '@neondatabase/serverless';

export const runtime = 'edge';

const sql = neon(process.env.DATABASE_URL!); // HTTP-based, Edge-safe

export async function GET() {
  const rows = await sql`SELECT count(*) AS total FROM visits`;
  return Response.json({ total: rows[0].total });
}

Streaming en langdurig werk

Beide runtimes kunnen antwoorden streamen, maar hun uitvoeringslimieten verschillen.

Edge is geoptimaliseerd voor korte, snelle antwoorden en streaming (ideaal voor het doorsturen van AI-tokenstromen). De limieten voor CPU-tijd en bundelgrootte zijn strenger.
Node kan langer durende, zwaardere berekeningen en grote afhankelijkheidsbomen uitvoeren en ondersteunt patronen die beter geschikt zijn voor achtergrondtaken.

Een route die een grote payload verwerkt, een PDF genereert of een zware bibliotheek uitvoert, hoort op Node te blijven.

// Streaming a response works on either runtime
export const runtime = 'edge';

export async function GET() {
  const stream = new ReadableStream({
    start(controller) {
      const enc = new TextEncoder();
      controller.enqueue(enc.encode('chunk-1\n'));
      controller.enqueue(enc.encode('chunk-2\n'));
      controller.close();
    },
  });
  return new Response(stream, { headers: { 'Content-Type': 'text/plain' } });
}

Een fragment voor het web dat je kunt uitvoeren

Edge-code gebruikt uitsluitend Web API's, wat betekent dat de kernlogica gewone TypeScript is die overal draait. Hier is een zelfstandig voorbeeld met crypto.subtle en TextEncoder — precies het soort code dat veilig is voor Edge omdat er geen ingebouwde Node-functionaliteit voor nodig is.

// Standalone: hash a string using only Web Crypto APIs
async function sha256Hex(input: string): Promise<string> {
  const data = new TextEncoder().encode(input);
  const digest = await crypto.subtle.digest('SHA-256', data);
  return Array.from(new Uint8Array(digest))
    .map((b) => b.toString(16).padStart(2, '0'))
    .join('');
}

async function main() {
  const hash = await sha256Hex('edge-runtime');
  console.log(hash);
}

main();

Een hulpmiddel bij beslissingen

Soms helpt het om de afweging in een eenvoudige regel vast te leggen. De functie hieronder geeft op basis van enkele feiten over een route een aanbeveling voor de runtime. Dit is gewone TypeScript-logica die je kunt begrijpen en uitvoeren.

type RouteNeeds = {
  usesNodeApis: boolean;     // fs, net, native addons
  usesTcpDatabase: boolean;  // classic pg/mysql driver
  latencySensitive: boolean; // users worldwide, light compute
  heavyCompute: boolean;     // big payloads, PDF, large deps
};

function recommendRuntime(r: RouteNeeds): 'node' | 'edge' {
  if (r.usesNodeApis || r.usesTcpDatabase || r.heavyCompute) return 'node';
  if (r.latencySensitive) return 'edge';
  return 'node';
}

console.log(recommendRuntime({ usesNodeApis: false, usesTcpDatabase: false, latencySensitive: true, heavyCompute: false }));
console.log(recommendRuntime({ usesNodeApis: false, usesTcpDatabase: true, latencySensitive: true, heavyCompute: false }));

Runtimes combineren in één app

Het grote voordeel van runtimes per route is dat je ze kunt combineren. Een typische Next.js 15-app kan het volgende gebruiken:

Controles van authenticatie en sessies, omleidingen, A/B-vlaggen, lichte proxy's → Edge.
Databasebewerkingen via Prisma, bestandsverwerking, SDK's van derden → Node.

Let op: Server Actions worden uitgevoerd op de Node.js-runtime in de App Router — de opt-in voor Edge die hier wordt getoond, geldt voor Route Handlers en Middleware, niet voor Server Actions.

// app/api/flag/route.ts  -> Edge: fast, global, no DB
export const runtime = 'edge';
export async function GET(req: Request) {
  const country = req.headers.get('x-vercel-ip-country') ?? 'US';
  return Response.json({ promoEnabled: country === 'US' });
}

Geo-context van Edge uitlezen

Edge draait dicht bij de gebruiker en is daarom de logische plek voor geobewuste logica. Op Vercel komt geodata binnen als aanvraagheaders (x-vercel-ip-country, x-vercel-ip-city). Je kunt inhoud lokaliseren of omleiden zonder een retour naar een centrale server.

Als je voor elke aanvraag een database-opzoeking nodig hebt, wordt het voordeel van Edge kleiner — gebruik Edge dus voor situaties waarin de beslissing goedkoop is en de gegevens lokaal of in de cache staan.

// app/api/welcome/route.ts
export const runtime = 'edge';

export async function GET(req: Request) {
  const country = req.headers.get('x-vercel-ip-country') ?? 'unknown';
  const greeting = country === 'FR' ? 'Bonjour' : 'Hello';
  return Response.json({ greeting, country });
}

Korte controle

Kies de route die het meest geschikt is voor de Edge-runtime.

Beantwoord dit in de interactieve les

Samenvatting: per route kiezen

Je kiest nu de runtime per route op basis van concrete afwegingen:

Edge — vrijwel geen koude starts, wereldwijd lage latentie, alleen Web API's. Het beste voor lichte, geobewuste routes waarvoor weinig gegevens nodig zijn (vlaggen, omleidingen, authenticatiecontroles, streamproxy's).
Node (standaard) — volledige Node-API's, npm-pakketten, TCP-databases, zware berekeningen en grote afhankelijkheden.

Beslis aan de hand van concrete vragen: zijn Node-API's of een TCP-databasestuurprogramma nodig? Gaat het om zware berekeningen? Zo ja → Node. Is het licht en wereldwijd gevoelig voor latentie? → Edge. En onthoud: Server Actions draaien op Node; de opt-in runtime = 'edge' is bedoeld voor Route Handlers en Middleware.

Gratis beginnen

Leer TypeScript met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 22
Lessen: 88

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Afwegingen tussen Node Runtime en Edge Runtime” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Fullstackontwikkeling met Next.js 15 (App Router + Server Actions), waaronder “Afwegingen tussen Node Runtime en Edge Runtime”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Fullstackontwikkeling met Next.js 15 (App Router + Server Actions) bevat in totaal 4 lessen.

Wat leer ik in “Afwegingen tussen Node Runtime en Edge Runtime”?

Kies per route tussen Node en Edge op basis van cold starts, beschikbare API’s en geografische latentie. Je oefent met Fullstackontwikkeling met Next.js 15 (App Router + Server Actions) door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Fullstackontwikkeling met Next.js 15 (App Router + Server Actions) te beginnen?

Ervaring vooraf is niet nodig. Fullstackontwikkeling met Next.js 15 (App Router + Server Actions) op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Afwegingen tussen Node Runtime en Edge Runtime”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Fullstackontwikkeling met Next.js 15 (App Router + Server Actions)?

Ja. Elke les over Fullstackontwikkeling met Next.js 15 (App Router + Server Actions) bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

RESTful route handlers ontwerpen met de Web Request API
Afwegingen tussen Node Runtime en Edge Runtime
Responses streamen en ReadableStream in handlers
Requestvalidatie en getypeerde JSON-responses met Zod

← Terug naar Fullstackontwikkeling met Next.js 15 (App Router + Server Actions)