Sync from GitHub 37f011465a0aa2abdfdd94d8bd5f31cfe932c669

CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 2026-07-04 (2)
+
+- Set difficulty (easy/medium/hard) on 49 Linux quizzes that were previously unclassified.
+- Added `level` (입문/중급/고급) to all 50 Azure lessons (was None for all).
+- Linked `related_practices` on 20 Azure lessons to their corresponding practice task IDs.
+- Added cumulative lesson/quiz/practice progress count (N/총개수) to home mode cards.
+- Added overall quiz progress bar (퀴즈 N/총개수 완료) to the top of the `확인 퀴즈` screen.
+- Added overall practice progress bar (실습 N/총개수 완료) to the top of the `실습하기` screen.
+- Added "관련 이론 다시 보기" button on practice failure, routing to the linked lesson (reverse `related_practices` lookup).
+
 ## 2026-07-04
 
 - Fixed AI quiz assistant crashing the page when ChromaDB collection is empty (added `min(k, count)` guard).

cert_study_app/content/azure/lessons.json

@@ -0,0 +1,1213 @@
+[
+  {
+    "id": "azure-rg",
+    "certification": "AZ-104",
+    "title": "Resource Group — 리소스 그룹",
+    "summary": "Azure 리소스를 논리적으로 묶는 컨테이너입니다. 동일 RG의 리소스는 함께 배포·관리·삭제되며, 위치(region)가 서로 달라도 같은 RG에 속할 수 있습니다.",
+    "example": "az group create --name myRG --location koreacentral\naz group list --output table\naz group delete --name myRG --yes",
+    "common_mistake": "RG를 삭제하면 안에 속한 모든 리소스가 함께 삭제됩니다. RG 위치와 내부 리소스 위치는 별개입니다.",
+    "keywords": [
+      "resource group",
+      "container",
+      "lifecycle",
+      "region",
+      "az group"
+    ],
+    "source_id": "azure-vm-overview",
+    "details": [
+      "RG는 리소스의 수명 주기를 함께 관리하기 위한 단위입니다. 프로젝트별, 환경별(dev/prod), 또는 팀별로 분리하는 것이 일반적입니다.",
+      "RG 자체의 위치는 메타데이터 저장 위치이며, 내부 리소스는 다른 region에 있어도 됩니다.",
+      "시험 패턴: RG 삭제 시 영향 범위, RG에 RBAC·Lock·Tag를 적용하는 시나리오, RG 이동 제한 사항이 출제됩니다."
+    ],
+    "level": "입문",
+    "related_practices": [
+      "azure-lab-1"
+    ]
+  },
+  {
+    "id": "azure-storage",
+    "certification": "AZ-104",
+    "title": "Storage Account — 스토리지 계정",
+    "summary": "Blob, File, Queue, Table 4가지 스토리지 서비스를 제공하는 최상위 네임스페이스입니다. SKU(Standard/Premium)와 중복성(LRS/GRS 등)을 생성 시 결정합니다.",
+    "example": "az storage account create \\\n  --name mystorageacct \\\n  --resource-group myRG \\\n  --sku Standard_LRS \\\n  --kind StorageV2",
+    "common_mistake": "Storage Account 이름은 전 세계에서 유일해야 하며 소문자·숫자만 사용 가능합니다(3~24자). SKU는 생성 후 변경할 수 없습니다.",
+    "keywords": [
+      "storage account",
+      "Blob",
+      "Files",
+      "LRS",
+      "GRS",
+      "SKU",
+      "StorageV2"
+    ],
+    "source_id": "azure-storage-account",
+    "details": [
+      "StorageV2(범용 v2)가 현재 권장 형식으로 모든 스토리지 서비스와 최신 기능을 지원합니다.",
+      "중복성: LRS(단일 datacenter 3복제), ZRS(3 AZ), GRS(다른 region으로 비동기 복제), GZRS(ZRS+GRS).",
+      "시험 패턴: 중복성 수준별 특징, 스토리지 계정 종류(Blob전용/StorageV2 등), 보안 설정(HTTPS 강제, 방화벽) 문제가 출제됩니다."
+    ],
+    "level": "입문",
+    "related_practices": [
+      "azure-lab-2"
+    ]
+  },
+  {
+    "id": "azure-vnet",
+    "certification": "AZ-104",
+    "title": "Virtual Network — 가상 네트워크",
+    "summary": "Azure에서 리소스가 통신하는 격리된 사설 네트워크입니다. 서브넷으로 나뉘며, 온프레미스 연결(VPN Gateway, ExpressRoute)과 피어링을 통해 확장합니다.",
+    "example": "az network vnet create \\\n  --name myVNet \\\n  --address-prefix 10.0.0.0/16 \\\n  --subnet-name default \\\n  --subnet-prefix 10.0.0.0/24",
+    "common_mistake": "VNet 주소 공간이 겹치면 피어링이 불가능합니다. 설계 초기에 IP 범위를 서로 겹치지 않게 잡아야 합니다.",
+    "keywords": [
+      "VNet",
+      "subnet",
+      "address space",
+      "CIDR",
+      "peering",
+      "NSG"
+    ],
+    "source_id": "azure-vnet-overview",
+    "details": [
+      "VNet 내 모든 리소스는 기본적으로 서로 통신 가능합니다. 외부 인터넷 통신은 Public IP 또는 NAT Gateway를 통합니다.",
+      "서브넷은 VNet 주소 공간의 일부. Azure가 각 서브넷에서 5개 IP를 예약합니다(첫 4개 + 마지막).",
+      "시험 패턴: VNet/서브넷 주소 범위 계산, NSG와 서브넷 연결, 피어링 조건(주소 비중첩) 문제가 자주 출제됩니다."
+    ],
+    "level": "입문",
+    "related_practices": [
+      "azure-lab-3"
+    ]
+  },
+  {
+    "id": "azure-rbac",
+    "certification": "AZ-104",
+    "title": "Azure RBAC — 역할 기반 접근 제어",
+    "summary": "누가(Who), 어떤 리소스에(Scope), 무엇을 할 수 있는지(Role)를 정의합니다. 역할 할당은 구독·RG·리소스 레벨에서 상속됩니다.",
+    "example": "az role assignment create \\\n  --assignee alice@example.com \\\n  --role 'Contributor' \\\n  --scope /subscriptions/SUB_ID/resourceGroups/myRG",
+    "common_mistake": "RBAC는 관리 평면(Azure Portal/API) 접근 제어입니다. VM 내부 OS 접근이나 Storage 데이터 접근은 별도 설정이 필요합니다.",
+    "keywords": [
+      "RBAC",
+      "role assignment",
+      "Owner",
+      "Contributor",
+      "Reader",
+      "scope",
+      "principal"
+    ],
+    "source_id": "azure-rbac-overview",
+    "details": [
+      "내장 역할 3가지: Owner(모든 권한+역할 할당), Contributor(리소스 CRUD, 역할 할당 불가), Reader(읽기만).",
+      "역할 할당 범위: 관리 그룹 > 구독 > RG > 리소스. 상위 범위 역할은 하위로 상속됩니다.",
+      "시험 패턴: 최소 권한 원칙에 따른 역할 선택, 범위별 역할 상속 결과, Owner vs Contributor 차이 문제가 자주 출제됩니다."
+    ],
+    "level": "입문",
+    "related_practices": [
+      "azure-lab-5"
+    ]
+  },
+  {
+    "id": "azure-policy",
+    "certification": "AZ-104",
+    "title": "Azure Policy — 정책",
+    "summary": "리소스가 조직의 규정을 준수하도록 강제합니다. 특정 region만 허용, 태그 강제, SKU 제한 등을 정책 정의로 만들어 구독·RG에 할당합니다.",
+    "example": "# 허용 location 제한 정책 할당 예\naz policy assignment create \\\n  --name 'allowed-locations' \\\n  --policy 'e56962a6-4747-49cd-b67b-bf8b01975c4f' \\\n  --params '{\"listOfAllowedLocations\":{\"value\":[\"koreacentral\"]}}'",
+    "common_mistake": "Policy는 이미 존재하는 비준수 리소스를 자동으로 수정하지 않습니다. 수정이 필요하면 remediation task를 별도로 실행해야 합니다.",
+    "keywords": [
+      "Azure Policy",
+      "policy definition",
+      "initiative",
+      "compliance",
+      "deny",
+      "audit",
+      "remediation"
+    ],
+    "source_id": "azure-policy-overview",
+    "details": [
+      "효과(effect) 유형: Deny(거부), Audit(감사만), AuditIfNotExists, DeployIfNotExists(자동 보완 배포), Disabled.",
+      "Initiative(이니셔티브)는 여러 Policy를 묶은 집합. NIST, CIS 등 규정 준수 프레임워크가 이니셔티브로 제공됩니다.",
+      "시험 패턴: Policy와 RBAC 차이(RBAC는 행위 제어, Policy는 리소스 속성 제어), 효과 유형별 동작, 이니셔티브 vs 단독 정책 문제가 출제됩니다."
+    ],
+    "level": "입문"
+  },
+  {
+    "id": "azure-vm",
+    "certification": "AZ-104",
+    "title": "Virtual Machine — 가상 머신",
+    "summary": "Azure에서 제공하는 IaaS 컴퓨팅입니다. VM 크기(SKU), OS 이미지, 가용성 구성, 디스크 유형을 선택해 배포합니다.",
+    "example": "az vm create \\\n  --name myVM \\\n  --resource-group myRG \\\n  --image Ubuntu2204 \\\n  --size Standard_B2s \\\n  --admin-username azureuser \\\n  --generate-ssh-keys",
+    "common_mistake": "VM을 '중지(Stop)'해도 할당 해제(deallocated)가 아니면 컴퓨팅 요금이 계속 청구됩니다. 비용 절감을 위해 '중지(할당 해제)'를 사용해야 합니다.",
+    "keywords": [
+      "VM",
+      "SKU",
+      "availability set",
+      "managed disk",
+      "deallocate",
+      "NSG",
+      "public IP"
+    ],
+    "source_id": "azure-vm-overview",
+    "details": [
+      "VM 크기 시리즈: B(버스트, 저비용), D(범용), E(메모리 최적화), F(컴퓨팅 최적화), N(GPU). 숫자는 vCPU 수를 의미합니다.",
+      "VM 생성 시 자동으로 NIC, OS 디스크, Public IP(선택)가 함께 생성됩니다.",
+      "시험 패턴: 중지 vs 할당 해제 요금 차이, VM 크기 변경 시 재시작 필요 여부, 가용성 SLA 99.9/99.95/99.99% 구성 방법이 자주 출제됩니다."
+    ],
+    "level": "입문"
+  },
+  {
+    "id": "azure-vmss",
+    "certification": "AZ-104",
+    "title": "Virtual Machine Scale Sets — 가상 머신 확장 집합",
+    "summary": "동일한 VM을 자동으로 확장·축소하는 그룹입니다. 부하에 따라 인스턴스 수를 자동 조정(Autoscale)하고, 부하 분산 장치와 통합합니다.",
+    "example": "az vmss create \\\n  --name myVMSS \\\n  --resource-group myRG \\\n  --image Ubuntu2204 \\\n  --instance-count 2 \\\n  --vm-sku Standard_B2s",
+    "common_mistake": "VMSS의 개별 인스턴스는 업그레이드 정책(자동/수동/롤링)에 따라 다르게 업데이트됩니다. 자동 정책은 인스턴스를 순차적으로 재시작합니다.",
+    "keywords": [
+      "VMSS",
+      "scale set",
+      "autoscale",
+      "instance count",
+      "upgrade policy",
+      "load balancer"
+    ],
+    "source_id": "azure-vmss-overview",
+    "details": [
+      "Orchestration 모드: Uniform(동일 VM, 자동 확장 최적화) vs Flexible(혼합 VM 크기 가능, Availability Zone 지원 강화).",
+      "Autoscale 규칙: CPU%, 메모리, 큐 길이 등 메트릭 기반으로 scale-out/in 임계값을 설정합니다.",
+      "시험 패턴: VMSS vs Availability Set 차이(AS는 자동 확장 없음), 업그레이드 정책 선택, 부하 분산기 통합 방법이 출제됩니다."
+    ],
+    "level": "중급"
+  },
+  {
+    "id": "azure-nsg",
+    "certification": "AZ-104",
+    "title": "Network Security Group — 네트워크 보안 그룹",
+    "summary": "인바운드/아웃바운드 트래픽을 포트·프로토콜·원본IP로 허용/거부하는 규칙 집합입니다. 서브넷 또는 NIC에 연결합니다.",
+    "example": "az network nsg rule create \\\n  --nsg-name myNSG \\\n  --name allow-ssh \\\n  --priority 100 \\\n  --access Allow \\\n  --protocol Tcp \\\n  --destination-port-ranges 22",
+    "common_mistake": "우선순위 숫자가 낮을수록 먼저 적용됩니다(100이 200보다 높은 우선순위). 규칙 충돌 시 낮은 번호 규칙이 이깁니다.",
+    "keywords": [
+      "NSG",
+      "inbound",
+      "outbound",
+      "priority",
+      "allow",
+      "deny",
+      "subnet",
+      "NIC"
+    ],
+    "source_id": "azure-nsg-overview",
+    "details": [
+      "NSG에는 기본 규칙이 있습니다: AllowVNetInbound(65000), AllowAzureLoadBalancerInbound(65001), DenyAllInbound(65500).",
+      "NSG를 서브넷과 NIC 양쪽에 연결하면 트래픽이 두 NSG를 모두 통과합니다. 인바운드는 서브넷NSG→NIC NSG 순서.",
+      "시험 패턴: 특정 포트 허용/차단 규칙 설계, 우선순위 충돌 결과, 서브넷 vs NIC 연결 차이 문제가 자주 출제됩니다."
+    ],
+    "level": "입문",
+    "related_practices": [
+      "azure-lab-4"
+    ]
+  },
+  {
+    "id": "azure-app-gateway",
+    "certification": "AZ-104",
+    "title": "Application Gateway — 애플리케이션 게이트웨이",
+    "summary": "HTTP/HTTPS 레이어(L7) 부하 분산 장치입니다. URL 기반 라우팅, SSL 종료, WAF(웹 방화벽)를 지원합니다.",
+    "example": "# 구성 요소: Frontend IP → Listener → Rule → Backend Pool → HTTP Settings\n# URL 기반 라우팅 예:\n# /images/* → image-pool\n# /api/* → api-pool",
+    "common_mistake": "Application Gateway는 L7, Azure Load Balancer는 L4입니다. URL 경로나 호스트 헤더 기반 라우팅이 필요하면 App Gateway를 씁니다.",
+    "keywords": [
+      "Application Gateway",
+      "L7",
+      "WAF",
+      "SSL termination",
+      "URL routing",
+      "backend pool"
+    ],
+    "source_id": "azure-app-gateway-overview",
+    "details": [
+      "구성 흐름: Frontend IP → Listener(포트/프로토콜) → Routing Rule → Backend Pool(VM/VMSS/IP) → HTTP Settings.",
+      "WAF SKU는 OWASP 규칙셋으로 SQL injection, XSS 등 웹 공격을 탐지·차단합니다.",
+      "시험 패턴: App Gateway vs Load Balancer 선택 기준, URL 경로 기반 라우팅 구성, SSL 오프로딩 개념이 자주 출제됩니다."
+    ],
+    "level": "중급"
+  },
+  {
+    "id": "azure-dns",
+    "certification": "AZ-104",
+    "title": "Azure DNS — 도메인 이름 서비스",
+    "summary": "Azure에서 DNS 영역을 호스팅합니다. Public DNS Zone은 인터넷용, Private DNS Zone은 VNet 내부 이름 해석에 사용합니다.",
+    "example": "az network dns zone create --name example.com --resource-group myRG\naz network dns record-set a add-record \\\n  --zone-name example.com \\\n  --record-set-name www \\\n  --ipv4-address 1.2.3.4",
+    "common_mistake": "Azure DNS는 도메인 등록 서비스가 아닙니다. 도메인은 별도 등록 기관에서 구매 후 네임서버를 Azure로 위임해야 합니다.",
+    "keywords": [
+      "Azure DNS",
+      "Public Zone",
+      "Private Zone",
+      "A record",
+      "CNAME",
+      "NS delegation"
+    ],
+    "source_id": "azure-dns-overview",
+    "details": [
+      "Public DNS Zone 생성 후 Azure가 제공하는 NS 레코드 4개를 도메인 등록 기관에서 설정해 위임합니다.",
+      "Private DNS Zone은 VNet에 연결(link)하면 해당 VNet의 VM이 사설 도메인 이름을 해석할 수 있습니다.",
+      "시험 패턴: Public vs Private Zone 사용 시나리오, 네임서버 위임 절차, Azure 서비스에 DNS별칭(CNAME/alias) 연결 방법이 출제됩니다."
+    ],
+    "level": "중급"
+  },
+  {
+    "id": "azure-blob-tier",
+    "certification": "AZ-104",
+    "title": "Blob Access Tier — Blob 접근 계층",
+    "summary": "데이터 접근 빈도에 따라 Hot·Cool·Cold·Archive 계층을 선택해 스토리지 비용을 최적화합니다. 저장 비용과 접근 비용은 반비례합니다.",
+    "example": "az storage blob set-tier \\\n  --account-name myaccount \\\n  --container-name mycontainer \\\n  --name myblob.log \\\n  --tier Cool",
+    "common_mistake": "Archive 계층의 Blob은 즉시 읽을 수 없습니다. 읽으려면 Hot 또는 Cool로 rehydration(몇 시간~15시간)이 필요합니다.",
+    "keywords": [
+      "blob tier",
+      "Hot",
+      "Cool",
+      "Cold",
+      "Archive",
+      "rehydration",
+      "lifecycle"
+    ],
+    "source_id": "azure-blob-access-tiers",
+    "details": [
+      "계층별 특징: Hot(자주 접근, 높은 저장 비용 낮은 접근 비용), Cool(30일 이상 보관), Cold(90일 이상), Archive(180일 이상, 접근 비용 최고).",
+      "Archive에서 꺼낼 때 우선순위: Standard(최대 15시간), High Priority(1시간 이내, 비쌈).",
+      "시험 패턴: 계층별 최소 보관 기간(Cool=30일, Cold=90일, Archive=180일), 조기 삭제 시 요금 부과, rehydration 시간 문제가 출제됩니다."
+    ],
+    "level": "입문",
+    "related_practices": [
+      "azure-lab-7"
+    ]
+  },
+  {
+    "id": "azure-log-analytics",
+    "certification": "AZ-104",
+    "title": "Log Analytics Workspace — 로그 분석 작업 영역",
+    "summary": "Azure Monitor의 데이터 저장소입니다. VM·서비스의 로그와 메트릭을 수집하고 KQL(Kusto Query Language)로 분석합니다.",
+    "example": "# KQL 예: 최근 1시간 오류 로그\nEvent\n| where TimeGenerated > ago(1h)\n| where EventLevelName == 'Error'\n| summarize count() by Source",
+    "common_mistake": "Log Analytics는 저장소이고 Azure Monitor가 수집 에이전트·경보를 포함한 플랫폼입니다. 둘은 함께 동작하며 별개입니다.",
+    "keywords": [
+      "Log Analytics",
+      "KQL",
+      "workspace",
+      "diagnostic settings",
+      "MMA",
+      "AMA"
+    ],
+    "source_id": "azure-log-analytics-overview",
+    "details": [
+      "데이터 수집: VM에 Azure Monitor Agent(AMA) 설치 또는 Diagnostic Settings로 Azure 서비스 로그를 Workspace로 전송합니다.",
+      "KQL 핵심: `| where`, `| project`(컬럼 선택), `| summarize`(집계), `| order by`, `| take`(상위 N개).",
+      "시험 패턴: Diagnostic Settings 설정 절차, VM에 에이전트 연결, KQL 기본 구문으로 로그를 쿼리하는 시나리오가 출제됩니다."
+    ],
+    "level": "중급"
+  },
+  {
+    "id": "azure-recovery-vault",
+    "certification": "AZ-104",
+    "title": "Recovery Services Vault — 복구 서비스 자격 증명 모음",
+    "summary": "Azure Backup과 Site Recovery 데이터를 저장하는 컨테이너입니다. VM, SQL, Files 등의 백업 정책을 정의하고 복원 지점을 관리합니다.",
+    "example": "az backup vault create \\\n  --name myVault \\\n  --resource-group myRG \\\n  --location koreacentral\naz backup protection enable-for-vm \\\n  --vault-name myVault \\\n  --vm myVM \\\n  --policy-name DefaultPolicy",
+    "common_mistake": "Recovery Services Vault는 백업 대상 리소스와 같은 region에 있어야 합니다. 다른 region의 VM은 백업할 수 없습니다.",
+    "keywords": [
+      "Recovery Services Vault",
+      "Azure Backup",
+      "backup policy",
+      "restore point",
+      "soft delete"
+    ],
+    "source_id": "azure-recovery-services-vault",
+    "details": [
+      "백업 정책: 스케줄(일별/주별), 보존 기간(일/주/월/년)을 정의합니다. VM은 기본 정책(일 1회, 30일 보존)으로 빠르게 시작 가능합니다.",
+      "Soft Delete: 백업 데이터를 삭제 후 14일간 복원 가능 상태로 유지합니다. 랜섬웨어 공격으로부터 보호합니다.",
+      "시험 패턴: 백업 정책 구성, 복원 유형(원래 위치/새 위치), 지역 간 복원(CRR) 기능, Soft Delete 활성화 방법이 출제됩니다."
+    ],
+    "level": "중급",
+    "related_practices": [
+      "azure-lab-8"
+    ]
+  },
+  {
+    "id": "azure-entra-id",
+    "certification": "AZ-104",
+    "title": "Microsoft Entra ID — ID 관리",
+    "summary": "Azure의 클라우드 기반 ID 및 접근 관리(IAM) 서비스입니다(구 Azure Active Directory). 사용자·그룹·애플리케이션 ID를 관리하고 MFA, 조건부 접근을 제공합니다.",
+    "example": "az ad user create \\\n  --display-name 'Alice Kim' \\\n  --user-principal-name alice@mydomain.com \\\n  --password 'TempPass123!'\naz ad group create --display-name 'Developers' --mail-nickname 'devs'",
+    "common_mistake": "Entra ID와 온프레미스 Active Directory는 다른 제품입니다. Entra ID는 클라우드 LDAP/Kerberos가 아니며, 도메인 조인은 Entra Domain Services를 사용합니다.",
+    "keywords": [
+      "Entra ID",
+      "AAD",
+      "tenant",
+      "user",
+      "group",
+      "MFA",
+      "SSO",
+      "B2B",
+      "B2C"
+    ],
+    "source_id": "azure-rbac-overview",
+    "details": [
+      "테넌트(Tenant)는 Entra ID의 인스턴스이며 조직 단위입니다. 구독은 반드시 하나의 테넌트에 연결됩니다.",
+      "사용자 유형: Member(내부 사용자) vs Guest(B2B 초대 사용자). 그룹 유형: Security(RBAC 할당용) vs Microsoft 365.",
+      "시험 패턴: 사용자/그룹 생성·관리, 게스트 사용자 초대(B2B), MFA 등록, SSPR 설정, Entra ID vs 온프레미스 AD 차이가 출제됩니다."
+    ],
+    "level": "입문"
+  },
+  {
+    "id": "azure-management-group",
+    "certification": "AZ-104",
+    "title": "Management Group — 관리 그룹",
+    "summary": "여러 구독을 계층적으로 묶는 컨테이너입니다. 최상위 루트 관리 그룹에서 RBAC와 Policy를 할당하면 하위 구독으로 상속됩니다.",
+    "example": "# 계층 구조 예:\n# Root Management Group\n#   └─ Production MG\n#       ├─ Sub-A\n#       └─ Sub-B\naz account management-group create --name 'Production'",
+    "common_mistake": "관리 그룹은 최대 6단계(루트 포함)까지 중첩 가능합니다. 구독은 한 번에 하나의 관리 그룹에만 속할 수 있습니다.",
+    "keywords": [
+      "management group",
+      "hierarchy",
+      "policy inheritance",
+      "RBAC",
+      "root",
+      "subscription"
+    ],
+    "source_id": "azure-rbac-overview",
+    "details": [
+      "루트 관리 그룹에 할당한 Policy·RBAC는 테넌트의 모든 구독에 상속됩니다. 전사 규정 적용에 사용됩니다.",
+      "관리 그룹 이동: 구독이나 하위 관리 그룹을 다른 관리 그룹으로 이동할 수 있습니다.",
+      "시험 패턴: 관리 그룹 계층 설계, Policy/RBAC 상속 흐름, 관리 그룹 vs 구독 vs RG 범위 차이 문제가 출제됩니다."
+    ],
+    "level": "입문"
+  },
+  {
+    "id": "azure-subscription",
+    "certification": "AZ-104",
+    "title": "Subscription — 구독",
+    "summary": "Azure 리소스를 배포하고 비용을 청구하는 기본 단위입니다. 구독마다 리소스 한도(quota)가 있으며 하나의 Entra ID 테넌트에 연결됩니다.",
+    "example": "az account list --output table\naz account set --subscription 'My Subscription'\naz account show",
+    "common_mistake": "구독과 테넌트는 1:1이 아닙니다. 하나의 테넌트에 여러 구독이 속할 수 있고, 구독을 다른 테넌트로 이전할 수도 있습니다.",
+    "keywords": [
+      "subscription",
+      "tenant",
+      "quota",
+      "billing",
+      "az account"
+    ],
+    "source_id": "azure-rbac-overview",
+    "details": [
+      "구독 유형: Pay-As-You-Go, Enterprise Agreement(EA), CSP(파트너 제공) 등. 비용 청구 계정과 연결됩니다.",
+      "리소스 한도(Quota)는 구독 단위로 관리됩니다. 예: 특정 region의 vCPU 최대 수. 한도 증가는 Microsoft에 요청합니다.",
+      "시험 패턴: 구독 이동(테넌트 간), 구독 레벨 RBAC, Cost Management에서 구독별 비용 분석 시나리오가 출제됩니다."
+    ],
+    "level": "입문"
+  },
+  {
+    "id": "azure-resource-lock",
+    "certification": "AZ-104",
+    "title": "Resource Lock — 리소스 잠금",
+    "summary": "실수로 리소스를 수정·삭제하지 못하도록 보호합니다. ReadOnly(수정·삭제 차단)와 CanNotDelete(삭제만 차단) 두 가지가 있습니다.",
+    "example": "az lock create \\\n  --name 'prod-lock' \\\n  --resource-group myRG \\\n  --lock-type CanNotDelete\naz lock list --resource-group myRG",
+    "common_mistake": "Lock은 RBAC보다 우선합니다. Owner라도 Lock이 걸린 리소스는 잠금을 먼저 해제해야 수정·삭제할 수 있습니다.",
+    "keywords": [
+      "resource lock",
+      "CanNotDelete",
+      "ReadOnly",
+      "RBAC override"
+    ],
+    "source_id": "azure-vm-overview",
+    "details": [
+      "ReadOnly Lock: 읽기는 가능하지만 쓰기·삭제 모두 차단. VM에 걸면 재시작도 차단될 수 있습니다.",
+      "Lock은 RG에 설정하면 하위 모든 리소스에 상속됩니다. 개별 리소스에만 걸 수도 있습니다.",
+      "시험 패턴: Lock과 RBAC 상호작용, CanNotDelete vs ReadOnly 시나리오, 잠금 해제 없이 삭제 시도 결과가 출제됩니다."
+    ],
+    "level": "입문",
+    "related_practices": [
+      "azure-lab-6"
+    ]
+  },
+  {
+    "id": "azure-tags",
+    "certification": "AZ-104",
+    "title": "Tags — 태그",
+    "summary": "리소스에 키-값 메타데이터를 붙여 분류·비용 추적·자동화에 활용합니다. RG의 태그는 내부 리소스에 자동 상속되지 않습니다.",
+    "example": "az resource tag \\\n  --tags Environment=Production CostCenter=IT \\\n  --ids /subscriptions/SUB/resourceGroups/myRG\n# Policy로 태그 강제:\n# 'Require a tag on resources'",
+    "common_mistake": "태그는 RG에서 내부 리소스로 자동 상속되지 않습니다. 상속이 필요하면 Azure Policy로 태그 상속 규칙을 적용해야 합니다.",
+    "keywords": [
+      "tags",
+      "key-value",
+      "cost center",
+      "environment",
+      "policy",
+      "inheritance"
+    ],
+    "source_id": "azure-vm-overview",
+    "details": [
+      "리소스당 최대 50개의 태그. 이름 최대 512자, 값 최대 256자(스토리지 계정은 이름 128자).",
+      "비용 분석에서 태그로 필터링하면 부서별·프로젝트별 비용을 추적할 수 있습니다.",
+      "시험 패턴: 태그 상속 제한, Policy를 통한 태그 강제 적용, 비용 분석에서 태그 활용 시나리오가 출제됩니다."
+    ],
+    "level": "입문"
+  },
+  {
+    "id": "azure-custom-role",
+    "certification": "AZ-104",
+    "title": "Custom Role — 사용자 지정 역할",
+    "summary": "내장 역할이 너무 광범위하거나 부족할 때 특정 Actions만 허용하는 역할을 직접 만듭니다. JSON으로 Actions·NotActions·DataActions를 정의합니다.",
+    "example": "{\n  \"Name\": \"VM Operator\",\n  \"Actions\": [\n    \"Microsoft.Compute/virtualMachines/start/action\",\n    \"Microsoft.Compute/virtualMachines/restart/action\",\n    \"Microsoft.Compute/virtualMachines/read\"\n  ],\n  \"AssignableScopes\": [\"/subscriptions/SUB_ID\"]\n}",
+    "common_mistake": "Custom Role은 테넌트 내에서 만들지만, AssignableScopes에 지정한 구독/RG 범위에서만 할당할 수 있습니다.",
+    "keywords": [
+      "custom role",
+      "Actions",
+      "NotActions",
+      "DataActions",
+      "AssignableScopes",
+      "JSON"
+    ],
+    "source_id": "azure-rbac-overview",
+    "details": [
+      "Actions: 관리 평면 작업 허용. NotActions: Actions에서 제외할 작업. DataActions: 데이터 평면 작업(Blob 읽기 등).",
+      "기존 내장 역할을 복사해 수정하는 방식이 편리합니다: `az role definition list --name 'Contributor'`로 시작.",
+      "시험 패턴: 최소 권한 원칙에 따른 Custom Role Actions 설계, DataActions vs Actions 차이, AssignableScopes 설정이 출제됩니다."
+    ],
+    "level": "중급"
+  },
+  {
+    "id": "azure-sas",
+    "certification": "AZ-104",
+    "title": "Shared Access Signature — SAS",
+    "summary": "스토리지 계정 전체를 노출하지 않고 특정 리소스에 제한된 권한과 시간 범위의 접근을 허용하는 서명된 URL입니다.",
+    "example": "az storage blob generate-sas \\\n  --account-name myaccount \\\n  --container-name data \\\n  --name report.pdf \\\n  --permissions r \\\n  --expiry 2024-12-31",
+    "common_mistake": "SAS URL이 노출되면 만료 전까지 누구나 접근 가능합니다. 민감한 데이터는 짧은 만료 시간을 설정하고, SAS를 저장한 Stored Access Policy를 사용해 즉시 취소할 수 있습니다.",
+    "keywords": [
+      "SAS",
+      "Service SAS",
+      "Account SAS",
+      "User Delegation SAS",
+      "expiry",
+      "stored access policy"
+    ],
+    "source_id": "azure-storage-account",
+    "details": [
+      "SAS 유형: Account SAS(전체 스토리지 서비스), Service SAS(특정 서비스), User Delegation SAS(Entra ID 자격 증명 기반, 가장 안전).",
+      "Stored Access Policy: 서비스 SAS를 정책에 연결하면 URL을 재발급하지 않고 정책 삭제만으로 접근을 즉시 취소할 수 있습니다.",
+      "시험 패턴: SAS 유형 선택, 권한·만료 설정, Stored Access Policy를 통한 취소 방법, 키 기반 vs Entra ID 기반 SAS 차이가 출제됩니다."
+    ],
+    "level": "중급"
+  },
+  {
+    "id": "azure-storage-redundancy",
+    "certification": "AZ-104",
+    "title": "Storage Redundancy — 스토리지 중복성",
+    "summary": "데이터를 복제해 가용성과 내구성을 보장합니다. 복제 범위(단일 데이터센터→AZ→다른 region)에 따라 LRS·ZRS·GRS·GZRS 중 선택합니다.",
+    "example": "# 생성 시 SKU로 결정\naz storage account create --sku Standard_GRS ...\n# 변경 (일부만 가능)\naz storage account update --sku Standard_RAGRS --name myaccount",
+    "common_mistake": "GRS는 보조 지역에 데이터를 복제하지만 기본적으로 읽기 불가입니다. 보조 지역 읽기를 허용하려면 RA-GRS(Read-Access GRS)로 설정해야 합니다.",
+    "keywords": [
+      "LRS",
+      "ZRS",
+      "GRS",
+      "GZRS",
+      "RA-GRS",
+      "redundancy",
+      "replication"
+    ],
+    "source_id": "azure-storage-account",
+    "details": [
+      "LRS: 단일 datacenter 내 3복제. ZRS: 동일 region 3개 AZ에 복제. GRS: 다른 region에 비동기 복제(LRS×2). GZRS: ZRS+GRS.",
+      "내구성(nines): LRS=11 9s, ZRS=12 9s, GRS=16 9s. 비용은 LRS<ZRS<GRS<GZRS 순입니다.",
+      "시험 패턴: 요구사항(AZ 장애 보호, region 장애 보호)에 따른 중복성 선택, RA-GRS에서 보조 지역 접근 방법이 출제됩니다."
+    ],
+    "level": "중급"
+  },
+  {
+    "id": "azure-lifecycle",
+    "certification": "AZ-104",
+    "title": "Storage Lifecycle Management — 스토리지 수명 주기",
+    "summary": "Blob을 일정 기간 후 자동으로 계층 전환(Hot→Cool→Archive)하거나 삭제하는 정책을 정의합니다. 비용 자동 최적화에 활용합니다.",
+    "example": "# 규칙 예: 30일 후 Cool, 90일 후 Archive, 365일 후 삭제\n{\n  \"rules\": [{\n    \"action\": {\"baseBlob\": {\n      \"tierToCool\": {\"daysAfterModificationGreaterThan\": 30},\n      \"tierToArchive\": {\"daysAfterModificationGreaterThan\": 90},\n      \"delete\": {\"daysAfterModificationGreaterThan\": 365}\n    }}\n  }]\n}",
+    "common_mistake": "수명 주기 정책은 Blob 레벨에서만 동작합니다. 이미 Archive 계층인 Blob은 정책이 다시 Archive로 전환하지 않습니다.",
+    "keywords": [
+      "lifecycle policy",
+      "tier transition",
+      "Hot",
+      "Cool",
+      "Archive",
+      "delete",
+      "daysAfterModification"
+    ],
+    "source_id": "azure-blob-access-tiers",
+    "details": [
+      "조건 기준: 마지막 수정 날짜, 마지막 접근 날짜(접근 추적 활성화 필요), blob 생성 날짜 중 선택합니다.",
+      "필터로 특정 컨테이너, 접두사, blob 유형(blockBlob/appendBlob)에만 정책을 적용할 수 있습니다.",
+      "시험 패턴: 특정 비용 최적화 시나리오에서 lifecycle 정책 규칙 작성, 조건별 계층 전환 순서, 삭제 포함 전체 흐름이 출제됩니다."
+    ],
+    "level": "중급"
+  },
+  {
+    "id": "azure-files",
+    "certification": "AZ-104",
+    "title": "Azure Files — 파일 공유",
+    "summary": "SMB/NFS 프로토콜로 마운트하는 완전 관리형 클라우드 파일 공유입니다. VM·온프레미스·컨테이너에서 네트워크 드라이브처럼 사용합니다.",
+    "example": "# Windows에서 마운트\nnet use Z: \\\\myaccount.file.core.windows.net\\myshare /user:myaccount [key]\n# Linux에서 마운트\nmount -t cifs //myaccount.file.core.windows.net/myshare /mnt -o user=myaccount,password=[key]",
+    "common_mistake": "Azure Files SMB는 포트 445를 사용합니다. 일부 ISP와 기업 방화벽이 445를 차단해 마운트가 실패하는 경우가 있습니다.",
+    "keywords": [
+      "Azure Files",
+      "SMB",
+      "NFS",
+      "file share",
+      "port 445",
+      "Azure File Sync"
+    ],
+    "source_id": "azure-storage-account",
+    "details": [
+      "성능 계층: Standard(HDD 기반), Premium(SSD 기반). Premium은 낮은 지연시간이 필요한 워크로드에 사용합니다.",
+      "Azure File Sync: 온프레미스 파일 서버와 Azure Files를 동기화하고, 자주 쓰지 않는 파일을 Cloud Tiering으로 Azure에 올립니다.",
+      "시험 패턴: Blob vs Files 선택 기준(파일 시스템 마운트 필요 여부), Azure File Sync 아키텍처, 포트 445 문제 해결이 출제됩니다."
+    ],
+    "level": "중급"
+  },
+  {
+    "id": "azure-managed-disk",
+    "certification": "AZ-104",
+    "title": "Managed Disk — 관리 디스크",
+    "summary": "VM에 연결하는 블록 스토리지입니다. OS 디스크와 데이터 디스크로 나뉘며, 성능 요구에 따라 Standard HDD·Standard SSD·Premium SSD·Ultra Disk를 선택합니다.",
+    "example": "az disk create \\\n  --name myDataDisk \\\n  --resource-group myRG \\\n  --size-gb 128 \\\n  --sku Premium_LRS\naz vm disk attach --vm-name myVM --name myDataDisk",
+    "common_mistake": "관리 디스크 크기는 늘릴 수만 있고 줄일 수 없습니다. 크기를 줄이려면 새 작은 디스크를 만들고 데이터를 이전해야 합니다.",
+    "keywords": [
+      "managed disk",
+      "OS disk",
+      "data disk",
+      "Premium SSD",
+      "Ultra Disk",
+      "snapshot",
+      "disk encryption"
+    ],
+    "source_id": "azure-storage-account",
+    "details": [
+      "SKU 선택: Standard HDD(비용 최저, 백업용), Standard SSD(일반 워크로드), Premium SSD(I/O 집약 앱), Ultra Disk(DB, 최저 지연).",
+      "스냅샷: 특정 시점의 디스크 상태를 캡처. 다른 region에 복사해 재해 복구에 활용할 수 있습니다.",
+      "시험 패턴: 워크로드별 디스크 SKU 선택, 디스크 확장 후 OS에서 파티션 확장 필요 여부, 스냅샷 vs 백업 차이가 출제됩니다."
+    ],
+    "level": "입문"
+  },
+  {
+    "id": "azure-availability-set",
+    "certification": "AZ-104",
+    "title": "Availability Set — 가용성 집합",
+    "summary": "동일 데이터센터 내에서 VM을 다른 물리 랙(장애 도메인)과 업데이트 그룹(업데이트 도메인)에 배치해 단일 장애점을 없앱니다.",
+    "example": "az vm availability-set create \\\n  --name myAS \\\n  --resource-group myRG \\\n  --platform-fault-domain-count 2 \\\n  --platform-update-domain-count 5",
+    "common_mistake": "Availability Set은 단일 데이터센터 내 보호입니다. 데이터센터 전체 장애나 AZ 장애에 대응하려면 Availability Zones를 사용해야 합니다.",
+    "keywords": [
+      "availability set",
+      "fault domain",
+      "update domain",
+      "UD",
+      "FD",
+      "SLA 99.95%"
+    ],
+    "source_id": "azure-vm-overview",
+    "details": [
+      "장애 도메인(FD): 공유 전원·네트워크 스위치 기준 물리 랙 분리. 기본 최대 3개.",
+      "업데이트 도메인(UD): 계획된 유지 관리 시 동시에 재시작하지 않는 그룹. 기본 5개(최대 20개).",
+      "시험 패턴: AS vs AZ 보호 수준 차이, SLA(AS=99.95%, 단일VM-Premium=99.9%, AZ=99.99%), AS에 VM 추가 시기 제한이 출제됩니다."
+    ],
+    "level": "입문"
+  },
+  {
+    "id": "azure-autoscale",
+    "certification": "AZ-104",
+    "title": "Autoscale — 자동 크기 조정",
+    "summary": "메트릭(CPU, 메모리, 큐 길이 등)이나 일정에 따라 VM Scale Set 또는 App Service의 인스턴스 수를 자동으로 늘리고 줄입니다.",
+    "example": "# Autoscale 규칙 예:\n# CPU > 70% 5분 유지 → +1 인스턴스 추가\n# CPU < 30% 5분 유지 → -1 인스턴스 제거\n# 최소 2, 최대 10 인스턴스",
+    "common_mistake": "Scale-out(추가)과 Scale-in(제거) 규칙을 모두 설정해야 합니다. Scale-out만 설정하면 인스턴스가 줄어들지 않아 비용�� 계속 증가합니다.",
+    "keywords": [
+      "autoscale",
+      "scale-out",
+      "scale-in",
+      "metric",
+      "cooldown",
+      "min/max instances"
+    ],
+    "source_id": "azure-vmss-overview",
+    "details": [
+      "냉각 기간(Cooldown): Scale 동작 후 다음 동작까지 기다리는 시간. 너무 짧으면 진동(flapping) 현상이 발생합니다.",
+      "일정 기반 Autoscale: 특정 요일·시간대에 인스턴스 수를 고정하거나 늘릴 수 있습니다.",
+      "시험 패턴: Scale-in/out 규칙 설계, 냉각 기간 개념, 메트릭 기반 vs 일정 기반 선택, VMSS와 App Service의 Autoscale 차이가 출제됩니다."
+    ],
+    "level": "중급"
+  },
+  {
+    "id": "azure-vnet-peering",
+    "certification": "AZ-104",
+    "title": "VNet Peering — 가상 네트워크 피어링",
+    "summary": "두 VNet을 Microsoft 백본 네트워크로 직접 연결합니다. 동일 region(Local Peering)과 다른 region(Global Peering) 모두 가능합니다.",
+    "example": "az network vnet peering create \\\n  --name VNet1-to-VNet2 \\\n  --vnet-name VNet1 \\\n  --remote-vnet VNet2 \\\n  --resource-group myRG\n# 반대 방향도 생성해야 함",
+    "common_mistake": "피어링은 비전이적(non-transitive)입니다. A↔B, B↔C로 피어링해도 A에서 C로 직접 통신할 수 없습니다. A↔C를 별도로 설정해야 합니다.",
+    "keywords": [
+      "VNet peering",
+      "non-transitive",
+      "local peering",
+      "global peering",
+      "transit"
+    ],
+    "source_id": "azure-vnet-overview",
+    "details": [
+      "피어링 조건: 두 VNet의 주소 공간이 겹치지 않아야 합니다. 피어링은 양방향 설정이 각각 필요합니다.",
+      "게이트웨이 전송(Gateway Transit): 피어링된 VNet이 허브의 VPN Gateway를 공유해 온프레미스 연결에 활용합니다.",
+      "시험 패턴: 비전이성으로 인한 연결 불가 시나리오, 주소 공간 중첩 오류, Gateway Transit 설정 방법이 자주 출제됩니다."
+    ],
+    "level": "중급",
+    "related_practices": [
+      "azure-lab-10"
+    ]
+  },
+  {
+    "id": "azure-route-table",
+    "certification": "AZ-104",
+    "title": "Route Table — 경로 테이블",
+    "summary": "서브넷의 트래픽 경로를 사용자 정의합니다(UDR: User-Defined Route). 기본 시스템 경로를 재정의해 트래픽을 NVA, VPN GW, VNet Gateway 등으로 보냅니다.",
+    "example": "az network route-table create --name myRT --resource-group myRG\naz network route-table route create \\\n  --route-table-name myRT \\\n  --name force-to-firewall \\\n  --address-prefix 0.0.0.0/0 \\\n  --next-hop-type VirtualAppliance \\\n  --next-hop-ip-address 10.0.1.4",
+    "common_mistake": "경로 테이블은 서브넷에 연결해야 효과가 납니다. Route Table을 만들기만 하고 서브넷에 연결(association)하지 않으면 적용되지 않습니다.",
+    "keywords": [
+      "route table",
+      "UDR",
+      "next hop",
+      "NVA",
+      "VirtualAppliance",
+      "subnet association"
+    ],
+    "source_id": "azure-vnet-overview",
+    "details": [
+      "Next hop 유형: VirtualAppliance(방화벽 NVA), VirtualNetworkGateway(VPN), Internet, VnetLocal, None(트래픽 드롭).",
+      "강제 터널링(Force Tunneling): 0.0.0.0/0을 VPN Gateway로 보내 인터넷 트래픽도 온프레미스 경유하게 합니다.",
+      "시험 패턴: 특정 트래픽을 NVA로 우회하는 UDR 설계, 강제 터널링 구성, 시스템 경로 vs 사용자 경로 우선순위가 출제됩니다."
+    ],
+    "level": "중급"
+  },
+  {
+    "id": "azure-private-endpoint",
+    "certification": "AZ-104",
+    "title": "Private Endpoint — 프라이빗 엔드포인트",
+    "summary": "Azure PaaS 서비스(Storage, SQL, Key Vault 등)에 VNet 내 사설 IP로 접근합니다. 인터넷을 통하지 않아 데이터 노출 위험을 줄입니다.",
+    "example": "az network private-endpoint create \\\n  --name myPE \\\n  --resource-group myRG \\\n  --vnet-name myVNet \\\n  --subnet default \\\n  --private-connection-resource-id /subscriptions/.../storageAccounts/myaccount \\\n  --group-ids blob",
+    "common_mistake": "Private Endpoint 생성 후 DNS 설정을 추가해야 합니다. Private DNS Zone과 연결하지 않으면 공용 DNS가 Public IP를 반환해 인터넷 경로로 접속됩니다.",
+    "keywords": [
+      "private endpoint",
+      "private link",
+      "private IP",
+      "DNS zone",
+      "Service Endpoint 차이"
+    ],
+    "source_id": "azure-private-endpoint",
+    "details": [
+      "Private Endpoint vs Service Endpoint: Private Endpoint는 VNet에 사설 IP를 부여(더 안전), Service Endpoint는 Public IP 유지하되 VNet에서만 허용.",
+      "Private DNS Zone 자동 통합: Private Endpoint 생성 시 DNS Zone Group을 통해 자동으로 DNS 레코드가 생성됩니다.",
+      "시험 패턴: Private Endpoint vs Service Endpoint 차이, DNS 설정 없을 때 발생하는 문��, 온프레미스에서 Private Endpoint 접근 방법이 출제됩니다."
+    ],
+    "level": "중급",
+    "related_practices": [
+      "azure-lab-11"
+    ]
+  },
+  {
+    "id": "azure-load-balancer-probe",
+    "certification": "AZ-104",
+    "title": "Load Balancer — 부하 분산 장치",
+    "summary": "L4(TCP/UDP) 수준에서 인바운드 트래픽을 백엔드 VM 풀로 분산합니다. Public LB는 인터넷 트래픽, Internal LB는 VNet 내부 트래픽을 처리합니다.",
+    "example": "az network lb create \\\n  --name myLB \\\n  --resource-group myRG \\\n  --frontend-ip-name frontendIP \\\n  --backend-pool-name backendPool\n# 상태 프로브 추가\naz network lb probe create --lb-name myLB --name myProbe --protocol Http --port 80 --path /health",
+    "common_mistake": "상태 프로브(Health Probe)가 실패하면 해당 인스턴스로 트래픽을 보내지 않습니다. 프로브 경로(/health)가 올바르지 않으면 정상 VM도 제외됩니다.",
+    "keywords": [
+      "load balancer",
+      "health probe",
+      "backend pool",
+      "frontend IP",
+      "SKU Basic/Standard"
+    ],
+    "source_id": "azure-load-balancer",
+    "details": [
+      "SKU: Basic(무료, AZ 미지원, 공개 미리 보기) vs Standard(유료, AZ 지원, HTTPS 프로브, SLA 99.99%). 새 구축은 Standard 권장.",
+      "부하 분산 규칙: 포트·프로토콜·세션 지속성(Client IP/Protocol)을 설정. Floating IP로 SQL AlwaysOn 등을 지원합니다.",
+      "시험 패턴: 프로브 실패 시 동작, Public vs Internal LB 선택, Basic vs Standard SKU 차이, 세션 지속성 옵션이 출제됩니다."
+    ],
+    "level": "중급"
+  },
+  {
+    "id": "azure-private-dns",
+    "certification": "AZ-104",
+    "title": "Private DNS Zone — 사설 DNS 영역",
+    "summary": "VNet 내부에서만 해석되는 사설 도메인을 호스팅합니다. Private Endpoint, 내부 서비스 검색, 온프레미스 DNS 통합에 사용합니다.",
+    "example": "az network private-dns zone create \\\n  --name 'privatelink.blob.core.windows.net' \\\n  --resource-group myRG\naz network private-dns link vnet create \\\n  --zone-name 'privatelink.blob.core.windows.net' \\\n  --virtual-network myVNet \\\n  --registration-enabled false",
+    "common_mistake": "Private DNS Zone 생성만으로는 적용되지 않습니다. VNet에 링크(link)를 연결해야 해당 VNet의 VM이 사설 DNS를 쿼리합니다.",
+    "keywords": [
+      "private DNS zone",
+      "VNet link",
+      "registration",
+      "privatelink",
+      "custom DNS"
+    ],
+    "source_id": "azure-dns-overview",
+    "details": [
+      "자동 등록(Auto-registration): VNet 링크에서 활성화하면 해당 VNet의 VM이 자동으로 A 레코드로 등록됩니다.",
+      "Private Endpoint DNS: `privatelink.blob.core.windows.net` 같은 특수 영역을 사용해 PaaS 서비스의 사설 IP를 해석합니다.",
+      "시험 패턴: Private Endpoint와 Private DNS Zone 연동 순서, 자동 등록 vs 수동 레코드, VNet 링크 없을 때 DNS 해석 실패 시나리오가 출제됩니다."
+    ],
+    "level": "중급"
+  },
+  {
+    "id": "azure-monitor-metrics",
+    "certification": "AZ-104",
+    "title": "Azure Monitor Metrics — 모니터 메트릭",
+    "summary": "Azure 리소스가 자동으로 수집하는 수치 데이터(CPU%, 네트워크 In/Out, 디스크 IOPS 등)를 실시간으로 확인하고 경보를 설정합니다.",
+    "example": "az monitor metrics list \\\n  --resource /subscriptions/.../virtualMachines/myVM \\\n  --metric 'Percentage CPU' \\\n  --interval PT1M",
+    "common_mistake": "기본 플랫폼 메트릭은 93일 보관됩니다. 더 오래 보관하거나 커스텀 메트릭을 저장하려면 Log Analytics Workspace로 전송해야 합니다.",
+    "keywords": [
+      "metrics",
+      "Azure Monitor",
+      "CPU",
+      "latency",
+      "alert",
+      "93 days retention"
+    ],
+    "source_id": "azure-monitor-overview",
+    "details": [
+      "플랫폼 메트릭은 별도 설정 없이 자동 수집됩니다. 게스트 OS 내부 메트릭(메모리 등)은 Azure Monitor Agent가 필요합니다.",
+      "메트릭 탐색기(Metrics Explorer)에서 여러 메트릭을 비교하고 차트를 대시보드에 고정할 수 있습니다.",
+      "시험 패턴: 메트릭 기반 경보 설정, 플랫폼 메트릭 vs 게스트 메트릭 수집 방법, 보관 기간 한계와 Log Analytics 연동이 출제됩니다."
+    ],
+    "level": "중급",
+    "related_practices": [
+      "azure-lab-15"
+    ]
+  },
+  {
+    "id": "azure-activity-log",
+    "certification": "AZ-104",
+    "title": "Activity Log — 활동 로그",
+    "summary": "구독 레벨에서 발생하는 관리 작업(리소스 생성·삭제·변경)을 기록합니다. 누가, 언제, 무엇을 했는지 감사(Audit)에 활용합니다.",
+    "example": "az monitor activity-log list \\\n  --resource-group myRG \\\n  --start-time 2024-01-01 \\\n  --end-time 2024-01-31\n# Portal: Monitor → Activity Log",
+    "common_mistake": "Activity Log는 기본 90일 보관됩니다. 장기 보관을 위해 Storage Account에 아카이브하거나 Log Analytics로 전송해야 합니다.",
+    "keywords": [
+      "activity log",
+      "audit",
+      "management plane",
+      "90 days",
+      "diagnostic settings"
+    ],
+    "source_id": "azure-monitor-overview",
+    "details": [
+      "기록 내용: 누가(caller), 언제(eventTimestamp), 무엇을(operation), 성공/실패(status). 데이터 평면 작업(Blob 읽기 등)은 기록되지 않습니다.",
+      "진단 설정(Diagnostic Settings)으로 Activity Log를 Log Analytics, Storage Account, Event Hub로 전송할 수 있습니다.",
+      "시험 패턴: 리소스 삭제 책임자 추적, 90일 이상 보관 방법, Activity Log vs Diagnostic Log(리소스 레벨) 차이가 출제됩니다."
+    ],
+    "level": "중급"
+  },
+  {
+    "id": "azure-alert",
+    "certification": "AZ-104",
+    "title": "Alert Rule — 경보 규칙",
+    "summary": "메트릭·로그·활동 로그 조건이 충족되면 이메일·SMS·webhook·ITSM 등으로 알립니다. Action Group에 알림 대상을 정의합니다.",
+    "example": "az monitor alert create \\\n  --name highCPU \\\n  --resource /subscriptions/.../myVM \\\n  --condition 'avg Percentage CPU > 80' \\\n  --action email alice@example.com",
+    "common_mistake": "경보는 Action Group 없이는 발생해도 아무도 알 수 없습니다. 반드시 Action Group에 알림 채널을 설정해야 합니다.",
+    "keywords": [
+      "alert rule",
+      "action group",
+      "metric alert",
+      "log alert",
+      "severity",
+      "signal"
+    ],
+    "source_id": "azure-monitor-overview",
+    "details": [
+      "신호 유형: 메트릭(수치 임계값), 로그(KQL 쿼리 결과), 활동 로그(특정 작업 발생), 서비스 상태.",
+      "Action Group: 이메일, SMS, 전화, Azure Function, Logic App, webhook, ITSM 통합을 정의합니다. 여러 경보에서 공유 가능합니다.",
+      "시험 패턴: 메트릭 경보 구성 절차, Action Group 생성 및 연결, 경보 심각도(0~4) 레벨, 정적 vs 동적 임계값이 출제됩니다."
+    ],
+    "level": "중급",
+    "related_practices": [
+      "azure-lab-15"
+    ]
+  },
+  {
+    "id": "azure-backup-policy",
+    "certification": "AZ-104",
+    "title": "Backup Policy — 백업 정책",
+    "summary": "백업 스케줄(일별/주별)과 보존 기간(일/주/월/년)을 정의합니다. Recovery Services Vault에서 워크로드별로 정책을 만들어 리소스에 적용합니다.",
+    "example": "az backup policy create \\\n  --vault-name myVault \\\n  --resource-group myRG \\\n  --name myPolicy \\\n  --policy @policy.json\n# policy.json에 스케줄과 보존 기간 정의",
+    "common_mistake": "백업 정책을 변경해도 기존 복원 지점 보존 기간은 소급 적용되지 않습니다. 변경 이후 생성되는 복원 지점에만 새 정책이 적용됩니다.",
+    "keywords": [
+      "backup policy",
+      "schedule",
+      "retention",
+      "RPO",
+      "Recovery Services Vault"
+    ],
+    "source_id": "azure-recovery-services-vault",
+    "details": [
+      "Enhanced Policy(향상된 정책): 시간당 백업, AZ 중복 복원 지점, Trusted Launch VM 지원 등 더 많은 옵션을 제공합니다.",
+      "보존 계층: 일별(최대 180일), 주별(최대 520주), 월별(최대 120개월), 연별(최대 10년).",
+      "시험 패턴: RPO(복구 시점 목표)에 따른 백업 스케줄 선택, 장기 보존 설정, GRS 백업으로 지역 간 복원 방법이 출제됩니다."
+    ],
+    "level": "중급",
+    "related_practices": [
+      "azure-lab-8"
+    ]
+  },
+  {
+    "id": "azure-restore",
+    "certification": "AZ-104",
+    "title": "Restore — 복원",
+    "summary": "Recovery Services Vault의 복원 지점에서 VM, 디스크, 파일을 원래 위치 또는 새 위치로 복원합니다.",
+    "example": "az backup restore restore-disks \\\n  --vault-name myVault \\\n  --resource-group myRG \\\n  --container-name myVM \\\n  --item-name myVM \\\n  --rp-name 'RecoveryPointName' \\\n  --storage-account myStorageAcct",
+    "common_mistake": "VM 전체 복원(Restore VM)과 디스크만 복원(Restore Disks)은 다른 옵션입니다. 디스크 복원 후에는 VM을 별도로 재구성해야 합니다.",
+    "keywords": [
+      "restore",
+      "recovery point",
+      "original location",
+      "alternate location",
+      "cross-region restore"
+    ],
+    "source_id": "azure-recovery-services-vault",
+    "details": [
+      "복원 옵션: 원래 위치(기존 VM 덮어쓰기), 새 위치(새 VM 생성), 디스크만 복원(Storage Account에 VHD 저장), 파일 복원(파일 단위).",
+      "지역 간 복원(CRR): GRS Vault에서 보조 region의 복원 지점으로 DR 복원. CRR 기능을 Vault에서 명시적으로 활성화해야 합니다.",
+      "시험 패턴: 복원 유형 선택(VM vs 파일), 지역 간 복원 요건, Soft Delete 상태에서 복원 가능 여부가 출제됩니다."
+    ],
+    "level": "중급",
+    "related_practices": [
+      "azure-lab-8"
+    ]
+  },
+  {
+    "id": "azure-app-service-plan",
+    "certification": "AZ-104",
+    "title": "App Service Plan — 앱 서비스 플랜",
+    "summary": "App Service 앱이 실행되는 컴퓨팅 리소스(CPU, 메모리, 스토리지)를 정의합니다. 동일 플랜의 앱은 같은 VM 인스턴스를 공유합니다.",
+    "example": "az appservice plan create \\\n  --name myPlan \\\n  --resource-group myRG \\\n  --sku P1v3 \\\n  --is-linux\naz webapp create --name myApp --plan myPlan --runtime 'NODE:18-lts'",
+    "common_mistake": "Free/Shared 플랜은 Autoscale과 커스텀 도메인 SSL을 지원하지 않습니다. 프로덕션에는 Standard(S1) 이상을 사용해야 합니다.",
+    "keywords": [
+      "App Service Plan",
+      "SKU",
+      "Free",
+      "Basic",
+      "Standard",
+      "Premium",
+      "Isolated",
+      "autoscale"
+    ],
+    "source_id": "azure-app-service-overview",
+    "details": [
+      "SKU 계층: Free/Shared(공유 인프라, SLA 없음), Basic(전용 VM), Standard(Autoscale, SSL), Premium(고성능), Isolated(VNet 전용 환경).",
+      "같은 플랜에 여러 앱을 넣으면 컴퓨팅을 공유합니다. 앱이 많아지면 플랜을 스케일업(크기 변경)하거나 분리합니다.",
+      "시험 패턴: 플랜 SKU별 지원 기능(Autoscale, Deployment Slots, VNet 통합 조건), 플랜 변경 시 앱 영향이 출제됩니다."
+    ],
+    "level": "고급",
+    "related_practices": [
+      "azure-lab-13"
+    ]
+  },
+  {
+    "id": "azure-container-registry",
+    "certification": "AZ-104",
+    "title": "Azure Container Registry — 컨테이너 레지스트리",
+    "summary": "Docker 컨테이너 이미지와 Helm 차트를 저장하고 관리하는 사설 레지스트리입니다. AKS, Container Instances, App Service와 통합됩니다.",
+    "example": "az acr create \\\n  --name myRegistry \\\n  --resource-group myRG \\\n  --sku Standard\naz acr build --registry myRegistry --image myapp:v1 .\ndocker pull myregistry.azurecr.io/myapp:v1",
+    "common_mistake": "ACR에서 이미지를 pull하려면 인증이 필요합니다. AKS에서 사용 시 Managed Identity 또는 Service Principal로 pull 권한을 부여해야 합니다.",
+    "keywords": [
+      "ACR",
+      "container registry",
+      "docker",
+      "image",
+      "geo-replication",
+      "SKU Basic/Standard/Premium"
+    ],
+    "source_id": "azure-app-service-overview",
+    "details": [
+      "SKU: Basic(개발용), Standard(일반, geo-replication 미지원), Premium(geo-replication, Private Link 지원).",
+      "ACR Tasks: 이미지 빌드·테스트·패치를 Azure에서 직접 실행. Docker 없이 클라우드에서 이미지를 빌드합니다.",
+      "시험 패턴: ACR SKU별 기능 차이, AKS에서 ACR 이미지 pull 권한 설정(Managed Identity 연결), geo-replication 설정이 출제됩니다."
+    ],
+    "level": "고급"
+  },
+  {
+    "id": "azure-key-vault",
+    "certification": "AZ-104",
+    "title": "Key Vault — 키 자격 증명 모음",
+    "summary": "비밀(Secret), 키(Key), 인증서(Certificate)를 중앙에서 안전하게 저장·관리합니다. 앱 코드에서 자격 증명을 제거하는 핵심 보안 서비스입니다.",
+    "example": "az keyvault create --name myKV --resource-group myRG --location koreacentral\naz keyvault secret set --vault-name myKV --name 'db-password' --value 'MyP@ss'\naz keyvault secret show --vault-name myKV --name 'db-password'",
+    "common_mistake": "Key Vault에 접근하려면 Access Policy 또는 RBAC로 권한을 부여해야 합니다. Managed Identity를 통해 앱이 자격 증명 없이 Key Vault에 접근하는 것이 모범 사례입니다.",
+    "keywords": [
+      "Key Vault",
+      "secret",
+      "key",
+      "certificate",
+      "soft delete",
+      "RBAC",
+      "access policy"
+    ],
+    "source_id": "azure-key-vault-overview",
+    "details": [
+      "접근 제어: 구식 Access Policy 방식과 최신 Azure RBAC 방식 두 가지. 새 구축은 RBAC 방식 권장.",
+      "Soft Delete와 Purge Protection: 실수로 삭제된 비밀을 7~90일 내 복원 가능. Purge Protection 활성화 시 삭제된 항목 영구 제거 불가.",
+      "시험 패턴: Managed Identity로 앱에서 비밀 접근, Soft Delete/Purge Protection 개념, HSM(하드웨어 보안 모듈) 지원 SKU 차이가 출제됩니다."
+    ],
+    "level": "중급",
+    "related_practices": [
+      "azure-lab-9"
+    ]
+  },
+  {
+    "id": "azure-cost-management",
+    "certification": "AZ-104",
+    "title": "Cost Management — 비용 관리",
+    "summary": "Azure 서비스 사용 비용을 분석하고 예산을 설정해 초과 시 알림을 받습니다. 태그·구독·RG별로 비용을 세분화할 수 있습니다.",
+    "example": "az consumption budget create \\\n  --budget-name monthlyBudget \\\n  --amount 1000 \\\n  --time-grain Monthly \\\n  --start-date 2024-01-01 \\\n  --end-date 2024-12-31",
+    "common_mistake": "예산 경보는 지출이 임계값에 도달했을 때 알려주는 것이지, 자동으로 리소스를 중지하거나 비용을 차단하지 않습니다.",
+    "keywords": [
+      "Cost Management",
+      "budget",
+      "alert",
+      "cost analysis",
+      "tags",
+      "billing"
+    ],
+    "source_id": "azure-monitor-overview",
+    "details": [
+      "비용 분석(Cost Analysis): 기간·서비스·location·태그 등으로 필터링해 비용 내역을 파이/누적 차트로 시각화합니다.",
+      "예산 경보: 실제 비용 또는 예측 비용이 설정 비율(예: 80%, 100%)에 도달하면 Action Group으로 알림을 보냅니다.",
+      "시험 패턴: 예산 경보 설정 절차, 태그를 통한 비용 분류, Cost Management vs Azure Advisor 역할 차이가 출제됩니다."
+    ],
+    "level": "중급"
+  },
+  {
+    "id": "azure-bastion",
+    "certification": "AZ-104",
+    "title": "Azure Bastion — 안전한 원격 접속",
+    "summary": "공용 IP 없이 Azure Portal에서 직접 VM에 RDP/SSH로 접속합니다. TLS 443 포트만 사용해 VM의 관리 포트를 인터넷에 노출하지 않습니다.",
+    "example": "az network bastion create \\\n  --name myBastion \\\n  --public-ip-address myBastionIP \\\n  --resource-group myRG \\\n  --vnet-name myVNet \\\n  --location koreacentral",
+    "common_mistake": "Bastion은 VNet에 `AzureBastionSubnet`이라는 이름의 서브넷(/27 이상)이 반드시 필요합니다. 이름이 정확히 일치해야 합니다.",
+    "keywords": [
+      "Azure Bastion",
+      "RDP",
+      "SSH",
+      "AzureBastionSubnet",
+      "port 443",
+      "no public IP"
+    ],
+    "source_id": "azure-bastion-overview",
+    "details": [
+      "Bastion SKU: Basic(RDP/SSH 기본), Standard(파일 전송, 멀티탭, 기본 호스트 포트 외 포트, VM Auth 등 추가 기능).",
+      "VM에 Public IP와 NSG에 RDP/SSH 허용 규칙이 없어도 Bastion으로 접속 가능합니다. 공격 표면이 크게 줄어듭니다.",
+      "시험 패턴: Bastion 서브넷 이름·크기 요구사항, Public IP 없는 VM 접속 방법, JIT(Just-In-Time) VM Access와 차이가 출제됩니다."
+    ],
+    "level": "중급",
+    "related_practices": [
+      "azure-lab-12"
+    ]
+  },
+  {
+    "id": "azure-nat-gateway",
+    "certification": "AZ-104",
+    "title": "NAT Gateway — 아웃바운드 인터넷 연결",
+    "summary": "서브넷의 모든 VM이 동일한 고정 공용 IP로 인터넷에 나가도록 합니다. 아웃바운드 연결 안정성을 높이고 SNAT 포트 고갈 문제를 해결합니다.",
+    "example": "az network public-ip create --name myNatIP --resource-group myRG --sku Standard\naz network nat gateway create \\\n  --name myNatGW \\\n  --resource-group myRG \\\n  --public-ip-addresses myNatIP\naz network vnet subnet update --nat-gateway myNatGW ...",
+    "common_mistake": "NAT Gateway는 아웃바운드 전용입니다. 인바운드 트래픽을 받으려면 여전히 Public IP 또는 Load Balancer가 필요합니다.",
+    "keywords": [
+      "NAT Gateway",
+      "outbound",
+      "SNAT",
+      "public IP",
+      "port exhaustion",
+      "static IP"
+    ],
+    "source_id": "azure-nat-gateway",
+    "details": [
+      "SNAT(Source NAT): VM의 사설 IP를 NAT Gateway의 공용 IP로 변환. 여러 VM이 같은 공용 IP를 공유합니다.",
+      "Load Balancer 아웃바운드 규칙 vs NAT Gateway: NAT Gateway가 더 많은 SNAT 포트(64,512 × IP 수)를 제공해 고부하에 적합합니다.",
+      "시험 패턴: NAT Gateway 서브넷 연결 방법, 고정 아웃바운드 IP 요구 시나리오, Load Balancer와 동시 사용 우선순위가 출제됩니다."
+    ],
+    "level": "중급"
+  },
+  {
+    "id": "azure-app-service",
+    "certification": "AZ-104",
+    "title": "App Service — 웹 앱 호스팅",
+    "summary": "코드 또는 컨테이너를 배포하는 완전 관리형 PaaS 웹 호스팅 서비스입니다. .NET, Node.js, Python, Java, PHP 등 다양한 런타임을 지원합니다.",
+    "example": "az webapp create \\\n  --name myWebApp \\\n  --resource-group myRG \\\n  --plan myPlan \\\n  --runtime 'PYTHON:3.11'\naz webapp deployment source config-zip \\\n  --name myWebApp --src app.zip",
+    "common_mistake": "App Service의 앱 설정(Application Settings)은 환경 변수로 앱에 주입됩니다. 코드에 하드코딩된 설정보다 앱 설정에 넣는 것이 보안에 좋습니다.",
+    "keywords": [
+      "App Service",
+      "web app",
+      "deployment slot",
+      "custom domain",
+      "SSL",
+      "VNet integration"
+    ],
+    "source_id": "azure-app-service-overview",
+    "details": [
+      "배포 방법: ZIP 배포, Git(로컬/GitHub Actions), Docker 이미지, Azure DevOps. CI/CD 연동이 용이합니다.",
+      "VNet 통합: Standard 이상 플랜에서 App Service를 VNet에 연결해 사설 리소스(DB, 캐시)에 접���할 수 있습니다.",
+      "시험 패턴: 커스텀 도메인·SSL 바인딩, 배포 슬롯 스왑, VNet 통합 설정, App Settings vs Connection Strings 차이가 출제됩니다."
+    ],
+    "level": "고급",
+    "related_practices": [
+      "azure-lab-13"
+    ]
+  },
+  {
+    "id": "azure-deployment-slot",
+    "certification": "AZ-104",
+    "title": "Deployment Slot — 배포 슬롯",
+    "summary": "앱의 스테이징 버전을 별도 슬롯에 배포하고 테스트 후 프로덕션 슬롯과 즉시 교체(Swap)합니다. Standard 이상 플랜에서 지원합니다.",
+    "example": "az webapp deployment slot create \\\n  --name myWebApp \\\n  --resource-group myRG \\\n  --slot staging\n# 테스트 후 swap\naz webapp deployment slot swap \\\n  --name myWebApp --slot staging",
+    "common_mistake": "Swap 시 슬롯 고유 설정(Slot Settings로 표시된 항목)은 교체되지 않고 각 슬롯에 고정됩니다. 예: 스테이징 DB 연결 문자열은 프로덕션으로 따라가지 않습니다.",
+    "keywords": [
+      "deployment slot",
+      "staging",
+      "swap",
+      "slot settings",
+      "traffic routing",
+      "warm-up"
+    ],
+    "source_id": "azure-app-service-overview",
+    "details": [
+      "Swap 동작: 슬롯이 워밍업된 후 라우터 수준에서 트래픽이 즉시 전환됩니다. 다운타임 없이 새 버전 배포가 가능합니다.",
+      "트래픽 라우팅: % 기반으로 일부 트래픽만 스테이징 슬롯으로 보내 A/B 테스트를 할 수 있습니다.",
+      "시험 패턴: Slot Settings(슬롯 고정 설정) 개념, Swap 시 설정 교체 규칙, Auto Swap 기능, 슬롯 수 제한(Standard=5) 이 출제됩니다."
+    ],
+    "level": "고급",
+    "related_practices": [
+      "azure-lab-14"
+    ]
+  },
+  {
+    "id": "azure-aci",
+    "certification": "AZ-104",
+    "title": "Azure Container Instances — 컨테이너 인스턴스",
+    "summary": "VM이나 클러스터 관리 없이 컨테이너를 초 단위로 빠르게 실행합니다. 단순 작업, 배치 처리, 이벤트 기반 처리에 적합합니다.",
+    "example": "az container create \\\n  --name myapp \\\n  --resource-group myRG \\\n  --image nginx:latest \\\n  --cpu 1 --memory 1.5 \\\n  --ports 80 \\\n  --dns-name-label myapp-dns",
+    "common_mistake": "ACI는 단기 실행 컨테이너에 적합합니다. 지속적인 고가용성 웹 앱이나 복잡한 마이크로서비스에는 AKS(Kubernetes)가 더 적합합니다.",
+    "keywords": [
+      "ACI",
+      "container",
+      "serverless",
+      "container group",
+      "CPU/memory",
+      "VNet"
+    ],
+    "source_id": "azure-container-instances",
+    "details": [
+      "Container Group: 동일 호스트에서 리소스를 공유하는 컨테이너 모음. Kubernetes Pod 개념과 유사합니다.",
+      "VNet 배포: ACI를 VNet에 배포하면 사설 IP를 부여받아 다른 Azure 리소스와 사설망에서 통신합니다.",
+      "시험 패턴: ACI vs AKS 선택 기준, 컨테이너 그룹 내 사이드카 패턴, 재시작 정책(Always/OnFailure/Never) 시나리오가 출제됩니다."
+    ],
+    "level": "고급"
+  },
+  {
+    "id": "azure-keyvault-secret",
+    "certification": "AZ-104",
+    "title": "Key Vault Secret — 비밀 관리",
+    "summary": "Key Vault에서 API 키, 비밀번호, 연결 문자열을 버전 관리와 함께 저장합니다. 앱에서 Managed Identity로 코드에 자격 증명 없이 비밀을 가져옵니다.",
+    "example": "az keyvault secret set --vault-name myKV --name 'APIKey' --value 'secret123'\naz keyvault secret show --vault-name myKV --name 'APIKey' --query 'value'\n# 앱에서: 환경변수 또는 Key Vault 참조로 주입",
+    "common_mistake": "비밀을 삭제하면 모든 버전이 삭제됩니다. Soft Delete가 활성화된 경우 복원 기간(90일 기본) 내에 복구 가능합니다.",
+    "keywords": [
+      "secret",
+      "version",
+      "managed identity",
+      "Key Vault reference",
+      "rotation",
+      "soft delete"
+    ],
+    "source_id": "azure-key-vault-overview",
+    "details": [
+      "비밀 버전: 값을 업데이트할 때마다 새 버전이 생성됩니다. 앱은 버전 없이 참조하면 현재 활성 버전을 받습니다.",
+      "Key Vault 참조: App Service 앱 설정에서 `@Microsoft.KeyVault(SecretUri=...)` 형식으로 비밀을 직접 주입합니다.",
+      "시험 패턴: App Service에서 Key Vault 참조로 비밀 주입, 비밀 순환(rotation) 설정, Managed Identity와 Key Vault 연동 절차가 출제됩니다."
+    ],
+    "level": "고급",
+    "related_practices": [
+      "azure-lab-9"
+    ]
+  },
+  {
+    "id": "azure-managed-identity",
+    "certification": "AZ-104",
+    "title": "Managed Identity — 관리형 ID",
+    "summary": "Azure 리소스(VM, App Service 등)에 Entra ID ID를 부여해 자격 증명 없이 다른 Azure 서비스에 인증합니다. 코드에 비밀을 저장할 필요가 없습니다.",
+    "example": "# VM에 System-Assigned MI 활성화\naz vm identity assign --name myVM --resource-group myRG\n# MI에 역할 할당\naz role assignment create \\\n  --assignee $(az vm show --name myVM --query identity.principalId -o tsv) \\\n  --role 'Key Vault Secrets User' \\\n  --scope /subscriptions/.../vaults/myKV",
+    "common_mistake": "System-Assigned MI는 리소스 삭제 시 함께 삭제됩니다. 여러 리소스에서 공유하는 ID가 필요하면 User-Assigned MI를 씁니다.",
+    "keywords": [
+      "managed identity",
+      "system-assigned",
+      "user-assigned",
+      "principal ID",
+      "service principal"
+    ],
+    "source_id": "azure-rbac-overview",
+    "details": [
+      "유형: System-Assigned(리소스에 종속, 1:1), User-Assigned(독립적으로 생성, 여러 리소스에 연결 가능).",
+      "동작 원리: 리소스가 Entra ID에서 토큰을 자동 획득 → 해당 토큰으로 Key Vault, Storage 등에 인증합니다.",
+      "시험 패턴: System vs User-Assigned 선택 시나리오, MI에 RBAC 역할 부여 절차, App Service에서 MI를 통한 Key Vault 접근이 출제됩니다."
+    ],
+    "level": "고급"
+  },
+  {
+    "id": "azure-network-watcher",
+    "certification": "AZ-104",
+    "title": "Network Watcher — 네트워크 진단",
+    "summary": "Azure 네트워크 연결 문제를 진단하는 도구 모음입니다. IP 흐름 확인, 연결 문제 해결, NSG 진단, 패킷 캡처 등을 제공합니다.",
+    "example": "# NSG가 패킷을 허용하는지 확인\naz network watcher test-ip-flow \\\n  --vm myVM \\\n  --direction Inbound \\\n  --protocol TCP \\\n  --local 10.0.0.4:80 \\\n  --remote 0.0.0.0:*",
+    "common_mistake": "Network Watcher는 region별로 활성화해야 합니다. VNet을 생성하면 대부분 자동 활성화되지만, 비활성화된 region에서는 진단 기능이 동작하지 않습니다.",
+    "keywords": [
+      "Network Watcher",
+      "IP flow verify",
+      "connection troubleshoot",
+      "NSG flow log",
+      "packet capture"
+    ],
+    "source_id": "azure-vnet-overview",
+    "details": [
+      "IP 흐름 확인: 특정 VM에서 출발지/목적지 IP·포트로 NSG가 허용/거부를 결정하는 규칙을 찾아줍니다.",
+      "NSG Flow Log: 서브넷·NIC를 통과하는 트래픽의 허용/거부 흐름을 Storage Account에 기록합니다. Traffic Analytics와 연동해 시각화.",
+      "시험 패턴: IP 흐름 확인으로 NSG 규칙 진단, Connection Troubleshoot으로 VM 간 연결 검증, NSG Flow Log 설정이 출제됩니다."
+    ],
+    "level": "중급"
+  },
+  {
+    "id": "azure-move-resource",
+    "certification": "AZ-104",
+    "title": "리소스 이동 — Resource Move",
+    "summary": "리소스를 다른 Resource Group이나 다른 Subscription으로 이동합니다. 이동 중 리소스는 잠기며, 모든 리소스가 이동을 지원하지는 않습니다.",
+    "example": "az resource move \\\n  --destination-group targetRG \\\n  --ids /subscriptions/SUB/resourceGroups/sourceRG/providers/Microsoft.Compute/virtualMachines/myVM",
+    "common_mistake": "이동 후 리소스 ID(ARM ID)가 변경됩니다. 이 ID를 하드코딩한 스크립트·모니터링·Role Assignment는 업데이트가 필요합니다.",
+    "keywords": [
+      "resource move",
+      "RG move",
+      "subscription move",
+      "ARM ID change",
+      "limitations"
+    ],
+    "source_id": "azure-vm-overview",
+    "details": [
+      "이동 전 유효성 검사: `az resource invoke-action --action validate-move`로 이동 가능 여부를 미리 확인합니다.",
+      "이동이 불가한 경우: 특정 리소스 유형, 구독 간 이동 시 서비스별 제한, Key Vault(구독 이동 시 일부 제한) 등.",
+      "시험 패턴: 이동 후 리소스 ID 변경 영향, 이동 불가 리소스 예시, 구독 간 이동 시 추가 조건(Entra ID 테넌트 일치 등)이 출제됩니다."
+    ],
+    "level": "고급"
+  },
+  {
+    "id": "azure-template-deployment",
+    "certification": "AZ-104",
+    "title": "ARM/Bicep — 인프라 코드 배포",
+    "summary": "ARM Template(JSON) 또는 Bicep(DSL)으로 Azure 리소스를 선언적으로 정의하고 반복 가능하게 배포합니다. IaC(Infrastructure as Code)의 표준 방식입니다.",
+    "example": "# Bicep 배포\naz deployment group create \\\n  --resource-group myRG \\\n  --template-file main.bicep \\\n  --parameters environment=prod\n# 구독 레벨 배포\naz deployment sub create --template-file rg.bicep --location koreacentral",
+    "common_mistake": "ARM 배포는 기본적으로 Incremental 모드(기존 리소스 유지, 새 리소스 추가)입니다. Complete 모드는 템플릿에 없는 RG 내 리소스를 삭제하므로 주의가 필요합니다.",
+    "keywords": [
+      "ARM template",
+      "Bicep",
+      "IaC",
+      "incremental",
+      "complete",
+      "deployment scope"
+    ],
+    "source_id": "azure-vm-overview",
+    "details": [
+      "배포 범위: Resource Group(대부분), Subscription(RG 생성 포함), Management Group(Policy/RBAC), Tenant 레벨 중 선택합니다.",
+      "Bicep은 ARM JSON보다 간결한 문법으로 같은 결과를 냅니다. `bicep build`로 ARM JSON으로 컴파일 가능합니다.",
+      "시험 패턴: Incremental vs Complete 모드 차이, 배포 범위별 명령(`deployment group/sub/mg create`), What-If 검증 사용법이 출제됩니다."
+    ],
+    "level": "고급"
+  }
+]

cert_study_app/content/azure/practices.json

@@ -0,0 +1,152 @@
+[
+  {
+    "id": "azure-lab-1",
+    "title": "리소스 그룹 생성",
+    "task_description": "Korea Central 지역에 `myRG`라는 리소스 그룹을 만드세요.",
+    "expected_command": "az group create --name myRG --location koreacentral",
+    "grading_conditions": ["az group create", "--name myRG", "--location koreacentral"],
+    "hint": "`az group create --name <이름> --location <지역>` 형식을 사용합니다.",
+    "explanation": "리소스 그룹은 Azure 리소스를 논리적으로 묶는 컨테이너입니다. 지역은 메타데이터 저장 위치이며 내부 리소스와 달라도 됩니다.",
+    "difficulty": "easy"
+  },
+  {
+    "id": "azure-lab-2",
+    "title": "스토리지 계정 생성 (Standard LRS)",
+    "task_description": "`myRG` 리소스 그룹에 Standard_LRS 중복성을 가진 `mystorageacct` 스토리지 계정을 생성하세요.",
+    "expected_command": "az storage account create --name mystorageacct --resource-group myRG --sku Standard_LRS --kind StorageV2",
+    "grading_conditions": ["az storage account create", "--name mystorageacct", "--resource-group myRG", "--sku Standard_LRS"],
+    "hint": "`az storage account create`에 `--sku`와 `--kind` 옵션을 추가합니다.",
+    "explanation": "StorageV2(범용 v2)는 현재 권장 스토리지 종류입니다. LRS는 단일 데이터센터 내 3복제로 가장 저렴한 중복성입니다.",
+    "difficulty": "easy"
+  },
+  {
+    "id": "azure-lab-3",
+    "title": "가상 네트워크와 서브넷 생성",
+    "task_description": "`myRG`에 주소 공간 `10.0.0.0/16`, 서브넷 `default`(`10.0.0.0/24`)를 가진 VNet `myVNet`을 생성하세요.",
+    "expected_command": "az network vnet create --name myVNet --resource-group myRG --address-prefix 10.0.0.0/16 --subnet-name default --subnet-prefix 10.0.0.0/24",
+    "grading_conditions": ["az network vnet create", "--name myVNet", "--address-prefix 10.0.0.0/16", "--subnet-name default", "--subnet-prefix 10.0.0.0/24"],
+    "hint": "`az network vnet create`에 `--address-prefix`와 `--subnet-name`, `--subnet-prefix`를 함께 지정합니다.",
+    "explanation": "VNet 주소 공간(/16)과 서브넷 범위(/24)는 포함 관계여야 합니다. Azure는 각 서브넷에서 5개 IP를 예약합니다.",
+    "difficulty": "easy"
+  },
+  {
+    "id": "azure-lab-4",
+    "title": "NSG 규칙으로 SSH 허용",
+    "task_description": "NSG `myNSG`에 우선순위 100으로 TCP 포트 22 인바운드를 허용하는 규칙 `allow-ssh`를 추가하세요.",
+    "expected_command": "az network nsg rule create --nsg-name myNSG --resource-group myRG --name allow-ssh --priority 100 --access Allow --protocol Tcp --destination-port-ranges 22",
+    "grading_conditions": ["az network nsg rule create", "--nsg-name myNSG", "--name allow-ssh", "--priority 100", "--access Allow", "--destination-port-ranges 22"],
+    "hint": "`az network nsg rule create`에 `--priority`, `--access`, `--protocol`, `--destination-port-ranges`를 지정합니다.",
+    "explanation": "NSG 규칙은 우선순위 숫자가 낮을수록 먼저 적용됩니다. 100은 기본 규칙(65000~65500)보다 훨씬 높은 우선순위입니다.",
+    "difficulty": "easy"
+  },
+  {
+    "id": "azure-lab-5",
+    "title": "RBAC 역할 할당 (Contributor)",
+    "task_description": "`alice@example.com`에게 `myRG` 리소스 그룹 범위의 `Contributor` 역할을 할당하세요.",
+    "expected_command": "az role assignment create --assignee alice@example.com --role Contributor --scope /subscriptions/SUB_ID/resourceGroups/myRG",
+    "grading_conditions": ["az role assignment create", "--assignee alice@example.com", "--role Contributor", "--scope"],
+    "hint": "`az role assignment create`에 `--assignee`, `--role`, `--scope`를 지정합니다. scope는 리소스 그룹의 전체 ARM ID입니다.",
+    "explanation": "Contributor는 리소스 생성/수정/삭제는 가능하지만 역할 할당은 불가합니다. Owner만 역할 할당 권한을 가집니다.",
+    "difficulty": "medium"
+  },
+  {
+    "id": "azure-lab-6",
+    "title": "리소스 잠금 설정 (CanNotDelete)",
+    "task_description": "`myRG` 리소스 그룹에 `CanNotDelete` 잠금 `prod-lock`을 설정하세요.",
+    "expected_command": "az lock create --name prod-lock --resource-group myRG --lock-type CanNotDelete",
+    "grading_conditions": ["az lock create", "--name prod-lock", "--resource-group myRG", "--lock-type CanNotDelete"],
+    "hint": "`az lock create`에 `--lock-type`으로 `CanNotDelete` 또는 `ReadOnly`를 선택합니다.",
+    "explanation": "CanNotDelete 잠금은 읽기와 수정은 허용하지만 삭제를 차단합니다. Owner라도 잠금을 먼저 해제해야 삭제할 수 있습니다.",
+    "difficulty": "easy"
+  },
+  {
+    "id": "azure-lab-7",
+    "title": "Blob 접근 계층 변경 (Cool)",
+    "task_description": "`mycontainer`의 `report.log` Blob을 Cool 계층으로 변경하세요.",
+    "expected_command": "az storage blob set-tier --account-name mystorageacct --container-name mycontainer --name report.log --tier Cool",
+    "grading_conditions": ["az storage blob set-tier", "--account-name mystorageacct", "--container-name mycontainer", "--name report.log", "--tier Cool"],
+    "hint": "`az storage blob set-tier`에 `--tier`로 Hot/Cool/Cold/Archive를 지정합니다.",
+    "explanation": "Cool 계층은 30일 이상 저장하는 데이터에 적합합니다. 저장 비용은 낮지만 접근 비용이 Hot보다 높습니다.",
+    "difficulty": "easy"
+  },
+  {
+    "id": "azure-lab-8",
+    "title": "VM 백업 활성화",
+    "task_description": "`myVault` Recovery Services Vault에서 `myVM` 가상 머신의 백업을 `DefaultPolicy`로 활성화하세요.",
+    "expected_command": "az backup protection enable-for-vm --vault-name myVault --resource-group myRG --vm myVM --policy-name DefaultPolicy",
+    "grading_conditions": ["az backup protection enable-for-vm", "--vault-name myVault", "--vm myVM", "--policy-name DefaultPolicy"],
+    "hint": "`az backup protection enable-for-vm`에 vault, vm, policy 이름을 지정합니다.",
+    "explanation": "VM 백업 활성화 후 최초 백업은 즉시 트리거하거나 다음 예약 시간까지 기다립니다. Vault와 VM은 같은 region에 있어야 합니다.",
+    "difficulty": "medium"
+  },
+  {
+    "id": "azure-lab-9",
+    "title": "Key Vault 비밀 저장",
+    "task_description": "`myKV` Key Vault에 `db-password`라는 이름으로 `MyP@ss123` 비밀을 저장하세요.",
+    "expected_command": "az keyvault secret set --vault-name myKV --name db-password --value MyP@ss123",
+    "grading_conditions": ["az keyvault secret set", "--vault-name myKV", "--name db-password", "--value"],
+    "hint": "`az keyvault secret set`에 vault 이름, 비밀 이름, 값을 지정합니다.",
+    "explanation": "비밀은 버전 관리됩니다. 같은 이름으로 다시 저장하면 새 버전이 생성되고 이전 버전은 비활성화됩니다.",
+    "difficulty": "easy"
+  },
+  {
+    "id": "azure-lab-10",
+    "title": "VNet 피어링 생성",
+    "task_description": "`VNet1`에서 `VNet2`로 향하는 피어링 `VNet1-to-VNet2`를 생성하세요. (resource group: myRG)",
+    "expected_command": "az network vnet peering create --name VNet1-to-VNet2 --vnet-name VNet1 --remote-vnet VNet2 --resource-group myRG",
+    "grading_conditions": ["az network vnet peering create", "--name VNet1-to-VNet2", "--vnet-name VNet1", "--remote-vnet VNet2"],
+    "hint": "피어링은 양방향을 각각 만들어야 합니다. 이 명령은 VNet1→VNet2 방향입니다.",
+    "explanation": "VNet 피어링은 비전이적(non-transitive)입니다. A↔B, B↔C가 있어도 A에서 C로는 직접 통신 불가이며 A↔C를 별도 생성해야 합니다.",
+    "difficulty": "medium"
+  },
+  {
+    "id": "azure-lab-11",
+    "title": "Private Endpoint 생성 (Blob)",
+    "task_description": "`myVNet`의 `default` 서브넷에 스토리지 계정 `mystorageacct`의 blob 서비스용 Private Endpoint `myPE`를 생성하세요.",
+    "expected_command": "az network private-endpoint create --name myPE --resource-group myRG --vnet-name myVNet --subnet default --private-connection-resource-id /subscriptions/SUB_ID/resourceGroups/myRG/providers/Microsoft.Storage/storageAccounts/mystorageacct --group-ids blob --connection-name myPEConnection",
+    "grading_conditions": ["az network private-endpoint create", "--name myPE", "--vnet-name myVNet", "--group-ids blob"],
+    "hint": "`--private-connection-resource-id`에 스토리지 계정의 전체 ARM ID를 넣고, `--group-ids blob`을 지정합니다.",
+    "explanation": "Private Endpoint는 PaaS 서비스에 VNet 내 사설 IP를 부여합니다. 생성 후 Private DNS Zone 연결이 있어야 DNS 해석이 올바르게 됩니다.",
+    "difficulty": "hard"
+  },
+  {
+    "id": "azure-lab-12",
+    "title": "Azure Bastion 생성",
+    "task_description": "`myVNet`에 Public IP `myBastionIP`를 사용하는 Azure Bastion `myBastion`을 Korea Central에 생성하세요.",
+    "expected_command": "az network bastion create --name myBastion --public-ip-address myBastionIP --resource-group myRG --vnet-name myVNet --location koreacentral",
+    "grading_conditions": ["az network bastion create", "--name myBastion", "--public-ip-address myBastionIP", "--vnet-name myVNet"],
+    "hint": "Bastion 생성 전 VNet에 `AzureBastionSubnet`(/27 이상)이 반드시 있어야 합니다.",
+    "explanation": "Azure Bastion은 VM에 Public IP 없이 포털에서 RDP/SSH 접근을 제공합니다. AzureBastionSubnet 이름은 정확히 일치해야 합니다.",
+    "difficulty": "medium"
+  },
+  {
+    "id": "azure-lab-13",
+    "title": "App Service 웹앱 생성",
+    "task_description": "`myPlan` App Service 플랜을 사용하는 `myWebApp` 웹앱을 Node.js 18 LTS 런타임으로 생성하세요.",
+    "expected_command": "az webapp create --name myWebApp --resource-group myRG --plan myPlan --runtime NODE:18-lts",
+    "grading_conditions": ["az webapp create", "--name myWebApp", "--resource-group myRG", "--plan myPlan", "--runtime"],
+    "hint": "`az webapp create`에 `--plan`과 `--runtime`을 지정합니다. 런타임 목록은 `az webapp list-runtimes`로 확인합니다.",
+    "explanation": "App Service는 런타임 환경과 배포 방법을 유연하게 선택할 수 있는 PaaS입니다. 같은 플랜의 앱들은 컴퓨팅 리소스를 공유합니다.",
+    "difficulty": "easy"
+  },
+  {
+    "id": "azure-lab-14",
+    "title": "배포 슬롯 생성 (staging)",
+    "task_description": "`myWebApp` 웹앱에 `staging` 배포 슬롯을 생성하세요.",
+    "expected_command": "az webapp deployment slot create --name myWebApp --resource-group myRG --slot staging",
+    "grading_conditions": ["az webapp deployment slot create", "--name myWebApp", "--slot staging"],
+    "hint": "`az webapp deployment slot create`에 `--slot`으로 슬롯 이름을 지정합니다. Standard 이상 플랜이 필요합니다.",
+    "explanation": "배포 슬롯은 다운타임 없이 스테이징 버전을 테스트하고 swap으로 즉시 교체하는 데 사용됩니다.",
+    "difficulty": "easy"
+  },
+  {
+    "id": "azure-lab-15",
+    "title": "경보 규칙 생성 (CPU 80%)",
+    "task_description": "`myVM`의 평균 CPU 사용률이 80%를 초과하면 `alice@example.com`으로 알림을 보내는 경보 규칙을 생성하세요.",
+    "expected_command": "az monitor alert create --name highCPU --resource-group myRG --resource myVM --resource-type Microsoft.Compute/virtualMachines --condition avg Percentage CPU > 80 --action email alice@example.com",
+    "grading_conditions": ["az monitor alert create", "--name highCPU", "--condition", "Percentage CPU", "> 80", "--action email alice@example.com"],
+    "hint": "`az monitor alert create`에 `--condition`으로 메트릭 이름과 임계값을, `--action`으로 알림 방법을 지정합니다.",
+    "explanation": "경보는 Action Group 없이는 발생해도 알 수 없습니다. --action email로 간단하게 지정하거나, 별도 Action Group을 생성해 연결합니다.",
+    "difficulty": "medium"
+  }
+]

cert_study_app/content/azure/quizzes.json

@@ -0,0 +1,1058 @@
+[
+  {
+    "id": "azure-q28",
+    "lesson_id": "azure-subscription",
+    "question_type": "multiple_choice",
+    "question": "Azure에서 과금과 리소스 배포의 주요 경계 단위는?",
+    "options": [
+      "Subscription",
+      "Resource Group",
+      "Management Group",
+      "Tenant"
+    ],
+    "answer": "Subscription",
+    "explanation": "Subscription은 Azure 과금, 리소스 할당량, RBAC/Policy 적용의 주요 경계입니다. Resource Group은 Subscription 아래, Management Group은 여러 Subscription을 묶는 상위 계층입니다.",
+    "difficulty": "easy",
+    "source_id": "manual-az104-basic"
+  },
+  {
+    "id": "azure-q29",
+    "lesson_id": "azure-tags",
+    "question_type": "multiple_choice",
+    "question": "Azure Tags의 주된 용도로 가장 맞는 것은?",
+    "options": [
+      "리소스에 key/value 메타데이터를 붙여 비용과 소유자를 분류한다",
+      "리소스 접근 권한을 직접 제어한다",
+      "VM 인스턴스를 자동으로 재시작한다",
+      "NSG 인바운드 규칙을 정의한다"
+    ],
+    "answer": "리소스에 key/value 메타데이터를 붙여 비용과 소유자를 분류한다",
+    "explanation": "Tags는 비용 분석, 소유자 식별, 환경 구분을 위한 메타데이터입니다. 리소스 접근 권한 제어는 RBAC가 담당합니다.",
+    "difficulty": "easy",
+    "source_id": "manual-az104-basic"
+  },
+  {
+    "id": "azure-q30",
+    "lesson_id": "azure-custom-role",
+    "question_type": "multiple_choice",
+    "question": "Azure Custom Role의 `AssignableScopes`를 잘못 설정하면 생기는 문제는?",
+    "options": [
+      "필요한 범위에 역할을 할당할 수 없게 된다",
+      "역할에 정의된 actions이 모두 무시된다",
+      "VM이 자동으로 중지된다",
+      "Blob 접근이 차단된다"
+    ],
+    "answer": "필요한 범위에 역할을 할당할 수 없게 된다",
+    "explanation": "`AssignableScopes`는 이 역할을 할당할 수 있는 범위를 제한합니다. 너무 좁게 설정하면 필요한 subscription이나 resource group에 할당할 수 없습니다.",
+    "difficulty": "medium",
+    "source_id": "azure-rbac-overview"
+  },
+  {
+    "id": "azure-q31",
+    "lesson_id": "azure-lifecycle",
+    "question_type": "multiple_choice",
+    "question": "Azure Storage Lifecycle 관리의 주된 목적은?",
+    "options": [
+      "Blob 접근 빈도에 따라 자동으로 tier를 이동하거나 삭제해 비용을 최적화한다",
+      "VM을 자동으로 백업한다",
+      "NSG 규칙을 주기적으로 갱신한다",
+      "DNS 레코드를 자동 업데이트한다"
+    ],
+    "answer": "Blob 접근 빈도에 따라 자동으로 tier를 이동하거나 삭제해 비용을 최적화한다",
+    "explanation": "Lifecycle 정책은 마지막 수정·접근 이후 경과 일수를 기준으로 Blob을 자동으로 Cool/Archive로 이동하거나 삭제합니다.",
+    "difficulty": "easy",
+    "source_id": "azure-blob-access-tiers"
+  },
+  {
+    "id": "azure-q32",
+    "lesson_id": "azure-files",
+    "question_type": "multiple_choice",
+    "question": "Azure Files와 Blob Storage의 주요 차이로 가장 맞는 것은?",
+    "options": [
+      "Azure Files는 SMB/NFS 파일 공유, Blob은 REST API 기반 개체 저장이다",
+      "두 서비스는 동일한 방식으로 마운트된다",
+      "Blob이 파일 공유에 적합하고 Azure Files가 개체 저장에 적합하다",
+      "Azure Files는 관계형 데이터베이스 서비스다"
+    ],
+    "answer": "Azure Files는 SMB/NFS 파일 공유, Blob은 REST API 기반 개체 저장이다",
+    "explanation": "Azure Files는 네트워크 드라이브처럼 마운트해 사용하고, Blob Storage는 REST API로 비정형 데이터(이미지, 로그, 백업)를 저장합니다.",
+    "difficulty": "easy",
+    "source_id": "azure-storage-account"
+  },
+  {
+    "id": "azure-q33",
+    "lesson_id": "azure-managed-disk",
+    "question_type": "multiple_choice",
+    "question": "Azure VM에서 재시작하면 데이터가 사라질 수 있는 디스크 유형은?",
+    "options": [
+      "Temporary disk",
+      "OS disk",
+      "Premium SSD data disk",
+      "Ultra disk"
+    ],
+    "answer": "Temporary disk",
+    "explanation": "임시 디스크(temporary disk)는 VM 재시작 시 데이터가 유지되지 않습니다. OS disk와 data disk는 영구 저장소로 재시작에도 데이터가 보존됩니다.",
+    "difficulty": "easy",
+    "source_id": "azure-vm-overview"
+  },
+  {
+    "id": "azure-q34",
+    "lesson_id": "azure-autoscale",
+    "question_type": "multiple_choice",
+    "question": "Autoscale이 연결되어 인스턴스 수를 자동으로 조정할 수 있는 리소스는?",
+    "options": [
+      "Virtual Machine Scale Sets (VMSS)",
+      "Recovery Services Vault",
+      "Private DNS Zone",
+      "Activity Log"
+    ],
+    "answer": "Virtual Machine Scale Sets (VMSS)",
+    "explanation": "Autoscale은 VMSS나 App Service Plan 같은 확장 가능한 리소스와 연결됩니다. CPU/메모리 메트릭 조건에 따라 인스턴스 수를 자동으로 늘리거나 줄입니다.",
+    "difficulty": "easy",
+    "source_id": "azure-vmss-overview"
+  },
+  {
+    "id": "azure-q35",
+    "lesson_id": "azure-route-table",
+    "question_type": "multiple_choice",
+    "question": "UDR(User Defined Route, 사용자 정의 경로)의 주된 역할은?",
+    "options": [
+      "Subnet 트래픽의 next hop을 기본 Azure 라우팅 대신 NVA나 다른 경로로 제어한다",
+      "VM의 크기를 자동으로 조정한다",
+      "Blob 데이터를 지역 간 복제한다",
+      "DNS 이름을 IP로 해석한다"
+    ],
+    "answer": "Subnet 트래픽의 next hop을 기본 Azure 라우팅 대신 NVA나 다른 경로로 제어한다",
+    "explanation": "UDR은 기본 Azure 라우팅을 재정의해 방화벽(NVA)이나 특정 장치를 통해 트래픽을 보낼 때 사용합니다. NSG와 역할이 다릅니다.",
+    "difficulty": "medium",
+    "source_id": "azure-vnet-overview"
+  },
+  {
+    "id": "azure-q36",
+    "lesson_id": "azure-private-endpoint",
+    "question_type": "multiple_choice",
+    "question": "Private Endpoint 연결 문제에서 DNS를 함께 확인해야 하는 이유는?",
+    "options": [
+      "Private Endpoint가 private IP를 쓰므로 DNS가 올바른 IP로 해석해야 연결되기 때문이다",
+      "DNS가 Blob 접근 tier를 결정하기 때문이다",
+      "DNS가 NSG 규칙을 적용하기 때문이다",
+      "DNS가 VM 크기를 제어하기 때문이다"
+    ],
+    "answer": "Private Endpoint가 private IP를 쓰므로 DNS가 올바른 IP로 해석해야 연결되기 때문이다",
+    "explanation": "Private Endpoint는 VNet 내부 private IP를 사용합니다. DNS가 해당 서비스를 public IP 대신 올바른 private IP로 해석하지 못하면 연결이 실패합니다.",
+    "difficulty": "medium",
+    "source_id": "azure-private-endpoint"
+  },
+  {
+    "id": "azure-q37",
+    "lesson_id": "azure-monitor-metrics",
+    "question_type": "multiple_choice",
+    "question": "Azure Monitor Metrics와 Logs의 차이로 가장 맞는 것은?",
+    "options": [
+      "Metrics는 수치형 시계열 데이터, Logs는 KQL로 조회하는 구조화 로그 데이터다",
+      "두 서비스 모두 KQL로만 조회한다",
+      "Metrics는 텍스트 로그, Logs는 숫자 값만 저장한다",
+      "Metrics는 백업, Logs는 복구에 사용한다"
+    ],
+    "answer": "Metrics는 수치형 시계열 데이터, Logs는 KQL로 조회하는 구조화 로그 데이터다",
+    "explanation": "Metrics는 CPU%, 네트워크 바이트처럼 숫자 기반 시계열 데이터이고, Logs는 Log Analytics workspace에서 KQL로 조회하는 구조화된 로그 데이터입니다.",
+    "difficulty": "medium",
+    "source_id": "azure-monitor-overview"
+  },
+  {
+    "id": "azure-q38",
+    "lesson_id": "azure-activity-log",
+    "question_type": "multiple_choice",
+    "question": "Azure Activity Log에서 확인하기 가장 적합한 정보는?",
+    "options": [
+      "누가 어떤 리소스를 언제 수정하거나 삭제했는지 관리 이벤트",
+      "VM 내부 애플리케이션 오류 스택 트레이스",
+      "Blob 데이터 접근 내역",
+      "네트워크 패킷의 페이로드"
+    ],
+    "answer": "누가 어떤 리소스를 언제 수정하거나 삭제했는지 관리 이벤트",
+    "explanation": "Activity Log는 subscription 수준의 관리 작업(누가 무엇을 언제 했는지)을 기록합니다. 애플리케이션 내부 오류 로그는 Diagnostic Settings나 Application Insights에서 봅니다.",
+    "difficulty": "easy",
+    "source_id": "azure-monitor-overview"
+  },
+  {
+    "id": "azure-q39",
+    "lesson_id": "azure-restore",
+    "question_type": "multiple_choice",
+    "question": "Recovery Services Vault에서 복구 가능한 시점을 결정하는 것은?",
+    "options": [
+      "Backup Policy의 백업 빈도와 보존 기간",
+      "VM의 크기(size)",
+      "NSG 규칙 수",
+      "VNet 주소 공간"
+    ],
+    "answer": "Backup Policy의 백업 빈도와 보존 기간",
+    "explanation": "복구 지점(recovery point)은 backup policy에서 정의한 일정과 보존 기간에 따라 생성됩니다. 보존 기간이 지난 복구 지점은 자동 삭제됩니다.",
+    "difficulty": "easy",
+    "source_id": "azure-recovery-services-vault"
+  },
+  {
+    "id": "azure-q40",
+    "lesson_id": "azure-app-service-plan",
+    "question_type": "multiple_choice",
+    "question": "App Service Plan이 Web App과의 관계에서 정의하는 것은?",
+    "options": [
+      "Web App이 사용할 컴퓨팅 리소스와 가격 티어",
+      "Web App의 도메인 이름",
+      "Web App의 데이터베이스 스키마",
+      "Web App의 사용자 인증 방식"
+    ],
+    "answer": "Web App이 사용할 컴퓨팅 리소스와 가격 티어",
+    "explanation": "App Service Plan은 CPU, 메모리, 인스턴스 수, 가격 티어를 정의합니다. 여러 Web App이 하나의 Plan을 공유할 수 있으며, 스케일 설정은 Plan 수준에서 합니다.",
+    "difficulty": "easy",
+    "source_id": "azure-vm-overview"
+  },
+  {
+    "id": "azure-q41",
+    "lesson_id": "azure-container-registry",
+    "question_type": "multiple_choice",
+    "question": "Azure Container Registry(ACR)의 주된 역할은?",
+    "options": [
+      "컨테이너 이미지를 저장하고 관리하는 프라이빗 레지스트리",
+      "컨테이너를 직접 실행하는 서버리스 서비스",
+      "VM을 컨테이너로 변환하는 도구",
+      "Kubernetes 클러스터를 관리하는 서비스"
+    ],
+    "answer": "컨테이너 이미지를 저장하고 관리하는 프라이빗 레지스트리",
+    "explanation": "ACR은 Docker Hub 같은 이미지 저장소입니다. 이미지 실행은 ACI, AKS, App Service가 담당하고 ACR은 이미지 저장/배포에 특화됩니다.",
+    "difficulty": "easy",
+    "source_id": "azure-vm-overview"
+  },
+  {
+    "id": "azure-q42",
+    "lesson_id": "azure-cost-management",
+    "question_type": "multiple_choice",
+    "question": "Azure Tags가 비용 관리에서 도움을 주는 방식은?",
+    "options": [
+      "리소스를 환경·팀·프로젝트별로 분류해 Cost Management에서 필터링을 쉽게 해준다",
+      "불필요한 리소스를 자동으로 삭제해 비용을 줄인다",
+      "VM을 자동으로 스케일다운해 절약한다",
+      "Blob tier를 자동으로 낮춰 절약한다"
+    ],
+    "answer": "리소스를 환경·팀·프로젝트별로 분류해 Cost Management에서 필터링을 쉽게 해준다",
+    "explanation": "Tags 자체는 비용을 줄이지 않지만, Cost Management에서 tag별로 필터링하면 부서/프로젝트별 지출을 파악할 수 있습니다.",
+    "difficulty": "easy",
+    "source_id": "manual-az104-basic"
+  },
+  {
+    "id": "azure-q43",
+    "lesson_id": "azure-app-service",
+    "question_type": "multiple_choice",
+    "question": "Azure App Service의 특징으로 가장 맞는 것은?",
+    "options": [
+      "VM을 직접 관리하지 않고 웹앱과 API를 배포하는 PaaS 서비스",
+      "OS와 미들웨어를 직접 관리하는 IaaS 서비스",
+      "컨테이너 이미지를 저장하는 레지스트리",
+      "관계형 데이터베이스 호스팅 서비스"
+    ],
+    "answer": "VM을 직접 관리하지 않고 웹앱과 API를 배포하는 PaaS 서비스",
+    "explanation": "App Service는 인프라 관리 없이 코드를 배포하는 PaaS입니다. OS 패치, 서버 관리는 Azure가 담당합니다.",
+    "difficulty": "easy",
+    "source_id": "azure-app-service-overview"
+  },
+  {
+    "id": "azure-q44",
+    "lesson_id": "azure-aci",
+    "question_type": "multiple_choice",
+    "question": "Azure Container Instances(ACI)가 AKS와 비교해 가진 주요 특징은?",
+    "options": [
+      "클러스터 관리 없이 컨테이너를 즉시 실행할 수 있는 서버리스 방식이다",
+      "대규모 마이크로서비스 오케스트레이션에 최적화됐다",
+      "VM Scale Set과 동일한 서비스다",
+      "컨테이너 이미지를 저장하는 레지스트리다"
+    ],
+    "answer": "클러스터 관리 없이 컨테이너를 즉시 실행할 수 있는 서버리스 방식이다",
+    "explanation": "ACI는 클러스터 운영 없이 간단한 컨테이너를 빠르게 실행하는 서버리스 방식입니다. 복잡한 마이크로서비스 오케스트레이션은 AKS가 적합합니다.",
+    "difficulty": "easy",
+    "source_id": "azure-container-instances"
+  },
+  {
+    "id": "azure-q45",
+    "lesson_id": "azure-keyvault-secret",
+    "question_type": "multiple_choice",
+    "question": "Key Vault Secret의 주된 사용 목적은?",
+    "options": [
+      "DB password, API 키 같은 민감한 값을 코드나 설정 파일 대신 안전하게 저장한다",
+      "VM 디스크를 암호화한다",
+      "RBAC 역할 정의를 저장한다",
+      "NSG 보안 규칙을 정의한다"
+    ],
+    "answer": "DB password, API 키 같은 민감한 값을 코드나 설정 파일 대신 안전하게 저장한다",
+    "explanation": "Key Vault Secret은 비밀값을 코드나 Git에 넣지 않고 중앙에서 안전하게 관리합니다. Managed Identity와 결합하면 코드에 비밀값이 전혀 없어도 됩니다.",
+    "difficulty": "easy",
+    "source_id": "azure-key-vault-overview"
+  },
+  {
+    "id": "azure-q46",
+    "lesson_id": "azure-network-watcher",
+    "question_type": "multiple_choice",
+    "question": "Azure Network Watcher의 주된 역할은?",
+    "options": [
+      "네트워크 연결 진단, 흐름 로그, 패킷 캡처 같은 네트워크 모니터링 도구를 제공한다",
+      "VM을 자동으로 시작하고 중지한다",
+      "Blob 수명주기를 자동 관리한다",
+      "NSG 규칙을 자동으로 생성한다"
+    ],
+    "answer": "네트워크 연결 진단, 흐름 로그, 패킷 캡처 같은 네트워크 모니터링 도구를 제공한다",
+    "explanation": "Network Watcher는 Connection troubleshoot, NSG flow log, IP flow verify, packet capture 같은 진단 도구를 제공합니다. NSG 규칙만으로 파악하기 어려운 실제 트래픽 경로를 확인할 수 있습니다.",
+    "difficulty": "easy",
+    "source_id": "azure-vnet-overview"
+  },
+  {
+    "id": "azure-q47",
+    "lesson_id": "azure-move-resource",
+    "question_type": "multiple_choice",
+    "question": "Azure 리소스 이동(Move)에서 주의해야 할 사항으로 가장 맞는 것은?",
+    "options": [
+      "모든 리소스 유형이 이동을 지원하지 않으며 종속 리소스도 함께 고려해야 한다",
+      "이동 중에도 서비스가 항상 정상 동작한다",
+      "이동하면 자동으로 새 subscription 과금으로 전환된다",
+      "Resource Lock이 있어도 항상 이동 가능하다"
+    ],
+    "answer": "모든 리소스 유형이 이동을 지원하지 않으며 종속 리소스도 함께 고려해야 한다",
+    "explanation": "일부 리소스 유형은 이동을 지원하지 않습니다. NIC, 디스크 같은 종속 리소스를 함께 이동해야 하는 경우가 많으며, 이동 중에는 일시적으로 잠금 상태가 됩니다.",
+    "difficulty": "medium",
+    "source_id": "manual-az104-basic"
+  },
+  {
+    "id": "azure-q48",
+    "lesson_id": "azure-vmss",
+    "question_type": "multiple_choice",
+    "question": "VMSS와 Availability Set의 가장 큰 차이점은?",
+    "options": [
+      "VMSS는 부하에 따라 VM 수를 자동 조정한다",
+      "Availability Set은 SLA가 더 높다",
+      "VMSS는 단일 VM만 지원한다",
+      "Availability Set이 더 저렴하다"
+    ],
+    "answer": "VMSS는 부하에 따라 VM 수를 자동 조정한다",
+    "explanation": "VMSS는 Autoscale로 인스턴스 수를 동적으로 조절합니다. Availability Set은 HA를 위한 배치 구성이며 자동 확장 기능이 없습니다.",
+    "source_id": "azure-vmss-overview"
+  },
+  {
+    "id": "azure-q49",
+    "lesson_id": "azure-dns",
+    "question_type": "multiple_choice",
+    "question": "Azure DNS에서 Public Zone 생성 후 반드시 해야 하는 추가 작업은?",
+    "options": [
+      "도메인 등록 기관에서 NS 레코드를 Azure로 위임",
+      "VNet에 DNS Zone 링크 연결",
+      "Private Endpoint 생성",
+      "SSL 인증서 바인딩"
+    ],
+    "answer": "도메인 등록 기관에서 NS 레코드를 Azure로 위임",
+    "explanation": "Azure DNS는 호스팅 서비스이므로 도메인 등록 기관에서 Azure가 제공한 NS 레코드 4개를 설정해 위임해야 실제로 동작합니다.",
+    "source_id": "azure-dns-overview"
+  },
+  {
+    "id": "azure-q50",
+    "lesson_id": "azure-recovery-vault",
+    "question_type": "multiple_choice",
+    "question": "Recovery Services Vault의 Soft Delete 기능이 하는 역할은?",
+    "options": [
+      "삭제된 백업 데이터를 일정 기간 복원 가능하게 유지한다",
+      "VM을 자동으로 백업한다",
+      "백업 정책을 자동 적용한다",
+      "다른 지역에 데이터를 복제한다"
+    ],
+    "answer": "삭제된 백업 데이터를 일정 기간 복원 가능하게 유지한다",
+    "explanation": "Soft Delete는 백업 항목 삭제 후 최대 14일간 데이터를 보호 상태로 유지해 실수나 랜섬웨어로 인한 삭제에서 복원할 수 있게 합니다.",
+    "source_id": "azure-recovery-services-vault"
+  },
+  {
+    "id": "azure-q51",
+    "lesson_id": "azure-rg",
+    "question_type": "command",
+    "question": "`Korea Central` 지역에 `myRG` 리소스 그룹을 생성하는 Azure CLI 명령어를 입력하세요.",
+    "options": [],
+    "answer": "az group create --name myRG --location koreacentral",
+    "explanation": "`az group create --name <이름> --location <지역>`. 지역 이름은 공백 없이 소문자로 씁니다 (koreacentral, eastus 등).",
+    "difficulty": "easy",
+    "source_id": "manual-az104-basic"
+  },
+  {
+    "id": "azure-q52",
+    "lesson_id": "azure-storage",
+    "question_type": "multiple_choice",
+    "question": "Azure Storage 계정의 기본 중복성 SKU로 동일 데이터센터 내 3개 복제본을 유지하는 것은?",
+    "options": ["LRS", "ZRS", "GRS", "GZRS"],
+    "answer": "LRS",
+    "explanation": "LRS(Locally Redundant Storage)는 단일 데이터센터 내 3개 복제본으로 가장 저렴하지만 데이터센터 전체 장애에 취약합니다.",
+    "difficulty": "easy",
+    "source_id": "azure-storage-account"
+  },
+  {
+    "id": "azure-q53",
+    "lesson_id": "azure-vnet",
+    "question_type": "multiple_choice",
+    "question": "Azure VNet에서 서브넷마다 예약되어 사용할 수 없는 IP 주소 수는?",
+    "options": ["5개", "3개", "2개", "1개"],
+    "answer": "5개",
+    "explanation": "Azure는 서브넷마다 네트워크 ��소, 게이트웨이, DHCP 2개, 브로드캐스트 등 5개 IP를 예약합니다. /28 서브넷이면 16-5=11개만 사용 가능합니다.",
+    "difficulty": "medium",
+    "source_id": "manual-az104-basic"
+  },
+  {
+    "id": "azure-q54",
+    "lesson_id": "azure-rbac",
+    "question_type": "multiple_choice",
+    "question": "Owner, Contributor, Reader 중 역할 할당(RBAC 부여) 권한을 가진 것은?",
+    "options": ["Owner만", "Owner와 Contributor", "세 역할 모두", "Reader만"],
+    "answer": "Owner만",
+    "explanation": "Owner만 역할 할당 권한을 가집니다. Contributor는 리소스 생성/수정/삭제는 되지만 다른 사람에게 역할을 줄 수 없고, Reader는 조회만 가능합니다.",
+    "difficulty": "easy",
+    "source_id": "azure-rbac-overview"
+  },
+  {
+    "id": "azure-q55",
+    "lesson_id": "azure-policy",
+    "question_type": "multiple_choice",
+    "question": "Azure Policy effect 중 규정에 맞지 않는 리소스 배포 자체를 차단하는 것은?",
+    "options": ["Deny", "Audit", "Append", "Modify"],
+    "answer": "Deny",
+    "explanation": "Deny는 비준수 리소스 생성을 막습니다. Audit는 허용하되 로그만 남기고, Append는 필드를 추가하며, Modify는 태그 같은 속성을 수정합니다.",
+    "difficulty": "easy",
+    "source_id": "azure-policy-overview"
+  },
+  {
+    "id": "azure-q56",
+    "lesson_id": "azure-vm",
+    "question_type": "command",
+    "question": "`myRG` 리소스 그룹에 Ubuntu 22.04 LTS 이미지로 `myVM`을 생성하는 최소한의 Azure CLI 명령어를 입력하세요.",
+    "options": [],
+    "answer": "az vm create --resource-group myRG --name myVM --image Ubuntu2204",
+    "explanation": "`az vm create --resource-group <RG> --name <이름> --image <이미지>`. 이미지 이름은 `az vm image list` 로 확인합니다.",
+    "difficulty": "medium",
+    "source_id": "azure-vm-overview"
+  },
+  {
+    "id": "azure-q57",
+    "lesson_id": "azure-vmss",
+    "question_type": "multiple_choice",
+    "question": "VMSS에서 인스턴스를 최소 2개 최대 10개로 유지하고 CPU 75% 초과 시 늘리는 규칙은 어디에 정의하는가?",
+    "options": ["Autoscale 설정", "NSG 규칙", "Backup Policy", "Alert Rule"],
+    "answer": "Autoscale 설정",
+    "explanation": "VMSS의 인스턴스 수 자동 조정은 Autoscale 설정에서 메트릭 조건(CPU %), 최소/최대 인스턴스, 증감 단위를 정의합니다.",
+    "difficulty": "easy",
+    "source_id": "azure-vmss-overview"
+  },
+  {
+    "id": "azure-q58",
+    "lesson_id": "azure-nsg",
+    "question_type": "command",
+    "question": "NSG `myNSG`에 우선순위 200으로 TCP 443 인바운드를 허용하는 규칙 `allow-https`를 추가하는 명령어를 입력하세요.",
+    "options": [],
+    "answer": "az network nsg rule create --nsg-name myNSG --resource-group myRG --name allow-https --priority 200 --access Allow --protocol Tcp --destination-port-ranges 443",
+    "explanation": "`az network nsg rule create`에 `--nsg-name`, `--priority`, `--access Allow`, `--protocol Tcp`, `--destination-port-ranges`를 지정합니다.",
+    "difficulty": "medium",
+    "source_id": "manual-az104-basic"
+  },
+  {
+    "id": "azure-q59",
+    "lesson_id": "azure-app-gateway",
+    "question_type": "multiple_choice",
+    "question": "Application Gateway와 Azure Load Balancer의 주요 차이는?",
+    "options": [
+      "App Gateway는 L7(HTTP/HTTPS) 라우팅, Load Balancer는 L4(TCP/UDP) 분산이다",
+      "두 서비스 모두 L4만 지원한다",
+      "Load Balancer가 URL 경로 기반 라우팅을 지원한다",
+      "App Gateway는 VM을 직접 관리한다"
+    ],
+    "answer": "App Gateway는 L7(HTTP/HTTPS) 라우팅, Load Balancer는 L4(TCP/UDP) 분산이다",
+    "explanation": "App Gateway는 URL 경로, 호스트 헤더 기반 L7 라우팅과 WAF를 제공합니다. Load Balancer는 TCP/UDP 레벨 L4 분산으로 더 단순하고 빠릅니다.",
+    "difficulty": "medium",
+    "source_id": "azure-vnet-overview"
+  },
+  {
+    "id": "azure-q60",
+    "lesson_id": "azure-dns",
+    "question_type": "multiple_choice",
+    "question": "Azure Private DNS Zone과 Public DNS Zone의 차이는?",
+    "options": [
+      "Private Zone은 VNet 내부에서만 해석되고, Public Zone은 인터넷에서 조회된다",
+      "Private Zone은 더 빠른 TTL을 가진다",
+      "Public Zone은 VNet에 링크해야만 동작한다",
+      "두 Zone 모두 동일하게 동작한다"
+    ],
+    "answer": "Private Zone은 VNet 내부에서만 해석되고, Public Zone은 인터넷에서 조회된다",
+    "explanation": "Private DNS Zone은 VNet 링크를 통해 해당 VNet 내부 리소스에만 DNS 이름을 제공합니다. Public Zone은 인터넷 전체에서 조회 가능합니다.",
+    "difficulty": "easy",
+    "source_id": "azure-dns-overview"
+  },
+  {
+    "id": "azure-q61",
+    "lesson_id": "azure-blob-tier",
+    "question_type": "multiple_choice",
+    "question": "Archive tier에 있는 Blob에 즉시 접근하려면 먼저 해야 하는 작업은?",
+    "options": [
+      "rehydration(리하이드레이션)으로 Hot 또는 Cool로 이동",
+      "스토리지 계정을 재생성",
+      "Blob을 삭제 후 다시 업로드",
+      "SAS 토큰을 새로 발급"
+    ],
+    "answer": "rehydration(리하이드레이션)으로 Hot 또는 Cool로 이동",
+    "explanation": "Archive tier의 Blob은 오프라인 상태라 직접 읽을 수 없습니다. Hot/Cool로 rehydration 후 접근 가능하며, 표준 우선순위로 수 시간이 걸립니다.",
+    "difficulty": "medium",
+    "source_id": "azure-blob-access-tiers"
+  },
+  {
+    "id": "azure-q62",
+    "lesson_id": "azure-log-analytics",
+    "question_type": "multiple_choice",
+    "question": "Log Analytics workspace에서 쿼리 언어로 사용하는 것은?",
+    "options": ["KQL (Kusto Query Language)", "SQL", "Bash", "PowerShell"],
+    "answer": "KQL (Kusto Query Language)",
+    "explanation": "Azure Log Analytics는 KQL(Kusto Query Language)로 로그를 조회합니다. `| where`, `| summarize`, `| project` 같은 파이프라인 문법을 사용합니다.",
+    "difficulty": "easy",
+    "source_id": "azure-monitor-overview"
+  },
+  {
+    "id": "azure-q63",
+    "lesson_id": "azure-entra-id",
+    "question_type": "multiple_choice",
+    "question": "Microsoft Entra ID와 온프레미스 Active Directory의 가장 큰 차이점은?",
+    "options": [
+      "Entra ID는 클라우드 기반 ID 서비스로 OAuth/OIDC를 지원, AD는 Kerberos/LDAP 기반이다",
+      "두 서비스 모두 Kerberos만 사용한다",
+      "AD는 클라우드 전용이다",
+      "Entra ID는 그룹 정책을 직접 적용할 수 있다"
+    ],
+    "answer": "Entra ID는 클라우드 기반 ID 서비스로 OAuth/OIDC를 지원, AD는 Kerberos/LDAP 기반이다",
+    "explanation": "Entra ID는 SaaS/클라우드 앱 인증에 OAuth2, OIDC, SAML을 사용합니다. 온프레미스 AD는 Kerberos/LDAP 기반으로 도메인 조인, 그룹 정책을 지원합니다.",
+    "difficulty": "medium",
+    "source_id": "azure-entra-id-overview"
+  },
+  {
+    "id": "azure-q64",
+    "lesson_id": "azure-management-group",
+    "question_type": "multiple_choice",
+    "question": "Management Group 계층 구조에서 Policy와 RBAC 상속 방향은?",
+    "options": [
+      "상위에서 하위로 상속 (Management Group → Subscription → Resource Group → Resource)",
+      "하위에서 상위로 상속",
+      "동일 레벨 간에만 상속",
+      "상속 없이 각 레벨에 독립 적용"
+    ],
+    "answer": "상위에서 하위로 상속 (Management Group → Subscription → Resource Group → Resource)",
+    "explanation": "Policy와 RBAC는 계층 상위에서 하위로 상속됩니다. Management Group에 정책을 적용하면 하위의 모든 Subscription과 Resource Group에 적용됩니다.",
+    "difficulty": "easy",
+    "source_id": "azure-management-group-overview"
+  },
+  {
+    "id": "azure-q65",
+    "lesson_id": "azure-resource-lock",
+    "question_type": "multiple_choice",
+    "question": "ReadOnly Lock이 걸린 리소스에서 할 수 없는 작업은?",
+    "options": [
+      "설정 수정 및 삭제 모두 불가",
+      "삭제만 불가, 수정은 가능",
+      "읽기만 불가",
+      "배포만 불가"
+    ],
+    "answer": "설정 수정 및 삭제 모두 불가",
+    "explanation": "ReadOnly Lock은 읽기만 허용하고 수정·삭제를 모두 차단합니다. CanNotDelete Lock은 수정은 허용하지만 삭제만 차단합니다.",
+    "difficulty": "medium",
+    "source_id": "manual-az104-basic"
+  },
+  {
+    "id": "azure-q66",
+    "lesson_id": "azure-tags",
+    "question_type": "command",
+    "question": "`myVM` VM에 `env=prod` 태그를 추가하는 Azure CLI 명령어를 입력하세요.",
+    "options": [],
+    "answer": "az resource tag --tags env=prod --resource-group myRG --name myVM --resource-type Microsoft.Compute/virtualMachines",
+    "explanation": "`az resource tag --tags key=value`로 리소스에 태그를 추가합니다. `--resource-type`은 전체 provider 경로를 써야 합니다.",
+    "difficulty": "hard",
+    "source_id": "manual-az104-basic"
+  },
+  {
+    "id": "azure-q67",
+    "lesson_id": "azure-custom-role",
+    "question_type": "multiple_choice",
+    "question": "Custom Role 생성 시 `NotActions`의 역할은?",
+    "options": [
+      "Actions에서 허용된 작업 중 특정 작업을 제외한다",
+      "모든 작업을 차단한다",
+      "Actions에 없는 작업을 추가한다",
+      "역할을 할당할 수 없게 만든다"
+    ],
+    "answer": "Actions에서 허용된 작업 중 특정 작업을 제외한다",
+    "explanation": "NotActions는 Actions 와일드카드로 허용된 작업에서 특정 작업을 뺄 때 사용합니다. 예: `Actions: [\"*\"]`, `NotActions: [\"Microsoft.Authorization/*/Delete\"]`.",
+    "difficulty": "medium",
+    "source_id": "azure-rbac-overview"
+  },
+  {
+    "id": "azure-q68",
+    "lesson_id": "azure-sas",
+    "question_type": "multiple_choice",
+    "question": "SAS(Shared Access Signature) 토큰에서 반드시 지정해야 하는 보안 요소 2가지는?",
+    "options": [
+      "만료 시간(se)과 허용 권한(sp)",
+      "IP 주소와 컨테이너 이름",
+      "스토리지 계정 이름과 구독 ID",
+      "리소스 그룹과 지역"
+    ],
+    "answer": "만료 시간(se)과 허용 권한(sp)",
+    "explanation": "SAS에서 `se`(signed expiry)는 유효 기간, `sp`(signed permission)는 r(read)/w(write)/d(delete) 등 허용 작업을 제한합니다. 유효 기간 없이 발급하면 보안 위험이 큽니다.",
+    "difficulty": "medium",
+    "source_id": "azure-storage-account"
+  },
+  {
+    "id": "azure-q69",
+    "lesson_id": "azure-storage-redundancy",
+    "question_type": "multiple_choice",
+    "question": "재해복구를 위해 지역 간 복제가 필요할 때 선택해야 하는 중복성 옵션은?",
+    "options": ["GRS 또는 GZRS", "LRS", "ZRS", "Premium LRS"],
+    "answer": "GRS 또는 GZRS",
+    "explanation": "GRS(Geo-Redundant Storage)와 GZRS는 수백 km 떨어진 페어 지역에 데이터를 복제해 지역 전체 재해에 대비합니다. LRS/ZRS는 단일 지역 내에서만 복제합니다.",
+    "difficulty": "easy",
+    "source_id": "azure-storage-account"
+  },
+  {
+    "id": "azure-q70",
+    "lesson_id": "azure-lifecycle",
+    "question_type": "multiple_choice",
+    "question": "Lifecycle 정책에서 마지막 수정 후 30일 뒤 Cool로, 90일 뒤 Archive로 이동하도록 설정하는 기준 값은?",
+    "options": [
+      "daysAfterModificationGreaterThan",
+      "daysAfterCreationGreaterThan",
+      "daysAfterLastAccessTimeGreaterThan",
+      "daysUntilExpiration"
+    ],
+    "answer": "daysAfterModificationGreaterThan",
+    "explanation": "Lifecycle 정책의 조건 필드 `daysAfterModificationGreaterThan: 30`과 `90`으로 단계적 tier 이동을 설정합니다. 접근 시간 기반은 `daysAfterLastAccessTimeGreaterThan`입니다.",
+    "difficulty": "medium",
+    "source_id": "azure-blob-access-tiers"
+  },
+  {
+    "id": "azure-q71",
+    "lesson_id": "azure-files",
+    "question_type": "command",
+    "question": "`myshare` Azure 파일 공유를 Linux에서 `/mnt/azfiles`에 마운트하는 프로토콜과 마운트 명령어 시작 부분을 입력하세요.",
+    "options": [],
+    "answer": "mount -t cifs",
+    "explanation": "Azure Files는 SMB 프로토콜(CIFS)로 Linux에 마운트합니다: `mount -t cifs //<스토리지>.file.core.windows.net/<공유명> /mnt/azfiles -o ...`",
+    "difficulty": "medium",
+    "source_id": "azure-storage-account"
+  },
+  {
+    "id": "azure-q72",
+    "lesson_id": "azure-managed-disk",
+    "question_type": "multiple_choice",
+    "question": "VM에 데이터 디스크를 추가할 때 Premium SSD와 Standard HDD의 선택 기준으로 맞는 것은?",
+    "options": [
+      "I/O 집약적 DB 워크로드는 Premium SSD, 로그 백업 보관은 Standard HDD",
+      "Standard HDD가 모든 경우에 더 빠르다",
+      "Premium SSD는 OS 디스크에만 사용 가능하다",
+      "데이터 디스크에는 SSD를 사용할 수 없다"
+    ],
+    "answer": "I/O 집약적 DB 워크로드는 Premium SSD, 로그 백업 보관은 Standard HDD",
+    "explanation": "Premium SSD는 낮은 지연시간과 높은 IOPS로 DB나 웹서버 스토리지에 적합합니다. Standard HDD는 접근 빈도가 낮은 백업, 아카이브에 비용 효율적입니다.",
+    "difficulty": "easy",
+    "source_id": "azure-vm-overview"
+  },
+  {
+    "id": "azure-q73",
+    "lesson_id": "azure-availability-set",
+    "question_type": "multiple_choice",
+    "question": "Availability Set의 Fault Domain과 Update Domain의 차이는?",
+    "options": [
+      "Fault Domain은 전원/네트워크 공유 그룹, Update Domain은 OS 패치 순서 그룹이다",
+      "두 도메인 모두 동일한 역할이다",
+      "Update Domain은 지역 간 분산을 의미한다",
+      "Fault Domain은 소프트웨어 업데이트 순서를 제어한다"
+    ],
+    "answer": "Fault Domain은 전원/네트워크 공유 그룹, Update Domain은 OS 패치 순서 그룹이다",
+    "explanation": "Fault Domain은 물리적 전원과 네트워크를 공유하는 서버 랙 그룹입니다. Update Domain은 OS 패치 재시작 시 동시에 내려가지 않도록 분리한 논리 그룹입니다.",
+    "difficulty": "medium",
+    "source_id": "azure-vm-overview"
+  },
+  {
+    "id": "azure-q74",
+    "lesson_id": "azure-autoscale",
+    "question_type": "multiple_choice",
+    "question": "Autoscale 규칙에서 scale-in 시 주의해야 하는 설정은?",
+    "options": [
+      "scale-in은 minimum 인스턴스 수 아래로는 줄어들지 않는다",
+      "scale-in은 maximum 인스턴스까지만 줄어든다",
+      "scale-in과 scale-out이 동시에 트리거될 수 있다",
+      "scale-in은 CPU 100%일 때만 작동한다"
+    ],
+    "answer": "scale-in은 minimum 인스턴스 수 아래로는 줄어들지 않는다",
+    "explanation": "Autoscale은 minimum/maximum 인스턴스 수를 설정합니다. scale-in 규칙이 트리거돼도 minimum 아래로 줄어들지 않아 항상 최소한의 용량을 보장합니다.",
+    "difficulty": "easy",
+    "source_id": "azure-vmss-overview"
+  },
+  {
+    "id": "azure-q75",
+    "lesson_id": "azure-vnet-peering",
+    "question_type": "multiple_choice",
+    "question": "VNet Peering이 비전이적(non-transitive)이라는 의미는?",
+    "options": [
+      "A↔B, B↔C 피어링이 있어도 A↔C는 직접 통신 불가",
+      "피어링된 VNet끼리는 항상 라우팅이 자동으로 된다",
+      "피어링은 동일 지역에서만 가능하다",
+      "A에서 B를 통해 C로 트래픽이 자동 전달된다"
+    ],
+    "answer": "A↔B, B↔C 피어링이 있어도 A↔C는 직접 통신 불가",
+    "explanation": "VNet Peering은 비전이적입니다. A-B, B-C가 피어링되어도 A-C 트래픽은 차단됩니다. A-C 통신이 필요하면 별도의 A-C 피어링을 만들거나 Hub-Spoke + VPN Gateway를 씁니다.",
+    "difficulty": "medium",
+    "source_id": "azure-vnet-overview"
+  },
+  {
+    "id": "azure-q76",
+    "lesson_id": "azure-route-table",
+    "question_type": "command",
+    "question": "`myRouteTable`을 `myRG`에 생성하는 CLI 명령어를 입력하세요.",
+    "options": [],
+    "answer": "az network route-table create --name myRouteTable --resource-group myRG",
+    "explanation": "`az network route-table create`로 Route Table을 만들고, `az network route-table route create`로 경로를 추가한 뒤 서브넷에 연결합니다.",
+    "difficulty": "easy",
+    "source_id": "azure-vnet-overview"
+  },
+  {
+    "id": "azure-q77",
+    "lesson_id": "azure-private-endpoint",
+    "question_type": "multiple_choice",
+    "question": "Private Endpoint 생성 후 VNet 내부에서 서비스 이름이 public IP로 해석된다면 원인으로 가장 맞는 것은?",
+    "options": [
+      "Private DNS Zone이 VNet에 링크되지 않았거나 A 레코드가 없다",
+      "NSG 규칙이 잘못됐다",
+      "Subnet 주소 범위가 부족하다",
+      "Private Endpoint가 승인되지 않았다"
+    ],
+    "answer": "Private DNS Zone이 VNet에 링크되지 않았거나 A 레코드가 없다",
+    "explanation": "Private Endpoint는 private IP가 생기지만, DNS가 여전히 public IP를 반환하면 연결이 공개 인터넷을 통하게 됩니다. Private DNS Zone 링크와 A 레코드를 반드시 확인해야 합니다.",
+    "difficulty": "hard",
+    "source_id": "azure-private-endpoint"
+  },
+  {
+    "id": "azure-q78",
+    "lesson_id": "azure-load-balancer-probe",
+    "question_type": "multiple_choice",
+    "question": "Azure Load Balancer의 Health Probe 실패 시 어떤 동작이 일어나는가?",
+    "options": [
+      "해당 백엔드 인스턴스로의 트래픽 전달을 중단한다",
+      "백엔드 인스턴스를 자동으로 재시작한다",
+      "전체 Load Balancer를 중지한다",
+      "새 인스턴스를 자동 추가한다"
+    ],
+    "answer": "해당 백엔드 인스턴스로의 트래픽 전달을 중단한다",
+    "explanation": "Health Probe가 설정된 횟수 이상 실패하면 Load Balancer는 해당 인스턴스를 unhealthy로 표시하고 트래픽 전달에서 제외합니다. 다시 성공하면 자동 복귀합니다.",
+    "difficulty": "easy",
+    "source_id": "azure-vnet-overview"
+  },
+  {
+    "id": "azure-q79",
+    "lesson_id": "azure-private-dns",
+    "question_type": "multiple_choice",
+    "question": "Private DNS Zone을 VNet에 `enableAutoRegistration: true`로 연결하면?",
+    "options": [
+      "해당 VNet의 VM이 생성/삭제될 때 A 레코드가 자동으로 등록/삭제된다",
+      "DNS Zone이 자동으로 백업된다",
+      "외부 인터넷에서도 조회할 수 있게 된다",
+      "Private Endpoint가 자동으로 생성된다"
+    ],
+    "answer": "해당 VNet의 VM이 생성/삭제될 때 A 레코드가 자동으로 등록/삭제된다",
+    "explanation": "Auto-registration 링크는 VNet 내 VM의 프라이빗 IP를 해당 DNS Zone에 자동 등록합니다. 수동으로 A 레코드를 관리할 필요가 없어집니다.",
+    "difficulty": "medium",
+    "source_id": "azure-dns-overview"
+  },
+  {
+    "id": "azure-q80",
+    "lesson_id": "azure-monitor-metrics",
+    "question_type": "multiple_choice",
+    "question": "Azure Monitor에서 특정 메트릭이 임계값을 초과할 때 이메일을 보내려면 무엇이 필요한가?",
+    "options": [
+      "Alert Rule + Action Group",
+      "Diagnostic Settings만",
+      "Log Analytics Workspace만",
+      "NSG Flow Log"
+    ],
+    "answer": "Alert Rule + Action Group",
+    "explanation": "Alert Rule은 조건(임계값)을 정의하고, Action Group은 이메일·SMS·웹훅 등 알림 방법을 정의합니다. 두 가지가 연결되���야 실제로 알림이 발송됩니다.",
+    "difficulty": "easy",
+    "source_id": "azure-monitor-overview"
+  },
+  {
+    "id": "azure-q81",
+    "lesson_id": "azure-activity-log",
+    "question_type": "command",
+    "question": "지난 24시간 동안 `myRG`에서 발생한 Activity Log를 CLI로 조회하는 명령어를 입력하세요.",
+    "options": [],
+    "answer": "az monitor activity-log list --resource-group myRG --offset 24h",
+    "explanation": "`az monitor activity-log list --resource-group <RG> --offset 24h` 로 최근 24시간 활동 로그를 조회합니다. `--offset`은 현재 시각 기준 이전 시간입니다.",
+    "difficulty": "medium",
+    "source_id": "azure-monitor-overview"
+  },
+  {
+    "id": "azure-q82",
+    "lesson_id": "azure-alert",
+    "question_type": "multiple_choice",
+    "question": "Alert Rule에서 `Severity 0`과 `Severity 4`의 차이는?",
+    "options": [
+      "Severity 0이 가장 심각(Critical), Severity 4는 가장 낮음(Verbose)",
+      "Severity 4가 가장 심각하다",
+      "두 값은 동일하다",
+      "Severity는 경보 조건 임계값을 의미한다"
+    ],
+    "answer": "Severity 0이 가장 심각(Critical), Severity 4는 가장 낮음(Verbose)",
+    "explanation": "Azure Alert Severity는 0(Critical)부터 4(Verbose)까지 5단계입니다. 심각도가 낮을수록 더 위험한 상황을 의미합니다.",
+    "difficulty": "easy",
+    "source_id": "azure-monitor-overview"
+  },
+  {
+    "id": "azure-q83",
+    "lesson_id": "azure-backup-policy",
+    "question_type": "multiple_choice",
+    "question": "VM Backup Policy에서 설정하는 핵심 두 가지 요소는?",
+    "options": [
+      "백업 빈도(일별/주별)와 보존 기간",
+      "백업 위치와 VM 크기",
+      "NSG 규칙과 subnet",
+      "이메일 알림 주소와 SKU"
+    ],
+    "answer": "백업 빈도(일별/주별)와 보존 기간",
+    "explanation": "Backup Policy는 언제 백업할지(빈도)와 얼마나 오래 보존할지(보존 기간)를 정의합니다. 보존 기간이 길수록 더 많은 복구 지점을 유지합니다.",
+    "difficulty": "easy",
+    "source_id": "azure-recovery-services-vault"
+  },
+  {
+    "id": "azure-q84",
+    "lesson_id": "azure-restore",
+    "question_type": "multiple_choice",
+    "question": "VM 복원 시 '기존 VM 교체' 대신 '새 VM으로 복원'을 선택하는 이유로 가장 맞는 것은?",
+    "options": [
+      "기존 VM을 보존하면서 복원 결과를 먼저 검증하기 위해",
+      "새 VM이 항상 더 빠르기 때문",
+      "기존 VM 교체가 더 오래 걸리기 때문",
+      "새 VM은 비용이 발생하지 않기 때문"
+    ],
+    "answer": "기존 VM을 보존하면서 복원 결과를 먼저 검증하기 위해",
+    "explanation": "프로덕션 VM에 직접 복원하면 되돌릴 수 없습니다. 새 VM으로 복원해 데이터와 앱 정상 동작을 확인한 뒤 DNS나 IP를 전환하는 것이 안전합니다.",
+    "difficulty": "medium",
+    "source_id": "azure-recovery-services-vault"
+  },
+  {
+    "id": "azure-q85",
+    "lesson_id": "azure-app-service-plan",
+    "question_type": "multiple_choice",
+    "question": "App Service Plan의 Free 티어와 Standard 티어의 가장 큰 기능 차이는?",
+    "options": [
+      "Standard 이상에서만 Custom Domain, SSL, 배포 슬롯, 자동 크기 조정이 가능하다",
+      "Free 티어가 더 빠른 처리량을 제공한다",
+      "Standard는 Linux만 지원한다",
+      "Free 티어에서만 VNet 통합이 가능하다"
+    ],
+    "answer": "Standard 이상에서만 Custom Domain, SSL, 배포 슬롯, 자동 크기 조정이 가능하다",
+    "explanation": "Free/Shared 티어는 개발·테스트용입니다. Custom Domain 바인딩, SSL 인증서, 배포 슬롯(Blue-Green), Autoscale은 Standard 이상에서 지원합니다.",
+    "difficulty": "medium",
+    "source_id": "azure-app-service-overview"
+  },
+  {
+    "id": "azure-q86",
+    "lesson_id": "azure-container-registry",
+    "command": "command",
+    "question_type": "command",
+    "question": "ACR `myACR`에서 이미지 `myapp:v1`을 빌드해 푸시하는 CLI 명령어를 입력하세요.",
+    "options": [],
+    "answer": "az acr build --registry myACR --image myapp:v1 .",
+    "explanation": "`az acr build`는 로컬 Dockerfile을 ACR 빌드 에이전트에 보내 빌드 후 자동으로 레지스트리에 푸시합니다. 로컬에 Docker 설치가 필요 없습니다.",
+    "difficulty": "medium",
+    "source_id": "azure-vm-overview"
+  },
+  {
+    "id": "azure-q87",
+    "lesson_id": "azure-key-vault",
+    "question_type": "multiple_choice",
+    "question": "Key Vault에서 비밀(Secret), 키(Key), 인증서(Certificate)의 차이는?",
+    "options": [
+      "Secret은 패스워드 같은 임의 문자열, Key는 암호화용 키 소재, Certificate는 X.509 인증서다",
+      "세 가지 모두 동일한 목적으로 사용된다",
+      "Key는 패스워드, Secret은 암호화 키다",
+      "Certificate는 네트워크 방화벽 규칙이다"
+    ],
+    "answer": "Secret은 패스워드 같은 임의 문자열, Key는 암호화용 키 소재, Certificate는 X.509 인증서다",
+    "explanation": "Secret: DB 비밀번호·API 키 같은 문자열. Key: HSM에서 보호되는 암호화/서명용 키 소재. Certificate: TLS 인증서로 자동 갱신 기능을 제공합니다.",
+    "difficulty": "medium",
+    "source_id": "azure-key-vault-overview"
+  },
+  {
+    "id": "azure-q88",
+    "lesson_id": "azure-cost-management",
+    "question_type": "multiple_choice",
+    "question": "Azure Cost Management에서 월별 예산 초과 시 자동으로 리소스를 종료하려면?",
+    "options": [
+      "예산 경보(Budget Alert)는 알림만 보내고 자동 종료는 Action Group + Automation으로 별도 구성해야 한다",
+      "예산 설정만 하면 자동으로 리소스가 종료된다",
+      "Cost Management가 직접 VM을 중지한다",
+      "Policy를 통해 자동 종료된다"
+    ],
+    "answer": "예산 경보(Budget Alert)는 알림만 보내고 자동 종료는 Action Group + Automation으로 별도 구성해야 한다",
+    "explanation": "Budget Alert은 예산 임계값 도달 시 이메일만 보냅니다. 실제 리소스 종료는 Automation Account의 Runbook을 Action Group에 연결해 트리거해야 합니다.",
+    "difficulty": "hard",
+    "source_id": "manual-az104-basic"
+  },
+  {
+    "id": "azure-q89",
+    "lesson_id": "azure-bastion",
+    "question_type": "multiple_choice",
+    "question": "Azure Bastion을 배포하기 위해 VNet에 반드시 있어야 하는 서브넷 이름은?",
+    "options": ["AzureBastionSubnet", "BastionSubnet", "GatewaySubnet", "PrivateEndpointSubnet"],
+    "answer": "AzureBastionSubnet",
+    "explanation": "Azure Bastion은 정확히 `AzureBastionSubnet`이라는 이름의 서브넷에만 배포됩니다. 이름이 다르면 배포에 실패합니다. 크기는 최소 /27 이상이어야 합니다.",
+    "difficulty": "easy",
+    "source_id": "azure-vnet-overview"
+  },
+  {
+    "id": "azure-q90",
+    "lesson_id": "azure-nat-gateway",
+    "question_type": "multiple_choice",
+    "question": "NAT Gateway를 사용하는 주된 이유는?",
+    "options": [
+      "VNet 내 Private VM의 아웃바운드 인터넷 연결에 고정 Public IP를 제공한다",
+      "인바운드 트래픽을 VM으로 분산한다",
+      "VNet 간 라우팅을 담당한다",
+      "DNS 이름을 해석한다"
+    ],
+    "answer": "VNet 내 Private VM의 아웃바운드 인터넷 연결에 고정 Public IP를 제공한다",
+    "explanation": "NAT Gateway는 Public IP가 없는 VM의 아웃바운드 트래픽을 고정 Public IP로 SNAT합니다. 로드밸런서의 SNAT 포트 소진 문제를 해결하는 데도 사용합니다.",
+    "difficulty": "medium",
+    "source_id": "azure-vnet-overview"
+  },
+  {
+    "id": "azure-q91",
+    "lesson_id": "azure-app-service",
+    "question_type": "command",
+    "question": "`myWebApp`에 GitHub Actions로 Node.js 앱을 배포하기 위해 게시 프로필을 내려받는 CLI 명령어를 입력하세요.",
+    "options": [],
+    "answer": "az webapp deployment list-publishing-profiles --name myWebApp --resource-group myRG",
+    "explanation": "`az webapp deployment list-publishing-profiles`로 게시 프로필(FTP, WebDeploy, Git URL 등)을 내려받아 GitHub Actions 시크릿에 등록합니다.",
+    "difficulty": "hard",
+    "source_id": "azure-app-service-overview"
+  },
+  {
+    "id": "azure-q92",
+    "lesson_id": "azure-deployment-slot",
+    "question_type": "multiple_choice",
+    "question": "배포 슬롯 swap 후 이전 버전으로 빠르게 롤백하는 방법은?",
+    "options": [
+      "다시 swap을 실행하면 production과 staging이 교체되어 롤백된다",
+      "git revert 후 재배포해야 한다",
+      "VM을 재시작하면 된다",
+      "슬롯을 삭제하고 재생성해야 한다"
+    ],
+    "answer": "다시 swap을 실행하면 production과 staging이 교체되어 롤백된다",
+    "explanation": "Swap은 production과 staging의 역할을 교환합니다. 문제가 발생하면 다시 swap으로 즉시 이전 버전으로 돌아갈 수 있습니다.",
+    "difficulty": "easy",
+    "source_id": "azure-app-service-overview"
+  },
+  {
+    "id": "azure-q93",
+    "lesson_id": "azure-aci",
+    "question_type": "command",
+    "question": "`myACR.azurecr.io/myapp:v1` 이미지로 `myContainer` 컨테이너 인스턴스를 생성하는 CLI 명령어를 입력하세요.",
+    "options": [],
+    "answer": "az container create --resource-group myRG --name myContainer --image myACR.azurecr.io/myapp:v1",
+    "explanation": "`az container create --image <이미지>` 로 ACI를 생성합니다. ACR의 프라이빗 이미지는 `--registry-login-server`, `--registry-username`, `--registry-password` 옵션이 필요합니다.",
+    "difficulty": "medium",
+    "source_id": "azure-container-instances"
+  },
+  {
+    "id": "azure-q94",
+    "lesson_id": "azure-keyvault-secret",
+    "question_type": "command",
+    "question": "`myKV` Key Vault에서 `db-password` 비밀의 현재 값을 조회하는 CLI 명령어를 입력하세요.",
+    "options": [],
+    "answer": "az keyvault secret show --vault-name myKV --name db-password",
+    "explanation": "`az keyvault secret show --vault-name <KV> --name <비밀이름>` 으로 현재 활성 버전의 비밀 값을 조회합니다. 출력에서 `value` 필드에 실제 값이 있습니다.",
+    "difficulty": "easy",
+    "source_id": "azure-key-vault-overview"
+  },
+  {
+    "id": "azure-q95",
+    "lesson_id": "azure-managed-identity",
+    "question_type": "multiple_choice",
+    "question": "System-assigned Managed Identity와 User-assigned Managed Identity의 차이는?",
+    "options": [
+      "System-assigned는 리소스와 수명이 같고, User-assigned는 독립적으로 만들어 여러 리소스에 공유 가능하다",
+      "User-assigned는 자동으로 권한이 부여된다",
+      "System-assigned는 여러 VM에 공유 가능하다",
+      "두 타입은 동일하게 동작한다"
+    ],
+    "answer": "System-assigned는 리소스와 수명이 같고, User-assigned는 독립적으로 만들어 여러 리소스에 공유 가능하다",
+    "explanation": "System-assigned는 VM/App Service 생성 시 자동으로 만들어지고 리소스 삭제 시 함께 삭제됩니다. User-assigned는 별도로 만들어 여러 리소스에 할당할 수 있어 공유 시나리오에 적합합니다.",
+    "difficulty": "medium",
+    "source_id": "azure-key-vault-overview"
+  },
+  {
+    "id": "azure-q96",
+    "lesson_id": "azure-network-watcher",
+    "question_type": "multiple_choice",
+    "question": "Network Watcher의 IP flow verify 기능으로 확인할 수 있는 것은?",
+    "options": [
+      "특정 IP와 포트 조합이 NSG에 의해 허용되는지 차단되는지",
+      "VM의 CPU 사용률",
+      "Blob 접근 이력",
+      "Key Vault 접근 로그"
+    ],
+    "answer": "특정 IP와 포트 조합이 NSG에 의해 허용되는지 차단되는지",
+    "explanation": "IP flow verify는 VM NIC에서 특정 소스 IP, 목적지 IP, 포트, 방향(인바운드/아웃바운드)을 입력하면 어떤 NSG 규칙이 적용되는지 즉시 확인할 수 있습니다.",
+    "difficulty": "medium",
+    "source_id": "azure-vnet-overview"
+  },
+  {
+    "id": "azure-q97",
+    "lesson_id": "azure-move-resource",
+    "question_type": "command",
+    "question": "`myRG`의 VM `myVM`을 `targetRG`로 이동하는 CLI 명령어를 입력하세요.",
+    "options": [],
+    "answer": "az resource move --destination-group targetRG --ids $(az vm show --resource-group myRG --name myVM --query id -o tsv)",
+    "explanation": "`az resource move --destination-group <대상RG> --ids <리소스ID>` 로 이동합니다. ID는 `az vm show --query id`로 가져옵니다. 종속 리소스(NIC, 디스크)도 함께 이동해야 합니다.",
+    "difficulty": "hard",
+    "source_id": "manual-az104-basic"
+  },
+  {
+    "id": "azure-q99",
+    "lesson_id": "azure-recovery-vault",
+    "question_type": "command",
+    "question": "`myRG`의 `myVM`을 `myVault` Recovery Services Vault에 `DefaultPolicy`로 백업 활성화하는 CLI 명령어를 입력하세요.",
+    "options": [],
+    "answer": "az backup protection enable-for-vm --vault-name myVault --resource-group myRG --vm myVM --policy-name DefaultPolicy",
+    "explanation": "`az backup protection enable-for-vm`으로 VM 백업을 시작합니다. Vault와 VM은 같은 region에 있어야 하며, 최초 백업은 활성화 직후 또는 예약 시간에 실행됩니다.",
+    "difficulty": "medium",
+    "source_id": "azure-recovery-services-vault"
+  },
+  {
+    "id": "azure-q100",
+    "lesson_id": "azure-subscription",
+    "question_type": "multiple_choice",
+    "question": "하나의 Azure Tenant 아래 여러 Subscription을 사용하는 주된 이유는?",
+    "options": [
+      "환경(개발/스테이징/운영)이나 부서별 과금과 정책을 분리하기 위해",
+      "Subscription이 많을수록 요금이 할인되기 때문",
+      "한 Subscription에 VM을 2개 이상 만들 수 없기 때문",
+      "Subscription을 늘리면 가용성이 높아지기 때문"
+    ],
+    "answer": "환경(개발/스테이징/운영)이나 부서별 과금과 정책을 분리하기 위해",
+    "explanation": "Subscription은 과금, 리소스 할당량, RBAC/Policy의 경계입니다. 개발과 운영을 분리하거나 부서별 비용을 독립적으로 관리할 때 여러 Subscription을 사용합니다.",
+    "difficulty": "easy",
+    "source_id": "manual-az104-basic"
+  },
+  {
+    "id": "azure-q98",
+    "lesson_id": "azure-template-deployment",
+    "question_type": "command",
+    "question": "`myRG`에 `main.bicep` 파일을 Bicep CLI로 배포하는 명령어를 입력하세요.",
+    "options": [],
+    "answer": "az deployment group create --resource-group myRG --template-file main.bicep",
+    "explanation": "`az deployment group create --template-file <파일>`로 Bicep 또는 ARM JSON 템플릿을 리소스 그룹에 배포합니다. `--parameters`로 파라미터 파일도 함께 지정할 수 있습니다.",
+    "difficulty": "easy",
+    "source_id": "azure-arm-bicep-overview"
+  }
+]

cert_study_app/content/linux/lessons.json

@@ -0,0 +1,1448 @@
+[
+  {
+    "id": "linux-pwd",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "pwd — 현재 디렉터리 확인",
+    "summary": "현재 쉘의 작업 디렉터리를 절대경로로 출력합니다. 파일 조작 명령은 모두 이 위치를 기준으로 실행되므로 작업 전 확인 습관이 중요합니다.",
+    "example": "pwd\n# /home/ubuntu\ncd /var/log && pwd\n# /var/log",
+    "common_mistake": "상대경로(../dir)는 pwd 결과 기준으로 해석됩니다. 헷갈리면 절대경로를 사용하세요.",
+    "keywords": [
+      "pwd",
+      "working directory",
+      "absolute path"
+    ],
+    "source_id": "linux-bash-manual",
+    "details": [
+      "`pwd`는 현재 위치를 절대경로로 출력합니다. 프롬프트에 표시된 경로가 잘릴 때 정확한 위치를 확인하는 용도로 씁니다.",
+      "스크립트에서 `DIR=$(pwd)`로 현재 경로를 저장해두면 `cd` 후 `cd $DIR`로 복귀할 수 있습니다.",
+      "시험에서는 `cd`로 이동 후 `pwd` 결과를 묻거나, 상대경로 명령이 어느 위치에 적용되는지 추론하는 형태로 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-ls",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "ls — 디렉터리 목록 확인",
+    "summary": "디렉터리의 파일과 하위 디렉터리를 나열합니다. 권한·소유자·크기·수정시간까지 보려면 `-l`, 숨김파일 포함은 `-a`를 씁니다.",
+    "example": "ls -al /etc\nls -lh /var/log\nls -lt   # 수정시간 역순 정렬",
+    "common_mistake": "`ls -l`의 첫 컬럼은 권한 비트(rwxrwxrwx)입니다. d로 시작하면 디렉터리, -면 일반 파일, l이면 심볼릭 링크.",
+    "keywords": [
+      "ls",
+      "-l",
+      "-a",
+      "-h",
+      "hidden files",
+      "permissions"
+    ],
+    "source_id": "linux-bash-manual",
+    "details": [
+      "`ls -l` 출력: `권한 링크수 소유자 그룹 크기 날짜 이름` 순서. 권한 비트 읽기를 반드시 익혀야 합니다.",
+      "`-a`는 `.`으로 시작하는 숨김파일 포함. `-h`는 용량을 KB/MB로 사람이 읽기 쉽게 표시합니다.",
+      "시험 패턴: 특정 디렉터리의 파일 권한·소유자를 확인하거나, 최근 수정 파일을 찾는 문제에서 `ls -lt` 조합이 자주 나옵니다."
+    ]
+  },
+  {
+    "id": "linux-cd",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "cd — 디렉터리 이동",
+    "summary": "작업 디렉터리를 변경합니다. 이후 실행하는 모든 상대경로 명령의 기준이 바뀝니다.",
+    "example": "cd /etc/nginx        # 절대경로 이동\ncd ..               # 부모 디렉터리\ncd ~                # 홈 디렉터리\ncd -                # 이전 디렉터리",
+    "common_mistake": "`cd ..`은 한 단계 위, `cd /`는 루트로 이동. `cd -`는 바로 직전 위치로 돌아옵니다.",
+    "keywords": [
+      "cd",
+      "relative path",
+      "absolute path",
+      "home"
+    ],
+    "source_id": "linux-bash-cd",
+    "details": [
+      "`cd 절대경로`는 어디서든 동일 위치로 이동. `cd 상대경로`는 현재 위치 기준으로 이동합니다.",
+      "`cd ~user`는 다른 사용자의 홈 디렉터리로 이동합니다. 관리자 작업 시 자주 활용합니다.",
+      "시험 패턴: 여러 번 `cd`로 이동 후 현재 위치를 묻거나, 올바른 경로 표현식을 고르는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-mkdir",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "mkdir — 디렉터리 생성",
+    "summary": "새 디렉터리를 만듭니다. `-p` 옵션으로 중간 경로가 없어도 한 번에 생성할 수 있습니다.",
+    "example": "mkdir logs\nmkdir -p /srv/app/config   # 중간 디렉터리 자동 생성\nmkdir -m 750 secure_dir    # 권한 지정해 생성",
+    "common_mistake": "부모 디렉터리가 없는 경로에 `mkdir`만 쓰면 에러납니다. `-p`를 붙이면 부모까지 자동 생성됩니다.",
+    "keywords": [
+      "mkdir",
+      "-p",
+      "directory",
+      "create"
+    ],
+    "source_id": "linux-bash-manual",
+    "details": [
+      "`mkdir -p a/b/c`는 a, a/b, a/b/c를 한 번에 만듭니다. 스크립트에서 경로 준비 시 필수 옵션입니다.",
+      "`-m 모드`로 생성과 동시에 권한을 설정할 수 있습니다: `mkdir -m 700 private`.",
+      "시험 패턴: 실습에서 특정 경로를 만들고 이어서 권한·소유자를 설정하는 흐름으로 자주 등장합니다."
+    ]
+  },
+  {
+    "id": "linux-touch",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "touch — 파일 생성 / 타임스탬프 갱신",
+    "summary": "빈 파일을 생성하거나, 이미 있는 파일의 수정 시간을 현재 시각으로 갱신합니다.",
+    "example": "touch newfile.txt\ntouch -t 202401010000 old.txt  # 특정 시각으로 설정",
+    "common_mistake": "이미 있는 파일에 `touch`를 쓰�� 내용을 지우지 않고 시간 정보만 갱신됩니다.",
+    "keywords": [
+      "touch",
+      "timestamp",
+      "create",
+      "mtime"
+    ],
+    "source_id": "linux-bash-manual",
+    "details": [
+      "파일이 없으면 빈 파일을 만들고, 있으면 atime(접근)과 mtime(수정) 시각을 현재로 갱신합니다.",
+      "`-t YYYYMMDDhhmm` 형태로 원하는 시각을 직접 지정할 수 있어 테스트 시나리오에서 활용됩니다.",
+      "시험 패턴: 파일 생성 후 `ls -l`로 존재·시각 확인, 또는 `find -newer`로 최근 파일 검색하는 흐름과 연결됩니다."
+    ]
+  },
+  {
+    "id": "linux-cat",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "cat — 파일 내용 출력",
+    "summary": "파일 내용을 표준 출력으로 보여줍니다. 여러 파일을 연결하거나 리다이렉션으로 파일을 만들 때도 씁니다.",
+    "example": "cat /etc/hostname\ncat file1.txt file2.txt > merged.txt\ncat -n file.txt   # 줄 번호 표시",
+    "common_mistake": "큰 파일은 `cat` 대신 `less`(스크롤), `head`/`tail`(일부만)을 사용하세요.",
+    "keywords": [
+      "cat",
+      "stdout",
+      "concatenate",
+      "-n"
+    ],
+    "source_id": "linux-bash-manual",
+    "details": [
+      "`cat`은 파일 전체를 한 번에 출력합니다. `/etc/passwd`, `/etc/hosts` 같은 설정 파일 빠르게 볼 때 씁니다.",
+      "`cat file1 file2 > combined`로 두 파일을 합칩니다. `>>` 사용 시 기존 파일에 추가됩니다.",
+      "시험 패턴: `cat > file << EOF … EOF` 형태의 here-doc으로 파일을 직접 작성하는 패턴도 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-grep",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "grep — 텍스트 패턴 검색",
+    "summary": "파일이나 표준 입력에서 패턴이 있는 줄을 출력합니다. 로그 분석과 설정 파일 검색에 가장 많이 쓰이는 명령어입니다.",
+    "example": "grep 'ERROR' /var/log/syslog\ngrep -rn 'PermitRootLogin' /etc/ssh/\ngrep -v '^#' /etc/ssh/sshd_config  # 주석 제외",
+    "common_mistake": "`grep`은 기본적으로 대소문자를 구분합니다. 구분 없이 찾으려면 `-i`를 추가하세요.",
+    "keywords": [
+      "grep",
+      "-r",
+      "-n",
+      "-i",
+      "-v",
+      "pattern",
+      "regex"
+    ],
+    "source_id": "linux-grep-manual",
+    "details": [
+      "주요 옵션: `-r`(재귀), `-n`(줄번호), `-i`(대소문자 무시), `-v`(제외), `-l`(파일명만), `-c`(개수).",
+      "`grep -r 'failed' /var/log/`로 로그 디렉터리 전체에서 오류를 검색할 수 있습니다.",
+      "시험 패턴: `ps aux | grep nginx`처럼 파이프와 함께, 또는 설정 파일에서 특정 값을 찾는 복합 문제로 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-chmod",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "chmod — 파일 권한 변경",
+    "summary": "파일·디렉터리의 읽기(r=4), 쓰기(w=2), 실행(x=1) 권한을 소유자·그룹·기타 사용자별로 설정합니다.",
+    "example": "chmod 755 script.sh     # rwxr-xr-x\nchmod 644 config.conf   # rw-r--r--\nchmod u+x,g-w file.txt  # 심볼릭 방식",
+    "common_mistake": "8진수 방식: 7=rwx, 6=rw-, 5=r-x, 4=r--. `chmod 777`은 모든 사용자에 모든 권한 — 보안상 위험합니다.",
+    "keywords": [
+      "chmod",
+      "permissions",
+      "rwx",
+      "octal",
+      "symbolic"
+    ],
+    "source_id": "ubuntu-server-docs",
+    "details": [
+      "8진수 표기: 첫째 자리=소유자(u), 둘째=그룹(g), 셋째=기타(o). 각 자리는 r(4)+w(2)+x(1) 합산입니다.",
+      "심볼릭 표기: `u+x`(소유자에 실행 추가), `go-w`(그룹·기타 쓰기 제거), `a=r`(모두 읽기만).",
+      "시험 패턴: 특정 권한 비트를 보고 8진수 숫자를 맞추거나, 요구 조건에 맞는 chmod 명령을 고르는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-chown",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "chown — 소유자·그룹 변경",
+    "summary": "파일·디렉터리의 소유자와 그룹을 변경합니다. `chmod`는 권한 비트, `chown`은 소유자를 바꾸는 것으로 역할이 다릅니다.",
+    "example": "sudo chown ubuntu:ubuntu /srv/app\nchown -R www-data:www-data /var/www/html\nchown :developers project/  # 그룹만 변경",
+    "common_mistake": "`chown user file`은 소유자만, `chown user:group file`은 소유자와 그룹을 함께 바꿉니다.",
+    "keywords": [
+      "chown",
+      "owner",
+      "group",
+      "-R",
+      "sudo"
+    ],
+    "source_id": "ubuntu-user-management",
+    "details": [
+      "`chown 사용자:그룹 파일` 형식. `:그룹`만 쓰면 그룹만 변경. `-R`은 디렉터리를 재귀적으로 변경합니다.",
+      "웹 서버 설정에서 `/var/www/html`의 소유자를 `www-data`로 변경하는 패턴이 자주 등장합니다.",
+      "시험 패턴: `chown`과 `chmod`를 조합해 특정 사용자만 접근하도록 설정하는 실습 문제에 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-umask",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "umask — 기본 권한 마스크",
+    "summary": "새로 생성되는 파일·디렉터리의 기본 권한에서 차감할 비트를 지정합니다. 기본 umask 022는 파일 644, 디렉터리 755를 만들어냅니다.",
+    "example": "umask          # 현재 마스크 확인\numask 027      # 파일 640, 디렉터리 750\numask -S       # 심볼릭 표기로 확인",
+    "common_mistake": "umask 값은 권한이 아니라 '빼는 값'입니다. umask 022 → 파일 기본 666-022=644, 디렉터리 777-022=755.",
+    "keywords": [
+      "umask",
+      "default permissions",
+      "mask",
+      "022"
+    ],
+    "source_id": "ubuntu-server-docs",
+    "details": [
+      "파일 기본 최대 권한은 666, 디렉터리는 777. 여기서 umask를 빼면 실제 생성 권한이 됩니다.",
+      "사용자별 umask는 `~/.bashrc` 또는 `/etc/profile`에서 설정합니다. 시스템 전체는 `/etc/login.defs`.",
+      "시험 패턴: umask 값을 주고 파일 생성 시 권한이 무엇인지, 또는 원하는 기본 권한을 만들기 위한 umask 값을 묻습니다."
+    ]
+  },
+  {
+    "id": "linux-find",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "find — 파일 검색",
+    "summary": "이름, 크기, 수정 시각, 권한, 소유자 등 다양한 조건으로 파일시스템에서 파일을 찾습니다.",
+    "example": "find /etc -name '*.conf'\nfind /var/log -mtime -1   # 하루 이내 수정\nfind / -perm /4000 -type f  # SUID 파일",
+    "common_mistake": "`find -name '*.conf'`에서 따옴표를 빠뜨리면 쉘이 glob을 먼저 해석해 예상치 못한 결과가 납니다.",
+    "keywords": [
+      "find",
+      "-name",
+      "-type",
+      "-mtime",
+      "-perm",
+      "-exec"
+    ],
+    "source_id": "linux-bash-manual",
+    "details": [
+      "주요 조건: `-name`(이름), `-type f/d`(파일/디렉터리), `-size +10M`(크기), `-mtime -7`(7일 이내 수정), `-user`(소유자).",
+      "`-exec 명령 {} \\;`로 찾은 파일에 명령을 실행합니다: `find . -name '*.tmp' -exec rm {} \\;`.",
+      "시험 패턴: SUID/SGID 파일 찾기(`-perm /4000`), 특정 사용자 파일 찾기(`-user`), 오래된 파일 정리가 자주 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-pipe-redirect",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "파이프와 리다이렉션",
+    "summary": "파이프(`|`)는 명령의 출력을 다음 명령의 입력으로 연결하고, 리다이렉션(`>`, `>>`, `<`)은 출력·입력을 파일로 연결합니다.",
+    "example": "cat /etc/passwd | grep root\nls -la > filelist.txt\necho 'append' >> log.txt\ncommand 2>&1 | tee output.log",
+    "common_mistake": "`>`는 파일을 덮어쓰고, `>>`는 추가합니다. 중요한 파일에 실수로 `>`를 쓰면 내용이 사라집니다.",
+    "keywords": [
+      "pipe",
+      "redirect",
+      ">",
+      ">>",
+      "2>&1",
+      "stdin",
+      "stdout"
+    ],
+    "source_id": "linux-bash-cd",
+    "details": [
+      "stdout 리다이렉션: `>` 덮어쓰기, `>>` 추가. stderr 리다이렉션: `2>`. `2>&1`은 stderr를 stdout으로 합칩니다.",
+      "`tee` 명령은 stdout을 화면과 파일에 동시에 출력합니다: `command | tee log.txt`.",
+      "시험 패턴: 명령 출력을 파일에 저장하거나, 에러 메시지를 로그에 기록하는 복합 파이프라인 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-tar",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "tar — 아카이브와 압축",
+    "summary": "여러 파일을 하나의 아카이브로 묶거나 압축합니다. `-c`(생성), `-x`(해제), `-z`(gzip), `-j`(bzip2)를 조합해 씁니다.",
+    "example": "tar czf backup.tar.gz /etc\ntar xzf backup.tar.gz -C /tmp\ntar tvf archive.tar.gz  # 내용 목록",
+    "common_mistake": "`c`(create)와 `x`(extract)를 혼동하지 마세요. `-C`로 압축 해제 위치를 지정하지 않으면 현재 위치에 풀립니다.",
+    "keywords": [
+      "tar",
+      "-czf",
+      "-xzf",
+      "gzip",
+      "archive",
+      "backup"
+    ],
+    "source_id": "linux-bash-manual",
+    "details": [
+      "옵션 의미: `c`=생성, `x`=해제, `t`=목록, `v`=상세출력, `f`=파일지정, `z`=gzip, `j`=bzip2, `J`=xz.",
+      "백업 패턴: `tar czf /backup/etc-$(date +%Y%m%d).tar.gz /etc`로 날짜 포함 백업 파일 생성.",
+      "시험 패턴: 특정 디렉터리를 압축하거나 지정 위치에 풀어내는 명령을 직접 작성하는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-process-ps-kill",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "ps, kill — 프로세스 확인과 종료",
+    "summary": "`ps`로 실행 중인 프로세스를 조회하고, `kill`로 ��그널을 보내 프로세스를 종료하거나 제어합니다.",
+    "example": "ps aux | grep nginx\nkill -15 1234   # SIGTERM (정상 종료 요청)\nkill -9 1234    # SIGKILL (강제 종료)\nkillall nginx   # 이름으로 종료",
+    "common_mistake": "`kill -9`는 프로세스가 정리 과정 없이 즉시 종료됩니다. 먼저 `-15`(SIGTERM)을 시도하고, 응답 없을 때만 `-9`를 씁니다.",
+    "keywords": [
+      "ps",
+      "kill",
+      "SIGTERM",
+      "SIGKILL",
+      "PID",
+      "aux"
+    ],
+    "source_id": "linux-bash-manual",
+    "details": [
+      "`ps aux`: a=모든 사용자, u=사용자/CPU/메모리 정보, x=터미널 없는 프로세스 포함. PID가 두 번째 컬럼입니다.",
+      "주요 시그널: 1(SIGHUP 재시작), 9(SIGKILL 강제종료), 15(SIGTERM 정상종료 요청), 2(SIGINT Ctrl+C).",
+      "시험 패턴: `ps aux | grep 프로세스명`으로 PID를 찾고 `kill`로 종료하는 두 단계 흐름이 자주 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-systemctl",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "systemctl — 서비스 관리",
+    "summary": "systemd 기반 서비스를 시작·중지·재시작하고, 부팅 시 자동 시작 여부를 제어합니다. Ubuntu 16.04 이후 표준입니다.",
+    "example": "systemctl start nginx\nsystemctl enable --now ssh   # 즉시 시작 + 부팅 자동 시작\nsystemctl status nginx\nsystemctl list-units --type=service",
+    "common_mistake": "`enable`은 부팅 자동 시작 설정, `start`는 지금 당장 시작. 둘 다 하려면 `enable --now`를 씁니다.",
+    "keywords": [
+      "systemctl",
+      "enable",
+      "disable",
+      "start",
+      "stop",
+      "status",
+      "systemd"
+    ],
+    "source_id": "linux-systemd-systemctl",
+    "details": [
+      "주요 서브커맨드: `start/stop/restart/reload`(실행 제어), `enable/disable`(부팅 자동 시작), `status`(상태 확인), `is-active/is-enabled`(조건 확인).",
+      "`systemctl status 서비스`는 현재 상태, 최근 로그, PID, 실행 시간을 함께 보여줍니다.",
+      "시험 패턴: 특정 서비스를 '지금 시작하고 부팅에도 자동 시작'하도록 설정하거나, 서비스 상태를 확인하는 문제가 자주 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-journalctl",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "journalctl — systemd 로그 조회",
+    "summary": "systemd journal에 기록된 시스템 로그를 조회합니다. 서비스별, 시간별, 우선순위별 필터링이 강력합니다.",
+    "example": "journalctl -u nginx --since today\njournalctl -p err -n 50\njournalctl -f   # 실시간 추적\njournalctl --disk-usage",
+    "common_mistake": "`journalctl`은 journal에 저장된 로그만 봅니다. `/var/log/` 텍스트 파일 로그는 `cat`/`tail`로 확인합니다.",
+    "keywords": [
+      "journalctl",
+      "-u",
+      "-f",
+      "--since",
+      "-p",
+      "systemd",
+      "journal"
+    ],
+    "source_id": "linux-systemd-systemctl",
+    "details": [
+      "주요 옵션: `-u 서비스`(서비스별), `-p err`(에러 이상), `--since '2024-01-01'`(시간 범위), `-n 100`(최근 100줄), `-f`(실시간).",
+      "`journalctl -b`는 현재 부팅 이후 로그, `-b -1`은 이전 부팅 로그. 재부팅 후 오류 추적에 활용합니다.",
+      "시험 패턴: 특정 서비스의 오류 로그를 찾거나, 특정 시간 이후 로그를 확인하는 문제로 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-ip-ss",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "ip, ss — 네트워크 인터페이스와 소켓 확인",
+    "summary": "`ip`로 네트워크 인터페이스·라우팅·IP 설정을 확인하고, `ss`로 현재 열린 포트와 연결 상태를 조회합니다.",
+    "example": "ip addr show\nip route show\nss -tlnp    # TCP 리스닝 포트와 프로세스\nss -s       # 소켓 통계 요약",
+    "common_mistake": "`ifconfig`와 `netstat`은 구식 도구입니다. 현재는 `ip`와 `ss`가 표준이며 시험에서도 이쪽이 출제됩니다.",
+    "keywords": [
+      "ip",
+      "ss",
+      "addr",
+      "route",
+      "netstat",
+      "socket",
+      "-tlnp"
+    ],
+    "source_id": "linux-man7-ip",
+    "details": [
+      "`ip addr`은 인터페이스별 IP, `ip route`는 라우팅 테이블, `ip link`는 인터페이스 상태를 보여줍니다.",
+      "`ss -tlnp`: t=TCP, l=listening, n=숫자표시, p=프로세스명. 어떤 서비스가 어느 포트를 열었는지 확인합니다.",
+      "시험 패턴: 특정 서비스가 올바른 포트를 리스닝하는지 확인하거나, IP 설정 상태를 조회하는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-df-du-mount",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "df, du, mount — 디스크 사용량과 마운트",
+    "summary": "`df`는 파일시스템 전체 용량, `du`는 특정 디렉터리 사용량, `mount`는 블록 장치를 파일시스템 트리에 연결합니다.",
+    "example": "df -h\ndu -sh /var/log/*\nmount /dev/sdb1 /mnt/data\nfindmnt   # 마운트 트리 확인",
+    "common_mistake": "`df`는 파일시스템 전체, `du`는 특정 경로의 실제 사용 크기. 두 숫자가 다를 수 있습니다(삭제됐지만 열린 파일 등).",
+    "keywords": [
+      "df",
+      "du",
+      "mount",
+      "-h",
+      "-sh",
+      "filesystem"
+    ],
+    "source_id": "ubuntu-storage",
+    "details": [
+      "`df -h`는 모든 마운트 파티션의 사용률을 보여줍니다. 디스크 풀 경고 시 먼저 실행하는 명령입니다.",
+      "`du -sh /경로/*`로 어느 하위 디렉터리가 공간을 차지하는지 찾을 수 있습니다.",
+      "시험 패턴: 디스크 사용률 확인, 임시 마운트 명령 작성, `findmnt`로 마운트 정보 확인하는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-useradd",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "useradd — 사용자 추가",
+    "summary": "새 사용자 계정을 생성합니다. `-m`으로 홈 디렉터리 자동 생성, `-s`로 로그인 쉘, `-G`로 추가 그룹을 지정합니다.",
+    "example": "sudo useradd -m -s /bin/bash -G sudo alice\nuseradd -r -s /usr/sbin/nologin svcuser  # 서비스 계정\npasswd alice  # 생성 후 비밀번호 설정",
+    "common_mistake": "`useradd`만 쓰면 홈 디렉터리가 생성되지 않습니다. `-m`을 반드시 붙이거나 `adduser`(대화형)를 씁니다.",
+    "keywords": [
+      "useradd",
+      "-m",
+      "-s",
+      "-G",
+      "adduser",
+      "home directory"
+    ],
+    "source_id": "ubuntu-user-management",
+    "details": [
+      "주요 옵션: `-m`(홈 디렉터리 생성), `-d 경로`(홈 경로 지정), `-s 쉘`(로그인 쉘), `-G 그룹`(추가 그룹), `-r`(시스템 계정).",
+      "서비스 계정은 `-r -s /usr/sbin/nologin`으로 생성해 로그인을 막고 시스템 서비스 전용으로 씁니다.",
+      "시험 패턴: 특정 조건(홈 디렉터리, 그룹, 쉘)을 만족하는 사용자를 생성하고 비밀번호를 설정하는 실습 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-usermod",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "usermod — 사용자 정보 변경",
+    "summary": "기존 사용자 계정의 그룹, 쉘, 홈 디렉터리, 잠금 상태를 변경합니다.",
+    "example": "usermod -aG docker alice    # docker 그룹 추가\nusermod -s /bin/zsh alice   # 쉘 변경\nusermod -L alice            # 계정 잠금\nusermod -U alice            # 잠금 해제",
+    "common_mistake": "`-G`만 쓰면 기존 그룹이 사라집니다. 그룹을 추가할 때는 반드시 `-aG`(append)를 써야 합니다.",
+    "keywords": [
+      "usermod",
+      "-aG",
+      "-L",
+      "-U",
+      "-s",
+      "group",
+      "lock"
+    ],
+    "source_id": "ubuntu-user-management",
+    "details": [
+      "`-aG 그룹`은 기존 그룹을 유지하면서 그룹을 추가. 그룹 변경 후 재로그인해야 적용됩니다.",
+      "`-L`(lock) / `-U`(unlock)로 비밀번호 앞에 `!`를 붙여 로그인을 차단하거나 해제합니다.",
+      "시험 패턴: 사용자를 특정 그룹에 추가하거나 계정을 잠금하는 명령을 작성하는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-passwd",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "passwd — 비밀번호와 계정 잠금",
+    "summary": "사용자 비밀번호를 변경하거나 계정 만료·잠금을 설정합니다. root는 다른 사용자의 비밀번호도 바꿀 수 있습니다.",
+    "example": "passwd                  # 현재 사용자 비밀번호 변경\nsudo passwd alice       # alice 비밀번호 변경\npasswd -l alice         # 계정 잠금\nchage -l alice          # 만료 정보 확인",
+    "common_mistake": "`passwd -l`로 잠근 계정도 SSH 키 인증으로는 접속 가능합니다. 완전 차단은 `/etc/shadow`의 쉘을 nologin으로 변경해야 합니다.",
+    "keywords": [
+      "passwd",
+      "-l",
+      "-u",
+      "-e",
+      "chage",
+      "password",
+      "lock"
+    ],
+    "source_id": "ubuntu-user-management",
+    "details": [
+      "`passwd -l`은 `/etc/shadow`의 비밀번호 앞에 `!`를 붙여 비밀번호 로그인을 차단합니다.",
+      "`chage -M 90 user`로 비밀번호 최대 사용 기간, `chage -E 날짜`로 계정 만료일을 설정합니다.",
+      "시험 패턴: 사용자 비밀번호 변경, 계정 잠금/해제, 비밀번호 만료 정책 설정 명령을 작성하는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-groups-id",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "id, groups — 사용자·그룹 확인",
+    "summary": "`id`는 현재 사용자의 UID, GID, 소속 그룹을 보여주고, `groups`는 그룹 목록만 출력합니다.",
+    "example": "id\n# uid=1000(ubuntu) gid=1000(ubuntu) groups=1000(ubuntu),4(adm),27(sudo)\nid alice\ngroups alice",
+    "common_mistake": "`usermod -aG`로 그룹을 추가한 뒤 `id`에 반영되려면 재로그인이 필요합니다. `newgrp 그룹명`으로 즉시 적용할 수 있습니다.",
+    "keywords": [
+      "id",
+      "groups",
+      "UID",
+      "GID",
+      "whoami"
+    ],
+    "source_id": "ubuntu-user-management",
+    "details": [
+      "`id` 출력에서 uid(사용자 번호), gid(기본 그룹), groups(모든 소속 그룹)를 확인할 수 있습니다.",
+      "root의 uid와 gid는 0입니다. `id -u`로 숫자만, `id -un`으로 이름만 출력할 수 있습니다.",
+      "시험 패턴: 사용자가 특정 그룹에 속해 있는지 확인하거나, uid/gid로 사용자 정보를 조회하는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-sudoers",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "sudo와 sudoers — 권한 위임",
+    "summary": "일반 사용자가 특정 명령을 root 권한으로 실행할 수 있도록 허용합니다. `/etc/sudoers`는 반드시 `visudo`로 편집합니다.",
+    "example": "sudo apt update\nvisudo  # /etc/sudoers 안전 편집\n# /etc/sudoers.d/alice 내용:\nalice ALL=(ALL) NOPASSWD: /usr/bin/systemctl",
+    "common_mistake": "`/etc/sudoers`를 직접 vi로 열어 수정하면 문법 오류 시 sudo가 완전히 잠길 수 있습니다. 반드시 `visudo`를 사용하세요.",
+    "keywords": [
+      "sudo",
+      "sudoers",
+      "visudo",
+      "NOPASSWD",
+      "ALL"
+    ],
+    "source_id": "ubuntu-user-management",
+    "details": [
+      "`sudo` 그룹 또는 wheel 그룹에 속한 사용자는 기본으로 sudo 사용 가능합니다: `usermod -aG sudo alice`.",
+      "`/etc/sudoers.d/` 디렉터리에 개별 파일을 만들면 메인 sudoers를 건드리지 않고 권한을 추가할 수 있습니다.",
+      "시험 패턴: 특정 사용자에게 특정 명령만 sudo 허용하거나, NOPASSWD 설정을 추가하는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-acl",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "ACL — 확장 접근 제어",
+    "summary": "기본 유닉스 권한(소유자/그룹/기타)만으로는 표현할 수 없는 세밀한 권한을 특정 사용자나 그룹별로 지정합니다.",
+    "example": "getfacl /srv/project\nsetfacl -m u:alice:rwx /srv/project\nsetfacl -m g:dev:r-x /srv/project\nsetfacl -R -m u:bob:r-- /data  # 재귀",
+    "common_mistake": "ACL이 설정된 파일은 `ls -l`에서 권한 뒤에 `+`가 붙습니다. 이것을 모르면 권한 설정이 됐는지 확인하기 어렵습니다.",
+    "keywords": [
+      "ACL",
+      "setfacl",
+      "getfacl",
+      "-m",
+      "-R",
+      "access control"
+    ],
+    "source_id": "ubuntu-server-docs",
+    "details": [
+      "`setfacl -m u:사용자:rwx 경로`로 특정 사용자에게 권한 추가. `getfacl`로 현재 ACL 확인.",
+      "기본 ACL(`setfacl -d`)을 설정하면 해당 디렉터리에 새로 생성되는 파일에 자동으로 ACL이 적용됩니다.",
+      "시험 패턴: 여러 사용자에게 다른 권한을 주는 시나리오에서 chmod 대신 setfacl을 사용하는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-special-perms",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "특수 권한 — SUID, SGID, Sticky Bit",
+    "summary": "SUID(4)는 파일 소유자 권한으로 실행, SGID(2)는 그룹 권한 상속, Sticky Bit(1)은 본인 파일만 삭제 가능하게 제한합니다.",
+    "example": "chmod u+s /usr/bin/passwd   # SUID\nchmod g+s /srv/shared       # SGID (공유 디렉터리)\nchmod +t /tmp               # Sticky bit\nls -la /tmp  # drwxrwxrwt 에서 t 확인",
+    "common_mistake": "SUID가 디렉터리에 붙으면 의미가 다릅니다. SGID가 디렉터리에 붙으면 생성되는 파일이 부모 그룹을 상속합니다.",
+    "keywords": [
+      "SUID",
+      "SGID",
+      "sticky bit",
+      "chmod 4755",
+      "chmod 1777"
+    ],
+    "source_id": "ubuntu-server-docs",
+    "details": [
+      "SUID 설정된 파일을 실행하면 실행한 사람이 아니라 파일 소유자 권한으로 실행됩니다. `/usr/bin/passwd`가 대표 예입니다.",
+      "SGID를 공유 디렉터리에 설정하면 그 안에 만든 파일들이 디렉터리 그룹을 자동으로 상속해 협업에 유용합니다.",
+      "시험 패턴: `ls -l`에서 `s`, `S`, `t`, `T` 표시를 보고 어떤 특수 권한인지, 또는 8진수 4자리 표기를 해석하는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-ssh",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "SSH — 원격 접속",
+    "summary": "SSH(Secure Shell)로 원격 서버에 암호화된 연결을 맺습니다. 설정 파일은 서버 쪽 `/etc/ssh/sshd_config`, 클라이언트 쪽 `~/.ssh/config`입니다.",
+    "example": "ssh alice@192.168.1.10\nssh -p 2222 user@server\nssh -i ~/.ssh/mykey.pem ubuntu@host\nsystemctl restart sshd  # 설정 변경 후 재시작",
+    "common_mistake": "`sshd_config` 변경 후 `systemctl reload sshd`를 해야 적용됩니다. 수정 전 `sshd -t`로 문법 검사를 먼저 하세요.",
+    "keywords": [
+      "ssh",
+      "sshd",
+      "sshd_config",
+      "-p",
+      "-i",
+      "PermitRootLogin"
+    ],
+    "source_id": "ubuntu-networking",
+    "details": [
+      "`sshd_config` 주요 설정: `Port`(포트 변경), `PermitRootLogin no`(root 직접 접속 차단), `PasswordAuthentication no`(키 인증만 허용).",
+      "`~/.ssh/config`에 `Host`, `HostName`, `User`, `IdentityFile`을 정의하면 `ssh 별칭`으로 간단히 접속할 수 있습니다.",
+      "시험 패턴: root 로그인 차단, 포트 변경, 키 인증 강제 등 sshd_config 보안 설정을 변경하는 문제가 자주 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-ssh-key",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "SSH 키 인증",
+    "summary": "비밀번호 없이 공개키/개인키 쌍으로 SSH 접속합니다. 개인키는 클라이언트에, 공개키는 서버의 `~/.ssh/authorized_keys`에 등록합니다.",
+    "example": "ssh-keygen -t ed25519 -C 'work key'\nssh-copy-id alice@server       # 공개키 자동 복사\ncat ~/.ssh/id_ed25519.pub      # 공개키 확인",
+    "common_mistake": "`~/.ssh/` 디렉터리는 700, `authorized_keys`는 600 권한이어야 합니다. 권한이 너무 열려 있으면 SSH가 키를 무시합니다.",
+    "keywords": [
+      "ssh-keygen",
+      "authorized_keys",
+      "ed25519",
+      "public key",
+      "private key"
+    ],
+    "source_id": "ubuntu-networking",
+    "details": [
+      "`ssh-keygen -t ed25519`로 최신 알고리즘 키 생성. 생성된 공개키(`.pub`)를 서버 `~/.ssh/authorized_keys`에 추가합니다.",
+      "디렉터리/파일 권한: `~/.ssh`=700, `authorized_keys`=600, 개인키=600. 이를 벗어나면 접속 거부됩니다.",
+      "시험 패턴: 키 생성, 공개키 배포, authorized_keys 권한 설정까지 이어지는 실습 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-hostname-hosts",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "hostname과 /etc/hosts",
+    "summary": "`hostname`으로 현재 호스트명을 확인하고, `/etc/hosts`로 DNS 없이 IP-이름 매핑을 설정합니다.",
+    "example": "hostname\nhostnamectl set-hostname webserver01\ncat /etc/hosts\necho '192.168.1.10 db.internal' >> /etc/hosts",
+    "common_mistake": "`hostname 이름`은 임시 변경입니다. 재부팅 후에도 유지하려면 `hostnamectl set-hostname`을 사용하세요.",
+    "keywords": [
+      "hostname",
+      "hostnamectl",
+      "/etc/hosts",
+      "FQDN"
+    ],
+    "source_id": "ubuntu-networking",
+    "details": [
+      "`hostnamectl set-hostname 이름`은 `/etc/hostname`을 수정해 영구 변경합니다. `hostnamectl status`로 현재 상태를 확인합니다.",
+      "`/etc/hosts`는 DNS보다 먼저 조회됩니다. 내부망 서버 이름 매핑이나 DNS 차단 테스트에 활용합니다.",
+      "시험 패턴: 서버의 호스트명을 영구 변경하거나, /etc/hosts에 항목을 추가하는 명령을 작성하는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-dns-resolve",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "DNS 조회 — dig, nslookup, resolvectl",
+    "summary": "도메인 이름을 IP로 해석하는 과정을 확인하고 문제를 진단합니다. DNS 서버는 `/etc/resolv.conf` 또는 `systemd-resolved`가 관리합니다.",
+    "example": "dig google.com\nnslookup google.com\nresolvectl status\ncat /etc/resolv.conf",
+    "common_mistake": "Ubuntu에서 `/etc/resolv.conf`는 `systemd-resolved`의 심볼릭 링크입니다. DNS 서버 변경은 `resolvectl`이나 netplan에서 합니다.",
+    "keywords": [
+      "dig",
+      "nslookup",
+      "resolv.conf",
+      "nameserver",
+      "systemd-resolved"
+    ],
+    "source_id": "ubuntu-networking",
+    "details": [
+      "`dig 도메인` 결과에서 ANSWER SECTION의 IP가 실제 해석된 주소입니다. `dig +short 도메인`으로 IP만 출력할 수 있습니다.",
+      "DNS 서버는 `/etc/resolv.conf`의 `nameserver` 줄에서 확인합니다. Ubuntu 22.04는 127.0.0.53(로컬 stub)이 기본입니다.",
+      "시험 패턴: DNS 조회 명령으로 도메인 해석 결과를 확인하거나, DNS 서버 설정 파일 위치를 묻는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-route",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "라우팅 확인 — ip route",
+    "summary": "패킷이 어느 경로로 나가는지 라우팅 테이블을 확인하고, 임시 라우트를 추가하거나 삭제합니다.",
+    "example": "ip route show\nip route add 10.0.0.0/8 via 192.168.1.1\nip route del 10.0.0.0/8\nip route get 8.8.8.8   # 특정 IP로 가는 경로",
+    "common_mistake": "`ip route add`로 추가한 라우트는 재부팅하면 사라집니다. 영�� 설정은 netplan 또는 `/etc/network/interfaces`에서 합니다.",
+    "keywords": [
+      "ip route",
+      "gateway",
+      "routing table",
+      "default",
+      "via"
+    ],
+    "source_id": "linux-man7-ip",
+    "details": [
+      "`ip route show`에서 `default via 게이트웨이IP dev 인터페이스` 줄이 기본 게이트웨이입니다.",
+      "`ip route get 목적지IP`는 실제로 그 IP에 패킷을 보낼 때 사용할 경로와 출구 인터페이스를 보여줍니다.",
+      "시험 패턴: 라우팅 테이블에서 기본 게이트웨이를 확인하거나, 특정 네트워크로 임시 라우트를 추가하는 명령을 작성하는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-netplan",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "netplan — 네트워크 설정",
+    "summary": "Ubuntu 18.04 이후 기본 네트워크 설정 도구입니다. `/etc/netplan/*.yaml` 파일에 설정하고 `netplan apply`로 적용합니다.",
+    "example": "# /etc/netplan/00-installer-config.yaml\nnetwork:\n  ethernets:\n    eth0:\n      addresses: [192.168.1.100/24]\n      gateway4: 192.168.1.1\nnetplan apply",
+    "common_mistake": "YAML은 들여쓰기(스페이스만, 탭 금지)가 매우 엄격합니다. 들여쓰기 오류 시 `netplan apply`가 실패합니다.",
+    "keywords": [
+      "netplan",
+      "yaml",
+      "static IP",
+      "gateway4",
+      "nameservers"
+    ],
+    "source_id": "ubuntu-networking",
+    "details": [
+      "`netplan generate`는 설정을 백엔드 설정 파일로 변환만 하고, `netplan apply`가 실제 네트워크에 적용합니다.",
+      "정적 IP 설정: `addresses`, `gateway4/routes`, `nameservers.addresses`를 YAML에 정의합니다.",
+      "시험 패턴: 정적 IP를 설정하거나 DNS 서버를 변경하는 netplan YAML 내용을 작성하는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-curl",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "curl — HTTP 요청과 파일 다운로드",
+    "summary": "HTTP/HTTPS 요청을 보내고 응답을 확인합니다. API 테스트, 파일 다운로드, 서비스 동작 확인에 사용합니다.",
+    "example": "curl http://localhost:8080/health\ncurl -O https://example.com/file.tar.gz\ncurl -H 'Content-Type: application/json' -d '{\"key\":\"val\"}' -X POST http://api/endpoint\ncurl -I https://example.com  # 헤더만",
+    "common_mistake": "`curl URL`은 내용을 stdout에 출력합니다. 파일로 저장하려면 `-o 파일명` 또는 URL과 같은 이름으로 저장은 `-O`를 씁니다.",
+    "keywords": [
+      "curl",
+      "-O",
+      "-o",
+      "-H",
+      "-d",
+      "-X",
+      "-I",
+      "HTTP"
+    ],
+    "source_id": "linux-man7-ip",
+    "details": [
+      "주요 옵션: `-o 파일`(저장), `-O`(원본 파일명), `-L`(리다이렉트 따라가기), `-k`(SSL 검증 무시), `-s`(silent), `-v`(상세).",
+      "`curl -I URL`은 HTTP 헤더만 확인. 상태 코드(200, 404, 301 등)로 서비스 응답을 빠르게 확인합니다.",
+      "시험 패턴: 서비스 동작 확인, 파일 다운로드, 간단한 API 요청 명령을 작성하는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-ping",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "ping — 네트워크 연결 확인",
+    "summary": "ICMP echo 요청으로 호스트에 도달 가능한지 확인합니다. 네트워크 문제 진단의 첫 번째 단계입니다.",
+    "example": "ping -c 4 8.8.8.8\nping -c 1 192.168.1.1  # 게이트웨이 확인\nping6 ::1              # IPv6 루프백",
+    "common_mistake": "방화벽이 ICMP를 차단하면 ping이 실패해도 실제로는 연결이 가능한 경우가 있습니다. ping 실패 = 서비스 장애는 아닙니다.",
+    "keywords": [
+      "ping",
+      "-c",
+      "ICMP",
+      "latency",
+      "packet loss"
+    ],
+    "source_id": "ubuntu-networking",
+    "details": [
+      "`-c 횟수`로 보낼 패킷 수를 제한합니다. 지정 않으면 Ctrl+C 누를 때까지 계속 전송합니다.",
+      "출력에서 `time=`은 RTT(왕복 시간), `packet loss %`는 패킷 손실률. 100% loss면 경로 문제 또는 방화벽 차단입니다.",
+      "시험 패턴: 특정 호스트의 연결 가능 여부 확인, `-c` 옵션으로 패킷 수 제한하는 명령이 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-cron",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "cron — 작업 스케줄링",
+    "summary": "지정한 시각이나 주기에 명령을 자동으로 실행합니다. `crontab -e`로 사용자별 스케줄을 관리합니다.",
+    "example": "crontab -e          # 편집\ncrontab -l          # 목록 확인\n# 매일 새벽 2시에 백업\n0 2 * * * /usr/local/bin/backup.sh\n# 매 5분마다\n*/5 * * * * /usr/local/bin/check.sh",
+    "common_mistake": "cron 작업에서는 PATH가 일반 쉘과 다릅니다. 명령을 절대경로로 쓰거나 스크립트 안에서 PATH를 직접 설정하세요.",
+    "keywords": [
+      "cron",
+      "crontab",
+      "-e",
+      "-l",
+      "schedule",
+      "*/5"
+    ],
+    "source_id": "ubuntu-server-docs",
+    "details": [
+      "crontab 형식: `분 시 일 월 요일 명령`. 별표(*)는 '모든 값', `*/5`는 '5마다', `0,30`은 '0과 30'을 의미합니다.",
+      "시스템 전체 cron은 `/etc/cron.d/`, `/etc/cron.daily/` 등에서 관리합니다. `/var/log/syslog`에 실행 기록이 남습니다.",
+      "시험 패턴: 특정 주기(매일, 매시간, 매 N분)로 스크립트를 실행하는 crontab 항목을 작성하는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-top",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "top — 실시간 시스템 모니터",
+    "summary": "CPU·메모리·프로세스를 실시간으로 모니터링합니다. 리소스를 많이 쓰는 프로세스를 빠르게 찾을 때 사용합니다.",
+    "example": "top\ntop -u alice    # 특정 사용자 프로세스만\ntop -bn 1       # 1회만 출력 (스크립트용)\nhtop            # 더 보기 좋은 대안",
+    "common_mistake": "`top` 실행 중 `k` 키로 PID를 입력하면 프로세스를 종료할 수 있습니다. 잘못 누르지 않도록 주의하세요.",
+    "keywords": [
+      "top",
+      "CPU",
+      "memory",
+      "load average",
+      "%MEM",
+      "%CPU"
+    ],
+    "source_id": "ubuntu-server-docs",
+    "details": [
+      "상단 요약: load average(1분/5분/15분 평균 부하), Tasks(프로세스 수), %Cpu(us/sy/id), Mem/Swap 사용량.",
+      "컬럼 의미: PID, USER, %CPU, %MEM, RES(실제 메모리), S(상태: R=실행/S=대기/Z=좀비).",
+      "시험 패턴: CPU나 메모리를 가장 많이 쓰는 프로세스 찾기, 로드 애버리지 해석, 프로세스 상태 확인 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-nice",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "nice, renice — 프로세스 우선순위",
+    "summary": "프로세스의 CPU 스케줄링 우선순위를 조정합니다. 값이 낮을수록(-20~+19) 우선순위가 높으며, 높은 우선순위 설정은 root만 가능합니다.",
+    "example": "nice -n 10 gzip big_file.gz   # 낮은 우선순위로 시작\nrenice -n -5 -p 1234          # 실행 중인 프로세스 변경\nps -o pid,ni,cmd -p 1234      # 현재 nice 값 확인",
+    "common_mistake": "nice 값이 낮을수록 우선순위가 높습니다(-20이 최고). 일반 사용자는 현재보다 낮게(낮은 우선순위로)만 변경 가능합니다.",
+    "keywords": [
+      "nice",
+      "renice",
+      "priority",
+      "niceness",
+      "-20",
+      "+19"
+    ],
+    "source_id": "ubuntu-server-docs",
+    "details": [
+      "기본 nice 값은 0. 백그라운드 배치 작업은 `nice -n 15`처럼 낮은 우선순위로 실행해 시스템 영향을 줄입니다.",
+      "`renice`로 실행 중인 프로세스의 우선순위를 바꿀 수 있습니다. `-p PID`로 프로세스, `-u 사용자`로 사용자 전체를 변경합니다.",
+      "시험 패턴: 특정 nice 값으로 프로세스를 실행하거나 실행 중인 프로세스의 우선순위를 변경하는 명령을 작성하는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-lsblk",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "lsblk — 블록 장치 확인",
+    "summary": "디스크, 파티션, LVM 등 블록 장치와 마운트 정보를 트리 형태로 보여줍니다.",
+    "example": "lsblk\nlsblk -f   # 파일시스템 타입과 UUID 포함\nblkid      # UUID와 타입 상세 확인",
+    "common_mistake": "`lsblk`는 블록 장치 구조를 보여주고, `df -h`는 마운트된 파일시스템의 사용량을 보여줍니다. 역할이 다릅니다.",
+    "keywords": [
+      "lsblk",
+      "blkid",
+      "partition",
+      "UUID",
+      "FSTYPE",
+      "block device"
+    ],
+    "source_id": "ubuntu-storage",
+    "details": [
+      "출력 컬럼: NAME(장치명), SIZE, TYPE(disk/part/lvm), MOUNTPOINT. `sda`는 디스크, `sda1`은 첫 파티션.",
+      "`lsblk -f`는 파일시스템 타입(ext4, xfs 등)과 UUID를 함께 보여줍니다. `/etc/fstab` 설정 시 UUID를 여기서 복사합니다.",
+      "시험 패턴: 마운트 가능한 파티션 목록 확인, UUID 조회, 디스크 구조 파악 문제에서 활용됩니다."
+    ]
+  },
+  {
+    "id": "linux-fstab",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "/etc/fstab — 자동 마운트 설정",
+    "summary": "부팅 시 자동으로 마운트할 파일시스템을 정의합니다. UUID, 장치명, 마운트 포인트, 파일시스템 타입, 옵션, dump/pass를 지정합니다.",
+    "example": "# UUID를 사용한 fstab 항목\nUUID=xxxx-yyyy /mnt/data ext4 defaults 0 2\n# 확인 및 테스트\nmount -a   # fstab 전체 마운트 시도",
+    "common_mistake": "fstab에 오류가 있으면 부팅 자체가 실패할 수 있습니다. 변경 후 `mount -a`로 테스트하고, UUID는 `blkid`로 확인하세요.",
+    "keywords": [
+      "fstab",
+      "UUID",
+      "mount -a",
+      "defaults",
+      "auto mount"
+    ],
+    "source_id": "ubuntu-storage",
+    "details": [
+      "fstab 형식: `장치 마운트포인트 타입 옵션 dump pass`. dump=0(백업 제외), pass=0(검사 안 함)/1(루트)/2(기타).",
+      "장치 지정은 UUID가 안전합니다. `/dev/sda1`은 디스크 추가 시 이름이 바뀔 수 있지만 UUID는 고정입니다.",
+      "시험 패턴: 특정 파티션을 부팅 시 자동 마운트하도록 fstab에 항목을 추가하는 실습 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-swap",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "swap — 스왑 관리",
+    "summary": "물리 메모리가 부족할 때 디스크 일부를 임시 메모리로 사용합니다. 스왑 파티션과 스왑 파일 두 가지 방식이 있습니다.",
+    "example": "swapon --show        # 현재 스왑 확인\nfallocate -l 2G /swapfile\nchmod 600 /swapfile\nmkswap /swapfile\nswapon /swapfile",
+    "common_mistake": "스왑 파일은 반드시 root만 읽을 수 있도록 `chmod 600`을 해야 합니다. 권한이 열려 있으면 `swapon`이 실패합니다.",
+    "keywords": [
+      "swap",
+      "swapon",
+      "swapoff",
+      "mkswap",
+      "swapfile",
+      "/proc/swaps"
+    ],
+    "source_id": "ubuntu-storage",
+    "details": [
+      "스왑 파일 생성 순서: `fallocate -l 크기 /swapfile` → `chmod 600` → `mkswap` → `swapon` → `/etc/fstab`에 추가.",
+      "영구 활성화: `/etc/fstab`에 `/swapfile none swap sw 0 0` 추가. `swapon -a`로 fstab의 스왑을 모두 활성화합니다.",
+      "시험 패턴: 특정 크기의 스왑 파일을 만들고 활성화하는 전체 과정을 작성하는 실습 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-lvm",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "LVM — 논리 볼륨 관리",
+    "summary": "물리 디스크(PV)를 볼륨 그룹(VG)으로 묶고, 그 안에 유연하게 크기를 조정할 수 있는 논리 볼륨(LV)을 만듭니다.",
+    "example": "pvcreate /dev/sdb\nvgcreate datavg /dev/sdb\nlvcreate -L 10G -n datalv datavg\nmkfs.ext4 /dev/datavg/datalv\nlvextend -L +5G /dev/datavg/datalv && resize2fs /dev/datavg/datalv",
+    "common_mistake": "`lvextend`로 LV 크기를 늘린 뒤 파일시스템도 늘려야 합니다. ext4는 `resize2fs`, xfs는 `xfs_growfs`를 씁니다.",
+    "keywords": [
+      "LVM",
+      "pvcreate",
+      "vgcreate",
+      "lvcreate",
+      "lvextend",
+      "resize2fs"
+    ],
+    "source_id": "ubuntu-storage",
+    "details": [
+      "LVM 3계층: PV(물리 볼륨, 실제 디스크/파티션) → VG(볼륨 그룹) → LV(논리 볼륨, 파일시스템이 올라가는 곳).",
+      "확장 절차: `lvextend -L +크기 /dev/VG/LV` 후 `resize2fs /dev/VG/LV`(ext4) 또는 `xfs_growfs /마운트포인트`(xfs).",
+      "시험 패턴: PV→VG→LV 생성 순서, LV 확장 후 파일시스템 확장까지 이어지는 실습 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-logs-var",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "/var/log — 시스템 로그 파일",
+    "summary": "Linux의 주요 로그 파일들은 `/var/log/`에 저장됩니다. 서비스별, 목적별로 파일이 나뉘어 있어 문제 진단의 출발점입니다.",
+    "example": "tail -f /var/log/syslog\ngrep 'ERROR' /var/log/auth.log\nls -lh /var/log/\nzcat /var/log/syslog.1.gz  # 회전된 로그",
+    "common_mistake": "`/var/log/syslog`는 일반 시스템 메시지, `/var/log/auth.log`는 인증 관련. journalctl은 이 파일이 아니라 journal을 읽습니다.",
+    "keywords": [
+      "syslog",
+      "auth.log",
+      "dmesg",
+      "/var/log",
+      "logrotate"
+    ],
+    "source_id": "ubuntu-server-docs",
+    "details": [
+      "주요 파일: `syslog`(일반 시스템), `auth.log`(SSH/sudo/PAM 인증), `kern.log`(커널), `dpkg.log`(패키지 설치/제거).",
+      "`logrotate`가 자동으로 로그를 회전합니다. 이전 로그는 `.1`, `.2` 또는 `.gz`(압축) 형태로 보관됩니다.",
+      "시험 패턴: 특정 이벤트(로그인 실패, 서비스 오류)를 해당 로그 파일에서 찾는 명령을 작성하는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-dmesg",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "dmesg — 커널 링 버퍼 로그",
+    "summary": "커널이 부팅 시와 하드웨어 이벤트 발생 시 기록하는 메시지를 출력합니다. 디스크 오류, 네트워크 인터페이스 UP/DOWN 등 하드웨어 문제 진단에 씁니다.",
+    "example": "dmesg | tail -20\ndmesg | grep -i error\ndmesg -T   # 사람이 읽을 수 있는 타임스탬프\ndmesg --level=err,warn",
+    "common_mistake": "`dmesg`는 커널 레벨 메시지만 보여줍니다. 서비스 로그는 `journalctl -u 서비스명`으로 확인하세요.",
+    "keywords": [
+      "dmesg",
+      "kernel",
+      "hardware",
+      "-T",
+      "--level",
+      "ring buffer"
+    ],
+    "source_id": "ubuntu-server-docs",
+    "details": [
+      "디스크 I/O 오류는 `dmesg | grep -i 'error\\|fail\\|sda'`로 찾을 수 있습니다.",
+      "`dmesg -T`는 타임스탬프를 사람이 읽기 쉬운 날짜 형식으로 변환합니다. 기본 출력은 부팅 이후 초 단위입니다.",
+      "시험 패턴: 시스템 부팅 오류나 하드웨어 문제를 dmesg에서 찾는 문제, 또는 로그 레벨 필터링 명령이 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-env-path",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "환경 변수와 PATH",
+    "summary": "환경 변수는 쉘과 프로세스에 설정을 전달합니다. PATH는 명령을 찾는 디렉터리 목록으로, 새 프로그램을 설치 후 PATH에 추가해야 할 수 있습니다.",
+    "example": "echo $PATH\nexport PATH=$PATH:/opt/myapp/bin\nprintenv HOME USER\nenv | grep JAVA\nunset MYVAR",
+    "common_mistake": "`export VAR=값`은 현재 쉘과 자식 프로세스에만 적용됩니다. 영구 설정은 `~/.bashrc` 또는 `/etc/environment`에 추가하세요.",
+    "keywords": [
+      "PATH",
+      "export",
+      "env",
+      "printenv",
+      "$HOME",
+      "~/.bashrc"
+    ],
+    "source_id": "linux-bash-cd",
+    "details": [
+      "`export 변수=값`으로 환경 변수를 설정하면 자식 프로세스에 전달됩니다. 없이 `변수=값`만 하면 현재 쉘에만 적용됩니다.",
+      "영구 설정 위치: 사용자별은 `~/.bashrc` 또는 `~/.profile`, 시스템 전체는 `/etc/environment` 또는 `/etc/profile`.",
+      "시험 패턴: PATH에 디렉터리를 추가하거나, 특정 환경 변수를 확인/설정하는 명령, 영구 설정 파일 위치를 묻는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-wildcard",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "와일드카드와 파일 글로빙",
+    "summary": "쉘이 패턴을 실제 파일 이름으로 확장합니다. `*`(모든 문자), `?`(한 문자), `[abc]`(문자 클래스)를 조합해 씁니다.",
+    "example": "ls *.log\nrm /tmp/test?.txt    # test1.txt, test2.txt 등\ncp /etc/[a-z]*.conf /backup/\nls {*.txt,*.md}      # brace expansion",
+    "common_mistake": "와일드카드는 쉘이 명령 실행 전에 파일 목록으로 확장합니다. 매칭되는 파일이 없으면 명령이 패턴 문자열을 그대로 인자로 받습니다.",
+    "keywords": [
+      "wildcard",
+      "glob",
+      "*",
+      "?",
+      "[]",
+      "brace expansion"
+    ],
+    "source_id": "linux-bash-cd",
+    "details": [
+      "`*`는 0개 이상의 임의 문자, `?`는 정확히 1개 문자, `[0-9]`는 범위 안의 한 문자, `[!abc]`는 제외입니다.",
+      "Brace expansion: `file{1,2,3}.txt`는 file1.txt file2.txt file3.txt로 확장됩니다. 파일이 없어도 동작합니다.",
+      "시험 패턴: 특정 패턴의 파일을 한 번에 처리하거나, 와일드카드 표현식이 어떤 파일에 매칭되는지 판단하는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-exit-code",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "exit code — 명령 종료 코드",
+    "summary": "명령 실행 후 반환하는 숫자(0~255). 0은 성공, 0이 아니면 오류. 스크립트에서 이전 명령 성공 여부를 `$?`로 확인합니다.",
+    "example": "ls /etc && echo '성공'\nls /없는경로 || echo '실패'\necho $?\ncommand; [ $? -eq 0 ] && echo ok",
+    "common_mistake": "`$?`는 바로 직전 명령의 종료 코드만 담습니다. 다른 명령 실행 후 이전 `$?`를 참조하려면 변수에 저장해야 합니다.",
+    "keywords": [
+      "exit code",
+      "$?",
+      "&&",
+      "||",
+      "return code",
+      "0=success"
+    ],
+    "source_id": "linux-bash-cd",
+    "details": [
+      "`&&`는 앞 명령이 성공(exit 0)할 때만 뒤를 실행. `||`는 실패(exit ≠0)할 때만 뒤를 실행합니다.",
+      "자주 보는 코드: 0=성공, 1=일반 오류, 2=명령 오용, 126=실행 권한 없음, 127=명령 없음, 130=Ctrl+C.",
+      "시험 패턴: `&&`와 `||`로 조건부 실행을 작성하거나, `$?` 값으로 이전 명령 성공 여부를 판단하는 스크립트 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-service-port",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "서비스와 포트 연결",
+    "summary": "실행 중인 서비스가 어느 포트를 열고 있는지 확인하고, 방화벽 설정과 함께 포트 접근을 제어합니다.",
+    "example": "ss -tlnp | grep 80\ncat /etc/services | grep ssh\nlsof -i :443\nufw allow 80/tcp",
+    "common_mistake": "포트를 열었어도 방화벽(ufw/firewalld)이 차단하면 외부에서 접근할 수 없습니다. 서비스와 방화벽을 함께 확인하세요.",
+    "keywords": [
+      "ss",
+      "lsof",
+      "/etc/services",
+      "port",
+      "firewall",
+      "ufw"
+    ],
+    "source_id": "ubuntu-networking",
+    "details": [
+      "`ss -tlnp`는 TCP 리스닝 포트와 서비스를 보여줍니다. `lsof -i :포트`는 해당 포트를 사용하는 프로세스를 찾습니다.",
+      "`/etc/services`는 포트 번호와 서비스 이름 매핑 파일입니다. 22=ssh, 80=http, 443=https, 3306=mysql.",
+      "시험 패턴: 특정 포트를 리스닝하는 서비스 확인, 방화벽에서 포트 개방, 서비스 포트 번호를 조회하는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-apt",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "apt — 패키지 관리",
+    "summary": "Ubuntu/Debian 계열의 패키지 관리 도구입니다. 패키지 설치, 업데이트, 검색, 삭제를 담당합니다.",
+    "example": "apt update && apt upgrade -y\napt install nginx\napt search 'web server'\napt show nginx\napt list --installed | grep nginx",
+    "common_mistake": "`apt install` 전에 `apt update`를 먼저 실행해야 최신 패키지 목록에서 설치됩니다. update 없이 설치하면 구버전이 설치될 수 있습니다.",
+    "keywords": [
+      "apt",
+      "apt update",
+      "apt install",
+      "apt upgrade",
+      "dpkg"
+    ],
+    "source_id": "ubuntu-package-management",
+    "details": [
+      "`apt update`는 패키지 목록만 갱신, `apt upgrade`는 실제 업데이트 설치. 항상 update → upgrade 순서로 실행합니다.",
+      "`dpkg -l | grep 패키지`로 설치 여부 확인, `dpkg -L 패키지`로 설치된 파일 목록을 볼 수 있습니다.",
+      "시험 패턴: 특정 패키지 설치, 설치 여부 확인, 모든 패키지 업데이트하는 명령을 작성하는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-repo",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "APT 저장소 관리",
+    "summary": "패키지를 다운로드하는 저장소(repository) 목록을 관리합니다. `/etc/apt/sources.list` 또는 `/etc/apt/sources.list.d/`에 저장소를 추가합니다.",
+    "example": "cat /etc/apt/sources.list\nadd-apt-repository ppa:name/repo\napt-key add key.gpg    # 구식\ncurl -fsSL URL | gpg --dearmor > /etc/apt/keyrings/key.gpg",
+    "common_mistake": "외부 저장소를 추가할 때 GPG 키도 함께 등록해야 합니다. 키 없이 저장소만 추가하면 `apt update` 시 서명 오류가 납니다.",
+    "keywords": [
+      "sources.list",
+      "PPA",
+      "repository",
+      "gpg",
+      "apt-key",
+      "add-apt-repository"
+    ],
+    "source_id": "ubuntu-package-management",
+    "details": [
+      "`/etc/apt/sources.list.d/`에 개별 `.list` 파일을 넣는 방식이 관리가 쉽습니다. 주 sources.list는 가급적 수정하지 않습니다.",
+      "최신 방식은 GPG 키를 `/etc/apt/keyrings/`에 저장하고 sources 파일에서 `signed-by=` 옵션으로 참조합니다.",
+      "시험 패턴: 저장소 추가 후 `apt update`, 패키지 설치까지 이어지는 절차를 작성하는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-remove-purge",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "패키지 제거 — remove와 purge",
+    "summary": "`apt remove`는 패키지 바이너리만 제거하고 설정 파일은 남깁니다. `apt purge`는 설정 파일까지 완전히 제거합니다.",
+    "example": "apt remove nginx\napt purge nginx\napt autoremove   # 의존성으로만 설치된 불필요 패키지 제거\ndpkg --list | grep ^rc  # 설정 남은 제거된 패키지",
+    "common_mistake": "`remove` 후 재설치하면 이전 설정 파일이 남아 있어 예상치 못한 동작을 할 수 있습니다. 깨끗이 제거하려면 `purge`를 씁니다.",
+    "keywords": [
+      "apt remove",
+      "apt purge",
+      "autoremove",
+      "dpkg --purge"
+    ],
+    "source_id": "ubuntu-package-management",
+    "details": [
+      "`apt autoremove`는 다른 패키지의 의존성으로 설치됐다가 더 이상 필요 없는 패키지들을 자동으로 제거합니다.",
+      "`dpkg --list | grep '^rc'`로 바이너리는 지워졌지만 설정 파일이 남은 패키지를 찾을 수 있습니다.",
+      "시험 패턴: 패키지를 설정 파일까지 완전히 제거하거나, 불필요 의존성을 정리하는 명령을 작성하는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-ufw",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "ufw — 방화벽 관리",
+    "summary": "Ubuntu의 간단한 방화벽 관리 도구입니다. iptables 위에서 동작하며 서비스 이름이나 포트로 규칙을 추가할 수 있습니다.",
+    "example": "ufw status verbose\nufw enable\nufw allow 22/tcp\nufw allow 'Nginx Full'\nufw deny 3306\nufw delete allow 80",
+    "common_mistake": "`ufw enable` 전에 반드시 SSH 포트(22)를 허용하세요. 순서를 바꾸면 SSH 연결이 끊겨 서버에 접근하지 못합니다.",
+    "keywords": [
+      "ufw",
+      "enable",
+      "allow",
+      "deny",
+      "status",
+      "firewall"
+    ],
+    "source_id": "ubuntu-firewall",
+    "details": [
+      "규칙 추가 형식: `ufw allow/deny 포트/프로토콜` 또는 `ufw allow 'Apache'`처럼 사전 정의된 애플리케이션 프로필 사용.",
+      "`ufw status numbered`로 번호가 붙은 규칙 목록 확인 후 `ufw delete 번호`로 특정 규칙을 삭제합니다.",
+      "시험 패턴: 특정 포트 개방/차단, SSH는 허용하면서 불필요한 포트 차단, 방화벽 상태 확인 명령이 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-head-tail",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "head, tail — 파일 앞뒤 확인",
+    "summary": "`head`는 파일 처음 N줄, `tail`은 마지막 N줄을 출력합니다. `tail -f`는 로그 파일에 추가되는 내용을 실시간으로 추적합니다.",
+    "example": "head -n 20 /etc/passwd\ntail -n 50 /var/log/syslog\ntail -f /var/log/nginx/error.log\ntail -f /var/log/syslog | grep ERROR",
+    "common_mistake": "`head`는 파일 시작, `tail`은 파일 끝에서 읽습니다. `-n` 없이 쓰면 기본 10줄을 출력합니다.",
+    "keywords": [
+      "head",
+      "tail",
+      "-n",
+      "-f",
+      "log",
+      "follow"
+    ],
+    "source_id": "linux-bash-manual",
+    "details": [
+      "`tail -f`는 파일에 새로 추가되는 내용을 실시간으로 보여줍니다. 서비스 로그 모니터링 시 가장 많이 씁니다.",
+      "`tail -n +5`는 5번째 줄부터 끝까지 출력합니다. 헤더 행을 건너뛸 때 활용합니다.",
+      "시험 패턴: 로그 마지막 N줄 확인, 실시간 로그 추적, 파이프로 grep과 연결하는 명령이 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-sed",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "sed — 스트림 편집기",
+    "summary": "파일이나 파이프 입력에서 패턴을 찾아 교체·삭제·출력합니다. 설정 파일 자동 수정과 텍스트 변환 스크립트에 필수입니다.",
+    "example": "sed 's/old/new/g' file.txt\nsed -i 's/localhost/127.0.0.1/g' nginx.conf\nsed -n '5,10p' file.txt    # 5~10줄만 출력\nsed '/^#/d' config.txt     # 주석 줄 삭제",
+    "common_mistake": "`-i` 없이는 원본을 수정하지 않고 stdout으로만 출력합니다. `-i.bak`으로 원본을 백업하면서 수정할 수 있습니다.",
+    "keywords": [
+      "sed",
+      "s/old/new/g",
+      "-i",
+      "stream editor",
+      "substitute",
+      "delete"
+    ],
+    "source_id": "linux-bash-manual",
+    "details": [
+      "치환 명령: `s/패턴/교체/g`. `g` 플래그 없으면 줄당 첫 번째만, `I` 플래그는 대소문자 무시.",
+      "줄 단위 작업: `Nd`(N번 줄 삭제), `Np`(N번 줄만 출력, `-n`과 함께), `/패턴/d`(패턴 줄 삭제).",
+      "시험 패턴: 설정 파일에서 값을 치환하거나(`-i`), 특정 줄을 출력/삭제하는 명령을 작성하는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-text-pipeline",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "텍스트 처리 — cut, sort, uniq, wc",
+    "summary": "텍스트 파이프라인을 구성하는 핵심 도구들입니다. 필드 추출(cut), 정렬(sort), 중복 제거(uniq), 줄/단어 수 세기(wc)를 파이프로 연결합니다.",
+    "example": "cut -d':' -f1 /etc/passwd | sort | uniq\nwc -l /var/log/syslog\ncat access.log | cut -d' ' -f1 | sort | uniq -c | sort -rn | head -10",
+    "common_mistake": "`uniq`는 연속된 중복만 제거합니다. 전체 중복 제거를 위해서는 반드시 `sort` 후 `uniq`를 써야 합니다.",
+    "keywords": [
+      "cut",
+      "sort",
+      "uniq",
+      "wc",
+      "-d",
+      "-f",
+      "-c",
+      "-rn"
+    ],
+    "source_id": "linux-bash-manual",
+    "details": [
+      "`cut -d구분자 -f필드번호`: 콜론 구분자에서 1번 필드 → `cut -d':' -f1`. 여러 필드는 `-f1,3` 또는 `-f1-3`.",
+      "`sort -rn`: r=역순, n=숫자 정렬. `uniq -c`는 중복 개수를 앞에 붙여 줍니다.",
+      "시험 패턴: 로그에서 상위 접속 IP 추출, 중복 제거 후 정렬, 줄 수 세기 등 파이프라인을 조합하는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-awk",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "awk — 필드 기반 텍스트 처리",
+    "summary": "공백이나 지정 구분자로 나뉜 필드를 처리합니다. `cut`보다 강력하며 조건문, 연산, 합산이 가능합니다.",
+    "example": "awk '{print $1, $3}' access.log\nawk -F':' '{print $1}' /etc/passwd\nawk '$3 > 1000 {print $1}' /etc/passwd\nps aux | awk '{print $1, $11}' | head",
+    "common_mistake": "awk에서 `$0`은 줄 전체, `$1`은 첫 번째 필드입니다. `-F`로 구분자를 바꾸지 않으면 기본으로 공백/탭이 구분자입니다.",
+    "keywords": [
+      "awk",
+      "-F",
+      "$1",
+      "NR",
+      "NF",
+      "print",
+      "field"
+    ],
+    "source_id": "linux-bash-manual",
+    "details": [
+      "기본 패턴: `awk '조건 {동작}' 파일`. 조건 없이 `{print $2}`만 쓰면 모든 줄에서 2번째 필드를 출력합니다.",
+      "내장 변수: `NR`=현재 줄 번호, `NF`=필드 개수. `NR==1`은 첫 번째 줄만, `$NF`는 마지막 필드입니다.",
+      "시험 패턴: 특정 필드만 출력하거나, 조건에 맞는 줄만 출력하는 awk 명령을 작성하는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-ln-symlink",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "ln — 하드 링크와 심볼릭 링크",
+    "summary": "심볼릭 링크(`ln -s`)는 원본 파일의 경로를 가리키는 포인터입니다. 하드 링크는 같은 inode를 직접 참조합니다.",
+    "example": "ln -s /etc/nginx/nginx.conf ~/nginx.conf\nln /data/file.txt /backup/file.txt  # 하드 링크\nls -la ~/nginx.conf   # -> 원본 경로 표시\nreadlink -f ~/nginx.conf  # 실제 경로 확인",
+    "common_mistake": "심볼릭 링크는 원본이 삭제되면 끊긴 링크(dangling symlink)가 됩니다. 하드 링크는 원본 삭제 후에도 데이터가 유지됩니다.",
+    "keywords": [
+      "ln",
+      "-s",
+      "symlink",
+      "hard link",
+      "inode",
+      "readlink"
+    ],
+    "source_id": "linux-bash-manual",
+    "details": [
+      "심볼릭 링크: `ln -s 원본경로 링크경로`. `ls -la`에서 `l`로 시작하며 `->` 뒤에 원본 경로가 표시됩니다.",
+      "하드 링크는 같은 파티션 내에서만 가능, 디렉터리에는 사용 불가. 심볼릭 링크는 파티션과 디렉터리 모두 가능합니다.",
+      "시험 패턴: 특정 경로에 심볼릭 링크를 만들거나, 링크 타입을 `ls -la`로 구별하는 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-bg-fg-jobs",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "백그라운드 작업 — jobs, bg, fg, nohup",
+    "summary": "터미널을 블록하지 않고 명령을 백그라운드에서 실행합니다. `&`로 시작, `Ctrl+Z`로 일시 정지, `fg`/`bg`로 전환합니다.",
+    "example": "long_task.sh &          # 백그라운드 시작\njobs -l                 # 작업 목록\nfg %1                   # 1번 작업 포그라운드 복귀\nnohup ./script.sh &     # 터미널 닫혀도 계속 실행",
+    "common_mistake": "`&`로 실행한 작업은 터미널을 닫으면 종료됩니다. 터미널 종료 후에도 계속 실행하려면 `nohup`을 함께 써야 합니다.",
+    "keywords": [
+      "jobs",
+      "bg",
+      "fg",
+      "nohup",
+      "&",
+      "Ctrl+Z",
+      "SIGHUP"
+    ],
+    "source_id": "linux-bash-cd",
+    "details": [
+      "`Ctrl+Z`는 현재 프로세스에 SIGTSTP를 보내 일시 정지. `bg`로 백그라운드 재개, `fg`로 포그라운드 복귀.",
+      "`nohup 명령 &`: SIGHUP 시그널을 무시하므로 터미널 종료 후에도 실행 유지. 출력은 기본으로 `nohup.out`에 저장됩니다.",
+      "시험 패턴: 작업을 백그라운드로 보내거나 복귀시키는 명령, nohup 사용 시나리오 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-shell-script-basics",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "쉘 스크립트 기초",
+    "summary": "반복 작업을 자동화하는 배시 스크립트를 작성합니다. shebang 라인, 변수, 조건문, 반복문, 함수가 핵심 요소입니다.",
+    "example": "#!/bin/bash\nset -euo pipefail\nBACKUP_DIR=/backup\n[ -d $BACKUP_DIR ] || mkdir -p $BACKUP_DIR\nfor f in /etc/*.conf; do\n  cp $f $BACKUP_DIR/\ndone",
+    "common_mistake": "`#!/bin/bash`(shebang)가 없으면 `/bin/sh`로 실행돼 bash 전용 문법이 오류납니다. 실행 권한(`chmod +x`)도 반드시 확인하세요.",
+    "keywords": [
+      "shebang",
+      "#!/bin/bash",
+      "if",
+      "for",
+      "while",
+      "function",
+      "chmod +x"
+    ],
+    "source_id": "linux-bash-cd",
+    "details": [
+      "`set -euo pipefail`: `-e`(에러 시 즉시 종료), `-u`(미정의 변수 사용 시 에러), `-o pipefail`(파이프 중간 실패 감지). 스크립트 상단에 권장됩니다.",
+      "조건 확인: `[ -f 파일 ]`(파일 존재), `[ -d 디렉터리 ]`(디렉터리 존재), `[ $var -eq 1 ]`(숫자 비교), `[[ $str == 'a' ]]`(문자열).",
+      "시험 패턴: 특정 조건에 따라 분기하는 if문, 파일 목록을 처리하는 for 루프, 함수 정의 등 스크립트 작성 문제가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-cp-mv-rm",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "cp, mv, rm — 파일 복사·이동·삭제",
+    "summary": "파일과 디렉터리를 복사(`cp`), 이동/이름변경(`mv`), 삭제(`rm`)합니다. 각 옵션의 조합이 시험에서 시나리오 형태로 출제됩니다.",
+    "example": "cp -a /etc/nginx /backup/nginx.bak   # 권한·타임스탬프 보존 복사\nmv config.txt config.bak             # 이름 변경\nrm -rf /tmp/old_build/               # 디렉터리 강제 삭제",
+    "common_mistake": "`cp -r`은 디렉터리를 복사하지만 권한과 타임스탬프를 보존하지 않습니다. 백업 목적이라면 반드시 `cp -a`를 사용하세요.",
+    "keywords": [
+      "cp",
+      "mv",
+      "rm",
+      "-a",
+      "-r",
+      "-i",
+      "-f",
+      "백업"
+    ],
+    "source_id": "manual-linux-basic",
+    "details": [
+      "**`cp` 핵심 옵션**: `-r`(디렉터리 재귀), `-a`(archive: `-dR --preserve=all`, 백업 시 표준), `-i`(덮어쓰기 전 확인), `-p`(권한·타임스탬프 보존).",
+      "**`mv`**: 같은 파일시스템 내 이동은 inode만 갱신해 빠릅니다. 다른 파티션 간 이동은 실제 복사 후 삭제가 일어납니다.",
+      "**시험 패턴**: '퍼미션을 유지하면서 백업' → `cp -a`, '실수 없이 삭제' → `rm -i`, 'force 삭제' → `rm -f`."
+    ]
+  },
+  {
+    "id": "linux-fdisk-parted",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "fdisk, parted — 디스크 파티셔닝",
+    "summary": "새 디스크를 사용하기 전 파티션 테이블을 만들고 파티션을 나눕니다. MBR은 `fdisk`, GPT(2TB 이상)는 `parted` 또는 `gdisk`를 사용합니다.",
+    "example": "fdisk /dev/sdb          # MBR 파티션 인터랙티브 편집\n# n(새 파티션) → p → 1 → Enter → +20G → w(저장)\nparted /dev/sdc mklabel gpt\nparted /dev/sdc mkpart primary ext4 1MiB 21GiB",
+    "common_mistake": "`fdisk`는 파티션 테이블을 변경해도 `w`로 저장하기 전까지 디스크에 기록되지 않습니다. 또한 2TB 초과 디스크에는 MBR(fdisk) 대신 GPT(parted/gdisk)를 사용해야 합니다.",
+    "keywords": [
+      "fdisk",
+      "parted",
+      "gdisk",
+      "MBR",
+      "GPT",
+      "partition table",
+      "lsblk"
+    ],
+    "source_id": "manual-linux-storage",
+    "details": [
+      "**파티션 테이블 유형**: MBR(최대 4 주파티션, 2TB 한계), GPT(최대 128 파티션, 사실상 무제한 용량).",
+      "**fdisk 흐름**: `n`(새 파티션) → 유형 선택(p/e) → 번호 → 시작/끝 섹터(또는 `+20G`) → `w`(저장 후 종료). `p`로 현재 상태 확인.",
+      "**시험 패턴**: lsblk로 장치 확인 → fdisk로 파티션 생성 → mkfs로 포맷 → mount 순서가 전체 스토리지 설정 흐름으로 자주 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-mkfs-fsck",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "mkfs, fsck — 파일시스템 생성과 검사",
+    "summary": "파티션에 파일시스템을 생성(`mkfs`)하고 오류를 검사·수정(`fsck`)합니다. 포맷 후 마운트해야 실제로 사용할 수 있습니다.",
+    "example": "mkfs.ext4 /dev/sdb1           # ext4 파일시스템 생성\nmkfs.xfs /dev/sdb2            # XFS 파일시스템 생성\numount /dev/sdb1 && fsck /dev/sdb1   # 검사 전 반드시 언마운트",
+    "common_mistake": "`fsck`는 마운트된 파일시스템에서 실행하면 데이터가 손상될 수 있습니다. 반드시 언마운트하거나 싱글 유저 모드에서 실행해야 합니다.",
+    "keywords": [
+      "mkfs",
+      "mkfs.ext4",
+      "mkfs.xfs",
+      "fsck",
+      "e2fsck",
+      "tune2fs",
+      "파일시스템"
+    ],
+    "source_id": "manual-linux-storage",
+    "details": [
+      "**주요 파일시스템**: ext4(리눅스 기본, 저널링), xfs(대용량·고성능, RHEL 기본), btrfs(스냅샷·서브볼륨 지원).",
+      "**`tune2fs -l /dev/sdb1`**: ext4 파일시스템 메타데이터(UUID, 마운트 횟수, 생성일 등)를 확인합니다. UUID는 fstab 설정 시 필요합니다.",
+      "**시험 패턴**: 파티션 생성 후 mkfs → UUID 확인(`blkid`) → fstab에 등록 → mount -a 순서가 통합 스토리지 시나리오로 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-groupadd",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "groupadd, groupmod, groupdel — 그룹 관리",
+    "summary": "그룹을 생성(`groupadd`), 수정(`groupmod`), 삭제(`groupdel`)합니다. 사용자를 보조 그룹에 추가하는 `usermod -aG`와 함께 사용합니다.",
+    "example": "groupadd developers           # 그룹 생성\ngroupmod -n devops developers  # 그룹 이름 변경\nusermod -aG developers alice   # alice를 developers 그룹에 추가\ngetent group developers        # 그룹 멤버 확인",
+    "common_mistake": "`groupdel`은 해당 그룹이 누군가의 기본 그룹(primary group)이면 삭제할 수 없습니다. 먼저 그 사용자의 기본 그룹을 변경해야 합니다.",
+    "keywords": [
+      "groupadd",
+      "groupmod",
+      "groupdel",
+      "usermod -aG",
+      "/etc/group",
+      "GID"
+    ],
+    "source_id": "ubuntu-user-management",
+    "details": [
+      "**`/etc/group` 구조**: `그룹명:암호:GID:멤버목록` 형식. `getent group <이름>`으로 특정 그룹 정보를 확인합니다.",
+      "**보조 그룹 추가**: `usermod -aG groupname username`. `-a`(append) 없이 `-G`만 쓰면 기존 보조 그룹이 교체됩니다.",
+      "**시험 패턴**: 새 팀 생성 → 그룹 만들기 → 여러 사용자를 그룹에 추가 → 그룹 공유 디렉터리에 SGID 설정하는 복합 시나리오가 자주 나옵니다."
+    ]
+  },
+  {
+    "id": "linux-chage",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "chage — 비밀번호 만료 정책",
+    "summary": "사용자 계정의 비밀번호 만료일, 최대 사용 기간, 경고 기간을 설정합니다. 보안 정책 적용과 계정 만료 시나리오에서 출제됩니다.",
+    "example": "chage -l alice              # 현재 만료 정책 확인\nchage -M 90 alice           # 최대 90일마다 변경 강제\nchage -E 2025-12-31 alice   # 계정 만료일 설정\nchage -d 0 alice            # 다음 로그인 시 즉시 비밀번호 변경 강제",
+    "common_mistake": "`chage -d 0`은 마지막 비밀번호 변경일을 에포크(1970-01-01)로 설정해 다음 로그인 시 즉시 변경하게 합니다. `-E 0`은 계정을 즉시 만료시켜 로그인 자체를 차단합니다.",
+    "keywords": [
+      "chage",
+      "-l",
+      "-M",
+      "-E",
+      "-d",
+      "/etc/shadow",
+      "password aging"
+    ],
+    "source_id": "ubuntu-user-management",
+    "details": [
+      "**주요 옵션**: `-M`(최대 사용일), `-m`(최소 사용일), `-W`(만료 전 경고일), `-I`(만료 후 비활성화 유예일), `-E`(계정 만료일), `-d`(마지막 변경일).",
+      "**`/etc/shadow`에 저장**: 만료 정책은 shadow 파일에 콜론으로 구분된 필드로 저장됩니다. `chage`는 이 파일을 안전하게 편집하는 래퍼입니다.",
+      "**시험 패턴**: '신규 사용자가 첫 로그인 시 비밀번호를 변경하게' → `chage -d 0`, '90일마다 변경 강제' → `chage -M 90` 형태로 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-systemd-unit",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "systemd 서비스 유닛 파일 작성",
+    "summary": "커스텀 프로세스를 systemd 서비스로 등록해 부팅 시 자동 시작하고 재시작 정책을 적용합니다. `/etc/systemd/system/`에 `.service` 파일을 작성합니다.",
+    "example": "# /etc/systemd/system/myapp.service\n[Unit]\nDescription=My Application\nAfter=network.target\n\n[Service]\nExecStart=/usr/local/bin/myapp\nRestart=on-failure\nUser=myapp\n\n[Install]\nWantedBy=multi-user.target\n\nsystemctl daemon-reload && systemctl enable --now myapp",
+    "common_mistake": "유닛 파일을 수정한 후 `systemctl daemon-reload` 없이 재시작하면 변경 사항이 반영되지 않습니다. 파일 수정 후에는 항상 daemon-reload가 먼저입니다.",
+    "keywords": [
+      "service unit",
+      "ExecStart",
+      "WantedBy",
+      "daemon-reload",
+      "enable",
+      "After",
+      "Restart"
+    ],
+    "source_id": "manual-linux-systemd",
+    "details": [
+      "**[Unit] 섹션**: `Description`(설명), `After`(이 유닛보다 늦게 시작), `Requires`(의존성, 없으면 실패).",
+      "**[Service] 섹션**: `ExecStart`(실행 명령), `Restart=on-failure`(실패 시 재시작), `User`(실행 계정), `Environment`(환경 변수).",
+      "**시험 패턴**: 스크립트를 서비스로 등록 → 부팅 시 자동 시작 설정 → 재시작 정책 적용의 전체 흐름, daemon-reload 누락 오류 진단이 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-at",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "at — 일회성 작업 스케줄링",
+    "summary": "cron이 반복 작업용이라면 `at`은 특정 시각에 한 번만 실행하는 명령에 사용합니다. 대화형으로 명령을 입력하거나 파이프로 전달합니다.",
+    "example": "echo 'tar -czf /backup/home.tar.gz /home' | at 02:00\nat now + 2 hours << 'EOF'\n/usr/local/bin/report.sh\nEOF\natq          # 예약 목록 확인\natrm 3       # 3번 작업 취소",
+    "common_mistake": "`at`은 cron과 달리 환경 변수가 최소화된 상태로 실행됩니다. 스크립트에 절대 경로를 사용하거나 환경 변수를 명시적으로 설정해야 합니다.",
+    "keywords": [
+      "at",
+      "atq",
+      "atrm",
+      "at now",
+      "batch",
+      "일회성 스케줄"
+    ],
+    "source_id": "manual-linux-basic",
+    "details": [
+      "**시간 표현**: `at 14:30`, `at now + 1 hour`, `at midnight`, `at noon`, `at 2:00 tomorrow`.",
+      "**`batch`**: 시스템 부하가 낮을 때 명령을 실행. at의 변형으로, 부하 기반 스케줄링이 필요할 때 사용합니다.",
+      "**시험 패턴**: cron vs at 선택 기준(반복 vs 일회성), 특정 시각 후 실행 예약, atq로 대기열 확인, atrm으로 취소하는 시나리오가 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-docker-basics",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "Docker — 컨테���너 기초",
+    "summary": "2023년 개편된 LFCS에 컨테이너 관리가 추가됐습니다. 이미지 pull, 컨테이너 실행·중지·삭제, 로그 확인 등 기본 라이프사이클을 다룹니다.",
+    "example": "docker pull nginx:latest\ndocker run -d -p 8080:80 --name webserver nginx\ndocker ps                          # 실행 중인 컨테이너 목록\ndocker logs webserver\ndocker stop webserver && docker rm webserver",
+    "common_mistake": "`docker stop`은 SIGTERM으로 정상 종료를 요청하고, `docker kill`은 SIGKILL로 강제 종료합니다. 데이터 일관성을 위해 가능하면 `stop`을 사용하세요.",
+    "keywords": [
+      "docker",
+      "pull",
+      "run",
+      "ps",
+      "stop",
+      "rm",
+      "logs",
+      "images",
+      "-d",
+      "-p"
+    ],
+    "source_id": "manual-linux-docker",
+    "details": [
+      "**`docker run` 주요 옵션**: `-d`(백그라운드), `-p 호스트:컨테이너`(포트 매핑), `-v`(볼륨 마운트), `--name`(이름 지정), `--rm`(종료 시 자동 삭제).",
+      "**이미지 vs 컨테이너**: `docker images`(로컬 이미지 목록), `docker ps -a`(중지된 것 포함 전체 컨테이너). `docker rmi`로 이미지, `docker rm`으로 컨테이너를 삭제합니다.",
+      "**시험 패턴**: 이미지 pull → 포트 매핑해 백그라운드 실행 → 로그 확인 → 중지 후 삭제 흐름, 컨테이너 내부 접근(`docker exec -it`)이 출제됩니다."
+    ]
+  },
+  {
+    "id": "linux-grub-boot",
+    "certification": "LFCS / 리눅스마스터",
+    "title": "부팅 프로세스와 GRUB",
+    "summary": "BIOS/UEFI → GRUB → 커널 → initramfs → systemd 순으로 부팅됩니다. GRUB 설정을 수정하고 복구 모드로 진입하는 방법이 시험에 출제됩니다.",
+    "example": "# GRUB 기본 설정 수정\nvim /etc/default/grub\n# GRUB_TIMEOUT=5, GRUB_CMDLINE_LINUX=\"quiet splash\"\nupdate-grub                    # Ubuntu (grub2-mkconfig -o /boot/grub2/grub.cfg on RHEL)\nsystemctl get-default          # 현재 기본 target 확인\nsystemctl set-default multi-user.target",
+    "common_mistake": "`/etc/default/grub`을 수정해도 `update-grub`(Ubuntu) 또는 `grub2-mkconfig`(RHEL)을 실행하지 않으면 실제 부트로더 설정에 반영되지 않습니다.",
+    "keywords": [
+      "GRUB",
+      "update-grub",
+      "grub2-mkconfig",
+      "systemd target",
+      "initramfs",
+      "boot"
+    ],
+    "source_id": "manual-linux-boot",
+    "details": [
+      "**부팅 순서**: BIOS/UEFI → MBR/ESP의 GRUB → `/boot/grub/grub.cfg` 로드 → 커널+initramfs 메모리 적재 → systemd PID 1 시작.",
+      "**systemd target**: `multi-user.target`(CLI, runlevel 3), `graphical.target`(GUI, runlevel 5), `rescue.target`(단일 사용자 복구).",
+      "**시험 패턴**: 부팅 실패 시 GRUB에서 커널 파라미터 수정(e키), 기본 target 변경, `update-grub` 실행 타이밍이 자주 출제됩니다."
+    ]
+  }
+]

cert_study_app/content/linux/practices.json

@@ -0,0 +1,428 @@
+[
+  {
+    "id": "linux-lab-31",
+    "title": "로그 마지막 20줄 확인",
+    "task_description": "`/var/log/syslog` 파일의 마지막 20줄을 확인하세요.",
+    "expected_command": "tail -n 20 /var/log/syslog",
+    "grading_conditions": [
+      "tail",
+      "-n",
+      "20",
+      "/var/log/syslog"
+    ],
+    "hint": "tail에 -n 옵션으로 출력할 줄 수를 지정할 수 있습니다.",
+    "explanation": "`tail -n 20 /var/log/syslog`는 파일의 마지막 20줄을 출력합니다.",
+    "difficulty": "easy"
+  },
+  {
+    "id": "linux-lab-32",
+    "title": "로그 파일 실시간 추적",
+    "task_description": "`/var/log/syslog` 파일에 추가되는 내용을 실시간으로 추적하세요.",
+    "expected_command": "tail -f /var/log/syslog",
+    "grading_conditions": [
+      "tail",
+      "-f",
+      "/var/log/syslog"
+    ],
+    "hint": "`-f` 옵션은 follow의 약자로 파일 끝을 실시간으로 추적합니다.",
+    "explanation": "`tail -f /var/log/syslog`는 파일에 추가되는 내용을 실시간으로 계속 출력합니다.",
+    "difficulty": "easy"
+  },
+  {
+    "id": "linux-lab-33",
+    "title": "파일 상위 10줄 확인",
+    "task_description": "`/etc/passwd` 파일의 처음 10줄을 확인하세요.",
+    "expected_command": "head /etc/passwd",
+    "grading_conditions": [
+      "head",
+      "/etc/passwd"
+    ],
+    "hint": "head는 기본으로 처음 10줄을 출력합니다.",
+    "explanation": "`head /etc/passwd`는 파일의 처음 10줄을 출력합니다. `-n`으로 줄 수를 지정할 수도 있습니다.",
+    "difficulty": "easy"
+  },
+  {
+    "id": "linux-lab-34",
+    "title": "sed로 텍스트 교체",
+    "task_description": "`config.txt`에서 `old_value`를 `new_value`로 모두 교체해 출력하세요.",
+    "expected_command": "sed 's/old_value/new_value/g' config.txt",
+    "grading_conditions": [
+      "sed",
+      "old_value",
+      "new_value",
+      "config.txt"
+    ],
+    "hint": "`s/패턴/교체/g` 형태로 교체 명령을 작성합니다. `g`는 한 줄에서 모두 교체합니다.",
+    "explanation": "`sed 's/old_value/new_value/g' config.txt`는 파일에서 old_value를 모두 new_value로 교체해 출력합니다.",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-lab-35",
+    "title": "sed 인플레이스 수정",
+    "task_description": "`nginx.conf`에서 `localhost`를 `127.0.0.1`로 직접 수정하세요.",
+    "expected_command": "sed -i 's/localhost/127.0.0.1/g' nginx.conf",
+    "grading_conditions": [
+      "sed",
+      "-i",
+      "localhost",
+      "127.0.0.1",
+      "nginx.conf"
+    ],
+    "hint": "`-i` 옵션은 표준 출력 대신 파일을 직접 수정합니다.",
+    "explanation": "`sed -i 's/localhost/127.0.0.1/g' nginx.conf`는 nginx.conf 파일을 직접 수정합니다.",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-lab-36",
+    "title": "cut으로 사용자 이름 추출",
+    "task_description": "`/etc/passwd`에서 콜론(`:`) 구분자의 첫 번째 필드(사용자 이름)만 추출하세요.",
+    "expected_command": "cut -d':' -f1 /etc/passwd",
+    "grading_conditions": [
+      "cut",
+      "-d",
+      "-f1",
+      "/etc/passwd"
+    ],
+    "hint": "`-d`로 구분자를, `-f`로 출력할 필드를 지정합니다.",
+    "explanation": "`cut -d':' -f1 /etc/passwd`는 콜론 구분자에서 첫 번째 필드(사용자 이름)를 추출합니다.",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-lab-37",
+    "title": "sort와 uniq으로 중복 제거",
+    "task_description": "`access.log`에서 중복 줄을 제거하고 알파벳 순으로 정렬해 출력하세요.",
+    "expected_command": "sort access.log | uniq",
+    "grading_conditions": [
+      "sort",
+      "access.log",
+      "uniq"
+    ],
+    "hint": "`uniq`은 연속된 중복만 제거하므로 먼저 `sort`가 필요합니다.",
+    "explanation": "`sort access.log | uniq`은 파일을 정렬한 뒤 중복 줄을 제거합니다.",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-lab-38",
+    "title": "wc로 줄 수 세기",
+    "task_description": "`/var/log/auth.log` 파일의 줄 수를 세세요.",
+    "expected_command": "wc -l /var/log/auth.log",
+    "grading_conditions": [
+      "wc",
+      "-l",
+      "/var/log/auth.log"
+    ],
+    "hint": "`wc -l`은 줄 수, `-w`는 단어 수, `-c`는 바이트 수를 셉니다.",
+    "explanation": "`wc -l /var/log/auth.log`는 파일의 줄 수를 출력합니다.",
+    "difficulty": "easy"
+  },
+  {
+    "id": "linux-lab-39",
+    "title": "awk로 두 번째 필드 출력",
+    "task_description": "`access.log`의 각 줄에서 두 번째 필드를 출력하세요.",
+    "expected_command": "awk '{print $2}' access.log",
+    "grading_conditions": [
+      "awk",
+      "$2",
+      "access.log"
+    ],
+    "hint": "awk에서 `$1`, `$2`는 공백으로 구분된 각 필드를 의미합니다.",
+    "explanation": "`awk '{print $2}' access.log`는 각 줄의 두 번째 필드를 출력합니다.",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-lab-40",
+    "title": "심볼릭 링크 생성",
+    "task_description": "`/etc/nginx/nginx.conf`를 가리키는 심볼릭 링크 `~/nginx.conf`를 만드세요.",
+    "expected_command": "ln -s /etc/nginx/nginx.conf ~/nginx.conf",
+    "grading_conditions": [
+      "ln",
+      "-s",
+      "/etc/nginx/nginx.conf",
+      "nginx.conf"
+    ],
+    "hint": "`ln -s 원본 링크이름` 형태로 심볼릭 링크를 만듭니다.",
+    "explanation": "`ln -s /etc/nginx/nginx.conf ~/nginx.conf`는 홈 디렉터리에 nginx.conf 심볼릭 링크를 만듭니다.",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-lab-41",
+    "title": "백그라운드 작업 목록 확인",
+    "task_description": "현재 쉘의 백그라운드 작업 목록을 확인하세요.",
+    "expected_command": "jobs",
+    "grading_conditions": [
+      "jobs"
+    ],
+    "hint": "`jobs` 명령으로 현재 쉘의 백그라운드 작업 목록을 볼 수 있습니다.",
+    "explanation": "`jobs`는 현재 쉘에서 `&`로 실행되거나 Ctrl+Z로 정지된 작업 목록을 보여줍니다.",
+    "difficulty": "easy"
+  },
+  {
+    "id": "linux-lab-42",
+    "title": "nohup 백그라운드 실행",
+    "task_description": "`long_process.sh` 스크립트를 터미널이 닫혀도 계속 실행되도록 백그라운드로 실행하세요.",
+    "expected_command": "nohup ./long_process.sh &",
+    "grading_conditions": [
+      "nohup",
+      "long_process.sh",
+      "&"
+    ],
+    "hint": "`nohup`은 HUP 시그널을 무시해 터미널 종료 후에도 계속 실행되게 합니다.",
+    "explanation": "`nohup ./long_process.sh &`는 터미널이 닫혀도 계속 실행됩니다. 출력은 기본적으로 nohup.out에 저장됩니다.",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-lab-43",
+    "title": "권한 보존 파일 백업",
+    "task_description": "`/etc/passwd` 파일을 권한·소유자·타임스탬프를 보존해 `/tmp/passwd.bak`으로 복사하세요.",
+    "expected_command": "cp -a /etc/passwd /tmp/passwd.bak",
+    "grading_conditions": [
+      "cp",
+      "-a",
+      "/etc/passwd",
+      "/tmp/passwd.bak"
+    ],
+    "hint": "일반 `cp`는 속성을 보존하지 않습니다. 백업 시에는 `-a` 옵션을 사용하세요.",
+    "explanation": "`cp -a`는 `-dR --preserve=all`의 단축으로 심볼릭 링크·권한·소유자·타임스탬프를 모두 보존합니다.",
+    "difficulty": "easy"
+  },
+  {
+    "id": "linux-lab-44",
+    "title": "디렉터리 재귀 삭제 전 확인",
+    "task_description": "`/tmp/testdir` 디렉터리를 삭제 전 각 파일을 확인하면서 제거하세요.",
+    "expected_command": "rm -ri /tmp/testdir",
+    "grading_conditions": [
+      "rm",
+      "-r",
+      "-i",
+      "/tmp/testdir"
+    ],
+    "hint": "`-r`은 재귀 삭제, `-i`는 각 파일마다 확인을 요청합니다.",
+    "explanation": "중요 데이터가 있는 디렉터리를 삭제할 때는 `-i`로 한 파일씩 확인하는 습관이 사고를 방지합니다.",
+    "difficulty": "easy"
+  },
+  {
+    "id": "linux-lab-45",
+    "title": "MBR 파티션 생성 (fdisk)",
+    "task_description": "`/dev/sdb`에 fdisk를 사용해 20GB 주 파티션을 생성하고 저장하세요. (인터랙티브: n → p → 1 → Enter → +20G → w)",
+    "expected_command": "fdisk /dev/sdb",
+    "grading_conditions": [
+      "fdisk",
+      "/dev/sdb"
+    ],
+    "hint": "fdisk 인터랙티브 모드에서 `n`(새 파티션), `p`(주), `1`(번호), Enter(기본 시작), `+20G`(크기), `w`(저장) 순서로 입력합니다.",
+    "explanation": "fdisk는 MBR 방식으로 최대 2TB 디스크에 적합합니다. 변경 사항은 `w`를 입력해야 실제 디스크에 기록됩니다.",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-lab-46",
+    "title": "ext4 파일시스템 생성",
+    "task_description": "`/dev/sdb1` 파티션에 ext4 파일시스템을 생성하세요.",
+    "expected_command": "mkfs.ext4 /dev/sdb1",
+    "grading_conditions": [
+      "mkfs.ext4",
+      "/dev/sdb1"
+    ],
+    "hint": "`mkfs.ext4` 또는 `mkfs -t ext4`를 사용합니다.",
+    "explanation": "파티션 생성 후 파일시스템을 만들어야 실제 데이터를 저장할 수 있습니다. 포맷하면 기존 데이터가 삭제되므로 대상 디바이스를 반드시 확인하세요.",
+    "difficulty": "easy"
+  },
+  {
+    "id": "linux-lab-47",
+    "title": "파일시스템 UUID 확인",
+    "task_description": "`/dev/sdb1`의 UUID를 확인하세요.",
+    "expected_command": "blkid /dev/sdb1",
+    "grading_conditions": [
+      "blkid",
+      "/dev/sdb1"
+    ],
+    "hint": "`blkid`는 블록 디바이스의 UUID와 파일시스템 유형을 출력합니다.",
+    "explanation": "fstab에 장치명 대신 UUID를 사용하면 재부팅 시 디바이스 순서가 바뀌어도 올바른 파티션이 마운트됩니다.",
+    "difficulty": "easy"
+  },
+  {
+    "id": "linux-lab-48",
+    "title": "그룹 생성 및 사용자 추가",
+    "task_description": "`devteam` 그룹을 만들고 `alice`를 기존 그룹을 유지한 채 추가하세요.",
+    "expected_command": "groupadd devteam && usermod -aG devteam alice",
+    "grading_conditions": [
+      "groupadd devteam",
+      "usermod",
+      "-aG",
+      "devteam",
+      "alice"
+    ],
+    "hint": "그룹 생성은 `groupadd`, 사용자를 보조 그룹에 추가할 때는 `-aG`(append)를 반드시 사용하세요.",
+    "explanation": "`-a` 없이 `-G`만 쓰면 alice의 기존 보조 그룹이 모두 devteam으로 교체됩니다. `-aG`가 안전합니다.",
+    "difficulty": "easy"
+  },
+  {
+    "id": "linux-lab-49",
+    "title": "첫 로그인 시 비밀번호 변경 강제",
+    "task_description": "새 사용자 `bob`이 첫 로그인 시 반드시 비밀번호를 변경하도록 설정하세요.",
+    "expected_command": "chage -d 0 bob",
+    "grading_conditions": [
+      "chage",
+      "-d 0",
+      "bob"
+    ],
+    "hint": "`chage -d 0`은 마지막 비밀번호 변경일을 에포크로 설정해 즉시 변경을 요구합니다.",
+    "explanation": "다음 로그인 시 PAM이 비밀번호 만료를 감지하고 새 비밀번호 입력을 요구합니다. 신규 계정 발급 시 표준 보안 절차입니다.",
+    "difficulty": "easy"
+  },
+  {
+    "id": "linux-lab-50",
+    "title": "systemd 서비스 파일 생성 및 활성화",
+    "task_description": "`/usr/local/bin/myapp`을 실행하는 `myapp.service`를 만들고 부팅 시 자동 시작하도록 활성화하세요.",
+    "expected_command": "systemctl daemon-reload && systemctl enable --now myapp",
+    "grading_conditions": [
+      "systemctl daemon-reload",
+      "systemctl enable",
+      "myapp"
+    ],
+    "hint": "유닛 파일을 `/etc/systemd/system/myapp.service`에 작성한 뒤 daemon-reload → enable --now 순서로 실행합니다.",
+    "explanation": "`daemon-reload`는 변경된 유닛 파일을 systemd가 인식하게 합니다. `enable --now`는 부팅 시 자동 시작 등록과 즉시 실행을 한 번에 처리합니다.",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-lab-51",
+    "title": "일회성 작업 예약 (at)",
+    "task_description": "2시간 후에 `/usr/local/bin/backup.sh`를 한 번 실행하도록 예약하세요.",
+    "expected_command": "echo '/usr/local/bin/backup.sh' | at now + 2 hours",
+    "grading_conditions": [
+      "at",
+      "now + 2 hours"
+    ],
+    "hint": "`echo '명령' | at now + 2 hours` 형식을 사용합니다. `at` 명령 후 Ctrl+D로도 입력할 수 있습니다.",
+    "explanation": "`at`은 일회성 스케줄링 도구입니다. 반복 실행이 필요하면 cron을 사용하세요. 예약 목록은 `atq`로 확인합니다.",
+    "difficulty": "easy"
+  },
+  {
+    "id": "linux-lab-52",
+    "title": "Docker 컨테이너 실행 및 확인",
+    "task_description": "nginx 이미지를 백그라운드로 실행하고 호스트 포트 8080을 컨테이너 포트 80에 연결한 뒤, 실행 중인 컨테이너를 확인하세요.",
+    "expected_command": "docker run -d -p 8080:80 nginx && docker ps",
+    "grading_conditions": [
+      "docker run",
+      "-d",
+      "-p 8080:80",
+      "nginx",
+      "docker ps"
+    ],
+    "hint": "`-d`는 백그라운드(detach), `-p 호스트:컨테이너`로 포트를 매핑합니다.",
+    "explanation": "컨테이너가 실행 중이면 `docker ps`에서 확인됩니다. 중지된 컨테이너까지 보려면 `docker ps -a`를 사용합니다.",
+    "difficulty": "easy"
+  },
+  {
+    "id": "linux-lab-53",
+    "title": "[시나리오] 신규 디스크 전체 설정 (파티션→포맷→마운트→fstab)",
+    "task_description": "신규 디스크 `/dev/sdb`에 파티션을 만들고 ext4로 포맷한 뒤 `/data`에 영구 마운트하는 전체 절차를 완성하세요.\n\n단계:\n1. `/dev/sdb`에 단일 주 파티션 생성 (fdisk)\n2. `/dev/sdb1`에 ext4 파일시스템 생성\n3. `/data` 마운트 포인트 생성\n4. `/dev/sdb1`을 `/data`에 마운트\n5. `/etc/fstab`에 UUID 기반으로 등록 후 `mount -a`로 검증\n\n이 단계 중 `blkid /dev/sdb1`의 목적을 서술하세요.",
+    "expected_command": "fdisk /dev/sdb && mkfs.ext4 /dev/sdb1 && mkdir /data && mount /dev/sdb1 /data && blkid /dev/sdb1",
+    "grading_conditions": [
+      "fdisk /dev/sdb",
+      "mkfs.ext4 /dev/sdb1",
+      "mkdir /data",
+      "mount /dev/sdb1 /data",
+      "blkid /dev/sdb1"
+    ],
+    "hint": "순서가 중요합니다: fdisk → mkfs → mkdir → mount → blkid(UUID 확인) → fstab 등록 → mount -a",
+    "explanation": "이 흐름은 LFCS 실기에서 가장 자주 나오는 복합 스토리지 시나리오입니다. fstab에 UUID를 쓰는 이유는 재부팅 시 디바이스 순서가 바뀌어도 올바른 파티션이 마운트되도록 보장하기 위해서입니다.",
+    "difficulty": "hard"
+  },
+  {
+    "id": "linux-lab-54",
+    "title": "[시나리오] LVM 볼륨 확장 (PV→VG 확장→LV 확장→FS 확장)",
+    "task_description": "기존 VG `vg_data`에 새 PV `/dev/sdc`를 추가하고, LV `lv_app`을 10GB 늘린 뒤 ext4 파일시스템까지 확장하세요.\n\n단계:\n1. `/dev/sdc`를 PV로 초기화\n2. `/dev/sdc`를 `vg_data`에 추가\n3. `lv_app`을 10GB 증가\n4. ext4 파일시스템 확장 (무중단)",
+    "expected_command": "pvcreate /dev/sdc && vgextend vg_data /dev/sdc && lvextend -L +10G /dev/vg_data/lv_app && resize2fs /dev/vg_data/lv_app",
+    "grading_conditions": [
+      "pvcreate /dev/sdc",
+      "vgextend vg_data /dev/sdc",
+      "lvextend",
+      "+10G",
+      "/dev/vg_data/lv_app",
+      "resize2fs"
+    ],
+    "hint": "LVM 확장 순서: pvcreate → vgextend → lvextend → resize2fs. `lvextend -r` 옵션으로 resize2fs를 통합할 수도 있습니다.",
+    "explanation": "LVM의 강점은 서비스 중단 없이 볼륨을 확장할 수 있다는 점입니다. `lvextend -r`은 LV 확장과 파일시스템 확장을 한 번에 처리합니다.",
+    "difficulty": "hard"
+  },
+  {
+    "id": "linux-lab-55",
+    "title": "[시나리오] 팀 공유 디렉터리 보안 설정 (그룹+SGID+ACL)",
+    "task_description": "개발팀 공유 디렉터리 `/srv/devteam`을 설정하세요.\n\n요구사항:\n1. `devteam` 그룹 생성\n2. `alice`와 `bob`을 `devteam`에 추가\n3. `/srv/devteam` 소유 그룹을 `devteam`으로 설정\n4. 그룹에 rwx 권한 부여, 기타 사용자는 접근 불가\n5. 새로 생성되는 파일도 자동으로 `devteam` 소유가 되도록 SGID 설정\n6. 오직 `alice`에게만 ACL로 추가 실행 권한 부여",
+    "expected_command": "groupadd devteam && usermod -aG devteam alice && usermod -aG devteam bob && chgrp devteam /srv/devteam && chmod 2770 /srv/devteam && setfacl -m u:alice:rwx /srv/devteam",
+    "grading_conditions": [
+      "groupadd devteam",
+      "usermod -aG devteam alice",
+      "usermod -aG devteam bob",
+      "chgrp devteam",
+      "chmod 2770",
+      "setfacl -m u:alice"
+    ],
+    "hint": "SGID 비트는 chmod 앞에 2를 붙입니다(예: 2770). ACL은 기본 권한과 독립적으로 동작합니다.",
+    "explanation": "2770 = SGID(2) + 소유자rwx(7) + 그룹rwx(7) + 기타없음(0). SGID가 있으면 해당 디렉터리에서 생성된 파일이 자동으로 부모 디렉터리의 그룹을 상속합니다.",
+    "difficulty": "hard"
+  },
+  {
+    "id": "linux-lab-56",
+    "title": "[시나리오] 커스텀 systemd 서비스 등록 및 보안 강화",
+    "task_description": "`/opt/myapp/run.sh` 스크립트를 systemd 서비스로 등록하세요.\n\n요구사항:\n1. `/etc/systemd/system/myapp.service` 파일 작성\n2. 전용 시스템 계정 `myapp`으로 실행 (로그인 불가)\n3. 네트워크 준비 후 시작 (`After=network.target`)\n4. 실패 시 자동 재시작\n5. 부팅 시 자동 시작 설정\n\n작성 후 즉시 시작까지 완료하세요.",
+    "expected_command": "useradd -r -s /sbin/nologin myapp && systemctl daemon-reload && systemctl enable --now myapp",
+    "grading_conditions": [
+      "useradd -r",
+      "-s /sbin/nologin myapp",
+      "systemctl daemon-reload",
+      "systemctl enable",
+      "myapp"
+    ],
+    "hint": "시스템 서비스 계정은 `useradd -r`(시스템 계정)과 `-s /sbin/nologin`(로그인 차단)으로 생성합니다. 유닛 파일 작성 후 daemon-reload 필수.",
+    "explanation": "운영 환경에서 서비스는 전용 최소 권한 계정으로 실행하는 것이 보안 모범 사례입니다. `-r` 플래그는 시스템 계정용 낮은 UID를 부여합니다.",
+    "difficulty": "hard"
+  },
+  {
+    "id": "linux-lab-57",
+    "title": "[시나리오] SSH 보안 강화 (키 인증 전환 + 비밀번호 차단)",
+    "task_description": "서버 SSH를 키 기반 인증으로 전환하고 비밀번호 로그인을 차단하세요.\n\n단계:\n1. 로컬에서 ED25519 키 쌍 생성\n2. 공개 키를 서버 `alice` 계정에 복사 (`ssh-copy-id`)\n3. `/etc/ssh/sshd_config`에서:\n   - `PasswordAuthentication no`\n   - `PermitRootLogin prohibit-password`\n4. sshd 재시작 전 설정 문법 검증\n5. sshd 재시작",
+    "expected_command": "ssh-keygen -t ed25519 && ssh-copy-id alice@server && sshd -t && systemctl restart sshd",
+    "grading_conditions": [
+      "ssh-keygen -t ed25519",
+      "ssh-copy-id",
+      "sshd -t",
+      "systemctl restart sshd"
+    ],
+    "hint": "`sshd -t`는 설정 파일 문법을 검증합니다. 재시작 전에 반드시 실행해 잠금 방지.",
+    "explanation": "비밀번호 인증을 끄기 전 키 인증이 작동하는지 반드시 확인해야 합니다. `sshd -t` 실패 시 재시작하면 서버에 접속 불가 상태가 될 수 있습니다.",
+    "difficulty": "hard"
+  },
+  {
+    "id": "linux-lab-58",
+    "title": "[시나리오] 브루트포스 IP 탐지 후 방화벽 차단",
+    "task_description": "`/var/log/auth.log`를 분석해 SSH 로그인 실패 IP를 찾고 ufw로 차단하���요.\n\n단계:\n1. auth.log에서 'Failed' 포함 줄의 IP(필드 11)를 추출\n2. 횟수 기준 내림차순 정렬\n3. 상위 IP를 ufw deny로 차단\n4. ufw 규칙 확인",
+    "expected_command": "grep 'Failed' /var/log/auth.log | awk '{print $11}' | sort | uniq -c | sort -rn | head -5",
+    "grading_conditions": [
+      "grep 'Failed' /var/log/auth.log",
+      "awk",
+      "sort",
+      "uniq -c",
+      "sort -rn"
+    ],
+    "hint": "grep→awk→sort→uniq -c→sort -rn 파이프라인으로 IP별 실패 횟수를 집계합니다.",
+    "explanation": "이 파이프라인은 보안 분석의 기본 패턴입니다. 탐지된 IP는 `ufw deny from 1.2.3.4`로 차단합니다. fail2ban이 이 과정을 자동화합니다.",
+    "difficulty": "hard"
+  },
+  {
+    "id": "linux-lab-59",
+    "title": "[시나리오] Docker 컨테이너 웹 서버 배포 및 로그 확인",
+    "task_description": "nginx 컨테이너를 배포하고 운영 상태를 검증하세요.\n\n단계:\n1. nginx:latest 이미지 pull\n2. 이름 `webserver`, 호스트 8080→컨테이너 80, 백그라운드로 실행\n3. 컨테이너 실행 상태 확인\n4. `curl localhost:8080`으로 응답 확인\n5. 컨테이너 로그 마지막 20줄 확인",
+    "expected_command": "docker pull nginx:latest && docker run -d -p 8080:80 --name webserver nginx && docker ps && curl localhost:8080 && docker logs --tail 20 webserver",
+    "grading_conditions": [
+      "docker pull nginx",
+      "docker run -d -p 8080:80 --name webserver nginx",
+      "docker ps",
+      "curl localhost:8080",
+      "docker logs --tail 20 webserver"
+    ],
+    "hint": "`docker logs --tail N`으로 최근 N줄만 볼 수 있습니다. `--follow`를 추가하면 실시간 스트리밍됩니다.",
+    "explanation": "컨테이너 배포 후 ps로 상태, curl로 응답, logs로 내부 동작을 확인하는 3단계 검증은 운영 환경 표준 절차입니다.",
+    "difficulty": "hard"
+  }
+]

cert_study_app/content/linux/quizzes.json

@@ -0,0 +1,1076 @@
+[
+  {
+    "id": "linux-q29",
+    "lesson_id": "linux-passwd",
+    "question_type": "multiple_choice",
+    "question": "`passwd -l devuser`의 의미로 가장 맞는 것은?",
+    "options": [
+      "devuser 계정을 잠가 비밀번호 로그인을 막는다",
+      "devuser 비밀번호를 강제 만료시킨다",
+      "devuser 계정을 완전히 삭제한다",
+      "devuser 비밀번호를 빈 값으로 초기화한다"
+    ],
+    "answer": "devuser 계정을 잠가 비밀번호 로그인을 막는다",
+    "explanation": "`passwd -l`은 계정을 잠가 해당 사용자가 비밀번호로 로그인할 수 없게 합니다. 잠금 해제는 `passwd -u`입니다.",
+    "difficulty": "easy",
+    "source_id": "ubuntu-user-management"
+  },
+  {
+    "id": "linux-q30",
+    "lesson_id": "linux-groups-id",
+    "question_type": "multiple_choice",
+    "question": "현재 사용자의 UID, GID, 보조 그룹 목록을 한 번에 확인하는 명령은?",
+    "options": [
+      "id",
+      "groups",
+      "whoami",
+      "ls -l"
+    ],
+    "answer": "id",
+    "explanation": "`id`는 UID, GID, 속한 그룹 목록을 모두 보여줍니다. `groups`는 그룹 이름만, `whoami`는 사용자 이름만 보여줍니다.",
+    "difficulty": "easy",
+    "source_id": "ubuntu-user-management"
+  },
+  {
+    "id": "linux-q31",
+    "lesson_id": "linux-acl",
+    "question_type": "multiple_choice",
+    "question": "파일에 설정된 ACL 권한 내역을 확인하는 명령은?",
+    "options": [
+      "getfacl",
+      "setfacl",
+      "chmod",
+      "ls -l"
+    ],
+    "answer": "getfacl",
+    "explanation": "`getfacl`로 현재 ACL 설정을 확인합니다. `setfacl -m`으로 ACL을 설정합니다. `ls -l`만으로는 ACL 전체가 보이지 않습니다.",
+    "difficulty": "easy",
+    "source_id": "manual-linux-basic"
+  },
+  {
+    "id": "linux-q32",
+    "lesson_id": "linux-ssh",
+    "question_type": "multiple_choice",
+    "question": "SSH 접속 실패 원인으로 관련이 없는 것은?",
+    "options": [
+      "사용자의 Python 버전",
+      "SSH 서비스 실행 여부",
+      "방화벽 22번 포트 허용 여부",
+      "authorized_keys 파일 권한"
+    ],
+    "answer": "사용자의 Python 버전",
+    "explanation": "SSH 접속은 서비스 실행, 방화벽, 키 파일 권한이 모두 맞아야 합니다. Python 버전은 SSH 접속과 무관합니다.",
+    "difficulty": "easy",
+    "source_id": "ubuntu-server-docs"
+  },
+  {
+    "id": "linux-q33",
+    "lesson_id": "linux-hostname-hosts",
+    "question_type": "multiple_choice",
+    "question": "`/etc/hosts` 파일의 주된 역할은?",
+    "options": [
+      "DNS 조회 전에 참조되는 로컬 이름 해석 파일이다",
+      "방화벽 규칙을 저장한다",
+      "사용자 비밀번호를 저장한다",
+      "swap 공간을 정의한다"
+    ],
+    "answer": "DNS 조회 전에 참조되는 로컬 이름 해석 파일이다",
+    "explanation": "`/etc/hosts`는 DNS 조회보다 먼저 참조되는 로컬 이름 해석 파일입니다. 테스트 환경이나 특정 호스트 이름 재정의에 자주 씁니다.",
+    "difficulty": "easy",
+    "source_id": "ubuntu-networking"
+  },
+  {
+    "id": "linux-q34",
+    "lesson_id": "linux-netplan",
+    "question_type": "multiple_choice",
+    "question": "Ubuntu에서 netplan 네트워크 설정을 시스템에 적용하는 명령은?",
+    "options": [
+      "sudo netplan apply",
+      "sudo ifconfig apply",
+      "sudo ip apply",
+      "sudo ufw apply"
+    ],
+    "answer": "sudo netplan apply",
+    "explanation": "`sudo netplan apply`는 `/etc/netplan/*.yaml` 설정을 파싱해 시스템에 적용합니다. YAML 들여쓰기 오류가 있으면 실패합니다.",
+    "difficulty": "easy",
+    "source_id": "ubuntu-networking"
+  },
+  {
+    "id": "linux-q35",
+    "lesson_id": "linux-curl",
+    "question_type": "multiple_choice",
+    "question": "`curl -I https://example.com`의 `-I` 옵션 역할은?",
+    "options": [
+      "HTTP 헤더만 요청해 응답 상태를 확인한다",
+      "데이터를 POST로 전송한다",
+      "SSL 인증서 검증을 건너뛴다",
+      "JSON 형식으로만 출력한다"
+    ],
+    "answer": "HTTP 헤더만 요청해 응답 상태를 확인한다",
+    "explanation": "`-I`는 HEAD 요청을 보내 응답 헤더만 받습니다. 서비스가 올바른 상태 코드를 반환하는지 빠르게 확인할 때 유용합니다.",
+    "difficulty": "easy",
+    "source_id": "ubuntu-networking"
+  },
+  {
+    "id": "linux-q36",
+    "lesson_id": "linux-ping",
+    "question_type": "multiple_choice",
+    "question": "ping이 성공하더라도 보장되지 않는 것은?",
+    "options": [
+      "HTTP 서비스가 정상 동작하는 것",
+      "ICMP 통신이 가능하다는 것",
+      "네트워크 경로가 있다는 것",
+      "IP 통신이 가능하다는 것"
+    ],
+    "answer": "HTTP 서비스가 정상 동작하는 것",
+    "explanation": "ping은 ICMP 응답만 확인합니다. 방화벽이 ICMP를 허용해도 HTTP 서비스가 내려가 있을 수 있고, 반대로 HTTP가 되어도 ICMP가 막힐 수 있습니다.",
+    "difficulty": "easy",
+    "source_id": "ubuntu-networking"
+  },
+  {
+    "id": "linux-q37",
+    "lesson_id": "linux-top",
+    "question_type": "multiple_choice",
+    "question": "`top` 명령어가 가장 적합한 상황은?",
+    "options": [
+      "CPU/메모리 사용량이 높은 프로세스를 실시간으로 확인할 때",
+      "파일 이름 패턴으로 검색할 때",
+      "패키지를 설치할 때",
+      "파일시스템 사용량을 볼 때"
+    ],
+    "answer": "CPU/메모리 사용량이 높은 프로세스를 실시간으로 확인할 때",
+    "explanation": "`top`은 CPU, 메모리 사용량과 프로세스 목록을 실시간으로 갱신해 보여줍니다. 서버 부하 원인 파악에 자주 씁니다.",
+    "difficulty": "easy",
+    "source_id": "ubuntu-server-docs"
+  },
+  {
+    "id": "linux-q38",
+    "lesson_id": "linux-nice",
+    "question_type": "multiple_choice",
+    "question": "`nice -n 10 command`에서 nice 값이 높을수록 어떻게 되는가?",
+    "options": [
+      "다른 프로세스에 CPU를 양보하는 낮은 우선순위를 가진다",
+      "CPU 코어를 더 많이 사용한다",
+      "지정된 분 후에 실행된다",
+      "메모리를 더 많이 차지한다"
+    ],
+    "answer": "다른 프로세스에 CPU를 양보하는 낮은 우선순위를 가진다",
+    "explanation": "nice 값이 높을수록 다른 프로세스에게 CPU를 더 양보합니다. 범위는 -20(가장 높은 우선순위)에서 19(가장 낮은 우선순위)입니다.",
+    "difficulty": "easy",
+    "source_id": "ubuntu-server-docs"
+  },
+  {
+    "id": "linux-q39",
+    "lesson_id": "linux-swap",
+    "question_type": "multiple_choice",
+    "question": "swap 사용량이 매우 높을 때 시스템 상태를 가장 잘 나타내는 것은?",
+    "options": [
+      "물리 메모리가 부족해 디스크를 보조 메모리로 사용하고 있다",
+      "CPU가 과부하 상태다",
+      "디스크 공간이 꽉 찼다",
+      "네트워크 연결이 끊겼다"
+    ],
+    "answer": "물리 메모리가 부족해 디스크를 보조 메모리로 사용하고 있다",
+    "explanation": "swap 과사용은 물리 RAM 부족의 신호입니다. 디스크가 RAM보다 훨씬 느려서 swap 과다 사용은 심각한 성능 저하로 이어집니다.",
+    "difficulty": "easy",
+    "source_id": "ubuntu-storage"
+  },
+  {
+    "id": "linux-q40",
+    "lesson_id": "linux-lvm",
+    "question_type": "multiple_choice",
+    "question": "LVM에서 물리 볼륨(PV)들이 합쳐지는 중간 계층은?",
+    "options": [
+      "Volume Group (VG)",
+      "Logical Volume (LV)",
+      "/etc/fstab",
+      "partition table"
+    ],
+    "answer": "Volume Group (VG)",
+    "explanation": "LVM 계층은 PV(물리 볼륨) → VG(볼륨 그룹) → LV(논리 볼륨) 순입니다. VG는 PV들을 묶고, LV는 VG에서 용량을 나눠 씁니다.",
+    "difficulty": "easy",
+    "source_id": "ubuntu-storage"
+  },
+  {
+    "id": "linux-q41",
+    "lesson_id": "linux-logs-var",
+    "question_type": "multiple_choice",
+    "question": "`/var/log` 디렉터리에서 주로 볼 수 있는 것은?",
+    "options": [
+      "서비스, 인증, 시스템의 로그 파일",
+      "사용자 홈 디렉터리",
+      "실행 가능한 패키지 바이너리",
+      "네트워크 설정 파일"
+    ],
+    "answer": "서비스, 인증, 시스템의 로그 파일",
+    "explanation": "`/var/log`는 nginx, syslog, auth.log, kern.log 같은 다양한 로그 파일이 모이는 표준 위치입니다.",
+    "difficulty": "easy",
+    "source_id": "ubuntu-server-docs"
+  },
+  {
+    "id": "linux-q42",
+    "lesson_id": "linux-dmesg",
+    "question_type": "multiple_choice",
+    "question": "`dmesg | tail`로 확인하기에 가장 적합한 정보는?",
+    "options": [
+      "부팅과 하드웨어 관련 커널 메시지",
+      "HTTP 서버 접속 로그",
+      "사용자 비밀번호 정책",
+      "cron 실행 이력"
+    ],
+    "answer": "부팅과 하드웨어 관련 커널 메시지",
+    "explanation": "`dmesg`는 커널 링 버퍼를 출력합니다. 부팅 과정, 하드웨어 감지, 드라이버 오류 같은 시스템 수준 메시지를 볼 때 유용합니다.",
+    "difficulty": "easy",
+    "source_id": "ubuntu-server-docs"
+  },
+  {
+    "id": "linux-q43",
+    "lesson_id": "linux-env-path",
+    "question_type": "multiple_choice",
+    "question": "cron 작업이 터미널에서는 되지만 cron에서만 실패할 때 먼저 의심할 원인은?",
+    "options": [
+      "PATH 환경 변수가 cron과 터미널에서 다르다",
+      "디스크 공간이 부족하다",
+      "SSH 키 파일이 없다",
+      "systemctl이 중지됐다"
+    ],
+    "answer": "PATH 환경 변수가 cron과 터미널에서 다르다",
+    "explanation": "cron��� 로그인 shell보다 훨씬 제한된 PATH를 씁니다. 스크립트에서 절대 경로를 사용하거나 crontab에서 PATH를 직접 설정하면 해결됩니다.",
+    "difficulty": "easy",
+    "source_id": "linux-bash-cd"
+  },
+  {
+    "id": "linux-q44",
+    "lesson_id": "linux-wildcard",
+    "question_type": "multiple_choice",
+    "question": "`ls *.log` 명령에서 `*.log` 패턴을 파일 목록으로 확장하는 주체는?",
+    "options": [
+      "Shell (bash/zsh)",
+      "ls 명령어 자체",
+      "kernel",
+      "파일시스템 드라이버"
+    ],
+    "answer": "Shell (bash/zsh)",
+    "explanation": "와일드카드 글로빙(glob)은 shell이 명령 실행 전에 파일명 목록으로 확장합니다. ls가 아니라 shell이 처리합니다.",
+    "difficulty": "easy",
+    "source_id": "linux-bash-cd"
+  },
+  {
+    "id": "linux-q45",
+    "lesson_id": "linux-service-port",
+    "question_type": "multiple_choice",
+    "question": "`systemctl is-active nginx`가 active인데도 80포트에 연결이 안 될 때 확인 대상이 아닌 것은?",
+    "options": [
+      "사용자의 SSH 공개 키",
+      "방화벽 80포트 허용 여부",
+      "nginx가 80포트에서 listen 중인지",
+      "nginx 설정 파일 문법 오류"
+    ],
+    "answer": "사용자의 SSH 공개 키",
+    "explanation": "서비스가 active여도 방화벽, 포트 listen 설정, 설정 파일 오류로 연결이 안 될 수 있습니다. SSH 공개 키는 80포트 연결과 무관합니다.",
+    "difficulty": "easy",
+    "source_id": "linux-man7-ip"
+  },
+  {
+    "id": "linux-q46",
+    "lesson_id": "linux-repo",
+    "question_type": "multiple_choice",
+    "question": "`apt update` 실행 시 특정 repository에서 오류가 날 때 먼저 의심할 원인은?",
+    "options": [
+      "repository URL이나 GPG 키 설정 문제",
+      "CPU 온도가 높다",
+      "swap 공간이 부족하다",
+      "실행 중인 프로세스 수가 많다"
+    ],
+    "answer": "repository URL이나 GPG 키 설정 문제",
+    "explanation": "`apt update` 실패는 repository URL 오류, 네트워크 차단, GPG 서명 키 문제가 주된 원인입니다.",
+    "difficulty": "easy",
+    "source_id": "ubuntu-package-management"
+  },
+  {
+    "id": "linux-q47",
+    "lesson_id": "linux-head-tail",
+    "question_type": "multiple_choice",
+    "question": "증가하는 로그 파일을 실시간으로 계속 추적하는 명령으로 가장 적합한 것은?",
+    "options": [
+      "tail -f /var/log/syslog",
+      "head -f /var/log/syslog",
+      "cat -f /var/log/syslog",
+      "watch /var/log/syslog"
+    ],
+    "answer": "tail -f /var/log/syslog",
+    "explanation": "`tail -f`는 파일 끝에 추가되는 내용을 실시간으로 계속 보여줍니다. 로그 모니터링에 가장 많이 씁니다.",
+    "difficulty": "easy",
+    "source_id": "manual-linux-basic"
+  },
+  {
+    "id": "linux-q48",
+    "lesson_id": "linux-sed",
+    "question_type": "multiple_choice",
+    "question": "`sed 's/old/new/g' file.txt`의 역할은?",
+    "options": [
+      "file.txt의 old를 모두 new로 교체해 표준 출력으로 보낸다",
+      "file.txt를 정렬해 출력한다",
+      "file.txt에서 old 줄을 삭제한다",
+      "file.txt를 새 파일로 복사한다"
+    ],
+    "answer": "file.txt의 old를 모두 new로 교체해 표준 출력으로 보낸다",
+    "explanation": "`sed 's/패턴/교체/g'`는 파일에서 패턴을 찾아 교체한 결과를 출력합니다. `-i` 없이는 원본 파일을 바꾸지 않습니다.",
+    "difficulty": "easy",
+    "source_id": "manual-linux-basic"
+  },
+  {
+    "id": "linux-q49",
+    "lesson_id": "linux-text-pipeline",
+    "question_type": "multiple_choice",
+    "question": "파일 전체에서 중복 줄을 제거하려 할 때 `uniq` 전에 일반적으로 필요한 명령은?",
+    "options": [
+      "sort",
+      "cut",
+      "wc",
+      "grep"
+    ],
+    "answer": "sort",
+    "explanation": "`uniq`은 연속된 중복 줄만 제거합니다. 파일 전체에서 중복을 제거하려면 먼저 `sort`로 정렬한 뒤 `uniq`을 적용해야 합니다.",
+    "difficulty": "easy",
+    "source_id": "manual-linux-basic"
+  },
+  {
+    "id": "linux-q50",
+    "lesson_id": "linux-awk",
+    "question_type": "multiple_choice",
+    "question": "`awk '{print $2}' access.log`가 하는 일은?",
+    "options": [
+      "각 줄의 두 번째 필드를 출력한다",
+      "두 번째 줄만 출력한다",
+      "두 번째 파일을 연다",
+      "필드 구분자를 2번으로 바꾼다"
+    ],
+    "answer": "각 줄의 두 번째 필드를 출력한다",
+    "explanation": "awk에서 `$1`, `$2`, `$N`은 공백으로 구분된 각 필드를 의미합니다. `$2`는 각 줄의 두 번째 필드를 출력합니다.",
+    "difficulty": "easy",
+    "source_id": "manual-linux-basic"
+  },
+  {
+    "id": "linux-q51",
+    "lesson_id": "linux-ln-symlink",
+    "question_type": "multiple_choice",
+    "question": "`ln -s /etc/nginx/nginx.conf ~/nginx.conf`로 만들어지는 것은?",
+    "options": [
+      "nginx.conf를 가리키는 심볼릭 링크",
+      "nginx.conf의 하드 복사본",
+      "nginx.conf라는 디렉터리",
+      "nginx.conf의 이름만 변경한 것"
+    ],
+    "answer": "nginx.conf를 가리키는 심볼릭 링크",
+    "explanation": "`ln -s`는 원본 파일을 가리키는 심볼릭 링크를 만듭니다. `ls -l`에서 `->` 표시로 확인할 수 있습니다.",
+    "difficulty": "easy",
+    "source_id": "manual-linux-basic"
+  },
+  {
+    "id": "linux-q52",
+    "lesson_id": "linux-bg-fg-jobs",
+    "question_type": "multiple_choice",
+    "question": "터미널이 닫혀도 작업이 계속 실행되도록 백그라운드로 실행하는 명령은?",
+    "options": [
+      "nohup long-command &",
+      "long-command &",
+      "bg long-command",
+      "jobs -r long-command"
+    ],
+    "answer": "nohup long-command &",
+    "explanation": "`nohup`은 터미널 종료 시 보내는 HUP 시그널을 무시해 작업이 계속 실행되도록 합니다. `&`만으로는 터미널이 닫히면 작업이 종료됩니다.",
+    "difficulty": "easy",
+    "source_id": "ubuntu-server-docs"
+  },
+  {
+    "id": "linux-q53",
+    "lesson_id": "linux-shell-script-basics",
+    "question_type": "multiple_choice",
+    "question": "쉘 스크립트에서 스크립트에 전달된 첫 번째 인수를 참조하는 변수는?",
+    "options": [
+      "$1",
+      "$0",
+      "$@",
+      "$$"
+    ],
+    "answer": "$1",
+    "explanation": "`$0`은 스크립트 이름, `$1`은 첫 번째 인수, `$@`는 모든 인수 목록, `$$`는 현재 프로세스 PID입니다.",
+    "difficulty": "easy",
+    "source_id": "linux-bash-cd"
+  },
+  {
+    "id": "linux-q54",
+    "lesson_id": "linux-ls",
+    "question_type": "multiple_choice",
+    "question": "숨김 파일을 포함해 상세 정보를 보는 ls 옵션 조합은?",
+    "options": [
+      "ls -rh",
+      "ls -al",
+      "ls -d",
+      "ls -t"
+    ],
+    "answer": "ls -al",
+    "explanation": "`-a`는 점으로 시작하는 숨김 파일 포함, `-l`은 권한·소유자·크기·날짜를 포함한 긴 형식 출력입니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "easy"
+  },
+  {
+    "id": "linux-q55",
+    "lesson_id": "linux-cd",
+    "question_type": "multiple_choice",
+    "question": "`cd -` 명령어의 결과는?",
+    "options": [
+      "루트 디렉터리로 이동",
+      "이전 디렉터리로 이동",
+      "홈 디렉터리로 이동",
+      "상위 디렉터리로 이동"
+    ],
+    "answer": "이전 디렉터리로 이동",
+    "explanation": "`cd -`는 OLDPWD에 저장된 직전 디렉터리로 돌아갑니다. 두 디렉터리 사이를 빠르게 오갈 때 유용합니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "easy"
+  },
+  {
+    "id": "linux-q56",
+    "lesson_id": "linux-cat",
+    "question_type": "multiple_choice",
+    "question": "파일 내용을 줄 번호와 함께 출력하는 cat 옵션은?",
+    "options": [
+      "-n",
+      "-v",
+      "-e",
+      "-s"
+    ],
+    "answer": "-n",
+    "explanation": "`cat -n`은 모든 줄에 번호를 붙여 출력합니다. 스크립트 디버깅이나 특정 줄 위치 확인에 유용합니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "easy"
+  },
+  {
+    "id": "linux-q57",
+    "lesson_id": "linux-process-ps-kill",
+    "question_type": "multiple_choice",
+    "question": "실행 중인 모든 프로세스를 사용자 이름과 함께 전체 목록으로 보는 명령은?",
+    "options": [
+      "ps aux",
+      "ps -e",
+      "top -n1",
+      "kill -l"
+    ],
+    "answer": "ps aux",
+    "explanation": "`ps aux`는 모든 사용자의 전체 프로세스를 CPU/메모리 사용량과 함께 보여줍니다. 시험에서 가장 자주 쓰이는 ps 옵션 조합입니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "easy"
+  },
+  {
+    "id": "linux-q58",
+    "lesson_id": "linux-cp-mv-rm",
+    "question_type": "multiple_choice",
+    "question": "운영 중인 서버의 `/etc/nginx/nginx.conf`를 수정하기 전 권한과 타임스탬프를 보존해 같은 디렉터리에 백업하려 합니다. 올바른 명령은?",
+    "options": [
+      "cp /etc/nginx/nginx.conf /etc/nginx/nginx.conf.bak",
+      "cp -a /etc/nginx/nginx.conf /etc/nginx/nginx.conf.bak",
+      "cp -r /etc/nginx/nginx.conf /etc/nginx/nginx.conf.bak",
+      "mv /etc/nginx/nginx.conf /etc/nginx/nginx.conf.bak"
+    ],
+    "answer": "cp -a /etc/nginx/nginx.conf /etc/nginx/nginx.conf.bak",
+    "explanation": "`cp -a`는 권한·소유자·타임스탬프를 모두 보존합니다(`-dR --preserve=all`). `-r`은 디렉터리 재귀 복사용이며 속성을 보존하지 않습니다. `mv`는 원본이 사라집니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-q59",
+    "lesson_id": "linux-cp-mv-rm",
+    "question_type": "multiple_choice",
+    "question": "`rm -rf /var/log/old/`를 실행했을 때 발생하는 일은?",
+    "options": [
+      "/var/log/old/ 디렉터리와 하위 모든 파일이 즉시 삭제된다",
+      "각 파일마다 삭제 확인을 요청한다",
+      "/var/log/old/가 휴지통으로 이동한다",
+      "심볼릭 링크만 삭제하고 실제 파일은 남긴다"
+    ],
+    "answer": "/var/log/old/ 디렉터리와 하위 모든 파일이 즉시 삭제된다",
+    "explanation": "`-r`은 재귀 삭제, `-f`는 확인 없이 강제 삭제입니다. 리눅스에는 휴지통이 없어 복구가 매우 어렵습니다. 중요 경로에서는 먼저 `ls`로 대상을 확인하세요.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "easy"
+  },
+  {
+    "id": "linux-q60",
+    "lesson_id": "linux-fdisk-parted",
+    "question_type": "multiple_choice",
+    "question": "3TB 용량의 새 디스크 `/dev/sdc`에 파티션을 만들 때 fdisk 대신 parted를 사용해야 하는 이유는?",
+    "options": [
+      "fdisk는 MBR 방식으로 2TB 초과 디스크를 지원하지 않기 때문",
+      "parted가 더 빠르기 때문",
+      "fdisk는 ext4 파일시스템만 지원하기 때문",
+      "parted만 RAID 설정을 지원하기 때문"
+    ],
+    "answer": "fdisk는 MBR 방식으로 2TB 초과 디스크를 지원하지 않기 때문",
+    "explanation": "MBR 파티션 테이블은 최대 2TB를 지원합니다. 3TB 디스크는 GPT가 필요하며 `parted`나 `gdisk`로 GPT 테이블을 생성해야 합니다.",
+    "source_id": "manual-linux-storage",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-q61",
+    "lesson_id": "linux-fdisk-parted",
+    "question_type": "multiple_choice",
+    "question": "`fdisk /dev/sdb` 실행 후 새 주 파티션을 만들고 저장하는 키 순서는?",
+    "options": [
+      "n → p → w",
+      "p → n → w",
+      "n → e → q",
+      "w → n → p"
+    ],
+    "answer": "n → p → w",
+    "explanation": "`n`(new partition) → `p`(primary) → 번호·섹터 입력 → `w`(write & quit). `q`는 저장 없이 종료, `p`는 현재 테이블 출력(Print)이기도 합니다.",
+    "source_id": "manual-linux-storage",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-q62",
+    "lesson_id": "linux-mkfs-fsck",
+    "question_type": "multiple_choice",
+    "question": "다음 스토리지 설정 순서 중 올바른 것은?",
+    "options": [
+      "파티션 생성 → 파일시스템 생성(mkfs) → 마운트 포인트 생성 → mount",
+      "마운트 → mkfs → 파티션 생성 → fstab 등록",
+      "mkfs → 파티션 생성 → mount → fstab 등록",
+      "파티션 생성 → mount → mkfs → fstab 등록"
+    ],
+    "answer": "파티션 생성 → 파일시스템 생성(mkfs) → 마운트 포인트 생성 → mount",
+    "explanation": "fdisk로 파티션 생성 → mkfs로 포맷 → mkdir로 마운트 포인트 생성 → mount로 연결이 올바른 순서입니다. 영구 마운트는 마지막에 fstab에 등록합니다.",
+    "source_id": "manual-linux-storage",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-q63",
+    "lesson_id": "linux-mkfs-fsck",
+    "question_type": "multiple_choice",
+    "question": "마운트된 파일시스템에서 `fsck`를 실행하면 어떻게 되는가?",
+    "options": [
+      "데이터 손상이 발생할 수 있다",
+      "자동으로 언마운트 후 검사한다",
+      "읽기 전용으로 전환 후 검사한다",
+      "정상적으로 오류를 수정한다"
+    ],
+    "answer": "데이터 손상이 발생할 수 있다",
+    "explanation": "`fsck`는 언마운트된 파일시스템에서만 실행해야 합니다. 마운트 상태에서 실행하면 OS와 fsck가 동시에 파일시스템에 쓰기를 시도해 데이터가 손상될 수 있습니다.",
+    "source_id": "manual-linux-storage",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-q64",
+    "lesson_id": "linux-groupadd",
+    "question_type": "multiple_choice",
+    "question": "`usermod -G developers alice`를 `-a` 없이 실행했을 때 발생하는 문제는?",
+    "options": [
+      "alice의 기존 보조 그룹이 모두 제거되고 developers만 남는다",
+      "alice가 developers 그룹에서 제거된다",
+      "명령이 실패하고 오류가 출력된다",
+      "alice의 기본 그룹이 developers로 변경된다"
+    ],
+    "answer": "alice의 기존 보조 그룹이 모두 제거되고 developers만 남는다",
+    "explanation": "`-G`는 보조 그룹을 지정한 목록으로 교체합니다. 기존 그룹을 유지하면서 추가하려면 반드시 `-aG`(append)를 사용해야 합니다.",
+    "source_id": "ubuntu-user-management",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-q65",
+    "lesson_id": "linux-chage",
+    "question_type": "multiple_choice",
+    "question": "신규 입사자 bob이 첫 로그인 시 반드시 비밀번호를 변경하게 하려 합니다. 적절한 명��은?",
+    "options": [
+      "chage -d 0 bob",
+      "chage -M 0 bob",
+      "passwd -l bob",
+      "chage -E 0 bob"
+    ],
+    "answer": "chage -d 0 bob",
+    "explanation": "`chage -d 0`은 마지막 비밀번호 변경일을 에포크(1970-01-01)로 설정해 다음 로그인 시 즉시 변경을 강제합니다. `-E 0`은 계정 자체를 만료시켜 로그인을 차단합니다.",
+    "source_id": "ubuntu-user-management",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-q66",
+    "lesson_id": "linux-chage",
+    "question_type": "multiple_choice",
+    "question": "보안 정책상 모든 사용자가 90일마다 비밀번호를 바꿔야 합니다. alice에게 적용하는 명령은?",
+    "options": [
+      "chage -M 90 alice",
+      "chage -d 90 alice",
+      "passwd -M 90 alice",
+      "chage -W 90 alice"
+    ],
+    "answer": "chage -M 90 alice",
+    "explanation": "`-M`은 비밀번호 최대 사용 기간(Maximum days)을 설정합니다. `-W`는 만료 전 경고일, `-d`는 마지막 변경일, `-E`는 계정 만료일입니다.",
+    "source_id": "ubuntu-user-management",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-q67",
+    "lesson_id": "linux-systemd-unit",
+    "question_type": "multiple_choice",
+    "question": "`/etc/systemd/system/myapp.service` 파일을 수정한 뒤 변경 사항을 적용하는 올바른 순서는?",
+    "options": [
+      "systemctl daemon-reload → systemctl restart myapp",
+      "systemctl restart myapp → systemctl daemon-reload",
+      "reboot → systemctl restart myapp",
+      "systemctl reload myapp만 실행"
+    ],
+    "answer": "systemctl daemon-reload → systemctl restart myapp",
+    "explanation": "유닛 파일 수정 후 systemd가 변경을 인식하려면 `daemon-reload`가 먼저 필요합니다. 그 다음 `restart`로 서비스를 재시작해야 새 설정이 적용됩니다.",
+    "source_id": "manual-linux-systemd",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-q68",
+    "lesson_id": "linux-systemd-unit",
+    "question_type": "multiple_choice",
+    "question": "서비스 유닛 파일에서 `WantedBy=multi-user.target`의 역할은?",
+    "options": [
+      "systemctl enable 시 multi-user.target 실행 단계에서 서비스가 자동 시작되도록 등록한다",
+      "서비스가 multi-user 이후에만 중지됨을 의미한다",
+      "서비스를 그래픽 환경에서만 실행하게 한다",
+      "다른 서비스보다 먼저 시작하게 한다"
+    ],
+    "answer": "systemctl enable 시 multi-user.target 실행 단계에서 서비스가 자동 시작되도록 등록한다",
+    "explanation": "`WantedBy`는 `systemctl enable` 실행 시 어느 target의 `.wants/` 디렉터리에 심볼릭 링크를 생성할지 결정합니다. `multi-user.target`은 네트워크 서비스가 준비된 CLI 환경(runlevel 3)입니다.",
+    "source_id": "manual-linux-systemd",
+    "difficulty": "easy"
+  },
+  {
+    "id": "linux-q69",
+    "lesson_id": "linux-at",
+    "question_type": "multiple_choice",
+    "question": "매일 반복이 아닌 내일 새벽 3시에 한 번만 백업 스크립트를 실행하려 합니다. 적절한 도구는?",
+    "options": [
+      "at",
+      "cron",
+      "systemd timer",
+      "nohup"
+    ],
+    "answer": "at",
+    "explanation": "`at`은 일회성 예약 실행을 위한 도구입니다. cron은 반복 스케줄에 적합하고, nohup은 터미널 종료 후에도 프로세스를 유지하기 위한 도구로 스케줄링 기능은 없습니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-q70",
+    "lesson_id": "linux-docker-basics",
+    "question_type": "multiple_choice",
+    "question": "nginx 컨테이너를 백그라운드로 실행하고 호스트 포트 8080을 컨테이너 포트 80에 연결하는 명령은?",
+    "options": [
+      "docker run -d -p 8080:80 nginx",
+      "docker run -p 80:8080 nginx",
+      "docker start -p 8080:80 nginx",
+      "docker run --port 8080=80 -b nginx"
+    ],
+    "answer": "docker run -d -p 8080:80 nginx",
+    "explanation": "`-d`는 detach(백그라운드), `-p 호스트포트:컨테이너포트`로 포트를 매핑합니다. `8080:80`은 호스트의 8080을 컨테이너의 80으로 포워딩합니다.",
+    "source_id": "manual-linux-docker",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-q71",
+    "lesson_id": "linux-docker-basics",
+    "question_type": "multiple_choice",
+    "question": "실행 중이거나 중지된 모든 컨테이너 목록을 보는 명령은?",
+    "options": [
+      "docker ps -a",
+      "docker ps",
+      "docker images",
+      "docker container ls"
+    ],
+    "answer": "docker ps -a",
+    "explanation": "`docker ps`는 실행 중인 컨테이너만 표시합니다. `-a`(all) 플래그를 추가하면 중지된 컨테이너까지 모두 표시합니다.",
+    "source_id": "manual-linux-docker",
+    "difficulty": "easy"
+  },
+  {
+    "id": "linux-q72",
+    "lesson_id": "linux-grub-boot",
+    "question_type": "multiple_choice",
+    "question": "`/etc/default/grub`에서 `GRUB_TIMEOUT=10`으로 변경 후 적용하는 명령은? (Ubuntu 기준)",
+    "options": [
+      "update-grub",
+      "grub-install",
+      "systemctl restart grub",
+      "reboot"
+    ],
+    "answer": "update-grub",
+    "explanation": "`/etc/default/grub`은 템플릿 역할을 하며, `update-grub`(Ubuntu) 또는 `grub2-mkconfig -o /boot/grub2/grub.cfg`(RHEL)를 실행해야 실제 GRUB 설정 파일에 반영됩니다.",
+    "source_id": "manual-linux-boot",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-q73",
+    "lesson_id": "linux-grub-boot",
+    "question_type": "multiple_choice",
+    "question": "시스템이 그래픽 환경 없이 CLI 다중 사용자 모드로 기본 부팅되게 하는 명령은?",
+    "options": [
+      "systemctl set-default multi-user.target",
+      "systemctl set-default graphical.target",
+      "update-grub --target=cli",
+      "systemctl disable gdm"
+    ],
+    "answer": "systemctl set-default multi-user.target",
+    "explanation": "`multi-user.target`은 GUI 없이 네트워크와 다중 사용자 환경을 제공하는 target(runlevel 3 상당)입니다. `graphical.target`(runlevel 5)에서 변경하면 다음 재시작부터 CLI로 부팅됩니다.",
+    "source_id": "manual-linux-boot",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-q74",
+    "lesson_id": "linux-find",
+    "question_type": "multiple_choice",
+    "question": "7일 이상 수정되지 않은 `/var/log`의 `.log` 파일을 찾아 일괄 삭제하려 합니다. 올바른 명령은?",
+    "options": [
+      "find /var/log -name '*.log' -mtime +7 -delete",
+      "find /var/log -name '*.log' -mtime 7 -rm",
+      "grep -r '.log' /var/log | xargs rm",
+      "ls -lt /var/log/*.log | tail -n +8 | xargs rm"
+    ],
+    "answer": "find /var/log -name '*.log' -mtime +7 -delete",
+    "explanation": "`-mtime +7`은 마지막 수정 후 7일 초과된 파일, `-delete`는 find 내장 삭제 액션입니다. `-mtime 7`(정확히 7일)과 `-mtime +7`(7일 초과)의 차이에 주의하세요.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "hard"
+  },
+  {
+    "id": "linux-q75",
+    "lesson_id": "linux-pipe-redirect",
+    "question_type": "multiple_choice",
+    "question": "`ls /notexist 2>/dev/null && echo OK`의 실행 결과는?",
+    "options": [
+      "아무것도 출력되지 않는다",
+      "OK가 출력된다",
+      "오류 메시지가 출력된다",
+      "OK와 오류 메시지가 함께 출력된다"
+    ],
+    "answer": "아무것도 출력되지 않는다",
+    "explanation": "`2>/dev/null`로 stderr를 버리고, `ls /notexist`가 실패(exit code != 0)하므로 `&&` 뒤의 `echo OK`는 실행되지 않습니다. 결과적으로 아무것도 출력되지 않습니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-q76",
+    "lesson_id": "linux-systemctl",
+    "question_type": "multiple_choice",
+    "question": "서버 재시작 후에도 nginx가 자동으로 시작되게 하려 합니다. 현재 실행 중이며 enable만 빠진 상태입니다. 필요한 명령은?",
+    "options": [
+      "systemctl enable nginx",
+      "systemctl start nginx",
+      "systemctl enable --now nginx",
+      "systemctl restart nginx"
+    ],
+    "answer": "systemctl enable nginx",
+    "explanation": "이미 실행 중이므로 `start`는 불필요합니다. `enable`만 하면 부팅 시 자동 시작 심볼릭 링크가 생성됩니다. `enable --now`는 enable + start를 동시에 처리합니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "easy"
+  },
+  {
+    "id": "linux-q77",
+    "lesson_id": "linux-acl",
+    "question_type": "multiple_choice",
+    "question": "`/project` 디렉터리를 `devteam` 그룹 멤버 모두가 읽고 쓸 수 있게 하고, 새로 생성된 파일도 같은 그룹 소유가 되게 하는 설정은?",
+    "options": [
+      "chmod 2775 /project && chgrp devteam /project",
+      "chmod 777 /project",
+      "setfacl -m g:devteam:rw /project",
+      "chown devteam /project && chmod 755 /project"
+    ],
+    "answer": "chmod 2775 /project && chgrp devteam /project",
+    "explanation": "`2775`의 앞 자리 2는 SGID(Set Group ID) 비트입니다. SGID가 설정된 디렉터리에서 생성된 파일은 자동으로 디렉터리의 그룹 소유가 됩니다. `775`는 소유자·그룹 읽기/쓰기/실행, 기타 읽기/실행을 부여합니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "hard"
+  },
+  {
+    "id": "linux-q78",
+    "lesson_id": "linux-fstab",
+    "question_type": "multiple_choice",
+    "question": "`/etc/fstab`에 UUID 기반으로 항목을 추가할 때 UUID를 확인하는 명령은?",
+    "options": [
+      "blkid",
+      "lsblk -f",
+      "fdisk -l",
+      "mount -l"
+    ],
+    "answer": "blkid",
+    "explanation": "`blkid`는 블록 디바이스의 UUID, TYPE(파일시스템), LABEL을 출력��니다. `lsblk -f`도 유사한 정보를 트리 형태로 보여줍니다. fstab에는 장치명(/dev/sdb1) 대신 UUID를 쓰는 것이 재부팅 시 장치 순서 변경에 안전합니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-q79",
+    "lesson_id": "linux-lvm",
+    "question_type": "multiple_choice",
+    "question": "LVM에서 논리 볼륨의 크기를 20GB로 늘리고 ext4 파일시스템도 함께 확장하는 명령 순서는?",
+    "options": [
+      "lvextend -L 20G /dev/vg0/lv0 → resize2fs /dev/vg0/lv0",
+      "resize2fs /dev/vg0/lv0 → lvextend -L 20G /dev/vg0/lv0",
+      "vgextend vg0 → resize2fs /dev/vg0/lv0",
+      "lvextend -r -L 20G /dev/vg0/lv0 만으로 완료"
+    ],
+    "answer": "lvextend -r -L 20G /dev/vg0/lv0 만으로 완료",
+    "explanation": "`lvextend -r`(또는 `--resizefs`)은 LV 확장과 파일시스템 확장을 한 번에 처리합니다. 별도로 `resize2fs`를 실행해도 되지만 `-r` 옵션 하나로 통합 가능합니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "hard"
+  },
+  {
+    "id": "linux-q80",
+    "lesson_id": "linux-ssh",
+    "question_type": "multiple_choice",
+    "question": "SSH 서버에서 root 계정의 비밀번호 로그인을 차단하고 키 기반 인증만 허용하려면 `sshd_config`에서 설정할 항목은?",
+    "options": [
+      "PermitRootLogin prohibit-password",
+      "PermitRootLogin no",
+      "PasswordAuthentication no",
+      "PermitRootLogin prohibit-password 와 PasswordAuthentication no 모두"
+    ],
+    "answer": "PermitRootLogin prohibit-password 와 PasswordAuthentication no 모두",
+    "explanation": "`PermitRootLogin prohibit-password`는 root의 비밀번호 인증만 차단(키 인증은 허용). `PasswordAuthentication no`는 모든 사용자의 비밀번호 인증을 차단합니다. 둘을 함께 적용해야 root 비밀번호 로그인이 완전히 차단됩니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-cmd-1",
+    "lesson_id": "linux-cp-mv-rm",
+    "question_type": "command",
+    "question": "`/etc/hosts` 파일을 권한·소유자·타임스탬프를 보존하며 `/tmp/hosts.bak`으로 복사하는 명령을 입력하세요.",
+    "options": [],
+    "answer": "cp -a /etc/hosts /tmp/hosts.bak",
+    "explanation": "`cp -a`는 `-dR --preserve=all`의 단축으로 속성을 완전히 보존합니다. 단순 `cp`는 타임스탬프와 권한을 보존하지 않습니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-cmd-2",
+    "lesson_id": "linux-grep",
+    "question_type": "command",
+    "question": "`/etc/ssh/sshd_config` 파일에서 주석(#으로 시작하는 줄)을 제외하고 내용을 출력하는 명령을 입력하세요.",
+    "options": [],
+    "answer": "grep -v '^#' /etc/ssh/sshd_config",
+    "explanation": "`-v`는 패턴과 일치하지 않는 줄을 출력(반전), `^#`은 줄의 시작이 #인 줄을 의미합니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-cmd-3",
+    "lesson_id": "linux-find",
+    "question_type": "command",
+    "question": "시스템 전체에서 SUID 비트가 설정된 파일을 찾는 명령을 입력하세요.",
+    "options": [],
+    "answer": "find / -perm -4000 -type f",
+    "explanation": "`-perm -4000`은 SUID 비트(4000)가 설정된 파일을 찾습니다. `-`를 앞에 붙이면 해당 비트가 포함된 파일 모두를 찾습니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "hard"
+  },
+  {
+    "id": "linux-cmd-4",
+    "lesson_id": "linux-tar",
+    "question_type": "command",
+    "question": "`/var/log` 디렉터리를 gzip 압축해 `/tmp/log_backup.tar.gz`로 만드는 명령을 입력하세요.",
+    "options": [],
+    "answer": "tar -czf /tmp/log_backup.tar.gz /var/log",
+    "explanation": "`-c`(create), `-z`(gzip 압축), `-f`(파일 이름 지정). 생성할 아카이브 이름 → 원본 경로 순서로 인수를 씁니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-cmd-5",
+    "lesson_id": "linux-tar",
+    "question_type": "command",
+    "question": "`/tmp/log_backup.tar.gz`의 내용을 현재 디렉터리에 압축 해제하는 명령을 입력하세요.",
+    "options": [],
+    "answer": "tar -xzf /tmp/log_backup.tar.gz",
+    "explanation": "`-x`(extract), `-z`(gzip), `-f`(파일 이름). `-C /경로`를 추가하면 특정 디렉터리에 압축 해제할 수 있습니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "easy"
+  },
+  {
+    "id": "linux-cmd-6",
+    "lesson_id": "linux-chmod",
+    "question_type": "command",
+    "question": "`/srv/app` 디렉터리와 그 하위 모든 파일에 소유자는 rwx, 그룹은 rx, 기타는 아무 권한도 없게 재귀적으로 설정하는 명령을 입력하세요.",
+    "options": [],
+    "answer": "chmod -R 750 /srv/app",
+    "explanation": "`750` = 소유자(7=rwx), 그룹(5=r-x), 기타(0=---). `-R`은 재귀 적용입니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-cmd-7",
+    "lesson_id": "linux-acl",
+    "question_type": "command",
+    "question": "`/project` 디렉터리에 `devteam` 그룹이 읽기·쓰기·실행 권한을 갖도록 ACL을 설정하는 명령을 입력하세요.",
+    "options": [],
+    "answer": "setfacl -m g:devteam:rwx /project",
+    "explanation": "`setfacl -m`(modify) `g:그룹명:권한` 형식으로 그룹 ACL을 설정합니다. 기존 권한은 유지됩니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "hard"
+  },
+  {
+    "id": "linux-cmd-8",
+    "lesson_id": "linux-useradd",
+    "question_type": "command",
+    "question": "홈 디렉터리를 자동 생성하면서 `alice`라는 사용자를 만들고 기본 셸을 `/bin/bash`로 설정하는 명령을 입력하세요.",
+    "options": [],
+    "answer": "useradd -m -s /bin/bash alice",
+    "explanation": "`-m`은 홈 디렉터리 생성, `-s`는 기본 셸 지정입니다. 이 옵션 없이 useradd만 실행하면 홈 디렉터리가 생성되지 않습니다.",
+    "source_id": "ubuntu-user-management",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-cmd-9",
+    "lesson_id": "linux-chage",
+    "question_type": "command",
+    "question": "`bob` 사용자의 비밀번호 만료 정책(최대 사용일, 경고일 등)을 확인하는 명령을 입력하세요.",
+    "options": [],
+    "answer": "chage -l bob",
+    "explanation": "`chage -l`(list)은 사용자의 비밀번호 정책(마지막 변경일, 최대 사용일, 경고일, 계정 만료일)을 보기 좋게 출력합니다.",
+    "source_id": "ubuntu-user-management",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-cmd-10",
+    "lesson_id": "linux-systemctl",
+    "question_type": "command",
+    "question": "`nginx` 서비스가 현재 실행 중인지 확인하는 명령을 입력하세요.",
+    "options": [],
+    "answer": "systemctl status nginx",
+    "explanation": "`systemctl status`는 서비스 상태, 최근 로그, PID, 메모리 사용량을 한눈에 보여줍니다. `is-active nginx`는 active/inactive만 출력합니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "easy"
+  },
+  {
+    "id": "linux-cmd-11",
+    "lesson_id": "linux-systemd-unit",
+    "question_type": "command",
+    "question": "유닛 파일 수정 후 systemd가 변경 사항을 인식하도록 새로고침하는 명령을 입력하세요.",
+    "options": [],
+    "answer": "systemctl daemon-reload",
+    "explanation": "유닛 파일(`/etc/systemd/system/*.service`)을 수정하면 systemd가 자동으로 감지하지 않습니다. `daemon-reload` 후 `restart`해야 변경이 적용됩니다.",
+    "source_id": "manual-linux-systemd",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-cmd-12",
+    "lesson_id": "linux-journalctl",
+    "question_type": "command",
+    "question": "`nginx` 서비스의 로그를 최근 50줄만 출력하는 명령을 입력하세요.",
+    "options": [],
+    "answer": "journalctl -u nginx -n 50",
+    "explanation": "`-u`는 특정 유닛(서비스) 필터, `-n 50`은 최근 50줄 출력입니다. `-f`를 추가하면 실시간 스트리밍됩니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-cmd-13",
+    "lesson_id": "linux-cron",
+    "question_type": "command",
+    "question": "현재 사용자의 crontab을 편집하는 명령을 입력하세요.",
+    "options": [],
+    "answer": "crontab -e",
+    "explanation": "`crontab -e`는 기본 편집기로 현재 사용자의 crontab을 엽니다. `-l`은 목록 확인, `-r`은 삭제입니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "easy"
+  },
+  {
+    "id": "linux-cmd-14",
+    "lesson_id": "linux-df-du-mount",
+    "question_type": "command",
+    "question": "현재 마운트된 파일시스템의 디스크 사용량을 사람이 읽기 쉬운 단위(GB, MB)로 출력하는 명령을 입력하세요.",
+    "options": [],
+    "answer": "df -h",
+    "explanation": "`df -h`는 `-h`(human-readable) 옵션으로 GB, MB 단위로 용량을 표시합니다. `-T`를 추가하면 파일시스템 유형도 함께 출력됩니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "easy"
+  },
+  {
+    "id": "linux-cmd-15",
+    "lesson_id": "linux-lvm",
+    "question_type": "command",
+    "question": "시스템의 모든 논리 볼륨(LV) 목록을 확인하는 명령을 입력하세요.",
+    "options": [],
+    "answer": "lvs",
+    "explanation": "`lvs`(LV summary)는 간결한 LV 목록을 출력합니다. `lvdisplay`는 더 자세한 정보를, `lvscan`은 모든 LV와 활성 상태를 보여줍니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-cmd-16",
+    "lesson_id": "linux-fstab",
+    "question_type": "command",
+    "question": "`/etc/fstab`에 등록된 모든 파일시스템을 마운트하는 명령을 입력하세요.",
+    "options": [],
+    "answer": "mount -a",
+    "explanation": "`mount -a`는 fstab의 noauto 옵션이 없는 모든 항목을 마운트합니다. fstab 수정 후 재부팅 없이 테스트할 때 사용합니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-cmd-17",
+    "lesson_id": "linux-ssh-key",
+    "question_type": "command",
+    "question": "ED25519 알고리즘으로 SSH 키 쌍을 생성하는 명령을 입력하세요.",
+    "options": [],
+    "answer": "ssh-keygen -t ed25519",
+    "explanation": "ED25519는 RSA 4096보다 짧고 강력한 알고리즘입니다. 생성된 공개 키(`~/.ssh/id_ed25519.pub`)를 서버의 `authorized_keys`에 등록합니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-cmd-18",
+    "lesson_id": "linux-sed",
+    "question_type": "command",
+    "question": "`/etc/hosts` 파일에서 `oldhost`를 `newhost`로 모두 바꿔 파일을 직접 수정하는 명령을 입력하세요.",
+    "options": [],
+    "answer": "sed -i 's/oldhost/newhost/g' /etc/hosts",
+    "explanation": "`-i`는 파일을 직접 수정(in-place), `s/패턴/교체/g`에서 `g`는 줄 내 모든 일치 항목을 교체합니다. `-i.bak`으로 백업도 만들 수 있습니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "hard"
+  },
+  {
+    "id": "linux-cmd-19",
+    "lesson_id": "linux-text-pipeline",
+    "question_type": "command",
+    "question": "`/var/log/auth.log`에서 `Failed` 문자열이 포함된 줄만 뽑아 IP 주소 필드(첫 번째 공백 기준 필드 11)별 시도 횟수를 내림차순으로 출력하는 파이프라인을 입력하세요.",
+    "options": [],
+    "answer": "grep 'Failed' /var/log/auth.log | awk '{print $11}' | sort | uniq -c | sort -rn",
+    "explanation": "grep→awk로 필드 추출→sort로 정렬→uniq -c로 중복 카운트→sort -rn으로 내림차순. 브루트포스 공격 IP를 파악하는 실전 패턴입니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "hard"
+  },
+  {
+    "id": "linux-cmd-20",
+    "lesson_id": "linux-docker-basics",
+    "question_type": "command",
+    "question": "실행 중인 `webserver` 컨테이너 내부에서 `/bin/bash` 셸을 인터랙티브 터미널로 실행하는 명령을 입력하세요.",
+    "options": [],
+    "answer": "docker exec -it webserver /bin/bash",
+    "explanation": "`docker exec -it`는 실행 중인 컨테이너 내부에서 명령을 실행합니다. `-i`(stdin 유지), `-t`(터미널 할당). 컨테이너 안에서 디버깅할 때 필수 패턴입니다.",
+    "source_id": "manual-linux-docker",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-cmd-21",
+    "lesson_id": "linux-mkfs-fsck",
+    "question_type": "command",
+    "question": "`/dev/sdb1` 파티션의 UUID를 확인하는 명령을 입력하세요.",
+    "options": [],
+    "answer": "blkid /dev/sdb1",
+    "explanation": "`blkid`는 블록 디바이스의 UUID, 파일시스템 유형(TYPE), 레이블을 출력합니다. fstab에 UUID 기반으로 등록할 때 이 명령으로 값을 확인합니다.",
+    "source_id": "manual-linux-storage",
+    "difficulty": "medium"
+  },
+  {
+    "id": "linux-cmd-22",
+    "lesson_id": "linux-at",
+    "question_type": "command",
+    "question": "1시간 후에 `/usr/local/bin/cleanup.sh`를 한 번 실행하도록 예약하는 명령을 입력하세요.",
+    "options": [],
+    "answer": "echo '/usr/local/bin/cleanup.sh' | at now + 1 hour",
+    "explanation": "`echo '명령' | at 시간` 형식으로 일회성 작업을 예약합니다. 예약 목록은 `atq`, 취소는 `atrm 번호`로 관리합니다.",
+    "source_id": "manual-linux-basic",
+    "difficulty": "hard"
+  }
+]

cert_study_app/content/loader.py

@@ -0,0 +1,34 @@
+"""JSON-based content loader for lessons, quizzes, and practice tasks.
+
+New content lives in cert_study_app/content/{track}/{type}.json.
+Returns raw dicts — callers convert to dataclass types.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+CONTENT_DIR = Path(__file__).parent
+
+
+def _load(track_id: str, filename: str) -> list[dict]:
+    path = CONTENT_DIR / track_id / filename
+    if not path.exists():
+        return []
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+        return data if isinstance(data, list) else []
+    except Exception:
+        return []
+
+
+def load_lesson_dicts(track_id: str) -> list[dict]:
+    return _load(track_id, "lessons.json")
+
+
+def load_quiz_dicts(track_id: str) -> list[dict]:
+    return _load(track_id, "quizzes.json")
+
+
+def load_practice_dicts(track_id: str) -> list[dict]:
+    return _load(track_id, "practices.json")

cert_study_app/content/tool_docs/lessons.json

@@ -0,0 +1,529 @@
+[
+  {
+    "id": "docs-ollama-models",
+    "certification": "Docs Study",
+    "title": "Ollama 모델 실행 흐름",
+    "level": "입문",
+    "related_practices": ["docs-lab-1", "docs-lab-2"],
+    "summary": "Ollama는 로컬에서 LLM 모델을 내려받고 실행해 CLI 또는 REST API로 사용할 수 있게 해주는 경량 모델 서버입니다. `ollama run`으로 대화하고, `ollama serve`로 API 서버를 유지합니다.",
+    "example": "# 모델 다운로드 및 실행\nollama pull qwen2.5:14b\nollama run qwen2.5:14b\n# 설치된 모델 목록\nollama list",
+    "common_mistake": "모델 이름에 태그(:14b, :latest 등)를 생략하면 `:latest`로 자동 설정됩니다. 모델이 로컬에 없을 때 `ollama run`이 자동으로 pull합니다.",
+    "keywords": ["ollama", "pull", "run", "serve", "model tag", "GGUF", "local LLM"],
+    "source_id": "official-docs-ollama",
+    "details": [
+      "**`ollama run`**: 모델이 없으면 자동 다운로드 후 대화형 세션 시작. `--nowordwrap` 옵션으로 긴 출력 처리 가능.",
+      "**`ollama serve`**: 11434 포트에서 OpenAI 호환 REST API 제공. `OLLAMA_HOST=0.0.0.0`으로 외부 접근 허용 가능.",
+      "모델 파일은 `~/.ollama/models`에 GGUF 형식으로 저장됩니다. `Modelfile`로 커스텀 시스템 프롬프트와 파라미터를 설정할 수 있습니다."
+    ]
+  },
+  {
+    "id": "docs-ollama-api",
+    "certification": "Docs Study",
+    "title": "Ollama REST API 호출",
+    "level": "입문",
+    "related_practices": ["docs-lab-3"],
+    "summary": "Ollama는 `localhost:11434`에서 REST API를 제공합니다. `/api/generate`(완성형), `/api/chat`(대화형), `/api/embeddings`(임베딩) 엔드포인트를 OpenAI 호환 형식으로도 지원합니다.",
+    "example": "# chat 엔드포인트\ncurl http://localhost:11434/api/chat -d '{\n  \"model\": \"qwen2.5:7b\",\n  \"messages\": [{\"role\": \"user\", \"content\": \"안녕\"}],\n  \"stream\": false\n}'",
+    "common_mistake": "Ollama 서버(`ollama serve`)가 실행 중이지 않거나 모델이 로컬에 없으면 API 호출이 실패합니다. 먼저 `ollama list`로 모델 존재를 확인하세요.",
+    "keywords": ["ollama", "REST API", "generate", "chat", "embeddings", "localhost:11434", "stream"],
+    "source_id": "official-docs-ollama",
+    "details": [
+      "**OpenAI 호환 API**: `http://localhost:11434/v1/chat/completions`로 OpenAI Python SDK나 LangChain의 `ChatOpenAI(base_url=...)` 그대로 사용 가능합니다.",
+      "**스트리밍**: `\"stream\": true` 설정 시 응답을 JSON 줄 단위로 스트리밍. `\"done\": true` 줄이 완료 신호입니다.",
+      "**임베딩**: `POST /api/embeddings`에 `{\"model\":\"nomic-embed-text\", \"prompt\":\"텍스트\"}`를 보내면 벡터 배열을 반환합니다."
+    ]
+  },
+  {
+    "id": "docs-dotenv",
+    "certification": "Docs Study",
+    "title": "python-dotenv — 환경변수 & .env 관리",
+    "level": "입문",
+    "related_practices": ["docs-lab-4"],
+    "summary": "python-dotenv는 `.env` 파일의 키-값 쌍을 `os.environ`에 자동으로 로드합니다. API 키 같은 민감 정보를 코드에 직접 쓰지 않고 파일로 분리해 관리하는 표준 방법입니다.",
+    "example": "# .env 파일\nOPENAI_API_KEY=sk-...\nOLLAMA_BASE_URL=http://localhost:11434\n\n# Python 코드\nfrom dotenv import load_dotenv\nimport os\n\nload_dotenv()  # .env 파일 로드\napi_key = os.getenv('OPENAI_API_KEY')",
+    "common_mistake": "`load_dotenv()`를 호출하기 전에 `os.getenv()`를 쓰면 항상 `None`을 반환합니다. 반드시 파일 상단에서 가장 먼저 `load_dotenv()`를 호출하세요.",
+    "keywords": ["dotenv", "load_dotenv", ".env", "os.getenv", "환경변수", "API 키"],
+    "source_id": "official-docs-python",
+    "details": [
+      "**우선순위**: `load_dotenv(override=False)`(기본값)는 이미 설정된 환경변수를 덮어쓰지 않습니다. CI/CD 환경에서 시스템 환경변수가 .env보다 우선합니다.",
+      "**.gitignore**: `.env`는 반드시 `.gitignore`에 추가해야 합니다. `.env.example`은 키 이름만 적어 팀원에게 어떤 변수가 필요한지 알려주는 용도로 커밋합니다.",
+      "**Streamlit 연동**: 로컬 개발 시 `load_dotenv()`로 키를 로드하고, 배포 시에는 `st.secrets`로 접근하도록 분기하거나 처음부터 `st.secrets`만 쓰는 방식 중 하나를 선택합니다."
+    ]
+  },
+  {
+    "id": "docs-prompt-template",
+    "certification": "Docs Study",
+    "title": "ChatPromptTemplate — 프롬프트 구조화",
+    "level": "입문",
+    "related_practices": ["docs-lab-5", "docs-lab-6"],
+    "summary": "ChatPromptTemplate은 시스템 프롬프트, 사용자 메시지, 변수 플레이스홀더를 구조화된 방식으로 정의합니다. 단순 f-string 대신 재사용 가능하고 LangChain 파이프라인에 연결되는 프롬프트를 만들 때 씁니다.",
+    "example": "from langchain_core.prompts import ChatPromptTemplate\n\nprompt = ChatPromptTemplate.from_messages([\n    (\"system\", \"당신은 도움이 되는 AI 어시스턴트입니다. 컨텍스트: {context}\"),\n    (\"human\", \"{question}\")\n])\n\n# 체인에 연결\nchain = prompt | llm | StrOutputParser()\nchain.invoke({\"context\": \"...\", \"question\": \"요약해줘\"})",
+    "common_mistake": "`PromptTemplate`은 단순 문자열 포맷용(변수 하나), `ChatPromptTemplate`은 역할이 구분된 메시지 배열용입니다. RAG에서 시스템 프롬프트와 질문을 구분하려면 항상 ChatPromptTemplate을 씁니다.",
+    "keywords": ["ChatPromptTemplate", "from_messages", "system", "human", "placeholder", "PromptTemplate"],
+    "source_id": "official-docs-langchain",
+    "details": [
+      "**MessagesPlaceholder**: 대화 히스토리를 통째로 주입할 때 씁니다. `(\"placeholder\", \"{chat_history}\")`로 선언하면 메시지 리스트가 그 자리에 펼쳐집니다.",
+      "**partial**: `prompt.partial(context=\"고정값\")`으로 특정 변수를 미리 채울 수 있습니다. context는 고정하고 question만 런타임에 받을 때 유용합니다.",
+      "**타입 안전성**: from_messages에 `(\"system\", \"...\")` 튜플 대신 `SystemMessage(content=\"...\")`를 사용해도 동일합니다. 튜플 방식이 더 간결합니다."
+    ]
+  },
+  {
+    "id": "docs-document-loaders",
+    "certification": "Docs Study",
+    "title": "LangChain Document Loaders — 문서 일괄 로드",
+    "level": "입문",
+    "related_practices": ["docs-lab-7"],
+    "summary": "Document Loader는 PDF, 마크다운, 웹 페이지, 디렉토리 등 다양한 소스에서 문서를 LangChain `Document` 객체로 변환합니다. RAG 파이프라인의 첫 단계입니다.",
+    "example": "from langchain_community.document_loaders import DirectoryLoader, PyPDFLoader\n\n# 디렉토리 내 모든 .md 파일 로드\nloader = DirectoryLoader('./notes', glob='**/*.md')\ndocs = loader.load()\n\n# 각 문서의 출처 확인\nfor doc in docs:\n    print(doc.metadata['source'], len(doc.page_content))",
+    "common_mistake": "`loader.load()`는 모든 문서를 메모리에 올립니다. 대용량 디렉토리에서는 `loader.lazy_load()`로 제너레이터를 쓰거나 배치로 처리해야 합니다.",
+    "keywords": ["DirectoryLoader", "PyPDFLoader", "WebBaseLoader", "glob", "metadata", "source", "lazy_load"],
+    "source_id": "official-docs-langchain",
+    "details": [
+      "**metadata['source']**: 로드된 문서는 `metadata` 딕셔너리에 파일 경로(`source`)를 포함합니다. RAG 답변에 출처를 표시할 때 이 값을 씁니다.",
+      "**glob 패턴**: `glob='**/*.md'`는 하위 폴더까지 재귀 검색합니다. `glob='*.pdf'`는 현재 폴더만 검색합니다.",
+      "**WebBaseLoader**: URL 리스트를 넘기면 웹 페이지를 크롤링해 Document로 변환합니다. BeautifulSoup 기반이며 `bs_kwargs`로 파싱 범위를 지정할 수 있습니다."
+    ]
+  },
+  {
+    "id": "docs-langchain-rag",
+    "certification": "Docs Study",
+    "title": "LangChain RAG 기본 흐름",
+    "level": "입문",
+    "related_practices": ["docs-lab-8", "docs-lab-9"],
+    "summary": "LangChain은 문서 로드 → 분할 → 임베딩 → 검색 → 생성의 RAG 파이프라인을 컴포넌트 조합으로 구현합니다. Retriever가 관련 문서를 찾아 LLM 컨텍스트로 주입합니다.",
+    "example": "from langchain_community.vectorstores import Chroma\nretriever = Chroma.from_documents(docs, embeddings).as_retriever(k=3)\nchain = (\n    {\"context\": retriever, \"question\": RunnablePassthrough()}\n    | prompt | llm | StrOutputParser()\n)",
+    "common_mistake": "Retriever가 찾은 문서를 그대로 정답으로 믿지 마세요. 검색된 청크가 질문과 다른 맥락일 수 있어 프롬프트에서 명시적으로 '아래 문서를 참고해'라고 지시해야 합니다.",
+    "keywords": ["langchain", "RAG", "retriever", "vectorstore", "document loader", "text splitter"],
+    "source_id": "official-docs-langchain",
+    "details": [
+      "**파이프라인 단계**: DocumentLoader → TextSplitter(청크 분할) → Embeddings → VectorStore → Retriever → LLM Chain.",
+      "**TextSplitter**: `RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)`이 일반적 시작점. overlap이 있어야 청크 경계에서 문맥 손실을 줄입니다.",
+      "`MultiQueryRetriever`나 `ContextualCompressionRetriever`로 검색 품질을 높일 수 있습니다. 단순 유사도 검색보다 관련 청크 선별 정확도가 올라갑니다."
+    ]
+  },
+  {
+    "id": "docs-lcel",
+    "certification": "Docs Study",
+    "title": "LangChain LCEL — 체인 구성",
+    "level": "입문",
+    "related_practices": ["docs-lab-10", "docs-lab-11"],
+    "summary": "LCEL(LangChain Expression Language)은 `|` 파이프 연산자로 Runnable 컴포넌트를 직렬·병렬 연결해 체인을 선언적으로 정의합니다.",
+    "example": "from langchain_core.runnables import RunnablePassthrough\nchain = (\n    RunnablePassthrough.assign(context=retriever)\n    | prompt\n    | llm\n    | StrOutputParser()\n)\nresult = chain.invoke({\"question\": \"What is RAG?\"})",
+    "common_mistake": "체인 각 단계의 입출력 타입이 맞아야 합니다. LLM은 `str` 또는 `BaseMessage`를 받고 반환하므로, 앞 단계가 딕셔너리를 반환하면 프롬프트 템플릿이 중간에서 받아 처리해야 합니다.",
+    "keywords": ["LCEL", "Runnable", "pipe", "chain", "invoke", "stream", "batch"],
+    "source_id": "official-docs-langchain",
+    "details": [
+      "**3가지 실행 방식**: `invoke`(단일 동기), `stream`(스트리밍 yield), `batch`(리스트 병렬 처리). 스트리밍 UI에는 `stream`을 씁니다.",
+      "**RunnablePassthrough**: 입력을 그대로 다음 단계로 전달. `.assign(key=fn)`으로 추가 키를 붙여 딕셔너리를 확장합니다.",
+      "**RunnableParallel**: `{\"a\": fn1, \"b\": fn2}` 형태로 여러 체인을 동시에 실행해 결과를 딕셔너리로 합칩니다."
+    ]
+  },
+  {
+    "id": "docs-vectorstore",
+    "certification": "Docs Study",
+    "title": "VectorStore와 Retriever — 벡터 검색",
+    "level": "입문",
+    "related_practices": ["docs-lab-11", "docs-lab-12"],
+    "summary": "문서를 임베딩 벡터로 변환해 저장하고, 쿼리와 코사인 유사도로 관련 청크를 검색합니다. Chroma, FAISS, pgvector 등 다양한 백엔드를 LangChain이 추상화합니다.",
+    "example": "from langchain_community.vectorstores import Chroma\nfrom langchain_ollama import OllamaEmbeddings\n\nembeddings = OllamaEmbeddings(model='nomic-embed-text')\ndb = Chroma.from_documents(docs, embeddings, persist_directory='./db')\nretriever = db.as_retriever(search_type='mmr', search_kwargs={'k': 4})",
+    "common_mistake": "임베딩 모델을 변경하면 벡터 차원이 달라져 기존 컬렉션과 호환되지 않습니다. 모델을 바꿀 때는 컬렉션을 새로 만들어야 합니다.",
+    "keywords": ["vectorstore", "Chroma", "FAISS", "embedding", "similarity", "MMR", "retriever"],
+    "source_id": "official-docs-langchain",
+    "details": [
+      "**검색 유형**: `similarity`(순수 유사도 상위 k개), `mmr`(MMR: 다양성 고려), `similarity_score_threshold`(임계값 이상만).",
+      "**Chroma**: 로컬 파일로 저장 가능(`persist_directory`). 프로토타입에 적합. 프로덕션은 pgvector(PostgreSQL), Qdrant, Pinecone 권장.",
+      "임베딩은 텍스트의 의미적 유사도를 잡지만, 정확한 키워드 매칭이 필요하면 BM25 등 키워드 검색과 `EnsembleRetriever`로 하이브리드 구성을 고려합니다."
+    ]
+  },
+  {
+    "id": "docs-streamlit-state",
+    "certification": "Docs Study",
+    "title": "Streamlit session_state — 상태 관리",
+    "level": "입문",
+    "related_practices": ["docs-lab-16", "docs-lab-17"],
+    "summary": "Streamlit은 상호작용마다 스크립트 전체를 rerun합니다. 버튼 클릭·입력 결과를 rerun 이후에도 유지하려면 `st.session_state`에 저장해야 합니다.",
+    "example": "if 'count' not in st.session_state:\n    st.session_state.count = 0\nif st.button('증가'):\n    st.session_state.count += 1\nst.write(f'클릭 횟수: {st.session_state.count}')",
+    "common_mistake": "일반 전역 변수나 함수 내 지역 변수는 rerun마다 초기화됩니다. 상태 보존이 필요한 모든 값은 반드시 `st.session_state`를 사용하세요.",
+    "keywords": ["session_state", "rerun", "widget", "state management", "callback"],
+    "source_id": "official-docs-streamlit",
+    "details": [
+      "**초기화 패턴**: `st.session_state.setdefault('key', default_value)` 또는 `if 'key' not in st.session_state:` 블록으로 안전하게 초기화합니다.",
+      "**Widget key**: `st.text_input('이름', key='username')`으로 위젯 값이 자동으로 `st.session_state.username`에 저장됩니다.",
+      "**callback**: `on_change=my_func`으로 위젯 변경 시 함수를 실행합니다. callback 안에서 session_state를 수정하면 rerun 전에 처리됩니다."
+    ]
+  },
+  {
+    "id": "docs-streamlit-cache",
+    "certification": "Docs Study",
+    "title": "Streamlit Cache — 캐시 데코레이터",
+    "level": "입문",
+    "related_practices": ["docs-lab-18"],
+    "summary": "rerun마다 반복 실행되는 비용 높은 계산·리소스 로딩을 캐시해 성능을 높입니다. `@st.cache_data`는 직렬화 가능 데이터, `@st.cache_resource`는 DB·모델 같은 공유 객체에 씁니다.",
+    "example": "@st.cache_resource\ndef load_model():\n    return SentenceTransformer('all-MiniLM-L6-v2')\n\n@st.cache_data(ttl=300)\ndef fetch_data(query: str):\n    return db.execute(query).fetchall()",
+    "common_mistake": "`cache_data`와 `cache_resource`를 혼동하면 문제가 생깁니다. LLM 모델이나 DB 연결처럼 공유해야 하는 객체는 반드시 `cache_resource`를 써야 합니다.",
+    "keywords": ["cache_data", "cache_resource", "TTL", "rerun", "performance"],
+    "source_id": "official-docs-streamlit",
+    "details": [
+      "**`@st.cache_data`**: 함수 인수를 키로 결과를 복사해 캐시. DataFrame, 리스트 등 직렬화 가능 반환값에 적합. `ttl` 인수로 만료 시간 설정 가능.",
+      "**`@st.cache_resource`**: 싱글톤처럼 한 번만 생성해 모든 세션이 공유. 모델 로딩, DB 연결, 벡터 스토어 초기화에 적합.",
+      "캐시 무효화: `st.cache_data.clear()` / `st.cache_resource.clear()`로 수동 초기화. 함수 본문이 바뀌면 자동으로 캐시가 무효화됩니다."
+    ]
+  },
+  {
+    "id": "docs-streamlit-secrets",
+    "certification": "Docs Study",
+    "title": "Streamlit Secrets — 비밀 관리",
+    "level": "입문",
+    "related_practices": ["docs-lab-4"],
+    "summary": "API 키, DB 비밀번호 등 민감 정보를 코드에 넣지 않고 `.streamlit/secrets.toml` 파일 또는 Streamlit Cloud의 Secrets UI에 저장합니다.",
+    "example": "# .streamlit/secrets.toml\n[database]\nhost = 'localhost'\npassword = 'secret'\n\n# 코드에서 접근\nimport streamlit as st\ndb_pass = st.secrets['database']['password']",
+    "common_mistake": "`.streamlit/secrets.toml`을 `.gitignore`에 추가하지 않으면 민감 정보가 Git에 커밋될 수 있습니다. 반드시 제외하세요.",
+    "keywords": ["secrets", "secrets.toml", "API key", ".gitignore", "Streamlit Cloud"],
+    "source_id": "official-docs-streamlit",
+    "details": [
+      "로컬 개발: `.streamlit/secrets.toml`에 TOML 형식으로 저장. 앱 코드에서 `st.secrets`로 딕셔너리처럼 접근합니다.",
+      "Streamlit Cloud: 앱 Settings → Secrets에 같은 TOML 내용을 붙여넣으면 배포 시 자동 주입됩니다.",
+      "`st.secrets`는 `os.environ`보다 구조화된 접근을 지원합니다. `st.secrets['key']`와 `st.secrets.key` 두 방식 모두 가능합니다."
+    ]
+  },
+  {
+    "id": "docs-hf-spaces",
+    "certification": "Docs Study",
+    "title": "Hugging Face Spaces — 앱 배포",
+    "level": "입문",
+    "related_practices": ["docs-lab-19"],
+    "summary": "Hugging Face Spaces는 Streamlit, Gradio, Docker 앱을 무료로 호스팅하는 환경입니다. README.md 상단의 YAML 메타데이터로 SDK와 파일을 지정합니다.",
+    "example": "# README.md 상단 (YAML frontmatter)\n---\ntitle: My App\nsdk: streamlit\napp_file: app.py\npython_version: '3.11'\n---",
+    "common_mistake": "API 키 등 민감 정보는 코드에 하드코딩하지 마세요. Space Settings → Secrets에 등록하고 코드에서는 `os.environ['MY_KEY']`로 참조합니다.",
+    "keywords": ["huggingface", "spaces", "SDK", "secrets", "app_file", "README metadata"],
+    "source_id": "official-docs-huggingface",
+    "details": [
+      "**무료 티어**: CPU 기본 제공, 공개 Space는 무료. GPU나 비공개 Space는 유료 플랜 또는 ZeroGPU(무료 공유 GPU) 활용.",
+      "**Secrets**: `Settings → Repository secrets`에 키-값으로 등록. 빌드 및 런타임에 환경 변수로 주입됩니다.",
+      "Space를 Duplicate(복제)하면 fork처럼 독립된 Space가 생성됩니다. 타인의 모델·앱을 내 Secrets와 함께 커스텀하는 일반적인 패턴입니다."
+    ]
+  },
+  {
+    "id": "docs-hf-docker-space",
+    "certification": "Docs Study",
+    "title": "Hugging Face Docker Space",
+    "level": "입문",
+    "related_practices": ["docs-lab-20"],
+    "summary": "Dockerfile로 앱 환경을 직접 정의하는 Space 배포 방식입니다. Streamlit/Gradio SDK 제약을 넘어 FastAPI, 커스텀 서버 등 어떤 앱도 배포할 수 있습니다.",
+    "example": "# README.md\n---\ntitle: My API\nsdk: docker\napp_port: 7860\n---\n\n# Dockerfile\nFROM python:3.11-slim\nCOPY . .\nRUN pip install -r requirements.txt\nEXPOSE 7860\nCMD [\"uvicorn\", \"main:app\", \"--host\", \"0.0.0.0\", \"--port\", \"7860\"]",
+    "common_mistake": "Docker Space는 포트 7860을 기본으로 노출합니다(`app_port: 7860`). 앱이 다른 포트를 사용하면 README 메타데이터의 `app_port`와 일치시켜야 합니다.",
+    "keywords": ["docker", "Dockerfile", "Spaces", "app_port", "FastAPI", "custom server"],
+    "source_id": "official-docs-huggingface",
+    "details": [
+      "**빌드 캐시**: Space는 이전 빌드 레이어를 캐시합니다. `COPY requirements.txt .` 후 `RUN pip install`을 배치해 의존성 레이어를 앱 코드보다 앞에 두면 빌드가 빠릅니다.",
+      "**Secrets**: `docker build --build-arg`가 아닌 Runtime Secrets로 주입해야 이미지에 민감 정보가 포함되지 않습니다. `os.environ`으로 접근합니다.",
+      "**모델 파일**: 대형 모델은 Space 저장소에 직접 넣지 말고 `huggingface_hub.snapshot_download()`로 런타임에 가져오거나 Dataset 저장소를 마운트하는 방식을 씁니다."
+    ]
+  },
+  {
+    "id": "docs-fastapi",
+    "certification": "Docs Study",
+    "title": "FastAPI — LLM 서비스 API 서버",
+    "level": "중급",
+    "related_practices": ["docs-lab-21"],
+    "summary": "FastAPI는 Python 타입 힌트 기반의 고성능 비동기 API 프레임워크입니다. RAG 체인이나 LLM 기능을 REST API 엔드포인트로 노출할 때 가장 많이 쓰입니다.",
+    "example": "from fastapi import FastAPI\nfrom pydantic import BaseModel\n\napp = FastAPI()\n\nclass Query(BaseModel):\n    question: str\n\n@app.post('/ask')\nasync def ask(q: Query):\n    answer = chain.invoke(q.question)\n    return {\"answer\": answer}\n\n# 실행\n# uvicorn main:app --reload",
+    "common_mistake": "LangChain 체인 같은 무거운 객체를 요청마다 생성하지 마세요. 모듈 레벨에서 한 번 초기화하거나 `lifespan` 이벤트로 앱 시작 시 로드하세요.",
+    "keywords": ["fastapi", "uvicorn", "pydantic", "async", "REST API", "endpoint", "lifespan"],
+    "source_id": "official-docs-fastapi",
+    "details": [
+      "**Pydantic**: 요청/응답 스키마를 `BaseModel`로 정의하면 자동 검증, OpenAPI 문서(`/docs`), JSON 직렬화가 무료로 제공됩니다.",
+      "**스트리밍 응답**: `StreamingResponse`와 async generator로 LLM 출력을 Server-Sent Events(SSE)로 스트리밍할 수 있습니다.",
+      "**lifespan**: `@asynccontextmanager`로 앱 시작 시 모델·DB 연결을 초기화하고 종료 시 정리하는 패턴. FastAPI 0.95+ 권장 방식입니다."
+    ]
+  },
+  {
+    "id": "docs-langsmith",
+    "certification": "Docs Study",
+    "title": "LangSmith — LLM 추적 & 평가",
+    "level": "중급",
+    "related_practices": ["docs-lab-13"],
+    "summary": "LangSmith는 LangChain 파이프라인의 모든 LLM 호출, 프롬프트, 응답, 지연시간을 자동 추적합니다. 버그 디버깅, 프롬프트 비교, 평가 데이터셋 관리를 한 곳에서 합니다.",
+    "example": "import os\nos.environ['LANGCHAIN_TRACING_V2'] = 'true'\nos.environ['LANGCHAIN_API_KEY'] = 'ls__...'\nos.environ['LANGCHAIN_PROJECT'] = 'my-rag-app'\n\n# 이후 LangChain 코드는 자동으로 추적됨\nresult = chain.invoke({'question': '질문'})",
+    "common_mistake": "추적 활성화는 환경변수 3개(`TRACING_V2=true`, `API_KEY`, `PROJECT`)가 모두 있어야 합니다. 하나라도 빠지면 조용히 추적이 안 됩니다.",
+    "keywords": ["langsmith", "tracing", "LangChain", "debugging", "evaluation", "dataset", "prompt"],
+    "source_id": "official-docs-langchain",
+    "details": [
+      "**Run 트레이스**: 체인 실행마다 tree 형태로 각 단계의 입출력·토큰 수·지연시간을 기록합니다. 어느 단계에서 오류가 났는지 즉시 파악할 수 있습니다.",
+      "**데이터셋 & 평가**: 프로덕션 오류 케이스를 Dataset으로 저장 → Evaluator(LLM-as-judge 등)로 자동 평가 → CI에 통합하는 흐름을 지원합니다.",
+      "**Playground**: LangSmith UI에서 특정 Run의 프롬프트를 바로 수정해 재실행 가능. 프롬프트 엔지니어링 반복에 유용합니다."
+    ]
+  },
+  {
+    "id": "docs-guardrails",
+    "certification": "Docs Study",
+    "title": "Guardrails AI — LLM 출력 검증",
+    "level": "중급",
+    "related_practices": ["docs-lab-14"],
+    "summary": "Guardrails AI는 LLM 입력/출력에 검증 규칙(Guard)을 적용합니다. 유해 콘텐츠 차단, JSON 스키마 강제, PII 마스킹 등 프로덕션 LLM 앱의 안전장치 역할을 합니다.",
+    "example": "from guardrails import Guard\nfrom guardrails.hub import ToxicLanguage\n\nguard = Guard().use(ToxicLanguage(threshold=0.5, on_fail='exception'))\n\nresult = guard(\n    llm_api=openai.chat.completions.create,\n    prompt='사용자 입력: {{user_input}}',\n    user_input=user_message\n)",
+    "common_mistake": "Guard는 LLM 호출을 래핑하므로 응답 시간이 증가합니다. 모든 요청에 heavy Guard를 걸면 지연이 커지니, 입력 검증과 출력 검증을 분리해 필요한 것만 적용하세요.",
+    "keywords": ["guardrails", "guard", "validation", "toxic", "PII", "JSON schema", "on_fail", "safety"],
+    "source_id": "official-docs-guardrails",
+    "details": [
+      "**Guard 허브**: `guardrails hub install hub://...`으로 커뮤니티 Guard를 설치합니다. ToxicLanguage, ValidJson, DetectPII, RegexMatch 등 수십 가지가 있습니다.",
+      "**on_fail 동작**: `'exception'`(예외 발생), `'reask'`(LLM에 재요청), `'fix'`(자동 수정), `'noop'`(통과) 중 선택합니다.",
+      "**구조화 출력**: `Guard.from_pydantic(OutputModel)`으로 LLM이 항상 지정한 스키마의 JSON을 반환하도록 강제할 수 있습니다."
+    ]
+  },
+  {
+    "id": "docs-gradio",
+    "certification": "Docs Study",
+    "title": "Gradio — ML 데모 UI",
+    "level": "중급",
+    "related_practices": ["docs-lab-22"],
+    "summary": "Gradio는 ML 모델 데모를 몇 줄로 만드는 UI 라이브러리입니다. `gr.Interface`로 함수를 감싸면 즉시 웹 UI가 생기고, HuggingFace Spaces와 네이티브 통합됩니다.",
+    "example": "import gradio as gr\n\ndef chat(message, history):\n    response = chain.invoke(message)\n    return response\n\ndemo = gr.ChatInterface(\n    fn=chat,\n    title='RAG 챗봇',\n    examples=['문서 요약해줘', '주요 키워드는?']\n)\ndemo.launch()",
+    "common_mistake": "Streamlit과 달리 Gradio는 함수 단위로 UI를 생성합니다. 복잡한 상태 관리는 `gr.State()`로, 여러 컴포넌트를 조합할 때는 `gr.Blocks()` 컨텍스트를 씁니다.",
+    "keywords": ["gradio", "Interface", "Blocks", "ChatInterface", "State", "HuggingFace", "demo"],
+    "source_id": "official-docs-gradio",
+    "details": [
+      "**Interface vs Blocks**: `gr.Interface`는 입력→함수→출력 단순 구조, `gr.Blocks`는 레이아웃과 이벤트를 자유롭게 구성. LLM 챗봇에는 `gr.ChatInterface`가 가장 적합합니다.",
+      "**스트리밍**: `gr.ChatInterface(fn=chat)`에서 `chat`을 generator 함수로 만들고 `yield`로 토큰을 내보내면 자동으로 스트리밍 UI가 됩니다.",
+      "**HF Spaces 통합**: `demo.launch()`만 하면 HF Spaces Gradio SDK로 즉시 배포됩니다. 별도 서버 설정 없이 `sdk: gradio`만 README에 선언하면 됩니다."
+    ]
+  },
+  {
+    "id": "docs-chroma",
+    "certification": "Docs Study",
+    "title": "Chroma — 영속 벡터 DB",
+    "level": "중급",
+    "related_practices": ["docs-chroma-1", "docs-chroma-2"],
+    "summary": "Chroma는 재시작해도 데이터가 유지되는 오픈소스 벡터 DB입니다. FAISS는 `save_local()`을 직접 호출해야 하지만, Chroma는 `persist_directory`만 지정하면 자동으로 로컬 DB에 저장합니다.",
+    "example": "from langchain_chroma import Chroma\n\n# 생성 & 자동 저장\ndb = Chroma.from_documents(\n    chunks,\n    embeddings,\n    persist_directory='./chroma_db'\n)\n\n# 다음 실행 시 — 임베딩 재계산 없이 로드\ndb = Chroma(\n    persist_directory='./chroma_db',\n    embedding_function=embeddings\n)",
+    "common_mistake": "FAISS처럼 `save_local()`을 별도로 호출할 필요가 없습니다. `persist_directory`를 지정하면 자동 저장됩니다. 단, `persist_directory`를 생략하면 인메모리로만 동작합니다.",
+    "keywords": ["Chroma", "persist_directory", "from_documents", "collection", "chromadb", "영속"],
+    "source_id": "official-docs-chromadb",
+    "details": [
+      "**FAISS vs Chroma**: FAISS는 인메모리 기반으로 `save_local()`로 수동 저장해야 합니다. Chroma는 `persist_directory`만 지정하면 SQLite 기반 로컬 DB에 자동 저장됩니다.",
+      "**컬렉션**: Chroma는 데이터를 컬렉션 단위로 관리합니다. `collection_name` 파라미터로 여러 문서 세트를 분리해 저장하고 개별로 검색할 수 있습니다.",
+      "**메타데이터 필터링**: `db.similarity_search(query, filter={\"source\": \"file.pdf\"})`처럼 메타데이터 조건으로 검색 범위를 제한할 수 있습니다. FAISS는 지원하지 않는 기능입니다."
+    ]
+  },
+  {
+    "id": "docs-sentence-transformers",
+    "certification": "Docs Study",
+    "title": "sentence-transformers — 로컬 임베딩",
+    "level": "중급",
+    "related_practices": ["docs-embed-1"],
+    "summary": "sentence-transformers는 HuggingFace 임베딩 모델을 로컬에서 실행합니다. OpenAI API 없이 완전 로컬 RAG를 구성할 수 있고, 한국어 특화 모델도 선택할 수 있습니다.",
+    "example": "from langchain_huggingface import HuggingFaceEmbeddings\n\nembeddings = HuggingFaceEmbeddings(\n    model_name='sentence-transformers/all-MiniLM-L6-v2'\n)\n\n# 임베딩 벡터 생성\nvector = embeddings.embed_query('파이썬이 뭐야?')\nprint(len(vector))  # 384차원\n\n# Chroma와 함께\ndb = Chroma.from_documents(chunks, embeddings, persist_directory='./db')",
+    "common_mistake": "첫 실행 시 모델 파일을 다운로드하므로 느립니다. Streamlit 앱에서는 `@st.cache_resource`로 감싸 한 번만 로드하세요. 임베딩 모델을 중간에 바꾸면 기존 VectorStore와 호환되지 않아 전체 재인덱싱이 필요합니다.",
+    "keywords": ["HuggingFaceEmbeddings", "sentence-transformers", "all-MiniLM-L6-v2", "embed_query", "로컬 임베딩", "384차원"],
+    "source_id": "official-docs-huggingface",
+    "details": [
+      "**모델 선택**: `all-MiniLM-L6-v2`는 빠르고 경량(384차원), `all-mpnet-base-v2`는 품질이 더 높지만 느립니다. 한국어가 많다면 `jhgan/ko-sroberta-multitask` 같은 한국어 특화 모델을 씁니다.",
+      "**OpenAI vs 로컬**: OpenAI `text-embedding-3-small`은 품질이 높지만 API 비용이 발생합니다. 로컬 임베딩은 무료이나 GPU 없이는 대용량에서 느립니다.",
+      "**차원 고정 주의**: 한 번 임베딩한 모델을 바꾸면 기존 인덱스와 호환되지 않습니다. 새 모델로 전체 인덱스를 재생성해야 합니다."
+    ]
+  },
+  {
+    "id": "docs-ragas",
+    "certification": "Docs Study",
+    "title": "Ragas — RAG 품질 자동 평가",
+    "level": "중급",
+    "related_practices": ["docs-ragas-1", "docs-ragas-2"],
+    "summary": "Ragas는 RAG 시스템의 품질을 자동으로 수치화합니다. Faithfulness(환각 없는가), Answer Relevancy(질문과 맞는 답인가), Context Precision(관련 문서를 잘 찾았는가)을 LLM-as-judge로 계산합니다.",
+    "example": "from ragas import evaluate\nfrom ragas.metrics import faithfulness, answer_relevancy, context_precision\nfrom datasets import Dataset\n\ndata = {\n    'question': ['LangChain이 뭐야?'],\n    'answer': ['LangChain은 LLM 앱 프레임워크입니다.'],\n    'contexts': [['LangChain은 LLM 애플리케이션 개발을 위한 프레임워크입니다.']],\n    'ground_truth': ['LangChain은 LLM 앱 개발 프레임워크입니다.']\n}\n\ndataset = Dataset.from_dict(data)\nresult = evaluate(dataset, metrics=[faithfulness, answer_relevancy, context_precision])\nprint(result)",
+    "common_mistake": "Ragas는 평가에 LLM을 사용합니다. 기본으로 OpenAI GPT를 씁니다. `evaluate(..., llm=your_llm, embeddings=your_embeddings)`로 다른 모델을 지정할 수 있습니다.",
+    "keywords": ["ragas", "evaluate", "faithfulness", "answer_relevancy", "context_precision", "LLM-as-judge", "Dataset"],
+    "source_id": "official-docs-ragas",
+    "details": [
+      "**3가지 핵심 메트릭**: Faithfulness(답변이 검색된 컨텍스트에 근거하는가 — 환각 탐지), Answer Relevancy(답변이 질문과 관련 있는가), Context Precision(관련 문서가 상위 k개 안에 있는가).",
+      "**MLflow 연동**: `result.to_pandas()`로 DataFrame 변환 후 `mlflow.log_metrics()`로 기록하면 chunk_size, k 파라미터별 품질 변화를 추적할 수 있습니다.",
+      "**ground_truth 없이도 가능**: `ground_truth`가 없으면 faithfulness, answer_relevancy만 계산합니다. Answer Correctness 메트릭은 ground_truth가 필요합니다."
+    ]
+  },
+  {
+    "id": "docs-summarization",
+    "certification": "Docs Study",
+    "title": "LangChain 요약 체인 — map_reduce & stuff",
+    "level": "중급",
+    "related_practices": ["docs-news-1", "docs-news-2"],
+    "summary": "LangChain의 `load_summarize_chain`은 긴 문서를 LLM 컨텍스트 한계 내에서 요약하는 체인을 만듭니다. 문서가 짧으면 `stuff`, 길면 `map_reduce` 방식을 씁니다.",
+    "example": "from langchain.chains.summarize import load_summarize_chain\nfrom langchain_core.documents import Document\n\n# map_reduce: 각 청크 요약 → 최종 요약\nchain = load_summarize_chain(llm, chain_type='map_reduce')\n\ndocs = [Document(page_content=article) for article in articles]\nresult = chain.invoke(docs)\nprint(result['output_text'])",
+    "common_mistake": "`stuff` 방식은 모든 문서를 하나의 프롬프트에 넣습니다. 문서가 LLM 컨텍스트 창보다 크면 오류가 납니다. 여러 문서나 긴 문서는 항상 `map_reduce`를 먼저 고려하세요.",
+    "keywords": ["load_summarize_chain", "map_reduce", "stuff", "refine", "output_text", "요약"],
+    "source_id": "official-docs-langchain",
+    "details": [
+      "**chain_type 비교**: `stuff`(전체 한 번), `map_reduce`(청크별 요약 후 합침), `refine`(이전 요약을 다음 청크에 반영). 품질은 refine > map_reduce > stuff이지만 속도는 반대입니다.",
+      "**map_prompt / combine_prompt**: `load_summarize_chain`에 `map_prompt`와 `combine_prompt`를 지정해 요약 지시문을 커스터마이징할 수 있습니다.",
+      "**비동기**: `chain.ainvoke(docs)`로 비동기 요청이 가능합니다. 여러 뉴스 기사를 병렬 요약할 때 `asyncio.gather`와 함께 쓰면 속도가 크게 개선됩니다."
+    ]
+  },
+  {
+    "id": "docs-sql-chain",
+    "certification": "Docs Study",
+    "title": "LangChain Text-to-SQL — 자연어로 DB 조회",
+    "level": "중급",
+    "related_practices": ["docs-sql-1", "docs-sql-2"],
+    "summary": "LangChain의 `create_sql_query_chain`은 자연어 질문을 SQL 쿼리로 변환합니다. `SQLDatabase`로 DB 스키마를 자동으로 읽어 LLM에게 컨텍스트를 제공합니다.",
+    "example": "from langchain_community.utilities import SQLDatabase\nfrom langchain.chains import create_sql_query_chain\n\ndb = SQLDatabase.from_uri('sqlite:///./mydb.db')\nchain = create_sql_query_chain(llm, db)\n\nsql = chain.invoke({'question': '가장 많이 팔린 상품 5개는?'})\nprint(sql)  # SELECT product, SUM(quantity) ...\n\nresult = db.run(sql)\nprint(result)",
+    "common_mistake": "LLM이 생성한 SQL을 바로 `db.run()`에 넘기면 잘못된 쿼리가 실행됩니다. Guardrails의 `ValidSQL`이나 별도 파싱으로 검증한 뒤 실행하세요.",
+    "keywords": ["SQLDatabase", "create_sql_query_chain", "from_uri", "db.run", "Text-to-SQL", "sqlite"],
+    "source_id": "official-docs-langchain",
+    "details": [
+      "**스키마 자동 주입**: `SQLDatabase`는 연결된 DB의 테이블명과 컬럼 정보를 자동으로 프롬프트에 주입합니다. LLM이 존재하는 테이블/컬럼만 참조하도록 유도합니다.",
+      "**QuerySQLDatabaseTool**: SQL 생성과 실행을 하나의 툴로 묶은 고수준 인터페이스. Agent에 등록하면 LLM이 필요할 때 DB를 직접 조회할 수 있습니다.",
+      "**보안 주의**: `db.run()`은 실제 DB를 수정할 수 있습니다. 읽기 전용 사용자 계정으로 연결하거나 SELECT만 허용하는 wrapper를 두는 것이 안전합니다."
+    ]
+  },
+  {
+    "id": "docs-langgraph",
+    "certification": "Docs Study",
+    "title": "LangGraph — 상태 기반 에이전트 워크플로",
+    "level": "고급",
+    "related_practices": ["docs-graph-1", "docs-graph-2"],
+    "summary": "LangGraph는 LLM 에이전트를 그래프(노드 + 엣지)로 정의합니다. 단순 체인의 A→B→C와 달리 조건 분기, 루프, 병렬 실행이 가능해 실제 에이전트 행동을 표현합니다.",
+    "example": "from langgraph.graph import StateGraph, END\nfrom typing import TypedDict\n\nclass State(TypedDict):\n    question: str\n    answer: str\n\ndef retrieve(state: State) -> State:\n    return {\"answer\": str(retriever.invoke(state[\"question\"]))}\n\ndef generate(state: State) -> State:\n    return {\"answer\": chain.invoke(state)}\n\ngraph = StateGraph(State)\ngraph.add_node(\"retrieve\", retrieve)\ngraph.add_node(\"generate\", generate)\ngraph.set_entry_point(\"retrieve\")\ngraph.add_edge(\"retrieve\", \"generate\")\ngraph.add_edge(\"generate\", END)\n\napp = graph.compile()\nresult = app.invoke({\"question\": \"LangChain이 뭐야?\"})",
+    "common_mistake": "LangGraph는 LangChain 체인이 아닙니다. `graph.compile()` 후 `app.invoke()`를 씁니다. State TypedDict를 정확히 정의하지 않으면 노드에서 키 오류가 발생합니다.",
+    "keywords": ["LangGraph", "StateGraph", "State", "node", "edge", "compile", "conditional_edges", "END"],
+    "source_id": "official-docs-langgraph",
+    "details": [
+      "**노드 vs 체인**: 체인은 A→B→C 선형. 그래프는 A에서 조건에 따라 B 또는 C로 분기, D에서 A로 루프 등 복잡한 흐름을 표현할 수 있습니다.",
+      "**conditional_edges**: `graph.add_conditional_edges('judge', router_fn, {'retry': 'retrieve', 'done': END})`처럼 노드 반환값에 따라 다음 노드를 동적으로 결정합니다. ReAct 에이전트의 핵심입니다.",
+      "**checkpointer**: `MemorySaver`를 `graph.compile(checkpointer=...)`에 넘기면 실행 상태를 저장해 중단 후 재개, 멀티턴 대화 유지가 가능합니다."
+    ]
+  },
+  {
+    "id": "docs-airflow",
+    "certification": "Docs Study",
+    "title": "Apache Airflow — 워크플로 오케스트레이션",
+    "level": "고급",
+    "related_practices": ["docs-lab-23"],
+    "summary": "Airflow는 DAG(Directed Acyclic Graph)로 데이터 파이프라인을 정의하고 스케줄링·모니터링합니다. ML 파이프라인(데이터 수집 → 전처리 → 학습 → 배포)이나 문서 재인덱싱 자동화에 씁니다.",
+    "example": "from airflow import DAG\nfrom airflow.operators.python import PythonOperator\nfrom datetime import datetime\n\ndef reindex():\n    # 문서 로드 → 임베딩 → VectorStore 업데이트\n    pass\n\nwith DAG('daily_reindex', schedule='@daily', start_date=datetime(2024,1,1)) as dag:\n    task = PythonOperator(task_id='reindex', python_callable=reindex)",
+    "common_mistake": "DAG 파일은 Airflow 스케줄러가 주기적으로 파싱합니다. 파일 최상위에 무거운 연산(DB 연결, 모델 로드)을 두면 파싱마다 실행돼 스케줄러가 느려집니다. 반드시 task 함수 안에 넣으세요.",
+    "keywords": ["airflow", "DAG", "task", "operator", "schedule", "XCom", "pipeline", "orchestration"],
+    "source_id": "official-docs-airflow",
+    "details": [
+      "**Operator 종류**: `PythonOperator`(파이썬 함수), `BashOperator`(셸 명령), `DockerOperator`(컨테이너 실행) 등. ML 파이프라인엔 주로 PythonOperator를 씁니다.",
+      "**XCom**: task 간 데이터 전달 메커니즘. `ti.xcom_push(key, value)` / `ti.xcom_pull(task_ids, key)`로 소량 데이터를 공유합니다. 대용량은 S3/GCS 경로를 전달하는 방식을 씁니다.",
+      "**의존성**: `task_a >> task_b >> task_c` 또는 `task_a.set_downstream(task_b)` 로 실행 순서를 정의합니다. 병렬 실행은 `[task_b, task_c] >> task_d` 형태로 표현합니다."
+    ]
+  },
+  {
+    "id": "docs-mlflow",
+    "certification": "Docs Study",
+    "title": "MLflow — 실험 추적 & 모델 관리",
+    "level": "고급",
+    "related_practices": ["docs-lab-15"],
+    "summary": "MLflow는 ML 실험의 파라미터, 메트릭, 아티팩트를 추적하고 모델을 버전 관리합니다. RAG에서 chunk_size, k, 임베딩 모델 등 파라미터 실험 결과를 체계적으로 비교할 때 씁니다.",
+    "example": "import mlflow\n\nwith mlflow.start_run(run_name='rag-exp-1'):\n    mlflow.log_param('chunk_size', 500)\n    mlflow.log_param('k', 4)\n    mlflow.log_metric('answer_relevance', 0.87)\n    mlflow.log_metric('faithfulness', 0.92)\n    mlflow.log_artifact('eval_results.json')",
+    "common_mistake": "run을 `with mlflow.start_run()` 블록으로 감싸지 않으면 실수로 이전 run에 로깅되는 경우가 있습니다. 항상 context manager를 사용하세요.",
+    "keywords": ["mlflow", "experiment", "run", "log_param", "log_metric", "artifact", "model registry"],
+    "source_id": "official-docs-mlflow",
+    "details": [
+      "**UI**: `mlflow ui` 명령으로 localhost:5000에서 실험 비교 대시보드를 실행합니다. 파라미터별 메트릭 추이를 시각적으로 비교할 수 있습니다.",
+      "**Model Registry**: `mlflow.log_model()`로 모델을 저장하고 `Staging`→`Production` 단계를 관리합니다. 배포 시 `mlflow.pyfunc.load_model('models:/name/Production')`으로 로드합니다.",
+      "**LangChain 통합**: `mlflow.langchain.autolog()`를 활성화하면 체인 실행마다 파라미터와 메트릭이 자동 기록됩니다."
+    ]
+  },
+  {
+    "id": "docs-mcp",
+    "certification": "Docs Study",
+    "title": "MCP — Model Context Protocol",
+    "level": "고급",
+    "related_practices": ["docs-lab-24"],
+    "summary": "MCP(Model Context Protocol)는 LLM 애플리케이션이 외부 도구·데이터소스와 표준화된 방식으로 연결하는 Anthropic 오픈 프로토콜입니다. Claude Desktop이나 Claude Code에 로컬 MCP 서버를 연결하면 파일 시스템, DB, 외부 API를 LLM이 직접 사용할 수 있습니다.",
+    "example": "# mcp_server.py (FastMCP 사용)\nfrom mcp.server.fastmcp import FastMCP\n\nmcp = FastMCP('my-server')\n\n@mcp.tool()\ndef search_docs(query: str) -> str:\n    '''벡터 DB에서 관련 문서를 검색합니다.'''\n    results = retriever.invoke(query)\n    return '\\n'.join(r.page_content for r in results)\n\nmcp.run(transport='stdio')",
+    "common_mistake": "MCP 서버는 stdio 또는 SSE transport 중 하나를 선택합니다. Claude Desktop은 stdio(로컬 프로세스), Claude Code는 SSE(HTTP 서버) 방식을 주로 씁니다. transport 불일치 시 연결이 안 됩니다.",
+    "keywords": ["MCP", "Model Context Protocol", "tool", "resource", "FastMCP", "stdio", "Claude", "agent"],
+    "source_id": "official-docs-mcp",
+    "details": [
+      "**3가지 기본 요소**: `tool`(LLM이 호출하는 함수), `resource`(LLM이 읽는 데이터), `prompt`(재사용 가능한 프롬프트 템플릿). 대부분의 서버는 `tool`만 구현합니다.",
+      "**Claude Desktop 연결**: `~/Library/Application Support/Claude/claude_desktop_config.json`에 서버 경로와 명령어를 등록하면 대화 중 자동으로 도구가 보입니다.",
+      "**FastMCP**: Anthropic 공식 Python SDK의 고수준 래퍼. `@mcp.tool()` 데코레이터로 함수를 도구로 등록하면 스키마 생성, 입출력 검증이 자동으로 처리됩니다."
+    ]
+  },
+  {
+    "id": "docs-litellm",
+    "certification": "Docs Study",
+    "title": "LiteLLM — 여러 LLM을 하나의 인터페이스로",
+    "level": "고급",
+    "related_practices": ["docs-litellm-1"],
+    "summary": "LiteLLM은 OpenAI, Anthropic, Ollama, Gemini 등 100개 이상의 LLM 프로바이더를 동일한 API 형식으로 호출합니다. 모델을 바꿀 때 코드 수정 없이 모델명만 변경하면 됩니다.",
+    "example": "from litellm import completion\n\n# Ollama 로컬\nresponse = completion(\n    model='ollama/llama3.2',\n    messages=[{'role': 'user', 'content': '안녕'}]\n)\n\n# OpenAI — 코드 동일, 모델명만 변경\nresponse = completion(\n    model='gpt-4o-mini',\n    messages=[{'role': 'user', 'content': '안녕'}]\n)\n\nprint(response.choices[0].message.content)",
+    "common_mistake": "모델명 형식은 `'프로바이더/모델명'`입니다. Ollama는 `'ollama/llama3.2'`, Anthropic은 `'anthropic/claude-3-5-sonnet-20241022'`. OpenAI만 예외로 접두사 없이 `'gpt-4o-mini'`처럼 씁니다.",
+    "keywords": ["LiteLLM", "completion", "model", "provider", "벤더 독립", "OpenAI 호환", "ChatLiteLLM"],
+    "source_id": "official-docs-litellm",
+    "details": [
+      "**비용 추적**: `litellm.success_callback`으로 각 호출의 토큰 수와 예상 비용을 자동 기록할 수 있습니다. 여러 모델을 실험할 때 비용 비교에 유용합니다.",
+      "**LangChain 통합**: `from langchain_community.chat_models import ChatLiteLLM`으로 LangChain 체인에서 LiteLLM을 씁니다. LCEL 파이프라인에 바로 연결됩니다.",
+      "**Fallback**: `completion(..., fallbacks=['gpt-4o-mini', 'ollama/llama3.2'])`처럼 주 모델 실패 시 자동으로 백업 모델로 전환하는 기능을 지원합니다."
+    ]
+  },
+  {
+    "id": "docs-chainlit",
+    "certification": "Docs Study",
+    "title": "Chainlit — 챗봇 UI 특화 프레임워크",
+    "level": "���급",
+    "related_practices": ["docs-chainlit-1"],
+    "summary": "Chainlit은 LLM 챗봇 UI에 특화된 프레임워크입니다. Streamlit과 달리 웹소켓 기반으로 동작해 스트리밍 응답, 파일 업로드, 멀티스텝 진행 표시가 자연스럽습니다.",
+    "example": "import chainlit as cl\n\n@cl.on_message\nasync def main(message: cl.Message):\n    # 스트리밍 응답\n    msg = cl.Message(content='')\n    async for chunk in chain.astream({'question': message.content}):\n        await msg.stream_token(chunk)\n    await msg.send()\n\n# 실행: chainlit run app.py",
+    "common_mistake": "Chainlit은 `async` 기반입니다. LangChain의 `chain.invoke()`(동기)를 쓰면 이벤트 루프가 블로킹됩니다. 반드시 `chain.ainvoke()` 또는 `chain.astream()`을 사용하세요.",
+    "keywords": ["chainlit", "on_message", "Message", "stream_token", "async", "astream", "on_chat_start"],
+    "source_id": "official-docs-chainlit",
+    "details": [
+      "**데코레이터 기반**: `@cl.on_chat_start`(세션 시작 시 체인 초기화), `@cl.on_message`(메시지 수신), `@cl.on_stop`(스트리밍 중단)으로 이벤트를 처리합니다.",
+      "**Step UI**: `async with cl.Step(name='검색 중...'):` 블록으로 에이전트의 각 단계(검색, 추론 등)를 UI에 실시간으로 펼쳐 보여줍니다. LangGraph 에이전트와 함께 쓰면 강력합니다.",
+      "**파일 업로드**: `@cl.on_message`에서 `message.elements`로 첨부 파일을 받을 수 있습니다. PDF 업로드 → 즉시 RAG 인덱싱 흐름을 몇 줄로 구현합니다."
+    ]
+  },
+  {
+    "id": "docs-redis",
+    "certification": "Docs Study",
+    "title": "Redis — 대화 메모리 영속화 & LLM 캐싱",
+    "level": "고급",
+    "related_practices": ["docs-redis-1"],
+    "summary": "Redis는 인메모리 데이터 저장소로 LLM 앱에서 대화 히스토리 영속화와 LLM 응답 캐싱에 씁니다. 서버를 재시작해도 대화가 유지되고, 동일 질문에 대한 LLM 호출 비용을 절감합니다.",
+    "example": "from langchain_community.chat_message_histories import RedisChatMessageHistory\nfrom langchain_core.runnables.history import RunnableWithMessageHistory\n\ndef get_session_history(session_id: str):\n    return RedisChatMessageHistory(\n        session_id=session_id,\n        url='redis://localhost:6379'\n    )\n\nchain_with_history = RunnableWithMessageHistory(\n    chain,\n    get_session_history,\n    input_messages_key='question',\n    history_messages_key='chat_history'\n)",
+    "common_mistake": "Redis 서버가 실행 중이지 않으면 연결 오류가 납니다. 로컬 개발 시 `docker run -d -p 6379:6379 redis`로 먼저 Redis를 실행하세요.",
+    "keywords": ["Redis", "RedisChatMessageHistory", "session_id", "url", "영속화", "캐싱", "TTL"],
+    "source_id": "official-docs-redis",
+    "details": [
+      "**인메모리 교체**: 기존 `ChatMessageHistory`(재시작 시 소멸)를 `RedisChatMessageHistory`로 교체하면 `get_session_history` 함수 한 줄만 바꿔도 영속성을 얻습니다.",
+      "**TTL**: `RedisChatMessageHistory(session_id, url, ttl=3600)`으로 1시간 후 자동 만료됩니다. 무한히 쌓이는 히스토리와 메모리 누수를 방지합니다.",
+      "**LLM 응답 캐싱**: `from langchain.cache import RedisCache; langchain.llm_cache = RedisCache(redis_client)`로 동일 질문에 대한 LLM 응답을 캐시해 비용과 응답 시간을 줄입니다."
+    ]
+  },
+  {
+    "id": "docs-unstructured",
+    "certification": "Docs Study",
+    "title": "Unstructured — PDF·Word·이미지 파싱",
+    "level": "고급",
+    "related_practices": ["docs-unstructured-1"],
+    "summary": "Unstructured는 PDF, Word, Excel, PowerPoint, 이미지 등 비정형 문서를 텍스트로 변환합니다. LangChain의 `UnstructuredFileLoader`와 통합되어 확장자에 상관없이 동일 코드로 RAG 파이프라인에 연결합니다.",
+    "example": "from langchain_community.document_loaders import UnstructuredFileLoader\n\n# 단일 파일 — 확장자 자동 감지\nloader = UnstructuredFileLoader('./report.pdf')\ndocs = loader.load()\n\n# 혼합 형식 디렉토리\nfrom langchain_community.document_loaders import DirectoryLoader\nloader = DirectoryLoader(\n    './docs',\n    glob='**/*',\n    loader_cls=UnstructuredFileLoader\n)\ndocs = loader.load()",
+    "common_mistake": "`pip install unstructured`는 기본 설치입니다. PDF에는 `pip install unstructured[pdf]`, 이미지 OCR에는 `pip install unstructured[local-inference]`처럼 별도 extra를 설치해야 합니다.",
+    "keywords": ["Unstructured", "UnstructuredFileLoader", "PDF", "Word", "OCR", "비정형 문서", "elements"],
+    "source_id": "official-docs-unstructured",
+    "details": [
+      "**자동 파일 감지**: 확장자에 따라 자동으로 적절한 파서를 선택합니다. `.pdf`, `.docx`, `.pptx`, `.jpg`, `.eml` 등을 동일 코드로 처리합니다.",
+      "**요소 분류**: `mode='elements'`로 로드하면 Title, NarrativeText, Table, Image 등 요소 타입이 메타데이터에 저장됩니다. 헤더를 청크 메타데이터로 활용하거나 테이블만 따로 추출할 때 씁니다.",
+      "**API vs 로컬**: Unstructured Cloud API는 고품질 OCR과 레이아웃 분석을 제공합니다. 로컬은 무료이나 이미지나 복잡한 레이아웃의 PDF 품질이 낮을 수 있습니다."
+    ]
+  },
+  {
+    "id": "docs-conversation-memory",
+    "certification": "Docs Study",
+    "title": "LangChain 대화 메모리 — 멀티턴 챗봇",
+    "level": "고급",
+    "related_practices": ["docs-lab-6", "docs-brain-1"],
+    "summary": "RunnableWithMessageHistory는 LangChain 체인에 대화 히스토리를 자동으로 주입합니다. 매 요청마다 이전 대화를 직접 관리하지 않아도 session_id만 넘기면 히스토리가 유지됩니다.",
+    "example": "from langchain_community.chat_message_histories import ChatMessageHistory\nfrom langchain_core.runnables.history import RunnableWithMessageHistory\n\nstore = {}  # session_id → ChatMessageHistory\n\ndef get_session_history(session_id: str):\n    if session_id not in store:\n        store[session_id] = ChatMessageHistory()\n    return store[session_id]\n\nchain_with_history = RunnableWithMessageHistory(\n    chain,\n    get_session_history,\n    input_messages_key=\"question\",\n    history_messages_key=\"chat_history\"\n)\n\nchain_with_history.invoke(\n    {\"question\": \"안녕\"},\n    config={\"configurable\": {\"session_id\": \"user-1\"}}\n)",
+    "common_mistake": "`session_id`를 모든 사용자에게 동일하게 넘기면 전체 사용자가 하나의 대화 히스토리를 공유합니다. 사용자별로 고유한 session_id를 생성해야 합니다.",
+    "keywords": ["RunnableWithMessageHistory", "ChatMessageHistory", "session_id", "chat_history", "멀티턴"],
+    "source_id": "official-docs-langchain",
+    "details": [
+      "**히스토리 저장소**: 인메모리(`ChatMessageHistory`)는 서버 재시작 시 사라집니다. 프로덕션에서는 `RedisChatMessageHistory`, `SQLChatMessageHistory` 등 영속 저장소를 씁니다.",
+      "**히스토리 길이 제한**: 대화가 길어지면 토큰이 초과됩니다. `trim_messages()` 또는 최근 N개 메시지만 유지하는 로직을 추가해야 합니다.",
+      "**프롬프트 연동**: `ChatPromptTemplate`에 `MessagesPlaceholder(variable_name=\"chat_history\")`를 추가해야 히스토리가 프롬프트에 주입됩니다. history_messages_key와 placeholder 이름이 일치해야 합니다."
+    ]
+  }
+]

cert_study_app/content/tool_docs/practices.json

@@ -0,0 +1,530 @@
+[
+  {
+    "id": "docs-lab-1",
+    "title": "[단계 1] Ollama — 로컬 LLM 설치",
+    "task_description": "**상황**\nOpenAI API로 개발하던 중 청구서가 나왔습니다. 테스트만 수십 번 했는데 요금이 청구됐습니다. 로컬에서 무료로 돌릴 수 없을까요?\n\n**문제**\nAPI 키 없이 LLM을 쓰려면 모델을 직접 로컬에 내려받아야 합니다.\n\n**해결**\nOllama로 `llama3.2` 모델을 로컬에 다운로드하세요. (대화 없이 다운로드만)\n\n> `run`이 아닌, 다운로드만 하는 명령어입니다.",
+    "expected_command": "ollama pull llama3.2",
+    "grading_conditions": ["ollama pull", "llama3.2"],
+    "hint": "`ollama pull <모델명>` 형식입니다.",
+    "explanation": "`ollama pull`은 모델 파일을 로컬에 내려받습니다. 이후 `ollama list`로 목록 확인, `ollama run llama3.2`로 대화를 시작할 수 있습니다. API 키도, 인터넷 연결도 없이 실행됩니다.",
+    "difficulty": "easy",
+    "takeaway": "API 키 없이 ollama pull 한 번으로 로컬 LLM 실행 환경이 완성됩니다."
+  },
+  {
+    "id": "docs-lab-2",
+    "title": "[단계 2] Ollama REST API — Python에서 호출하기",
+    "task_description": "**상황**\n`ollama run llama3.2`로 터미널 대화는 되는데, 내 Python 코드에서 LLM을 호출하려니 방법을 모르겠습니다.\n\n**문제**\nCLI 대화 모드는 자동화가 불가능합니다. 코드에서 호출하려면 HTTP API가 필요합니다.\n\n**해결**\ncurl로 Ollama REST API를 직접 호출해 동작을 확인하세요.\n- 엔드포인트: `http://localhost:11434/api/generate`\n- 모델: `llama3.2`, 프롬프트: `'2+2는?'`, 스트리밍 없이",
+    "expected_command": "curl http://localhost:11434/api/generate -d '{\"model\":\"llama3.2\",\"prompt\":\"2+2는?\",\"stream\":false}'",
+    "grading_conditions": ["curl", "localhost:11434/api/generate", "stream", "false"],
+    "hint": "`-d` 플래그로 JSON 바디를 전달합니다. `\"stream\": false`를 넣어야 한 번에 응답이 옵니다.",
+    "explanation": "Ollama는 기본적으로 줄 단위 스트리밍으로 응답합니다. `\"stream\": false`를 넣으면 완성된 응답을 한 번에 받을 수 있어 Python에서 파싱하기 쉽습니다.",
+    "difficulty": "easy",
+    "takeaway": "Ollama REST API는 OpenAI 호환 형식이라 어떤 언어·프레임워크에서도 동일한 방법으로 호출합니다."
+  },
+  {
+    "id": "docs-lab-3",
+    "title": "[단계 3] Ollama 채팅 API — 대화 히스토리 구조",
+    "task_description": "**상황**\n`/api/generate`로 '이전에 내가 뭐라고 했어?'를 물어봤더니 모른다고 합니다. 매 요청이 완전히 독립적으로 처리되기 때문입니다.\n\n**문제**\n`/api/generate`는 단일 프롬프트만 받습니다. 대화 히스토리를 붙이려면 다른 엔드포인트가 필요합니다.\n\n**해결**\n`/api/chat`은 `messages` 배열로 히스토리를 전달합니다. `llama3.2`에게 `user` 메시지 `'파이썬이 뭐야?'`를 보내세요. (stream: false)",
+    "expected_command": "curl http://localhost:11434/api/chat -d '{\"model\":\"llama3.2\",\"messages\":[{\"role\":\"user\",\"content\":\"파이썬이 뭐야?\"}],\"stream\":false}'",
+    "grading_conditions": ["curl", "localhost:11434/api/chat", "messages", "role", "user"],
+    "hint": "`/api/chat`은 `messages` 배열로 대화 히스토리를 전달합니다.",
+    "explanation": "`messages` 배열에 `{\"role\": \"user\", \"content\": \"...\"}` 형식으로 이전 대화를 쌓으면 멀티턴 대화가 됩니다. LangChain의 채팅 모델도 내부적으로 이 구조를 사용합니다.",
+    "difficulty": "medium",
+    "takeaway": "messages 배열에 {role, content} 쌍을 쌓는 구조가 모든 LLM 멀티턴 대화의 기본 형식입니다."
+  },
+  {
+    "id": "docs-lab-4",
+    "title": "[단계 4] .env — API 키를 코드에서 분리하기",
+    "task_description": "**상황**\n```python\napi_key = 'sk-abc123...'\n```\n이렇게 코드에 직접 썼다가 GitHub에 push했더니 API 키가 공개됐습니다. GitHub이 자동으로 탐지해서 키를 즉시 무효화했습니다.\n\n**문제**\nAPI 키를 코드에 하드코딩하면 버전 관리 시스템에 노출됩니다. `.gitignore`에 추가한 별도 파일에 보관해야 합니다.\n\n**해결**\n`.env` 파일을 로드하고 `OPENAI_API_KEY`를 읽는 코드 2줄을 입력하세요.\n\n```python\nfrom dotenv import load_dotenv\nimport os\n# 여기에 입력하세요\n```",
+    "expected_command": "load_dotenv()\napi_key = os.getenv('OPENAI_API_KEY')",
+    "grading_conditions": ["load_dotenv()", "os.getenv", "OPENAI_API_KEY"],
+    "hint": "`load_dotenv()`를 반드시 먼저 호출해야 `os.getenv()`가 값을 읽을 수 있습니다.",
+    "explanation": "`load_dotenv()` 호출 전에 `os.getenv()`를 쓰면 항상 `None`이 반환됩니다. `.env` 파일은 `.gitignore`에 추가하고, `.env.example`에는 키 이름만 적어 팀에 공유합니다.",
+    "difficulty": "easy",
+    "takeaway": "load_dotenv() → os.getenv() 순서가 모든 Python 프로젝트의 환경변수 관리 표준입니다."
+  },
+  {
+    "id": "docs-lab-5",
+    "title": "[단계 5] ChatPromptTemplate — 프롬프트 구조화",
+    "task_description": "**상황**\n```python\nresponse = llm.invoke(f'문서: {context}\\n질문: {question}')\n```\nf-string으로 프롬프트를 만들었더니 변수 순서를 실수하기 쉽고, 시스템 역할(어시스턴트 페르소나)을 지정할 수 없습니다.\n\n**문제**\n단순 문자열 방식은 역할 구분이 없고 LangChain 파이프라인에 연결되지 않습니다.\n\n**해결**\n아래 조건으로 `ChatPromptTemplate`을 작성하세요.\n- 시스템: `\"당신은 문서 기반 AI 어시스턴트입니다. 컨텍스트: {context}\"`\n- 사용자: `\"{question}\"`\n\n결과를 `prompt` 변수에 저장하세요.",
+    "expected_command": "prompt = ChatPromptTemplate.from_messages([\n    (\"system\", \"당신은 문서 기반 AI 어시스턴트입니다. 컨텍스트: {context}\"),\n    (\"human\", \"{question}\")\n])",
+    "grading_conditions": ["ChatPromptTemplate.from_messages", "system", "context", "human", "question"],
+    "hint": "`ChatPromptTemplate.from_messages([(\"system\", \"...\"), (\"human\", \"...\")])` 형식입니다.",
+    "explanation": "ChatPromptTemplate은 역할별 메시지를 구조화하고 변수 자리(`{context}`, `{question}`)를 안전하게 관리합니다. `chain.invoke({\"context\": ..., \"question\": ...})`로 실행 시 자동으로 채워집니다.",
+    "difficulty": "easy",
+    "takeaway": "ChatPromptTemplate은 역할(system/human)과 변수({})를 분리해 프롬프트를 재사용 가능한 컴포넌트로 만듭니다."
+  },
+  {
+    "id": "docs-lab-6",
+    "title": "[단계 6] LCEL — 체인을 한 줄로",
+    "task_description": "**상황**\n```python\nformatted = prompt.format(context=ctx, question=q)\nllm_result = llm.invoke(formatted)\nfinal = output_parser.parse(llm_result)\n```\n3단계를 매번 직접 연결하는 코드가 반복됩니다. 체인이 길어질수록 더 복잡해집니다.\n\n**문제**\n각 단계를 수동으로 연결하면 코드가 길고 단계 추가/변경이 번거롭습니다.\n\n**해결**\n`prompt`, `llm`, `output_parser`를 LCEL `|` 연산자로 연결해 `chain` 변수에 저장하세요.",
+    "expected_command": "chain = prompt | llm | output_parser",
+    "grading_conditions": ["chain", "prompt", "|", "llm", "|", "output_parser"],
+    "hint": "유닉스 파이프처럼 `|`로 연결합니다.",
+    "explanation": "`chain = prompt | llm | output_parser` 한 줄이 위의 3줄을 대체합니다. `chain.invoke({\"context\": ..., \"question\": ...})`로 실행하면 순서대로 처리됩니다. 단계 추가도 `| 새단계`를 붙이면 됩니다.",
+    "difficulty": "easy",
+    "takeaway": "| 파이프 연산자로 Runnable을 연결하는 LCEL이 LangChain 모든 체인의 기본 구조입니다."
+  },
+  {
+    "id": "docs-lab-7",
+    "title": "[단계 7] TextSplitter — 토큰 초과 해결",
+    "task_description": "**상황**\n100페이지 PDF 전체를 LLM 프롬프트에 넣었더니:\n```\nError: This model's maximum context length is 128000 tokens. \nYour message resulted in 210000 tokens.\n```\n문서가 길수록 LLM에 통째로 넣는 건 불가능합니다.\n\n**문제**\nLLM은 한 번에 처리할 수 있는 토큰 수에 한계가 있습니다. 문서를 잘라야 합니다.\n\n**해결**\n`RecursiveCharacterTextSplitter`로 청크 크기 500, 오버랩 50으로 `docs`를 분할해 `chunks`에 저장하세요.",
+    "expected_command": "splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)\nchunks = splitter.split_documents(docs)",
+    "grading_conditions": ["RecursiveCharacterTextSplitter", "chunk_size=500", "chunk_overlap=50", "split_documents"],
+    "hint": "생성 후 `.split_documents(docs)`를 호출합니다.",
+    "explanation": "chunk_size=500은 청크당 최대 500자, chunk_overlap=50은 인접 청크가 50자를 공유합니다. 오버랩이 없으면 청크 경계에서 문장이 잘려 검색 품질이 떨어집니다.",
+    "difficulty": "medium",
+    "takeaway": "chunk_overlap이 없으면 청크 경계에서 문맥이 잘려 검색 품질이 떨어집니다. 일반적으로 chunk_size의 10% 정도를 씁니다."
+  },
+  {
+    "id": "docs-lab-8",
+    "title": "[단계 8] FAISS VectorStore — 의미 기반 검색 인덱스 생성",
+    "task_description": "**상황**\n문서를 청크로 잘랐는데, 질문이 들어올 때마다 500개 청크를 전부 LLM에 넣으면 처음과 똑같이 토큰이 초과됩니다.\n\n**문제**\n\"관련 있는 청크만\" 찾아야 합니다. 키워드 검색은 동의어나 의미적 유사성을 못 잡습니다.\n\n**해결**\n`chunks`와 `embeddings` 모델로 FAISS VectorStore를 만들고, `./faiss_index`에 저장하세요. (다음 실행 시 재사용하기 위해)",
+    "expected_command": "db = FAISS.from_documents(chunks, embeddings)\ndb.save_local(\"./faiss_index\")",
+    "grading_conditions": ["FAISS.from_documents", "chunks", "embeddings", "save_local"],
+    "hint": "`FAISS.from_documents(문서, 임베딩모델)`로 생성, `.save_local(경로)`로 저장합니다.",
+    "explanation": "FAISS는 각 청크를 벡터로 변환해 인덱스를 만듭니다. 질문도 벡터로 변환해 가장 가까운(의미적으로 유사한) 청크를 O(1)에 가깝게 찾습니다. `save_local`로 저장하면 다음 실행 시 임베딩 재계산 없이 로드할 수 있습니다.",
+    "difficulty": "medium",
+    "takeaway": "FAISS.from_documents()가 임베딩 생성과 인덱스 구축을 한 번에 처리하고, save_local()로 재시작 시 재계산을 피합니다."
+  },
+  {
+    "id": "docs-lab-9",
+    "title": "[단계 9] RAG 전체 파이프라인 — 연결",
+    "task_description": "**상황**\n```python\ndocs = retriever.invoke(question)          # 1. 검색\ncontext = '\\n'.join(d.page_content for d in docs)  # 2. 합치기\nprompt_text = prompt.format(...)           # 3. 프롬프트\nresponse = llm.invoke(prompt_text)         # 4. LLM 호출\nfinal = parser.parse(response)             # 5. 파싱\n```\n5줄 코드를 매 질문마다 반복해야 합니다.\n\n**문제**\nretriever → prompt → llm → parser를 수동으로 연결하는 코드가 장황합니다.\n\n**해결**\nLCEL로 RAG 체인을 한 줄로 만드세요.\n- `retriever`, `prompt`, `llm`, `StrOutputParser` 변수는 이미 정의되어 있습니다.",
+    "expected_command": "chain = {\"context\": retriever, \"question\": RunnablePassthrough()} | prompt | llm | StrOutputParser()",
+    "grading_conditions": ["retriever", "RunnablePassthrough", "|", "prompt", "|", "llm", "StrOutputParser"],
+    "hint": "`{\"context\": retriever, \"question\": RunnablePassthrough()}`로 retriever와 질문을 동시에 prompt에 넘깁니다.",
+    "explanation": "딕셔너리로 묶으면 `RunnableParallel`처럼 동작해 retriever 검색과 질문 전달을 동시에 처리합니다. `RunnablePassthrough()`는 입력(질문)을 그대로 다음 단계로 전달합니다.",
+    "difficulty": "hard",
+    "takeaway": "{context: retriever, question: RunnablePassthrough()} 패턴이 RAG 체인에서 검색과 질문을 동시에 프롬프트에 주입하는 핵심 구조입니다."
+  },
+  {
+    "id": "docs-lab-10",
+    "title": "[단계 10] session_state — 대화가 사라지는 문제 해결",
+    "task_description": "**상황**\nStreamlit 챗봇을 만들었는데, 메시지를 보낼 때마다 이전 대화가 전부 사라집니다.\n\n**문제**\nStreamlit은 버튼 클릭 등 모든 상호작용마다 Python 스크립트를 처음부터 다시 실행합니다. `messages = []`처럼 선언하면 매번 초기화됩니다.\n\n**해결**\n`messages` 키가 없을 때만 빈 리스트로 초기화하는 패턴을 작성하세요.\n\n> 핵심: `st.session_state`에 저장된 값은 rerun해도 유지됩니다.",
+    "expected_command": "if \"messages\" not in st.session_state:\n    st.session_state.messages = []",
+    "grading_conditions": ["\"messages\" not in st.session_state", "st.session_state.messages", "[]"],
+    "hint": "`if \"키\" not in st.session_state:` 가드를 쓰면 첫 실행에만 초기화됩니다.",
+    "explanation": "`if ... not in st.session_state` 패턴이 없으면 매 rerun마다 `[]`로 리셋됩니다. 이 가드가 있으면 이미 값이 있을 때는 건너뜁니다.",
+    "difficulty": "easy",
+    "takeaway": "`if key not in st.session_state:` 가드 패턴 하나가 Streamlit 상태 보존의 전부입니다."
+  },
+  {
+    "id": "docs-lab-11",
+    "title": "[단계 11] cache_resource — 질문마다 LLM이 새로 로드되는 문제",
+    "task_description": "**상황**\n챗봇에 질문할 때마다 3~4초씩 걸립니다. 로그를 보니 LLM 객체가 매번 새로 생성되고 있습니다.\n\n```python\ndef load_llm():          # 이 함수가 매 rerun마다 실행됨\n    return OllamaLLM(model=\"llama3.2\")\n```\n\n**문제**\nStreamlit은 rerun마다 모든 함수를 다시 실행합니다. LLM 로드는 비용이 크므로 한 번만 해야 합니다.\n\n**해결**\n`load_llm()` 함수에 `st.cache_resource` 데코레이터를 붙여 앱 수명 동안 한 번만 로드되게 하세요.",
+    "expected_command": "@st.cache_resource\ndef load_llm():\n    return OllamaLLM(model=\"llama3.2\")",
+    "grading_conditions": ["@st.cache_resource", "def load_llm", "OllamaLLM"],
+    "hint": "함수 정의 바로 위에 `@st.cache_resource`를 붙입니다.",
+    "explanation": "`@st.cache_resource`는 반환 객체를 앱 전체(모든 세션)에서 공유합니다. 첫 번째 호출에만 함수를 실행하고 이후에는 캐시된 객체를 반환합니다.",
+    "difficulty": "easy",
+    "takeaway": "@st.cache_resource는 LLM·DB처럼 공유 가능한 무거운 객체에, @st.cache_data는 계산 결과(DataFrame 등)에 씁니다."
+  },
+  {
+    "id": "docs-lab-12",
+    "title": "[단계 12] Streamlit secrets — 배포 환경의 API 키 관리",
+    "task_description": "**상황**\n로컬에서 `.env`로 잘 작동하던 챗봇을 Streamlit Cloud에 배포했더니:\n```\nKeyError: 'OPENAI_API_KEY'\n```\nStreamlit Cloud는 로컬의 `.env` 파일을 읽을 수 없습니다.\n\n**문제**\n배포 환경에서는 `.env` 파일이 없습니다. 다른 방법으로 API 키를 주입해야 합니다.\n\n**해결**\nStreamlit Cloud 대시보드의 Secrets에 키를 등록한 뒤, 코드에서 읽는 한 줄을 작성하세요.",
+    "expected_command": "api_key = st.secrets[\"OPENAI_API_KEY\"]",
+    "grading_conditions": ["st.secrets", "OPENAI_API_KEY"],
+    "hint": "`st.secrets[\"키이름\"]`으로 접근합니다.",
+    "explanation": "`st.secrets`는 로컬에서는 `.streamlit/secrets.toml`, 배포 시에는 대시보드 Secrets에서 값을 읽습니다. 코드를 바꾸지 않아도 두 환경에서 동일하게 작동합니다.",
+    "difficulty": "easy",
+    "takeaway": "st.secrets는 로컬(.streamlit/secrets.toml)과 배포(Streamlit Cloud) 환경을 코드 변경 없이 동일하게 처리합니다."
+  },
+  {
+    "id": "docs-lab-13",
+    "title": "[단계 13] 대화 메모리 — 이전 대화를 기억하게",
+    "task_description": "**상황**\n```\n사용자: 파이썬이 뭐야?\n챗봇: 파이썬은 프로그래밍 언어입니다...\n사용자: 그거 어디서 배울 수 있어?\n챗봇: 무엇을 배우고 싶으신가요? (??)\n```\n\"그거\"가 무엇인지 챗봇이 모릅니다. 매 질문이 독립적으로 처리되기 때문입니다.\n\n**문제**\nRAG 체인은 이전 대화 내용을 받지 않습니다. 멀티턴 대화를 위해 히스토리를 주입해야 합니다.\n\n**해결**\n기존 `chain`을 `RunnableWithMessageHistory`로 감싸세요.\n- `input_messages_key`: `\"question\"`\n- `history_messages_key`: `\"chat_history\"`\n- 결과를 `chain_with_history`에 저장",
+    "expected_command": "chain_with_history = RunnableWithMessageHistory(\n    chain,\n    get_session_history,\n    input_messages_key=\"question\",\n    history_messages_key=\"chat_history\"\n)",
+    "grading_conditions": ["RunnableWithMessageHistory", "chain", "get_session_history", "input_messages_key", "history_messages_key"],
+    "hint": "`RunnableWithMessageHistory(체인, 히스토리함수, input_messages_key=..., history_messages_key=...)`",
+    "explanation": "`RunnableWithMessageHistory`는 매 invoke마다 session_id에 해당하는 히스토리를 자동으로 불러와 프롬프트에 주입합니다. invoke 시 `config={\"configurable\": {\"session_id\": \"user-1\"}}`을 넘겨야 합니다.",
+    "difficulty": "medium",
+    "takeaway": "RunnableWithMessageHistory로 기존 체인을 감싸기만 하면 멀티턴 대화가 됩니다. session_id 관리가 전부입니다."
+  },
+  {
+    "id": "docs-lab-14",
+    "title": "[단계 14] HF Spaces — 다른 사람도 쓸 수 있게 배포",
+    "task_description": "**상황**\n완성된 챗봇을 팀원에게 보여주려니 \"로컬에서만 돌아가고 밖에선 접근이 안 됩니다.\"\n\n**문제**\n서버를 직접 구매하거나 AWS/GCP를 설정하지 않고도 외부에 공개하고 싶습니다.\n\n**해결**\nHugging Face Spaces로 무료 배포합니다. `README.md` 상단에 SDK를 선언하세요.\n- SDK: `streamlit`, 앱 파일: `app.py`, Python: `3.11`",
+    "expected_command": "---\nsdk: streamlit\napp_file: app.py\npython_version: \"3.11\"\n---",
+    "grading_conditions": ["sdk: streamlit", "app_file: app.py"],
+    "hint": "README.md 맨 위 `---` YAML 블록 안에 선언합니다.",
+    "explanation": "HF Spaces는 README 메타데이터의 `sdk` 필드로 런타임을 결정합니다. `sdk: streamlit`이면 자동으로 Streamlit 서버를 실행합니다. 무료 플랜으로도 외부 URL이 즉시 생성됩니다.",
+    "difficulty": "easy",
+    "takeaway": "README YAML 메타데이터 3줄(sdk, app_file, python_version)만으로 HF Spaces 배포가 완료됩니다."
+  },
+  {
+    "id": "docs-lab-15",
+    "title": "[단계 15] HF Docker Space — SDK 제약 없이 배포",
+    "task_description": "**상황**\nHF Spaces Streamlit SDK로 배포했는데, FastAPI 서버를 함께 띄우고 싶어 포트를 커스텀하려니 설정이 막혀있습니다.\n\n**문제**\nStreamlit/Gradio SDK는 런타임 환경이 고정됩니다. 직접 서버를 제어하려면 Dockerfile이 필요합니다.\n\n**해결**\nDocker Space에서 HF가 인식하는 포트로 앱을 노출하는 Dockerfile 지시어를 작성하세요.\n\n> HF Docker Space 기본 포트: 7860",
+    "expected_command": "EXPOSE 7860\nENV PORT=7860",
+    "grading_conditions": ["EXPOSE 7860"],
+    "hint": "Streamlit 기본 포트는 8501이지만 HF는 7860을 기대합니다.",
+    "explanation": "Docker Space에서는 `EXPOSE 7860`으로 포트를 선언하고, `streamlit run app.py --server.port 7860`으로 Streamlit도 7860에 바인딩해야 합니다.",
+    "difficulty": "medium",
+    "takeaway": "HF Docker Space는 항상 포트 7860을 기대합니다. EXPOSE 7860과 앱의 포트 설정을 일치시켜야 합니다."
+  },
+  {
+    "id": "docs-lab-16",
+    "title": "[단계 16] FastAPI — 챗봇 로직을 API로 분리",
+    "task_description": "**상황**\n프론트엔드 팀에서 \"챗봇 API 엔드포인트만 주세요. React에서 붙이겠습니다.\"라고 합니다. 지금은 Streamlit에 로직이 묶여 있어 분리가 안 됩니다.\n\n**문제**\nStreamlit 앱은 UI와 로직이 결합되어 있어 다른 프론트엔드에서 재사용하기 어렵습니다.\n\n**해결**\n아래 `???`를 채워 POST `/ask` 엔드포인트를 완성하세요.\n\n```python\nclass Query(BaseModel):\n    question: str\n\n@app.post('/ask')\nasync def ask(q: Query):\n    answer = ???\n    return {\"answer\": answer}\n```",
+    "expected_command": "answer = chain.invoke(q.question)",
+    "grading_conditions": ["chain.invoke", "q.question"],
+    "hint": "Pydantic 모델 `q`의 `.question` 속성으로 질문에 접근합니다.",
+    "explanation": "FastAPI는 Pydantic 모델 타입을 파라미터로 지정하면 자동으로 JSON 바디를 파싱합니다. `q.question`으로 질문 문자열을 꺼내 chain에 전달합니다.",
+    "difficulty": "easy",
+    "takeaway": "FastAPI + Pydantic 조합이 LLM 서비스를 API로 노출하는 가장 빠른 방법입니다. Pydantic이 JSON 검증을 자동 처리합니다."
+  },
+  {
+    "id": "docs-lab-17",
+    "title": "[단계 17] FastAPI 개발 서버 — 코드 수정 즉시 반영",
+    "task_description": "**상황**\n```python\nuvicorn main:app\n```\n엔드포인트 코드를 수정할 때마다 서버를 `Ctrl+C`로 종료하고 다시 실행해야 합니다. 개발 중에 너무 번거롭습니다.\n\n**문제**\n기본 uvicorn은 파일 변경을 감지하지 않습니다.\n\n**해결**\n`main.py`의 `app` 인스턴스를 파일 변경 시 자동 재시작되는 모드로 실행하세요.",
+    "expected_command": "uvicorn main:app --reload",
+    "grading_conditions": ["uvicorn", "main:app", "--reload"],
+    "hint": "`--reload` 플래그 하나를 추가합니다.",
+    "explanation": "`--reload`는 소스 파일 변경을 감지해 서버를 자동 재시작합니다. 개발 중에만 사용하며, 프로덕션에서는 제거하고 `gunicorn` 같은 프로덕션 서버를 씁니다.",
+    "difficulty": "easy",
+    "takeaway": "--reload는 개발용, 프로덕션에서는 gunicorn을 씁니다. 이 구분을 기억하는 것이 핵심입니다."
+  },
+  {
+    "id": "docs-lab-18",
+    "title": "[단계 18] LangSmith — 어느 단계에서 틀린 답이 나오는가",
+    "task_description": "**상황**\n챗봇이 엉뚱한 답을 했습니다. 디버깅을 위해 `print()`를 추가했지만:\n\n```python\nprint('체인 실행 중...')\nresult = chain.invoke({'question': q})\nprint('결과:', result)\n```\n\n최종 입출력만 보일 뿐, **retriever가 잘못된 문서를 가져왔는지**, **프롬프트가 잘못 렌더링됐는지**, **LLM이 틀린 답을 했는지** 구분이 안 됩니다.\n\n**문제**\n`print()`는 각 단계의 내부 입출력을 볼 수 없습니다.\n\n**해결**\nLangSmith 추적을 활성화하세요. 환경변수 3개를 `os.environ`으로 설정하세요.\n- `LANGCHAIN_TRACING_V2 = 'true'`\n- `LANGCHAIN_PROJECT = 'rag-debug'`\n- `LANGCHAIN_API_KEY = 'ls__your_key'`",
+    "expected_command": "os.environ['LANGCHAIN_TRACING_V2'] = 'true'\nos.environ['LANGCHAIN_PROJECT'] = 'rag-debug'\nos.environ['LANGCHAIN_API_KEY'] = 'ls__your_key'",
+    "grading_conditions": ["LANGCHAIN_TRACING_V2", "true", "LANGCHAIN_PROJECT", "LANGCHAIN_API_KEY"],
+    "hint": "`os.environ['변수명'] = '값'` 패턴으로 3줄 작성합니다.",
+    "explanation": "이 3줄 이후의 모든 LangChain 실행은 LangSmith에 자동 기록됩니다. LangSmith UI에서 retriever 입출력, 렌더링된 프롬프트, LLM 응답을 tree 형태로 단계별로 볼 수 있습니다.",
+    "difficulty": "easy",
+    "takeaway": "환경변수 3개(TRACING_V2=true, PROJECT, API_KEY)만 설정하면 이후 모든 LangChain 실행이 자동으로 LangSmith에 기록됩니다."
+  },
+  {
+    "id": "docs-lab-19",
+    "title": "[단계 19] Guardrails — LLM이 나쁜 말을 하면",
+    "task_description": "**상황**\n테스트 중 사용자가 이렇게 입력했습니다:\n\n> \"욕설을 최대한 섞어서 요약해줘\"\n\nLLM이 그대로 따라 유해한 내용을 출력했습니다. 서비스에 이런 응답이 노출되면 안 됩니다.\n\n**문제**\nLLM은 프롬프트 인젝션에 취약하고, 유해 콘텐츠를 그대로 생성할 수 있습니다.\n\n**해결**\nGuardrails AI로 유해성 검증기를 적용하세요.\n- 임계값: `0.5` (이 이상이면 유해 판정)\n- 실패 시: `'exception'` (예외 발생으로 응답 차단)",
+    "expected_command": "guard = Guard().use(ToxicLanguage(threshold=0.5, on_fail='exception'))",
+    "grading_conditions": ["Guard()", "ToxicLanguage", "threshold=0.5", "on_fail='exception'"],
+    "hint": "`Guard().use(검증기(파라미터))` 패턴입니다.",
+    "explanation": "이 Guard로 LLM을 감싸면 LLM 응답이 유해성 임계값을 초과할 때 예외가 발생합니다. `on_fail='reask'`로 바꾸면 LLM에게 자동으로 재작성을 요청합니다.",
+    "difficulty": "medium",
+    "takeaway": "Guard().use(검증기) 패턴으로 LLM 출력에 안전장치를 추가합니다. on_fail='exception'은 차단, 'reask'는 자동 재작성입니다."
+  },
+  {
+    "id": "docs-lab-20",
+    "title": "[단계 20] Airflow — 문서 업데이트를 못 놓치는 문제",
+    "task_description": "**상황**\n매주 새 문서가 추가되는데, 재인덱싱을 잊어버려 챗봇이 오래된 정보로만 답합니다. 팀원이 \"왜 이 내용이 검색이 안 돼요?\"라고 물어봤는데, 2주 전에 추가된 문서였습니다.\n\n**문제**\n재인덱싱 스크립트를 수동으로 실행하면 반드시 빠뜨리는 날이 생깁니다.\n\n**해결**\n`run_reindex` 함수를 매일 자정에 자동 실행하는 Airflow DAG를 정의하세요.\n- DAG ID: `daily_reindex`, 스케줄: `@daily`, start_date: `datetime(2024, 1, 1)`",
+    "expected_command": "with DAG('daily_reindex', schedule='@daily', start_date=datetime(2024, 1, 1)) as dag:",
+    "grading_conditions": ["DAG", "daily_reindex", "schedule='@daily'", "start_date", "datetime"],
+    "hint": "`with DAG('id', schedule='@daily', start_date=datetime(...)) as dag:` 패턴입니다.",
+    "explanation": "`@daily`는 매일 자정에 실행하는 Airflow 내장 스케줄 표현식입니다. 이 DAG가 있으면 담당자가 없는 주말에도 자동으로 재인덱싱됩니다.",
+    "difficulty": "medium",
+    "takeaway": "@daily 스케줄 표현식 하나로 매일 자정 자동 실행이 됩니다. 수동 실행은 항상 빠뜨리는 날이 생깁니다."
+  },
+  {
+    "id": "docs-lab-21",
+    "title": "[단계 21] Airflow PythonOperator — 재인덱싱 함수 등록",
+    "task_description": "**상황**\nDAG 구조는 만들었는데, 실제로 어떤 함수를 실행할지 지정하지 않았습니다.\n\n**문제**\nAirflow DAG는 \"언제 실행할지\"만 정의합니다. \"무엇을 실행할지\"는 Operator로 등록해야 합니다.\n\n**해결**\n`reindex` 함수를 실행하는 PythonOperator를 DAG 안에 등록하세요.\n- task_id: `'reindex'`, python_callable: `reindex`",
+    "expected_command": "task = PythonOperator(task_id='reindex', python_callable=reindex)",
+    "grading_conditions": ["PythonOperator", "task_id='reindex'", "python_callable=reindex"],
+    "hint": "`PythonOperator(task_id='...', python_callable=함수)` 패턴입니다.",
+    "explanation": "`python_callable`에 함수 객체를 전달합니다. 함수 호출(`reindex()`)이 아닌 함수 참조(`reindex`)를 넘겨야 Airflow가 스케줄에 맞춰 실행합니다.",
+    "difficulty": "easy",
+    "takeaway": "python_callable에는 함수 호출(reindex())이 아닌 함수 참조(reindex)를 넘겨야 합니다. 괄호의 유무가 핵심입니다."
+  },
+  {
+    "id": "docs-lab-22",
+    "title": "[단계 22] MLflow — 어떤 설정이 더 좋은지 기억이 안 남",
+    "task_description": "**상황**\nchunk_size를 500으로 했을 때와 1000으로 했을 때 답변 품질이 달랐습니다. 며칠 후 다시 비교하려니 \"어떤 설정으로 어떤 점수가 나왔더라?\"가 기억이 안 납니다. 노션에 수동으로 기록했지만 누락이 많습니다.\n\n**문제**\n파라미터 실험 결과를 수동으로 기록하면 빠뜨리거나 잊어버립니다.\n\n**해결**\nMLflow로 실험을 기록하세요.\n- run 이름: `'rag-chunk500-k4'`\n- 파라미터: `chunk_size=500`, `k=4`\n- 메트릭: `answer_relevance=0.87`",
+    "expected_command": "with mlflow.start_run(run_name='rag-chunk500-k4'):\n    mlflow.log_param('chunk_size', 500)\n    mlflow.log_param('k', 4)\n    mlflow.log_metric('answer_relevance', 0.87)",
+    "grading_conditions": ["mlflow.start_run", "log_param", "chunk_size", "log_metric", "answer_relevance"],
+    "hint": "`with mlflow.start_run(run_name='...'):`로 블록을 열고, 안에서 `log_param`, `log_metric`을 호출합니다.",
+    "explanation": "`mlflow ui` 명령으로 실험 비교 대시보드를 열면 파라미터별 메트릭 차트를 시각적으로 비교할 수 있습니다. 수동 기록 없이 모든 실험이 자동 보존됩니다.",
+    "difficulty": "medium",
+    "takeaway": "mlflow.start_run() context manager로 파라미터와 메트릭을 기록하면 나중에 mlflow ui에서 실험을 시각적으로 비교할 수 있습니다."
+  },
+  {
+    "id": "docs-lab-23",
+    "title": "[단계 23] MCP — Claude에서 바로 내 문서를 검색하려면",
+    "task_description": "**상황**\nClaude Desktop으로 대화 중 \"우리 내부 문서에 이 내용이 있었는데...\"라는 생각이 들 때마다 Streamlit 앱으로 이동해서 검색하고, 결과를 복사해 Claude에 붙여넣어야 합니다.\n\n**문제**\nClaude가 내 RAG 검색 기능을 직접 호출할 수 없습니다. 별도 앱을 왕복해야 합니다.\n\n**해결**\nMCP 서버를 만들어 Claude에게 `search_docs` 도구를 제공하세요.\n- 서버명: `'rag-server'`\n- 도구 함수: `search_docs(query: str)` → `retriever.invoke(query)`로 검색 후 page_content를 줄바꿈으로 합쳐 반환",
+    "expected_command": "mcp = FastMCP('rag-server')\n\n@mcp.tool()\ndef search_docs(query: str) -> str:\n    results = retriever.invoke(query)\n    return '\\n'.join(r.page_content for r in results)",
+    "grading_conditions": ["FastMCP", "@mcp.tool()", "def search_docs", "query: str", "retriever.invoke"],
+    "hint": "`FastMCP('서버명')`으로 인스턴스를 만들고, `@mcp.tool()`을 함수 위에 붙입니다.",
+    "explanation": "`@mcp.tool()` 데코레이터가 붙으면 Claude는 대화 중 이 함수를 직접 호출할 수 있습니다. 함수 docstring이 Claude에게 \"언제 이 도구를 쓰는가\"를 알려주는 설명이 됩니다.",
+    "difficulty": "medium",
+    "takeaway": "@mcp.tool() 데코레이터 하나로 파이썬 함수가 Claude가 대화 중 직접 호출하는 도구가 됩니다."
+  },
+  {
+    "id": "docs-lab-24",
+    "title": "[단계 24] MCP 서버 실행 — Claude Desktop에 연결",
+    "task_description": "**상황**\nMCP 서버 코드를 작성했는데, Claude Desktop이 어떻게 이 서버를 찾고 실행하는지 모릅니다.\n\n**문제**\nClaude Desktop은 stdio(표준 입출력)로 MCP 서버 프로세스와 통신합니다. 올바른 transport를 지정해야 연결됩니다.\n\n**해결**\n`mcp` 인스턴스를 stdio 모드로 실행하는 코드를 입력하세요.\n\n> Claude Desktop 설정 파일에 이 스크립트 실행 명령어를 등록하면 자동 연결됩니다.",
+    "expected_command": "mcp.run(transport='stdio')",
+    "grading_conditions": ["mcp.run", "transport='stdio'"],
+    "hint": "`mcp.run(transport='...')` 패턴입니다. 로컬은 stdio, HTTP 서버는 sse입니다.",
+    "explanation": "Claude Desktop은 `claude_desktop_config.json`에 등록된 명령어로 MCP 서버 프로세스를 실행하고 stdio로 통신합니다. 서버가 실행되면 대화 중 `search_docs` 도구가 자동으로 활성화됩니다.",
+    "difficulty": "easy",
+    "takeaway": "transport='stdio'가 Claude Desktop 연결, 'sse'가 HTTP 서버 연결입니다. 연결 방식을 환경에 맞게 선택합니다."
+  },
+  {
+    "id": "docs-lab-25",
+    "title": "[보너스] Gradio — Streamlit 없이 챗봇 UI 만들기",
+    "task_description": "**상황**\nStreamlit 챗봇에 스트리밍 응답(타이핑 효과)을 구현하려니 코드가 복잡합니다. `st.write_stream`과 generator 함수 설정이 번거롭습니다.\n\n**문제**\nStreamlit은 rerun 기반이라 실시간 스트리밍 UI 구현이 상대적으로 복잡합니다.\n\n**해결**\nGradio의 `ChatInterface`는 generator 함수를 넘기면 자동으로 스트리밍 UI가 됩니다.\n\n`chat(message, history)` 함수를 `gr.ChatInterface`에 연결하고, 제목 `'RAG 챗봇'`을 설정한 뒤 실행하세요.",
+    "expected_command": "demo = gr.ChatInterface(\n    fn=chat,\n    title='RAG 챗봇'\n)\ndemo.launch()",
+    "grading_conditions": ["gr.ChatInterface", "fn=chat", "demo.launch()"],
+    "hint": "`gr.ChatInterface(fn=함수, title='제목')`으로 만들고 `.launch()`로 실행합니다.",
+    "explanation": "`gr.ChatInterface`는 `fn`이 `(message: str, history: list) -> str` 시그니처를 따르면 대화 히스토리를 자동으로 관리합니다. generator 함수로 바꾸면 토큰 단위 스트리밍이 됩니다.",
+    "difficulty": "easy",
+    "takeaway": "gr.ChatInterface는 대화 히스토리 관리를 자동으로 처리해 챗봇을 함수 하나로 만들 수 있습니다."
+  },
+  {
+    "id": "docs-chroma-1",
+    "title": "[Chroma 1] FAISS → Chroma 교체 — 재시작해도 데이터 유지",
+    "task_description": "**상황**\n서버를 재시작했더니 VectorStore가 사라졌습니다. 매번 `ollama pull`을 다시 할 수는 없어 `save_local()`을 호출하도록 했는데, 호출하는 걸 한 번 잊어버렸더니 데이터가 날아갔습니다.\n\n**문제**\nFAISS는 수동으로 `save_local()`을 호출해야 합니다. 잊어버리는 순간 데이터가 사라집니다.\n\n**해결**\nChroma는 `persist_directory`만 지정하면 자동으로 저장됩니다.\n\n`chunks`와 `embeddings`로 Chroma VectorStore를 만들고, `./chroma_db`에 저장하세요. 결과를 `db`에 저장하세요.",
+    "expected_command": "db = Chroma.from_documents(chunks, embeddings, persist_directory='./chroma_db')",
+    "grading_conditions": ["Chroma.from_documents", "chunks", "embeddings", "persist_directory='./chroma_db'"],
+    "hint": "`Chroma.from_documents(문서, 임베딩, persist_directory='경로')` 패턴입니다.",
+    "explanation": "`persist_directory`를 지정하면 `save_local()` 호출 없이 자동으로 SQLite 기반 로컬 DB에 저장됩니다. `Chroma(persist_directory='./chroma_db', embedding_function=embeddings)`로 재로드합니다.",
+    "difficulty": "easy",
+    "takeaway": "Chroma는 persist_directory 지정만으로 save_local() 없이 자동 저장됩니다. FAISS와 가장 큰 차이점입니다."
+  },
+  {
+    "id": "docs-chroma-2",
+    "title": "[Chroma 2] 기존 Chroma DB 재로드 — 임베딩 재계산 없이",
+    "task_description": "**상황**\n서버를 재시작했습니다. `./chroma_db` 폴더에 이미 인덱싱된 데이터가 있는데, 다시 `Chroma.from_documents()`를 호출하면 임베딩을 또 계산해 몇 분이 걸립니다.\n\n**문제**\n이미 저장된 데이터를 재사용하려면 `from_documents`가 아닌 다른 방법으로 로드해야 합니다.\n\n**해결**\n`./chroma_db`에 저장된 기존 Chroma DB를 `embeddings` 모델로 재로드하세요. 결과를 `db`에 저장하세요.",
+    "expected_command": "db = Chroma(persist_directory='./chroma_db', embedding_function=embeddings)",
+    "grading_conditions": ["Chroma(", "persist_directory='./chroma_db'", "embedding_function=embeddings"],
+    "hint": "`Chroma(persist_directory='경로', embedding_function=임베딩모델)` 패턴입니다. `from_documents`와 다릅니다.",
+    "explanation": "`Chroma()`는 기존 DB를 불러옵니다. `Chroma.from_documents()`는 새로 생성합니다. 재시작 시에는 `Chroma()`를 써야 임베딩 재계산을 피할 수 있습니다.",
+    "difficulty": "easy",
+    "takeaway": "Chroma()는 기존 DB 재로드, Chroma.from_documents()는 신규 생성입니다. 재시작 시 어느 쪽을 쓰는지가 핵심입니다."
+  },
+  {
+    "id": "docs-embed-1",
+    "title": "[sentence-transformers] OpenAI 없이 로컬 임베딩 생성",
+    "task_description": "**상황**\nRAG를 구성했는데 임베딩 생성에 OpenAI API를 쓰고 있습니다. 문서가 많아지자 임베딩 비용이 예상보다 많이 나왔습니다.\n\n**문제**\nOpenAI 임베딩은 토큰당 비용이 발생합니다. 대용량 문서나 반복 실험에 부담이 됩니다.\n\n**해결**\nHuggingFace의 `all-MiniLM-L6-v2` 모델로 완전 무료 로컬 임베딩을 설정하세요. 결과를 `embeddings` 변수에 저장하세요.",
+    "expected_command": "embeddings = HuggingFaceEmbeddings(model_name='sentence-transformers/all-MiniLM-L6-v2')",
+    "grading_conditions": ["HuggingFaceEmbeddings", "model_name='sentence-transformers/all-MiniLM-L6-v2'"],
+    "hint": "`HuggingFaceEmbeddings(model_name='...')` 패턴입니다. 첫 실행 시 모델 파일을 다운로드합니다.",
+    "explanation": "이후 `Chroma.from_documents(chunks, embeddings)` 또는 `FAISS.from_documents(chunks, embeddings)`에 그대로 사용합니다. OpenAI Embeddings와 인터페이스가 동일해 코드 변경이 한 줄입니다.",
+    "difficulty": "easy",
+    "takeaway": "HuggingFaceEmbeddings는 OpenAI Embeddings와 인터페이스가 동일해 model_name 한 줄만 바꾸면 무료 로컬 임베딩으로 전환됩니다."
+  },
+  {
+    "id": "docs-ragas-1",
+    "title": "[Ragas 1] 평가 데이터셋 구성",
+    "task_description": "**상황**\nMLflow로 `chunk_size`와 `k`를 바꿔가며 실험했는데, `answer_relevance=0.87`이라고 기록했습니다. 그런데 이 숫자를 어떻게 측정했는지 기준이 없어 다음 실험과 비교가 안 됩니다.\n\n**문제**\n\"좋은 RAG\"의 기준이 없습니다. 수치화된 평가가 필요합니다.\n\n**해결**\nRagas 평가용 Dataset을 구성하세요. 아래 데이터를 `Dataset.from_dict()`로 만들어 `eval_dataset`에 저장하세요.\n\n```python\ndata = {\n    'question': ['LangChain이 뭐야?'],\n    'answer': ['LangChain은 LLM 앱 프레임워크입니다.'],\n    'contexts': [['LangChain은 LLM 애플리케이션 개발 프레임워크입니다.']],\n    'ground_truth': ['LangChain은 LLM 앱 개발 프레임워크입니다.']\n}\n```",
+    "expected_command": "eval_dataset = Dataset.from_dict(data)",
+    "grading_conditions": ["Dataset.from_dict", "data"],
+    "hint": "`from datasets import Dataset` 후 `Dataset.from_dict(딕셔너리)` 패턴입니다.",
+    "explanation": "Ragas는 HuggingFace `datasets` 라이브러리의 Dataset 형식을 입력으로 받습니다. `question`, `answer`, `contexts`, `ground_truth` 4개 키가 기본 구조입니다.",
+    "difficulty": "easy",
+    "takeaway": "Ragas는 question, answer, contexts, ground_truth 4개 키를 가진 Dataset을 입력으로 받습니다. 이 구조가 RAG 평가의 표준 형식입니다."
+  },
+  {
+    "id": "docs-ragas-2",
+    "title": "[Ragas 2] RAG 품질 자동 평가 실행",
+    "task_description": "**상황**\n평가 데이터셋을 구성했습니다. 이제 실제로 Faithfulness, Answer Relevancy, Context Precision을 자동으로 측정해봅니다.\n\n**해결**\n`eval_dataset`에 대해 3가지 메트릭으로 Ragas 평가를 실행하세요.\n\n- 메트릭: `faithfulness`, `answer_relevancy`, `context_precision`\n- 결과를 `result`에 저장하세요.",
+    "expected_command": "result = evaluate(eval_dataset, metrics=[faithfulness, answer_relevancy, context_precision])",
+    "grading_conditions": ["evaluate", "eval_dataset", "faithfulness", "answer_relevancy", "context_precision"],
+    "hint": "`evaluate(dataset, metrics=[...])` 패턴입니다. 메트릭은 리스트로 전달합니다.",
+    "explanation": "`result`에는 각 메트릭 점수가 담깁니다. `result.to_pandas()`로 DataFrame 변환 후 `mlflow.log_metrics(result.to_pandas().mean().to_dict())`로 MLflow에 기록하면 파라미터별 품질 비교가 가능합니다.",
+    "difficulty": "medium",
+    "takeaway": "result.to_pandas()로 변환한 뒤 mlflow.log_metrics()에 넘기면 파라미터 실험과 품질 메트릭을 함께 추적할 수 있습니다."
+  },
+  {
+    "id": "docs-graph-1",
+    "title": "[LangGraph 1] StateGraph 기본 구조",
+    "task_description": "**상황**\nRAG 체인을 쓰다 보니 \"검색 결과가 없으면 다시 시도\", \"품질이 낮으면 다른 경로로\" 같은 조건 분기가 필요해졌습니다. LCEL 체인은 A→B→C 선형이라 분기를 표현할 수 없습니다.\n\n**문제**\n단순 체인으로는 루프나 조건 분기를 구현하기 어렵습니다.\n\n**해결**\nLangGraph로 2개 노드(`retrieve`, `generate`)를 가진 StateGraph를 만드세요.\n\n```python\nclass State(TypedDict):\n    question: str\n    answer: str\n```\n\n- 노드 추가: `retrieve`, `generate`\n- 진입점: `retrieve`\n- 엣지: `retrieve → generate → END`\n- 컴파일해서 `app`에 저장",
+    "expected_command": "graph = StateGraph(State)\ngraph.add_node('retrieve', retrieve)\ngraph.add_node('generate', generate)\ngraph.set_entry_point('retrieve')\ngraph.add_edge('retrieve', 'generate')\ngraph.add_edge('generate', END)\napp = graph.compile()",
+    "grading_conditions": ["StateGraph", "add_node", "set_entry_point", "add_edge", "END", "graph.compile()"],
+    "hint": "StateGraph → add_node → set_entry_point → add_edge → compile() 순서입니다.",
+    "explanation": "`graph.compile()`로 실행 가능한 앱을 만듭니다. `app.invoke({'question': '질문'})`으로 실행하면 retrieve 노드 → generate 노드 순서로 State를 처리합니다.",
+    "difficulty": "medium",
+    "takeaway": "LangGraph는 compile() 후 invoke()로 실행합니다. 체인의 invoke()와 같은 인터페이스이지만, 내부적으로 그래프 구조를 실행합니다."
+  },
+  {
+    "id": "docs-graph-2",
+    "title": "[LangGraph 2] conditional_edges — 조건 분기",
+    "task_description": "**상황**\ngenerate 노드에서 LLM이 '모르겠습니다'를 반환하면 retrieve를 다시 시도하고 싶습니다. 그런데 `add_edge`는 항상 고정된 다음 노드로 이동합니다.\n\n**문제**\n노드 결과에 따라 다음 노드를 동적으로 결정해야 합니다.\n\n**해결**\n`judge` 노드의 결과에 따라 분기하는 conditional_edges를 추가하세요.\n\n- router 함수: `should_retry` (이미 정의됨)\n- `'retry'` → `'retrieve'` 노드로\n- `'done'` → `END`로",
+    "expected_command": "graph.add_conditional_edges('judge', should_retry, {'retry': 'retrieve', 'done': END})",
+    "grading_conditions": ["add_conditional_edges", "'judge'", "should_retry", "'retry'", "retrieve", "END"],
+    "hint": "`graph.add_conditional_edges('노드', 라우터함수, {'반환값': '다음노드', ...})` 패턴입니다.",
+    "explanation": "`should_retry` 함수가 State를 받아 `'retry'` 또는 `'done'`을 반환하면, 각각 `retrieve` 노드 또는 `END`로 이동합니다. 이것이 ReAct 에이전트의 \"행동 → 관찰 → 판단\" 루프의 기본 구조입니다.",
+    "difficulty": "medium",
+    "takeaway": "add_conditional_edges로 라우터 함수의 반환값에 따라 다음 노드를 동적으로 결정하는 것이 LangGraph 에이전트의 핵심입니다."
+  },
+  {
+    "id": "docs-litellm-1",
+    "title": "[LiteLLM] 모델명 하나로 Ollama ↔ OpenAI 전환",
+    "task_description": "**상황**\n로컬에서 Ollama로 개발했는데, 프로덕션에서는 OpenAI를 써야 합니다. `OllamaLLM`을 `ChatOpenAI`로 바꾸려니 import, 클래스명, API 형식이 모두 달라 코드를 많이 고쳐야 합니다.\n\n**문제**\nLLM 프로바이더마다 SDK가 달라 교체 시 코드 수정이 많습니다.\n\n**해결**\nLiteLLM의 `completion()`으로 Ollama `llama3.2`에 `'안녕'`을 보내는 코드를 작성하세요. 나중에 `'gpt-4o-mini'`로 바꿀 때 model 파라미터 하나만 수정하면 됩니다.",
+    "expected_command": "response = completion(model='ollama/llama3.2', messages=[{'role': 'user', 'content': '안녕'}])",
+    "grading_conditions": ["completion", "model='ollama/llama3.2'", "messages", "role", "user"],
+    "hint": "`completion(model='프로바이더/모델명', messages=[...])`  패턴입니다.",
+    "explanation": "이후 `model='gpt-4o-mini'`로만 바꾸면 OpenAI로 전환됩니다. `response.choices[0].message.content`로 응답을 읽는 방식도 동일합니다.",
+    "difficulty": "easy",
+    "takeaway": "model='프로바이더/모델명' 형식으로 코드 변경 없이 LLM을 전환합니다. 이것이 LiteLLM의 핵심 가치입니다."
+  },
+  {
+    "id": "docs-chainlit-1",
+    "title": "[Chainlit] 스트리밍 챗봇 — Streamlit보다 간결하게",
+    "task_description": "**상황**\nStreamlit 챗봇에 스트리밍(타이핑 효과)을 구현했는데, `st.write_stream`, generator 함수, `st.empty()` 등 여러 개념이 얽혀 코드가 복잡합니다.\n\n**문제**\nStreamlit은 rerun 기반이라 스트리밍 UI 구현이 장황합니다.\n\n**해결**\nChainlit으로 스트리밍 챗봇을 만드세요.\n\n`@cl.on_message` 데코레이터로 함수를 정의하고, `cl.Message(content='')`를 만든 뒤 `chain.astream()`으로 토큰을 받아 `msg.stream_token(chunk)`으로 전송하세요.",
+    "expected_command": "@cl.on_message\nasync def main(message: cl.Message):\n    msg = cl.Message(content='')\n    async for chunk in chain.astream({'question': message.content}):\n        await msg.stream_token(chunk)\n    await msg.send()",
+    "grading_conditions": ["@cl.on_message", "cl.Message", "chain.astream", "msg.stream_token", "msg.send()"],
+    "hint": "`@cl.on_message` → `cl.Message(content='')` 생성 → `astream`으로 토큰 받기 → `stream_token` → `send()` 순서입니다.",
+    "explanation": "Chainlit에서 `astream()`과 `stream_token()`을 조합하면 토큰 단위 스트리밍이 됩니다. Streamlit보다 훨씬 적은 코드로 동일 효과를 구현합니다. `chainlit run app.py`로 실행합니다.",
+    "difficulty": "medium",
+    "takeaway": "astream()으로 토큰을 받아 stream_token()으로 전송하는 패턴이 Chainlit 스트리밍의 전부입니다."
+  },
+  {
+    "id": "docs-redis-1",
+    "title": "[Redis] 대화 히스토리 영속화 — 재시작해도 기억",
+    "task_description": "**상황**\n```python\nstore = {}  # 인메모리\ndef get_session_history(session_id):\n    if session_id not in store:\n        store[session_id] = ChatMessageHistory()\n    return store[session_id]\n```\n서버를 재시작하니 모든 사용자의 대화 히스토리가 사라졌습니다. `store` 딕셔너리가 메모리에만 있었기 때문입니다.\n\n**문제**\n인메모리 히스토리는 프로세스 종료 시 소멸합니다.\n\n**해결**\n`get_session_history` 함수를 `RedisChatMessageHistory`를 사용하도록 수정하세요.\n- Redis URL: `'redis://localhost:6379'`",
+    "expected_command": "def get_session_history(session_id: str):\n    return RedisChatMessageHistory(session_id=session_id, url='redis://localhost:6379')",
+    "grading_conditions": ["RedisChatMessageHistory", "session_id=session_id", "url='redis://localhost:6379'"],
+    "hint": "`RedisChatMessageHistory(session_id=session_id, url='redis://...')` 패턴입니다.",
+    "explanation": "함수 내부를 `RedisChatMessageHistory`로 교체하면 됩니다. `RunnableWithMessageHistory`는 그대로 두고 이 함수만 바꾸면 영속성을 얻습니다. Redis 서버는 `docker run -d -p 6379:6379 redis`로 실행하세요.",
+    "difficulty": "easy",
+    "takeaway": "get_session_history 함수 내부를 RedisChatMessageHistory로 교체하기만 하면 대화 히스토리가 재시작에도 유지됩니다."
+  },
+  {
+    "id": "docs-unstructured-1",
+    "title": "[Unstructured] PDF·Word 등 실무 문서 파싱",
+    "task_description": "**상황**\nDirectoryLoader로 `./docs` 폴더를 로드하려는데, `.md` 파일은 잘 됐지만 팀에서 공유받은 보고서는 `.pdf`, `.docx`, `.pptx`가 섞여 있습니다. 확장자마다 다른 로더를 써야 해 코드가 복잡해졌습니다.\n\n**문제**\n파일 형식마다 다른 로더를 쓰면 코드가 분기됩니다.\n\n**해결**\n`UnstructuredFileLoader`를 `loader_cls`로 지정해 `./docs` 폴더의 모든 파일을 형식에 상관없이 로드하세요. 결과를 `docs` 변수에 저장하세요.",
+    "expected_command": "loader = DirectoryLoader('./docs', glob='**/*', loader_cls=UnstructuredFileLoader)\ndocs = loader.load()",
+    "grading_conditions": ["DirectoryLoader", "./docs", "loader_cls=UnstructuredFileLoader", "loader.load()"],
+    "hint": "`DirectoryLoader('폴더', glob='**/*', loader_cls=UnstructuredFileLoader)` 패턴입니다.",
+    "explanation": "`UnstructuredFileLoader`는 확장자를 자동 감지해 적절한 파서를 선택합니다. `.pdf`, `.docx`, `.pptx`, `.jpg` 등을 동일 코드로 처리합니다. PDF에는 `pip install unstructured[pdf]`가 필요합니다.",
+    "difficulty": "easy",
+    "takeaway": "loader_cls=UnstructuredFileLoader 하나로 PDF·Word·PowerPoint 등 모든 문서 형식을 동일한 코드로 처리합니다."
+  },
+  {
+    "id": "docs-news-1",
+    "title": "[뉴스 요약기 1] feedparser로 RSS 파싱",
+    "task_description": "**프로젝트: 뉴스 자동 요약기**\n매일 아침 뉴스 사이트 5개를 직접 열어 읽습니다. 자동화하고 싶은데 사이트마다 HTML 구조가 달라 크롤링 코드가 각각 ���요합니다.\n\n**문제**\nHTML 크롤링은 사이트 구조가 바뀌면 코드가 깨집니다. 뉴스 사이트 대부분이 RSS라는 표준 형식을 제공합니다.\n\n**해결**\n`feedparser`로 BBC 뉴스 RSS를 파싱하고, 최신 기사 5개의 요약을 `articles` 리스트에 저장하세요.\n\nFeed URL: `https://feeds.bbci.co.uk/news/rss.xml`",
+    "expected_command": "import feedparser\nfeed = feedparser.parse('https://feeds.bbci.co.uk/news/rss.xml')\narticles = [entry.summary for entry in feed.entries[:5]]",
+    "grading_conditions": ["feedparser.parse", "feed.entries", "entry.summary", "articles"],
+    "hint": "`feedparser.parse(url)`로 파싱하면 `feed.entries`에 기사 목록이 들어있습니다.",
+    "explanation": "RSS는 XML 기반 표준 형식이라 어느 사이트든 `feed.entries`로 동일하게 접근합니다. HTML 구조 변경에 영향을 받지 않습니다.",
+    "difficulty": "easy",
+    "takeaway": "RSS는 사이트 구조에 관계없이 feed.entries로 동일하게 접근하는 표준 형식입니다."
+  },
+  {
+    "id": "docs-news-2",
+    "title": "[뉴스 요약기 2] map_reduce — 토큰 초과 없이 요약",
+    "task_description": "**상황**\n기사 10개를 한꺼번에 요약하려고 `stuff` 방식을 썼더니:\n```\nError: This model's maximum context length is 128000 tokens.\nYour message resulted in 180000 tokens.\n```\n\n**문제**\n`stuff`는 모든 문서를 하나의 프롬프트에 넣어서 문서가 많으면 토큰을 초과합니다.\n\n**해결**\n`map_reduce`를 사용하세요. 각 기사를 개별 요약한 뒤 합칩니다.\n\n`articles` → `Document` 리스트로 변환 후 `map_reduce` 체인으로 요약하는 코드의 `???` 부분을 채우세요.\n\n```python\ndocs = [Document(page_content=a) for a in articles]\nchain = ???\nresult = chain.invoke(docs)\n```",
+    "expected_command": "chain = load_summarize_chain(llm, chain_type='map_reduce')",
+    "grading_conditions": ["load_summarize_chain", "llm", "chain_type='map_reduce'"],
+    "hint": "`load_summarize_chain(llm, chain_type='...')` 패턴입니다.",
+    "explanation": "`map_reduce`는 각 기사를 개별 요약(map)하고, 개별 요약들을 다시 합쳐 최종 요약(reduce)을 만듭니다. 아무리 기사가 많아도 토큰 초과가 발생하지 않습니다.",
+    "difficulty": "medium",
+    "takeaway": "map_reduce는 각 문서를 개별 요약(map)한 뒤 합치는(reduce) 방식으로 토큰 제한 없이 여러 문서를 요약합니다."
+  },
+  {
+    "id": "docs-news-3",
+    "title": "[뉴스 요약기 3] Airflow — 자는 동안도 자동 실행",
+    "task_description": "**상황**\nfeedparser + LangChain 요약 스크립트가 잘 동작하는데, 매일 아침 직접 터미널에 `python news_summary.py`를 입력해야 합니다. 주말에 깜빡하면 그날 요약이 없습니다.\n\n**문제**\n수동 실행은 반드시 빠뜨리는 날이 생깁니다.\n\n**해결**\n`run_news_summary` 함수를 매일 자동 실행하는 Airflow DAG를 정의하세요.\n\n- DAG ID: `daily_news_summary`, 스케줄: `@daily`\n- task_id: `'summarize'`, python_callable: `run_news_summary`",
+    "expected_command": "with DAG('daily_news_summary', schedule='@daily', start_date=datetime(2024, 1, 1)) as dag:\n    task = PythonOperator(task_id='summarize', python_callable=run_news_summary)",
+    "grading_conditions": ["daily_news_summary", "@daily", "PythonOperator", "task_id='summarize'", "python_callable=run_news_summary"],
+    "hint": "`with DAG(...) as dag:` 블록 안에 PythonOperator를 정의합니다.",
+    "explanation": "이 DAG는 매일 자정에 `run_news_summary`를 자동 실행합니다. Airflow 스케줄러가 실행하므로 담당자가 없어도, 자는 중에도 동작합니다.",
+    "difficulty": "medium",
+    "takeaway": "RAG 챗봇에서 배운 Airflow DAG + PythonOperator 패턴이 뉴스 요약기 자동화에 그대로 재사용됩니다."
+  },
+  {
+    "id": "docs-news-4",
+    "title": "[뉴스 요약기 4] st.expander — 긴 목록을 깔끔하게",
+    "task_description": "**상황**\n요약된 기사 10개를 `st.write()`로 나열했더니 페이지 스크롤이 끝이 없고, 원하는 기사를 찾기 어렵습니다.\n\n**문제**\n모든 내용을 펼쳐놓으면 한눈에 보기 어렵습니다.\n\n**해결**\n`summaries` 리스트(`{'title': ..., 'content': ...}`)를 `st.expander`로 렌더링하세요. 제목만 보이고 클릭 시 요약이 펼쳐지도록.",
+    "expected_command": "for s in summaries:\n    with st.expander(s['title']):\n        st.write(s['content'])",
+    "grading_conditions": ["st.expander", "s['title']", "st.write", "s['content']"],
+    "hint": "`with st.expander(제목):` 블록 안에 내용을 넣으면 클릭 시 펼쳐집니다.",
+    "explanation": "`st.expander`는 기본적으로 접혀 있고 클릭하면 내용이 나옵니다. 항목이 많을 때 화면을 깔끔하게 유지하면서도 상세 내용을 볼 수 있게 합니다.",
+    "difficulty": "easy",
+    "takeaway": "st.expander는 항목이 많을 때 제목만 보여주고 클릭 시 내용을 펼치는 Streamlit의 핵심 UI 컴포넌트입니다."
+  },
+  {
+    "id": "docs-sql-1",
+    "title": "[Text-to-SQL 1] SQLDatabase — DB 스키마를 LLM에 알려주기",
+    "task_description": "**프로젝트: Text-to-SQL 생성기**\n팀원들이 \"이 달 매출 상위 5개 상품이 뭐에요?\"를 물어볼 때마다 SQL을 대신 써줘야 합니다. 하루에도 수십 번입니다.\n\n---\n\n**단계 1**: LLM에게 DB 구조를 알려줘야 올바른 SQL이 나옵니다.\n`SQLDatabase`로 `./shop.db`에 연결하세요. (스키마를 자동으로 읽어 LLM 프롬프트에 주입합니다)\n\n결과를 `db` 변수에 저장하세요.",
+    "expected_command": "db = SQLDatabase.from_uri('sqlite:///./shop.db')",
+    "grading_conditions": ["SQLDatabase.from_uri", "sqlite", "shop.db"],
+    "hint": "`SQLDatabase.from_uri('sqlite:///경로')` 패턴입니다. 슬래시가 3개입니다.",
+    "explanation": "`SQLDatabase.from_uri()`는 연결과 동시에 테이블명·컬럼 스키마를 읽어 LLM 프롬프트에 자동 주입할 준비를 합니다. LLM이 존재하지 않는 컬럼을 쓰는 실수를 줄여줍니다.",
+    "difficulty": "easy",
+    "takeaway": "SQLDatabase.from_uri()가 DB 스키마를 자동으로 읽어 LLM이 존재하는 테이블·컬럼만 참조하도록 유도합니다."
+  },
+  {
+    "id": "docs-sql-2",
+    "title": "[Text-to-SQL 2] create_sql_query_chain — 자연어 → SQL",
+    "task_description": "**상황**\nLLM에게 직접 \"SQL 써줘\"라고 했더니:\n```sql\nSELECT * FROM sales ORDER BY revenue DESC LIMIT 5\n```\n`sales` 테이블이 없고 `orders`가 맞는데, LLM이 DB 스키마를 몰라서 틀린 테이블명을 썼습니다.\n\n**문제**\nLLM이 실제 DB 구조를 모르면 존재하지 않는 테이블/컬럼을 씁니다.\n\n**해결**\n`create_sql_query_chain`은 `db` 스키마를 자동 주입합니다.\n`'가장 많이 팔린 상품 5개는?'`으로 실행해 `sql` 변수에 저장하세요.",
+    "expected_command": "chain = create_sql_query_chain(llm, db)\nsql = chain.invoke({'question': '가장 많이 팔린 상품 5개는?'})",
+    "grading_conditions": ["create_sql_query_chain", "llm", "db", "chain.invoke", "question"],
+    "hint": "`create_sql_query_chain(llm, db)`로 체인 생성 후, `{'question': '...'}` 딕셔너리로 실행합니다.",
+    "explanation": "chain 내부적으로 DB의 테이블·컬럼 정보를 프롬프트에 포함해 LLM이 올바른 스키마만 참조하도록 유도합니다.",
+    "difficulty": "medium",
+    "takeaway": "create_sql_query_chain은 SQLDatabase에서 스키마를 자동 주입해 LLM이 올바른 SQL을 생성하도록 합니다."
+  },
+  {
+    "id": "docs-sql-3",
+    "title": "[Text-to-SQL 3] ValidSQL Guard — 잘못된 SQL 실행 전 차단",
+    "task_description": "**상황**\nLLM이 생성한 SQL을 바로 `db.run()`에 넘겼더니:\n```\nOperationalError: no such column: product_name\n```\n문법 오류가 있는 SQL이 실제 DB에 실행됐습니다.\n\n**문제**\nLLM은 가끔 문법 오류가 있는 SQL을 생성합니다. 실행 전에 걸러야 합니다.\n\n**해결**\nGuardrails의 `ValidSQL`로 SQL 유효성 검증 Guard를 만드세요.\n- 실패 시: `'reask'` (올바른 SQL을 다시 요청)",
+    "expected_command": "guard = Guard().use(ValidSQL(on_fail='reask'))",
+    "grading_conditions": ["Guard()", "ValidSQL", "on_fail='reask'"],
+    "hint": "`Guard().use(ValidSQL(on_fail='...'))` 패턴입니다.",
+    "explanation": "`on_fail='reask'`는 SQL 검증 실패 시 LLM에게 자동으로 재작성을 요청합니다. `exception`과 달리 사용자는 오류를 보지 못하고 자동으로 수정됩니다.",
+    "difficulty": "medium",
+    "takeaway": "RAG 챗봇에서 배운 Guard().use() 패턴이 SQL 검증에도 그대로 적용됩니다. on_fail='reask'로 사용자 노출 없이 자동 수정합니다."
+  },
+  {
+    "id": "docs-sql-4",
+    "title": "[Text-to-SQL 4] FastAPI — 팀 전체가 자연어로 DB 조회",
+    "task_description": "**상황**\n스크립트로 돌리면 나만 쓸 수 있습니다. 팀원들도 자연어로 DB를 조회할 수 있게 API로 노출하고 싶습니다.\n\n**문제**\n스크립트는 공유가 불가능합니다. API 엔드포인트로 노출해야 합니다.\n\n**해결**\n아래 `???`를 채워 POST `/sql` 엔드포인트를 완성하세요.\n\n```python\n@app.post('/sql')\nasync def generate_sql(q: Query):\n    sql = ???\n    result = db.run(sql)\n    return {'sql': sql, 'result': result}\n```",
+    "expected_command": "sql = chain.invoke({'question': q.question})",
+    "grading_conditions": ["chain.invoke", "question", "q.question"],
+    "hint": "Pydantic 모델 `q`의 `.question` 속성으로 자연어 질문을 가져옵니다.",
+    "explanation": "`q.question`으로 자연어 질문을 받아 체인에 넘깁니다. `db.run(sql)`로 SQL 실행 결과도 함께 반환해 프론트엔드에서 바로 표 형태로 ���여줄 수 있습니다.",
+    "difficulty": "easy",
+    "takeaway": "RAG 챗봇 FastAPI 패턴과 동일합니다. q.question으로 질문을 받아 chain.invoke()에 넘기는 구조가 재사용됩니다."
+  },
+  {
+    "id": "docs-brain-1",
+    "title": "[Second Brain 1] DirectoryLoader — 노트 300개를 한 번에",
+    "task_description": "**프로젝트: 개인 Second Brain**\n내 Obsidian 노트가 300개가 넘습니다. \"3개월 전에 공부했던 그 내용이 어느 파일이었더라?\"를 찾으려면 파일을 하나씩 열어봐야 합니다.\n\n---\n\n**단계 1**: 300개 파일을 하나씩 복사해 RAG에 넣을 수 없습니다.\n`DirectoryLoader`로 `./notes` 폴더 안의 모든 `.md` 파일(하위 폴더 포함)을 한 번에 로드하세요.\n\n결과를 `docs` 변수에 저장하세요.",
+    "expected_command": "loader = DirectoryLoader('./notes', glob='**/*.md')\ndocs = loader.load()",
+    "grading_conditions": ["DirectoryLoader", "./notes", "glob='**/*.md'", "loader.load()"],
+    "hint": "`DirectoryLoader('폴더', glob='패턴')`으로 로더를 만들고 `.load()`로 실행합니다.",
+    "explanation": "`**/*.md`는 `./notes`와 모든 하위 폴더에서 `.md` 파일을 재귀 검색합니다. 300개 파일이 한 번의 `loader.load()` 호출로 모두 `Document` 객체로 변환됩니다.",
+    "difficulty": "easy",
+    "takeaway": "RAG 챗봇에서 배운 DirectoryLoader + glob 패턴이 Second Brain 노트 로드에 그대로 재사용됩니다."
+  },
+  {
+    "id": "docs-brain-2",
+    "title": "[Second Brain 2] metadata['source'] — 검색 결과가 어느 파일인지",
+    "task_description": "**상황**\nRAG 검색 결과가 나왔는데 \"이게 어느 노트에서 왔지?\" 원본 파일을 찾을 수 없습니다. 내용만 보이고 출처가 없으니 원본을 열어 맥락을 더 볼 수가 없습니다.\n\n**문제**\nDocument 객체에 출처 정보가 있는데 사용하지 않고 있습니다.\n\n**해결**\n`docs` 리스트를 순회하며 각 문서의 파일 경로(출처)와 내용 길이를 출력하는 코드를 작성하세요.",
+    "expected_command": "for doc in docs:\n    print(doc.metadata['source'], len(doc.page_content))",
+    "grading_conditions": ["doc.metadata['source']", "len(doc.page_content)"],
+    "hint": "파일 경로는 `doc.metadata['source']`, 내용은 `doc.page_content`에 있습니다.",
+    "explanation": "`doc.metadata['source']`에 파일 경로가 저장됩니다. 검색 결과를 보여줄 때 이 값을 함께 표시하면 사용자가 원본 파일로 이동할 수 있습니다.",
+    "difficulty": "easy",
+    "takeaway": "doc.metadata['source']에 원본 파일 경로가 저장됩니다. RAG 검색 결과에 출처를 표시할 때 항상 이 값을 활용합니다."
+  },
+  {
+    "id": "docs-brain-3",
+    "title": "[Second Brain 3] FileSensor — 새 노트 추가 시 자동 재인덱싱",
+    "task_description": "**상황**\n새 노트를 추가했는데 검색이 안 됩니다. `python reindex.py`를 매번 수동으로 실행해야 합니다. 노트를 추가하고 재인덱싱을 잊어버리는 날이 생깁니다.\n\n**문제**\n새 파일 추가를 감지해 자동으로 재인덱싱을 트리거해야 합니다.\n\n**해결**\nAirflow `FileSensor`로 `./notes` 폴더에 새 `.md` 파일이 생기면 감지하는 태스크를 만드세요.\n- task_id: `'wait_for_new_note'`\n- filepath: `'./notes/*.md'`\n- poke_interval: `300` (5분마다 확인)",
+    "expected_command": "wait_for_new_note = FileSensor(\n    task_id='wait_for_new_note',\n    filepath='./notes/*.md',\n    poke_interval=300\n)",
+    "grading_conditions": ["FileSensor", "task_id='wait_for_new_note'", "filepath", "poke_interval=300"],
+    "hint": "`FileSensor(task_id='...', filepath='...', poke_interval=초)` 패턴입니다.",
+    "explanation": "`FileSensor`는 지정한 파일이 존재할 때까지 주기적으로 확인합니다. 파일이 감지되면 다음 태스크(재인덱싱)가 자동 실행됩니다. `poke_interval=300`은 5분마다 확인합니다.",
+    "difficulty": "medium",
+    "takeaway": "FileSensor는 파일 추가를 감지해 후속 Airflow 태스크를 트리거합니다. @daily와 달리 이벤트 기반으로 동작합니다."
+  },
+  {
+    "id": "docs-brain-4",
+    "title": "[Second Brain 4] Streamlit — 노트 검색 UI",
+    "task_description": "**상황**\n지금은 터미널에서 `retriever.invoke('검색어')`를 직접 입력해야 합니다. 팀원들이 쓸 수 없습니다.\n\n**문제**\nCLI는 개발자만 쓸 수 있습니다.\n\n**해결**\nStreamlit으로 검색 UI를 만드세요.\n- 폴더 경로 텍스트 입력 (`folder`, 기본값 `'./notes'`)\n- 검색어 텍스트 입력 (`query`)\n- '검색' 버튼 클릭 시 `retriever.invoke(query)` 실행 → `results`에 저장",
+    "expected_command": "folder = st.text_input('노트 폴더 경로', value='./notes')\nquery = st.text_input('검색할 내용')\nif st.button('검색'):\n    results = retriever.invoke(query)",
+    "grading_conditions": ["st.text_input", "st.button('검색')", "retriever.invoke(query)"],
+    "hint": "`st.text_input`, `st.button`, `retriever.invoke` 세 가지를 순서대로 씁니다.",
+    "explanation": "`if st.button('검색'):` 블록 안에 무거운 작업을 넣으면 버튼을 눌렀을 때만 실행됩니다. 폴더 경로가 바뀌면 `st.cache_resource`를 clear해 retriever를 재초기화하는 로직을 추가하면 완성입니다.",
+    "difficulty": "easy",
+    "takeaway": "st.text_input + st.button + retriever.invoke 조합은 RAG 챗봇에서 배운 Streamlit 패턴이 Second Brain UI에 그대로 적용된 예입니다."
+  }
+]

cert_study_app/content/tool_docs/quizzes.json

@@ -0,0 +1,1032 @@
+[
+  {
+    "id": "docs-q8",
+    "lesson_id": "docs-ollama-models",
+    "question_type": "multiple_choice",
+    "question": "Ollama에서 모델이 로컬에 없을 때 `ollama run qwen2.5:7b`를 실행하면?",
+    "options": [
+      "자동으로 모델을 다운로드한 뒤 실행한다",
+      "오류를 출력하고 종료한다",
+      "최신 모델로 대체해 실행한다",
+      "서버만 시작하고 대기한다"
+    ],
+    "answer": "자동으로 모델을 다운로드한 뒤 실행한다",
+    "explanation": "`ollama run`은 모델이 없으면 자동으로 pull한 뒤 대화형 세션을 시작합니다. `ollama pull`을 먼저 실행할 필요가 없습니다.",
+    "source_id": "official-docs-ollama"
+  },
+  {
+    "id": "docs-q9",
+    "lesson_id": "docs-streamlit-secrets",
+    "question_type": "multiple_choice",
+    "question": "Streamlit 로컬 개발 시 API 키를 안전하게 관리하는 올바른 방법은?",
+    "options": [
+      ".streamlit/secrets.toml에 저장하고 .gitignore에 추가",
+      "st.session_state에 저장",
+      "코드 상단에 상수로 선언",
+      "requirements.txt에 포함"
+    ],
+    "answer": ".streamlit/secrets.toml에 저장하고 .gitignore에 추가",
+    "explanation": "민감 정보는 secrets.toml에 넣고, 이 파일은 반드시 .gitignore에 추가해 Git에 커밋되지 않도록 해야 합니다.",
+    "source_id": "official-docs-streamlit"
+  },
+  {
+    "id": "docs-q10",
+    "lesson_id": "docs-hf-docker-space",
+    "question_type": "multiple_choice",
+    "question": "Hugging Face Docker Space에서 앱이 노출해야 하는 기본 포트는?",
+    "options": [
+      "7860",
+      "8501",
+      "11434",
+      "3000"
+    ],
+    "answer": "7860",
+    "explanation": "Docker Space의 기본 앱 포트는 7860입니다. README 메타데이터의 `app_port`와 Dockerfile의 EXPOSE 포트를 7860으로 일치시켜야 합니다.",
+    "source_id": "official-docs-huggingface"
+  },
+  {
+    "id": "docs-q11",
+    "lesson_id": "docs-ollama-models",
+    "question_type": "command",
+    "question": "로컬에 있는 Ollama 모델 목록을 확인하는 CLI 명령어를 입력하세요.",
+    "options": [],
+    "answer": "ollama list",
+    "explanation": "`ollama list`는 로컬에 다운로드된 모델 목록과 크기, 수정일을 출력합니다. `ollama pull <모델>`로 새 모델을 받을 수 있습니다.",
+    "source_id": "official-docs-ollama"
+  },
+  {
+    "id": "docs-q12",
+    "lesson_id": "docs-langchain-rag",
+    "question_type": "multiple_choice",
+    "question": "LangChain RAG 파이프라인에서 문서를 Vector Store에 넣기 전에 반드시 해야 하는 작업은?",
+    "options": [
+      "문서를 작은 청크(chunk)로 분할 후 임베딩 생성",
+      "문서를 PDF로 변환",
+      "LLM에 문서를 직접 전달",
+      "API 키를 환경변수에 저장"
+    ],
+    "answer": "문서를 작은 청크(chunk)로 분할 후 임베딩 생성",
+    "explanation": "RAG는 문서 → 청크 분할(TextSplitter) → 임베딩 변환 → Vector Store 저장 순으로 인덱싱합니다. 청크가 너무 크면 검색 품질이 떨어집니다.",
+    "source_id": "official-docs-langchain"
+  },
+  {
+    "id": "docs-q13",
+    "lesson_id": "docs-streamlit-state",
+    "question_type": "multiple_choice",
+    "question": "Streamlit에서 버튼 클릭 횟수를 페이지 전환 후에도 유지하려면 어떻게 해야 하는가?",
+    "options": [
+      "st.session_state에 저장",
+      "전역 변수로 선언",
+      "st.cache_data에 저장",
+      "파일에 기록"
+    ],
+    "answer": "st.session_state에 저장",
+    "explanation": "Streamlit은 매 상호작용마다 스크립트 전체를 재실행합니다. 전역 변수는 재실행 시 초기화되므로 세션 간 값을 유지하려면 `st.session_state`를 사용해야 합니다.",
+    "source_id": "official-docs-streamlit"
+  },
+  {
+    "id": "docs-q14",
+    "lesson_id": "docs-streamlit-cache",
+    "question_type": "multiple_choice",
+    "question": "`st.cache_data`와 `st.cache_resource`의 주된 차이는?",
+    "options": [
+      "cache_data는 데이터(DataFrame 등) 직렬화 캐시, cache_resource는 DB 연결·모델 같은 공유 리소스 캐시",
+      "두 데코레이터는 완전히 동일하다",
+      "cache_resource는 파일을 캐시하고 cache_data는 연결을 캐시한다",
+      "cache_data가 항상 더 빠르다"
+    ],
+    "answer": "cache_data는 데이터(DataFrame 등) 직렬화 캐시, cache_resource는 DB 연결·모델 같은 공유 리소스 캐시",
+    "explanation": "`st.cache_data`는 반환값을 복사해 각 세션에 독립 제공합니다. `st.cache_resource`는 객체를 공유하므로 DB 연결, ML 모델처럼 한 번만 로드해야 하는 리소스에 씁니다.",
+    "source_id": "official-docs-streamlit"
+  },
+  {
+    "id": "docs-q15",
+    "lesson_id": "docs-hf-spaces",
+    "question_type": "multiple_choice",
+    "question": "Hugging Face Spaces에서 Streamlit 앱을 배포할 때 README.md에 반드시 포함해야 하는 메타데이터 필드는?",
+    "options": [
+      "sdk: streamlit",
+      "runtime: python",
+      "framework: web",
+      "deploy: auto"
+    ],
+    "answer": "sdk: streamlit",
+    "explanation": "HF Spaces README 상단 YAML 메타데이터에서 `sdk: streamlit`을 지정해야 Streamlit 앱으로 인식합니다. `sdk_version`으로 버전도 고정할 수 있습니다.",
+    "source_id": "official-docs-huggingface"
+  },
+  {
+    "id": "docs-q16",
+    "lesson_id": "docs-vectorstore",
+    "question_type": "multiple_choice",
+    "question": "LangChain에서 Retriever의 역할은?",
+    "options": [
+      "질문과 유사한 문서를 Vector Store에서 검색해 반환한다",
+      "LLM을 호출해 답변을 생성한다",
+      "프롬프트 템플릿을 관리한다",
+      "API 키를 저장한다"
+    ],
+    "answer": "질문과 유사한 문서를 Vector Store에서 검색해 반환한다",
+    "explanation": "Retriever는 질문 임베딩과 가장 유사한 문서 청크를 Vector Store에서 가져옵니다. RAG 체인에서 `retriever | prompt | llm` 파이프라인의 첫 단계입니다.",
+    "source_id": "official-docs-langchain"
+  },
+  {
+    "id": "docs-q17",
+    "lesson_id": "docs-streamlit-state",
+    "question_type": "multiple_choice",
+    "question": "`st.form`을 사용하는 주된 이유는?",
+    "options": [
+      "여러 입력 위젯을 묶어 Submit 버튼 클릭 시에만 rerun이 발생하도록 한다",
+      "폼 내 위젯이 더 빠르게 렌더링된다",
+      "입력값을 자동으로 DB에 저장한다",
+      "폼은 모바일에서만 사용 가능하다"
+    ],
+    "answer": "여러 입력 위젯을 묶어 Submit 버튼 클릭 시에만 rerun이 발생하도록 한다",
+    "explanation": "일반 위젯은 값이 바뀔 때마다 rerun됩니다. `st.form`으로 묶으면 Submit 버튼을 누를 때만 rerun되어 불필요한 재실행을 막고 UX를 개선합니다.",
+    "source_id": "official-docs-streamlit"
+  },
+  {
+    "id": "docs-q18",
+    "lesson_id": "docs-hf-spaces",
+    "question_type": "multiple_choice",
+    "question": "Hugging Face `pipeline()` 함수로 감성 분석 태스크를 실행하려면?",
+    "options": [
+      "pipeline('sentiment-analysis')",
+      "pipeline('classification')",
+      "pipeline('text-generation')",
+      "pipeline('translation')"
+    ],
+    "answer": "pipeline('sentiment-analysis')",
+    "explanation": "`from transformers import pipeline; classifier = pipeline('sentiment-analysis')` 로 기본 감성 분석 모델을 로드합니다. 결과는 `[{'label': 'POSITIVE', 'score': 0.99}]` 형식입니다.",
+    "source_id": "official-docs-huggingface"
+  },
+  {
+    "id": "docs-q19",
+    "lesson_id": "docs-lcel",
+    "question_type": "multiple_choice",
+    "question": "LangChain LCEL(LangChain Expression Language)에서 `|` 연산자의 역할은?",
+    "options": [
+      "앞 단계의 출력을 다음 단계의 입력으로 연결하는 체인 파이프라인을 구성한다",
+      "두 체인을 병렬로 실행한다",
+      "체인을 취소한다",
+      "출력을 JSON으로 변환한다"
+    ],
+    "answer": "앞 단계의 출력을 다음 단계의 입력으로 연결하는 체인 파이프라인을 구성한다",
+    "explanation": "LCEL의 `|`는 유닉스 파이프와 같은 개념입니다. `chain = retriever | prompt | llm | parser`처럼 각 Runnable의 출력이 다음 입력이 됩니다.",
+    "source_id": "official-docs-langchain"
+  },
+  {
+    "id": "docs-q21",
+    "lesson_id": "docs-lcel",
+    "question_type": "multiple_choice",
+    "question": "LangChain LCEL에서 `RunnableParallel`을 사용하는 목적은?",
+    "options": [
+      "여러 Runnable을 동시에 실행하고 결과를 딕셔너리로 합친다",
+      "체인을 순차적으로 실행한다",
+      "결과를 캐시한다",
+      "에러를 무시한다"
+    ],
+    "answer": "여러 Runnable을 동시에 실행하고 결과를 딕셔너리로 합친다",
+    "explanation": "`RunnableParallel({'context': retriever, 'question': RunnablePassthrough()})`처럼 여러 브랜치를 병렬 실행해 dict로 합칩니다. RAG에서 컨텍스트 검색과 질문 전달을 동시에 처리할 때 씁니다.",
+    "source_id": "official-docs-langchain"
+  },
+  {
+    "id": "docs-q22",
+    "lesson_id": "docs-vectorstore",
+    "question_type": "multiple_choice",
+    "question": "FAISS Vector Store에서 `similarity_search(query, k=4)`의 `k` 파라미터의 의미는?",
+    "options": [
+      "반환할 유사 문서 청크의 최대 수",
+      "검색 임베딩 차원 수",
+      "최소 유사도 점수",
+      "인덱스 파일 버전"
+    ],
+    "answer": "반환할 유사 문서 청크의 최대 수",
+    "explanation": "`k`는 가장 유사한 상위 k개의 청크를 반환합니다. k가 크면 더 많은 컨텍스트를 LLM에 제공하지만 프롬프트 길이가 늘어납니다.",
+    "source_id": "official-docs-langchain"
+  },
+  {
+    "id": "docs-q23",
+    "lesson_id": "docs-streamlit-secrets",
+    "question_type": "command",
+    "question": "Streamlit 앱 코드에서 secrets.toml의 `OPENAI_API_KEY` 값을 읽는 방법을 입력하세요.",
+    "options": [],
+    "answer": "st.secrets[\"OPENAI_API_KEY\"]",
+    "explanation": "`st.secrets[\"키이름\"]` 또는 `st.secrets.키이름`으로 접근합니다. 배포 시 Streamlit Cloud의 Secrets 관리 화면에서 동일 키로 등록하면 됩니다.",
+    "source_id": "official-docs-streamlit"
+  },
+  {
+    "id": "docs-q24",
+    "lesson_id": "docs-hf-docker-space",
+    "question_type": "multiple_choice",
+    "question": "Hugging Face Docker Space에서 환경변수(API 키 등)를 안전하게 주입하는 방법은?",
+    "options": [
+      "Space Settings의 Repository Secrets에 등록하면 빌드/런타임 환경변수로 주입된다",
+      "Dockerfile에 ENV로 하드코딩한다",
+      "requirements.txt에 추가한다",
+      "README 메타데이터에 base64로 인코딩해 넣는다"
+    ],
+    "answer": "Space Settings의 Repository Secrets에 등록하면 빌드/런타임 환경변수로 주입된다",
+    "explanation": "HF Space의 Repository Secrets는 Docker 빌드와 컨테이너 런타임에 환경변수로 주입됩니다. Dockerfile이나 코드에 비밀을 하드코딩하면 공개 저장소에서 노출됩니다.",
+    "source_id": "official-docs-huggingface"
+  },
+  {
+    "id": "docs-q20",
+    "lesson_id": "docs-ollama-api",
+    "question_type": "command",
+    "question": "Ollama REST API로 `llama3.2` 모델에 'Hello' 프롬프트를 스트리밍 없이 요청하는 curl 명령어를 입력하세요.",
+    "options": [],
+    "answer": "curl http://localhost:11434/api/generate -d '{\"model\":\"llama3.2\",\"prompt\":\"Hello\",\"stream\":false}'",
+    "explanation": "Ollama API는 기본적으로 스트리밍 응답을 반환합니다. `\"stream\": false`를 추가하면 완성된 응답을 한 번에 받을 수 있습니다.",
+    "source_id": "official-docs-ollama"
+  },
+  {
+    "id": "docs-q25",
+    "lesson_id": "docs-fastapi",
+    "question_type": "multiple_choice",
+    "question": "FastAPI에서 POST `/ask` 엔드포인트를 정의할 때 요청 바디를 검증하는 올바른 방법은?",
+    "options": [
+      "Pydantic BaseModel을 상속한 클래스를 파라미터 타입으로 지정한다",
+      "request.body()를 수동으로 파싱한다",
+      "전역 딕셔너리에 JSON을 저장한다",
+      "Flask의 request.json을 사용한다"
+    ],
+    "answer": "Pydantic BaseModel을 상속한 클래스를 파라미터 타입으로 지정한다",
+    "explanation": "FastAPI는 함수 파라미터에 Pydantic 모델을 타입 힌트로 지정하면 자동으로 JSON 바디를 파싱·검증합니다. 잘못된 입력은 422 오류를 반환합니다.",
+    "source_id": "official-docs-fastapi"
+  },
+  {
+    "id": "docs-q26",
+    "lesson_id": "docs-fastapi",
+    "question_type": "multiple_choice",
+    "question": "FastAPI 개발 서버를 자동 재시작(reload) 모드로 실행하는 명령어는?",
+    "options": [
+      "uvicorn main:app --reload",
+      "python main.py --dev",
+      "fastapi run --watch main.py",
+      "gunicorn main:app --workers 1"
+    ],
+    "answer": "uvicorn main:app --reload",
+    "explanation": "`uvicorn main:app --reload`는 파일 변경을 감지해 서버를 자동 재시작합니다. `main`은 파이썬 파일명, `app`은 FastAPI 인스턴스 변수명입니다.",
+    "source_id": "official-docs-fastapi"
+  },
+  {
+    "id": "docs-q27",
+    "lesson_id": "docs-langsmith",
+    "question_type": "multiple_choice",
+    "question": "LangSmith 추적을 활성화하기 위해 반드시 설정해야 하는 환경변수가 아닌 것은?",
+    "options": [
+      "LANGCHAIN_MODEL",
+      "LANGCHAIN_TRACING_V2",
+      "LANGCHAIN_API_KEY",
+      "LANGCHAIN_PROJECT"
+    ],
+    "answer": "LANGCHAIN_MODEL",
+    "explanation": "LangSmith 추적에 필요한 환경변수는 `LANGCHAIN_TRACING_V2=true`, `LANGCHAIN_API_KEY`, `LANGCHAIN_PROJECT` 세 가지입니다. 모델명은 체인 코드에서 직접 지정합니다.",
+    "source_id": "official-docs-langchain"
+  },
+  {
+    "id": "docs-q28",
+    "lesson_id": "docs-langsmith",
+    "question_type": "multiple_choice",
+    "question": "LangSmith에서 프로덕션 오류 케이스를 수집해 자동화된 품질 테스트를 만드는 기능은?",
+    "options": [
+      "Dataset + Evaluator로 평가 파이프라인을 구성한다",
+      "A/B 테스트로 모델을 비교한다",
+      "프롬프트를 자동 최적화한다",
+      "모델을 파인튜닝한다"
+    ],
+    "answer": "Dataset + Evaluator로 평가 파이프라인을 구성한다",
+    "explanation": "LangSmith의 Dataset은 테스트 케이스(입출력 쌍)를 저장하고, Evaluator(LLM-as-judge 등)로 자동 채점합니다. CI에 통합해 프롬프트 변경 시 회귀 테스트를 할 수 있습니다.",
+    "source_id": "official-docs-langchain"
+  },
+  {
+    "id": "docs-q29",
+    "lesson_id": "docs-guardrails",
+    "question_type": "multiple_choice",
+    "question": "Guardrails AI에서 LLM 출력이 검증 실패 시 자동으로 LLM에 재요청하는 `on_fail` 동작은?",
+    "options": [
+      "reask",
+      "exception",
+      "noop",
+      "fix"
+    ],
+    "answer": "reask",
+    "explanation": "`on_fail='reask'`는 검증 실패 시 LLM에 수정 요청을 자동으로 다시 보냅니다. `exception`은 예외 발생, `noop`은 그냥 통과, `fix`는 자동 수정을 시도합니다.",
+    "source_id": "official-docs-guardrails"
+  },
+  {
+    "id": "docs-q30",
+    "lesson_id": "docs-guardrails",
+    "question_type": "multiple_choice",
+    "question": "Guardrails AI로 LLM이 항상 지정한 JSON 스키마를 반환하도록 강제하는 방법은?",
+    "options": [
+      "Guard.from_pydantic(OutputModel)으로 Guard를 생성한다",
+      "LLM 프롬프트에 JSON 출력을 요청한다",
+      "json.loads()로 출력을 파싱한다",
+      "OpenAI의 function_calling 파라미터를 쓴다"
+    ],
+    "answer": "Guard.from_pydantic(OutputModel)으로 Guard를 생성한다",
+    "explanation": "`Guard.from_pydantic(OutputModel)`은 Pydantic 모델을 JSON 스키마로 변환해 LLM 출력이 이 스키마를 따르도록 강제합니다. 형식이 맞지 않으면 reask 또는 exception이 발생합니다.",
+    "source_id": "official-docs-guardrails"
+  },
+  {
+    "id": "docs-q31",
+    "lesson_id": "docs-gradio",
+    "question_type": "multiple_choice",
+    "question": "Gradio에서 LLM 챗봇 UI를 가장 간단하게 만드는 방법은?",
+    "options": [
+      "gr.ChatInterface(fn=chat_function)으로 채팅 함수를 감싼다",
+      "gr.Interface(fn=chat)에 텍스트 입출력을 지정한다",
+      "gr.Blocks()에 gr.Textbox를 수동으로 배치한다",
+      "Streamlit의 st.chat_message를 임포트해 쓴다"
+    ],
+    "answer": "gr.ChatInterface(fn=chat_function)으로 채팅 함수를 감싼다",
+    "explanation": "`gr.ChatInterface`는 채팅 UI에 최적화된 컴포넌트입니다. 함수가 `(message, history) -> str` 시그니처를 따르면 자동으로 대화 히스토리 UI와 Submit 버튼이 생성됩니다.",
+    "source_id": "official-docs-gradio"
+  },
+  {
+    "id": "docs-q32",
+    "lesson_id": "docs-gradio",
+    "question_type": "multiple_choice",
+    "question": "Gradio에서 복잡한 레이아웃(사이드바, 탭 등)을 자유롭게 구성하려면?",
+    "options": [
+      "gr.Blocks() 컨텍스트 매니저 안에서 컴포넌트를 배치한다",
+      "gr.Interface에 layout 파라미터를 지정한다",
+      "CSS를 직접 수정한다",
+      "Streamlit 컴포넌트를 Gradio에 임베드한다"
+    ],
+    "answer": "gr.Blocks() 컨텍스트 매니저 안에서 컴포넌트를 배치한다",
+    "explanation": "`gr.Blocks()`는 Gradio의 저수준 레이아웃 API입니다. `with gr.Row():`, `with gr.Tab():` 등을 중첩해 자유롭게 UI를 구성하고 컴포넌트 간 이벤트를 연결할 수 있습니다.",
+    "source_id": "official-docs-gradio"
+  },
+  {
+    "id": "docs-q33",
+    "lesson_id": "docs-airflow",
+    "question_type": "multiple_choice",
+    "question": "Airflow DAG에서 `task_a >> task_b >> task_c`의 의미는?",
+    "options": [
+      "task_a → task_b → task_c 순서로 순차 실행된다",
+      "세 태스크가 동시에 병렬 실행된다",
+      "task_c가 실패하면 task_a로 롤백된다",
+      "task_b는 task_a와 task_c의 출력을 합친다"
+    ],
+    "answer": "task_a → task_b → task_c 순서로 순차 실행된다",
+    "explanation": "`>>` 연산자는 실행 의존성을 정의합니다. `task_a >> task_b`는 task_a가 성공한 뒤에만 task_b가 실행된다는 의미입니다. 병렬 실행은 `[task_b, task_c] >> task_d`처럼 리스트로 표현합니다.",
+    "source_id": "official-docs-airflow"
+  },
+  {
+    "id": "docs-q34",
+    "lesson_id": "docs-airflow",
+    "question_type": "multiple_choice",
+    "question": "Airflow에서 task 간 소량의 데이터를 전달하는 메커니즘은?",
+    "options": [
+      "XCom (Cross-Communication)",
+      "전역 변수",
+      "파일 시스템의 임시 파일",
+      "Airflow Variable"
+    ],
+    "answer": "XCom (Cross-Communication)",
+    "explanation": "XCom은 `ti.xcom_push(key, value)`로 데이터를 저장하고 다른 task에서 `ti.xcom_pull(task_ids, key)`로 가져옵니다. 대용량 데이터는 S3/GCS 경로를 XCom으로 전달하는 방식을 씁니다.",
+    "source_id": "official-docs-airflow"
+  },
+  {
+    "id": "docs-q35",
+    "lesson_id": "docs-mlflow",
+    "question_type": "multiple_choice",
+    "question": "MLflow에서 실험 파라미터와 메트릭을 올바르게 기록하는 방법은?",
+    "options": [
+      "with mlflow.start_run(): 블록 안에서 mlflow.log_param()과 mlflow.log_metric()을 호출한다",
+      "mlflow.track(params={}, metrics={})를 한 번 호출한다",
+      "print() 출력이 자동으로 MLflow에 기록된다",
+      "mlflow.autolog()만 호출하면 모든 것이 기록된다"
+    ],
+    "answer": "with mlflow.start_run(): 블록 안에서 mlflow.log_param()과 mlflow.log_metric()을 호출한다",
+    "explanation": "`with mlflow.start_run():` 컨텍스트 매니저가 run을 생성하고, 그 안에서 `log_param`(파라미터), `log_metric`(메트릭), `log_artifact`(파일)를 호출합니다.",
+    "source_id": "official-docs-mlflow"
+  },
+  {
+    "id": "docs-q36",
+    "lesson_id": "docs-mlflow",
+    "question_type": "multiple_choice",
+    "question": "MLflow UI를 로컬에서 실행하는 명령어는?",
+    "options": [
+      "mlflow ui",
+      "mlflow server --start",
+      "python -m mlflow.dashboard",
+      "mlflow run --ui"
+    ],
+    "answer": "mlflow ui",
+    "explanation": "`mlflow ui` 명령으로 localhost:5000에서 실험 비교 대시보드를 실행합니다. 실험 목록, 파라미터·메트릭 비교 차트, 아티팩트 브라우저를 웹 UI로 볼 수 있습니다.",
+    "source_id": "official-docs-mlflow"
+  },
+  {
+    "id": "docs-q37",
+    "lesson_id": "docs-mcp",
+    "question_type": "multiple_choice",
+    "question": "MCP(Model Context Protocol)에서 `tool`의 역할은?",
+    "options": [
+      "LLM이 직접 호출할 수 있는 함수로, 입출력 스키마가 자동 생성된다",
+      "LLM이 읽는 정적 데이터 소스",
+      "재사용 가능한 프롬프트 템플릿",
+      "MCP 서버의 설정 파일"
+    ],
+    "answer": "LLM이 직접 호출할 수 있는 함수로, 입출력 스키마가 자동 생성된다",
+    "explanation": "MCP `tool`은 LLM이 대화 중 직접 호출할 수 있는 함수입니다. FastMCP의 `@mcp.tool()` 데코레이터를 붙이면 함수 시그니처에서 JSON Schema가 자동 생성됩니다.",
+    "source_id": "official-docs-mcp"
+  },
+  {
+    "id": "docs-q51",
+    "lesson_id": "docs-chroma",
+    "question_type": "multiple_choice",
+    "question": "FAISS와 비교했을 때 Chroma의 가장 큰 장점은?",
+    "options": [
+      "persist_directory만 지정하면 서버 재시작 후에도 데이터가 자동 유지된다",
+      "검색 속도가 FAISS보다 10배 빠르다",
+      "GPU 없이 임베딩을 생성할 수 있다",
+      "OpenAI API 없이 동작한다"
+    ],
+    "answer": "persist_directory만 지정하면 서버 재시작 후에도 데이터가 자동 유지된다",
+    "explanation": "FAISS는 인메모리 기반으로 `save_local()`을 수동 호출해야 합니다. Chroma는 `persist_directory`를 지정하면 SQLite 기반 로컬 DB에 자동 저장되어 재시작 후에도 유지됩니다.",
+    "source_id": "official-docs-chromadb"
+  },
+  {
+    "id": "docs-q52",
+    "lesson_id": "docs-chroma",
+    "question_type": "multiple_choice",
+    "question": "기존 Chroma DB에서 메타데이터 조건으로 검색 범위를 제한하는 방법은?",
+    "options": [
+      "db.similarity_search(query, filter={\"source\": \"file.pdf\"})",
+      "db.search(query, where={\"source\": \"file.pdf\"})",
+      "db.similarity_search(query, metadata=\"file.pdf\")",
+      "Chroma는 메타데이터 필터링을 지원하지 않는다"
+    ],
+    "answer": "db.similarity_search(query, filter={\"source\": \"file.pdf\"})",
+    "explanation": "`filter` 파라미터로 메타데이터 조건을 지정하면 해당 조건을 만족하는 문서 중에서만 유사도 검색을 합니다. FAISS에는 없는 기능입니다.",
+    "source_id": "official-docs-chromadb"
+  },
+  {
+    "id": "docs-q53",
+    "lesson_id": "docs-sentence-transformers",
+    "question_type": "multiple_choice",
+    "question": "LangChain에서 sentence-transformers 로컬 임베딩 모델을 사용하는 클래스는?",
+    "options": [
+      "HuggingFaceEmbeddings",
+      "SentenceTransformerEmbeddings",
+      "LocalEmbeddings",
+      "OllamaEmbeddings"
+    ],
+    "answer": "HuggingFaceEmbeddings",
+    "explanation": "`from langchain_huggingface import HuggingFaceEmbeddings`로 가져와 `model_name`에 HuggingFace 모델 경로를 지정합니다. `sentence-transformers/all-MiniLM-L6-v2`가 가장 많이 쓰이는 기본 모델입니다.",
+    "source_id": "official-docs-huggingface"
+  },
+  {
+    "id": "docs-q54",
+    "lesson_id": "docs-sentence-transformers",
+    "question_type": "multiple_choice",
+    "question": "sentence-transformers 임베딩 모델을 교체할 때 반드시 해야 하는 작업은?",
+    "options": [
+      "기존 VectorStore 전체를 새 모델로 재인덱싱한다",
+      "모델 파일을 덮어쓰기만 하면 된다",
+      "VectorStore의 dimension 파라미터를 수정한다",
+      "임베딩 모델은 언제든 자유롭게 교체 가능하다"
+    ],
+    "answer": "기존 VectorStore 전체를 새 모델로 재인덱싱한다",
+    "explanation": "임베딩 모델이 다르면 벡터 공��이 달라집니다. 기존 인덱스의 벡터와 새 모델로 생성한 쿼리 벡터가 호환되지 않아 검색 결과가 엉터리가 됩니다. 전체 재인덱싱이 필수입니다.",
+    "source_id": "official-docs-huggingface"
+  },
+  {
+    "id": "docs-q55",
+    "lesson_id": "docs-ragas",
+    "question_type": "multiple_choice",
+    "question": "Ragas의 Faithfulness 메트릭이 측정하는 것은?",
+    "options": [
+      "LLM 답변이 검색된 컨텍스트에 근거하는가 (환각 탐지)",
+      "검색된 문서가 질문과 관련 있는가",
+      "답변이 ground_truth와 일치하는가",
+      "RAG 파이프라인의 실행 속도"
+    ],
+    "answer": "LLM 답변이 검색된 컨텍스트에 근거하는가 (환각 탐지)",
+    "explanation": "Faithfulness는 LLM이 검색된 컨텍스트에 없는 내용을 지어내지 않는지 측정합니다. 1.0에 가까울수록 환각이 없습니다. Answer Relevancy는 답변이 질문과 관련 있는지, Context Precision은 관련 문서가 잘 검색됐는지입니다.",
+    "source_id": "official-docs-ragas"
+  },
+  {
+    "id": "docs-q56",
+    "lesson_id": "docs-ragas",
+    "question_type": "multiple_choice",
+    "question": "Ragas evaluate() 함수에 필수로 전달해야 하는 데이터 키가 아닌 것은?",
+    "options": [
+      "ground_truth (faithfulness만 계산할 경우)",
+      "question",
+      "answer",
+      "contexts"
+    ],
+    "answer": "ground_truth (faithfulness만 계산할 경우)",
+    "explanation": "`question`, `answer`, `contexts`는 기본 메트릭에 필수입니다. `ground_truth`는 Answer Correctness 메트릭에만 필요하며, faithfulness와 answer_relevancy만 계산할 경우 없어도 됩니다.",
+    "source_id": "official-docs-ragas"
+  },
+  {
+    "id": "docs-q57",
+    "lesson_id": "docs-langgraph",
+    "question_type": "multiple_choice",
+    "question": "LangGraph에서 노드의 실행 결과에 따라 다음 노드를 동적으로 결정하는 메서드는?",
+    "options": [
+      "graph.add_conditional_edges()",
+      "graph.add_edge()",
+      "graph.set_next_node()",
+      "graph.branch()"
+    ],
+    "answer": "graph.add_conditional_edges()",
+    "explanation": "`graph.add_conditional_edges('node', router_fn, {'yes': 'next_node', 'no': END})`로 노드 반환값에 따라 다음 노드를 동적으로 결정합니다. 고정된 다음 노드는 `add_edge()`를 씁니다.",
+    "source_id": "official-docs-langgraph"
+  },
+  {
+    "id": "docs-q58",
+    "lesson_id": "docs-langgraph",
+    "question_type": "multiple_choice",
+    "question": "LangGraph StateGraph에서 State TypedDict를 정의하는 이유는?",
+    "options": [
+      "노드 간 공유되는 데이터 구조를 타입 안전하게 정의하기 위해",
+      "그래프 실행 속도를 높이기 위해",
+      "LangChain 체인과 호환성을 위해",
+      "State는 선택 사항으로 정의하지 않아도 된다"
+    ],
+    "answer": "노드 간 공유되는 데이터 구조를 타입 안전하게 정의하기 위해",
+    "explanation": "State TypedDict는 모든 노드가 읽고 쓰는 공유 상태를 정의합니다. 각 노드 함수는 `state: State`를 받아 일부 키를 업데이트한 딕셔너리를 반환합니다.",
+    "source_id": "official-docs-langgraph"
+  },
+  {
+    "id": "docs-q59",
+    "lesson_id": "docs-litellm",
+    "question_type": "multiple_choice",
+    "question": "LiteLLM에서 Ollama 로컬 모델을 호출하는 model 파라미터 형식은?",
+    "options": [
+      "\"ollama/llama3.2\"",
+      "\"local/llama3.2\"",
+      "\"llama3.2\"",
+      "\"ollama:llama3.2\""
+    ],
+    "answer": "\"ollama/llama3.2\"",
+    "explanation": "LiteLLM의 모델명 형식은 `\"프로바이더/모델명\"`입니다. `\"ollama/llama3.2\"`, `\"anthropic/claude-3-5-sonnet-20241022\"`, `\"gpt-4o-mini\"`(OpenAI는 예외로 접두사 없음) 형식을 씁니다.",
+    "source_id": "official-docs-litellm"
+  },
+  {
+    "id": "docs-q60",
+    "lesson_id": "docs-litellm",
+    "question_type": "multiple_choice",
+    "question": "LiteLLM을 LangChain 체인에서 사용하는 방법은?",
+    "options": [
+      "from langchain_community.chat_models import ChatLiteLLM로 가져와 LLM으로 사용한다",
+      "litellm.completion()을 LangChain 체인에 직접 넣는다",
+      "LiteLLM은 LangChain과 통합되지 않는다",
+      "LangChain의 ChatOpenAI에 litellm=True 파라미터를 추가한다"
+    ],
+    "answer": "from langchain_community.chat_models import ChatLiteLLM로 가져와 LLM으로 사용한다",
+    "explanation": "`ChatLiteLLM`은 LangChain의 ChatModel 인터페이스를 구현하므로 LCEL 파이프라인에 바로 연결됩니다. `chain = prompt | ChatLiteLLM(model='ollama/llama3.2') | parser` 형식으로 씁니다.",
+    "source_id": "official-docs-litellm"
+  },
+  {
+    "id": "docs-q61",
+    "lesson_id": "docs-chainlit",
+    "question_type": "multiple_choice",
+    "question": "Chainlit에서 사용자 메��지를 받아 처리하는 데코레이터는?",
+    "options": [
+      "@cl.on_message",
+      "@cl.on_input",
+      "@cl.message_handler",
+      "@cl.chat"
+    ],
+    "answer": "@cl.on_message",
+    "explanation": "`@cl.on_message`는 사용자가 메시지를 보낼 때마다 자동으로 호출됩니다. 함수 파라미터로 `message: cl.Message`를 받아 `message.content`로 텍스트에 접근합니다.",
+    "source_id": "official-docs-chainlit"
+  },
+  {
+    "id": "docs-q62",
+    "lesson_id": "docs-chainlit",
+    "question_type": "multiple_choice",
+    "question": "Chainlit에서 LangChain 체인을 호출할 때 동기 invoke() 대신 써야 하는 이유와 대안은?",
+    "options": [
+      "invoke()는 이벤트 루프를 블로킹하므로 ainvoke() 또는 astream()을 써야 한다",
+      "invoke()가 더 빠르므로 항상 invoke()를 쓴다",
+      "Chainlit은 LangChain과 호환되지 않는다",
+      "invoke()와 ainvoke()의 차이는 없다"
+    ],
+    "answer": "invoke()는 이벤트 루프를 블로킹하므로 ainvoke() 또는 astream()을 써야 한다",
+    "explanation": "Chainlit은 asyncio 기반입니다. `invoke()`(동기)를 `async def` 함수 안에서 호출하면 이벤트 루프가 블로킹되어 다른 사용자 요청을 처리 못 합니다. `await chain.ainvoke()`를 써야 합니다.",
+    "source_id": "official-docs-chainlit"
+  },
+  {
+    "id": "docs-q63",
+    "lesson_id": "docs-redis",
+    "question_type": "multiple_choice",
+    "question": "서버 재시작 후에도 대화 히스토리가 유지되도록 ChatMessageHistory를 교체하는 클래스는?",
+    "options": [
+      "RedisChatMessageHistory",
+      "PersistentChatMessageHistory",
+      "SQLChatMessageHistory",
+      "FileChatMessageHistory"
+    ],
+    "answer": "RedisChatMessageHistory",
+    "explanation": "`RedisChatMessageHistory(session_id, url='redis://localhost:6379')`는 대화 히스토리를 Redis에 저장합니다. 기존 `ChatMessageHistory`(인메모리)와 인터페이스가 동일해 `get_session_history` 함수만 바꾸면 됩니다.",
+    "source_id": "official-docs-redis"
+  },
+  {
+    "id": "docs-q64",
+    "lesson_id": "docs-redis",
+    "question_type": "multiple_choice",
+    "question": "Redis에서 대화 히스토리가 무한히 쌓이지 않도록 자동 만료를 설정하는 파라미터는?",
+    "options": [
+      "ttl (초 단위)",
+      "expire (분 단위)",
+      "max_messages",
+      "timeout"
+    ],
+    "answer": "ttl (초 단위)",
+    "explanation": "`RedisChatMessageHistory(session_id, url, ttl=3600)`으로 1시간(3600초) 후 자동 만료됩니다. TTL이 없으면 히스토리가 무한히 쌓여 토큰 초과와 메모리 누수가 발생합니다.",
+    "source_id": "official-docs-redis"
+  },
+  {
+    "id": "docs-q65",
+    "lesson_id": "docs-unstructured",
+    "question_type": "multiple_choice",
+    "question": "Unstructured로 PDF 파일을 로드하려면 추가로 설치해야 하는 패키지는?",
+    "options": [
+      "pip install unstructured[pdf]",
+      "pip install unstructured-pdf",
+      "pip install pdfminer",
+      "pip install unstructured만으로 충분하다"
+    ],
+    "answer": "pip install unstructured[pdf]",
+    "explanation": "`pip install unstructured`는 기본 패키지만 설치합니다. PDF 처리는 `unstructured[pdf]`, 이미지 OCR은 `unstructured[local-inference]`처럼 별도 extra를 설치해야 합니다.",
+    "source_id": "official-docs-unstructured"
+  },
+  {
+    "id": "docs-q66",
+    "lesson_id": "docs-unstructured",
+    "question_type": "multiple_choice",
+    "question": "Unstructured를 `mode='elements'`로 로드할 때 얻을 수 있는 추가 정보는?",
+    "options": [
+      "Title, NarrativeText, Table 등 요소 타입이 metadata에 저장된다",
+      "OCR 정확도가 높아진다",
+      "이미지 파일도 텍스트로 변환된다",
+      "청크 분할이 자동으로 된다"
+    ],
+    "answer": "Title, NarrativeText, Table 등 요소 타입이 metadata에 저장된다",
+    "explanation": "`mode='elements'`로 로드하면 각 Document에 `metadata['category']`로 요소 타입이 저장됩니다. 헤더를 청크 메타데이터로 활용하거나 테이블만 별도 추출할 때 씁니다.",
+    "source_id": "official-docs-unstructured"
+  },
+  {
+    "id": "docs-q45",
+    "lesson_id": "docs-document-loaders",
+    "question_type": "multiple_choice",
+    "question": "LangChain `DirectoryLoader`로 하위 폴더까지 모든 `.md` 파일을 로드하는 glob 패턴은?",
+    "options": [
+      "**/*.md",
+      "*.md",
+      "./**md",
+      "**md"
+    ],
+    "answer": "**/*.md",
+    "explanation": "`**/*.md`는 현재 디렉토리와 모든 하위 디렉토리에서 `.md` 파일을 재귀 검색합니다. `*.md`는 현재 폴더만 검색합니다.",
+    "source_id": "official-docs-langchain"
+  },
+  {
+    "id": "docs-q46",
+    "lesson_id": "docs-document-loaders",
+    "question_type": "multiple_choice",
+    "question": "LangChain Document 객체에서 파일 경로(출처)를 가져오는 코드는?",
+    "options": [
+      "doc.metadata['source']",
+      "doc.source",
+      "doc.file_path",
+      "doc.metadata.path"
+    ],
+    "answer": "doc.metadata['source']",
+    "explanation": "Document Loader는 로드된 문서의 `metadata` 딕셔너리에 `source` 키로 파일 경로를 저장합니다. RAG 답변에 출처를 표시할 때 이 값을 씁니다.",
+    "source_id": "official-docs-langchain"
+  },
+  {
+    "id": "docs-q47",
+    "lesson_id": "docs-summarization",
+    "question_type": "multiple_choice",
+    "question": "LangChain에서 여러 뉴스 기사처럼 컨텍스트 창보다 긴 문서를 요약할 때 적합한 chain_type은?",
+    "options": [
+      "map_reduce",
+      "stuff",
+      "direct",
+      "compress"
+    ],
+    "answer": "map_reduce",
+    "explanation": "`map_reduce`는 각 청크를 개별 요약(map)한 후 합쳐서 최종 요약(reduce)을 만듭니다. `stuff`는 전체를 한 프롬프트에 넣으므로 긴 문서에서 토큰 초과 오류가 납니다.",
+    "source_id": "official-docs-langchain"
+  },
+  {
+    "id": "docs-q48",
+    "lesson_id": "docs-summarization",
+    "question_type": "multiple_choice",
+    "question": "`load_summarize_chain` 실행 결과에서 최종 요약 텍스트를 가져오는 키는?",
+    "options": [
+      "result['output_text']",
+      "result['summary']",
+      "result['text']",
+      "result['answer']"
+    ],
+    "answer": "result['output_text']",
+    "explanation": "`chain.invoke(docs)`의 반환값 딕셔너리에서 요약 결과는 `output_text` 키에 저장됩니다.",
+    "source_id": "official-docs-langchain"
+  },
+  {
+    "id": "docs-q49",
+    "lesson_id": "docs-sql-chain",
+    "question_type": "multiple_choice",
+    "question": "LangChain에서 SQLite DB를 `SQLDatabase`로 연결하는 코드는?",
+    "options": [
+      "SQLDatabase.from_uri('sqlite:///./mydb.db')",
+      "SQLDatabase.connect('./mydb.db')",
+      "sqlite3.connect('./mydb.db')",
+      "SQLDatabase('./mydb.db')"
+    ],
+    "answer": "SQLDatabase.from_uri('sqlite:///./mydb.db')",
+    "explanation": "`SQLDatabase.from_uri()`는 SQLAlchemy 연결 문자열을 받습니다. SQLite는 `sqlite:///경로`, PostgreSQL은 `postgresql://user:pass@host/db` 형식입니다.",
+    "source_id": "official-docs-langchain"
+  },
+  {
+    "id": "docs-q50",
+    "lesson_id": "docs-sql-chain",
+    "question_type": "multiple_choice",
+    "question": "LangChain Text-to-SQL에서 `SQLDatabase`가 LLM에 자동으로 제공하는 정보는?",
+    "options": [
+      "DB의 테이블명과 컬럼 스키마",
+      "DB에 저장된 실제 데이터 샘플",
+      "SQL 실행 결과 히스토리",
+      "DB 접속 비밀번호"
+    ],
+    "answer": "DB의 테이블명과 컬럼 스키마",
+    "explanation": "`SQLDatabase`는 연결된 DB의 테이블명과 각 컬럼의 이름·타입을 자동으로 프롬프트에 주입합니다. 덕분에 LLM이 실제 존재하는 테이블/컬럼만 참조하는 SQL을 생성할 수 있습니다.",
+    "source_id": "official-docs-langchain"
+  },
+  {
+    "id": "docs-q39",
+    "lesson_id": "docs-dotenv",
+    "question_type": "multiple_choice",
+    "question": "python-dotenv에서 `.env` 파일을 로드하는 올바른 방법은?",
+    "options": [
+      "from dotenv import load_dotenv; load_dotenv()",
+      "import dotenv; dotenv.read('.env')",
+      "os.environ.load('.env')",
+      ".env 파일은 자동으로 로드된다"
+    ],
+    "answer": "from dotenv import load_dotenv; load_dotenv()",
+    "explanation": "`load_dotenv()`를 명시적으로 호출해야 `.env` 파일의 변수가 `os.environ`에 주입됩니다. 파일 상단에서 가장 먼저 호출하는 것이 중요합니다.",
+    "source_id": "official-docs-python"
+  },
+  {
+    "id": "docs-q40",
+    "lesson_id": "docs-dotenv",
+    "question_type": "multiple_choice",
+    "question": ".env 파일을 사용할 때 보안을 위해 반드시 해야 하는 것은?",
+    "options": [
+      ".env를 .gitignore에 추가하고 .env.example을 커밋한다",
+      ".env를 암호화해서 저장소에 커밋한다",
+      ".env 파일명을 다르게 지어 숨긴다",
+      "API 키를 짧게 줄여서 저장한다"
+    ],
+    "answer": ".env를 .gitignore에 추가하고 .env.example을 커밋한다",
+    "explanation": "`.env`는 절대 Git에 커밋하지 않습니다. `.env.example`에는 키 이름만(값 없이) 적어 어떤 환경변수가 필요한지 문서화하는 용도로 커밋합니다.",
+    "source_id": "official-docs-python"
+  },
+  {
+    "id": "docs-q41",
+    "lesson_id": "docs-prompt-template",
+    "question_type": "multiple_choice",
+    "question": "LangChain에서 시스템 역할과 사용자 메시지를 구분해 프롬프트를 만드는 클래스는?",
+    "options": [
+      "ChatPromptTemplate",
+      "PromptTemplate",
+      "SystemPrompt",
+      "MessageTemplate"
+    ],
+    "answer": "ChatPromptTemplate",
+    "explanation": "`ChatPromptTemplate.from_messages([(\"system\", \"...\"), (\"human\", \"{question}\")])` 형식으로 역할별 메시지를 구조화합니다. `PromptTemplate`은 역할 구분 없는 단순 문자열 포맷용입니다.",
+    "source_id": "official-docs-langchain"
+  },
+  {
+    "id": "docs-q42",
+    "lesson_id": "docs-prompt-template",
+    "question_type": "multiple_choice",
+    "question": "ChatPromptTemplate에서 대화 히스토리 메시지 배열을 주입하는 방법은?",
+    "options": [
+      "(\"placeholder\", \"{chat_history}\") 또는 MessagesPlaceholder(variable_name=\"chat_history\")를 messages에 추가한다",
+      "chat_history 문자열을 system 메시지에 직접 포함한다",
+      "히스토리는 LLM이 자동으로 관리하므로 별도 처리가 불필요하다",
+      "HistoryTemplate 클래스를 별도로 사용한다"
+    ],
+    "answer": "(\"placeholder\", \"{chat_history}\") 또는 MessagesPlaceholder(variable_name=\"chat_history\")를 messages에 추가한다",
+    "explanation": "`MessagesPlaceholder`는 메시지 리스트 전체를 그 자리에 펼쳐줍니다. RunnableWithMessageHistory의 `history_messages_key`와 placeholder의 변수명이 일치해야 합니다.",
+    "source_id": "official-docs-langchain"
+  },
+  {
+    "id": "docs-q43",
+    "lesson_id": "docs-conversation-memory",
+    "question_type": "multiple_choice",
+    "question": "LangChain에서 멀티턴 대화 히스토리를 체인에 자동으로 주입하는 클래스는?",
+    "options": [
+      "RunnableWithMessageHistory",
+      "ConversationChain",
+      "ChatMemoryBuffer",
+      "HistoryRunnable"
+    ],
+    "answer": "RunnableWithMessageHistory",
+    "explanation": "`RunnableWithMessageHistory`는 기존 체인을 감싸 `session_id`별로 히스토리를 관리합니다. `get_session_history` 함수로 저장소를 지정하면 자동으로 이전 대화가 주입됩니다.",
+    "source_id": "official-docs-langchain"
+  },
+  {
+    "id": "docs-q44",
+    "lesson_id": "docs-conversation-memory",
+    "question_type": "multiple_choice",
+    "question": "RunnableWithMessageHistory에서 모든 사용자가 동일한 대화 히스토리를 공유하는 원인은?",
+    "options": [
+      "invoke 시 config에 동일한 session_id를 사용했다",
+      "ChatMessageHistory를 클래스 레벨에서 하나만 생성했다",
+      "get_session_history 함수를 정의하지 않았다",
+      "RunnableWithMessageHistory 대신 체인을 직접 사용했다"
+    ],
+    "answer": "invoke 시 config에 동일한 session_id를 사용했다",
+    "explanation": "`config={\"configurable\": {\"session_id\": \"fixed-id\"}}`처럼 고정 ID를 쓰면 모든 사용자가 같은 히스토리를 씁니다. 사용자별로 고유한 session_id(UUID 등)를 생성해야 합니다.",
+    "source_id": "official-docs-langchain"
+  },
+  {
+    "id": "docs-q38",
+    "lesson_id": "docs-mcp",
+    "question_type": "multiple_choice",
+    "question": "Claude Desktop에 로컬 MCP 서버를 연결하려면 어디에 등록해야 하는가?",
+    "options": [
+      "~/Library/Application Support/Claude/claude_desktop_config.json",
+      "~/.claude/mcp_servers.json",
+      "CLAUDE.md 파일",
+      "환경변수 MCP_SERVER_PATH"
+    ],
+    "answer": "~/Library/Application Support/Claude/claude_desktop_config.json",
+    "explanation": "Claude Desktop의 MCP 서버 목록은 `claude_desktop_config.json`에 등록합니다. 서버 이름, 실행 명령어(`command`), 인수(`args`)를 JSON으로 정의하면 앱 재시작 후 자동 연결됩니다.",
+    "source_id": "official-docs-mcp"
+  },
+  {
+    "id": "docs-q67",
+    "lesson_id": "docs-vectorstore",
+    "question_type": "multiple_choice",
+    "question": "**[상황 판단]** 서버를 재시작할 때마다 벡터 인덱스가 사라지는 문제가 발생했습니다. 개발팀에서 `save_local()` 호출을 종종 빠뜨립니다. 어떤 VectorStore를 선택하고 그 이유는?",
+    "options": [
+      "Chroma — persist_directory만 지정하면 save_local() 없이 자동 저장되므로",
+      "FAISS — 성능이 더 빠르고 클라우드 배포에 유리하므로",
+      "pgvector — PostgreSQL 기반이라 안정성이 높으므로",
+      "Qdrant — 대규모 벡터 검색에 최적화되어 있으므로"
+    ],
+    "answer": "Chroma — persist_directory만 지정하면 save_local() 없이 자동 저장되므로",
+    "explanation": "이 상황의 근본 문제는 수동 저장 호출을 빠뜨리는 것입니다. Chroma는 `persist_directory='./chroma_db'`만 지정하면 자동으로 저장되므로 실수 가능성이 없습니다. FAISS는 성능이 좋지만 `save_local()`을 반드시 호출해야 해 이 문제를 해결하지 못합니다.",
+    "source_id": "official-docs-chromadb",
+    "difficulty": "medium"
+  },
+  {
+    "id": "docs-q68",
+    "lesson_id": "docs-sentence-transformers",
+    "question_type": "multiple_choice",
+    "question": "**[상황 판단]** RAG 시스템에 20만 개의 문서를 인덱싱해야 합니다. OpenAI 임베딩 API를 쓰면 비용이 예상보다 10배 나올 것 같습니다. 어떤 선택이 가장 적합한가?",
+    "options": [
+      "sentence-transformers의 all-MiniLM-L6-v2로 로컬 임베딩 — 무료이고 인터페이스가 동일하므로",
+      "OpenAI 임베딩 유지 — 품질이 중요하므로 비용을 감수한다",
+      "임베딩을 사용하지 않고 키워드 검색만 쓴다",
+      "Chroma로 교체하면 임베딩 비용이 절감된다"
+    ],
+    "answer": "sentence-transformers의 all-MiniLM-L6-v2로 로컬 임베딩 — 무료이고 인터페이스가 동일하므로",
+    "explanation": "`HuggingFaceEmbeddings(model_name='sentence-transformers/all-MiniLM-L6-v2')`는 OpenAI Embeddings와 인터페이스가 동일해 코드를 한 줄만 바꾸면 됩니다. 로컬 실행이므로 API 비용이 없고, 대용량 인덱싱에 경제적입니다. 한국어 많으면 `jhgan/ko-sroberta-multitask`도 고려합니다.",
+    "source_id": "official-docs-huggingface",
+    "difficulty": "medium"
+  },
+  {
+    "id": "docs-q69",
+    "lesson_id": "docs-summarization",
+    "question_type": "multiple_choice",
+    "question": "**[상황 판단]** 뉴스 기사 50개를 동시에 LLM에 넣어 요약하려다 토큰 초과 오류가 났습니다. 가장 적절한 해결 방법은?",
+    "options": [
+      "load_summarize_chain(llm, chain_type='map_reduce') 사용 — 기사를 개별 요약 후 합치므로 토큰 초과가 없음",
+      "모든 기사를 하나의 프롬프트에 넣는 stuff 방식을 유지하되 LLM 모델을 교체",
+      "기사 개수를 5개로 줄여 stuff 방식 유지",
+      "summarization 대신 RAG로 기사를 검색해 요약"
+    ],
+    "answer": "load_summarize_chain(llm, chain_type='map_reduce') 사용 — 기사를 개별 요약 후 합치므로 토큰 초과가 없음",
+    "explanation": "`map_reduce`는 각 기사를 독립적으로 요약(map)한 뒤 개별 요약들을 합쳐 최종 요약(reduce)을 만듭니다. 기사가 100개든 1000개든 토큰 초과가 발생하지 않습니다. 모델 교체나 기사 수 감소는 근본 해결책이 아닙니다.",
+    "source_id": "official-docs-langchain",
+    "difficulty": "medium"
+  },
+  {
+    "id": "docs-q70",
+    "lesson_id": "docs-langsmith",
+    "question_type": "multiple_choice",
+    "question": "**[상황 판단]** RAG 챗봇이 엉뚱한 답을 했습니다. 문제가 검색 단계인지, 프롬프트 렌더링 단계인지, LLM 생성 단계인지 파악이 안 됩니다. `print()`로 디버깅 중인데 어느 단계인지 구분이 어렵습니다. 가장 효과적인 도구는?",
+    "options": [
+      "LangSmith — 체인 각 단계의 입출력을 트리 형태로 시각화하므로",
+      "Python logging 모듈로 더 상세한 로그 출력",
+      "LLM 모델을 더 강력한 것으로 교체",
+      "chunk_size를 줄여 검색 정확도 향상"
+    ],
+    "answer": "LangSmith — 체인 각 단계의 입출력을 트리 형태로 시각화하므로",
+    "explanation": "LangSmith는 환경변수 3개(`LANGCHAIN_TRACING_V2=true`, `LANGCHAIN_API_KEY`, `LANGCHAIN_PROJECT`) 설정만으로 체인 실행마다 retriever 입출력, 렌더링된 프롬프트, LLM 응답을 단계별로 기록합니다. 어느 단계가 문제인지 즉시 특정할 수 있습니다.",
+    "source_id": "official-docs-langchain",
+    "difficulty": "medium"
+  },
+  {
+    "id": "docs-q71",
+    "lesson_id": "docs-guardrails",
+    "question_type": "multiple_choice",
+    "question": "**[상황 판단]** 서비스 사용자가 \"욕설을 섞어 요약해줘\"라고 입력했더니 LLM이 그대로 따랐습니다. 시스템 프롬프트에 '욕설 금지'를 추가했지만 우회되는 경우가 있습니다. 더 강력한 대응은?",
+    "options": [
+      "Guardrails AI의 ToxicLanguage Guard를 LLM 출력에 적용 — 확률적으로 유해 콘텐츠를 실질적으로 차단",
+      "시스템 프롬프트를 더 길고 자세하게 작성",
+      "더 강력한 LLM 모델로 교체",
+      "사용자 입력 길이를 100자로 제한"
+    ],
+    "answer": "Guardrails AI의 ToxicLanguage Guard를 LLM 출력에 적용 — 확률적으로 유해 콘텐츠를 실질적으로 차단",
+    "explanation": "시스템 프롬프트는 프롬프트 인젝션으로 우회될 수 있습니다. Guardrails AI는 LLM 출력을 별도 분류 모델로 검증해 임계값 이상이면 예외를 발생시킵니다. `on_fail='reask'`로 설정하면 자동으로 재작성을 요청합니다. 시스템 프롬프트보다 실질적인 보호 수단입니다.",
+    "source_id": "official-docs-guardrails",
+    "difficulty": "hard"
+  },
+  {
+    "id": "docs-q72",
+    "lesson_id": "docs-redis",
+    "question_type": "multiple_choice",
+    "question": "**[상황 판단]** 챗봇 서비스를 배포했더니 서버를 재시작할 때마다 모든 사용자의 대화 기록이 초기화됩니다. 인메모리 딕셔너리로 히스토리를 관리하고 있습니다. 최소한의 코드 변경으로 해결하는 방법은?",
+    "options": [
+      "get_session_history 함수 내부를 RedisChatMessageHistory로 교체 — 나머지 코드는 그대로",
+      "RunnableWithMessageHistory를 제거하고 매 요청마다 히스토리를 DB에 직접 저장",
+      "Streamlit session_state에 히스토리를 저장",
+      "대화 히스토리 없이 단일 턴으로 서비스를 재설계"
+    ],
+    "answer": "get_session_history 함수 내부를 RedisChatMessageHistory로 교체 — 나머지 코드는 그대로",
+    "explanation": "`RunnableWithMessageHistory`는 `get_session_history` 함수만 보고 히스토리를 관리합니다. 이 함수 내부를 `RedisChatMessageHistory(session_id, url='redis://localhost:6379')`로 바꾸기만 하면 됩니다. 다른 코드는 전혀 수정할 필요가 없습니다.",
+    "source_id": "official-docs-redis",
+    "difficulty": "hard"
+  },
+  {
+    "id": "docs-q73",
+    "lesson_id": "docs-litellm",
+    "question_type": "multiple_choice",
+    "question": "**[상황 판단]** 로컬 Ollama로 개발하고 프로덕션에는 Anthropic Claude를 쓸 계획입니다. 매번 LLM 교체 시 코드를 최소로 수정하려면 어떻게 구현해야 하는가?",
+    "options": [
+      "LiteLLM completion()을 사용하고 model 파라미터만 변경 — 코드 나머지는 그대로",
+      "OllamaLLM과 ChatAnthropic을 if문으로 분기",
+      "개발/프로덕션마다 다른 코드베이스를 유지",
+      "LangChain의 ChatOpenAI를 기본으로 Ollama는 별도 브랜치에서 관리"
+    ],
+    "answer": "LiteLLM completion()을 사용하고 model 파라미터만 변경 — 코드 나머지는 그대로",
+    "explanation": "LiteLLM은 `completion(model='ollama/llama3.2', ...)`과 `completion(model='anthropic/claude-3-5-sonnet-20241022', ...)`의 코드가 동일합니다. model 파라미터 한 줄만 바꾸면 프로바이더를 전환합니다. if문 분기나 별도 브랜치 관리는 유지보수 비용이 높습니다.",
+    "source_id": "official-docs-litellm",
+    "difficulty": "medium"
+  },
+  {
+    "id": "docs-q74",
+    "lesson_id": "docs-langgraph",
+    "question_type": "multiple_choice",
+    "question": "**[상황 판단]** RAG 챗봇에 다음 기능을 추가해야 합니다: \"검색 결과 품질이 낮으면 다른 검색어로 재시도하고, 3번 이상 실패하면 '찾지 못했습니다'를 반환.\" LCEL 체인만으로 이 기능을 구현할 수 있는가?",
+    "options": [
+      "불가능 — LCEL은 선형이라 루프와 조건 분기가 없다. LangGraph를 써야 한다",
+      "가능 — LCEL의 RunnableBranch로 조건 분기를 구현할 수 있다",
+      "가능 — Python while문을 chain.invoke() 바깥에 쓰면 된다",
+      "가능 — retry 파라미터를 chain에 전달하면 된다"
+    ],
+    "answer": "불가능 — LCEL은 선형이라 루프와 조건 분기가 없다. LangGraph를 써야 한다",
+    "explanation": "LCEL은 A→B→C 선형 파이프라인입니다. '품질 판단 → 재시도 여부 결정 → 루프' 같은 반복/분기 로직은 표현할 수 없습니다. LangGraph의 `add_conditional_edges`와 루프 구조가 이런 에이전트 행동 패턴에 적합합니다.",
+    "source_id": "official-docs-langgraph",
+    "difficulty": "hard"
+  },
+  {
+    "id": "docs-q75",
+    "lesson_id": "docs-airflow",
+    "question_type": "multiple_choice",
+    "question": "**[상황 판단]** 뉴스 요약 스크립트를 완성했습니다. 매일 오전 6시에 자동으로 실행되고 실패 시 알림을 받고 싶습니다. 담당자 없이도 주말에 동작해야 합니다. 가장 적합한 도구는?",
+    "options": [
+      "Airflow — DAG로 스케줄 정의, 실패 알림, 이전 실행 이력 관리가 가능",
+      "cron 스크립트 — 가장 단순하고 추가 설치가 없음",
+      "Streamlit 버튼 — 수동 실행이지만 UI가 있음",
+      "GitHub Actions — CI/CD 환경에서 실행 가능"
+    ],
+    "answer": "Airflow — DAG로 스케줄 정의, 실패 알림, 이전 실행 이력 관리가 가능",
+    "explanation": "단순 cron도 스케줄링은 되지만 실패 시 알림, 이전 실행 이력 확인, 재실행 기능이 없습니다. Airflow는 `@daily` 스케줄로 자동 실행되고, 실패 시 이메일/Slack 알림, 과거 실행 이력 조회, 수동 재실행이 모두 지원됩니다. 담당자 없이 운영하는 프로덕션 파이프라인에 적합합니다.",
+    "source_id": "official-docs-airflow",
+    "difficulty": "medium"
+  },
+  {
+    "id": "docs-q76",
+    "lesson_id": "docs-fastapi",
+    "question_type": "multiple_choice",
+    "question": "**[상황 판단]** RAG 챗봇을 완성했습니다. 프론트엔드 팀(React), 모바일 팀(Flutter), 데이터 팀(Python)이 모두 이 기능을 사용해야 합니다. Streamlit 앱 그대로 배포하는 것이 좋을까요?",
+    "options": [
+      "아니오 — FastAPI로 REST API를 만들어 공유하는 것이 적합. 각 팀이 자기 방식으로 연결 가능",
+      "예 — Streamlit UI를 iframe으로 각 팀 서비스에 삽입하면 됨",
+      "예 — Streamlit은 API 기능도 자동으로 제공함",
+      "아니오 — Gradio로 교체해야 다른 팀과 공유 가능"
+    ],
+    "answer": "아니오 — FastAPI로 REST API를 만들어 공유하는 것이 적합. 각 팀이 자기 방식으로 연결 가능",
+    "explanation": "Streamlit은 UI와 로직이 결합된 단일 앱입니다. 다른 팀이 LLM 기능을 재사용하려면 API가 필요합니다. FastAPI로 `POST /ask` 엔드포인트를 만들면 React, Flutter, Python 어디서든 HTTP 요청으로 접근할 수 있습니다. Streamlit은 개인/팀 내부 도구, FastAPI는 서비스 통합에 적합합니다.",
+    "source_id": "official-docs-fastapi",
+    "difficulty": "medium"
+  }
+]

cert_study_app/services/docs_source_service.py

@@ -0,0 +1,395 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterable
+
+
+@dataclass(frozen=True)
+class DocsSource:
+    id: str
+    track: str
+    provider: str
+    title: str
+    url: str
+    category: str
+    tags: tuple[str, ...] = ()
+    role: str = "reference"
+    enabled: bool = True
+
+
+DOCS_SOURCES: tuple[DocsSource, ...] = (
+    DocsSource(
+        "manual-az104-basic",
+        "azure",
+        "Microsoft Learn",
+        "AZ-104 study guide",
+        "https://learn.microsoft.com/en-us/credentials/certifications/resources/study-guides/az-104",
+        "exam-guide",
+        ("az-104", "study-guide"),
+    ),
+    DocsSource(
+        "azure-vnet-overview",
+        "azure",
+        "Microsoft Learn",
+        "Azure Virtual Network overview",
+        "https://learn.microsoft.com/en-us/azure/virtual-network/virtual-networks-overview",
+        "network",
+        ("vnet", "subnet", "networking"),
+    ),
+    DocsSource(
+        "azure-nsg-overview",
+        "azure",
+        "Microsoft Learn",
+        "Network security groups",
+        "https://learn.microsoft.com/en-us/azure/virtual-network/network-security-groups-overview",
+        "network",
+        ("nsg", "security"),
+    ),
+    DocsSource(
+        "azure-private-endpoint",
+        "azure",
+        "Microsoft Learn",
+        "Private Endpoint overview",
+        "https://learn.microsoft.com/en-us/azure/private-link/private-endpoint-overview",
+        "network",
+        ("private-link", "private-endpoint"),
+    ),
+    DocsSource(
+        "azure-load-balancer",
+        "azure",
+        "Microsoft Learn",
+        "Azure Load Balancer overview",
+        "https://learn.microsoft.com/en-us/azure/load-balancer/load-balancer-overview",
+        "network",
+        ("load-balancer",),
+    ),
+    DocsSource(
+        "azure-vm-overview",
+        "azure",
+        "Microsoft Learn",
+        "Azure Virtual Machines overview",
+        "https://learn.microsoft.com/en-us/azure/virtual-machines/overview",
+        "compute",
+        ("vm", "compute"),
+    ),
+    DocsSource(
+        "azure-storage-account",
+        "azure",
+        "Microsoft Learn",
+        "Storage account overview",
+        "https://learn.microsoft.com/en-us/azure/storage/common/storage-account-overview",
+        "storage",
+        ("storage-account", "blob"),
+    ),
+    DocsSource(
+        "azure-rbac-overview",
+        "azure",
+        "Microsoft Learn",
+        "Azure RBAC overview",
+        "https://learn.microsoft.com/en-us/azure/role-based-access-control/overview",
+        "identity",
+        ("rbac", "role"),
+    ),
+    DocsSource(
+        "azure-monitor-overview",
+        "azure",
+        "Microsoft Learn",
+        "Azure Monitor overview",
+        "https://learn.microsoft.com/en-us/azure/azure-monitor/overview",
+        "monitor",
+        ("monitor", "log-analytics"),
+    ),
+    DocsSource(
+        "azure-backup-overview",
+        "azure",
+        "Microsoft Learn",
+        "Azure Backup overview",
+        "https://learn.microsoft.com/en-us/azure/backup/backup-overview",
+        "backup",
+        ("backup", "recovery"),
+    ),
+    DocsSource(
+        "azure-policy-overview",
+        "azure",
+        "Microsoft Learn",
+        "Azure Policy overview",
+        "https://learn.microsoft.com/en-us/azure/governance/policy/overview",
+        "governance",
+        ("policy", "initiative", "compliance"),
+    ),
+    DocsSource(
+        "azure-app-gateway-overview",
+        "azure",
+        "Microsoft Learn",
+        "Application Gateway overview",
+        "https://learn.microsoft.com/en-us/azure/application-gateway/overview",
+        "network",
+        ("application-gateway", "waf", "layer-7"),
+    ),
+    DocsSource(
+        "azure-dns-overview",
+        "azure",
+        "Microsoft Learn",
+        "Azure DNS overview",
+        "https://learn.microsoft.com/en-us/azure/dns/dns-overview",
+        "network",
+        ("dns", "private-dns", "resolver"),
+    ),
+    DocsSource(
+        "azure-blob-access-tiers",
+        "azure",
+        "Microsoft Learn",
+        "Blob access tiers",
+        "https://learn.microsoft.com/en-us/azure/storage/blobs/access-tiers-overview",
+        "storage",
+        ("blob", "hot", "cool", "archive"),
+    ),
+    DocsSource(
+        "azure-vmss-overview",
+        "azure",
+        "Microsoft Learn",
+        "Virtual Machine Scale Sets overview",
+        "https://learn.microsoft.com/en-us/azure/virtual-machine-scale-sets/overview",
+        "compute",
+        ("vmss", "autoscale", "availability"),
+    ),
+    DocsSource(
+        "azure-log-analytics-overview",
+        "azure",
+        "Microsoft Learn",
+        "Log Analytics overview",
+        "https://learn.microsoft.com/en-us/azure/azure-monitor/logs/log-analytics-overview",
+        "monitor",
+        ("log-analytics", "kql", "monitor"),
+    ),
+    DocsSource(
+        "azure-recovery-services-vault",
+        "azure",
+        "Microsoft Learn",
+        "Recovery Services vault overview",
+        "https://learn.microsoft.com/en-us/azure/backup/backup-azure-recovery-services-vault-overview",
+        "backup",
+        ("recovery-services-vault", "backup-policy"),
+    ),
+    DocsSource(
+        "azure-bastion-overview",
+        "azure",
+        "Microsoft Learn",
+        "Azure Bastion overview",
+        "https://learn.microsoft.com/en-us/azure/bastion/bastion-overview",
+        "network",
+        ("bastion", "ssh", "rdp"),
+    ),
+    DocsSource(
+        "azure-nat-gateway",
+        "azure",
+        "Microsoft Learn",
+        "Azure NAT Gateway overview",
+        "https://learn.microsoft.com/en-us/azure/nat-gateway/nat-overview",
+        "network",
+        ("nat-gateway", "outbound"),
+    ),
+    DocsSource(
+        "azure-app-service-overview",
+        "azure",
+        "Microsoft Learn",
+        "App Service overview",
+        "https://learn.microsoft.com/en-us/azure/app-service/overview",
+        "compute",
+        ("app-service", "web-app"),
+    ),
+    DocsSource(
+        "azure-container-instances",
+        "azure",
+        "Microsoft Learn",
+        "Azure Container Instances overview",
+        "https://learn.microsoft.com/en-us/azure/container-instances/container-instances-overview",
+        "compute",
+        ("aci", "container"),
+    ),
+    DocsSource(
+        "azure-key-vault-overview",
+        "azure",
+        "Microsoft Learn",
+        "Azure Key Vault overview",
+        "https://learn.microsoft.com/en-us/azure/key-vault/general/overview",
+        "security",
+        ("key-vault", "secret", "key"),
+    ),
+    DocsSource(
+        "manual-linux-basic",
+        "linux",
+        "GNU Coreutils Manual",
+        "GNU Coreutils basic operations",
+        "https://www.gnu.org/software/coreutils/manual/coreutils.html",
+        "essential-commands",
+        ("pwd", "ls", "mkdir", "touch", "chmod"),
+        "command-reference",
+    ),
+    DocsSource(
+        "linux-bash-cd",
+        "linux",
+        "GNU Bash Manual",
+        "Bash builtins",
+        "https://www.gnu.org/software/bash/manual/html_node/Bourne-Shell-Builtins.html",
+        "shell",
+        ("cd", "shell-builtin"),
+        "command-reference",
+    ),
+    DocsSource(
+        "linux-grep-manual",
+        "linux",
+        "GNU Grep Manual",
+        "GNU Grep manual",
+        "https://www.gnu.org/software/grep/manual/grep.html",
+        "text-processing",
+        ("grep", "search"),
+        "command-reference",
+    ),
+    DocsSource(
+        "linux-systemd-systemctl",
+        "linux",
+        "freedesktop.org",
+        "systemctl manual",
+        "https://www.freedesktop.org/software/systemd/man/latest/systemctl.html",
+        "services",
+        ("systemctl", "service"),
+        "command-reference",
+    ),
+    DocsSource(
+        "linux-man7-ip",
+        "linux",
+        "man7.org",
+        "ip command manual",
+        "https://man7.org/linux/man-pages/man8/ip.8.html",
+        "networking",
+        ("ip", "networking"),
+        "command-reference",
+    ),
+    DocsSource(
+        "ubuntu-server-docs",
+        "linux",
+        "Ubuntu Server Docs",
+        "Ubuntu Server documentation",
+        "https://ubuntu.com/server/docs/",
+        "server-operations",
+        ("ubuntu", "server", "operations"),
+        "practice-guide",
+    ),
+    DocsSource(
+        "ubuntu-package-management",
+        "linux",
+        "Ubuntu Server Docs",
+        "Install and manage packages",
+        "https://ubuntu.com/server/docs/how-to/software/package-management/",
+        "package-management",
+        ("apt", "package", "software"),
+        "practice-guide",
+    ),
+    DocsSource(
+        "ubuntu-user-management",
+        "linux",
+        "Ubuntu Server Docs",
+        "User management",
+        "https://ubuntu.com/server/docs/how-to/security/user-management/",
+        "users-groups",
+        ("user", "group", "sudo"),
+        "practice-guide",
+    ),
+    DocsSource(
+        "ubuntu-networking",
+        "linux",
+        "Ubuntu Server Docs",
+        "Networking",
+        "https://ubuntu.com/server/docs/how-to/networking/",
+        "networking",
+        ("netplan", "dns", "network-tools"),
+        "practice-guide",
+    ),
+    DocsSource(
+        "ubuntu-firewall",
+        "linux",
+        "Ubuntu Server Docs",
+        "Firewall",
+        "https://ubuntu.com/server/docs/how-to/security/firewalls/",
+        "security",
+        ("ufw", "firewall", "port"),
+        "practice-guide",
+    ),
+    DocsSource(
+        "ubuntu-storage",
+        "linux",
+        "Ubuntu Server Docs",
+        "Storage",
+        "https://ubuntu.com/server/docs/how-to/storage/",
+        "storage",
+        ("lvm", "storage", "iscsi"),
+        "practice-guide",
+    ),
+    DocsSource(
+        "official-docs-ollama",
+        "tool_docs",
+        "Ollama Docs",
+        "Ollama documentation",
+        "https://docs.ollama.com/",
+        "ollama",
+        ("ollama", "local-model"),
+    ),
+    DocsSource(
+        "official-docs-langchain",
+        "tool_docs",
+        "LangChain Docs",
+        "LangChain documentation",
+        "https://python.langchain.com/docs/",
+        "langchain",
+        ("langchain", "rag"),
+    ),
+    DocsSource(
+        "official-docs-streamlit",
+        "tool_docs",
+        "Streamlit Docs",
+        "Streamlit documentation",
+        "https://docs.streamlit.io/",
+        "streamlit",
+        ("streamlit", "session-state"),
+    ),
+    DocsSource(
+        "official-docs-huggingface",
+        "tool_docs",
+        "Hugging Face Docs",
+        "Hugging Face documentation",
+        "https://huggingface.co/docs",
+        "huggingface",
+        ("huggingface", "spaces"),
+    ),
+)
+
+
+def active_docs_sources(track_id: str | None = None) -> list[DocsSource]:
+    sources = [source for source in DOCS_SOURCES if source.enabled]
+    if track_id and track_id != "all":
+        sources = [source for source in sources if source.track == track_id]
+    return sources
+
+
+def doc_source_by_id(source_id: str | None) -> DocsSource | None:
+    if not source_id:
+        return None
+    return next((source for source in DOCS_SOURCES if source.id == source_id), None)
+
+
+def doc_source_urls(track_id: str | None = None) -> list[str]:
+    return [source.url for source in active_docs_sources(track_id)]
+
+
+def docs_source_options() -> list[tuple[str, str]]:
+    return [
+        ("all", "전체 Docs"),
+        ("azure", "Azure Docs"),
+        ("linux", "Linux Docs"),
+        ("tool_docs", "Tool Docs"),
+    ]
+
+
+def urls_from_sources(sources: Iterable[DocsSource]) -> list[str]:
+    return [source.url for source in sources]

cert_study_app/services/official_docs_service.py

@@ -0,0 +1,210 @@
+from __future__ import annotations
+
+import hashlib
+import re
+from datetime import datetime
+from html.parser import HTMLParser
+from typing import Optional
+
+import requests
+
+from cert_study_app.models import AzureDocsSync
+from cert_study_app.services.docs_source_service import DocsSource, active_docs_sources
+from cert_study_app.services.vector_service import DEFAULT_EMBEDDING_MODEL, QuestionVectorStore
+
+
+OFFICIAL_DOC_URLS = [source.url for source in active_docs_sources()]
+OFFICIAL_DOCS_COLLECTION = "official_docs"
+LEGACY_AZURE_DOCS_COLLECTION = "azure_docs"
+
+
+class _MainTextParser(HTMLParser):
+    def __init__(self):
+        super().__init__()
+        self.title = ""
+        self._in_title = False
+        self._skip_depth = 0
+        self._chunks: list[str] = []
+
+    def handle_starttag(self, tag, attrs):
+        if tag == "title":
+            self._in_title = True
+        if tag in {"script", "style", "noscript", "svg"}:
+            self._skip_depth += 1
+        if tag in {"p", "li", "h1", "h2", "h3", "h4", "td", "th"}:
+            self._chunks.append("\n")
+
+    def handle_endtag(self, tag):
+        if tag == "title":
+            self._in_title = False
+        if tag in {"script", "style", "noscript", "svg"} and self._skip_depth:
+            self._skip_depth -= 1
+        if tag in {"p", "li", "h1", "h2", "h3", "h4", "tr"}:
+            self._chunks.append("\n")
+
+    def handle_data(self, data):
+        text = re.sub(r"\s+", " ", data or "").strip()
+        if not text:
+            return
+        if self._in_title and not self.title:
+            self.title = text
+        if not self._skip_depth:
+            self._chunks.append(text)
+
+    def text(self) -> str:
+        text = " ".join(self._chunks)
+        text = re.sub(r"\s*\n\s*", "\n", text)
+        text = re.sub(r"[ \t]{2,}", " ", text)
+        return text.strip()
+
+
+def _chunk_text(text: str, chunk_size: int = 1400, overlap: int = 180) -> list[str]:
+    clean = re.sub(r"\n{3,}", "\n\n", text or "").strip()
+    if not clean:
+        return []
+    chunks = []
+    start = 0
+    while start < len(clean):
+        end = min(len(clean), start + chunk_size)
+        chunk = clean[start:end].strip()
+        if chunk:
+            chunks.append(chunk)
+        if end >= len(clean):
+            break
+        start = max(0, end - overlap)
+    return chunks
+
+
+def _doc_id(url: str, index: int, text: str) -> str:
+    digest = hashlib.sha1(f"{url}|{index}|{text}".encode("utf-8")).hexdigest()[:16]
+    return f"official_docs:{digest}"
+
+
+def _category_from_url(url: str) -> str:
+    if "virtual-network" in url or "private-link" in url or "load-balancer" in url or "application-gateway" in url:
+        return "network"
+    if "virtual-machines" in url or "app-service" in url or "container-instances" in url:
+        return "compute"
+    if "storage" in url:
+        return "storage"
+    if "role-based-access-control" in url or "entra" in url or "key-vault" in url:
+        return "identity"
+    if "monitor" in url:
+        return "monitor"
+    if "backup" in url:
+        return "backup"
+    return "docs"
+
+
+class OfficialDocsService:
+    def __init__(
+        self,
+        db,
+        embedding_model: Optional[str] = None,
+        urls: Optional[list[str]] = None,
+        track_id: str | None = None,
+        sources: Optional[list[DocsSource]] = None,
+        collection_name: str = OFFICIAL_DOCS_COLLECTION,
+    ):
+        self.db = db
+        self.embedding_model = embedding_model or DEFAULT_EMBEDDING_MODEL
+        if sources is not None:
+            self.sources = sources
+        elif urls:
+            self.sources = self._sources_from_urls(urls)
+        else:
+            self.sources = active_docs_sources(track_id)
+        self.vector_store = QuestionVectorStore(
+            collection_name=collection_name,
+            embedding_model=self.embedding_model,
+        )
+
+    @staticmethod
+    def _sources_from_urls(urls: Optional[list[str]]) -> list[DocsSource]:
+        return [
+            DocsSource(
+                id=f"custom-doc-{index}",
+                track="custom",
+                provider="Custom Docs",
+                title=url.rsplit("/", 1)[-1] or url,
+                url=url,
+                category="custom",
+            )
+            for index, url in enumerate(urls or [], 1)
+        ]
+
+    def latest_sync(self) -> AzureDocsSync | None:
+        return self.db.query(AzureDocsSync).order_by(AzureDocsSync.id.desc()).first()
+
+    def sync(self, limit: Optional[int] = None) -> dict:
+        sync = AzureDocsSync(
+            embedding_model=self.embedding_model,
+            status="running",
+            message="공식 Docs 동기화를 시작했습니다.",
+            started_at=datetime.utcnow(),
+        )
+        self.db.add(sync)
+        self.db.commit()
+
+        sources = self.sources[: int(limit)] if limit else self.sources
+        checked = 0
+        docs_indexed = 0
+        chunks_indexed = 0
+        try:
+            for source in sources:
+                checked += 1
+                response = requests.get(source.url, timeout=20, headers={"User-Agent": "cert-study-app/1.0"})
+                response.raise_for_status()
+                parser = _MainTextParser()
+                parser.feed(response.text)
+                title = parser.title or source.title or source.url.rsplit("/", 1)[-1]
+                chunks = _chunk_text(parser.text())
+                payloads = [
+                    {
+                        "id": _doc_id(source.url, index, chunk),
+                        "text": f"Title: {title}\nURL: {source.url}\n\n{chunk}",
+                        "source_type": f"{source.track}_docs",
+                        "source": source.provider,
+                        "source_id": source.id,
+                        "track": source.track,
+                        "role": source.role,
+                        "title": title,
+                        "url": source.url,
+                        "category": source.category or _category_from_url(source.url),
+                    }
+                    for index, chunk in enumerate(chunks, 1)
+                ]
+                inserted = self.vector_store.upsert_documents(payloads)
+                if inserted:
+                    docs_indexed += 1
+                    chunks_indexed += inserted
+
+            sync.status = "success"
+            sync.message = f"{docs_indexed}개 문서, {chunks_indexed}개 chunk를 색인했습니다."
+        except Exception as exc:
+            sync.status = "failed"
+            sync.error_message = str(exc)[:1000]
+            sync.message = "공식 Docs 동기화 실패"
+        finally:
+            sync.urls_checked = checked
+            sync.documents_indexed = docs_indexed
+            sync.chunks_indexed = chunks_indexed
+            sync.completed_at = datetime.utcnow()
+            self.db.commit()
+
+        return {
+            "status": sync.status,
+            "urls_checked": checked,
+            "documents_indexed": docs_indexed,
+            "chunks_indexed": chunks_indexed,
+            "message": sync.message,
+            "error_message": sync.error_message,
+        }
+
+
+class AzureDocsService(OfficialDocsService):
+    """Backward-compatible alias for older imports."""
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("track_id", "azure")
+        super().__init__(*args, **kwargs)