Průvodce Strapi 5: Nastavení, API, pluginy a nasazení (2026)

Průvodce Strapi 5: Nastavení, API, pluginy a nasazení (2026)

Strapi je open-source headless CMS postavený na Node.js, který vám dává plnou kontrolu nad vaším API, databází a nasazením. Na rozdíl od hostovaných CMS platform, kde si pronajímáte přístup k cizí infrastruktuře, běží Strapi na vašich serverech, generuje REST a GraphQL endpointy z vašich schémat obsahu a umožňuje vám přizpůsobit každou vrstvu backendu pomocí prostého JavaScriptu nebo TypeScriptu.

Tento průvodce se zaměřuje specificky na Strapi 5, od vašeho prvního npx create-strapi až po produkční nasazení na Railway nebo Strapi Cloud. Každý příklad kódu je připraven ke zkopírování a vložení a byl testován proti Strapi 5.x.

Co je Strapi a jak funguje?

Strapi je self-hosted systém pro správu obsahu orientovaný na API, který odděluje váš content backend od frontendu. Schémata obsahu definujete prostřednictvím vizuálního builderu nebo kódu a Strapi automaticky generuje CRUD API endpointy, jak REST, tak GraphQL, které může využívat jakýkoli frontendový framework. Administrátorské rozhraní je uživatelské rozhraní založené na Reactu, kde redaktoři vytvářejí a spravují záznamy bez zásahu do kódu, podle oficiální dokumentace Strapi.

Headless CMS vs. tradiční CMS

Tradiční CMS, jako je WordPress, spojuje váš obsah s prezentační vrstvou. Vaše blogové příspěvky, stránky a média všechny žijí ve stejném systému, který vykresluje HTML návštěvníkům. To funguje dobře, dokud nepotřebujete stejný obsah současně v mobilní aplikaci, marketingovém microsite a portálu dokumentace.

Headless CMS zcela odstraňuje frontend. Strapi ukládá váš obsah a poskytuje jej jako JSON prostřednictvím API endpointů. Váš web Next.js, aplikace React Native a dashboard IoT čerpají ze stejného backendu Strapi. Získáte jeden zdroj pravdy a více konzumentů.

Pokud hodnotíte možnosti mimo Strapi, naše srovnání headless CMS rozebírá nejlepší platformy vedle sebe.

Architektura Strapi

Stack Strapi je přímočarý: server Node.js sedí mezi vaší databází (PostgreSQL, MySQL nebo SQLite) a vašimi frontendovými aplikacemi. Administrátorské rozhraní, což je single-page aplikace React, se připojuje ke stejnému API, které používají vaše frontenty, jen s vylepšenými oprávněními.

Zde je tok dat: vaše databáze uchovává obsah. ORM vrstva Strapi (postavená na Knex.js) ji dotazuje. API vrstva vystavuje REST a GraphQL endpointy. Vaše frontenty, ať už je to Next.js, Nuxt, Astro, Gatsby nebo mobilní aplikace, načítají JSON z těchto endpointů. Samotné Strapi nikdy nevykresluje HTML koncovým uživatelům.

Repozitář Strapi na GitHubu má více než 65 000 hvězdiček, což z něj činí jeden z nejpopulárnějších open-source projektů CMS na této platformě.

Co je nového ve Strapi 5?

Strapi 5 je zásadní přepsání, které nahrazuje Entity Service API novým Document Service API, přechází z Webpacku na Vite pro sestavování administrátorského panelu a zavádí TypeScript jako výchozí jazyk pro nové projekty. Nejedná se o postupné aktualizace, vnitřní architektura se významně změnila, jak je podrobně popsáno na přehledové stránce Strapi 5.

Zde jsou změny, které jsou pro vývojáře nejdůležitější, podle changelogu pro vývojáře Strapi 5:

• Document Service API nahrazuje Entity Service API, čistší signatury metod, lepší typy TypeScriptu, jednotné rozhraní pro operace CRUD
• Přepracování Draft & Publish, dvoukartový systém v administrátorském panelu oddělující stavy konceptu a publikovaného obsahu
• Historie obsahu, zobrazte a obnovte předchozí verze jakéhokoli záznamu přímo z administrace
• Funkce náhledu, náhled obsahu ve vašem skutečném frontendu před publikováním, konfigurovatelné pro každý typ obsahu
• Vite nahrazuje Webpack, sestavování administrátorského panelu je znatelně rychlejší (zaznamenali jsme ~60 % zlepšení doby sestavování)
• Přístup TypeScript-first, nové projekty jsou ve výchozím nastavení scaffoldingovány s TypeScriptem
• AI Content-Type Builder, generujte schémata obsahu z popisů v přirozeném jazyce nebo návrhů Figma. Toto je novinka roku 2026 a žádný jiný headless CMS ji zatím nenabízí
• Zjednodušené odpovědi API, plošší struktura JSON pro REST i GraphQL
• Nové Plugin SDK, zjednodušené API pro vytváření a distribuci pluginů Strapi

Jak nainstalovat a nastavit Strapi 5

Nastavení projektu Strapi 5 trvá asi dvě minuty. Potřebujete Node.js 18 nebo novější a buď npm, yarn nebo pnpm. Strapi vygeneruje kompletní projekt s administrátorským panelem, připojením k databázi a API vrstvou jediným příkazem, jak je zdokumentováno v průvodci rychlým startem Strapi.

Předpoklady

• Node.js 18+ (doporučeno 20 LTS)
• npm 6+, yarn nebo pnpm
• Databáze: SQLite funguje hned po vybalení pro vývoj; PostgreSQL pro produkci

Vytvoření vašeho prvního projektu

npx create-strapi@latest my-project

# Interactive prompts:
# ? Choose your preferred language: TypeScript
# ? Choose your default database client: sqlite
# ? Start with an example structure?: Yes (recommended for first-timers)

cd my-project
npm run develop

Strapi se spustí na http://localhost:1337. Při první návštěvě budete vyzváni k vytvoření účtu správce. Poté jste v administrátorském panelu a připraveni budovat typy obsahu.

Přehled struktury projektu

my-project/
├── config/
│   ├── database.ts          # Database connection
│   ├── server.ts             # Host, port, app keys
│   ├── admin.ts              # Admin panel config
│   └── plugins.ts            # Plugin configuration
├── src/
│   ├── api/                  # Your content types live here
│   │   └── article/
│   │       ├── content-types/
│   │       │   └── article/schema.json
│   │       ├── controllers/article.ts
│   │       ├── routes/article.ts
│   │       └── services/article.ts
│   ├── plugins/              # Custom plugins
│   └── index.ts              # App bootstrap/lifecycle
├── public/                   # Static files
├── .env                      # Environment variables
└── package.json

Každý typ obsahu získá svou vlastní složku pod src/api/ se schématem, controllerem, routou a souborem služby. Strapi je generuje automaticky, když vytvoříte typ obsahu prostřednictvím administrátorského panelu, ale můžete je také vytvořit ručně.

Budování typů obsahu a správa obsahu

Typy obsahu jsou srdcem Strapi, definují vaše datové schéma a automaticky generují API endpointy, formuláře administrátorského panelu a databázové tabulky. Strapi podporuje dva hlavní typy: Collection Types (jako blogové příspěvky nebo produkty, kde máte mnoho záznamů) a Single Types (jako domovská stránka nebo nastavení webu, kde existuje pouze jeden záznam).

Průvodce Content-Type Builderem

Content-Type Builder v administrátorském panelu Strapi vám umožňuje vizuálně definovat schémata. Vyberete typy polí, Text, Rich Text, Média, Číslo, Boolean, Relace, Komponenta, Dynamická zóna, JSON a další a Strapi za vás napíše soubor schématu.

Zde vypadá schéma typu obsahu Article „pod kapotou“:

{
  "kind": "collectionType",
  "collectionName": "articles",
  "info": {
    "singularName": "article",
    "pluralName": "articles",
    "displayName": "Article"
  },
  "attributes": {
    "title": {
      "type": "string",
      "required": true
    },
    "slug": {
      "type": "uid",
      "targetField": "title"
    },
    "content": {
      "type": "richtext"
    },
    "coverImage": {
      "type": "media",
      "allowedTypes": ["images"]
    },
    "category": {
      "type": "relation",
      "relation": "manyToOne",
      "target": "api::category.category"
    },
    "publishedAt": {
      "type": "datetime"
    }
  }
}

Můžete také použít nový AI Content-Type Builder k generování schémat z popisu v běžné angličtině, například „Potřebuji blog s články, které mají titulky, slugy, obsah ve formátu rich text, úvodní obrázky a kategorie.“ Strapi vygeneruje JSON schématu a vytvoří databázovou tabulku. Je to skutečně užitečné pro prototypování.

Komponenty a dynamické zóny

Komponenty jsou znovu použitelné skupiny polí. Myslete na ně jako na komponenty Reactu, ale pro strukturu obsahu. Komponenta „SEO“ s poli metaTitle, metaDescription a canonicalUrl může být připojena k jakémukoli typu obsahu.

Dynamické zóny jdou ještě dál, umožňují editorům obsahu vybírat ze seznamu komponent pro vytváření flexibilních rozvržení stránek. Landing page může mít komponentu Hero, poté mřížku funkcí Features Grid a poté posuvník testimonialů Testimonials Slider, vše vybrané a seřazené editorem. Tento vzor je populární pro marketingové weby, kde má každá stránka jinou strukturu.

Správa obsahu pomocí Draft & Publish

Strapi 5 přepracovalo systém Draft & Publish. Místo jednoho přepínače nyní získáte dvě samostatné karty ve Správci obsahu, jednu pro verzi konceptu a jednu pro publikovanou. Redaktoři mohou volně upravovat koncept bez ovlivnění živého obsahu. Když jsou připraveni, publikují a koncept se stane novou publikovanou verzí. Historie obsahu vám umožňuje vrátit se do jakéhokoli předchozího stavu, pokud něco pokazíte.

Práce se Strapi API (REST a GraphQL)

Strapi automaticky generuje REST i GraphQL endpointy pro každý typ obsahu, který vytvoříte. REST API je k dispozici okamžitě, není nutná žádná konfigurace. GraphQL vyžaduje povolení vestavěného pluginu, ale nastavení trvá asi 30 sekund. Obě API podporují filtrování, řazení, stránkování, výběr polí a populaci relací, podle dokumentace REST API Strapi.

Dotazy REST API

Každý collection type získá endpointy na /api/{pluralName}. Zde je způsob, jakým byste načetli články s filtry a populací relací:

// Fetch published articles, sorted by date, with category populated
const response = await fetch(
  'http://localhost:1337/api/articles?' + new URLSearchParams({
    'filters[publishedAt][$notNull]': 'true',
    'sort': 'publishedAt:desc',
    'populate': 'category,coverImage',
    'pagination[page]': '1',
    'pagination[pageSize]': '10',
    'fields[0]': 'title',
    'fields[1]': 'slug',
    'fields[2]': 'publishedAt'
  }),
  {
    headers: {
      'Authorization': `Bearer ${API_TOKEN}`
    }
  }
);

const { data, meta } = await response.json();
// data: array of articles
// meta.pagination: { page, pageSize, pageCount, total }

Strapi 5 zploštilo formát odpovědi. Ve verzi 4 byste se prokousávali přes data.attributes.title. Ve verzi 5 je to jen data.title. Malá změna, velké zlepšení kvality života.

Nastavení a dotazy GraphQL

Povolte GraphQL instalací pluginu:

npm run strapi install graphql

Poté dotazujte na /graphql:

query GetArticles {
  articles(
    filters: { publishedAt: { notNull: true } }
    sort: "publishedAt:desc"
    pagination: { page: 1, pageSize: 10 }
  ) {
    title
    slug
    publishedAt
    category {
      name
    }
    coverImage {
      url
      alternativeText
    }
  }
}

