All systems operational 12 elite locations · Europe & Asia Pay with crypto · 0 KYC
Home / Guides / How to Migrate a VPS Without Downtime
Guides

How to Migrate a VPS Without Downtime

VPSbit KVM still: frontal rack with six status-LED units

Move a VPS with no outage: keep both boxes live, stream deltas, drop record lifetimes early, flip writes in one ten-minute window. Core from $4.80/mo.

Short answer

Move a VPS with no outage: keep both boxes live, stream deltas, drop record lifetimes early, flip writes in one ten-minute window. Core from $4.80/mo.

The outage lives in the write flip, not the file copy

Two clocks govern every relocation, and only one of them matters to your visitors. The first clock measures how long the bytes need to cross from the old machine to the new one; it is counted in hours and it punishes nobody. The second clock measures how long the service stutters while you switch over; it is counted in seconds and it defines the project in the memory of everyone who watched it. Keep both machines live, stream deltas from the aging box toward its successor, and confine the stutter to the single instant when you redirect fresh writes — a promotion, a record edit, a configuration toggle.

No volume ever needs detaching, imaging, or carrying across a datacenter floor. The whole method rests on arithmetic you can verify: 10 minutes of rehearsal per move, seconds of measured lag before the flip, and 7 days of overlap insurance afterward. Three venues can absorb the handoff, and a disciplined move commits to exactly one of them before any data travels.

Which route fits depends on how clients locate you. The names-and-caches world is described in DNS, and its lesson is blunt: whatever answer you published yesterday keeps serving until its lease expires, on whatever schedule you granted it. Continuous streaming is the machinery that renders any of those flips inexpensive. The successor ingests a steady diet of deltas — file trees through repeated rsync passes, transactions through the database engine's own change feed, events through whatever queue the stack already runs.

Distance behind the leader becomes your vital sign. Seconds of lag mean a warm standby; minutes mean something upstream stalled; hours mean the schedule quietly collapsed while nobody watched the gauge. The classic blunder is withdrawing the productive machine first. Freezing everything to copy a disk sounds conscientious, yet it turns every latent defect — version skew, missing libraries, stale credentials — into a live incident with an audience. Copying and verifying belong to the rehearsal phase, while the old box still answers; only the flip and the probes behind it earn a named maintenance window.

Two live servers exchanging a continuous stream of change deltas before a handoff

VPS from $4.80* — Core on the annual term (list $6/mo), one invoice for 12 months, no auto-charges. Dedicated with IPMI from $39.20/mo. Crypto invoice, no KYC.

Launch now

Furnish the successor before anything valuable arrives

A vacant server is a trap armed with a schedule. Harden it while it holds nothing, because the moment data lands is the moment your free hours end. Treat baselines as habits rather than archives: you will rebuild this identical setup on some future machine years from now, so make every choice legible, documented, and stored somewhere that outlives the fleet. Everything on this page assumes root on both ends — a managed panel that hides the shell also hides the failure modes this playbook exists to handle.

Package parity comes first: identical daemon generations, not merely identical names, because a mismatched minor version reproduces behavior the source never showed and cannot explain. Match numeric ownership so transferred files keep coherent permissions on arrival; uid 1000 is a convention, not a statute. On a fresh Core plan you have 2 vCPU on a Ryzen 9 9950X, 4 GB of DDR5, and 80 GB of NVMe to mirror onto — confirm the destination's disk meets or exceeds the source before a single byte moves.

Access deserves a private ritual before payloads arrive. Mint a dedicated keypair with ssh-keygen -t ed25519, install the public half into the successor's authorized_hosts, and abolish prompt-based entry while the disk is still empty. Performing this during the handoff instead makes every mistake costly, public, and permanently inscribed in somebody's incident channel. A drifting clock is the quieter trap: every replication protocol gauges distance in timestamps, and a chronometer that wanders fabricates phantom lag out of a healthy feed.

