데이터 수집과 파이프라인

AI 서비스의 대부분은 데이터를 모으고 다듬는 일이에요. 연습용 쇼핑몰 서버를 직접 띄워서 robots.txt와 요청 간격을 지키며 BeautifulSoup으로 상품 정보를 수집하고, 제각각인 가격 표기를 정제하고, 이상한 값을 격리하고, 같은 날 여러 번 돌려도 기록이 늘지 않게 SQLite에 저장해요. 날마다 쌓이는 가격 기록, 사라진 상품 처리, 사이트 구조가 바뀌었을 때 조용히 망가지지 않고 멈추는 감시까지 파이프라인 전체를 만들어요.

중급강의 2 / 6약 20분

AI 프로젝트에서 모델을 다루는 시간은 생각보다 짧아요. 대부분의 시간은 데이터를 모으고, 다듬고, 믿을 수 있게 관리하는 일에 들어가요. RAG의 문서도, 파인튜닝의 예시도, 평가 세트도 결국 데이터예요. 데이터가 엉망이면 아무리 좋은 모델도 엉망인 결과를 내요.

데이터를 정해진 순서대로, 정기적으로, 사람 손 없이 흘려보내는 장치를 데이터 파이프라인이라고 해요. 이번 강의에서는 쇼핑몰의 상품 가격을 날마다 모아 기록하는 파이프라인을 처음부터 만들어요.

  1. 수집: 원천에서 데이터를 가져와요.
  2. 정제: 제각각인 형식을 하나로 맞춰요.
  3. 검증: 이상한 값을 걸러 격리해요.
  4. 저장: 여러 번 돌려도 안전하게 저장해요.
  5. 정기 실행과 감시: 날마다 돌리고, 문제가 생기면 알려요.

데이터는 어디서 얻을까

먼저 찾아볼 순서가 있어요.

  1. 공식 API: 데이터 제공자가 프로그램용으로 열어 둔 창구예요. 형식이 안정적이고 이용 조건이 분명해요. 앞 강의처럼 키와 요청 한도가 있어요.
  2. 공개 데이터: 정부와 기관, 연구자들이 파일로 공개한 데이터예요. 이용 허락 조건(라이선스)을 확인해요.
  3. 웹 페이지 수집: API도 공개 데이터도 없을 때, 사람이 보는 웹 페이지에서 정보를 뽑아요. 스크래핑 또는 크롤링이라고 불러요.

웹 페이지 수집은 가장 마지막 수단이고, 지켜야 할 것이 많아요.

  • robots.txt를 지켜요. 사이트가 "이 경로는 자동으로 수집하지 마세요", "요청 사이에 몇 초 쉬어 주세요"라고 적어 두는 파일이에요.
  • 이용 약관을 읽어요. 자동 수집을 금지하는 사이트가 많아요. 국내외에서 무단 수집이 소송으로 이어진 사례도 있어요.
  • 서버에 부담을 주지 않아요. 요청 사이에 간격을 두고, 같은 페이지를 불필요하게 반복해서 가져오지 않아요.
  • 개인 정보와 저작물을 조심해요. 공개된 페이지에 있다고 해서 마음대로 모아 써도 되는 건 아니에요. 개인 정보 보호법과 저작권법이 적용돼요.
  • 막힌 곳은 뚫지 않아요. 로그인이 필요한 곳, 유료 콘텐츠, 차단 장치를 우회하는 수집은 하지 않아요.

연습용 쇼핑몰 띄우기

진짜 사이트로 연습하면 그 사이트에 부담을 주고, 사이트 구조가 바뀌면 코드가 안 돌아가요. 그래서 내 컴퓨터 안에 연습용 쇼핑몰 서버를 띄울게요. 실제 데이터처럼 일부러 지저분하게 만들었어요.

import threading
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

SITE = {}                                            # 주소: 내용 (연습용 쇼핑몰)

