WireGuard Easy: 웹 UI로 간편하게 관리하는 VPN 서버 구축 완전 가이드

⏱️ 예상 읽기 시간: 14분

서론

원격 근무가 일상이 된 시대, 안전한 VPN 연결이 필수가 되었습니다. WireGuard Easy는 복잡한 WireGuard 설정을 웹 UI로 간편하게 관리할 수 있게 해주는 혁신적인 도구입니다.

기존 VPN 솔루션의 복잡한 설정과 달리, Docker 한 번으로 전체 VPN 서버가 완성되고, 웹 브라우저에서 클라이언트를 쉽게 추가/삭제할 수 있습니다. QR 코드로 모바일 연결도 간단하죠!

왜 WireGuard Easy가 필요한가?

🔒 현대적 보안 요구사항

전통적 VPN (OpenVPN):
복잡한 설정 → 인증서 관리 → 성능 제약 → 관리 어려움

WireGuard Easy:
Docker 실행 → 웹 UI → 즉시 사용 → 간편 관리

🎯 핵심 해결 문제들

1. 원격 근무 보안: 집에서 회사 네트워크 안전 접속
2. 개발 환경 접근: 개발 서버, 데이터베이스 원격 관리
3. 홈 랩 연결: 외부에서 홈 서버 접속
4. 지역 제한 우회: 합법적 범위 내 네트워크 우회
5. 공용 WiFi 보안: 카페, 공항 등 안전하지 않은 네트워크에서 보호

📊 wg-easy vs 다른 VPN 솔루션

기능	wg-easy	OpenVPN	상용 VPN
설치 시간	5분	30분+	즉시
웹 UI	✅	❌	✅
성능	최고	보통	다양
비용	무료	무료	유료
커스터마이징	완전	완전	제한적

시스템 요구사항 및 준비

서버 요구사항

# 최소 사양
- CPU: 1 vCPU
- RAM: 512MB
- 디스크: 1GB
- OS: Ubuntu 20.04+, CentOS 8+, Debian 11+

# 권장 사양 (10+ 클라이언트)
- CPU: 2 vCPU
- RAM: 1GB
- 디스크: 5GB
- 네트워크: 고정 IP 또는 DDNS

네트워크 요구사항

# 포트 설정
- WireGuard: 51820/UDP (기본값)
- Web UI: 51821/TCP (기본값)

# 방화벽 설정 필요
- 클라우드: Security Group/Firewall 규칙
- 홈 네트워크: 공유기 포트포워딩
- Linux: iptables/ufw 설정

Docker 환경 준비

1. Docker 설치

# Ubuntu/Debian
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# 사용자를 docker 그룹에 추가
sudo usermod -aG docker $USER
newgrp docker

# Docker Compose 설치
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

# 설치 확인
docker --version
docker-compose --version

2. 시스템 설정

# IP 포워딩 활성화 (영구 설정)
echo 'net.ipv4.ip_forward=1' | sudo tee -a /etc/sysctl.conf
echo 'net.ipv6.conf.all.forwarding=1' | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

# 방화벽 설정 (Ubuntu UFW 예제)
sudo ufw allow 51820/udp comment 'WireGuard'
sudo ufw allow 51821/tcp comment 'WG-Easy Web UI'
sudo ufw --force enable

# CentOS/RHEL 방화벽 설정
# sudo firewall-cmd --permanent --add-port=51820/udp
# sudo firewall-cmd --permanent --add-port=51821/tcp
# sudo firewall-cmd --reload

WireGuard Easy 설치 및 설정

1. 기본 설치 (Docker Compose)

# 작업 디렉토리 생성
mkdir -p ~/wg-easy && cd ~/wg-easy

# docker-compose.yml 파일 생성
cat > docker-compose.yml << 'EOF'
version: '3.8'

services:
  wg-easy:
    environment:
      # 🚨 서버의 공인 IP 또는 도메인 설정 (필수!)
      - WG_HOST=your-server-ip-or-domain
      
      # 웹 UI 비밀번호 설정
      - PASSWORD=your-secure-password
      
      # WireGuard 포트 (기본값: 51820)
      - WG_PORT=51820
      
      # 기본 클라이언트 수 (나중에 늘릴 수 있음)
      - WG_DEFAULT_DNS=1.1.1.1,8.8.8.8
      
      # 웹 UI 포트
      - WG_ADMIN_PORT=51821
      
      # 내부 네트워크 대역 (기본값)
      - WG_DEFAULT_ADDRESS=10.8.0.x
      
      # 허용할 최대 클라이언트 수
      - WG_MAX_CLIENTS=100
      
      # 클라이언트 만료 시간 (일 단위, 0은 무제한)
      - WG_CLIENT_EXPIRY_DAYS=30
      
    image: ghcr.io/wg-easy/wg-easy
    container_name: wg-easy
    volumes:
      - ~/.wg-easy:/etc/wireguard
    ports:
      - "51820:51820/udp"  # WireGuard 포트
      - "51821:51821/tcp"  # 웹 UI 포트
    restart: unless-stopped
    cap_add:
      - NET_ADMIN
      - SYS_MODULE
    sysctls:
      - net.ipv4.ip_forward=1
      - net.ipv4.conf.all.src_valid_mark=1
    dns:
      - 1.1.1.1
      - 8.8.8.8
EOF

echo "⚠️  WG_HOST와 PASSWORD를 실제 값으로 변경해주세요!"

2. 고급 설정 (추가 보안 기능)

# 고급 설정이 포함된 docker-compose.yml
cat > docker-compose.yml << 'EOF'
version: '3.8'

