Blogs intéressants
Blog d'Omid Ameri : Dédié à la virtualisation et au système.
Sponsor

PostHeaderIcon tuto | sauvegardez vos instances rundeck

Article publiée le 15 Août 2017

Suite à la rédaction du précédent article concernant l’installation et la configuration d’une instance rundeck (https://journaldunadminlinux.fr/tuto-installez-et-configurer-rundeck-ordonnanceur-opensource/), vous trouverez ci-dessous un outil permettant de sauvegarder entièrement votre instance rundeck.

 

1) Installation des prérequis

Les scripts de backups/restore que j’ai écrit utilisent le client en ligne de commande rundeck: « rd »

Installation sous Debian/Ubuntu

echo « deb https://dl.bintray.com/rundeck/rundeck-deb / » | sudo tee -a /etc/apt/sources.list
curl « https://bintray.com/user/downloadSubjectPublicKey?username=bintray » > /tmp/bintray.gpg.key
apt-key add – < /tmp/bintray.gpg.key
apt-get -y install apt-transport-https
apt-get -y update
apt-get -y install rundeck-cli

Installation sous RedHat/Centos

wget https://bintray.com/rundeck/rundeck-rpm/rpm -O bintray.repo
sudo mv bintray.repo /etc/yum.repos.d/
yum install rundeck-cli

Une fois l’installation terminée, éditez le fichier .profile du compte qui fera le backup et rajoutez y les lignes suivantes:

export RD_URL=http://<ip ou dns de votre machine rundeck>/api/20
export RD_USER=<login rundeck>
export RD_PASSWORD=<password rundeck>

2) Script de sauvegarde

Le user qui lance ce script doit avoir les privilèges root (sudo)

Ci-dessous un script de sauvegarde:

#!/bin/bash
# Variables utiles
DATE=`date +%Y%m%d`

# répertoire où les sauvegardes seront déposées
BACKUPDIRECTORY= » »

# Repertoire home du user qui fera les backups
HOMEBACKUPDIRECTORY= »/ »
mkdir backup_tmp

echo « Création d’un DUMP de base »
mysqldump rundeck >> $HOMEBACKUPDIRECTORY/backup_tmp/rundeck.sql

echo « Récupération de la liste des projets en cours… »
rm -f list_projet.tmp
rd projects list | grep -v « # » >> list_projet.tmp

lineone=`head -1 list_projet.tmp | cut -c5-100 >> list_projet.tmp`
sed -i 1s/.*/$lineone/ list_projet.tmp

echo « Sauvegarde des projets en cours… »
while read PROJET
do
rd jobs list -f $HOMEBACKUPDIRECTORY/backup_tmp/jobs_$PROJET.xml -p $PROJET 2> /dev/null
done < list_projet.tmp
rm -f list_projet.tmp

echo « Arret de Rundeck en cours… »
sudo service rundeckd stop

echo « Copie des répertoires logs et data »
sudo cp -r /var/lib/rundeck/data $HOMEBACKUPDIRECTORY/backup_tmp
sudo cp -r /var/lib/rundeck/logs $HOMEBACKUPDIRECTORY/backup_tmp
sudo cp -r /var/rundeck $HOMEBACKUPDIRECTORY/backup_tmp

echo « Démarrage de Rundeck en cours… »
sudo service rundeckd start
sudo tar -czvf backuprundeck$DATE.tar.gz backup_tmp/*

echo « Déplacement du backup vers le serveur NFS »
sudo mv backuprundeck$DATE.tar.gz $BACKUPDIRECTORY

echo « Suppression du répertoire temporaire »
sudo rm -Rf backup_tmp

 

 

3) Script de restauration

#!/bin/bash

# répertoire où les sauvegardes sont déposées
BACKUPDIRECTORY= » »

echo « Arret de rundeck »
sudo service rundeckd stop

echo « Récupération du dernier backup »
FILETORESTORE=`ls -1t /srv/rundeckconfbackup | head -1`
cp -R $BACKUPDIRECTORY/$FILETORESTORE .
sudo tar -xf $FILETORESTORE

echo « Importation du DUMP de base »
mysql rundeck < ~/backup_tmp/rundeck.sql

echo « Démarrage de rundeck »
sudo service rundeckd start

# Rundeck est long à démarrer…
sleep 90

# Purge de tout les projets avant une resto propre
echo « Purge de la conf rundeck en cours… »
rd projects list | grep -v « # » >> list_projet.tmp

lineone=`head -1 list_projet.tmp | cut -c5-100 >> list_projet.tmp`
sed -i 1s/.*/$lineone/ list_projet.tmp
while read file
do
PROJET=`echo $file | cut -d « _ » -f2 | cut -d « . » -f1` 2>/dev/null
rd projects delete -p $PROJET -y 2>/dev/null
done < list_projet.tmp
rm -f list_projet.tmp

 

