Node.js HTTPS モジュール

Volardev 編集部 April 26, 2026

1. HTTPS モジュール入門

HTTPS モジュールは、HTTPS プロトコルの実装を提供する Node.js のコアモジュールです。これは本質的に、TLS/SSL 上で動作する HTTP です。
HTTP モジュールのセキュアなバージョンであり、クライアントとサーバー間の通信をエンクリプション（暗号化）して保護します。

2. HTTPS を使用する理由

モダンな Web アプリケーションにおいて HTTPS は不可欠です。その主な理由は以下の通りです。

データの暗号化: パスワード、クレジットカード番号、個人情報などの機密情報を盗聴から保護します。
サーバー認証: クライアントが意図した正しいサーバーと通信していることを検証します。
データの整合性: 転送中にデータが改ざんされたり、破損したりするのを防ぎます。
信頼の構築: ブラウザの南京錠アイコンなどの視覚的なインジケーターがユーザーの安心感を高めます。
SEO の向上: 検索エンジン（Google など）は、HTTPS サイトを検索結果で優先します。
モダンな機能の有効化: Geolocation、Service Workers などの多くの Web API は HTTPS を必須条件としています。

3. HTTPS の仕組み

クライアントがサーバーに対してセキュアな接続を開始します。
サーバーは SSL/TLS 証明書をクライアントに提示します。
クライアントは、信頼できる認証局（CA）と照らし合わせて証明書を検証します。
非対称暗号化（Asymmetric Encryption）を使用して、暗号化されたセッションが確立されます。
実際のデータ転送には、共通鍵暗号化（Symmetric Encryption）が使用されます。

注意: モダンな HTTPS は SSL（Secure Sockets Layer）の後継である TLS（Transport Layer Security） を使用しています。用語は混同されがちですが、SSL は現在、非推奨（Deprecated）と見なされています。

重要: 2023年時点で、すべての主要ブラウザは新しい Web 機能や API に HTTPS を要求しています。また、多くのブラウザが非 HTTPS サイトに「保護されていない通信」という警告を表示します。

4. HTTPS モジュールの基本

4.1 モジュールのインポート

Node.js アプリケーションで HTTPS モジュールを使用するには、CommonJS または ES modules の構文でインポートします。

CommonJS (Node.js デフォルト)

// require() を使用
const https = require('https');

ES Modules (Node.js 14+)

// import を使用 (package.json で "type": "module" が必要)
import https from 'https';

4.2 HTTPS vs HTTP API

HTTPS モジュールは HTTP モジュールと同じインターフェースを持っています。主な違いは、TLS/SSL を使用して接続を作成する点です。
つまり、HTTP モジュールで利用可能なすべてのメソッドやイベントは、HTTPS モジュールでも利用可能です。

注意: 使用上の主な違いは、HTTPS には SSL/TLS 証明書が必要ですが、HTTP には不要であるという点です。

5. SSL/TLS 証明書

HTTPS でセキュアな接続を確立するには SSL/TLS 証明書が必要です。証明書にはいくつかのタイプがあります。

5.1 証明書の種類

自己署名証明書 (Self-Signed Certificates): 開発およびテスト用（ブラウザには信頼されません）。
ドメイン認証 (DV): 基本的なバリデーション。ドメインの所有権のみを確認します。
実在証明 (OV): 組織の詳細情報を検証します。
実在証明 (EV): 最高レベルのバリデーション。ブラウザに会社名が表示されます。
ワイルドカード証明書: ドメインのすべてのサブドメインを保護します。
マルチドメイン (SAN) 証明書: 1つの証明書で複数のドメインを保護します。

5.2 自己署名証明書の生成

開発用として、OpenSSL を使用して自己署名証明書を作成できます。

基本的な自己署名証明書

# プライベートキーの生成 (RSA 2048-bit)
openssl genrsa -out key.pem 2048

# 自己署名証明書の生成 (365日間有効)
openssl req -new -x509 -key key.pem -out cert.pem -days 365 -nodes

注意: もし key.pem ファイルが存在しない場合は、上記のコマンドで -key の代わりに -newkey オプションを使用する必要があります。

SAN（Subject Alternative Names）付きの生成

