RAID (Português) - ArchWiki

Jump to content
From ArchWiki

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 (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-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.

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:

1. Desmonte o array alvo
2. Pare o array com: `mdadm --stop /dev/md0`
3. Repita os três comandos descritos no início desta seção em cada dispositivo.
4. 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 on The Linux Kernel Archives
- How Bitmaps Work
- Chapter 15: Redundant Array of Independent Disks (RAID) 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

Category:

- Storage virtualization (Português)