Kurs Next.js · Moduł 8: Deployment i produkcja

Generowanie map witryn i robots.txt

9 min czytania ·
W tej lekcji12

W świecie wyszukiwarek internetowych, dostępność treści i ich poprawna indeksacja stanowią fundament skutecznego SEO (Search Engine Optimization). Next.js oferuje zaawansowane mechanizmy i narzędzia, które ułatwiają generowanie map witryn (sitemaps) oraz plików robots.txt - dwóch kluczowych elementów dla wyszukiwarek takich jak Google, Bing czy Yahoo.

Znaczenie map witryn i pliku robots.txt

Mapa witryny (Sitemap)

Mapa witryny to plik XML, który zawiera listę wszystkich adresów URL twojej strony wraz z dodatkowymi metadanymi, takimi jak:

  • Data ostatniej modyfikacji strony
  • Częstotliwość zmian
  • Priorytet ważności w porównaniu z innymi stronami

Mapa witryny pomaga wyszukiwarkom w następujących aspektach:

  1. Odkrywanie zawartości - informuje o wszystkich stronach na Twojej witrynie
  2. Efektywne indeksowanie - pomaga zrozumieć strukturę witryny
  3. Priorytyzacja - wskazuje, które strony są najważniejsze
  4. Aktualność - informuje, kiedy strony były ostatnio modyfikowane

Plik robots.txt

Robots.txt to prosty plik tekstowy, który zawiera instrukcje dla robotów wyszukiwarek (crawlers). Główne funkcje robots.txt to:

  1. Kontrola dostępu - określa, które strony mogą być indeksowane, a które nie
  2. Zarządzanie ruchem botów - zapobiega przeciążeniu serwera przez ograniczenie dostępu
  3. Wskazywanie lokalizacji mapy witryny - informuje boty o lokalizacji pliku sitemap.xml

Ręczne generowanie mapy witryny w Next.js

Zacznijmy od najprostszego podejścia - ręcznego stworzenia mapy witryny jako statycznego pliku XML:

// app/sitemap.xml/route.ts
import { BASE_URL } from '@/lib/constants';
import { getAllPostSlugs } from '@/lib/api';

export async function GET() {
  // Pobierz dynamiczne dane, np. adresy URL wszystkich postów bloga
  const postSlugs = await getAllPostSlugs();

  // Aktualna data dla lastmod
  const date = new Date().toISOString();

  // Tworzenie zawartości XML
  const sitemap = `<?xml version="1.0" encoding="UTF-8"?>
    <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
      <url>
        <loc>${BASE_URL}</loc>
        <lastmod>${date}</lastmod>
        <changefreq>daily</changefreq>
        <priority>1.0</priority>
      </url>
      <url>
        <loc>${BASE_URL}/about</loc>
        <lastmod>${date}</lastmod>
        <changefreq>monthly</changefreq>
        <priority>0.8</priority>
      </url>
      <url>
        <loc>${BASE_URL}/products</loc>
        <lastmod>${date}</lastmod>
        <changefreq>weekly</changefreq>
        <priority>0.9</priority>
      </url>
      ${postSlugs.map(slug => `
        <url>
          <loc>${BASE_URL}/blog/${slug}</loc>
          <lastmod>${date}</lastmod>
          <changefreq>weekly</changefreq>
          <priority>0.7</priority>
        </url>
      `).join('')}
    </urlset>`;

  // Zwróć odpowiedź z odpowiednim Content-Type
  return new Response(sitemap, {
    headers: {
      'Content-Type': 'application/xml',
      'Cache-Control': 'public, max-age=3600, s-maxage=3600'
    }
  });
}

To podejście jest elastyczne i pozwala na pełną kontrolę nad zawartością mapy witryny, ale wymaga ręcznego zarządzania i aktualizacji.

Automatyczne generowanie mapy witryny za pomocą funkcji sitemap()

Next.js 13.4+ wprowadził specjalną funkcję sitemap(), która upraszcza generowanie map witryn. W tym podejściu definiujesz plik sitemap.ts lub sitemap.js w katalogu głównym aplikacji:

// app/sitemap.ts
import { MetadataRoute } from 'next';
import { getAllProducts } from '@/lib/products';
import { getAllPosts } from '@/lib/blog';

