리눅스 기초 튜토리얼¶

코딩을 좋아하는 여러분, 리눅스에 오신 것을 환영합니다! 이 문서는 리눅스를 처음 접하는 분들을 위해 친절하게 설명합니다. 하나하나 천천히 따라오면, 어느새 터미널이 여러분의 놀이터가 될 거예요.

목차¶

리눅스란?
파일 시스템 구조
기본 명령어
파일 검색
권한과 소유권
패키지 관리
프로세스 관리
파이프와 리다이렉트
환경 변수
압축과 아카이브
명령어 치트시트
실습 미션

1. 리눅스란?¶

리눅스는 운영체제입니다¶

여러분이 윈도우나 맥을 쓰고 있잖아요? 리눅스도 그런 운영체제(OS) 중 하나입니다. 1991년, 핀란드의 대학생 리누스 토르발스가 취미로 만들기 시작한 게 지금 전 세계를 지배하게 되었죠.

왜 개발자가 리눅스를 알아야 할까요?¶

이유	설명
서버의 90% 이상이 리눅스	구글, 아마존, 넷플릭스, 카카오... 거의 모든 서버가 리눅스에서 돌아갑니다
오픈소스 생태계의 핵심	무료이고, 누구나 코드를 볼 수 있고, 자유롭게 수정할 수 있습니다
개발 환경의 표준	Docker, Kubernetes, GitHub Actions... 모두 리눅스 기반입니다
코딩에 최적화	터미널과 명령어로 모든 것을 할 수 있어서 개발 속도가 엄청나요
Android도 리눅스	여러분의 스마트폰 속에도 리눅스가 들어있습니다

코딩을 좋아한다면? 리눅스는 선택이 아니라 필수입니다. 서버에 코드를 올리고, 프로그램을 실행하고, 문제를 찾고 고치려면 리눅스를 알아야 해요. 하지만 너무 걱정하지 마세요! 기본만 알아도 엄청난 힘을 발휘할 수 있습니다.

리눅스 배포판 소개¶

리눅스는 "배포판(distribution)"이라는 여러 가지 버전이 있습니다. 핵심(커널)은 같지만, 겉모습과 기본 프로그램이 다릅니다.

배포판	특징	추천 대상
Ubuntu	가장 인기, 커뮤니티가 큼, 초보자 친화적	초보자 추천 1순위!
Fedora	최신 기술을 빠르게 반영, Red Hat 계열	새로운 기술을 좋아하는 사람
Arch	모든 것을 직접 설정, 가볍고 빠름	리눅스를 깊이 이해하고 싶은 사람
Linux Mint	윈도우와 비슷한 인터페이스	윈도우에서 넘어오는 사람

초보자라면 Ubuntu로 시작하세요!

Ubuntu(우분투)는 자료가 가장 많고, 문제가 생기면 검색만 해도 해결책이 나옵니다. 나중에 익숙해지면 다른 배포판도 시도해보세요.

2. 파일 시스템 구조¶

리눅스에서는 모든 것이 파일입니다. 폴더도 파일이고, USB도 파일이고, 심지어 키보드도 파일입니다. 그리고 모든 파일은 루트(root, /) 라는 하나의 시작점에서 뻗어나옵니다.

윈도우에서는 C:\, D:\ 처럼 드라이브가 나뉘지만, 리눅스에서는 하나의 트리 구조입니다.

/               ← 루트 (모든 것의 시작, 나무의 뿌리)
├── home/       ← 사용자 폴더 (각 사용자의 공간)
│   ├── minjun/ ← 민준이의 방 (개인 파일)
│   ├── sujin/  ← 수진이의 방 (개인 파일)
│   └── ...
├── etc/        ← 설정 파일 (시스템 설정 모음)
├── var/        ← 로그, 데이터 (계속 변하는 파일들)
│   ├── log/    ← 시스템 로그 (일기장 같은 것)
│   └── www/    ← 웹 서버 파일
├── usr/        ← 프로그램 (설치된 앱들)
│   ├── bin/    ← 일반 사용자 프로그램
│   ├── lib/    ← 라이브러리
│   └── local/  ← 직접 설치한 프로그램
├── tmp/        ← 임시 파일 (재부팅하면 사라짐)
├── bin/        ← 기본 명령어 (ls, cp, mv 등)
├── sbin/       ← 관리자 명령어 (시스템 관리용)
├── dev/        ← 장치 파일 (USB, 마우스, 키보드 등)
├── proc/       ← 프로세스 정보 (실행 중인 프로그램 정보)
└── root/       ← root 관리자의 홈 폴더

비유로 이해하기¶

리눅스 파일 시스템을 하나의 큰 건물(학교) 이라고 생각해봅시다.

디렉토리	비유	설명
`/`	학교 건물 전체	모든 것의 시작
`/home`	학생들의 사물함	각 학생(사용자)만의 공간
`/etc`	학교 운영 규칙 안내서	학교(시스템)가 어떻게 돌아가는지 적힌 설정
`/var`	학교 게시판, 방명록	계속 내용이 추가되고 변하는 곳
`/usr`	특별실, 도서관	모두가 쓸 수 있는 프로그램이 있는 곳
`/tmp`	임시 화이트보드	지우개로 싹 지워지는 임시 공간
`/bin`	필수 교구실	수업에 꼭 필요한 기본 도구(명령어)들
`/dev`	방과후 교실 (기기 연결)	USB, 프린터 같은 장치들이 연결되는 곳

홈 디렉토리가 내 진짜 공간!

여러분이 주로 작업할 곳은 /home/사용자이름 입니다. 터미널에서 ~ 기호로 줄여서 표시합니다. 예: ~/projects = /home/minjun/projects

3. 기본 명령어¶

이제 본격적으로 터미널에서 명령어를 사용해봅시다! 이 섹션이 가장 중요합니다. 하나하나 실습하면서 익혀보세요.

터미널 여는 법

Ubuntu: Ctrl + Alt + T

macOS: Spotlight에서 "Terminal" 검색

Windows: WSL 설치 후 Ubuntu 앱 실행

3-1. 탐색 명령어 (지금 내가 어디에 있는지 알기)¶

`pwd` - Print Working Directory (지금 내가 어디에 있나?)¶

pwd

출력 예시:

/home/minjun

