모니터링, 로그, 백업: 서비스를 오래 살리는 습관

배포한 뒤에 서비스를 오래 살리는 세 가지 습관을 익혀요. 기계가 읽기 좋은 JSON 로그를 남기고 요청 번호로 한 요청의 흔적을 모으며 개인정보는 가리는 법, 평균이 숨기는 느린 꼬리를 p95와 p99로 드러내는 법, 한 달에 실패해도 되는 양을 정하는 오류 예산, 한 번 튄 값에는 울리지 않는 알림 규칙을 직접 계산해요. 백업은 떠 두는 것보다 복원해 보는 것이 중요하다는 걸 실제로 지운 데이터를 되살리고 망가진 백업을 걸러 내며 확인하고, 사고가 났을 때 무엇을 하고 어떻게 돌아보는지까지 다뤄요.

고급강의 6 / 6약 14분

서버를 만들고, 앞단을 두고, 컨테이너에 담고, 자동으로 배포했어요. 이제 서비스가 세상에 나갔어요. 그런데 진짜 일은 여기서부터예요. 서비스는 어느 날 느려지고, 어느 밤 멈추고, 누군가의 실수로 데이터가 지워져요. 그 순간 무슨 일이 일어나는지 볼 수 있는지, 그리고 되살릴 수 있는지가 서비스의 수명을 정해요. 이번 강의에서는 로그, 지표, 알림, 백업이라는 습관을 다뤄요.

로그: 무슨 일이 있었는지

첫 강의의 서버는 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개월처럼요. 실수를 몇 주 뒤에야 알아채는 경우도 있으니 오래된 사본도 남겨요.

사고가 났을 때

모든 준비를 해도 사고는 나요. 그때의 순서도 미리 정해 두면 당황하지 않아요.

  1. 피해를 멈춰요. 원인을 찾기 전에 먼저 되돌려요. 방금 배포했다면 앞 버전으로, 트래픽이 몰렸다면 기능을 잠시 꺼요.
  2. 알려요. 사용자에게 상태 페이지나 공지로 무슨 일이 있는지 알리고, 팀 안에서 한 사람이 상황을 정리하는 역할을 맡아요.
  3. 원인을 찾아요. 로그, 지표, 요청 번호로 흔적을 따라가요. 오늘 배운 것들이 여기서 쓰여요.
  4. 돌아봐요. 끝난 뒤에는 무슨 일이 있었고, 왜 알아채는 데 그만큼 걸렸고, 무엇을 바꿀지 글로 남겨요. 이때 사람을 탓하지 않아요. "누가 실수했나"가 아니라 "그 실수가 사고로 이어지게 둔 구조가 무엇인가"를 물어요. 실수한 사람을 탓하면 다음 사고는 숨겨져요.

실습

  1. 로그 예제에 응답 시간이 2초를 넘은 요청만 골라 주소별로 세는 코드를 더해 보세요.
  2. mask_email처럼 전화번호의 가운데 네 자리를 가리는 함수를 만들고 로그에 적용해 보세요.
  3. 응답 시간 예제에서 느린 요청 두 개를 없애면 평균과 p99는 어떻게 바뀌나요? 반대로 느린 요청을 다섯 개로 늘리면요?
  4. 오류 예산 예제에서 SLO를 99.95%로 올리면 이번 달 예산은 몇 개가 되고, 지금까지의 사고로 이미 넘었나요?
  5. 알림 예제에 "알림이 울린 뒤 10분 동안은 다시 울리지 않기" 규칙을 더해 보세요.
  6. 백업 예제를 매일 실행되는 함수로 바꾸고, 7일보다 오래된 백업 파일은 지우되 매주 일요일 백업은 남기게 해 보세요.

