Devin.KR

AI 개발 · 실무

AI 시대의 보안 코딩과 보안 점검 - AI 가 짠 코드를 안전하게

로그·모니터링·사고 대응 - 이상 징후를 놓치지 않기

보안 로그에 남길 것과 남기면 안 되는 것, 로그인 실패 급증 탐지, 경보 기준, 사고 대응 단계(탐지·격리·복구·회고), 완성 코드는 고정 로그 묶음에서 이상 패턴을 찾아 사고 보고서 초안을 출력

개발자KR · 원고 갱신

이 장에서 배우는 것

앞 장에서는 정적 분석과 지속적 통합(CI)으로 게시판 코드의 문제를 배포 전에 찾았다. 게시판이 운영에 들어가면 실행 중에만 드러나는 문제도 살펴야 한다. 로그인 기능이 명세대로 실패 응답을 보내고 있어도, 같은 계정에서 짧은 시간에 실패가 몰린다면 운영자가 확인할 이유가 생긴다. 그 이유를 설명하려면 먼저 어떤 일이 언제 일어났는지 재구성할 수 있어야 한다.

  • 로그인 결과를 조사에 필요한 필드만 담은 보안 로그로 남긴다.
  • 계정별 로그인 실패를 이동 시간 창에서 세어 경보를 만든다.
  • 경보의 관측 사실과 조사 가설을 사고 보고서 초안에서 구분한다.
  • 고정 로그 묶음을 재실행해 실패 누락, 시간 경계, 중복 경보를 검사한다.

문제 상황

작은 게시판에서 이용자 한 명이 오전에 로그인이 되지 않았다고 문의한다. 운영자가 남은 로그를 열어 보니 로그인 성공은 계정별로 찾을 수 있다. 실패는 응답을 보내는 분기에서 바로 반환되므로 기록이 비어 있다. 문의가 한 건이라는 사실만으로는 실패도 한 건이었는지 알 수 없다. 같은 계정에서 여러 번 실패했는지, 다른 계정에서도 비슷한 시각에 문제가 생겼는지 확인할 자료가 없다.

팀에서 쓰던 AI에 실패 로그를 추가해 달라고 요청하자, 로그인 요청 전체를 기록하자는 초안이 나왔다고 가정하자. 그 방식은 실패를 조사할 단서를 늘리는 동시에 비밀번호와 같은 입력을 로그 저장소로 복제한다. 로그는 장애 분석을 위해 여러 사람이 조회하거나 별도로 보관할 수 있다. 인증에만 쓰던 값이 로그에 들어가는 순간 그 값을 다루는 저장소와 접근 경로가 늘어난다.

게시판의 로그인 성공과 실패를 같은 형식으로 기록하라. 로그 함수에는 UTC 시각, 내부 계정 참조값, 서버가 정한 결과만 넘겨라. 고정된 예제에서 같은 계정의 5분 이내 실패가 3건에 도달하면 경보를 내고, 관측 범위와 증거 사건 ID를 보고서 초안에 표시하라. 실패 누락, 시간 창 경계, 후속 실패로 인한 중복 경보를 검사하라.

리뷰에서는 로그인 결과가 결정된 지점부터 반환문까지 따라간다. 성공과 실패가 같은 기록 지점을 지나가는지, 로그 함수에 전달되는 값이 어디서 만들어지는지 확인한다. 변경 비교(diff)에서는 성공 조건이 그대로인지와 요청 본문을 기록하는 호출이 생기지 않았는지를 확인한다. 완성 코드의 두 처리 함수는 이미 결정된 로그인 결과를 입력으로 받는다. 따라서 인증 내부를 재현하지 않고도 결과 기록의 전후 차이를 실행으로 확인할 수 있다.

조사에 필요한 로그 설계

보안 로그의 한 행은 특정 시각에 발생한 한 사건을 나타낸다. 이 장에서는 사건 ID, 시각, 계정 참조값, 결과를 고정 필드로 둔다. 운영에서 로그인 외의 사건을 같은 곳에 저장한다면 사건 종류도 별도 필드로 둔다. 자유 형식 문장과 달리 고정 필드는 계정으로 묶고 시각으로 정렬할 때 매번 문장을 해석할 필요가 없다. 결과 역시 요청에서 받은 문자열 대신 서버가 정한 값으로 기록한다.

