What is
Brick-Level Mailbox backup?
Brick-Level mailbox
backup is a method in which the backup
program logs on into each mailbox on the
store (by using MAPI, just like Outlook
does) and then backs-up the contents of
the mailboxes to the tape device. Each
mailbox is backed up individually, and
thus restoring a specific mailbox in
case it has been deleted and purged from
the database is easier than before.
Note: Read
Recover a Deleted Mailbox for more info
on how to restore a mailbox that has not
been purged from the database.
Not
every 3rd-Party backup software does
Brick-Level backups, as stated in one of
the vendor's website: The main reasons
for the lack of Brick-Level support are
that a Brick-Level backup is not
designed to fully protect an Exchange
server, just one mailbox at a time. It
is not an alternative to a monolithic
(full) backup/restore. A Brick-Level
restore cannot be used to recover the
Information Store after a disaster. If
used, a Brick-Level backup must be
utilized in conjunction with a
monolithic backup in order to fully
protect the server.
In
order for any 3rd-party backup software
to be able to do Brick-Level backups,
the product would have to backup
multiple copies of the same message. In
other words, it would have to change the
Exchange Single Instance architecture
database. Removing the Single Instance
architecture is possible but it would
mean longer backup time and greater tape
usage.
Single
Instance architecture is a method used
by Exchange to reduce the size of the
database and also to minimize disk space
fluctuation when users read and delete
their mail messages. A case in point is
that when a message is being sent to 100
users. If all 100 users were on the same
server, then Exchange would store only a
single copy in the database, but would
create a pointer in each of the 100
mailboxes that the message was being
sent. When the user reads and deletes
the mail message, only the pointer is
deleted. Without the Single Instance
architecture, 100 copies of the message
would have to be created. More
importantly is that when the users read
and delete the message, it creates
tremendous disk usage fluctuation.
The
problem with Single Instance
architecture is that when you restore a
user's mailbox, you are only restoring
the pointer. Hence, you need to restore
the complete database so that mailbox
pointer would work. In order to restore
a user mailbox, Exchange would have to
restore all messages found on each of
the mailbox pointers. That is very
difficult using tape technology. To
accomplish a complete mailbox restore,
the backup software would have to remove
the Single Instance architecture by
replacing the pointer with the message.
This requires more time for the backup
and also more tapes are used.
Furthermore, by replacing the Single
Instance architecture, what happens if
one needs to restore the whole database?
Will the Single Instance Architecture be
maintained?
As
noted above, Brick-Level backup
capabilities rely on MAPI to access each
mailbox to re-create all of the mailbox
data in the message store. Performance
can be as slow as 8MB/min. If studies
are to be believed, each message is sent
to an average of 4 users. Therefore, the
size of the resulting data-file (it's
not an information store) would increase
dramatically because the notion of a
single-instance does not apply. For
example, using the 4:1 ratio, a 30GB
Information Store could end up occupying
120GB on 3-4 tapes (assuming 40GB
tapes). And that is in addition to the
monolithic backups done for disaster
recovery!
As you
might guess, Brick-Level backups and
restores can easily get out of
proportion, both in time for the backups
to take place, and in space once the
database is restored. (An Exchange
database that was backed up Brick-Level,
when restored, could be about 4 times
larger than it was originally!) |
