RAID (Português)

Artigos relacionados
Software RAID and LVM
LVM#RAID
Instalando Arch Linux com FakeRAID
Convert a single drive system to RAID
ZFS
ZFS/Virtual disks
Swap#Distribuição
Btrfs#RAID
Status de tradução:
Esse artigo é uma tradução de
RAID
. Data da última tradução: 2020-12-29. Você pode ajudar a sincronizar a tradução, se houver
alterações
na versão em inglês.
Redundant Array of Independent Disks (Conjunto Redundante de Discos Independentes, sigla em inglês
RAID
) é uma tecnologia de armazenamento que combina múltiplos componentes de unidade de disco (tipicamente unidades de disco ou partições da mesma) em uma unidade lógica. Dependendo da implementação do RAID, essa unidade lógica pode ser um sistema de arquivos ou uma camada transparente adicional que pode conter várias partições. Os dados são distribuídos pelas unidades de uma das várias maneiras chamadas
níveis de RAID
, dependendo do nível de redundância e desempenho necessário. O nível de RAID escolhido pode assim prevenir perda de dados na ocorrência de falha de disco rígido, aumentar performance ou ser uma combinação de ambos.
Esse artigo explica como criar/gerenciar um software RAID array usando mdadm.
Atenção
Tenha certeza
de fazer backup
de todos os dados antes de proceder.
Níveis de RAID
Apesar da redundância implicada pela maioria dos níveis de RAID, RAID não garante que os dados estão seguros. Um RAID não vai proteger os dados se houver incêndio, se o computador for roubado ou se multiplos discos rígidos falharem de uma só vez. Além disso, instalar um sistema com RAID é um processo complexo que pode destruir dados.
Níveis padrão de RAID
Existem muitos
níveis de RAID
, veja a seguir os mais usados.
RAID 0
Usa striping para combinar discos. Apesar de
não fornecer redundância
, ainda é considerado RAID. No entanto,
fornece um grande benefício de velocidade
. Se o aumento da velocidade compensar a possibilidade de perda de dados (para partição
swap
, por exemplo), escolha este nível de RAID. Em um servidor, RAID 1 e RAID 5 são mais apropriados. O tamanho de um dispositivo de bloco de um array RAID 0 é o tamanho da menor partição do componente vezes o número de partições do componente.
RAID 1
O nível RAID mais simples: espelhamento direto. Tal como acontece com outros níveis de RAID, só faz sentido se as partições estiverem em diferentes unidades de disco físico. Se uma dessas unidades falhar, o dispositivo de bloco fornecido pelo array RAID continuará a funcionar normalmente. O exemplo usará RAID 1 para tudo, exceto
swap
e dados temporários. Observe que, com uma implementação de software, o nível de RAID 1 é a única opção para a partição de inicialização, porque os carregadores de inicialização que lêem a partição de inicialização não entendem RAID, mas uma partição de componente RAID 1 pode ser lida como uma partição normal. O tamanho de um dispositivo de bloco de um array RAID 1 é o tamanho da menor partição do componente.
RAID 5
Requer 3 ou mais unidades físicas e fornece a redundância do RAID 1 combinada com os benefícios de velocidade e tamanho do RAID 0. RAID 5 usa striping, como RAID 0, mas também armazena blocos de paridade
distribuídos em cada disco membro
. No caso de um disco com falha, esses blocos de paridade são usados para reconstruir os dados em um disco de substituição. RAID 5 pode suportar a perda de um disco membro.
Nota
RAID 5 é uma escolha comum devido à sua combinação de velocidade e redundância de dados. A ressalva é que, se uma unidade falhar e outra falhar antes daquela ser substituída, todos os dados serão perdidos. Além disso, com tamanhos de disco modernos e taxas esperadas de erro de leitura irrecuperável (URE) em discos do consumidor, a reconstrução de um array de 4TiB é
esperada
(ou seja, mais de 50% de chance) de ter pelo menos um URE. Por causa disso, o RAID 5 não é mais recomendado pela indústria de armazenamento.
RAID 6
Requer 4 ou mais unidades físicas e oferece os benefícios do RAID 5, mas com segurança contra falhas de duas unidades. O RAID 6 também usa striping, como o RAID 5, mas armazena dois blocos de paridade distintos
distribuídos em cada disco membro
. No caso de um disco com falha, esses blocos de paridade são usados para reconstruir os dados em um disco de substituição. RAID 6 pode suportar a perda de dois discos membros. A robustez contra erros de leitura irrecuperáveis é um pouco melhor, porque o array ainda tem blocos de paridade ao reconstruir a partir de uma única unidade com falha. No entanto, dada a sobrecarga, o RAID 6 é caro e na maioria das configurações o RAID 10 no layout far2 (veja abaixo) oferece melhores benefícios de velocidade e robustez e, portanto, é preferido.
Níveis de RAID aninhados
RAID 1+0
RAID1+0 é um RAID aninhado que combina dois dos níveis padrão de RAID para obter desempenho e redundância adicional. É comumente referido como
RAID10
, no entanto, Linux MD RAID10 é um pouco diferente da camada RAID simples, veja abaixo.
RAID 10
RAID10 no Linux é construído sobre os conceitos de RAID1+0, no entanto, ele implementa isso como uma única camada, com vários layouts possíveis.
O layout
near X
nos discos Y repete cada chunk X vezes nos Y / 2 stripes, mas não precisa de X para dividir Y uniformemente. Os chunks são colocados quase no mesmo local em cada disco em que são espelhados, daí o nome. Ele pode funcionar com qualquer número de discos, começando em 2. Quase 2 em 2 discos é equivalente a RAID1, perto de 2 em 4 discos a RAID1+0.
O layout
far X
em discos Y é projetado para oferecer desempenho de leitura distribuído em um array espelhado. Ele faz isso dividindo cada disco em duas seções, digamos, frente e verso, e o que está escrito no disco 1 frontal é espelhado no disco 2 posterior e vice-versa. Isso tem o efeito de ser capaz de distribuir leituras sequenciais, que é de onde RAID0 e RAID5 obtêm seu desempenho. A desvantagem é que a gravação sequencial tem uma penalidade de desempenho muito pequena devido à distância que o disco precisa buscar até a outra seção do disco para armazenar o espelho. RAID10 no layout far2 é, no entanto, preferível a RAID1+0 em camadas
e
RAID5 sempre que as velocidades de leitura forem preocupantes e a disponibilidade / redundância forem cruciais. No entanto, ainda não é um substituto para backups. Veja a página da Wikipedia para mais informações.
Atenção
mdadm não pode remodelar arrays em layouts
far X
, o que significa que uma vez que o array é criado, você não será capaz de realizar
mdadm --grow
nele. Por exemplo, se você tiver um array RAID10 de 4x1TB e quiser mudar para discos de 2TB, sua capacidade utilizável permanecerá 2TB. Para tais casos de uso, use layouts
near X
.
Comparação entre os níveis de RAID
Nível RAID
redundância de dados
Utilização de unidade física
Performance de leitura
Performance de escrita
Min de unidades
0
Não
100%
nX
Melhor
nX
Melhor
2
1
Sim
50%
Até nX se vários processos estiverem lendo, caso contrário, 1X
1X
2
5
Sim
67% - 94%
(n−1)X
Superior
(n−1)X
Superior
3
6
Sim
50% - 88%
(n−2)X
(n−2)X
4
10,far2
Sim
50%
nX
Melhor;
em paridade com RAID0, mas redudante
(n/2)X
2
10,near2
Sim
50%
Até nX se vários processos estiverem lendo, caso contrário, 1X
(n/2)X
2
* Onde
n
representa o número de discos dedicados.
Implementação
Os dispositivos RAID podem ser gerenciados de diferentes maneiras:
Software RAID
Esta é a implementação mais fácil, pois não depende de firmware e software proprietário obscuro para ser usado. O array é gerenciado pelo sistema operacional através de:
uma camada de abstração (e.g.
mdadm
);
Nota
Este é o método que usaremos posteriormente neste guia.
um gerenciador de volume lógico (e.g.
LVM
);
um componente de um sistema de arquivos (e.g.
ZFS
,
Btrfs
).
Hardware RAID
O array é gerenciado diretamente por uma placa de hardware dedicada instalada no PC ao qual os discos são conectados diretamente. A lógica RAID é executada em um processador integrado, independentemente do
processador hospedeiro (CPU)
. Embora esta solução seja independente de qualquer sistema operacional, o último requer um driver para funcionar corretamente com o controlador RAID de hardware. O array RAID pode ser configurado através de uma interface ROM ou, dependendo do fabricante, com um aplicativo dedicado quando o sistema operacional for instalado. A configuração é transparente para o kernel Linux: ele não vê os discos separadamente.
FakeRAID
Este tipo de RAID é chamado de BIOS ou RAID integrado, mas é falsamente anunciado como RAID de hardware. O array é gerenciado por controladores pseudo-RAID onde a lógica RAID é implementada em uma opção rom ou no próprio firmware
com um EFI SataDriver
[
link inativo
2024-01-13 ⓘ]
(no caso de
UEFI
), mas não são controladores RAID de hardware completo com
todos
os recursos RAID implementados. Portanto, este tipo de RAID às vezes é chamado de FakeRAID.
dmraid
dos
repositórios oficiais
, será usado para lidar com esses controladores. Aqui estão alguns exemplos de controladores FakeRAID:
Intel Rapid Storage
, JMicron JMB36x RAID ROM, AMD RAID, ASMedia 106x, and NVIDIA MediaShield.
Que tipo de RAID eu possuo?
Como o RAID de software é implementado pelo usuário, o tipo de RAID é facilmente conhecido por ele.
No entanto, discernir entre o FakeRAID e o verdadeiro RAID de hardware pode ser mais difícil. Como mostrado, os fabricantes muitas vezes distinguem incorretamente esses dois tipos de RAID e a propaganda enganosa sempre é possível. A melhor solução neste caso é executar o comando
lspci
e olhar a saída para encontrar o controlador RAID. Em seguida, faça uma pesquisa para ver quais informações podem ser localizadas sobre o controlador RAID. Os controladores RAID de hardware aparecem nesta lista, mas as implementações FakeRAID não. Além disso, o verdadeiro controlador RAID de hardware costuma ser bastante caro, portanto, se alguém personalizou o sistema, é muito provável que a escolha de uma configuração de RAID de hardware tenha feito uma mudança muito perceptível no preço do computador.
Instalação
Instale
mdadm
.
mdadm
é usado para administrar RAID de software puro usando dispositivos de bloco simples: o hardware subjacente não fornece nenhuma lógica RAID, apenas um suprimento de discos.
mdadm
funcionará com qualquer coleção de dispositivos de bloco. Mesmo que incomum. Por exemplo, pode-se, portanto, fazer um array RAID a partir de uma coleção de pen drives.
Prepare os dispositivos
Atenção
Essas etapas apagam tudo em um dispositivo, então digite com cuidado!
Se o dispositivo estiver sendo reutilizado ou reaproveitado de um array existente, apague todas as informações de configuração RAID antigas:
# mdadm --misc --zero-superblock /dev/<dispositivo>
ou se uma partição específica em uma unidade deve ser excluída:
# mdadm --misc --zero-superblock /dev/<partição>
Nota
Apagar o superbloco de uma partição não deve afetar as outras partições no disco.
Devido à natureza da funcionalidade RAID, é muito difícil
limpar seguramente o disco
totalmente em um array em execução. Considere se é útil fazer isso antes de criá-lo.
Particione os dispositivos
É altamente recomendado particionar os discos a serem usados no array. Como a maioria dos usuários de RAID está selecionando unidades de disco maiores que 2 TiB, o GPT é necessário e recomendado. Veja
Particionamento
para mais informações sobre particionamento e as
ferramentas de particionamento
disponíveis.
Nota
Também é possível criar um RAID diretamente nos discos brutos (sem partições), mas não é recomendado porque pode causar problemas ao trocar um disco com falha.
Dica
Ao substituir um disco com falha de um RAID, o novo disco deve ser exatamente do mesmo tamanho do disco com falha ou maior — caso contrário, o processo de recriação da matriz não funcionará. Mesmo discos rígidos do mesmo fabricante e modelo podem ter pequenas diferenças de tamanho. Ao deixar um pouco de espaço no final do disco não alocado, pode-se compensar as diferenças de tamanho entre as unidades, o que torna a escolha de um modelo de unidade de substituição mais fácil. Portanto, é uma boa prática deixar cerca de 100 MiB de espaço não alocado no final do disco.
Tabela de Partição GUID
Depois de criar as partições, seus
GUIDs de tipo de partição
devem ser
A19D880F-05FC-4D3B-A006-743F0F84911E
(pode ser atribuído selecionando o tipo de partição
Linux RAID
em
fdisk
ou
FD00
no
gdisk
).
Se uma matriz de disco maior for empregada, considere atribuir
rótulos do sistema de arquivos
ou
rótulos de partição
para facilitar a identificação de um disco individual posteriormente.
Recomenda-se a criação de partições do mesmo tamanho em cada um dos dispositivos.
Master Boot Record
Para quem está criando partições em HDDs com uma tabela de partição MBR, os
IDs de tipos de partição
disponíveis para uso são:
0xFD
para arrays de detecção automática de raid (
Linux raid autodetect
em
fdisk
)
0xDA
para dados não-fs (
Non-FS data
em
fdisk
)
Veja
Linux Raid Wiki:Partition Types
para mais informações.
Contrua o array
Use
mdadm
para construir o array. Veja
mdadm(8)
para opções suportadas. Vários exemplos são fornecidos abaixo.
Atenção
Não basta copiar/colar os exemplos abaixo; certifique-se fazer as substituições corretas.
Nota
Se este for um array RAID1 que deve ser inicializado a partir do
Syslinux
, uma limitação do syslinux v4.07 requer que o valor dos metadados seja 1.0 em vez do padrão 1.2.
Ao criar um array a partir do
meio de instalação do Arch
use a opção
--homehost=
myhostname
(ou
--homehost=any
para ter sempre o mesmo nome, independentemente do host) para definir o
hostname
, caso contrário, o hostname
archiso
será escrito nos metadados do array.
Dica
Você pode especificar um nome de dispositivo raid personalizado usando a opção
--name=
MeuNomeDeRaid
ou definindo o caminho do dispositivo raid para
/dev/md/
MeuNomeDeRaid
.Udev irá criar links simbólicos para os arrays raid em
/dev/md/
usando aquele nome. Se o
homehost
corresponde ao
hostname
(ou se homehost está definido como
any
) o link será
/dev/md/
name
, se o homehost não corresponder o link será
/dev/md/
homehost
:
name
.
O exemplo a seguir mostra a construção de um array RAID1 de 2 dispositivos:
# mdadm --create --verbose --level=1 --metadata=1.2 --raid-devices=2 /dev/md/MeuArrayRAID1 /dev/sdb1 /dev/sdc1
O exemplo a seguir mostra a construção de uma matriz RAID5 com 4 dispositivos ativos e 1 dispositivo de reserva:
# mdadm --create --verbose --level=5 --metadata=1.2 --chunk=256 --raid-devices=4 /dev/md/MeuArrayRAID5 /dev/sdb1 /dev/sdc1 /dev/sdd1 /dev/sde1 --spare-devices=1 /dev/sdf1
Dica
--chunk
é usado para mudar o valor padrão para o tamanho do chunk. Veja
Chunks: the hidden key to RAID performance
para mais sobre otimização de tamanho do chunk.
O exemplo a seguir mostra a construção de um array RAID10,far2 com 2 dispositivos:
# mdadm --create --verbose --level=10 --metadata=1.2 --chunk=512 --raid-devices=2 --layout=f2 /dev/md/MeuArrayRAID10 /dev/sdb1 /dev/sdc1
O array é criado no dispositivo virtual
/dev/mdX
, montado e pronto para uso (em modo degradado). Pode-se começar a usá-lo diretamente enquanto o mdadm ressincroniza o array em segundo plano. Pode levar muito tempo para restaurar a paridade. Verifique o progresso com:
$ cat /proc/mdstat
Atualize o arquivo de configuração
Por padrão, a maior parte de
mdadm.conf
é comentada e contém apenas o seguinte:
/etc/mdadm.conf
...
DEVICE partitions
...
Esta diretiva diz ao mdadm para examinar os dispositivos referenciados por
/proc/partitions
e montar tantos arrays quanto possível. Isto é bom se você realmente deseja iniciar todos os arrays disponíveis e está confiante de que nenhum superbloco inesperado será encontrado (como depois de instalar um novo dispositivo de armazenamento). Uma abordagem mais precisa é adicionar explicitamente as matrizes em
/etc/mdadm.conf
:
# mdadm --detail --scan >> /etc/mdadm.conf
Isso resulta em algo como o seguinte:
/etc/mdadm.conf
...
DEVICE partitions
...
ARRAY /dev/md/MeuArrayRAID1 metadata=1.2 name=pine:MeuArrayRAID1 UUID=27664f0d:111e493d:4d810213:9f291abe
Isso também faz com que o mdadm examine os dispositivos referenciados por
/proc/partitions
. No entanto, apenas dispositivos que possuem superblocos com um UUID de
27664…
são montados em arrays ativos.
Veja
mdadm.conf(5)
para mais informações.
Monte o array
Uma vez que o arquivo de configuração tenha sido atualizado, o array pode ser montado usando mdadm:
# mdadm --assemble --scan
Formate o sistema de arquivos RAID
Dica
Para criar vários volumes dentro de um array RAID, siga o artigo
LVM on software RAID
.
O array agora pode ser formatado com um
sistema de arquivos
como qualquer outra partição, apenas tenha em mente que:
Devido ao grande tamanho do volume, nem todos os sistemas de arquivos são adequados (veja:
Wikipedia:Comparison of file systems#Limits
).
O sistema de arquivos deve suportar crescimento e redução enquanto online (veja:
Wikipedia:Comparison of file systems#Features
).
Deve-se calcular o stride correto e a largura de stripe para um desempenho ideal.
Calculando o stride e a largura do stripe
Dois parâmetros são necessários para otimizar a estrutura do sistema de arquivos para se encaixar perfeitamente na estrutura RAID subjacente: o
stride
e a
largura de stripe
. Esses são derivados do
tamanho do chunk
do RAID,
tamanho do bloco
do sistema de arquivos, e o
número de "discos de dados"
.
O tamanho do chunk é uma propriedade do array RAID, decidida no momento de sua criação. O padrão atual do
mdadm
é 512 KiB. Pode ser encontrado com
mdadm
:
# mdadm --detail /dev/mdX | grep 'Chunk Size'
O tamanho do bloco é uma propriedade do sistema de arquivos, decidido na
sua
criação. O padrão para muitos sistemas de arquivos, incluindo ext4, é 4 KiB. Veja
/etc/mke2fs.conf
para detalhes sobre ext4.
O número de "discos de dados" é o número mínimo de dispositivos no array necessários para reconstruí-lo completamente sem perda de dados. Por exemplo, este é N para um array raid0 de N dispositivos e N-1 para raid5.
Depois de ter essas três quantidades, o stride e a largura do stripe podem ser calculadas usando as seguintes fórmulas:
stride = tamando do chunk / tamanho do bloco
largura do stripe = número dso discos de dados * stride
Examplo 1. RAID0
Exemplo de formatação para ext4 com a largura de stripe e stride corretos:
O array RAID0 hipotético é composto por 2 discos físicos.
Tamanho do chunk é 512 KiB.
Tamanho do bloco é 4 KiB.
stride = tamanho do chunk / tamanho do bloco. Neste exemplo, a matemática é 512/4, então o stride = 128.
largura do stripe = # de discos físicos de
dados
* stride. Neste exemplo, a matemática é 2*128, então a largura do stripe = 256.
# mkfs.ext4 -v -L meuarray -b 4096 -E stride=128,stripe-width=256 /dev/md0
Examplo 2. RAID5
Exemplo de formatação para ext4 com a largura de stripe e stride corretos:
O array RAID5 hipotético é composto por 4 discos físicos; 3 discos de dados e 1 disco de paridade.
Tamanho do chunk é 512 KiB.
Tamanho do bloco é 4 KiB.
stride = tamanho do chunk / tamanho do bloco. Neste exemplo, a matemática é 512/4, então o stride = 128.
largura do stripe = # de discos físicos de
dados
* stride. Neste exemplo, a matemática é 3*128, então a largura do stripe = 384.
# mkfs.ext4 -v -L meuarray -b 4096 -E stride=128,stripe-width=384 /dev/md0
Para mais sobre stride e largura de stripe, veja:
RAID Math
.
Exemplo 3. RAID10,far2
Exemplo de formatação para ext4 com a largura de stripe e stride corretos:
O array RAID10 hipotético é composto por 2 discos físicos. Por causa das propriedades do RAID10 no layout far2, ambos contam como discos de dados.
Tamanho do chunk é 512 KiB.
Tamanho do bloco é 4 KiB.
stride = tamanho do chunk / tamanho do bloco.
Neste exemplo, a matemática é 512/4, então o stride = 128.
largura do stripe = # de discos físicos de
dados
* stride.
Neste exemplo, a matemática é 2*128 então a largura do stripe = 256.
# mkfs.ext4 -v -L meuarray -b 4096 -E stride=128,stripe-width=256 /dev/md0
Montando a partir de um Live CD
Os usuários que desejam montar a partição RAID a partir de um Live CD, utilize:
# mdadm --assemble /dev/md<número> /dev/<disco1> /dev/<disco2> /dev/<disco3> /dev/<disco4>
Se o seu RAID 1 sem uma matriz de disco foi erroneamente detectado automaticamente como RAID 1 (conforme
mdadm --detail /dev/md<número>
) e reportado como inativo (conforme
cat /proc/mdstat
), pare o array primeiro:
# mdadm --stop /dev/md<número>
Instalando Arch Linux em RAID
Nota
A seção a seguir é aplicável apenas se o sistema de arquivos raiz residir no array. Os usuários podem pular esta seção se o array contiver partição(ões) de dados.
Você deve criar a matriz RAID entre as estapas de
particionamento
e
formatação
do processo de instalação. Em vez de formatar diretamente uma partição para ser seu sistema de arquivos raiz, ela será criada em um array RAID.
Siga a seção
#Instalação
para criar o array RAID. Em seguida, continue com o procedimento de instalação até que a etapa pacstrap seja concluída.
Ao usar
UEFI boot
, também leia
ESP no RAID
.
Atualize o arquivo de configuração
Nota
Isso deve ser feito fora do chroot, daí o prefixo
/mnt
para o caminho do arquivo.
Depois que o sistema básico é instalado, o arquivo de configuração padrão,
mdadm.conf
, deve ser atualizado assim:
# mdadm --detail --scan >> /mnt/etc/mdadm.conf
Sempre verifique o arquivo de configuração
mdadm.conf
usando um editor de texto depois de executar este comando para garantir que seu conteúdo pareça razoável.
Nota
Para evitar falha de
mdmonitor.service
na inicialização (habilitado por padrão), você precisará descomentar
MAILADDR
e fornecer um endereço de e-mail e/ou aplicativo para lidar com a notificação de problemas com sua matriz na parte inferior de
mdadm.conf
. Veja
#Notificações de email
.
Continue com o procedimento de instalação até chegar na etapa
Guia de instalação#Initramfs
, então siga a próxima seção.
Configure mkinitcpio
Nota
Isso deve ser feito em chroot.
Adicione
mdadm_udev
à seção
HOOKS
do
mkinitcpio.conf
para adicionar suporte para mdadm na imagem initramfs:
/etc/mkinitcpio.conf
...
 HOOKS=(base udev autodetect keyboard modconf block
mdadm_udev
filesystems fsck)
...
Se você usar o hook
mdadm_udev
com um array FakeRAID, é recomendado incluir
mdmon
no vetor
BINARIES
:
/etc/mkinitcpio.conf
...
BINARIES=(
mdmon
)
...
Em seguida,
gere o intiramfs novamente
.
Veja também
Mkinitcpio (Português)#Usando RAID
.
Nota
Sempre que você fizer alterações em
/etc/mdadm.conf
, o initramfs precisa ser gerado novamente.
Configure o carregador de boot
Dispositivo raiz
Aponte o parâmetro
root
para o dispositivo mapeado. E.g.:
root=/dev/md/
MeuArrayRAID
Se a inicialização a partir de uma partição raid de software falhar usando o método de nó de dispositivo de kernel acima, uma maneira alternativa é usar um dos métodos de
nomeação de dispositivo de bloco persistente
, por exemplo:
root=LABEL=Root_Label
Veja também
GRUB (Português)#RAID
.
Layout RAID0
Nota
Isso também afeta os usuários mdraid RAID0 existentes que atualizaram de uma versão mais antiga do kernel Linux para 5.3.4 ou mais recente.
Desde a versão 5.3.4 do kernel Linux, você precisa informar explicitamente ao kernel qual layout RAID0 deve ser usado: RAID0_ORIG_LAYOUT (
1
) ou RAID0_ALT_MULTIZONE_LAYOUT (
2
).
[1]
Você pode fazer isso fornecendo o
parâmetro do kernel
conforme a seguir:
raid0.default_layout=2
O valor correto depende da versão do kernel que foi usada para criar o array raid: use
1
se criado usando kernel 3.14 ou anterior, use
2
se estiver usando uma versão mais recente do kernel . Uma maneira de verificar isso é observar o tempo de criação da matriz raid:
mdadm --detail /dev/md1
/dev/md1:
           Version : 1.2
     Creation Time : Thu Sep 24 10:17:41 2015
        Raid Level : raid0
        Array Size : 975859712 (930.65 GiB 999.28 GB)
      Raid Devices : 3
     Total Devices : 3
       Persistence : Superblock is persistent

       Update Time : Thu Sep 24 10:17:41 2015
             State : clean
    Active Devices : 3
   Working Devices : 3
    Failed Devices : 0
     Spare Devices : 0

        Chunk Size : 512K