# 設定ファイル (san.cnf) の作成
cat > san.cnf << EOF
[req]
distinguished_name = req_distinguished_name
x509_extensions = v3_req
prompt = no
[req_distinguished_name]
C = JP
ST = Tokyo
L = Chiyoda
O = MyOrganization
OU = DevUnit
CN = localhost
[v3_req]
keyUsage = keyEncipherment, dataEncipherment
extendedKeyUsage = serverAuth
subjectAltName = @alt_names
[alt_names]
DNS.1 = localhost
IP.1 = 127.0.0.1
EOF

# SAN 付きでキーと証明書を生成
openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
-keyout key.pem -out cert.pem -config san.cnf -extensions 'v3_req'

セキュリティ上の注意: 自己署名証明書は信頼できる認証局によって署名されていないため、ブラウザでセキュリティ警告が表示されます。開発およびテスト目的でのみ使用してください。

5.3 信頼された証明書の取得

本番環境では、信頼された認証局（CA）から証明書を取得してください。

有料 CA: DigiCert, GlobalSign, Comodo など
無料 CA: Let's Encrypt, ZeroSSL, Cloudflare

Let's Encrypt は、信頼された証明書を無料で提供する、自動化されたオープンな認証局として非常に人気があります。

6. HTTPS サーバーの作成

SSL/TLS 証明書の準備ができたら、Node.js で HTTPS サーバーを作成できます。サーバー API は HTTP サーバーと酷似していますが、SSL/TLS の設定（オプション）が必要です。

6.1 基本的な HTTPS サーバーの例

const https = require('https');
const fs = require('fs');
const path = require('path');

// SSL/TLS 証明書とキーのパス
const sslOptions = {
  key: fs.readFileSync(path.join(__dirname, 'key.pem')),
  cert: fs.readFileSync(path.join(__dirname, 'cert.pem')),
  // すべてのセキュリティ機能を有効化
  minVersion: 'TLSv1.2',
  // 推奨されるセキュリティ設定
  secureOptions: require('constants').SSL_OP_NO_SSLv3 |
                require('constants').SSL_OP_NO_TLSv1 |
                require('constants').SSL_OP_NO_TLSv1_1
};

// HTTPS サーバーを作成
const server = https.createServer(sslOptions, (req, res) => {
  // セキュリティヘッダーの設定
  res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains');
  res.setHeader('X-Content-Type-Options', 'nosniff');
  res.setHeader('X-Frame-Options', 'SAMEORIGIN');
  res.setHeader('X-XSS-Protection', '1; mode=block');
  res.setHeader('Referrer-Policy', 'strict-origin-when-cross-origin');

  // ルーティング処理
  if (req.url === '/') {
    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
    res.end('<h1>セキュアサーバーへようこそ</h1><p>あなたの接続は暗号化されています！</p>');
  } else if (req.url === '/api/status') {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ status: 'ok', time: new Date().toISOString() }));
  } else {
    res.writeHead(404, { 'Content-Type': 'text/plain' });
    res.end('404 Not Found');
  }
});

// サーバーエラーのハンドリング
server.on('error', (error) => {
  console.error('サーバーエラー:', error);
});

// ポート 3000 で起動 (HTTPS デフォルトは 443 ですが root 権限が必要です)
const PORT = process.env.PORT || 3000;
server.listen(PORT, '0.0.0.0', () => {
  console.log(`サーバーが https://localhost:${PORT} で稼働中`);
  console.log('停止するには Ctrl+C を押してください');
});

注意: Unix 系システムでは、1024 未満のポート番号には root 権限が必要です。本番環境では、Node.js を高いポート（3000, 8080 など）で実行し、Nginx や Apache などの リバースプロキシ を使用して SSL ターミネーションを行うのが一般的です。

7. 高度なサーバー構成

本番環境では、OCSP ステープリングやセッション再開など、より高度な SSL/TLS 設定が必要になる場合があります。

7.1 OCSP ステープリングとセッション再開を備えた高度な構成

const https = require('https');
const fs = require('fs');
const path = require('path');
const tls = require('tls');

