Article publié le 14 Août 2017

Article mis à jour le 17 Janvier 2018

J’ai eu l’occasion de tester pas mal d’ordonnanceur et j’ai remarqué que la plupart du temps les solutions du marché sont onéreuses, difficile à mettre en place et dur à maîtriser.

C’est pour ces raisons que j’ai été impressionné par la solution Rundeck.

Cet ordonnanceur open-source est extrêmement simple à mettre en place et à administrer. De plus énormément de plugins sont disponible ce qui permet de bénéficier d’un paquet de fonctionnalités supplémentaire (intégration d’Ansible, etc…)

1) Installation

Sous Debian/Ubuntu:

Installez Java:

apt-get install openjdk-8-jdk

Télécharger le paquet DEB sur le site officiel de Rundeck et installez le.

dpkg -i <nom du paquet>

Sous RedHat/Centos:

Installez Java:

yum install java-1.8.0-openjdk

Installez Rundeck

rpm -Uvh http://repo.rundeck.org/latest.rpm
yum install rundeck

Une fois l’installation terminée, démarrez le service rundeck:

service rundeckd start

Pour accéder à l’interface d’administration, connectez vous àl’URL suivante: <IP ou nom de la machine>:4440

Login et mot de passe par défaut: admin/admin

Si vous avez des difficultés à vous authentifiez (erreur 404 après avoir saisi les identifiants), lisez la suite de ce tutoriel.

2) Configuration

2.1) Paramétrage de la base de donnée

Par défaut, Rundeck utilise une base de donnée SqlLite. Il est préférable d’utiliser une base de donnée MySQL afin d’éviter de futures problèmes de performances:

# Sous Debian/Ubuntu

apt-get install mysql-server*

# Sous RedHat/Centos

yum install mysql

Authentifiez vous sur votre base mysql en root

mysql -uroot -p<votre password>

Créons ensuite la base de données rundeck:

CREATE database rundeck;

CREATE USER ‘rundeck’@’localhost’ IDENTIFIED BY ‘rundeck’;

GRANT ALL PRIVILEGES ON rundeck.* TO ‘rundeck’@’localhost’;

FLUSH PRIVILEGES;

Utilisez un mot plus sécurisé bien évidemment 😉

Éditez ensuite le fichier /etc/rundeck/rundeck-config.properties et modifiez les lignes suivantes:

grails.serverURL=http://<IP ou DNS de votre machine>:4440

dataSource.dbCreate = update
dataSource.url = jdbc:mysql://localhost/rundeck?autoReconnect=true
dataSource.username = rundeck
dataSource.password = rundeck
dataSource.driverClassName=com.mysql.jdbc.Driver

Redémarrez ensuite rundeck:

service rundeckd restart

2.2) Génération clés SSH

Afin de lancer un job sur une machine spécifique rundeck le protocole SSH.

Il est donc nécessaire de générer une clé privée via la commande « ssh-keygen » et de la coller dans le répertoire /var/lib/rundeck/.ssh

ssh-keygen

mkdir /var/lib/rundeck/.ssh

cp id_rsa /var/lib/rundeck/.ssh

chown -R rundeck:rundeck /var/lib/rundeck/.ssh

La clé publique (le fichier avec l’extension « .pub » généré par la commande ssh-keygen) sera a coller sur chaque machine cible dans le fichier authorized_keys du user système qui exécutera le job.

2.3 Création de votre premier job

Connectez-vous sur l’interface WEB de rundeck (<IP ou nom de la machine>:4440) et authentifiez vous (admin/admin par défaut).

Cliquez sur le bouton new projet afin de créer votre premier projet.

Renseignez le nom de votre projet et cliquez sur le bouton « create » en laissant tous les autres paramètres par défaut:

Cliquez ensuite sur le bouton « create a new job »:

Indiquez tout en haut de la page le nom de votre job et positionnez vous ensuite sur l’encadré « add a step ».

C’est à ce niveau que tout se joue!

Vous pouvez lancer une commande ou exécutez un script sur une machine distante comme l’exemple ci-dessous.

La partie matched nodes correspond aux machines sur lequelles vous voulez exécutez  vos jobs/workflow. Par défaut seul localhost est paramétré. Pour rajouter une machine vous devez éditer le fichier

/var/rundeck/projects/<nom de votre projet>/etc/resources.xml et ajoutez vos machines en respectant la synthaxe XML suivante:

<project>
<node name= »nom de votre machine 1″ description= »votre description » tags= » » hostname= »<adresse ou ip de votre machine » osArch= »amd64″ osFamily= »unix » osName= »Linux » osVersion= »votre distrib » username= »user qui execute votre job sur votre machine »/>
<node name= »nom de votre machine 2″ description= »votre description » tags= » » hostname= »<adresse ou ip de votre deuxième machine » osArch= »amd64″ osFamily= »unix » osName= »Linux » osVersion= »votre distrib » username= »user qui execute votre job sur votre machine »/>
</project>

Enregistrez vos modifications et normalement de nouveaux nodes devraient apparaître (Si ce n’est pas le cas rafraîchissez la page).

Vous avez désormais les bases pour vous lancer. Rundeck est un ordonnanceur très complet et il me serait impossible de vous expliquer chaque fonctionnalité. L’interface étant très intuitive, il vous sera très facile de trouver les fonctions dont vous avez besoin.

3) Sauvegardes/restaurations

tuto | sauvegardez vos instances rundeck

4) Supervisez vos jobs Rundeck

Monitoring | Superviser vos jobs rundeck

5) Purger les logs d’exécutions Rundeck

Script | Purger les logs d’exécution Rundeck

Article publiée le 19 Juin 2017

Pour ceux qui l’ignore encore, une nouvelle version de debian est disponible en version final depuis le 17 Juin 2017.

Ci-dessous la liste des nouveautés (Sources : https://www.debian.org):

• Apache 2.4.25
• Asterisk 13.14.1
• Chromium 59.0.3071.86
• Firefox 45.9 (in the firefox-esr package)
• GIMP 2.8.18
• an updated version of the GNOME desktop environment 3.22
• GNU Compiler Collection 6.3
• GnuPG 2.1
• Golang 1.7
• KDE Frameworks 5.28, KDE Plasma 5.8, and KDE Applications 16.08 and 16.04 for PIM components
• LibreOffice 5.2
• Linux 4.9
• MariaDB 10.1
• MATE 1.16
• OpenJDK 8
• Perl 5.24
• PHP 7.0
• PostgreSQL 9.6
• Python 2.7.13 and 3.5.3
• Ruby 2.3
• Samba 4.5
• systemd 232
• Thunderbird 45.8
• Tomcat 8.5
• Xen Hypervisor
• the Xfce 4.12 desktop environment

Ci-dessous la procédure pour mettre à jour votre Debian Jessie:

• Vérifiez que votre OS est à jour

apt-get update && apt-get upgrade

• On remplace les dépôts Jessie par les dépôts Stretch

sed -i ‘s|jessie|stretch|’ /etc/apt/sources.list && apt-get update

• Si vous avez message d’avertissement concernant une clé:

• Installez le paquet suivant:

apt install debian-archive-keyring

• Enfin  vous pouvez lancez la mise à niveau

apt-get dist-upgrade

• Une fois la mise à niveau terminée, redémarrez votre machine puis vérifiez que tout c’est bien passé:

Enjoy!

Article publiée le 7 Juin 2017

WildFly est un fork opensource de Jboss. Ce serveur d’application Java EE représente une alternative à crédible par rapport aux autres serveurs d’application JAVA type weblogic, websphère (tutoriel d’installation disponible ici), Jboss, etc…

Ce tutoriel explique comment installer et configurer rapidement un serveur WildFly afin qu’il soit opérationnel. Nous ne rentrerons pas dans les fonctionnalités avancées du produit.

1) Installation

Avant toute chose, Wildfly doit être exécuté via un user système dédié (surtout pas en root!).

Le choix de la distribution importera peu (Debian/Ubuntu ou Centos/RedHat feront très bien l’affaire). Assurez que JAVA soit installé sur votre serveur.

• Authentifiez vous ensuite en tant que user wildfly (ou celui que vous avez créé)

su – wildfly

• Téléchargez ensuite la dernière version de WildFly sur le site officiel (au moment ou ce tutoriel a été rédigé, la version 10.1.0 été en version stable.): http://wildfly.org/downloads/
• Éditez le fichier .bashrc afin de mettre à jour les variables d’environnement $JAVA_HOME et $PATH.

export JAVA_HOME=<chemin d’installation de JAVA>
export PATH=$JAVA_HOME/bin:$PATH

• Sans oublier de sourcer votre .bashrc

source .bash_rc

Décompressez ensuite l’archive précédemment téléchargée. Vous devriez avoir le contenu suivant:

2) Configuration

Le fichier de configuration qui va nous intéresser se situe dans le répertoire <votre répertoire d’installation>/wildfly/standalone/configuration/standalone.xml.

Les élément qui nous intéresse se situe à la fin du fichier:

<socket-binding-group name= »standard-sockets » default-interface= »public » port-offset= »${jboss.socket.binding.port-offset:0} »>
<socket-binding name= »management-http » interface= »management » port= »${jboss.management.http.port:9990} »/>
<socket-binding name= »management-https » interface= »management » port= »${jboss.management.https.port:9993} »/>
<socket-binding name= »ajp » port= »${jboss.ajp.port:8009} »/>
<socket-binding name= »http » port= »${jboss.http.port:8080} »/>
<socket-binding name= »https » port= »${jboss.https.port:8443} »/>
<socket-binding name= »txn-recovery-environment » port= »4712″/>
<socket-binding name= »txn-status-manager » port= »4713″/>
<outbound-socket-binding name= »mail-smtp »>
<remote-destination host= »localhost » port= »25″/>
</outbound-socket-binding>
</socket-binding-group>

Les lignes ci-dessus permette de paramétrer les ports d’écoutes (port d’écoute HTTP par défaut: 8080).

3) Démarrage/Arrêt

Vous trouverez ci-dessous le contenu d’un shell permettant de gérer l’arret/démarrage de votre serveur WildFly

#!/usr/bin/env bash

# LANG must be explicitly set in startup script (it is not set by monit)
export LANG= »en_US.utf8″

 

# Adapt  JBOSS_HOME with your current installation wildfly PATH
export JAVA_HOME= »${JAVA_HOME} »
export JBOSS_HOME=/srv/wildfly/apps/wildfly
export JBOSS_PIDFILE=$JBOSS_HOME/standalone/tmp/wildfly.pid
export JBOSS_SCRIPT=$JBOSS_HOME/bin/standalone.sh
export JBOSS_CONFIG=standalone.xml
export JBOSS_CONSOLE_LOG=/srv/wildfly/logs/wilfly/console-$(date +%Y%m%d-%H%M%S).log

