Sign in Subscribe
By Thisara Priyamal —

Next.js SEO Metadata Sinhala Guide | වෙබ් අඩවි දර්ශනය වැඩි කරන්න

Next.js SEO Essentials: Mastering Metadata for Visibility SC Guide

ආයුබෝවන් යාළුවනේ! ✋ මේ දවස්වල Software Engineering ලෝකේ දියුණුව කොච්චරද කියනවනම්, අලුත් ටෙක්නොලොජිස් එන වේගෙත් එක්ක අපිට ඒ හැමදේම එක්ක අප්ඩේට් වෙලා ඉන්න එක අභියෝගයක් වෙලා. ඒත් අපි දන්නවා, ඩිජිටල් ලෝකයේ සාර්ථක වෙන්න නම්, හොඳ වෙබ්සයිට් එකක් හදනවා වගේම, ඒක මිනිස්සුන්ට හොයාගන්න පුළුවන් වෙන එකත් ඊටත් වඩා වැදගත් කියලා. මොකද, ඔයා කොච්චර ලස්සනට, හොඳට වෙබ්සයිට් එකක් හැදුවත්, ඒකට මිනිස්සු එන්නේ නැත්නම්, ඒකෙන් වැඩක් නෑ නේද? 🤷‍♂️

ඔන්න ඔය ප්‍රශ්නෙට විසඳුමක් තමයි Search Engine Optimization (SEO) කියන්නේ. සරලවම කිව්වොත්, Google, Bing වගේ Search Engines වල ඔයාගේ වෙබ්සයිට් එක ඉහළින් පෙන්නන්න කරන වැඩ ටික තමයි SEO. මේකෙදි අපිට ලොකු උදව්වක් කරන Framework එකක් තමයි Next.js කියන්නේ.

Next.js Framework එකේ තියෙන Server-Side Rendering (SSR) සහ Static Site Generation (SSG) වගේ හැකියාවන් නිසා, Search Engines වලට අපේ වෙබ්සයිට් එක ඉක්මනින් හා පහසුවෙන් කියවන්න පුළුවන් වෙනවා. අද අපි කතා කරන්නේ Next.js වල තියෙන Metadata කියන වැදගත් කොටස ගැන. මේකෙන් ඔයාගේ වෙබ්සයිට් එකේ Visibility එක වැඩි කරගන්න පුළුවන් කොහොමද කියලා අපි විස්තරාත්මකව බලමු. අපි `next/head` සහ Next.js 13+ App Router එකේ අලුත් Metadata API එක ගැනත් කතා කරනවා. එහෙනම්, අපි පටන් ගමු! 🚀

1. SEO වලට Metadata වල වැදගත්කම (The Importance of Metadata for SEO)

මුලින්ම බලමු මේ Metadata කියන්නේ මොකක්ද කියලා. සරලවම කිව්වොත්, Metadata කියන්නේ "data about data" කියන එක. වෙබ් අඩවියකදී, මේක තමයි ඔයාගේ වෙබ් පිටුව ගැන Search Engines වලට සහ social media platforms වලට කියන තොරතුරු ටික. මේවා සාමාන්‍යයෙන් අපිට වෙබ් පිටුවක පේන්නේ නැහැ, හැබැයි ඒක HTML එකේ `` tag එක ඇතුළේ සැඟවිලා තියෙනවා.

