Belajar Next.js 16: Masih Belajar Tutorial Lama? Banyak yang Udah Gak Berlaku
Next.js 16 mengubah cara kita membangun aplikasi React: komponen server jadi default, caching jadi eksplisit lewat 'use cache', dan halaman bisa setengah statis setengah dinamis. Ini panduan lengkapnya, dari konsep sampai deploy.

Next.js adalah framework React untuk membangun aplikasi web full-stack, dan per Oktober 2026 versi terbarunya, Next.js 16.4, membawa perubahan paling besar sejak App Router lahir: komponen server jadi default, caching jadi eksplisit lewat 'use cache', dan satu halaman bisa setengah statis setengah dinamis. Semua kode di bawah sudah gua uji langsung di Next.js 16.4.2, jadi kalian bisa langsung pakai.
Kalau kalian pernah bikin aplikasi React dari nol, kemungkinan besar pernah ngalamin momen ini: aplikasinya jalan mulus di laptop, animasinya halus, semua tombol berfungsi. Terus iseng buka view-source, dan isinya cuma <div id= plus setumpuk tag script. Google memang sudah bisa menjalankan JavaScript, tapi prosesnya antre, gak instan, dan gak semua crawler sesabar Googlebot. Belum lagi urusan routing, pemecahan bundle, optimasi gambar, sampai pertanyaan klasik: data dari database ini sebaiknya diambil di mana?
Next.js lahir buat menjawab masalah-masalah itu. Tapi Next.js yang sekarang sudah jauh beda dengan Next.js yang dulu orang kenal sebagai "React yang bisa SSR", dan banyak tutorial yang beredar sudah gak berlaku lagi.
Nah, yang mau gua kupas di sini lebih ke kenapa Next.js bekerja seperti itu. Daftar fiturnya bisa kalian baca sendiri di dokumentasi, tapi pemahaman soal alasannya yang bikin kalian tahu harus cari di mana waktu ketemu error aneh. Contoh kasusnya sebuah blog sederhana yang mengambil data dari headless CMS, lengkap dengan komentar, SEO, dan cara deploy-nya.
Siapkan kopi, artikelnya panjang. Sekarang kita bedah satu per satu.
Apa Itu Next.js?
Next.js adalah framework berbasis React yang dikembangkan oleh Vercel dan pertama kali dirilis pada Oktober 2016. Kalau React itu mesin, Next.js itu mobil utuhnya. React tahu cara menyusun antarmuka dari komponen, tapi dia gak peduli URL mana menampilkan halaman apa, data diambil dari mana, atau bagaimana halaman dikirim ke browser secepat mungkin. Semua itu urusan Next.js.
Secara konkret, Next.js memberi kalian:
- Routing berbasis struktur folder, tanpa perlu konfigurasi router manual.
- Rendering di server, jadi HTML yang sampai ke browser sudah berisi konten.
- Cara mengambil dan mengubah data langsung dari komponen, tanpa harus bikin API terpisah untuk semuanya.
- Sistem caching yang bisa diatur sampai level komponen.
- Optimasi gambar, font, dan script bawaan.
- Build produksi yang bisa di-deploy ke Vercel, server sendiri, atau container.
Apa bedanya Next.js dengan React biasa?
React yang dipakai sendirian, misalnya lewat Vite, biasanya berjalan sebagai Single Page Application. Browser mengunduh JavaScript, lalu JavaScript itulah yang membangun halaman. Konsekuensinya, layar kosong sampai script selesai dimuat, dan semua pengambilan data terjadi di browser.
Next.js membalik urutannya. Halaman dirender dulu di server, HTML-nya dikirim, lalu React di browser "menghidupkan" bagian yang interaktif. Selain itu, sejak React punya Server Components, ada bagian komponen yang memang cuma berjalan di server dan kodenya gak pernah dikirim ke browser sama sekali. React sendiri menyediakan konsepnya, tapi butuh framework untuk menjalankannya, dan Next.js adalah implementasi yang paling matang saat ini.
Posisi Next.js per Oktober 2026
Ini penting, karena banyak tutorial di internet masih memakai cara lama. Beberapa tonggak yang perlu kalian tahu:
- Next.js 16 rilis 21 Oktober 2025. Turbopack jadi bundler default,
middleware.tsdigantiproxy.ts, Cache Components diperkenalkan,paramsdancookies()wajib diakses secara async, dan versi Node.js minimal naik ke 20.9. - Next.js 16.3 rilis Agustus 2026. Membawa Instant Navigations, Partial Prefetching, root params, dan
catchErroruntuk error boundary yang lebih fleksibel. - Next.js 16.4 rilis 6 Oktober 2026. Cache Components kini direkomendasikan untuk semua aplikasi dan aktif secara default di
create-next-app. Tim Next.js juga sudah menyatakan model ini akan jadi default di Next.js 17.
Kalimat dari tim Next.js di pengumuman 16.4 cukup tegas soal arah ini:
"we're excited to recommend Cache Components as the best choice for every Next.js app."
Jadi kalau kalian menemukan tutorial yang masih pakai getServerSideProps, export const revalidate = 60, atau revalidateTag('posts') dengan satu argumen, anggap itu catatan sejarah. Konsepnya masih berguna untuk dipahami, tapi cara menulisnya sudah berubah.
Sedikit Sejarah: Kenapa Next.js Jadi Seperti Sekarang
Memahami perjalanan Next.js bikin banyak keputusan desainnya jadi masuk akal.
Dulu, web dibangun dengan server yang merender HTML, entah pakai PHP, Rails, atau yang lain. Setiap klik berarti halaman baru dimuat penuh. Sederhana, cepat untuk muatan pertama, tapi terasa kaku.
Lalu datang era Single Page Application. Semua dipindah ke browser, navigasi jadi mulus, tapi muatan pertama jadi berat dan SEO jadi urusan tersendiri. Next.js versi awal menjembatani dua dunia ini lewat Pages Router, dengan fungsi seperti getServerSideProps dan getStaticProps untuk menentukan halaman dirender kapan.
Next.js 13 di akhir 2022 memperkenalkan App Router yang dibangun di atas React Server Components, dan dinyatakan stabil di versi 13.4 pada Mei 2023. Ini lompatan besar, tapi juga datang dengan satu masalah yang bikin banyak orang frustrasi: caching yang implisit. fetch di-cache otomatis, halaman bisa jadi statis tanpa kalian sadari, dan data yang sudah diubah di database gak muncul-muncul di layar.
Gua termasuk yang sempat garuk-garuk kepala waktu itu. Database sudah di-update, halaman di-refresh berkali-kali, datanya tetap yang lama. Ternyata fetch-nya di-cache diam-diam dan halamannya sudah jadi statis saat build. Rasanya kayak nanya teman "udah makan belum?", dijawab "udah", ternyata itu jawaban kemarin. Pengalaman seperti ini yang bikin banyak developer bilang App Router "susah ditebak".
Next.js 15 mulai memperbaiki dengan membuat fetch gak di-cache secara default. Next.js 16 menuntaskannya dengan Cache Components: semuanya dinamis secara default, dan kalian yang memutuskan secara eksplisit bagian mana yang di-cache. Arah ini dipertegas di 16.3 dan 16.4. Pendek kata, Next.js sedang kembali ke prinsip yang lebih jujur: apa yang kalian tulis, itu yang terjadi.
Menyiapkan Proyek Pertama
Pastikan Node.js kalian minimal versi 20.9. Lalu jalankan:
npx create-next-app@latest belajar-next
cd belajar-next
npm run devKalau memilih pengaturan yang direkomendasikan, kalian akan mendapat TypeScript, Tailwind CSS, App Router, Turbopack, plus Cache Components dan Partial Prefetching yang sudah aktif. Cek next.config.ts, isinya kurang lebih seperti ini:
import type { NextConfig } from 'next'
const nextConfig: NextConfig = {
cacheComponents: true,
partialPrefetching: true,
}
export default nextConfigUntuk proyek lama yang mau migrasi, dua opsi ini bisa ditambahkan manual. Set partialPrefetching secara eksplisit, karena kalau dibiarkan kosong Next.js akan memunculkan peringatan.
Oiya, satu hal kecil yang mungkin bikin kalian bingung: setelah menjalankan next dev, bisa muncul file AGENTS.md di root proyek. Itu bukan sampah. Sejak 16.3, Next.js menulis petunjuk ke file itu supaya AI coding agent membaca dokumentasi yang sesuai dengan versi Next.js di proyek kalian. Mau dipakai atau di-ignore, terserah kalian.
Struktur awal proyeknya kira-kira begini:
belajar-next/
├── app/
│ ├── layout.tsx
│ ├── page.tsx
│ └── globals.css
├── public/
├── next.config.ts
├── package.json
└── tsconfig.jsonApp Router: Folder Adalah Rute
Konsep paling dasar di App Router: struktur folder di dalam app/ adalah struktur URL kalian. Folder menentukan segmen rute, dan file dengan nama khusus di dalamnya menentukan apa yang ditampilkan.
File-file khusus yang paling sering dipakai:
page.tsxadalah isi halaman. Sebuah folder baru bisa diakses sebagai URL kalau punya file ini.layout.tsxmembungkus halaman dan semua halaman turunannya. Layout gak dirender ulang saat navigasi antarhalaman di bawahnya, jadi state-nya tetap terjaga.loading.tsxadalah tampilan sementara selama halaman memuat data.error.tsxmenangkap error di segmen itu supaya gak merusak seluruh aplikasi.not-found.tsxtampil saat kalian memanggilnotFound().route.tsadalah endpoint HTTP, dibahas di bagian Route Handlers nanti.
Untuk blog yang akan kita bangun, strukturnya seperti ini:
app/
├── layout.tsx
├── page.tsx
├── robots.ts
├── sitemap.ts
├── api/
│ └── revalidate/
│ └── route.ts
└── blog/
├── page.tsx
└── [slug]/
├── page.tsx
├── actions.ts
├── comments.tsx
└── comment-form.tsxFolder [slug] dengan kurung siku adalah segmen dinamis. URL / akan mengisi slug dengan belajar-next. Ada juga variasi lain yang perlu kalian kenal:
[...slug]menangkap semua segmen sisanya, misalnya/docs/a/b/c.(marketing)dengan kurung biasa adalah route group. Foldernya gak muncul di URL, gunanya untuk mengelompokkan rute yang berbagi layout._componentsdengan garis bawah adalah folder privat yang gak akan pernah jadi rute. Cocok untuk menaruh komponen yang cuma dipakai di segmen itu.
Sekarang root layout. File app/layout.tsx:
import type { Metadata } from 'next'
import { Inter } from 'next/font/google'
import './globals.css'
const inter = Inter({ subsets: ['latin'], display: 'swap' })
export const metadata: Metadata = {
metadataBase: new URL('https://contoh.com'),
title: { default: 'Catatan Dev', template: '%s · Catatan Dev' },
description: 'Catatan seputar web development, dari frontend sampai infrastruktur.',
}
export default function RootLayout({ children }: LayoutProps<'/'>) {
return (
<html lang="id" className={inter.className}>
<body>{children}</body>
</html>
)
}Perhatikan LayoutProps<'/. Ini tipe global yang dibuat otomatis oleh Next.js saat next dev atau next build berjalan, jadi kalian gak perlu import apa pun. Pasangannya, PageProps<'/, akan kita pakai nanti. Keuntungannya, kalau nama segmen dinamis berubah, TypeScript langsung protes di semua tempat yang terdampak.
Oiya, metadataBase juga sering dilupakan. Tanpa dia, URL gambar Open Graph yang relatif gak bisa diubah jadi URL absolut, dan pratinjau tautan di media sosial bisa gagal muncul.
Server Components dan Client Components
Kalau ada satu bagian artikel ini yang menurut gua paling penting buat dipahami, ya ini dia. Hampir semua kebingungan soal Next.js modern berakar dari sini.
Semua komponen adalah Server Component, kecuali kalian bilang sebaliknya
Di App Router, setiap komponen secara default adalah Server Component. Artinya:
- Komponen itu dijalankan di server, saat build atau saat request.
- Kodenya gak dikirim ke browser. Library berat yang cuma dipakai di sana, misalnya parser Markdown, gak menambah ukuran bundle sedikit pun.
- Dia boleh
asyncdan boleh langsung mengakses database, file system, atau API dengan kredensial rahasia. - Dia gak bisa pakai
useState,useEffect, event handler sepertionClick, atau API browser sepertiwindowdanlocalStorage.
Client Component adalah komponen yang ditandai dengan 'use client' di baris paling atas file. Komponen ini dikirim ke browser dan bisa interaktif.
Ada satu salah kaprah yang sering gua temui, bahkan dari developer yang sudah cukup lama pakai Next.js: Client Component tetap dirender di server untuk HTML awalnya. 'use client' bukan berarti "render di browser saja". Artinya "komponen ini juga perlu dikirim ke browser supaya bisa interaktif". HTML-nya tetap datang dari server, lalu React di browser menyambungkan event handler-nya. Proses ini disebut hydration.
Kapan harus pakai 'use client'?
Pakai 'use client' kalau komponennya butuh salah satu dari ini:
- State atau lifecycle:
useState,useReducer,useEffect, dan sejenisnya. - Event handler:
onClick,onChange,onSubmityang berisi logika di browser. - API browser:
window,document,localStorage,navigator., geolocation.clipboard - Library pihak ketiga yang memakai hal-hal di atas.
Contohnya tombol salin tautan. Butuh navigator. dan state, jadi wajib Client Component. File app/:
'use client'
import { useState } from 'react'
export function CopyLink({ url }: { url: string }) {
const [copied, setCopied] = useState(false)
return (
<button
type="button"
onClick={async () => {
await navigator.clipboard.writeText(url)
setCopied(true)
setTimeout(() => setCopied(false), 1500)
}}
>
{copied ? 'Tersalin' : 'Salin tautan'}
</button>
)
}Komponen ini dipakai dari Server Component seperti biasa, cukup dengan <CopyLink url={...} />. Yang dikirim ke browser cuma kode tombol kecil ini, bukan seluruh halaman artikel.
'use client' adalah batas, bukan label
Ini detail yang sering terlewat. 'use client' menandai titik di mana kode mulai masuk ke bundle browser. Semua yang di-import oleh file itu ikut jadi kode client juga.
Kesalahan klasiknya: menaruh 'use client' di layout paling atas karena butuh satu state kecil, misalnya untuk menu mobile. Hasilnya, seluruh pohon komponen di bawahnya ikut terseret jadi client, persis kayak satu orang ngajak makan siang terus satu divisi ikut. Semua keuntungan Server Components pun hilang.

