Essential Eight: regular backups

Name:

Date:

Class:

Quick Questions

Shade in the A or B circle for each question.

1. A team backs up its project code once a year. Is this a good backup frequency under the Essential Eight?

A No. Backups should be made often enough that little work is lost

B Yes. One backup a year is enough if the file is large

2. Which statement about testing backups is correct?

A Restores should be tested to confirm the backup actually works

B A backup only needs testing if it is used for ransomware

3. Which is the best place to keep a backup of your code repository?

A On the same server as the live repository

B A separate, protected location away from the live system

4. Ransomware encrypts every file on a developer's computer. What does a good backup let the team do?

A Restore clean copies of the files without paying the ransom

B Decrypt the ransomware by running the backup again

5. Which backup is better protected against tampering by an attacker?

A A backup that every developer can edit and delete

B A backup that normal user accounts cannot change or delete

Match the Pairs

Draw a line connecting each item on the left to its match on the right.

Left column		Right column
1backup_schedule = "daily"		AThe backup is far too infrequent, so years of work could be lost. It should run daily or at least regularly, based on how much loss is acceptable.
2restore_test(latest_backup)		BCopies data and code every day, so only a small amount of work is lost if something goes wrong
3Backups should be made often so the amount of lost work after an incident stays small		CRUN backup EVERY night AT 2:00
4Backups must be protected from tampering so ransomware cannot encrypt or delete them		DRestores a backup to check it works before it is needed in an emergency
5backup_schedule = "every 5 years"		EThe backup sits on the same server as the live data and is never tested. Ransomware could encrypt both copies, and the backup may not restore at all. Store it separately and test restores.
6save backup TO live_server; never_test = TRUE		Fbackup.access = "read-only"; backup.copy = "offline"

Definitions

regular backups

Fill in the Blanks

Complete each line of code by filling in the missing parts.

______(codeRepo, offsiteStorage)

backupEveryHours = __

testResult = _______(latestBackup)

backupFile = _______(backupFile, key)

IF backupAgeHours _ maxAgeHours THEN

Spot the Error

Shade in the letter of the line that contains an error.

Question 1

A RUN backup_job

B RUN restore_test ON copy

C IF test_passes THEN alert

D END IF

Question 2

A SET changes TO 'every hour'

B SET max_loss TO 1 hour

C SET backup_gap TO 1 week

Question 3

A backup = copy(data)

B encrypted = encrypt(backup)

C store(encrypted, disk)

D set_access(disk, everyone)

Question 4

A SET schedule TO once per year

B RUN backup_job ON schedule

C RUN restore_test ON schedule

Question 5

A def backup(files, dest):

B for f in files

C shutil.copy(f, dest)

Answer Key

Essential Eight: regular backups

Section A: Quick Questions

A — No. Backups should be made often enough that little work is lost

A — Restores should be tested to confirm the backup actually works

B — A separate, protected location away from the live system

A — Restore clean copies of the files without paying the ransom

B — A backup that normal user accounts cannot change or delete

Section B: Match the Pairs

backup_schedule = "daily" → Copies data and code every day, so only a small amount of work is lost if something goes wrong

restore_test(latest_backup) → Restores a backup to check it works before it is needed in an emergency

Backups should be made often so the amount of lost work after an incident stays small → RUN backup EVERY night AT 2:00

Backups must be protected from tampering so ransomware cannot encrypt or delete them → backup.access = "read-only"; backup.copy = "offline"

backup_schedule = "every 5 years" → The backup is far too infrequent, so years of work could be lost. It should run daily or at least regularly, based on how much loss is acceptable.

save backup TO live_server; never_test = TRUE → The backup sits on the same server as the live data and is never tested. Ransomware could encrypt both copies, and the backup may not restore at all. Store it separately and test restores.

Section C: Definitions

regular backups — An Essential Eight strategy: keep tested, protected copies of data and code, made often, so work can be restored after loss, tampering or ransomware.

Section D: Fill in the Blanks

BACKUP(codeRepo, offsiteStorage)

backupEveryHours = 24

testResult = RESTORE(latestBackup)

backupFile = ENCRYPT(backupFile, key)

IF backupAgeHours > maxAgeHours THEN

Section E: Spot the Error

C — Backups must be tested, and a failed restore test needs attention. The alert should run when the test fails (test_fails), not when it passes.

C — Backup frequency must match how often data changes and how much loss is acceptable. A 1 week gap loses far more than the 1 hour limit. It should be 1 hour or less.

D — Backups must be protected from tampering and theft. Access should be limited to administrators (admins_only), not open to everyone.

A — Regular backups are made often. A yearly schedule would risk losing months of work. The schedule should be frequent, such as every night.

B — A Python for loop header must end with a colon. It should be: for f in files: