Skip to main content
Servers Are Up
Virtual Datacenter
PricingFree Tools
Sign inBrowse catalog
Servers Are Up
Virtual Datacenter
PricingFree Tools
Sign inBrowse catalog

Loading…

Servers Are Up

Your apps, automation and data on hardware we own. Build a private stack with predictable capacity and access through your dashboard, API or SSH.

SLA with service creditsOwned hardwareUS-based

Make room for your next idea

Explore the capacity, apps and access options that fit your workload. Check current availability and your total before you buy.

Sign up freeView Pricing

Products

  • Linux VPS
  • Windows VPS
  • Cloud & SaaS Services
  • Cloud Storage (Azure)
  • Virtual Datacenter
  • AI & Agent Hosting
  • Containers
  • Instant Apps
  • Software Platforms
  • Network builder
  • Game Servers
  • Pricing

Resources

  • Free Network Tools
  • 2026 Pricing Benchmark
  • Live SVG Badges
  • Latency & Speed Test
  • Guides & Tutorials
  • Documentation
  • API Reference
  • MCP Server
  • CLI & SDKs
  • OpenAPI & llms.txt
  • Use Cases
  • Free Migration
  • Uptime & Reliability
  • Datacenter
  • System Status
  • Network
  • Provider Comparisons Hub
  • Compare Providers

Company

  • About Us
  • Enterprise
  • Security Architecture
  • Trust Center
  • Blog
  • FAQ
  • Compliance
  • Startup Program
  • Open-Source Sponsorship
  • Press & Media Kit
  • Referral Program
  • Help Center
  • Contact Us
© Servers Are Up
TermsPrivacySLARefund PolicyDPAAcceptable Use
Service information
Docs
  • Documentation Hub
  • Choose a Product
    VMs, Containers & Cloud
  • First Linux Server
    SSH, Firewall & Apps
  • Windows Server 2025
    BYOL & Remote Desktop
  • Remote Access
  • Troubleshooting
  • FAQ
  • All Product Guides
    29 Step-by-Step Guides
  • Cloud & SaaS Catalog
    112 Cloud & SaaS Offerings
  • Azure Cloud Storage
    Hot/Cool/Archive & WORM
  • Resource Manager & RBAC
    Groups, Tags & Locks
  • Multi-Model Cloud DB
    JSONB, SQL & pgvector
  • Cloud Identity & ZTNA
    OIDC, SCIM & PIM
  • Key Vault & KMS
    Secrets & Envelope Keys
  • Cloud SIEM, SOAR & DLP
    Posture & Threat Response
  • API Gateway & Cloud DNS
    Edge WAF & DNS Zones
  • Serverless, Workflows & IoT
    Functions, Queues & DAGs
  • SaaS, Governance & Vault
    Budgets & Off-Host GRS
  • Build Web Apps with AI
  • Next.js and React
  • TypeScript and Node.js
  • npm and Tooling
  • Data and APIs
  • Deploy and Operate
  • Tutorials
  • Infrastructure
  • Automation & Regions
  • API Overview
  • API v1 Reference
    Endpoints & 23 Scopes
  • MCP Server
    129 AI Agent Tools
  • Swagger / OpenAPI 3.1
  • API Playground
  • Versioning & Sunset
  • API Token Security
    Authentication & Tokens
  • Instances API
    Compute Resources
  • Networking API
    Networks & Ports
  • Storage API Availability
    Volumes & Backups
  • Webhooks & Events
    Event Notifications
  • Rate Limits & Best Practices
    Throttling & Retries
  • sau CLI Reference
    34 Commands (v0.2)
  • Browser Web CLI
  • SDKs
  • Infrastructure as Code
    Terraform & Ansible
  • Code Examples
  • CLI & SDK Guides
  • Security Guides
  • Security at a Glance
  • Zero Trust Architecture
  • Live Trust Center
  • Compliance
Need help?

Loading documentation...

Documentation/products

