{"id":11850,"date":"2019-03-17T14:44:00","date_gmt":"2019-03-17T14:44:00","guid":{"rendered":"http:\/\/www.appservgrid.com\/paw92\/?p=11850"},"modified":"2019-03-17T14:44:00","modified_gmt":"2019-03-17T14:44:00","slug":"introduction-to-raid-concepts-of-raid-and-raid-levels-in-linux","status":"publish","type":"post","link":"https:\/\/www.appservgrid.com\/paw92\/index.php\/2019\/03\/17\/introduction-to-raid-concepts-of-raid-and-raid-levels-in-linux\/","title":{"rendered":"Introduction to RAID, Concepts of RAID and RAID Levels in Linux"},"content":{"rendered":"

RAID<\/b>\u00a0is a Redundant Array of Inexpensive disks, but nowadays it is called Redundant Array of Independent drives. Earlier it is used to be very costly to buy even a smaller size of disk, but nowadays we can buy a large size of disk with the same amount like before. Raid is just a collection of disks in a pool to become a logical volume.<\/p>\n

\n

\"RAID<\/a><\/p>\n

Understanding RAID Setups in Linux<\/p>\n<\/div>\n

Raid contains groups or sets or Arrays. A combine of drivers make a group of disks to form a RAID Array or RAID set. It can be a minimum of 2 number of disk connected to a raid controller and make a logical volume or more drives can be in a group. Only one Raid level can be applied in a group of disks. Raid are used when we need excellent performance. According to our selected raid level, performance will differ. Saving our data by fault tolerance & high availability.<\/p>\n

This series will be titled Preparation for the setting up RAID \u2018s through Parts 1-9 and covers the following topics.<\/p>\n

Part 1<\/b>:\u00a0Introduction to RAID, Concepts of RAID and RAID Levels<\/b><\/div>\n
Part 2<\/b>:\u00a0How to setup RAID0 (Stripe) in Linux<\/div>\n
Part 3<\/b>:\u00a0How to setup RAID1 (Mirror) in Linux<\/div>\n
Part 4<\/b>:\u00a0How to setup RAID5 (Striping with Distributed Parity) in Linux<\/div>\n
Part 5<\/b>:\u00a0How to setup RAID6 (Striping with Double Distributed Parity) in Linux<\/div>\n
Part 6<\/b>:\u00a0Setting Up RAID 10 or 1+0 (Nested) in Linux<\/div>\n
Part 7<\/b>:\u00a0Growing an Existing RAID Array and Removing Failed Disks in Raid<\/div>\n
Part 8<\/b>:\u00a0How to Recover Data and Rebuild Failed Software RAID\u2019s<\/div>\n
Part 9<\/b>:\u00a0How to Manage Software RAID\u2019s in Linux with \u2018Mdadm\u2019 Tool<\/div>\n

This is the Part 1 of a 9-tutorial series, here we will cover the introduction of RAID, Concepts of RAID and RAID Levels that are required for the setting up RAID in Linux.<\/p>\n

Software RAID and Hardware RAID<\/h3>\n

Software RAID<\/b>\u00a0have low performance, because of consuming resource from hosts. Raid software need to load for read data from software raid volumes. Before loading raid software, OS need to get boot to load the raid software. No need of Physical hardware in software raids. Zero cost investment.<\/p>\n

Hardware RAID<\/b>\u00a0have high performance. They are dedicated RAID Controller which is Physically built using PCI express cards. It won\u2019t use the host resource. They have NVRAM for cache to read and write. Stores cache while rebuild even if there is power-failure, it will store the cache using battery power backups. Very costly investments needed for a large scale.<\/p>\n

Hardware RAID Card will look like below:<\/p>\n

\n

\"Hardware<\/a><\/p>\n

Hardware RAID<\/p>\n<\/div>\n

Featured Concepts of RAID<\/h4>\n
    \n
  1. Parity<\/b>\u00a0method in raid regenerate the lost content from parity saved information\u2019s. RAID 5, RAID 6 Based on Parity.<\/li>\n
  2. Stripe<\/b>\u00a0is sharing data randomly to multiple disk. This won\u2019t have full data in a single disk. If we use 3 disks half of our data will be in each disks.<\/li>\n
  3. Mirroring<\/b>\u00a0is used in RAID 1 and RAID 10. Mirroring is making a copy of same data. In RAID 1 it will save the same content to the other disk too.<\/li>\n
  4. Hot spare<\/b>\u00a0is just a spare drive in our server which can automatically replace the failed drives. If any one of the drive failed in our array this hot spare drive will be used and rebuild automatically.<\/li>\n
  5. Chunks<\/b>\u00a0are just a size of data which can be minimum from 4KB and more. By defining chunk size we can increase the I\/O performance.<\/li>\n<\/ol>\n

    RAID\u2019s are in various Levels. Here we will see only the RAID Levels which is used mostly in real environment.<\/p>\n

      \n
    1. RAID0<\/b>\u00a0= Striping<\/li>\n
    2. RAID1<\/b>\u00a0= Mirroring<\/li>\n
    3. RAID5<\/b>\u00a0= Single Disk Distributed Parity<\/li>\n
    4. RAID6<\/b>\u00a0= Double Disk Distributed Parity<\/li>\n
    5. RAID10<\/b>\u00a0= Combine of Mirror & Stripe. (Nested RAID)<\/li>\n<\/ol>\n

      RAID are managed using\u00a0mdadm<\/b>\u00a0package in most of the Linux distributions. Let us get a Brief look into each RAID Levels.<\/p>\n

      RAID 0 (or) Striping<\/h4>\n

      Striping have a excellent performance. In Raid 0 (Striping) the data will be written to disk using shared method. Half of the content will be in one disk and another half will be written to other disk.<\/p>\n

      Let us assume we have 2 Disk drives, for example, if we write data \u201cTECMINT<\/b>\u201d to logical volume it will be saved as \u2018T<\/b>\u2018 will be saved in first disk and \u2018E<\/b>\u2018 will be saved in Second disk and \u2018C<\/b>\u2018 will be saved in First disk and again \u2018M<\/b>\u2018 will be saved in Second disk and it continues in round-robin process.<\/p>\n

      In this situation if any one of the drive fails we will loose our data, because with half of data from one of the disk can\u2019t use to rebuilt the raid. But while comparing to Write Speed and performance RAID 0 is Excellent. We need at least minimum 2 disks to create a RAID 0 (Striping). If you need your valuable data don\u2019t use this RAID LEVEL.<\/p>\n

        \n
      1. High Performance.<\/li>\n
      2. There is Zero Capacity Loss in RAID 0<\/li>\n
      3. Zero Fault Tolerance.<\/li>\n
      4. Write and Reading will be good performance.<\/li>\n<\/ol>\n

        RAID 1 (or) Mirroring<\/h4>\n

        Mirroring have a good performance. Mirroring can make a copy of same data what we have. Assuming we have two numbers of 2TB Hard drives, total there we have 4TB, but in mirroring while the drives are behind the RAID Controller to form a Logical drive Only we can see the 2TB of logical drive.<\/p>\n

        While we save any data, it will write to both 2TB Drives. Minimum two drives are needed to create a RAID 1 or Mirror. If a disk failure occurred we can reproduce the raid set by replacing a new disk. If any one of the disk fails in RAID 1, we can get the data from other one as there was a copy of same content in the other disk. So there is zero data loss.<\/p>\n

          \n
        1. Good Performance.<\/li>\n
        2. Here Half of the Space will be lost in total capacity.<\/li>\n
        3. Full Fault Tolerance.<\/li>\n
        4. Rebuilt will be faster.<\/li>\n
        5. Writing Performance will be slow.<\/li>\n
        6. Reading will be good.<\/li>\n
        7. Can be used for operating systems and database for small scale.<\/li>\n<\/ol>\n

          RAID 5 (or) Distributed Parity<\/h4>\n

          RAID 5 is mostly used in enterprise levels. RAID 5 work by distributed parity method. Parity info will be used to rebuild the data. It rebuilds from the information left on the remaining good drives. This will protect our data from drive failure.<\/p>\n

          Assume we have 4 drives, if one drive fails and while we replace the failed drive we can rebuild the replaced drive from parity informations. Parity information\u2019s are Stored in all 4 drives, if we have 4 numbers of 1TB hard-drive. The parity information will be stored in 256GB in each drivers and other 768GB in each drives will be defined for Users. RAID 5 can be survive from a single Drive failure, If drives fails more than 1 will cause loss of data\u2019s.<\/p>\n

            \n
          1. Excellent Performance<\/li>\n
          2. Reading will be extremely very good in speed.<\/li>\n
          3. Writing will be Average, slow if we won\u2019t use a Hardware RAID Controller.<\/li>\n
          4. Rebuild from Parity information from all drives.<\/li>\n
          5. Full Fault Tolerance.<\/li>\n
          6. 1 Disk Space will be under Parity.<\/li>\n
          7. Can be used in file servers, web servers, very important backups.<\/li>\n<\/ol>\n

            RAID 6 Two Parity Distributed Disk<\/h4>\n

            RAID 6 is same as RAID 5 with two parity distributed system. Mostly used in a large number of arrays. We need minimum 4 Drives, even if there 2 Drive fails we can rebuild the data while replacing new drives.<\/p>\n

            Very slower than RAID 5, because it writes data to all 4 drivers at same time. Will be average in speed while we using a Hardware RAID Controller. If we have 6 numbers of 1TB hard-drives 4 drives will be used for data and 2 drives will be used for Parity.<\/p>\n

              \n
            1. Poor Performance.<\/li>\n
            2. Read Performance will be good.<\/li>\n
            3. Write Performance will be Poor if we not using a Hardware RAID Controller.<\/li>\n
            4. Rebuild from 2 Parity Drives.<\/li>\n
            5. Full Fault tolerance.<\/li>\n
            6. 2 Disks space will be under Parity.<\/li>\n
            7. Can be Used in Large Arrays.<\/li>\n
            8. Can be use in backup purpose, video streaming, used in large scale.<\/li>\n<\/ol>\n

              RAID 10 (or) Mirror & Stripe<\/h4>\n

              RAID 10 can be called as 1+0 or 0+1. This will do both works of Mirror & Striping. Mirror will be first and stripe will be the second in RAID 10. Stripe will be the first and mirror will be the second in RAID 01. RAID 10 is better comparing to 01.<\/p>\n

              Assume, we have 4 Number of drives. While I\u2019m writing some data to my logical volume it will be saved under All 4 drives using mirror and stripe methods.<\/p>\n

              If I\u2019m writing a data \u201cTECMINT<\/b>\u201d in RAID 10 it will save the data as follow. First \u201cT<\/b>\u201d will write to both disks and second \u201cE<\/b>\u201d will write to both disk, this step will be used for all data write. It will make a copy of every data to other disk too.<\/p>\n

              Same time it will use the RAID 0 method and write data as follow \u201cT<\/b>\u201d will write to first disk and \u201cE<\/b>\u201d will write to second disk. Again \u201cC<\/b>\u201d will write to first Disk and \u201cM<\/b>\u201d to second disk.<\/p>\n

                \n
              1. Good read and write performance.<\/li>\n
              2. Here Half of the Space will be lost in total capacity.<\/li>\n
              3. Fault Tolerance.<\/li>\n
              4. Fast rebuild from copying data.<\/li>\n
              5. Can be used in Database storage for high performance and availability.<\/li>\n<\/ol>\n

                Conclusion<\/h3>\n

                In this article we have seen what is RAID and which levels are mostly used in RAID in real environment. Hope you have learned the write-up about RAID. For RAID setup one must know about the basic Knowledge about RAID. The above content will fulfil basic understanding about RAID.<\/p>\n

                In the next upcoming articles I\u2019m going to cover how to setup and create a RAID using Various Levels, Growing a RAID Group (Array) and Troubleshooting with failed Drives and much more.<\/p>\n

                Creating Software RAID0 (Stripe) on \u2018Two Devices\u2019 Using \u2018mdadm\u2019 Tool in Linux \u2013 Part 2<\/h1>\n

                RAID<\/strong>\u00a0is Redundant Array of Inexpensive disks, used for high availability and reliability in large scale environments, where data need to be protected than normal use. Raid is just a collection of disks in a pool to become a logical volume and contains an array. A combine drivers makes an array or called as set of (group).<\/p>\n

                RAID can be created, if there are minimum 2 number of disk connected to a raid controller and make a logical volume or more drives can be added in an array according to defined RAID Levels. Software Raid are available without using Physical hardware those are called as software raid. Software Raid will be named as Poor man raid.<\/p>\n

                \n

                \"Setup<\/a><\/p>\n

                Setup RAID0 in Linux<\/p>\n<\/div>\n

                Main concept of using RAID is to save data from Single point of failure, means if we using a single disk to store the data and if it\u2019s failed, then there is no chance of getting our data back, to stop the data loss we need a fault tolerance method. So, that we can use some collection of disk to form a RAID set.<\/p>\n

                What is Stripe in RAID 0?<\/h4>\n

                Stripe is striping data across multiple disk at the same time by dividing the contents. Assume we have two disks and if we save content to logical volume it will be saved under both two physical disks by dividing the content. For better performance\u00a0RAID 0<\/strong>\u00a0will be used, but we can\u2019t get the data if one of the drive fails. So, it isn\u2019t a good practice to use RAID 0. The only solution is to install operating system with RAID0 applied logical volumes to safe your important files.<\/p>\n

                  \n
                1. RAID 0 has High Performance.<\/li>\n
                2. Zero Capacity Loss in RAID 0. No Space will be wasted.<\/li>\n
                3. Zero Fault Tolerance ( Can\u2019t get back the data if any one of disk fails).<\/li>\n
                4. Write and Reading will be Excellent.<\/li>\n<\/ol>\n

                  Requirements<\/h4>\n

                  Minimum number of disks are allowed to create RAID 0 is\u00a02<\/strong>, but you can add more disk but the order should be twice as 2, 4, 6, 8. If you have a Physical RAID card with enough ports, you can add more disks.<\/p>\n

                  Here we are not using a Hardware raid, this setup depends only on Software RAID. If we have a physical hardware raid card we can access it from it\u2019s utility\u00a0UI<\/strong>. Some motherboard by default in-build with RAID feature, there\u00a0UI<\/strong>\u00a0can be accessed using\u00a0Ctrl+I<\/b>\u00a0keys.<\/p>\n

                  If you\u2019re new to RAID setups, please read our earlier article, where we\u2019ve covered some basic introduction of about RAID.<\/p>\n

                    \n
                  1. Introduction to RAID and RAID Concepts<\/a><\/li>\n<\/ol>\n
                    My Server Setup<\/h5>\n
                    Operating System :\tCentOS 6.5 Final\r\nIP Address\t :\t192.168.0.225\r\nTwo Disks\t :\t20 GB each\r\n<\/pre>\n
                    This article is Part 2 of a 9-tutorial RAID series, here in this part, we are going to see how we can create and setup Software\u00a0RAID0<\/strong>\u00a0or striping in Linux systems or servers using two\u00a020GB<\/strong>\u00a0disks named\u00a0sdb<\/b>\u00a0and\u00a0sdc<\/b>.<\/p>\n
                    Step 1: Updating System and Installing mdadm for Managing RAID<\/h3>\n
                    1.<\/strong>\u00a0Before setting up RAID0 in Linux, let\u2019s do a system update and then install \u2018mdadm<\/strong>\u2018 package. The mdadm is a small program, which will allow us to configure and manage RAID devices in Linux.<\/p>\n
                    # yum clean all && yum update\r\n# yum install mdadm -y\r\n<\/pre>\n
                    \n
                    \"install<\/a><\/p>\n
                    Install mdadm Tool<\/p>\n<\/div>\n
                    Step 2: Verify Attached Two 20GB Drives<\/h3>\n
                    2.<\/strong>\u00a0Before creating RAID 0, make sure to verify that the attached two hard drives are detected or not, using the following command.<\/p>\n
                    # ls -l \/dev | grep sd\r\n<\/pre>\n
                    \n
                    \"Check<\/a><\/p>\n
                    Check Hard Drives<\/p>\n<\/div>\n
                    3.<\/strong>\u00a0Once the new hard drives detected, it\u2019s time to check whether the attached drives are already using any existing raid with the help of following \u2018mdadm\u2019 command.<\/p>\n
                    # mdadm --examine \/dev\/sd[b-c]\r\n<\/pre>\n
                    \n
                    \"Check<\/a><\/p>\n
                    Check RAID Devices<\/p>\n<\/div>\n
                    In the above output, we come to know that none of the RAID have been applied to these two\u00a0sdb<\/b>\u00a0and\u00a0sdc<\/b>\u00a0drives.<\/p>\n
                    Step 3: Creating Partitions for RAID<\/h3>\n
                    4.<\/strong>\u00a0Now create\u00a0sdb<\/b>\u00a0and\u00a0sdc<\/b>\u00a0partitions for raid, with the help of following fdisk command. Here, I will show how to create partition on\u00a0sdb<\/b>\u00a0drive.<\/p>\n
                    # fdisk \/dev\/sdb\r\n<\/pre>\n
                    Follow below instructions for creating partitions.<\/p>\n
                      \n
                    1. Press \u2018n<\/strong>\u2018 for creating new partition.<\/li>\n
                    2. Then choose \u2018P<\/strong>\u2018 for Primary partition.<\/li>\n
                    3. Next select the partition number as\u00a01<\/strong>.<\/li>\n
                    4. Give the default value by just pressing two times\u00a0Enter<\/strong>\u00a0key.<\/li>\n
                    5. Next press \u2018P<\/strong>\u2018 to print the defined partition.<\/li>\n<\/ol>\n
                      \n
                      \"Create<\/a><\/p>\n
                      Create Partitions<\/p>\n<\/div>\n
                      Follow below instructions for creating Linux raid auto on partitions.<\/p>\n
                        \n
                      1. Press \u2018L<\/strong>\u2018 to list all available types.<\/li>\n
                      2. Type \u2018t<\/strong>\u2018to choose the partitions.<\/li>\n
                      3. Choose \u2018fd<\/strong>\u2018 for Linux raid auto and press Enter to apply.<\/li>\n
                      4. Then again use \u2018P<\/strong>\u2018 to print the changes what we have made.<\/li>\n
                      5. Use \u2018w<\/strong>\u2018 to write the changes.<\/li>\n<\/ol>\n
                        \n
                        \"Create<\/a><\/p>\n
                        Create RAID Partitions in Linux<\/p>\n<\/div>\n
                        Note<\/strong>: Please follow same above instructions to create partition on\u00a0sdc<\/b>\u00a0drive now.<\/p>\n
                        5.<\/strong>\u00a0After creating partitions, verify both the drivers are correctly defined for RAID using following command.<\/p>\n
                        # mdadm --examine \/dev\/sd[b-c]\r\n# mdadm --examine \/dev\/sd[b-c]1\r\n<\/pre>\n
                        \n
                        \"Verify<\/a><\/p>\n
                        Verify RAID Partitions<\/p>\n<\/div>\n
                        Step 4: Creating RAID md Devices<\/h3>\n
                        6.<\/strong>\u00a0Now create md device (i.e.\u00a0\/dev\/md0<\/strong>) and apply raid level using below command.<\/p>\n
                        # mdadm -C \/dev\/md0 -l raid0 -n 2 \/dev\/sd[b-c]1\r\n# mdadm --create \/dev\/md0 --level=stripe --raid-devices=2 \/dev\/sd[b-c]1\r\n<\/pre>\n
                          \n
                        1. -C<\/b>\u00a0\u2013 create<\/li>\n
                        2. -l<\/b>\u00a0\u2013 level<\/li>\n
                        3. -n<\/b>\u00a0\u2013 No of raid-devices<\/li>\n<\/ol>\n
                          7.<\/strong>\u00a0Once md device has been created, now verify the status of\u00a0RAID Level<\/strong>,\u00a0Devices<\/strong>\u00a0and\u00a0Array<\/strong>\u00a0used, with the help of following series of commands as shown.<\/p>\n
                          # cat \/proc\/mdstat\r\n<\/pre>\n
                          \n
                          \"Verify<\/a><\/p>\n
                          Verify RAID Level<\/p>\n<\/div>\n
                          # mdadm -E \/dev\/sd[b-c]1\r\n<\/pre>\n
                          \n
                          \"Verify<\/a><\/p>\n
                          Verify RAID Device<\/p>\n<\/div>\n
                          # mdadm --detail \/dev\/md0\r\n<\/pre>\n
                          \n
                          \"Verify<\/a><\/p>\n
                          Verify RAID Array<\/p>\n<\/div>\n
                          Step 5: Assiging RAID Devices to Filesystem<\/h3>\n
                          8.<\/strong>\u00a0Create a ext4 filesystem for a RAID device\u00a0\/dev\/md0<\/strong>\u00a0and mount it under\u00a0\/dev\/raid0<\/strong>.<\/p>\n
                          # mkfs.ext4 \/dev\/md0\r\n<\/pre>\n
                          \n
                          \"Create<\/a><\/p>\n
                          Create ext4 Filesystem<\/p>\n<\/div>\n
                          9.<\/strong>\u00a0Once ext4 filesystem has been created for Raid device, now create a mount point directory (i.e.\u00a0\/mnt\/raid0<\/strong>) and mount the device\u00a0\/dev\/md0<\/strong>\u00a0under it.<\/p>\n
                          # mkdir \/mnt\/raid0\r\n# mount \/dev\/md0 \/mnt\/raid0\/\r\n<\/pre>\n
                          10.<\/strong>\u00a0Next, verify that the device\u00a0\/dev\/md0<\/strong>\u00a0is mounted under\u00a0\/mnt\/raid0<\/strong>\u00a0directory using\u00a0df<\/strong>\u00a0command.<\/p>\n
                          # df -h\r\n<\/pre>\n
                          11.<\/strong>\u00a0Next, create a file called \u2018tecmint.txt<\/strong>\u2018 under the mount point\u00a0\/mnt\/raid0<\/strong>, add some content to the created file and view the content of a file and directory.<\/p>\n
                          # touch \/mnt\/raid0\/tecmint.txt\r\n# echo \"Hi everyone how you doing ?\" > \/mnt\/raid0\/tecmint.txt\r\n# cat \/mnt\/raid0\/tecmint.txt\r\n# ls -l \/mnt\/raid0\/\r\n<\/pre>\n
                          \n
                          \"Verify<\/a><\/p>\n
                          Verify Mount Device<\/p>\n<\/div>\n
                          12.<\/strong>\u00a0Once you\u2019ve verified mount points, it\u2019s time to create an fstab entry in\u00a0\/etc\/fstab<\/strong>\u00a0file.<\/p>\n
                          # vim \/etc\/fstab\r\n<\/pre>\n
                          Add the following entry as described. May vary according to your mount location and filesystem you using.<\/p>\n
                          \/dev\/md0                \/mnt\/raid0              ext4    defaults         0 0\r\n<\/pre>\n
                          \n
                          \"Add<\/a><\/p>\n
                          Add Device to Fstab<\/p>\n<\/div>\n
                          13.<\/strong>\u00a0Run mount \u2018-a<\/strong>\u2018 to check if there is any error in fstab entry.<\/p>\n
                          # mount -av\r\n<\/pre>\n
                          \n
                          \"Check<\/a><\/p>\n
                          Check Errors in Fstab<\/p>\n<\/div>\n
                          Step 6: Saving RAID Configurations<\/h3>\n
                          14.<\/strong>\u00a0Finally, save the raid configuration to one of the file to keep the configurations for future use. Again we use \u2018mdadm\u2019 command with \u2018-s<\/strong>\u2018 (scan) and \u2018-v<\/strong>\u2018 (verbose) options as shown.<\/p>\n
                          # mdadm -E -s -v >> \/etc\/mdadm.conf\r\n# mdadm --detail --scan --verbose >> \/etc\/mdadm.conf\r\n# cat \/etc\/mdadm.conf\r\n<\/pre>\n
                          \n
                          \"Save<\/a><\/p>\n
                          Save RAID Configurations<\/p>\n<\/div>\n
                          That\u2019s it, we have seen here, how to configure RAID0 striping with raid levels by using two hard disks. In next article, we will see how to setup\u00a0RAID5<\/strong>.<\/p>\n
                          Setting up RAID 1 (Mirroring) using \u2018Two Disks\u2019 in Linux \u2013 Part 3<\/h1>\n
                          RAID Mirroring<\/strong>\u00a0means an exact clone (or mirror) of the same data writing to two drives. A minimum two number of disks are more required in an array to create RAID1 and it\u2019s useful only, when read performance or reliability is more precise than the data storage capacity.<\/p>\n
                          \n
                          \"Create<\/a><\/p>\n
                          Setup Raid1 in Linux<\/p>\n<\/div>\n
                          Mirrors are created to protect against data loss due to disk failure. Each disk in a mirror involves an exact copy of the data. When one disk fails, the same data can be retrieved from other functioning disk. However, the failed drive can be replaced from the running computer without any user interruption.<\/p>\n
                          Features of RAID 1<\/h3>\n
                            \n
                          1. Mirror has Good Performance.<\/li>\n
                          2. 50% of space will be lost. Means if we have two disk with 500GB size total, it will be 1TB but in Mirroring it will only show us 500GB.<\/li>\n
                          3. No data loss in Mirroring if one disk fails, because we have the same content in both disks.<\/li>\n
                          4. Reading will be good than writing data to drive.<\/li>\n<\/ol>\n
                            Requirements<\/h4>\n
                            Minimum Two number of disks are allowed to create RAID 1, but you can add more disks by using twice as 2, 4, 6, 8. To add more disks, your system must have a RAID physical adapter (hardware card).<\/p>\n
                            Here we\u2019re using software raid not a Hardware raid, if your system has an inbuilt physical hardware raid card you can access it from it\u2019s utility UI or using\u00a0Ctrl+I key<\/strong>.<\/p>\n
                            Read Also<\/b>:\u00a0Basic Concepts of RAID in Linux<\/a><\/center><\/p>\n
                            My Server Setup<\/h5>\n
                            Operating System :\tCentOS 6.5 Final\r\nIP Address\t :\t192.168.0.226\r\nHostname\t :\trd1.tecmintlocal.com\r\nDisk 1 [20GB]\t :\t\/dev\/sdb\r\nDisk 2 [20GB]\t :\t\/dev\/sdc\r\n<\/pre>\n
                            This article will guide you through a step-by-step instructions on how to setup a software\u00a0RAID 1<\/strong>\u00a0or\u00a0Mirror<\/strong>\u00a0using\u00a0mdadm<\/strong>\u00a0(creates and manages raid) on Linux Platform. Although the same instructions also works on other Linux distributions such as RedHat, CentOS, Fedora, etc.<\/p>\n
                            Step 1: Installing Prerequisites and Examine Drives<\/h3>\n
                            1.<\/strong>\u00a0As I said above, we\u2019re using mdadm utility for creating and managing RAID in Linux. So, let\u2019s install the\u00a0mdadm<\/strong>\u00a0software package on Linux using yum or apt-get package manager tool.<\/p>\n
                            # yum install mdadm\t\t[on RedHat systems]\r\n# apt-get install mdadm \t[on Debain systems]\r\n<\/pre>\n
                            2.<\/strong>\u00a0Once \u2018mdadm<\/strong>\u2018 package has been installed, we need to examine our disk drives whether there is already any raid configured using the following command.<\/p>\n
                            # mdadm -E \/dev\/sd[b-c]\r\n<\/pre>\n
                            \n
                            \"Check<\/a><\/p>\n
                            Check RAID on Disks<\/p>\n<\/div>\n
                            As you see from the above screen, that there is no any\u00a0super-block<\/strong>\u00a0detected yet, means no RAID defined.<\/p>\n
                            Step 2: Drive Partitioning for RAID<\/h3>\n
                            3.<\/strong>\u00a0As I mentioned above, that we\u2019re using minimum two partitions\u00a0\/dev\/sdb<\/strong>\u00a0and\u00a0\/dev\/sdc<\/strong>\u00a0for creating RAID1. Let\u2019s create partitions on these two drives using \u2018fdisk<\/strong>\u2018 command and change the type to raid during partition creation.<\/p>\n
                            # fdisk \/dev\/sdb\r\n<\/pre>\n
                            Follow the below instructions<\/h6>\n
                              \n
                            1. Press \u2018n<\/strong>\u2018 for creating new partition.<\/li>\n
                            2. Then choose \u2018P<\/strong>\u2018 for Primary partition.<\/li>\n
                            3. Next select the partition number as\u00a01<\/strong>.<\/li>\n
                            4. Give the default full size by just pressing two times\u00a0Enter<\/strong>\u00a0key.<\/li>\n
                            5. Next press \u2018p<\/strong>\u2018 to print the defined partition.<\/li>\n
                            6. Press \u2018L<\/strong>\u2018 to list all available types.<\/li>\n
                            7. Type \u2018t<\/strong>\u2018to choose the partitions.<\/li>\n
                            8. Choose \u2018fd<\/strong>\u2018 for Linux raid auto and press Enter to apply.<\/li>\n
                            9. Then again use \u2018p<\/strong>\u2018 to print the changes what we have made.<\/li>\n
                            10. Use \u2018w<\/strong>\u2018 to write the changes.<\/li>\n<\/ol>\n
                              \n
                              \"Create<\/a><\/p>\n
                              Create Disk Partitions<\/p>\n<\/div>\n
                              After \u2018\/dev\/sdb<\/strong>\u2018 partition has been created, next follow the same instructions to create new partition on\u00a0\/dev\/sdc<\/strong>\u00a0drive.<\/p>\n
                              # fdisk \/dev\/sdc\r\n<\/pre>\n
                              \n
                              \"Create<\/a><\/p>\n
                              Create Second Partitions<\/p>\n<\/div>\n
                              4.<\/strong>\u00a0Once both the partitions are created successfully, verify the changes on both\u00a0sdb<\/strong>\u00a0&\u00a0sdc<\/strong>\u00a0drive using the same \u2018mdadm<\/strong>\u2018 command and also confirm the RAID type as shown in the following screen grabs.<\/p>\n
                              # mdadm -E \/dev\/sd[b-c]\r\n<\/pre>\n
                              \n
                              \"Verify<\/a><\/p>\n
                              Verify Partitions Changes<\/p>\n<\/div>\n
                              \n
                              \"Check<\/a><\/p>\n
                              Check RAID Type<\/p>\n<\/div>\n
                              Note<\/strong>: As you see in the above picture, there is no any defined RAID on the\u00a0sdb1<\/strong>\u00a0and\u00a0sdc1<\/strong>\u00a0drives so far, that\u2019s the reason we are getting as no\u00a0super-blocks<\/b>\u00a0detected.<\/p>\n
                              Step 3: Creating RAID1 Devices<\/h3>\n
                              5.<\/strong>\u00a0Next create RAID1 Device called \u2018\/dev\/md0<\/strong>\u2018 using the following command and verity it.<\/p>\n
                              # mdadm --create \/dev\/md0 --level=mirror --raid-devices=2 \/dev\/sd[b-c]1\r\n# cat \/proc\/mdstat\r\n<\/pre>\n
                              \n
                              \"Create<\/a><\/p>\n
                              Create RAID Device<\/p>\n<\/div>\n
                              6.<\/strong>\u00a0Next check the raid devices type and raid array using following commands.<\/p>\n
                              # mdadm -E \/dev\/sd[b-c]1\r\n# mdadm --detail \/dev\/md0\r\n<\/pre>\n
                              \n
                              \"Check<\/a><\/p>\n
                              Check RAID Device type<\/p>\n<\/div>\n
                              \n
                              \"Check<\/a><\/p>\n
                              Check RAID Device Array<\/p>\n<\/div>\n
                              From the above pictures, one can easily understand that raid1 have been created and using\u00a0\/dev\/sdb1<\/strong>\u00a0and\u00a0\/dev\/sdc1<\/strong>\u00a0partitions and also you can see the status as resyncing.<\/p>\n
                              Step 4: Creating File System on RAID Device<\/h3>\n
                              7.<\/strong>\u00a0Create file system using ext4 for\u00a0md0<\/strong>\u00a0and mount under\u00a0\/mnt\/raid1<\/strong>.<\/p>\n
                              # mkfs.ext4 \/dev\/md0\r\n<\/pre>\n
                              \n
                              \"Create<\/a><\/p>\n
                              Create RAID Device Filesystem<\/p>\n<\/div>\n
                              8.<\/strong>\u00a0Next, mount the newly created filesystem under \u2018\/mnt\/raid1<\/strong>\u2018 and create some files and verify the contents under mount point.<\/p>\n
                              # mkdir \/mnt\/raid1\r\n# mount \/dev\/md0 \/mnt\/raid1\/\r\n# touch \/mnt\/raid1\/tecmint.txt\r\n# echo \"tecmint raid setups\" > \/mnt\/raid1\/tecmint.txt\r\n<\/pre>\n
                              \n
                              \"Mount<\/a><\/p>\n
                              Mount Raid Device<\/p>\n<\/div>\n
                              9.<\/strong>\u00a0To auto-mount RAID1 on system reboot, you need to make an entry in fstab file. Open \u2018\/etc\/fstab<\/strong>\u2018 file and add the following line at the bottom of the file.<\/p>\n
                              \/dev\/md0                \/mnt\/raid1              ext4    defaults        0 0\r\n<\/pre>\n
                              \n
                              \"Raid<\/a><\/p>\n
                              Raid Automount Device<\/p>\n<\/div>\n
                              10.<\/strong>\u00a0Run \u2018mount -a<\/strong>\u2018 to check whether there are any errors in fstab entry.<\/p>\n
                              # mount -av\r\n<\/pre>\n
                              \n
                              \"Check<\/a><\/p>\n
                              Check Errors in fstab<\/p>\n<\/div>\n
                              11.<\/strong>\u00a0Next, save the raid configuration manually to \u2018mdadm.conf<\/strong>\u2018 file using the below command.<\/p>\n
                              # mdadm --detail --scan --verbose >> \/etc\/mdadm.conf\r\n<\/pre>\n
                              \n
                              \"Save<\/a><\/p>\n
                              Save Raid Configuration<\/p>\n<\/div>\n
                              The above configuration file is read by the system at the reboots and load the RAID devices.<\/p>\n
                              Step 5: Verify Data After Disk Failure<\/h3>\n
                              12.<\/strong>\u00a0Our main purpose is, even after any of hard disk fail or crash our data needs to be available. Let\u2019s see what will happen when any of disk disk is unavailable in array.<\/p>\n
                              # mdadm --detail \/dev\/md0\r\n<\/pre>\n
                              \n
                              \"Raid<\/a><\/p>\n
                              Raid Device Verify<\/p>\n<\/div>\n
                              In the above image, we can see there are 2 devices available in our RAID and Active Devices are 2. Now let us see what will happen when a disk plugged out (removed\u00a0sdc<\/strong>\u00a0disk) or fails.<\/p>\n
                              # ls -l \/dev | grep sd\r\n# mdadm --detail \/dev\/md0\r\n<\/pre>\n
                              \n
                              \"Test<\/a><\/p>\n
                              Test RAID Devices<\/p>\n<\/div>\n
                              Now in the above image, you can see that one of our drive is lost. I unplugged one of the drive from my Virtual machine. Now let us check our precious data.<\/p>\n
                              # cd \/mnt\/raid1\/\r\n# cat tecmint.txt\r\n<\/pre>\n
                              \n
                              \"Verify<\/a><\/p>\n
                              Verify RAID Data<\/p>\n<\/div>\n
                              Did you see our data is still available. From this we come to know the advantage of RAID 1 (mirror). In next article, we will see how to setup a\u00a0RAID 5<\/strong>\u00a0striping with distributed Parity. Hope this helps you to understand how the RAID 1 (Mirror) Works.<\/p>\n
                              Creating RAID 5 (Striping with Distributed Parity) in Linux \u2013 Part 4<\/h1>\n
                              In RAID 5, data strips across multiple drives with distributed parity. The striping with distributed parity means it will split the parity information and stripe data over the multiple disks, which will have good data redundancy.<\/p>\n
                              \n
                              \"Setup<\/a><\/p>\n
                              Setup Raid 5 in Linux<\/p>\n<\/div>\n
                              For RAID Level it should have at least three hard drives or more. RAID 5 are being used in the large scale production environment where it\u2019s cost effective and provide performance as well as redundancy.<\/p>\n
                              What is Parity?<\/h4>\n
                              Parity<\/strong>\u00a0is a simplest common method of detecting errors in data storage. Parity stores information in each disks, Let\u2019s say we have 4 disks, in 4 disks one disk space will be split to all disks to store the parity information\u2019s. If any one of the disks fails still we can get the data by rebuilding from parity information after replacing the failed disk.<\/p>\n
                              Pros and Cons of RAID 5<\/h4>\n
                                \n
                              1. Gives better performance<\/li>\n
                              2. Support Redundancy and Fault tolerance.<\/li>\n
                              3. Support hot spare options.<\/li>\n
                              4. Will loose a single disk capacity for using parity information.<\/li>\n
                              5. No data loss if a single disk fails. We can rebuilt from parity after replacing the failed disk.<\/li>\n
                              6. Suits for transaction oriented environment as the reading will be faster.<\/li>\n
                              7. Due to parity overhead, writing will be slow.<\/li>\n
                              8. Rebuild takes long time.<\/li>\n<\/ol>\n
                                Requirements<\/h4>\n
                                Minimum 3 hard drives are required to create Raid 5, but you can add more disks, only if you\u2019ve a dedicated hardware raid controller with multi ports. Here, we are using software RAID and \u2018mdadm<\/strong>\u2018 package to create raid.<\/p>\n
                                mdadm<\/strong>\u00a0is a package which allow us to configure and manage RAID devices in Linux. By default there is no configuration file is available for RAID, we must save the configuration file after creating and configuring RAID setup in separate file called\u00a0mdadm.conf<\/strong>.<\/p>\n
                                Before moving further, I suggest you to go through the following articles for understanding the basics of RAID in Linux.<\/p>\n
                                  \n
                                1. Basic Concepts of RAID in Linux \u2013 Part 1<\/a><\/li>\n
                                2. Creating RAID 0 (Stripe) in Linux \u2013 Part 2<\/a><\/li>\n
                                3. Setting up RAID 1 (Mirroring) in Linux \u2013 Part 3<\/a><\/li>\n<\/ol>\n
                                  My Server Setup<\/h5>\n
                                  Operating System :\tCentOS 6.5 Final\r\nIP Address\t :\t192.168.0.227\r\nHostname\t :\trd5.tecmintlocal.com\r\nDisk 1 [20GB]\t :\t\/dev\/sdb\r\nDisk 2 [20GB]\t :\t\/dev\/sdc\r\nDisk 3 [20GB]\t :\t\/dev\/sdd\r\n<\/pre>\n
                                  This article is a\u00a0Part 4<\/strong>\u00a0of a 9-tutorial RAID series, here we are going to setup a software\u00a0RAID 5<\/strong>\u00a0with distributed parity in Linux systems or servers using three 20GB disks named \/dev\/sdb, \/dev\/sdc and \/dev\/sdd.<\/p>\n
                                  Step 1: Installing mdadm and Verify Drives<\/h3>\n
                                  1.<\/strong>\u00a0As we said earlier, that we\u2019re using CentOS 6.5 Final release for this raid setup, but same steps can be followed for RAID setup in any Linux based distributions.<\/p>\n
                                  # lsb_release -a\r\n# ifconfig | grep inet\r\n<\/pre>\n
                                  \n
                                  \"Setup<\/a><\/p>\n
                                  CentOS 6.5 Summary<\/p>\n<\/div>\n
                                  2.<\/strong>\u00a0If you\u2019re following our raid series, we assume that you\u2019ve already installed \u2018mdadm<\/strong>\u2018 package, if not, use the following command according to your Linux distribution to install the package.<\/p>\n
                                  # yum install mdadm\t\t[on RedHat systems]\r\n# apt-get install mdadm \t[on Debain systems]\r\n<\/pre>\n
                                  3.<\/strong>\u00a0After the \u2018mdadm<\/strong>\u2018 package installation, let\u2019s list the three 20GB disks which we have added in our system using \u2018fdisk<\/strong>\u2018 command.<\/p>\n
                                  # fdisk -l | grep sd\r\n<\/pre>\n
                                  \n
                                  \"Install<\/a><\/p>\n
                                  Install mdadm Tool<\/p>\n<\/div>\n
                                  4.<\/strong>\u00a0Now it\u2019s time to examine the attached three drives for any existing RAID blocks on these drives using following command.<\/p>\n
                                  # mdadm -E \/dev\/sd[b-d]\r\n# mdadm --examine \/dev\/sdb \/dev\/sdc \/dev\/sdd\r\n<\/pre>\n
                                  \n
                                  \"Examine<\/a><\/p>\n
                                  Examine Drives For Raid<\/p>\n<\/div>\n
                                  Note<\/strong>: From the above image illustrated that there is no any super-block detected yet. So, there is no RAID defined in all three drives. Let us start to create one now.<\/p>\n
                                  Step 2: Partitioning the Disks for RAID<\/h3>\n
                                  5.<\/strong>\u00a0First and foremost, we have to partition the disks (\/dev\/sdb<\/strong>,\u00a0\/dev\/sd<\/strong>c and\u00a0\/dev\/sdd<\/strong>) before adding to a RAID, So let us define the partition using \u2018fdisk\u2019 command, before forwarding to the next steps.<\/p>\n
                                  # fdisk \/dev\/sdb\r\n# fdisk \/dev\/sdc\r\n# fdisk \/dev\/sdd\r\n<\/pre>\n
                                  Create \/dev\/sdb Partition<\/h5>\n
                                  Please follow the below instructions to create partition on\u00a0\/dev\/sdb<\/strong>\u00a0drive.<\/p>\n
                                    \n
                                  1. Press \u2018n<\/strong>\u2018 for creating new partition.<\/li>\n
                                  2. Then choose \u2018P<\/strong>\u2018 for Primary partition. Here we are choosing Primary because there is no partitions defined yet.<\/li>\n
                                  3. Then choose \u20181<\/strong>\u2018 to be the first partition. By default it will be\u00a01<\/strong>.<\/li>\n
                                  4. Here for cylinder size we don\u2019t have to choose the specified size because we need the whole partition for RAID so just Press Enter two times to choose the default full size.<\/li>\n
                                  5. Next press \u2018p<\/strong>\u2018 to print the created partition.<\/li>\n
                                  6. Change the Type, If we need to know the every available types Press \u2018L<\/strong>\u2018.<\/li>\n
                                  7. Here, we are selecting \u2018fd<\/strong>\u2018 as my type is RAID.<\/li>\n
                                  8. Next press \u2018p<\/strong>\u2018 to print the defined partition.<\/li>\n
                                  9. Then again use \u2018p<\/strong>\u2018 to print the changes what we have made.<\/li>\n
                                  10. Use \u2018w<\/strong>\u2018 to write the changes.<\/li>\n<\/ol>\n
                                    \n
                                    \"Create<\/a><\/p>\n
                                    Create sdb Partition<\/p>\n<\/div>\n
                                    Note<\/strong>: We have to follow the steps mentioned above to create partitions for\u00a0sdc<\/strong>\u00a0&\u00a0sdd<\/strong>\u00a0drives too.<\/p>\n
                                    Create \/dev\/sdc Partition<\/h5>\n
                                    Now partition the\u00a0sdc<\/strong>\u00a0and\u00a0sdd<\/strong>\u00a0drives by following the steps given in the screenshot or you can follow above steps.<\/p>\n
                                    # fdisk \/dev\/sdc\r\n<\/pre>\n
                                    \n
                                    \"Create<\/a><\/p>\n
                                    Create sdc Partition<\/p>\n<\/div>\n
                                    Create \/dev\/sdd Partition<\/h5>\n
                                    # fdisk \/dev\/sdd\r\n<\/pre>\n
                                    \n
                                    \"Create<\/a><\/p>\n
                                    Create sdd Partition<\/p>\n<\/div>\n
                                    6.<\/strong>\u00a0After creating partitions, check for changes in all three drives sdb, sdc, & sdd.<\/p>\n
                                    # mdadm --examine \/dev\/sdb \/dev\/sdc \/dev\/sdd\r\n\r\nor\r\n\r\n# mdadm -E \/dev\/sd[b-c]\r\n<\/pre>\n
                                    \n
                                    \"Check<\/a><\/p>\n
                                    Check Partition Changes<\/p>\n<\/div>\n
                                    Note<\/strong>: In the above pic. depict the type is fd i.e. for RAID.<\/p>\n
                                    7.<\/strong>\u00a0Now Check for the RAID blocks in newly created partitions. If no super-blocks detected, than we can move forward to create a new RAID 5 setup on these drives.<\/p>\n
                                    \n
                                    \"Check<\/a><\/p>\n
                                    Check Raid on Partition<\/p>\n<\/div>\n
                                    Step 3: Creating md device md0<\/h3>\n
                                    8.<\/strong>\u00a0Now create a Raid device \u2018md0<\/strong>\u2018 (i.e.\u00a0\/dev\/md0<\/strong>) and include raid level on all newly created partitions (sdb1, sdc1 and sdd1) using below command.<\/p>\n
                                    # mdadm --create \/dev\/md0 --level=5 --raid-devices=3 \/dev\/sdb1 \/dev\/sdc1 \/dev\/sdd1\r\n\r\nor\r\n\r\n# mdadm -C \/dev\/md0 -l=5 -n=3 \/dev\/sd[b-d]1\r\n<\/pre>\n
                                    9.<\/strong>\u00a0After creating raid device, check and verify the RAID, devices included and RAID Level from the\u00a0mdstat<\/strong>\u00a0output.<\/p>\n
                                    # cat \/proc\/mdstat\r\n<\/pre>\n
                                    \n
                                    \"Verify<\/a><\/p>\n
                                    Verify Raid Device<\/p>\n<\/div>\n
                                    If you want to monitor the current building process, you can use \u2018watch<\/strong>\u2018 command, just pass through the \u2018cat \/proc\/mdstat<\/strong>\u2018 with watch command which will refresh screen every\u00a01<\/strong>\u00a0second.<\/p>\n
                                    # watch -n1 cat \/proc\/mdstat\r\n<\/pre>\n
                                    \n
                                    \"Monitor<\/a><\/p>\n
                                    Monitor Raid 5 Process<\/p>\n<\/div>\n
                                    \n
                                    \"Raid<\/a><\/p>\n
                                    Raid 5 Process Summary<\/p>\n<\/div>\n
                                    10.<\/strong>\u00a0After creation of raid, Verify the raid devices using the following command.<\/p>\n
                                    # mdadm -E \/dev\/sd[b-d]1\r\n<\/pre>\n
                                    \n
                                    \"Verify<\/a><\/p>\n
                                    Verify Raid Level<\/p>\n<\/div>\n
                                    Note<\/strong>: The Output of the above command will be little long as it prints the information of all three drives.<\/p>\n
                                    11.<\/strong>\u00a0Next, verify the RAID array to assume that the devices which we\u2019ve included in the RAID level are running and started to re-sync.<\/p>\n
                                    # mdadm --detail \/dev\/md0\r\n<\/pre>\n
                                    \n
                                    \"Verify<\/a><\/p>\n
                                    Verify Raid Array<\/p>\n<\/div>\n
                                    Step 4: Creating file system for md0<\/h3>\n
                                    12.<\/strong>\u00a0Create a file system for \u2018md0<\/strong>\u2018 device using\u00a0ext4<\/strong>\u00a0before mounting.<\/p>\n
                                    # mkfs.ext4 \/dev\/md0\r\n<\/pre>\n
                                    \n
                                    \"Create<\/a><\/p>\n
                                    Create md0 Filesystem<\/p>\n<\/div>\n
                                    13.<\/strong>\u00a0Now create a directory under \u2018\/mnt<\/strong>\u2018 then mount the created filesystem under\u00a0\/mnt\/raid5<\/strong>\u00a0and check the files under mount point, you will see\u00a0lost+found<\/strong>\u00a0directory.<\/p>\n
                                    # mkdir \/mnt\/raid5\r\n# mount \/dev\/md0 \/mnt\/raid5\/\r\n# ls -l \/mnt\/raid5\/\r\n<\/pre>\n
                                    14.<\/strong>\u00a0Create few files under mount point\u00a0\/mnt\/raid5<\/strong>\u00a0and append some text in any one of the file to verify the content.<\/p>\n
                                    # touch \/mnt\/raid5\/raid5_tecmint_{1..5}\r\n# ls -l \/mnt\/raid5\/\r\n# echo \"tecmint raid setups\" > \/mnt\/raid5\/raid5_tecmint_1\r\n# cat \/mnt\/raid5\/raid5_tecmint_1\r\n# cat \/proc\/mdstat\r\n<\/pre>\n
                                    \n
                                    \"Mount<\/a><\/p>\n
                                    Mount Raid Device<\/p>\n<\/div>\n
                                    15.<\/strong>\u00a0We need to add entry in\u00a0fstab<\/strong>, else will not display our mount point after system reboot. To add an entry, we should edit the fstab file and append the following line as shown below. The mount point will differ according to your environment.<\/p>\n
                                    # vim \/etc\/fstab\r\n\r\n\/dev\/md0                \/mnt\/raid5              ext4    defaults        0 0\r\n<\/pre>\n
                                    \n
                                    \"Raid<\/a><\/p>\n
                                    Raid 5 Automount<\/p>\n<\/div>\n
                                    16.<\/strong>\u00a0Next, run \u2018mount -av<\/strong>\u2018 command to check whether any errors in fstab entry.<\/p>\n
                                    # mount -av\r\n<\/pre>\n
                                    \n
                                    \"Check<\/a><\/p>\n
                                    Check Fstab Errors<\/p>\n<\/div>\n
                                    Step 5: Save Raid 5 Configuration<\/h3>\n
                                    17.<\/strong>\u00a0As mentioned earlier in requirement section, by default RAID don\u2019t have a config file. We have to save it manually. If this step is not followed RAID device will not be in md0, it will be in some other random number.<\/p>\n
                                    So, we must have to save the configuration before system reboot. If the configuration is saved it will be loaded to the kernel during the system reboot and RAID will also gets loaded.<\/p>\n
                                    # mdadm --detail --scan --verbose >> \/etc\/mdadm.conf\r\n<\/pre>\n
                                    \n
                                    \"Save<\/a><\/p>\n
                                    Save Raid 5 Configuration<\/p>\n<\/div>\n
                                    Note<\/strong>: Saving the configuration will keep the RAID level stable in md0 device.<\/p>\n
                                    Step 6: Adding Spare Drives<\/h3>\n
                                    18.<\/strong>\u00a0What the use of adding a spare drive? its very useful if we have a spare drive, if any one of the disk fails in our array, this spare drive will get active and rebuild the process and sync the data from other disk, so we can see a redundancy here.<\/p>\n
                                    For more instructions on how to add spare drive and check Raid 5 fault tolerance, read\u00a0#Step 6<\/strong>\u00a0and\u00a0#Step 7<\/strong>\u00a0in the following article.<\/p>\n
                                      \n
                                    1. Add Spare Drive to Raid 5 Setup<\/a><\/li>\n<\/ol>\n
                                      Conclusion<\/h3>\n
                                      Here, in this article, we have seen how to setup a RAID 5 using three number of disks. Later in my upcoming articles, we will see how to troubleshoot when a disk fails in RAID 5 and how to replace for recovery.<\/p>\n
                                      Setup RAID Level 6 (Striping with Double Distributed Parity) in Linux \u2013 Part 5<\/h1>\n
                                      RAID 6<\/b>\u00a0is upgraded version of\u00a0RAID 5<\/strong>, where it has two distributed parity which provides fault tolerance even after two drives fails. Mission critical system still operational incase of two concurrent disks failures. It\u2019s alike\u00a0RAID 5<\/b>, but provides more robust, because it uses one more disk for parity.<\/p>\n
                                      In our earlier article, we\u2019ve seen distributed parity in\u00a0RAID 5<\/strong>, but in this article we will going to see\u00a0RAID 6<\/b>\u00a0with double distributed parity. Don\u2019t expect extra performance than any other RAID, if so we have to install a dedicated RAID Controller too. Here in\u00a0RAID 6<\/b>\u00a0even if we loose our 2 disks we can get the data back by replacing a spare drive and build it from parity.<\/p>\n
                                      \n
                                      \"Setup<\/a><\/p>\n
                                      Setup RAID 6 in Linux<\/p>\n<\/div>\n
                                      To setup a\u00a0RAID 6<\/b>, minimum\u00a04<\/strong>\u00a0numbers of disks or more in a set are required.\u00a0RAID 6<\/b>\u00a0have multiple disks even in some set it may be have some bunch of disks, while reading, it will read from all the drives, so reading would be faster whereas writing would be poor because it has to stripe over multiple disks.<\/p>\n
                                      Now, many of us comes to conclusion, why we need to use\u00a0RAID 6<\/b>, when it doesn\u2019t perform like any other RAID. Hmm\u2026 those who raise this question need to know that, if they need high fault tolerance choose RAID 6. In every higher environments with high availability for database, they use\u00a0RAID 6<\/b>\u00a0because database is the most important and need to be safe in any cost, also it can be useful for video streaming environments.<\/p>\n
                                      Pros and Cons of RAID 6<\/h4>\n
                                        \n
                                      1. Performance are good.<\/li>\n
                                      2. RAID 6 is expensive, as it requires two independent drives are used for parity functions.<\/li>\n
                                      3. Will loose a two disks capacity for using parity information (double parity).<\/li>\n
                                      4. No data loss, even after two disk fails. We can rebuilt from parity after replacing the failed disk.<\/li>\n
                                      5. Reading will be better than RAID 5, because it reads from multiple disk, But writing performance will be very poor without dedicated RAID Controller.<\/li>\n<\/ol>\n
                                        Requirements<\/h4>\n
                                        Minimum 4 numbers of disks are required to create a\u00a0RAID 6<\/strong>. If you want to add more disks, you can, but you must have dedicated raid controller. In software RAID, we will won\u2019t get better performance in RAID 6. So we need a physical RAID controller.<\/p>\n
                                        Those who are new to RAID setup, we recommend to go through RAID articles below.<\/p>\n
                                          \n
                                        1. Basic Concepts of RAID in Linux \u2013 Part 1<\/a><\/li>\n
                                        2. Creating Software RAID 0 (Stripe) in Linux \u2013 Part 2<\/a><\/li>\n
                                        3. Setting up RAID 1 (Mirroring) in Linux \u2013 Part 3<\/a><\/li>\n<\/ol>\n
                                          My Server Setup<\/h5>\n
                                          Operating System :\tCentOS 6.5 Final\r\nIP Address\t :\t192.168.0.228\r\nHostname\t :\trd6.tecmintlocal.com\r\nDisk 1 [20GB]\t :\t\/dev\/sdb\r\nDisk 2 [20GB]\t :\t\/dev\/sdc\r\nDisk 3 [20GB]\t :\t\/dev\/sdd\r\nDisk 4 [20GB]\t : \t\/dev\/sde\r\n<\/pre>\n
                                          This article is a\u00a0Part 5<\/strong>\u00a0of a 9-tutorial RAID series, here we are going to see how we can create and setup Software\u00a0RAID 6<\/strong>\u00a0or Striping with Double Distributed Parity in Linux systems or servers using four 20GB disks named \/dev\/sdb, \/dev\/sdc, \/dev\/sdd and \/dev\/sde.<\/p>\n
                                          Step 1: Installing mdadm Tool and Examine Drives<\/h3>\n
                                          1.<\/strong>\u00a0If you\u2019re following our last two Raid articles (Part 2<\/strong>\u00a0and Part 3<\/strong>), where we\u2019ve already shown how to install \u2018mdadm<\/strong>\u2018 tool. If you\u2019re new to this article, let me explain that \u2018mdadm<\/strong>\u2018 is a tool to create and manage Raid in Linux systems, let\u2019s install the tool using following command according to your Linux distribution.<\/p>\n
                                          # yum install mdadm\t\t[on RedHat systems]\r\n# apt-get install mdadm \t[on Debain systems]\r\n<\/pre>\n
                                          2.<\/strong>\u00a0After installing the tool, now it\u2019s time to verify the attached four drives that we are going to use for raid creation using the following \u2018fdisk<\/strong>\u2018 command.<\/p>\n
                                          # fdisk -l | grep sd\r\n<\/pre>\n
                                          \n
                                          \"Check<\/a><\/p>\n
                                          Check Disks in Linux<\/p>\n<\/div>\n
                                          3.<\/strong>\u00a0Before creating a RAID drives, always examine our disk drives whether there is any RAID is already created on the disks.<\/p>\n
                                          # mdadm -E \/dev\/sd[b-e]\r\n# mdadm --examine \/dev\/sdb \/dev\/sdc \/dev\/sdd \/dev\/sde\r\n<\/pre>\n
                                          \n
                                          \"Check<\/a><\/p>\n
                                          Check Raid on Disk<\/p>\n<\/div>\n
                                          Note:<\/strong>\u00a0In the above image depicts that there is no any super-block detected or no RAID is defined in four disk drives. We may move further to start creating RAID 6.<\/p>\n
                                          Step 2: Drive Partitioning for RAID 6<\/h3>\n
                                          4.<\/strong>\u00a0Now create partitions for raid on \u2018\/dev\/sdb<\/strong>\u2018, \u2018\/dev\/sdc<\/strong>\u2018, \u2018\/dev\/sdd<\/strong>\u2018 and \u2018\/dev\/sde<\/strong>\u2018 with the help of following\u00a0fdisk<\/strong>\u00a0command. Here, we will show how to create partition on\u00a0sdb<\/strong>\u00a0drive and later same steps to be followed for rest of the drives.<\/p>\n
                                          Create \/dev\/sdb Partition<\/h6>\n
                                          # fdisk \/dev\/sdb\r\n<\/pre>\n
                                          Please follow the instructions as shown below for creating partition.<\/p>\n
                                            \n
                                          1. Press \u2018n<\/strong>\u2018 for creating new partition.<\/li>\n
                                          2. Then choose \u2018P<\/strong>\u2018 for Primary partition.<\/li>\n
                                          3. Next choose the partition number as\u00a01<\/strong>.<\/li>\n
                                          4. Define the default value by just pressing two times\u00a0Enter<\/strong>\u00a0key.<\/li>\n
                                          5. Next press \u2018P<\/strong>\u2018 to print the defined partition.<\/li>\n
                                          6. Press \u2018L<\/strong>\u2018 to list all available types.<\/li>\n
                                          7. Type \u2018t<\/strong>\u2018 to choose the partitions.<\/li>\n
                                          8. Choose \u2018fd<\/strong>\u2018 for Linux raid auto and press Enter to apply.<\/li>\n
                                          9. Then again use \u2018P<\/strong>\u2018 to print the changes what we have made.<\/li>\n
                                          10. Use \u2018w<\/strong>\u2018 to write the changes.<\/li>\n<\/ol>\n
                                            \n
                                            \"Create<\/a><\/p>\n
                                            Create \/dev\/sdb Partition<\/p>\n<\/div>\n
                                            Create \/dev\/sdb Partition<\/h6>\n
                                            # fdisk \/dev\/sdc\r\n<\/pre>\n
                                            \n
                                            \"Create<\/a><\/p>\n
                                            Create \/dev\/sdc Partition<\/p>\n<\/div>\n
                                            Create \/dev\/sdd Partition<\/h6>\n
                                            # fdisk \/dev\/sdd\r\n<\/pre>\n
                                            \n
                                            \"Create<\/a><\/p>\n
                                            Create \/dev\/sdd Partition<\/p>\n<\/div>\n
                                            Create \/dev\/sde Partition<\/h6>\n
                                            # fdisk \/dev\/sde\r\n<\/pre>\n
                                            \n
                                            \"Create<\/a><\/p>\n
                                            Create \/dev\/sde Partition<\/p>\n<\/div>\n
                                            5.<\/strong>\u00a0After creating partitions, it\u2019s always good habit to examine the drives for super-blocks. If super-blocks does not exist than we can go head to create a new RAID setup.<\/p>\n
                                            # mdadm -E \/dev\/sd[b-e]1\r\n\r\n\r\nor\r\n\r\n# mdadm --examine \/dev\/sdb1 \/dev\/sdc1 \/dev\/sdd1 \/dev\/sde1\r\n<\/pre>\n
                                            \n
                                            \"Check<\/a><\/p>\n
                                            Check Raid on New Partitions<\/p>\n<\/div>\n
                                            Step 3: Creating md device (RAID)<\/h3>\n
                                            6.<\/strong>\u00a0Now it\u2019s time to create Raid device \u2018md0<\/strong>\u2018 (i.e.\u00a0\/dev\/md0<\/strong>) and apply raid level on all newly created partitions and confirm the raid using following commands.<\/p>\n
                                            # mdadm --create \/dev\/md0 --level=6 --raid-devices=4 \/dev\/sdb1 \/dev\/sdc1 \/dev\/sdd1 \/dev\/sde1\r\n# cat \/proc\/mdstat\r\n<\/pre>\n
                                            \n
                                            \"Create<\/a><\/p>\n
                                            Create Raid 6 Device<\/p>\n<\/div>\n
                                            7.<\/strong>\u00a0You can also check the current process of raid using\u00a0watch<\/strong>\u00a0command as shown in the screen grab below.<\/p>\n
                                            # watch -n1 cat \/proc\/mdstat\r\n<\/pre>\n
                                            \n
                                            \"Check<\/a><\/p>\n
                                            Check Raid 6 Process<\/p>\n<\/div>\n
                                            8.<\/strong>\u00a0Verify the raid devices using the following command.<\/p>\n
                                            # mdadm -E \/dev\/sd[b-e]1\r\n<\/pre>\n
                                            Note:<\/strong>: The above command will be display the information of the four disks, which is quite long so not possible to post the output or screen grab here.<\/p>\n
                                            9.<\/strong>\u00a0Next, verify the RAID array to confirm that the re-syncing is started.<\/p>\n
                                            # mdadm --detail \/dev\/md0\r\n<\/pre>\n
                                            \n
                                            \"Check<\/a><\/p>\n
                                            Check Raid 6 Array<\/p>\n<\/div>\n
                                            Step 4: Creating FileSystem on Raid Device<\/h3>\n
                                            10.<\/strong>\u00a0Create a filesystem using ext4 for \u2018\/dev\/md0<\/strong>\u2018 and mount it under\u00a0\/mnt\/raid6<\/b>. Here we\u2019ve used ext4, but you can use any type of filesystem as per your choice.<\/p>\n
                                            # mkfs.ext4 \/dev\/md0\r\n<\/pre>\n
                                            \n
                                            \"Create<\/a><\/p>\n
                                            Create File System on Raid 6<\/p>\n<\/div>\n
                                            11.<\/strong>\u00a0Mount the created filesystem under\u00a0\/mnt\/raid6<\/b>\u00a0and verify the files under mount point, we can see lost+found directory.<\/p>\n
                                            # mkdir \/mnt\/raid6\r\n# mount \/dev\/md0 \/mnt\/raid6\/\r\n# ls -l \/mnt\/raid6\/\r\n<\/pre>\n
                                            12.<\/strong>\u00a0Create some files under mount point and append some text in any one of the file to verify the content.<\/p>\n
                                            # touch \/mnt\/raid6\/raid6_test.txt\r\n# ls -l \/mnt\/raid6\/\r\n# echo \"tecmint raid setups\" > \/mnt\/raid6\/raid6_test.txt\r\n# cat \/mnt\/raid6\/raid6_test.txt\r\n<\/pre>\n
                                            \n
                                            \"Verify<\/a><\/p>\n
                                            Verify Raid Content<\/p>\n<\/div>\n
                                            13.<\/strong>\u00a0Add an entry in\u00a0\/etc\/fstab<\/b>\u00a0to auto mount the device at the system startup and append the below entry, mount point may differ according to your environment.<\/p>\n
                                            # vim \/etc\/fstab\r\n\r\n\/dev\/md0                \/mnt\/raid6              ext4    defaults        0 0\r\n<\/pre>\n
                                            \n
                                            \"Automount<\/a><\/p>\n
                                            Automount Raid 6 Device<\/p>\n<\/div>\n
                                            14.<\/strong>\u00a0Next, execute \u2018mount -a<\/strong>\u2018 command to verify whether there is any error in fstab entry.<\/p>\n
                                            # mount -av\r\n<\/pre>\n
                                            \n
                                            \"Verify<\/a><\/p>\n
                                            Verify Raid Automount<\/p>\n<\/div>\n
                                            Step 5: Save RAID 6 Configuration<\/h3>\n
                                            15.<\/strong>\u00a0Please note by default RAID don\u2019t have a config file. We have to save it by manually using below command and then verify the status of device \u2018\/dev\/md0<\/strong>\u2018.<\/p>\n
                                            # mdadm --detail --scan --verbose >> \/etc\/mdadm.conf\r\n# mdadm --detail \/dev\/md0\r\n<\/pre>\n
                                            \n
                                            \"Save<\/a><\/p>\n
                                            Save Raid 6 Configuration<\/p>\n<\/div>\n
                                            \n
                                            \"Check<\/a><\/p>\n
                                            Check Raid 6 Status<\/p>\n<\/div>\n
                                            Step 6: Adding a Spare Drives<\/h3>\n
                                            16.<\/strong>\u00a0Now it has\u00a04<\/strong>\u00a0disks and there are two parity information\u2019s available. In some cases, if any one of the disk fails we can get the data, because there is double parity in RAID 6.<\/p>\n
                                            May be if the second disk fails, we can add a new one before loosing third disk. It is possible to add a spare drive while creating our RAID set, But I have not defined the spare drive while creating our raid set. But, we can add a spare drive after any drive failure or while creating the RAID set. Now we have already created the RAID set now let me add a spare drive for demonstration.<\/p>\n
                                            For the demonstration purpose, I\u2019ve hot-plugged a new HDD disk (i.e.\u00a0\/dev\/sdf<\/strong>), let\u2019s verify the attached disk.<\/p>\n
                                            # ls -l \/dev\/ | grep sd\r\n<\/pre>\n
                                            \n
                                            \"Check<\/a><\/p>\n
                                            Check New Disk<\/p>\n<\/div>\n
                                            17.<\/strong>\u00a0Now again confirm the new attached disk for any raid is already configured or not using the same\u00a0mdadm<\/strong>command.<\/p>\n
                                            # mdadm --examine \/dev\/sdf\r\n<\/pre>\n
                                            \n
                                            \"Check<\/a><\/p>\n
                                            Check Raid on New Disk<\/p>\n<\/div>\n
                                            Note:<\/strong>\u00a0As usual, like we\u2019ve created partitions for four disks earlier, similarly we\u2019ve to create new partition on the new plugged disk using\u00a0fdisk<\/strong>\u00a0command.<\/p>\n
                                            # fdisk \/dev\/sdf\r\n<\/pre>\n
                                            \n
                                            \"Create<\/a><\/p>\n
                                            Create \/dev\/sdf Partition<\/p>\n<\/div>\n
                                            18.<\/strong>\u00a0Again after creating new partition on\u00a0\/dev\/sdf<\/strong>, confirm the raid on the partition, include the spare drive to the\u00a0\/dev\/md0<\/strong>\u00a0raid device and verify the added device.<\/p>\n
                                            # mdadm --examine \/dev\/sdf\r\n# mdadm --examine \/dev\/sdf1\r\n# mdadm --add \/dev\/md0 \/dev\/sdf1\r\n# mdadm --detail \/dev\/md0\r\n<\/pre>\n
                                            \n
                                            \"Verify<\/a><\/p>\n
                                            Verify Raid on sdf Partition<\/p>\n<\/div>\n
                                            \n
                                            \"Add<\/a><\/p>\n
                                            Add sdf Partition to Raid<\/p>\n<\/div>\n
                                            \n
                                            \"Verify<\/a><\/p>\n
                                            Verify sdf Partition Details<\/p>\n<\/div>\n
                                            Step 7: Check Raid 6 Fault Tolerance<\/h3>\n
                                            19.<\/strong>\u00a0Now, let us check whether spare drive works automatically, if anyone of the disk fails in our Array. For testing, I\u2019ve personally marked one of the drive is failed.<\/p>\n
                                            Here, we\u2019re going to mark\u00a0\/dev\/sdd1<\/b>\u00a0as failed drive.<\/p>\n
                                            # mdadm --manage --fail \/dev\/md0 \/dev\/sdd1\r\n<\/pre>\n
                                            \n
                                            \"Check<\/a><\/p>\n
                                            Check Raid 6 Fault Tolerance<\/p>\n<\/div>\n
                                            20.<\/strong>\u00a0Let me get the details of RAID set now and check whether our spare started to sync.<\/p>\n
                                            # mdadm --detail \/dev\/md0\r\n<\/pre>\n
                                            \n
                                            \"Check<\/a><\/p>\n
                                            Check Auto Raid Syncing<\/p>\n<\/div>\n
                                            Hurray!<\/strong>\u00a0Here, we can see the spare got activated and started rebuilding process. At the bottom we can see the faulty drive\u00a0\/dev\/sdd1<\/b>\u00a0listed as faulty. We can monitor build process using following command.<\/p>\n
                                            # cat \/proc\/mdstat\r\n<\/pre>\n
                                            \n
                                            \"Raid<\/a><\/p>\n
                                            Raid 6 Auto Syncing<\/p>\n<\/div>\n
                                            Conclusion:<\/h3>\n
                                            Here, we have seen how to setup\u00a0RAID 6<\/strong>\u00a0using four disks. This RAID level is one of the expensive setup with high redundancy. We will see how to setup a\u00a0Nested RAID 10<\/strong>\u00a0and much more in the next articles.<\/p>\n
                                            Setting Up RAID 10 or 1+0 (Nested) in Linux \u2013 Part 6<\/h1>\n
                                            RAID 10<\/strong>\u00a0is a combine of\u00a0RAID 0<\/strong>\u00a0and\u00a0RAID 1<\/strong>\u00a0to form a\u00a0RAID 10<\/strong>. To setup Raid 10, we need at least 4 number of disks. In our earlier articles, we\u2019ve seen how to setup a RAID 0 and RAID 1 with minimum 2 number of disks.<\/p>\n
                                            Here we will use both RAID 0 and RAID 1 to perform a Raid 10 setup with minimum of 4 drives. Assume, that we\u2019ve some data saved to logical volume, which is created with RAID 10. Just for an example, if we are saving a data \u201capple<\/strong>\u201d this will be saved under all 4 disk by this following method.<\/p>\n
                                            \n
                                            \"Create<\/a><\/p>\n
                                            Create Raid 10 in Linux<\/p>\n<\/div>\n
                                            Using\u00a0RAID 0<\/strong>\u00a0it will save as \u201cA<\/b>\u201d in first disk and \u201cp<\/b>\u201d in the second disk, then again \u201cp<\/b>\u201d in first disk and \u201cl<\/b>\u201d in second disk. Then \u201ce<\/b>\u201d in first disk, like this it will continue the Round robin process to save the data. From this we come to know that RAID 0 will write the half of the data to first disk and other half of the data to second disk.<\/p>\n
                                            In\u00a0RAID 1<\/strong>\u00a0method, same data will be written to other 2 disks as follows. \u201cA<\/b>\u201d will write to both first and second disks, \u201cP<\/b>\u201d will write to both disk, Again other \u201cP<\/b>\u201d will write to both the disks. Thus using RAID 1 it will write to both the disks. This will continue in round robin process.<\/p>\n
                                            Now you all came to know that how RAID 10 works by combining of both RAID 0 and RAID 1. If we have 4 number of 20 GB size disks, it will be 80 GB in total, but we will get only 40 GB of Storage capacity, the half of total capacity will be lost for building RAID 10.<\/p>\n
                                            Pros and Cons of RAID 5<\/h4>\n
                                              \n
                                            1. Gives better performance.<\/li>\n
                                            2. We will loose two of the disk capacity in RAID 10.<\/li>\n
                                            3. Reading and writing will be very good, because it will write and read to all those 4 disk at the same time.<\/li>\n
                                            4. It can be used for Database solutions, which needs a high I\/O disk writes.<\/li>\n<\/ol>\n
                                              Requirements<\/h4>\n
                                              In RAID 10, we need minimum of 4 disks, the first 2 disks for RAID 0 and other 2 Disks for RAID 1. Like I said before, RAID 10 is just a Combine of RAID 0 & 1. If we need to extended the RAID group, we must increase the disk by minimum 4 disks.<\/p>\n
                                              My Server Setup<\/h5>\n
                                              Operating System :\tCentOS 6.5 Final\r\nIP Address\t \t:\t192.168.0.229\r\nHostname\t \t:\trd10.tecmintlocal.com\r\nDisk 1 [20GB]\t \t:\t\/dev\/sdd\r\nDisk 2 [20GB]\t \t:\t\/dev\/sdc\r\nDisk 3 [20GB]\t \t:\t\/dev\/sdd\r\nDisk 4 [20GB]\t \t:\t\/dev\/sde\r\n<\/pre>\n
                                              There are two ways to setup RAID 10, but here I\u2019m going to show you both methods, but I prefer you to follow the first method, which makes the work lot easier for setting up a RAID 10.<\/p>\n
                                              Method 1: Setting Up Raid 10<\/h3>\n
                                              1.<\/strong>\u00a0First, verify that all the 4 added disks are detected or not using the following command.<\/p>\n
                                              # ls -l \/dev | grep sd\r\n<\/pre>\n
                                              2.<\/strong>\u00a0Once the four disks are detected, it\u2019s time to check for the drives whether there is already any raid existed before creating a new one.<\/p>\n
                                              # mdadm -E \/dev\/sd[b-e]\r\n# mdadm --examine \/dev\/sdb \/dev\/sdc \/dev\/sdd \/dev\/sde\r\n<\/pre>\n
                                              \n
                                              \"Verify<\/a><\/p>\n
                                              Verify 4 Added Disks<\/p>\n<\/div>\n
                                              Note<\/strong>: In the above output, you see there isn\u2019t any super-block detected yet, that means there is no RAID defined in all 4 drives.<\/p>\n
                                              Step 1: Drive Partitioning for RAID<\/h4>\n
                                              3.<\/strong>\u00a0Now create a new partition on all 4 disks (\/dev\/sdb, \/dev\/sdc, \/dev\/sdd and \/dev\/sde) using the \u2018fdisk\u2019 tool.<\/p>\n
                                              # fdisk \/dev\/sdb\r\n# fdisk \/dev\/sdc\r\n# fdisk \/dev\/sdd\r\n# fdisk \/dev\/sde\r\n<\/pre>\n
                                              Create \/dev\/sdb Partition<\/h5>\n
                                              Let me show you how to partition one of the disk (\/dev\/sdb) using fdisk, this steps will be the same for all the other disks too.<\/p>\n
                                              # fdisk \/dev\/sdb\r\n<\/pre>\n
                                              Please use the below steps for creating a new partition on\u00a0\/dev\/sdb<\/strong>\u00a0drive.<\/p>\n
                                                \n
                                              1. Press \u2018n<\/strong>\u2018 for creating new partition.<\/li>\n
                                              2. Then choose \u2018P<\/strong>\u2018 for Primary partition.<\/li>\n
                                              3. Then choose \u20181<\/strong>\u2018 to be the first partition.<\/li>\n
                                              4. Next press \u2018p<\/strong>\u2018 to print the created partition.<\/li>\n
                                              5. Change the Type, If we need to know the every available types Press \u2018L<\/strong>\u2018.<\/li>\n
                                              6. Here, we are selecting \u2018fd<\/strong>\u2018 as my type is RAID.<\/li>\n
                                              7. Next press \u2018p<\/strong>\u2018 to print the defined partition.<\/li>\n
                                              8. Then again use \u2018p<\/strong>\u2018 to print the changes what we have made.<\/li>\n
                                              9. Use \u2018w<\/strong>\u2018 to write the changes.<\/li>\n<\/ol>\n
                                                \n
                                                \"Disk<\/a><\/p>\n
                                                Disk sdb Partition<\/p>\n<\/div>\n
                                                Note<\/strong>: Please use the above same instructions for creating partitions on other disks (sdc, sdd sdd sde).<\/p>\n
                                                4.<\/strong>\u00a0After creating all 4 partitions, again you need to examine the drives for any already existing raid using the following command.<\/p>\n
                                                # mdadm -E \/dev\/sd[b-e]\r\n# mdadm -E \/dev\/sd[b-e]1\r\n\r\nOR\r\n\r\n# mdadm --examine \/dev\/sdb \/dev\/sdc \/dev\/sdd \/dev\/sde\r\n# mdadm --examine \/dev\/sdb1 \/dev\/sdc1 \/dev\/sdd1 \/dev\/sde1\r\n<\/pre>\n
                                                \n
                                                \"Check<\/a><\/p>\n
                                                Check All Disks for Raid<\/p>\n<\/div>\n
                                                Note<\/strong>: The above outputs shows that there isn\u2019t any super-block detected on all four newly created partitions, that means we can move forward to create RAID 10 on these drives.<\/p>\n
                                                Step 2: Creating \u2018md\u2019 RAID Device<\/h4>\n
                                                5.<\/strong>\u00a0Now it\u2019s time to create a \u2018md\u2019 (i.e. \/dev\/md0) device, using \u2018mdadm\u2019 raid management tool. Before, creating device, your system must have \u2018mdadm\u2019 tool installed, if not install it first.<\/p>\n
                                                # yum install mdadm\t\t[on RedHat systems]\r\n# apt-get install mdadm \t[on Debain systems]\r\n<\/pre>\n
                                                Once \u2018mdadm\u2019 tool installed, you can now create a \u2018md\u2019 raid device using the following command.<\/p>\n
                                                # mdadm --create \/dev\/md0 --level=10 --raid-devices=4 \/dev\/sd[b-e]1\r\n<\/pre>\n
                                                6.<\/strong>\u00a0Next verify the newly created raid device using the \u2018cat\u2019 command.<\/p>\n
                                                # cat \/proc\/mdstat\r\n<\/pre>\n
                                                \n
                                                \"Create<\/a><\/p>\n
                                                Create md raid Device<\/p>\n<\/div>\n
                                                7.<\/strong>\u00a0Next, examine all the 4 drives using the below command. The output of the below command will be long as it displays the information of all 4 disks.<\/p>\n
                                                # mdadm --examine \/dev\/sd[b-e]1\r\n<\/pre>\n
                                                8. Next, check the details of Raid Array with the help of following command.<\/p>\n
                                                # mdadm --detail \/dev\/md0\r\n<\/pre>\n
                                                \n
                                                \"Check<\/a><\/p>\n
                                                Check Raid Array Details<\/p>\n<\/div>\n
                                                Note<\/strong>: You see in the above results, that the status of Raid was active and re-syncing.<\/p>\n
                                                Step 3: Creating Filesystem<\/h4>\n
                                                9.<\/strong>\u00a0Create a file system using ext4 for \u2018md0\u2019 and mount it under \u2018\/mnt\/raid10<\/strong>\u2018. Here, I\u2019ve used ext4, but you can use any filesystem type if you want.<\/p>\n
                                                # mkfs.ext4 \/dev\/md0\r\n<\/pre>\n
                                                \n
                                                \"Create<\/a><\/p>\n
                                                Create md Filesystem<\/p>\n<\/div>\n
                                                10.<\/strong>\u00a0After creating filesystem, mount the created file-system under \u2018\/mnt\/raid10<\/strong>\u2018 and list the contents of the mount point using \u2018ls -l\u2019 command.<\/p>\n
                                                # mkdir \/mnt\/raid10\r\n# mount \/dev\/md0 \/mnt\/raid10\/\r\n# ls -l \/mnt\/raid10\/\r\n<\/pre>\n
                                                Next, add some files under mount point and append some text in any one of the file and check the content.<\/p>\n
                                                # touch \/mnt\/raid10\/raid10_files.txt\r\n# ls -l \/mnt\/raid10\/\r\n# echo \"raid 10 setup with 4 disks\" > \/mnt\/raid10\/raid10_files.txt\r\n# cat \/mnt\/raid10\/raid10_files.txt\r\n<\/pre>\n
                                                \n
                                                \"Mount<\/a><\/p>\n
                                                Mount md Device<\/p>\n<\/div>\n
                                                11.<\/strong>\u00a0For automounting, open the \u2018\/etc\/fstab<\/strong>\u2018 file and append the below entry in fstab, may be mount point will differ according to your environment. Save and quit using wq!.<\/p>\n
                                                # vim \/etc\/fstab\r\n\r\n\/dev\/md0                \/mnt\/raid10              ext4    defaults        0 0\r\n<\/pre>\n
                                                \n
                                                \"AutoMount<\/a><\/p>\n
                                                AutoMount md Device<\/p>\n<\/div>\n
                                                12.<\/strong>\u00a0Next, verify the \u2018\/etc\/fstab<\/strong>\u2018 file for any errors before restarting the system using \u2018mount -a<\/strong>\u2018 command.<\/p>\n
                                                # mount -av\r\n<\/pre>\n
                                                \n
                                                \"Check<\/a><\/p>\n
                                                Check Errors in Fstab<\/p>\n<\/div>\n
                                                Step 4: Save RAID Configuration<\/h4>\n
                                                13.<\/strong>\u00a0By default RAID don\u2019t have a config file, so we need to save it manually after making all the above steps, to preserve these settings during system boot.<\/p>\n
                                                # mdadm --detail --scan --verbose >> \/etc\/mdadm.conf\r\n<\/pre>\n
                                                \n
                                                \"Save<\/a><\/p>\n
                                                Save Raid10 Configuration<\/p>\n<\/div>\n
                                                That\u2019s it, we have created RAID 10 using method 1, this method is the easier one. Now let\u2019s move forward to setup RAID 10 using method 2.<\/p>\n
                                                Method 2: Creating RAID 10<\/h3>\n
                                                1.<\/strong>\u00a0In method 2, we have to define 2 sets of RAID 1 and then we need to define a RAID 0 using those created RAID 1 sets. Here, what we will do is to first create 2 mirrors (RAID1) and then striping over RAID0.<\/p>\n
                                                First, list the disks which are all available for creating RAID 10.<\/p>\n
                                                # ls -l \/dev | grep sd\r\n<\/pre>\n
                                                \n
                                                \"List<\/a><\/p>\n
                                                List 4 Devices<\/p>\n<\/div>\n
                                                2.<\/strong>\u00a0Partition the all 4 disks using \u2018fdisk\u2019 command. For partitioning, you can follow\u00a0#step 3<\/b>\u00a0above.<\/p>\n
                                                # fdisk \/dev\/sdb\r\n# fdisk \/dev\/sdc\r\n# fdisk \/dev\/sdd\r\n# fdisk \/dev\/sde\r\n<\/pre>\n
                                                3.<\/strong>\u00a0After partitioning all 4 disks, now examine the disks for any existing raid blocks.<\/p>\n
                                                # mdadm --examine \/dev\/sd[b-e]\r\n# mdadm --examine \/dev\/sd[b-e]1\r\n<\/pre>\n
                                                \n
                                                \"Examine<\/a><\/p>\n
                                                Examine 4 Disks<\/p>\n<\/div>\n
                                                Step 1: Creating RAID 1<\/h4>\n
                                                4.<\/strong>\u00a0First let me create 2 sets of RAID 1 using 4 disks \u2018sdb1\u2019 and \u2018sdc1\u2019 and other set using \u2018sdd1\u2019 & \u2018sde1\u2019.<\/p>\n
                                                # mdadm --create \/dev\/md1 --metadata=1.2 --level=1 --raid-devices=2 \/dev\/sd[b-c]1\r\n# mdadm --create \/dev\/md2 --metadata=1.2 --level=1 --raid-devices=2 \/dev\/sd[d-e]1\r\n# cat \/proc\/mdstat\r\n<\/pre>\n
                                                \n
                                                \"Creating<\/a><\/p>\n
                                                Creating Raid 1<\/p>\n<\/div>\n
                                                \n
                                                \"Check<\/a><\/p>\n
                                                Check Details of Raid 1<\/p>\n<\/div>\n
                                                Step 2: Creating RAID 0<\/h4>\n
                                                5.<\/strong>\u00a0Next, create the RAID 0 using md1 and md2 devices.<\/p>\n
                                                # mdadm --create \/dev\/md0 --level=0 --raid-devices=2 \/dev\/md1 \/dev\/md2\r\n# cat \/proc\/mdstat\r\n<\/pre>\n
                                                \n
                                                \"Creating<\/a><\/p>\n
                                                Creating Raid 0<\/p>\n<\/div>\n
                                                Step 3: Save RAID Configuration<\/h4>\n
                                                6.<\/strong>\u00a0We need to save the Configuration under \u2018\/etc\/mdadm.conf<\/strong>\u2018 to load all raid devices in every reboot times.<\/p>\n
                                                # mdadm --detail --scan --verbose >> \/etc\/mdadm.conf\r\n<\/pre>\n
                                                After this, we need to follow #step 3 Creating file system of method 1.<\/p>\n
                                                That\u2019s it! we have created RAID 1+0 using method 2. We will loose two disks space here, but the performance will be excellent compared to any other raid setups.<\/p>\n
                                                Conclusion<\/h3>\n
                                                Here we have created RAID 10 using two methods. RAID 10 has good performance and redundancy too. Hope this helps you to understand about RAID 10 Nested Raid level. Let us see how to grow an existing raid array and much more in my upcoming articles.<\/p>\n
                                                Growing an Existing RAID Array and Removing Failed Disks in Raid \u2013 Part 7<\/h1>\n
                                                Every newbies will get confuse of the word array. Array is just a collection of disks. In other words, we can call array as a set or group. Just like a set of eggs containing 6 numbers. Likewise RAID Array contains number of disks, it may be 2, 4, 6, 8, 12, 16 etc. Hope now you know what Array is.<\/p>\n
                                                Here we will see how to grow (extend) an existing array or raid group. For example, if we are using 2 disks in an array to form a raid 1 set, and in some situation if we need more space in that group, we can extend the size of an array using\u00a0mdadm \u2013grow<\/b>\u00a0command, just by adding one of the disk to the existing array. After growing (adding disk to an existing array), we will see how to remove one of the failed disk from array.<\/p>\n
                                                \n
                                                \"Grow<\/a><\/p>\n
                                                Growing Raid Array and Removing Failed Disks<\/p>\n<\/div>\n
                                                Assume that one of the disk is little weak and need to remove that disk, till it fails let it under use, but we need to add one of the spare drive and grow the mirror before it fails, because we need to save our data. While the weak disk fails we can remove it from array this is the concept we are going to see in this topic.<\/p>\n
                                                Features of RAID Growth<\/h4>\n
                                                  \n
                                                1. We can grow (extend) the size of any raid set.<\/li>\n
                                                2. We can remove the faulty disk after growing raid array with new disk.<\/li>\n
                                                3. We can grow raid array without any downtime.<\/li>\n<\/ol>\n
                                                  Requirements<\/h4>\n
                                                    \n
                                                  1. To grow an RAID array, we need an existing RAID set (Array).<\/li>\n
                                                  2. We need extra disks to grow the Array.<\/li>\n
                                                  3. Here I\u2019m using 1 disk to grow the existing array.<\/li>\n<\/ol>\n
                                                    Before we learn about growing and recovering of Array, we have to know about the basics of RAID levels and setups. Follow the below links to know about those setups.<\/p>\n
                                                      \n
                                                    1. Understanding Basic RAID Concepts \u2013 Part 1<\/a><\/li>\n
                                                    2. Creating a Software Raid 0 in Linux \u2013 Part 2<\/a><\/li>\n<\/ol>\n
                                                      My Server Setup<\/h5>\n
                                                      Operating System \t:\tCentOS 6.5 Final\r\nIP Address\t \t:\t192.168.0.230\r\nHostname\t\t:\tgrow.tecmintlocal.com\r\n2 Existing Disks \t:\t1 GB\r\n1 Additional Disk\t:\t1 GB\r\n<\/pre>\n
                                                      Here, my already existing RAID has 2 number of disks with each size is 1GB and we are now adding one more disk whose size is 1GB to our existing raid array.<\/center><\/p>\n
                                                      Growing an Existing RAID Array<\/h3>\n
                                                      1.<\/strong>\u00a0Before growing an array, first list the existing Raid array using the following command.<\/p>\n
                                                      # mdadm --detail \/dev\/md0\r\n<\/pre>\n
                                                      \n
                                                      \"Check<\/a><\/p>\n
                                                      Check Existing Raid Array<\/p>\n<\/div>\n
                                                      Note<\/strong>: The above output shows that I\u2019ve already has two disks in Raid array with raid1 level. Now here we are adding one more disk to an existing array,<\/p>\n
                                                      2.<\/strong>\u00a0Now let\u2019s add the new disk \u201csdd<\/strong>\u201d and create a partition using \u2018fdisk<\/strong>\u2018 command.<\/p>\n
                                                      # fdisk \/dev\/sdd\r\n<\/pre>\n
                                                      Please use the below instructions to create a partition on\u00a0\/dev\/sdd<\/strong>\u00a0drive.<\/p>\n
                                                        \n
                                                      1. Press \u2018n<\/strong>\u2018 for creating new partition.<\/li>\n
                                                      2. Then choose \u2018P<\/strong>\u2018 for Primary partition.<\/li>\n
                                                      3. Then choose \u20181<\/strong>\u2018 to be the first partition.<\/li>\n
                                                      4. Next press \u2018p<\/strong>\u2018 to print the created partition.<\/li>\n
                                                      5. Here, we are selecting \u2018fd<\/strong>\u2018 as my type is RAID.<\/li>\n
                                                      6. Next press \u2018p<\/strong>\u2018 to print the defined partition.<\/li>\n
                                                      7. Then again use \u2018p<\/strong>\u2018 to print the changes what we have made.<\/li>\n
                                                      8. Use \u2018w<\/strong>\u2018 to write the changes.<\/li>\n<\/ol>\n
                                                        \n
                                                        \"Create<\/a><\/p>\n
                                                        Create New sdd Partition<\/p>\n<\/div>\n
                                                        3.<\/strong>\u00a0Once new\u00a0sdd<\/strong>\u00a0partition created, you can verify it using below command.<\/p>\n
                                                        # ls -l \/dev\/ | grep sd\r\n<\/pre>\n
                                                        \n
                                                        \"Confirm<\/a><\/p>\n
                                                        Confirm sdd Partition<\/p>\n<\/div>\n
                                                        4.<\/strong>\u00a0Next, examine the newly created disk for any existing raid, before adding to the array.<\/p>\n
                                                        # mdadm --examine \/dev\/sdd1\r\n<\/pre>\n
                                                        \n
                                                        \"Check<\/a><\/p>\n
                                                        Check Raid on sdd Partition<\/p>\n<\/div>\n
                                                        Note<\/strong>: The above output shows that the disk has no super-blocks detected, means we can move forward to add a new disk to an existing array.<\/p>\n
                                                        4.<\/strong>\u00a0To add the new partition\u00a0\/dev\/sdd1<\/strong>\u00a0in existing array\u00a0md0<\/strong>, use the following command.<\/p>\n
                                                        # mdadm --manage \/dev\/md0 --add \/dev\/sdd1\r\n<\/pre>\n
                                                        \n
                                                        \"Add<\/a><\/p>\n
                                                        Add Disk To Raid-Array<\/p>\n<\/div>\n
                                                        5.<\/strong>\u00a0Once the new disk has been added, check for the added disk in our array using.<\/p>\n
                                                        # mdadm --detail \/dev\/md0\r\n<\/pre>\n
                                                        \n
                                                        \"Confirm<\/a><\/p>\n
                                                        Confirm Disk Added to Raid<\/p>\n<\/div>\n
                                                        Note<\/strong>: In the above output, you can see the drive has been added as a spare. Here, we already having 2 disks in the array, but what we are expecting is 3 devices in array for that we need to grow the array.<\/p>\n
                                                        6.<\/strong>\u00a0To grow the array we have to use the below command.<\/p>\n
                                                        # mdadm --grow --raid-devices=3 \/dev\/md0\r\n<\/pre>\n
                                                        \n
                                                        \"Grow<\/a><\/p>\n
                                                        Grow Raid Array<\/p>\n<\/div>\n
                                                        Now we can see the third disk (sdd1<\/strong>) has been added to array, after adding third disk it will sync the data from other two disks.<\/p>\n
                                                        # mdadm --detail \/dev\/md0\r\n<\/pre>\n
                                                        \n
                                                        \"Confirm<\/a><\/p>\n
                                                        Confirm Raid Array<\/p>\n<\/div>\n
                                                        Note<\/strong>: For large size disk it will take hours to sync the contents. Here I have used 1GB virtual disk, so its done very quickly within seconds.<\/p>\n
                                                        Removing Disks from Array<\/h3>\n
                                                        7.<\/strong>\u00a0After the data has been synced to new disk \u2018sdd1<\/strong>\u2018 from other two disks, that means all three disks now have same contents.<\/p>\n
                                                        As I told earlier let\u2019s assume that one of the disk is weak and needs to be removed, before it fails. So, now assume disk \u2018sdc1<\/strong>\u2018 is weak and needs to be removed from an existing array.<\/p>\n
                                                        Before removing a disk we have to mark the disk as failed one, then only we can able to remove it.<\/p>\n
                                                        # mdadm --fail \/dev\/md0 \/dev\/sdc1\r\n# mdadm --detail \/dev\/md0\r\n<\/pre>\n
                                                        \n
                                                        \"Disk<\/a><\/p>\n
                                                        Disk Fail in Raid Array<\/p>\n<\/div>\n
                                                        From the above output, we clearly see that the disk was marked as faulty at the bottom. Even its faulty, we can see the raid devices are\u00a03<\/strong>, failed\u00a01<\/strong>\u00a0and state was degraded.<\/p>\n
                                                        Now we have to remove the faulty drive from the array and grow the array with\u00a02<\/strong>\u00a0devices, so that the raid devices will be set to\u00a02<\/strong>\u00a0devices as before.<\/p>\n
                                                        # mdadm --remove \/dev\/md0 \/dev\/sdc1\r\n<\/pre>\n
                                                        \n
                                                        \"Remove<\/a><\/p>\n
                                                        Remove Disk in Raid Array<\/p>\n<\/div>\n
                                                        8.<\/strong>\u00a0Once the faulty drive is removed, now we\u2019ve to grow the raid array using\u00a02<\/strong>\u00a0disks.<\/p>\n
                                                        # mdadm --grow --raid-devices=2 \/dev\/md0\r\n# mdadm --detail \/dev\/md0\r\n<\/pre>\n
                                                        \n
                                                        \"Grow<\/a><\/p>\n
                                                        Grow Disks in Raid Array<\/p>\n<\/div>\n
                                                        From the about output, you can see that our array having only 2 devices. If you need to grow the array again, follow the same steps as described above. If you need to add a drive as spare, mark it as spare so that if the disk fails, it will automatically active and rebuild.<\/p>\n
                                                        Conclusion<\/h3>\n
                                                        In the article, we\u2019ve seen how to grow an existing raid set and how to remove a faulty disk from an array after re-syncing the existing contents. All these steps can be done without any downtime. During data syncing, system users, files and applications will not get affected in any case.<\/p>\n
                                                        In next, article I will show you how to manage the RAID, till then stay tuned to updates and don\u2019t forget to add your comments.<\/p>\n
                                                        How to Recover Data and Rebuild Failed Software RAID\u2019s \u2013 Part 8<\/h1>\n
                                                        In the previous articles of this\u00a0RAID series<\/a>\u00a0you went from zero to RAID hero. We reviewed several software RAID configurations and explained the essentials of each one, along with the reasons why you would lean towards one or the other depending on your specific scenario.<\/p>\n
                                                        \n
                                                        \"Recover<\/a><\/p>\n
                                                        Recover Rebuild Failed Software RAID\u2019s \u2013 Part 8<\/p>\n<\/div>\n
                                                        In this guide we will discuss how to rebuild a software RAID array without data loss when in the event of a disk failure. For brevity, we will only consider a\u00a0RAID 1<\/strong>\u00a0setup \u2013 but the concepts and commands apply to all cases alike.<\/p>\n
                                                        RAID Testing Scenario<\/h4>\n
                                                        Before proceeding further, please make sure you have set up a\u00a0RAID 1<\/strong>\u00a0array following the instructions provided in Part 3 of this series:\u00a0How to set up RAID 1 (Mirror) in Linux<\/a>.<\/p>\n
                                                        The only variations in our present case will be:<\/p>\n
                                                        1)<\/strong>\u00a0a different version of CentOS (v7) than the one used in that article (v6.5), and
                                                        \n2)<\/strong>\u00a0different disk sizes for\u00a0\/dev\/sdb<\/strong>\u00a0and\u00a0\/dev\/sdc<\/strong>\u00a0(8 GB each).<\/p>\n
                                                        In addition, if\u00a0SELinux<\/strong>\u00a0is enabled in enforcing mode, you will need to add the corresponding labels to the directory where you\u2019ll mount the RAID device. Otherwise, you\u2019ll run into this warning message while attempting to mount it:<\/p>\n
                                                        \n
                                                        \"SELinux<\/a><\/p>\n
                                                        SELinux RAID Mount Error<\/p>\n<\/div>\n
                                                        You can fix this by running:<\/p>\n
                                                        # restorecon -R \/mnt\/raid1\r\n<\/pre>\n
                                                        Setting up RAID Monitoring<\/h3>\n
                                                        There is a variety of reasons why a storage device can fail (SSDs have greatly reduced the chances of this happening, though), but regardless of the cause you can be sure that issues can occur anytime and you need to be prepared to replace the failed part and to ensure the availability and integrity of your data.<\/p>\n
                                                        A word of advice first. Even when you can inspect\u00a0\/proc\/mdstat<\/strong>\u00a0in order to check the status of your RAIDs, there\u2019s a better and time-saving method that consists of running\u00a0mdadm<\/strong>\u00a0in monitor + scan mode, which will send alerts via email to a predefined recipient.<\/p>\n
                                                        To set this up, add the following line in\u00a0\/etc\/mdadm.conf<\/strong>:<\/p>\n
                                                        MAILADDR user@<domain or localhost>\r\n<\/pre>\n
                                                        In my case:<\/p>\n
                                                        MAILADDR gacanepa@localhost\r\n<\/pre>\n
                                                        \n
                                                        \"RAID<\/a><\/p>\n
                                                        RAID Monitoring Email Alerts<\/p>\n<\/div>\n
                                                        To run\u00a0mdadm<\/strong>\u00a0in monitor + scan mode, add the following crontab entry as root:<\/p>\n
                                                        @reboot \/sbin\/mdadm --monitor --scan --oneshot\r\n<\/pre>\n
                                                        By default,\u00a0mdadm<\/strong>\u00a0will check the RAID arrays every 60 seconds and send an alert if it finds an issue. You can modify this behavior by adding the\u00a0--delay<\/code>\u00a0option to the crontab entry above along with the amount of seconds (for example,\u00a0--delay<\/code>\u00a01800 means 30 minutes).<\/p>\n
                                                        Finally, make sure you have a\u00a0Mail User Agent<\/strong>\u00a0(MUA) installed, such as\u00a0mutt or mailx<\/a>. Otherwise, you will not receive any alerts.<\/p>\n
                                                        In a minute we will see what an alert sent by\u00a0mdadm<\/strong>\u00a0looks like.<\/p>\n
                                                        Simulating and Replacing a failed RAID Storage Device<\/h3>\n
                                                        To simulate an issue with one of the storage devices in the RAID array, we will use the\u00a0--manage<\/code>\u00a0and\u00a0--set-faulty<\/code>\u00a0options as follows:<\/p>\n
                                                        # mdadm --manage --set-faulty \/dev\/md0 \/dev\/sdc1  \r\n<\/pre>\n
                                                        This will result in\u00a0\/dev\/sdc1<\/strong>\u00a0being marked as faulty, as we can see in\u00a0\/proc\/mdstat<\/strong>:<\/p>\n
                                                        \n
                                                        \"Stimulate<\/a><\/p>\n
                                                        Stimulate Issue with RAID Storage<\/p>\n<\/div>\n
                                                        More importantly, let\u2019s see if we received an email alert with the same warning:<\/p>\n
                                                        \n
                                                        \"Email<\/a><\/p>\n
                                                        Email Alert on Failed RAID Device<\/p>\n<\/div>\n
                                                        In this case, you will need to remove the device from the software RAID array:<\/p>\n
                                                        # mdadm \/dev\/md0 --remove \/dev\/sdc1\r\n<\/pre>\n
                                                        Then you can physically remove it from the machine and replace it with a spare part (\/dev\/sdd<\/strong>, where a partition of type\u00a0fd<\/strong>\u00a0has been previously created):<\/p>\n
                                                        # mdadm --manage \/dev\/md0 --add \/dev\/sdd1\r\n<\/pre>\n
                                                        Luckily for us, the system will automatically start rebuilding the array with the part that we just added. We can test this by marking\u00a0\/dev\/sdb1<\/strong>\u00a0as faulty, removing it from the array, and making sure that the file\u00a0tecmint.txt<\/strong>\u00a0is still accessible at\u00a0\/mnt\/raid1<\/strong>:<\/p>\n
                                                        # mdadm --detail \/dev\/md0\r\n# mount | grep raid1\r\n# ls -l \/mnt\/raid1 | grep tecmint\r\n# cat \/mnt\/raid1\/tecmint.txt\r\n<\/pre>\n
                                                        \n
                                                        \"Confirm<\/a><\/p>\n
                                                        Confirm Rebuilding RAID Array<\/p>\n<\/div>\n
                                                        The image above clearly shows that after adding\u00a0\/dev\/sdd1<\/strong>\u00a0to the array as a replacement for\u00a0\/dev\/sdc1<\/strong>, the rebuilding of data was automatically performed by the system without intervention on our part.<\/p>\n
                                                        Though not strictly required, it\u2019s a great idea to have a spare device in handy so that the process of replacing the faulty device with a good drive can be done in a snap. To do that, let\u2019s re-add\u00a0\/dev\/sdb1<\/strong>\u00a0and\u00a0\/dev\/sdc1<\/strong>:<\/p>\n
                                                        # mdadm --manage \/dev\/md0 --add \/dev\/sdb1\r\n# mdadm --manage \/dev\/md0 --add \/dev\/sdc1\r\n<\/pre>\n
                                                        \n
                                                        \"Replace<\/a><\/p>\n
                                                        Replace Failed Raid Device<\/p>\n<\/div>\n
                                                        Recovering from a Redundancy Loss<\/h3>\n
                                                        As explained earlier,\u00a0mdadm<\/strong>\u00a0will automatically rebuild the data when one disk fails. But what happens if 2 disks in the array fail? Let\u2019s simulate such scenario by marking\u00a0\/dev\/sdb1<\/strong>\u00a0and\u00a0\/dev\/sdd1<\/strong>\u00a0as faulty:<\/p>\n
                                                        # umount \/mnt\/raid1\r\n# mdadm --manage --set-faulty \/dev\/md0 \/dev\/sdb1\r\n# mdadm --stop \/dev\/md0\r\n# mdadm --manage --set-faulty \/dev\/md0 \/dev\/sdd1\r\n<\/pre>\n
                                                        Attempts to re-create the array the same way it was created at this time (or using the\u00a0--assume-clean<\/code>\u00a0option) may result in data loss, so it should be left as a last resort.<\/p>\n
                                                        Let\u2019s try to recover the data from\u00a0\/dev\/sdb1<\/strong>, for example, into a similar disk partition (\/dev\/sde1<\/strong>\u00a0\u2013 note that this requires that you create a partition of type\u00a0fd<\/strong>\u00a0in\u00a0\/dev\/sde<\/strong>\u00a0before proceeding) using\u00a0ddrescue<\/strong>:<\/p>\n
                                                        # ddrescue -r 2 \/dev\/sdb1 \/dev\/sde1\r\n<\/pre>\n
                                                        \n
                                                        \"Recovering<\/a><\/p>\n
                                                        Recovering Raid Array<\/p>\n<\/div>\n
                                                        Please note that up to this point, we haven\u2019t touched\u00a0\/dev\/sdb<\/strong>\u00a0or\u00a0\/dev\/sdd<\/strong>, the partitions that were part of the RAID array.<\/p>\n
                                                        Now let\u2019s rebuild the array using\u00a0\/dev\/sde1<\/strong>\u00a0and\u00a0\/dev\/sdf1<\/strong>:<\/p>\n
                                                        # mdadm --create \/dev\/md0 --level=mirror --raid-devices=2 \/dev\/sd[e-f]1\r\n<\/pre>\n
                                                        Please note that in a real situation, you will typically use the same device names as with the original array, that is,\u00a0\/dev\/sdb1<\/strong>\u00a0and\u00a0\/dev\/sdc1<\/strong>\u00a0after the failed disks have been replaced with new ones.<\/p>\n
                                                        In this article I have chosen to use extra devices to re-create the array with brand new disks and to avoid confusion with the original failed drives.<\/p>\n
                                                        When asked whether to continue writing array, type\u00a0Y<\/strong>\u00a0and press\u00a0Enter<\/strong>. The array should be started and you should be able to watch its progress with:<\/p>\n
                                                        # watch -n 1 cat \/proc\/mdstat\r\n<\/pre>\n
                                                        When the process completes, you should be able to access the content of your RAID:<\/p>\n
                                                        \n
                                                        \"Confirm<\/a><\/p>\n
                                                        Confirm Raid Content<\/p>\n<\/div>\n
                                                        Summary<\/h3>\n
                                                        In this article we have reviewed how to recover from\u00a0RAID<\/strong>\u00a0failures and redundancy losses. However, you need to remember that this technology is a storage solution and\u00a0DOES NOT<\/strong>\u00a0replace backups.<\/p>\n
                                                        The principles explained in this guide apply to all RAID setups alike, as well as the concepts that we will cover in the next and final guide of this series (RAID management).<\/p>\n
                                                        How to Manage Software RAID\u2019s in Linux with \u2018Mdadm\u2019 Tool \u2013 Part 9<\/h1>\n
                                                        Regardless of your previous experience with RAID arrays, and whether you followed all of the tutorials in\u00a0this RAID series<\/a>\u00a0or not, managing software RAIDs in Linux is not a very complicated task once you have become acquainted with\u00a0mdadm --manage<\/code>\u00a0command.<\/p>\n
                                                        \n
                                                        \"Manage<\/a><\/p>\n
                                                        Manage Raid Devices with Mdadm in Linux \u2013 Part 9<\/p>\n<\/div>\n
                                                        In this tutorial we will review the functionality provided by this tool so that you can have it handy when you need it.<\/p>\n
                                                        RAID Testing Scenario<\/h4>\n
                                                        As in the last article of this series, we will use for simplicity a\u00a0RAID 1<\/strong>\u00a0(mirror) array which consists of two\u00a08 GB<\/strong>disks (\/dev\/sdb<\/strong>\u00a0and\u00a0\/dev\/sdc<\/strong>) and an initial spare device (\/dev\/sdd<\/strong>) to illustrate, but the commands and concepts listed herein apply to other types of setups as well. That said, feel free to go ahead and add this page to your browser\u2019s bookmarks, and let\u2019s get started.<\/p>\n
                                                        Understanding mdadm Options and Usage<\/h3>\n
                                                        Fortunately,\u00a0mdadm<\/strong>\u00a0provides a\u00a0built-in --help<\/code>\u00a0flag that provides explanations and documentation for each of the main options.<\/p>\n
                                                        Thus, let\u2019s start by typing:<\/p>\n
                                                        # mdadm --manage --help\r\n<\/pre>\n
                                                        to see what are the tasks that\u00a0mdadm --manage<\/code>\u00a0will allow us to perform and how:<\/p>\n
                                                        \n
                                                        \"Manage<\/a><\/p>\n
                                                        Manage RAID with mdadm Tool<\/p>\n<\/div>\n
                                                        As we can see in the above image, managing a RAID array involves performing the following tasks at one time or another:<\/p>\n
                                                          \n
                                                        1. (Re)Adding a device to the array.<\/li>\n
                                                        2. Mark a device as faulty.<\/li>\n
                                                        3. Removing a faulty device from the array.<\/li>\n
                                                        4. Replacing the faulty device with a spare one.<\/li>\n
                                                        5. Start an array that\u2019s partially built.<\/li>\n
                                                        6. Stop an array.<\/li>\n
                                                        7. Mark an array as ro (read-only) or rw (read-write).<\/li>\n<\/ol>\n
                                                          Managing RAID Devices with mdadm Tool<\/h3>\n
                                                          Note that if you omit the\u00a0--manage<\/code>\u00a0option, mdadm assumes management mode anyway. Keep this fact in mind to avoid running into trouble further down the road.<\/p>\n
                                                          The highlighted text in the previous image shows the basic syntax to manage RAIDs:<\/p>\n
                                                          # mdadm --manage RAID options devices\r\n<\/pre>\n
                                                          Let\u2019s illustrate with a few examples.<\/p>\n
                                                          \u200b Example 1: Add a device to the RAID array<\/h6>\n
                                                          You will typically add a new device when replacing a faulty one, or when you have a spare part that you want to have handy in case of a failure:<\/p>\n
                                                          # mdadm --manage \/dev\/md0 --add \/dev\/sdd1\r\n<\/pre>\n
                                                          \n
                                                          \"Add<\/a><\/p>\n
                                                          Add Device to Raid Array<\/p>\n<\/div>\n
                                                          \u200bExample 2: Marking a RAID device as faulty and removing it from the array<\/h6>\n
                                                          This is a mandatory step before logically removing the device from the array, and later physically pulling it out from the machine \u2013 in that order (if you miss one of these steps you may end up causing actual damage to the device):<\/p>\n
                                                          # mdadm --manage \/dev\/md0 --fail \/dev\/sdb1\r\n<\/pre>\n
                                                          Note how the spare device added in the previous example is used to automatically replace the failed disk. Not only that, but the\u00a0recovery and rebuilding of raid data<\/a>\u00a0start immediately as well:<\/p>\n
                                                          \n
                                                          \"Recover<\/a><\/p>\n
                                                          Recover and Rebuild Raid Data<\/p>\n<\/div>\n
                                                          Once the device has been indicated as failed manually, it can be safely removed from the array:<\/p>\n
                                                          # mdadm --manage \/dev\/md0 --remove \/dev\/sdb1\r\n<\/pre>\n
                                                          \u200bExample 3: Re-adding a device that was part of the array which had been removed previously<\/h6>\n
                                                          Up to this point, we have a working\u00a0RAID 1<\/strong>\u00a0array that consists of 2 active devices:\u00a0\/dev\/sdc1<\/strong>\u00a0and\u00a0\/dev\/sdd1<\/strong>. If we attempt to re-add\u00a0\/dev\/sdb1<\/strong>\u00a0to\u00a0\/dev\/md0<\/strong>\u00a0right now:<\/p>\n
                                                          # mdadm --manage \/dev\/md0 --re-add \/dev\/sdb1\r\n<\/pre>\n
                                                          we will run into an error:<\/p>\n
                                                          mdadm: --re-add for \/dev\/sdb1 to \/dev\/md0 is not possible<\/strong>\r\n<\/pre>\n
                                                          because the array is already made up of the maximum possible number of drives. So we have 2 choices: a) add\u00a0\/dev\/sdb1<\/strong>\u00a0as a spare, as shown in Example #1, or b) remove\u00a0\/dev\/sdd1<\/strong>\u00a0from the array and then re-add\u00a0\/dev\/sdb1<\/strong>.<\/p>\n
                                                          We choose option\u00a0b)<\/strong>, and will start by stopping the array to later reassemble it:<\/p>\n
                                                          # mdadm --stop \/dev\/md0\r\n# mdadm --assemble \/dev\/md0 \/dev\/sdb1 \/dev\/sdc1\r\n<\/pre>\n
                                                          If the above command does not successfully add\u00a0\/dev\/sdb1<\/strong>\u00a0back to the array, use the command from\u00a0Example #1<\/strong>\u00a0to do it.<\/p>\n
                                                          Although\u00a0mdadm<\/strong>\u00a0will initially detect the newly added device as a spare, it will start rebuilding the data and when it\u2019s done doing so, it should recognize the device to be an active part of the RAID:<\/p>\n
                                                          \n
                                                          \"Raid<\/a><\/p>\n
                                                          Raid Rebuild Status<\/p>\n<\/div>\n
                                                          Example 4: Replace a Raid device with a specific disk<\/h6>\n
                                                          Replacing a disk in the array with a spare one is as easy as:<\/p>\n
                                                          # mdadm --manage \/dev\/md0 --replace \/dev\/sdb1 --with \/dev\/sdd1\r\n<\/pre>\n
                                                          \n
                                                          \"Replace<\/a><\/p>\n
                                                          Replace Raid Device<\/p>\n<\/div>\n
                                                          This results in the device following the\u00a0--with<\/code>\u00a0switch being added to the RAID while the disk indicated through\u00a0--replace<\/code>\u00a0being marked as faulty:<\/p>\n
                                                          \n
                                                          \"Check<\/a><\/p>\n
                                                          Check Raid Rebuild Status<\/p>\n<\/div>\n
                                                          \u200bExample 5: Marking an Raid array as ro or rw<\/h6>\n
                                                          After creating the array, you must have created a filesystem on top of it and mounted it on a directory in order to use it. What you probably didn\u2019t know then is that you can mark the RAID as\u00a0ro<\/strong>, thus allowing only read operations to be performed on it,\u00a0or rw<\/strong>, in order to write to the device as well.<\/p>\n
                                                          To mark the device as\u00a0ro<\/strong>, it needs to be unmounted first:<\/p>\n
                                                          # umount \/mnt\/raid1\r\n# mdadm --manage \/dev\/md0 --readonly\r\n# mount \/mnt\/raid1\r\n# touch \/mnt\/raid1\/test1\r\n<\/pre>\n
                                                          \n
                                                          \"Set<\/a><\/p>\n
                                                          Set Permissions on Raid Array<\/p>\n<\/div>\n
                                                          To configure the array to allow write operations as well, use the\u00a0--readwrite<\/code>\u00a0option. Note that you will need to unmount the device and stop it before setting the\u00a0rw<\/strong>\u00a0flag:<\/p>\n
                                                          # umount \/mnt\/raid1\r\n# mdadm --manage \/dev\/md0 --stop\r\n# mdadm --assemble \/dev\/md0 \/dev\/sdc1 \/dev\/sdd1\r\n# mdadm --manage \/dev\/md0 --readwrite\r\n# touch \/mnt\/raid1\/test2\r\n<\/pre>\n
                                                          \n
                                                          \"Allow<\/a><\/p>\n
                                                          Allow Read Write Permission on Raid<\/p>\n<\/div>\n
                                                          Summary<\/h3>\n
                                                          Throughout this series we have explained how to set up a variety of software RAID arrays that are used in enterprise environments. If you followed through the articles and the examples provided in these articles you are prepared to leverage the power of software RAIDs in Linux.<\/p>\n
                                                          Source<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
                                                          RAID\u00a0is a Redundant Array of Inexpensive disks, but nowadays it is called Redundant Array of Independent drives. Earlier it is used to be very costly to buy even a smaller size of disk, but nowadays we can buy a large size of disk with the same amount like before. Raid is just a collection of … <\/p>\n
                                                          Continue reading “Introduction to RAID, Concepts of RAID and RAID Levels in Linux”<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-11850","post","type-post","status-publish","format-standard","hentry","category-linux"],"_links":{"self":[{"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/posts\/11850","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/comments?post=11850"}],"version-history":[{"count":1,"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/posts\/11850\/revisions"}],"predecessor-version":[{"id":11851,"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/posts\/11850\/revisions\/11851"}],"wp:attachment":[{"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/media?parent=11850"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/categories?post=11850"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/tags?post=11850"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}