const sslOptions = {
  // 証明書とキー
  key: fs.readFileSync(path.join(__dirname, 'privkey.pem')),
  cert: fs.readFileSync(path.join(__dirname, 'cert.pem')),
  ca: [
    fs.readFileSync(path.join(__dirname, 'chain.pem'))
  ],

  // 推奨されるセキュリティ設定
  minVersion: 'TLSv1.2',
  maxVersion: 'TLSv1.3',
  ciphers: [
    'TLS_AES_256_GCM_SHA384',
    'TLS_CHACHA20_POLY1305_SHA256',
    'TLS_AES_128_GCM_SHA256',
    'ECDHE-ECDSA-AES256-GCM-SHA384',
    'ECDHE-RSA-AES256-GCM-SHA384',
    'ECDHE-ECDSA-CHACHA20-POLY1305',
    'ECDHE-RSA-CHACHA20-POLY1305',
    'ECDHE-ECDSA-AES128-GCM-SHA256',
    'ECDHE-RSA-AES128-GCM-SHA256'
  ].join(':'),
  honorCipherOrder: true,
  
  // OCSP ステープリングの有効化
  requestCert: true,
  rejectUnauthorized: true,
  
  // セッション再開の有効化
  sessionTimeout: 300, // 5分
  sessionIdContext: 'my-secure-app',
  
  // HSTS プリロードの有効化
  hsts: {
    maxAge: 63072000, // 2年間
    includeSubDomains: true,
    preload: true
  },
  
  // セキュアな再ネゴシエーションの有効化
  secureOptions: require('constants').SSL_OP_LEGACY_SERVER_CONNECT |
    require('constants').SSL_OP_NO_SSLv3 |
    require('constants').SSL_OP_NO_TLSv1 |
    require('constants').SSL_OP_NO_TLSv1_1 |
    require('constants').SSL_OP_CIPHER_SERVER_PREFERENCE
};

const server = https.createServer(sslOptions, (req, res) => {
  const securityHeaders = {
    'Strict-Transport-Security': 'max-age=63072000; includeSubDomains; preload',
    'X-Content-Type-Options': 'nosniff',
    'X-Frame-Options': 'DENY',
    'X-XSS-Protection': '1; mode=block',
    'Content-Security-Policy': "default-src 'self'",
    'Referrer-Policy': 'strict-origin-when-cross-origin',
    'Permissions-Policy': 'geolocation=(), microphone=(), camera=()',
  };
  
  Object.entries(securityHeaders).forEach(([key, value]) => {
    res.setHeader(key, value);
  });

  if (req.url === '/') {
    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
    res.end('<h1>セキュアな Node.js サーバー</h1><p>接続は安全です！</p>');
  } else {
    res.writeHead(404, { 'Content-Type': 'text/plain' });
    res.end('404 Not Found');
  }
});

// エラーハンドリング
server.on('error', (error) => {
  console.error('サーバーエラー:', error);
});

// キャッチされない例外のハンドリング
process.on('uncaughtException', (error) => {
  console.error('未処理の例外:', error);
  // グレースフルシャットダウンを実行
  server.close(() => process.exit(1));
});

// 未処理の Promise 拒否のハンドリング
process.on('unhandledRejection', (reason, promise) => {
  console.error('未処理の拒否:', promise, '理由:', reason);
});

// グレースフルシャットダウン処理
const gracefulShutdown = () => {
  console.log('グレースフルに停止中...');
  server.close(() => {
    console.log('サーバーが停止しました');
    process.exit(0);
  });

  // 10秒後に強制終了
  setTimeout(() => {
    console.error('強制終了します...');
    process.exit(1);
  }, 10000);
};

process.on('SIGTERM', gracefulShutdown);
process.on('SIGINT', gracefulShutdown);

const PORT = process.env.PORT || 3000;
const HOST = process.env.HOST || '0.0.0.0';

server.listen(PORT, HOST, () => {
  const { address, port } = server.address();
  console.log(`サーバーが https://${address}:${port} で稼働中`);
  console.log('Node.js バージョン:', process.version);
  console.log('環境:', process.env.NODE_ENV || 'development');
  console.log('PID:', process.pid);
});

7.2 セキュリティ・ベストプラクティス