services:
  wg-easy:
    environment:
      # 기본 설정
      - WG_HOST=your-server-ip-or-domain
      - PASSWORD=your-secure-password
      - WG_PORT=51820
      
      # 고급 보안 설정
      - WG_DEFAULT_DNS=1.1.1.1,8.8.8.8,2606:4700:4700::1111
      - WG_DEFAULT_ADDRESS=10.8.0.x
      - WG_MTU=1420
      - WG_PERSISTENT_KEEPALIVE=25
      
      # 웹 UI 고급 설정
      - WG_ADMIN_PORT=51821
      - WG_MAX_CLIENTS=100
      - WG_CLIENT_EXPIRY_DAYS=30
      
      # 다국어 지원 (한국어)
      - LANG=ko
      
      # 2FA 활성화 (선택사항)
      - WG_ENABLE_2FA=false
      
      # Prometheus 메트릭 (모니터링용)
      - WG_ENABLE_PROMETHEUS=true
      - WG_PROMETHEUS_PORT=9586
      
      # IPv6 지원
      - WG_IPV6=false
      
      # 클라이언트별 트래픽 제한 (MB/day, 0은 무제한)
      - WG_CLIENT_TRAFFIC_LIMIT=0
      
      # 로그 레벨
      - LOG_LEVEL=info
      
    image: ghcr.io/wg-easy/wg-easy
    container_name: wg-easy
    volumes:
      - ~/.wg-easy:/etc/wireguard
      - /lib/modules:/lib/modules:ro
    ports:
      - "51820:51820/udp"
      - "51821:51821/tcp"
      # - "9586:9586/tcp"  # Prometheus 메트릭 (필요시 주석 해제)
    restart: unless-stopped
    cap_add:
      - NET_ADMIN
      - SYS_MODULE
    sysctls:
      - net.ipv4.ip_forward=1
      - net.ipv4.conf.all.src_valid_mark=1
      - net.ipv6.conf.all.forwarding=1
    dns:
      - 1.1.1.1
      - 8.8.8.8
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"
    
    # 헬스체크 추가
    healthcheck:
      test: ["CMD-SHELL", "curl -f http://localhost:51821 || exit 1"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

EOF

3. 설정 파일 커스터마이징

# 실제 서버 IP/도메인으로 설정 변경
read -p "서버 IP 또는 도메인을 입력하세요: " SERVER_HOST
read -s -p "웹 UI 비밀번호를 입력하세요: " WEB_PASSWORD
echo

# 자동으로 설정 파일 업데이트
sed -i "s/your-server-ip-or-domain/${SERVER_HOST}/g" docker-compose.yml
sed -i "s/your-secure-password/${WEB_PASSWORD}/g" docker-compose.yml

echo "✅ 설정이 완료되었습니다!"

WireGuard Easy 실행 및 관리

1. 서비스 시작

# 컨테이너 시작
docker-compose up -d

# 로그 확인
docker-compose logs -f

# 상태 확인
docker-compose ps

2. 웹 UI 접속

# 웹 브라우저에서 접속
# http://서버IP:51821
# 또는
# http://도메인:51821

# 로컬 테스트의 경우
# http://localhost:51821

3. 기본 관리 명령어

# 컨테이너 중지
docker-compose down

# 컨테이너 재시작
docker-compose restart

# 설정 파일 위치 확인
ls -la ~/.wg-easy/

# WireGuard 상태 확인 (컨테이너 내부)
docker exec wg-easy wg show

# 실시간 로그 모니터링
docker-compose logs -f --tail=50

# 컨테이너 리소스 사용량 확인
docker stats wg-easy

웹 UI를 통한 클라이언트 관리

1. 첫 로그인 및 인터페이스

# 웹 UI 접속 후 로그인
1. 브라우저에서 http://서버IP:51821 접속
2. 설정한 비밀번호 입력
3. WireGuard Easy 대시보드 확인

# 대시보드 주요 기능
- 연결된 클라이언트 수 실시간 표시
- 전체 트래픽 통계
- 클라이언트 목록 및 상태
- 새 클라이언트 추가 버튼

2. 클라이언트 추가 및 설정

// 클라이언트 추가 프로세스
클라이언트 추가 단계:
1. "Add Client" 버튼 클릭
2. 클라이언트 이름 입력 (예: "John-iPhone", "Office-Laptop")
3. 선택사항 설정:
   - 만료 날짜 설정
   - 트래픽 제한 설정
   - 특정 IP 주소 할당
4. "Create" 버튼 클릭
5. QR 코드 자동 생성

3. 고급 클라이언트 관리

# 클라이언트별 세부 설정

## 1. 클라이언트 편집
- 클라이언트 이름 변경
- 만료 날짜 수정
- 활성/비활성 전환
- 트래픽 통계 확인

## 2. 대량 클라이언트 관리
- CSV 내보내기/가져오기
- 일괄 만료 날짜 설정
- 그룹별 관리 (태그 시스템)

## 3. 보안 관리
- 클라이언트별 접근 권한
- IP 화이트리스트/블랙리스트
- 연결 시간 제한

4. QR 코드 및 설정 파일 관리

# QR 코드를 통한 모바일 설정
1. 웹 UI에서 클라이언트 QR 코드 클릭
2. 모바일 WireGuard 앱에서 QR 코드 스캔
3. 자동으로 VPN 설정 완료

# 설정 파일 다운로드 (PC/Mac용)
1. 클라이언트 이름 옆 "Download" 버튼 클릭
2. .conf 파일 다운로드
3. WireGuard 클라이언트에서 파일 가져오기

# 원클릭 링크 생성 (고급 기능)
- 임시 링크 생성으로 설정 파일 안전 공유
- 링크 만료 시간 설정 가능
- 다운로드 횟수 제한 가능

클라이언트 설치 및 연결

1. Windows 클라이언트 설정

# WireGuard for Windows 설치
1. https://www.wireguard.com/install/ 접속
2. "Download Windows Installer" 다운로드
3. 관리자 권한으로 설치

# 설정 파일 가져오기
1. WireGuard 실행
2. "Import tunnel(s) from file" 클릭
3. 다운로드한 .conf 파일 선택
4. "Activate" 버튼으로 연결

# 연결 확인
1. 상태가 "Active"로 변경 확인
2. 웹 UI에서 클라이언트 연결 상태 확인
3. IP 주소 변경 확인: https://whatismyipaddress.com/

2. macOS 클라이언트 설정

# WireGuard for macOS 설치
1. App Store에서 "WireGuard" 검색 및 설치
   또는
2. https://www.wireguard.com/install/ 에서 직접 다운로드

# 설정 방법
1. WireGuard 앱 실행
2. "+" 버튼 → "Import from File or Archive"
3. .conf 파일 선택
4. "Allow" 클릭하여 VPN 구성 추가
5. 토글 스위치로 연결/해제

# 메뉴바 설정
- "Show in Menu Bar" 옵션 활성화
- 메뉴바에서 빠른 연결/해제 가능

3. 모바일 클라이언트 설정

# Android/iOS WireGuard 앱 설치
- Google Play Store 또는 App Store에서 "WireGuard" 설치

# QR 코드로 설정 (권장)
1. WireGuard 앱 실행
2. "+" 버튼 → "Scan from QR code"
3. 웹 UI의 QR 코드 스캔
4. 터널 이름 확인 후 "Create Tunnel"
5. VPN 연결 허용 팝업에서 "OK"

# 수동 설정 파일 추가
1. .conf 파일을 모바일로 전송 (이메일, 클라우드 등)
2. WireGuard 앱에서 "Import from File"
3. 파일 선택 후 설정 완료

4. Linux 클라이언트 설정

# WireGuard 설치 (Ubuntu/Debian)
sudo apt update
sudo apt install wireguard wireguard-tools

# 설정 파일 복사
sudo cp downloaded-config.conf /etc/wireguard/wg0.conf

# 수동 연결
sudo wg-quick up wg0

# 연결 해제
sudo wg-quick down wg0

# 자동 시작 설정
sudo systemctl enable wg-quick@wg0
sudo systemctl start wg-quick@wg0

# 상태 확인
sudo wg show
sudo systemctl status wg-quick@wg0

# NetworkManager를 사용하는 경우
sudo apt install network-manager-openvpn-gnome
# GUI에서 VPN 설정 추가 가능

고급 설정 및 최적화

1. 네트워크 최적화

# 서버측 커널 파라미터 최적화
cat > /etc/sysctl.d/99-wireguard.conf << 'EOF'
# WireGuard 최적화
net.core.default_qdisc = fq
net.ipv4.tcp_congestion_control = bbr
net.core.rmem_max = 134217728
net.core.wmem_max = 134217728
net.ipv4.tcp_rmem = 4096 65536 134217728
net.ipv4.tcp_wmem = 4096 65536 134217728
net.ipv4.tcp_slow_start_after_idle = 0

# IPv4 포워딩
net.ipv4.ip_forward = 1
net.ipv4.conf.all.src_valid_mark = 1

# IPv6 지원 (필요시)
net.ipv6.conf.all.forwarding = 1
EOF

sudo sysctl -p /etc/sysctl.d/99-wireguard.conf

2. 방화벽 규칙 세밀 조정

# iptables 규칙 추가 (Ubuntu/Debian)
sudo iptables -t nat -A POSTROUTING -s 10.8.0.0/24 -o eth0 -j MASQUERADE
sudo iptables -A INPUT -p udp --dport 51820 -j ACCEPT
sudo iptables -A FORWARD -i wg0 -j ACCEPT
sudo iptables -A FORWARD -o wg0 -j ACCEPT

# 규칙 영구 저장
sudo iptables-save > /etc/iptables/rules.v4

# 특정 포트만 허용하는 제한적 규칙
sudo iptables -A FORWARD -i wg0 -p tcp --dport 80 -j ACCEPT
sudo iptables -A FORWARD -i wg0 -p tcp --dport 443 -j ACCEPT
sudo iptables -A FORWARD -i wg0 -p tcp --dport 22 -j ACCEPT
sudo iptables -A FORWARD -i wg0 -j DROP

# UFW를 사용하는 경우
sudo ufw route allow in on wg0 out on eth0
sudo ufw route allow in on eth0 out on wg0

3. Docker Compose 추가 서비스

# 모니터링 및 로그 관리가 포함된 docker-compose.yml
version: '3.8'

services:
  wg-easy:
    environment:
      - WG_HOST=your-server-ip-or-domain
      - PASSWORD=your-secure-password
      - WG_PORT=51820
      - WG_ENABLE_PROMETHEUS=true
      - WG_PROMETHEUS_PORT=9586
    image: ghcr.io/wg-easy/wg-easy
    container_name: wg-easy
    volumes:
      - ~/.wg-easy:/etc/wireguard
    ports:
      - "51820:51820/udp"
      - "51821:51821/tcp"
      - "9586:9586/tcp"
    restart: unless-stopped
    cap_add:
      - NET_ADMIN
      - SYS_MODULE
    sysctls:
      - net.ipv4.ip_forward=1
      - net.ipv4.conf.all.src_valid_mark=1
    networks:
      - wireguard

  # Prometheus 모니터링 (선택사항)
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
    networks:
      - wireguard
    restart: unless-stopped

  # Grafana 대시보드 (선택사항)
  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
    volumes:
      - grafana-data:/var/lib/grafana
    networks:
      - wireguard
    restart: unless-stopped

networks:
  wireguard:
    driver: bridge

volumes:
  grafana-data:

4. SSL/TLS 보안 설정 (Reverse Proxy)

# Nginx 리버스 프록시 설정
cat > nginx-wireguard.conf << 'EOF'
server {
    listen 80;
    server_name your-domain.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name your-domain.com;

    ssl_certificate /etc/letsencrypt/live/your-domain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/your-domain.com/privkey.pem;
    
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;
    
    # Security headers
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
    add_header X-Frame-Options DENY always;
    add_header X-Content-Type-Options nosniff always;
    
    location / {
        proxy_pass http://localhost:51821;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_cache_bypass $http_upgrade;
    }
}
EOF

# Let's Encrypt SSL 인증서 자동 설정
sudo apt install certbot python3-certbot-nginx
sudo certbot --nginx -d your-domain.com

실전 활용 사례

1. 홈 오피스 VPN 구축

# 시나리오: 집에서 회사 네트워크 접속
구성:
- 서버: 회사 사무실 또는 클라우드
- 클라이언트: 집 PC, 노트북, 모바일

# 설정 방법
1. 회사 방화벽에 51820 포트 오픈
2. 내부 네트워크 대역 설정 (예: 192.168.1.0/24)
3. 직원별 클라이언트 생성
4. 회사 리소스 접근 규칙 설정

# 접근 제어 예시
# 개발팀: 개발 서버만 접근
iptables -A FORWARD -i wg0 -s 10.8.0.10/32 -d 192.168.1.100/32 -j ACCEPT

# 관리팀: 모든 내부 서버 접근
iptables -A FORWARD -i wg0 -s 10.8.0.20/32 -d 192.168.1.0/24 -j ACCEPT

2. 개발 환경 접근용 VPN

# 시나리오: 외부에서 개발 서버 접속
개발 서버 구성:
- Web Server: 192.168.1.10:80,443
- Database: 192.168.1.11:3306,5432
- Redis: 192.168.1.12:6379
- Elasticsearch: 192.168.1.13:9200

# 개발자별 설정 자동화 스크립트
cat > create-dev-client.sh << 'EOF'
#!/bin/bash

DEV_NAME=$1
if [ -z "$DEV_NAME" ]; then
    echo "사용법: $0 <개발자이름>"
    exit 1
fi

# WireGuard Easy API를 통한 클라이언트 생성
curl -X POST http://localhost:51821/api/clients \
  -H "Authorization: Bearer your-api-token" \
  -H "Content-Type: application/json" \
  -d "{
    \"name\": \"${DEV_NAME}-dev\",
    \"address\": \"10.8.0.$(shuf -i 10-100 -n 1)\",
    \"expiryDays\": 30,
    \"allowedIPs\": \"192.168.1.0/24\"
  }"

