Cloud VPS

With shared hosting, resources are shared among several clients. A VPS gives you dedicated resources (vCPU, RAM, SSD), root access and full isolation — more performance and control.

Yes, all our Linux VPS include full root access via SSH. You install whatever you want, configure your stack freely, and manage permissions as you need.

3 configurations, all with root access and a dedicated IPv4: VPS Start (2 vCPU, 4 GB RAM, 50 GB SSD — 99 DH/month), VPS Power (4 vCPU, 8 GB RAM, 100 GB SSD — 299 DH/month) and VPS Business (8 vCPU, 16 GB RAM, 200 GB SSD — 499 DH/month). Up-to-date details are on the VPS Cloud page.

Yes. Every VPS gets a free address of the form vps-xxxxxxx.servorbit-dns.com, included and active from the moment it's provisioned. It masks the public IP and lets you do everything — connect over SSH, publish an application or share an access point — without owning a domain. You'll find it in your VPS console (client area → VPS → Manage). Register or transfer your own domain whenever you like: your branded address stays available alongside it.

Yes, subject to the terms of use. You can install Node.js, Python, Docker, Nginx, Apache, or any other software compatible with your Linux distribution.

You choose your Linux distribution at order time (Ubuntu, Debian, and other common distributions). You can reinstall the system whenever you want.

A template is a preconfigured environment (for example Open WebUI, n8n, Coolify) installed automatically when the VPS is created, so you can get started without manual configuration.

By default, the VPS is unmanaged: you have full control of it. A VPS administration service is available as an option if you prefer to entrust it to us.

Yes, every VPS comes with a dedicated IPv4 address, included in the price. An IPv6 is available on request.

