Seum.Lee Story

OS 시스템 기초 핵심 개념

Seum Lee — Mon, 25 May 2026 22:56:23 +0900

1. 운영체제

운영체제란 무엇인가

운영체제(OS)는 컴퓨터 하드웨어와 사용자(혹은 애플리케이션) 사이에서 중재자 역할을 하는 소프트웨어의 집합이다. CPU, 메모리, 디스크, 네트워크 장치 등 한정된 자원을 여러 프로그램이 동시에 사용할 때 충돌 없이 배분해 주는 것이 핵심 임무다.

운영체제의 설계 목표는 네 가지로 요약된다.

처리 능력(Throughput) 향상 : 단위 시간당 처리하는 작업량을 늘린다.
반환 시간(Turnaround Time) 감소 : 작업 제출부터 완료까지 걸리는 시간을 줄인다.
사용 가능도(Availability) 향상 : 시스템이 즉시 사용 가능한 상태를 오래 유지한다.
신뢰도(Reliability) 향상 : 오류 없이 정확하게 작동한다.

실무에서는 "고가용성(HA)" 설계라는 말을 자주 듣는데, 이것이 바로 사용 가능도와 신뢰도를 동시에 높이는 아키텍처 전략이다.

UNIX와 LINUX

UNIX

1960년대 AT&T 벨 연구소에서 개발된 UNIX는 현대 OS 설계의 원형이다. 대부분 C언어로 작성되어 이식성이 높고, 파일 시스템은 루트(/)를 최상위로 하는 트리 구조를 따른다. 시분할 시스템(Time Sharing System) 방식으로 여러 사용자가 CPU를 번갈아 사용할 수 있게 했다.

구조는 두 층으로 나뉜다.

커널(Kernel) : 프로그램과 하드웨어 사이의 인터페이스를 담당한다. 메모리 관리, 프로세스 스케줄링, 파일 시스템 접근 등 핵심 기능이 모두 여기에 있다.
쉘(Shell) : 사용자와 시스템 사이의 인터페이스다. 사용자가 입력한 명령을 해석해 커널에 전달한다.

LINUX

리누스 토발즈가 1991년 개발한 UNIX 계열 오픈소스 OS다. 서버, 클라우드, 임베디드 환경에서 사실상의 표준으로 쓰인다. 주요 명령어를 실무 맥락과 함께 정리하면 아래와 같다.

파일 조작

명령어	기능	실무 팁
`cat`	파일 내용 출력	짧은 설정 파일 확인 시 자주 쓴다
`cp`	파일 복사	`-r` 옵션으로 디렉토리째 복사
`mv`	파일 이동 / 이름 변경	이름 변경도 `mv`로 한다
`rm`	파일 삭제	`-rf`는 되돌릴 수 없으니 신중하게
`find`	파일 검색	`find / -name "*.log"` 형태로 사용

디렉토리 조작

명령어	기능
`ls`	파일 목록 표시
`mkdir`	디렉토리 생성
`rmdir`	빈 디렉토리 삭제
`cd`	디렉토리 이동
`pwd`	현재 경로 출력

프로세스 관련

명령어	기능
`ps`	실행 중인 프로세스 목록
`kill`	프로세스 종료
`fork`	새 프로세스 생성 (시스템 콜)

사용자 및 권한

명령어	기능
`who`	현재 접속 중인 사용자 목록
`chown`	파일 소유자와 그룹 변경
`chmod`	파일 보호 모드(권한) 설정

chmod 권한 체계

chmod는 파일에 대한 읽기(r), 쓰기(w), 실행(x) 권한을 사용자(user), 그룹(group), 기타(other) 세 대상에 대해 설정한다. 8진수 표기법을 사용하며, rwx를 이진수로 변환해 숫자로 표현한다.

r = 4 (100)
w = 2 (010)
x = 1 (001)

rwx = 4+2+1 = 7
rw- = 4+2+0 = 6
r-x = 4+0+1 = 5
r-- = 4+0+0 = 4

예시:

chmod 755 a.txt
# 사용자: rwx (7) = 읽기 + 쓰기 + 실행
# 그룹:   r-x (5) = 읽기 + 실행
# 기타:   r-x (5) = 읽기 + 실행

chmod 644 config.yaml
# 사용자: rw- (6) = 읽기 + 쓰기
# 그룹:   r-- (4) = 읽기만
# 기타:   r-- (4) = 읽기만

실무에서 chmod 777(모든 권한 개방)은 보안상 권장하지 않는다. 웹 서버 설정 파일이나 SSH 키 파일에는 소유자만 읽을 수 있는 600 또는 400이 일반적이다.

2. 기억장치

기억장치 관리 전략

프로그램을 주기억장치(RAM)에 올리는 과정은 세 가지 전략 결정을 포함한다.

반입 전략 : 언제 올릴까?

요구 반입 : 프로그램이나 데이터가 실제로 필요해질 때 적재한다. 수요 기반이라 메모리를 효율적으로 쓸 수 있다.
예상 반입 : 곧 필요할 것을 미리 예측해 올린다. 적중하면 빠르지만, 빗나가면 자원 낭비다.

배치 전략 : 어디에 올릴까?

빈 공간 중 어느 자리에 프로그램을 배치할지 결정한다.

전략	설명	특징
최초 적합(First Fit)	빈 공간 중 첫 번째에 배치	탐색이 빠르다
최적 적합(Best Fit)	단편화가 가장 작게 남는 곳	공간 낭비가 적다
최악 적합(Worst Fit)	단편화가 가장 많이 남는 곳	남은 공간이 커서 재활용 가능

단편화(Fragmentation) 란 메모리 공간이 조각조각 나뉘어 실제로는 충분한 공간이 있지만 연속된 빈 공간이 없어 할당이 안 되는 현상이다.

주기억장치 할당 기법

연속 할당

단일 분할 할당 은 한 번에 한 명의 사용자만 메모리 사용자 영역을 사용하는 방식이다. 단순하지만 멀티태스킹이 안 된다.

오버레이 기법 : 실행할 프로그램이 주기억장치보다 클 때, 프로그램을 여러 조각으로 나눠 필요한 부분만 순서대로 올려서 실행한다. 현재는 가상 메모리가 이 역할을 대체한다.
스와핑 기법 : 실행 중인 프로그램 전체를 디스크로 잠시 내려놓고(swap out), 다른 프로그램을 올린다(swap in). 문맥 교환 비용이 크다.

다중 분할 할당 은 여러 프로그램을 동시에 메모리에 올리는 방식이다.

고정 분할(정적) : 메모리를 미리 고정된 크기로 나눠놓는다. 단순하지만 내부 단편화가 발생한다.
가변 분할(동적) : 프로그램 크기에 맞게 그때그때 영역을 나눈다. 고정 분할의 단편화 문제를 줄이기 위해 도입되었다.

가상기억장치

가상기억장치는 보조기억장치(디스크)의 일부를 주기억장치처럼 사용하는 기법이다. 실제 RAM이 부족해도 더 많은 프로그램을 동시에 실행할 수 있다. 현대 OS의 기본 메모리 관리 방식이다.

페이징 기법

프로그램과 메모리 영역을 동일한 크기의 단위로 자른다.

프로그램을 자른 단위 : 페이지(Page)
메모리를 자른 단위 : 페이지 프레임(Page Frame)

페이지 크기가 같으므로 외부 단편화가 없다. 다만 페이지 내 남는 공간(내부 단편화)은 여전히 발생할 수 있다.

페이지 부재(Page Fault)

CPU가 필요한 페이지가 현재 RAM에 없는 상황이다. 이때 디스크에서 해당 페이지를 가져와야 하는데, RAM이 꽉 차 있으면 기존 페이지 중 하나를 내보내야 한다. 어떤 페이지를 내보낼지 결정하는 것이 페이지 교체 알고리즘 이다.

페이지 교체 알고리즘 비교

알고리즘	기준	특징
OPT(최적 교체)	앞으로 가장 오래 쓰지 않을 페이지	이론적으로 최적이나, 미래를 알 수 없어 실제 구현 불가. 비교 기준으로 사용
FIFO	가장 먼저 들어온 페이지	구현이 단순. Belady의 역설(프레임 늘려도 폴트 증가) 발생 가능
LRU	가장 오랫동안 사용 안 된 페이지	실무에서 가장 많이 쓰이는 근사 알고리즘의 기준
LFU	사용 빈도가 가장 낮은 페이지	자주 쓰이지만 최근에는 안 쓰인 페이지를 보호하지 못함
NUR	최근에 사용하지 않은 페이지	참조 비트 + 변형 비트 사용. LRU 근사 구현
SCR(2차 기회)	오래됐지만 자주 쓰이는 페이지는 보호	FIFO의 단점을 보완

실제 Linux 커널은 LRU 기반의 변형 알고리즘을 사용하며, 활성 리스트와 비활성 리스트를 나눠 페이지를 관리한다.

지역성(Locality)

프로세스가 실행될 때 메모리 참조는 균일하게 분산되지 않는다. 특정 구역에 집중되는 경향이 있는데, 이것을 지역성이라 한다.

시간 지역성 : 최근에 접근한 데이터는 곧 다시 접근될 가능성이 높다. 반복문 안의 변수가 대표적인 예다.
공간 지역성 : 현재 접근한 주소 근처 데이터에도 곧 접근할 가능성이 높다. 배열 순차 접근이 대표 예다.

이 지역성 원리가 워킹 셋(Working Set) 이론의 기반이다. 워킹 셋은 프로세스가 일정 시간 동안 자주 참조하는 페이지들의 집합으로, 이 집합이 모두 RAM에 올라와 있을 때 페이지 폴트가 적게 발생한다.

세그멘테이션 기법

페이징이 고정 크기로 자른다면, 세그멘테이션은 논리적 의미 단위로 자른다. 코드 영역, 데이터 영역, 스택 영역처럼 프로그램의 논리 구조에 맞는 크기로 분할하며, 각 세그먼트는 고유한 이름과 크기를 가진다.

3. 프로세스

프로세스란

프로세스는 실행 중인 프로그램이다. 디스크에 저장된 실행 파일(프로그램)이 메모리에 올라와 CPU 시간을 할당받아 동작하는 순간부터 프로세스가 된다.

운영체제는 각 프로세스마다 PCB(Process Control Block) 를 만들어 관리한다. PCB에는 프로세스 상태, 고유 식별자(PID), CPU 레지스터 값, 메모리 정보, 입출력 상태, 계정 정보 등이 담긴다. 프로세스가 CPU를 내놓고 다시 받을 때 PCB에 저장된 정보를 복원해 이어서 실행한다.

프로세스 상태 전이

디스패치 : 준비 상태에서 실행 상태로 전이. 스케줄러가 CPU를 이 프로세스에 배정하는 행위다.
Wake Up : 대기 상태에서 준비 상태로 전이. I/O 완료 등의 이벤트가 발생하면 깨어난다.
스풀링(Spooling) : 출력이나 입력 데이터를 디스크에 임시로 저장해두는 기법. 프린터 큐가 대표적인 예다.

스레드

스레드는 프로세스 내의 실행 단위다. 하나의 프로세스 안에서 여러 스레드가 메모리 공간을 공유하면서 동시에 작업을 처리할 수 있다. 프로세스보다 생성과 전환 비용이 낮아 "경량 프로세스"라고도 부른다.

실무에서 웹 서버는 요청마다 스레드를 생성하거나(Thread per Request), 스레드 풀을 만들어 재사용하는 방식으로 동시 요청을 처리한다.

스래싱(Thrashing)

페이지 교체가 너무 자주 일어나 실제 작업보다 페이지를 올리고 내리는 데 더 많은 시간을 쓰는 현상이다. 메모리가 부족한 상태에서 프로세스를 너무 많이 올리면 발생한다. 워킹 셋 기반 관리로 완화할 수 있다.

프로세스 스케줄링

한정된 CPU를 여러 프로세스에 어떻게 배분할지 결정하는 것이 스케줄링이다. 크게 비선점과 선점 방식으로 나뉜다.

비선점 스케줄링

실행 중인 프로세스를 강제로 빼앗을 수 없다. 프로세스가 자발적으로 CPU를 내놓거나 작업을 마칠 때까지 기다린다.

FCFS(First Come First Served)
먼저 들어온 순서대로 처리한다. 구현이 간단하지만, 긴 작업이 앞에 있으면 짧은 작업이 오래 기다리는 호위 효과(Convoy Effect)가 발생한다.

SJF(Shortest Job First)
실행 시간이 짧은 프로세스를 먼저 처리한다. 평균 대기 시간이 최소화되지만, 긴 프로세스는 계속 밀릴 수 있다(기아 현상).

대기 시간 = 앞 프로세스의 반환 시간
반환 시간 = 대기 시간 + 실행 시간

HRN(Highest Response-Ratio Next)
SJF의 기아 현상을 보완하기 위해 우선순위를 동적으로 부여한다.

우선순위 = (대기 시간 + 서비스 시간) / 서비스 시간

오래 기다린 프로세스일수록 우선순위가 높아지므로, 기아 현상이 완화된다.

선점 스케줄링

실행 중인 프로세스에서 CPU를 강제로 빼앗아 다른 프로세스에 줄 수 있다. 반응성이 중요한 시스템(대화형, 실시간)에 적합하다.

Round Robin : 각 프로세스에 동일한 시간 할당량(Time Quantum)을 부여하고 순환한다.
SRT(Shortest Remaining Time) : SJF의 선점 버전. 현재 실행 중인 것보다 남은 시간이 짧은 프로세스가 오면 교체한다.
다단계 큐 : 프로세스를 여러 우선순위 큐로 분류해 관리한다.
다단계 피드백 큐 : 실행 시간에 따라 프로세스가 낮은 우선순위 큐로 이동하는 동적 방식이다.

4. 네트워크

IP 주소 체계

IPv4

32비트(8비트 × 4)로 구성된다. 192.168.1.100 같은 점-십진수 표기법을 쓴다. 약 43억 개의 주소를 가질 수 있는데, 인터넷 확산으로 고갈 문제가 발생했다.

클래스 구분:

클래스	첫 번째 옥텟 범위	용도
A	0~127	대규모 네트워크
B	128~191	중규모 네트워크
C	192~223	소규모 네트워크
D	224~239	멀티캐스트
E	240~255	실험용 예약

서브네팅

하나의 네트워크 주소를 여러 개의 작은 네트워크로 나누는 작업이다. IP 주소를 네트워크 부분과 호스트 부분으로 구분하는 비트 마스크가 서브넷 마스크 다.

예시: 192.168.1.0/24에서 /24는 앞 24비트가 네트워크 주소라는 의미다.

IP  주소: 192.168.1.100  → 11000000.10101000.00000001.01100100
서브넷:   255.255.255.0  → 11111111.11111111.11111111.00000000
네트워크: 192.168.1.0    (AND 연산 결과)

IPv6

128비트(16비트 × 8)로 구성된다. 주소 고갈 문제 해결 외에 인증성, 기밀성, 데이터 무결성을 프로토콜 수준에서 지원한다. 주소 유형은 세 가지다.

유니캐스트 : 1:1 통신
멀티캐스트 : 1:다 통신
애니캐스트 : 1:가장 가까운 1 통신 (유니캐스트처럼 보이지만 가장 가까운 노드가 응답)

OSI 7계층 참조 모델

네트워크 통신을 7개의 계층으로 추상화한 모델이다. 계층별로 역할이 분리되어 있어, 특정 계층의 기술이 바뀌어도 다른 계층에는 영향이 없다는 것이 핵심 설계 원칙이다.

실무에서는 L4(전송 계층), L7(응용 계층) 같은 표현을 자주 쓴다. 예를 들어 "L7 로드밸런서"는 HTTP 헤더나 URL 경로를 분석해 트래픽을 분산한다.

TCP/IP 프로토콜 스택

OSI 7계층이 이론 모델이라면, TCP/IP는 인터넷에서 실제로 동작하는 프로토콜 스택이다.

TCP(Transmission Control Protocol)
전송 계층에서 동작한다. 연결을 먼저 맺고(3-way handshake) 데이터를 주고받는 연결 지향 방식이다. 데이터 순서 보장, 오류 재전송, 흐름 제어를 제공한다. 웹(HTTP), 이메일, 파일 전송에 쓰인다.

UDP(User Datagram Protocol)
연결 설정 없이 바로 데이터를 보내는 비연결형 방식이다. 오버헤드가 낮고 빠르다. 스트리밍 영상, 게임, DNS 쿼리처럼 약간의 손실보다 속도가 중요한 경우에 사용한다.

IP(Internet Protocol)
네트워크 계층에서 동작한다. 패킷이 출발지에서 목적지까지 경로를 찾아가도록 하는 역할이다. 비연결형이며 신뢰성은 보장하지 않는다(TCP가 보완).

기타 주요 프로토콜

프로토콜	설명
ICMP	IP와 함께 동작하며 오류 메시지 및 통신 상태를 전달. `ping` 명령이 ICMP를 사용
ARP	IP 주소를 MAC 주소로 변환
RARP	MAC 주소를 IP 주소로 변환
RTCP	RTP 패킷의 전송 품질을 제어하는 프로토콜. 영상 통화 품질 모니터링에 쓰임

패킷 교환 방식

데이터를 일정 크기의 패킷으로 나눠 전송하는 방식으로, 현대 인터넷의 기반이다.

가상 회선 방식
통신 전에 경로를 미리 설정한다. 모든 패킷이 같은 경로로 전달되므로 순서가 보장된다. ATM 네트워크가 대표적이다.

데이터그램 방식
경로를 미리 설정하지 않는다. 각 패킷이 독립적으로 경로를 선택한다. 인터넷(IP)이 이 방식이다. 순서가 뒤바뀔 수 있어 TCP가 재조립을 담당한다.

네트워크 장비

장비	동작 계층	주요 역할
리피터	1계층	신호 재생/증폭. 장거리 전송
허브	1계층	여러 장치를 연결. 수신 신호를 모든 포트로 전달
브리지	2계층	LAN과 LAN 연결. MAC 주소 기반 필터링
L2 스위치	2계층	브리지의 발전형. MAC 주소로 특정 포트에만 전달
라우터	3계층	LAN-LAN, LAN-WAN 연결. 최적 경로 선택
L3 스위치	3계층	L2 스위치 + 라우터 기능
L4 스위치	4계층	TCP/UDP 포트 기반 로드 밸런싱
L7 스위치	7계층	HTTP 헤더, URL, 쿠키까지 분석해 세밀한 트래픽 제어
게이트웨이	전 계층	서로 다른 프로토콜을 사용하는 네트워크 연결

브리지 회선 수 공식 : n개의 브리지로 서브넷 구성 시 전송 가능한 회선 수는 n(n-1)/2개다. 망형 토폴로지와 같은 공식 이라는 점에 주의한다.

라우팅 프로토콜

패킷의 최적 경로를 결정하는 프로토콜이다.

RIP : 구현이 단순하지만 최대 15홉 제한이 있어 대규모 네트워크에 부적합하다.
OSPF : RIP의 단점을 보완한다. 링크 상태 변화 시 즉시 전파하므로 수렴 속도가 빠르다.
BGP : 인터넷 AS(자율 시스템) 간 경로를 관리하는 프로토콜로, 인터넷 백본의 핵심이다.

흐름 제어

송수신 속도 차이로 인한 데이터 손실을 방지한다.

정지-대기(Stop-and-Wait) : 패킷을 하나 보내고 확인 응답을 받을 때까지 기다린다. 단순하지만 효율이 낮다.
슬라이딩 윈도우(Sliding Window) : 확인 응답을 기다리지 않고 윈도우 크기만큼 연속으로 보낸다. TCP가 이 방식을 사용하며, 실무에서 네트워크 처리량을 높이는 핵심 메커니즘이다.

네트워크 토폴로지

토폴로지	특징	장애 시
성형(Star)	중앙 허브/스위치에 연결. 현재 LAN의 표준	중앙 장애 시 전체 마비
버스형(Bus)	하나의 회선에 모두 연결	회선 단절 시 전체 마비
링형(Ring)	원형으로 연결	한 노드 장애 시 전체 영향
계층형(Tree)	버스형 확장. 계층 구조	상위 노드 장애 시 하위 전체 영향
망형(Mesh)	모든 노드가 서로 연결	일부 장애에도 통신 유지

망형 공식 : 노드 n개일 때 필요 회선 수 = n(n-1)/2, 노드당 필요 포트 수 = n-1

5. 기타 신기술

SW 관련 신기술

블록체인
데이터를 중앙 서버 없이 P2P 네트워크의 여러 노드에 분산 저장한다. 한 번 기록된 데이터를 변경하려면 체인 전체를 바꿔야 하므로 위변조가 어렵다. 암호화폐 외에도 스마트 계약, 공급망 추적에 활용된다.

