How to self-host Ghost on your own VPS without Docker

ox new <you>/Ghost
ox review ghost --from-file ghost.env --wait

# Ghost 6, as Dockerfile.production builds its server and CI builds its
# admin (job_build_admin), with MySQL (MariaDB) and the content folder kept
# (the image's VOLUME). Ghost reads its config from `__` variables: url,
# database__*, mail__* and logging are in ox.vars.
# fontconfig is the image's runtime package; jemalloc is preloaded in start.
packages = ["libjemalloc2", "fontconfig"]
# The owner is made at the first start from these, through the setup
# screen's own API call, so no first visitor can claim the site.
required_variables = ["GHOST_OWNER_EMAIL", "GHOST_OWNER_PASSWORD"]

[app]
start = "exec bash ox-ghost.sh start"
health = "/ghost/api/admin/site/"

[build]
# The whole workspace: admin's nx build fans out across the frontend graph.
# The workspace links node_modules into pnpm's global store, which the
# Dockerfile and CI turn off so the app is self-contained.
install = "pnpm_config_enable_global_virtual_store=false pnpm install --frozen-lockfile"
commands = [
  # The Dockerfile's server build: the workspace packages ghost runs, its
  # TypeScript (compiled in place) and its assets.
  "pnpm --filter-prod 'ghost^...' -r run build",
  "pnpm --filter ghost run build:tsc",
  "pnpm --filter ghost run build:assets",
  # CI's admin build: writes ghost/core/built/admin and embed-renderer.
  # CI's settings for nx, and no Nx Cloud.
  "NX_NATIVE_COMMAND_RUNNER=false NX_DAEMON=false NX_NO_CLOUD=true pnpm nx run @tryghost/admin:build",
]
# Ghost would also migrate as it boots; run it first, so a first deploy's
# schema is not made inside the start's health wait.
migrate = "bash ox-ghost.sh migrate"

[services]
mysql = {}

[storage]
# Ghost's contentPath: images, media, files, themes, settings (routes.yaml).
# The bundled Casper and Source themes are seeded into it.
keep = ["ghost/content"]

// Ghost's owner account on ox, made from GHOST_OWNER_* the way the setup
// screen (/ghost/#/setup) makes it: one call to the Admin API's setup
// endpoint, which also names the site and seeds the default tier,
// newsletter and theme settings. Run from ghost/ by ox-ghost.sh.
//   state      prints "yes" when the site is set up, "no" when it is not:
//              Ghost's own test (User.isSetup), the owner's status, read
//              from the database Ghost's config names
//   setup PID PORT  waits for the Ghost started as PID to answer on PORT,
//              then posts the setup unless the site is set up already, and
//              turns the Network feature off (see networkOff)
import http from 'node:http';
import {createRequire} from 'node:module';
import path from 'node:path';

// Ghost's dependencies and config, resolved from ghost/ (the cwd)
const require = createRequire(path.join(process.cwd(), 'index.js'));
const setupPath = '/ghost/api/admin/authentication/setup/';
const sessionPath = '/ghost/api/admin/session/';
const settingsPath = '/ghost/api/admin/settings/';

async function state() {
    const config = require('./core/shared/config');
    const mysql = require('mysql2/promise');
    const {host, port, user, password, database} = config.get('database:connection');
    const conn = await mysql.createConnection({host, port, user, password, database});
    try {
        const [rows] = await conn.query(
            'SELECT u.status FROM users u JOIN roles_users ru ON ru.user_id = u.id JOIN roles r ON r.id = ru.role_id WHERE r.name = ?',
            ['Owner']
        );
        if (rows.length !== 1) {
            throw new Error(`expected one owner in the users table, found ${rows.length}`);
        }
        console.log(rows[0].status === 'inactive' ? 'no' : 'yes');
    } finally {
        await conn.end();
    }
}