로그인 결과를 조사할 때 필요한 값과 기록 정책
항목기록 정책조사에서 쓰는 곳
시각과 사건 ID협정 세계시(UTC)와 서버가 부여한 고유 ID를 남긴다.사건 순서를 재구성하고 보고서에서 원본 행을 찾는다.
계정 참조값서비스 내부의 불투명한 참조값을 남긴다.같은 계정의 사건을 묶는다.
성공과 실패서버가 정한 두 값 중 하나를 남긴다.실패 증가와 이후의 성공을 각각 확인한다.
비밀번호, 쿠키, 인증 헤더로그에서 제외한다. 요청 본문과 헤더 묶음도 통째로 기록하지 않는다.조사에는 확정된 결과와 사건 ID를 이용한다.

예제의 acct-17은 이미 알아낸 내부 계정 참조값이다. 운영에서 어떤 계정인지 확인되지 않은 실패도 집계 대상이 될 수 있다. 그런 사건에는 계정 미확인 상태를 표시하고, 그 집계를 계정별 실패와 별도로 해석한다. 미확인 사건이 모두 같은 값을 쓴다면 해당 값으로 묶인 기록은 서로 다른 시도의 합계다. 사용자가 입력한 이메일이나 표시 이름을 그대로 복사하면 오타도 식별값이 되고 조사 자료에 개인정보가 쌓인다. 내부 참조값도 서비스 안에서는 계정과 연결되므로 조회 권한과 보존 기간을 정한다.

로그 시각에는 사건이 일어난 시각을 사용한다. 여러 프로세스에서 받은 기록을 모을 때는 도착 순서가 발생 순서와 다를 수 있다. 사건 ID가 있다면 보고서에 요청 전체를 붙이지 않고도 권한이 있는 사람이 해당 행을 찾아볼 수 있다. 예제의 ID는 한 실행 안에서 순번으로 만들고, 운영에서는 수집 범위 전체에서 같은 ID가 다른 사건을 가리키지 않도록 한다.

로그인 실패 급증을 세는 기준

게시판 예제의 기준은 한 계정에서 실패가 5분 이내에 3건 모이는 경우다. 이 숫자는 계산과 검사를 위한 예시다. 실패가 들어올 때마다 해당 계정의 현재 시각을 기준으로 직전 5분을 본다. 현재 실패와 정확히 5분 전의 실패를 모두 포함한다. 시간 창의 앞쪽 경계를 포함한다는 규칙은 테스트로 고정한다.

09시 05분에 끝나는 5분 창에는 왼쪽 경계의 실패까지 세 건이 포함된다.

acct-17에 09시 00분, 09시 02분, 09시 05분 실패가 있다면 09시 05분에 기준에 도달한다. 09시 02분에 기록된 acct-42의 실패는 다른 계정의 창에 들어간다. 09시 06분에 acct-17이 다시 실패하면 09시 00분은 창 밖으로 나가지만 09시 02분, 09시 05분, 09시 06분이 남는다. 같은 계정에서 기준을 계속 충족하는 동안 새 경보를 매번 만들면 운영자는 같은 상황을 여러 번 읽게 된다.

완성 코드는 이전 실패 시점에 경보가 활성화돼 있었는지 기억한다. 다음 실패가 들어오면 먼저 오래된 사건을 걷어 낸다. 그 결과 창에 앞선 실패가 하나도 남지 않았다면 이전 경보 상태를 해제한다. 이어 현재 실패를 더하고 다시 기준을 확인한다. 따라서 이 예제의 경보 묶음은 연속한 실패 사이에 5분을 초과하는 간격이 생길 때 끝난다. 그 전에는 창 안의 수가 잠시 3건 아래로 내려갔다가 회복되더라도 한 묶음으로 본다. 09시 06분의 실패가 두 번째 경보를 만들지 않는 이유도 이 규칙에 있다.

경보를 받는 쪽에서는 5분과 3건 외에 누가 확인할지, 어떤 기록을 함께 볼지 정한다. 자기 게시판의 평소 실패 빈도와 운영 중 확인 가능한 경보량을 기준으로 수치를 조정한다. 예를 들어 평소 이용자가 비밀번호를 여러 번 다시 입력하는 게시판이라면 낮은 기준에서 경보가 자주 생길 수 있다. 반대로 기준을 크게 올리면 작은 증가가 화면에 나타나지 않는다. 기준을 조정할 때는 고정 로그에서 어떤 경보가 생기거나 사라지는지 먼저 확인한다.