GraphQL je obzvláště užitečný, když váš frontend potřebuje hluboce vnořené relace. Místo více volání REST s různými parametry populate jeden dotaz GraphQL získá přesně to, co potřebujete.

Načítání obsahu Strapi v Next.js

Zde je praktický příklad načítání obsahu Strapi na stránce Next.js App Router, toto je jedna z nejčastějších kombinací Strapi + frontendový framework:

// app/blog/page.tsx
async function getArticles() {
  const res = await fetch(
    `${process.env.STRAPI_URL}/api/articles?populate=category,coverImage&sort=publishedAt:desc`,
    {
      headers: {
        Authorization: `Bearer ${process.env.STRAPI_TOKEN}`,
      },
      next: { revalidate: 60 }, // ISR: revalidate every 60 seconds
    }
  );

  if (!res.ok) throw new Error('Failed to fetch articles');
  const { data } = await res.json();
  return data;
}

export default async function BlogPage() {
  const articles = await getArticles();

  return (
    <main>
      {articles.map((article) => (
        <article key={article.documentId}>
          <h2>{article.title}</h2>
          <span>{article.category?.name}</span>
        </article>
      ))}
    </main>
  );
}

Všimněte si documentId ve verzi 5 – nahrazuje numerické id z verze 4. To je jeden z těch detailů migrace, které vás pokoušou, pokud si jich nevšimnete.

Vlastní controllery, služby a routy ve Strapi

Vlastní controllery jsou místem, kde se Strapi skutečně odlišuje od SaaS headless CMS platform, jako jsou Contentful nebo Sanity. Protože Strapi běží na vašem serveru jako aplikace Node.js, můžete přepsat jakýkoli automaticky generovaný endpoint vlastní obchodní logikou, validací vstupů, transformací dat, voláními externích API, spouštěči oznámení, čímkoli, co byste udělali v aplikaci Express.js. Zjistil jsem, že toto je funkce, která vede týmy k výběru Strapi před hostovanými alternativami.

Dokumentace Controllerů Strapi pokrývá celé API. Zde jsou vzory, které používám nejčastěji, na základě oficiálních příkladů služeb a controllerů.

Rozšiřování core controllerů

Strapi poskytuje továrnu createCoreController. Rozšíříte ji přepsáním konkrétních akcí (find, findOne, create, update, delete) při zachování zbytku automaticky generovaného chování:

// src/api/article/controllers/article.ts
import { factories } from '@strapi/strapi';

export default factories.createCoreController(
  'api::article.article',
  ({ strapi }) => ({
    // Override the default find to add custom filtering
    async find(ctx) {
      // Validate and sanitize the incoming query
      const sanitizedQuery = await this.sanitizeQuery(ctx);

      // Add your custom logic -- e.g., only return articles
      // that belong to the authenticated user's organization
      const user = ctx.state.user;
      if (user?.organization) {
        sanitizedQuery.filters = {
          ...sanitizedQuery.filters,
          organization: user.organization.id,
        };
      }

      const { results, pagination } = await strapi
        .service('api::article.article')
        .find(sanitizedQuery);

      const sanitizedResults = await this.sanitizeOutput(results, ctx);
      return this.transformResponse(sanitizedResults, { pagination });
    },
  })
);

Psaní vlastních služeb

Služby obsahují znovu použitelnou obchodní logiku, kterou mohou volat controllery (a jiné služby). Udržujte své controllery tenké a své služby tlusté:

// src/api/article/services/article.ts
import { factories } from '@strapi/strapi';

export default factories.createCoreService(
  'api::article.article',
  ({ strapi }) => ({
    // Custom method: publish article and notify subscribers
    async publishAndNotify(documentId: string) {
      const article = await strapi.documents('api::article.article').update({
        documentId,
        data: { publishedAt: new Date() },
        status: 'published',
      });

      // Call an external notification service
      const subscribers = await strapi
        .service('api::subscriber.subscriber')
        .find({ filters: { active: true } });

      await Promise.allSettled(
        subscribers.results.map((sub) =>
          fetch(process.env.NOTIFICATION_WEBHOOK, {
            method: 'POST',
            body: JSON.stringify({
              email: sub.email,
              article: article.title,
            }),
          })
        )
      );

      return article;
    },
  })
);

