扩容Linux文件系统

beebe_3

　　扩容Linux文件系统
　　腾讯云 云硬盘扩容
　　https://cloud.tencent.com/product/cbs
　　https://cloud.tencent.com/document/product/362/6738
　　
普通云硬盘（HDD Cloud Storage） 容量最大为16TB
高性能云硬盘（Premium Cloud Storage） 容量最大为4TB
SSD云硬盘（SSD Cloud Storage） 容量最大为4TB
单台虚拟机最多可挂载 10 块云盘，容量达 40TB。您可以轻松搭建大容量的文件系统，用于大数据、数据仓库、日志处理等业务。
　　请注意，由于MBR的限制，选择任何一种方式时，请保持任意分区的大小不超过2TB（若您扩容后的空间已经大于2TB则不可选择第二种方式。
　　一般系统分区方案
/boot 500M
/     30G
SWAP  8G   
/data  剩下空间

　　扩容分三步
1) 扩容实体云硬盘大小
　　2) 扩容分区
　　确定文件系统分区表形式
扩容分区
3) 扩容文件系统

　　
GPT分区云硬盘扩容
umount 挂载点
parted [磁盘路径]
e2fsck -f /dev/vdb1
resize2fs /dev/vdb1
mount 分区路径 挂载点



# 具体命令
umount -lf /data
parted /dev/vdb
e2fsck -f /dev/vdb1
resize2fs /dev/vdb1
mount /dev/vdb1  /data
或
echo "/dev/vdb  /data  ext4  defaults,noatime,nodiratime   0 0" >>/etc/fstab
mount -a
　　新空间增加到已有分区中(GPT分区格式)
　　查看数据盘信息
　　执行命令
　　parted 磁盘路径 print
　　确认云硬盘的容量变化。如在过程中收到如下提示,请输入Fix：

　　这里扩容后的云硬盘大小为107GB，已有分区的大小为10.7GB。
　　卸载已挂载数据盘
　　执行以下命令确认该云硬盘是否还有分区已挂载：
　　mount | grep '磁盘路径'

　　这里云硬盘上有一个分区(vdb1)挂载在/data上，需要将其解挂。
　　使用以下命令解挂：
　　umount 挂载点
本例中即执行umount /data进行卸载。
　　注：要将云硬盘上所有分区的文件系统都解挂，如vdb1、vdb2......
再次使用mount | grep '/dev/vdb'命令来确认此硬盘上所有分区的文件系统都已解挂。

　　数据盘分区
　　确认云硬盘所有分区均已卸载后，执行以下命令，将原分区删除并以同样的起始偏移新建一个分区：
　　parted  [磁盘路径]
接下来输入unit s，将显示和操纵单位变成sector（默认为GB），输入print来查看分区信息，记住已有分区的Start值。
　　删除分区并新建后，Start值必须与这个相同，否则数据将会丢失。

　　执行以下命令删除原有分区：
　　rm [分区Number]
由上图可知云硬盘上有一个分区，Number号为“1”，执行rm 1，结果如下图：

　　输入mkpart primary [原分区起始扇区] 100%
　　新建一个主分区。
　　本例中使用mkpart primary 2048s 100%，此主分区从第2048个扇区开始（必须与删除之前的分区一致），100%表示此分区到磁盘的最末尾。
　　如果出现如图状态请输入Ignore：

　　再次输入print可发现新分区已经新建成功，输入quit，即可退出parted工具：

　　检查扩容后分区的文件系统
　　使用以下命令检查扩容后的分区：
　　e2fsck -f 分区路径
前述步骤中本例已新建了分区1，使用e2fsck -f /dev/vdb1进行操作。结果如下：

　　扩容文件系统
　　执行以下命令进行分区上文件系统的扩容操作：
　　resize2fs 分区路径

　　挂载新分区
　　执行以下命令挂载分区：
　　mount 分区路径 挂载点
这里通过mount /dev/vdb1 /data
　　手动挂载新分区，并使用df -h命令查看，出现以下信息说明挂载成功，即可以查看到数据盘了。

　　MBR分区云硬盘扩容
　　
下面两种情况都可以选择使用自动扩容工具（devresize.py）进行扩容
1、原有的硬盘（数据盘）只有一个MBR主分区并制作了文件系统
2、原有的硬盘（数据盘）没有分区，直接在此硬盘上制作了文件系统
　　
自动扩容工具适用于Linux操作系统，用于将扩容时新扩的云硬盘存储空间添加到已存在的文件系统中，扩容能够成功必须满足下面3个条件：
1、文件系统是ext2/ext3/ext4,并且只有一个主分区没有其他主分区和扩展分区
2、当前文件系统不能有错误
3、扩容后的磁盘大小不超过2TB
　　umount 挂载点
wget -O /tmp/devresize.py http://mirrors.tencentyun.com/install/virts/devresize.py 下载一键扩容工具
python /tmp/devresize.py 硬盘路径 云硬盘，而不是分区名
mount 分区路径 挂载点



