Service Organization

Projects Unified Service Management

Organize all your Shulker services — VPS, Minecraft Servers, DevSpace containers, Databases, and more — into a single visual workspace. Control everything from one page with real-time metrics and intuitive drag-and-drop management.

Updated recently 18 min read Projects Beta
Shulker Projects Dashboard - Visual grid of all your services with drag-and-drop organization

What are Projects?

Unified Dashboard
All your services — VPS, Minecraft, DevSpace, Databases — in one visual workspace.
Drag & Drop UX
Arrange services exactly how you want them. Completely customizable layout.
Service Connection
Connect services via environment variables or the built-in Connect Service feature.
Real-Time Metrics
CPU, memory, disk, and network usage — live updates when you visit the project.
Service Control
Start, stop, restart, view logs, edit env vars — all from one place.
Network Pool
Services in the same network pool can communicate internally via Internal Gateway IP.

📁 Projects is your control center — Stop jumping between multiple dashboards. Projects brings everything together into a single, organized view where you can visually manage and monitor all your Shulker infrastructure.

Getting Started

1
Create a Project
Navigate to Projects in the Shulker sidebar and click New Project. Give it a name and description.
2
Add Services
Click the Add Service button at the top right of the projects page. Choose from your existing VPS, Minecraft servers, DevSpace containers, or Databases.
3
Arrange Your Layout
Drag and drop service cards to rearrange them. Your layout saves automatically.
4
Manage & Monitor
Click on any service to expand its controls — start/stop, view logs, metrics, and environment variables.

💡 Pro Tip — You can add the same service to multiple projects. This is useful for organizing services across different teams or use cases (e.g., "Production" project, "Staging" project, "Development" project).

Service Control Panel

When you click on a service card in your project, an expanded panel opens with full control capabilities.

Start / Stop / Restart
One-click control for any service in your project.
Real-Time Logs
Streaming logs with search, filtering, and export capabilities.
Metrics Dashboard
CPU, memory, disk, and network I/O — updates in real-time.
Environment Variables
View, edit, add, and delete env vars for each service.

📊 Real-Time Metrics — Metrics automatically start streaming when you open a service's detail panel. You'll see live CPU usage, memory consumption, disk I/O, and network traffic. Historical graphs are also available for the past 24 hours.

Networking: How Services Communicate

Understanding how services connect is critical for building integrated applications. Shulker provides two primary methods for service-to-service communication: Internal Network Pools and Public IPs.

🌐 Network Pools (Internal Communication)

A Network Pool is a private virtual network that allows multiple Shulker services to communicate with each other internally, without traffic going over the public internet.

┌─────────────────────────────────────────────────────────────┐
│                    Network Pool: "prod-net"                  │
│                     Internal CIDR: 172.17.0.0/16             │
├─────────────────────────────────────────────────────────────┤
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐   │
│  │  DevSpace A  │    │   Database   │    │  DevSpace B  │   │
│  │ 172.17.0.2:80│◄──►│ 172.17.0.3:5432│◄──►│ 172.17.0.4:3000│   │
│  │   (Web App)  │    │  (PostgreSQL) │    │   (API)      │   │
│  └──────────────┘    └──────────────┘    └──────────────┘   │
│                                                             │
│  All traffic stays within the pool — no public exposure     │
└─────────────────────────────────────────────────────────────┘
1
Check Network Pool
Each service displays its assigned Network Pool in the Info section of its main panel or in the service's settings.
2
Same Pool = Internal Access
If two or more services are in the same Network Pool, they can communicate using each other's Internal Gateway IP addresses.
3
Port Forwarding Required
Even for internal communication, you must forward the required port on the container you want to connect to.
4
Use Internal IP in Env Vars
Add the Internal Gateway IP and forwarded port as an environment variable in the connecting service.
Same Network Pool Connection 
# Assuming both services are in Network Pool "prod-net"
# Database container (PostgreSQL) has Internal IP: 172.17.0.3, forwarded port: 5432

# In the Web App container's environment variables, add:
DATABASE_HOST=172.17.0.3:5432
DATABASE_NAME=mydb
DATABASE_USER=admin
DATABASE_PASSWORD=secret