비유: 내가 지금 건물 몇 층, 어느 방에 있는지 확인하는 것.

`ls` - List (이 폴더에 뭐가 있나?)¶

# 기본 사용
ls
# 출력: Desktop  Documents  Downloads  Music  Pictures  Videos

# 자세한 정보 보기 (-l 옵션)
ls -l
# 출력:
# drwxr-xr-x  2 minjun minjun 4096 Jan 15 10:30 Desktop
# -rw-r--r--  1 minjun minjun  220 Jan 15 10:30 .bashrc

# 숨김 파일까지 보기 (-a 옵션: .으로 시작하는 파일)
ls -a
# 출력: .  ..  .bashrc  .profile  Desktop  Documents

# 자세한 정보 + 숨김 파일 (-la 옵션: -l과 -a를 합친 것)
ls -la

# 파일 크기를 사람이 읽기 쉽게 (-h 옵션: human-readable)
ls -lh
# 출력:
# -rw-r--r--  1 minjun minjun 2.5K Jan 15 10:30 .bashrc
# (4096 대신 4.0K로 보여줌)

# 특정 폴더 내용 보기
ls /home
# 출력: minjun  sujin

# 정렬해서 보기
ls -lS    # 파일 크기순 정렬
ls -lt    # 수정 시간순 정렬
ls -lSr   # 파일 크기 역순 정렬

옵션 조합 팁

ls -la, ls -lh, ls -lha 처럼 옵션을 여러 개 조합할 수 있어요. -lha는 "자세히 + 숨김파일 + 읽기쉬운크기" 입니다.

`cd` - Change Directory (다른 폴더로 이동하기)¶

# 특정 폴더로 이동
cd Documents

# 절대 경로로 이동 (루트부터 전체 경로 적기)
cd /home/minjun/Documents

# 홈 디렉토리로 이동 (~ 기호 사용)
cd ~

# 홈 디렉토리로 이동 (cd만 입력해도 같은 효과)
cd

# 한 단계 위로 이동 (.. 은 부모 디렉토리)
cd ..

# 두 단계 위로 이동
cd ../..

# 이전에 있던 폴더로 돌아가기 (- 기호)
cd -

특수 기호 정리:

기호	의미	예시
`.`	현재 디렉토리	`cd .` (제자리)
`..`	부모 디렉토리	`cd ..` (한 단계 위로)
`~`	홈 디렉토리	`cd ~/Documents`
`-`	이전 디렉토리	`cd -` (뒤로 가기)

비유

cd = 방에서 다른 방으로 이동하기

pwd = "내가 지금 어디 있지?" 확인하기

ls = 방 안을 둘러보기

3-2. 파일과 디렉토리 다루기¶

`mkdir` - Make Directory (새 폴더 만들기)¶

# 기본 사용
mkdir projects

# 여러 폴더 한 번에 만들기
mkdir homework notes games

# 중간 폴더까지 한 번에 만들기 (-p 옵션)
mkdir -p projects/python/beginner
# projects가 없어도 알아서 만들어줌!

# 중첩 폴더 구조 만들기
mkdir -p school/{math,science,english}
# school/math, school/science, school/english이 동시에 생성됨

-p 옵션은 정말 유용해요!

중간 경로가 없으면 자동으로 만들어주기 때문에, 한 번에 깊은 폴더 구조를 만들 수 있습니다.

`touch` - 빈 파일 만들기¶

# 빈 파일 만들기
touch hello.py

# 여러 파일 한 번에 만들기
touch main.py utils.py test.py

# 파일의 수정 시간 업데이트하기 (이미 있는 파일에 사용)
touch hello.py

`rm` - Remove (파일/폴더 삭제하기)¶

# 파일 삭제
touch test.txt
rm test.txt

# 여러 파일 삭제
rm file1.txt file2.txt file3.txt

# 폴더와 그 안의 모든 내용 삭제 (-r 옵션: recursive)
rm -r old_project/

# 확인 없이 바로 삭제 (-f 옵션: force)
rm -f unwanted_file.txt

# 폴더 강제 삭제 (-rf 옵션: recursive + force)
rm -rf old_project/

경고: rm 명령어는 휴지통을 거치지 않고 바로 삭제합니다!

윈도우처럼 휴지통에 들어가는 게 아닙니다. 복구가 매우 어렵습니다.

rm -rf / 같은 명령어는 절대 입력하지 마세요. 시스템 전체가 날아갑니다.

삭제하기 전에 꼭 ls로 먼저 확인하는 습관을 들이세요.

실수를 방지하려면 rm -i (삭제 전 확인) 옵션을 사용하세요.

# 안전한 삭제 (-i: 삭제 전 물어보기)
rm -i important_file.txt
# rm: remove regular empty file 'important_file.txt'? y

`cp` - Copy (파일/폴더 복사하기)¶

# 파일 복사
cp original.txt copy.txt

# 다른 폴더에 복사
cp original.txt backup/

# 이름을 바꿔서 복사
cp report.pdf report_backup_2026.pdf

# 폴더 복사 (-r 옵션 필요)
cp -r projects/ projects_backup/

# 여러 파일을 한 폴더에 복사
cp *.py backup/

`mv` - Move (파일 이동 / 이름 바꾸기)¶

# 파일 이동
mv file.txt Documents/

# 폴더 이동
mv old_location/project/ new_location/

# 파일 이름 바꾸기 (같은 위치에서 mv)
mv old_name.py new_name.py

# 여러 파일을 한 폴더로 이동
mv *.py projects/python/

# 이동 전에 확인 (-i 옵션)
mv -i file.txt Documents/
# 덮어쓰기 전에 물어봐줌

mv는 이동과 이름 바꾸기를 모두 할 수 있어요!

같은 폴더 안에서 mv를 쓰면 이름 바꾸기

다른 폴더로 mv를 쓰면 이동

3-3. 파일 내용 보기¶

`cat` - 파일 전체 내용 출력¶

# 파일 내용 보기
cat hello.py
# 출력:
# print("Hello, World!")

# 여러 파일 이어서 보기
cat header.txt content.txt footer.txt

# 파일 내용을 다른 파일에 쓰기
cat notes.txt > combined.txt

# 줄 번호와 함께 보기
cat -n hello.py
# 출력:
#      1  print("Hello, World!")
#      2  name = "minjun"
#      3  print(f"Hi, {name}!")

cat은 Concatenate(이어붙이기)의 약자입니다.

원래는 여러 파일을 이어붙이는 명령어지만, 짧은 파일 하나를 볼 때도 자주 씁니다.

`less` - 긴 파일을 페이지 단위로 보기¶

# 긴 파일 보기
less long_log.txt

# less 안에서 사용하는 키:
#   스페이스바 / f    : 다음 페이지
#   b                : 이전 페이지
#   /검색어          : 검색 (n으로 다음 결과)
#   q                : 나가기
#   g                : 파일 맨 앞으로
#   G                : 파일 맨 뒤로

긴 파일은 cat 대신 less를 사용하세요!

cat은 파일 전체를 한 번에 출력해서 긴 파일은 보기 힘듭니다. less는 페이지 단위로 볼 수 있어서 편합니다. 기억하기: "less is more" (less가 더 좋다)

`head` / `tail` - 파일의 처음/끝 부분만 보기¶

# 파일의 앞 10줄 보기 (기본)
head README.md

# 앞 20줄 보기 (-n 옵션)
head -n 20 README.md

# 파일의 뒤 10줄 보기 (기본)
tail error.log

# 뒤 50줄 보기
tail -n 50 error.log

# 실시간으로 파일 끝부분 감시하기 (-f 옵션: follow)
tail -f /var/log/syslog
# 로그 파일을 실시간으로 볼 수 있음! Ctrl+C로 종료

tail -f는 개발자의 필수 도구입니다!

서버 로그를 실시간으로 확인할 때 정말 유용해요. 프로그램을 실행하고, 다른 터미널에서 tail -f로 로그를 지켜보는 방식으로 디버깅을 많이 합니다.

`wc` - Word Count (줄 수, 단어 수, 글자 수 세기)¶

# 파일의 줄 수 / 단어 수 / 바이트 수
wc hello.py
# 출력:  10  25  180 hello.py
#        줄  단어 바이트

# 줄 수만 세기 (-l 옵션: lines) - 가장 많이 사용!
wc -l data.csv
# 출력: 1500 data.csv

# 파이프와 함께 사용 (이건 뒤에서 자세히 배워요)
ls -la | wc -l     # 현재 폴더의 파일 개수 세기
cat log.txt | grep ERROR | wc -l   # ERROR가 몇 줄인지 세기

4. 파일 검색¶

파일이 어디 있는지, 파일 안에 어떤 내용이 있는지 찾는 방법을 배워봅시다.

`find` - 파일 이름, 타입, 크기로 검색¶

find는 아주 강력한 검색 명령어입니다.

# 기본 형식: find [검색할 위치] [조건]

# 현재 폴더에서 이름으로 찾기
find . -name "hello.py"
# 출력: ./projects/python/hello.py

# 대소문자 구분 없이 이름으로 찾기 (-iname)
find . -iname "README.md"
# README.md, readme.md, Readme.md 모두 찾아줌

# 확장자로 찾기 (와일드카드 * 사용)
find . -name "*.py"
# 모든 파이썬 파일 찾기

find . -name "*.jpg"
# 모든 이미지 파일 찾기

# 타입으로 찾기
find . -type d        # 디렉토리만 찾기 (d = directory)
find . -type f        # 파일만 찾기 (f = file)

# 크기로 찾기
find . -size +100M    # 100MB보다 큰 파일
find . -size -1k      # 1KB보다 작은 파일
find . -size +1G      # 1GB보다 큰 파일 (대용량 파일 찾기)

# 수정 시간으로 찾기
find . -mtime -7      # 7일 이내에 수정된 파일
find . -mtime +30     # 30일 넘게 수정 안 된 파일

# 찾은 파일로 바로 명령 실행 (-exec)
find . -name "*.tmp" -delete           # .tmp 파일 모두 삭제
find . -name "*.py" -exec wc -l {} \;  # 모든 .py 파일의 줄 수 세기

# 조건 조합하기 (AND, OR)
find . -name "*.py" -size +1k              # .py이면서 1KB 이상
find . \( -name "*.py" -o -name "*.js" \)  # .py 또는 .js

실용 예시: 내 컴퓨터에서 큰 파일 찾기

# 홈 디렉토리에서 500MB 넘는 파일 찾기
find ~ -size +500M -exec ls -lh {} \;

# 30일 넘게 안 쓴 임시 파일 찾기
find /tmp -mtime +30 -type f

`grep` - 파일 내용에서 검색¶

grep은 파일 안의 텍스트를 검색하는 명령어입니다. 코드에서 특정 함수를 찾거나, 로그에서 에러를 찾을 때 매일 쓰게 될 거예요.

# 기본 사용: 파일에서 특정 단어 찾기
grep "print" hello.py

# 여러 파일에서 찾기
grep "TODO" *.py

# 폴더 안의 모든 파일에서 재귀적으로 찾기 (-r 옵션: recursive)
grep -r "def main" projects/
# projects/ 안의 모든 파일에서 "def main" 찾기

# 대소문자 구분 없이 찾기 (-i 옵션: ignore case)
grep -i "error" log.txt
# ERROR, Error, error 모두 찾아줌

# 줄 번호와 함께 보여주기 (-n 옵션: line number)
grep -n "print" hello.py
# 출력: 5:    print("Hello, World!")

# 특정 파일 형식에서만 찾기 (--include)
grep -r "import" . --include="*.py"
# 파이썬 파일에서만 "import" 찾기

# 여러 조건 조합 (가장 많이 쓰는 조합!)
grep -rn "class Main" . --include="*.java"
# -r: 재귀, -n: 줄번호, --include: 파일 형식 지정

# 매치되지 않는 줄 보기 (-v 옵션: invert)
grep -v "^#" config.py
# 주석(#으로 시작하는 줄)을 제외하고 보기

# 정규식 사용하기
grep -E "^def |^class " *.py
# def 또는 class로 시작하는 줄 찾기

grep은 개발자가 가장 많이 쓰는 명령어 중 하나입니다!

코드에서 버그를 찾을 때, 로그에서 에러를 찾을 때, 설정 파일에서 특정 항목을 찾을 때... 매일매일 사용하게 될 거예요. -rn 조합을 특히 많이 씁니다.

`which` - 명령어 위치 찾기¶

# 명령어가 어디에 설치되어 있는지 확인
which python3
# 출력: /usr/bin/python3

which git
# 출력: /usr/bin/git

which npm
# 출력: /usr/bin/npm

`locate` - 빠른 전체 검색¶

# 파일 이름으로 빠르게 검색 (미리 만들어진 데이터베이스 사용)
locate hello.py

# 패턴으로 검색
locate "*.pdf"

# 데이터베이스 업데이트 (새로 설치한 파일을 찾으려면 필요)
sudo updatedb

find vs locate 차이

find: 실시간으로 검색, 정확하지만 느릴 수 있음

locate: 데이터베이스에서 검색, 빠르지만 최근 파일은 안 나올 수 있음

보통은 find를 더 많이 사용합니다.

5. 권한과 소유권¶

리눅스는 여러 사람이 함께 쓰는 시스템이기 때문에, 누가 어떤 파일에 접근할 수 있는지를 관리합니다. 이것이 권한(permission)입니다.

권한 구조 이해하기¶

ls -l을 실행하면 다음과 같은 결과가 나옵니다:

-rwxr-xr-x  1 minjun students  4096 Jan 15 10:30 script.sh
drwxr-x---  2 minjun students  4096 Jan 15 10:30 private/

첫 번째 문자열을 자세히 봅시다:

- rwx r-x r-x
│  │   │   │
│  │   │   └── 다른 사람(other)의 권한: 읽기(r), 실행(x)
│  │   └────── 그룹(group)의 권한: 읽기(r), 실행(x)
│  └────────── 소유자(user/owner)의 권한: 읽기(r), 쓰기(w), 실행(x)
└───────────── 파일 타입: - (일반 파일), d (디렉토리), l (링크)

권한의 3가지 종류¶

기호	이름	숫자	설명	비유
`r`	읽기 (read)	4	파일 내용 보기 / 폴더 목록 보기	책 읽기
`w`	쓰기 (write)	2	파일 수정 / 폴더에서 파일 생성·삭제	책에 글씨 쓰기
`x`	실행 (execute)	1	파일 실행 / 폴더에 들어가기	도구 사용하기

숫자 표기법¶

세 권한의 숫자를 더해서 3자리 숫자로 표현합니다:

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

자주 쓰는 권한 조합:

숫자	권한	의미	사용 예시
`755`	rwxr-xr-x	소유자: 전부, 나머지: 읽기+실행	실행 파일, 웹 폴더
`644`	rw-r--r--	소유자: 읽기+쓰기, 나머지: 읽기만	일반 문서 파일
`700`	rwx------	소유자만 전부 가능	개인 스크립트
`600`	rw-------	소유자만 읽기+쓰기	비밀 파일, SSH 키
`777`	rwxrwxrwx	모두가 전부 가능	거의 사용하지 마세요!

777은 위험합니다!

누구나 파일을 수정하고 실행할 수 있기 때문에 보안에 매우 취약합니다. 꼭 필요한 경우에만 임시로 사용하고, 바로 원래 권한으로 돌려놓으세요.

`chmod` - 권한 변경¶

# 숫자식 표기법 (권장)
chmod 755 script.sh    # 소유자: rwx, 그룹: r-x, 다른사람: r-x
chmod 644 readme.md    # 소유자: rw-, 그룹: r--, 다른사람: r--
chmod 600 secret.key   # 소유자만 읽기/쓰기 가능
chmod 700 myfolder/    # 소유자만 접근 가능한 폴더

# 기호식 표기법
chmod +x script.sh     # 실행 권한 추가 (모두에게)
chmod -w shared.txt    # 쓰기 권한 제거 (모두에게)
chmod u+x script.sh    # 소유자(user)에게 실행 권한 추가
chmod g+w report.txt   # 그룹(group)에 쓰기 권한 추가
chmod o-r secret.txt   # 다른 사람(other)의 읽기 권한 제거
chmod u+x,go+r file.sh # 소유자에게 실행, 그룹과 다른 사람에게 읽기 권한

# 폴더와 그 안의 모든 파일 권한 변경 (-R 옵션: recursive)
chmod -R 755 public_html/

실행 파일 만들기
# 파이썬 스크립트를 실행 가능하게 만들기
chmod +x myscript.py

# 이제 이렇게 실행할 수 있어요
./myscript.py
단, 스크립트 파일의 첫 줄에 shebang이 있어야 합니다:
#!/usr/bin/env python3
print("Hello!")

`chown` - 소유권 변경¶

# 파일의 소유자 변경 (관리자 권한 필요)
sudo chown minjun file.txt

# 소유자와 그룹 모두 변경
sudo chown minjun:students file.txt

# 폴더와 그 안의 모든 파일 변경
sudo chown -R minjun:students project/

`sudo` - Super User Do (관리자 권한으로 실행)¶

# 관리자 권한으로 명령 실행
sudo apt install python3

# 관리자 권한으로 파일 수정
sudo nano /etc/hosts

# 임시로 root 사용자가 되기
sudo -i
# 또는
sudo su

sudo를 사용할 때는 주의하세요!

sudo는 "관리자 모드"로 명령을 실행합니다. 실수하면 시스템 전체에 영향을 줄 수 있어요. 꼭 필요한 경우에만 사용하고, 어떤 명령인지 이해한 후에 실행하세요.

실용 예시: 권한 에러 해결¶

# 상황: 스크립트를 실행하려고 하는데 "Permission denied" 에러가 나는 경우

# 1. 현재 권한 확인
ls -l script.sh
# -rw-r--r-- 1 root root 100 Jan 15 10:30 script.sh

# 2. 실행 권한 추가
chmod +x script.sh

# 3. 만약 소유자가 root라면 sudo 필요
sudo chown minjun:minjun script.sh
chmod +x script.sh

# 4. 이제 실행!
./script.sh

6. 패키지 관리¶

리눅스에서 프로그램을 설치, 업데이트, 삭제하는 방법입니다. 윈도우의 "프로그램 추가/제거" 같은 역할을 터미널에서 합니다.

Ubuntu / Debian (apt)¶

# 패키지 목록 업데이트 (설치 전에 항상 실행!)
sudo apt update

# 설치된 패키지 업그레이드
sudo apt upgrade

# 패키지 설치
sudo apt install python3
sudo apt install git vim curl