매시업(Mashup)
여러 서비스의 API를 조합해 새로운 서비스나 애플리케이션을 만드는 기법이다. 지도 API + 부동산 데이터를 합쳐 새로운 서비스를 만드는 것이 대표적인 예다.

SOA(서비스 지향 아키텍처)
IT 시스템을 재사용 가능한 서비스 단위로 구성하는 설계 방식이다. 마이크로서비스 아키텍처(MSA)의 전신이라 볼 수 있다. 계층 구조는 다음과 같다.

표현 계층 → 업무 프로세스 계층 → 서비스 중간 계층 → 애플리케이션 계층 → 데이터 저장 계층

SaaS(Software as a Service)
소프트웨어의 필요한 기능만 인터넷으로 구독해 사용하는 방식이다. Google Workspace, Slack, Salesforce가 대표적이다.

디지털 트윈
물리적 사물이나 시스템을 소프트웨어로 가상화한 모델이다. 제조 공장의 설비를 디지털로 복제해 고장을 사전 예측하거나 시뮬레이션하는 데 쓰인다.

HW 관련 신기술

RAID (Redundant Array of Inexpensive Disks)
여러 디스크를 묶어 성능이나 안정성을 높이는 기술이다.

레벨	방식	최소 디스크	손상 허용
RAID 0	스트라이핑	2개	0개
RAID 1	미러링	2개	1개
RAID 2~4	비트/바이트/워드 단위 패리티	3개	1개
RAID 5	분산 패리티	3개	1개
RAID 6	이중 분산 패리티	4개	2개

실무에서 DB 서버나 NAS에는 RAID 5 또는 RAID 6이 주로 사용된다. RAID 0은 속도가 빠르지만 디스크 하나만 고장나도 데이터 전체를 잃으므로 중요 데이터에는 쓰지 않는다.

DB 관련 신기술

하둡(Hadoop)
더그 커팅과 마이크 캐퍼렐라가 개발한 오픈소스 분산 컴퓨팅 플랫폼이다. 구글 맵리듀스 엔진을 기반으로 하며 Java로 구현되었다. 수십 TB에서 PB 규모의 데이터를 여러 서버에 분산 처리한다.

맵리듀스(MapReduce)
대용량 데이터를 분산 처리하는 프로그래밍 모델이다.

Map 단계  : 데이터를 키-값 쌍으로 분류 (흩어진 데이터를 연관성 있는 그룹으로 묶음)
Reduce 단계 : 중복 제거 및 집계 (원하는 결과 데이터 추출)

단어 빈도 분석을 예로 들면, Map에서 각 단어를 (단어, 1) 형태로 출력하고, Reduce에서 같은 단어의 카운트를 모두 더한다.

OLAP(Online Analytical Processing)
다차원 데이터를 다양한 각도에서 집계·분석해 의사결정을 지원하는 방식이다. BI(Business Intelligence) 도구가 내부적으로 OLAP을 활용한다. OLTP(실시간 트랜잭션 처리)와 구분된다.

데이터 마이닝
대량의 데이터에서 숨겨진 패턴, 상관관계, 규칙을 찾아내는 기법이다. 머신러닝 알고리즘을 포함한다.

DB 회복 기법

DB가 손상되었을 때 정상 상태로 되돌리는 작업이다. 로그 파일에 기록된 트랜잭션 정보를 활용한다.

REDO : 완료(COMMIT)된 트랜잭션 중 아직 디스크에 반영되지 않은 것을 다시 실행한다. "완료된 작업을 다시 한다."
UNDO : 완료되지 않은(COMMIT 없는) 트랜잭션이 변경한 내용을 되돌린다. "미완 작업을 없던 일로 한다."

기법	갱신 시점	가능한 회복
연기 갱신 기법	트랜잭션 완료 후 실제 갱신	REDO만 가능
즉각 갱신 기법	부분 완료 전이라도 즉시 반영	REDO + UNDO 모두 가능

병행 제어와 교착 상태

여러 트랜잭션이 동시에 DB에 접근할 때 일관성을 유지하는 것이 병행 제어 다.

로킹(Locking)

데이터에 접근하기 전 잠금(Lock)을 요청하고, 허락된 트랜잭션만 접근할 수 있게 하는 기법이다.

로킹 단위	로크 수	관리 난이도	병행성
크다 (예: 테이블 전체)	적다	쉽다	낮다
작다 (예: 행 단위)	많다	어렵다	높다

교착 상태(Dead Lock)

교착 상태 발생의 필요충분 조건 4가지:

상호 배제 : 자원은 한 번에 한 프로세스만 사용
점유와 대기 : 자원을 점유한 채로 다른 자원을 기다림
비선점 : 점유된 자원을 강제로 빼앗을 수 없음
환형 대기 : 프로세스들이 원형으로 서로의 자원을 기다림

네 가지 조건이 모두 성립해야 교착 상태가 발생한다. 해결 방법은 다음과 같다.

방법	설명
예방	네 조건 중 하나를 제거
회피	은행원 알고리즘으로 안전한 상태만 유지
발견	주기적으로 교착 상태 탐지 후 처리
회복	교착 상태 프로세스 종료 또는 자원 선점

타임스탬프 순서

트랜잭션마다 시작 시각을 타임스탬프로 부여하고, 이 순서대로 실행을 직렬화하는 병행 제어 기법이다. 로킹 방식에서 발생할 수 있는 교착 상태를 원천 방지할 수 있다. 순서를 정하는 방법 중 가장 보편적으로 사용된다.

부록 — 주요 공식 정리

숫자로 기억하는 핵심 공식

항목	공식
망형 토폴로지 회선 수	`n(n-1)/2`
브리지 n개의 회선 수	`n(n-1)/2`
망형 노드당 필요 포트	`n-1`
chmod rwx → 8진수	r=4, w=2, x=1 합산
HRN 우선순위	`(대기시간 + 서비스시간) / 서비스시간`
SJF 반환 시간	`대기시간 + 실행시간`

자주 혼동하는 개념 정리

혼동 포인트	구분 방법
REDO vs UNDO	REDO = 완료된 작업 재실행 / UNDO = 미완 작업 취소
TCP vs UDP	TCP = 연결형, 신뢰성 / UDP = 비연결형, 속도
ARP vs RARP	ARP = IP→MAC / RARP = MAC→IP
LRU vs LFU	LRU = 최근에 안 쓴 것 교체 / LFU = 빈도가 낮은 것 교체
페이지 vs 세그먼트	페이지 = 고정 크기 / 세그먼트 = 논리 단위 크기
IGP vs EGP	IGP = 같은 AS 내부 / EGP = AS 간 라우팅

소프트웨어 개발 보안 구축 핵심 개념

Seum Lee — Mon, 25 May 2026 12:56:24 +0900

소프트웨어 개발 보안 구축

1. Secure SDLC

보안은 개발이 끝나고 붙이는 패치가 아니다. 요구사항을 정의하는 순간부터 배포 이후까지, 개발 생명 주기 전 단계에 보안을 내재화하는 것이 Secure SDLC의 핵심이다. 나중에 발견된 취약점을 고치는 비용은 설계 단계에서 예방하는 비용의 수십 배에 달한다는 것은 현업에서 자주 체감하는 사실이다.

대표적인 방법론 세 가지가 있다.

CLASP	Cigital	SDLC 초기 단계 보안 강화에 초점. 역할 기반 활동 정의.
SDL	Microsoft	MS 내부에서 출발해 공개된 방법론. 위협 모델링 포함.
Seven Touchpoints	Gary McGraw	모범 사례를 SDLC 7개 접점에 통합. 코드 리뷰·위험 분석 강조.

2. 보안 요소 (CIA + 인증·부인방지)

현업에서 보안 설계를 논할 때 가장 먼저 나오는 프레임이 CIA Triad다. 여기에 인증과 부인방지를 더하면 보안 요소 전체 그림이 완성된다.

CIA Triad

기밀성 (Confidentiality): 인가된 사용자만 데이터에 접근할 수 있어야 한다. 전송 중 패킷이 탈취되더라도 암호화가 되어 있으면 내용을 읽을 수 없다. HTTPS, VPN이 이 원칙을 구현한 대표적인 기술이다.

무결성 (Integrity): 데이터가 인가되지 않은 방식으로 수정되어서는 안 된다. 해시값 비교나 디지털 서명이 대표적인 구현 방법이다. 파일을 배포할 때 SHA-256 해시를 함께 공개하는 관행이 바로 이 원칙을 따른 것이다.

가용성 (Availability): 인가된 사용자는 필요할 때 언제든 정보와 자원을 사용할 수 있어야 한다. DDoS 공격이 가용성을 노리는 대표적인 위협이다.

인증과 부인방지

인증(Authentication)은 접속한 주체가 정말 그 사람인지 확인하는 행위다. 인증 방식은 다섯 가지 기반으로 분류된다.

지식 기반: 비밀번호, PIN처럼 "알고 있는 것"
소유 기반: OTP 토큰, 스마트카드처럼 "가지고 있는 것"
생체 기반: 지문, 홍채처럼 "나 자신인 것"
위치 기반: 특정 IP 대역, 국가처럼 "있는 위치"
행위 기반: 서명 패턴, 타이핑 리듬처럼 "행동 방식"

부인방지(Non-repudiation)는 송신자나 수신자가 나중에 "나는 그런 적 없다"고 발뺌하지 못하도록 증거를 남기는 것이다. 전자서명이 가장 전형적인 구현이다.

3. 시큐어 코딩

보안 취약점의 상당수는 애플리케이션 코드 레벨에서 비롯된다. 시큐어 코딩은 이 취약점을 코드 작성 단계에서 예방하는 실천이다.

입력 데이터 검증 관련 취약점

외부에서 들어오는 모든 입력은 잠재적으로 악의적일 수 있다는 전제로 코드를 작성하는 것이 기본이다.

경로 순회 (Path Traversal): ../ 같은 상대 경로 기호를 악용해 허가되지 않은 파일에 접근하는 공격이다. 예를 들어 파일 다운로드 기능에서 파일명 파라미터를 그대로 경로에 사용하면 서버의 /etc/passwd까지 노출될 수 있다.

# 취약한 코드: 입력값을 그대로 경로에 사용
filename = request.args.get('file')
with open(f"/var/uploads/{filename}") as f:  # ../../../etc/passwd 가능
    return f.read()

# 개선: 경로를 정규화하고 허용 디렉토리 내인지 검증
import os
base_dir = "/var/uploads"
filename = request.args.get('file')
safe_path = os.path.realpath(os.path.join(base_dir, filename))
if not safe_path.startswith(base_dir):
    abort(403)

SQL 삽입 (SQL Injection): 입력값에 SQL 구문을 섞어 DB를 조작하거나 인증을 우회하는 공격이다. 실무에서 여전히 OWASP Top 10에 빠지지 않는 단골 취약점이다.

# 취약한 코드: 문자열 포매팅으로 쿼리 조합
query = f"SELECT * FROM users WHERE id='{user_id}'"  # ' OR '1'='1 삽입 가능

# 개선: 파라미터 바인딩 사용
cursor.execute("SELECT * FROM users WHERE id = %s", (user_id,))

XSS (Cross-Site Scripting): 악의적인 스크립트를 웹 페이지에 삽입해 다른 사용자의 브라우저에서 실행시키는 공격이다. 세션 쿠키 탈취, 피싱 페이지 삽입 등에 활용된다.

# 취약한 코드: 사용자 입력을 HTML에 그대로 출력
return f"<p>안녕하세요, {username}</p>"  # <script>alert(1)</script> 삽입 가능

# 개선: 출력 시 HTML 이스케이프 처리
from markupsafe import escape
return f"<p>안녕하세요, {escape(username)}</p>"

메모리 버퍼 오버플로: 할당된 메모리 범위를 넘어 데이터를 쓸 때 발생한다. C/C++ 환경에서 자주 나타나며, 공격자가 이를 이용해 임의 코드를 실행시킬 수 있다. Python, Java 등 메모리 관리 언어를 사용하면 이 위험이 크게 줄어든다.

보안 기능 관련 취약점

하드 코딩: API 키, DB 패스워드, 암호화 키를 소스코드에 직접 쓰는 관행이다. 코드가 깃허브에 올라가는 순간 탈취 위험이 생긴다. 환경변수나 시크릿 관리 서비스(AWS Secrets Manager, HashiCorp Vault 등)로 분리하는 것이 올바른 방향이다.

# 권장하지 않는 방식
DB_PASSWORD = "super_secret_123"

# 권장 방식: 환경변수에서 읽기
import os
DB_PASSWORD = os.environ.get("DB_PASSWORD")

TOCTOU (Time Of Check To Time Of Use) 경쟁 조건: 파일 존재 여부를 검사(Check)한 시점과 실제 사용(Use) 시점 사이의 간격을 파고드는 취약점이다. 멀티스레드 환경이나 공유 자원 접근 시 빈번하게 나타난다.

널 포인터 역참조: 널 포인터가 가리키는 메모리 위치에 접근하면 프로그램이 충돌하거나 예측 불가능한 동작이 발생한다. 반드시 널 체크를 선행하는 습관이 중요하다.

스택 가드: 버퍼 오버플로 공격을 탐지하기 위한 방어 기법이다. 복귀 주소와 변수 사이에 특정 카나리(canary) 값을 넣어두고, 이 값이 변조되면 오버플로우로 판단해 실행을 중단한다.

접근 제어자 범위: public → protected → default → private 순으로 접근 범위가 좁아진다. 실무에서는 정보 은닉 원칙에 따라 가능한 한 좁은 접근 범위를 선택하는 편이 안전하다.

4. 암호화

개인키(대칭키) 암호화

암호화와 복호화에 동일한 키를 쓴다. 속도가 빠르고 구현이 단순하지만, 키를 안전하게 전달하는 문제(키 배포 문제)가 있다. 대량 데이터 암호화에 주로 쓰인다.

암호화 방식은 처리 단위에 따라 두 가지로 나뉜다.

스트림 방식: 평문과 동일한 길이의 키스트림을 생성해 비트 단위로 XOR 연산한다. 실시간 통신에 적합하다. 대표 알고리즘으로 LFSR, RC4가 있다.

블록 방식: 데이터를 고정 크기 블록으로 나눠 한 블록씩 암호화한다. 대표 알고리즘은 아래와 같다.

DES	미국 NBS	1975	64비트 키	현재는 취약. 3DES로 보완했으나 느림.
SEED	KISA	1999	128비트 키	국내 표준 블록 암호
AES	미국 NIST	2001	128/192/256비트 키	현재 가장 널리 쓰이는 표준
ARIA	국정원+산학연	2004	AES 규격 준용	국내 표준, 경량 환경에 적합

알고리즘 제안 주체 연도 키/블록 크기 비고

AES는 현재 사실상의 글로벌 표준이다. 신규 시스템을 설계할 때 특별한 이유가 없다면 AES-256을 기준으로 삼는 것이 일반적이다.

공개키(비대칭키) 암호화

공개키로 암호화하고 개인키로 복호화한다. 키 배포 문제를 해결하지만, 대칭키 방식에 비해 연산이 훨씬 느리다. 그래서 실제 데이터 암호화보다는 대칭키를 안전하게 교환하거나 전자서명을 생성하는 용도로 주로 쓰인다.

RSA: 라이베스트, 샤미르, 애들먼이 개발한 공개키 알고리즘이다. 큰 수의 소인수분해가 현실적으로 어렵다는 수학적 난제를 기반으로 한다. 현재도 TLS 핸드셰이크, 전자서명에 광범위하게 사용된다.

해시

입력 데이터를 고정 길이의 값으로 변환한다. 단방향 함수이므로 복호화가 불가능하다. 데이터 무결성 검증, 패스워드 저장에 활용된다.

MD5	128비트	1991년 라이베스트 개발. 충돌 취약점 발견으로 보안 용도로는 권장하지 않음.
SHA-256 / SHA-512	256 / 512비트	NSA·NIST 발표. 현재 가장 많이 쓰이는 해시 계열.
N-NASH	128비트	일본 NTT 발표.
SNEFRU	가변	머클이 1990년 발표. 32비트 프로세서 최적화.

알고리즘 출력 크기 비고

패스워드를 저장할 때 MD5나 SHA-1을 단순히 적용하는 것은 권장하지 않는다. 레인보우 테이블 공격에 취약하기 때문이다. bcrypt, Argon2, PBKDF2처럼 솔트(salt)와 반복 연산을 적용한 알고리즘을 쓰는 편이 현재 기준에 맞다.

무선 보안 프로토콜

WEP → TKIP(WPA) → WPA2 순으로 보안 수준이 높아졌다.

WEP: 초기 무선랜 보안 프로토콜. 취약점이 많아 현재는 사용하지 않는다.
TKIP: WEP의 취약점을 보완한 데이터 보안 프로토콜. WPA에 사용됨.
WPA2: 현재 표준. AES 기반 CCMP 암호화를 사용한다.

5. 보안 아키텍처와 솔루션

실무에서는 단일 보안 제품 하나로 모든 위협을 막을 수 없다. 여러 보안 솔루션을 계층적으로 배치하는 심층 방어(Defense in Depth) 전략이 현실적인 접근이다.

주요 보안 솔루션

방화벽 (Firewall): 네트워크 경계에서 트래픽을 필터링한다. 허용할 IP와 포트를 정의하고, 그 외는 차단한다. 하지만 허용된 포트를 통한 애플리케이션 레이어 공격(예: HTTP를 통한 SQL 인젝션)은 막지 못한다.

침입 탐지 시스템 (IDS): 공격을 탐지하지만 자동 차단은 하지 않는다. 두 가지 방식이 있다.

오용 탐지: 알려진 공격 패턴(시그니처)과 비교해 탐지한다. 알려지지 않은 공격(제로데이)은 놓칠 수 있다.
이상 탐지: 정상 상태 기준선을 설정하고 벗어난 행동을 탐지한다. 오탐율이 높을 수 있다.

침입 방지 시스템 (IPS): IDS에 자동 차단 기능을 더한 것이다. 비정상 트래픽을 능동적으로 격리한다. "방화벽 + IDS"의 조합으로 이해하면 편하다.

웹 방화벽 (WAF): SQL 인젝션, XSS 등 웹 계층 공격에 특화된 방화벽이다. 일반 방화벽이 놓치는 HTTP 레이어 공격을 잡아낸다.

VPN: 공중망 인터넷을 통해 암호화된 사설 터널을 구성한다. 재택근무 환경에서 사내망 접근에 광범위하게 쓰인다.

NAC (Network Access Control): 내부망에 접속하는 단말의 MAC 주소를 등록·관리해 비인가 단말의 접속을 차단한다.

DLP (Data Loss Prevention): 내부 데이터가 외부로 유출되는 것을 감지하고 차단한다. 이메일, USB, 클라우드 업로드 경로를 모니터링한다.

ESM (Enterprise Security Management): 여러 보안 장비에서 발생하는 로그와 이벤트를 통합 관리하는 플랫폼이다. 개별 장비를 각각 들여다보는 것보다 상관 분석이 가능해 위협 탐지 정확도가 높아진다.

AAA: 보안 접근 통제의 세 가지 핵심 기능이다.

인증 (Authentication): 본인 확인
인가 (Authorization): 권한 부여
과금 (Accounting): 접근 기록과 자원 사용 추적

ISMS (정보보호관리체계): 조직의 정보 자산을 안전하게 보호하기 위한 절차와 대책의 체계다. 국내에서는 KISA가 운영하며, ISO 27001을 기반으로 한다.

6. 주요 공격 기법

서비스 거부 공격 (DoS / DDoS)

서비스를 정상적으로 제공하지 못하도록 가용성을 공격하는 방식이다.

Ping of Death	ICMP 패킷 크기를 허용 범위 이상으로 전송해 시스템 충돌 유발
Smurf Attack	출발지 IP를 피해자로 위조한 ICMP 브로드캐스트로 대량 응답 집중
SYN Flooding	TCP 3-way 핸드셰이크를 미완성 상태로 방치해 연결 자원 소진
TearDrop	IP 단편화 오프셋을 변조해 재조합 과정에서 과부하 발생
LAND Attack	송신·수신 IP를 동일하게 설정해 무한 응답 루프 유발
DDoS	봇넷(좀비 PC 집합)을 이용해 여러 지점에서 동시 공격. Trin00, TFN, TFN2k, Stacheldraht 등의 툴 활용.

공격 원리

SYN Flooding은 현업에서도 자주 접하는 공격이다. 이에 대응하기 위한 SYN Cookie, Rate Limiting 설정을 서버 운영 시 기본으로 챙기는 편이 좋다.

세션·네트워크 탈취 공격

