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 when ordering: Ubuntu (24.04 or 22.04 LTS) or Debian 12. You can reinstall the system whenever you wish.

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 backup storage; both are started on demand from your client area. 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.

There is no 2 GB ServOrbit VPS: our smallest plan, VPS Start, comes with 2 vCPUs and 4 GB of RAM, which is enough to run Kubernetes thanks to K3s, a lightweight CNCF-certified Kubernetes distribution that works with as little as 2 GB of RAM. K3s bundles all control-plane components into a single 60 MB binary and replaces etcd with SQLite, significantly reducing the memory footprint. It remains fully compatible with `kubectl` and Helm, so you can use the usual Kubernetes ecosystem without extra infrastructure cost.

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 application Marketplace 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 ServOrbit VPS page 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; a secure single-use link is then emailed to you so you can view the new password (if you supplied an SSH key when ordering, it is put back and no password is sent). 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 backup storage (backups started from the client area) 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 /applications 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 SMTP relay is not part of the reseller offer, which is shared cPanel/WHM hosting: it runs on a VPS you order separately. You configure Postfix on it as an authenticated relay and give each client an individual SMTP account, which keeps you in control of sender reputation, rate limits and the SPF/DKIM/DMARC records of your sending domain. Outbound port 25 is closed by default on our VPS: open a ticket to request it, granted after a review of your use case. For a quote, use the contact form and choose the “Quote” type.

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.

Yes, nothing prevents you from hosting a self-hosted team messaging solution for your clients on a ServOrbit VPS. Fluxer is not offered in the Marketplace: you install it yourself, using the VPS root access. If a solution from the catalogue suits you, Mattermost, Rocket.Chat and Matrix (Synapse) are available there as VPS templates. You order the VPS from your client area at the public price and re-bill it at the price you set. For a specific need, contact us at [email protected].

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.

Stalwart Mail Server supports multi-tenancy natively: you can create multiple domains within a single instance and assign accounts, quotas, and aliases per domain — each client only sees their own mailboxes. Deploy Stalwart on a ServOrbit VPS and manage your client domains via the REST API or the administration interface. This model is distinct from the reseller shared hosting offer (cPanel/WHM): you are fully responsible for administration, deliverability (SPF/DKIM/DMARC), and backups. For setup support, contact us via /contact (Quote type).

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.

ServOrbit offers VPS and dedicated servers with root access, on which you can install Woodpecker CI or Forgejo (a Gitea fork) yourself to provide a DevOps chain to your agency clients; neither is offered in the Marketplace, which does offer Gitea as a VPS template. One machine per client keeps their projects isolated. Root access comes with the VPS or dedicated server, not with the reseller offer, which is shared cPanel/WHM hosting. The VPS, running Ubuntu or Debian, is unmanaged: installing and maintaining these tools is up to you.

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. Once it is ready, you receive an email with a secure single-use link, valid for 24 hours, that shows your password a single time in your client area. 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.

Yes, on a ServOrbit VPS or dedicated server: Tabby (an open-source code completion assistant) is not offered in the Marketplace, so you install it yourself using root access, for example with the Docker image published by the project. Your developers and your clients' developers then connect to it from their editor. The cost is that of the machine, independent of the number of seats, unlike Copilot licences billed per user; size the machine for the code model you choose, following Tabby's documentation.

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.

Yes, a ServOrbit VPS can run multiple tools simultaneously: CRM, invoicing, project management platforms, and more. Feasibility depends on each application's resource requirements. We recommend starting with a VPS Power VPS and monitoring RAM/CPU usage from your client area. Our support team can advise on Docker or Nginx configuration to isolate each service and simplify maintenance.

An AI coding agent like OpenHands is a tool that automatically performs development tasks (writing code, testing, fixing bugs) from natural language instructions. It typically requires at least 8 GB of RAM to run comfortably, and more if you also run the language model locally. On ServOrbit, our VPS plans starting from VPS Power are suited for this type of workload. Check our dedicated blog post for the complete installation guide.

Odoo 17 Community requires at minimum 2 vCPU and 4 GB of RAM for development use or a handful of concurrent users. In production with 10 to 30 simultaneous users, 4 vCPU and 8 GB of RAM provide a solid baseline. Since PostgreSQL is typically hosted on the same server in standalone deployments, plan for at least 40 GB of SSD storage. Heavy third-party modules (accounting, manufacturing) noticeably increase memory consumption; monitor actual usage after the first few days and scale your VPS plan accordingly.