# 여러 패키지 한 번에 설치
sudo apt install nodejs npm

# 패키지 삭제
sudo apt remove python3

# 패키지 검색
apt search python
apt search text editor

# 패키지 정보 보기
apt show python3

# 더 이상 필요 없는 패키지 정리
sudo apt autoremove

apt update vs apt upgrade 차이

apt update: "어떤 패키지가 새 버전이 있나?" 목록을 업데이트 (설치 X)

apt upgrade: "새 버전이 있으면 업그레이드!" 실제로 설치

항상 update를 먼저 하고 upgrade를 하세요.

Fedora (dnf)¶

# 패키지 설치
sudo dnf install python3

# 패키지 삭제
sudo dnf remove python3

# 시스템 업데이트
sudo dnf upgrade

# 패키지 검색
sudo dnf search python

# 설치된 패키지 목록
dnf list installed

Arch Linux (pacman)¶

# 패키지 설치
sudo pacman -S python
sudo pacman -S git vim

# 패키지 삭제
sudo pacman -R python

# 시스템 전체 업데이트
sudo pacman -Syu

# 패키지 검색
pacman -Ss python

# 설치된 패키지 목록
pacman -Q

요약 비교표¶

동작	Ubuntu (apt)	Fedora (dnf)	Arch (pacman)
설치	`apt install`	`dnf install`	`pacman -S`
삭제	`apt remove`	`dnf remove`	`pacman -R`
업데이트	`apt update && apt upgrade`	`dnf upgrade`	`pacman -Syu`
검색	`apt search`	`dnf search`	`pacman -Ss`

7. 프로세스 관리¶

프로세스는 실행 중인 프로그램입니다. 리눅스에서는 여러 프로그램이 동시에 돌아가고, 이들을 관리하는 방법을 알아야 합니다.

`ps` - Process Status (프로세스 목록 보기)¶

# 내가 실행한 프로세스 보기
ps
#   PID TTY          TIME CMD
#  1234 pts/0    00:00:00 bash
#  5678 pts/0    00:00:00 ps

# 모든 프로세스를 자세히 보기 (가장 많이 사용!)
ps aux
# a: 모든 사용자
# u: 사용자 정보 표시
# x: 터미널 없는 프로세스도 포함

# 특정 프로세스 찾기
ps aux | grep python
# python이 들어간 프로세스만 보기

`top` / `htop` - 실시간 프로세스 모니터링¶

# 실시간 프로세스 보기 (기본)
top

# 더 예쁜 버전 (설치 필요: sudo apt install htop)
htop

top 안에서 자주 쓰는 키

q: 나가기

k: 프로세스 죽이기 (PID 입력)

M: 메모리 사용순 정렬

P: CPU 사용순 정렬

`kill` / `killall` - 프로세스 종료¶

# PID로 프로세스 종료 (정상 종료 요청, SIGTERM)
kill 1234

# PID로 강제 종료 (SIGKILL, 정말 안 죽을 때만!)
kill -9 1234

# 이름으로 프로세스 종료
killall python3

# 이름으로 강제 종료
killall -9 python3

SIGTERM vs SIGKILL

kill PID (또는 kill -15 PID): SIGTERM. "제발 종료해줘~"라고 정중하게 요청. 프로세스가 마무리 작업을 하고 종료합니다.

kill -9 PID: SIGKILL. "당장 꺼!"라고 강제로 종료. 저장 안 된 데이터가 날아갈 수 있으니 최후의 수단으로만 사용하세요.

백그라운드 / 포그라운드¶

# 명령어를 뒤에서 실행하기 (명령어 끝에 & 붙이기)
python3 server.py &
# [1] 5678    ← 작업 번호와 PID가 표시됨

# 실행 중인 프로그램 일시정지: Ctrl+Z
# (프로그램이 멈추고 터미널을 다시 쓸 수 있음)

# 일시정지된 프로그램을 뒤에서 계속 실행
bg

# 뒤에서 실행 중인 프로그램을 앞으로 가져오기
fg

# 특정 작업 번호로 가져오기
fg %1

단축키 정리

단축키 동작

Ctrl+C 프로그램 강제 종료 (SIGINT)

Ctrl+Z 프로그램 일시정지 (백그라운드로)

Ctrl+D 입력 종료 (EOF)

`nohup` - 터미널을 닫아도 계속 실행¶

# 터미널을 닫아도 계속 실행되도록 하기
nohup python3 server.py &

# 출력을 파일로 저장
nohup python3 server.py > server.log 2>&1 &

# 백그라운드 프로세스 확인
jobs -l

서버를 돌릴 때 nohup이 필수입니다!

그냥 python3 server.py &로 실행하면, 터미널을 닫을 때 프로그램도 같이 종료됩니다. nohup을 붙이면 SSH 연결이 끊어져도 서버가 계속 돌아갑니다.

8. 파이프와 리다이렉트¶

이건 명령어들을 연결하고, 결과를 파일로 저장하는 강력한 기능입니다. 리눅스의 진가는 여기서 빛을 발합니다!

파이프 (`|`) - 명령어 연결하기¶

파이프는 한 명령어의 출력을 다음 명령어의 입력으로 전달합니다.

비유: 공장의 컨베이어 벨트! 각 공정(명령어)을 거치면서 결과가 가공됩니다.

# 기본 형식: 명령어1 | 명령어2

# 파이썬 파일만 골라서 보기
ls -la | grep ".py"

# 프로세스 중 python만 찾기
ps aux | grep python

# 파일 중 ERROR가 몇 개인지 세기
cat log.txt | grep ERROR | wc -l

# 디렉토리만 골라서 보기
ls -la | grep "^d"

# 가장 많이 사용하는 메모리 프로세스 Top 5
ps aux --sort=-%mem | head -n 6

# 현재 폴더의 파이썬 파일 개수
ls *.py | wc -l

# 여러 파이프 연결 (3개 이상도 가능!)
cat access.log | grep "404" | grep "Jan" | wc -l

# 파일 찾아서 내용 검색
find . -name "*.py" | xargs grep "import os"

파이프는 리눅스의 핵심 철학입니다!

"각 프로그램은 한 가지 일만 잘하자. 그리고 파이프로 연결하자." 이게 바로 유닉스 철학이에요. 복잡한 작업도 간단한 명령어를 파이프로 연결하면 할 수 있습니다.

