모니터링, 로그, 백업: 서비스를 오래 살리는 습관
배포한 뒤에 서비스를 오래 살리는 세 가지 습관을 익혀요. 기계가 읽기 좋은 JSON 로그를 남기고 요청 번호로 한 요청의 흔적을 모으며 개인정보는 가리는 법, 평균이 숨기는 느린 꼬리를 p95와 p99로 드러내는 법, 한 달에 실패해도 되는 양을 정하는 오류 예산, 한 번 튄 값에는 울리지 않는 알림 규칙을 직접 계산해요. 백업은 떠 두는 것보다 복원해 보는 것이 중요하다는 걸 실제로 지운 데이터를 되살리고 망가진 백업을 걸러 내며 확인하고, 사고가 났을 때 무엇을 하고 어떻게 돌아보는지까지 다뤄요.
서버를 만들고, 앞단을 두고, 컨테이너에 담고, 자동으로 배포했어요. 이제 서비스가 세상에 나갔어요. 그런데 진짜 일은 여기서부터예요. 서비스는 어느 날 느려지고, 어느 밤 멈추고, 누군가의 실수로 데이터가 지워져요. 그 순간 무슨 일이 일어나는지 볼 수 있는지, 그리고 되살릴 수 있는지가 서비스의 수명을 정해요. 이번 강의에서는 로그, 지표, 알림, 백업이라는 습관을 다뤄요.
로그: 무슨 일이 있었는지
첫 강의의 서버는 POST /todos → 201 같은 글자 한 줄을 기록했어요. 사람이 읽기는 좋지만, 기록이 하루에 수백만 줄이 되면 사람이 읽을 수 없어요. 그래서 기록을 기계가 읽기 좋은 모양(구조화된 로그)으로 남겨요. 줄마다 JSON 하나로 남기고, 요청마다 고유한 요청 번호를 붙여요.
import io
import json
import logging
import re
def mask_email(email):
name, _, domain = email.partition("@")
return f"{name[0]}***@{domain}"
class JsonFormatter(logging.Formatter): # 기록 한 줄을 JSON 하나로 만들어요
def format(self, record):
data = {"level": record.levelname, "msg": record.getMessage()}
data.update(getattr(record, "ctx", {}))
return json.dumps(data, ensure_ascii=False)
stream = io.StringIO()
logger = logging.getLogger("todo-api")
handler = logging.StreamHandler(stream)
handler.setFormatter(JsonFormatter())
logger.addHandler(handler)
logger.setLevel(logging.INFO)
logger.propagate = False
def handle(request_id, path, email, ms, error=None):
ctx = {"request_id": request_id, "path": path, "user": mask_email(email), "ms": ms}
if error:
logger.error(error, extra={"ctx": ctx})
else:
logger.info("처리 완료", extra={"ctx": ctx})
handle("r-101", "/todos", "[email protected]", 31)
handle("r-102", "/checkout", "[email protected]", 2400, error="결제 서버 응답 없음")
handle("r-103", "/todos", "[email protected]", 28)
handle("r-104", "/checkout", "[email protected]", 2600, error="결제 서버 응답 없음")
lines = [json.loads(line) for line in stream.getvalue().splitlines()]
print(stream.getvalue().splitlines()[1])
errors = [l for l in lines if l["level"] == "ERROR"]
print("오류가 난 주소:", sorted({l["path"] for l in errors}), "| 오류 수:", len(errors))
print("r-104 요청의 기록:", [l["msg"] for l in lines if l["request_id"] == "r-104"])
print("기록에 이메일 원문이 남았나요?", bool(re.search(r"[a-z]+@example\.com", stream.getvalue())))
{"level": "ERROR", "msg": "결제 서버 응답 없음", "request_id": "r-102", "path": "/checkout", "user": "j***@example.com", "ms": 2400}
오류가 난 주소: ['/checkout'] | 오류 수: 2
r-104 요청의 기록: ['결제 서버 응답 없음']
기록에 이메일 원문이 남았나요? False
- 구조화된 로그는 질문할 수 있어요. "오류가 난 주소는?", "2초 넘게 걸린 요청은?" 같은 질문을 코드나 로그 검색 도구로 바로 할 수 있어요. 글자 한 줄이었다면 정규식으로 쪼개야 했을 거예요.
- 요청 번호가 흔적을 이어요. 한 요청이 앞단, 앱 서버, 결제 서버를 거친다면, 모두 같은 요청 번호를 기록하게 해요. 사용자가 "결제가 안 돼요"라고 문의하면 요청 번호 하나로 모든 서버의 기록을 모을 수 있어요. 여러 서비스를 거치는 요청의 단계별 시간까지 이어 보는 것을 분산 추적이라고 해요.
- 개인정보와 비밀은 남기지 않아요. 이메일은 앞 글자만 남기고 가렸어요. 비밀번호, 토큰, 카드 번호, 주민등록번호는 아예 남기지 않아요. 로그는 생각보다 많은 사람과 도구가 보고, 오래 보관돼요. 로그에서 개인정보가 새는 사고가 흔해요.
- 수준을 나눠요.
DEBUG(개발 중 자세히),INFO(평소 흐름),WARNING(이상하지만 돌아감),ERROR(실패),CRITICAL(서비스가 위험)로 나누고, 운영에서는 보통INFO이상만 남겨요.
지표: 지금 얼마나 건강한지
로그가 사건 하나하나의 기록이라면, 지표는 숫자로 본 건강 상태예요. 웹 서비스라면 세 가지를 꼭 봐요. 초당 요청 수(얼마나 바쁜지), 오류율(얼마나 실패하는지), 응답 시간(얼마나 느린지)이에요. 그중 응답 시간은 평균으로 보면 안 돼요.
import math
import statistics
latency = [30] * 90 + [80] * 8 + [1200, 3000] # 요청 100개의 응답 시간(ms)
def percentile(values, p): # p번째 백분위: 줄 세웠을 때 p% 지점의 값
ordered = sorted(values)
return ordered[math.ceil(p / 100 * len(ordered)) - 1]
print(f"평균 {statistics.mean(latency):.1f}ms")
for p in (50, 95, 99):
print(f"p{p}: {percentile(latency, p)}ms")
print("1초 넘게 기다린 요청:", sum(ms > 1000 for ms in latency), "개")
평균 75.4ms
p50: 30ms
p95: 80ms
p99: 1200ms
1초 넘게 기다린 요청: 2 개
평균 75ms만 보면 아무 문제가 없어 보여요. 하지만 p99는 1.2초이고, 100명 중 2명은 1초 넘게 기다렸어요. 하루 100만 요청이면 2만 번의 답답한 기다림이에요. 게다가 페이지 하나가 요청을 수십 개 보내면, 그중 하나라도 느린 요청에 걸릴 확률은 훨씬 커져요. 그래서 응답 시간은 **p50(보통의 경험), p95, p99(느린 꼬리)**로 봐요. 웹 개발 트랙의 성능 강의에서 75번째 백분위로 판정했던 것과 같은 생각이에요.
오류 예산: 얼마나 실패해도 되나
"절대 실패하지 않는 서비스"는 없어요. 대신 얼마나까지 실패해도 되는지를 미리 정해요. 이 약속을 SLO(서비스 수준 목표)라고 하고, 거기서 남는 여유가 오류 예산이에요.
SLO = 0.999 # 한 달 요청의 99.9%는 성공해야 해요
monthly_requests = 2_000_000
budget = round(monthly_requests * (1 - SLO))
print(f"이번 달 실패해도 되는 요청(오류 예산): {budget:,}개, 시간으로는 {30 * 24 * 60 * (1 - SLO):.1f}분")
incidents = [("11월 3일 배포 실수", 900), ("11월 12일 데이터베이스 느려짐", 600)]
used = sum(n for _, n in incidents)
for name, n in incidents:
print(f" {name}: {n:,}개")
print(f"쓴 예산 {used / budget:.0%}, 남은 예산 {budget - used:,}개")
이번 달 실패해도 되는 요청(오류 예산): 2,000개, 시간으로는 43.2분
11월 3일 배포 실수: 900개
11월 12일 데이터베이스 느려짐: 600개
쓴 예산 75%, 남은 예산 500개
오류 예산은 팀이 결정을 내리는 기준이 돼요. 예산이 넉넉하면 새 기능을 과감하게 배포하고, 이번 달처럼 75%를 써 버렸으면 남은 기간에는 위험한 배포를 미루고 안정화에 힘을 써요. "더 안정적으로 하자"는 막연한 말 대신, 숫자로 대화할 수 있어요. 목표는 서비스에 맞게 정해요. 개인 블로그에 99.99%는 지나치고, 결제 서비스에 99%는 부족해요.
알림: 사람을 깨울 때만 깨우기
지표를 계속 쳐다볼 수는 없으니, 이상할 때 알림을 받아요. 문제는 알림이 너무 자주 울리면 사람들이 무시하기 시작한다는 거예요. 1분마다 잰 오류율로 두 가지 규칙을 비교해 볼게요.
per_minute = [0.5, 0.4, 3.2, 0.6, 0.5, 2.5, 2.8, 3.1, 2.9, 0.4] # 1분마다 잰 오류율(%)
naive = [minute for minute, rate in enumerate(per_minute, 1) if rate > 2]
print("2%를 넘을 때마다 울리면:", naive, f"→ {len(naive)}번")
alerts, streak = [], 0
for minute, rate in enumerate(per_minute, 1):
streak = streak + 1 if rate > 2 else 0
if streak == 3: # 3분 연속으로 넘으면 한 번만
alerts.append(minute)
print("3분 연속일 때만 울리면:", alerts, f"→ {len(alerts)}번")
2%를 넘을 때마다 울리면: [3, 6, 7, 8, 9] → 5번
3분 연속일 때만 울리면: [8] → 1번
3분에 한 번 튄 값은 금방 돌아왔으니 사람을 깨울 일이 아니었어요. 6분부터 이어진 진짜 문제는 8분에 한 번만 알렸어요. 알림이 다섯 번 울렸다면 사람들은 "또 울리네" 하고 넘기다가 진짜 문제도 놓쳤을 거예요. 이걸 알림 피로라고 해요. 좋은 알림의 조건은 이래요.
- 사용자가 겪는 증상으로 울려요. "CPU 80%"보다 "오류율 2% 이상 3분 지속", "p99가 2초 이상"처럼 사용자에게 보이는 문제가 기준이에요.
- 할 일이 있을 때만 울려요. 알림을 받고 할 수 있는 게 없다면 알림이 아니라 기록으로 충분해요.
- 급한 정도를 나눠요. 한밤중에 깨워야 하는 일과 다음 날 아침에 봐도 되는 일을 다른 통로로 보내요.
- 서비스 바깥에서 주기적으로 주소를 불러 보는 상태 검사도 둬요. 서버 안의 감시 도구는 서버가 통째로 죽으면 같이 죽으니까요.
백업: 복원해 보기 전에는 백업이 아니에요
데이터베이스 트랙에서 WHERE 없는 DELETE를 봤죠. 그런 실수, 디스크 고장, 해킹은 언젠가 일어나요. 그때 기댈 곳이 백업이에요. 백업을 떠 두고, 사고를 내고, 되살려 볼게요.
import hashlib
import pathlib
import sqlite3
import tempfile
folder = pathlib.Path(tempfile.mkdtemp())
live = sqlite3.connect(folder / "todo.db")
live.execute("CREATE TABLE todos (id INTEGER PRIMARY KEY, text TEXT NOT NULL)")
live.executemany("INSERT INTO todos (text) VALUES (?)", [(f"할 일 {i}",) for i in range(1000)])
live.commit()
backup_path = folder / "todo-2026-11-16.db"
dst = sqlite3.connect(backup_path)
live.backup(dst) # 쓰는 중에도 일관된 사본을 떠요
dst.close()
checksum = hashlib.sha256(backup_path.read_bytes()).hexdigest()
live.execute("DELETE FROM todos") # 사고: 누군가 WHERE 없이 지웠어요
live.commit()
print("운영 데이터:", live.execute("SELECT COUNT(*) FROM todos").fetchone()[0], "개")
def verify_and_count(path, expected):
if hashlib.sha256(path.read_bytes()).hexdigest() != expected:
return "백업 파일이 손상됐어요. 다른 백업을 찾아요"
con = sqlite3.connect(path)
result = con.execute("PRAGMA integrity_check").fetchone()[0], con.execute("SELECT COUNT(*) FROM todos").fetchone()[0]
con.close()
return result
print("백업 검사와 개수:", verify_and_count(backup_path, checksum))
broken = folder / "todo-broken.db"
data = bytearray(backup_path.read_bytes())
data[len(data) // 2] ^= 0xFF # 저장하는 동안 한 바이트가 망가졌다면
broken.write_bytes(bytes(data))
print("망가진 백업:", verify_and_count(broken, checksum))
live.close()
운영 데이터: 0 개
백업 검사와 개수: ('ok', 1000)
망가진 백업: 백업 파일이 손상됐어요. 다른 백업을 찾아요
- 일관된 사본을 떠요. 쓰고 있는 데이터베이스 파일을 그냥 복사하면 중간 상태가 섞일 수 있어요. SQLite의
backup, PostgreSQL의pg_dump처럼 데이터베이스가 제공하는 백업 방법을 써요. - 백업할 때 지문을 남겨요. 체크섬을 함께 저장해 두면, 저장하거나 옮기는 동안 한 바이트만 망가져도 복원하기 전에 알아챌 수 있어요.
- 복원해 봐야 알아요. 위에서는 백업을 실제로 열어 무결성 검사(
integrity_check)를 하고 개수까지 셌어요. 백업 작업이 몇 달째 조용히 실패하고 있었거나, 백업은 있는데 복원 방법을 아무도 모르는 일이 실제로 흔해요. 정해 둔 주기마다 복원 연습을 해요.
백업 계획을 세울 때 정할 두 숫자와 흔히 쓰는 규칙이 있어요.
| 정할 것 | 뜻 | 예 |
|---|---|---|
| RPO | 사고가 나면 최대 얼마만큼의 데이터를 잃어도 되나 | 하루 한 번 백업하면 최대 하루치 |
| RTO | 복원해서 다시 서비스하기까지 얼마나 걸려도 되나 | 한 시간 안에 |
- 3-2-1 규칙: 사본은 3개, 저장 매체는 2가지, 그중 1개는 다른 장소에 둬요. 서버와 같은 데이터 센터에만 있는 백업은 그 데이터 센터에 불이 나면 함께 사라져요.
- 지울 수 없는 사본도 하나: 랜섬웨어는 백업까지 찾아 암호화해요. 일정 기간 고치거나 지울 수 없게 잠그는 저장소나, 네트워크에서 떨어진 사본을 하나 둬요.
- 보관 기간을 정해요. 매일 백업은 2주, 매주 백업은 3개월처럼요. 실수를 몇 주 뒤에야 알아채는 경우도 있으니 오래된 사본도 남겨요.
사고가 났을 때
모든 준비를 해도 사고는 나요. 그때의 순서도 미리 정해 두면 당황하지 않아요.
- 피해를 멈춰요. 원인을 찾기 전에 먼저 되돌려요. 방금 배포했다면 앞 버전으로, 트래픽이 몰렸다면 기능을 잠시 꺼요.
- 알려요. 사용자에게 상태 페이지나 공지로 무슨 일이 있는지 알리고, 팀 안에서 한 사람이 상황을 정리하는 역할을 맡아요.
- 원인을 찾아요. 로그, 지표, 요청 번호로 흔적을 따라가요. 오늘 배운 것들이 여기서 쓰여요.
- 돌아봐요. 끝난 뒤에는 무슨 일이 있었고, 왜 알아채는 데 그만큼 걸렸고, 무엇을 바꿀지 글로 남겨요. 이때 사람을 탓하지 않아요. "누가 실수했나"가 아니라 "그 실수가 사고로 이어지게 둔 구조가 무엇인가"를 물어요. 실수한 사람을 탓하면 다음 사고는 숨겨져요.
실습
- 로그 예제에 응답 시간이 2초를 넘은 요청만 골라 주소별로 세는 코드를 더해 보세요.
mask_email처럼 전화번호의 가운데 네 자리를 가리는 함수를 만들고 로그에 적용해 보세요.- 응답 시간 예제에서 느린 요청 두 개를 없애면 평균과 p99는 어떻게 바뀌나요? 반대로 느린 요청을 다섯 개로 늘리면요?
- 오류 예산 예제에서 SLO를 99.95%로 올리면 이번 달 예산은 몇 개가 되고, 지금까지의 사고로 이미 넘었나요?
- 알림 예제에 "알림이 울린 뒤 10분 동안은 다시 울리지 않기" 규칙을 더해 보세요.
- 백업 예제를 매일 실행되는 함수로 바꾸고, 7일보다 오래된 백업 파일은 지우되 매주 일요일 백업은 남기게 해 보세요.
자주 하는 실수
- 사람만 읽을 수 있는 로그를 남긴다. 많아지면 아무도 못 읽어요. 구조화해서 남겨요.
- 로그에 개인정보와 비밀을 남긴다. 로그는 오래, 많은 곳에 보관돼요. 가리거나 남기지 않아요.
- 응답 시간을 평균으로만 본다. 느린 꼬리가 숨어요. p95와 p99를 봐요.
- 모든 이상에 알림을 건다. 알림 피로로 진짜 문제를 놓쳐요. 사용자의 증상과 지속 시간으로 걸어요.
- 서버 안에서만 감시한다. 서버가 통째로 죽으면 감시도 같이 죽어요. 바깥에서도 확인해요.
- 백업만 하고 복원해 보지 않는다. 필요한 순간에 쓸 수 없는 백업일 수 있어요.
- 백업을 서버 옆에만 둔다. 같은 사고에 함께 사라져요. 다른 장소에도 둬요.
- 사고 뒤에 사람을 탓한다. 다음 사고가 숨겨져요. 구조를 고쳐요.
점검 문제
- 로그를 JSON처럼 구조화해서 남기면 좋은 점은?
- 요청 번호를 모든 서버의 기록에 남기는 이유는?
- 응답 시간을 평균으로만 보면 안 되는 이유를 예제의 숫자로 설명해 보세요.
- 오류 예산이란 무엇이고, 어떤 결정에 쓰이나요?
- 한 번 튄 값에 울리지 않는 알림 규칙이 필요한 이유는?
- 백업에 체크섬을 함께 남기는 이유와, 복원 연습을 하는 이유는?
- RPO와 RTO는 각각 무엇인가요?
- 3-2-1 규칙이란? 지울 수 없는 사본이 따로 필요한 이유는?
- 사고를 돌아볼 때 사람을 탓하지 않는 이유는?
정답
- 기계가 읽을 수 있어서 "오류가 난 주소는?", "2초 넘게 걸린 요청은?" 같은 질문을 검색과 집계로 바로 할 수 있어요.
- 한 요청이 여러 서버를 거칠 때, 요청 번호 하나로 모든 곳의 기록을 모아 그 요청에 무슨 일이 있었는지 따라갈 수 있기 때문이에요.
- 예제에서 평균은 75.4ms로 괜찮아 보이지만 p99는 1,200ms였고, 100명 중 2명은 1초 넘게 기다렸어요. 평균은 소수의 느린 경험을 숨겨요.
- 목표(SLO)에서 허용한 실패의 양이에요. 예산이 넉넉하면 새 기능을 과감하게 배포하고, 많이 썼으면 위험한 배포를 미루고 안정화에 집중하는 결정에 써요.
- 금방 돌아오는 일시적인 값에도 울리면 알림이 너무 잦아져, 사람들이 알림을 무시하다 진짜 문제를 놓치기 때문이에요.
- 체크섬은 저장하거나 옮기는 동안 백업이 망가졌는지 복원 전에 알려 줘요. 복원 연습은 백업이 실제로 쓸 수 있는지, 복원 방법을 알고 있는지 확인하는 유일한 방법이에요.
- RPO는 사고가 났을 때 잃어도 되는 데이터의 최대 양(시간)이고, RTO는 복원해서 다시 서비스하기까지 걸려도 되는 최대 시간이에요.
- 사본 3개를 2가지 매체에 두고 그중 1개는 다른 장소에 두는 규칙이에요. 랜섬웨어 같은 공격은 연결된 백업까지 지우거나 암호화하기 때문에, 고치거나 지울 수 없는 사본이 따로 있어야 해요.
- 사람을 탓하면 다음 사고와 실수가 숨겨지기 때문이에요. 실수가 사고로 이어지게 둔 구조를 고쳐야 같은 사고가 반복되지 않아요.
다음 강의
서버 트랙을 마쳤어요. 이제 만든 것을 세상에 내놓고, 지켜보고, 되살릴 수 있어요. 다음은 보안 트랙이에요. 지금까지 곳곳에서 만난 XSS, SQL 주입, 비밀 관리 이야기를 한데 모아, 공격자가 어떻게 생각하는지와 서비스를 어떻게 지키는지 체계적으로 배워요.