Oleh Farruh Kushnazarov
Tutorial praktis yang membandingkan Token API, PTU, Model Unit, dan Bare Metal GPU untuk inference LLM di lingkungan produksi. Angka nyata. Deployment nyata.
Suatu Selasa sore, Sarah, engineering lead di sebuah startup fintech yang berkembang cepat, membanting tutup laptopnya.
Selama dua minggu, timnya menghabiskan waktu mengintegrasikan DeepSeek V4-Flash ke chatbot customer support mereka. Model bekerja dengan sangat baik saat testing. Respons cepat, kemampuan reasoning tajam, dan tingkat halusinasi lebih rendah dibanding apa pun yang pernah mereka coba. Demo berjalan sempurna.
Kemudian mereka melihat tagihan cloud.
Pada volume traffic mereka saat ini — sekitar 8 juta token per hari — biaya Token API menguras anggaran AI mereka. Dan situasi akan semakin parah seiring layanan diperluas ke lebih banyak pelanggan.
Sarah memiliki empat opsi. Tapi inilah masalahnya: setiap blog post yang ia baca dan setiap deck vendor yang ia hadiri mengklaim opsi mereka adalah "yang terbaik." Token API disebut "tercepat untuk dimulai." PTU diklaim "paling dapat diprediksi." Model Unit dipuji "paling hemat biaya pada skala besar." Sementara itu, lead engineer-nya berbisik tentang menyewa GPU sendiri dan menjalankan semuanya secara mandiri.
Masalahnya? Tidak ada yang benar-benar membenchmark keempat opsi ini secara berdampingan — pada model yang sama, dengan workload yang sama, di cloud yang sama.
Jadi kami melakukannya.
Artikel ini adalah panduan lengkap atas temuan kami — dilengkapi instruksi deployment langkah demi langkah, angka benchmark nyata, serta panduan untuk memilih yang sesuai dengan workload Anda.
Sebelum menyentuh satu baris kode pun, Anda perlu memahami empat model deployment yang tersedia di Alibaba Cloud. Keempatnya bukan sekadar tier harga yang berbeda — masing-masing merupakan model teknis dan ekonomis yang sangat berbeda.
Catatan: Semua harga yang ditampilkan adalah estimasi dan diambil dari sumber publik. Harga aktual dapat bervariasi tergantung wilayah, term kontrak, dan penawaran yang tersedia.
Ini cara paling umum untuk memulai. Panggil sebuah endpoint API, kirim prompt Anda, terima completion, dan bayar untuk setiap token yang mengalir melalui sistem.
PTU adalah solusi Alibaba Cloud untuk masalah prediktabilitas biaya. Alih-alih bayar per token, Anda membeli throughput terjamin di muka, diukur dalam token per menit (TPM).
Di sinilah mulai menarik. Model Unit memberi Anda cluster GPU dedicated khusus untuk workload Anda, sepenuhnya dikelola oleh Alibaba Cloud.
Opsi paling ekstrem. Anda menyewa instans GPU mentah (H20, H200, atau B300 yang segera hadir), lalu men-deploy stack inference Anda sendiri.
Mari mulai dengan opsi termudah. Jika Anda belum pernah menggunakan layanan AI Alibaba Cloud, di sinilah titik awalnya.
Login ke konsol Alibaba Cloud dan buka Model Studio. Ini adalah marketplace model sekaligus API gateway terpadu untuk semua layanan AI Alibaba Cloud.
Di katalog model, cari DeepSeek V4-Flash. Model ini akan muncul bersama model populer lain seperti Qwen3, GLM, dan Wan.
Buka halaman model DeepSeek V4-Flash. Anda akan melihat tombol Get API Key. Klik, buat API key baru, dan salin ke clipboard.
Simpan key ini dengan aman — ini adalah token autentikasi Anda untuk semua panggilan API.
Berikut script Python singkat untuk memastikan semuanya sudah terhubung:
import requests
API_KEY = "your-api-key-here"
ENDPOINT = "https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions"
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}
payload = {
"model": "deepseek-v4-flash",
"messages": [
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Explain quantum computing in one paragraph."}
],
"max_tokens": 256
}
response = requests.post(ENDPOINT, headers=headers, json=payload)
print(response.json()["choices"][0]["message"]["content"])
Jalankan script ini. Jika Anda mendapat paragraf yang koheren tentang quantum computing — selamat, Anda sudah berhasil memanggil DeepSeek V4-Flash melalui Token API.
Harga Token API mengikuti model per-token yang sederhana. Anda membayar terpisah untuk input token dan output token, di mana output token biasanya ~4x lebih mahal dibanding input token.
Untuk interaksi chat standar dengan prompt input 2K dan respons output 1K, biaya per request hanya pecahan sen. Pada volume rendah (misalnya 10.000 request/hari), biaya bulanan masih terkendali. Tapi biaya naik secara linear — dan di situlah masalahnya.
Untuk prototyping, ini tidak jadi masalah. Tapi bagaimana kalau 100.000 request per hari? Atau 1 juta?
Berikut pola scaling-nya:
| Request Harian | Rata-rata Token/Request | Biaya Bulanan Relatif |
|---|---|---|
| 10.000 | 3K | 1x (baseline) |
| 50.000 | 3K | ~5x |
| 100.000 | 3K | ~10x |
| 500.000 | 3K | ~50x |
Angkanya cepat membengkak. Persis inilah yang dialami Sarah di startup fintech-nya.
Misalkan traffic Anda tidak acak. Anda punya produk SaaS dengan 10.000 pengguna aktif harian, dan penggunaan memuncak secara konsisten antara pukul 9 pagi hingga 6 sore. Anda tahu butuh sekitar 500.000 token per menit saat jam sibuk.
PTU dirancang untuk skenario ini.
Alih-alih bayar per token, Anda membeli tier PTU yang menjamin throughput tertentu. Alibaba Cloud me-reserve kapasitas GPU untuk workload Anda. Saat jam sibuk, request Anda bypass pool bersama dan langsung masuk ke reserved capacity Anda.
Pricing model-nya terdiri dari dua komponen:
Jika melebihi reserved capacity, request yang overflow akan dikenakan harga Token API.
PTU mulai layak secara finansial ketika volume token harian Anda cukup tinggi sehingga total biaya reservasi + tarif pemakaian yang lebih rendah menjadi lebih hemat dibanding murni menggunakan Token API. Break-even point tergantung tier dan tarif yang Anda negosiasikan, tapi secara umum:
Bagi tim Sarah, PTU adalah peningkatan dari Token API. Tapi tetap ada batasnya. Begitu mereka melampaui tier reserved, biaya melonjak lagi. Dan mereka sedang merencanakan pertumbuhan user base 10x lipat di kuartal berikutnya.
Di sinilah bagian utamanya. Tim Sarah butuh sesuatu yang bisa scaling seiring pertumbuhan mereka tanpa menguras biaya. Mereka butuh dedicated resource, performa terjamin, dan pricing model yang justru makin murah semakin banyak dipakai.
Mereka butuh Model Unit.
Inilah insight utama yang membuat Model Unit berbeda: biaya tetap.
Anda membayar biaya bulanan flat per Model Unit. Mau memproses 1 juta token atau 1 miliar token — biayanya tetap sama.
Untuk DeepSeek V4-Flash, konfigurasi tipikal menggunakan 4x unit MU1 pada GPU H20-141G. Berdasarkan estimasi kasar dari sumber publik:
Sekarang bandingkan dengan Token API pada volume yang sama. Pada ~500 juta token per hari (kira-kira kapasitas 4x MU1 saat peak), Token API akan menelan biaya sekitar:
Kesimpulannya: pada throughput tinggi yang sustained, Model Unit bisa menghemat sekitar 40–50% dibanding Token API — dan Anda mendapat resource dedicated dengan SLA terjamin.
Catatan: Angka ini adalah estimasi kasar untuk tujuan ilustrasi. Harga aktual tergantung region, term komitmen, dan volume. Selalu cek harga resmi sebelum membuat keputusan pembelian.
Tapi ada angka yang lebih menarik: biaya efektif per juta token.
Pada 100% utilisasi dari 4x MU1 (Peak TPM ~550.000):
Tapi realistisnya, tidak ada workload yang berjalan 100% utilisasi 24/7. Kebanyakan workload produksi aktif saat jam kerja — sekitar 8-12 jam per hari, dengan load yang bervariasi.
Chart di atas menunjukkan biaya efektif per juta token pada berbagai tingkat utilisasi harian. Pada 4 jam penggunaan aktif per hari, biaya efektif Anda masih kompetitif dengan Token API. Pada 12+ jam per hari, Model Unit jauh lebih murah.
Dan berikut perbandingan biaya bulanannya:
Break-even point terhadap Token API ada di sekitar 2,6 miliar token per hari. Di bawah itu, Token API lebih murah. Di atasnya, Model Unit jelas lebih hemat.
Model Unit bukan hanya soal harga. Ini soal apa yang bisa Anda lakukan dengan dedicated infrastructure:
Untuk aplikasi fintech Sarah, poin terakhir saja sudah jadi alasan kuat untuk beralih. Data finansial tidak boleh lewat shared pool.
Sebelum men-deploy apa pun, mari bahas pertanyaan yang pasti muncul: kenapa tidak sewa GPU saja dan jalankan semuanya sendiri?
Pertanyaan yang valid. Dan bagi sebagian tim, memang itu jawaban yang tepat.
Anda menyewa instans GPU H20 atau H200. Install vLLM atau SGLang. Download model weights DeepSeek V4-Flash. Konfigurasi tensor parallelism, pipeline parallelism, quantization, dan KV cache settings. Setup load balancing, monitoring, autoscaling, dan failover.
Lalu Anda yang harus maintain semuanya.
Sewa GPU bukan biaya sebenarnya. Biaya sebenarnya adalah tim:
Meskipun sewa GPU terlihat lebih murah dibanding Model Unit, fully-loaded cost dari tim (sering kali 2-3x dari sewa GPU itu sendiri) hampir selalu menjadikan Model Unit pilihan yang lebih ekonomis untuk production inference.
Di mana bare metal unggul:
Bagi tim Sarah, bare metal bukan opsi. Mereka perlu kirim fitur, bukan mengelola GPU cluster.
Sekarang mari kita mulai praktiknya. Berikut panduan deployment step-by-step.
PAI-EAS (Elastic Algorithm Service) adalah managed model serving platform dari Alibaba Cloud. Anggap ini sebagai engine room tempat resource Model Unit di-provision dan model Anda di-serve.
Saat Anda membeli Model Unit, yang sebenarnya Anda lakukan adalah me-reserve dedicated PAI-EAS capacity dengan SLA guarantee. Model Unit adalah commercial wrapper-nya. PAI-EAS adalah teknologi di baliknya.
Sebelum men-deploy, tentukan konfigurasi Anda:
Untuk tutorial ini, kita akan men-deploy dengan 4x unit MU1 pada GPU H20-141G di region Singapore.
Buka PAI console dan pilih EAS dari menu kiri.
Klik Create Service. Anda akan melihat wizard deployment.
Service Name: deepseek-v4-flash-prod
Model Source: Pilih "Custom Model" dan tentukan model artifact DeepSeek V4-Flash. Jika model tersedia di Alibaba Cloud model registry, Anda bisa pilih langsung. Jika tidak, masukkan OSS path ke model weights Anda.
Konfigurasi Resource:
Konfigurasi Framework:
Atur VPC dan vSwitch Anda. Untuk API yang internet-facing, aktifkan public endpoint. Untuk internal service, gunakan private endpoint di dalam VPC Anda.
Aktifkan API key authentication. Buat API key khusus untuk service tersebut.
Klik Deploy. Proses provisioning memakan waktu 5-10 menit selagi PAI-EAS mengalokasikan dedicated GPU resource Anda dan memuat model weights ke memory.
Status service akan berubah dari "Creating" → "Deploying" → "Running."
Setelah service running, catat endpoint URL-nya. URL-nya akan terlihat seperti ini:
https://deepseek-v4-flash-prod.123456.ap-southeast-1.pai-eas.aliyuncs.com
Uji dengan request curl:
curl -X POST https://deepseek-v4-flash-prod.123456.ap-southeast-1.pai-eas.aliyuncs.com/v1/chat/completions \
-H "Authorization: Bearer YOUR_SERVICE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "deepseek-v4-flash",
"messages": [
{"role": "user", "content": "What are the key benefits of dedicated GPU inference?"}
],
"max_tokens": 512
}'Jika Anda mendapat respons yang koheren, deployment Model Unit Anda sudah live dan serving traffic.
Anda juga bisa test langsung dari PAI-EAS console. Setiap service yang di-deploy menyertakan built-in Playground tempat Anda bisa mengirim prompt, mengatur parameter (temperature, top-p, max tokens), dan melihat streaming response secara real time — tanpa menulis kode.
Ini berguna untuk quick sanity check, debugging prompt behavior, atau demo deployment ke stakeholder sebelum diintegrasikan ke aplikasi Anda.
Sekarang bagian yang seru. Kita akan benchmark keempat opsi deployment dengan workload yang sama dan bandingkan hasilnya.
Kami menggunakan benchmark script standar yang mengukur:
Test workload:
Berikut benchmark script yang kami gunakan. Sesuaikan untuk test Anda sendiri:
import asyncio
import time
import statistics
from dataclasses import dataclass
from typing import List
import aiohttp
import numpy as np
@dataclass
class BenchmarkResult:
concurrency: int
total_requests: int
ttft_ms: List[float]
tpot_ms: List[float]
tps: List[float]
total_tokens: int
duration_sec: float
@property
def avg_ttft(self) -> float:
return statistics.mean(self.ttft_ms)
@property
def p99_ttft(self) -> float:
return np.percentile(self.ttft_ms, 99)
@property
def avg_tps(self) -> float:
return statistics.mean(self.tps)
@property
def avg_tpot(self) -> float:
return statistics.mean(self.tpot_ms)
@property
def throughput_tpm(self) -> float:
return (self.total_tokens / self.duration_sec) * 60
async def send_request(session, endpoint, api_key, prompt, max_tokens):
headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
payload = {
"model": "deepseek-v4-flash",
"messages": [{"role": "user", "content": prompt}],
"max_tokens": max_tokens,
"stream": True
}
start_time = time.time()
first_token_time = None
token_count = 0
last_token_time = start_time
async with session.post(endpoint, headers=headers, json=payload) as response:
async for line in response.content:
line = line.decode('utf-8').strip()
if line.startswith('data: '):
chunk = line[6:]
if chunk == '[DONE]':
break
# Parse SSE chunk and count tokens
token_count += 1
if first_token_time is None:
first_token_time = time.time()
last_token_time = time.time()
end_time = time.time()
ttft = (first_token_time - start_time) * 1000 if first_token_time else 0
generation_time = (last_token_time - first_token_time) if first_token_time else 0
tps = token_count / generation_time if generation_time > 0 else 0
tpot = generation_time / token_count * 1000 if token_count > 0 else 0
return ttft, tpot, tps, token_count
async def run_benchmark(endpoint, api_key, concurrency, duration_sec=300):
# Long context prompt (~2048 tokens)
prompt = "Explain the history of artificial intelligence..." * 50
max_tokens = 1024
results = []
start_time = time.time()
request_count = 0
async with aiohttp.ClientSession() as session:
while time.time() - start_time < duration_sec:
tasks = [
send_request(session, endpoint, api_key, prompt, max_tokens)
for _ in range(concurrency)
]
batch_results = await asyncio.gather(*tasks, return_exceptions=True)
for r in batch_results:
if isinstance(r, Exception):
continue
ttft, tpot, tps, tokens = r
results.append((ttft, tpot, tps, tokens))
request_count += 1
total_tokens = sum(r[3] for r in results)
return BenchmarkResult(
concurrency=concurrency,
total_requests=request_count,
ttft_ms=[r[0] for r in results],
tpot_ms=[r[1] for r in results],
tps=[r[2] for r in results],
total_tokens=total_tokens,
duration_sec=duration_sec
)
# Run benchmarks at different concurrency levels
async def main():
endpoint = "https://your-endpoint.aliyuncs.com/v1/chat/completions"
api_key = "your-api-key"
for concurrency in [1, 4, 8, 16, 32, 64]:
print(f"\n=== Benchmarking at concurrency={concurrency} ===")
result = await run_benchmark(endpoint, api_key, concurrency)
print(f"Total requests: {result.total_requests}")
print(f"Throughput: {result.throughput_tpm:.0f} TPM")
print(f"Avg TTFT: {result.avg_ttft:.1f}ms")
print(f"P99 TTFT: {result.p99_ttft:.1f}ms")
print(f"Avg TPS: {result.avg_tps:.1f} tok/s")
print(f"Avg TPOT: {result.avg_tpot:.1f}ms")
if __name__ == "__main__":
asyncio.run(main())
Catatan: Script ini menggunakan streaming mode agar TTFT dan per-token latency bisa diukur secara akurat. Untuk non-streaming endpoint, sesuaikan measurement logic-nya.
Kami menjalankan benchmark pada keempat opsi deployment. Berikut hasilnya.
| Concurrency | Rata-rata TTFT | P99 TTFT | Rata-rata TPS | Throughput (TPM) |
|---|---|---|---|---|
| 1 | 245 ms | 890 ms | 42,3 | 2.540 |
| 4 | 312 ms | 1.240 ms | 38,7 | 9.280 |
| 8 | 485 ms | 2.100 ms | 31,2 | 14.960 |
| 16 | 920 ms | 4.500 ms | 18,5 | 17.760 |
| 32 | 1.850 ms | 8.200 ms | 9,8 | 18.816 |
Temuan: Pada concurrency rendah, Token API cukup cepat. Tapi seiring concurrency naik, latensi memburuk signifikan. Shared pool tidak mampu menahan throughput tinggi tanpa queuing. Throughput mentok di sekitar 18K TPM.
| Concurrency | Rata-rata TTFT | P99 TTFT | Rata-rata TPS | Throughput (TPM) |
|---|---|---|---|---|
| 1 | 180 ms | 420 ms | 48,5 | 2.910 |
| 4 | 195 ms | 380 ms | 46,2 | 11.090 |
| 8 | 210 ms | 450 ms | 44,8 | 21.500 |
| 16 | 245 ms | 520 ms | 41,3 | 39.600 |
| 32 | 310 ms | 680 ms | 36,7 | 70.300 |
Temuan: PTU memberikan konsistensi latensi yang jauh lebih baik. Guaranteed capacity berarti tidak ada queuing yang tak terduga. Throughput meningkat secara linear sesuai batas reserved tier. P99 TTFT tetap di bawah 700ms bahkan pada 32 concurrent request.
| Concurrency | Rata-rata TTFT | P99 TTFT | Rata-rata TPS | Throughput (TPM) |
|---|---|---|---|---|
| 1 | 95 ms | 180 ms | 95,2 | 5.710 |
| 4 | 102 ms | 195 ms | 94,8 | 22.750 |
| 8 | 118 ms | 225 ms | 93,5 | 44.880 |
| 16 | 145 ms | 280 ms | 91,2 | 87.550 |
| 32 | 195 ms | 380 ms | 87,6 | 168.200 |
| 64 | 310 ms | 620 ms | 79,3 | 304.100 |
Temuan: Model Unit mendominasi di setiap metrik. TTFT 3x lebih cepat dari Token API pada high concurrency. TPS tetap stabil bahkan di bawah heavy load. Peak throughput 304K TPM — 16x lipat dari Token API. Dan ingat, semua ini dengan guaranteed SLA, bukan best-effort.
| Concurrency | Rata-rata TTFT | P99 TTFT | Rata-rata TPS | Throughput (TPM) |
|---|---|---|---|---|
| 1 | 85 ms | 160 ms | 105,0 | 6.300 |
| 4 | 92 ms | 175 ms | 102,5 | 24.600 |
| 8 | 105 ms | 200 ms | 98,3 | 47.200 |
| 16 | 130 ms | 250 ms | 92,1 | 88.300 |
| 32 | 180 ms | 340 ms | 82,5 | 158.400 |
Temuan: Pada low concurrency, bare metal sedikit lebih unggul dari Model Unit karena direct GPU access dan custom tuning. Tapi selisihnya marginal (10-15%), sementara operational overhead-nya jauh lebih besar.
| Deployment | Biaya Bulanan* | Peak TPM | Avg Latency (P50) | Biaya Relatif per 1 Juta Token |
|---|---|---|---|---|
| Token API | Variabel (naik linear) | ~19K | 1.850ms | 1x (baseline) |
| PTU | ~1,5x Model Unit | ~70K | 310ms | ~2x Token API |
| Model Unit (4x MU1) | Fixed (mid-range) | ~304K | 195ms | ~0,3x Token API |
| Bare Metal (8x H200) | Mirip Model Unit | ~158K | 180ms | ~0,3x Token API |
*Pada sustained load 500 juta token/hari, tidak termasuk biaya tim untuk bare metal. Semua biaya adalah estimasi dari sumber publik.
Key insight: Model Unit menghasilkan throughput 16x dari Token API pada sepertiga biaya per-token, dengan latensi yang jauh lebih baik. Bukan sekadar lebih murah — lebih unggul di setiap metrik pada skala produksi.
Setelah menguji keempat opsi dengan benchmark yang sama, berikut panduan yang andai saja kami punya dari awal.
Mari kembali ke startup fintech Sarah.
Setelah melihat hasil benchmark, keputusannya jelas.
Token API memang bagus untuk prototype, tapi akan menelan biaya sekitar 2x lebih mahal per bulan dari Model Unit pada skala proyeksi mereka. PTU bisa jadi opsi tengah di sekitar 60-70% dari biaya Token API, tapi mereka akan melampaui reserved tier dalam satu kuartal. Bare metal bukan opsi — tim mereka hanya 12 engineer, dan tidak ada yang mau on-call GPU cluster di jam 3 pagi.
Mereka memilih Model Unit. Empat unit MU1, di-deploy di PAI-EAS, menjalankan DeepSeek V4-Flash dengan custom fine-tuned checkpoint untuk domain mereka.
Hasil setelah satu bulan di production:
Pelajarannya? Jangan hanya lihat harga yang tertera. Lihat fully-loaded cost — termasuk team overhead, opportunity cost, dan risiko performance degradation di bawah beban. Kalau semua faktor dihitung, Model Unit bukan sekadar opsi termurah pada skala besar — tapi satu-satunya opsi yang memberikan performa, prediktabilitas, dan ketenangan secara bersamaan.
Siap men-deploy instans DeepSeek V4-Flash Anda sendiri? Berikut resource yang Anda perlukan:
Benchmark ini dilakukan dalam environment terkontrol dengan workload sintetis. Hasil aktual Anda akan bervariasi tergantung pada:
Angka harga adalah estimasi berdasarkan sumber publik pada saat penulisan. Diskon volume, perbedaan harga antar-region, dan harga promosi dapat berubah sewaktu-waktu. Pastikan untuk mengonfirmasi biaya dengan account manager Alibaba Cloud Anda sebelum mengambil keputusan.
Punya pertanyaan tentang deployment DeepSeek V4-Flash di Alibaba Cloud? Tim AI Infra SA mengadakan sesi evaluasi setiap minggu. Hubungi melalui MU Request Form yang ditautkan di atas.
Artikel ini awalnya ditulis dalam bahasa Inggris. Lihat artikel aslinya di sini.
139 posts | 4 followers
FollowRegional Content Hub - July 15, 2024
Regional Content Hub - July 14, 2025
Regional Content Hub - December 15, 2025
Alibaba Cloud Indonesia - January 22, 2026
Alibaba Cloud_Academy - March 14, 2023
Alibaba Cloud Community - December 14, 2023
139 posts | 4 followers
Follow
Alibaba Cloud Model Studio
A one-stop generative AI platform to build intelligent applications that understand your business, based on Qwen model series such as Qwen-Max and other popular models
Learn More
Qwen
Full-range, open-source, multimodal, and multi-functional
Learn More
AI Acceleration Solution
Accelerate AI-driven business and AI model training and inference with Alibaba Cloud GPU technology
Learn More
Network Intelligence Service
Self-service network O&M service that features network status visualization and intelligent diagnostics capabilities
Learn MoreMore Posts by Regional Content Hub