성공은 실패 수에 더하지 않으며, 창에 남아 있는 실패를 지우지도 않는다. 09시 07분의 성공은 경보가 만들어진 뒤에 관측된 별도 사건이다. 성공 이전에 실패가 있었다는 사실도, 성공으로 무엇이 이루어졌는지도 따로 읽는다. 보고서에는 자료의 마지막 시각을 함께 적는다. 그 뒤의 사건을 관측할 수 있는지는 로그가 어디까지 준비됐는지에 달려 있다.

경보에서 사고 대응으로

경보는 정해 둔 관측 기준을 넘었다는 사실을 전달한다. 로그인 실패 급증은 입력 실수, 게시판 로그인 장애, 의도하지 않은 계정 사용 시도 등 여러 상황에서 나타날 수 있다. 여러 계정에서 함께 늘었다면 같은 시각의 서비스 오류 기록을 확인하고, 한 계정에 집중됐다면 그 계정에 이어진 성공과 서비스 내 활동을 확인한다. 로그인 성공 한 건의 기록만으로 로그인한 사람이 누구였는지 판정할 수는 없다.

발견한 증거를 보존하고 영향 범위를 확인한 뒤 격리, 복구, 회고를 진행한다.
게시판 로그인 이상을 확인한 뒤 단계별로 남길 근거
단계할 일기록할 내용
탐지경보 조건과 원본 사건을 확인하고 담당자를 정한다.발견 시각, 조사 범위, 사건 ID
격리영향이 확인된 범위에서 의심 세션 제한 등 필요한 조치를 선택한다.대상, 조치 시각, 판단 근거
복구원인을 조치한 뒤 담당자가 정상 로그인과 필요한 권한을 확인한다.확인 항목, 관측 결과, 서비스 재개 시각
회고타임라인을 검토해 놓친 기록과 불필요했던 경보를 찾는다.개선 항목, 담당자, 재검사 방법

탐지 직후에는 관련 기록이 정기 삭제로 사라지기 전에 조사 범위와 원본 위치를 남긴다. 영향이 확인돼 격리가 필요하면 누가 어떤 근거로 범위를 정했는지 기록한다. 복구 후에는 정상 로그인만 확인하고 끝내기보다 같은 조건에서 로그가 남고 경보가 도달하는지도 확인한다. 회고에서는 경보를 본 시각과 실제 사건 시각을 구분해 어느 구간에서 대응이 늦었는지 살핀다.

완성 코드

main.py

고정 입력의 각 항목은 시각, 계정 참조값, 이미 결정된 로그인 결과를 담는다. 이전 처리 함수와 고친 처리 함수에 같은 입력을 전달한다. 두 함수의 반환값을 비교하고, 고친 함수에서 얻은 사건으로 경보와 보고서 초안을 만든다. 파일에 적힌 입력 순서를 일부러 섞어 두어 탐지가 사건 발생 시각을 사용하는지 확인할 수 있다.

from collections import defaultdict, deque
from dataclasses import dataclass
from datetime import datetime, timedelta, timezone


WINDOW = timedelta(minutes=5)
THRESHOLD = 3

LOGIN_RESULTS = (
    ("09:02", "acct-42", False),
    ("09:00", "acct-17", False),
    ("09:02", "acct-17", False),
    ("09:05", "acct-17", False),
    ("09:06", "acct-17", False),
    ("09:07", "acct-17", True),
)


@dataclass(frozen=True)
class Event:
    event_id: str
    at: datetime
    account: str
    succeeded: bool


@dataclass(frozen=True)
class Alert:
    account: str
    evidence: tuple[Event, ...]


def fixed_time(clock: str) -> datetime:
    hour, minute = map(int, clock.split(":"))
    return datetime(2026, 10, 12, hour, minute, tzinfo=timezone.utc)


def before(events: list[Event], event: Event) -> bool:
    if not event.succeeded:
        return False
    events.append(event)
    return True


def after(events: list[Event], event: Event) -> bool:
    events.append(event)
    return event.succeeded