The `LocalExecutor` runs tasks in parallel within the same process as the scheduler, with no external dependency: it suits moderate DAG volumes and small teams. The `CeleryExecutor` distributes tasks across separate workers via a message queue (Redis or RabbitMQ); it is suited to intensive pipelines or fault-tolerance requirements. On a single VPS, `LocalExecutor` is sufficient in most cases and avoids the operational complexity of a broker. Switching to `CeleryExecutor` becomes justified when tasks saturate the server's CPUs or when workers need to be spread across multiple nodes.

Yes, a single VPS can host multiple services in parallel via Docker Compose, provided you choose a plan with enough RAM and storage — Jellyfin with transcoding and Immich with AI analysis are the most resource-intensive. An intermediate plan starting from 299 DH/month with 8 GB of RAM is a good starting point; add extra storage according to your media library. Find installation guides on our Marketplace.

Permission denied errors on Docker volumes occur when the UID of the container process does not match the owner of the mounted directory on the host. Before starting your stack, create the data directory and set the correct ownership with `chown <uid>:<gid>` on the VPS. You can also define `user:` in your `docker-compose.yml` to enforce the runtime identity. Our VPS documentation covers the most common cases; the support team is available at [email protected] for guidance.

Yes, you can deploy a mesh VPN (NetBird, WireGuard, Tailscale) directly on your ServOrbit root VPS to create a private network between multiple machines without exposing your services on a public IP. Each VPS comes with full root access, allowing you to freely install and configure the daemon of your choice. This approach is especially suited for agencies managing multiple clients from a single control plane. Check our VPS guides or write to [email protected] if you need help with routing.

Yes. These dashboards install like any Docker application on your ServOrbit VPS, using your root access. Homarr and Glance are available in the ServOrbit Marketplace as ready-to-use VPS templates: deploy in minutes and then access your dashboard from your domain. See the VPS Cloud page to choose the right plan for your needs.

Plane combines a Django backend, a task worker, a notification service, and a Next.js frontend. In production, the absolute minimum is 4 GB of RAM: below that, Docker containers compete for memory during load spikes and the task worker gets killed by the OOM killer. For a team of 5 to 20 active users, a VPS with 8 GB RAM (4 vCPUs) is recommended — that is the profile to aim for if you install Plane yourself on your VPS (Plane is not yet offered for order on the ServOrbit Marketplace). If you exceed 50 concurrent users or enable the real-time analytics module, move up to 16 GB. The PostgreSQL database and Redis broker are included in Plane's official Docker Compose deployment; plan for at least 20 GB of NVMe SSD storage for attachments and logs. The entry-level VPS Start plan (2 vCPUs, 4 GB of RAM) covers this minimum, but the right starting point for Plane is the 4 vCPU / 8 GB offer.

Yes, LibreChat is designed to be multi-provider. In your `librechat.yaml` file, you configure as many endpoints as you want: OpenAI, Anthropic, Mistral, a local model via Ollama, or any OpenAI-compatible API. Each endpoint is identified by a name, an API key, and a list of available models. Your users can then switch between models in the interface using the model selector, within the same session or across conversations. There is no limit to the number of configured endpoints — you can have GPT-4o, Claude 3.5 Sonnet, and Mistral Large available simultaneously. API key management stays in your `.env` file on the server side: your users have no access to it. On a ServOrbit VPS, the LibreChat template includes a commented example `librechat.yaml` with the most common endpoints. API calls are billed by each provider separately according to their own pricing.

LibreChat has several mechanisms to control API spending in a shared environment. First, enable per-user token limits in `librechat.yaml` via the `tokenCreditConfig` key: define a token quota per period (for example, 100,000 tokens per day per user). When the quota is reached, the user receives a message and cannot send requests until the next reset. Second, restrict available models: expose only cost-effective models (gpt-4o-mini rather than gpt-4o) or limit certain models to specific user roles via LibreChat's role system. Third, configure low default `maxTokens` for each endpoint to limit the length of generated responses. Fourth, on the OpenAI side, set monthly spending limits in your OpenAI dashboard — this is a safety net independent of LibreChat. On a ServOrbit VPS, the LibreChat template includes a `tokenCreditConfig` configuration example. For configuration assistance, contact [email protected].

RustFS is an S3-compatible object storage server, written in Rust and released under the Apache 2.0 licence. Unlike Garage (no built-in web console) or MinIO (advanced console under a separate commercial licence since 2021), RustFS includes a full web console in a single binary with no external dependency. It exposes a standard S3 API on port 9000 and its console on port 9001.

No. RustFS works without a domain: you access it through an SSH tunnel. For the web console (port 9001), create a tunnel `ssh -L 9001:127.0.0.1:<port> root@<ip>` then open `http://localhost:9001/rustfs/console/`. For the S3 API (port 9000), a second tunnel `ssh -L 9000:127.0.0.1:9000 root@<ip>` is enough to connect aws-cli, rclone or any S3 client. You can attach a domain later for public access.

After installation from the ServOrbit Marketplace, two credentials are generated and shown in your client area: `RUSTFS_ACCESS_KEY` (username) and `RUSTFS_SECRET_KEY` (password). The web console is accessible via an SSH tunnel on the port shown in your client area; log in at `http://localhost:9001/rustfs/console/` with these credentials. The S3 API is accessible on port 9000 via a second tunnel. All S3 clients (aws-cli, rclone, mc, AWS SDK) work with the endpoint `http://localhost:9000`.

RustFS requires **at least 2 GB of RAM** to run stably. CPU requirements are low (1 vCPU is enough for personal or small-team use). The main variable is storage: size your SSD volume according to the amount of data you want to store (allow 10–20% margin for metadata and backups). For intensive production use, 4 GB of RAM and 2 vCPUs are recommended.

Open an SSH tunnel to port 9000 of your VPS: `ssh -L 9000:127.0.0.1:9000 root@<ip>`. Then configure your S3 client with endpoint `http://localhost:9000` and your credentials. With **rclone**: in `rclone.conf`, add a `[rustfs]` backend of type `s3`, `provider = Other`, `endpoint = http://localhost:9000`, plus `access_key_id` and `secret_access_key` from your client area. With **aws-cli**: `aws --endpoint-url http://localhost:9000 s3 ls`. With **mc** (MinIO Client): `mc alias set rustfs http://localhost:9000 <ACCESS_KEY> <SECRET_KEY>`.

The licence governs what you can do with the code, not what you host on your VPS. AGPL-3.0 allows internal use and making the app available to your own clients, provided you publish your modifications if the application is exposed to third parties. The Sustainable Use License and Business Source License generally restrict reselling access to the application itself, but permit internal use. Read the text of the relevant licence; if in doubt, see our documentation page or consult a lawyer.

Yes, Ollama is available in the ServOrbit marketplace and installs with one click on VPS with sufficient RAM (minimum 8 GB for 7B models, 16 GB recommended for 13B models). Your data stays local without sending requests to external APIs. ServOrbit offers high-memory VPS suited for running Mistral, LLaMA or Gemma with full confidentiality, ideal for professional use or prototype testing.

Syncthing is offered in the ServOrbit marketplace for fast installation on your VPS. Once deployed, it acts as a central synchronization node: your workstations and servers connect via its secured web interface (accessible over HTTPS with the TLS certificate self-managed by ServOrbit). Synchronization is end-to-end encrypted without going through a third-party server. It is a sovereign alternative to Dropbox or OneDrive, hosted on your own ServOrbit infrastructure.

To run Open WebUI and Ollama together, plan for at least 8 GB of RAM — 4 GB for the model (e.g. Llama 3.1 8B with Q4 quantisation) and the rest for the OS and containers. With 16 GB you can load a 13B model and leave headroom for concurrent requests. Storage depends on the models you download: allow at least 20 to 40 GB of SSD depending on the range selected.

Pi-hole must only respond to clients on your private network. In the Pi-hole v6 configuration (Admin → Settings → DNS), select 'Listen only on interface' (your LAN or Docker interface) and disable listening on the VPS public IP. Add a firewall rule (ufw or iptables) blocking port 53 UDP/TCP from the outside: an open resolver can be exploited for DNS amplification attacks.

Pi-hole and AdGuard Home are both self-hosted DNS ad blockers, but AdGuard Home includes its own recursive DNS server with native DoH/DoT encryption out of the box. Pi-hole v6 uses FTL as its DNS engine and offers more detailed statistics; it benefits from a larger blocklist community. Both run on any ServOrbit VPS with a minimum of 512 MB of RAM.

Yes, Cap (an open-source Loom alternative) generates a sharing link for each recording; your external clients can access it without creating an account. Hosted on your VPS, all videos stay on your infrastructure and links remain active as long as your server is running. Plan for a VPS with at least 2 vCPUs, 2 GB of RAM and a storage volume sized to your recording volume.

From the Grafana interface, open each dashboard, click the share icon then 'Export → Save to file' to download a JSON file. To export all dashboards in bulk, use the Grafana API: `GET /api/dashboards/home` lists the UIDs, then `GET /api/dashboards/uid/{uid}` retrieves each definition. Also save your datasources (Settings → Data sources) and any alerts you have configured.

