{"id":25031,"date":"2026-10-20T13:39:26","date_gmt":"2026-10-20T13:39:26","guid":{"rendered":"https:\/\/atalnetworks.com\/?p=25031"},"modified":"2026-10-20T13:57:23","modified_gmt":"2026-10-20T13:57:23","slug":"raid-levels-dedicated-server","status":"publish","type":"post","link":"https:\/\/atalnetworks.com\/de\/raid-levels-dedicated-server\/","title":{"rendered":"RAID 0, 1, 5, 6, 10: Which Level for Your Dedicated Server?"},"content":{"rendered":"

The right RAID level depends on your drive count, workload, capacity target, and response to a failed drive. A two-drive production server often starts with RAID 1. RAID 10 deserves a look for busy databases and virtual machines. RAID 6 suits capacity-focused arrays that need to survive two failed drives. RAID 5 makes sense only when its one-drive failure limit and rebuild behavior fit the plan. Use RAID 0 for data you can recreate. Data you need to retain also needs a separate backup.<\/span><\/p>\n

RAID levels for dedicated servers\u00a0<\/span><\/h2>\n

This table assumes equal-size drives in a conventional layout. <\/span>N<\/span> is the number of active drives, and <\/span>S<\/span> is the usable size of one drive. It excludes a hot spare, array metadata, partitions, and filesystem overhead.<\/span><\/p>\n\n\n\n\n\n\n\n\n\n
Level<\/b><\/th>\nMinimum drives<\/b><\/th>\nApproximate usable capacity<\/b><\/th>\nFailed drives tolerated<\/b><\/th>\nFirst workload to assess<\/b><\/th>\nMain cost<\/b><\/th>\n<\/tr>\n<\/thead>\n
RAID 0<\/span><\/td>\n2<\/span><\/td>\nN \u00d7 S<\/span><\/td>\nKeiner<\/span><\/td>\nDisposable scratch or cache<\/span><\/td>\nOne drive failure takes down the array<\/span><\/td>\n<\/tr>\n
RAID 1<\/span><\/td>\n2<\/span><\/td>\nS<\/span> for a two-drive mirror<\/span><\/td>\nOne of the two<\/span><\/td>\nSmall production server or boot mirror<\/span><\/td>\nHalf the raw space is used for the copy<\/span><\/td>\n<\/tr>\n
RAID 5<\/span><\/td>\n3<\/span><\/td>\n(N \u2212 1) \u00d7 S<\/span><\/td>\nAny one<\/span><\/td>\nRead-heavy storage with an accepted recovery plan<\/span><\/td>\nDegraded operation and parity writes<\/span><\/td>\n<\/tr>\n
RAID 6<\/span><\/td>\n4<\/span><\/td>\n(N \u2212 2) \u00d7 S<\/span><\/td>\nAny two<\/span><\/td>\nLarger capacity-focused storage pool<\/span><\/td>\nTwo drives’ worth of space for parity<\/span><\/td>\n<\/tr>\n
RAID 10<\/span><\/td>\n4<\/span><\/td>\n(N \u00f7 2) \u00d7 S<\/span><\/td>\nOne per mirror pair; some combinations of additional failures<\/span><\/td>\nBusy database or VM storage<\/span><\/td>\nHalf the raw space is used for mirrors<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

For two drive bays, RAID 1 is the straightforward redundant layout. With four bays, the choice often comes down to RAID 5, 6, or 10. Their failure rules differ even when two layouts provide the same usable capacity. These conventional minimums and fault limits match <\/span>Dell’s PowerEdge RAID specifications<\/span><\/a>.<\/span><\/p>\n

RAID 10 in this guide means mirrored pairs striped together. <\/span>Linux MD also supports other RAID 10 layouts<\/span><\/a>, including configurations that do not follow the usual four-drive pair model. Check the exact layout before applying the RAID 10 capacity or failure examples to an existing array.<\/span><\/p>\n

What striping, mirroring, and parity change<\/span><\/h2>\n

Striping<\/b> divides data across drives so more than one drive can take part in an operation. RAID 0 uses striping alone. It makes the combined space available, but it keeps no information that can replace a missing member.<\/span><\/p>\n

Mirroring<\/b> writes the same data to more than one drive. In a two-drive RAID 1 array, either member can supply the data after the other fails. The price is usable space: two 2 TB drives provide roughly 2 TB before overhead, not 4 TB.<\/span><\/p>\n

Parity<\/b> stores information used to reconstruct data from a missing drive. RAID 5 spreads single parity across its drives; RAID 6 spreads double parity. The parity is part of the live array. It is not an older copy you can return to after someone deletes a file. RAID 10 combines mirroring with striping and does not use parity.<\/span><\/p>\n

These layouts define what happens to the <\/span>array<\/span><\/i> after particular disk failures. They do not, by themselves, guarantee that the application stays online, that the operating system boots after a restart, or that a damaged file can be recovered.<\/span><\/p>\n

RAID 0: only for data you can recreate<\/span><\/h2>\n

RAID 0 offers the combined capacity of its drives and no disk fault tolerance. With two equal 2 TB drives, the array has roughly 4 TB available before overhead. If either drive fails, the array can no longer provide the complete striped data.<\/span><\/p>\n

It can suit a render scratch volume, temporary analytics workspace, or cache whose contents can be regenerated from another system. Write down how to recreate the data and how long that would take before choosing it. A game world, customer upload directory, database, or only copy of a backup is a different kind of storage: losing that volume has a lasting cost.<\/span><\/p>\n

Striping can improve throughput when the drives and workload permit it. It does not guarantee a fixed twofold speed increase. Interface bandwidth, queue depth, request size, application behavior, and the rest of the server can limit the result.<\/span><\/p>\n

RAID 1: a simple two-drive mirror<\/span><\/h2>\n

RAID 1 keeps a copy of the same logical data on both members of a two-drive mirror. One member can fail while the surviving member continues to serve the array. That makes it a practical starting point for a dedicated server with two bays or a separate pair of operating-system drives.<\/span><\/p>\n

The capacity calculation is simple. Two 2 TB drives provide roughly 2 TB of array space before overhead. A replacement disk must then be added and the mirror rebuilt. Until the new copy is complete, there is only one healthy copy in that two-drive array.<\/span><\/p>\n

If the operating system lives on the mirror, test booting with either member unavailable. A mirrored data partition does not automatically mean both drives have a working EFI System Partition, bootloader, or firmware boot path. Dedicated-server <\/span>UEFI software RAID recovery procedures<\/span><\/a> show why the boot partitions need separate attention.<\/span><\/p>\n

RAID 1 copies good writes and bad writes alike. An accidental deletion or damaged database record can appear on both drives, so the mirror remains a poor substitute for a versioned backup.<\/span><\/p>\n

RAID 5: more capacity, one-drive failure tolerance<\/span><\/h2>\n

RAID 5 stripes data and distributed parity across at least three drives. It uses the equivalent of one drive for redundancy. Four equal 2 TB drives therefore provide roughly 6 TB before overhead. The array can continue after any one member fails, then reconstruct the missing data onto a replacement.<\/span><\/p>\n

That capacity may appeal to a read-heavy file store. The decision gets harder if the server performs frequent small random writes. Updating data and its parity can add work, and a degraded array must reconstruct missing data as it handles requests. The actual effect depends on the drives, controller or software implementation, cache policy, and workload.<\/span><\/p>\n

Once one member is gone, RAID 5 has used its whole-drive failure margin. A second full drive failure before recovery is complete exceeds that protection. A read error on a surviving member can also complicate reconstruction of affected data. Neither fact justifies a universal claim that every large RAID 5 array will fail during a rebuild. It does justify monitoring, a tested backup, and a realistic disk-replacement process.<\/span><\/p>\n

Assess RAID 5 when the extra usable space matters, the workload has been measured, and the team accepts its failure limit. For a write-heavy primary database or an array where a second-drive failure margin is required, compare RAID 10 and RAID 6 before ordering.<\/span><\/p>\n

RAID 6: two-drive failure tolerance for capacity storage<\/span><\/h2>\n

RAID 6 uses double distributed parity. At least four drives take part, and the array can tolerate any two failed members. Four equal 2 TB drives provide roughly 4 TB before overhead. With six of those drives, the idealized array capacity rises to roughly 8 TB.<\/span><\/p>\n

The second failure margin matters during replacement and rebuild. If a drive fails, another drive can fail before the array loses its whole-drive fault tolerance. RAID 6 still needs prompt action: two failed members leave no further whole-drive margin. It also uses more space for parity than RAID 5 and may have more write work, especially for small updates.<\/span><\/p>\n

A larger file or media store is a common reason to assess RAID 6. It is not automatically the right layout for every four-drive server. Four-drive RAID 6 and conventional RAID 10 offer the same idealized capacity, yet they handle write patterns and pairs of drive failures differently. Choose against the actual application and recovery plan.<\/span><\/p>\n

RAID 10: striped mirrors for busy storage<\/span><\/h2>\n

Conventional RAID 10 makes mirror pairs, then stripes data across those pairs. Four equal 2 TB drives provide roughly 4 TB before overhead. It has no parity calculation, which makes it a useful candidate for databases and VM hosts with frequent random writes. Confirm the choice with application latency and throughput tests on the intended drives. RAID level alone cannot predict performance.<\/span><\/p>\n

The position of a failed drive matters. For a four-drive array with mirror pairs <\/span>A\/B<\/b> und <\/span>C\/D<\/b>:<\/span><\/p>\n\n\n\n\n\n\n\n
Failed drives<\/b><\/th>\nWhat remains<\/b><\/th>\n<\/tr>\n<\/thead>\n
A<\/span><\/td>\nB still holds the first mirror’s data; C\/D remain intact<\/span><\/td>\n<\/tr>\n
A and C<\/span><\/td>\nB and D each keep their mirror’s data; the array can remain accessible<\/span><\/td>\n<\/tr>\n
A and B<\/span><\/td>\nThe first mirror pair is gone; the array cannot reconstruct its data<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

RAID 10 therefore survives any one member failure, and it can survive some two-drive failures. It does <\/span>not<\/b> survive every possible two-drive combination. Dell describes its rule as one failed drive per mirrored set. Linux MD’s alternative RAID 10 layouts require their own placement check. <\/span>Dell’s RAID level guide<\/span><\/a> and the <\/span>Linux MD manual<\/span><\/a> document those distinctions.<\/span><\/p>\n

When one member of a pair fails, a rebuild restores its copy from the surviving data. The time and effect on live traffic depend on drive capacity and health, application load, and rebuild settings. Do not select RAID 10 on the assumption that every mirror rebuild will finish within a particular number of hours.<\/span><\/p>\n

How much usable space do four 2 TB drives provide?<\/span><\/h2>\n

The advertised drive total is <\/span>8 TB of raw capacity<\/b>. The RAID level determines how much of that total can hold application data:<\/span><\/p>\n

 <\/p>\n\n\n\n\n\n\n\n\n
Four-drive layout<\/b><\/th>\nIdealized usable capacity<\/b><\/th>\nWhole-drive failure rule<\/b><\/th>\n<\/tr>\n<\/thead>\n
RAID 0<\/span><\/td>\n8 TB<\/span><\/td>\nKeiner<\/span><\/td>\n<\/tr>\n
RAID 5<\/span><\/td>\n6 TB<\/span><\/td>\nAny one drive<\/span><\/td>\n<\/tr>\n
RAID 6<\/span><\/td>\n4 TB<\/span><\/td>\nAny two drives<\/span><\/td>\n<\/tr>\n
Conventional RAID 10<\/span><\/td>\n4 TB<\/span><\/td>\nOne per mirror pair; position matters for two failures<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

For a <\/span>separate two-drive RAID 1<\/b>, two 2 TB drives provide about <\/span>2 TB<\/b>, before overhead. That example uses two drives, not four.<\/span><\/p>\n

These are planning figures in decimal TB. An operating system that reports binary TiB will show a lower number, and partitions, array metadata, filesystems, reserved space, and any hot spare reduce available application capacity further. If you want a dedicated RAID 1 boot pair plus a four-drive data array, count <\/span>six physical drives<\/b> and verify that the chassis has six supported bays.<\/span><\/p>\n

What happens after a drive fails?<\/span><\/h2>\n

A level’s fault limit describes whether its data can still be reconstructed from the remaining members. It is not a service uptime agreement. An application can still stop because of a boot problem, a controller fault, a damaged filesystem, or the time needed to replace hardware.<\/span><\/p>\n\n\n\n\n\n\n\n\n\n
Level<\/b><\/th>\nAfter the first drive fails<\/b><\/th>\nNext step<\/b><\/th>\nExposure until recovery<\/b><\/th>\n<\/tr>\n<\/thead>\n
RAID 0<\/span><\/td>\nThe array loses required data<\/span><\/td>\nRestore or recreate the volume<\/span><\/td>\nThere is no array rebuild from parity or a mirror<\/span><\/td>\n<\/tr>\n
Two-drive RAID 1<\/span><\/td>\nThe surviving member can keep the array available<\/span><\/td>\nReplace and rebuild the mirror<\/span><\/td>\nLoss of its remaining member exceeds tolerance<\/span><\/td>\n<\/tr>\n
RAID 5<\/span><\/td>\nRemaining drives reconstruct missing data<\/span><\/td>\nReplace the member and complete rebuild<\/span><\/td>\nAnother full drive failure exceeds tolerance<\/span><\/td>\n<\/tr>\n
RAID 6<\/span><\/td>\nThe array can still reconstruct data<\/span><\/td>\nReplace and complete rebuild<\/span><\/td>\nOne further full drive failure is tolerated after the first; two failed drives use all the margin<\/span><\/td>\n<\/tr>\n
Conventional RAID 10<\/span><\/td>\nThe surviving member of that mirror supplies its data<\/span><\/td>\nRestore the failed mirror member<\/span><\/td>\nFailure of the surviving member in the same pair loses that pair<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Watch degraded operation and rebuilds<\/span><\/h3>\n

The first job is to notice the failure. A controller warning or <\/span>mdadm<\/span> status visible only to someone who never checks it does little good. Confirm that an alert reaches the team responsible for action. Record the failed member’s serial number and bay before removing a drive, then monitor the rebuild until the array returns to its intended healthy state.<\/span><\/p>\n

A hot spare can allow a supported array to start rebuilding without waiting for a technician to insert a replacement. It does not turn RAID 5 into two-failure protection or replace a backup. The failed physical drive still needs attention. Periodic drive-health and array-consistency checks help find problems before an urgent rebuild, but their behavior and schedule depend on the implementation. Red Hat’s <\/span>RAID management documentation<\/span><\/a> covers monitoring and recovery in Linux.<\/span><\/p>\n

There is no honest universal rebuild duration. Disk size and type, existing read errors, rebuild priority, and live traffic all matter. If recovery time is a purchase requirement, ask the provider for a documented test using the proposed hardware and workload.<\/span><\/p>\n

Keep an independent, restorable backup<\/span><\/h3>\n

RAID handles specified drive failures. It does not supply a clean earlier version of a deleted file, undo a bad deployment, or preserve data if the entire server is lost. Keep versioned backups outside the array and test a restore to a different destination. Set retention and restore time around the application, not the RAID level. Dell explicitly warns that <\/span>RAID does not replace a backup<\/span><\/a>.<\/span><\/p>\n

For the wider storage design, including drive media and backup planning, see our <\/span>dedicated server storage architecture guide<\/span><\/a>.<\/span><\/p>\n

Choose by workload, drive count, and recovery needs<\/span><\/h2>\n

Use the table as a starting shortlist. Then test the shortlist against your own capacity and recovery requirements.<\/span><\/p>\n

 <\/p>\n\n\n\n\n\n\n\n\n\n
Server need<\/b><\/th>\nLevel to assess first<\/b><\/th>\nCheck before deciding<\/b><\/th>\n<\/tr>\n<\/thead>\n
Two bays for a production OS and data<\/span><\/td>\nRAID 1<\/span><\/td>\nEnough usable space, boot from either member, off-server restore<\/span><\/td>\n<\/tr>\n
Four or more drives for a busy database or VM host<\/span><\/td>\nRAID 10<\/span><\/td>\nRandom-write latency, required capacity, mirror layout<\/span><\/td>\n<\/tr>\n
Four or more drives for mostly read-heavy files<\/span><\/td>\nRAID 5 or 6<\/span><\/td>\nRequired failure margin, rebuild impact, backup restore time<\/span><\/td>\n<\/tr>\n
Larger media or archive pool<\/span><\/td>\nRAID 6<\/span><\/td>\nCapacity after two parity equivalents, write behavior, replacement process<\/span><\/td>\n<\/tr>\n
Temporary data that can be regenerated<\/span><\/td>\nRAID 0<\/span><\/td>\nRecovery time and the independent source of the data<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Start with the application, not the RAID number. Work out the minimum usable capacity and expected growth. Count the actual drive bays, then separate sequential transfer needs from small random reads and writes. Check how much latency the application can tolerate while a member is missing and during rebuild. Finally, confirm that a backup can be restored within the time the business needs.<\/span><\/p>\n

Drive type matters as well. An HDD array, a SATA or SAS SSD array, and an NVMe SSD array can respond differently to the same request pattern. A hardware RAID controller and Linux software RAID can also implement the <\/span>same level<\/span><\/i> through different data paths. Treat <\/span>which RAID level<\/b> und <\/span>which RAID implementation<\/b> as two decisions; check what the chosen server and operating system support rather than assuming one implementation always wins.<\/span><\/p>\n

Six questions to ask before ordering a dedicated server<\/span><\/h2>\n
    \n
  1. Which drives and bays are in the quote?<\/b> Get the physical count, model, capacity, interface, and number of supported spare bays. A quoted raw total is not the usable RAID capacity.<\/span><\/li>\n
  2. Which layouts can this server actually run?<\/b> Ask whether the array uses a RAID controller or operating-system software, which levels are supported, how it boots, and whether a hot spare is available.<\/span><\/li>\n
  3. Who receives degradation and drive-health alerts?<\/b> Confirm whether the provider, your team, or both monitor the array, and how an alert becomes a replacement request.<\/span><\/li>\n
  4. Who owns the rebuild?<\/b> Establish who identifies the bay, replaces the disk, starts or monitors recovery, and handles a failed controller or an operating-system boot issue.<\/span><\/li>\n
  5. Has one-drive boot been tested?<\/b> For an operating-system mirror, ask whether the server can reboot with either member missing. An intact data mirror alone does not answer that question.<\/span><\/li>\n
  6. Where are the backups, and who tests restores?<\/b> Get the retention, location, access, and expected restore time in writing.<\/span><\/li>\n<\/ol>\n

    Atal Networks offers <\/span>bare metal server options<\/span><\/a> Und ein <\/span>custom server request<\/span><\/a> path. If you need help sizing a storage layout, send the workload, required usable TB, drive count, read\/write pattern, and recovery target. Confirm the available RAID and support details for the specific quoted server before placing an order.<\/span><\/p>\n

    Frequently asked questions<\/span><\/h2>\n

    Which RAID level is best for a dedicated server?<\/span><\/h3>\n

    There is no single best level. RAID 1 is a practical starting point for a two-drive production server. RAID 10 merits a test for write-heavy storage, and RAID 6 suits capacity pools needing two-drive fault tolerance. RAID 5 can fit a read-heavy array when one-drive tolerance and the recovery plan are acceptable. RAID 0 belongs on data that can be recreated.<\/span><\/p>\n

    Is RAID 5 or RAID 10 better for a database?<\/span><\/h3>\n

    Assess RAID 10 first for a database with frequent small writes or strict latency needs, then measure it on the intended hardware. RAID 5 uses less space for redundancy across four or more drives but may face more work on small updates and while degraded. The database’s write pattern, durability settings, capacity target, and backup plan decide.<\/span><\/p>\n

    Is RAID 6 safer than RAID 10 if two drives fail?<\/span><\/h3>\n

    For <\/span>any two whole-drive failures<\/span><\/i>, conventional RAID 6 retains array fault tolerance. Conventional RAID 10 survives two failures only if they occur in different mirror pairs. RAID 10 may suit a different performance need, so the two layouts should be compared against both the workload and the failures the operator intends to tolerate.<\/span><\/p>\n

    Can RAID 10 survive two drive failures?<\/span><\/h3>\n

    Yes, in some combinations. A four-drive RAID 10 array with pairs A\/B and C\/D can survive the loss of A and C. It cannot survive the loss of A and B, because both members of one pair would be gone. Check the actual layout before applying this example to Linux MD or another implementation.<\/span><\/p>\n

    How much space is left with four 2 TB drives?<\/span><\/h3>\n

    Before filesystem and other overhead, four equal 2 TB drives provide about 6 TB in RAID 5, 4 TB in RAID 6, and 4 TB in conventional RAID 10. RAID 0 provides about 8 TB but no disk fault tolerance. These figures use decimal TB; a system reporting TiB displays smaller numeric values.<\/span><\/p>\n

    Does RAID protect against ransomware or accidental deletion?<\/span><\/h3>\n

    No. RAID keeps an array accessible after the drive failures its level can tolerate. It also writes deletions or damaged data across the live layout. Use separate, versioned backups with access controls suited to the threat and run a restore test. A second live RAID member is not a historical copy.<\/span><\/p>\n

    Does a hot spare replace a backup?<\/span><\/h3>\n

    No. A hot spare is an unused drive that a supported, configured array can bring into a rebuild after a member fails. It helps reduce the wait for replacement capacity. It cannot restore a deleted file, repair a bad application write, or recover the whole server after a site incident.<\/span><\/p>\n

    Is hardware RAID faster than software RAID?<\/span><\/h3>\n

    Neither is faster in every server. Controller capabilities, cache settings, CPU, drive interface, RAID level, and workload affect the result. Compare the same drive set and request pattern, including latency while degraded and rebuilding. The level determines the data layout; the hardware or software choice determines how that layout is managed.<\/span><\/p>\n

    Can a server boot after one RAID 1 disk fails?<\/span><\/h3>\n

    It can if the remaining drive and the server’s boot configuration support it. A mirrored operating-system volume alone is not proof. EFI partitions, bootloader files, firmware entries, and provider boot settings can affect recovery. Test a controlled reboot with each mirror member unavailable before relying on that path.<\/span><\/p>\n

    Choose the layout that meets the whole storage requirement: usable capacity, live workload, known drive-failure behavior, and a recovery process your team can carry out. RAID 1, 6, and 10 each solve different problems; RAID 5 and 0 also have valid, narrower uses. Before the server goes live, make sure a drive failure produces an alert, the replacement path is documented, the boot path works, and an independent backup has been restored successfully.<\/span><\/p>","protected":false},"excerpt":{"rendered":"

    The right RAID level depends on your drive count, workload, capacity target, and response to a failed drive. A two-drive […]<\/p>\n","protected":false},"author":2,"featured_media":25033,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"default","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"set","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"categories":[1],"tags":[],"class_list":["post-25031","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-enterprise-grade-server"],"acf":[],"_links":{"self":[{"href":"https:\/\/atalnetworks.com\/de\/wp-json\/wp\/v2\/posts\/25031","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/atalnetworks.com\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/atalnetworks.com\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/atalnetworks.com\/de\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/atalnetworks.com\/de\/wp-json\/wp\/v2\/comments?post=25031"}],"version-history":[{"count":2,"href":"https:\/\/atalnetworks.com\/de\/wp-json\/wp\/v2\/posts\/25031\/revisions"}],"predecessor-version":[{"id":25034,"href":"https:\/\/atalnetworks.com\/de\/wp-json\/wp\/v2\/posts\/25031\/revisions\/25034"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/atalnetworks.com\/de\/wp-json\/wp\/v2\/media\/25033"}],"wp:attachment":[{"href":"https:\/\/atalnetworks.com\/de\/wp-json\/wp\/v2\/media?parent=25031"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/atalnetworks.com\/de\/wp-json\/wp\/v2\/categories?post=25031"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/atalnetworks.com\/de\/wp-json\/wp\/v2\/tags?post=25031"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}