When Your Host Is Also Your Registrar, a Fresh Backup Won't Save You Fast

2026-11-17来源 HackerNoonEnglish

What happened

At 01:50 on November 2, Beget posted a short message in its Telegram channel: a "major incident." A few hours later, it said the problem affected every layer of its architecture and that engineers were reconfiguring infrastructure by hand inside the data centers. Around midday it published an official force majeure notice. By Beget's own count, its cloud servers host more than 450,000 websites.

According to that notice, dedicated servers were back, DNS (the NS servers) was the top priority, email had no timeline, and the company could not yet give a date for everything else. Beget names a cyberattack as the cause, and the Coordination Center for .RU/.РФ, which runs the zone, says the same. No technical details have been published. Replying to customers in its official social media group, Beget says its legal position on services and consequences will be set out after the investigation ends.

Any host can have an outage like this. What made it worse for some customers was where their domain lived.

I saw it on two sites, an online store and a content site. Both had hosting and the domain at Beget. Everything stopped at once, and moving out wasn't an option either: the domain is managed from the same control panel that wouldn't load.

Hosting and domain at one company is a single point of failure

Moving a site has two halves. Bring it up on a new server, then tell the domain where the site lives now. The second half happens at the registrar, where the name servers are set.

Run a whois lookup on your domain and check two fields: the registrar and the name servers:

  • Name servers at the failed host, registrar somewhere else. Fixable. Log in to the registrar, point the name servers at a working DNS provider, and recreate the records. You still need a server, but you control the domain.
  • Registrar and host are the same company. Beget is also an accredited registrar for .RU domains, and plenty of hosts everywhere sell domains as a convenience. If their panel is down, there is nowhere to change the name servers. Your backup comes up on a new server and the domain keeps pointing at the old one.

One login for site, backups, DNS, email and domain is convenient until the outage, when it cuts you off from all of them at once.

When the domain expires mid-outage

Beget customers started asking this on day one. Other TLDs have their own grace periods; the registration rules for .RU and .РФ (Russia's Latin and Cyrillic-script country domains) are explicit about theirs, and the shape is worth knowing whatever zone you're in:

  • You get 30 days of priority renewal after expiry. Only the previous holder can renew, and only through their current registrar. After that, the registration is cancelled (clauses 4.5 and 4.9).
  • You can't transfer to another registrar once the registration has expired (clause 7.8). Before expiry, a transfer needs an AuthInfo code (the EPP auth code) from the current registrar (clause 7.5), which is hard to get from a registrar that's offline.
  • The registry may suspend that 30-day clock while a registrar is inactive (clause 4.5). As of November 3, the Coordination Center said it was helping Beget restore infrastructure. No suspension had been announced.

So in practice: check the expiry date in WHOIS, keep dated records of every renewal attempt, and write to both the registrar and the registry if the date passes. Better, renew early. For .RU you can file up to 60 days ahead (clause 4.4). Look up the equivalent rules for your own TLD before you need them.

Three scenarios, depending on what you still have

You have a recent backup outside the host. The good case. Rent a VPS elsewhere, set up the stack, restore files and the database dump, test by IP or through your hosts file, then switch DNS. Before you switch, run through forms, cart and checkout. Plan around size: a 1C-Bitrix store (a CMS widely used for online stores in Russia) with a 100,000+ product catalog takes me about one working day to move. A small WordPress site goes faster.

You have the code but no recent database. Code in Git redeploys anywhere; it holds no state. A store doesn't work without its database, since products, orders and customers live there. What you can do is put up a temporary storefront on the same templates: contacts, main pages, an inquiry form that sends to email or a chat. That keeps paid traffic from landing on a connection error.

You have nothing. Pause your ads first, or the budget keeps paying for an error page. Put a contact page on any working host if you control the domain. The Wayback Machine can give back the text of pages it crawled, with no database, cart or accounts. Google's `cache:` operator was retired in September 2024, so that old trick is gone.

Why your host's backups don't help

When the host is down, its backups are down with it. In the same notice Beget says file backups exist for the vast majority of shared hosting and cloud resources, but restoring from them "will take a long time" because of the volume of data. The copies exist; you get them when your turn in the queue comes.

Two related traps:

  • Replication is not a backup. A replica saves you when a disk dies. A dropped table or encrypted data reaches the replica as fast as any other change.
  • A web server that can delete its own backups. If the storage key on the production box has delete rights, a compromised server means compromised backups.

RPO and RTO: two numbers to agree on

Both are defined in NIST SP 800-34, the federal contingency planning guide.

  • RPO is the point in time to which data must be recovered. Nightly dump, server dies at 6 pm: that day's orders are gone.
  • RTO is how long recovery can take before it hurts the business: download, restore, test, switch DNS. Having a backup says nothing about RTO. The Beget case shows it: the copies exist, the timeline doesn't.

You shrink RPO by copying more often. On PostgreSQL, continuous WAL archiving gives point-in-time recovery, and `archive_timeout` caps how stale unarchived data can get (the docs call about a minute reasonable). You shrink RTO only by restoring on a clean server and timing it.

3-2-1-1-0 for an ordinary website

Veeam extended the classic 3-2-1 rule with one immutable copy and zero restore errors. For a site or a store:

  1. Three copies: the live site plus at least two backups.
  2. Two different media, for example the host's backups plus object storage.
  3. One copy offsite, at a different provider with a different login and contract.
  4. One immutable copy that can't be deleted or overwritten until its retention ends, even with full access to the web server.
  5. Zero errors on restore, checked by restoring on a schedule.

Object Lock, briefly

Per the AWS S3 documentation, Object Lock has two retention modes plus legal hold:

  • Governance: users with `s3:BypassGovernanceRetention` can override it.
  • Compliance: no user can overwrite or delete the locked version, including the account root user. Retention can be extended, not shortened. AWS notes the only way to delete such an object early is to delete the account.
  • Legal hold: no expiry, stays until removed.

It requires a versioned bucket, and once enabled on a bucket it can't be disabled. The flip side of compliance mode: you can't delete those copies either, and you pay to store them. AWS suggests testing in governance mode first. And a write-only key can still upload junk that also gets locked, so watch bucket size.

For ransomware, assume whoever gets into the server gets every key on it. So the key on the server can only `PutObject`, default retention locks every upload automatically, and a separate admin account that never touches production manages the bucket.

The minimum setup (AWS CLI v2)

A working minimum for a MySQL site (WordPress, WooCommerce, Bitrix) backing up to Amazon S3. Treat it as a starting point, not something to paste into production: replace the example names and run it against a test bucket in governance mode first.

Bucket with Object Lock, from an admin machine:

export AWS_PROFILE=backup-admin # never on the web server BUCKET=example-backups REGION=eu-central-1 # for us-east-1, drop --create-bucket-configuration aws s3api create-bucket --bucket "$BUCKET" --region "$REGION" \ --create-bucket-configuration LocationConstraint="$REGION" \ --object-lock-enabled-for-bucket # GOVERNANCE while you test; switch to COMPLIANCE once everything works aws s3api put-object-lock-configuration --bucket "$BUCKET" \ --object-lock-configuration \ '{"ObjectLockEnabled":"Enabled","Rule":{"DefaultRetention":{"Mode":"GOVERNANCE","Days":30}}}' 

The only policy the web server's key gets:

{ "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Action": "s3:PutObject", "Resource": "arn:aws:s3:::example-backups/*" }] } 