Solusinya biasanya sama: dorong 'use client' sejauh mungkin ke ujung pohon. Yang interaktif cuma tombol menunya? Ya cuma tombol menu itu yang jadi Client Component.
Pola yang sering dilupakan: Server Component sebagai children
Bagaimana kalau kalian butuh pembungkus interaktif, misalnya panel yang bisa dibuka-tutup, tapi isinya mengambil data dari server? Client Component gak bisa meng-import Server Component. Tapi dia bisa menerimanya lewat children.
File app/:
'use client'
import { type ReactNode, useState } from 'react'
export function Collapsible({ title, children }: { title: string; children: ReactNode }) {
const [open, setOpen] = useState(false)
return (
<section>
<button type="button" aria-expanded={open} onClick={() => setOpen((v) => !v)}>
{title}
</button>
{open ? children : null}
</section>
)
}Lalu di Server Component:
<Collapsible title="Daftar isi">
<TableOfContents slug={slug} />
</Collapsible>TableOfContents tetap jadi Server Component. Dia dirender di server, hasilnya diteruskan sebagai children ke Collapsible. Kode TableOfContents gak masuk ke bundle browser sama sekali. Pola ini kelihatannya sepele, tapi ini salah satu teknik paling berguna untuk menjaga bundle tetap kecil.
Apa saja yang bisa dikirim dari server ke client?
Props dari Server Component ke Client Component harus bisa diserialisasi, karena datanya melintasi jaringan. Yang aman:
- String, angka, boolean,
null, danundefined. - Array dan objek biasa.
Date,Map,Set, danBigInt.- Promise, yang bisa di-unwrap di client dengan
use(). - Elemen JSX, termasuk Server Component sebagai
children.
Yang gak bisa: fungsi biasa dan instance class. Pengecualiannya adalah Server Function, yang akan kita bahas di bagian Server Actions.
Jaga kode server tetap di server
Begitu proyek membesar, risiko kode server gak sengaja ter-import dari Client Component makin tinggi. Kalau itu terjadi pada file yang berisi kredensial, akibatnya bisa fatal. Cara mencegahnya, pasang paket server-only dan import di file yang memang khusus server:
npm install server-onlySekarang kita buat lapisan akses ke CMS. File lib/cms.ts:
import 'server-only'
const base = process.env.CMS_URL
const token = process.env.CMS_TOKEN
export async function cms<T>(path: string, init?: RequestInit): Promise<T> {
const res = await fetch(`${base}${path}`, {
...init,
headers: {
'Content-Type': 'application/json',
Authorization: `Bearer ${token}`,
...init?.headers,
},
})
if (!res.ok) throw new Error(`CMS merespons ${res.status} untuk ${path}`)
return res.json() as Promise<T>
}Kalau suatu saat ada Client Component yang meng-import file ini, build langsung gagal dengan pesan yang jelas. Jauh lebih baik ketahuan saat build daripada token CMS bocor ke browser.
Soal environment variable, aturannya sederhana: hanya variabel berawalan NEXT_PUBLIC_ yang dikirim ke browser. CMS_TOKEN di atas aman karena gak berawalan itu. Jangan pernah menaruh rahasia di variabel NEXT_PUBLIC_, karena nilainya ditanam langsung ke dalam JavaScript yang bisa dibaca siapa saja.
Mengambil Data Tanpa useEffect
Di React klasik, pola mengambil data biasanya begini: render komponen kosong, jalankan useEffect, panggil API, simpan ke state, render ulang. Di Server Component, semua itu diganti dengan satu baris await.
File lib/posts.ts:
import 'server-only'
import { cacheLife, cacheTag } from 'next/cache'
import { cms } from './cms'
export type Post = {
slug: string
title: string
excerpt: string
content: string
cover?: string
publishedAt: string
updatedAt: string
}
export async function getPosts() {
'use cache'
cacheLife('hours')
cacheTag('posts')
return cms<Post[]>('/posts?sort=-publishedAt')
}
export async function getPost(slug: string) {
'use cache'
cacheLife('days')
cacheTag('posts', `post-${slug}`)
const [post] = await cms<Post[]>(`/posts?slug=${encodeURIComponent(slug)}`)
return post ?? null
}Abaikan dulu 'use cache', cacheLife, dan cacheTag. Kita bahas tuntas di bagian caching. Sekarang halaman daftar artikel, file app/:
import type { Metadata } from 'next'
import Link from 'next/link'
import { getPosts } from '@/lib/posts'
export const metadata: Metadata = {
title: 'Blog',
description: 'Semua tulisan tentang web development.',
}
export default async function BlogPage() {
const posts = await getPosts()
return (
<main>
<h1>Blog</h1>
<ul>
{posts.map((post) => (
<li key={post.slug}>
<Link href={`/blog/${post.slug}`}>{post.title}</Link>
<p>{post.excerpt}</p>
</li>
))}
</ul>
</main>
)
}Gak ada useEffect, gak ada state loading, gak ada endpoint API perantara. Komponen meminta data, menunggu, lalu merender. Kodenya lebih pendek, dan yang lebih penting, lebih mudah dibaca enam bulan kemudian.
Hati-hati dengan waterfall
Karena await begitu gampang ditulis, ada jebakan yang sering muncul. Lihat kode ini:
export default async function Page() {
const posts = await getPosts()
const categories = await getCategories()
const popular = await getPopularPosts()
return <Home posts={posts} categories={categories} popular={popular} />
}Ketiga permintaan ini gak saling bergantung, tapi dijalankan berurutan. Kalau masing-masing butuh 200 milidetik, total waktunya 600 milidetik. Cukup lama buat pengguna nyalahin sinyalnya, padahal yang lemot kodenya. Ini yang disebut waterfall.
Perbaikan paling sederhana, jalankan secara paralel:
export default async function Page() {
const [posts, categories, popular] = await Promise.all([
getPosts(),
getCategories(),
getPopularPosts(),
])
return <Home posts={posts} categories={categories} popular={popular} />
}Sekarang totalnya kira-kira setara permintaan paling lambat. Tapi masih ada yang lebih baik lagi: pecah jadi komponen terpisah yang masing-masing mengambil datanya sendiri, lalu bungkus dengan <Suspense>. Dengan begitu, bagian yang cepat bisa tampil duluan tanpa menunggu yang lambat. Kita bahas di bagian berikutnya.

