Start here

What do you have?

Four ways in. Pick the one that describes what is on your disk right now — the rest of the page is one section per card.

Once

Log in, and make a project.

A project is the namespace your apps, databases and volumes live in. You do this once — every later command acts on the selected project.

1. Install the CLI

   Linux and macOS, amd64 and arm64. Windows binaries are attached to every release. PREFIX=$HOME/.local installs somewhere other than /usr/local/bin.

   install

   copy

   curl -fsSL https://raw.githubusercontent.com/hostimdev/cli/main/install.sh | sh
   

2. Log in and select a project

   Create an API token in the console under Account Settings → API Tokens. It is validated against the API and saved to ~/.config/hostim/config.yml with mode 0600.

   login

   copy

   hostim login
   hostim projects create myproject --region eu-center
   hostim use myproject
   

3. In CI, skip the login

   Two environment variables instead, and nothing is written to disk. Add -o json to any command to parse the result.

   ci

   copy

   export HOSTIM_TOKEN=…
   export HOSTIM_PROJECT=myproject
   hostim deploy app --git https://github.com/hostimdev/demo-express --branch main
   

A published image

Run an image from a registry.

Nothing is built. Give the image a plan, the port it listens on and — if it keeps data — a volume. These four are deployed exactly as written.

# A static site or a proxy
hostim deploy site --docker-image nginx:alpine --plan sa-1-1 --port 80

# Uptime Kuma — monitoring and status pages, SQLite in the volume
hostim volumes create kuma-data --plan vol-0
hostim deploy kuma --docker-image louislam/uptime-kuma:2 --plan sa-1-1 --port 3001 --volume kuma-data:/app/data

# Memos — notes, a 20 MB image
hostim volumes create memos-data --plan vol-0
hostim deploy memos --docker-image neosmemo/memos:stable --plan sa-1-1 --port 5230 --volume memos-data:/var/opt/memos

# Vaultwarden — Bitwarden-compatible password manager
hostim volumes create vault-data --plan vol-0
hostim deploy vault --docker-image vaultwarden/server:latest --plan sa-1-1 --port 80 --volume vault-data:/data

The vol-0 volume plan is 1 GB and costs nothing, so each of these is €2.50/month in total. A private registry works the same with --registry, --docker-user and --docker-pass. Shipping a new build is the same command with a new tag — the app is updated, not recreated.

A Git repository

Build the Dockerfile in your repo.

The platform clones the repository, builds the Dockerfile and runs the image. The command waits for the build and exits non-zero if it fails, which is why the same line belongs in CI.

This is the Express example app — github.com/hostimdev/demo-express — with the PostgreSQL, Redis and volume it expects. No credential is typed anywhere: $(DB_POSTGRES_PASSWORD) and the rest are resolved by the platform when the container starts.

hostim db postgres create db --plan sp-0
hostim db redis create redis --plan sr-0
hostim volumes create avatar-uploads --plan vol-0

hostim deploy app --git https://github.com/hostimdev/demo-express --branch main \
  --plan sa-1-1 --port 3000 \
  --volume avatar-uploads:/app/public/uploads/avatars \
  --env 'DB_HOST=$(DB_POSTGRES_HOST)' \
  --env 'DB_USER=$(DB_POSTGRES_USER)' \
  --env 'DB_PASS=$(DB_POSTGRES_PASSWORD)' \
  --env 'DB_NAME=$(DB_POSTGRES_DATABASE)' \
  --env 'REDIS_HOST=$(REDIS_REDIS_HOST)' \
  --env 'REDIS_PORT=$(REDIS_REDIS_PORT)'

Point --git at your own repository and the command is unchanged. Private repositories take --git-token; a Dockerfile outside the root takes --dockerfile. Each example app below is the same shape, and its template creates the whole set in one command:

hostim templates apply --id demo-expressjs --new-project express-demo --yes

Software you did not write

34 stacks, one command each.

A curated template creates the app, its database, its Redis and its volumes in order, with the environment variables already wired. Nothing to look up.

hostim templates ls
hostim templates show linkding
hostim templates apply --id linkding --new-project bookmarks --yes

--new-project creates the project first, so those three lines are a whole deployment from an empty account. Without it the resources land in the project you selected. Drop --yes and the command prints what it will create and asks first.

That is a selection; hostim templates ls prints the rest. Any template can be written out with --save stack.yml, edited — a bigger plan, a different image tag, an extra variable — and deployed with hostim templates apply -f stack.yml.

A docker-compose.yml

Bring the file you already have.

The Compose file is converted into a stack: each service becomes its own app on its own plan, named volumes become volumes, and postgres, mysql or redis services become managed instances instead of containers you have to maintain.

hostim templates apply --compose docker-compose.yml --save stack.yml
hostim templates validate -f stack.yml
hostim templates apply -f stack.yml

Saving first is worth the extra line. The converted file is plain YAML, and it is where you set plans, fix a port, or add the Git URL for a service that was build: . locally. validate checks it offline, without creating anything.

After it is up

Everything else is one line.

Logs, variables, domains, a shell in the container, and what it all costs.

hostim status                              # build and runtime state of every app
hostim logs web --follow                   # stream logs
hostim env set -a web KEY=value            # set a variable, restarts the app
hostim env pull -a web                     # write them to a local .env
hostim domain add app.example.com -a web   # prints the DNS record to create
hostim exec web -- sh                      # a shell inside the container
hostim overview                            # every resource and its monthly cost

Questions

Before you start.