Linux 커맨드라인 완전 정복: 개발자가 반드시 알아야 할 100가지 명령어와 실전 활용

# 현재 디렉토리 확인
pwd
# /home/developer/projects

# 디렉토리 이동
cd /var/log          # 절대 경로
cd ../config         # 상대 경로
cd ~                 # 홈 디렉토리
cd -                 # 이전 디렉토리

# 디렉토리 내용 확인
ls -la               # 숨김 파일 포함 상세 목록
ls -lhS              # 파일 크기 순 정렬 (사람이 읽기 쉬운 단위)
ls -lt               # 수정 시간 순 정렬
ls -R                # 재귀적 목록

# find: 디렉토리 트리에서 파일 검색
find /var/log -name "*.log" -mtime -7           # 7일 이내 수정된 .log 파일
find . -type f -size +100M                       # 100MB 이상 파일
find . -name "*.tmp" -exec rm -f {} \;           # .tmp 파일 찾아서 삭제
find . -type f -name "*.js" ! -path "*/node_modules/*"  # node_modules 제외

# locate: 색인 기반 빠른 검색
sudo updatedb        # 데이터베이스 업데이트
locate nginx.conf    # 빠른 파일 검색

# which / whereis: 실행 파일 위치
which python3        # /usr/bin/python3
whereis nginx        # 바이너리, 소스, 매뉴얼 위치

# tree: 디렉토리 구조 시각화
tree -L 2 -I "node_modules|.git"   # 2단계 깊이, 특정 디렉토리 제외

# 디렉토리 생성
mkdir -p project/src/components     # 중간 디렉토리 자동 생성

# 디렉토리 스택 활용
pushd /etc/nginx     # 현재 위치 저장 후 이동
# ... 작업 수행 ...
popd                 # 저장된 위치로 복귀
dirs -v              # 스택 확인

# 복사
cp -r src/ backup/                  # 디렉토리 재귀 복사
cp -p important.conf important.conf.bak  # 권한/타임스탬프 보존

# 이동/이름 변경
mv old_name.txt new_name.txt        # 이름 변경
mv *.log /var/log/archive/          # 여러 파일 이동

# 삭제 (주의!)
rm -rf build/                       # 디렉토리 강제 삭제 (매우 주의)
rm -i *.tmp                         # 삭제 전 확인

# 안전한 대안
trash-put file.txt                  # 휴지통으로 이동 (trash-cli 패키지)

# 권한 변경
chmod 755 script.sh                 # rwxr-xr-x
chmod +x deploy.sh                  # 실행 권한 추가
chmod -R 644 public/                # 재귀적 권한 변경

# 소유권 변경
chown www-data:www-data /var/www    # 소유자:그룹 변경
chown -R developer: project/        # 재귀적 소유자 변경

# 권한 숫자 이해
# r(4) + w(2) + x(1) = 7 (소유자)
# r(4) + x(1)        = 5 (그룹)
# r(4) + x(1)        = 5 (기타)
# 결과: 755

# 심볼릭 링크 (바로가기)
ln -s /usr/local/bin/python3.11 /usr/local/bin/python
ls -la /usr/local/bin/python        # 링크 확인

# 하드 링크
ln original.txt hardlink.txt        # 같은 inode 공유

# 아카이브와 압축
tar -czf backup.tar.gz project/     # gzip 압축 아카이브 생성
tar -xzf backup.tar.gz              # 압축 해제
tar -xjf archive.tar.bz2            # bzip2 압축 해제

zip -r project.zip project/ -x "*/node_modules/*"  # node_modules 제외 zip
unzip project.zip -d /tmp/          # 특정 디렉토리에 해제

# 기본 검색
grep "ERROR" /var/log/syslog              # ERROR 포함 줄 검색
grep -i "warning" app.log                  # 대소문자 무시
grep -r "TODO" src/ --include="*.py"       # Python 파일에서 재귀 검색
grep -n "function" script.js               # 줄 번호 표시

