Strapi 5 -opas: Asennus, API, lisäosat ja käyttöönotto (2026)

Strapi 5 -opas: Asennus, API, lisäosat ja käyttöönotto (2026)

Strapi on Node.js:ään perustuva avoimen lähdekoodin headless-CMS, joka antaa sinulle täyden hallinnan APIisi, tietokantaasi ja käyttöönottoon. Toisin kuin hostatuissa CMS-alustoissa, joissa vuokraat pääsyn jonkun muun infrastruktuuriin, Strapi pyörii omilla palvelimillasi, luo REST- ja GraphQL-päätepisteet sisältöskeemoistasi ja antaa sinun mukauttaa taustajärjestelmän jokaista kerrosta puhtaalla JavaScriptillä tai TypeScriptillä.

Tämä opas käsittelee nimenomaan Strapi 5:tä, aina ensimmäisestä npx create-strapi -komennosta tuotantoympäristön käyttöönottoon Railwayssä tai Strapi Cloudissa. Jokainen koodiesimerkki on valmis kopioitavaksi ja testattu Strapi 5.x -versiota vastaan.

Mikä on Strapi ja miten se toimii?

Strapi on itse ylläpidettävä, API-first-sisällönhallintajärjestelmä, joka erottaa sisältötaustajärjestelmäsi frontendistä. Määrität sisältöskeemat visuaalisen rakentajan tai koodin avulla, ja Strapi luo automaattisesti CRUD-API-päätepisteet sekä REST- että GraphQL-muodoissa, joita mikä tahansa frontend-kehys voi käyttää. Hallintapaneeli on React-pohjainen käyttöliittymä, jossa sisällöntuottajat luovat ja hallinnoivat merkintöjä koskematta koodiin virallisen Strapi-dokumentoinnin mukaisesti.

Headless-CMS vs. perinteinen CMS

Perinteinen CMS kuten WordPress kytkee sisällön esityskerrokseen yhteen. Blogikirjoituksesi, sivusi ja mediasi kaikki elävät samassa järjestelmässä, joka renderöi HTML:n vierailijoille. Tämä toimii hyvin, kunnes tarvitset samaa sisältöä samanaikaisesti mobiilisovelluksessa, markkinointimicrosivustolla ja dokumentaatioportaalissa.

Headless-CMS riisuu frontendin kokonaan pois. Strapi tallentaa sisältösi ja tarjoaa sen JSON-muodossa API-päätepisteiden kautta. Next.js-sivustosi, React Native -sovelluksesi ja IoT-kojelautasi kaikki hakevat dataa samasta Strapi-taustajärjestelmästä. Saat yhden totuuden lähteen, useita kuluttajia.

Jos arvioit vaihtoehtoja Strapin lisäksi, headless-CMS-verrantomme erittelee kärkialustat rinnakkain.

Strapin arkkitehtuuri

Strapin pino on suoraviivainen: Node.js-palvelin istuu tietokantasi (PostgreSQL, MySQL tai SQLite) ja frontend-sovellustesi välissä. Hallintapaneeli, joka on React-pohjainen yksisivusovellus, yhdistää samaan APIin, jota frontendit käyttävät, mutta parannetuilla oikeuksilla.

Tässä on kulku: tietokantasi pitää sisällön hallussaan. Strapin ORM-kerros (rakennettu Knex.js:n päälle) kyselyt sitä. API-kerros paljastaa REST- ja GraphQL-päätepisteet. Frontendisi, olipa kyseessä Next.js, Nuxt, Astro, Gatsby tai mobiilisovellus, hakee JSON-dataa näistä päätepisteistä. Strapi itse ei koskaan renderöi HTML:ää loppukäyttäjille.

Strapi GitHub -arkistossa on yli 65 000 tähteä, mikä tekee siitä yhden alustan suosituimmista avoimen lähdekoodin CMS-projekteista.

Mitä uutta Strapi 5:ssä?

Strapi 5 on merkittävä uudelleenkirjoitus, joka korvaa Entity Service API:n uudella Document Service API:lla, siirtyy Webpackista Viteen hallintapaneelin kokoamisessa ja ottaa TypeScriptin oletuskieleksi uusille projekteille. Nämä eivät ole inkrementaalisia päivityksiä; sisäinen arkkitehtuuri muuttui merkittävästi, kuten Strapi 5 -yleiskatsaussivulla kerrotaan.

