Sites
WordPress, PHP apps, or static sites on your own server, with automatic HTTPS, file access over SFTP, and daily backups. Sites from cPanel can be moved over together with their databases, and a site can be moved to another server with only a short pause.
Who it is for
Sites (Situs in the app) is built for app owners who used cPanel only to run their own site or app, not for hosting companies that sell accounts to many customers. It focuses on the functions people actually use: installing a site, domains and HTTPS, uploading files, databases, and backups.
Sites connect with the rest of Saka: the database can live on the same server or in a multi-location database cluster, and a site can sit behind a load balancer.
Site types
| Type | What you get | Database |
|---|---|---|
| WordPress | Installed automatically and ready to use (Indonesian or English). The admin password is randomly generated and shown in the panel. | Yes |
| PHP | Apache with PHP 8.2, 8.3, or 8.4, and .htaccess works. For Laravel, CodeIgniter, or other PHP apps; upload files over SFTP. | Yes |
| Statis (HTML) (Static) | HTML/CSS/JS pages served directly by the web server. The lightest option. | No |
| Pindahkan dari cPanel (Move from cPanel) | Sign in to the old cPanel (like the WHM Transfer Tool), or use a cPanel backup file or a site archive. Files and database are moved, and WordPress is adjusted automatically. See Moving from cPanel. | Yes |
Creating a site
Server requirements: connected to Saka, ports 80 and 443 free (not used by another nginx or apache), and at least 1 GB of RAM.
- Open the Situs (Sites) menu in the panel, then press + Buat situs (Create site).
- Jenis (Type). Choose WordPress, PHP, Statis (HTML), or Pindahkan dari cPanel.
- Server. Pick the target server from the list of connected servers.
- Domain. Enter the domain, for example
tokokue.idorblog.tokokue.id. For a root domain, tick Sertakan juga www (Also include www) if you want it. A domain can only be used by one site in your account. - PHP & database (not for static sites). Choose the PHP version (8.3 recommended), the WordPress language, and where the database lives: Database di server ini (Database on this server) or Klaster database (Database cluster).
- Nama situs (Site name), for example "Toko Kue Ibu". For WordPress, this is also used as the site title (you can change it in WordPress).
- Press Buat situs (Create site), or Pindahkan situs (Move site) when moving from cPanel.
A site is usually ready in 2-5 minutes. The first site on a server takes a little longer because PHP is prepared first; a cPanel move depends on the size of the backup. You are also notified on Telegram. If it fails, the detail page shows why; delete that site and try again.
Domains, DNS, and HTTPS
No domain yet? When creating a site, press Use a free test address. Saka fills in <name>.<server-ip>.sslip.io, which works right away with HTTPS and no DNS setup. Switch to your own domain any time.
After the site is created, point the domain to the server in your domain's DNS manager (where you bought the domain, or Cloudflare). The Domain & HTTPS card on the detail page shows the records you need:
tokokue.id. A 203.0.113.10
www.tokokue.id. A 203.0.113.10
; optional, if the server has IPv6:
tokokue.id. AAAA 2001:db8::10- An A record to the server's IPv4 address is required. An AAAA record to the server's IPv6 address is optional, for IPv6 visitors.
- The DNS column for each domain shows mengarah (pointing), ke IP lain (to another IP), or belum ada (not set yet). The HTTPS column shows aktif (active) or menunggu DNS (waiting for DNS).
- HTTPS turns on by itself within a few minutes after DNS points to the server. Let's Encrypt certificates are issued per domain and renewed automatically.
- Domains can be changed or added with Ubah / tambah domain (Change / add domain), one per line; the first one becomes the main address. For WordPress, when the main address changes, the addresses inside WordPress are replaced automatically.
Turn off the orange cloud first (choose "DNS only", grey cloud) until HTTPS is active in Saka.
Files over SFTP
Every site has its own SFTP account. Open the Akses (Access) card on the detail page and press Tampilkan sandi (Show password) to see the host, port, username, and password.
- Use FileZilla, WinSCP, or Cyberduck with the SFTP protocol.
- The site folder is
/www. Files uploaded there are served right away. - The account is jailed: it can only see that site's folder, cannot open a shell, and cannot see other files on the server.
- PHP apps run as the site's own user, so files created by WordPress or your app can still be edited over SFTP.
File manager
The File manager card on the site page replaces cPanel's File Manager, no SFTP app needed:
- Browse the site folder, edit text files (PHP, HTML, CSS,
.htaccess, up to 2 MB; Ctrl+S saves), create folders or files, and rename. - Upload files up to 100 MB each; upload a theme or plugin as a zip and press Extract. Download one file, or a whole folder as a zip. Files stream straight from your server and are not stored by Saka.
- Delete moves to a trash kept for 7 days, so it can be restored. Every time a file is edited or replaced by an upload, the previous version is kept there too, so a bad edit to
wp-config.phpcan be undone. - The file manager can only open that site's folder. Paths and symlinks that point outside it are refused.
- For apps from Git, the file manager opens the persistent data folder (
/data), for example to download the SQLite database.
AI agents use berkas_daftar, berkas_baca, and berkas_ubah (with your approval).
Database
| Option | What it is | When to use it |
|---|---|---|
| Database di server ini (Database on this server, recommended) | MariaDB 11.8 on the same server, one database and user per site, reachable only from that server. | Regular sites on one server. |
| Klaster database (Database cluster) | Saka creates a database and user for this site in your MariaDB cluster, and installs the Saka proxy on the site's server. Connections use TLS; if one database server goes down, the proxy moves to a healthy node. | Sites that must keep running even if one database server goes down. |
You can pick a MariaDB cluster that is ready and runs on other servers (the site's server must not be a member of that cluster). For WordPress, the TLS connection to the cluster is set up automatically. The database connection details (host, name, user, password) are in the Akses (Access) card. To view and edit the database contents, use phpMyAdmin.
phpMyAdmin
WordPress and PHP sites have their own phpMyAdmin. On the Access card, press Open phpMyAdmin; it opens in a new tab and signs you in.
- No open port. phpMyAdmin opens through the Saka dashboard tunnel (the same way as the OpenClaw dashboard): the agent connects outward, and no port is opened on your server.
- Signed in automatically as that site's database user, and it only sees that site's database. You do not need to type the database password.
- Stops by itself after 3 hours. Press the button again if you still need it.
- The first time on a server can take about 30 seconds because the phpMyAdmin image is downloaded first.
- Works for a database on this server and for a database cluster (TLS connection). Static sites have no database, so they have no phpMyAdmin.
Via the API: POST /api/v1/situs/{id}/phpmyadmin returns {"url"}, a single-use sign-in link valid for 60 seconds. phpMyAdmin is not available through MCP.
Backups and restore
- Daily, automatic. Files and database are backed up every day into one
.tar.gzfile on your server. The last 7 daily backups are kept. The first daily backup is made within 24 hours. - Manual. Press Cadangkan sekarang (Back up now) on the Cadangan (Backups) card at any time (the last 5 are kept).
- Download. Press Unduh (Download) on a backup to save the
.tar.gzarchive (site files + database) to your computer. The file streams straight from your server and is not stored on Saka. Backups that exist only in S3 are first fetched to the server with Fetch to server. - Restore. Press Pulihkan (Restore) on the backup you want. The site's files and database are replaced with the contents of that backup. Before that, the current state is always backed up first (type "sebelum pemulihan", before restore), so a restore can still be undone by restoring that backup.
Daily backups are stored on the same server as the site. To stay safe even if the server is lost completely, turn on backups to S3.
Backup restore test
A backup is only useful if it really restores. Once a month, at night (01:00 to 06:00 in the server time zone; UTC servers use WIB, UTC+7), Saka opens each site's latest backup in a temporary folder, imports its database into a temporary MariaDB, then runs the WordPress or PHP site in a temporary container and loads it once. The result shows on the site's Backups card (restorable or failed with the reason: broken archive, database that will not import, or a site that answers with an error) and in the monthly report. You are alerted when it fails. Press Test restore now to test at any time.
- The live site is not touched. The test container has no internet access (it cannot send email, call webhooks, or run outgoing cron) and cannot be reached from outside. The temporary folder and containers are removed after the test; the backup archive is not changed.
- Light. One site at a time, with CPU and memory limits. When there is not enough free disk to open the archive, the test is skipped (the backup itself stays); the same when less than about 1 GB of RAM is free.
- Static sites have their pages checked; ready-made apps, Compose apps, and Git app data have their archive checked without being run.
Through your AI agent: situs_uji_pulih, with the result in situs_status (uji_pulih).
Backups to your own S3
Site backups can also be sent automatically to your own S3 storage: Amazon S3, Cloudflare R2, DigitalOcean Spaces, Wasabi, Backblaze B2, or any S3-compatible service. If the server breaks or is deleted, sites are restored to a new server from there.
- Create a bucket just for backups (not public) and an access key that can read, write, and delete in that bucket.
- Open the server page, Backups to S3 card, press Set up S3. Pick the provider, fill in the region, bucket name, access key, and secret key, then Test & save. Saka tests writing, reading, and deleting before saving.
- Save the recovery code that appears (it starts with
SAKA-S3-) in a password manager. It holds the S3 destination and the key that opens the backups.
- Encrypted on the server before upload (age), so the S3 provider can't read them. The S3 keys and the encryption key are stored only on your server, never on Saka. Saka can't open your backups, so without the recovery code the backups can't be opened.
- Every backup (daily, manual, before an update) is sent in the background Backups already sent are marked in S3.
- You set how long they are kept so the bucket does not pile up: on the Backup to S3 card press Change on the Kept for row, pick 7, 14, 30, 60, 90, 180, 365 days or enter your own (1 to 3650), without re-entering the S3 keys. The default is 30 days. Older backups are removed from the bucket automatically, and the newest backup of each site is always kept even past the limit. Shortening asks for confirmation first because old archives are deleted right away. The same card shows what is in the bucket: the number of archives and their size.
- If sending keeps failing for more than 6 hours (key revoked, bucket full), you get a Telegram message. You are also alerted when a site's daily backup has not succeeded for more than 26 hours. Backup health (sites backed up, last S3 upload, retention) is part of the monthly report. Backups stay on the server and are sent once the problem is fixed.
- Ready-made apps are included with their database and variables. Git apps are not backed up (their code is in the repo).
Restore from S3
- Same site: on the site's Backups card, open Backups in S3 and press Restore. Useful when the local backup is gone.
- To a new server (the old one is gone): add the new server to Saka, choose Recovery code on its Backups to S3 card and paste the code. Then Create site, choose Restore from S3, pick the site and backup, and enter the domain. The site is set up as it was when backed up; WordPress addresses are adjusted if the domain changed. Finally point the domain to the new server's IP.
Through your AI agent: cadangan_s3_status, cadangan_s3_daftar, cadangan_s3_masa_simpan (change retention), and situs_buat with dari_s3. The S3 destination and recovery code are set only from the panel on purpose, so keys never pass through an AI agent.
Moving from cPanel
Choose the Pindahkan dari cPanel (Move from cPanel) type when creating a site. There are two ways to move.
Option 1: Sign in to the old cPanel (recommended)
Like the WHM Transfer Tool, but with just the cPanel account login. Saka creates a full backup on the old cPanel, waits for it to finish, downloads it to the new server, deletes that backup file from the old cPanel, and then sets it up.
- Old cPanel address: the domain or IP of the old server, for example
oldshop.com. Port 2083 is used automatically (you can add your own:port). - cPanel username and cPanel password (the cPanel account password, not the WHM or root password).
- If the account uses two-factor authentication (2FA), tick the API token option and enter a token from cPanel (Security, then Manage API Tokens). You can delete the token after the move.
- Tick Skip cPanel's HTTPS certificate check only if the old cPanel's certificate is self-signed.
- The password is not stored. The password or token is only passed to your server for this one transfer and is not written to disk.
- The new server must be able to reach port 2083 on the old server. If it cannot, make sure the old server's firewall allows it.
- How long it takes depends on the account size: cPanel needs time to build the backup, and then the file is downloaded.
Option 2: Use a backup file
- In the old cPanel, open Backup (or Backup Wizard), choose Download a Full Account Backup, then wait until the
backup-….tar.gzfile is ready. - Fill in one of:
- A download link for the backup file (it must be reachable from the internet), or
- A file path on the target server, after you upload it to
/root,/home, or/tmp, for example/root/backup-….tar.gz.
A plain site archive also works: a .zip or .tar.gz containing the site folder, with or without .sql files.
What Saka does
- The archive is unpacked safely: symlinks and paths that escape the folder are ignored, and the contents are limited to 20 GB. Free disk space is checked first.
- The contents of
public_htmlbecome the site files (including.htaccess). - For WordPress, the database to import is chosen from
DB_NAMEinwp-config.php. The database settings inwp-config.phpare updated for the new database, and the old address in the database is replaced with the new domain (https://plus the main domain). - Other databases in the backup are not imported, but their names are reported.
- If the site is not WordPress, the main database is still imported, and you are told the new host, database name, and user so you can update your app's settings yourself.
All of this is shown in the Catatan pemindahan (Move notes) box on the site's detail page. For a moved WordPress site, sign in with your old WordPress admin account.
Moving from Dokploy
When your VPS runs Dokploy (or Coolify), Saka recognises it automatically and leaves it alone: its Traefik keeps ports 80/443, Saka's firewall keeps the Dokploy and Docker Swarm ports open, and Saka sites and Kubernetes are not installed on that server. OpenClaw, Hermes, databases, VPN, and Shield still work there.
On that server's page, Move its apps to Saka lists every Dokploy app by project, read straight from Dokploy's database on that server, without an API key. Pick the apps and the target Saka server:
- Git apps (GitHub, GitLab, Gitea, Bitbucket, Git) become Saka Git apps with the same branch, subfolder, port, variables, and domain. Private repos need the deploy key shown after the move, because Dokploy's GitHub app access cannot be carried over.
- Docker image and Compose apps (pasted or from Git) become Saka Docker Compose apps. Compose volume data is copied directly from the Dokploy server to the target (one-time certificate, target IP only); the Dokploy app pauses briefly while it is copied, then runs again.
- Dokploy databases used by a Git app (PostgreSQL, MySQL, MariaDB, MongoDB, Redis) move as an app database: same image, credentials, host name, and data path, so the old
DATABASE_URLkeeps working unchanged. The data is copied server to server; the Dokploy database pauses briefly, then runs again. - Variables encrypted by Dokploy are decrypted on that server itself, and
${{project.X}}references are filled from project variables. Variables pass through Saka Panel in memory only and are not stored.
An overview of every way to move is in Moving to Saka. Dokploy is not changed. When it is done, point the domain's A record to the target server; the Dokploy app keeps running until you turn it off, and data changed there after the copy is not included. Not automatic yet: mounts of non-compose apps, and apps from a zip upload; each gets a note in the list. AI agents use the MCP tool dokploy_pindah.
Moving from Coolify
A server running Coolify is treated the same way: it is left alone, and Move its apps to Saka reads its apps straight from Coolify's database on that server, without an API key. Variables encrypted by Coolify are opened with the APP_KEY on that server, and {{project.X}}, {{environment.X}}, and {{team.X}} references are filled from shared variables.
- Repo apps (Nixpacks, Dockerfile, static) become Saka Git apps with the same branch, base directory, port, build/start commands, variables, and domain.
- Docker image, Docker Compose, and Coolify one-click services (for example Uptime Kuma or Plausible) become Saka Docker Compose apps, with their volume data.
- Coolify databases used by a Git app move as an app database with the same host name (the Coolify uuid), credentials, and data.
- When you change the domain while moving, variables that mention the old domain (such as
SERVICE_URL_*orAPP_URL) point to the new one.
Not automatic yet: apps built from a Dockerfile typed into Coolify without a repo, and storage of non-compose apps. MCP tool dokploy_pindah with platform: coolify.
Moving from aaPanel
A server running aaPanel is recognised and left alone too: its Nginx/Apache keeps ports 80/443, and Saka's firewall keeps the aaPanel panel port, phpMyAdmin (888), and FTP open. Move its apps to Saka reads the sites, domains, and databases straight from aaPanel's data on that server.
- PHP and WordPress sites become Saka PHP sites: the site files and their main database (from
wp-config.php, or the database aaPanel links to the site) are copied straight between the servers, then installed through the same path as moving from cPanel. WordPress is pointed to the new database and upload-folder hardening is turned on. - Static sites (no PHP) become Saka static sites.
- The database is copied with
mysqldump --single-transaction, so the aaPanel site keeps running during the copy. - PHP 8.2, 8.3, and 8.4 are kept. PHP 7.x, 8.0, and 8.1 run on PHP 8.2 (the lowest version still supported), with a note to check old themes and plugins first.
Not automatic yet: aaPanel Node/Python/Go/Java projects (use a Git app), FTP accounts (Saka uses SFTP per site), and a site's other databases besides its main one. MCP tool dokploy_pindah with platform: aapanel.
Moving from CyberPanel
A CyberPanel server (OpenLiteSpeed) is recognised and left alone too: OpenLiteSpeed keeps ports 80/443, and Saka's firewall keeps CyberPanel's panel (8090), OpenLiteSpeed admin (7080), FTP, email, and DNS ports open. Move its apps to Saka reads the sites, child domains, aliases, and databases from CyberPanel's internal database on that server.
- Every site and child domain becomes a Saka PHP site: the site folder and its main database (from
wp-config.php, or the site's first database) are copied straight between the servers, then installed through the same path as moving from cPanel. WordPress is pointed to the new database. - The database is copied with
--single-transaction, so the CyberPanel site keeps running. PHP below 8.2 runs on PHP 8.2 with a note.
Not automatic yet: CyberPanel email hosting and FTP accounts, and a site's other databases besides its main one. MCP tool dokploy_pindah with platform: cyberpanel.
Standalone databases into a cluster
PostgreSQL, MySQL, or MariaDB databases on Dokploy, Coolify, or aaPanel that no Git app uses (for example used by an app on another server) can be copied into a Saka database cluster: tick the database in the move dialog and choose the target cluster (PostgreSQL into a PostgreSQL cluster, MySQL/MariaDB into a MariaDB cluster). Saka opens a temporary path to that database on 127.0.0.1 of the old server only, copies it in one transaction through the cluster proxy, compares the row count of every table, then closes the path. The old database keeps running; afterwards create a user for the app on the cluster page and point the app at the cluster. MongoDB and Redis are not supported yet.
Move to another server
For changing VPS (for example to a bigger server or another location) without the hassle. The site is copied straight to the new server, and the old site keeps serving visitors until you are ready. The target server must be connected to the same Saka account, with ports 80/443 free.
- Copy. On the site's detail page, open the Move to another server card. Choose the Target server and PHP on the new server (you can change the PHP version, for example up to 8.4). For WordPress, tick Update WordPress, plugins, and themes during the move if you want. Press Copy to new server. The old site keeps running; you are notified on Telegram when the copy is ready. You can press Copy again at any time to refresh the copy.
- Move now. The old site shows a maintenance page (HTTP 503) briefly, the latest changes are copied, and the site goes live on the new server. If you chose the WordPress update, WordPress core, plugins, themes, and translations are updated after a backup; if the site breaks afterwards, it is rolled back automatically to the state before the update. If this step fails, the old site goes live again.
- Change DNS. Change the domain's A record to the new server's IP at your domain's DNS provider. The DNS column on the Domain & HTTPS card turns to pointing here afterwards.
- Finish. Once DNS points to the new server, press Finish (delete from old server). The site on the old server is deleted; its last backup is kept in
/rooton the old server.
Cancel is available until you finish. Before Move now, the copy on the new server is deleted and the old site is unchanged. After it, Cancel, go back to the old server makes the site live on the old server again and deletes the copy on the new server; changes made on the new server since the move are lost, and an A record you already changed needs to point back to the old server's IP.
How it works
- Directly from server to server over HTTPS, not through Saka. The old server opens a temporary sender with a one-time certificate; Saka passes that certificate's fingerprint to the new server, so the new server only accepts the right sender.
- The sender port is random, opened only for the target server's IP, uses a random token, and stops by itself after 1 hour at most.
- The database name, user, password, and the SFTP account stay the same, so your app's settings do not need to change.
- Sites with a database cluster: the database is not copied, because the new server is connected to the same cluster (the Saka proxy is installed on the new server).
Behind a load balancer
If a load balancer in proxy mode is ready and forwards the site's domain to this server, the site is automatically served through the balancer: visitors come in through the balancer, and the balancer holds HTTPS. The HTTPS column then shows di load balancer (at the load balancer). This is reapplied automatically when a load balancer is created or deleted, or when a balancer's IP changes.
PHP versions
Choose PHP 8.2, 8.3, or 8.4. On the PHP card, pick a version and press Ganti versi (Change version). The site restarts with the new version within a few seconds; a version that has not been used on that server yet is prepared first (about 1-2 minutes).
PHP settings
The same card has PHP settings, like cPanel's MultiPHP INI Editor but without editing files:
- Upload limit (
upload_max_filesize, 2 to 2048 MB;post_max_sizeis adjusted to match). Default 64 MB. - Memory limit (
memory_limit, 64 to 2048 MB, at most three quarters of the server's RAM). The site container's memory limit is raised to match. Default 256 MB. - Max execution time (
max_execution_timeandmax_input_time, 10 to 3600 seconds). Default 120 seconds. - max_input_vars (1000 to 100000), often needed for long WordPress menus. Default 3000.
- Time zone (
date.timezone, e.g. Asia/Jakarta). Default UTC. - Show PHP errors (
display_errors): only for debugging, turn it off again afterwards.
Press Save settings; the site restarts for a few seconds. Via the API: PATCH /api/v1/situs/{id} with php_ini; via MCP: the situs_atur_php tool.
Deleting a site
In the Zona berbahaya (Danger zone) section, press Hapus situs (Delete site) and type the site name to confirm. The site's files, database, SFTP account, and all its backups on the server are deleted. Your domain and server are not touched.
Tick Simpan cadangan terakhir dulu di /root server (Keep the last backup in /root on the server first, recommended) to copy one final backup to /root before the site is deleted. If that copy fails, the site is not deleted.
When you release a server, every site on it is cleaned up too; with the keep-backups option, each site's backup is copied to /root.
Ready-made apps
Install popular apps with one click, complete with a domain, HTTPS, and daily backups: open Sites, Create site, choose Ready-made app, then pick the app.
| App | For | Minimum RAM |
|---|---|---|
| n8n | Workflow automation without code | 1 GB |
| Uptime Kuma | Monitor sites & APIs, status pages | 512 MB |
| Vaultwarden | Password manager (Bitwarden compatible) | 300 MB |
| Metabase | Dashboards & reports from databases | 2 GB |
| NocoDB | Spreadsheet-database (Airtable alternative) | 512 MB |
| Gitea | Self-hosted Git | 512 MB |
| Memos | Quick notes with Markdown | 300 MB |
| Nextcloud | Files, calendar, contacts (Google Drive alternative) | 1 GB |
| Umami | Website analytics (Google Analytics alternative), with its own PostgreSQL | 1 GB |
| Ghost | Blog & newsletter with memberships, with its own MySQL | 1.5 GB |
| Listmonk | Newsletters & bulk email, with its own PostgreSQL | 512 MB |
- Data stays on your server, in the site folder, and is part of the daily backups. The app pauses briefly while being backed up so the data is consistent. Restore from the Backups card.
- Update to the latest version from the app page: a backup is made first, and if the new version fails to run, the previous version and data are restored automatically. There is a short pause while it restarts.
- Variables (app settings) can be changed in the Environment variables card. If a change makes the app fail to start, the previous variables are restored automatically.
- Apps that need a database (Umami, Ghost, Listmonk) get their own automatically: dedicated to that app, not reachable from outside the server, and included in backups, updates, and restores together with the app. No need to create a database yourself.
- Each app's first step (for example creating the admin account) is shown on the app page and sent on Telegram. Apps that ship with a default admin password (Umami) get a random one right away; see it with the Show login button.
- Home server? Open the app through a tunnel address.
Through your AI agent: katalog_daftar, then situs_buat with jenis: "katalog" and katalog: "n8n"; update with situs_perbarui_aplikasi.
Apps from Git
Deploy your own app straight from a Git repository: Node (Next.js, Express, Vite), Python (Flask, FastAPI, Django), Go, PHP, Ruby, or anything with a Dockerfile. Every push deploys automatically, and if a new release misbehaves you roll back to the previous one with one click.
- Open Sites, Create site, choose App from Git.
- Enter the repo address and branch. Leave the branch empty to use the repo's default branch (e.g.
mainormaster); addresses pasted from the browser likegithub.com/name/repo/tree/devare cleaned up automatically and fill in the branch. For a monorepo, set Subfolder under advanced settings. - Pick the server and domain, then create. The first deploy starts automatically; build steps show on the app page.
How it builds
- A
Dockerfilein the repo is used as is. The port comes fromEXPOSE. - Without a Dockerfile the app type is detected automatically by Railpack. You can set build and start commands yourself if needed.
- Builds run on your own server; the code never passes through Saka. One build at a time per server. Small servers should have swap (one click from the Readiness card).
- Your app should listen on the
PORTvariable; Saka sets it.
Zero-downtime deploys, one-click rollback
A new release starts next to the old one, is health checked (the path is configurable), and only then do visitors switch over. If the new release fails to build, stops, or doesn't respond, the old release keeps serving and you are notified on Telegram. The last five releases are kept; Roll back here runs an older release in seconds without rebuilding.
Private repos (deploy key)
Private repos are read with a deploy key: an SSH key generated on your server for one app that can only read that one repo. Saka never asks for your password, token or GitHub account access. Until the key is added, the first deploy fails with The repo cannot be read from this server; that is expected.
- Use the SSH URL when creating the app:
[email protected]:name/app.git(nothttps://github.com/...). On GitHub it is under Code, tab SSH. Already used an https URL? On the app page, card Repository & auto deploy, press Edit, change the URL and save. - Copy the deploy key from the app page (section Deploy key (private repo), copy button). It is a single line starting with
ssh-ed25519. - Paste it in the repo, with write access off:
- GitHub: repo, Settings, Deploy keys, Add deploy key. Any title (e.g.
saka-server-name), paste the key, leave Allow write access unchecked. - GitLab: Settings, Repository, Deploy keys, Add new key, leave Grant write permissions unchecked.
- Bitbucket: Repository settings, Access keys, Add key.
- Gitea/Forgejo: Settings, Deploy Keys, Add Deploy Key.
- GitHub: repo, Settings, Deploy keys, Add deploy key. Any title (e.g.
- Back on the app page, press Deploy now. Clone and build steps show on the app page.
- Optional: set up deploy on push so you do not need to press Deploy again.
Saka checks repo access before the first deploy. Until the key is added, no deploy runs (so there is no failed deploy); you get the key by Telegram or email, and the app page shows a Last step card with a Check & deploy button.
If it still fails:
- Permission denied (publickey): the key was not added, was added to another repo, or was not copied completely. Copy the whole line again.
- Repository not found: a typo in the repo URL, or the key was added to another repo.
- GitHub says Key is already in use: the same key is already on another repo. Each Saka app has its own key, so this usually means another app's key was copied.
- Private submodules need access too; add the same key to the submodule repo (GitLab/Gitea), or use a repo without private submodules. GitHub does not allow one deploy key on two repos.
The same app on a second server (two locations) or a fleet deploy uses the same key, so it is added only once. AI agents can help through MCP: they read the key from situs_status and ask you to add it (or use your own gh repo deploy-key add).
Deploy on push
The app page shows a Payload URL and Secret. In GitHub: Settings, Webhooks, Add webhook, Content type application/json, event Just the push event. GitLab and Gitea work too. Pushes to other branches are ignored; a push that arrives during a deploy is deployed right after it.
Environment variables
API keys, database URLs, and other settings go in the Environment variables card. Values are stored only on the server and not shown again; saving restarts the app without downtime. From inside the app, services on the server (for example the database cluster proxy) are reachable at host.docker.internal.
For secrets you make up yourself, such as SESSION_SECRET or JWT_SECRET, type the name and press Random: a random value is generated on the server and never shown, not even to an AI agent.
Persistent data folder
Every app from Git gets a /data folder that is not lost on deploy, rollback, or variable changes. Its location is in the DATA_DIR variable. Keep SQLite databases and uploaded files there, for example path.join(process.env.DATA_DIR || "./data", "app.db"). Workers and cron jobs use the same folder.
- Backed up. Once the data folder has content, it is backed up automatically every day (last 7 kept), and can be backed up manually, downloaded, restored, and sent to your own S3 like any other site. During a backup the app is frozen for a few seconds so SQLite is copied intact.
- Pull request previews get their own copy of the data folder (when under 1 GB), so testing does not touch the real data.
- Two locations cannot be used while the data folder holds SQLite; move the data to a MariaDB cluster first.
Outgoing email
To let the app send email (password resets, notifications, invoices), fill in the Outgoing email card with your email service's SMTP server (e.g. Brevo, Amazon SES, or Gmail with an App Password). It is stored as the variables SMTP_HOST, SMTP_PORT, SMTP_USER, SMTP_PASS, SMTP_FROM, and SMTP_SECURE, which the app reads. Press Send test email: the email is sent from the app's own server. If the VPS provider blocks outgoing email ports (common on new accounts), Saka tells you and suggests port 2525 or asking the provider to open them. Saka does not offer email hosting.
Stay out of spam. On the same card, press Check DNS: Saka reads the sender domain's SPF, DKIM, DMARC, and MX through public DNS and shows the records to add for the email service in use (Brevo, Amazon SES, Google, Mailgun, SendGrid, Postmark, and more), each with a copy button. SPF that uses include or redirect is followed the way receivers read it. The domain's DNS is managed on your side (registrar or Cloudflare), and Saka tells you where; Saka only advises and does not change DNS. AI agents use email_dns_cek.
App check
On every deploy, Saka checks the code without stopping the deploy, which suits apps built with AI help:
- Secrets in the repo: committed
.envfiles, private keys, AWS, Stripe, OpenAI, Anthropic, GitHub, Slack, Midtrans and Xendit keys, Telegram bot tokens, database URLs with passwords, and Supabaseservice_rolekeys (the public anon key is skipped). Values are masked in the report. - Missing env variables: names the code reads (
process.env,import.meta.env,os.getenv,os.Getenv, Laravelenv(), RubyENV[], and similar) that are not set in App variables. Ones with a default in the code are skipped. - Open without login: once the release runs, Saka checks from inside the server whether
/.env,/.git/configor APIs such as/api/userscan be opened and contain email data. SPAs that answer every path are not reported as open.
Results are in the App check card (Check now checks without deploying). Important findings are sent by Telegram once per commit. AI agents use the MCP tool situs_periksa_aplikasi.
Bulk deploy: one app on many servers
For the same app on many servers (e.g. one VM per customer), open Bulk deploy and press + Create group: Saka groups your Git apps by repo and branch; just pick Make a fleet.
- Deploy to all: the latest commit goes to one server first (canary). If it succeeds, that commit is pinned and deployed to the other servers, 5 at a time. The rollout stops on its own if the canary fails or more than 10% fail; failed servers keep serving their previous release, and servers not reached yet are untouched.
- Disconnected servers are skipped (not counted as failures) and can be deployed later. Two-location apps apply the change to their second location too.
- Change variables: one NAME=value line per variable, applied to every member in waves with a canary.
- The Bulk deploy page shows the version (commit) on each server, so lagging servers stand out. Per-server notices are muted; you get one summary on Telegram.
- In testing (3 Oct 2026, 3 servers): deploy to all ended with a uniform version; deploying a commit that doesn't exist stopped at the canary without touching the other two; a powered-off server was skipped.
- API:
GET /api/v1/armada/saran,POST /api/v1/armada {"nama", "situs"},GET /api/v1/armada/<id>,POST .../rilis {"commit?", "gelombang?", "batas_gagal?"},POST .../env {"env"}. MCP:armada_daftar,armada_buat,armada_status,armada_deploy,armada_env.
Workers & cron
Like a Procfile: on the Workers & cron card, add extra processes from the same release with the same variables. Commands run with sh -c inside the app container.
- Workers (up to 5): run continuously without a port, e.g. an email queue or a bot (
npm run worker). They follow deploys and rollbacks; a worker that stops right away is reported. - Cron (up to 10): ready-made schedules (every 5 minutes, every hour, every day at 02:00, and more) or the 5-field cron format, in the server's time zone. A job never runs twice at the same time and is stopped if it exceeds its limit (30 minutes by default). The last result (exit code, duration, and the end of the log) shows in the panel, with a Run now button.
Pull request previews
Turn it on in the Pull request previews card, then in the repo's webhook settings also tick the Pull requests event (GitHub/Gitea) or Merge request events (GitLab). Every pull request to the app's branch (forks included) is built on your server and runs at https://pr-<number>-<id>.<server-ip>.sslip.io with HTTPS, no DNS setup needed. The address is sent on Telegram and updated on every push to that PR.
- Up to 3 previews per app; removed automatically when the PR is closed or merged, or after 7 days without updates. Previews are not indexed by search engines.
- Previews use the same variables as production, plus
SAKA_PRATINJAU=1andSAKA_PR=<number>. - Separate database for each PR (on by default): the app database from
DATABASE_URL(or Laravel-styleDB_DATABASE) is copied to<name>_pr<number>on the same database server, and the preview uses that copy. Migrations and test data in the PR never touch production. The copy is made when the PR is first previewed, reused on later pushes, and removed with the preview. PostgreSQL, MySQL, and MariaDB; up to 2 GB; the database user needs permission to create databases. If copying fails, the preview does not run at all (it never silently falls back to production). Untick it if you want previews to use the production database. - Needs a server with a public IPv4 (not home servers behind a tunnel).
Through your AI agent and the API
# deploy the latest commit, roll back, set variables
curl -s -X POST https://app.saka.work/api/v1/situs/<id>/deploy -H "Authorization: Bearer $SAKA_TOKEN"
curl -s -X POST https://app.saka.work/api/v1/situs/<id>/rollback -H "Authorization: Bearer $SAKA_TOKEN" -H "Content-Type: application/json" -d '{"commit": "<release tag>"}'
curl -s -X POST https://app.saka.work/api/v1/situs/<id>/env -H "Authorization: Bearer $SAKA_TOKEN" -H "Content-Type: application/json" -d '{"env": {"MODE": "production"}}'MCP tools: situs_buat (type git), situs_deploy, situs_rollback, situs_env, situs_proses (workers & cron), situs_cron_jalankan, situs_pratinjau, situs_email_uji, and situs_status to see releases and the last error.
Test sandbox. The MCP tool situs_ruang_uji (and POST /api/v1/situs/{id}/ruang-uji) runs one shell command on a copy of a WordPress, PHP or static site's files, in a throwaway container: no internet, read-only root, no capabilities, 256 MB RAM, 1 CPU, 128 processes, 300 seconds at most. You get the command output, the exit code, and the files that were added, changed or removed. The live site never changes. Useful for checking a site you suspect was hacked (grep -rlE "eval\(base64_decode" .) or checking syntax (php -l index.php) with no risk. Needs the sites permission and Docker on the server.
Binary services. The layanan site type runs a single binary (for example a Go app) directly on the server under systemd, without Docker, with a domain and automatic HTTPS. The binary runs as a locked-down system account with a read-only filesystem except one data folder, and environment variables are stored only on the server (their values are never read back through Saka). Create it with situs_buat type layanan (layanan.perintah, layanan.cek_sehat), then install a release: POST /api/v1/situs/<id>/layanan/rilis with {"berkas": "/root/server"} or {"url": "https://...", "sha256": "..."} (a binary or a .tar.gz). Saka copies it, runs the pre-command if any, switches the active release, restarts and checks health; if it is not healthy it returns to the previous release automatically. The last five releases are kept for rollback. There is a few seconds of downtime while restarting. MCP tools: layanan_status, layanan_rilis, layanan_rollback, layanan_env, layanan_atur, layanan_kontrol. The first version does not back up the data folder, cannot be moved to another server and does not support two-location replicas. Backups: the data folder and the service environment variables are included in the automatic daily backup, manual backups, S3 upload, Restore (with an automatic safety backup) and the restore test. The binary and releases are not (the last five releases stay on the server). The copy is taken while the service runs; a service that needs a consistent state (for example a file-based database) should write its own export into the data folder before the nightly backup. The cadangan_kecuali field (set when creating the service, a list of paths relative to the data folder) keeps caches the app rebuilds on its own out of the archive; they do not come back when you restore.
Saka Endpoint (managed remote desktop). Endpoint installs MeshCentral on your own server as a binary service, with a domain and automatic HTTPS: screen control, terminal and files from the browser, agents for Windows, Linux and macOS, no per-device fee. One server per customer: a problem on one server does not affect other customers and the data does not pass through a third party. Install with endpoint_pasang (MCP) or POST /api/v1/endpoint with {"server_id": "..."} (optional nama, domain, judul, email); follow progress with GET /api/v1/endpoint/<job>. The install takes about 5 to 10 minutes: it creates the service site, stores the settings, downloads the MeshCentral package (sha256 pinned by Saka), creates the first admin before the service opens, then removes the initial password from the server. The initial admin password is shown once in the install response; note it, then set up 2FA (required) at first login. Self-service sign-up is off, MeshCentral listens only on 127.0.0.1 behind Saka's web server, and the daily backup (database and agent keys) is part of the site backup, so existing agents reconnect after a restore without being reinstalled. A dedicated server is recommended (at least 2 vCPU and 2 GB RAM). Some antivirus products flag the Windows agent because it is a remote tool; allowlist it according to your policy.
Binary service egress limit. A binary service runs directly on the server, so Saka recognizes it by its system account (one account per service) and installs firewall rules in the outgoing chain (OUTPUT). The Restrict the addresses it may contact card on the site page has the same three modes as other apps: Monitor only (no rules), Simulate (records the internet destinations that would be blocked without rejecting anything) and Restrict (rejects anything not in the allow list). Private addresses, loopback, replies to incoming requests and the server DNS always stay allowed. Saka runs the enforcement test as the service account and cancels Restrict by itself if it fails; a 10 minute trial returns to Simulate unless confirmed. New destinations are only recorded in Simulate and Restrict, domain names do not show in the list, and IPv6 is not covered. REST: GET/PUT /api/v1/situs/{id}/layanan/egress; MCP: layanan_egress_batas and layanan_egress_atur.
Not yet available for Git apps: automatic backups (the code is in the repo; back up your database separately), one-click moves to another server (create the same app on the target server and deploy), and multiple servers behind a load balancer.
Docker Compose
The Docker Compose site type runs a docker-compose.yml you paste into the panel or one in a Git repo (found automatically as compose.yaml/docker-compose.yml, or give its path). Pick the web service and its port inside the container; Saka connects it to your domain with HTTPS. The Docker Compose plugin is installed automatically when missing.
Before running it, Saka rewrites your file (your original is not changed):
- The web service is only exposed on
127.0.0.1, behind Saka's web server. Ports published by other services are bound to127.0.0.1too, so databases are not open to the internet. container_namebecomes a network alias (no clash with other apps, but other services can still call that name), named volumes that are not declared at the top of the file are added, and services withoutrestartgetunless-stopped.- Refused with an explanation:
network_mode: host,pid/ipc: host,privileged,cap_add: SYS_ADMIN/ALL, mounting the Docker socket, mounting the whole disk or system folders, and ports 80/443 on services other than the web service.
Variables fill ${NAME} in the compose file and are also written to .env in the project folder (for env_file: .env). The Docker Compose card on the site page shows every service and its state, logs per service, Stop/Start, and Redeploy (pulls the latest code when from Git).
Daily backups apply: the project folder plus the content of every named volume (services pause briefly so the data is consistent). Restoring puts the files and volume data back, then starts the services again.
Deploy automatically on push (Compose from Git): in the Docker Compose card, open Deploy automatically on push and add its Payload URL and Secret as a webhook on GitHub, GitLab, or Gitea. Every push to the app's branch pulls the latest code and restarts the services.
Moving to another server uses the same Move to another server card as regular sites: files, variables, the deploy key, and volume data are copied straight to the new server, the local port is adjusted, and the services start there. Services on the old server pause briefly each time their volumes are packed. A second location is not available for this type, because volume data cannot be shared between two servers.
Ready-made templates in the catalog run as Compose apps too: Supabase (from its official repo, with every secret and the anon/service_role keys created on the server), Cal.com, PocketBase, and Directus.
Databases for Git apps
In the App database card, add PostgreSQL, MySQL, MariaDB, MongoDB, or Redis for one Git app with a single click. The database runs on the same server, on that app's own Docker network, with no port open to the internet; the app and its workers reach it by host name (for example postgres). DATABASE_URL, DB_HOST, DB_DATABASE, DB_USERNAME, DB_PASSWORD (or REDIS_URL, MONGODB_URI) are set automatically with a random password; variables you set yourself still win. The app is redeployed so it reads them. The database is included in daily backups (it pauses briefly) and is put back on restore. Removing a database requires typing its type.
Logs
The Logs card on a site page shows logs read straight from the server when opened (not stored on Saka): App (Git & ready-made apps), Build (output of the last deploy build, successful or not), workers, Database (ready-made apps with a database), Errors & Access (WordPress/PHP), and Web server (HTTPS certificates and proxy errors for the site's domains). Follow refreshes every 3 seconds; Download saves a .txt file.
From the terminal: saka site log <name> build, or -f to follow (see CLI). AI agents use the situs_log tool.
Your own HTTPS certificate
By default every site domain gets a free Let's Encrypt certificate, installed and renewed automatically. Have a paid, wildcard, or EV certificate? On the site page, HTTPS card, press Use your own certificate, then paste or choose files:
- Certificate (PEM): the site certificate, then the intermediate certificates (CA bundle) below it.
- Private key (PEM): the key created with the CSR. A password-protected key must be unlocked first. The key is stored only on the site's server.
Saka checks the key pair, validity, intermediate chain, and which domains are covered. Site domains not covered keep the automatic certificate. You're reminded on Telegram 30, 14, 7, 3, and 1 days before it expires, and can go Back to automatic at any time. Sites behind a proxy-mode load balancer use the balancer's HTTPS.
WordPress security & staging
WordPress sites get a WordPress security card on their site page.
Security check
Every day Saka checks the installed WordPress, plugin, and theme versions and alerts you about new important findings. The result is summed up as a score from 0 to 100.
- Known vulnerabilities (CVE). Installed versions are matched against the WPVulnerability.net database (free, no API key). Each finding lists the CVE numbers, severity, and the version that fixes it. Vulnerabilities with no fix yet are flagged, and an active plugin like that can be deactivated right away.
Other findings from wordpress.org:
- Important: plugins closed on wordpress.org for a security issue, and WordPress missing the fix release on its version branch (releases like 6.6.1 to 6.6.2 usually carry security fixes). Active important plugins can be deactivated from the panel.
- Recommended: plugins, themes, or WordPress with a newer version, and plugins closed for other reasons (they will get no more security updates).
- Info: plugins their authors have not updated for more than 2 years.
Update all takes a backup, updates WordPress, plugins, themes, and languages, then checks the site; if it breaks, the backup is restored automatically. Premium plugins not on wordpress.org cannot be checked for closure, but their updates are still detected if the plugin offers them.
Hardening
Below the findings is a list of settings that close common WordPress holes. Every row that is not safe yet has a Fix button:
- Plugin & theme file editor disabled (
DISALLOW_FILE_EDIT): an intruder who gets into the dashboard cannot edit PHP code. - Debug mode off (
WP_DEBUG): error messages do not leak file paths to visitors. - Unique secret keys (salts). Replacing the keys signs everyone out, so Saka asks first.
- wp-config.php protected: only the site owner can read it.
- XML-RPC closed:
xmlrpc.phpis often used to guess thousands of passwords at once. Leave it open if you use Jetpack or the WordPress mobile app; it can be reopened with one click. - PHP blocked in the uploads folder: PHP files smuggled in through uploads cannot run.
- New sign-ups get no admin rights: when registration is open, the default role must not be Administrator or Editor.
- No admin called "admin". This row is not fixed automatically: create a new admin with another name, sign in with it, then delete the old account.
New WordPress sites from Saka start with a random admin username (not admin), a protected wp-config.php, and PHP blocked in the uploads folder. AI agents can do the same through wp_keamanan and wp_kuatkan, with your approval.
File integrity
The daily check also compares WordPress core files and plugins from wordpress.org with their originals (checksums). Changed core or plugin files, and unknown files in wp-admin or wp-includes, are common signs of a hacked site and are flagged as important. Reinstall original files re-downloads WordPress core or that plugin (same version) and overwrites the changed files; site content, uploads, and settings stay, with a backup first and automatic restore if the site breaks. Unknown files are not deleted automatically: check and remove them over SFTP, then change the admin password.
File shield
For every WordPress, PHP, and static site, Saka answers 404 for files that must never be reachable from the internet even if they end up in the web folder: .git, .env, database dumps (.sql), backups such as wp-config.php.bak, debug.log, and error_log. It works in front of PHP, so it protects non-WordPress sites too. With the security check, file integrity, and this shield, a heavy security plugin inside WordPress is usually no longer needed; you can still keep one for its specific features.
Staging
Press Create staging to copy the site (files and database) to https://staging-<id>.<server-ip>.sslip.io with HTTPS and no DNS setup. Log in with the same WordPress account. On staging, outgoing email and WP-Cron are off (customers get no test emails, scheduled tasks do not run twice), and search engines are asked not to index it.
- Update on staging or change themes/plugins in the staging dashboard, then test the site.
- Push to live site, choosing:
- Files only (recommended): WordPress, plugins, and themes from staging replace the live site's. The live database, uploads, and wp-config.php are not touched, so orders, comments, and new users stay safe.
- Files and database: everything on staging replaces the live site, with addresses switched back to the live domain. Changes on the live site since staging was created are lost.
- Delete staging when you no longer need it (removes the copy and its database; the live site does not change).
Staging needs a server with a public IPv4 and free disk about the size of the site. MCP: wp_keamanan, wp_perbarui, wp_nonaktifkan_plugin, wp_staging.
Monitored from the internet
Every minute Saka opens each site's main domain over the internet, like a visitor would. The site page shows whether it opens, its response time, and 30-day uptime. If the site can't be opened for more than 3 minutes while its server is connected, you're told on Telegram (or by email if Telegram isn't linked) with the cause: DNS missing or pointing elsewhere, an expired or wrong-domain HTTPS certificate, port 443 closed, no answer from the server, or a 5xx error from the app. You're told again when it recovers.
Sites that have never opened (e.g. the domain's DNS isn't pointed yet) don't trigger alerts; monitoring starts after the first successful open. An automatic certificate with less than 7 days left means its renewal failed, and that is reported too. Monitoring requests use the SakaPanel-Pantau User-Agent.
Checked from two locations. Checks run from Singapore. When a site fails from there, Saka immediately checks it again from Bangalore (another network and country). An outage is only counted in uptime and reported when both locations fail, so a network problem at one point does not cause a false alert. Outage alerts name the locations checked. This also applies to tunnels, load balancers, and external addresses.
Tunnels and load balancers are monitored too. The address of every active tunnel (<name>-app.hack.id) and the domain of every load balancer are checked the same way, and the result shows on the Tunnel page and the load balancer page. A Telegram alert is sent when one cannot be opened for more than 3 minutes.
Monitor addresses outside Saka
In Settings, the Monitor addresses outside Saka card watches any URL or API, including ones not on Saka: sites on other hosting, third-party APIs, mobile app endpoints. Checked from the internet every minute; outages longer than 3 minutes are reported (once the address has been up), and so are HTTPS certificates with less than 14 days left. Under Advanced settings, set a keyword that must appear in the response (useful when an error page still answers 200) or the expected HTTP status (e.g. 401 for an API that requires login). Up to 20 addresses per account; internal network addresses (private IPs, loopback, cloud metadata) are refused. External addresses can go on a public status page and are in the monthly report. MCP: pantau_luar.
Monthly report
On the 1st of every month at 08:00 WIB, Saka sends last month's report: outages and bandwidth per server, availability and downtime per site, tunnel, load balancer, and external address, bandwidth and WordPress security score per site, certificates expiring within 30 days, and alert counts. Full by email (when verified) and short over Telegram. Set it up in Settings, Monthly report card (on/off, preview this month, send now). For agencies, add client emails in the Report for your client card on the site page (up to 3): the client only receives that site's report, without your servers or other sites. The site page also shows this site's bandwidth per month and per day; a single site's spike (at least 2 GB a day and five times its average) is reported with the site's name. MCP: laporan_bulanan.
Public status page
In Settings, the Public status page card, press + Create status page, give it a title, pick the sites, tunnels, or load balancers to show, and give each a display name (e.g. "Online shop", "API"). You get an address https://app.saka.work/status/<code> to share with your customers. It shows the current state and 30-day history of each service, refreshed every minute. Domains, servers, and error messages are not shown. A JSON version is at the same address with .json appended. Up to 5 pages per account.
App error alerts
For every site and app (WordPress, PHP, Git apps, ready-made apps), Saka reads the web access log. When a site answers with server errors (5xx) at least 10 times and for at least 20% of its requests within 5 minutes, you get a Telegram alert with the most affected addresses and a snippet of the app's error log (e.g. PHP Fatal error, Traceback, panic). The same warning shows on the site page. At most once an hour per site; a "back to normal" message follows after 15 minutes without a spike.
Scheduled job monitoring
Cron jobs of Git apps in Saka are monitored automatically: when a scheduled job starts failing (non-zero exit code or timeout), you get alerted with the end of its output, and again when it succeeds. Repeated failures are not re-alerted.
Other jobs (cron on any server, backup scripts, stock sync): in Settings, Scheduled job monitoring card, press + Monitor a job and enter a name and how often it runs. You get a ping address; add it to the end of your cron command:
0 2 * * * /opt/backup.sh && curl -fsS -m 10 --retry 3 https://app.saka.work/ping/<code> || curl -fsS -m 10 --retry 3 https://app.saka.work/ping/<code>/gagalIf no report arrives within the interval plus grace period, or the job calls /gagal (a POST body is stored, e.g. the error message), you get alerted; when it reports normally again, you hear it recovered. Monitoring starts after the first report. MCP: tugas_pantau_daftar, tugas_pantau_buat, tugas_pantau_hapus.
Sites in two locations
Run a copy of a WordPress, PHP, or static site on a second server (ideally in another city or provider). If the main server goes down, visitors are served by the second one automatically and the site stays up.
- Requirements: WordPress/PHP sites use a database in a MariaDB cluster (static sites need none). The second server is connected to Saka, has a public IP, and is not a member of that cluster. Git apps with a PostgreSQL cluster may run on cluster members (web app and database on the same VM); see Survive a VM outage.
- On the site page, Two locations card, press Add a second location and pick the server. The site is copied without downtime (usually a few minutes); you get a Telegram message.
- Last step: change the domain's DNS record to a CNAME pointing to the load balancer address shown on the card (e.g.
lbxxxx.lb.saka.work). A bare domain (e.g. shop.com) can't be a CNAME at most DNS providers: use www.shop.com or a provider with CNAME flattening (e.g. Cloudflare).
- How it works: the main server serves and writes; site files are copied to the second server every minute (rsync over SSH). The copy key can only copy that site's folder and only from the main server's IP, with no shell. The database is shared through the cluster, on the same port on both servers.
- Automatic failover: a DNS-mode load balancer (both servers act as name servers) answers with the main server's IP while it is healthy, and the second server's IP when the main one is down (13 seconds in our test). HTTPS stays valid on both servers.
- Back to normal: when the main server returns, files changed on the second server in the meantime (e.g. uploaded images) are pulled back first, then copying resumes as usual.
- Domain and PHP changes are applied to both servers. Backups are made on the main server. Remove second location deletes the copy and its load balancer; the site keeps running on the main server.
Git apps in two locations
- The second server builds the same commit from the repo with the same env variables. Variables, the deploy key, workers, and cron are sent directly between the servers, not through Saka.
- Every deploy, rollback, and variable change on the main server is applied to the second server too. If it fails there, you are notified and the main server is unaffected; press Copy now to bring it back in line.
- Workers and cron run on the main server so jobs never run twice. If the main server is unreachable for 3 minutes, the second server takes over workers and cron, and hands them back 2 minutes after the main server is reachable again. A main server that has just booted holds workers and cron for 4 minutes, so the two never run together (in testing: takeover 3.5 minutes after the main server died, no overlap on return). If both servers are up but cannot reach each other, jobs may run on both during the disruption: make jobs safe to run twice.
- The app's database must be a Saka cluster or a database service, not a plain local database, since no files are copied. A PostgreSQL cluster may share the VM with the app (guide).
- Catalog apps can't use two locations yet: their local database can't be copied safely while running.
Through your AI agent: situs_lokasi_kedua. Through the API: POST /api/v1/situs/<id>/lokasi {"server_id": "..."}.
What we deliberately do not do
- Email hosting. Use the email provider of your choice. Saka helps check its email DNS (see Outgoing email).
- Reseller or WHM accounts. Sites is for app owners, not for selling hosting.
- One-by-one technical menus such as a zone editor or MIME types.
Security
- Passwords stay on your server. Database, SFTP, and WordPress admin passwords are stored on the server (in a file only root can read) and read by the panel when you press Tampilkan sandi (Show password). They are never given to an AI agent through MCP. The old cPanel's password or API token is only passed to your server once and is not stored.
- Root SSH settings stay unchanged. Saka adds SFTP settings just for site accounts, then compares the SSH settings for root before and after. If anything changed, the change is rolled back. Root stays without password login if it was that way before.
- Separated per site. Every PHP or WordPress site runs in its own container that only listens on
127.0.0.1; visitors come in through a single web server with HTTPS on ports 80/443. - Logged. Creating, changing, backing up, restoring, and deleting sites is recorded in the server's task history.
Through your AI agent (MCP) and the API
MCP tools
| Tool | What it does |
|---|---|
situs_daftar | Lists sites across all servers, with their domains and state. |
situs_buat | Creates a WordPress, PHP, or static site, with a local or cluster database, or moves one from cPanel (sumber with a backup file, or cpanel to sign in to the old cPanel). The agent must confirm the plan with you first. |
situs_status | Site state: HTTPS and DNS for each domain, size, list of backups, SFTP account. No passwords. |
situs_cadangkan | Makes a backup now. |
situs_atur_php | Changes the PHP settings: upload limit, memory, execution time, max_input_vars, time zone, show errors. |
situs_pindah_salin | First step of moving to another server: copies the site to the target server (optionally with another PHP version and a WordPress update). The old site keeps running. |
situs_ubah_siapkan | Step 1 of 2 for pulihkan (restore), hapus (delete), pindah_sekarang (move now), pindah_selesai (finish the move), or pindah_batal (cancel the move): a preview and a confirmation token (10 minutes). |
situs_ubah | Step 2 of 2: runs that action with the token, only after you have approved the preview. |
There is no MCP tool for reading site passwords. See Connect your AI (MCP).
API endpoints
| Method | Path | Details |
|---|---|---|
GET | /situs | List sites (can be filtered with ?server_id=). |
POST | /situs | Create a site. Body {"nama", "server_id", "jenis", "domain", "php", "bahasa", "db", "klaster_id", "sumber", "cpanel"}. |
GET | /situs/{id} | Details and status (DNS, HTTPS, backups, SFTP without password, pindah while a move is in progress). |
PATCH | /situs/{id} | Change the name, domains, PHP version, or PHP settings. Body {"nama", "domain", "php", "php_ini"}. |
DELETE | /situs/{id} | Delete. Body {"konfirmasi": "<site name>", "simpan_cadangan": true}. |
POST | /situs/{id}/rahasia | Read the database, SFTP, and WordPress admin passwords directly from the server. |
POST | /situs/{id}/cadangan | Back up now. |
POST | /situs/{id}/pulihkan | Restore. Body {"berkas": "<backup name>", "konfirmasi": "<site name>"}. |
POST | /situs/{id}/phpmyadmin | Start the site's phpMyAdmin. Returns {"url"}, a single-use sign-in link (60 seconds). |
POST | /situs/{id}/pindah | Copy to another server. Body {"server_id", "php", "perbarui_wp"}. |
POST | /situs/{id}/pindah/sekarang | Move now. Body {"konfirmasi": "<site name>"}. |
POST | /situs/{id}/pindah/selesai | Finish: delete the site on the old server (last backup kept in /root). |
POST | /situs/{id}/pindah/batal | Cancel the move; the site stays on, or goes back to, the old server. |
curl -s -X POST https://app.saka.work/api/v1/situs \
-H "Authorization: Bearer $SAKA_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"nama": "Toko Kue Ibu",
"server_id": "srv_aaaaaaaaaaaaaaaa",
"jenis": "wordpress",
"domain": ["tokokue.id", "www.tokokue.id"],
"php": "8.3",
"bahasa": "en",
"db": "lokal"
}'jenis (type): wordpress, php, or statis (static); a cPanel move uses php with sumber, or with cpanel: {"host", "pengguna", "sandi"}, or "token" instead of the password, plus "abaikan_tls": true for a self-signed certificate. php: 8.2, 8.3 (default), or 8.4. db: lokal (local, default) or klaster (cluster) with klaster_id. The 202 response contains the site with keadaan: "dibuat" (being created); poll GET /situs/{id} until it is siap (ready) or gagal (failed). General details are in the REST API page.
Coming soon
Need something else? Suggest it from the Request a feature menu in the panel (see Feature requests & migration help).