XtraBackup.. 1
2 安裝XtraBackup.. 1
2.1 安裝XtraBackup binary版本... 1
2.1.1 yum的安裝方法：... 1
2.1.2 直接下載rpm包安裝... 1
3 XtraBackup使用手冊... 1
3.1 使用innobackupex腳本... 1
3.1.1 備份預備工作... 1
3.1.2 全備和全備還原... 1
3.1.2.1 使用innobackupex創建全備... 1
3.1.2.2 使用innobackupex預備全備... 1
3.1.2.3 使用innobackupex還原備份... 1
3.1.3 增量備份和還原... 1
3.1.3.1 創建增量備份... 1
3.1.3.2 預備增量備份... 1
3.1.3.3 還原增量備份... 1
3.1.3.4 可以使用流做增量備份... 1
3.1.4 部分備份和還原... 1
3.1.4.1 創建部分備份... 1
3.1.4.2 預備部分備份... 1
3.1.4.3 還原部分備份... 1
3.1.5 窄備份... 1
3.1.5.1 創建窄備份... 1
3.1.5.2 預備窄備份... 1
3.1.5.3 還原窄備份... 1
3.1.6 備份加密... 1
3.1.7 其他功能... 1
3.1.7.1 備份壓縮和流... 1
3.1.7.2 在復制環境下備份... 1
3.1.7.3 加速備份進程... 1
3.1.7.4 節流(throttling)備份... 1
3.1.7.5 還原獨立表... 1
3.1.7.6 時間點還原... 1
3.1.7.7 提高對FLUSH TABLES WITH READ LOCK控制... 1
3.1.8 innobackupex工作原理... 1
3.1.9 Reference. 1
3.2 使用Xtrabackup.. 1
3.2.1 選擇bianry. 1
3.2.2 配置Xtrabackup.. 1
3.2.3 創建全備和還原... 1
3.2.3.1 創建全備... 1
3.2.3.2 預備全備... 1
3.2.3.3 還原全備... 1
3.2.4 增量備份和還原... 1
3.2.4.1 增量備份... 1
3.2.4.2 預備增量備份... 1
3.2.5 使用歸檔日志做增量備份... 1
3.2.5.1 原理... 1
3.2.5.2 創建備份... 1
3.2.5.3 使用歸檔日志來預備備份... 1
3.2.6 部分備份和預備... 1
3.2.6.1 備份部分備份... 1
3.2.6.2 預備備份... 1
3.2.7 窄備份和預備... 1
3.2.7.1 創建窄備份... 1
3.2.7.2 預備窄備份... 1
3.2.7.3 備份還原... 1
3.2.8 其他功能... 1
3.2.8.1 節流備份... 1
3.2.8.2 使用腳本調用xtrabackup來執行備份... 1
3.2.8.3 分析表統計信息... 1
3.2.8.4 使用binary log. 1
3.2.8.5 還原單個表... 1
3.2.8.6 LRU dump備份... 1
3.2.8.7 xtrabackup的限制... 1
3.2.8.8 References1
3.2.9 xbstream.. 1
3.2.10 xbcrypt1
3.2.11 Xtrabackup原理... 1
4 如何使用和案例(How-tos and Recipes)1
4.1 innobackupex案例... 1
4.1.1 本地全備(備份，預備，還原)1
4.1.2 使用Stream備份... 1
4.1.3 創建增量備份... 1
4.1.4 創建壓縮備份... 1
4.1.5 備份還原獨立分區... 1
4.1.5.1 創建備份... 1
4.1.5.2 預備備份... 1
4.1.5.3 從備份還原... 1
4.2 xtrabackup案例... 1
4.3 其他案例... 1
4.3.1 六個步驟安裝一個slave. 1
4.3.2 再增加一個slave. 1
4.3.3 使用復制和pt-checksum驗證備份... 1
4.3.4 如何創建基於GTID的Slave. 1
4.4輔助工具手冊... 1
參考... 1
這裡只介紹yum和rpm安裝方法
其他安裝方法查看：
§ Installing Percona XtraBackup from Binaries
§ Compiling and Installing from Source Code
自動
$ rpm -Uhv http://www.percona.com/downloads/percona-release/percona-release-0.0-1.x86_64.rpm
然後會看到：
Retrieving http://www.percona.com/downloads/percona-release/percona-release-0.0-1.x86_64.rpm
Preparing... ########################################### [100%]
1:percona-release ########################################### [100%]
手動
[percona]
name = CentOS $releasever - Percona
baseurl=http://repo.percona.com/centos/$releasever/os/$basearch/
enabled = 1
gpgkey = file:///etc/pki/rpm-gpg/RPM-GPG-KEY-percona
gpgcheck = 1
測試安裝庫
使用yum list | grep percona來確保安裝
yum list | grep percona
會出現以下信息：
percona-release.x86_64 0.0-1 installed
...
Percona-Server-client-51.x86_64 5.1.47-rel11.1.51.rhel5 percona
Percona-Server-devel-51.x86_64 5.1.47-rel11.1.51.rhel5 percona
Percona-Server-server-51.x86_64 5.1.47-rel11.1.51.rhel5 percona
Percona-Server-shared-51.x86_64 5.1.47-rel11.1.51.rhel5 percona
Percona-Server-test-51.x86_64 5.1.47-rel11.1.51.rhel5 percona
...
xtrabackup.x86_64 1.2-22.rhel5 percona
使用wget下載rpm包，然後通過rpm包安裝
參考：http://www.cnblogs.com/cosiray/archive/2012/03/02/2376595.html
innobackupex是perl腳本對xtrabackup的封裝，和功能擴展。
權限和連接
xtrabackup需要連接到數據庫和datadir操作權限。
xtrabackup或者innobackupex在使用過程中設計到2類用戶權限：
1.系統用戶，用來調用innobackupex或者xtrabackup
2.數據庫用戶，數據庫內使用的用戶
連接到服務：innobackupex或者xtrabackup通過—user和—password連接到數據庫服務
$ innobackupex --user=DBUSER --password=SECRET /path/to/backup/dir/
$ innobackupex --user=LUKE --password=US3TH3F0RC3 --stream=tar ./ | bzip2 -
$ xtrabackup --user=DVADER --password=14MY0URF4TH3R --backup --target-dir=/data/bkps/
其他連接選項：
Option
Description
–port
The port to use when connecting to the database server with TCP/IP.
–socket
The socket to use when connecting to the local database.
–host
The host to use when connecting to the database server with TCP/IP.
需要的權限：連接到服務是為了執行備份，需要在datadir上有read，write和execute權限。在數據庫中需要以下權限：
Ÿ RELOAD和LOCK TABLES權限為了執行FLUSH TABLES WITH READ LOCK 。
Ÿ REPLICATION CLIENT為了獲取binary log 位置
Ÿ CREATE TABLESPACE權限為了導入表，用戶表級別的恢復
Ÿ SUPER權限在slave環境下備份用來啟動和關閉slave線程
mysql>CREATEUSER'bkpuser'@'localhost' IDENTIFIED BY's3cret';
mysql>GRANT RELOAD, LOCK TABLES, REPLICATION CLIENT ON*.*TO'bkpuser'@'localhost';
mysql> FLUSH PRIVILEGES;
創建全備
$ innobackupex --user=DBUSER --password=DBUSERPASS /path/to/BACKUP-DIR/
會輸出以下信息
innobackupex: Backup created in directory '/path/to/BACKUP-DIR/2013-03-25_00-00-09'
innobackupex: MySQL binlog position: filename 'mysql-bin.000003', position 1946
111225 00:00:53 innobackupex: completed OK!
從信息中會發現備份被創建在/path/to/BACKUP-DIR/2013-03-25_00-00-09
內部機制：在備份的時候innobackupex會調用xtrabackup來備份innodb表，並復制所有的表定義，其他引擎的表(MyISAM,MERGE,CSV,ARCHIVE)。
其他選項:
--no-timestamp，指定了這個選項備份會直接備份在BACKUP-DIR，不再創建時間戳文件夾。
--default-file，指定配置文件，用來配置innobackupex的選線。
創建完備份之後數據被沒有馬上可以被還原，需要回滾未提交事務，前滾提交事務，讓數據庫文件保持一致性。
innobackupex使用—apply-log來做預備備份
$ innobackupex --apply-log /path/to/BACKUP-DIR
成功則會輸出：
111225 1:01:57 InnoDB: Shutdown completed; log sequence number 1609228
111225 01:01:57 innobackupex: completed OK!
成功後，備份可以被用來還原數據庫了。
內部機制：讀取備份文件夾中的配置文件，然後innobackupex重做已提交事務，回滾未提交事務，之後數據就被寫到了備份的數據文件(innodb文件)中，並重建日志文件。這一步隱式調用了2次xtrabackup –prepare。跟多關於xtrabackup可以看之後的章節。
其他選項：
--user-memory：指定預備階段可使用的內存，內存多則速度快，默認為10MB
$ innobackupex --apply-log --use-memory=4G /path/to/BACKUP-DIR
使用innobackupex --copy-back來還原備份
$ innobackupex --copy-back /path/to/BACKUP-DIR
會根據my.cnf復制所有備份到datadir下：
innobackupex: Finished copying back files.
111225 01:08:13 innobackupex: completed OK!
注：datadir必須是為空的，innobackupex –copy-back不會覆蓋已存在的文件，還要注意，還原時需要先關閉服務，如果服務是啟動的，那麼就不能還原到datadir。
之後需要修改文件的所有者和權限：
$ chown -R mysql:mysql /var/lib/mysql
增量備份呢是為了減少空間使用和備份的時間。
增量備份的實現，依賴於innodb頁上面的LSN（log sequence number），每次對數據庫的修改都會導致LSN自增。
增量備份會復制指定LSN之後的所有數據頁。
創建全備
在創建增量備份之前需要一個全備，不然增量備份是沒有意義的。
$ innobackupex /data/backups
這樣就會在/data/backups下創建一個時間戳文件夾，如 /data/backups/2013-03-31_23-01-18，然後文件夾內是備份文件。
檢查備份文件夾下的xtrabackup-checkpoints，會有一下信息：
backup_type = full-backuped
from_lsn =0
to_lsn =1291135
創建第一個增量備份
然後使用—incremental創建增量備份
$ innobackupex --incremental /data/backups --incremental-basedir=BASEDIR
BASEDIR指向之前的全備， /data/backups/2013-03-31_23-01-18，成功後備份會生成在/data/backups下的時間戳目錄中，如：/data/backups/2013-04-01_23-01-18 ，把這個目錄叫為記為 INCREMENTAL-DIR-1方面之後使用。
然後查看xtrabackup-checkpoints:
backup_type = incremental
from_lsn =1291135
to_lsn =1352113
可以發現和全備不同的是，backup_type為incremental，from_lsn不為0。
然後再創建一個增量備份
在INCREMENTAL-DIR-1的基礎上再創建一個增量備份，記為INCREMENTAL-DIR-2。
$ innobackupex --incremental /data/backups --incremental-basedir=INCREMENTAL-DIR-1
增量備份替代方法
可以使用指定—incremental-lsn來代替—incremental-basedir的方法創建增量備份。
innobackupex --incremental /data/backups --incremental-lsn=1291135
innobackupex --incremental /data/backups --incremental-lsn=1358967
注意：xtrabackup只會影響xtradb或者innodb的表，其他引擎的表在增量備份的時候只會復制整個文件，不會差異。
預備增量備份需要2個步驟：
1.需要先預備全備，但是只重做已提交事務，不回滾未提交事務，然後應用到全備，也是只重做已提交事務，不回滾未提交事務
2.回滾未提交事務
如果已經回滾了未提交事務，那麼就無法再應用增量備份。
注：在mariadb 10.0 上測試發現不加—redo-only預備全備，然後使用 –redo-only應用增量備份，mysql服務能夠正常啟動並且數據被成功還原
在全備上，使用—redo-only只做已提交事務，不回滾未提交事務
innobackupex --apply-log --redo-only BASE-DIR
會出現以下結果：
120103 22:00:12 InnoDB: Shutdown completed; log sequence number 1291135
120103 22:00:12 innobackupex: completed OK!
應用第一個增量備份
innobackupex --apply-log --redo-only BASE-DIR --incremental-dir=INCREMENTAL-DIR-1
輸出結果，注意LSN的變化：
120103 22:08:43 InnoDB: Shutdown completed; log sequence number 1358967
120103 22:08:43 innobackupex: completed OK!
如果沒有指定—incremental-dir，那麼innobackupex會使用最近的一個在basedir中被創建的子目錄。
應用另外一個備份
innobackupex --apply-log BASE-DIR --incremental-dir=INCREMENTAL-DIR-2
因為是最後一個增量備份所以沒有必要再加—redo-only，這樣最後一個增量也被應用到全備上了。
注：--redo-only除了最後一個不用加之外，其他的增量應用都要加，最後一個應用的時候可以直接進入回滾未提交事務階段。如果加了也沒事兒，服務啟動的時候會進入recovery過程，來回滾
需要注意的是，應用增量備份的時候只能按照備份的順序來應用。如果應用順序錯誤，那麼備份就不可用。如果無法確定順序，可以使用xtrabackup-checkpoints來確定順序。
回滾未提交事務
當應用完所有增量備份的時候，就需要回滾所有為完成事務（如果最後一步加了 –redo-only就需要回滾未提交，不執行的話在服務啟動階段服務會處理未提交事務）。
innobackupex --apply-log BASE-DIR
Note that the iblog* files will not be created by innobackupex, if you want them to be created, use xtrabackup –prepareon the directory. Otherwise, the files will be created by the server once started.
注：
文中提到innodb事務日志(iblog*)不會被創建，但是測試下使用了最後一步回滾未提交事務發現有iblog*文件，而且上文提到 innobackupex會隱式執行兩次 xtrabackup –prepare，在下文介紹xtrabackup時會提到，執行2次xtrabackup –preare會創建iblog*文件，與文中提到不符。
還原增量備份其實和還原全備一樣
innobackupex --copy-back BASE-DIR
注意事項可以看：使用innobackupex還原備份
先進行一個全備：
innobackupex /data/backups
使用本地：
innobackupex --incremental --incremental-lsn=LSN-number --stream=xbstream ./ > incremental.xbstream
解包方法
xbstream -x < incremental.xbstream
使用本地備份流到遠程並解包
innobackupex --incremental --incremental-lsn=LSN-number --stream=xbstream ./ | /
ssh user@hostname " cat - | xbstream -x -C > /backup-dir/"
xtrabackup可以使用部分備份，但是只能在一個表一個文件的狀況下才能使用，設置mysql選項：innodb_file_per_table。
還原部分備份使用表導入的方式，而不是—copy-back選項。
盡管很多場景下可以通過直接復制文件的方式，但是會產生一致性問題不建議使用。
部分備份有3個選項可以使用：
--include:設置正則表達式的格式，匹配的就備份
--table-file:在文件中指定要備份的表，然後通過這個選項傳入文件
--database:指定數據庫列表
使用include方式
include 方式數據庫名也可以匹配：
$ innobackupex --include='^mydatabase[.]mytable' /path/to/backup
這個選項是傳給xtrabackup –tables，所有的數據庫目錄都會被創建，但是裡面可能是空的。
使用tables-file方式
如:
$ echo "mydatabase.mytable" > /tmp/tables.txt
$ innobackupex --tables-file=/tmp/tables.txt /path/to/backup
這個選項是應用xtrabackup –tablefile，只有匹配到表的數據庫目錄才會被創建
使用database方式
innobackupex可以傳遞用空格隔開的數組，格式為：databasename[.tablename]
$ innobackupex --databases="mydatabase.mytable mysql" /path/to/backup
注意：--databasees選項只會對非innodb引擎表和frm文件產生影響，對於innodb數據文件總是備份的
部分備份的預備需要使用—export：
$ innobackupex --apply-log --export /path/to/partial/backup
會出現以下，是因為innodb表保存了數據文件但是沒有保存frm文件。
111225 0:54:06 InnoDB: Error: table 'mydatabase/mytablenotincludedinpartialb'
InnoDB: in InnoDB data dictionary has tablespace id 6,
InnoDB: but tablespace with that id or name does not exist. It will be removed from data dictionary.
之後會發現生成了.exp和.cfg文件。exp文件適用於percona server，cfg適用於mariadb和mysql。mariadb 10.0可以直接通過ibd和frm文件import。mysql 5.6之後可以不使用cfg來進行import，cfg如果存在會被用來做表結構的驗證。
在已經預備好的備份上，可以使用—export和—apply-log創建.exp文件。
先創建一個表，表結構需要和被還原的一樣。
OTHERSERVER|mysql> CREATE TABLE mytable (...) ENGINE=InnoDB;
然後discard表空間
OTHERSERVER|mysql> ALTER TABLE mydatabase.mytable DISCARD TABLESPACE;
之後把文件復制到相應的目錄下（注意文件的所有者和文件權限），需要文件.ibd,.exp或者.cfg文件(.cfg文件用戶mysql5.6)。
然後import表空間
OTHERSERVER|mysql> ALTER TABLE mydatabase.mytable IMPORT TABLESPACE;
窄備份指不備份secondary索引數據。這樣可以減少備份的大小。缺點就是需要重建索引，會很慢。
$ innobackupex --compact /data/backups
創建了之後查看xtrabackup_checkpoint
backup_type = full-backuped
from_lsn =0
to_lsn =2888984349
last_lsn =2888984349
compact =1
compact=1說明該備份是窄備份。
在預備窄備份的時候需要使用—rebuild-indexes來重新創建索引
$ innobackupex --apply-log --rebuild-indexes /data/backups/2013-02-01_10-29-48
從輸出上可以看到索引被重建
130201 10:40:20 InnoDB: Waiting for the background threads to start
Rebuilding indexes for table sbtest/sbtest1 (space id: 10)
Found index k_1
Dropping 1 index(es).
Rebuilding 1 index(es).
Rebuilding indexes for table sbtest/sbtest2 (space id: 11)
Found index k_1
Found index c
Found index k
Found index c_2
Dropping 4 index(es).
Rebuilding 4 index(es).
對於增量備份的應用可以先不重建索引，在應用最後一個差異備份的時候使用—rebuild-index來創建索引，每次都應用都重建索引太花時間。
注意：為了重建速度，可以使用並發創建索引，使用參數—rebuild-threads指定並發數。
窄備份還原和全備還原一樣直接使用—copy-back選項。
具體看：使用innobackupex還原備份
具體看：Encrypted Backups
Stream模式下，Xtrabackup的STDOUT可以指定tar或者xbstream格式輸出。
流允許，其他程序過濾備份輸出，提供更大的靈活存儲backup。
使用流特性，需要指定—stream選項
$ innobackupex --stream=tar /tmp
innobackupex會用子程序啟動xtrabackup –log-stream 定向到臨時文件，然後使用xbstream把所有數據文件steam到STDOUT。
當壓縮啟動，xtrabackup壓縮所有輸出數據，但是元數據和非innodb文件不能被壓縮。現在唯一支持的壓縮算法是quicklz。會生產qpress歸檔格式的文件。
使用xbstream可以平法復制壓縮可以提高備份速度。
使用xbstream流備份：
$ innobackupex --stream=xbstream /root/backup/ > /root/backup/backup.xbstream
使用流壓縮:
$ innobackupex --stream=xbstream --compress /root/backup/ > /root/backup/backup.xbstream
解包：
$ xbstream -x < backup.xbstream -C /root/backup/
流壓縮並備份到另外一台機器：
$ innobackupex --compress --stream=xbstream /root/backup/ | ssh user@otherhost "xbstream -x -C /root/backup/"
使用tar備份：
$ innobackupex --stream=tar /root/backup/ > /root/backup/out.tar
使用tar流並備份到其他服務器
$ innobackupex --stream=tar ./ | ssh user@destination \ "cat - > /data/backups/backup.tar"
提取tar流，需要加i參數
$ tar -xizf backup.tar.gz
也可以壓縮流
$ innobackupex --stream=tar ./ | gzip - > backup.tar.gz
$ innobackupex --stream=tar ./ | bzip2 - > backup.tar.bz2
有2個選項用於從復制環境下備份
slave-info
--slave-info，會打印binary log的位置和master server名，並且以change master的方式寫到xtrabackup_slave_info中。
safe-slave-backup
--safe-slave-backup,為了保證復制狀態的一致性，這個選項會關閉slave sql線程，等待直到SHOW STATUS 中的Slave_open_temp_tabls為了才啟動備份。如果等待時間超過—safe-slave-backup-timeout就會報錯默認300秒。備份成功後 slave sql thread會自動啟動。
使用parallel和compress-threads加速
當有多個文件時，可以使用使用—parallel加速備份，這個選項會指定xtrabackup備份文件的線程數。
$ innobackupex --parallel=4 /path/to/backup
如果使用xbstream可以考慮通過—compress-threads加速壓縮進程，默認為1.
$ innobackupex --stream=xbstream --compress --compress-threads=4 ./ > backup.xbstream
使用rsync加速
為了加速復制過程，最小化FLUSH TABLES WITH READ LOCK堵塞時間，使用innobackupex –rsync。使用了這個選項所有文件都會在一個cp命令裡面，而不是每個文件一個cp。並且innobackupex會調用2次 rsync，一次在執行FLUSH TABLES WITH READ LOCL之前，一次在之後。第二次執行的時候會把第一次之後的修改過的數據。
盡管innobackupex不會堵塞數據庫操作，但是備份終會消耗系統資源。為了減少資源消耗，可以使用—throttle來限制每秒鐘讀寫對次數。
使用xtrabackup來導出指定表，然後導入到XtraDB或者Mysql 5.6（測試可以的導入mariadb 10.0）
mariadb 10.0可以直接復制 ibd然後通過import tablespace倒入。
導出表
導出表使用—export選項：
$ innobackupex --apply-log --export /path/to/backup
會在發現多了一個.exp文件和.cfg文件(用於不同的mysql版本)
$ find /data/backups/mysql/ -name export_test.*
/data/backups/mysql/test/export_test.exp
/data/backups/mysql/test/export_test.ibd
/data/backups/mysql/test/export_test.cfg
導入表
先創建一個表，表結構需要和被還原的一樣。
OTHERSERVER|mysql> CREATE TABLE mytable (...) ENGINE=InnoDB;
然後discard表空間
OTHERSERVER|mysql> ALTER TABLE mydatabase.mytable DISCARD TABLESPACE;
之後把文件復制到相應的目錄下（注意文件的所有者和文件權限），需要文件.ibd,.exp或者.cfg文件(.cfg文件用戶mysql5.6)。
然後import表空間
OTHERSERVER|mysql> ALTER TABLE mydatabase.mytable IMPORT TABLESPACE;
和mysql手冊中介紹的時間點還原一樣，xtrabackup也是通過binary log進行時間點還原。
先進行備份
$ innobackupex /path/to/backup --no-timestamp
然後進行預備
$ innobackupex --apply-log /path/to/backup
在服務器中找出操作binary log和當前binary log狀態
mysql> SHOW BINARY LOGS;
+------------------+-----------+
| Log_name | File_size |
+------------------+-----------+
| mysql-bin.000001 | 126 |
| mysql-bin.000002 | 1306 |
| mysql-bin.000003 | 126 |
| mysql-bin.000004 | 497 |
+------------------+-----------+
mysql> SHOW MASTER STATUS;
+------------------+----------+--------------+------------------+
| File | Position | Binlog_Do_DB | Binlog_Ignore_DB |
+------------------+----------+--------------+------------------+
| mysql-bin.000004 | 497 | | |
+------------------+----------+--------------+------------------+
然後查看 xtrabackup_binlog_info確定備份的binary log位置：
$ cat /path/to/backup/xtrabackup_binlog_info
mysql-bin.000003 57
還原數據庫
$ innobackupex --copy-back /path/to/backup
然後使用mysqlbinlog取出binary log中的記錄，然後輸出到文件
$ mysqlbinlog /path/to/datadir/mysql-bin.000003 /path/to/datadir/mysql-bin.000004 \
--start-position=57 > mybinlog.sql
然後檢查輸出的文件，確定要恢復到的位置，然後執行恢復
$ mysqlbinlog /path/to/datadir/mysql-bin.000003 /path/to/datadir/mysql-bin.000004 \
--start-position=57 --stop-datetime="11-12-25 01:00:00" | mysql -u root -p
在備份的時候，為了保證數據一致性，在備份非innodb表的之前會先使用FLUSH TABLES WITH READ LOCK，這個語句在有長時間查詢運行的情況下也能執行，但是其他的所有事都會被堵塞，Waiting for table flush或者Waiting for master to send event，這個時候不應該kill FLUSH TABLES WITH READ LOCK，而是應該kill掉那個大的查詢。因為當有大的查詢的時候，FLUSH TABLES WITH READ LOCK會被卡住。
為了能夠避免這種事情發生需要實現2個事情：
1.innobackupex等一個好的時機運行
2.innobackupex可以kiil 所有查詢或者只能存在SELECT查詢。即kill所有阻止獲取全局鎖的查詢。
等待查詢完成
為了避免innobackupex等待FLUSH TABLES WITH READ LOCK執行太長時間，可以使用innobackupex –lock-wait-timeout，可以用來限制等待時間，一旦超時就會報錯退出。
另外一個是設置等待查詢的類型，innobackupex --lock-wait-query-type 可取的值是all或者update，如果為all那麼會等待所有長運行查詢完成，如果是update，會等待除select之外的DML完成。
--lock-wait-threshold用來定義 --locl-wait-query-type中的長運行查詢，如果超過--lock-wait-threshold都算長運行查詢。
Kill堵塞查詢
innobackupex可以kill所有阻止獲取全局鎖的查詢。
可以通過指定--kill-long-queries-timeout用來指定執行FLUSH TABLES WITH READ LOCK後還可以執行的時間，0為不kill，--kill-long-query-type用來指定超時之後，kill的查詢類型，可以是all或者select。
例如：
$ innobackupex --lock-wait-threshold=40 --lock-wait-query-type=all --lock-wait-timeout=180 --kill-long-queries-timeout=20 --kill-long-query-type=all /data/backups/
innobackupex是perl腳本，封裝了xtrabackup和tar4ibd的功能。
備份
如果沒有指定，innobackupex默認認為是備份模式。
默認innobackupex會以--suspend-at-end啟動xtrabackup，來復制innodb文件。當xtrabackup復制完成，innobackupex發現創建的xtrabckup_suspended_2文件，就執行FLUASH TABLES WITH READ LOCL復制其他文件。
xtrabackup的確定，如果運行的時候沒有帶ibbackup參數，那麼innobackupex會從xtrabackup_binary上找，然後讀取要啟動xtrabackup的二進制文件。否則只能通過連接mysql服務確定使用的二進制文件。如果不能連接就錯誤。
決定好二進制文件之後，斷開連接以二進制方式啟動binary。
如果不是增量備份，連接到服務，如果啟動了--safe-slave-backup等待slave，然後獲取全局read lock，防止其他引擎的表被修改，讀鎖只鎖定非innodb表，並且在innodb表復制完數據和日志後進行。
當所有文件備份完之後，恢復ibbackup並等待完成對事務復制，復制在備份期間生產的事務。然後釋放表鎖，slave啟動並且連接關閉，然後刪除xtrabckup_suspended_2文件。
還原
還原數據庫使用 --copy-back選項
innobackupex通過讀取my.cnf中的 datadir, innodb_data_home_dir, innodb_data_file_path,innodb_log_group_home_dir並檢查目錄是否存在。
然後復制MyISAM表，索引，然後復制innodb表和索引，最後日志文件。復制的時候會保留文件屬性，需要修改用戶所有者。
恢復除了--cop-back也可以使用--move-back，不同的是一個是復制，一個是移動。
主要介紹一些選項：The innobackupex Option Reference
Xtrabackup有4個binary：Xtrabackup，Xtrabackup_51，Xtrabackup_55，Xtrabackup_56。
服務和binary對照：
Server
xtrabackup binary
MySQL 5.1.*
xtrabackup_51
MySQL 5.1.* with InnoDB plugin
xtrabackup
MySQL 5.5.*
xtrabackup_55
MySQL 5.6.*
xtrabackup_56
MariaDB 5.1.*
xtrabackup
MariaDB 5.2.*
xtrabackup
MariaDB 5.3.*
xtrabackup
MariaDB 5.5.*
xtrabackup_55
MariaDB 10.0.*
xtrabackup_56
Percona Server 5.0
xtrabackup_51
Percona Server 5.1
xtrabackup
Percona Server 5.5
xtrabackup_55
Percona Server 5.6
xtrabackup_56
所有的Xtrabackup配置都是通過選項設置，可以是命令行參數，也可以通過配置文件my.cnf。
xtrabackup會讀取[mysql],[xtrabackup]選項，若Xtrabackup讀入，會覆蓋[mysqld]的選項。
並不是所有的配置都要寫入配置文件，寫配置文件只是為了方便。
xtrabackup 並不接受和mysqld一樣的語法，有些語法不支持如，--set-variable=<variable>=<value>要用 --variable=value語法。
xtrabackup並不需要特殊的存儲，但是如果是NFS並不是以sync掛載，那麼在執行fsync的時候可能並不是真正的同步數據。
使用xtrabackup創建全備需要指定選項-backup，還需要指定--target_dir，如果target不存在，會創建一個，如果存在那麼如果是空的就會成功，如果不是空的，不會覆蓋已存在文件，並且報錯。
主要完成2個任務：
1.開啟一個log copy線程，用來監控innodb日志文件(ib_logfile*),如果修改就復制到xtrabackup_logfile，因為復制會持續很長時間，所以恢復進程需要所有從備份開始到結束的所有日志。
2.復制innodb數據文件到目標目錄，這個並不是簡單的復制，是和innodb引擎一樣，從數據目錄中一頁一頁的復制。
當數據文件完成復制，xtrabackup會停止對日志的復制，並在目標目錄中創建xtrabackup_checkpoint文件。
$ xtrabackup --backup --datadir=/var/lib/mysql/ --target-dir=/data/backups/mysql/
在備份輸出的時候，可以看到日志的復制。
>> log scanned up to (3646475465483)
>> log scanned up to (3646475517369)
>> log scanned up to (3646475581716)
>> log scanned up to (3646475636841)
>> log scanned up to (3646475718082)
>> log scanned up to (3646475988095)
>> log scanned up to (3646476048286)
>> log scanned up to (3646476102877)
>> log scanned up to (3646476140854)
[01] Copying /usr/local/mysql/var/ibdata1
to /usr/local/mysql/Backups/2011-04-18_21-11-15/ibdata1
[01] ...done
注意：日志復制線程是每秒檢查一次，查看是否有新的日志被寫入，因為日志文件是被回繞寫的，所以日志復制線程要更上日志文件的修改，如果沒有復制日志被覆蓋了，那麼就會報錯。
備份的時間長短依賴於數據庫的大小，然後時間都可以停止數據庫，因為不會去修改數據庫數據。
備份完數據庫之後，下一步是預備數據庫，因為數據文件在某個時間點上，並不是一致的，所以需要預備讓數據文件在某個時間點一致，--prepare就是來完成，讓數據文件保持一致性。
注意：在innobackupex --apply-log的時候，innodb就是自動讀取配置文件back-my.cnf就是使用--defaults-file=xxx來指定一個配置文件，傳遞給xtrabackup用於預備數據庫備份。
可以在任何機器上進行預備，沒必要在原服務器或者要還原的服務器上進行。
在恢復階段，xtrabackup嵌入了修改過的innodb，禁止了innodb的標准安全監察，如日志文件大小是否准確。
prepare階段就是使用這個嵌入的innodb來做通過日志文件對數據文件進行crash恢復。
xtrabackup --prepare --target-dir=/data/backups/mysql/
當預備完成就會有以下輸出：
101107 16:40:15 InnoDB: Shutdown completed; log sequence number <LSN>
現在備份一致性已經沒問題了，可以准備還原，但是為了能夠更快還原，可以再執行一次預備，第一次執行的時候只讓數據文件保持一致性，並沒有創建日志文件。第二次執行的時候會創建日志文件。如果第一次預備後還原，啟動服務，服務會自動創建日志文件，但是比較滑時間。當第二次運行預備的時候有一下輸出:
$ xtrabackup --prepare --target-dir=/data/backups/mysql/
xtrabackup: This target seems to be already prepared.
xtrabackup: notice: xtrabackup_logfile was already used to '--prepare'.
101107 16:54:10 InnoDB: Log file ./ib_logfile0 did not exist: new to be created
InnoDB: Setting log file ./ib_logfile0 size to <SIZE> MB
InnoDB: Database physically writes the file full: wait...
101107 16:54:10 InnoDB: Log file ./ib_logfile1 did not exist: new to be created
InnoDB: Setting log file ./ib_logfile1 size to <SIZE> MB
InnoDB: Database physically writes the file full: wait...
101107 16:54:15 InnoDB: Shutdown completed; log sequence number 1284108
如果是第二次運行，運行時會有以下提示：
xtrabackup: This target seems to be already prepared.
xtrabackup: notice: xtrabackup_logfile was already used to '--prepare'.
不推薦在執行預備的時候終端過程，這樣可能會導致數據文件異常。
如果視圖要加入增量備份，那麼使用--apply-log-only，不然加不上增量備份。
xtrabackup沒有什麼功能來還原備份，可以直接通過rsync，cp來還原數據庫
注意：注意保持datadir必須是空的，並且mysql服務是停止的。不能還原到已經在運行的mysql服務中。
通過rsync還原：
$ rsync -avrP /data/backup/ /var/lib/mysql/
還原後注意修改所有者
$ chown -R mysql:mysql /var/lib/mysql
注意：xtrabackup只備份innodb數據文件，不會備份其他引擎的表，和frm文件。如果要對整個庫備份還原可以使用innodbbackupex
增量備份原理
xtrabackup和innobackupex都可以實現增量備份，也就是說只備份修改過的數據。
增量備份實現，依賴於innodb頁中的LSN(log sequence number)增量備份會復制比之前的增量或者全備新的lsn頁。
有2個算法找這樣的頁：
1.直接掃描數據頁，並復制大於上次全備或者增量的lsn的頁
2.類似percona server，啟動 changed page tracking 會記錄頁的修改。這樣的記錄會被保存在一個map文件中。xtrabackup會使用這個文件讀取需要備份的頁數據。當然也可以使用--incremental-force-scan強制掃描所有數據頁。
增量備份並不是比較全備的數據，如果沒有上次的備份，可以使用指定--incremental-lsn來進行增量備份。增量備份只會備份比指定lsn大的數據頁。當然需要全備來還原增量備份，不然增量備份是沒有意義的。
創建增量備份
首先創建全備
xtrabackup --backup --target-dir=/data/backups/base --datadir=/var/lib/mysql/
查看xtrabackup_checkpoint信息：
backup_type = full-backuped
from_lsn =0
to_lsn =1291135
然後進行增量備份：
xtrabackup --backup --target-dir=/data/backups/inc1 \
--incremental-basedir=/data/backups/base --datadir=/var/lib/mysql/
在/data/backups/inc1下包含了delta文件，如果ibdata1.delta和test/table1.ibd.delta，檢查增量備份的xtrabackup_checkpoint：
backup_type = incremental
from_lsn =1291135
to_lsn =1291340
在做一個增量備份：
xtrabackup --backup --target-dir=/data/backups/inc2 \
--incremental-basedir=/data/backups/inc1 --datadir=/var/lib/mysql/
預備增量備份和在innobackupex一樣，先不回滾方式應用全備，然後應用增量備份。
在innobackupex上使用 --apply-log-only來重做，但不回滾。
現在已有備份：
/data/backups/base
/data/backups/inc1
/data/backups/inc2
預備全備，不回滾未提交事務：
xtrabackup --prepare --apply-log-only --target-dir=/data/backups/base
成功後輸出：
101107 20:49:43 InnoDB: Shutdown completed; log sequence number 1291135
應用第一個增量備份：
xtrabackup --prepare --apply-log-only --target-dir=/data/backups/base \
--incremental-dir=/data/backups/inc1
增量備份被應用到/data/backups/base，應用後輸出：
incremental backup from 1291135 is enabled.
xtrabackup: cd to /data/backups/base/
xtrabackup: This target seems to be already prepared.
xtrabackup: xtrabackup_logfile detected: size=2097152, start_lsn=(1291340)
Applying /data/backups/inc1/ibdata1.delta ...
Applying /data/backups/inc1/test/table1.ibd.delta ...
.... snip
101107 20:56:30 InnoDB: Shutdown completed; log sequence number 1291340
應用最後一個增量備份：
xtrabackup --prepare --target-dir=/data/backups/base \
--incremental-dir=/data/backups/inc2
注意：除了最後一個外其他的都要使用--apply-log-only，如果最後一個也用了--apply-log-only，就還原了文件還是一直的，但是沒有回滾未提交事務，當服務啟動的時候會自動回滾未提交事務。
在percona server 5.6.11-60.3加入了新功能，為xtradb日志歸檔，這個功能是，在老的日志文件被重寫之前會被復制，因此保存了所有的redo日志。
歸檔日志的文件格式，ib_log_archive_<LSN>，LSN表示這個歸檔文件開始的lsn。
ib_log_archive_00000000010145937920
ib_log_archive_00000000010196267520
這個功能由innodb_log_archive啟動，保存的位置為innodb_log_arch_dir(默認為數據文件夾)。
創建一個全備
xtrabackup_56 --backup --target-dir=/data/backup/ --datadir=/var/lib/mysql/
xtrabackup_checkpoint如下：
backup_type = full-backuped
from_lsn =0
to_lsn =1546908388
last_lsn =1574827339
compact =0
xtrabackup_56 --prepare --target-dir=/data/backup/ --innodb-log-arch-dir=/data/archived-logs/
執行後查看xtrabackup_checkpoint，backup-type被修改：
backup_type = full-prepared
from_lsn =0
to_lsn =1546908388
last_lsn =1574827339
compact =0
另外也可以指定時間點預備：
xtrabackup_56 --prepare --target-dir=/data/backup/ --innodb-log-arch-dir=/data/archived-logs/ --to-archived-lsn=5536301566
當服務使用innodb_file_per_table的時候，xtrabackup支持部分備份。
使用--tables進行部分備份
使用--tables備份，該選項的值是一個正則表達式，匹配的表名都會被備份。
備份test下的所有表：
$ xtrabackup --backup --datadir=/var/lib/mysql --target-dir=/data/backups/ \
--tables="^test[.].*"
備份test.t1表
$ xtrabackup --backup --datadir=/var/lib/mysql --target-dir=/data/backups/ \
--tables="^test[.]t1"
使用--tables-file進行備份
--tables-file指向一個選項包了表名，如：
$ echo “mydatabase.mytable” > /tmp/tables.txt $ xtrabackup –backup –tables-file=/tmp/tables.txt
在prepare的時候會出現很多warnings，是因為表存在在innodb，但是對於的ibd不存在，這些表在還原備份啟動innodb的時候會被刪除。
InnoDB: Reading tablespace information from the .ibd files...
101107 22:31:30 InnoDB: Error: table 'test1/t'
InnoDB: in InnoDB data dictionary has tablespace id 6,
InnoDB: but tablespace with that id or name does not exist. It will be removed from data dictionary.
窄備份是在備份的是否不備份secondary index讓備份文件邊小。窄備份可以通過--compact啟動。
$ xtrabackup --backup --compact --target-dir=/data/backups
查看備份後的xtrabackup_checkpoint，compact為1說明是窄備份
backup_type = full-backuped
from_lsn =0
to_lsn =2888984349
last_lsn =2888984349
compact =1
在預備的時候為了重建索引，需要使用選項--rebuild-indexes
$ xtrabackup --prepare --rebuild-indexes /data/backups/
輸出：
[01] Checking if there are indexes to rebuild in table sakila/city (space id: 9)
[01] Found index idx_fk_country_id
[01] Rebuilding 1 index(es).
[01] Checking if there are indexes to rebuild in table sakila/country (space id: 10)
[01] Checking if there are indexes to rebuild in table sakila/customer (space id: 11)
[01] Found index idx_fk_store_id
[01] Found index idx_fk_address_id
[01] Found index idx_last_name
[01] Rebuilding 3 index(es).
使用--rebuild-threads指定重建的線程數，加快重建速度：
$ xtrabackup --prepare --rebuild-indexes --rebuild-threads=16 /data/backups/
輸出：
Starting 16 threads to rebuild indexes.
[09] Checking if there are indexes to rebuild in table sakila/city (space id: 9)
[09] Found index idx_fk_country_id
[10] Checking if there are indexes to rebuild in table sakila/country (space id: 10)
[11] Checking if there are indexes to rebuild in table sakila/customer (space id: 11)
[11] Found index idx_fk_store_id
[11] Found index idx_fk_address_id
[11] Found index idx_last_name
[11] Rebuilding 3 index(es).
對於增量備份的應用可以先不重建索引，在應用最後一個差異備份的時候使用—rebuild-index來創建索引，每次都應用都重建索引太花時間。
使用命令rsync或者cp來還原備份，和全備的還原一樣，請看：3.2.3.3還原全備
--throttle用來控制每秒io次數，一次io，1MB。
如果在backup模式下，這個選項用來控制讀寫對的每秒次數。
默認不會節流，xtrabackup會讀寫是盡量快的方式。
最典型的例子innobackupex，innobackupex是perl腳本調用xtrabackup來執行備份。
具體看：Scripting Backups With xtrabackup
具體查看：Analyzing Table Statistics
xtrabackup提取了inoodb的事務日志中提交事務，對於到binary log的位置。使用這個位置可以啟動一個新的復制slave或者恢復一個時間點備份。
如果備份是一個來至於binary log啟動的日志，xtrabackup會創建一個文件xtrabackup_binlog_info裡面包含了，binary log文件名和位置。信息也會寫在xtrabackup_binlog_pos_innodb，這個文件只會在只有xtradb或者innodb情況下才會准確。其他情況下應該使用xtrabackup_binlog_info。
時間點恢復，和innobackupex的一樣可以查看 3.1.7.6時間點還原
關於如何還原一個slave可以查看下面的內容：4.3.1 六個步驟安裝一個Slave
在mariadb 10.0中可以直接通過ibd文件導入表。
導出表
先查找是否有這個文件存在
$ find /data/backups/mysql/ -name export_test.*
/data/backups/mysql/test/export_test.ibd
然後導出表
$ xtrabackup --prepare --export --target-dir=/data/backups/mysql/
會產生exp文件
$ find /data/backups/mysql/ -name export_test.*
/data/backups/mysql/test/export_test.exp
/data/backups/mysql/test/export_test.ibd
/data/backups/mysql/test/export_test.cfg
注意：mysql使用cfg文件，這個文件包含了innodb字典dump。這個格式和exp文件的不同，exp文件用於xtradb。嚴格來說cfg在mysql 5.6和percona 5.6之後是可以不用的，如果存在cfg文件，那麼innodb會通過cfg文件做schema驗證 。
導入表
導入表，在percona server使用xtradb，需要設置innodb_import_table_from_xtrabackup設置為可用，mysql5.6只要表結構一樣都可以導入。
1.執行alter table discard tablespace
2.復制上一步生成的文件到對於的數據庫目錄
3.執行alter table import tablespace導入
這個功能減少了服務warm up的時間，在重啟的時候直接導入ib_lru_dump文件中的數據，在備份的時候會自動備份。
如果my.cnf配置了，percona server啟動了innodb_buffer_pool_resotre_at_startup=1那麼這個功能會自動啟動。
這個功能在mariadb中有類似的功能：XtraDB/InnoDB Server System Variables
1.在32位的系統下如果xtrabackup_logfile大於4gb那麼--prepare會報錯
2.在第一次執行--prepare的時候不會生成ib_logfile*
3.xtrabackup只復制數據文件和日志，不會復制表定義，frm文件。
4.xtrabackup不支持--set-variable這種格式設置my.cnf
具體看：The xtrabackup Option Reference
具體看: xbstream
具體看：xbcrypt
xtrabackup是基於innodb的crash恢復功能。復制innodb數據文件，但是數據是不一致的，然後使用crash恢復讓數據文件一直。
當innodb啟動會去檢查數據文件和日志文件，然後重做已提交事務，執行未提交事務。
xtrabackup記下LSN，然後啟動，復制數據文件。同時xtrabackup啟動一個後台進程用來監控日志文件，然後復制修改，這個進程在備份期間一直是運行的，因為日志文件時回繞的，避免數據被覆蓋無法恢復。直到備份完成。
第二階段就是預備階段，xtrabackup通過執行crash恢復，應用日志文件到數據文件上。這個過程在xtrabackup中實現。innobackupex增加了功能，會對myisam和.frm進行復制。innobackupex啟動xtrabackup，等待復制innodb結束，然後執行FLUSH TABLES WITH READ LOCK，停止對mysql數據的修改。復制非innodb引擎表，知道復制完成，然後釋放鎖。
這樣在prepare階段後，innodb和非innodb相互保持了一致性。innodb會一直redo，直到備份完成。這個時間剛剛好和FLUSH TABLES WITH READ LOCK時間一直，所以innodb和非innodb是保持同步的。
創建備份
$ innobackupex /data/backups
備份完成
100313 02:43:07 innobackupex: completed OK!
預備備份
使用--apply-log來預備，使用--user-memory來加快預備速度
$ innobackupex --use-memory=4G --apply-log /data/backups/2010-03-13_02-42-44/
完成
100313 02:51:02 innobackupex: completed OK!
還原備份
使用--copy-back來還原備份
innobackupex --copy-back /data/backups/2010-03-13_02-42-44/
## Use chmod to correct the permissions, if necessary!
還原的位子由my.cnf中的datadir決定。
注意修改文件所有者
$ chown -R mysql:mysql /var/lib/mysql
tar使用例子
是用留備份歸檔到文件 ‘backup.tar’
$ innobackupex --stream=tar ./ > backup.tar
壓縮歸檔文件
$ innobackupex --stream=tar ./ | gzip - > backup.tar.gz
加密備份
$ innobackupex --stream=tar . | gzip - | openssl des3 -salt -k "password" > backup.tar.gz.des3
把備份復制到遠程
$ innobackupex --stream=tar ./ | ssh user@desthost "cat - > /data/backups/backup.tar"
使用netcat復制到遠程
## On the destination host:
$ nc -l 9999 | cat - > /data/backups/backup.tar
## On the source host:
$ innobackupex --stream=tar ./ | nc desthost 9999
和上面一樣只是一樣完成
$ ssh user@desthost "( nc -l 9999 > /data/backups/backup.tar & )" \
&& innobackupex --stream=tar ./ | nc desthost 9999
限制傳輸速度為10MB/s 需要pv工具。可以通過apt-get 安裝
$ innobackupex --stream=tar ./ | pv -q -L10m \
| ssh user@desthost "cat - > /data/backups/backup.tar"
在備份的時候計算checksum
## On the destination host:
$ nc -l 9999 | tee >(sha1sum > destination_checksum) > /data/backups/backup.tar
## On the source host:
$ innobackupex --stream=tar ./ | tee >(sha1sum > source_checksum) | nc desthost 9999
## compare the checksums
## On the source host:
$ cat source_checksum
65e4f916a49c1f216e0887ce54cf59bf3934dbad -
## On the destination host:
$ destination_checksum
65e4f916a49c1f216e0887ce54cf59bf3934dbad -
xbstream使用例子
備份並歸檔為‘backup.xbstream
innobackupex --stream=xbstream ./ > backup.xbstream
使用壓縮歸檔
innobackupex --stream=xbstream --compress ./ > backup.xbstream
解包
xbstream -x < backup.xbstream
把備份發送到其他目錄
innobackupex --compress --stream=xbstream ./ | ssh user@otherhost "xbstream -x"
並發壓縮歸檔
innobackupex --compress --compress-threads=8 --stream=xbstream --parallel=4 ./ > backup.xbstream
創建備份
先創建一個全備：
innobackupex --user=USER --password=PASSWORD /path/to/backup/dir/
全備會生成一個時間戳的子目錄，備份在子目錄裡，如/path/to/backup/dir/2011-12-24_23-01-00/，並記為$FULLBACK
創建增量備份
innobackupex --incremental /path/to/inc/dir \
--incremental-basedir=$FULLBACKUP --user=USER --password=PASSWORD
生成的目錄為：/path/to/inc/dir/2011-12-25_00-01-00/並記為$INCREMENTALBACKUP
預備備份
innobackupex --apply-log --redo-only $FULLBACKUP \
--use-memory=1G --user=USER --password=PASSWORD
--user-memory可以加速預備速度。
輸出：
111225 01:10:12 InnoDB: Shutdown completed; log sequence number 91514213
然後應用增量
innobackupex --apply-log --redo-only $FULLBACKUP
--incremental-dir=$INCREMENTALBACKUP
--use-memory=1G --user=DVADER --password=D4RKS1D3
因為是應用到 $FULLBACK下的，所以不再增量備份文件夾下。
如果還原多個增量備份，但是忘記了備份順序可以查看xtrabackup_checkpoint文件
如：
backup_type = full-backuped
from_lsn =0
to_lsn =1291135
backup_type = incremental
from_lsn =1291135
to_lsn =1291340
一旦都預備好之後，就可以回滾未提交事務，然後還原備份使用了
innobackupex-1.5.1 --apply-log $FULLBACKUP --use-memory=1G \
--user=$USERNAME --password=$PASSWORD
備份
帶--compress創建壓縮備份
$ innobackupex --compress /data/backup
如果想要加快速度，可以使用--compress-threads加速
$ innobackupex --compress --compress-threads=4 /data/backup
輸出：
...
[01] Compressing ./imdb/comp_cast_type.ibd to /data/backup/2013-08-01_11-24-04/./imdb/comp_cast_type.ibd.qp
[01] ...done
[01] Compressing ./imdb/aka_name.ibd to /data/backup/2013-08-01_11-24-04/./imdb/aka_name.ibd.qp
[01] ...done
...
130801 11:50:24 innobackupex: completed OK
預備
在預備之前先要使用qpress解壓
$ for bf in `find . -iname "*\.qp"`; do qpress -d $bf $(dirname $bf) && rm $bf; done
在xtrabackup2.1.4之後也可以使用--decompress解壓
$ innobackupex --decompress /data/backup/2013-08-01_11-24-04/
這個選項加壓文件原來的文件會被替換為解壓後的文件。
注意：使用--decompress需要安裝qpress，並且--parallel可以和--decompress一起使用，加速解壓縮。
然後使用--apply-log預備
$ innobackupex --apply-log /data/backup/2013-08-01_11-24-04/
還原
使用--copy-back還原數據庫
$ innobackupex --copy-back /data/backups/2013-08-01_11-24-04/
--copy-back讀取復制到my.cnf中的datadir的值
之後修改文件的所有者
$ chown -R mysql:mysql /var/lib/mysql
之後再啟動服務
xtrabackup可以部分備份，這個也讓獨立區的備份還原變成可能，只要啟動innodb_file_per_table。
先創建一個分區表
create table t.tb_part (id int ,v int) partition by hash(id) partitions 4;
然後插入數據
insert t.tb_part values(1,1),(2,1),(3,1),(4,1);
這樣保證每個分區都有1條記錄。
使用innobackupex --include進行備份，還有很多其他方法進行部分備份：
innobackupex --user=root --include='^t[.]tb_part' /home/tiansign/mysql_backup
和獨立表還原類似，使用--export進行預備
innobackupex --apply-log --export /home/tiansign/mysql_backup/2014-08-19_23-25-55/
ls
tb_part.frm tb_part#P#p0.ibd tb_part#P#p2.cfg tb_part#P#p3.exp
tb_part.par tb_part#P#p1.cfg tb_part#P#p2.exp tb_part#P#p3.ibd
tb_part#P#p0.cfg tb_part#P#p1.exp tb_part#P#p2.ibd
tb_part#P#p0.exp tb_part#P#p1.ibd tb_part#P#p3.cfg
有類似如下輸出
xtrabackup: export option is specified.
xtrabackup: export metadata of table 't/tb_part#P#p0' to file `./t/tb_part#P#p0.exp` (1 indexes)
xtrabackup: name=GEN_CLUST_INDEX, id.low=58, page=3
xtrabackup: export metadata of table 't/tb_part#P#p2' to file `./t/tb_part#P#p2.exp` (1 indexes)
xtrabackup: name=GEN_CLUST_INDEX, id.low=60, page=3
xtrabackup: export metadata of table 't/tb_part#P#p3' to file `./t/tb_part#P#p3.exp` (1 indexes)
xtrabackup: name=GEN_CLUST_INDEX, id.low=61, page=3
xtrabackup: export metadata of table 't/tb_part#P#p1' to file `./t/tb_part#P#p1.exp` (1 indexes)
xtrabackup: name=GEN_CLUST_INDEX, id.low=59, page=3
這裡主要介紹maridb 10.0的方法，也適用於mysql5.6
首先創建表結構：
create table test.tb_part (id int ,v int) partition by hash(id) partitions 4;
create table test.p3 (id int ,v int) ;
然後discard
alter table test.p3 discard tablespace;
復制cfg和ibd到數據庫目錄下（在mariadb 10.0之後可以不用cfg文件，直接使用ibd文件）
cp tb_part#P#p3.ibd /home/db/test/p3.ibd
然後修改所有者
chown mysql:mysql /home/db/test/p3.ibd
最後 import 表
alter table test.p3 import tablespace;
最後通過exchange partition方式把表數據交換到分區表中
alter table test.tb_part exchange partition p3 with table test.p3;
驗證
select *from test.tb_part;
具體看：Recipes for xtrabackup
需要的東西
1.TheMaster服務器
a.需要安裝mysql並且能公國tcp/ip訪問
b.配置了SSH服務
c.有個系統賬號，並有一些權限
d.有個數據庫賬號，也有相應的權限
e.服務的binlog啟動，並且server-id為1
2.TheSlave,另一個系統安裝了mysql，其他都和TheMaster一樣，但是server-id要為2
3.2個系統都要安裝xtrabackup
步驟1：創建一個備份並准備
TheMaster$ innobackupex --user=yourDBuser --password=MaGiCdB1 /path/to/backupdir
完成之後預備
TheMaster$ innobackupex --user=yourDBuser --password=MaGiCdB1 /
--apply-log /path/to/backupdir/$TIMESTAMP/
如果你有特定的配置文件，那麼通過--defaults-file=XXXX/my.cnf指定。默認使用備份目錄下的backup-my.cnf。
步驟2：把備份復制到TheSlave
使用rsync來同步備份文件
TheMaster$ rsync -avprP -e ssh /path/to/backupdir/$TIMESTAMP TheSlave:/path/to/mysql/
關閉，mysql服務，並保存原先的數據庫
TheSlave$ mv /path/to/mysql/datadir /path/to/mysql/datadir_bak
然後把備份復制到mysql配置的datadir下
TheSlave$ mv /path/to/mysql/$TIMESTAMP /path/to/mysql/datadir
修改文件所有者
TheSlave$ chown mysql:mysql /path/to/mysql/datadir
步驟3：配置Master
配置slave，master連接賬號
TheMaster|mysql>GRANT REPLICATION SLAVE ON*.* TO'repl'@'$slaveip'
IDENTIFIED BY'$slavepass';
保證TheSlave可以通過這個賬號連接到TheMaster
TheSlave$ mysql --host=TheMaster --user=repl --password=$slavepass
驗證權限
mysql> SHOW GRANTS;
步驟4：配置Slave
先復制master 上的配置文件
TheSlave$ scp user@TheMaster:/etc/mysql/my.cnf /etc/mysql/my.cnf
然後修改server-id=2
server-id=2
啟動slave上的服務
步驟5：啟動復制
先查看xtrabackup_binlog_info來確定binary log的位置
TheSlave$ cat /var/lib/mysql/xtrabackup_binlog_info
TheMaster-bin.000001 481
使用CHANGE MASTER，賬號密碼使用剛才在master中申請的賬號。
TheSlave|mysql>CHANGE MASTER TO
MASTER_HOST='$masterip',
MASTER_USER='repl',
MASTER_PASSWORD='$slavepass',
MASTER_LOG_FILE='TheMaster-bin.000001',
MASTER_LOG_POS=481;
然後啟動slave
TheSlave|mysql> START SLAVE;
步驟6：檢查
TheSlave|mysql> SHOW SLAVE STATUS \G
...
Slave_IO_Running: Yes
Slave_SQL_Running: Yes
...
Seconds_Behind_Master: 13
...
io和SQL都要運行，Seconds_behind_master是現在slave執行的語句在master上是13秒之前的數據。這個是master和slave之間的延遲。
過程基本上和上面類似
1.備份slave，要帶上--slave-info，帶上這個選項會產生一個xtrabackup_slave_info其中的master的binary log和位置都記錄在這個文件上
TheSlave$ innobackupex --user=yourDBuser --password=MaGiCiGaM /
--slave-info /path/to/backupdir
2.預備，增加了use-memory來加快預備速度
TheSlave$ innobackupex --apply-log --use-memory=2G /path/to/backupdir/$TIMESTAMP/
3.復制到是slave
rsync -avprP -e ssh /path/to/backupdir/$TIMESTAMP TheNewSlave:/path/to/mysql/datadir
4.在master上，再創建一個賬號，當然也可以使用同一個賬號，只要能連接上就可以
heMaster|mysql>GRANT REPLICATION SLAVE ON*.* TO'repl'@'$newslaveip'
IDENTIFIED BY'$slavepass';
5.復制配置文件，在啟動的時候不啟動復制，並設置server-id為3
TheNEWSlave$ scp user@TheSlave:/etc/mysql/my.cnf /etc/mysql/my.cnf
修改配置文件
Skip-slave-start
server-id=3
啟動slave的服務
6.通過xtrabackup_slave_info獲取master的日志名和位置
TheNEWSlave|mysql>CHANGE MASTER TO
MASTER_HOST='$masterip',
MASTER_USER='repl',
MASTER_PASSWORD='$slavepass',
MASTER_LOG_FILE='TheMaster-bin.000001',
MASTER_LOG_POS=481;
啟動slave
TheSlave|mysql> START SLAVE;
具體看：Verifying Backups with replication and pt-checksum
具體看：How to create a new (or repair a broken) GTID based slave
具體看：Auxiliary Guides
Xtrabackup安裝及使用
Percona Xtrabackup - Documentation
xtrabackup原理及實施
