Edge TTS 로컬 배포: 무료 음성 합성 서비스 자가 구축 완벽 가이드

음성 합성(Text-to-Speech, TTS) 서비스를 구축할 때 가장 큰 고민은 비용입니다. Google Cloud TTS, AWS Polly, Azure Speech Services는 사용량당 과금되어 대규모 애플리케이션에서는 비용이 급격히 증가합니다. Edge TTS는 Microsoft의 Edge 브라우저에 내장된 음성 합성 엔진으로, 완전히 무료이면서도 고품질 한국어 음성을 제공합니다.

핵심 결론

• 비용: Edge TTS는 완전 무료, HolySheep AI Gateway를 통한 API 연동 시 월 $0 비용
• 품질: Microsoft의 최신 neural TTS 엔진으로 자연스러운 한국어 음성 생성
• 배포: Docker 기반으로 5분 이내 로컬 서버 구축 가능
• 대안: HolySheep AI의 TTS API는 $0.015/1K 문자로 경쟁력 있는 가격 제공

Edge TTS란?

Edge TTS는 Microsoft Edge 브라우저의 "읽기 aloud" 기능에 사용되는 음성 합성 기술입니다. Python 라이브러리로 제공되며, Azure TTS와 동일한 음성 모델을 사용하면서 추가 비용 없이 무료로 활용할 수 있습니다.

HolySheep AI와 경쟁 서비스 비교

서비스	가격	지연 시간	결제 방식	모델 지원	적합한 팀
HolySheep AI	TTS $0.015/1K문자 LLM 모델 다양	150-300ms	로컬 결제 (신용카드 불필요)	GPT-4.1, Claude, Gemini, DeepSeek, TTS	비용 최적화가 필요한 팀
Edge TTS (로컬)	무료	100-200ms	없음 (자체 서버)	Microsoft 음성 모델	기술력이 있는 개발팀
Google Cloud TTS	$0.016/1K문자 (Standard) $0.042/1K문자 (Neural)	200-400ms	신용카드 필수	다양한 음성 지원	기업 대규모 배포
AWS Polly	$0.004/1K문자 (Standard) $0.016/1K문자 (Neural)	200-350ms	신용카드 필수	60개 이상 음성	AWS 생태계 사용자
Azure Speech	$0.015/1K문자 (Standard) $0.025/1K문자 (Neural)	150-300ms	신용카드 필수	다양한 언어 지원	Microsoft 환경 사용자

Edge TTS 로컬 배포: 단계별 가이드

이 섹션에서는 Edge TTS를 로컬 서버에 배포하는 방법을 설명합니다. Docker 환경이 구축되어 있다고 가정합니다.

1. Docker Compose 설정 파일 생성

version: '3.8'

services:
  edge-tts:
    image: ghcr.io/roohitavaf/edge-tts:latest
    container_name: edge-tts-server
    ports:
      - "8080:8080"
    environment:
      - HOST=0.0.0.0
      - PORT=8080
    restart: unless-stopped
    volumes:
      - ./audio_output:/app/audio
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
      interval: 30s
      timeout: 10s
      retries: 3

2. Edge TTS Python 서버 구축

Docker를 사용하지 않고 직접 Python 서버를 구축하려면 다음 코드를 사용하세요.

# requirements.txt
fastapi==0.109.0
uvicorn==0.27.0
edge-tts==6.1.12
python-multipart==0.0.6

server.py
from fastapi import FastAPI, HTTPException
from fastapi.responses import FileResponse
from pydantic import BaseModel
import edge_tts
import asyncio
import os
from pathlib import Path

app = FastAPI(title="Edge TTS Server")

class TTSRequest(BaseModel):
    text: str
    voice: str = "ko-KR-SunHiNeural"
    rate: str = "+0%"
    volume: str = "+0%"
    pitch: str = "+0Hz"

OUTPUT_DIR = Path("audio_output")
OUTPUT_DIR.mkdir(exist_ok=True)

@app.post("/tts")
async def synthesize_speech(request: TTSRequest):
    """텍스트를 음성으로 변환합니다."""
    try:
        output_file = OUTPUT_DIR / f"tts_{asyncio.get_event_loop().time()}.mp3"
        
        communicate = edge_tts.Communicate(
            request.text,
            request.voice,
            rate=request.rate,
            volume=request.volume,
            pitch=request.pitch
        )
        await communicate.save(str(output_file))
        
        return FileResponse(
            output_file,
            media_type="audio/mpeg",
            filename="output.mp3"
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/voices")
async def list_voices(lang: str = "ko"):
    """지원되는 음성 목록을 반환합니다."""
    voices = await edge_tts.list_voices()
    filtered = [v for v in voices if v["Locale"].startswith(lang)]
    return {"voices": filtered}

@app.get("/health")
async def health_check():
    return {"status": "healthy"}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8080)

