배포

cd api
pnpm build

cd web
pnpm build

cd api
NODE_ENV=production node dist/index.js

pm2 start dist/index.js --name sonamu-api

# nginx.conf
server {
  listen 80;
  server_name example.com;

  root /var/www/sonamu/web/dist;
  index index.html;

  location / {
    try_files $uri $uri/ /index.html;
  }

  location /api {
    proxy_pass http://localhost:34900;
    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;
  }
}

# api/.env.production

# Database (SONAMU_DB_ 접두사 사용)
SONAMU_DB_HOST=prod-db.example.com
SONAMU_DB_PORT=5432
SONAMU_DB_NAME=myapp_production
SONAMU_DB_USER=postgres
SONAMU_DB_PASSWORD=secure_password

# Server
PORT=34900

# CORS
CORS_ORIGIN=https://example.com

# Cache (Redis)
REDIS_HOST=redis.example.com
REDIS_PORT=6379
REDIS_PASSWORD=redis_password

import { defineConfig } from "sonamu";

export default defineConfig({
  // ...
  database: {
    database: "pg",
    defaultOptions: {
      pool: { min: 2, max: 10 },
    },
  },
  server: {
    listen: {
      port: Number(process.env.PORT) || 34900,
    },
    // ...
  },
});

# .env 파일은 .gitignore에 추가
echo ".env" >> .gitignore
echo ".env.*" >> .gitignore

// AWS Secrets Manager 예시
import { SecretsManager } from "@aws-sdk/client-secrets-manager";

const client = new SecretsManager({ region: "us-east-1" });

async function getSecret(secretName: string) {
  const response = await client.getSecretValue({ SecretId: secretName });
  return JSON.parse(response.SecretString!);
}

const dbSecret = await getSecret("prod/database");

NODE_ENV=production pnpm sonamu migrate status

NODE_ENV=production pnpm sonamu migrate shadow-test

NODE_ENV=production pnpm sonamu migrate run

NODE_ENV=production pnpm sonamu migrate rollback

# 수동 백업
pg_dump -h prod-db.example.com -U postgres -d sonamu_prod > backup.sql

# 압축 백업
pg_dump -h prod-db.example.com -U postgres -d sonamu_prod | gzip > backup.sql.gz

# 복원
gunzip < backup.sql.gz | psql -h prod-db.example.com -U postgres -d sonamu_prod

# crontab -e
# 매일 새벽 2시 백업
0 2 * * * /usr/bin/pg_dump -h prod-db.example.com -U postgres sonamu_prod | gzip > /backups/sonamu_$(date +\%Y\%m\%d).sql.gz

# 30일 이상 된 백업 삭제
0 3 * * * find /backups -name "sonamu_*.sql.gz" -mtime +30 -delete

// sonamu.config.ts
import winston from "winston";

export default {
  server: {
    logger: winston.createLogger({
      level: process.env.LOG_LEVEL || "info",
      format: winston.format.json(),
      transports: [
        new winston.transports.File({
          filename: "logs/error.log",
          level: "error",
        }),
        new winston.transports.File({
          filename: "logs/combined.log",
        }),
      ],
    }),
  },
} satisfies SonamuConfig;

class UserModelClass extends BaseModelClass {
  @api({ httpMethod: "POST" })
  async createUser(params: UserSaveParams): Promise<User> {
    this.logger.info("Creating user", { email: params.email });

    try {
      const user = await this.save(params);
      this.logger.info("User created", { userId: user.id });
      return user;
    } catch (error) {
      this.logger.error("Failed to create user", { error, params });
      throw error;
    }
  }
}

// health.frame.ts
import { BaseFrameClass, api } from "sonamu";

class HealthFrameClass extends BaseFrameClass {
  @api({ httpMethod: "GET" }) // guards 생략 = 공개 API
  async healthCheck(): Promise<{
    status: string;
    timestamp: Date;
    uptime: number;
    database: string;
  }> {
    // DB 연결 확인
    let databaseStatus = "ok";
    try {
      await this.getDB("r").raw("SELECT 1");
    } catch (error) {
      databaseStatus = "error";
    }

    return {
      status: databaseStatus === "ok" ? "healthy" : "unhealthy",
      timestamp: new Date(),
      uptime: process.uptime(),
      database: databaseStatus,
    };
  }
}

export const HealthFrame = new HealthFrameClass();

// sonamu.config.ts
import * as Sentry from "@sentry/node";

