---
title: "Internal Network Helipod: Cara Koneksi Antar Pod dalam Satu Project"
url: "https://helipod.io/blog/internal-network-pod-to-pod-helipod"
date: "2026-05-09"
updated: "2026-05-09"
author: "Tim Helipod"
tags: ["networking", "internal network", "database", "redis", "helipod", "kubernetes"]
excerpt: "Cara kerja internal network Helipod: koneksi antar pod ke database, Redis, dan multi-service lewat hostname internal, tanpa expose port."
---

# Internal Network Helipod: Cara Koneksi Antar Pod dalam Satu Project

Salah satu fitur paling powerful di Helipod adalah **internal network**: semua service dalam satu project bisa saling berkomunikasi secara langsung tanpa perlu expose port ke internet, tanpa konfigurasi tambahan, dan tanpa biaya bandwidth tambahan.

Ini yang memungkinkan Laravel-mu bisa konek ke PostgreSQL, NestJS bisa akses Redis, atau background worker bisa berkomunikasi dengan API server, semuanya dalam satu project Helipod yang terisolasi.

## Cara Kerja Internal Network

Di balik layar, Helipod menjalankan semua pod dalam satu **Kubernetes namespace** per project. Kubernetes otomatis membuat **internal DNS** untuk setiap pod, sehingga pod bisa saling menemukan satu sama lain via nama.

Format internal DNS hostname:

```
nama-pod.nama-environment.svc.cluster.local
```

Contoh nyata yang terlihat di tab Settings:

```
heli-6cf75a80.env-a2f7e406-4a3e-43c7-acb1-b842d895b920.svc.cluster.local
```

Tapi kamu tidak perlu menggunakan hostname panjang itu. Di Helipod, cukup gunakan **nama pod** yang kamu beri saat membuat service, Kubernetes DNS akan menyelesaikan sisanya.

## Cara Menggunakan Internal Network

### Langkah 1: Buat Services dalam Satu Project

Semua service yang ingin saling berkomunikasi **harus ada dalam project yang sama**. Service di project yang berbeda tidak bisa saling akses via internal network.

Misalnya, untuk stack Laravel + PostgreSQL + Redis:

1. Buat project baru di Helipod
2. Tambahkan service **PostgreSQL**: beri nama `postgres`
3. Tambahkan service **Redis**: beri nama `redis`
4. Tambahkan service **Laravel** dari GitHub repo: beri nama `app`

### Langkah 2: Gunakan Nama Pod sebagai Hostname

Di konfigurasi Laravel (tab Variables):

```env
DB_HOST=postgres
DB_PORT=5432
DB_NAME=mydb
DB_USER=postgres
DB_PASSWORD=secret

REDIS_HOST=redis
REDIS_PORT=6379
```

Nama `postgres` dan `redis` adalah nama service yang kamu beri di canvas, langsung bisa dipakai sebagai hostname.

### Langkah 3: Deploy dan Verifikasi

Setelah semua service running, verifikasi koneksi dari tab **Terminal** di service Laravel:

```bash
# Test koneksi ke PostgreSQL
php artisan db:monitor

# Atau langsung ping
php -r "
\$pdo = new PDO('pgsql:host=postgres;port=5432;dbname=mydb', 'postgres', 'secret');
echo 'Koneksi berhasil!';
"
```

## Contoh per Stack

### Laravel + PostgreSQL + Redis

```env
# .env Laravel (via tab Variables)
DB_CONNECTION=pgsql
DB_HOST=postgres         # nama service PostgreSQL di canvas
DB_PORT=5432
DB_DATABASE=laravel
DB_USERNAME=postgres
DB_PASSWORD=secretpassword

CACHE_DRIVER=redis
QUEUE_CONNECTION=redis
SESSION_DRIVER=redis
REDIS_HOST=redis          # nama service Redis di canvas
REDIS_PORT=6379
REDIS_PASSWORD=null
```

### Django + PostgreSQL

```env
# Via tab Variables
DATABASE_URL=postgresql://postgres:password@postgres:5432/mydb

# Atau individual:
DB_HOST=postgres
DB_PORT=5432
DB_NAME=mydb
DB_USER=postgres
DB_PASSWORD=password
```

```python
# settings.py
import os
import dj_database_url

DATABASES = {
    'default': dj_database_url.config(default=os.environ['DATABASE_URL'])
}

# Atau manual
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'HOST': os.environ['DB_HOST'],  # 'postgres'
        'PORT': os.environ.get('DB_PORT', '5432'),
        'NAME': os.environ['DB_NAME'],
        'USER': os.environ['DB_USER'],
        'PASSWORD': os.environ['DB_PASSWORD'],
    }
}
```

### NestJS + PostgreSQL + Redis

```env
# Via tab Variables
DB_HOST=postgres
DB_PORT=5432
DB_NAME=nestdb
DB_USER=postgres
DB_PASSWORD=password

REDIS_HOST=redis
REDIS_PORT=6379
```

```typescript
// TypeORM config
TypeOrmModule.forRoot({
  type: 'postgres',
  host: process.env.DB_HOST,     // 'postgres'
  port: parseInt(process.env.DB_PORT || '5432'),
  username: process.env.DB_USER,
  password: process.env.DB_PASSWORD,
  database: process.env.DB_NAME,
  entities: [...],
  migrations: [...],
  migrationsRun: true,
})

// BullMQ / Redis
BullModule.forRoot({
  connection: {
    host: process.env.REDIS_HOST,  // 'redis'
    port: parseInt(process.env.REDIS_PORT || '6379'),
  }
})
```