리다이렉트 - 출력을 파일로 보내기¶

# > 덮어쓰기 (기존 내용이 사라짐!)
ls -la > filelist.txt
echo "Hello" > greeting.txt

# >> 이어쓰기 (기존 내용 뒤에 추가)
echo "새로운 줄" >> greeting.txt
ls -la >> filelist.txt

# 2> 에러만 파일로 저장
python3 script.py 2> error.log

# 출력과 에러를 각각 다른 파일로
python3 script.py > output.txt 2> error.log

# 2>&1 에러를 일반 출력과 같은 곳으로
python3 script.py > all.log 2>&1

# /dev/null: 블랙홀! 출력을 버리고 싶을 때
command > /dev/null 2>&1
# 아무 출력도 보고 싶지 않을 때 사용

리다이렉트 기호 정리¶

기호	이름	설명	예시
`>`	덮어쓰기	파일 내용을 새로 씀	`echo "hi" > file.txt`
`>>`	이어쓰기	파일 끝에 추가	`echo "hi" >> file.txt`
`2>`	에러 리다이렉트	에러 메시지를 파일로	`cmd 2> err.log`
`2>&1`	에러를 출력으로	에러를 일반 출력과 합침	`cmd > all.log 2>&1`
`<`	입력 리다이렉트	파일에서 입력 읽기	`sort < names.txt`

실용 예시 모음¶

# 1. 로그 파일에서 오늘 발생한 에러만 따로 저장
grep "ERROR" server.log | grep "$(date +%Y-%m-%d)" > today_errors.txt

# 2. 시스템 정보를 파일로 저장
echo "=== 시스템 정보 ===" > system_info.txt
echo "날짜: $(date)" >> system_info.txt
uname -a >> system_info.txt
df -h >> system_info.txt
free -h >> system_info.txt

# 3. 특정 확장자 파일 목록 저장
find . -name "*.py" > python_files.txt

# 4. 명령어 도움말 저장
man ls > ls_manual.txt

# 5. 파이썬 패키지 목록 백업
pip list > requirements_backup.txt

9. 환경 변수¶

환경 변수는 시스템 전체에서 사용하는 설정값입니다. 프로그램이 어디에 설치되어 있는지, 어떤 언어를 사용하는지 등을 저장합니다.

환경 변수란?¶

비유: 환경 변수는 학교의 안내 방송 같은 것입니다. "오늘 점심은 A식당에서 12시에"라는 정보를 모든 학생(프로그램)이 들을 수 있죠.

환경 변수 다루기¶

# 환경 변수 값 확인 (echo $변수명)
echo $HOME
# 출력: /home/minjun

echo $USER
# 출력: minjun

echo $SHELL
# 출력: /bin/bash

# PATH 확인 (매우 중요!)
echo $PATH
# 출력: /usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin
# PATH는 명령어를 찾는 경로 목록입니다

# 환경 변수 설정 (현재 세션에서만 유효)
export MY_NAME="minjun"
echo $MY_NAME
# 출력: minjun

# 기존 PATH에 새 경로 추가
export PATH="$PATH:/home/minjun/my_scripts"

# 모든 환경 변수 보기
env
# 또는
printenv

# 특정 환경 변수 검색
env | grep PATH
printenv | grep HOME

영구 설정: `.bashrc` / `.zshrc`¶

터미널에서 export로 설정한 환경 변수는 터미널을 닫으면 사라집니다. 매번 자동으로 설정되게 하려면 설정 파일에 적어두어야 합니다.

# 설정 파일 열기
nano ~/.bashrc
# 또는 (zsh을 쓰는 경우)
nano ~/.zshrc

# 파일 마지막에 추가:
export EDITOR="vim"
export PATH="$PATH:/home/minjun/bin"
export PYTHONPATH="/home/minjun/projects"

# 저장 후 변경사항 적용
source ~/.bashrc

.bashrc vs .zshrc

.bashrc: Bash 셸을 사용할 때 읽히는 설정 파일

.zshrc: Zsh 셸을 사용할 때 읽히는 설정 파일 (macOS 기본)

자신이 어떤 셸을 쓰는지 확인하려면: echo $SHELL

자주 쓰는 환경 변수¶

변수	설명	예시 값
`HOME`	홈 디렉토리	`/home/minjun`
`USER`	현재 사용자	`minjun`
`PATH`	명령어 검색 경로	`/usr/bin:/bin:...`
`SHELL`	현재 셸	`/bin/bash`
`PWD`	현재 디렉토리	`/home/minjun/projects`
`EDITOR`	기본 에디터	`vim` 또는 `nano`
`LANG`	언어 설정	`ko_KR.UTF-8`

10. 압축과 아카이브¶

파일들을 하나로 묶거나, 크기를 줄이는 방법입니다. 프로젝트를 백업하거나, 다운로드한 파일을 풀 때 사용합니다.

`tar` - Tape ARchive (파일 묶기 + 압축)¶

tar는 여러 파일을 하나로 묶는 명령어입니다. 옵션을 외우는 게 핵심!

# 파일/폴더를 하나로 묶기 (-cvf)
tar -cvf project.tar project/
# c: create (생성)
# v: verbose (진행 상황 보여주기)
# f: file (파일 이름 지정)

# 묶은 파일 풀기 (-xvf)
tar -xvf project.tar
# x: extract (풀기)

# gzip으로 압축까지 함께 (-czvf) - 가장 많이 사용!
tar -czvf project.tar.gz project/
# z: gzip 압축

# gzip 압축 풀기 (-xzvf)
tar -xzvf project.tar.gz

# 특정 폴더에 풀기 (-C 옵션)
tar -xzvf project.tar.gz -C /home/minjun/projects/

# 압축 파일 내용만 보기 (-tvf)
tar -tvf project.tar.gz
# t: list (목록 보기)

tar 옵션 외우기: "Create Extract View"

동작 옵션 의미

묶기 -cvf Create + Verbose + File

풀기 -xvf eXtract + Verbose + File

압축 묶기 -czvf Create + gZip + Verbose + File

압축 풀기 -xzvf eXtract + gZip + Verbose + File

내용 보기 -tvf lisT + Verbose + File

`zip` / `unzip`¶

# zip으로 압축
zip archive.zip file1.txt file2.txt