# 정규표현식
grep -E "^[0-9]{4}-[0-9]{2}" access.log   # 날짜 패턴으로 시작하는 줄
grep -P "\d+\.\d+\.\d+\.\d+" access.log   # IP 주소 패턴 (Perl 정규식)
grep -v "^#" config.ini                     # 주석 제외

# 실전: 로그에서 에러 컨텍스트 확인
grep -B 3 -A 5 "Exception" app.log         # 에러 전후 줄 포함

# 실전: 특정 HTTP 상태 코드 추출
grep -oP 'HTTP/\d\.\d" \K5\d{2}' access.log | sort | uniq -c | sort -rn

# 필드 추출
awk '{print $1, $4}' access.log            # 1번째, 4번째 필드 출력
awk -F: '{print $1, $3}' /etc/passwd       # 구분자 지정

# 조건 필터링
awk '$9 >= 500' access.log                 # HTTP 5xx 에러만
awk '$3 > 1000 {print $1, $3}' data.txt    # 3번째 필드가 1000 초과

# 계산
awk '{sum += $5} END {print "Total:", sum}' sales.txt    # 합계
awk '{sum += $1; n++} END {print sum/n}' numbers.txt     # 평균

# 실전: 로그에서 IP별 요청 수 카운트
awk '{print $1}' access.log | sort | uniq -c | sort -rn | head -20

# 실전: CSV 처리
awk -F',' '{
  if ($3 > 100) {
    total += $3
    count++
  }
}
END {
  printf "Average: %.2f\n", total/count
}' sales.csv

# 실전: 특정 시간대 로그 필터링
awk '/2026-03-23 14:[0-5][0-9]/' application.log

# 문자열 치환
sed 's/old/new/g' file.txt                 # 모든 old를 new로
sed -i 's/localhost/0.0.0.0/g' config.yml  # 파일 직접 수정 (-i)
sed -i.bak 's/debug/info/g' app.conf      # 백업 생성 후 수정

# 줄 삭제
sed '/^$/d' file.txt                       # 빈 줄 삭제
sed '/^#/d' config.ini                     # 주석 줄 삭제
sed '1,5d' file.txt                        # 1-5번째 줄 삭제

# 줄 추가/삽입
sed '3a\New line after line 3' file.txt    # 3번째 줄 뒤에 추가
sed '1i\Header Line' file.txt              # 1번째 줄 앞에 삽입

# 실전: 설정 파일에서 특정 블록 추출
sed -n '/\[database\]/,/\[/p' config.ini

# 실전: 여러 치환을 한번에
sed -e 's/foo/bar/g' -e 's/baz/qux/g' -e '/^$/d' input.txt

# cut: 필드 잘라내기
cut -d: -f1,3 /etc/passwd               # 구분자로 필드 추출
cut -c1-10 file.txt                      # 문자 위치로 추출

# sort와 uniq
sort -t: -k3 -n /etc/passwd             # 3번째 필드 숫자 정렬
sort -u file.txt                         # 정렬 + 중복 제거
uniq -c sorted.txt                       # 중복 횟수 카운트

# wc: 카운트
wc -l *.py                               # 파일별 줄 수
find . -name "*.java" | xargs wc -l | tail -1  # Java 전체 줄 수

# head / tail
head -20 file.txt                        # 처음 20줄
tail -f /var/log/syslog                  # 실시간 로그 모니터링
tail -f app.log | grep --line-buffered "ERROR"  # 실시간 에러 필터링

# diff: 파일 비교
diff -u old.conf new.conf               # 통합 diff 형식
diff -rq dir1/ dir2/                     # 디렉토리 비교 (다른 파일만)

# tr: 문자 변환
echo "Hello World" | tr 'A-Z' 'a-z'     # 소문자 변환
cat file.txt | tr -d '\r'               # Windows 줄바꿈 제거

# xargs: 파이프 결과를 인자로 전달
find . -name "*.log" | xargs gzip       # 찾은 파일 압축
cat urls.txt | xargs -P 4 -I {} curl -sO {}  # 4개 병렬 다운로드

# ps: 프로세스 목록
ps aux                                   # 전체 프로세스
ps aux | grep nginx                      # 특정 프로세스 검색
ps -ef --forest                          # 프로세스 트리

# top / htop: 실시간 모니터링
top -o %MEM                              # 메모리 사용량 순
htop                                     # 대화형 모니터링 (더 직관적)

# pgrep / pidof: PID 찾기
pgrep -f "python app.py"                # 이름으로 PID 검색
pidof nginx                              # 프로세스 PID 확인

# kill: 프로세스 종료
kill -15 1234                            # SIGTERM (정상 종료 요청)
kill -9 1234                             # SIGKILL (강제 종료)
killall nginx                            # 이름으로 모든 프로세스 종료
pkill -f "node server"                   # 패턴 매칭으로 종료

# 백그라운드 실행
nohup python server.py > output.log 2>&1 &    # 로그아웃해도 유지
disown %1                                # 현재 쉘에서 분리

# jobs: 백그라운드 작업 관리
jobs -l                                  # 현재 쉘의 백그라운드 작업
fg %1                                    # 포그라운드로 전환
bg %1                                    # 백그라운드에서 계속 실행

# 서비스 상태 확인/제어
sudo systemctl status nginx              # 상태 확인
sudo systemctl start nginx               # 시작
sudo systemctl stop nginx                # 중지
sudo systemctl restart nginx             # 재시작
sudo systemctl reload nginx              # 설정 리로드 (무중단)
sudo systemctl enable nginx              # 부팅 시 자동 시작

# 서비스 로그 확인
journalctl -u nginx -f                   # 실시간 로그
journalctl -u nginx --since "1 hour ago" # 최근 1시간 로그
journalctl -u nginx --no-pager -n 100   # 최근 100줄
journalctl -p err -b                     # 현재 부팅의 에러 로그만

# 서비스 파일 위치 확인
systemctl show nginx -p FragmentPath

# curl: HTTP 요청
curl -s https://api.example.com/data     # 기본 GET
curl -X POST -H "Content-Type: application/json" \
  -d '{"name":"test"}' https://api.example.com/users
curl -o file.zip https://example.com/file.zip  # 파일 다운로드
curl -I https://example.com               # 헤더만 확인
curl -w "@curl-format.txt" -o /dev/null -s https://example.com  # 응답 시간 측정

# wget: 파일 다운로드
wget -c https://example.com/large-file.iso     # 이어받기
wget -r -np -l 2 https://example.com/docs/     # 재귀 다운로드 (2단계)

# 연결 확인
ss -tlnp                                 # 열린 TCP 포트 확인
ss -tlnp | grep :8080                    # 특정 포트 사용 프로세스
netstat -tulpn                           # netstat 대안 (구버전)

# DNS 조회
dig example.com                          # DNS 조회
dig +short example.com A                 # 간단한 A 레코드 조회
dig @8.8.8.8 example.com                # 특정 DNS 서버로 조회
nslookup example.com                     # 간단한 DNS 조회

# 경로 추적
traceroute example.com                   # 네트워크 경로 추적
mtr example.com                          # 실시간 traceroute + ping

# 방화벽 (iptables / nftables)
sudo iptables -L -n -v                   # 현재 규칙 확인
sudo iptables -A INPUT -p tcp --dport 80 -j ACCEPT   # HTTP 포트 허용
sudo iptables -A INPUT -s 192.168.1.0/24 -j ACCEPT   # 특정 서브넷 허용

# 네트워크 인터페이스
ip addr show                             # IP 주소 확인
ip route show                            # 라우팅 테이블

# SSH 키 생성
ssh-keygen -t ed25519 -C "dev@example.com"

# 공개키 복사
ssh-copy-id -i ~/.ssh/id_ed25519.pub user@server

# SSH 접속
ssh user@192.168.1.100
ssh -p 2222 user@server                  # 특정 포트

# ~/.ssh/config
Host production
    HostName 10.0.1.50
    User deploy
    Port 22
    IdentityFile ~/.ssh/prod_key
    ForwardAgent yes

