🤔 왜 DB 연결에 SSL/TLS가 필요한가요?

일단 기본적으로 생각해봐요. 여러분이 애플리케이션 서버에서 데이터베이스로 쿼리를 날릴 때, 그 데이터가 네트워크를 타고 이동하잖아요? 만약 이 통신이 암호화되지 않은 평문(plaintext)으로 전송된다면 어떻게 될까요?

특히 클라우드 환경에서는 더 조심해야 해요. AWS RDS, Azure Database, Google Cloud SQL 같은 서비스 쓸 때 인터넷 구간을 거치는 경우가 많거든요. 사내 네트워크라고 해도 100% 안전하다고 장담할 수 없고요.

🔐 SSL과 TLS, 뭐가 다른 건가요?

많은 분들이 SSL과 TLS를 혼용해서 쓰는데, 사실 약간 다른 개념이에요. 간단히 정리해드릴게요 ㅋㅋ

그래서 정확히 말하면 "TLS를 사용한다"고 해야 하는데, 역사적인 이유로 아직도 많은 사람들이 "SSL"이라고 부르거나 "SSL/TLS"라고 함께 표기해요. 실무에서는 대부분 TLS 1.2 이상을 사용하고 있어요.

🛠️ SSL/TLS 작동 원리 (핸드셰이크 과정)

SSL/TLS가 어떻게 작동하는지 이해하면 설정할 때 훨씬 수월해요. 핸드셰이크(Handshake) 과정을 단계별로 설명해드릴게요 ㅎㅎ

이 과정이 처음 연결할 때 한 번 일어나고, 그 다음부터는 세션 키로 빠르게 암호화 통신을 하는 거예요. 그래서 첫 연결은 약간 느릴 수 있지만, 이후에는 성능 저하가 거의 없어요.

📋 주요 데이터베이스별 SSL/TLS 설정 방법

자, 이제 본격적으로 각 데이터베이스에서 SSL/TLS를 어떻게 설정하는지 알아볼게요. 실무에서 가장 많이 쓰는 DB들 위주로 설명드릴게요!

🐬 MySQL/MariaDB SSL 설정

MySQL은 5.7 버전부터 SSL을 기본으로 지원하고, 8.0부터는 자동으로 SSL 인증서를 생성해줘요. 하지만 프로덕션 환경에서는 직접 인증서를 관리하는 게 좋아요.

# CA 개인키 생성
openssl genrsa 2048 > ca-key.pem

# CA 인증서 생성 (자체 서명)
openssl req -new -x509 -nodes -days 3650 \
  -key ca-key.pem -out ca-cert.pem

# 서버 개인키 생성
openssl req -newkey rsa:2048 -days 3650 \
  -nodes -keyout server-key.pem -out server-req.pem

# 서버 인증서 생성
openssl x509 -req -in server-req.pem -days 3650 \
  -CA ca-cert.pem -CAkey ca-key.pem \
  -set_serial 01 -out server-cert.pem

# 클라이언트 개인키 생성
openssl req -newkey rsa:2048 -days 3650 \
  -nodes -keyout client-key.pem -out client-req.pem

# 클라이언트 인증서 생성
openssl x509 -req -in client-req.pem -days 3650 \
  -CA ca-cert.pem -CAkey ca-key.pem \
  -set_serial 01 -out client-cert.pem

[mysqld]
# SSL 인증서 경로 지정
ssl-ca=/path/to/ca-cert.pem
ssl-cert=/path/to/server-cert.pem
ssl-key=/path/to/server-key.pem

# SSL 필수로 설정 (선택사항)
require_secure_transport=ON

# TLS 버전 지정
tls_version=TLSv1.2,TLSv1.3

# 명령줄에서 연결
mysql -h hostname -u username -p \
  --ssl-ca=/path/to/ca-cert.pem \
  --ssl-cert=/path/to/client-cert.pem \
  --ssl-key=/path/to/client-key.pem

# 연결 후 SSL 사용 확인
mysql> SHOW STATUS LIKE 'Ssl_cipher';
+---------------+------------------------+
| Variable_name | Value                  |
+---------------+------------------------+
| Ssl_cipher    | TLS_AES_256_GCM_SHA384 |
+---------------+------------------------+

