OpenERP: export de base de données – compression extrême avec lzma

Exporter une base

$ pg_dump -Fp --no-owner ma_base_openerp > ma_base_openerp.sql

-Fp: on exporte au format plain text

–no-owner: on ne sauvegarde pas le nom du propriétaire

Et pour importer une base ??

Pour importer une base exportée:

$ psql -d nom_de_ma_base_openerp -f mon_export.sql

Compression extrême avec lzma

Dans le cas d’une très grosse base de données, il peut être intéressant de la compresser la base. pg_dump a une option de compression mais le ratio peut être grandement amélioré avec lzma.

LZMA, pour Lempel-Ziv-Markov chain-Algorithm, est un algorithme de compression de données en développement jusqu’à 2001 et utilisé dans le format 7z du programme 7-Zip et par StuffitX. Il utilise une compression avec dictionnaire assez similaire au LZ77 et offre un fort taux de compression (en général plus fort que le Bzip2) et une taille variable de dictionnaire de compression (jusqu’à 4 Go). (voir aussi LZW) source Wikipedia

Donc voici comment exporter une base et la compresser à la volée avec lzma:

$ pg_dump -Fp --no-owner ma_base_openerp | lzma --best -f -c > ma_base_openerp.lzma

L’option –best permet d’obtenir le meilleur ratio de compression.

A titre d’exemple, j’avais une base de donnée qui, non compressée, faisait 1,3 Go.

En utilisant le meilleur ratio de compression de pg_dump, je tombe à 373 Mo

lzma fait encore mieux, seulement 64 Mo !!

SSH: chroot facile d’un utilisateur

Nous allons voir 2 choses dans cet article:

  • Tout d’abord, enfermer un utilisateur dans un chroot
  • Donner un accès SSH à cet utilisateur dans son environnement « chrooté »

Introduction

Un chroot est une « prison » où vous allez « enfermer » votre utilisateur. Concrètement, pourquoi enfermer un utilisateur dans un chroot ? A quoi ça sert ?

Et bien, imaginez que vous décidez d’autoriser un utilisateur à accéder aux ressources de votre machine. Ceci pour une raison X ou Y. Ce dernier jouit d’un grand pouvoir. Il peut s’il le désire essayer de se balader dans votre système de fichiers, mettre le nez où il ne devrait pas, lancer des programmes installés, … il peut même aller (si il est suffisamment malin) jusqu’à obtenir des privilèges administrateur…

Bref, l’enfermer dans un chroot, c’est l’enfermer dans un répertoire d’où il ne peut pas sortir, et avec un accès limité aux executables.

Configurer un chroot est habituellement assez chiant, car de base, l’utilisateur ne dispose d’aucun programme, il faut importer des librairies à la main avec ldd, il faut créer les devices /dev/null, /dev/zero, /dev/tty, /dev/urandom avec mknod

Pour nous simplifier la vie, nous allons utiliser un script de Wolfgang Fuschlberger, permettant d’automatiser tout ça.

Vous pouvez le télécharger sur cette page: http://www.fuschlberger.net/programs/ssh-scp-sftp-chroot-jail/

J’ai eu un problème avec ce script avec notamment ce message d’erreur:

./make_chroot_jail.sh: 428: cannot create : Directory nonexistent

La solution se trouve ici: http://ubuntuforums.org/showpost.php?p=5583234&postcount=5

Il faut en fait supprimer au début des lignes 406 et 407 :

TMPFILE1=`mktemp` &> /dev/null ||

Allez, assez de bla-bla, on y va !!

Chroot utilisateur

Installation de paquets nécessaires:

# aptitude install sudo debianutils coreutils

On télécharge le script et on le rend executable:

# cd /usr/local/sbin
# wget https://jcvassort.open-web.fr/scripts/make_chroot_jail.sh
# chmod 700 /usr/local/sbin/make_chroot_jail.sh

Avant d’utiliser le script, vous pouvez décider d’ajouter/supprimer vers la ligne 111 les applications disponibles dans le chroot:

# Specify the apps you want to copy to the jail
if [ "$DISTRO" = SUSE ]; then
 APPS="/bin/bash /bin/cp /usr/bin/dircolors /bin/ls /bin/mkdir /bin/mv /bin/rm /bin/rmdir /bin/sh /bin/su /usr/bin/groups /usr/bin/id /usr/bin/netcat /usr/bin/rsync /usr/bin/ssh /usr/bin/scp /sbin/unix_chkpwd"
elif [ "$DISTRO" = FEDORA ]; then
 APPS="/bin/bash /bin/cp /usr/bin/dircolors /bin/ls /bin/mkdir /bin/mv /bin/rm /bin/rmdir /bin/sh /bin/su /usr/bin/groups /usr/bin/id /usr/bin/nc /usr/bin/rsync /usr/bin/ssh /usr/bin/scp /sbin/unix_chkpwd"
elif [ "$DISTRO" = REDHAT ]; then
 APPS="/bin/bash /bin/cp /usr/bin/dircolors /bin/ls /bin/mkdir /bin/mv /bin/rm /bin/rmdir /bin/sh /bin/su /usr/bin/groups /usr/bin/id /usr/bin/nc /usr/bin/rsync /usr/bin/ssh /usr/bin/scp /sbin/unix_chkpwd"
elif [ "$DISTRO" = DEBIAN ]; then
 APPS="/bin/cat /bin/bash /bin/cp /usr/bin/dircolors /bin/ls /bin/mkdir /bin/mv /bin/rm /bin/rmdir /bin/sh /bin/su /usr/bin/groups /usr/bin/id /usr/bin/rsync /usr/bin/ssh /usr/bin/scp /sbin/unix_chkpwd"
else
 APPS="/bin/bash /bin/cp /usr/bin/dircolors /bin/ls /bin/mkdir /bin/mv /bin/rm /bin/rmdir /bin/sh /bin/su /usr/bin/groups /usr/bin/id /usr/bin/rsync /usr/bin/ssh /usr/bin/scp /usr/sbin/unix_chkpwd"
fi

Création d’un répertoire où sera enfermé l’utilisateur. Je le crée à la racine et le nomme chroot:

# mkdir /chroot

C’est le moment d’utiliser le script. Il s’utilise de cette manière:

# make_chroot_jail.sh username [/path/to/chroot-shell [/path/to/chroot]]

chroot-shell est un shell spécialement créé par le script pour chrooter les utilisateurs. Mais maintenant qu’OpenSSH supporte le chroot, on indique le shell à utiliser. Concernant l’utilisateur, si il n’existe pas, il sera créé. Si il existe, son profil sera mis à jour.

Pour un utilisateur toto enfermé dans /chroot avec comme shell bash:

# make_chroot_jail.sh toto /bin/bash /chroot

Répondez yes aux questions.

Si vous avez ce message d’erreur:

./make_chroot_jail.sh: 428: cannot create : Directory nonexistent

J’ai donné la solution plus haut…

Configuration de SSH

Le but étant de donner un accès SSH à cet utilisateur, il ne reste plus qu’à configurer son accès SSH. Ça se passe dans /etc/ssh/sshd_config:

Ajoutez ceci à la fin du fichier:

Match User toto
    ChrootDirectory /chroot
    AllowTCPForwarding no
    X11Forwarding no

Si vous chrootez un groupe d’utilisateurs, remplacez User par Group.

Pour toute question, direction les commentaires…

Source: http://www.howtoforge.com/chrooted-ssh-sftp-tutorial-debian-lenny

Samba / SWAT: installation rapide

Sous un système à base Debian / Ubuntu:

# aptitude install samba swat

Voilà, c’est installé ! Place à la configuration, ouvrez votre navigateur à l’adresse http://127.0.0.1:901 Une fenêtre d’authentification apparaît, loguez-vous avec l’utilisateur root pour la configuration.

Les options par défaut suffisent pour une utilisation basique. Dans la partie GLOBALS, vous pouvez personnaliser le Netbios Name, c’est le nom qui va apparaître lorsque vous parcourrez votre réseau.

