User Guide: Deploy or Publish Your Application

After building an application using open web services in Eyevinn Open Source Cloud (OSC), you have three paths to choose from. Each path is fully supported, and you can switch between them at any time.

Overview

Path Best for Requirement Link
1. Open Source — Submit to OSC Catalog Sharing with the community, earning revenue Public GitHub repo, MIT/Apache 2.0 license Builders Dashboard
2. Private Deployment on OSC Running your app without open sourcing Any HTTPS git repo (GitHub, GitLab, Gitea, etc.), Node.js/Python/WASM My Apps Dashboard
3. External Deployment Deploying on your own infrastructure None — zero lock-in Use OSC service APIs from anywhere

Path 1: Submit to the OSC Catalog (Open Source)

Make your creation publicly available as a one-click service that other OSC users can deploy. You earn revenue share from every user who runs your service.

Requirements

  • A public GitHub repository
  • An open source license: MIT or Apache 2.0
  • A Dockerfile in the repository root
  • The container must read the PORT environment variable to determine the listening port
  • Environment variables for any user-configurable settings

How to Submit

  1. Log in to Eyevinn Open Source Cloud
  2. Navigate to the Builders Dashboard at app.osaas.io/dashboard/builders
  3. Enter the public URL to your GitHub repository
  4. If your service requires environment variables, toggle "Enable env variables" and specify them
  5. Click Add new repository to submit

Your code enters a review queue. Once accepted, it becomes available in the OSC service catalog for anyone to deploy with one click.

Revenue Sharing

As a creator, you earn a share of the revenue generated when other users create instances of your service. See the Creator Guide for details.

Preparing Your Dockerfile

Your Dockerfile must produce a container that: - Listens on the port specified by the PORT environment variable - Starts cleanly without manual intervention

Example for a Node.js application:

FROM node:20-alpine AS build
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:20-alpine
WORKDIR /app
COPY --from=build /app/dist ./dist
COPY --from=build /app/node_modules ./node_modules
COPY --from=build /app/package.json ./
EXPOSE 8080
CMD ["node", "dist/index.js"]

Path 2: Deploy Privately on OSC

Run your application on OSC infrastructure without open sourcing it. No public repository or open source license required.

Supported Tech Stacks

  • Node.js — npm-based projects with a package.json
  • Python — pip-based projects with a requirements.txt
  • WebAssembly — Compiled .wasm modules

Requirements

  • A git repository (public or private) on any HTTPS git host — GitHub, GitLab, Gitea, or self-hosted
  • A /health endpoint that returns HTTP 200 for OSC to monitor your application
  • Your app must listen on the port specified by the PORT environment variable
  • No Dockerfile needed — OSC automatically handles containerization

How to Deploy

  1. Log in to Eyevinn Open Source Cloud
  2. Navigate to My Apps at app.osaas.io/dashboard/my-apps
  3. Click Create App
  4. Choose your git source:
  5. I have a git repository — provide any HTTPS git URL (GitHub, GitLab, Gitea, etc.)
  6. I need a git repository — OSC provisions a managed Gitea repository for you and shows push instructions before deploying
  7. Provide:
  8. A unique application name (alphanumeric only, no hyphens or special characters)
  9. Your git repository URL (e.g. https://github.com/youruser/yourrepo or https://gitlab.com/youruser/yourrepo)
  10. The runtime type (Node.js, Python, or WebAssembly)
  11. An access token (required for private repositories)
  12. Click Deploy

Your app will be built, deployed, and assigned a public URL.

Tip: If you don't have a git repository yet, select "I need a git repository" in the Create App dialog. OSC will provision a managed Gitea instance for your account and create a repository. You'll receive push instructions so you can push your code before the app is deployed.

Using MCP or CLI

You can also deploy using the OSC MCP tool create-my-app or the CLI:

# Using CLI (GitHub)
npx @osaas/cli@latest app create myapp \
  --type nodejs \
  --github-url https://github.com/youruser/yourrepo

# Using MCP (via AI agent — accepts any HTTPS git URL)
# Ask your AI agent: "Deploy my app from https://github.com/youruser/yourrepo as a Node.js app called myapp"
# Or with GitLab: "Deploy my app from https://gitlab.com/youruser/yourrepo as a Node.js app called myapp"

If you need a managed git repository first, ask your AI agent:

"Set up a git repository for my app called myapp"

The setup-git-repo MCP tool provisions a Gitea repository under your account and returns clone URL and push instructions.

Managing Your App After Deployment

Once deployed, you can restart, rebuild, enable high-availability mode, and configure custom domains. See Managing Custom Apps for the full guide.

Connecting OSC Services

Your private app can use any OSC service (databases, caches, storage, etc.). Create services first, then configure your app with their connection URLs via environment variables or a parameter store.

Path 3: Deploy Externally

Deploy your application anywhere you want — AWS, Vercel, your own servers, or any other hosting provider. This is fully supported with zero lock-in.

How It Works

All OSC-hosted services (databases, media processing, analytics, storage, etc.) expose standard APIs that are accessible from any host on the internet. Your externally deployed application connects to OSC services using:

  • Service URLs — Each OSC service instance has a public HTTPS URL
  • Authentication — Use your OSC Personal Access Token (PAT) for API authentication
  • Standard protocols — PostgreSQL connections, S3-compatible storage, Redis-compatible caching, REST APIs

Example: External App Using OSC Database

# 1. Create a PostgreSQL database on OSC (via CLI or MCP)
npx @osaas/cli@latest create birme-osc-postgresql mydb \
  -o username=myuser -o password=mypassword -o database=myappdb

# 2. Get the connection URL
npx @osaas/cli@latest describe birme-osc-postgresql mydb

# 3. Use the connection URL in your externally deployed app
# Example: DATABASE_URL=postgresql://myuser:mypassword@mydb-xxxxx.db.osaas.io:5432/myappdb

Why This Matters

  • No vendor lock-in — Every OSC service is based on open source software
  • Portable architecture — If you ever want to self-host, you can run the same open source software on your own infrastructure
  • Hybrid approach — Use OSC for services that are hard to manage (databases, media processing) while running your application code wherever you prefer

Decision Matrix for AI Agents

When helping a user decide which path to take, consider these factors:

Factor Path 1: Open Source Path 2: Private OSC Path 3: External
Code is open source Required Not required Not required
Wants to earn revenue Yes No No
Needs managed hosting Yes (via catalog) Yes (via My Apps) No (self-managed)
Supported stacks Any (with Dockerfile) Node.js, Python, WASM Any
OSC services accessible Yes Yes Yes
  1. First ask: "Would you like to make this available to the OSC community, or keep it private?"
  2. If open source → Path 1 (builders dashboard)
  3. If private and wants OSC hosting → Path 2 (my-apps dashboard)
  4. If private and has own hosting → Path 3 (external deployment)