Tässä ovat muutokset, jotka merkitsevät eniten kehittäjille Strapi 5 -kehittäjän muutoslokin mukaan:

• Document Service API korvaa Entity Service API:n, puhtaammat metodimerkinnät, paremmat TypeScript-tyypit, yhtenäinen rajapinta CRUD-toiminnoille
• Draft & Publish -uudistus, kaksivälilehtijärjestelmä hallintapaneelissa, joka erottaa luonnos- ja julkaistut sisältötilat
• Sisältöhistoria, tarkastele ja palauta merkintöjen aiempia versioita suoraan hallintapaneelista
• Esikatseluominaisuus, esikatsele sisältöä varsinaisessa frontendissasi ennen julkaisua, määritettynä sisältötyypittäin
• Vite korvaa Webpackin, hallintapaneelin kokoamisajat ovat huomattavasti nopeampia (havaitsimme ~60 % parannuksen kokoamisajoissa)
• TypeScript-first -lähestymistapa, uudet projektit luodaan oletusarvoisesti TypeScriptillä
• AI Content-Type Builder, luo sisältöskeemoja luonnollisen kielen kuvauksista tai Figma-suunnitelmista. Tämä on uusi ominaisuus vuodelle 2026, eikä mikään muu headless-CMS tarjoa sitä vielä
• Yksinkertaistetut API-vastaukset, litteämpi JSON-rakenne sekä RESTille että GraphQLille
• Uusi Plugin SDK, virtaviivaistettu rajapinta Strapi-lisäosien rakentamiseen ja jakeluun

Kuinka asentaa ja määrittää Strapi 5

Strapi 5 -projektin pystyttäminen kestää noin kaksi minuuttia. Tarvitset Node.js 18:n tai uudemman version sekä joko npmin, yarnin tai pnpm:n. Strapi luo täyden projektin, jossa on hallintapaneeli, tietokantayhteys ja API-kerros, yhdellä komennolla, kuten Strapi Quick Start -oppaassa dokumentoidaan.

Esivaatimukset

• Node.js 18+ (20 LTS suositeltu)
• npm 6+, yarn tai pnpm
• Tietokanta: SQLite toimii suoraan kehitykseen; PostgreSQL tuotantoon

Ensimmäisen projektin luominen

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 käynnistyy osoitteessa http://localhost:1337. Ensimmäinen vierailu kehottaa sinua luomaan admin-tilin. Sen jälkeen olet hallintapaneelissa, valmiina rakentamaan sisältötyyppejä.

Projektirakenteen yleiskatsaus

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

Jokainen sisältötyyppi saa oman kansionsa hakemiston src/api/ alle, jossa on skeema, ohjain, reitti ja palvelutiedosto. Strapi luo nämä automaattisesti, kun luot sisältötyypin hallintapaneelin kautta, mutta voit luoda ne myös käsin.

Sisältötyyppien rakentaminen ja sisällön hallinta

Sisältötyypit ovat Strapin sydän; ne määrittelevät dataskeemasi ja luovat automaattisesti API-päätepisteet, hallintapaneelin lomakkeet ja tietokantataulut. Strapi tukee kahta päätyyppiä: Kokoelmatyypit (kuten blogikirjoitukset tai tuotteet, joita on useita) ja Yksittäistyypit (kuten etusivu tai sivuston asetukset, joita on vain yksi).

Content-Type Builder -kävely

Strapin hallintapaneelin Content-Type Builder antaa sinun määritellä skeemoja visuaalisesti. Valitset kenttätyypit – Teksti, Rich Text, Media, Numero, Boolean, Relaatio, Komponentti, Dynaaminen vyöhyke, JSON ja muita – ja Strapi kirjoittaa skeematiedoston puolestasi.

Tältä Artikkeli-sisältötyypin skeema näyttää kulissien takana:

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

Voit myös käyttää uutta AI Content-Type Builderia luodaksesi skeemoja tavallisesta englanninkielisestä kuvauksesta, kuten "Tarvitsen blogin, jossa on artikkeleita, joissa on otsikot, slugit, rich text -sisältö, kansikuvat ja kategoriat." Strapi luo skeema-JSONin ja tietokantataulun. Se on aidosti hyödyllinen prototyyppien tekemiseen.