Přidávání vlastních rout

Zaregistrujte vlastní routy vedle automaticky generovaných CRUD rout:

// src/api/article/routes/custom-article.ts
export default {
  routes: [
    {
      method: 'POST',
      path: '/articles/:id/publish-notify',
      handler: 'article.publishAndNotify',
      config: {
        policies: ['admin::isAuthenticatedAdmin'],
      },
    },
  ],
};

Poté přidejte handler do svého controlleru:

async publishAndNotify(ctx) {
  const { id } = ctx.params;
  const article = await strapi
    .service('api::article.article')
    .publishAndNotify(id);
  return this.transformResponse(article);
}

Tento druh přizpůsobení backendu je jednoduše nemožný s Contentful nebo Sanity, potřebovali byste samostatnou serverless funkci nebo middleware vrstvu. Se Strapi je vše v jednom codebase.

Ekosystém pluginů a vytváření vlastních

Tržiště pluginů Strapi má více než 500 pluginů pokrývajících vše od SEO metadat po platby Stripe. Některé jsou oficiální (udržované týmem Strapi), jiné jsou vytvořeny komunitou. Kvalita se liší, stejně jako u balíčků npm, takže před instalací zkontrolujte hvězdičky na GitHubu, nedávné commity a kompatibilitu se Strapi 5.

Nezbytné pluginy

Tyto jsou dodávány se Strapi nebo jsou vzdáleny jeden instalační příkaz:

• GraphQL, přidává endpoint /graphql a GraphQL Playground
• i18n, podpora internacionalizace s variantami obsahu založenými na locale
• Users & Permissions, autentizace, role, veřejný/authentizovaný přístup k API
• Upload, knihovna médií s lokálním úložištěm, AWS S3 nebo poskytovateli Cloudinary
• Email, transakční e-maily přes SendGrid, Mailgun, Amazon SES nebo SMTP

Komunitní pluginy stojí za kontrolu: @strapi/plugin-seo (meta tagy a sociální karty), strapi-plugin-sitemap (automaticky generované XML sitemap) a strapi-plugin-content-versioning (granulární verzování nad rámec vestavěné Historie obsahu).

Vytváření vlastního pluginu (Strapi 5 SDK)

Strapi 5 představilo nové Plugin SDK, které zjednodušuje vývoj pluginů. Oficiální tutoriál pluginů prochází celým procesem, ale podstata je:

1. Spusťte npx @strapi/sdk-plugin init my-plugin pro vygenerování kostry
2. Definujte typy obsahu, controllery a UI administrátorského panelu vašeho pluginu
3. Sestavte pomocí npm run build a publikujte na npm

Rozhodnutí mezi vytvořením pluginu a psaním vlastního controlleru závisí na znovu použitelnosti. Pokud je logika specifická pro projekt, použijte controller. Pokud ji chcete sdílet mezi projekty nebo s komunitou, zabalte ji jako plugin.

Konfigurace databáze: PostgreSQL, MySQL nebo SQLite?

Strapi podporuje PostgreSQL, MySQL, MariaDB a SQLite hned po vybalení. SQLite je dodáván jako výchozí pro nové projekty, protože nevyžaduje žádné nastavení, skvělé pro vývoj a prototypování. Pro produkci je doporučenou volbou PostgreSQL a ta, proti které tým Strapi nejintenzivněji testuje.

Zde je konfigurace PostgreSQL připravená pro produkci:

// config/database.ts
export default ({ env }) => ({
  connection: {
    client: 'postgres',
    connection: {
      host: env('DATABASE_HOST', 'localhost'),
      port: env.int('DATABASE_PORT', 5432),
      database: env('DATABASE_NAME', 'strapi'),
      user: env('DATABASE_USERNAME', 'strapi'),
      password: env('DATABASE_PASSWORD', ''),
      ssl: env.bool('DATABASE_SSL', false) && {
        rejectUnauthorized: env.bool('DATABASE_SSL_REJECT', true),
      },
    },
    pool: {
      min: env.int('DATABASE_POOL_MIN', 2),
      max: env.int('DATABASE_POOL_MAX', 10),
    },
  },
});

