{"id":20124,"date":"2026-07-29T11:49:51","date_gmt":"2026-07-29T09:49:51","guid":{"rendered":"https:\/\/webhosting.de\/redis-security-offene-ports-absichern-cache-server-fortgeschritten\/"},"modified":"2026-07-29T11:49:51","modified_gmt":"2026-07-29T09:49:51","slug":"redis-security-securing-open-ports-cache-server-advanced","status":"publish","type":"post","link":"https:\/\/webhosting.de\/en\/redis-security-offene-ports-absichern-cache-server-fortgeschritten\/","title":{"rendered":"Redis Security: Avoid Open Ports and Unprotected Instances"},"content":{"rendered":"<p>Open ports and unprotected instances are the most common entry points when it comes to <strong>Redis Security<\/strong> Here's how it works. I'll clearly demonstrate how to close ports, secure instances, and drastically reduce the risk with just a few changes to redis.conf.<\/p>\n\n<h2>Key points<\/h2>\n\n<p>To help you get started quickly, I\u2019ll summarize the most important aspects concisely and prioritize what should be done first. I\u2019ll address common misconfigurations that lead to open ports and provide practical settings for a secure production environment. I\u2019ll also focus on authentication, encryption, and strict network boundaries to ensure that attacks come to nothing. The following bullet points serve as your quick-start guide before I dive deeper into details and examples.<\/p>\n<ul>\n  <li><strong>Network<\/strong> Isolate: Never expose Redis publicly; allow access only from private networks.<\/li>\n  <li><strong>Configuration<\/strong> Harden: Set `bind`, `protected-mode`, and `Ports` correctly, and ensure `Rename-Commands` are set properly.<\/li>\n  <li><strong>Auth<\/strong> Enforce: requirepass plus ACLs for fine-grained access control.<\/li>\n  <li><strong>Encryption<\/strong> Enable: TLS for transport, OS encryption for persistence.<\/li>\n  <li><strong>Monitoring<\/strong> &amp; Updates: Logs, alerts, backups, and regular version updates.<\/li>\n<\/ul>\n<p>My first priority is to close any open <strong>Ports<\/strong>, then authentication, and finally encryption. After that, I\u2019ll handle logging, backups, and updates to ensure that security measures remain effective over the long term. This keeps the attack surface small and ensures the instance remains under your control.<\/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\/07\/sicherheit-serverraum-3241.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Open Ports: Risks and Common Attack Vectors<\/h2>\n\n<p>An open standard port 6379 acts like a sign that says \u201ePlease check here.\u201c Attackers automatically scan the Internet and test unprotected <strong>Instances<\/strong> in seconds. Without authentication, they can read data, set keys, or load modules. In practice, this often results in data leaks or the initiation of cryptomining. I eliminate this risk by strictly limiting accessibility and allowing only defined source addresses.<\/p>\n\n<h2>Properly Configure Network Isolation and Bindings<\/h2>\n\n<p>I'm connecting to Redis <strong>localhost<\/strong> or to a private IP address on the internal subnet. This network architecture prevents the service from being directly exposed to the public Internet. In distributed setups, I place the nodes in a private VLAN or VPC and provide access only via VPN or internal peering connections. This ensures that every packet remains within controlled segments. This simple separation significantly reduces the risk.<\/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\/07\/redis_security_meeting_9786.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Configuration in redis.conf: bind, port, protected-mode<\/h2>\n\n<p>I start at the <strong>redis.conf<\/strong>, because just a few lines often make all the difference. I restrict the interfaces using `bind 127.0.0.1` or `bind 127.0.0.1 10.0.x.y`. I change the default port to make trivial scans more difficult, and I keep `protected-mode yes` enabled. Additionally, I rename or disable dangerous commands. The following table helps me with common misconfigurations.<\/p>\n\n<table>\n  <thead>\n    <tr>\n      <th><strong>Setting<\/strong><\/th>\n      <th><strong>Risks Associated with Incorrect Configuration<\/strong><\/th>\n      <th><strong>Recommended action<\/strong><\/th>\n      <th><strong>Example<\/strong><\/th>\n    <\/tr>\n  <\/thead>\n  <tbody>\n    <tr>\n      <td>bind<\/td>\n      <td>Public <strong>Accessibility<\/strong> for each host<\/td>\n      <td>Bind only to localhost\/private IP<\/td>\n      <td>bind 127.0.0.1 10.0.1.50<\/td>\n    <\/tr>\n    <tr>\n      <td>port<\/td>\n      <td>Easy scanning to <strong>6379<\/strong><\/td>\n      <td>Set an alternative port<\/td>\n      <td>port 6389<\/td>\n    <\/tr>\n    <tr>\n      <td>protected mode<\/td>\n      <td>Unlimited access with an open <strong>IP<\/strong><\/td>\n      <td>Leave active<\/td>\n      <td>protected-mode yes<\/td>\n    <\/tr>\n    <tr>\n      <td>rename-command<\/td>\n      <td>More serious abuse <strong>Commands<\/strong><\/td>\n      <td>Rename or shut down<\/td>\n      <td>rename-command CONFIG \u201e\u201c<\/td>\n    <\/tr>\n    <tr>\n      <td>tls-port\/port<\/td>\n      <td>Plain text-<strong>Traffic<\/strong> accessible<\/td>\n      <td>Use only the TLS port<\/td>\n      <td>tls-port 6379 \/ port 0<\/td>\n    <\/tr>\n  <\/tbody>\n<\/table>\n\n<p>For more in-depth information on misconfigurations, please refer to this overview of <a href=\"https:\/\/webhosting.de\/en\/security-misconfiguration-hosting-avoid-errors-configuration\/\">Avoiding Configuration Errors<\/a>. I also add comments to the file to make it easier to follow, so that future audits go more quickly. A clean configuration saves time and prevents outages. Small security hardening measures have a big impact here. It pays off right away.<\/p>\n\n<h2>Consistently Use Authentication and ACLs<\/h2>\n\n<p>I'm placing a strong <strong>Authentication<\/strong> always, even on internal networks. I use `requirepass` to enforce the AUTH handshake, and I rotate passwords regularly. Since Redis 6, I\u2019ve been relying on Access Control Lists: This allows me to create users, grant only the necessary commands, and restrict key ranges. This clearly separates production, admin, and analytics access. Fewer privileges mean less damage in the event of a security breach.<\/p>\n\n<h2>Defusing Dangerous Commands<\/h2>\n\n<p>Many attacks are launched via powerful <strong>Commands<\/strong> such as CONFIG, MODULE LOAD, or SLAVEOF\/REPLICAOF. I restrict standard users' access via ACLs and disable sensitive commands using `rename-command` by setting them to an empty string. This eliminates entire attack vectors. Where I really need certain functions, I document them and restrict them to admin accounts. This keeps the instance manageable and secure.<\/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\/07\/redis-security-offene-ports-2948.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Enable Transport Encryption with TLS<\/h2>\n\n<p>I'm enabling TLS so that no one can <strong>Traffic<\/strong> can read or tamper with. In the configuration, I set the TLS port, disable the plaintext port using port 0, and configure the certificate, key, and CA. Optionally, I verify client certificates to further authenticate machine access. Modern clients support TLS with little effort. After that, all connections run over a secure channel.<\/p>\n\n<h2>Make it impossible to decrypt data at rest<\/h2>\n\n<p>For persistence files, I rely on <strong>Encryption<\/strong> of the file system. RDB and AOF are then stored securely on the disk, even if someone were to read the storage. I also encrypt sensitive values within the application before passing them to Redis. This way, I don\u2019t need to store plain text in the cache. This reduces the risk in the event of theft or improper backups.<\/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\/07\/RedisSecurityOffice1234.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Network Security and Firewalls in Practice<\/h2>\n\n<p>I enable the host firewall and let the Redis\u2014<strong>Port<\/strong> only for defined IP ranges. In the cloud, I supplement this with security groups that precisely specify protocols, ports, and source networks. I also run regular port scans to find any forgotten open ports. I disable unnecessary services to ensure no \u201cshadow ports\u201d remain open. You can find a practical guide here: <a href=\"https:\/\/webhosting.de\/en\/server-firewall-configurations-hosting-security-boost\/\">Firewall Configurations<\/a>.<\/p>\n\n<h2>Establish Monitoring, Logging, and Updates<\/h2>\n\n<p>I analyze Redis logs centrally and set <strong>Alerts<\/strong> I monitor for failed logins or suspicious commands. I detect anomalies early by keeping an eye on metrics such as connections, commands per second, or latency. I schedule regular backups and test the restore process. I apply security updates promptly because they often close critical vulnerabilities. In addition, I review configurations at regular intervals and document any deviations.<\/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\/07\/RedisSecurityDesks_1234.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Roles, Rights, and Operational Procedures<\/h2>\n\n<p>I start Redis with a <strong>Service User<\/strong> Without root privileges, so that a breach doesn't affect the entire system. I strictly separate roles: Admins, developers, and operators are granted only the privileges they need. Application accounts are placed in their own ACL profiles and can only see their own key prefixes. I document changes in a traceable manner to facilitate audits. This framework maintains order and reduces the risk of operational errors.<\/p>\n\n<h2>Selecting Secure Hosted Environments<\/h2>\n\n<p>For managed services, I check whether firewalling, <strong>Network Isolation<\/strong>, TLS and ACLs are enabled by default. I also make sure to keep the system up to date and monitor it reliably. Anyone who needs more performance and control should consider options such as <a href=\"https:\/\/webhosting.de\/en\/redis-shared-vs-dedicated-performance-security-cacheboost\/\">Shared vs. Dedicated Redis<\/a> Take a look. The right platform reduces effort and fills typical gaps. This keeps the focus on the application and the data.<\/p>\n\n<h2>Operating Replication, Clusters, and Sentinel Securely<\/h2>\n\n<p>I secure replication and cluster communication just as rigorously as client access. This includes authentication, encryption, and proper endpoint registration.<\/p>\n<ul>\n  <li>Replication: I set <strong>replica-read-only yes<\/strong>, so that replicas do not allow write access. For authentication, I configure <strong>masteruser<\/strong> and <strong>masterauth<\/strong> on the replicas, using dedicated ACL users with minimal permissions.<\/li>\n  <li>Stale Data: With <strong>replica-serve-stale-data no<\/strong> This prevents an isolated replica from serving outdated data. This safeguards data integrity and reduces the attack surface in partitions.<\/li>\n  <li>Cluster: I'm activating <strong>tls-cluster yes<\/strong>, so that the Gossip bus runs in encrypted mode. I also set <strong>cluster-announce-ip<\/strong>, <strong>cluster-announce-port<\/strong> and <strong>cluster-announce-bus-port<\/strong> to internal addresses\/ports. This way, I prevent nodes from announcing their public IP addresses.<\/li>\n  <li>Sentinel: Sentinel also runs only on private networks. For monitored masters, I use <strong>sentinel auth-user<\/strong> and <strong>sentinel auth-pass<\/strong>. I do not expose the admin interface to the outside world and only allow access from defined operator IP ranges.<\/li>\n  <li>Availability vs. Security: I'm calibrating <strong>minimum number of replicas to write<\/strong> and <strong>min-replicas-max-lag<\/strong>, so that write operations are carefully throttled in the event of a partial failure. While this is primarily intended to ensure consistency, it also prevents misuse in the event of network errors.<\/li>\n<\/ul>\n\n<h2>DoS and Resource Protection in the Configuration<\/h2>\n\n<p>In addition to authentication and network restrictions, I harden Redis against overload and memory attacks. This ensures the service remains stable, even if clients behave erratically or maliciously.<\/p>\n<ul>\n  <li><strong>maxclients<\/strong>: I limit the number of simultaneous connections to a realistic number with a buffer. This prevents the system from becoming overwhelmed by connection spam.<\/li>\n  <li><strong>client output buffer limit<\/strong>For <em>normal<\/em>, <em>pubsub<\/em> and <em>replica<\/em> I set strict limits. This prevents unchecked storage growth caused by slow users.<\/li>\n  <li><strong>timeout<\/strong> and <strong>TCP keepalive<\/strong>: I automatically disconnect inactive connections so that zombie connections don't tie up resources.<\/li>\n  <li><strong>latency-monitor-threshold<\/strong> and <strong>slowlog<\/strong>: I enable monitoring points to detect patterns of abuse (e.g., KEYS scans) early on. Alerts for unusually long command execution times help with early detection.<\/li>\n  <li><strong>maxmemory<\/strong> and Policy: I'm setting a <em>maxmemory<\/em>-limit and an appropriate eviction policy. This isn't a security feature per se, but it protects the entire environment from OOM conditions and emergency restarts.<\/li>\n<\/ul>\n\n<h2>ACL Design: Practical Patterns and Secure Storage<\/h2>\n\n<p>I keep ACLs simple, reproducible, and versionable. I don't just define the rules at runtime; I also save them in a file and assign restrictive file permissions to it.<\/p>\n<ul>\n  <li><strong>Base<\/strong>: I'm logging out the default user (<em>user default off<\/em>). For applications, I create dedicated users who are granted only the command categories they actually need (<em>+@read<\/em>, <em>+@write<\/em>, <em>-@dangerous<\/em>).<\/li>\n  <li><strong>Scopes<\/strong>: I use prefixes to delimit key areas, for example,. <em>~app:*<\/em>. This prevents an application from accidentally accessing other namespaces.<\/li>\n  <li><strong>Example<\/strong>: <em>user app on &gt;S3cur3P@ss ~app:* +@read +@write -@dangerous -config -module -eval -evalsha<\/em> and a separate admin user with <em>+@all<\/em>, which is accessible only via Bastion hosts.<\/li>\n  <li><strong>Persistence<\/strong>: I use <em>aclfile \/etc\/redis\/users.acl<\/em> and set the file permissions to 600. I save the changes with <em>ACL SAVE<\/em> and document them in the change log.<\/li>\n  <li><strong>Rotation<\/strong>: I rotate passwords regularly and version control ACL changes so that I can quickly roll them back in the event of an incident.<\/li>\n<\/ul>\n\n<h2>Check Scripts and Modules<\/h2>\n\n<p>I'm reducing the attack surface of <strong>Lua scripts<\/strong> and <strong>modules<\/strong> Consistent. Unnecessary features are eliminated, and dangerous commands are off-limits to app users.<\/p>\n<ul>\n  <li><strong>EVAL only when needed<\/strong>: I am revoking non-admin users' access to <em>EVAL<\/em> and <em>EVALSHA<\/em>. Otherwise, scripts run with the privileges of the user who called them and can move large amounts of data.<\/li>\n  <li><strong>Lua Limits<\/strong>With <em>lua-time-limit<\/em> I prevent faulty scripts from blocking the server for a long time. If necessary, I terminate them with <em>SCRIPT KILL<\/em> from.<\/li>\n  <li><strong>Curing Modules<\/strong>: <em>LOAD MODULE<\/em> I disable it by <em>rename-command<\/em> or allow it only for admins. I load modules exclusively at startup from a trusted, read-only path.<\/li>\n  <li><strong>Dangerous Categories<\/strong>: Instead of blocking individual commands, I use <em>-@dangerous<\/em> Entire risk groups (e.g., DEBUG, CONFIG, MODULE, SHUTDOWN). This is clear and robust.<\/li>\n<\/ul>\n\n<h2>Setting Up Secure Container and Kubernetes Operations<\/h2>\n\n<p>The same principles apply in containers and on Kubernetes\u2014supplemented by platform controls. I prevent public exposure, minimize privileges, and regulate data paths.<\/p>\n<ul>\n  <li><strong>Network Policies<\/strong>: I only allow pod-to-pod traffic between shared namespaces\/deployments. Redis services run internally; no NodePort or load balancer faces the Internet.<\/li>\n  <li><strong>Pod Security<\/strong>: Redis is running <em>runAsNonRoot<\/em>, with <em>readOnlyRootFilesystem<\/em> and minimal Linux capabilities. I enable Seccomp\/AppArmor profiles and set resource limits.<\/li>\n  <li><strong>Secrets<\/strong>: Passwords and certificates end up as <em>Secret<\/em>-Volume with restricted permissions\u2014not included in the container image or in the logs. Rotation is automated.<\/li>\n  <li><strong>Volumes<\/strong>: I keep data and configuration strictly separate. Only the data volume is writable; configuration mounts remain read-only.<\/li>\n  <li><strong>Liveness\/Readiness<\/strong>: I authenticate health checks (e.g., via an ACL user with read-only permissions) to ensure that probes do not become backdoors.<\/li>\n<\/ul>\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\/07\/sicherer-serverraum-8392.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Automation, Systemd Sandboxing, and Secure Deployment<\/h2>\n\n<p>I build security into the automation process to ensure that every instance is deployed identically and securely. Any deviations are then immediately noticeable.<\/p>\n<ul>\n  <li><strong>Templates<\/strong>: <em>redis.conf<\/em>, The ACL file and the systemd unit are versioned as code. Before each rollout, I run automated checks on bind, ports, TLS, and ACLs.<\/li>\n  <li><strong>Systemd Hardening<\/strong>: In the unit, I activate <em>NoNewPrivileges=yes<\/em>, <em>PrivateTmp=yes<\/em>, <em>ProtectSystem=strict<\/em>, <em>ProtectHome=yes<\/em> and set <em>UMask=027<\/em>. This effectively restricts file access and runtime permissions.<\/li>\n  <li><strong>CICD Gates<\/strong>: Pipelines fail if a port is exposed to the public, certificates are missing, or risky commands haven't been renamed. That's how I prevent regressions.<\/li>\n  <li><strong>Images &amp; Packages<\/strong>: I scan container images and OS packages for vulnerabilities. I roll out updates in phases, tracking metrics and error budgets along the way.<\/li>\n<\/ul>\n\n<h2>Preparing for Incidents: A Structured Response Plan<\/h2>\n\n<p>I plan for emergencies before they happen. That way, I can respond quickly, minimize damage, and get operations back on track smoothly.<\/p>\n<ul>\n  <li><strong>Contain<\/strong>: I immediately block the network paths (security groups, firewall), stop public exposure, and freeze suspicious instances to preserve evidence.<\/li>\n  <li><strong>Identify<\/strong>With <em>INFO clients<\/em>, <em>ACL LIST<\/em>, <em>ROLE<\/em>, <em>CONFIG GET<\/em> and <em>MODULE LIST<\/em> I check the status, active users, replication, and loaded modules.<\/li>\n  <li><strong>Rotate credentials<\/strong>: I set new passwords\/ACL keys and block suspicious users (<em>ACL SETUSER user off<\/em>) and revoke rights until the matter is resolved.<\/li>\n  <li><strong>Cleanup<\/strong>: I identify unauthorized key spaces using a prefix strategy, remove malicious modules offline, and compare the configuration to the target state.<\/li>\n  <li><strong>Restoration<\/strong>: I restore the system from verified backups, apply updates, and roll out hardened configurations. This is followed by a post-mortem with clear action items.<\/li>\n<\/ul>\n\n<h2>Practical Implementation: Checklist in Words<\/h2>\n\n<p>I'll start by scanning for open <strong>Ports<\/strong> and immediately restrict access if 6379 is publicly visible. Next, I bind Redis to localhost or a private IP address and enforce the host and cloud firewalls. In the next step, I enable `requirepass`, rotate the password, and set up ACLs for users and workloads. I then disable or rename sensitive commands, enable TLS, and disable the plaintext port. Finally, I set up logging, alerts, backups, regular updates, and recurring configuration checks.<\/p>\n\n<h2>Briefly summarized<\/h2>\n\n<p>Redis remains secure if I <strong>Attack surface<\/strong> Keep it small, limit access, and encrypt communication. The combination of network segmentation, strong authentication, and restrictive command privileges effectively stops common attacks. I use TLS to secure data in transit and OS-level encryption to ensure data persistence. Monitoring, backups, and updates ensure smooth day-to-day operations. By consistently implementing these steps, you can avoid open ports, protect sensitive data, and keep your instances reliably under control.<\/p>","protected":false},"excerpt":{"rendered":"<p>This guide to Redis security shows you how to prevent open ports and unprotected instances\u2014using firewalls, Redis authentication, ACLs, TLS, and monitoring.<\/p>","protected":false},"author":1,"featured_media":20117,"comment_status":"","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[794],"tags":[],"class_list":["post-20124","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-sicherheit-computer_und_internet"],"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":"126","_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":"redis security","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":"20117","footnotes":null,"_links":{"self":[{"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/posts\/20124","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=20124"}],"version-history":[{"count":0,"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/posts\/20124\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/media\/20117"}],"wp:attachment":[{"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/media?parent=20124"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/categories?post=20124"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/tags?post=20124"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}