Next.js 15 Fullstack (App Router + Server Actions) · レッスン

オプトアウト：Dynamic Renderingとno-store

キャッシュが適切でない場合に、cookies、headers、no-storeディレクティブで動的な動作を強制します。

レッスン 4/413 ステップ

「オプトアウト：Dynamic Renderingとno-store」はCoddyKit上の無料Next.js 15 Fullstack (App Router + Server Actions)レッスンです。これはレッスン4/4です。下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。これはNext.js 15 Fullstack (App Router + Server Actions)学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 Next.js 15 Fullstack (App Router + Server Actions)コースには全4レッスンが含まれています。

このレッスンの一部はまだ翻訳されておらず、英語で表示されています。

When Caching Is Wrong

By default, Next.js 15 tries to make your routes static at build time and cache data aggressively. That is great for marketing pages, but wrong for things that must reflect the current request.

A dashboard showing the logged-in user's data
A page that reads the request's cookies() or headers()
Prices, inventory, or notifications that change every second

This lesson is about opting out of caching: forcing dynamic rendering and disabling fetch caching with no-store.

Static vs Dynamic Rendering

A route is rendered in one of two modes:

Static: rendered once (at build, or in the background) and the HTML/data is reused for everyone.
Dynamic: rendered fresh on every request, so it can read per-request input.

Next.js decides automatically. The moment your code touches a Dynamic API (cookies(), headers(), searchParams) or an uncached fetch, the route switches to dynamic. You rarely flip it manually — you opt out of caching and the renderer follows.

cookies() Forces Dynamic

Reading cookies() inside a Server Component signals that the output depends on the incoming request. In Next.js 15 these APIs are async — you must await them.

Touching cookies() at all moves the route to dynamic rendering. There is no way to read a cookie statically, because a static page has no request to read from.

import { cookies } from 'next/headers';

export default async function DashboardPage() {
  const cookieStore = await cookies();
  const theme = cookieStore.get('theme')?.value ?? 'light';

  // Reading cookies() opts this page out of static rendering
  return <main data-theme={theme}>Welcome back</main>;
}

headers() Forces Dynamic Too

Like cookies, headers() is async in Next.js 15 and reading it forces dynamic rendering. Use it when output depends on request headers such as Authorization, User-Agent, or a geo header from your CDN.

Because the header value is per-request, the page can never be cached as a single static HTML for all users.

import { headers } from 'next/headers';

export default async function GreetingPage() {
  const headerList = await headers();
  const country = headerList.get('x-vercel-ip-country') ?? 'unknown';

  return <h1>Hello from {country}</h1>;
}

fetch with cache: 'no-store'

Next.js extends the native fetch with caching options. By default a fetch result may be cached, which is wrong for always-fresh data.

Pass cache: 'no-store' to bypass the cache entirely. Every render performs a real network request, and the route becomes dynamic.

cache: 'no-store' → never cache, always refetch
cache: 'force-cache' → cache indefinitely (the old default)

async function getLivePrice(symbol: string) {
  const res = await fetch(`https://api.example.com/price/${symbol}`, {
    cache: 'no-store',
  });
  return res.json() as Promise<{ price: number }>;
}

export default async function PricePage() {
  const { price } = await getLivePrice('BTC');
  return <p>Current price: {price}</p>;
}

next: { revalidate: 0 } Is the Same

There are two equivalent ways to disable caching on a single fetch:

{ cache: 'no-store' }
{ next: { revalidate: 0 } }

Both mean "do not serve this from cache." Prefer cache: 'no-store' for readability. Do not combine cache: 'force-cache' with revalidate: 0 — those conflict, and Next.js will warn.

// These two calls behave identically
await fetch(url, { cache: 'no-store' });
await fetch(url, { next: { revalidate: 0 } });

Route Segment: dynamic = 'force-dynamic'

Instead of opting out per fetch, you can opt out for an entire route segment using the route segment config. Exporting dynamic = 'force-dynamic' from a page.tsx or layout.tsx forces every render to be dynamic and disables the data cache for that segment.

Use this when most data on the page must be fresh, so you do not have to annotate each fetch individually.

// app/feed/page.tsx
export const dynamic = 'force-dynamic';

export default async function FeedPage() {
  // No need for cache: 'no-store' on each fetch —
  // the whole segment is dynamic
  const res = await fetch('https://api.example.com/feed');
  const items = await res.json();
  return <ul>{items.map((i: { id: string; text: string }) => <li key={i.id}>{i.text}</li>)}</ul>;
}