3. HolySheep AI Gateway와 통합

Edge TTS 서버를 HolySheep AI Gateway를 통해 프록시하면 모니터링, 로깅, 캐싱 기능을 추가할 수 있습니다.

# holysheep_tts_proxy.py
import requests
import os
from typing import Optional

HOLYSHEEP_API_KEY = os.environ.get("HOLYSHEEP_API_KEY")
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
EDGE_TTS_URL = "http://localhost:8080"

class HolySheepTTSProxy:
    """HolySheep AI Gateway를 통한 TTS 프록시 서비스"""
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = HOLYSHEEP_BASE_URL
        
    def text_to_speech(
        self, 
        text: str, 
        voice: str = "ko-KR-SunHiNeural",
        model: str = "tts-1"
    ) -> bytes:
        """한국어 텍스트를 음성으로 변환합니다."""
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "model": model,
            "input": text,
            "voice": voice
        }
        
        response = requests.post(
            f"{self.base_url}/audio/speech",
            headers=headers,
            json=payload,
            timeout=30
        )
        
        if response.status_code == 200:
            return response.content
        else:
            raise Exception(f"TTS 요청 실패: {response.status_code} - {response.text}")
    
    def list_available_voices(self) -> dict:
        """사용 가능한 음성 목록 조회"""
        headers = {
            "Authorization": f"Bearer {self.api_key}"
        }
        
        response = requests.get(
            f"{self.base_url}/audio/voices",
            headers=headers
        )
        
        return response.json()

사용 예시
if __name__ == "__main__":
    proxy = HolySheepTTSProxy(api_key="YOUR_HOLYSHEEP_API_KEY")
    
    # 한국어 음성 생성
    audio = proxy.text_to_speech(
        text="안녕하세요, HolySheep AI Gateway를 통한 음성 합성 데모입니다.",
        voice="ko-KR-SunHiNeural"
    )
    
    # 파일 저장
    with open("output.mp3", "wb") as f:
        f.write(audio)
    
    print("음성 파일 생성 완료: output.mp3")

4. 지원되는 한국어 음성 목록

# edge_tts_korean_voices.py
import asyncio
import edge_tts

async def get_korean_voices():
    """한국어 지원 음성 목록 조회"""
    voices = await edge_tts.list_voices()
    
    korean_voices = [
        voice for voice in voices 
        if voice["Locale"].startswith("ko-")
    ]
    
    print("=" * 60)
    print("지원되는 한국어 음성 목록")
    print("=" * 60)
    
    for voice in korean_voices:
        print(f"이름: {voice['Name']}")
        print(f"로케일: {voice['Locale']}")
        print(f"성별: {voice['Gender']}")
        print(f"설명: {voice.get('FriendlyName', 'N/A')}")
        print("-" * 40)
    
    return korean_voices

주요 음성 태그
KOREAN_VOICE_TAGS = {
    "SunHiNeural": "한국어 여성 목소리 (선희)",
    "BaOmNeural": "한국어 남성 목소리 (바옴)",
    "JiMinNeural": "한국어 남성 목소리 (지민)",
    "SeoHyeonNeural": "한국어 여성 목소리 (서현)",
    "YunJaeNeural": "한국어 남성 목소리 (윤재)"
}

if __name__ == "__main__":
    voices = asyncio.run(get_korean_voices())
    print(f"\n총 {len(voices)}개의 한국어 음성 지원")

비용 비교 분석

저의 실제 프로젝트 경험에서, 월 100만 문자를 처리하는 음성 합성 시스템을 구축한다고 가정하면:

• Edge TTS (로컬): $0 (서버 비용 별도, 약 $20-50/월)
• HolySheep AI: 월 $15 (100만 문자)
• Google Cloud Neural: 월 $42 (100만 문자)
• AWS Polly Neural: 월 $16 (100만 문자)
• Azure Neural: 월 $25 (100만 문자)

개발 초기 단계나 소규모 프로젝트에는 Edge TTS 로컬 배포가 가장 비용 효율적입니다. 다만 운영 환경에서는 서버 관리 오버헤드를 고려해야 합니다. HolySheep AI는 서버 관리 없이 안정적인 TTS 서비스를 원하는 팀에게 균형 잡힌 선택입니다.

자주 발생하는 오류 해결

오류 1: Edge TTS 연결 시간 초과