Metadata වර්ග කිහිපයක්:

  • <title> Tag එක: මේක තමයි ඔයාගේ වෙබ් පිටුවේ නම. Browser tab එකේ පෙන්නන්නෙත් මේකයි, Search Engine results වල ප්‍රධානම Headline එක විදියට එන්නෙත් මේකයි. මේක තමයි SEO වලට බලපාන වැදගත්ම Metadata එක. හැම පිටුවකටම අද්විතීය (unique) සහ විස්තරාත්මක (descriptive) title එකක් තිබිය යුතුයි.
  • <meta name="description" content="..." />: මේක තමයි ඔයාගේ වෙබ් පිටුව ගැන සාරාංශයක්. Search Engine results වල title එකට යටින් පෙන්නන්නේ මේ description එක. මේකත් unique වෙන්න ඕනේ වගේම, පිටුව ඇතුළේ තියෙන දේ හරියටම විස්තර කරන්න ඕනේ. Keywords දාන්නත් පුළුවන්.
  • <meta name="keywords" content="..." />: කාලෙකට කලින් මේක SEO වලට ගොඩක් වැදගත් වුණත්, දැන් Search Engines මේකට ලොකු වැදගත්කමක් දෙන්නේ නැහැ. ඒත් සමහර වෙබ් අඩවි වලට තාමත් මේක තියෙනවා.
  • Open Graph (OG) Tags: මේවා තමයි ඔයාගේ වෙබ් පිටුව Facebook, Twitter, LinkedIn වගේ social media platforms වල share කරද්දී පෙන්නන තොරතුරු පාලනය කරන්නේ. උදාහරණයක් විදියට: og:title, og:description, og:image, og:url. මේවා හරියට තිබුණොත්, ඔයාගේ link එක share කරද්දී ලස්සනට පේනවා වගේම, මිනිස්සුන්ට ක්ලික් කරන්න උනන්දුවක් ඇති වෙනවා.
  • Canonical URL: ඔයාගේ වෙබ් අඩවියේ එකම content එක විවිධ URLs යටතේ තිබුණොත් (උදා: www.example.com/page සහ example.com/page), Search Engines වලට ඒක duplicate content විදියට පේන්න පුළුවන්. Canonical URL එකකින් (<link rel="canonical" href="..." />) Search Engines වලට කියනවා "මේක තමයි මේ content එකේ original version එක" කියලා. මේක SEO penalty වලින් බේරෙන්න වැදගත්.

මේ Metadata එක එක පිටුවට වෙනස්, අද්විතීය විදියට තිබීම අත්‍යවශ්‍යයි. මොකද, Search Engines අපේ වෙබ් අඩවිය crawl කරද්දී, මේ Metadata කියවල තමයි ඔයාගේ පිටුව මොකක් ගැනද, මොන වගේ search query එකකටද අදාළ වෙන්නේ කියලා තේරුම් ගන්නේ. හරියට Metadata නොතිබුණොත්, ඔයාගේ වෙබ් අඩවිය Search Results වල පහළට යන්න පුළුවන්. ඒක හරියට, ඔයාගේ පොතේ නමක්, පිටකවරයක් නැතුව ලයිබ්‍රරි එකේ තියනවා වගේ දෙයක්. 📚

2. Next.js වල Metadata කළමනාකරණය - `pages` Router (Managing Metadata in Next.js - `pages` Router)

Next.js වලට කලින් HTML එකේ Metadata add කරන්න ඕන වුණානම්, අපිට ඒ HTML file එකේ `` tag එක ඇතුළට ගිහින් manually add කරන්න වෙනවා. ඒත් Next.js වලදී, ඒක ගොඩක් පහසු කරලා තියෙනවා. Next.js 13 ට කලින් තිබ්බ `pages` Router architecture එකේදී, අපි Metadata කළමනාකරණය කරන්න next/head Component එක භාවිත කළා.

`next/head` භාවිතය

next/head Component එක React component එකක් වගේම තමයි. ඔයාට ඕන කරන `` tags මේක ඇතුළේ දාන්න පුළුවන්. මේකෙන් වෙන්නේ, වෙබ් පිටුව render වෙනකොට, මේ `` tags ටික auto-magically වෙබ් පිටුවේ `` section එකට එකතු වෙන එක.

සාමාන්‍ය භාවිතය (Basic Usage):

මුල් පිටුවට (Home Page) Metadata එකතු කරන විදිය මේ උදාහරණයෙන් බලමු:

// pages/index.js
import Head from 'next/head';

export default function HomePage() {
  return (
    <>
      <Head>
        <title>Next.js SEO Essentials SC Guide</title>
        <meta name="description" content="Next.js භාවිතයෙන් වෙබ් අඩවි වල SEO වැඩි දියුණු කරගන්නා ආකාරය." />
        <meta property="og:title" content="Next.js SEO Essentials" />
        <meta property="og:description" content="Next.js භාවිතයෙන් වෙබ් අඩවි වල SEO වැඩි දියුණු කරගන්නා ආකාරය." />
        <meta property="og:image" content="https://yourwebsite.com/images/og-image.jpg" />
        <meta property="og:url" content="https://yourwebsite.com" />
        <link rel="canonical" href="https://yourwebsite.com" />
      </Head>
      <h1>Next.js SEO වලට සාදරයෙන් පිළිගනිමු!</h1>
      <p>මෙය අපගේ මුල් පිටුවයි.</p>
    </>
  );
}