Create an IAM user (say `backup-writer`) with that policy and an access key; on the web server the key goes into its own `[backup-writer]` profile in `~/.aws/credentials`. Reads for monitoring and restores go through a separate `ListBucket` + `GetObject` user that also stays off the server.

Nightly backup on the web server, encrypted to a GPG public key whose private half lives elsewhere. The database password sits in `~/.my.cnf`, not in the script:

#!/usr/bin/env bash set -euo pipefail export PATH=/usr/local/bin:/usr/bin:/bin # cron's PATH is minimal BUCKET=example-backups; SITE_DIR=/var/www/example.com DB_NAME=example_db; GPG_RECIPIENT=backup@example.com STAMP=$(date -u +%Y-%m-%dT%H-%M-%SZ) TMP=$(mktemp -d); trap 'rm -rf "$TMP"' EXIT mysqldump --single-transaction --routines --triggers "$DB_NAME" | gzip > "$TMP/db.sql.gz" # Skip caches and Bitrix's own backup archives. # Live site: tar exit 1 (file changed while reading) is not a failure tar -czf "$TMP/files.tar.gz" --warning=no-file-changed -C "$SITE_DIR" \ --exclude='./bitrix/cache' --exclude='./bitrix/managed_cache' --exclude='./bitrix/backup' \ --exclude='./wp-content/cache' . || [ $? -eq 1 ] tar -cf - -C "$TMP" db.sql.gz files.tar.gz \ | gpg --batch --encrypt --recipient "$GPG_RECIPIENT" --trust-model always -o "$TMP/backup.tar.gpg" # Object Lock buckets reject uploads without a checksum aws s3 cp "$TMP/backup.tar.gpg" "s3://$BUCKET/example.com/$STAMP.tar.gpg" \ --checksum-algorithm CRC32 --profile backup-writer 

Last, check the age of the newest backup. The dangerous failure is the silent one: the site runs, and the backup stopped a week ago because a key was revoked or the disk filled up. Run this from a different machine than the web server:

LAST=$(aws s3api list-objects-v2 --bucket example-backups --prefix example.com/ \ --query 'max_by(Contents || `[]`, &LastModified).LastModified' --output text \ --profile backup-reader) || { alert "Could not check backups"; exit 1; } if [ -z "$LAST" ] || [ "$LAST" = "None" ]; then alert "No backups at all"; exit 1; fi AGE_H=$(( ( $(date +%s) - $(date -d "$LAST" +%s) ) / 3600 )) # GNU date if [ "$AGE_H" -gt 26 ]; then alert "Latest backup is $AGE_H hours old"; fi 

`alert` is whatever pings you: a chatbot, email, a pager. Once a month, pull the latest backup onto a clean server, decrypt, restore into a separate database, open the site, and time it start to finish. That's the "0" in 3-2-1-1-0, and the number you get is your actual RTO.

Four questions to ask whoever runs your site

  1. Where are the backups and credentials if the hosting dashboard stops loading? Including registrar, DNS and email.
  2. Who notices if the backup fails three nights in a row, and how?
  3. Can someone who gets into the web server delete the backups, using keys already on that server?
  4. When did anyone last restore the project on a clean server, and how long did it take?

If the answer to the last one is "never," you don't know your RTO, and you'll find it out during the next outage.

原文:https://www.a8q9.cn/en/article/when-your-host-is-also-your-registrar-a-fresh-backup-won-t-save-you-fast-80f148.html

相关文章