echo "개발자 ${DEV_NAME}의 VPN 클라이언트가 생성되었습니다."
EOF

chmod +x create-dev-client.sh
./create-dev-client.sh john

3. 멀티 사이트 연결

# 시나리오: 여러 지점 간 VPN 연결
구성:
- 본사: WireGuard Server (Seoul)
- 지점1: WireGuard Client (Busan) 
- 지점2: WireGuard Client (Daegu)

# Site-to-Site VPN 설정
# 각 지점별 서브넷 분할
Seoul Office: 10.8.1.0/24
Busan Office: 10.8.2.0/24  
Daegu Office: 10.8.3.0/24

# 라우팅 규칙 추가
ip route add 10.8.2.0/24 via 10.8.0.10  # Busan Gateway
ip route add 10.8.3.0/24 via 10.8.0.11  # Daegu Gateway

4. 클라우드 리소스 보안 접근

# 시나리오: AWS/GCP 인스턴스 보안 접근
구성:
- VPN 서버: 퍼블릭 서브넷
- 애플리케이션 서버: 프라이빗 서브넷
- 데이터베이스: 프라이빗 서브넷

# AWS Security Group 설정
# VPN Server Security Group
Inbound:
- 51820/UDP: 0.0.0.0/0 (WireGuard)
- 51821/TCP: 관리자IP/32 (Web UI)
- 22/TCP: 관리자IP/32 (SSH)