මෙහිදී, අපි Head component එක import කරලා, අපිට ඕන කරන <title>, <meta>, <link> tags ටික ඒක ඇතුළේ දාලා තියෙනවා. Remember, <Head> component එකට ඇතුල් කරන tags ටික වෙබ් පිටුවේ <head> section එකට එකතු වෙනවා.

Dynamic Metadata එකතු කිරීම:

බ්ලොග් පෝස්ට් වගේ dynamic content එකක් තියෙන පිටු වලට, එක එක පෝස්ට් එකට වෙනස් Metadata එකතු කරන්න වෙනවා. මේකට අපි getServerSideProps හෝ getStaticProps වගේ Data Fetching functions එක්ක next/head භාවිත කරනවා.

// pages/posts/[slug].js
import Head from 'next/head';

export default function PostPage({ post }) {
  return (
    <>
      <Head>
        <title>{post.title} | My Blog SC Guide</title>
        <meta name="description" content={post.description} />
        <meta property="og:title" content={post.title} />
        <meta property="og:description" content={post.description} />
        <meta property="og:image" content={post.imageUrl} />
        <meta property="og:url" content={`https://yourwebsite.com/posts/${post.slug}`} />
        <link rel="canonical" href={`https://yourwebsite.com/posts/${post.slug}`} />
      </Head>
      <h1>{post.title}</h1>
      <p>{post.content}</p>
    </>
  );
}

// Static Site Generation (SSG) for pre-rendering blog posts
export async function getStaticProps({ params }) {
  // Simulate fetching post data from a database or API
  const postData = {
    'next-js-seo-basics': {
      title: 'Next.js SEO Basics: පළමු පියවර', 
      description: 'Next.js වල SEO ආරම්භ කරන හැටි. මූලික කරුණු.',
      imageUrl: 'https://yourwebsite.com/images/next-js-seo-basics.jpg',
      slug: 'next-js-seo-basics',
      content: 'මේක Next.js SEO ගැන පළමු පෝස්ට් එක.',
    },
    'advanced-next-js-metadata': {
      title: 'Advanced Next.js Metadata: ගැඹුරින් ඉගෙන ගනිමු',
      description: 'Dynamic metadata, Canonical URLs ගැන ගැඹුරින් ඉගෙන ගනිමු.',
      imageUrl: 'https://yourwebsite.com/images/advanced-next-js-metadata.jpg',
      slug: 'advanced-next-js-metadata',
      content: 'මේක Next.js metadata ගැන දෙවෙනි පෝස්ට් එක.',
    },
  };
  
  const post = postData[params.slug];

  if (!post) {
    return {
      notFound: true,
    };
  }

  return { props: { post } };
}

// Define which paths should be pre-rendered at build time
export async function getStaticPaths() {
  const paths = [
    { params: { slug: 'next-js-seo-basics' } },
    { params: { slug: 'advanced-next-js-metadata' } },
  ];
  return { paths, fallback: 'blocking' }; // 'blocking' for new paths not defined here
}

මේ උදාහරණයේදී, getStaticProps function එකෙන් අපිට dynamic post data fetch කරලා, ඒ data එක post prop එක විදියට component එකට pass කරන්න පුළුවන්. ඊට පස්සේ, next/head එක ඇතුළේ අපි ඒ post object එකේ තියෙන title, description, imageUrl වගේ properties පාවිච්චි කරලා dynamic Metadata generate කරනවා. getStaticPaths එකෙන් build time එකේදී pre-render කරන්න ඕන paths ටික specify කරනවා.

pages Router එකේදී, අපි සාමාන්‍යයෙන් _app.js file එකේ Common Layout එකක් හදනවා. ඒක ඇතුළෙත් next/head දාලා, වෙබ් අඩවියේ හැම පිටුවටම පොදු වෙන Metadata (උදා: site name, default OG image) දාන්න පුළුවන්. හැබැයි, තනි පිටුවක next/head එකකින් දාන Metadata, Common Layout එකේ තියෙන Metadata override කරනවා.

3. Next.js වල Metadata කළමනාකරණය - `App` Router (Managing Metadata in Next.js - `App` Router)

Next.js 13+ එක්ක එන අලුත්ම සහ recommended Architecture එක තමයි `App` Router කියන්නේ. මේකේදී Metadata කළමනාකරණය කරන විදිය pages Router එකට වඩා ටිකක් වෙනස්. ඒක තවත් පහසු, වඩාත් structured විදියක්. දැන් අපිට next/head Component එක වෙනුවට, JavaScript object එකක් export කරලා Metadata specify කරන්න පුළුවන්.