def detect(events: list[Event]) -> list[Alert]:
    failures: dict[str, deque[Event]] = defaultdict(deque)
    active: set[str] = set()
    alerts: list[Alert] = []

    for event in sorted(events, key=lambda item: (item.at, item.event_id)):
        if event.succeeded:
            continue

        recent = failures[event.account]
        start = event.at - WINDOW
        while recent and recent[0].at < start:
            recent.popleft()

        if not recent:
            active.discard(event.account)

        recent.append(event)
        if len(recent) >= THRESHOLD and event.account not in active:
            alerts.append(Alert(event.account, tuple(recent)))
            active.add(event.account)

    return alerts


def verify_detection() -> None:
    boundary = [
        Event("b1", fixed_time("09:00"), "acct-test", False),
        Event("b2", fixed_time("09:02"), "acct-test", False),
        Event("b3", fixed_time("09:05"), "acct-test", False),
        Event("b4", fixed_time("09:06"), "acct-test", False),
    ]
    alerts = detect(list(reversed(boundary)))
    assert len(alerts) == 1
    assert [event.event_id for event in alerts[0].evidence] == [
        "b1", "b2", "b3"
    ]

    outside = [
        boundary[0],
        boundary[1],
        Event("b5", fixed_time("09:06"), "acct-test", False),
    ]
    assert detect(outside) == []

    resumed = boundary + [
        Event("b6", fixed_time("09:12"), "acct-test", False),
        Event("b7", fixed_time("09:13"), "acct-test", False),
        Event("b8", fixed_time("09:14"), "acct-test", False),
    ]
    assert len(detect(resumed)) == 2

    mixed = [
        boundary[0],
        Event("b9", fixed_time("09:02"), "acct-other", False),
        Event("b10", fixed_time("09:03"), "acct-test", True),
        boundary[2],
    ]
    assert detect(mixed) == []


def report(alert: Alert, events: list[Event]) -> None:
    observed_from = min(event.at for event in events)
    observed_until = max(event.at for event in events)
    detected_at = alert.evidence[-1].at
    later_successes = sorted(
        (
            event
            for event in events
            if event.account == alert.account
            and event.succeeded
            and event.at > detected_at
        ),
        key=lambda event: (event.at, event.event_id),
    )

    print("사고 보고서 초안")
    print(f"관측 범위: {observed_from:%Y-%m-%d %H:%M}~{observed_until:%H:%M} UTC")
    print(f"탐지 시각: {detected_at:%H:%M} UTC")
    print(f"관측 사실: {alert.account}에서 5분 이내 로그인 실패 {len(alert.evidence)}건")
    print("증거 사건: " + ", ".join(event.event_id for event in alert.evidence))

    if later_successes:
        summary = ", ".join(
            f"{event.event_id}({event.at:%H:%M} UTC)" for event in later_successes
        )
        print(f"탐지 이후 같은 계정의 성공: {summary}")
    else:
        print("탐지 이후 같은 계정의 성공: 관측 범위 내 0건")

    print("판단: 원인과 영향 범위 확인 중")
    print("격리: 후속 성공과 관련 활동을 확인한 뒤 필요 범위를 결정")
    print("복구: 원인 조치 후 정상 로그인과 로그 수집 확인 예정")
    print("회고: 실패 누락 방지 검사와 경보 기준 검토 예정")


def main() -> None:
    old_events: list[Event] = []
    new_events: list[Event] = []

    for number, (clock, account, succeeded) in enumerate(LOGIN_RESULTS, start=1):
        event = Event(f"evt-{number:02d}", fixed_time(clock), account, succeeded)
        old_result = before(old_events, event)
        new_result = after(new_events, event)
        assert old_result == new_result == succeeded

    old_alerts = detect(old_events)
    new_alerts = detect(new_events)
    old_failures = sum(not event.succeeded for event in old_events)
    new_failures = sum(not event.succeeded for event in new_events)

    assert (old_failures, new_failures) == (0, 5)
    assert len(old_alerts) == 0
    assert len(new_alerts) == 1
    verify_detection()

    print(f"수정 전: 실패 기록 {old_failures}건, 경보 {len(old_alerts)}건")
    print(f"수정 후: 실패 기록 {new_failures}건, 경보 {len(new_alerts)}건")
    print("경계·중복·재탐지·계정 분리 검사 통과")
    print()
    for alert in new_alerts:
        report(alert, new_events)


if __name__ == "__main__":
    main()

줄별 해설