# 具体命令
umount -lf /data
wget -O /tmp/devresize.py http://mirrors.tencentyun.com/install/virts/devresize.py
python /tmp/devresize.py  /dev/vdb
mount /dev/vdb1  /data
或
echo "/dev/vdb  /data  ext4  defaults,noatime,nodiratime   0 0" >>/etc/fstab
mount -a
　　新空间增加到已有分区中(MBR分区格式)
　　卸载正在使用的硬盘分区
　　执行以下命令卸载分区：
　　umount 挂载点

　　下载一键扩容工具
　　执行以下命令下载工具：
　　wget -O /tmp/devresize.py http://mirrors.tencentyun.com/install/virts/devresize.py
执行扩容工具
　　执行以下命令进行扩容：
　　python /tmp/devresize.py 硬盘路径
请注意，这里硬盘路径是需要扩容的云硬盘，而不是分区名。若您的文件系统在vdb1上，则应执行
　　python /tmp/devresize.py /dev/vdb

　　若输出“The filesystem on /dev/vdb1 is now XXXXX blocks long.“则表示扩容成功。
　　重新挂载扩容后的分区
　　执行以下命令挂载扩容后的分区：
　　mount 分区路径 挂载点
并通过以下命令查看扩容后的分区容量：
　　df -h
这里通过mount /dev/vdb1 /data命令手动挂载扩容后的分区(如果原先是没有分区的，执行mount /dev/vdb /data)，
　　用df -h命令查看，出现以下信息说明挂载成功，即可以查看到数据盘了:

　　再执行ll /data命令，可以查看到，扩容后原分区的数据没有丢失，新增加的存储空间已经扩容到文件系统中。
　　devresize.py



#!/usr/bin/env python
# coding: utf-8
# FileName: devresize.py
"""
It only handle the following two situations:
1. There is only one primary partiion in the disk with a format of ext2/3/4;
2. The disk is raw with a file system whose format is ext2/3/4.
"""
import struct
import array
import fcntl
import time
import sys
import os
import glob
import logging
BLKSSZGET = 0x1268
BLKGETSIZE = 0x1260
BLKRRPART = 0x125f
BLKGETSIZE64 = 0x80041272
logger = None

def read_ub(data):
return struct.unpack('B', data[0])[0]

def read_us(data):
return struct.unpack('<H', data[0:2])[0]

def read_ui(data):
return struct.unpack('<I', data[0:4])[0]

def read_ul(data):
return struct.unpack('<Q', data[0:8])[0]

def init_log():
global logger
log_file = 'devresize.log'
fmt_file = '%(asctime)s - [%(levelname)-5.5s]- %(filename)s:%(lineno)s - %(message)s'
fmt_stream = '[%(levelname)s] - %(message)s'
logger = logging.getLogger('devresize')
logger.setLevel(logging.DEBUG)
file_handler = logging.FileHandler(log_file)
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(logging.Formatter(fmt_file))
logger.addHandler(file_handler)
stream_handler = logging.StreamHandler()
stream_handler.setLevel(logging.INFO)
stream_handler.setFormatter(logging.Formatter(fmt_stream))
logger.addHandler(stream_handler)

class PartitionEntry(object):
PartitionTypes = {
0x05: "Microsoft Extended",
0x83: "Linux",
0x85: "Linux Extended"
}
def __init__(self, data):
self.data = data
self.boot_sig = data[0]
self.start_head, self.start_sector, self.start_cylinder = (
PartitionEntry.get_hsc(data[1:1 + 3]))
self.partition_type = read_ub(data[4])
self.end_head, self.end_sector, self.end_cylinder = (
PartitionEntry.get_hsc(data[5:5 + 3]))
self.start_lba = read_ui(data[8:8 + 4])
self.sector_num = read_ui(data[12:12 + 4])
self.partition_type_name = PartitionEntry.PartitionTypes.get(self.partition_type, "other")
@staticmethod
def get_hsc(data):
h, s, c = struct.unpack('BBB', data[0:3])
c = (c | ((s & 0xC0) << 2))
s = (s & 0x3F)
return h, s, c
@staticmethod
def cal_hsc(sector, hh, ss):
s = sector % ss + 1
sector /= ss
h = sector % hh
sector /= hh
c = sector & 0xFF
s |= (sector >> 2) & 0xC0
return h, s, c
def vaild_type(self):
return self.partition_type in self.PartitionTypes
def isprimary(self):
return self.partition_type == 0x83
def __str__(self):
if not self.vaild_type():
print "%x" % self.partition_type
return "This isn't a Linux Partition!"
return """
Start h,s,c: %u %u %u
End h,s,c: %u %u %u
Partition Type Name:%s
Start LBA: %u
Sector Number: %u
""" % (self.start_head, self.start_sector, self.start_cylinder,
self.end_head, self.end_sector, self.end_cylinder,
self.partition_type_name, self.start_lba, self.sector_num)