# 문제: requests.exceptions.ReadTimeout: HTTPSConnectionPool
해결: 타임아웃 설정 증가 및 재시도 로직 추가

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

def create_session_with_retry():
    """재시도 로직이 포함된 세션 생성"""
    session = requests.Session()
    
    retry_strategy = Retry(
        total=3,
        backoff_factor=1,
        status_forcelist=[429, 500, 502, 503, 504],
    )
    
    adapter = HTTPAdapter(max_retries=retry_strategy)
    session.mount("http://", adapter)
    session.mount("https://", adapter)
    
    return session

사용
session = create_session_with_retry()
response = session.post(
    f"{HOLYSHEEP_BASE_URL}/audio/speech",
    headers=headers,
    json=payload,
    timeout=60  # 60초 타임아웃 설정
)

오류 2: 음성 파일 인코딩 오류

# 문제: audioop.error: not a valid WAV file
해결: 파일 형식 명시적 지정 및 변환 로직

from pydub import AudioSegment
import io

def convert_audio_format(audio_data: bytes, target_format: str = "mp3") -> bytes:
    """오디오 데이터 형식 변환"""
    try:
        audio = AudioSegment.from_mp3(io.BytesIO(audio_data))
        output = io.BytesIO()
        audio.export(output, format=target_format)
        return output.getvalue()
    except Exception as e:
        # WAV로 시도
        try:
            audio = AudioSegment.from_wav(io.BytesIO(audio_data))
            output = io.BytesIO()
            audio.export(output, format=target_format)
            return output.getvalue()
        except Exception as e2:
            print(f"형식 변환 실패: 원본={e}, WAV={e2}")
            raise

오류 3: HolySheep API 키 인증 실패

# 문제: 401 Unauthorized 또는 403 Forbidden
해결: API 키 유효성 검사 및 환경 변수 관리

import os
import requests

def validate_api_key(api_key: str) -> bool:
    """API 키 유효성 검증"""
    if not api_key or len(api_key) < 20:
        return False
    
    response = requests.get(
        "https://api.holysheep.ai/v1/models",
        headers={"Authorization": f"Bearer {api_key}"},
        timeout=10
    )
    
    return response.status_code == 200

환경 변수에서 안전하게 로드
def get_api_key() -> str:
    """환경 변수에서 API 키 로드"""
    api_key = os.environ.get("HOLYSHEEP_API_KEY")
    
    if not api_key:
        raise ValueError(
            "HOLYSHEEP_API_KEY 환경 변수가 설정되지 않았습니다.\n"
            "export HOLYSHEEP_API_KEY='your-api-key'"
        )
    
    if not validate_api_key(api_key):
        raise ValueError("유효하지 않은 API 키입니다.")
    
    return api_key

오류 4: 한국어 텍스트 길이 초과

# 문제: Request too long 또는 음성 출력 불완전
해결: 긴 텍스트 자동 분할 처리

def split_text_for_tts(text: str, max_chars: int = 500) -> list:
    """TTS용 텍스트 분할 (한국어 어절 기준)"""
    sentences = []
    current = []
    current_length = 0
    
    for char in text:
        current.append(char)
        current_length += 1
        
        # 한국어 어절 단위 분할
        if char in '다.' and current_length > max_chars:
            sentences.append(''.join(current))
            current = []
            current_length = 0
    
    if current:
        sentences.append(''.join(current))
    
    return sentences

async def synthesize_long_text(communicate, text: str, output_path: str):
    """긴 텍스트 음성 합성 (청크 단위)"""
    chunks = split_text_for_tts(text)
    
    for i, chunk in enumerate(chunks):
        temp_file = f"temp_{i}.mp3"
        await communicate.presets.AltSave(temp_file)
        # 청크 파일 병합 로직 추가
        print(f"청크 {i+1}/{len(chunks)} 완료")

결론

Edge TTS 로컬 배포는 비용 절감과隐私 보호가 중요한 프로젝트에 이상적인 선택입니다. Microsoft의 고품질 음성 엔진을 무료로 활용할 수 있으며, Docker 기반 배포로 빠른 셋업이 가능합니다.

그러나 서버 관리, 확장성, 유지보수 부담을 고려한다면 HolySheep AI Gateway를 통한 통합이 더 효율적입니다. HolySheep AI는 단일 API 키로 음성 합성과 LLM 서비스를 모두 제공하며, 해외 신용카드 없이 로컬 결제가 가능합니다.

프로젝트 규모와 요구사항에 따라 최적의 선택이 달라지므로, 이 가이드가 합리적인 의사결정에 도움이 되길 바랍니다.

👉 HolySheep AI 가입하고 무료 크레딧 받기