セキュリティアップデートのため、常に最新の安定版 Node.js を使用してください。
npm audit や npm update を使用して、依存関係（Dependencies）を最新に保ちます。
機密性の高い設定には環境変数を使用し、シークレットをバージョン管理に含めないでください。
悪用を防ぐためにレート制限（Rate Limiting）を実装します。
SSL/TLS 証明書を定期的に更新（ローテーション）してください。
サーバーのセキュリティ脆弱性を定期的にモニタリングします。
追加のセキュリティ機能のために、本番環境では Nginx や Apache などのリバースプロキシを使用してください。

8. HTTPS サーバーのテスト

HTTPS サーバーをテストするには、curl または Web ブラウザを使用します。

8.1 curl を使用したテスト

# 証明書の検証をスキップ (自己署名証明書の場合)
curl -k https://localhost:3000

# 証明書の検証を行う (信頼された証明書の場合)
curl --cacert /path/to/ca.pem https://yourdomain.com

8.2 Web ブラウザを使用したテスト

ブラウザを開き、https://localhost:3000 にアクセスします。
自己署名証明書を使用している場合は、セキュリティ警告を許可する必要があります。
開発環境では、自己署名証明書を信頼されたルート証明書として追加することも可能です。

9. HTTPS リクエストの送信

HTTPS モジュールを使用すると、他のサーバーに対してセキュアな HTTP リクエストを送信できます。これは、セキュアな API や Web サービスとやり取りする際に必須です。

9.1 基本的な GET リクエスト

HTTPS エンドポイントへのシンプルな GET リクエストの送信方法は以下の通りです。

const https = require('https');
const { URL } = require('url');

// ターゲット URL のパース
const apiUrl = new URL('https://api.example.com/data');

// リクエストオプション
const options = {
  hostname: apiUrl.hostname,
  port: 443,
  path: apiUrl.pathname + apiUrl.search,
  method: 'GET',
  headers: {
    'User-Agent': 'MySecureApp/1.0',
    'Accept': 'application/json',
    'Cache-Control': 'no-cache'
  },
  // セキュリティ設定
  rejectUnauthorized: true, // サーバー証明書を検証する (デフォルト: true)
  // タイムアウト設定 (ミリ秒)
  timeout: 10000, // 10秒
};

console.log(`リクエストを送信中: https://${options.hostname}${options.path}`);

// HTTPS リクエストの作成
const req = https.request(options, (res) => {
  const { statusCode, statusMessage, headers } = res;
  const contentType = headers['content-type'] || '';

  console.log(`ステータス: ${statusCode} ${statusMessage}`);
  console.log('ヘッダー:', headers);

  // リダイレクトの処理
  if (statusCode >= 300 && statusCode < 400 && headers.location) {
    console.log(`リダイレクト先: ${headers.location}`);
    res.resume(); // レスポンスボディを破棄
    return;
  }

  // 成功レスポンスの確認
  let error;
  if (statusCode !== 200) {
    error = new Error(`リクエスト失敗。\nステータスコード: ${statusCode}`);
  } else if (!/^application\/json/.test(contentType)) {
    error = new Error(`無効な content-type。\n期待値: application/json, 受信値: ${contentType}`);
  }
  if (error) {
    console.error(error.message);
    res.resume(); // メモリを解放するためにレスポンスデータを消費
    return;
  }

  // レスポンスの処理
  let rawData = '';
  res.setEncoding('utf8');

  // データチャンクの収集
  res.on('data', (chunk) => {
    rawData += chunk;
  });

  // レスポンス完了後の処理
  res.on('end', () => {
    try {
      const parsedData = JSON.parse(rawData);
      console.log('レスポンスデータ:', parsedData);
    } catch (e) {
      console.error('JSON パースエラー:', e.message);
    }
  });
});

// リクエストエラーのハンドリング
req.on('error', (e) => {
  console.error(`リクエストエラー: ${e.message}`);
  if (e.code === 'ECONNRESET') {
    console.error('サーバーによって接続がリセットされました');
  } else if (e.code === 'ETIMEDOUT') {
    console.error('リクエストがタイムアウトしました');
  }
});

// リクエスト全体のタイムアウト設定
req.setTimeout(15000, () => {
  req.destroy(new Error('15秒後にリクエストがタイムアウトしました'));
});

// ソケットエラーのハンドリング
req.on('socket', (socket) => {
  socket.on('error', (error) => {
    console.error('ソケットエラー:', error.message);
    req.destroy(error);
  });
  // ソケット接続のタイムアウト設定
  socket.setTimeout(5000, () => {
    req.destroy(new Error('5秒後にソケットがタイムアウトしました'));
  });
});

