httpd-cvs mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From gry...@apache.org
Subject svn commit: r831756 [4/4] - /httpd/httpd/trunk/docs/manual/mod/
Date Sun, 01 Nov 2009 20:13:29 GMT
Added: httpd/httpd/trunk/docs/manual/mod/mod_headers.xml.fr
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/docs/manual/mod/mod_headers.xml.fr?rev=831756&view=auto
==============================================================================
--- httpd/httpd/trunk/docs/manual/mod/mod_headers.xml.fr (added)
+++ httpd/httpd/trunk/docs/manual/mod/mod_headers.xml.fr Sun Nov  1 20:13:27 2009
@@ -0,0 +1,491 @@
+<?xml version="1.0"?>
+<!DOCTYPE modulesynopsis SYSTEM "../style/modulesynopsis.dtd">
+<?xml-stylesheet type="text/xsl" href="../style/manual.fr.xsl"?>
+<!-- English Revision : 826164 -->
+<!-- French translation : Lucien GENTIS -->
+<!-- Reviewed by : Vincent Deffontaines -->
+
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements.  See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+
+<modulesynopsis metafile="mod_headers.xml.meta">
+
+<name>mod_headers</name>
+<description>Personnalisation des en-t&ecirc;tes de requ&ecirc;tes et de r&eacute;ponses
+HTTP</description>
+<status>Extension</status>
+<sourcefile>mod_headers.c</sourcefile>
+<identifier>headers_module</identifier>
+
+<summary>
+    <p>Ce module fournit des directives permettant de contr&ocirc;ler et
+    modifier les en-t&ecirc;tes de requ&ecirc;tes et de r&eacute;ponses HTTP. Les en-t&ecirc;tes
+    peuvent &ecirc;tre fusionn&eacute;s, remplac&eacute;s ou supprim&eacute;s.</p>
+</summary>
+
+<section id="order"><title>Chronologie du traitement</title>
+
+    <p>Les directives fournies par <module>mod_headers</module> peuvent
+    s'ins&eacute;rer presque partout dans la configuration du serveur, et on
+    peut limiter leur port&eacute;e en les pla&ccedil;ant dans des <a
+    href="../sections.html">sections de configuration</a>.</p>
+
+    <p>La chronologie du traitement est importante et est affect&eacute;e par
+    l'ordre d'apparition des directives dans le fichier de configuration
+    et par leur placement dans les <a
+    href="../sections.html#mergin">sections de configuration</a>. Ainsi,
+    ces deux directives ont un effet diff&eacute;rent si leur ordre est invers&eacute;
+    :</p>
+
+    <example>
+      RequestHeader append MirrorID "mirror 12"<br />
+      RequestHeader unset MirrorID
+    </example>
+
+    <p>Dans cet ordre, l'en-t&ecirc;te <code>MirrorID</code> n'est pas d&eacute;fini.
+    Si l'ordre des directives &eacute;tait invers&eacute;, l'en-t&ecirc;te
+    <code>MirrorID</code> serait d&eacute;fini &agrave; "mirror 12".</p>
+</section>
+
+<section id="early"><title>Traitement pr&eacute;coce et traitement
+tardif</title>
+    <p><module>mod_headers</module> peut agir soir pr&eacute;cocement, soit
+    tardivement au niveau de la requ&ecirc;te. Le mode normal est le mode
+    tardif, lorsque les en-t&ecirc;tes de requ&ecirc;te sont d&eacute;finis, imm&eacute;diatement
+    avant l'ex&eacute;cution du g&eacute;n&eacute;rateur de contenu, et pour les en-t&ecirc;tes de
+    r&eacute;ponse, juste au moment o&ugrave; la r&eacute;ponse est envoy&eacute;e sur le r&eacute;seau.
+    Utilisez toujours le mode tardif sur un serveur en production.</p>
+
+    <p>Le mode pr&eacute;coce a &eacute;t&eacute; con&ccedil;u &agrave; des fins d'aide aux tests et au
+    d&eacute;bogage pour les d&eacute;veloppeurs. Les directives d&eacute;finies en utilisant
+    le mot-cl&eacute; <code>early</code> sont cens&eacute;es agir au tout d&eacute;but du
+    traitement de la requ&ecirc;te. Cela signifie que l'on peut les utiliser
+    pour simuler diff&eacute;rentes requ&ecirc;tes et d&eacute;finir des situations de test,
+    tout en gardant &agrave; l'esprit que les en-t&ecirc;tes peuvent &ecirc;tre modifi&eacute;s &agrave;
+    tout moment par d'autres modules avant que le r&eacute;ponse ne soit
+    g&eacute;n&eacute;r&eacute;e.</p>
+
+    <p>Comme les directives pr&eacute;coces sont trait&eacute;es avant que le
+    chemin de la requ&ecirc;te ne soit parcouru, les en-t&ecirc;tes
+    pr&eacute;coces ne peuvent &ecirc;tre d&eacute;finis que dans un contexte de serveur
+    principal ou de serveur virtuel. Les directives pr&eacute;coces ne peuvent
+    pas d&eacute;pendre d'un chemin de requ&ecirc;te, si bien qu'elles &eacute;choueront
+    dans des contextes tels que <code>&lt;Directory&gt;</code> ou
+    <code>&lt;Location&gt;</code>.</p>
+</section>
+
+<section id="examples"><title>Exemples</title>
+
+    <ol>
+      <li>
+        Copie tous les en-t&ecirc;tes de requ&ecirc;te qui commencent par "TS" vers
+	les en-t&ecirc;tes de la r&eacute;ponse :
+
+        <example>
+          Header echo ^TS
+        </example>
+      </li>
+
+      <li>
+        Ajoute &agrave; la r&eacute;ponse un en-t&ecirc;te, <code>mon-en-t&ecirc;te</code>, qui
+	contient un horodatage permettant de d&eacute;terminer le moment o&ugrave; la
+	requ&ecirc;te a &eacute;t&eacute; re&ccedil;ue, et le temps qui s'est &eacute;coul&eacute; jusqu'&agrave; ce que
+	la requ&ecirc;te ait commenc&eacute; &agrave; &ecirc;tre servie. Cet en-t&ecirc;te peut &ecirc;tre
+	utilis&eacute; par le client pour estimer la charge du serveur ou
+	isoler les goulets d'&eacute;tranglement entre le client et le
+	serveur.
+
+        <example>
+          Header set mon-en-t&ecirc;te "%D %t"
+        </example>
+
+        <p>le r&eacute;sultat est l'ajout &agrave; la r&eacute;ponse d'un en-t&ecirc;te du type :</p>
+
+        <example>
+          mon-en-t&ecirc;te: D=3775428 t=991424704447256
+        </example>
+      </li>
+
+      <li>
+        Dit Bonjour &agrave; Joe
+
+        <example>
+          Header set mon-en-t&ecirc;te "Bonjour Joe. Il a fallu %D microsecondes \<br />
+          &agrave; Apache pour servir cette requ&ecirc;te."
+        </example>
+
+        <p>le r&eacute;sultat est l'ajout &agrave; la r&eacute;ponse d'un en-t&ecirc;te du type :</p>
+
+        <example>
+          mon-en-t&ecirc;te: Bonjour Joe. Il a fallu D=3775428 microsecondes &agrave; Apache
+          pour servir cette requ&ecirc;te.
+        </example>
+      </li>
+
+      <li>
+        Ajoute l'en-t&ecirc;te <code>mon-en-t&ecirc;te</code> &agrave; la r&eacute;ponse si et
+	seulement si l'en-t&ecirc;te <code>mon-en-t&ecirc;te-requ&ecirc;te</code> est
+	pr&eacute;sent dans la requ&ecirc;te. Ceci peut s'av&eacute;rer utile pour g&eacute;n&eacute;rer
+	des en-t&ecirc;tes de r&eacute;ponse "&agrave; la t&ecirc;te du client". Notez que cet
+	exemple n&eacute;cessite les services du module
+	<module>mod_setenvif</module>.
+
+        <example>
+          SetEnvIf mon-en-t&ecirc;te-requ&ecirc;te mavaleur HAVE_MyRequestHeader<br />
+          Header set mon-en-t&ecirc;te "%D %t montexte" env=HAVE_MyRequestHeader
+        </example>
+
+        <p>Si l'en-t&ecirc;te <code>mon-en-t&ecirc;te-requ&ecirc;te: mavaleur</code> est
+	pr&eacute;sent dans la requ&ecirc;te HTTP, la r&eacute;ponse contiendra un en-t&ecirc;te
+	du type :</p>
+
+        <example>
+          mon-en-t&ecirc;te: D=3775428 t=991424704447256 montexte
+        </example>
+      </li>
+
+      <li>
+        Permet &agrave; DAV de fonctionner avec Apache sur SSL (voir la <a
+	href="http://svn.haxx.se/users/archive-2006-03/0549.shtml">description
+	du probl&egrave;me</a>) en rempla&ccedil;ant <var>https:</var> par
+	<var>http:</var> dans l'en-t&ecirc;te <var>Destination</var> :
+
+        <example>
+          RequestHeader edit Destination ^https: http: early
+        </example>
+      </li>
+
+      <li>
+        D&eacute;finit la valeur d'un m&ecirc;me en-t&ecirc;te sous de multiples conditions
+	non exclusives, mais ne duplique pas une valeur d&eacute;j&agrave; d&eacute;finie
+	dans l'en-t&ecirc;te qui en r&eacute;sulte. Si toutes les conditions
+	suivantes sont satisfaites pour une requ&ecirc;te (en d'autres termes,
+	si les trois variables d'environnement <code>CGI</code>,
+	<code>NO_CACHE</code> et <code>NO_STORE</code> existent pour la
+	requ&ecirc;te) :
+
+        <example>
+          Header merge Cache-Control no-cache env=CGI<br />
+          Header merge Cache-Control no-cache env=NO_CACHE<br />
+          Header merge Cache-Control no-store env=NO_STORE
+        </example>
+
+        <p>alors, la r&eacute;ponse contiendra l'en-t&ecirc;te suivant :</p>
+
+        <example>
+          Cache-Control: no-cache, no-store
+        </example>
+
+        <p>Si <code>append</code> avait &eacute;t&eacute; utilis&eacute; &agrave; la place de
+	<code>merge</code>, la r&eacute;ponse aurait contenu l'en-t&ecirc;te suivant
+	:</p>
+
+        <example>
+          Cache-Control: no-cache, no-cache, no-store
+        </example>
+      </li>
+      <li>
+        D&eacute;finit un cookie de test si et seulement si le client n'envoie
+	pas de cookie
+        <example>
+          Header set Set-Cookie testcookie !$req{Cookie}
+        </example>
+      </li>
+    </ol>
+</section>
+
+<directivesynopsis>
+<name>RequestHeader</name>
+<description>Configure les en-t&ecirc;tes d'une requ&ecirc;te HTTP</description>
+<syntax>RequestHeader add|append|edit|merge|set|unset <var>en-t&ecirc;te</var>
+[<var>valeur</var>] [<var>remplacement</var>] [early|env=[!]<var>variable</var>]</syntax>
+<contextlist><context>server config</context><context>virtual host</context>
+<context>directory</context><context>.htaccess</context></contextlist>
+<override>FileInfo</override>
+
+<usage>
+    <p>Cette directive permet de remplacer, fusionner, modifier ou
+    supprimer des en-t&ecirc;tes de requ&ecirc;te HTTP. L'en-t&ecirc;te est modifi&eacute; juste
+    avant que le gestionnaire de contenu ne s'ex&eacute;cute, ce qui permet la
+    modification des en-t&ecirc;tes entrants. L'action effectu&eacute;e est
+    d&eacute;termin&eacute;e par le premier argument. Ce dernier accepte les valeurs
+    suivantes :</p>
+
+    <dl>
+
+    <dt><code>add</code></dt>
+    <dd>L'en-t&ecirc;te est ajout&eacute; au jeu d'en-t&ecirc;tes pr&eacute;existant, m&ecirc;me s'il
+    existe d&eacute;j&agrave;. Ceci peut conduire &agrave; la pr&eacute;sence de deux (ou plusieurs)
+    en-t&ecirc;tes poss&egrave;dant le m&ecirc;me nom et donc induire des cons&eacute;quences
+    impr&eacute;vues ; en g&eacute;n&eacute;ral, il est pr&eacute;f&eacute;rable d'utiliser
+    <code>set</code>, <code>append</code> ou <code>merge</code>.</dd>
+
+    <dt><code>append</code></dt>
+    <dd>La valeur d'en-t&ecirc;te est ajout&eacute;e &agrave; tout en-t&ecirc;te existant de m&ecirc;me
+    nom. Lorsqu'une nouvelle valeur est ainsi ajout&eacute;e, elle est s&eacute;par&eacute;e
+    de celles qui sont d&eacute;j&agrave; pr&eacute;sentes par une virgule. Il s'agit de la
+    m&eacute;thode HTTP standard permettant d'affecter plusieurs valeurs &agrave; un
+    en-t&ecirc;te.</dd>
+
+    <dt><code>edit</code></dt>
+    <dd>Si l'en-t&ecirc;te existe, sa valeur est modifi&eacute;e en fonction d'une
+    <glossary ref="regex">expression rationnelle</glossary> de type
+    recherche/remplacement. L'argument <var>valeur</var> est une
+    <glossary ref="regex">expression rationnelle</glossary>, et
+    l'argument <var>remplacement</var> une cha&icirc;ne de caract&egrave;res de
+    remplacement qui peut contenir des r&eacute;f&eacute;rences arri&egrave;res.</dd>
+
+    <dt><code>merge</code></dt>
+    <dd>La valeur d'en-t&ecirc;te est ajout&eacute;e &agrave; tout en-t&ecirc;te de m&ecirc;me nom, sauf
+    si elle appara&icirc;t d&eacute;j&agrave; dans la liste des valeurs pr&eacute;existantes de
+    l'en-t&ecirc;te s&eacute;par&eacute;es par des virgules. Lorsqu'une nouvelle valeur est
+    ainsi ajout&eacute;e, elle est s&eacute;par&eacute;e de celles qui sont d&eacute;j&agrave; pr&eacute;sentes
+    par une virgule. Il s'agit de la m&eacute;thode HTTP standard permettant
+    d'affecter plusieurs valeurs &agrave; un en-t&ecirc;te. Les valeurs sont
+    compar&eacute;es en tenant compte de la casse, et apr&egrave;s le traitement de
+    tous les sp&eacute;cificateurs de format. Une valeur entour&eacute;e de guillemets
+    est consid&eacute;r&eacute;e comme diff&eacute;rente de la m&ecirc;me valeur mais sans
+    guillemets.</dd>
+
+    <dt><code>set</code></dt>
+    <dd>L'en-t&ecirc;te est d&eacute;fini, rempla&ccedil;ant tout en-t&ecirc;te pr&eacute;existant avec
+    le m&ecirc;me nom.</dd>
+
+    <dt><code>unset</code></dt>
+    <dd>L'en-t&ecirc;te est supprim&eacute; s'il existe. Si plusieurs en-t&ecirc;tes
+    poss&egrave;dent le m&ecirc;me nom, ils seront tous supprim&eacute;s. L'argument
+    <var>value</var> ne doit pas appara&icirc;tre.</dd>
+    </dl>
+
+    <p>Cet argument est suivi d'un nom d'en-t&ecirc;te qui peut se terminer
+    par un caract&egrave;re ':', mais ce n'est pas obligatoire. La casse est
+    ignor&eacute;e. Avec <code>set</code>, <code>append</code>,
+    <code>merge</code> et <code>add</code>, une <var>valeur</var> est
+    fournie en troisi&egrave;me argument. Si une <var>valeur</var> contient des
+    espaces, elle doit &ecirc;tre entour&eacute;e de guillemets. Avec
+    <code>unset</code>, aucune <var>valeur</var> ne doit appara&icirc;tre.
+    <var>valeur</var> peut &ecirc;tre une cha&icirc;ne de caract&egrave;res, une cha&icirc;ne
+    contenant des sp&eacute;cificateurs de format, ou une combinaison des deux.
+    Les sp&eacute;cificateurs de format support&eacute;s sont les m&ecirc;mes que ceux de la
+    directive <directive module="mod_headers">Header</directive>, &agrave;
+    laquelle vous pouvez vous reporter pour plus de d&eacute;tails. Avec
+    <code>edit</code>, les deux arguments <var>valeur</var> et
+    <var>remplacement</var> sont obligatoires, et correspondent
+    respectivement &agrave; une <glossary ref="regex">expression
+    rationnelle</glossary> et &agrave; une cha&icirc;ne de remplacement.</p>
+
+    <p>La directive <directive>RequestHeader</directive> peut &ecirc;tre
+    suivie d'un argument suppl&eacute;mentaire, qui pourra prendre les valeurs
+    suivantes :</p>
+    <dl>
+    <dt><code>early</code></dt>
+    <dd>Sp&eacute;cifie <a href="#early">traitement pr&eacute;alable</a>.</dd>
+    <dt><code>env=[!]variable</code></dt>
+    <dd>La directive est appliqu&eacute;e si et seulement si la <a
+    href="../env.html">variable d'environnement</a>
+    <code>variable</code> existe. Un <code>!</code> devant
+    <code>variable</code> inverse le test, et la directive ne
+    s'appliquera alors que si <code>variable</code> n'est pas d&eacute;finie.</dd>
+    <dt><code>expr</code></dt>
+    <dd>Une cha&icirc;ne qui correspond &agrave; toute valeur ci-dessus est
+    interpr&eacute;t&eacute;e comme une expression. Les d&eacute;tails &agrave; propos de la syntaxe
+    des expressions et leur &eacute;valuation sont pour l'instant mieux
+    document&eacute;s dans la page de <module>mod_filter</module>.</dd>
+    </dl>
+
+    <p>Except&eacute; le cas du mode <a href="#early">pr&eacute;coce</a>, la directive
+    <directive>RequestHeader</directive> est trait&eacute;e juste avant la
+    prise en compte de la requ&ecirc;te par son gestionnaire, au cours de la
+    phase de v&eacute;rification. Ceci permet la modification des en-t&ecirc;tes
+    g&eacute;n&eacute;r&eacute;s par le navigateur, ou par les filtres en entr&eacute;e
+    d'Apache.</p>
+</usage>
+</directivesynopsis>
+
+<directivesynopsis>
+<name>Header</name>
+<description>Configure les en-t&ecirc;tes d'une r&eacute;ponse HTTP</description>
+<syntax>Header [<var>condition</var>] add|append|echo|edit|merge|set|unset
+<var>en-t&ecirc;te</var> [<var>valeur</var>] [early|env=[!]<var>variable</var>]</syntax>
+<contextlist><context>server config</context><context>virtual host</context>
+<context>directory</context><context>.htaccess</context></contextlist>
+<override>FileInfo</override>
+
+<usage>
+    <p>Cette directive permet de remplacer, fusionner, ou
+    supprimer des en-t&ecirc;tes de r&eacute;ponse HTTP. L'en-t&ecirc;te est modifi&eacute; juste
+    apr&egrave;s que le gestionnaire de contenu et les filtres en sortie ne
+    s'ex&eacute;cutent, ce qui permet la modification des en-t&ecirc;tes
+    sortants.</p>
+
+    <p>Par d&eacute;faut, cette directive n'affecte que les r&eacute;ponses positives
+    (r&eacute;ponses dont le code de statut est dans la gamme
+    <code>2<var>xx</var></code>). Le param&egrave;tre optionnel
+    <var>condition</var> peut prendre pour valeur soit
+    <code>onsuccess</code> (valeur par d&eacute;faut), soit <code>always</code>
+    (tous les codes de statut, y compris les r&eacute;ponses positives).
+    D&eacute;finir cette valeur &agrave; <code>always</code> permet d'affecter des
+    en-t&ecirc;tes d&eacute;finis par certains modules internes, y compris dans le
+    cas d'une r&eacute;ponse positive, et s'av&egrave;re m&ecirc;me n&eacute;cessaire pour affecter
+    des en-t&ecirc;tes de r&eacute;ponses dont le code de statut n'est pas dans la
+    gamme <code>2<var>xx</var></code> comme les redirections ou les
+    erreurs client.</p>
+
+    <p>L'action que cette directive provoque est d&eacute;termin&eacute;e par le
+    second argument. Il peut prendre une des valeurs suivantes :</p>
+
+    <dl>
+    <dt><code>add</code></dt>
+    <dd>L'en-t&ecirc;te est ajout&eacute; au jeu d'en-t&ecirc;tes pr&eacute;existant, m&ecirc;me s'il
+    existe d&eacute;j&agrave;. Ceci peut conduire &agrave; la pr&eacute;sence de deux (ou plusieurs)
+    en-t&ecirc;tes poss&egrave;dant le m&ecirc;me nom et donc induire des cons&eacute;quences
+    impr&eacute;vues ; en g&eacute;n&eacute;ral, il est pr&eacute;f&eacute;rable d'utiliser
+    <code>set</code>, <code>append</code> ou <code>merge</code>.</dd>
+
+    <dt><code>append</code></dt>
+    <dd>La valeur d'en-t&ecirc;te est ajout&eacute;e &agrave; tout en-t&ecirc;te existant de m&ecirc;me
+    nom. Lorsqu'une nouvelle valeur est ainsi ajout&eacute;e, elle est s&eacute;par&eacute;e
+    de celles qui sont d&eacute;j&agrave; pr&eacute;sentes par une virgule. Il s'agit de la
+    m&eacute;thode HTTP standard permettant d'affecter plusieurs valeurs &agrave; un
+    en-t&ecirc;te.</dd>
+
+    <dt><code>echo</code></dt>
+    <dd>Les en-t&ecirc;tes de la requ&ecirc;te poss&eacute;dant le nom sp&eacute;cifi&eacute; sont
+    recopi&eacute;s vers les en-t&ecirc;tes de la r&eacute;ponse. <var>en-t&ecirc;te</var> peut
+    &ecirc;tre une <glossary ref="regex">expression rationnelle</glossary>, et
+    <var>valeur</var> ne doit pas &ecirc;tre pr&eacute;sent.</dd>
+
+    <dt><code>edit</code></dt>
+    <dd>Si l'en-t&ecirc;te existe, sa valeur est modifi&eacute;e en fonction d'une
+    <glossary ref="regex">expression rationnelle</glossary> de type
+    recherche/remplacement. L'argument <var>valeur</var> est une
+    <glossary ref="regex">expression rationnelle</glossary>, et
+    l'argument <var>remplacement</var> une cha&icirc;ne de caract&egrave;res de
+    remplacement qui peut contenir des r&eacute;f&eacute;rences arri&egrave;res.</dd>
+
+    <dt><code>merge</code></dt>
+    <dd>La valeur d'en-t&ecirc;te est ajout&eacute;e &agrave; tout en-t&ecirc;te de m&ecirc;me nom, sauf
+    si elle appara&icirc;t d&eacute;j&agrave; dans la liste des valeurs pr&eacute;existantes de
+    l'en-t&ecirc;te s&eacute;par&eacute;es par des virgules. Lorsqu'une nouvelle valeur est
+    ainsi ajout&eacute;e, elle est s&eacute;par&eacute;e de celles qui sont d&eacute;j&agrave; pr&eacute;sentes
+    par une virgule. Il s'agit de la m&eacute;thode HTTP standard permettant
+    d'affecter plusieurs valeurs &agrave; un en-t&ecirc;te. Les valeurs sont
+    compar&eacute;es en tenant compte de la casse, et apr&egrave;s le traitement de
+    tous les sp&eacute;cificateurs de format. Une valeur entour&eacute;e de guillemets
+    est consid&eacute;r&eacute;e comme diff&eacute;rente de la m&ecirc;me valeur mais sans
+    guillemets.</dd>
+
+    <dt><code>set</code></dt>
+    <dd>L'en-t&ecirc;te est d&eacute;fini, rempla&ccedil;ant tout en-t&ecirc;te pr&eacute;existant avec
+    le m&ecirc;me nom. L'argument <var>valeur</var> peut &ecirc;tre une cha&icirc;ne de
+    formatage.</dd>
+
+    <dt><code>unset</code></dt>
+    <dd>L'en-t&ecirc;te est supprim&eacute; s'il existe. Si plusieurs en-t&ecirc;tes
+    poss&egrave;dent le m&ecirc;me nom, ils seront tous supprim&eacute;s. L'argument
+    <var>value</var> ne doit pas appara&icirc;tre.</dd>
+    </dl>
+
+    <p>Cet argument est suivi d'un nom d'<var>en-t&ecirc;te</var> qui peut se
+    terminer par un caract&egrave;re ':', mais ce n'est pas obligatoire. La
+    casse est ignor&eacute;e avec <code>set</code>, <code>append</code>,
+    <code>merge</code>, <code>add</code>, <code>unset</code> et
+    <code>edit</code>. Le nom d'<var>en-t&ecirc;te</var> est sensible &agrave; la
+    casse pour <code>echo</code> et peut &ecirc;tre une <glossary
+    ref="regex">expression rationnelle</glossary>.</p>
+
+    <p>Avec <code>set</code>, <code>append</code>, <code>merge</code> et
+    <code>add</code>, une <var>valeur</var> est sp&eacute;cifi&eacute;e comme
+    troisi&egrave;me argument. Si <var>valeur</var> contient des espaces, elle
+    doit &ecirc;tre entour&eacute;e de guillemets. <var>valeur</var> peut &ecirc;tre une
+    cha&icirc;ne de caract&egrave;res, une cha&icirc;ne contenant des sp&eacute;cificateurs de
+    format, ou une combinaison des deux. <var>valeur</var> supporte les
+    sp&eacute;cificateurs de format suivants :</p>
+
+    <table border="1" style="zebra">
+    <columnspec><column width=".25"/><column width=".75"/></columnspec>
+    <tr><th>Format</th><th>Description</th></tr>
+    <tr><td><code>%%</code></td>
+        <td>Le caract&egrave;re pourcentage</td></tr>
+
+    <tr><td><code>%t</code></td>
+        <td>Le moment de r&eacute;ception de la requ&ecirc;te en temps
+	universel coordonn&eacute; depuis le temps epoch (Jan. 1, 1970) et
+	exprim&eacute; en microsecondes. La valeur est pr&eacute;c&eacute;d&eacute;e de
+	<code>t=</code>.</td></tr>
+
+    <tr><td><code>%D</code></td>
+        <td>Le temps &eacute;coul&eacute; entre la r&eacute;ception de la requ&ecirc;te et l'envoi
+	des en-t&ecirc;tes sur le r&eacute;seau. Il s'agit de la dur&eacute;e de traitement
+	de la requ&ecirc;te. La valeur est pr&eacute;c&eacute;d&eacute;e de <code>D=</code>. La
+	valeur est exprim&eacute;e en microsecondes.</td></tr>
+
+    <tr><td><code>%{NOM_VARIABLE}e</code></td>
+        <td>Le contenu de la <a href="../env.html">variable
+	d'environnement</a> <code>NOM_VARIABLE</code>.</td></tr>
+
+    <tr><td><code>%{NOM_VARIABLE}s</code></td>
+        <td>Le contenu de la <a href="../env.html">variable
+	d'environnement SSL</a> <code>NOM_VARIABLE</code>, si
+	<module>mod_ssl</module> est activ&eacute;.</td></tr>
+
+    </table>
+
+    <note><title>Note</title>
+      <p>Le sp&eacute;cificateur de format <code>%s</code> est disponible
+      depuis la version 2.1 d'Apache ; il peut &ecirc;tre utilis&eacute; &agrave; la place
+      de <code>%e</code> pour &eacute;viter de devoir sp&eacute;cifier
+      <code>SSLOptions +StdEnvVars</code>. Cependant, si
+      <code>SSLOptions +StdEnvVars</code> doit tout de m&ecirc;me &ecirc;tre
+      sp&eacute;cifi&eacute; pour une raison quelconque, <code>%e</code> sera plus
+      efficace que <code>%s</code>.</p>
+    </note>
+
+    <p><code>edit</code>n&eacute;cessite les deux arguments
+    <var>valeur</var>, qui est une <glossary ref="regex">expression
+    rationnelle</glossary>, et une cha&icirc;ne additionnelle
+    <var>remplacement</var>.</p>
+
+    <p>La directive <directive>Header</directive> peut &ecirc;tre suivie d'un
+    argument additionnel qui peut prendre les valeurs suivantes :</p>
+
+    <dl>
+    <dt><code>early</code></dt>
+    <dd>Sp&eacute;cifie <a href="#early">traitement pr&eacute;alable</a>.</dd>
+    <dt><code>env=[!]variable</code></dt>
+    <dd>La directive est appliqu&eacute;e si et seulement si la <a
+    href="../env.html">variable d'environnement</a>
+    <code>variable</code> existe. Un <code>!</code> devant
+    <code>variable</code> inverse le test, et la directive ne
+    s'appliquera alors que si <code>variable</code> n'est pas d&eacute;finie.</dd>
+    <dt><code>expr</code></dt>
+    <dd>Une cha&icirc;ne qui correspond &agrave; toute valeur ci-dessus est
+    interpr&eacute;t&eacute;e comme une expression. Les d&eacute;tails &agrave; propos de la syntaxe
+    des expressions et leur &eacute;valuation sont pour l'instant mieux
+    document&eacute;s dans la page de <module>mod_filter</module>.</dd>
+    </dl>
+
+    <p>Except&eacute; le cas du mode <a href="#early">pr&eacute;coce</a>, les
+    directives <directive>Header</directive> sont trait&eacute;es juste avant
+    l'envoi de la r&eacute;ponse sur le r&eacute;seau. Cela signifie qu'il est
+    possible de d&eacute;finir et/ou modifier la plupart des en-t&ecirc;tes, &agrave;
+    l'exception de ceux qui sont ajout&eacute;s par le filtre d'en-t&ecirc;te.</p>
+</usage>
+</directivesynopsis>
+
+</modulesynopsis>
+