if (process.env.NODE_ENV === "production") {
  Sentry.init({
    dsn: process.env.SENTRY_DSN,
    environment: process.env.NODE_ENV,
    tracesSampleRate: 1.0,
  });
}

export default {
  server: {
    lifecycle: {
      async onStart() {
        console.log("Server started");
      },
      async onError(error: Error) {
        if (process.env.NODE_ENV === "production") {
          Sentry.captureException(error);
        }
      },
    },
  },
} satisfies SonamuConfig;

export default {
  database: {
    connections: {
      main: {
        pool: {
          min: 2,
          max: 10,
          acquireTimeoutMillis: 30000,
          idleTimeoutMillis: 30000,
        },
      },
    },
  },
} satisfies SonamuConfig;

import { bentostore } from "bentocache";
import { redisDriver } from "bentocache/drivers/redis";

export default {
  server: {
    cache: {
      default: "redis",
      stores: {
        redis: bentostore().useL1Layer(
          redisDriver({
            connection: {
              host: process.env.REDIS_HOST,
              port: 6379,
            },
          }),
        ),
      },
    },
  },
} satisfies SonamuConfig;

import compress from "@fastify/compress";

export default {
  server: {
    lifecycle: {
      async onStart(fastify) {
        await fastify.register(compress);
      },
    },
  },
} satisfies SonamuConfig;

server {
  # ...

  location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg|woff|woff2|ttf)$ {
    expires 1y;
    add_header Cache-Control "public, immutable";
  }
}

# api/Dockerfile
FROM node:18-alpine

WORKDIR /app

# pnpm 설치
RUN npm install -g pnpm

# Dependencies 복사 및 설치
COPY package.json pnpm-lock.yaml ./
RUN pnpm install --frozen-lockfile

# 소스 코드 복사
COPY . .

# 빌드
RUN pnpm build

# 프로덕션 모드로 실행
ENV NODE_ENV=production
EXPOSE 34900

CMD ["node", "dist/index.js"]

version: "3.8"

services:
  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: sonamu_prod
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

  api:
    build: ./api
    environment:
      NODE_ENV: production
      SONAMU_DB_HOST: postgres
      SONAMU_DB_PORT: 5432
      SONAMU_DB_NAME: sonamu_production
      SONAMU_DB_USER: postgres
      SONAMU_DB_PASSWORD: ${SONAMU_DB_PASSWORD}
      REDIS_HOST: redis
      REDIS_PORT: 6379
    ports:
      - "34900:34900"
    depends_on:
      - postgres
      - redis

  web:
    build: ./web
    ports:
      - "80:80"
    depends_on:
      - api

volumes:
  postgres_data:

docker-compose up -d

name: Deploy

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v3

      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: "18"

      - name: Install pnpm
        run: npm install -g pnpm

      - name: Install dependencies
        run: pnpm install

      - name: Run tests
        run: pnpm test

      - name: Build
        run: pnpm build

      - name: Deploy to server
        uses: appleboy/ssh-action@master
        with:
          host: ${{ secrets.SERVER_HOST }}
          username: ${{ secrets.SERVER_USER }}
          key: ${{ secrets.SSH_PRIVATE_KEY }}
          script: |
            cd /var/www/sonamu
            git pull
            pnpm install
            pnpm build
            pm2 restart sonamu-api

# Certbot 설치
sudo apt install certbot python3-certbot-nginx

# 인증서 발급
sudo certbot --nginx -d example.com -d www.example.com

# 자동 갱신 테스트
sudo certbot renew --dry-run

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

  ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
  ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;

  ssl_protocols TLSv1.2 TLSv1.3;
  ssl_ciphers HIGH:!aNULL:!MD5;

  # ...
}

# HTTP to HTTPS 리다이렉트
server {
  listen 80;
  server_name example.com;
  return 301 https://$server_name$request_uri;
}

// sonamu.config.ts
export default {
  server: {
    cors: {
      origin: process.env.CORS_ORIGIN || "http://localhost:5173",
      credentials: true,
      methods: ["GET", "POST", "PUT", "DELETE", "PATCH"],
    },
  },
} satisfies SonamuConfig;

import rateLimit from "@fastify/rate-limit";

export default {
  server: {
    lifecycle: {
      async onStart(fastify) {
        await fastify.register(rateLimit, {
          max: 100, // 100 requests
          timeWindow: "1 minute",
        });
      },
    },
  },
} satisfies SonamuConfig;