pushだけで反映まで終わる — DevOpsの到達作品

DevOpsの到達作品。コードのカードとテストのチェックリスト、サーバーと切り戻しの矢印。

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

pushしたらテストが走り、サーバーに反映されるところまでを1本につなぐ演習です。手作業のデプロイをやめます。

前回: ログが3箇所に散っている — Lokiで1画面にする

これは DevOps コースの「到達作品」の回です。 新しい知識はほとんど出てきません。これまでの pushしてもVMには届かない — GitHub ActionsとCI/CD・startとenableは別物 — サーバーが「動いている」とは何か・.envは暗号化してGitに置ける — SOPSとage を、1つの動くパイプラインに束ねる回です。CI/CD の考え方そのものは前回までにやったので、ここではそれを最後まで1本の線につなぐことに集中します。

この記事は、GitHub(Windowsのブラウザ)と、デプロイ先のVM(Ubuntu)の両方を使います。どちらで打つかを毎回明示します。 ワークフローの結果を見たり、ボタンを押したり、ブランチの設定をするのは Windows本体のブラウザです。テストを書いたり、セルフホストランナーを動かしたり、git push するのは VMの中(Ubuntu Server)のシェルです。混ざると詰まるので、各手順の先頭に「どこで」を書きます。


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

目次

めがける作品

このコースを終えたら、これが動いている。 ——そう言い切れる1本の「線」を、ここで完成させます。

作るのは アプリではありません。 これまで作ってきた ~/server(タスクのAPI)を題材に、「push したら、あとは機械が最後までやる」パイプラインを作ります。

めがけるのは、この4つが1本につながった状態です。

  1. main に push する(Windowsのブラウザで PR をマージする、が実体)
  2. GitHub Actions がテストを走らせる(CI)
  3. テストが通ったときだけ、自分のVMへ自動でデプロイする(CD)
  4. デプロイが失敗したら、止まって、前のバージョンへ戻る(ロールバック)

完成すると、こういう流れになります。 先に全体像を見ておきます。

  ┌──────────────┐   push /   ┌───────────────────────────────────────────┐
  │  あなた       │  マージ    │              GitHub                        │
  │ (PRをマージ) │ ─────────▶ │                                            │
  └──────────────┘            │  ┌─────────────┐   通ったら   ┌──────────┐ │
                              │  │ test (CI)   │ ──────────▶ │ deploy   │ │
                              │  │ ubuntu-     │   needs:    │ (CD)     │ │
                              │  │ latest      │   test で    │ self-    │ │
                              │  └─────────────┘   ゲート     │ hosted   │ │
                              │        │                     └────┬─────┘ │
                              │      赤なら                       │        │
                              │      ここで止まる                  │取りに来る│
                              └───────────────────────────────────┼────────┘
                                                                  │
                                            ┌─────────────────────▼───────────┐
                                            │  あなたのVM (Ubuntu / NATの内側)  │
                                            │  git pull → npm ci → migrate     │
                                            │  → systemctl restart → health    │
                                            │  失敗したら前のコミットへ戻す      │
                                            └──────────────────────────────────┘

左上から時計回りに1本です。 あなたがやるのは左上の「マージ」だけ。残りは全部、機械が順番どおりにやります。

この記事の肝は、真ん中の needs: test という矢印です。 テスト(CI)が緑にならない限り、デプロイ(CD)は始まりもしません。 これが「壊れたコードを、より速く本番へ届ける装置」にしないための安全弁です。前回の CI/CD の回では、デプロイは手で押すボタン(継続的デリバリー)にしておきました。今回は、テストと戻す仕組みが揃ったので、一歩進めて自動にします(継続的デプロイ)。ただし、後で見るようにいくつも安全装置を付けてからです。

そして、右下のVMは、インターネットから見えない NAT の内側にいます。 だから「GitHub からVMへ ssh して届ける」は成立しません。VMの側から GitHub へ仕事を取りに行く(セルフホストランナー)——ここが、世の中の自動デプロイ記事とこの記事がいちばん違うところです。

この記事でわかること

  • 手作業デプロイの本当の問題は「面倒」ではなく「毎回ぶれる・忘れる・深夜に事故る」こと。CI/CD は人がやっていた手順を、機械に決まった通りやらせることだと分かる
  • CD を安全にするのは自動化そのものではなく、その周りの安全装置だということ。テストを通過ゲート(needs)にする / ヘルスチェックで確かめる / 失敗したら戻す / mainに直接pushしないの4つが本体
  • 「戻せること」を先に作ってから自動化すること。戻せない自動デプロイは、事故を速く確実に起こす装置になる
  • 秘密(SSH鍵・トークン・DBのパスワード)は Git にもコードにも書かず、GitHub Secrets とVM側の .env に分けること。本番と検証で値を分けること
  • 「読んで分かった」DevOps の部品が、1本のパイプラインとしてつながって初めて「使える」になること

この記事でやること

  1. 手作業デプロイの手順を、いったん全部紙に書き出す。機械にやらせる前に、何を自動化するのかをはっきりさせる
  2. 1つのワークフローに test と deploy の2つのジョブを書き、deploy に needs: test を付けて「テストが緑のときだけデプロイ」にする
  3. CI で「手元では通るのにCIで落ちる」を1回わざと起こして直す(環境差の実演)
  4. CD を自分のVMへ自動で流す。セルフホストランナーで受け、git pull → npm ci → migrate → restart を機械にやらせる
  5. ヘルスチェックと if: failure() で「失敗したら前へ戻す」を組み込み、わざと壊して戻ることを確かめる
  6. 秘密と環境を分ける。Secrets の使いどころと、本番・検証の値の分け方を決める
  7. 完成のチェックリストを自分で通す

先に知る言葉

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

言葉意味
パイプラインpush から反映までの一連の流れを1本につないだもの。この記事で作る「線」そのもの
CIContinuous Integration。変更を合流させるたびに、自動でテストして確かめること
CDContinuous Delivery / Deployment。確かめたものを自動で配ること。今回は配るところまで自動にする
ジョブ / ステップワークフローの中身。ジョブが実行のかたまり(test と deploy)、ステップがその中の1コマンド
needsあるジョブが終わって成功したら、次のジョブを始めるという依存の指定。これがテストの通過ゲート
ランナーワークフローを実際に実行するマシン。GitHubが貸すものと、自分のVM(セルフホスト)がある
セルフホストランナー自分のVMを、GitHubの実行係として登録したもの。NATの内側でも、VMから取りに行くので成立する
ヘルスチェック再起動のあと、「本当に上がったか」をURLを叩いて確かめること。ここでは /health を叩く
ロールバック前の正常だったバージョンへ戻すこと。デプロイが失敗したときの命綱
SecretsGitHubに預ける秘密の値。ワークフローの中から ${{ secrets.名前 }} で呼び出せる