function request(port, method, urlPath, body, cookie) {
    const {PUBLIC_HOST, PUBLIC_SCHEME, PUBLIC_URL} = process.env;
    const data = body ? JSON.stringify(body) : undefined;
    return new Promise((resolve, reject) => {
        const req = http.request({
            host: '127.0.0.1',
            port,
            method,
            path: urlPath,
            timeout: 30000,
            headers: {
                // As ox's proxy calls it, so Ghost serves the request instead of
                // redirecting it to the site's public URL
                Host: PUBLIC_HOST,
                'X-Forwarded-Proto': PUBLIC_SCHEME,
                'X-Forwarded-For': '127.0.0.1',
                Origin: PUBLIC_URL,
                Accept: 'application/json',
                ...(cookie ? {Cookie: cookie} : {}),
                ...(data ? {'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data)} : {})
            }
        }, (res) => {
            let text = '';
            res.setEncoding('utf8');
            res.on('data', (chunk) => {
                text += chunk;
            });
            res.on('end', () => resolve({status: res.statusCode, headers: res.headers, text}));
        });
        req.on('timeout', () => req.destroy(new Error(`${method} ${urlPath} timed out`)));
        req.on('error', reject);
        req.end(data);
    });
}

function alive(pid) {
    try {
        process.kill(pid, 0);
        return true;
    } catch {
        return false;
    }
}

async function setup(pid, port) {
    const {GHOST_OWNER_EMAIL, GHOST_OWNER_PASSWORD, GHOST_OWNER_NAME, GHOST_SITE_TITLE} = process.env;
    if (!GHOST_OWNER_EMAIL || !GHOST_OWNER_PASSWORD) {
        throw new Error('GHOST_OWNER_EMAIL and GHOST_OWNER_PASSWORD must be set: they are the owner\'s sign-in');
    }
    const deadline = Date.now() + 5 * 60 * 1000;
    let last = 'no answer';
    for (;;) {
        if (!alive(pid)) {
            throw new Error(`Ghost stopped before it answered ${setupPath}, so no owner was made`);
        }
        try {
            const res = await request(port, 'GET', setupPath);
            if (res.status === 200) {
                if (JSON.parse(res.text).setup[0].status === true) {
                    console.log('ox-ghost: the site is set up already');
                    return;
                }
                break;
            }
            last = `${res.status} ${res.text.slice(0, 200)}`;
        } catch (err) {
            last = err.message;
        }
        if (Date.now() > deadline) {
            throw new Error(`Ghost did not answer ${setupPath} in 5 minutes (last: ${last}), so no owner was made`);
        }
        await new Promise((resolve) => {
            setTimeout(resolve, 1000);
        });
    }
    const res = await request(port, 'POST', setupPath, {
        setup: [{
            name: GHOST_OWNER_NAME || 'Owner',
            email: GHOST_OWNER_EMAIL,
            password: GHOST_OWNER_PASSWORD,
            blogTitle: GHOST_SITE_TITLE || 'Ghost'
        }]
    });
    if (res.status !== 201) {
        throw new Error(`the setup answered ${res.status}: ${res.text.slice(0, 500)}`);
    }
    console.log(`ox-ghost: made the owner ${GHOST_OWNER_EMAIL}`);
    await networkOff(port, GHOST_OWNER_EMAIL, GHOST_OWNER_PASSWORD);
}

// networkOff: Ghost's Network feature (social_web, on by default) needs
// Ghost's ActivityPub service, a separate app this deploy does not run. On,
// the admin calls /.ghost/activitypub/ on every page (404) and the boot
// logs a failed fetch, so the site starts with it off; the owner can turn it
// on in Settings, Network. An owner who never signed in gets a session
// without the mailed code, so this sign-in is the owner's first.
async function networkOff(port, email, password) {
    const signin = await request(port, 'POST', sessionPath, {username: email, password});
    if (signin.status !== 201) {
        throw new Error(`the owner's first sign-in answered ${signin.status}: ${signin.text.slice(0, 500)}`);
    }
    const cookie = (signin.headers['set-cookie'] || []).map((c) => c.split(';')[0]).join('; ');
    if (!cookie) {
        throw new Error('the owner\'s first sign-in set no session cookie');
    }
    const res = await request(port, 'PUT', settingsPath, {settings: [{key: 'social_web', value: false}]}, cookie);
    if (res.status !== 200) {
        throw new Error(`turning Network off answered ${res.status}: ${res.text.slice(0, 500)}`);
    }
    console.log('ox-ghost: turned Network (ActivityPub) off');
}

const [mode, pid, port] = process.argv.slice(2);
try {
    if (mode === 'state') {
        await state();
    } else if (mode === 'setup' && Number(pid) > 0 && Number(port) > 0) {
        await setup(Number(pid), Number(port));
    } else {
        throw new Error('usage: ox-ghost-owner.mjs state | setup PID PORT');
    }
} catch (err) {
    console.error(`ox-ghost: ${err.message}`);
    process.exit(1);
}

#!/usr/bin/env bash
# Ghost on ox, run as Ghost-CLI and the Docker image run it: the server in
# ghost/, configured by Ghost's own `__` variables (url, database__*,
# mail__*), with jemalloc in front.
#   migrate  knex-migrator, as Ghost-CLI runs it before a start: makes the
#            schema on the first deploy and migrates it on an upgrade
#   start    make the owner from GHOST_OWNER_* when the site is not set up
#            yet, then run Ghost
set -euo pipefail
cd ghost
export NODE_ENV=production

migrate() {
  exec pnpm exec knex-migrator-migrate --init --mgpath .
}

# make_owner: Ghost makes its owner only through its running server (the
# setup screen's API call), so run it in the background, complete the
# setup, and stop it again. It listens on a free port of its own, not on
# $PORT, where ox's health check would take it for the started release.
make_owner() {
  local pid port rc=0
  port=$(node -e 'const s = require("node:net").createServer(); s.listen(0, "127.0.0.1", () => { console.log(s.address().port); s.close(); });')
  server__port=$port node index.js &
  pid=$!
  if ! node ../ox-ghost-owner.mjs setup "$pid" "$port"; then
    kill "$pid" 2>/dev/null || true
    wait "$pid" || true
    exit 1
  fi
  kill "$pid"
  wait "$pid" || rc=$?
  # 143 is a stop by SIGTERM before Ghost's own handler took it.
  if [ "$rc" != 0 ] && [ "$rc" != 143 ]; then
    echo "ox-ghost: Ghost ended with status $rc after the owner was made" >&2
    exit 1
  fi
}

start() {
  local jemalloc state
  jemalloc=/usr/lib/$(uname -m)-linux-gnu/libjemalloc.so.2
  [ -f "$jemalloc" ] || { echo "ox-ghost: no $jemalloc (the libjemalloc2 package)" >&2; exit 1; }
  export server__host=127.0.0.1 server__port=$PORT
  state=$(node ../ox-ghost-owner.mjs state)
  case $state in
    yes) ;;
    no) make_owner ;;
    *) echo "ox-ghost: the setup check answered '$state'" >&2; exit 1 ;;
  esac
  # The Docker image preloads jemalloc for the server (ENV LD_PRELOAD).
  exec env LD_PRELOAD="$jemalloc" node index.js
}

case "${1:-}" in
  migrate) migrate ;;
  start) start ;;
  *) echo "usage: ox-ghost.sh migrate|start" >&2; exit 2 ;;
esac

GHOST_OWNER_EMAIL
GHOST_OWNER_PASSWORD
GHOST_OWNER_NAME
GHOST_SITE_TITLE
url
database__client
database__connection__host
database__connection__port
database__connection__user
database__connection__password
database__connection__database
logging__transports
mail__transport
mail__from
mail__options__host
mail__options__port
mail__options__secure