export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
  // Pobierz wszystkie produkty
  const products = await getAllProducts();
  const productEntries = products.map(product => ({
    url: `https://example.com/products/${product.slug}`,
    lastModified: new Date(product.updatedAt),
    changeFrequency: 'weekly' as const,
    priority: 0.8,
  }));

  // Pobierz wszystkie posty bloga
  const posts = await getAllPosts();
  const blogEntries = posts.map(post => ({
    url: `https://example.com/blog/${post.slug}`,
    lastModified: new Date(post.publishedAt),
    changeFrequency: 'monthly' as const,
    priority: 0.7,
  }));

  // Statyczne strony
  const staticPages = [
    {
      url: 'https://example.com',
      lastModified: new Date(),
      changeFrequency: 'daily' as const,
      priority: 1.0,
    },
    {
      url: 'https://example.com/about',
      lastModified: new Date(),
      changeFrequency: 'monthly' as const,
      priority: 0.5,
    },
    {
      url: 'https://example.com/contact',
      lastModified: new Date(),
      changeFrequency: 'yearly' as const,
      priority: 0.5,
    },
  ];

  // Połącz wszystkie wpisy
  return [...staticPages, ...productEntries, ...blogEntries];
}

Kiedy budujesz aplikację, Next.js automatycznie wygeneruje plik /sitemap.xml na podstawie zwracanych danych. Dodatkowe korzyści tego podejścia:

  • Wbudowane typowanie TypeScript - dzięki MetadataRoute.Sitemap
  • Automatyczna walidacja - Next.js sprawdza poprawność struktury danych
  • Integracja z systemem kompilacji - mapa witryny jest generowana podczas budowania

Generowanie mapy witryny dla dużych stron: podejście wieloplikowe

Dla większych stron z tysiącami URL, zaleca się tworzenie wielu map witryn i indeksu map witryn. Oto przykład implementacji:

// app/sitemap-index.xml/route.ts
export async function GET() {
  const baseUrl = 'https://example.com';

  const sitemapIndex = `<?xml version="1.0" encoding="UTF-8"?>
    <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
      <sitemap>
        <loc>${baseUrl}/sitemaps/static-sitemap.xml</loc>
        <lastmod>${new Date().toISOString()}</lastmod>
      </sitemap>
      <sitemap>
        <loc>${baseUrl}/sitemaps/products-sitemap.xml</loc>
        <lastmod>${new Date().toISOString()}</lastmod>
      </sitemap>
      <sitemap>
        <loc>${baseUrl}/sitemaps/blog-sitemap.xml</loc>
        <lastmod>${new Date().toISOString()}</lastmod>
      </sitemap>
    </sitemapindex>`;

  return new Response(sitemapIndex, {
    headers: {
      'Content-Type': 'application/xml',
      'Cache-Control': 'public, max-age=3600, s-maxage=3600'
    }
  });
}

// app/sitemaps/static-sitemap.xml/route.ts
export async function GET() {
  // Logika generowania mapy statycznych stron...
}

// app/sitemaps/products-sitemap.xml/route.ts
export async function GET() {
  // Logika generowania mapy produktów...
}

// app/sitemaps/blog-sitemap.xml/route.ts
export async function GET() {
  // Logika generowania mapy blogów...
}

To podejście jest skalowalne i pozwala każdej mapie witryny pozostać poniżej limitu 50,000 URL (zalecany maksymalny rozmiar pojedynczej mapy witryny).

Tworzenie pliku robots.txt

Ręczne tworzenie robots.txt

Najprostszym sposobem jest stworzenie pliku Route Handler dla robots.txt:

// app/robots.txt/route.ts
export async function GET() {
  const robotsTxt = `# https://www.robotstxt.org/robotstxt.html
User-agent: *
Allow: /

Disallow: /admin/
Disallow: /api/
Disallow: /internal/

Sitemap: https://example.com/sitemap.xml`;

  return new Response(robotsTxt, {
    headers: {
      'Content-Type': 'text/plain',
      'Cache-Control': 'public, max-age=3600, s-maxage=3600'
    }
  });
}