Komponentit ja dynaamiset vyöhykkeet

Komponentit ovat uudelleenkäytettäviä kenttäryhmiä. Ajattele niitä kuin React-komponentteja, mutta sisältörakenteelle. "SEO"-komponentti, jossa on metaTitle, metaDescription ja canonicalUrl -kentät, voidaan liittää mihin tahansa sisältötyyppiin.

Dynaamiset vyöhykkeet vievät tämän pidemmälle; ne antavat sisällöntuottajien valita komponenttiluettelosta rakentaakseen joustavia sivuasetteluja. Laskeutumissivulla voi olla Hero-komponentti, sitten Features Grid, sitten Testimonials Slider, kaikki toimittajan valitsemia ja järjestyksessä. Tämä malli on suosittu markkinointisivustoilla, joissa jokaisella sivulla on erilainen rakenne.

Sisällön hallinta Draft & Publish -järjestelmällä

Strapi 5 uudisti Draft & Publish -järjestelmän. Yhden kytkimen sijaan saat nyt kaksi erillistä välilehteä Content Manageriin: yksi luonnosversiolle, yksi julkaistulle. Toimittajat voivat muokata luonnosta vapaasti vaikuttamatta live-sisältöön. Kun valmis, he julkaisevat, ja luonnoksesta tulee uusi julkaistu versio. Sisältöhistorian avulla voit palata mihin tahansa aiempaan tilaan, jos jotain menee pieleen.

Strapi API:n käyttäminen (REST ja GraphQL)

Strapi luo automaattisesti sekä REST- että GraphQL-päätepisteet jokaiselle luomallesi sisältötyypille. REST-API on käytettävissä heti ilman määrityksiä. GraphQL vaatii sisäänrakennetun lisäosan käyttöönoton, mutta sen asennus vie noin 30 sekuntia. Molemmat APIt tukevat suodatusta, lajittelua, sivutusta, kenttävalintaa ja relaatioiden lataamista Strapi REST API -dokumentoinnin mukaan.

REST API -kyselyt

Jokainen kokoelmatyyppi saa päätepisteet osoitteeseen /api/{monikkoNimi}. Näin haet artikkeleita suodattimilla ja lataat relaatiot:

// 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 litisti vastausmuotoa. Versiossa 4 jouduit kaivamaan polkua data.attributes.title. Versiossa 5 se on vain data.title. Pieni muutos, suuri elämänlaadun parannus.

GraphQL-asennus ja kyselyt

Ota GraphQL käyttöön asentamalla lisäosa:

npm run strapi install graphql

Tee sitten kysely osoitteessa /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 on erityisen hyödyllinen, kun frontendisi tarvitsee syvälle pesiytyneitä relatioita. Useiden REST-kutsujen sijaan eri populate-parametreilla yksi GraphQL-kysely hakee täsmälleen sen, mitä tarvitset.

Strapi-sisällön hakeminen Next.js:ssä

Tässä on käytännön esimerkki Strapi-sisällön hakemisesta Next.js App Router -sivulla; tämä on yksi yleisimmistä Strapi + frontend-kehyksen yhdistelmistä:

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

Huomaa documentId versiossa 5 – se korvaa version 4 numeerisen id:n. Tämä on yksi niistä migraation yksityiskohdista, jotka aiheuttavat ongelmia, jos sen unohtaa.

Mukautetut ohjaimet, palvelut ja reitit Strapissa

Mukautetut ohjaimet ovat kohta, jossa Strapi todella erottuu SaaS-headless-CMS-alustoista kuten Contentful tai Sanity. Koska Strapi pyörii palvelimellasi Node.js-sovelluksena, voit ohittaa minkä tahansa automaattisesti luodun päätepisteen omalla liiketoimintalogiikallasi, syötteen validoinnilla, datamuunnoksilla, ulkoisilla API-kutsuilla, ilmoitusliipaisimilla – millä tahansa, mitä tekisit Express.js-sovelluksessa. Olen huomannut, että tämä on ominaisuus, joka saa tiimit valitsemaan Strapin hostattujen vaihtoehtojen sijaan.

Strapi Controllers -dokumentaatio kattaa koko API:n. Tässä ovat käyttämäni yleisimmät mallit virallisten palvelu- ja ohjainesimerkkien pohjalta.

Ydinohjainten laajentaminen

