RAID (Portuguê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.
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.
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:
- 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
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>
- 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.
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çãoLinux RAID
em fdisk ouFD00
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.
- 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 hostnamearchiso
será escrito nos metadados do array.
--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
--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
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
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
/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.
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
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.
/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
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
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
/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-checkAUR que pode ajudar com isso. Para realizar um scrub periódico usando cronômetros systemd em vez de cron, consulte raid-check-systemdAUR que contém o mesmo script junto com arquivos de unidade de cronômetro systemd associados.
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
- 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
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).
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.
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
mdadm
- mdadm source code
- Software RAID on Linux with mdadm in Linux Magazine
- Wikipedia - mdadm
Tópicos de fórum