Proof outranks intention. Boot the empty machine, deploy synthetic content, and exercise the whole stack once — interpreter, datastore, cache, scheduler. Missing extensions and absent kernel modules surface here, on a machine where a reinstall costs 10 minutes and a shrug, instead of surfacing during probes with spectators. That single dry pass eliminates the majority of relocation surprises before they cost anything.

Stream deltas until the follower trails by heartbeats

A solitary bulk copy freezes time; replication declines to. The distinction decides whether the destination finishes coherent. One pass across a live datastore slices it into inconsistent strata, while the engine's own change feed replays transactions in commit order and ends with a byte-faithful twin. Directory trees tolerate naive copying; relational engines categorically refuse — hand a live engine a raw file duplicate and it retaliates on the first write, without negotiating.

Filesystems take the undemanding road. A scheduled loop of rsync -aAX --delete every 5 minutes holds drift shallow; the rsync archive switches are what preserve ownership, extended attributes, and sparse files across the wire. PostgreSQL travels farther: pg_basebackup -R seeds a physical twin, primary_conninfo sustains the feed, and pg_stat_replication on the leader discloses replay_lag for every subscriber. MySQL's dialect differs in grammar but not in shape: bootstrap from a consistent snapshot, enroll with CHANGE REPLICATION SOURCE TO carrying the leader's coordinates, then read Seconds_Behind_Source until it settles into single digits.

Catastrophes here carry signatures you can rehearse recognizing. A raw duplicate of live tablespace files yields a plausible-looking volume that corrupts on the first insert — magnitudes match, checksums do not. An inverted --delete target annihilates the destination's own files with consummate politeness. A schedule that expired quietly last Tuesday announces itself only when lag crosses hours, which is why the alarm keys on distance, not on the cron entry's survival.

Wherever an application-level channel exists — append-only journals, queue topics, export hooks — prefer it. The software itself knows which bytes changed, and that knowledge survives refactors that shatter filesystem assumptions entirely. When the follower's worst moment of a routine day stays within seconds of its leader, the destination has stopped being a copy and become a warm standby, which is the precondition every later step presumes.

VPS from $4.80/mo on the annual term — Core lists at $6/mo, one invoice for 12 months, no auto-charges. Dedicated with IPMI from $39.20/mo. Crypto invoice, no KYC, roughly 60 seconds from payment to SSH.

Launch now

Shorten resolver memory a day before the move

Publishing a fresh address is instantaneous; audiences arriving at it are not. Every recursive resolver between your visitors and the zone retains the previous answer until its lease expires, so a record edited at midday keeps dispatching part of your readership toward a machine you already demoted. The size and duration of that leftover crowd were fixed the moment the zone was last touched — by you, weeks ago, invisibly. Registries publish lifetimes; caches enforce them.

One rule renders the timing deterministic: cached lifetimes cannot be abbreviated retroactively. A field presently reading 86400 keeps honoring itself for up to a day after you lower it, which is why the reduction belongs 24 hours ahead of the flip rather than beside it. Stage the descent deliberately — 300 on the prior day, 60 on the morning of the move — and interrogate the live answer with dig +norecurse so you observe what exterior caches actually hold instead of trusting your assumptions about them.

Two RFC habits delimit the boundaries. RFC 2181 untangles lifetime semantics for affirmative answers; RFC 2308 covers the negative kind — resolvers also memorize failures, and a single botched lookup during the switch teaches thousands of caches to keep failing for the stale-response interval. Keep negative answers short across the window and loosen them once the old box retires. If your service publishes AAAA records alongside A records, remember that IPv6 clients follow the same cache discipline on their side of the handshake.

Two failure shapes dominate. Editing lifetimes at flip moment strands a fraction of visitors on the demoted host for hours — the textbook version, recited in every postmortem. The quieter variant: mail exchangers, integration partners, and monitoring vendors run resolvers under private policies, so convergence arrives as a curve rather than an instant. Verify from multiple networks and at least one mobile carrier; your own workstation proves nothing, its cache having been purged by you personally.

