Punya project side yang udah selesai tapi bingung mau di-deploy ke mana? Atau mungkin kamu lagi cari hosting gratis yang nggak bikin dompet nangis buat side project, MVP, atau bahkan aplikasi production yang traffic-nya belum terlalu gede?

Fly.io jawabannya.

Platform ini udah jadi favorit banyak developer dalam beberapa tahun terakhir, dan di 2026 ini, free tier-nya masih cukup legit buat dipakai. Nggak kayak beberapa layanan cloud lain yang pelan-pelan ngurangin free tier-nya, Fly.io masih kasih ruang bernapas buat developer indie dan tim kecil.

Di artikel ini, gue bakal jelasin step-by-step cara deploy aplikasi ke Fly.io secara gratis — dari nol sampai aplikasi kamu live di internet. Semua dijelasin dengan bahasa yang mudah dipahami, lengkap dengan contoh kode dan tips-tips yang sering luput dari tutorial lain.

Apa Itu Fly.io dan Kenapa Pilih Ini?

Sebelum masuk ke teknis, penting buat ngerti dulu kenapa Fly.io layak dipilih.

Fly.io adalah platform-as-a-service (PaaS) yang memungkinkan kamu menjalankan aplikasi di berbagai region di seluruh dunia. Bedanya dengan VPS biasa, Fly.io handle banyak hal teknis buat kamu — mulai dari provisioning server, load balancing, sampai SSL certificates. Kamu tinggal push kode, dan aplikasi kamu jalan.

Beberapa alasan kenapa Fly.io menarik di 2026:

  • Free tier yang cukup generous — Kamu bisa dapat 3 shared-cpu VMs dengan 256MB RAM, 3GB persistent storage, dan 160GB bandwidth per bulan. Buat side project atau prototipe, ini lebih dari cukup.
  • Deploy dari Dockerfile atau buildpack — Fleksibel banget. Mau pakai Docker? Silakan. Mau pakai buildpack otomatis (support Node.js, Go, Ruby, Python, dll)? Bisa.
  • Global edge network — Aplikasi kamu bisa di-deploy di server yang dekat dengan user, bikin latency lebih rendah.
  • WireGuard VPN built-in — Mau akses internal services tanpa expose ke public? Gampang.
  • CLI yang powerful — Flyctl, CLI resmi dari Fly.io, bikin semua operasi bisa dilakukan dari terminal.

Kalau kamu pernah pakai Heroku, feel-nya mirip. Tapi Fly.io lebih modern, lebih cepat, dan free tier-nya lebih masuk akal.

Persiapan Sebelum Deploy

Oke, sebelum kita mulai nge-deploy, ada beberapa hal yang perlu disiapkan dulu. Tenang, semuanya gratis.

1. Buat Akun Fly.io

Kunjungi fly.io dan daftar akun. Kamu bisa sign up pakai GitHub atau email biasa. Di 2026 ini, Fly.io tidak lagi meminta credit card untuk mengaktifkan free tier — jadi kamu nggak perlu khawatir tiba-tiba kena charge.

2. Install Flyctl (Fly CLI)

Flyctl adalah command-line tool utama buat berinteraksi dengan Fly.io. Install tergantung OS kamu:

macOS (pakai Homebrew):

brew install flyctl

Linux / WSL:

curl -L https://fly.io/install.sh | sh

Windows (pakai PowerShell):

iwr https://fly.io/install.ps1 -useb | iex

Setelah install, login ke akun kamu:

flyctl auth login

Ini bakal buka browser, kamu tinggal authorize aja. Kalau udah, balik ke terminal. Verifikasi kalau kamu udah login:

flyctl auth whoami

Kalau muncul email kamu, berarti udah sukses.

3. Siapkan Aplikasi

Di tutorial ini, gue bakal pakai contoh aplikasi sederhana pakai Node.js + Express. Tapi prinsipnya sama untuk framework atau bahasa lain — baik itu Python (Flask/Django), Go, Ruby on Rails, atau bahkan static site.

Kalau kamu belum punya project, bikin yang simpel aja dulu:

mkdir my-fly-app && cd my-fly-app
npm init -y
npm install express

Buat file app.js:

const express = require('express');
const app = express();
const PORT = process.env.PORT || 3000;

app.get('/', (req, res) => {
  res.send(`
    <html>
      <head><title>My App on Fly.io</title></head>
      <body style="font-family: sans-serif; text-align: center; padding-top: 80px;">
        <h1>🚀 Hello from Fly.io!</h1>
        <p>Deployed at: ${new Date().toISOString()}</p>
        <p>Region: ${process.env.FLY_REGION || 'unknown'}</p>
      </body>
    </html>
  `);
});

app.get('/health', (req, res) => {
  res.json({ status: 'ok', uptime: process.uptime() });
});