Coolify v4 does not limit the number of applications per server: the constraint is solely your VPS resources (CPU, RAM, disk). A 4 GB RAM VPS is enough for a few lightweight apps, while a 8 GB plan lets you run a dozen services in parallel. Each application is isolated in its own Docker container, making dependency and update management straightforward.

Yes, Coolify v4.3 introduces Preview Deployments: every push to a branch in your repository can trigger the deployment of an ephemeral environment accessible via a dedicated URL. This feature requires a webhook configured on the Git side (GitHub, Gitea, etc.) and a VPS with enough resources to host several containers in parallel. Previews are automatically deleted when the branch or pull request is closed.

AnythingLLM 1.17.0 in multi-user mode with a local vector database (LanceDB) and a lightweight embedding model needs at least 2 GB of dedicated RAM for the service itself. If you add a local LLM (Ollama), add 4 to 8 GB depending on the model. A 8 GB VPS is recommended for team use with active RAG; for lighter use (remote API such as OpenAI), a 4 GB plan is sufficient.

The choice of extension does not affect the technical operation of your VPS: .ma and .com are associated with an IP address in exactly the same way. The decision is a commercial one. If your activity primarily targets the Moroccan market, a .ma strengthens local credibility and improves visibility in Morocco-oriented searches. If your audience is international or you are deploying an application with no geographic anchor, .com remains the most widely recognized extension. Nothing prevents you from registering both and pointing each to your VPS, or redirecting one to the other. Check our extension catalogue on the Domains page to compare prices.

The recommended approach is to pull the new image (`docker compose pull`) then restart only the updated service (`docker compose up -d --no-deps <service>`) rather than recreating everything. For applications with a database, always take a backup before any update. If your stack uses a reverse proxy (nginx, Traefik, Caddy), the service can remain reachable while the application container restarts. For automated update notifications, tools like Watchtower or Diun can alert you to new versions; check our blog for detailed guides.

ClickHouse can run on 2 GB of RAM for modest volumes (a few hundred million rows), but the default configuration is tuned for more powerful machines. It is advisable to cap `max_server_memory_usage` at ~1.2 GB and disable heavy features (external dictionaries, many MergeTree parts). For high-throughput production logs, prefer a VPS with at least 8 GB of RAM — see our dedicated ClickHouse on VPS guide.

Yes, Invoice Ninja is well suited to billing your own clients: your logo, your prices and your payment terms, independently of what you pay ServOrbit. It is not offered in the Marketplace: you install it yourself on a VPS using root access, for example with the Docker image published by the project. Your client invoices thus remain entirely separate from your ServOrbit invoices, which simplifies bookkeeping and client relationships.

Metabase runs on the JVM and defaults to up to 2 GB of heap; for production use with multiple dashboards, a VPS with 4 GB of RAM is recommended, with 2 to 2.5 GB allocated to the heap via the environment variable `JAVA_OPTS=-Xmx2500m`. Below 2 GB of total heap, Metabase may encounter OutOfMemory errors on heavy queries. If you notice slowdowns, monitor memory usage with `docker stats` or `free -h` and adjust `Xmx` incrementally.

For local positioning in Morocco, a .ma domain strengthens trust among Moroccan visitors and can improve geo-localised rankings; however, it requires justification with the ANRT (Moroccan identity or commercial registration). A .com domain remains universal and easier to obtain, but will require Google Search Console geo-targeting configuration to compete locally. You can combine both: a .ma for the Moroccan market and a .com for international reach, both hosted on the same ServOrbit VPS.

To deploy Traefik v3 with automatic Let's Encrypt on a ServOrbit VPS, create a docker-compose.yml file exposing ports 80 and 443, with the /var/traefik/acme.json volume mounted at mode 600 to store certificates. In Traefik's static configuration, enable the ACME resolver with challengeType tlsChallenge or httpChallenge depending on your infrastructure, and provide a valid email address for Let's Encrypt. Make sure your domain points to the ServOrbit VPS IP and that the firewall allows inbound ports 80 and 443 before the first start. For renewals, Traefik v3 manages the certificate lifecycle autonomously without manual intervention; simply verify that the acme.json file persists between container restarts. The full Traefik v3 deployment guide on ServOrbit VPS is available in the knowledge base.

ntfy is a lightweight push notification server (Go) you can deploy in minutes on any ServOrbit VPS with Docker or a static binary. Once installed, you publish alerts via a simple HTTP POST and receive them on the ntfy mobile app (Android/iOS) or in a browser. Hosting your own instance ensures alert privacy and removes message limits. ntfy is available in the ServOrbit marketplace; contact [email protected] for configuration assistance.