The handoff itself: five moves, ten minutes, zero drama

A rehearsed handoff is administrative; an unrehearsed one is theater. Five actions, roughly 10 minutes end to end, and every catastrophe story in relocation folklore begins with one of them being improvised onstage instead of rehearsed twice on a disposable twin. Nothing here is ingenious — the entire discipline consists of refusing to improvise under pressure.

  1. Suspend fresh writes on the incumbent (read_only=ON or maintenance mode).
  2. Drain the terminal deltas until measured lag reads zero.
  3. Redirect: edit the record, promote the replica, or repoint the endpoint.
  4. Probe the write paths: login, purchase, nightly batch, health endpoint.
  5. Observe global convergence from networks you do not control.

Suspending writes is the keystone. Quiesce the incumbent's datastore so closing deltas land against a frozen source and the destination finishes consistent rather than almost-consistent. Skip the freeze and you have manufactured split-brain: two primaries accepting divergent histories, a wound reconciled afterward with exported spreadsheets, apologies, and a week of reconciliation nobody budgeted for. In PostgreSQL, SELECT pg_is_in_recovery(); answering f certifies the successor now leads.

Then probe like an adversary. curl -fk https://example.com/health checks the front entrance, but you also submit the login form, walk one item through purchase, and fire the nightly batch manually. Write paths are what replication stressed; a homepage proves none of them and soothes precisely nobody who matters. Numbers keep you honest: 10 minutes for the window, seconds for lag to settle, one probe round from each vantage network before you call it done.

For the destination itself, secure Core at $6/mo list — $4.80 on the annual term — and keep both invoices alive through the entire window. Deliberate pacing costs pennies per day and rescues evenings. Rehearse the sequence twice against a sacrificial machine and the real event collapses into muscle memory: ten unhurried minutes whose only tension is watching a lag gauge settle to zero.

A control panel showing replication lag settle to zero during a rehearsed cutover window

The incumbent is your insurance; cancel it late

Decommissioning belongs to the same project as the move, on a calendar measured in traffic cycles rather than triumph. Leave the old box powered for at least 7 full days — long enough for weekly jobs, monthly digests, and the one client whose resolver honors ancient answers with religious devotion. Weeks, if the service carries monthly cycles; 7 days is the floor, not the target. Every discovery in that window is trivial while the aged host still answers; after cancellation it degenerates into a support ticket addressed to a wiped volume.

Observe the veteran throughout its retirement, not merely the newcomer. Orphaned schedules betray themselves as outbound mail with nowhere to go — mailq prints the queue at a glance, and crontab -l enumerates what still stirs nightly. Renewal jobs may keep refreshing certificates on the old web root, silently splitting arrivals between two origins; certbot renewal timestamps disclose which box strangers still genuinely visit. Partner firewalls and upstream balancers keep pointing at the source for weeks unless somebody notifies them, and that somebody is you.

Before the plug departs, bank the escape route: a complete snapshot stored off both machines, checksummed so the archive can attest its own integrity afterward, plus the orphan-prone minutiae — job inventories, packet-filter rules, renewal configuration. The reassurance it purchases is simple: restoring beats reconstructing from memory at midnight. A 320 GB NVMe tier holds the snapshot comfortably if you would rather keep the copy on hardware you control.

The purge impulse is the notorious failure: the handoff succeeds Tuesday, cancellation lands Thursday, and Friday hosts the monthly reconciliation job that only ever ran there. Its twin is the forwarding loop — a legacy balancer rule still redirecting toward the newcomer while the newcomer proxies a legacy path, two machines politely bouncing visitors between them until somebody reads access logs line by line. Logs, not memory, decide when the loop actually ceased.

Addresses do not emigrate; plan around the one you leave behind