Użycie funkcji robots() w Next.js

Next.js 13.4+ wprowadził również dedykowaną funkcję robots() do generowania pliku robots.txt:

// app/robots.ts
import { MetadataRoute } from 'next';

export default function robots(): MetadataRoute.Robots {
  return {
    rules: {
      userAgent: '*',
      allow: '/',
      disallow: ['/admin/', '/api/', '/internal/'],
    },
    sitemap: 'https://example.com/sitemap.xml',
  };
}

Podobnie jak w przypadku funkcji sitemap(), Next.js automatycznie wygeneruje plik /robots.txt na podstawie zwracanych danych, z wbudowaną walidacją i obsługą TypeScript.

Dynamiczne generowanie maps witryn i robots.txt

Dla bardziej zaawansowanych przypadków użycia, możesz tworzyć zależne od środowiska lub dynamiczne mapy witryn i pliki robots.txt:

// app/robots.ts
import { MetadataRoute } from 'next';

export default function robots(): MetadataRoute.Robots {
  // Różne zasady dla różnych środowisk
  const isProduction = process.env.NODE_ENV === 'production';

  if (!isProduction) {
    return {
      rules: {
        userAgent: '*',
        disallow: '/',
      },
    };
  }

  return {
    rules: {
      userAgent: '*',
      allow: '/',
      disallow: ['/admin/', '/api/'],
    },
    sitemap: 'https://example.com/sitemap.xml',
  };
}

W powyższym przykładzie, w środowisku deweloperskim robots.txt blokuje indeksację całej witryny, podczas gdy w produkcji pozwala na indeksację większości stron.

Weryfikacja i testowanie

Po wdrożeniu map witryn i pliku robots.txt, ważne jest ich przetestowanie, aby upewnić się, że działają poprawnie:

Narzędzia do testowania

  1. Google Search Console - dodaj swoją stronę i prześlij mapę witryny do weryfikacji
  2. Bing Webmaster Tools - podobnie jak Google, oferuje narzędzia do weryfikacji
  3. Narzędzia sprawdzania map witryn i Robots.txt:

Ręczna weryfikacja

Możesz także ręcznie sprawdzić swoje pliki, aby upewnić się, że zawierają oczekiwane dane:

  1. Odwiedź https://yourdomain.com/sitemap.xml w przeglądarce - powinien pokazać się poprawnie sformatowany plik XML
  2. Odwiedź https://yourdomain.com/robots.txt - powinien pokazać się poprawny plik tekstowy
  3. Sprawdź przykładowe URL z mapy witryny, aby upewnić się, że są one dostępne i zawierają oczekiwaną treść

Najlepsze praktyki

Dla map witryn

  1. Aktualizuj regularnie - generuj mapy witryn przy każdym wdrożeniu lub zmianie treści
  2. Uwzględniaj tylko kanoniczne URL - unikaj duplikatów i wersji alternatywnych tej samej treści
  3. Używaj dokładnych dat lastmod - nie generuj daty dynamicznie, jeśli treść się nie zmieniła
  4. Uwzględniaj tylko ważne strony - pomijaj strony administracyjne, logowania, koszyki itp.
  5. Uwzględniaj alternatywne wersje językowe - używaj elementu <xhtml:link rel="alternate"> dla wielojęzycznych stron

Dla pliku robots.txt

  1. Bądź selektywny z Disallow - blokuj tylko te ścieżki, które naprawdę nie powinny być indeksowane
  2. Używaj odpowiednich User-agent - rozważ różne zasady dla różnych robotów
  3. Dodaj link do mapy witryny - zawsze uwzględniaj odniesienie do sitemap.xml
  4. Komentuj swoje zasady - dodawaj komentarze wyjaśniające, dlaczego blokujesz określone ścieżki
  5. Testuj zmiany - weryfikuj, czy zmiany w robots.txt nie blokują ważnych stron

Automatyzacja aktualizacji map witryn

Dla stron, które często się zmieniają, rozważ automatyzację generowania map witryn:

// scripts/generate-sitemap.js
const fs = require('fs');
const path = require('path');
const { getAllDynamicPaths } = require('../lib/api');