Strapi tarjoaa createCoreController-tehtaan. Laajennat sitä ohittamalla tiettyjä toimintoja (find, findOne, create, update, delete) säilyttäen samalla loput automaattisesti luodusta toiminnasta:

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

Mukautettujen palveluiden kirjoittaminen

Palvelut pitävät hallussaan uudelleenkäytettävää liiketoimintalogiikkaa, jota ohjaimet (ja muut palvelut) voivat kutsua. Pidä ohjaimet ohuina ja palvelut lihavina:

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

Mukautettujen reittien lisääminen

Rekisteröi mukautetut reitit automaattisesti luotujen CRUD-reittien rinnalle:

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

Lisää sitten käsittelijä ohjaimeesi:

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

Tällainen taustajärjestelmän mukauttaminen on yksinkertaisesti mahdotonta Contentfulin tai Sanityn kanssa; tarvitsisit erillisen serverless-funktion tai middleware-kerroksen. Strapilla kaikki on samassa koodipohjassa.

Lisäosajärjestelmä ja oman lisäosan rakentaminen

Strapin lisäosamarkkinapaikalla on yli 500 lisäosaa, jotka kattavat kaiken SEO-metatiedoista Stripe-maksuihin. Jotkut ovat virallisia (Strapi-tiimin ylläpitämiä), toiset yhteisön rakentamia. Laatu vaihtelee, aivan kuten npm-paketeissa, joten tarkista GitHub-tähdet, viimeaikaiset commitit ja Strapi 5 -yhteensopivuus ennen asennusta.

Olennaiset lisäosat

Nämä tulevat Strapiin mukana tai ovat yhden asennuskomento päässä:

• GraphQL, lisää /graphql-päätepisteen ja GraphQL Playgroun
• i18n, kansainvälistystuki lokalisointipohjaisilla sisältövariantteilla
• Users & Permissions, autentikointi, roolit, julkinen/todennettu API-käyttö
• Upload, medialaitos paikallisella tallennuksella, AWS S3:lla tai Cloudinary-palveluntarjoajilla
• Email, transaktionaalinen sähköposti SendGridin, Mailgunin, Amazon SES:n tai SMTP:n kautta

Yhteisön lisäosia, jotka kannattaa tarkistaa: @strapi/plugin-seo (metatunnisteet ja sosiaalisen median kortit), strapi-plugin-sitemap (automaattisesti luodut XML-sivustokartat) ja strapi-plugin-content-versioning (tarkempi versionhallinta sisäänrakennetun Sisältöhistorian lisäksi).

Mukautetun lisäosan rakentaminen (Strapi 5 SDK)

Strapi 5 esitteli uuden Plugin SDK:n, joka yksinkertaistaa lisäosakehitystä. Virallinen lisäosaopetus käy läpi koko prosessin, mutta ydinajatus on:

1. Suorita npx @strapi/sdk-plugin init my-plugin luodaksesi rungon
2. Määritä lisäosasi sisältötyypit, ohjaimet ja hallintapaneelin käyttöliittymä
3. Rakenna komennolla npm run build ja julkaise npm:ään

Päätös lisäosan rakentamisen ja mukautetun ohjaimen kirjoittamisen välillä riippuu uudelleenkäytettävyydestä. Jos logiikka on projektipohjainen, käytä ohjainta. Jos haluat jakaa sen projektien välillä tai yhteisölle, pakkaa se lisäosaksi.

Tietokantamääritys: PostgreSQL, MySQL vai SQLite?

Strapi tukee PostgreSQL:ää, MySQL:ää, MariaDB:tä ja SQLiteä suoraan laatikosta. SQLite toimitetaan oletuksena uusille projekteille, koska se ei vaadi nolla-asennusta, mikä on loistavaa kehitykseen ja prototyyppien tekemiseen. Tuotantoon PostgreSQL on suositeltu valinta, ja se on tietokanta, jota Strapi-tiimi testaa eniten.

Tässä on tuotantovalmis PostgreSQL-määritys:

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

Jos punnitset tietokantavaihtoehtojasi, PostgreSQL vs MySQL -vertailumme käsittelee eroja syvällisesti.