① 手作業デプロイの何が問題か

まず、機械にやらせる前に、いま「手でやっている手順」を全部書き出します。 これをやらないと、何を自動化するのかが曖昧なまま自動化してしまいます。

~/server を更新するとき、VMの中でやっていたのは、だいたいこれです。

(VMの中で、毎回手でやっていたこと)
1. ssh でVMに入る
2. cd ~/server
3. git pull
4. npm ci          (依存が変わっていれば)
5. マイグレーションを流す(DBの構造が変わっていれば)
6. sudo systemctl restart myserver
7. curl で /health を叩いて、上がったか確かめる(……たまに忘れる)

書き出すと、たった7行です。 「これくらい手でいい」と思えます。問題は、手順の数ではありません。

本当の問題は、この4つです。

問題何が起きるか
忘れる「今日は依存もマイグレーションも無いだろう」と npm ci を飛ばして、Cannot find module で落ちる
人によってぶれる別の人(未来の自分)は git pull の代わりに git fetch && git reset --hard を使う。手順が2種類できる
順番を間違えるマイグレーションの前に再起動して、古いコードが新しいDBを見て落ちる(あるいは逆)
深夜に事故る眠い・急いでいる・確認を飛ばす。手作業がいちばん危ないのは、疲れているとき

具体的に、手作業がどう事故るか。 よくあるのは、こういう連鎖です。

  金曜の夜、急いでデプロイ:
    git pull   → OK
    (npm ci を飛ばす。「今日は依存いじってないから」)
    restart    → 起動する
    (/health は確認しない。「見た目は動いてるし」)
  ────────────────────────────────────
  → 実は依存を1つ足していた。restart は成功。
    でも新しいコードが読む module が無くて、
    最初のリクエストで 500。気づくのは月曜の朝。

どのステップも「うっかり飛ばせる」のが、手作業の弱点です。 そして飛ばしても、その場では動いて見えることがある。壊れるのは、あとから来た本物のリクエストです。

CI/CD とは、この7行を「機械に、毎回、まったく同じ順番で、確認まで含めてやらせる」ことです。 速くするためではありません。ぶれと、忘れと、深夜の事故を無くすためです(このあたりの考え方は pushしてもVMには届かない — GitHub ActionsとCI/CD で最初に扱いました)。機械は、飛ばしません。 npm ci も、ヘルスチェックも、毎回必ず通ります。

だから、自動化する前に手順を紙に書くのが正しい順番です。 「なんとなく手でやっていたこと」を言葉にすると、そのまま deploy.yml の steps: になります。 頭の中にある手順は自動化できません。書き出したものだけが自動化できます。

この記事は、上の7行を、こういう役割分担にします。

  手順1〜2 (ssh して cd) → もう要らない。GitHubが自動でVMのランナーに渡す
  手順3〜6 (pull〜restart)→ deploy.yml の steps に、順番どおり書く
  手順7   (/health を確認)→ deploy.yml の中で curl -f。落ちたら自動で戻す
  + 手順の前に            → テストが緑か(CI)を、機械が先に確かめる

② リポジトリとワークフロー — 1ファイルに2つの仕事を入れる

GitHub Actions は、リポジトリの中の .github/workflows/ に置いた YAML ファイルを見て動きます。 管理画面のスイッチではありません。「いつ・何をするか」が、コードと一緒に履歴に残る——これが手作業との最初の違いです。

前回までに、テストだけを走らせる ci.yml を1本置いてありました。今回は、そこに「デプロイ」という2つ目の仕事を足して、1本のパイプラインにします。

まず、いまあるものをVMの中で確認します。

bash
$ # VMの中で
$ ls -a ~/server/.github/workflows/
$ cat ~/server/.github/workflows/ci.yml

ワークフローの骨格は、この3つです。 ここは前回の復習です。

書くもの意味
on:いつ動くか。push / pull_request / workflow_dispatch(手動ボタン)など
jobs:やることのかたまり。今回はこの下に test と deploy の2つを並べる
steps:ジョブの中で、上から順に実行される1コマンドずつ

on: の「いつ」は、この記事の設計そのものです。 何を引き金にするかで、パイプラインの性格が決まります。

引き金いつ動くかこの記事での使い方
pushブランチに push されたときmain への push で、test と deploy が動く(マージ = main への push)
pull_requestPRが作られた・更新されたときtest だけを走らせる。マージ前に緑を確かめるため
workflow_dispatch画面のボタンで手動起動今回は使わないが、「押すデプロイ」に戻したいときの引き金

push と pull_request の両方を書くと、PRを更新するたびに test が走り、マージ(=main への push)でもう一度 test が走ってから deploy に進みます。 「二重に走って無駄では」と思うかもしれませんが、マージの瞬間に、他の変更が混ざって壊れることがあるので、main でもう一度確かめるのは正しい動きです。

今回のパイプラインは、1つのファイルに2つのジョブを入れます。 先に「形」だけ見ておきます。中身は③④で埋めます。

name: CI/CD

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  test:
    # ← ③で書く。GitHubが貸すマシンでテストを走らせる(CI)
    runs-on: ubuntu-latest
    steps:
      - run: echo "ここにテストが入る"

  deploy:
    # ← ④で書く。自分のVMへ届ける(CD)
    needs: test          # ⚠️ test が成功したときだけ、このジョブが始まる
    runs-on: self-hosted
    steps:
      - run: echo "ここにデプロイが入る"

この needs: test の1行が、この記事でいちばん大事です。 deploy ジョブは、test ジョブが緑(成功)になるまで、いっさい始まりません。 テストが赤なら、deploy は「skipped(飛ばされた)」になります。壊れたコードは、VMに届く前に、ここで止まります。

  test が緑 ──▶ deploy が始まる ──▶ VMに反映される
  test が赤 ──▶ deploy は skipped ──▶ VMは古いまま(=安全)

runs-on: が、2つのジョブで違うことにも注目してください。test は ubuntu-latest(GitHubが貸す使い捨てのマシン)、deploy は self-hosted(あなたのVM)です。この1語だけで、仕事の行き先が変わります。


③ CI(テストを自動で)— 通過ゲートを先に固める

デプロイを自動にする前に、「デプロイしていいか」を判断する係を固めます。 それが test ジョブです。ここが緩いと、後ろの自動デプロイが全部危なくなります。

~/server には、前回 node:test で書いたテストが入っているはずです。まず、VMの中で手で走らせて、緑を確認します。

bash
$ # VMの中で
$ cd ~/server
$ npm test
ℹ tests 5
ℹ pass 5
ℹ fail 0

