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

Open Graph i udostępnianie na platformach społecznościowych

10 min czytania ·
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:

  1. og:title - tytuł treści
  2. og:type - typ treści (np. website, article, product)
  3. og:image - URL obrazu, który powinien reprezentować treść
  4. og:url - kanoniczny URL treści

Dodatkowe przydatne tagi obejmują:

  1. og:description - krótki opis treści
  2. og:site_name - nazwa witryny
  3. 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:

  1. twitter:card - typ karty (summary, summary_large_image, app, player)
  2. twitter:title - tytuł treści
  3. twitter:description - opis treści
  4. twitter:image - obrazek do wyświetlenia
  5. twitter:site - nazwa konta witryny (@nazwawitryny)
  6. 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

  1. Facebook/Open Graph:

    • Zalecane: 1200 × 630 pikseli
    • Minimalnie: 600 × 315 pikseli
    • Proporcje: 1.91:1
  2. Twitter:

    • Duża karta (summary_large_image): 1200 × 628 pikseli
    • Zwykła karta (summary): 800 × 418 pikseli
  3. LinkedIn:

    • Zalecane: 1200 × 627 pikseli
    • Proporcje: 1.91:1
  4. 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

  1. Facebook Sharing Debugger: https://developers.facebook.com/tools/debug/
  2. Twitter Card Validator: https://cards-dev.twitter.com/validator
  3. LinkedIn Post Inspector: https://www.linkedin.com/post-inspector/
  4. 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

  1. Optymalizuj obrazy - Używaj obrazów o odpowiednich wymiarach i proporcjach dla każdej platformy
  2. Używaj unikalnych obrazów - Twórz unikalne i przyciągające wzrok obrazy dla ważnych stron
  3. Dodaj branding - Umieść logo lub elementy identyfikacji wizualnej na obrazach OG
  4. Testuj na różnych platformach - Sprawdź, jak udostępniane treści wyglądają na wszystkich najważniejszych platformach
  5. Eksperymentuj z tytułami - Testuj różne tytuły i opisy, aby zwiększyć CTR z udostępnień
  6. 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?

Przydatne artykuły