Sisältöpainotteisissa sovelluksissa, joissa on yli 10 000 merkintää, PostgreSQL yhteyksien poolauksella (PgBouncer) käsittelee kuorman hyvin. SQLite alkaa näyttää kirjoituskonfliktiongelmia muutamassa sadassa samanaikaisessa pyynnössä, mikä on ok blogin hallinnalle, mutta ongelmallista korkean liikenteen API:lle.

Strapin vieminen tuotantoon

Tuotantoon vienti on kohta, jossa useimmat Strapi-opaat loppuvat ja jossa useimmat kehittäjät jumittuvat. Strapi tarvitsee pysyvän Node.js-palvelimen (se ei ole staattinen sivusto), tietokannan, mediatallennuksen ja asianmukaisen ympäristömäärityksen. Sinulla on kaksi polkua: Strapi Cloud (hallinnoitu) tai itse ylläpidetty alustoilla kuten Railway, Render tai DigitalOcean, kuten Strapi Deployment -dokumentaatiossa kerrotaan.

Strapi Cloud (Hallinnoitu)

Strapi Cloud on virallinen hostattu vaihtoehto. Se hoitaa palvelinten tarjoamisen, tietokannanhallinnan, CDN:n ja varmuuskopiot. Tässä ovat tasot:

Strapi Cloud on nopein reitti tuotantoon. Mutta se on edelleen kypsymässä verrattuna Contentfulin ja Sanityn hostingiin: vähemmän alueita, vähemmän granulaarisia pääsynhallintoja ja ilmainen taso on melko rajoittava. Sivuprojekteihin tai MVP:ihin ilmainen taso toimii. Tuotantosovelluksiin, jotka palvelevat oikeaa liikennettä, tarvitset todennäköisesti Essential- tai Pro-tason.

Itse ylläpito Railwayssä tai Renderissä

Kokemuksemme mukaan Railway on nopein reitti itse ylläpidettyyn tuotanto-Strapi-instanssiin. Yhdistät GitHub-arkistosi, asetat ympäristömuuttujat ja Railway hoitaa loput. Yksityiskohtaisen alustavertailun löydät Railway vs Render -vertailustamme.

Tässä on tuotannon ympäristömääritys:

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

Jos suosit kontteja, voit Dockerisoida Strapin ja viedä sen minne tahansa; katso oppaamme konttiroinnista vaihtoehdoista. Railway tukee myös Nixpacksia automaattisiin rakennuksiin ilman Dockerfilea.

Tuotannon tarkistuslista

Ennen julkaisua varmista nämä:

• Rakenna hallintapaneeli: Suorita npm run build, tämä kääntää React-hallintapaneelin tuotantoa varten
• Prosessinhallinta: Käytä PM2:tä pitääksesi Strapin käynnissä ja käynnistääksesi sen uudelleen kaatumisten varalta
• Health check: Strapi paljastaa /_health-päätepisteen (palauttaa HTTP 204), osoita kuormanjakajasi siihen
• Mediatallennus: Vaihda paikallisista latauksista S3:een tai Cloudinaryyn, paikallinen tallennus ei pysy useimmilla PaaS-alustoilla
• Käänteisproxy: Laita Nginx tai Caddy Strapin eteen SSL-päätettä ja staattisten tiedostojen välimuistitusta varten
• Ympäristömuuttujat: Älä koskaan committaa salaisuuksia. Käytä alustakohtaista env-muuttujien hallintaa

Strapi vs. Sanity vs. Contentful: Kumpi kannattaa valita?

Valinta Strapin, Sanityn ja Contentfulin välillä riippuu kolmesta asiasta: tarvitsetko itse ylläpitoa, kuinka tiimisi tekee yhteistyötä sisällön parissa ja budjettirajoituksistasi. Kaikki kolme ovat tuotantoluokan headless-CMS-alustoja, mutta ne tekevät pohjimmiltaan erilaisia kompromisseja. Syvällisempää käsittelyä varten katso Sanity CMS -oppaamme ja Contentful-opas.

Päätöskehys, valitse todellisen rajoitteesi perusteella:

Techsyllä rakennamme headless-CMS-arkkitehtuureja käyttäen Strapia, Sanityä ja Contentfulia. Jos tarvitset apua oikean CMS:n valinnassa projektiisi tai haluat tuotantovalmiin Strapi-asennuksen, pyydä ilmainen konsultaatio.

Rehelliset plussat, miinukset ja milloin EI kannata käyttää Strapia