Yes, HAProxy installs easily on any ServOrbit Linux VPS (apt/yum) and lets you distribute HTTP/TCP traffic across multiple backends with active health checks and automatic failover. For a high-availability architecture, you can pair two VPS in active/passive mode with Keepalived for a virtual IP. Refer to your distribution's documentation for SSL termination configuration, and contact [email protected] if you need guidance on your architecture.

Harbor is an enterprise-grade open-source OCI registry you can deploy on a ServOrbit VPS (recommended: 4 vCPU, 8 GB RAM, 50 GB storage) via Docker Compose. It provides per-project access control, image signing, replication to other registries, and built-in vulnerability scanning via Trivy. Once set up, your CI/CD pipelines push and pull images from your own domain over TLS. Harbor is available in the ServOrbit marketplace; contact [email protected] for sizing questions.

Yes, Windmill is an open-source orchestration platform (workflows, Python/TypeScript/Go scripts, forms) you can self-host on a ServOrbit VPS via Docker Compose. It replaces tools like Airflow or Prefect for business and developer use cases, with a visual workflow editor and native secret management. A VPS with 2 vCPU and 4 GB RAM is enough to get started. Windmill is available in the ServOrbit marketplace; contact [email protected] for guidance.

Uptime Kuma v2 installs in minutes on your VPS via Docker Compose and provides a real-time monitoring dashboard for your services, ports and HTTP endpoints. Create a 'Docker Container' monitor for each service or an 'HTTP(s)' monitor for your exposed endpoints, then set up e-mail or webhook alerts. Your ServOrbit VPS comes with root access and a dedicated IPv4, so you can restrict the Uptime Kuma interface port to trusted addresses only. Find the Uptime Kuma template in our Marketplace for a quick start.

Yes. Kavita is an open-source reading server (GPL-3.0) that runs in a single Docker container and requires no domain name. Access it via SSH tunnel (`ssh -L 5000:127.0.0.1:<port> root@<ip>` then `http://localhost:5000`) or via any free subdomain included with every ServOrbit VPS. It reads EPUB, CBZ, CBR, PDF and many other formats directly in the browser.

Kavita supports: EPUB and EPUB3 (with automatic chapters, covers and metadata), CBZ, CBR, CB7 and CBT (comic/manga page archives), PDF, and raw image archives (ZIP, RAR). EPUB files are indexed with their metadata on the first scan. Comics and manga in CBZ/CBR are automatically grouped into series based on your folder structure.

Calibre-Web is built on an existing Calibre database and specialises in library management, format conversion (EPUB to MOBI) and e-book delivery by email to Kindle devices. Kavita is lighter (single container, under 256 MB RAM), requires no Calibre database, and handles comics and manga (CBZ, CBR) natively — which Calibre-Web does not support. If your library contains manga or comics alongside e-books, Kavita is the better choice.

Local shell history (the `.bash_history` or `.zsh_history` file) is stored only on the current machine, without encryption or precise timestamps, and is lost when you change servers. Atuin replaces that file with an enriched local SQLite database (execution time, working directory, exit code) and syncs this end-to-end encrypted journal to your own self-hosted Atuin server — your commands stay private and searchable from any workstation or server connected to the same account.

Yes. Self-hosted Infisical on a ServOrbit VPS gives you a secrets vault entirely under your control: API keys, database passwords, certificates and tokens are stored encrypted on your own infrastructure, with full audit logs. Your applications retrieve secrets at startup via the official SDKs (Node.js, Python, Go…) or by injecting them into Docker environment variables — without any plaintext `.env` file left on the server. A VPS Power (4 vCPU, 8 GB) comfortably covers the Infisical stack and several projects in parallel.

Yes, provided you expose Gotenberg on a public port or behind an authenticated reverse proxy. By default, Gotenberg listens on port 3000 of the container, accessible only locally; for external access, configure a subdomain with TLS and protect the endpoint with an API key or IP restriction (Gotenberg supports the `Gotenberg-Api-Token` header). For internal use only, keep the port closed and call Gotenberg from the internal Docker network — the most secure configuration for a PDF generation API.

Yes. Postal natively supports multiple domains and organisations: you create one organisation per client, each with its own sender domains, sending servers and isolated statistics. Postal is not offered in the Marketplace: order a VPS dedicated to this use, install Postal on it yourself using root access, configure the DNS records (SPF, DKIM, bounce MX) for each client domain, then open a ticket to request outbound port 25: it is closed by default and only opened after a review of your use case. Each client accesses their own Postal dashboard without seeing the others' sends.