// リクエストの終了 (送信に必要)
req.end();

9.2 シンプルなリクエストのための https.get()

シンプルな GET リクエストの場合、より簡潔な https.get() メソッドを使用できます。これは自動的にメソッドを GET に設定し、req.end() を自動で呼び出す便利なメソッドです。

const https = require('https');
const { URL } = require('url');

const url = new URL('https://jsonplaceholder.typicode.com/posts/1');

const options = {
  hostname: url.hostname,
  path: url.pathname,
  method: 'GET',
  headers: {
    'Accept': 'application/json',
    'User-Agent': 'MySecureApp/1.0'
  }
};

console.log(`データの取得元: ${url}`);

const req = https.get(options, (res) => {
  const { statusCode } = res;
  const contentType = res.headers['content-type'];

  if (statusCode !== 200) {
    console.error(`リクエストが失敗しました。ステータスコード: ${statusCode}`);
    res.resume();
    return;
  }

  if (!/^application\/json/.test(contentType)) {
    console.error(`JSON を期待していましたが、受信したのは ${contentType} です`);
    res.resume();
    return;
  }

  let rawData = '';
  res.setEncoding('utf8');

  res.on('data', (chunk) => {
    rawData += chunk;
  });

  res.on('end', () => {
    try {
      const parsedData = JSON.parse(rawData);
      console.log('受信データ:', parsedData);
    } catch (e) {
      console.error('パースエラー:', e.message);
    }
  });
});

req.on('error', (e) => {
  console.error(`エラー: ${e.message}`);
});

req.setTimeout(10000, () => {
  console.error('リクエストタイムアウト');
  req.destroy();
});

9.3 POST リクエストの送信

サーバーにデータを送信するには、POST リクエストを使用します。以下は JSON データを含むセキュアな POST リクエストの例です。

const https = require('https');
const { URL } = require('url');

// 送信データ
const postData = JSON.stringify({
  title: 'foo',
  body: 'bar',
  userId: 1
});

const url = new URL('https://jsonplaceholder.typicode.com/posts');

const options = {
  hostname: url.hostname,
  port: 443,
  path: url.pathname,
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(postData),
    'User-Agent': 'MySecureApp/1.0',
    'Accept': 'application/json'
  },
  timeout: 10000 // 10秒
};

console.log('POST リクエスト送信先:', url.toString());

const req = https.request(options, (res) => {
  console.log(`ステータスコード: ${res.statusCode}`);
  console.log('ヘッダー:', res.headers);

  let responseData = '';
  res.setEncoding('utf8');

  res.on('data', (chunk) => {
    responseData += chunk;
  });

  res.on('end', () => {
    try {
      const parsedData = JSON.parse(responseData);
      console.log('レスポンス:', parsedData);
    } catch (e) {
      console.error('レスポンスパースエラー:', e.message);
    }
  });
});

req.on('error', (e) => {
  console.error(`リクエストエラー: ${e.message}`);
});

req.setTimeout(15000, () => {
  req.destroy(new Error('15秒後にリクエストがタイムアウトしました'));
});

// リクエストボディにデータを書き込む
req.write(postData);
req.end();

9.4 HTTPS リクエストでの Promise の利用

HTTPS リクエストをより扱いやすくするために、Promise でラップすることができます。

const https = require('https');
const { URL } = require('url');

/**
 * HTTPS リクエストを実行し、Promise を返します
 */
function httpsRequest(options, data = null) {
  return new Promise((resolve, reject) => {
    const req = https.request(options, (res) => {
      let responseData = '';

      res.on('data', (chunk) => {
        responseData += chunk;
      });

      res.on('end', () => {
        try {
          const contentType = res.headers['content-type'] || '';
          const isJSON = /^application\/json/.test(contentType);
          
          const response = {
            statusCode: res.statusCode,
            headers: res.headers,
            data: isJSON ? JSON.parse(responseData) : responseData
          };
          
          if (res.statusCode >= 200 && res.statusCode < 300) {
            resolve(response);
          } else {
            const error = new Error(`ステータスコード ${res.statusCode} で失敗しました`);
            error.response = response;
            reject(error);
          }
        } catch (e) {
          e.response = { data: responseData };
          reject(e);
        }
      });
    });

    req.on('error', (e) => {
      reject(e);
    });

    req.setTimeout(options.timeout || 10000, () => {
      req.destroy(new Error('リクエストタイムアウト'));
    });

    if (data) {
      req.write(data);
    }

    req.end();
  });
}

