Deployment Strategies for Openship: Desktop, Self-Hosted, and Cloud Options

Openship supports three distinct deployment strategies—Desktop App for solo development, Self-Hosted Server for teams with Compose or Bare runtime modes, and Openship Cloud as a fully managed SaaS—each optimized for different infrastructure requirements and team sizes.

The oblien/openship repository provides a flexible, open-source deployment platform that adapts to your infrastructure needs. Whether you are a solo developer running the control plane locally or an enterprise team requiring always-on availability, understanding the available deployment strategies ensures you select the right architecture for your workload.

The Three Deployment Strategies for Openship

Openship organizes its deployment capabilities into three primary strategies, each targeting specific operational contexts and resource constraints.

Desktop App (Solo Mode)

The Desktop App strategy runs the control plane directly on your local machine. This approach requires no always-on server infrastructure—the application only runs while the desktop client is active. It supports macOS, Windows, and Linux through native binaries available in the Quick Start documentation. This mode suits individual developers who need to deploy applications temporarily or test configurations locally without provisioning cloud resources.

Self-Hosted Server (Team / Always-On)

The Self-Hosted Server strategy installs the full stack on a Virtual Private Server (VPS) or dedicated Linux machine. This configuration provides 24/7 availability for team collaboration and production workloads. According to the repository's README.md, the self-hosted option supports two distinct operational configurations:

• Compose mode: The server hosts deployed applications directly on the same machine running the control plane.
• Bare mode: The server acts as a driver that launches applications on other remote hosts or cloud providers via SSH.

Openship Cloud (Managed SaaS)

Openship Cloud offers a fully managed, auto-scaling platform where Oblien maintains all infrastructure. You only need to point your domain to the cloud instance, eliminating server maintenance, updates, and scaling concerns. This strategy suits teams that prefer to focus exclusively on application development rather than infrastructure management.

Runtime Modes for Self-Hosted Deployments

When selecting the self-hosted strategy, Openship automatically selects between two runtime modes based on your environment capabilities.

Compose Mode (Docker)

Compose mode utilizes Docker Compose to orchestrate the complete stack. As defined in docker/docker-compose.yml, this includes Postgres for data persistence, Redis for caching, the API service, the dashboard UI, and an OpenResty edge layer. This is the default selection on Linux systems when Docker is available. The platform runs as containerized services on the same machine that executes your deployed applications.

To launch in Compose mode, execute the command from the repository root:

docker compose --env-file .env -f docker/docker-compose.yml up -d

Bare Mode (Lightweight Process)

Bare mode runs the control plane as a single lightweight process without Docker dependencies. In this configuration, the control plane can deploy applications to remote hosts via SSH or to cloud provider instances. This mode activates automatically on macOS, Windows, or Linux systems where Docker is unavailable or when explicitly configured for remote deployment scenarios.

Install and start the control plane using the official installer:

curl -fsSL https://get.openship.io | sh
openship up

Getting Started: Code Examples

The following practical examples demonstrate how to initialize and manage Openship across different deployment strategies.

Deploying a Project

Once your control plane is running—whether in Desktop, Compose, or Bare mode—link a local codebase and trigger deployment:

cd my-project
openship init
openship deploy

Publishing Docker Images

For custom builds or CI/CD pipelines, the release script located at scripts/release.ts can publish Docker images to GitHub Container Registry (GHCR) without creating a new version tag:

bun run release docker 0.0.0-rc.1

Building from Source

When you need to build images from source rather than using pre-built containers, reference docker/docker-compose.build.yml to compile the stack components locally before deployment.

Key Files and Configuration

Understanding the repository structure helps you navigate the deployment configuration:

• docker/docker-compose.yml: Defines the full self-hosted stack including Postgres, Redis, API, dashboard, and OpenResty edge services.
• docker/docker-compose.build.yml: Used for building images from source when customizing the platform components.
• scripts/release.ts: CLI helper that manages Docker image publishing to container registries.
• README.md: Contains the overview of deployment strategies and quick-start commands.
• docs/installation.md: Provides step-by-step installation procedures for each supported mode.

Summary

• Openship offers three deployment strategies: Desktop App for local development, Self-Hosted Server for team infrastructure, and Openship Cloud for managed SaaS convenience.
• Self-hosted deployments automatically select between Compose mode (Docker containers on Linux) and Bare mode (lightweight process for macOS, Windows, or Docker-less Linux).
• The docker/docker-compose.yml file orchestrates the full stack in Compose mode, while scripts/release.ts handles image publishing for custom builds.
• Initialize projects with openship init and deploy with openship deploy regardless of your chosen strategy.

Frequently Asked Questions

What is the difference between Compose mode and Bare mode in Openship?

Compose mode runs the control plane and all services (Postgres, Redis, API, dashboard) as Docker containers on a single Linux host, defined in docker/docker-compose.yml. Bare mode runs the control plane as a standalone process without Docker, typically used on macOS or Windows, and can deploy applications to remote hosts via SSH or cloud providers.

Can I run Openship on my local machine without a server?

Yes, the Desktop App strategy allows you to run the control plane locally on macOS, Windows, or Linux. This requires no always-on server—the application only operates while your desktop client is open, making it ideal for solo development and testing.

How do I deploy Openship on a VPS for my team?

For always-on team access, use the Self-Hosted Server strategy on a Linux VPS. If Docker is available, the platform defaults to Compose mode using docker/docker-compose.yml. If Docker is unavailable or you prefer a lightweight setup, the platform switches to Bare mode, where you install the CLI via curl -fsSL https://get.openship.io | sh and run openship up.

What files control the Docker image building process?

The docker/docker-compose.build.yml file defines how to build Openship's Docker images from source, while scripts/release.ts provides CLI commands to publish these images to GHCR. The standard docker/docker-compose.yml uses pre-built images for immediate deployment.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}