For your security, the root password is never sent in plain text by email. When your VPS is delivered, and after a reinstallation, you receive an email containing a secure single-use link, valid for 24 hours. The link opens only once, in your client area, while signed in to the account that ordered the server: the password is displayed a single time, with a button to copy it, and is then erased from our servers — save it straight away in your password manager. On a Linux VPS, the system then asks you to choose a new password the first time you log in over SSH.

Open it anyway: the page offers a “Generate a new access” button. Once you confirm with your account password and a code received by email, the server's password is reset — the server restarts, so expect one to two minutes of downtime — and a new single-use link, valid for 24 hours, is emailed to you. The old password and any earlier links then stop working: we cannot resend a password that has already been displayed, because it has been erased. If you no longer have the email, the “Password” tile on the server page (Reset root access) generates a new password, shown only once.

Yes, and it is recommended: in the cart, tick “Add my public SSH key” and paste the contents of your .pub file (accepted formats: Ed25519, RSA of 2048 bits or more, ECDSA and FIDO hardware keys). No password is then sent to you: the root password is locked, SSH password login is disabled and only your key is accepted; it is put back automatically if the server is reinstalled. Never paste your private key. If you lose your key, “Reset root access” in your client area gives you a password you can use from the server console, while SSH stays key-only. This option does not apply to Windows servers.

Open the one-time link received by email on delivery, click “Show the password”, then copy the login command into your terminal; the system will then ask you for a new password. The link is valid for 24 hours and works only once. Step by step: Log in to your VPS over SSH for the first time.

On the server page, open the “Password” tile, confirm with your password and the code received by email, then click “Reset”. The server restarts for one to two minutes and the new password is displayed only once. Step by step: Reset a VPS root password.

Yes, MySQL 8.4 LTS is available on all ServOrbit VPS instances running Ubuntu 22.04/24.04 and Debian 12 via the official MySQL repository. MySQL 8.0 reaches end-of-life in April 2026: we recommend migrating by first taking a full dump (`mysqldump --all-databases`), then installing MySQL 8.4 and re-importing your data after checking SQL query compatibility (using `EXPLAIN`). Refer to our migration documentation or open a ticket at [email protected] with any question.

A ServOrbit VPS is hosted in a European datacenter: there is no server in Morocco, and the datacenter cannot be chosen when ordering. For an Arabic website, serve your pages in UTF-8 (MySQL database in utf8mb4, character set declared by Apache or Nginx) and install a free Let's Encrypt certificate. To speed up loading from Morocco, put your domain behind a CDN such as Cloudflare, which serves static files from points of presence close to your visitors, and slim down images and fonts.

