起動しただけでは動き続けない — Backendの到達作品

Backendの到達作品。サーバーと鍵付きのメモ、データベース。

※本記事はアフィリエイト広告(PR)を含みます。

サーバー・API・認証・REST設計で学んだことを、1つの動くものに束ねる演習です。起動しただけで終わらせず、動き続ける状態まで作ります。

前回: GitHubにコードを上げる手順|GitとGitHubの違いとpushまで

これは Backend コースの「到達作品」の回です。 新しい知識はほとんど出てきません。これまでの サーバーとは待ち続けるプログラム・APIの基本・セッションとJWT・REST APIの設計 を、1つの動くものに束ねる回です。作品づくりの進め方そのものは 全部書いてから動かさない — 作品のAPIと認証 にも書きました。

この記事のコマンドは、VMの中(Ubuntu Server)で打ちます。 Windows 本体の PowerShell ではありません。VM に SSH で入った状態、あるいは VM のコンソールで、Linux のシェルに打ちます。VM の立て方は、Backend の前段で使ってきた Ubuntu Server の回にあります。


対象レベル: 初級〜中級 / 区分: 必修

目次

めがける作品

このコースを終えたら、これが作れるようになっている。 ——そう言い切れる1本を、ここで作ります。

作るのは 「ログイン付きのメモAPI」 です。画面はありません。画面の無い、curl で叩くだけのAPIですが、Backend の基礎が全部入っています。

  • 登録できる(メールとパスワードでアカウントを作る)
  • ログインすると JWT(トークン)が返る
  • そのトークンを付けると、自分のメモを作る・一覧・書き換え・削除できる(CRUD)
  • 他人のメモは、IDを指定しても見えない(認証と認可は別、を実演する)
  • SSH を切っても動き続ける(手で起動しただけでは止まる、を越える)
  • VM の外(同じネットワークの別PC)から、80番ポートで叩ける

完成すると、こう叩けます。 ここでは中身を先に見せます。作るのは後です。

bash
$ # 1) 登録する
$ curl -X POST http://127.0.0.1:3000/auth/register \
    -H "Content-Type: application/json" \
    -d '{"email":"me@example.com","password":"pass1234"}'
$ # → {"id":1,"email":"me@example.com"}

$ # 2) ログインする → トークンが返る
$ curl -X POST http://127.0.0.1:3000/auth/login \
    -H "Content-Type: application/json" \
    -d '{"email":"me@example.com","password":"pass1234"}'
$ # → {"token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."}

$ # 3) 自分のメモを作る(さっきのトークンを付ける)
$ curl -X POST http://127.0.0.1:3000/memos \
    -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..." \
    -H "Content-Type: application/json" \
    -d '{"body":"牛乳を買う"}'
$ # → {"id":1,"body":"牛乳を買う","done":0}

$ # 4) 自分のメモ一覧
$ curl http://127.0.0.1:3000/memos \
    -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
$ # → [{"id":1,"body":"牛乳を買う","done":0}]

この作品は、最終的にこういう形で通信が流れます。 先に全体像を見ておきます。

  ┌──────────┐   80番    ┌──────────┐  3000番  ┌──────────┐   ファイル  ┌──────────┐
  │ curl や  │ ───────▶ │  nginx   │ ──────▶ │ Node.js  │ ─────────▶ │  SQLite  │
  │ ブラウザ │  HTTP    │(表で受け)│  中継   │ (API本体)│   読み書き  │ data.db  │
  └──────────┘          └──────────┘          └──────────┘            └──────────┘
       │                                            │
       │  Authorization: Bearer <JWT>               │  トークンを検証し
       └────────────────────────────────────────────┘  「誰のリクエストか」を決める

左から右へ、80番 → 3000番 → ファイル、と流れます。 外から見えるのは nginx(80番)だけで、Node.js(3000番)と SQLite(data.db)は VM の中に隠れています。⑦までで、この形を完成させます。

http://127.0.0.1:3000 は「VM の中から、VM 自身に」向けています。 最後の⑦で、これを VM の外から http://<VMのIP>/(80番) で叩ける形にします。そこまで行って初めて「作品」です。

作るエンドポイントは、全部でこれだけです。 一覧を先に決めておくと、迷いません。

メソッドとパス何をするかログイン成功コード
GET /health生きているか確認不要200
POST /auth/registerアカウント登録不要201
POST /auth/loginログイン。JWT を返す不要200
GET /memos自分のメモ一覧必要200
POST /memosメモを1件作る必要201
PATCH /memos/:idメモを1件書き換える必要200
DELETE /memos/:idメモを1件消す必要204

7本だけです。 これ以上増やさないと最初に決めたから、作り切れます。①で書いた「作らないものリスト」が、ここに効いています。

そして最後に、この API を node app.js で手で起動しただけでは、SSH を切った瞬間に止まる——この壁を越えることが、Backend コースの到達点です。

この記事でわかること

  • 「読んで分かる」と「1本を作り切る」は別であること。埋めるのは、手を動かす1本だけであること
  • 認証(あなたは誰か)と認可(あなたはこれに触ってよいか)は、別の仕事であること。ログインできても、他人のデータが見えていいわけではないこと
  • node app.js を手で起動しただけのAPIは「動いている」ではないこと。SSH を切れば止まる。常駐(デプロイ)まで含めて、はじめて動いていること
  • 秘密(JWTの鍵・パスワード)は、コードにもGitにも置かないこと。置き場所は環境変数(.env)であること
  • 自分で「完成した」と判定する基準の作り方

この記事でやること

  1. 作らないものリストを先に書いて、機能を「登録・ログイン・自分のメモCRUD」だけに絞る
  2. Express でサーバーの骨組みを作り、/health を curl で確かめる
  3. SQLite にテーブルを作り、ユーザーとメモを保存する
  4. 登録・ログインを作る。パスワードは bcrypt でハッシュ化し、ログイン成功で JWT を発行する
  5. JWT を検証するミドルウェアを挟み、自分のメモだけを返す。他人のは見えないことを curl で確認する
  6. systemd で常駐させ、nginx のリバースプロキシで80番から繋ぎ、SSH を切っても生きている状態にする
  7. 完成の判定(6つのチェック)を自分で通す