IPv4 space belongs to networks, not to customers: the address your service answers on is a loan from the old provider's block, and it stays behind at departure. Every relocation therefore contains an embedded address migration, and crews that refuse to admit it meet hardcoded literals — in cron scripts, partner allowlists, monitoring probes — during final checks rather than during planning. That is the costliest conceivable venue for such a discovery, and it is entirely avoidable with a search session.

Most audiences need nothing exotic. The shortened-lifetime record edit from the previous section relocates the name, and the successor's address simply differs; clients that follow names never notice. For the exceptional partner that hard-depends on a constant endpoint — a filter keyed on source, a legacy appliance that ignores names — erect a front porch instead: a proxy or tunnel entrance you administer, stationed ahead of both machines, converting the immovable provider address into a portable one you own.

Rebuild the identity plumbing deliberately: reverse records from the panel if mail participates, sender frameworks naming the fresh address, probe targets and partner filters revised through tickets rather than apologies. Your own terminal objects first — expunge the stale fingerprint with ssh-keygen -R, and resist the campus habit of StrictHostKeyChecking=no, which trades a one-line known-hosts edit for permanent, unexamined credulity. Documentation specimens like 203.0.113.10 serve as search patterns only after you substitute the real departing address.

Where crews stumble: the literal hunt crosses application code but bypasses the periphery — schedules on neighboring servers, the integration runner, the archiver on somebody's laptop. Comb /etc, every readable crontab, and aged tickets; most operators recover two or three forgotten literals this way. Treat the address change as its own deliverable with its own acceptance tests, and the segment everybody dreads becomes the segment nobody remembers.

A network cable moving to a new uplink port as the old address stays behind

Dry-run the whole play against a disposable twin

A relocation performed unrehearsed is a rough draft graded by your users. Rehearsal is affordable precisely because the practice target is expendable: raise a sacrificial twin, execute the entire sequence — furnishing, streaming, lifetime edits, freeze, redirect, probes — and time each movement instead of guessing it. The figures you carry into the real event should be measurements with error bars, never optimism wearing a decimal point.

Timestamp everything. Stamp date -u +%s into the runbook, and keep the runbook itself versioned in git so every rehearsal leaves a dated diff of what ran long, what errored, and how the lag curve genuinely bent. A plan that lives in one administrator's memory rehearses exactly once — at the moment of maximal pressure — which is indistinguishable from never having rehearsed at all. Two passes against the twin are the difference between a schedule and a wish.

Rehearsal output becomes the real schedule. If closing deltas consume 12 minutes and worldwide convergence needs 45, the maintenance window is a defensible figure rather than a hope. Price the tree phase beforehand with rsync --dry-run, and rehearse the retreat as seriously as the advance — restore the archive, repoint the record, certify the veteran still serves — because an untested rollback is a bedtime story, not a procedure anybody can execute under pressure.

Two traps excavate rehearsals from the inside. The first is practicing everything except the write freeze, because pausing an imaginary workload feels theatrical — which leaves the single most consequential lock untested until reality supplies the audience. The second is skipping destination probes because synthetic data is obviously fine, which trains the crew to treat probing as ceremony. Momentum, not malice, causes both; drill the tedious steps hardest, because they are the ones that fail loudly. If the destination deserves bare metal from first boot — whole-core compute, onboard console — order Forge at $49/mo list, $39.20 annual-eff, and drill against it identically; the choreography survives, only the stage changes.

The migration, in the order to run it

Recited end to end: furnish and harden the successor while the incumbent still earns; open the delta streams and supervise lag; shorten resolver lifetimes a day early; execute the five-move handoff; shelter the veteran for a week; archive; retire. The sequence is load-bearing — each stage manufactures the preconditions for the next, and skipping ahead converts minutes of work into nights of recovery. This page was written by somebody who watched an unrehearsed cutover become a weekend; you can borrow the caution wholesale.