fail 0 を確認したら、test ジョブを埋めます。 VMの中で ci.yml を開いて、test ジョブをこうします。

  test:
    runs-on: ubuntu-latest
    steps:
      - name: コードを取得する
        uses: actions/checkout@v4

      - name: Node.js を用意する
        uses: actions/setup-node@v4
        with:
          node-version: '22'

      - name: 依存を入れる
        run: npm ci

      - name: テストを走らせる
        run: npm test

ここは前回とほぼ同じです。 大事な点だけ、もう一度。

  • actions/checkout が無いと、ランナーにファイルが1つもありません。 ubuntu-latest は毎回まっさらなマシンなので、自分でコードを持ってくる必要があります。最頻出の書き忘れです
  • run: npm ci であって npm install ではありません。 npm ci は package-lock.json の1つのバージョンに確定して入れます。「今日と明日で違うバージョンが入る」を防ぐ——確かめる場所では、動くものを1つずつ減らすのが鉄則です

npm ci と npm install は、名前が似ているだけで別のコマンドです。 ここは到達作品で必ず引っかかるので、表で押さえます。

何を見るかpackage-lock.json を既存の node_modules/ を
npm installpackage.json(範囲で書かれている)書き換えることがある残したまま差分だけ入れる
npm cipackage-lock.json(1つのバージョンに確定)絶対に書き換えないまるごと消してから入れ直す

npm ci は package-lock.json が無いと動きません。 そして package.json と package-lock.json が食い違っていても止まります。これは意地悪ではなく、「lock を更新せずに push した」ことを教えてくれています。 手元で npm install したら、package-lock.json も必ず一緒にコミットしてください。 これが CI の「手元では通るのに落ちる」の、いちばん多い原因です。

「手元では通るのにCIで落ちる」を1回起こす

CIの価値は、ここで一番はっきりします。 手元(VM)で npm test が緑でも、CIで赤くなることがあります。 これは故障ではなく、「あなたのVMにしか無い前提」に気づかせてくれているのです。1回、わざと起こしてみます。

例に使うのは「日付」です。 「今日の日付を YYYY-MM-DD で返す」関数を足します。

bash
$ # VMの中で
$ nano ~/server/lib/today.js
// その日の日付を YYYY-MM-DD で返す
function today(date = new Date()) {
  const y = date.getFullYear();
  const m = String(date.getMonth() + 1).padStart(2, "0");
  const d = String(date.getDate()).padStart(2, "0");
  return `${y}-${m}-${d}`;
}

module.exports = { today };

テストを、こう書いたとします。 「日本の深夜0時すぎ」を表す時刻を渡します。

bash
$ nano ~/server/test/today.test.js
const test = require("node:test");
const assert = require("node:assert/strict");
const { today } = require("../lib/today.js");

test("その瞬間の日付を返す", () => {
  // 2026-10-16 の午前1時(VMのローカル時刻 = 日本時間のつもり)
  const d = new Date("2026-10-16T01:00:00");
  assert.equal(today(d), "2026-10-16");
});

VMの中では通ります。

bash
$ cd ~/server
$ npm test
✔ その瞬間の日付を返す (0.5ms)
ℹ pass 6
ℹ fail 0

ところが push すると、CIで赤くなります。

✖ その瞬間の日付を返す
  + actual - expected
  + '2026-10-15'
  - '2026-10-16'

1日ずれています。 理由は、new Date("2026-10-16T01:00:00") は「タイムゾーン指定なし」なので、実行するマシンのローカル時刻として解釈されるからです。あなたのVMは日本時間(JST)ですが、GitHubが貸す ubuntu-latest は UTC で動いています。 JST の 10/16 午前1時は、UTC では 10/15 の午後4時。だから getDate() が「15」を返します。「手元では通るのにCIで落ちる」の、典型そのものです。

直し方は2つあります。どちらでもいいので、片方を選びます。

A. テストを、時刻をタイムゾーンごと固定して書く(おすすめ)。

test("その瞬間の日付を返す", () => {
  // ⚠️ Z を付けて UTC で確定させる。どのマシンでも同じ意味になる
  const d = new Date("2026-10-16T00:00:00Z");
  assert.equal(today(d, "UTC"), "2026-10-16"); // today 側もタイムゾーンを受け取る形にする
});

B. CIのタイムゾーンを、あなたのVMに合わせる(ワークフロー側で1行)。

  test:
    runs-on: ubuntu-latest
    env:
      TZ: Asia/Tokyo          # ⚠️ このジョブの時刻を日本時間にそろえる
    steps:
      - uses: actions/checkout@v4
      # 以下同じ

この一件が教えているのは、「CIは意地悪をしているのではない」ということです。 あなたのVMという「たまたまの環境」に隠れていた前提を、まっさらなマシンで暴いてくれています。 これに気づかず自動デプロイまで作ると、本番だけで時々ずれるという、いちばん厄介なバグを埋め込むことになります。通過ゲートを先に固める、とはこういう意味です。

どちらで直したかを、コミットメッセージに残してください。 「TZ をそろえた」なのか「テストを UTC 固定にした」なのか。未来の自分が、同じ罠をもう一度踏まないための道しるべになります。

時刻以外にも、「あなたのVMにしか無い前提」はいくつもあります。 CIで初めて表に出るのは、だいたいこの5つです。

環境差手元で通る理由CIで落ちる理由
タイムゾーンVMが日本時間ランナーが UTC
package-lock.json 未コミットnode_modules/ が手元にあるランナーは npm ci で lock どおり入れ直す
入れ忘れたシステムのパッケージ昔 apt install した記憶が残っているまっさらなマシンには入っていない
文字コード・ロケールVMが日本語ロケールランナーの既定ロケールが違う
大文字小文字を区別しないパス(Windowsで書いた場合)Foo.js を foo.js で読めたLinux は区別する。ファイルが見つからない

どれも「あなたの環境が汚れている」のではありません。 「動くために、無意識に頼っていたもの」が、まっさらなマシンで見えただけです。CIは、その一覧を毎回タダで出してくれます。これが、自動デプロイの土台になります。


④ CD(自分のVMへ自動デプロイ)

ここが、この記事のいちばんの山です。 CI(テスト)が固まったので、通ったものを、自分のVMへ自動で届けます。

まず、届け方は2つある — 自分のVMはどっちか

GitHub Actions から、自分のサーバーへ届ける方法は、大きく2つです。

やり方仕組みどんなサーバー向きか
A. ランナーから ssh で入る(appleboy/ssh-action など)GitHubの使い捨てランナーが、外からサーバーへ ssh して pull・restart するインターネットから ssh で入れるサーバー(クラウドのVM・VPSなど)
B. セルフホストランナーサーバー自身がGitHubへ「仕事は無いか」と取りに行く外から入れないサーバー(NATの内側・自宅のVM)