자주 하는 실수

  • 사람만 읽을 수 있는 로그를 남긴다. 많아지면 아무도 못 읽어요. 구조화해서 남겨요.
  • 로그에 개인정보와 비밀을 남긴다. 로그는 오래, 많은 곳에 보관돼요. 가리거나 남기지 않아요.
  • 응답 시간을 평균으로만 본다. 느린 꼬리가 숨어요. p95와 p99를 봐요.
  • 모든 이상에 알림을 건다. 알림 피로로 진짜 문제를 놓쳐요. 사용자의 증상과 지속 시간으로 걸어요.
  • 서버 안에서만 감시한다. 서버가 통째로 죽으면 감시도 같이 죽어요. 바깥에서도 확인해요.
  • 백업만 하고 복원해 보지 않는다. 필요한 순간에 쓸 수 없는 백업일 수 있어요.
  • 백업을 서버 옆에만 둔다. 같은 사고에 함께 사라져요. 다른 장소에도 둬요.
  • 사고 뒤에 사람을 탓한다. 다음 사고가 숨겨져요. 구조를 고쳐요.

점검 문제

  1. 로그를 JSON처럼 구조화해서 남기면 좋은 점은?
  2. 요청 번호를 모든 서버의 기록에 남기는 이유는?
  3. 응답 시간을 평균으로만 보면 안 되는 이유를 예제의 숫자로 설명해 보세요.
  4. 오류 예산이란 무엇이고, 어떤 결정에 쓰이나요?
  5. 한 번 튄 값에 울리지 않는 알림 규칙이 필요한 이유는?
  6. 백업에 체크섬을 함께 남기는 이유와, 복원 연습을 하는 이유는?
  7. RPO와 RTO는 각각 무엇인가요?
  8. 3-2-1 규칙이란? 지울 수 없는 사본이 따로 필요한 이유는?
  9. 사고를 돌아볼 때 사람을 탓하지 않는 이유는?

정답

  1. 기계가 읽을 수 있어서 "오류가 난 주소는?", "2초 넘게 걸린 요청은?" 같은 질문을 검색과 집계로 바로 할 수 있어요.
  2. 한 요청이 여러 서버를 거칠 때, 요청 번호 하나로 모든 곳의 기록을 모아 그 요청에 무슨 일이 있었는지 따라갈 수 있기 때문이에요.
  3. 예제에서 평균은 75.4ms로 괜찮아 보이지만 p99는 1,200ms였고, 100명 중 2명은 1초 넘게 기다렸어요. 평균은 소수의 느린 경험을 숨겨요.
  4. 목표(SLO)에서 허용한 실패의 양이에요. 예산이 넉넉하면 새 기능을 과감하게 배포하고, 많이 썼으면 위험한 배포를 미루고 안정화에 집중하는 결정에 써요.
  5. 금방 돌아오는 일시적인 값에도 울리면 알림이 너무 잦아져, 사람들이 알림을 무시하다 진짜 문제를 놓치기 때문이에요.
  6. 체크섬은 저장하거나 옮기는 동안 백업이 망가졌는지 복원 전에 알려 줘요. 복원 연습은 백업이 실제로 쓸 수 있는지, 복원 방법을 알고 있는지 확인하는 유일한 방법이에요.
  7. RPO는 사고가 났을 때 잃어도 되는 데이터의 최대 양(시간)이고, RTO는 복원해서 다시 서비스하기까지 걸려도 되는 최대 시간이에요.
  8. 사본 3개를 2가지 매체에 두고 그중 1개는 다른 장소에 두는 규칙이에요. 랜섬웨어 같은 공격은 연결된 백업까지 지우거나 암호화하기 때문에, 고치거나 지울 수 없는 사본이 따로 있어야 해요.
  9. 사람을 탓하면 다음 사고와 실수가 숨겨지기 때문이에요. 실수가 사고로 이어지게 둔 구조를 고쳐야 같은 사고가 반복되지 않아요.

다음 강의

서버 트랙을 마쳤어요. 이제 만든 것을 세상에 내놓고, 지켜보고, 되살릴 수 있어요. 다음은 보안 트랙이에요. 지금까지 곳곳에서 만난 XSS, SQL 주입, 비밀 관리 이야기를 한데 모아, 공격자가 어떻게 생각하는지와 서비스를 어떻게 지키는지 체계적으로 배워요.