export SHUTDOWN_WAIT=30

export prog=wildfly
export JBOSS_BIND_ADDRESS=0.0.0.0

JBOSS_MODULES_SYSTEM_PKGS= »org.jboss.byteman »

#Adapt the memory tunning as you want
JAVA_OPTS= »-Xms1303m -Xmx1303m -XX:MaxPermSize=256m -Djava.net.preferIPv4Stack=true »
JAVA_OPTS= »$JAVA_OPTS -Djboss.modules.system.pkgs=$JBOSS_MODULES_SYSTEM_PKGS -Djava.awt.headless=true »
JAVA_OPTS= »$JAVA_OPTS -Djboss.modules.policy-permissions=true »
JAVA_OPTS= »$JAVA_OPTS -Djboss.bind.address=$JBOSS_BIND_ADDRESS »
export JAVA_OPTS

EXEC_PATH=${JBOSS_HOME}/bin
cd ${EXEC_PATH}

start() {
# TODO verifier le contenu du fichier de pid
if [ -f $JBOSS_PIDFILE ]; then
read ppid < $JBOSS_PIDFILE
if [ `ps –pid $ppid 2> /dev/null | grep -c $ppid 2> /dev/null` -eq ‘1’ ]; then
echo -n « $prog is already running »
echo
return 1
else
rm -f $JBOSS_PIDFILE
fi
fi

mkdir -p $(dirname $JBOSS_CONSOLE_LOG)
cat /dev/null > $JBOSS_CONSOLE_LOG

mkdir -p $(dirname $JBOSS_PIDFILE)

export LAUNCH_JBOSS_IN_BACKGROUND=1
$JBOSS_SCRIPT -c $JBOSS_CONFIG > $JBOSS_CONSOLE_LOG 2>&1 &
return 0
}

stop() {
# TODO verifier le contenu du fichier de pid
count=0;

if [ -f $JBOSS_PIDFILE ]; then
read kpid < $JBOSS_PIDFILE
let kwait=$SHUTDOWN_WAIT

# Try issuing SIGTERM

kill -15 $kpid
until [ `ps –pid $kpid 2> /dev/null | grep -c $kpid 2> /dev/null` -eq ‘0’ ] || [ $count -gt $kwait ]
do
sleep 1
let count=$count+1;
done

if [ $count -gt $kwait ]; then
kill -9 $kpid
fi
fi
rm -f $JBOSS_PIDFILE
}

status() {
# TODO verifier le contenu du fichier de pid
if [ -f $JBOSS_PIDFILE ]; then
read ppid < $JBOSS_PIDFILE
if [ `ps –pid $ppid 2> /dev/null | grep -c $ppid 2> /dev/null` -eq ‘1’ ]; then
echo « $prog is running (pid $ppid) »
return 0
else
echo « $prog dead but pid file exists »
return 1
fi
fi
echo « $prog is not running »
return 3
}

case « $1 » in
start)
start
;;
stop)
stop
;;
restart)
$0 stop
$0 start
;;
status)
status
;;
*)
## If no parameters are given, print which are avaiable.
echo « Usage: $0 {start|stop|status|restart|reload} »
esac

4) Déploiement

Pour déployer votre application JAVA (sous forme de fichier ear), il vous suffit de le placer dans le répertoire <votre répertoire d’installation>/wildfly/standalone/. Une fois la copie terminée créer un fichier vide ayant le même nom que votre fichier ear suivi de .dodeploy.

Exemple: monapplicationjava.ear.dodeploy.

Wildfly commencera à déployer votre application. Si le déploiement se passe correctement le fichier sera renommé en <nom de votre fichier ear>.deployed

Le contenu de votre application sera disponible depuis votre navigateur via le port 8080 (port HTTP par défaut).

Il est vivement conseillé de toujours utiliser un reverse proxy HTTP (apache2) devant votre serveur d’application (un tutoriel est disponible à ce sujet: https://journaldunadminlinux.fr/tutoriel-mettre-en-place-un-reverse-proxy-sur-apache-via-mod_proxy/)

Article publié le 6 Juin 2017

Article mis à jour le 13 Janvier 2018

Cela fait un petit moment que je m’intéresse aux technologies Cloud (AWS, OpenStack, etc…) et OpenNebula a particulièrement attiré mon attention par sa simplicité d’installation.

C’est pourquoi, je vous propose un petit tutoriel d’installation sur OpenNebula sous Debian.

Pour suivre ce tutoriel, vous aurez besoin d’au minimum deux VMs: Une VM pour l’interface de gestion et d’une ou plusieurs VMs pour les hôtes (hyperviseurs).

1) Installation de l’interface de gestion

1.1) Installation des paquets

On installe les dépôts:

wget -q -O- http://downloads.opennebula.org/repo/Debian/repo.key | apt-key add –

echo « deb http://downloads.opennebula.org/repo/5.2/Debian/8 stable opennebula » > /etc/apt/sources.list.d/opennebula.list

On installe les paquets:

apt-get update & apt-get install opennebula*

A adapter selon la version de votre Debian (à l’heure ou cet article a été écrit, la 9 n’est pas encore sortie en version stable). De plus la version de opennebula (dernière version en date de cet article: 5.4) est à adapter dans le lien (deb http://downloads.opennebula.org/repo/<version opennebula>/Debian/8 stable opennebula)

On installe des bibliothèques Gem supplémentaires

/usr/share/one/install_gems

Activation d’openNebula:

systemctl enable opennebula
systemctl enable opennebula-sunstone

1.2) Installation du stockage partagé

On installe le serveur NFS:

apt-get install nfs-common nfs-kernel-server

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

/var/lib/one/ *(rw,sync,no_subtree_check,root_squash)

Activez  nfs:

systemctl enable nfs-kernel-server

Démarrez nfs:

systemctl start nfs-kernel-server

1.3 Installation de la base de données

La base de données par défaut est SQLITE. Inutile de vous préciser que rester sur ce type de base de données n’est pas une solution pérenne. Nous allons donc partir sur une installation de MySQL.

Installez les paquets:

apt-get install mariadb-server

Activez Mysql:

systemctl enable mysql

Démarrez Mysql:

systemctl start mysql

Créons maintenant la base ainsi que le user MySQL:

# mysql
> CREATE DATABASE opennebula;
> GRANT ALL ON opennebula.* TO oneadmin@localhost IDENTIFIED BY ‘onepassword’;

Le mot de passe est à changer bien entendu 😉

Procédez à la configuration d’openNebula pour que celui-ci se connecte à votre base de données MySQL. Pour cela éditez le fichier /etc/one/oned.conf et commencer par commenter la ligne suivante :

DB = [ backend = « sqlite » ]

Ensuite, rajoutez les lignes suivantes :

DB = [ backend = « mysql »,
server  = « localhost »,
port    = 0,
user    = « oneadmin »,
passwd  = « onepassword »,
db_name = « opennebula » ]

Démarrez les services :

systemctl start opennebula
systemctl start opennebula-sunstone

2) Installation de l’hyperviseur

Sur votre deuxième VM, installez les dépôts:

wget -q -O- http://downloads.opennebula.org/repo/Debian/repo.key | apt-key add –

echo « deb http://downloads.opennebula.org/repo/5.2/Debian/8 stable opennebula » > /etc/apt/sources.list.d/opennebula.list

On installe ensuite le paquet:

apt-get update & apt-get install opennebula-node

On active libvirtd et on le démarre:

systemctl enable libvirtd
systemctl start libvirtd

Rajoutez dans votre fichier /etc/fstab la ligne suivante :

<ip de votre serveur de gestion>:/var/lib/one/ /var/lib/one/ nfs soft,intr,rsize=8192,wsize=8192 0 0

Montez le volume NFS:

mount -a

Maintenant que votre hyperviseur est installé nous allons le rajoutez dans le cluster opennebula depuis l’interface de gestion.

Pour cela connectez vous à l’interface Web via l’URL: http://<ip ou nom de votre machine>:9869.

Une page ressemblante à la capture d’écran ci-dessous devrait s’afficher:

Récupérez vos identifiants en affichant le contenu du fichier  /var/lib/one/.one/one_auth et identifiez-vous.

Une fois connecté, le dashboard général d’openNebula s’affiche:

Cliquez sur le menu « infrastructure » puis sur « Hosts »:

Cliquez sur le bouton ajoutez:

Puis renseignez le hostname ou l’ip de votre hyperviseur:

Votre installation d’OpenNebula est maintenant terminée!

Vous pouvez commencer à créer des templates et provisionner des Vms

Merci à Séb pour sa contribution pour la rédaction de cet article 😉

Article publiée le 02/06/2017

Plus de 74 millions de sites tournent sous WordPress dans le monde. Malheureusement ce CMS est très facilement piratable ce qui fait qu’il y a énormément de site wordpress piraté dans le monde. WordPress représente à lui tout seul une faille de sécurité si celui ci n’est pas géré correctement (mise à jour régulière de wordpress et des plugins installés, vérification de la provenance des plugins, etc…) et ceux, même si vous sécurisez convenablement votre serveur (apache, OS etc…)

Après quelques recherches, j’ai trouvé un super outil développé en PYTHON permettant de faire un audit de sécurité complet d’un site wordpress: WPSEku.

Comme vous pouvez le voir sur la capture d’écran ci-dessus, ce petit script est riche en fonctionnalités.

Un grand merci au développeur pour son travail !

Ci-dessous le lien git

https://github.com/m4ll0k/WPSeku

En cas de message d’erreur lors de l’exécution de ce script, vérifiez l’installation des librairies Python nécessaire pour la bonne exécution de ce script comme python-request.

Inutile de tester cet outil sur mon site, vous risqueriez d’avoir votre IP blacklisté et de ce fait ne plus pouvoir accéder à mon blog ;-))

Article publiée le 11 Avril 2017

J’ai découvert par hasard un petit outil de monitoring Web en temps réel nommé PyDASH. Cet outil développé en Python vous permet d’avoir un aperçu global de votre machine:

1) Installation

1.1) Prérequis

Installez les prérequis:

Sous Debian/Ubuntu:

apt-get install git python-pip apache2 libapache2-mod-wsgi

Sous Redhat/Centos

Installez les dépots EPEL:

yum install epel-release

Puis installez les prérequis:

yum install git python-pip httpd mod-wsgi

1.2) Installation de PyDASH

On installe ensuite PyDASH:

Positionnez-vous dans le répertoire apache censé contenir le contenu (par défaut /var/www)