Consistency Policy : none

              Name : archiso:root
              UUID : 028de718:20a81234:4db79a2c:e94fd560
            Events : 0

    Number   Major   Minor   RaidDevice State
       0     259        2        0      active sync   /dev/nvme0n1p1
       1     259        6        1      active sync   /dev/nvme2n1p1
       2     259        5        2      active sync   /dev/nvme1n1p2
Aqui podemos ver que este array raid foi criado em 24 de setembro de 2015. A data de lançamento do Linux Kernel 3.14 foi 30 de março de 2014 e, como tal, este array raid é provavelmente criado usando um layout de várias zonas (
2
).
Manutenção do RAID
Scrubbing
É uma boa prática executar regularmente um
scrubbing
de dados para verificar e corrigir erros. Dependendo do tamanho/configuração do array, um scrub pode levar várias horas para ser concluído.
Para iniciar um scrub de dados:
# echo check > /sys/block/md0/md/sync_action
A operação check verifica as unidades em busca de setores defeituosos e os repara automaticamente. Se encontrar setores bons que contêm dados ruins (os dados de um setor não correspondem com o que os dados de outro disco indicam que deveria ser, por exemplo o bloco de paridade + os outros blocos de dados nos faria pensar que este bloco de dados está incorreto), nenhuma ação é realizada, mas o evento é registrado em um log (veja abaixo). Este "não fazer nada" permite que os administradores inspecionem os dados no setor e os dados que seriam produzidos pela reconstrução dos setores a partir de informações redundantes e escolham os dados corretos para manter.
Tal como acontece com muitas tarefas/itens relacionados ao mdadm, o status do scrub pode ser consultado lendo
/proc/mdstat
.
Exemplo:
$ cat /proc/mdstat
Personalities : [raid6] [raid5] [raid4] [raid1]
md0 : active raid1 sdb1[0] sdc1[1]
      3906778112 blocks super 1.2 [2/2] [UU]
      [>....................]  check =  4.0% (158288320/3906778112) finish=386.5min speed=161604K/sec
      bitmap: 0/30 pages [0KB], 65536KB chunk
