KR_Memcached - somaz94/python-study GitHub Wiki
Memcached ์๋ฒ์์ ๊ธฐ๋ณธ์ ์ธ ์ฐ๊ฒฐ์ ์ค์ ํ๋ ๋ฐฉ๋ฒ์ด๋ค.
from pymemcache.client.base import Client
from pymemcache.client.hash import HashClient
from typing import Any, Optional, Dict, List, Tuple
import json
import pickle
import socket
class MemcachedClient:
def __init__(
self,
host: str = 'localhost',
port: int = 11211,
connect_timeout: float = 1.0,
timeout: float = 0.5
):
"""Memcached ํด๋ผ์ด์ธํธ ์ด๊ธฐํ
Args:
host: Memcached ์๋ฒ ํธ์คํธ
port: Memcached ์๋ฒ ํฌํธ
connect_timeout: ์ฐ๊ฒฐ ์๊ฐ ์ ํ(์ด)
timeout: ์์
์๊ฐ ์ ํ(์ด)
"""
self.client = Client(
(host, port),
connect_timeout=connect_timeout,
timeout=timeout
)
def ping(self) -> bool:
"""์๋ฒ ์ฐ๊ฒฐ ํ
์คํธ"""
try:
return self.client.stats() is not None
except (socket.timeout, ConnectionRefusedError) as e:
print(f"์๋ฒ ์ฐ๊ฒฐ ์คํจ: {e}")
return False
except Exception as e:
print(f"๊ธฐํ ์ค๋ฅ: {e}")
return False
def close(self):
"""์ฐ๊ฒฐ ์ข
๋ฃ"""
try:
self.client.close()
print("Memcached ์ฐ๊ฒฐ์ด ์ ์์ ์ผ๋ก ์ข
๋ฃ๋์์ต๋๋ค")
except Exception as e:
print(f"์ฐ๊ฒฐ ์ข
๋ฃ ์ค ์ค๋ฅ ๋ฐ์: {e}")
def get_stats(self) -> Dict:
"""์๋ฒ ํต๊ณ ์ ๋ณด ์กฐํ"""
try:
return self.client.stats()
except Exception as e:
print(f"ํต๊ณ ์ ๋ณด ์กฐํ ์ค๋ฅ: {e}")
return {}
def flush_all(self) -> bool:
"""๋ชจ๋ ์บ์ ๋ฐ์ดํฐ ์ญ์ """
try:
return self.client.flush_all()
except Exception as e:
print(f"์บ์ ์ญ์ ์ค๋ฅ: {e}")
return False
โ
ํน์ง:
- ์๋ฒ ์ฐ๊ฒฐ ๊ด๋ฆฌ
- ์ํ ํ์ธ
- ์ฐ๊ฒฐ ์ข ๋ฃ ์ฒ๋ฆฌ
- ํ์์์ ์ค์
- ์ค๋ฅ ์ฒ๋ฆฌ
- ์๋ฒ ํต๊ณ ์ ๋ณด ์กฐํ
Memcached๋ ๊ณ ์ฑ๋ฅ ๋ถ์ฐ ๋ฉ๋ชจ๋ฆฌ ์บ์ฑ ์์คํ
์ผ๋ก ์น ์ ํ๋ฆฌ์ผ์ด์
์ ์ฑ๋ฅ์ ํฅ์์ํค๋ ๋ฐ ์ฌ์ฉ๋๋ค.
- ์ธ๋ฉ๋ชจ๋ฆฌ ์บ์: ๋ฐ์ดํฐ๋ฒ ์ด์ค ๋ถํ๋ฅผ ์ค์ด๊ธฐ ์ํด ์์ฃผ ์ฌ์ฉ๋๋ ๋ฐ์ดํฐ๋ฅผ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅ
- ๋ถ์ฐ ์ํคํ ์ฒ: ์ฌ๋ฌ ์๋ฒ์ ๊ฑธ์ณ ํ์ฅ ๊ฐ๋ฅํ ๊ตฌ์กฐ
- ๊ฐ๋จํ ํค-๊ฐ ์ ์ฅ์: ๋ณต์กํ ์ฐ์ฐ ์์ด ๋น ๋ฅธ ์ก์ธ์ค ์ ๊ณต
- LRU(Least Recently Used): ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ถ์กฑํ ๋ ๊ฐ์ฅ ์ค๋๋ ํญ๋ชฉ๋ถํฐ ์ ๊ฑฐ
- ์์์ ์ฐ์ฐ: ๋ค์ค ์ค๋ ๋/ํ๋ก์ธ์ค ํ๊ฒฝ์์ ์์ ํ ๋ฐ์ดํฐ ์ก์ธ์ค
Memcached์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ณ ์กฐํํ๋ ๊ธฐ๋ณธ ์์
๋ฐฉ๋ฒ์ด๋ค.
class MemcachedOperations:
def __init__(self, client: MemcachedClient):
self.client = client.client
def set_value(
self,
key: str,
value: Any,
expire: int = 0,
noreply: bool = False
) -> bool:
"""๊ฐ ์ค์
Args:
key: ์ ์ฅํ ํค
value: ์ ์ฅํ ๊ฐ
expire: ๋ง๋ฃ ์๊ฐ(์ด), 0์ ๋ง๋ฃ ์์
noreply: ์๋ฒ ์๋ต์ ๊ธฐ๋ค๋ฆฌ์ง ์์
Returns:
bool: ์ฑ๊ณต ์ฌ๋ถ
"""
try:
return self.client.set(
key,
pickle.dumps(value),
expire=expire,
noreply=noreply
)
except Exception as e:
print(f"๊ฐ ์ค์ ์ค๋ฅ: {e}")
return False
def get_value(self, key: str) -> Optional[Any]:
"""๊ฐ ์กฐํ
Args:
key: ์กฐํํ ํค
Returns:
Optional[Any]: ์ ์ฅ๋ ๊ฐ ๋๋ None
"""
try:
value = self.client.get(key)
return pickle.loads(value) if value else None
except Exception as e:
print(f"๊ฐ ์กฐํ ์ค๋ฅ: {e}")
return None
def delete(self, key: str, noreply: bool = False) -> bool:
"""๊ฐ ์ญ์
Args:
key: ์ญ์ ํ ํค
noreply: ์๋ฒ ์๋ต์ ๊ธฐ๋ค๋ฆฌ์ง ์์
Returns:
bool: ์ฑ๊ณต ์ฌ๋ถ
"""
try:
return self.client.delete(key, noreply=noreply)
except Exception as e:
print(f"๊ฐ ์ญ์ ์ค๋ฅ: {e}")
return False
def add(
self,
key: str,
value: Any,
expire: int = 0
) -> bool:
"""ํค๊ฐ ์กด์ฌํ์ง ์์ ๋๋ง ๊ฐ ์ถ๊ฐ
Args:
key: ์ถ๊ฐํ ํค
value: ์ถ๊ฐํ ๊ฐ
expire: ๋ง๋ฃ ์๊ฐ(์ด)
Returns:
bool: ์ฑ๊ณต ์ฌ๋ถ
"""
try:
return self.client.add(
key,
pickle.dumps(value),
expire=expire
)
except Exception as e:
print(f"๊ฐ ์ถ๊ฐ ์ค๋ฅ: {e}")
return False
def incr(self, key: str, value: int = 1) -> Optional[int]:
"""์ ์ ๊ฐ ์ฆ๊ฐ
Args:
key: ์ฆ๊ฐ์ํฌ ํค
value: ์ฆ๊ฐ๋
Returns:
Optional[int]: ์ฆ๊ฐ ํ ๊ฐ ๋๋ None
"""
try:
return self.client.incr(key, value)
except Exception as e:
print(f"๊ฐ ์ฆ๊ฐ ์ค๋ฅ: {e}")
return None
def decr(self, key: str, value: int = 1) -> Optional[int]:
"""์ ์ ๊ฐ ๊ฐ์
Args:
key: ๊ฐ์์ํฌ ํค
value: ๊ฐ์๋
Returns:
Optional[int]: ๊ฐ์ ํ ๊ฐ ๋๋ None
"""
try:
return self.client.decr(key, value)
except Exception as e:
print(f"๊ฐ ๊ฐ์ ์ค๋ฅ: {e}")
return None
def get_multi(self, keys: List[str]) -> Dict[str, Any]:
"""์ฌ๋ฌ ํค ๊ฐ ๋์ ์กฐํ
Args:
keys: ์กฐํํ ํค ๋ชฉ๋ก
Returns:
Dict[str, Any]: ํค-๊ฐ ์ ๋์
๋๋ฆฌ
"""
try:
values = self.client.get_multi(keys)
return {k: pickle.loads(v) if v else None for k, v in values.items()}
except Exception as e:
print(f"๋ค์ค ๊ฐ ์กฐํ ์ค๋ฅ: {e}")
return {}
โ
ํน์ง:
- ๋ฐ์ดํฐ ์ ์ฅ/์กฐํ
- ์ง๋ ฌํ ์ฒ๋ฆฌ
- ์๋ฌ ์ฒ๋ฆฌ
- ์์์ ์ฆ๊ฐ/๊ฐ์
- ๋ค์ค ํค ์กฐํ
- ์กฐ๊ฑด๋ถ ์ถ๊ฐ
Memcached์์ ์ง์ํ๋ ๋ค์ํ ์์
ํ์
๊ณผ ํน์ง์ด๋ค.
์์ | ์ค๋ช | ํน์ง |
---|---|---|
set | ๊ฐ ์ค์ | ํค๊ฐ ์กด์ฌํ๋ฉด ๋ฎ์ด์ |
get | ๊ฐ ์กฐํ | ์์ผ๋ฉด None ๋ฐํ |
delete | ๊ฐ ์ญ์ | ์ฑ๊ณต ์ฌ๋ถ ๋ฐํ |
add | ์ ๊ฐ ์ถ๊ฐ | ํค๊ฐ ์กด์ฌํ๋ฉด ์คํจ |
replace | ๊ฐ ๋์ฒด | ํค๊ฐ ์กด์ฌํด์ผ ์ฑ๊ณต |
incr | ๊ฐ ์ฆ๊ฐ | ์ ์ ๊ฐ๋ง ๊ฐ๋ฅ |
decr | ๊ฐ ๊ฐ์ | ์ ์ ๊ฐ๋ง ๊ฐ๋ฅ |
append | ๊ฐ ๋ค์ ์ถ๊ฐ | ๊ธฐ์กด ๊ฐ ํ์ |
prepend | ๊ฐ ์์ ์ถ๊ฐ | ๊ธฐ์กด ๊ฐ ํ์ |
get_multi | ๋ค์ค ํค ์กฐํ | ๋คํธ์ํฌ ์ต์ ํ |
ํจ์ ๊ฒฐ๊ณผ๋ฅผ ํจ์จ์ ์ผ๋ก ์บ์ฑํ๋ ๋ฐ์ฝ๋ ์ดํฐ ํจํด ๊ตฌํ ๋ฐฉ๋ฒ์ด๋ค.
from functools import wraps
import hashlib
import time
import inspect
import json
class MemcachedCache:
def __init__(self, client: MemcachedClient):
self.ops = MemcachedOperations(client)
def _generate_cache_key(self, func, args, kwargs):
"""ํจ์ ํธ์ถ์ ๋ํ ๊ณ ์ ์บ์ ํค ์์ฑ"""
# ํจ์ ์ด๋ฆ๊ณผ ๋ชจ๋ ํฌํจ
key_parts = [func.__module__, func.__name__]
# ์์น ์ธ์ ์ถ๊ฐ
for arg in args:
key_parts.append(str(arg))
# ํค์๋ ์ธ์ ์ถ๊ฐ (์ ๋ ฌํ์ฌ ์ผ๊ด์ฑ ๋ณด์ฅ)
sorted_kwargs = sorted(kwargs.items())
for k, v in sorted_kwargs:
key_parts.append(f"{k}={v}")
# ํค ๋ฌธ์์ด ์์ฑ ๋ฐ ํด์
key_str = ":".join(key_parts)
return f"cache:{hashlib.md5(key_str.encode()).hexdigest()}"
def cache_decorator(self, expire: int = 300):
"""ํจ์ ๊ฒฐ๊ณผ๋ฅผ ์บ์ํ๋ ๋ฐ์ฝ๋ ์ดํฐ
Args:
expire: ์บ์ ๋ง๋ฃ ์๊ฐ(์ด)
Returns:
Callable: ๋ฐ์ฝ๋ ์ดํฐ ํจ์
"""
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
# ์บ์ ํค ์์ฑ
key = self._generate_cache_key(func, args, kwargs)
# ์บ์๋ ๊ฒฐ๊ณผ ํ์ธ
cached_result = self.ops.get_value(key)
if cached_result is not None:
return cached_result
# ์บ์ ๋ฏธ์ค: ํจ์ ์คํ ๋ฐ ๊ฒฐ๊ณผ ์บ์ฑ
start_time = time.time()
result = func(*args, **kwargs)
exec_time = time.time() - start_time
# ๊ฒฐ๊ณผ ์บ์ฑ
self.ops.set_value(key, result, expire)
print(f"์บ์ ์ ์ฅ: {key} (์คํ ์๊ฐ: {exec_time:.4f}์ด)")
return result
return wrapper
return decorator
def invalidate_cache(self, func, *args, **kwargs):
"""ํน์ ํจ์ ํธ์ถ์ ๋ํ ์บ์ ๋ฌดํจํ
Args:
func: ์บ์๋ฅผ ๋ฌดํจํํ ํจ์
*args, **kwargs: ํจ์ ์ธ์
Returns:
bool: ์ฑ๊ณต ์ฌ๋ถ
"""
key = self._generate_cache_key(func, args, kwargs)
return self.ops.delete(key)
def memoize(self, expire: int = 300):
"""๋ฉ์๋ ๊ฒฐ๊ณผ๋ฅผ ๋ฉ๋ชจ์ด์ ์ด์
ํ๋ ๋ฐ์ฝ๋ ์ดํฐ
Args:
expire: ์บ์ ๋ง๋ฃ ์๊ฐ(์ด)
Returns:
Callable: ๋ฐ์ฝ๋ ์ดํฐ ํจ์
"""
return self.cache_decorator(expire)
โ
ํน์ง:
- ๋ฐ์ฝ๋ ์ดํฐ ํจํด
- ํค ์์ฑ ๋ก์ง
- ๋ง๋ฃ ์๊ฐ ๊ด๋ฆฌ
- ์บ์ ๋ฌดํจํ
- ์คํ ์๊ฐ ์ธก์
- ๋ฉ๋ชจ์ด์ ์ด์
Memcached ์บ์ฑ์ด ํจ๊ณผ์ ์ธ ์ผ๋ฐ์ ์ธ ์ฌ์ฉ ์ฌ๋ก์ด๋ค.
- ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ฟผ๋ฆฌ ๊ฒฐ๊ณผ: ์์ฃผ ์คํ๋๋ ์ฟผ๋ฆฌ์ ๊ฒฐ๊ณผ ์บ์ฑ
- API ์๋ต: ์ธ๋ถ API ํธ์ถ ๊ฒฐ๊ณผ ์บ์ฑ์ผ๋ก API ์ ํ ๋ฐ ์ง์ฐ ์๊ฐ ๊ฐ์
- ์ธ์ ๋ฐ์ดํฐ: ์น ์ ํ๋ฆฌ์ผ์ด์ ์ ์ฌ์ฉ์ ์ธ์ ์ ๋ณด ์ ์ฅ
- ํ์ด์ง ๋ ๋๋ง: ๋์ ์น ํ์ด์ง์ HTML ์ถ๋ ฅ ์บ์ฑ
- ๊ณ์ฐ ๋น์ฉ์ด ๋์ ์์ : ๋ณต์กํ ์ฐ์ฐ ๊ฒฐ๊ณผ ์บ์ฑ
- ์ ๊ทผ ์ ์ด ํ ํฐ: ์์ ์ก์ธ์ค ํ ํฐ ๋ฐ ์ธ์ฆ ์ ๋ณด ์ ์ฅ
Memcached๋ฅผ ์ฌ์ฉํ ์น ์ ํ๋ฆฌ์ผ์ด์
์ธ์
๊ด๋ฆฌ ๊ตฌํ ๋ฐฉ๋ฒ์ด๋ค.
import uuid
from datetime import datetime, timedelta
import json
from typing import Optional, Dict, Any
class MemcachedSession:
def __init__(self, client: MemcachedClient):
self.ops = MemcachedOperations(client)
self.session_prefix = "session:"
def create_session(
self,
user_id: str,
data: dict,
expire: int = 3600
) -> Optional[str]:
"""์ ์ธ์
์์ฑ
Args:
user_id: ์ฌ์ฉ์ ID
data: ์ธ์
์ ์ ์ฅํ ๋ฐ์ดํฐ
expire: ์ธ์
๋ง๋ฃ ์๊ฐ(์ด)
Returns:
Optional[str]: ์์ฑ๋ ์ธ์
ID ๋๋ None
"""
session_id = str(uuid.uuid4())
session_key = f"{self.session_prefix}{session_id}"
# ์ธ์
๋ฐ์ดํฐ ๊ตฌ์ฑ
session_data = {
"user_id": user_id,
"created_at": datetime.now().isoformat(),
"last_accessed": datetime.now().isoformat(),
"expire_at": (datetime.now() + timedelta(seconds=expire)).isoformat(),
"data": data
}
# ์ธ์
์ ์ฅ
if self.ops.set_value(session_key, session_data, expire):
return session_id
return None
def get_session(self, session_id: str) -> Optional[Dict[str, Any]]:
"""์ธ์
์กฐํ
Args:
session_id: ์ธ์
ID
Returns:
Optional[Dict[str, Any]]: ์ธ์
๋ฐ์ดํฐ ๋๋ None
"""
session_key = f"{self.session_prefix}{session_id}"
session_data = self.ops.get_value(session_key)
if session_data:
# ๋ง์ง๋ง ์ ๊ทผ ์๊ฐ ์
๋ฐ์ดํธ
session_data["last_accessed"] = datetime.now().isoformat()
self.ops.set_value(session_key, session_data)
return session_data
def update_session(
self,
session_id: str,
data: Dict[str, Any],
extend_expire: bool = True,
expire: int = 3600
) -> bool:
"""์ธ์
๋ฐ์ดํฐ ์
๋ฐ์ดํธ
Args:
session_id: ์ธ์
ID
data: ์
๋ฐ์ดํธํ ๋ฐ์ดํฐ
extend_expire: ๋ง๋ฃ ์๊ฐ ์ฐ์ฅ ์ฌ๋ถ
expire: ์ ๋ง๋ฃ ์๊ฐ(์ด)
Returns:
bool: ์ฑ๊ณต ์ฌ๋ถ
"""
session_key = f"{self.session_prefix}{session_id}"
session_data = self.ops.get_value(session_key)
if not session_data:
return False
# ์ธ์
๋ฐ์ดํฐ ์
๋ฐ์ดํธ
session_data["data"].update(data)
session_data["last_accessed"] = datetime.now().isoformat()
if extend_expire:
session_data["expire_at"] = (datetime.now() + timedelta(seconds=expire)).isoformat()
return self.ops.set_value(session_key, session_data, expire)
else:
return self.ops.set_value(session_key, session_data)
def delete_session(self, session_id: str) -> bool:
"""์ธ์
์ญ์
Args:
session_id: ์ธ์
ID
Returns:
bool: ์ฑ๊ณต ์ฌ๋ถ
"""
session_key = f"{self.session_prefix}{session_id}"
return self.ops.delete(session_key)
def is_valid_session(self, session_id: str) -> bool:
"""์ธ์
์ ํจ์ฑ ํ์ธ
Args:
session_id: ์ธ์
ID
Returns:
bool: ์ ํจ ์ฌ๋ถ
"""
session_data = self.get_session(session_id)
return session_data is not None
โ
ํน์ง:
- ์ธ์ ์๋ณ์ ์์ฑ
- ๋ง๋ฃ ์๊ฐ ์ค์
- ์ธ์ ๋ฐ์ดํฐ ๊ด๋ฆฌ
- ์๋ ๊ฐฑ์
- ์ ํจ์ฑ ๊ฒ์ฆ
- ์ฌ์ฉ์ ์ฐ๊ฒฐ
์ฌ๋ฌ Memcached ์๋ฒ๋ฅผ ๊ด๋ฆฌํ๋ ๋ถ์ฐ ์บ์ ๊ตฌํ ๋ฐฉ๋ฒ์ด๋ค.
from typing import List, Tuple, Dict, Any, Optional
import hashlib
class DistributedCache:
def __init__(self, servers: List[Tuple[str, int]]):
"""์ฌ๋ฌ Memcached ์๋ฒ ์ฐ๊ฒฐ
Args:
servers: (ํธ์คํธ, ํฌํธ) ํํ์ ์๋ฒ ๋ชฉ๋ก
"""
self.clients = [
MemcachedClient(host, port)
for host, port in servers
]
self.n_servers = len(servers)
self.server_info = servers
def _get_client(self, key: str) -> MemcachedOperations:
"""ํด์ ๊ธฐ๋ฐ์ผ๋ก ์๋ฒ ์ ํ
Args:
key: ํค
Returns:
MemcachedOperations: ์ ํ๋ ์๋ฒ์ ์์
๊ฐ์ฒด
"""
hash_value = int(hashlib.md5(key.encode()).hexdigest(), 16)
server_index = hash_value % self.n_servers
return MemcachedOperations(self.clients[server_index])
def set(self, key: str, value: Any, expire: int = 0) -> bool:
"""๋ถ์ฐ ํ๊ฒฝ์์ ๊ฐ ์ค์
Args:
key: ํค
value: ๊ฐ
expire: ๋ง๋ฃ ์๊ฐ(์ด)
Returns:
bool: ์ฑ๊ณต ์ฌ๋ถ
"""
client = self._get_client(key)
return client.set_value(key, value, expire)
def get(self, key: str) -> Optional[Any]:
"""๋ถ์ฐ ํ๊ฒฝ์์ ๊ฐ ์กฐํ
Args:
key: ํค
Returns:
Optional[Any]: ๊ฐ ๋๋ None
"""
client = self._get_client(key)
return client.get_value(key)
def delete(self, key: str) -> bool:
"""๋ถ์ฐ ํ๊ฒฝ์์ ๊ฐ ์ญ์
Args:
key: ํค
Returns:
bool: ์ฑ๊ณต ์ฌ๋ถ
"""
client = self._get_client(key)
return client.delete(key)
def get_stats_all(self) -> Dict[Tuple[str, int], Dict]:
"""๋ชจ๋ ์๋ฒ์ ํต๊ณ ์ ๋ณด ์กฐํ
Returns:
Dict: ์๋ฒ๋ณ ํต๊ณ ์ ๋ณด
"""
stats = {}
for i, client in enumerate(self.clients):
stats[self.server_info[i]] = client.get_stats()
return stats
def close_all(self):
"""๋ชจ๋ ์๋ฒ ์ฐ๊ฒฐ ์ข
๋ฃ"""
for client in self.clients:
client.close()
โ
ํน์ง:
- ๋ค์ค ์๋ฒ ๊ด๋ฆฌ
- ํด์ ๊ธฐ๋ฐ ๋ถ์ฐ
- ํ์ฅ์ฑ ์ง์
- ์๋ฒ ์ ํ ์๊ณ ๋ฆฌ์ฆ
- ํตํฉ ์ธํฐํ์ด์ค
- ๋ฆฌ์์ค ๊ด๋ฆฌ
Memcached์์ ์ฌ์ฉ๋๋ ์ฃผ์ ๋ถ์ฐ ์๊ณ ๋ฆฌ์ฆ๊ณผ ํน์ง์ด๋ค.
- ์ผ๊ด๋ ํด์ฑ(Consistent Hashing): ์๋ฒ ์ถ๊ฐ/์ ๊ฑฐ ์ ์ต์ํ์ ํค ์ฌ๋ฐฐ์น
- ๋ชจ๋๋ฌ ํด์ฑ(Modular Hashing): ํค ํด์๋ฅผ ์๋ฒ ์๋ก ๋๋ ๋๋จธ์ง๋ก ์๋ฒ ๊ฒฐ์
- ๊ฐ์ค์น ๊ธฐ๋ฐ ๋ฐฐํฌ: ์๋ฒ ์ฉ๋์ ๋น๋กํ์ฌ ํค ๋ฐฐํฌ
- ๋ ํ๋ฆฌ์นด(Replica): ๋์ผํ ํค๋ฅผ ์ฌ๋ฌ ์๋ฒ์ ๋ณต์ ํ์ฌ ๊ฐ์ฉ์ฑ ํฅ์
- ์ค๋ฉ(Sharding): ๋ฐ์ดํฐ๋ฅผ ๋ถํ ํ์ฌ ์ฌ๋ฌ ์๋ฒ์ ๋ถ์ฐ
โ
๋ชจ๋ฒ ์ฌ๋ก:
- ํค ๋ค์ด๋ฐ ์ ๋ต ์๋ฆฝ: ๊ด๋ จ ๋ฐ์ดํฐ๋ฅผ ๊ทธ๋ฃนํํ๋ ์ผ๊ด๋ ํค ์ ๋์ฌ ์ฌ์ฉ
- ๋ง๋ฃ ์๊ฐ ์ ์ ํ ์ค์ : ๋ฐ์ดํฐ ์ ํ๊ณผ ๊ฐฑ์ ๋น๋์ ๋ง๊ฒ ์ค์
- ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ ๋ชจ๋ํฐ๋ง: ๊ณผ๋ํ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ์ผ๋ก ์ธํ ํญ๋ชฉ ์ ๊ฑฐ ๋ฐฉ์ง
- ๋ถ์ฐ ์ฒ๋ฆฌ ๊ณ ๋ ค: ์ผ๊ด๋ ํด์ฑ์ ํตํ ํจ์จ์ ์ธ ์๋ฒ ํ์ฅ
- ์๋ฌ ์ฒ๋ฆฌ ๊ตฌํ: ๋คํธ์ํฌ ์ค๋ฅ์ ์๋ฒ ๋ค์ด์ ๋ํ ๋๋น
- ์ฑ๋ฅ ์ต์ ํ: ์ง๋ ฌํ/์ญ์ง๋ ฌํ ๋น์ฉ ์ต์ํ ๋ฐ ๋ฐฐ์น ์์ ํ์ฉ
- ๋ฐฑ์ ์ ๋ต ์๋ฆฝ: ์ฃผ์ ๋ฐ์ดํฐ์ ๋ํ ๋ฐฑ์ ๋ฉ์ปค๋์ฆ ๊ตฌํ
- ๋ณด์ ์ค์ ํ์ธ: ๋ฐฉํ๋ฒฝ ์ค์ ๋ฐ ์ธ์ฆ ๋ฉ์ปค๋์ฆ ํ์ฑํ
- ๋์ฉ๋ ๊ฐ์ฒด ๋ถํ : ํฐ ๊ฐ์ฒด๋ ์ฌ๋ฌ ์กฐ๊ฐ์ผ๋ก ๋๋์ด ์ ์ฅ
- ํซํค ๋ฌธ์ ํด๊ฒฐ: ์์ฃผ ์ ๊ทผํ๋ ํค์ ๋ถํ ๋ถ์ฐ ์ ๋ต ์๋ฆฝ