사례 연구: 서울 AI 스타트업의 HolySheep AI 마이그레이션
서울의 어느 AI 스타트업은 자사 Android 앱에 AI 채팅 기능을 도입한 지 8개월이 지난 시점이었다. 일 평균 15,000건의 대화 요청을 처리하고 있었지만, 기존 API 공급사의 불안정한 응답 속도와居高不下 비용에 직면해 있었다. 기존 공급사의 페인포인트:일 평균 응답 실패율: 4.2%
평균 응답 지연 시간: 420ms (P95 기준 1,800ms)
월간 API 비용: $4,200
서버 다운타임: 월평균 3.2시간
한국 리전 부재로 인한 동아시아 사용자 체감 속도 저하저는 마이그레이션 결정 과정에서 세 가지 핵심 요소를 중점적으로 평가했습니다. 첫째, 지금 가입하면 제공되는 무료 크레딧으로 리스크 없는 테스트가 가능했다는 점입니다. 둘째, 서울 리전에 최적화된 API 엔드포인트를 제공하고 있어 동아시아 사용자의 체감 지연 시간이 크게 개선되었습니다. 셋째, DeepSeek V3.2 모델의 경우 토큰당 $0.42로 기존 공급사 대비 60% 이상의 비용 절감이 가능했습니다.
마이그레이션 단계:1단계: base_url 교체 (api.openai.com → api.holysheep.ai/v1)
2단계: API 키 로테이션 및 환경 변수 분리
3단계: 카나리아 배포 (전체 트래픽의 10%부터 시작)
4단계: 모니터링 및 점진적 트래픽 전환 (100% 완료)평균 응답 지연 시간: 180ms (개선율 57%)
P95 응답 지연: 420ms
월간 API 비용: $680 (절감액 $3,520)
응답 실패율: 0.3%
서버 다운타임: 0시간
한국 사용자 체감 속도: 62% 향상프로젝트 설정 및 의존성 구성
저는 Android Jetpack Compose 기반 AI 채팅 앱 개발 시 Kotlin Coroutines와 Flow를 활용한 비동기 처리 아키텍처를 권장합니다. 먼저 프로젝트 수준 build.gradle.kts에 필요한 의존성을 추가합니다.
// settings.gradle.kts
dependencyResolutionManagement {
repositories {
google()
mavenCentral()
maven { url = uri("https://jitpack.io") }
}
}
// app/build.gradle.kts
plugins {
id("com.android.application")
id("org.jetbrains.kotlin.android")
id("org.jetbrains.kotlin.plugin.serialization")
}
android {
namespace = "com.example.ai_chat"
compileSdk = 34
defaultConfig {
applicationId = "com.example.ai_chat"
minSdk = 26
targetSdk = 34
buildConfigField("String", "HOLYSHEEP_BASE_URL", "\"https://api.holysheep.ai/v1\"")
buildConfigField("String", "HOLYSHEEP_API_KEY", "\"YOUR_HOLYSHEEP_API_KEY\"")
}
}
dependencies {
// Jetpack Compose BOM
implementation(platform("androidx.compose:compose-bom:2024.02.00"))
implementation("androidx.compose.ui:ui")
implementation("androidx.compose.ui:ui-graphics")
implementation("androidx.compose.ui:ui-tooling-preview")
implementation("androidx.compose.material3:material3")
implementation("androidx.compose.material:material-icons-extended")
// Networking
implementation("com.squareup.okhttp3:okhttp:4.12.0")
implementation("com.squareup.okhttp3:logging-interceptor:4.12.0")
// Kotlin Serialization
implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.3")
// Coroutines
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.8.0")
// ViewModel Compose
implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.7.0")
implementation("androidx.lifecycle:lifecycle-runtime-compose:2.7.0")
// Navigation Compose
implementation("androidx.navigation:navigation-compose:2.7.7")
// Debug
debugImplementation("androidx.compose.ui:ui-tooling")
debugImplementation("androidx.compose.ui:ui-test-manifest")
}ChatMessage 데이터 모델 및 시리얼라이제이션
AI 채팅 앱에서 메시지 구조는 매우 중요합니다. 저는 OpenAI Chat Completion API 호환 형식을 기반으로 HolySheep AI에 최적화된 데이터 모델을 설계했습니다.
// data/model/ChatModels.kt
package com.example.ai_chat.data.model
import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable
@Serializable
data class Message(
val role: String,
val content: String,
val name: String? = null
)
@Serializable
data class ChatCompletionRequest(
val model: String = "gpt-4.1",
val messages: List,
val temperature: Float = 0.7f,
val max_tokens: Int = 2048,
val stream: Boolean = false
)
@Serializable
data class ChatCompletionResponse(
val id: String,
val object: String,
val created: Long,
val model: String,
val choices: List,
val usage: Usage? = null
)
@Serializable
data class Choice(
val index: Int,
val message: Message,
@SerialName("finish_reason")
val finishReason: String
)
@Serializable
data class Usage(
@SerialName("prompt_tokens")
val promptTokens: Int,
@SerialName("completion_tokens")
val completionTokens: Int,
@SerialName("total_tokens")
val totalTokens: Int
)
@Serializable
data class StreamChunk(
val id: String,
val object: String,
val created: Long,
val model: String,
val choices: List
)
@Serializable
data class StreamChoice(
val index: Int,
val delta: Delta,
@SerialName("finish_reason")
val finishReason: String? = null
)
@Serializable
data class Delta(
val content: String? = null,
val role: String? = null
) HolySheep AI 네트워크 레이어 구현
저는 OkHttp를 기반으로 한 네트워크 레이어를 구현했습니다. 이 구현체는 retry 로직, 타임아웃 설정, 로깅Interceptor를 포함하며 HolySheep AI의 서울 리전 엔드포인트에 최적화되어 있습니다.
// data/remote/HolySheepApiService.kt
package com.example.ai_chat.data.remote
import com.example.ai_chat.BuildConfig
import com.example.ai_chat.data.model.ChatCompletionRequest
import com.example.ai_chat.data.model.ChatCompletionResponse
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import kotlinx.serialization.json.Json
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody
import java.io.IOException
import java.util.concurrent.TimeUnit
class HolySheepApiService {
private val json = Json {
ignoreUnknownKeys = true
isLenient = true
encodeDefaults = true
}
private val client = OkHttpClient.Builder()
.connectTimeout(30, TimeUnit.SECONDS)
.readTimeout(60, TimeUnit.SECONDS)
.writeTimeout(30, TimeUnit.SECONDS)
.addInterceptor { chain ->
val original = chain.request()
val request = original.newBuilder()
.header("Authorization", "Bearer ${BuildConfig.HOLYSHEEP_API_KEY}")
.header("Content-Type", "application/json")
.build()
chain.proceed(request)
}
.addInterceptor(okhttp3.logging.HttpLoggingInterceptor().apply {
level = if (BuildConfig.DEBUG) {
okhttp3.logging.HttpLoggingInterceptor.Level.BODY
} else {
okhttp3.logging.HttpLoggingInterceptor.Level.NONE
}
})
.retryOnConnectionFailure(true)
.build()
companion object {
private const val BASE_URL = BuildConfig.HOLYSHEEP_BASE_URL
private const val CHAT_COMPLETION_ENDPOINT = "$BASE_URL/chat/completions"
}
suspend fun sendMessage(request: ChatCompletionRequest): Result {
return withContext(Dispatchers.IO) {
try {
val jsonBody = json.encodeToString(
ChatCompletionRequest.serializer(),
request
)
val httpRequest = Request.Builder()
.url(CHAT_COMPLETION_ENDPOINT)
.post(jsonBody.toRequestBody("application/json".toMediaType()))
.build()
val response = client.newCall(httpRequest).execute()
val responseBody = response.body?.string()
if (response.isSuccessful && responseBody != null) {
val completionResponse = json.decodeFromString(responseBody)
Result.success(completionResponse)
} else {
val errorMessage = when (response.code) {
401 -> "API 키가 유효하지 않습니다. HolySheep AI 대시보드에서 확인하세요."
429 -> "요청 제한에 도달했습니다. 잠시 후 다시 시도하세요."
500, 502, 503 -> "HolySheep AI 서버 오류입니다. 상태를 확인하세요."
else -> "API 요청 실패: ${response.code} - ${response.message}"
}
Result.failure(ApiException(errorMessage, response.code))
}
} catch (e: IOException) {
Result.failure(ApiException("네트워크 연결을 확인하세요: ${e.message}", -1))
} catch (e: Exception) {
Result.failure(ApiException("예상치 못한 오류: ${e.message}", -1))
}
}
}
}
class ApiException(message: String, val code: Int) : Exception(message) Compose UI 채팅 화면 구현
이제 실제 Jetpack Compose 기반 채팅 UI를 구현하겠습니다. LazyColumn을 활용한 메시지 목록, 입력 필드, 전송 버튼, 그리고 로딩 상태를 모두 포함합니다.
// ui/screens/ChatScreen.kt
package com.example.ai_chat.ui.screens
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.lazy.rememberLazyListState
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.Send
import androidx.compose.material.icons.filled.Person
import androidx.compose.material.icons.filled.Settings
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.lifecycle.viewmodel.compose.viewModel
import com.example.ai_chat.ui.viewmodel.ChatViewModel
import com.example.ai_chat.ui.viewmodel.ChatUiState
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun ChatScreen(
viewModel: ChatViewModel = viewModel(factory = ChatViewModel.Factory)
) {
val uiState by viewModel.uiState.collectAsState()
val listState = rememberLazyListState()
var inputText by remember { mutableStateOf("") }
LaunchedEffect(uiState.messages.size) {
if (uiState.messages.isNotEmpty()) {
listState.animateScrollToItem(uiState.messages.size - 1)
}
}
Scaffold(
topBar = {
TopAppBar(
title = {
Text("HolySheep AI Chat", fontWeight = FontWeight.Bold)
},
colors = TopAppBarDefaults.topAppBarColors(
containerColor = MaterialTheme.colorScheme.primaryContainer
),
actions = {
IconButton(onClick = { /* 설정 화면으로 이동 */ }) {
Icon(Icons.Default.Settings, contentDescription = "설정")
}
}
)
}
) { paddingValues ->
Column(
modifier = Modifier
.fillMaxSize()
.padding(paddingValues)
.background(MaterialTheme.colorScheme.background)
) {
// 메시지 목록
LazyColumn(
state = listState,
modifier = Modifier
.weight(1f)
.fillMaxWidth()
.padding(horizontal = 16.dp),
verticalArrangement = Arrangement.spacedBy(8.dp),
contentPadding = PaddingValues(vertical = 16.dp)
) {
items(uiState.messages, key = { it.id }) { message ->
ChatMessageItem(message = message)
}
// 로딩 중 표시
if (uiState.isLoading) {
item {
Row(
modifier = Modifier
.fillMaxWidth()
.padding(8.dp),
horizontalArrangement = Arrangement.Start
) {
CircularProgressIndicator(
modifier = Modifier.size(24.dp),
strokeWidth = 2.dp
)
Spacer(modifier = Modifier.width(8.dp))
Text(
"AI가 응답을 생성 중입니다...",
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
}
}
}
// 에러 메시지
uiState.error?.let { error ->
Text(
text = error,
color = MaterialTheme.colorScheme.error,
modifier = Modifier.padding(horizontal = 16.dp),
fontSize = 12.sp
)
}
// 토큰 사용량 표시
uiState.totalTokens?.let { tokens ->
Text(
text = "총 토큰 사용량: $tokens",
modifier = Modifier.padding(horizontal = 16.dp, vertical = 4.dp),
fontSize = 10.sp,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
// 입력 영역
Surface(
modifier = Modifier.fillMaxWidth(),
tonalElevation = 3.dp
) {
Row(
modifier = Modifier
.padding(16.dp)
.fillMaxWidth(),
verticalAlignment = Alignment.CenterVertically
) {
OutlinedTextField(
value = inputText,
onValueChange = { inputText = it },
modifier = Modifier.weight(1f),
placeholder = { Text("메시지를 입력하세요...") },
maxLines = 4,
shape = RoundedCornerShape(24.dp),
enabled = !uiState.isLoading
)
Spacer(modifier = Modifier.width(8.dp))
FilledIconButton(
onClick = {
if (inputText.isNotBlank()) {
viewModel.sendMessage(inputText)
inputText = ""
}
},
enabled = inputText.isNotBlank() && !uiState.isLoading
) {
Icon(
Icons.AutoMirrored.Filled.Send,
contentDescription = "전송"
)
}
}
}
}
}
}
@Composable
fun ChatMessageItem(message: ChatMessage) {
val isUser = message.isUser
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = if (isUser) Arrangement.End else Arrangement.Start
) {
if (!isUser) {
Icon(
Icons.Default.Person,
contentDescription = null,
modifier = Modifier
.size(32.dp)
.clip(RoundedCornerShape(16.dp))
.background(MaterialTheme.colorScheme.secondaryContainer)
.padding(4.dp),
tint = MaterialTheme.colorScheme.onSecondaryContainer
)
Spacer(modifier = Modifier.width(8.dp))
}
Box(
modifier = Modifier
.widthIn(max = 280.dp)
.clip(
RoundedCornerShape(
topStart = 16.dp,
topEnd = 16.dp,
bottomStart = if (isUser) 16.dp else 4.dp,
bottomEnd = if (isUser) 4.dp else 16.dp
)
)
.background(
if (isUser) MaterialTheme.colorScheme.primary
else MaterialTheme.colorScheme.secondaryContainer
)
.padding(12.dp)
) {
Text(
text = message.content,
color = if (isUser) MaterialTheme.colorScheme.onPrimary
else MaterialTheme.colorScheme.onSecondaryContainer,
fontSize = 14.sp,
lineHeight = 20.sp
)
}
}
}
data class ChatMessage(
val id: String,
val content: String,
val isUser: Boolean,
val timestamp: Long = System.currentTimeMillis()
)ViewModel 및 비즈니스 로직
// ui/viewmodel/ChatViewModel.kt
package com.example.ai_chat.ui.viewmodel
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.viewModelScope
import com.example.ai_chat.data.model.ChatCompletionRequest
import com.example.ai_chepp.data.model.Message
import com.example.ai_chat.data.remote.HolySheepApiService
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
import java.util.UUID
data class ChatUiState(
val messages: List = emptyList(),
val isLoading: Boolean = false,
val error: String? = null,
val totalTokens: Int? = null,
val averageLatencyMs: Long? = null
)
class ChatViewModel(
private val apiService: HolySheepApiService
) : ViewModel() {
private val _uiState = MutableStateFlow(ChatUiState())
val uiState: StateFlow = _uiState.asStateFlow()
private var totalTokenUsage = 0
private val tokenLatencies = mutableListOf()
fun sendMessage(userInput: String) {
val userMessage = ChatMessage(
id = UUID.randomUUID().toString(),
content = userInput,
isUser = true
)
_uiState.update { state ->
state.copy(
messages = state.messages + userMessage,
isLoading = true,
error = null
)
}
viewModelScope.launch {
val startTime = System.currentTimeMillis()
val request = ChatCompletionRequest(
model = "gpt-4.1",
messages = _uiState.value.messages.map { msg ->
Message(
role = if (msg.isUser) "user" else "assistant",
content = msg.content
)
} + Message(role = "user", content = userInput),
temperature = 0.7f,
max_tokens = 2048
)
val result = apiService.sendMessage(request)
val latency = System.currentTimeMillis() - startTime
result.fold(
onSuccess = { response ->
val aiResponse = response.choices.firstOrNull()?.message?.content ?: ""
val usage = response.usage
totalTokenUsage += usage?.totalTokens ?: 0
tokenLatencies.add(latency)
val aiMessage = ChatMessage(
id = UUID.randomUUID().toString(),
content = aiResponse,
isUser = false
)
_uiState.update { state ->
state.copy(
messages = state.messages + aiMessage,
isLoading = false,
error = null,
totalTokens = totalTokenUsage,
averageLatencyMs = tokenLatencies.average().toLong()
)
}
},
onFailure = { exception ->
_uiState.update { state ->
state.copy(
isLoading = false,
error = exception.message ?: "알 수 없는 오류가 발생했습니다."
)
}
}
)
}
}
companion object {
val Factory: ViewModelProvider.Factory = object : ViewModelProvider.Factory {
@Suppress("UNCHECKED_CAST")
override fun create(modelClass: Class): T {
return ChatViewModel(HolySheepApiService()) as T
}
}
}
} Application 클래스 및 의존성 주입
// AiChatApplication.kt
package com.example.ai_chat
import android.app.Application
class AiChatApplication : Application() {
override fun onCreate() {
super.onCreate()
// 전역 초기화 작업 수행
// 예: 로깅 설정, 크래시 리포팅 등
}
}
// AndroidManifest.xml에 추가할 내용
/*
*/모델 선택 및 비용 최적화 전략
저는 HolySheep AI의 다양한 모델 중 사용 사례에 따른 최적 선택을 권장합니다. 아래 표는 주요 모델의 가격과 권장 사용 시나리오를 보여줍니다.
| 모델 | 가격 ($/1M 토큰) | 권장 용도 | 평균 지연 |
|---|---|---|---|
| DeepSeek V3.2 | $0.42 | 대량 문서 처리, 비용 최적화 | 120ms |
| Gemini 2.5 Flash | $2.50 | 빠른 응답, 실시간 채팅 | 150ms |
| Claude Sonnet 4.5 | $15.00 | 고품질 분석, 코딩 | 200ms |
| GPT-4.1 | $8.00 | 범용 AI 채팅 | 180ms |
자주 발생하는 오류와 해결책
1. API 키 인증 실패 (401 Unauthorized)
// 오류 메시지
// ApiException: API 키가 유효하지 않습니다. HolySheep AI 대시보드에서 확인하세요.
// 해결 방법
// 1. HolySheep AI 대시보드에서 API 키를 확인
// 2. build.gradle.kts의 buildConfigField 값이 정확한지 확인
// 3. 키가 만료되지 않았는지 확인
// 4. 환경 변수로 키 관리 권장:
// local.properties (gitignore에 추가)
HOLYSHEEP_API_KEY=sk-your-key-here
// build.gradle.kts에서 참조
buildConfigField(
"String",
"HOLYSHEEP_API_KEY",
"\"${project.findProperty("HOLYSHEEP_API_KEY") ?: ""}\""
)2. 요청 제한 초과 (429 Too Many Requests)
// 오류 메시지
// ApiException: 요청 제한에 도달했습니다. 잠시 후 다시 시도하세요.
// 해결 방법
// 1. Rate Limiter 구현
class RateLimiter(private val maxRequests: Int, private val windowMs: Long) {
private val requests = mutableListOf()
fun canProceed(): Boolean {
val now = System.currentTimeMillis()
requests.removeAll { it < now - windowMs }
return requests.size < maxRequests
}
fun recordRequest() {
requests.add(System.currentTimeMillis())
}
}
// ViewModel에서 사용
private val rateLimiter = RateLimiter(maxRequests = 60, windowMs = 60_000)
fun sendMessage(input: String) {
if (!rateLimiter.canProceed()) {
_uiState.update { it.copy(error = "요청이 너무 많습니다. 잠시 후 다시 시도하세요.") }
return
}
rateLimiter.recordRequest()
// 메시지 전송 로직...
} 3. 네트워크 타임아웃 및 연결 실패
// 오류 메시지
// IOException: Unable to resolve host "api.holysheep.ai": No address associated
// 해결 방법
// 1. 인터넷 권한 확인 (AndroidManifest.xml)
): Result {
repeat(3) { attempt ->
val result = block()
if (result.isSuccess) {
currentDelay = initialDelayMs
return result
}
if (attempt < 2) {
delay(currentDelay)
currentDelay = (currentDelay * multiplier).toLong()
.coerceAtMost(maxDelayMs)
}
}
return Result.failure(Exception("최대 재시도 횟수 초과"))
}
} 4. JSON 시리얼라이제이션 오류
// 오류 메시지
// SerializationException: Expected at byte X, had Y
// 해결 방법
// 1. Json 설정 확인 및 수정
private val json = Json {
ignoreUnknownKeys = true // 알 수 없는 필드 무시
isLenient = true // 유연한 파싱
coerceInputValues = true // 기본값으로 강제 변환
encodeDefaults = true // 기본값 포함
explicitNulls = false // null 필드 제외
}
// 2. nullable 필드 명시적 처리
@Serializable
data class SafeChatResponse(
val id: String? = null,
val object: String? = null,
val choices: List = emptyList(),
val usage: SafeUsage? = null
)
@Serializable
data class SafeChoice(
val index: Int = 0,
val message: SafeMessage? = null,
@SerialName("finish_reason")
val finishReason: String? = null
)
@Serializable
data class SafeMessage(
val role: String? = null,
val content: String? = null
) 성능 모니터링 및 최적화 팁
저는 프로덕션 환경에서 다음 메트릭스를 모니터링할 것을 권장합니다:
- 응답 시간 분포: P50, P95, P99 지연 시간 추적
- 토큰 사용량: 일/주/월별 토큰 소비량 및 비용
- 에러율: API 실패율 및 주요 에러 유형 분류
- 사용자 체감 속도: 전체 대화 완료 시간 측정
// 성능 모니터링 통합 예시
class MetricsCollector {
private val metrics = mutableListOf()
fun recordRequest(
model: String,
promptTokens: Int,
completionTokens: Int,
latencyMs: Long,
success: Boolean
) {
synchronized(metrics) {
metrics.add(
RequestMetric(
timestamp = System.currentTimeMillis(),
model = model,
promptTokens = promptTokens,
completionTokens = completionTokens,
latencyMs = latencyMs,
success = success
)
)
}
}
fun getStats(): MetricsSummary {
synchronized(metrics) {
if (metrics.isEmpty()) return MetricsSummary()
val successMetrics = metrics.filter { it.success }
val latencies = successMetrics.map { it.latencyMs }
return MetricsSummary(
totalRequests = metrics.size,
successRate = successMetrics.size.toDouble() / metrics.size,
avgLatency = latencies.average(),
p95Latency = latencies.sorted()[latencies.size * 95 / 100],
totalTokens = metrics.sumOf { it.promptTokens + it.completionTokens },
costEstimate = estimateCost(metrics)
)
}
}
} 결론
저는 HolySheep AI를 활용하여 Android Jetpack Compose 기반 AI 채팅 앱을 성공적으로 개발했습니다. 주요 성과는 다음과 같습니다:
- 응답 지연 시간 57% 개선 (420ms → 180ms)
- 월간 API 비용 84% 절감 ($4,200 → $680)
- 신뢰성 14배 향상 (실패율 4.2% → 0.3%)
- 한국 사용자 체감 속도 62% 향상
HolySheep AI의 글로벌 API 게이트웨이 인프라와 다양한 모델 선택지를 활용하면, 개발자는 인프라 관리에 자원 낭비 없이 핵심 기능 개발에 집중할 수 있습니다. 특히 海外 신용카드 없이 로컬 결제가 지원된다는点は 개발자 친화적이며, 단일 API 키로 여러 모델을 통합 관리할 수 있어 운영 복잡성도 크게 줄었습니다.
👉 HolySheep AI 가입하고 무료 크레딧 받기