Kurs Next.js · Moduł 8: Deployment i produkcja
Open Graph i udostępnianie na platformach społecznościowych
W tej lekcji9
Odpowiednie udostępnianie treści w mediach społecznościowych to kluczowy element strategii marketingowej i SEO każdej nowoczesnej aplikacji. Protokoły takie jak Open Graph i Twitter Cards pozwalają na kontrolę wyglądu udostępnianych linków, co znacznie zwiększa ich atrakcyjność i skuteczność. W tym rozdziale dowiesz się, jak zoptymalizować swoją aplikację Next.js pod kątem udostępniania w mediach społecznościowych.
Czym jest Open Graph Protocol?
Open Graph Protocol (OGP) to technologia opracowana przez Facebook, która umożliwia każdej stronie internetowej stanie się bogatym obiektem w mediach społecznościowych. Gdy użytkownik udostępnia link do twojej strony na Facebooku, LinkedInie czy innych platformach społecznościowych, protokół OG określa, jakie informacje i elementy wizualne powinny być wyświetlane.
Podstawowe tagi Open Graph
Podstawowy zestaw tagów Open Graph obejmuje:
- og:title - tytuł treści
- og:type - typ treści (np. website, article, product)
- og:image - URL obrazu, który powinien reprezentować treść
- og:url - kanoniczny URL treści
Dodatkowe przydatne tagi obejmują:
- og:description - krótki opis treści
- og:site_name - nazwa witryny
- og:locale - język treści (np. pl_PL)
Twitter Cards
Twitter Cards to podobna technologia, specyficzna dla platformy Twitter (X), która kontroluje sposób wyświetlania udostępnionych treści. Najważniejsze tagi to:
- twitter:card - typ karty (summary, summary_large_image, app, player)
- twitter:title - tytuł treści
- twitter:description - opis treści
- twitter:image - obrazek do wyświetlenia
- twitter:site - nazwa konta witryny (@nazwawitryny)
- twitter:creator - nazwa konta autora treści (@autor)
Implementacja Open Graph w Next.js
Next.js 13+ znacznie upraszcza implementację protokołu Open Graph poprzez nowe API Metadanych. Oto jak to zrobić:
Podstawowa implementacja
// app/page.tsx
import { Metadata } from 'next';
export const metadata: Metadata = {
openGraph: {
title: 'Moja aplikacja Next.js',
description: 'Poznaj możliwości naszej aplikacji',
url: 'https://twojadomena.pl',
siteName: 'Nazwa Twojej Strony',
images: [
{
url: 'https://twojadomena.pl/og-image.jpg',
width: 1200,
height: 630,
alt: 'Moja aplikacja Next.js',
},
],
locale: 'pl_PL',
type: 'website',
},
twitter: {
card: 'summary_large_image',
title: 'Moja aplikacja Next.js',
description: 'Poznaj możliwości naszej aplikacji',
images: ['https://twojadomena.pl/twitter-image.jpg'],
creator: '@twojanazwa',
site: '@twojastrona',
},
};
export default function Home() {
return (
<main>
{/* Treść strony */}
</main>
);
}Dynamiczne metadane Open Graph
Dla stron dynamicznych, takich jak artykuły bloga czy produkty, możemy generować metadane Open Graph na podstawie danych z API lub bazy danych:
// app/blog/[slug]/page.tsx
import { Metadata } from 'next';
import { getBlogPost } from '@/lib/api';
export async function generateMetadata({ params }): Promise<Metadata> {
const post = await getBlogPost((await params).slug);
if (!post) {
return {
openGraph: {
title: 'Post nie znaleziony',
description: 'Przepraszamy, nie znaleźliśmy szukanego artykułu',
type: 'article',
},
};
}
// Podstawowe informacje
const title = `${post.title} | Blog Moja Aplikacja`;
const description = post.excerpt;
const url = `https://twojadomena.pl/blog/${post.slug}`;
// Metadane Open Graph dla artykułu
return {
openGraph: {
title: title,
description: description,
url: url,
siteName: 'Nazwa Twojej Strony',
images: [
{
url: post.coverImage || 'https://twojadomena.pl/default-og.jpg',
width: 1200,
height: 630,
alt: post.title,
},
],
locale: 'pl_PL',
type: 'article',
publishedTime: post.publishedAt,
authors: post.author.name,
tags: post.tags,
},
twitter: {
card: 'summary_large_image',
title: title,
description: description,
images: [post.coverImage || 'https://twojadomena.pl/default-twitter.jpg'],
creator: post.author.twitter || '@twojanazwa',
site: '@twojastrona',
},
};
}
export default async function BlogPost({ params }) {
const post = await getBlogPost((await params).slug);
if (!post) {
return <div>Post nie znaleziony</div>;
}
return (
<article>
<h1>{post.title}</h1>
<div dangerouslySetInnerHTML={{ __html: post.content }} />
</article>
);
}Tworzenie i optymalizacja obrazów dla mediów społecznościowych
Każda platforma społecznościowa ma swoje zalecane wymiary obrazów. Przygotowanie obrazów zgodnie z tymi wytycznymi zapewnia najlepsze doświadczenie podczas udostępniania:
Zalecane wymiary obrazów
Facebook/Open Graph:
- Zalecane: 1200 × 630 pikseli
- Minimalnie: 600 × 315 pikseli
- Proporcje: 1.91:1
Twitter:
- Duża karta (summary_large_image): 1200 × 628 pikseli
- Zwykła karta (summary): 800 × 418 pikseli
LinkedIn:
- Zalecane: 1200 × 627 pikseli
- Proporcje: 1.91:1
Pinterest:
- Zalecane: 1000 × 1500 pikseli
- Proporcje: 2:3
Dynamiczna generacja obrazów Open Graph
Zamiast ręcznie tworzyć obrazy dla każdej strony, możemy generować je dynamicznie przy użyciu API Routes w Next.js. To świetne rozwiązanie dla aplikacji z dużą liczbą dynamicznych stron, takich jak e-commerce czy blogi:
// app/api/og/route.tsx
import { ImageResponse } from 'next/og';
import { NextRequest } from 'next/server';
export const runtime = 'edge';
export async function GET(req: NextRequest) {
const { searchParams } = new URL(req.url);
// Pobierz parametry z URL
const title = searchParams.get('title') || 'Moja Aplikacja';
const description = searchParams.get('description') || 'Domyślny opis';
const imageUrl = searchParams.get('image');
// Określ kolory, czcionki i styl
const bgColor = '#111827';
const textColor = '#ffffff';
// Można również pobierać czcionki dynamicznie
// const font = await fetch('...').then(res => res.arrayBuffer());
return new ImageResponse(
(
<div
style={{
display: 'flex',
flexDirection: 'column',
alignItems: 'center',
justifyContent: 'center',
width: '100%',
height: '100%',
backgroundColor: bgColor,
color: textColor,
padding: '40px',
position: 'relative',
}}
>
{imageUrl && (
<img
src={imageUrl}
style={{
position: 'absolute',
top: 0,
left: 0,
width: '100%',
height: '100%',
objectFit: 'cover',
opacity: 0.6,
}}
/>
)}
<div
style={{
display: 'flex',
flexDirection: 'column',
zIndex: 10,
maxWidth: '80%',
textAlign: 'center',
}}
>
<h1 style={{ fontSize: '64px', fontWeight: 'bold', marginBottom: '20px' }}>
{title}
</h1>
<p style={{ fontSize: '32px', margin: 0 }}>
{description}
</p>
<div style={{
marginTop: '40px',
display: 'flex',
alignItems: 'center',
justifyContent: 'center'
}}>
<img
src="https://twojadomena.pl/logo.png"
width="60"
height="60"
style={{ marginRight: '20px' }}
/>
<p style={{ fontSize: '36px', fontWeight: 'bold' }}>mojadomena.pl</p>
</div>
</div>
</div>
),
{
width: 1200,
height: 630,
// Opcjonalnie możesz zastosować czcionki
// fonts: [{ name: 'Inter', data: font, weight: 400 }],
},
);
}Używanie dynamicznie generowanych obrazów Open Graph:
// app/blog/[slug]/page.tsx
export async function generateMetadata({ params }) {
const post = await getBlogPost((await params).slug);
const ogImageUrl = new URL('/api/og', 'https://twojadomena.pl');
ogImageUrl.searchParams.append('title', post.title);
ogImageUrl.searchParams.append('description', post.excerpt);
if (post.coverImage) {
ogImageUrl.searchParams.append('image', post.coverImage);
}
return {
openGraph: {
// ...inne metadane
images: [
{
url: ogImageUrl.toString(),
width: 1200,
height: 630,
alt: post.title,
},
],
},
//
};
}Przyciski udostępniania w mediach społecznościowych
Dodanie przycisków udostępniania do twojej aplikacji to skuteczny sposób na zwiększenie zasięgu. Oto jak zaimplementować je w Next.js:
Komponent ShareButtons
// components/ShareButtons.tsx
'use client';
import { usePathname } from 'next/navigation';
import { FaFacebook, FaTwitter, FaLinkedin, FaPinterest, FaEnvelope } from 'react-icons/fa';
interface ShareButtonsProps {
title: string;
description?: string;
imageUrl?: string;
hashtags?: string[];
}
export default function ShareButtons({ title, description, imageUrl, hashtags = [] }: ShareButtonsProps) {
const pathname = usePathname();
// Tworzymy pełny adres URL
const baseUrl = 'https://twojadomena.pl';
const url = baseUrl + pathname;
// Kodujemy parametry do udostępniania
const encodedUrl = encodeURIComponent(url);
const encodedTitle = encodeURIComponent(title);
const encodedDescription = description ? encodeURIComponent(description) : '';
const encodedHashtags = hashtags.length > 0 ? encodeURIComponent(hashtags.join(',')) : '';
// Tworzymy linki do udostępniania
const facebookShareUrl = `https://www.facebook.com/sharer/sharer.php?u=${encodedUrl}`;
const twitterShareUrl = `https://twitter.com/intent/tweet?url=${encodedUrl}&text=${encodedTitle}&hashtags=${encodedHashtags}`;
const linkedinShareUrl = `https://www.linkedin.com/sharing/share-offsite/?url=${encodedUrl}`;
const pinterestShareUrl = imageUrl
? `https://pinterest.com/pin/create/button/?url=${encodedUrl}&media=${encodeURIComponent(imageUrl)}&description=${encodedTitle}`
: `https://pinterest.com/pin/create/button/?url=${encodedUrl}&description=${encodedTitle}`;
const emailShareUrl = `mailto:?subject=${encodedTitle}&body=${encodedDescription}%0A%0A${encodedUrl}`;
// Funkcja obsługująca kliknięcie w przycisk udostępniania
const handleShare = (url: string) => {
window.open(url, '_blank', 'width=600,height=400');
};
return (
<div className="flex space-x-4 items-center">
<span className="text-sm font-medium text-gray-700">Udostępnij: </span>
<button
className="text-blue-600 hover:text-blue-800 transition-colors"
onClick={() => handleShare(facebookShareUrl)}
aria-label="Udostępnij na Facebooku"
>
<FaFacebook size={24} />
</button>
<button
className="text-sky-500 hover:text-sky-700 transition-colors"
onClick={() => handleShare(twitterShareUrl)}
aria-label="Udostępnij na Twitterze"
>
<FaTwitter size={24} />
</button>
<button
className="text-blue-700 hover:text-blue-900 transition-colors"
onClick={() => handleShare(linkedinShareUrl)}
aria-label="Udostępnij na LinkedIn"
>
<FaLinkedin size={24} />
</button>
<button
className="text-red-600 hover:text-red-800 transition-colors"
onClick={() => handleShare(pinterestShareUrl)}
aria-label="Udostępnij na Pinterest"
>
<FaPinterest size={24} />
</button>
<a
href={emailShareUrl}
className="text-gray-600 hover:text-gray-800 transition-colors"
aria-label="Udostępnij przez email"
>
<FaEnvelope size={24} />
</a>
</div>
);
}Użycie komponentu ShareButtons
// app/blog/[slug]/page.tsx
import ShareButtons from '@/components/ShareButtons';
import { getBlogPost } from '@/lib/api';
export default async function BlogPost({ params }) {
const post = await getBlogPost((await params).slug);
if (!post) {
return <div>Post nie znaleziony</div>;
}
return (
<article className="max-w-2xl mx-auto py-8">
<h1 className="text-3xl font-bold mb-4">{post.title}</h1>
<div className="my-6">
<ShareButtons
title={post.title}
description={post.excerpt}
imageUrl={post.coverImage}
hashtags={post.tags}
/>
</div>
<div className="prose max-w-none" dangerouslySetInnerHTML={{ __html: post.content }} />
<div className="mt-8 pt-4 border-t">
<ShareButtons
title={post.title}
description={post.excerpt}
imageUrl={post.coverImage}
hashtags={post.tags}
/>
</div>
</article>
);
}Integracja z Web Share API
Web Share API to nowoczesna alternatywa dla tradycyjnych przycisków udostępniania, która pozwala użytkownikom udostępniać treści za pomocą dowolnej aplikacji zainstalowanej na ich urządzeniu:
// components/NativeShareButton.tsx
'use client';
import { useState, useEffect } from 'react';
import { FaShare } from 'react-icons/fa';
import { usePathname } from 'next/navigation';
interface NativeShareProps {
title: string;
text?: string;
url?: string;
files?: File[];
}
export default function NativeShareButton({ title, text, url, files }: NativeShareProps) {
const [isShareSupported, setIsShareSupported] = useState(false);
const pathname = usePathname();
useEffect(() => {
// Sprawdź czy przeglądarka wspiera Web Share API
setIsShareSupported(
typeof navigator !== 'undefined' &&
!!navigator.share
);
}, []);
// Jeśli przeglądarka nie wspiera Web Share API, nie renderuj przycisku
if (!isShareSupported) {
return null;
}
const handleShare = async () => {
try {
const shareData: ShareData = {
title,
text: text || title,
url: url || window.location.href,
};
// Dodaj pliki, jeśli są dostępne i przeglądarka je obsługuje
if (files && navigator.canShare && navigator.canShare({ files })) {
shareData.files = files;
}
await navigator.share(shareData);
console.log('Treść została udostępniona');
} catch (error) {
console.error('Błąd podczas udostępniania:', error);
}
};
return (
<button
onClick={handleShare}
className="flex items-center space-x-2 bg-blue-600 hover:bg-blue-700 text-white px-4 py-2 rounded-md transition-colors"
aria-label="Udostępnij"
>
<FaShare />
<span>Udostępnij</span>
</button>
);
}Testowanie Open Graph i udostępniania
Poprawne skonfigurowanie Open Graph i Twitter Cards wymaga testowania. Oto narzędzia, które mogą pomóc:
Narzędzia debugowania
- Facebook Sharing Debugger: https://developers.facebook.com/tools/debug/
- Twitter Card Validator: https://cards-dev.twitter.com/validator
- LinkedIn Post Inspector: https://www.linkedin.com/post-inspector/
- Pinterest Rich Pins Validator: https://developers.pinterest.com/tools/url-debugger/
Automatyzacja testów Open Graph
Możesz zautomatyzować testy Open Graph w ramach procesu CI/CD:
// scripts/test-og-tags.mjs
import puppeteer from 'puppeteer';
import { promises as fs } from 'fs';
const pages = [
{ url: '/', name: 'home' },
{ url: '/blog/example-post', name: 'blog-post' },
{ url: '/products/example-product', name: 'product' },
// Dodaj inne ważne strony
];
async function testOgTags() {
const browser = await puppeteer.launch();
const results = [];
try {
for (const page of pages) {
const pageUrl = `https://twojadomena.pl${page.url}`;
const puppeteerPage = await browser.newPage();
await puppeteerPage.goto(pageUrl, { waitUntil: 'networkidle0' });
// Pobierz wszystkie tagi Open Graph
const ogTags = await puppeteerPage.evaluate(() => {
const tags = {};
const metaTags = document.querySelectorAll('meta[property^="og:"], meta[name^="twitter:"]');
metaTags.forEach(tag => {
const property = tag.getAttribute('property') || tag.getAttribute('name');
const content = tag.getAttribute('content');
tags[property] = content;
});
return tags;
});
// Sprawdź wymagane tagi
const requiredTags = ['og:title', 'og:description', 'og:image', 'og:url', 'twitter:card'];
const missingTags = requiredTags.filter(tag => !ogTags[tag]);
const result = {
page: page.name,
url: pageUrl,
ogTags,
missingTags,
hasErrors: missingTags.length > 0,
};
results.push(result);
await puppeteerPage.close();
}
// Zapisz raport
await fs.writeFile('./og-tags-report.json', JSON.stringify(results, null, 2));
// Czy wszystkie strony mają wymagane tagi
const hasErrors = results.some(result => result.hasErrors);
if (hasErrors) {
console.error('Znaleziono braki w tagach Open Graph:');
for (const result of results) {
if (result.hasErrors) {
console.error(`Strona: ${result.page}`);
console.error(`Brakujące tagi: ${result.missingTags.join(', ')}`);
console.error('---');
}
}
process.exit(1);
} else {
console.log('Wszystkie wymagane tagi Open Graph są obecne.');
}
} finally {
await browser.close();
}
}
testOgTags().catch(console.error);Najlepsze praktyki i porady
- Optymalizuj obrazy - Używaj obrazów o odpowiednich wymiarach i proporcjach dla każdej platformy
- Używaj unikalnych obrazów - Twórz unikalne i przyciągające wzrok obrazy dla ważnych stron
- Dodaj branding - Umieść logo lub elementy identyfikacji wizualnej na obrazach OG
- Testuj na różnych platformach - Sprawdź, jak udostępniane treści wyglądają na wszystkich najważniejszych platformach
- Eksperymentuj z tytułami - Testuj różne tytuły i opisy, aby zwiększyć CTR z udostępnień
- Aktualizuj metadane - Regularnie odświeżaj metadane dla stron z cyklicznymi treściami
Podsumowanie
Odpowiednia implementacja protokołów Open Graph i Twitter Cards oraz dobrze zaprojektowane przyciski udostępniania mogą znacząco zwiększyć widoczność i zasięg twojej aplikacji Next.js. Wykorzystanie dynamicznie generowanych obrazów OG pozwala na spersonalizowane i atrakcyjne wyświetlanie udostępnianych treści, a Web Share API oferuje natywne doświadczenie udostępniania na urządzeniach mobilnych.
Pamiętaj, że platformy społecznościowe często aktualizują swoje wymagania i zalecenia, dlatego warto regularnie sprawdzać dokumentację każdej platformy i testować udostępnianie treści na różnych urządzeniach i przeglądarkach.
Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?