Strapi 5-guide: Opsætning, API, plugins og deployment (2026)

Strapi 5-guide: Opsætning, API, plugins og deployment (2026)

Strapi er et open source headless CMS bygget på Node.js, som giver dig fuld kontrol over dit API, din database og din deployment. I modsætning til hostede CMS-platforme, hvor du lejer adgang til andres infrastruktur, kører Strapi på dine egne servere, genererer REST- og GraphQL-endepunkter ud fra dine indholdsskemaer og lader dig tilpasse hvert lag af backenden med almindelig JavaScript eller TypeScript.

Denne guide dækker specifikt Strapi 5, fra din første npx create-strapi til en produktionsdeployment på Railway eller Strapi Cloud. Alle kodeeksempler er klar til copy-paste og testet mod Strapi 5.x.

Hvad er Strapi, og hvordan virker det?

Strapi er et self-hosted, API-first content management system, der afkobler dit indholdsbackend fra dit frontend. Du definerer indholdsskemaer gennem en visuel builder eller kode, og Strapi genererer automatisk CRUD-API-endepunkter, både REST og GraphQL, som ethvert frontend-framework kan forbruge. Admin-panelet er en React-baseret brugergrænseflade, hvor indholdsredaktører opretter og administrerer poster uden at røre ved kode, jf. den officielle Strapi-dokumentation.

Headless CMS vs. traditionelt CMS

Et traditionelt CMS som WordPress kobler dit indhold sammen med dit præsentationslag. Dine blogindlæg, sider og medier lever alle i samme system, der renderer HTML til besøgende. Det fungerer fint, indtil du har brug for det samme indhold i en mobilapp, et marketing-mikrosite og en dokumentationsportal samtidigt.

Et headless CMS fjerner frontendet helt. Strapi gemmer dit indhold og serverer det som JSON gennem API-endepunkter. Dit Next.js-site, din React Native-app og dit IoT-dashboard henter alle data fra samme Strapi-backend. Du får én sandhedskilde og flere forbrugere.

Hvis du evaluerer muligheder ud over Strapi, giver vores sammenligning af headless CMS'er et overblik over de førende platforme side om side.

Strapis arkitektur

Strapis stack er ligetil: en Node.js-server sidder mellem din database (PostgreSQL, MySQL eller SQLite) og dine frontend-applikationer. Admin-panelet, en React single-page app, forbinder sig til det samme API, som dine frontends bruger, blot med forbedrede rettigheder.

Her er flowet: din database indeholder indhold. Strapis ORM-lag (bygget på Knex.js) forespørger det. API-laget eksponerer REST- og GraphQL-endepunkter. Dine frontends, hvad enten det er Next.js, Nuxt, Astro, Gatsby eller en mobilapp, henter JSON fra disse endepunkter. Strapi renderer selv aldrig HTML til slutbrugere.

Strapi GitHub-repositoriet har 65.000+ stjerner, hvilket gør det til et af de mest populære open source CMS-projekter på platformen.

Hvad er nyt i Strapi 5?

Strapi 5 er en stor omskrivning, der erstatter Entity Service API'en med en ny Document Service API, skifter fra Webpack til Vite til builds af admin-panelet og introducerer TypeScript som standardsproget for nye projekter. Dette er ikke inkrementelle opdateringer; den interne arkitektur er ændret betydeligt, som detaljeret på Strapi 5-oversigtssiden.

Her er de ændringer, der betyder mest for udviklere, ifølge Strapi 5-udviklerchangelogen:

• Document Service API erstatter Entity Service API, renere metodesignaturer, bedre TypeScript-typer, ensartet grænseflade for CRUD-operationer
• Omarbejdelse af Draft & Publish, to-fane-system i admin-panelet, der adskiller udkast og publicerede indholdstilstande
• Indholdshistorik, se og gendan tidligere versioner af enhver post direkte fra admin
• Forhåndsvisningsfunktion, forhåndsvis indhold i dit faktiske frontend før publicering, konfigureret pr. indholdstype
• Vite erstatter Webpack, builds af admin-panelet er mærkbart hurtigere (vi så ~60 % forbedring i build-tider)
• TypeScript-first tilgang, nye projekter scaffolder med TypeScript som standard
• AI Content-Type Builder, generér indholdsskemaer fra naturlige sprogbeskrivelser eller Figma-designs. Dette er nyt i 2026, og ingen andet headless CMS tilbyder det endnu
• Forenklede API-svar, fladere JSON-struktur for både REST og GraphQL
• Nyt Plugin SDK, strømlinet API til at bygge og distribuere Strapi-plugins

Sådan installerer og opsætter du Strapi 5

Det tager cirka to minutter at opsætte et Strapi 5-projekt. Du skal bruge Node.js 18 eller nyere samt enten npm, yarn eller pnpm. Strapi scaffolder et fuldt projekt med et admin-panel, databaseforbindelse og API-lag fra en enkelt kommando, som dokumenteret i Strapi Quick Start-guiden.

Forudsætninger

• Node.js 18+ (20 LTS anbefales)
• npm 6+, yarn eller pnpm
• En database: SQLite fungerer out of the box til udvikling; PostgreSQL til produktion

Oprettelse af dit første projekt

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 starter på http://localhost:1337. Dit første besøg beder dig om at oprette en admin-konto. Derefter er du i admin-panelet og klar til at bygge indholdstyper.

Oversigt over projektstruktur

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

Hver indholdstype får sin egen mappe under src/api/ med en skema-, controller-, rute- og servicefil. Strapi genererer disse automatisk, når du opretter en indholdstype gennem admin-panelet, men du kan også oprette dem manuelt.

Bygning af indholdstyper og styring af indhold

Indholdstyper er hjertet i Strapi; de definerer dit dataskema og genererer automatisk API-endepunkter, admin-panel-formularer og databasetabeller. Strapi understøtter to hovedtyper: Samlingstyper (som blogindlæg eller produkter, hvor du har mange poster) og Enkelttyper (som en forside eller site-indstillinger, hvor kun én post eksisterer).

Gennemgang af Content-Type Builder

Content-Type Builder i Strapis admin-panel lader dig visuelt definere skemaer. Du vælger felttyper – Tekst, Rich Text, Medie, Tal, Boolean, Relation, Komponent, Dynamisk Zone, JSON og mere – og Strapi skriver skemafilen for dig.

Sådan ser et Article-indholdstype-skema ud under motorhjelmen:

{
  "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"
    }
  }
}

Du kan også bruge den nye AI Content-Type Builder til at generere skemaer fra en beskrivelse i almindeligt engelsk som "Jeg har brug for en blog med artikler, der har titler, slugs, rich text-indhold, coverbilleder og kategorier." Strapi genererer skema-JSON'en og opretter databasetabellen. Det er virkelig nyttigt til prototyping.

Komponenter og dynamiske zoner

Komponenter er genanvendelige feltgrupper. Tænk på dem som React-komponenter, men for indholdsstruktur. En "SEO"-komponent med felterne metaTitle, metaDescription og canonicalUrl kan knyttes til enhver indholdstype.

Dynamiske zoner tager dette et skridt videre; de lader indholdsredaktører vælge fra en liste over komponenter for at bygge fleksible sidelayouts. En landingsside kan have en Hero-komponent, derefter et Features Grid, derefter en Testimonials Slider, alt sammen valgt og sorteret af redaktøren. Dette mønster er populært til marketingsites, hvor hver side har en anden struktur.

Styring af indhold med Draft & Publish

Strapi 5 har overhalet Draft & Publish-systemet. I stedet for en enkelt toggle får du nu to separate faner i Content Manager: én til din udkastversion og én til den publicerede. Redaktører kan frit modificere udkastet uden at påvirke det live indhold. Når de er klar, publicerer de, og udkastet bliver den nye publicerede version. Indholdshistorik lader dig rulle tilbage til en tidligere tilstand, hvis noget går galt.