No. PhotoPrism works without a domain: you can access it via an SSH tunnel (ssh -L 2342:127.0.0.1:PORT root@vps-ip, then http://localhost:2342 in your browser). A free ServOrbit subdomain is also included with every VPS plan.

PhotoPrism is designed to index and organise a large existing photo library on disk (read-only mode, rsync, WebDAV). Immich targets daily backup from iOS/Android. If you want to sort a large archive without modifying the originals, PhotoPrism is the better fit.

Plan for at least 2 GB of RAM: PhotoPrism + MariaDB use around 500 MB at rest, but TensorFlow indexing can spike to 2 GB. For a library of tens of thousands of photos or intensive use, 4 GB is recommended.

Yes. Mount the originals folder read-only (:ro in the Docker volume) and set PHOTOPRISM_READONLY=true. PhotoPrism stores thumbnails, AI labels and the search index in a separate storage volume — your source files are never modified.

Three things to back up: (1) the originals folder — your source photo files; (2) the storage volume — AI labels, thumbnails and search index; (3) the MariaDB data volume. Volumes 2 and 3 can be rebuilt by re-indexing; volume 1 is irreplaceable.

Penpot requires at least 4 GB RAM and 2 vCPU with Docker Compose. The setup includes three main services: frontend (Nginx), backend (Clojure/JVM), and exporter (headless Chromium for PDF/PNG exports). Below 4 GB, the Chromium exporter becomes unstable. For a team of 5 to 10 active users, 8 GB RAM and 4 vCPU are recommended. Storage depends on files: plan for at least 10 GB for assets and exports.

Atlassian announced Opsgenie's end of life on April 5, 2027. For migration to self-hosted, OneUptime is the most complete alternative: alert management, on-call scheduling, public status page, and native integration with Prometheus and Grafana via webhook. OneUptime deploys with Docker Compose on a VPS with a minimum of 2 vCPU / 4 GB RAM. IncidentRelay is a lighter alternative for small teams.

No. Extended support for SQL Server 2016 ended on July 14, 2026. This means no more security fixes or cumulative patches are released. Instances exposed to the internet or processing personal data become non-compliant. Migrating to SQL Server 2019/2022 or an open source database (PostgreSQL, MariaDB) is the only path to remain covered.

Two main tools: pgloader (open source, command-line migration, automatically handles many SQL Server type conversions) and AWS Schema Conversion Tool / SCT (free, GUI, analyzes T-SQL incompatibilities and stored procedures). Recommended approach: export the schema with SCT, manually identify incompatibilities, use pgloader for data transfer, then validate with a row comparison tool (e.g. pg_comparator).

If you use Vaultwarden (self-hosted Bitwarden-compatible server), updating official Bitwarden clients to version 2026.8.0 or later may cause the vault to appear empty or decryption to fail. These clients adopted a new EncString format not yet implemented in Vaultwarden (as of October 18, 2026). Temporary fix: downgrade clients to version 2026.7.x while waiting for a Vaultwarden update. Track issue #7612 on the Vaultwarden GitHub repository for implementation status.

Yes. Open-source tools such as Rybbit, Umami or Plausible can be installed in minutes via the ServOrbit Marketplace and operate without cookies — which removes the cookie consent banner requirement under the GDPR. Data stays exclusively on your VPS, in Europe, and never passes through third-party servers. For compliance questions specific to your situation, a legal adviser is the right contact.

Yes. Open-source alternatives such as Hoppscotch or Bruno can be self-hosted on a VPS and provide a shared workspace to test and document APIs as a team, with no third-party cloud account and no credential synchronisation to external servers. Installation is done via Docker Compose and collections remain stored on your own server. For deployment details, check the relevant app pages in the ServOrbit Marketplace.

Yes. PostgreSQL natively supports streaming replication: a primary node streams its WAL to one or more read-only replicas with millisecond-level lag on a local network. For automatic failover, tools such as Patroni or Repmgr orchestrate replica promotion when the primary fails. You can order two ServOrbit VPS servers in the same datacenter to minimise network latency between nodes.

In a container, the PHP interpreter is part of the image, not of the application: updating WordPress or Laravel, or restarting the container, reuses the image already on the disk. To apply a PHP fix, pull or rebuild the image (for example with the --pull option of the build), recreate the container, then check the version actually served. Do this for every container that ships PHP, workers included.

A VPS will not warn you by itself: set an alert at about 80% disk usage, also watch inodes and processes killed for lack of memory, and send it to a channel you actually read. A scheduled script or a monitoring tool such as those in the Marketplace is enough, and you can add disk space or RAM from your customer area. This monitoring remains your responsibility: ServOrbit provides the guides, not the monitoring of your applications.

No. ServOrbit VPS servers run in Finland and Germany; ServOrbit has no server and no office in the United Arab Emirates. If a contract or a regulation requires you to keep your data inside the UAE, this VPS does not meet that requirement. For your users in the Gulf, traffic travels over the Europe–Gulf link.

Yes. Every ServOrbit VPS comes with full root access, a dedicated IPv4 address and SSD storage, with the Linux distribution of your choice. Docker, Node.js, Python and databases install freely: nothing is locked. The Marketplace also deploys open-source applications such as n8n or self-hosted AI tools in one click, which you then administer yourself.

Prices are shown in AED by default, but a card is not charged in AED: it goes through the CMI gateway, which charges in MAD. With PayPal, the charge is in the currency PayPal displays before you confirm. Whatever the method, you read the exact amount and its currency on the payment screen before confirming. The invoice is issued in MAD.

Web hosting is shared and managed from cPanel: it suits a company website, a WordPress blog or business email addresses. A VPS gives you root access, a dedicated IPv4 and your choice of Linux distribution: it suits Docker, n8n, an API or a custom application. Both live in the same client area, on the same invoice.

No. ServOrbit VPS run on servers in Finland and Germany, and ServOrbit has no server and no office in France. The offer is aimed at businesses and developers based in France who accept a machine elsewhere in Europe. If a contract or a client requires the server to be physically in France, this VPS does not meet that requirement.

Anything a Linux server runs. Every VPS includes full root access, a dedicated IPv4 address and an SSD disk, with the Linux distribution of your choice. You install Docker, Node.js, Python or a database without restriction. The Marketplace also deploys open-source applications in one click, such as n8n or self-hosted AI tools.

Not necessarily. From France, VPS prices show in EUR by default, with USD as an option, but what leaves your account depends on the payment method: a bank card goes through the CMI gateway and is charged in MAD; PayPal charges in the currency it shows you. The exact amount appears before you confirm. The invoice is issued in MAD.

Yes. ServOrbit support answers in French, as well as in English and Arabic, so you can describe an incident on your VPS in your own language. ServOrbit is published by MEGALOGI, a Moroccan company: your contact and your billing are not French, but your VPS, domains and hosting stay together in a single client area.

In a data centre in Finland or Germany. ServOrbit has no server and no office in Togo: from Lomé, you administer a machine located in Europe. If a client, a contract or a specification requires data to stay on Togolese territory, this VPS does not meet that requirement; it is better to check before ordering.

Yes. Every VPS comes with full root access, a dedicated IPv4 address and SSD storage. You choose the Linux distribution, install your packages and configure the server as you see fit: nothing is locked, and you do not need to go through support to administer the machine day to day.

Both. With root access, you install Docker, Node.js, Python or whatever database your project needs yourself. If you would rather start from a ready-made application, the Marketplace deploys open-source applications to your VPS in one click. Either way, the server stays yours: you then administer it like any other Linux machine.

In French, English or Arabic: support answers in all three. Your VPS is managed from the ServOrbit client area, the same one as your domain names and web hosting, and everything arrives on a single invoice. If your project also needs a .tg, you register it from that account, with no local presence in Togo.

On a server in Finland or Germany. ServOrbit has no server and no office in Côte d'Ivoire: it is a market served remotely. Traffic between your Ivorian users and the VPS therefore goes through Europe. If a contract or a regulation requires your data to stay within Côte d'Ivoire, this VPS does not meet that requirement.

Yes. Every VPS comes with full root access, a dedicated IPv4 address and SSD storage, on the Linux distribution of your choice. You install Docker, Node.js, Python or a database yourself, and open the ports your application needs. Nothing is locked, and administering the server is in your hands.

Yes. The Marketplace installs ready-to-use open-source applications on your VPS in one click. It is a starting point, not a constraint: once the application is deployed, the server is still yours, with full root access, and you can add whatever you need. If an application is not listed, you install it yourself.

French, English or Arabic. You write to the team in the language you work in, whether the question is about configuration or billing. Your VPS sits in the same client area as your domain names and any web hosting plans, and everything arrives on the same invoice.

In Finland or Germany. ServOrbit has no server and no office in Senegal: the country is a market served remotely. Your VPS is therefore a European machine that you manage over SSH from Dakar or anywhere else. If a contract or a client requires data to stay on Senegalese soil, this VPS does not meet that condition.

Whatever a Linux server can run. You get full root access, a dedicated IPv4 address, an SSD disk and the Linux distribution of your choice. You install Docker, Node.js, Python or a database, with nothing locked. The Marketplace also deploys open-source applications in one click, which you then manage yourself.

Because the CFA franc (XOF) is not offered today. From Senegal, the VPS is shown in euros by default, with US dollars as an option. That is only a display: the currency charged depends on the payment method, and the summary shows it to you, with the amount, before you confirm. The invoice is in MAD.

Three payment methods are offered: international bank card, PayPal or bank transfer. They are the only ones; check that one of them is available to you before planning a go-live. Support answers in French, English and Arabic. The VPS sits in the same client area and on the same invoice as your domains and hosting plans.

Installing a kernel update is not enough: the server keeps using the old one until it has rebooted. Compare the version shown by `uname -r` with that of the most recent kernel package (`dpkg -l 'linux-image*'` on Debian and Ubuntu, `rpm -q kernel` on AlmaLinux and Rocky). If they differ, or if the file `/var/run/reboot-required` exists, schedule a reboot; `needrestart -k` performs this check for you.

The command line and the website do not necessarily use the same PHP. `php -v` shows the command-line version, while the site is served by PHP-FPM, which keeps the old code in memory until it is restarted. Restart the service (for example `systemctl restart php8.3-fpm`), then print `PHP_VERSION` from a temporary page that you delete right afterwards.

A media folder should only hold images and documents, never a script. Connect to your VPS over SSH and run `find wp-content/uploads -type f -name "*.php"` (adapt the path to your CMS): every result needs a look before you delete it. `find wp-content/uploads -type f -mtime -7` also lists the files dropped over the last seven days. Keep a copy of what you find for analysis and, if in doubt, open a ticket from your client area.

A media folder has no reason to run PHP: refusing it in your web server configuration (nginx or Apache) limits the damage if a booby-trapped file lands there. This is general hardening, and it does not replace updates to your CMS and its extensions. On an unmanaged VPS this configuration is yours to maintain; test it with a harmless test file and check that it is no longer executed.