class Handler(BaseHTTPRequestHandler):
    def do_GET(self):
        body = SITE.get(self.path)
        if body is None:
            self.send_response(404)
            self.end_headers()
            return
        data = body.encode("utf-8")
        self.send_response(200)
        kind = "text/plain" if self.path.endswith(".txt") else "text/html"
        self.send_header("Content-Type", f"{kind}; charset=utf-8")
        self.send_header("Content-Length", str(len(data)))
        self.end_headers()
        self.wfile.write(data)
    def log_message(self, *args):                    # 서버 기록은 조용히
        pass

server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)   # 0번 포트: 빈 포트를 알아서 골라요
threading.Thread(target=server.serve_forever, daemon=True).start()
BASE = f"http://127.0.0.1:{server.server_port}"

def card(pid, name, price, stock="재고 있음", price_class="price"):
    price_html = f'<span class="{price_class}">{price}</span>' if price is not None else ""
    return (f'<div class="product" data-id="{pid}"><h2 class="name">{name}</h2>'
            f'{price_html}<span class="stock">{stock}</span></div>')

def make_site(products, per_page=4, price_class="price"):
    site = {"/robots.txt": "User-agent: *\nDisallow: /admin\nCrawl-delay: 1\n"}
    pages = [products[i:i + per_page] for i in range(0, len(products), per_page)]
    for n, items in enumerate(pages, 1):
        cards = "".join(card(*p, price_class=price_class) for p in items)
        nav = f'<a class="next" href="/products?page={n + 1}">다음</a>' if n < len(pages) else ""
        site[f"/products?page={n}"] = f"<html><body>{cards}{nav}</body></html>"
    return site

DAY1 = [
    ("A101", "무선 이어폰", "39,900원"),
    ("A102", "  보조 배터리\n 10000mAh ", "₩21,500"),
    ("A103", "USB-C 케이블", "8900원"),
    ("A104", "블루투스 스피커", "54,000원", "품절"),
    ("A104", "블루투스 스피커", "54,000원", "품절"),   # 목록이 밀려 다음 쪽에 또 나온 상품
    ("A105", "노트북 거치대", None),                   # 가격 칸이 없어요
    ("A106", "기계식 키보드", "가격 문의"),
    ("A107", "웹캠", "45,000원"),
    ("A108", "마우스 패드", "-3,000원"),               # 말이 안 되는 값
]
SITE.update(make_site(DAY1))
print(sorted(SITE))
['/products?page=1', '/products?page=2', '/products?page=3', '/robots.txt']

한 쪽에 상품 4개씩, 3쪽짜리 목록과 robots.txt가 생겼어요. robots.txt는 /admin을 수집하지 말고, 요청 사이에 1초씩 쉬어 달라고 해요.

1단계: 수집하기

웹 페이지를 가져오는 데는 requests, HTML에서 원하는 부분을 찾는 데는 BeautifulSoup을 써요(pip install requests beautifulsoup4 pandas). HTML은 태그가 겹겹이 들어 있는 나무 구조라서, CSS 선택자로 "class가 product인 div"처럼 원하는 부분을 집어낼 수 있어요.

import time
import requests
from urllib import robotparser
from bs4 import BeautifulSoup

AGENT = "practice-crawler/1.0"
session = requests.Session()
session.headers["User-Agent"] = AGENT                # 누가 수집하는지 밝혀요
RETRY_STATUS = {429, 500, 502, 503, 504}             # 기다리면 나아질 수 있는 상태 코드

def fetch(url, tries=4):
    for attempt in range(tries):
        try:
            resp = session.get(url, timeout=10)      # 응답 없는 서버를 끝없이 기다리지 않게
            if resp.status_code not in RETRY_STATUS:
                resp.raise_for_status()              # 404 같은 오류는 다시 해도 같아서 바로 멈춰요
                return resp.text
        except (requests.ConnectionError, requests.Timeout, requests.exceptions.ChunkedEncodingError):
            pass                                     # 연결 끊김, 시간 초과: 다시 해 볼 만해요
        if attempt < tries - 1:
            time.sleep(0.5 * 2 ** attempt)           # 0.5초, 1초, 2초로 점점 길게 기다려요
    raise RuntimeError(f"{tries}번 시도했지만 실패했어요: {url}")