// 使用例
async function fetchData() {
  try {
    const url = new URL('https://jsonplaceholder.typicode.com/posts/1');
    
    const options = {
      hostname: url.hostname,
      path: url.pathname,
      method: 'GET',
      headers: {
        'Accept': 'application/json'
      },
      timeout: 5000
    };

    const response = await httpsRequest(options);
    console.log('レスポンス:', response.data);
  } catch (error) {
    console.error('エラー:', error.message);
    if (error.response) {
      console.error('レスポンスデータ:', error.response.data);
    }
  }
}

fetchData();

9.5 HTTPS リクエストのベストプラクティス

リクエストを送信する前に、入力データを常に検証およびサニタイズしてください。
API キーなどの機密情報には環境変数を使用します。
適切なエラーハンドリングとタイムアウトを実装してください。
適切なヘッダー（Content-Type, Accept, User-Agent）を設定します。
リダイレクト（3xx ステータスコード）を適切に処理します。
一時的な失敗に対してリトライロジックを実装します。
より複雑なシナリオでは、axios や node-fetch などのライブラリの使用を検討してください。

10. Express.js を使用した HTTPS サーバー

コアの HTTPS モジュールを直接使用することもできますが、多くの Node.js アプリケーションでは Express.js のようなフレームワークを使用して HTTP/HTTPS リクエストを処理します。

10.1 基本的な Express.js HTTPS サーバー

const express = require('express');
const https = require('https');
const fs = require('fs');
const path = require('path');
const helmet = require('helmet'); // セキュリティミドルウェア

const app = express();

// セキュリティミドルウェアの使用
app.use(helmet());

// JSON および URL エンコードされたボディのパース
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// 'public' ディレクトリから静的ファイルを提供
app.use(express.static(path.join(__dirname, 'public'), {
  dotfiles: 'ignore',
  etag: true,
  extensions: ['html', 'htm'],
  index: 'index.html',
  maxAge: '1d',
  redirect: true
}));

// ルート設定
app.get('/', (req, res) => {
  res.send('<h1>セキュアな Express サーバーへようこそ</h1>');
});

app.get('/api/status', (req, res) => {
  res.json({
    status: 'operational',
    timestamp: new Date().toISOString(),
    environment: process.env.NODE_ENV || 'development',
    nodeVersion: process.version
  });
});

// エラーハンドリングミドルウェア
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ error: 'エラーが発生しました！' });
});

// 404 ハンドラー
app.use((req, res) => {
  res.status(404).json({ error: 'Not Found' });
});

// SSL/TLS オプション
const sslOptions = {
  key: fs.readFileSync(path.join(__dirname, 'key.pem')),
  cert: fs.readFileSync(path.join(__dirname, 'cert.pem')),
  // 利用可能な場合は HTTP/2 を許可
  allowHTTP1: true,
  minVersion: 'TLSv1.2',
  ciphers: [
    'TLS_AES_256_GCM_SHA384',
    'TLS_CHACHA20_POLY1305_SHA256',
    'TLS_AES_128_GCM_SHA256',
    'ECDHE-RSA-AES128-GCM-SHA256',
    '!DSS', '!aNULL', '!eNULL', '!EXPORT', '!DES', '!RC4', '!3DES', '!MD5', '!PSK'
  ].join(':'),
  honorCipherOrder: true
};

// HTTPS サーバーを作成
const PORT = process.env.PORT || 3000;
const server = https.createServer(sslOptions, app);

// グレースフルシャットダウン
const gracefulShutdown = (signal) => {
  console.log(`\n${signal} を受信しました。グレースフルに停止します...`);
  server.close(() => {
    console.log('HTTP サーバーを終了しました。');
    process.exit(0);
  });
};

process.on('SIGTERM', gracefulShutdown);
process.on('SIGINT', gracefulShutdown);