先に知る言葉

この記事で軸になる言葉です。 基本的な言葉は用語集にもまとめてあります。

言葉意味
APIプログラムが叩く窓口。ここでは JSON をやり取りする HTTP の窓口
エンドポイントPOST /auth/login のような、メソッド+パスの1つ1つ。窓口の各カウンター
認証(Authentication)「あなたは誰か」を確かめること。ログインがこれ
認可(Authorization)「あなたはこの操作をしてよいか」を判断すること。認証とは別
JWTログイン後に渡す署名付きの通行証(文字列)。毎回これを見せて「私は誰々」と示す
ハッシュ化パスワードを元に戻せない形に変えること。暗号化とは違い、戻せないのが正しい
ミドルウェアExpress で、各エンドポイントの手前に共通で挟む処理。ここでは「トークン検証」に使う
CRUDCreate / Read / Update / Delete。作る・読む・書き換える・消すの4操作
常駐(デーモン化)プログラムをログアウトしても動き続ける形にすること。ここでは systemd がやる
リバースプロキシ表で受けて、裏のプログラムへ流す係。ここでは nginx が80番で受けて3000番へ流す

① 何を作るか決める — 「作らないものリスト」を先に書く

いきなりコードを書きません。 到達作品でいちばん多い失敗は、機能を盛りすぎて、1つも完成しないまま力尽きることです。だから最初にやるのは、作らないものを決めることです。作るものリストより、作らないものリストのほうが大事です(個人開発の題材選びの回でも、同じ「作らないものを先に書く」考え方を扱っています)。

この作品で「作る」もの。

作る:
- アカウント登録(メール + パスワード)
- ログイン(成功したら JWT を返す)
- メモの作成 / 一覧 / 更新 / 削除(=自分のメモの CRUD)
- 「自分のメモだけ」見える(他人のは見えない)
- systemd で常駐、nginx で80番から叩ける

この作品で「作らない」もの。 どれも「あとで足せる」ものです。 いま足すと完成しません。

作らない(今回は捨てる):
- 画面(HTML/CSS/React)……API だけ作る。画面は後で繋ぐ
- パスワードを忘れたときの再設定メール……仕組みが増える
- メモの共有・公開……「自分のだけ」の原則が崩れる
- 本物のDB(MySQL/PostgreSQL)……まずは SQLite で作り切る
- Docker / CI / クラウド……VM の中で1つ動かすことに集中する
- タグ・検索・並べ替え……CRUD が動いてから

「あとで足せる」と「今いる」を分けるのが、題材を絞るコツです。 画面もDBの本物化も、ここから育てられます。まずは一本、端から端まで動くものを作り切ります。

この記事の完成形のフォルダ構成はこうなります。先に地図を見ておきます。

memo-api/
├── package.json      ← npm が作る
├── .env              ← 秘密(JWTの鍵)。⚠️ Git に上げない
├── .gitignore
├── db.js             ← SQLite の初期化とテーブル作成
├── app.js            ← API 本体(登録・ログイン・メモCRUD)
└── data.db           ← SQLite のデータ本体。⚠️ 自動でできる。Git に上げない

② サーバーの骨組み — まず /health が返るだけの状態を作る

認証もDBも、まだ一切書きません。 「サーバーは待ち続けるプログラム」でした(サーバーとは待ち続けるプログラム)。まず、待ち受けて、/health に {"ok":true} を返すだけの骨組みを動かします。ここが動かないと、この先は全部無意味です。

まず、Node.js が入っているか確かめます。

bash
$ node --version
$ npm --version

node: command not found と出たら、まだ Node.js が入っていません。 その場合は先に入れます(Ubuntu の例。バージョンは公式の手順に従ってください)。

bash
$ # 例: NodeSource から Node.js 22 を入れる(公式手順を確認してから)
$ sudo apt update
$ sudo apt install -y curl
$ # ↓ 具体的な導入コマンドは Node.js 公式のインストール手順を見て、その通りに打つ

プロジェクトのフォルダを作り、Express を入れます。

bash
$ mkdir ~/memo-api
$ cd ~/memo-api
$ npm init -y
$ npm install express

npm init -y は package.json を作るだけです。これが無いと npm install の記録が残りません。

app.js を作ります(nano app.js でも、VS Code のリモート編集でも構いません)。

// app.js — まずは骨組みだけ
const express = require("express");

const app = express();
app.use(express.json()); // ⚠️ これが無いと、送られてきた JSON を req.body で読めない

// 動作確認用。認証は要らない、誰でも叩ける
app.get("/health", (req, res) => {
  res.json({ ok: true });
});

const PORT = process.env.PORT || 3000;
// ⚠️ 待ち受けアドレスを 127.0.0.1 に固定する。省略すると全インターフェースで待ち受け、3000番が VM の外から直接叩けてしまう
app.listen(PORT, "127.0.0.1", () => {
  console.log(`listening on http://127.0.0.1:${PORT}`);
});

起動します。

bash
$ node app.js
$ # → listening on http://127.0.0.1:3000

別の端末(もう1つ SSH で入る)から、叩いて確かめます。

bash
$ curl http://127.0.0.1:3000/health
$ # → {"ok":true}

curl を打つ端末と、node app.js を動かす端末は別々にします。 node app.js を打った端末は、サーバーが動いている間ずっと戻ってきません(待ち続けているからです)。止めるときは、その端末で Ctrl + C です。

[スクリーンショット: 01_health確認.png] 片方の端末で node app.js が listening on ... と出ていて、もう片方で curl .../health が {"ok":true} を返している様子を、2つ並べて撮ってください。

確認: {"ok":true} が返れば、骨組みは完成です。ここまでは認証もDBも関係ありません。まず「待ち受けて返す」が動くこと。


③ データを置く — まずは SQLite(ファイル1つ)

メモもユーザーも、プロセスを止めたら消えては困ります。 「プロセスを止めても消えない場所」がデータベースでした(データベースとSQLの回で見たとおりです)。