Rapatriez les sources depuis le dépôt GIT officiel

git clone https://github.com/k3oni/pydash

Positionnez-vous dans le répertoire pydash/pydash et changez la valeur SECRET_KEY contenue dans le fichier setting.py

Installez-le framework python Django (framework Web Python):

pip install -r requirement.txt

On initialise la base de donnée interne:

./manage.py syncdb

Ensuite attribuez les bons droits au répertoire racine pydash:

chown -R apache:apache pydash    – Pour les distribution Redhat/Centos

chown -R www-data-:www-data  – Pour les distributions Debian/Ubuntu

1.3) Configuration du serveur Apache

Sous Centos/RedHat

Créez le fichier /etc/httpd/conf.d/pyfash.conf et ajoutez y les lignes suivantes:

 WSGISocketPrefix run/wsgi
<VirtualHost *:80>
ServerAdmin [email protected]
ServerName dummy-host.example.com

WSGIDaemonProcess pydash display-name=%{GROUP} python-path=/var/www/pydash
WSGIProcessGroup pydash
WSGIScriptAlias / /var/www/pydash/pydash/wsgi.py
service apache2 reload
Alias /static /var/www/pydash/static/
Alias /media /var/www/pydash/media/

<Directory /var/www/pydash/pydash>
<Files wsgi.py>
Order deny,allow
Allow from all
</Files>
</Directory>

#CustomLog logs/pydash-access_log common
#ErrorLog logs/pydash-error_log
</VirtualHost>

Sous Debian/Ubuntu

Créez le fichier /etc/apache2/sites-available/pydash.conf et ajoutez y les lignes suivantes (sans oublier de tapez la commande « a2ensite pydash.conf » pour activer votre VirtualHost) :

 WSGISocketPrefix /var/run/apache2/wsgi
<VirtualHost *:80>
ServerAdmin [email protected]
ServerName dummy-host.example.com

WSGIDaemonProcess pydash display-name=%{GROUP} python-path=/var/www/pydash
WSGIProcessGroup pydash
WSGIScriptAlias / /var/www/pydash/pydash/wsgi.py

Alias /static /var/www/pydash/static/
Alias /media /var/www/pydash/media/

<Directory /var/www/pydash/pydash>
<Files wsgi.py>
Order deny,allow
Allow from all
</Files>
</Directory>

#CustomLog logs/pydash-access_log common
#ErrorLog logs/pydash-error_log
</VirtualHost>

Recharger ensuite la configuration de votre serveur apache:

service apache2 reload

Article publiée le 10 Avril 2017

Durant mon temps libre, j’ai décidé de m’intéresser de prêt à Nginx. Il est vrai que je n’ai jamais eu l’occasion de le mettre en place étant donné que l’intégralité de mes environnements WEB tournent avec Apache. Nginx est un serveur Web spécialement conçu pour encaisser de très forts trafics. Les performances de celui-ci sont nettement supérieures à ceux d’Apache. De plus, Nginx intègre une fonctionnalité de LoadBalancing très puissante. Cependant, l’inconvénient majeur de Nginx est qu’il ne peut gérer nativement du contenu  dynamique (PHP par exemple). Il faudrait pour cela passer par une configuration légèrement plus fastidieuse par rapport à celle d’Apache.

1) Installation

Installez Nginx sur une distrib Debian/Ubuntu:

apt-get install nginx

Installez Nginx sur une distrib Centos/RedHat

yum install nginx

(jusque-là rien de compliqué 😉 )

2) Configuration

2.1) Optimisation de la configuration

Dans le fichier nginx.conf, rajoutez les lignes suivantes afin d’optimiser la configuration de votre serveur nginx:

client_body_buffer_size 10k;

client_header_buffer_size 1k;

client_max_body_size 8m;

large_client_header_buffers 2 1k;

client_body_timeout 12;

client_header_timeout 12;

keepalive_timeout 15;  #modification car la ligne existe déja

send_timeout 10;

2.2) VirtualHost

Vous trouverez ci-dessous des exemples de configuration de VirtualHost Nginx. Pour rappel, un Virtualhost permet de gérer plusieurs sites simultanément avec le même serveur Web. Il permet d’afficher le bon site en fonction du nom de domaine. La configuration des VirtualHost Nginx est assez similaire à celle d’Apache.

Pour créer un VirtualHost sous Debian/Ubuntu il faut créer un fichier de configuration dans le répertoire « /etc/nginx/sites-available » est le remplir avec une configuration similaire à ce qui est indiqué ci-dessous. Ensuite, il ne restera plus qu’à faire un lien symbolique de ce fichier vers le répertoire « site-enabled »

Sous Redhat/Centos créer le répertoire /etc/nginx/vhost.d/ et rajoutez dans le fichier de configuration /etc/nginx.conf la ligne suivante:

include /etc/nginx/vhost.d/*.conf

Ci-dessous un VirtualHost prenant en compte un site accessible via HTTP et HTTPS:

server {
              listen 80;
              root /var/www/html;
              index index.html index.htm index.php;
              server_name example.com example;

              access_log /var/log/nginx/myexample.access.http.log;

              error_log /var/log/nginx/myexample.error.http.log;
}

server {
        listen 443;
        root /var/www/html;
        index index.html index.htm index.php;
        server_name example.com example;

        access_log /var/log/nginx/myexample.access.https.log;

        error_log /var/log/nginx/myexample.error.https.log;

        ssl on;
        ssl_certificate /etc/nginx/ssl/server.crt;
        ssl_certificate_key /etc/nginx/ssl/server.key;
}

Dans le cadre de la configuration du VirtualHost HTTPS, les certificats seront à générer au préalable!

Ci-dessous un VirtualHost permettant de faire un reverse proxy:

upstream mysite {

              server localhost:8080;

}

 server {

              server_name mysite.local;

              location / {

              proxy_pass http://mysite.local;

              }

}

2.3) Configuration d’un LoadBalancer

Il est également possible de faire du Loadbalancing avec NGINX.

La configuration (VirtualHost) ci-dessous permet de mettre en place un LoadBalancing de type « round robin » (file d’attente gérée de manière circulaire, « chacun son tour »)

upstream vip.local {

server example1.local;
                server example2local;
}
server {
listen 80;
server_name vip.local;
location / {
                proxy_pass http://vip.local;
                }
}

Il est également possible d’assigner un « poids » pour prioriser la répartition de la charge:

upstream vip.local {

server example1.local weight=3;
server example2.local weight=6;
}
server {
listen 80;
server_name vip.local;
location / {
                proxy_pass http://vip.local;
                }
}

3) PHP

Comme indiqué dans l’introduction de ce tutoriel, Nginx ne gère pas nativement PHP (du moins pas aussi bien qu’Apache). Vous trouverez ci-dessous la marche à suivre pour implémenter PHP.

Installez PHP-FPM

apt-get install php5-fpm ou yum install php5-fpm

Redémarrez php5-fpm

service php5-fpm restart

Rajoutez la configuration suivante dans votre virtualhost (ou le VirtualHost default si vous n’avez pas défini de VirtualHost) dans la section server {}

   location ~ \.php$ {
try_files $uri =404;
fastcgi_pass unix:/var/run/php5-fpm.sock;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
include fastcgi_params;
}

Si vous avez besoin de modules PHP spécifique pour faire tourner votre site web, il suffira de les installer via votre gestionnaire de paquet:

Exemple:

apt-get install php5-curl ou yum install php5-curl

Après un redémarrage de Nginx et de php5-fpm votre serveur nginx sera capable d’héberger des sites en PHP sans aucun souci!

Article publiée le 10 Février 2017

Après mon tuto sur Docker (http://journaldunadminlinux.fr/tuto-docker-demarrer-avec-docker/) je continue dans ma lancée en vous présentant l’outil docker-compose. Docker-compose est un outil officiel Docker  absolument génial qui permet de gérer à 100% vos container uniquement avec un fichier de configuration yml. Cet outil est d’autant plus pratique si vos applications nécessite l’installation de plusieurs containers pour fonctionner.

I) Installation

L’installation est très simple (curl doit être installé sur votre machine):

curl -L https://github.com/docker/compose/releases/download/1.11.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

chmod +x /usr/local/bin/docker-compose

La commande docker-compose doit fonctionner:

2) Utiliser Docker Compose

Pour vous montrer comment fonctionne docker-compose je vais prendre comme exemple l’installation d’un GITLAB complet sous Docker (base de données + application).

Après une petite recherche, on trouve facilement un template d’une configuration docker-compose.yml:

version: ‘2’

services:
redis:
restart: always
image: sameersbn/redis:latest
command:
– –loglevel warning
volumes:
– /srv/docker/gitlab/redis:/var/lib/redis:Z

postgresql:
restart: always
image: sameersbn/postgresql:9.6-2
volumes:
– /srv/docker/gitlab/postgresql:/var/lib/postgresql:Z
environment:
– DB_USER=gitlab
– DB_PASS=password
– DB_NAME=gitlabhq_production
– DB_EXTENSION=pg_trgm

gitlab:
restart: always
image: sameersbn/gitlab:8.16.4
depends_on:
– redis
– postgresql
ports:
– « 10080:80 »
– « 10022:22″
volumes:
– /srv/docker/gitlab/gitlab:/home/git/data:Z
environment:
– DEBUG=false

– DB_ADAPTER=postgresql
– DB_HOST=postgresql
– DB_PORT=5432
– DB_USER=gitlab
– DB_PASS=password
– DB_NAME=gitlabhq_production

– REDIS_HOST=redis
– REDIS_PORT=6379

– TZ=Asia/Kolkata
– GITLAB_TIMEZONE=Kolkata

– GITLAB_HTTPS=false
– SSL_SELF_SIGNED=false

– GITLAB_HOST=localhost
– GITLAB_PORT=10080
– GITLAB_SSH_PORT=10022
– GITLAB_RELATIVE_URL_ROOT=
– GITLAB_SECRETS_DB_KEY_BASE=long-and-random-alphanumeric-string
– GITLAB_SECRETS_SECRET_KEY_BASE=long-and-random-alphanumeric-string
– GITLAB_SECRETS_OTP_KEY_BASE=long-and-random-alphanumeric-string

– GITLAB_ROOT_PASSWORD=
– GITLAB_ROOT_EMAIL=

– GITLAB_NOTIFY_ON_BROKEN_BUILDS=true
– GITLAB_NOTIFY_PUSHER=false

– [email protected]
– [email protected]
– [email protected]

– GITLAB_BACKUP_SCHEDULE=daily
– GITLAB_BACKUP_TIME=01:00

– SMTP_ENABLED=false
– SMTP_DOMAIN=www.example.com
– SMTP_HOST=smtp.gmail.com
– SMTP_PORT=587
– [email protected]
– SMTP_PASS=password
– SMTP_STARTTLS=true
– SMTP_AUTHENTICATION=login

– IMAP_ENABLED=false
– IMAP_HOST=imap.gmail.com
– IMAP_PORT=993
– [email protected]
– IMAP_PASS=password
– IMAP_SSL=true
– IMAP_STARTTLS=false

– OAUTH_ENABLED=false
– OAUTH_AUTO_SIGN_IN_WITH_PROVIDER=
– OAUTH_ALLOW_SSO=
– OAUTH_BLOCK_AUTO_CREATED_USERS=true
– OAUTH_AUTO_LINK_LDAP_USER=false
– OAUTH_AUTO_LINK_SAML_USER=false
– OAUTH_EXTERNAL_PROVIDERS=

– OAUTH_CAS3_LABEL=cas3
– OAUTH_CAS3_SERVER=
– OAUTH_CAS3_DISABLE_SSL_VERIFICATION=false
– OAUTH_CAS3_LOGIN_URL=/cas/login
– OAUTH_CAS3_VALIDATE_URL=/cas/p3/serviceValidate
– OAUTH_CAS3_LOGOUT_URL=/cas/logout

– OAUTH_GOOGLE_API_KEY=
– OAUTH_GOOGLE_APP_SECRET=
– OAUTH_GOOGLE_RESTRICT_DOMAIN=

– OAUTH_FACEBOOK_API_KEY=
– OAUTH_FACEBOOK_APP_SECRET=

– OAUTH_TWITTER_API_KEY=
– OAUTH_TWITTER_APP_SECRET=

– OAUTH_GITHUB_API_KEY=
– OAUTH_GITHUB_APP_SECRET=
– OAUTH_GITHUB_URL=
– OAUTH_GITHUB_VERIFY_SSL=

– OAUTH_GITLAB_API_KEY=
– OAUTH_GITLAB_APP_SECRET=

– OAUTH_BITBUCKET_API_KEY=
– OAUTH_BITBUCKET_APP_SECRET=

– OAUTH_SAML_ASSERTION_CONSUMER_SERVICE_URL=
– OAUTH_SAML_IDP_CERT_FINGERPRINT=
– OAUTH_SAML_IDP_SSO_TARGET_URL=
– OAUTH_SAML_ISSUER=
– OAUTH_SAML_LABEL= »Our SAML Provider »
– OAUTH_SAML_NAME_IDENTIFIER_FORMAT=urn:oasis:names:tc:SAML:2.0:nameid-format:transient
– OAUTH_SAML_GROUPS_ATTRIBUTE=
– OAUTH_SAML_EXTERNAL_GROUPS=
– OAUTH_SAML_ATTRIBUTE_STATEMENTS_EMAIL=
– OAUTH_SAML_ATTRIBUTE_STATEMENTS_NAME=
– OAUTH_SAML_ATTRIBUTE_STATEMENTS_FIRST_NAME=
– OAUTH_SAML_ATTRIBUTE_STATEMENTS_LAST_NAME=

– OAUTH_CROWD_SERVER_URL=
– OAUTH_CROWD_APP_NAME=
– OAUTH_CROWD_APP_PASSWORD=

– OAUTH_AUTH0_CLIENT_ID=
– OAUTH_AUTH0_CLIENT_SECRET=
– OAUTH_AUTH0_DOMAIN=

– OAUTH_AZURE_API_KEY=
– OAUTH_AZURE_API_SECRET=
– OAUTH_AZURE_TENANT_ID=

Le fichier docker-compose ci-dessus va créer 3 container: deux container pour GITLAB et un pour PostgresSQL. Le fichier contient tout les paramètres de connexions à la base données, de l’applicatif, réseau (avec le mapping des ports) ainsi que le répertoire des volumes persistants très utile notamment pour les tablespaces de la base de données PostGRESQL.

Une fois le fichier docker-compose adapté à vos besoins, il ne reste plus qu’à builder vos container. Pour cela veillez à être dans le répertoire contenant votre fichier docker-compose.yml puis lancez la commande suivante pour builder les containers:

docker-compose up -d

On vérifie la présence des containers:

Comme prévus, trois containers ont été créés: un pour la base de données et deux pour GITLAB).

Dans le fichier docker-compose.yml (aussi via votre docker ps -a) il est indiqué que le port 80 du container est mappé sur le port 10080 accessible depuis l’extérieur.

Il ne reste plus qu’à tester (http://ip ou DNS de votre machine :10080):

3) Les commandes utiles

Les commandes ci-dessous sont à utiliser quand vous êtes positionné dans le répertoire contenant le  fichier docker-compose.yml:

Stopper le/les containers
docker-compose stop

Démarrer le/les containers
docker-compose start

Supprimer le/les containers
docker-compose rm

Builder le/les Containers
docker-compose up -d

Check des logs
docker logs -f <nom de container>

Article publié le 09/02/2017

Mis à jour le 22/08/2018

Après pas mal de temps, j’ai enfin décidé à me mettre à étudier Docker. Étant très hésitant au départ, je me suis vite aperçu que Docker est un outil extrêmement puissant, flexible avec un potentiel Devops incroyable.

La question que se posent beaucoup de personnes est: qu’est-ce que c’est Docker? Contrairement à la virtualisation classique ou vous virtualisez l’intégralité de la machine et tout se qu’elle héberge, Docker n’héberge  que les applications et les librairies!

I) Installation

Sous Debian: 

On ajoute les dépôts docker et on installe:

sudo apt-get install apt-transport-https ca-certificates curl gnupg2 software-properties-common
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add –
sudo add-apt-repository « deb [arch=amd64] https://download.docker.com/linux/debian $(lsb_release -cs) stable »
sudo apt-get update
sudo apt-get install docker-ce

systemctl enable docker

systemctl start docker

Sous Centos:

On ajoute les dépôts docker et on installe:

sudo yum install -y yum-utils device-mapper-persistent-data lvm2
sudo yum-config-manager –add-repo https://download.docker.com/linux/centos/docker-ce.repo
sudo yum install docker-ce

systemctl enable docker

systemctl start docker

usermod -a -G docker  <votre user>

 II) Création d’un container

Dans l’exemple ci-dessous, on va chercher une image nginx:

docker search nginx

On rapatrie l’image sur notre machine :

docker pull nginx

On vérifie notre liste d’images:

docker images

On s’aperçoit que notre image nginx a bien été rapatrié:

On installe le container

docker run -d –name=ServeurNginx nginx:latest

On vérifie que le container est bien installé:

docker ps  -a

On démarre notre container:

docker start <container id>

docker start 1f8b15c5b642

Nous allons maintenant inspecter la configuration de notre container afin de déterminer l’adresse IP local du container:

docker inspect <id du container>

Vous verrez toutes les informations de votre container et notamment un élément qui nous intéresse:

  « IPAddress »: « 172.17.0.2 »,
« IPPrefixLen »: 16,

L’IP ci-dessus correspond à l’interface virtuel  de votre container. Si vous tentez de vous connecter en HTTP via l’adresse de votre container, le serveur nginx hébergé dans votre container va répondre:

elinks 172.0.0.2

Bon j’imagine que vous allez me poser la question suivante: « comment on fait pour que notre container soit accessible de l’extérieur? »

Pour cela rien de plus simple, nous allons créer un deuxième container depuis l’image nginx avec quelques arguments en plus:

 docker run -d -p 9876:80 –name=Webserver3 nginx:latest

Votre container sera joignable via le port 9876 depuis l’extérieur:

III) DockerFile

Il est possible avec Docker de créer un container  à partir d’un fichier de configuration nommé Dockerfile.

Pour cela créer un fichier nommé Dockerfile.

Dans notre fichier nous allons créer un container Debian et installer un serveur apache2 accessible depuis l’extérieur.

Ci-dessous le contenu du Dockerfile

# Image

FROM debian:stable

#Information sur le propriétaire du container
MAINTAINER [email protected]
# Commande RUN utilisé uniquement lors de la creation du container (necessite un docker build)
RUN apt-get update && apt-get upgrade -y && apt-get install -y apache2 telnet  elinks openssh-server
# Creation variable
ENV VARIABLE ma-variable
# PORT 80 Ouvert
EXPOSE  80

# On expose le port SSH pour pouvoir se connecter sur la machine

EXPOSE 22
# Commande passé une fois le container créé (ne neccessite pas un docker build juste un run)
#     Commande               1er arg 2eme arg
CMD [« /usr/sbin/apache2ctl », »-D », »FOREGROUND »]

docker run -d -P 9999:80 –name=Debianapache myapache:latest

IV) Autre commandes utiles

docker rm `docker ps -a -q`

docker start <container>

docker stop <container>

docker rm `docker ps -a -q`

docker rmi <image>

docker run -it <votre container> /bin/bash

VI) Repository

Un tuto pour créer votre propre Registry Docker est disponible ici

VII) Docker Compose

Docker-compose est un outil officiel Docker  absolument génial qui permet de gérer à 100% vos container uniquement un fichier de configuration yml. Cet outil est d’autant plus pratique si vos applications nécessite l’installation de plusieurs containers pour fonctionner.

Le tutoriel sur docker-compose est disponible ici:

Tuto Docker | Gérer vos container avec Docker compose

VIII) Docker Swarm

Docker swarm est l’orchestrateur de container officiel Docker. Un tutoriel sur son déploiement est disponible:

Tutoriel | Installer et utiliser DockerSwarm

IX) Registry Privé

Un tutoriel sur l’installation d’un registry privé Docker est disponible:

Tutoriel | Installation, configuration et utilisation d’un Docker Registry

X) Kubernetes

Kubernetes est un puissant orchestrateur de container extrêmement utilisé aujourd’hui. Un tutoriel sur son déploiement est disponible:

Tutoriel | Installez facilement un cluster Kubernetes sous Debian ou Centos

XI) Portainer

Portainer est un outil puissant permettant de gérer vos environnement Docker via une interface Web extrêmement simple d’utilisation:

Tutoriel | Gérez vos container docker avec Portainer

Article publiée le 27 Décembre 2016

Je continue dans ma lancée des tutoriels concernant l’installation et la configuration de base de données multi instance (cf: tuto sur l’installation d’une base Mysql multi instance: http://journaldunadminlinux.fr/tuto-installation-dune-mysql-multi-instance/).

Si vous ne connaissez rien du tout sur postgresql je vous suggère d’aller faire un tour sur le tuto d’installation de postgres: http://journaldunadminlinux.fr/tuto-installation-dune-mysql-multi-instance/

Ci-dessous la procédure pour configurer un serveur postgresql en multi instance

• Procédez à l’installation de PostgreSQL via la commande apt-get install postgresql postgresql-common postgresql-contrib
• Faites, une sauvegarde du fichier de configuration /etc/postgresql/9.4/main/postgresql.conf
• Copier la configuration ci-dessous dans votre fichier postgresql.conf:

data_directory = '/var/lib/postgresql/9.4/main'

hba_file = '/etc/postgresql/9.4/main/pg_hba.conf'

ident_file = '/etc/postgresql/9.4/main/pg_ident.conf'

external_pid_file = '/var/run/postgresql/9.4-main.pid'

listen_addresses = 'localhost'

port = 5432

max_connections = 100

unix_socket_directories = '/var/run/postgresql'

ssl = true

shared_buffers = 1024MB

work_mem = 16MB

maintenance_work_mem = 1024MB

checkpoint_segments = 64

checkpoint_completion_target = 0.9

effective_cache_size = 1024MB

log_min_duration_statement = 500

log_line_prefix = '%m %d '

datestyle = 'iso, mdy'

lc_messages = 'en_US.UTF-8'

lc_monetary = 'en_US.UTF-8'

lc_numeric = 'en_US.UTF-8'

lc_time = 'en_US.UTF-8'

default_text_search_config = 'pg_catalog.english'

ssl_cert_file = '/etc/ssl/certs/ssl-cert-snakeoil.pem'

ssl_key_file = '/etc/ssl/private/ssl-cert-snakeoil.key'

• Créez les dossiers de stockage  avec les bons droits:

• Créez la nouvelle instance

su - postgres /usr/lib/postgresql/9.4/bin/initdb -D /srv//pg cp /etc/postgresql/9.4/main/*conf /etc/postgresql/9.4/<instance name>

• Éditez et modifier le fichier /etc/postgresql/9.4/<instance name>/postgresql.conf avec les bonnes informations

• Redémarrez PostgreSQL

Quelques commandes pour aider (version « 9.4 »  adapter bien évidemment):

Lister les Clusters :   pg_lsclusters

Arrêter une instance: pg_ctlcluster 9.4 <instance name> stop

Démarrer une instance: pg_ctlcluster 9.4 instance1 start

Article publiée le 27 Décembre 2016

PostgreSQL est pour moi la meilleure alternative à Oracle. Elle allie performance, fiabilité et simplicité d’administration. Ayant eu pas mal de galère avec MySQL que je trouve plus « fragile » j’ai vite été séduis par la robustesse de PostGRESQL.

1) Installation

Debian/Ubuntu

apt-get install postgresql-*

RedHat/Centos

La version de postgresql contenu dans les dépôts de ces distributions sont un peu veilles. Je vous suggère d’ajouter les dépots yum officiel:

CentOS/RHEL 7 # rpm -Uvh http://yum.postgresql.org/9.4/redhat/rhel-7-x86_64/pgdg-centos94-9.4-1.noarch.rpm CentOS/RHEL 6 # rpm -Uvh http://yum.postgresql.org/9.4/redhat/rhel-6-x86_64/pgdg-redhat94-9.4-1.noarch.rpm CentOS/RHEL 5 # rpm -Uvh http://yum.postgresql.org/9.4/redhat/rhel-5-x86_64/pgdg-redhat94-9.4-1.noarch.rpm

9.4 correspond à la version de postgreSQL, rien ne vous empêche d’installer une version supérieur/inférieur en modifiant le lien.

Ensuite procédez à l’installation (encore une fois le numéro de la version est à adapter)

yum install postgresql94-server postgresql94

Initialisez l’instance postgresql:

/usr/pgsql-9.4/bin/postgresql94-setup initdb

2) Configuration

• Emplacement des fichiers de configuration sous RedHat/Centos: /var/lib/pgsql/9.4/data/postgresql.conf
• Emplacement des fichiers de configuration sous Debian/Ubuntu: /etc/postgresql/9.4/main/

Modifiez le fichier de configuration postgresql.conf avec la configuration suivante:

data_directory = ‘/var/lib/postgresql/9.4/main’
hba_file = ‘/etc/postgresql/9.4/main/pg_hba.conf’
ident_file = ‘/etc/postgresql/9.4/main/pg_ident.conf’
external_pid_file = ‘/var/run/postgresql/9.4-main.pid’

listen_addresses = ‘*’
port = 5432
max_connections = 200
unix_socket_directories = ‘/var/run/postgresql’
ssl = true

shared_buffers = 512MB
work_mem = 16MB
maintenance_work_mem = 2048MB

checkpoint_segments = 64
checkpoint_completion_target = 0.9

effective_cache_size = 1024MB

log_min_duration_statement = 500
log_line_prefix = ‘%m %d ‘

datestyle = ‘iso, mdy’
#lc_messages = ‘en_US.UTF-8’
#lc_monetary = ‘en_US.UTF-8’
#lc_numeric = ‘en_US.UTF-8’
#lc_time = ‘en_US.UTF-8’

lc_messages = ‘fr_FR.UTF-8’
lc_monetary = ‘fr_FR.UTF-8’
lc_numeric = ‘fr_FR.UTF-8’
lc_time = ‘fr_FR.UTF-8’
default_text_search_config = ‘pg_catalog.english’

ssl_cert_file = ‘/etc/ssl/certs/ssl-cert-snakeoil.pem’
ssl_key_file = ‘/etc/ssl/private/ssl-cert-snakeoil.key’

Modifiez le fichier pg_hba.conf afin d’autoriser la connexion d’un client extérieur à votre base (à adapter selon la configuration de votre réseau):

# DO NOT DISABLE!
# If you change this first entry you will need to make sure that the
# database superuser can access the database using some other method.
# Noninteractive access to all databases is required during automatic
# maintenance (custom daily cronjobs, replication, and similar tasks).
#
# Database administrative login by Unix domain socket
local all postgres peer

# TYPE DATABASE USER ADDRESS METHOD

# « local » is for Unix domain socket connections only
local all all peer
# IPv4 local connections:
host all all 127.0.0.1/32 md5
host all all 192.1.1.137/24 md5
host all all 192.168.0.0/24 md5

Enfin redémarrez postgresql afin de charger la conf.

3) Connexion

Pour vous connecter à votre instance postgreSQL vous avez le choix entre deux méthodes:

• En ligne de commande:

[user@dbserver ~]$ psqlsu – postgres

[postgres@dbserver ~]$ psql

 

Vous serez ainsi connecter au client en ligne de commande Postgresql. Afin d’avoir un apercu des commandes tapez \h.

Pour plus d’info n’hésitez pas à consulter la documentation officiel : http://docs.postgresql.fr/

• Via une interface graphique

Il est également possible d’utiliser une interface graphique afin d’administrer votre instance postgreSQL.

Cette interface graphique du nom de PGADMIN est disponible en libre téléchargement: https://www.pgadmin.org/

Autre tutoriel sur postgresql:

Tuto | Installation d’un serveur PostgreSQL multi-instances

Tutoriel | Configurer la réplication master/slave d’une instance PostgreSQL

Article publiée le 26 Décembre 2016

Un petit tutoriel sur l’installation d’une base de données MySQL multi instance. Ce type d’installation vous sera particulièrement utile si votre serveur héberge plusieurs instances applicative. En effet admettons que vous hébergiez plusieurs instances applicatives, au lieu de créer une base de données par application, vous pourrez créer une instance MySQL dédié par application. L’avantage est que vous pourrez effectuer un tunning précis de votre base de données par application.

•  Procédez à l’installation de mysql via la commande apt-get install mysql-server

•  Faites une sauvegarde du fichier de configuration original /etc/mysql/my.cnf et modifier le de la manière suivante (le fichier de configuration est bien sur à adapter. Dans cette exemple j’ai décidé de créer trois instances MySQL):

[client]

port            = 3306

socket          = /var/run/mysqld/mysqld.sock

[mysqld_safe]

socket          = /var/run/mysqld/mysqld.sock

nice            = 0

[mysqld]

#user           = mysql

[mysqldump]

quick

quote-names

max_allowed_packet      = 16M

[mysql]

#no-auto-rehash # faster start of mysql but no tab completition

[isamchk]

key_buffer              = 16M

!includedir /etc/mysql/conf.d/

[mysqld1]

user            = mysql1

pid-file        = /var/run/mysqld1/mysqld.pid

socket          = /var/run/mysqld1/mysqld.sock

port            = 33061

basedir         = /usr

datadir         = /var/lib/mysql1

tmpdir          = /tmp

lc-messages-dir = /usr/share/mysql

skip-external-locking

bind-address            = 127.0.0.1

general_log_file        = /var/log/mysql1/mysql.log

general_log             = 1

key_buffer              = 16M

max_allowed_packet      = 16M

thread_stack            = 192K

thread_cache_size       = 8

myisam-recover          = BACKUP

query_cache_limit       = 1M

query_cache_size        = 16M

expire_logs_days        = 10

max_binlog_size         = 100M

[mysqld2]

user            = mysql2

pid-file        = /var/run/mysqld2/mysqld.pid

socket          = /var/run/mysqld2/mysqld.sock

port            = 33062

basedir         = /usr

datadir         = /var/lib/mysql2

tmpdir          = /tmp

lc-messages-dir = /usr/share/mysql

skip-external-locking

bind-address            = 127.0.0.1

general_log_file        = /var/log/mysql2/mysql.log

key_buffer              = 16M

max_allowed_packet      = 16M

thread_stack            = 192K

thread_cache_size       = 8

myisam-recover          = BACKUP

query_cache_limit       = 1M

query_cache_size        = 16M

log_error               = /var/log/mysql2/error.log

expire_logs_days        = 10

max_binlog_size         = 100M

[mysqld3]

user            = mysql3

pid-file        = /var/run/mysqld3/mysqld.pid

socket          = /var/run/mysqld3/mysqld.sock

port            = 33063

basedir         = /usr

datadir         = /var/lib/mysql3

tmpdir          = /tmp

lc-messages-dir = /usr/share/mysql

skip-external-locking

bind-address            = 127.0.0.1

general_log_file        = /var/log/mysql3/mysql.log

general_log             = 1

key_buffer              = 16M

max_allowed_packet      = 16M

thread_stack            = 192K

thread_cache_size       = 8

myisam-recover          = BACKUP

query_cache_limit       = 1M

query_cache_size        = 16M

log_error               = /var/log/mysql3/error.log

expire_logs_days        = 10

max_binlog_size         = 100M

Article publié le 8 Novembre 2016

Article mise à jour le 19 Janvier 2018

Très souvent je peux constater que des admins mettent directement leur serveur Tomcat en front (les clients se connectent directement sur le Tomcat).

Il est très vivement recommandé d’utiliser un serveur Apache en front (reverse proxy). En effet l’utilisation d’un serveur apache a les avantages suivants:

• Sécurité: Le serveur tomcat est isolé de l’extérieur et apache gère mieux les requêtes HTTP
• Performance: Apache sera plus performant que Tomcat (le moteur HTTP d’apache est beaucoup plus performant).
• Configuration: Apache contrairement à Tomcat est hautement configurable!

Une fois votre serveur apache installé activez le mode proxy:

a2enmod proxy_http

Créez votre virtualhost:

touch /etc/apache2/site-available/<nom de votre site>.conf

Ajoutez y la configuration suivante

< VirtualHost *: 80>

ServerName <nom de votre site>

ProxyPreserveHost On

ProxyRequests On

ProxyPass / <adresse IP ou DNS de votre appli tomcat>

ProxyPassReverse / <Adresse IP ou DNS de votre appli tomcat>

</VirtualHost>

Activez ensuite votre virtualHost via la commande a2ensite <nom de votre VirtualHost> puis recharger la configuration de  votre serveur apache avec la commande /etc/init.d/apache2 reload

Article publiée le 8 Novembre 2016

1) Présentation

Tomcat 9 est sortie depuis quelque temps.

Tous d’abord faisons un point sur les nouveautés:

– Implémentation des spécification de JAVA7

– Implémentation de Java Servlet  3.1,

– Implémentation de de JavaServer Page2.3

Ci dessous un petit tuto rappel de comment installer un serveur tomcat (version 9):

Cette article reprend le tutoriel que j’ai rédigé pour tomcat 8 en étant adapté pour cette nouvelle version. Il n’y aura pas de gros changement pour les personnes ayant lu le tutoriel sur tomcat 8 🙂

Prérequis: Java

yum install java* pour (RedHat/Centos) ou apt-get install openjdk* (Sous debian/Ubuntu)

– Créez proprement votre répertoire d’installation de tomcat, dans mon cas cela sera /srv/tomcat

mkdir /srv/tomcat

– Décompressez l’archive dans le répertoire de destination:

mv <votre archive>.tar.gz <repertoire d’installation>  &&  tar -xvf  <repertoire d’installation>/<votre archive>.tar.gz

Exemple:  mv /root/apache-tomcat-9.0.0.tar.gz  /srv/tomcat/

Quelques petites explications:

– Le répertoire bin contient tous les scripts de tomcat notamment ceux de démarrage et d’arrêt.

– Le répertoire conf contient tous les fichiers de configuration de tomcat

– Le répertoire webapps contient toutes les webapps (vos servlets java)

2) Configuration

– Allez dans le répertoire conf:

cd conf

– Si vous désirez changer le port d’écoute éditez le fichier server.xml et éditez cette ligne en remplaçant le port par défaut 8080 par celui que vous désirez:

<Connector port= »8080″ protocol= »HTTP/1.1″
connectionTimeout= »20000″
redirectPort= »8443″ />
<!– A « Connector » using the shared thread pool–>

– Editons ensuite le fichier tomcat-user afin de définir le mot de passe de l’interface d’administration de tomcat:

Le dernier « paragraphe »  du fichier de configuration est commenté. Pour le dé-commentez enlevez :

<!– et  –>

Ajoutez ensuite les balises rolename:

<role rolename= »manager »/>

<role rolename= »manager-gui »/>

Créons ensuite le user qui aura les droits d’admin de votre serveur tomcat:

<user username= »tomcat-admin » password= »tomcat » roles= »manager,manager-gui »/>

Sans oublier de modifier le password !

 Nouvel particularité avec Tomcat 9: si vous désirez accéder au manager app depuis une machine distante vous devez créer le fichier conf/Catalina/localhost/manager.xml et y ajoutez les lignes suivantes:

<Context privileged= »true » antiResourceLocking= »false »
docBase= »${catalina.home}/webapps/manager »>
<Valve className= »org.apache.catalina.valves.RemoteAddrValve » allow= »^.*$ » />
</Context>

-Il ne reste plus qu’ à redémarrer Tomcat :

rendez vous dans le répertoire bin (de tomcat) et exécutez ces scripts:

./shutdown.sh (pour arréter tomcat)

./startup.sh (pour démarrer tomcat)

Ici vous trouverez la liste des Webapp déployées.

-Il existe 2 méthodes pour déployer une Webapp (fichier .war):

La première (la plus simple) consiste à cliquer sur le bouton déployer et de sélectionnez votre fichier war.

Tomcat se chargera de la déployer pour vous. Une fois le déploiement terminé vous pourrez voir apparaître une nouvelle ligne avec le nom de votre Webapp.

La deuxième est de déposer le war directement dans le répertoire Webapp est de redémarrer le serveur Tomcat

Votre Webapp sera automatiquement déployée.

3) Tunning : 

Il est possible, si vous déployez des applications lourdes ou en grand nombre, que vous ayez des problèmes mémoires.

Dans ce cas vous pourrez avoir des messages d’erreur ou de grosses lenteurs lors de l’exécution de vos webapps.

Pour cela éditez le fichier startup.sh et ajoutez à la ligne export JAVA_OPTS= -server -Xms<mémoire minimal alloué> -Xmx <mémoire maximum alloué>

Exemple:

export JAVA_OPTS= »-server -Xms2048m -Xmx2048m »

Redémarrez votre serveur Tomcat afin que les modifications soient prises en comptes.

Si vous rencontrez d’autres problèmes mémoire vous pouvez vous rendre sur cette page :

http://journaldunadminlinux.fr/tomcat-severe-failed-to-initialize-java-lang-outofmemoryerror-permgen-space/

Cette article traite d’un problème Tomcat et pourra peut-être vous aider.

4) Script de démarrage

Afin de vous faciliter la vie, je vous livre ci-dessous le script de démarrage de tomcat à déposer dans le répertoire init.d:

#!/bin/sh
CATALINA_HOME=<repertoire tomcat>; export CATALINA_HOME
JAVA_HOME=<repertoire java>; export JAVA_HOME
TOMCAT_OWNER=<votre user tomcat>; export TOMCAT_OWNER

start() {
echo -n « Starting Tomcat:  »
su $TOMCAT_OWNER -c $CATALINA_HOME/bin/startup.sh
sleep 2
}
stop() {
echo -n « Stopping Tomcat:  »
su $TOMCAT_OWNER -c $CATALINA_HOME/bin/shutdown.sh
}

# See how we were called.
case « $1″ in
start)
start
;;
stop)
stop
;;
restart)
stop
start
;;
*)
echo $ »Usage: tomcat {start|stop|restart} »
exit
esac

5) Best Pratice

– Si votre application doit-être accessible depuis le monde extérieur je vous conseille de procéder à un couplage (Apache/Tomcat) avec les règles firewall qui vont bien

– Utilisez toujours un serveur apache en front en mode revese proxy. Vos clients ne doivent pas se connecter en direct sur le Tomcat. Un tuto est disponible: http://journaldunadminlinux.fr/tutoriel-mettre-en-place-un-reverse-proxy-sur-apache-via-mod_proxy/

Article publiée le 12 Octobre 2016

Petit tuto expliquant comment configurer un serveur FTPs sécurisé avec vsftpd. Vsftpd étant le serveur FTP le plus sécurisé, je vous le recommande fortement.

– Installez vsftpd via la commande apt-get install vsftpd (sous Debian) ou yum install vsftpd (sous RedHat/CentOS)

– Une fois l’installation effectuée, éditez le fichier /etc/vsftpd/vsftpd.conf et écraser le contenu avec la configuration suivante (sans oublier de faire une sauvegarde du fichier original):

# A adapter


pasv_min_port=30000

pasv_max_port=30099

local_enable=YES

virtual_use_local_privs=YES

write_enable=YES

local_umask=18

dirmessage_enable=YES

xferlog_enable=YES

connect_from_port_20=YES

xferlog_file=/var/log/vsftpd.log

xferlog_std_format=YES

idle_session_timeout=600

data_connection_timeout=1200

chroot_local_user=YES

listen=YES

max_clients=30

pam_service_name=vsftpd.virtual

guest_enable=YES

user_sub_token=$USER

local_root=/srv/ftp/$USER

hide_ids=YES

userlist_enable=YES

tcp_wrappers=YES

ssl_enable=YES

allow_anon_ssl=NO

allow_writeable_chroot=YES

force_local_data_ssl=YES

force_local_logins_ssl=YES

rsa_cert_file=/etc/ssl/certs/<nom du fichier>.crt


rsa_private_key_file=/etc/ssl/private/<nom du fichier>.key

ssl_tlsv1=YES

ssl_sslv2=NO

ssl_sslv3=NO

require_ssl_reuse=NO

openssl req -x509 -newkey rsa:1024-keyout /etc/ssl/private/private.key -out /etc/ssl/certs/certificate.crt -nodes -days 3650

chmod 0600/etc/ssl/private/private.key; chmod 0640/etc/ssl/certs/certificate.crt

#%PAM-1.0

auth       required     pam_userdb.so db=/etc/vsftpd/login

account    required     pam_userdb.so db=/etc/vsftpd/login

session    required     pam_loginuid.so

useradd ftp

user1

passworduser1

user2

passworduser2

mkdir -p /srv/ftp/user1

mkdir -p /srv/ftp/user2

chown -R ftp:ftp /srv/ftp

service vsftpd restart

Article publié le 10 Octobre 2016

Petit tuto très simplifié sur comment chiffrer/dechiffrer des fichiers avec GnuPG.

– Démarrez l’agent gnugpg:

gpg-agent –daemon –use-standard-socket

– Authentifiez vous sans utiliser sudo mais en vous connectant directement avec le compte UNIX souhaité.
– Générez votre clé privée (de préférence sur une machine sûre):

gpg -gen-key

– Renseignez les informations demandées par l’invite de commande. Si la génération de votre clé prend trop de temps, utilisez la commande ci-dessous

rngd -r /dev/urandom

– Générez votre clé de révocation (au cas ou)

gpg –output revoke.asc –gen <id de votre clé>

– Vérifiez que votre clé a bien été généré

gpg –list-keys

– Exportez votre clé publique qui sera nécessaire pour chiffrer / déchiffrer (la clé public devra être envoyé au destinataire afin qu’il puisse
déchiffrer le contenu).

gpg –output mykey.asc –armor –export <id de la clé>

– Une fois la clé reçu par le destinataire celui ci devra signer la clé

gpg –sign-key <id de la clé>Chiffrement / Déchiffrement

– Procédez au chiffrement de votre fichier

gpg –recipient « <identifiant de votre clé  » –encrypt –cipher-algo AES256 <votre fichier>

– Le destinataire pourra alors déchiffrer votre fichier avec la clé publique précédemment envoyée

gpg –decrypt <fichier>.gpg

Article publié le 23 Juin 2016

Un petit tuto sur le firewall Shorewall qui simplifie grandement la configuration d’IPTABLES. En effet avec Shorewall vous pouvez configurer de manière très efficace IPTABLE juste avec une  petite poignée de fichiers de configuration (très utile pour de nombreux  serveurs dédiés piratés…)

1) Installation

Sous Debian/ Ubuntu:

apt-get install shorewall shorewall-core

(sans oublier shorewall6 si vous avez une interface réseau avec une adresse IPV6)

Sous RedHat/Centos

Shorewall n’est pas dans les dépots officiels de ces distributions. Pour cela il est nécessaire de rajouter les dépôts de shorewall:

Créez le fichier /etc/yum.repos.d/shorewall.repo et rajouter les lignes suivantes:

[shorewall]
name = RHEL $releasever – Shorewall – sysadminguide.net
baseurl = http://mirror.sysadminguide.net/shorewall
enabled = 1
protect = 0
gpgcheck = 0

Puis installez shorewall:

yum install shorewall, shorewall-core

(Sans oublier shorewall6 si vous avez une interface réseau avec une adresse IPV6;-))

2) Configuration

2.1) Sous Debian:

Copiez les fichiers de configurations depuis le répertoire /usr/share/doc/shorewall/examples/one-interface vers  /etc/shorewall

cd /usr/share/doc/shorewall/examples/one-interface && cp {interfaces, policy, shorewall.conf.gz, zones} /etc/shorewall && gunzip /etc/shorewall/shorewall.conf.gz

cd /usr/share/doc/shorewall6/examples/one-interface && cp {interfaces, policy, shorewall.conf.gz, zones} /etc/shorewall6 && gunzip /etc/shorewall6/shorewall.cong.gz (si vous avez une adresse IPv6)

Créez le fichier /etc/shorewall/rules  (également pour /etc/shorewall6/rules le cas échéant) et ajoutez y les lignes suivantes:

?SECTION NEW
SHELL cat /etc/shorewall/rules.d/*.rules 2> /dev/null || true

Puis créez le répertoire /etc/shorewall/rules

mkdir /etc/shorewall/rules.d

(mkdir /etc/shorewall6/rules.d)

 

2.2) RedHat

La procédure est presque identique à celle de Debian.

Copier les fichiers disponibles ICI  dans le répertoire /etc/shorewall/ et /etc/shorewall6 (si vous avec une adresse IPv6).

Créer les répertoire /etc/shorewall/rules.d et /etc/shorewall6/rules.d

mkdir /etc/shorewall/rules.d   (mkdir /etc/shorewall6/rules.d).

3) Paramétrage du Firewall

La politique appliquée ici (étant une best practice) est de tout bloquer et d’ouvrir uniquement les ports utilisés.

Pour cela il suffit de créer des fichiers contenant les règles dans le répertoires /etc/shorewall/rules.d

Exemple pour rendre accessible le port SSH que pour certaines IP:

vi /etc/shorewall/rules.d/ssh.rules

ACCEPT net:<ip autorisée> $FW tcp 22
ACCEPT net:<deuxième ip autorisée> $FW tcp 22

Il est également possible d’autoriser une plage d’IP:

vi /etc/shorewall/rules.d/votreservice.rules

ACCEPT net:<ip autorisée> $FW tcp 7896,9800:9809
ACCEPT net:<deuxième ip autorisée> $FW tcp 7896,9800:9809

# UDP

ACCEPT net:<ip autorisée> $FW udp 7896,9800:9809
ACCEPT net:<deuxième ip autorisée> $FW udp 7896,9800:9809

Une fois votre configuration effectuée nous allons activer shorewall.

• Editez le fichier /etc/shorewall/shorewall.conf et modifier la ligne « STARTUP_ENABLED=No » par « STARTUP_ENABLED=Yes »
• Editez le fichier /etc/default/shorewall et remplacez « startup=0 » par « startup=1 »
• Lancez shorewall avec la commande service shorewall start

Il ne reste plus qu’à vérifier que votre firewall contient toutes les règles que vous avez paramétré avec la commande iptables -L

Certains serveurs dédiés (notamment chez OVH) possèdent une adresse IPv4 et IPv6 sur 2 interfaces. Je tiens à souligner l’importance du paramétrage du firewall sur l’interface IPv6 avec shorewall6 (répertoire de configuration /etc/shorewall6). Un oubli pourrait transformer votre machine en passoire.

Article publié le 25 Mai 2013

Mis à jour publié le 24 Mai 2016

Ce tutoriel a été mis à jour pour la sortie de la  version 3.x

Nagios/Centreon est pour moi le meilleur système de supervision qui existe. Il est puissant, gratuit avec une énorme communauté qui le maintient.

Maintenant sa mise en place est plus ou moins fastidieuse.

J’ai découvert par hasard que Centreon proposait une édition Entreprise.

La version standard est entièrement gratuite est présente de nombreux avantage

– Téléchargeable sous forme d’ISO centreon Entreprise standard est livré sous forme d’OS complet (basé sur CENTOS) avec tout le  système de monitoring préinstallé. Vous installez l’ISO comme un OS Linux et il ne vous restera plus qu’à vous connecter dessus via l’interface web

– Possibilité de souscrire à un support, ce qui est très utile si votre supervision est un élément critique dans votre entreprise

– Des add ons payant comme un système de rapport poussé avec des indicateurs de qualités etc, très utile pour remettre à votre DSI des rapports complets sur la santé de votre SI 😉

En gros Centreon Entreprise Standard vous offre gratuitement une solution de monitoring Centreon clé en main!

I) Installation

Télécharger l’ISO depuis le site :

http://www.centreon.com/Content-Download/download-centreon-enterprise-server

En bootant sur l’image cette interface apparait:

Appuyez sur ENTRER pour une installation par défaut et suivez la procédure normal pour installer un OS linux.

• Petit détail avec la version 3.3 vous pouvez choisir quelle type de serveur installer:

•  Si c’est votre première installation, choisissez « Central server with database ».
• « Central server without database » installera Centreon sans la base de données.
• « Poller Server » correspond à un relais Centreon au cas ou votre infrastructure est tellement grande qu’un seul serveur de monitoring ne suffirait pas en terme de ressources.
• « Database Server » correspond à l’installation de la base de donnée uniquement.

Une fois l’installation terminée connectez vous sur l’interface web  (http://<ip_du_serveur>/centreon).

Un assistant de configuration va alors s’afficher:

Cliquez sur suivant:

L’écran ci-dessous affiche comme quoi la timezone n’est pas initialisé dans le fichier php.ini (un classique)

Connectez vous sur votre machine et éditez le fichier /etc/php.ini. Modifier la ligne « ;date.timezone = » par « date.timezone = « Europe/Paris » » puis redémarrez http (service https restart).

Cliquez ensuite sur le bouton refresh pour que tout soit au vert puis, cliquez sur le bouton « Next »

Cliquez sur « Next »:

Cliquez sur « Next »:

Renseignez les identifiants qui vont vous permettre de vous connectez à l’interface Web ainsi que les informations demandées:

Cliquez sur « Next » après avoir renseigné les mots de passe de base de données

Attendez que l’installation termine puis cliquez sur next:

Connectez vous sur l’interface WEB avec les identifiants renseignés précédemment:

Je vais vous expliquer ci-dessous la logique  de Centreon. Rassurez vous il n’y a aucune différence avec les autres outils de monitoring disponible sur le marché!

ETAPE 1: Ajout des hosts (machines)

Ceci est la 1er étape, il faut que vous ajoutiez toutes les machines que vous voulez monitorer.

Pour cela connectez vous sur votre interface centreon via l’interface web (http://<ip_du_serveur>/centreon) puis, une fois l’authentification effectuée, cliquez sur « Configuration » et « hosts » comme vous le montre les captures d’écrans ci-dessous:

Une fois sur la section des gestion des hosts cliquez sur le bouton  « add »

La page suivante apparaît alors:

Renseignez les différents champs renseignant votre machines et validez en cliquant sur « save » en bas de la page.

ETAPE 2: Commandes.

Les commandes sont les scripts qui vont checker les hosts (Charge cpu,mémoire etc). Ces scripts sont situées dans /usr/lib64/nagios/plugins.

Si vous décidez de développer vos propres scripts de supervision, vous devrez les placer dans ce répertoire afin qu’il soit visible sur la page « command » de Centreon.

ETAPE 3: Services

Les services représentent ce qui va superviser votre machine. Un service contient une commande. C’est le service qui va exécuter votre script de supervision sur le ou les machines et vous renvoyer le résultat.

Pour configurer un service cliquez sur « configuration » puis « service ».

Une fois sur la page cliquez sur « add » pour créer un nouveau service:

Explication de quelques champs:

« Linked with Hosts »: Afin d’associer votre services aux hosts

« Description »: le nom du service tel qu’il apparaîtra sur votre interface de monitoring

« Check Period »: La période ou le service sera actif.

« Check Command »: La command (le script) qui sera effectuée.

« Args »: si le script contient des arguments des champs apparaîtront. Généralement les arguments correspondent aux seuils d’alerte

« Max Check Attempts »: le nombre de check que va faire le service en cas de problème avant de se mettre en alerte (nombre d’essai). (status autre que « OK »)

« Normal Check Interval »: le temps séparant 2 checks. Par exemple si vous spécifier « 1 », le script sera exécuté toutes les minutes. L’avantage d’avoir un interval minimum est que vous serez alerté très vite en cas de problème. Cependant cela demandera plus de ressources réseau et machine.

« Retry Check Interval »: le temps que met le service à rechercker une machine ayant un statut autre que « OK ».

 » Notification Type »: Le type de notification qui sera afficheée par le service.

Cliquez sur « save » une fois votre sélection terminée.

ETAPE 4: Commiter la configuration

Il ne reste plus qu’à faire en sorte que votre configuration soit pris en compte (écriture sur les fichiers de configuration NAGIOS).

Pour cela cliquez sur « configuration » et « pollers »:

Cliquez ensuite sur l’icône d’engrenage en dessous de « Action »:

Cochez « Generate Configuration Files », « Restart Monitoring Engine » et « Move Export Files ».

La « méthod » correspond à l’action effectué pour la prise en compte de votre nouvelle configuration: « reload » ou « restart » le service.

Il ne vous reste plus qu’à cliquez sur export pour que la configuration soit écrite en dur sur les fichiers de configuration Nagios.

Cliquez ensuite sur l’onglet « monitoring » en haut de la page puis sur « host » ou « service » en fonction de la vue que vous voulez avoir.

Il ne reste plus qu’à admirer l’état de vos machines!!

Ce tutoriel reprend juste les grandes lignes de l’administration de Centreon. Le nombre de fonctionnalité possible sur Centreon est énorme (liste de contact, notification SMS, etc…) .

L’interface étant assez intuitive, je trouve que la prise en main est rapide.

Comme je l’ai expliqué plus haut Centreon Entreprise Server Standard et la version « gratuite » (très complète). Des éditions payantes  contenant des extensions propriétaires sont disponibles sur le site. Ces extensions vous permettent par exemple de générer des rapport pointues,  des vues plus poussées, etc…

Je vous conseil également ce site:  http://nagios.manubulon.com/

Ce site contient une multitude de scripts de supervision (command) que vous pourrez rajouter.

Article publiée le 23 Mai 2016

Depuis pas mal de temps je bosse sur la configuration SSL des serveurs web. Ayant rejoint une entreprise dont la préoccupation sur la sécurité est forte j’ai pu connaitre l’existence de petits outils permettant de faire un check complet de la configuration SSL (HTTPS) de votre site Web.

Cet outil est vraiment bien et peu notamment vous servir en cas d’audit pour prouver que la configuration de vos serveurs web est sérieuse.

1) Qualys SSL LABs

Le plus connu et réputé Qualys SSLLABS. Via cette page web vous pouvez avoir un diagnostic complet de votre site avec une note ainsi que des indications sur ce qui peut être amélioré:

2) API SSL Labs

Pour ceux qui sont vraiment à fond dans la configuration SSL de leurs serveurs web, je leur propose une petite solution afin d’automatiser les checks de leurs site. Pour ma part un script va vérifier chaque jour que les serveurs webs de mon employeur aient la note A+.

Afin d’éviter de réinventer la roue, un petit outil opensource en ligne de commande existe:

https://github.com/ssllabs/ssllabs-scan

Ci dessous la procédure pour l’installer

• Téléchargez le package
• Assurez vous d’avoir les outils de compilations (make, gcc etc…), pour les utilisateurs de Debian faites un « apt-get install build-essential » et vous serez tranquille 😉
• Assure vous également que golang-go soient installé:
  • Sous debian: apt-get install golang-go
  • RedHat/Centos: Installez les dépots EPEL  et installez le paquet golang (yum install epel-release && yum install golang)
• Enfin il ne vous reste plus qu’à compiler avec la commande « make » à la racine du répertoire contenant les sources de ssllabs-scan
• Enfin lancer le binaire ssllabs-scan <URL>:
• Une fois l’exécution terminée un fichier avec le résultat complet de votre test sera créé.

3) Scripts d’automatisations

Enfin, j’ai conçu un petit script permettant de monitorer automatiquement la note et d’envoyer une alerte si jamais la note que vous désirez et inférieur.

#!/bin/bash

BASEDIR=$(dirname $(readlink -f $0))

SSL_LABS_BINARY=$BASEDIR/bin/ssllabs-scan
SSL_LABS_CONF=$BASEDIR/conf/hosts.conf
SSL_LOGS_DIR=$BASEDIR/logs

unset HTTP_PROXY

if [ ! -f $SSL_LABS_BINARY ] || [ ! -f $SSL_LABS_CONF ]; then
echo « ERREUR: Arret du script, l’un des fichiers n’est pas présent »
exit 1
fi

if [ ! -d $SSL_LOGS_BINARY ]; then
mkdir $SSL_LOGS_DIR
fi

audit_securite ()
{
LOGNAME= »`date +%Y%m%d` ».log
$SSL_LABS_BINARY –hostfile $SSL_LABS_CONF >> $SSL_LOGS_DIR/$LOGNAME
if [ $? -eq 0 ]; then
echo « Rapport de securite généré et disponible dans $SSL_LOGS_DIR/$LOGNAME »
else
echo « Erreur durant la génération du rapport » >> $SSL_LOGS_DIR/$LOGNAME
mail -a « from:ssllabs » -s « Erreur de génération du rapport SSLLABS » [email protected] <<< ‘Bonjour, une erreur a été detectée durant la génération quotidienne du rapport SSLLABS.’
exit 1
fi
}

rapport_securite ()
{
LOGNAME= »`date +%Y%m%d` ».log
RAPPORT_TEMP=$(grep ‘grade’ $SSL_LOGS_DIR/$LOGNAME | grep -v ‘gradeTrustIgnored’)
NOTE_FINALE=$(echo $RAPPORT_TEMP | cut -d « : » -f2 | cut -c3-4)

if [ « $NOTE_FINALE » != « A+ » ]; then      # Changer ici pour la note désirée
mail -a « from:ssllabs » -s « WARNING : NOTE SSLLABS INFERIEURE A A+ » [email protected] <<< ‘Bonjour, la note SSLLABS est inferieure a A+, Merci de verifier la conf Apache !’
fi
}

audit_securite
rapport_securite

Dans le fichier hosts.conf, indiquez juste l’URL du site que vous voulez monitorer

Article publiée le 6 Mai 2016

Article mise à jour le 23 Juin 2017

Un petit tuto sur le système (et gestionnaire de volume) ZFS. En travaillant sur des serveurs ayant ce système de fichiers, j’ai pu voir son incroyable potentiel !

IL est courant que ZFS fasse peur à tort étant donnée que la corruption de données n’existe pas avec ce système de fichiers…En effet, avec ZFS, aurevoir fsck et compagnie!

ZFS est un système de fichiers développé à l’origine par SUN. Les caractéristiques de ZFS sont quasiment illimités:

• 2⁴⁸ : le nombre d’instantanés maximal ;
• 2⁴⁸ : le nombre de fichiers dans chaque système de fichiers ;
• 16 exbioctets : la taille maximum du système de fichiers ;
• 16 exbioctets : la taille maximum d’un seul fichier ;
• 2⁵⁶ : le nombre maximal théorique de fichiers par répertoire (en réalité limité à 2⁴⁸ par le nombre maximal de fichiers dans un système de fichiers).

De plus ZFS possède un système de snapshots incroyablement puissant!

Ci-dessous un petit tuto expliquant comment utiliser ZFS.

1) Installation

1.1) Sous Debian/Ubuntu

ZFS est disponible dans les dépots backport.

Ajouter les dépots Backport puis installez ZFS

Installez maintenant ZFS: apt-get update && apt-get install zfs-dkms zfsutils-linux zfsutils-linux

1.2) Sous RedHat/Centos (Redhat7 / Centos7 ou supérieu)

Installez ZFS : yum install zfs-dracut

Activer le module ZFS: modprobe zfs

2) Création d’un volume ZFS (ZPOOL)

2.1) Création d’un ZPOOL simple

Nous allons pour cela créer un zpool. Un zpool est comparable à un VG dans LVM sauf que l’on peut directement le monter en tant que volume étant donnée qu’il est nativement en ZFS:

zpool create -f <nom de votre zpool> <votre disque>

Exemple: zpool create -f zfspool sdb

2.2) Création d’un RAID

zpool create -f mypool <type de raid> <vos disques>

Exemple: zpool create -f zfspool raidz sdb sdc sdd sde sdf

Vous devez renseigner l’argument <type de raid> par le RAID que vous souhaitez créer :

MIRROR: RAID1

RAIDZ: Equivalent RAID5 amélioré

RAIDZ-1: Avec un disque de parité supplémentaire.

RAIDZ-2: Avec deux disques de parité supplémentaire.

RAIDZ-3: Avec trois disques de parité supplémentaire.

2.3) Lister les ZPOOL

Nous allons maintenant lister notre ZPOOL fraîchement crée:

zpool list

Vous devriez obtenir ceci:

Vous pouvez également avoir un statut global de votre ZPOOL:

zpool status

2.4) Supprimer un ZPOOL

zfs destroy <zpool>

Exemple:

zfs destroy zfspool

2.5) démonter un ZPOOL

Vous pouvez monter votre ZPOOL avec la commande:

zfs umount <nom de votre zpool>

Exemple:

zfs umount zfspool

2.6) Agrandir un ZPOOL

Admettons que vous ayez besoin d’espace supplémentaire.

Après avoir rajouté votre disque où volume il suffit d’utiliser la commande suivante:

zpool add <nom de votre zpool> <nom de votre volume>

Exemple:

zpool add zfspool  sdc

2.6) Modifier les paramètres d’un ZPOOL

2.6.1 Changer le point de montage d’un ZPOOL

Par défaut les points de montage ZFS sont créés à la racine.

Vous pouvez modifier le point de montage avec la commande :  zfs set mountpoint= <le chemin de votre point de montage> <nom de votre zpool>

Exemple:

zfs set mountpoint=/mnt/zfs zfspool

3) Gestion des partitions ZFS

3.1) Créer une partition 

zfs create <nom de votre zpool><nom de votre nouvelle partition>

Exemple:

zfs create zfspool/partition1

3.2) Renommer une partition

zfs rename <zpool><votre partition> <zpool><nom de votre nouvelle partition>

Exemple:

zfs rename zfspool/partition1 zfspool/partitionnew

 

3.3) Supprimer une partition

zfs destroy <zpool><votre partition>

Exemple:

zfs destroy zfspool/partition1

4) Monter un ZPOOL

Vous pouvez monter votre ZPOOL avec la commande:

zfs mount <nom de votre zpool>

Exemple:

zfs mount zfspool

5) Snapshot

5.1 Créer un snapshot 

zfs snapshot <zpool ou partition>@<nom de votre snapshot>

Exemple:

zfs snapshot zfspool@07052016

5.2 Lister les snapshot

zfs list -t snapshot

5.3 Utiliser un snapshot

Commande: zfs rollback <nom de votre snapshot>

Exemple:

Nous allons créer un fichier:

Nous allons créer un snapshot:

Nous allons maintenant supprimer le fichier:

Nous allons utiliser notre snapshot pour le restaurer:

(enjoy ;))

5.4 Supprimer un snapshot

zfs destroy <nom de votre snapshot>

Exemple:

zfs destroy zfspool/partition2@aujourdhui

Autres tutoriels sur les systèmes de fichiers:

LVM: http://journaldunadminlinux.fr/tutoriel-gerez-votre-systeme-de-fichier-grace-a-lvm-logical-volume-management/

BTRFS: http://journaldunadminlinux.fr/presentation-de-btrfs-et-comment-migrer/