rembg / frontend /src /lib /hf-inference.js
ilhamdev's picture
feat(inference): resolve ZeroGPU quota limits with token rotation, IP forwarding, and CPU fallback
4f85e22
Raw History Blame Contribute Delete
8.68 kB
/**
* Hugging Face Gradio ZeroGPU & CPU Fallback Client
*
* Mengelola komunikasi ke Hugging Face Space dengan proteksi kuota:
* 1. Token Pool / Multi-token Rotation (HF_TOKEN / HF_TOKENS) untuk mendistribusikan kuota.
* 2. Header IP Rotation & Forwarding (X-Forwarded-For, CF-Connecting-IP, dsb.) dengan random public IP generator.
* 3. Otomatis Fallback ke endpoint CPU (remove_bg_cpu) jika kuota ZeroGPU Space tercapai.
* 4. Sanitasi pesan error agar ramah pengguna dan tidak menampilkan raw JSON dump.
*/
const PUBLIC_IP_POOLS = [
'36.68', '36.69', '36.70', '36.71', // Telkom Indonesia
'114.120', '114.121', '114.122', '114.124', // Telkomsel
'180.240', '180.241', '180.250', // Biznet / FirstMedia
'103.10', '103.28', '103.47', // APNIC regional pool
'202.80', '202.152', '202.158', // Indonesian ISPs
'13.212', '13.250', '52.74', // AWS Singapore Edge
'104.28', '172.68', '172.69', // Cloudflare Edge
]
/**
* Menghasilkan IP publik acak dari pool IP valid non-private.
*/
export function getRandomPublicIp() {
const prefix = PUBLIC_IP_POOLS[Math.floor(Math.random() * PUBLIC_IP_POOLS.length)]
const octet3 = Math.floor(Math.random() * 254) + 1
const octet4 = Math.floor(Math.random() * 254) + 1
return `${prefix}.${octet3}.${octet4}`
}
/**
* Memeriksa apakah IP adalah IP internal/private/loopback.
*/
export function isPrivateOrLocalIp(ip) {
if (!ip || typeof ip !== 'string') return true
const trimmed = ip.trim()
return (
trimmed === '127.0.0.1' ||
trimmed === '::1' ||
trimmed === 'localhost' ||
trimmed.startsWith('10.') ||
trimmed.startsWith('192.168.') ||
trimmed.startsWith('169.254.') ||
/^172\.(1[6-9]|2[0-9]|3[0-1])\./.test(trimmed)
)
}
/**
* Menyelesaikan IP yang akan dikirim ke backend.
* Jika IP dari request adalah IP eksternal valid, gunakan itu.
* Jika request dari local dev / private IP, gunakan random public IP.
*/
export function resolveForwardedIp(request) {
if (!request || !request.headers) {
return getRandomPublicIp()
}
const rawHeader =
request.headers.get('cf-connecting-ip') ||
request.headers.get('x-forwarded-for')?.split(',')[0]?.trim() ||
request.headers.get('x-real-ip')
if (rawHeader && !isPrivateOrLocalIp(rawHeader)) {
return rawHeader
}
return getRandomPublicIp()
}
/**
* Mengambil token Hugging Face dari environment.
* Mendukung multiple tokens (HF_TOKENS=t1,t2) dengan pemilihan acak untuk meratakan kuota.
*/
export function getHfToken() {
const rawTokens = process.env.HF_TOKENS || process.env.HF_TOKEN || process.env.HUGGINGFACE_TOKEN || process.env.HUGGING_FACE_HUB_TOKEN || ''
const tokenList = rawTokens
.split(',')
.map((t) => t.trim())
.filter(Boolean)
if (tokenList.length === 0) return ''
if (tokenList.length === 1) return tokenList[0]
// Pick random token dari list untuk load-balancing kuota
return tokenList[Math.floor(Math.random() * tokenList.length)]
}
/**
* Membuat headers lengkap untuk memanggil endpoint Hugging Face Gradio.
*/
export function buildHfHeaders({ token = getHfToken(), clientIp = getRandomPublicIp() } = {}) {
const headers = {
'Content-Type': 'application/json',
Accept: 'application/json',
'X-Forwarded-For': clientIp,
'CF-Connecting-IP': clientIp,
'X-Real-IP': clientIp,
'X-Client-IP': clientIp,
'True-Client-IP': clientIp,
}
if (token) {
headers['Authorization'] = `Bearer ${token}`
}
return headers
}
/**
* Membersihkan pesan error Gradio / SSE menjadi teks ramah pengguna.
*/
export function cleanGradioErrorMessage(rawError) {
if (!rawError) return 'Terjadi kesalahan pada backend AI Hugging Face.'
let msg = typeof rawError === 'string' ? rawError : JSON.stringify(rawError)
try {
const parsed = JSON.parse(msg)
if (parsed.error) {
msg = parsed.title ? `${parsed.title}: ${parsed.error}` : parsed.error
}
} catch {
// msg tetap teks asli jika bukan format JSON
}
if (msg.includes('ZeroGPU runs limit') || msg.includes('ZeroGPU quota exceeded')) {
return 'Batas kuota gratis ZeroGPU Hugging Face sedang tercapai atau antre. Sistem telah mencoba fallback CPU; silakan coba kembali beberapa saat lagi.'
}
return msg
}
/**
* Menjalankan inferensi Gradio SSE dengan toleransi fallback ZeroGPU -> CPU.
*/
export async function executeGradioInference({
spaceUrl,
dataPayload,
clientIp,
token = getHfToken(),
timeoutMs = 90_000,
}) {
const normalizedSpaceUrl = spaceUrl.replace(/\/+$/, '')
const headers = buildHfHeaders({ token, clientIp })
// Daftar urutan endpoint: GPU terlebih dahulu, kemudian CPU jika kuota habis
const attempts = [
{ name: 'remove_bg', isGpu: true },
{ name: 'remove_bg_cpu', isGpu: false },
]
let lastError = null
for (const attempt of attempts) {
const candidateEndpoints = [
`${normalizedSpaceUrl}/gradio_api/call/${attempt.name}`,
`${normalizedSpaceUrl}/call/${attempt.name}`,
]
let callRes = null
let usedEndpoint = ''
let postErrorText = ''
for (const endpoint of candidateEndpoints) {
try {
console.log(`[HF Inference] Memanggil ${endpoint} (${attempt.isGpu ? 'ZeroGPU' : 'CPU Fallback'})...`)
const res = await fetch(endpoint, {
method: 'POST',
headers,
body: JSON.stringify({ data: dataPayload }),
})
if (res.ok) {
callRes = res
usedEndpoint = endpoint
break
} else {
postErrorText = await res.text()
console.warn(`[HF Endpoint ${res.status}] ${endpoint}:`, postErrorText.slice(0, 120))
}
} catch (err) {
console.warn(`[HF Fetch Fail] ${endpoint}:`, err.message)
}
}
if (!callRes) {
lastError = new Error(
`Gagal menghubungi backend Hugging Face (${attempt.name}): ${postErrorText.slice(0, 100) || 'Connection failed'}`
)
// Jika endpoint remove_bg_cpu belum ter-deploy di HuggingFace Space saat ini, lanjutkan
continue
}
let eventId = null
try {
const data = await callRes.json()
eventId = data.event_id
} catch {
// response bukan json
}
if (!eventId) {
lastError = new Error('Hugging Face tidak mengembalikan event_id')
continue
}
// Baca SSE Stream
const sseUrl = `${usedEndpoint}/${eventId}`
const sseController = new AbortController()
const sseTimer = setTimeout(() => sseController.abort(), timeoutMs)
let sseRes = null
try {
sseRes = await fetch(sseUrl, {
headers: {
Accept: 'text/event-stream',
...(token ? { Authorization: `Bearer ${token}` } : {}),
},
signal: sseController.signal,
})
} catch (err) {
lastError = err
continue
} finally {
clearTimeout(sseTimer)
}
if (!sseRes || !sseRes.ok) {
lastError = new Error(`Gagal membaca SSE status dari Hugging Face: ${sseRes?.status || 'unknown'}`)
continue
}
const sseText = await sseRes.text()
const lines = sseText.split('\n')
let currentEvent = ''
let resultOutput = null
let errorMsg = null
for (const line of lines) {
const trimmed = line.trim()
if (trimmed.startsWith('event: ')) {
currentEvent = trimmed.slice(7).trim()
} else if (trimmed.startsWith('data: ')) {
const raw = trimmed.slice(6).trim()
if (currentEvent === 'error') {
errorMsg = raw
break
}
if (currentEvent === 'complete') {
try {
const parsed = JSON.parse(raw)
if (Array.isArray(parsed) && parsed.length > 0) {
resultOutput = parsed[0]
}
} catch {
console.error('[SSE parse error]', raw.slice(0, 100))
}
}
}
}
// Jika terjadi error kuota ZeroGPU pada attempt GPU, coba attempt berikutnya (CPU Fallback)
if (errorMsg) {
const cleaned = cleanGradioErrorMessage(errorMsg)
if (
attempt.isGpu &&
(errorMsg.includes('ZeroGPU runs limit') || errorMsg.includes('ZeroGPU quota exceeded'))
) {
console.warn('[HF Inference] ZeroGPU limit terdeteksi, beralih otomatis ke CPU fallback...')
lastError = new Error(cleaned)
continue // Coba attempt berikutnya (remove_bg_cpu)
}
throw new Error(cleaned)
}
if (resultOutput) {
return {
result: resultOutput,
endpointUsed: attempt.name,
isGpu: attempt.isGpu,
}
}
}
throw lastError || new Error('Tidak ada respon berhasil dari backend Hugging Face.')
}