{"id":22164,"date":"2026-11-05T11:30:00","date_gmt":"2026-11-05T10:30:00","guid":{"rendered":"https:\/\/webhosting.de\/?p=22164"},"modified":"2026-11-05T07:23:23","modified_gmt":"2026-11-05T06:23:23","slug":"sizing-redis-maxmemory-correctly","status":"publish","type":"post","link":"https:\/\/webhosting.de\/en\/redis-maxmemory-richtig-dimensionieren\/","title":{"rendered":"Sizing Redis `maxmemory` Correctly: Memory Reserves for Data and Operations"},"content":{"rendered":"<div class=\"wh-article\" data-wh-layout=\"2.1.2\" style=\"width:100%;max-width:820px;margin:0 auto;color:#263b4b;font-family:inherit;font-size:18px;line-height:1.8;text-align:start;overflow-wrap:break-word;box-sizing:border-box\"><p class=\"wh-lead\" style=\"font-size:20px;line-height:1.7;color:#233746;margin:0 0 1.1em\">Set <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">maxmemory<\/code> not equal to the available RAM: This value controls eviction but does not limit the total memory consumption of processes or containers. In addition to data and Redis overhead, be sure to account for buffers, allocator effects, and persistence spikes. A robust starting value is derived from the <strong style=\"font-weight:700;color:inherit\">actual storage limit<\/strong> and consumption trends under representative load. Export the \"Primary\" and \"Replicates\" values separately and verify the budget, even in the event of a potential role change. <\/p>\n<nav class=\"wh-toc\" aria-label=\"Contents of this article\" style=\"display:block;margin:28px 0 38px;padding:22px;border:1px solid #d9e4e8;border-radius:14px;background:#f4f8f8\"><p class=\"wh-toc-title\" style=\"font-size:13px;font-weight:700;letter-spacing:.08em;color:#49656b;margin:0 0 14px\">Go directly to the section<\/p><div class=\"wh-toc-grid\" style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(min(100%,280px),1fr));gap:10px\"><div class=\"wh-toc-item\" style=\"display:block;min-width:0;margin:0;padding:0\"><a class=\"wh-toc-link\" href=\"#maxmemory-grundlagen\" style=\"display:block;height:100%;padding:12px 15px;border:1px solid #dce6e8;border-radius:9px;background:#fff;color:#18575b;font-size:14px;line-height:1.5;font-weight:600;text-decoration:none;box-sizing:border-box\">What Actually Limits `maxmemory`<\/a><\/div>\n<div class=\"wh-toc-item\" style=\"display:block;min-width:0;margin:0;padding:0\"><a class=\"wh-toc-link\" href=\"#rss-und-persistenz\" style=\"display:block;height:100%;padding:12px 15px;border:1px solid #dce6e8;border-radius:9px;background:#fff;color:#18575b;font-size:14px;line-height:1.5;font-weight:600;text-decoration:none;box-sizing:border-box\">RSS, Allocator, and Persistence Peaks<\/a><\/div>\n<div class=\"wh-toc-item\" style=\"display:block;min-width:0;margin:0;padding:0\"><a class=\"wh-toc-link\" href=\"#replikation-speicher\" style=\"display:block;height:100%;padding:12px 15px;border:1px solid #dce6e8;border-radius:9px;background:#fff;color:#18575b;font-size:14px;line-height:1.5;font-weight:600;text-decoration:none;box-sizing:border-box\">Replicas require their own budgets<\/a><\/div>\n<div class=\"wh-toc-item\" style=\"display:block;min-width:0;margin:0;padding:0\"><a class=\"wh-toc-link\" href=\"#metriken-erfassen\" style=\"display:block;height:100%;padding:12px 15px;border:1px solid #dce6e8;border-radius:9px;background:#fff;color:#18575b;font-size:14px;line-height:1.5;font-weight:600;text-decoration:none;box-sizing:border-box\">Track inventory across three levels<\/a><\/div>\n<div class=\"wh-toc-item\" style=\"display:block;min-width:0;margin:0;padding:0\"><a class=\"wh-toc-link\" href=\"#budget-rechnen\" style=\"display:block;height:100%;padding:12px 15px;border:1px solid #dce6e8;border-radius:9px;background:#fff;color:#18575b;font-size:14px;line-height:1.5;font-weight:600;text-decoration:none;box-sizing:border-box\">Calculate a robust memory budget<\/a><\/div>\n<div class=\"wh-toc-item\" style=\"display:block;min-width:0;margin:0;padding:0\"><a class=\"wh-toc-link\" href=\"#eviction-vergleichen\" style=\"display:block;height:100%;padding:12px 15px;border:1px solid #dce6e8;border-radius:9px;background:#fff;color:#18575b;font-size:14px;line-height:1.5;font-weight:600;text-decoration:none;box-sizing:border-box\">A Comparative Analysis of Eviction Policies in Practice<\/a><\/div>\n<div class=\"wh-toc-item\" style=\"display:block;min-width:0;margin:0;padding:0\"><a class=\"wh-toc-link\" href=\"#betrieb-ueberwachen\" style=\"display:block;height:100%;padding:12px 15px;border:1px solid #dce6e8;border-radius:9px;background:#fff;color:#18575b;font-size:14px;line-height:1.5;font-weight:600;text-decoration:none;box-sizing:border-box\">Check the reserve under load<\/a><\/div>\n<div class=\"wh-toc-item\" style=\"display:block;min-width:0;margin:0;padding:0\"><a class=\"wh-toc-link\" href=\"#fehler-diagnose\" style=\"display:block;height:100%;padding:12px 15px;border:1px solid #dce6e8;border-radius:9px;background:#fff;color:#18575b;font-size:14px;line-height:1.5;font-weight:600;text-decoration:none;box-sizing:border-box\">Pinpoint Memory Issues<\/a><\/div>\n<div class=\"wh-toc-item\" style=\"display:block;min-width:0;margin:0;padding:0\"><a class=\"wh-toc-link\" href=\"#hosting-entscheidung\" style=\"display:block;height:100%;padding:12px 15px;border:1px solid #dce6e8;border-radius:9px;background:#fff;color:#18575b;font-size:14px;line-height:1.5;font-weight:600;text-decoration:none;box-sizing:border-box\">Weighing the Options for Redis Hosting and Architecture<\/a><\/div>\n<\/div><\/nav><section class=\"wh-section\" aria-labelledby=\"maxmemory-grundlagen\" style=\"display:block;margin:0 0 36px;min-width:0\"><h2 id=\"maxmemory-grundlagen\" style=\"margin:38px 0 18px;color:#172f41;font-size:clamp(24px,1.25rem + 1vw,30px);font-weight:700;line-height:1.3;scroll-margin-top:115px\">What Actually Limits `maxmemory`<\/h2><p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\"><code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">maxmemory<\/code> creates an <strong style=\"font-weight:700;color:inherit\">Eviction Threshold<\/strong> There is no hard upper limit for the Redis process or its container. If the memory usage relevant to memory management reaches the threshold, Redis attempts to remove keys based on the selected policy. For a policy without eviction, write commands that increase memory usage may fail instead. <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">The key figure <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">used_memory<\/code> includes the memory allocated by Redis through its allocator. This includes not only the actual values of your application, but also management structures and other Redis memory areas. If you calculate the limit based solely on the estimated size of the user data, you are not taking this overhead into account. <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">Part of <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">used_memory<\/code> is excluded from the eviction test: <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">mem_not_counted_for_evict<\/code> specifies, in particular, temporary replication and AOF buffers. These buffers still require physical memory. The value is already specified in <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">used_memory<\/code> is included and therefore must not be added to this metric a second time without verification.  <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">This does not mean that all client or replication storage is excluded from the eviction calculation. A single large command can also temporarily exceed the threshold by a significant margin. If you set <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">maxmemory<\/code> If the container reaches its full capacity, there is no reliable margin left to accommodate such spikes and additional process usage. <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">When planning, therefore, two questions must be answered separately: How much space do the data set and Redis overhead require within the memory management system? And how much additional reserve does the entire runtime environment require? Only by considering both perspectives together can we determine whether a chosen value below the actual memory limit is plausible.<\/p>\n<\/section><section class=\"wh-section\" aria-labelledby=\"rss-und-persistenz\" style=\"display:block;margin:0 0 36px;min-width:0\"><h2 id=\"rss-und-persistenz\" style=\"margin:38px 0 18px;color:#172f41;font-size:clamp(24px,1.25rem + 1vw,30px);font-weight:700;line-height:1.3;scroll-margin-top:115px\">RSS, Allocator, and Persistence Peaks<\/h2><p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">After a load spike, <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">used_memory<\/code> decrease, while <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">used_memory_rss<\/code> remains high: Although Redis has released memory via the allocator, that memory was not necessarily returned to the operating system immediately. RSS describes the process's resident memory from the operating system's perspective and is therefore a different level of observation. <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">Suppose a cache grows significantly during an operation and many keys expire afterward. The smaller Redis memory value does not automatically mean that the container immediately regains that amount of free memory. For the next peak, therefore, the actual consumption history is more important than the assumption that freed memory disappears immediately. <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">Also <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">mem_fragmentation_ratio<\/code> is not simply a fragmentation percentage. The ratio includes other process components; for the root cause analysis, you should consider it together with the available <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">allocator_*<\/code>-metrics and load history. A single ratio cannot be used to determine a universally applicable reserve. <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">For RDB snapshots and AOF rewrites, Redis creates a child process. By <strong style=\"font-weight:700;color:inherit\">Copy-on-Write<\/strong> Additional physical memory pages may be required if pages are modified during the persistence run. The heavier and broader the write load during this time, the more important it is to monitor this phase during capacity planning. <\/p>\n<figure class=\"wp-block-image size-large wh-figure\" aria-describedby=\"wh-caption-detail1\" style=\"display:block;float:none;clear:both;width:100%;max-width:760px;margin:34px auto 40px;border:1px solid #dae5e9;border-radius:14px;overflow:hidden;background:#f5f8fa;box-shadow:0 10px 28px -17px rgba(24,47,60,.28);box-sizing:border-box\"><div class=\"wh-figure-media\" style=\"display:block;background:#eef3f5;line-height:0\"><img loading=\"lazy\" width=\"800\" height=\"534\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/11\/redis-persistenz-ram-reserve-54c86e44-detail1-08896ef59b-1024x683.webp\" class=\"wp-image-22167\" alt=\"An AI-generated stock image of a removed RAM module on an antistatic mat.\" decoding=\"async\" srcset=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/11\/redis-persistenz-ram-reserve-54c86e44-detail1-08896ef59b-1024x683.webp 1024w, https:\/\/webhosting.de\/wp-content\/uploads\/2026\/11\/redis-persistenz-ram-reserve-54c86e44-detail1-08896ef59b-300x200.webp 300w, https:\/\/webhosting.de\/wp-content\/uploads\/2026\/11\/redis-persistenz-ram-reserve-54c86e44-detail1-08896ef59b-768x512.webp 768w, https:\/\/webhosting.de\/wp-content\/uploads\/2026\/11\/redis-persistenz-ram-reserve-54c86e44-detail1-08896ef59b-18x12.webp 18w, https:\/\/webhosting.de\/wp-content\/uploads\/2026\/11\/redis-persistenz-ram-reserve-54c86e44-detail1-08896ef59b.webp 1536w\" sizes=\"auto, (max-width: 800px) 100vw, 800px\" ><\/div><figcaption class=\"wh-caption\" id=\"wh-caption-detail1\" style=\"display:block;margin:0;padding:12px 18px 15px;border-top:1px solid #dce5e9;color:#506575;background:#f5f8fa;font-size:14px;line-height:1.55;text-align:start\">AI-generated illustrative image: Physical memory serves as the foundation, but does not replace the planning of persistence reserves.<\/figcaption><\/figure><p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">Redis Administration states that, in extreme cases, write-intensive applications may require up to twice the amount of memory normally used. This is a warning about unfavorable load conditions, not a blanket multiplier. Also, do not simply add the RSS values of the parent and child processes: Shared pages would be counted multiple times; what matters is monitoring the appropriate host or container. <\/p>\n<\/section><section class=\"wh-section\" aria-labelledby=\"replikation-speicher\" style=\"display:block;margin:0 0 36px;min-width:0\"><h2 id=\"replikation-speicher\" style=\"margin:38px 0 18px;color:#172f41;font-size:clamp(24px,1.25rem + 1vw,30px);font-weight:700;line-height:1.3;scroll-margin-top:115px\">Replicas require their own budgets<\/h2><p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">A replica always maintains a copy of the data set and requires its own RAM to do so. The primary and the replica are therefore separate memory consumers: A reserve on the primary does not free up space in the replica's container. Plan for each member based on its own limits and observed usage. <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">By default, a replica ignores its configured <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">maxmemory<\/code> for its own evictions. The primary decides which keys to remove and replicates the deletions. Nevertheless, the storage states may differ, for example due to differing buffers or data structures; therefore, the same threshold does not guarantee identical utilization. <\/p>\n<figure class=\"wp-block-image size-large wh-figure\" aria-describedby=\"wh-caption-detail2\" style=\"display:block;float:none;clear:both;width:100%;max-width:760px;margin:34px auto 40px;border:1px solid #dae5e9;border-radius:14px;overflow:hidden;background:#f5f8fa;box-shadow:0 10px 28px -17px rgba(24,47,60,.28);box-sizing:border-box\"><div class=\"wh-figure-media\" style=\"display:block;background:#eef3f5;line-height:0\"><img loading=\"lazy\" width=\"800\" height=\"534\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/11\/redis-replikation-eigene-speicherbudgets-54c86e44-detail2-820fa7a1b9-1024x683.webp\" class=\"wp-image-22168\" alt=\"AI-generated illustration of two linked instances with similar data structures and different additional storage requirements.\" decoding=\"async\" srcset=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/11\/redis-replikation-eigene-speicherbudgets-54c86e44-detail2-820fa7a1b9-1024x683.webp 1024w, https:\/\/webhosting.de\/wp-content\/uploads\/2026\/11\/redis-replikation-eigene-speicherbudgets-54c86e44-detail2-820fa7a1b9-300x200.webp 300w, https:\/\/webhosting.de\/wp-content\/uploads\/2026\/11\/redis-replikation-eigene-speicherbudgets-54c86e44-detail2-820fa7a1b9-768x512.webp 768w, https:\/\/webhosting.de\/wp-content\/uploads\/2026\/11\/redis-replikation-eigene-speicherbudgets-54c86e44-detail2-820fa7a1b9-18x12.webp 18w, https:\/\/webhosting.de\/wp-content\/uploads\/2026\/11\/redis-replikation-eigene-speicherbudgets-54c86e44-detail2-820fa7a1b9.webp 1536w\" sizes=\"auto, (max-width: 800px) 100vw, 800px\" ><\/div><figcaption class=\"wh-caption\" id=\"wh-caption-detail2\" style=\"display:block;margin:0;padding:12px 18px 15px;border-top:1px solid #dce5e9;color:#506575;background:#f5f8fa;font-size:14px;line-height:1.55;text-align:start\">AI-generated illustration: Primary and Replica store copies of the data, but each requires its own storage quota.<\/figcaption><\/figure><p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">In the case of a <strong style=\"font-weight:700;color:inherit\">Promotion<\/strong> The former replica assumes the primary role. Therefore, check not only whether it has enough space as a read replica, but also whether its storage limit and configuration can support operation as a primary. This includes, in particular, write load, replication connections, and the eviction policy in effect at that time. <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">Starting with Redis 7.0, the replica buffer and the replication backlog share memory. <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">mem_clients_slaves<\/code> It may therefore show zero, even though replication is using memory. Do not interpret this field in isolation, and do not add the backlog and replica buffer together without verification as if they were completely separate areas. <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">In addition to memory usage, the progress of data transfer is relevant to system operation: A delay exhibits different characteristics than the size of a buffer. The article on the topic explains how replication status and backlog can be classified: <a href=\"https:\/\/webhosting.de\/en\/redis-replication-offset-analysis-data-consistency-cluster\/\">Redis Replication Offset<\/a>. However, the actual consumption patterns of each instance remain the determining factor for the storage reserve.<\/p>\n<\/section><section class=\"wh-section\" aria-labelledby=\"metriken-erfassen\" style=\"display:block;margin:0 0 36px;min-width:0\"><h2 id=\"metriken-erfassen\" style=\"margin:38px 0 18px;color:#172f41;font-size:clamp(24px,1.25rem + 1vw,30px);font-weight:700;line-height:1.3;scroll-margin-top:115px\">Track inventory across three levels<\/h2><p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">To size the instance, you'll need values from Redis and from the environment in which the instance is running. The <strong style=\"font-weight:700;color:inherit\">Observation Level<\/strong> determines what a number represents: Allocator usage, process RSS, and container usage are different metrics and cannot simply be added together. <\/p>\n<div class=\"wh-table-scroll\" tabindex=\"0\" role=\"region\" aria-label=\"Stored Values and Their Limits of Validity\" style=\"width:100%;max-width:100%;overflow-x:auto;margin:28px 0;border:1px solid #dce5e9;border-radius:14px;background:#fff;box-shadow:0 10px 28px -16px rgba(24,47,60,.32);box-sizing:border-box\"><table style=\"width:100%;min-width:580px;border-collapse:separate;border-spacing:0;border:0;margin:0;font-size:15px;line-height:1.6;background:#fff\"><caption style=\"padding:20px;text-align:start;font-size:17px;line-height:1.5;font-weight:700;color:#173246;background:#fff\">Stored Values and Their Limits of Validity<\/caption><thead><tr><th scope=\"col\" style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#19394d;color:#fff\">Size<\/th><th scope=\"col\" style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#19394d;color:#fff\">Level and Meaning<\/th><th scope=\"col\" style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#19394d;color:#fff\">Limits of Interpretation<\/th><\/tr><\/thead><tbody><tr><td style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#fff;color:#294252\">used_memory<\/td><td style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#fff;color:#294252\">Memory allocated by Redis via the allocator<\/td><td style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#fff;color:#294252\">Includes Redis overhead and is not identical to the raw payload.<\/td><\/tr><tr><td style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#f4f7f9;color:#294252\">used_memory_rss<\/td><td style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#f4f7f9;color:#294252\">Resident memory of the Redis process from the operating system's perspective<\/td><td style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#f4f7f9;color:#294252\">May remain high after load spikes; should not be equated with used_memory.<\/td><\/tr><tr><td style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#fff;color:#294252\">mem_not_counted_for_evict<\/td><td style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#fff;color:#294252\">Percentage of `used_memory` to be excluded from the eviction check<\/td><td style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#fff;color:#294252\">It fluctuates and is already included in `used_memory`.<\/td><\/tr><tr><td style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#f4f7f9;color:#294252\">Host or Container Usage<\/td><td style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#f4f7f9;color:#294252\">Consumption at the relevant operating limit<\/td><td style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#f4f7f9;color:#294252\">May include other consumers in addition to Redis; the definition depends on the environment.<\/td><\/tr><\/tbody><\/table><\/div><p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">With <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">INFO memory<\/code> Among other things, you'll read the Redis storage values and the configured policy. <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">MEMORY STATS<\/code> Adds details about memory allocation. Both commands are read-only; the fields available depend on the Redis version, permissions, and hosting plan. <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">To verify the temporal relationship, you should also check <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">INFO persistence<\/code> on persistence activity and available copy-on-write values. <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">INFO replication<\/code> Displays the role and replication status. Enter this information separately for the primary and the replica so that a role change or synchronization remains visible during evaluation.  <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">A single value does not indicate either typical utilization or the necessary peak reserve. Therefore, collect time series data covering normal operation, write spikes, and persistence runs, and associate them with the host or container usage observed at the same time. This will also help you determine whether a high RSS value accompanies a current load or persists after a previous spike. <\/p>\n<\/section><section class=\"wh-section\" aria-labelledby=\"budget-rechnen\" style=\"display:block;margin:0 0 36px;min-width:0\"><h2 id=\"budget-rechnen\" style=\"margin:38px 0 18px;color:#172f41;font-size:clamp(24px,1.25rem + 1vw,30px);font-weight:700;line-height:1.3;scroll-margin-top:115px\">Calculate a robust memory budget<\/h2><p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">The starting point is the one that is actually effective <strong style=\"font-weight:700;color:inherit\">Memory Limit<\/strong>: For a container, this limit may be lower than the host's RAM. Determine which other processes and operating system components are using this same limit. The space reserved for them is not available to Redis for data or peak loads.<\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">Next, subtract reserves for additional RSS and allocator effects, buffers not counted toward eviction, persistence spikes, and a safety margin. The result is a preliminary <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">maxmemory<\/code>-Budget, not an internal Redis equation. The reserves must match the same limit and reflect realistic, simultaneously occurring load conditions.   <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">Illustrative calculation example, not a measurement: From a container limit of 8 GiB, 0.5 GiB is allocated for other consumers, 0.5 GiB for additional RSS effects, 0.5 GiB for buffers excluded from the eviction calculation, 1 GiB for a persistence spike, and 0.5 GiB for a safety margin. This leaves 5 GiB as a preliminary value for <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">maxmemory<\/code>.<\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">These figures are not a recommendation for a specific instance. The example assumes that the allocated reserves represent additional, non-overlapping contributions to the container limit. Especially during a persistence run, shared memory pages and copy-on-write can complicate the allocation; simply adding the RSS values of the parent and child processes would be unsuitable for this purpose. <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">Avoid <strong style=\"font-weight:700;color:inherit\">Double Counts<\/strong>: <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">mem_not_counted_for_evict<\/code> is already included in <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">used_memory<\/code>. If you base your calculation on the total observed RSS or container usage, you must not add this buffer portion again without verifying it. The remaining eviction budget must accommodate both the dataset and the included Redis overhead; then test this approach under a comparable load.  <\/p>\n<\/section><section class=\"wh-section\" aria-labelledby=\"eviction-vergleichen\" style=\"display:block;margin:0 0 36px;min-width:0\"><h2 id=\"eviction-vergleichen\" style=\"margin:38px 0 18px;color:#172f41;font-size:clamp(24px,1.25rem + 1vw,30px);font-weight:700;line-height:1.3;scroll-margin-top:115px\">A Comparative Analysis of Eviction Policies in Practice<\/h2><p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">The <strong style=\"font-weight:700;color:inherit\">Eviction policy<\/strong> Determines how Redis responds to write commands when storage is scarce. It does not replace capacity planning: Even an appropriate policy requires reserves beyond what is accounted for by the eviction algorithm. The decision depends primarily on which keys can be lost and how the application responds to errors. <\/p>\n<div class=\"wh-table-scroll\" tabindex=\"0\" role=\"region\" aria-label=\"Policies by Use Case and Behavior During Storage Shortages\" style=\"width:100%;max-width:100%;overflow-x:auto;margin:28px 0;border:1px solid #dce5e9;border-radius:14px;background:#fff;box-shadow:0 10px 28px -16px rgba(24,47,60,.32);box-sizing:border-box\"><table style=\"width:100%;min-width:580px;border-collapse:separate;border-spacing:0;border:0;margin:0;font-size:15px;line-height:1.6;background:#fff\"><caption style=\"padding:20px;text-align:start;font-size:17px;line-height:1.5;font-weight:700;color:#173246;background:#fff\">Policies by Use Case and Behavior During Storage Shortages<\/caption><thead><tr><th scope=\"col\" style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#19394d;color:#fff\">Policy<\/th><th scope=\"col\" style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#19394d;color:#fff\">Typical suitability<\/th><th scope=\"col\" style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#19394d;color:#fff\">Loss and Error Conditions<\/th><\/tr><\/thead><tbody><tr><td style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#fff;color:#294252\">no eviction<\/td><td style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#fff;color:#294252\">Data that should not be removed to free up space<\/td><td style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#fff;color:#294252\">No eviction to free up space; memory-expanding write commands may fail due to OOM.<\/td><\/tr><tr><td style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#f4f7f9;color:#294252\">allkeys-lru<\/td><td style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#f4f7f9;color:#294252\">Cache with recoverable data<\/td><td style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#f4f7f9;color:#294252\">Keys can be removed based on an approximate LRU policy; this results in cache misses.<\/td><\/tr><tr><td style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#fff;color:#294252\">volatile-*<\/td><td style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#fff;color:#294252\">A set in which only keys with an expiration time are scheduled for eviction<\/td><td style=\"padding:15px 18px;border:0;border-bottom:1px solid #e2e9ed;text-align:start;vertical-align:top;white-space:normal;font-size:15px;line-height:1.6;background:#fff;color:#294252\">Only keys with TTL are candidates; if there are no suitable candidates, not enough space can be freed up.<\/td><\/tr><\/tbody><\/table><\/div><p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">With a pure cache, you can <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">allkeys-lru<\/code> This works if deleted entries can be reconstructed from another source. In Redis, LRU is an approximation and not an exact global sort. Frequent evictions can trigger more requests to the backend; therefore, not only free bytes but also cache hit rate and backend capacity are important. <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">For data that cannot be deleted at will, <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">noeviction<\/code> Another decision: The application must be able to handle failed write operations, rather than silently assuming that data has been successfully saved. The policy is neither persistence nor protection against an OOM at the operating system or container level. <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">For mixed populations, the <strong style=\"font-weight:700;color:inherit\">TTL discipline<\/strong> Crucial: A <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">volatile-*<\/code>-Policy can only select keys with an expiration time. If there are too few suitable candidates, a TTL alone does not protect against write errors. Therefore, check whether the cache and important data should really share the same instance and error handling strategy. <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">Session data highlights the conflict of objectives: Deleting an entry can result in the loss of session state for users, even if the application continues to run technically. Evaluate the consequences and the possibility of recovery before selecting a policy; additional background information is provided in the article on <a href=\"https:\/\/webhosting.de\/en\/session-management-webhosting-redis-database-storage\/\">Session Management with Redis and Other Storage Solutions<\/a>.<\/p>\n<\/section><section class=\"wh-section\" aria-labelledby=\"betrieb-ueberwachen\" style=\"display:block;margin:0 0 36px;min-width:0\"><h2 id=\"betrieb-ueberwachen\" style=\"margin:38px 0 18px;color:#172f41;font-size:clamp(24px,1.25rem + 1vw,30px);font-weight:700;line-height:1.3;scroll-margin-top:115px\">Check the reserve under load<\/h2><p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">A calculated value for <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">maxmemory<\/code> This is a starting point. Test it in an isolated environment with a comparable Redis version, data structure, and memory limit. The load should not only reflect normal operation but also write spikes and periods when persistence and replication are active simultaneously. <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">As you do this, watch the <strong style=\"font-weight:700;color:inherit\">Container Usage<\/strong> or the corresponding host metrics, as well as Redis storage values. Keep track of when a snapshot or AOF rewrite is running and whether a replica is being synchronized. What matters is how much time remains until the actual threshold during overlapping events, not just during the idle period afterward.  <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">Using the read command <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">INFO stats<\/code> Among other things, you'll track eviction counters. Analyze how these values change over time: A high historical value alone doesn't indicate whether keys are currently being evicted. Correlate rising eviction rates with cache hits and backend load, provided your application provides these metrics. <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">Also, track Redis OOM responses in the application and memory-related container events on the platform. Both errors can occur under similar load conditions but are related to different limits. Therefore, any alerting should take into account both the available reserve and the observed errors and their temporal progression. <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">Repeat the evaluation after making changes to the dataset, the write load, or persistence and replication. A promotion also changes the role of a replica and, consequently, the load profile to be tested. The results from the isolated environment do not replace the ongoing monitoring of the production instances. <\/p>\n<\/section><section class=\"wh-section\" aria-labelledby=\"fehler-diagnose\" style=\"display:block;margin:0 0 36px;min-width:0\"><h2 id=\"fehler-diagnose\" style=\"margin:38px 0 18px;color:#172f41;font-size:clamp(24px,1.25rem + 1vw,30px);font-weight:700;line-height:1.3;scroll-margin-top:115px\">Pinpoint Memory Issues<\/h2><p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">If the process RSS increases while <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">used_memory<\/code> If memory is released, first consider its usage history and previous load. Released memory does not have to be returned to the operating system immediately. The <strong style=\"font-weight:700;color:inherit\">Allocator Metrics<\/strong> from <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">INFO memory<\/code> help with analysis; the fragmentation ratio alone does not prove either a memory leak or its cause. <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">Next, check whether the increase coincides with a persistence run or a synchronization. The following are used for this purpose: <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">INFO persistence<\/code> and <code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">INFO replication<\/code>. A single value for buffers not included in the eviction process describes only the current state. To determine a reserve, you need observations spanning relevant load and disturbance phases. <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">In the case of a <strong style=\"font-weight:700;color:inherit\">Redis OOM Response<\/strong> Check the configured policy and whether suitable keys are available for eviction. In particular, a write command may fail if Redis cannot free up enough space under the current policy. The application must handle this error rather than assuming the write operation will succeed.  <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">In the case of a memory-related container termination, however, examine the platform events and memory usage against the container limit. Take into account persistence spikes and other memory consumers tracked within the container. A Redis OOM and a container OOM are not the same thing: the outer memory limit can be reached even without a prior Redis OOM response. <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\"><code data-no-translation style=\"font:600 .87em\/1.5 ui-monospace,monospace;color:#235063;background:#edf3f5;border-radius:4px;padding:.1em .3em\">maxmemory-clients<\/code> can also limit the memory used by clients. If the relevant client memory exceeds the configured threshold, Redis may disconnect high-usage clients; applications must handle connection terminations. This setting does not limit all replication connections and does not replace the overall budget or the monitoring of buffer spikes. <\/p>\n<\/section><section class=\"wh-section\" aria-labelledby=\"hosting-entscheidung\" style=\"display:block;margin:0 0 36px;min-width:0\"><h2 id=\"hosting-entscheidung\" style=\"margin:38px 0 18px;color:#172f41;font-size:clamp(24px,1.25rem + 1vw,30px);font-weight:700;line-height:1.3;scroll-margin-top:115px\">Weighing the Options for Redis Hosting and Architecture<\/h2><p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">If the observed reserve is insufficient under representative load, adding more RAM may be advisable if the dataset and load are to remain on a single instance. However, the additional capacity must be part of the actual effective host or container limit. A higher Redis limit alone does not create additional physical memory. <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">Alternatively, a <strong style=\"font-weight:700;color:inherit\">Load distribution<\/strong> distribute memory requirements and write operations across multiple instances. This requires an appropriate partitioning of the data and separate resource allocation for each participating instance. Replicas should not be equated with a partitioning of the data set: They essentially maintain a copy and require their own RAM to do so. <\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">An architectural change can also help\u2014for example, separating a loss-tolerant cache from data with stricter requirements. This allows policies and capacities to be selected independently. However, neither this separation nor additional RAM nor load balancing guarantees that persistence, replication, and write spikes will not occur in the future.<\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">When comparing <strong style=\"font-weight:700;color:inherit\">Provider Limits<\/strong> Determine whether the reported value refers to a container limit, an instance limit, or another type of database limit. Also, find out which metrics and diagnostic commands are available, whether replicas are included in the reserved storage, and how a promotion affects available resources.<\/p>\n<p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">Redis Open Source, Redis Software, and Redis Cloud should be considered separately. For Redis Software, the documented database limit applies across primary and replica shards; this does not imply a corresponding rule for a single Redis OSS instance. For Redis Cloud and other hosting services, check the specific product terms and conditions for each service rather than applying this definition without verification. <\/p>\n<\/section><section class=\"wh-sources\" style=\"margin:40px 0 0;padding:24px 0 0;border-top:1px solid #dce5e9;color:#596b7b;font-size:14px;line-height:1.65\"><h2 style=\"margin:38px 0 18px;color:#172f41;font-size:clamp(24px,1.25rem + 1vw,30px);font-weight:700;line-height:1.3;scroll-margin-top:115px\">Sources and Current State of Knowledge<\/h2><p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">Status of the research: <time datetime=\"2026-11-04\">2026-11-04<\/time><\/p><p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\">Research and product scope as of November 4, 2026. Examples refer to Redis Open Source; available metrics and hosting limits depend on the version and provider.<\/p><div class=\"wh-source-urls\"><p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\"><span class=\"wh-source-url\" data-no-translation dir=\"ltr\" style=\"overflow-wrap:anywhere;font:12px\/1.6 ui-monospace,monospace;direction:ltr\">https:\/\/redis.io\/docs\/latest\/develop\/reference\/eviction\/<\/span><\/p><p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\"><span class=\"wh-source-url\" data-no-translation dir=\"ltr\" style=\"overflow-wrap:anywhere;font:12px\/1.6 ui-monospace,monospace;direction:ltr\">https:\/\/redis.io\/docs\/latest\/operate\/oss_and_stack\/management\/replication\/<\/span><\/p><p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\"><span class=\"wh-source-url\" data-no-translation dir=\"ltr\" style=\"overflow-wrap:anywhere;font:12px\/1.6 ui-monospace,monospace;direction:ltr\">https:\/\/redis.io\/docs\/latest\/commands\/info\/<\/span><\/p><p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\"><span class=\"wh-source-url\" data-no-translation dir=\"ltr\" style=\"overflow-wrap:anywhere;font:12px\/1.6 ui-monospace,monospace;direction:ltr\">https:\/\/redis.io\/docs\/latest\/operate\/oss_and_stack\/management\/admin\/<\/span><\/p><p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\"><span class=\"wh-source-url\" data-no-translation dir=\"ltr\" style=\"overflow-wrap:anywhere;font:12px\/1.6 ui-monospace,monospace;direction:ltr\">https:\/\/redis.io\/docs\/latest\/develop\/reference\/errors\/common\/oom\/<\/span><\/p><p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\"><span class=\"wh-source-url\" data-no-translation dir=\"ltr\" style=\"overflow-wrap:anywhere;font:12px\/1.6 ui-monospace,monospace;direction:ltr\">https:\/\/redis.io\/docs\/latest\/develop\/reference\/clients\/<\/span><\/p><p style=\"margin:0 0 1.1em;font-size:inherit;line-height:inherit\"><span class=\"wh-source-url\" data-no-translation dir=\"ltr\" style=\"overflow-wrap:anywhere;font:12px\/1.6 ui-monospace,monospace;direction:ltr\">https:\/\/redis.io\/docs\/latest\/operate\/rs\/databases\/memory-performance\/memory-limit\/<\/span><\/p><\/div><\/section><\/div>","protected":false},"excerpt":{"rendered":"<p>Redis `maxmemory` is not a hard RAM limit. Learn how to factor in data, replication, persistence spikes, and container limits when planning your storage.<\/p>","protected":false},"author":1,"featured_media":22166,"comment_status":"closed","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[781],"tags":[],"class_list":["post-22164","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-datenbanken-administration-anleitungen"],"acf":[],"_wp_attached_file":null,"_wp_attachment_metadata":null,"surfer_file_name":null,"surfer_file_original_url":null,"_wp_attachment_image_alt":null,"litespeed-optimize-set":null,"litespeed-optimize-size":null,"_oembed_b5e1eb923ad3b086e579b1befcd4075c":null,"_elementor_source_image_hash":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,"_source_url":null,"_elementor_migrations_state_8b2d":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,"_wh_make_key":"wh_54c86e44167291080cf614c61d005eeb","rank_math_internal_links_processed":"1","_wh_make_topic":"Redis maxmemory richtig dimensionieren \u2013 ausreichend Platz f\u00fcr Daten, Replikation und interne Buffer","_wh_make_input_keywords":["redis maxmemory","redis speicher","redis hosting"],"_wh_make_config":{"research_model":"gpt-6.1-terra","writer_model":"gpt-6.1-terra","review_model":"gpt-6.1-sol","image_model":"gpt-image-2.5-flare","image_quality":"high","image_format":"webp","final_status":"draft","charts_enabled":true},"_wh_make_links":{"I1":{"id":"I1","post_id":21475,"url":"https:\/\/webhosting.de\/redis-replication-offset-analyse-datenkonsistenz-cluster\/","title":"Understanding and Analyzing Redis Replication Offsets for High Data Consistency","excerpt":"I\u2019ll show you how I specifically read and analyze the Redis offset and use it to ensure high data consistency. This allows me to detect replication gaps early, assess failover risks, and reliably keep production clusters in sync. Key Points The following key points provide a targeted introduction to the topic, terminology, and practical implementation. The offset measures the progress of the replication stream byte by byte. Lag is the difference between `master_repl_offset` and `slave_repl_offset`. ID+Offset identifies an exact data version for partial syncs. Backlog prevents full syncs during brief connection interruptions. Monitoring with INFO\/cluster metrics controls alerting and failover. What does the Redis replication offset mean? The replication offset is a continuous 64-bit counter that tracks every byte stream transferred between the primary and the replica. I use it to determine how far the replication has progressed and whether a replica still has work to do. The `master_repl_offset` on the primary increases with every newly generated byte, while the replica increments its own counter as soon as it has applied commands. Differences result in a lag in bytes and indicate whether the replica is falling behind. This simple yet effective mechanism makes the offset the key metric for synchronization, failure analysis, and clean failover decisions. Reading Offsets: Using `INFO replication` Correctly I almost always begin my diagnosis with `INFO replication` because the command provides the relevant fields in a compact format. On the primary, I check `master_repl_offset` as well as the status of connected replicas, including their offsets. On a replica, I also check `master_link_status` and synchronization statuses to identify ongoing full syncs or partial syncs. For a more in-depth analysis, I rely on structured output and correlate offsets with CPU, I\/O, and network metrics. This guide provides me with a thorough introduction to the command: Redis INFO for Monitoring. Replication ID + Offset: Unique Data Version To identify a unique version, I use the combination of the Replication ID and the offset. The ID marks a history, while the offset marks a position within the"},"I2":{"id":"I2","post_id":18104,"url":"https:\/\/webhosting.de\/datenbank-replikation-hosting-master-slave-multi-master-syncio\/","title":"Database replication in hosting: master-slave vs. multi-master","excerpt":"In hosting, database replication determines how well applications remain available as load increases and how quickly they resume writing and reading after failures. I clearly outline the difference between master-slave and multi-master configurations, including tuning, failover strategies, and appropriate use cases. Key Points: The following core aspects help me choose the right replication strategy. Master-slave: Simple writes, scalable reads, clear responsibilities. Multi-master: Distributed writes, higher availability, but conflict management. GTIDs &amp; Failover: Faster failovers and cleaner replication paths. Hosting Reality: Latency, storage, and network impact consistency. Monitoring &amp; Tuning: Keeping an eye on metrics, catch-up times, and binlog settings. What Replication Achieves in Hosting I use replication to increase availability, distribute read loads, and enable maintenance windows without downtime. Master-slave topologies handle writes centrally, while multiple replicas handle massive read volumes, thereby reducing response times. Multi-master configurations allow for distributed writes, which reduces latency in global setups and makes it easier to withstand the loss of a node. For web stacks built on WordPress, e-commerce platforms, or APIs, this means more buffer against traffic spikes and faster recovery after incidents. Those planning horizontal growth beyond simple replication should gradually combine it with sharding and replication to distribute data and load more broadly and make scaling predictable. Master-Slave: How It Works and Its Strengths In a master-slave setup, I consistently write only to the master, while slaves handle read operations and synchronize binlogs. This clear division of roles prevents write conflicts and keeps the model straightforward. This works perfectly for many hosting scenarios with a high proportion of read operations, such as product catalogs, content portals, or reporting dashboards. Depending on needs, I can add additional slaves without changing the write path. I build in buffers for replication latency so that reports or caches deliver consistent results despite brief delays. MySQL Master-Slave Step by"},"I3":{"id":"I3","post_id":17026,"url":"https:\/\/webhosting.de\/session-management-webhosting-redis-datenbanken-storage\/","title":"Session management in web hosting: Optimal storage with files, Redis and databases","excerpt":"I\u2019ll show how session management in web hosting becomes measurably faster when I store sessions in specific locations\u2014such as files, Redis, or databases\u2014and strictly control their lifecycle. This allows me to reduce latency, maintain a high cache hit rate, and scale reliably across multiple servers. Key Points I consistently implement the following key points to handle sessions securely, quickly, and scalably. Protect the cache hit rate: Minimize session usage and keep requests cache-friendly. Redis for Speed: Use in-memory storage for short, frequent accesses. Files with Care: Start simple; migrate early when load increases. Databases Selectively: Use persistence only for truly critical sessions. Tight Configuration: Fine-tune PHP-FPM, TTLs, timeouts, and monitoring. Why Sessions Lower the Cache Hit Rate: Every active session sets a PHPSESSID cookie, which makes requests unique and thus bypasses many caches. I therefore deliberately decide which routes truly need sessions and which run strictly without them. This ensures that pages such as product lists, blogs, or static content remain as fast and scalable as possible via CDN and app cache. I only open a session when the request writes status data or reads sensitive data. I keep the write portion brief, close the session quickly, and thereby give concurrent requests free rein. Files as Session Storage: Simple, but Limited The file system handler in PHP is a good starting point, but it only scales up to a moderate load. Every access generates I\/O, and on slow storage or NFS, latency increases rapidly. In cluster setups, inconsistencies can arise if multiple app servers aren\u2019t pointing to the same directory. I therefore ensure centrally accessible paths early on or plan the transition to Redis well in advance. File storage is sufficient for small projects; for growth, I plan a migration path from the very beginning. Redis for Sessions: Fast and Centralized Redis stores session data in RAM, delivering millisecond-level access even under load. I deploy Redis centrally so that all application servers see the same sessions and load balancers can distribute them freely. I keep TTLs tight so that short-lived states"}},"_wh_make_stage":"entwurf","_wh_make_research_date":"2026-11-04","_wh_make_sitemap_info":{"index":"https:\/\/webhosting.de\/sitemap_index.xml?wh_make=1","sitemaps":["https:\/\/webhosting.de\/post-sitemap1.xml","https:\/\/webhosting.de\/post-sitemap2.xml","https:\/\/webhosting.de\/post-sitemap3.xml","https:\/\/webhosting.de\/post-sitemap4.xml"],"url_count":3138,"fetched_at":"2026-11-04T08:42:44+00:00","selected_ids":[21475,18104,17026]},"_wh_make_draft_hash":"a7260eec0c2da93959c7a86ee14723c7d8333a520ce09a041cd00c7013ecd323","_wh_make_work":{"version":"2.1","identity":{"sheet_ref":"1VMjxV8Q73i0Q1HO6s-u4jNHVRF0snliGCeg97intLPs","sheet_name":"Tabellenblatt1","external_id":"1442","topic":"Redis maxmemory richtig dimensionieren \u2013 ausreichend Platz f\u00fcr Daten, Replikation und interne Buffer","keywords":["redis maxmemory","redis speicher","redis hosting"],"category_input":"781"},"config":{"research_model":"gpt-6.1-terra","writer_model":"gpt-6.1-terra","review_model":"gpt-6.1-sol","image_model":"gpt-image-2.5-flare","image_quality":"high","image_format":"webp","final_status":"draft","charts_enabled":true},"phase":"done","pending":null,"receipts":{"c91fe5d3591117c4f7adc4eee15b3ac3":"30bd1e88656e0718f85329585c679d2d659eb327caa90c03f64fd485fa14990b","56a538c4b74c5f95a41bc250d37cbf22":"2af7e8b7b53aa5257abc760d6f00f6e9777763ed27052d7c83e9b9f939094017","705a7dfceba1d20df0f23b9fd2ae4a0c":"e4d29c52683faa81f0652772c98e9cd0ff484f2d910fcb8c7971e51b02aacc36","b135231ad0c155adefc805c017852707":"f4e5adec18e96b8a349a88ce187eb4bbfa9115ed645c17f0e86a8d0bb2eae8a9","53003776155a329a5e0f6f11290878cb":"4048ee288742f6795705d5772e9b8e4793feff9879d216c4f677e5e296a80fb8","8a16a91cd2f5131ca4c9353d525810d4":"884915d1efd6761143e2810e4af1af9fd5cb6d9656d4d4ec78fd274fde73d467","afcdaa6816fc080ec4fc305a2d31d891":"0778004888b86192a97109fa70e349beba152314a459459a86d44a6b9e344311","6dcd84225d01eebfbf6c8d9681c42042":"2b0bef1e78f33ab0144d901205d3c730a3b63342ce632d4751b8aad9d9ca87f5","b8f9a1b767805fe27c10bc7f424ae28a":"25cbd4d4689c31917f9eaabe8499815876a3e3bc98466674767400fee5d8ae46","1fe947fbc0410ceb6c66f68637a00712":"383cd29043b07fa7309d74e15638feec00edcac3e7c715bd6f58b34d98eaa6fb","9610b9bbce2245afebeb99d1566719f1":"ae059105a70529489e8a66abb21a1c16d93eb8cfb1aeb8092c05910dc2fbfc73"},"parts":{"1":[{"id":"maxmemory-grundlagen","heading":"Was maxmemory tats\u00e4chlich begrenzt","blocks":[{"type":"paragraph","runs":[{"kind":"code","text":"maxmemory","ref":""},{"kind":"text","text":" legt in Redis Open Source eine ","ref":""},{"kind":"strong","text":"Eviction-Schwelle","ref":""},{"kind":"text","text":" fest, keine harte Obergrenze f\u00fcr den Redis-Prozess oder seinen Container. Erreicht der f\u00fcr die Speichersteuerung relevante Verbrauch die Schwelle, versucht Redis abh\u00e4ngig von der gew\u00e4hlten Policy Schl\u00fcssel zu entfernen. Bei einer Policy ohne Eviction k\u00f6nnen speichervergr\u00f6\u00dfernde Schreibbefehle stattdessen fehlschlagen.","ref":""},{"kind":"citation","text":"","ref":"S2"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Die Kennzahl ","ref":""},{"kind":"code","text":"used_memory","ref":""},{"kind":"text","text":" umfasst den von Redis \u00fcber seinen Allocator belegten Speicher. Dazu geh\u00f6ren nicht nur die eigentlichen Werte deiner Anwendung, sondern auch Verwaltungsstrukturen und weitere Redis-Speicherbereiche. Wer das Limit allein aus der gesch\u00e4tzten Gr\u00f6\u00dfe der Nutzdaten ableitet, l\u00e4sst diesen Overhead unber\u00fccksichtigt.","ref":""},{"kind":"citation","text":"","ref":"S3"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Ein Teil von ","ref":""},{"kind":"code","text":"used_memory","ref":""},{"kind":"text","text":" wird bei der Eviction-Pr\u00fcfung ausgenommen: ","ref":""},{"kind":"code","text":"mem_not_counted_for_evict","ref":""},{"kind":"text","text":" weist insbesondere tempor\u00e4re Replikations- und AOF-Puffer aus. Diese Puffer ben\u00f6tigen trotzdem realen Speicher. Der Wert ist bereits in ","ref":""},{"kind":"code","text":"used_memory","ref":""},{"kind":"text","text":" enthalten und darf deshalb nicht ohne Pr\u00fcfung ein zweites Mal zu dieser Kennzahl addiert werden.","ref":""},{"kind":"citation","text":"","ref":"S2"},{"kind":"citation","text":"","ref":"S3"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Daraus folgt nicht, dass s\u00e4mtliche Client- oder Replikationsspeicher au\u00dferhalb der Eviction-Rechnung liegen. Ein einzelner gro\u00dfer Befehl kann die Schwelle zudem vor\u00fcbergehend deutlich \u00fcberschreiten. Setzt du ","ref":""},{"kind":"code","text":"maxmemory","ref":""},{"kind":"text","text":" auf das volle Containerlimit, bleibt f\u00fcr solche Ausschl\u00e4ge und zus\u00e4tzlichen Prozessverbrauch kein verl\u00e4sslicher Spielraum.","ref":""},{"kind":"citation","text":"","ref":"S2"}]},{"type":"paragraph","runs":[{"kind":"text","text":"F\u00fcr die Planung sind daher zwei Fragen getrennt zu beantworten: Wie viel Platz brauchen Datensatz und Redis-Overhead innerhalb der Speichersteuerung? Und wie viel Reserve ben\u00f6tigt die gesamte Laufzeitumgebung dar\u00fcber hinaus? Erst beide Perspektiven zusammen zeigen, ob ein gew\u00e4hlter Wert unter der tats\u00e4chlichen Speichergrenze plausibel ist.","ref":""}]}]},{"id":"rss-und-persistenz","heading":"RSS, Allocator und Persistenzspitzen","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Nach einer Lastspitze kann ","ref":""},{"kind":"code","text":"used_memory","ref":""},{"kind":"text","text":" sinken, w\u00e4hrend ","ref":""},{"kind":"code","text":"used_memory_rss","ref":""},{"kind":"text","text":" hoch bleibt: Redis hat dann zwar Speicher \u00fcber den Allocator freigegeben, dieser wurde aber nicht zwingend sofort an das Betriebssystem zur\u00fcckgegeben. RSS beschreibt den residenten Speicher des Prozesses aus Betriebssystemsicht und ist deshalb eine andere Beobachtungsebene.","ref":""},{"kind":"citation","text":"","ref":"S3"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Angenommen, ein Cache w\u00e4chst w\u00e4hrend einer Aktion stark und viele Schl\u00fcssel laufen danach ab. Der kleinere Redis-Speicherwert bedeutet nicht automatisch, dass der Container sofort entsprechend viel freie Reserve zur\u00fcckerh\u00e4lt. F\u00fcr die n\u00e4chste Spitze ist daher der Verlauf des tats\u00e4chlichen Verbrauchs wichtiger als die Annahme, dass freigegebener Speicher unmittelbar verschwindet.","ref":""},{"kind":"citation","text":"","ref":"S3"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Auch ","ref":""},{"kind":"code","text":"mem_fragmentation_ratio","ref":""},{"kind":"text","text":" ist kein reiner Fragmentierungsprozentsatz. Das Verh\u00e4ltnis umfasst weitere Prozessanteile; f\u00fcr die Ursachenanalyse solltest du es zusammen mit den verf\u00fcgbaren ","ref":""},{"kind":"code","text":"allocator_*","ref":""},{"kind":"text","text":"-Metriken und der Lastgeschichte betrachten. Aus einem einzelnen Verh\u00e4ltnis l\u00e4sst sich keine allgemein g\u00fcltige Reserve ableiten.","ref":""},{"kind":"citation","text":"","ref":"S3"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Bei RDB-Snapshots und AOF-Rewrites erzeugt Redis einen Kindprozess. Durch ","ref":""},{"kind":"strong","text":"Copy-on-Write","ref":""},{"kind":"text","text":" k\u00f6nnen zus\u00e4tzlich physische Speicherseiten ben\u00f6tigt werden, wenn w\u00e4hrend des Persistenzlaufs Seiten ver\u00e4ndert werden. Je st\u00e4rker und breiter die Schreiblast w\u00e4hrenddessen ist, desto wichtiger ist es, diese Phase bei der Kapazit\u00e4tsplanung zu beobachten.","ref":""},{"kind":"citation","text":"","ref":"S4"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Die Redis-Administration nennt f\u00fcr schreibintensive Anwendungen im Extrem einen Bedarf bis zum Doppelten des normalerweise genutzten Speichers. Das ist eine Warnung f\u00fcr ung\u00fcnstige Lastverh\u00e4ltnisse, kein pauschaler Multiplikator. Addiere au\u00dferdem nicht einfach die RSS-Werte von Eltern- und Kindprozess: Gemeinsam genutzte Seiten w\u00fcrden mehrfach gez\u00e4hlt; relevant ist die passende Host- oder Containerbeobachtung.","ref":""},{"kind":"citation","text":"","ref":"S4"}]}]},{"id":"replikation-speicher","heading":"Replikate brauchen eigene Budgets","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Ein Replica h\u00e4lt grunds\u00e4tzlich eine Kopie des Datenbestands und ben\u00f6tigt daf\u00fcr eigenes RAM. Primary und Replica sind deshalb getrennte Speicherverbraucher: Eine Reserve auf dem Primary schafft keinen Platz im Container des Replica. Plane jedes Mitglied anhand seiner eigenen Grenze und seines beobachteten Verbrauchs.","ref":""},{"kind":"citation","text":"","ref":"S5"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Standardm\u00e4\u00dfig ignoriert ein Replica sein konfiguriertes ","ref":""},{"kind":"code","text":"maxmemory","ref":""},{"kind":"text","text":" f\u00fcr eigene Evictions. Der Primary entscheidet \u00fcber das Entfernen von Schl\u00fcsseln und repliziert die L\u00f6schungen. Trotzdem k\u00f6nnen sich die Speicherst\u00e4nde unterscheiden, etwa wegen abweichender Puffer oder Datenstrukturen; derselbe Grenzwert garantiert daher keine identische Auslastung.","ref":""},{"kind":"citation","text":"","ref":"S5"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Bei einer ","ref":""},{"kind":"strong","text":"Promotion","ref":""},{"kind":"text","text":" \u00fcbernimmt das fr\u00fchere Replica die Primary-Rolle. Pr\u00fcfe deshalb nicht nur, ob es als lesende Kopie gen\u00fcgend Platz hat, sondern auch, ob seine Speichergrenze und Konfiguration den Betrieb als Primary tragen. Dazu geh\u00f6ren insbesondere Schreiblast, Replikationsverbindungen und die dann geltende Eviction-Steuerung.","ref":""},{"kind":"citation","text":"","ref":"S5"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Seit Redis 7.0 teilen sich Replica-Buffer und Replikations-Backlog Speicher. ","ref":""},{"kind":"code","text":"mem_clients_slaves","ref":""},{"kind":"text","text":" kann deshalb null anzeigen, obwohl die Replikation Speicher beansprucht. Interpretiere das Feld nicht isoliert und addiere Backlog und Replica-Buffer nicht ungepr\u00fcft als vollst\u00e4ndig getrennte Bereiche.","ref":""},{"kind":"citation","text":"","ref":"S3"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Neben dem Speicherverbrauch ist der Fortschritt der Daten\u00fcbertragung f\u00fcr den Betrieb relevant: Eine Verz\u00f6gerung zeigt eine andere Eigenschaft als die Gr\u00f6\u00dfe eines Puffers. Wie sich Replikationsstand und R\u00fcckstand einordnen lassen, erkl\u00e4rt der Beitrag zum ","ref":""},{"kind":"internal_link","text":"Redis Replication Offset","ref":"I1"},{"kind":"text","text":". F\u00fcr die Speicherreserve bleiben dennoch die tats\u00e4chlichen Verbrauchsverl\u00e4ufe jeder Instanz entscheidend.","ref":""}]}]}],"2":[{"id":"metriken-erfassen","heading":"Speicher auf drei Ebenen erfassen","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"F\u00fcr die Dimensionierung brauchst du Werte aus Redis und von der Umgebung, in der die Instanz l\u00e4uft. Die ","ref":""},{"kind":"strong","text":"Beobachtungsebene","ref":""},{"kind":"text","text":" entscheidet dar\u00fcber, was eine Zahl aussagt: Allocator-Belegung, Prozess-RSS und Containerverbrauch sind unterschiedliche Gr\u00f6\u00dfen und lassen sich nicht einfach addieren.","ref":""},{"kind":"citation","text":"","ref":"S3"}]},{"type":"table","caption":"Speicherwerte und ihre Aussagegrenzen","headers":["Gr\u00f6\u00dfe","Ebene und Bedeutung","Grenze der Interpretation"],"rows":[["used_memory","Von Redis \u00fcber den Allocator belegter Speicher","Enth\u00e4lt Redis-Overhead und ist nicht identisch mit den reinen Nutzdaten."],["used_memory_rss","Residenter Speicher des Redis-Prozesses aus Betriebssystemsicht","Kann nach Lastspitzen hoch bleiben; ist nicht mit used_memory gleichzusetzen."],["mem_not_counted_for_evict","Anteil von used_memory, der bei der Eviction-Pr\u00fcfung ausgenommen wird","Schwankt und ist bereits in used_memory enthalten."],["Host- oder Containerverbrauch","Verbrauch an der relevanten Betriebsgrenze","Kann neben Redis weitere Verbraucher umfassen; die Definition h\u00e4ngt von der Umgebung ab."]],"source_ids":["S3"]},{"type":"paragraph","runs":[{"kind":"text","text":"Mit ","ref":""},{"kind":"code","text":"INFO memory","ref":""},{"kind":"text","text":" liest du unter anderem die Redis-Speicherwerte und die konfigurierte Policy. ","ref":""},{"kind":"code","text":"MEMORY STATS","ref":""},{"kind":"text","text":" erg\u00e4nzt Details zur Speicherverteilung. Beide Befehle sind lesend; welche Felder verf\u00fcgbar sind, h\u00e4ngt von Redis-Version, Berechtigungen und Hosting-Angebot ab.","ref":""},{"kind":"citation","text":"","ref":"S3"}]},{"type":"paragraph","runs":[{"kind":"text","text":"F\u00fcr den zeitlichen Zusammenhang pr\u00fcfst du au\u00dferdem ","ref":""},{"kind":"code","text":"INFO persistence","ref":""},{"kind":"text","text":" auf Persistenzaktivit\u00e4t und verf\u00fcgbare Copy-on-Write-Werte. ","ref":""},{"kind":"code","text":"INFO replication","ref":""},{"kind":"text","text":" zeigt Rolle und Replikationszustand. Erfasse diese Angaben f\u00fcr Primary und Replica getrennt, damit ein Rollenwechsel oder eine Synchronisation bei der Auswertung erkennbar bleibt.","ref":""},{"kind":"citation","text":"","ref":"S3"},{"kind":"citation","text":"","ref":"S5"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Ein einzelner Wert zeigt weder die typische Auslastung noch die notwendige Spitzenreserve. Sammle deshalb Zeitreihen \u00fcber normalen Betrieb, Schreibspitzen und Persistenzl\u00e4ufe und ordne ihnen den gleichzeitig beobachteten Host- oder Containerverbrauch zu. So erkennst du auch, ob ein hoher RSS-Wert eine aktuelle Last begleitet oder nach einer fr\u00fcheren Spitze bestehen bleibt.","ref":""},{"kind":"citation","text":"","ref":"S3"}]}]},{"id":"budget-rechnen","heading":"Ein belastbares Speicherbudget berechnen","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Ausgangspunkt ist die tats\u00e4chlich wirksame ","ref":""},{"kind":"strong","text":"Speichergrenze","ref":""},{"kind":"text","text":": Bei einem Container kann sie niedriger sein als der RAM des Hosts. Ermittle, welche anderen Prozesse und Betriebsanteile dieselbe Grenze beanspruchen. Was ihnen vorbehalten ist, steht Redis nicht f\u00fcr Daten oder Spitzen zur Verf\u00fcgung.","ref":""}]},{"type":"paragraph","runs":[{"kind":"text","text":"Ziehe anschlie\u00dfend Reserven f\u00fcr zus\u00e4tzliche RSS- und Allocator-Effekte, nicht f\u00fcr Eviction gez\u00e4hlte Buffer, Persistenzspitzen und einen Sicherheitsabstand ab. Das Ergebnis ist ein vorl\u00e4ufiges ","ref":""},{"kind":"code","text":"maxmemory","ref":""},{"kind":"text","text":"-Budget, keine Redis-interne Gleichung. Die Reserven m\u00fcssen zur gleichen Grenze und zu realistisch gleichzeitig auftretenden Lastzust\u00e4nden passen.","ref":""},{"kind":"citation","text":"","ref":"S2"},{"kind":"citation","text":"","ref":"S3"},{"kind":"citation","text":"","ref":"S4"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Illustratives Rechenbeispiel, keine Messung: Von einer Containergrenze von 8 GiB werden 0,5 GiB f\u00fcr andere Verbraucher, 0,5 GiB f\u00fcr zus\u00e4tzliche RSS-Effekte, 0,5 GiB f\u00fcr aus der Eviction-Rechnung ausgenommene Buffer, 1 GiB f\u00fcr eine Persistenzspitze und 0,5 GiB Sicherheitsabstand abgezogen. Als vorl\u00e4ufiger Wert bleiben 5 GiB f\u00fcr ","ref":""},{"kind":"code","text":"maxmemory","ref":""},{"kind":"text","text":".","ref":""}]},{"type":"paragraph","runs":[{"kind":"text","text":"Diese Zahlen sind keine Empfehlung f\u00fcr eine konkrete Instanz. Das Beispiel setzt voraus, dass die angesetzten Reserven zus\u00e4tzliche, nicht \u00fcberlappende Beitr\u00e4ge zur Containergrenze beschreiben. Gerade bei einem Persistenzlauf k\u00f6nnen gemeinsame Speicherseiten und Copy-on-Write die Zuordnung erschweren; eine blo\u00dfe Addition der RSS-Werte von Eltern- und Kindprozess w\u00e4re daf\u00fcr ungeeignet.","ref":""},{"kind":"citation","text":"","ref":"S4"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Vermeide ","ref":""},{"kind":"strong","text":"Doppelz\u00e4hlungen","ref":""},{"kind":"text","text":": ","ref":""},{"kind":"code","text":"mem_not_counted_for_evict","ref":""},{"kind":"text","text":" steckt bereits in ","ref":""},{"kind":"code","text":"used_memory","ref":""},{"kind":"text","text":". Wenn du vom beobachteten gesamten RSS oder Containerverbrauch ausgehst, darfst du diesen Bufferanteil nicht ungepr\u00fcft noch einmal addieren. Im verbleibenden Eviction-Budget m\u00fcssen sowohl der Datensatz als auch der mitgez\u00e4hlte Redis-Overhead Platz finden; pr\u00fcfe den Ansatz anschlie\u00dfend unter vergleichbarer Last.","ref":""},{"kind":"citation","text":"","ref":"S2"},{"kind":"citation","text":"","ref":"S3"}]}]},{"id":"eviction-vergleichen","heading":"Eviction-Policies im Praxisvergleich","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Die ","ref":""},{"kind":"strong","text":"Eviction-Policy","ref":""},{"kind":"text","text":" bestimmt, wie Redis bei Speicherknappheit auf schreibende Befehle reagiert. Sie ersetzt keine Kapazit\u00e4tsplanung: Selbst eine passende Policy ben\u00f6tigt Reserven au\u00dferhalb der Eviction-Rechnung. Die Entscheidung h\u00e4ngt vor allem davon ab, welche Schl\u00fcssel verloren gehen d\u00fcrfen und wie die Anwendung auf Fehler reagiert.","ref":""},{"kind":"citation","text":"","ref":"S2"}]},{"type":"table","caption":"Policies nach Einsatzzweck und Verhalten bei Speicherknappheit","headers":["Policy","Typische Eignung","Verlust und Fehlerfall"],"rows":[["noeviction","Daten, die nicht zur Platzgewinnung entfernt werden sollen","Keine Eviction zur Platzgewinnung; speichervergr\u00f6\u00dfernde Schreibbefehle k\u00f6nnen mit OOM scheitern."],["allkeys-lru","Cache mit wiederherstellbaren Daten","Schl\u00fcssel k\u00f6nnen nach n\u00e4herungsweisem LRU entfernt werden; dadurch entstehen Cache-Misses."],["volatile-*","Bestand, bei dem nur Schl\u00fcssel mit Ablaufzeit zur Eviction vorgesehen sind","Nur Schl\u00fcssel mit TTL sind Kandidaten; fehlen geeignete Kandidaten, kann Platz nicht ausreichend freigemacht werden."]],"source_ids":["S2","S6"]},{"type":"paragraph","runs":[{"kind":"text","text":"Bei einem reinen Cache kann ","ref":""},{"kind":"code","text":"allkeys-lru","ref":""},{"kind":"text","text":" passen, wenn sich entfernte Eintr\u00e4ge aus einer anderen Quelle neu aufbauen lassen. LRU ist in Redis eine N\u00e4herung und keine exakte globale Sortierung. H\u00e4ufige Evictions k\u00f6nnen mehr Zugriffe auf das Backend ausl\u00f6sen; deshalb sind nicht nur freie Bytes, sondern auch Cache-Trefferrate und Backend-Kapazit\u00e4t wichtig.","ref":""},{"kind":"citation","text":"","ref":"S2"}]},{"type":"paragraph","runs":[{"kind":"text","text":"F\u00fcr nicht beliebig l\u00f6schbare Daten ist ","ref":""},{"kind":"code","text":"noeviction","ref":""},{"kind":"text","text":" eine andere Entscheidung: Die Anwendung muss fehlgeschlagene Schreibvorg\u00e4nge behandeln k\u00f6nnen, statt stillschweigend mit erfolgreicher Speicherung zu rechnen. Die Policy ist weder Persistenz noch Schutz vor einem OOM auf Betriebssystem- oder Containerebene.","ref":""},{"kind":"citation","text":"","ref":"S6"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Bei gemischten Best\u00e4nden ist die ","ref":""},{"kind":"strong","text":"TTL-Disziplin","ref":""},{"kind":"text","text":" entscheidend: Eine ","ref":""},{"kind":"code","text":"volatile-*","ref":""},{"kind":"text","text":"-Policy kann nur Schl\u00fcssel mit Ablaufzeit ausw\u00e4hlen. Wenn zu wenige geeignete Kandidaten vorhanden sind, sch\u00fctzt eine TTL allein nicht vor Schreibfehlern. Pr\u00fcfe deshalb, ob Cache und wichtige Daten wirklich dieselbe Instanz und Fehlerstrategie teilen sollten.","ref":""},{"kind":"citation","text":"","ref":"S2"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Session-Daten verdeutlichen den Zielkonflikt: Ein entfernter Eintrag kann f\u00fcr Nutzer den Verlust eines Sitzungszustands bedeuten, auch wenn die Anwendung technisch weiterl\u00e4uft. Bewerte die Folgen und Wiederherstellbarkeit vor der Policy-Wahl; zus\u00e4tzliche Grundlagen bietet der Beitrag zum ","ref":""},{"kind":"internal_link","text":"Session-Management mit Redis und anderen Speichern","ref":"I3"},{"kind":"text","text":".","ref":""}]}]}],"3":[{"id":"betrieb-ueberwachen","heading":"Reserve unter Last \u00fcberpr\u00fcfen","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Ein berechneter Wert f\u00fcr ","ref":""},{"kind":"code","text":"maxmemory","ref":""},{"kind":"text","text":" ist zun\u00e4chst ein Ausgangspunkt. Pr\u00fcfe ihn in einer isolierten Umgebung mit vergleichbarer Redis-Version, Datenstruktur und Speichergrenze. Die Last sollte nicht nur den gew\u00f6hnlichen Betrieb abbilden, sondern auch Schreibspitzen und Phasen, in denen Persistenz und Replikation gleichzeitig aktiv sind.","ref":""},{"kind":"citation","text":"","ref":"S4"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Beobachte dabei den ","ref":""},{"kind":"strong","text":"Containerverbrauch","ref":""},{"kind":"text","text":" beziehungsweise die passende Host-Metrik ebenso wie Redis-Speicherwerte. Halte fest, wann ein Snapshot oder AOF-Rewrite l\u00e4uft und ob ein Replica synchronisiert wird. Entscheidend ist, wie viel Abstand zur tats\u00e4chlichen Grenze w\u00e4hrend \u00fcberlappender Ereignisse bleibt, nicht nur im Leerlauf danach.","ref":""},{"kind":"citation","text":"","ref":"S3"},{"kind":"citation","text":"","ref":"S5"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Mit dem lesenden Befehl ","ref":""},{"kind":"code","text":"INFO stats","ref":""},{"kind":"text","text":" erfasst du unter anderem Eviction-Z\u00e4hler. Werte deren \u00c4nderung pro Zeitintervall aus: Ein hoher historischer Stand allein sagt nicht, ob gerade Schl\u00fcssel verdr\u00e4ngt werden. Setze steigende Evictions in Beziehung zu Cache-Treffern und Backend-Last, sofern deine Anwendung diese Gr\u00f6\u00dfen bereitstellt.","ref":""},{"kind":"citation","text":"","ref":"S3"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Erfasse au\u00dferdem Redis-OOM-Antworten in der Anwendung und speicherbedingte Container-Ereignisse auf der Plattform. Beide Fehler k\u00f6nnen bei \u00e4hnlicher Last auftreten, betreffen aber unterschiedliche Grenzen. Eine Alarmierung sollte deshalb sowohl die verf\u00fcgbare Reserve als auch die beobachteten Fehler und deren zeitlichen Verlauf ber\u00fccksichtigen.","ref":""},{"kind":"citation","text":"","ref":"S6"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Wiederhole die Bewertung nach \u00c4nderungen am Datensatz, an der Schreiblast oder an Persistenz und Replikation. Auch eine Promotion ver\u00e4ndert die Rolle eines Replica und damit das zu pr\u00fcfende Lastprofil. Die Ergebnisse aus der isolierten Umgebung ersetzen nicht die fortlaufende Beobachtung der produktiven Instanzen.","ref":""},{"kind":"citation","text":"","ref":"S5"}]}]},{"id":"fehler-diagnose","heading":"Speicherprobleme gezielt eingrenzen","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Steigt der Prozess-RSS, w\u00e4hrend ","ref":""},{"kind":"code","text":"used_memory","ref":""},{"kind":"text","text":" f\u00e4llt, betrachte zuerst den Verlauf und die vorherige Last. Freigegebener Speicher muss nicht sofort an das Betriebssystem zur\u00fcckgehen. Die ","ref":""},{"kind":"strong","text":"Allocator-Metriken","ref":""},{"kind":"text","text":" aus ","ref":""},{"kind":"code","text":"INFO memory","ref":""},{"kind":"text","text":" helfen bei der Einordnung; das Fragmentierungsverh\u00e4ltnis allein beweist weder ein Speicherleck noch dessen Ursache.","ref":""},{"kind":"citation","text":"","ref":"S3"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Pr\u00fcfe anschlie\u00dfend, ob der Anstieg zeitlich mit einem Persistenzlauf oder einer Synchronisierung zusammenf\u00e4llt. Dazu dienen ","ref":""},{"kind":"code","text":"INFO persistence","ref":""},{"kind":"text","text":" und ","ref":""},{"kind":"code","text":"INFO replication","ref":""},{"kind":"text","text":". Ein einzelner Wert f\u00fcr nicht zur Eviction gez\u00e4hlte Buffer beschreibt nur den aktuellen Zustand. F\u00fcr eine Reserve brauchst du Beobachtungen \u00fcber relevante Last- und St\u00f6rungsphasen hinweg.","ref":""},{"kind":"citation","text":"","ref":"S3"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Bei einer ","ref":""},{"kind":"strong","text":"Redis-OOM-Antwort","ref":""},{"kind":"text","text":" pr\u00fcfe die konfigurierte Policy und ob geeignete Schl\u00fcssel f\u00fcr eine Eviction vorhanden sind. Insbesondere kann ein Schreibbefehl scheitern, wenn Redis unter der geltenden Policy keinen ausreichenden Platz freimachen kann. Die Anwendung muss diesen Fehler behandeln, statt einen erfolgreichen Schreibvorgang vorauszusetzen.","ref":""},{"kind":"citation","text":"","ref":"S6"},{"kind":"citation","text":"","ref":"S2"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Bei einem speicherbedingten Container-Abbruch untersuche dagegen die Plattformereignisse und den Verbrauch gegen\u00fcber dem Containerlimit. Beziehe Persistenzspitzen und andere im Container erfasste Verbraucher ein. Ein Redis-OOM und ein Container-OOM sind nicht gleichzusetzen: Auch ohne eine vorherige Redis-OOM-Antwort kann die \u00e4u\u00dfere Speichergrenze erreicht werden.","ref":""},{"kind":"citation","text":"","ref":"S3"}]},{"type":"paragraph","runs":[{"kind":"code","text":"maxmemory-clients","ref":""},{"kind":"text","text":" kann zus\u00e4tzlich den von Clients belegten Speicher begrenzen. \u00dcberschreitet der relevante Client-Speicher die konfigurierte Schwelle, kann Redis Clients mit hohem Verbrauch trennen; Anwendungen m\u00fcssen mit Verbindungsabbr\u00fcchen umgehen. Die Einstellung begrenzt nicht s\u00e4mtliche Replikationsverbindungen und ersetzt weder das Gesamtbudget noch die Beobachtung von Pufferspitzen.","ref":""},{"kind":"citation","text":"","ref":"S7"}]}]},{"id":"hosting-entscheidung","heading":"Redis Hosting und Architektur abw\u00e4gen","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Reicht die beobachtete Reserve bei repr\u00e4sentativer Last nicht aus, kann mehr RAM sinnvoll sein, wenn Datensatz und Last grunds\u00e4tzlich auf einer Instanz bleiben sollen. Die zus\u00e4tzliche Kapazit\u00e4t muss jedoch zur tats\u00e4chlich wirksamen Host- oder Containergrenze geh\u00f6ren. Ein gr\u00f6\u00dferes Redis-Limit allein schafft keinen zus\u00e4tzlichen physischen Speicher.","ref":""},{"kind":"citation","text":"","ref":"S4"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Alternativ kann eine ","ref":""},{"kind":"strong","text":"Lastverteilung","ref":""},{"kind":"text","text":" den Speicherbedarf und die Schreibarbeit auf mehrere Instanzen verteilen. Das erfordert eine passende Aufteilung der Daten und eine eigene Budgetierung f\u00fcr jede beteiligte Instanz. Replikate sind dabei nicht mit einer Aufteilung des Datenbestands gleichzusetzen: Sie halten grunds\u00e4tzlich eine Kopie und ben\u00f6tigen daf\u00fcr eigenes RAM.","ref":""},{"kind":"citation","text":"","ref":"S5"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Auch eine Architektur\u00e4nderung kann helfen, etwa die Trennung eines verlusttoleranten Caches von Daten mit strengeren Anforderungen. Dadurch lassen sich Policies und Kapazit\u00e4ten unabh\u00e4ngig w\u00e4hlen. Weder diese Trennung noch mehr RAM oder Lastverteilung garantiert allerdings, dass Persistenz-, Replikations- und Schreibspitzen k\u00fcnftig ausbleiben.","ref":""}]},{"type":"paragraph","runs":[{"kind":"text","text":"Beim Vergleich von ","ref":""},{"kind":"strong","text":"Anbietergrenzen","ref":""},{"kind":"text","text":" kl\u00e4re, ob der ausgewiesene Wert ein Containerlimit, ein Instanzlimit oder ein anders definiertes Datenbanklimit bezeichnet. Frage au\u00dferdem, welche Metriken und Diagnosebefehle zug\u00e4nglich sind, ob Replikate im gebuchten Speicher enthalten sind und wie sich eine Promotion auf die verf\u00fcgbaren Ressourcen auswirkt.","ref":""}]},{"type":"paragraph","runs":[{"kind":"text","text":"Redis Open Source, Redis Software und Redis Cloud sind getrennt zu betrachten. Bei Redis Software gilt das dokumentierte Datenbanklimit \u00fcber Primary- und Replica-Shards hinweg; daraus folgt keine entsprechende Regel f\u00fcr eine einzelne Redis-OSS-Instanz. F\u00fcr Redis Cloud und andere Hosting-Angebote pr\u00fcfst du die jeweils konkreten Produktbedingungen, statt diese Definition ungepr\u00fcft zu \u00fcbertragen.","ref":""},{"kind":"citation","text":"","ref":"S1"}]}]}]},"plan":{"reader_question":"Wie gro\u00df darf Redis maxmemory sein, damit Daten, Replikation, Clients und Persistenz auch unter Last innerhalb der verf\u00fcgbaren Speichergrenze bleiben?","sections":[{"id":"maxmemory-grundlagen","heading":"Was maxmemory tats\u00e4chlich begrenzt","part":1,"target_words":270,"purpose":"Die Eviction-Schwelle von einer harten Prozess- oder Containergrenze abgrenzen. In kurzen Abs\u00e4tzen erkl\u00e4ren, dass used_memory auch Redis-Overhead enth\u00e4lt, mem_not_counted_for_evict darin enthalten und bei der Eviction-Pr\u00fcfung ausgenommen ist. Ein gro\u00dfer Befehl kann die Schwelle vor\u00fcbergehend \u00fcberschreiten; nicht alle Client- und Replikationsbereiche pauschal ausnehmen.","source_ids":["S2","S3"],"internal_link_ids":[]},{"id":"rss-und-persistenz","heading":"RSS, Allocator und Persistenzspitzen","part":1,"target_words":270,"purpose":"Anhand eines Lastspitzen-Beispiels used_memory und Prozess-RSS unterscheiden und erkl\u00e4ren, warum freigegebener Speicher im RSS verbleiben kann. Fragmentierungsverh\u00e4ltnis nicht als reinen Prozentsatz behandeln. Fork und Copy-on-Write bei RDB und AOF erl\u00e4utern; das m\u00f6gliche Extrem bis zum Doppelten als Warnung statt allgemeiner Formel einordnen und gemeinsame Speicherseiten beachten.","source_ids":["S3","S4"],"internal_link_ids":[]},{"id":"replikation-speicher","heading":"Replikate brauchen eigene Budgets","part":1,"target_words":270,"purpose":"Primary und Replica als getrennte Speicherverbraucher erkl\u00e4ren: Datenkopie, abweichende Puffer und standardm\u00e4\u00dfig vom Primary gesteuerte Evictions. Promotion als eigenes Kapazit\u00e4tsszenario einf\u00fchren. Redis 7.0 und den geteilten Speicher von Backlog und Replica-Buffern nennen; mem_clients_slaves nicht isoliert deuten oder Bereiche doppelt addieren.","source_ids":["S3","S5"],"internal_link_ids":["I1"]},{"id":"metriken-erfassen","heading":"Speicher auf drei Ebenen erfassen","part":2,"target_words":270,"purpose":"Eine informative Tabelle zu used_memory, used_memory_rss, mem_not_counted_for_evict und Host- oder Containerverbrauch planen: Bedeutung, Beobachtungsebene und Interpretationsgrenze. Anschlie\u00dfend lesende Befehle INFO memory, INFO persistence, INFO replication und MEMORY STATS sowie versions- und angebotsabh\u00e4ngige Felder einordnen. Zeitreihen und repr\u00e4sentative Lastphasen statt einzelner Werte betonen.","source_ids":["S3","S5"],"internal_link_ids":[]},{"id":"budget-rechnen","heading":"Ein belastbares Speicherbudget berechnen","part":2,"target_words":280,"purpose":"Schrittweise von der tats\u00e4chlichen Grenze \u00fcber andere Verbraucher, zus\u00e4tzliche RSS-Effekte, nicht f\u00fcr Eviction gez\u00e4hlte Buffer, Persistenzspitzen und Sicherheitsabstand zu einem vorl\u00e4ufigen maxmemory gelangen. Ein ausdr\u00fccklich illustratives Zahlenbeispiel ohne Messbehauptung planen. Einheitliche Bezugsgr\u00f6\u00dfen, \u00dcberschneidungen und den Platz f\u00fcr Datensatz samt Redis-Overhead innerhalb des Budgets erkl\u00e4ren.","source_ids":["S2","S3","S4"],"internal_link_ids":[]},{"id":"eviction-vergleichen","heading":"Eviction-Policies im Praxisvergleich","part":2,"target_words":270,"purpose":"Eine Vergleichstabelle f\u00fcr noeviction, allkeys-lru und volatile-* mit Eignung, Verlustverhalten und Fehlerfall vorsehen. Cache, wichtige Daten und gemischten Bestand anhand konkreter Folgen unterscheiden; begrenzte TTL-Kandidaten und n\u00e4herungsweises LRU erl\u00e4utern. Session-Daten als Beispiel f\u00fcr bewusst zu bewertende Verlustfolgen einordnen.","source_ids":["S2","S6"],"internal_link_ids":["I3"]},{"id":"betrieb-ueberwachen","heading":"Reserve unter Last \u00fcberpr\u00fcfen","part":3,"target_words":270,"purpose":"Einen Ablauf f\u00fcr isolierte Tests unter vergleichbarer Last und anschlie\u00dfendes Monitoring planen: normale und gleichzeitige Schreib-, Persistenz- und Replikationsspitzen beobachten. INFO stats und Z\u00e4hler\u00e4nderungen mit Containerverbrauch, Evictions und OOM-Fehlern verkn\u00fcpfen. Kein Test als durchgef\u00fchrt darstellen; nach Last- und Rollen\u00e4nderungen neu dimensionieren.","source_ids":["S3","S4","S5","S6"],"internal_link_ids":[]},{"id":"fehler-diagnose","heading":"Speicherprobleme gezielt eingrenzen","part":3,"target_words":270,"purpose":"Eine Diagnosefolge f\u00fcr steigendes RSS, Redis-OOM und Container-OOM anhand von Verlauf, Allocator-Feldern, Persistenz und Replikation skizzieren. Einzelne Bufferwerte nicht als Spitzenreserve interpretieren. maxmemory-clients als gesonderten Schutz mit m\u00f6glichen Client-Trennungen erkl\u00e4ren, nicht als umfassende Begrenzung aller Replikationsverbindungen.","source_ids":["S3","S6","S7"],"internal_link_ids":[]},{"id":"hosting-entscheidung","heading":"Redis Hosting und Architektur abw\u00e4gen","part":3,"target_words":260,"purpose":"Abschlie\u00dfend Entscheidungskriterien f\u00fcr mehr RAM, Lastverteilung oder Architektur\u00e4nderungen gegen\u00fcberstellen, ohne Spitzenfreiheit zu versprechen. Anbietergrenzen, Metrikzugang und Einbeziehung von Replikaten pr\u00fcfen; Redis OSS, Redis Software und Redis Cloud ausdr\u00fccklich trennen. Das \u00fcber Primary- und Replica-Shards geltende Software-Datenbanklimit nicht auf OSS \u00fcbertragen.","source_ids":["S1","S4","S5"],"internal_link_ids":[]}]},"repairs":0,"reviews":1,"issues":[],"guard":{"content_md5":"9185ebad95cda99cf462486ef30cb309","title":"Sizing Redis `maxmemory` Correctly: Memory Reserves for Data and Operations","slug":"sizing-redis-maxmemory-correctly","excerpt":"Redis `maxmemory` is not a hard RAM limit. Learn how to factor in data, replication, persistence spikes, and container limits when planning your storage.","status":"draft","featured_media":22166},"verify":{"content_md5":"9185ebad95cda99cf462486ef30cb309","title":"Sizing Redis `maxmemory` Correctly: Memory Reserves for Data and Operations","slug":"sizing-redis-maxmemory-correctly","excerpt":"Redis `maxmemory` is not a hard RAM limit. Learn how to factor in data, replication, persistence spikes, and container limits when planning your storage.","status":"draft","featured_media":22166},"row_number":1937,"created_at":"2026-11-04T13:41:49+00:00","editorial_policy":{"version":"2.1.6","max_repairs":4,"review_model_from_attempt":2},"updated_at":"2026-11-04T13:46:43+00:00","verified_at":"2026-11-04T13:46:27+00:00"},"_wh_make_research":"# Recherchebriefing: Redis maxmemory richtig dimensionieren\n\nRecherchestand: 4. November 2026  \nGeplanter Umfang des Fachartikels: 2.400\u20132.700 W\u00f6rter\n\n## Leserfrage und Ziel\n\nWie gro\u00df darf `maxmemory` bei einer Redis-Instanz sein, damit Daten, Replikation, Clients und Persistenz auch unter Last gen\u00fcgend Speicher haben? Der Artikel soll zeigen, warum der Wert weder dem verf\u00fcgbaren RAM noch der reinen Nutzdatengr\u00f6\u00dfe entspricht und wie sich ein belastbares Budget aus Beobachtungen ableiten l\u00e4sst.\n\nZielgruppe sind Administratoren und Entwickler mit Grundkenntnissen in Redis und Linux. Vorausgesetzt werden Zugang zu lesenden Redis-Diagnosebefehlen und zu Metriken des Hosts beziehungsweise Containers. Der Schwerpunkt liegt auf Redis Open Source. Redis Software, Redis Cloud und Angebote f\u00fcr Redis Hosting m\u00fcssen getrennt betrachtet werden: Deren Speicherlimits und administrative M\u00f6glichkeiten k\u00f6nnen anders definiert sein. ([redis.io](https:\/\/redis.io\/docs\/latest\/operate\/rs\/databases\/memory-performance\/memory-limit\/?utm_source=openai))\n\n## Gesicherte Funktionsweise\n\n### Was `maxmemory` tats\u00e4chlich begrenzt\n\n`maxmemory` ist ein Schwellenwert f\u00fcr die Redis-Speichersteuerung, keine harte Obergrenze f\u00fcr den gesamten Prozess- oder Containerverbrauch. Bei speichervergr\u00f6\u00dfernden Befehlen pr\u00fcft Redis den Verbrauch und versucht gegebenenfalls, entsprechend der Eviction-Policy Schl\u00fcssel zu entfernen. Ein einzelner gro\u00dfer Befehl kann die Schwelle vor\u00fcbergehend deutlich \u00fcberschreiten. ([redis.io](https:\/\/redis.io\/docs\/latest\/develop\/reference\/eviction\/?utm_source=openai))\n\nF\u00fcr die Eviction werden bestimmte Speicheranteile nicht mitgerechnet. Dazu geh\u00f6ren insbesondere tempor\u00e4re Replikations- und AOF-Puffer. Redis weist ihren aktuellen Umfang mit `mem_not_counted_for_evict` aus. Dieser Wert schwankt; ein einzelner Messpunkt ist deshalb keine sichere Reservesch\u00e4tzung. Nicht alle Replikations- oder Client-Speicherbereiche d\u00fcrfen pauschal als \u201eau\u00dferhalb von maxmemory\u201c bezeichnet werden. ([redis.io](https:\/\/redis.io\/docs\/latest\/develop\/reference\/eviction\/?utm_source=openai))\n\nDie wichtige Abgrenzung f\u00fcr den Artikel:\n\n- `used_memory` beschreibt von Redis \u00fcber den Allocator belegten Speicher, nicht nur Nutzdaten.\n- `used_memory_rss` beschreibt den residenten Speicher des Redis-Prozesses aus Betriebssystemsicht.\n- `mem_not_counted_for_evict` ist ein in `used_memory` enthaltener Anteil, der f\u00fcr die Eviction-Pr\u00fcfung nicht ber\u00fccksichtigt wird.\n- Host- oder Containergrenzen betreffen mehr als die Eviction-Rechnung und gegebenenfalls mehr als den Redis-Hauptprozess. ([redis.io](https:\/\/redis.io\/docs\/latest\/commands\/info\/?utm_source=openai))\n\n### Warum RSS und Persistenz Reserve ben\u00f6tigen\n\nFreigegebener Redis-Speicher wird nicht zwingend sofort an das Betriebssystem zur\u00fcckgegeben. Nach Lastspitzen kann RSS deshalb hoch bleiben, obwohl `used_memory` gesunken ist. Das Verh\u00e4ltnis `mem_fragmentation_ratio` umfasst neben Fragmentierung auch weitere Prozessanteile; es ist kein reiner Fragmentierungsprozentsatz. F\u00fcr eine Diagnose geh\u00f6ren Verlauf, `allocator_*`-Metriken und Lastgeschichte zusammen. ([redis.io](https:\/\/redis.io\/docs\/latest\/commands\/info\/?utm_source=openai))\n\nBei RDB-Snapshots und AOF-Rewrites nutzt Redis einen Kindprozess und Copy-on-Write. Werden w\u00e4hrenddessen viele Speicherseiten ver\u00e4ndert, steigt der tats\u00e4chliche Speicherbedarf. Die Redis-Administration nennt f\u00fcr schreibintensive Anwendungen im Extrem bis zum Doppelten des normalerweise genutzten Speichers. Das ist eine Warnung f\u00fcr die Kapazit\u00e4tsplanung, kein pauschaler Multiplikator f\u00fcr jeden Betrieb. Prozess-RSS-Werte von Eltern- und Kindprozess d\u00fcrfen wegen gemeinsam genutzter Seiten nicht einfach addiert werden; f\u00fcr die Grenze ist die passende Host- oder Containerbeobachtung entscheidend. ([redis.io](https:\/\/redis.io\/docs\/latest\/operate\/oss_and_stack\/management\/admin\/?utm_source=openai))\n\n### Replikation gesondert planen\n\nEin Replica h\u00e4lt grunds\u00e4tzlich eine Kopie des Datenbestands und ben\u00f6tigt daher eigenes RAM. Standardm\u00e4\u00dfig ignoriert ein Replica `maxmemory` f\u00fcr eigene Evictions; der Primary entscheidet \u00fcber Evictions und repliziert die L\u00f6schungen. Ein Replica kann dennoch mehr Speicher als sein konfigurierter Wert ben\u00f6tigen, etwa durch unterschiedliche Buffer oder Datenstrukturen. Nach einer Promotion \u00e4ndert sich seine Rolle: Die Dimensionierung muss auch den Betrieb als Primary ber\u00fccksichtigen. ([redis.io](https:\/\/redis.io\/docs\/latest\/operate\/oss_and_stack\/management\/replication\/?utm_source=openai))\n\nSeit Redis 7.0 teilen Replica-Buffer Speicher mit dem Replikations-Backlog. `mem_clients_slaves` kann daher null anzeigen, ohne dass Replikation keinen Speicher verbraucht. Backlog und Replica-Buffer nicht anhand einzelner Felder doppelt addieren. ([redis.io](https:\/\/redis.io\/docs\/latest\/commands\/info\/?utm_source=openai))\n\n## Dimensionierung als Arbeitsmodell\n\nF\u00fcr jede Instanz beziehungsweise jeden Container zuerst die tats\u00e4chlich verf\u00fcgbare Speichergrenze bestimmen. Davon werden Reserven f\u00fcr andere Prozesse und Betriebssystemanteile, zus\u00e4tzliche RSS-\/Allocator-Effekte, nicht f\u00fcr Eviction gez\u00e4hlte Buffer, Persistenzspitzen und Sicherheitsabstand abgeleitet. \u00dcbrig bleibt ein vorl\u00e4ufiges `maxmemory`-Budget.\n\nDiese Rechnung ist ein Planungsmodell, keine Redis-interne Gleichung. Komponenten m\u00fcssen auf derselben Bezugsgr\u00f6\u00dfe beruhen und d\u00fcrfen nicht doppelt gez\u00e4hlt werden. Insbesondere ist `mem_not_counted_for_evict` bereits Teil von `used_memory`; wer mit dem beobachteten gesamten RSS oder Containerverbrauch rechnet, darf ihn nicht nochmals ungepr\u00fcft addieren. Gleichzeitig muss das resultierende Budget gen\u00fcgend Platz f\u00fcr Datensatz und Redis-Overhead innerhalb der Eviction-Rechnung lassen. ([redis.io](https:\/\/redis.io\/docs\/latest\/commands\/info\/?utm_source=openai))\n\nSinnvolle Vorgehensweise f\u00fcr den Artikel:\n\n1. Host-, Container- und Anbietergrenzen sowie andere Verbraucher erfassen.\n2. \u00dcber repr\u00e4sentative Zeitr\u00e4ume Normalbetrieb, Schreibspitzen und Persistenzl\u00e4ufe beobachten.\n3. Primary und jedes Replica separat auswerten; Failover-Szenario einbeziehen.\n4. Einen vorl\u00e4ufigen Wert mit Reserve festlegen und in einer isolierten Testumgebung unter vergleichbarer Last pr\u00fcfen.\n5. Auslastung, Evictions, OOM-Fehler und tats\u00e4chlichen Speicherverbrauch dauerhaft \u00fcberwachen und das Budget nach Last\u00e4nderungen neu bewerten.\n\n## Relevante Praxisf\u00e4lle und Entscheidungen\n\n**Reiner Cache:** Sind alle Daten aus einer anderen Quelle wiederherstellbar, kann `allkeys-lru` eine passende Wahl sein. Evictions sind dann Teil des Betriebs; steigende Evictions k\u00f6nnen aber Cache-Trefferrate und Backend-Last verschlechtern. LRU und LFU arbeiten n\u00e4herungsweise, nicht als exakte globale Sortierung. ([redis.io](https:\/\/redis.io\/docs\/latest\/develop\/reference\/eviction\/?utm_source=openai))\n\n**Nicht beliebig l\u00f6schbare Daten:** Bei `noeviction` entfernt Redis keine Schl\u00fcssel, um Platz zu schaffen. Speichervergr\u00f6\u00dfernde Schreibbefehle k\u00f6nnen mit OOM-Fehlern scheitern; die Anwendung braucht daf\u00fcr eine Fehlerstrategie. `noeviction` ist weder Persistenz noch eine Garantie gegen Betriebssystem-OOM. ([redis.io](https:\/\/redis.io\/docs\/latest\/develop\/reference\/errors\/common\/oom\/?utm_source=openai))\n\n**Gemischter Datenbestand:** `volatile-*`-Policies w\u00e4hlen nur Schl\u00fcssel mit Ablaufzeit aus. Gibt es keine geeigneten Schl\u00fcssel mehr, kann Redis wie bei `noeviction` keine ausreichende Kapazit\u00e4t freimachen. Ob eine gemeinsame Instanz f\u00fcr Cache und wichtige Daten sinnvoll ist, h\u00e4ngt daher auch von TTL-Disziplin und Fehlertoleranz ab. ([redis.io](https:\/\/redis.io\/docs\/latest\/develop\/reference\/eviction\/?utm_source=openai))\n\n**Schreiblast mit Persistenz und Replikation:** Hier m\u00fcssen Buffer-Schwankungen und Copy-on-Write-Spitzen gemeinsam in realistischen Zeitfenstern betrachtet werden. Als Alternative zu einer gr\u00f6\u00dferen Reserve kommen mehr RAM, Lastverteilung oder eine Anpassung der Architektur infrage; keine Ma\u00dfnahme beseitigt automatisch alle Spitzen. ([redis.io](https:\/\/redis.io\/docs\/latest\/operate\/oss_and_stack\/management\/admin\/?utm_source=openai))\n\n**Redis Hosting:** Pr\u00fcfen, ob der Anbieter eine Instanzgrenze, Containergrenze oder ein anders definiertes Datenbanklimit ausweist, welche Metriken verf\u00fcgbar sind und ob Replikate im gebuchten Speicher enthalten sind. Redis-Software-Datenbanklimits beispielsweise gelten \u00fcber Primary- und Replica-Shards hinweg; das darf nicht ungepr\u00fcft auf Redis OSS \u00fcbertragen werden. ([redis.io](https:\/\/redis.io\/docs\/latest\/operate\/rs\/databases\/memory-performance\/memory-limit\/?utm_source=openai))\n\n## Sichere Diagnosebeispiele\n\nDie folgenden Beispiele sind lesend; sie ver\u00e4ndern keine Konfiguration. Ausgabe und verf\u00fcgbare Felder h\u00e4ngen von Version, Berechtigungen und Hosting-Angebot ab.\n\nRedis-CLI: `INFO memory`  \nF\u00fcr `used_memory`, `used_memory_rss`, `maxmemory`, `maxmemory_policy` und `mem_not_counted_for_evict`.\n\nRedis-CLI: `INFO stats`  \nF\u00fcr Betriebsz\u00e4hler wie Evictions; \u00c4nderungen \u00fcber die Zeit sind aussagekr\u00e4ftiger als ein isolierter Z\u00e4hlerstand.\n\nRedis-CLI: `INFO persistence`  \nZur Einordnung von Persistenzaktivit\u00e4t und verf\u00fcgbaren Copy-on-Write-Metriken.\n\nRedis-CLI: `INFO replication`  \nZur Pr\u00fcfung der Rolle und des Replikationszustands.\n\nRedis-CLI: `MEMORY STATS`  \nF\u00fcr zus\u00e4tzliche Einblicke in die Speicherverteilung. Die Interpretation der Felder muss zur eingesetzten Version passen. ([redis.io](https:\/\/redis.io\/docs\/latest\/commands\/info\/?utm_source=openai))\n\nBei vielen Clients kann `maxmemory-clients` als separate Schutzma\u00dfnahme relevant sein: Redis kann dann Clients mit hohem Speicherverbrauch trennen. Das ist keine Begrenzung f\u00fcr alle Replikationsverbindungen und ersetzt keine Gesamtbudgetierung. ([redis.io](https:\/\/redis.io\/docs\/latest\/develop\/reference\/clients\/?utm_source=openai))\n\n## Typische Fehler und Tabellenplanung\n\nEine Tabelle sollte die Metriken, ihre Bedeutung, ihre Grenzen und die jeweils passende Beobachtungsebene gegen\u00fcberstellen: Redis-Allocator, Prozess-RSS sowie Host oder Container. Eine zweite Tabelle kann `noeviction`, `allkeys-lru` und eine `volatile-*`-Policy anhand von Eignung, Verlustverhalten und Fehlerfall vergleichen.\n\nZu vermeiden sind insbesondere:\n\n- `maxmemory` auf das gesamte Containerlimit setzen.\n- `used_memory` mit reinen Nutzdaten gleichsetzen.\n- Einen aktuellen Bufferwert als dauerhaften Spitzenwert verwenden.\n- Fragmentierungsquote oder Copy-on-Write pauschal als festen Prozentsatz annehmen.\n- Replikate und Failover nicht separat dimensionieren.\n- `volatile-*` w\u00e4hlen, ohne ausreichend Schl\u00fcssel mit TTL zu haben.\n- Redis OSS, Redis Software und Hosting-Grenzen vermischen.\n\nEin Chart ist auf Basis dieser Recherche nicht erforderlich: Es liegen keine geeigneten workloadbezogenen Messreihen vor. Falls sp\u00e4ter ein Zahlenbeispiel erg\u00e4nzt wird, muss es ausdr\u00fccklich als illustrativ und nicht als Messung gekennzeichnet sein.\n\n## Quelldokumente f\u00fcr die sp\u00e4tere Ausarbeitung\n\n- Redis-Dokumentation, \u201eKey eviction\u201c: Schwelle, Buffer und Policies. ([redis.io](https:\/\/redis.io\/docs\/latest\/develop\/reference\/eviction\/?utm_source=openai))\n- Redis-Befehlsreferenz, \u201eINFO\u201c: Definition und Versionshinweise der Speicherfelder. ([redis.io](https:\/\/redis.io\/docs\/latest\/commands\/info\/?utm_source=openai))\n- Redis-Dokumentation, \u201eRedis replication\u201c: Replica-Verhalten und `maxmemory`. ([redis.io](https:\/\/redis.io\/docs\/latest\/operate\/oss_and_stack\/management\/replication\/?utm_source=openai))\n- Redis-Dokumentation, \u201eRedis administration\u201c und \u201eRedis persistence\u201c: Speicherreserve, Fork und Copy-on-Write. ([redis.io](https:\/\/redis.io\/docs\/latest\/operate\/oss_and_stack\/management\/admin\/?utm_source=openai))\n\nF\u00fcr den Folgeartikel sollten die tats\u00e4chlich eingesetzte Redis-Version und die Anbietergrenzen nochmals konkret gepr\u00fcft werden. Es wurden keine bestehenden S- oder I-Kennungen mitgeliefert; daher werden hier keine erfunden.","_wh_make_sources":{"S1":{"id":"S1","url":"https:\/\/redis.io\/docs\/latest\/operate\/rs\/databases\/memory-performance\/memory-limit\/?utm_source=openai","title":"Database Memory Limits | Docs"},"S2":{"id":"S2","url":"https:\/\/redis.io\/docs\/latest\/develop\/reference\/eviction\/?utm_source=openai","title":"Key Eviction | Docs"},"S3":{"id":"S3","url":"https:\/\/redis.io\/docs\/latest\/commands\/info\/?utm_source=openai","title":"INFO | Docs"},"S4":{"id":"S4","url":"https:\/\/redis.io\/docs\/latest\/operate\/oss_and_stack\/management\/admin\/?utm_source=openai","title":"Redis Administration | Docs"},"S5":{"id":"S5","url":"https:\/\/redis.io\/docs\/latest\/operate\/oss_and_stack\/management\/replication\/?utm_source=openai","title":"Redis Replication | Docs"},"S6":{"id":"S6","url":"https:\/\/redis.io\/docs\/latest\/develop\/reference\/errors\/common\/oom\/?utm_source=openai","title":"OOM error | Docs"},"S7":{"id":"S7","url":"https:\/\/redis.io\/docs\/latest\/develop\/reference\/clients\/?utm_source=openai","title":"Redis Client Handling | Docs"}},"_wh_make_usage":{"research":{"input_tokens":13202,"output_tokens":2662,"response_id":"resp_0477cf8546c3325b016aeb361fbf2087d2a37241280dfd8478","model":"gpt-6.1-terra","search_calls":1},"plan_56a538c4b74c5f95a41bc250d37cbf22":{"input_tokens":5783,"output_tokens":1203,"response_id":"resp_0e7a3fa2e1c42137016aeb36476aec87d2b4c4667932c83f07","model":"gpt-6.1-terra","search_calls":0},"part1_705a7dfceba1d20df0f23b9fd2ae4a0c":{"input_tokens":8201,"output_tokens":1923,"response_id":"resp_0bc3f07cf1a8f493016aeb36595bd487d2827ee38c8f05879b","model":"gpt-6.1-terra","search_calls":0},"part2_b135231ad0c155adefc805c017852707":{"input_tokens":8225,"output_tokens":2260,"response_id":"resp_05d2c49f94323075016aeb3674b4b087d2917adeb784fefbd9","model":"gpt-6.1-terra","search_calls":0},"part3_53003776155a329a5e0f6f11290878cb":{"input_tokens":8222,"output_tokens":1852,"response_id":"resp_0503a8e3a6ebef82016aeb3690917087d2a078154aa4bb1e0c","model":"gpt-6.1-terra","search_calls":0},"package_8a16a91cd2f5131ca4c9353d525810d4":{"input_tokens":15729,"output_tokens":1660,"response_id":"resp_0fedc2bfbf6dc272016aeb36afcbd087d2b8414f8ff3d2af49","model":"gpt-6.1-terra","search_calls":0},"review_afcdaa6816fc080ec4fc305a2d31d891":{"input_tokens":34638,"output_tokens":595,"response_id":"resp_03f06b524515eecf016aeb36c6a09087d2a26a9f97cb56a45e","model":"gpt-6.1-sol","search_calls":3},"image_hero":{"input_tokens":190,"output_tokens":1372,"response_id":"","model":"gpt-image-2.5-flare","search_calls":0},"image_detail1":{"input_tokens":169,"output_tokens":1372,"response_id":"","model":"gpt-image-2.5-flare","search_calls":0},"image_detail2":{"input_tokens":175,"output_tokens":1372,"response_id":"","model":"gpt-image-2.5-flare","search_calls":0}},"_wh_make_last_error":"","_wh_make_write_intent":{"before":{"content_md5":"2bd8a87de070ea1b93a15bc536191e5f","title":"Sizing Redis `maxmemory` Correctly: Memory Reserves for Data and Operations","slug":"sizing-redis-maxmemory-correctly","excerpt":"Redis `maxmemory` is not a hard RAM limit. Learn how to factor in data, replication, persistence spikes, and container limits when planning your storage.","status":"draft","featured_media":0},"expected":{"content_md5":"9185ebad95cda99cf462486ef30cb309","title":"Sizing Redis `maxmemory` Correctly: Memory Reserves for Data and Operations","slug":"sizing-redis-maxmemory-correctly","excerpt":"Redis `maxmemory` is not a hard RAM limit. Learn how to factor in data, replication, persistence spikes, and container limits when planning your storage.","status":"draft","featured_media":22166},"at":"2026-11-04T13:46:15+00:00"},"_wh_make_design_version":"2.1.19","rank_math_title":"Redis maxmemory richtig dimensionieren","_wh_make_doc":{"title":"Sizing Redis `maxmemory` Correctly: Memory Reserves for Data and Operations","slug":"sizing-redis-maxmemory-correctly","excerpt":"Redis `maxmemory` is not a hard RAM limit. Learn how to factor in data, replication, persistence spikes, and container limits when planning your storage.","seo":{"title":"Sizing Redis maxmemory Correctly","description":"Planning Redis maxmemory with a buffer: Understanding memory values, accounting for replicas, and checking for persistence spikes under load.","focus_keyword":"redis maxmemory"},"lead":[{"kind":"text","text":"Setze ","ref":""},{"kind":"code","text":"maxmemory","ref":""},{"kind":"text","text":" nicht mit dem verf\u00fcgbaren RAM gleich: Der Wert steuert die Eviction, begrenzt aber nicht den gesamten Prozess- oder Containerverbrauch. Plane neben Daten und Redis-Overhead auch Platz f\u00fcr Buffer, Allocator-Effekte und Persistenzspitzen ein. ","ref":""},{"kind":"citation","text":"","ref":"S2"},{"kind":"text","text":"Ein belastbarer Ausgangswert entsteht aus der ","ref":""},{"kind":"strong","text":"tats\u00e4chlichen Speichergrenze","ref":""},{"kind":"text","text":" und Verbrauchsverl\u00e4ufen unter repr\u00e4sentativer Last. Werte Primary und Replikate getrennt aus und \u00fcberpr\u00fcfe das Budget auch f\u00fcr einen m\u00f6glichen Rollenwechsel.","ref":""},{"kind":"citation","text":"","ref":"S5"}],"images":{"hero":{"prompt":"Sachliche redaktionelle Illustration zur Redis-Speicherplanung: Auf einer dunklen, matten Fl\u00e4che verlaufen zwei ungleich gro\u00dfe, ineinanderliegende geschlossene Konturen. Die innere Kontur steht sinnbildlich f\u00fcr die Eviction-Schwelle, der Raum bis zur \u00e4u\u00dferen Kontur f\u00fcr zus\u00e4tzlich ben\u00f6tigte Speicherreserve. Einige flache, unterschiedlich strukturierte Farbfl\u00e4chen \u00fcberlagern die innere Grenze und machen deutlich, dass beide Grenzen nicht identisch sind. Grafische Ansicht direkt von oben, reduzierte Formen in gedecktem Rostrot, Creme und Anthrazit, keine r\u00e4umlichen Beh\u00e4lter, keine Menschen. Keine Texte, Zahlen, Logos, Messwerte oder Wasserzeichen.","alt":"KI-generierte Illustration zweier ineinanderliegender Grenzen als Sinnbild f\u00fcr Eviction-Schwelle und Speicherreserve.","caption":"KI-generierte Illustration: Die Eviction-Schwelle l\u00e4sst sich nicht mit der \u00e4u\u00dferen Speichergrenze gleichsetzen.","filename_base":"redis-maxmemory-speichergrenzen-illustration","section_id":"","after_block":0},"detail1":{"prompt":"Fotografisches KI-generiertes Symbolbild zur physischen RAM-Kapazit\u00e4t: Ein einzelnes ausgebautes Arbeitsspeichermodul liegt schr\u00e4g auf einer leicht gebrauchten antistatischen Unterlage an einem schlichten Werkstattplatz. Nahaufnahme aus niedriger seitlicher Perspektive, Leiterplatte und Speicherchips plausibel erkennbar, ohne bestimmte Marke oder Produktvariante zu behaupten. Nat\u00fcrliches seitliches Tageslicht, matte Materialien und kleine Alltagsspuren, keine Menschen und keine Hochglanzbeleuchtung. Keine lesbaren Beschriftungen, Zahlen, Logos oder Wasserzeichen.","alt":"KI-generiertes Symbolbild eines ausgebauten RAM-Moduls auf einer antistatischen Unterlage.","caption":"KI-generiertes Symbolbild: Physischer Arbeitsspeicher bildet die Grundlage, ersetzt aber nicht die Planung von Persistenzreserven.","filename_base":"redis-persistenz-ram-reserve","section_id":"rss-und-persistenz","after_block":4},"detail2":{"prompt":"Sachliche redaktionelle Illustration zur Redis-Replikation: Zwei getrennte, unterschiedlich gro\u00dfe matte Rechteckfl\u00e4chen liegen nebeneinander auf hellem Hintergrund. In jeder Fl\u00e4che befindet sich eine \u00e4hnliche Gruppe kleiner geometrischer Formen als Sinnbild f\u00fcr kopierte Daten; weitere ungleiche Formen stehen f\u00fcr den jeweils eigenen Betriebsbedarf. Eine schlichte Verbindung zwischen den Fl\u00e4chen deutet die Replikation an, ohne einen exakten Speicherverbrauch oder eine technische Topologie zu behaupten. Weite asymmetrische Draufsicht, gedeckte Gr\u00fcn- und Erdt\u00f6ne, keine Menschen. Keine Texte, Zahlen, Logos, Diagrammachsen oder Wasserzeichen.","alt":"KI-generierte Illustration zweier verbundener Instanzen mit \u00e4hnlichen Datenformen und unterschiedlichem zus\u00e4tzlichem Speicherbedarf.","caption":"KI-generierte Illustration: Primary und Replica halten Datenkopien, ben\u00f6tigen aber jeweils ein eigenes Speicherbudget.","filename_base":"redis-replikation-eigene-speicherbudgets","section_id":"replikation-speicher","after_block":2}},"chart":null,"social":{"facebook":"Wie viel RAM braucht Redis neben den eigentlichen Daten? Der Leitfaden erkl\u00e4rt maxmemory, Replikationspuffer und Persistenzspitzen und zeigt, wie du eine Reserve planst.","instagram":"Redis maxmemory ist keine harte RAM-Grenze. Plane auch Replikate, Buffer und Persistenzspitzen ein \u2013 und pr\u00fcfe deine Reserve unter passender Last.","tiktok":"Redis bis zum Containerlimit bef\u00fcllen? Keine gute Speicherplanung. Erfahre, warum maxmemory Reserve f\u00fcr Buffer und Persistenz braucht.","youtube":"Redis maxmemory dimensionieren: So unterscheiden sich Eviction-Schwelle, Prozessspeicher und Containerlimit. Dazu: Replikation, Copy-on-Write und Monitoring.","threads":"maxmemory begrenzt nicht den gesamten Redis-Prozess. Entscheidend sind auch Buffer, Persistenzspitzen und die tats\u00e4chliche Containergrenze.","x":"Redis maxmemory ist keine harte RAM-Grenze. Plane Reserve f\u00fcr Buffer, RSS-Effekte und Persistenzspitzen ein und bewerte jedes Replica separat."},"avatar_script":"Wie gro\u00df darf maxmemory bei Redis sein? Nicht einfach so gro\u00df wie der verf\u00fcgbare Arbeitsspeicher. Die Einstellung steuert die Eviction, begrenzt aber nicht den gesamten Verbrauch des Prozesses oder Containers. Plane deshalb Platz f\u00fcr Redis-Overhead, schwankende Buffer und zus\u00e4tzliche Speicherseiten w\u00e4hrend der Persistenz ein. Miss den Verbrauch \u00fcber normale Last und Schreibspitzen hinweg und beobachte dabei auch die tats\u00e4chliche Containergrenze. Replikate brauchen eigene Budgets: Sie halten eine Datenkopie und m\u00fcssen nach einer Promotion auch als Primary funktionieren. Aus diesen Beobachtungen leitest du einen vorl\u00e4ufigen Wert ab und pr\u00fcfst ihn in einer isolierten Umgebung unter vergleichbarer Last. \u00dcberwache anschlie\u00dfend Evictions, Schreibfehler und den Abstand zur Speichergrenze.","version_note":"Recherche und Produktabgrenzung auf Stand 4. November 2026. Beispiele beziehen sich auf Redis Open Source; verf\u00fcgbare Metriken und Hosting-Grenzen h\u00e4ngen von Version und Anbieter ab.","sections":[{"id":"maxmemory-grundlagen","heading":"Was maxmemory tats\u00e4chlich begrenzt","blocks":[{"type":"paragraph","runs":[{"kind":"code","text":"maxmemory","ref":""},{"kind":"text","text":" legt in Redis Open Source eine ","ref":""},{"kind":"strong","text":"Eviction-Schwelle","ref":""},{"kind":"text","text":" fest, keine harte Obergrenze f\u00fcr den Redis-Prozess oder seinen Container. Erreicht der f\u00fcr die Speichersteuerung relevante Verbrauch die Schwelle, versucht Redis abh\u00e4ngig von der gew\u00e4hlten Policy Schl\u00fcssel zu entfernen. Bei einer Policy ohne Eviction k\u00f6nnen speichervergr\u00f6\u00dfernde Schreibbefehle stattdessen fehlschlagen.","ref":""},{"kind":"citation","text":"","ref":"S2"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Die Kennzahl ","ref":""},{"kind":"code","text":"used_memory","ref":""},{"kind":"text","text":" umfasst den von Redis \u00fcber seinen Allocator belegten Speicher. Dazu geh\u00f6ren nicht nur die eigentlichen Werte deiner Anwendung, sondern auch Verwaltungsstrukturen und weitere Redis-Speicherbereiche. Wer das Limit allein aus der gesch\u00e4tzten Gr\u00f6\u00dfe der Nutzdaten ableitet, l\u00e4sst diesen Overhead unber\u00fccksichtigt.","ref":""},{"kind":"citation","text":"","ref":"S3"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Ein Teil von ","ref":""},{"kind":"code","text":"used_memory","ref":""},{"kind":"text","text":" wird bei der Eviction-Pr\u00fcfung ausgenommen: ","ref":""},{"kind":"code","text":"mem_not_counted_for_evict","ref":""},{"kind":"text","text":" weist insbesondere tempor\u00e4re Replikations- und AOF-Puffer aus. Diese Puffer ben\u00f6tigen trotzdem realen Speicher. Der Wert ist bereits in ","ref":""},{"kind":"code","text":"used_memory","ref":""},{"kind":"text","text":" enthalten und darf deshalb nicht ohne Pr\u00fcfung ein zweites Mal zu dieser Kennzahl addiert werden.","ref":""},{"kind":"citation","text":"","ref":"S2"},{"kind":"citation","text":"","ref":"S3"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Daraus folgt nicht, dass s\u00e4mtliche Client- oder Replikationsspeicher au\u00dferhalb der Eviction-Rechnung liegen. Ein einzelner gro\u00dfer Befehl kann die Schwelle zudem vor\u00fcbergehend deutlich \u00fcberschreiten. Setzt du ","ref":""},{"kind":"code","text":"maxmemory","ref":""},{"kind":"text","text":" auf das volle Containerlimit, bleibt f\u00fcr solche Ausschl\u00e4ge und zus\u00e4tzlichen Prozessverbrauch kein verl\u00e4sslicher Spielraum.","ref":""},{"kind":"citation","text":"","ref":"S2"}]},{"type":"paragraph","runs":[{"kind":"text","text":"F\u00fcr die Planung sind daher zwei Fragen getrennt zu beantworten: Wie viel Platz brauchen Datensatz und Redis-Overhead innerhalb der Speichersteuerung? Und wie viel Reserve ben\u00f6tigt die gesamte Laufzeitumgebung dar\u00fcber hinaus? Erst beide Perspektiven zusammen zeigen, ob ein gew\u00e4hlter Wert unter der tats\u00e4chlichen Speichergrenze plausibel ist.","ref":""}]}]},{"id":"rss-und-persistenz","heading":"RSS, Allocator und Persistenzspitzen","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Nach einer Lastspitze kann ","ref":""},{"kind":"code","text":"used_memory","ref":""},{"kind":"text","text":" sinken, w\u00e4hrend ","ref":""},{"kind":"code","text":"used_memory_rss","ref":""},{"kind":"text","text":" hoch bleibt: Redis hat dann zwar Speicher \u00fcber den Allocator freigegeben, dieser wurde aber nicht zwingend sofort an das Betriebssystem zur\u00fcckgegeben. RSS beschreibt den residenten Speicher des Prozesses aus Betriebssystemsicht und ist deshalb eine andere Beobachtungsebene.","ref":""},{"kind":"citation","text":"","ref":"S3"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Angenommen, ein Cache w\u00e4chst w\u00e4hrend einer Aktion stark und viele Schl\u00fcssel laufen danach ab. Der kleinere Redis-Speicherwert bedeutet nicht automatisch, dass der Container sofort entsprechend viel freie Reserve zur\u00fcckerh\u00e4lt. F\u00fcr die n\u00e4chste Spitze ist daher der Verlauf des tats\u00e4chlichen Verbrauchs wichtiger als die Annahme, dass freigegebener Speicher unmittelbar verschwindet.","ref":""},{"kind":"citation","text":"","ref":"S3"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Auch ","ref":""},{"kind":"code","text":"mem_fragmentation_ratio","ref":""},{"kind":"text","text":" ist kein reiner Fragmentierungsprozentsatz. Das Verh\u00e4ltnis umfasst weitere Prozessanteile; f\u00fcr die Ursachenanalyse solltest du es zusammen mit den verf\u00fcgbaren ","ref":""},{"kind":"code","text":"allocator_*","ref":""},{"kind":"text","text":"-Metriken und der Lastgeschichte betrachten. Aus einem einzelnen Verh\u00e4ltnis l\u00e4sst sich keine allgemein g\u00fcltige Reserve ableiten.","ref":""},{"kind":"citation","text":"","ref":"S3"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Bei RDB-Snapshots und AOF-Rewrites erzeugt Redis einen Kindprozess. Durch ","ref":""},{"kind":"strong","text":"Copy-on-Write","ref":""},{"kind":"text","text":" k\u00f6nnen zus\u00e4tzlich physische Speicherseiten ben\u00f6tigt werden, wenn w\u00e4hrend des Persistenzlaufs Seiten ver\u00e4ndert werden. Je st\u00e4rker und breiter die Schreiblast w\u00e4hrenddessen ist, desto wichtiger ist es, diese Phase bei der Kapazit\u00e4tsplanung zu beobachten.","ref":""},{"kind":"citation","text":"","ref":"S4"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Die Redis-Administration nennt f\u00fcr schreibintensive Anwendungen im Extrem einen Bedarf bis zum Doppelten des normalerweise genutzten Speichers. Das ist eine Warnung f\u00fcr ung\u00fcnstige Lastverh\u00e4ltnisse, kein pauschaler Multiplikator. Addiere au\u00dferdem nicht einfach die RSS-Werte von Eltern- und Kindprozess: Gemeinsam genutzte Seiten w\u00fcrden mehrfach gez\u00e4hlt; relevant ist die passende Host- oder Containerbeobachtung.","ref":""},{"kind":"citation","text":"","ref":"S4"}]}]},{"id":"replikation-speicher","heading":"Replikate brauchen eigene Budgets","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Ein Replica h\u00e4lt grunds\u00e4tzlich eine Kopie des Datenbestands und ben\u00f6tigt daf\u00fcr eigenes RAM. Primary und Replica sind deshalb getrennte Speicherverbraucher: Eine Reserve auf dem Primary schafft keinen Platz im Container des Replica. Plane jedes Mitglied anhand seiner eigenen Grenze und seines beobachteten Verbrauchs.","ref":""},{"kind":"citation","text":"","ref":"S5"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Standardm\u00e4\u00dfig ignoriert ein Replica sein konfiguriertes ","ref":""},{"kind":"code","text":"maxmemory","ref":""},{"kind":"text","text":" f\u00fcr eigene Evictions. Der Primary entscheidet \u00fcber das Entfernen von Schl\u00fcsseln und repliziert die L\u00f6schungen. Trotzdem k\u00f6nnen sich die Speicherst\u00e4nde unterscheiden, etwa wegen abweichender Puffer oder Datenstrukturen; derselbe Grenzwert garantiert daher keine identische Auslastung.","ref":""},{"kind":"citation","text":"","ref":"S5"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Bei einer ","ref":""},{"kind":"strong","text":"Promotion","ref":""},{"kind":"text","text":" \u00fcbernimmt das fr\u00fchere Replica die Primary-Rolle. Pr\u00fcfe deshalb nicht nur, ob es als lesende Kopie gen\u00fcgend Platz hat, sondern auch, ob seine Speichergrenze und Konfiguration den Betrieb als Primary tragen. Dazu geh\u00f6ren insbesondere Schreiblast, Replikationsverbindungen und die dann geltende Eviction-Steuerung.","ref":""},{"kind":"citation","text":"","ref":"S5"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Seit Redis 7.0 teilen sich Replica-Buffer und Replikations-Backlog Speicher. ","ref":""},{"kind":"code","text":"mem_clients_slaves","ref":""},{"kind":"text","text":" kann deshalb null anzeigen, obwohl die Replikation Speicher beansprucht. Interpretiere das Feld nicht isoliert und addiere Backlog und Replica-Buffer nicht ungepr\u00fcft als vollst\u00e4ndig getrennte Bereiche.","ref":""},{"kind":"citation","text":"","ref":"S3"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Neben dem Speicherverbrauch ist der Fortschritt der Daten\u00fcbertragung f\u00fcr den Betrieb relevant: Eine Verz\u00f6gerung zeigt eine andere Eigenschaft als die Gr\u00f6\u00dfe eines Puffers. Wie sich Replikationsstand und R\u00fcckstand einordnen lassen, erkl\u00e4rt der Beitrag zum ","ref":""},{"kind":"internal_link","text":"Redis Replication Offset","ref":"I1"},{"kind":"text","text":". F\u00fcr die Speicherreserve bleiben dennoch die tats\u00e4chlichen Verbrauchsverl\u00e4ufe jeder Instanz entscheidend.","ref":""}]}]},{"id":"metriken-erfassen","heading":"Speicher auf drei Ebenen erfassen","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"F\u00fcr die Dimensionierung brauchst du Werte aus Redis und von der Umgebung, in der die Instanz l\u00e4uft. Die ","ref":""},{"kind":"strong","text":"Beobachtungsebene","ref":""},{"kind":"text","text":" entscheidet dar\u00fcber, was eine Zahl aussagt: Allocator-Belegung, Prozess-RSS und Containerverbrauch sind unterschiedliche Gr\u00f6\u00dfen und lassen sich nicht einfach addieren.","ref":""},{"kind":"citation","text":"","ref":"S3"}]},{"type":"table","caption":"Speicherwerte und ihre Aussagegrenzen","headers":["Gr\u00f6\u00dfe","Ebene und Bedeutung","Grenze der Interpretation"],"rows":[["used_memory","Von Redis \u00fcber den Allocator belegter Speicher","Enth\u00e4lt Redis-Overhead und ist nicht identisch mit den reinen Nutzdaten."],["used_memory_rss","Residenter Speicher des Redis-Prozesses aus Betriebssystemsicht","Kann nach Lastspitzen hoch bleiben; ist nicht mit used_memory gleichzusetzen."],["mem_not_counted_for_evict","Anteil von used_memory, der bei der Eviction-Pr\u00fcfung ausgenommen wird","Schwankt und ist bereits in used_memory enthalten."],["Host- oder Containerverbrauch","Verbrauch an der relevanten Betriebsgrenze","Kann neben Redis weitere Verbraucher umfassen; die Definition h\u00e4ngt von der Umgebung ab."]],"source_ids":["S3"]},{"type":"paragraph","runs":[{"kind":"text","text":"Mit ","ref":""},{"kind":"code","text":"INFO memory","ref":""},{"kind":"text","text":" liest du unter anderem die Redis-Speicherwerte und die konfigurierte Policy. ","ref":""},{"kind":"code","text":"MEMORY STATS","ref":""},{"kind":"text","text":" erg\u00e4nzt Details zur Speicherverteilung. Beide Befehle sind lesend; welche Felder verf\u00fcgbar sind, h\u00e4ngt von Redis-Version, Berechtigungen und Hosting-Angebot ab.","ref":""},{"kind":"citation","text":"","ref":"S3"}]},{"type":"paragraph","runs":[{"kind":"text","text":"F\u00fcr den zeitlichen Zusammenhang pr\u00fcfst du au\u00dferdem ","ref":""},{"kind":"code","text":"INFO persistence","ref":""},{"kind":"text","text":" auf Persistenzaktivit\u00e4t und verf\u00fcgbare Copy-on-Write-Werte. ","ref":""},{"kind":"code","text":"INFO replication","ref":""},{"kind":"text","text":" zeigt Rolle und Replikationszustand. Erfasse diese Angaben f\u00fcr Primary und Replica getrennt, damit ein Rollenwechsel oder eine Synchronisation bei der Auswertung erkennbar bleibt.","ref":""},{"kind":"citation","text":"","ref":"S3"},{"kind":"citation","text":"","ref":"S5"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Ein einzelner Wert zeigt weder die typische Auslastung noch die notwendige Spitzenreserve. Sammle deshalb Zeitreihen \u00fcber normalen Betrieb, Schreibspitzen und Persistenzl\u00e4ufe und ordne ihnen den gleichzeitig beobachteten Host- oder Containerverbrauch zu. So erkennst du auch, ob ein hoher RSS-Wert eine aktuelle Last begleitet oder nach einer fr\u00fcheren Spitze bestehen bleibt.","ref":""},{"kind":"citation","text":"","ref":"S3"}]}]},{"id":"budget-rechnen","heading":"Ein belastbares Speicherbudget berechnen","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Ausgangspunkt ist die tats\u00e4chlich wirksame ","ref":""},{"kind":"strong","text":"Speichergrenze","ref":""},{"kind":"text","text":": Bei einem Container kann sie niedriger sein als der RAM des Hosts. Ermittle, welche anderen Prozesse und Betriebsanteile dieselbe Grenze beanspruchen. Was ihnen vorbehalten ist, steht Redis nicht f\u00fcr Daten oder Spitzen zur Verf\u00fcgung.","ref":""}]},{"type":"paragraph","runs":[{"kind":"text","text":"Ziehe anschlie\u00dfend Reserven f\u00fcr zus\u00e4tzliche RSS- und Allocator-Effekte, nicht f\u00fcr Eviction gez\u00e4hlte Buffer, Persistenzspitzen und einen Sicherheitsabstand ab. Das Ergebnis ist ein vorl\u00e4ufiges ","ref":""},{"kind":"code","text":"maxmemory","ref":""},{"kind":"text","text":"-Budget, keine Redis-interne Gleichung. Die Reserven m\u00fcssen zur gleichen Grenze und zu realistisch gleichzeitig auftretenden Lastzust\u00e4nden passen.","ref":""},{"kind":"citation","text":"","ref":"S2"},{"kind":"citation","text":"","ref":"S3"},{"kind":"citation","text":"","ref":"S4"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Illustratives Rechenbeispiel, keine Messung: Von einer Containergrenze von 8 GiB werden 0,5 GiB f\u00fcr andere Verbraucher, 0,5 GiB f\u00fcr zus\u00e4tzliche RSS-Effekte, 0,5 GiB f\u00fcr aus der Eviction-Rechnung ausgenommene Buffer, 1 GiB f\u00fcr eine Persistenzspitze und 0,5 GiB Sicherheitsabstand abgezogen. Als vorl\u00e4ufiger Wert bleiben 5 GiB f\u00fcr ","ref":""},{"kind":"code","text":"maxmemory","ref":""},{"kind":"text","text":".","ref":""}]},{"type":"paragraph","runs":[{"kind":"text","text":"Diese Zahlen sind keine Empfehlung f\u00fcr eine konkrete Instanz. Das Beispiel setzt voraus, dass die angesetzten Reserven zus\u00e4tzliche, nicht \u00fcberlappende Beitr\u00e4ge zur Containergrenze beschreiben. Gerade bei einem Persistenzlauf k\u00f6nnen gemeinsame Speicherseiten und Copy-on-Write die Zuordnung erschweren; eine blo\u00dfe Addition der RSS-Werte von Eltern- und Kindprozess w\u00e4re daf\u00fcr ungeeignet.","ref":""},{"kind":"citation","text":"","ref":"S4"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Vermeide ","ref":""},{"kind":"strong","text":"Doppelz\u00e4hlungen","ref":""},{"kind":"text","text":": ","ref":""},{"kind":"code","text":"mem_not_counted_for_evict","ref":""},{"kind":"text","text":" steckt bereits in ","ref":""},{"kind":"code","text":"used_memory","ref":""},{"kind":"text","text":". Wenn du vom beobachteten gesamten RSS oder Containerverbrauch ausgehst, darfst du diesen Bufferanteil nicht ungepr\u00fcft noch einmal addieren. Im verbleibenden Eviction-Budget m\u00fcssen sowohl der Datensatz als auch der mitgez\u00e4hlte Redis-Overhead Platz finden; pr\u00fcfe den Ansatz anschlie\u00dfend unter vergleichbarer Last.","ref":""},{"kind":"citation","text":"","ref":"S2"},{"kind":"citation","text":"","ref":"S3"}]}]},{"id":"eviction-vergleichen","heading":"Eviction-Policies im Praxisvergleich","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Die ","ref":""},{"kind":"strong","text":"Eviction-Policy","ref":""},{"kind":"text","text":" bestimmt, wie Redis bei Speicherknappheit auf schreibende Befehle reagiert. Sie ersetzt keine Kapazit\u00e4tsplanung: Selbst eine passende Policy ben\u00f6tigt Reserven au\u00dferhalb der Eviction-Rechnung. Die Entscheidung h\u00e4ngt vor allem davon ab, welche Schl\u00fcssel verloren gehen d\u00fcrfen und wie die Anwendung auf Fehler reagiert.","ref":""},{"kind":"citation","text":"","ref":"S2"}]},{"type":"table","caption":"Policies nach Einsatzzweck und Verhalten bei Speicherknappheit","headers":["Policy","Typische Eignung","Verlust und Fehlerfall"],"rows":[["noeviction","Daten, die nicht zur Platzgewinnung entfernt werden sollen","Keine Eviction zur Platzgewinnung; speichervergr\u00f6\u00dfernde Schreibbefehle k\u00f6nnen mit OOM scheitern."],["allkeys-lru","Cache mit wiederherstellbaren Daten","Schl\u00fcssel k\u00f6nnen nach n\u00e4herungsweisem LRU entfernt werden; dadurch entstehen Cache-Misses."],["volatile-*","Bestand, bei dem nur Schl\u00fcssel mit Ablaufzeit zur Eviction vorgesehen sind","Nur Schl\u00fcssel mit TTL sind Kandidaten; fehlen geeignete Kandidaten, kann Platz nicht ausreichend freigemacht werden."]],"source_ids":["S2","S6"]},{"type":"paragraph","runs":[{"kind":"text","text":"Bei einem reinen Cache kann ","ref":""},{"kind":"code","text":"allkeys-lru","ref":""},{"kind":"text","text":" passen, wenn sich entfernte Eintr\u00e4ge aus einer anderen Quelle neu aufbauen lassen. LRU ist in Redis eine N\u00e4herung und keine exakte globale Sortierung. H\u00e4ufige Evictions k\u00f6nnen mehr Zugriffe auf das Backend ausl\u00f6sen; deshalb sind nicht nur freie Bytes, sondern auch Cache-Trefferrate und Backend-Kapazit\u00e4t wichtig.","ref":""},{"kind":"citation","text":"","ref":"S2"}]},{"type":"paragraph","runs":[{"kind":"text","text":"F\u00fcr nicht beliebig l\u00f6schbare Daten ist ","ref":""},{"kind":"code","text":"noeviction","ref":""},{"kind":"text","text":" eine andere Entscheidung: Die Anwendung muss fehlgeschlagene Schreibvorg\u00e4nge behandeln k\u00f6nnen, statt stillschweigend mit erfolgreicher Speicherung zu rechnen. Die Policy ist weder Persistenz noch Schutz vor einem OOM auf Betriebssystem- oder Containerebene.","ref":""},{"kind":"citation","text":"","ref":"S6"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Bei gemischten Best\u00e4nden ist die ","ref":""},{"kind":"strong","text":"TTL-Disziplin","ref":""},{"kind":"text","text":" entscheidend: Eine ","ref":""},{"kind":"code","text":"volatile-*","ref":""},{"kind":"text","text":"-Policy kann nur Schl\u00fcssel mit Ablaufzeit ausw\u00e4hlen. Wenn zu wenige geeignete Kandidaten vorhanden sind, sch\u00fctzt eine TTL allein nicht vor Schreibfehlern. Pr\u00fcfe deshalb, ob Cache und wichtige Daten wirklich dieselbe Instanz und Fehlerstrategie teilen sollten.","ref":""},{"kind":"citation","text":"","ref":"S2"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Session-Daten verdeutlichen den Zielkonflikt: Ein entfernter Eintrag kann f\u00fcr Nutzer den Verlust eines Sitzungszustands bedeuten, auch wenn die Anwendung technisch weiterl\u00e4uft. Bewerte die Folgen und Wiederherstellbarkeit vor der Policy-Wahl; zus\u00e4tzliche Grundlagen bietet der Beitrag zum ","ref":""},{"kind":"internal_link","text":"Session-Management mit Redis und anderen Speichern","ref":"I3"},{"kind":"text","text":".","ref":""}]}]},{"id":"betrieb-ueberwachen","heading":"Reserve unter Last \u00fcberpr\u00fcfen","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Ein berechneter Wert f\u00fcr ","ref":""},{"kind":"code","text":"maxmemory","ref":""},{"kind":"text","text":" ist zun\u00e4chst ein Ausgangspunkt. Pr\u00fcfe ihn in einer isolierten Umgebung mit vergleichbarer Redis-Version, Datenstruktur und Speichergrenze. Die Last sollte nicht nur den gew\u00f6hnlichen Betrieb abbilden, sondern auch Schreibspitzen und Phasen, in denen Persistenz und Replikation gleichzeitig aktiv sind.","ref":""},{"kind":"citation","text":"","ref":"S4"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Beobachte dabei den ","ref":""},{"kind":"strong","text":"Containerverbrauch","ref":""},{"kind":"text","text":" beziehungsweise die passende Host-Metrik ebenso wie Redis-Speicherwerte. Halte fest, wann ein Snapshot oder AOF-Rewrite l\u00e4uft und ob ein Replica synchronisiert wird. Entscheidend ist, wie viel Abstand zur tats\u00e4chlichen Grenze w\u00e4hrend \u00fcberlappender Ereignisse bleibt, nicht nur im Leerlauf danach.","ref":""},{"kind":"citation","text":"","ref":"S3"},{"kind":"citation","text":"","ref":"S5"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Mit dem lesenden Befehl ","ref":""},{"kind":"code","text":"INFO stats","ref":""},{"kind":"text","text":" erfasst du unter anderem Eviction-Z\u00e4hler. Werte deren \u00c4nderung pro Zeitintervall aus: Ein hoher historischer Stand allein sagt nicht, ob gerade Schl\u00fcssel verdr\u00e4ngt werden. Setze steigende Evictions in Beziehung zu Cache-Treffern und Backend-Last, sofern deine Anwendung diese Gr\u00f6\u00dfen bereitstellt.","ref":""},{"kind":"citation","text":"","ref":"S3"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Erfasse au\u00dferdem Redis-OOM-Antworten in der Anwendung und speicherbedingte Container-Ereignisse auf der Plattform. Beide Fehler k\u00f6nnen bei \u00e4hnlicher Last auftreten, betreffen aber unterschiedliche Grenzen. Eine Alarmierung sollte deshalb sowohl die verf\u00fcgbare Reserve als auch die beobachteten Fehler und deren zeitlichen Verlauf ber\u00fccksichtigen.","ref":""},{"kind":"citation","text":"","ref":"S6"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Wiederhole die Bewertung nach \u00c4nderungen am Datensatz, an der Schreiblast oder an Persistenz und Replikation. Auch eine Promotion ver\u00e4ndert die Rolle eines Replica und damit das zu pr\u00fcfende Lastprofil. Die Ergebnisse aus der isolierten Umgebung ersetzen nicht die fortlaufende Beobachtung der produktiven Instanzen.","ref":""},{"kind":"citation","text":"","ref":"S5"}]}]},{"id":"fehler-diagnose","heading":"Speicherprobleme gezielt eingrenzen","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Steigt der Prozess-RSS, w\u00e4hrend ","ref":""},{"kind":"code","text":"used_memory","ref":""},{"kind":"text","text":" f\u00e4llt, betrachte zuerst den Verlauf und die vorherige Last. Freigegebener Speicher muss nicht sofort an das Betriebssystem zur\u00fcckgehen. Die ","ref":""},{"kind":"strong","text":"Allocator-Metriken","ref":""},{"kind":"text","text":" aus ","ref":""},{"kind":"code","text":"INFO memory","ref":""},{"kind":"text","text":" helfen bei der Einordnung; das Fragmentierungsverh\u00e4ltnis allein beweist weder ein Speicherleck noch dessen Ursache.","ref":""},{"kind":"citation","text":"","ref":"S3"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Pr\u00fcfe anschlie\u00dfend, ob der Anstieg zeitlich mit einem Persistenzlauf oder einer Synchronisierung zusammenf\u00e4llt. Dazu dienen ","ref":""},{"kind":"code","text":"INFO persistence","ref":""},{"kind":"text","text":" und ","ref":""},{"kind":"code","text":"INFO replication","ref":""},{"kind":"text","text":". Ein einzelner Wert f\u00fcr nicht zur Eviction gez\u00e4hlte Buffer beschreibt nur den aktuellen Zustand. F\u00fcr eine Reserve brauchst du Beobachtungen \u00fcber relevante Last- und St\u00f6rungsphasen hinweg.","ref":""},{"kind":"citation","text":"","ref":"S3"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Bei einer ","ref":""},{"kind":"strong","text":"Redis-OOM-Antwort","ref":""},{"kind":"text","text":" pr\u00fcfe die konfigurierte Policy und ob geeignete Schl\u00fcssel f\u00fcr eine Eviction vorhanden sind. Insbesondere kann ein Schreibbefehl scheitern, wenn Redis unter der geltenden Policy keinen ausreichenden Platz freimachen kann. Die Anwendung muss diesen Fehler behandeln, statt einen erfolgreichen Schreibvorgang vorauszusetzen.","ref":""},{"kind":"citation","text":"","ref":"S6"},{"kind":"citation","text":"","ref":"S2"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Bei einem speicherbedingten Container-Abbruch untersuche dagegen die Plattformereignisse und den Verbrauch gegen\u00fcber dem Containerlimit. Beziehe Persistenzspitzen und andere im Container erfasste Verbraucher ein. Ein Redis-OOM und ein Container-OOM sind nicht gleichzusetzen: Auch ohne eine vorherige Redis-OOM-Antwort kann die \u00e4u\u00dfere Speichergrenze erreicht werden.","ref":""},{"kind":"citation","text":"","ref":"S3"}]},{"type":"paragraph","runs":[{"kind":"code","text":"maxmemory-clients","ref":""},{"kind":"text","text":" kann zus\u00e4tzlich den von Clients belegten Speicher begrenzen. \u00dcberschreitet der relevante Client-Speicher die konfigurierte Schwelle, kann Redis Clients mit hohem Verbrauch trennen; Anwendungen m\u00fcssen mit Verbindungsabbr\u00fcchen umgehen. Die Einstellung begrenzt nicht s\u00e4mtliche Replikationsverbindungen und ersetzt weder das Gesamtbudget noch die Beobachtung von Pufferspitzen.","ref":""},{"kind":"citation","text":"","ref":"S7"}]}]},{"id":"hosting-entscheidung","heading":"Redis Hosting und Architektur abw\u00e4gen","blocks":[{"type":"paragraph","runs":[{"kind":"text","text":"Reicht die beobachtete Reserve bei repr\u00e4sentativer Last nicht aus, kann mehr RAM sinnvoll sein, wenn Datensatz und Last grunds\u00e4tzlich auf einer Instanz bleiben sollen. Die zus\u00e4tzliche Kapazit\u00e4t muss jedoch zur tats\u00e4chlich wirksamen Host- oder Containergrenze geh\u00f6ren. Ein gr\u00f6\u00dferes Redis-Limit allein schafft keinen zus\u00e4tzlichen physischen Speicher.","ref":""},{"kind":"citation","text":"","ref":"S4"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Alternativ kann eine ","ref":""},{"kind":"strong","text":"Lastverteilung","ref":""},{"kind":"text","text":" den Speicherbedarf und die Schreibarbeit auf mehrere Instanzen verteilen. Das erfordert eine passende Aufteilung der Daten und eine eigene Budgetierung f\u00fcr jede beteiligte Instanz. Replikate sind dabei nicht mit einer Aufteilung des Datenbestands gleichzusetzen: Sie halten grunds\u00e4tzlich eine Kopie und ben\u00f6tigen daf\u00fcr eigenes RAM.","ref":""},{"kind":"citation","text":"","ref":"S5"}]},{"type":"paragraph","runs":[{"kind":"text","text":"Auch eine Architektur\u00e4nderung kann helfen, etwa die Trennung eines verlusttoleranten Caches von Daten mit strengeren Anforderungen. Dadurch lassen sich Policies und Kapazit\u00e4ten unabh\u00e4ngig w\u00e4hlen. Weder diese Trennung noch mehr RAM oder Lastverteilung garantiert allerdings, dass Persistenz-, Replikations- und Schreibspitzen k\u00fcnftig ausbleiben.","ref":""}]},{"type":"paragraph","runs":[{"kind":"text","text":"Beim Vergleich von ","ref":""},{"kind":"strong","text":"Anbietergrenzen","ref":""},{"kind":"text","text":" kl\u00e4re, ob der ausgewiesene Wert ein Containerlimit, ein Instanzlimit oder ein anders definiertes Datenbanklimit bezeichnet. Frage au\u00dferdem, welche Metriken und Diagnosebefehle zug\u00e4nglich sind, ob Replikate im gebuchten Speicher enthalten sind und wie sich eine Promotion auf die verf\u00fcgbaren Ressourcen auswirkt.","ref":""}]},{"type":"paragraph","runs":[{"kind":"text","text":"Redis Open Source, Redis Software und Redis Cloud sind getrennt zu betrachten. Bei Redis Software gilt das dokumentierte Datenbanklimit \u00fcber Primary- und Replica-Shards hinweg; daraus folgt keine entsprechende Regel f\u00fcr eine einzelne Redis-OSS-Instanz. F\u00fcr Redis Cloud und andere Hosting-Angebote pr\u00fcfst du die jeweils konkreten Produktbedingungen, statt diese Definition ungepr\u00fcft zu \u00fcbertragen.","ref":""},{"kind":"citation","text":"","ref":"S1"}]}]}]},"_wh_make_word_report":{"words":2162,"min":2000,"max":3000,"target":2500,"ok":true,"missing":0,"excess":0,"lead_words":62,"section_words":{"maxmemory-grundlagen":222,"rss-und-persistenz":226,"replikation-speicher":214,"metriken-erfassen":250,"budget-rechnen":225,"eviction-vergleichen":292,"betrieb-ueberwachen":217,"fehler-diagnose":220,"hosting-entscheidung":234}},"_wh_make_review":{"verdict":"pass","issues":[],"checked_source_ids":["S1","S2","S3","S4","S5","S6","S7"],"summary":"Fachlich freigabef\u00e4hig. Die gepr\u00fcften Originalquellen st\u00fctzen die Abgrenzung von maxmemory, ausgeschlossenen Puffern, Prozessspeicher und Eviction-Verhalten. RSS-Effekte, Copy-on-Write, Replica-Verhalten und die Besonderheit der Replikationsbuffer seit Redis 7.0 sind korrekt eingeordnet. Die Produktgrenzen von Redis Software werden nicht auf Redis Open Source \u00fcbertragen. Das illustrative Budgetbeispiel ergibt korrekt 5 GiB und benennt seine Voraussetzungen sowie Doppelz\u00e4hlungsrisiken. Diagnosebefehle, Tabellen, Versionshinweise und Bildkonzepte enthalten keine festgestellten fachlichen Fehler; das fotografische Motiv ist ausdr\u00fccklich als KI-generiertes Symbolbild gekennzeichnet. Ein Chart und behauptete eigene Messungen liegen nicht vor."},"_wh_make_review_doc_hash":"656b7c8d51118ed0fa3cfb0264c799884ab362d2160c431915834a20b6c4ea7e","_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,"inline_featured_image":null,"_yoast_wpseo_linkdex":null,"_eael_widget_elements":null,"_oembed_c3b0f6959478faf92a1f343d8f96b19e":null,"_oembed_27e3473bf8bec795fbeb3a9d38489348":null,"_trp_translated_slug_en_us":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_8357e2b8a2575c74ed5978f262a10126":null,"_oembed_ad96e4112edb9f8ffa35731d4098bc6b":null,"_oembed_3d5fea5103dd0d22ec5d6a33eff7f863":null,"_oembed_819a879e7da16dd629cfd15a97334c8a":null,"_oembed_time_819a879e7da16dd629cfd15a97334c8a":null,"_wh_make_writer_raw":null,"_wh_make_design_backup_204":null,"_wp_desired_post_slug":null,"_oembed_0d8a206f09633e3d62b95a15a4dd0487":null,"_oembed_time_0d8a206f09633e3d62b95a15a4dd0487":null,"_aioseo_description":null,"_eb_attr":null,"_eb_data_table":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":"73","_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,"_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 maxmemory","rank_math_og_content_image":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":"22166","_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":"Redis maxmemory mit Reserve planen: Speicherwerte verstehen, Replikate ber\u00fccksichtigen und Persistenzspitzen unter Last pr\u00fcfen.","footnotes":null,"_links":{"self":[{"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/posts\/22164","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=22164"}],"version-history":[{"count":2,"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/posts\/22164\/revisions"}],"predecessor-version":[{"id":22169,"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/posts\/22164\/revisions\/22169"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/media\/22166"}],"wp:attachment":[{"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/media?parent=22164"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/categories?post=22164"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/webhosting.de\/en\/wp-json\/wp\/v2\/tags?post=22164"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}