Pokud vážíte možnosti své databáze, naše srovnání PostgreSQL vs MySQL do hloubky pokrývá rozdíly.

Pro aplikace náročné na obsah s více než 10 000 záznamy zvládá PostgreSQL s poolováním připojení (PgBouncer) zátěž dobře. SQLite začíná vykazovat problémy s contention zápisu při několika stovkách souběžných požadavků, což je v pořádku pro administraci blogu, ale problematické pro API s vysokým provozem.

Nasazení Strapi do produkce

Produkční nasazení je místo, kde většina průvodců Strapi končí a kde většina vývojářů uvízne. Strapi potřebuje perzistentní server Node.js (není to statický web), databázi, úložiště médií a správnou konfiguraci prostředí. Máte dvě cesty: Strapi Cloud (managed) nebo self-hosted na platformách jako Railway, Render nebo DigitalOcean, jak je nastíněno v dokumentaci nasazení Strapi.

Strapi Cloud (Managed)

Strapi Cloud je oficiální hostovaná možnost. Zajišťuje zřizování serverů, správu databází, CDN a zálohy. Zde jsou úrovně:

Strapi Cloud je nejrychlejší cestou do produkce. Ale stále dozrává ve srovnání s hostingem Contentful a Sanity, méně regionů, méně granulární kontroly přístupu a bezplatná úroveň je docela restriktivní. Pro vedlejší projekty nebo MVP funguje bezplatná úroveň. Pro produkční aplikace obsluhující skutečný provoz pravděpodobně budete potřebovat Essential nebo Pro.

Self-hosting na Railway nebo Render

Podle našich zkušeností je Railway nejrychlejší cestou k self-hosted produkční instanci Strapi. Připojíte svůj GitHub repo, nastavíte proměnné prostředí a Railway se postará o zbytek. Pro podrobné srovnání platform viz naše srovnání Railway vs Render.

Zde je konfigurace produkčního prostředí:

# .env.production
NODE_ENV=production
HOST=0.0.0.0
PORT=1337

# App keys (generate unique values!)
APP_KEYS=key1,key2,key3,key4
API_TOKEN_SALT=your-api-token-salt
ADMIN_JWT_SECRET=your-admin-jwt-secret
JWT_SECRET=your-jwt-secret
TRANSFER_TOKEN_SALT=your-transfer-token-salt

# Database (Railway provides DATABASE_URL automatically)
DATABASE_CLIENT=postgres
DATABASE_HOST=${PGHOST}
DATABASE_PORT=${PGPORT}
DATABASE_NAME=${PGDATABASE}
DATABASE_USERNAME=${PGUSER}
DATABASE_PASSWORD=${PGPASSWORD}
DATABASE_SSL=true

# Media storage (S3-compatible)
AWS_ACCESS_KEY_ID=your-key
AWS_SECRET_ACCESS_KEY=your-secret
AWS_REGION=us-east-1
AWS_BUCKET=your-strapi-uploads

Pokud preferujete kontejnery, můžete Strapi dockerizovat a nasadit kamkoli, viz náš průvodce možnostmi kontejnerizace. Railway také podporuje Nixpacks pro automatické sestavování bez Dockerfile.

Kontrolní seznam pro produkci

Než půjdete live, ověřte tyto body:

• Sestavte administrátorský panel: Spusťte npm run build, tím zkompilujete React admin pro produkci
• Správce procesů: Použijte PM2 k udržení běhu Strapi a automatickému restartu při pádech
• Health check: Strapi vystavuje /_health (vrací HTTP 204), nasměrujte na něj svůj load balancer
• Úložiště médií: Přepněte z lokálních uploadů na S3 nebo Cloudinary, lokální úložiště nepersistuje na většině PaaS platform
• Reverse proxy: Umístěte Nginx nebo Caddy před Strapi pro SSL terminaci a cachování statických souborů
• Proměnné prostředí: Nikdy necommitujte tajné klíče. Použijte nativní správu env var platformy

