Kurs Next.js · Moduł 8: Deployment i produkcja
Generowanie map witryn i robots.txt
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:
- Odkrywanie zawartości - informuje o wszystkich stronach na Twojej witrynie
- Efektywne indeksowanie - pomaga zrozumieć strukturę witryny
- Priorytyzacja - wskazuje, które strony są najważniejsze
- 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:
- Kontrola dostępu - określa, które strony mogą być indeksowane, a które nie
- Zarządzanie ruchem botów - zapobiega przeciążeniu serwera przez ograniczenie dostępu
- 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
- Google Search Console - dodaj swoją stronę i prześlij mapę witryny do weryfikacji
- Bing Webmaster Tools - podobnie jak Google, oferuje narzędzia do weryfikacji
- 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:
- Odwiedź
https://yourdomain.com/sitemap.xmlw przeglądarce - powinien pokazać się poprawnie sformatowany plik XML - Odwiedź
https://yourdomain.com/robots.txt- powinien pokazać się poprawny plik tekstowy - Sprawdź przykładowe URL z mapy witryny, aby upewnić się, że są one dostępne i zawierają oczekiwaną treść
Najlepsze praktyki
Dla map witryn
- Aktualizuj regularnie - generuj mapy witryn przy każdym wdrożeniu lub zmianie treści
- Uwzględniaj tylko kanoniczne URL - unikaj duplikatów i wersji alternatywnych tej samej treści
- Używaj dokładnych dat lastmod - nie generuj daty dynamicznie, jeśli treść się nie zmieniła
- Uwzględniaj tylko ważne strony - pomijaj strony administracyjne, logowania, koszyki itp.
- Uwzględniaj alternatywne wersje językowe - używaj elementu
<xhtml:link rel="alternate">dla wielojęzycznych stron
Dla pliku robots.txt
- Bądź selektywny z Disallow - blokuj tylko te ścieżki, które naprawdę nie powinny być indeksowane
- Używaj odpowiednich User-agent - rozważ różne zasady dla różnych robotów
- Dodaj link do mapy witryny - zawsze uwzględniaj odniesienie do sitemap.xml
- Komentuj swoje zasady - dodawaj komentarze wyjaśniające, dlaczego blokujesz określone ścieżki
- 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