Présentation de l'architecture de PostfixPrésentation de l'architecture de PostfixCe document presente un aperçu de l'architecture de Postfix et les liens vers chacunes des commandes ou serveurs de Postfix. Il montre le contexte général dans lequel chaque commande ou serveur est utilisé et indique les pages dans lesquelles vous trouverez plus d'information.
Sujets abordés par ce document :
Lorsqu'un message entre dans le système de messagerie Postfix, le premier point d'arrêt est la file d'attente entrante. Le schéma ci-dessous montre les principaux processus invoqués à l'arrivée d'un nouveau message. Les noms suivis par un nombre désignent des commandes ou programmes de Postfix, et les noms sans chiffre dans une aire grisée représentent des files d'attente.
trivial-
rewrite(8)Réseau -> smtpd(8)
^
||
v\ Réseau -> qmqpd(8) -> cleanup(8) -> file d'attente entrante / pickup(8) <- maildrop ^
|Local -> sendmail(1) -> postdrop(1)
Les messages du réseau entrent dans Postfix via les serveurs smtpd(8) ou qmqpd(8). Ces derniers retirent les enveloppes protocolaires (SMTP ou QMQP), effectuent quelques contrôles de sécurité pour protéger Postfix, et donnent l'expéditeur, les destinataires et le contenu du message au serveur cleanup(8). Le serveur smtpd(8) peut être configuré pour bloquer les messages indésirables comme décrit à la page SMTPD_ACCESS_README.
Les sousmissions locales sont reçues par la commande compatible sendmail(1) de Postfix et sont stockés dans la file d'attente maildrop par la commande privilégiée postdrop(1). Ce dispositif fonctionne même lorsque le système de messagerie Postfix est arrêté. Le serveur local pickup(8) reprend ces sousmissions locales, effectue quelques contrôles de sécurité pour protéger Postfix et donne l'expéditeur, les destinataires et le contenu du message au serveur cleanup(8).
Les messages issus de sources internes sont donnés directement au serveur cleanup(8). Ces sources ne sont pas montrées dans le schéma et incluent : les messages transférés par l'agent de livraison local(8) (voir paragraphe suivant), les messages retournés à l'expéditeur par le serveur bounce(8) (voir le deuxième paragraphe suivant) et les notifications au Postmaster à propos des problèmes rencontrés par Postfix.
Le serveur cleanup(8) implemente le processus final avant que les messages ne soient mis en file d'attente. Il ajoute les From: manquants et d'autres en-têtes de message et transforme les adresses comme décrit à la page ADDRESS_REWRITING_README. De plus, le serveur cleanup(8) peut être configuré pour effectuer une inspection de contenu légère avec des expressions rationnelles tel que décrit à la page BUILTIN_FILTER_README. Le serveur cleanup(8) place le résultat dans un fichier dans la file d'attente entrante et notifie au gestionnaire des files d'attente (voir paragraphe suivant) l'arrivée d'un nouveau message.
Le serveur trivial-rewrite(8) réécrit les adresses sous la forme standard "utilisateur@domaine.qualifié", comme décrit à la page ADDRESS_REWRITING_README. Postfix n'implémente pas actuellement de langage de réécriture mais beaucoup peut être fait avec les tables de correspondances et, si besoin, les expressions rationnelles.
Une fois le message arrivé dans la file d'attente entrante, l'étape suivante est la livraison. Le schéma ci-dessous montre les principaux composants de l'appareil de livraison de Postfix. Les noms suivis par un nombre désignent des commandes ou programmes de Postfix, et les noms sans chiffre dans une aire grisée représentent des files d'attente.
trivial-
rewrite(8)smtp(8) -> Réseau /
^
||
v- lmtp(8) -> Réseau / file d'attente
entrante-> file d'attente
active-> qmgr(8) --- local(8) -> Fichier, commande
^
||
v\ - virtual(8) -> Fichier file d'attente
retardée\ pipe(8) -> Commande
Le gestionnaire des files d'attente (le processus serveur qmgr(8) du schéma) est le cœur de la livraison de message de Postfix. Il contacte les agents de livraison smtp(8), lmtp(8), local(8), virtual(8), pipe(8), ou error(8) , et envoie une requête de livraison pour une ou plusieurs adresses de destination. L'agent de livraison error(8) est special : il déclare toujours le message non livrable. Il n'est pas montré dans le schéma ci-dessus.
Le gestionnaire des files d'attente maintient une file d'attente active aussi petite que possible avec les messages ouverts pour livraison. La file d'attente active agit comme une fenêtre limitée sur une file d'attente entrante ou des files d'attente retardées potentiellement encombrées. La limitation de la file d'attente active évite au gestionnaire des files d'attente de fonctionner avec trop de mémoire.
Le gestionnaire des files d'attente maintient une file d'attente retardée séparée pour les messages qui ne peuvent être livrés évitant ainsi le ralentissement de l'accès normal aux files d'attentes. La stratégie du gestionnaire des files d'attente pour estimer le temps d'attente est décrite aux pages QSHAPE_README et TUNING_README.
Le serveur trivial-rewrite(8) résout chaque adresse de destination suivant ses classes d'adresses locales et distantes, comme définit à la page ADDRESS_CLASS_README. Des informations complémentaires de routage peuvent être ajoutées à la table optionnelle transport(5). Le serveur trivial-rewrite(8) intérroge éventuellement la table relocated(5) pour connaître les destinataires dont l'adresse à changé ; le courrier de ces destinataires est retourné à l'expéditeur avec une explication.
Le client smtp(8) consulte une liste des échangeurs de messagerie pour obtenir la machine de destination host, la trie par ordre de préference et essaye chaque serveur jusqu'à ce qu'il trouve un serveur qui lui répond. Il encapsule ensuite l'expéditeur, le destinataire et le contenu du message comme exigé par le protocole SMTP ; ce qui inclut la conversion de l'encodage 8-bit MIME vers l'encodage 7-bit.
Le client lmtp(8) parle un protocole similaire à SMTP qui est optimisé pour la livraison aux serveurs de boîtes-aux-lettres tels Cyrus. L'avantage de cette configuration est qu'une machine Postfix peut alimenter plusieurs serveurs de boîtes-aux-lettres via LMTP. L'opposé est vrai aussi : un serveur de boîtes-aux-lettres peut être alimenté via LMTP par de multiples machines Postfix. La page LMTP_README montre des exemples de l'emploi du client lmtp(8).
L'agent de livraison local(8) sait utiliser les boîtes-aux-lettres type UNIX, les fichiers de courrier maildir de qmail, les bases de données d'alias(5) type Sendmail et les fichiers .forward style Sendmail des utilisateurs. Plusieurs agents de livraisons "local" peuvent fonctionner en parallèle, mais la livraison simultanée au même utilisateur est limitée.
L'agent de livraison local(8) peut utiliser des formes de livraison locales alternatives : vous pouvez le configurer pour livrer dans des fichiers boites-aux-lettres des répertoires des utilisateurs, pour déléguer la livraison à un programme externe tel procmail ou déléguer la livraison à un agent de livraison de Postfix différent.
L'agent de livraison virtual(8) est un agent de livraison qui ne livre que dans les boîtes-aux-lettres type UNIX ou les fichiers de courrier maildir de qmail. Cet agent de livraison peut livrer le courrier de plusieurs domaines ce qui le rend particulièrement intéressant pour l'hébergement de nombreux petits domaines sur la même machine. Ceci est décrit à la page VIRTUAL_README.
L'agent pipe(8) est l'interface de sortie vers les autres systèmes de traitement du courrier (la commande Postfix sendmail(1) constitue l'interface d'entrée). Cette interface est compatible UNIX : elle fournit des informations sur la ligne de commande et sur l'entrée standard et s'attend à ce que le processus termine avec un code de statut tel que définit dans <sysexits.h>. Des exemples de livraison via l'agent pipe(8) sont proposés aux pages MAILDROP_README et UUCP_README.
Les paragraphes précédents ont montré un aperçu de la réception et de la livraison du courrier par Postfix. Ces processus serveurs sont reliés à d'autres qui effectuent des actions en coulisse. Ce paragraphe tente de montrer chaque service dans son contexte. Comme précédemment, les noms suivis par un nombre désignent des commandes ou programmes de Postfix, et les noms sans chiffre dans une aire grisée représentent des files d'attente.
Le serveur résident master(8) est le superviseur qui garde un œuil sur le bon fonctionnement du système de messagerie Postfix. Il est typiquement lancé au démarrage du système avec la commande "postfix start" et reste actif jusqu'à l'arrêt de ce dernier. Le serveur master(8) est responsable du lancement des processus serveur de Postfix pour la réception et la livraison du courrier, et du relancement des serveurs se terminant prématurément suite à un problème. Le serveur master(8) est égelement responsable du respect des limites du nombre de processus serveur indiqué dans le fichier de configuration master.cf. Le schéma ci-dessous montre la hiérarchie des programmes au lancement de Postfix. Seuls quelques processus démons manipulant le courrier sont montrés.
| postfix(1) | |||||||||||
| | | | |||||||||||
| postfix-script(1) | |||||||||||
|
| | |
| |||||||||
| postsuper(1) | master(8) | postlog(1) | |||||||||
|
| | |
| |||||||||
| smtpd(8) | qmgr(8) | local(8) | |||||||||
Le serveur anvil(8) implemente la connexion client et la limite du taux pour tous les serveurs smtpd(8). La page TUNING_README fournit un guide pour l'échange avec des clients SMTP se comportant mal. Le service anvil(8) est disponible dans les versions 2.2 et supérieures de Postfix.
| Réseau | -> | smtpd(8) | <-> | anvil(8) |
Les serveurs bounce(8), defer(8) et trace(8) maintiennent chacun leur propre arbre de répertoires de file d'attente avec des fichiers de log par message. Ces informations sont utilisées pour envoyer les notifications de livraison ou de non-livraison à l'expéditeur.
Le service trace(8) implemente le support des commandes "sendmail -bv" et "sendmail -v" qui produisent des rapports sur la livraison de message par Postfix et est disponible sur les versions 2.1 et supérieures de Postfix. Reportez-vous à la page DEBUG_README pour les exemples.
| cleanup(8) | -> | qmgr(8) File d'attente Postfix | -> | Agents de livraison |
| ^ | | | v |
| v | ||
| Notifications de (non-) livraison | <- | bounce(8) defer(8) trace(8) | <- | id d'attente, destinataire, statut |
| ||||
|
Fichiers de log par message | ||||
Les serveurs flush(8) maintiennent les logs par destination et implémentent ETRN et la commande "sendmail -qRdestination", tel que décrit à la page ETRN_README. Ils déplacent les fichiers stockés dans les files d'attente retardées dans la file d'attente entrante et demande leur livraison. Le service flush(8) est disponible dans les versions 1.0 et supérieures de Postfix.
|
file d'attente entrante ^ file d'attente retardée | ||||||||
| ^ | | ||||||||
| smtpd(8) sendmail(1) postqueue(1) | - |
Destination dont les messages doivent être expédiés | -> | flush(8) | <- | Destination retardée, id de file d'attente |
- |
Agents de livraison, qmgr(8) |
| ||||||||
| Logs par destination | ||||||||
Les serveurs proxymap(8) fournissent un service de consultation des tables de correspondance aux proscessus de Postfix. Ceci permet les restrictions chroot, et réduit le nombre de tables de correspondances ouvertes en partageant l'accès à de multiples processus.
Le serveur scache(8) maintient le cache des sessions pour le client smtp(8) de Postfix. Lorsque le cache des sessions est activé pour des destinations choisies, le client smtp(8) ne se déconnecte pas immédiatement après une transaction, mais donne cette connexion au serveur de cache. Le client smtp(8) continue avec d'autres requêtes de livraison. Parallèlement, le cache de session maintient la connexion ouverte pour un temps limité. Pendant ce temps, tout processus smtp(8) peut demander au serveur scache(8) cette session cachée et l'utiliser pour la livraison d'un message. Postfix limite le temps pendant lequel une connexion peut être réutilisée.
Lors de la livraison vers des destinations disposant de plusieurs serveurs, le cache des connexions peut permettre d'exclure un serveur ne répondant pas, ce qui augmente sensiblement la vitesse de livraison.
| smtp(8) | -> | scache(8) | -> | smtp(8) |
Les serveurs showq(8) listent les statuts des files d'attente de Postfix. Il s'agit du service de listage qui effectue le travail des commandes mailq(1) et postqueue(1).
| Sortie | <- | mailq(1) post- queue(1) | <- | showq(8) | <- | File d'attente |
Les serveurs spawn(8) lancent les commandes non-Postfix à la demande avec les clients connectés par des sockets ou FIFO à l'entrée, la sortie et le flux d'erreur standard de la commande. Vous pouvez trouver des exemples de cet usage à la page SMTPD_POLICY_README.
Le serveur tlsmgr(8) fonctionne lorsque TLS (Transport Layer Security, connu sous le nom SSL) est activé dans le client smtp(8) ou le serveur smtpd(8). Ce processus poursuit deux buts :
maintenir un générateur de nombres pseudo-aléatoire (PRNG) utilisé pour égrainer les moteurs TLS des processus du client smtp(8) client ou du serveur smtpd(8) de Postfix. L'état du PRNG est régulièrement sauvegardé dans un fichier et est lu au démarrage de tlsmgr(8),
maintenir l'optionnel cache des clefs de sessions TLS du client smtp(8) ou du serveur smtpd(8) de Postfix. La sauvegarde des clefs peut améliorer les performances en réduisant le surplus de trafic et de calcul lié au démarrage d'une session TLS.
Le support TLS est disponible à partir de la version 2.2 de Postfix. Les informations sur l'implémentation TLS de Postfix se trouvent à la page TLS_README.
| Réseau-> | smtpd(8) |
<--graine-- <-session-> | tlsmgr(8) |
--graine--> <-session-> | smtp(8) | ->Réseau | ||||||||||
| | | |
| ||||||||||||||
|
cache des session smtpd | fichier d'état PRNG | cache des session smtp |
||||||||||||||
Le serveur verify(8) verifie que l'adresse d'expédition ou de destination est livrable avant que le serveur smtpd(8) l'accepte. Le serveur verify(8) injecte les messages approuvés dans la file d'attente Postfix et procède à la mise à jour des statuts des agents de livraisons et/ou du gestionnaire des files d'attente. Ce processus est décrit à la page ADDRESS_VERIFICATION_README. Le service verify(8) est disponible sur les versions 2.1 et supérieures de Postfix.
| Réseau | -> | smtpd(8) | <-> | verify(8) | -> | cleanup(8) | -> |
qmgr(8) File d'attente | -> | Agents de livraison |
|||||||
| <- | <- |
| v |
| |||||||||||||
Cet aperçu de l'architecture de Postfix se termine avec un résumé des utilitaires en ligne de commande pour l'utilisation au quotidien du système de messagerie Postfix. En plus des commandes compatibles Sendmail sendmail(1), mailq(1), et newaliases(1), le système Postfix fournit sa propre collection d'utilitaires en ligne de commande. Pour plus de consistance, elles sont nommées postsomething.
La commande postfix(1) contrôle les opérations du système de messagerie. C'est l'interface pour démarrer, arrêter et redémarrer le système de messagerie, ainsi que d'autres opérations administratives. Cette commande est reservée au super-utilisateur.
La commande postalias(1) maintient les bases de données type alias(5) de Postfix. Il s'agit du programme qui effectue le travail de la commande newaliases(1).
La commande postcat(1) expose le contenu des fichiers de files d'attente de Postfix. Il s'agit d'un utilitaire préliminaire et limité. Ce programme est généralement surclassé par d'autres plus puissants pouvant également éditer les files d'attente.
La commande postconf(1) expose ou met à jour les paramètres du fichier main.cf de Postfix et montre les informations dépendantes du système sur les méthodes de vérrouillage et les types de tables de correspondance supportées.
La commande postdrop(1) est l'utilitaire d'envoi de courrier qui est lancé par la commande Postfix sendmail(1) afin de déposer le courrier dans la file d'attente maildrop.
La commande postkick(1) crée des canaux internes de communication utilisables, par exemple, avec les scripts shell.
La commande postlock(1) fournit des verrous de boîtes-aux-lettres compatibles Postfix utilisables, par exemple, avec les scripts shell.
La commande postlog(1) permet aux scripts shell d'enregistrer des logs compatibles Postfix.
La commande postmap(1) maintient les tables de correspondances de Postfix telles les tables canoniques(5), virtuelles(5) et autres. C'est un cousin de la commande UNIX makemap.
La commande postqueue(1) est la commande privilegiée utilisée par les commandes sendmail(1) et mailq(1) de Postfix pour vider ou lister les files d'attente des messages.
La commande postsuper(1) maintient la file d'attente Postfix. Elle supprime les vieux fichiers temporaires et déplace les fichiers de file d'attente dans les bons répertoires après un changement dans la profondeur des répertoires des files d'attente. Elle est lancée au démarrage du système de messagerie startup et lorsque Postfix est relancé.
traduction par Xavier Guimard - Retour au menu