# Application Server Security Group  
Inbound:
- 80,443/TCP: VPN서버SG (Web Traffic)
- 22/TCP: VPN서버SG (SSH via VPN)

# Database Security Group
Inbound:
- 3306/TCP: 애플리케이션서버SG (MySQL)
- 22/TCP: VPN서버SG (Admin SSH)

5. 모바일 팀 관리

# 시나리오: 영업팀 모바일 VPN 관리
특징:
- 자주 변경되는 클라이언트 목록
- 지역별 접근 제어
- 임시 접근 권한 필요

# 임시 클라이언트 생성 스크립트
cat > create-temp-client.sh << 'EOF'
#!/bin/bash

CLIENT_NAME=$1
EXPIRY_DAYS=${2:-7}  # 기본 7일
REGION=${3:-"ALL"}   # 기본 모든 지역

# 클라이언트 생성
CLIENT_IP=$(docker exec wg-easy wg-easy add-client \
  --name "${CLIENT_NAME}" \
  --expiry-days "${EXPIRY_DAYS}" \
  --region "${REGION}")

# QR 코드 이메일 발송
python3 send-qr-email.py \
  --client-name "${CLIENT_NAME}" \
  --client-ip "${CLIENT_IP}" \
  --expiry-days "${EXPIRY_DAYS}"

echo "임시 클라이언트 ${CLIENT_NAME} 생성 완료 (${EXPIRY_DAYS}일간 유효)"
EOF

# 사용 예시
./create-temp-client.sh "김영업-출장" 3 "SEOUL"

모니터링 및 문제 해결

1. 실시간 모니터링 설정

# WireGuard 연결 상태 모니터링
cat > monitor-wireguard.sh << 'EOF'
#!/bin/bash

echo "=== WireGuard 연결 상태 ==="
docker exec wg-easy wg show

echo -e "\n=== 활성 클라이언트 ==="
docker exec wg-easy wg show wg0 peers

echo -e "\n=== 트래픽 통계 ==="
docker exec wg-easy wg show wg0 transfer

echo -e "\n=== 컨테이너 상태 ==="
docker stats wg-easy --no-stream

echo -e "\n=== 시스템 리소스 ==="
free -h
df -h /
EOF

chmod +x monitor-wireguard.sh

# 주기적 모니터링 (cron)
echo "*/5 * * * * /path/to/monitor-wireguard.sh >> /var/log/wireguard-monitor.log" | crontab -

2. 로그 분석 및 알림

# 로그 분석 스크립트
cat > analyze-logs.sh << 'EOF'
#!/bin/bash

LOG_FILE="/var/log/wireguard-monitor.log"
ALERT_EMAIL="admin@company.com"

# 연결 실패 감지
FAILED_CONNECTIONS=$(docker logs wg-easy 2>&1 | grep -c "handshake failed")

if [ "$FAILED_CONNECTIONS" -gt 10 ]; then
    echo "경고: 연결 실패가 ${FAILED_CONNECTIONS}회 발생했습니다." | \
    mail -s "WireGuard 연결 실패 알림" "$ALERT_EMAIL"
fi

# 높은 트래픽 감지
HIGH_TRAFFIC_CLIENTS=$(docker exec wg-easy wg show wg0 transfer | \
  awk '$3 > 1000000000 {print $1}')  # 1GB 이상

if [ -n "$HIGH_TRAFFIC_CLIENTS" ]; then
    echo "높은 트래픽 사용 클라이언트: $HIGH_TRAFFIC_CLIENTS" | \
    mail -s "WireGuard 트래픽 알림" "$ALERT_EMAIL"
fi
EOF

chmod +x analyze-logs.sh

3. 백업 및 복구

# 설정 백업 스크립트
cat > backup-wireguard.sh << 'EOF'
#!/bin/bash

BACKUP_DIR="/backup/wireguard"
DATE=$(date +%Y%m%d_%H%M%S)

mkdir -p "$BACKUP_DIR"

# WireGuard 설정 백업
tar -czf "$BACKUP_DIR/wg-easy-config-$DATE.tar.gz" \
  ~/.wg-easy/ \
  docker-compose.yml

# 데이터베이스 백업 (웹 UI 설정)
docker exec wg-easy sqlite3 /etc/wireguard/wg-easy.db ".backup /tmp/wg-easy-$DATE.db"
docker cp wg-easy:/tmp/wg-easy-$DATE.db "$BACKUP_DIR/"

# 오래된 백업 삭제 (30일 이상)
find "$BACKUP_DIR" -name "*.tar.gz" -mtime +30 -delete
find "$BACKUP_DIR" -name "*.db" -mtime +30 -delete

echo "백업 완료: $BACKUP_DIR/wg-easy-config-$DATE.tar.gz"
EOF