# 폴더 압축 (-r 옵션)
zip -r project.zip project/

# unzip으로 압축 풀기
unzip archive.zip

# 특정 폴더에 풀기 (-d 옵션)
unzip archive.zip -d /home/minjun/extracted/

# 압축 파일 내용만 보기
unzip -l archive.zip

tar vs zip 비교¶

항목	tar.gz	zip
압축률	더 좋음	일반적
호환성	리눅스 표준	윈도우/맥에서도 잘 됨
명령어	`tar -czvf` / `tar -xzvf`	`zip` / `unzip`
추천	리눅스 서버에서	다른 OS와 공유할 때

11. 명령어 치트시트¶

자주 쓰는 명령어를 한눈에 모았습니다. 옆에 두고 필요할 때마다 찾아보세요!

탐색¶

명령어	설명	예시
`pwd`	현재 디렉토리 확인	`pwd`
`ls`	파일 목록 보기	`ls -la`
`cd`	디렉토리 이동	`cd ~/Documents`
`cd ..`	한 단계 위로	`cd ..`
`cd -`	이전 디렉토리로	`cd -`

파일/디렉토리¶

명령어	설명	예시
`mkdir`	폴더 만들기	`mkdir -p projects/python`
`touch`	빈 파일 만들기	`touch hello.py`
`cp`	복사	`cp -r src/ backup/`
`mv`	이동/이름변경	`mv old.py new.py`
`rm`	삭제	`rm -rf old_folder/`
`rm -i`	삭제 전 확인	`rm -i important.txt`

파일 내용¶

명령어	설명	예시
`cat`	전체 내용 보기	`cat file.txt`
`less`	페이지 단위 보기	`less long_file.txt`
`head`	처음 N줄 보기	`head -n 20 file.txt`
`tail`	마지막 N줄 보기	`tail -n 50 file.txt`
`tail -f`	실시간 감시	`tail -f log.txt`
`wc -l`	줄 수 세기	`wc -l data.csv`

검색¶

명령어	설명	예시
`find`	파일 검색	`find . -name "*.py"`
`grep`	내용 검색	`grep -rn "error" .`
`which`	명령어 위치	`which python3`
`locate`	빠른 검색	`locate file.txt`

권한¶

명령어	설명	예시
`chmod`	권한 변경	`chmod 755 script.sh`
`chmod +x`	실행 권한 추가	`chmod +x run.py`
`chown`	소유권 변경	`sudo chown user:group file`
`sudo`	관리자 권한	`sudo apt install git`

패키지 관리¶

명령어	설명	예시
`apt update`	패키지 목록 업데이트	`sudo apt update`
`apt upgrade`	패키지 업그레이드	`sudo apt upgrade`
`apt install`	패키지 설치	`sudo apt install vim`
`apt remove`	패키지 삭제	`sudo apt remove vim`
`apt search`	패키지 검색	`apt search editor`

프로세스¶

명령어	설명	예시
`ps aux`	프로세스 목록	`ps aux \\| grep python`
`top`	실시간 모니터링	`top`
`htop`	예쁜 모니터링	`htop`
`kill`	프로세스 종료	`kill 1234`
`kill -9`	강제 종료	`kill -9 1234`
`killall`	이름으로 종료	`killall python3`
`nohup`	백그라운드 지속	`nohup python3 app.py &`
`Ctrl+C`	실행 중지	(키보드)
`Ctrl+Z`	일시정지	(키보드)

파이프/리다이렉트¶

기호/명령어	설명	예시
`\\|`	파이프 (명령어 연결)	`ls \\| grep ".py"`
`>`	덮어쓰기	`echo "hi" > file.txt`
`>>`	이어쓰기	`echo "hi" >> file.txt`
`2>`	에러를 파일로	`cmd 2> err.log`
`2>&1`	에러를 출력으로	`cmd > log.txt 2>&1`

압축¶

명령어	설명	예시
`tar -czvf`	tar.gz 압축	`tar -czvf backup.tar.gz folder/`
`tar -xzvf`	tar.gz 해제	`tar -xzvf backup.tar.gz`
`zip -r`	zip 압축	`zip -r backup.zip folder/`
`unzip`	zip 해제	`unzip backup.zip`

환경 변수¶

명령어	설명	예시
`export`	환경 변수 설정	`export VAR="value"`
`echo $VAR`	환경 변수 확인	`echo $PATH`
`env`	모든 환경 변수	`env`
`source`	설정 파일 적용	`source ~/.bashrc`

12. 실습 미션¶

자, 이제 배운 것을 직접 해봅시다! 각 미션을 차례대로 도전해보세요.

미션 1: 나만의 프로젝트 폴더 만들기¶

목표: mkdir, cd, touch, ls 연습하기

# 1. 홈 디렉토리로 이동
cd ~

# 2. projects 폴더 만들기
mkdir projects

# 3. projects 안에 들어가기
cd projects

# 4. 다음 구조의 폴더를 만들어 보세요:
#    my-app/
#    ├── src/
#    ├── tests/
#    └── docs/
mkdir -p my-app/src my-app/tests my-app/docs

# 5. 각 폴더에 파일 만들기
touch my-app/src/main.py
touch my-app/src/utils.py
touch my-app/tests/test_main.py
touch my-app/docs/README.md

# 6. 구조 확인하기
ls -R my-app/

# 7. 현재 위치 확인
pwd

확인: ls -R my-app/ 을 실행했을 때 모든 파일과 폴더가 보이면 성공!

미션 2: 파일 탐색과 내용 보기¶

목표: cat, echo, head, tail, wc 연습하기

# 1. 미션 1에서 만든 my-app 폴더로 이동
cd ~/projects/my-app

# 2. 파이썬 파일에 코드 작성하기
echo 'print("Hello, Linux!")' > src/main.py
echo 'def greet(name):' >> src/main.py
echo '    return f"Hello, {name}!"' >> src/main.py
echo '' >> src/main.py
echo 'if __name__ == "__main__":' >> src/main.py
echo '    print(greet("World"))' >> src/main.py

# 3. 파일 내용 확인
cat src/main.py