React.cache untuk data per request
Ada data yang dipakai di banyak tempat dalam satu request, tapi gak boleh di-cache lintas pengguna. Contoh paling umum adalah sesi login. Untuk ini, pakai cache dari React. Dia memastikan fungsi yang sama dengan argumen yang sama cuma dijalankan sekali per request.
File lib/session.ts:
import 'server-only'
import { cookies } from 'next/headers'
import { cache } from 'react'
import { cms } from './cms'
export type User = { id: string; name: string }
export const getSession = cache(async () => {
const token = (await cookies()).get('session')?.value
if (!token) return null
return cms<User>('/users/me', { headers: { Authorization: `Bearer ${token}` } }).catch(() => null)
})Mau dipanggil di header, sidebar, dan Server Action dalam satu request, permintaan ke CMS tetap cuma terjadi sekali. Bedakan ini dengan 'use cache': React.cache hidup selama satu request saja, sedangkan 'use cache' bertahan lintas request.
Streaming dan Suspense: Biar Halaman Gak Nunggu yang Paling Lambat
Bayangkan halaman artikel. Isi artikelnya bisa diambil dalam 50 milidetik, tapi daftar komentar butuh 800 milidetik karena layanan komentarnya lambat. Tanpa streaming, pengguna menatap layar kosong selama 800 milidetik. Dengan streaming, isi artikel tampil duluan dan komentar menyusul.
Caranya, bungkus bagian yang lambat dengan <Suspense>:
import { Suspense } from 'react'
export default function Page() {
return (
<>
<ArticleBody />
<Suspense fallback={<p>Memuat komentar…</p>}>
<Comments />
</Suspense>
</>
)
}Server mengirim HTML artikel beserta teks "Memuat komentar…" lebih dulu. Begitu data komentar siap, server mengirim potongan HTML berikutnya di respons yang sama, dan React menukar fallback dengan konten aslinya. Gak ada request tambahan dari browser. Semuanya satu respons HTTP yang mengalir.

File loading.tsx sebenernya adalah jalan pintas untuk pola yang sama, hanya saja membungkus seluruh halaman. File app/:
export default function Loading() {
return <p>Memuat artikel…</p>
}Saran gua, gunakan <Suspense> yang lebih granular sebisa mungkin. loading.tsx bagus sebagai jaring pengaman, tapi kalau satu-satunya batas Suspense ada di level rute, satu komponen lambat akan menahan seluruh halaman.
Caching di Next.js 16: Cache Components dan 'use cache'
Ini bagian yang paling banyak berubah, dan menurut gua bagian yang paling layak dipahami dalam-dalam.
Cara berpikir barunya
Dengan Cache Components, setiap bagian halaman masuk ke salah satu dari tiga kategori:
- Statis. Komponen yang gak mengambil data async apa pun, atau cuma memakai nilai yang pasti sama setiap saat. Dirender saat build.
- Di-cache. Komponen atau fungsi yang ditandai
'use cache'. Hasilnya disimpan dan dipakai ulang sesuai umur cache yang kalian tentukan. - Dinamis saat request. Komponen yang mengambil data tanpa cache, atau membaca data spesifik request seperti
cookies(),headers(), dansearchParams. Komponen ini wajib dibungkus<Suspense>.
Saat build, Next.js merender pohon komponen dan menghasilkan apa yang disebut static shell: semua bagian statis, semua bagian yang di-cache, plus fallback dari setiap <Suspense>. Shell ini bisa dikirim langsung dari CDN dalam hitungan milidetik. Bagian dinamis kemudian mengalir masuk di respons yang sama. Teknik ini namanya Partial Prerendering, dan dengan Cache Components dia jadi perilaku default. Penjelasan lengkapnya ada di panduan caching Next.js.