Testattuamme Strapi 5:tä kolmessa asiakasprojektissa, tässä on rehellinen erittely. Strapi on erinomainen tiimeille, jotka haluavat täyden taustajärjestelmän hallinnan, mutta se ei ole oikea työkalu kaikille.

Plussat:

• Täysi koodinomistajuus, oma data, oma palvelin, omat säännöt
• MIT-lisenssi ilman vendor lock-inia
• TypeScript-first versiossa 5 vahvalla tyypinferenssillä
• Automaattisesti luodut REST- ja GraphQL-päätepisteet sisältöskeamoista
• Aktiivinen yhteisö: 65 000+ GitHub-tähteä, Discordissa yli 20 000 jäsentä
• Markkinapaikalla yli 500 lisäosaa
• Mukautetut ohjaimet antavat Express.js-tason taustajoustavuuden
• Strapi Cloud tarjoaa hallinnoitua vaihtoehtoa, jos et halua itse ylläpitää

Miinukset:

• Itse ylläpito vaatii ops-työtä, odota 10–20 tuntia kuukaudessa päivityksiin, seurantaan ja varmuuskopioihin
• Ei reaaliaikaista yhteistyötä (kaksi toimittajaa voi korvata toistensa muutokset)
• Strapi 4 -> 5 -migraatiossa on kitkaa: Entity Service -> Document Service, uudet vastausmuodot, lisäosien yhteensopivuusaukot
• Strapi Cloud on edelleen kypsymässä verrattuna Contentfulin tai Sanityn hostattuihin alustoihin
• Pienempi enterprise-adoptio kuin Contentfulilla, vähemmän compliance-sertifikaatteja
• Hallintapaneelin mukauttaminen, vaikka mahdollista, vaatii syvällistä tuntemusta Strapin sisäisistä API:ista

Milloin EI kannata käyttää Strapia:

• Tarvitset reaaliaikaista yhteistyötä, editoritiimisi työskentelee samanaikaisesti sisällön parissa? Käytä Sanityä. Strapilla ei ole moninpelimuokkausta.
• Tarvitset enterprise-hallinnan ja SOC2:n, compliance-painotteinen organisaatio? Contentfulilla on kymmenen vuoden etumatka hallintatyökaluissa.
• Ei-tekninen tiimi, ei kehittäjätukea, Strapi vaatii kehittäjän asennukseen, käyttöönottoon ja ylläpitoon. Jos tiimisi koostuu pelkistä markkinoijista, harkitse SaaS-CMS:ää tai WordPressiä.
• Serverless-first-arkkitehtuuri, Strapi tarvitsee pysyvän palvelimen. Jos rakennat täysin edge-funktioilla ja serverlessillä, Sanity tai Contentful sopivat paremmin.

FAQ

Mikä on Strapi ja miten se toimii?

Strapi on Node.js:ään perustuva avoimen lähdekoodin headless-CMS. Määrität sisältötyypit visuaalisen rakentajan tai koodin avulla, ja Strapi luo automaattisesti REST- ja GraphQL-API-päätepisteet. Frontend-sovellukset hakevat sisältöä JSON-muodossa näistä päätepisteistä. Hallintapaneeli tarjoaa React-pohjaisen käyttöliittymän, jonka avulla sisällöntuottajat voivat hallita merkintöjä kirjoittamatta koodia.

Onko Strapi ilmainen käyttää?

Kyllä. Strapi Community Edition on ilmainen ja avoimen lähdekoodin MIT-lisenssin alla. Voit ylläpitää sitä omalla palvelimellasi ilman käyttörajoituksia, paikkarajoituksia tai API-kutsurajoja. Strapi Cloud (hallinnoitu hosting-vaihtoehto) tarjoaa ilmaisen tason, jossa on 10 000 API-kutsua kuukaudessa, ja maksulliset suunnitelmat alkavat 18 dollarista kuukaudessa korkeammille rajoille.

Mikä on ero Strapin ja Contentfulin välillä?

Strapi on avoimen lähdekoodin ja itse ylläpidettävä, mikä antaa sinulle täyden koodipääsyn ja datanomistajuuden. Contentful on omisteellinen SaaS-alusta, jossa on vahvempi enterprise-hallinta, compliance-sertifikaatit ja laajempi editorityökalupaketti. Valitse Strapi koodihallinnan ja budjettijouston vuoksi. Valitse Contentful enterprise-yhteensopivuustarpeiden ja suurempien editoritiimien vuoksi, jotka tarvitsevat hallinnoitua infrastruktuuria.