def crawl(base):
    robots = robotparser.RobotFileParser()
    robots.parse(fetch(base + "/robots.txt").splitlines())
    delay = robots.crawl_delay(AGENT) or 1
    url, rows = base + "/products?page=1", []
    while url:
        if not robots.can_fetch(AGENT, url):
            raise PermissionError(f"robots.txt가 막은 주소예요: {url}")
        soup = BeautifulSoup(fetch(url), "html.parser")
        for c in soup.select("div.product"):
            price = c.select_one(".price")
            rows.append({
                "id": c["data-id"],
                "name": c.select_one(".name").get_text(),
                "price_text": price.get_text(strip=True) if price else None,
                "stock_text": c.select_one(".stock").get_text(strip=True),
            })
        nxt = soup.select_one("a.next")
        url = base + nxt["href"] if nxt else None
        if url:
            time.sleep(delay)                        # 사이트가 부탁한 간격을 지켜요
    return rows

raw = crawl(BASE)
print(len(raw), "건")
for r in raw[:2]:
    print(r)
9 건
{'id': 'A101', 'name': '무선 이어폰', 'price_text': '39,900원', 'stock_text': '재고 있음'}
{'id': 'A102', 'name': '  보조 배터리\n 10000mAh ', 'price_text': '₩21,500', 'stock_text': '재고 있음'}

코드에 담긴 습관들을 짚어 볼게요.

  • robots.txt 먼저: 주소마다 수집해도 되는지 확인하고, 사이트가 부탁한 간격(1초)을 지켜요. 그래서 3쪽을 가져오는 데 2초쯤 걸려요.
  • 나를 밝히기: User-Agent에 수집기 이름을 적어요. 진짜 서비스라면 연락처도 적어서, 사이트 운영자가 문제가 있을 때 연락할 수 있게 해요.
  • 다시 시도하기: 네트워크는 가끔 끊겨요. 같은 컴퓨터 안의 연습 서버와 주고받는데도 환경에 따라 수십 번에 한 번꼴로 연결이 끊기기도 해요. 그래서 fetch는 연결 끊김, 시간 초과, 일시적인 서버 오류(429, 5xx)를 만나면 점점 길게 기다리며 네 번까지 시도해요. 응답 본문을 끝까지 받은 뒤에야 성공으로 쳐요. 본문을 받는 도중에 끊기는 경우도 있거든요. 앞 강의에서 본 것과 같은 원리예요.
  • 시간 제한: timeout이 없으면 응답하지 않는 서버를 영원히 기다릴 수 있어요.
  • 상태 확인: raise_for_status()로 404 같은 오류를 정상 페이지처럼 처리하지 않게 하고, 다시 해도 소용없는 오류라 바로 멈춰요.
  • 다음 쪽 따라가기: 쪽 번호를 짐작하지 않고, 페이지에 있는 "다음" 링크를 따라가요. 마지막 쪽에서 자연스럽게 멈춰요.

수집한 그대로를 보면 지저분해요. 이름에 공백과 줄바꿈이 섞여 있고, 가격은 "39,900원", "₩21,500"처럼 제각각이에요. 실제로는 이렇게 원본을 그대로 따로 보관해 두는 게 좋아요. 정제 코드에 버그가 있으면 다시 수집하지 않고 원본으로 다시 정제할 수 있으니까요.

2단계: 정제하고 검증하기

정제는 제각각인 표현을 하나의 형식으로 맞추는 일이에요. 머신러닝 트랙 특징 공학 강의의 데이터 다듬기와 같은 작업이에요.

import re
import pandas as pd