Arbejde med Strapi API'et (REST og GraphQL)

Strapi autogenererer både REST- og GraphQL-endepunkter for hver indholdstype, du opretter. REST API'en er tilgængelig med det samme uden konfiguration. GraphQL kræver aktivering af det indbyggede plugin, men tager ca. 30 sekunder at sætte op. Begge API'er understøtter filtrering, sortering, paginering, feltvalg og relations-populering, jf. Strapi REST API-dokumentationen.

REST API-forespørgsler

Hver samlingstype får endepunkter på /api/{pluralName}. Her er hvordan du henter artikler med filtre og populerer relationer:

// 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 har fladet svarformatet ud. I v4 skulle du grave dig gennem data.attributes.title. I v5 er det bare data.title. En lille ændring, men en stor kvalitetsforbedring.

GraphQL-opsætning og forespørgsler

Aktivér GraphQL ved at installere pluginnet:

npm run strapi install graphql

Forespørg derefter på /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 er især nyttigt, når dit frontend har brug for dybt nestede relationer. I stedet for flere REST-kald med forskellige populate-parametre, henter én GraphQL-forespørgsel præcis det, du har brug for.

Hentning af Strapi-indhold i Next.js

Her er et praktisk eksempel på hentning af Strapi-indhold i en Next.js App Router-side; dette er en af de mest almindelige Strapi + frontend framework kombinationer:

// 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>
  );
}

Bemærk documentId i v5 – det erstatter det numeriske id fra v4. Dette er en af de migrationsdetaljer, der vil give dig problemer, hvis du overser den.

Tilpassede controllere, services og ruter i Strapi

Tilpassede controllere er der, hvor Strapi virkelig adskiller sig fra SaaS headless CMS-platforme som Contentful eller Sanity. Fordi Strapi kører på din server som en Node.js-applikation, kan du overskrive ethvert autogenereret endepunkt med din egen forretningslogik, inputvalidering, datatransformation, eksterne API-kald, notifikationsudløsere – alt hvad du ville gøre i en Express.js-app. Jeg har fundet ud af, at dette er funktionen, der får teams til at vælge Strapi frem for hostede alternativer.

Strapi Controllers-dokumentationen dækker hele API'en. Her er de mønstre, jeg bruger mest, baseret på de officielle service- og controller-eksempler.

Udvidelse af core-controllere

Strapi leverer en createCoreController-fabrik. Du udvider den ved at overskrive specifikke handlinger (find, findOne, create, update, delete) mens du beholder resten af den autogenererede adfærd:

// 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 });
    },
  })
);

Skrivning af tilpassede services

Services indeholder genanvendelig forretningslogik, som controllere (og andre services) kan kalde. Hold dine controllere tynde og dine services fede:

// 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;
    },
  })
);

Tilføjelse af tilpassede ruter

Registrér tilpassede ruter sammen med de autogenererede CRUD-ruter:

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

Tilføj derefter handleren til din controller:

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

Denne form for backend-tilpasning er simpelthen umulig med Contentful eller Sanity; du ville have brug for en separat serverless-funktion eller middleware-lag. Med Strapi er det hele i én kodebase.

Plugin-økosystem og bygning af dit eget

Strapis plugin-markedsplads har 500+ plugins, der dækker alt fra SEO-metadata til Stripe-betalinger. Nogle er officielle (vedligeholdt af Strapi-teamet), andre er community-byggede. Kvaliteten varierer, ligesom npm-pakker, så tjek GitHub-stjerner, seneste commits og Strapi 5-kompatibilitet før installation.

Essentielle plugins

Disse følger med Strapi eller er én install-kommando væk:

• GraphQL, tilføjer /graphql-endepunkt og GraphQL Playground
• i18n, internationaliseringsunderstøttelse med lokalitetsbaserede indholdsvarianter
• Users & Permissions, autentificering, roller, offentlig/authentificeret API-adgang
• Upload, mediebibliotek med local storage, AWS S3 eller Cloudinary-udbydere
• Email, transaktions-e-mail via SendGrid, Mailgun, Amazon SES eller SMTP