const HOST = process.env.HOST || '0.0.0.0';
server.listen(PORT, HOST, () => {
  console.log(`Express サーバーが https://${HOST}:${PORT} で稼働中`);
});

10.2 環境変数の使用

設定には環境変数を使用するのがベストプラクティスです。.env ファイルを作成します。

.env ファイル

NODE_ENV=development
PORT=3000
HOST=0.0.0.0
SSL_KEY_PATH=./key.pem
SSL_CERT_PATH=./cert.pem

そして、dotenv パッケージを使用してこれらを読み込みます。

require('dotenv').config();

const PORT = process.env.PORT || 3000;
const sslOptions = {
  key: fs.readFileSync(process.env.SSL_KEY_PATH),
  cert: fs.readFileSync(process.env.SSL_CERT_PATH)
};

11. 本番環境へのデプロイ

本番環境では、Node.js アプリケーションの前に Nginx や Apache などの リバースプロキシ を配置することを推奨します。これにより、以下のメリットが得られます。

SSL/TLS ターミネーションの効率化
ロードバランシング（負荷分散）
静的ファイルの高速な提供
リクエストのキャッシュ
レート制限
より高度なセキュリティヘッダー管理

11.1 Nginx 設定例

server {
    listen 443 ssl http2;
    server_name yourdomain.com;

    # SSL 設定
    ssl_certificate /path/to/your/cert.pem;
    ssl_certificate_key /path/to/your/key.pem;

    # セキュリティヘッダー
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-XSS-Protection "1; mode=block" always;

    # Node.js アプリへのプロキシ
    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    # 静的ファイルの直接提供
    location /static/ {
        root /path/to/your/app/public;
        expires 30d;
        access_log off;
    }
}

# HTTP から HTTPS へのリダイレクト
server {
    listen 80;
    server_name yourdomain.com;
    return 301 https://$host$request_uri;
}

11.2 HTTPS を使用した Express.js のベストプラクティス

セキュリティヘッダーのために常に helmet ミドルウェアを使用してください。
セッションを使用する場合は、セキュアなセッションオプション（Secure, HttpOnly）を設定します。
設定には環境変数を使用します。
適切なエラーハンドリングとログ記録を実装します。
本番環境ではリバースプロキシを使用します。
依存関係を最新に保ちます。
パフォーマンス向上のため、HTTP/2 を利用します。
悪用を防ぐためにレート制限を実装します。
API が異なるドメインからアクセスされる場合は、cors ミドルウェアを使用します。

12. Node.js での HTTP/2

HTTP/2 は HTTP プロトコルの大規模な改訂版であり、HTTP/1.1 と比較して大幅なパフォーマンス向上が期待できます。HTTPS と組み合わせることで、モダンな Web アプリケーションにセキュリティとパフォーマンスの両方のメリットをもたらします。

12.1 HTTP/2 のメリット

マルチプレクシング (Multiplexing): 1つの接続で複数のリクエスト/レスポンスを並行して送信でき、ヘッドオブラインブロッキングを解消します。
ヘッダー圧縮 (Header Compression): HPACK アルゴリズムにより HTTP ヘッダーを圧縮し、オーバーヘッドを削減します。
サーバープッシュ (Server Push): クライアントが要求する前に、サーバーがリソースを能動的に送信できます。
バイナリプロトコル: テキストベースの HTTP/1.1 よりもパース効率が向上しています。

12.2 HTTP/2 サーバーの例

const http2 = require('http2');
const fs = require('fs');
const path = require('path');

const serverOptions = {
  key: fs.readFileSync(path.join(__dirname, 'key.pem')),
  cert: fs.readFileSync(path.join(__dirname, 'cert.pem')),
  allowHTTP1: true, // 必要に応じて HTTP/1.1 へのフォールバックを許可

  minVersion: 'TLSv1.2',
  ciphers: [
    'TLS_AES_256_GCM_SHA384',
    'TLS_CHACHA20_POLY1305_SHA256',
    'TLS_AES_128_GCM_SHA256',
    'ECDHE-ECDSA-AES256-GCM-SHA384',
    '!aNULL', '!eNULL', '!EXPORT', '!DES', '!RC4', '!3DES', '!MD5', '!PSK'
  ].join(':'),
  honorCipherOrder: true
};

// HTTP/2 サーバーを作成
const server = http2.createSecureServer(serverOptions);

