{"id":6428,"date":"2023-12-14T11:20:18","date_gmt":"2023-12-14T18:20:18","guid":{"rendered":"https:\/\/ioflood.com\/blog\/?p=6428"},"modified":"2023-12-14T11:22:45","modified_gmt":"2023-12-14T18:22:45","slug":"lvm-linux-command","status":"publish","type":"post","link":"https:\/\/ioflood.com\/blog\/lvm-linux-command\/","title":{"rendered":"LVM Cheat Sheet | Linux System Administration Guide"},"content":{"rendered":"
\n
\"Digital<\/figure>\n<\/div>\n

Are you finding it challenging to manage disk drives in Linux? You’re not alone. Many system administrators and developers grapple with this task, but there’s a tool that can make this process a breeze. Like a skilled architect, the LVM (Logical Volume Manager) command in Linux allows you to design and manage your storage space with ease. These commands can run on any Linux system, providing a versatile and handy tool for various tasks.<\/p>\n

This guide will walk you through the basics to the advanced usage of the LVM command.<\/strong> We\u2019ll explore LVM’s core functionality, delve into its advanced features, and even discuss common issues and their solutions.<\/p>\n

So, let’s dive in and start mastering the LVM command in Linux!<\/p>\n

TL;DR: What is LVM in Linux?<\/h2>\n

\n The LVM<\/code>, or Logical Volume Manager, is a flexible and advanced command in Linux. You can manage physical volumes with pvcreate<\/code>, volume groups with vgcreate<\/code>, and logical volumes with lvcreate<\/code>. It provides a method of allocating space on mass-storage devices that is more flexible than conventional partitioning schemes. In particular, it allows volumes to be resized and moved across different physical devices on the fly.\n<\/p><\/blockquote>\n

Here’s a simple example of creating a logical volume:<\/p>\n

pvcreate \/dev\/sdb1\nvgcreate myvg \/dev\/sdb1\nlvcreate -n mylv -L 10G myvg\n\n# Output:\n# Physical volume \"\/dev\/sdb1\" successfully created.\n# Volume group \"myvg\" successfully created\n# Logical volume \"mylv\" created.\n<\/code><\/pre>\n
In this example, we first create a physical volume with pvcreate<\/code>, then create a volume group with vgcreate<\/code>, and finally, we create a logical volume with lvcreate<\/code>. The -n<\/code> option specifies the name of the logical volume, and -L<\/code> specifies the size.<\/p>\n
\n  This is just a basic way to use the LVM command in Linux, but there’s much more to learn about managing your storage space efficiently. Continue reading for a deeper understanding and more advanced usage scenarios.\n<\/p><\/blockquote>\n
Getting Started with LVMs in Linux<\/h2>\n
The LVM command in Linux is a powerful tool that allows you to manage physical volumes, volume groups, and logical volumes. But before we dive into the code, let’s take a moment to understand these concepts.<\/p>\n
    \n
  • Physical Volumes (PV):<\/strong> These are your actual disks or disk partitions.<\/li>\n
  • Volume Groups (VG):<\/strong> A volume group is a pool of disk space made from one or more physical volumes.<\/li>\n
  • Logical Volumes (LV):<\/strong> These are the partitions that your operating systems and applications will actually use. They reside within a volume group.<\/li>\n<\/ul>\n
    Now, let’s see how we can use the LVM command to create and manage these components.<\/p>\n
    First, let’s create a physical volume. Here is an example:<\/p>\n
    pvcreate \/dev\/sdc1\n\n# Output:\n# Physical volume \"\/dev\/sdc1\" successfully created.\n<\/code><\/pre>\n
    In this example, we used pvcreate<\/code> to create a new physical volume on the disk partition \/dev\/sdc1<\/code>. The output confirms that the physical volume was successfully created.<\/p>\n
    Next, let’s create a volume group. Here’s how you can do it:<\/p>\n
    vgcreate my_vg \/dev\/sdc1\n\n# Output:\n# Volume group \"my_vg\" successfully created\n<\/code><\/pre>\n
    In the above example, vgcreate<\/code> is used to create a new volume group named my_vg<\/code> using the physical volume we created earlier (\/dev\/sdc1<\/code>).<\/p>\n
    Finally, let’s create a logical volume within our volume group. Here’s the command:<\/p>\n
    lvcreate -n my_lv -L 5G my_vg\n\n# Output:\n# Logical volume \"my_lv\" created.\n<\/code><\/pre>\n
    In this command, lvcreate<\/code> creates a logical volume. The -n<\/code> option specifies the name of the logical volume (my_lv<\/code>), and -L<\/code> specifies the size (5G).<\/p>\n
    The LVM command provides a flexible and efficient way to manage your storage space in Linux. However, it’s important to remember that while these commands are powerful, they also come with potential pitfalls. For example, if you delete a logical volume, all data stored on it will be lost. Therefore, always ensure you have a reliable backup system in place.<\/p>\n
    Unleashing the Full Potential of LVMs<\/h2>\n
    Now that you’re comfortable with the basics of the LVM command, it’s time to explore its more advanced features. These include resizing volumes, moving data between volumes, and managing snapshots. But before we delve into these, let’s familiarize ourselves with some of the command-line arguments or flags that can modify the behavior of the LVM command. Here’s a table with some of the most commonly used LVM arguments.<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
    Argument<\/th>\nDescription<\/th>\nExample<\/th>\n<\/tr>\n<\/thead>\n
    -l<\/code><\/td>\nSpecifies the number of logical extents.<\/td>\nlvcreate -l 100 -n mylv myvg<\/code><\/td>\n<\/tr>\n
    -L<\/code><\/td>\nSpecifies the size of the logical volume.<\/td>\nlvcreate -L 20G -n mylv myvg<\/code><\/td>\n<\/tr>\n
    -m<\/code><\/td>\nSets the number of mirrors.<\/td>\nlvcreate -m1 -L 10G -n mylv myvg<\/code><\/td>\n<\/tr>\n
    -n<\/code><\/td>\nNames the logical volume.<\/td>\nlvcreate -n mylv -L 10G myvg<\/code><\/td>\n<\/tr>\n
    -p<\/code><\/td>\nSets the permissions to read or write.<\/td>\nlvchange -p r myvg\/mylv<\/code><\/td>\n<\/tr>\n
    -r<\/code><\/td>\nMakes the logical volume read-only.<\/td>\nlvchange -pr myvg\/mylv<\/code><\/td>\n<\/tr>\n
    -s<\/code><\/td>\nCreates a snapshot of the logical volume.<\/td>\nlvcreate -s -n mylv_snap myvg\/mylv<\/code><\/td>\n<\/tr>\n
    -v<\/code><\/td>\nMakes the command run in verbose mode.<\/td>\nlvcreate -v -n mylv -L 10G myvg<\/code><\/td>\n<\/tr>\n
    -Z<\/code><\/td>\nSets the zeroing policy of the logical volume.<\/td>\nlvcreate -Z y -n mylv -L 10G myvg<\/code><\/td>\n<\/tr>\n
    -R<\/code><\/td>\nSpecifies the region size for RAID logical volumes.<\/td>\nlvcreate --type raid5 -i 2 -L 1G -n mylv myvg -R 512<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
    Let’s now delve deeper into the advanced usage of the LVM command.<\/p>\n
    Resizing Volumes<\/h3>\n
    One of the standout features of LVM is the ability to resize volumes. This can be particularly useful when you’re dealing with dynamic storage needs.<\/p>\n
    Here’s how you can resize a logical volume:<\/p>\n
    lvextend -L+5G \/dev\/myvg\/mylv\nresize2fs \/dev\/myvg\/mylv\n\n# Output:\n# Size of logical volume myvg\/mylv changed from 10.00 GiB (2560 extents) to 15.00 GiB (3840 extents).\n# Logical volume mylv successfully resized.\n<\/code><\/pre>\n
    In this example, we used lvextend<\/code> to increase the size of the logical volume mylv<\/code> by 5GB. We then used resize2fs<\/code> to resize the filesystem to fit the enlarged volume.<\/p>\n
    Moving Data Between Volumes<\/h3>\n
    LVM also allows you to move data from one logical volume to another. This can be useful when you want to free up space on a specific volume.<\/p>\n
    Here’s an example:<\/p>\n
    pvmove \/dev\/sdb1 \/dev\/sdc1\n\n# Output:\n# \/dev\/sdb1: Moved: 10.0%\n# \/dev\/sdb1: Moved: 20.0%\n# ...\n# \/dev\/sdb1: Moved: 100%\n<\/code><\/pre>\n
    In this example, we used pvmove<\/code> to move all physical extents from \/dev\/sdb1<\/code> to \/dev\/sdc1<\/code>.<\/p>\n
    Managing Snapshots<\/h3>\n
    Snapshots are another powerful feature of LVM. They allow you to create a copy of a logical volume at a specific point in time.<\/p>\n
    Here’s how you can create a snapshot:<\/p>\n
    lvcreate -L1G -s -n mylv_snap \/dev\/myvg\/mylv\n\n# Output:\n# Logical volume \"mylv_snap\" created.\n<\/code><\/pre>\n
    In this example, we created a snapshot of mylv<\/code> named mylv_snap<\/code> with a size of 1GB.<\/p>\n
    The LVM command provides a flexible and efficient way to manage your storage space in Linux. However, it’s important to remember that while these commands are powerful, they also come with potential pitfalls. For example, if you delete a logical volume, all data stored on it will be lost. Therefore, always ensure you have a reliable backup system in place.<\/p>\n
    Alternative Disk Management Methods in Linux<\/h2>\n
    While the LVM command offers a powerful and flexible way to manage disk space in Linux, it’s not the only tool available. There are alternative methods you can use, such as traditional partitioning, RAID, or even third-party tools. Let’s dive into these alternatives and see how they compare to LVM.<\/p>\n
    Traditional Partitioning<\/h3>\n
    Before the advent of LVM, most Linux users relied on traditional partitioning to manage their disk space. This involves dividing your hard drive into distinct sections, each of which acts as a separate drive.<\/p>\n
    Here’s an example of creating a partition using fdisk<\/code>:<\/p>\n
    fdisk \/dev\/sdb\n\n# Output:\n# Welcome to fdisk (util-linux 2.36.1).\n# Changes will remain in memory only, until you decide to write them.\n# Be careful before using the write command.\n\n<\/code><\/pre>\n
    In this example, we used fdisk<\/code> to create a new partition on the disk \/dev\/sdb<\/code>. The output shows that changes will only be applied when you decide to write them, giving you control over the process.<\/p>\n
    While traditional partitioning is straightforward, it lacks the flexibility of LVM. For instance, resizing partitions with traditional partitioning can be a complex and risky process.<\/p>\n
    RAID<\/h3>\n
    RAID (Redundant Array of Independent Disks) is another method for managing disk space. It combines multiple physical disks into a single logical unit for the purposes of redundancy, performance improvement, or both.<\/p>\n
    Here’s an example of creating a RAID 1 array using mdadm<\/code>:<\/p>\n
    mdadm --create --verbose \/dev\/md0 --level=1 --raid-devices=2 \/dev\/sda1 \/dev\/sdb1\n\n# Output:\n# mdadm: Note: this array has metadata at the start and\n#    may not be suitable as a boot device.  If you plan to\n#    store '\/boot' on this device please ensure that\n#    your boot-loader understands md\/v1.x metadata, or use\n#    --metadata=0.90\n# mdadm: size set to 2097088K\n# Continue creating array? y\n# mdadm: Defaulting to version 1.2 metadata\n# mdadm: array \/dev\/md0 started.\n<\/code><\/pre>\n
    In this example, we used mdadm<\/code> to create a RAID 1 array consisting of two disks (\/dev\/sda1<\/code> and \/dev\/sdb1<\/code>). The output provides a warning about storing the boot partition on this array and prompts for confirmation before creating the array.<\/p>\n
    While RAID provides redundancy and can improve performance, it’s not as flexible as LVM when it comes to disk management. For instance, RAID doesn’t support the creation of snapshots.<\/p>\n
    Third-Party Tools<\/h3>\n
    There are also third-party tools available for disk management in Linux, such as GParted and Parted Magic. These tools provide a graphical interface for managing your disk space, making them more user-friendly than command-line tools. However, they may not offer the same level of control or flexibility as the LVM command.<\/p>\n
    In conclusion, while there are several methods for managing disk space in Linux, the LVM command offers a combination of power, flexibility, and control that is hard to beat. Whether you’re a beginner or an experienced system administrator, mastering the LVM command will undoubtedly be a valuable addition to your Linux toolkit.<\/p>\n
    Navigating Issues with LVMs<\/h2>\n
    While LVM is a powerful tool for managing disk space in Linux, it’s not without its challenges. Here, we’ll discuss some common issues you may encounter when using LVM, along with solutions and workarounds.<\/p>\n
    Problems with Volume Resizing<\/h3>\n
    One common issue is problems with volume resizing. For example, you may encounter an error message when trying to resize a volume group. This is often due to insufficient space in the volume group.<\/p>\n
    Here’s an example of such an error and how to resolve it:<\/p>\n
    lvextend -L +1G \/dev\/myvg\/mylv\n\n# Output:\n# Insufficient free space: 256 extents needed, but only 0 available\n<\/code><\/pre>\n
    In this example, we tried to extend the logical volume mylv<\/code> by 1GB, but the operation failed because there was not enough free space in the volume group myvg<\/code>. To resolve this issue, you can either reduce the size of the extension or add more physical volumes to the volume group.<\/p>\n
    Data Loss<\/h3>\n
    Another potential pitfall is data loss. This can occur if you accidentally delete a logical volume.<\/p>\n
    Here’s an example of how this can happen:<\/p>\n
    lvremove \/dev\/myvg\/mylv\n\n# Output:\n# Do you really want to remove active logical volume mylv? [y\/n]: y\n# Logical volume \"mylv\" successfully removed\n<\/code><\/pre>\n
    In this example, we used lvremove<\/code> to remove the logical volume mylv<\/code>. The command prompts for confirmation before removing the volume, but if you confirm the operation, all data on the volume will be lost. To prevent accidental data loss, always make sure to have a backup of your data before performing any destructive operations.<\/p>\n
    Performance Issues<\/h3>\n
    Lastly, you may encounter performance issues when using LVM. This can be due to various factors, such as disk I\/O, CPU usage, or network latency.<\/p>\n
    One way to troubleshoot performance issues is by using the iostat<\/code> command to monitor disk I\/O:<\/p>\n
    iostat -dx \/dev\/myvg\/mylv 1\n\n# Output:\n# Device: rrqm\/s wrqm\/s r\/s w\/s rMB\/s wMB\/s avgrq-sz avgqu-sz await r_await w_await svctm %util\n# \/dev\/myvg\/mylv 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00\n<\/code><\/pre>\n
    In this example, iostat<\/code> provides detailed statistics about disk I\/O for the logical volume mylv<\/code>. You can use this information to identify potential bottlenecks and optimize your system accordingly.<\/p>\n
    In conclusion, while LVM is a powerful tool, it’s not without its challenges. However, with careful planning and a good understanding of its features, you can navigate these pitfalls and effectively manage your disk space in Linux.<\/p>\n
    Understanding the Building Blocks of LVM<\/h2>\n
    Before we can fully appreciate the power and flexibility of the LVM command in Linux, we need to understand the fundamental concepts that underpin it. These include physical volumes, volume groups, and logical volumes.<\/p>\n
    Physical Volumes<\/h3>\n
    Physical volumes are the foundation of the LVM structure. They represent the actual storage devices (hard drives or partitions) on your system. You can think of them as the raw materials that LVM uses to construct your storage architecture.<\/p>\n
    pvdisplay \/dev\/sdb1\n\n# Output:\n# --- Physical volume ---\n# PV Name               \/dev\/sdb1\n# VG Name               myvg\n# PV Size               10.00 GiB \/ not usable 4.00 MiB\n# Allocatable           yes\n# PE Size               4.00 MiB\n# Total PE              2559\n# Free PE               0\n# Allocated PE          2559\n# PV UUID               0s1gPQ-4ebp-9Hpf-uJh4-8VZ8-e6WY-kJ4c5N\n<\/code><\/pre>\n
    In the above example, the pvdisplay<\/code> command provides detailed information about the physical volume \/dev\/sdb1<\/code>. The output shows the volume’s size, allocation status, and other important details.<\/p>\n
    Volume Groups<\/h3>\n
    Volume groups act as containers for physical volumes. They provide a pool of disk space from which logical volumes can be allocated. This level of abstraction allows for greater flexibility and ease of management.<\/p>\n
    vgdisplay myvg\n\n# Output:\n# --- Volume group ---\n# VG Name               myvg\n# System ID\n# Format                lvm2\n# Metadata Areas        1\n# Metadata Sequence No  3\n# VG Access             read\/write\n# VG Status             resizable\n# MAX LV                0\n# Cur LV                2\n# Open LV               2\n# Max PV                0\n# Cur PV                1\n# Act PV                1\n# VG Size               <10.00 GiB\n# PE Size               4.00 MiB\n# Total PE              2559\n# Alloc PE \/ Size       2559 \/ <10.00 GiB\n# Free  PE \/ Size       0 \/ 0\n# VG UUID               9zrUvK-5fVf-vG8N-otb4-PF4Z-9zJC-7CpqBf\n<\/code><\/pre>\n
    In this example, vgdisplay<\/code> provides information about the volume group myvg<\/code>. The output shows the volume group’s size, the number of logical volumes it contains, and other relevant details.<\/p>\n
    Logical Volumes<\/h3>\n
    Logical volumes are the partitions that your operating systems and applications will actually use. They reside within a volume group and can span multiple physical volumes.<\/p>\n
    lvdisplay \/dev\/myvg\/mylv\n\n# Output:\n# --- Logical volume ---\n# LV Path                \/dev\/myvg\/mylv\n# LV Name                mylv\n# VG Name                myvg\n# LV UUID                J1r8G8-1qD2-Vn8h-0hF6-keZE-oiMO-fR4Scp\n# LV Write Access        read\/write\n# LV Creation host, time ubuntu, 2021-01-01 00:00:00 -0700\n# LV Status              available\n# # open                 1\n# LV Size                <10.00 GiB\n# Current LE             2559\n# Segments               1\n# Allocation             inherit\n# Read ahead sectors     auto\n# - currently set to     256\n# Block device           253:0\n<\/code><\/pre>\n
    In the above example, lvdisplay<\/code> provides detailed information about the logical volume mylv<\/code>. The output shows the volume’s size, status, and other important details.<\/p>\n
    In conclusion, LVM’s structure of physical volumes, volume groups, and logical volumes provides a flexible and efficient way to manage disk space in Linux. Whether you’re dealing with a single hard drive or a complex array of storage devices, LVM gives you the tools to manage your storage space with ease.<\/p>\n
    LVM in Real-World Scenarios: Beyond the Basics<\/h2>\n
    Having delved into the mechanics of the LVM command in Linux, it’s time to explore its relevance in real-world scenarios. LVM’s flexibility and power make it an invaluable tool in various situations, from managing large storage arrays to handling dynamic storage needs and improving data integrity.<\/p>\n
    Managing Large Storage Arrays<\/h3>\n
    In an era where data is king, managing large storage arrays efficiently is crucial. LVM shines in this aspect. With its ability to group multiple physical volumes into a single logical volume, managing large amounts of data becomes a breeze.<\/p>\n
    vgextend myvg \/dev\/sdb2 \/dev\/sdc2\n\n# Output:\n# Volume group \"myvg\" successfully extended\n<\/code><\/pre>\n
    In this example, vgextend<\/code> is used to add two more physical volumes (\/dev\/sdb2<\/code> and \/dev\/sdc2<\/code>) to the existing volume group myvg<\/code>. This allows for easy management of large storage arrays.<\/p>\n
    Handling Dynamic Storage Needs<\/h3>\n
    Businesses today have dynamic storage needs, with requirements changing rapidly. LVM allows for easy resizing of logical volumes, making it ideal for such environments.<\/p>\n
    lvresize -L +5G \/dev\/myvg\/mylv\nresize2fs \/dev\/myvg\/mylv\n\n# Output:\n# Size of logical volume myvg\/mylv changed from 15.00 GiB (3840 extents) to 20.00 GiB (5120 extents).\n# Logical volume mylv successfully resized.\n<\/code><\/pre>\n
    In the above example, lvresize<\/code> is used to increase the size of the logical volume mylv<\/code> by 5GB, followed by resize2fs<\/code> to resize the filesystem to fit the enlarged volume.<\/p>\n
    Improving Data Integrity<\/h3>\n
    LVM also plays a role in improving data integrity. With features like mirroring and snapshotting, LVM can help prevent data loss and facilitate easy recovery.<\/p>\n
    lvcreate -L1G -s -n mylv_snap \/dev\/myvg\/mylv\n\n# Output:\n# Logical volume \"mylv_snap\" created.\n<\/code><\/pre>\n
    In this example, a snapshot of mylv<\/code> named mylv_snap<\/code> is created. This snapshot can be used for recovery in case of accidental deletion or corruption of data.<\/p>\n
    Exploring Related Concepts<\/h3>\n
    While LVM provides a comprehensive solution for disk management in Linux, it’s worth exploring related concepts like file systems and RAID for a more holistic understanding of Linux storage management.<\/p>\n
    Further Resources for Mastering LVM<\/h3>\n
    For those interested in delving deeper into the world of LVM, here are some resources to guide you on your journey:<\/p>\n
      \n
    1. The Linux Logical Volume Manager<\/a> – This is an in-depth guide on LVM by The Linux Documentation Project.<\/p>\n<\/li>\n
    2. \n
      Introduction to LVM<\/a> – A beginner-friendly introduction to LVM concepts and operations by DigitalOcean.<\/p>\n<\/li>\n
    3. \n
      Linux LVM Guide<\/a> – A comprehensive guide on LVM by HowtoForge, complete with practical examples.<\/p>\n<\/li>\n<\/ol>\n
      Wrapping Up: Linux Logical Volume Manager<\/h2>\n
      In this comprehensive guide, we’ve delved into the world of the LVM command in Linux, a powerful tool for managing disk drives in Linux. We’ve covered the basic to advanced usage of LVM, its core functionality, and solutions to common issues.<\/p>\n
      We began with a basic understanding of LVM and how to use it to manage physical volumes, volume groups, and logical volumes. We then progressed to more complex uses of LVM, such as resizing volumes, moving data between volumes, and managing snapshots. Along the way, we tackled common issues you might encounter when using LVM, such as problems with volume resizing, data loss, and performance issues, providing you with solutions and workarounds for each issue.<\/p>\n
      We also looked at alternative approaches to disk management in Linux, comparing LVM with traditional partitioning, RAID, and third-party tools. Here’s a quick comparison of these methods:<\/p>\n\n\n\n\n\n\n\n\n
      Method<\/th>\nFlexibility<\/th>\nComplexity<\/th>\nRisk<\/th>\n<\/tr>\n<\/thead>\n
      LVM<\/td>\nHigh<\/td>\nModerate<\/td>\nLow with proper backup<\/td>\n<\/tr>\n
      Traditional Partitioning<\/td>\nLow<\/td>\nLow<\/td>\nLow<\/td>\n<\/tr>\n
      RAID<\/td>\nHigh<\/td>\nHigh<\/td>\nHigh without redundancy<\/td>\n<\/tr>\n
      Third-party Tools<\/td>\nModerate<\/td>\nLow<\/td>\nDepends on the tool<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
      Whether you’re just starting out with LVM or you’re looking to level up your disk management skills, we hope this guide has given you a deeper understanding of LVM and its capabilities.<\/p>\n
      With its balance of flexibility, control, and power, LVM is a powerful tool for disk management in Linux. Happy managing!<\/p>\n","protected":false},"excerpt":{"rendered":"
      Are you finding it challenging to manage disk drives in Linux? You’re not alone. Many system administrators and developers grapple with this task, but there’s a tool that can make this process a breeze. Like a skilled architect, the LVM (Logical Volume Manager) command in Linux allows you to design and manage your storage space […]<\/p>\n","protected":false},"author":1,"featured_media":13848,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[124,3,9],"tags":[],"class_list":["post-6428","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-bash","category-linux","category-sysadmin","cat-124-id","cat-3-id","cat-9-id","has_thumb"],"_links":{"self":[{"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/posts\/6428","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/comments?post=6428"}],"version-history":[{"count":7,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/posts\/6428\/revisions"}],"predecessor-version":[{"id":13855,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/posts\/6428\/revisions\/13855"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/media\/13848"}],"wp:attachment":[{"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/media?parent=6428"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/categories?post=6428"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/tags?post=6428"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}