세션 하이재킹: 클라이언트와 서버 사이의 세션을 가로채는 공격이다. TCP 3-way 핸드셰이크 과정에 끼어드는 TCP 세션 하이재킹이 대표적이다. 세션 토큰을 탈취하거나 시퀀스 번호를 예측해 세션을 강탈한다.

ARP Spoofing: ARP는 IP 주소를 MAC 주소로 변환하는 프로토콜인데, 이 과정에서 자신의 MAC 주소를 공격 대상인 것처럼 위조해 트래픽을 가로채는 공격이다. 같은 네트워크 내 중간자 공격(MITM)의 전형적인 수단이다.

스니핑: 네트워크를 지나는 패킷을 수동적으로 도청한다. 암호화되지 않은 프로토콜(HTTP, FTP, Telnet)은 스니핑에 취약하다. HTTPS, SSH, SFTP를 쓰는 이유 중 하나가 여기 있다.

악성코드·사회공학 공격

랜섬웨어: 내부 파일을 암호화한 뒤 복호화 대가로 금전을 요구한다. 백업과 오프라인 복사본이 현재로서 가장 현실적인 대응책이다.

백도어: 개발자나 공격자가 정상 인증 절차를 우회해 시스템에 접근하도록 숨겨둔 통로다. 탐지 방법으로는 무결성 검사, 열린 포트 확인, 로그 분석, SetUID 파일 검사가 있다.

워터링 홀: 공격 대상이 자주 방문하는 웹사이트를 미리 감염시켜 방문자를 감염시키는 방식이다. 표적 집단의 행동 패턴을 사전에 연구한다는 점에서 정교한 APT 공격에 자주 활용된다.

APT (Advanced Persistent Threat): 특정 조직을 목표로 장기간에 걸쳐 조직적으로 침투하는 공격이다. 단발성 공격이 아니라 정찰, 침투, 내부 이동, 정보 탈취까지 단계적으로 진행한다.

키로거: 키보드 입력을 몰래 기록해 패스워드, 카드 번호 등 민감한 정보를 탈취한다.

기타 공격·취약점 용어

스미싱	SMS + 피싱. 문자 링크로 악성 앱 설치 유도.
스피어 피싱	특정 대상을 선정해 지속적으로 맞춤형 이메일 발송.
큐싱	QR코드 + 피싱. QR 스캔 시 악성 사이트로 유도.
브루트 포스	가능한 모든 값을 대입해 패스워드를 찾는 무차별 공격.
크리덴셜 스터핑	이미 유출된 계정 정보를 다른 서비스에 무작위 대입.
제로데이 공격	취약점이 공개되기 전에 이미 해당 취약점을 악용하는 공격.
트로이 목마	정상 프로그램으로 위장한 악성코드. 사용자가 직접 실행.
웜	자가 복제하며 네트워크를 통해 스스로 전파하는 악성코드.
멀버타이징	정상 광고 네트워크에 악성 코드를 심어 배포하는 방식.
공급망 공격	소프트웨어 공급망에 침투해 악성코드를 정상 배포물에 삽입.
데이터 디들링	처리될 데이터를 처리 전에 몰래 변조하는 방식.
POODLE	TLS 연결을 SSL 3.0으로 강제 다운그레이드 후 취약점 악용.
DDE 취약점	오피스 문서에 포함된 DDE 프로토콜을 통한 악성코드 실행.

용어 설명

7. 보안 관련 기타 개념

보안 아키텍처: 보안 요소들 간의 관계와 구조를 정의한 설계 체계다. 어떤 보안 통제를 어떤 계층에 적용할지 그림을 그리는 작업이다.

보안 프레임워크: 안전한 정보 시스템 환경을 유지하기 위한 체계적 틀이다. ISO 27001, BS7799가 대표적이다.

EDR (Endpoint Detection and Response): 엔드포인트(PC, 서버 등)에서 발생하는 위협을 모니터링하고 대응한다. 기존 백신과 달리 행위 기반으로 탐지하므로 알려지지 않은 위협에도 반응한다.

TMS (Threat Management System): 전사적 IT 인프라에 대한 위협 정보를 통합 관리하는 시스템이다.

DTLS: UDP 기반 통신에 SSL/TLS와 유사한 보안 기능을 제공한다. VoIP나 게임처럼 실시간성이 중요한 UDP 통신에 적합하다.

비트 로커 (BitLocker): 윈도우 전용 볼륨 암호화 기능이다. TPM(신뢰 플랫폼 모듈) 칩과 AES-128을 결합해 디스크 전체를 암호화한다. 분실된 노트북의 데이터를 보호하는 데 효과적이다.

CC (Common Criteria) 인증: 정보보안 제품의 보안 기능을 국제적으로 평가하는 기준이다. EAL 1~7 등급으로 나뉜다.

ISAC (정보공유분석센터): 산업별 사이버 위협 정보를 공유하고, 실시간 경보 및 분석 체계를 운영하는 기관이다.

BCP (Business Continuity Planning): 재해·장애 상황에서도 비즈니스를 지속하기 위한 계획이다. RTO(목표 복구 시간), RPO(목표 복구 시점), BIA(업무 영향 분석)를 기반으로 수립한다.

봇넷(C&C 구조): 악성코드에 감염된 좀비 PC들을 C&C(Command and Control) 서버가 원격 조종하는 구조다. DDoS 공격, 스팸 발송, 크리덴셜 스터핑 등에 활용된다.

부록 — 암호화 알고리즘 한눈에 비교

대칭키 vs 비대칭키 vs 해시

대칭키	하나의 키	가능	대량 데이터 암호화	AES, DES, SEED, ARIA
비대칭키	공개키 + 개인키 쌍	가능 (개인키로)	키 교환, 전자서명	RSA
해시	없음	불가 (단방향)	무결성 검증, 패스워드 저장	SHA-256, MD5

구분 키 구조 복호화 가능 주요 용도 대표 알고리즘

보안 솔루션 계층 배치

계층	솔루션	핵심 역할
경계 (Perimeter)	방화벽 (Firewall)	허가되지 않은 네트워크 접근을 IP/Port 기반으로 차단
애플리케이션 (App)	IPS / WAF	패킷 침입 탐지 및 웹 애플리케이션 취약점 공격 방어
접근 제어 (Access)	NAC	네트워크 접속 단말의 무결성 검증 및 인증 관리
엔드포인트 (Endpoint)	EDR	단말 내부의 이상 행위 모니터링 및 실시간 위협 대응
통합 관제 (Monitoring)	ESM / SIEM	분산된 보안 로그를 통합하여 상관관계 분석 및 경보

공격 유형 분류 요약

공격 목표	주요 공격 기법	설명
가용성 파괴	DoS / DDoS	서비스에 과부하를 주어 정상 사용자가 이용하지 못하게 함
기밀성 침해	스니핑, ARP Spoofing, 세션 하이재킹	데이터 흐름을 도청하거나 세션을 탈취하여 정보를 훔침
무결성 침해	데이터 디들링, SQL 인젝션	데이터를 악의적으로 변조하거나 잘못된 데이터로 조작함
인증 우회	크리덴셜 스터핑, 브루트 포스	계정 정보를 탈취하거나 무작위 대입으로 로그인을 시도함
지속 접근	백도어, APT, 공급망 공격	침투 후 몰래 장기간 상주하며 시스템 통제권을 유지함
금전 탈취	랜섬웨어, 피싱	데이터를 인질로 잡거나 사용자를 속여 직접적인 이득을 취함

애플리케이션 테스트 핵심 개념

Seum Lee — Mon, 25 May 2026 12:50:27 +0900

1. 애플리케이션 테스트란

테스트는 소프트웨어에서 결함을 찾아내는 행위이자 절차다. 두 가지 시각으로 나눌 수 있다.

검증(Verification) 테스트: 개발자 입장에서 "제대로 만들었는가"를 확인한다. 설계 명세를 기준으로 삼는다.
확인(Validation) 테스트: 사용자 입장에서 "맞는 것을 만들었는가"를 확인한다. 실제 요구사항이 기준이다.

이 둘은 비슷해 보이지만 전혀 다른 질문에 답한다. 기능은 완벽하게 작동하지만 사용자가 원하는 기능이 아닌 경우가 현장에서 자주 벌어지는 이유가 바로 이 둘의 간극에서 나온다.

테스트의 기본 원리

테스트를 설계할 때 자주 놓치는 원리 세 가지다.

파레토 법칙: 결함의 80%는 전체 모듈의 20%에 집중된다. 실무에서는 이력이 불안정하거나 복잡한 모듈을 먼저 집중 점검하는 근거가 된다.

살충제 패러독스: 동일한 테스트 케이스로 반복 테스트하면 어느 시점부터 새로운 결함이 발견되지 않는다. 살충제를 계속 뿌리면 내성이 생기는 것과 같다. 이를 피하려면 테스트 케이스를 주기적으로 갱신하거나 다양한 관점으로 바꿔야 한다.

오류-부재의 궤변: 결함이 전혀 없다고 해서 품질이 높은 것은 아니다. 결함이 없어도 사용자의 요구사항을 충족하지 못하면 그 소프트웨어는 쓸모가 없다. 테스트는 "결함 제거"가 아닌 "요구사항 충족 여부"를 최종 목표로 삼아야 한다.

2. 테스트 분류 체계

테스트는 세 가지 기준으로 분류한다. 기반, 목적, 개발 단계가 그것이다.

테스트 기반에 따른 분류

테스트를 어떤 근거로 설계하느냐에 따라 나뉜다.

명세 기반	요구사항 명세, 설계 문서	동등 분할, 경계값 분석
구조 기반	소스 코드의 내부 구조	구문 기반, 결정 기반, 조건 기반
경험 기반	테스터의 직관과 경험	에러 추정, 체크리스트, 탐색적 테스팅

분류 근거 대표 기법

명세 기반은 코드를 몰라도 테스트할 수 있고, 구조 기반은 코드를 직접 들여다본다. 경험 기반은 자동화하기 어렵지만 베테랑 QA가 놓치는 엣지 케이스를 잡아내는 데 강하다.

목적에 따른 분류

회복(Recovery)	결함 발생 후 정상 복구되는지 확인
안전(Security)	외부 침입으로부터 시스템이 보호되는지 확인
강도(Stress)	과부하 상황에서의 동작 확인
성능(Performance)	응답 시간, 처리량 측정
구조(Structure)	논리 경로, 코드 복잡도 평가
회귀(Regression)	변경 후 기존 기능에 문제가 생기지 않았는지 확인
병행(Parallel)	변경 전후 버전에 동일 데이터를 입력하고 결과를 비교

테스트 목적

시험 포인트: 회귀 테스트는 "이미 테스트된 프로그램의 테스팅을 반복"하는 것이다. 코드 수정 후 기존 기능이 깨지는 현상(Regression)을 잡기 위해 수행한다. CI/CD 파이프라인에서 자동화 테스트가 가장 많이 담당하는 역할이기도 하다.

정적 테스트 vs 동적 테스트

실행 여부로 나뉘는 구분이다.

정적 테스트는 프로그램을 실행하지 않고 코드나 문서를 검토한다. 대표적으로 워크스루(비공식 리뷰)와 인스펙션(공식 절차에 따른 검토)이 있다.

동적 테스트는 실제로 프로그램을 실행해서 결과를 확인한다. 화이트박스와 블랙박스로 세분화된다.

3. 화이트박스 vs 블랙박스 테스트

화이트박스 테스트

소스 코드를 오픈한 상태에서 내부 논리 경로를 모두 점검하는 방식이다. 개발자가 직접 수행하는 경우가 많다.

대표 기법은 기초 경로 검사(Base Path Testing)와 제어 구조 검사다. 제어 구조 검사는 다시 조건 검사, 루프 검사, 데이터 흐름 검사로 나뉜다.

검증 기준은 두 가지다.

분기(결정) 검증 기준: 모든 조건문에서 True와 False를 각각 한 번씩 수행한다.
조건 검증 기준: 복합 조건식에서 각 개별 조건식의 결과를 따로 확인한다.

예를 들어 if (A && B) 같은 조건이 있을 때 분기 기준은 조건문 전체의 True/False만 보지만, 조건 기준은 A와 B 각각의 True/False 조합을 확인한다.

# 분기 검증 기준 예시
def check_age_and_score(age, score):
    if age >= 18 and score >= 60:  # 이 조건 전체의 T/F를 각 1회 수행
        return "합격"
    return "불합격"

# 분기 기준: (True, True) → "합격" / (False, ...) or (..., False) → "불합격" 2가지면 충분
# 조건 기준: age>=18 의 T/F, score>=60 의 T/F 각각 확인 → 더 많은 케이스 필요

블랙박스 테스트

내부 코드를 보지 않고 기능 명세만으로 테스트한다. "기능 테스트"라고도 부른다.

동치 분할(Equivalence Partitioning)	입력값을 유효/무효 구간으로 나눠 각 구간에서 대표값 하나씩 선택
경계값 분석(Boundary Value Analysis)	구간의 경계 지점 값을 집중 테스트 (경계에서 결함이 자주 발생)
원인-효과 그래프	입력 조건과 출력 결과의 인과 관계를 그래프로 표현해 TC 도출
오류 예측	경험에 의해 발생 가능한 오류를 추정하고 테스트
비교 검사	여러 버전의 프로그램에 동일한 TC를 제공해 결과를 비교

기법 설명

동치 분할과 경계값 분석은 함께 쓰이는 경우가 많다. 예를 들어 "1 이상 100 이하의 정수"를 입력받는 필드라면 동치 분할로 유효 구간(1~100)과 무효 구간을 나누고, 경계값 분석으로 0, 1, 100, 101을 집중 테스트한다.

입력 범위: 1 ~ 100

동치 분할
  - 유효 구간: 1 ~ 100 (대표값: 50)
  - 무효 구간 1: 100 초과 (대표값: 150)
  - 무효 구간 2: 1 미만 (대표값: -10)

경계값 분석
  - 테스트 값: 0, 1, 2, 99, 100, 101

4. 개발 단계에 따른 테스트

단위 테스트

모듈 또는 컴포넌트 단위로 수행하는 첫 번째 테스트다. 주로 구조 기반(화이트박스) 기법을 활용한다. 개발자가 작성한 코드를 개발자 본인이 점검하는 단계이기도 하다.

통합 테스트

단위 테스트가 완료된 모듈들을 조합해 하나의 시스템으로 엮는 과정에서 발생하는 문제를 찾는다. 모듈 간 인터페이스, 데이터 흐름, 제어 흐름이 주요 점검 대상이다.

통합 방식은 크게 두 가지로 나뉜다.

비점진적 방식 (빅뱅 통합): 모든 모듈을 한꺼번에 합쳐서 테스트한다. 간단하지만 결함 위치를 찾기 어렵다.

점진적 방식: 모듈을 하나씩 추가하면서 테스트한다. 결함 추적이 쉬운 대신 시간이 걸린다.

하향식 통합	상위 → 하위	스텁(Stub)	초기에 전체 구조 파악 가능
상향식 통합	하위 → 상위	드라이버(Driver)	하위 모듈을 클러스터로 묶어 통합
혼합식 (샌드위치)	양방향	스텁 + 드라이버	상위는 하향식, 하위는 상향식 동시 진행

방식 방향 대체 모듈 특징

스텁(Stub)은 아직 구현되지 않은 하위 모듈을 임시로 대체하는 더미 코드다. 드라이버(Driver)는 반대로 테스트 대상 모듈을 호출해주는 역할을 하는 임시 코드다.

# 스텁(Stub) 예시: 하위 모듈이 아직 없을 때 임시 대체
def calculate_tax(price):
    # 실제 구현 전, 고정값 반환으로 상위 모듈 테스트 가능하게
    return price * 0.1  # 스텁

# 드라이버(Driver) 예시: 하위 모듈만 완성됐을 때 호출해주는 임시 주체
def test_driver():
    result = calculate_discount(50000)  # 테스트 대상 하위 모듈 직접 호출
    print(f"할인 금액: {result}")

시스템 테스트

완성된 소프트웨어 전체가 요구사항대로 작동하는지 점검한다. 기능뿐 아니라 성능, 보안, 호환성 같은 비기능 요건도 함께 검증한다.

인수 테스트

실제 사용자가 요구사항 충족 여부를 최종 확인하는 단계다. 두 가지로 나뉜다.

알파 테스트: 사용자가 개발자 앞에서, 통제된 환경에서 테스트한다.
베타 테스트: 사용자가 실제 업무 환경에서 직접 테스트한다.

실무에서 베타 테스트는 서비스 출시 직전 소수의 실제 사용자에게 먼저 배포해 피드백을 수집하는 과정과 일치한다.

5. 테스트 케이스, 시나리오, 오라클

테스트 케이스

테스트 항목에 대한 명세서다. 어떤 입력을 주고, 어떤 결과가 나와야 하는지를 사전에 정의해둔 문서라고 볼 수 있다. 테스트 케이스가 잘 작성되어 있어야 반복 가능한 테스트가 가능하고, 자동화도 용이해진다.

테스트 시나리오는 테스트 케이스들을 논리적인 순서로 묶은 집합이다. "로그인 → 상품 검색 → 장바구니 추가 → 결제" 같은 사용자 흐름 하나가 하나의 시나리오가 된다.

테스트 오라클

테스트 결과가 올바른지 판단하는 기준이다. 사전에 정의된 참값을 대입해 실제 결과와 비교한다.

참(True) 오라클	모든 입력에 대해 정확한 결과를 제공. 비용이 높음
샘플링 오라클	일부 입력값에 대해서만 결과를 제공
휴리스틱 오라클	경험적으로 결과를 추정
일관성 오라클	변경 전후 결과가 동일한지 확인 (회귀 테스트에 활용)

종류 설명

6. 테스트 자동화 도구

테스트 자동화는 반복적인 회귀 테스트를 사람이 직접 수행하는 비용을 줄이고, 빌드 파이프라인에 통합해 지속적인 품질 관리를 가능하게 한다.

도구 분류

정적 실행 도구: 코드를 실행하지 않고 코드 품질을 분석한다. SonarQube, PMD, Checkstyle이 대표적이다.

테스트 실행 도구: 스크립트 언어로 작성된 테스트를 자동 실행한다. Selenium, JUnit 같은 도구가 여기에 해당한다.

성능 테스트 도구: 처리량, 응답 시간, 자원 사용률을 측정한다.

JMeter	다양한 프로토콜 지원 (HTTP, FTP, JDBC 등)
LoadUI	Drag & Drop 기반 UI로 편의성이 높음
OpenSTA	오픈소스 성능 테스트 도구

도구 특징

테스트 통제 도구: 테스트 계획, 수행, 결과를 관리한다.

테스트 하네스(Test Harness)

컴포넌트나 모듈을 테스트하기 위해 만들어진 코드와 데이터의 집합이다. 구성 요소는 다음과 같다.

드라이버: 테스트 대상 모듈을 호출하는 임시 주체
스텁: 아직 구현되지 않은 하위 모듈을 대체하는 더미
슈트(Suite): 여러 테스트 케이스를 묶은 집합
스크립트: 자동화 테스트 실행 코드
목 오브젝트(Mock Object): 실제 객체를 흉내 내는 가짜 객체. 외부 API나 DB에 의존하지 않고 단위 테스트를 가능하게 함

# Mock 객체 활용 예시 (pytest-mock)
def get_user_from_db(user_id):
    # 실제로는 DB에서 조회하지만, 테스트에서는 Mock으로 대체
    pass

def test_user_service(mocker):
    mock_db = mocker.patch('myapp.get_user_from_db')
    mock_db.return_value = {"id": 1, "name": "홍길동"}

    result = user_service.get_user(1)
    assert result["name"] == "홍길동"
    # DB 없이도 비즈니스 로직만 독립적으로 테스트 가능

7. 결함 관리

결함이란

개발자가 설계한 의도와 다르게 동작하거나 다른 결과가 발생하는 것을 결함이라 한다. 단순히 "에러가 발생했다"는 것과는 다르다. 기능이 동작하더라도 의도한 것과 다른 결과라면 결함에 해당한다.

결함 분류

분류 기준: 시스템 결함, 기능 결함, GUI 결함, 문서 결함
심각도: High / Medium / Low 또는 Critical / Major / Normal / Minor / Simple
우선순위: Critical / High / Medium / Low 또는 즉시 해결 / 주의 요망 / 대기 / 개선 권고

심각도와 우선순위는 다를 수 있다. 심각도가 낮은 결함이라도 고객에게 노출도가 높으면 우선순위가 올라갈 수 있고, 반대로 내부 시스템의 치명적 결함이 외부 영향이 적어 일정을 이유로 우선순위가 낮아지는 경우도 있다.

결함 상태 추적