CREATE USER 'secureuser'@'%' IDENTIFIED BY 'password' REQUIRE SSL;

🐘 PostgreSQL SSL 설정

PostgreSQL도 SSL을 잘 지원해요. 설정 방법이 MySQL과 약간 다르니 주의하세요!

# 서버 개인키 생성
openssl genrsa -out server.key 2048
chmod 600 server.key

# 인증서 서명 요청 생성
openssl req -new -key server.key -out server.csr

# 자체 서명 인증서 생성 (또는 CA에서 서명받기)
openssl x509 -req -in server.csr -signkey server.key \
  -out server.crt -days 3650

# PostgreSQL 데이터 디렉토리로 복사
cp server.crt server.key /var/lib/postgresql/data/
chown postgres:postgres /var/lib/postgresql/data/server.*

# SSL 활성화
ssl = on

# 인증서 파일 경로
ssl_cert_file = 'server.crt'
ssl_key_file = 'server.key'
ssl_ca_file = 'root.crt'  # CA 인증서 (선택)

# TLS 버전 지정
ssl_min_protocol_version = 'TLSv1.2'
ssl_max_protocol_version = 'TLSv1.3'

# 암호화 알고리즘 지정
ssl_ciphers = 'HIGH:MEDIUM:+3DES:!aNULL'

# SSL 연결만 허용
hostssl    all    all    0.0.0.0/0    md5

# 클라이언트 인증서 검증 필요
hostssl    all    all    0.0.0.0/0    cert

# 특정 사용자는 SSL 필수
hostssl    securedb    secureuser    0.0.0.0/0    md5

# psql 명령줄
psql "host=hostname dbname=mydb user=myuser sslmode=require"

# 연결 문자열에서
postgresql://username:password@hostname:5432/dbname?sslmode=verify-full&sslrootcert=/path/to/ca.crt

# SSL 연결 확인
SELECT ssl_is_used();

🍃 MongoDB SSL 설정

MongoDB도 TLS/SSL을 지원하는데, 버전에 따라 설정 방법이 약간 달라요. 최신 버전 기준으로 설명할게요.

net:
  port: 27017
  ssl:
    mode: requireSSL
    PEMKeyFile: /path/to/mongodb.pem
    CAFile: /path/to/ca.pem
    allowConnectionsWithoutCertificates: false
    allowInvalidCertificates: false
    allowInvalidHostnames: false

# MongoDB는 인증서와 키를 하나의 PEM 파일로 합쳐야 해요
cat server.crt server.key > mongodb.pem
chmod 600 mongodb.pem

# mongo shell
mongo --ssl --host hostname \
  --sslCAFile /path/to/ca.pem \
  --sslPEMKeyFile /path/to/client.pem

# 연결 문자열
mongodb://username:password@hostname:27017/dbname?ssl=true&tlsCAFile=/path/to/ca.pem

🔴 Redis SSL/TLS 설정

Redis는 6.0 버전부터 네이티브 TLS를 지원해요. 그 전 버전에서는 stunnel 같은 프록시를 사용해야 했는데, 이제는 직접 지원하니까 훨씬 편해졌어요 ㅋㅋ

# TLS 포트 활성화
port 0
tls-port 6379

# 인증서 설정
tls-cert-file /path/to/redis.crt
tls-key-file /path/to/redis.key
tls-ca-cert-file /path/to/ca.crt

# 클라이언트 인증 필요 여부
tls-auth-clients yes

# TLS 버전
tls-protocols "TLSv1.2 TLSv1.3"

# 암호화 알고리즘
tls-ciphers DEFAULT:!MEDIUM:!LOW:!EXPORT:!aNULL

redis-cli --tls \
  --cert /path/to/client.crt \
  --key /path/to/client.key \
  --cacert /path/to/ca.crt \
  -h hostname -p 6379

💻 프로그래밍 언어별 SSL/TLS 연결 예제

이제 실제 애플리케이션 코드에서 어떻게 SSL/TLS로 DB에 연결하는지 알아볼게요. 주요 언어별로 예제를 준비했어요!

🐍 Python

import pymysql