ここで MySQL や PostgreSQL は入れません。 まずは SQLite を使います。

SQLite は「サーバーを立てないデータベース」です。 MySQL や PostgreSQL は、別にデータベース用のサーバープロセスを起動して、そこへ繋ぎます。SQLite は違います。data.db というファイルが1つできるだけで、それが丸ごとデータベースです。起動も設定もログインも要りません。学習で「まず1本作り切る」には最適です(用途ごとの選び方は SQLiteはおもちゃではない — 用途で選ぶデータベース にまとめました)。

Node.js から SQLite を触るライブラリを入れます。

bash
$ npm install better-sqlite3

better-sqlite3 は C++ で書かれた部分を、入れるときにその場でコンパイルします。 素の Ubuntu Server にはコンパイラが無く、npm install が長いエラーで止まることがあります。先にビルド道具を入れておくと確実です。

bash
$ sudo apt update
$ sudo apt install -y build-essential python3
$ npm install better-sqlite3

db.js を作ります。起動時に、テーブルが無ければ作るだけの、短いファイルです。

// db.js — SQLite の初期化とテーブル作成
const Database = require("better-sqlite3");

const db = new Database("data.db"); // ⚠️ このファイル1つがデータベース本体
db.pragma("journal_mode = WAL");    // 読み書きが少し重なっても壊れにくくする

// テーブルが無ければ作る。あれば何もしない(IF NOT EXISTS)
db.exec(`
  CREATE TABLE IF NOT EXISTS users (
    id       INTEGER PRIMARY KEY AUTOINCREMENT,
    email    TEXT UNIQUE NOT NULL,
    password TEXT NOT NULL
  );

  CREATE TABLE IF NOT EXISTS memos (
    id      INTEGER PRIMARY KEY AUTOINCREMENT,
    user_id INTEGER NOT NULL,
    body    TEXT NOT NULL,
    done    INTEGER NOT NULL DEFAULT 0,
    FOREIGN KEY (user_id) REFERENCES users(id)
  );
`);

module.exports = db;

この設計の意図を、SQL で説明します。

-- users: 1人1行。email は UNIQUE(同じメールで2回登録させない)
-- password: ⚠️ ここに入れるのは平文ではなく「ハッシュ化した文字列」(④でやる)

-- memos: 1メモ1行。⚠️ 大事なのは user_id
--   「このメモは誰のものか」を user_id が持つ。
--   これが無いと「自分のだけ見せる」ができない(⑤の肝)

表と表の関係は、こうなっています。

  users                         memos
  ┌────┬──────────────┐        ┌────┬─────────┬────────────┬──────┐
  │ id │ email        │        │ id │ user_id │ body       │ done │
  ├────┼──────────────┤        ├────┼─────────┼────────────┼──────┤
  │ 1  │ me@...       │◀──────┐│ 1  │    1    │ 牛乳を買う  │  0   │
  │ 2  │ other@...    │       ││ 2  │    1    │ 資料を送る  │  1   │
  └────┴──────────────┘       │└────┴─────────┴────────────┴──────┘
                              └── memos.user_id が users.id を指す
                                  (このメモは誰のものか)

memos に user_id を持たせたことが、あとで効きます。 「このメモは誰のものか」をデータ側に持っておかないと、⑤の「他人のメモは見えない」が作れません。設計の段階で、認可のことまで考えておくわけです。

本物の MySQL / PostgreSQL への置き換えは、今はやりません。 多人数で同時に使う・本番で運用する段階になったら移します。SQL の書き方はほとんど同じなので、そのときに慌てません。まずは SQLite で作り切ります。


④ 認証 — 登録とログイン(パスワードは平文で保存しない)

ここが Backend の肝の1つです。 やることは2つ。

  1. 登録: メールとパスワードを受け取り、パスワードはハッシュ化して保存する
  2. ログイン: メールとパスワードを照合し、合っていたら JWT を発行して返す

まず、必要なライブラリを入れます。

bash
$ npm install bcryptjs jsonwebtoken dotenv
  • bcryptjs … パスワードのハッシュ化。わざと遅いハッシュを使うのが正解です(速いハッシュは使わない — パスワード保存とbcrypt)。純 JavaScript 版なのでコンパイル不要で、素の Ubuntu でもそのまま入ります
  • jsonwebtoken … JWT の発行と検証
  • dotenv … .env ファイルから秘密を読み込む

ここまでで入れたパッケージは、package.json にこう記録されているはずです。 確認しておきます。

bash
$ cat package.json
"dependencies": {
  "better-sqlite3": "...",
  "bcryptjs": "...",
  "dotenv": "...",
  "express": "...",
  "jsonwebtoken": "..."
}

node_modules は .gitignore に入れます(次で書きます)。 中身は巨大で、package.json があれば npm install でいつでも作り直せるからです。「作れるものは持ち歩かない」——バージョン管理の基本です。

秘密は .env に置く(コードにもGitにも書かない)

JWT に署名する鍵を、コードに直接書いてはいけません。 コードは Git に上がり、人の目に触れます。鍵が漏れると、誰でも「私は誰々です」という偽の通行証を作れてしまいます。だから秘密は .env に分けて置き、Git からは除外します。

.env を作ります。

# .env — ⚠️ この値はダミー。本番では自分で長い乱数に置き換える。絶対にコミットしない
JWT_SECRET=change-this-to-a-long-random-string
PORT=3000

change-this-to-a-long-random-string は、見ての通りダミーです。 本物は、こう作った長い乱数に差し替えます。

bash
$ # 32バイトの乱数を16進で出す。この出力を .env の JWT_SECRET に貼る
$ node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"

.gitignore を作って、秘密とデータとライブラリを Git から外します。

node_modules/
.env
data.db
data.db-wal
data.db-shm

.env と data.db を .gitignore に入れるのは必須です。 秘密の鍵と、利用者のデータ(ハッシュ化済みとはいえ)を、うっかり公開リポジトリに上げないためです。

app.js に登録・ログインを足す

app.js の先頭と /health の下に、追記していきます。まず先頭。