Para interromper um scrub de dados em execução com segurança:
# echo idle > /sys/block/md0/md/sync_action
Nota
Se o sistema for reiniciado após um scrub parcial ter sido suspenso, o scrub será reiniciado.
Quando a limpeza é concluída, os administradores podem verificar quantos blocos (se houver) foram sinalizados como ruins:
# cat /sys/block/md0/md/mismatch_cnt
Notas gerais sobre scrubbing
Nota
Os usuários podem, alternativamente, ecoar
repair
para
/sys/block/md0/md/sync_action
, mas isso é desaconselhável, pois se uma incompatibilidade nos dados for encontrada, ele será atualizado automaticamente para ser consistente. O perigo é que realmente não sabemos se é a paridade ou o bloco de dados que está correto (ou qual bloco de dados no caso de RAID1). É a sorte que define se a operação obtém ou não os dados corretos em vez dos dados ruins.
É uma boa ideia configurar um cron job como root para agendar um scrub periódico. Veja
raid-check
AUR
que pode ajudar com isso. Para realizar um scrub periódico usando cronômetros systemd em vez de cron, consulte
raid-check-systemd
AUR
que contém o mesmo script junto com arquivos de unidade de cronômetro systemd associados.
Nota
Para unidades de discos típicos, a limpeza pode levar aproximadamente
seis segundos por gigabyte
(ou seja, uma hora e quarenta e cinco minutos por terabyte), portanto, planeje o início de seu cron job ou cronômetro apropriadamente.
Notas sobre scrubbing de RAID1 e RAID10
Devido ao fato de que as gravações RAID1 e RAID10 no kernel não são bufferizadas, um array pode ter contagens de incompatibilidade diferente de 0, mesmo quando o array está saudável. Essas contagens diferentes de 0 só existirão em áreas de dados transitórios onde não representam um problema. No entanto, não podemos dizer a diferença entre uma contagem diferente de 0 que está apenas em dados transitórios ou uma contagem diferente de 0 que significa um problema real. Este fato é uma fonte de falsos positivos para arrays RAID1 e RAID10. No entanto, ainda é recomendado realizar scrub regularmente a fim de detectar e corrigir quaisquer setores defeituosos que possam estar presentes nos dispositivos.
Removendo dispositivos de um array
Pode-se remover um dispositivo do array após marcá-lo como defeituoso:
# mdadm --fail /dev/md0 /dev/sdxx
Agora remova-o do array:
# mdadm --remove /dev/md0 /dev/sdxx
Remova o dispositivo permanentemente (por exemplo, para usá-lo individualmente a partir de agora):
Emita os dois comandos descritos acima, então:
# mdadm --zero-superblock /dev/sdxx
Atenção
Não emita este comando em arrays lineares ou RAID0 ou ocorrerá perda de dados!
Reutilizar o disco removido sem zerar o superbloco causará perda de todos os dados na próxima inicialização. (Depois mdadm tentará usá-lo como parte do array raid).
Pare de usar um array:
Desmonte o array alvo
Pare o array com:
mdadm --stop /dev/md0
Repita os três comandos descritos no início desta seção em cada dispositivo.
Remova a linha correspondente de
/etc/mdadm.conf
.
Adicionando um novo dispositivo a um array
Adicionar novos dispositivos com mdadm pode ser feito em um sistema em execução com os dispositivos montados.
Particione o novo dispositivo usando o mesmo layout de um dos que já estão nos arrays, conforme discutido acima.
Monte o array RAID caso ainda não esteja montado:
# mdadm --assemble /dev/md0 /dev/sda1 /dev/sdb1
Adicione o novo dispositivo ao array:
# mdadm --add /dev/md0 /dev/sdc1
Isso não deve demorar muito para o mdadm fazer.
Dependendo do tipo de RAID (por exemplo, com RAID1), o mdadm pode adicionar o dispositivo como extra sem sincronizar dados com ele. Você pode aumentar o número de discos que o RAID usa usando
--grow
com a opção
--raid-devices
. Por exemplo, para aumentar um array para quatro discos:
# mdadm --grow /dev/md0 --raid-devices=4
Você pode verificar o progresso com:
# cat /proc/mdstat
Verifique se o dispositivo foi adicionado com o comando:
# mdadm --misc --detail /dev/md0
Nota
Para arrays RAID0, você pode obter a seguinte mensagem de erro:
mdadm: add new device failed for /dev/sdc1 as 2: Invalid argument
Isso ocorre porque os comandos acima irão adicionar o novo disco como um "sobressalente", mas o RAID0 não possui sobressalentes. Se você deseja adicionar um dispositivo a uma matriz RAID0, você precisa "crescer" e "adicionar" no mesmo comando, conforme demonstrado abaixo:
# mdadm --grow /dev/md0 --raid-devices=3 --add /dev/sdc1
Aumentando o tamanho de um volume RAID
Se discos maiores forem instalados em um array RAID ou o tamanho da partição tiver aumentado, pode ser desejável aumentar o tamanho do volume RAID para preencher o maior espaço disponível. Este processo pode ser iniciado seguindo primeiro as seções acima relacionadas à substituição de discos. Uma vez que o volume RAID tenha sido reconstruído em discos maiores, ele deve ser "aumentado" para preencher o espaço.
# mdadm --grow /dev/md0 --size=max
Em seguida, as partições presentes no volume RAID
/dev/md0
pode precisar ser redimensionadas. Veja
Particionamento
para mais detalhes. Finalmente, o sistema de arquivos na partição mencionada acima precisará ser redimensionado. Se o particionamento foi executado com
gparted
isso será feito automaticamente. Se outras ferramentas foram usadas, desmonte e redimensione o sistema de arquivos manualmente.
# umount /storage
# fsck.ext4 -f /dev/md0p1
# resize2fs /dev/md0p1
Alterar os limites de velocidade de sincronização
Sincronização pode demorar um pouco. Se a máquina não for necessária para outras tarefas, o limite de velocidade pode ser aumentado.
# cat /proc/mdstat
Personalities : [raid1]
 md0 : active raid1 sda3[2] sdb3[1]
       155042219 blocks super 1.2 [2/1] [_U]
       [>....................]  recovery =  0.0% (77696/155042219) finish=265.8min speed=9712K/sec

 unused devices: <none>
