Next.js 15 fullstack (App Router + Server Actions) · leksjon

Avveininger mellom Node-runtime og Edge-runtime

Velg mellom Node og Edge per rute basert på kaldstart, tilgjengelige API-er og geografisk forsinkelse.

Leksjon 2 av 413 trinn

Avveininger mellom Node-runtime og Edge-runtime er en gratis leksjon i Next.js 15 fullstack (App Router + Server Actions) på CoddyKit. Dette er leksjon 2 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Next.js 15 fullstack (App Router + Server Actions), og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Next.js 15 fullstack (App Router + Server Actions) inneholder totalt 4 leksjoner.

To runtime-miljøer, én Route Handler

I Next.js 15 kjører hver Route Handler (app/api/.../route.ts) i ett av to runtime-miljøer: Node.js-runtime-miljøet (standard) eller Edge-runtime-miljøet.

Node-runtime-miljøet – en fullverdig Node.js-server med tilgang til alle Node-API-er, npm-pakker, filsystemet og TCP-sockets.
Edge-runtime-miljøet – et lett V8-basert miljø (bare Web-API-er) som distribueres til mange steder nær brukerne dine.

Du velger runtime per rute med én enkelt eksport, slik at ulike endepunkter i samme app kan bruke ulike runtime-miljøer.

// 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' });
}

Standardverdien er Node

Hvis du ikke angir runtime, kjører handleren i Node.js-runtime-miljøet. Dette er standardvalget for det meste av fullstack-utvikling, fordi det støtter database-drivere, ORM-er (Prisma, Drizzle) og alle npm-biblioteker.

Du velger bare Edge når de spesifikke fordelene (lav forsinkelse, rask oppstart etter inaktivitet og geografisk distribusjon) er viktigere enn API-ene du gir avkall på.

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

Oppstart etter inaktivitet: Hvorfor Edge føles raskere

En cold start er forsinkelsen som oppstår når en serverless-funksjon må starte opp før den kan håndtere en forespørsel.

Node-funksjoner starter en Node.js-prosess – tyngre og langsommere oppstarter etter inaktivitet (ofte titalls til hundrevis av ms).
Edge-funksjoner kjører i en V8-isolat som starter på omtrent ett millisekund – nesten ingen oppstartsforsinkelse.

For ruter med lite eller ujevnt trafikk (webhooks, autentiseringskontroller og omdirigeringer) unngår Edge ulempen med at "den første forespørselen er treg", som Node-funksjoner kan ha.

Geografisk forsinkelse

Node-serverless-funksjoner kjører vanligvis i én region (regionen du distribuerte til). En bruker i Tokyo som treffer en funksjon i Virginia, må betale for en full rundtur på tvers av kloden.

Edge-funksjoner er replikert globalt og kjører på stedet nærmest brukeren. For tidskritisk arbeid med lite beregning reduserer dette svartiden betydelig.

Viktig forbehold: Hvis Edge-funksjonen deretter kaller en database i én fjerntliggende region, har du bare flyttet forsinkelsen. Edge gir størst fordel når funksjonen trenger lite eller ingen data fra opprinnelsen, eller kommuniserer med et globalt distribuert datalager.

Hva Edge ikke kan gjøre

Edge-runtime-miljøet eksponerer bare Web-standard-API-er (fetch, Request, Response, crypto.subtle, TextEncoder, ...). Det inneholder ikke innebygde Node-moduler.

Ingen fs, ingen net og ingen rå TCP-sockets.
Pakker med native/C++-tillegg kan ikke kjøre.
Mange database-drivere som bruker TCP (standardvariantene pg og mysql2) fungerer ikke direkte.

Hvis en rute importerer et bibliotek som trenger dette, bør du la den kjøre på 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);
}

Databaser på Edge

Fordi Edge ikke kan åpne rå TCP-forbindelser, kobler du til databaser via HTTP-baserte drivere i stedet.

Neon serverless-driver (@neondatabase/serverless) – Postgres over HTTP/WebSocket.
Vercel Postgres / Turso (libSQL) / Upstash Redis – alle er basert på HTTP Fetch.
Prisma med Accelerate eller en serverless-adapter.

Hvis teknologistakken din bruker en klassisk, samlet TCP-forbindelse, hører ruten hjemme på 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 });
}

Strømming og langvarig arbeid

Begge kjøretidsmiljøene kan strømme svar, men grensene for kjøring er forskjellige.