# On récupère le nom du projet via le nom du fichier XML et pour on importe le ou les jobs
cd ~/backup_tmp
for file in `ls *.xml`
do
PROJET=`echo $file | cut -d « _ » -f2 | cut -d « . » -f1`
echo « Restauration du projet $PROJET »
rd projects create -p $PROJET 2>/dev/null
rd jobs load -f $file -p $PROJET 2>/dev/null
done
# On recopies le répertoire /var/lib/rundeck ainsi que les logs des JOBS
echo « Copie des logs en cours »
sudo cp -R ~/backup_tmp/logs /var/lib/rundeck
echo « Copie des datas en cours »
sudo cp -R ~/backup_tmp/data /var/lib/rundeck && sudo chown -R rundeck:rundeck /var/lib/rundeck
sudo cp -R ~/backup_tmp/rundeck /var/ && sudo chown -R rundeck:rundeck /var/rundeck

echo « Restauration terminée »
cd ..

sudo rm -Rf ~/backup_tmp
if [ -f $FILETORESTORE ]; then
sudo rm -f $FILETORESTORE
fi

 

 

PostHeaderIcon tuto | Installez et configurez rundeck (ordonnanceur opensource)

Article publié le 14 Août 2017

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-.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

 

 

 

 

 

 

 

 

PostHeaderIcon Mettre à jour Debian 8 Jessie vers Debian 9 Stretch

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!

 

 

PostHeaderIcon Tuto | Installer et configurer un serveur WildFly

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/)

PostHeaderIcon Tuto | Installer et configurer OpenNebula sous Debian

Article publié le 6 Juin 2017

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 opennebula-sunstone opennebula-gate opennebula-flow

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)

 

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

 

PostHeaderIcon Vérifiez la sécurité de votre site wordpress avec WPSeku

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 ;-))

PostHeaderIcon PyDash | Outil de monitoring Web pour Linux

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 webmaster@dummy-host.example.com
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 webmaster@dummy-host.example.com
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

 

 

 

 

 

PostHeaderIcon Tuto | Installation et configuration de nginx + Loadbalancing

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!

 

 

 

 

 

 

 

 

 

 

 

 

 

PostHeaderIcon Tuto Docker | Gérer vos container avec Docker compose

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

– GITLAB_EMAIL=notifications@example.com
– GITLAB_EMAIL_REPLY_TO=noreply@example.com
– GITLAB_INCOMING_EMAIL_ADDRESS=reply@example.com

– 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
– SMTP_USER=mailer@example.com
– SMTP_PASS=password
– SMTP_STARTTLS=true
– SMTP_AUTHENTICATION=login

– IMAP_ENABLED=false
– IMAP_HOST=imap.gmail.com
– IMAP_PORT=993
– IMAP_USER=mailer@example.com
– 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>

PostHeaderIcon Tuto Docker | Démarrer avec Docker

Article publié le 09/02/2017

Après 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:

echo « deb https://apt.dockerproject.org/repo debian-jessie main » > /etc/apt/sources.list.d/docker.list

apt-key adv –keyserver hkp://p80.pool.sks-keyservers.net:80 –recv-keys 58118E89F3A912897C070ADBF76221572C52609D

apt-get update && apt-get install docker-engine

Sous Centos:

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

vi /etc/yum.repos.d/docker.repo
[dockerrepo]
name=Docker Repository
baseurl=https://yum.dockerproject.org/repo/main/centos/7/
enabled=1
gpgcheck=1
gpgkey=https://yum.dockerproject.org/gpg
yum install docker-engine
systemctl enable docker
systemctl start docker
Afin de nous faciliter la vie, on attribue les droits à notre utilisateur pour éviter de bosser avec root.
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:

Allons encore un peu plus loin en mappant des répertoires internes de votre container directement sur un répertoire de votre serveur (par exemple pour mettre à jour le contenu d’un site web hébergé dans votre container).
docker run -d -p 9876:80 –name=WebServer4 -v /home/usr/www:/usr/share/nginx/html nginx:latest

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 vdahmane@gmail.com
# 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 »]
Reste plus qu’à créer notre container depuis le Dockerfile.
On crée notre image Docker:
docker build -t myapache .
On installe notre container:
docker run -d -P 9999:80 –name=Debianapache myapache:latest
Il ne reste plus qu’à vérifier via l’IP de votre serveur Docker si le serveur apache est accessible:

IV) Autre commandes utiles