App Router එකේදී, Metadata specify කරන්න පුළුවන් විදිය දෙකක් තියෙනවා:

  • Static Metadata: Layouts (layout.js) හෝ Pages (page.js) වලින් metadata object එකක් export කිරීම.
  • Dynamic Metadata: generateMetadata function එකක් export කිරීම.

Static Metadata එකතු කිරීම:

මුළු වෙබ් අඩවියටම හෝ නිශ්චිත කොටසකට පොදු Metadata එකතු කරන්න මේ විදිය පාවිච්චි කරන්න පුළුවන්. උදාහරණයක් විදියට, app/layout.js එකේදී:

// app/layout.js

export const metadata = {
  title: 'Next.js SEO Essentials SC Guide',
  description: 'Next.js භාවිතයෙන් වෙබ් අඩවි වල SEO වැඩි දියුණු කරගන්නා ආකාරය.',
  openGraph: {
    title: 'Next.js SEO Essentials',
    description: 'Next.js භාවිතයෙන් වෙබ් අඩවි වල SEO වැඩි දියුණු කරගන්නා ආකාරය.',
    url: 'https://yourwebsite.com',
    images: [
      {
        url: 'https://yourwebsite.com/images/og-image.jpg',
        width: 800,
        height: 600,
        alt: 'Next.js SEO',
      },
    ],
  },
  canonical: 'https://yourwebsite.com',
  // Additional meta tags can be added here
  keywords: ['Next.js', 'SEO', 'Metadata', 'Web Development', 'Sinhala'],
  authors: [{ name: 'Your Name' }],
  robots: { index: true, follow: true },
};

export default function RootLayout({ children }) {
  return (
    <html lang="si">
      <body>{children}</body>
    </html>
  );
}

මෙහිදී, අපි metadata නමින් JavaScript object එකක් export කරලා තියෙනවා. Next.js මේ object එක auto-magically කියවලා, වෙබ් පිටුවේ `` section එකට අදාළ HTML tags generate කරනවා. මේක ඉතාම සංවිධානාත්මක හා කියවීමට පහසු ක්‍රමයක්.

Dynamic Metadata එකතු කිරීම:

App Router එකේදී dynamic content (උදා: blog posts, product pages) සඳහා Metadata add කරන්න generateMetadata කියන async function එක පාවිච්චි කරනවා.

// app/posts/[slug]/page.js
import { notFound } from 'next/navigation';

// Simulate a function to fetch post data from a database/API
async function getPostBySlug(slug) {
  const postData = {
    'next-js-seo-basics': {
      title: 'Next.js SEO Basics: පළමු පියවර', 
      description: 'Next.js වල SEO ආරම්භ කරන හැටි. මූලික කරුණු.',
      imageUrl: 'https://yourwebsite.com/images/next-js-seo-basics.jpg',
      slug: 'next-js-seo-basics',
      content: 'මේක Next.js SEO ගැන පළමු පෝස්ට් එක. Next.js App Router එකේ Metadata හසුරුවන ආකාරය මෙහිදී පැහැදිලි කෙරේ.',
    },
    'advanced-next-js-metadata': {
      title: 'Advanced Next.js Metadata: ගැඹුරින් ඉගෙන ගනිමු',
      description: 'Dynamic metadata, Canonical URLs ගැන App Router එකේ ගැඹුරින් ඉගෙන ගනිමු.',
      imageUrl: 'https://yourwebsite.com/images/advanced-next-js-metadata.jpg',
      slug: 'advanced-next-js-metadata',
      content: 'මේක Next.js metadata ගැන දෙවෙනි පෝස්ට් එක. App Router එකේ `generateMetadata` function එක ගැන වැඩි විස්තර මෙහි අඩංගුයි.',
    },
  };
  return postData[slug] || null;
}

