German Translation mod_mem_cache

[Jobst Giesecke]

<?xml version="1.0"?>
<!DOCTYPE modulesynopsis SYSTEM "../style/modulesynopsis.dtd">
<?xml-stylesheet type="text/xsl" href="../style/manual.de.xsl"?>
<modulesynopsis metafile="mod_mem_cache.xml.meta">

<name>mod_mem_cache</name>
<description>Content-Cache &uuml;ber URIs</description>
<status>Experimentell</status>
<sourcefile>mod_mem_cache.c</sourcefile>
<identifier>mem_cache_module</identifier>

<summary>
    <note type="warning">
      Dieses Modul befindet sich in einem experimentellen Stadium. Die
      Dokumentation ist noch nicht abgeschlossen...
    </note>

    <p>Dieses Modul <em>ben&ouml;tigt</em> die Dienste des <module
    >mod_cache</module>-Moduls. Es erg&auml;nzt dieses Modul und stellt einen
    Manager f&uuml;r den interenen Speicher zur Verf&uuml;gung.
    <module>mod_mem_cache</module> kann f&uuml;r zwei Modi konfiguriert
    werden: F&uuml;r das Caching offner Dateideskriptoren oder f&uuml;r das 
Caching
    von Objekten im Heap-Speicher. Am sinnvollsten wird
    <module>mod_mem_cache</module> f&uuml;r die Zwischenspeicherung lokal
    erzeugter Inhalte oder der Inhalte von Backend-Servern f&uuml;r das Modul
    <module>mod_proxy</module>, welches f&uuml;r <directive module="mod_proxy"
    >ProxyPass</directive> konfiguriert wurde (auch bekannt unter der
    Bezeichnung <dfn>reverse proxy</dfn>), benutzt.</p>

    <p>Die Inhalte werden &uuml;ber URI-Schl&uuml;ssel im Cache gespeichert und 
aus
    diesem wieder entnommen. Gesch&uuml;tzte Inhalte werden nicht
    zwischengespeichert.</p>
</summary>
<seealso><module>mod_cache</module></seealso>
<seealso><module>mod_disk_cache</module></seealso>

<directivesynopsis>
<name>MCacheSize</name>
<description>Der maximale Umfang, den die gespeicherten Daten im Speicher
 einnehmen sollen (in KByte).</description>
<syntax>MCacheSize <var>kByte</var></syntax>
<default>MCacheSize 100</default>
<contextlist><context>server config</context></contextlist>

<usage>
    <p>Die <directive>MCacheSize</directive>-Direktive gibt den maximalen
    Speicherumfang f&uuml;r den Cache in KByte an (1.024-Byte-Einheiten).
    Wird beim Einf&uuml;gen eines neuen Objekts in den Zwischenspeicher
    die angegebene Gr&ouml;&szlig;e &uuml;berschritten, werden Objekte aus dem 
Speicher
    entfernt, damit diese Grenze nicht &uuml;berschritten wird. Die zu 
entfernenden
    Objekte werden mit einem Algorithmus ermittelt, der mit
    <directive module="mod_mem_cache">MCacheRemovalAlgorithm</directive>
    angegeben wird.</p>

    <example><title>Beispiel</title>
      MCacheSize 700000
    </example>

    <note><title>Hinweis</title>
      <p>Der Wert f&uuml;r <directive>MCacheSize</directive> muss
      gr&ouml;&szlig;er als der Wert f&uuml;r
      <directive module="mod_mem_cache">MCacheMaxObjectSize</directive>
      sein.</p>
    </note>
</usage>
</directivesynopsis>

<directivesynopsis>
<name>MCacheMaxObjectCount</name>
<description>Die maximale Anzahl von Objekten im Cache</description>
<syntax>MCacheMaxObjectCount <var>Wert</var></syntax>
<default>MCacheMaxObjectCount 1009</default>
<contextlist><context>server config</context></contextlist>

<usage>
    <p>Die <directive>MCacheMaxObjectCount</directive>-Direktive gibt
    die maximale Anzahl im Cache zwischengespeicherter Objekte an. Mit
    diesem Wert wird eine Hash-Tabelle erzeugt. Wird beim Einf&uuml;gen eines
    neuen Objekts in den Cache die maximale Anzahl der Objekte 
&uuml;berschritten,
    wird ein anderes Objekt entfernt, um dem neuen Platz zu machen. Das zu
    entfernende Objekt wird mit einem Algorithmus ausgew&auml;hlt, der mit der
    <directive module="mod_mem_cache">MCacheRemovalAlgorithm
    </directive>-Anweisung angegeben wird.</p>

    <example><title>Beispiel</title>
      MCacheMaxObjectCount 13001
    </example>
</usage>
</directivesynopsis>

<directivesynopsis>
<name>MCacheMinObjectSize</name>
<description>Die Mindestgr&ouml;&szlig;e eines zwischengespeicherten
Dokuments (in Byte)</description>
<syntax>MCacheMinObjectSize <var>Byte</var></syntax>
<default>MCacheMinObjectSize 0</default>
<contextlist><context>server config</context></contextlist>

<usage>
    <p>Die <directive>MCacheMinObjectSize</directive>-Direktive gibt die
    Mindestgr&ouml;&szlig;e f&uuml;r zwischenzuspeichernde Dokumente in Byte 
an.</p>

    <example><title>Beispiel</title>
      MCacheMinObjectSize 10000
    </example>