Deploy your repository as a Custom GitHub App

Build and run a public GitHub repository commit on an isolated host with pinned environment variables, health checks and redeploy hooks.

Intermediate
18 min
Updated 2026-11-12

Deploy Ready-to-Run Infrastructure in Seconds

Linux VMs from $6/mo · Pooled Virtual Datacenters from $12/mo · Use code WELCOME20 for 20% off your first order.

Browse ServersView Pricing

Commands checked on 2026-11-12 with Servers Are Up Platform v1.7, Docker Engine 27, Git 2.43.

What you will have at the end

Your own application repository from GitHub will build at an exact, immutable commit SHA on an isolated Servers Are Up host, run with validated health checks and injected runtime secrets, and redeploy cleanly whenever you push a reviewed release from GitHub Actions or the v1 API.

Before you start

  • A GitHub repository containing a production Dockerfile at the repository root (or a specified subdirectory) that listens on a configurable TCP PORT (for example 3000 or 8080) and exposes an HTTP health route such as /healthz or /api/health.
  • A Servers Are Up account signed in at /dashboard, plus an optional scoped Personal Access Token created on Account settings > API keys (/account/api-keys) if you want automated CI/CD redeploys from GitHub Actions.
  • Check live catalog availability for app-custom-github via GET /api/v1/catalog or Home > Create a resource (/dashboard/store).

Steps

1. Prepare a deterministic Dockerfile and health endpoint in your repository

Ensure your repository builds reproducibly from a lockfile and binds to 0.0.0.0 inside the container so the host reverse proxy can reach it:

FROM node:24-bookworm-slim AS build
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:24-bookworm-slim AS runner
WORKDIR /app
ENV NODE_ENV=production
ENV PORT=3000
USER node
COPY --from=build --chown=node:node /app ./
EXPOSE 3000
HEALTHCHECK --interval=15s --timeout=3s --start-period=15s \
  CMD node -e "fetch('http://127.0.0.1:3000/healthz').then(r=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))"
CMD ["node", "dist/server.js"]

Commit and push your Dockerfile, then record the full 40-character commit SHA you want to deploy (git rev-parse HEAD). Pinning an exact commit SHA guarantees the host builds the exact code you reviewed.

2. Configure the Custom GitHub App deployment

