{"id":21079,"date":"2026-08-27T15:05:09","date_gmt":"2026-08-27T13:05:09","guid":{"rendered":"https:\/\/webhosting.de\/xfs-ext4-nvme-server-benchmarks-linux-storage\/"},"modified":"2026-08-27T15:05:09","modified_gmt":"2026-08-27T13:05:09","slug":"xfs-ext4-nvme-server-benchmarks-linux-storage","status":"publish","type":"post","link":"https:\/\/webhosting.de\/en\/xfs-ext4-nvme-server-benchmarks-linux-storage\/","title":{"rendered":"XFS vs. EXT4 on NVMe Servers: Benchmarks and Real-World Comparison"},"content":{"rendered":"<p>I compare <strong>XFS EXT4<\/strong> on NVMe servers based on the latest benchmarks and real-world data, and show you when each file system has a measurable performance advantage. I\u2019ll focus on throughput, latency, and real-world workloads so you can make the most of NVMe performance in your server.<\/p>\n\n<h2>Key points<\/h2>\n<p>To start off, I'll briefly summarize the key findings before diving into the details, benchmarks, and tuning.<\/p>\n<ul>\n  <li><strong>Random I\/O<\/strong>: Both are very close to each other; EXT4 has slightly higher throughput, while XFS has more consistent latencies.<\/li>\n  <li><strong>Sequential<\/strong>: XFS often leads the way with large files, with EXT4 close behind, delivering solid performance.<\/li>\n  <li><strong>Metadata<\/strong>: EXT4 offers some minor advantages; XFS provides consistent response times.<\/li>\n  <li><strong>Applications<\/strong>: Neck-and-neck in the polls, with differences in the low single digits.<\/li>\n  <li><strong>Tuning<\/strong>: The kernel, scheduler, I\/O depth, free space, and mount options make all the difference.<\/li>\n<\/ul>\n\n<h2>XFS and EXT4 on NVMe: Technical Overview<\/h2>\n<p>EXT4 is considered a proven Linux standard and delivers very <strong>reliable<\/strong> It serves as the baseline and is used as a reference in many comparisons. XFS is designed to handle large files, high levels of parallelism, and sequential data streams, and is very effective at maximizing NVMe throughput. On modern hardware, the performance gap is narrowing because both file systems have matured over the years and new kernel versions continue to optimize the NVMe stack. In everyday workloads, load profiles are often the deciding factor: many small, random accesses occur in rapid succession, while large sequential transfers tend to favor XFS. Decision-makers should therefore be familiar with their I\/O profile and not rely solely on general <strong>Rankings<\/strong> look.<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img fetchpriority=\"high\" decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/08\/server-benchmarkvergleich-2589.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Random I\/O on NVMe: Small Blocks, High Parallelism<\/h2>\n<p>For 4K and 8K accesses, both file systems deliver IOPS at a very <strong>similar<\/strong> Performance levels, often differing by only a few percentage points. In some benchmarks, EXT4 shows slightly higher average values for random writes, which may be noticeable in OLTP-like scenarios. XFS, on the other hand, excels with more consistent latencies and less jitter over longer runs, which facilitates predictable response times under mixed workloads. In production environments, caches, application logic, and network paths often mask these subtle differences. As a result, other tuning parameters\u2014such as the buffer cache, WAL strategy, or I\/O depth\u2014take center stage (Source: <strong>1<\/strong>, 4, 7).<\/p>\n\n<h2>Sequential Transfers: Moving Large Files Efficiently<\/h2>\n<p>With MB-sized blocks and long, sequential streams, XFS often comes out on top because its extent layout handles large files efficiently <strong>managed<\/strong>. Backup windows, archive jobs, and sequential checkpoints benefit noticeably from this, especially on PCIe 4.0\/5.0 NVMe. EXT4 remains close behind and delivers very good transfer rates that are rarely a limiting factor in many setups. The longer the stream and the larger the file, the more clearly the advantage shifts toward XFS. My short article provides a supplementary overview <a href=\"https:\/\/webhosting.de\/en\/ext4-xfs-zfs-hosting-performance-comparison-storage\/\">Performance comparison<\/a> with typical server workloads (Source: 4, 5, 9).<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/08\/xfs_ext4_nvme_benchmark_8345.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Metadata Operations: Many Small Files<\/h2>\n<p>Workloads involving many file operations place heavy demands on metadata paths and result in differences in locking and journaling. <strong>Light<\/strong>. In some tests, EXT4 has a slight edge when it comes to quickly creating and deleting many small files. XFS, on the other hand, maintains consistent latencies, making it well-suited for logs, caches, and build directories. Compared to alternative file systems, both demonstrate mature management and predictable response patterns. Anyone moving large numbers of small files should pay attention to the mount options and run practical tests over extended periods of time (Sources: 1, 7, 13).<\/p>\n\n<h2>Benchmark Overview by the Numbers<\/h2>\n<p>I'll summarize the following trends concisely so you can quickly identify typical patterns <strong>recognize<\/strong>. Random I\/O with small blocks: Differences are generally minor, often in the range of \u00b13\u20135 % for IOPS. Sequential I\/O with large blocks: XFS often leads, especially with long streams and large files. Metadata-heavy tests: a slight advantage for EXT4 in some cases; XFS delivers consistent latencies. In analytical scenarios, both file systems often utilize around 80\u201385 % of the theoretical NVMe performance, depending on the kernel, drivers, and controller firmware (Sources: 1, 3, 4, 5, 10).<\/p>\n<table>\n  <thead>\n    <tr>\n      <th>Scenario<\/th>\n      <th>Tendency<\/th>\n      <th>Typical Advantage<\/th>\n      <th>Note<\/th>\n    <\/tr>\n  <\/thead>\n  <tbody>\n    <tr>\n      <td>Random I\/O (4K\/8K)<\/td>\n      <td>Very close<\/td>\n      <td>EXT4 offers slightly higher throughput<\/td>\n      <td>XFS often has lower latency<\/td>\n    <\/tr>\n    <tr>\n      <td>Sequential (\u22651 MB)<\/td>\n      <td>XFS in the lead<\/td>\n      <td>Higher throughput for large files<\/td>\n      <td>Long streams amplify the effect<\/td>\n    <\/tr>\n    <tr>\n      <td>Metadata Operations<\/td>\n      <td>Neck and neck<\/td>\n      <td>EXT4 Is Sometimes Faster for Create\/Delete Operations<\/td>\n      <td>XFS Performs Consistently Under Mixed Load<\/td>\n    <\/tr>\n    <tr>\n      <td>Databases (OLTP)<\/td>\n      <td>Very close<\/td>\n      <td>EXT4: Slightly Higher TPS<\/td>\n      <td>XFS provides more consistent response times<\/td>\n    <\/tr>\n    <tr>\n      <td>Analytics\/Reporting<\/td>\n      <td>Close<\/td>\n      <td>XFS for Large Scans<\/td>\n      <td>Both use 80\u201385 % of the hardware<\/td>\n    <\/tr>\n  <\/tbody>\n<\/table>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/08\/xfs-vs-ext4-nvme-comparison-8473.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Application-Specific Benchmarks: Databases and Mixed Workloads<\/h2>\n<p>In PostgreSQL or MySQL tests, I see a neck-and-neck race influenced by latency profiles, WAL strategies, and buffer cache settings <strong>lives<\/strong>. EXT4 sometimes delivers a slightly higher number of transactions per second under high concurrency. XFS excels with stable response times, which can smooth out tail latencies in critical APIs. The differences remain small enough that database tuning has a greater impact than simply switching file systems. Therefore, decision-makers should measure endurance tests typical for their workload and carefully monitor application metrics (Sources: 2, 3, 9).<\/p>\n\n<h2>Kernel Version, NVMe Models, and Their Impact<\/h2>\n<p>Newer Linux kernels in the 5.x and 6.x series reduce latency and improve throughput, which benefits both file systems on fast NVMe drives and alleviates bottlenecks in the I\/O stack <strong>reduces<\/strong>. Enterprise SSDs with large DRAM caches and power-loss protection further mask these differences because the controller and firmware impose limits before the file system becomes a significant factor. Budget consumer NVMe drives show the range more clearly, but in everyday use they usually perform quite similarly. PCIe 4.0\/5.0 increases the headroom, making the sequential advantages of XFS more apparent. Kernel updates, NVMe firmware, and up-to-date drivers therefore yield measurable benefits (Source: 1, 5, 10, 11).<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/08\/xfs_ext4_nvme_vergleich_5273.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Tuning for NVMe: Scheduler, I\/O Depth, Free Space<\/h2>\n<p>I often start with a simple scheduler like <strong>none<\/strong> or mq-deadline and adjust the I\/O depth for each workload to fill queues efficiently. Too high a depth causes latency spikes, while too low a depth wastes parallel resources. Allocating 15\u201320 % of free space reduces fragmentation and keeps allocations fast. For XFS, I look at the distribution across allocation groups because they significantly influence the file system\u2019s parallelism; a good place to start is the <a href=\"https:\/\/webhosting.de\/en\/xfs-allocation-groups-nvme-performance-tuning-storagegrid\/\">XFS Allocation Groups<\/a>. I measure every change using an A\/B test to ensure that the effects remain traceable and that no negative changes slip through.<\/p>\n\n<h2>Make Strategic Use of Mount Options<\/h2>\n<p>Mount options affect journaling, commit intervals, and write paths, and can impact latency and throughput <strong>noticeable<\/strong> Adjust. EXT4 offers useful controls for journal mode and commit times, while XFS provides options for log buffers and inode parameters. I adjust these settings based on the load profile and document every change. If you want to dive deeper, you\u2019ll find concise notes on useful parameters in the <a href=\"https:\/\/webhosting.de\/en\/ext4-mount-options-hosting-server-tuning-performance-i-o\/\">EXT4 Mount Options<\/a>. It remains important to test every mount configuration with real-world workloads, not just with synthetic tests.<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/08\/XFS_EXT4_NVMe_Benchmark_2763.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Hosting Best Practices: Choosing Based on Workload<\/h2>\n<p>For traditional web applications with CMS and online stores, EXT4 provides a reliable <strong>Base<\/strong>, because many small files and mixed I\/O patterns dominate. Highly parallel databases perform very well on both file systems; I make my decision based on existing experience, monitoring setup, and backup strategy. Large sequential data streams during backups and archiving favor XFS, which streamlines transfer windows. Analytics workloads also benefit from XFS\u2019s handling of large scans, while mixed profiles often show little difference. If you\u2019re unsure, set up a staging system and measure performance under the most important daily workloads.<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/08\/xfs-ext4-nvme-server-8745.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Test Strategy: Realistic and Measurable<\/h2>\n<p>I combine short peak tests with long endurance runs so that I can assess both maximum values and jitter and aging effects <strong>see<\/strong>. Instead of relying solely on synthetic tools, I use copies of production databases, typical log files, and real import\/export jobs. I always run monitoring with iostat, perf, and application metrics so that I can clearly demonstrate correlations. I repeat the tests after kernel updates or firmware changes to detect regressions early. This reveals whether XFS or EXT4 provides the better balance of throughput, latency, and predictability in my own environment (Source: 1).<\/p>\n\n<h2>Journaling, Barriers, and Sync Semantics on NVMe<\/h2>\n<p>Journaling details play a role in determining latency spikes and recovery behavior. EXT4 uses by default <strong>data=ordered<\/strong> and writes metadata to the journal, while user data is persisted before the commit. If you need maximum write throughput while accepting a certain level of risk, you can <strong>data=writeback<\/strong> consider, although this makes replays after crashes more difficult. Newer versions of EXT4 support <strong>fast_commit<\/strong>, which bundles many small metadata transactions and reduces commit times. XFS maintains its own log (journal), whose <strong>logbsize<\/strong> and <strong>logbufs<\/strong> significantly affect parallelism and latency. On NVMe, <strong>Write Barriers<\/strong> Important: Without Power-Loss Protection (PLP), barriers should remain active to ensure that the controller firmware is not reordered. With PLP, you can selectively reduce barriers to speed up fsync()-intensive workloads\u2014but always weigh this against the risk. For applications with strict durability requirements (e.g., databases), clean fsync() behavior is more important than a few percentage points of additional throughput.<\/p>\n\n<h2>TRIM\/Discard and Long-Term Behavior of NVMe<\/h2>\n<p>Affect Flash <strong>Discard\/Trim<\/strong>-Strategies for sustainable write performance. Inline discard on mount (discard\/async_discard) reduces the controller's background workload but can cause latency spikes under heavy load. Periodic <strong>fstrim<\/strong>-Runs (e.g., weekly) help maintain more consistent performance in many production environments and decouple the release of unused blocks from the hot path. XFS efficiently processes discards in batches, while EXT4 offers <strong>discard=async<\/strong> A conservative approach. It is important to ensure that discard is properly propagated through all layers (dm-crypt, LVM, MD-RAID, hypervisor). If 15\u201320 % of reserve space is kept free over the long term, internal garbage collection is reduced\u2014latency jitter decreases, and write performance remains more stable.<\/p>\n\n<h2>RAID, LVM, and Encryption: Balancing the Layers Properly<\/h2>\n<p>Before formatting, the block geometry should be compatible with RAID\/LVM. For XFS, the correct choice of <strong>sunit\/swidth<\/strong> (Allocation-Alignment) the efficiency of large sequential transfers; in EXT4, this is done by <strong>stride\/stripe-width<\/strong>. If the alignment is correct, read-modify-write cycles in the RAID are minimized. LVM-Thin and snapshots are convenient, but they increase latency in write paths\u2014this has a greater impact on random workloads than on pure scan operations. <strong>dm-crypt\/LUKS<\/strong> It consumes CPU resources and can limit IOPS with small blocks; modern AES-NI\/ARM-Crypto help, but tail latencies typically increase slightly. For encrypted volumes, it\u2019s worth readjusting I\/O depth and queue affinities and explicitly allowing discards, if security policies permit it.<\/p>\n\n<h2>CPU\/NUMA, Interrupt Affinity, and io_uring: Fine-Tuning Latency<\/h2>\n<p>NVMe scales across multiple submission\/completion queues; whoever <strong>NUMA location<\/strong> Note that this reduces cross-node hops. NVMe IRQs and the application's worker threads should run on the same NUMA node where the memory is allocated. In Linux, IRQ pinning and customized <strong>rps\/xps<\/strong>-Settings to keep the data path local. Modern workloads benefit from <strong>io_uring<\/strong> (instead of the older AIO), which reduces syscalls and allows batch submission. In fio tests, this results in lower latencies at the same IOPS. Excessively high queue depths (<em>iodepth<\/em>) However, these values skew the latency distribution; it makes sense to use a series of tests (e.g., 1, 4, 16, 64) to identify the sweet spot for each workload.<\/p>\n\n<h2>Container and VM Environments: Unique Features in the Stack<\/h2>\n<p>For containers (overlayfs), XFS has long been the go-to choice because <strong>d_type<\/strong> was reliably available early on, and large layer sets were managed efficiently. Today, modern EXT4 deployments offer comparable stability; performance differences are minor and are driven more by overlayfs than by the file system itself. In VMs, the hypervisor\u2019s Virtio\/NVMe front ends and caching modes are the dominant factors: <strong>cache=none<\/strong> plus O_DIRECT in the guest reduces double buffering. The following are important: <strong>Discard Pass<\/strong> and uniform sector sizes (4K vs. 512e) to avoid write amplification. Snapshot-driven platforms (e.g., QCOW2, ZVOL) implement copy-on-write; the choice of file system in the guest remains relevant, but the host backend often imposes limits sooner than XFS\/EXT4 itself.<\/p>\n\n<h2>Recovery, Consistency, and Maintenance Windows<\/h2>\n<p>Both file systems are considered robust, but the <strong>Maintenance Routes<\/strong> differ. EXT4 can be thoroughly checked using e2fsck; on very large volumes, this takes a noticeable amount of time if errors are found, but benefits from incremental improvements (Fast-Commit shortens the replay time for smaller transactions). XFS is on <strong>Online Consistency<\/strong> configured; deep scans are run using xfs_repair, which requires a lot of RAM in critical situations and can take a long time with very large file systems. For production systems, it's worth <strong>fsfreeze<\/strong> Before taking LVM\/storage snapshots, to ensure application-consistent backups; databases should also trigger their own checkpoint\/backup mechanisms. Organizations with SLAs that have short RTOs and RPOs should explicitly schedule recovery tests\u2014this debunks myths and reveals realistic downtime windows.<\/p>\n\n<h2>Feature Aspects Beyond Raw Performance<\/h2>\n<p>Performance isn't everything. XFS offers <strong>Reflink<\/strong>-based copies and deduplication hooks, which save storage space and reduce copy times for VM images and large media collections. EXT4 stands out for its broad tool support and conservative defaults, which simplify rollouts. <strong>Quotas<\/strong> are available in both worlds; XFS stands out with <strong>Project-Quotas<\/strong> for directory-based quotas in large multitenant structures. Options such as <strong>noatime\/relatime\/lazytime<\/strong> significantly reduce the metadata write load. Anyone using per-directory or per-file encryption (fscrypt) should factor in the slight overhead associated with small random access operations and ensure they have sufficient CPU resources available.<\/p>\n\n<h2>Avoiding Measurement Errors: Common Pitfalls<\/h2>\n<p>Many supposed differences in FS are, in reality, <strong>Test artifacts<\/strong>. Data sets that are too small end up in the page cache and mask differences; data sets should be larger than the available RAM. A missing <em>warm-up<\/em> distorts random-write profiles on flash; similarly, concurrently running maintenance jobs (scrubs, rebuilds, fstrim) lead to outliers. In fio tests, it must be clear whether <strong>direct=1<\/strong> It is used to determine whether fsync() phases are set realistically and whether read\/write mixes run interleaved or in phases. Reproducible results require fixed CPU frequencies (no aggressive scaling governors), a constant background load, and clear isolation between testing and monitoring.<\/p>\n\n<h2>Practical Checklist: Here's How to Proceed<\/h2>\n<ul>\n  <li><strong>Determine the workload profile<\/strong>: Block sizes, read\/write ratio, latency budget, burst behavior.<\/li>\n  <li><strong>Clean up the stack<\/strong>: Check the kernel, NVMe firmware, and driver versions; verify IRQ affinity and NUMA.<\/li>\n  <li><strong>Align Layout<\/strong>: Set the RAID\/LVM alignment (sunit\/swidth or stride\/stripe width) correctly.<\/li>\n  <li><strong>Test Mount Options<\/strong>: Barriers, commit intervals, noatime\/relatime\/lazytime; XFS log parameters.<\/li>\n  <li><strong>Calibrate I\/O Depth<\/strong>: Balance latency and throughput; find the sweet spot for each application.<\/li>\n  <li><strong>Allow for extra space<\/strong>: 15\u201320 % reserve for consistent latencies and less fragmentation.<\/li>\n  <li><strong>Define a Discard Strategy<\/strong>: Inline vs. periodic fstrim, propagating through all layers.<\/li>\n  <li><strong>Backups &amp; Recovery<\/strong>: Test fsfreeze and snapshot processes; verify downtime under realistic conditions.<\/li>\n  <li><strong>A\/B measurements<\/strong>: Change only one variable; correlate the results with application metrics.<\/li>\n<\/ul>\n\n<h2>Summary: Decision-Making Guidance Without Myths<\/h2>\n<p>XFS and EXT4 deliver very high performance on NVMe; the differences are usually negligible <strong>moderate<\/strong> and depend heavily on the I\/O profile. Random workloads with small blocks are closely matched, while long sequential streams tend to give XFS the edge. EXT4 delivers slightly higher throughput in some transactional patterns, while XFS offers consistent latencies during sustained workloads. The kernel version, NVMe models, scheduler, I\/O depth, free space, and mount options often influence the results more than the choice of file system alone. Those who measure accurately and understand their own workloads can make an informed decision\u2014without myths and with measurable <strong>Profit<\/strong>.<\/p>","protected":false},"excerpt":{"rendered":"<p>XFS vs. EXT4 on NVMe Servers: This article explains benchmarks and real-world performance metrics and shows which file system is best suited for your Linux storage.<\/p>","protected":false},"author":1,"featured_media":21072,"comment_status":"","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[676],"tags":[],"class_list":["post-21079","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-server_vm"],"acf":[],"_wp_attached_file":null,"_wp_attachment_metadata":null,"litespeed-optimize-size":null,"litespeed-optimize-set":null,"_elementor_source_image_hash":null,"_wp_attachment_image_alt":null,"stockpack_author_name":null,"stockpack_author_url":null,"stockpack_provider":null,"stockpack_image_url":null,"stockpack_license":null,"stockpack_license_url":null,"stockpack_modification":null,"color":null,"original_id":null,"original_url":null,"original_link":null,"unsplash_location":null,"unsplash_sponsor":null,"unsplash_exif":null,"unsplash_attachment_metadata":null,"_elementor_is_screenshot":null,"surfer_file_name":null,"surfer_file_original_url":null,"envato_tk_source_kit":null,"envato_tk_source_index":null,"envato_tk_manifest":null,"envato_tk_folder_name":null,"envato_tk_builder":null,"envato_elements_download_event":null,"_menu_item_type":null,"_menu_item_menu_item_parent":null,"_menu_item_object_id":null,"_menu_item_object":null,"_menu_item_target":null,"_menu_item_classes":null,"_menu_item_xfn":null,"_menu_item_url":null,"_trp_menu_languages":null,"rank_math_primary_category":null,"rank_math_title":null,"inline_featured_image":null,"_yoast_wpseo_primary_category":null,"rank_math_schema_blogposting":null,"rank_math_schema_videoobject":null,"_oembed_049c719bc4a9f89deaead66a7da9fddc":null,"_oembed_time_049c719bc4a9f89deaead66a7da9fddc":null,"_yoast_wpseo_focuskw":null,"_yoast_wpseo_linkdex":null,"_oembed_27e3473bf8bec795fbeb3a9d38489348":null,"_oembed_c3b0f6959478faf92a1f343d8f96b19e":null,"_trp_translated_slug_en_us":null,"_wp_desired_post_slug":null,"_yoast_wpseo_title":null,"tldname":null,"tldpreis":null,"tldrubrik":null,"tldpolicylink":null,"tldsize":null,"tldregistrierungsdauer":null,"tldtransfer":null,"tldwhoisprivacy":null,"tldregistrarchange":null,"tldregistrantchange":null,"tldwhoisupdate":null,"tldnameserverupdate":null,"tlddeletesofort":null,"tlddeleteexpire":null,"tldumlaute":null,"tldrestore":null,"tldsubcategory":null,"tldbildname":null,"tldbildurl":null,"tldclean":null,"tldcategory":null,"tldpolicy":null,"tldbesonderheiten":null,"tld_bedeutung":null,"_oembed_d167040d816d8f94c072940c8009f5f8":null,"_oembed_b0a0fa59ef14f8870da2c63f2027d064":null,"_oembed_4792fa4dfb2a8f09ab950a73b7f313ba":null,"_oembed_33ceb1fe54a8ab775d9410abf699878d":null,"_oembed_fd7014d14d919b45ec004937c0db9335":null,"_oembed_21a029d076783ec3e8042698c351bd7e":null,"_oembed_be5ea8a0c7b18e658f08cc571a909452":null,"_oembed_a9ca7a298b19f9b48ec5914e010294d2":null,"_oembed_f8db6b27d08a2bb1f920e7647808899a":null,"_oembed_168ebde5096e77d8a89326519af9e022":null,"_oembed_cdb76f1b345b42743edfe25481b6f98f":null,"_oembed_87b0613611ae54e86e8864265404b0a1":null,"_oembed_27aa0e5cf3f1bb4bc416a4641a5ac273":null,"_oembed_time_27aa0e5cf3f1bb4bc416a4641a5ac273":null,"_tldname":null,"_tldclean":null,"_tldpreis":null,"_tldcategory":null,"_tldsubcategory":null,"_tldpolicy":null,"_tldpolicylink":null,"_tldsize":null,"_tldregistrierungsdauer":null,"_tldtransfer":null,"_tldwhoisprivacy":null,"_tldregistrarchange":null,"_tldregistrantchange":null,"_tldwhoisupdate":null,"_tldnameserverupdate":null,"_tlddeletesofort":null,"_tlddeleteexpire":null,"_tldumlaute":null,"_tldrestore":null,"_tldbildname":null,"_tldbildurl":null,"_tld_bedeutung":null,"_tldbesonderheiten":null,"_oembed_ad96e4112edb9f8ffa35731d4098bc6b":null,"_oembed_8357e2b8a2575c74ed5978f262a10126":null,"_oembed_3d5fea5103dd0d22ec5d6a33eff7f863":null,"_eael_widget_elements":null,"_oembed_0d8a206f09633e3d62b95a15a4dd0487":null,"_oembed_time_0d8a206f09633e3d62b95a15a4dd0487":null,"_aioseo_description":null,"_eb_attr":null,"_eb_data_table":null,"_oembed_819a879e7da16dd629cfd15a97334c8a":null,"_oembed_time_819a879e7da16dd629cfd15a97334c8a":null,"_acf_changed":null,"_wpcode_auto_insert":null,"_edit_last":null,"_edit_lock":null,"_oembed_e7b913c6c84084ed9702cb4feb012ddd":null,"_oembed_bfde9e10f59a17b85fc8917fa7edf782":null,"_oembed_time_bfde9e10f59a17b85fc8917fa7edf782":null,"_oembed_03514b67990db061d7c4672de26dc514":null,"_oembed_time_03514b67990db061d7c4672de26dc514":null,"rank_math_news_sitemap_robots":null,"rank_math_robots":null,"_eael_post_view_count":"141","_trp_automatically_translated_slug_ru_ru":null,"_trp_automatically_translated_slug_et":null,"_trp_automatically_translated_slug_lv":null,"_trp_automatically_translated_slug_fr_fr":null,"_trp_automatically_translated_slug_en_us":null,"_wp_old_slug":null,"_trp_automatically_translated_slug_da_dk":null,"_trp_automatically_translated_slug_pl_pl":null,"_trp_automatically_translated_slug_es_es":null,"_trp_automatically_translated_slug_hu_hu":null,"_trp_automatically_translated_slug_fi":null,"_trp_automatically_translated_slug_ja":null,"_trp_automatically_translated_slug_lt_lt":null,"_elementor_edit_mode":null,"_elementor_template_type":null,"_elementor_version":null,"_elementor_pro_version":null,"_wp_page_template":null,"_elementor_page_settings":null,"_elementor_data":null,"_elementor_css":null,"_elementor_conditions":null,"_happyaddons_elements_cache":null,"_oembed_75446120c39305f0da0ccd147f6de9cb":null,"_oembed_time_75446120c39305f0da0ccd147f6de9cb":null,"_oembed_3efb2c3e76a18143e7207993a2a6939a":null,"_oembed_time_3efb2c3e76a18143e7207993a2a6939a":null,"_oembed_59808117857ddf57e478a31d79f76e4d":null,"_oembed_time_59808117857ddf57e478a31d79f76e4d":null,"_oembed_965c5b49aa8d22ce37dfb3bde0268600":null,"_oembed_time_965c5b49aa8d22ce37dfb3bde0268600":null,"_oembed_81002f7ee3604f645db4ebcfd1912acf":null,"_oembed_time_81002f7ee3604f645db4ebcfd1912acf":null,"_elementor_screenshot":null,"_oembed_7ea3429961cf98fa85da9747683af827":null,"_oembed_time_7ea3429961cf98fa85da9747683af827":null,"_elementor_controls_usage":null,"_elementor_page_assets":[],"_elementor_screenshot_failed":null,"theplus_transient_widgets":null,"_eael_custom_js":null,"_wp_old_date":null,"_trp_automatically_translated_slug_it_it":null,"_trp_automatically_translated_slug_pt_pt":null,"_trp_automatically_translated_slug_zh_cn":null,"_trp_automatically_translated_slug_nl_nl":null,"_trp_automatically_translated_slug_pt_br":null,"_trp_automatically_translated_slug_sv_se":null,"rank_math_analytic_object_id":null,"rank_math_internal_links_processed":"1","_trp_automatically_translated_slug_ro_ro":null,"_trp_automatically_translated_slug_sk_sk":null,"_trp_automatically_translated_slug_bg_bg":null,"_trp_automatically_translated_slug_sl_si":null,"litespeed_vpi_list":null,"litespeed_vpi_list_mobile":null,"rank_math_seo_score":null,"rank_math_contentai_score":null,"ilj_limitincominglinks":null,"ilj_maxincominglinks":null,"ilj_limitoutgoinglinks":null,"ilj_maxoutgoinglinks":null,"ilj_limitlinksperparagraph":null,"ilj_linksperparagraph":null,"ilj_blacklistdefinition":null,"ilj_linkdefinition":null,"_eb_reusable_block_ids":null,"rank_math_focus_keyword":"XFS EXT4","rank_math_og_content_image":null,"_yoast_wpseo_metadesc":null,"_yoast_wpseo_content_score":null,"_yoast_wpseo_focuskeywords":null,"_yoast_wpseo_keywordsynonyms":null,"_yoast_wpseo_estimated-reading-time-minutes":null,"rank_math_description":null,"surfer_last_post_update":null,"surfer_last_post_update_direction":null,"surfer_keywords":null,"surfer_location":null,"surfer_draft_id":null,"surfer_permalink_hash":null,"surfer_scrape_ready":null,"_thumbnail_id":"21072","footnotes":null,"_links":{"self":[{"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/posts\/21079","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/comments?post=21079"}],"version-history":[{"count":0,"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/posts\/21079\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/media\/21072"}],"wp:attachment":[{"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/media?parent=21079"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/categories?post=21079"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/tags?post=21079"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}