WINDOW와 THRESHOLD는 탐지 규칙이다. 그 아래의 LOGIN_RESULTS는 날짜가 같은 여섯 사건을 정의한다. 서로 다른 계정이 같은 분에 실패하는 행도 넣었다. fixed_time은 각 입력에 고정된 날짜와 UTC 정보를 붙인다. 현재 시각이나 시스템의 시간대 설정을 읽지 않으므로 같은 입력을 실행하면 같은 관측 범위가 나온다.

Event의 필드는 로그가 받는 값의 범위를 드러낸다. 이 예제에서는 계정 참조값과 결과를 고정 데이터에서 가져오므로 요청 객체는 로그 기록 경로에 등장하지 않는다. before의 첫 반환문은 실패 행이 사라지는 지점이다. after에서는 성공과 실패가 모두 append를 지난다. main의 결과 비교는 기록 지점을 옮긴 뒤에도 반환값이 같음을 입력마다 검사한다.

detect의 정렬 키는 사건 시각을 먼저, 사건 ID를 다음에 적용한다. 같은 시각의 사건은 ID로 순서를 고정한다. failures는 계정별 양쪽 끝 큐(deque)를 만들며 각 큐의 왼쪽에 가장 오래된 실패가 있다. 현재 시각에서 5분을 뺀 start보다 이른 행만 왼쪽에서 제거한다. 비교에 <를 써서 경계에 딱 걸린 행을 남긴다. 성공을 만나면 해당 반복을 건너뛰므로 큐를 수정하지 않는다.

active에는 현재 묶음에서 이미 경보를 낸 계정을 둔다. 오래된 행을 제거한 뒤 큐가 비어 있으면 discard로 그 계정을 집합에서 뺀다. 그 후 현재 실패를 넣고 경보 여부를 판단한다. 경보 증거에는 큐를 튜플로 복사한다. 뒤에서 큐가 바뀌어도 보고서에 들어갈 사건 목록은 경보가 만들어진 시점 그대로다.

verify_detection에서 뒤집은 입력은 정렬과 5분 경계를 함께 검사한다. 경보가 하나라는 사실 외에도 어느 사건 세 개가 경보를 만들었는지 비교한다. outside는 6분 전 실패가 빠지는 경우다. resumed는 마지막 실패에서 6분 뒤 새 묶음이 시작되는 경우다. mixed는 다른 계정의 실패와 같은 계정의 성공이 실패 수에 섞이는 회귀를 잡는다.

report의 관측 시작과 끝은 전체 예제 로그의 최소와 최대 시각이다. 개별 경보의 발생 시각은 증거 중 마지막 행의 시각이다. 이후 성공은 같은 계정에서 그 시각보다 뒤에 발생한 성공으로 정의한다. 시각이 같으면 이 보고서의 ‘이후’에는 포함하지 않는다. 마지막 네 줄은 아직 확인하지 않은 판단과 대응 상태다. 사건을 탐지하는 코드가 계정을 잠그거나 복구를 완료했다고 표시하는 호출은 없다.

실행 결과

macOS나 Linux에서 Python 3.12 이상을 사용한다. 첫 명령은 경고를 오류로 처리하도록 설정해 문법을 검사한다. 통과하면 첫 명령에서 출력은 없다. 두 번째 명령은 고정 입력으로 검사를 수행하고 초안을 출력한다.

python3 -W error -m py_compile main.py
python3 main.py
수정 전: 실패 기록 0건, 경보 0건
수정 후: 실패 기록 5건, 경보 1건
경계·중복·재탐지·계정 분리 검사 통과

사고 보고서 초안
관측 범위: 2026-10-12 09:00~09:07 UTC
탐지 시각: 09:05 UTC
관측 사실: acct-17에서 5분 이내 로그인 실패 3건
증거 사건: evt-02, evt-03, evt-04
탐지 이후 같은 계정의 성공: evt-06(09:07 UTC)
판단: 원인과 영향 범위 확인 중
격리: 후속 성공과 관련 활동을 확인한 뒤 필요 범위를 결정
복구: 원인 조치 후 정상 로그인과 로그 수집 확인 예정
회고: 실패 누락 방지 검사와 경보 기준 검토 예정

