Entrada

LVM en Linux: Gestión Avanzada de Volúmenes Lógicos para Administradores

Publicado Actualizado
Por Andrés Nuñez
11 min de lectura
LVM en Linux: Gestión Avanzada de Volúmenes Lógicos para Administradores

LVM en Linux: Gestión Avanzada de Volúmenes Lógicos para Administradores

LVM (Logical Volume Manager) revoluciona la gestión de almacenamiento en Linux, proporcionando flexibilidad y capacidades avanzadas que van más allá de las particiones tradicionales.

Introducción a LVM

¿Qué es LVM?

LVM es una capa de abstracción entre el hardware de almacenamiento físico y el sistema de archivos. Permite crear, redimensionar y gestionar volúmenes de forma dinámica sin interrumpir el servicio.

Conceptos Fundamentales

Jerarquía LVM

1
2
3
4
5
6
7
8
9

Disco Físico (HD)
    ↓
Physical Volume (PV)
    ↓
Volume Group (VG)
    ↓
Logical Volume (LV)
    ↓
Sistema de Archivos

Componentes Principales

  1. Physical Volume (PV): Disco o partición física
  2. Volume Group (VG): Pool de Physical Volumes
  3. Logical Volume (LV): Partición lógica dentro del VG
  4. Physical Extent (PE): Unidad mínima de asignación
  5. Logical Extent (LE): Mapeo de PE en LV

Instalación y Configuración Inicial

Instalación de LVM

1
2
3
4
5
6
7
8
9
10
11
12
13

# Ubuntu/Debian
apt-get update
apt-get install lvm2

# CentOS/RHEL
yum install lvm2
# o
dnf install lvm2

# Verificar instalación
pvdisplay --version
vgdisplay --version
lvdisplay --version

Preparación de Discos

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# Listar discos disponibles
lsblk
fdisk -l

# Crear partición LVM (tipo 8e)
fdisk /dev/sdb
# n (nueva partición)
# p (primaria)
# 1 (número de partición)
# [Enter] (primer sector por defecto)
# [Enter] (último sector por defecto)
# t (cambiar tipo)
# 8e (Linux LVM)
# w (escribir cambios)

# Verificar partición
fdisk -l /dev/sdb

Gestión de Physical Volumes

Crear Physical Volumes

1
2
3
4
5
6
7
8
9
10
11
12

# Crear PV en disco completo
pvcreate /dev/sdb

# Crear PV en partición
pvcreate /dev/sdb1

# Crear múltiples PVs
pvcreate /dev/sdb /dev/sdc /dev/sdd

# Verificar creación
pvdisplay
pvs  # Vista resumida

Información de Physical Volumes

1
2
3
4
5
6
7
8
9
10
11

# Vista detallada
pvdisplay /dev/sdb

# Vista resumida de todos los PVs
pvs

# Información específica
pvs -o pv_name,pv_size,pv_free,vg_name

# Verificar PV antes de usar
pvscan

Eliminar Physical Volumes

1
2
3
4
5
6
7
8

# Remover PV del VG primero
vgreduce nombre_vg /dev/sdb

# Eliminar PV
pvremove /dev/sdb

# Verificar eliminación
pvs

Gestión de Volume Groups

Crear Volume Groups

1
2
3
4
5
6
7
8
9
10
11
12

# Crear VG con un PV
vgcreate datos_vg /dev/sdb

# Crear VG con múltiples PVs
vgcreate datos_vg /dev/sdb /dev/sdc

# Crear VG con PE específico
vgcreate -s 32M datos_vg /dev/sdb

# Verificar creación
vgdisplay datos_vg
vgs

Extender Volume Groups

1
2
3
4
5
6
7
8
9

# Agregar PV al VG
vgextend datos_vg /dev/sdd

# Verificar extensión
vgdisplay datos_vg
vgs datos_vg

# Ver espacio total disponible
vgdisplay datos_vg | grep "Total PE"

Reducir Volume Groups

1
2
3
4
5
6
7
8

# Mover datos del PV a eliminar
pvmove /dev/sdc

# Reducir VG removiendo PV
vgreduce datos_vg /dev/sdc

# Verificar reducción
vgs datos_vg

Información de Volume Groups

1
2
3
4
5
6
7
8
9
10
11

# Vista detallada
vgdisplay datos_vg

# Vista resumida
vgs

# Información específica
vgs -o vg_name,vg_size,vg_free,pv_count,lv_count

# Escanear VGs
vgscan

Gestión de Logical Volumes