결함은 발견 이후 상태를 지속적으로 추적하고 관리한다. 분포(어느 모듈에 얼마나 있는가), 추세(시간에 따라 늘고 있는가 줄고 있는가), 에이징(오래된 결함이 방치되고 있지 않은가)을 측정해 관리한다.

8. 복잡도와 코드 최적화

순환 복잡도 (Cyclomatic Complexity)

코드의 논리적 복잡도를 수치로 나타낸 지표다. 값이 낮을수록 테스트하기 쉽고 유지보수가 편하다.

공식: V(G) = E - N + 2

E: 간선(Edge, 화살표) 수
N: 노드(Node) 수

일반적으로 V(G) ≤ 10이면 낮은 복잡도, 10~20은 보통, 20 이상이면 리팩터링을 고려하는 것이 좋다.

예시: if/else 분기 2개가 있는 함수
노드 수 N = 5, 간선 수 E = 6 이라면
V(G) = 6 - 5 + 2 = 3

소스 코드 최적화

클린 코드로 작성하는 것이 최적화의 출발점이다. 클린 코드 작성 원칙은 다섯 가지다.

가독성: 이름, 주석, 들여쓰기가 의도를 명확히 드러낸다
단순성: 한 번에 하나의 일만 한다
의존성 배제: 다른 모듈의 변경이 이 코드에 영향을 주지 않는다
중복성 최소화: 동일한 로직이 여러 곳에 흩어지지 않는다
추상화: 세부 구현이 아닌 인터페이스 수준에서 통신한다

나쁜 코드의 대표적인 유형도 알아두면 좋다.

스파게티 코드: 로직이 서로 복잡하게 얽혀 어디서 무엇이 실행되는지 추적하기 어려운 코드
외계인 코드: 너무 오래되어 참고 문서나 원작자가 없어 수정 자체가 두려운 코드

소스 코드 품질 분석 도구

정적 분석	SonarQube	코드 품질, 버그, 보안 취약점 종합 대시보드
정적 분석	PMD	Java 중심 정적 분석, 불필요한 코드 탐지
정적 분석	cppcheck	C/C++ 전용 정적 분석
정적 분석	Checkstyle	Java 코딩 컨벤션 준수 여부 검사
동적 분석	Valgrind	메모리 누수, 잘못된 메모리 접근 탐지
동적 분석	Avalanche	런타임 결함 탐지

유형 도구 특징

정적 분석은 코드를 실행하지 않고도 잠재적 버그를 찾아낸다. 빌드 파이프라인에 SonarQube를 연동하면 PR마다 코드 품질 리포트를 자동으로 받을 수 있다.

웹 서버 및 프로그램 구조 이해 (Web / DB)

Seum Lee — Mon, 25 May 2026 12:05:39 +0900

1. 개발 환경

하드웨어 환경 구성

실무에서 서버 환경은 크게 네 가지 역할로 나뉜다.

구성 요소	역할	실무 예시
Web Server	HTTP 요청 처리, 정적 파일 반환	Nginx, Apache
WAS	동적 비즈니스 로직 처리	Tomcat, Node.js
DB Server	데이터 영구 저장 및 조회	PostgreSQL, MySQL
File Server	파일 저장소 역할	NFS, S3(클라우드)

실무에서는 이 네 가지를 반드시 물리적으로 분리하는 건 아니다. 소규모 서비스라면 Web Server와 WAS를 한 서버에서 함께 돌리기도 한다. 다만 트래픽이 커지면 각각을 분리해야 병목이 생기는 지점을 독립적으로 스케일링할 수 있다.

웹 서버의 주요 기능

웹 서버는 단순히 "요청을 받아 파일을 돌려주는 것" 이상의 역할을 한다.

HTTP/HTTPS 지원: 보안 통신(TLS) 처리
통신 기록(Logging): 접근 로그, 에러 로그 관리
정적 파일 관리: HTML, CSS, 이미지 등 직접 반환 (WAS까지 안 보냄)
대역폭 제한: 트래픽 폭주 시 서버 보호
가상 호스팅: 하나의 서버 IP로 여러 도메인을 처리 (예: a.com, b.com을 같은 Nginx에서 분기)
인증: Basic Auth, SSL 인증서 기반 접근 제어

소프트웨어 환경

개발 언어 선정 기준

암기용 키워드: 적효이친범

적정성: 개발 목적에 맞는가
효율성: 처리 능력이 충분한가
이식성: 다른 환경에서도 동작하는가
친밀성: 개발팀이 익숙한가 (생산성과 직결)
범용성: 커뮤니티/생태계가 충분한가

실무에서는 친밀성과 범용성이 가장 현실적인 선택 기준이 된다. 아무리 성능이 좋은 언어라도 팀이 모르면 유지보수 비용이 급격히 올라간다.

2. 개발 패턴과 방법

소프트웨어 아키텍처란

SW 아키텍처는 시스템을 구성하는 요소들이 어떻게 연결되고 상호작용하는지를 표현하는 구조다. 코드를 짜기 전에 "어떤 구조로 만들 것인가"를 결정하는 설계 단계에서 핵심 역할을 한다.

품질 속성은 세 가지 측면에서 바라본다.

시스템 측면: 성능, 보안, 가용성, 안정성
비즈니스 측면: 출시 일정, 비용, 시장 요구
아키텍처 측면: 개념적 무결성, 정확성

아키텍처 설계 원칙

모듈화는 시스템을 기능 단위로 쪼개는 것이다. 각 모듈이 독립적일수록 수정 시 파급 범위를 줄일 수 있다.

추상화는 큰 그림부터 그리고 점차 구체화하는 방식이다. 세 가지로 나뉜다.

과정 추상화: "어떻게"보다 "무엇을" 하는지에 집중 (함수 시그니처 정의)
자료 추상화: 데이터 내부 구조를 숨김 (클래스, DTO)
제어 추상화: 실행 흐름의 세부 내용을 숨김 (이벤트 루프, 스케줄러)

정보 은닉은 캡슐화와 연결되는 개념이다. 모듈 내부 구현을 외부에서 직접 접근하거나 수정하지 못하도록 막는다. 실무에서는 private 메서드, 내부 패키지 분리, API 게이트웨이 같은 형태로 적용된다.

단계적 분해는 상위 개념에서 하위 개념으로 순차적으로 구체화하는 Top-Down 접근 방식이다.

상위 설계 vs 하위 설계

구분	다른 이름	다루는 내용
상위 설계	아키텍처 설계 / 예비 설계	전체 구조, DB 스키마, 인터페이스 정의
하위 설계	모듈 설계 / 상세 설계	컴포넌트 내부, 자료구조, 알고리즘

상위 설계가 "건물의 평면도"라면, 하위 설계는 "각 방의 내부 도면"에 해당한다.

협약에 의한 설계 (Design by Contract)

컴포넌트가 정상 동작하기 위한 조건을 명시적으로 계약처럼 기술하는 방식이다.

선행 조건(Precondition): 이 함수를 호출하기 전에 만족해야 하는 조건 (예: 입력값이 null이 아닌 것)
결과 조건(Postcondition): 함수 실행 후 보장되는 상태 (예: 반환값은 항상 양수)
불변 조건(Invariant): 실행 전후에 항상 유지되어야 하는 조건 (예: 리스트의 길이는 음수가 될 수 없음)

def withdraw(account, amount):
    # 선행 조건
    assert amount > 0, "출금액은 0보다 커야 한다"
    assert account.balance >= amount, "잔액이 부족하다"

    account.balance -= amount

    # 결과 조건
    assert account.balance >= 0, "잔액은 음수가 될 수 없다"

아키텍처 패턴 정리

아키텍처 패턴은 시스템 전체 구조를 어떻게 잡을지에 대한 검증된 해법이다.