あなたのVMは、A では届きません。 VMは自宅PCの中の VMware、さらに NAT の内側にいます。グローバルIPも、ドメイン名もありません。 GitHubの使い捨てランナーが ssh <あなたのVM> しようとしても、名指しできる住所が無いのです。ここは前回 GitHub ActionsとCI/CD の⑥で詳しく確かめました。

入れないなら、出ればいい。 NAT は「外から入る」を止めますが、「中から出る」は止めません。ブラウザで GitHub を開けているのが、その証拠です。だから B のセルフホストランナー——VMの中に「GitHubに仕事が無いか聞きに行き続けるプログラム」を常駐させる——を使います。

A(appleboy/ssh-action)が悪いわけではありません。 クラウドの本番サーバーなら、A のほうが手軽なこともあります。「自分のサーバーがどこにいるか」で選ぶのが正解です。今回のVMは NAT の内側なので、迷わず B です。

セルフホストランナーは、動いている前提

セルフホストランナーの入れ方と、その危険(公開リポジトリでは他人のPRのコードが自分のVMで動く)は、前回やりました。 ここでは繰り返しません。1つだけ、必ず守るルールを再掲します。

セルフホストランナーは、非公開(Private)リポジトリでだけ動かします。 公開リポジトリでは、見知らぬ他人が送ってきたPRのコードが、あなたのVMで実行され得ます。 GitHub自身も公開での使用を推奨していません。

VMの中で、ランナーが常駐しているかを確認します。

bash
$ # VMの中で
$ cd ~/actions-runner
$ sudo ./svc.sh status
active (running)

active (running) なら、VMは GitHub に繋ぎに行き続けています。 GitHubがVMに繋ぎに来たのではありません。VMがGitHubに繋ぎに行っています。 だから NAT の内側でも成立します。

deploy ジョブを書く

VMの中で ci.yml を開き、deploy ジョブを埋めます。 ①で紙に書いた7行が、そのまま steps: になります。

  deploy:
    needs: test                                  # ⚠️ test が緑のときだけ始まる
    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
    runs-on: self-hosted                         # ⚠️ あなたのVMで動く
    steps:
      - name: いまのコミットを控える
        run: |
          cd ~/server
          git rev-parse HEAD > /tmp/prev_commit  # 戻すときの目印
          echo "戻す先: $(cat /tmp/prev_commit)"

      - name: 最新を取り込む
        run: |
          cd ~/server
          git fetch origin main
          git merge --ff-only origin/main         # 黙って上書きさせない

      - name: 依存を入れ直す
        run: |
          cd ~/server
          npm ci

      - name: マイグレーションを流す
        run: |
          cd ~/server
          node --env-file=.env.migrate node_modules/knex/bin/cli.js migrate:latest

      - name: サービスを再起動する
        run: sudo systemctl restart myserver

      - name: ヘルスチェック(本当に上がったか)
        run: |
          sleep 5
          curl -fsS http://127.0.0.1:3000/health

      - name: 失敗したら前のコミットへ戻す
        if: failure()                             # ⚠️ ここまでのどれかが失敗したら動く
        run: |
          cd ~/server
          git checkout "$(cat /tmp/prev_commit)"
          npm ci
          sudo systemctl restart myserver
          echo "前のバージョンへ戻しました"

説明が要る点が5つあります。

1. needs: test — テストのゲート。 ②で見たとおり、test が緑にならない限り deploy は始まりません。壊れたコードはVMに届きません。

2. if: github.ref == 'refs/heads/main' && github.event_name == 'push' — いつ動かすか。 main への push のときだけデプロイします。 プルリクエストの段階(まだレビュー中)ではテストだけを走らせ、デプロイはしません。 これが⑤の「PRを挟む」と組み合わさります。

3. runs-on: self-hosted — ここがVM。 test は ubuntu-latest、deploy は self-hosted。test は必ず ubuntu-latest のままにします。 テストはVMで動かす必要がないし、VMの電源が落ちていてもテストは走ってほしいからです。逆に、VMの電源が落ちていると deploy は始まりません。 セルフホストランナーが居ないので、ジョブは「ランナーを待っています」のまま止まります(すぐにはエラーにならず待ち続けますが、24時間を超えると失敗扱いになります)。「マージしたのにデプロイが動かない」ときは、まずVMとランナーが起きているかを確かめます。

4. git rev-parse HEAD > /tmp/prev_commit — 戻る先の記録。 デプロイを始める前に、「いまの正常なコミット」を控えておきます。 これが無いと、失敗したときに「どこへ戻ればいいか」が分かりません。戻す仕組みは、壊す前に用意します。

5. curl -fsS .../health — ヘルスチェック。 restart が「エラーなく終わった」ことと、「サービスが本当に上がった」ことは別です。設定ミスで起動直後に落ちても、systemctl restart 自体は成功で返ることがあります。だから、URLを叩いて {"ok":true} が返るまで確かめます。 curl -f は、200 以外(500 や、そもそも繋がらない)だと失敗で終わるので、次の if: failure() が発動します。

もう1つ、git pull ではなく git fetch と git merge --ff-only に分けた理由。

--ff-only は「まっすぐ進める場合だけ進む」という指定です。 VMの中でファイルを直接いじって履歴が枝分かれしていたら、マージせずに、その場で失敗します。

fatal: Not possible to fast-forward, aborting.

これは失敗ではなく、正しい停止です。 「何が入るか分からない自動マージ」を、動いている本番のフォルダで走らせないための線引きです。git pull は状況次第で勝手にマージコミットを作ってしまうので、デプロイのような「黙って進めたくない場所」では --ff-only にします。 出たときの直し方は「つまずいたところ」に書きました。

sudo を1コマンドだけ許す

ランナーはあなたのユーザー権限で動くので、sudo systemctl restart はパスワードを聞かれて止まります。 誰も座っていないので、ジョブが固まります。前回やった sudoers の設定を、まだなら入れます。

bash
$ # VMの中で
$ which systemctl          # パスを確認(環境で違う)
$ whoami                   # 自分のログイン名を確認
$ sudo visudo -f /etc/sudoers.d/myserver-deploy

中身は、この2行だけを許します。 ロールバックでも restart を使うので、restart だけ許せば足ります。

ユーザー名 ALL=(root) NOPASSWD: /usr/bin/systemctl restart myserver

NOPASSWD: ALL と書かないでください。 それは「このユーザーはいつでも無条件に root になれる」=ランナーがVMを完全に支配できるという意味です。許すのはこのコマンド1本だけです。visudo を使うのは、文法を間違えて sudo ごと壊さないためです。

動かす

VMの中で push します。