def parse_price(text):
    if not isinstance(text, str):                    # 가격 칸이 없으면 빈 값(NaN)이 들어와요
        return None
    digits = re.sub(r"[^\d-]", "", text)             # 숫자와 빼기표만 남겨요
    return int(digits) if re.fullmatch(r"-?\d+", digits) else None

def clean(rows):
    df = pd.DataFrame(rows)
    df["name"] = df["name"].str.split().str.join(" ")          # 줄바꿈과 겹친 공백 정리
    df["price"] = df["price_text"].map(parse_price).astype("Int64")
    df["in_stock"] = df["stock_text"] != "품절"
    df = df.drop_duplicates(subset="id", keep="first")
    return df[["id", "name", "price", "in_stock"]].reset_index(drop=True)

def validate(df):
    ok = df["price"].notna() & (df["price"] > 0) & (df["name"].str.len() > 0)
    ok = ok.fillna(False).astype(bool)
    return df[ok], df[~ok]

df = clean(raw)
for row in df.itertuples(index=False):
    print(f"{row.id} | {row.name} | {row.price} | {row.in_stock}")
good, bad = validate(df)
print("통과", len(good), "격리", len(bad), bad["id"].tolist())
A101 | 무선 이어폰 | 39900 | True
A102 | 보조 배터리 10000mAh | 21500 | True
A103 | USB-C 케이블 | 8900 | True
A104 | 블루투스 스피커 | 54000 | False
A105 | 노트북 거치대 | <NA> | True
A106 | 기계식 키보드 | <NA> | True
A107 | 웹캠 | 45000 | True
A108 | 마우스 패드 | -3000 | True
통과 5 격리 3 ['A105', 'A106', 'A108']
  • 공백 정리: 낱말 사이의 공백과 줄바꿈을 한 칸으로 맞췄어요.
  • 가격 해석: 숫자만 남겨 정수로 바꿨어요. "가격 문의"처럼 숫자가 없거나 가격 칸 자체가 없으면 빈 값(<NA>)이 돼요. 빈 값을 0으로 채우면 안 돼요. 0원짜리 상품이 생겨 버리니까요.
  • 중복 제거: 수집하는 동안 목록이 밀려 두 쪽에 걸쳐 나온 A104를 상품 번호 기준으로 하나만 남겼어요. 이름으로 중복을 판단하면 이름이 같은 다른 상품을 지울 수 있어요.

검증에서는 가격이 없거나 0 이하인 행을 버리지 않고 격리했어요. 조용히 버리면 문제가 있었다는 사실 자체가 사라지고, 오류를 내며 멈추면 멀쩡한 다섯 건까지 저장하지 못해요. 격리한 건 따로 모아 두고 사람이 살펴봐요. 격리가 갑자기 늘면 그 자체가 중요한 신호예요.

3단계: 여러 번 돌려도 안전하게 저장하기

데이터베이스 트랙에서 자세히 배울 SQLite에 저장해요. 파이썬에 기본으로 들어 있는, 파일 하나짜리 데이터베이스예요. 표를 두 개 만들어요.

  • products: 상품마다 최신 상태 한 줄. 상품 번호가 기본 키(겹칠 수 없는 열쇠)예요.
  • price_history: 상품과 날짜마다 가격 한 줄. (상품 번호, 날짜) 쌍이 기본 키예요.
import sqlite3
import pathlib

def save(db, df, day):
    db.execute("""CREATE TABLE IF NOT EXISTS products (
        id TEXT PRIMARY KEY, name TEXT, price INTEGER, in_stock INTEGER, updated TEXT)""")
    db.execute("""CREATE TABLE IF NOT EXISTS price_history (
        id TEXT, day TEXT, price INTEGER, PRIMARY KEY (id, day))""")
    for r in df.itertuples():
        db.execute("""INSERT INTO products VALUES (?, ?, ?, ?, ?)
            ON CONFLICT(id) DO UPDATE SET name = excluded.name, price = excluded.price,
            in_stock = excluded.in_stock, updated = excluded.updated""",
            (r.id, r.name, int(r.price), int(r.in_stock), day))
        db.execute("INSERT OR REPLACE INTO price_history VALUES (?, ?, ?)", (r.id, day, int(r.price)))
    db.commit()