server.on('stream', (stream, headers) => {
  const method = headers[':method'];
  const path = headers[':path'];

  console.log(`${method} ${path} (HTTP/2)`);

  if (path === '/') {
    stream.respond({
      'content-type': 'text/html; charset=utf-8',
      ':status': 200,
      'x-powered-by': 'Node.js HTTP/2'
    });

    stream.end(`
      <!DOCTYPE html>
      <html>
      <head><title>HTTP/2 Server</title></head>
      <body>
        <h1>HTTP/2 サーバーからの挨拶！</h1>
        <p>このページは HTTP/2 で提供されています。</p>
      </body>
      </html>
    `);
  } else if (path === '/api/data') {
    stream.respond({
      'content-type': 'application/json',
      ':status': 200
    });
    stream.end(JSON.stringify({ message: 'HTTP/2 API からのデータ' }));
  } else {
    stream.respond({ ':status': 404 });
    stream.end('404 Not Found');
  }
});

const PORT = process.env.PORT || 8443;
server.listen(PORT, () => {
  console.log(`HTTP/2 サーバーが https://localhost:${PORT} で稼働中`);
});

12.3 Express.js での HTTP/2

Express.js で HTTP/2 を使用するには、spdy パッケージを利用するのが一般的です。

npm install spdy --save

const express = require('express');
const spdy = require('spdy');
const fs = require('fs');
const path = require('path');

const app = express();

app.get('/', (req, res) => {
  res.send('HTTP/2 を介した Express からの挨拶！');
});

const options = {
  key: fs.readFileSync(path.join(__dirname, 'key.pem')),
  cert: fs.readFileSync(path.join(__dirname, 'cert.pem')),
  spdy: {
    protocols: ['h2', 'http/1.1'],
    plain: false,
    'x-forwarded-for': true
  }
};

const PORT = 3000;
spdy.createServer(options, app).listen(PORT, () => {
  console.log(`HTTP/2 対応の Express サーバーがポート ${PORT} で稼働中`);
});

12.4 HTTP/2 サポートのテスト

curl を使用: curl -I --http2 https://localhost:8443
ブラウザの DevTools を使用: Network タブで「Protocol」カラムを有効にし、「h2」と表示されているか確認します。

13. HTTP と HTTPS の比較

機能	HTTP	HTTPS
データの暗号化	なし (プレーンテキスト)	あり (暗号化)
サーバー認証	なし	あり (証明書経由)
データの整合性	保護なし	保護あり (改ざん検知)
デフォルトポート	80	443
パフォーマンス	高速	わずかなオーバーヘッド (HTTP/2 で最適化)
SEO ランキング	低い	高い (Google が推奨)
セットアップ複雑度	単純	複雑 (証明書が必要)

14. まとめとベストプラクティス

本ガイドでは、Node.js の HTTPS モジュールを使用したセキュアな Web アプリケーション構築について学びました。

14.1 主要なポイント

HTTPS は必須: モダンな Web 開発において、データセキュリティ、ユーザーのプライバシー、および Web 標準への準拠のために HTTPS は不可欠です。
証明書管理: 開発用の自己署名証明書から、本番用の信頼された CA 証明書まで、適切に管理してください。
セキュリティ第一: 適切な TLS 設定、セキュアヘッダー、入力検証を含むセキュリティのベストプラクティスを常に実装しましょう。
パフォーマンスの活用: マルチプレクシングやヘッダー圧縮などの機能を持つ HTTP/2 を活用してパフォーマンスを向上させます。
本番環境の準備: 本番環境では Nginx などのリバースプロキシを使用し、セキュリティ、パフォーマンス、信頼性を高めてください。

14.2 セキュリティチェックリスト

TLS 1.2 以上を使用（1.3 推奨）
HSTS の実装
脆弱な暗号スイートの無効化
Node.js と依存関係の更新
セキュアクッキーフラグ（Secure, HttpOnly, SameSite）の設定
コンテンツセキュリティポリシー（CSP）ヘッダーの使用
レート制限とリクエスト検証の実装

セキュリティは継続的なプロセスです。定期的にアプリケーションを監査し、依存関係を更新し、最新のセキュリティ情報に常に耳を傾けるようにしましょう。