bash
$ # VMの中で
$ cd ~/server
$ git add .github/workflows/ci.yml lib test
$ git status                        # ⚠️ .env と node_modules が一覧に無いことを確認
$ git commit -m "test/deploy を1本のパイプラインにする"
$ git push

Windowsのブラウザで、リポジトリの Actions タブを開きます。 test が緑になり、続けて deploy が動き、最後の ヘルスチェック まで緑になれば、push だけでVMに反映されました。

[スクリーンショット: 01_actions緑.png] Actions タブで、test と deploy の2つのジョブが両方とも緑のチェックになっている実行を撮ってください。アカウント名やリポジトリ名は、隠したければ塗りつぶして構いません。

VMの側でも確かめます。

bash
$ # VMの中で
$ systemctl status myserver
$ curl http://127.0.0.1:3000/health
$ # → {"ok":true}

パイプライン全体を、1枚で見る

ここまでで ci.yml に書いたものを、通して1枚にしておきます。 到達作品は「散らばった部品」ではなく「1本のファイル」で残すのが大事です。これが、あなたのパイプラインの全部です。

name: CI/CD

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  # ── CI: GitHub が貸すマシンで、テストを走らせる ──
  test:
    runs-on: ubuntu-latest
    env:
      TZ: Asia/Tokyo                       # ③の時刻ずれ対策(片方の直し方)
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '22'
      - run: npm ci
      - run: npm test

  # ── CD: 自分のVMへ届ける。test が緑のときだけ ──
  deploy:
    needs: test
    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
    runs-on: self-hosted
    steps:
      - name: いまのコミットを控える
        run: |
          cd ~/server
          git rev-parse HEAD > /tmp/prev_commit
          echo "戻す先: $(cat /tmp/prev_commit)"

      - name: 最新を取り込む
        run: |
          cd ~/server
          git fetch origin main
          git merge --ff-only origin/main

      - name: 依存を入れ直す
        run: |
          cd ~/server
          npm ci

      - name: マイグレーションを流す
        run: |
          cd ~/server
          node --env-file=.env.migrate node_modules/knex/bin/cli.js migrate:latest

      - name: サービスを再起動する
        run: sudo systemctl restart myserver

      - name: ヘルスチェック
        run: |
          sleep 5
          curl -fsS http://127.0.0.1:3000/health

      - name: 失敗したら前のコミットへ戻す
        if: failure()
        run: |
          cd ~/server
          git checkout "$(cat /tmp/prev_commit)"
          npm ci
          sudo systemctl restart myserver
          echo "前のバージョンへ戻しました"

上半分が「確かめる(CI)」、下半分が「配る(CD)」です。 そして両者をつなぐのは、deploy の needs: test の1行だけ。この1ファイルが、①で紙に書いた手作業7行の、機械が読める版です。 頭の中にあった手順が、履歴に残り、誰が見ても同じに動く形になりました。

いま、①の7行を、あなたは1回も手で打っていません。 ブラウザでマージ(この段階ではまだ push)しただけで、テストが走り、通り、VMに反映され、上がったことまで機械が確かめました。これが到達点の半分です。 残りの半分は「失敗したときに、ちゃんと止まって戻ること」です。


この記事の届け先は自分のVMですが、同じワークフローをインターネット上のサーバーへ向ける練習をするなら、小さなVPSを1台用意する方法があります。たとえばシンVPSは API や CLI でのサーバー操作の自動化にも向くとしており、大容量メモリプランの 1GB(1コア・30GB)が1ヶ月 750円〜36ヶ月 451円(税込・月額換算、2026-11 時点)です。無料のお試し期間は無く、最低利用期間は3ヶ月、2026年9月1日に全プランが値上げされているので、古い比較記事の金額ではなく公式の料金表で確かめてください。

⑤ 失敗を安全に — 止める・戻す・レビューを挟む

自動デプロイのいちばん怖いところは、「成功したとき」ではありません。 失敗したときに、壊れたまま突き進むことです。ここを固めて、はじめて「安全な自動化」になります。安全装置は3つです。

安全装置1: 失敗したら止まる(needs と curl -f)

もう組み込んであります。 2か所です。

  • テストが赤 → needs: test で deploy が始まらない。 VMは古いまま(=安全)
  • デプロイの途中で失敗 → 後ろのステップは実行されない。 GitHub Actions は、あるステップが失敗した時点で、そのジョブを止めます(if: failure() を付けたステップを除く)

「止まる」がなぜ安全か。 中途半端に進むのが、いちばん危ないからです。「マイグレーションだけ流れて、コードは古いまま」のような状態が、いちばん復旧しにくい。途中で止まれば、最悪でも「前のバージョンのまま」で済みます。

安全装置2: 失敗したら前へ戻す(ロールバック)

④の最後のステップが、これです。

      - name: 失敗したら前のコミットへ戻す
        if: failure()
        run: |
          cd ~/server
          git checkout "$(cat /tmp/prev_commit)"
          npm ci
          sudo systemctl restart myserver

if: failure() は、「同じジョブの中で、ここまでのどれかが失敗したときだけ、このステップを動かす」という指定です。 普段は飛ばされ、デプロイがコケたときだけ発動します。控えておいた prev_commit(前の正常なコミット)へ git checkout で戻し、入れ直して、再起動します。

わざと壊して、戻ることを確かめます。 ~/server/app.js の、起動時に必ず通る場所へ、わざと throw を1つ入れます。

// app.js の先頭あたりに、わざと1行(確認したら消す)
throw new Error("わざと壊す");
bash
$ # VMの中で
$ cd ~/server
$ git add app.js
$ git commit -m "わざと壊す(戻ることの確認)"
$ git push

Windowsのブラウザの Actions で見ると、こうなります。

  test            ✔ 緑(このバグはテストに引っかからない種類)
  deploy
    ├ 最新を取り込む     ✔
    ├ 依存を入れ直す     ✔
    ├ マイグレーション   ✔
    ├ サービスを再起動   ✔(restart 自体は成功で返る)
    ├ ヘルスチェック     ✖ ← ここで落ちる(起動直後に throw で死ぬので /health が返らない)
    └ 失敗したら戻す     ✔ ← if: failure() が発動。前のコミットへ戻る

ヘルスチェックが赤で、その下の「戻す」が緑——これが見たかった形です。VMは、壊れたコミットではなく、1つ前の正常なコミットで動いています。

bash
$ # VMの中で
$ curl http://127.0.0.1:3000/health
$ # → {"ok":true}   ← 戻っているので、ちゃんと返る
$ git log --oneline -1
$ # → 戻し先のコミット(detached HEAD 状態)

[スクリーンショット: 02_失敗して戻る.png] deploy の実行画面で、ヘルスチェック が赤い×、その下の 失敗したら前のコミットへ戻す が緑のチェックになっている様子を撮ってください。「失敗しても、勝手に戻る」が一目で分かります。