Edge er optimalisert for korte, raske svar og strømming (svært godt egnet til å videresende AI-tokenstrømmer). Det har strengere grenser for CPU-tid og pakkestørrelse.
Node kan kjøre lengre og tyngre beregninger og store avhengighetstrær, og støtter mønstre som egner seg bedre for bakgrunnskjøring.

En rute som behandler en stor nyttelast, genererer en PDF eller kjører et tungt bibliotek, bør forbli på Node.

// 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' } });
}

Et rent webutdrag du kan kjøre

Edge-kode holder seg til Web APIs, noe som betyr at kjernelogikken er ren TypeScript som kan kjøre hvor som helst. Her er et frittstående eksempel som bruker crypto.subtle og TextEncoder — akkurat den typen kode som er trygg å kjøre på Edge, fordi den ikke trenger innebygde Node-funksjoner.

// 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();

En beslutningshjelper

Noen ganger er det nyttig å uttrykke avveiningen som en enkel regel. Funksjonen nedenfor returnerer en anbefaling av kjøretidsmiljø basert på noen få fakta om en rute. Dette er bare ren TypeScript-logikk som De kan analysere og kjøre.

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

Blande kjøretidsmiljøer i én app

Den store fordelen med kjøretidsmiljøer per rute er at De kan blande dem. En typisk Next.js 15-app kan for eksempel ha:

Kontroller av autentisering og økter, omdirigeringer, A/B-flagg og lette proxyer → Edge.
Databaseskrivinger via Prisma, filbehandling og SDK-er fra tredjeparter → Node.

Merk: Server Actions kjører i Node.js-kjøretidsmiljøet i App Router — Edge-valget som vises her, gjelder Route Handlers og Middleware, ikke 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' });
}

Lese geografisk kontekst fra Edge

Edge kjører nær brukeren, så det er et naturlig sted for geografisk bevisst logikk. På Vercel kommer geografiske data som forespørselshoder (x-vercel-ip-country, x-vercel-ip-city). De kan lokalisere innhold eller omdirigere uten en rundtur til en sentral server.

Hvis De måtte slå opp i en database for hver forespørsel, blir Edge-fordelen mindre — bruk derfor Edge i tilfeller der avgjørelsen er billig å ta, og dataene er lokale eller bufret.

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

Rask kontroll

Velg ruten som passer best for Edge-kjøretidsmiljøet.

Besvar den i den interaktive leksjonen

Oppsummering: Velge per rute

De velger nå kjøretidsmiljø per rute basert på reelle avveininger:

Edge — nesten ingen kaldstart, lav ventetid globalt og bare Web APIs. Best for lette, geografisk bevisste ruter med lite databehandling (flagg, omdirigeringer, autentiseringskontroller og proxyer for strømmer).
Node (standard) — alle Node-API-er, npm-pakker, TCP-databaser, tunge beregninger og store avhengigheter.

Ta avgjørelsen ved å stille konkrete spørsmål: Trenger den Node-API-er eller en TCP-database-driver? Utfører den tunge beregninger? Hvis ja → Node. Er den lett og følsom for ventetid over hele verden? → Edge. Og husk: Server Actions kjører på Node; runtime = 'edge'-valget gjelder Route Handlers og Middleware.

Gratis å komme i gang

Lær deg TypeScript med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 22
Leksjoner: 88

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Avveininger mellom Node-runtime og Edge-runtime» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Next.js 15 fullstack (App Router + Server Actions), inkludert «Avveininger mellom Node-runtime og Edge-runtime», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Next.js 15 fullstack (App Router + Server Actions) inneholder totalt 4 leksjoner.

Hva lærer jeg i «Avveininger mellom Node-runtime og Edge-runtime»?

Velg mellom Node og Edge per rute basert på kaldstart, tilgjengelige API-er og geografisk forsinkelse. Du øver på Next.js 15 fullstack (App Router + Server Actions) med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Next.js 15 fullstack (App Router + Server Actions)?

Ingen tidligere erfaring er nødvendig. Next.js 15 fullstack (App Router + Server Actions) på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «Avveininger mellom Node-runtime og Edge-runtime»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Next.js 15 fullstack (App Router + Server Actions)-leksjonen?

Ja. Alle Next.js 15 fullstack (App Router + Server Actions)-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Utforme RESTful-rutehåndterere med Web Request API
Avveininger mellom Node-runtime og Edge-runtime
Strømming av svar og ReadableStream i håndterere
Validering av forespørsler og typede JSON-svar med Zod

← Tilbake til Next.js 15 fullstack (App Router + Server Actions)