Modified: httpd/httpd/trunk/docs/manual/mod/mod_headers.xml.meta
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/docs/manual/mod/mod_headers.xml.meta?rev=831756&r1=831755&r2=831756&view=diff
==============================================================================
--- httpd/httpd/trunk/docs/manual/mod/mod_headers.xml.meta (original)
+++ httpd/httpd/trunk/docs/manual/mod/mod_headers.xml.meta Sun Nov  1 20:13:27 2009
@@ -8,6 +8,7 @@
 
   <variants>
     <variant>en</variant>
+    <variant>fr</variant>
     <variant outdated="yes">ja</variant>
     <variant outdated="yes">ko</variant>
   </variants>

Modified: httpd/httpd/trunk/docs/manual/mod/mod_unique_id.html
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/docs/manual/mod/mod_unique_id.html?rev=831756&r1=831755&r2=831756&view=diff
==============================================================================
--- httpd/httpd/trunk/docs/manual/mod/mod_unique_id.html (original)
+++ httpd/httpd/trunk/docs/manual/mod/mod_unique_id.html Sun Nov  1 20:13:27 2009
@@ -4,6 +4,10 @@
 Content-Language: en
 Content-type: text/html; charset=ISO-8859-1
 
+URI: mod_unique_id.html.fr
+Content-Language: fr
+Content-type: text/html; charset=ISO-8859-1
+
 URI: mod_unique_id.html.ja.utf8
 Content-Language: ja
 Content-type: text/html; charset=UTF-8

