Deploy a Docker image to a server you own.

Point Serversinc at an image and a tag. It pulls the image on your server, runs it behind HTTPS, and swaps in each new version without dropping requests.

dash.serversinc.io/applications
An application detail page with its deployments, status and settings

Bring the image, Serversinc runs it.

No build step on the server. Your CI builds the image, Serversinc ships it.

Any registry

Docker Hub, GitHub Container Registry, GitLab, or your own. Save credentials once and reuse them across applications.

Fresh pull on every deploy

Serversinc pulls the tag each time, so pushing a new latest and deploying runs the new image.

Zero-downtime deploys

Rolling deploys wait for your health route to answer, and the old version keeps serving until it does.

Deploy from CI

A deploy trigger lets your pipeline deploy one application with one request, without a personal token.

HTTPS on your domain

The proxy on your server issues the certificate and routes the domain to your app.

One flat price

Bandwidth isn't billed, and image pulls happen on your own server.

Deploy a Docker image in five steps.

The example is a web service on port 8080, pushed to GitHub Container Registry. Change the image, port and registry to match yours.

You’ll need a server connected to Serversinc and an image in a registry. If your code is on GitHub and you’d rather build on the server, use a GitHub app instead, as in the Next.js guide.

Push the image

Build the image in CI and push it to your registry. This workflow builds on every push to main and pushes two tags: latest and the commit SHA.

.github/workflows/image.yml
name: Image
on:
push:
branches: [main]
permissions:
contents: read
packages: write
jobs:
image:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v7
- uses: docker/setup-buildx-action@v4
- uses: docker/login-action@v4
with:
registry: ghcr.io
username: ${{ github.actor }}
password: ${{ secrets.GITHUB_TOKEN }}
- uses: docker/build-push-action@v7
with:
push: true
tags: |
ghcr.io/${{ github.repository }}:latest
ghcr.io/${{ github.repository }}:${{ github.sha }}

The SHA tag gives you an exact version to go back to. GitHub Container Registry needs the image name in lowercase, so rename the repository or set the tag by hand if it has capitals.

Save the registry credentials

Skip this step if the image is public.

  1. Create a token that can read the image. On GitHub, that’s a personal access token with the read:packages scope.
  2. Open Settings → Providers. Under Registries, select Add registry and enter ghcr.io, your username and the token.

Saved registries are shared across the organisation, so every application that pulls from ghcr.io can use the same entry.

Create the application

  1. Open Applications, select New application, then Docker image.
  2. Choose the server and name the application, such as api.
  3. Set Docker image to ghcr.io/acme/api and Default tag to latest.
  4. Under Registry credentials, pick the saved registry.
  5. Under Environment variables, add the values your app reads at runtime.
  6. Under Labels, add traefik.http.services.api.loadbalancer.server.port=8080. The health check and the proxy both use this port.
  7. Select Create application.

Then open the application’s Settings. Set Deploy strategy to Rolling and Health check to a path your app answers quickly, such as /health. Select Deploy.

When the deployment shows Completed, open Logs to see the container’s output.

Put it on a domain

  1. Point an A record for api.example.com at the server’s IP address.
  2. On the application’s Settings, enter api.example.com under Domain and save. The Labels tab now shows a traefik.http.routers.api.rule label. The router takes its name from the application.
  3. On Labels, add these three:
Labels
traefik.http.routers.api.entrypoints=websecure
traefik.http.routers.api.tls=true
traefik.http.routers.api.tls.certresolver=le
  1. Deploy again. The certificate is issued once the domain resolves to the server.

Deploy from CI

Create a deploy trigger on the application, and store the deploy key and secret as CI secrets. Add a step to the end of the workflow:

.github/workflows/image.yml
- name: Deploy
run: |
curl -fsS -X POST "https://api.serversinc.io/v1/applications/${{ secrets.SERVERSINC_DEPLOY_KEY }}/trigger" \
-H "X-Deploy-Secret: ${{ secrets.SERVERSINC_DEPLOY_SECRET }}" \
-H "Accept: application/json"

Each push to main now builds the image, pushes latest, and deploys it. Serversinc pulls the new image and rolls it over once the health check answers. If the new version never answers, Serversinc removes it and the old one keeps serving.

To deploy an exact SHA tag instead, see Deploy triggers.

One flat price for every image.

£5 a month covers your first three servers. Every server after that adds £2 a month. Builds and bandwidth are on the house, and the servers stay on your provider and your bill.

Docker image on Serversinc, answered.

Ship your image today.

Connect a server you already run, or provision one on your cloud account. £5 a month covers the first three.