app.listen(PORT, '0.0.0.0', () => {
  console.log(`Server running on port ${PORT}`);
});

Update package.json tambahkan script:

{
  "name": "my-fly-app",
  "version": "1.0.0",
  "scripts": {
    "start": "node app.js"
  },
  "dependencies": {
    "express": "^4.21.0"
  }
}

Pastikan ada script start — Fly.io bakal pakai ini buat jalanin aplikasi kamu kalau pakai Node.js buildpack.

Step-by-Step Deploy ke Fly.io

Sekarang kita masuk ke bagian utama. Ada dua cara buat deploy: pakai buildpack otomatis atau pakai Dockerfile manual. Gue bakal jelasin keduanya.

Cara 1: Deploy dengan Buildpack (Paling Gampang)

Masuk ke folder project kamu, lalu jalankan:

flyctl launch

Flyctl bakal nge-detect framework yang kamu pakai. Untuk Node.js, dia bakal otomatis detect package.json dan pakai Node.js buildpack.

Kamu bakal ditanya beberapa hal:

  • App name — Pilih nama unik, atau biarkan Fly.io generate otomatis. Nama ini jadi bagian dari URL: nama-kamu.fly.dev
  • Region — Pilih region terdekat. Kalau target user di Asia, pilih sin (Singapore) atau nrt (Tokyo).
  • PostgreSQL/Redis? — Untuk sekarang pilih No, kita keep it simple.

Flyctl bakal generate file fly.toml — ini adalah konfigurasi utama aplikasi kamu di Fly.io. Isi defaultnya kurang lebih kayak gini:

app = 'my-fly-app'
primary_region = 'sin'

[build]

[http_service]
  internal_port = 3000
  force_https = true
  auto_stop_machines = 'stop'
  auto_start_machines = true
  min_machines_running = 0

[[vm]]
  size = 'shared-cpu-1x'
  memory = '256mb'

Beberapa hal penting di fly.toml:

  • internal_port — Port yang didengerin aplikasi kamu di dalam container. Pastiin sama dengan port di kode kamu (3000 dalam contoh ini).
  • auto_stop_machines — Set ke 'stop' supaya VM berhenti kalau idle. Ini kunci buat hemat resource di free tier.
  • min_machines_running — Set ke 0 supaya nggak makan resource kalau nggak ada request masuk. Aplikasi akan “wake up” otomatis saat ada yang akses (cold start).

Kalau udah review, deploy:

flyctl deploy

Tunggu beberapa menit. Fly.io bakal build aplikasi kamu, bikin Docker image, dan deploy ke server. Setelah selesai, kamu bakal dapat URL: https://my-fly-app.fly.dev

Buka di browser, dan voila — aplikasi kamu udah live!

Cara 2: Deploy dengan Dockerfile (Lebih Kontrol)

Kalau kamu butuh kontrol lebih atas environment aplikasi, pakai Dockerfile. Buat file Dockerfile di root project:

FROM node:20-alpine

WORKDIR /app

COPY package*.json ./
RUN npm ci --only=production

COPY . .

EXPOSE 3000

CMD ["node", "app.js"]

Dan buat .dockerignore supaya nggak copy node_modules ke dalam image:

nn..opgedmine-tv_dmeobduugl.elsog

Lalu jalankan flyctl launch seperti biasa. Fly.io bakal detect Dockerfile dan pakai itu sebagai build method.

Deploy:

flyctl deploy

Sama aja hasilnya, tapi kamu sekarang punya full kontrol atas base image, dependencies, dan proses build.

Verifikasi Deployment

Setelah deploy sukses, cek status:

flyctl status

Ini bakal nampilin info tentang VM yang jalan, region, IP address, dan status health. Kamu juga bisa cek logs:

flyctl logs

Dan kalau mau SSH ke dalam VM buat debugging:

flyctl ssh console

Mengelola Aplikasi dan Optimasi Free Tier

Deploy cuma langkah pertama. Biar aplikasi kamu tetap jalan lancar di free tier tanpa kejutan, ada beberapa hal yang perlu diperhatikan.

Auto-Stop dan Auto-Start

Fitur ini adalah best friend kamu di free tier. Dengan auto_stop_machines = 'stop' dan min_machines_running = 0, VM kamu akan berhenti otomatis kalau nggak ada request selama beberapa menit.

Ini artinya:

  • Nggak ada request masuk → VM mati → Nggak makan resource.
  • Ada request masuk → VM nyala dalam beberapa detik → Request dilayani.
  • Ada sedikit cold start (biasanya 1-3 detik) saat VM bangun dari tidur.

Untuk side project, cold start ini biasanya acceptable. Kalau butuh always-on, naikkan min_machines_running ke 1 — tapi ini bakal makan kuota free tier lebih banyak.