Host staging
    HostName 10.0.2.50
    User deploy
    IdentityFile ~/.ssh/staging_key

Host bastion
    HostName bastion.example.com
    User admin
    IdentityFile ~/.ssh/bastion_key

Host internal-*
    ProxyJump bastion
    User developer

# 로컬 포트 포워딩: 원격 서비스에 로컬로 접근
# 로컬 5432 포트 -> 원격 서버의 DB(5432)에 연결
ssh -L 5432:db-server:5432 bastion-server

# 리버스 포트 포워딩: 로컬 서비스를 원격에서 접근
# 원격의 8080 -> 로컬의 3000
ssh -R 8080:localhost:3000 remote-server

# 동적 포트 포워딩 (SOCKS 프록시)
ssh -D 1080 proxy-server

# 실전: 여러 터널 한번에
ssh -L 5432:db:5432 -L 6379:redis:6379 -L 9200:elastic:9200 bastion

# scp: 간단한 파일 전송
scp local-file.txt user@server:/remote/path/
scp -r local-dir/ user@server:/remote/path/
scp user@server:/remote/file.txt ./local/

# rsync: 효율적인 동기화 (변경분만 전송)
rsync -avz --progress local/ user@server:/remote/
rsync -avz --delete local/ user@server:/remote/     # 원본에 없는 파일 삭제
rsync -avz --exclude "node_modules" --exclude ".git" \
  project/ user@server:/deploy/

#!/bin/bash
set -euo pipefail   # 에러 발생 시 즉시 중단, 미선언 변수 사용 방지

# 변수
APP_NAME="my-app"
VERSION="1.0.0"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)

# 문자열 조작
echo "App: $APP_NAME, Version: $VERSION"
echo "Length: ${#APP_NAME}"              # 문자열 길이
echo "${APP_NAME^^}"                      # 대문자 변환 (MY-APP)
echo "${APP_NAME/my/your}"               # 치환 (your-app)

#!/bin/bash

# 조건문
if [ -f "/etc/nginx/nginx.conf" ]; then
    echo "Nginx config exists"
elif [ -f "/etc/apache2/apache2.conf" ]; then
    echo "Apache config exists"
else
    echo "No web server config found"
fi

# 파일 테스트 연산자
# -f: 파일 존재
# -d: 디렉토리 존재
# -r: 읽기 권한
# -w: 쓰기 권한
# -x: 실행 권한
# -s: 파일 크기가 0보다 큼

# for 루프
for server in web1 web2 web3; do
    echo "Deploying to $server..."
    ssh "$server" "cd /app && git pull && systemctl restart app"
done