Crear Logical Volumes

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# Crear LV con tamaño específico
lvcreate -L 10G -n web_lv datos_vg

# Crear LV con porcentaje del VG
lvcreate -l 50%VG -n database_lv datos_vg

# Crear LV usando todos los PE libres
lvcreate -l 100%FREE -n backup_lv datos_vg

# Crear LV con stripe (RAID 0)
lvcreate -L 20G -i 2 -I 64 -n stripe_lv datos_vg

# Verificar creación
lvdisplay
lvs

Formatear y Montar Logical Volumes

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# Formatear con ext4
mkfs.ext4 /dev/datos_vg/web_lv

# Formatear con xfs
mkfs.xfs /dev/datos_vg/database_lv

# Crear punto de montaje
mkdir -p /var/www
mkdir -p /var/lib/mysql

# Montar temporalmente
mount /dev/datos_vg/web_lv /var/www
mount /dev/datos_vg/database_lv /var/lib/mysql

# Configurar montaje permanente en /etc/fstab
echo "/dev/datos_vg/web_lv /var/www ext4 defaults 0 2" >> /etc/fstab
echo "/dev/datos_vg/database_lv /var/lib/mysql xfs defaults 0 2" >> /etc/fstab

# Verificar fstab
mount -a
df -h

Redimensionamiento de Volúmenes

Extender Logical Volumes

Extensión Online (sin desmontar)

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# Extender LV
lvextend -L +5G /dev/datos_vg/web_lv

# O extender usando porcentaje libre
lvextend -l +50%FREE /dev/datos_vg/web_lv

# Extender sistema de archivos ext4 (online)
resize2fs /dev/datos_vg/web_lv

# Extender sistema de archivos xfs (online)
xfs_growfs /var/lib/mysql

# Verificar nueva capacidad
df -h /var/www

Extensión en un solo comando

1
2
3
4
5

# Extender LV y filesystem automáticamente
lvextend -L +5G -r /dev/datos_vg/web_lv

# Verificar
df -h /var/www

Reducir Logical Volumes

⚠️ Reducción Segura (solo ext2/3/4)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# NUNCA reducir sistemas de archivos montados
# XFS NO soporta reducción

# 1. Desmontar filesystem
umount /var/www

# 2. Verificar filesystem
e2fsck -f /dev/datos_vg/web_lv

# 3. Reducir filesystem primero
resize2fs /dev/datos_vg/web_lv 8G

# 4. Reducir LV
lvreduce -L 8G /dev/datos_vg/web_lv

# 5. Remontar
mount /dev/datos_vg/web_lv /var/www

# Verificar
df -h /var/www

Snapshots: Backup y Recuperación

Crear Snapshots

1
2
3
4
5
6
7
8
9

# Crear snapshot
lvcreate -L 2G -s -n web_snapshot /dev/datos_vg/web_lv

# Crear snapshot con porcentaje
lvcreate -l 10%ORIGIN -s -n db_snapshot /dev/datos_vg/database_lv

# Verificar snapshots
lvs -a
lvdisplay /dev/datos_vg/web_snapshot

Montar y Usar Snapshots

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# Crear punto de montaje para snapshot
mkdir /mnt/web_snapshot

# Montar snapshot (solo lectura es más seguro)
mount -o ro /dev/datos_vg/web_snapshot /mnt/web_snapshot

# Explorar contenido del snapshot
ls -la /mnt/web_snapshot

# Backup desde snapshot
tar -czf /backup/web_$(date +%Y%m%d).tar.gz -C /mnt/web_snapshot .

# Desmontar snapshot
umount /mnt/web_snapshot

Restaurar desde Snapshot

1
2
3
4
5
6
7
8
9
10

# Restaurar LV original desde snapshot
lvconvert --merge /dev/datos_vg/web_snapshot

# NOTA: Esto requiere desmontar el LV original
umount /var/www
lvconvert --merge /dev/datos_vg/web_snapshot

# El snapshot se elimina automáticamente después del merge
# Remontar LV original
mount /dev/datos_vg/web_lv /var/www

Eliminar Snapshots

1
2
3
4
5

# Eliminar snapshot
lvremove /dev/datos_vg/web_snapshot

# Confirmar eliminación
lvs

LVM Avanzado

Striping y Mirroring

RAID 0 (Striping)

1
2
3
4
5
6
7
8

# Crear LV con stripe para mejor performance
lvcreate -L 20G -i 2 -I 64 -n fast_lv datos_vg /dev/sdb /dev/sdc