# 4. README 파일 만들기
echo "# My First Linux Project" > docs/README.md
echo "" >> docs/README.md
echo "## Description" >> docs/README.md
echo "This is my first project using Linux commands." >> docs/README.md
echo "" >> docs/README.md
echo "## How to Run" >> docs/README.md
echo "python3 src/main.py" >> docs/README.md
echo "" >> docs/README.md
echo "## Author" >> docs/README.md
echo "A student learning Linux!" >> docs/README.md

# 5. README의 처음 3줄만 보기
head -n 3 docs/README.md

# 6. README의 마지막 3줄만 보기
tail -n 3 docs/README.md

# 7. README가 몇 줄인지 세기
wc -l docs/README.md

# 8. 파이썬 실행해보기 (선택)
python3 src/main.py

확인: cat src/main.py 를 실행했을 때 파이썬 코드가 보이면 성공!

미션 3: 파일 검색 마스터¶

목표: find, grep 연습하기

# 1. 홈 디렉토리에서 모든 .py 파일 찾기
find ~ -name "*.py" 2>/dev/null
# (2>/dev/null은 권한 에러 메시지를 숨기는 거예요)

# 2. projects 폴더에서 "print"가 들어간 파일 찾기
grep -rn "print" ~/projects/

# 3. README.md에서 "Linux"라는 단어가 있는지 검색
grep -n "Linux" ~/projects/my-app/docs/README.md

# 4. 파이썬 파일에서 "def"로 시작하는 줄 찾기
grep -rn "^def " ~/projects/

# 5. 시스템에서 python3 명령어가 어디에 있는지 찾기
which python3

# 6. 홈 디렉토리에서 1MB보다 큰 파일 찾기
find ~ -size +1M -type f 2>/dev/null | head -n 10

# 7. 7일 이내에 수정된 파일 찾기
find ~/projects -mtime -7

확인: 각 명령어가 에러 없이 결과를 출력하면 성공!

미션 4: 권한과 압축 연습¶

목표: chmod, tar, zip 연습하기

# 1. 미션 1에서 만든 프로젝트로 이동
cd ~/projects

# 2. 스크립트 파일 만들기
echo '#!/bin/bash' > my-app/run.sh
echo 'echo "Running my app..."' >> my-app/run.sh
echo 'python3 src/main.py' >> my-app/run.sh

# 3. 실행 권한 주기
chmod +x my-app/run.sh

# 4. 권한 확인 (x가 있는지)
ls -l my-app/run.sh

# 5. 프로젝트를 tar.gz로 압축
tar -czvf my-app-backup.tar.gz my-app/

# 6. 압축 파일 확인
ls -lh my-app-backup.tar.gz

# 7. 압축 내용 확인 (풀지 않고 보기)
tar -tvf my-app-backup.tar.gz

# 8. 다른 이름으로 압축 풀기
mkdir restored
tar -xzvf my-app-backup.tar.gz -C restored/

# 9. 원본과 복원본 비교
diff -r my-app/ restored/my-app/
# 아무 출력이 없으면 동일한 것!

# 10. (선택) zip으로도 압축해보기
zip -r my-app-backup.zip my-app/

확인: diff -r 명령어가 아무 출력 없이 끝나면 성공! (두 폴더가 동일하다는 뜻)

미션 5: 파이프와 리다이렉트 마스터¶

목표: |, >, >> 연습하기

# 1. 프로젝트 폴더로 이동
cd ~/projects/my-app

# 2. 모든 파이썬 파일 목록을 파일로 저장
find . -name "*.py" > python_files.txt
cat python_files.txt

# 3. 파일 목록에 타임스탬프 추가
echo "--- 생성 시각: $(date) ---" >> python_files.txt

# 4. 모든 파이썬 파일에서 "print" 찾기
grep -rn "print" --include="*.py" . > search_results.txt
cat search_results.txt

# 5. 시스템 정보를 파일로 저장
echo "=== 시스템 정보 리포트 ===" > system_report.txt
echo "작성자: $(whoami)" >> system_report.txt
echo "날짜: $(date)" >> system_report.txt
echo "호스트명: $(hostname)" >> system_report.txt
echo "" >> system_report.txt
echo "=== 디스크 사용량 ===" >> system_report.txt
df -h >> system_report.txt
echo "" >> system_report.txt
echo "=== 메모리 사용량 ===" >> system_report.txt
free -h >> system_report.txt

# 6. 리포트 확인
cat system_report.txt

# 7. 파일 구조를 텍스트로 저장
echo "=== 프로젝트 파일 구조 ===" > structure.txt
find . -print | sed -e 's;[^/]*/;|____;g;s;____|; |;g' >> structure.txt
cat structure.txt

# 8. 프로젝트 내 모든 .py 파일의 총 줄 수 세기
find . -name "*.py" -exec cat {} \; | wc -l

확인: cat system_report.txt 를 실행했을 때 시스템 정보가 예쁘게 정리되어 있으면 성공!

보너스: 모든 미션 완료 후 정리¶

# 모든 실습 파일을 최종 백업
cd ~
tar -czvf linux-practice-final.tar.gz projects/

# 백업 확인
tar -tvf linux-practice-final.tar.gz | head -n 20

# 수고하셨습니다!

마무리¶

축하합니다! 리눅스의 기본을 모두 배웠습니다.

처음에는 명령어가 많고 복잡해 보일 수 있어요. 하지만 계속 쓰다 보면 자연스럽게 외워집니다. 중요한 것은 이 명령어들을 직접 입력해보고, 실습하는 것입니다.

앞으로 해볼 만한 것들:

리눅스 가상머신이나 WSL을 설치해서 매일 조금씩 터미널 써보기
GitHub를 사용하면서 자연스럽게 리눅스 명령어 익히기
나만의 개발 환경 세팅해보기 (Python, Node.js 등)
간단한 서버 띄워보기 (Flask, Express 등)

기억하세요: 모든 전문가도 한때 초보자였습니다. 화이팅!

단축키	동작
`Ctrl+C`	프로그램 강제 종료 (SIGINT)
`Ctrl+Z`	프로그램 일시정지 (백그라운드로)
`Ctrl+D`	입력 종료 (EOF)

동작	옵션	의미
묶기	`-cvf`	Create + Verbose + File
풀기	`-xvf`	eXtract + Verbose + File
압축 묶기	`-czvf`	Create + gZip + Verbose + File
압축 풀기	`-xzvf`	eXtract + gZip + Verbose + File
내용 보기	`-tvf`	lisT + Verbose + File