def pipeline(db, day):
    raw = crawl(BASE)
    df = clean(raw)
    good, bad = validate(df)
    print(f"{day}: 수집 {len(raw)}건, 중복 제거 {len(df)}건, 통과 {len(good)}건, 격리 {len(bad)}건")
    if len(df) == 0 or len(bad) > len(df) / 2:
        raise RuntimeError("데이터가 이상해요. 저장하지 않고 멈춰요")   # 사이트 구조가 바뀌었을 수 있어요
    save(db, good, day)

def counts(db):
    return [db.execute(f"SELECT COUNT(*) FROM {t}").fetchone()[0] for t in ("products", "price_history")]

pathlib.Path("shop.db").unlink(missing_ok=True)      # 연습이라 새로 시작해요
db = sqlite3.connect("shop.db")
pipeline(db, "2026-11-16")
print(counts(db))
pipeline(db, "2026-11-16")                           # 같은 날 한 번 더 돌려도
print(counts(db))
2026-11-16: 수집 9건, 중복 제거 8건, 통과 5건, 격리 3건
[5, 5]
2026-11-16: 수집 9건, 중복 제거 8건, 통과 5건, 격리 3건
[5, 5]

같은 날 두 번 돌렸는데 기록은 그대로 5건, 5건이에요. 이미 있는 상품 번호는 새로 넣지 않고 고쳐 쓰고(ON CONFLICT ... DO UPDATE), 같은 날의 가격도 덮어쓰기 때문이에요. 이렇게 같은 일을 여러 번 해도 결과가 같은 성질을 멱등성이라고 해요. 파이프라인은 실패하면 다시 돌리고, 실수로 두 번 돌기도 하니까 꼭 갖춰야 할 성질이에요. 그냥 INSERT만 했다면 두 번째 실행에서 중복 기록이 생기거나 오류가 났을 거예요.

4단계: 날마다 돌리기

다음 날 사이트가 바뀌었어요. A103이 사라지고, A109가 새로 생기고, A101의 가격이 내렸어요.

DAY2 = [p for p in DAY1 if p[0] != "A103"] + [("A109", "모니터 조명", "29,000원")]
DAY2 = [(pid, name, "35,900원" if pid == "A101" else price, *rest) for pid, name, price, *rest in DAY2]
SITE.clear()
SITE.update(make_site(DAY2))
pipeline(db, "2026-11-17")
print(counts(db))
print(db.execute("SELECT day, price FROM price_history WHERE id = 'A101' ORDER BY day").fetchall())
for row in db.execute("SELECT id, price, updated FROM products ORDER BY id"):
    print(row)
2026-11-17: 수집 9건, 중복 제거 8건, 통과 5건, 격리 3건
[6, 10]
[('2026-11-16', 39900), ('2026-11-17', 35900)]
('A101', 35900, '2026-11-17')
('A102', 21500, '2026-11-17')
('A103', 8900, '2026-11-16')
('A104', 54000, '2026-11-17')
('A107', 45000, '2026-11-17')
('A109', 29000, '2026-11-17')

A101의 가격 기록이 이틀 치 쌓였어요. 새 상품 A109도 들어왔어요. 그런데 사라진 A103이 여전히 남아 있어요. 마지막으로 본 날(updated)이 어제에 멈춰 있을 뿐이에요. 사라진 상품을 바로 지우면 과거 기록과의 연결이 끊어지니, 보통은 지우지 않고 "마지막으로 본 날"로 판단하거나 판매 중 여부를 따로 표시해요. 이 사이트에서 하루 이틀 안 보이다 다시 나타나는 상품도 있을 수 있으니까요.

5단계: 조용한 실패를 막는 감시

파이프라인에서 가장 무서운 건 오류를 내며 멈추는 것보다 아무 일 없다는 듯 엉터리 데이터를 저장하는 것이에요. 사이트가 디자인을 바꿔서 가격 칸의 class 이름이 달라졌다고 해 볼게요.