Open Home > Create a resource (/dashboard/store?src=dashboard&product=app-custom-github) or inspect existing app records at /dashboard/custom-apps:

  1. Paste your HTTPS GitHub repository URL (https://github.com/your-org/your-service) and the pinned branch or 40-character commit SHA.
  2. Specify the internal container port (3000) and health-check path (/healthz).
  3. Supply non-secret runtime configuration (NODE_ENV=production, LOG_LEVEL=info) and reference sensitive credentials from Access > Key vault & KMS (/dashboard/key-vault) so secrets never sit in repository files.
  4. Complete checkout when app-custom-github is marked Available in the catalog, or deploy the identical container workflow onto a Linux VPS (/linux) or Managed Docker host (/containers) at any time.

3. Automate zero-downtime redeploys on push with GitHub Actions

To redeploy automatically whenever main passes tests, store a least-privilege Servers Are Up API token (instances:exec + instances:read) in your GitHub repository under Settings > Secrets and variables > Actions as SAU_API_TOKEN, alongside SAU_INSTANCE_ID.

Add .github/workflows/deploy-sau.yml to trigger an authenticated pull-and-restart over the audited /api/v1/instances/{id}/exec endpoint (no raw SSH private key needed in GitHub!):

name: Deploy to Servers Are Up
on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run build and tests
        run: |
          npm ci
          npm test
      - name: Roll out pinned commit via SAU v1 API
        env:
          SAU_API_TOKEN: ${{ secrets.SAU_API_TOKEN }}
          SAU_INSTANCE_ID: ${{ secrets.SAU_INSTANCE_ID }}
          GIT_SHA: ${{ github.sha }}
        run: |
          curl -fsSL -X POST "https://serversareup.com/api/v1/instances/${SAU_INSTANCE_ID}/exec" \
            -H "Authorization: Bearer ${SAU_API_TOKEN}" \
            -H "Content-Type: application/json" \
            -d "{\"command\":\"/usr/local/bin/redeploy-app.sh ${GIT_SHA}\",\"timeoutMs\":120000}"

4. Attach a custom domain and inspect live logs

Open Network (/dashboard/network) to verify port 443 forwards to your host's TLS reverse proxy, and stream build or runtime container logs from Automation > Console & scripts (/dashboard/ide) or via the sau CLI:

sau ssh <instance-id> -- docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"

Check that it works

Query your live health endpoint and confirm it reports HTTP 200 and the exact deployed commit SHA:

curl -fsSL https://api.example.com/healthz | jq .

Check Operations > Activity log (/dashboard/activity) to confirm every automated deployment command is recorded with the caller token prefix, timestamp, and exit status.

What can go wrong

  • Container builds cleanly but never turns healthy. Your server code bound to 127.0.0.1 inside the Docker container instead of 0.0.0.0, preventing Docker port publishing from reaching the process. Bind 0.0.0.0 inside the container while binding 127.0.0.1:3000:3000 on the host side behind Caddy.
  • npm ci fails inside the Docker build with missing lockfile or engine mismatch. Commit package-lock.json and match the FROM node:24-... base image to your engines.node constraint in package.json.
  • GitHub Actions deploy step returns 403 Forbidden. Confirm the Personal Access Token in SAU_API_TOKEN carries instances:exec scope and that no ReadOnly management lock is active on the target server in /dashboard/resource-manager.

Good practice

  • Always deploy immutable 40-character Git commit SHAs or signed OCI image digests (@sha256:...) from Compute > Container registry (/dashboard/container-registry) rather than mutable latest tags.
  • Keep your redeploy script idempotent on the host (/usr/local/bin/redeploy-app.sh <sha>) and validate /healthz before stopping the previous container so a broken release never causes downtime.
  • Rotate CI tokens every 90 days on Account settings > API keys (/account/api-keys).

Where to go next

  • Run your first Docker Compose stack on Managed Docker
  • Create a scoped API key and send your first v1 request
  • Run serverless functions, workflows, queues and OCI registries

Related Articles

Create a scoped API key and send your first v1 request

Read more

Route APIs with Edge WAF, rate limits and Cloud DNS

Read more

Purchase Azure-backed cloud storage with WORM locks and SAS

Read more

Frequently Asked Questions

What does the Deploy your repository as a Custom GitHub App documentation guide cover?
Build and run a public GitHub repository commit on an isolated host with pinned environment variables, health checks and redeploy hooks. It is rated intermediate difficulty (18 min) and applies to Servers Are Up infrastructure and workflows.
Can I manage or automate these steps through the Servers Are Up dashboard, REST API v1, or MCP server?
Yes. Every Servers Are Up server includes browser-based SSH, WebRDP, and VNC console access in the dashboard, plus programmatic control via the REST API v1 (/api/v1) and hosted Model Context Protocol server (/api/mcp/v1) using a scoped Personal Access Token.

Need hands-on help with Deploy your repository as a Custom GitHub App?

Every Servers Are Up virtual machine and container includes an integrated HTML5 browser-based SSH, RDP, and VNC console in your dashboard, default-off inbound firewall rules with per-IP allow-lists, and full programmatic control via REST API v1 and Model Context Protocol (MCP). Explore our Virtual Datacenter Plans or reach out to Servers Are Up Support.

Was this article helpful?

On this page

What you will have at the endBefore you startSteps1. Prepare a deterministic Dockerfile and health endpoint in your repository2. Configure the Custom GitHub App deployment3. Automate zero-downtime redeploys on push with GitHub Actions4. Attach a custom domain and inspect live logsCheck that it worksWhat can go wrongGood practiceWhere to go next