# 파일 목록 순회
for file in /var/log/*.log; do
    echo "Processing: $file"
    gzip "$file"
done

# while 루프
while read -r line; do
    echo "Processing: $line"
done < input.txt

# 카운터 루프
count=0
while [ $count -lt 10 ]; do
    echo "Attempt $count"
    ((count++))
done

#!/bin/bash
set -euo pipefail

# 함수 정의
deploy() {
    local environment="$1"
    local version="$2"

    echo "Deploying version $version to $environment..."

    if ! docker pull "myapp:$version" 2>/dev/null; then
        echo "Error: Image myapp:$version not found"
        return 1
    fi

    docker stop myapp 2>/dev/null || true
    docker run -d --name myapp "myapp:$version"
    echo "Deploy complete!"
}

# 에러 핸들링
cleanup() {
    echo "Cleaning up temporary files..."
    rm -rf /tmp/deploy_*
}
trap cleanup EXIT    # 스크립트 종료 시 항상 실행

# getopts로 인자 파싱
usage() {
    echo "Usage: deploy.sh -e ENVIRONMENT -v VERSION [-d]"
    exit 1
}

DRY_RUN=false
while getopts "e:v:dh" opt; do
    case $opt in
        e) ENVIRONMENT="$OPTARG" ;;
        v) VERSION="$OPTARG" ;;
        d) DRY_RUN=true ;;
        h) usage ;;
        *) usage ;;
    esac
done

# 실행
deploy "$ENVIRONMENT" "$VERSION"

#!/bin/bash
set -euo pipefail

BACKUP_DIR="/backup"
DB_NAME="production"
RETENTION_DAYS=30
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="$BACKUP_DIR/${DB_NAME}_$TIMESTAMP.sql.gz"

# 로깅 함수
log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1"
}

# 백업 실행
log "Starting backup of $DB_NAME..."
pg_dump "$DB_NAME" | gzip > "$BACKUP_FILE"

# 백업 검증
if [ -s "$BACKUP_FILE" ]; then
    SIZE=$(du -h "$BACKUP_FILE" | cut -f1)
    log "Backup successful: $BACKUP_FILE ($SIZE)"
else
    log "ERROR: Backup file is empty!"
    exit 1
fi

# 오래된 백업 정리
log "Removing backups older than $RETENTION_DAYS days..."
find "$BACKUP_DIR" -name "${DB_NAME}_*.sql.gz" -mtime +$RETENTION_DAYS -delete

# 남은 백업 수 확인
REMAINING=$(find "$BACKUP_DIR" -name "${DB_NAME}_*.sql.gz" | wc -l)
log "Done. $REMAINING backups remaining."

# 세션 관리
tmux new -s dev                          # 새 세션 생성
tmux ls                                  # 세션 목록
tmux attach -t dev                       # 세션 연결
tmux kill-session -t dev                 # 세션 종료

# ~/.tmux.conf
set -g mouse on                          # 마우스 지원
set -g history-limit 50000               # 스크롤백 버퍼 확대
set -g base-index 1                      # 창 번호 1부터 시작
setw -g pane-base-index 1               # 패널 번호 1부터 시작

# 프리픽스 키 변경 (Ctrl+a)
unbind C-b
set -g prefix C-a

# 직관적 분할 키
bind | split-window -h -c "#{pane_current_path}"
bind - split-window -v -c "#{pane_current_path}"

# Vi 모드
setw -g mode-keys vi

# 이동
h/j/k/l                 왼/아래/위/오른
w / b                    단어 앞/뒤로
0 / $                    줄 시작/끝
gg / G                   파일 처음/끝
:42                      42번째 줄로 이동

# 편집
dd                       줄 삭제
yy                       줄 복사
p                        붙여넣기
u                        실행 취소
Ctrl+r                   다시 실행
.                        마지막 명령 반복

# 검색/치환
/pattern                 앞으로 검색
?pattern                 뒤로 검색
n / N                    다음/이전 결과
:%s/old/new/g            전체 치환
:%s/old/new/gc           확인하며 치환

# 저장/종료
:w                       저장
:q                       종료
:wq                      저장 후 종료
:q!                      저장 안 하고 종료

# 여러 파일 편집
:e filename              파일 열기
:bn / :bp                다음/이전 버퍼
:vs filename             수직 분할 열기

# 매크로
qa                       매크로 a 녹화 시작
q                        녹화 중지
@a                       매크로 a 실행
100@a                    100번 반복 실행

# 블록 편집 (여러 줄 주석 등)
Ctrl+v                   블록 선택
I                        블록 앞에 삽입
Esc                      적용

# 메모리
free -h                                  # 메모리 사용량
cat /proc/meminfo                        # 상세 메모리 정보

# 디스크
df -h                                    # 디스크 사용량
du -sh /var/log/*                        # 디렉토리별 크기
du -h --max-depth=1 / | sort -rh | head -10  # 가장 큰 디렉토리

# 디스크 I/O
iostat -x 1                              # I/O 통계 (1초 간격)
iotop                                    # 프로세스별 I/O 사용량

# CPU 정보
lscpu                                    # CPU 정보
nproc                                    # CPU 코어 수
uptime                                   # 로드 평균

# vmstat: 가상 메모리 통계
vmstat 1 10                              # 1초 간격 10번

# sar: 시스템 활동 보고서
sar -u 1 5                               # CPU 사용률 (1초 간격 5번)
sar -r 1 5                               # 메모리 사용률
sar -n DEV 1 5                           # 네트워크 트래픽

# lsof: 열린 파일 목록
lsof -i :8080                            # 8080 포트 사용 프로세스
lsof -u developer                        # 특정 사용자의 열린 파일
lsof +D /var/log/                        # 특정 디렉토리의 열린 파일

# strace: 시스템 콜 추적 (디버깅용)
strace -f -e trace=network -p 1234       # 네트워크 관련 시스템 콜 추적

sudo apt update                          # 패키지 목록 업데이트
sudo apt upgrade                         # 설치된 패키지 업그레이드
sudo apt install nginx                   # 패키지 설치
sudo apt remove nginx                    # 패키지 제거
sudo apt autoremove                      # 불필요한 패키지 정리
apt search keyword                       # 패키지 검색
apt show nginx                           # 패키지 정보
dpkg -l | grep nginx                     # 설치된 패키지 확인

sudo yum update                          # 업데이트
sudo yum install httpd                   # 설치
sudo yum remove httpd                    # 제거
yum search keyword                       # 검색
rpm -qa | grep httpd                     # 설치된 패키지 확인

brew update                              # Homebrew 업데이트
brew install jq                          # 패키지 설치
brew upgrade                             # 모든 패키지 업그레이드
brew list                                # 설치된 패키지 목록
brew cleanup                             # 캐시 정리

# 이미지 관리
docker images                            # 이미지 목록
docker pull nginx:latest                 # 이미지 다운로드
docker build -t myapp:1.0 .             # 이미지 빌드
docker rmi myapp:1.0                     # 이미지 삭제

# 컨테이너 관리
docker ps                                # 실행 중인 컨테이너
docker ps -a                             # 모든 컨테이너
docker run -d -p 8080:80 --name web nginx  # 백그라운드 실행
docker stop web                          # 컨테이너 중지
docker rm web                            # 컨테이너 삭제

# 디버깅
docker logs -f web                       # 실시간 로그
docker exec -it web /bin/bash            # 컨테이너 내부 접속
docker inspect web                       # 상세 정보

# 정리
docker system prune -a                   # 미사용 리소스 전체 정리
docker volume prune                      # 미사용 볼륨 정리

# 기본 리다이렉트
command > output.txt                     # 표준 출력을 파일로 (덮어쓰기)
command >> output.txt                    # 표준 출력을 파일로 (추가)
command 2> error.log                     # 표준 에러를 파일로
command > output.txt 2>&1                # 표준 출력 + 에러를 같은 파일로
command &> all.log                       # 위와 동일 (Bash 단축형)

# 파이프 체이닝 실전
# 가장 많은 메모리를 사용하는 프로세스 10개
ps aux --sort=-%mem | head -11

# 로그에서 에러 빈도 분석
cat app.log | grep "ERROR" | awk '{print $4}' | sort | uniq -c | sort -rn | head

# 실시간 로그에서 특정 패턴 알림
tail -f app.log | grep --line-buffered "CRITICAL" | while read line; do
    echo "ALERT: $line" | mail -s "Critical Error" admin@example.com
done

# 프로세스 치환
diff <(ssh server1 cat /etc/config) <(ssh server2 cat /etc/config)

# Here document
cat <<'SCRIPT' > /tmp/setup.sh
#!/bin/bash
echo "Running setup..."
apt update && apt install -y nginx
SCRIPT

# 1. 전체 디스크 사용량 확인
df -h

# 2. 큰 디렉토리 찾기
du -h --max-depth=1 / 2>/dev/null | sort -rh | head -10

# 3. 큰 파일 찾기
find / -type f -size +500M 2>/dev/null | head -20

# 4. 삭제되었지만 프로세스가 잡고 있는 파일 확인
lsof +L1

# 5. 로그 파일 정리
sudo journalctl --vacuum-size=500M
find /var/log -name "*.gz" -mtime +30 -delete

# 1. 서비스 상태 확인
sudo systemctl status myapp

# 2. 포트 리스닝 확인
ss -tlnp | grep :8080

# 3. 프로세스 상태 확인
ps aux | grep myapp

# 4. 최근 로그 확인
journalctl -u myapp --since "10 minutes ago" --no-pager

# 5. 리소스 확인 (OOM Killer)
dmesg | grep -i "oom\|killed"

# 1. CPU 소비 프로세스 확인
top -o %CPU -bn1 | head -15

# 2. 특정 프로세스의 스레드 확인
top -H -p $(pgrep myapp)

# 3. 시스템 콜 확인
strace -c -p $(pgrep myapp) -e trace=all

# 4. 로드 평균 히스토리
sar -u 1 10

# 1. DNS 확인
dig api.example.com +short

# 2. 포트 연결 테스트
nc -zv api.example.com 443

# 3. 경로 추적
traceroute api.example.com

# 4. SSL 인증서 확인
openssl s_client -connect api.example.com:443 -servername api.example.com </dev/null 2>/dev/null | openssl x509 -text -noout | grep -A2 "Validity"

# 1. 메모리 사용량 추이 확인
watch -n 5 'free -h'

# 2. 프로세스별 메모리 사용량
ps aux --sort=-%mem | head -10

# 3. 특정 프로세스 메모리 상세
cat /proc/$(pgrep myapp)/status | grep -i "vm\|mem"

# 4. OOM Killer 로그
dmesg -T | grep -i "oom"

# 1. I/O 대기 확인
iostat -x 1 5

# 2. I/O 많이 사용하는 프로세스
iotop -oP

# 3. 디스크 성능 테스트
dd if=/dev/zero of=testfile bs=1G count=1 oflag=direct

# 1. 상세 디버그 모드로 접속 시도
ssh -vvv user@server

# 2. SSH 서비스 상태 확인 (서버에서)
sudo systemctl status sshd

# 3. 방화벽 확인
sudo iptables -L -n | grep 22

# 4. 인증 로그 확인
sudo tail -50 /var/log/auth.log

# 1. 파일 권한 확인
ls -la /path/to/file
namei -l /path/to/file                   # 전체 경로의 권한 확인

# 2. SELinux / AppArmor 확인
getenforce                               # SELinux 상태
ls -Z /path/to/file                      # SELinux 컨텍스트

# 3. ACL 확인
getfacl /path/to/file

# 1. 비정상 로그인 시도 확인
grep "Failed password" /var/log/auth.log | awk '{print $(NF-3)}' | sort | uniq -c | sort -rn | head

# 2. 웹 서버 비정상 접근 확인
awk '$9 == 404' access.log | awk '{print $7}' | sort | uniq -c | sort -rn | head

# 3. 동시 접속 수 확인
ss -tn | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -rn | head

# 1. 좀비 프로세스 확인
ps aux | awk '$8 ~ /Z/ {print}'

# 2. 부모 프로세스 찾기
ps -o ppid= -p ZOMBIE_PID

# 3. 부모 프로세스 재시작으로 정리
kill -SIGCHLD PARENT_PID
# 또는 부모 프로세스 재시작

# 현재 디렉토리에서 가장 큰 파일 10개
find . -type f -exec du -h {} + | sort -rh | head -10

# 특정 포트를 사용하는 프로세스 즉시 종료
kill $(lsof -t -i:8080)

# Git 저장소에서 가장 큰 파일 찾기
git rev-list --objects --all | git cat-file --batch-check='%(objecttype) %(objectname) %(objectsize) %(rest)' | sed -n 's/^blob //p' | sort -snk2 | tail -10

# 서버 응답 시간 측정 (10회 반복)
for i in $(seq 1 10); do curl -o /dev/null -s -w "%{time_total}\n" https://example.com; done

# JSON 파일 예쁘게 출력
cat data.json | python3 -m json.tool
# 또는
cat data.json | jq .

# 파일 인코딩 변환
iconv -f EUC-KR -t UTF-8 input.txt > output.txt

# 현재 쉘의 모든 환경변수를 정렬해서 보기
env | sort

# 특정 확장자 파일의 총 줄 수
find . -name "*.py" -exec wc -l {} + | tail -1