Modified: httpd/httpd/trunk/docs/manual/mod/mod_unique_id.html.en
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/docs/manual/mod/mod_unique_id.html.en?rev=831756&r1=831755&r2=831756&view=diff
==============================================================================
--- httpd/httpd/trunk/docs/manual/mod/mod_unique_id.html.en (original)
+++ httpd/httpd/trunk/docs/manual/mod/mod_unique_id.html.en Sun Nov  1 20:13:27 2009
@@ -22,6 +22,7 @@
 <div id="preamble"><h1>Apache Module mod_unique_id</h1>
 <div class="toplang">
 <p><span>Available Languages: </span><a href="../en/mod/mod_unique_id.html" title="English">&nbsp;en&nbsp;</a> |
+<a href="../fr/mod/mod_unique_id.html" hreflang="fr" rel="alternate" title="Français">&nbsp;fr&nbsp;</a> |
 <a href="../ja/mod/mod_unique_id.html" hreflang="ja" rel="alternate" title="Japanese">&nbsp;ja&nbsp;</a> |
 <a href="../ko/mod/mod_unique_id.html" hreflang="ko" rel="alternate" title="Korean">&nbsp;ko&nbsp;</a></p>
 </div>
@@ -208,6 +209,7 @@
 </div>
 <div class="bottomlang">
 <p><span>Available Languages: </span><a href="../en/mod/mod_unique_id.html" title="English">&nbsp;en&nbsp;</a> |