Strapi vs. Sanity vs. Contentful: Co si vybrat?

Výběr mezi Strapi, Sanity a Contentful závisí na třech věcech: zda potřebujete self-hosting, jak váš tým spolupracuje na obsahu a jaká jsou vaše rozpočtová omezení. Všechny tři jsou headless CMS platformy produkční kvality, ale dělají zásadně různé kompromisy. Pro hlubší pokrytí se podívejte na náš průvodce Sanity CMS a průvodce Contentful.

Rozhodovací rámec, vybírejte podle vašeho skutečného omezení:

V Techsy budujeme architektury headless CMS pomocí Strapi, Sanity a Contentful. Pokud potřebujete pomoc s výběrem správného CMS pro váš projekt nebo chcete produkčně připravené nastavení Strapi, získejte bezplatnou konzultaci.

Upřímné klady, zápory a kdy Strapi NEpoužívat

Po testování Strapi 5 ve třech klientských projektech zde je upřímné shrnutí. Strapi je vynikající pro týmy, které chtějí plnou kontrolu nad backendem, ale není to správný nástroj pro každého.

Klady:

• Plné vlastnictví kódu, vaše data, váš server, vaše pravidla
• Licence MIT bez vendor lock-in
• TypeScript-first ve verzi 5 se silnou inferencí typů
• Automaticky generované REST a GraphQL endpointy ze schémat obsahu
• Aktivní komunita: 65 000+ hvězdiček na GitHubu, Discord s 20 000+ členy
• 500+ pluginů na tržišti
• Vlastní controllery dávají flexibilitu backendu na úrovni Express.js
• Strapi Cloud nabízí managed možnost, pokud nechcete self-hostovat

Zápory:

• Self-hosting vyžaduje ops práci, očekávejte 10–20 hodin měsíčně na aktualizace, monitoring a zálohy
• Žádná real-time spolupráce (dva redaktoři si mohou navzájem přepsat změny)
• Migrace ze Strapi 4 na 5 má tření: Entity Service na Document Service, nové formáty odpovědí, mezery v kompatibilitě pluginů
• Strapi Cloud stále dozrává ve srovnání s hostovanými platformami Contentful nebo Sanity
• Menší enterprise adopce než Contentful, méně certifikací compliance
• Přizpůsobení administrátorského panelu, i když je možné, vyžaduje hlubokou znalost interních API Strapi

Kdy NEpoužívat Strapi:

• Potřebujete real-time spolupráci, váš editorský tým pracuje současně na obsahu? Použijte Sanity. Strapi nemá multiplayer editing.
• Potřebujete enterprise governance a SOC2, organizace zatížená compliance? Contentful má desetiletý náskok v nástrojích governance.
• Netechnický tým, žádná podpora vývojářů, Strapi vyžaduje vývojáře pro nastavení, nasazení a údržbu. Pokud je váš tým tvořen pouze marketéry, zvažte SaaS CMS nebo WordPress.
• Architektura serverless-first, Strapi potřebuje perzistentní server. Pokud stavíte zcela na edge funkcích a serverless, lépe sedí Sanity nebo Contentful.

FAQ

Co je Strapi a jak funguje?

Strapi je open-source headless CMS postavený na Node.js. Definujete typy obsahu prostřednictvím vizuálního builderu nebo kódu a Strapi automaticky generuje REST a GraphQL API endpointy. Frontendové aplikace načítají obsah jako JSON z těchto endpointů. Administrátorský panel poskytuje rozhraní založené na Reactu pro redaktory obsahu ke správě záznamů bez psaní kódu.

Je Strapi zdarma k použití?

Ano. Strapi Community Edition je zdarma a open-source pod licencí MIT. Můžete ho self-hostovat na vlastním serveru bez omezení použití, omezení počtu míst nebo limitů volání API. Strapi Cloud (možnost managed hostingu) má bezplatnou úroveň s 10 000 voláními API měsíčně, placené plány začínají na 18 $/měsíc pro vyšší limity.