✅ Internal Communication Benefits — Zero latency overhead (direct container-to-container), no public exposure (more secure), no bandwidth costs, and faster data transfer.

🌍 Public IP Communication

When services are in different Network Pools, or when you need to access a service from outside Shulker, you must use the service's public forwarded IP address.

┌──────────────┐         ┌─────────────────────────────────────────┐
│  DevSpace A  │         │              Public Internet             │
│  (Pool: prod)│         │                                         │
│ 172.17.0.2   │────────▶│  Traffic goes through public internet   │
└──────────────┘         │                                         │
                         └─────────────────────────────────────────┘
                                              │
                                              ▼
                         ┌─────────────────────────────────────────┐
                         │              DevSpace B                 │
                         │            (Pool: staging)              │
                         │    Public IP: in1-north.shulker.in:1002 │
                         └─────────────────────────────────────────┘
Cross-Pool / Public Connection 
# Services in different network pools cannot use internal IPs
# Use the public forwarded IP of the target container

# Database container's public forwarded address (from Port Manager)
# Format: {node}.shulker.in:{forwarded_port}

DATABASE_HOST=in1-north.shulker.in:1002
DATABASE_NAME=mydb
DATABASE_USER=admin
DATABASE_PASSWORD=secret

⚠️ Important — Public IP communication routes through Shulker's edge network and is protected by DDoS filtering. However, it adds minimal latency and counts toward your bandwidth usage. For production applications, keeping services in the same Network Pool is strongly recommended for performance and security.

Connecting Services

Shulker Projects provides two methods to connect services together: the built-in "Connect Service" feature and manual environment variable configuration.

Method 1: Connect Service Feature (Recommended)

1
Open Service Panel
Click on the service you want to configure (the one that needs to connect to another service).
2
Go to Environment Variables
Navigate to the Env Vars section of the service panel.
3
Click "Connect a Service"
Use the Connect Service button to automatically generate the correct connection string.
4
Select Target Service
Choose the service you want to connect to. Shulker will automatically determine if they're in the same Network Pool and provide the appropriate Internal or Public IP.
5
Confirm & Save
The environment variable is automatically added and the services are connected.

Method 2: Manual Environment Variable Configuration

1
Check Service A's Network Pool
In the Info section, note which Network Pool Service A belongs to.
2
Check Service B's Network Pool
Compare Network Pools — same pool = use Internal IP, different pools = use Public IP.
3
Find the Connection String
For same pool: Internal Gateway IP + forwarded port. For different pools: Public forwarded address.
4
Add Environment Variable
In Service A's Env Vars section, add the connection string with the appropriate key name (e.g., DATABASE_HOST).
Manual Connection Examples 
# Example 1: Same Network Pool (Internal Communication)
# Service A (Web App) connecting to Service B (PostgreSQL Database)
# Both are in Network Pool "prod-net"
# Service B has Internal IP: 172.17.0.3, forwarded port: 5432

DATABASE_HOST=172.17.0.3:5432
DATABASE_NAME=myapp
DATABASE_USER=postgres
DATABASE_PASSWORD=securepassword

# Example 2: Different Network Pools (Public Communication)
# Service A (Web App) in "prod-net" connecting to Service B (API) in "staging-net"
# Service B's public forwarded address (from Port Manager)

API_BASE_URL=https://in1-north.shulker.in:1002

# Example 3: Connecting to a Managed Database
# Managed databases have a dedicated hostname

DATABASE_URL=postgresql://user:[email protected]:5432/mydb

🔌 What happens when you click "Connect a Service"? Shulker automatically checks the Network Pool of both services, retrieves the correct connection string (Internal IP if same pool, Public IP if different), creates an environment variable with the appropriate name, and injects it into the source service — all with one click.

Port Forwarding for Service Communication

Before services can communicate (whether internally or externally), you must forward the required ports on the target service.

1
Open Service Panel
Click on the service you want to expose (the one that will receive connections).
2
Go to Port Manager
Navigate to the Port Forwarding or Port Manager section.
3
Add Port Forward
Specify the internal port your application is listening on (e.g., 5432 for PostgreSQL, 3306 for MySQL, 80 for HTTP).
4
Get Connection Address
Shulker provides both an Internal Gateway IP:port and a Public forwarded address (if enabled).