Community-plugins værd at tjekke: @strapi/plugin-seo (meta-tags og sociale kort), strapi-plugin-sitemap (autogenererede XML-sitemaps) og strapi-plugin-content-versioning (granulær versionskontrol ud over den indbyggede indholdshistorik).

Bygning af et tilpasset plugin (Strapi 5 SDK)

Strapi 5 introducerede et nyt Plugin SDK, der forenkler plugin-udvikling. Den officielle plugin-tutorial guider dig gennem hele processen, men essensen er:

1. Kør npx @strapi/sdk-plugin init my-plugin for at scaffold'e
2. Definer dit plugins indholdstyper, controllere og admin-panel UI
3. Byg med npm run build og publicér til npm

Beslutningen mellem at bygge et plugin kontra at skrive en tilpasset controller afhænger af genanvendelighed. Hvis logikken er projektspecifik, brug en controller. Hvis du vil dele den på tværs af projekter eller med community'et, pak den som et plugin.

Databasekonfiguration: PostgreSQL, MySQL eller SQLite?

Strapi understøtter PostgreSQL, MySQL, MariaDB og SQLite out of the box. SQLite leveres som standard for nye projekter, fordi det kræver nul opsætning, hvilket er fantastisk til udvikling og prototyping. Til produktion er PostgreSQL det anbefalede valg og den, som Strapi-teamet tester mest intensivt imod.

Her er en produktionsklar PostgreSQL-konfiguration:

// 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),
    },
  },
});

Hvis du vejer dine databasemuligheder, dækker vores sammenligning af PostgreSQL vs. MySQL forskellene i dybden.

Til indholdstunge applikationer med 10.000+ poster håndterer PostgreSQL med connection pooling (PgBouncer) belastningen godt. SQLite begynder at vise write contention-problemer ved et par hundrede samtidige anmodninger, hvilket er fint til en blog-admin, men problematisk for en højtrafik-API.

Deployment af Strapi til produktion

Produktionsdeployment er der, hvor de fleste Strapi-guider stopper, og hvor de fleste udviklere går i stå. Strapi har brug for en persistent Node.js-server (det er ikke et statisk site), en database, medielayring og korrekt miljøkonfiguration. Du har to veje: Strapi Cloud (managed) eller self-hosted på platforme som Railway, Render eller DigitalOcean, som beskrevet i Strapi Deployment-dokumentationen.

Strapi Cloud (Managed)

Strapi Cloud er den officielle hostede mulighed. Det håndterer serverprovisioning, databaseadministration, CDN og backups. Her er niveauerne:

Strapi Cloud er den hurtigste vej til produktion. Men det er stadig under modning sammenlignet med Contentfuls og Santys hosting, færre regioner, mindre granulære adgangskontroller, og det gratis niveau er ret begrænsende. Til sideprojekter eller MVP'er fungerer det gratis niveau. Til produktionsapps, der betjener rigtig trafik, vil du sandsynligvis have brug for Essential eller Pro.

Self-hosting på Railway eller Render

I vores erfaring er Railway den hurtigste vej til en self-hosted produktionsinstans af Strapi. Du forbinder dit GitHub-repo, indstiller miljøvariabler, og Railway håndterer resten. For en detaljeret platformsammenligning, se vores Railway vs. Render-sammenligning.

Her er produktionsmiljøkonfigurationen:

# .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

Hvis du foretrækker containere, kan du Dockerize Strapi og deploye hvor som helst; se vores guide om containerisering muligheder. Railway understøtter også Nixpacks til automatiske builds uden en Dockerfile.

Produktions-checkliste

Før du går live, skal du verificere følgende:

• Byg admin-panelet: Kør npm run build; dette kompilerer React-admin'en til produktion
• Procesmanager: Brug PM2 til at holde Strapi kørende og auto-genstarte ved nedbrud
• Health check: Strapi eksponerer /_health (returnerer HTTP 204); peg din load balancer mod det
• Medielagring: Skift fra lokale uploads til S3 eller Cloudinary; lokal lagring persistere ikke på de fleste PaaS-platforme
• Reverse proxy: Sæt Nginx eller Caddy foran Strapi til SSL-terminering og caching af statiske filer
• Miljøvariabler: Commit aldrig hemmeligheder. Brug platform-native env var-management

Strapi vs. Sanity vs. Contentful: Hvilken skal du vælge?

Valget mellem Strapi, Sanity og Contentful afhænger af tre ting: om du har brug for self-hosting, hvordan dit team samarbejder om indhold, og dine budgetbegrænsninger. Alle tre er produktionsgrade headless CMS-platforme, men de laver fundamentalt forskellige afvejninger. For dybere dækning, tjek vores Sanity CMS-guide og Contentful-guide.

Beslutningsramme, vælg baseret på din faktiske begrænsning:

Hos Techsy bygger vi headless CMS-arkitekturer ved hjælp af Strapi, Sanity og Contentful. Hvis du har brug for hjælp til at vælge det rigtige CMS til dit projekt eller ønsker en produktionsklar Strapi-opsætning, få en gratis konsultation.

Ærlige fordele, ulemper og hvornår du IKKE bør bruge Strapi

Efter at have testet Strapi 5 på tværs af tre klientprojekter, her er den ærlige gennemgang. Strapi er fremragende til teams, der ønsker fuld backend-kontrol, men det er ikke det rette værktøj for alle.

Fordele:

• Fuld kodeejerskab, dine data, din server, dine regler
• MIT-licens uden vendor lock-in
• TypeScript-first i v5 med stærk typeinferens
• Autogenererede REST- og GraphQL-endepunkter fra indholdsskemaer
• Aktivt community: 65.000+ GitHub-stjerner, Discord med 20.000+ medlemmer
• 500+ plugins på markedspladsen
• Tilpassede controllere giver dig Express.js-niveau backend-fleksibilitet
• Strapi Cloud tilbyder en managed option, hvis du ikke vil self-hoste

Ulemper:

• Self-hosting kræver ops-arbejde, forvent 10-20 timer/måned til opdateringer, overvågning og backups
• Ingen realtidssamarbejde (to redaktører kan overskrive hinandens ændringer)
• Migration fra Strapi 4 til 5 har friktion: Entity Service til Document Service, nye svarformater, plugin-kompatibilitetsgab
• Strapi Cloud er stadig under modning sammenlignet med Contentfuls eller Santys hostede platforme
• Mindre enterprise-adoption end Contentful, færre compliance-certificeringer
• Tilpasning af admin-panel, selvom det er muligt, kræver dyb viden om Strapis interne API'er

Hvornår du IKKE bør bruge Strapi:

• Har brug for realtidssamarbejde, arbejder dit redaktionelle team samtidigt på indhold? Brug Sanity. Strapi har ingen multiplayer-redigering.
• Har brug for enterprise-governance og SOC2, compliance-tung organisation? Contentful har et årtis forspring på governance-værktøjer.
• Ikke-teknisk team, ingen udviklerstøtte, Strapi kræver en udvikler til opsætning, deployment og vedligeholdelse. Hvis dit team kun består af marketingsfolk, så overvej et SaaS CMS eller WordPress.
• Serverless-first arkitektur, Strapi har brug for en persistent server. Hvis du bygger udelukkende på edge-funktioner og serverless, passer Sanity eller Contentful bedre.

FAQ

Hvad er Strapi, og hvordan virker det?

Strapi er et open source headless CMS bygget på Node.js. Du definerer indholdstyper gennem en visuel builder eller kode, og Strapi autogenererer REST- og GraphQL-API-endepunkter. Frontend-applikationer henter indhold som JSON fra disse endepunkter. Admin-panelet giver en React-baseret grænseflade, hvor indholdsredaktører kan administrere poster uden at skrive kode.

Er Strapi gratis at bruge?