Supprimer tout les container actifs:
docker rm `docker ps -a -q`
Démarrer ou arrêter un container :
docker start <container>
docker stop <container>
Supprimer tout les container actif:
docker rm `docker ps -a -q`
Supprimer une image docker (vérifier qu’aucun container n’est actif):
docker rmi <image>
Vous connecter directement sur votre container:
docker run -it <votre container> /bin/bash

VI) Repository

Le repository docker https://hub.docker.com/explore/ contient toutes les images dockers possible et imaginable. Vous pouvez aussi bien trouver des container apache que nginx voir même des images de distributions Linux comme Centos ou Debian. Je vous suggère de créer un compte et d’y  aller faire un tour.

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

 

 

PostHeaderIcon Tuto | Installation d’un serveur PostgreSQL multi-instances

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:
mkdir /srv//pg && chown postgres:postgres /srv//pg && chmod 700 /srv/pg
  • Créez les répertoires pour les fichiers de configurations

mkdir /etc/postgresql/9.4/<instance>
  • 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
data_directory
hba_file
ident_file
external_pid_file
port
  • 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

PostHeaderIcon Tuto | Installez et débutez avec postgresql

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’une Mysql Multi-instances

PostHeaderIcon Tuto | Installation d’une base Mysql Multi-instances

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
  • On crée  les différents users:

     useradd -r mysql1

     useradd -r mysql2

     useradd -r mysql3

 

  • On crée les répertoires avec les bons droits :
mkdir /var/lib/mysql{1,2,3}
mkdir /var/lib/mysql{1,2,3}
chown mysql1:adm /var/log/mysql1
chown mysql2:adm /var/log/mysql2
chown mysql3:adm /var/log/mysql3
mkdir /var/run/mysqld{1,2,3}
chown mysql1 /var/run/mysqld1
chown mysql2 /var/run/mysqld2
chown mysql3 /var/run/mysqld3
  • On initialise les datastores pour chaque instances
mysql_install_db --datadir=/var/lib/mysql1 --user=mysql1
mysql_install_db --datadir=/var/lib/mysql2 --user=mysql2
mysql_install_db --datadir=/var/lib/mysql3 --user=mysql3

 

  • On démarre nos instances:

mysqld_multi --verbose --no-log start 1

mysqld_multi --verbose --no-log start 2

mysqld_multi --verbose --no-log start 3

 

  • Pour stopper une instance spécifique : mysqld_multi --verbose --no-log stop <numéro de l'instance>
  • Il est possible d’avoir un statut pour chaque instance grâce à la commande : mysqld_multi report
  • Enfin la connexion à une instance via le client mysql se fait avec ce type de commande : mysql -uroot –socket=<chemin du fichier>
    Exemple : mysql -uroot -ptoto --socket=/var/run/mysql1/mysqld.sock

PostHeaderIcon Tutoriel | Mettre en place un reverse proxy Apache avec un serveur tomcat

Article publié le 8 Novembre 2016

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>

ProxyPassReserve / <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



PostHeaderIcon tutoriel | Installation et configuration de Tomcat 9

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/

 

PostHeaderIcon Tutoriel | Installer et paramétrer un FTP sécurisé avec VsFTPD

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):

anonymous_enable=NO
# 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
ssl_ciphers=HIGH
– On génère ensuite un certificat auto-signé:
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
– On configure le PAM (vi /etc/pam.d/vsftpd.virtual)
#%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
– On crée le user ftp:
useradd ftp
– On oublies pas de créer le répertoire des comptes FTP selon ce que vous avez indiqué dans le fichier de configuration vsftpd.conf. Dans notre cas /srv/ftp
– Créez le fichier de user ftp (touch /etc/vsftpd/login.txt) et on le renseigne comme l’exemple ci dessous:
user1
passworduser1
user2
passworduser2
– On génère ensuite le fichier login.db (bekerley DB):
db_load -T -t hash -f /etc/vsftpd/login.txt /etc/vsftpd/login.db
– Créez le répertoire FTP associé à l’utilisateur:
mkdir -p /srv/ftp/user1
mkdir -p /srv/ftp/user2
chown -R ftp:ftp /srv/ftp
– Enfin on redémarre le service vsftpd
service vsftpd restart

PostHeaderIcon Tutoriel | chiffrer et déchiffrer avec GnuPG

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

PostHeaderIcon Tutoriel | Installer et configurer le firewall Shorewall

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.

PostHeaderIcon Installer et configurer Centreon Entreprise Server

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.

 

 

 

PostHeaderIcon Testez la configuration SSL de vos serveurs avec ssllabs

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 » votremail@votredomaine.com <<< ‘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+ » votremail@votredomaine.com <<< ‘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

 

image_print