Concrete order for the baseline: dedicated keypairs via ssh-keygen -t ed25519, the packet filter expressed as a file loaded with nft -f, unattended-upgrades enrolled, chronometers verified with chronyc tracking. Then movement: rsync -aAX loops for trees, pg_basebackup plus sustained streaming for PostgreSQL, leader-coordinates enrollment for MySQL, alarms keyed on measured lag so silence means health rather than death. The follower attains standby rank when its worst routine lag reads in seconds, not when the initial copy finishes.

On switch morning: freeze writes, drain remnants, redirect by whichever route you chose — record edit, replica promotion, or endpoint repoint — then probe the mutating paths like an intruder and watch convergence from networks you do not personally control. The freeze is sacrosanct; divergent primaries are the one wound this method cannot cheaply heal, and everything else on the inventory exists to make the freeze brief. In the week after, the veteran stays powered, its queues and schedules watched, renewals intact, while forgotten jobs confess themselves one at a time.

Flip routeWhat changesBest forConvergence
Resolver editA / AAAA record after lifetime dropName-based clients, public webMinutes to hours, cache-bound
Replica promotionFollower becomes leaderDatabases with change feedsSeconds, no cache involved
Endpoint repointConfig string in the applicationInternal services, APIsInstant per restart

Where the successor's successor should live — slice or metal — is the question the VPS vs dedicated comparison answers; the choreography between them stays identical either way. Perform the run twice, once against a sacrificial twin and once for the record, and the second rendition runs itself: ten unhurried minutes that feel exactly as rehearsed, which is the entire ambition of this page.

Keep both boxes alive through the window: Core at $6/mo list ($4.80 annual-eff), Prime at $12/mo list ($9.60 annual-eff), Titan at $24/mo list ($19.20 annual-eff) with 320 GB NVMe for snapshot-grade targets. Twelve locations, crypto invoice, no KYC.

Launch now
Can VPSbit migrate my server for me?

No managed relocation service exists — you keep root and this playbook, which is the point of the platform's hands-off model. On dedicated tiers, remote hands (a $24/mo add-on) assist with physical-layer tasks such as reaching a console, while data movement remains entirely your operation from the first rsync pass to the final probe.

How do I move without changing my IP?

You cannot; addresses belong to provider networks and stay behind at departure. Route around it with shortened record lifetimes and a quick edit for name-based clients, or with a proxy and tunnel entrance in front of both machines if a partner genuinely requires the endpoint to stay fixed.

Which migration direction is most common?

Inbound traffic from mainstream clouds toward no-KYC sites, typically over billing or jurisdiction preferences that the <a href='../../offshore-vps/'>offshore VPS guide</a> details. Streaming mechanics run identically in both directions; only onboarding differs — here, a mailbox or token plus a crypto invoice, with no identity documents on either side.

How long should the old server stay online?

No shorter than one complete traffic cycle, ordinarily 7 days, so sluggish clients, patient resolvers, and overlooked schedules all confess while retreat costs one record edit. Bank a checksummed snapshot ahead of decommissioning; regret costs more than the archive ever will.

Does the destination need more disk than the source?

Assume the follower carries a near-whole duplicate, so match or exceed the incumbent's volume before the first byte travels. When a source has outgrown its own storage, a second machine on the 320 GB NVMe tier doubles conveniently as the replication target and the retirement archive in one.

Which plan sizes a rehearsal twin correctly?

Core at $6/mo list ($4.80 annual-eff) rehearses the full choreography for a single-service box; step to Prime at $12/mo list ($9.60 annual-eff) when the stack includes a database worth streaming. Keep both invoices alive through the window — deliberate pacing costs pennies per day and rescues evenings.

Primary sources

More ways to pay

Pay with Bitcoin · Pay with Monero · Pay with USDT (TRC-20/ERC-20/SPL) · Pay with Litecoin · Pay with Ethereum · Pay with Solana · Pay with x402 · Pay with Dogecoin · Pay with XRP · Pay with TRX · Monero on bare metal · Dedicated servers with crypto · Pick the jurisdiction first.

Ready to launch?

Build the box — VPS or bare metal — create the password, pay the invoice that follows.