確認したら、app.js の throw を消して、push し直します。

bash
$ # VMの中で
$ cd ~/server
$ git checkout main             # detached HEAD から main へ戻る
$ nano app.js                   # throw の行を消す
$ git add app.js
$ git commit -m "わざと壊した行を消す"
$ git push

git checkout <コミット> をすると detached HEAD(どの枝にも乗っていない状態)になります。 壊れてはいません。git checkout main でいつでも枝に戻れます。ロールバックは「その瞬間だけを見ている」ので、直したものを取り込むときは main に戻ってから push します。

コードは戻る。データベースの構造は、戻らない

いまのロールバックには、大きな落とし穴が1つあります。 git checkout で戻るのは「コード」だけです。マイグレーション(migrate:latest)で足した列は、そのまま残ります。

なぜ問題になるか。 例を1つ。「メモに priority(優先度)という列を足す」変更をデプロイして、失敗したとします。

  1. migrate:latest が走る    → memos テーブルに priority 列が「足される」
  2. restart → ヘルスチェック  → 何か別の理由で失敗
  3. if: failure() が発動      → コードは1つ前へ git checkout で戻る
  ────────────────────────────────────────────────────────────
  結果: コードは「priority を知らない古い版」/ DBには priority 列が「ある」

コードとDBが食い違った状態になります。 古いコードは、知らない列があっても普通は動くので、この例では大事故にはなりません。でも、逆(列を消すマイグレーション)だと、古いコードが「あるはずの列が無い」で即座に落ちます。

戻す難しさは、この2つで段違いです。

戻すもの難しさ何が起きうるか
コード簡単。Git が全部覚えているgit checkout で一瞬
DBの構造難しい。そしてデータが消えることがあるmigrate:rollback の down が「列を消す」なら、その列のデータは消える

DBを手で戻すなら、ORMとマイグレーションの回で書いた down を使います。

bash
$ # VMの中で(DBの構造を1つ戻す)
$ cd ~/server
$ node --env-file=.env.migrate node_modules/knex/bin/cli.js migrate:rollback

migrate:rollback は「無かったことにする」ではなく「down に書いた操作を実行する」です。 down が「列を削除する」なら、その列に入っていたデータは本当に消えます。 練習用のデータでしか、気軽に打たないでください。

だから、自動ロールバックに DB は任せません。 ④のワークフローも、if: failure() で戻すのはコードだけにしてあります。代わりに、「そもそもコードとDBを、同時に切り替えなくても動く形」にしておきます。 これが、戻せるデプロイの本体です。

やりたいこと安全な順番
列を足す先にマイグレーション、あとでコード。 古いコードは、知らない列があっても普通は動く
列を消す・名前を変える先にコードから使うのをやめて、しばらく置いてから消す。 いきなり消すと古いコードが即落ちる

「コードとDBを一度に切り替えない」——これが身につくと、ロールバックの半分は要らなくなります。 自動化は、その安全な土台の上に乗るだけです。段階的リリース(一部だけ新版にして様子を見る)も、この考え方の延長にあります。

安全装置3: main に直接 push しない(PRを挟む)

ここまで、話を分かりやすくするために git push(=main へ直接)で通してきました。 でも、本当は、main へ直接 push しないほうが安全です。 一人でもmainに直接コミットしない — PRとレビュー でやったとおりです。

なぜか。 ④の if: を思い出してください。デプロイが走るのは「main への push」のときだけでした。

  作業ブランチへ push        → test だけ走る(デプロイはされない)
       │
       ▼ Pull Request を作る
  PR の画面で test が緑を確認  → 安心してから
       │
       ▼ Merge ボタンを押す(= main への push)
  main が更新される          → test が走り、通れば deploy が走る

こうすると、「テストが緑だと分かってから、自分の意思でマージする」という一拍が入ります。深夜に寝ぼけて main へ直接 push、という事故が起きません。自動化していても、最後にマージを押すのは人です。

GitHubの「ブランチ保護」を使うと、これを強制できます。 Windowsのブラウザで、リポジトリの Settings → Branches → Add branch protection rule で、main に対して次を有効にします。

設定意味
Require a pull request before mergingmain への直接 push を禁止。必ずPR経由にする
Require status checks to passtest が緑でないとマージできない。赤いものは main に入れない

[スクリーンショット: 03_branch保護.png] Settings → Branches のブランチ保護ルールで、Require a pull request before merging と Require status checks to pass にチェックが入っている画面を撮ってください。「壊れたものは main に入れない」を、GitHub側で強制しているのが分かります。

Require status checks to pass を有効にすると、「どのチェックを必須にするか」を選ぶ欄が出ます。 そこで test を選びます。一度 test を走らせておかないと、候補として出てこないことがあるので、先に1回 push してからにしてください。

これで「壊れたものが main に入る」経路が塞がります。 needs: test は「壊れたものをデプロイしない」ゲート、ブランチ保護は「壊れたものを main に入れない」ゲート。二重にすると、自動デプロイが安心して回せます。


⑥ シークレットと環境の分離

パイプラインが動くようになると、必ず「秘密の値」の置き場所が問題になります。 DBのパスワード、外部サービスのAPIキー、通知先のURL。これらを、絶対に Git にもワークフローにも直接書きません。

いまの構成の、秘密の置き場所

この記事の構成では、秘密は2か所に分かれています。 それぞれ役割が違います。

秘密どこに置くかなぜそこか
DBのパスワードなど、VMのアプリが使う値VMの中の .env(.gitignore 済み)セルフホストランナーはVM自身。.env はもうそこにあるので、渡す必要がない
外部サービスのAPIキーなど、ワークフローが使う値GitHub Secrets「機械の中に無い値」だから。Secretsに預けて、名前で呼ぶ

今回のデプロイは、Secrets を1つも使いません。 セルフホストランナー=あなたのVMなので、~/server/.env はもう手元にあるからです。これは手抜きではなく、「渡す必要が無いから渡さない」という判断です。 秘密は、置き場所が増えるほど漏れます。 減らせるなら減らします。

Secrets を使うなら、この形

将来、たとえば「デプロイが終わったら Slack へ通知する」を足すなら、通知先URLは Secrets に入れます。 Windowsのブラウザで、Settings → Secrets and variables → Actions → New repository secret で名前と値を保存し、ワークフローからはこう呼びます。

      - name: 通知する
        env:
          SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}   # ⚠️ 本物は書かない。名前で呼ぶ
        run: node scripts/notify.js

${{ secrets.SLACK_WEBHOOK }} のように、名前で参照します。 本物の値は、ワークフローファイルにも、コードにも、絶対に書きません。書けば Git に残り、履歴からは消せません。