// generateMetadata is an async function that can fetch data
export async function generateMetadata({ params }) {
  const post = await getPostBySlug(params.slug); // Fetch post data based on slug

  if (!post) {
    return { // Return basic metadata if post not found
      title: 'Post Not Found - Next.js Blog SC Guide',
      description: 'The requested blog post does not exist.',
    };
  }

  return {
    title: `${post.title} | My Next.js Blog SC Guide`,
    description: post.description,
    openGraph: {
      title: post.title,
      description: post.description,
      url: `https://yourwebsite.com/posts/${post.slug}`,
      images: [
        {
          url: post.imageUrl,
          width: 800,
          height: 600,
          alt: post.title,
        },
      ],
    },
    canonical: `https://yourwebsite.com/posts/${post.slug}`,
  };
}

export default async function PostPage({ params }) {
  const post = await getPostBySlug(params.slug);

  if (!post) {
    notFound(); // Next.js utility to show 404 page
  }

  return (
    <div>
      <h1>{post.title}</h1>
      <p>{post.content}</p>
    </div>
  );
}

generateMetadata function එක App Router එකේ server components වලදී ක්‍රියාත්මක වෙනවා. ඒක ඇතුළේදී අපිට Data Fetching කරන්න පුළුවන් (await keyword එක පාවිච්චි කරලා). මේකෙන් එන object එක වෙබ් පිටුවේ Metadata විදියට generate වෙනවා. මේක pages Router එකේදී getStaticProps/getServerSideProps එක්ක next/head භාවිත කරනවට වඩා simplified සහ efficient ක්‍රමයක්. 👍

4. Metadata තහවුරු කිරීම සහ හොඳම භාවිතයන් (Verifying Metadata & Best Practices)

Metadata add කලාට විතරක් මදි, ඒක හරියට වැඩ කරනවද කියලා අපි හැමවෙලේම check කරන්න ඕනේ. එහෙම නැත්නම්, අපි දාපු මහන්සිය අපතේ යන්න පුළුවන්.

Metadata check කරන විදිය:

  • Browser Developer Tools: ඕනෑම වෙබ් පිටුවකට ගිහින් Right-click කරලා "Inspect" (or "Inspect Element") කරන්න. Developer Tools open වුණාම "Elements" tab එකට ගිහින් `` tag එක expand කරලා ඔයාගේ Metadata tags හරියට තියෙනවද කියලා බලන්න.
  • View Page Source: Browser එකේ Right-click කරලා "View Page Source" (Ctrl+U or Cmd+U) කරන්න. එතකොට ඔයාගේ වෙබ් පිටුවේ raw HTML source code එක පෙනේවි. ඒක ඇතුළේ `` section එක බලලා Metadata tags verify කරන්න. මේ ක්‍රමය Search Engines ඔයාගේ පිටුව දකින විදියටම බලන්න පුළුවන් හොඳම විදියක්.
  • Social Media Debuggers: Facebook Debugger (Open Graph Debugger), Twitter Card Validator වගේ tools පාවිච්චි කරලා ඔයාගේ Open Graph tags social media වලට කොහොමද පේන්නේ කියලා බලන්න පුළුවන්. මේවා SEO වලට වගේම, Social Media Marketing වලටත් වැදගත්.
  • Online SEO Tools: Google Search Console, Ahrefs, SEMrush, Screaming Frog වගේ tools වලින් ඔයාගේ වෙබ් අඩවියේ SEO health එක, Metadata issues වගේ දේවල් analyze කරන්න පුළුවන්.

සාමාන්‍ය ගැටලු සහ ඒවාට විසඳුම් (Common Issues & Troubleshooting):

  • Duplicate Metadata: එකම title එක හෝ description එක පිටු කිහිපයකට තිබීම. මේකෙන් Search Engines වලට ඔයාගේ වෙබ් අඩවිය confuse වෙන්න පුළුවන්. විසඳුම: හැම පිටුවකටම unique, descriptive Metadata එකක් දෙන්න. Dynamic pages වලට dynamic Metadata use කරන්න.
  • Missing Metadata: සමහර පිටු වල Metadata කිසිසේත්ම නොතිබීම. විසඳුම: වෙබ් අඩවියේ හැම පිටුවකටම අනිවාර්යයෙන්ම title සහ description එකක් add කරන්න.
  • Too Short/Long Metadata: Title එක හෝ description එක Search Engine වලට පෙන්නන limit එකට වඩා කොට වැඩි වීම හෝ දිග වැඩි වීම. විසඳුම: Title එකට සාමාන්‍යයෙන් pixels 600ක් හෝ අකුරු 50-60ක් වගේ ප්‍රමාණයක් සහ Description එකට pixels 920ක් හෝ අකුරු 150-160ක් වගේ ප්‍රමාණයක් නිර්දේශ කරනවා.
  • Stale Data: වෙබ් පිටුවේ content එක update වුණාට Metadata update නොවීම. විසඳුම: Content එක update කරද්දී, Metadata එකත් ඒකට අනුකූලව update කරන්න.
  • Incorrect Open Graph Images: Social media share කරද්දී වැරදි image එකක් පෙන්නීම හෝ image එකක් නොපෙන්නීම. විසඳුම: Open Graph Debuggers පාවිච්චි කරලා images වල URL, size, format (JPEG, PNG) හරියට තියෙනවද කියලා බලන්න.