# 자동 백업 설정 (매일 새벽 2시)
echo "0 2 * * * /path/to/backup-wireguard.sh" | crontab -

# 복구 스크립트
cat > restore-wireguard.sh << 'EOF'
#!/bin/bash

BACKUP_FILE=$1
if [ -z "$BACKUP_FILE" ]; then
    echo "사용법: $0 <백업파일.tar.gz>"
    exit 1
fi

# 서비스 중지
docker-compose down

# 설정 복구
tar -xzf "$BACKUP_FILE" -C /

# 서비스 재시작
docker-compose up -d

echo "복구 완료"
EOF

chmod +x backup-wireguard.sh restore-wireguard.sh

4. 성능 튜닝

# 성능 테스트 스크립트
cat > performance-test.sh << 'EOF'
#!/bin/bash

echo "=== WireGuard 성능 테스트 ==="

# 지연시간 테스트
echo "1. 지연시간 테스트"
ping -c 10 10.8.0.1

# 대역폭 테스트 (iperf3 필요)
echo -e "\n2. 대역폭 테스트"
# 서버에서 실행: docker run -d --rm -p 5201:5201 networkstatic/iperf3 -s
# 클라이언트에서 실행:
# iperf3 -c 서버IP -t 30

# 동시 연결 테스트
echo -e "\n3. 동시 연결 수"
docker exec wg-easy wg show wg0 peers | wc -l

# CPU/메모리 사용률
echo -e "\n4. 리소스 사용률"
docker stats wg-easy --no-stream --format "table \t\t"
EOF

chmod +x performance-test.sh

보안 강화 및 베스트 프랙티스

1. 고급 보안 설정

# 2단계 인증 활성화
cat > enable-2fa.sh << 'EOF'
#!/bin/bash

# Google Authenticator 설정
docker exec -it wg-easy bash -c "
  apt update && apt install -y libpam-google-authenticator
  google-authenticator -t -d -f -r 3 -R 30 -w 3
"

# 웹 UI에 2FA 통합
# docker-compose.yml에 환경변수 추가
# - WG_ENABLE_2FA=true
# - WG_2FA_ISSUER=CompanyVPN

echo "2FA가 활성화되었습니다. QR 코드를 스캔하세요."
EOF

# Fail2Ban 설정 (무차별 대입 공격 방지)
cat > /etc/fail2ban/jail.local << 'EOF'
[DEFAULT]
bantime = 3600
findtime = 600
maxretry = 5

[wireguard-webui]
enabled = true
port = 51821
protocol = tcp
filter = wireguard-webui
logpath = /var/log/wireguard.log
maxretry = 3
bantime = 86400
EOF

# 로그 로테이션 설정
cat > /etc/logrotate.d/wireguard << 'EOF'
/var/log/wireguard*.log {
    daily
    missingok
    rotate 7
    compress
    delaycompress
    notifempty
    postrotate
        docker kill -s USR1 wg-easy 2>/dev/null || true
    endscript
}
EOF

2. 네트워크 분할 및 접근 제어

# VLAN 기반 네트워크 분할
cat > setup-vlans.sh << 'EOF'
#!/bin/bash

# 부서별 VLAN 설정
# 개발팀: 10.8.10.0/24
# 마케팅팀: 10.8.20.0/24  
# 관리팀: 10.8.30.0/24

# iptables 규칙 설정
# 개발팀은 개발 서버만 접근
iptables -A FORWARD -s 10.8.10.0/24 -d 192.168.100.0/24 -j ACCEPT
iptables -A FORWARD -s 10.8.10.0/24 -j DROP

# 관리팀은 모든 서버 접근
iptables -A FORWARD -s 10.8.30.0/24 -d 192.168.0.0/16 -j ACCEPT

# 마케팅팀은 웹 서버만 접근
iptables -A FORWARD -s 10.8.20.0/24 -d 192.168.200.0/24 -p tcp --dport 80 -j ACCEPT
iptables -A FORWARD -s 10.8.20.0/24 -d 192.168.200.0/24 -p tcp --dport 443 -j ACCEPT
iptables -A FORWARD -s 10.8.20.0/24 -j DROP

echo "부서별 네트워크 분할이 설정되었습니다."
EOF

chmod +x setup-vlans.sh

3. 감사 로그 및 컴플라이언스

# 상세 감사 로그 설정
cat > setup-audit-logs.sh << 'EOF'
#!/bin/bash

# rsyslog 설정으로 상세 로그 수집
cat >> /etc/rsyslog.conf << 'RSYSLOG_EOF'
# WireGuard 감사 로그
:msg,contains,"wireguard" /var/log/wireguard-audit.log
& stop
RSYSLOG_EOF

# 로그 포맷 정의
cat > /etc/rsyslog.d/20-wireguard.conf << 'RSYSLOG_CONF'
# WireGuard 연결 로그 템플릿
template(name="WireGuardFormat" type="string"
    string="%timestamp:::date-rfc3339% %hostname% %programname%: %msg%\n")

# 모든 WireGuard 관련 로그를 별도 파일로
if $programname == 'wireguard' then {
    action(type="omfile" file="/var/log/wireguard-audit.log" template="WireGuardFormat")
    stop
}
RSYSLOG_CONF

systemctl restart rsyslog

echo "감사 로그 설정이 완료되었습니다."
EOF

# 로그 분석 대시보드 (ELK 스택 연동)
cat > docker-compose-elk.yml << 'EOF'
version: '3.8'

services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.8.0
    environment:
      - discovery.type=single-node
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
    ports:
      - "9200:9200"
    volumes:
      - elasticsearch-data:/usr/share/elasticsearch/data

  logstash:
    image: docker.elastic.co/logstash/logstash:8.8.0
    volumes:
      - ./logstash.conf:/usr/share/logstash/pipeline/logstash.conf
      - /var/log/wireguard-audit.log:/var/log/wireguard-audit.log:ro
    depends_on:
      - elasticsearch

  kibana:
    image: docker.elastic.co/kibana/kibana:8.8.0
    ports:
      - "5601:5601"
    environment:
      - ELASTICSEARCH_HOSTS=http://elasticsearch:9200
    depends_on:
      - elasticsearch

volumes:
  elasticsearch-data:
EOF

클라우드 배포 가이드

1. AWS EC2 배포

# AWS EC2 인스턴스 생성 및 설정
# 사용자 데이터 스크립트 (EC2 생성 시 사용)
cat > aws-userdata.sh << 'EOF'
#!/bin/bash

