---
title: "Terminal Live di Helipod: Debug Langsung ke Container Tanpa SSH"
url: "https://helipod.io/blog/terminal-live-di-helipod"
date: "2026-05-12"
updated: "2026-05-12"
author: "Tim Helipod"
tags: ["terminal", "debugging", "helipod", "devops", "production"]
excerpt: "Terminal live di Helipod: akses shell ke container tanpa SSH, jalankan migrasi, debug masalah production, dan inspect environment tanpa setup."
---

# Terminal Live di Helipod: Debug Langsung ke Container Tanpa SSH

Ada masalah di production. Aplikasi tidak berjalan seperti yang diharapkan. Kamu butuh masuk ke dalam container untuk lihat apa yang sebenarnya terjadi, inspect file, cek environment variable, jalankan command debug.

Di setup VPS tradisional, kamu butuh SSH key, IP server, dan biasanya beberapa langkah autentikasi. Di Helipod, kamu cukup buka tab **Terminal** di dashboard, dan langsung dapat shell ke container yang sedang berjalan.

Tidak perlu SSH. Tidak perlu setup apapun.

## Cara Membuka Terminal

1. Buka dashboard Helipod
2. Klik service yang ingin kamu akses
3. Pilih tab **Terminal** di panel sebelah kanan
4. Tunggu beberapa detik: terminal akan otomatis connect ke container

Kamu akan melihat prompt seperti ini:

```
6CF75A80 · CONNECTED
Connecting to heli-6cf75a80-855f9cf889-gnnpt...
nextjs@heli-6cf75a80-855f9cf889-gnnpt:/app$
```

Format prompt: `[username]@[pod-name]:[working-directory]$`

Username disesuaikan dengan framework:
- `nextjs` untuk Next.js
- `appuser` untuk Python (Django/FastAPI/Flask)
- `appgroup` untuk NestJS/Node generic
- `www-data` untuk Laravel/PHP

## Apa yang Bisa Kamu Lakukan di Terminal?

### 1. Jalankan Database Migration

Setelah deploy pertama atau setelah ada perubahan schema:

**Laravel:**
```bash
php artisan migrate --force
php artisan migrate:status
php artisan db:seed --force
```

**Django:**
```bash
python manage.py migrate
python manage.py showmigrations
python manage.py createsuperuser
```

**NestJS + TypeORM:**
```bash
npx typeorm migration:run -d dist/data-source.js
npx typeorm migration:show -d dist/data-source.js
```

**NestJS + Prisma:**
```bash
npx prisma migrate deploy
npx prisma migrate status
npx prisma db seed
```

**FastAPI + Alembic:**
```bash
alembic upgrade head
alembic history
alembic current
```

### 2. Inspect Environment Variables

Cek apakah environment variable sudah ter-inject dengan benar:

```bash
# Lihat semua env vars
env

# Cari variable spesifik
echo $DATABASE_URL
echo $APP_KEY
printenv | grep DB_

# PHP: lihat via artisan
php artisan env
```

> **Catatan keamanan:** Variable yang ditampilkan di terminal session ini tidak dilog atau disimpan oleh Helipod. Tapi tetap berhati-hati, jangan screenshot atau share output yang mengandung credential.

### 3. Debug Koneksi Database

Test koneksi ke database dari dalam container:

**PostgreSQL:**
```bash
# Test dengan psql
psql $DATABASE_URL -c "SELECT version();"
psql -h $DB_HOST -U $DB_USER -d $DB_NAME -c "\l"

# Test dengan nc (netcat)
nc -zv postgres 5432
```

**Redis:**
```bash
redis-cli -h $REDIS_HOST -p 6379 ping
redis-cli -h redis -p 6379 info server
```

**Laravel:**
```bash
php artisan db:monitor
php artisan tinker
>>> DB::select('SELECT 1')
```

**Django:**
```bash
python manage.py shell
>>> from django.db import connection
>>> connection.ensure_connection()
>>> print("Connected!")
```

### 4. Inspect File System

```bash
# Lihat struktur aplikasi
ls -la
ls -la storage/
ls -la public/

# Cek ukuran folder
du -sh *
du -sh storage/*

# Cek apakah file ada
ls -la storage/app/public/
cat .env  # jangan lakukan ini di shared environment!

# Cek permission
stat storage/
ls -la bootstrap/cache/
```

### 5. Jalankan Artisan / Manage Commands

**Laravel:**
```bash
# Cache management
php artisan cache:clear
php artisan config:clear
php artisan route:clear
php artisan view:clear

# Queue management
php artisan queue:work --once
php artisan queue:failed
php artisan queue:retry all

# Tinker (REPL Laravel)
php artisan tinker
>>> User::count()
>>> User::first()
>>> Cache::get('my-key')
```

**Django:**
```bash
python manage.py shell_plus  # jika pakai django-extensions
python manage.py collectstatic --noinput
python manage.py check --deploy
python manage.py clearsessions
```

### 6. Debug Aplikasi Node.js

```bash
# Cek versi Node
node --version
npm --version

# Inspect package yang terinstall
ls node_modules/ | head -20
cat package.json

# Test import module
node -e "const db = require('./dist/database'); console.log(db)"

# Cek environment
node -e "console.log(process.env.NODE_ENV)"
node -e "console.log(process.env.DATABASE_URL)"
```

### 7. Monitor Resource Usage