SITE.clear()
SITE.update(make_site(DAY2, price_class="sale-price"))   # 사이트가 디자인을 바꿨어요
try:
    pipeline(db, "2026-11-18")
except RuntimeError as e:
    print("알림:", e)
print(counts(db))
db.close()
server.shutdown()
2026-11-18: 수집 9건, 중복 제거 8건, 통과 0건, 격리 8건
알림: 데이터가 이상해요. 저장하지 않고 멈춰요
[6, 10]

수집기는 오류 없이 9건을 가져왔지만 가격을 하나도 찾지 못했어요. 코드 입장에서는 그냥 "가격 칸이 없는 상품들"이에요. 검증 단계에서 격리가 절반을 넘으면 멈추도록 해 둔 덕분에, 엉터리 데이터를 저장하지 않고 알림을 냈어요. 기록은 어제 그대로예요. 이런 감시가 없었다면 며칠 동안 빈 가격이 쌓이고 나서야 알아챘을 거예요.

실무에서 흔히 쓰는 감시 항목이에요.

  • 건수: 어제보다 수집 건수가 크게 줄거나 늘었나?
  • 빈 값 비율: 특정 열의 빈 값이 갑자기 늘었나?
  • 값의 범위: 가격이 음수이거나 어제의 100배가 됐나?
  • 신선도: 마지막으로 성공한 지 너무 오래되지 않았나?

문제가 생기면 메일이나 메신저로 사람에게 알리고, 마지막으로 성공한 데이터를 그대로 둬요.

정해진 시간에 돌리기

파이프라인은 사람이 실행하지 않아도 정해진 시간에 돌아야 해요.

  • cron: 리눅스와 맥의 예약 실행 도구예요. 0 9 * * *는 "매일 9시 0분"이에요. 리눅스 트랙에서 다뤄요.
  • 작업 스케줄러: 윈도의 예약 실행 도구예요.
  • GitHub Actions: 저장소에 설정 파일을 두면 정해진 시간에 코드를 실행해 줘요. 시간은 세계 표준시(UTC) 기준이라, 한국 시간 오전 9시는 0 0 * * *로 적어야 해요. 자주 하는 실수예요.
  • 작업 관리 도구: 단계가 많고 서로 기다려야 하는 복잡한 파이프라인은 Airflow 같은 도구로 순서, 재시도, 기록을 관리해요.

정기 실행에는 빠진 날 채우기도 필요해요. 서버가 이틀 꺼져 있었다면, 다시 켜졌을 때 빠진 날을 처리할 수 있어야 해요. 다만 웹 페이지는 "지금"만 보여 주니, 지나간 날의 가격은 다시 수집할 수 없어요. 그래서 수집은 놓치지 않는 것이 무엇보다 중요해요.

AI 프로젝트와 데이터 파이프라인

  • RAG의 색인: 문서가 바뀌면 조각을 다시 만들고 임베딩을 갱신하는 것도 파이프라인이에요. 바뀐 문서만 다시 처리하면 비용이 줄어요.
  • 학습 데이터: 어떤 데이터로 학습했는지 기록해 두지 않으면, 모델이 이상해졌을 때 원인을 찾을 수 없어요. 다음 강의의 MLOps에서 다뤄요.
  • 파이프라인 안의 LLM: 형식이 제각각인 글에서 정보를 뽑는 일(주소, 날짜, 상품 사양)은 앞 강의의 구조화 출력이 잘해요. 다만 비용과 검증은 여기서 배운 그대로 챙겨요.