class MBR(object):
def __init__(self, data):
self.data = data
self.boot_code = data[:446]
self.mbr_sig = data[510:512]
if self.check_mbr_sig():
self.partitions = ([PartitionEntry(data[446 + 16 * i:446 + 16 * (i + 1)])
for i in range(0, 4)])
else:
self.partitions = None
if self.partitions is not None:
self.vaild_part_num = len(filter(lambda x: x.vaild_type(), self.partitions))
else:
self.vaild_part_num = 0
self.device_heads = 0
self.device_sectors = 0
self.cal_device_hs()
def cal_device_hs(self):
if self.partitions is not None and self.vaild_part_num == 1:
self.device_heads = self.partitions[0].end_head + 1
self.device_sectors = self.partitions[0].end_sector & 0x3F
def check_mbr_sig(self):
mbr_sig = read_us(self.mbr_sig)
if mbr_sig == 0xAA55:
return True
else:
return False

def get_device_size(fd):
buf = array.array('c', [chr(0)] * 8)
fcntl.ioctl(fd, BLKSSZGET, buf, True)
logical_sector_size = read_ul(buf)
buf = array.array('c', [chr(0)] * 8)
try:
fcntl.ioctl(fd, BLKGETSIZE, buf, True)
device_size = read_ul(buf) * 512
except IOError:
fcntl.ioctl(fd, BLKGETSIZE64, buf, True)
device_size = read_ul(buf)
device_sector_number = device_size / logical_sector_size
logger.debug(
'''device_size:%d
device_sector_number:%d
logical_sector_size:%d''' % (device_size, device_sector_number, logical_sector_size))
return device_size, device_sector_number, logical_sector_size

def backup_mbr(data):
bak_name = '/tmp/MBR_%s_bak' % time.strftime("%Y-%m-%d_%X", time.localtime())
bak_file = open(bak_name, 'w')
bak_file.write(data)
bak_file.close()
logger.info("Backup MBR to %s" % bak_name)
return bak_name

def is_first_start():
bak_file_list = glob.glob('/tmp/MBR_%s*bak' % time.strftime("%Y-%m-%d", time.localtime()))
return len(bak_file_list) == 0

def cal_new_part(part_data, mbr, start_lab, new_end):
device_heads, device_sectors = mbr.device_heads, mbr.device_sectors
new_partition_sector_num = new_end - start_lab + 1
begin_h, begin_s, begin_c = PartitionEntry.cal_hsc(start_lab, device_heads, device_sectors)
end_h, end_s, end_c = PartitionEntry.cal_hsc(new_end, device_heads, device_sectors)
new_part_data = list(part_data[:])
new_part_data[1:1 + 3] = list(struct.pack('BBB', begin_h, begin_s, begin_c))
new_part_data[5:5 + 3] = list(struct.pack('BBB', end_h, end_s, end_c))
new_part_data[0xc:] = list(
struct.pack('BBBB', (new_partition_sector_num & 0xff), ((new_partition_sector_num >> 8) & 0xff),
((new_partition_sector_num >> 16) & 0xff), ((new_partition_sector_num >> 24) & 0xff)))
logger.debug("""
Start h,s,c: %u %u %u
End h,s,c: %u %u %u
Partition Type Name:%s
Start LBA: %u
Sector Number: %u
""" % (begin_h, begin_s, begin_c,
end_h, end_s, end_c,
mbr.partitions[0].partition_type_name,
mbr.partitions[0].start_lba,
new_partition_sector_num))
return new_part_data

# filesystem type must be ext2/3/4
def check_format(dev):
blkid_ret = os.popen('blkid %s' % dev)
s = blkid_ret.read()
if blkid_ret.close() is not None:
return False
return True in [i in s for i in ['ext2', 'ext3', 'ext4']]

def part_probe(fd):
logger.debug('part_probe')
fd.flush()
fcntl.ioctl(fd, BLKRRPART)

def resize2fs(dev):
ret = os.system('e2fsck -f %s' % dev)
logger.debug('e2fsck ret is %d' % ret)
if ret not in (0, 1):
raise RuntimeError('e2fsck failed!!')
if ret == 1:
logger.info('File system errors corrected')
ret = os.system('resize2fs %s' % dev)
logger.debug('resize2fs ret is %d' % ret)
if ret != 0:
raise RuntimeError('resize2fs failed!!')

def check_mount(target_dev):  # target_dev is mounted!
return os.system('mount | grep "%s " > /dev/null' % target_dev) == 0

def write_mbr(fd, mbr_data):
fd.seek(0)
fd.write(mbr_data)
part_probe(fd)
fd.close()
time.sleep(1)