Persistent Storage

Fly.io kasih 3GB persistent storage gratis. Kalau aplikasi kamu butuh nyimpan file atau database SQLite, kamu bisa bikin volume:

flyctl volumes create my_data --size 1 --region sin

Lalu mount di fly.toml:

[[mounts]]
  source = "my_data"
  destination = "/data"

Ini berguna banget buat aplikasi yang butuh penyimpanan lokal — misalnya pakai SQLite, menyimpan upload user, atau caching.

Environment Variables

Jangan hardcode secrets di kode. Set environment variables lewat Fly.io:

flyctl secrets set DATABASE_URL="sqlite:///data/app.db"
flyctl secrets set SECRET_KEY="rahasia-banget"

Secrets ini di-encrypt dan hanya tersedia di dalam VM. Aman.

Custom Domain

Mau pakai domain sendiri alih-alih *.fly.dev? Gampang:

flyctl certs add yourdomain.com

Lalu tambahkan DNS records yang diminta Fly.io di provider domain kamu (CNAME atau A record). SSL otomatis di-handle oleh Fly.io.

Monitoring

Fly.io punya built-in dashboard di fly.io/dashboard. Di situ kamu bisa monitor:

  • CPU dan memory usage
  • Request count dan response time
  • Logs real-time
  • Deployment history

Untuk monitoring lebih advanced, kamu bisa integrate dengan tools eksternal seperti Grafana, Datadog, atau yang gue rekomendasikan — Upptime (open-source, bisa di-deploy juga di Fly.io!).

Deploy Aplikasi Lain: Contoh Python (Flask)

Biar kamu nggak terbatas di Node.js aja, ini contoh deploy aplikasi Python pakai Flask.

app.py:

from flask import Flask, jsonify
import os
from datetime import datetime

app = Flask(__name__)

@app.route('/')
def index():
    return f'''
    <html>
        <body style="font-family: sans-serif; text-align: center; padding-top: 80px;">
            <h1>🐍 Python on Fly.io!</h1>
            <p>Deployed at: {datetime.now().isoformat()}</p>
            <p>Region: {os.environ.get("FLY_REGION", "unknown")}</p>
        </body>
    </html>
    '''

@app.route('/health')
def health():
    return jsonify(status='ok')

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=int(os.environ.get('PORT', 8080)))

requirements.txt:

fgluansikc=o=r3n.=1=.203.0.0

Dockerfile:

FROM python:3.12-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 8080

CMD ["gunicorn", "-w", "2", "-b", "0.0.0.0:8080", "app:app"]

Set internal_port di fly.toml ke 8080, lalu flyctl deploy. Selesai.

Yang penting diingat: selalu gunakan production server seperti Gunicorn atau Uvicorn untuk Python. Jangan pakai development server bawaan framework — itu nggak stabil dan nggak aman buat production.

Troubleshooting Umum

Nggak ada yang namanya deploy tanpa masalah. Ini beberapa issue yang sering muncul dan cara ngatasinnya:

1. App gagal start / langsung exit

Cek logs: flyctl logs. Biasanya karena port yang salah. Pastiin aplikasi kamu listen di 0.0.0.0, bukan 127.0.0.1 (localhost). Di Docker, 127.0.0.1 cuma bisa diakses dari dalam container — Fly.io nggak bisa nge-route traffic ke sana.

2. Cold start terlalu lama

Kurangi ukuran image Docker. Pakai Alpine-based image (node:20-alpine, python:3.12-slim). Hapus dependencies yang nggak dipakai. Semakin kecil image, semakin cepat boot.

3. Out of memory (OOM)

Free tier cuma kasih 256MB RAM. Kalau aplikasi kamu makan banyak memory, optimasi kode atau kurangi workers (misalnya gunicorn workers dari 4 jadi 2). Monitor usage di dashboard Fly.io.

4. Volume tidak persist setelah redeploy

Pastikan volume sudah benar-benar di-mount dan path-nya sesuai. Data di volume TIDAK hilang saat redeploy — tapi data di filesystem container (di luar volume) akan hilang. Jadi pastiin data penting ada di path yang di-mount.

5. Rate limit atau billing warning

Free tier punya batas. Kalau kamu kena warning, cek usage di dashboard. Biasanya ini terjadi kalau kamu deploy terlalu sering atau VM nyala terus tanpa auto-stop.

Tips Tambahan Biar Makin Optimal