실습

  1. parse_price에 1만 2천원이나 12,900원~15,900원 같은 표기가 들어오면 어떻게 되나요? 각각 어떻게 다루는 게 좋을까요?
  2. robots.txt에 Disallow: /products를 넣고 crawl을 돌려 보세요. 어떤 일이 일어나나요?
  3. products 표에 last_seen 열을 두고, 3일 넘게 안 보인 상품을 "판매 중지"로 표시하도록 바꿔 보세요.
  4. 감시 규칙에 "수집 건수가 직전 실행의 절반 아래로 떨어지면 멈추기"를 더해 보세요.
  5. 가격이 어제보다 50% 넘게 내린 상품만 골라 보여 주는 SQL을 price_history로 써 보세요.

자주 하는 실수

  • API를 찾아보지 않고 바로 스크래핑하기. 공식 API가 더 안정적이고 이용 조건도 분명해요.
  • robots.txt와 약관 무시하기. 사이트에 부담을 주고 법적 문제가 생길 수 있어요.
  • timeout 없이 요청하기. 응답 없는 서버 하나에 파이프라인 전체가 멈춰요.
  • 빈 값을 0으로 채우기. 없는 정보가 거짓 정보가 돼요.
  • 이름으로 중복 판단하기. 고유한 번호(키)로 판단해요.
  • 그냥 INSERT만 하기. 다시 돌리면 중복이 생겨요. 멱등하게 저장해요.
  • 성공했다는 기록만 보기. 건수와 빈 값 비율을 감시하지 않으면 조용히 망가져요.
  • GitHub Actions 시간을 한국 시간으로 적기. UTC 기준이에요.

점검 문제

  1. 데이터를 얻을 때 웹 페이지 수집을 마지막 수단으로 하는 이유는?
  2. robots.txt의 Crawl-delay: 1은 무슨 뜻이고, 코드에서 어떻게 지켰나요?
  3. 원본 수집 결과를 따로 보관하면 좋은 이유는?
  4. 검증에 걸린 행을 버리지 않고 격리하는 이유는?
  5. 멱등성이란 무엇이고, 실습에서 어떻게 확인했나요?
  6. 사이트 구조가 바뀌었을 때 파이프라인이 오류 없이 엉터리 데이터를 저장할 수 있는 이유와, 막는 방법은?
  7. 한국 시간 오전 9시에 GitHub Actions로 실행하려면 cron을 어떻게 적어야 하나요?

정답

  1. 사이트 구조가 바뀌면 깨지기 쉽고, 약관과 법적 문제, 서버 부담을 신경 써야 하기 때문이에요. 공식 API나 공개 데이터가 더 안정적이고 조건이 분명해요.
  2. 요청 사이에 1초씩 쉬어 달라는 뜻이에요. robots.crawl_delay()로 읽어서 다음 쪽을 가져오기 전에 time.sleep()으로 기다렸어요.
  3. 정제 코드에 버그가 있거나 규칙을 바꾸고 싶을 때 다시 수집하지 않고 원본으로 다시 정제할 수 있기 때문이에요. 지나간 웹 페이지는 다시 가져올 수 없어요.
  4. 버리면 문제가 있었다는 사실이 사라지고, 멈추면 멀쩡한 데이터까지 저장하지 못해요. 격리하면 정상 데이터는 저장하고 문제는 따로 살펴볼 수 있어요.
  5. 같은 작업을 여러 번 해도 결과가 같은 성질이에요. 같은 날 파이프라인을 두 번 돌려도 기록 수가 5건, 5건 그대로인 것으로 확인했어요.
  6. 수집 코드는 찾는 칸이 없으면 빈 값을 낼 뿐 오류를 내지 않기 때문이에요. 격리 비율, 건수, 빈 값 비율 같은 검증 규칙을 두고 기준을 넘으면 저장하지 않고 알려요.
  7. UTC 기준이라 9시간을 빼서 0 0 * * *로 적어요.

다음 강의

데이터가 흐르기 시작했어요. 이 데이터로 모델을 학습시켰다면, 그 모델을 서비스에 올리고, 성능이 떨어지지 않는지 지켜보고, 필요하면 되돌리는 일이 남아요. 다음 강의에서는 모델을 배포하고 지키는 MLOps를 다뤄요.