# -i 2: 2 stripes
# -I 64: stripe size 64KB

# Verificar configuración
lvdisplay datos_vg/fast_lv -m

RAID 1 (Mirroring)

1
2
3
4
5

# Crear LV con mirror
lvcreate -L 10G -m 1 -n mirror_lv datos_vg

# Verificar mirror
lvs -a -o +devices

Thin Provisioning

Crear Pool de Thin Provisioning

1
2
3
4
5
6
7
8
9

# Crear thin pool
lvcreate -L 50G -T datos_vg/thin_pool

# Crear volúmenes thin
lvcreate -V 20G -T datos_vg/thin_pool -n thin_vol1
lvcreate -V 30G -T datos_vg/thin_pool -n thin_vol2

# Verificar thin volumes
lvs -a

Monitoreo de Thin Pools

1
2
3
4
5
6
7

# Ver uso de thin pool
lvs -a -o +data_percent,metadata_percent

# Extender thin pool automáticamente
# Configurar en /etc/lvm/lvm.conf
# thin_pool_autoextend_threshold = 80
# thin_pool_autoextend_percent = 20

Cache Volumes

Acelerar LVs con SSD Cache

1
2
3
4
5
6
7
8
9
10
11
12

# Crear cache pool en SSD
lvcreate -L 10G -n cache_pool datos_vg /dev/nvme0n1p1
lvcreate -L 1G -n cache_meta datos_vg /dev/nvme0n1p1

# Convertir a cache pool
lvconvert --type cache-pool --poolmetadata datos_vg/cache_meta datos_vg/cache_pool

# Aplicar cache a LV
lvconvert --type cache --cachepool datos_vg/cache_pool datos_vg/database_lv

# Verificar cache
lvs -a -o +cache_percent

Migración y Movimiento de Datos

Migrar Physical Volumes

1
2
3
4
5
6
7
8
9
10
11

# Mover datos de un PV a otros PVs en el mismo VG
pvmove /dev/sdb

# Mover a PV específico
pvmove /dev/sdb /dev/sdc

# Mover LV específico
pvmove -n datos_vg/web_lv /dev/sdb /dev/sdc

# Verificar progreso
pvmove --abort  # Para cancelar si es necesario

Migrar Volume Groups

1
2
3
4
5
6
7
8
9
10
11

# Exportar VG
vgchange -an datos_vg  # Desactivar VG
vgexport datos_vg

# En el nuevo servidor, importar VG
vgimport datos_vg
vgchange -ay datos_vg  # Activar VG

# Verificar migración
vgs
lvs

Monitoreo y Mantenimiento

Scripts de Monitoreo

Monitor de Espacio LVM

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

#!/bin/bash
# monitor_lvm.sh

THRESHOLD=80
LOG_FILE="/var/log/lvm_monitor.log"

check_lv_usage() {
    lvs --noheadings --units g -o lv_name,lv_size,data_percent,vg_name | \
    while read lv_name lv_size usage vg_name; do
        if [ ! -z "$usage" ]; then
            usage_int=${usage%.*}
            if [ "$usage_int" -gt "$THRESHOLD" ]; then
                message="ALERTA: LV $vg_name/$lv_name está al ${usage}% de capacidad"
                echo "[$(date)] $message" >> "$LOG_FILE"
                echo "$message" | mail -s "LVM Alert" admin@ejemplo.com
            fi
        fi
    done
}

check_vg_space() {
    vgs --noheadings --units g -o vg_name,vg_size,vg_free | \
    while read vg_name vg_size vg_free; do
        vg_size_num=$(echo $vg_size | sed 's/g//')
        vg_free_num=$(echo $vg_free | sed 's/g//')
        
        if [ "$(echo "$vg_free_num < 1" | bc)" -eq 1 ]; then
            message="ALERTA: VG $vg_name tiene menos de 1GB libre"
            echo "[$(date)] $message" >> "$LOG_FILE"
            echo "$message" | mail -s "VG Space Alert" admin@ejemplo.com
        fi
    done
}

check_lv_usage
check_vg_space

Backup de Configuración LVM

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#!/bin/bash
# backup_lvm_config.sh

BACKUP_DIR="/backup/lvm"
DATE=$(date +%Y%m%d)

mkdir -p "$BACKUP_DIR"

# Backup configuración LVM
cp -r /etc/lvm "$BACKUP_DIR/lvm_config_$DATE"

# Backup metadata
vgcfgbackup --file "$BACKUP_DIR/vg_backup_$DATE"

# Generar información del sistema
{
    echo "=== LVM BACKUP $(date) ==="
    echo ""
    echo "PHYSICAL VOLUMES:"
    pvs
    echo ""
    echo "VOLUME GROUPS:"
    vgs
    echo ""
    echo "LOGICAL VOLUMES:"
    lvs
    echo ""
    echo "DETAILED INFORMATION:"
    pvdisplay
    vgdisplay
    lvdisplay
} > "$BACKUP_DIR/lvm_info_$DATE.txt"

echo "Backup LVM completado en $BACKUP_DIR"

Troubleshooting y Recuperación

Problemas Comunes

VG Inactivo

1
2
3
4
5
6
7
8
9
10

# Activar VG
vgchange -ay datos_vg

# Si falla, verificar PVs
pvscan
vgscan
lvscan

# Forzar activación
vgchange -ay --partial datos_vg

LV Corrupto

1
2
3
4
5
6
7
8

# Verificar filesystem
e2fsck -f /dev/datos_vg/web_lv

# Reparar filesystem
e2fsck -y /dev/datos_vg/web_lv

# Para XFS
xfs_repair /dev/datos_vg/database_lv

Recuperar Metadata

1
2
3
4
5
6
7

# Restaurar configuración desde backup
vgcfgrestore -f /backup/lvm/vg_backup_20250717 datos_vg

# Escanear y activar
pvscan
vgscan
vgchange -ay datos_vg

Migración de Emergencia

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#!/bin/bash
# emergency_lvm_migration.sh

SOURCE_VG="datos_vg"
SOURCE_LV="database_lv"
DEST_DEVICE="/dev/sde"
BACKUP_DIR="/emergency_backup"

echo "Iniciando migración de emergencia..."

# Crear backup del LV
mkdir -p "$BACKUP_DIR"
dd if="/dev/$SOURCE_VG/$SOURCE_LV" of="$BACKUP_DIR/emergency_backup.img" bs=64M status=progress

# Preparar nuevo dispositivo
pvcreate "$DEST_DEVICE"
vgcreate emergency_vg "$DEST_DEVICE"
lvcreate -L $(lvdisplay "/dev/$SOURCE_VG/$SOURCE_LV" | grep "LV Size" | awk '{print $3$4}') -n emergency_lv emergency_vg

# Restaurar datos
dd if="$BACKUP_DIR/emergency_backup.img" of="/dev/emergency_vg/emergency_lv" bs=64M status=progress

echo "Migración completada. Verificar antes de usar."

Best Practices

Diseño de LVM

  1. Planificar el Layout: Diseñar VGs por función (sistema, datos, logs)
  2. Tamaño de PE: Usar 4MB para VGs pequeños, 32MB+ para grandes
  3. Reservar Espacio: Mantener 10-20% libre en VGs
  4. Snapshots: Dimensionar al 20-30% del LV original
  5. Naming Convention: Usar nombres descriptivos y consistentes

Seguridad y Backup

1
2
3
4
5
6
7
8
9

# Configurar permisos restrictivos
chmod 600 /etc/lvm/backup/*
chmod 600 /etc/lvm/archive/*

# Backup automático de metadata
echo "0 2 * * * /usr/sbin/vgcfgbackup" >> /etc/crontab

# Monitoreo continuo
echo "*/5 * * * * /scripts/monitor_lvm.sh" >> /etc/crontab

Performance Tuning

1
2
3
4
5
6
7
8
9
10
11

# Configurar readahead para LVs grandes
blockdev --setra 8192 /dev/datos_vg/database_lv

# Usar deadline scheduler para bases de datos
echo deadline > /sys/block/dm-0/queue/scheduler

# Configurar en /etc/lvm/lvm.conf
# global {
#     raid_region_size = 2048
#     thin_pool_autoextend_threshold = 80
# }

Conclusiones

LVM proporciona:

  1. Flexibilidad: Redimensionamiento dinámico sin downtime
  2. Snapshots: Backup consistente y recuperación rápida
  3. Performance: Striping y caching para optimización
  4. Escalabilidad: Agregación de discos sin límites físicos
  5. Alta Disponibilidad: Mirroring y migración online

LVM es fundamental para administradores que gestionan infraestructuras críticas donde la flexibilidad del almacenamiento es esencial.

Andrés Nuñez - t4ifi

Administración, Storage
lvm volúmenes lógicos storage particiones administración
Esta entrada está licenciada bajo CC BY 4.0 por el autor.