def check_arg(device):
return not device[-1].isdigit()

def get_disk_path(partation_name):
for i, ch in enumerate(os.path.basename(partation_name)[::-1]):
if not ch.isdigit():
return partation_name[::-1][i::][::-1]
logger.error("invalid para %s" % partation_name)
raise Exception("invalid para %s" % partation_name)

def main():
if len(sys.argv) < 2:
print "Usage: %s block_device" % sys.argv[0]
sys.exit(1)
init_log()
logger.debug("user input:%s" % ' '.join(sys.argv))
device = sys.argv[1]
if not check_arg(device):
logger.error("The argument should be a whole disk not a partation!like %s" % get_disk_path(device))
sys.exit(1)
if not os.access(device, os.W_OK):
logger.error("Permission denied")
sys.exit(1)
fd = open(device, 'r+')
data = fd.read(512)
mbr = MBR(data)
device_size, device_sector_number, logical_sector_size = get_device_size(fd)
if mbr.vaild_part_num > 1:
logger.error("Disk %s have multi partition." % device)
sys.exit(1)
target_partition = ''
resize_part_flag = True
if mbr.vaild_part_num == 1:  # only one partition, which is the primary partition
if not mbr.partitions[0].isprimary():  # and the filesystem type is ext2/3/4.
logger.error("Must be primary partition.")
resize_part_flag = True
if device[-1].isdigit():
target_partition = device + 'p1'  # ex: /dev/nbd0 -> /dev/nbd0p1
else:
target_partition = device + '1'  # ex: /dev/vdb -> /dev/vdb1
        logger.debug(mbr.partitions[0])
if mbr.vaild_part_num == 0:  # no partition but whole disk is ext2/3/4
resize_part_flag = False
target_partition = device
logger.debug('target_partition:%s' % target_partition)
if not check_format(target_partition):
logger.error("Only can process ext2/3/4.")
sys.exit(1)
if check_mount(target_partition):
logger.error("Target device %s must be unmounted." % target_partition)
sys.exit(1)
logger.info("It will resize (%s).\n"
"This operation may take from several minutes to several hours, continue? [Y/n]"
% target_partition)
user_input = raw_input()
if user_input.lower() != 'y' and user_input != '':
logger.warn("User input neither 'y' nor '[Enter]',exit.")
sys.exit(1)
if not is_first_start():
logger.warn('We find some MBR backup file in /tmp,maybe the MBR is already changed,'
'do you want to just resize the filesystem? [Y/n]')
user_input = raw_input()
if user_input.lower() == 'y' or user_input == '':
resize_part_flag = False
if resize_part_flag:
logger.debug("Begin to change the partation")
if (mbr.partitions[0].start_lba + mbr.partitions[0].sector_num) == device_sector_number:
logger.error("No free sectors available.")
sys.exit(1)
if mbr.partitions[0].sector_num > 0xFFFFFFFF * 512 / logical_sector_size:
logger.error("Can't process the partition which have exceeded 2TB.")
sys.exit(1)
new_start_sector = mbr.partitions[0].start_lba
new_end_sector = device_sector_number - 1
if (new_end_sector - new_start_sector + 1) * logical_sector_size > 0xFFFFFFFF * 512:
user_input = raw_input("The size of this disk is %.2fTB (%d bytes).\n"
"But DOS partition table format can not be used on drives for volumes larger than 2TB (2199023255040 bytes).\n"
"Do you want to resize (%s) to 2TB?[Y/n]"
% (round(device_size / 1024.0 / 1024 / 1024 / 1024, 2), device_size,
target_partition))
if user_input.lower() != 'y' and user_input != '':
logger.warn("User input neither 'y' nor '[Enter]',exit.")
sys.exit(1)
new_end_sector = 0xFFFFFFFF * 512 / logical_sector_size + new_start_sector - 1
new_mbr_data = list(data)[:]
new_mbr_data[446:446 + 16] = cal_new_part(data[446:446 + 16], mbr,
new_start_sector, new_end_sector)
backup_mbr(data)
try:
if resize_part_flag:
write_mbr(fd, ''.join(new_mbr_data))
resize2fs(target_partition)
except Exception, e:
logger.error(e)
logger.error('Some error occurred!!Maybe you should call the customer service staff.')

if __name__ == '__main__':
main()

　　腾讯云主机做raid
　　https://cloud.tencent.com/document/product/362/2932
　　都是系统层面的raid
　　windows主机
　　windows2012R2：使用系统自带磁盘管理器里的 ，新建镜像卷功能，把两个弹性云硬盘连接到云主机，然后新建镜像卷做raid1
　　Linux主机
　　centos6：Linux内核提供了md模块在底层管理RAID设备，我们可以使用mdadm工具来调用md模块。安装mdadm（以CentOS为例）
　　f