Dulu, Next.js harus memilih: halaman ini statis atau dinamis, gak ada jalan tengah. Satu pemanggilan cookies() di mana pun bisa bikin seluruh halaman jadi dinamis. Sekarang, statis dan dinamis bisa hidup berdampingan di halaman yang sama.
'use cache' di level data dan di level UI
'use cache' bisa ditaruh di fungsi pengambil data, seperti getPosts tadi, atau di komponen:
import { cacheLife } from 'next/cache'
async function PopularPosts() {
'use cache'
cacheLife('hours')
const posts = await getPopularPosts()
return (
<ol>
{posts.map((post) => (
<li key={post.slug}>{post.title}</li>
))}
</ol>
)
}Argumen fungsi dan nilai yang ditangkap dari luar otomatis jadi bagian dari kunci cache. getPost('belajar- dan getPost('tips- punya entri cache sendiri-
Mengatur umur cache dengan cacheLife
Selalu pasangkan 'use cache' dengan cacheLife. Tanpa itu, profil default yang dipakai, dan perilakunya jadi susah ditebak, terutama kalau ada cache bersarang. Setiap profil punya tiga angka:
- stale: berapa lama browser boleh memakai data dari cache tanpa bertanya ke server.
- revalidate: setelah waktu ini, request berikutnya tetap dapat data lama, tapi server memperbarui cache di belakang layar.
- expire: kalau gak ada request selama waktu ini, request berikutnya harus menunggu data baru.
Profil bawaan yang tersedia, sesuai dokumentasi cacheLife:
default: stale 5 menit, revalidate 15 menit, gak pernah expire.seconds: stale 30 detik, revalidate 1 detik, expire 1 menit. Untuk data real-time seperti skor pertandingan.minutes: stale 5 menit, revalidate 1 menit, expire 1 jam. Untuk feed yang sering berubah.hours: stale 5 menit, revalidate 1 jam, expire 1 hari.days: stale 5 menit, revalidate 1 hari, expire 1 minggu. Cocok untuk artikel blog.weeks: stale 5 menit, revalidate 1 minggu, expire 30 hari.max: stale 5 menit, revalidate 30 hari, expire 1 tahun. Untuk konten yang nyaris gak pernah berubah.

Kalau gak ada yang pas, buat profil sendiri di next.config.ts:
import type { NextConfig } from 'next'
const nextConfig: NextConfig = {
cacheComponents: true,
partialPrefetching: true,
cacheLife: {
editorial: {
stale: 600,
revalidate: 3600,
expire: 86400,
},
},
}
export default nextConfigLalu panggil dengan cacheLife('editorial'). Satu catatan: cache yang umurnya sangat pendek, misalnya profil seconds, gak ikut masuk static shell. Dia diperlakukan sebagai bagian dinamis, jadi tetap perlu dibungkus <Suspense>.
Invalidasi dengan tag: revalidateTag, updateTag, dan refresh
Menunggu cache kedaluwarsa sendiri seringkali gak cukup. Waktu editor menerbitkan artikel baru, kalian mau artikel itu langsung muncul. Di sinilah cacheTag berguna. Kita sudah memberi tag posts dan post-${slug} di lib/posts.ts. Sekarang tinggal membuang cache berdasarkan tag itu.
Ada tiga fungsi, masing-masing dengan perannya:
revalidateTag(tag, profil)menandai cache sebagai basi dengan perilaku stale-while- revalidate. Pengunjung berikutnya masih melihat versi lama sesaat, sementara versi baru disiapkan di belakang layar. Cocok untuk konten publik seperti artikel. Sejak Next.js 16, argumen kedua wajib diisi, dan profil 'max'adalah pilihan yang direkomendasikan untuk kebanyakan kasus.updateTag(tag)langsung membuang cache dan memastikan request yang sama sudah membaca data baru. Hanya bisa dipakai di Server Action. Cocok untuk interaksi pengguna, misalnya setelah mengirim komentar, pengguna harus langsung melihat komentarnya sendiri.refresh()gak menyentuh cache sama sekali. Dia cuma menyegarkan bagian halaman yang memang gak di-cache. Juga khusus Server Action.
Contoh pemakaiannya ada di bagian Server Actions dan Route Handlers sebentar lagi.
Data spesifik request harus dibungkus Suspense
Ada aturan yang bakal sering kalian temui: komponen yang membaca cookies(), headers(), searchParams, atau params yang gak dikenal saat build, harus berada di dalam <Suspense>. Kalau lupa, dev overlay Next.js akan menampilkan insight bernama blocking-route lengkap dengan saran perbaikannya.
Awalnya mungkin terasa merepotkan. Tapi gua justru suka aturan ini, karena dia memaksa kita sadar bagian mana yang dinamis. Dulu, satu cookies() yang nyelip di komponen header bisa diam-diam bikin seluruh situs jadi dinamis, dan baru ketahuan waktu tagihan server membengkak. Sekarang, Next.js protes dari awal, saat masih di laptop.
Data dari request juga gak bisa dibaca langsung di dalam 'use cache', karena hasil cache dipakai bersama oleh banyak pengguna. Polanya: baca nilainya di luar, lalu kirim sebagai argumen.
import { cacheLife } from 'next/cache'
import { cookies } from 'next/headers'
import { Suspense } from 'react'
import { getPostsByTopic } from '@/lib/posts'
export default function Page() {
return (
<Suspense fallback={<p>Memuat rekomendasi…</p>}>
<Recommendations />
</Suspense>
)
}
async function Recommendations() {
const topic = (await cookies()).get('topic')?.value ?? 'umum'
return <CachedRecommendations topic={topic} />
}
async function CachedRecommendations({ topic }: { topic: string }) {
'use cache'
cacheLife('hours')
const posts = await getPostsByTopic(topic)
return (
<ul>
{posts.map((post) => (
<li key={post.slug}>{post.title}</li>
))}
</ul>
)
}topic jadi bagian dari kunci cache. Semua pengguna dengan topik yang sama berbagi satu entri cache, sementara pembacaan cookie tetap terjadi per request.
Nilai acak dan waktu sekarang
Satu lagi yang sering bikin kaget: Math.random(), Date.now(), new Date() tanpa argumen, dan crypto. juga perlu ditangani secara eksplisit. Kalau dibiarkan, nilainya akan "membeku" saat build. Pilihannya dua: panggil await connection() dari next/server sebelum memakainya, plus bungkus dengan <Suspense>, supaya nilainya dibuat ulang tiap request. Atau taruh di dalam 'use cache' kalau memang boleh sama untuk semua orang sampai cache diperbarui.
Di mana sebenernya cache disimpan?
Ini pertanyaan yang jarang dibahas, padahal penting begitu kalian self-host:
- HTML hasil prerender disimpan di disk saat self-host, atau di penyimpanan platform di belakang CDN.
- Hasil
'use cache'saat runtime secara default disimpan di memori, per instance server. Kalau kalian menjalankan tiga container, masing-masing punya cache sendiri. Di lingkungan serverless, memori ini juga gak bertahan lama. - Browser menyimpan hasil cache sesuai nilai
staleuntuk navigasi berikutnya.
Kalau butuh cache yang dipakai bersama oleh banyak instance, ada varian 'use cache: remote' yang memakai cache handler bersama, misalnya Redis. Ada juga 'use cache: private' untuk data personal yang cuma disimpan di browser. Satu hal lagi: semua cache ini terikat pada satu deployment. Begitu kalian deploy versi baru, cache mulai dari nol.
Merangkai Halaman Artikel
Sekarang kita gabungkan semuanya di halaman detail artikel. File app/:
import type { Metadata } from 'next'
import { notFound } from 'next/navigation'
import { Suspense } from 'react'
import { getPost, getPosts } from '@/lib/posts'
import { CommentForm } from './comment-form'
import { Comments } from './comments'
import { CopyLink } from './copy-link'
export async function generateStaticParams() {
const posts = await getPosts()
return posts.slice(0, 20).map((post) => ({ slug: post.slug }))
}
export async function generateMetadata({ params }: PageProps<'/blog/[slug]'>): Promise<Metadata> {
const { slug } = await params
const post = await getPost(slug)
if (!post) return {}
return {
title: post.title,
description: post.excerpt,
alternates: { canonical: `/blog/${post.slug}` },
openGraph: {
type: 'article',
title: post.title,
description: post.excerpt,
publishedTime: post.publishedAt,
modifiedTime: post.updatedAt,
images: post.cover ? [post.cover] : [],
},
}
}
export default function Page({ params }: PageProps<'/blog/[slug]'>) {
return (
<Suspense fallback={<p>Memuat artikel…</p>}>
<Article params={params} />
</Suspense>
)
}
async function Article({ params }: { params: Promise<{ slug: string }> }) {
const { slug } = await params
const post = await getPost(slug)
if (!post) notFound()
const published = new Intl.DateTimeFormat('id-ID', { dateStyle: 'long' }).format(new Date(post.publishedAt))
return (
<article>
<h1>{post.title}</h1>
<time dateTime={post.publishedAt}>{published}</time>
<CopyLink url={`https://contoh.com/blog/${post.slug}`} />
<div dangerouslySetInnerHTML={{ __html: post.content }} />
<section>
<h2>Komentar</h2>
<Suspense fallback={<p>Memuat komentar…</p>}>
<Comments slug={slug} />
</Suspense>
<CommentForm slug={slug} />
</section>
</article>
)
}Beberapa hal yang perlu diperhatikan:
paramssekarang adalah Promise. Sejak Next.js 16, akses sinkron keparams,searchParams,cookies(), danheaders()sudah dihapus.generateStaticParamsmemprerender 20 artikel terbaru saat build. Artikel lain gak error. Pengunjung pertamanya langsung mendapat shell, lalu versi lengkapnya dibuat di belakang layar dan disimpan untuk pengunjung berikutnya. Ini bentuk baru Incremental Static Regeneration yang hadir di 16.3.- Halaman utamanya sinkron, dan
paramsbaru di-await di dalam<Suspense>. Dengan begitu, kerangka halaman tetap bisa masuk static shell meskipun slug-nya belum dikenal saat build. getPostdipanggil dua kali, digenerateMetadatadan diArticle, tapi permintaan ke CMS cuma terjadi sekali karena hasilnya di-cache.dangerouslySetInnerHTMLdipakai karena konten datang dari CMS sendiri. Kalau kontennya bisa diisi pihak luar, sanitasi dulu sebelum dirender.notFound()di dalam<Suspense>punya perilaku yang perlu kalian tahu. Saat gua tes, slug yang gak ada mengembalikan status 200 ke browser biasa, karena status HTTP sudah terkirim sebelumnotFound()dipanggil. Tampilannya tetap halaman 404 dan Next.js otomatis menyisipkan<meta name="robots" content=. Sementara Googlebot, yang dikenali sebagai crawler dan dirender tanpa streaming, menerima status 404 asli. Jadi aman untuk SEO, tapi jangan kaget kalau monitoring kalian mencatat 200 untuk halaman yang sebenernya gak ada."noindex">
Komponen komentar, file app/:
import { cacheLife, cacheTag } from 'next/cache'
import { cms } from '@/lib/cms'
type Comment = { id: string; author: string; body: string }
export async function Comments({ slug }: { slug: string }) {
'use cache'
cacheLife('minutes')
cacheTag(`comments-${slug}`)
const comments = await cms<Comment[]>(`/comments?post=${encodeURIComponent(slug)}`)
if (!comments.length) return <p>Belum ada komentar. Sepi kayak grup kelas setelah lulus.</p>
return (
<ul>
{comments.map((comment) => (
<li key={comment.id}>
<strong>{comment.author}</strong>
<p>{comment.body}</p>
</li>
))}
</ul>
)
}Server Actions: Mutasi Data Tanpa Bikin API Sendiri
Server Action adalah fungsi async yang berjalan di server tapi bisa dipanggil langsung dari form atau komponen di browser. Kalian cukup menandai fungsinya dengan 'use server'. Next.js yang mengurus pembuatan endpoint, serialisasi data, dan pemanggilannya.
Form komentar
File app/:
'use server'
import { updateTag } from 'next/cache'
import { cms } from '@/lib/cms'
import { getSession } from '@/lib/session'
type CommentState = { error: string | null }
export async function addComment(slug: string, _prev: CommentState, formData: FormData): Promise<CommentState> {
const session = await getSession()
if (!session) return { error: 'Masuk dulu sebelum berkomentar.' }
const body = String(formData.get('body') ?? '').trim()
if (body.length < 3 || body.length > 2000) return { error: 'Komentar harus 3 sampai 2.000 karakter.' }
await cms('/comments', {
method: 'POST',
body: JSON.stringify({ post: slug, body, author: session.id }),
})
updateTag(`comments-${slug}`)
return { error: null }
}Lalu form-nya, file app/:
'use client'
import { useActionState } from 'react'
import { addComment } from './actions'
export function CommentForm({ slug }: { slug: string }) {
const [state, action, pending] = useActionState(addComment.bind(null, slug), { error: null })
return (
<form action={action}>
<textarea name="body" required minLength={3} maxLength={2000} />
{state.error ? <p role="alert">{state.error}</p> : null}
<button type="submit" disabled={pending}>
{pending ? 'Mengirim…' : 'Kirim komentar'}
</button>
</form>
)
}Alurnya begini: pengguna menekan tombol, useActionState memanggil addComment di server dengan slug yang sudah diikat lewat bind, server menyimpan komentar lalu memanggil updateTag. Karena updateTag punya semantik read-fetch manual, tanpa state global.
Bandingkan dengan cara lama: bikin endpoint API, panggil dengan fetch dari client, tangani loading dan error, lalu sinkronkan ulang state lokal. Jumlah kodenya bisa tiga kali lipat.

Server Action adalah endpoint publik
Ini yang paling sering diremehkan. Setiap Server Action pada dasarnya adalah endpoint HTTP POST yang bisa dipanggil siapa saja, bukan cuma dari form yang kalian buat. Menyembunyikan tombol dari pengguna yang belum login gak berarti action-nya terlindungi.
Jadi di setiap Server Action, tanpa kecuali:
- Cek autentikasi. Siapa yang memanggil?
- Cek otorisasi. Apakah dia boleh melakukan ini pada data ini?
- Validasi input. Semua isi
FormDatadatang dari client dan gak bisa dipercaya. Untuk form yang lebih kompleks, library seperti Zod atau Valibot sangat membantu.
Next.js memang menambah lapisan pengaman, misalnya ID action yang dibuat non-
Pelajaran dari deploy: "Failed to find Server Action"
Ada satu masalah yang hampir pasti kalian temui begitu self-host dengan Docker, dan dokumentasinya baru terasa relevan setelah kena sendiri.
Gua pernah mengalaminya di proyek pribadi yang di-deploy ke VPS lewat container. Habis deploy versi baru, tombol simpan di dashboard mendadak gak bereaksi apa-apa. Log server penuh dengan pesan "Failed to find Server Action". Penyebabnya: tab browser yang masih terbuka memegang ID action dari build lama, sementara server sudah menjalankan build baru dengan ID yang berbeda.
Next.js membuat ID Server Action dan mengenkripsi datanya dengan kunci yang bisa berbeda di setiap build. Solusinya, tetapkan kunci enkripsi yang konsisten lewat environment variable NEXT_. Kuncinya berupa string base64 dengan panjang 16, 24, atau 32 byte:
openssl rand -base64 32Yang sering terlewat: variabel ini harus tersedia saat build, bukan cuma saat runtime, karena kuncinya ditanam ke hasil build. Kalau kalian pakai platform seperti Dokploy atau Coolify, artinya kunci ini harus dimasukkan sebagai build argument, gak cukup di environment runtime saja. Gua sempat bingung kenapa build-nya tiba-tiba selesai jauh lebih cepat dari biasanya padahal masalahnya belum beres. Ternyata kuncinya cuma terbaca saat runtime.
Kunci yang konsisten juga wajib kalau kalian menjalankan beberapa instance di belakang load balancer, supaya semua instance bisa membaca data action yang sama. Tapi ingat, action yang memang berubah atau dihapus di build baru tetap gak akan ditemukan oleh tab lama. Jadi tetap tangani kegagalan itu di UI, misalnya dengan pesan untuk memuat ulang halaman, dan simpan draf pengguna di browser supaya tulisannya gak hilang. Di Vercel, masalah ini ditangani oleh fitur Skew Protection.
Route Handlers: Kalau Memang Butuh Endpoint HTTP
Server Action cocok untuk mutasi yang dipicu dari UI kalian sendiri. Tapi ada kasus di mana kalian butuh endpoint HTTP sungguhan: webhook dari layanan lain, API untuk aplikasi mobile, atau feed RSS. Untuk itu ada Route Handler, yaitu file route.ts yang mengekspor fungsi sesuai nama metode HTTP.
Contoh paling berguna untuk blog kita: webhook yang dipanggil CMS setiap kali artikel diterbitkan atau diubah. File app/:
import { revalidateTag } from 'next/cache'
import type { NextRequest } from 'next/server'
export async function POST(request: NextRequest) {
if (request.headers.get('x-webhook-secret') !== process.env.WEBHOOK_SECRET) {
return Response.json({ ok: false }, { status: 401 })
}
const { slug } = (await request.json()) as { slug?: string }
revalidateTag('posts', 'max')
if (slug) revalidateTag(`post-${slug}`, 'max')
return Response.json({ ok: true })
}Atur CMS kalian untuk mengirim POST ke /api/revalidate dengan header rahasia setiap kali konten berubah. Sekarang artikel bisa di-cache berhari-hari, tapi tetap tampil terbaru beberapa detik setelah editor menekan tombol terbit. Ini kombinasi yang ideal untuk situs konten: cepat seperti situs statis, segar seperti situs dinamis.
Satu kesalahan yang sering gua lihat: Server Component memanggil Route Handler milik aplikasinya sendiri lewat fetch('/. Itu putaran jaringan yang sia-sia. Server Component sudah berjalan di server, jadi panggil saja fungsi pengambil datanya langsung.
proxy.ts: Penjaga di Depan Pintu
Di Next.js 16, middleware.ts diganti namanya jadi proxy.ts, dan fungsi yang diekspor juga jadi proxy. Logikanya tetap sama. Bedanya, proxy.ts berjalan di runtime Node.js, dan namanya sengaja dipilih supaya jelas perannya: lapisan di depan aplikasi yang mencegat request sebelum sampai ke rute. middleware.ts masih bisa dipakai untuk kasus Edge runtime, tapi sudah deprecated.
Contoh, mengarahkan pengguna yang belum punya cookie sesi ke halaman masuk. File proxy.ts di root proyek:
import { type NextRequest, NextResponse } from 'next/server'
export function proxy(request: NextRequest) {
if (!request.cookies.has('session')) {
const url = new URL('/masuk', request.url)
url.searchParams.set('next', request.nextUrl.pathname)
return NextResponse.redirect(url)
}
return NextResponse.next()
}
export const config = {
matcher: ['/dashboard/:path*'],
}Perhatikan, ini cuma mengecek apakah cookie-nya ada, bukan apakah sesinya valid. Dan memang sebaiknya begitu. Proxy cocok untuk pengecekan ringan yang optimis: redirect, rewrite, mengatur header, atau mengarahkan bahasa. Jangan jadikan dia satu-satunya lapisan keamanan.
Ada alasan nyata di balik saran ini. Maret 2025 lalu, ditemukan celah CVE-2025-29927 yang memungkinkan penyerang melewati middleware sepenuhnya cukup dengan menambahkan satu header khusus di request. Aplikasi yang menaruh seluruh pengecekan otorisasinya di middleware langsung terbuka lebar. Aplikasi yang tetap mengecek sesi di dekat datanya, di Server Component, Server Action, dan Route Handler, relatif aman.

Prinsipnya: verifikasi akses sedekat mungkin dengan data. Fungsi seperti getSession() yang kita buat tadi sebaiknya dipanggil di setiap tempat yang mengakses data sensitif.
SEO di Next.js: Metadata, Sitemap, dan Data Terstruktur
Salah satu alasan utama orang memilih Next.js adalah SEO. Sebenernya SEO itu lebih banyak urusan produk daripada urusan tim konten, dan soal ini gua pernah bahas panjang di tulisan Media Berita Butuh SEO, tapi Gak Butuh Tim SEO. Fondasinya sudah kuat karena HTML dirender di server. Tapi ada beberapa hal yang tetap perlu kalian atur.
Metadata
Kita sudah melihat dua caranya: objek metadata statis di layout dan generateMetadata di halaman dinamis. Next.js menggabungkan metadata dari layout ke halaman secara berjenjang. Itu sebabnya title.template di root layout otomatis menambahkan " · Catatan Dev" ke setiap judul halaman.
Ada detail menarik soal metadata di era streaming. Dengan Partial Prerendering, metadata yang dinamis bisa menyusul setelah shell dikirim. Sebagian crawler gak bisa menangani itu dan butuh metadata ada di dalam <head> sejak awal. Next.js mendeteksi crawler semacam ini dari user agent-nya dan merender halaman secara utuh untuk mereka. Konsekuensinya, sumber data kalian harus tetap bisa diakses saat request, bukan cuma saat build. Kalau gak, crawler bisa mendapat error 500.
Sitemap dan robots
Next.js bisa membuat sitemap.xml dan robots.txt dari kode. File app/sitemap.ts:
import type { MetadataRoute } from 'next'
import { getPosts } from '@/lib/posts'
export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
const posts = await getPosts()
const latest = posts[0]?.updatedAt
return [
{ url: 'https://contoh.com', lastModified: latest },
{ url: 'https://contoh.com/blog', lastModified: latest },
...posts.map((post) => ({
url: `https://contoh.com/blog/${post.slug}`,
lastModified: post.updatedAt,
})),
]
}Perhatikan gua memakai tanggal dari artikel terbaru, bukan new Date(). Selain lebih jujur di mata mesin pencari, ini juga menghindari masalah nilai waktu sekarang yang dibahas di bagian caching.
File app/robots.ts:
import type { MetadataRoute } from 'next'
export default function robots(): MetadataRoute.Robots {
return {
rules: [{ userAgent: '*', allow: '/', disallow: ['/dashboard', '/api'] }],
sitemap: 'https://contoh.com/sitemap.xml',
}
}Data terstruktur dengan JSON-LD
Supaya mesin pencari dan mesin jawaban berbasis AI memahami konteks halaman kalian, tambahkan data terstruktur. Di komponen Article, buat objek JSON-LD setelah data artikel didapat, lalu render sebagai tag script di awal <article>. Potongannya seperti ini:
const jsonLd = {
'@context': 'https://schema.org',
'@type': 'BlogPosting',
headline: post.title,
description: post.excerpt,
datePublished: post.publishedAt,
dateModified: post.updatedAt,
image: post.cover,
mainEntityOfPage: `https://contoh.com/blog/${post.slug}`,
}
return (
<article>
<script
type="application/ld+json"
dangerouslySetInnerHTML={{ __html: JSON.stringify(jsonLd).replace(/</g, '\\u003c') }}
/>
<h1>{post.title}</h1>
…
</article>
).replace(/</g, '\\u003c') itu bukan hiasan. Kalau judul atau deskripsi artikel mengandung </script>, tanpa escape itu tag script-nya bisa tertutup lebih awal dan membuka celah XSS. Kecil, tapi detail seperti ini yang membedakan kode yang sekadar jalan dengan kode yang siap produksi.
Gambar dan Font
next/image
Komponen Image dari next/image mengurus banyak hal sekaligus: mengubah ukuran gambar sesuai layar, mengonversi ke format modern seperti WebP atau AVIF, lazy loading, dan mencegah layout bergeser saat gambar dimuat.
import Image from 'next/image'
<Image
src={post.cover}
alt={post.title}
width={1200}
height={630}
sizes="(min-width: 768px) 720px, 100vw"
/>Prop sizes sering diabaikan, padahal penting. Tanpa itu, browser bisa mengunduh gambar ukuran besar untuk layar ponsel. Untuk gambar dari domain luar, daftarkan polanya di next.config.ts:
import type { NextConfig } from 'next'
const nextConfig: NextConfig = {
images: {
remotePatterns: [new URL('https://cdn.contoh.com/**')],
},
}
export default nextConfigNext.js 16 juga mengubah beberapa default: cache gambar yang dioptimasi sekarang 4 jam, bukan 60 detik, dan kualitas default dikunci di 75. Kalau kalian butuh kualitas lain, daftarkan dulu di images..
next/font
Kita sudah memakai next/ di root layout. Font diunduh saat build lalu disajikan dari domain kalian sendiri, jadi gak ada request ke Google saat pengguna membuka situs. Ukuran fallback-nya juga disesuaikan otomatis, sehingga teks gak melompat saat font asli selesai dimuat. Dua masalah klasik soal web font beres tanpa konfigurasi tambahan.
Deploy: Vercel atau Self-Host
Deploy ke Vercel adalah jalur paling mulus. Hubungkan repositori, push, selesai. Fitur seperti cache terdistribusi dan Skew Protection langsung jalan.
Tapi Next.js juga sepenuhnya bisa di-self-host, dan sejak Maret 2026 tim Next.js makin serius mendukung platform lain lewat Build Adapters dan kerja sama dengan OpenNext. Untuk VPS atau container, aktifkan output standalone di next.config.ts:
import type { NextConfig } from 'next'
const nextConfig: NextConfig = {
output: 'standalone',
cacheComponents: true,
partialPrefetching: true,
}
export default nextConfigMode ini menghasilkan folder . berisi server Node.js minimal beserta dependensi yang benar-benar dipakai saja. Ukurannya jauh lebih kecil dibanding menyalin seluruh node_modules. Contoh Dockerfile multi-stage yang gua pakai sebagai titik awal:
FROM node:22-alpine AS deps
WORKDIR /app
RUN corepack enable
COPY package.json pnpm-lock.yaml ./
RUN pnpm install --frozen-lockfile
FROM node:22-alpine AS build
WORKDIR /app
RUN corepack enable
ARG NEXT_SERVER_ACTIONS_ENCRYPTION_KEY
ENV NEXT_SERVER_ACTIONS_ENCRYPTION_KEY=$NEXT_SERVER_ACTIONS_ENCRYPTION_KEY
COPY --from=deps /app/node_modules ./node_modules
COPY . .
RUN pnpm build
FROM node:22-alpine AS run
WORKDIR /app
ENV NODE_ENV=production
ENV PORT=3000
ENV HOSTNAME=0.0.0.0
COPY --from=build --chown=node:node /app/public ./public
COPY --from=build --chown=node:node /app/.next/standalone ./
COPY --from=build --chown=node:node /app/.next/static ./.next/static
USER node
EXPOSE 3000
CMD ["node", "server.js"]Beberapa detail yang sering bikin orang terjebak:
HOSTNAME=wajib di container. Tanpa itu, server hanya mendengarkan di localhost dalam container dan gak bisa diakses dari luar.0. 0. 0. 0 - Folder
publicdan.next/staticgak otomatis ikut ke standalone. Harus disalin manual seperti di atas. Lupa langkah ini, situs jalan tapi semua CSS dan gambar 404. -dan- chown= node:node USER nodemembuat aplikasi gak berjalan sebagai root, dan Next.js tetap bisa menulis cache ke.next/cache.- Kunci enkripsi Server Actions masuk sebagai
ARGdi tahap build, sesuai cerita di bagian Server Actions tadi.
Kalau kalian menjalankan lebih dari satu instance, ingat lagi bahwa cache runtime default tersimpan di memori masing-masing instance. Untuk aplikasi yang sangat bergantung pada cache, pertimbangkan cache handler bersama.
Terakhir, rajin-rajinlah update. Desember 2025 lalu ada celah kritis di protokol React Server Components, tercatat sebagai CVE-2025-66478 di sisi Next.js, yang memungkinkan eksekusi kode jarak jauh di server. Aplikasi yang telat update benar-benar terekspos. Sejak 16.4, Next.js bisa mengingatkan kalian otomatis kalau ada update keamanan yang relevan untuk versi yang sedang dipakai.
Kesalahan yang Paling Sering Gua Lihat
Dari berbagai proyek Next.js yang pernah gua kerjakan dan review, pola kesalahannya cenderung berulang:
'use client'di level terlalu tinggi. Satu state kecil di layout membuat seluruh aplikasi jadi Client Component. Dorong batasnya ke komponen paling kecil yang benar-benar butuh interaktivitas.- Server Component memanggil API route milik sendiri. Panggil fungsi datanya langsung. Gak perlu putaran HTTP tambahan.
awaitberurutan untuk data yang gak saling bergantung. PakaiPromise.all, atau lebih baik lagi, pecah jadi komponen dengan<Suspense>masing-masing.- Otorisasi hanya di proxy. Proxy untuk redirect dan pengecekan ringan. Verifikasi sesungguhnya dilakukan di dekat data.
- Server Action tanpa validasi. Setiap action adalah endpoint publik. Cek sesi, cek izin, validasi input.
- Rahasia di variabel
NEXT_PUBLIC_. Apa pun yang berawalan itu bisa dibaca siapa saja yang membuka DevTools. - Membaca
cookies()di dalam'use cache'. Baca di luar, kirim nilainya sebagai argumen. - Belajar dari tutorial lama tanpa cek versi.
getServerSideProps,middleware.ts,revalidateTagsatu argumen, dan aksesparamssinkron sudah bukan cara yang benar untuk Next.js 16.
Kapan Next.js Bukan Pilihan Terbaik
Gua gak mau artikel ini terdengar seperti iklan. Next.js itu alat yang hebat, tapi bukan untuk semua kasus.
- Dashboard internal di balik login, tanpa kebutuhan SEO. Vite dengan React Router atau TanStack Router seringkali lebih sederhana. Gak ada server yang perlu dijaga, cukup file statis.
- Situs dokumentasi atau konten yang hampir seluruhnya statis. Astro misalnya, mengirim JavaScript jauh lebih sedikit secara default dan model mentalnya lebih ringan.
- Tim yang gak punya pengalaman mengelola server Node.js. Kalau gak mau pakai Vercel dan gak siap mengurus container, kompleksitas operasionalnya nyata.
- Aplikasi yang hampir seluruhnya real-time dan berjalan di browser, seperti editor kolaboratif atau game. Keunggulan rendering server-nya jadi kurang terpakai.
Next.js paling bersinar di aplikasi yang butuh SEO dan performa muatan pertama, sekaligus punya bagian yang dinamis dan interaktif. Situs media, e-commerce, SaaS dengan halaman marketing, dan blog dengan fitur komunitas adalah habitat alaminya.
Nah, kalau kalian baru mau mulai, saran gua mungkin jangan coba menguasai semuanya sekaligus. Mulai dari satu halaman aja. Coba kalian terapkan dengan cara ini: ambil data di Server Component, tambahkan satu <Suspense>, cache satu fungsi dengan 'use cache', lalu buat satu form dengan Server Action. Misalnya halaman daftar artikel plus form komentar kecil kayak contoh di atas. Setelah empat hal itu terasa natural, sisanya sebenernya tinggal variasi dari pola yang sama.
Panjang ya, makasih udah baca sampai sini. Mudah-mudahan cara pandang kalian ke Next.js jadi lebih utuh.