Docs / Your own VM and server
Your own VM and server
The platform is for development and previews. Need your own resources and SSH — your team’s own VM (+ Admin). Need production with your users’ data on your side — Panel Prod: your server, while management, builds and deploys run from this dashboard.
What to choose
| Platform | + Admin · own VM | Panel Prod · own server | |
|---|---|---|---|
| Where it runs | Shared platform servers | A dedicated team VM on platform servers | Your server (x86_64, Ubuntu or Debian) |
| What for | Development, testing, previews | Staging and working projects with their own resources | Production with your users’ data |
| Resources | As per plan | 1–4 vCPU, 2–8 GB, 20–100 GB of disk | Whatever the server has; plan limits don’t apply |
| SSH | — | With your key, without root | It’s your server — your access |
| Databases | Team cluster, backups, pool, external access | Team cluster on the VM, nightly backups, pool, import by link | Cluster on the server; nightly backups on the platform optional; external access by IP allowlist, pool, import by link |
| Logs | Kept for 7 days | Kept for 7 days | Optional: 7 days on the platform or only the latest lines from the server |
| Project addresses | <name> on the platform domain | <name>.vm.relaxdev.ru | <name>.<your domain> |
| Price | As per plan | $6 – $48/month on top of a plan | $12/month, with or without a plan |
A team can have its own VM and Panel Prod at the same time: for example, staging on the VM and production on your own server.
Staging and production
A handy setup: the project runs and is checked on the platform or your own VM — that’s staging — while production lives on your server through Panel Prod. Production logs, database and users stay with you; builds, deploys, domains and certificates run from the same dashboard.
Environments — one project in several places
- In the project settings, block “Where the project runs” → “Create a copy” on your own server or your own VM, with an empty database or with data. An instance of the project, <name>-prod (or -vm), appears in the same team.
- An environment has its own variables (the address is replaced with the new one), its own database — empty or a copy of the data at creation time — its own Redis and its own domains.
- In the project, environments are tabs above the title: “prod”, “preprod” or your own label (changed in settings); without a label — the place: “Platform”, “VM · vm3”.
- “Deploy here” builds in the environment the same commit that runs in the other one: checked on staging — shipped to production. The build uses production’s variables, so NEXT_PUBLIC_* and other build-time values are each environment’s own.
- Autodeploy is off for an environment: production updates only through deploys from another environment. The main project keeps its autodeploy setting.
- The main project can be deleted after its environments; deleting an environment leaves the main project untouched.
Moving without downtime: your domains on the copy right away
- In “Where the project runs”, the copy has a “Domains «…» → here” button: the main server forwards requests for the main project's custom domains to the copy while A records still point to it. The site runs in the copy with its database right away.
- Data written to the main project's database after the copy was created does not reach the copy — switch right after creating it or create the copy again.
- Variables of the copy with the site address (APP_URL, AUTH_URL, NEXT_PUBLIC_SITE_URL) must be your domain, not the copy's tech address — otherwise OAuth sign-in and links lead to the tech address. The panel lists the ones that still point there.
- Your domains are added to the copy right away, waiting for DNS: change the A records to the new server's IP and the domain connects there by itself (checked every 5 minutes), leaves the old project, and so does the forwarding.
- You can stop the old project right after switching; delete it after the DNS change (deleting removes the forwarding). While forwarding is on, requests pass through the platform's main server.
Or move it as a whole
- Move a project to production as a whole — in the project settings, block “Where the project runs” → “Move”.
- Move your whole VM to production — VM page → Panel Prod → “Move the whole VM”: all projects at once, databases are copied.
- If any build fails during the move, everything returns to where it was — sites are never left without a version.
+ Admin — your team’s own VM
What’s inside
- 1–4 vCPU, 2–8 GB of memory, 20–100 GB of disk — you choose when ordering.
- $3 per vCPU + $2 per GB of memory + $0.30 per GB of disk above 20 GB, charged daily from your balance.
- New team projects start on the VM; running ones move over from their settings together with their database.
- Your team’s PostgreSQL cluster on the VM: nightly backups (kept 3 days), external access by IP allowlist.
- An add-on to PRO, PRO Team or Business — it can’t be ordered on its own.
SSH and console
- Sign in with your key, without root: ssh -p 22NN c-login@135.136.191.56 — the command is on your VM card.
- VM processes, your home folder, git, your own tools in ~/bin, pip --user, files over scp, internet access.
- Containers, Traefik and certificates are run by the platform — they can’t be broken by accident.
- Console on the VM page: docker ps, stats, logs, restart and stop (owner and editor).
Panel Prod — your own server
Connecting
- An x86_64 server with Ubuntu or Debian and a public IPv4 address: SSH open, ports 80 and 443 free.
- SSH login details, once: IP, port, root or a dedicated sudo user (e.g. relaxdev), a password or a key. The panel installs Docker and Traefik and then signs in with its own key; your login details are not stored.
- A domain for project addresses, e.g. apps.example.com, with A records for apps.example.com and *.apps.example.com pointing to the server IP.
- $12/month charged daily from your balance; a month’s worth is needed on the balance to connect.
Your data stays with you
- By default logs are not sent to the platform — the dashboard shows the latest lines straight from the server, and the platform makes no database dumps.
- Server options are up to you, in the Panel Prod card: logs on the platform (7 days), visit analytics, nightly database backups (3 days). External database access — a port on the server itself, by IP allowlist, off until you turn it on.
- A platform watchdog keeps an eye on the server’s containers: restarts, memory and CPU at the limit, the server going unreachable. It never stops or starts anything by itself.
- Plan limits don’t apply on your server; use it together with a main plan or on its own.
- Disconnect Panel Prod and the server and its projects stay with you.
Moving
- A project — from its settings: to your own VM or your own server. The code is rebuilt, the database is copied and checked row by row, Redis starts empty, custom domains move along.
- The whole VM to production — VM page → Panel Prod → “Move the whole VM”. Projects move all at once: the team’s database and Redis are shared. While the move runs, builds, restarts and new projects of the team are closed.
- From the isolator — in two steps: via the main server and straight on to your own target.
- Failure — it rolls back by itself: the previous target, variables and addresses. If a project already ran on your server, its database there is not wiped but kept as <db>_rb_<date>.
- Autodeploy is switched off for the move and isn’t switched back on by itself — turn it on once you’ve checked the new place.
- Bots are created on the platform: only there a bot gets access to Telegram right away. On a VM or your own server a bot reaches Telegram through that server’s network; if Telegram isn’t reachable from there, set the RELAXDEV_PROXY_URL variable. A bot copy is created stopped — give it another bot’s token, otherwise two bots with one token get in each other’s way.
Pros and cons
Platform — shared servers
Pros
- The cheapest option, nothing to set up.
- Powerful servers: 200 GB of memory, 104 threads, NVMe.
- Logs for 7 days, visit analytics, AI bot blocking, database connection pooling, nightly database backups.
Cons
- Plan limits on resources and deploys.
- No SSH or custom system settings.
Own VM “+ Admin”
Pros
- Isolation: your own cores and memory, neighbours don’t interfere.
- SSH without root, nightly database backups, logs for 7 days.
Cons
- Requests reach the VM through the platform entry — one short extra hop and a shared entry point.
- No analytics or AI bot blocking yet; up to 4 vCPU and 8 GB of memory.
Panel Prod — your own server
Pros
- All of the server’s power goes to your projects, no plan limits.
- Direct route: the A record points to the server, no intermediate hops.
- Your data stays with you: logs, analytics and backups on the platform only if you turn the options on.
Cons
- The server is on you: system updates, disk space.
- No AI bot blocking yet.
- One server is one point of failure: if it goes down, its sites are down.
A VDS for your project — from 300 ₽/month
Pros
- A dedicated server for one project: we rent the VDS and set everything up, then move the project and domains without downtime.
- Direct route: requests go straight to the app, no intermediaries.
- Logs and backups as you decide: stored on the platform or not.
Cons
- Resources depend on the chosen VDS size; as the project grows, we upgrade the server.
What to choose when
- Fast response and near-100% uptime are critical, with or without VPN: a VDS for your project or team (from 300 ₽/month) or your own server via Panel Prod — a direct route with no intermediaries, resources only yours.
- You just need isolation: your own VM “+ Admin” — your own cores and memory on our servers; requests to the VM take an extra routing step through the platform entry.
- Many projects, spiky load, databases, Redis and storage, no strict response requirements: stay on the platform — powerful servers (200 GB of memory, 104 threads, NVMe) absorb spikes, everything is already set up.
How a request travels
- Platform: the main server’s Traefik, certificates are issued automatically.
- Own VM: platform entry → Traefik on the VM. A custom domain is an A record to the entry address.
- Own server: the A record points straight to the server, Traefik runs on it.
- During a move: the main server forwards the domain’s requests to the copy — an instant switch and one-click rollback at the cost of one extra hop.
Moving without downtime
Why move
- A separate production: production with user data on your own server, development and previews on the platform.
- Your own resources, no plan limits: as many cores and as much memory as the server has.
- Your data stays with you: the production database and logs live on your server; builds, deploys and management stay on the platform.
- Your load is yours: bots and traffic spikes of one site do not affect other projects.
How to move
- 1. Connect a server (VM page → Panel Prod) or order your own VM.
- 2. In project settings, “Where the project runs” → “Create a copy” on the new host, database “with data”. The copy is built alongside while the old site keeps running.
- 3. Check the copy at its tech address. In its variables set the site address (APP_URL, AUTH_URL, NEXT_PUBLIC_SITE_URL) to your domain.
- 4. On the copy press “Domains «…» → here” — from that moment your domain opens the copy.
- 5. Stop the old project and turn on auto-deploy for the copy so pushes build it.
- 6. Change the domain’s A records to the new server’s IP — nothing else to do: the domain is already waiting on the copy and connects by itself (checked every 5 minutes), leaving the old project, and the forwarding goes away too.
Why there is no downtime
- The copy comes up alongside while the old site runs: build, database and checks happen before the switch.
- The switch happens on the platform side: the main server starts forwarding your domain’s requests to the copy. No waiting for DNS — all visitors switch at once.
- Changing the A record later is invisible: visitors still on the old IP reach the copy through the platform, those on the new IP reach it directly. Both paths lead to the same app and database.
- The certificate on the new server is issued once DNS points to it — until then the domain works with its current certificate through the platform.
- Rollback is the “Return domains” button: requests go to the old project again.
Keep in mind
- Data written to the old database after the copy was created does not reach the copy — switch right after checking or create the copy again.
- Background jobs (mailings, updates, bots) would run in two places — stop the old project after the switch.
- While forwarding is on, requests pass through the main server; after the DNS change — directly.
- Don’t want to deal with a server — a VDS for your project from 300 ₽/month: write to support, we rent and set up the server, move the project and database and switch the domains. Logs and backups as you decide.
Domains and addresses
Own VM
- The VM has no IP of its own — it sits behind the platform’s shared entry point 135.136.191.56.
- The <name>.vm.relaxdev.ru address is assigned automatically.
- A custom domain is an A record pointing to 135.136.191.56 in the Domains tab; the certificate is issued automatically.
- A bare IP won’t open a site: the entry point tells projects apart by domain name.
Own server
- The domain you give when connecting is only for technical project addresses <name>.<domain> with HTTPS.
- Your sites’ own domains go in the Domains tab — an A record pointing to the server IP.
- A bare IP won’t open a site: there are several projects and the server tells them apart by domain name.
Databases
- A team has one PostgreSQL cluster and one Redis — they run where the team’s projects run.
- On your own VM: nightly backups (kept 3 days) and manual ones, external access by IP allowlist.
- On your own server: the database port is opened on the server itself by IP allowlist; backups via the “Database backups on the platform” option or on your side.
- The PgBouncer pool and database import by link work on VMs and servers — the source must be reachable from that server.
- A project copy on another platform has its own database: its port (on your own server) and pool are set in the copy’s Database tab, separately from the main project.
- Builds with database access run on the VM or server itself — next to the team’s database, in its network.
- Not available on VMs and servers yet: DataLens.