No. When you order a VPS, you choose its address freely — without ever blocking checkout. Three options: keep the free servorbit-dns.com subdomain (offered by default, nothing to buy), use a domain name you already own on your account (we attach it to the server as soon as it's provisioned), or register a new one along the way. You can also start on the free subdomain and attach a domain later, at any time.

VPS Power includes snapshots. VPS Business includes snapshots and automatic backups. You can also configure your own backups (rsync, borgbackup, etc.).

Yes. From your client area, add options (vCPU, RAM, disk space, additional IP) on the fly: the difference is billed pro rata for the remaining time and the resources are applied upon payment, with no data loss.

Partly. From the client area, you can remove reclaimable options — vCPU, RAM, backup, snapshots — and release an additional IP: the reduction is immediate and the unused portion is refunded to you pro rata (as credit). The main IP and disk space cannot be reduced (the disk cannot be shrunk without risk) — for these cases, contact support.

Yes. The VPS Power and VPS Business plans are recommended for production depending on the expected load (traffic, containers, databases).

Yes. On the VPS Cloud configurator, after choosing the plan and the distribution, set the "Number of VPS" before continuing: we create as many independent servers — each with its own machine, its IP and its credentials — paid for in a single order. You can then manage them separately from your client area.

Avoid it: during a 1-click installation, your server is momentarily frozen and management actions are suspended. If you restart it or connect to it (console / SSH root) at that moment, you risk interrupting the installation. There is no cause for concern about your data, however: we take a backup (snapshot) just before starting, and in the event of an interruption your server is automatically restored to its state before the installation. Simply wait for the operation to finish (the page updates on its own).

In one click from your client area: in your VPS console, the "Attached domains" section (or a domain's DNS tab, "Attach to a VPS") points the domain to the server's IP — we automatically create the A records (root and www) and configure the reverse proxy. The domain must belong to the same account and the VPS must be active with an assigned IP. You can also order or transfer a domain directly for this VPS: the routing will take effect as soon as it is activated.

The free `vps-xxxxxxx.servorbit-dns.com` address is perfect to get started: it hides the IP and serves your apps over HTTPS. But your own domain name carries your brand, makes your professional e-mail reliable (you control SPF, DKIM and DMARC on your own domain) and reassures your visitors. You attach it in one click from the client area — managed DNS and HTTPS certificate included — and the free address keeps working during the switch.

Yes. When installing an application (client area → VPS → Manage → Applications), you choose its web address — a subdomain (e.g. dolibarr.monsite.tld) or a path (monsite.tld/dolibarr) — on one of your domains. We create the DNS record automatically if your domain uses our managed DNS (otherwise we tell you which record to create at your provider), then we set up a reverse proxy and an HTTPS certificate (Let's Encrypt) that renews automatically. No domain yet? Publish the application on your free subdomain (e.g. dolibarr.vps-xxxxxxx.servorbit-dns.com, HTTPS included, nothing to configure), or register / transfer your own domain directly from the form. VPN-type network applications (OpenVPN, WireGuard) are an exception: they install without a web domain and are used via the server's address (its IP or its ServOrbit address).

Yes, from your VPS console (Network & security → Reverse DNS). The PTR record is essential for sending e-mail from the server: it must match the name your mail server announces. If you don't have a domain of your own, you can set your free ServOrbit address as the PTR in one click — it already points to the server's IP, giving a “confirmed” reverse DNS that mail services expect.

Yes. From the client area → VPS → Manage → Applications, each installed application offers an "Uninstall" button. You choose whether to keep the data (by default: only the containers are removed, and a reinstallation recovers them) or to delete it permanently. As with installation, the operation is confirmed by a security code, your server is momentarily unreachable, and a backup (snapshot) is taken before starting: in the event of a problem, the server is restored identically. Once finished, the port and the resources the application occupied are available again. Note: an application required by another installed application cannot be removed as long as the latter is present.

Yes, thanks to K3s — a lightweight, CNCF-certified Kubernetes distribution — you can deploy a working cluster on a VPS with as little as one vCPU and 2 GB of RAM. K3s packages all control plane components into a single 60 MB binary and replaces etcd with SQLite, dramatically reducing memory usage. It remains fully compatible with `kubectl` and Helm, so you can use the standard Kubernetes ecosystem without extra infrastructure costs.

Yes. Woodpecker CI (server + agent) uses less than 50 MB of RAM at idle, and Forgejo runs comfortably within 300 to 500 MB. A 2 GB RAM VPS is sufficient for everyday use (a few repositories, short pipelines). For more intensive builds (compilation, parallel tests), a 4 GB VPS provides better headroom. Each pipeline step runs in an isolated Docker container, so Docker must be installed and the daemon active.

Yes. Every GitHub repository publishes an Atom release feed at `https://github.com/<owner>/<repo>/releases.atom`. Add these URLs in FreshRSS, create an auto-star rule on keywords like 'security' or 'breaking change', and enable the ntfy webhook or email webhook in settings. FreshRSS refreshes feeds every 20 minutes server-side — you receive a mobile notification the moment a maintainer publishes an alert, without opening any application.

In FreshRSS, go to Settings → Authentication → GReader API access, enable the API, and note the endpoint URL (format `http://ip-or-domain:8080`). In Reeder 5, add an account of type 'FreshRSS' (or 'Fever' depending on version) and enter that URL with your FreshRSS username and password. In NetNewsWire, select 'FreshRSS' from the accounts list and do the same. Feeds and read states (read/unread, starred) sync automatically. Recommendation: enable HTTPS via an nginx reverse proxy so your credentials are not transmitted in plain text over the internet.

FreshRSS uses less than 128 MB of RAM at idle. A 512 MB VPS is more than sufficient for personal use or a small team of 5 to 10 users with 200 to 500 feeds each. For more than 10 simultaneous users or thousands of feeds, a 1 GB VPS is recommended. FreshRSS can coexist with other applications on the same VPS without issue — it occupies only a single Docker container and its SQLite database stays under a few megabytes even after months of intensive use.

Yes. FreshRSS supports OPML import and export — the standard format for exchanging RSS subscription lists. In Feedly or your current reader, export your subscriptions as OPML (a `.xml` or `.opml` file). In FreshRSS, go to Settings → Subscriptions → Import/Export, select your OPML file and confirm. All your feeds appear immediately with their original folders and categories. The process takes under a minute regardless of the size of your subscription list.

FreshRSS serves HTTP on port 80 (exposed as 8080 on the host). For HTTPS, configure nginx as a reverse proxy in front of that port with a Let's Encrypt certificate — or enable `requireDomain: true` in the ServOrbit marketplace to have the VPS automatically configured with an nginx vhost and HTTPS. Once on HTTPS, mobile apps like Reeder or FeedMe can connect securely to `https://rss.your-domain.com` from any network.

Yes — since 2026, quantized 3B to 7B models (Q4_K_M format) run well on modern CPUs with AVX-512 support, reaching 8 to 12 tokens per second, which is sufficient for low-traffic API usage (fewer than 5 requests per minute). We recommend a VPS with 8 to 16 GB of RAM and models such as Phi-3-mini, Llama 3.2 3B, or Qwen2.5-7B deployed via Ollama. Find Ollama directly in our <a href="/marketplace">application Marketplace</a> for one-click installation.

MCP (Model Context Protocol) is an open-source protocol standardized by Anthropic and adopted by OpenAI, Google, and Microsoft, enabling AI agents to interact uniformly with external tools — databases, files, APIs — without sending your data to third-party cloud services. An MCP server can be deployed on a standard VPS (minimum 1 GB RAM, using Docker or Node.js) and exposes an HTTP API that clients such as Claude Desktop, Open WebUI, or n8n connect to. Browse our VPS plans on the <a href="/vps-cloud">ServOrbit VPS page</a> or reach us at [email protected] for guidance.

No. From your client area (VPS → Advanced → Reinstall OS) you pick a recent distribution from the published list, and the server is rebuilt while keeping its public IP address; new credentials are then emailed to you. The operation wipes the disk entirely: back up your data, volumes and configuration files before starting it, then redeploy your applications on the fresh system. It is protected by a strong confirmation (typing the exact server name); if you are unsure about the order of the steps, open a ticket before you begin.

Because the console is direct screen access to the server: it bypasses the network, SSH and the firewall — opening it is the equivalent of sitting down in front of the machine. So we protect it like our other sensitive operations (administrator password reset, reinstall, rescue mode, restore): your account password plus a 6-digit code sent by e-mail. Once confirmed, the console stays open for 15 minutes: you can reconnect as often as you need during troubleshooting without asking for another code. After that, a fresh confirmation is required.

It depends on your profile. Caddy is the ideal choice for beginners: a few lines of configuration, automatic Let's Encrypt certificates and no external dependencies. Traefik suits multi-container Docker environments: it discovers services via Docker labels and manages certificates natively, but requires a more complete configuration file. Nginx Proxy Manager offers a web graphical interface that appeals to non-technical users. If you manage fewer than five services and want to move quickly, choose Caddy. If you operate a cluster of dozens of containers with complex routing rules, prefer Traefik.

Yes. These open source PaaS platforms run on any Linux VPS with root access, which all ServOrbit plans include. The VPS Power plan (4 vCPU, 8 GB RAM) or higher is recommended, as these tools consume memory before your own applications do. The ServOrbit Marketplace also offers ready-to-deploy templates for several of these solutions.

Enable the X-Pack security module (built-in since Elasticsearch 8) and create a dedicated user with a password: without authentication, anyone on the network can read your indices. To avoid OOM errors, set the JVM heap to half the available RAM (e.g. `-Xms1g -Xmx1g` on a 2 GB VPS) and enable `bootstrap.memory_lock: true` to prevent swapping. A VPS starting at 299 DH/month with 8 GB of RAM covers a light development instance; plan for at least 4 GB in production.

Before any major Docker upgrade, take a snapshot of your VPS (available on the VPS Power and VPS Business plans) to have an immediate restore point. Read the release notes of the target version to identify removed options or network behaviour changes, then test the upgrade on a staging VPS running the same stack before applying it to production. Our article on migrating to Docker v29 lists the specific checks for that version.

From your VPS, commands like `top`, `htop` or `vmstat` give you an instant overview of RAM and CPU. For continuous monitoring with history and alerts, you can deploy a lightweight stack such as Netdata (one-line install) or a Prometheus + Grafana stack, available as templates from the ServOrbit Marketplace. These solutions let you receive automatic alerts on load spikes before any saturation occurs.

Yes, a VPS can host multiple services simultaneously, provided the allocated resources cover the combined workload. Mattermost alone consumes an average of 500 MB of RAM under light load. If you add other services such as a reverse proxy, a database, or a monitoring tool, plan for at least 2 GB of available RAM, ideally 4 GB for comfortable headroom. Isolating applications with Docker containers simplifies cohabitation and management. A reverse proxy such as Nginx or Caddy lets you route multiple domains or subdomains to the correct ports. You can scale your VPS up at any time from the ServOrbit client area.

Sizing depends on the number and nature of the tools you deploy. As a rough guide: Mattermost needs around 500 MB to 1 GB, Forgejo runs comfortably on 512 MB, Nextcloud requires at least 1 GB, and each PostgreSQL or MariaDB database adds 256 to 512 MB depending on load. For two to three tools running in parallel, a VPS with 4 GB of RAM is a solid starting point. If your team grows or you add third-party integrations, 8 GB provides a comfortable buffer. Also account for SSD storage for persistent volumes, logs, and backups. ServOrbit VPS plans start at 99 DH/month and can be scaled on demand.

Firefly III is a lightweight PHP/Laravel application that runs comfortably on modest VPS plans. **Minimum configuration**: 1 GB RAM, 1 vCPU, 10 GB SSD storage. This is sufficient for personal use or a small team (fewer than 5 users). **Recommended for professional use**: 2 GB RAM, 2 vCPU, 20 GB SSD. This gives you headroom for the Data Importer (secondary application for bank statement imports) and load spikes during large CSV file imports. **Recommended OS**: Ubuntu 22.04 LTS or Debian 12. **Required software**: Docker Engine ≥ 24 and Docker Compose V2 — Firefly III installs exclusively via Docker in the official documentation. Our VPS plans start from 99 DH/month. Snapshots are available from the VPS Power plan up, and daily backups on VPS Business — worth planning for to secure your financial data.

To host Ollama with a code model (Continue.dev, Tabby), the minimum configuration depends on the target model. For a 7B model in 4-bit quantization (e.g. Qwen2.5-Coder-7B-Q4, ~4 GB VRAM/RAM): a VPS with 8 GB RAM and 4 vCPUs is sufficient for CPU-only inference. For a 13B model: plan for 16 GB RAM. CPU inference is functional but slower than GPU — expect 5 to 15 tokens/second depending on the model and processor. Storage is critical: a 7B model takes 4 to 5 GB. Ollama is available as a VPS template on the ServOrbit Marketplace with the OpenAI-compatible API enabled by default.

Yes, both Actual Budget and Firefly III are available as VPS templates in the ServOrbit Marketplace: you can deploy either one in minutes on a root-access VPS. Migrating your data from Firefly III to Actual Budget is done manually using Firefly's CSV exports and Actual's native import; take a full backup before switching. Visit /marketplace to deploy the solution that fits your needs.

Authentik can act as a centralised identity provider using the forward authentication mechanism: your reverse proxy (Nginx, Traefik, Caddy) queries Authentik before forwarding each request to the target application, blocking any unauthenticated access. Each application is registered as a Provider in Authentik with its own domain; a single login then grants access to all protected services (SSO). Authentik is available as a VPS template in the ServOrbit Marketplace.

The `immich-machine-learning` container shares an internal Docker network with the other Immich services; start by verifying it is on the same network (`docker network inspect immich_default`) and that the service is running (`docker compose ps`). If the container keeps restarting, check its logs with `docker compose logs immich-machine-learning`: an OOM (Out Of Memory) kill shows up as `Killed` — in that case your VPS is short on RAM and you should either reduce the number of loaded models or upgrade to a larger plan. On a ServOrbit VPS, you can adjust your resources at any time from the client area.

Technically yes, but their resource requirements differ greatly: Plane needs at minimum 2 vCPU and 4 GB RAM (Django, Celery, PostgreSQL 16, Redis, RabbitMQ and MinIO), while Vikunja is much lighter (under 256 MB at idle). Hosting both on a single VPS is feasible from 6 to 8 GB of RAM, as long as you keep their databases and Docker networks separate. As your team grows, it is simpler to move each tool to its own VPS; that operation is non-destructive since all data lives in Docker volumes.

The most common cause is that the database container is 'running' (process started) but not yet 'healthy' (ready to accept connections): PostgreSQL or MySQL takes a few seconds to initialize. The fix is to use `depends_on` with a `service_healthy` condition in your `compose.yaml`, paired with a `healthcheck` on the database container (`pg_isready -U user` for PostgreSQL). Without a healthcheck, Docker considers the service ready as soon as the process starts, and your application tries to connect before the database is reachable.

Yes. The template installs PHP 8.3-FPM, Nginx, PostgreSQL 16, Redis, Supervisor and Composer on Ubuntu 24.04. It sets up the server environment, not your application: clone your repository, create your `.env.local`, run `composer install --no-dev --optimize-autoloader`, apply your migrations, and Nginx is ready to proxy to PHP-FPM. Any Symfony 5, 6 or 7 project runs on this base.

The template installs `php8.3-opcache` and enables OPcache by default in `php.ini`. To enable Symfony preloading, add to `/etc/php/8.3/fpm/php.ini`: `opcache.preload=/var/www/your-app/var/cache/prod/App_KernelProdContainer.preload.php` and `opcache.preload_user=www-data`, then reload PHP-FPM with `systemctl reload php8.3-fpm`. Symfony's service container is then loaded into memory at PHP-FPM startup, which noticeably reduces production latency.

No. The template targets the production environment: PHP 8.3-FPM, Nginx, PostgreSQL 16, Redis and Supervisor. Symfony CLI is a local development tool — it is not installed on the production server. For continuous deployments, use a Git pipeline (GitHub Actions, GitLab CI) that runs `composer install`, `cache:clear` and migrations on the server via SSH.

Supervisor is preconfigured on the template. Create `/etc/supervisor/conf.d/symfony-messenger.conf` with the directive `command=php /var/www/your-app/bin/console messenger:consume async --time-limit=3600` and `autorestart=true`. Reload Supervisor with `supervisorctl reread && supervisorctl update`. After each deployment, run `php bin/console messenger:stop-workers` to force workers to shut down gracefully: Supervisor will restart them immediately with the new code.

Both templates install the same PHP toolchain (PHP 8.3-FPM, Nginx, PostgreSQL, Redis, Supervisor, Composer) on Ubuntu 24.04. The difference lies in the PHP extensions: Symfony Stack adds `php8.3-intl` (required for the Translation component and locales) and `php8.3-opcache` explicitly (for preloading). Laravel Stack includes `php8.3-zip` and works without `intl` on most applications. Choose the template that matches your framework — both coexist without conflict on the same VPS.

Yes. The template installs Node.js LTS, PM2, and Nginx. For a static site (`output: 'static'`), build your Astro project locally, transfer the `dist/` folder to the VPS, and configure Nginx to serve it. No Node process is needed in production — Nginx serves static files directly with minimal memory usage.

Astro Stack installs Node.js LTS, PM2, and Nginx without PostgreSQL — suited for Astro projects in static (SSG) or SSR mode. Next.js Stack adds PostgreSQL for full-stack applications requiring a database. Astro is often lighter: its static mode requires no Node process in production, unlike Next.js which always runs SSR.

Yes. Install the `@astrojs/node` adapter, configure `output: 'server'` and `adapter: node({ mode: 'standalone' })` in `astro.config.mjs`. After building, launch the server with `pm2 start dist/server/entry.mjs --name astro` and proxy Nginx to `http://localhost:4321`. PM2 manages automatic restarts and zero-downtime updates.

Yes. Nginx supports multiple vhosts on the same server. Each static Astro site points to its own `dist/` folder; each SSR site uses a different PM2 port (e.g., 4321, 4322). A single Node.js and Nginx installation is sufficient for all sites. Plan enough RAM if you stack multiple Node processes in SSR mode.

1 GB of RAM is sufficient for a fully static Astro site: Nginx consumes very few resources serving files. For SSR mode with a Node process and PM2, plan for at least 2 GB. If you stack multiple SSR sites on the same VPS, add roughly 100 to 200 MB per additional Node process.

The reference solution is Patroni, an orchestrator that automatically promotes a replica to primary upon failure, using etcd or Consul as the distributed consensus store. You need at least three nodes: one primary, one replica and one quorum node (or a separate etcd cluster). Patroni is paired with HAProxy or pgBouncer on the application side to redirect connections to the new primary without code changes. A VPS with at least 2 GB RAM per node is recommended for a production PostgreSQL cluster.

Both templates install Node.js LTS, PM2, and Nginx. SvelteKit Stack is designed for reactive web applications with form actions, server-side `load` functions, and real-time features (WebSockets, SSE). Astro Stack targets content sites and hybrid rendering: Astro ships zero JavaScript by default and runs a lighter Node process for SSR pages. If you are building an app with forms, sessions, and server logic, choose SvelteKit; if you are building a blog or landing page, choose Astro.

Yes. Configure `@sveltejs/adapter-static` in `svelte.config.js`, build your project with `npm run build`, and transfer the `build/` folder to the VPS. Nginx will serve static files directly — no Node process runs in production, keeping memory usage to a minimum.

SvelteKit uses `ORIGIN` to validate form action requests and protect against CSRF attacks. If this variable does not match your site's actual URL, SvelteKit rejects form submissions with a 403 error. Set it via PM2 or the ecosystem config file: `ORIGIN=https://yourdomain.com pm2 start build/index.js`.

Yes. Launch each application as a separate PM2 process on a different internal port (3000, 3001, 3002…). Then configure Nginx with separate `server {}` blocks or `location` rules to route requests by domain name to the correct port. Each app keeps its own logs and environment variables in PM2.

PM2 monitors your Node process and restarts it automatically on crash or when the configured memory threshold is exceeded. For zero-downtime updates, use `pm2 reload svelte-app` — PM2 launches a new instance, waits for it to be ready, then shuts down the old one. To make PM2 persistent across server reboots, run `pm2 startup` to generate the systemd script, then `pm2 save` to persist the process list.

Jellyfin in Direct Play mode (reading the file as-is) works with 1 vCPU and 1 GB RAM. However, if your clients do not support the source format and software transcoding is needed, CPU becomes the limiting factor: each 1080p H.264 transcoded stream consumes between 1 and 2 vCPUs depending on the source codec. For 2 to 4 simultaneous users with transcoding, the VPS Power plan (4 vCPU, 8 GB RAM) is the recommended minimum; beyond that, prefer a VPS with more vCPUs or explore dedicated server options on the /serveurs-dedies page.

Yes — OpenTofu (open-source fork of Terraform, CNCF) lets you version your fleet configuration in HCL and apply it via tofu plan/apply. Our guide opentofu-terraform-vps-automatiser-infrastructure covers the Docker provider for managing containers directly on your VPS.

AnythingLLM alone (external LLM via API): 2 vCPU / 2 GB RAM is sufficient. With a local embedding model (nomic-embed-text via Ollama): 2 vCPU / 4 GB RAM minimum. With a local LLM (Mistral 7B in Q4 via Ollama): 4 vCPU / 8 GB RAM recommended — Q4 quantisation roughly halves the memory footprint.

A basic mail server for one or two domains with a few dozen users runs on 1 vCPU and 1 GB of RAM, but 2 GB is recommended as soon as you enable spam filtering (rspamd, SpamAssassin) or full-text search. Stalwart is a particularly lean Go binary: it starts up using under 50 MB of RAM at idle. Plan for at least 20 GB of SSD storage to start, adding more based on mailbox retention. The VPS Power plan (8 GB, 299 DH/month) suits most production configurations. Also remember to configure a reverse DNS (PTR) record and SPF/DKIM/DMARC entries to ensure deliverability.

Yes, by isolating each service in its own Docker container and assigning them separate ports or subdomains. Plan for at least 4 GB of RAM for both instances running simultaneously, and monitor the load via your client area metrics. Once you have made your choice, stop and remove the unused instance to free up resources. Check our Marketplace templates to deploy each solution in a few clicks.

Sizing depends on the application type and expected traffic: **Light application (< 100 req/min)**: 1 vCPU / 1 GB RAM. Sufficient for a Node.js or Flask REST API with a small database. **Medium application (100–1,000 req/min)**: 2 vCPU / 2–4 GB RAM. Recommended for an Express or FastAPI backend with PostgreSQL, including Redis for caching. **Heavy application (> 1,000 req/min or ML)**: 4+ vCPU / 8+ GB RAM. Processing workers (Celery, BullMQ), ML models, or report generation are very resource-intensive. **Rule of thumb**: start with 2 vCPU / 4 GB RAM and monitor. You can always scale up. Prefer more RAM over more CPU for most web applications — swapping kills performance more surely than a limited CPU.

The first minutes after creating a VPS are critical. Here are the priority steps: **1. Update the system** — `apt update && apt upgrade -y` **2. Create a non-root user with sudo** — `adduser myuser && usermod -aG sudo myuser` **3. Configure SSH key authentication** — from your local machine, `ssh-copy-id myuser@server-ip`, then in `/etc/ssh/sshd_config`: `PasswordAuthentication no` and `PermitRootLogin no`. **4. Configure the firewall** — `ufw default deny incoming`, then `ufw allow ssh`, `ufw allow 80`, `ufw allow 443` and finally `ufw enable`. **5. Enable fail2ban** — `apt install fail2ban` These five steps cover the essentials. Detailed guides are available in the ServOrbit knowledge base.

Kamal (formerly MRSK) orchestrates your deployments via SSH and Docker directly from your local machine to your ServOrbit VPS: simply configure `config/deploy.yml` with your server IP, Docker registry credentials and image. ServOrbit provides VPS with Docker ready to install (Debian/Ubuntu) and root SSH access; make sure to open ports 80/443 in your firewall and configure your DNS before the first deployment. Kamal natively handles rolling updates and rollbacks, making zero-downtime updates possible from the very first configuration.

Yes. GlitchTip is available in the ServOrbit marketplace as a compose recipe: PostgreSQL + Redis + an all-in-one GlitchTip container start with a single command. The `GLITCHTIP_EMBED_WORKER=true` option merges the Celery worker into the web container, eliminating a fourth service. A domain name is required (the FQDN is used for email links and OAuth tokens): you can use the free subdomain included with your VPS or attach your own domain. The first account is created from the interface at `https://<domain>/register`.

Yes, GlitchTip fully implements the Sentry event ingestion API and is compatible with all official SDKs: Python (sentry-sdk), JavaScript (@sentry/browser, @sentry/node), PHP, Ruby, Go, Java, .NET, iOS and Android. To migrate, simply replace the DSN URL in your environment variables with the URL of your GlitchTip instance; no source code changes are required. Your error groups, alerts and integrations continue to work as with Sentry Cloud.

GlitchTip requires at least 512 MB of RAM for the Python web container, PostgreSQL and Redis. A VPS with 1 GB of RAM is suitable for a single project with moderate traffic. For multiple projects or a high volume of error events, 2 GB of RAM are recommended. Disk depends on the volume of stored events: start with 10 GB and monitor PostgreSQL size. Database migrations run automatically when the web container starts, without manual intervention.

GlitchTip includes a built-in uptime monitoring module. In the interface, go to **Monitor → Create Monitor**, enter the URL to watch, the check type (HTTP/HTTPS or ping), the interval (minimum 1 minute) and the number of consecutive failures before alerting. You can configure notifications via email, Slack or webhook. GlitchTip records the incident history and displays uptime on a dedicated dashboard. Uptime monitoring runs from the GlitchTip server itself — it must have network access to the monitored URLs.

**Backup**: the only persistent data is the PostgreSQL volume (`glitchtip-db`). Schedule a daily `pg_dump` with `docker compose exec db pg_dump -U $DB_USER glitchtip > backup.sql` and copy the file off the server (rsync, Backblaze B2, etc.). **Update**: `docker compose pull && docker compose up -d`. GlitchTip applies Django migrations automatically on startup. No extended downtime is required — the container typically restarts in under 60 seconds. Check the release notes on gitlab.com/glitchtip before any major upgrade.

Plane CE runs several Docker services (app, worker, beat, migrator, PostgreSQL, Redis, MinIO, RabbitMQ) — plan for a minimum of 4 vCPU and 8 GB RAM for smooth operation. MinIO storage for attachments requires a separate volume sized to your needs. For fewer than 15 users, a 4 vCPU / 8 GB VPS with 40 GB SSD is a solid starting point.

No. Audiobookshelf works without a domain via SSH tunnel: `ssh -L 13378:127.0.0.1:<port> root@<vps-ip>` then `http://localhost:13378`. For permanent access from the iOS or Android app without a tunnel, attach a domain from your ServOrbit dashboard — nginx proxies to the container over HTTPS — or use the free `{app}.{dns_slug}.servorbit-dns.com` subdomain included with every VPS.

Yes. Both apps (iOS and Android) are free, fully open-source under GPL-3.0 and community-maintained. They support offline playback, chapter-accurate progress sync, and bookmark and playlist management — no third-party cloud account required.

Audiobookshelf supports: MP3, M4A, M4B (with chapter markers), AAC, OGG, FLAC, WAV, OPUS, AIFF and WMA. M4B chapters are displayed in the player with their titles and durations. Audible AAX files (DRM-protected) must be converted to a DRM-free format with a third-party tool before importing.

Yes. Audiobookshelf supports multiple user accounts on the same instance. Each account has its own listening progress, bookmarks, playlists and ratings. Permissions can be set per library (Books, Podcasts), giving fine-grained control over who can access what.

Audiobookshelf separates data into four Docker volumes: `/audiobooks` and `/podcasts` hold your audio files (never modified by the server), `/config` holds the SQLite database with progress and bookmarks, and `/metadata` holds covers and index data. Back up `/config` and `/metadata` via SFTP or `rsync`. The built-in Backup function (Settings → Backups) also exports a ZIP file with all metadata — handy for migrating to another instance or VPS.

All three are available as Marketplace templates on ServOrbit.com, but their use cases differ. Open WebUI is best if you want to run local models (Llama, Mistral) via Ollama without sending requests externally. LibreChat suits a team that needs a multi-model chat environment (OpenAI, Anthropic, local API) with user management and SSO. Dify targets building AI agents and workflows rather than general-purpose chat. Check the Marketplace page for each template's RAM requirements.

Wallos is a GPL-3.0 open-source self-hosted subscription manager. It lets you centralize all your recurring subscriptions — software, cloud services, licences, streaming — and visualize their real cost in a single reference currency. Wallos runs as a single Docker container on your VPS, with no external database needed.

No. Wallos works without a domain via SSH tunnel: `ssh -L 8080:127.0.0.1:<port> root@<vps-ip>` then `http://localhost:8080`. For access from any browser or device, attach a domain from your ServOrbit client area — nginx proxies the container over HTTPS — or use the free `{app}.{dns_slug}.servorbit-dns.com` subdomain included with every VPS.

Wallos shows a setup screen on first launch. Enter a username, email address and password to create your admin account — no pre-generated credentials. After that first login, invite other users from Settings → Users, and optionally connect an OIDC provider.

Wallos supports 170+ currencies including Moroccan dirham (MAD), Euro (EUR), US Dollar (USD) and Saudi Riyal (SAR). In Settings → Currency, choose your reference currency; Wallos automatically fetches exchange rates and converts each subscription so your totals always display in a single monetary unit.

All Wallos data lives in two Docker volumes: `wallos_db` (SQLite database with your subscription list) and `wallos_logos` (uploaded logos). Back them up via SFTP or `rsync`. Wallos also offers a CSV export from the interface (Settings → Import/Export) — useful for a human-readable backup or migration to another instance or host.

Expect a few minutes: the machine is cloned, started and configured automatically. As soon as you pay, the server appears in your client area marked as being set up — there is nothing for you to do, and no need to order it again. You receive an email with your credentials once it is ready. If it takes more than an hour, contact support with your order number.

Prometheus collects metrics from your applications and the OS via exporters (Node Exporter, cAdvisor), Loki centralises Docker logs, and Grafana visualises everything in dashboards. On a ServOrbit VPS, 8 GB is the recommended minimum to run all three tools in parallel with a reasonable data volume. Deploy the stack via Docker Compose with persistent volumes for Prometheus and Loki data, and protect Grafana with an HTTPS reverse proxy. The ServOrbit Marketplace offers pre-configured templates to get you started quickly.

The recommended approach is to combine Restic (encrypted, deduplicated backups) with a systemd timer rather than a cron job, because systemd logs each run and can send failure notifications. Create a `.service` file that exports the Restic environment variables (S3 endpoint, access keys, repository password) and runs `restic backup /var/www /var/lib/mysql-files`, then a `.timer` file that triggers it daily. Enable catch-up behaviour with `OnCalendar=daily` and `Persistent=true` (so a missed run is retried on next boot). Our support team can point you to a repository initialisation guide tailored to your VPS plan.

A standalone n8n instance runs comfortably on 1 GB of RAM, but in production with a PostgreSQL database and several active workflows, a minimum of 2 GB is recommended. If you combine n8n with other Docker services (Redis, a reverse proxy, a business app), plan for 4 GB to avoid slowdowns during execution spikes. ServOrbit VPS plans starting from 99 DH/month include NVMe SSD storage and are sized for this type of workload; upgrading to a higher plan is possible at any time from the client area.

Create a shared Docker network (`docker network create proxy`) and attach your containers to it. In Nginx, declare a `server` block per application with the `proxy_pass` directive pointing to the container name and its internal port (e.g., `http://app1:3000`). Use distinct domain names or subdomains to differentiate applications, and enable HTTPS with Certbot (`certbot --nginx -d myapp.example.com`). A simpler alternative is Nginx Proxy Manager, available in the ServOrbit marketplace, which provides a graphical interface to manage your reverse proxies without manually editing configuration files.

Yes, all three components coexist well on a single server via Docker Compose. Plan for at least 8 GB of RAM for lightweight models (7B) and enough storage for model weights (4 to 10 GB depending on the model). The VPS Power plan is a good starting point for this combination. See our guide on building an open-source AI stack on a VPS for configuration details.

For a WordPress Multisite network with fewer than ten sites at moderate traffic, we recommend a minimum of 2 vCPU and 4 GB RAM. Beyond twenty active sites or with an OPcache PHP opcode plugin, 4 vCPU and 8 GB RAM provide more comfort. Multisite mode concentrates several WordPress instances on a single MySQL installation: simultaneous traffic spikes across multiple sub-sites strain PHP-FPM more than a single instance. See our WordPress Multisite on VPS guide for the full setup with wildcard DNS and nginx.

In your Cloudflare DNS zone (or ServOrbit DNS manager), add a wildcard A record *.yourdomain.com pointing to your VPS IPv4 address. In nginx, configure a server_name *.yourdomain.com block and enable the ALLOW_MULTISITE option in wp-config.php. Each new sub-site created in WordPress resolves automatically without touching DNS again. If you use Cloudflare, enable the proxy on the wildcard record to benefit from caching and protection. See our WordPress Multisite on VPS guide for the full nginx configuration.

Both options are available on a ServOrbit VPS (Ubuntu/Debian with root access). A cron job is quicker to set up for a simple task: one line in crontab is enough. A systemd timer offers more control: native logging (journalctl), dependency management, automatic restart on failure and more precise triggers (at a time, on boot, after a delay). For backup scripts or production sync jobs, we recommend systemd timers: each execution is logged and errors are surfaced without extra configuration. Configuration is done directly via SSH on your VPS.