// app.js — 先頭
require("dotenv").config(); // ⚠️ 一番上で .env を読み込む
const express = require("express");
const bcrypt = require("bcryptjs");
const jwt = require("jsonwebtoken");
const db = require("./db");

const app = express();
app.use(express.json());

const SECRET = process.env.JWT_SECRET;
if (!SECRET) {
  // ⚠️ 鍵が無いまま起動させない。事故を早い段階で止める
  console.error("JWT_SECRET がありません。.env を確認してください。");
  process.exit(1);
}

登録のエンドポイントです。

// 登録: メールとパスワードでアカウントを作る
app.post("/auth/register", (req, res) => {
  const { email, password } = req.body ?? {};
  if (!email || !password) {
    return res.status(400).json({ error: "email と password は必須です" });
  }

  // ⚠️ 平文では保存しない。bcrypt で「戻せない形」にする
  const hash = bcrypt.hashSync(password, 10);

  try {
    const info = db
      .prepare("INSERT INTO users (email, password) VALUES (?, ?)")
      .run(email, hash);
    return res.status(201).json({ id: info.lastInsertRowid, email });
  } catch (e) {
    // email が UNIQUE なので、同じメールの2回目はここに来る
    return res.status(409).json({ error: "そのメールは登録済みです" });
  }
});

bcrypt.hashSync(password, 10) の 10 は「どれだけ手間をかけてハッシュ化するか」です。 大きいほど、攻撃者が総当たりする時間も伸びます。速いハッシュ(MD5 など)を使わないのは、速いと総当たりも速くなるからでした。

SQL に値を直接埋め込まず、? と .run(email, hash) で渡しています。 これがSQLインジェクション対策の基本です。文字列連結で "... VALUES ('" + email + "')" と書いてはいけません。

ログインのエンドポイントです。

// ログイン: 合っていたら JWT を返す
app.post("/auth/login", (req, res) => {
  const { email, password } = req.body ?? {};
  const user = db.prepare("SELECT * FROM users WHERE email = ?").get(email);

  // ⚠️ 「メールが無い」と「パスワード違い」で応答を分けない。
  //    分けると「このメールは登録されている」と攻撃者に教えてしまう
  if (!user || !bcrypt.compareSync(password, user.password)) {
    return res.status(401).json({ error: "メールかパスワードが違います" });
  }

  // 通行証を発行。sub にユーザーIDを入れ、1時間で失効させる
  const token = jwt.sign({ sub: user.id }, SECRET, { expiresIn: "1h" });
  return res.json({ token });
});

bcrypt.compareSync で照合します。 保存してあるのはハッシュなので、送られてきた平文パスワードを同じ手順でハッシュ化して突き合わせます。保存したハッシュを元のパスワードに戻すことはできません(それが正しい)。

返ってくる JWT の中身

ログインで返る token は、ただの長い文字列に見えます。 でも中身は、. で3つに区切られた、意味のあるデータです。

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9  .  eyJzdWIiOjEsImlhdCI6MTcy...  .  署名(改ざん検知)
└──────────── ヘッダ ────────────┘     └──────── 中身(誰か等) ──────┘  └── SECRET で作った印 ──┘

中身(真ん中)は暗号化されていません。 Base64 という「読める形」に変換されているだけで、誰でも中を見られます。だから、パスワードなど秘密を JWT に入れてはいけません。 ここに入れるのは「誰か(sub)」くらいです。

では、なぜ偽造できないのか。 それが3つ目の署名です。SECRET(.env の鍵)を使って作った印で、鍵を持っていない人は、中身を書き換えても正しい署名を作り直せません。 だから jwt.verify(token, SECRET) は、改ざんされたトークンや、別の鍵で作られた偽トークンを弾けます。鍵さえ漏らさなければ、なりすませない——これが JWT の肝です。

動かして確かめます。 node app.js で起動し、別端末から:

bash
$ # 登録
$ curl -X POST http://127.0.0.1:3000/auth/register \
    -H "Content-Type: application/json" \
    -d '{"email":"me@example.com","password":"pass1234"}'
$ # → {"id":1,"email":"me@example.com"}

$ # ログイン
$ curl -X POST http://127.0.0.1:3000/auth/login \
    -H "Content-Type: application/json" \
    -d '{"email":"me@example.com","password":"pass1234"}'
$ # → {"token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOjEsImlhdCI6..."}

確認: ログインでトークンが返れば成功です。わざと違うパスワードで叩いて、401 が返ることも確かめてください。 「成功のときだけ確認して終わり」にしないのが、Backend のクセです。


⑤ 認可 — 自分のものだけ(他人のメモは見えない)

ここが「認証と認可は別」を体で理解するところです。

ログインでトークンをもらえた——これは認証(あなたが誰か分かった)です。でも、「ログインした人なら誰のメモでも見ていい」わけではありません。 「あなたは自分のメモだけ触ってよい」を守るのが認可です。

認証 (Authentication) … あなたは誰か?        → ログイン。JWT で示す
認可 (Authorization)  … あなたはこれをしてよいか? → その JWT の持ち主のメモだけ触らせる

  ┌─────────────┐   ┌─────────────────┐   ┌───────────────────────┐
  │ トークン無し │ → │ 401 未認証       │   (そもそも誰か分からない)
  └─────────────┘   └─────────────────┘
  ┌─────────────┐   ┌─────────────────┐   ┌───────────────────────┐
  │ 有効なトークン│ → │ 認証OK(誰か判明)│ → │ 自分のメモ = 見える/触れる │
  │  (ユーザーA) │   └─────────────────┘   │ 他人のメモ = 存在しない扱い │
  └─────────────┘                         └───────────────────────┘

多くの事故は「認証はした、でも認可を忘れた」で起きます。 「ログインできたか」だけ確かめて満足すると、ログインさえすれば他人のデータが全部見えるAPI ができあがります。この記事では、その一歩先まで必ず確かめます。

トークンを検証するミドルウェア

各メモ操作の手前に、共通で「トークンを見る」処理を挟みます。 これがミドルウェアです。app.js に足します。