fetchCache: 'default-no-store'

A subtler knob is fetchCache. Setting fetchCache = 'default-no-store' changes the default for every fetch in the segment to no-store, while still letting an individual fetch opt back in with cache: 'force-cache'.

This is handy for an authenticated area where almost everything is per-user, but a few public lookups can still be cached.

// app/(app)/layout.tsx
export const fetchCache = 'default-no-store';

// Now any plain fetch() in this segment defaults to no-store.
// Opt back in explicitly when you want caching:
// await fetch(url, { cache: 'force-cache' });

Dynamic APIs in Route Handlers

Route Handlers (route.ts) follow the same rules. A GET handler can be cached unless it reads a Dynamic API or you opt out.

Reading request.url search params, or calling cookies()/headers(), makes the handler dynamic. You can also force it with export const dynamic = 'force-dynamic'.

// app/api/me/route.ts
import { cookies } from 'next/headers';
import { NextResponse } from 'next/server';

export const dynamic = 'force-dynamic';

export async function GET() {
  const session = (await cookies()).get('session')?.value;
  if (!session) {
    return NextResponse.json({ error: 'unauthorized' }, { status: 401 });
  }
  return NextResponse.json({ user: session });
}

Server Actions Are Always Dynamic

Server Actions run in response to a user interaction, so they are inherently dynamic — they are never statically cached. They read the cache and can invalidate it, but the action body itself always executes fresh.

After mutating data in an action, call revalidatePath or revalidateTag so cached pages refetch. The action does not need no-store itself.

'use server';
import { revalidatePath } from 'next/cache';

export async function addComment(postId: string, text: string) {
  await db.comment.create({ data: { postId, text } });
  // Force the post page to refetch its (otherwise cached) data
  revalidatePath(`/posts/${postId}`);
}

Don't Reach for no-store Too Early

Opting out of caching is a real performance cost: every request hits your origin and database. Before forcing dynamic everywhere, ask whether time-based revalidation would do.

Data fresh within a few seconds → next: { revalidate: 5 }
Data must reflect this exact request → no-store / dynamic
Data changes on a known event → cache + revalidateTag on mutation

Use no-store when correctness truly depends on per-request freshness — not as a reflex to "make it work."

Quick Check

Test your understanding of opting out of caching in Next.js 15.

対話的なレッスンで答える

Recap

You learned how to opt out of caching when it would be wrong:

Dynamic APIs — awaiting cookies() or headers() automatically forces dynamic rendering.
Per-fetch — cache: 'no-store' (or next: { revalidate: 0 }) skips the data cache.
Per-segment — export const dynamic = 'force-dynamic' makes the whole route dynamic; fetchCache = 'default-no-store' changes the default per fetch.
Route Handlers follow the same rules; Server Actions are always dynamic and invalidate caches with revalidatePath/revalidateTag.
Restraint — prefer time-based or tag-based revalidation; reach for no-store only when correctness needs per-request freshness.

無料で開始

AI チューターと学ぶ TypeScript — 無料

ブラウザでリアルコードを書いて実行し、24/7 の AI チューターから瞬時にサポートを受け、ウェブまたはアプリで続きから学習できます。

コース: 22
レッスン: 88

無料で学習を始めるコース全体を表示

よくある質問

「オプトアウト：Dynamic Renderingとno-store」レッスンは無料ですか？

はい。「オプトアウト：Dynamic Renderingとno-store」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、Next.js 15 Fullstack (App Router + Server Actions)コースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 Next.js 15 Fullstack (App Router + Server Actions)コースには全4レッスンが含まれています。

「オプトアウト：Dynamic Renderingとno-store」で何を学びますか？

キャッシュが適切でない場合に、cookies、headers、no-storeディレクティブで動的な動作を強制します。ブラウザで直接実行するハンズオンコードでNext.js 15 Fullstack (App Router + Server Actions)を演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

Next.js 15 Fullstack (App Router + Server Actions)を始めるのに経験は必要ですか？

事前経験は必要ありません。CoddyKitのNext.js 15 Fullstack (App Router + Server Actions)は初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。これはレッスン4/4です。

「オプトアウト：Dynamic Renderingとno-store」レッスンにはどのくらい時間がかかりますか？

ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。

このNext.js 15 Fullstack (App Router + Server Actions)レッスンでコードを書いて実行できますか？

はい。すべてのNext.js 15 Fullstack (App Router + Server Actions)レッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。

このコースのすべてのレッスン

← Next.js 15 Fullstack (App Router + Server Actions)に戻る