秘密を echo しないでください。 run: echo "$SLACK_WEBHOOK" は厳禁です。ログはリポジトリを読める人全員が読め、しばらく残ります。 GitHubは登録した値を *** に伏せますが、一部だけ出したり、Base64で形を変えたりすると素通りします。 マスクは保険で、本体は「出さない」ことです。詳しい暗号化つきの持ち方は .envは暗号化してGitに置ける — SOPSとage にまとめました。

マスク(***)を過信しないための、境目です。

隠れる隠れない
登録した文字列と、完全に一致するもの一部だけ出したとき(先頭8文字だけ、など)
形を変えたとき(Base64・URLエンコード・JSONに入れて整形)
改行を含む値(行ごとに分かれると一致しなくなることがある)

マスクは「うっかり全文が出たとき」の保険であって、仕組みではありません。 「出さない」が本体です。

もう2つ、勘違いしやすい点があります。到達作品で必ず引っかかります。

  • 他人のフォークから送られたPRには、Secrets が渡りません。 GitHub がそう作っています。「PRだと動かない」の原因はこれで、故障ではありません
  • Secrets は共同作業者から守るものではありません。 リポジトリに書き込める人は、その値を使うワークフローを自由に書けます。 「読めないから安全」ではありません

本番と検証で、値を分ける

もう1つ大事なのが、「本番の値」と「検証の値」を混ぜないことです。

いまは学習用のVM1台なので、.env も1つです。 でも、本番と検証(ステージング)を分けるようになったら、同じ名前の秘密を、環境ごとに別の値で持ちます。

  本番    : DB_HOST=db-prod   DB_PASSWORD=(本番の長い乱数)
  検証    : DB_HOST=db-stg    DB_PASSWORD=(検証の別の乱数)

検証のパスワードで本番に繋がってしまう、が最悪の事故です。 GitHub Actions には「Environments」という、環境ごとに Secrets を分ける仕組みもあります。「1つの .env を使い回さない」——これを最初から癖にしておくと、台数が増えたときに慌てません。

Environments は、値を分けるだけではありません。 「この環境へデプロイする前に、人の承認を挟む」という関所も付けられます。

仕組み何ができるか
環境ごとの Secrets同じ ${{ secrets.DB_PASSWORD }} でも、本番と検証で中身が変わる
必須レビュアー(required reviewers)本番へ配る前に、指定した人が承認するまで止まる
待機時間(wait timer)「マージから◯分は本番へ流さない」など、あわてて配らないための間

いまは学習用のVM1台なので、ここまでは要りません。 でも、「本番だけは、機械が勝手に配らない」という関所を、あとから足せることは知っておいてください。自動化は「全部を無人にすること」ではなく、「無人でよいところと、人が押すところを、はっきり分けること」です。


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

「なんとなく動いた」で終わらせません。 この6つを自分で通したら、DevOps コースの到達点です。

□ push すると、Actions で test が自動で走る
□ テストが赤なら、deploy は skipped になり、VMに反映されない
□ テストが緑なら、自動でVMに反映される(git pull → npm ci → migrate → restart)
□ 秘密が分離されている(.env は Git に無い / ワークフローに本物の値を書いていない)
□ デプロイが失敗したら、前のバージョンへ自動で戻る(if: failure())
□ ヘルスチェックで「本当に上がったか」を確かめている(curl -f /health)

このリストを、上から実際に手を動かして確かめます。 特に、「テストが赤ならデプロイされない」と「失敗したら戻る」は、成功だけ見て満足しがちな2つです。⑤でわざと1回ずつ起こしました。壊れたときに正しく止まる・戻ることまで見て、はじめて「完成」です。

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

最後に、通しで1回やる

部品ごとに確かめてきましたが、最後に「本番と同じ流れ」を1回通します。 PRを作ってマージする、という本来の形で回します。

bash
$ # VMの中で。作業ブランチを切って、小さな変更を1つ入れる
$ cd ~/server
$ git checkout main
$ git checkout -b tweak-health
$ nano app.js                 # 例: /health の応答に version を足すなど、無害な変更
$ git add app.js
$ git commit -m "health に version を足す"
$ git push -u origin tweak-health

このあとは Windowsのブラウザです。

  1. GitHub で "Compare & pull request" を押して PR を作る
  2. PR の画面で test が緑になるのを待つ(deploy はまだ動かない)
  3. Merge ボタンを押す(= main への push)
  4. Actions で test → deploy が順に緑になるのを見る
  5. deploy の「ヘルスチェック」が緑 = VMに反映された

VMに戻って、最後の確認です。

bash
$ # VMの中で
$ git checkout main
$ git pull                    # 手元の main もGitHubに追いつかせておく
$ curl http://127.0.0.1:3000/health

あなたが手で打ったのは「変更を書いて push」と「Merge を押す」だけです。テスト・取り込み・入れ直し・再起動・確認は、全部機械がやりました。これが、DevOps コースの到達点の「通し」の形です。

やりすぎない — いま足さないものを決める

ここまで動くと、足したくなるものが一気に増えます。 全部あとでいいです。 到達作品を太らせると、かえって完成が遠のきます。

よく足したくなるものいま要るか
DBを使うテストを CI で回すまだ。services: で立てられるが、先に普通のテストを増やすほうが効く
Lint(ESLint など)を CI に足すテストが安定してからで十分
Docker イメージを作って配るコンテナの回と繋がるが、いまは分けたほうが読める
段階的リリース(一部だけ新版にする)VMが1台のうちは意味がない。複数台になってから
通知(Slack など)失敗すればメールが届く。まずはそれで足りる

CI/CD の記事は、たいてい完成形から始まります。 そして完成形は、そこに至った理由が全部消えた状態です。1本のテストと1本のパイプラインから始めたほうが、後で足すときに「なぜ足すのか」が自分で分かります。 足すのは、いつでもできます。


ここまでで、パイプラインが1本、最後まで通りました。 「手で毎回デプロイ」から「pushするだけ」へ来ました。 ①で紙に書いた7行を、あなたはもう手で打っていません。

そして、この先があります。 いまのパイプラインは VM1台が相手です。複数台に、止めずに(無停止で)、段階的に配る——となると、次の道具が要ります。

でも、今日はここまでで十分です。 押すだけで、テストが走り、通ったものだけが、確かめられながら反映される——この1本を、自分の手で通し切ったことが、DevOps コースの到達点です。


つまずいたところ

8つ詰まりました。

deploy が、テストが赤でも動いてしまった(と思った)。 実際は needs: test を書き忘れていて、2つのジョブが並行して動いていました。 GitHub Actions は、needs を書かないジョブを同時に始めます。 deploy に needs: test を足したら、テストの後に順番待ちするようになりました。「順番に動く」は、書かないと成立しません。