### FastAPI + PostgreSQL (Async)

```env
DATABASE_URL=postgresql+asyncpg://postgres:password@postgres:5432/mydb
```

```python
# database.py
from sqlalchemy.ext.asyncio import create_async_engine
import os

engine = create_async_engine(
    os.environ['DATABASE_URL'],  # postgresql+asyncpg://...@postgres:5432/...
    echo=False,
    pool_size=10,
)
```

### Next.js + PostgreSQL (Prisma)

```env
DATABASE_URL=postgresql://postgres:password@postgres:5432/nextdb
```

```prisma
// schema.prisma
datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}
```

## Multi-Service Architecture

Internal network memungkinkan arsitektur multi-service yang powerful. Contoh stack microservice:

```
Project: myapp-production
├── api-gateway (Next.js)        → port 3000, expose ke internet
├── user-service (NestJS)        → port 3001, internal only
├── payment-service (NestJS)     → port 3002, internal only
├── notification-worker (NestJS) → background, no port
├── postgres (PostgreSQL)        → port 5432, internal only
└── redis (Redis)                → port 6379, internal only
```

Hanya `api-gateway` yang punya URL publik. Service lainnya hanya bisa diakses dari dalam project via internal network.

Konfigurasi `api-gateway`:

```env
USER_SERVICE_URL=http://user-service:3001
PAYMENT_SERVICE_URL=http://payment-service:3002
```

```typescript
// api-gateway/src/user.service.ts
import axios from 'axios';

const userServiceUrl = process.env.USER_SERVICE_URL;

async function getUser(id: string) {
  const response = await axios.get(`${userServiceUrl}/users/${id}`);
  return response.data;
}
```

## Background Worker tanpa HTTP Port

Service yang berjalan sebagai background worker (Celery, BullMQ processor, dll) tidak perlu expose HTTP port. Di `helipack.json`:

```json
{
  "run": {
    "isTcp": true,
    "port": 0,
    "command": "celery -A myproject worker --loglevel=info"
  }
}
```

Atau untuk Laravel Queue Worker:

```json
{
  "run": {
    "command": "php artisan queue:work redis --sleep=3 --tries=3 --max-time=3600"
  }
}
```

Worker bisa akses database dan Redis via internal network sama seperti service lain.

## Keamanan Internal Network

Internal network di Helipod **terisolasi per project**: service dari project A tidak bisa mengakses service dari project B, meskipun keduanya milik akun yang sama.

Ini berarti:
- Database PostgreSQL-mu tidak bisa diakses dari luar project
- Redis-mu tidak exposed ke internet
- Komunikasi antar service terjadi dalam jaringan private Kubernetes

Tidak perlu setup firewall, Security Group, atau VPC rules, Helipod mengurus isolasi jaringan ini secara otomatis.

## Port yang Digunakan Tiap Service

| Service | Port Default | Catatan |
|---------|-------------|---------|
| PostgreSQL | 5432 | Standard PostgreSQL |
| MySQL / MariaDB | 3306 | Standard MySQL |
| Redis | 6379 | Standard Redis |
| MongoDB | 27017 | Standard MongoDB |
| HTTP service | sesuai deteksi | 3000, 8000, 5000, dll |

## Troubleshooting Koneksi Internal

**"Connection refused" ke PostgreSQL**
- Pastikan nama service di `DB_HOST` sama persis dengan nama pod di canvas (case-sensitive)
- Pastikan service PostgreSQL sudah status **Running** sebelum service Laravel/Django deploy
- Cek dari Terminal: `nc -zv postgres 5432`

**"Name resolution failed"**
- Service harus berada dalam **project yang sama**
- Tunggu beberapa detik setelah service baru dibuat: DNS propagation butuh waktu
- Coba dari Terminal: `nslookup postgres`

**Koneksi lambat atau timeout**
- Gunakan connection pooling (PgBouncer, atau connection pool di ORM)
- Untuk Django: set `CONN_MAX_AGE` di database settings
- Untuk Laravel: Helipod sudah include persistent connection by default

**Redis "NOAUTH Authentication required"**
- Jika Redis service kamu dikonfigurasi dengan password, tambahkan `REDIS_PASSWORD` di Variables
- Atau gunakan `REDIS_URL=redis://:password@redis:6379`

## Melihat Internal DNS di Dashboard

Di tab **Settings → Networking & Domains** setiap service, kamu bisa melihat dua URL:

1. **Internal cluster DNS**: hostname panjang untuk akses dalam cluster (labeled "Internal only")
2. **Magic domain**: URL publik format `nama-project.helipod.app`

Untuk komunikasi antar pod, gunakan nama pod pendek saja, tidak perlu hostname panjang.

## Kesimpulan

Internal network di Helipod membuat arsitektur multi-service menjadi mudah, tidak perlu konfigurasi jaringan, tidak perlu expose port database ke internet, dan tidak ada biaya bandwidth tambahan untuk komunikasi antar pod.

Cukup buat semua service dalam satu project, gunakan nama pod sebagai hostname, dan semuanya langsung terhubung.

Ingin setup custom domain untuk service yang menghadap internet? Baca [Cara Setup Custom Domain di Helipod](/blog/custom-domain-di-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).