connection = pymysql.connect(
    host='your-db-host.com',
    user='username',
    password='password',
    database='mydb',
    ssl={
        'ca': '/path/to/ca-cert.pem',
        'cert': '/path/to/client-cert.pem',
        'key': '/path/to/client-key.pem'
    },
    ssl_verify_cert=True,
    ssl_verify_identity=True
)

# 연결 확인
with connection.cursor() as cursor:
    cursor.execute("SHOW STATUS LIKE 'Ssl_cipher'")
    result = cursor.fetchone()
    print(f"SSL Cipher: {result}")

connection.close()

import psycopg2

connection = psycopg2.connect(
    host='your-db-host.com',
    database='mydb',
    user='username',
    password='password',
    sslmode='verify-full',
    sslrootcert='/path/to/ca.crt',
    sslcert='/path/to/client.crt',
    sslkey='/path/to/client.key'
)

# SSL 연결 확인
cursor = connection.cursor()
cursor.execute("SELECT ssl_is_used();")
print(f"SSL enabled: {cursor.fetchone()[0]}")

cursor.close()
connection.close()

from pymongo import MongoClient

client = MongoClient(
    'your-db-host.com',
    port=27017,
    username='username',
    password='password',
    tls=True,
    tlsCAFile='/path/to/ca.pem',
    tlsCertificateKeyFile='/path/to/client.pem',
    tlsAllowInvalidCertificates=False,
    tlsAllowInvalidHostnames=False
)

db = client['mydb']
print(f"Connected to: {client.server_info()}")

☕ Java

import java.sql.Connection;
import java.sql.DriverManager;
import java.util.Properties;

