{"id":20356,"date":"2026-08-05T15:05:33","date_gmt":"2026-08-05T13:05:33","guid":{"rendered":"https:\/\/webhosting.de\/xdp-hochperformante-paketverarbeitung-kernel-speed\/"},"modified":"2026-08-05T15:05:33","modified_gmt":"2026-08-05T13:05:33","slug":"xdp-high-performance-packet-processing-kernel-speed","status":"publish","type":"post","link":"https:\/\/webhosting.de\/en\/xdp-hochperformante-paketverarbeitung-kernel-speed\/","title":{"rendered":"XDP and eXpress Data Path: High-Performance Packet Processing"},"content":{"rendered":"<p><strong>XDP<\/strong> It accelerates packet processing by making decisions directly at the entrance to the Linux network stack, thereby reducing latency, memory accesses, and CPU cycles. The eXpress Data Path inspects packets right within the driver path, discarding, redirecting, or allowing them to pass\u2014ideal for DDoS defense, load balancing, traffic filtering, and telemetry.<\/p>\n\n<h2>Key points<\/h2>\n\n<ul>\n  <li><strong>Early<\/strong> Decisions Made Directly at the NIC Input<\/li>\n  <li><strong>eBPF<\/strong> as a secure, verified execution mechanism<\/li>\n  <li><strong>Latency<\/strong> and drastically reduce overhead<\/li>\n  <li><strong>Scaling<\/strong> for millions of packets per second<\/li>\n  <li><strong>Integration<\/strong> with Linux drivers, routing, and monitoring<\/li>\n<\/ul>\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\/netzwerkserverraum-datenfluss-4725.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>What XDP Does in the Kernel<\/h2>\n\n<p>I place logic at the <strong>NIC<\/strong>, before packets burden the entire stack, thereby reducing the need for copies, interrupts, and context switches. XDP programs decide early on whether to DROP, PASS, REDIRECT, or TX, thereby reducing the load on higher layers. This increases the <strong>Efficiency<\/strong> This is particularly evident with small packets, which would otherwise dominate the CPU. I minimize cache misses and reduce queues, which has a direct impact on tail latencies. This is precisely where the difference lies compared to traditional paths, which classify packets too late and thus cause unnecessary overhead.<\/p>\n\n<h2>eBPF as the Engine of the Express Data Path<\/h2>\n\n<p>I write concise eBPF code, have it verified by the kernel, and attach it to the <strong>XDP Hook<\/strong> of the driver. This allows me to respond to every incoming packet in nanoseconds and change behavior without rebuilding the kernel. For the analysis, I use <a href=\"https:\/\/webhosting.de\/en\/ebpf-linux-analysis-tools-server-monitoring-insights\/\">eBPF Analysis Tools<\/a>, to make paths, maps, and latencies visible. I vary keys in maps for rate limiting, Conntrack-light, or telemetry, while keeping the code lean. This proximity to the <strong>Hardware<\/strong> significantly reduces latency without sacrificing Linux integration.<\/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\/xdp-konferenz-2897.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>XDP Actions: Reject, Forward, Redirect<\/h2>\n\n<p>I use XDP campaigns strategically to generate traffic early on <strong>steer<\/strong>: DROP for bot scans, PASS for legitimate traffic, REDIRECT to the neighboring interface, and TX for immediate return. This is how I isolate unwanted traffic at the edge and protect hosts from flooding in lower layers. The following mappings help with planning specific policies. I prioritize simple, deterministic checks first and add optional measurement points only where they provide real value. This keeps the <strong>Data path<\/strong> short and predictable.<\/p>\n\n<table>\n  <thead>\n    <tr>\n      <th>Action<\/th>\n      <th>Typical use<\/th>\n      <th>Benefit<\/th>\n      <th>Overhead<\/th>\n    <\/tr>\n  <\/thead>\n  <tbody>\n    <tr>\n      <td>XDP_DROP<\/td>\n      <td>Spoofing, DDoS, Scans<\/td>\n      <td>Early Defense and CPU Offload<\/td>\n      <td>Very low<\/td>\n    <\/tr>\n    <tr>\n      <td>XDP_PASS<\/td>\n      <td>Legitimate Traffic<\/td>\n      <td>Passing to the kernel stack<\/td>\n      <td>Low<\/td>\n    <\/tr>\n    <tr>\n      <td>XDP_REDIRECT<\/td>\n      <td>Load Balancers, Service Chains<\/td>\n      <td>Fast Redirection Without a Stack<\/td>\n      <td>Low<\/td>\n    <\/tr>\n    <tr>\n      <td>XDP_TX<\/td>\n      <td>ICMP\/ARP Responses, Blackhole ACK<\/td>\n      <td>Direct response from the NIC path<\/td>\n      <td>Low<\/td>\n    <\/tr>\n    <tr>\n      <td>AF_XDP (Userspace)<\/td>\n      <td>Zero-Copy User-Space Engines<\/td>\n      <td>High throughput for specialized logic<\/td>\n      <td>Moderate (dependence on pacing)<\/td>\n    <\/tr>\n  <\/tbody>\n<\/table>\n\n<h2>Performance and Latency in Numbers<\/h2>\n\n<p>I achieve high packet rates per <strong>Core<\/strong>, because I drastically shorten the data path and finish the work early. Published papers cite up to 24 million packets per second per core; reports from ACM and the University of Stuttgart describe this order of magnitude. In practice, the value depends on the driver, the XDP mode, and NIC parameters such as queues. I therefore always measure end-to-end latencies and not just synthetic rates. The key factor remains: fewer copies, fewer jumps, and less cache pressure deliver consistent <strong>Latencies<\/strong>.<\/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\/packet-processing-xdp-tech-8035.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Practical Application: DDoS Defense at the NIC Edge<\/h2>\n\n<p>I block attacks with <strong>XDP_DROP<\/strong> Right at the entrance, I already handle kernels, sockets, and applications. Rate limits and Bloom filters in maps keep the code compact and take effect very early on. For legitimate traffic, I maintain whitelists close to the driver, while supplementing them with source checks and TTL validation. For the architecture, it\u2019s worth taking a look at the <a href=\"https:\/\/webhosting.de\/en\/server-packet-processing-pipeline-hosting-network-router\/\">Packet processing pipeline<\/a>, to clearly organize decisions along the path. This way, I prevent expensive Layer 7 rules from wasting valuable <strong>Resources<\/strong> burn.<\/p>\n\n<h2>Load Balancing and Pre-filtering<\/h2>\n\n<p>I use <strong>XDP_REDIRECT<\/strong> For very fast fan-out to backend queues or neighboring interfaces. ECMP-like hashes on 5-tuples or QUIC-CIDs distribute flows evenly. For telemetry, I write concise header samples to maps and only pull up representative samples. For stateful features, I shift complexity to downstream layers and keep XDP deterministic. This way, I maintain performance, keep the code maintainable, and ensure consistency. <strong>Response times<\/strong>.<\/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\/Techoffice_XDP_Paketverarbeitung_7890.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>XDP modes: native, generic, offload<\/h2>\n\n<p>I choose the <strong>Mode<\/strong> Depending on the hardware: \"native\" (driver-based) delivers the highest performance, \"generic\" works everywhere, and \"offload\" offloads logic to the NIC. \"Native\" is suitable for production systems with good drivers and thoroughly tested paths. Generic is useful in VMs or with older drivers when I need portability. Offload requires NIC support and thoroughly tested programs, but delivers impressive efficiency. I test each option with real-world load patterns and prioritize reproducible <strong>Results<\/strong>.<\/p>\n\n<h2>Programming and Deployment: CO-RE, BTF, and bpftool<\/h2>\n\n<p>When it comes to deployment, I rely on <strong>CO-RE<\/strong> (Compile Once \u2013 Run Everywhere) and BTF, so that my eBPF object remains stable across kernel versions. With libbpf, I keep structures lean, resolve offsets at runtime, and thereby reduce build matrices. I pin programs and <strong>Maps<\/strong> in bpffs, so that lifecycles can be managed independently of processes and upgrades occur atomically. For operations, I use bpftool to load, pin, replace, and inspect maps; I document map sizes, types, and key layouts to ensure reproducible deployments. I define policies that <strong>Capabilities<\/strong> that are required for loading programs, automate attachment points (via systemd or init scripts), and plan for rollbacks: If an upgrade fails, the link falls back to a stable version or, if in doubt, to <strong>XDP_PASS<\/strong>. This ensures that changes are managed effectively and the risk remains low.<\/p>\n\n<h2>Interaction with tc\/eBPF and User Space<\/h2>\n\n<p>I combine XDP with tc\/eBPF when outbound shaping, DSCP marking, or complex decisions are required. For special cases, I use <strong>AF_XDP<\/strong> in zero-copy mode and move logic to user-space engines. In doing so, I encapsulate parsing and the fast path in XDP and offload expensive operations to workers. This way, I keep the hot loop to a minimum while remaining flexible. This architecture clearly separates responsibilities and protects critical <strong>hot paths<\/strong> from outliers.<\/p>\n\n<h2>Parser Design and Metadata in the XDP Program<\/h2>\n\n<p>I'm building the parser defensively: I'm working exclusively with <strong>xdp_md<\/strong> (data\/data_end), strictly check lengths, and avoid out-of-bounds accesses. I handle VLAN tags explicitly; if necessary, I adjust the packet header using `bpf_xdp_adjust_head` and keep offsets consistent. I distinguish between IPv4 and IPv6 early on, check for fragmentation, perform simple sanity checks (e.g., minimum header length, valid protocol values), and do not rely on corrections later on. Optionally, I record a brief <strong>Flow-Key<\/strong> in the metadata pipeline (per CPU) and pass it on to downstream layers. This keeps the parsing <strong>deterministic<\/strong>, cache-friendly, and resilient against faulty or intentionally manipulated packets.<\/p>\n\n<h2>Tail Calls, Maps, and Per-CPU Design<\/h2>\n\n<p>I structure logic using <strong>Tail Calls<\/strong>, to keep common paths short and offload rare cases. For counters, I use per-CPU array maps to avoid atomic operations and aggregate only during export. For caches, I use LRU hash maps, size them conservatively, and measure collision rates to prevent evictions from getting out of hand. I store configurations (e.g., prefix lists, port groups) in array or hash maps, reload them at runtime, and decouple code from data. I collect telemetry using ring buffers or sampling counters, never in the <strong>Hot-Loop<\/strong> with costly operations. I pay attention to alignment and cache lines to avoid false sharing, and I group fields so that hot data is stored compactly together. This measurably reduces latency without sacrificing readability.<\/p>\n\n<h2>AF_XDP in Depth: Zero-Copy Userland<\/h2>\n\n<p>I run AF_XDP with properly sized <strong>UMEM<\/strong>, I tightly bind queues to CPUs and use fill\/completion rings efficiently. Zero-copy only delivers maximum performance if the driver and NIC support the mode; otherwise, I fall back to copy mode in a controlled manner. I bundle RX\/TX operations into <strong>batches<\/strong>, I confirm TX completions promptly and adjust the pacing to avoid buffer overflows. I use busy polling only when latency is more important than CPU idle time, and I measure its effect on jitter. In multiqueue setups, I specifically bind sockets to <strong>Queue IDs<\/strong> and isolate cores (IRQ affinity, pinning) to prevent deadlocks. This is how I scale user-space engines in a controlled manner and keep the paths short.<\/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\/xdp_datenverarbeitung_1234.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Virtualization and Container Orchestration<\/h2>\n\n<p>I distinguish between bare-metal, VMs, and containers: In the <strong>generic<\/strong>In -mode, I test functionality in VMs and migrate to native mode for better performance. In Kubernetes, I place XDP on the host interface, regulate the inflow per node, and apply pod-specific rules later via tc\/eBPF. In <strong>SR-IOV<\/strong> Or with vDPA, I move hot paths even closer to the hardware and check whether offloads leave the semantics unchanged. I handle veth paths deliberately: pre-filtering (XDP) on the host, fine-grained policies in namespaces. This ensures that the interaction between CNI, the service mesh, and host security remains consistent and <strong>predictable<\/strong>.<\/p>\n\n<h2>Troubleshooting, Testing, and Reproducibility<\/h2>\n\n<p>I incorporate diagnostics early in the design: per-CPU drop counters based on <strong>Reason Codes<\/strong>, limited trace points for rare error cases, and clear build IDs for programs. I only use `bpf_printk` in the lab so as not to interfere with hot paths; in production, I rely on counters, samples, and stored metadata. Regression tests feed synthetic patterns (SYN flood, UDP bursts, mixed traffic), compare latency quantiles, and measure <strong>End-to-end<\/strong>. I freeze test profiles (packet sizes, distribution, duration), document kernel, driver, and firmware versions, and thereby prevent measurement drift. If deviations occur, I perform targeted rollbacks or isolate changes (only map contents, only parser, only tail-call chain) until the cause is clear.<\/p>\n\n<h2>Operations: Rollout, Versioning, and Fallback Strategies<\/h2>\n\n<p>I update programs via <strong>atomic<\/strong> Update links, keep Blue\/Green versions ready, and link rollouts to guardrails: If drop rates rise unexpectedly, I automatically revert to the previous version. I separate configurations (maps) from code deployments so that hotfixes are possible without a rebuild. I define <strong>Safe Defaults<\/strong> (When in doubt, use PASS instead of DROP), time out experimental paths, and monitor memory limits for maps. When upgrading the kernel, I check for CO-RE compatibility and BTF availability, and maintain a fallback in generic mode. This discipline prevents outages and ensures predictable changes to the network path.<\/p>\n\n<h2>Security and Compliance<\/h2>\n\n<p>As a rule, I work <strong>minimally invasive<\/strong>: Only the necessary capabilities, restrictive sysctl settings for unprivileged BPF, and a clear separation of responsibilities. My programs rely on the verifier, avoid infinite loops, and keep execution times strictly limited. I log decisions in a way that allows auditors to trace causes without permanently logging sensitive data. In multi-tenant scenarios, I use namespaces and resource budgets for maps and prevent any single tenant from exhausting capacity. This is how I combine performance with secure, <strong>more verifiable<\/strong> Implementation.<\/p>\n\n<h2>Drivers, Hardware, and Tuning<\/h2>\n\n<p>I check driver versions, NIC firmware, and queue mappings before evaluating performance. I use RSS, RPS, and pinning to distribute traffic to <strong>cores<\/strong> and minimize cross-core jumps. I tune the number of queues, MTU, and offloads to match actual packet sizes. For interrupt pacing, I set the value depending on the load <a href=\"https:\/\/webhosting.de\/en\/interrupt-coalescing-network-optimization-serverflux\/\">Interrupt coalescing<\/a> wisely to reduce jitter without causing latency spikes. These steps deliver measurable <strong>Profits<\/strong>, even before I continue optimizing the code.<\/p>\n\n<h2>Monitoring, Security, and Observability<\/h2>\n\n<p>I read counters from Maps, export sample data, and correlate it with system metrics such as CPU idle and LLC miss rate. I supplement security checks with <strong>Sanity<\/strong>-Checks on header fields, minimal state, and deliberate rate limits. For audits, I ensure that decision paths are traceable and document program versions. I also verify that verifier limits are adhered to and keep loops strictly controlled. This is how I maintain performance and <strong>Security<\/strong> in balance, without sacrificing fast-path quality.<\/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\/xdpath-serverraum-4721.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Classification and Limits in Operation<\/h2>\n\n<p>I use XDP mainly on the <strong>Ingress<\/strong>- I implement the hot path and supplement it with tc\/eBPF or other mechanisms for return paths. I use stateful functions sparingly and only to the extent that makes sense in the hot path. For protocols that require subsequent stack functions, I simply pass them on and delegate the depth to higher layers. When it comes to hardware offload, I ensure functional equivalence, thorough testing, and clear error messages. This way, I leverage strengths in a targeted manner without compromising in the wrong places. <strong>Comfort<\/strong> to lose.<\/p>\n\n<h2>Briefly summarized<\/h2>\n\n<p>I delegate decisions about packages as early as possible to the <strong>NIC<\/strong> and thereby drastically reduce latency, overhead, and CPU load. eBPF makes XDP programmable, secure, and updatable without leaving the kernel. In high-load scenarios such as DDoS defense, load balancing, and telemetry, this approach delivers consistent benefits. With a smart combination of maps, actions, and tuning, I achieve high throughput with stable response times. Anyone who wants to operate Linux networks cost-effectively today stands to gain significantly from XDP. <strong>Advantages<\/strong> in the data path.<\/p>","protected":false},"excerpt":{"rendered":"<p>XDP improves networking performance through early packet processing in the Linux kernel. Ideal for DDoS protection, load balancing, and low latency.<\/p>","protected":false},"author":1,"featured_media":20349,"comment_status":"","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[922],"tags":[],"class_list":["post-20356","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-technologie"],"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":"118","_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":"XDP","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":"20349","footnotes":null,"_links":{"self":[{"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/posts\/20356","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=20356"}],"version-history":[{"count":0,"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/posts\/20356\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/media\/20349"}],"wp:attachment":[{"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/media?parent=20356"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/categories?post=20356"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/tags?post=20356"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}