async function generateSitemap() {
  console.log('Generowanie mapy witryny...');

  // Pobierz wszystkie dynamiczne ścieżki
  const dynamicPaths = await getAllDynamicPaths();

  // Generuj XML
  const date = new Date().toISOString();
  const sitemap = `<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>https://example.com</loc>
    <lastmod>${date}</lastmod>
    <priority>1.0</priority>
  </url>
  ${dynamicPaths.map(path => `
  <url>
    <loc>https://example.com${path}</loc>
    <lastmod>${date}</lastmod>
    <priority>0.8</priority>
  </url>
  `).join('')}
</urlset>`;

  // Zapisz do pliku
  const publicPath = path.join(process.cwd(), 'public');
  fs.writeFileSync(path.join(publicPath, 'sitemap.xml'), sitemap);

  console.log('Mapa witryny wygenerowana pomyślnie!');
}

generateSitemap().catch(console.error);

Skrypt ten można uruchamiać jako krok w procesie wdrażania lub poprzez zaplanowane zadanie.

Integracja z CMS

Jeśli korzystasz z CMS (Content Management System), możesz automatycznie generować mapy witryn na podstawie zawartości zarządzanej przez CMS:

// app/sitemap.ts
import { MetadataRoute } from 'next';
import { getCmsClient } from '@/lib/cms';

export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
  const cms = getCmsClient();

  // Pobierz wszystkie strony z CMS
  const pages = await cms.getPages();
  const pageEntries = pages.map(page => ({
    url: `https://example.com/${page.slug}`,
    lastModified: new Date(page.updatedAt),
    changeFrequency: 'weekly' as const,
    priority: 0.8,
  }));

  // Pobierz wszystkie posty z CMS
  const posts = await cms.getPosts();
  const postEntries = posts.map(post => ({
    url: `https://example.com/blog/${post.slug}`,
    lastModified: new Date(post.updatedAt),
    changeFrequency: 'weekly' as const,
    priority: 0.7,
  }));

  // Połącz wszystkie wpisy
  return [
    {
      url: 'https://example.com',
      lastModified: new Date(),
      changeFrequency: 'daily' as const,
      priority: 1.0,
    },
    ...pageEntries,
    ...postEntries,
  ];
}

Obsługa map witryn obrazów i wideo

Dla stron z dużą ilością obrazów lub wideo, warto rozważyć specjalne mapy witryn:

Mapa witryny obrazów

// app/image-sitemap.xml/route.ts
import { getAllProductImages } from '@/lib/products';

export async function GET() {
  const images = await getAllProductImages();

  const sitemap = `<?xml version="1.0" encoding="UTF-8"?>
    <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
            xmlns:image="http://www.google.com/schemas/sitemap-image/1.1">
      ${images.map(image => `
        <url>
          <loc>https://example.com/products/${image.productSlug}</loc>
          <image:image>
            <image:loc>https://example.com${image.url}</image:loc>
            <image:title>${image.title}</image:title>
            <image:caption>${image.caption}</image:caption>
          </image:image>
        </url>
      `).join('')}
    </urlset>`;

  return new Response(sitemap, {
    headers: {
      'Content-Type': 'application/xml',
      'Cache-Control': 'public, max-age=3600, s-maxage=3600'
    }
  });
}

Podsumowanie

Mapa witryny i plik robots.txt to kluczowe elementy każdej aplikacji Next.js, które chcą być widoczne w wynikach wyszukiwania. Next.js 13.4+ wprowadził dedykowane funkcje sitemap() i robots(), które znacznie upraszczają proces generowania tych plików, zapewniając jednocześnie wsparcie dla TypeScript i automatyczną walidację.

Pamiętaj, że skuteczne SEO to nie tylko techniczne aspekty jak mapy witryn, ale szerszy zestaw praktyk, w tym jakość treści, szybkość ładowania i dostępność. Generowanie map witryn i robots.txt to jednak ważny krok w kierunku zwiększenia widoczności twojej aplikacji Next.js w wyszukiwarkach internetowych.

Kod do tej lekcji: App.tsx
import React, { useState } from 'react';

// Demo: Generowanie map witryn (sitemap) i robots.txt
interface SitemapEntry {
  url: string;
  lastModified: string;
  changeFrequency: string;
  priority: number;
}