// これより下のエンドポイントは、全部この関数を通す = 要ログイン
function auth(req, res, next) {
  const header = req.headers.authorization ?? "";
  const token = header.startsWith("Bearer ") ? header.slice(7) : null;
  if (!token) {
    return res.status(401).json({ error: "トークンがありません" });
  }
  try {
    const payload = jwt.verify(token, SECRET); // ⚠️ 署名を検証。偽物はここで弾かれる
    req.userId = payload.sub; // ⚠️ 「誰か」はトークンから取る。本文のIDは信じない
    next(); // 検証OK。本来の処理へ進む
  } catch {
    return res.status(401).json({ error: "トークンが無効か期限切れです" });
  }
}

req.userId = payload.sub が、この記事でいちばん大事な1行です。 「あなたは誰か」を、トークンの中身から取り出してサーバーが決めます。リクエストの本文(body)に書かれた user_id は、絶対に信じません。 そこを信じると、{"user_id": 2} と書くだけで他人になりすませてしまいます。

メモの一覧(自分のものだけ)

// メモ一覧: ⚠️ WHERE user_id = ? で「自分のだけ」に絞る
app.get("/memos", auth, (req, res) => {
  const rows = db
    .prepare("SELECT id, body, done FROM memos WHERE user_id = ? ORDER BY id DESC")
    .all(req.userId);
  res.json(rows);
});

WHERE user_id = ? に req.userId を渡しているのが認可の実体です。 SQL の段階で、他人の行はそもそも取ってきません。「全部取ってきてから、画面で隠す」ではありません。元から返さないのが正しいやり方です。

「他人のは見えない」を実演する

ここで一度、認可が効いているか確かめます。 2人目を登録してログインし、その人のトークンで一覧を叩いても、1人目のメモは1件も出ないことを見ます。

bash
$ # 2人目を登録してログイン
$ curl -X POST http://127.0.0.1:3000/auth/register \
    -H "Content-Type: application/json" \
    -d '{"email":"other@example.com","password":"pass5678"}'

$ curl -X POST http://127.0.0.1:3000/auth/login \
    -H "Content-Type: application/json" \
    -d '{"email":"other@example.com","password":"pass5678"}'
$ # → 2人目のトークンが返る

$ # 2人目のトークンで一覧を叩く
$ curl http://127.0.0.1:3000/memos \
    -H "Authorization: Bearer <2人目のトークン>"
$ # → []   ⚠️ 1人目のメモは1件も出ない。これが認可

トークンをまったく付けずに叩くと 401、他人として叩いても他人のは見えない。 この2つが確認できたら、認証と認可が両方効いています。

[スクリーンショット: 02_他人のメモは見えない.png] 1人目が作ったメモがある状態で、2人目のトークンで /memos を叩いたら [](空)が返っている様子を撮ってください。「ログインはできても他人のは見えない」が一目で分かります。

トークンを毎回コピペするのが面倒でも、jq などを勝手に前提にしません。 素の Ubuntu には jq が入っていないことが多いので、ここでは返ってきたトークン文字列を手でコピーして貼るやり方で通しています。


⑥ REST らしく — CRUD を揃え、ステータスコードを正しく返す

メモの残り3操作(作成・更新・削除)を足します。 URL に動詞を入れません(URLに動詞を入れない — REST APIの設計)。/createMemo ではなく、POST /memos。「何を」がパス、「どうするか」がメソッドです。

やりたいことメソッドとパス成功時のコード
一覧を読むGET /memos200
1件作るPOST /memos201(作成された)
1件書き換えるPATCH /memos/:id200
1件消すDELETE /memos/:id204(成功・中身なし)
// 作成
app.post("/memos", auth, (req, res) => {
  const { body } = req.body ?? {};
  if (!body || body.trim() === "") {
    return res.status(400).json({ error: "body は必須です" });
  }
  const info = db
    .prepare("INSERT INTO memos (user_id, body, done) VALUES (?, ?, 0)")
    .run(req.userId, body.trim());
  res.status(201).json({ id: info.lastInsertRowid, body: body.trim(), done: 0 });
});

// 更新(完了の切り替えや本文の修正)
app.patch("/memos/:id", auth, (req, res) => {
  const id = Number(req.params.id);
  // ⚠️ 取ってくる時点で AND user_id = ? を付ける。これが「他人のは触れない」
  const memo = db
    .prepare("SELECT * FROM memos WHERE id = ? AND user_id = ?")
    .get(id, req.userId);
  if (!memo) return res.status(404).json({ error: "見つかりません" });

  const body = req.body?.body ?? memo.body;
  const done = req.body?.done ?? memo.done;
  db.prepare("UPDATE memos SET body = ?, done = ? WHERE id = ? AND user_id = ?")
    .run(body, done ? 1 : 0, id, req.userId);
  res.json({ id, body, done: done ? 1 : 0 });
});

// 削除
app.delete("/memos/:id", auth, (req, res) => {
  const id = Number(req.params.id);
  const info = db
    .prepare("DELETE FROM memos WHERE id = ? AND user_id = ?")
    .run(id, req.userId);
  if (info.changes === 0) return res.status(404).json({ error: "見つかりません" });
  res.status(204).end(); // 中身なしの成功
});

更新も削除も、WHERE ... AND user_id = ? を必ず付けます。 ここを忘れると、PATCH /memos/1 で他人のメモ1番を書き換えられてしまいます。他人のIDを指定したときは、403(禁止)ではなく 404(無い)を返すのがこの実装の選択です。「あなたには、そのメモは存在しない」という扱いにすると、「そのIDのメモは実在する」という情報すら渡さないで済みます。

ステータスコードを揃える理由。 「動く」だけなら全部 200 でも動きます。 でも、作成は 201、削除は 204、入力ミスは 400、未ログインは 401、無いものは 404——と分けておくと、この API を叩く側(あとで繋ぐ画面)が、中身を読まずに成否を判断できます。 これが「使えるAPI」と「動くだけのAPI」の差です。

ひととおり curl で回します。

bash
$ # 作成 → 一覧 → 完了に更新 → 削除
$ curl -X POST http://127.0.0.1:3000/memos \
    -H "Authorization: Bearer <トークン>" \
    -H "Content-Type: application/json" \
    -d '{"body":"牛乳を買う"}'