```bash
# CPU dan memory
top
htop  # jika tersedia

# Disk usage
df -h
du -sh /app/*

# Network connections
netstat -tlnp  # jika tersedia
ss -tlnp

# Process yang berjalan
ps aux
ps aux | grep node
ps aux | grep gunicorn
```

### 8. Manipulasi Storage dan File

```bash
# Laravel storage:link
php artisan storage:link

# Buat folder
mkdir -p storage/app/public/uploads
chmod -R 775 storage/

# Copy file
cp config/production.php config/local.php

# Edit file (jika vi/nano tersedia)
vi .env.testing

# Download file dari URL
curl -o /app/public/assets.zip https://example.com/assets.zip
wget -O file.txt https://example.com/file.txt
```

## Tips Debugging Production

### Debugging Memory Leak

```bash
# Monitor memory selama beberapa detik
watch -n 2 'ps aux --sort=-%mem | head -5'

# Cek memory PHP
php -r "echo memory_get_usage(true) / 1024 / 1024 . ' MB';"

# Node.js memory
node -e "
const used = process.memoryUsage();
for (const key in used) {
  console.log(key, Math.round(used[key] / 1024 / 1024 * 100) / 100, 'MB');
}
"
```

### Debugging Slow Query

**Django:**
```bash
python manage.py shell
>>> from django.db import connection, reset_queries
>>> from django.conf import settings
>>> settings.DEBUG = True
>>> reset_queries()
>>> # Jalankan operasi yang lambat
>>> from myapp.models import MyModel
>>> list(MyModel.objects.all())
>>> print(len(connection.queries))
>>> for q in connection.queries: print(q['time'], q['sql'][:100])
```

**Laravel:**
```bash
php artisan tinker
>>> DB::enableQueryLog();
>>> // Jalankan operasi
>>> User::with('posts')->get();
>>> dd(DB::getQueryLog());
```

### Cek Log Aplikasi dari Dalam Container

```bash
# Laravel
tail -f storage/logs/laravel.log
cat storage/logs/laravel.log | grep ERROR

# Python
cat /var/log/app.log  # jika dikonfigurasi
# Atau lihat stdout langsung via tab App Logs di dashboard

# Node.js
# Stdout/stderr langsung muncul di tab App Logs
```

## Keterbatasan Terminal Helipod

Ada beberapa hal yang perlu diketahui:

**Session tidak persistent**: Terminal session akan terputus jika browser ditutup atau koneksi internet terputus. Command yang sedang berjalan (seperti `php artisan migrate` pada database besar) akan terhenti jika koneksi putus. Untuk command yang butuh waktu lama, gunakan `nohup` atau jalankan di background:

```bash
nohup php artisan migrate --force > /tmp/migrate.log 2>&1 &
# Pantau progress:
tail -f /tmp/migrate.log
```

**Non-root user**: Terminal berjalan sebagai non-root user untuk keamanan. Kamu tidak bisa install package sistem (`apt install`, `apk add`) dari sini. Untuk tambah package sistem, gunakan `helipack.json` dengan field `packages.apk` atau `packages.apt`, lalu redeploy.

**File system ephemeral**: File yang dibuat di dalam container (di luar persistent volume) akan hilang saat redeploy. Jika perlu menyimpan file permanent, mount persistent volume di **Settings → Storage Volumes**.

**Multiple replicas**: Jika service kamu berjalan dengan beberapa replica, terminal akan connect ke **salah satu** replica. Perubahan yang kamu buat (seperti clear cache) mungkin tidak ter-apply ke semua replica.

## Use Case Lanjutan

### Seed Data Production (Hati-hati!)

```bash
# Laravel - jalankan seeder spesifik
php artisan db:seed --class=ProductionDataSeeder --force

# Django - custom management command
python manage.py seed_initial_data --production
```

### Generate Laravel App Key

Jika lupa set `APP_KEY` di Variables:

```bash
php artisan key:generate --show
# Copy output ke tab Variables → APP_KEY
```

### Debug OAuth / JWT Token

```bash
# Laravel - generate personal access token via tinker
php artisan tinker
>>> $user = User::find(1)
>>> $token = $user->createToken('debug-token')
>>> echo $token->plainTextToken

# Decode JWT
echo "your.jwt.token" | cut -d. -f2 | base64 -d 2>/dev/null | python3 -m json.tool
```

### Inspect Container Image

```bash
# Cek OS
cat /etc/os-release

# Cek PHP version dan extensions
php --version
php -m | grep -i redis
php -m | grep -i pdo

# Cek Python packages
pip list | grep -i django
pip show fastapi

# Cek Node version dan packages
node --version
cat node_modules/.package-lock.json | python3 -m json.tool | grep '"version"' | head -20
```

## Kesimpulan

Terminal di Helipod menghilangkan salah satu hambatan terbesar saat debugging production: "bagaimana cara masuk ke dalam container?" Cukup buka tab Terminal, dan kamu langsung punya shell ke container yang sedang berjalan.

Ini bukan fitur yang semua platform punya, Render misalnya, tidak menyediakan terminal ke container sama sekali. Ini salah satu keunggulan Helipod yang langsung terasa nilainya saat ada insiden production.

Ingin tahu cara monitor CPU dan memory aplikasimu? Baca [Panduan Monitoring Metrics Helipod](/blog/monitoring-metrics-helipod).

Punya pertanyaan? Hubungi kami di [support@helipod.io](mailto:support@helipod.io) atau bergabung ke komunitas di [hangar.helipod.io](https://hangar.helipod.io).