function SitemapGenerator() {
  const [pages, setPages] = useState<SitemapEntry[]>([
    { url: 'https://example.com', lastModified: '2024-01-15', changeFrequency: 'daily', priority: 1.0 },
    { url: 'https://example.com/about', lastModified: '2024-01-10', changeFrequency: 'monthly', priority: 0.8 },
    { url: 'https://example.com/blog', lastModified: '2024-01-14', changeFrequency: 'weekly', priority: 0.9 },
    { url: 'https://example.com/contact', lastModified: '2024-01-01', changeFrequency: 'yearly', priority: 0.5 },
  ]);
  const [showSitemap, setShowSitemap] = useState(false);
  const [showRobots, setShowRobots] = useState(false);
  const [newUrl, setNewUrl] = useState('');
  const [newPriority, setNewPriority] = useState(0.5);

  const [robotsConfig, setRobotsConfig] = useState({
    allowAll: true,
    disallowAdmin: true,
    disallowApi: true,
    sitemapUrl: 'https://example.com/sitemap.xml',
  });

  const addPage = () => {
    if (!newUrl.trim()) return;
    setPages(prev => [...prev, {
      url: newUrl.startsWith('http') ? newUrl : 'https://example.com' + newUrl,
      lastModified: new Date().toISOString().split('T')[0],
      changeFrequency: 'weekly',
      priority: newPriority,
    }]);
    setNewUrl('');
  };

  const removePage = (url: string) => setPages(prev => prev.filter(p => p.url !== url));

  const sitemapXml = `<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
${pages.map(p => `  <url>
    <loc>${p.url}</loc>
    <lastmod>${p.lastModified}</lastmod>
    <changefreq>${p.changeFrequency}</changefreq>
    <priority>${p.priority}</priority>
  </url>`).join('\n')}
</urlset>`;

  const robotsTxt = `User-agent: *
${robotsConfig.allowAll ? 'Allow: /' : 'Disallow: /'}
${robotsConfig.disallowAdmin ? 'Disallow: /admin\nDisallow: /admin/*' : ''}
${robotsConfig.disallowApi ? 'Disallow: /api\nDisallow: /api/*' : ''}

Sitemap: ${robotsConfig.sitemapUrl}`;

  const nextjsCode = `// app/sitemap.ts
import { MetadataRoute } from 'next';

export default function sitemap(): MetadataRoute.Sitemap {
  return [
${pages.map(p => `    { url: '${p.url}', lastModified: '${p.lastModified}', changeFrequency: '${p.changeFrequency}', priority: ${p.priority} },`).join('\n')}
  ];
}`;

  return (
    <div style={{ background: '#0f0f23', minHeight: '100vh', padding: '20px', color: '#e0e0e0', fontFamily: 'system-ui' }}>
      <h1 style={{ color: '#64ffda', marginBottom: '8px' }}>Sitemap & robots.txt Generator</h1>
      <p style={{ color: '#8892b0', marginBottom: '24px' }}>Generuj mapy witryn i robots.txt dla Next.js</p>

      <div style={{ display: 'flex', gap: '12px', marginBottom: '20px', flexWrap: 'wrap' }}>
        <input value={newUrl} onChange={e => setNewUrl(e.target.value)} placeholder="/nowa-strona" style={{ padding: '8px 12px', borderRadius: '6px', background: '#1a1a2e', color: '#fff', border: '1px solid #333', flex: 1, minWidth: '200px' }} />
        <input type="range" min="0" max="1" step="0.1" value={newPriority} onChange={e => setNewPriority(parseFloat(e.target.value))} style={{ width: '100px' }} />
        <span style={{ color: '#8892b0', fontSize: '14px' }}>Priority: {newPriority}</span>
        <button onClick={addPage} style={{ padding: '8px 16px', borderRadius: '6px', background: '#64ffda', color: '#0f0f23', border: 'none', cursor: 'pointer', fontWeight: 'bold' }}>+ Dodaj</button>
      </div>

      <div style={{ display: 'grid', gap: '8px', marginBottom: '24px' }}>
        {pages.map(p => (
          <div key={p.url} style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', padding: '10px 16px', background: '#1a1a2e', borderRadius: '8px', border: '1px solid #333' }}>
            <div>
              <code style={{ color: '#64ffda' }}>{p.url}</code>
              <div style={{ fontSize: '12px', color: '#8892b0' }}>
                Priority: {p.priority} | Freq: {p.changeFrequency} | Modified: {p.lastModified}
              </div>
            </div>
            <button onClick={() => removePage(p.url)} style={{ background: '#ef4444', color: '#fff', border: 'none', borderRadius: '4px', padding: '4px 8px', cursor: 'pointer', fontSize: '12px' }}>X</button>
          </div>
        ))}
      </div>

      <div style={{ display: 'flex', gap: '8px', marginBottom: '16px' }}>
        <button onClick={() => { setShowSitemap(!showSitemap); setShowRobots(false); }} style={{ padding: '10px 20px', borderRadius: '8px', background: showSitemap ? '#64ffda' : '#1a1a2e', color: showSitemap ? '#0f0f23' : '#8892b0', border: 'none', cursor: 'pointer', fontWeight: 'bold' }}>sitemap.xml</button>
        <button onClick={() => { setShowRobots(!showRobots); setShowSitemap(false); }} style={{ padding: '10px 20px', borderRadius: '8px', background: showRobots ? '#64ffda' : '#1a1a2e', color: showRobots ? '#0f0f23' : '#8892b0', border: 'none', cursor: 'pointer', fontWeight: 'bold' }}>robots.txt</button>
      </div>

      {showSitemap && (
        <div>
          <h3 style={{ color: '#f59e0b', fontSize: '14px' }}>Wygenerowany sitemap.xml:</h3>
          <pre style={{ background: '#1a1a2e', padding: '16px', borderRadius: '8px', fontSize: '12px', overflow: 'auto', border: '1px solid #333', color: '#e0e0e0', whiteSpace: 'pre-wrap' }}>{sitemapXml}</pre>
          <h3 style={{ color: '#64ffda', fontSize: '14px', marginTop: '16px' }}>Kod Next.js (app/sitemap.ts):</h3>
          <pre style={{ background: '#1a1a2e', padding: '16px', borderRadius: '8px', fontSize: '12px', overflow: 'auto', border: '1px solid #333', color: '#64ffda', whiteSpace: 'pre-wrap' }}>{nextjsCode}</pre>
        </div>
      )}

      {showRobots && (
        <div>
          <div style={{ background: '#1a1a2e', padding: '16px', borderRadius: '8px', border: '1px solid #333', marginBottom: '16px' }}>
            <h3 style={{ color: '#f59e0b', fontSize: '14px', marginTop: 0 }}>Konfiguracja robots.txt:</h3>
            {[
              { key: 'allowAll', label: 'Allow all pages' },
              { key: 'disallowAdmin', label: 'Disallow /admin' },
              { key: 'disallowApi', label: 'Disallow /api' },
            ].map(opt => (
              <label key={opt.key} style={{ display: 'flex', alignItems: 'center', gap: '8px', marginBottom: '8px', cursor: 'pointer' }}>
                <input type="checkbox" checked={(robotsConfig as any)[opt.key]} onChange={e => setRobotsConfig(prev => ({ ...prev, [opt.key]: e.target.checked }))} />
                {opt.label}
              </label>
            ))}
          </div>
          <pre style={{ background: '#1a1a2e', padding: '16px', borderRadius: '8px', fontSize: '12px', overflow: 'auto', border: '1px solid #333', color: '#e0e0e0', whiteSpace: 'pre-wrap' }}>{robotsTxt}</pre>
        </div>
      )}
    </div>
  );
}

export default SitemapGenerator;

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Zadania praktyczne w grze

  • Układanie w pionie

    Ułóż elementy w prawidłowej kolejności: import { headers } → from 'next/headers'

  • Edytor kodu

    Utwórz next.config.js z optymalizacjami production: compression, webpack bundle analyzer, image optimization

  1. Ułóż w kolejnościKolejność: import { headers } → from 'next/headers'
  2. Zadanie z kodemPraktyka: Utwórz next.config.js z optymalizacjami

Przydatne artykuły