Archives de la catégorie ‘Informatique’

BASH to SYSLOG

Publié: 29 juin 2015 dans Haute disponibilite

D’un point de vue sécurité, on peut être amené à scruter les commandes exécutées par les techniciens informatiques. On ne voit pas ici une sorte de BIG BROTHER, mais il peut arriver qu’un changement entraine des dysfonctionnements.

Dans ce cas, savoir qui a envoyé quelle commande et quand s’avère une source cruciale d’information.

La mise en œuvre est très simple.

1. Modification de /etc/bashrc

echo « export HISTTIMEFORMAT=’%F %T  »>>/etc/bashrc
echo « export PROMPT_COMMAND=’RETRN_VAL=\$?;logger -p local6.info \ »<LE TAG> : \$(whoami) [\$\
$]: \$(history 1 | sed \ »s/^[ ]*[0-9]\+[ ]*//\ » ) [\$RETRN_VAL]\ »‘ « >>/etc/bashrc

On ajoute un TAG <LE TAG> qui nous permettra de rediriger ces évènements vers un fichier SYSLOG particulier.

2. Modification dy fichier /etc/syslog-ng.conf

Notre serveur SYSLOG : monsyslog

sed -i ‘/# Redirection vers server de log/ d’ /etc/syslog.conf
sed -i ‘/\*.\*/ d’ /etc/syslog.conf
echo « #Log des commandes shell »>>/etc/syslog.conf
echo « local6.* @monsyslog »>>/etc/syslog.conf
echo «  »>>/etc/syslog.conf
echo « # Redirection vers server de log »>>/etc/syslog.conf
echo « *.* @monsyslog »>>/etc/syslog.conf

Et on redémarre le service SYSLOG

/etc/init.d/syslog restart

Publicités

Commandes Linux

Publié: 12 décembre 2013 dans Haute disponibilite

Espace disque :

Afficher l’occupation disque des 30 premiers dossiers les plus volumineux, triée par ordre croissant et afficher la somme :

du -sm  * | sort -nr | head -30 && du -sm  * | sort -nr | head -30 | awk '{somme+=$1} END {print somme}'
#!/bin/bash
# System-wide crontab file and cron job directory. Change these for your system. 
CRONTAB='/etc/crontab' 
CRONDIR='/etc/cron.d' 
# Single tab character. Annoyingly necessary. 
tab=$(echo -en "\t") 
# Given a stream of crontab lines, exclude non-cron job lines, replace 
# whitespace characters with a single space, and remove any spaces from the 
# beginning of each line. 
function clean_cron_lines() { 
    while read line ; do 
        echo "${line}" | 
            egrep --invert-match '^($|\s*#|\s*[[:alnum:]_]+=)' | 
            sed --regexp-extended "s/\s+/ /g" | 
            sed --regexp-extended "s/^ //" 
    done; 
} 
# Given a stream of cleaned crontab lines, echo any that don't include the 
# run-parts command, and for those that do, show each job file in the run-parts 
# directory as if it were scheduled explicitly. 
function lookup_run_parts() { 
    while read line ; do 
        match=$(echo "${line}" | egrep -o 'run-parts (-{1,2}\S+ )*\S+') 
        if [[ -z "${match}" ]] ; then 
            echo "${line}" 
        else 
            cron_fields=$(echo "${line}" | cut -f1-6 -d' ') 
            cron_job_dir=$(echo  "${match}" | awk '{print $NF}') 
            if [[ -d "${cron_job_dir}" ]] ; then 
                for cron_job_file in "${cron_job_dir}"/* ; do  # */ <not a comment> 
                    [[ -f "${cron_job_file}" ]] && echo "${cron_fields} ${cron_job_file}" 
                done 
            fi 
        fi 
    done; 
} 
# Temporary file for crontab lines. 
temp=$(mktemp) || exit 1 
# Add all of the jobs from the system-wide crontab file. 
[[ -f ${CRONTAB} ]] && cat "${CRONTAB}" | clean_cron_lines | lookup_run_parts >"${temp}"  
# Add all of the jobs from the system-wide cron directory. 
[[ -f ${CRONTAB} ]] && cat "${CRONTAB}" | clean_cron_lines | lookup_run_parts >"${temp}"  
# Add all of the jobs from the system-wide cron directory. 
[[ -d ${CRONDIR} ]] && ( cat "${CRONDIR}"/* 2> /dev/null | clean_cron_lines >>"${temp}" ||  true ) # */ <not a com
ment>
# Add each user's crontab (if it exists). Insert the user's name between the 
# five time fields and the command. 
while read user ; do 
    crontab -l -u "${user}" 2>/dev/null | 
        clean_cron_lines | 
        sed --regexp-extended "s/^((\S+ +){5})(.+)$/\1${user} \3/" >>"${temp}" 
done < <(cut --fields=1 --delimiter=: /etc/passwd) 
# Output the collected crontab lines. Replace the single spaces between the 
# fields with tab characters, sort the lines by hour and minute, insert the 
# header line, and format the results as a table. 
cat "${temp}" | 
    sed --regexp-extended "s/^(\S+) +(\S+) +(\S+) +(\S+) +(\S+) +(\S+) +(.*)$/\1\t\2\t\3\t\4\t\5\t\6\t\7/" | 
    sort --numeric-sort --field-separator="${tab}" --key=2,1 | 
    sed "1i\mi\th\td\tm\tw\tuser\tcommand" | 
    column -s"${tab}" -t 
rm --force "${temp}"

1. Pourquoi mettre en place un cluster failover DHCP ?

Nous avons vu dans l’article consacré à l’implémentation d’un serveur DHCP que cet élément d’infrastructure fournit la configuration réseau des postes de travail (et serveurs si vous le souhaitez). AInsi, lorsqu’une station de travail démarre ou renouvelle son bail, elle s’adresse au serveur DHCP qui se charge de lui fournir sa configuration et son bail.

Que se passe-t-il si le serveur est down ? les stations de travail déjà configurée ne modifieront pas leur configuration. Par contre, les nouvelles machines se retrouveront avec une adresse IP en 169.1.1.1 et ne pourront pas se connecter au réseau.

2. Préparation des serveurs DHCP

Nous installerons 2 serveurs DHCP identiques (cf DHCP – Dynamic Host Configuration Protocol).

Les deux serveurs DHCP1 et DHCP2 doivent être synchronisées (cf NTP : Serveur de temps)

Rappel :

Pour ce faire, vous devez tout d’abord installer le service NTPD sur chacun des  serveurs à synchroniser, puis les configurer comme suit :

Dans le fichier /etc/ntp.conf, ajoutez :
server adresse IP de votre serveur de temps
puis redémarrez votre service NTPD.

A ce stade, vous disposez de deux serveurs DHCP, synchronisés sur la même horloge et qui fournissent tous deux la même plage d’IP.

Si une station de travail se connecte à cet instant, elle prendra sa configuration auprès du serveur DHCP qui répondra le plus rapidement. Nous verrons ensuite le mode de fonctionnement en cas de fourniture d’une adresse IP déjà occupée.

3. Configuration du cluster failover

DHCP1 et DHCP ont le fichier de configuration /etc/dhcp3/dhcpd.conf suivant :

On suppose que DHCP1 a l’adresse IP 192.168.1.21 et DHCP2 à l’adresse IP 192.168.1.22

Fichier de configuration de base :

option domain-name "mondomaine.priv";
option domain-name-servers 192.168.0.10, 194.168.0.11;
option routers 192.168.0.1;
default-lease-time 3600;
max-lease-time 3600;

authoritative; 

subnet 192.168.0.0 netmask 255.255.255.0 {
 range 192.168.0.200 192.168.0.254;
}

Configuration de DHCP1 :

option domain-name "mondomaine.priv";
 option domain-name-servers 192.168.0.10, 194.168.0.11;
 option routers 192.168.0.1;
 default-lease-time 3600;
 max-lease-time 3600;
 authoritative;
 
failover peer "dhcp-failover" {
 primary;
 address 192.168.0.21;
 port 647;
 peer address 192.168.0.22;
 peer port 847;
 max-response-delay 60;
 max-unacked-updates 10;
 load balance max seconds 3;
 mclt 3600;
 split 128;
 }
subnet 192.168.0.0 netmask 255.255.255.0 {
 range 192.168.0.200 192.168.0.254;
 }

Configuration de DHCP2 :

option domain-name "mondomaine.priv";
option domain-name-servers 192.168.0.10, 194.168.0.11;
option routers 192.168.0.1;
default-lease-time 3600;
max-lease-time 3600;
authoritative;
 
failover peer "dhcp-failover" {
 secondary;
 address 192.168.0.22;
 port 847;
 peer address 192.168.0.21;
 peer port 647;
 max-response-delay 60;
 max-unacked-updates 10;
 load balance max seconds 3;
 }
subnet 192.168.0.0 netmask 255.255.255.0 {
 range 192.168.0.200 192.168.0.254;
 }

puis :

DHCP1 # /etc/init.d/dhcp3server restart   
DHCP2 # /etc/init.d/dhcp3server restart 

Différence entre DHCP1 et DHCP2 : pour DHCP1, on indique en premier l’adresse IP du primaire et ensuite l’adresse IP du pair (secondaire).
On ajoute (uniquement pour le primaire) les paramètres mclt et split.
Pour DHCP2, on indique l’adresse IP du secondaire puis l’adresse IP du pair (primaire).

3. Mode de fonctionnement

En temps normal, le serveur DHCP1 est le seul serveur DHCP à répondre. Il détient l’autorité pour fournir les configurations réseaux et la « base de données » des adresses IP attribuées.

Le serveur DHCP1 s’arrête alors le serveur DHCP2 devient autoritée. Il détient l’autorité pour fournir les configurations réseaux et la « base de données » des adresses IP attribuées. Attention : cette « base de données » est alors VIDE.

Lorsqu’une station de travail se présente et demande sa configuration IP, le serveur lui attribue une adresse IP « disponible ». SI cette dernière est en cours d’utilisation, la station de travail renvoi un message DHCPDECLINE. Le serveur secondaire enregistre que l’adresse IP est utilisée et attribue une autre adresse IP « disponible ».

1. Gestion des utilisateurs sous Unix/Linux

Unix est multi-utilisateurs. Pour cette raison, tout le monde ne peut pas tout faire, à part l’administrateur système (traditionnellement nommé root), qui à le droit de lire et d’écrire tous les fichiers de tous les répertoires.

Chaque utilisateur est désigné de manière unique par son login (son « nom »). De plus, chaque utilisateur appartient à un ou plusieurs groupes. Par exemple, sous Red Hat Linux, chaque utilisateur est par défaut seul membre de son groupe personnel et membre du groupe users. Ainsi, sur ma machine, j’ai un utilisateur damien qui est membre des groupes damien et users. L’intêret d’avoir chaque utilisateur unique membre d’un groupe dépasse le cadre de cet article.

Un fichier ou un répertoire appartient toujours à un utilisateur et à un groupe. D’autre part, un fichier peut être accessible en lecture, en écriture et en exécution. Les permissions sont distinctes pour l’utilisateur propriétaire du fichier, pour le groupe propriétaire et pour le reste du monde. Ces permissions sont affichées par la commande ls quand on lui passe l’option -l:

-rw-r--r--  1 damien   users  297 Jun 07 10:31 toto

Cette ligne signifie que le fichier toto appartient à l’utilisateur damien et au groupe users, avec les droits -rw-r--r--. Les autres valeurs (1, 297 et la date) ne nous intéressent pas ici.

Décryptage des droits -rw-r–r– : le premier caractère représente le type de fichier: « – » pour un fichier normal, « d » pour un répertoire, « p » pour un tube, « b » ou « c » pour un périphérique, « l » pour un lien symbolique.

Les trois suivants représentent les droits de l’utilisateur propriétaire du fichier.

  • « r » représente le droit de lecture,
  • « w » le droit d’écriture
  • « x » le droit d’exécution

Ici, « rw- » signifie que l’utilisateur damien peut lire et écrire dans le fichier, mais pas l’exécuter.
Les trois caractères suivants représentent les permissions du groupe; ici, tous les membres du groupe users peuvent lire le fichier, mais pas y écrire.
Enfin, les trois derniers caractères ont une signification analogue pour le reste du monde.

Une astruce mnémotechnique : pensez au prénom HUGO et vous retrouverez UGO : User, Group, Other

Une petite nuance pour les répertoires: si un utilisateur a le droit d' »exécution » sur un répertoire, cela signifie qu’il peut y entrer avec la commande cd ou équivalent.

Comment fixer les droits : on a vu que les droits d’accès sont fixés pour UGO et sont en rwx.

  rwx
  ||+-- 1
  |+--- 2
  +---- 4

Ainsi, fixer les droits sur un répertoire ou un fichier peut être synthétiser par en additionnant les valeurs pour chaque UGO.

Par exemple, un groupe « rwx » est représenté par 4+2+1=7. Un groupe « r– » par 4+0+0=4. Un groupe « –x » par 0+0+1=1. Ainsi, les permissions rw-r--r-- de notre fichier toto s’écrivent 644.

Fixer les droits :

chmod 644 toto

2. Setuid sur un script Shell ou un programme

Rappel : une ligne de commande précédée par $ indique un utilisateur lambda. Une ligne de commande précédée par # indique que cette commande est exécutée par l’utilisateur ROOT

Dans l’exemple ci-dessous, on modifie les droits du script monshell.sh par un SETUID=4 (on fixe l’utilisateur d’exécution à ROOT) :

# chown root:root monshell.sh
# chmod 4755 monshell.sh
# exit
$ ./monshell.sh

L’utilisateur exécute ici le script monshell.sh avec les droits ROOT et ce, bien que n’étant pas dans le groupe ROOT !

1. Pourquoi mettre en oeuvre un serveur DHCP ?

DHCP signifie Dynamic Host Configuration Protocol.

Il s’agit d’un protocole qui permet à un ordinateur qui se connecte sur un réseau IP d’obtenir dynamiquement et automatiquement sa configuration IP. Le but principal étant la simplification de l’administration d’un réseau.

Le serveur DHCP fournit des adresses IP au format IPv4 (ex : 192.168.0.1/24) mais peut tout à fait fournir au format IPv6. Tout est question de configuration et de taille de parc informatique.

Comme tout protocole, DHCP est régit par des RFCs qui sont :

– RFC951 : Bootp
– RFC1497 : Options vendor extensions
– RFC1541 : Définition du protocole Dhcp
– RFC1542 : Interaction entre Bootp et Dhcp
– RFC2131 : Complément à la Rfc 1541
– RFC2132 : Complément aux options vendor extensions

2. Elément de l’infrastructure de votre système d’information

Vous l’aurez compris, le serveur DHCP est un élément fondamental de votre infrastructure. Néanmoins, j’émets une réserve sur la suite du document.

En effet, ce tutoriel vous guidera sur l’installation, la configuration et le maintien en conditions opérationnelles d’un serveur DHCP sous Linux.

Or, si dans votre infrastructure vous disposez également de services à publier, comme Exchange par exemple, je vous conseille d’utiliser le serveur DHCP intégré à l’Active Directory. Ce dernier offre plusieurs interfaces entre votre AD, votre serveur de messagerie et vos stations de travail.

3. Mode de fonctionnement

Le protocole DHCP repose sur 8 types de requêtes :

DHCPDISCOVER : permet aux clients de localiser les serveurs DHCP (ils obtiennent l’adresse IP du serveur DHCP qui réponds le plus rapidement)
DHCPOFFER : réponse du serveur qui fournit les premiers paramètres
DHCPREQUEST : requête du client pour prolonger son bail
DHCPDECLINE : le client annonce au serveur que l’adresse IP fournie par le serveur est déjà utilisée
DHCPACK : réponse du serveur au client avec les paramètres IP
DHCPNACK : réponse du serveur pour annoncer au client que le bail est échu ou que le serveur acquite le message DHCPDECLINE : message envoyé par le client au serveur et l’informant que l’adresse IP fournie est déjà utilisée
DHCPRELEASE : le client relache son adresse IP
DHCPINFORM : message du client qui demande les paramètres locaux. Le client a déjà son adresse IP

La première requête émise par le client est un message DHCPDISCOVER. Le serveur répond par un DHCPOFFER, en particulier pour soumettre une adresse IP au client. Le client établit sa configuration, demande éventuellement d’autres paramètres, puis fait un DHCPREQUEST pour valider son adresse IP. Le serveur répond simplement par un DHCPACK avec l’adresse IP pour confirmation de l’attribution. Normalement, c’est suffisant pour qu’un client obtienne une configuration réseau efficace, mais cela peut être plus ou moins long selon que le client accepte ou non l’adresse IP ou demande des infos complémentaires…

4. Installation du serveur DHCP

Très simple à installer, ouvrez un shell en tant que ROOT, puis :

# apt-get install dhcp3-server

Par défaut, votre nouveau serveur DHCP écoutera sur la première interface réseau (c à d eth0). Pour corriger cette configuration :

# dpkg-reconfigure dhcp3-server

ou

Modifiez le fichier de configuration /etc/default/dhcp3-server

5. Configuration du serveur

Le fichier de configuration du serveur dhcp est « /etc/dhcp3/dhcpd.conf »

Je conseille pour commencer de faire une copie de sauvegarde de ce fichier. Ensuite, vous pouvez effacer ou commenter les lignes existantes et ajouter les lignes suivantes :

option domain-name "mondomaine.priv";
option domain-name-servers 192.168.0.10, 194.168.0.11;
option routers 192.168.0.1;
default-lease-time 3600;
max-lease-time 3600;
authoritative;

subnet 192.168.0.0 netmask 255.255.255.0 {
     range 192.168.0.200 192.168.0.254;
 }

La première ligne permet de fournir aux clients le nom du domaine.

La ligne suivante donne aux clients le ou les serveurs DNS.

La ligne suivante donne l’adresse de la passerelle par défaut

La ligne suivante donne le délai du bail en secondes. Il est préférable d’augmenter la valeur par défaut pour limiter le trafic sur le réseau.

Le max-lease-time est le temps maximum de votre bail. Si vous configurez un default-lease-time à 10000 secondes et un max-lease-time à 4000 secondes, vos clients auront un bail maximum de 4000 secondes.Les 4 dernières lignes permettent d’indiquer la plage d’adresses gérée par le serveur dhcp :

La ligne «  authoritative  » permet d’indiquer que le serveur DHCP sera responsable de la zone concernée

Une fois la configuration terminée, il faut démarrer ou redémarrer le démon pour prendre en compte les modifications :

# /etc/init.d/dhcp3-server restart

Si le démarrage retourne une erreur, il faut penser à consulter les logs :

# tail -f /var/log/syslog

Le fichier suivant donne la liste des adresses IP délivrées par le serveur.

Pour chaque adresse IP l’on retrouve : son adresse mac, le nom de l’ordinateur, la date de début et de fin du bail :

/var/lib/dhcp3/dhclient.leases 

6. Configuration avancée

  • Configuration des logs : ajouter dans /etc/dhcp3/dhcpd.conf l’instruction : log-facility local7

L’instruction log-facility local7 indique un fichier de log de niveau debug mais toujours dans le fichier /var/log/syslog.

On sépare ensuite les logs DHCP dans un fichier nommé dhcpd.log.

Dans le fichier /etc/syslog.conf :

local7.*     /var/log/dhcpd.log

Onrelance le daemon syslog :

# /etc/init.d/sysklogd restart
  • DNS dynamique
### DNS Dynamique
 ddns-updates on;
 ddns-update-style interim;
 ### Pour autoriser les adresses fixes à s'inscrire dans le DNS
 update-static-leases on;
 ddns-domainname "mondomaine.priv";
  • Plusieurs zones DNS

Vous pouvez ajouter les différentes zones DNS (ex : chezmoi.mondomaine.priv, monvoisin.mondomaine.priv, toto.mondomaine.priv). L’intérêt est de permettre une résolution plus rapide.

Ajouter dans le fichier /etc/dhcp3/dhcpd.conf :

# zone chezmoi.mondomaine.priv pour résolution rapide
 zone monvoisin.mondomaine.priv. {
 primary 100.11.0.10;                                                #serveur DNS primaire de la zone chezmoi.mondomaine.priv
 }
# zone monvoisin.mondomaine.priv pour résolution rapide
 zone monvoisin.mondomaine.priv. {
 primary 101.11.0.10;                                               #serveur DNS primaire de la zone monvoisin.mondomaine.priv
 }
# zone toto.mondomaine.priv pour résolution rapide
 zone monvoisin.mondomaine.priv. {
 primary 102.11.0.10;                                               #serveur DNS primaire de la zone toto.mondomaine.priv
 }
  • Auto-configuration du proxy
### Autodetection du proxy
 option wpad-url code 252 = text;
 option wpad-url "http://monserveurapache/proxy.pac";

### Autodetection du proxy
option local-pac-server code 252 = text;
option local-pac-server "http://proxy/wpad.dat";

7. Comment avoir des IP fixes avec un serveur DHCP

Le protocole DHCP offre la possibilité d’attribuer un adresse IP fixe à un ordinateur configuré en DHCP.

Cas d’utilisation : une station de travail avec un accès particulier, un serveur

Pour cela, il faut ajouter dans le fichier /etc/dhcp3/dhcpd.conf, de nouvelles lignes.

L’exemple suivant permet de fixer une adresse IP en fonction de son adresse MAC :

host MASTATION  {
 hardware ethernet 00:11:22:33:aa:bb;
 fixed-address 192.168.0.110;
 }

Redémarrer le démon pour prendre en compte les modifications :

/etc/init.d/dhcp3-server restart

8. Configuration des postes clients

  • OS Linux :
  • Fichier de configuration : /etc/network/interfaces
  • Contenu :

auto lo eth0
iface lo inet loopback
iface eth0 inet dhcp

  • Post-installation :
# /etc/init.d/networking restart
  • OS Windows :

Menu Démarrer >> Panneau de configuration >> Réseau

Cliquez sur « Obtenir une adresse IP dynamiquement

9. Comment vérifier que le client est correctement configuré

Sur un poste client linux, la commande suivante, permet de connaître la configuration IP et également de retrouver l’adresse MAC :

ifconfig

Sur un poste client Windows, la commande est la suivante :

ipconfig /all

La consultation des logs sur le serveur en temps réel (avec le paramètre -f), permet également de vérifier que tout fonctionne correctement :

tail -f /var/log/message

La virtualisation d’un système d’exploitation permet aujourd’hui d’exploiter au mieux les configurations matérielles disponibles de nos jours. Je pense principalement à la multiplication des coeurs au sein d’un même serveur et de la RAM qui les accompagne.

La virtualisation peut alors s’appuyer sur VMware, Microsoft ????, ou encore sur LXC.

D’ailleurs, on ne parle plus de VM ou de machine virtuelle mais plutôt de container 😉

1. Installation

# apt-get install lxc bridge-utils libvirt-bin debootstrap

2. Configuration

2.1 Cgroups

cgroups (control groups) est une fonctionnalité du noyau Linux pour limiter, compter et isoler l’utilisation des ressources (processeur, mémoire, utilisation disque, etc.). Pour plus de détails : wikipédia

Dans le fichier /etc/fstab : ajoutez la ligne suivante

## LXC
cgroup    /sys/fs/cgroup    cgroup    defaults    0    0

puis

# mount -a

2.2 Réseau

Commentez la configuration de votre carte réseau eth0

# The loopback network interface
auto lo
iface lo inet loopback

# The primary network interface
#allow-hotplug eth0
#iface eth0 inet static
#address x.x.x.x
#netmask y.y.y.y
#gateway    x.x.x.x
#network x.x.x.x

Ajoutez la configuration de votre nouvelle interface bridge ci-dessous :

auto br0
iface br0 inet static
       bridge_ports eth0
       bridge_fd 0
       address x.x.x.x
       netmask y.y.y.y
       network x.x.x.x
       broadcast x.x.x.x
       gateway x.x.x.x
       # dns-* options are implemented by the resolvconf package, if installed
       dns-nameservers x.x.x.x
       dns-search votre.domaine.dns

2.3 Réseau virtuel

# virsh -c lxc:/// net-define /etc/libvirt/qemu/networks/default.xml
# virsh -c lxc:/// net-start default
# virsh -c lxc:/// net-autostart default
# virsh -c lxc:/// net-edit default

exemple : ici un range d

<network>
  <name>default</name>
  <uuid>961c5bb4-6023-2485-dc64-140ee33d59f0</uuid>
  <forward mode='nat'/>
  <bridge name='virbr0' stp='on' delay='0' />
  <ip address='192.168.122.1' netmask='255.255.255.0'>
    <dhcp>
      <range start='192.168.122.2' end='192.168.122.254' />
    </dhcp>
  </ip>
</network>

2.4 Vérification

# lxc-checkconfig

qui donne :

Kernel config /proc/config.gz not found, looking in other places…
Found kernel config file /boot/config-3.2.0-4-686-pae
— Namespaces —
Namespaces: enabled
Utsname namespace: enabled
Ipc namespace: enabled
Pid namespace: enabled
User namespace: enabled
Network namespace: enabled
Multiple /dev/pts instances: enabled

— Control groups —
Cgroup: enabled
Cgroup clone_children flag: enabled
Cgroup device: enabled
Cgroup sched: enabled
Cgroup cpu account: enabled
Cgroup memory controller: enabled
Cgroup cpuset: enabled

— Misc —
Veth pair device: enabled
Macvlan: enabled
Vlan: enabled
File capabilities: enabled

Note : Before booting a new kernel, you can check its configuration
usage : CONFIG=/path/to/config /usr/bin/lxc-checkconfig

Tout est au vert ?

Vous voici désormais avec une plate-forme de virtualisation opérationnelle.

Voyons comment l’administrer :

3. Création d’un container

# lxc-create -n <moncontainer> -t debian

Un container est créé et enregistré sous /var/lib/lxc/moncontainer.

Exemple :

# lxc-create -n proxy -t debian

puis :

Sélection_001

Sélection_002

Sélection_003

Sélection_004

Sélection_005

Sélection_006

Sélection_007

Sélection_008

Sélection_009

Mais attention, ce container n’est pas immédiatement opérationnel.

En effet, les accès consoles, réseaux, … ne sont pas configurés.

4. Correction/activation du container

4.1 Console

La gestion de la console LXC pose un problème.

Lors de son lancement #lxc-console -n <moncontainer>, le message suivant apparaît :

Type <Ctrl+a q> to exit the console, <Ctrl+a Ctrl+a> to enter Ctrl+a itself

et vous ne pouvez plus vous loguer !!!

En effet, de prime à bord vous ne pouvez pas vous connecter à la console sans avoir au préalable effectué une petite opération.

# chroot /var/lib/lxc/moncontainer/rootfs
# mknod -m 666 /dev/tty1 c 4 1
# mknod -m 666 /dev/tty2 c 4 2
# mknod -m 666 /dev/tty3 c 4 3
# mknod -m 666 /dev/tty4 c 4 4
# mknod -m 666 /dev/tty5 c 4 5
# mknod -m 666 /dev/tty6 c 4 6

4.2 Languages – Locales

Par défaut, le container est créé sans configuration des locales, donc : Démarrez le container en console :

# lxc-start -n moncontainer -d
# lxc-console -n moncontainer

Loguez-vous sous ROOT, puis :

# locale-gen en_US en_US.UTF-8 fr_FR.UTF-8
# dpkg-reconfigure locales

4.3 Quelques outils manquants

# apt-get install dnsutils man locate rsyslog gcc

5. Démarrage automatique

ln -s /var/lib/lxc/<monnouveaucontainer>/config /etc/lxc/auto/<monnouveaucontainer>

et voilà …

6. Administration

6.1 Fichiers et dossiers

  • Dossier de stockage de vos containers : /var/lib/lxc/
  • Configuration de votre container : /var/lib/lxc/<votre container>/config
# /var/lib/lxc/moncontainer/config

## Container
lxc.utsname                             = moncontainer

lxc.rootfs                              = /var/lib/lxc/moncontainer/rootfs
#lxc.console                            = /var/log/lxc/moncontainer.console
lxc.tty                                 = 6
lxc.pts                                 = 1024

## Capabilities
lxc.cap.drop                            = mac_admin
lxc.cap.drop                            = mac_override
lxc.cap.drop                            = sys_admin
lxc.cap.drop                            = sys_module
## Devices
# Allow all devices
#lxc.cgroup.devices.allow               = a
# Deny all devices
lxc.cgroup.devices.deny                 = a
# Allow to mknod all devices (but not using them)
lxc.cgroup.devices.allow                = c *:* m
lxc.cgroup.devices.allow                = b *:* m

# RESEAU
lxc.network.type = veth
lxc.network.flags = up
lxc.network.link = br0
lxc.network.name = eth0
lxc.network.ipv4 = x.x.x.x/24
lxc.network.veth.pair = vethvm2
lxc.network.hwaddr = 00:FF:AA:00:00:02

# /dev/console
lxc.cgroup.devices.allow                = c 5:1 rwm
# /dev/fuse
lxc.cgroup.devices.allow                = c 10:229 rwm
# /dev/null
lxc.cgroup.devices.allow                = c 1:3 rwm
# /dev/ptmx
lxc.cgroup.devices.allow                = c 5:2 rwm
# /dev/pts/*
lxc.cgroup.devices.allow                = c 136:* rwm
# /dev/random
lxc.cgroup.devices.allow                = c 1:8 rwm
# /dev/rtc
lxc.cgroup.devices.allow                = c 254:0 rwm
# /dev/tty
lxc.cgroup.devices.allow                = c 5:0 rwm
# /dev/urandom
lxc.cgroup.devices.allow                = c 1:9 rwm
# /dev/zero
lxc.cgroup.devices.allow                = c 1:5 rwm

## Limits
#lxc.cgroup.cpu.shares                  = 1024
#lxc.cgroup.cpuset.cpus                 = 0
#lxc.cgroup.memory.limit_in_bytes       = 256M
#lxc.cgroup.memory.memsw.limit_in_bytes = 1G

## Filesystem
lxc.mount.entry                         = proc /var/lib/lxc/moncontainer/rootfs/proc proc nodev,noexec,nosuid 0 0
lxc.mount.entry                         = sysfs /var/lib/lxc/moncontainer/rootfs/sys sysfs defaults,ro 0 0
#lxc.mount.entry                        = /srv/moncontainer /var/lib/lxc/moncontainer/rootfs/srv/moncontainer none defaults,bind 0 0

5.2 Commandes

  • lxc-list : liste l’ensemble des containers et donne leur état (Running, Frozen, Stopped)
  • lxc-ls -Al : liste l’ensemble des fichiers et répertoires des containers. Mêmes options que la commande ls
  • lxc-start : démarre un container (ex: # lxc-start -d -n moncontainer). L’option -d permet l’exécution du container en démon
  • lxc-halt : arrête proprement un container (ex: # lxc-halt -n moncontainer)
  • lxc-stop : stoppe le container (ex: # lxc-stop -n moncontainer)
  • lxc-console : ouvre une console de connexion locale à un container (ex : # lxc-console -n moncontainer)Attention : si le prompt ne s’affiche pas, alors le paragraphe n° 4
  • lxc-info : affiche l’état d’un container et son PID (ex: # lxc-info -n moncontainer)
  • lxc-ps : affiche les processus de chaque container
  • lxc-create : crée un container (ex: # lxc-create -n monnouveaucontainer -t debian)
  • lxc-destroy : supprime un container

7. Problèmes rencontrés et solutions

71 SSH

Le serveur SSH est installé mais sa configuration est incomplète. En effet il manque les fichiers ssh_host_dsa_key et ssh_host_rsa_key.

# lxc-console -n serveur
# cd /etc/ssh
# ssh-keygen -t dsa -f ssh_host_dsa_key
# ssh-keygen -t rsa1 -f ssh_host_rsa_key
# /etc/init.d/ssh restart

7.2 Interface réseau

L’interface réseau et la route ne sont pas configurées.

Ajouter dans /etc/network/interface

iface eth0 inet static
address 192.168.1.201
mask 255.255.255.0
gatewau 192.168.1.1

et pour la route :

route add -net 0.0.0.0 gw 192.168.1.1 dev eth0

… et on redémarre : ctrl+a q      lxc-stop -n <moncontainer>

7.3 Paquets manquants

Bon nombre de paquets manquent à l’appel. On notera particulièrement : vi, nano