수정 후 실패 기록은 전체 계정과 관측 범위를 합해 5건이다. 초안의 3건은 경보 시점에 acct-17의 창 안에 있던 증거 수다. 다른 계정의 09시 02분 실패와 경보 이후의 09시 06분 실패도 기록돼 있으므로, 5건과 3건은 각각의 집계 범위에 맞는 값이다.

실무에서 자주 틀리는 것

실패 분기에서 기록 전에 반환한다

아래 검사에서 틀린 함수는 성공 분기까지 도달한 결과만 기록한다. 고친 함수는 결과를 먼저 기록하고 동일한 결과를 반환한다. 두 함수에 같은 실패 입력을 줘서 호출자에게 돌아오는 값과 운영자가 볼 수 있는 기록을 함께 비교한다.

def wrong(log, succeeded):
    if not succeeded:
        return False
    log.append("success")
    return True


def fixed(log, succeeded):
    log.append("success" if succeeded else "failure")
    return succeeded


old_log, new_log = [], []
assert wrong(old_log, False) == fixed(new_log, False) == False
print(old_log, new_log)

출력은 [] ['failure']다. 실제 변경 비교에서도 실패 응답을 보내기 직전 로그 호출이 실행되는지 확인한다.

진단 편의를 위해 요청 구조 전체를 전달한다

요청 구조에는 새 필드가 추가될 수 있다. 기록 함수가 요청 구조를 그대로 받으면 호출부를 손대지 않아도 로그가 수집하는 항목이 늘어난다. 다음 검사에서는 가짜 필드와 가짜 값만 사용해 어떤 키가 결과에 남는지 비교한다.

def wrong(request, account):
    return {"account": account, "request": request}


def fixed(account, outcome):
    return {"account": account, "outcome": outcome}


sample = {"password": "test-only"}
old = wrong(sample, "acct-17")
new = fixed("acct-17", "failure")
assert "password" in old["request"]
assert set(new) == {"account", "outcome"}
print(sorted(old), sorted(new))

검사 출력은 키 이름만 보여 준다. 검토할 때는 account와 outcome도 실제로 서비스 내부에서 결정되는지 호출부에서 확인한다.

시간 창 경계가 비교 연산자에 묻힌다

정확히 5분 전을 포함한다는 합의가 있어도 비교 연산자가 다르면 경보가 한 번 늦어질 수 있다. 아래 검사는 현재 시각을 09시 05분으로 놓고 후보 사건이 남는지 확인한다. 분 단위 정수는 이 경계만 재현하기 위한 입력이다.

def wrong(event_minute, start_minute):
    return event_minute > start_minute


def fixed(event_minute, start_minute):
    return event_minute >= start_minute


candidate = 0
window_start = 5 - 5
assert wrong(candidate, window_start) is False
assert fixed(candidate, window_start) is True
print(wrong(candidate, window_start), fixed(candidate, window_start))

출력은 False True다. 완성 코드에서는 포함 조건을 직접 쓰는 대신 그 반대인 ‘시작 시각보다 이르다’는 조건으로 제거한다. 두 방식의 경계는 같다.

경보가 만들어진 시점의 증거를 큐에 맡겨 둔다

실패 창은 다음 사건을 처리할 때 바뀐다. 경보에 창의 참조를 저장하면 뒤늦게 펼쳐 본 보고서에서 최초 실패가 사라진다. 아래 검사는 목록의 첫 항목을 뺀 뒤 각 경보에서 무엇을 읽는지 비교한다.

def wrong(recent):
    return recent


def fixed(recent):
    return tuple(recent)


recent = ["evt-02", "evt-03", "evt-04"]
old_evidence = wrong(recent)
new_evidence = fixed(recent)
recent.pop(0)
assert list(old_evidence) == ["evt-03", "evt-04"]
assert list(new_evidence) == ["evt-02", "evt-03", "evt-04"]
print(len(old_evidence), len(new_evidence))

출력은 2 3이다. 보고서에 있는 사건 ID를 원본에서 다시 조회할 수 있으면 탐지 기준을 사후에 검토할 수 있다.

한눈에 보기