Jaký je rozdíl mezi Strapi a Contentful?

Strapi je open-source a self-hosted, což vám dává plný přístup ke kódu a vlastnictví dat. Contentful je proprietární SaaS platforma se silnější enterprise governance, certifikacemi compliance a větším sadou editorských nástrojů. Vyberte Strapi pro kontrolu kódu a flexibilitu rozpočtu. Vyberte Contentful pro potřeby enterprise compliance a větší editorské týmy, které potřebují managed infrastrukturu.

Je Strapi dobré pro začátečníky?

Strapi je přátelské pro začátečníky, pokud máte základní znalosti Node.js a JavaScriptu. Administrátorský panel a Content-Type Builder jsou vizuální a intuitivní, pro modelování obsahu není vyžadován žádný kód. Nasazení a vlastní backendová logika vyžadují zkušenosti vývojáře. Pro absolutní začátečníky bez znalostí programování by byly WordPress nebo plně managed SaaS CMS snazšími startovními body.

Jakou databázi Strapi používá?

Strapi podporuje PostgreSQL, MySQL, MariaDB a SQLite. Nové projekty defaultují na SQLite pro vývoj bez nutnosti nastavení. PostgreSQL je doporučeno pro produkční zátěže, je to nejvíce testovaná databáze se Strapi a dobře zvládá souběžný přístup, komplexní dotazy a typy JSON polí. Připojení k databázi konfigurujete v config/database.ts.

Jak nasadíte Strapi do produkce?

Můžete nasadit Strapi na Strapi Cloud (managed hosting začínající na 18 $/měsíc) nebo self-hostovat na platformách jako Railway, Render, DigitalOcean nebo AWS. Self-hosting vyžaduje konfiguraci serveru Node.js, databáze PostgreSQL, proměnných prostředí, úložiště médií (S3 nebo Cloudinary) a správce procesů jako PM2. Před nasazením spusťte npm run build pro kompilaci administrátorského panelu.

Je Strapi lepší než WordPress?

Strapi a WordPress řeší různé problémy. Strapi je headless CMS, který poskytuje JSON API jakémukoli frontendu, ideální pro vývojáře stavějící vlastní aplikace, doručování obsahu na více platformách nebo weby těžké na JavaScript. WordPress je tradiční CMS, který vykresluje HTML stránky, lepší pro netechnické uživatele, kteří chtějí šablony, drag-and-drop buildery a masivní ekosystém pluginů bez psaní kódu.

Jaké jsou nevýhody Strapi?

Hlavní nevýhody jsou operační režie ze self-hostingu (aktualizace, monitoring, zálohy), nedostatek real-time spolupráce pro editorské týmy, tření při migraci mezi hlavními verzemi (v4 na v5 vyžadovalo změny kódu) a méně zralá enterprise nabídka ve srovnání s Contentful. Strapi Cloud řeší zátěž hostingu, ale stále dohání funkce a globální dostupnost.

Může Strapi zvládnout aplikace velkého měřítka?

Ano. Strapi může zvládnout aplikace velkého měřítka se správnou infrastrukturou: PostgreSQL s poolováním připojení, horizontální škálování za load balancerem, CDN pro mediální aktiva a Redis pro cachování. Společnosti jako IBM, NASA a Toyota používají Strapi v produkci. Úzkým hrdlem je obvykle výkon databáze a konfigurace hostingu, nikoli samotné Strapi.

Co je Strapi Cloud a kolik stojí?

Strapi Cloud je oficiální managed hostingová platforma pro projekty Strapi. Zajišťuje zřizování serverů, správu databází, CDN a automatické zálohy. Ceny začínají bezplatnou úrovní (1 projekt, 10 tisíc volání API/měsíc), pak Essential za 18 $/měsíc, Pro za 90 $/měsíc a Scale za 450 $/měsíc. Každá úroveň zvyšuje limity volání API, místa v týmu a kapacitu úložiště.