<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>K-Tux &#187; architecture</title>
	<atom:link href="http://www.k-tux.com/tag/architecture/feed" rel="self" type="application/rss+xml" />
	<link>http://www.k-tux.com</link>
	<description></description>
	<lastBuildDate>Mon, 30 Jan 2012 08:30:32 +0000</lastBuildDate>
	<language>en</language>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
	<generator>http://wordpress.org/?v=3.3.1</generator>
		<item>
		<title>OSSEC : Surveillance du système et réponse active</title>
		<link>http://www.k-tux.com/ossec-surveillance-du-systeme-et-reponse-active</link>
		<comments>http://www.k-tux.com/ossec-surveillance-du-systeme-et-reponse-active#comments</comments>
		<pubDate>Mon, 10 Oct 2011 13:00:59 +0000</pubDate>
		<dc:creator>KXan</dc:creator>
				<category><![CDATA[Linux]]></category>
		<category><![CDATA[Mac]]></category>
		<category><![CDATA[Mac Sysadmin apps]]></category>
		<category><![CDATA[Sysadmin apps]]></category>
		<category><![CDATA[Windows]]></category>
		<category><![CDATA[WSysadmin apps]]></category>
		<category><![CDATA[architecture]]></category>
		<category><![CDATA[IDS]]></category>
		<category><![CDATA[network]]></category>
		<category><![CDATA[opensrc]]></category>
		<category><![CDATA[OSSEC]]></category>
		<category><![CDATA[planet-libre]]></category>
		<category><![CDATA[remote]]></category>
		<category><![CDATA[sécurité]]></category>
		<category><![CDATA[system]]></category>

		<guid isPermaLink="false">http://www.k-tux.com/?p=1063</guid>
		<description><![CDATA[Le dernier post était axé sur la surveillance de certaines données via auditd. Et bien cette fois, câblons plus efficace, et englobons dans un joli package surveillance du système ET réponse active ! C&#8217;est le rôle d&#8217;OSSEC. OSSEC OSSEC est &#8230; <a href="http://www.k-tux.com/ossec-surveillance-du-systeme-et-reponse-active">Continue reading <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[Le dernier post était axé sur la<a href="/auditd-monitoring-de-donnees-en-temps-reel" target="_blank"> surveillance de certaines données via auditd</a>.

Et bien cette fois, câblons plus efficace, et englobons dans un joli package surveillance du système ET réponse active ! C'est le rôle d'<a href="http://www.ossec.net/main/" target="_blank">OSSEC</a>.
<h2>OSSEC</h2>
OSSEC est un HIDS (Host-based Intrusion Detection System). Il s'agit en quelque sorte d'une sonde qui travaille sur une machine en particulier et analyse les éléments propres à cette machine. OSSEC dispose de fonctionnalités adaptées à son utilisation, comme l'analyse de logs, la détection de rootkit, les alertes en temps réel et les réponses actives.

OSSEC fonctionne sur la plupart des OS communément rencontrés : Windows, Linux, Mac OS, HP-UX, solaris, ... Il s'appuie sur un schéma client / Serveur :
<ul>
	<li>d'une part le Manager, qui met à disposition les éléments permettant d'évaluer les clients et stocke les informations renvoyées par ces clients</li>
	<li>d'autre part un agent, qui se charge de récupérer les éléments nécessaires aux analyses et pousse le tout au Manager</li>
</ul>
Cependant, OSSEC peut très bien se passer de l'agent, par exemple pour le cas où les systèmes à monitorer seraient plus de l'ordre des équipements réseaux. Ce mode ne sera pas testé ici, mais sachez qu'il est tout-à-fait envisageable.
<h3> Installation et configuration en standalone</h3>
Comme d'habitude, l'installation se fera depuis les sources, non pas que l'outil ne soit pas disponible sur les dépôts, mais il se peut qu'il date un peu par rapport à la fraiche mouture du site référent.

L'installation est on ne peut plus simple : ./install
<pre class="brush: bash">$ wget http://www.ossec.net/files/ossec-hids-2.6.tar.gz
$ tar zxvf ossec-hids-2.6.tar.gz
$ cd ossec-hids-2.6
$ sudo "./install.sh "
Password:

** Pour une installation en français, choisissez [fr]
(en/br/cn/de/el/es/fr/it/jp/nl/pl/ru/sr/tr) [en]: fr

OSSEC HIDS v2.6 Script d'installation - http://www.ossec.net

Vous êtes sur le point d'installer OSSEC HIDS.
Vous devez avoir une compilateur C préinstallé sur votre système.
Si vous avez des questions ou des commentaires, envoyez un email
à dcid@ossec.net (ou daniel.cid@gmail.com).

- Système: Linux ossec-server.k-tux Debian
- Utilisateur: root
- Hôte: ossec-server.k-tux

-- Appuyez sur Entrée pour continuer ou Ctrl-C pour annuler. --

1- Quel type d'installation voulez-vous (serveur, agent, local ou aide) ? serveur
- Installation du serveur choisie.

2- Définition de l'environnement d'installation.
- Choisissez votre répertoire d'installation de OSSEC HIDS [/var/ossec]:
- L'installation sera faite sur  /var/ossec .

3- Configuration de OSSEC HIDS.
3.1- Voulez-vous une alerte par email ? (o/n) [o]: o
- Quel est votre adresse email ? k-tux@k-tux.com
- Quel est l'adresse IP ou le nom d'hôte de votre serveur SMTP ? smtp.k-tux.com

3.2- Voulez-vous démarrer le démon de vérification d'intégrité ? (o/n) [o]: o
- Lancement de syscheck (démon de vérification d'intégrité).

3.3- Voulez-vous démarrer le moteur de détection de rootkit ? (o/n) [o]: o
- Lancement de rootcheck (détection de rootkit).

3.4- La réponse active vous permet d'éxécuter des commandes  spécifiques en fonction d'évènement. Par exemple, vous pouvez bloquer une adresse IP ou interdire l'accès à un utilisateur spécifique. Plus d'information sur : http://www.ossec.net/en/manual.html#active-response
- voulez-vous démarrer la réponse active ? (o/n) [o]: o
- Réponse active activée.

- Par défaut, nous pouvons activer le contrôle d'hôte
et le pare-feu (firewall-drop). Le premier ajoute un hôte dans /etc/hosts.deny et le second bloquera l'hôte dans iptables (sous linux) ou dans ipfilter (sous Solaris, FreeBSD ou NetSBD).
- Ils peuvent aussi être utilisés pour arrêter les scans en force brute de SSHD, les scans de ports ou d'autres formes d'attaques. Vous pouvez aussi les bloquer par rapport à des évènements snort, par exemple.
- Voulez-vous activer la réponse pare-feu (firewall-drop) ? (o/n) [o]:
- pare-feu (firewall-drop) activé (local) pour les levels &gt;= 6
- liste blanche (white list) par défaut pour la réponse active :
- Voulez-vous d'autres adresses IP dans votre liste (white list) ? (o/n)? [n]:

3.5- Voulez-vous activer fonctionnalité syslog (port udp 514) ? (o/n) [o]:
- Fonctionnalité syslog activé.

3.6- Mise en place de la configuration pour analyser les logs suivants :
-- /var/log/messages
-- /var/log/auth.log
-- /var/log/secure
-- /var/log/syslog
-- /var/log/security
-- /var/log/maillog
-- /var/log/proftpd/proftpd.log
-- /var/log/httpd/error_log (apache log)
-- /var/log/httpd/access_log (apache log)

- Si vous voulez surveiller d'autres fichiers, changez le fichier ossec.conf en ajoutant une nouvelle valeur de nom de fichier local. Pour toutes vos questions sur la configuration, consultez notre site web http://www.ossec.net
--- Appuyez sur Entrée pour continuer ---

5- Installation du système
- Exécution du Makefile INFO: Little endian set.
[...]
- Le Système est Debian Linux.
- Script d'initialisation modifié pour démarrer OSSEC HIDS pendant le boot.
- Configuration correctement terminée.
- Pour démarrer OSSEC HIDS:
/var/ossec/bin/ossec-control start
- Pour arrêter OSSEC HIDS:
/var/ossec/bin/ossec-control stop
- La configuration peut être visualisée ou modifiée dans /var/ossec/etc/ossec.conf

Merci d'utiliser OSSEC HIDS.
Si vous avez des questions, suggestions ou si vous trouvez un bug, contactez nous sur contact@ossec.net ou en utilisant la liste de diffusion publique sur ossec-list@ossec.net ( http://www.ossec.net/en/mailing_lists.html ).
Plus d'information peut être trouver sur http://www.ossec.net

- Vous devez ajouter le(s) agent(s) avant qu'ils aient un accés autorisé. Lancez 'manage_agent' pour les ajouter ou les supprimer:
/var/ossec/bin/manage_agents

Plus d'information sur http://www.ossec.net/en/manual.html</pre>
C'est plutôt verbeux, ce qui nous permet de bien maîtriser ce qui est fourni à OSSEC et de savoir par où commencer. Allons faire un tour sur le basedir d'OSSEC : /var/ossec.
<pre class="brush: bash">$ cd /var/ossec/
$ ll
total 76
4 dr-xr-x--- 15 root  ossec 4096 2011-08-25 15:28 .
4 drwxr-xr-x 21 root  root  4096 2011-08-25 15:28 ..
4 dr-xr-x---  3 root  ossec 4096 2011-08-25 15:28 active-response
4 dr-xr-x---  2 root  ossec 4096 2011-08-25 15:28 agentless
4 -r-xr-x---  1 root  ossec   24 2011-08-25 15:28 .bash_logout
4 -r-xr-x---  1 root  ossec  191 2011-08-25 15:28 .bash_profile
4 -r-xr-x---  1 root  ossec  124 2011-08-25 15:28 .bashrc
4 dr-xr-x---  2 root  ossec 4096 2011-08-25 15:28 bin
4 dr-xr-x---  3 root  ossec 4096 2011-08-25 15:28 etc
4 dr-xr-x---  2 root  ossec 4096 2011-08-25 15:28 .gnome2
4 drwxr-x---  5 ossec ossec 4096 2011-08-25 15:28 logs
4 dr-xr-x---  2 root  ossec 4096 2011-08-25 15:28 .mozilla
4 dr-xr-x--- 11 root  ossec 4096 2011-08-25 15:28 queue
4 dr-xr-x---  3 root  ossec 4096 2011-08-25 15:28 rules
4 -r-xr-x---  1 root  ossec 3793 2011-08-25 15:28 .screenrc
4 drwx------  2 ossec ossec 4096 2011-08-25 15:28 .ssh
4 drwxr-x---  2 ossec ossec 4096 2011-08-25 15:28 stats
4 dr-xr-x---  2 root  ossec 4096 2011-08-25 15:28 tmp
4 dr-xr-x---  3 root  ossec 4096 2011-08-25 15:28 var</pre>
<p style="text-align: left;">Comme on peut le voir, toute une arborescence a été créée et remplie avec les informations données à l'installation.</p>
<p style="text-align: left;"><!--nextpage--></p>
<p style="text-align: left;">La configuration se trouve sous etc, profitons-en pour jeter un oeil dessus :</p>

<pre class="brush: bash">$ cat etc/ossec.conf
&lt;ossec_config&gt;
&lt;global&gt;
&lt;email_notification&gt;yes&lt;/email_notification&gt;
&lt;email_to&gt;k-tux@k-tux.com&lt;/email_to&gt;
&lt;smtp_server&gt;smtp.k-tux.com&lt;/smtp_server&gt;
&lt;email_from&gt;ossecm@ossec-server.k-tux&lt;/email_from&gt;
&lt;/global&gt;

&lt;rules&gt;
&lt;include&gt;rules_config.xml&lt;/include&gt;
&lt;include&gt;pam_rules.xml&lt;/include&gt;
&lt;include&gt;sshd_rules.xml&lt;/include&gt;
&lt;include&gt;telnetd_rules.xml&lt;/include&gt;
&lt;include&gt;syslog_rules.xml&lt;/include&gt;
&lt;include&gt;arpwatch_rules.xml&lt;/include&gt;
&lt;include&gt;symantec-av_rules.xml&lt;/include&gt;
&lt;include&gt;symantec-ws_rules.xml&lt;/include&gt;
&lt;include&gt;pix_rules.xml&lt;/include&gt;
&lt;include&gt;named_rules.xml&lt;/include&gt;
&lt;include&gt;smbd_rules.xml&lt;/include&gt;
&lt;include&gt;vsftpd_rules.xml&lt;/include&gt;
&lt;include&gt;pure-ftpd_rules.xml&lt;/include&gt;
&lt;include&gt;proftpd_rules.xml&lt;/include&gt;
&lt;include&gt;ms_ftpd_rules.xml&lt;/include&gt;
&lt;include&gt;ftpd_rules.xml&lt;/include&gt;
&lt;include&gt;hordeimp_rules.xml&lt;/include&gt;
&lt;include&gt;roundcube_rules.xml&lt;/include&gt;
&lt;include&gt;wordpress_rules.xml&lt;/include&gt;
&lt;include&gt;cimserver_rules.xml&lt;/include&gt;
&lt;include&gt;vpopmail_rules.xml&lt;/include&gt;
&lt;include&gt;vmpop3d_rules.xml&lt;/include&gt;
&lt;include&gt;courier_rules.xml&lt;/include&gt;
&lt;include&gt;web_rules.xml&lt;/include&gt;
&lt;include&gt;apache_rules.xml&lt;/include&gt;
&lt;include&gt;nginx_rules.xml&lt;/include&gt;
&lt;include&gt;php_rules.xml&lt;/include&gt;
&lt;include&gt;mysql_rules.xml&lt;/include&gt;
&lt;include&gt;postgresql_rules.xml&lt;/include&gt;
&lt;include&gt;ids_rules.xml&lt;/include&gt;
&lt;include&gt;squid_rules.xml&lt;/include&gt;
&lt;include&gt;firewall_rules.xml&lt;/include&gt;
&lt;include&gt;cisco-ios_rules.xml&lt;/include&gt;
&lt;include&gt;netscreenfw_rules.xml&lt;/include&gt;
&lt;include&gt;sonicwall_rules.xml&lt;/include&gt;
&lt;include&gt;postfix_rules.xml&lt;/include&gt;
&lt;include&gt;sendmail_rules.xml&lt;/include&gt;
&lt;include&gt;imapd_rules.xml&lt;/include&gt;
&lt;include&gt;mailscanner_rules.xml&lt;/include&gt;
&lt;include&gt;dovecot_rules.xml&lt;/include&gt;
&lt;include&gt;ms-exchange_rules.xml&lt;/include&gt;
&lt;include&gt;racoon_rules.xml&lt;/include&gt;
&lt;include&gt;vpn_concentrator_rules.xml&lt;/include&gt;
&lt;include&gt;spamd_rules.xml&lt;/include&gt;
&lt;include&gt;msauth_rules.xml&lt;/include&gt;
&lt;include&gt;mcafee_av_rules.xml&lt;/include&gt;
&lt;include&gt;trend-osce_rules.xml&lt;/include&gt;
&lt;include&gt;ms-se_rules.xml&lt;/include&gt;
&lt;!-- &lt;include&gt;policy_rules.xml&lt;/include&gt; --&gt;
&lt;include&gt;zeus_rules.xml&lt;/include&gt;
&lt;include&gt;solaris_bsm_rules.xml&lt;/include&gt;
&lt;include&gt;vmware_rules.xml&lt;/include&gt;
&lt;include&gt;ms_dhcp_rules.xml&lt;/include&gt;
&lt;include&gt;asterisk_rules.xml&lt;/include&gt;
&lt;include&gt;ossec_rules.xml&lt;/include&gt;
&lt;include&gt;attack_rules.xml&lt;/include&gt;
&lt;include&gt;openbsd_rules.xml&lt;/include&gt;
&lt;include&gt;clam_av_rules.xml&lt;/include&gt;
&lt;include&gt;bro-ids_rules.xml&lt;/include&gt;
&lt;include&gt;dropbear_rules.xml&lt;/include&gt;
&lt;include&gt;local_rules.xml&lt;/include&gt;
&lt;/rules&gt;

&lt;syscheck&gt;
&lt;!-- Frequency that syscheck is executed - default to every 22 hours --&gt;
&lt;frequency&gt;79200&lt;/frequency&gt;

&lt;!-- Directories to check  (perform all possible verifications) --&gt;
&lt;directories check_all="yes"&gt;/etc,/usr/bin,/usr/sbin&lt;/directories&gt;
&lt;directories check_all="yes"&gt;/bin,/sbin&lt;/directories&gt;

&lt;!-- Files/directories to ignore --&gt;
&lt;ignore&gt;/etc/mtab&lt;/ignore&gt;
&lt;ignore&gt;/etc/mnttab&lt;/ignore&gt;
&lt;ignore&gt;/etc/hosts.deny&lt;/ignore&gt;
&lt;ignore&gt;/etc/mail/statistics&lt;/ignore&gt;
&lt;ignore&gt;/etc/random-seed&lt;/ignore&gt;
&lt;ignore&gt;/etc/adjtime&lt;/ignore&gt;
&lt;ignore&gt;/etc/httpd/logs&lt;/ignore&gt;
&lt;ignore&gt;/etc/utmpx&lt;/ignore&gt;
&lt;ignore&gt;/etc/wtmpx&lt;/ignore&gt;
&lt;ignore&gt;/etc/cups/certs&lt;/ignore&gt;
&lt;ignore&gt;/etc/dumpdates&lt;/ignore&gt;
&lt;ignore&gt;/etc/svc/volatile&lt;/ignore&gt;

&lt;!-- Windows files to ignore --&gt;
&lt;ignore&gt;C:\WINDOWS/System32/LogFiles&lt;/ignore&gt;
&lt;ignore&gt;C:\WINDOWS/Debug&lt;/ignore&gt;
&lt;ignore&gt;C:\WINDOWS/WindowsUpdate.log&lt;/ignore&gt;
&lt;ignore&gt;C:\WINDOWS/iis6.log&lt;/ignore&gt;
&lt;ignore&gt;C:\WINDOWS/system32/wbem/Logs&lt;/ignore&gt;
&lt;ignore&gt;C:\WINDOWS/system32/wbem/Repository&lt;/ignore&gt;
&lt;ignore&gt;C:\WINDOWS/Prefetch&lt;/ignore&gt;
&lt;ignore&gt;C:\WINDOWS/PCHEALTH/HELPCTR/DataColl&lt;/ignore&gt;
&lt;ignore&gt;C:\WINDOWS/SoftwareDistribution&lt;/ignore&gt;
&lt;ignore&gt;C:\WINDOWS/Temp&lt;/ignore&gt;
&lt;ignore&gt;C:\WINDOWS/system32/config&lt;/ignore&gt;
&lt;ignore&gt;C:\WINDOWS/system32/spool&lt;/ignore&gt;
&lt;ignore&gt;C:\WINDOWS/system32/CatRoot&lt;/ignore&gt;
&lt;/syscheck&gt;

&lt;rootcheck&gt;
&lt;rootkit_files&gt;/var/ossec/etc/shared/rootkit_files.txt&lt;/rootkit_files&gt;
&lt;rootkit_trojans&gt;/var/ossec/etc/shared/rootkit_trojans.txt&lt;/rootkit_trojans&gt;
&lt;system_audit&gt;/var/ossec/etc/shared/system_audit_rcl.txt&lt;/system_audit&gt;
&lt;system_audit&gt;/var/ossec/etc/shared/cis_debian_linux_rcl.txt&lt;/system_audit&gt;
&lt;system_audit&gt;/var/ossec/etc/shared/cis_rhel_linux_rcl.txt&lt;/system_audit&gt;
&lt;system_audit&gt;/var/ossec/etc/shared/cis_rhel5_linux_rcl.txt&lt;/system_audit&gt;
&lt;/rootcheck&gt;

&lt;global&gt;
&lt;white_list&gt;127.0.0.1&lt;/white_list&gt;
&lt;white_list&gt;^localhost.localdomain$&lt;/white_list&gt;
&lt;/global&gt;

&lt;remote&gt;
&lt;connection&gt;syslog&lt;/connection&gt;
&lt;/remote&gt;

&lt;remote&gt;
&lt;connection&gt;secure&lt;/connection&gt;
&lt;/remote&gt;

&lt;alerts&gt;
&lt;log_alert_level&gt;1&lt;/log_alert_level&gt;
&lt;email_alert_level&gt;7&lt;/email_alert_level&gt;
&lt;/alerts&gt;

&lt;command&gt;
&lt;name&gt;host-deny&lt;/name&gt;
&lt;executable&gt;host-deny.sh&lt;/executable&gt;
&lt;expect&gt;srcip&lt;/expect&gt;
&lt;timeout_allowed&gt;yes&lt;/timeout_allowed&gt;
&lt;/command&gt;

&lt;command&gt;
&lt;name&gt;firewall-drop&lt;/name&gt;
&lt;executable&gt;firewall-drop.sh&lt;/executable&gt;
&lt;expect&gt;srcip&lt;/expect&gt;
&lt;timeout_allowed&gt;yes&lt;/timeout_allowed&gt;
&lt;/command&gt;

&lt;command&gt;
&lt;name&gt;disable-account&lt;/name&gt;
&lt;executable&gt;disable-account.sh&lt;/executable&gt;
&lt;expect&gt;user&lt;/expect&gt;
&lt;timeout_allowed&gt;yes&lt;/timeout_allowed&gt;
&lt;/command&gt;

&lt;command&gt;
&lt;name&gt;restart-ossec&lt;/name&gt;
&lt;executable&gt;restart-ossec.sh&lt;/executable&gt;
&lt;expect&gt;&lt;/expect&gt;
&lt;/command&gt;

&lt;command&gt;
&lt;name&gt;route-null&lt;/name&gt;
&lt;executable&gt;route-null.sh&lt;/executable&gt;
&lt;expect&gt;srcip&lt;/expect&gt;
&lt;timeout_allowed&gt;yes&lt;/timeout_allowed&gt;
&lt;/command&gt;

&lt;!-- Active Response Config --&gt;
&lt;active-response&gt;
&lt;!-- This response is going to execute the host-deny
- command for every event that fires a rule with
- level (severity) &gt;= 6.
- The IP is going to be blocked for  600 seconds.
--&gt;
&lt;command&gt;host-deny&lt;/command&gt;
&lt;location&gt;local&lt;/location&gt;
&lt;level&gt;6&lt;/level&gt;
&lt;timeout&gt;600&lt;/timeout&gt;
&lt;/active-response&gt;

&lt;active-response&gt;
&lt;!-- Firewall Drop response. Block the IP for
- 600 seconds on the firewall (iptables, ipfilter, etc). --&gt;
&lt;command&gt;firewall-drop&lt;/command&gt;
&lt;location&gt;local&lt;/location&gt;
&lt;level&gt;6&lt;/level&gt;
&lt;timeout&gt;600&lt;/timeout&gt;
&lt;/active-response&gt;

&lt;!-- Files to monitor (localfiles) --&gt;

&lt;localfile&gt;
&lt;log_format&gt;syslog&lt;/log_format&gt;
&lt;location&gt;/var/log/messages&lt;/location&gt;
&lt;/localfile&gt;

&lt;localfile&gt;
&lt;log_format&gt;syslog&lt;/log_format&gt;
&lt;location&gt;/var/log/auth.log&lt;/location&gt;
&lt;/localfile&gt;

&lt;localfile&gt;
&lt;log_format&gt;syslog&lt;/log_format&gt;
&lt;location&gt;/var/log/secure&lt;/location&gt;
&lt;/localfile&gt;

&lt;localfile&gt;
&lt;log_format&gt;syslog&lt;/log_format&gt;
&lt;location&gt;/var/log/syslog&lt;/location&gt;
&lt;/localfile&gt;

&lt;localfile&gt;
&lt;log_format&gt;syslog&lt;/log_format&gt;
&lt;location&gt;/var/log/security&lt;/location&gt;
&lt;/localfile&gt;

&lt;localfile&gt;
&lt;log_format&gt;syslog&lt;/log_format&gt;
&lt;location&gt;/var/log/maillog&lt;/location&gt;
&lt;/localfile&gt;

&lt;localfile&gt;
&lt;log_format&gt;syslog&lt;/log_format&gt;
&lt;location&gt;/var/log/proftpd/proftpd.log&lt;/location&gt;
&lt;/localfile&gt;

&lt;localfile&gt;
&lt;log_format&gt;apache&lt;/log_format&gt;
&lt;location&gt;/var/log/httpd/error_log&lt;/location&gt;
&lt;/localfile&gt;

&lt;localfile&gt;
&lt;log_format&gt;apache&lt;/log_format&gt;
&lt;location&gt;/var/log/httpd/access_log&lt;/location&gt;
&lt;/localfile&gt;
&lt;/ossec_config&gt;</pre>
Par défaut telle quelle, la configuration est tout-à-fait viable. On recevra alors des mails du genre :
<pre class="brush: bash">[...]Received: from notify.ossec.net (ossec-server.k-tux.com)[...]
To: &lt;k-tux@k-tux.com&gt;
From: "OSSEC HIDS" &lt;ossecm@ossec-server.k-tux&gt;
Date: Wed, 21 Sep 2011 14:23:41 +0200
Subject: OSSEC Notification - ossec-server.k-tux - Alert level 4
<br id="line1" />OSSEC HIDS Notification.
2011 Sep 21 14:23:28

Received From: ossec-server.k-tux-&gt;/var/log/messages
Rule: 10100 fired (level 4) -&gt; "First time user logged in."
Portion of the log(s):

Sep 21 14:23:26 ossec-server.k-tux sshd[3185]: Accepted password for k-user1 from 192.168.10.105 port 62205 ssh2

 --END OF NOTIFICATION</pre>
C'est pratique, notamment pour garder un oeil sur ce qui se passe sur votre infrastructure, cela s'inscrit notamment dans la même veine que le monitoring via Nagios, à ceci près qu'il n'a besoin que des logs de la cible. D'ailleurs, on pourrait mettre également en place la centralisation de logs, afin de pouvoir sécuriser les éléments sur lesquels OSSEC s'appuie.
<h3>Active responses</h3>
Les actives responses -ou réponses actives en français- sont une des principales fonctionnalités d'OSSEC.

Ce sont des actions qui, selon certaines conditions, permettent d'agir immédiatement et de prendre les mesures qui s'imposent. Comme on peut s'en douter, il est facile de mesurer les avantages et inconvénients de ces mécanismes : rapidité de réponse, efficacité (trop parfois), faux positifs, ...

Tout est contenu dans la définition : il s'agit d'une part de paramétrer une action / une commande, et de l'autre, de spécifier les conditions déclenchant l'action.

Comme vous pouvez le constater, la cnfiguration par défuat en contient déjà quelques unes, comme par exemple :
<pre>&lt;command&gt;
&lt;name&gt;firewall-drop&lt;/name&gt;
&lt;executable&gt;firewall-drop.sh&lt;/executable&gt;
&lt;expect&gt;srcip&lt;/expect&gt;
&lt;timeout_allowed&gt;yes&lt;/timeout_allowed&gt;
&lt;/command&gt;
[...]
&lt;active-response&gt;
&lt;!-- Firewall Drop response. Block the IP for
- 600 seconds on the firewall (iptables, ipfilter, etc). --&gt;
&lt;command&gt;firewall-drop&lt;/command&gt;
&lt;location&gt;local&lt;/location&gt;
&lt;level&gt;6&lt;/level&gt;
&lt;timeout&gt;600&lt;/timeout&gt;
&lt;/active-response&gt;</pre>
En ce qui concerne la définition de la commande, on a principalement :
<ul>
	<li>le nom de la commande</li>
	<li>l'exécutable auquel OSSEC doit se référer pour l'action, situé sous /var/ossec/active-response/bin/</li>
	<li>expect, qui contient l'argument nécessaire pour effectuer l'action</li>
	<li>la possibilité d'autoriser un timeout</li>
</ul>
Pour ce qui est de la définition de la réponse active, on doit spécifier :
<ul>
	<li>le nom de la commande</li>
	<li>location : où la commande doit être exécutée. 4 choix s'offrent à vous :</li>
<ul>
	<li>local ; c'est-à-dire sur la machine cliente, où l'agent s'est exécuté</li>
	<li>server ; donc sur le serveur OSSEC lui-même</li>
	<li>defined-agent ; sur un agent spécifique, il faut alors renseigner un champ agent_id pour que cela soit fait correctement</li>
	<li>all : partout</li>
</ul>
	<li>agent_id : le fameux agent sur lequel l'action sera faite si on a mentionné defined-agent dans les balises de location</li>
	<li style="text-align: left;">level : la réponse sera exécutée sur chaque évènement ayant un niveau supérieur ou égal à celui spécifié</li>
	<li style="text-align: left;">timeout : combien de temps avant que la réponse soit défaite (par exemple, ici, l'ip débloquée)</li>
</ul>
Voyons ce que cela donne dans le cadre d'une installation d'un client seulement...
<p style="text-align: left;"><!--nextpage--></p>

<h3 style="text-align: left;">Clients / Serveur</h3>
<p style="text-align: left;">L'installation d'un client distinct fonctionne à peu près pareil que pour l'installation du serveur, à ceci près que l'on mention agent au lieu de server.</p>

<pre class="brush: bash"># cd /usr/lcoal/src/ossec-hids-2.6
-bash-4.0# ls
active-response/  BUGS  CONFIG  contrib/  CONTRIBUTORS  doc/  etc/  INSTALL  install.sh*  LICENSE  README  src/
-bash-4.0# ./install.sh
** Pour une installation en français, choisissez [fr]
(en/br/cn/de/el/es/fr/it/jp/nl/pl/ru/sr/tr) [en]: fr

OSSEC HIDS v2.6 Script d'installation - http://www.ossec.net
[...]

- Système: Linux Debian
- Utilisateur: root
- Hôte: ossec-agent.k-tux.com

1- Quel type d'installation voulez-vous (serveur, agent, local ou aide) ? agent
- Installation de l'agent (client) choisie.
2- Définition de l'environnement d'installation.
- Choisissez votre répertoire d'installation de OSSEC HIDS [/var/ossec]:
- L'installation sera faite sur  /var/ossec .
3- Configuration de OSSEC HIDS.
3.1- Quelle est l'adresse IP de votre serveur OSSEC HIDS ?: 192.168.206.145
- Ajout de l'IP du Serveur 192.168.206.145
3.2- Voulez-vous démarrer le démon de vérification d'intégrité ? (o/n) [o]: o
- Lancement de syscheck (démon de vérification d'intégrité).
3.3- Voulez-vous démarrer le moteur de détection de rootkit ? (o/n) [o]:
- Lancement de rootcheck (détection de rootkit).
3.4 - voulez-vous démarrer la réponse active ? (o/n) [o]:
3.5- Mise en place de la configuration pour analyser les logs suivants :
-- /var/log/messages
-- /var/log/auth.log
-- /var/log/secure
-- /var/log/syslog
-- /var/log/security
-- /var/log/maillog
-- /var/log/proftpd/proftpd.log
-- /var/log/httpd/error_log (apache log)
-- /var/log/httpd/access_log (apache log)

5- Installation du système
- Exécution du Makefile [...]
- Le Système est Debian Linux.
- Script d'initialisation modifié pour démarrer OSSEC HIDS pendant le boot.
- Configuration correctement terminée.
- Pour démarrer OSSEC HIDS:
/var/ossec/bin/ossec-control start
- Pour arrêter OSSEC HIDS:
/var/ossec/bin/ossec-control stop
- La configuration peut être visualisée ou modifiée dans /var/ossec/etc/ossec.conf
- Vous devez d'abord ajouter cet agent sur le serveur pour
qu'ils communiquent entre eux. Quand cela sera fait,
vous pourrez lancer l'outil 'manage_agents' pour
importer la clef d'authentification depuis le serveur.

/var/ossec/bin/manage_agent</pre>
Comme mentionné, il faut ajouter manuellement l'agent sur le serveur, car sinon, il ne voit que lui-même. Pour cela il faut utiliser manage_agent, qui, sur mon serveur, se situe sous /var/ossec/bin. Quant à agent_control, il permet d'avoir la main sur la liste des agents référencés et de leur faire subir quelques contrôles.
<pre class="brush: bash"> ossec-server.k-tux# agent_control -l

OSSEC HIDS agent_control. List of available agents:
ID: 000, Name: ossec-serv.k-tux (server), IP: 127.0.0.1, Active/Local

# manage_agents
****************************************
* OSSEC HIDS v2.6 Agent manager.     *
* The following options are available: *
****************************************
(A)dd an agent (A).
(E)xtract key for an agent (E).
(L)ist already added agents (L).
(R)emove an agent (R).
(Q)uit.
Choose your action: A,E,L,R or Q: A

- Adding a new agent (use '\q' to return to the main menu).
Please provide the following:
* A name for the new agent: ossec-agent.k-tux
* The IP Address of the new agent: 192.168.206.151
* An ID for the new agent[001]:
Agent information:
ID:001
Name:ossec-agent.k-tux
IP Address:192.168.206.151
Confirm adding it?(y/n): y
Agent added.

****************************************
* OSSEC HIDS v2.6 Agent manager.     *
* The following options are available: *
****************************************
(A)dd an agent (A).
(E)xtract key for an agent (E).
(L)ist already added agents (L).
(R)emove an agent (R).
(Q)uit.
Choose your action: A,E,L,R or Q: Q

** You must restart the server for your changes to have effect.
manage_agents: Exiting ..</pre>
Et de redémarrer le serveur ossec :
<pre class="brush: bash"># ossec-control restart
Deleting PID file '/var/ossec/var/run/ossec-remoted-7684.pid' not used...
Killing ossec-monitord ..
Killing ossec-logcollector ..
ossec-remoted not running ..
Killing ossec-syscheckd ..
Killing ossec-analysisd ..
Killing ossec-maild ..
Killing ossec-execd ..
OSSEC HIDS v2.6 Stopped
Starting OSSEC HIDS v2.6 (by Trend Micro Inc.)...
OSSEC analysisd: Testing rules failed. Configuration error. Exiting.
Started ossec-maild...
Started ossec-execd...
Started ossec-analysisd...
Started ossec-logcollector...
Started ossec-remoted...
Started ossec-syscheckd...
Started ossec-monitord...
Completed.</pre>
Du client, si rien de plus n'est fait, on part tout de même en erreur sur une histoire de clé :
<pre class="brush: bash"> ossec-agent.k-tux # /var/ossec/bin/ossec-control start
Starting OSSEC HIDS v2.6 (by Trend Micro Inc.)...
Started ossec-execd...
2011/10/05 13:21:39 ossec-agentd(1402): ERROR: Authentication key file '/var/ossec/etc/client.keys' not found.
2011/10/05 13:21:39 ossec-agentd(1750): ERROR: No remote connection configured. Exiting.
2011/10/05 13:21:39 ossec-agentd(4109): ERROR: Unable to start without auth keys. Exiting.</pre>
Pour récupérer la clé du client, il faut créer un fichier /var/ossec/etc/client.keys qui contiendra la clé du client que le serveur garde sous son /var/ossec/etc/clients.keys (attention, il y a bien un s à clients, contrairement à celui du client).
<pre class="brush: bash">ossec-agent.k-tux # cat /var/ossec/etc/client.keys
001 ossec-agent.k-tux 192.168.206.151 3ba007429eb3f283e85cc18eefcf4e01e64604e82757723db94c23fd1026df88</pre>
Une autre méthode, mais qui n'a pas fonctionné pour moi, est, depuis le client, de passer par manage_agent avec un bon cut/paste de la clé :
<pre class="brush: bash">ossec-agent.k-tux # ./manage_agents

****************************************
* OSSEC HIDS v2.6 Agent manager.     *
* The following options are available: *
****************************************
(I)mport key from the server (I).
(Q)uit.
Choose your action: I or Q: I

* Provide the Key generated by the server.
* The best approach is to cut and paste it.
*** OBS: Do not include spaces or new lines.

Paste it here (or '\q' to quit): 3ba007429eb3f283e85cc18eefcf4e01e64604e82757723db94c23fd1026df88

** Invalid authentication key. Starting over again.
** Press ENTER to return to the main menu.</pre>
Dans un cas comme dans l'autre -du moins si votre manage_agent fonctionne sur l'import-, vous pouvez dès que cela est réglé, lancer ossec-agent sur le client :
<pre class="brush: bash">ossec-agent.k-tux # /var/ossec/bin/ossec-control start
Starting OSSEC HIDS v2.6 (by Trend Micro Inc.)...
ossec-execd already running...
Started ossec-agentd...
Started ossec-logcollector...
Started ossec-syscheckd...
Completed.</pre>
A partir de là, votre agent fonctionne tout comme votre serveur, notifications et réponses actives !
<h2>Conclusion</h2>
Il est indéniable qu'OSSEC dispose de fonctionnalités clé qui permettent d'avoir un état en temps réel de votre infrastructure. En cela, il devient un des outils nécessaires à tout administrateur voulant contrôler un peu plus ce qui se passe sur son parc.

Cependant, comme pour tous les outils puissants, il reste maintenant à faire un peu de tri dans les informations renvoyées, afin de distinguer celles qui sont vraiment importantes de celles qui relèvent plus de l'anecdote. Car c'est un risque identifié : plus il y a de bruit, et moins on voit le problème...]]></content:encoded>
			<wfw:commentRss>http://www.k-tux.com/ossec-surveillance-du-systeme-et-reponse-active/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Bcfg2 : la gestion de conf du bout des doigts</title>
		<link>http://www.k-tux.com/bcfg2-la-gestion-de-conf-du-bout-des-doigts</link>
		<comments>http://www.k-tux.com/bcfg2-la-gestion-de-conf-du-bout-des-doigts#comments</comments>
		<pubDate>Thu, 21 Jul 2011 13:49:18 +0000</pubDate>
		<dc:creator>KXan</dc:creator>
				<category><![CDATA[Linux]]></category>
		<category><![CDATA[Sysadmin apps]]></category>
		<category><![CDATA[architecture]]></category>
		<category><![CDATA[authentication]]></category>
		<category><![CDATA[Bcfg2]]></category>
		<category><![CDATA[conception]]></category>
		<category><![CDATA[conf]]></category>
		<category><![CDATA[install]]></category>
		<category><![CDATA[network]]></category>
		<category><![CDATA[opensrc]]></category>
		<category><![CDATA[planet-libre]]></category>

		<guid isPermaLink="false">http://www.k-tux.com/?p=1029</guid>
		<description><![CDATA[Il n&#8217;y a pas si longtemps que ça, je vous avais parlé d&#8217;un gestionnaire de conf, Puppet, qui s&#8217;appuyait sur son propre langage descriptif et jouait avec du Ruby. Après quelques essais ma foi assez pertinents, je me suis aperçue &#8230; <a href="http://www.k-tux.com/bcfg2-la-gestion-de-conf-du-bout-des-doigts">Continue reading <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[Il n'y a pas si longtemps que ça,<a href="http://www.k-tux.com/puppet-gestionnaire-de-configuration" target="_blank"> je vous avais parlé d'un gestionnaire de conf, Puppet</a>, qui s'appuyait sur son propre langage descriptif et jouait avec du <strong>Ruby</strong>.

Après quelques essais ma foi assez pertinents, je me suis aperçue que <strong>Puppet</strong> était somme toute un peu lent : pour 3 packages (certes, il y avait du java dans le tas) et 2 conf, plus de 20 minutes étaient nécessaires pour mettre à niveau les nodes.

Un autre fâcheux défaut est que, par défaut, il agrège toutes les instructions dans un même espace, sans tenir compte de la séquence selon laquelle ils sont définis.

Pour le coup, les résultats sont pour le moins inattendus, surtout si on est dans un cas de figure où l'on doit passer une instruction (exemple : définition des dépôts officiels) avant une autre (installation de package).

Au final, l'organisation des manifests finit, par défaut en un gigantesque mashup d'instructions. Pas trop sympa quand, naif, on n'y a pas pensé et passé des heures à tout bien organiser. Le seul moyen d'échapper à ce mécanisme est de passer par de lourdes définitions de dépendances.

Il était temps de faire jouer <a href="http://alternativeto.net/" target="_blank">AlternativeTo</a>... Et de tomber sur <strong>bcfg2</strong>, un gestionnaire de conf s'appuyant sur du python ! Retour sur une conf aux petits oignons !
<h2>Principes de fonctionnement</h2>
Dans l'absolu, le fonctionnement de bcfg2 est assez similaire à celui de Puppet  : on a un agent qui interroge le serveur, et exécute -ou pas- les modifications.

Après, étant un peu flemmarde et n'étant pas trop pour la copie illégitime de contenu, je vous renvoie sur <a href="http://trac.mcs.anl.gov/projects/bcfg2" target="_blank">le fonctionnement détaillé au poil du projet</a> !
<h2>Un peu de technique</h2>
<h3>Installation</h3>
Comme d'habitude, on partira des sources : fraîches, dispo, et surtout dernière version :)
<pre class="brush: bash">$ cd /usr/local/src
$ wget ftp://ftp.mcs.anl.gov/pub/bcfg/bcfg2-1.1.2.tar.gz
$ tar zxvf bcfg2-1.1.2.tar.gz
$ python setup.py build
$ python setup.py install</pre>
<pre class="brush: bash">$ bcfg2-admin init
Store bcfg2 configuration in [/etc/bcfg2.conf]:
Location of bcfg2 repository [/var/lib/bcfg2]:
Input password used for communication verification (without echoing; leave blank for a random):
What is the server's hostname [bcfg2-server]:
Input the server location [https://bcfg2-server:6789]:
Input base Operating System for clients:
1: Redhat/Fedora/RHEL/RHAS/Centos
2: SUSE/SLES
3: Mandrake
4: Debian
5: Ubuntu
6: Gentoo
7: FreeBSD
: 5
Generating a 2048 bit RSA private key
.......+++
........+++
writing new private key to '/etc/bcfg2.key'
-----
Signature ok
subject=/C=US/ST=Illinois/L=Argonne/CN=bcfg2-server.k-tux.com
Getting Private key
Repository created successfuly in /var/lib/bcfg2</pre>
Bon, certificat un peu faussé parce que <strong>K-Tux</strong>, dans l'Illinois, c'est un peu tiré par les cheveux, mais bon, en s'en contentera :)
<h3>Configuration du service</h3>
La configuration du serveur en lui-même (je veux dire par là, le paramétrage du service, hein, pas celui concernant les nodes qui vont le solliciter) se situe tout simplement sous <em>/etc</em> et se compose de 3 éléments : la conf, la clé et le certificat en lui-même.
<pre class="brush: bash">bcfg2-server $ ls /etc/bc*
bcfg2.conf  bcfg2.crt   bcfg2.key</pre>
Un petit start du service pour se rendre compte du truc :
<pre class="brush: bash">bcfg2-server $ bcfg2-server start
Handled 14 events in 0.017s
service available at https://bcfg2-server.k-tux.com:6789
serving bcfg2-server at https://bcfg2-server.k-tux.com:6789
serve_forever() [start]</pre>
...Qui reste en foreground, mais c'est pas plus mal pour voir ce qui se passe !

La première conf est celle du Hello World : tester le service en local. Notre serveur sera donc, pour cette fois-ci du moins, également notre node. On lance donc la partie cliente, avec les options qui vont bien : -q (query) -v (verbose) -n (dry-run mode)
<pre class="brush: bash">bcfg2-server $ bcfg2 -q -v -n
Loaded tool drivers:
Action     Chkconfig  POSIX      RPMng

Phase: initial
Correct entries:        0
Incorrect entries:      0
Total managed entries:  0
Unmanaged entries:      2754

Phase: final
Correct entries:        0
Incorrect entries:      0
Total managed entries:  0
Unmanaged entries:      2754</pre>
C'est un peu violent de se prendre 2754 Unmanaged entries dans la tronche, mais pas d'erreur, le serveur nous renvoie tout simplement un :
<pre class="brush: bash">Generated config for bcfg2-server.k-tux.com in 0.001s
Client bcfg2-server.k-tux.com reported state clean</pre>
En clair, il nous reste 2754 packages à configurer.
<h3>Configuration du client en local</h3>
Il faut savoir, et c'est intéressant car c'est là que vous allez bosser, que la configuration des paramétrages pour les nodes tapant sur votre bcfg2-server se situe par défaut sous /var/lib/bcfg2. Là-dedans, vous avez tout une arborescence qui a été mise en place lors de l'installation :
<pre class="brush: bash">bcfg2-server $ ls -lsaR  /var/lib/bcfg2
/var/lib/bcfg2:
total 40
4 drwxr-xr-x 10 root root 4096 2011-07-06 16:14 .
4 drwxr-xr-x 48 root root 4096 2011-07-06 16:14 ..
4 drwxr-xr-x  2 root root 4096 2011-07-06 16:14 Base
4 drwxr-xr-x  2 root root 4096 2011-07-06 16:14 Bundler
4 drwxr-xr-x  2 root root 4096 2011-07-06 16:14 Cfg
4 drwxr-xr-x  2 root root 4096 2011-07-06 16:14 etc
4 drwxr-xr-x  2 root root 4096 2011-07-06 16:14 Metadata
4 drwxr-xr-x  2 root root 4096 2011-07-06 16:14 Pkgmgr
4 drwxr-xr-x  2 root root 4096 2011-07-06 16:14 Rules
4 drwxr-xr-x  2 root root 4096 2011-07-06 16:14 SSHbase

/var/lib/bcfg2/Base:
total 8
4 drwxr-xr-x  2 root root 4096 2011-07-06 16:14 .
4 drwxr-xr-x 10 root root 4096 2011-07-06 16:14 ..

/var/lib/bcfg2/Bundler:
total 8
4 drwxr-xr-x  2 root root 4096 2011-07-06 16:14 .
4 drwxr-xr-x 10 root root 4096 2011-07-06 16:14 ..

/var/lib/bcfg2/Cfg:
total 8
4 drwxr-xr-x  2 root root 4096 2011-07-06 16:14 .
4 drwxr-xr-x 10 root root 4096 2011-07-06 16:14 ..

/var/lib/bcfg2/etc:
total 8
4 drwxr-xr-x  2 root root 4096 2011-07-06 16:14 .
4 drwxr-xr-x 10 root root 4096 2011-07-06 16:14 ..

/var/lib/bcfg2/Metadata:
total 16
4 drwxr-xr-x  2 root root 4096 2011-07-06 16:14 .
4 drwxr-xr-x 10 root root 4096 2011-07-06 16:14 ..
4 -rw-r--r--  1 root root  111 2011-07-06 16:14 clients.xml
4 -rw-r--r--  1 root root  354 2011-07-06 16:14 groups.xml

/var/lib/bcfg2/Pkgmgr:
total 8
4 drwxr-xr-x  2 root root 4096 2011-07-06 16:14 .
4 drwxr-xr-x 10 root root 4096 2011-07-06 16:14 ..

/var/lib/bcfg2/Rules:
total 8
4 drwxr-xr-x  2 root root 4096 2011-07-06 16:14 .
4 drwxr-xr-x 10 root root 4096 2011-07-06 16:14 ..

/var/lib/bcfg2/SSHbase:
total 8
4 drwxr-xr-x  2 root root 4096 2011-07-06 16:14 .
4 drwxr-xr-x 10 root root 4096 2011-07-06 16:14 ..</pre>
Et par défaut, et bien vous avez vraiment peu de choses :)

En  fait, seuls /var/lib/bcfg2/Metadata/clients.xml et groups.xml sont définis. Soit dit en passant, ce sont ces fichiers qui vont permettre d'associer un profil à un node, le profil pouvant ensuite se moduler à l'infini, par le biais de Bundle et d'autres subtilités. Jetons-y un oeil, pour le coup :
<pre class="brush: bash">bcfg2-server $ cat /var/lib/bcfg2/Metadata/clients.xml
&lt;Clients version="3.0"&gt;
&lt;Client profile="basic" pingable="Y" pingtime="0" name="bcfg2-server.k-tux.com"/&gt;
&lt;/Clients&gt;</pre>
Ici, notre client (qui est aussi le serveur) est associé au profil par défaut; "basic". pinguable et pingtime parlent d'eux même.

Pour ce qui est de groups.xml, c'est la même trame : une série de &lt;Group&gt; sont définis, par défaut vides et fonction de la distribution du client.
<pre class="brush: bash">bcfg2-server $ cat /var/lib/bcfg2/Metadata/groups.xml
&lt;Groups version='3.0'&gt;
&lt;Group profile='true' public='true' default='true' name='basic'&gt;
&lt;Group name='ubuntu'/&gt;
&lt;/Group&gt;
&lt;Group name='ubuntu'/&gt;
&lt;Group name='debian'/&gt;
&lt;Group name='freebsd'/&gt;
&lt;Group name='gentoo'/&gt;
&lt;Group name='redhat'/&gt;
&lt;Group name='suse'/&gt;
&lt;Group name='mandrake'/&gt;
&lt;Group name='solaris'/&gt;
&lt;/Groups&gt;</pre>
<p style="text-align: left;">A noter que 2 types de groupes existent : les publics, qui sont en fait les entrées par lesquelles les clients accèdent à leur catalogue, et les autres, qui ne sont pas directement visibles par les clients mais servent à mieux organiser les catégories.</p>
<p style="text-align: left;"><!--nextpage--></p>

<h3 style="text-align: left;">Jouer avec les conf</h3>
Le premier jeu va consister à mettre à jour une conf sur un client.Les conf, les fichiers texte e, général sont toujours stockés dans /var/lib/bcfg2/Cfg.

Pour jouer donc, tapons et modifions d'abord nos jolis xml :
<pre class="brush: bash">bcfg2-server:/var/lib/bcfg2 $ cat Metadata/groups.xml
&lt;Groups version='3.0'&gt;
&lt;Group profile='true' public='true' default='true' name='basic'&gt;
&lt;Group name='ubuntu'/&gt;
&lt;/Group&gt;
&lt;Group name='debian'/&gt;
&lt;Group name='ubuntu'&gt;
&lt;Bundle name='release'/&gt;
&lt;/Group&gt;
&lt;/Groups&gt;

/var/lib/bcfg2 $ cat Bundler/release.xml
&lt;Bundle name='release' version='2.0'&gt;
&lt;Path name="/etc/ubuntu-release"/&gt;
&lt;/Bundle&gt;</pre>
Bien sûr, il faut tout de même mettre la conf dans un endroit précis, distinct du système (que se passerait-il si ce ne sont pas les mêmes OS ?). Pour cela, il suffit de créer un dir portant le path et le nom de la conf sous /var/lib/bcfg2/Cfg/. Par exemple, ici, on va :
<pre class="brush: bash">bcfg2-server $ mkdir -p /var/lib/bcfg2/Cfg/etc/ubuntu-release/
bcfg2-server $ cp /etc/ubuntu-release /var/lib/bcfg2/Cfg/etc/ubuntu-release/</pre>
Enfantin, n'est-ce pas ? Le plus embêtant, c'est que j'ai dû redémarrer le service pour qu'il prenne en compte les changements.
<pre class="brush: bash">bcfg2-server $ bcfg2-server start
service available at https://bcfg2.k-tux.com:6789
serving bcfg2-server at https://bcfg2.k-tux.com:6789
serve_forever() [start]
Handled 30 events in 0.020s</pre>
Lançons le client,qui dispose de son ubuntu-release correctement paramétré :
<pre class="brush: bash">bcfg2-server $ bcfg2 -q -v -n
Loaded tool drivers:
Action     Chkconfig  POSIX      RPMng

Phase: initial
Correct entries:        1
Incorrect entries:      0
Total managed entries:  1
Unmanaged entries:      2754

Phase: final
Correct entries:        1
Incorrect entries:      0
Total managed entries:  1
Unmanaged entries:      2754</pre>
Et cette fois, qui a volontairement le ubuntu-release tronqué :
<pre class="brush: bash">bcfg2-server $ bcfg2 -q -v -n
Loaded tool drivers:
Action     Chkconfig  POSIX      RPMng

Phase: initial
Correct entries:        0
Incorrect entries:      1
Total managed entries:  1
Unmanaged entries:      2759</pre>
Le dry-run mode ne faisant rien de spécial sur le système, il se contente de nous broncher une Incorrect entry. Virons le dry-run et voyons si la conf redescend bien comme il faut !
<pre class="brush: bash">bcfg2-server $ bcfg2 -q -v
Loaded tool drivers:
Action     Chkconfig  POSIX      RPMng

Phase: initial
Correct entries:        0
Incorrect entries:      1
Total managed entries:  1
Unmanaged entries:      2759

Installing ConfigFile /etc/ubuntu-release
The Following Bundles have been modified:
release

Phase: final
Correct entries:        1
Incorrect entries:      0
Total managed entries:  1
Unmanaged entries:      2759</pre>
Clair, net, concis : notre conf est bien redescendue !

C'est bien joli tout ça, mais tant qu'à y être, autant voir les choses en grand :) Passons donc en multi clients !
<h3>Client - Serveur distincts</h3>
Notre client, lui, n'est plus sous ubuntu comme le serveur mais sur une autre machine , en Debian 6.0.1. En réalité, que se passe-t-il qui est différent de notre mode client=serveur ? Et bien, rien de spécial, si ce n'est qu'on a rajouté une entrée dans le clients.xml.
<pre class="brush: bash">bcfg2-server $ /var/lib/bcfg2 $ cat Metadata/clients.xml
&lt;Clients version="3.0"&gt;
&lt;Client profile="basic" pingable="Y" pingtime="0" name="bcgf2-server.k-tux.com"/&gt;
&lt;Client profile="deb" pingable="Y" pingtime="0" name="bcfg2cli-deb.k-tux.com"/&gt;
&lt;/Clients&gt;</pre>
Notre groups.xml est aussi enrichi, puisque l'OS est différent et qu'il existe pile poil la bonne catégorie pour ce type de machine :

bcfg2-server&lt;Groups version='3.0'&gt;
&lt;Group profile='true' public='true' default='true' name='basic'&gt;
&lt;Group name='ubuntu'/&gt;
&lt;/Group&gt;
&lt;Group profile='true' public='true' default='true' name='deb'&gt;
&lt;Group name='debian'/&gt;
&lt;/Group&gt;
&lt;Group name='ubuntu'&gt;
&lt;Bundle name='release'/&gt;
&lt;/Group&gt;
&lt;Group name='debian'/&gt;
&lt;/Groups&gt;

Au niveau du client, c'est un peu plus palpable :
<pre class="brush: bash">bcfg2cli-deb $ apt-get update &amp;&amp; apt-get upgrade
bcfg2cli-deb $ apt-get install bcfg2
Creating config file /etc/bcfg2.conf with new version</pre>
Forcément, la conf par défaut n'est pas valide, puisque pour fonctionner doit d'ailleurs directement taper sur le serveur (logique). Avant, on avait donc ça :
<pre class="brush: bash">bcfg2cli-deb $ cat /etc/bcfg2.conf
[communication]
protocol = xmlrpc/ssl
password = foobat
# certificate = /etc/bcfg2.key
# key = /etc/bcfg2.key

[components]
bcfg2 = https://localhost:6789</pre>
Et après modification du general password et du serveur sur lequel taper :
<pre class="brush: bash">bcfg2cli-deb $ cat /etc/bcfg2.conf
[communication]
protocol = xmlrpc/ssl
password = sF9Xlpuv
# certificate = /etc/bcfg2.key
# key = /etc/bcfg2.key

[components]
bcfg2 = https://bcfg2-server.k-tux.com:6789</pre>
On lance le client :
<pre class="brush: bash">bcfg2cli-deb $ bcfg2 -qvn
No ca is specified. Cannot authenticate the server with SSL.
No ca is specified. Cannot authenticate the server with SSL.
Loaded tool drivers:
APT      Action   DebInit  POSIX

Phase: initial
Correct entries:        0
Incorrect entries:      0
Total managed entries:  0
Unmanaged entries:      365

Phase: final
Correct entries:        0
Incorrect entries:      0
Total managed entries:  0
Unmanaged entries:      365

No ca is specified. Cannot authenticate the server with SSL.</pre>
Au niveau du serveur, il existe des outils permettant de bien visualiser ce que l'on a, sans forcément rentrer dans le xml. Un peu comme... bcfg2-info :
<pre class="brush: bash">bcfg2-server $ bcfg2-info "clients"
Handled 31 events in 0.012s
cli Client          | Profile
============================
bcfg2cli-deb   | deb
bcfg2-server  | basic</pre>
<h3>Installer des packages via bcfg2</h3>
Forcément, la conf ne fait pas tout, et on aimerait -moi en tout cas- pouvoir monter un noeud qui aurait été victime d'une installation très basique pour en faire un noeud fonctionnel, prêt à brasser du code.

Contrairement à son petit nom qui sonne un peu restrictif somme toute, bcfg2 peut, comme Puppet, prendre en charge cette opération, aussi facilement que pour la partie configuration.

Attaquons de suite par un exemple on ne peut plus simple ! Je rappelle que le noeud en question rentre dans le profil deb qui fait appel au group debian.

Pour pouvoir accéder à la fonctionnalité installation / gestion des packages, il faut retoucher la conf de bcfg2 et rajouter le plugin Packages au bon endroit. Votre conf deviendra donc :
<pre class="brush: bash">bcfg2-server $ cat /etc/bcfg2.conf

[server]
repository = /var/lib/bcfg2
plugins = Base,Bundler,Cfg,Metadata,Pkgmgr,Packages,Rules,SSHbase

[statistics]
sendmailpath = /usr/lib/sendmail
database_engine = sqlite3
# 'postgresql', 'mysql', 'mysql_old', 'sqlite3' or 'ado_mssql'.
database_name =
# Or path to database file if using sqlite3.
#&lt;repository&gt;/etc/brpt.sqlite is default path if left empty
database_user =
# Not used with sqlite3.
database_password =
# Not used with sqlite3.
database_host =
# Not used with sqlite3.
database_port =
# Set to empty string for default. Not used with sqlite3.
web_debug = True

[communication]
protocol = xmlrpc/ssl
password = sF9Xlpuv
certificate = /etc/bcfg2.crt
key = /etc/bcfg2.key
ca = /etc/bcfg2.crt

[components]
bcfg2 = https://bcfg2-server.k-tux.com:6789</pre>
Il faut également créer le répertoire et la configuration qu'il contiendra et qui permettra d'indiquer les dépôts sur lesquels chercher les packages. Dans ma config.xml, comme c'est une Debian Squeeze à qui je m'adresse, les dépôts sont spécifiques. Donc à modifier pour aligner sur vos noeuds.
<pre class="brush: bash">bcfg2-server:/var/lib/bcfg2 $ mkdir /var/lib/bcfg2/Packages
bcfg2-server:/var/lib/bcfg2 $ vim Packages/config.xml

&lt;Sources&gt;
&lt;APTSource&gt;
&lt;Group&gt;debian-squeeze&lt;/Group&gt;
&lt;URL&gt;http://ftp.de.debian.org/debian/&lt;/URL&gt;
&lt;Version&gt;squeeze&lt;/Version&gt;
&lt;Component&gt;main&lt;/Component&gt;
&lt;Component&gt;multiverse&lt;/Component&gt;
&lt;Component&gt;restricted&lt;/Component&gt;
&lt;Component&gt;universe&lt;/Component&gt;
&lt;Arch&gt;amd64&lt;/Arch&gt;
&lt;/APTSource&gt;
&lt;/Sources&gt;</pre>
A présent, il faut indiquer quels packages, et pour qui.
<pre class="brush: bash">bcfg2-server $ cat /var/lib/bcfg2/Metadata/groups.xml
&lt;Groups version='3.0'&gt;
&lt;Group profile='true' public='true' default='true' name='basic'&gt;
&lt;Group name='ubuntu'/&gt;
&lt;/Group&gt;
&lt;Group profile='true' public='true' default='true' name='deb'&gt;
&lt;Group name='debian'/&gt;
&lt;/Group&gt;
&lt;Group name='debian'&gt;
&lt;Bundle name='python'/&gt;
&lt;/Group&gt;
&lt;Group name='ubuntu'&gt;
&lt;Bundle name='release'/&gt;
&lt;/Group&gt;
&lt;/Groups&gt;</pre>
Voila pour qui. Maintenant, le quoi en question. Pour les packages, on utilise ce que bcfg2 appelle des Bundles, qui permettent de grouper plusieurs définitions pour actions. Le tout étant, bien entendu, stocké à sa place dans /var/lib/bcfg2/Bundler/. Nous avons indiqué un Bundle nommé python, nous allons le mettre en forme :
<pre class="brush: bash">bcfg2-server $ cat /var/lib/bcfg2/Bundler/python.xml
&lt;Bundle name="python" version="2.0"&gt;
&lt;Package name="python-openssl"/&gt;
&lt;Package name="python-pytools"/&gt;
&lt;Package name="python-setuptools"/&gt;
&lt;/Bundle&gt;</pre>
Le restart du service n'est pas très rassurant :
<pre class="brush: bash">bcfg2-server:/var/lib/bcfg2 $ bcfg2-server start
Failed to read file /var/lib/bcfg2/Packages/cache/http:@@ftp.de.debian.org@debian@dists@squeeze@multiverse@binary-amd64@Packages.gz
Packages: File read failed; falling back to file download
Packages: Updating http://ftp.de.debian.org/debian/dists/squeeze/main/binary-amd64/Packages.gz
Packages: Updating http://ftp.de.debian.org/debian/dists/squeeze/multiverse/binary-amd64/Packages.gz
Packages: Failed to fetch url http://ftp.de.debian.org/debian/dists/squeeze/multiverse/binary-amd64/Packages.gz. code=404
Packages: Updating http://ftp.de.debian.org/debian/dists/squeeze/restricted/binary-amd64/Packages.gz
Packages: Failed to fetch url http://ftp.de.debian.org/debian/dists/squeeze/restricted/binary-amd64/Packages.gz. code=404
Packages: Updating http://ftp.de.debian.org/debian/dists/squeeze/universe/binary-amd64/Packages.gz
Packages: Failed to fetch url http://ftp.de.debian.org/debian/dists/squeeze/universe/binary-amd64/Packages.gz. code=404
Failed to read file /var/lib/bcfg2/Packages/cache/http:@@ftp.de.debian.org@debian@dists@squeeze@multiverse@binary-amd64@Packages.gz
Failed to update source
Traceback (most recent call last):
File "/usr/lib/python2.6/site-packages/Bcfg2/Server/Plugins/Packages.py", line 120, in setup_data
self.read_files()
File "/usr/lib/python2.6/site-packages/Bcfg2/Server/Plugins/Packages.py", line 406, in read_files
raise
File "/usr/lib/python2.6/site-packages/Bcfg2/Server/Plugins/Packages.py", line 403, in read_files
reader = gzip.GzipFile(fname)
File "/usr/lib/python2.6/gzip.py", line 79, in __init__
fileobj = self.myfileobj = __builtin__.open(filename, mode or 'rb')
IOError: [Errno 2] No such file or directory: '/var/lib/bcfg2/Packages/cache/http:@@ftp.de.debian.org@debian@dists@squeeze@multiverse@binary-amd64@Packages.gz'
The following plugins conflict with Packages;Unloading ['Pkgmgr']
Loading experimental plugin(s): Packages
NOTE: Interfaces subject to change
Handled 32 events in 0.012s
service available at https://bcfg2-server.k-tux.com:6789
serving bcfg2-server at https://bcfg2-server.k-tux.com:6789
serve_forever() [start]</pre>
Par contre, le service est opérationel ! Le client en dry-run, nous renvoie :
<pre class="brush: bash">bcfg2cli-deb $ bcfg2 -qvn
No ca is specified. Cannot authenticate the server with SSL.
No ca is specified. Cannot authenticate the server with SSL.
Loaded tool drivers:
APT      Action   DebInit  POSIX
Package python-openssl not installed
Package python-pytools not installed
Package python-setuptools not installed

Phase: initial
Correct entries:        0
Incorrect entries:      3
Total managed entries:  3
Unmanaged entries:      364

In dryrun mode: suppressing entry installation for:
Package:python-openssl     Package:python-pytools     Package:python-setuptools

Phase: final
Correct entries:        0
Incorrect entries:      3
Package:python-openssl     Package:python-pytools     Package:python-setuptools
Total managed entries:  3
Unmanaged entries:      364

No ca is specified. Cannot authenticate the server with SSL.</pre>
Et en mode non dry-run, on a effectivement les installations qui se déroulent comme prévu :
<pre class="brush: bash">bcfg2cli-deb $ bcfg2 -qv
No ca is specified. Cannot authenticate the server with SSL.
No ca is specified. Cannot authenticate the server with SSL.
Loaded tool drivers:
APT      Action   DebInit  POSIX
Package python-openssl not installed
Package python-pytools not installed
Package python-setuptools not installed

Phase: initial
Correct entries:        0
Incorrect entries:      3
Total managed entries:  3
Unmanaged entries:      364

The Following Bundles have been modified:
python

Phase: final
Correct entries:        3
Incorrect entries:      0
Total managed entries:  3
Unmanaged entries:      364

No ca is specified. Cannot authenticate the server with SSL.

bcfg2cli-deb $ dpkg -s python-openssl
Package: python-openssl
Status: install ok installed [...]</pre>
Et voilà !

Il ne reste plus qu'à gérer les 364 entrées restantes, plus celles que vous allez rajouter pour enrichir vos nodes :) Pour ma part, je dois encore paufiner la conf sur la partie authentification par certificat SSL et tant qu'à faire résoudre le pourquoi-qu'il-me-crache-des-erreurs-python-au-start. Mais tout ceci est une autre histoire !

Ah ! Et à toujours garder en tête : garder la conf par défaut est trèèèèèèèèèèèès dangereux (je pense au port 6789 en question) !!!

Enjoy !!!]]></content:encoded>
			<wfw:commentRss>http://www.k-tux.com/bcfg2-la-gestion-de-conf-du-bout-des-doigts/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Ubuntu Server 11.04 i686 sur plus de 8 CPU</title>
		<link>http://www.k-tux.com/ubuntu-server-11-04-i686-sur-plus-de-8-cpu</link>
		<comments>http://www.k-tux.com/ubuntu-server-11-04-i686-sur-plus-de-8-cpu#comments</comments>
		<pubDate>Fri, 08 Jul 2011 09:02:32 +0000</pubDate>
		<dc:creator>KXan</dc:creator>
				<category><![CDATA[Linux]]></category>
		<category><![CDATA[Sysadmin apps]]></category>
		<category><![CDATA[architecture]]></category>
		<category><![CDATA[conf]]></category>
		<category><![CDATA[kernel]]></category>
		<category><![CDATA[planet-libre]]></category>
		<category><![CDATA[system]]></category>
		<category><![CDATA[ubuntu]]></category>

		<guid isPermaLink="false">http://www.k-tux.com/?p=1023</guid>
		<description><![CDATA[Récemment, j&#8217;ai pu tester l&#8217;installation d&#8217;un Ubuntu Server 11.04 i686 sur un serveur contenant 2 CPU Intel® Xeon® Processor X5650, ce qui fait pas moins de 24 CPUs visibles sous nunux. La demande était expresse : OS 32 bits imposé, &#8230; <a href="http://www.k-tux.com/ubuntu-server-11-04-i686-sur-plus-de-8-cpu">Continue reading <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[Récemment, j'ai pu tester l'installation d'un Ubuntu Server 11.04 i686 sur un serveur contenant 2 CPU Intel® Xeon® Processor X5650, ce qui fait pas moins de 24 CPUs visibles sous nunux. La demande était expresse : OS 32 bits imposé, donc aucune discussion possible.

Et là surprise : à la fin de l'install, on ne voit plus que 8 CPU. Alors forcément, on se pose des questions... Enfin, on pose des questions à dmesg, qui nous renvoie un joli : WARNING: NR_CPUS <em>limit</em> of 8 <em>reached</em>.

Pour cela, il existe une solution : recompiler le noyau avec les bonnes options :)

Pas de panique ni de make menuconfig, sous Ubuntu, la <a href="https://help.ubuntu.com/community/Kernel/Compile" target="_blank">procédure est standardisée</a>.

Au cas où le lien n'est plus valide :
<pre class="brush: bash">sudo apt-get install fakeroot build-essential crash kexec-tools makedumpfile kernel-wedge
sudo apt-get build-dep linux
sudo apt-get install git-core libncurses5 libncurses5-dev libelf-dev asciidoc binutils-dev

fakeroot debian/rules clean
sudo apt-get build-dep --no-install-recommends linux-image-$(uname -r)
apt-get source linux-image-$(uname -r)</pre>
A partir de là, il suffit juste d'éditer <em>linux-2.6.38/debian.master/config/i386/config.flavour.generic-pae</em> (enfin pour moi, à modifier pour votre cas de figure), et de stipuler en plus 2 options :
<pre class="brush: bash">CONFIG_NR_CPUS=32
CONFIG_X86_BIGSMP=y</pre>
Pourquoi 32 ?

D'une, il s'agit en fait d'une limite, donc pas besoin de mettre 24 dans la mesure où <strong>Ubuntu</strong> va lui-même détecter le bon nombre de <strong>CPU</strong> présent.

Et de deux, pour l'avoir testé avec 24, j'ai pu constater qu'en fait, il pouvait voir 32 slots possibles -sûrement la capacité d'accueil de la carte mère-, donc au cas où je décide de rajouter des processeurs (on ne sait jamais), autant la fixer au max :)

Ne pas oublier le <em>chmod</em> des scripts :
<pre class="brush: bash">chmod -R u+x debian/scripts/*</pre>
Update de la <strong>config</strong> :
<pre class="brush: bash">debian/rules updateconfigs</pre>
On recompile en adoptant l'option <em>skipabi</em> (car pour moi ça partait en erreur):
<pre class="brush: bash">DEB_BUILD_OPTIONS=parallel=2 AUTOBUILD=1 NOEXTRAS=1 skipabi=true fakeroot debian/rules binary-generic-pae</pre>
Si vous tombez sur une question vous demandant de choisir entre <em>Sparse</em> et <em>Discontinious Memory</em> et que vous ne savez absolument pas de quoi il en retourne, mieux vaut choisir la Discontinuous Memory, car la Sparse est à titre expérimentale. <a href="http://how-to.wikia.com/wiki/How_to_configure_the_Linux_kernel/mm" target="_blank">Toute l'information est ici</a>.

Et c'est parti pour la génération des <strong>.deb</strong> !

Il ne restera plus qu'à <em>dpkg -i</em> les .deb, rebooter et vous avez un serveur prêt, frais et dispo !!]]></content:encoded>
			<wfw:commentRss>http://www.k-tux.com/ubuntu-server-11-04-i686-sur-plus-de-8-cpu/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Back To Basis : Torque &amp; MAUI</title>
		<link>http://www.k-tux.com/back-to-basis-torque-maui</link>
		<comments>http://www.k-tux.com/back-to-basis-torque-maui#comments</comments>
		<pubDate>Mon, 06 Jun 2011 11:44:36 +0000</pubDate>
		<dc:creator>KXan</dc:creator>
				<category><![CDATA[Linux]]></category>
		<category><![CDATA[Sysadmin apps]]></category>
		<category><![CDATA[architecture]]></category>
		<category><![CDATA[cluster]]></category>
		<category><![CDATA[conception]]></category>
		<category><![CDATA[conf]]></category>
		<category><![CDATA[MAUI]]></category>
		<category><![CDATA[network]]></category>
		<category><![CDATA[planet-libre]]></category>
		<category><![CDATA[system]]></category>
		<category><![CDATA[Torque]]></category>

		<guid isPermaLink="false">http://www.k-tux.com/?p=1004</guid>
		<description><![CDATA[Rapide tip pour sauver ce qui me reste de mémoire avec la mise en place et l&#8217;exploitation d&#8217;un cluster de calcul via Torque et MAUI. Fonctionnement Un cluster de calcul est composé de noeuds de calcul, plus ou moins riches &#8230; <a href="http://www.k-tux.com/back-to-basis-torque-maui">Continue reading <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[Rapide tip pour sauver ce qui me reste de mémoire avec la mise en place et l'exploitation d'un cluster de calcul via <strong>Torque</strong> et <strong>MAUI</strong>.
<h2>Fonctionnement</h2>
Un cluster de calcul est composé de noeuds de calcul, plus ou moins riches en ressources, et à plus ou moins charger. Typiquement, ici, j'ai un cluster composé de 2 ensembles :
<ul>
	<li>les noeuds de calcul 24/24 7/7</li>
	<li>les noeuds de calcul cumulant 2 rôles et qui sont principalement des postes de travail</li>
</ul>
Pour info, je ne détaille pas l'installation ni du cluster en lui-même (réplication d'un noeud sur tous les autres, voir le tip sur <a href="http://www.k-tux.com/systemimager-concepts-dune-solution-dautomatisation-de-deploiement" target="_blank">SystemImager</a>) ni celle des installations de Torque ni MAUI, qui sont triviales.

Je n'attaquerais que la partie <strong>configuration.</strong>

Le fonctionnement d'un cluster de calcul sous Torque / MAUI est le suivant.

Les utilisateurs soumettent des travaux (on appellera ça des <strong>batchs</strong>) au master. Ce master a pour tâche d'enregistrer ces travaux dans une queue et de les soumettre à n noeuds en fonctions des ressources disponibles et demandées par le travail en question.

Pour cela, il existe sur chacun des noeuds de calcul un daemon, <strong>pbs_mom</strong>, qui est chargé de la communication entre le master et le noeud. Pourquoi pbs_mom ? Et bien parce qu'avant de s'appeler Torque, l'outil portait le doux nom de <strong>PBS</strong>.

Le master quant à lui fait tourner principalement 2 daemons : <strong>MAUI</strong>, l'ordonnanceur, et <strong>pbs_server</strong>, qui est notre serveur <strong>TORQUE</strong>. De plus, il gère toute une collection (enfin ça dépend de vous) de queue avec -de préférence- des priorités et des contraintes différentes.
<p style="text-align: left;">Ces contraintes sont notamment liées au temps d'exécution qui est borné, et selon votre bon plaisir, le mien en tout cas, à un maximum de soumission et de jobs en cours d'exécution.</p>
<p style="text-align: left;">Comment faire ? Il suffit de continuer à lire :)</p>
<p style="text-align: left;"><!--nextpage--></p>

<h2 style="text-align: left;">Configuration</h2>
<h3>Maui</h3>
En réalité, MAUI n'a pas besoin, sauf cas particulier -du genre allouer telle ressources entre telle heure et telle heure à tel utilisateur- de configuration spécifique. Tout ce qu'il y a à savoir se trouve sous <em>/var/spool/maui/maui.cfg</em>, je vous ai même rajouté ce cas particulier dont je vous parlais :
<pre class="brush: bash">$ cat /var/spool/maui/maui.cfg | grep -v "#"

SERVERHOST            master
ADMIN1                root

RMCFG[base] TYPE=PBS
AMCFG[bank]  TYPE=NONE

RMPOLLINTERVAL        00:00:30
SERVERPORT            50001
SERVERMODE            NORMAL

LOGDIR                /var/log/maui
LOGFILE               maui.log
LOGFILEMAXSIZE        1000000000
LOGLEVEL              3

QUEUETIMEWEIGHT       1

BACKFILLPOLICY        FIRSTFIT
RESERVATIONPOLICY     CURRENTHIGHEST
NODEALLOCATIONPOLICY  LASTAVAILABLE

SRCFG[prioritaire]          PERIOD=DAY
SRCFG[prioritaire]          STARTTIME=3:00:00
SRCFG[prioritaire]          ENDTIME=11:45:00
SRCFG[prioritaire]          HOSTLIST=ktux-w1,ktux-w2
SRCFG[prioritaire]          USERLIST=kuser</pre>
<h3>Torque</h3>
Par défaut, l'installation de Torque / PBS vous a crée un petit fichier de conf, destiné à paramétrer notamment le démarrage des services. Il nous indique également où est le home de Torque, c'est-à-dire où il range ses petites affaires. Ici, c'est sous <em>/var/spool/pbs</em>.
<pre class="brush: bash">$ cat /etc/pbs.conf
#!/bin/sh
# init of some var needed bi pbs service
# config: /etc/pbs.conf

pbs_home=/var/spool/pbs
pbs_exec=/usr
# set 1 to start the service
start_server=1
start_sched=0
start_mom=0</pre>
<h4>/var/spool/pbs</h4>
Ce répertoire contient notamment les <strong>logs</strong>, mais aussi les données relatives aux queues et aux jobs
<pre class="brush: bash">$ ll /var/spool/pbs/
total 112
drwxr-xr-x  2 root root  4096 2011-06-06 02:40 aux/
drwx------  2 root root  4096 2011-06-06 02:40 checkpoint/
drwxr-xr-x  2 root root  4096 2011-06-06 00:00 mom_logs/
drwxr-xr-x  3 root root  4096 2011-06-06 09:20 mom_priv/
-rw-r--r--  1 root root 56261 2011-06-06 12:46 nodes
-rwxr-xr-x  1 root root  2317 2011-06-06 02:41 pbs_config.sample*
-rw-r--r--  1 root root    26 2011-06-06 02:40 pbs_environment
drwxr-xr-x  2 root root  4096 2011-06-06 09:40 sched_logs/
drwxr-xr-x  3 root root  4096 2011-06-06 10:33 sched_priv/
drwxr-xr-x  2 root root  4096 2011-06-06 00:00 server_logs/
-rwxr-xr-x  1 root root    13 2011-06-06 16:39 server_name*
drwxr-xr-x 12 root root  4096 2011-06-06 15:10 server_priv/
drwxrwxrwt  2 root pbs   4096 2011-06-06 12:30 spool/
drwxrwxrwt  2 root pbs   4096 2011-06-06 02:40 undelivered/</pre>
Principalement, ce qui nous intéressera sera situé sous <strong>server_priv</strong> :
<pre class="brush: bash">$ ll /var/spool/pbs/server_priv/
total 328
drwxr-xr-x 2 root root  12288 2011-06-06 05:00 accounting/
drwxr-xr-x 2 root root   4096 2011-06-06 02:40 acl_groups/
drwxr-xr-x 2 root root   4096 2011-06-06 02:40 acl_hosts/
drwxr-xr-x 2 root root   4096 2011-06-06 10:40 acl_svr/
drwxr-xr-x 2 root root   4096 2011-06-06 10:23 acl_users/
drwxr-xr-x 2 root root   4096 2011-06-06 02:40 arrays/
drwxr-xr-x 2 root root   4096 2011-06-06 02:40 disallowed_types/
drwxr-xr-x 2 root root   4096 2011-06-06 02:40 hostlist/
drwxr-xr-x 2 root root 274432 2011-06-06 10:52 jobs/
-rw-r--r-- 1 root root   1058 2011-06-06 15:10 nodes
drwxr-xr-x 2 root root   4096 2011-06-06 06:55 queues/
-rw------- 1 root root   1351 2011-06-06 10:52 serverdb
-rw------- 1 root root      5 2011-06-06 09:41 server.lock
-rw------- 1 root root      0 2011-06-06 16:47 tracking
$ ll /var/spool/pbs/server_priv/queues/
total 36
-rw------- 1 root root 1319 2011-06-06 13:58 longday
-rw------- 1 root root 1321 2011-06-06 06:55 longnight
-rw------- 1 root root 1320 2011-06-06 13:58 shortday
-rw------- 1 root root 1321 2011-06-06 06:55 shortnight

$ file /var/spool/pbs/server_priv/queues/shortday
/var/spool/pbs/server_priv/queues/shortday: data</pre>
Et sous server_logs :
<pre class="brush: bash">$ ll /var/spool/pbs/server_logs/ | head
-rw-r--r-- 1 root root 315447768 2011-06-06 00:00 20110606</pre>
Tout ça pour dire que c'est facile de retrouver une information.
<h4>Queues</h4>
Je vous parlais plus haut de queue. Une queue est exactement ce à quoi son nom fait penser : c'est une file type <strong>FIFO</strong> qui contient les travaux en attente.

L'utilitaire par définition qui va s'occuper de créer et moduler nos queues comme bon nous semble répond au doux nom de <strong>qmgr</strong>.

Ce qui est bien avec lui, c'est qu'il permet, juste en lançant une petite requête, de nous dumper l'essentiel des commandes nécessaires à créer et paramétrer les <strong>queues</strong> que nous nous sommes donné tant de mal à créer.

Ca me permet de faire 2 manips en une : une, vous montrer comment interroger Torque, et deux, vous montrer comment créer une queue :)
<pre class="brush: bash">$ qmgr -c "print queue @master"
#
# Create queues and set their attributes.
#
#
# Create and define queue longday
#
create queue longday
set queue longday queue_type = Execution
set queue longday Priority = 4
set queue longday max_user_queuable = 30
set queue longday from_route_only = False
set queue longday resources_default.neednodes = day
set queue longday resources_default.nodect = 1
set queue longday resources_default.nodes = 1:day
set queue longday resources_default.walltime = 100:00:00
set queue longday max_user_run = 6
set queue longday enabled = True
set queue longday started = True
#
# Create and define queue shortday
#
create queue shortday
set queue shortday queue_type = Execution
set queue shortday Priority = 2
set queue shortday max_user_queuable = 200
set queue shortday from_route_only = False
set queue shortday resources_max.walltime = 03:00:00
set queue shortday resources_default.neednodes = day
set queue shortday resources_default.nodect = 1
set queue shortday resources_default.nodes = 1:day
set queue shortday resources_default.walltime = 03:00:00
set queue shortday max_user_run = 12
set queue shortday enabled = True
set queue shortday started = True

#
# Create and define queue shortnight
#
create queue shortnight
set queue shortnight queue_type = Execution
set queue shortnight Priority = 2
set queue shortnight max_user_queuable = 400
set queue shortnight from_route_only = False
set queue shortnight resources_max.walltime = 04:00:00
set queue shortnight resources_default.neednodes = night
set queue shortnight resources_default.nodect = 1
set queue shortnight resources_default.nodes = 1:night
set queue shortnight resources_default.walltime = 04:00:00
set queue shortnight max_user_run = 70
set queue shortnight enabled = True
set queue shortnight started = False

#
# Create and define queue longnight
#
create queue longnight
set queue longnight queue_type = Execution
set queue longnight Priority = 4
set queue longnight max_user_queuable = 180
set queue longnight from_route_only = False
set queue longnight resources_default.neednodes = night
set queue longnight resources_default.nodect = 1
set queue longnight resources_default.nodes = 1:night
set queue longnight resources_default.walltime = 100:00:00
set queue longnight max_user_run = 30
set queue longnight enabled = True
set queue longnight started = False</pre>
Comme vous pouvez le voir, les priorités entre queues sont tranchées au couteau : les queues de priorité moindre seront plus prioritaire que celles ayant une valeur plus grandes.

Pour modifier un de ces paramètres, il suffit de les modifier avec par exemple un :
<pre class="brush: bash">$ qmgr -c "set queue longnight max_user_run = 20"</pre>
<h4>Noeuds de calcul</h4>
Pour rajouter des noeuds de calcul, il faut être un peu plus sournois : il faut jouer avec les propriétés du noeud. Même principe, je print, mais pour le créer, soit on passe par un qmgr -c, soit qmgr tout court, qui nous renvoie un prompt :
<pre class="brush: bash">$ qmgr -c "print node ktux-1"

#
# Create and define node ktux-1
#
create node ktux-1
set node ktux-1 np = 2
set node ktux-1 properties = night
set node ktux-1 ntype = cluster</pre>
Ici, je dis que mon noeud ktux-1 a 2 CPUs, de type cluster et doit faire jouer uniquement les travaux en mode night. Pour un noeud de calcul 24/24, 7/7, ça donnera plus du genre :

Via qmgr -c :
<pre class="brush: bash">$ qmgr -c 'create node ktux-w1 np=4,ntype=cluster'
$ qmgr -c 'set node ktux-w1 properties=day'</pre>
Ce qui nous donne :
<pre class="brush: bash">$ qmgr -c "print node ktux-w1"
#
# Create nodes and set their properties.
#
#
# Create and define node ktux-w1
#
create node ktux-w1
set node ktux-w1 state = free
set node ktux-w1 np = 4
set node ktux-w1 properties = day
set node ktux-w1 ntype = cluster</pre>
Au fur et à mesure que les noeuds communiqueront avec le master, tout un tas d'autres infos vont être remontées, comme l'état actuel, les jobs en cours sur ce noeud, ...
<pre class="brush: bash">$ qmgr -c "print node ktux-w1"
#
# Create nodes and set their properties.
#
#
# Create and define node ktux-w1
#
create node ktux-w1
set node ktux-w1 state = busy
set node ktux-w1 np = 4
set node ktux-w1 properties = day
set node ktux-w1 ntype = cluster
set node ktux-w1 status = opsys=linux
set node ktux-w1 status += uname=Linux ktux-w1 2.6.31.14-server-1mnb
set node ktux-w1 status += sessions=23566 23591 23629 23680
set node ktux-w1 status += nsessions=4
set node ktux-w1status += nusers=1
set node ktux-w1 status += idletime=8968185
set node ktux-w1 status += totmem=9009420kb
set node ktux-w1 status += availmem=8458932kb
set node ktux-w1 status += physmem=8143220kb
set node ktux-w1 status += ncpus=4
set node ktux-w1 status += loadave=1.36
set node ktux-w1 status += netload=2067207052
set node ktux-w1 status += state=free
set node ktux-w1 status += jobs=65605 65606 65607 65608
set node ktux-w1 status += varattr=
set node ktux-w1 status += rectime=1307353529</pre>
En réalité, le lien entre properties et queue est fait via l'instruction resources_default.neednodes :
<pre class="brush: bash">set queue longnight resources_default.neednodes = night</pre>
et qmgr mentionne explicitement, pour chaque noeud, à quelle queue il se rattache. Le tout est sous <em>/var/spool/pbs/server_priv/nodes</em> :
<pre class="brush: bash">$ cat /var/spool/pbs/server_priv/nodes

ktux-1 np=2 night
ktux-2 np=2 night
ktux-3 np=2 night
ktux-w1 np=4 day
ktux-w2 np=4 day</pre>
Sans ces instructions, on aurait une erreur du genre :
<pre class="brush: bash">$ qmgr -c "print node ktux-2"
qmgr obj=ktux-2 svr=default: Unknown node  MSG=cannot located specified node</pre>
<p style="text-align: left;">Évidemment, toute modification doit être ponctuée par un restart de pbs_server pour être effective.</p>
<p style="text-align: left;"></p>
<p style="text-align: left;"><!--nextpage--></p>

<h4 style="text-align: left;">Job</h4>
Toute soumission de travail passe par un qsub et doit mentionner le job à faire, la queue sur laquelle on désire travailler et optionnellement si l'on souhaite être averti en allocation des ressources, run et fin du travail.

En retour, on obtient un identifiant de travail.
<pre class="brush: bash">$ qsub -q shortday -o /home/kuser/date.res -e /home/kuser/date.err -m  abe -N  date -M ktux@ktux.com  /home/kuser/date.sh</pre>
Ici, -q attend une queue spécifique, -o précède l'emplacement de l'output désiré, -e celui de l'erreur renvoyée si il y a, -m abe désigne l'instruction de mailing en cas de <em>a(borted)</em> <em>b(egin)</em> <em>e(nd)</em>. -N donne un nom au travail, -M précise le mail en question et en  dernier, le script à exécuter.

A noter qu'ici, le <em>/home</em> de <em>kuser</em> est un partage <strong>NFS</strong>, qui fonctionnera quelque soit le noeud de calcul choisi. Autrement, il aurait fallu désigner un espace accessible avec les droits de kuser par le noeud de calcul en question.

Sur le master, on peut alors suivre le job et son évolution :
<pre class="brush: bash">$ qstat -u kuser

master :
Req'd  Req'd   Elap
Job ID               Username Queue    Jobname          SessID NDS   TSK Memory Time  S Time
-------------------- -------- -------- ---------------- ------ ----- --- ------ ----- - -----
656969            kuser           shortday date                --      1  --    --  00:45 Q   --</pre>
Q : le job est enqueue. R : running.

Sur le client aussi, et ce en étant loggé en tant que kuser :
<pre class="brush: bash">$ qstat
Job id                    Name             User            Time Use S Queue
------------------------- ---------------- --------------- -------- - -----
656969              date                 kuser              0 Q shortday</pre>
Un affichage plus complet passe par un <strong>qstat -f</strong>, d'où on extrait facilement l'<strong>exec host</strong>, c'est à dire l'hôte qui a pris en charge le calcul dès que celui-ci passe en mode <strong>Running</strong>.

Cet exec host peut être composé de plusieurs noeuds de calcul, en fonction des ressources nécessaires au run du travail.

Lorsque l'on souhaite investiguer sur un batch qui ne s'est pas passé comme on l'attendait, deux options s'offrent à nous pour mettre le doigt sur les noeuds ayant participé à sa résolution :
<ul>
	<li>une analyse classique de log</li>
	<li>tracejob</li>
</ul>
L'analyse classique de log va vous amener à <strong>grepper</strong> votre <em>jobID</em> sur les logs de <em>/var/spool/pbs/server_logs/</em> et à remonter jusqu'à l'attribution d'un noeud au batch. C'est sympa, mais manuellement, et sur beaucoup de batch, ça devient un peu long.

Tracejob permet de <strong>parser</strong> justement un ensemble de logs et de vous retourner automatiquement tout ce qui a, de près ou de loin, participé à votre batch. La petite faiblesse étant que, par défaut, il ne prend que les logs du jour même.

<strong>Tracejob</strong> est à lancer sur le master, qui sait et qui voit tout.

En gros, pour aujourd'hui le lundi 06 Juin, il va chercher :

/var/spool/pbs/server_priv/accounting/20110606
/var/spool/pbs/server_logs/20110606
/var/spool/pbs/mom_logs/20110606
/var/spool/pbs/sched_logs/20110606

Ca nous donne ça :
<pre class="brush: bash">$ tracejob 656969
/var/spool/pbs/mom_logs/20110606: No matching job records located
/var/spool/pbs/sched_logs/20110606: No such file or directory

Job: 656969

06/06/2011 12:29:22  S    ready to commit job
06/06/2011 12:29:22  S    ready to commit job completed
06/06/2011 12:29:22  S    committing job
06/06/2011 12:29:22  S    enqueuing into veryshortjour, state 1 hop 1
06/06/2011 12:29:22  S    Job Queued at request of kuser@ktux-1, owner = kuser@ktux-1, job name = date, queue = shortday
06/06/2011 12:29:22  A    queue=shortday
06/06/2011 12:35:25  S    attr Resource_List modified
06/06/2011 12:35:25  S    Job Modified at request of root@master

06/06/2011 12:35:25  S    Job Run at request of root@master
06/06/2011 12:35:25  S    forking in send_job                                                                                                      06/06/2011 12:35:25  S    send_job child job pid is 30568
06/06/2011 12:35:25  S    entering post_sendmom
06/06/2011 12:35:25  S    child reported success for job after 0 seconds (dest=ktux-w1), rc=0
06/06/2011 12:35:25  S    attr Resource_List modified
06/06/2011 12:35:25  S    Job Modified at request of root@master
06/06/2011 12:35:25  S    attr session_id modified
06/06/2011 12:35:25  S    sending 'b' mail for job 656969 to kuser@ktux-1 (---)
06/06/2011 12:35:25  A    user=kuser group=kuser jobname=date queue=shortday ctime=1307356162 qtime=1307356162 etime=1307356162 start=1307356525
owner=kuser@ktux-1 exec_host=ktux-w1/0 Resource_List.neednodes=ktux-w1 Resource_List.nodect=1 Resource_List.nodes=1:day
Resource_List.walltime=00:45:00
06/06/2011 12:35:29  S    obit received
06/06/2011 12:35:29  S    obit received - updating final job usage info
06/06/2011 12:35:29  S    attr resources_used modified
06/06/2011 12:35:29  S    job exit status 0 handled
06/06/2011 12:35:29  S    sending 'e' mail for job 656969 to kuser@ktux-1 (Exit_status=0
06/06/2011 12:35:29  S    Exit_status=0 resources_used.cput=00:00:00 resources_used.mem=0kb resources_used.vmem=0kb resources_used.walltime=00:00:04
06/06/2011 12:35:29  S    on_job_exit task assigned to job
06/06/2011 12:35:29  S    req_jobobit completed
06/06/2011 12:35:29  S    JOB_SUBSTATE_EXITING
06/06/2011 12:35:29  S    JOB_SUBSTATE_STAGEOUT
06/06/2011 12:35:29  S    about to copy stdout/stderr/stageout files
06/06/2011 12:35:29  S    JOB_SUBSTATE_STAGEOUT
06/06/2011 12:35:29  S    JOB_SUBSTATE_STAGEDEL
06/06/2011 12:35:29  S    JOB_SUBSTATE_EXITED
06/06/2011 12:35:29  S    JOB_SUBSTATE_COMPLETE
06/06/2011 12:35:29  S    dequeuing from shortday, state COMPLETE
06/06/2011 12:35:29  S    removed job script
06/06/2011 12:35:29  S    removed job file
06/06/2011 12:35:29  S    freeing job
06/06/2011 12:35:29  A    user=kuser group=kuser jobname=date queue=shortday ctime=1307356162 qtime=1307356162 etime=1307356162 start=1307356525
owner=kuser@ktux-1 exec_host=ktux-w1/0 Resource_List.neednodes=1:day Resource_List.nodect=1 Resource_List.nodes=1:day
Resource_List.walltime=00:45:00 session=24524 end=1307356529 Exit_status=0 resources_used.cput=00:00:00 resources_used.mem=0kb
resources_used.vmem=0kb resources_used.walltime=00:00:04</pre>
<h4>Manipulations de jobs</h4>
Bien entendu, on peut manipuler comme bon nous semble les batches ! Pour cela, nous avons tout un éventail de commandes en q.
<ul>
	<li>qdel : suppression du jobID</li>
	<li>qrun : forçage du run du batch, avec options possibles, comme de le faire tourner sur tel et tel noeuds,...</li>
	<li>qalter : modifier les attributs du job : queue, mailing, ...</li>
	<li>qhold : mettre en suspens un job</li>
	<li>qenable/qdisable : activer/désactiver la destination, typiquement une queue particulière</li>
	<li>qstart/qstop : démarrer/arrêter les queues dans le sens où on peut soumettre, mais les jobs enqueued ne sont pas distribués</li>
	<li>...</li>
</ul>
<h2>Conclusion</h2>
En fait, monter un <strong>cluster</strong> de calcul est beaucoup plus contraignant au moment de la conception matérielle  (installation, câblage, mise dans un <strong>VLAN</strong>, homogénéisation des configurations) et lors de sa maintenance quotidienne que dans la configuration. D'autant plus que le couple <strong>Torque</strong>/<strong>MAUI</strong> est vraiment opérationnel !

Que dire, maintenant que d'autres moyens, plus abstraits comme le <strong>Cloud Computing</strong> existent ?

Car malgré tout, un cluster de calcul, ce n'est rien que pour parser des données. A vous de voir si celles-ci méritent un peu de temps et de moyens pour garder le tout sous contrôle ou si ce besoin de sécurité n'est pas du tout pertinent...]]></content:encoded>
			<wfw:commentRss>http://www.k-tux.com/back-to-basis-torque-maui/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Keepalived : entrée en matière</title>
		<link>http://www.k-tux.com/keepalived-entree-en-matiere</link>
		<comments>http://www.k-tux.com/keepalived-entree-en-matiere#comments</comments>
		<pubDate>Wed, 23 Feb 2011 12:38:03 +0000</pubDate>
		<dc:creator>K-TUX</dc:creator>
				<category><![CDATA[Linux]]></category>
		<category><![CDATA[Sysadmin apps]]></category>
		<category><![CDATA[architecture]]></category>
		<category><![CDATA[Keepalived]]></category>
		<category><![CDATA[LVS]]></category>
		<category><![CDATA[planet-libre]]></category>
		<category><![CDATA[VRRP]]></category>

		<guid isPermaLink="false">http://www.k-tux.com/?p=912</guid>
		<description><![CDATA[Le down d&#8217;un service peut avoir d&#8217;étranges conséquences sur le milieu professionnel. En effet, cela peut passer totalement inaperçu ou bien cela va générer une crise sans précédent, au cours de laquelle vous n&#8217;aurez jamais assez bien fait en aval &#8230; <a href="http://www.k-tux.com/keepalived-entree-en-matiere">Continue reading <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[Le down d'un service peut avoir d'étranges conséquences sur le milieu professionnel. En effet, cela peut passer totalement inaperçu ou bien cela va générer une crise sans précédent, au cours de laquelle vous n'aurez jamais assez bien fait en aval que ce que vous auriez dû prévoir en amont.

L'appréhension de ce genre d'incident permet l'évaluation du besoin et des <strong>SLA</strong> (Service Level Agreements) et, en fonction, le déploiement d'architecture dites <strong>HA</strong> (High Availability). Dans ce type d'architecture, typiquement, l'objectif est de pouvoir assurer un service quelque soit les incidents possibles et imaginables.

Techniquement, cela se traduit par la mise en place de <em>n</em> machines, capables, toutes de délivrer le service, et de savoir ordonner qui prend la main et quand. Ce dernier point implique la présence d'un maître d'orchestre, et donc d'un <strong>Single Point Of Failure</strong>.

Dans ce cas, qui monitore et assure la disponibilité du service de dispatchage des rôles ?
<h2>KeepAlived ?</h2>
<a href="http://www.keepalived.org/" target="_blank">Keepalived</a> est un daemon tournant en Userland qui a pour ambition d'adresser ces 2 problématiques : d'une part gérer la vérification de l'état des intervenants d'un cluster de serveurs et d'autre part assurer, en fonction de ces états, la distribution des rôles aux membres de ce regroupement.

En clair, il s'agit de monitorer les états des différents serveurs impliqués dans la délivrance du service et d'en gérer la disponibilité via l'attribution dynamique de l'IP par laquelle les clients sollicite ce service.

La clé repose sur l'exploitation des fonctionnalités du projet <a href="http://www.linuxvirtualserver.org/" target="_blank">LVS</a> (Linux Virtual Server) et sur le concept d'IP virtuelle. Le tout fonctionne sur une infrastructure de type cluster de serveur / load balancer, généralement contenu dans une DMZ.

Afin de mieux comprendre son fonctionnement, je vous propose de rentrer directement dans la configuration de la bête, car comme dit le vieux proverbe : "il faut avoir les manches retroussées pour comprendre complètement la mécanique !"

Par la suite, je vais donc lâchement supposer que votre infrastructure est en place, et qu'il ne reste plus que le point Keepalived à traiter. Si vous avez besoin d'un petit coup de pouce niveau LVS, jetez un coup d'oeil sur le <a href="http://www.austintek.com/LVS/LVS-HOWTO/" target="_blank">LVS HowTo</a> de Joseph Mack.
<h2>Installation depuis les sources</h2>
L'installation la plus nette est toujours celle utilisant <a href="http://www.k-tux.com/git-quand-un-filesystem-fait-du-versionning" target="_blank">git</a>, c'est d'ailleurs elle que j'ai choisi, mais rien ne vous empêche d'utiliser les dépôts !
<pre class="brush: bash">$ git clone http://master.formilux.org/git/people/alex/keepalived.git /usr/local/src/

$ ll /usr/local/src/
total 12
drwxr-xr-x  3 bux bux 4096 2011-02-16 12:08 .
drwxr-xr-x 20 bux bux 4096 2011-02-16 12:08 ..
drwxr-xr-x  9 bux bux 4096 2011-02-16 12:08 keepalived

$ cd keepalived

$ ./configure

[...]

Keepalived configuration
------------------------
Keepalived version       : 1.1.20
Compiler                 : gcc
Compiler flags           : -g -O2
Extra Lib                : -lpopt -lssl -lcrypto
Use IPVS Framework       : No
IPVS sync daemon support : No
Use VRRP Framework       : Yes
Use Debug flags          : No

$ make &amp;&amp; make install

[...]

install -d /usr/local/sbin
install -m 700 ../bin/keepalived /usr/local/sbin/
install -d /usr/local/etc/rc.d/init.d
install -m 755 etc/init.d/keepalived.init /usr/local/etc/rc.d/init.d/keepalived
install -d /usr/local/etc/sysconfig
install -m 755 etc/init.d/keepalived.sysconfig /usr/local/etc/sysconfig/keepalived
install -d /usr/local/etc/keepalived/samples
install -m 644 etc/keepalived/keepalived.conf /usr/local/etc/keepalived/
install -m 644 ../doc/samples/* /usr/local/etc/keepalived/samples/
install -d /usr/local/share/man/man5
install -d /usr/local/share/man/man8
install -m 644 ../doc/man/man5/keepalived.conf.5 /usr/local/share/man/man5
install -m 644 ../doc/man/man8/keepalived.8 /usr/local/share/man/man8
make[1]: quittant le répertoire « /usr/local/src/keepalived/keepalived »
make -C genhash install
make[1]: entrant dans le répertoire « /usr/local/src/keepalived/genhash »
install -d /usr/local/bin
install -m 755 ../bin/genhash /usr/local/bin/
install -d /usr/local/share/man/man1
install -m 644 ../doc/man/man1/genhash.1 /usr/local/share/man/man1
make[1]: quittant le répertoire « /usr/local/src/keepalived/genhash »</pre>
Installation cleared !
<h2>Configuration</h2>
Comme on peut le déduire des traces laissées par le make de keepalived, les fichiers de configuration se situent sous /usr/local/etc/keepalived/, en sachant qu'un fichier est déjà fourni de base et qu'on peut également s'appuyer sur les samples (exemples, extraits) fournis :
<pre class="brush: bash">$ ll /usr/local/etc/keepalived/
total 16
drwxr-xr-x 3 root root 4096 2011-02-16 12:13 .
drwxr-xr-x 5 root root 4096 2011-02-16 12:13 ..
-rw-r--r-- 1 root root 3562 2011-02-16 12:13 keepalived.conf
drwxr-xr-x 2 root root 4096 2011-02-16 12:13 samples

$ ll samples/
total 104
drwxr-xr-x 2 root root 4096 2011-02-16 12:13 .
drwxr-xr-x 3 root root 4096 2011-02-16 12:13 ..
-rw-r--r-- 1 root root 1745 2011-02-16 12:13 client.pem
-rw-r--r-- 1 root root  245 2011-02-16 12:13 dh1024.pem
-rw-r--r-- 1 root root  433 2011-02-16 12:13 keepalived.conf.fwmark
-rw-r--r-- 1 root root  684 2011-02-16 12:13 keepalived.conf.HTTP_GET.port
-rw-r--r-- 1 root root  746 2011-02-16 12:13 keepalived.conf.inhibit
-rw-r--r-- 1 root root  550 2011-02-16 12:13 keepalived.conf.misc_check
-rw-r--r-- 1 root root  538 2011-02-16 12:13 keepalived.conf.misc_check_arg
-rw-r--r-- 1 root root 2467 2011-02-16 12:13 keepalived.conf.quorum
-rw-r--r-- 1 root root  919 2011-02-16 12:13 keepalived.conf.sample
-rw-r--r-- 1 root root 2760 2011-02-16 12:13 keepalived.conf.SMTP_CHECK
-rw-r--r-- 1 root root 1587 2011-02-16 12:13 keepalived.conf.SSL_GET
-rw-r--r-- 1 root root  842 2011-02-16 12:13 keepalived.conf.status_code
-rw-r--r-- 1 root root  735 2011-02-16 12:13 keepalived.conf.track_interface
-rw-r--r-- 1 root root  887 2011-02-16 12:13 keepalived.conf.virtualhost
-rw-r--r-- 1 root root 1087 2011-02-16 12:13 keepalived.conf.virtual_server_group
-rw-r--r-- 1 root root 1425 2011-02-16 12:13 keepalived.conf.vrrp
-rw-r--r-- 1 root root 3019 2011-02-16 12:13 keepalived.conf.vrrp.localcheck
-rw-r--r-- 1 root root 1083 2011-02-16 12:13 keepalived.conf.vrrp.lvs_syncd
-rw-r--r-- 1 root root  888 2011-02-16 12:13 keepalived.conf.vrrp.routes
-rw-r--r-- 1 root root 1146 2011-02-16 12:13 keepalived.conf.vrrp.scripts
-rw-r--r-- 1 root root  591 2011-02-16 12:13 keepalived.conf.vrrp.static_ipaddress
-rw-r--r-- 1 root root 1742 2011-02-16 12:13 keepalived.conf.vrrp.sync
-rw-r--r-- 1 root root  802 2011-02-16 12:13 root.pem
-rw-r--r-- 1 root root  323 2011-02-16 12:13 sample.misccheck.smbcheck.sh</pre>
Le fichier de configuration en question est généré tel quel :
<pre class="brush: bash">! Configuration File for keepalived

global_defs {
  notification_email {
    acassen@firewall.loc
    failover@firewall.loc
    sysadmin@firewall.loc
  }
  notification_email_from Alexandre.Cassen@firewall.loc
  smtp_server 192.168.200.1
  smtp_connect_timeout 30
  router_id LVS_DEVEL
}

vrrp_instance VI_1 {
  state MASTER
  interface eth0
  virtual_router_id 51
  priority 100
  advert_int 1
  authentication {
    auth_type PASS
    auth_pass 1111
  }
  virtual_ipaddress {
    192.168.200.16
    192.168.200.17
    192.168.200.18
 }
}

virtual_server 192.168.200.100 443 {
  delay_loop 6
  lb_algo rr
  lb_kind NAT
  nat_mask 255.255.255.0
  persistence_timeout 50
  protocol TCP

  real_server 192.168.201.100 443 {
    weight 1
    SSL_GET {
      url {
        path /
        digest ff20ad2481f97b1754ef3e12ecd3a9cc
      }
      url {
        path /mrtg/
        digest 9b3a0c85a887a256d6939da88aabd8cd
      }
      connect_timeout 3
      nb_get_retry 3
      delay_before_retry 3
    }
   }
}

virtual_server 10.10.10.2 1358 {
  delay_loop 6
  lb_algo rr
  lb_kind NAT
  persistence_timeout 50
  protocol TCP
  sorry_server 192.168.200.200 1358

  real_server 192.168.200.2 1358 {
    weight 1
    HTTP_GET {
      url {
        path /testurl/test.jsp
        digest 640205b7b0fc66c1ea91c463fac6334d
     }
      url {
        path /testurl2/test.jsp
        digest 640205b7b0fc66c1ea91c463fac6334d
      }
      url {
        path /testurl3/test.jsp
        digest 640205b7b0fc66c1ea91c463fac6334d
      }
      connect_timeout 3
      nb_get_retry 3
      delay_before_retry 3
    }
  }

  real_server 192.168.200.3 1358 {
  weight 1
  HTTP_GET {
    url {
    path /testurl/test.jsp
    digest 640205b7b0fc66c1ea91c463fac6334c
    }
    url {
      path /testurl2/test.jsp
      digest 640205b7b0fc66c1ea91c463fac6334c
    }
    connect_timeout 3
    nb_get_retry 3
    delay_before_retry 3
  }
 }
}

virtual_server 10.10.10.3 1358 {
  delay_loop 3
  lb_algo rr
  lb_kind NAT
  nat_mask 255.255.255.0
  persistence_timeout 50
  protocol TCP

  real_server 192.168.200.4 1358 {
    weight 1
    HTTP_GET {
      url {
        path /testurl/test.jsp
        digest 640205b7b0fc66c1ea91c463fac6334d
      }
      url {
        path /testurl2/test.jsp
        digest 640205b7b0fc66c1ea91c463fac6334d
      }
      url {
        path /testurl3/test.jsp
        digest 640205b7b0fc66c1ea91c463fac6334d
      }
     connect_timeout 3
     nb_get_retry 3
     delay_before_retry 3
   }
  }

  real_server 192.168.200.5 1358 {
  weight 1
    HTTP_GET {
      url {
        path /testurl/test.jsp
        digest 640205b7b0fc66c1ea91c463fac6334d
      }
      url {
        path /testurl2/test.jsp
        digest 640205b7b0fc66c1ea91c463fac6334d
     }
      url {
        path /testurl3/test.jsp
        digest 640205b7b0fc66c1ea91c463fac6334d
      }
      connect_timeout 3
      nb_get_retry 3
      delay_before_retry 3
    }
  }
}</pre>
<p style="text-align: left;">Grâce à lui, on a déjà un aperçu de la manière dont KeepAlived organise les informations : tout passe par la définition de bloc.</p>

<h3 style="text-align: left;"><!--nextpage--></h3>
<h3 style="text-align: left;">Epluchage de conf</h3>
On peut voir que la configuration est scindée en trois :
<ul>
	<li>une partie globale (le bloc <em>global_def</em>), qui n'est ni plus ni moins que la définition des adresses mail, de routes statiques et d'identifiant.</li>
	<li>une partie définissant les instances et groupes de synchronisation <strong>VRRP</strong>,</li>
	<li>une partie propre aux paramétrages des <strong>LVS</strong>, qui peut contenir un ou plusieurs blocs de définition de serveurs virtuels, eux-même encapsulant des serveurs réels caractérisés par des paramétrage en terme de poids, d'IP, et de process de vérification.</li>
</ul>
Intéressons-nous aux 2 dernières parties.
<h4>VRRP</h4>
<h5>vrrp_sync_group</h5>
Les VRRP synchronization groups sont des groupes qui rassemblent les instances VVRP.
<pre class="brush: bash">#string, name of group of IPs that failover together
vrrp_sync_group VG_1 {
group {
VI_1   # name of vrrp_instance (below)
VI_2  # One for each moveable IP.
...
}

# notify scripts and alerts are optional

# filenames of scripts to run on transitions can be unquoted (if just filename) or quoted (if has parameters) to MASTER transition

notify_master /path/to_master.sh
# to BACKUP transition
notify_backup /path/to_backup.sh
# FAULT transition
notify_fault "/path/fault.sh VG_1"

# for ANY state transition.
# "notify" script is called AFTER the
# notify_* script(s) and is executed
# with 3 arguments provided by keepalived (ie don't include parameters in the notify line).
# arguments
# $1 = "GROUP"|"INSTANCE"
# $2 = name of group or instance
# $3 = target state of transition
#     ("MASTER"|"BACKUP"|"FAULT")
notify /path/notify.sh

# Send email notifcation during state transition,
# using addresses in global_defs above.
smtp_alert
}</pre>
<h5>vrrp_instance</h5>
La partie <em>vrrp_instance</em> est définie dans la configuration créée telle que :
<pre class="brush: bash">vrrp_instance VI_1 {
    state MASTER
    interface eth0
    virtual_router_id 51
    priority 100
    advert_int 1
    authentication {
      auth_type PASS
      auth_pass 1111
    }

    virtual_ipaddress {
      192.168.200.16
      192.168.200.17
      192.168.200.18
  }
}</pre>
Alors, c'est quoi au juste cette vrrp_instance ?

Commençons par le commencement. <strong>VRRP</strong>, pour <em>Virtual Router Redondancy Protocol</em>, est un protocole d'abstraction de serveur, qui permet via la création d'un groupe de serveurs réels et la gestion d'adresses IP réelles et virtuelles, d'attribuer dynamiquement le rôle de réponse aux requêtes client à un des serveurs en état de le faire. En un mot, il assure le <strong>monitoring</strong> des instances capables de délivrer le service et donc sa <strong>disponibilité</strong>.

La configuration par défaut définit donc notre machine comme l'instance VRRP maître et y associe :
<ul>
	<li>un identifiant (<em>virtual_router_id 51</em>),</li>
	<li>une interface liée à VRRP (<em>interface eth0</em>),</li>
	<li>une priorité très haute (<em>priority 100</em>), en sachant que plus cette priorité est haute et plus la machine a de chance d'être élue,</li>
	<li>des paramètres d'authentification</li>
	<li>des adresses IP virtuelles à rajouter / supprimer lors des bascules.</li>
</ul>
Juste au cas où, <em>auth_pass</em> doit être strictement identique sur toutes les machines impliquées.

De cette façon, il faudra définir, pour chaque membre étant ou pouvant être impliqué potentiellement dans la bascule les caractéristiques de sa <em>vrrp_instance</em>.
<p style="text-align: left;">A noter que le template généré est loin d'être exhaustif. En effet, pas mal d'options permettent de mieux travailler la bascule.</p>

<h4 style="text-align: left;"><!--nextpage--></h4>
<h4 style="text-align: left;">LVS</h4>
<p style="text-align: left;">De la même manière qu'il est possible de faire des groupes d'instance <strong>vrrpd</strong>, il est possible de grouper les instances <em>virtual_server</em>, mais la Communauté ne semble envisager son utilisation que dans le cas où vous êtes en présence de très grands LVS , ce ne sera donc pas abordé ici.</p>

<h5 style="text-align: left;">virtual_server</h5>
Notre bloc concernant un <em>virtual_server</em> a cette tête-là dans la conf générée. Les commentaires sont là pour éviter une répétition laborieuse et peu utile de chacune des instructions pour détail :)
<pre class="brush: bash">virtual_server 192.168.200.100 443 {
# delay timer for service polling
delay_loop 3

# LVS scheduler
lb_algo rr

# LVS forwarding method
lb_kind NAT
nat_mask 255.255.255.0

# LVS persistence timeout, sec
persistence_timeout 50
protocol TCP

# RS to add when all realservers are down
sorry_server 192.168.200.200 443

# one entry for each realserver
real_server 192.168.201.100 443 {
# relative weight to use, default: 1
 weight 1

# pick one healthchecker
# HTTP_GET|SSL_GET|TCP_CHECK|SMTP_CHECK|MISC_CHECK
 SSL_GET {
     url {
       path /
       digest ff20ad2481f97b1754ef3e12ecd3a9cc
     }
     url {
      path /mrtg/
      digest 9b3a0c85a887a256d6939da88aabd8cd
     }

connect_timeout 3
nb_get_retry 3
delay_before_retry 3
  } # End HTTP_GET section
 } # End real_server definition
} # End virtual_server definition</pre>
Beaucoup plus intuitif que les sections VRRP, cette configuration est très simple à manier et se passe assez facilement d'explication. Même remarque, les options ne sont pas exhaustives et une véritable mine de paramètres vous attendent au détour d'un man.

Il ne reste plus qu'à paufiner la conf et à lancer un petit keepalived -D (detailed logs).
<h2>La preuve par l'exemple</h2>
Jouons un peu avec les serveurs DNS.

Nous avons un serveur maître, et un esclave. Ces deux serveurs ont chacun une IP réelle (192.168.0.2 pour le Maître et 192.168.0.3 pour l'esclave). En revanche, le service est accédé l'IP virtuelle 192.168.0.10.
<pre class="brush: bash">$ ssh root@dns1 ip addr sh eth0
2: eth0: &lt;BROADCAST,MULTICAST,UP,LOWER_UP&gt; mtu 1500 qdisc pfifo_fast qlen 1000
link/ether 00:50:56:a3:00:0d brd ff:ff:ff:ff:ff:ff
inet 192.168.0.2/24 brd 192.168.0.255 scope global eth0
inet 192.168.0.10/32 scope global eth0
inet6 fe80::250:56ff:fea3:d/64 scope link
valid_lft forever preferred_lft forever

$ ssh root@dns2 ip addr sh eth0
2: eth0: &lt;BROADCAST,MULTICAST,UP,LOWER_UP&gt; mtu 1500 qdisc pfifo_fast qlen 1000
link/ether 00:50:56:a3:00:0c brd ff:ff:ff:ff:ff:ff
inet 192.168.0.3/24 brd 192.168.0.255 scope global eth0
inet6 fe80::250:56ff:fea3:c/64 scope link
valid_lft forever preferred_lft forever

$ ping dns

PING dns.k-tux.com (192.168.0.10) 56(84) bytes of data.
64 bytes from dns.k-tux.com (192.168.0.10): icmp_seq=1 ttl=63 time=0.499 ms
^C
--- dns.k-tux.com ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 535ms
rtt min/avg/max/mdev = 0.499/0.499/0.499/0.000 ms</pre>
En terme de configuration Keepalived, nous aurons donc 2 types d'instances vrrp.

Ici, nous effectuons une vérification toutes les 6 secondes qui, selon le résultat du check, pourra potentiellement faire basculer l'IP virtuelle 192.168.0.10 d'un serveur à l'autre. Pour cela nous devons définir un <em>vrrp_script</em>, qui fera en temps et en secondes les traitements voulus.
<h5>Sur le master :</h5>
<pre class="brush: bash">vrrp_script check_named {           # Requires keepalived-1.1.13
    script "killall -0 named"           # cheaper than pidof
    interval 6                          # check every 6 seconds
    weight -60                          # add 60 points of prio if OK
}

vrrp_instance dns_on_master {
    state MASTER
    interface eth0
    virtual_router_id 91
    priority 200
    advert_int 1
    smtp_alert
    authentication {
      auth_type PASS
      auth_pass 1111
   }

    virtual_ipaddress {
      192.168.0.10
    }

    track_script {
      check_named
    }

notify_master "/etc/rc.d/init.d/named reload"
notify_backup "/etc/rc.d/init.d/named reload"
}</pre>
<h5>Et sur le slave :</h5>
<pre class="brush: bash">vrrp_script check_named {           # Requires keepalived-1.1.13
    script "killall -0 named"           # cheaper than pidof
    interval 6                          # check every 6 seconds
    weight -60                          # add 60 points of prio if OK
}

vrrp_instance dns_on_slave {
    state SLAVE
    interface eth0
    virtual_router_id 91
    priority 150
    smtp_alert
    advert_int 1
    authentication {
      auth_type PASS
      auth_pass 1111
    }
    virtual_ipaddress {
      192.168.0.10
   }

   track_script {
   check_named
}

notify_master "/etc/rc.d/init.d/named reload"
notify_backup "/etc/rc.d/init.d/named reload"
}</pre>
Le test le plus probant est d'arrêter un des deux serveurs dns, au hasard le master (celui qui a la plus haute priorité détient logiquement l'IP virtuelle) : on doit observer une bascule de l'IP virtuelle 192.168.0.10 de dns1 à dns2. Le <em>smtp_alert</em> nous rajoute une couche d'information en nous mailant la bascule.
<h2>Conclusion</h2>
Quelques détails suffisent à changer la donne, et coupler Keepalived avec une infrastructure bien étudiée permet de balayer assez facilement les petits soucis relatifs à des pannes de service.

De plus c'est un outil simple, intuitif, riche en terme d'options et paramétrable à souhait.

Pourquoi s'en passer ?]]></content:encoded>
			<wfw:commentRss>http://www.k-tux.com/keepalived-entree-en-matiere/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>SystemImager : concepts d&#8217;une solution d&#8217;automatisation de déploiement</title>
		<link>http://www.k-tux.com/systemimager-concepts-dune-solution-dautomatisation-de-deploiement</link>
		<comments>http://www.k-tux.com/systemimager-concepts-dune-solution-dautomatisation-de-deploiement#comments</comments>
		<pubDate>Sun, 04 Jul 2010 14:59:59 +0000</pubDate>
		<dc:creator>K-TUX</dc:creator>
				<category><![CDATA[Linux]]></category>
		<category><![CDATA[Sysadmin apps]]></category>
		<category><![CDATA[architecture]]></category>
		<category><![CDATA[conf]]></category>
		<category><![CDATA[deploiement]]></category>
		<category><![CDATA[filesystem]]></category>
		<category><![CDATA[install]]></category>
		<category><![CDATA[multicast]]></category>
		<category><![CDATA[planet-libre]]></category>
		<category><![CDATA[remote]]></category>
		<category><![CDATA[rsync]]></category>
		<category><![CDATA[SSH]]></category>
		<category><![CDATA[system]]></category>
		<category><![CDATA[SystemImager]]></category>

		<guid isPermaLink="false">http://www.k-tux.com/?p=681</guid>
		<description><![CDATA[SystemImager est un projet très abouti qui permet de gérer l&#8217;installation et le déploiement de logiciel et de distribution Linux, tout en s&#8217;appuyant des outils standards comme SSH et rsync. Il se distingue très nettement des outils comme Fedora kickstart &#8230; <a href="http://www.k-tux.com/systemimager-concepts-dune-solution-dautomatisation-de-deploiement">Continue reading <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[<strong><a href="http://wiki.systemimager.org/index.php/Main_Page" target="_blank&quot;">SystemImager</a> </strong>est un projet très abouti qui permet de gérer l'installation et le déploiement de logiciel et de distribution Linux, tout en s'appuyant des outils standards comme <strong>SSH </strong>et <strong>rsync</strong>.

Il se distingue très nettement des outils comme Fedora <strong>kickstart </strong>et Debian <strong>debootstrap </strong>dans la mesure où il est capable de gérer plusieurs architectures et distributions différentes.

D'autre part, la finesse des petites <strong>customisations </strong>et tout ce qui pourrait sortir du standard des dépôts est directement prise en compte et appliquée, sans avoir à se confronter aux fameux scripts de<strong> post-installation</strong>. En ce sens, cela fait de lui l'outil incontournable pour une gestion de parc uniforme et <strong>automatisée</strong>.

Son fonctionnement est simple : il aspire dans un premier temps tout ou partie d'un système de fichier (on peut spécifier des <strong>exclusions </strong>ou même en créer un viable, via les outils du package) qu'il stocke tel quel au sein d'un <strong>dépôt </strong>d'image. Il s'agit ensuite de rebalancer l'arborescence, soit pour une installation complète, soit pour un alignement des version.

Du fait que le système de fichier soit stocké en l'état, il est alors très facile de modifier et contrôler le contenu de l'<strong>image </strong>avant déploiement.

La seule contrainte concerne les clients et requiert une parfaite adéquation dans le nombre de  disques durs des <strong>noeuds </strong>sous la juridiction de SystemImager. La capacité peut varier, mais attention aux disques plus petits que ceux du <strong>GoldenClient</strong>. En effet, si l'on venait à balancer une install qui ne tiendrait pas sur le disque, cela ferait désordre.

Pour pouvoir entrer dans les détails, il est nécessaire de définir les notions sur lesquelles s'appuie SystemImager.
<h2>Les éléments</h2>
<h3>L'image server</h3>
SystemImager a besoin d'un maître d'orchestre, appelé le serveur d'image, afin de pouvoir centraliser toute la partie gestion des images et des noeuds.

Notre serveur contiendra donc tous les packages et toute la configuration nécessaire à SystemImager. La racine de SystemImager se situe au niveau de<em> /var/lib/systemimager</em>, et est enrichie de plusieurs éléments :
<pre class="brush: bash"># ll /var/lib/systemimager/
total 28
-rw-r--r--  1 root root 14361 2010-06-29 11:13 clients.xml
drwxr-xr-x  9 root root  4096 2010-06-23 10:21 images/
drwxr-xr-x 55 root root  4096 2010-06-23 10:21 overrides/
drwxr-xr-x  4 root root  4096 2010-06-23 10:21 scripts/</pre>
Les explications relatives aux différents éléments seront fournies un peu plus loin.

Afin de pouvoir distribuer les images correctement -et surtout lors du boot <strong>PXE</strong>-, le server devra regrouper le duo <strong>TFTP </strong>server et <strong>DHCP </strong>server.

A noter que SystemImager permet de rapidement mettre en place une configuration complète de serveur de <strong>boot </strong>grâce à l'outil <em>si_mkbootserver</em>, intégré au package<em> systemimager-server</em>.

Il existe plusieurs façons d'installer via SystemImager. PXE, comme nous l'avons mentionné un peu plus haut, <strong>Bittorent</strong>, ou par <strong>multicast</strong>. Ces variations sont à l'origine de certains packages qui ont été spécialement crée sur ces spécificités.

A titre d'information, les packages intéressants sont :
<pre class="brush: bash">systemimager-server : le core du serveur SystemImager,
systemimager-common : les outils qui vont avec,
systemimager-*boot-standard : les outils relatifs à la partie boot server, * regroupe i386 et x86_64

systemimager-server-flamethrower* : pour utiliser le mode multicast
systemimager-server-bittorrent : pour utiliser le mode BitTorrent.</pre>
Il va sans dire que, si vous projetez d'installer plusieurs distributions, il faudra assurer au niveau <strong>stockage </strong>des images. Même réflexion concernant la partie réseau, surtout si l'intention de virtualiser vous taraude.

Le paramétrage fin de SystemImager se fait comme d'habitude, via un fichier de configuration : <em>/etc/systemimager.conf</em>, ou<em> /etc/systemimager/systemimager.conf</em>.
<h3>Les nodes</h3>
Les nodes sont les postes clients qui vont faire l'objet d'une installation <strong>automatisée </strong>par SystemImager. Ils sont rattachés préalablement à une image bien précise, et optionnellement à un ou plusieurs <strong>overrides</strong>.

Accessoirement, ils disposent d'une entrée dans le fichier <em>/etc/dhcpd.conf</em> du serveur afin de pouvoir obtenir une adresse et pouvoir rapatrier, via TFTP par exemple, un noyau minimal qui se chargera de l'installation.

Le paramétrage des clients et leur <strong>association </strong>à une image peut passer par <em>si_addclients</em> (c'est d'ailleurs historique)ou par <em>si_clusterconfig</em>.

Je ne vous éplucherais pas toutes les options qui sont disponibles, sachez que vous pouvez absolument tout faire, grouper vos clients en liste FQDN, IP, avec un domainname qui leur pend, en interactif,... Bref, <strong>man </strong>est votre meilleur ami. On retrouve les informations relatives aux nodes dans le fichier<em> /var/lib/systemimager/clients.xml</em>.

Point important,<em> si_clusterconfig</em> est un outil au-dessus de la gestion de <strong>node</strong>, c'est-à-dire qu'il définit l'ensemble de votre <strong>cluster </strong>en terme de groupe, de priorité, d'image, d'override, et de node.
<h3>Le GoldenClient</h3>
Le GoldenClient est un poste de même calibre que les nodes, et qui leur servira indirectement de <strong>référence</strong>. Il doit être installé et configuré manuellement et est à l'origine de l'image référente que vous déployerez. <em>systemimager-common</em> et<em> systemimager-client</em> devront être présents sur le GoldenClient.
<h3>Les images</h3>
Les images sont des répertoires <strong>chrootables </strong>qui contiennent l'intégralité du système de fichier à déployer sur les clients. Elles sont identifiées par un nom intelligible, fourni en entrée lors de leur récupération du GoldenClient.

Toutes les images sont stockées sous la racine de SystemImager, c'est-à-dire sous <em>/var/lib/systemimager/images</em>.

Gardez sous le coude <em>si_lsimage</em> pour les voir, <em>si_rmimage</em> pour les supprimer et surtout <em>si_getimage</em> pour en rapatrier une (oui, aussi <em>si_mvimage</em> et <em>si_cpimage</em> mais pas besoin de vous expliquer ce que ça vaut).
<h3>Les overrides</h3>
Parce qu'on ne va pas stocker plusieurs systèmes de fichiers juste pour une différence de <strong>configuration </strong>sur une poignée de fichiers, SystemImager a défini la notion d'override.

Les <strong>overrides </strong>concernent les customisations appliquées à une image en particulier, il y peut donc y avoir plusieurs overrides pour une image. De la même façon que les images ont un nom, les overrides en disposent également d'un.

Les overrides contiennent une portion de l'<strong>arborescence </strong>du système de fichier, qui diffère de celle proposée par l'image, et qui viendra écraser celle issue de l'image originale après que celle-ci ait été mise en place.
<pre class="brush: bash" style="text-align: left;">ls overrides/ide/
boot/  etc/</pre>
<p style="text-align: left;">On retrouve les overrides sous <em>/var/lib/systemimager/overrides</em>, et pour les pousser sur les nodes, il vous suffit d'un  <em>si_pushoverrides</em>.</p>
<p style="text-align: left;"><!--more--></p>

<h2>Fonctionnement</h2>
Voila commence ça se passe...

Premièrement, vous avez dû monter, à la sueur de votre front, votre petit serveur DHCP/TFTP/SystemImager. Deux-trois tips sympa qui vous permettront d'avancer rapidement :
-<em> si_mkdhcpserver / si_mkdhcpstatic</em>, qui va vous arquer sur la configuration d'un DHCP opérationnel,
- <em>si_mkbootserver</em>, pour l'aspect PXE / TFTP,
- <em>/etc/systemimager/systemimager.conf</em>, pour la conf.

Et puis on attaque le gros œuvre !
<!--nextpage-->
<h3>From Scratch ! L'installation automatisée</h3>
Le plus pénible d'abord. Prenez votre GoldenClient et, gentillement, patiemment, installez-le et configurez au poil toutes les <strong>options </strong>qui vont bien.

Saupoudrez de<em> systemimager-common</em> et de <em>systemimager-client</em>, vos petits outils qui vous sauveront une énorme quantité de temps.

N'oubliez pas de customiser le<em> /etc/systemimager/client.conf</em> pour tout ce qui est port d'adressage, exclude,...

<em>si_prepareclient</em> va vous permettre de lancer tout ce qui va bien -<strong>rsync</strong>, fichiers,... afin que votre server SystemImager puisse récupérer l'image.

En clair, il déduit de la conf actuelle toutes les informations utiles, dont le <strong>partitionnement </strong>des disques.
<pre class="brush: bash">$ si_prepareclient  --server kaster
Welcome to the SystemImager si_prepareclient command.  This command may modify
the following files to prepare your golden client for having it's image
retrieved by the imageserver.  It will also create the /etc/systemimager
directory and fill it with information about your golden client.  All modified
files will be backed up with the .before_systemimager-4.1.6 extension.

/etc/services:
This file defines the port numbers used by certain software on your system.
Entries for rsync will be added if necessary.

/tmp/filerNi0f5:
This is a temporary configuration file that rsync needs on your golden client
in order to make your filesystem available to your SystemImager server.

inetd configuration:
SystemImager needs to run rsync as a standalone daemon on your golden client
until it's image is retrieved by your SystemImager server.  If rsyncd is
configured to run as a service started by inetd, it will be temporarily
disabled, and any running rsync daemons or commands will be stopped.  Then,
an rsync daemon will be started using the temporary configuration file
mentioned above.

See "si_prepareclient --help" for command line options.

Continue? (y/[n]): y
*********************************** WARNING ***********************************
This utility starts an rsync daemon that makes all of your files accessible
by anyone who can connect to the rsync port of this machine.  This is the
case until you reboot, or kill the 'rsync --daemon' process by hand.  By
default, once you use si_getimage to retrieve this image on your imageserver,
these contents will become accessible to anyone who can connect to the rsync
port on your imageserver.  See rsyncd.conf(5) for details on restricting
access to these files on the imageserver.  See the systemimager-ssh package
for a more secure method of making images available to clients.
*********************************** WARNING ***********************************

Continue? (y/[n]): y

Signaling xinetd to restart...
...
Using "sfdisk" to gather information about disk:
/dev/sda

[...]
&gt;&gt;&gt; Choosing filesystem for new initrd:  cpio
&gt;&gt;&gt; Creating new initrd from staging dir:  /tmp/.systemimager.0
&gt;&gt; cd /tmp/.systemimager.0 &amp;&amp; find . ! -name "*~" | cpio -H newc --create | gzip -9 &gt; /etc/systemimager/boot/initrd.img
123093 blocks
&gt;&gt; ls -l /etc/systemimager/boot/initrd.img
-rw-r--r-- 1 root root 44150730 Jul  1 16:02 /etc/systemimager/boot/initrd.img

&gt;&gt; Evaluating initrd size to be added in the kernel boot options
&gt;&gt; (e.g. /etc/systemimager/pxelinux.cfg/syslinux.cfg):
&gt;&gt;     suggested value -&gt; ramdisk_size=71786.5

&gt;&gt;&gt; Using kernel from:          /boot/vmlinuz-2.6.31.13-server-1mnb
&gt;&gt; ls -l /etc/systemimager/boot/kernel
-rw-r--r-- 1 root root 2748752 Jul  1 16:02 /etc/systemimager/boot/kernel

Starting or re-starting rsync as a daemon.....
done!

This client is ready to have its image retrieved.  You must now run
the "si_getimage" command on your imageserver.

Your client has been successfully prepared.  Boot kernel (copied from
this Linux distribution) and an initrd.img (generated by the
initrd_template package) can be found in /etc/systemimager/boot.

Automatically create configuration file for systemconfigurator:
&gt;&gt; /etc/systemconfig/systemconfig.conf</pre>
Ici, le transport se fera par rsync, mais il est possible d'utiliser rsync over SSH, BitTorrent, <strong>multicast</strong>,...

Switchez sur votre serveur SystemImager et lancez le<em> si_getimage</em> qui va bien, avec<em> -golden-client </em>et image en entrée.

En optionnel, des options sur des exclusions, les assignements IP, le comportement postinstallation (reboot, beep, shutdown,...), bref, de quoi bien jouer.

Une fois l'image <strong>rapatriée</strong>, et mise au frais, <em>si_clusterconfig -e</em> pour organiser votre cluster -tel node va avec telle image, tel overrides,...

Pour la petite idée de ce à quoi ça ressemble :
<pre class="brush: bash">&lt;?xml version='1.0' standalone='yes'?&gt;
&lt;xml&gt;
&lt;master&gt;kaster&lt;/master&gt;
&lt;name&gt;absolutely_all_nodes&lt;/name&gt;
&lt;override&gt;override_for_absolutely_all_nodes&lt;/override&gt;
&lt;group&gt;
&lt;name&gt;kluster.knBSD.overBSD&lt;/name&gt;
&lt;priority&gt;1&lt;/priority&gt;
&lt;image&gt;knBSD&lt;/image&gt;
&lt;override&gt;overBSD&lt;/override&gt;
&lt;node&gt;knod1&lt;/node&gt;
&lt;/group&gt;
&lt;group&gt;
&lt;name&gt;kluster.kDeb.overDeb&lt;/name&gt;
&lt;priority&gt;2&lt;/priority&gt;
&lt;image&gt;kDeb&lt;/image&gt;
&lt;override&gt;overDeb&lt;/override&gt;
&lt;node&gt;knod2,knod3,knod4&lt;/node&gt;
&lt;/group&gt;
&lt;/xml&gt;</pre>
Tous vos nodes paramétrés bien comme il faut dans votre SystemImager, il ne vous reste plus qu'à forcer leur boot réseau avec <em>si_mkclientnetboot</em>...
<pre class="brush: bash">si_mkclientnetboot --client=knod2 --netboot
[netboot] using the kernel and initrd.img for architecture: i386
[netboot] using the flavor: standard</pre>
...Et de les rebooter en <strong>PXE</strong>.

<em>si_pushinstall</em> prend alors le contrôle des choses et le server va tout simplement redescendre par SSH, brute de force, l'image sur le node.
<h3>Les synchronisations</h3>
Evidemment, je vous avais parlé de SystemImager en tant qu'outil de déploiement d'OS, oui, mais de logiciel également.

En soi, le processus est le même, il s'agit d'une <strong>synchronisation </strong>-initiée par le serveur SystemImager à destination des nodes- entre l'image assignée au node et le système de fichier du node en lui-même. Ce qui diffère, ce sont les outils.
<h4>si_pushupdate</h4>
L'outil adapté à tout ce qui doit découler d'une mise à jour de l'image référente.

<em>si_pushupdate</em> va, ici via rsync, transférer tout ce qui manque du server aux nodes. Vu que c'est du rsync, la gestion de la bande passante est <strong>optimisée </strong>-on ne redescend pas absolument toute l'image-, malgré tout, le <strong>multicast </strong>est, à mon avis, beaucoup plus adapté à ce genre de redescente, surtout si vous avez beaucoup de node à mettre à jour.
<pre class="brush: bash">si_pushupdate --server kaster --hosts="knod2"
knod2 : ======================= WARNING =================================
knod2 :  This command will update this host with the image: kDeb
knod2 :  and overrides (in order of importance):
knod2 :
knod2 :  overDeb, override_for_absolutely_all_nodes
knod2 :
knod2 :  Some files could be deleted or overwritten, so probably it is a
knod2 :  good idea to run this command with --dry-run before and stop the
knod2 :  production on this host.
knod2 : ======================= WARNING =================================
knod2 :
knod2 : Are you sure to continue? (y / N)? y
knod2 : [...]
knod2 : Excluding (filesystem ext2): /tmp
knod2 : &gt;&gt; Updating image from module kDeb...
knod2 : receiving incremental file list
knod2 : deleting .readahead_collect
knod2 : sent 86986 bytes  received 23829894 bytes  621217.66 bytes/sec
knod2 : total size is 10895198915  speedup is 455.54
knod2 : &gt;&gt; Updating image from module overrides/override_for_absolutely_all_nodes...
knod2 : Running bootloader...Kernel /boot/...</pre>
<h4>si_pushoverrides</h4>
Comme son nom l'indique, il s'agit en réalité non pas d'aligner le node avec son image mais avec ses overrides.
<pre class="brush: bash">si_pushoverrides -v knod2
Building clients list...
Grouping clients by common overrides...
WARNING: in case of file overlaps the overrides will be distributed using the following order (first hit wins):
WARNING: --&gt;
Performing the updates...
&gt;&gt; si_pcp -v    -n knod2 /var/lib/systemimager/overrides/overDeb/ /
knod2 :/: sending incremental file list
[...]
knod2 :/: sent 898 bytes  received 203 bytes  734.00 bytes/sec
knod2 :/: total size is 2510  speedup is 2.28</pre>
<h3>Le monitoring</h3>
Monitorer un node revient, sous SystemImager, à se faire une idée d'où il en est au niveau de l'installation.

Pour cela, SystemImager exploite grandement <em>/var/lib/systemimager/clients.xml </em>et met à disposition 2 outils, l'un étant la version graphique de l'autre, il s'agit de <em>si_monitor</em> et <em>si_monitortk</em>.
<h2>Conclusion</h2>
SystemImager apporte donc une réponse simple, complète et très satisfaisante aux besoins d'<strong>automatisation </strong>d'installation et de déploiement.

De par ce fait, il est tout-à-fait dans la ligne de mire des exploitation en <strong>cluster</strong>, et se marie très bien avec des<strong> systèmes de répartition de charge</strong> dans des environnements de calcul, comme c'est le cas pour <strong>OSCAR</strong>, <strong>Torque</strong>, <strong>MAUI</strong>, et autres.

Attention toutefois, car même s'il correspond également au besoin d'uniformisation dans un parc constitué de postes de travail, il peut s'avérer que la synchronisation provoque des problèmes d'incohérence et d'instabilité au niveau de l'environnement graphique ou du noyau, selon ce qui a été mis à jour. Il est donc sage de l'utiliser avec parcimonie quand vous êtes en première ligne face à vos utilisateurs.

Il ne vous reste plus qu'à vous en faire une idée par vous-même, et, pourquoi pas, l'adopter !]]></content:encoded>
			<wfw:commentRss>http://www.k-tux.com/systemimager-concepts-dune-solution-dautomatisation-de-deploiement/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>TSM : Petite mise en bouche</title>
		<link>http://www.k-tux.com/tsm-petite-mise-en-bouche</link>
		<comments>http://www.k-tux.com/tsm-petite-mise-en-bouche#comments</comments>
		<pubDate>Thu, 08 Apr 2010 11:08:11 +0000</pubDate>
		<dc:creator>K-TUX</dc:creator>
				<category><![CDATA[Linux]]></category>
		<category><![CDATA[Sysadmin apps]]></category>
		<category><![CDATA[architecture]]></category>
		<category><![CDATA[backup]]></category>
		<category><![CDATA[data]]></category>
		<category><![CDATA[install]]></category>
		<category><![CDATA[planet-libre]]></category>
		<category><![CDATA[sécurité]]></category>
		<category><![CDATA[system]]></category>
		<category><![CDATA[TSM]]></category>

		<guid isPermaLink="false">http://www.k-tux.com/?p=584</guid>
		<description><![CDATA[Tivoli Storage Manager, de son petit nom TSM, compte parmi les plus puissantes architectures dédiées aux sauvegardes / stockage / restauration de données. Seulement voilà, non content d&#8217;être une technologie propriétaire, c&#8217;est en plus un gros morceau à gérer&#8230; Enfin &#8230; <a href="http://www.k-tux.com/tsm-petite-mise-en-bouche">Continue reading <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[Tivoli Storage Manager, de son petit nom <strong>TSM</strong>, compte parmi les plus puissantes architectures dédiées aux sauvegardes / stockage / restauration de données. Seulement voilà, non content d'être une technologie <strong>propriétaire</strong>, c'est en plus un gros morceau à gérer... Enfin du moins au début.
Ce billet a donc pour vocation de découvrir les premiers concepts qui se cachent sous TSM et de vous lancer dans l'apprivoisement de ce géant bourru.
<h2>Fonctionnement général</h2>
TSM fonctionne sur un mode <strong>Client/Serveur</strong>, c'est-à-dire que le serveur TSM se tient à la disposition des Clients, nos <strong>nodes</strong>, afin que les sauvegardes soient faites. Selon la manière dont la sauvegarde est effectuée, les rôles varient.
En effet, sur une sauvegarde faite manuellement, le node sollicite le serveur TSM et lui demande d'effectuer une tâche bien précise (sauvegarde ou restauration).
Lorsque la sauvegarde est <strong>automatisée</strong>, c'est le serveur TSM qui sollicite le node -via un <strong>scheduler</strong>- et qui va lui demander les données à sauvegarder. Le node endosse ainsi la fonction de serveur (en perpétuelle écoute de requête en provenance du serveur TSM).

Au sein de l'<strong>architecture</strong> TSM, un node se définit par rapport à d'autres entités, qui permettent notamment d'organiser et de paramétrer au plus fin les détails liés aux sauvegardes à faire. Logiquement, on a :
<ul>
	<li>Policy
<ul>
	<li>Domain
<ul>
	<li>CLOptSet (jeu d'options pour le domaine (INCLEXCL), optionnel)
<ul>
	<li>Schedule (planification des sauvegarde)
<ul>
	<li>Node (noeud à sauvegarder)</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
</ul>
<h2>Les mains dans le cambouillis</h2>
<h3>Sur de l'opérationnel</h3>
L'appel du terminal se fait par <em>dsmadmc</em>, qui, par défaut, ouvre une interface de commande avec le <strong>serveur</strong> TSM. Il est également possible de stipuler la commande sur la même ligne que <em>dsmadm</em>. Ainsi, <em>dsmadm</em> exécutera la commande, fermera l'invite de <strong>commande</strong> <em>tsm</em> et rendra le terminal à l'utilisateur.
Dans un système qui fonctionne, on peut interroger l'existant grâce à la commande <em>QUERY</em> -abrégée en q-
<em>QUERY</em> sert à rapporter un <strong>état</strong> précis du système, par exemple, l'état des processes qui tournent et s'il y en a (<em>q proc</em>), les associations existantes (<em>q association</em>)...
<pre class="brush: bash">tsm: TSMSERVER&gt;q policy

Policy        Policy        Default       Description
Domain        Set Name      Mgmt
Name                        Class
Name
---------     ---------     ---------     ------------------------
NDMP          ACTIVE        STANDARD
[...]

tsm: TSMSERVER&gt;q domain

Policy        Activated     Activated      Number of     Description
Domain        Policy        Default       Registered
Name          Set           Mgmt               Nodes
Class
---------     ---------     ---------     ----------     ------------------------
NIX          STANDARD      STANDARD             205     serveurs UNIX
[...]
tsm: TSMSERVER&gt;q sched
Domain           *     Schedule Name        Action     Start Date/Time          Duration     Period     Day
--
NIX                   Schedbux             Inc Bk     27-05-2008 00:00:00          8 H        1 D      Any
[...]</pre>
Ce qui revient à dire que, lorsque l'on arrive sur un système TSM tout frais, prêt à être installé, il faut donc créer et paramétrer tout le système.
<h3>Sur du tout neuf</h3>
Et bien, allons-y, recréons tout ça !
L'invite <em>dsmadmc</em> lancée, vous pouvez d'ores et déjà vous essayer à créer tout ce bazard. Et si vous bloquez sur une option, il existe une commande <em>help</em> qui, invoquée seule, vous énumérera l'ensemble des catégories qu'elle détient, et sinon, si vous savez sur quelle commande vous bloquez, il suffit de lancer <em>help &lt;commande&gt;</em> pour avoir accès à tout le descriptif, illustré d'exemple, de ladite commande. Alors pas de panique !
<h4 style="text-align: left;">Petit aperçu de comment faire...</h4>
<p style="text-align: left;"><!--more--></p>
<p style="text-align: left;">1. Créer un domaine, avec ou non son set d'option :</p>

<pre class="brush: bash">define domain domainname [...]
define cloptset cloptsetname [...]
define clientopt cloptsetname inclexcl "exclude.dir /tmp*"
[...]</pre>
2. Définir une policyset :
<pre class="brush: bash">define policyset domainname policysetname [...]</pre>
3. Définir sa mgmtclass ou utiliser celle par défaut (STANDARD)
<pre class="brush: bash">define mgmtclass domainname policysetname classname [...]</pre>
4. Assigner la mgmtclass définie (on peut utiliser celle par défaut en mentionnant <em>STANDARD</em> en lieu et place de <em>classname</em>) :
<pre class="brush: bash">assign defmgmtclass domainname policysetname classname [...]</pre>
5. Valider la policyset (il n'existe qu'une et une seule policyset activée à un instant donné) :
<pre class="brush: bash">validate policyset policysetname [...]
activate policyset policysetname [...]</pre>
6. Créer un schedule et fixer le schedule et les paramètres de sauvegarde pour le node :
<pre class="brush: bash">define sched domainname schedname nodename action=Incremental|[...voir help define sched] desc=\\\"description\\\" type=client scheds=classic startDate=11/25/2005 startTime=20:00:00 period=1 perunits=days priority=1 duration=8 durUnits=hours</pre>
7. Enregistrer le node dans le domaine, ainsi que ses paramètres de connexion au service :
<pre class="brush: bash">register node nodename nodepasswd passexp=0 contact=contact\@bux.fr domain=domainname cloptset=optionsetname forcepwreset=no url=http://nodename:1581</pre>
8. Définir l'association entre le domain, le schedule et le node :
<pre class="brush: bash">define association domainname schedulename nodename</pre>
9. Customiser le node :
<pre class="brush: bash">update node nodename [...]</pre>
Et lorsqu'on veut supprimer des nodes...

D'abord supprimer ses data :
<pre class="brush: bash">delete filespace nodename *</pre>
Et enfin supprimer le node :
<pre class="brush: bash">remove node nodename</pre>
En cas, supprimer le schedule, si on lui a attribué un schedule rien que pour lui :
<pre class="brush: bash">delete schedule domainname schedulename</pre>
Et oui, ce n'est pas de tout repos...<!--nextpage-->
<h3>La config</h3>
Les fichiers de configuration se situent généralement aux emplacements mentionnés, à savoir dans <em>/opt/tivoli</em>, mais il peut arriver que ce ne soit pas le cas. Si vous êtes dans ce genre de situation, un petit <em>find</em> vous fixera de suite sur la localisation de votre configuration.
<h4>Le client</h4>
Le client dispose de 2 fichiers relatifs à sa configuration : <em>dsm.opt</em> et <em>dsm.sys</em>, tous les 2 disponibles à l'emplacement <em>/opt/tivoli/tsm/client/ba/bin/</em>. <em>dsm.opt</em>, comme son extension laisse le supposer, précise les options utilisateur du client, tandis que <em>dsm.sys</em>, quant à lui, définit les options système du client. Par défaut, à l'installation, TSM met à disposition des samples permettant de comprendre et de paufiner les réglages client.

Voici quelques exemples :
<pre class="brush: bash"># cat /opt/tivoli/tsm/client/ba/bin/dsm.opt
SERVERNAME              TSMSERVER
DOMAIN                  /home
DATEFORMAT              3
ARCHSYMLINKASFILE       no

# cat /opt/tivoli/tsm/client/ba/bin/dsm.sys
SERVERNAME          TSMSERVER
NODENAME            tsmcli
COMMMETHOD          TCPIP
TCPPORT             1500
HTTPPORT            1581
TCPSERVERADDRESS    192.168.1.252
TCPNODELAY          YES
PASSWORDACCESS      GENERATE
COMMRESTARTDURATION 0
SCHEDLOGRETENTION   7 D
ERRORLOGRETENTION   7 D
SCHEDLOGNAME        /var/log/dsmsched.log
ERRORLOGNAME        /var/log/dsmerror.log
MAXCMDRETRIES       10
RETRYPERIOD         5
REVOKEREMOTEACCESS      ACCESS
SCHEDMODE           PROMPTED
MANAGEDSERVICES     schedule webclient
INCLUDE             /home/.../* DONNEES
EXCLUDE.DIR         /tmp</pre>
Il est possible d'avoir un bref <strong>aperçu</strong> de la configuration client en lançant en superutilisateur, la commande <em>dsmc query session</em>, qui vous rendra un <strong>output</strong> qui ressemble à peu près à ça :
<pre class="brush: bash"># dsmc query session
IBM Tivoli Storage Manager
Interface du client de sauvegarde/archivage en ligne de commande
Version client 5, Edition 5, Niveau 2.2
Date/heure client : 2010-04-10 11:00:19
(c) Copyright by IBM Corporation and other(s) 1990, 2009. All Rights Reserved.

Nom du poste : TSMClient
Session etablie avec le serveur SERVER1 : Linux/i386
Version serveur 5, edition 5, niveau 4.1
Date/heure serveur : 2010-04-10 10:57:37    Dernier acces : 2010-04-10 10:55:55

Informations sur la connexion au serveur TSM

Nom du serveur...........................: TSMSERVER
Type de serveur..........................: Linux/i386
Proteger la conservation de l'archivage..: "Non"
Version du serveur.......................: Ver. 5, Edi. 5, Niv. 4.1
Date du dernier acces....................: 2010-04-10 10:55:55
Supprimer les fichiers sauvegardes.......: "Non"
Supprimer les fichiers archives..........: "Oui"

Nom du poste client......................: TSMClient
Nom d'utilisateur........................: root</pre>
<h4>Le server</h4>
Le serveur dispose, de la même manière, d'un <em>dsmserver.opt</em>, par contre, pas de <em>dsmserv.sys</em>, tout du moins, dans mon installation. Du coup, tout le paramétrage du serveur se concentre dans un et un seul fichier de <em>conf</em>, dont voici un aperçu.
<pre class="brush: bash"># cat /opt/tivoli/tsm/server/bin/dsmserv.opt
* dsmserv.opt
COMMmethod TCPIP
COMMmethod HTTP
TCPPort 1500
TCPWindowsize 64
TCPNODELAY         YES
HTTPPort 1580
MSGINTerval 1
MAXSessions 400
LOGPoolsize 3072
TXNGroupmax 256
COMMTimeout 300
IDLETimeout 30
LANGuage en_US
DATEformat 1
TIMEformat 1
NUMberformat 1
EXPInterval  0
MIRRORREAD LOG NORMAL
MIRRORREAD DB  NORMAL
MIRRORWRITE LOG PARALLEL
MIRRORWRITE DB  SEQUENTIAL
VOLUMEHistory volhist.out
DEVCONFIG devconfig.out
MOVEBatchsize 1000
MOVESizethresh 500
USELARGEBUFFERS    YES
EVENTSERVer        YES
DISABLESCHEDS no
REQSYS Yes
ASSISTVCRRECOVERY  YES
QUERYAUTH NONE
DBPAGEShadow Yes
DBPAGESHADOWFILE dbpgshdw.bdt
DNSLOOKUP       NO
ALIASHALT bye
NOMIGRRECL
DIRECTIO YES

TXNGROUPMAX 1024
BUFPOOLSIZE 786432

IDLETIMEOUT 60
COMMTIMEOUT 300

MAXSESSIONS 400
* EOF</pre>
Votre premier choc : les commentaires sont marqués par une *. Dur. Enfin, vous êtes habitués, maintenant...
<h3>La WebI</h3>
Selon que l'on ait paramétré comme il faut son serveur TSM -flagez le paramètre <em>COMMmethod</em> et <em>HTTPPort</em>-, il est possible de faire en sorte que l'utilisateur puisse accéder facilement à ses sauvegardes TSM sans avoir à se débattre avec <em>dsmadmc</em>, et ceci, en passant par l'interface <strong>Web</strong> du node.
Ainsi, les données engrangées par notre serveur seront disponibles simplement à l'adresse <em>http://nodename:1581</em>.
Petit bémol, pensez que c'est une applet <strong>JAVA</strong>, par conséquent, vérifiez tout de même que vous faites bien tourner le JDK de Sun avant de vous lancer dans la grande aventure.
<h2>Conclusion</h2>
Voila !
Fin de l'introduction, qui, quoiqu'un peu massive, donne un aperçu bien ciselé de TSM.
Pour les plus curieux, la documentation est très présente, et il vaut mieux, car TSM est un produit propriétaire bien coûteux, mais qui peut valoir l'investissement, s'il est couplé avec la <strong>IBM Tape Library</strong>.

Ce point rajoute d'ailleurs encore aux commandes à savoir manier, car la gestion des bandes est plus rapide via un terminal type <em>dsmadmc</em> que via une interface web. Enfin, à ce niveau-là, nous ne sommes plus en introduction.

Les aides officielles / non officielles qui aident bien :
<ul>
	<li><a href="http://www-947.ibm.com/support/entry/portal/Overview/Software/Tivoli/Tivoli_Storage_Manager" target="_blank">http://www-947.ibm.com/support/entry/portal/Overview/Software/Tivoli/Tivoli_Storage_Manager</a></li>
	<li><a href="http://www.adsm.org/" target="_blank"> http://www.adsm.org/</a></li>
	<li><a href="http://unixadmin.free.fr/htdocs/modules/newbb/viewtopic.php?post_id=10" target="_blank"> http://unixadmin.free.fr/htdocs/modules/newbb/viewtopic.php?post_id=10</a></li>
</ul>]]></content:encoded>
			<wfw:commentRss>http://www.k-tux.com/tsm-petite-mise-en-bouche/feed</wfw:commentRss>
		<slash:comments>3</slash:comments>
		</item>
		<item>
		<title>GPU joins the game : quick intro to Cuda and OpenCL</title>
		<link>http://www.k-tux.com/gpu-joins-the-game-quick-intro-to-cuda-and-opencl</link>
		<comments>http://www.k-tux.com/gpu-joins-the-game-quick-intro-to-cuda-and-opencl#comments</comments>
		<pubDate>Fri, 19 Feb 2010 21:49:23 +0000</pubDate>
		<dc:creator>K-TUX</dc:creator>
				<category><![CDATA[Linux]]></category>
		<category><![CDATA[User apps]]></category>
		<category><![CDATA[Windows]]></category>
		<category><![CDATA[WUser apps]]></category>
		<category><![CDATA[architecture]]></category>
		<category><![CDATA[conception]]></category>
		<category><![CDATA[graphic]]></category>
		<category><![CDATA[planet-libre]]></category>

		<guid isPermaLink="false">http://www.k-tux.com/?p=513</guid>
		<description><![CDATA[C&#8217;est dit, c&#8217;était déjà sur la sellette, et maintenant c&#8217;est en train de grandir, DEVINEZ QUOI !!! Vous qui pensiez que le CPU était le cerveau véritable de votre superbe étalon watercooled qui ronronne dans votre bureau / salle des &#8230; <a href="http://www.k-tux.com/gpu-joins-the-game-quick-intro-to-cuda-and-opencl">Continue reading <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[C'est dit, c'était déjà sur la sellette, et maintenant c'est en train de grandir, DEVINEZ QUOI !!!

Vous qui pensiez que le <strong>CPU </strong>était le cerveau véritable de votre superbe étalon watercooled qui ronronne dans votre bureau / salle des serveurs !

Vous qui vous êtes laissé emporté par les sirènes des commerciaux qui vendent toujours plus de <strong>core</strong>, toujours plus cher, sans jamais assurer quoi que ce soit en cas d'explosion impromptue, voici pour vous l'occasion d'effectuer un 280 et, par la même occasion, de pouvoir tester encore, et encore !!!
<h2>Utilisez votre GPU bon sang !!!</h2>
Ce n'est pas une idée nouvelle. Elle nous vient de ces maniaques à demi-fous qui planchent sur des phrases aux lettres incompréhensibles et sur des équations qui ressemblent à la vie.

Des besoins immenses et toujours plus importants en puissance de calcul, harcelant nuit et jour l'ASR, toujours en quête de <strong>ressources</strong>, ils se sont vite résignés à trouver une autre solution après avoir constaté (<strong>Moore </strong>?) que l'empilage des CPU ne mène nulle part.

Et ils ont trouvé autre chose, quelque chose de plus puissant et  surtout, de plus disponible ! Pensez donc à la fabuleuse évolution des PC, qui sont passés du statut froid et vide de <strong>terminaux </strong>de travail à un divertissement majeur largement répandu.

L'apparition de jeux de plus en plus sophistiqués notamment amène une <strong>évolution </strong>flagrante au niveau des équipements directement mis en cause, et la carte graphique est au centre de toutes les préoccupations.

<h3>Cuda, technologie propriétaire NVidia</h3>
<a href="http://www.nvidia.fr/object/cuda_home_new_fr.html" target="_blank">Cuda</a> est une technologie qui permet de tirer parti de manière drastique des capacités du <strong>GPU</strong>. C'est un outil qui s'articule autour de l'installation de 3 packages, les pilotes, le SDK et les toolkits / exemples.

Elle amène pas mal de contraintes, notamment concernant les conflits que les <strong>pilotes </strong>peuvent entraîner avec ceux déjà présents sur la machine, ce qui nécessite notamment de redémarrer la machine sous environnement texte, et de se palucher les tests de configurations, debout devant la machine. Pire, et c'est un inconvénient majeur, elle est <strong>propriétaire</strong>.
<h3>OpenCL, la petite soeur de Khronos</h3>
Très belle initiative des grands de ces monde, d'ailleurs également à l'origine <a href="http://www.opengl.org/" target="_blank&quot;">d'OpenGL</a>, <a href="http://www.khronos.org/opencl/" target="_blank">OpenCL</a> s'inscrit dans les mêmes lignes, à ceci près que c'est une technologie <strong>OpenSource</strong>.

Elle est donc vouée à très vite se développer, à être optimisée, et sûrement à être <strong>intégrée </strong>dans les distributions -voir même à avoir la sienne, dédiée. Déjà une version 1.0, à suivre de très près donc ! Enfin, pour ceux qui aiment les gros calculs !
<h3>Le CPU, ce n'est plus ce que c'était...</h3>
Et ce n'est pas une histoire de puissance, mais plutôt, de <strong>système réparti</strong>. Car oui, l'Ère de la Centralisation a bel et bien touché à son terme, et ce, depuis l'apparition d'Internet et des <strong>architectures n-tiers</strong>.

Et bientôt ce mouvement s'étendra à votre pc -votre <strong>CPU</strong>- qui apprendra, et c'est sûrement déjà le cas, à <strong>distribuer </strong>les tâches à ses petits copains et non plus tout se garder pour lui et finir par en avaler trop.

Ah, c'est beau...]]></content:encoded>
			<wfw:commentRss>http://www.k-tux.com/gpu-joins-the-game-quick-intro-to-cuda-and-opencl/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Marionnet : conception et tests d&#8217;infrastructure réseau</title>
		<link>http://www.k-tux.com/marionnet-conception-et-tests-dinfrastructure-reseau</link>
		<comments>http://www.k-tux.com/marionnet-conception-et-tests-dinfrastructure-reseau#comments</comments>
		<pubDate>Wed, 20 Jan 2010 21:22:20 +0000</pubDate>
		<dc:creator>K-TUX</dc:creator>
				<category><![CDATA[Linux]]></category>
		<category><![CDATA[Sysadmin apps]]></category>
		<category><![CDATA[architecture]]></category>
		<category><![CDATA[conception]]></category>
		<category><![CDATA[network]]></category>
		<category><![CDATA[opensrc]]></category>
		<category><![CDATA[planet-libre]]></category>
		<category><![CDATA[port]]></category>
		<category><![CDATA[theory]]></category>
		<category><![CDATA[UML]]></category>
		<category><![CDATA[virtualisation]]></category>

		<guid isPermaLink="false">http://www.k-tux.com/?p=449</guid>
		<description><![CDATA[Connaissez-vous Marionnet ? Non ? Et bien voilà, c&#8217;est l&#8217;occasion ! Marionnet est un simulateur d&#8217;architecture réseau. Il permet aux novices qui aimeraient s&#8217;y coller -mais qui n&#8217;ont pas les autorisations ou le matériel requis- de se familiariser avec toutes &#8230; <a href="http://www.k-tux.com/marionnet-conception-et-tests-dinfrastructure-reseau">Continue reading <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[Connaissez-vous <strong>Marionnet </strong>?

Non ? Et bien voilà, c'est l'occasion !

Marionnet est un <strong>simulateur </strong>d'architecture réseau. Il permet aux novices qui aimeraient s'y coller -mais qui n'ont pas les autorisations ou le matériel requis- de se familiariser avec toutes les problématiques que vous, ASR, rencontrez lorsque vous arrivez dans un chaos de réseau à l'ancienne et qu'il faut tout casser pour tout reconstruire. Et intelligemment.

Marionnet met à disposition des <strong>objets </strong>-switches, routers, hosts, ...- que vous pouvez alors organiser et structurer dans l'espace, dont vous pouvez analyser les processes en cours -par exemple sous les hosts- et vérifier que tout fonctionne avant justement de tout casser, de tout remettre, et de s'apercevoir que ça ne fonctionne pas -Diantre !

Marionnet est un projet qui s'inscrit donc plus dans un contexte d'enseignement, et fonctionne grâce au <strong>User Mode Linux</strong>, fonctionnalité des noyaux récents Linux (oui, le projet tourne sur du Linux, mais continuez à lire, vous serez agréablement surpris). UML permet notamment de lancer un ou plusieurs noyaux Linux comme s'il ne s'agissait que d'applications toutes simples.

Le projet est disponible soit en sources -./configure; make &amp;&amp; make install, enfin, vous connaissez la chanson-, soit via un <strong>LiveCD</strong>, et tout ça, sur le <a href="http://www.marionnet.org/" target="_blank">site officiel</a>.

Voilà ! Avec ça, les DSI n'auront plus d'excuse pour vous enlever tout le fun de la conception d'une architecture !]]></content:encoded>
			<wfw:commentRss>http://www.k-tux.com/marionnet-conception-et-tests-dinfrastructure-reseau/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Cfengine, cet outil qui facilite la vie des ASR&#8230;</title>
		<link>http://www.k-tux.com/cfengine-cet-outil-qui-facilite-la-vie-des-asr</link>
		<comments>http://www.k-tux.com/cfengine-cet-outil-qui-facilite-la-vie-des-asr#comments</comments>
		<pubDate>Sun, 17 Jan 2010 18:47:41 +0000</pubDate>
		<dc:creator>K-TUX</dc:creator>
				<category><![CDATA[Linux]]></category>
		<category><![CDATA[Sysadmin apps]]></category>
		<category><![CDATA[Windows]]></category>
		<category><![CDATA[WSysadmin apps]]></category>
		<category><![CDATA[architecture]]></category>
		<category><![CDATA[backup]]></category>
		<category><![CDATA[conf]]></category>
		<category><![CDATA[data]]></category>
		<category><![CDATA[key]]></category>
		<category><![CDATA[planet-libre]]></category>
		<category><![CDATA[remote]]></category>
		<category><![CDATA[sécurité]]></category>
		<category><![CDATA[system]]></category>

		<guid isPermaLink="false">http://www.k-tux.com/?p=403</guid>
		<description><![CDATA[Une grande partie de l&#8217;activité d&#8217;un Administrateur Système consiste à suivre, à bichonner, à soigner et à updater ses serveurs. Certains ont choisi de le faire manuellement, comme sur une bonne vieille architecture constituée d&#8217;une poignée de serveurs. Sachez qu&#8217;il &#8230; <a href="http://www.k-tux.com/cfengine-cet-outil-qui-facilite-la-vie-des-asr">Continue reading <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[Une grande partie de l'<strong>activité </strong>d'un Administrateur Système consiste à suivre, à bichonner, à soigner et à updater ses serveurs.

Certains ont choisi de le faire manuellement, comme sur une bonne vieille <strong>architecture </strong>constituée d'une poignée de serveurs.

Sachez qu'il existe plusieurs moyens de s'en dispenser, pas totalement, mais suffisamment pour pouvoir se dégager du temps libre et donc attaquer des activités à plus forte plus-value et plus intéressantes.

<strong>Cfengine </strong>est un puissant outil qui permet de s'affranchir des contraintes machinales dues à un parc de serveurs dépassant en nombre notre enjouement à passer tout bien tout comme il faut manuellement et unitairement. Le but du jeu étant de centraliser et d'organiser les traitements selon des classes d'objet.

Cfengine fonctionne en utilisant<strong> TCP/IP</strong> (port 5308 tcp/udp) et les outils libres, en mode client / serveur, et dont les principaux acteurs sont :
<ul>
	<li>Sur le client :
<ul>
	<li>cf-agent,  process client, qui va analyser et traiter les différentes configurations, on peut l'apparenter à un interpréteur,</li>
	<li>cf-execd, un process scheduler,</li>
	<li>cf-runagent, un outil qui permet de déclencher manuellement les traitements et de solliciter des hosts précis,</li>
</ul>
</li>
	<li>Sur le serveur :
<ul>
	<li>cf-servd, process serveur, qui a la responsabilité du partage des fichiers,</li>
	<li>cf-key, le process permettant de sécuriser un minimum les flus de données, qui fonctionne à la manière du keygen d'OpenSSH.</li>
</ul>
</li>
</ul>
La <strong>version 3</strong> est implémentée à l'heure où j'écris ces lignes, c'est donc sur elle que je vais baser mon article.
<p style="text-align: left;">Mais avant cela, pourquoi dois-je choisir entre les versions ? Et bien parce que la dernière version amène un schisme au niveau du langage utilisé par Cfengine. Malgré tout, la Communauté a fait les choses intelligemment en faisant collaborer les binaires de <strong>Cfengine 2</strong> et ceux de <strong>Cfengine 3</strong>.</p>
<p style="text-align: left;">On peut donc sans soucis utiliser la version 2 de cfservd avec les versions 3 de cf-agent. C'est ce qu'on appelle être <strong>run-time compatible</strong>.</p>
<p style="text-align: left;">Pour analyser la version 3, il est donc nécessaire de  détailler un peu le fonctionnement sous la version 2, et c'est ce que nous allons faire.</p>
<p style="text-align: left;"><!--more--></p>

<h2 style="text-align: left;">En version 2, ça se passait comment déjà ?</h2>
<p style="text-align: left;">En version 2, l'installation construit l'outil, génère un couple de clés grâce à <strong>cfkey</strong>, et stocke tout ça dans <em>/var/cfengine/ppkeys</em>. Notez bien au passage que le répertoire <strong>important </strong>qui contient pratiquement tout ce qui est intéressant est justement situé sous <em>/var/cfengine/</em>.</p>
Notamment concernant <em>/var/cfengine/inputs/</em>, qui contient tous les fichiers de <strong>configuration</strong>, par défaut et customisés, que vous serez amené à éditer. On y trouve donc :
<ul>
	<li><em>cfagent.conf</em>, le fichier de conf de l'agent,</li>
	<li><em>update.conf</em>, lu avant<em> cfagent.conf</em> et chargé, comme son nom l'indique, de rapatrier les mises à jour de configuration,</li>
	<li><em>cfservd.conf</em>, notre configuration de serveur. Utile surtout pour encadrer correctement les droits d'accès de certains serveurs sur certains répertoires,</li>
	<li><em>cfrun.conf</em>, un listing des serveurs à joindre en cas d'utilisation de <em>cfrun</em>.</li>
</ul>
Ce qu'il est important de savoir, c'est que vous n'êtes pas tenu de bourrer de suite toutes vos <strong>règles </strong>dans <em>cfagent.conf</em>, mais vous pouvez, à volonté, utiliser autant de fichier de configuration que vous le voulez, grouper certaines règles en fonction de vos <strong>critères</strong>. Au contraire cela ne fera que vous faciliter un peu plus le boulot.

Il est également intéressant de préciser que Cfengine adopte un comportement de <strong>non surcharge</strong> des ressources. Ainsi, les boucles infernales de commandes sont évitées, et un délai aléatoire est introduit pour éviter que toutes les requêtes ne convergent et viennent s'étrangler sur notre serveur.

Les fichiers de configuration sont donc au cœur de Cfengine et leur <strong>skeleton </strong>n'est pas crée par défaut à l'installation. Un fichier de configuration typique est structuré tel quel :
<pre class="brush: bash">section1 :
classe1::
directives11
section2 :
classe1::
directives21
classe2::
directives22</pre>
Il peut contenir en lui-même plusieurs <strong>sections </strong>distinctes.
<h3>Les sections.</h3>
Les sections constituent le moteur même de Cfengine. On peut diviser les sections en 2 catégories : celles qui vont <strong>moduler </strong>le comportement de Cfengine, et celles qui, à proprement parler, vont faire tout le boulot.
<h3>Les classes.</h3>
Elles servent à cibler les <strong>conditions </strong>qui déclencheront les actions à entreprendre. La plupart des classes sont prédéfinies mais il est possible d'en créer de nouvelles. Elles peuvent concerner très spécifiquement une <strong>configuration </strong>donnée, à un temps t, comme l'OS, la date, la distribution, l'architecture (32 bits, 64bits), on parle alors de <strong>hard classes</strong>, ou être beaucoup plus abstraites, ce sont alors des <strong>evaluated classes</strong>. La troisième catégorie contient les classes que nous, administrateurs, nous allons définir. Notez également l'existence d'une hard classe <em>any</em>, qui regroupe toute machine, quel qu'elle soit.

Le fonctionnement est simple. <strong>Cfagent </strong>détecte que c'est l'heure à laquelle il doit déclencher un traitement. Avant toute chose, il va chercher sur notre <strong>serveur </strong>-le <em>policy host</em>- via <em>update.conf</em> la version à jour, s'il y en a une, de <em>cfagent.conf</em>. En cas d'impossibilité de joindre le serveur, il se basera alors sur celui dont il dispose en local. Les traitements seront alors fait selon ce qui est écrit dans ce <em>cfagent.conf</em>. C'est une <strong>stratégie </strong>de pull, c'est-à-dire que le client est autonome et c'est lui qui sollicite le serveur. Et, bien sûr, pour plus de fun, tout cela est à votre charge !

Petit exemple de<em> cfservd.conf</em> :
<pre class="brush: bash">################################################################
#
# cfservd.conf
#
################################################################
control:
   domain = ( k-tux.com )
   AllowConnectionsFrom = ( 192.168.0 )
   TrustKeysFrom = ( 192.168.0 )
   Access = ( root kbux )

# Variables internes, pour faciliter les choses.
   cfrunCommand = ( "/usr/local/sbin/cfagent" )

# Utile pour que 'cfrun' sache ce qu'il a à faire...
grant:
   any::
      /usr/local/sbin   $(policyhost)

   policyhost::
      /var/cfengine/inputs   *.k-tux.com

# Sans cette spécification-là, c'est l'action 'copy' de 'update.conf'
# qui ferait une erreur
# EOF cfservd.conf.</pre>
Petit exemple de cfagent.conf.
<pre class="brush: bash">################################################################
#
# cfagent.conf basique, tout juste fonctionnel.
#
################################################################
control:
   domain  = ( k-tux.com )
   actionsequence = ( shellcommands )

shellcommands:
   "/bin/echo cfagent OK"

# Dans un premier temps, cela suffit !
# En effet, cfagent requiert essentiellement la présence d'une
# 'actionsequence' dans son fichier de conf'.
#
# EOF cfagent.conf.</pre>
Petit exemple d'<em>update.conf</em>.
<pre class="brush: bash">##############################################################
#
# Ceci est le fichier update.conf, simple et fonctionnel,
# servant à tenir à jour tous les fichiers de conf,
# (soit l'intégralité du répertoire /var/cfengine/inputs)
# sur les machines locales.
# En tout état de cause, le garder simple et fonctionnel !
#
##############################################################
control:
   domain = ( k-tux.com )
   actionsequence = ( copy )

# En fait, l'action 'copy' sera utilisé ici pour 'update',
# mais comme cette dernière n'existe pas...
# De toute façon, basiquement, c'est bien une copie de fichiers que l'on demande.
   policyhost = ( policyhost )
   masterdir = ( /var/cfengine/inputs )
   localdir = ( /var/cfengine )

# Bien entendu, 'policyhost' existe dans le fichier /etc/hosts de la machine locale.
# En-dehors de ça, nous venons de déclarer nos propres variables.
# Elles ne tarderons pas à servir...
copy:
   !policyhost::

# Inutile de spécifier une classe, 'any' ou autre,
# car nous voulons que TOUS les hôtes soient à jour de leurs fichiers de conf...
# Tous, sauf le ‘policyhost’, bien sûr
# Précédée du signe '!', toute machine ou classe de machine sera
# exclue de l'action entreprise.
      $(masterdir)   dest=$(localdir)/inputs

# L'action 'copy' est structurée de cette façon.
# L'usage de l'espace autour de la source et de la destination est libre,
# mais pas d'espace à l'intérieur de celles-ci.
# Règle d'or : si la source est un fichier, la destination doit être un fichier.
# Ici, la source est un répertoire, la destination doit en être un aussi.
# Tout ce que contient l'un sera copié dans l'autre.
                     server=$(policyhost)
                     r=inf

# Option obligatoire car copie de répertoire.'r' pour récursif
# (peut également s'écrire 'recurse'). 'inf' pour niveau maximum de récursivité,
                     purge=true

# Sans cette option, 'copy' générerait des fichiers *.cfsaved
# dans le répertoire de destination.
# Ici, nous obtiendrons une réplication exacte et fidèle du répertoire source, sans plus.
                     type=binary

# Le fichier 'dest' sera comparé bit à bit à son homologue source.
                     mode=644

# Là, 'copy' se "contente" de vérifier les permissions d'accès des fichiers
# présents dans $(localdir)/inputs, et de corriger le tir en cas de besoin.
                     trustkey=true

# Le point sensible.
# Ici, nous voulons que $(policyhost) fasse confiance à la machine locale,
# et accepte sa clef publique lors du premier contact entre les deux hôtes.
# Cela nous évitera d'avoir à faire cette échange de clefs manuellement,
# mais bien évidemment nous créons ainsi une petite faille de sécurité...
#
# EOF update.conf.</pre>
<!--nextpage-->
<h2>En version 3, ce n'est plus pareil alors ?</h2>
Presque ! On peut voir déjà une subtile différence au niveau du nom des binaires, cf-servd au lieu de cfservd, cf-agent au lieu de cfagent,... Mais vous me direz, et vous n'avez pas tort, que ce ne sont que des détails.

D'abord, un petit état des lieux. Voici, après installation, ce qui vous a bourgeonné sur le <strong>filesystem</strong>. Notez en passant que Cfengine tourne sous <em>root </em>par défaut, mais il est possible de changer ce comportement en retouchant un peu le fichier de configuration du serveur. Toutefois, gardez à l'esprit qu'il lui faut certains <strong>privilèges </strong>pour pouvoir fonctionner normalement.
<pre class="brush: bash">[kbux@policyhost cfengine]$ ls -lsa /var/lib/cfengine/
total 80
4 drwxr-xr-x 13 root root 4096 2010-01-13 11:43 ./
4 drwxr-xr-x 31 root root 4096 2010-01-12 12:44 ../
4 drwxr-xr-x  2 root root 4096 2010-01-12 12:44 bin/
4 -rw-------  1 root root 1252 2010-01-13 11:43 cf3.localhost.runlog
8 -rw-------  1 root root 8192 2010-01-13 11:43 cfengine_lock_db
4 -rw-------  1 root root    5 2010-01-13 11:43 cf-execd.pid
4 -rw-------  1 root root    5 2010-01-13 11:43 cf-monitor.pid
4 -rw-------  1 root root    5 2010-01-13 11:43 cf-serverd.pid
0 lrwxrwxrwx  1 root root   21 2010-01-12 12:44 inputs -&gt; ../../../etc/cfengine/
4 drwxr-xr-x  2 root root 4096 2009-08-23 21:03 lastseen/
4 drwxr-xr-x  2 root root 4096 2009-08-23 21:03 modules/
4 drwxr-xr-x  2 root root 4096 2010-01-13 11:45 outputs/
4 drwx------  2 root root 4096 2010-01-12 12:45 ppkeys/
4 -rw-------  1 root root  185 2010-01-13 11:18 promise.log
4 drw-r--r--  2 root root 4096 2009-08-23 21:03 randseed/
4 drwxr-xr-x  2 root root 4096 2009-08-23 21:03 reports/
4 drwx------  2 root root 4096 2009-08-23 21:03 rpc_in/
4 drwx------  2 root root 4096 2009-08-23 21:03 rpc_out/
4 drwxr-xr-x  2 root root 4096 2009-08-23 21:03 rpc_state/
4 drwxr-xr-x  2 root root 4096 2010-01-13 11:43 state/

[kbux@policyhost cfengine]# ls -lsa /usr/sbin/cf*
72 -rwxr-xr-x 1 root root 72008 2009-08-23 21:03 /usr/sbin/cf-agent*
60 -rwxr-xr-x 1 root root 60256 2009-10-14 18:54 /usr/sbin/cfdisk*
32 -rwxr-xr-x 1 root root 30896 2009-08-23 21:03 /usr/sbin/cf-execd*
12 -rwxr-xr-x 1 root root 10116 2009-08-23 21:03 /usr/sbin/cf-key*
80 -rwxr-xr-x 1 root root 79908 2009-08-23 21:03 /usr/sbin/cf-know*
52 -rwxr-xr-x 1 root root 51272 2009-08-23 21:03 /usr/sbin/cf-monitord*
12 -rwxr-xr-x 1 root root  9960 2009-08-23 21:03 /usr/sbin/cf-promises*
56 -rwxr-xr-x 1 root root 55700 2009-08-23 21:03 /usr/sbin/cf-report*
20 -rwxr-xr-x 1 root root 18244 2009-08-23 21:03 /usr/sbin/cf-runagent*
76 -rwxr-xr-x 1 root root 76160 2009-08-23 21:03 /usr/sbin/cf-serverd*

[kbux@policyhost cfengine]$ ls -lsa /etc/cfengine/
total 32
4 drwxr-xr-x  2 root root 4096 2010-01-12 12:44 ./
4 drwxr-xr-x 91 root root 4096 2010-01-12 12:45 ../
4 -rw-r--r--  1 root root  204 2009-08-23 21:03 failsafe.cf
4 -rw-r--r--  1 root root 2518 2009-08-23 21:03 library.cf
4 -rw-r--r--  1 root root 1898 2009-08-23 21:03 promises.cf
8 -rw-r--r--  1 root root 6006 2009-08-23 21:03 site.cf
4 -rw-r--r--  1 root root  971 2009-08-23 21:03 update.cf

[kbux@policyhost cfengine]$ grep cfengine /etc/services
cfengine        5308/tcp                        # CFengine
cfengine        5308/udp                        # CFengine</pre>
Les <strong>éléments </strong>importants se situent au niveau de <em>/var/lib/cfengine</em>, ce sont les répertoires <em>inputs</em>, <em>outputs </em>et <em>bin</em>.
<ul>
	<li><em>Inputs </em>servira de <strong>référence</strong> pour ce qui est de passer les paramètres aux <em>cf-agents</em>, il faut donc faire en sorte que ce répertoire soit copié et <strong>maintenu </strong>à jour fréquemment par toutes les machines concernées. Vu que dans l'installation, le répertoire est en fait un lien symbolique vers<em> /etc/cfengine</em>, nous retrouvons dedans les 5 fichiers <em>*.cf</em>.</li>
	<li><em>Outputs </em>sert de conteneur de <strong>reports </strong>qui peuvent alors être entreposés et mailés via <em>cf-execd,</em> si on le souhaite.</li>
	<li><em>Bin</em>, en revanche, ne contient qu'un lien symbolique vers le binaire<em> /usr/sbin/cf-promises</em>.</li>
</ul>
Finalement, on retrouve une arborescence tout à fait comparable à celle de cfengine 2. Et oui, car la majeure différence en version 3 est palpable au niveau du <strong>langage </strong>en lui-même, ce qui amène à une réorganisation complète de la <strong>structure interne</strong> aux fichiers de configuration. Par ailleurs, de nouveaux composants se sont rajoutés et on nous parle de <strong>promises </strong>(oui, c'est de l'anglais).

Les <em>promises </em>synthétisent les états que l'on veut maintenir, autrement dit, ce sont vos fichiers de configuration. D'ailleurs, tout ce qui concerne leur gestion, vérification, tout cela dépend de <em>cf-promises</em>. Par exemple, pour vérifier que votre<em> test.cf</em> est correct, rien ne vaut un
<pre class="brush: bash">[kbux@policyhost cfengine]# cf-promises -v -f /var/lib/cfengine/inputs/test.cf
cf3 Cfengine - autonomous configuration engine - commence self-diagnostic prelude
cf3 ------------------------------------------------------------------------
cf3 Work directory is /var/lib/cfengine
cf3 cf3: INFO: /var/lib/cfengine/inputs is a symbolic link, not a true directory!
cf3 Making sure that locks are private...
cf3 Checking integrity of the state database
cf3 Checking integrity of the module directory
cf3 Checking integrity of the input data for RPC
cf3 Checking integrity of the output data for RPC
cf3 Checking integrity of the PKI directory
cf3 Looking for a source of entropy in /var/lib/cfengine/randseed
cf3 Could not read sufficient randomness from /var/lib/cfengine/randseed
cf3 Loaded /var/lib/cfengine/ppkeys/localhost.priv
cf3 Loaded /var/lib/cfengine/ppkeys/localhost.pub
cf3 Setting cfengine default port to 5308 = 5308
cf3 Reference time set to Sun Jan 17 11:48:27 2010
cf3 Cfengine - 3.0.2 (C) Cfengine AS 2008-
cf3 ------------------------------------------------------------------------
cf3 Host name is: policyhost
cf3 Operating System Type is linux
cf3 Operating System Release is 2.6.31.5-desktop-1mnb
cf3 Architecture = i686
cf3 Using internal soft-class linux for host localhost
cf3 The time is now Sun Jan 17 11:48:27 2010
cf3 ------------------------------------------------------------------------
cf3 # Extended system discovery is only available in version Nova and above
cf3 Additional hard class defined as: 32_bit
cf3 Additional hard class defined as: linux_2_6_31_5_desktop_1mnb
cf3 Additional hard class defined as: linux_i686
cf3 Additional hard class defined as: linux_i686_2_6_31_5_desktop_1mnb
cf3 GNU autoconf class from compile time: compiled_on_linux_gnu
cf3 Address given by nameserver: 127.0.0.1
cf3 Interface 1: lo
cf3 Interface 2: eth0
cf3 Trying to locate my IPv6 address
cf3 Found IPv6 address inet6:
cf3 Found IPv6 address fe80::a00:27ff:fe24:ef9f
cf3 Found IPv6 address inet6:
cf3 Looking for environment from cf-monitor...
cf3 Loading environment...
cf3 Environment data loaded
cf3 This appears to be a mandriva system.
cf3 Looking for Mandriva linux info in "Mandriva Linux release 2010.0 (Official) for i586
"
cf3 This appears to be a LSB compliant system.
cf3 ***********************************************************
cf3  Loading persistent classes
cf3 ***********************************************************
cf3 ***********************************************************
cf3  Loaded persistent memory
cf3 ***********************************************************
cf3   &gt; Parsing file /var/lib/cfengine/inputs/test.cf
cf3 Initiate variable convergence...
cf3 Initiate variable convergence...
cf3 # Knowledge map reporting feature is only available in version Nova and above
cf3  -&gt; Defined hard classes = { any verbose_mode Sunday Hr11 Morning Min48 Min45_50 Q4 Hr11_Q4 Day17 January Yr2010 Lcycle_0 GMT_Hr10 linux localhost undefined_domain 32_bit linux_2_6_31_5_desktop_1mnb i686 linux_i686 linux_i686_2_6_31_5_desktop_1mnb linux_i686_2_6_31_5_desktop_1mnb__1_SMP_Fri_Oct_23_01_46_54_EDT_2009 compiled_on_linux_gnu net_iface_lo net_iface_eth0 ipv4_10_0_2_15 ipv4_10_0_2 ipv4_10_0 ipv4_10 inet6_ fe80__a00_27ff_fe24_ef9f rootprocs_high_normal syslog_low_normal messages_low_normal entropy_netbiosns_in_low entropy_netbiosdgm_in_low entropy_netbiosssn_in_low entropy_irc_in_low entropy_cfengine_in_low entropy_nfsd_in_low entropy_smtp_in_low entropy_www_in_low entropy_ftp_in_low entropy_ssh_in_low entropy_wwws_in_low entropy_netbiosns_out_low entropy_netbiosdgm_out_low entropy_netbiosssn_out_low entropy_irc_out_low entropy_cfengine_out_low entropy_nfsd_out_low entropy_smtp_out_low entropy_ftp_out_low entropy_ssh_out_low entropy_icmp_in_low entropy_udp_in_low entropy_dns_in_low entropy_tcpsyn_in_low entropy_tcpack_in_low entropy_tcpfin_in_low entropy_misc_in_low entropy_icmp_out_low entropy_udp_out_low entropy_dns_out_low entropy_tcpsyn_out_low entropy_tcpack_out_low entropy_tcpfin_out_low entropy_misc_out_low cfengine_3_0_2 cfengine_3_0 cfengine_3 Mandrake Mandriva mandriva mandriva_2010 mandriva_2010_0 lsb_compliant mandrivalinux mandrivalinux_adelie mandrivalinux_2010_0 mandrivalinux_2010 common }
cf3  -&gt; Negated Classes = { }
cf3 Initiate variable convergence...
cf3 Initiate control variable convergence...
cf3 Inputs are valid</pre>
Le <em>-v</em> vous inonde d'informations. Ne vous perdez pas, seule la dernière ligne compte, puisqu'elle vous indique explicitement que votre configuration est valide.

Mais alors, comment faire votre <em>cf</em>, à proprement parler ? Et bien, comme vous avez pu lire, il faut d'abord revenir sur notre bon vieux concept concernant le composant central de Cfengine : les <strong>classes</strong>.

Les classes sont toujours présentes et organisées en 2 grandes familles, les hard et les soft, dont on peut d'ailleurs facilement en avoir la liste avec un <em>cf-promises -v</em>. Elles sont définies exclusivement au sein de <em>bundle</em>, ces derniers pouvant être <strong>typés</strong>.

Un <strong>bundle </strong>est un <em>container </em>qui permet de regrouper plusieurs déclarations et définitions de promesse. Le type d'un <em>bundle </em>est généralement le nom du composant auquel il est destiné. Le typage intervient sur la portée des classes et des traitements associés.

Concrètement, un type <em>common </em>invoquera des classes <strong>globales </strong>au sens de la portée de la classe, un type <em>server </em>sera destiné... Et bien à notre <em>cf-servd</em>, le serveur -que nous appellerons aussi le <em>policy host</em>-, tandis que le type <em>agent </em>impliquera une utilisation <strong>locale </strong>des classes, et sera destiné à nos <em>cf-agents</em> -nos hosts.

Il existe d'autres containers que le <em>bundle</em>, le <strong>body </strong>par exemple. Le <em>body </em>permet surtout d'organiser une série de paramétrages complexes sous une et une seule <strong>dénomination </strong>afin de faciliter son exploitation dans les divers <em>bundles </em>du fichier. Le nombre de <em>body </em>n'est pas limité, il est d'ailleurs recommandé d'en disposer plutôt que de lister toutes les variables, crûment, au sein du <em>bundle </em>en lui-même et de nuire ainsi à la lisibilité du fichier... Sans compter tout ce qui concerne la <strong>réutilisabilité </strong>du code...

En logique, nous avons ça :
<pre class="brush: bash">type:
classes::
"promiser"-&gt;{"promisee1","promisee2",...}
attribute_1=&gt;value_1,
attribute_2=&gt;value_2,
...
attribute_n=&gt;value_n;</pre>
La <strong>promesse </strong>la plus simple est la suivante.
<pre class="brush: bash">commands:
"/bin/echo Hello World";</pre>
<em>commands </em>est un type de <em>promiser </em>qui est défini par défaut dans Cfengine. Le <strong>promiser </strong>en lui-même ne constitue qu'une entité aux yeux de Cfengine, n'override pas les paramètres par défaut qui lui sont appliqués et n'en prend aucun.

Et voici l'exemple illustrant le contenu d'un fichier<em> /var/lib/cfengine/inputs/test.cf</em>. L'association d'une variable avec sa valeur est faite via la syntaxe nomvariable =&gt; valeurs.
<pre class="brush: bash">body common control {
bundlesequence =&gt; { "g", "tryclasse1", "tryclasse2" };
}

##
bundle common g {
classes:
"one" expression =&gt; "any" ;
}

##
bundle agent tryclasse1 {
classes:
"two" expression =&gt; "any" ;
}

##
bundle agent tryclasse2 {
classes:
"three" expression =&gt; "any";

reports:
one.three.!two::
"Success" ;
}</pre>
Ici, la classe <em>one </em>est <strong>globale </strong>à tout le fichier, alors que les <em>two </em>et <em>three </em>sont locales. Il en résulte que, dans le<em> bundle tryclasse2</em>, le <em>report</em> renvoie Success, car <em>one </em>est connue, <em>three </em>est connue, et <em>two </em>ne l'est pas.

Toujours des détails, rien que ça, mais ça permet de mettre en lumière 2-3 éléments clés.

Tout d'abord, la partie <strong>bundlesequence </strong>contenue dans la première déclaration, celle du <em>body common control</em>. C'est cette partie qui décide de l'enchainement des traitements. Ici, dans cet exemple <strong>succinct</strong>, nous demandons <em>g</em>, puis <em>tryclasse1 </em>et enfin <em>tryclasse2</em>.

Il se trouve que c'est le même ordre dans lequel les classes sont déclarées, ne vous y trompez pas, la déclaration n'a aucun rapport avec l'ordre d'invocation. Seule la <em>bundlesequence </em>fait foi. Et c'est d'ailleurs pour ça que sa déclaration est en <em>common</em>. <em>Common </em>est le type de déclaration <strong>globale</strong>.

Pour tester cette configuration, vous pouvez attaquer par un <em>cf-promises -f &lt;file&gt;</em> pour la syntaxe et enchainer sur un <em>cf-agent -f &lt;file&gt;</em> pour voir ce qui est vraiment fait.
<pre class="brush: bash">[kbux@policyhost cfengine]# cf-promises -f /var/lib/cfengine/inputs/test0.cf
[kbux@policyhost cfengine]# cf-agent -f /var/lib/cfengine/inputs/test0.cf
R: Success</pre>
En un peu plus élaborée et demandant quelques argument, et nous avons :
<pre class="brush: bash">bundle agent testbundle
{
files:
"/var/cfengine/inputs"

handle=&gt;"update_policy",
depends_on=&gt;"serve_updates",
perms=&gt;system("600"),
copy_from=&gt;mycopy("$(master_location)","$(policy_server)"),
depth_search=&gt;recurse("inf"),
file_select=&gt;input_files,
action=&gt;immediate;
}

bundle server access_rules
{
access:
"/var/lib/cfengine/inputs"
admit=&gt;{"192.168.0.*"};
}

body copy_from mycopy(from,server)
{
source=&gt;"$(from)";
servers=&gt;{"$(server)"};
copy_backup=&gt;"true";
special_class::
purge=&gt;"true";
}</pre>
Il est possible d'accéder aux variables définies au sein d'un <em>bundle </em>-soit dit en passant, si ce n'était pas le cas, où serait la fonctionnalité d'en disposer ?- pour peu qu'elles soient accessibles (mais si ! Rappelez-vous du <strong>scope </strong>des <em>containers</em>). Pour cela, la syntaxe rappelle celle du Java : <em>nombundle.var</em>.

Nous n'en sommes toujours pas au niveau de ce que je vous avais promis, à savoir l'interaction et les traitements <strong>automatisés </strong>entre les hosts et le <em>policy host</em> (notre serveur Cfengine), mais nous n'en sommes pas loin.

Comme je vous l'ai dit auparavant, Cfengine fonctionne sur un système de clé basé sur un modèle semblable à celui d'<strong>OpenSSH </strong>et mis en place par <em>cf-keys</em>. Ce qui implique donc la mise en place de l'infrastructure clé de Cfengine (vous savez, les copies des <em>.pub</em> sur le serveur et les <em>hosts</em> concernés), et naturellement, puisque Cfengine, par défaut, est imperméable aux sollicitations des<strong> nouvelles clés</strong>, un paramétrage plus fin des accès.

Ca aussi, ça passe par des <em>bundles </em>de classe. Plus particulièrement, ces <em>bundles </em>étant destinés au serveur, leur typage lui aussi se distingue de ceux que nous avons vu jusqu'à présent : ils sont de type <em>server</em>.

Le mécanisme doit passer plusieurs étapes. Tout d'abord, l'<strong>authentification</strong>.
<pre class="brush: bash">body server control
{
allowconnects=&gt;{"127.0.0.1","::1" ...etc };
allowallconnects=&gt;{"127.0.0.1","::1" ...etc };
trustkeysfrom=&gt;{"127.0.0.1","::1" ...etc };
}</pre>
Vos armes pour <strong>tester </strong>l'authentification sont principalement <em>cf-agent -v</em> et <em>cf-servd -v</em>. Éventuellement, vous pouvez passer en mode <em>debug </em>avec <em>-d2</em>. N'oubliez pas que vous devez enlever le <em>trustkeysfrom </em>de l'hôte qui a fini avec succès l'échange de clé. En effet, une fois la transmission acceptée, la déclaration de cet hôte à cet endroit n'a plus aucun intérêt.

Petit point intéressant, si vous mettez en place sur une architecture conséquente, ça serait long de devoir se taper toutes les <strong>IPs </strong>à la main. On peut donc mettre, au lieu de notre <em>trustkeysfrom </em>un petit<strong> trustkey=&gt;"true"</strong>, ce qui aurait pour conséquence d'accepter toutes les sollicitations d'échange, et d'enregistrer toutes les clés associées.

Avec tout ce que cela peut impliquer. Donc à faire sur un réseau <em>safe </em>et surtout de penser à le désactiver une fois tous les <em>hosts </em>enregistrées, car cela peut être dangereux.

Ensuite, une fois que l'accès est ok, il vous faut spécifier qui a accès à quoi.
<pre class="brush: bash">bundle server access_rules()
{
access:
"/var/lib/cfengine"
admit=&gt;{"127.0.0.1","192.168.0.*"},
deny=&gt;{"172\..*"};
}</pre>
Au final, votre configuration de serveur pourra éventuellement ressembler à ça :
<pre class="brush: bash">#######################################################
# Server configuration
#######################################################
bundle server access_rules()
{
access:
"/var/lib/cfengine"
admit =&gt; { "127.0.0.1", "192.168.0.*" };
# Rule for cf-runagent
"/home/kbux/.cfagent/bin/cf-agent"
admit =&gt; { "127.0.0.1" };

# New in cf3 - RBAC with cf-runagent
roles:
".*" authorize =&gt; { "kbux" };
}</pre>
Il vous faut également, en plus du <em>server.cf</em> et du <em>promises.cf</em>, notre fameux <em>update.cf</em> qui donnera le ton aux <em>cf-agents</em> distants et un<em> failsafe.cf</em>.

L'<em>update.cf</em> devra être <strong>le plus stable possible</strong> dans le temps, ne jamais le modifier serait l'idéal. Dans le cas où vous êtes amené à le modifier, faites en sorte de <strong>vérifier </strong>qu'il fonctionne correctement. L'officiel met à disposition cette matrice d'<em>update.cf</em>. A vous de jouer !
<pre class="brush: bash">#######################################################
#
# update.cf
#
#######################################################
bundle agent update
{
files:
"/var/cfengine/inputs"
perms =&gt; system("600"),
copy_from =&gt; mycopy("/home/mark/cfengine-inputs","localhost"),
depth_search =&gt; recurse("inf");
"/var/cfengine/bin"
perms =&gt; system("700"),
copy_from =&gt; mycopy("/usr/local/sbin","localhost"),
file_select =&gt; cf3_files,
depth_search =&gt; recurse("inf");
}
############################################
body perms system(p)
{
mode =&gt; "$(p)";
}
############################################
Chapter 4: A complete conguration 51
body file_select cf3_files
{
leaf_name =&gt; { "cf-.*" };
file_result =&gt; "leaf_name";
}
#########################################################
body copy_from mycopy(from,server)
{
source =&gt; "$(from)";
compare =&gt; "digest";
}</pre>
Le <em>failsafe.cf</em>, quant à lui, est destiné aux cas où Cfengine n'arrive pas à lire votre configuration principale. C'est votre porte de sortie, notamment lorsqu'une <strong>migration </strong>ne s'est pas exactement passée comme prévue.

Lui aussi devra subir aussi peu de changements que possible, et être testé <strong>très sérieusement</strong> pour éviter justement de ne pas vous en sortir en cas de pépin. Je vous donne également la matrice officielle du fichier.
<pre class="brush: bash">#######################################################
#
# failsafe.cf
#
#######################################################
body common control
{
bundlesequence =&gt; { "update" };
}
#########################################################
bundle agent update
{
files:
"/var/cfengine/inputs"
perms =&gt; system,
copy_from =&gt; mycopy("/home/mark/cfengine-inputs","localhost"),
file_select =&gt; cf3_files,
depth_search =&gt; recurse("inf");
"/var/cfengine/bin"
perms =&gt; system,
copy_from =&gt; mycopy("/usr/local/sbin","localhost"),
file_select =&gt; cf3_files,
depth_search =&gt; recurse("inf");
}
#########################################################
body perms system
{
mode =&gt; "0700";
}
#########################################################
body depth_search recurse(d)
{
depth =&gt; "$(d)";
}
############################################
body file_select cf3_files
{
leaf_name =&gt; { "cf-.*" };
file_result =&gt; "leaf_name";
}
#########################################################
body copy_from mycopy(from,server)
{
source =&gt; "$(from)";
servers =&gt; { "$(server)" , "failover.domain.tld" };
#copy_backup =&gt; "true";
#trustkey =&gt; "true";
encrypt =&gt; "true";
}</pre>
Voilà. Normalement, vous êtes parés niveau configuration. Il ne vous reste plus qu'à tester, piocher sur les <strong>expressions régulières</strong> et les détails de variables, à savoir les listes, les scalaires, etc, etc, et vous serez vite enclin à adopter la solution.

Allez-y doucement tout de même et n'oubliez pas d'exclure votre <em>policy host</em> des <em>hosts </em>qui doivent mettre leurs configurations à jour.

Vous pouvez retrouver des ensembles consistants de fichier de configuration directement en lisant <a href="http://www.cfengine.org/" target="_blank">les documents officiels</a>.
<div id="_mcePaste" style="overflow: hidden; position: absolute; left: -10000px; top: 1039px; width: 1px; height: 1px;">3408494K</div>]]></content:encoded>
			<wfw:commentRss>http://www.k-tux.com/cfengine-cet-outil-qui-facilite-la-vie-des-asr/feed</wfw:commentRss>
		<slash:comments>3</slash:comments>
		</item>
		<item>
		<title>Nos amis les Filesystems&#8230; Part II (suite et fin)</title>
		<link>http://www.k-tux.com/nos-amis-les-filesystems-part-ii-suite-et-fin</link>
		<comments>http://www.k-tux.com/nos-amis-les-filesystems-part-ii-suite-et-fin#comments</comments>
		<pubDate>Tue, 05 Jan 2010 14:16:52 +0000</pubDate>
		<dc:creator>K-TUX</dc:creator>
				<category><![CDATA[Linux]]></category>
		<category><![CDATA[Sysadmin apps]]></category>
		<category><![CDATA[architecture]]></category>
		<category><![CDATA[filesystem]]></category>
		<category><![CDATA[planet-libre]]></category>
		<category><![CDATA[sécurité]]></category>
		<category><![CDATA[system]]></category>

		<guid isPermaLink="false">http://www.k-tux.com/?p=370</guid>
		<description><![CDATA[Tout d&#8217;abord, BONNE ANNEE à tous les courageux qui ont réussi à se convaincre de reprendre le boulot sur leur site de travail -car maintenant, avec tous les moyens qu&#8217;il existe, il est largement possible de skipper l&#8217;implication physique, avec &#8230; <a href="http://www.k-tux.com/nos-amis-les-filesystems-part-ii-suite-et-fin">Continue reading <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[Tout d'abord, <strong>BONNE ANNEE</strong> à tous les courageux qui ont réussi à se convaincre de reprendre le boulot sur leur site de travail -car maintenant, avec tous les moyens qu'il existe, il est largement possible de skipper l'implication physique, avec tout ce qu'elle entraîne, tout gardant la charge et la pleine responsabilité de l'infrastructure-.

Donc nous voila de retour sur les <strong>filesystems</strong> pour continuer -et éventuellement finir, tout dépend de ce qui vous reste en motivation le sujet.

Pour rappeler le contexte, ceci n'est qu'un épluchage de filesystems <strong>échantillonnés </strong>au hasard des rencontres, le tout rangé comme il faut dans les catégories qui vont bien. Si vous êtes curieux des épisodes précédents mais que le scroll down est trop pénible (je comprends, je comprends), vous pouvez juste placer votre souris sur le <a href="http://www.k-tux.com/nos-amis-les-filesystems-part-i" target="_blank">lien</a> &lt;- ici et vous laisser transporter dans la première partie de cet article !

Rapidement, nous nous sommes pluché les généralités, l'architecture logique, les classiques et les extensibles / haute disponibilités... Non, je n'ai pas prévu les apéritifs... Mais si vous avez faim, on attaque !

<strong>Les réseaux.</strong>

A l'heure de la communication et des <strong>flux</strong> de données, il aurait été inconcevable de ne pas mentionner les systèmes de fichier distants. En effet, il est possible d'exporter un système de fichier et de le rendre accessible par plusieurs machines. L'avantage concerne notamment le fameux "Zero Conf", et donc la possibilité d'être complètement -ou presque- <strong>indépendant</strong> de la  machine que l'on utilise. Cela permet aussi de beaucoup mieux contrôler, sécuriser les accès et les droits sur ce système de fichiers, de centraliser les traitements et d'apporter une certaine robustesse et une certaine portabilité.

Le plus connu est <strong>NFS</strong> (<em>Network File System</em>). Il existe à l'heure où j'écris ces lignes, 2 versions qui sont exclusives l'une de l'autre, la version 3 et la version 4. La version 4 est celle désormais supportée par défaut.

NFS fonctionne comme un <strong>export</strong> de répertoire, qui peut être fait de manière lâche ou en contraignant les accès. Les machines autorisées peuvent alors, de manière manuelle ou automatique, monter ces répertoires, en lecture, en écriture et/ou exécution et les utiliser comme s'ils faisaient partie intégrantes de leur filesystem local. Si l'on veut savoir de quoi il en retourne, il suffit alors de lancer un <em>netstat</em>, un <em>rpcinfo -p</em>, un <em>nmap</em> ou un <em>nfsstat</em> sur les machines impliquées.

Globalement, les différences entre NFSv3 et NFSv4 tiennent à une réécriture du code pour <strong>optimisation</strong> et améliorations. Elles concernent notamment :
<ul>
	<li>une gestion plus poussée de la sécurité,
- support de techniques comme Kerberos,
- réduction des ports à ouvrir sur un firewall (plus d'UDP, on passe de 4 ports à 1, 2049:tcp)</li>
	<li>une gestion de cache plus poussée,</li>
	<li>une compatibilité pour les clients non Unix-like (donc Windows, via SFU, Services For Unix) ,</li>
	<li>une administration facilité (en terme de réplication, de migration,...),</li>
	<li>la gestion du crash recovery (client comme serveur)...</li>
</ul>
NFSv4 est <strong>statefull</strong> (il gère les états, ce qui n'était pas le cas de NFSv3), utilise la notion de répertoires virtuels, et supporte IPv6 côté client. L'unique port auquel il s'adresse est le 2049:tcp.

Il est bien sûr tout à fait possible de <a href="http://nfsv4.bullopensource.org/doc/NFS3_NFS4_migration.pdf" target="_blank">migrer</a> de NFSv3 à NFSv4. Et pour ceux que cela intéresse, un petit <a href="http://www.linux.com/archive/feature/138453" target="_blank">lien</a> sur les benchmarks réalisés sur les 2 versions et des <a href="http://www.citi.umich.edu/projects/nfsv4/" target="_blank">infos</a> sur la bête en question !

Effectivement, NFS est bien visible, beaucoup utilisé, mais il existe d'autres filesystems dans cette catégorie, comme <strong>SAMBA</strong>, qui présente l'avantage d'être accessible nativement par Windows <span style="text-decoration: underline;">et</span> par <strong>Mac OS X</strong>. En effet, à l'heure actuelle, aucun support n'a été intégré au nouveau noyau de Mac concernant la prise en charge d'NFSv4. Bien entendu, un courageux développeur a bien tenté de créer un module pour pallier au manque -d'autant plus éprouvant qu'NFSv4 est maintenant devenu <strong>standard</strong> sous Linux- mais le résultat est aléatoire et peut sans problème et à répétition, faire planter outrageusement Mac OS X. Le module est accessible <a href="http://snowhite.cis.uoguelph.ca/nfsv4/" target="_blank">ici</a>.

Les outils et fichiers importants :
<ul>
	<li><em>nfs-common</em> et <em>nfs-kernel-server</em> : les packages respectivement pour le client et le serveur et pour le serveur,</li>
	<li><em>/etc/exports</em> : le fichier de paramétrage d'export et de contrôle d'accès des fichiers accessibles via NFS,</li>
	<li style="text-align: left;"><em>/etc/default/nfs-kernel-server</em> et <em>/etc/default/nfs-common</em> : fichiers de configuration globaux</li>
	<li style="text-align: left;"><em>/etc/fstab</em> : notre fichier de montage automatique au démarrage,</li>
	<li style="text-align: left;"><em>mount -t nfs</em> : notre outil de montage manuel.</li>
</ul>
<!--more-->
<p style="text-align: left;"><strong>Les systèmes répartis.</strong></p>
Gros gibier. Eh oui, les clusters ont, eux-aussi, droit à leur catégorie puisqu'il existe des systèmes de fichiers conçus exprès pour eux.

<strong>PVFS</strong> (<em>Parallel Virtual FileSystem</em>) est l'un d'eux.

PVFS, comme son nom l'indique, s'adresse aux <strong>clusters</strong> destinés à faire tourner des traitements en parallèle. Il a été conçu pour optimiser les flux d'information transitant entre les nœuds du cluster. Ses principaux objectifs sont :
<ul>
	<li>d'offrir une large capacité concernant les accès concurrents de multiples processes sur un même espace,</li>
	<li>supporter plusieurs API (UNIX/POSIX IO, MPI I/O, PVFS I/O,...) et d'être Unix command-compliant (ls, cp, rm,...)</li>
	<li>offrir robustesse et scalabilité tout en restant accessible à l'utilisateur.</li>
</ul>
PVS est en réalité composé d'un set de <strong>daemons</strong> et de librairies, liés aux nodes suivant des rôles qui leur sont attribué par l'administrateur (donc vous). Il en existe 3 : compute, IO et management, certains peuvent même se cumuler. Grâce à l'attribution de ces rôles, il devient possible de découper les <strong>responsabilités </strong>attribuées à un filesystem orienté parallel computing sur plusieurs nodes et donc mieux gérer les accès aux ressources et par là même d'optimiser les performance du système.

Pour schématiser, c'est au rôle de <strong>Manager </strong>que reviennent les charges de contrôle des permissions d'accès et la maintenance des métadonnées et de l'organisation logique des éléments du filesystem. Les <strong>IO nodes</strong>, quant à eux, ont pour tâche de fournir l'accès aux données et de se corréler pour gérer les accès concurrents.

Les <strong>Compute nodes</strong> sont à la base des requêtes d'accès, de création et de modification des données, communiquent directement avec les IO nodes et sont donc encadrés en amont par les Management nodes au moment de la vérification des permissions d'accès, de lecture, d'écriture, d'exécution, et toute autre modification comme une copie ou un effacement de fichier. Ce sont eux qui font tourner les processes à proprement parler.

On notera que PVFS est très user-friendly, compatible, <strong>scalable </strong>à souhait et permet d'atteindre de haute performances concernant les applications IO intensives (parallèles comme distribuées) mais qu'en revanche, il ne fournit aucun mécanisme de <strong>recovery </strong>en cas de crash de node, et la redondance de donnée n'est pas présente. Il est également soumis aux limitations de <strong>TCP </strong>(nombre de socket ouvertes simultanément, surchage du trafic,...) et celles des filesystems Linux en général (taille de fichier &lt;= 2Gb). Son module de <strong>compatibilité </strong>d'API UNIX/POSIX pose un problème de support des différentes versions de <em>glibc</em>. Enfin, le modèle de sécurité fourni par PVFS est plutôt basique (aucune restriction sur les connexions client, pas d'<strong>encryption </strong>des données, aucune vérification d'authenticité sur l'identité des clients, comme pour NFS, les clients et les informations qu'ils transmettent (UID) sont considérés comme fiables), ce qui le destine à des clusters confinés dans un réseau sécurisé.

Il faut tout de même dire que PVFS est encore en évolution, et quelques améliorations sont d'ores et déjà annoncées. Pour les liens, ça se passe par <a href="http://www.pvfs.org/" target="_blank">ici</a> et par <a href="http://chl.be/glmf/articles.linuxmag-france.org/lm32/PVFS.html" target="_blank">là</a> !

Sachez que les principaux rivaux à PVFS se nomment <a href="http://www.redhat.com/gfs/" target="_blank">GFS (<em>Global FileSystem</em>)</a>, <a href="http://www.mosix.org/" target="_blank">MFS (Mosix FileSystem)</a>, <a href="http://www.coda.cs.cmu.edu/" target="_blank">Coda</a>, <a href="http://clustercenter.org/software/InterMezzo-File-System-Home/" target="_blank">Intermezzo</a>, et <a href="http://wiki.lustre.org/index.php/Main_Page" target="_blank">Lustre</a>.

La discussion sur les différences inhérentes à ces filesystems représente un vaste débat dans lequel je n'entrerais pas, pour la simple et bonne raison que d'une part je ne les ai pas mis en pratique, et d'autre part, comme on dit, c'est le contexte qui choisit sa solution. Je vous laisse donc potasser joyeusement, du moins si le cœur vous en dit...

<strong>Les encryptés.</strong>

Nous en arrivons à nous demander si, par rapport à toute cette histoire d'accès aux données, de confiance implicite accordée au client et de tout ce que l'on entend à la radio, vandalisme, blackmailing, trafic de données et espionnage industriel, si nos données à nous, locales, notre filesystem, si lui est <strong>sécurisé </strong>contre les intrusions... Ou pas...

Tout d'abord, vous devez absolument savoir que des <strong>lois</strong> s'étendent sur le sujet, notamment parce que l'absolue imperméabilité des échanges pourrait servir des desseins terroristes, des machinations, des pushs, bref l'autorité n'est pas tranquille. Cette anticipation amène donc à de drôles de restrictions au niveau de l'encodage des données.

<span style="text-decoration: underline;">Les solutions Linux.</span>

Il y a plusieurs manières de faire le boulot sous Linux, surtout depuis le noyau 2.6. Dans un premier temps déjà, au niveau de l'installation, la plupart des distributions vous demande si vous désirez <strong>crypter</strong> vos données (Ubuntu 9.10 : "le mot de passe est requis pour ouvrir une session et déchiffrer mon dossier personnel", Fedora : "Encrypt System || Encrypt", ...). L'avantage d'opérer la manip' à ce niveau est surtout que vous n'aurez pas à passer par des sauvegardes pour <strong>migrer</strong> d'un espace non encrypté à un qui l'est. Par ce que, oui, il n'y a pas de recette miracle : lorsque vous devez faire en sorte que telle ou telle partition doit encryptées, les données existantes sont écrasées. L'inconvénient est qu'en fait, les opérations d'encryption réalisées à ce moment-là nous sont complètement cachées, impossible de savoir précisément ce qui se trame, et surtout ce qu'il y a dessous cette "encryption".

S'il n'a pas jugé opportun de procéder à l'encryption du filesystem à l'installation, ou si les données ont changé (nouveau disque tout beau, <strong>PSSI</strong> renforcée, syndrome de paranoïa aigüe, ...), alors Linux, depuis le noyau 2.6, met à disposition nativement une <strong>API </strong>de cryptographie (<em>CryptoAPI</em>) qui centralise les traitements et ce, quelque soit le choix de l'outil qui fera le sale boulot. Notons également que certaines distributions (les<strong> *BSD</strong> par exemple) proposent un panel d'outils supplémentaire.

Parmi les outils et les mécanismes disponibles, il est nécessaire de cerner le besoin : a-t-on besoin d'une granularité fine sur les répertoires et fichiers, ou nous arrêtons-nous aux partitions ?

En effet, il est possible de gérer l'encryption de manière totale, c'est-à-dire que tout le disque est encrypté, y compris les outils qui permettent justement d'encrypter et de décrypter, c'est ce que l'on appelle le <strong>Full Disk Encryption</strong>. Généralement, ce type de fonctionnement implique une déclaration statique de l'espace à encrypter, qui est fixe et ne peut être alloué dynamiquement, par exemple lors du rajout d'un disque, du moins sans avoir préalablement renouvelé la démarche de déclaration et d'encryption. Ce type d'encryption englobant la totalité du support, cela permet d'éviter tout leaking d'information, notamment au niveau swap, malheureusement, il est parfois impossible de paramétrer l'encryption plus finement au niveau des répertoires. Parmi les grands noms impliqués, <strong>dm-crypt</strong> et <strong>LUKS</strong> (<em>Linux Unified Key Setup</em>) figurent dans le top ten. Remarquez, c'est normal, on les trouve souvent ensembles, ces deux-là.

N'hésitez pas à mettre les mains dans le cambouillis ! Les dm-Crypt, par <a href="http://www.saout.de/misc/dm-crypt/" target="_blank">ici</a> et <a href="http://polishlinux.org/howtos/encrypted-home-partition-in-linux/" target="_blank">ici</a> ! Les LUKS, <a href="http://code.google.com/p/cryptsetup/" target="_blank">là</a> et <a href="http://docs.fedoraproject.org/install-guide/f11/fr-FR/html-single/#Disk_Encryption_Guide" target="_blank">là (pour les RedHat)</a> !

A contrario, l'encryption peut être gérée en elle-même par le filesystem, et donc nous ne trouvons plus face à la nécessité d'allouer et de crypter explicitement avant d'écrire sur l'espace. L'encryption est alors faite à la volée (<strong>on the fly</strong>). Ce mode apporte une certaine souplesse mais en revanche, il laisse des traces au niveau swap et les traitements intermédiaires ne sont pas adaptés à une large sollicitation des  accès disques. C'est ce que l'on appelle communément un <strong>Filesystem-Level Encryption</strong>. On peut citer, par exemple, dm-Crypt avec ou sans LUKS (et oui, qui peut le plus peut souvent le moins), <a href="http://www.truecrypt.org/" target="_blank">Truecrypt</a>, <a href="http://www.fsl.cs.sunysb.edu/docs/cryptfs/cryptfs.html" target="_blank">CryptFS</a>, <a href="http://www.linux.com/archive/feature/52820" target="_blank">Enc-FS, Loop-AES</a>, ... Il est intéressant que certains des outils fonctionnent en <strong>UserSpace</strong> grâce à notre bon vieux FUSE, et ne nécessitent souvent pas de root access pour être mis en place. Si vous décidez de ce type d'encryption, CryptoAPI est votre ami.

Enfin, on peut se pencher uniquement sur certains fichiers, et on bascule sur le cryptage manuel via des certificats numériques.

Si vous avez besoin de plus de détails concernant les généralités des 3 niveaux d'encryption, vous pouvez trouver une masse conséquente de savoir <a href="http://linuxreviews.org/howtos/security/Disk-Encryption-HOWTO/index.html.en" target="_blank">ici</a> !

<span style="text-decoration: underline;">Les solutions *BSD.</span>

En ce qui concerne les solutions <strong>*BSD</strong>, il vous arrivera d'entendre 2 noms : CDG pour <a href="http://www.freebsd.org/fr/index.html" target="_blank">FreeBSD</a> et GELI pour <a href="http://www.netbsd.org/" target="_blank">NetBSD</a>. Vous vous posez sûrement la question, vous qui ne faîtes pas partie des troupes *BSD, en quoi ces 2 OS sont-ils différents ? Pour répondre à cette question qui abrite beaucoup de trolls et qui sort complètement du <strong>scope </strong>de l'article, vous pouvez vous référer aux sites officiels, de les tester, tout simplement, ou si vous n'avez ni le temps ni la patience pour l'une ou l'autre solution proposée, vous pouvez toujours couper court en lisant l'article de <a href="http://www.commentcamarche.net/faq/sujet-1839-bsd-les-divers-systemes-bsd" target="_blank">Comment ça marche</a>.

CDG se compose d'une <strong>couche d'abstraction </strong>supplémentaire qui se situe en dessous du buffer cache, cette position lui permettant de faire abstraction du système de fichier employé, de ce qu'il encrypte et décrypte (swap, disque, ...) et d'une partie <strong>user utility</strong>, située dans le UserSpace. Il a été conçu et optimisé pour les machines destinées à une seule personne ou pour les supports de stockage amovibles et encrypte entièrement les partitions. Il est portable sur toute autre version dérivée de BSD et il est nécessaire d'activer son support à la création du kernel.

Techniquement parlant, <strong>CDG</strong>, via son outil de configuration en UserSpace, supporte et met à disposition différentes méthodes de cryptage, afin que l'utilisateur ne soit pas tenu à une technologie et qu'il puisse adapter CDG à son niveau de besoin. La partie située dans le kernel, sous le buffer cache, se contente, elle, d'encrypter les données, ce qui lui permet d'être plus <strong>réactive</strong>, mais de fait, l'encryption par utilisateur n'est pas possible. Pour les détails techniques, rendez-vous sur le <a href="http://www.netbsd.org/docs/guide/en/chap-cgd.html" target="_blank">chapitre dédié</a>.

<strong>GELI </strong>(GEOM_ELI de son petit nom) demande également l'activation de son support avant recompilation du kernel car il n'est pas intégré nativement dans NetBSD. GELi est en fait la combinaison de 2 outils. Le premier outil, <a href="http://www.freebsd.org/doc/fr/books/handbook/geom.html" target="_blank">GEOM</a>,  s'occupe de gérer les disques (labels BSD, MBR, ...) et qui sert souvent de base pour la mise en place de RAID. Dans le cas de l'encryption, GEOM sert également de base pour GBDE (Geom Based Disk Encryption). <strong>GELI</strong>, quant à lui, s'occupe de la partie encryption en elle-même.

Le reste est librement consultable <a href="http://www.freebsd.org/doc/en/books/handbook/disks-encrypting.html" target="_blank">ici</a> ! Pour ceux qui voudraient même aller plus loin, vous pouvez lire l'excellente poussée <strong><a href="http://www.unixgarden.com/index.php/securite/filesystems-encryptes-sous-netbsd-et-freebsd-par-la-pratique" target="_blank">Unix Garden</a></strong>.

On trouve de la même façon des solutions dites "<strong>cross plateform</strong>", c'est-à-dire qui fonctionnent sous  importe quel OS. Amis Windowsien, voici pour toi. Parce qu'il est vrai que jusqu'à présent, nous avons parlé de solutions exclusivement Linux, pour autant, il en existe pour Windows -<strong>EFS</strong>, <a href="http://www.freeotfe.org/" target="_blank">FreeOTFE</a>- et pour les deux -<a href="http://www.jetico.com/encryption-bestcrypt/" target="_blank">BestCrypt</a>, <a href="http://www.truecrypt.org/" target="_blank">TrueCrypt</a>-. Si vous êtes intéressés, vous pouvez aller faire un petit tour sur les sites officiels. BestCrypt a aussi un article pour lui tout seul dans <strong><a href="http://www.linuxjournal.com/article/5938" target="_blank">Linux Journal</a></strong>.

Notre "rapide" tour d'horizon s'achève sur ces mots. Oui, promis, plus jamais aussi basique. Plus court aussi. Je note dans mes bonnes résolutions.

Par contre, pour ceux qui ont décroché -et donc qui ne sont sûrement plus en train de lire ces lignes-, vous pouvez noter dans les vôtres plus d'endurance ! Après tout, c'est bien beau les tutos et autres, mais faut aussi savoir ce que l'on fait. Et pour cela, 4 lettres bénites : <strong>RTFM</strong>.

Sur ce ! Paix et longue vie à vos serveurs critiques (et aux autres aussi) !]]></content:encoded>
			<wfw:commentRss>http://www.k-tux.com/nos-amis-les-filesystems-part-ii-suite-et-fin/feed</wfw:commentRss>
		<slash:comments>2</slash:comments>
		</item>
		<item>
		<title>Nos amis les Filesystems&#8230; Part I</title>
		<link>http://www.k-tux.com/nos-amis-les-filesystems-part-i</link>
		<comments>http://www.k-tux.com/nos-amis-les-filesystems-part-i#comments</comments>
		<pubDate>Fri, 11 Dec 2009 07:51:50 +0000</pubDate>
		<dc:creator>K-TUX</dc:creator>
				<category><![CDATA[Linux]]></category>
		<category><![CDATA[Sysadmin apps]]></category>
		<category><![CDATA[architecture]]></category>
		<category><![CDATA[filesystem]]></category>
		<category><![CDATA[planet-libre]]></category>
		<category><![CDATA[system]]></category>
		<category><![CDATA[theory]]></category>

		<guid isPermaLink="false">http://www.k-tux.com/?p=325</guid>
		<description><![CDATA[Bonjour readers et readeuses acharnés. Aujourd&#8217;hui, nous allons parler des différents système de fichiers -Filesystem, pour briller en société- qui font la richesse et la pluridisciplinarité de Linux, et comme il y en a beaucoup et de toutes sortes, nous &#8230; <a href="http://www.k-tux.com/nos-amis-les-filesystems-part-i">Continue reading <span class="meta-nav">&#8594;</span></a>]]></description>
			<content:encoded><![CDATA[Bonjour readers et readeuses acharnés.

Aujourd'hui, nous allons parler des différents système de fichiers -<strong>Filesystem</strong>, pour briller en société- qui font la richesse et la pluridisciplinarité de Linux, et comme il y en a beaucoup et de toutes sortes, nous allons découper ça bien propre en plusieurs parties. Utilisateur Windows, ne t'inquiète pas ! Ton heure viendra, mais pas tout de suite quand même, parce que, même avec <strong>Windows 7</strong> (dites Séveuuun), il y a encore un petit bout de chemin à faire.

<span style="text-decoration: underline;">Avertissement pour les puristes de la technique :</span>

Cette note est tournée grand public et la mise en œuvre des techniques décrites ci-dessous ne sera pas détaillée, même si quelques liens propices vous guideront vers des howtos bien ficelés.

<strong><span style="text-decoration: underline;">Petites généralités.</span></strong>

Selon notre ami <a href="http://fr.wikipedia.org/wiki/Syst%C3%A8me_de_fichiers" target="_blank">Wikipédia</a>, un système de fichier est un ensemble structuré qui permet d'organiser, de localiser, d'accéder et de maintenir des données. Le tout sur un support persistant, c'est-à-dire qui gardera les informations en l'état à l'extinction de la machine. Le plus communément, c'est donc sur votre (vos ?) disque(s) dur(s) que vous retrouverez vos fichiers.

Afin de pouvoir maintenir toutes ces informations, le système de fichier crée lui-même d'autres informations, relatives, elles, aux fichiers en eux-même. C'est ce que l'on appelle des <strong>métadonnées</strong>. Sous Linux, ce sont les inodes qui contiennent ces métadonnées. Les inodes sont des structures de données contenant toutes les informations utiles d'un fichier, permissions comprises. Elles sont liées aux fichiers par une autre structure de données, le dentry. Les fichiers, les <strong>inodes</strong> et les dentries sont contenus dans ce que l'on appelle le superblock, entité qui est chargée de la maintenance et de la gestion de la structure de donnée. Il contient le nom du filesystem (par exemple ext4), sa taille, son état, des métadonnées et une référence aux bloc devices. Le superbloc est la <strong>racine</strong> du filesystem.

Pour votre curiosité, Windows, lui, stocke directement ces métadonnées dans le fichier lui-même.

De visu, le système de fichier se présente comme une arborescence de répertoires dont la racine est /:
<p style="text-align: center;"><em>/</em></p>
<p style="text-align: center;"><em>/bin /boot /dev /etc /home /lib /lib64 /lost+found /media /mnt /opt /proc /root /sbin /tmp /usr /var</em></p>
<p style="text-align: left;">Ce que vous ne voyez pas, mais que vous avez pu rencontrer si vous avez, par curiosité ou par science, partitionné votre disque manuellement, c'est la swap.</p>
<p style="text-align: left;">La <strong>swap</strong> est en fait une petite partie du disque réservée à la mémoire. Du fait qu'elle soit située sur le disque, elle est beaucoup plus lente d'accès que la mémoire vive en elle-même, mais elle présente un avantage dans le cas où vous êtes submergé par une occupation excessive de la mémoire vive par un ou plusieurs processus. Dans ce cas, au lieu de vous bloquer définitivement pour cause de pénurie de <strong>RAM</strong>, on utilise la swap. Une règle de pouce consiste à créer une swap de taille égale à la quantité de RAM présente sur la machine.</p>
<p style="text-align: left;"><strong><span style="text-decoration: underline;">Organisation logique.</span></strong></p>
Mais revenons-en à nos moutons. Vous vous doutez bien qu'avec la quantité et la diversité des médias existants en ce bas-monde, le système de fichier Linux ne peut raisonnablement pas être livré tel quel, figé sur une implémentation pure et dure qui serait relative à un et un seul type de média, ni être décliné pour chacun des médias existant sur cette petite planète. D'une part parce qu'il en existe vraiment beaucoup, et d'autre part parce que cela nécessiterait de faire massivement évoluer le code lors d'une évolution de média. Bref, pas du tout portable, aucune scalabilité, le cauchemar. Il en est tout autrement.

<span style="text-decoration: underline;">User-Space, Kernel-Space.</span>
<p style="text-align: left;">En effet, le système de fichier Linux distingue 2 couches <strong>abstraites</strong>. Pourquoi ? Et bien pour séparer les traitements effectués par le système de fichier des manipulations de device à proprement parler.</p>
<p style="text-align: left;"><img class="aligncenter size-full wp-image-329" title="linuxFS" src="http://www.k-tux.com/wp-content/uploads/linuxFS.jpg" alt="linuxFS" width="557" height="562" /></p>
Le schéma parle de lui-même. Nous pouvons donc voir que toutes les interactions avec le <strong>User-Space</strong> (autrement dit, tout ce qui touche à l'environnement utilisateur) passe par l'interface SYSTEM CALL, Kernel-Space qui, elle-même, devra s'adresser à un système de fichier virtuel (<strong>VFS</strong>) pour que ses traitements soient effectués à proprement dit. VFS abstrait les interfaces qui lui viennent d'un export de l'individual filesystem. Il gère également les informations concernant les filesystems supportés et ceux actuellement montés (oui, promis, j'expliquerais "monter"). Individual Filesystem, à l'origine de l'export des interfaces, fonctionnera très différemment selon le filesystem choisi (ext2, ext3, JFS, ...). Des <strong>caches</strong> sont présents à différent niveau afin d'optimiser le temps de traitement (Inode cache, Directory cache, Buffer cache).

Ok, je sens que je vais un peu loin alors je vais arrêter là. Pour ceux qui en veulent plus, n'hésitez plus, allez farmer un peu sur le Net.<!--nextpage-->

<span style="text-decoration: underline;"><strong>Les types de filesystem.</strong></span>

<strong>Les classiques.</strong>

Lorsque vous installez votre Linux, sachez que vous avez la possibilité de choisir votre filesystem, et de le <strong>partitionner</strong> vous-même (c'est-à-dire le scinder en morceau de disque). Par défaut, Linux, dans ses versions récentes, installera votre filesystem sous <strong>ext4</strong> -<em>Extended FileSystem</em>- (Ubuntu Karmic Koala, Fedora 12 Constantine, ...). Mais comme cela est si bien dit dans les notes d'Ubuntu, cela ne signifie pas que les autres filesystems ne sont plus supportés. Il existe en effet, historiquement, d'autres versions d'ext : ext2, ext3 sont les plus souvent rencontrées (au-delà, votre serveur est <span style="text-decoration: underline;">vraiment</span> vieux).

Ah. Question au fond. La différence ? Entre ? AAAH !!!

Déjà, entre ext2 et ext3, nous avons principalement une différence au niveau de la <strong>journalisation</strong>. En effet, ext2 est un des dinosaures de Linux. Il était certes plus intelligent que le <strong>FAT</strong> de Windows, en ce sens qu'il organisait les fichiers et donc limitait le recours à la fragmentation, mais il restait perfectible. Vous en avez révé ? Ext3 l'a fait ! La journalisation sert essentiellement à maintenir la cohérence des métadonnées, notamment en cas de crash. Cela évite par exemple le gentil <strong><em>fsck</em> </strong>de ext2 lorsque le système a subi un arrêt impromptu. Le système relit tranquillement son fichier de <strong>log</strong>, retrace les dernières transactions non commitées et remet d'aplomb un système sain en 2 temps trois mouvements. Hop, ne soyons pas radin, un peu de <a href="http://e2fsprogs.sourceforge.net/ext2.html" target="_blanck">doc</a> vous fera du bien !

Ext3 et Ext4, c'est une autre histoire. Ext4 est une évolution puisqu'étant encore attaché à la compatibilité descendante, il reste limité dans ses mouvements. Ext4 oriente la majorité de son travail sur les problèmes de tailles et de <strong>fragmentation</strong>. Hop, moment opportun pour un petit lien d'info sur <a href="http://linuxfr.org/2009/06/14/25602.html" target="_blank">Linuxfr.org</a> et sur le <a href="http://ext4.wiki.kernel.org/index.php/Main_Page" target="_blank">Wiki officiel Ext4</a>.

Ext3 et Ext4 sont principalement utilisés, ce sont eux qui supportent votre Linux. Ils peuvent travailler sur disques durs, sur volumes logiques, sur partition raid, toussa toussa, sans broncher (ou si peu).

Les outils et fichier impliqués font partie du noyau Linux depuis belle lurette, ce sont, entre autre<em> </em> :
<ul>
	<li><em>fdisk </em>: permet de manipuler / voir / gérer les partitions,</li>
	<li> <em>mkfs.ext2</em> ou<em> mkfs.ext3</em> : créer le système de fichier (respectivement ext2 ou ext3),</li>
	<li><em>fsck </em>: monitorer et réparer votre système de fichier,</li>
	<li><em>resize2fs </em>: redimensionner le filesystem,</li>
	<li><em>mount </em>: "monter", c'est-à-dire rendre accessible en lecture (et, pourquoi pas, en écriture-exécution) un système de fichier,</li>
	<li><em>/etc/fstab</em> : fichier de configuration pour les montages automatiques au démarrage des différents filesystems. Par défaut, votre filesystem est déjà monté et inscrit dans ce fichier.</li>
</ul>
<strong>Les extensibles et les hautes disponibilités.</strong>

Lorsque l'on donne, dans son immense bonté, vie à une machine Linux, elle a, comme tout être vivant, un <strong>cycle</strong> de vie. Parce que oui, dans un contexte généralisé, votre machine aussi a besoin de grandir, en terme de composant, de performances, de service et d'espace.

Il existe plusieurs moyens permettant de construire et d'<strong>étendre</strong> un système de fichier. Certaines approches nécessitent un travail de réflexion en amont, à savoir si réellement on a besoin de rajouter de l'espace, si ce doit être opérationnel sans avoir à réinstaller, rapidement, de manière modulaire, si il y a une forte contrainte de temps et de disponibilité,... Bref, plus on veut, plus fallait réfléchir avant.

De même, souhaitons-nous recourir à des outils qui ont fait leurs preuves depuis des années, des solutions toutes packagées, principalement hardware, ou bien préférerons-nous les versions plus intelligentes, plus intuitives, plus modulables ? Les alternatives sont nombreuses, et je ne les maîtrise pas toutes.

<strong>RAID</strong>. Voilà le premier point qu'il vous vient à l'esprit.

Un RAID (<em>Redundant Array of Inexpensive Disks</em>) est une agrégation de device de stockage qui permet d'avoir une <strong>tolérance</strong> aux éventuels accidents (panne, crash d'un disque dur,...) et qui améliore les performances d'accès aux données. En effet, composé de plusieurs disques, cela lui permet d'une part d'étaler les données sur l'ensemble des disques, mais en plus, et c'est vital, de rajouter des brides d'information concernant ces données tour à tour sur chacun des disques (RAID 5). Ces bribes d'information (bits de parité) sont stockés dans des <em>stripes</em> et servent à contrôler les données ajoutées et, au besoin, de les <strong>reconstruire</strong>. En conséquence, puisque ces données sont éclatées sur plusieurs disques, les temps d'accès en lecture et en écriture sont grandement améliorés.

Notre ami <a href="http://fr.wikipedia.org/wiki/RAID_%28informatique%29" target="_blank">Wiki</a> est toujours là pour vous.

Construire un RAID -logiciel, j'entends, puisqu'il n'y a jamais assez de moyens pour le tout packagé et qu'on est curieux de savoir ce qu'il y a sous le capot-, et surtout le maintenir, ce n'est pas de tout repos. Dans la meilleure des configurations, il vous faut <em>n </em>fois le même genre de disque dur (capacité, mémoire cache, vitesse, connectique), sinon le bonus de capacité qu'un disque pourrait avoir sur les autres sera jeté aux oubliettes. Il vous faut aussi, de préférence (mais c'est comme dans la vraie vie, tout est une histoire de bon matériel au bon moment) des disques en <strong>spare</strong>, histoire que vous ne soyez pas en position malheureuse si un autre "incident" survenait. De même, en cas de fail d'une unité du raid, la reconstruction des données peut prendre du temps.

Le RAID est une bonne solution concernant la scalabilité et la <strong>haute disponibilité</strong>, mais ce n'est pas un système de fichier, c'est une technologie. Vos meilleurs amis seront :
<ul>
	<li><em>mdadm</em> : monitorer, créer, gérer le raid,</li>
	<li><em>mkraid </em>: créer un raid,</li>
	<li><em>lsraid </em>: lister les composants du (des) raid(s),</li>
	<li><em>raidhotadd</em> : ajout à chaud de volume dans le raid,</li>
	<li><em>raidsetfaulty</em> : forcer la sortie d'une volume en le mettant en faulty,</li>
	<li><em>raidstop, raidstart,...</em></li>
	<li><em>mknod</em> : créer un fichier spécial block ou character</li>
	<li><em>/etc/raidtab</em> : fichier de configuration d'un raid (optionnel)</li>
	<li><em>/proc/mdstat</em> : fichier monitorant l'état du raid (pensez à watch pour le visionner en temps réel),</li>
	<li><em>/var/log/messages</em> : log système,</li>
	<li>tous les outils gérant le filesystem sous-jacent.</li>
</ul>
Resté sur votre faim ? <a href="http://www.tldp.org/HOWTO/Software-RAID-HOWTO-5.html" target="_blank&quot;">Par ici !</a>

Une autre façon de faire serait de passer par <strong>LVM</strong> (<em>Logical Volume Manager</em>).

La principale différence entre RAID et LVM, c'est que justement LVM n'est pas un RAID. LVM ne travaille pas directement sur les disques, mais sur des entités appelées <strong><em>Logical Volume</em>s</strong>, crées, maintenus et gérés par tout un arsenal d'outil rattachés au package <em>lvm2</em>. LVM apporte donc un niveau d'abstraction supplémentaire qui permet à vous, utilisateur et administrateur, de pouvoir redimensionner, créer, supprimer, étendre,... vos partitions sans avoir à vous soucier du hardware en dessous.

Plus en détail, LVM décompose le disque dur en <em>pv</em>, <em>physical volumes</em>, qu'il regroupe au sein d'un <em>vg</em>, <em>Volume Group</em>, et sur lequel il crée un <em>lv</em>, <em>Logical Volume</em>. C'est sur le <em>Logical Volume</em> que le filesystem s'installe, donc "quelque part" sur le <em>Volume Group</em>. Il est vraiment très facile d'étendre et de shrinker (réduire) l'espace disque.

LVM est très stable, éprouvé en production, modulable à souhait, un brin plus souple que le RAID, et plus que propice à la <strong>scalabilité</strong> mais en revanche, il n'aide pas niveau haute-disponibilité. Il est cependant possible d'utiliser LVM sur un RAID pour ajouter les avantages du RAID -et ses inconvénients par la même occasion- à ceux de LVM.

Les outils qui vous aideront :
<ul>
	<li><em>lvm2 </em>: le package de référence,</li>
	<li><em>pv{change||ck||create||display||move||remove||resize||display||scan||s}</em> : gestion des physical volumes (par exemple, <em>pvcreate /dev/sda2</em>),</li>
	<li><em>vg{cfgbackup||cfgrestore||change||ck||convert||create||display||export||extend||import
||merge||mknodes||reduce||remove||rename||s||scan||split}</em> : gestion des volume groups,</li>
	<li><em>lv{change||convert||create||display||extend||reduce||remove||rename||resize||s||scan}</em> : gestion des logical volumes,</li>
	<li><em>lvm{||change||diskscan||dump||sadc||sar}</em> : gestion lvm.</li>
</ul>
Si vous voulez en venir aux mains, <a href="http://doc.ubuntu-fr.org/lvm" target="_blank">faites</a>.

Le dernier point que je souhaiterais voir avec vous au niveau des extensibles et hautement disponibles, se cache sous trois lettres : ZFS.

<strong>ZFS</strong>, contrairement aux deux autres points, est un filesystem à part entière, il ne s'agit donc pas d'un outil. Zeta Filesystem, de son petit nom, a été développé par Sun. Ce système de fichier présente des caractéristiques très particulières mais n'est pas intégré au noyau Linux pour une raison simple : la licence sous lequel il est distribué (CDDL) est incompatible avec GPL dans sa version 2. Mais là encore, grâce à Ricardo Correia, développeur, nous pouvons utiliser ZFS via <strong>fuse</strong> (<em>filesystem in userspace</em>), environnement qui met à disposition, comme son nom l'indique, les fonctionnalités des filesystems dans l'espace User.

ZFS constitue un peu le fantasme de tout administrateur système. Il fait en sorte d'être toujours cohérent. Oui. Vous avez bien entendu. Il se corrige tout seul. Cette citation à elle seule, comme ça, sans preuve peut choquer. De même, il fournit une très haute capacité de stockage (nettement plus haute que tous les autres filesystems d'après notre ami Wiki). Voyons comment tout ça fonctionne.

Eh bien ZFS nous rappelle un peu le fonctionnement de LVM. En effet, notre filesystem s'appuie en réalité sur des <strong>pools</strong> de stockage. Les pools permettent, comme on l'a vu précédemment, d'éviter de se soucier du hardware, partionnement compris. Dans ZFS, ils sont utilisés pour centraliser les IO (entrées-sorties) et comme lien entre les différents périphériques de stockage. Lorsqu'une donnée est destinée à être écrite sur un disque, elle passe par le pool, à ce moment-là, elle est vérifiée à la volée, <strong>dupliquée</strong>, puis stockée. ZFS dispose donc de tous les éléments nécessaires pour <strong>contrôler</strong> à n'importe quel moment la cohérence et la véracité des données et va même jusqu'à corriger la donnée corrompue sans que vous ayez à le lui demander.

De la même manière, ZFS s'appuie sur du <strong>RAID Z</strong>, qui est un peu semblable à notre bon vieux RAID 5, à la différence que les stripes de données ont une largeur variable, de sorte que ZFS limite les pertes d'espace disque à leur origine.

Si vous avez envie d'en savoir plus, jetez un coup d'oeil sur le <a href="http://www.sun.com/software/solaris/zfs.jsp" target="_blank">site officiel</a>, la <a href="http://docs.sun.com/app/docs/doc/820-2315?l=fr" target="_blank">doc officielle</a>, et <a href="http://www.unixgarden.com/index.php/administration-systeme/zfs-sous-gnulinux" target="_blank">l'article d'Unix Garden</a> sur sa mise en place. Sachez aussi que ZFS est présent nativement sous <a href="http://www.opensolaris.com/" target="_blank">OpenSolaris</a>, version Open Source de Solaris.

Il existe beaucoup d'autres qui mériteraient d'être dans cette catégorie, mais j'arrêterais là. Sachez que je vous encourage à participer si vous estimez qu'il manque vraiment quelque chose.

C'est tout pour la première partie et encore !!! Je suis loin d'être exhaustive, même en me cantonnant à Linux.

Sur ce, potassez bien, farmez, complétez et n'oubliez pas de passer de Bonnes Fêtes -oui, un ASR aussi, ça se repose parfois- !!!]]></content:encoded>
			<wfw:commentRss>http://www.k-tux.com/nos-amis-les-filesystems-part-i/feed</wfw:commentRss>
		<slash:comments>1</slash:comments>
		</item>
	</channel>
</rss>