Verifique o limite de velocidade atual.
# cat /proc/sys/dev/raid/speed_limit_min
1000
# cat /proc/sys/dev/raid/speed_limit_max
200000
Aumente os limites.
# echo 400000 >/proc/sys/dev/raid/speed_limit_min
# echo 400000 >/proc/sys/dev/raid/speed_limit_max
Em seguida, verifique a velocidade de sincronização e o tempo estimado de término.
# cat /proc/mdstat
Personalities : [raid1]
 md0 : active raid1 sda3[2] sdb3[1]
       155042219 blocks super 1.2 [2/1] [_U]
       [>....................]  recovery =  1.3% (2136640/155042219) finish=158.2min speed=16102K/sec

 unused devices: <none>
Veja também
sysctl#MDADM
.
Performance do RAID5
Para melhorar o desempenho do RAID5 para armazenamento rápido (e.g.
NVMe
), aumente
/sys/block/mdx/md/group_thread_cnt
para mais threads. Por exemplo, para usar 8 threads para operar em um dispositivo RAID5:
# echo 8 > /sys/block/md0/md/group_thread_cnt
Veja
git kernel commit 851c30c9badf
.
Atualizar o superbloco RAID
Para atualizar o superbloco RAID, você precisa primeiro desmontar o array e depois parar o array com o seguinte comando:
# mdadm --stop /dev/md0
Então você pode atualizar certos parâmetros remontando o matriz. Por exemplo, para atualizar o
homehost
:
# mdadm --assemble --update=homehost --homehost=NAS /dev/md0 /dev/sda1 /dev/sdb1
Veja os argumentos de
--update
para detalhes.
Monitoramento
Uma linha simples que imprime o status dos dispositivos RAID:
# awk '/^md/ {printf "%s: ", $1}; /blocks/ {print $NF}' </proc/mdstat
md1: [UU]
md0: [UU]
Observe o status com mdstat
# watch -t 'cat /proc/mdstat'
Ou de preferência usando
tmux
# tmux split-window -l 12 "watch -t 'cat /proc/mdstat'"
Rastrear ES com iotop
O pacote
iotop
exibe as estatísticas de entrada/saída para processos. Use este comando para ver a ES para threads de raid.
# iotop -a $(sed 's/^/-p /g' <<<`pgrep "_raid|_resync|jbd2"`)
Rastrear ES com iostat
O utilitário
iostat
do pacote
sysstat
exibe as estatísticas de entrada/saída para dispositivos e partições.
# iostat -dmy 1 /dev/md0
# iostat -dmy 1 # all
Notificações de email
mdadm
fornece o serviço
systemd
mdmonitor.service
que pode ser útil para monitorar a integridade de seus arrays raid e notificar por e-mail se algo der errado.
Este serviço é especial porque não pode ser ativado manualmente como um serviço normal;
mdadm
cuidará de ativá-lo via udev ao montar seus arrays na inicialização do sistema, mas
apenas
fará isso se um endereço de e-mail tiver sido configurado para suas notificações (veja abaixo).
Atenção
A falha na configuração de um endereço de e-mail resultará na falha silenciosa do serviço de monitoramento ao iniciar.
Nota
Para enviar e-mails, é necessário um
agente de transferência de correio
devidamente configurado.
Para habilitar esta funcionalidade, edite
/etc/mdadm.conf
e defina o endereço de e-mail:
MAILADDR
usuário@domínio
Então, para verificar se tudo está funcionando como deveria, execute o seguinte comando:
# mdadm --monitor --scan --oneshot --test
Se o teste for bem-sucedido e o e-mail for entregue, você está pronto; da próxima vez que seus arrays forem remontados,
mdmonitor.service
começará a monitorá-los em busca de erros.
Solução de problemas
Se você estiver recebendo um erro ao reinicializar sobre "invalid raid superblock magic" e tiver discos rígidos adicionais além dos que você instalou, verifique se a ordem do seu disco rígido está correta. Durante a instalação, seus dispositivos RAID podem ser hdd, hde e hdf, mas durante a inicialização eles podem ser hda, hdb e hdc. Ajuste sua linha de kernel de acordo.
Error: "kernel: ataX.00: revalidation failed"
Se você repentinamente (após reiniciar, alterou as configurações do BIOS) receber mensagens de erro como:
Feb  9 08:15:46 hostserver kernel: ata8.00: revalidation failed (errno=-5)
Isso não significa necessariamente que uma unidade está quebrada. Frequentemente, você encontra links de pânico na web que apontam o pior. Em poucas palavras, sem pânico. Talvez você tenha alterado as configurações de APIC ou ACPI dentro de seus parâmetros de BIOS ou Kernel de alguma forma. Troque-os de volta e deverá voltar a funcionar bem. Normalmente, desligar ACPI e/ou ACPI deve ajudar.
Iniciar arrays em somente leitura
Quando um array md é iniciado, o superbloco será escrito e a ressincronização pode começar. Para iniciar somente leitura, defina o módulo do kernel
md_mod
com o parâmetro
start_ro
. Quando isso é definido, os novos arrays obtêm um modo 'auto-ro', que desativa todos as ES internas (atualizações de superbloco, ressincronização, recuperação) e é automaticamente alterado para 'rw' quando a primeira solicitação de gravação chega.
Nota
O array pode ser configurado para o modo 'ro' verdadeiro usando
mdadm --readonly
antes da primeira solicitação de gravação, ou a ressincronização pode ser iniciada sem uma gravação usando
mdadm --readwrite
.
Para definir o parâmetro na inicialização, adicione
md_mod.start_ro=1
à sua linha de kernel.
Ou defina-o no tempo de carregamento do módulo no arquivo
/etc/modprobe.d/
ou diretamente em
/sys/
:
# echo 1 > /sys/module/md_mod/parameters/start_ro
Recuperando de uma unidade quebrada ou perdida no raid
Você pode obter o erro mencionado acima também quando uma das unidades quebrar por qualquer motivo. Nesse caso, você terá que forçar o raid a ainda ligar, mesmo com um disco curto. Digite isto (mude onde necessário):
# mdadm --manage /dev/md0 --run
Agora você deve ser capaz de montá-lo novamente com algo assim (se você o tinha no fstab):
# mount /dev/md0
Agora o raid deve estar funcionando novamente e disponível para uso, porém com um disco a menos! Portanto, para adicionar essa partição de um disco da maneira descrita acima em
#Prepare os dispositivos
. Depois de fazer isso, você pode adicionar o novo disco ao raid fazendo:
# mdadm --manage --add /dev/md0 /dev/sdd1
Se você digitar:
# cat /proc/mdstat
você provavelmente verá que o raid agora está ativo e reconstruindo.
Você também pode querer atualizar suas configurações (veja:
#Atualize o arquivo de configuração
).
Benchmarking
Existem várias ferramentas para fazer benchmarking em um RAID. A melhoria mais notável é o aumento da velocidade quando várias threads estão lendo do mesmo volume RAID.
bonnie++
testa o analisa o tipo de acesso ao banco de dados para um ou mais arquivos e criação, leitura e exclusão de pequenos arquivos que podem simular o uso de programas como Squid, INN ou formato Maildir e-mail. O programa anexo
ZCAV
testa o desempenho de diferentes zonas de um disco rígido sem gravar nenhum dado no disco.
hdparm
não
deve ser usado para fazer benchmarking em um RAID, porque fornece resultados muito inconsistentes.
Veja também
Linux Software RAID
(thomas-krenn.com)
Linux RAID wiki entry
[
link inativo
2024-10-12 ⓘ]
on The Linux Kernel Archives
How Bitmaps Work
Chapter 15: Redundant Array of Independent Disks (RAID)
[
link inativo
2024-07-30 ⓘ]
of Red Hat Enterprise Linux 6 Documentation
Linux-RAID FAQ
on the Linux Documentation Project
BAARF
(Archive.org) including
Why should I not use RAID 5?
(Archive.org) by Art S. Kagel
Introduction to RAID
,
Nested-RAID: RAID-5 and RAID-6 Based Configurations
,
Intro to Nested-RAID: RAID-01 and RAID-10
, and
Nested-RAID: The Triple Lindy
in Linux Magazine
HowTo: Speed Up Linux Software Raid Building And Re-syncing
Wikipedia:Non-RAID drive architectures
Lista de discução
Kernel Linux-Raid mailing list
mdadm
mdadm source code
Software RAID on Linux with mdadm
in Linux Magazine
Wikipedia - mdadm
Tópicos de fórum
Raid Performance Improvements with bitmaps
GRUB and GRUB2
Can't install grub2 on software RAID
Use RAID metadata 1.2 in boot and root partition