Beberapa tips dari pengalaman pakai Fly.io di production:

  • Pakai fly.toml sebaik mungkin — File ini pusat kontrol aplikasi kamu. Pelajari setiap opsi di docs Fly.io.
  • Gunakan multiple regions kalau perlu — Kamu bisa deploy VM di beberapa region sekaligus untuk mengurangi latency. Tapi di free tier, fokus satu region dulu aja.
  • Backup volume secara berkala — Free tier nggak include automatic backup. Buat cron job atau script buat backup data secara periodik.
  • Pakai health checks — Tambahkan health check endpoint (seperti /health di contoh atas) dan konfigurasikan di fly.toml supaya Fly.io bisa monitor kesehatan aplikasi kamu.
  • Jangan deploy dari production branch — Gunakan branch terpisah untuk testing, dan merge ke main setelah yakin semuanya berjalan.

Ada Pertanyaan atau Butuh Bantuan?

Kalau kamu mengalami kendala saat deploy, atau butuh bantuan setup infrastruktur yang lebih kompleks di Fly.io — jangan ragu buat reach out.

📧 Hubungi gue di: [email protected]

Gue bantu dari setup sampai troubleshooting, atau bahkan arsitektur yang lebih advanced. Gratis buat ngobrol, bayar kalau butuh eksekusi. 😄

FAQ (Frequently Asked Questions)

Apakah Fly.io benar-benar gratis di 2026?

Ya, Fly.io masih menyediakan free tier di tahun 2026. Kamu bisa mendapatkan hingga 3 shared-cpu VMs, 3GB persistent storage, dan 160GB outbound data transfer per bulan tanpa biaya. Namun, perlu diingat bahwa free tier ini ditujukan untuk development dan side project. Kalau aplikasi kamu sudah mulai punya traffic tinggi, pertimbangkan untuk upgrade ke plan berbayar. Fly.io juga tidak lagi meminta credit card saat pendaftaran, jadi kamu nggak perlu khawatir terkena charge yang tidak diinginkan.

Berapa lama cold start di Fly.io?

Cold start di Fly.io biasanya berkisar antara 1-5 detik, tergantung ukuran image Docker dan kompleksitas startup aplikasi kamu. Untuk mengurangi cold start, gunakan image berbasis Alpine atau slim, minimalkan dependencies, dan hindari operasi berat saat inisialisasi aplikasi. Kalau cold start jadi masalah (misalnya untuk aplikasi yang butuh response time konsisten), kamu bisa set min_machines_running = 1 — tapi ini akan mengonsumsi kuota free tier lebih banyak karena VM akan selalu hidup.

Apakah bisa deploy aplikasi Next.js / Nuxt.js ke Fly.io?

Sangat bisa. Fly.io mendukung Dockerfile, yang berarti kamu bisa deploy hampir semua jenis aplikasi. Untuk Next.js, buat Dockerfile yang menjalankan next build dan next start di production mode. Pastikan internal_port di fly.toml disesuaikan dengan port yang dipakai Next.js (default 3000). Untuk Nuxt.js, prinsipnya sama. Kamu juga bisa memanfaatkan standalone output mode di Next.js untuk mengurangi ukuran image secara signifikan.

Bagaimana cara menambahkan database ke aplikasi di Fly.io?

Fly.io menyediakan beberapa opsi. Yang paling simple untuk free tier: gunakan SQLite dengan persistent volume (seperti contoh di artikel ini). Untuk kebutuhan yang lebih serius, kamu bisa: (1) Spin up PostgreSQL di VM Fly.io sendiri, (2) Pakai layanan database managed eksternal seperti Neon (free tier tersupai), Supabase, atau PlanetScale, atau (3) Gunakan Fly Postgres — managed PostgreSQL dari Fly.io sendiri (ada free trial, tapi setelahnya berbayar). Untuk side project, SQLite + volume biasanya sudah lebih dari cukup.

Bisakah deploy static site ke Fly.io?

Bisa banget. Cara termudah: buat Dockerfile yang pakai Nginx sebagai web server, copy file static kamu ke folder serving Nginx. Atau kalau kamu pakai framework seperti Hugo, Jekyll, atau Astro yang menghasilkan static files, build di local, lalu deploy hasilnya. Fly.io bahkan mendukung buildpack untuk beberapa static site generator. Keuntungannya: static site hampir tidak makan resource sama sekali, jadi sangat efisien di free tier.

Bagaimana cara update aplikasi setelah deploy?

Simpel banget. Setiap kali kamu push perubahan ke kode, tinggal jalankan flyctl deploy lagi dari folder project. Fly.io akan build ulang image, push ke registry, dan rolling update VM kamu. Proses ini biasanya cuma butuh 1-3 menit. Kamu juga bisa setup CI/CD pipeline (GitHub Actions, GitLab CI, dll) untuk otomatis deploy setiap kali push ke branch main. Fly.io menyediakan GitHub Action resmi yang memudahkan ini.

Artikel ini terakhir di-update pada Juli 2026. Informasi mengenai free tier dan fitur Fly.io bisa berubah sewaktu-waktu — selalu cek halaman pricing resmi Fly.io untuk info terbaru.