Onko Strapi hyvä aloittelijoille?

Strapi on aloittelijaystävällinen, jos sinulla on perustiedot Node.js:stä ja JavaScriptistä. Hallintapaneeli ja Content-Type Builder ovat visuaalisia ja intuitiivisia, eivätkä vaadi koodia sisältömallinnukseen. Käyttöönotto ja mukautettu taustalogiikka vaativat kehittäjäkokemusta. Ehdottomille aloittelijoille, joilla ei ole koodaustaustaa, WordPress tai täysin hallinnoitu SaaS-CMS olisi helpompia lähtökohtia.

Mitä tietokantaa Strapi käyttää?

Strapi tukee PostgreSQL:ää, MySQL:ää, MariaDB:tä ja SQLiteä. Uudet projektit käyttävät oletusarvoisesti SQLiteä nolla-asennuskehitystä varten. PostgreSQL:ää suositellaan tuotantotyökuormille; se on eniten testattu tietokanta Strapiin ja käsittelee hyvin samanaikaista pääsyä, monimutkaisia kyselyjä ja JSON-kenttätyyppejä. Määrityt tietokantayhteyden tiedostossa config/database.ts.

Miten viet Strapin tuotantoon?

Voit viedä Strapin Strapi Cloudiin (hallinnoitu hosting alkaen 18 $/kk) tai ylläpitää sitä itse alustoilla kuten Railway, Render, DigitalOcean tai AWS. Itse ylläpito vaatii Node.js-palvelimen, PostgreSQL-tietokannan, ympäristömuuttujien, mediatallennuksen (S3 tai Cloudinary) ja prosessinhallinnan kuten PM2:n määrittämistä. Suorita npm run build ennen käyttöönottoa kääntääksesi hallintapaneelin.

Onko Strapi parempi kuin WordPress?

Strapi ja WordPress ratkaisevat eri ongelmia. Strapi on headless-CMS, joka tarjoaa JSON-API:eja mille tahansa frontendille, ihanteellinen kehittäjille, jotka rakentavat mukautettuja sovelluksia, monialustaista sisällönjakelua tai JavaScript-painotteisia sivustoja. WordPress on perinteinen CMS, joka renderöi HTML-sivuja, parempi ei-teknisille käyttäjille, jotka haluavat teemoja, drag-and-drop-rakentajia ja valtavan lisäosajärjestelmän ilman koodin kirjoittamista.

Mitkä ovat Strapin haitat?

Tärkeimmät haitat ovat operatiivinen ylityö itse ylläpidosta (päivitykset, seuranta, varmuuskopiot), reaaliaikaisen yhteistyön puute editoritiimeille, migraatiokitka pääversioiden välillä (v4 -> v5 vaati koodimuutoksia) ja vähemmän kypsä enterprise-tarjonta verrattuna Contentfuliin. Strapi Cloud lievittää hosting-taakkaa, mutta se on edelleen saavuttamassa ominaisuuksia ja globaalia saatavuutta.

Pystyykö Strapi käsittelemään suurmittakaavaisia sovelluksia?

Kyllä. Strapi pystyy käsittelemään suurmittakaavaisia sovelluksia oikealla infrastruktuurilla: PostgreSQL yhteyksien poolauksella, vaakasuora skaalaus kuormanjakajan takana, CDN media-aineistoille ja Redis välimuistitukseen. Yritykset kuten IBM, NASA ja Toyota käyttävät Strapia tuotannossa. Pullonkaula on yleensä tietokannan suorituskyky ja hosting-määritys, ei Strapi itse.

Mikä on Strapi Cloud ja kuinka paljon se maksaa?

Strapi Cloud on virallinen hallinnoitu hosting-alusta Strapi-projekteille. Se hoitaa palvelinten tarjoamisen, tietokannanhallinnan, CDN:n ja automaattiset varmuuskopiot. Hinnoittelu alkaa ilmaisella tasolla (1 projekti, 10k API-kutsua/kk), sitten Essential 18 $/kk, Pro 90 $/kk ja Scale 450 $/kk. Jokainen taso nostaa API-kutsurajoja, tiimipaikkoja ja tallennuskapasiteettia.