හොඳම භාවිතයන් (Best Practices):

  • Keyword Research: ඔයාගේ content එකට අදාළ, මිනිස්සු search කරන keywords මොනවද කියලා හොයලා, ඒවා title සහ description එකට ඇතුළත් කරන්න. හැබැයි, ඕනවට වඩා Keywords පුරවන්න එපා (Keyword Stuffing).
  • Clarity and Conciseness: Metadata එක පැහැදිලිව හා කෙටියෙන් ලියන්න. ඔයාගේ පිටුව ගැන හරියටම තේරෙන්න ඕනේ.
  • Call to Action (for descriptions): Description එක ඇතුළේ "වැඩි විස්තර සඳහා පිවිසෙන්න", "දැන්ම මිලදී ගන්න" වගේ call to action එකක් දාන්න පුරුදු වෙන්න.
  • Mobile-Friendliness: ඔයාගේ වෙබ් අඩවිය mobile devices වලටත් හරියට render වෙනවද කියලා බලන්න. Mobile-first indexing නිසා මේක ගොඩක් වැදගත්. Next.js මේකට හොඳටම උදව් කරනවා.
  • Fast Loading Times: වෙබ් අඩවිය වේගයෙන් load වෙන එක Search Engines වලට වගේම, users ලාටත් වැදගත්. Next.js වල SSR, SSG වගේ features මේකට උදව් කරනවා.
  • Structured Data (Schema.org): වෙලාව තියෙනවා නම්, Schema.org වගේ Structured Data Markup එකතු කරන්න බලන්න. මේකෙන් Search Engines වලට ඔයාගේ content එක තවත් හොඳින් තේරුම් ගන්න පුළුවන්. (උදා: Reviews, Products, Recipes).

නිගමනය (Conclusion)

හරි යාළුවනේ, අපි Next.js වල Metadata සහ SEO ගැන ගොඩක් දේවල් ඉගෙන ගත්තා. ඔයාගේ වෙබ් අඩවියක් Search Engine results වල ඉහළට ගෙනියන්න Metadata කියන්නේ කොච්චර වැදගත් දෙයක්ද කියලා දැන් ඔයාට හොඳටම තේරෙනවා ඇති. next/head Component එක සහ Next.js App Router එකේ අලුත් Metadata API එක පාවිච්චි කරලා, අපිට ඉතාම පහසුවෙන් හා කාර්යක්ෂමව අපේ වෙබ් පිටු වලට අදාල Metadata එකතු කරන්න පුළුවන්.

මතක තියාගන්න, SEO කියන්නේ එකපාරක් කරලා ඉවර කරන්න පුළුවන් දෙයක් නෙමෙයි. ඒක දිගටම කරන්න ඕන දෙයක්. ඔයාගේ වෙබ් අඩවියේ Metadata හරියට තියෙනවද කියලා නිතරම check කරන්න, අලුත් content add කරද්දී ඒකට අදාළ Metadata හරියට යොදන්න, ඒ වගේම අලුත් SEO trends ගැනත් දැනුවත් වෙලා ඉන්න එක වැදගත්. 📈

ඔබේ Next.js Project එකේ මේ Metadata implement කරලා බලන්න. මොන වගේ ප්‍රතිඵල ලැබුණාද? මොන වගේ අභියෝග වලට මුහුණ දුන්නාද? ඔබේ අදහස් පහළින් Comment කරන්න! 💬 මේ ගැන තවත් දැනගන්න ඕන දේවල් තියෙනවා නම්, ඒකත් කියන්න. ඊළඟ ලිපියකින් හමුවෙමු! සුභ දවසක්! 👋

Previous

Java Microservices හැඳින්වීම | Scalability සහ API | SC Guide

 Next

Java Microservices Design with Spring Boot & DDD | SC Guide