로그인 결과 기록부터 사고 보고서까지 확인할 항목
확인 지점구현 규칙확인 자료
로그 기록성공과 실패를 같은 경로에서 기록한다.같은 입력의 수정 전후 실패 수와 동일한 반환값
필드 선택시각, 사건 ID, 계정 참조값, 결과를 고정 필드로 둔다.기록 함수의 입력과 저장할 필드의 변경 비교
실패 급증계정별로 경계를 포함한 직전 5분의 실패를 센다.경계 바로 위와 밖, 다른 계정, 성공 혼입 검사
중복 경보실패 사이 간격이 5분을 초과한 뒤 새 묶음을 시작한다.연속 실패와 긴 간격 뒤의 재탐지 검사
대응 기록관측 범위, 증거, 판단 상태, 대응 단계를 남긴다.원본 사건 ID와 조치 시각이 있는 타임라인

연습 문제

  1. 완성 코드에서 09시 05분의 acct-17 실패를 09시 06분으로 옮긴다. 원래 09시 06분 실패는 그대로 둔다. 첫 경보 시각과 증거 ID를 적고, 두 행의 시각이 같을 때도 결과가 결정적인 이유를 설명한다.
  2. detect의 제거 조건을 recent[0].at <= start로 바꾸면 원래 입력에서 언제 첫 경보가 생기는지 계산한다. verify_detection에서 어떤 비교가 이 변화를 적발하는지도 찾는다.
  3. 원래 입력에 acct-42의 09시 04분과 09시 05분 실패를 그 순서대로 끝에 추가한다. 두 경보의 출력 순서와 두 번째 경보의 증거 ID를 적는다.
  4. 예제와 같은 경보를 받은 운영자가 후속 성공을 발견했다. 초안에 바로 적을 수 있는 사실 한 문장과 격리 범위를 정하기 전에 확인할 사항 한 문장을 쓴다.

정답과 해설

  1. 첫 경보는 09시 06분에 생기고 증거는 evt-03, evt-04, evt-05다. 09시 00분 실패는 창 밖이다. 같은 시각인 evt-04와 evt-05는 사건 ID 순서로 처리되므로 마지막 행을 넣을 때 3건이 된다.
  2. 09시 05분에는 왼쪽 경계의 09시 00분 행까지 제거하므로 2건만 남는다. 첫 경보는 09시 06분에 생긴다. 경보 수가 하나라는 비교는 여전히 통과한다. 그 아래 증거 ID 비교는 기대값 b1, b2, b3 대신 b2, b3, b4가 들어와 실패한다.
  3. acct-17의 경보가 먼저 나오고 acct-42가 이어진다. 두 번째 경보의 증거는 evt-01, evt-07, evt-08이다. 두 경보는 09시 05분에 발생하며, 그 시각에서 acct-17의 세 번째 실패 ID인 evt-04를 먼저 처리한다.
  4. 관측 사실은 ‘09시 07분 UTC에 같은 계정의 로그인 성공이 한 건 기록됐다’로 쓸 수 있다. 이어 ‘그 성공의 사건 ID를 기준으로 연결된 세션과 이후 게시판 활동을 확인한다’고 적을 수 있다. 격리가 필요하다고 판단하면 확인한 영향 범위를 근거와 함께 남긴다.

현업에서 이렇게 본다

당직 중에 경보를 읽을 때 가장 먼저 찾는 것은 시각과 원본을 열 수 있는 단서다. 보고서에 실패 수만 있으면 집계 창이 어디서 시작됐는지 다시 물어야 한다. 계정 참조값과 증거 사건 ID가 있으면 교대하는 사람도 같은 기록에서 조사를 이어 갈 수 있다. 회고에서 ‘로그를 더 남긴다’고만 쓰면 다음 변경을 리뷰하기 어렵다. ‘실패 반환 전에 결과를 기록하고 경계에 걸린 사건 ID를 검사한다’고 적으면 무엇을 실행해 확인할지 정해진다. 다음 장의 출시 전 점검에서는 이처럼 실행으로 확인한 결과를 점검 보고서의 근거로 사용한다.

오탈자·오류 제보 비공개로 접수되어 원고 수정에 반영됩니다

이메일 등 개인정보는 받지 않습니다. 답변이 필요한 질문은 아래 댓글을 이용해 주세요.

READER FEEDBACK

질문·의견

내용에 관한 질문이나 더 나은 설명을 위한 의견을 남겨 주세요. 오탈자는 위의 제보 양식이 더 빨리 반영됩니다. 이 댓글은 원래 게시글과 같은 자리에 쌓입니다.

댓글 0

아직 댓글이 없습니다. 첫 댓글을 남겨 보세요.

댓글을 남기려면 로그인이 필요합니다.