🔐 Port Security — You can apply IP whitelisting to forwarded ports, even for internal Network Pool communication. This adds an extra layer of security by restricting which services can connect to the port.

Understanding Network Pools

Network Pools are the foundation of service isolation and communication in Shulker.

What is a Network Pool?
A private virtual network that assigns internal IP addresses to services. Services in the same pool can communicate directly using these internal IPs.
Isolation
Services in different Network Pools cannot communicate internally — they must use public IPs, creating security boundaries between environments.
Changing Pools
You can move services between Network Pools via the service's Settings page. Requires a restart of the service to take effect.
Finding Network Pool Information 
# Via Shulker Dashboard:
# 1. Navigate to your service's main panel
# 2. Look for the "Info" or "Network" section
# 3. Find "Network Pool" field (e.g., "prod-net", "staging-net", "default")
# 4. Find "Internal Gateway IP" (e.g., "172.17.0.2")

# Via Shulker API:
curl "https://shulker.in/api/v2/?req=service_info&service_id=123&api_key=sk_..."

⚠️ Network Pool Best Practices — Keep services that need to communicate frequently in the same Network Pool for optimal performance. Use different pools for isolation between environments (dev/staging/prod). Changing a service's Network Pool will change its Internal IP address — update any environment variables that reference the old IP.

Real-Time Metrics

When you open a service's detail panel in a project, metrics automatically start streaming in real-time.

CPU Usage
Real-time percentage of CPU cores being utilized. Updates every 2 seconds.
Memory Usage
RAM consumption with peak and average indicators. Shows used/total in MB/GB.
Disk I/O
Read and write operations with throughput graphs. Persistent volume usage separate.
Network Traffic
Inbound and outbound throughput with packet counts. Live graphs for both.

📈 Historical Data — Metrics streaming starts automatically when you view a service. You can also view historical graphs for the past 24 hours, including peak usage times and average load patterns.

Troubleshooting

❌ Services Can't Communicate

Check if they're in the same Network Pool. Verify that the target service has its port forwarded. Confirm the environment variable uses the correct address (Internal IP for same pool, Public IP for different pools). Ensure no IP whitelist is blocking the connection.

📊 Metrics Not Showing

Metrics require the service to be running. If the service is stopped, metrics won't be available. Try restarting the service. For DevSpace containers, ensure the metrics agent is enabled in settings.

🔌 Port Forwarding Not Working

Verify your application is listening on 0.0.0.0 (not localhost/127.0.0.1). Check that no firewall rules are blocking the port. Confirm the internal port number matches what your application uses.

🔄 Service Not Appearing in Project

Refresh the project page. Ensure the service is deployed and in an "active" state. Try removing and re-adding the service to the project.

Best Practices

📁 Project Organization — Create separate projects for different environments (Development, Staging, Production). Use descriptive names and add team members with appropriate permissions.

🔗 Service Connections — Always use the "Connect Service" feature when possible — it handles IP detection and environment variable naming automatically. For manual connections, document your connection strings.

🌐 Network Pool Strategy — Keep tightly coupled services (app + database) in the same Network Pool for optimal performance. Use different pools for security isolation between trust boundaries.

📊 Metrics Monitoring — Set up alerts for abnormal metrics (high CPU, memory leaks, network spikes). Projects can send notifications to Discord, Slack, or email when thresholds are exceeded.

Quick Reference

Connection String Examples 
# Same Network Pool (Internal IP)
DATABASE_HOST=172.17.0.3:5432
REDIS_HOST=172.17.0.4:6379
API_INTERNAL=http://172.17.0.5:8080

# Different Network Pools (Public IP)
DATABASE_HOST=in1-north.shulker.in:1002
REDIS_HOST=in2-south.shulker.in:1003
API_PUBLIC=https://api.shulker.in:1044

# Managed Services
DATABASE_URL=postgresql://user:[email protected]:5432/mydb
MYSQL_URL=mysql://user:[email protected]:3306/mydb
Back to Docs Open Projects