# .env でポートを変数化する例
# .env
POSTGRES_PORT=5432
REDIS_PORT=6379
MAIL_SMTP_PORT=1025
MAIL_UI_PORT=8025
MINIO_API_PORT=9000
MINIO_CONSOLE_PORT=9001

# docker-compose.yml
services:
  postgres:
    image: postgres:16-alpine
    ports:
      - "${POSTGRES_PORT:-5432}:5432"
 
  redis:
    image: redis:7-alpine
    ports:
      - "${REDIS_PORT:-6379}:6379"

# docker-compose.yml
services:
  postgres:
    image: postgres:16-alpine
    container_name: myapp-postgres
    restart: unless-stopped
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: myapp_development
      POSTGRES_INITDB_ARGS: "--encoding=UTF-8 --lc-collate=C --lc-ctype=C"
      TZ: Asia/Tokyo
    ports:
      - "5432:5432"
    volumes:
      - pgdata:/var/lib/postgresql/data
      - ./docker/postgres/init:/docker-entrypoint-initdb.d
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 5
      start_period: 10s
 
volumes:
  pgdata:
    driver: local

-- docker/postgres/init/01-create-databases.sql
-- 開発用・テスト用の DB を自動作成
 
CREATE DATABASE myapp_test;
 
-- テスト用ユーザー
CREATE USER test_user WITH PASSWORD 'test_password';
GRANT ALL PRIVILEGES ON DATABASE myapp_test TO test_user;
 
-- 拡張機能のインストール
\c myapp_development
CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
CREATE EXTENSION IF NOT EXISTS "pgcrypto";
CREATE EXTENSION IF NOT EXISTS "pg_trgm";
CREATE EXTENSION IF NOT EXISTS "citext";
CREATE EXTENSION IF NOT EXISTS "hstore";
 
\c myapp_test
CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
CREATE EXTENSION IF NOT EXISTS "pgcrypto";

#!/bin/bash
# docker/postgres/init/02-seed-data.sh
set -e
 
psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" --dbname myapp_development <<-EOSQL
  INSERT INTO users (name, email) VALUES
    ('開発太郎', 'dev@example.com'),
    ('テスト花子', 'test@example.com')
  ON CONFLICT DO NOTHING;
EOSQL

-- docker/postgres/init/03-create-schemas.sql
-- マルチテナント用スキーマ分離パターン
 
\c myapp_development
 
-- テナントごとのスキーマ
CREATE SCHEMA IF NOT EXISTS tenant_demo;
CREATE SCHEMA IF NOT EXISTS tenant_test;
 
-- 共有テーブル（public スキーマ）
CREATE TABLE IF NOT EXISTS public.tenants (
    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
    name TEXT NOT NULL,
    schema_name TEXT NOT NULL UNIQUE,
    created_at TIMESTAMPTZ DEFAULT NOW()
);
 
INSERT INTO public.tenants (name, schema_name) VALUES
    ('Demo Company', 'tenant_demo'),
    ('Test Company', 'tenant_test')
ON CONFLICT DO NOTHING;

# docker/postgres/postgresql.conf (開発用に最適化)
# パフォーマンス (開発マシン向け)
shared_buffers = 256MB
work_mem = 16MB
maintenance_work_mem = 128MB
effective_cache_size = 512MB
 
# WAL 設定 (開発用)
wal_buffers = 16MB
checkpoint_completion_target = 0.9
max_wal_size = 1GB
 
# ログ (デバッグしやすく)
log_statement = 'all'
log_duration = on
log_min_duration_statement = 100
log_line_prefix = '%t [%p] %u@%d '
log_lock_waits = on
log_temp_files = 0
 
# 開発用設定 (本番では使わない)
fsync = off
synchronous_commit = off
full_page_writes = off
 
# 接続設定
max_connections = 100

services:
  postgres:
    image: postgres:16-alpine
    command: >
      postgres
        -c config_file=/etc/postgresql/postgresql.conf
    volumes:
      - pgdata:/var/lib/postgresql/data
      - ./docker/postgres/postgresql.conf:/etc/postgresql/postgresql.conf:ro
      - ./docker/postgres/init:/docker-entrypoint-initdb.d

# バックアップ（ダンプ）
docker compose exec postgres pg_dump -U postgres -d myapp_development \
  --format=custom --file=/tmp/backup.dump
 
# ホストにコピー
docker compose cp postgres:/tmp/backup.dump ./backups/
 
# リストア
docker compose cp ./backups/backup.dump postgres:/tmp/
docker compose exec postgres pg_restore -U postgres -d myapp_development \
  --clean --if-exists /tmp/backup.dump
 
# テキスト形式でのダンプ（Git 管理しやすい）
docker compose exec postgres pg_dump -U postgres -d myapp_development \
  --schema-only --no-owner --no-privileges > ./docker/postgres/schema.sql
 
# データのみダンプ
docker compose exec postgres pg_dump -U postgres -d myapp_development \
  --data-only --inserts > ./docker/postgres/seed-data.sql

# 実行中のクエリを確認
docker compose exec postgres psql -U postgres -d myapp_development -c \
  "SELECT pid, now() - pg_stat_activity.query_start AS duration, query, state
   FROM pg_stat_activity
   WHERE state != 'idle' AND query NOT ILIKE '%pg_stat_activity%'
   ORDER BY duration DESC;"
 
# テーブルサイズの確認
docker compose exec postgres psql -U postgres -d myapp_development -c \
  "SELECT schemaname, tablename,
          pg_size_pretty(pg_total_relation_size(schemaname || '.' || tablename)) AS total_size
   FROM pg_tables
   WHERE schemaname = 'public'
   ORDER BY pg_total_relation_size(schemaname || '.' || tablename) DESC;"
 
# インデックスの使用状況
docker compose exec postgres psql -U postgres -d myapp_development -c \
  "SELECT relname, indexrelname, idx_scan, idx_tup_read, idx_tup_fetch
   FROM pg_stat_user_indexes
   ORDER BY idx_scan ASC;"
 
# コネクション数の確認
docker compose exec postgres psql -U postgres -c \
  "SELECT count(*), state FROM pg_stat_activity GROUP BY state;"

# docker-compose.yml に追加
services:
  pgadmin:
    image: dpage/pgadmin4:latest
    container_name: myapp-pgadmin
    restart: unless-stopped
    environment:
      PGADMIN_DEFAULT_EMAIL: admin@example.com
      PGADMIN_DEFAULT_PASSWORD: admin
      PGADMIN_LISTEN_PORT: 5050
    ports:
      - "5050:5050"
    volumes:
      - pgadmin_data:/var/lib/pgadmin
      - ./docker/pgadmin/servers.json:/pgadmin4/servers.json:ro
    depends_on:
      postgres:
        condition: service_healthy
 
volumes:
  pgadmin_data:

// docker/pgadmin/servers.json (自動接続設定)
{
  "Servers": {
    "1": {
      "Name": "Local Development",
      "Group": "Development",
      "Host": "postgres",
      "Port": 5432,
      "MaintenanceDB": "postgres",
      "Username": "postgres",
      "SSLMode": "prefer",
      "PassFile": "/tmp/pgpassfile"
    }
  }
}

# docker-compose.yml (MySQL 版)
services:
  mysql:
    image: mysql:8.0
    container_name: myapp-mysql
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: myapp_development
      MYSQL_USER: developer
      MYSQL_PASSWORD: developer
      TZ: Asia/Tokyo
    ports:
      - "3306:3306"
    volumes:
      - mysqldata:/var/lib/mysql
      - ./docker/mysql/init:/docker-entrypoint-initdb.d
      - ./docker/mysql/my.cnf:/etc/mysql/conf.d/custom.cnf
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 5s
      timeout: 5s
      retries: 5
    command: >
      --default-authentication-plugin=mysql_native_password
      --character-set-server=utf8mb4
      --collation-server=utf8mb4_unicode_ci
 
volumes:
  mysqldata:
    driver: local

# docker/mysql/my.cnf
[mysqld]
# 文字コード
character-set-server = utf8mb4
collation-server = utf8mb4_unicode_ci
 
# パフォーマンス (開発用)
innodb_buffer_pool_size = 256M
innodb_log_file_size = 64M
innodb_flush_log_at_trx_commit = 0
sync_binlog = 0
innodb_flush_method = O_DIRECT
 
# ログ
general_log = 1
general_log_file = /var/log/mysql/general.log
slow_query_log = 1
slow_query_log_file = /var/log/mysql/slow.log
long_query_time = 1
 
# タイムゾーン
default-time-zone = '+09:00'
 
# 接続設定
max_connections = 100
wait_timeout = 28800
interactive_timeout = 28800
 
[client]
default-character-set = utf8mb4