# 시스템 업데이트
apt update && apt upgrade -y

# Docker 설치
curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh

# Docker Compose 설치
curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose

# 방화벽 설정
ufw allow 51820/udp
ufw allow 51821/tcp
ufw allow 22/tcp
ufw --force enable

# IP 포워딩 활성화
echo 'net.ipv4.ip_forward=1' >> /etc/sysctl.conf
sysctl -p

# WireGuard Easy 설정
mkdir -p /opt/wireguard
cd /opt/wireguard

# 메타데이터에서 퍼블릭 IP 가져오기
PUBLIC_IP=$(curl -s http://169.254.169.254/latest/meta-data/public-ipv4)

cat > docker-compose.yml << COMPOSE_EOF
version: '3.8'
services:
  wg-easy:
    environment:
      - WG_HOST=${PUBLIC_IP}
      - PASSWORD=ChangeThisPassword123!
      - WG_PORT=51820
      - WG_DEFAULT_DNS=1.1.1.1,8.8.8.8
    image: ghcr.io/wg-easy/wg-easy
    container_name: wg-easy
    volumes:
      - ~/.wg-easy:/etc/wireguard
    ports:
      - "51820:51820/udp"
      - "51821:51821/tcp"
    restart: unless-stopped
    cap_add:
      - NET_ADMIN
      - SYS_MODULE
    sysctls:
      - net.ipv4.ip_forward=1
      - net.ipv4.conf.all.src_valid_mark=1
COMPOSE_EOF

# 서비스 시작
docker-compose up -d

# 자동 시작 설정
echo "@reboot cd /opt/wireguard && docker-compose up -d" | crontab -

echo "WireGuard Easy 설치 완료!"
echo "웹 UI: http://${PUBLIC_IP}:51821"
echo "기본 비밀번호: ChangeThisPassword123!"
EOF

# Terraform으로 AWS 인프라 생성
cat > main.tf << 'EOF'
provider "aws" {
  region = "ap-northeast-2"  # Seoul
}

# VPC 생성
resource "aws_vpc" "wireguard_vpc" {
  cidr_block           = "10.0.0.0/16"
  enable_dns_hostnames = true
  enable_dns_support   = true

  tags = {
    Name = "wireguard-vpc"
  }
}

# 퍼블릭 서브넷
resource "aws_subnet" "public_subnet" {
  vpc_id                  = aws_vpc.wireguard_vpc.id
  cidr_block              = "10.0.1.0/24"
  availability_zone       = "ap-northeast-2a"
  map_public_ip_on_launch = true

  tags = {
    Name = "wireguard-public-subnet"
  }
}

# 인터넷 게이트웨이
resource "aws_internet_gateway" "igw" {
  vpc_id = aws_vpc.wireguard_vpc.id

  tags = {
    Name = "wireguard-igw"
  }
}

# 라우팅 테이블
resource "aws_route_table" "public_rt" {
  vpc_id = aws_vpc.wireguard_vpc.id

  route {
    cidr_block = "0.0.0.0/0"
    gateway_id = aws_internet_gateway.igw.id
  }

  tags = {
    Name = "wireguard-public-rt"
  }
}

resource "aws_route_table_association" "public_rta" {
  subnet_id      = aws_subnet.public_subnet.id
  route_table_id = aws_route_table.public_rt.id
}

# 보안 그룹
resource "aws_security_group" "wireguard_sg" {
  name        = "wireguard-sg"
  description = "Security group for WireGuard server"
  vpc_id      = aws_vpc.wireguard_vpc.id

  # WireGuard 포트
  ingress {
    from_port   = 51820
    to_port     = 51820
    protocol    = "udp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  # 웹 UI 포트 (관리자 IP만 허용)
  ingress {
    from_port   = 51821
    to_port     = 51821
    protocol    = "tcp"
    cidr_blocks = ["YOUR_ADMIN_IP/32"]  # 실제 관리자 IP로 변경
  }

  # SSH 포트 (관리자 IP만 허용)
  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["YOUR_ADMIN_IP/32"]  # 실제 관리자 IP로 변경
  }

  # 모든 아웃바운드 허용
  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }

  tags = {
    Name = "wireguard-sg"
  }
}

# EC2 인스턴스
resource "aws_instance" "wireguard_server" {
  ami                    = "ami-0c6e5afdd23291f73"  # Ubuntu 22.04 LTS (ap-northeast-2)
  instance_type          = "t3.micro"
  key_name               = "your-key-pair"  # 실제 키 페어 이름으로 변경
  vpc_security_group_ids = [aws_security_group.wireguard_sg.id]
  subnet_id              = aws_subnet.public_subnet.id

  user_data = file("aws-userdata.sh")

  root_block_device {
    volume_type = "gp3"
    volume_size = 10
    encrypted   = true
  }

  tags = {
    Name = "wireguard-server"
  }
}

# Elastic IP
resource "aws_eip" "wireguard_eip" {
  instance = aws_instance.wireguard_server.id
  domain   = "vpc"

  tags = {
    Name = "wireguard-eip"
  }
}

# 출력
output "wireguard_public_ip" {
  value = aws_eip.wireguard_eip.public_ip
}

output "web_ui_url" {
  value = "http://${aws_eip.wireguard_eip.public_ip}:51821"
}
EOF

# Terraform 실행
terraform init
terraform plan
terraform apply

2. Google Cloud Platform 배포

# GCP Compute Engine 배포 스크립트
cat > deploy-gcp.sh << 'EOF'
#!/bin/bash

PROJECT_ID="your-project-id"
REGION="asia-northeast3"  # Seoul
ZONE="asia-northeast3-a"

# gcloud CLI 설정
gcloud config set project $PROJECT_ID
gcloud config set compute/region $REGION
gcloud config set compute/zone $ZONE

# 방화벽 규칙 생성
gcloud compute firewall-rules create allow-wireguard \
    --allow udp:51820 \
    --source-ranges 0.0.0.0/0 \
    --description "Allow WireGuard traffic"

gcloud compute firewall-rules create allow-wireguard-ui \
    --allow tcp:51821 \
    --source-ranges YOUR_ADMIN_IP/32 \
    --description "Allow WireGuard Web UI access"

# VM 인스턴스 생성
gcloud compute instances create wireguard-server \
    --zone=$ZONE \
    --machine-type=e2-micro \
    --network-interface=network-tier=PREMIUM,subnet=default \
    --maintenance-policy=MIGRATE \
    --provisioning-model=STANDARD \
    --service-account=YOUR_SERVICE_ACCOUNT \
    --scopes=https://www.googleapis.com/auth/cloud-platform \
    --create-disk=auto-delete=yes,boot=yes,device-name=instance-1,image=projects/ubuntu-os-cloud/global/images/ubuntu-2204-jammy-v20240614,mode=rw,size=10,type=projects/$PROJECT_ID/zones/$ZONE/diskTypes/pd-standard \
    --no-shielded-secure-boot \
    --shielded-vtpm \
    --shielded-integrity-monitoring \
    --reservation-affinity=any \
    --metadata-from-file startup-script=gcp-startup.sh

# 정적 IP 할당
gcloud compute addresses create wireguard-static-ip --region=$REGION
STATIC_IP=$(gcloud compute addresses describe wireguard-static-ip --region=$REGION --format="get(address)")
gcloud compute instances add-access-config wireguard-server --access-config-name="External NAT" --address=$STATIC_IP --zone=$ZONE

echo "WireGuard 서버가 생성되었습니다."
echo "정적 IP: $STATIC_IP"
echo "웹 UI: http://$STATIC_IP:51821"
EOF

# GCP 시작 스크립트
cat > gcp-startup.sh << 'EOF'
#!/bin/bash

apt update && apt upgrade -y
curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh

curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose

# GCP 메타데이터에서 외부 IP 가져오기
EXTERNAL_IP=$(curl -H "Metadata-Flavor: Google" http://metadata.google.internal/computeMetadata/v1/instance/network-interfaces/0/access-configs/0/external-ip)

mkdir -p /opt/wireguard
cd /opt/wireguard

cat > docker-compose.yml << COMPOSE_EOF
version: '3.8'
services:
  wg-easy:
    environment:
      - WG_HOST=${EXTERNAL_IP}
      - PASSWORD=SecurePassword456!
      - WG_PORT=51820
    image: ghcr.io/wg-easy/wg-easy
    container_name: wg-easy
    volumes:
      - ~/.wg-easy:/etc/wireguard
    ports:
      - "51820:51820/udp"
      - "51821:51821/tcp"
    restart: unless-stopped
    cap_add:
      - NET_ADMIN
      - SYS_MODULE
    sysctls:
      - net.ipv4.ip_forward=1
      - net.ipv4.conf.all.src_valid_mark=1
COMPOSE_EOF

sysctl -w net.ipv4.ip_forward=1
echo 'net.ipv4.ip_forward=1' >> /etc/sysctl.conf

docker-compose up -d
EOF

chmod +x deploy-gcp.sh gcp-startup.sh

3. Azure 배포

# Azure CLI 배포 스크립트
cat > deploy-azure.sh << 'EOF'
#!/bin/bash

RESOURCE_GROUP="wireguard-rg"
LOCATION="koreacentral"
VM_NAME="wireguard-vm"
VM_SIZE="Standard_B1s"

# 리소스 그룹 생성
az group create --name $RESOURCE_GROUP --location $LOCATION

# 가상 네트워크 생성
az network vnet create \
    --resource-group $RESOURCE_GROUP \
    --name wireguard-vnet \
    --address-prefix 10.0.0.0/16 \
    --subnet-name wireguard-subnet \
    --subnet-prefix 10.0.1.0/24

# 네트워크 보안 그룹 생성
az network nsg create \
    --resource-group $RESOURCE_GROUP \
    --name wireguard-nsg

# 보안 규칙 추가
az network nsg rule create \
    --resource-group $RESOURCE_GROUP \
    --nsg-name wireguard-nsg \
    --name AllowWireGuard \
    --protocol Udp \
    --priority 1000 \
    --destination-port-range 51820 \
    --access Allow

az network nsg rule create \
    --resource-group $RESOURCE_GROUP \
    --nsg-name wireguard-nsg \
    --name AllowWebUI \
    --protocol Tcp \
    --priority 1001 \
    --destination-port-range 51821 \
    --source-address-prefix YOUR_ADMIN_IP/32 \
    --access Allow

# 퍼블릭 IP 생성
az network public-ip create \
    --resource-group $RESOURCE_GROUP \
    --name wireguard-pip \
    --allocation-method Static \
    --sku Standard

# 네트워크 인터페이스 생성
az network nic create \
    --resource-group $RESOURCE_GROUP \
    --name wireguard-nic \
    --vnet-name wireguard-vnet \
    --subnet wireguard-subnet \
    --public-ip-address wireguard-pip \
    --network-security-group wireguard-nsg

# VM 생성
az vm create \
    --resource-group $RESOURCE_GROUP \
    --name $VM_NAME \
    --nics wireguard-nic \
    --image Ubuntu2204 \
    --size $VM_SIZE \
    --admin-username azureuser \
    --generate-ssh-keys \
    --custom-data azure-cloud-init.yml

# 퍼블릭 IP 가져오기
PUBLIC_IP=$(az network public-ip show --resource-group $RESOURCE_GROUP --name wireguard-pip --query ipAddress -o tsv)

echo "Azure WireGuard 서버가 생성되었습니다."
echo "퍼블릭 IP: $PUBLIC_IP"
echo "웹 UI: http://$PUBLIC_IP:51821"
EOF

# Cloud-init 설정 파일
cat > azure-cloud-init.yml << 'EOF'
#cloud-config
package_upgrade: true
packages:
  - docker.io
  - docker-compose

runcmd:
  - systemctl start docker
  - systemctl enable docker
  - usermod -aG docker azureuser
  - sysctl -w net.ipv4.ip_forward=1
  - echo 'net.ipv4.ip_forward=1' >> /etc/sysctl.conf
  
write_files:
  - path: /opt/wireguard/docker-compose.yml
    content: |
      version: '3.8'
      services:
        wg-easy:
          environment:
            - WG_HOST=AZURE_PUBLIC_IP  # 실제 IP로 변경됨
            - PASSWORD=AzureSecure789!
            - WG_PORT=51820
          image: ghcr.io/wg-easy/wg-easy
          container_name: wg-easy
          volumes:
            - ~/.wg-easy:/etc/wireguard
          ports:
            - "51820:51820/udp"
            - "51821:51821/tcp"
          restart: unless-stopped
          cap_add:
            - NET_ADMIN
            - SYS_MODULE
          sysctls:
            - net.ipv4.ip_forward=1
            - net.ipv4.conf.all.src_valid_mark=1

  - path: /opt/wireguard/start.sh
    permissions: '0755'
    content: |
      #!/bin/bash
      cd /opt/wireguard
      
      # Azure 메타데이터에서 퍼블릭 IP 가져오기
      PUBLIC_IP=$(curl -H Metadata:true "http://169.254.169.254/metadata/instance/network/interface/0/ipv4/ipAddress/0/publicIpAddress?api-version=2017-08-01&format=text")
      
      # docker-compose.yml에서 IP 업데이트
      sed -i "s/AZURE_PUBLIC_IP/${PUBLIC_IP}/g" docker-compose.yml
      
      # 서비스 시작
      docker-compose up -d

final_message: "WireGuard Easy 설치가 완료되었습니다. /opt/wireguard/start.sh를 실행하세요."
EOF

chmod +x deploy-azure.sh

성능 벤치마킹 및 대안 비교

1. WireGuard vs OpenVPN 성능 비교

# 성능 테스트 자동화 스크립트
cat > benchmark-vpn.sh << 'EOF'
#!/bin/bash

echo "=== VPN 성능 벤치마크 테스트 ==="

# 1. 대역폭 테스트 (iperf3)
echo "1. 대역폭 테스트"
echo "WireGuard:"
iperf3 -c 10.8.0.1 -t 30 -f M | grep "sender\|receiver"

echo -e "\nOpenVPN (비교용):"
# OpenVPN 연결 후
# iperf3 -c openvpn-server-ip -t 30 -f M | grep "sender\|receiver"

# 2. 지연시간 테스트
echo -e "\n2. 지연시간 테스트"
echo "WireGuard:"
ping -c 20 10.8.0.1 | tail -n 1

# 3. CPU 사용률 테스트
echo -e "\n3. CPU 사용률 (VPN 트래픽 중)"
echo "WireGuard 서버:"
docker stats wg-easy --no-stream --format ""

# 4. 암호화 오버헤드 측정
echo -e "\n4. 암호화 오버헤드"
# VPN 없이
DIRECT_SPEED=$(iperf3 -c direct-server -t 10 -f M | grep "sender" | awk '{print $7}')
# WireGuard 통해
VPN_SPEED=$(iperf3 -c 10.8.0.1 -t 10 -f M | grep "sender" | awk '{print $7}')

OVERHEAD=$(echo "scale=2; ($DIRECT_SPEED - $VPN_SPEED) / $DIRECT_SPEED * 100" | bc)
echo "직접 연결: ${DIRECT_SPEED} Mbits/sec"
echo "WireGuard: ${VPN_SPEED} Mbits/sec"
echo "오버헤드: ${OVERHEAD}%"
EOF

chmod +x benchmark-vpn.sh

2. 모바일 클라이언트 성능 최적화

# 모바일 최적화 설정
cat > mobile-optimized-config.sh << 'EOF'
#!/bin/bash

echo "모바일 클라이언트 최적화 설정 적용 중..."

# docker-compose.yml 업데이트
cat > docker-compose.yml << 'MOBILE_EOF'
version: '3.8'
services:
  wg-easy:
    environment:
      - WG_HOST=your-server-ip
      - PASSWORD=your-password
      - WG_PORT=51820
      
      # 모바일 최적화 설정
      - WG_MTU=1280              # 모바일 네트워크 최적화
      - WG_PERSISTENT_KEEPALIVE=25  # 연결 유지 (모바일 절전모드 대응)
      - WG_DEFAULT_ALLOWED_IPS=0.0.0.0/0,::/0  # 모든 트래픽 라우팅
      
      # 배터리 절약 설정
      - WG_CLIENT_IDLE_TIMEOUT=300  # 5분 비활성 시 연결 해제
      - WG_MOBILE_OPTIMIZATION=true
      
      # DNS 최적화
      - WG_DEFAULT_DNS=1.1.1.1,8.8.8.8,2606:4700:4700::1111
      
    image: ghcr.io/wg-easy/wg-easy
    container_name: wg-easy
    volumes:
      - ~/.wg-easy:/etc/wireguard
    ports:
      - "51820:51820/udp"
      - "51821:51821/tcp"
    restart: unless-stopped
    cap_add:
      - NET_ADMIN
      - SYS_MODULE
    sysctls:
      - net.ipv4.ip_forward=1
      - net.ipv4.conf.all.src_valid_mark=1
      
      # 모바일 네트워크 최적화 커널 파라미터
      - net.core.rmem_default=262144
      - net.core.rmem_max=16777216
      - net.core.wmem_default=262144
      - net.core.wmem_max=16777216
MOBILE_EOF

docker-compose down
docker-compose up -d

echo "모바일 최적화 설정이 적용되었습니다."
EOF

chmod +x mobile-optimized-config.sh

결론

WireGuard Easy는 복잡한 VPN 설정의 패러다임을 완전히 바꾼 혁신적인 솔루션입니다. Docker 한 줄로 전체 VPN 인프라가 구축되고, 웹 브라우저로 간편하게 관리할 수 있는 시대가 열렸습니다.

🎯 핵심 가치

1. 설치 시간 혁신: 기존 30분 → 5분으로 단축
2. 관리 편의성: 명령줄 → 웹 UI로 사용성 극대화
3. 보안성: 최신 WireGuard 프로토콜 기반 강력한 암호화
4. 확장성: 개인용부터 기업용까지 자유로운 확장

🚀 활용 분야

• 원격 근무: 안전한 홈 오피스 연결
• 개발 환경: 외부에서 개발 서버 접근
• 클라우드 보안: 프라이빗 네트워크 구성
• 사이트 간 연결: 다중 지점 VPN 구축
• 모바일 보안: 공공 WiFi에서의 안전한 연결

🔮 미래 전망

WireGuard Easy는 네트워크 보안의 민주화를 이끌고 있습니다. 앞으로는:

• 제로 트러스트 네트워크 구축의 기본 도구
• 하이브리드 워크 환경의 필수 인프라
• IoT 기기 보안 연결의 표준
• 엣지 컴퓨팅 환경의 핵심 구성요소

복잡했던 VPN이 이제 누구나 쉽게 구축할 수 있는 도구가 되었습니다. 보안과 편의성을 모두 잡은 WireGuard Easy로 안전한 네트워크 환경을 구축해보세요!

---

참고 자료:

• WireGuard Easy GitHub
• 공식 문서

• Star: 20.8k

  Forks: 2k

  License: AGPL-3.0

• 최신 릴리스: v15.1.0 (2025년 7월 1일)

관련 키워드: #WireGuard #wg-easy #VPN #Docker #네트워크보안 #원격접속 #웹UI