패턴	핵심 구조	대표 사례
레이어	계층별로 역할 분리, 인접 계층만 통신	Spring MVC (Presentation / Service / Repository)
클라이언트-서버	서버 1개 + 클라이언트 N개	웹 서비스 대부분
파이프-필터	데이터가 필터를 순서대로 통과	UNIX 쉘 파이프(`
MVC	Model / View / Controller 분리	Spring, Django, Rails
마스터-슬레이브	마스터가 작업 분배, 슬레이브가 처리	DB 복제, 분산 연산
브로커	브로커가 서비스 요청자와 제공자를 중개	Kafka, RabbitMQ
피어-투-피어	모든 노드가 클라이언트이자 서버	BitTorrent, 블록체인
이벤트-버스	퍼블리셔가 이벤트 발행, 구독자가 처리	푸시 알림, AWS SNS+SQS
블랙보드	공유 저장소에 모든 컴포넌트가 접근	음성 인식, AI 추론 시스템
인터프리터	기호/언어를 파싱해 실행	SQL 파서, 스크립트 엔진

시험 포인트: 파이프-필터의 대표 예시는 UNIX 쉘이다. 이벤트-버스는 퍼블리시/구독(Pub-Sub) 구조라는 점을 기억한다.

3. 객체 지향

핵심 개념 한눈에

객체 지향의 목표는 현실 세계의 사물을 소프트웨어 객체로 표현하고, 그 객체들이 서로 메시지를 주고받으며 동작하는 시스템을 만드는 것이다.

개념	한 줄 설명	실무 연결
객체	데이터 + 함수(메서드)의 묶음	클래스의 인스턴스
클래스	객체를 찍어내는 설계도	`class User { ... }`
메시지	객체에게 동작을 요청하는 것	메서드 호출
캡슐화	내부 구현 숨기고 인터페이스만 노출	`private` 필드 + getter/setter
상속	부모 클래스의 속성/메서드를 물려받음	`class Admin extends User`
다형성	같은 메서드 호출이 객체마다 다르게 동작	오버라이딩, 인터페이스 구현

// 다형성 예시
interface Shape {
    double area();
}

class Circle implements Shape {
    double radius;
    public double area() { return Math.PI * radius * radius; }
}

class Rectangle implements Shape {
    double w, h;
    public double area() { return w * h; }
}

// 같은 area() 호출이지만 객체에 따라 다르게 동작
Shape s1 = new Circle();
Shape s2 = new Rectangle();
s1.area(); // 원 넓이
s2.area(); // 직사각형 넓이

객체 간 연관성

표현	의미	예시
`is member of`	연관화 (상호 참조)	학생이 동아리에 속함
`is instance of`	분류화 (같은 클래스의 인스턴스)	홍길동은 User 클래스의 인스턴스
`is part of`	집단화 (전체-부분 관계)	엔진은 자동차의 일부
`is a`	일반화 / 특수화	관리자(Admin)는 사용자(User)다

객체 지향 분석 방법론

시험에서는 방법론별 키워드를 외우는 것이 핵심이다.

럼바우: 객동기 (객체 모델링 / 동적 모델링 / 기능 모델링)
부치: 미시적 / 거시적 개발 프로세스
제이콥슨: 유스케이스 중심
코드와 요르돈: E-R 다이어그램 활용
Wirfs-Brock: 분석과 설계 구분 없이 진행

SOLID 원칙

SOLID는 유지보수하기 좋은 객체 지향 설계를 위한 다섯 가지 원칙이다.

원칙	이름	핵심 내용
S	단일 책임 원칙 (SRP)	클래스는 하나의 책임만 가져야 한다
O	개방-폐쇄 원칙 (OCP)	확장에는 열려 있고, 수정에는 닫혀 있어야 한다
L	리스코프 치환 원칙 (LSP)	자식 클래스는 부모 클래스를 대체할 수 있어야 한다
I	인터페이스 분리 원칙 (ISP)	사용하지 않는 인터페이스에 의존하지 않아야 한다
D	의존 역전 원칙 (DIP)	구체 클래스보다 추상(인터페이스)에 의존해야 한다

4. 모듈

결합도와 응집도

모듈 품질을 평가하는 두 가지 축이다. 방향이 반대다.

결합도는 낮을수록, 응집도는 높을수록 좋은 설계다.

결합도 (낮은 것이 좋음): 자스제외공내

순서	종류	설명
1 (낮음)	자료(Data)	단순 데이터 값만 전달
2	스탬프(Stamp)	자료구조(객체, 배열 등)를 통째로 전달
3	제어(Control)	제어 플래그를 전달해 상대 모듈의 흐름을 제어
4	외부(External)	외부 모듈의 변수를 직접 참조
5	공통(Common)	전역 변수 공유
6 (높음)	내용(Content)	다른 모듈의 내부 코드/데이터를 직접 참조/수정

응집도 (높은 것이 좋음)

순서	종류	설명
1 (낮음)	우연(Coincidental)	아무 관계 없는 기능이 한 모듈에 묶임
2	논리(Logical)	유사한 성격의 기능을 묶음 (같은 타입의 입출력 처리 등)
3	시간적(Temporal)	특정 시점에 함께 실행되는 것들을 묶음 (초기화 루틴 등)
4	절차(Procedural)	순서대로 실행되어야 하는 기능들을 묶음
5	교통(Communication)	동일한 입출력 데이터를 다루는 기능들을 묶음
6	순차(Sequential)	앞 기능의 출력이 다음 기능의 입력이 되는 파이프라인 구조
7 (높음)	기능(Functional)	단 하나의 명확한 기능만 수행

팬인 / 팬아웃

모듈 구조도(구조 차트)에서 모듈 간 호출 관계를 나타내는 지표다.

팬인(Fan-in): 해당 모듈을 호출하는 모듈의 수 (들어오는 화살표)
팬아웃(Fan-out): 해당 모듈이 호출하는 모듈의 수 (나가는 화살표)

팬아웃이 너무 높으면 그 모듈이 너무 많은 책임을 지고 있다는 신호다. 반대로 팬인이 높은 모듈은 재사용성이 높은 핵심 모듈일 가능성이 있다.

IPC (Inter-Process Communication)

모듈 또는 프로세스 간에 데이터를 주고받는 방식이다.

방법	특징
공유 메모리	빠르지만 동기화 필요
소켓	네트워크 기반, 원격 통신 가능
세마포어	동시 접근 제어(잠금 역할)
파이프 / 네임드 파이프	단방향 / 양방향 데이터 스트림
메시지 큐	비동기 메시지 전달 (Kafka, RabbitMQ의 원형)

5. 테스트와 코드

테스트 케이스

테스트 케이스는 소프트웨어가 요구사항을 제대로 만족하는지 확인하기 위한 시험 항목 명세서다. 단순히 "실행해서 오류 없으면 OK"가 아니라, 어떤 입력에 어떤 결과가 나와야 하는지를 사전에 정의한다.

공통 모듈 명세 기법의 기준은 다섯 가지다.

정확성: 실제로 구현 가능한 내용인가
명확성: 이중 해석의 여지 없이 단일하게 이해되는가
완전성: 시스템이 갖춰야 할 모든 것을 기술했는가
일관성: 다른 명세와 충돌하지 않는가
추적성: 요구사항의 출처와 이유를 역추적할 수 있는가

재사용 단위

단위	설명
함수 / 객체	가장 작은 재사용 단위
컴포넌트	독립적으로 배포 가능한 기능 묶음
애플리케이션	전체 시스템을 통째로 재활용

코드 체계

코드는 데이터를 식별하고 분류하기 위한 기호 체계다.

코드 종류	예시	특징
순차 코드	1, 2, 3, 4	단순 일련번호
블록 코드	1001~1100	범위로 구분
10진 코드	1000: 공학, 2000: 문학	십진 분류법
그룹 분류 코드	1-01-001: 본사-총무부-인사계	계층 구조 표현
연상 코드	TV-40: 40인치 TV	의미를 직관적으로 표현
표의 숫자 코드	120-720-1500: 두께×폭×길이	수치 자체가 의미를 가짐
합성 코드	KE-711: 대한항공 711편	두 가지 이상 코드 결합

6. 디자인 패턴

디자인 패턴은 모듈 간 관계 및 인터페이스 설계에서 자주 반복되는 문제에 대한 검증된 해법이다. GoF(Gang of Four) 패턴이 가장 많이 쓰인다.

생성 패턴 (객체를 어떻게 만들 것인가)

패턴	핵심
추상 팩토리	관련 객체 그룹을 묶어서 생성
빌더	복잡한 객체를 단계별로 조립
팩토리 메소드	객체 생성을 서브 클래스에 위임
프로토타입	기존 객체를 복제해서 생성
싱글톤	인스턴스를 딱 하나만 유지

구조 패턴 (객체를 어떻게 조합할 것인가)

패턴	핵심
어댑터	호환되지 않는 인터페이스를 변환 (플러그 변환기와 같은 원리)
브리지	기능과 구현을 분리해 독립적으로 확장
컴포지트	단일 객체와 복합 객체를 동일하게 다룸 (트리 구조)
퍼사드	복잡한 서브시스템에 단순한 인터페이스 제공
플라이웨이트	유사 객체를 공유해 메모리 절약
프록시	실제 객체 앞에 대리 객체를 두어 접근 제어

행위 패턴은 이 자료의 범위에서는 생략한다.

7. 기타: 프레임워크와 배치

서버 개발 프레임워크

대부분의 서버 사이드 프레임워크는 MVC 구조를 기반으로 한다.

프레임워크	언어	특징
Spring	Java	국내 엔터프라이즈 환경에서 가장 널리 쓰임
Django	Python	빠른 개발, 배터리 포함 철학
Ruby on Rails	Ruby	CoC(설정보다 관례) 원칙
CodeIgniter	PHP	경량 PHP 프레임워크

API와 Open API

API(Application Programming Interface)는 라이브러리나 서비스를 외부에서 사용할 수 있도록 규칙을 정의한 인터페이스다. 그 중 외부에 공개된 것을 Open API라고 부른다. 카카오 지도 API, 기상청 날씨 API 등이 대표적이다.

배치 프로그램

배치는 "정해진 시간에 대량의 데이터를 자동으로 처리"하는 프로그램이다. 실시간으로 처리하기 부담스러운 작업을 새벽 시간대에 몰아서 처리하는 방식으로 많이 쓰인다.

배치 프로그램이 갖춰야 할 요소 다섯 가지:

대용량 데이터 처리 능력
자동화: 사람이 개입하지 않아도 실행
견고성: 예외 상황에서도 비정상 종료 없이 처리
안정성 / 신뢰성: 중복 실행, 누락 없이 정확하게 처리
성능: 정해진 시간 내에 완료

배치 스케줄러는 세 가지를 기억한다.

스케줄러	특징
Spring Batch	Java 기반, 대규모 배치 처리 표준 프레임워크
Quartz	Java 기반, 유연한 스케줄링
Cron	Unix/Linux 기반, 시간 기반 작업 자동화 (`0 0 * * *` 형태의 표현식)

# Cron 표현식 예시
# 분 시 일 월 요일
0 2 * * *    # 매일 새벽 2시에 실행
0 9 * * 1    # 매주 월요일 오전 9시에 실행
0 0 1 * *    # 매월 1일 자정에 실행

데이터와 DBMS 핵심 정리

Seum Lee — Mon, 25 May 2026 11:59:40 +0900

1. 데이터 전환과 검증

데이터 전환이란 기존 시스템의 데이터를 추출해 새 정보 시스템이 운영할 수 있는 형태로 변환한 뒤 적재하는 전 과정을 말한다. 단순 복사가 아니라 구조 변환과 품질 검증까지 포함한다.

데이터 검증은 원본 데이터가 목적 시스템에 정상적으로 옮겨졌는지 확인하는 단계다.

오류 데이터 처리는 아래 순서로 진행한다.

데이터 품질 분석
오류 데이터 측정
오류 데이터 정제

2. 데이터베이스

기본 개념

데이터베이스는 공동으로 사용될 데이터를 중복 없이 통합하고, 저장 장치에 보관하여 항상 접근 가능하도록 운영하는 데이터 집합이다. 네 가지 특성으로 요약된다.

통합된 데이터: 중복을 제거하여 하나로 관리
저장된 데이터: 물리적 저장 매체에 보관
운영 데이터: 조직의 업무 수행에 반드시 필요한 데이터
공용 데이터: 여러 사용자가 함께 사용

DBMS는 사용자 요구에 따라 데이터를 생성하고 데이터베이스를 관리하는 소프트웨어다. 세 가지 기능을 제공한다.

기능	언어	역할
정의 기능	DDL	구조 생성·변경·삭제
조작 기능	DML	데이터 삽입·조회·수정·삭제
제어 기능	DCL	접근 권한·무결성·보안·회복

스키마 3단계 구조

스키마는 데이터베이스의 구조와 제약 조건에 관한 전반적인 명세다. 외부·개념·내부 3단계로 나뉜다.

외부 스키마: 각 사용자가 필요로 하는 DB의 논리적 구조 정의. 여러 개 존재 가능.
개념 스키마: DB 전체의 논리적 구조. 조직 전체의 관점. 단 하나만 존재.
내부 스키마: 물리적 저장 장치 관점의 DB 구조. 실제 저장 방식을 기술.

DB 설계 순서

요구 조건 분석부터 구현까지 5단계로 진행한다.

단계	이름	핵심 활동
1	요구 조건 분석	사용자 요구 파악
2	개념적 설계	현실을 추상적 개념으로 표현. E-R 모델 작성
3	논리적 설계	DBMS가 지원하는 구조로 변환 (Mapping)
4	물리적 설계	논리 구조를 물리 구조로 변환. 저장 방식 결정
5	구현	SQL로 실제 DB 생성

E-R 모델

현실 세계의 데이터를 개념적 논리 구조로 표현하기 위한 모델이다. 아래 기호를 사용한다.

기호	의미
사각형	개체(Entity)
마름모	관계(Relationship)
타원	속성(Attribute)
이중 타원	다중값 속성
밑줄 타원	기본키 속성
복수 타원	복합 속성
선/링크	연결

개체(Entity)는 DB에 표현하려는 현실 세계의 대상체로, 유일한 식별자로 구분된다. 관계는 개체 간의 연관성을 나타내며 1:1, 1:N, N:M 세 가지로 구분한다.

릴레이션 구조

관계형 DB에서 테이블(릴레이션)을 구성하는 요소들이다.

┌──────┬────────┬──────┬──────────┐  ← 릴레이션 스키마 (속성의 집합)
│ 학번 │  이름  │ 학년 │  전공    │
├──────┼────────┼──────┼──────────┤
│ 1001 │ 홍길동 │  2   │ 컴퓨터   │  ← 튜플 (행 하나)
│ 1002 │ 이순신 │  3   │ 소프트웨어│  ← 튜플
└──────┴────────┴──────┴──────────┘
  ↑ 속성(Attribute) / 도메인: 각 속성이 취할 수 있는 값의 집합

카디널리티(기수): 튜플의 수 (행의 수)
디그리(차수): 속성의 수 (열의 수)

키의 종류

후보키: 유일성 + 최소성 모두 만족
기본키: 후보키 중 대표로 선택한 키. Not Null, 중복 불가.
대체키: 기본키로 선택되지 않은 나머지 후보키
슈퍼키: 유일성은 만족하지만 최소성은 만족하지 않는 키
외래키: 다른 릴레이션의 기본키를 참조하는 속성

무결성

데이터의 정확성과 일관성을 유지하기 위한 제약 조건이다.

개체 무결성: 기본키는 NULL이 될 수 없고, 중복될 수 없다.
참조 무결성: 외래키 값은 NULL이거나, 참조하는 릴레이션의 기본키 값과 동일해야 한다.

-- 개체 무결성 예시
CREATE TABLE Student (
    student_id INT PRIMARY KEY,  -- NOT NULL + UNIQUE 자동 적용
    name       VARCHAR(50)
);

-- 참조 무결성 예시
CREATE TABLE Enrollment (
    enroll_id  INT PRIMARY KEY,
    student_id INT,
    FOREIGN KEY (student_id) REFERENCES Student(student_id)
    -- Student 테이블에 없는 student_id는 삽입 불가
);

관계 대수

원하는 데이터를 어떻게 유도할지 절차적으로 기술하는 언어다.

연산자	기호	설명
Select	σ (시그마)	조건을 만족하는 튜플 추출 (수평 연산)
Project	π (파이)	원하는 속성만 추출 (수직 연산)
Join	⋈	두 릴레이션을 결합 (카티션 프로덕트 + 셀렉트)
Division	÷	R ÷ S: R에서 S의 속성을 제외한 나머지를 구함
합집합	∪	두 릴레이션의 합
교집합	∩	두 릴레이션의 공통 튜플
차집합	-	R에서 S에 있는 튜플 제거
교차곱	×	모든 가능한 튜플의 조합

-- Select (σ): 학년이 2인 학생만 조회
SELECT * FROM Student WHERE grade = 2;

-- Project (π): 이름과 전공만 조회
SELECT name, major FROM Student;

-- Join (⋈): 두 테이블 결합
SELECT * FROM Student JOIN Enrollment
    ON Student.student_id = Enrollment.student_id;

이상(Anomaly)과 정규화

정규화되지 않은 테이블에서는 삽입·삭제·갱신 시 이상 현상이 발생한다.

삽입 이상: 불필요한 데이터를 함께 입력해야만 삽입 가능한 현상
삭제 이상: 하나의 데이터를 삭제하면 관련 없는 데이터도 함께 사라지는 현상
갱신 이상: 일부 튜플만 수정되어 데이터 불일치가 생기는 현상

정규화는 이 이상 현상을 단계적으로 제거하는 과정이다.

단계	조건
제 1 정규형 (1NF)	모든 도메인이 원자값(더 이상 분해 불가)
제 2 정규형 (2NF)	1NF + 부분 함수 종속 제거
제 3 정규형 (3NF)	2NF + 이행적 함수 종속 제거
BCNF	3NF + 결정자이면서 후보키가 아닌 속성 제거
제 4 정규형 (4NF)	BCNF + 다치 종속 제거
제 5 정규형 (5NF)	4NF + 조인 종속성 이용

함수 종속: 속성 A의 값이 결정되면 속성 B의 값도 결정될 때, B는 A에 함수적으로 종속된다고 한다. (A → B)
이행적 함수 종속: A → B이고 B → C이면, A → C가 성립하는 관계.

반정규화

정규화된 모델을 의도적으로 역행시켜 성능을 높이는 기법이다. 조회 성능이 중요한 상황에서 쓰인다.

중복 테이블 추가: 자주 조인하는 테이블을 미리 합쳐서 별도로 관리
집계 테이블 추가: 합계·평균 같은 집계 데이터를 위한 테이블 생성 + 트리거로 자동 갱신
진행 테이블 추가: 이력 관리 목적
특정 부분 테이블 추가: 조건에 해당하는 행만 별도 테이블로 분리

시스템 카탈로그

데이터베이스 내 다양한 객체(테이블, 뷰, 인덱스, 사용자 등)에 관한 메타데이터를 담는 시스템 DB다. DBMS가 자동으로 관리하며, 사용자는 조회만 가능하다.

트랜잭션

논리적 기능을 수행하기 위한 작업 단위로, 한꺼번에 모두 수행되어야 할 일련의 연산이다. 네 가지 특성(ACID)을 가진다.

특성	설명
원자성 (Atomicity)	모두 실행되거나, 모두 실행되지 않아야 한다
일관성 (Consistency)	트랜잭션 완료 후에도 DB는 일관된 상태를 유지한다
독립성 (Isolation)	트랜잭션 수행 중 다른 트랜잭션이 끼어들 수 없다
영속성 (Durability)	완료된 트랜잭션 결과는 영구 반영된다

-- 트랜잭션 예시: 계좌 이체
BEGIN TRANSACTION;
    UPDATE Account SET balance = balance - 10000 WHERE id = 'A';
    UPDATE Account SET balance = balance + 10000 WHERE id = 'B';
COMMIT;  -- 둘 다 성공해야 반영
-- 중간에 오류 발생 시 ROLLBACK으로 전체 취소

CRUD 분석은 프로세스와 테이블 간의 Create·Read·Update·Delete 관계를 매트릭스로 정리해 트랜잭션 패턴을 파악하는 기법이다.

인덱스

데이터 레코드에 빠르게 접근하기 위해 <키 값, 포인터> 쌍으로 구성하는 데이터 구조다.

종류	특징
클러스터드 인덱스	키 순서에 따라 데이터 자체도 물리적으로 정렬. 테이블당 1개만 가능.
넌 클러스터드 인덱스	키 값만 정렬. 실제 데이터 위치는 포인터로 참조. 여러 개 생성 가능.

뷰 (View)

하나 이상의 기본 테이블로부터 유도된 가상 테이블이다. 실제 데이터를 저장하지 않고 쿼리 결과를 논리적으로 보여준다. CREATE VIEW와 DROP VIEW로 관리한다.

-- 뷰 생성 예시
CREATE VIEW cs_students AS
    SELECT name, grade FROM Student WHERE major = '컴퓨터';

-- 뷰 조회 (일반 테이블처럼 사용)
SELECT * FROM cs_students;

-- 뷰 삭제
DROP VIEW cs_students;

파티션

대용량 테이블이나 인덱스를 작은 논리 단위로 나누는 기법이다.

종류	설명	적합한 경우
범위 분할	값의 범위 기준으로 분할	월별·일별 데이터
해시 분할	해시 함수로 균등 분산	고객번호·주민번호처럼 데이터가 고른 컬럼
조합 분할	범위 분할 후 다시 해시 함수 적용	두 기준을 혼합해야 하는 경우

분산 데이터베이스의 투명성 목표

분산 환경에서 사용자가 내부 구조를 의식하지 않아도 되도록 보장하는 4가지 목표다.

목표	설명
위치 투명성	데이터가 어디 있는지 몰라도 논리적 명칭으로 접근 가능
중복 투명성	데이터가 여러 곳에 복제되어 있어도 하나처럼 보임
병행 투명성	다수 트랜잭션이 동시에 실행되어도 결과에 영향 없음
장애 투명성	일부 노드에 장애가 생겨도 트랜잭션이 정상 처리됨

3. 데이터 복구 및 보안

RTO / RPO

장애 발생 시 복구 목표를 정량화하는 두 가지 지표다.

RTO (Recovery Time Objective, 목표 복구 시간): 장애 발생 후 시스템이 정상 복구되기까지 허용되는 최대 시간
RPO (Recovery Point Objective, 목표 복구 시점): 장애 발생 시 어느 시점의 데이터까지 복구할 수 있어야 하는지의 기준

RTO가 짧을수록 빠른 복구를 보장해야 하고, RPO가 짧을수록 최신 데이터에 가깝게 복구해야 한다. 두 값이 모두 작을수록 복구 인프라 비용은 올라간다.

암호화

평문을 암호화(Encryption)하여 보호하고, 필요 시 복호화(Decryption)하여 원래 값을 복원하는 방식이다.

방식	키 구조	특징
개인키 암호화 (대칭키)	암호화·복호화에 같은 키 사용	속도 빠름. 키 배포 문제 있음.
공개키 암호화 (비대칭키)	공개키로 암호화, 개인키로 복호화	키 배포 안전. 속도 느림.

접근 통제

방식	영문	기준
임의 접근 통제	DAC (Discretionary AC)	사용자 신원에 따라 접근 권한 부여
강제 접근 통제	MAC (Mandatory AC)	주체와 객체의 보안 등급 비교 후 접근 허용
역할 기반 접근 통제	RBAC (Role-Based AC)	사용자의 역할에 따라 권한 부여

스토리지

대용량 데이터를 저장하기 위해 서버와 저장 장치를 연결하는 기술이다.

종류	연결 방식	특징
DAS (Direct Attached Storage)	전용 케이블로 직접 연결	단순하지만 공유 어려움
NAS (Network Attached Storage)	네트워크를 통해 연결	파일 공유에 유리
SAN (Storage Area Network)	별도 전용 네트워크 구성	DAS의 속도 + NAS의 공유 장점 혼합

4. 자료구조

선형 구조

데이터가 일렬로 나열된 구조다.

자료구조	특징
배열	크기와 형이 동일. 인덱스로 접근. 정적 자료구조.
선형 리스트	순서 있는 연속 구조
스택	LIFO (Last In, First Out). 함수 호출 스택, 괄호 검사 등에 활용.
큐	FIFO (First In, First Out). 프린터 스풀, 프로세스 스케줄링 등에 활용.
데크 (Deque)	양쪽 끝에서 삽입·삭제 모두 가능

# 스택 (LIFO)
stack = []
stack.append(1)  # push
stack.append(2)
stack.append(3)
print(stack.pop())  # 3 — 마지막에 넣은 것이 먼저 나옴

# 큐 (FIFO)
from collections import deque
queue = deque()
queue.append(1)  # enqueue
queue.append(2)
queue.append(3)
print(queue.popleft())  # 1 — 처음에 넣은 것이 먼저 나옴

비선형 구조

그래프

정점(Vertex)과 간선(Edge)으로 구성된 자료구조다. 방향·무방향 그래프로 나뉜다.

최대 간선 수:

방향 그래프: N(N-1)
무방향 그래프: N(N-1) / 2

트리

사이클이 없는 그래프다. 계층적 구조를 표현하는 데 적합하다.

용어	설명
루트 노드	트리의 최상위 노드
디그리	각 노드에서 뻗어나온 가지(자식)의 수
단말 노드	자식이 없는 노드 (리프 노드)
레벨	루트 노드가 레벨 1, 아래로 내려갈수록 증가
깊이	트리에서 노드가 가질 수 있는 최대 레벨

이진 트리 순회 3가지

순회	순서	위 트리 결과
Preorder (전위)	루트 → 왼 → 오른	A B D E C
Inorder (중위)	왼 → 루트 → 오른	D B E A C
Postorder (후위)	왼 → 오른 → 루트	D E B C A

class Node:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

def preorder(node):
    if node:
        print(node.val, end=' ')  # 루트
        preorder(node.left)        # 왼
        preorder(node.right)       # 오른

def inorder(node):
    if node:
        inorder(node.left)         # 왼
        print(node.val, end=' ')  # 루트
        inorder(node.right)        # 오른

def postorder(node):
    if node:
        postorder(node.left)       # 왼
        postorder(node.right)      # 오른
        print(node.val, end=' ')  # 루트

정렬 알고리즘

1. 정렬 개요

정렬(Sort)은 데이터를 특정 기준에 따라 순서대로 나열하는 연산이다. 알고리즘마다 시간 복잡도, 공간 복잡도, 안정성이 다르기 때문에 상황에 따라 선택 기준이 달라진다.

안정 정렬(Stable Sort): 동일한 키 값을 가진 요소들의 상대적 순서가 정렬 후에도 유지되는 정렬.

시간 복잡도 요약:

정렬	최선	평균	최악	공간	안정
버블 정렬	O(n)	O(n²)	O(n²)	O(1)	✓
선택 정렬	O(n²)	O(n²)	O(n²)	O(1)	✗
삽입 정렬	O(n)	O(n²)	O(n²)	O(1)	✓
셸 정렬	O(n)	O(n^1.5)	O(n²)	O(1)	✗
퀵 정렬	O(n log n)	O(n log n)	O(n²)	O(log n)	✗
합병 정렬	O(n log n)	O(n log n)	O(n log n)	O(n)	✓
힙 정렬	O(n log n)	O(n log n)	O(n log n)	O(1)	✗
기수 정렬	O(kn)	O(kn)	O(kn)	O(n+k)	✓

2. 교환 기반 정렬

버블 정렬 (Bubble Sort)

인접한 두 원소를 비교해 순서가 맞지 않으면 교환한다. 한 패스가 끝날 때마다 가장 큰 값이 맨 뒤로 이동한다. 구현이 단순하지만 효율은 낮은 편이다.

이미 정렬된 배열에서는 교환이 발생하지 않으면 조기 종료할 수 있어 최선의 경우 O(n)이 된다.

초기: [5, 3, 8, 1, 2]

1패스:
[3, 5, 8, 1, 2]  → 5↔3
[3, 5, 8, 1, 2]  → 5<8, 유지
[3, 5, 1, 8, 2]  → 8↔1
[3, 5, 1, 2, 8]  → 8↔2  ← 8이 맨 뒤로 확정

2패스:
[3, 5, 1, 2, 8]  → 3<5, 유지
[3, 1, 5, 2, 8]  → 5↔1
[3, 1, 2, 5, 8]  → 5↔2  ← 5 확정
...

def bubble_sort(arr):
    n = len(arr)
    for i in range(n - 1):
        swapped = False
        for j in range(n - 1 - i):   # 이미 정렬된 뒷부분은 건너뜀
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                swapped = True
        if not swapped:               # 교환 없으면 이미 정렬된 상태
            break
    return arr

선택 정렬 (Selection Sort)

전체에서 가장 작은(또는 큰) 원소를 찾아 맨 앞 원소와 교환한다. 패스마다 정렬 범위가 하나씩 줄어든다. 비교 횟수는 항상 동일하므로 최선·최악 모두 O(n²)다.

초기: [5, 3, 8, 1, 2]

1패스: 최솟값 1 → 인덱스 0의 5와 교환
[1, 3, 8, 5, 2]

2패스: 나머지 [3,8,5,2]에서 최솟값 2 → 인덱스 1의 3과 교환
[1, 2, 8, 5, 3]

3패스: [8,5,3]에서 최솟값 3 → 8과 교환
[1, 2, 3, 5, 8]

4패스: [5,8]에서 최솟값 5 → 유지
[1, 2, 3, 5, 8]  ← 완료

def selection_sort(arr):
    n = len(arr)
    for i in range(n - 1):
        min_idx = i
        for j in range(i + 1, n):      # 남은 범위에서 최솟값 탐색
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]  # 최솟값을 앞으로
    return arr

퀵 정렬 (Quick Sort)

피벗(pivot)을 기준으로 피벗보다 작은 것은 왼쪽, 큰 것은 오른쪽으로 분할한 뒤, 각 부분을 재귀적으로 정렬한다. 평균적으로 가장 빠른 정렬 중 하나이나, 피벗 선택이 나쁘면 최악 O(n²)이 될 수 있다.

초기: [5, 3, 8, 1, 2]  ← 피벗: 5

분할:
좌: [3, 1, 2]  (5보다 작은 것)
피벗: [5]
우: [8]        (5보다 큰 것)

좌측 [3, 1, 2] 재귀 정렬 ← 피벗: 3
  좌: [1, 2] → 피벗: 1 → [1, 2]
  피벗: [3]
  우: []

결과 조합: [1, 2, 3, 5, 8]

def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]          # 중간값을 피벗으로 선택
    left  = [x for x in arr if x < pivot]
    mid   = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quick_sort(left) + mid + quick_sort(right)

3. 삽입 기반 정렬

삽입 정렬 (Insertion Sort)

현재 원소를 이미 정렬된 앞부분의 적절한 위치에 삽입한다. 데이터가 거의 정렬된 상태라면 매우 효율적이고, 소규모 데이터에서 실용적인 편이다.

초기: [5, 3, 8, 1, 2]

i=1: 3을 [5] 사이에 삽입 → [3, 5, 8, 1, 2]
i=2: 8은 5보다 크므로 유지 → [3, 5, 8, 1, 2]
i=3: 1을 [3,5,8] 앞에 삽입 → [1, 3, 5, 8, 2]
i=4: 2를 [1,3,5,8] 사이에 삽입 → [1, 2, 3, 5, 8]

def insertion_sort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and arr[j] > key:  # 정렬된 부분을 오른쪽으로 밀기
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key                # 적절한 위치에 삽입
    return arr

셸 정렬 (Shell Sort)

삽입 정렬의 개선판이다. 간격(gap)을 두고 떨어진 원소들끼리 먼저 정렬한 다음, 간격을 줄여가며 최종적으로 gap=1인 삽입 정렬로 마무리한다. 삽입 정렬의 단점인 "먼 거리 이동"을 줄이는 것이 핵심이다.

초기: [8, 3, 5, 1, 9, 2, 7, 4]  gap=4

gap=4: [8,9], [3,2], [5,7], [1,4] 각각 정렬
→ [8, 2, 5, 1, 9, 3, 7, 4]

gap=2: [8,5,9,7], [2,1,3,4] 각각 정렬
→ [5, 1, 7, 2, 8, 3, 9, 4]

gap=1: 일반 삽입 정렬
→ [1, 2, 3, 4, 5, 7, 8, 9]

def shell_sort(arr):
    n = len(arr)
    gap = n // 2
    while gap > 0:
        for i in range(gap, n):
            temp = arr[i]
            j = i
            while j >= gap and arr[j - gap] > temp:
                arr[j] = arr[j - gap]
                j -= gap
            arr[j] = temp
        gap //= 2
    return arr

4. 분할 정복 / 트리 기반 정렬

합병 정렬 (Merge Sort)

배열을 절반으로 계속 나누고, 정렬된 부분을 합치는(Merge) 방식이다. 항상 O(n log n)을 보장하고 안정 정렬이지만, 합치는 과정에서 추가 메모리 O(n)이 필요하다.

초기: [5, 3, 8, 1, 2]

분할:
[5, 3] [8, 1, 2]
[5][3] [8][1, 2]
       [8][1][2]

합병:
[3, 5]    [1, 2] → [1, 2, 8]
[1, 2, 3, 5, 8]

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left  = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)

def merge(left, right):
    result = []
    i = j = 0
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:     # <= 이므로 안정 정렬
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result.extend(left[i:])
    result.extend(right[j:])
    return result

힙 정렬 (Heap Sort)

최대 힙(Max Heap) 자료구조를 이용한다. 전체를 힙으로 만든 뒤, 루트(최댓값)를 맨 뒤로 보내고 힙을 재구성하는 과정을 반복한다. 추가 메모리 없이 O(n log n)을 보장하지만 안정 정렬은 아니다.

초기: [5, 3, 8, 1, 2]

힙 구성(heapify):
        8
       / \
      3   5
     / \
    1   2

루트(8) 추출 → 맨 뒤로:
[3, 2, 5, 1, | 8]

다시 힙 구성 → 루트(5) 추출:
[3, 2, 1, | 5, 8]

반복 후 결과: [1, 2, 3, 5, 8]

def heap_sort(arr):
    n = len(arr)

    # 최대 힙 구성
    for i in range(n // 2 - 1, -1, -1):
        heapify(arr, n, i)

    # 루트를 맨 뒤로 보내며 반복
    for i in range(n - 1, 0, -1):
        arr[0], arr[i] = arr[i], arr[0]   # 최댓값을 맨 뒤로
        heapify(arr, i, 0)                 # 나머지를 다시 힙으로

    return arr

def heapify(arr, n, i):
    largest = i
    left    = 2 * i + 1
    right   = 2 * i + 2
    if left  < n and arr[left]  > arr[largest]: largest = left
    if right < n and arr[right] > arr[largest]: largest = right
    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]
        heapify(arr, n, largest)

5. 비교 없는 정렬

기수 정렬 (Radix Sort)

원소를 직접 비교하지 않고, 자릿수(1의 자리 → 10의 자리 → …) 순서로 정렬을 반복한다. 키의 자릿수 k와 데이터 수 n에 따라 O(kn)의 시간 복잡도를 가진다. 정수나 고정 길이 문자열에 효과적이다.

초기: [170, 45, 75, 90, 802, 24, 2, 66]

1의 자리 기준 정렬:
[170, 90, 802, 2, 24, 45, 75, 66]

10의 자리 기준 정렬:
[802, 2, 24, 45, 66, 170, 75, 90]

100의 자리 기준 정렬:
[2, 24, 45, 66, 75, 90, 170, 802]  ← 완료

def radix_sort(arr):
    max_val = max(arr)
    exp = 1                          # 1의 자리부터 시작
    while max_val // exp > 0:
        counting_sort_by_digit(arr, exp)
        exp *= 10
    return arr

def counting_sort_by_digit(arr, exp):
    n = len(arr)
    output  = [0] * n
    count   = [0] * 10              # 0~9 자릿수 버킷

    for i in range(n):
        digit = (arr[i] // exp) % 10
        count[digit] += 1

    for i in range(1, 10):          # 누적 합
        count[i] += count[i - 1]

    for i in range(n - 1, -1, -1):  # 뒤에서부터 채워야 안정 정렬 유지
        digit = (arr[i] // exp) % 10
        output[count[digit] - 1] = arr[i]
        count[digit] -= 1

    for i in range(n):
        arr[i] = output[i]

5. 통합 구현

개요

통합 구현은 송수신 모듈과 중계 모듈 간의 연계를 구현하는 것이다. 구성 요소는 송수신 시스템, 모듈, 중계 시스템, 연계 데이터, 네트워크다.

연계 메커니즘 흐름

데이터 생성 및 추출 → 코드 매핑 및 데이터 변환 → 인터페이스 테이블 또는 파일 생성 → 연계 서버 또는 송신 어댑터

연계 방식은 직접 연계와 간접 연계 두 가지로 나뉜다.

시스템별 역할

송신 시스템: 인터페이스 테이블 또는 파일의 데이터를 전송 형식에 맞게 변환하고 송신
수신 시스템: 수신한 데이터를 인터페이스 테이블이나 파일로 생성
연계 서버: 모든 중계 처리를 수행

연계 테스트 순서: 케이스 작성 → 환경 구축 → 수행 → 검증

연계 데이터 보안은 전송 구간 보안과 데이터 자체 보안 두 축으로 관리한다.

부록 — 키 개념 비교 정리

정규화 단계 요약

단계	제거 대상	키워드
1NF	비원자값	원자값
2NF	부분 함수 종속	완전 함수 종속
3NF	이행적 함수 종속	A→B→C 제거
BCNF	결정자 ≠ 후보키	모든 결정자가 후보키
4NF	다치 종속
5NF	조인 종속

분산 DB 투명성 암기 포인트

위치·중복·병행·장애 — "위중병장" 으로 묶어 기억하면 편하다.

스토리지 3종 비교

부록 — 정렬 선택 가이드

상황별 권장 정렬

상황	권장 정렬	이유
데이터가 거의 정렬되어 있음	삽입 정렬	최선 O(n), 구현 단순
범용·대규모 데이터	퀵 정렬	평균 O(n log n), 캐시 효율 좋음
최악도 O(n log n) 보장 필요	합병 정렬 / 힙 정렬	항상 O(n log n)
안정 정렬이 필요	합병 정렬	안정 + O(n log n) 보장
정수·고정 길이 키	기수 정렬	O(kn), 비교 불필요
메모리 제약 있음	힙 정렬	추가 메모리 O(1)

핵심 암기 포인트

버블·선택·삽입: 단순 정렬. 평균 O(n²). 소규모에 적합.
퀵·합병·힙: 고급 정렬. 평균 O(n log n).
합병 정렬만 안정 + O(n log n) 최악 보장을 동시에 만족.
힙 정렬만 추가 메모리 없이 O(n log n) 최악 보장.
기수 정렬: 비교 없이 정렬. 조건(정수 or 고정 키)이 맞으면 가장 빠를 수 있다.

소프트웨어 디자인 패턴 핵심 정리 (with Python)

Seum Lee — Mon, 25 May 2026 10:52:55 +0900

디자인 패턴 정리

1. 생성 패턴 (Creational Patterns)

객체 생성 방식을 추상화해서 코드와 생성 로직을 분리한다.

1-1. 추상 팩토리 (Abstract Factory)

서로 연관·의존하는 객체 그룹을 하나의 팩토리로 묶어 생성한다.
구체 클래스를 지정하지 않고 인터페이스만으로 객체 집합을 교체할 수 있다.

from abc import ABC, abstractmethod

class Button(ABC):
    @abstractmethod
    def render(self): ...

class Checkbox(ABC):
    @abstractmethod
    def render(self): ...

class WindowsButton(Button):
    def render(self): return "Windows Button"

class WindowsCheckbox(Checkbox):
    def render(self): return "Windows Checkbox"

class MacButton(Button):
    def render(self): return "Mac Button"

class MacCheckbox(Checkbox):
    def render(self): return "Mac Checkbox"

class GUIFactory(ABC):
    @abstractmethod
    def create_button(self) -> Button: ...
    @abstractmethod
    def create_checkbox(self) -> Checkbox: ...

class WindowsFactory(GUIFactory):
    def create_button(self): return WindowsButton()
    def create_checkbox(self): return WindowsCheckbox()

class MacFactory(GUIFactory):
    def create_button(self): return MacButton()
    def create_checkbox(self): return MacCheckbox()

# 사용
factory: GUIFactory = WindowsFactory()
print(factory.create_button().render())    # Windows Button
print(factory.create_checkbox().render())  # Windows Checkbox

1-2. 빌더 (Builder)

복잡한 객체의 생성 과정을 단계별로 분리한다.
같은 생성 절차로 다른 표현의 객체를 만들 수 있다.

class Car:
    def __init__(self):
        self.engine = None
        self.seats = None

    def __repr__(self):
        return f"Car(engine={self.engine}, seats={self.seats})"

class CarBuilder:
    def __init__(self):
        self._car = Car()

    def set_engine(self, engine: str):
        self._car.engine = engine
        return self  # 메서드 체이닝 지원

    def set_seats(self, seats: int):
        self._car.seats = seats
        return self

    def build(self) -> Car:
        return self._car

# 사용
car = CarBuilder().set_engine("V8").set_seats(4).build()
print(car)  # Car(engine=V8, seats=4)

1-3. 팩토리 메소드 (Factory Method)

객체 생성을 서브클래스에 위임한다.
상위 클래스는 인터페이스만 정의하고, 실제 인스턴스화는 서브클래스가 담당한다.

from abc import ABC, abstractmethod

class Transport(ABC):
    @abstractmethod
    def deliver(self) -> str: ...

class Truck(Transport):
    def deliver(self): return "트럭으로 육상 배송"

class Ship(Transport):
    def deliver(self): return "배로 해상 배송"

class Logistics(ABC):
    @abstractmethod
    def create_transport(self) -> Transport: ...

    def plan_delivery(self):
        transport = self.create_transport()
        return transport.deliver()

class RoadLogistics(Logistics):
    def create_transport(self): return Truck()

class SeaLogistics(Logistics):
    def create_transport(self): return Ship()

# 사용
for logistics in [RoadLogistics(), SeaLogistics()]:
    print(logistics.plan_delivery())
# 트럭으로 육상 배송
# 배로 해상 배송

1-4. 프로토타입 (Prototype)

기존 객체를 복제해서 새 객체를 만든다.
초기화 비용이 크거나 외부 의존성이 많은 객체에 유용하다.

import copy

class DatabaseConnection:
    def __init__(self, host: str, port: int):
        self.host = host
        self.port = port
        # 실제로는 여기서 무거운 초기화 작업이 일어난다고 가정
        self.config = {"timeout": 30, "retry": 3}

    def clone(self):
        return copy.deepcopy(self)

    def __repr__(self):
        return f"DB({self.host}:{self.port}, config={self.config})"

# 무거운 초기화는 최초 1회만
original = DatabaseConnection("localhost", 5432)

# 이후에는 복제로 비용 절감
replica = original.clone()
replica.port = 5433
replica.config["timeout"] = 60

print(original)  # DB(localhost:5432, config={'timeout': 30, 'retry': 3})
print(replica)   # DB(localhost:5433, config={'timeout': 60, 'retry': 3})

1-5. 싱글톤 (Singleton)

클래스의 인스턴스가 단 하나만 존재하도록 보장한다.
전역 접근점을 제공하며, 설정 관리자·로거·DB 커넥션 풀에서 자주 쓰인다.

class AppConfig:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance.settings = {}
        return cls._instance

    def set(self, key, value):
        self.settings[key] = value

    def get(self, key):
        return self.settings.get(key)

# 사용
config1 = AppConfig()
config1.set("debug", True)

config2 = AppConfig()
print(config2.get("debug"))      # True — 같은 인스턴스
print(config1 is config2)        # True

2. 구조 패턴 (Structural Patterns)

클래스와 객체를 조합해서 더 큰 구조를 만든다.

2-1. 어댑터 (Adapter)

호환되지 않는 인터페이스를 클라이언트가 기대하는 형태로 변환한다.
기존 코드를 수정하지 않고 새 인터페이스에 맞게 연결할 때 쓴다.

class KoreanPayment:
    """기존 한국 결제 모듈 — 인터페이스가 다름"""
    def korean_pay(self, amount: int) -> str:
        return f"한국 결제: {amount}원"

class PaymentGateway:
    """클라이언트가 기대하는 인터페이스"""
    def pay(self, amount: float) -> str: ...

class PaymentAdapter(PaymentGateway):
    def __init__(self, korean_payment: KoreanPayment):
        self._payment = korean_payment

    def pay(self, amount: float) -> str:
        krw = int(amount * 1350)  # USD → KRW 변환
        return self._payment.korean_pay(krw)

# 사용
adapter = PaymentAdapter(KoreanPayment())
print(adapter.pay(10.0))  # 한국 결제: 13500원

2-2. 브리지 (Bridge)

추상화(Abstraction)와 구현(Implementation)을 독립적으로 변경할 수 있도록 분리한다.
상속 대신 합성을 사용해서 두 축의 변화를 각자 확장한다.

from abc import ABC, abstractmethod

class Renderer(ABC):
    @abstractmethod
    def render_shape(self, name: str) -> str: ...

class VectorRenderer(Renderer):
    def render_shape(self, name): return f"벡터로 {name} 렌더링"

class RasterRenderer(Renderer):
    def render_shape(self, name): return f"래스터로 {name} 렌더링"

class Shape(ABC):
    def __init__(self, renderer: Renderer):
        self.renderer = renderer

    @abstractmethod
    def draw(self) -> str: ...

class Circle(Shape):
    def draw(self): return self.renderer.render_shape("원")

class Square(Shape):
    def draw(self): return self.renderer.render_shape("사각형")

# 사용 — 추상(도형)과 구현(렌더러)을 독립적으로 조합
print(Circle(VectorRenderer()).draw())   # 벡터로 원 렌더링
print(Square(RasterRenderer()).draw())   # 래스터로 사각형 렌더링

2-3. 컴포지트 (Composite)

단일 객체와 복합 객체를 동일한 인터페이스로 다룬다.
파일 시스템처럼 트리 구조로 구성된 대상에 적합하다.

from abc import ABC, abstractmethod

class FileSystemItem(ABC):
    def __init__(self, name: str):
        self.name = name

    @abstractmethod
    def size(self) -> int: ...

class File(FileSystemItem):
    def __init__(self, name: str, size: int):
        super().__init__(name)
        self._size = size

    def size(self): return self._size

class Directory(FileSystemItem):
    def __init__(self, name: str):
        super().__init__(name)
        self._children: list[FileSystemItem] = []

    def add(self, item: FileSystemItem):
        self._children.append(item)
        return self

    def size(self): return sum(c.size() for c in self._children)

# 사용 — 파일과 디렉토리를 구분 없이 처리
root = Directory("root")
root.add(File("README.md", 10))
src = Directory("src")
src.add(File("main.py", 50)).add(File("utils.py", 30))
root.add(src)

print(root.size())   # 90
print(src.size())    # 80

2-4. 퍼케이드 (Facade)

복잡한 서브시스템 위에 단순한 인터페이스를 제공한다.
내부 구조를 숨기고 클라이언트가 쉽게 사용할 수 있도록 창구 역할을 한다.

class Projector:
    def on(self): print("프로젝터 켜짐")
    def off(self): print("프로젝터 꺼짐")

class SoundSystem:
    def on(self): print("사운드 시스템 켜짐")
    def set_volume(self, v): print(f"볼륨 {v}으로 설정")

class StreamingPlayer:
    def play(self, title): print(f"'{title}' 재생 시작")
    def stop(self): print("재생 중지")

class HomeTheaterFacade:
    """복잡한 초기화를 한 메서드로 압축"""
    def __init__(self):
        self._proj = Projector()
        self._sound = SoundSystem()
        self._player = StreamingPlayer()

    def watch_movie(self, title: str):
        self._proj.on()
        self._sound.on()
        self._sound.set_volume(30)
        self._player.play(title)

    def end_movie(self):
        self._player.stop()
        self._proj.off()

# 사용
theater = HomeTheaterFacade()
theater.watch_movie("Inception")
theater.end_movie()

2-5. 플라이웨이트 (Flyweight)

대량의 유사 객체에서 공유 가능한 상태를 분리해 메모리를 절약한다.
불변 데이터(내재적 상태)를 공유하고, 가변 데이터(외재적 상태)는 외부에서 전달한다.

class TreeType:
    """공유되는 내재적 상태 — 무거운 텍스처 데이터"""
    def __init__(self, name: str, texture: str):
        self.name = name
        self.texture = texture  # 실제로는 수 MB의 이미지 데이터

    def draw(self, x: int, y: int):
        print(f"[{self.name}] 텍스처로 ({x},{y})에 그리기")

class TreeFactory:
    _cache: dict[str, TreeType] = {}

    @classmethod
    def get(cls, name: str, texture: str) -> TreeType:
        key = f"{name}:{texture}"
        if key not in cls._cache:
            cls._cache[key] = TreeType(name, texture)
            print(f"새 TreeType 생성: {name}")
        return cls._cache[key]

class Tree:
    """외재적 상태(좌표)만 보유"""
    def __init__(self, x: int, y: int, tree_type: TreeType):
        self.x = x
        self.y = y
        self.tree_type = tree_type

    def draw(self):
        self.tree_type.draw(self.x, self.y)

# 사용 — 1000그루를 심어도 TreeType은 2개만 생성
oak_type = TreeFactory.get("oak", "oak_texture.png")
pine_type = TreeFactory.get("pine", "pine_texture.png")

trees = [
    Tree(i * 10, i * 5, oak_type if i % 2 == 0 else pine_type)
    for i in range(10)
]
trees[0].draw()
trees[1].draw()

2-6. 프록시 (Proxy)

실제 객체 앞에 대리 객체를 두어 접근을 제어한다.
지연 초기화, 접근 권한 제어, 캐싱, 로깅 등에 활용한다.

from abc import ABC, abstractmethod

class Database(ABC):
    @abstractmethod
    def query(self, sql: str) -> str: ...

class RealDatabase(Database):
    def query(self, sql: str) -> str:
        return f"결과: {sql} 실행 완료"

class CachingProxy(Database):
    """캐싱 + 접근 로깅"""
    def __init__(self):
        self._real = RealDatabase()
        self._cache: dict[str, str] = {}

    def query(self, sql: str) -> str:
        if sql in self._cache:
            print(f"[캐시 히트] {sql}")
            return self._cache[sql]
        print(f"[DB 조회] {sql}")
        result = self._real.query(sql)
        self._cache[sql] = result
        return result

# 사용
db = CachingProxy()
print(db.query("SELECT * FROM users"))  # [DB 조회]
print(db.query("SELECT * FROM users"))  # [캐시 히트]

3. 행위 패턴 (Behavioral Patterns)

객체 간의 책임 분배와 알고리즘 캡슐화를 다룬다.

3-1. 책임 연쇄 (Chain of Responsibility)

요청을 처리할 수 있는 객체들을 체인으로 연결한다.
각 핸들러는 처리하거나 다음 핸들러로 넘긴다. HTTP 미들웨어, 이벤트 버블링이 대표적이다.

from abc import ABC, abstractmethod

class Handler(ABC):
    def __init__(self):
        self._next: Handler | None = None

    def set_next(self, handler: "Handler") -> "Handler":
        self._next = handler
        return handler  # 체이닝용

    @abstractmethod
    def handle(self, request: dict) -> str | None: ...

class AuthHandler(Handler):
    def handle(self, request):
        if not request.get("token"):
            return "인증 실패"
        return self._next.handle(request) if self._next else None

class LogHandler(Handler):
    def handle(self, request):
        print(f"[LOG] 요청 수신: {request.get('action')}")
        return self._next.handle(request) if self._next else None

class BusinessHandler(Handler):
    def handle(self, request):
        return f"처리 완료: {request.get('action')}"

# 체인 구성
auth = AuthHandler()
log = LogHandler()
biz = BusinessHandler()
auth.set_next(log).set_next(biz)

print(auth.handle({"action": "create", "token": "abc"}))
# [LOG] 요청 수신: create
# 처리 완료: create

print(auth.handle({"action": "create"}))
# 인증 실패

3-2. 커맨드 (Command)

요청을 객체로 캡슐화한다.
요청의 큐잉, 로깅, 실행 취소(undo)가 필요할 때 사용한다.

from abc import ABC, abstractmethod

class Command(ABC):
    @abstractmethod
    def execute(self): ...
    @abstractmethod
    def undo(self): ...

class Light:
    def on(self): print("조명 켜짐")
    def off(self): print("조명 꺼짐")

class LightOnCommand(Command):
    def __init__(self, light: Light):
        self._light = light
    def execute(self): self._light.on()
    def undo(self): self._light.off()

class RemoteControl:
    def __init__(self):
        self._history: list[Command] = []

    def press(self, cmd: Command):
        cmd.execute()
        self._history.append(cmd)

    def undo(self):
        if self._history:
            self._history.pop().undo()

# 사용
remote = RemoteControl()
light = Light()
remote.press(LightOnCommand(light))  # 조명 켜짐
remote.undo()                        # 조명 꺼짐

3-3. 이터레이터 (Iterator)

컬렉션의 내부 구조를 노출하지 않고 순회한다.
Python의 __iter__ / __next__ 프로토콜이 이 패턴의 언어 수준 구현이다.

class NumberRange:
    """짝수만 반환하는 이터레이터"""
    def __init__(self, start: int, end: int):
        self.start = start
        self.end = end
        self.current = start

    def __iter__(self):
        self.current = self.start
        return self

    def __next__(self):
        while self.current <= self.end:
            val = self.current
            self.current += 1
            if val % 2 == 0:
                return val
        raise StopIteration

# 사용
for n in NumberRange(1, 10):
    print(n, end=" ")
# 2 4 6 8 10

3-4. 중재자 (Mediator)

객체들이 서로 직접 참조하지 않고 중재자를 통해 통신한다.
채팅 서버, UI 컴포넌트 간 조율, 항공 관제 시스템이 대표적이다.

from __future__ import annotations

class ChatRoom:
    def __init__(self):
        self._users: list[User] = []

    def add_user(self, user: User):
        user.mediator = self
        self._users.append(user)

    def broadcast(self, message: str, sender: User):
        for user in self._users:
            if user is not sender:
                user.receive(f"[{sender.name}] {message}")

class User:
    def __init__(self, name: str):
        self.name = name
        self.mediator: ChatRoom | None = None

    def send(self, message: str):
        self.mediator.broadcast(message, self)

    def receive(self, message: str):
        print(f"{self.name} 수신: {message}")

# 사용
room = ChatRoom()
alice, bob, charlie = User("Alice"), User("Bob"), User("Charlie")
for u in [alice, bob, charlie]:
    room.add_user(u)

alice.send("안녕하세요!")
# Bob 수신: [Alice] 안녕하세요!
# Charlie 수신: [Alice] 안녕하세요!

3-5. 메멘토 (Memento)

객체의 내부 상태를 캡슐화해서 저장하고, 나중에 복원한다.
실행 취소(undo), 스냅샷, 게임 세이브 포인트에 활용한다.

class Memento:
    def __init__(self, state: str):
        self._state = state

    def get_state(self) -> str:
        return self._state

class Editor:
    def __init__(self):
        self.content = ""

    def write(self, text: str):
        self.content += text

    def save(self) -> Memento:
        return Memento(self.content)

    def restore(self, memento: Memento):
        self.content = memento.get_state()

class History:
    def __init__(self):
        self._stack: list[Memento] = []

    def push(self, m: Memento): self._stack.append(m)
    def pop(self) -> Memento | None:
        return self._stack.pop() if self._stack else None

# 사용
editor = Editor()
history = History()

editor.write("첫 번째 문장. ")
history.push(editor.save())

editor.write("두 번째 문장. ")
history.push(editor.save())

editor.write("잘못된 내용...")
print(editor.content)  # 첫 번째 문장. 두 번째 문장. 잘못된 내용...

editor.restore(history.pop())
print(editor.content)  # 첫 번째 문장. 두 번째 문장.

3-6. 옵저버 (Observer)

한 객체(Subject)의 상태 변화를 여러 객체(Observer)에게 자동으로 알린다.
이벤트 시스템, 데이터 바인딩, pub-sub 아키텍처의 기반이다.

from abc import ABC, abstractmethod

class Observer(ABC):
    @abstractmethod
    def update(self, event: str): ...

class EventBus:
    def __init__(self):
        self._observers: list[Observer] = []

    def subscribe(self, observer: Observer):
        self._observers.append(observer)

    def unsubscribe(self, observer: Observer):
        self._observers.remove(observer)

    def notify(self, event: str):
        for obs in self._observers:
            obs.update(event)

class EmailNotifier(Observer):
    def update(self, event): print(f"[이메일] 이벤트 발생: {event}")

class SlackNotifier(Observer):
    def update(self, event): print(f"[슬랙] 이벤트 발생: {event}")

# 사용
bus = EventBus()
bus.subscribe(EmailNotifier())
bus.subscribe(SlackNotifier())
bus.notify("주문 완료")
# [이메일] 이벤트 발생: 주문 완료
# [슬랙] 이벤트 발생: 주문 완료

3-7. 상태 (State)

객체의 내부 상태에 따라 행동을 바꾼다.
조건문 분기 대신 상태 클래스를 교체하는 방식으로 동작한다.

from abc import ABC, abstractmethod

class OrderState(ABC):
    @abstractmethod
    def next(self, order: "Order"): ...

    @abstractmethod
    def status(self) -> str: ...

class IdleState(OrderState):
    def next(self, order):
        order.state = ProcessingState()
    def status(self): return "대기 중"

class ProcessingState(OrderState):
    def next(self, order):
        order.state = CompletedState()
    def status(self): return "처리 중"

class CompletedState(OrderState):
    def next(self, order):
        print("이미 완료된 주문")
    def status(self): return "완료"

class Order:
    def __init__(self):
        self.state: OrderState = IdleState()

    def next(self):
        self.state.next(self)

    def status(self) -> str:
        return self.state.status()

# 사용
order = Order()
print(order.status())  # 대기 중
order.next()
print(order.status())  # 처리 중
order.next()
print(order.status())  # 완료

3-8. 전략 (Strategy)

알고리즘을 별도 클래스로 캡슐화하고 런타임에 교체할 수 있도록 한다.
정렬 알고리즘, 결제 방법, 압축 방식처럼 "어떻게 할지"를 바꿔야 할 때 쓴다.

from abc import ABC, abstractmethod

class SortStrategy(ABC):
    @abstractmethod
    def sort(self, data: list) -> list: ...

class BubbleSort(SortStrategy):
    def sort(self, data):
        d = data[:]
        for i in range(len(d)):
            for j in range(len(d) - i - 1):
                if d[j] > d[j+1]:
                    d[j], d[j+1] = d[j+1], d[j]
        return d

class QuickSort(SortStrategy):
    def sort(self, data):
        if len(data) <= 1:
            return data
        pivot = data[0]
        left = [x for x in data[1:] if x <= pivot]
        right = [x for x in data[1:] if x > pivot]
        return self.sort(left) + [pivot] + self.sort(right)

class Sorter:
    def __init__(self, strategy: SortStrategy):
        self.strategy = strategy

    def sort(self, data: list) -> list:
        return self.strategy.sort(data)

# 런타임에 알고리즘 교체
data = [5, 3, 1, 4, 2]
sorter = Sorter(BubbleSort())
print(sorter.sort(data))  # [1, 2, 3, 4, 5]

sorter.strategy = QuickSort()
print(sorter.sort(data))  # [1, 2, 3, 4, 5]

3-9. 템플릿 메소드 (Template Method)

알고리즘의 골격을 상위 클래스에서 정의하고, 세부 단계는 서브클래스가 구현한다.
전체 흐름은 변하지 않고 일부 단계만 교체할 때 사용한다.

from abc import ABC, abstractmethod

class DataProcessor(ABC):
    def process(self):
        """골격 — 순서는 고정"""
        data = self.read_data()
        result = self.transform(data)
        self.write_data(result)

    @abstractmethod
    def read_data(self) -> list: ...

    @abstractmethod
    def transform(self, data: list) -> list: ...

    @abstractmethod
    def write_data(self, data: list): ...

class CsvProcessor(DataProcessor):
    def read_data(self):
        print("CSV 파일 읽기")
        return [1, 2, 3]

    def transform(self, data):
        return [x * 2 for x in data]

    def write_data(self, data):
        print(f"CSV 저장: {data}")

class JsonProcessor(DataProcessor):
    def read_data(self):
        print("JSON 파일 읽기")
        return [10, 20, 30]

    def transform(self, data):
        return [x + 1 for x in data]

    def write_data(self, data):
        print(f"JSON 저장: {data}")

# 사용
CsvProcessor().process()
# CSV 파일 읽기 → CSV 저장: [2, 4, 6]

JsonProcessor().process()
# JSON 파일 읽기 → JSON 저장: [11, 21, 31]

3-10. 방문자 (Visitor)

구조는 그대로 두고 새로운 연산을 추가한다.
기존 클래스를 수정하지 않고 외부에서 기능을 붙일 수 있다.

from abc import ABC, abstractmethod

class Visitor(ABC):
    @abstractmethod
    def visit_file(self, file: "FileNode"): ...
    @abstractmethod
    def visit_directory(self, directory: "DirectoryNode"): ...

class FileNode:
    def __init__(self, name: str, size: int):
        self.name = name
        self.size = size

    def accept(self, visitor: Visitor):
        visitor.visit_file(self)

class DirectoryNode:
    def __init__(self, name: str):
        self.name = name
        self.children = []

    def add(self, node): self.children.append(node)

    def accept(self, visitor: Visitor):
        visitor.visit_directory(self)
        for child in self.children:
            child.accept(visitor)

class SizeCalculator(Visitor):
    def __init__(self):
        self.total = 0

    def visit_file(self, file):
        self.total += file.size
        print(f"  파일: {file.name} ({file.size}KB)")

    def visit_directory(self, directory):
        print(f"디렉토리: {directory.name}")

# 사용
root = DirectoryNode("root")
root.add(FileNode("README.md", 10))
src = DirectoryNode("src")
src.add(FileNode("main.py", 50))
root.add(src)

calc = SizeCalculator()
root.accept(calc)
print(f"총 크기: {calc.total}KB")
# 총 크기: 60KB

3-11. 인터프리터 (Interpreter)

언어의 문법을 클래스 계층으로 표현하고, 해당 언어의 문장을 해석한다.
간단한 DSL, 쿼리 파서, 수식 계산기에서 사용한다.

from abc import ABC, abstractmethod

class Expression(ABC):
    @abstractmethod
    def interpret(self) -> int: ...

class NumberExpression(Expression):
    def __init__(self, value: int):
        self.value = value

    def interpret(self) -> int:
        return self.value

class AddExpression(Expression):
    def __init__(self, left: Expression, right: Expression):
        self.left = left
        self.right = right

    def interpret(self) -> int:
        return self.left.interpret() + self.right.interpret()

class MultiplyExpression(Expression):
    def __init__(self, left: Expression, right: Expression):
        self.left = left
        self.right = right

    def interpret(self) -> int:
        return self.left.interpret() * self.right.interpret()

# (3 + 4) * 2
expr = MultiplyExpression(
    AddExpression(NumberExpression(3), NumberExpression(4)),
    NumberExpression(2)
)
print(expr.interpret())  # 14

패턴 선택 가이드

상황	추천 패턴
객체 생성 방식을 바꿔야 함	팩토리 메소드 / 추상 팩토리
복잡한 객체를 단계별로 조립	빌더
초기화 비용이 큰 객체가 많이 필요	프로토타입
전역 단일 인스턴스 필요	싱글톤
인터페이스가 맞지 않는 기존 코드 재사용	어댑터
기능과 구현을 독립적으로 확장	브리지
트리 구조를 단일 인터페이스로 처리	컴포지트
복잡한 서브시스템을 단순하게 노출	퍼케이드
대량의 유사 객체로 메모리 절감	플라이웨이트
접근 제어 / 캐싱 / 지연 초기화	프록시
요청을 여러 핸들러 중 하나가 처리	책임 연쇄
요청을 객체화해 undo/큐잉 필요	커맨드
컬렉션 순회 방식을 캡슐화	이터레이터
객체 간 직접 참조를 없애고 싶음	중재자
상태 저장 / 복원이 필요	메멘토
상태 변화를 여러 객체에 자동 전파	옵저버
상태에 따라 동작이 달라짐	상태
알고리즘을 런타임에 교체	전략
알고리즘 골격은 고정, 세부만 변경	템플릿 메소드
구조 변경 없이 새 연산 추가	방문자
간단한 언어/문법 해석	인터프리터

Software 공학 핵심 정리 - 생명주기(SDLC) 및 방법론 등

Seum Lee — Mon, 25 May 2026 10:38:35 +0900

소프트웨어 공학 핵심 정리

1. 소프트웨어 생명 주기 (SDLC)

개요

소프트웨어 개발 과정을 체계적으로 나눈 것이다. 어떤 모형을 선택하느냐에 따라 팀 구조, 문서화 방식, 일정 산정 방식이 달라진다.

4가지 주요 모형 비교

모형	핵심 특징	단점
폭포수	단계가 순차적으로 진행, 이전 단계로 되돌아가기 어렵다	요구 변화에 경직됨
프로토타입	견본품을 먼저 만들어 최종 결과를 미리 확인한다	프로토타입을 실제 제품으로 오해할 수 있다
나선형	위험 분석을 반복하며 점진적으로 완성한다	관리가 복잡하다
애자일	짧은 반복 주기로 변화에 유연하게 대응한다	문서화가 부족해질 수 있다

폭포수 모형은 이처럼 단계가 한 방향으로 흐른다. 이전 단계로 되돌아가는 것이 구조적으로 어렵다는 점이 핵심 단점이다.

애자일 상세

애자일은 특정 방법론이 아니라 일종의 철학이다. 그 아래에 스크럼, XP, 칸반, 린, FDD 같은 구체적인 방법론들이 존재한다.

스크럼 (Scrum)

역할

PO (Product Owner): 제품 백로그 관리, 우선순위 결정
SM (Scrum Master): 팀의 장애물 제거, 프로세스 가이드
DT (Development Team): 실제 개발을 담당하는 팀원

진행 흐름

스프린트는 보통 1~4주 단위로 진행되며, 이 주기 안에서 계획, 개발, 검토, 회고가 모두 이루어진다.

XP (eXtreme Programming)

XP는 다섯 가지 가치를 기반으로 한다: 의사소통, 단순성, 용기, 존중, 피드백.

주요 실천 방법은 아래와 같다.

페어 프로그래밍: 두 명이 한 컴퓨터로 함께 코드를 작성한다
TDD (테스트 주도 개발): 코드보다 테스트를 먼저 작성한다
공동 코드 소유: 팀원 누구나 코드를 수정할 수 있다
지속적 통합 (CI): 코드를 자주 통합해 충돌을 미리 발견한다
리팩토링: 기능을 유지하면서 코드 구조를 지속적으로 개선한다
소규모 릴리즈: 작은 단위로 자주 배포한다

# TDD 예시: 테스트 먼저 작성
def test_add():
    assert add(2, 3) == 5  # 아직 add 함수가 없어도 테스트를 먼저 정의한다

# 그 다음 구현
def add(a, b):
    return a + b

2. 관리 시스템 선택 기준

시스템 선택 시 고려할 기준을 정리하면 아래와 같다.

시스템	주요 고려 요소
DBMS	가용성, 성능, 기술 지원, 구축 비용, 상호 호환성
WAS	가용성, 성능, 기술 지원, 구축 비용
오픈소스	라이선스 종류, 사용자 수, 기술의 지속 가능성

DBMS는 WAS에 비해 상호 호환성이 추가된다는 점이 차이다. 다른 시스템과의 연동 가능성까지 확인해야 한다는 뜻이다.

3. 요구사항

기능 vs 비기능

기능 요구사항: 시스템이 무엇을 해야 하는지에 대한 것. "로그인 기능을 제공한다", "검색 결과를 10개씩 보여준다" 같은 것들이다.
비기능 요구사항: 품질과 제약에 관한 것. "응답 시간이 1초 이내여야 한다", "HTTPS를 사용해야 한다" 같은 것들이다.

개발 프로세스

분석 단계: DFD와 자료 사전

DFD (Data Flow Diagram)는 데이터의 흐름과 변환 과정을 도형으로 표현하는 도구다. 구조적 분석에 사용된다.

DFD의 4가지 구성 요소:

프로세스: 데이터를 변환하는 처리 단위 (원으로 표현)
자료 흐름: 데이터의 이동 경로 (화살표)
자료 저장소: 데이터가 보관되는 곳 (이중 선)
단말: 시스템 외부의 입출력 주체 (사각형)

자료 사전 기호 요약:

기호	의미	예시
`=`	정의	주문 = 고객명 + 상품명
`+`	연결 (AND)	이름 + 전화번호
`( )`	생략 가능	(주소)
`[ ]`	선택 (OR)	[현금\|카드]
`{ }`	반복	{주문 항목}
` `	설명/주석	배송 상태 코드

명세 단계

정형 명세 기법: VDM, Z, Petri-net, CSP. 수학적 표기를 사용해 정밀하게 표현한다.
비정형 명세 기법: FSM, Decision Table, ER 모델링, State Chart. 더 직관적이며 현업에서 자주 쓰인다.

4. UML

개요

UML은 객체지향 설계를 시각적으로 표현하기 위한 표준 모델링 언어다. 럼바우, 부치, 제이콥슨의 방법론을 통합해서 만들어졌다.

세 가지 구성 요소는 사물(Things), 다이어그램(Diagram), 관계(Relationships)다.

다이어그램 분류

주요 다이어그램 정리

유스케이스 다이어그램

시스템이 제공하는 기능과 그 기능을 사용하는 액터(사용자 또는 외부 시스템)를 표현한다.

관계의 방향이 헷갈리기 쉬운 부분:

포함 관계 (include): 기존 유스케이스에서 새로 만든 유스케이스로 점선 화살표가 향한다. "반드시 포함된다"는 의미다.
확장 관계 (extend): 확장하는 유스케이스에서 원래 유스케이스 방향으로 점선 화살표가 향한다. "조건에 따라 추가된다"는 의미다.

시퀀스 vs 커뮤니케이션

둘 다 객체 간 메시지 흐름을 표현하지만, 시퀀스는 시간 순서를, 커뮤니케이션은 객체 간 연관 관계를 더 강조한다.

활동 다이어그램의 노드 구분

노드 이름이 비슷해 헷갈리기 쉽다.

노드	모양	의미
조건 노드	마름모	나가는 흐름이 2개 이상
병합 노드	마름모	들어오는 흐름이 2개 이상
포크 노드	두꺼운 가로선	병렬 분기 시작 (나가는 흐름 2+)
조인 노드	두꺼운 가로선	병렬 흐름 합류 (들어오는 흐름 2+)
스윔 레인	구분선	행위 주체를 구분하는 영역

관계 정리

관계를 정리하면 아래와 같다.

연관: 서로 관련된 관계. 실선.
집합: 부분이 전체에 포함되지만, 독립적으로 존재 가능. 속이 빈 마름모.
포함(Composition): 부분이 전체에 종속됨. 전체가 사라지면 부분도 사라진다. 속이 찬 마름모.
일반화: 상속 관계. 속이 빈 실선 화살표.
의존: 짧은 시간만 연관. 점선 화살표.
실체화: 인터페이스 구현. 속이 빈 점선 화살표.

5. 개발 방법론 및 비용 산정

방법론 비교

방법론	핵심 개념
객체지향	객체를 조립해 시스템 구성
컴포넌트 기반 (CBD)	기존 컴포넌트를 재조합해 새 시스템 구성
소프트웨어 재사용	검증된 SW를 다른 개발에 활용
소프트웨어 재공학	기존 시스템을 분석해 더 나은 시스템으로 재구성

소프트웨어 재사용은 두 가지 방식이 있다. 합성 중심은 블록을 조립하듯 완성하고, 생성 중심은 추상화된 명세를 구체화해 생성한다.

비용 산정 기법

LOC 공식

COCOMO 유형

조직형: 5만 라인 이하, 소규모 팀
반분리형: 30만 라인 이하, 중간 규모
임베디드형: 30만 라인 초과, 복잡한 하드웨어 연계 환경

일정 관리 도구

PERT: 불확실한 상황에서 완료 시기를 확률적으로 예측한다. 낙관, 가능성, 비관 세 가지 시나리오를 활용한다.
CPM: 전체 작업 네트워크에서 가장 긴 경로(임계 경로)를 찾는다. 이 경로가 전체 프로젝트 기간을 결정한다.
간트 차트: 작업별 일정을 막대 형태로 시각화한 표다.

소프트웨어 품질 및 평가 모델

모델	특징
ISO/IEC 12207	생명 주기 프로세스 표준. 기본/지원/조직 프로세스로 구성
CMMI	조직의 프로세스 성숙도를 5단계로 평가
SPICE (ISO/IEC 15504)	소프트웨어 프로세스 수행 능력을 6단계로 평가

CMMI 5단계 (초관정정최): 초기 → 관리 → 정의 → 정량적 관리 → 최적화

SPICE 6단계: 불완전 → 수행 → 관리 → 확립 → 예측 → 최적화

스테레오 타입

UML 기본 표기 외에 추가 의미를 부여할 때 사용한다. <<interface>>, <<abstract>> 같은 형식으로 표현한다.

<<interface>>
PaymentGateway

부록 — 개발 프레임워크와 CASE

CASE (Computer-Aided Software Engineering)

SW 개발 과정의 전부 또는 일부를 자동화하는 도구다. 분석 단계에서 쓰이는 CASE 도구로는 SADT, SREM, PSL/PSA, TAGS 등이 있다.

SADT: SoftTech 사가 개발. 시스템 정의와 요구사항 분석에 활용.
HIPO: 입력-처리-출력 기능을 계층 구조로 표현. 하향식 개발의 문서화 도구.

스프링 프레임워크

자바 기반의 오픈소스 경량형 애플리케이션 프레임워크다. 핵심 특성은 모듈화, 재사용성, 확장성, 제어의 역흐름(IoC)이다.

// IoC (제어의 역흐름) 예시
// 직접 객체를 생성하는 대신, 스프링이 의존성을 주입해준다
@Service
public class OrderService {
    private final PaymentService paymentService;

    // 스프링이 PaymentService를 자동으로 주입한다 (생성자 주입)
    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

개발자가 객체의 생성과 생명 주기를 직접 제어하는 대신, 프레임워크가 그 제어권을 가져가는 방식이다. 이것이 "제어의 역흐름"이라는 이름의 유래다.

[ML] 군집화 알고리즘을 Azure ML에서 구현

Seum Lee — Mon, 24 Nov 2025 17:23:12 +0900

군집화 알고리즘

군집화

회기 모델에서 오차 개념을 사용하였다.

군집이 잘 뭉쳐있는지, 넓게 퍼져있는지를 볼 때 오차를 거리 개념으로 사용한다. 각 군집 간의 거리도 지표로 사용 한다.

거리에 대한 것은 Manhattan distance와 Euclidian distance가 있으며, 그 외에 Minkowski, Mahlanobis, Jacaard 개념 등이 있다.

군집화 알고리즘의 종류

분할적 군집화

K-MEANS Clustering, DBSCAN 등이 있으며, 계층 관계가 없고 직관적인 방법이 특징.

중심점(Centroid)이 거리의 평균. K(클러스터링 수)를 미리 정하고 초기 중심점 설정 이후 그 갱신을 반복한다.

추가 참고 자료: 군집 클러스터링 (bskyvision)

* K-Means 알고리즘은 경계가 선으로 구분된다. 그러기 때문에 기하학적 모양의 군집은 제대로 되지 않을 수 있다.

계층적 군집화

군집 간에 상하 계층적 구조로 형성 된다. (Dendrogram) 거리에 따라 계층을 형성한다.

덴드로그램의 단점은 데이터 추가 제거에 대해 전체 연산량 부하가 많을 수도 있다.

DBSCAN Clustering (Density-Based Spatial CLustering of Applications with Noise)

밀도의 개념으로 군집을 형성하며, 그 결과를 통해 Noise 제거가 가능하다. 클러스터에 할당되지 않는 데이터도 있으며, 이러한 형태의 Noise를 제거할 수도 있다.

Core Point, Border Point, Noise Point가 주요 항목이며, 하이퍼 파라미터로 Epsilon(이웃 반경), minPts(최소 샘플 수)가 있다.

K-MEANS 클러스터링의 초기화

Random Seed 방법은 임의로 초기화점을 선택하며, 이로 인해 간혹 잘못된 결과가 나오기도 한다.

반면 K-Means ++는 초기 Centroid가 최대한 서로 멀리 떨어지도록 선택하는 방법이며, 랜덤 시드 초기화보다 빠르게 수렴한다.

군집수 결정

오차제곱합(SSE, Sum of Squared Error): 군집 내 유사도 최대화

실루엣 (Silhouette): 군집 내 유사도 최대화 + 군집 간 유사도 최소화

a(i): 동일한 클러스터 내 데이터들과의 평균 거리 (응집도), b(i): 가장 가까운 다른 클러스터 데이터들과의 평균거리 (분리도)

실루엣의 경우 응집도와 분리도를 함께 보아야 한다. 실루엣의 가파른 정도에 따라 군집화가 잘 구성되었는지 판단할 수 있으며, 실루엣 계수 평균 선 또한 이와 비슷하다.

참고 자료: 군집 분석 (ML)

Azure ML을 통한 시각화

간단한 클러스터 머신 러닝 분석은 아래 단계와 같다.

데이터 전처리와 병합
정규화 (Normalization)
주성분분석 (PCA)
데이터 분리 및 학습

`Execute Python Script` 블럭에서는 PCA를 수행하며, 별도의 코드를 삽입해야 한다.

Designing a Real-Time Data Streaming Architecture on Azure

Seum Lee — Tue, 4 Nov 2025 15:06:55 +0900

Azure Cloud is a PaaS platform that helps developers build applications without managing infrastructure.
It also enables real-time data streaming using open-source technologies such as Kafka and Elasticsearch.
Additionally, Azure provides a large-scale message pipeline service called Azure Event Hub, which works similarly to Kafka.

Azure Event Hub

Azure Event Hub helps process massive real-time data streams, handling millions of events per second.
It is similar to Kafka, but if you prefer an open-source and self-managed architecture, you can use Kafka instead.

Why use Event Hub?

If your workflow focuses on batch processing—collecting, cleaning, and loading data in bulk—you don’t necessarily need to use Event Hub.
However, Event Hub is optimized for real-time streaming, capable of handling a massive number of concurrent events and routing them to multiple independent microservices.

Azure Functions

Azure Functions is a serverless computing service that allows you to run small, single-purpose pieces of code.
It can handle business logic, data processing or transformation, and API requests.
It is simple, lightweight, fast, and flexible.

Currently, the function only logs messages, but you can implement any business logic or custom functionality you want inside it.

import azure.functions as func
import logging

app = func.FunctionApp()

@app.event_hub_message_trigger(arg_name="azeventhub", event_hub_name="myeventhub",
                               connection="exampleEventhub_RootManageSharedAccessKey_EVENTHUB") 
def eventhub_trigger(azeventhub: func.EventHubEvent):
    logging.info('Python EventHub trigger processed an event: %s',
                azeventhub.get_body().decode('utf-8'))


@app.function_name(name="eventhub_output")
@app.route(route="eventhub_output", methods=["POST"])
@app.event_hub_output(arg_name="event", 
                      event_hub_name='myeventhub',
                      connection="exampleEventhub_RootManageSharedAccessKey_EVENTHUB")
def eventhub_output(req: func.HttpRequest, event: func.Out[str]) -> func.HttpResponse:
    req_body = req.get_body().decode('utf-8')
    event.set(req_body)
    logging.info("HTTP trigger function received a request: %s", req_body)

    return func.HttpResponse("Event Hub output function executed successfully.", status_code=200)

[!Tip] For more information on how to build an Azure Function, see: How-can-I-build-an-Event-Hub-in-Azure-and-integrate-it-with-a-webhook-for-Microsoft-Teams

Simple Diagram

When a client makes a POST request to /api/eventhub_output, the Azure Function forwards the data to an Event Hub that it’s already connected to.
The Event Hub then triggers another function by publishing a new message.
This triggered function runs the logic defined by the user.

Very simple diagram for EventHub & Function

Event Hub can be connected to other microservices, as it is capable of processing massive amounts of data concurrently in real time.

An example diagram for Data Processing

The purpose of using Event Hub is not just to collect massive amounts of data, but to enable automatic scale-out and flexible customization in response to incoming data from producers.
Developers can also build a real-time, large-scale data streaming architecture without worrying about infrastructure, allowing them to focus on implementing business logic and core project features.

Build the services on Azure Portal

Once you have created an Event Hub, you will see a screen where you can manage your Event Hub instances, as shown below.

The Data Explorer tab allows you to view the list of events received from producers and send dummy events for testing.

Logging and Test in Azure Function

You can check logs and test whether your functions work properly.
But be sure to configure security tokens and authentication settings correctly when your Azure Function is accessed externally.

Function App ➣ An event hub we created before > Tab 'Logs'

[!Tip] You can test your deployed Azure Function with the following command:

curl -X POST -d https://<Your App Name>.azurewebsites.net/api/<Function Name>?code=<Function Token>

[!Note] If the Authorization Level is set to function or admin, you must include the code parameter in the URL.
However, if it is set to anonymous, no token is required, and the Authorization Level can be configured when you create or initialize the function.

Building a RAG Model with Azure OpenAI and NoSQL (1)

Seum Lee — Fri, 31 Oct 2025 16:02:28 +0900

The RAG model is useful for improving the search performance and reliability of artificial intelligence systems.
As you may know, Azure Cloud provides OpenAI services and also supports NoSQL databases such as Azure Cosmos DB.

Ready to start:

You need one resource group.
Make sure your subscription has valid payment information registered.

✅ Create an Azure Open AI

You can find Azure OpenAI in the Azure Marketplace.
Click Create to start setting up a new Azure OpenAI instance.

Select your subscription type and the resource group you created earlier.
Then, configure any other settings according to your preferences.

Once the instance has been created, you will see a dashboard similar to the image below.

✅ Azure AI Foundry

Creating a LLM Instance

If you click Go to Azure AI Foundry portal, a page will appear where you can configure your preferences and create AI instances.

Find the tab named Deployments below, then click + Deploy model and select Deploy base model.

You can search for many AI models. For this example, we will search for **gpt-4o-mini**, or you can choose another model you want to use.

If you find the AI model you want to use, click Confirm to continue creating the instance.

Then, you can click `Customize` to set up the preferences as you like.

Adjust the slider bar to set the Maximum Token Rate in the detailed settings panel.
When you finish configuring the settings, click Deploy to continue creating the instance.

✅ Creating a Text Embedding Model Instance

Just like you created the LLM instance earlier, you also need to create a text embedding model instance.

Enter text-embedding in the search bar to find the Embeddings model, then click it to continue creating the instance.

And configure the settings in the panel like earlier.

✅ Start a project to build a RAG

Access Key

If you want to make this model accessible from requests by external clients, deploy the API key and store it in environment variables, such as in a .env or .json file.

Backend System

You may need to set up your project as shown below. I have already created an Azure Function App Project for testing in my VS Code workspace, but I want to create a new example using FastAPI in the next time.
(You can set up the API backend system using your preferred framework, such as Azure Functions, FastAPI, Express.js, and more.)

Azure Function Project Directory

[!Note] This topic will be continued in the next post.

Azure Cosmos DB (NoSQL)

Now, we will create a NoSQL database using Azure Cosmos DB. Search for Cosmos DB to find it.

Click Create on the card named Azure Cosmos DB for NoSQL to continue.

You can configure your instance according to your preferences.

Once your Cosmos DB instance is created, go to the Settings section and find the Features tab.
Then, select Vector Search for NoSQL API and enable it, so the status shows On.

We will continue in the next post.

How to Use Windows on macOS with VMware Fusion

Seum Lee — Thu, 30 Oct 2025 17:28:48 +0900

Requirements

VMware Fusion (Free)

You need to sign in to Broadcom and download VMware Fusion.

https://www.vmware.com/products/desktop-hypervisor/workstation-and-fusion

Fusion and Workstation | VMware

VMware Workstation and VMware Fusion desktop hypervisors are the industry leaders in local virtualization. Learn how VMware’s local virtualization solutions provide an easier way to build, test and deliver any app for any device or cloud.

www.vmware.com

You’ve successfully installed the application if you see an icon like the one below.

Windows ISO file

To download a Windows ISO file, visit the official Microsoft website:

https://www.microsoft.com/en-US/software-download/windows10ISO

Windows 10 디스크 이미지(ISO 파일) 다운로드

Windows를 설치할 때 동일한 언어를 선택해야 합니다. 현재 사용 중인 언어를 확인하려면 PC 설정에서 시간 및 언어 또는 제어판의 지역으로 이동합니다.

www.microsoft.com

Installation

Select Install from disk or image, then choose the ISO image you downloaded.

Pick the version of Windows you want to install.
If you don’t have a product key, you can skip it by closing or ignoring the warning dialog.

Click Continue to begin setting up your virtual environment.

Successful

Once the installation is complete, click the Start (►) button to run the Windows virtual environment.
You should see the Windows logo appear on the screen.

[!Tip] Changes the volume size before starts the virtual environment. Default volume size is maybe sets to '40 ~ 60GB'.

Building a Data Pipeline for Heavy Tasks with Python, Celery, Django API, and Docker (1)

Seum Lee — Wed, 29 Oct 2025 21:56:36 +0900

Sometimes, we need to handle multiple tasks such as data processing, data collection, and making API requests that are I/O-bound. Even if it's not about data, we still have to handle heavy tasks in a company or in various projects.
However, I/O-bound tasks are not recommended with Celery, because Celery is optimized for heavy tasks, also known as CPU-bound tasks.

[!TIP] What is CPU-bound? A CPU-bound task primarily relies on the CPU for computation and consumes significant system resources. It is the opposite of I/O-bound tasks. Usually, I/O-bound tasks involve waiting for network responses, API requests, or user interactions.

Architecture & Building an API overview

Django

Django is a powerful Python web framework, analogous to FastAPI and Flask, that supports ORM models and queries, provides an admin panel, and can be used to build REST APIs with many available libraries.
By choosing Django, you can build scalable, well-supported, production-ready microservices.

# Create a virtual environment
python -m venv .venv
# Activate the virtual environment
source .venv/bin/activate        # linux, macOS

# Alternatively, if you want to use (mini)conda:
conda create -n my-env python=3.12
# It's recommended to check the Django version and Python version before creating the environment.
conda activate my-env

Installation django:
pip install django==5.1.2

When you have completed installing Django, you can create your project and the apps you want to use.

[!Note] This article does not cover the details of the installation process. For installation instructions, please refer to Django Installation .

What is PostgreSQL?

PostgreSQL is compatible with ACID and ensures data integrity. It supports JSONField, ArrayField, HStoreField, and advanced queries. It can handle concurrent tasks efficiently, and the official Django documentation recommends it. However, you can also use other databases like MySQL, MariaDB, etc.

[!Tip] ACID stands for Atomicity, Consistency, Isolation, and Durability.
In a DBMS, a transaction is a single logical unit of work in the database. It ensures that all SQL statements within the transaction are executed as a single unit, so that partial execution or failure does not leave the database in an inconsistent state. Transactions maintain the integrity of the database by committing all changes if successful, or rolling them back in case of failure.

There are two ways to deploy PostgreSQL: setting it up on the host machine or running it in a Docker contianer.
Also, we will build PostgreSQL using a Docker container because it offers several advantages: flexibility, easy management, and impressive security performance.

Docker

First, you need to set up Docker on your host machine using Linux commands.

# Ubuntu
sudo apt update
sudo apt install -y ca-certificates curl gnupg lsb-release

# Add Docker’s official GPG key
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

# Add the Docker repository
echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
https://download.docker.com/linux/ubuntu \
$(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Install Docker Engine
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# Verify installation
docker --version
sudo docker run hello-world

# (Optional) Allow running Docker without sudo
sudo usermod -aG docker $USER
newgrp docker

[!Note] This document primarily targets Linux environments, focusing on production server deployment rather than beginner-level setup.
For Windows or macOS users, please refer to Installation Docker Desktop.

Setup PostgreSQL using Docker

The following commands are basic Docker commands to set up the database.

# Select the version you prefer.
docker pull postgres:16

docker run --name my-postgres \
  -e POSTGRES_USER=myuser \
  -e POSTGRES_PASSWORD=mypassword \
  -e POSTGRES_DB=mydatabase \
  -p 5432:5432 \
  -v pgdata:/var/lib/postgresql/data \
  -d postgres:16

# After building the container: check the currently running Docker containers.
docker ps

# Access the psql shell of a running Docker container
docker exec -it my-postgres psql -U myuser -d mydatabase

# (Optional) Control running Docker containers
docker stop my-postgres
docker start my-postgres

[!Note] Docker Compose will be introduced later in the guide, along with how to use a docker-compose.yml file to manage multiple containers efficiently.

Gunicorn (or ASGI)

The command python manage.py runserver starts a Django application, but it is not suitable for production. For production, you should use Gunicorn (WSGI) to serve all requests, or use ASGI with asynchronous views.
However, We will now install Gunicorn.

pip install gunicorn
gunicorn --version

# Default command to start
gunicorn myproject.wsgi:application --bind 0.0.0.0:8000 --workers 3

[!TIP] Django supports ASGI and asynchronous views and functions. However, you need to consider using an asynchronous system carefully, because some libraries may cause bugs or may not support asynchronous features.

How can I build an Event Hub in Azure and integrate it with a webhook for Microsoft Teams?

Seum Lee — Wed, 29 Oct 2025 14:47:40 +0900

What can you do with Azure Cloud?

Azure cloud enables you to build microservices-compatiable applications and focus on code development and processes during deployment.

What is Event hub?

Azure Event Hub is a fully managed, cloud-native data streaming platform ingests millions of events per second from any source, enabling real-time analytics and dynamic data pipelines.
It offers low latency, high scalability, and is compatible with Apache Kafka, allowing existing Kafka applications to run without code changes.
Evenv hubs serves as a powerful event ingestion layer within Azure, facilitating immediate responses to business events, anomaly detection, and data archiving.

Compares with AWS kinesis

Azure Event Hub is compatible with Kafka and easily integrates with other Azure serivces.
And AWS Kinesis offers powerful serverless integration with AWS Lambda, Glue, and Redshift.

Step by step

Create a resource group (Azure Portal)

Left sidebar: Resource groups → Create → enter the resource group name → choose Subscription and Region → Review + create

If you uses in CLI:

  # create a resource group
  az group create --name MyResourceGroup --location eastus

[!NOTE] An Azure Resource Group acts as a container that holds related Azure resources and services.

Create a Event Hub (Namespace)

Click Create, and you will see the Marketplace.
Enter "Event Hub" in the search bar to find Event Hubs.

Once you find Event Hubs, click the Create button to start a new instance.

First, create an Event Hub Namspace for your hubs, and use a Schema Registry to define a clear data structure between producers and consumers.

When Event Hub Nampsace is created, you can add hubs on it.

Edit in Visual Studio Code for Azure Function App

# function_app.py
import azure.functions as func
import pandas as pd
import json
import os
import requests
app = func.FunctionApp()

@app.event_hub_output(arg_name="event", 
                      event_hub_name= os.environ["SampleEventHubName"], 
                      connection="SampleEventHubConnectionString"
)
def sample_eventhubs_scheduler(timer: func.TimerRequest, event: func.Out[str]):
    df = pd.read_csv("sample_data/samples.csv", encoding="euc-kr")

    # Data preprocessing...

    sample_data_list = []
    for index, row in df.iterrows():
        # The code to process sample data and send an output to the event hub
        #
        ...

    event.set(sample_data_list)

    # A webhook request example
    whook_url = os.environ["AzureWebHookUrl"]
    payload = {
        "type": "message",
        "attachments": [
            {
                "contentType": "application/vnd.microsoft.card.adaptive",
                "contentUrl": None,
                "content": {
                    "$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
                    "type": "AdaptiveCard",
                    "version": "1.2",
                    "body": [
                        {
                            "type": "TextBlock",
                            "text": "Hello, An example web hook payload."
                        }
                    ]
                }
            }
        ]
    }
    response = requests.post(
        whook_url, 
        json=payload
    )
    response.raise_for_status()
    ...

# Your requirements.txt 
# Maybe recommended to uses in Virtual Environment. (venv)

# DO NOT include azure-functions-worker in this file
# The Python Worker is managed by Azure Functions platform
# Manually managing azure-functions-worker may cause unexpected issues

azure-functions
requests
numpy
pytz
pandas

You must have a local.settings.json file in the root directory of your Azure Function App project.

[!Note] This is a development settings for test & debugging.

{
    "IsEncrypted": false,
    "Values": {
        "AzureWebJobsStorage": "UseDevelopmentStorage=true",
        "FUNCTIONS_WORKER_RUNTIME": "python",
        "SampleEventHubName": "<Your Hub Name>",
        "SampleEventHubConnectionString": "<Connection String of Event Hub namespace>",
        "AzureWebHookUrl": "<Web hook url you want to add>"
    }
}

[!Note] You can find the ...EventHubConnectionString in Resource Group → Your Event Hub Namespace → Settings → Shared access policies
Make sure to create a policy named with RootManageSharedAccessKey.

Copies your Primary connection string in the policy you created and pastes it to local.settings.json.

The host.json file should also be located in the root directory of your project.

{
  "version": "2.0",
  "logging": {
    "applicationInsights": {
      "samplingSettings": {
        "isEnabled": true,
        "excludedTypes": "Request"
      }
    }
  },
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[4.*, 5.0.0)"
  }
}

It is recommended to install these VS Code extensions to help you build Azure Functions and other Azure services.

Main Points When Building an Azure Function App in VS Code

Visual Studio Code supports many Azure Cloud services through its extensions.
It provides seamless integration that allows you to develop locally and deploy automatically to the cloud.

Deploy to the Cloud Easily with Azure Extensions

You can deploy your code to Azure Cloud directly once it’s ready.

[!TIP] You may need to sign in to Azure using the CLI before deploying.

az login
# A browser window will open for authentication.
# Make sure Azure CLI is installed on your device. (Compatible with Windows, macOS, and Linux)
# Installation instructions can be found in the official Microsoft documentation.

Environment Variables in Azure Cloud

You can check your environment variables in
Resource Group → Function App → Settings → Environment variables

Your local environment settings can be uploaded to Azure Cloud using:
Command Palette: Azure Functions: Upload Local Settings

Integrates with Microsoft Teams Web hook

Microsoft teams support many services and hook, you can integrate them with Azure Cloud Services.

Search for Workflow to find the Teams Workflow app, where you can add a webhook, mailing system, bot messages, or any other automation you need for your project group or organization.

Once you've installed the Workflow app, open the workflow management dialog and modify it for your own customization.

Here is an example of a webhook that triggers when an external Azure Function App has completed its task.