Ja. Strapi Community Edition er gratis og open source under MIT-licensen. Du kan self-hoste det på din egen server uden brugsbegrænsninger, ingen pladsbegrænsninger og ingen loft på API-kald. Strapi Cloud (den managed hosting-option) har et gratis niveau med 10.000 API-kald om måneden, med betalte planer startende ved $18/måned for højere grænser.

Hvad er forskellen mellem Strapi og Contentful?

Strapi er open source og self-hosted, hvilket giver dig fuld kodeadgang og dataejerskab. Contentful er en proprietær SaaS-platform med stærkere enterprise-governance, compliance-certificeringer og et større redaktionelt værktøjssæt. Vælg Strapi for kodekontrol og budgetfleksibilitet. Vælg Contentful til enterprise-compliance-behov og større redaktionelle teams, der har brug for managed infrastruktur.

Er Strapi godt for begyndere?

Strapi er begyndervenligt, hvis du har basal Node.js- og JavaScript-viden. Admin-panelet og Content-Type Builder er visuelle og intuitive; der kræves ingen kode til indholdsmodellering. Deployment og tilpasset backend-logik kræver udviklererfaring. For absolutte begyndere uden kodningsbaggrund ville WordPress eller et fuldt managed SaaS CMS være lettere udgangspunkter.

Hvilken database bruger Strapi?

Strapi understøtter PostgreSQL, MySQL, MariaDB og SQLite. Nye projekter defaulter til SQLite for zero-setup udvikling. PostgreSQL anbefales til produktionsworkloads; det er den mest testede database med Strapi og håndterer samtidig adgang, komplekse forespørgsler og JSON-felttyper godt. Du konfigurerer databaseforbindelsen i config/database.ts.

Hvordan deployer man Strapi til produktion?

Du kan deploye Strapi til Strapi Cloud (managed hosting startende ved $18/måned) eller self-hoste på platforme som Railway, Render, DigitalOcean eller AWS. Self-hosting kræver konfiguration af en Node.js-server, PostgreSQL-database, miljøvariabler, medielayring (S3 eller Cloudinary) og en procesmanager som PM2. Kør npm run build før deployment for at kompilere admin-panelet.

Er Strapi bedre end WordPress?

Strapi og WordPress løser forskellige problemer. Strapi er et headless CMS, der serverer JSON-API'er til ethvert frontend, ideelt til udviklere, der bygger tilpassede apps, multi-platform indholdslevering eller JavaScript-tunge sites. WordPress er et traditionelt CMS, der renderer HTML-sider, bedre til ikke-tekniske brugere, der ønsker temaer, drag-and-drop-buildere og et massivt plugin-økosystem uden at skrive kode.

Hvad er ulemperne ved Strapi?

De største ulemper er operationel overhead fra self-hosting (opdateringer, overvågning, backups), manglende realtidssamarbejde for redaktionelle teams, migrationsfriktion mellem hovedversioner (v4 til v5 krævede kodeændringer) og et mindre modent enterprise-tilbud sammenlignet med Contentful. Strapi Cloud adresserer hosting-byrden, men halter stadig efter på funktioner og global tilgængelighed.

Kan Strapi håndtere storskala-applikationer?

Ja. Strapi kan håndtere storskala-applikationer med korrekt infrastruktur: PostgreSQL med connection pooling, horisontal skalering bag en load balancer, CDN til medieaktiver og Redis til caching. Virksomheder som IBM, NASA og Toyota bruger Strapi i produktion. Bottleneck er normalt databaseydelse og hostingkonfiguration, ikke Strapi selv.

Hvad er Strapi Cloud, og hvor meget koster det?

Strapi Cloud er den officielle managed hosting-platform til Strapi-projekter. Det håndterer serverprovisioning, databaseadministration, CDN og automatiske backups. Priserne starter med et gratis niveau (1 projekt, 10K API-kald/måned), derefter Essential til $18/måned, Pro til $90/måned og Scale til $450/måned. Hvert niveau øger grænserne for API-kald, team-pladser og lagerkapacitet.