+<a href="../fr/mod/mod_unique_id.html" hreflang="fr" rel="alternate" title="Français">&nbsp;fr&nbsp;</a> |
 <a href="../ja/mod/mod_unique_id.html" hreflang="ja" rel="alternate" title="Japanese">&nbsp;ja&nbsp;</a> |
 <a href="../ko/mod/mod_unique_id.html" hreflang="ko" rel="alternate" title="Korean">&nbsp;ko&nbsp;</a></p>
 </div><div id="footer">

Added: httpd/httpd/trunk/docs/manual/mod/mod_unique_id.html.fr
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/docs/manual/mod/mod_unique_id.html.fr?rev=831756&view=auto
==============================================================================
--- httpd/httpd/trunk/docs/manual/mod/mod_unique_id.html.fr (added)
+++ httpd/httpd/trunk/docs/manual/mod/mod_unique_id.html.fr Sun Nov  1 20:13:27 2009
@@ -0,0 +1,240 @@
+<?xml version="1.0" encoding="ISO-8859-1"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" lang="fr" xml:lang="fr"><head><!--
+        XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+              This file is generated from xml source: DO NOT EDIT
+        XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+      -->
+<title>mod_unique_id - Serveur Apache HTTP</title>
+<link href="../style/css/manual.css" rel="stylesheet" media="all" type="text/css" title="Main stylesheet" />
+<link href="../style/css/manual-loose-100pc.css" rel="alternate stylesheet" media="all" type="text/css" title="No Sidebar - Default font size" />
+<link href="../style/css/manual-print.css" rel="stylesheet" media="print" type="text/css" />
+<link href="../images/favicon.ico" rel="shortcut icon" /></head>
+<body>
+<div id="page-header">
+<p class="menu"><a href="../mod/">Modules</a> | <a href="../mod/directives.html">Directives</a> | <a href="../faq/">FAQ</a> | <a href="../glossary.html">Glossaire</a> | <a href="../sitemap.html">Plan du site</a></p>
+<p class="apache">Serveur Apache HTTP Version 2.3</p>
+<img alt="" src="../images/feather.gif" /></div>
+<div class="up"><a href="./"><img title="&lt;-" alt="&lt;-" src="../images/left.gif" /></a></div>
+<div id="path">
+<a href="http://www.apache.org/">Apache</a> &gt; <a href="http://httpd.apache.org/">Serveur HTTP</a> &gt; <a href="http://httpd.apache.org/docs/">Documentation</a> &gt; <a href="../">Version 2.3</a> &gt; <a href="./">Modules</a></div>
+<div id="page-content">
+<div id="preamble"><h1>Module Apache mod_unique_id</h1>
+<div class="toplang">
+<p><span>Langues Disponibles: </span><a href="../en/mod/mod_unique_id.html" hreflang="en" rel="alternate" title="English">&nbsp;en&nbsp;</a> |
+<a href="../fr/mod/mod_unique_id.html" title="Français">&nbsp;fr&nbsp;</a> |
+<a href="../ja/mod/mod_unique_id.html" hreflang="ja" rel="alternate" title="Japanese">&nbsp;ja&nbsp;</a> |
+<a href="../ko/mod/mod_unique_id.html" hreflang="ko" rel="alternate" title="Korean">&nbsp;ko&nbsp;</a></p>
+</div>
+<table class="module"><tr><th><a href="module-dict.html#Description">Description:</a></th><td>Fournit une variable d'environnement contenant un
+identifiant unique pour chaque requête</td></tr>
+<tr><th><a href="module-dict.html#Status">Statut:</a></th><td>Extension</td></tr>
+<tr><th><a href="module-dict.html#ModuleIdentifier">Identificateur de Module:</a></th><td>unique_id_module</td></tr>
+<tr><th><a href="module-dict.html#SourceFile">Fichier Source:</a></th><td>mod_unique_id.c</td></tr></table>
+<h3>Sommaire</h3>
+
+
+    <p>Ce module fournit un identifiant dont l'unicité est garantie
+    parmi "toutes" les requêtes sous des conditions très précises.
+    L'identifiant unique le sera aussi parmi plusieurs machines
+    appartenant à un cluster correctement configuré. L'identifiant est
+    affecté à la variable d'environnement <code>UNIQUE_ID</code> pour
+    chaque requête. Les identifiants uniques sont utiles pour diverses
+    raisons dont la nature se situe au delà de la portée de ce
+    document.</p>
+</div>
+<div id="quickview"><h3 class="directives">Directives</h3>
+<p>Ce module ne fournit aucune directive.</p>
+<h3>Sujets</h3>
+<ul id="topics">
+<li><img alt="" src="../images/down.gif" /> <a href="#theory">Théorie</a></li>
+</ul></div>
+<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
+<div class="section">
+<h2><a name="theory" id="theory">Théorie</a></h2>
+    
+
+    <p>Tout d'abord un bref rappel de la manière dont le serveur Apache
+    fonctionne sous Unix (cette fonctionnalité n'étant actuellement pas
+    supportée sous Windows NT). Sous Unix, Apache crée plusieurs
+    processus enfants, ces derniers traitant les requêtes une par une.
+    Chaque processus enfant peut traiter plusieurs requêtes pendant sa
+    durée de vie. Dans le cadre de cette discussion, nous supposerons
+    que les différents processus enfants ne s'échangent pas de données
+    entre eux. Nous nous référerons aux processus enfants sous le nom de
+    <dfn>processus httpd</dfn>.</p>
+
+    <p>Votre site web est réparti entre une ou plusieurs machines dont
+    vous êtes l'administrateur, et que nous nommerons cluster de
+    serveurs. Chaque serveur peut exécuter plusieurs instances d'Apache.
+    L'ensemble de ces dernières sera considéré comme "l'Univers", et
+    sous certaines hypothèses, nous montrerons qu'il est possible dans
+    cet univers, de générer des identifiants uniques pour chaque
+    requête, sans pour autant nécessiter une communication importante
+    entre les différents serveurs du cluster.</p>
+
+    <p>Les machines de votre cluster doivent satisfaire ces conditions
+    (même si le cluster ne comporte qu'une machine, vous devez
+    synchroniser son horloge avec NTP) :</p>
+
+    <ul>
+      <li>Les temps des machines sont synchronisés via NTP ou tout autre
+      protocole de synchronisation du temps en réseau.</li>
+
+      <li>Les nom d'hôtes des machines sont tous différents, de façon à
+      ce que le module puisse recevoir une adresse IP différente pour
+      chaque machine du cluster en effectuant une recherche sur le nom
+      d'hôte.</li>
+    </ul>
+
+    <p>Au vu des caractéristiques actuelles du système d'exploitation,
+    nous supposerons que les pids (identifiants processus) sont codés
+    sur 32 bits. Si le système d'exploitation utilise plus de 32 bits
+    pour un pid, la correction est triviale mais doit être effectuée
+    dans le code.</p>
+
+    <p>Ces hypothèses posées, à un instant donné, nous pouvons
+    distinguer tout processus httpd sur toute machine du cluster de tous
+    les autres processus httpd. Pour ce faire, il suffit d'utiliser
+    l'adresse IP de la machine et le pid du processus httpd. Ainsi, afin
+    de générer des identifiants uniques pour chaque requête, il suffit
+    d'effectuer une distinction en fonction du temps.</p>
+
+    <p>Pour déterminer le temps, nous utiliserons un repère de temps
+    Unix (les secondes écoulées depuis le 1er janvier 1970 UTC), et un
+    compteur 16 bits. La précision du repère de temps n'étant que d'une
+    seconde, le compteur va représenter 65536 valeurs par seconde. Le
+    quadruplet <em>(adresse IP, pid, repère de temps, compteur)</em> est
+    en mesure de distinguer 65536 requêtes par seconde par processus
+    httpd. Il peut cependant arriver que le même pid soit réutilisé au
+    cours du temps, et le compteur est là pour pallier cet
+    inconvénient.</p>
+
+    <p>Lorsqu'un processus enfant httpd est créé, le compteur est
+    initialisé avec (nombre de microsecondes actuel divisé par 10)
+    modulo 65536 (cette formule a été choisie pour éliminer certains
+    problème de variance avec les bits de poids faibles du compteur de
+    microsecondes sur certains systèmes). Lorsqu'un identifiant unique
+    est généré, le repère de temps utilisé est le moment où la requête
+    arrive sur le serveur web. Le compteur est incrémenté à chaque
+    création d'identifiant (et peut repasser à 0 lorsqu'il a atteint sa
+    valeur maximale).</p>
+
+    <p>Le noyau génère un pid pour chaque processus lors de sa création,
+    et le compteur de pid est réinitialisé à une certaine valeur
+    lorsqu'il a atteint sa valeur maximale (les pid sont codés sur 16
+    bits sous de nombreux Unixes, mais les systèmes les plus récents les
+    ont étendus à 32 bits). La même valeur de pid pourra donc être
+    réutilisée au cours du temps. Cependant, tant qu'elle n'est pas
+    réutilisée dans la même seconde, elle ne remet pas en cause
+    l'unicité de notre quadruplet. Nous supposerons donc que le système
+    ne créera pas plus de 65536 processus en une seconde (ce nombre peut
+    être de 32768 sous certains Unixes, mais même dans ce cas, on est en
+    général loin de cette situation).</p>
+
+    <p>Il est possible que le temps se répète pour une raison
+    quelconque.
+    Supposons par exemple que l'horloge système soit retardée et repasse
+    par un temps passé (ou bien, comme elle avançait, elle a été remise
+    à l'heure, et elle repasse par un temps futur). Dans ce cas, il peut
+    être facilement démontré que le couple pid/repère de temps peut être
+    réutilisé. Le choix de la formule d'initialisation du compteur a
+    été effectué dans l'intention de pallier ce problème. Notez qu'un
+    nombre vraiment aléatoire serait souhaitable pour initialiser le
+    compteur, mais il n'existe pas de tel nombre directement lisible sur
+    la plupart des systèmes (c'est à dire que vous ne pouvez pas
+    utiliser rand() car vous devez déclencher le générateur avec une
+    valeur unique, et vous ne pouvez pas utiliser le temps à cet effet
+    car celui-ci , au moins à la seconde près, s'est répété). Il ne
+    s'agit donc pas d'une défense parfaite.</p>
+
+    <p>Même si elle n'est pas parfaite, quel est le degré d'efficacité
+    de cette défense ? Supposons
+    qu'une de vos machines serve au plus 500 requêtes par seconde (ce
+    qui constitue une limite supérieure très raisonnable au moment où ce
+    document est écrit, car les systèmes ne se contentent en général pas
+    de débiter des fichiers statiques). Pour y parvenir, un certain nombre
+    de processus enfants sera nécessaire, qui dépendra du nombre de
+    clients simultanés présents. Mais soyons pessimiste et supposons
+    qu'un seul processus enfant soit capable de servir 500 requêtes par
+    secondes.
+    Il existe 1000 valeurs de démarrage possibles du compteur pour
+    lesquelles deux séquences de 500 requêtes puissent se recouvrir. Il
+    y a donc 1,5% de chance que le processus enfant répète une valeur de
+    compteur si le temps se répète (avec une résolution d'une seconde),
+    et l'unicité sera alors remise en cause. C'est cependant un exemple
+    très pessimiste, et avec les valeurs du monde réel, il y a bien
+    moins de chances que cela ne se produise. Si vous estimez que ceci a
+    tout de même quelque chances de se produire sur votre système, vous
+    pouvez migrer vers un compteur à 32 bits (en modifiant le code).</p>
+
+    <p>On pourrait supposer que ceci a plus de chance de se produire
+    lors du passage à l'heure d'hiver où l'horloge est "retardée". Cela
+    ne constitue cependant pas un problème car les temps pris en compte
+    ici sont des temps UTC, qui vont "toujours" de l'avant. Notez que
+    les Unixes à base de processeur x86 peuvent nécessiter une
+    configuration particulière pour que ceci soit vrai -- il doivent
+    être configurés pour assumer que l'horloge système est en UTC et
+    compenser de manière appropriée. Mais même dans ce cas, si vous
+    utilisez NTP, votre temps UTC sera correct peu après le
+    redémarrage.</p>
+
+    <p>La variable d'environnement <code>UNIQUE_ID</code> est construite
+    par codage du quadruplet de 112 bits (adresse IP sur 32 bits, pid
+    sur 32 bits, repère de temps sur 32 bits et compteur 16 bits) en
+    utilisant l'alphabet <code>[A-Za-z0-9@-]</code> d'une manière
+    similaire à celle du codage MIME base64, et sa valeur se présente
+    sous la forme d'une chaîne de 19 caractères. L'alphabet MIME base64
+    est en fait <code>[A-Za-z0-9+/]</code> ; cependant, les caractères
+    <code>+</code> et <code>/</code> nécessitent un codage particulier
+    dans les URLs, ce qui rend leur utilisation peu commode. Toutes les
+    valeurs sont codées dans l'ordre des octets d'une adresse réseau de
+    façon à ce
+    que le codage soit comparable entre des architectures où l'ordre des
+    octets est différent. L'ordre réel de codage est : repère de temps,
+    adresse IP, pid, compteur. Cet ordre de codage possède un but
+    précis, mais il faut souligner que les applications n'ont aucun
+    intérêt à entrer dans les détails de ce codage. Les applications
+    doivent se contenter de traiter la variable <code>UNIQUE_ID</code>
+    comme un symbole opaque, qui peut être comparé avec d'autres
+    <code>UNIQUE_ID</code>s en ne testant que leur égalité.</p>
+
+    <p>L'ordre a été choisi de façon à ce qu'il soit possible de
+    modifier le codage dans le futur sans avoir à se préoccuper de
+    conflits éventuels avec une base de données de
+    <code>UNIQUE_ID</code>s existante. Les nouveaux codages doivent
+    conserver le repère de temps comme premier élément, et pour le
+    reste, utiliser les même alphabet et longueur en bits. Comme les
+    repères de temps constituent essentiellement un séquence croissante,
+    il suffit que toutes les machines du cluster arrêtent de servir et
+    de requérir dans la même <em>seconde repère</em>, et n'utilisent
+    alors plus l'ancien format de codage. Ensuite, elles peuvent
+    reprendre le traitement des requêtes en utilisant les nouveaux
+    codages.</p>
+
+    <p>Nous pensons que ceci apporte une solution relativement portable
+    au problème. Elle peut être étendue aux systèmes multithreadés comme
+    Windows NT, et peut évoluer en fonction des besoins futurs. Les
+    identifiants générés possèdent une durée de vie pratiquement infinie
+    car les identifiants futurs pourront être allongés selon les
+    besoins. Pratiquement aucune communication n'est requise entre les
+    machines du cluster (seule la synchronisation NTP est requise, ce
+    qui représente une charge très faible), et aucune communication
+    entre les processus httpd n'est nécessaire (la communication est
+    implicite et incluse dans le pid assigné par le noyau). Dans des
+    situations très spécifiques, l'identifiant peut être raccourci, mais
+    dans ce cas, d'avantage d'informations doivent être admises (par
+    exemple, les 32 bits de l'adresse IP sont excessifs pour la plupart
+    des sites, mais il n'existe pas de valeur de remplacement portable
+    plus courte).</p>
+</div>
+</div>
+<div class="bottomlang">
+<p><span>Langues Disponibles: </span><a href="../en/mod/mod_unique_id.html" hreflang="en" rel="alternate" title="English">&nbsp;en&nbsp;</a> |
+<a href="../fr/mod/mod_unique_id.html" title="Français">&nbsp;fr&nbsp;</a> |
+<a href="../ja/mod/mod_unique_id.html" hreflang="ja" rel="alternate" title="Japanese">&nbsp;ja&nbsp;</a> |
+<a href="../ko/mod/mod_unique_id.html" hreflang="ko" rel="alternate" title="Korean">&nbsp;ko&nbsp;</a></p>
+</div><div id="footer">
+<p class="apache">Copyright 2009 The Apache Software Foundation.<br />Autorisé sous <a href="http://www.apache.org/licenses/LICENSE-2.0">Apache License, Version 2.0</a>.</p>
+<p class="menu"><a href="../mod/">Modules</a> | <a href="../mod/directives.html">Directives</a> | <a href="../faq/">FAQ</a> | <a href="../glossary.html">Glossaire</a> | <a href="../sitemap.html">Plan du site</a></p></div>
+</body></html>
\ No newline at end of file

Added: httpd/httpd/trunk/docs/manual/mod/mod_unique_id.xml.fr
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/docs/manual/mod/mod_unique_id.xml.fr?rev=831756&view=auto
==============================================================================
--- httpd/httpd/trunk/docs/manual/mod/mod_unique_id.xml.fr (added)
+++ httpd/httpd/trunk/docs/manual/mod/mod_unique_id.xml.fr Sun Nov  1 20:13:27 2009
@@ -0,0 +1,225 @@
+<?xml version="1.0"?>
+<!DOCTYPE modulesynopsis SYSTEM "../style/modulesynopsis.dtd">
+<?xml-stylesheet type="text/xsl" href="../style/manual.fr.xsl"?>
+<!-- English Revision : 420990 -->
+<!-- French translation : Lucien GENTIS -->
+<!-- Reviewed by : Vincent Deffontaines -->
+
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements.  See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+
+<modulesynopsis metafile="mod_unique_id.xml.meta">
+
+<name>mod_unique_id</name>
+<description>Fournit une variable d'environnement contenant un
+identifiant unique pour chaque requ&ecirc;te</description>
+<status>Extension</status>
+<sourcefile>mod_unique_id.c</sourcefile>
+<identifier>unique_id_module</identifier>
+
+<summary>
+
+    <p>Ce module fournit un identifiant dont l'unicit&eacute; est garantie
+    parmi "toutes" les requ&ecirc;tes sous des conditions tr&egrave;s pr&eacute;cises.
+    L'identifiant unique le sera aussi parmi plusieurs machines
+    appartenant &agrave; un cluster correctement configur&eacute;. L'identifiant est
+    affect&eacute; &agrave; la variable d'environnement <code>UNIQUE_ID</code> pour
+    chaque requ&ecirc;te. Les identifiants uniques sont utiles pour diverses
+    raisons dont la nature se situe au del&agrave; de la port&eacute;e de ce
+    document.</p>
+</summary>
+
+<section id="theory">
+    <title>Th&eacute;orie</title>
+
+    <p>Tout d'abord un bref rappel de la mani&egrave;re dont le serveur Apache
+    fonctionne sous Unix (cette fonctionnalit&eacute; n'&eacute;tant actuellement pas
+    support&eacute;e sous Windows NT). Sous Unix, Apache cr&eacute;e plusieurs
+    processus enfants, ces derniers traitant les requ&ecirc;tes une par une.
+    Chaque processus enfant peut traiter plusieurs requ&ecirc;tes pendant sa
+    dur&eacute;e de vie. Dans le cadre de cette discussion, nous supposerons
+    que les diff&eacute;rents processus enfants ne s'&eacute;changent pas de donn&eacute;es
+    entre eux. Nous nous r&eacute;f&eacute;rerons aux processus enfants sous le nom de
+    <dfn>processus httpd</dfn>.</p>
+
+    <p>Votre site web est r&eacute;parti entre une ou plusieurs machines dont
+    vous &ecirc;tes l'administrateur, et que nous nommerons cluster de
+    serveurs. Chaque serveur peut ex&eacute;cuter plusieurs instances d'Apache.
+    L'ensemble de ces derni&egrave;res sera consid&eacute;r&eacute; comme "l'Univers", et
+    sous certaines hypoth&egrave;ses, nous montrerons qu'il est possible dans
+    cet univers, de g&eacute;n&eacute;rer des identifiants uniques pour chaque
+    requ&ecirc;te, sans pour autant n&eacute;cessiter une communication importante
+    entre les diff&eacute;rents serveurs du cluster.</p>
+
+    <p>Les machines de votre cluster doivent satisfaire ces conditions
+    (m&ecirc;me si le cluster ne comporte qu'une machine, vous devez
+    synchroniser son horloge avec NTP) :</p>
+
+    <ul>
+      <li>Les temps des machines sont synchronis&eacute;s via NTP ou tout autre
+      protocole de synchronisation du temps en r&eacute;seau.</li>
+
+      <li>Les nom d'h&ocirc;tes des machines sont tous diff&eacute;rents, de fa&ccedil;on &agrave;
+      ce que le module puisse recevoir une adresse IP diff&eacute;rente pour
+      chaque machine du cluster en effectuant une recherche sur le nom
+      d'h&ocirc;te.</li>
+    </ul>
+
+    <p>Au vu des caract&eacute;ristiques actuelles du syst&egrave;me d'exploitation,
+    nous supposerons que les pids (identifiants processus) sont cod&eacute;s
+    sur 32 bits. Si le syst&egrave;me d'exploitation utilise plus de 32 bits
+    pour un pid, la correction est triviale mais doit &ecirc;tre effectu&eacute;e
+    dans le code.</p>
+
+    <p>Ces hypoth&egrave;ses pos&eacute;es, &agrave; un instant donn&eacute;, nous pouvons
+    distinguer tout processus httpd sur toute machine du cluster de tous
+    les autres processus httpd. Pour ce faire, il suffit d'utiliser
+    l'adresse IP de la machine et le pid du processus httpd. Ainsi, afin
+    de g&eacute;n&eacute;rer des identifiants uniques pour chaque requ&ecirc;te, il suffit
+    d'effectuer une distinction en fonction du temps.</p>
+
+    <p>Pour d&eacute;terminer le temps, nous utiliserons un rep&egrave;re de temps
+    Unix (les secondes &eacute;coul&eacute;es depuis le 1er janvier 1970 UTC), et un
+    compteur 16 bits. La pr&eacute;cision du rep&egrave;re de temps n'&eacute;tant que d'une
+    seconde, le compteur va repr&eacute;senter 65536 valeurs par seconde. Le
+    quadruplet <em>(adresse IP, pid, rep&egrave;re de temps, compteur)</em> est
+    en mesure de distinguer 65536 requ&ecirc;tes par seconde par processus
+    httpd. Il peut cependant arriver que le m&ecirc;me pid soit r&eacute;utilis&eacute; au
+    cours du temps, et le compteur est l&agrave; pour pallier cet
+    inconv&eacute;nient.</p>
+
+    <p>Lorsqu'un processus enfant httpd est cr&eacute;&eacute;, le compteur est
+    initialis&eacute; avec (nombre de microsecondes actuel divis&eacute; par 10)
+    modulo 65536 (cette formule a &eacute;t&eacute; choisie pour &eacute;liminer certains
+    probl&egrave;me de variance avec les bits de poids faibles du compteur de
+    microsecondes sur certains syst&egrave;mes). Lorsqu'un identifiant unique
+    est g&eacute;n&eacute;r&eacute;, le rep&egrave;re de temps utilis&eacute; est le moment o&ugrave; la requ&ecirc;te
+    arrive sur le serveur web. Le compteur est incr&eacute;ment&eacute; &agrave; chaque
+    cr&eacute;ation d'identifiant (et peut repasser &agrave; 0 lorsqu'il a atteint sa
+    valeur maximale).</p>
+
+    <p>Le noyau g&eacute;n&egrave;re un pid pour chaque processus lors de sa cr&eacute;ation,
+    et le compteur de pid est r&eacute;initialis&eacute; &agrave; une certaine valeur
+    lorsqu'il a atteint sa valeur maximale (les pid sont cod&eacute;s sur 16
+    bits sous de nombreux Unixes, mais les syst&egrave;mes les plus r&eacute;cents les
+    ont &eacute;tendus &agrave; 32 bits). La m&ecirc;me valeur de pid pourra donc &ecirc;tre
+    r&eacute;utilis&eacute;e au cours du temps. Cependant, tant qu'elle n'est pas
+    r&eacute;utilis&eacute;e dans la m&ecirc;me seconde, elle ne remet pas en cause
+    l'unicit&eacute; de notre quadruplet. Nous supposerons donc que le syst&egrave;me
+    ne cr&eacute;era pas plus de 65536 processus en une seconde (ce nombre peut
+    &ecirc;tre de 32768 sous certains Unixes, mais m&ecirc;me dans ce cas, on est en
+    g&eacute;n&eacute;ral loin de cette situation).</p>
+
+    <p>Il est possible que le temps se r&eacute;p&egrave;te pour une raison
+    quelconque.
+    Supposons par exemple que l'horloge syst&egrave;me soit retard&eacute;e et repasse
+    par un temps pass&eacute; (ou bien, comme elle avan&ccedil;ait, elle a &eacute;t&eacute; remise
+    &agrave; l'heure, et elle repasse par un temps futur). Dans ce cas, il peut
+    &ecirc;tre facilement d&eacute;montr&eacute; que le couple pid/rep&egrave;re de temps peut &ecirc;tre
+    r&eacute;utilis&eacute;. Le choix de la formule d'initialisation du compteur a
+    &eacute;t&eacute; effectu&eacute; dans l'intention de pallier ce probl&egrave;me. Notez qu'un
+    nombre vraiment al&eacute;atoire serait souhaitable pour initialiser le
+    compteur, mais il n'existe pas de tel nombre directement lisible sur
+    la plupart des syst&egrave;mes (c'est &agrave; dire que vous ne pouvez pas
+    utiliser rand() car vous devez d&eacute;clencher le g&eacute;n&eacute;rateur avec une
+    valeur unique, et vous ne pouvez pas utiliser le temps &agrave; cet effet
+    car celui-ci , au moins &agrave; la seconde pr&egrave;s, s'est r&eacute;p&eacute;t&eacute;). Il ne
+    s'agit donc pas d'une d&eacute;fense parfaite.</p>
+
+    <p>M&ecirc;me si elle n'est pas parfaite, quel est le degr&eacute; d'efficacit&eacute;
+    de cette d&eacute;fense ? Supposons
+    qu'une de vos machines serve au plus 500 requ&ecirc;tes par seconde (ce
+    qui constitue une limite sup&eacute;rieure tr&egrave;s raisonnable au moment o&ugrave; ce
+    document est &eacute;crit, car les syst&egrave;mes ne se contentent en g&eacute;n&eacute;ral pas
+    de d&eacute;biter des fichiers statiques). Pour y parvenir, un certain nombre
+    de processus enfants sera n&eacute;cessaire, qui d&eacute;pendra du nombre de
+    clients simultan&eacute;s pr&eacute;sents. Mais soyons pessimiste et supposons
+    qu'un seul processus enfant soit capable de servir 500 requ&ecirc;tes par
+    secondes.
+    Il existe 1000 valeurs de d&eacute;marrage possibles du compteur pour
+    lesquelles deux s&eacute;quences de 500 requ&ecirc;tes puissent se recouvrir. Il
+    y a donc 1,5% de chance que le processus enfant r&eacute;p&egrave;te une valeur de
+    compteur si le temps se r&eacute;p&egrave;te (avec une r&eacute;solution d'une seconde),
+    et l'unicit&eacute; sera alors remise en cause. C'est cependant un exemple
+    tr&egrave;s pessimiste, et avec les valeurs du monde r&eacute;el, il y a bien
+    moins de chances que cela ne se produise. Si vous estimez que ceci a
+    tout de m&ecirc;me quelque chances de se produire sur votre syst&egrave;me, vous
+    pouvez migrer vers un compteur &agrave; 32 bits (en modifiant le code).</p>
+
+    <p>On pourrait supposer que ceci a plus de chance de se produire
+    lors du passage &agrave; l'heure d'hiver o&ugrave; l'horloge est "retard&eacute;e". Cela
+    ne constitue cependant pas un probl&egrave;me car les temps pris en compte
+    ici sont des temps UTC, qui vont "toujours" de l'avant. Notez que
+    les Unixes &agrave; base de processeur x86 peuvent n&eacute;cessiter une
+    configuration particuli&egrave;re pour que ceci soit vrai -- il doivent
+    &ecirc;tre configur&eacute;s pour assumer que l'horloge syst&egrave;me est en UTC et
+    compenser de mani&egrave;re appropri&eacute;e. Mais m&ecirc;me dans ce cas, si vous
+    utilisez NTP, votre temps UTC sera correct peu apr&egrave;s le
+    red&eacute;marrage.</p>
+
+    <p>La variable d'environnement <code>UNIQUE_ID</code> est construite
+    par codage du quadruplet de 112 bits (adresse IP sur 32 bits, pid
+    sur 32 bits, rep&egrave;re de temps sur 32 bits et compteur 16 bits) en
+    utilisant l'alphabet <code>[A-Za-z0-9@-]</code> d'une mani&egrave;re
+    similaire &agrave; celle du codage MIME base64, et sa valeur se pr&eacute;sente
+    sous la forme d'une cha&icirc;ne de 19 caract&egrave;res. L'alphabet MIME base64
+    est en fait <code>[A-Za-z0-9+/]</code> ; cependant, les caract&egrave;res
+    <code>+</code> et <code>/</code> n&eacute;cessitent un codage particulier
+    dans les URLs, ce qui rend leur utilisation peu commode. Toutes les
+    valeurs sont cod&eacute;es dans l'ordre des octets d'une adresse r&eacute;seau de
+    fa&ccedil;on &agrave; ce
+    que le codage soit comparable entre des architectures o&ugrave; l'ordre des
+    octets est diff&eacute;rent. L'ordre r&eacute;el de codage est : rep&egrave;re de temps,
+    adresse IP, pid, compteur. Cet ordre de codage poss&egrave;de un but
+    pr&eacute;cis, mais il faut souligner que les applications n'ont aucun
+    int&eacute;r&ecirc;t &agrave; entrer dans les d&eacute;tails de ce codage. Les applications
+    doivent se contenter de traiter la variable <code>UNIQUE_ID</code>
+    comme un symbole opaque, qui peut &ecirc;tre compar&eacute; avec d'autres
+    <code>UNIQUE_ID</code>s en ne testant que leur &eacute;galit&eacute;.</p>
+
+    <p>L'ordre a &eacute;t&eacute; choisi de fa&ccedil;on &agrave; ce qu'il soit possible de
+    modifier le codage dans le futur sans avoir &agrave; se pr&eacute;occuper de
+    conflits &eacute;ventuels avec une base de donn&eacute;es de
+    <code>UNIQUE_ID</code>s existante. Les nouveaux codages doivent
+    conserver le rep&egrave;re de temps comme premier &eacute;l&eacute;ment, et pour le
+    reste, utiliser les m&ecirc;me alphabet et longueur en bits. Comme les
+    rep&egrave;res de temps constituent essentiellement un s&eacute;quence croissante,
+    il suffit que toutes les machines du cluster arr&ecirc;tent de servir et
+    de requ&eacute;rir dans la m&ecirc;me <em>seconde rep&egrave;re</em>, et n'utilisent
+    alors plus l'ancien format de codage. Ensuite, elles peuvent
+    reprendre le traitement des requ&ecirc;tes en utilisant les nouveaux
+    codages.</p>
+
+    <p>Nous pensons que ceci apporte une solution relativement portable
+    au probl&egrave;me. Elle peut &ecirc;tre &eacute;tendue aux syst&egrave;mes multithread&eacute;s comme
+    Windows NT, et peut &eacute;voluer en fonction des besoins futurs. Les
+    identifiants g&eacute;n&eacute;r&eacute;s poss&egrave;dent une dur&eacute;e de vie pratiquement infinie
+    car les identifiants futurs pourront &ecirc;tre allong&eacute;s selon les
+    besoins. Pratiquement aucune communication n'est requise entre les
+    machines du cluster (seule la synchronisation NTP est requise, ce
+    qui repr&eacute;sente une charge tr&egrave;s faible), et aucune communication
+    entre les processus httpd n'est n&eacute;cessaire (la communication est
+    implicite et incluse dans le pid assign&eacute; par le noyau). Dans des
+    situations tr&egrave;s sp&eacute;cifiques, l'identifiant peut &ecirc;tre raccourci, mais
+    dans ce cas, d'avantage d'informations doivent &ecirc;tre admises (par
+    exemple, les 32 bits de l'adresse IP sont excessifs pour la plupart
+    des sites, mais il n'existe pas de valeur de remplacement portable
+    plus courte).</p>
+</section>
+
+
+</modulesynopsis>

Modified: httpd/httpd/trunk/docs/manual/mod/mod_unique_id.xml.meta
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/docs/manual/mod/mod_unique_id.xml.meta?rev=831756&r1=831755&r2=831756&view=diff
==============================================================================
--- httpd/httpd/trunk/docs/manual/mod/mod_unique_id.xml.meta (original)
+++ httpd/httpd/trunk/docs/manual/mod/mod_unique_id.xml.meta Sun Nov  1 20:13:27 2009
@@ -8,6 +8,7 @@
 
   <variants>
     <variant>en</variant>
+    <variant>fr</variant>
     <variant>ja</variant>
     <variant outdated="yes">ko</variant>
   </variants>



Mime
View raw message