C’est dans la partie SHARE que vous configurez vos partages.

Les champs indispensables sont:

  • path: le répertoire à partager, par exemple /media/disk
  • valid users: les utilisateurs autorisés à accéder au partage, séparés par une virgule si il en a plusieurs.
  • admin users: les super-utilisateurs autorisés à modifier tout le contenu du répertoire
  • read list: les utilisateurs autorisés à lire, mais pas à écrire
  • read only: le répertoire sera en lecture seule
  • guest OK: est-ce que l’on autorise les utilisateurs non-authentifiés à accéder au partage ?
  • Browsable: doit être à Yes pour parcourir le partage
  • Available: obligatoirement à Yes si vous voulez pouvoir accéder à votre partage

Concernant les utilisateurs, on peut définir également des groupes, il suffit pour cela d’ajouter un @ devant le nom. Par exemple pour le groupe toto: @toto.

Justement, il est temps de voir comment ajouter des utilisateurs. SWAT ne peut gérer que des utilisateurs déjà présents dans le système.

Pour cela, dans une console:

# adduser toto

Et hop, l’utilisateur toto est présent dans le système. Pour le faire connaître à votre serveur SAMBA, allez dans la section Password. C’est ici que vous pourrez ajouter des utilisateurs, modifier leur mot de passe, etc.

Pour toute question, il y a les commentaires ^^

Problème de connexion Gwibber / StatusNet résolu !!

Je galère depuis plusieurs mois à faire communiquer Gwibber avec mon instance de microblog Status.net.

Alors que je pouvais communiquer sans soucis avec Facebook et Twitter, ce qui m’intéressait avant tout, c’était la connexion avec Status.net.

J’ai tout d’abord activé les logs dans le fichier config.php de status.net:

$config['site']['logfile'] = '/tmp/statusnet.log';

Ce que j’ai observé dans les logs lorsque je tentais de me connecter avec Gwibber, ce sont les multiples erreurs d’authentification:

2010-11-27 13:48:13 LOG_DEBUG: [jcvassort.open-web.fr:22950.01e2a9a3 GET /microblog/api/statuses/mentions.json?count=200] apiaction.php - User error '401' on 'ApiTimelineMentions': Could not authenticate you.

Quant à l’interface Gui de Gwibber:

Erreur d’authentification sur statusnet pour le compte jcvassort

J’ai trouvé la solution par hasard sur le forum de Status.net sur ce thread :

Password authentication in the API currently doesn’t work if PHP is configured on the CGI or FastCGI interfaces…

En gros, l’authentification ne fonctionne pas si PHP est configuré en mode CGI ou FastCGI. Or c’est justement le cas de mon serveur !!

J’ai trouvé la solution quelques lignes plus loin, solution qui consiste à affiner le fichier .htaccess en ajoutant ces lignes:

RewriteCond %{HTTP:Authorization} ^(.*)
RewriteRule ^(.*) - [E=HTTP_AUTHORIZATION:%1]

La connexion Gwibber <> Status.net est maintenant OK \0/

Mon microblog: https://jcvassort.open-web.fr/microblog/

Extensions PHP PECL: créer un paquet Debian

En consultant dernièrement les Status Reports dans Drupal, ce dernier me conseillait d’installer l’extension PECL uploadprogress afin d’avoir une barre de progression pour l’upload de fichiers, bref…
Si on consulte la doc PHP, on peut voir qu’il suffit de faire un simple:

$ pecl install extension

Nous allons voir ici comment créer un paquet Debian de cette extension PECL. Pourquoi un paquet Debian ? Pour que notre petite extension ajoutée à la mimine soit connue du système apt.

On installe les paquets nécessaires:

# aptitude install php5-dev dh-make-php fakeroot libicu-dev xsltproc 

C’est le paquet dh-make-php qui va nous permettre de construire les sources nécessaires à notre futur paquet Debian.

Une petite description:

$ apt-cache show dh-make-php
(...)
Description: Creates Debian source packages for PHP PEAR and PECL extensions
 Contains dh-make-pear and dh-make-pecl, which create Debian source packages
 from PHP PEAR and PECL packages respectively.
(...)

Une fois les paquets installés, on peut remplacer pecl install extension par :

$ dh-make-pecl --only 5 --maintainer "John Doe " extension

Remplacez John Doe par votre nom et adresse mail, et bien sur « extension » par l’extension PECL que vous voulez installer. dh-make-pecl se charge de downloader et préparer le répertoire source pour vous.
L’option –only 5, c’est pour ne prendre en compte que php5.

Vous devriez maintenant avoir un répertoire portant le nom de votre extension. Placez-vous dedans et faites pour contruire le paquet:

$ dpkg-buildpackage -rfakeroot

Retournez dans le répertoire parent, vous devriez y trouver un paquet *.deb tout frais.

Il n’y a plus qu’à installer !!

PostgreSQL: Changer le propriétaire d’une base de données

Après avoir importé une base de données PostgreSQL de cette manière…

psql nom_de_ma_base < import.sql

... OpenERP ne trouvait la trouvait pas. Tout simplement car le propriétaire de la base n'était pas bon.
Voici comment le changer, on se connecte sous l'utilisateur postgres:

sudo su postgres

Puis on lance la requète suivante (adaptez l'utilisateur et le nom de la base):

UPDATE pg_database SET datdba = (SELECT usesysid FROM pg_shadow WHERE usename = 'nom_de_l_utilisateur') WHERE datname = 'nom_de_la_base'

OpenERP: mot de passe oublié

Il peut arriver que l’on ne se souvienne plus de son mot de passe administrateur OpenERP. Voici comment le retrouver.

Logguez-vous via ssh (ou autre) sur le serveur où se trouve votre base de données. Si vous travaillez en local, c’est localhost :-p

Connectez-vous en tant qu’utilisateur postgres:

$ sudo su postgres

Connectez-vous à votre base de données:

$ psql le_nom_de_ma_base_de_données

Il ne vous reste plus qu’à executer la requète suivante (n’oubliez pas le point-virgule à la fin de la requète):

SELECT login, password FROM res_users;

A vous d’adapter cette requête en fonction du login recherché (admin, demo, ou je ne sais quoi d’autre).

Installation de Seeks sous Debian

Présentation

Seeks est un projet de meta-moteur de recherche libre. Il utilise pour le moment les résultats des moteurs de recherches commerciaux comme Google, Yahoo, Bing, … pour ne citer que les plus gros.

Je dis « pour le moment » car il aspire à devenir à terme un moteur de recherche Peer2Peer complètement décentralisé, et n’utilisant que les noeuds des autres serveurs Seeks installés sur différents serveurs.

Nous allons voir dans cet article comment l’installer sur une distribution Debian.

Installation

Pour se faciliter la vie, il existe des dépôts Debian.

On les ajoute (en étant connecté en root):

# wget http://archive.sileht.net/seeks/seeks-lenny.list -O - | tee /etc/apt/sources.list.d/seeks.list

On enregistre la clef:

# apt-key adv --recv-keys --keyserver keyserver.ubuntu.com EC0FC7E8

On met à jour et on installe:

# aptitude update
# aptitude install seeks

Pour pouvoir utiliser Seeks, on installe le serveur web lighttpd, ainsi que php et php-curl:

# aptitude install lighttpd php5-cgi php5-curl

On active fastcgi pour pouvoir utiliser php avec lighttpd, puis on relance le serveur:

# lighty-enable-mod fastcgi
# /etc/init.d/lighttpd force-reload

Pour terminer, on crée dans /var/www/ un fichier index.php qui va rediriger les requêtes:



Votre moteur de recherche libre (et bientôt décentralisé 😉 ) est fonctionnel.
Vous pouvez y accéder à l’adresse: http://adresse-de-votre-serveur/index.php/websearch-hp/

J’ai moi-même installé Seeks, vous pouvez y effectuer vos recherches: https://jcvassort.open-web.fr/search.php/websearch-hp