public class MySQLSSLConnection {
    public static void main(String[] args) {
        String url = "jdbc:mysql://your-db-host.com:3306/mydb";
        
        Properties props = new Properties();
        props.setProperty("user", "username");
        props.setProperty("password", "password");
        props.setProperty("useSSL", "true");
        props.setProperty("requireSSL", "true");
        props.setProperty("verifyServerCertificate", "true");
        props.setProperty("trustCertificateKeyStoreUrl", "file:/path/to/truststore.jks");
        props.setProperty("trustCertificateKeyStorePassword", "password");
        props.setProperty("clientCertificateKeyStoreUrl", "file:/path/to/keystore.jks");
        props.setProperty("clientCertificateKeyStorePassword", "password");
        
        try (Connection conn = DriverManager.getConnection(url, props)) {
            System.out.println("SSL connection established!");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

keytool -importcert -alias ca -file ca-cert.pem -keystore truststore.jks -storepass password

🟢 Node.js

const mysql = require('mysql2');
const fs = require('fs');

const connection = mysql.createConnection({
  host: 'your-db-host.com',
  user: 'username',
  password: 'password',
  database: 'mydb',
  ssl: {
    ca: fs.readFileSync('/path/to/ca-cert.pem'),
    cert: fs.readFileSync('/path/to/client-cert.pem'),
    key: fs.readFileSync('/path/to/client-key.pem'),
    rejectUnauthorized: true
  }
});

connection.connect((err) => {
  if (err) {
    console.error('Connection error:', err);
    return;
  }
  console.log('SSL connection established!');
  
  connection.query("SHOW STATUS LIKE 'Ssl_cipher'", (err, results) => {
    if (err) throw err;
    console.log('SSL Cipher:', results);
    connection.end();
  });
});

const { Client } = require('pg');
const fs = require('fs');

const client = new Client({
  host: 'your-db-host.com',
  port: 5432,
  database: 'mydb',
  user: 'username',
  password: 'password',
  ssl: {
    rejectUnauthorized: true,
    ca: fs.readFileSync('/path/to/ca.crt').toString(),
    cert: fs.readFileSync('/path/to/client.crt').toString(),
    key: fs.readFileSync('/path/to/client.key').toString()
  }
});

client.connect()
  .then(() => {
    console.log('SSL connection established!');
    return client.query('SELECT ssl_is_used();');
  })
  .then(result => {
    console.log('SSL enabled:', result.rows[0]);
    client.end();
  })
  .catch(err => {
    console.error('Connection error:', err);
  });

🐘 PHP

<?php
$options = [
    PDO::MYSQL_ATTR_SSL_CA => '/path/to/ca-cert.pem',
    PDO::MYSQL_ATTR_SSL_CERT => '/path/to/client-cert.pem',
    PDO::MYSQL_ATTR_SSL_KEY => '/path/to/client-key.pem',
    PDO::MYSQL_ATTR_SSL_VERIFY_SERVER_CERT => true,
];

try {
    $pdo = new PDO(
        'mysql:host=your-db-host.com;dbname=mydb',
        'username',
        'password',
        $options
    );
    
    $stmt = $pdo->query("SHOW STATUS LIKE 'Ssl_cipher'");
    $result = $stmt->fetch(PDO::FETCH_ASSOC);
    echo "SSL Cipher: " . $result['Value'] . "\n";
    
} catch (PDOException $e) {
    echo "Connection failed: " . $e->getMessage();
}
?>

🦀 Rust

use tokio_postgres::{Config, NoTls};
use postgres_native_tls::MakeTlsConnector;
use native_tls::{Certificate, TlsConnector, Identity};
use std::fs;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // CA 인증서 로드
    let ca_cert = fs::read("/path/to/ca.crt")?;
    let cert = Certificate::from_pem(&ca_cert)?;
    
    // 클라이언트 인증서 로드
    let client_cert = fs::read("/path/to/client.p12")?;
    let identity = Identity::from_pkcs12(&client_cert, "password")?;
    
    // TLS 커넥터 생성
    let connector = TlsConnector::builder()
        .add_root_certificate(cert)
        .identity(identity)
        .build()?;
    let connector = MakeTlsConnector::new(connector);
    
    // 연결 설정
    let config = "host=your-db-host.com user=username password=password dbname=mydb sslmode=require"
        .parse::<Config>()?;
    
    let (client, connection) = config.connect(connector).await?;
    
    tokio::spawn(async move {
        if let Err(e) = connection.await {
            eprintln!("connection error: {}", e);
        }
    });
    
    let rows = client.query("SELECT ssl_is_used()", &[]).await?;
    println!("SSL enabled: {:?}", rows);
    
    Ok(())
}

☁️ 클라우드 환경에서의 SSL/TLS 설정

요즘은 클라우드 DB 서비스를 많이 쓰잖아요? AWS, Azure, GCP 같은 곳에서 제공하는 관리형 데이터베이스 서비스들은 SSL/TLS 설정이 좀 더 간편해요. 각 플랫폼별로 알아볼게요!

☁️ AWS RDS/Aurora

AWS RDS는 기본적으로 SSL/TLS를 지원하고, 인증서도 자동으로 제공해줘요. 진짜 편함 ㅋㅋ

# 글로벌 번들 (모든 리전 포함)
wget https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem

# 특정 리전 (예: ap-northeast-2)
wget https://truststore.pki.rds.amazonaws.com/ap-northeast-2/ap-northeast-2-bundle.pem

mysql -h mydb.abc123.ap-northeast-2.rds.amazonaws.com \
  -u admin -p \
  --ssl-ca=global-bundle.pem \
  --ssl-mode=VERIFY_IDENTITY

# MySQL/MariaDB
require_secure_transport = 1

# PostgreSQL
rds.force_ssl = 1

🔷 Azure Database

Azure도 관리형 DB 서비스에서 SSL/TLS를 기본 지원해요. Azure Database for MySQL, PostgreSQL, MariaDB 모두 동일한 방식으로 작동합니다.

# Azure CA 인증서
wget https://www.digicert.com/CACerts/BaltimoreCyberTrustRoot.crt.pem

# 또는 새로운 루트 인증서
wget https://cacerts.digicert.com/DigiCertGlobalRootG2.crt.pem

psql "host=myserver.postgres.database.azure.com \
  port=5432 \
  dbname=mydb \
  user=myadmin@myserver \
  password=mypassword \
  sslmode=verify-full \
  sslrootcert=BaltimoreCyberTrustRoot.crt.pem"

🌐 Google Cloud SQL

GCP의 Cloud SQL도 SSL/TLS를 잘 지원하는데, 특히 Cloud SQL Proxy를 사용하면 더 편리해요.

# 1. 클라이언트 인증서 생성 (GCP 콘솔 또는 gcloud CLI)
gcloud sql ssl-certs create mycert \
  --instance=myinstance \
  --cert-file=client-cert.pem

# 2. 서버 CA 인증서 다운로드
gcloud sql ssl-certs describe server-ca \
  --instance=myinstance \
  --format="get(cert)" > server-ca.pem

# 3. MySQL 연결
mysql -h [INSTANCE_IP] \
  -u root -p \
  --ssl-ca=server-ca.pem \
  --ssl-cert=client-cert.pem \
  --ssl-key=client-key.pem

# 1. Cloud SQL Proxy 다운로드 및 실행
./cloud_sql_proxy -instances=PROJECT:REGION:INSTANCE=tcp:3306

# 2. 로컬호스트로 연결 (SSL은 프록시가 자동 처리)
mysql -h 127.0.0.1 -u root -p

# 애플리케이션 코드에서도 localhost로 연결하면 됨
# SSL 설정 불필요!

🔍 SSL/TLS 연결 문제 해결 (트러블슈팅)

SSL/TLS 설정하다 보면 여러 가지 에러를 만나게 돼요. 자주 발생하는 문제들과 해결 방법을 정리해봤어요!

❌ 자주 발생하는 에러들

openssl x509 -in server-cert.pem -noout -text | grep -A1 "Subject Alternative Name"

cat server.crt intermediate.crt root.crt > bundle.crt

🔧 디버깅 도구 및 명령어

# 기본 SSL 연결 테스트
openssl s_client -connect hostname:3306 -showcerts

# 특정 TLS 버전 테스트
openssl s_client -connect hostname:3306 -tls1_2

# 클라이언트 인증서 포함 테스트
openssl s_client -connect hostname:3306 \
  -cert client-cert.pem \
  -key client-key.pem \
  -CAfile ca-cert.pem

# 인증서 체인 확인
openssl s_client -connect hostname:3306 -showcerts | \
  openssl x509 -noout -text

# 인증서 내용 보기
openssl x509 -in certificate.pem -noout -text

# 인증서 유효기간 확인
openssl x509 -in certificate.pem -noout -dates

# 인증서 발급자 확인
openssl x509 -in certificate.pem -noout -issuer

# 인증서 주체 확인
openssl x509 -in certificate.pem -noout -subject

# 인증서와 개인키 매칭 확인
openssl x509 -noout -modulus -in certificate.pem | openssl md5
openssl rsa -noout -modulus -in private-key.pem | openssl md5
# 두 해시값이 같아야 함

# MySQL/MariaDB
SHOW VARIABLES LIKE '%ssl%';
SHOW STATUS LIKE 'Ssl_cipher';
SELECT * FROM performance_schema.session_status 
WHERE VARIABLE_NAME LIKE 'Ssl%';

# PostgreSQL
SHOW ssl;
SELECT * FROM pg_stat_ssl;
SELECT datname, usename, ssl, client_addr 
FROM pg_stat_ssl 
JOIN pg_stat_activity USING (pid);

# MongoDB
db.serverStatus().security
db.adminCommand({getParameter: 1, sslMode: 1})

⚡ 성능 최적화 및 모범 사례

SSL/TLS를 사용하면 당연히 암호화/복호화 오버헤드가 생겨요. 하지만 올바르게 설정하면 성능 영향을 최소화할 수 있어요!

🚀 성능 최적화 팁

from sqlalchemy import create_engine
from sqlalchemy.pool import QueuePool

engine = create_engine(
    'mysql+pymysql://user:pass@host/db',
    connect_args={
        'ssl': {
            'ca': '/path/to/ca.pem',
            'cert': '/path/to/client-cert.pem',
            'key': '/path/to/client-key.pem'
        }
    },
    poolclass=QueuePool,
    pool_size=20,  # 풀 크기
    max_overflow=10,  # 추가 연결 허용
    pool_recycle=3600,  # 1시간마다 연결 재생성
    pool_pre_ping=True  # 연결 유효성 검사
)

[mysqld]
# 세션 캐시 크기 (기본값: 20480)
ssl_session_cache_size = 40960

# 세션 캐시 타임아웃 (초, 기본값: 300)
ssl_session_cache_timeout = 600

🛡️ 보안 모범 사례

ssl_cipher = 'ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384'

#!/bin/bash
CERT_FILE="/path/to/certificate.pem"
DAYS_WARNING=30

# 인증서 만료일 확인
EXPIRY_DATE=$(openssl x509 -enddate -noout -in "$CERT_FILE" | cut -d= -f2)
EXPIRY_EPOCH=$(date -d "$EXPIRY_DATE" +%s)
CURRENT_EPOCH=$(date +%s)
DAYS_LEFT=$(( ($EXPIRY_EPOCH - $CURRENT_EPOCH) / 86400 ))

if [ $DAYS_LEFT -lt $DAYS_WARNING ]; then
    echo "경고: 인증서가 ${DAYS_LEFT}일 후 만료됩니다!"
    # 알림 발송 (이메일, Slack 등)
fi

-- 읽기 전용 사용자 생성 (SSL 필수)
CREATE USER 'readonly'@'%' 
IDENTIFIED BY 'strong_password' 
REQUIRE SSL;

GRANT SELECT ON mydb.* TO 'readonly'@'%';

-- 특정 테이블만 접근 가능
GRANT SELECT ON mydb.users TO 'limited'@'%' REQUIRE SSL;
GRANT SELECT ON mydb.orders TO 'limited'@'%' REQUIRE SSL;

📊 SSL/TLS 성능 벤치마크

실제로 SSL/TLS를 사용하면 성능이 얼마나 영향을 받는지 궁금하죠? 간단한 벤치마크 결과를 공유해드릴게요 ㅎㅎ

보시다시피 최신 TLS 1.3과 연결 풀링을 사용하면 성능 저하가 거의 없어요! 보안을 위해 1-3% 정도의 성능을 포기하는 건 충분히 가치 있는 트레이드오프라고 생각해요 ㅋㅋ

🎓 실전 프로젝트 예제

이론만 알면 뭐해요, 실전이 중요하죠! 실제 프로젝트에서 사용할 수 있는 완전한 예제를 만들어봤어요. Node.js + Express + MySQL 조합으로 SSL/TLS 연결을 구현해볼게요.

🏗️ 프로젝트 구조

my-secure-app/
├── certs/
│   ├── ca-cert.pem
│   ├── client-cert.pem
│   └── client-key.pem
├── config/
│   └── database.js
├── routes/
│   └── users.js
├── .env
├── package.json
└── server.js

📦 패키지 설치

npm init -y
npm install express mysql2 dotenv

⚙️ 환경 변수 설정 (.env)

DB_HOST=your-db-host.com
DB_PORT=3306
DB_USER=your-username
DB_PASSWORD=your-password
DB_NAME=your-database
DB_SSL_CA=/path/to/certs/ca-cert.pem
DB_SSL_CERT=/path/to/certs/client-cert.pem
DB_SSL_KEY=/path/to/certs/client-key.pem
PORT=3000

🔌 데이터베이스 연결 설정 (config/database.js)

const mysql = require('mysql2/promise');
const fs = require('fs');
require('dotenv').config();

// SSL 인증서 읽기
const sslConfig = {
  ca: fs.readFileSync(process.env.DB_SSL_CA),
  cert: fs.readFileSync(process.env.DB_SSL_CERT),
  key: fs.readFileSync(process.env.DB_SSL_KEY),
  rejectUnauthorized: true
};

// 연결 풀 생성
const pool = mysql.createPool({
  host: process.env.DB_HOST,
  port: process.env.DB_PORT,
  user: process.env.DB_USER,
  password: process.env.DB_PASSWORD,
  database: process.env.DB_NAME,
  ssl: sslConfig,
  waitForConnections: true,
  connectionLimit: 10,
  queueLimit: 0,
  enableKeepAlive: true,
  keepAliveInitialDelay: 0
});

// 연결 테스트 함수
async function testConnection() {
  try {
    const connection = await pool.getConnection();
    console.log('✅ 데이터베이스 연결 성공!');
    
    // SSL 연결 확인
    const [rows] = await connection.query("SHOW STATUS LIKE 'Ssl_cipher'");
    console.log('🔐 SSL Cipher:', rows[0].Value);
    
    connection.release();
    return true;
  } catch (error) {
    console.error('❌ 데이터베이스 연결 실패:', error.message);
    return false;
  }
}

module.exports = { pool, testConnection };

🛣️ 라우트 설정 (routes/users.js)

const express = require('express');
const router = express.Router();
const { pool } = require('../config/database');

// 사용자 목록 조회
router.get('/', async (req, res) => {
  try {
    const [rows] = await pool.query('SELECT id, username, email FROM users');
    res.json({
      success: true,
      data: rows
    });
  } catch (error) {
    console.error('쿼리 실행 오류:', error);
    res.status(500).json({
      success: false,
      message: '서버 오류가 발생했습니다.'
    });
  }
});

// 특정 사용자 조회
router.get('/:id', async (req, res) => {
  try {
    const [rows] = await pool.query(
      'SELECT id, username, email FROM users WHERE id = ?',
      [req.params.id]
    );
    
    if (rows.length === 0) {
      return res.status(404).json({
        success: false,
        message: '사용자를 찾을 수 없습니다.'
      });
    }
    
    res.json({
      success: true,
      data: rows[0]
    });
  } catch (error) {
    console.error('쿼리 실행 오류:', error);
    res.status(500).json({
      success: false,
      message: '서버 오류가 발생했습니다.'
    });
  }
});

// 사용자 생성
router.post('/', async (req, res) => {
  const { username, email, password } = req.body;
  
  try {
    const [result] = await pool.query(
      'INSERT INTO users (username, email, password) VALUES (?, ?, ?)',
      [username, email, password]
    );
    
    res.status(201).json({
      success: true,
      message: '사용자가 생성되었습니다.',
      data: {
        id: result.insertId,
        username,
        email
      }
    });
  } catch (error) {
    console.error('쿼리 실행 오류:', error);
    res.status(500).json({
      success: false,
      message: '서버 오류가 발생했습니다.'
    });
  }
});

module.exports = router;

🚀 메인 서버 파일 (server.js)

const express = require('express');
const { testConnection } = require('./config/database');
const usersRouter = require('./routes/users');
require('dotenv').config();

const app = express();
const PORT = process.env.PORT || 3000;

// 미들웨어
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// 라우트
app.use('/api/users', usersRouter);

// 헬스체크 엔드포인트
app.get('/health', (req, res) => {
  res.json({
    status: 'OK',
    timestamp: new Date().toISOString()
  });
});

// 서버 시작
async function startServer() {
  // 데이터베이스 연결 테스트
  const isConnected = await testConnection();
  
  if (!isConnected) {
    console.error('데이터베이스 연결 실패로 서버를 시작할 수 없습니다.');
    process.exit(1);
  }
  
  app.listen(PORT, () => {
    console.log(`🚀 서버가 포트 ${PORT}에서 실행 중입니다.`);
    console.log(`🔐 SSL/TLS로 데이터베이스에 안전하게 연결되었습니다.`);
  });
}

startServer();

🌟 재능넷에서 배우는 DB 보안

여기까지 SSL/TLS를 통한 DB 연결 보안에 대해 알아봤는데요, 혹시 더 깊이 있는 내용이 궁금하거나 실제 프로젝트에 적용하는 데 어려움이 있다면 재능넷을 활용해보는 것도 좋은 방법이에요!

재능넷의 '지식인의 숲' 같은 곳에서 이런 전문 지식을 공유하고 배울 수 있다는 게 정말 좋은 것 같아요. 혼자 삽질하면서 배우는 것도 의미 있지만, 때로는 전문가의 조언 한마디가 며칠간의 고민을 해결해주기도 하거든요!

🔮 미래의 DB 보안 트렌드

기술은 계속 발전하고 있고, DB 보안도 마찬가지예요. 앞으로 주목해야 할 트렌드들을 살펴볼게요!

📚 추가 학습 리소스

더 깊이 공부하고 싶은 분들을 위해 유용한 리소스들을 정리해봤어요!

✅ 체크리스트: SSL/TLS 구현 전 확인사항

마지막으로 실제로 SSL/TLS를 구현하기 전에 확인해야 할 체크리스트를 만들어봤어요. 하나씩 체크하면서 진행하면 실수를 줄일 수 있어요!