$ curl http://127.0.0.1:3000/memos -H "Authorization: Bearer <トークン>"

$ curl -X PATCH http://127.0.0.1:3000/memos/1 \
    -H "Authorization: Bearer <トークン>" \
    -H "Content-Type: application/json" \
    -d '{"done":true}'

$ curl -i -X DELETE http://127.0.0.1:3000/memos/1 \
    -H "Authorization: Bearer <トークン>"
$ # → HTTP/1.1 204 No Content

curl -i を付けると、ステータスコードを含む応答ヘッダも表示されます。 204 が返っているか確かめるときに使います。

想定外にも、落ちずに答える

最後に、2つの「取りこぼし」を塞ぎます。 どちらも app.listen(...) の直前、全エンドポイントの下に置きます。順番が大事です。

// どのエンドポイントにも当たらなかったとき(例: GET /unknown)
app.use((req, res) => {
  res.status(404).json({ error: "そのエンドポイントはありません" });
});

// エンドポイントの中で例外が投げられたとき(想定外のエラー)
app.use((err, req, res, next) => {
  console.error(err); // ⚠️ 中身はログにだけ出す。利用者には返さない
  res.status(500).json({ error: "サーバー側でエラーが発生しました" });
});

この2つが無いと、知らないURLを叩かれたときに Express 既定の HTML が返り、例外が起きたときはプロセスごと巻き込まれかねません。 エラーの中身(スタックトレース)を利用者に返さないのも大事です。 どのファイルのどの行で落ちたかは、攻撃の手がかりになります。詳細はログへ、利用者には短い一言だけ——この線引きを最初から入れておきます。

ここまでで、API 本体は完成です。 残るは山場——動かし続けることです。


⑦ 動かし続ける(常駐=デプロイ)

ここが、この記事のいちばんの山です。 API は完成しました。でも——

node app.js を手で起動しただけのものは、まだ「動いている」とは言えません。

理由は2つ。

  1. SSH を切ると止まります。 node app.js は、あなたがログインしている端末(ターミナル)にぶら下がって動いています。ログアウトすると、道連れで殺されます。試しに、node app.js した SSH を閉じて、別のSSHから curl .../health を叩いてみてください。繋がりません。
  2. 落ちたら、二度と起きません。 何かのエラーでプロセスが死んだら、それきりです。VM を再起動しても、自動では立ち上がりません。

「動いている」とは、start ではなく enable された状態でした(startとenableは別物 — サーバーが「動いている」とは何か)。これを解決するのが systemd です。

まず、node の場所を確かめる

systemd には、node のフルパスを書きます。

bash
$ which node
$ # → 例: /usr/bin/node  (環境によって違う。出た通りに次で使う)
$ whoami
$ # → 例: ubuntu  (このユーザー名も次で使う)

which node の結果は環境で違います。 /usr/bin/node とは限りません。自分の環境で出た通りに、次のユニットファイルへ書きます。

systemd のユニットを書く

ユニットファイルを作ります。パスに sudo が要ります。

bash
$ sudo nano /etc/systemd/system/memo-api.service

中身です。User・WorkingDirectory・ExecStart を、自分の環境に合わせて直します。

[Unit]
Description=Memo API
After=network.target

[Service]
Type=simple
User=ubuntu
WorkingDirectory=/home/ubuntu/memo-api
ExecStart=/usr/bin/node /home/ubuntu/memo-api/app.js
Restart=on-failure
RestartSec=3
Environment=NODE_ENV=production

[Install]
WantedBy=multi-user.target
  • WorkingDirectory … ここを memo-api にしておくと、dotenv が .env を、better-sqlite3 が data.db を、正しくこのフォルダから見つけます
  • Restart=on-failure … 落ちたら自動で起き直す。RestartSec=3 で3秒後に再起動
  • ExecStart … node はフルパスで。systemd は PATH を当てにできないため

登録して、起動して、自動起動を有効にする

bash
$ sudo systemctl daemon-reload          # ユニットの追加を systemd に知らせる
$ sudo systemctl enable --now memo-api  # ⚠️ enable(自動起動) と start(今すぐ起動) を同時に
$ sudo systemctl status memo-api        # 状態を見る。active (running) なら成功

enable --now の --now を忘れると、「次回の再起動から有効」なだけで、今は起動しません。 enable(VM再起動後も自動で上がる)と start(今すぐ上げる)は別物でした。両方を1つで済ませるのが --now です。

ここで、①の壁を越えたか確かめます。

bash
$ # app.js を手で起動していた端末があれば、Ctrl+C で止めておく(systemd と二重起動しない)
$ curl http://127.0.0.1:3000/health
$ # → {"ok":true}

$ # ⚠️ そして SSH を全部切って、入り直して、もう一度叩く
$ curl http://127.0.0.1:3000/health
$ # → {"ok":true}   ← SSH を切っても生きている!

SSH を切って入り直しても {"ok":true} が返る——これが、node app.js では超えられなかった壁です。いま初めて「動き続けている」と言えます。

[スクリーンショット: 03_systemd常駐.png] sudo systemctl status memo-api が active (running) になっている様子を撮ってください。SSH を切って入り直したあとの curl .../health の成功も、同じ画面か続けて撮れると、常駐できたことが伝わります。

ログを見る — 手で起動していたときの console.log はどこへ行ったか

手で node app.js していたときは、console.log が画面に出ていました。 systemd で常駐させると、その出力は画面に出ません。消えたのではなく、systemd のログ(journal)に流れています。 見るコマンドはこれです。

bash
$ sudo systemctl status memo-api        # 直近の数行と状態
$ sudo journalctl -u memo-api -n 50     # このサービスのログを直近50行
$ sudo journalctl -u memo-api -f        # 流れるログをリアルタイムで追う(Ctrl+C で抜ける)

起動に失敗したときは、まずここを見ます。 「active (running) にならない」「すぐ落ちる」ときの原因(鍵が無い、node のパス違い、ポートの取り合い)は、ほぼ journalctl に書いてあります。エラーは下から読む——ログの一番下の行が、いちばん新しい失敗です。