-- docker/mysql/init/01-create-databases.sql
CREATE DATABASE IF NOT EXISTS myapp_test
  CHARACTER SET utf8mb4
  COLLATE utf8mb4_unicode_ci;
 
-- テスト用ユーザーに権限付与
GRANT ALL PRIVILEGES ON myapp_test.* TO 'developer'@'%';
FLUSH PRIVILEGES;

-- docker/mysql/init/02-create-tables.sql
USE myapp_development;
 
CREATE TABLE IF NOT EXISTS users (
    id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    email VARCHAR(255) NOT NULL UNIQUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    INDEX idx_email (email),
    INDEX idx_created_at (created_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

# バックアップ
docker compose exec mysql mysqldump -u root -proot \
  --single-transaction --routines --triggers \
  myapp_development > ./backups/mysql_backup.sql
 
# リストア
docker compose exec -T mysql mysql -u root -proot \
  myapp_development < ./backups/mysql_backup.sql
 
# 特定のテーブルのみダンプ
docker compose exec mysql mysqldump -u root -proot \
  myapp_development users orders > ./backups/partial_backup.sql
 
# スキーマのみダンプ
docker compose exec mysql mysqldump -u root -proot \
  --no-data myapp_development > ./docker/mysql/schema.sql

# MySQL 8.4 LTS 対応
services:
  mysql:
    image: mysql:8.4
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: myapp_development
    # mysql_native_password は非推奨
    # アプリケーションの MySQL クライアントが caching_sha2_password に対応しているか確認
    command: >
      --character-set-server=utf8mb4
      --collation-server=utf8mb4_unicode_ci

# docker-compose.yml に追加
services:
  redis:
    image: redis:7-alpine
    container_name: myapp-redis
    restart: unless-stopped
    ports:
      - "6379:6379"
    volumes:
      - ./docker/redis/redis.conf:/usr/local/etc/redis/redis.conf
    command: redis-server /usr/local/etc/redis/redis.conf
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 3s
      retries: 5

# docker/redis/redis.conf (開発用)
# メモリ制限
maxmemory 128mb
maxmemory-policy allkeys-lru
 
# 永続化 (開発では不要なら off)
save ""
appendonly no
 
# ログ
loglevel verbose
 
# パスワード (開発環境)
# requirepass dev_redis_password
 
# キーの有効期限通知（Pub/Sub で期限切れイベントを受け取る）
notify-keyspace-events Ex

# docker/redis/redis-session.conf
# セッションデータは永続化が必要
save 60 1000
save 300 100
appendonly yes
appendfsync everysec
 
maxmemory 256mb
maxmemory-policy volatile-lru

# docker/redis/redis-cache.conf
# キャッシュは永続化不要
save ""
appendonly no
 
maxmemory 512mb
maxmemory-policy allkeys-lfu

# docker/redis/redis-queue.conf
# ジョブデータの永続化が必要
save 60 1
appendonly yes
appendfsync everysec
 
maxmemory 256mb
maxmemory-policy noeviction  # キューデータは削除しない

# Redis の情報を表示
docker compose exec redis redis-cli INFO
 
# メモリ使用状況
docker compose exec redis redis-cli INFO memory
 
# リアルタイムのコマンド監視
docker compose exec redis redis-cli MONITOR
 
# キーの一覧（開発環境のみ）
docker compose exec redis redis-cli KEYS "*"
 
# 特定のキーの内容を確認
docker compose exec redis redis-cli GET "session:abc123"
docker compose exec redis redis-cli HGETALL "user:1"
 
# キーの有効期限を確認
docker compose exec redis redis-cli TTL "cache:products"
 
# 全キーの削除（開発環境のみ）
docker compose exec redis redis-cli FLUSHALL
 
# スロークエリの確認
docker compose exec redis redis-cli SLOWLOG GET 10

// config/redis.ts
import { Redis } from 'ioredis';
 
function createRedisClient(): Redis {
  const redisUrl = process.env.REDIS_URL || 'redis://localhost:6379';
 
  const client = new Redis(redisUrl, {
    maxRetriesPerRequest: 3,
    retryStrategy(times) {
      const delay = Math.min(times * 50, 2000);
      return delay;
    },
    // 接続が切れた場合の自動再接続
    reconnectOnError(err) {
      const targetError = 'READONLY';
      if (err.message.includes(targetError)) {
        return true;
      }
      return false;
    },
  });
 
  client.on('error', (err) => {
    console.error('Redis connection error:', err);
  });
 
  client.on('connect', () => {
    console.log('Redis connected');
  });
 
  return client;
}
 
export const redis = createRedisClient();

# docker-compose.yml に追加
services:
  redis-insight:
    image: redis/redisinsight:latest
    container_name: myapp-redis-insight
    restart: unless-stopped
    ports:
      - "5540:5540"
    volumes:
      - redisinsight_data:/data
    depends_on:
      redis:
        condition: service_healthy
 
volumes:
  redisinsight_data:

# docker-compose.yml に追加
services:
  mailpit:
    image: axllent/mailpit:latest
    container_name: myapp-mailpit
    restart: unless-stopped
    ports:
      - "1025:1025"    # SMTP サーバー
      - "8025:8025"    # Web UI
    environment:
      MP_SMTP_AUTH_ACCEPT_ANY: 1
      MP_SMTP_AUTH_ALLOW_INSECURE: 1
      MP_MAX_MESSAGES: 5000
      MP_DATABASE: /data/mailpit.db
      MP_SMTP_RELAY_CONFIG: ""
    volumes:
      - mailpit_data:/data
 
volumes:
  mailpit_data:

# docker-compose.yml に追加
services:
  mailhog:
    image: mailhog/mailhog:latest
    container_name: myapp-mailhog
    restart: unless-stopped
    ports:
      - "1025:1025"    # SMTP サーバー
      - "8025:8025"    # Web UI
    environment:
      MH_STORAGE: memory
      MH_SMTP_BIND_ADDR: 0.0.0.0:1025
      MH_UI_BIND_ADDR: 0.0.0.0:8025

// config/mail.ts
import nodemailer from 'nodemailer';
 
function createMailTransport() {
  if (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {
    // Mailpit / MailHog （SMTP 互換）
    return nodemailer.createTransport({
      host: process.env.SMTP_HOST || 'localhost',
      port: parseInt(process.env.SMTP_PORT || '1025'),
      secure: false,
      // Mailpit / MailHog は認証不要
      tls: {
        rejectUnauthorized: false,
      },
    });
  }
 
  // 本番環境
  return nodemailer.createTransport({
    host: process.env.SMTP_HOST,
    port: parseInt(process.env.SMTP_PORT || '587'),
    secure: process.env.SMTP_SECURE === 'true',
    auth: {
      user: process.env.SMTP_USER,
      pass: process.env.SMTP_PASS,
    },
  });
}
 
export const mailTransport = createMailTransport();

# config/mail.py (Python / Django)
import os
 
if os.getenv('ENVIRONMENT', 'development') == 'development':
    EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
    EMAIL_HOST = os.getenv('SMTP_HOST', 'localhost')
    EMAIL_PORT = int(os.getenv('SMTP_PORT', '1025'))
    EMAIL_USE_TLS = False
    EMAIL_HOST_USER = ''
    EMAIL_HOST_PASSWORD = ''
else:
    EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
    EMAIL_HOST = os.getenv('SMTP_HOST')
    EMAIL_PORT = int(os.getenv('SMTP_PORT', '587'))
    EMAIL_USE_TLS = True
    EMAIL_HOST_USER = os.getenv('SMTP_USER')
    EMAIL_HOST_PASSWORD = os.getenv('SMTP_PASS')

// tests/helpers/mail.ts
interface MailpitMessage {
  ID: string;
  From: { Address: string; Name: string };
  To: { Address: string; Name: string }[];
  Subject: string;
  Snippet: string;
  Created: string;
}
 
interface MailpitSearchResult {
  total: number;
  messages: MailpitMessage[];
}
 
export async function waitForEmail(
  to: string,
  subject?: string,
  timeout = 10000
): Promise<MailpitMessage> {
  const startTime = Date.now();
  const mailpitUrl = process.env.MAILPIT_URL || 'http://localhost:8025';
 
  while (Date.now() - startTime < timeout) {
    const query = subject
      ? `to:${to} subject:"${subject}"`
      : `to:${to}`;
 
    const res = await fetch(
      `${mailpitUrl}/api/v1/search?query=${encodeURIComponent(query)}`
    );
    const data: MailpitSearchResult = await res.json();
 
    if (data.total > 0) {
      return data.messages[0];
    }
 
    await new Promise((resolve) => setTimeout(resolve, 500));
  }
 
  throw new Error(`Email not received within ${timeout}ms`);
}
 
export async function getEmailHtml(messageId: string): Promise<string> {
  const mailpitUrl = process.env.MAILPIT_URL || 'http://localhost:8025';
  const res = await fetch(`${mailpitUrl}/api/v1/message/${messageId}`);
  const data = await res.json();
  return data.HTML;
}
 
export async function deleteAllEmails(): Promise<void> {
  const mailpitUrl = process.env.MAILPIT_URL || 'http://localhost:8025';
  await fetch(`${mailpitUrl}/api/v1/messages`, { method: 'DELETE' });
}

// tests/e2e/password-reset.test.ts
import { test, expect } from '@playwright/test';
import { waitForEmail, getEmailHtml, deleteAllEmails } from '../helpers/mail';
 
test.beforeEach(async () => {
  await deleteAllEmails();
});
 
test('パスワードリセットメールが送信される', async ({ page }) => {
  // パスワードリセットを要求
  await page.goto('/forgot-password');
  await page.fill('[name="email"]', 'user@example.com');
  await page.click('button[type="submit"]');
 
  // メールが届くまで待機
  const email = await waitForEmail('user@example.com', 'パスワードリセット');
 
  expect(email.Subject).toContain('パスワードリセット');
 
  // メール本文からリセットリンクを取得
  const html = await getEmailHtml(email.ID);
  const resetLink = html.match(/href="([^"]*reset-password[^"]*)"/)?.[1];
 
  expect(resetLink).toBeTruthy();
 
  // リセットリンクにアクセス
  await page.goto(resetLink!);
  await expect(page.locator('h1')).toContainText('新しいパスワード');
});

# docker-compose.yml に追加
services:
  minio:
    image: minio/minio:latest
    container_name: myapp-minio
    restart: unless-stopped
    environment:
      MINIO_ROOT_USER: minioadmin
      MINIO_ROOT_PASSWORD: minioadmin
    ports:
      - "9000:9000"    # API
      - "9001:9001"    # Console
    volumes:
      - miniodata:/data
    command: server /data --console-address ":9001"
    healthcheck:
      test: ["CMD", "mc", "ready", "local"]
      interval: 5s
      timeout: 5s
      retries: 5
 
  # 初期バケット作成
  minio-init:
    image: minio/mc:latest
    depends_on:
      minio:
        condition: service_healthy
    entrypoint: >
      /bin/sh -c "
      mc alias set local http://minio:9000 minioadmin minioadmin;
      mc mb local/uploads --ignore-existing;
      mc mb local/avatars --ignore-existing;
      mc mb local/documents --ignore-existing;
      mc anonymous set download local/avatars;
      mc ilm rule add local/uploads --expire-days 30;
      echo 'MinIO buckets initialized';
      "
 
volumes:
  miniodata:
    driver: local

// config/storage.ts
import { S3Client, PutObjectCommand, GetObjectCommand, DeleteObjectCommand } from '@aws-sdk/client-s3';
import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
 
function createStorageClient(): S3Client {
  if (process.env.NODE_ENV === 'development') {
    return new S3Client({
      endpoint: process.env.S3_ENDPOINT || 'http://localhost:9000',
      region: 'us-east-1',
      credentials: {
        accessKeyId: process.env.S3_ACCESS_KEY || 'minioadmin',
        secretAccessKey: process.env.S3_SECRET_KEY || 'minioadmin',
      },
      forcePathStyle: true, // MinIO ではパススタイル必須
    });
  }
 
  // 本番は通常の S3
  return new S3Client({ region: process.env.AWS_REGION || 'ap-northeast-1' });
}
 
export const storageClient = createStorageClient();
 
// ファイルアップロード
export async function uploadFile(
  bucket: string,
  key: string,
  body: Buffer | ReadableStream,
  contentType: string
): Promise<string> {
  await storageClient.send(
    new PutObjectCommand({
      Bucket: bucket,
      Key: key,
      Body: body,
      ContentType: contentType,
    })
  );
 
  if (process.env.NODE_ENV === 'development') {
    return `http://localhost:9000/${bucket}/${key}`;
  }
  return `https://${bucket}.s3.amazonaws.com/${key}`;
}
 
// 署名付き URL の生成
export async function getPresignedUrl(
  bucket: string,
  key: string,
  expiresIn = 3600
): Promise<string> {
  const command = new GetObjectCommand({ Bucket: bucket, Key: key });
  return getSignedUrl(storageClient, command, { expiresIn });
}
 
// ファイル削除
export async function deleteFile(bucket: string, key: string): Promise<void> {
  await storageClient.send(
    new DeleteObjectCommand({ Bucket: bucket, Key: key })
  );
}

# MinIO Client (mc) の設定
docker compose exec minio mc alias set local http://localhost:9000 minioadmin minioadmin
 
# バケット一覧
docker compose exec minio mc ls local
 
# バケット内のオブジェクト一覧
docker compose exec minio mc ls local/uploads --recursive
 
# ファイルのアップロード（ホストから）
docker compose exec minio mc cp /data/test.jpg local/uploads/test.jpg
 
# バケットのポリシー確認
docker compose exec minio mc anonymous get local/avatars
 
# バケットの統計情報
docker compose exec minio mc stat local/uploads
 
# 全オブジェクトの削除
docker compose exec minio mc rm --recursive --force local/uploads

services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.12.0
    container_name: myapp-elasticsearch
    environment:
      - discovery.type=single-node
      - xpack.security.enabled=false
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
    ports:
      - "9200:9200"
    volumes:
      - esdata:/usr/share/elasticsearch/data
    healthcheck:
      test: ["CMD-SHELL", "curl -f http://localhost:9200/_cluster/health || exit 1"]
      interval: 10s
      timeout: 5s
      retries: 5
 
  # Kibana (管理UI)
  kibana:
    image: docker.elastic.co/kibana/kibana:8.12.0
    container_name: myapp-kibana
    ports:
      - "5601:5601"
    environment:
      ELASTICSEARCH_HOSTS: '["http://elasticsearch:9200"]'
    depends_on:
      elasticsearch:
        condition: service_healthy
 
volumes:
  esdata:

services:
  meilisearch:
    image: getmeili/meilisearch:v1.6
    container_name: myapp-meilisearch
    restart: unless-stopped
    environment:
      MEILI_ENV: development
      MEILI_MASTER_KEY: dev_master_key
      MEILI_NO_ANALYTICS: true
    ports:
      - "7700:7700"
    volumes:
      - meilidata:/meili_data
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:7700/health"]
      interval: 5s
      timeout: 3s
      retries: 5
 
volumes:
  meilidata:

services:
  rabbitmq:
    image: rabbitmq:3.13-management-alpine
    container_name: myapp-rabbitmq
    restart: unless-stopped
    environment:
      RABBITMQ_DEFAULT_USER: guest
      RABBITMQ_DEFAULT_PASS: guest
    ports:
      - "5672:5672"    # AMQP
      - "15672:15672"  # Management UI
    volumes:
      - rabbitmq_data:/var/lib/rabbitmq
    healthcheck:
      test: ["CMD", "rabbitmq-diagnostics", "check_port_connectivity"]
      interval: 10s
      timeout: 5s
      retries: 5
 
volumes:
  rabbitmq_data:

services:
  mongodb:
    image: mongo:7.0
    container_name: myapp-mongodb
    restart: unless-stopped
    environment:
      MONGO_INITDB_ROOT_USERNAME: root
      MONGO_INITDB_ROOT_PASSWORD: root
      MONGO_INITDB_DATABASE: myapp_development
    ports:
      - "27017:27017"
    volumes:
      - mongodata:/data/db
      - ./docker/mongo/init:/docker-entrypoint-initdb.d
    healthcheck:
      test: ["CMD", "mongosh", "--eval", "db.adminCommand('ping')"]
      interval: 5s
      timeout: 3s
      retries: 5
 
  # Mongo Express (管理UI)
  mongo-express:
    image: mongo-express:latest
    container_name: myapp-mongo-express
    restart: unless-stopped
    ports:
      - "8081:8081"
    environment:
      ME_CONFIG_MONGODB_ADMINUSERNAME: root
      ME_CONFIG_MONGODB_ADMINPASSWORD: root
      ME_CONFIG_MONGODB_URL: mongodb://root:root@mongodb:27017/
      ME_CONFIG_BASICAUTH_USERNAME: admin
      ME_CONFIG_BASICAUTH_PASSWORD: admin
    depends_on:
      mongodb:
        condition: service_healthy
 
volumes:
  mongodata:

services:
  keycloak:
    image: quay.io/keycloak/keycloak:24.0
    container_name: myapp-keycloak
    restart: unless-stopped
    environment:
      KEYCLOAK_ADMIN: admin
      KEYCLOAK_ADMIN_PASSWORD: admin
      KC_DB: postgres
      KC_DB_URL: jdbc:postgresql://postgres:5432/keycloak
      KC_DB_USERNAME: postgres
      KC_DB_PASSWORD: postgres
    ports:
      - "8080:8080"
    command: start-dev
    depends_on:
      postgres:
        condition: service_healthy

services:
  localstack:
    image: localstack/localstack:latest
    container_name: myapp-localstack
    restart: unless-stopped
    environment:
      SERVICES: s3,sqs,sns,dynamodb,ses,lambda
      DEBUG: 1
      DEFAULT_REGION: ap-northeast-1
    ports:
      - "4566:4566"      # Gateway
      - "4510-4559:4510-4559"  # Service ports
    volumes:
      - localstack_data:/var/lib/localstack
      - /var/run/docker.sock:/var/run/docker.sock
      - ./docker/localstack/init:/etc/localstack/init/ready.d
 
volumes:
  localstack_data:

#!/bin/bash
# docker/localstack/init/init-aws.sh
# LocalStack 初期化スクリプト
 
# S3 バケット作成
awslocal s3 mb s3://uploads
awslocal s3 mb s3://avatars
 
# SQS キュー作成
awslocal sqs create-queue --queue-name email-queue
awslocal sqs create-queue --queue-name notification-queue
 
# DynamoDB テーブル作成
awslocal dynamodb create-table \
  --table-name Sessions \
  --attribute-definitions AttributeName=id,AttributeType=S \
  --key-schema AttributeName=id,KeyType=HASH \
  --billing-mode PAY_PER_REQUEST
 
echo "LocalStack initialization complete"

# docker-compose.yml (統合版)
services:
  postgres:
    image: postgres:16-alpine
    container_name: myapp-postgres
    restart: unless-stopped
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: myapp_development
      TZ: Asia/Tokyo
    ports:
      - "${POSTGRES_PORT:-5432}:5432"
    volumes:
      - pgdata:/var/lib/postgresql/data
      - ./docker/postgres/init:/docker-entrypoint-initdb.d
      - ./docker/postgres/postgresql.conf:/etc/postgresql/postgresql.conf:ro
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 5
    command: postgres -c config_file=/etc/postgresql/postgresql.conf
 
  redis:
    image: redis:7-alpine
    container_name: myapp-redis
    restart: unless-stopped
    ports:
      - "${REDIS_PORT:-6379}:6379"
    volumes:
      - ./docker/redis/redis.conf:/usr/local/etc/redis/redis.conf:ro
    command: redis-server /usr/local/etc/redis/redis.conf
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 3s
      retries: 5
 
  mailpit:
    image: axllent/mailpit:latest
    container_name: myapp-mailpit
    restart: unless-stopped
    ports:
      - "${MAIL_SMTP_PORT:-1025}:1025"
      - "${MAIL_UI_PORT:-8025}:8025"
    environment:
      MP_SMTP_AUTH_ACCEPT_ANY: 1
      MP_SMTP_AUTH_ALLOW_INSECURE: 1
      MP_MAX_MESSAGES: 5000
 
  minio:
    image: minio/minio:latest
    container_name: myapp-minio
    restart: unless-stopped
    environment:
      MINIO_ROOT_USER: minioadmin
      MINIO_ROOT_PASSWORD: minioadmin
    ports:
      - "${MINIO_API_PORT:-9000}:9000"
      - "${MINIO_CONSOLE_PORT:-9001}:9001"
    volumes:
      - miniodata:/data
    command: server /data --console-address ":9001"
    healthcheck:
      test: ["CMD", "mc", "ready", "local"]
      interval: 5s
      timeout: 5s
      retries: 5
 
  minio-init:
    image: minio/mc:latest
    depends_on:
      minio:
        condition: service_healthy
    restart: "no"
    entrypoint: >
      /bin/sh -c "
      mc alias set local http://minio:9000 minioadmin minioadmin;
      mc mb local/uploads --ignore-existing;
      mc mb local/avatars --ignore-existing;
      mc anonymous set download local/avatars;
      echo 'MinIO buckets initialized';
      "
 
volumes:
  pgdata:
  miniodata:

# docker-compose.yml (プロファイル対応)
services:
  postgres:
    image: postgres:16-alpine
    # ... (基本設定)
    profiles: ["db", "full"]
 
  mysql:
    image: mysql:8.0
    # ... (基本設定)
    profiles: ["mysql", "full"]
 
  redis:
    image: redis:7-alpine
    # ... (基本設定)
    profiles: ["cache", "full"]
 
  mailpit:
    image: axllent/mailpit:latest
    # ... (基本設定)
    profiles: ["mail", "full"]
 
  minio:
    image: minio/minio:latest
    # ... (基本設定)
    profiles: ["storage", "full"]
 
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.12.0
    # ... (基本設定)
    profiles: ["search", "full"]

# 必要なサービスだけ起動
docker compose --profile db --profile cache up -d
 
# 全サービス起動
docker compose --profile full up -d

# Makefile
.PHONY: up down restart logs status clean db-shell redis-shell psql
 
# サービスの起動
up:
	docker compose up -d
 
# サービスの停止
down:
	docker compose down
 
# サービスの再起動
restart:
	docker compose restart
 
# ログの表示
logs:
	docker compose logs -f
 
# 特定サービスのログ
logs-%:
	docker compose logs -f $*
 
# ステータス確認
status:
	docker compose ps
 
# データベースシェル
db-shell:
	docker compose exec postgres psql -U postgres -d myapp_development
 
# Redis シェル
redis-shell:
	docker compose exec redis redis-cli
 
# MySQL シェル
mysql-shell:
	docker compose exec mysql mysql -u root -proot myapp_development
 
# データベースのリセット
db-reset:
	docker compose down -v
	docker compose up -d postgres
	@echo "Waiting for PostgreSQL to be ready..."
	@sleep 5
	@echo "Database reset complete"
 
# 全データの削除
clean:
	docker compose down -v --remove-orphans
	docker volume prune -f
 
# バックアップ
backup:
	@mkdir -p backups
	docker compose exec postgres pg_dump -U postgres -d myapp_development \
		--format=custom > backups/backup_$(shell date +%Y%m%d_%H%M%S).dump
	@echo "Backup created"
 
# リストア (使用法: make restore FILE=backups/backup_xxx.dump)
restore:
	docker compose exec -T postgres pg_restore -U postgres -d myapp_development \
		--clean --if-exists < $(FILE)
	@echo "Restore complete"

services:
  app:
    build: .
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
      mailpit:
        condition: service_started  # ヘルスチェック不要なサービス
 
  postgres:
    image: postgres:16-alpine
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 5
      start_period: 10s  # 初期化中はチェックしない
 
  redis:
    image: redis:7-alpine
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 3s
      retries: 5

// lib/db.ts
import { PrismaClient } from '@prisma/client';
 
async function createPrismaClient(maxRetries = 5): Promise<PrismaClient> {
  const prisma = new PrismaClient();
 
  for (let i = 0; i < maxRetries; i++) {
    try {
      await prisma.$connect();
      console.log('Database connected');
      return prisma;
    } catch (error) {
      console.log(`Database connection attempt ${i + 1}/${maxRetries} failed`);
      if (i === maxRetries - 1) throw error;
      await new Promise((resolve) => setTimeout(resolve, 2000));
    }
  }
 
  throw new Error('Failed to connect to database');
}
 
export const prisma = await createPrismaClient();

# NG: Volume 未設定 → docker-compose down でデータ全消失
services:
  postgres:
    image: postgres:16-alpine
    # volumes が未設定
 
# OK: 名前付き Volume でデータを永続化
services:
  postgres:
    image: postgres:16-alpine
    volumes:
      - pgdata:/var/lib/postgresql/data
 
volumes:
  pgdata:
    driver: local

# NG: 本番の認証情報をそのまま使用
services:
  postgres:
    environment:
      POSTGRES_PASSWORD: ${PROD_DB_PASSWORD}  # 本番パスワード
 
# OK: 開発専用の固定パスワード
services:
  postgres:
    environment:
      POSTGRES_PASSWORD: postgres  # 開発専用

# NG: バインドマウント (I/O が遅い + 権限問題)
services:
  postgres:
    volumes:
      - ./data/postgres:/var/lib/postgresql/data
 
# OK: 名前付き Volume (高速 + 権限問題なし)
services:
  postgres:
    volumes:
      - pgdata:/var/lib/postgresql/data
 
volumes:
  pgdata:

# NG: ヘルスチェックなし → DB 起動前にアプリが接続を試みる
services:
  app:
    depends_on:
      - postgres  # コンテナ起動のみ保証
 
# OK: ヘルスチェックで起動完了を保証
services:
  app:
    depends_on:
      postgres:
        condition: service_healthy
 
  postgres:
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 5

# NG: バージョンが不定
services:
  postgres:
    image: postgres:latest
  redis:
    image: redis:latest
 
# OK: メジャーバージョンを固定
services:
  postgres:
    image: postgres:16-alpine
  redis:
    image: redis:7-alpine