</usage>
</directivesynopsis>

<directivesynopsis>
<name>MCacheMaxObjectSize</name>
<description>Die maximale Gr&ouml;&szlig;e eines Dokuments im Cache (in Byte)
</description>
<syntax>MCacheMaxObjectSize <var>Byte</var></syntax>
<default>MCacheMaxObjectSize 10000</default>
<contextlist><context>server config</context></contextlist>

<usage>
    <p>Die <directive>MCacheMaxObjectSize</directive>-Direktive gibt die
    maximal zul&auml;ssige Gr&ouml;&szlig;e f&uuml;r zwischenzuspeichernde 
Dokumente in Byte an.</p>

    <example><title>Beispiel</title>
      MCacheMaxObjectSize 6400000
    </example>

    <note><title>Hinweis</title>
      <p>Der Wert f&uuml;r <directive>MCacheMaxObjectSize</directive> muss
      gr&ouml;&szlig;er als der Wert f&uuml;r <directive
      module="mod_mem_cache">MCacheMinObjectSize</directive> sein.</p>
    </note>
</usage>
</directivesynopsis>

<directivesynopsis>
<name>MCacheRemovalAlgorithm</name>
<description>Der Algorithmus f&uuml;r die Auswahl aus dem Cache zu
entfernender Objekte</description>
<syntax>MCacheRemovalAlgorithm LRU|GDSF</syntax>
<default>MCacheRemovalAlgorithm GDSF</default>
<contextlist><context>server config</context></contextlist>

<usage>
    <p>Die <directive>MCacheRemovalAlgorithm</directive>-Direktive gibt
    den Algorithmus f&uuml;r die Auswahl der aus dem Cache zu entfernenden
    Dokumente an. Zwei Angaben sind m&ouml;glich:</p>

    <dl>
      <dt><code>LRU</code> (Least Recently Used)</dt>
      <dd><code>LRU</code> entfernt die Dokumente, auf die am l&auml;ngsten
      nicht mehr zugegriffen wurde.</dd>

      <dt><code>GDSF</code> (GreadyDual-Size)</dt>
      <dd><code>GDSF</code> weist auf der Basis der Anzahl der Zugriffe
      auf das Dokument, der Zeit des letzten Zugriffs und der Gr&ouml;&szlig;e 
dem
      Dokument eine Priorit&auml;t zu. Dokumente mit der niedrigsten 
Priorit&auml;t werden
      zuerst entfernt.</dd>
    </dl>

    <example><title>Beispiel</title>
      MCacheRemovalAlgorithm GDSF<br />
      MCacheRemovalAlgorithm LRU
    </example>
</usage>
</directivesynopsis>

<directivesynopsis>
<name>MCacheMaxStreamingBuffer</name>
<description>Maximaler Umfang tempor&auml;r gepufferter Antworten.
Umfangreichere Antworten werden nicht zwischengespeichert.</description>
<syntax>MCacheMaxStreamingBuffer <var>Gr&ouml;&szlig;e_in_Byte</var></syntax>
<default>MCacheMaxStreamingBuffer kleiner 100000 oder 
MCacheMaxObjectSize</default>
<contextlist><context>server config</context>
</contextlist>

<usage>
    <p>Die <directive>MCacheMaxStreamingBuffer</directive>-Direktive
    gibt die maximale Anzahl Bytes f&uuml;r tempor&auml;r gepufferte Anworten 
an.
    Wird der Wert &uuml;berschritten, erfolgt keine Zwischenspeicherung.
    Bei gepufferten Antworten stehen der gesamte Inhalt und der 
    <code>Content-Length</code>-Header nicht umnittelbar zur Verf&uuml;gung.
    Das kann bei Antworten von Proxies und CGI-Skripten der Fall sein.
    Standardm&auml;&szlig;ig wird eine tempor&auml;r gepufferte Antwort
    <em>nicht</em> zwischengespeichert, es sei denn, es liegt ein
    <code>Content-Length</code>-Header vor. Dadurch soll vermieden werden,
    dass zuviel Speicher f&uuml;r die Pufferung einer partiellen Antwort 
benutzt wird,
    die sich am Ende als zu gro&szlig; f&uuml;r den Cache herausstellt. Mit der
    <directive>MCacheMaxStreamingBuffer</directive>-Direktive k&ouml;nnen
    Antworten gepuffert werden, deren Gr&ouml;&szlig;e im geforderten Rahmen 
liegt.
    Wird die maximale Puffergr&ouml;&szlig;e erreicht, wird der Pufferinhalt 
verworfen
    und der Versuch der Zwischenspeicherung abgebrochen.</p>

    <note><title>Hinweis:</title>
      <p>Ein Wert f&uuml;r <directive>MCacheMaxStreamingBuffer</directive>,
      der ungleich null ist, verz&ouml;gert die &Uuml;bertragung der Antwort an 
den Client
      nicht. Sobald <module>mod_mem_cache</module> einen Block in einen
      Puffer kopiert, wird dieser Block an den n&auml;chsten Ausgabefilter 
f&uuml;r die
      Auslieferung an den Client gesendet.</p>
    </note>

    <example>
      # Das Caching f&uuml;r tempor&auml;r gepufferte <br />
      # Antworten bis 64 kByte aktivieren:<br />
      MCacheMaxStreamingBuffer 65536
    </example>
</usage>
</directivesynopsis>

</modulesynopsis>


---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]