nginx で80番から繋ぐ

いまの API は 127.0.0.1:3000 でしか受けていません。 これは「VM の中からしか叩けない」という意味です。VM の外(同じネットワークの別PC)から、ポート番号を意識せず http://<VMのIP>/ で叩けるようにします。表で受けて裏へ流す係が nginx です(ポート番号を隠す — nginxのリバースプロキシ)。

bash
$ sudo apt update
$ sudo apt install -y nginx

設定ファイルを作ります。

bash
$ sudo nano /etc/nginx/sites-available/memo-api
server {
    listen 80;
    server_name _;

    location / {
        proxy_pass http://127.0.0.1:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

proxy_pass http://127.0.0.1:3000; が要です。 nginx が80番で受けた通信を、そのまま裏で動いている Node.js(3000番)へ流します。外からは3000番の存在が見えません。

有効にして、設定を検査してから、読み込み直します。

bash
$ sudo ln -s /etc/nginx/sites-available/memo-api /etc/nginx/sites-enabled/
$ sudo rm -f /etc/nginx/sites-enabled/default   # 既定のページを外す
$ sudo nginx -t                                 # ⚠️ 先に構文チェック。OK なら次へ
$ sudo systemctl reload nginx

sudo nginx -t を必ず先に打ちます。 設定を間違えたまま reload すると、nginx が起動しなくなることがあります。test is successful を見てから reload します。

VM の外(同じネットワークの Windows 本体など)から叩きます。

bash
$ # <VMのIP> は VM の中で `ip a` で確認したアドレス
$ curl http://<VMのIP>/health
$ # → {"ok":true}   ← VM の外から、80番で、ポート番号なしで届いた

これで「自分のVMの外から叩けるAPI」になりました。 ここが到達点です。

外に公開する場合の1行の注意

もしこの VM をインターネットに直接さらすなら、ファイアウォールで必要なポート(80、SSHの22)だけを開け、それ以外は閉じます。 学習の間は、VM を自分のネットワークの中だけに置くのが安全です。


手元のVMで常駐まで通ったら、同じ手順をインターネットに面したサーバーで繰り返すと、「SSHを切っても動き続ける」の意味がもう一段はっきりします。たとえばさくらのVPSは初期費用無料の定額制で、クレジットカード払いなら全プラン2週間無料で試せます(1GB・2コア・50GB の月払いは 880〜990円でリージョンにより異なる、税込、2026-11 時点)。最低利用期間は3ヶ月で、お試し期間中は外向き通信が10Mbpsに制限され、解約しないと自動で本登録になるので、試すだけなら期限を控えておいてください。

⑧ 完成の判定 — 自分で「できた」と言えるように

「なんとなく動く」で終わらせません。 この6つを自分で通したら、完成です。

□ 登録できる(POST /auth/register が 201 を返す)
□ ログインで JWT が返る(POST /auth/login が token を返す)
□ トークンを付けると、自分のメモを作成・一覧・更新・削除できる
□ 他人のトークンでは、自分のメモが見えない(一覧が [] になる)
□ SSH を切って入り直しても、API が生きている(systemd で常駐)
□ VM を再起動しても、API が自動で起き上がる

最後のチェックは、実際に VM を再起動して確かめます。

bash
$ sudo reboot
$ # 再起動を待って、入り直したら
$ curl http://127.0.0.1:3000/health
$ # → {"ok":true}   ← enable してあるので、自動で上がっている

判定を1本のスクリプトにする

毎回 curl を手で打つのは面倒です。 何度も打つコマンドは、スクリプトにまとめます。check.sh を作ります。

bash
#!/usr/bin/env bash
  # check.sh — API がひととおり動くかを一気に確かめる
  set -e
  BASE="http://127.0.0.1:3000"

  echo "1) health"
  curl -s "$BASE/health"; echo

  echo "2) 登録(2回目は409でも気にしない)"
  curl -s -X POST "$BASE/auth/register" \
    -H "Content-Type: application/json" \
    -d '{"email":"me@example.com","password":"pass1234"}'; echo

  echo "3) ログイン → トークンを取り出す"
  TOKEN=$(curl -s -X POST "$BASE/auth/login" \
    -H "Content-Type: application/json" \
    -d '{"email":"me@example.com","password":"pass1234"}' \
    | sed -E 's/.*"token":"([^"]+)".*/\1/')
  echo "token(先頭20文字): ${TOKEN:0:20}..."

  echo "4) メモ作成 → 一覧"
  curl -s -X POST "$BASE/memos" \
    -H "Authorization: Bearer $TOKEN" \
    -H "Content-Type: application/json" \
    -d '{"body":"スクリプトから作った"}'; echo
  curl -s "$BASE/memos" -H "Authorization: Bearer $TOKEN"; echo

  echo "5) トークン無し → 401 のはず"
  curl -s -o /dev/null -w "%{http_code}\n" "$BASE/memos"

実行します。

bash
$ chmod +x check.sh
$ ./check.sh

ここでは jq を使わず、sed でトークンを取り出しています。 素の Ubuntu に無いものを前提にしないためです。最後の行が 401 を返せば、「トークン無しは弾かれる」も確かめられています。

1つでも通らなかったら、それがこのコースの「まだ手が届いていない場所」です。 そこだけ、対応する回に戻ればいい。この判定リストが、「読んだ」を「作り切れた」に変えます。


つまずいたところ

node app.js した SSH を閉じたら、API が止まった。 手で起動したプロセスは、ログイン端末にぶら下がっています。切れば道連れで死にます。systemd で常駐させて解決しました。この記事の山場そのものです。

better-sqlite3 の npm install が、長いエラーで止まった。 素の Ubuntu にコンパイラが無いためでした。sudo apt install -y build-essential python3 を先に入れたら通りました。「自分の環境に入っていた前提」で書かないための、いい例でした。

systemd で起動したら、起動直後に落ちて再起動を繰り返した。 最初 WorkingDirectory を書いていませんでした。systemd はルート(/)から起動するので、better-sqlite3 が /data.db を作ろうとして、User=ubuntu には / へ書く権限が無いため失敗していました。WorkingDirectory=/home/ubuntu/memo-api を書いて解決。.env が読めない問題も、同じ原因でした。

ExecStart=node ... と書いたら、起動に失敗した。 systemd は PATH を当てにできず、node を見つけられませんでした。which node で出たフルパス(/usr/bin/node)に直したら起きました。

本文に user_id を書いたら、他人になりすませてしまった(設計中に気づいた)。 「誰か」を body から取ってはいけません。トークンの中身(req.userId)から取る——この一方通行を徹底したら、なりすましの余地が消えました。

削除で他人のメモが消せてしまった。 最初 DELETE FROM memos WHERE id = ? としていて、user_id の条件を忘れていました。AND user_id = ? を足して、他人のIDでは 404 を返すようにして解決。

nginx を入れたのに、外から繋がらなかった。 sites-enabled の default が残っていて、そちらが先に80番を受けていました。default を外し、nginx -t で検査してから reload したら通りました。

ログインで、正しいパスワードなのに通らなかった。 実際は bcrypt.compareSync の引数の順(平文, ハッシュ)を逆にしていて、常に false を返していました。「成功のときだけ」でなく「失敗のときも」確かめると、この手の取り違えに気づけます。

メモを作ったのに、一覧に出ないことがあった。 POST /memos に Content-Type: application/json を付け忘れていて、req.body が空になっていました。express.json() は、Content-Type が JSON のときだけ本文を解釈します。 curl の -d を使うときは、ヘッダをセットで付けるのを癖にします。

3000番が、VM の外からも直接叩けていた。 最初は app.listen(PORT, ...) と待ち受けアドレスを省略して書いていて、Node.js はアドレスを省略すると全インターフェース(:: / 0.0.0.0)で待ち受けます。 この記事の app.js は app.listen(PORT, "127.0.0.1", ...) として3000番を VM の中に閉じてあります。nginx は同じ VM の中から 127.0.0.1:3000 へ流すので、これで外から繋がらなくなることはなく、外向けの口は nginx(80番)だけで足ります。Node.js を直接外に晒さない、という形に落ち着きました。


後片づけ

このAPIは常駐しています。 学習が一段落して止めたいときは、こうします。

bash
$ sudo systemctl stop memo-api      # 今すぐ止める
$ sudo systemctl disable memo-api   # ⚠️ 次回起動時の自動起動も無効にする

stop だけだと、VM を再起動したらまた勝手に上がります。 enable した自動起動を消すには disable が要ります。start/enable が別だったのと同じで、stop/disable も別です。

完全に片づけるときは、nginx の設定リンクを外し、プロジェクトのフォルダごと消します。

bash
$ sudo rm -f /etc/nginx/sites-enabled/memo-api
$ sudo systemctl reload nginx
$ sudo rm -f /etc/systemd/system/memo-api.service
$ sudo systemctl daemon-reload
$ rm -rf ~/memo-api                 # data.db(利用者データ)も消える。要確認

data.db を消すと、登録したユーザーもメモも全部消えます。 残しておきたいなら、フォルダごとバックアップしてから消します。


まとめ — 理解できたこと

  • 「読んで分かる」と「1本を作り切る」は別物だった。埋めたのは、端から端まで動く1本
  • 作らないものリストを先に書く。 機能を絞らないと、1つも完成しないまま力尽きる
  • まず /health が返るだけの骨組みを動かす。 ここが動かないと、この先は全部無意味
  • 学習の最初のDBは SQLite。 ファイル1つ・サーバー不要で、「まず作り切る」に集中できる
  • パスワードは平文で保存しない。 わざと遅い bcrypt でハッシュ化する
  • 秘密(JWTの鍵)はコードにもGitにも書かない。 .env に置き、.gitignore で外す
  • 認証(あなたは誰か)と認可(あなたはこれに触ってよいか)は別。 ログインできても他人のは見えない
  • 「誰か」はトークンから取る。 リクエストの本文に書かれたIDは信じない
  • SQL は必ず WHERE ... AND user_id = ?。 これが「自分のだけ」の実体
  • URL に動詞を入れない。 POST /memos。ステータスコード(201/204/400/401/404)を揃える
  • node app.js を手で起動しただけは「動いている」ではない。 SSH を切れば止まる
  • systemd で常駐(enable --now)させ、落ちたら自動再起動。 ここまでで初めて「動き続ける」
  • nginx のリバースプロキシで80番から繋ぐ。 VM の外から、ポート番号なしで叩ける形になる
  • 完成の判定を自分で持つ。 SSH を切っても生きているか、再起動後も自動で上がるかまで確かめる

そして、次にやること

この作品は、2つの方向へ育てられます。

  1. DBを本物にする。 SQLite は1ファイルで学習向きです。多人数・本番になったら、MySQL / PostgreSQL へ移します(用途で選ぶデータベース)。SQL の書き方はほとんど同じなので、慌てません
  2. 画面を繋ぐ。 この API には画面がありません。ここに Frontend の到達作品や React の画面をつなぐと、「作品」になります。API と画面を別々に作って繋ぐ進め方は 全部書いてから動かさない — 作品のAPIと認証 にまとめました

あなたはもう、「動くAPI」ではなく「動き続けるAPI」を、自分の手で1本作り切りました。 ——これが Backend コースの到達点です。


参考リンク


次に読む

この記事は 【第5段階】バックエンドとデータベース の 29 / 29 本目です。

記事
← 前の記事GitとGitHubは別物 — VMのコードを初めて上げる
→ 次の記事nginxを入れたのに繋がらない — Webサーバーの導入

上から順に読めば積み上がるように並べています。 飛ばしても構いませんが、詰まったら前の回に戻ってください。

全体の順路は はじめに にあります。

roadmap.sh のどこをやっているか

Backend コースの到達作品です。 特定の roadmap.sh 項目ではなく、サーバー・API・認証・DB・常駐までを1つの動くAPIに束ねます。

よかったらシェアしてね!
  • URLをコピーしました!
  • URLをコピーしました!

コメント

コメントする

目次