テストは緑なのに、deploy が skipped のまま動かなかった。 プルリクエストの画面で見ていました。deploy には if: github.ref == 'refs/heads/main' を付けてあるので、PRの段階では意図通り飛ばされます。 マージして main が更新されたら動きました。故障ではなく、そういう設計でした。

ヘルスチェックが、いつも一瞬早くて失敗した。 restart の直後に curl すると、まだ起動しきっておらず、繋がりませんでした。sleep 5 を入れて、少し待ってから叩くようにしたら安定しました。「上がるまでの数秒」を見込むのを忘れていました。

「手元では通るのにCIで落ちる」で丸1日ずれた。 ③でやった日付の件です。VMは日本時間、ubuntu-latest は UTC。new Date("...") にタイムゾーンを書いていませんでした。テストを Z 付き(UTC固定)に直して解決。CIは意地悪ではなく、隠れた前提を暴いてくれたのでした。

sudo systemctl restart で、ジョブが固まった。 ランナーはパスワードを聞かれても、誰も打てません(a terminal is required to read the password)。/etc/sudoers.d/ に「そのコマンドだけ NOPASSWD」を1行足して解決。NOPASSWD: ALL にしないのが肝です。

ロールバックが動いたのに、次の push でまた merge --ff-only が失敗した。 ロールバックで git checkout <コミット> した結果、VMが detached HEAD のまま放置されていました。デプロイの前に、VM側を git checkout main に戻しておくのを手順に足したら直りました。「動かす場所」で手作業をすると、こうなります。

if: failure() の戻すステップが、成功時にも動いていた気がした。 実際は、前のステップで警告が出ていただけで、ジョブ自体は成功していました。if: failure() は「ジョブが失敗状態のときだけ」で、警告では発動しません。ログをよく見たら、戻すステップはちゃんと skipped でした。思い込みで直す前に、ログを最後まで読む——毎回これです。

列を足すデプロイをロールバックしたら、コードとDBが食い違ったまま残った。 if: failure() が戻すのはコードだけで、migrate:latest が足した列は残っていました。幸い「列が余っているだけ」で古いコードは動きましたが、逆(列を消す変更)だったら即落ちていたはずです。⑤に書いたとおり、列は「足す→使う→消す」の順にして、コードとDBを一度に切り替えない形へ直しました。自動ロールバックにDBを任せない、が結論です。


後片づけ

この記事で足したものは、全部戻せます。

パイプラインを一時的に止める。 Windowsのブラウザの Actions タブでワークフローを選び、右上のメニューから Disable workflow を選びます。ファイルは残したまま止まります。

自動デプロイだけをやめて、手動ボタンに戻す。 VMの中で ci.yml の deploy ジョブの on: 相当を見直し、deploy の if: を外して on: workflow_dispatch(手動起動)中心に戻せば、前回の回の「押すボタン」の形に戻ります。自動が不安なうちは、手動に戻すのは正しい判断です。

わざと壊した確認用のコミットを、履歴から消したいとき。 消さなくて構いません。git revert で「打ち消すコミット」を足すのが安全です。履歴を書き換える(reset --hard して force push)と、共同作業者や、すでに pull した自分が壊れます。

bash
$ # VMの中で(不要な確認コミットを打ち消す例)
$ cd ~/server
$ git revert --no-edit <打ち消したいコミットID>
$ git push

セルフホストランナーやブランチ保護そのものを外す手順は、前回の GitHub ActionsとCI/CD の「後片づけ」にまとめてあります。ランナーを外すときは、GitHub側の Settings → Actions → Runners からも登録を消すのを忘れずに。


まとめ — 理解できたこと

  • 手作業デプロイの本当の問題は「面倒」ではなく、忘れる・ぶれる・順番を間違える・深夜に事故ること。CI/CD はその7行を、機械に毎回同じ順でやらせること
  • 自動化する前に、手順を紙に書き出す。 頭の中の手順は自動化できない。書き出したものが、そのまま steps: になる
  • 1つのワークフローに test と deploy の2ジョブを入れ、deploy に needs: test を付ける。 これが「テストが緑のときだけデプロイ」の通過ゲート
  • test は ubuntu-latest、deploy は self-hosted。 runs-on: の1語で行き先が変わる。テストはVMが落ちていても走ってほしい
  • 「手元では通るのにCIで落ちる」は、CIが隠れた前提を暴いた合図。 タイムゾーン差が典型。意地悪ではない
  • 自分のVMは NAT の内側。 GitHubから ssh は届かない。VMから取りに行くセルフホストランナーで解く。appleboy/ssh-action は外から入れるサーバー向け
  • 戻せる仕組みを、壊す前に用意する。 デプロイの最初に git rev-parse HEAD を控え、if: failure() で前のコミットへ戻す
  • restart が成功で返っても、上がったとは限らない。 curl -f /health で本当に上がったかを確かめる
  • 安全装置は3つ。 テストのゲート(needs)/ 失敗時のロールバック(if: failure())/ mainに直接pushせずPRとブランチ保護を挟む
  • 秘密は分ける。 VMのアプリが使う値は .env(Git外)、ワークフローが使う値は Secrets。今回は渡す必要が無いので Secrets ゼロ
  • 秘密は echo しない。 ログは残るし、マスクは形を変えると素通りする。本番と検証の値も混ぜない
  • sudo systemctl restart はランナーで止まる。 sudoers でそのコマンドだけを NOPASSWD にする。NOPASSWD: ALL は書かない
  • 完成の判定を自分で持つ。 「テストが赤ならデプロイされない」「失敗したら戻る」まで、わざと起こして確かめてこそ完成
  • 「手で毎回デプロイ」から「pushするだけ」へ来た。 複数台・段階的リリースは、この先の Terraform や ArgoCD へ続く

あなたはもう、散らばっていた DevOps の部品を、押すだけで最後まで流れる1本の線につなぎ切りました。 ——これが DevOps コースの到達点です。


参考リンク

GitHub Docs は改編が多く、URLも画面も変わります。 リンク先が見当たらないときは、上の日本語トップから 「ワークフロー構文」「セルフホストランナー」「シークレット」「ブランチ保護」 で探してください。


次に読む

この記事は 【第6段階】インフラとコンテナ の 14 / 25 本目です。

記事
← 前の記事ログが3箇所に散っている — Lokiで1画面にする
→ 次の記事「遅い」の次は「どこが」 — 分散トレーシング入門

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

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

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

DevOps コースの到達作品です。 push だけでテストと自動デプロイが走り、失敗したら安全に止めて戻すまでを1本のパイプラインに束ねます。

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

コメント

コメントする

目次