Étiquette : linux

Catégories
Open-source Reseau Systeme

Utilisation du protocole NFS avec votre NAS

J’ai un NAS Synology DS110+ chez moi pour sauvegarder mes données et comme de serveur DLNA vers ma télévision.

Depuis le début j’avais utilisé le protocole réseau SMB (aka CIFS), installé et configuré par défaut sur le NAS.

Comme je n’étais pas satisfait des performances et de l’intégration de ce protocole sur ma distribution Ubuntu, j’ai décidé d’activer un protocole issu du monde Unix: j’ai nommé NFS.

Activation de NFS sur le NAS Synology DS110+

C’est assez simple en se connectant sur l’interface d’administration Web DSM:

Configuration de Linux comme client NFS

Sous une distribution Debian ou Ubuntu, il suffit d’installer le paquet autofs. Celui-ci prendra en charge nativement le protocole NFS:

sudo aptitude install autofs

Ensuite il faut éditer les deux fichiers suivants:

/etc/auto.master

/media/nas /etc/auto.nfs –ghost,–timeout=60

Ce fichier permet de définir dans quel répertoire de votre machine client GNU/Linux les répertoires partagés par votre NAS seront présentés (/media/nas dans mon cas).

/etc/auto.nfs

video -fstype=nfs,rw,intr 192.168.0.253:/volume1/video

Dans ce second fichier, on défini la liste des répertoires partagés (un répertoire par ligne). Par exemple, nous allons « mounter » le répertoire NFS /volume1/video du serveur NAS (adresse IP 192.168.0.253) vers le répertoir /media/nas/video de notre machine client GNU/Linux.

On relance ensuite le daemon autofs pour prendre en compte ces deux fichiers de configuration:

sudo service autofs restart

A partir de ce moment là, à partir du moment ou vous utiliserez le répertoire /media/nas/video, un montage sera automatiquement effectué vers votre serveur NAS et les fichiers seront visibles localement.

Et au niveau des performances

Outre une intégration parfaite à Linux, j’ai observé un gain non négligeable des performances notamment lors des phases d’écritures de fichiers sur le serveur NAS.

Sources pour la rédacion ce billet:

Catégories
Nagios Open-source Planet-libre Web

Twitter en ligne de commande (même avec oAuth)

Il y a quelque temps, j’avais écrit un billet sur comment envoyer les alertes de votre serveur Nagios sur un compte Twitter (ou comment réunir les SI et le Web 2.0). Malheureusement, depuis cette date,  Twitter a changé la méthode d’authentification pour poster des tweets. Ce n’est plus une authentification HTTP classique (qui pouvait donc être facilement faite en ligne de commande avec curl par exemple) mais une authentification oAuth, beaucoup plus souple mais nettement plus complexe.

Nous allons donc dans ce nouveau billet voir comment mettre en place l’authentification oAuth pour un script Python qui permettra à partir d’une simple ligne de commande de mettre à jour une timeline Twitter.

A vos fourneaux !

Les ingrédients…

Pour suivre cette recette il faut:

  • un compte Twitter
  • la librairie Python python-tweepy
  • un navigateur Web (pour enregistrer votre application)

Installation de Python-tweepy

Cette librairie Python va vous permettre de parler oAuth avec le serveur Twitter. Il existe un PPA pour Ubuntu (pour les autres distribution GNU/Linux, il faut installer la bête en suivant ces instructions):

sudo add-apt-repository ppa:chris-lea/python-tweepy

sudo aptitude update && sudo aptitude install python-tweepy

Update: Sous Debian la procédure à suivre est la suivante (merci Benjamin):

apt-get install python python-setuptools python-json python-twitter

wget http://pypi.python.org/packages/source/t/tweepy/tweepy-1.7.1.tar.gz

tar xvfz tweepy-1.7.1.tar.gz

cd tweepy-1.7.1

python ./setup.py install

Enregistrement de votre script

C’est la première étape: déclarer votre application (votre script) sur le serveur Twitter. Dans la suite de ce billet je vais procéder à l’enregistrement d’une application qui s’appellera ‘tweetit’ (c’est le nom de mon script en ligne de commande qui permettra de mettre à jour ma Timeline).

Pour cela, il faut se rendre à l’URL suivante: http://twitter.com/oauth_clients

Puis cliquer sur Register a new application »

On saisie ensuite le formulaire:

Une fois le formulaire validée, vous devriez être redirigé vers une page contenant deux informations importantes: Consumer key (la clés) et Consumer secret (le mot de passe) de votre application.

Il faut bien sur mettre ces informations de coté.

Connecter votre script à votre compte Twitter

Nous allons utiliser la librairie python-tweepy pour faire cette étape qui ne devra être faite qu’une seule fois lors du développement de votre application.

Le plus simple est de reprendre le script écrit par Jeff Miller sur son blog. On va donc créer un script nommé tweetit-register.py contenant le code suivant (remplacer les codes):

#!/usr/bin/env python

import tweepy

CONSUMER_KEY = ‘VOTRE CODE CONSUMER KEY’

CONSUMER_SECRET = ‘VOTRE CODE CONSUMER SECRET’

auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)

auth_url = auth.get_authorization_url()

print ‘Please authorize: ‘ + auth_url

verifier = raw_input(‘PIN: ‘).strip()

auth.get_access_token(verifier)

print « ACCESS_KEY = ‘%s' » % auth.access_token.key

print « ACCESS_SECRET = ‘%s' » % auth.access_token.secret

On exécute le script:

chmod a+x tweetit-register.py

./tweetit-register.py

Le script va vous afficher une URL  et attendre un code PIN:


Please authorize: http://twitter.com/oauth/authorize?oauth_token=Ndddb0DBsjd6PNYccSEtl8vtdYkNsPRCk5joO7djqO8

PIN:

On copie l’URL dans un navigateur Web:

On récupère ensuite le code PIN que l’on entre dans notre terminal:

PIN: 0665141

On obtient en retour la clés et le mot de passe d’accès :

ACCESS_KEY = ‘7707822-TWzha9rf3icVF1h0FhGnaK5q7iLyNIRzHXDY8aagt4’

ACCESS_SECRET = ‘3dbTcWkU1LIYG4MtwmraausjaoSne5coGbXKOXhDfG0’

Création du script

Voilà (enfin), on peut développer notre application (tweetit.py):

#!/usr/bin/env python


import sys

import tweepy


# Authentification oAuth

CONSUMER_KEY = ‘Consumer Key’

CONSUMER_SECRET = ‘Consumer Secret’

ACCESS_KEY = ‘Access Key’

ACCESS_SECRET = ‘Access Secret’

auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)

auth.set_access_token(ACCESS_KEY, ACCESS_SECRET)

api = tweepy.API(auth)


# Main program

api.update_status(sys.argv[1])

On rend le script executable:

chmod a+x tweetit.py

Test de l’application

On lance le script avec le texte à tweeter:

./tweetitcli.py ‘Petit test depuis la ligne de commande Linux…’

Et voilà le travail:

Et voila, bientôt un prochain billet pour voir comment intégrer ce nouveau script à Nagios 🙂

Source pour la rédaction de cet article:

Catégories
Gstreamer Open-source Planet-libre Video Web

Installation et test de Flumotion 0.8

Flumotion est un serveur de streaming open-source sous licence GPL. Il permet de diffuser à des utilisateurs ne disposant que d’un simple navigateur Web des contenus audio et vidéo.

La dernière version disponible (la 0.8) apporte une fonctionnalité que je trouve intéressante de tester: le support du conteneur WebM et du codec vidéo VP8 que gOOgle à libéré il y a quelques mois.

Nous allons voir dans ce billet comment installer et configurer Flumotion 0.8 sur une distribution GNU/Linux Ubuntu Desktop 10.10.

Compilation de Flumotion 0.8

Récupération des sources:

mkdir ~/src

cd ~/src

wget http://www.flumotion.net//src/flumotion/flumotion-0.8.0.tar.gz

tar zxvf flumotion-0.8.0.tar.gz

cd ~/src/flumotion-0.8.0

Installation des librairies (en plus de mon installation standard d’Ubuntu), j’ai du ajouter:

sudo aptitude install python-all-dev python-kiwi

Configuration et compilation:

./configure

make

sudo make install

sudo mkdir /usr/local/etc/flumotion/

sudo cp conf/default.pem /usr/local/etc/flumotion/

Configuration de Flumotion 0.8

Le serveur Flumotion utilise deux processus: flumotion-manager et flumotion-worker.

Le premier processus (flumotion-manager) à besoin d’un fichier de configuration nommé planet.xml. Je vous propose donc de partir du fichier de configuration fourni avec les sources et de le copier dans un répertoire de votre machine.

mkdir ~/flumotion

mkdir ~/flumotion/conf

cp ~/src/flumotion-0.8.0/conf/managers/default/planet.xml ~/flumotion/conf/

Puis de l’éditer:

gedit ~/flumotion/conf/planet.xml

La ligne vraiment intéressante à modifier est celle-ci:

user:PSfNpHTkpTx1M

Elle défini l’utilisateur user avec le mot de passe par défaut test (encodé).

Remarque: Pour générer un nouveau couple login/password, le plus simple est de ce rendre sur ce site et de remplacer le résultat dans le fichier ~/flumotion/conf/planet.xml.

On lance ainsi le processus avec la commande suivante:

flumotion-manager ~/flumotion/conf/planet.xml &

On vérifie que le processus est bien lancé:

ps auxw | grep flumotion

labo    16352 10.4  0.3  18300 12724 pts/3    S    15:41   0:00 /usr/bin/python /usr/local/bin/flumotion-manager /home/labo/flumotion/conf/planet.xml

Le deuxième processus (flumotion-worker) n’a pas besoin d’un fichier de configuration. Il faut juste passer en paramètre l’utilisateur user avec le mot de passe test (clair) à utiliser pour se connecter au processus flumotion-manager:

flumotion-worker -v -u user -p test

Utilisation de Flumotion 0.8

On va utiliser le programme flumotion-admin pour administrer notre serveur Flumotion:

flumotion-admin &

La fenêtre suivante devrait s’afficher :

Remarque: si vous installez Flumotion sur un serveur sans interface graphique, il faudra utiliser flumotion-admin-text en lieu et place de flumotion-admin.

On clique sur Suivant:

On clique sur Suivant puis on entre le login user et le password test:

Après avoir cliqué sur Suivant, un assistant de configuration (wizard) va s’afficher:

On arrête de cliquer quelques instant pour voir que Flumotion propose deux scénarios:

  • configuration d’un streaming « live » à partir d’une camera / webcam
  • configuration d’un streaming « on demand » à partir d’un fichier

Configuration d’un « streaming live »

Comme un des objectifs de ce billet est de tester la diffusion live en WebM/VP8, on choisi la première option dans la fenêtre suivante:

Si vous n’avez pas de caméra digitale ou de Webcam sur votre machine, vous pouvez utiliser le « test video producer »  qui est en fait une mire de test (je rappelle de Flumotion se base sur GStreamer et cette mire est en fait généré par le plugin videotestsrc).

On configure la mire:

Il est ensuite possible de configurer un texte ou un logo qui sera affiché en overlay sur la vidéo:

On passe ensuite à la configuration de la « mire audio »:

Puis on défini les paramètres du streaming: conteneur, codec vidéo et codec audio:

Au niveau du codec vidéo VP8, on peut soit définir un débit fixe (CBR) ou bien une qualité fixe (VBR). Pour du streaming live, je conseille plutôt du CBR, par exemple à 400 Kbps:

De même pour le codec audio Vorbis:

On défini ensuite si l’on veut streamer sur HTTP (seule option disponible pour l’instant) et/ou sauver le résultat du streaming dans un fichier local sur le serveur (cette option peut être intéressante pour relire la vidéo de manière offline).

Enfin, on défini le point de montage (URL) ainsi que le port TCP à partir duquel le serveur sera accessible. Il est également possible de limiter le streaming (nombre d’utilisateur max, bande passante max…):

On peut également préciser la licence de diffusion de votre streaming:

Et voilà le travail, votre serveur de streaming est opérationnel:

Pour le tester il suffit de ccopier l’URL de l’onglet Statistiques dans (attention pour voir la vidéo depuis une autre machine, il faut remplacer le nom d’hôte avant le :8800 par l’adresse IP de la machine):

  • un navigateur Web compatible WebM/VP8: Chromium
  • un lecteur multimedia compatible WebM/VP8: Totem sous Ubuntu

La vidéo devrait s’afficher:

Pour sauvegarder cette configuration de streaming, il suffit de cliquer sur Connexion > Exporter la connexion puis de sauvegarder le fichier au format XML (Connexion > Importer pour la réimporter dans Flumotion).

Les sources vidéos possibles pour un streaming live sont:

  • la mire (pour les tests)
  • webcam (j’ai rencontré un problème avec la mienne, voir le dernier chapitre de ce billet)
  • TV card
  • Loop video (prend en entrée un fichier OGG et génère une boucle infini à partir de cette vidéo)
  • Firewire

Configuration d’un streaming on-demand (VoD)

Avant de tester la vidéo à la demande, il faut disposer de fichiers vidéos encodés au format WebM (pour la VoD, la version communautaire de Flumotion supporte également le format OGG). Pour produire de tel fichier, je vous conseille la lecture de ce billet. Une fois les vidéos localisées dans un répertoire de votre machine faisant tourner le serveur Flumotion, il suffit de faire appel à l’assistant via le menu Contrôler > Lancer l’assistant de flumotion-admin.

Il faut seulement définir le répertoire ou sont stockées les vidéos:

Puis identifier la liste des vidéos disponibles et leurs URLs dans l’onglet Browser. Là encore, il faut adapter l’adresse en remplaçant le nom logique par l’adresse IP de votre machine Flumotion si vous voulez consulter ces vidéos sur d’autres machines du réseau.

Enfin, vous pouvez ouvrir cette URL soit dans un navigateur Web qui prend en charge WebM (par exemple Chromium):

Soit dans votre lecteur multimédia par défaut (par exemple Totem, ouvrir en utilisant CTRL+L):

Pour une intégration plus « web design compliant » de vos vidéos dans des pages Web (plutôt qu’un bête affichage en full-screen), il faut utiliser le tag HTML5 <video> dont j’ai donné plusieurs syntaxe d’utilisation dans ce billet.

Problèmes rencontrés…

Lors de mes tests, j’ai rencontré un problème lors de la détection de ma WebCam Logitech QuickCam Pro 4000 (qui marche très bien par ailleurs). La détection des informations n’aboutie pas…

Un autre problème est l’ouverture des fichiers VoD à partir de VLC qui supporte pourtant le format WebM. Le son passe correctement mais la vidéo reste désespérément noire…

Catégories
Gstreamer Open-source Planet-libre Systeme Video

Installation complète de GStreamer sous Fedora 14

Gstreamer est un framework multimedia très puissant que j’aborde régulièrement sur mon blog (voir la liste des articles ici). Il fonctionne avec un système de « plugins » lui permettant d’apporter de nouvelles fonctions sans toucher au coeur du framework.

Comme toutes les distributions GNU/Linux, Fedora est installée par défaut avec GStreamer et un certain nombre de plugins (environ 180 sur ma toute fraîche Fedora 14).   Nous allons donc voir dans ce billet comment installer « la totale » (c’est à dire la liste complète des plugins pour GStreamer).

Installation des dépôts

J’utilise les depôts RPMFusion qui contienne les dernières versions stable de GStreamer et des plugins:

su –

yum -y localinstall –nogpgcheck http://fr2.rpmfind.net/linux/rpmfusion/free/fedora/rpmfusion-free-release-stable.noarch.rpm http://fr2.rpmfind.net/linux/rpmfusion/nonfree/fedora/rpmfusion-nonfree-release-stable.noarch.rpm

yum update

Installation de GStreamer et de tous les composants

Cette installation devrait occuper environ 160 Mo sur votre disque dur.

LISTE=`yum -q list available ‘*gstreamer*’ | awk ‘{print $1 }’ | grep gstreamer | xargs -eol` ; yum -y install $LISTE

A la fin de cette installation, on peut demander le nombre de plugins avec la commande suivantes:

gst-inspect | tail -1

Nombre total :229 greffons (2 éléments de liste noire not shown), 1125 fonctionnalités

Et voili, on a donc un gain de 49 plugins 🙂 !

Catégories
Image Open-source Planet-libre Systeme

Mon desktop 201011

Comme chaque début de mois, voici une actualisation de mon desktop (sous Ubuntu 10.10) qui va m’accompagner en novembre 2011 !

On commence par le résultat:

Fond d’écran: Urban Digital sur DevianArt
GTK: Look des fenêtre Equinox + icônes Faenza
Sur ce bureau: Terminator (Htop) + Nautilus Elementary

Installation des dépôts

On lance un terminal et on saisie les lignes de commandes suivantes:

sudo add-apt-repository ppa:tiheum/equinox

sudo add-apt-repository ppa:am-monkeyd/nautilus-elementary-ppa

sudo aptitude update

sudo aptitude safe-upgrade

Installer de la combo magique (Equinox + Faenza + Nautilus Elementary)

Puis on installe le thème:

sudo aptitude install gtk2-engines-equinox equinox-theme equinox-ubuntu-theme faenza-icon-theme

nautilus -q

On active le tout en allant dans le menu “Système > Préférences > Apparences > Thème > Equinox Evolution“.

Installation de Docky

Ce dock « à la MacOS X »  est disponible dans les dépôt standard, pour l’installer en ligne de commande:

sudo aptitude install docky

Pour le paramétrage, j’utilise:

Paramétrage de mon tableau de bord

J’utilise l’application NetSpeed pour voir en temps réel les débits sur mon interface réseau. Il faut l’installer avec la ligne de commande suivante:

sudo aptitude install netspeed

Ensuite je configure de la manière suivante:

Et vous cela donne quoi vos desktops en ce moment, à vos screenshots !

Catégories
Open-source Planet-libre Systeme

Profiter de sa Dropbox sur son serveur GNU/Linux

Depuis quelques mois, j’utilise le service Dropbox (gratuit jusqu’à 2 Go) pour sauvegarder, partager et synchroniser les fichiers entre mes différentes machines. Souhaitant pouvoir également mon serveur VPS (Ubuntu Server 10.04 LTS) dans ce « cloud » et ainsi permettre la sauvegarde de certains fichiers de mon serveur dans ma Dropbox, il a fallu que je passe outre la limitation du client Dropbox de fonctionner sans un environnement graphique (no-gui…).

Pour tester cette procédure, il faut disposer:

  • d’un compte Dropbox (même un compte gratuit suffit)
  • d’un serveur avec un accès SSH et les droits admin (j’ai validé cette procédure sur un Ubuntu Server 10.04 LTS mais elle doit fonctionner sur d’autre distribution avec quelques adaptations)

Installation du daemon Dropbox

On commence par récupérer le daemon GNU/linux Dropbox sur notre serveur:

cd

wget -O ~/dropbox.tar.gz http://www.dropbox.com/download/?plat=lnx.x86

tar zxvf dropbox.tar.gz

rm -f ~/dropbox.tar.gz

L’archive va être décompressé dans le répertoire ~/.dropbox-dist. Il faut ensuite lancer le programme dropboxd qui va permettre d’associer votre serveur avec votre compte Dropbox.

.dropbox-dist/dropboxd

This client is not linked to any account…

Please visit https://www.dropbox.com/cli_link?host_id=c241bed09af0ae77383c4d89310b08cf to link this machine.

Il faut donc lancer un navigateur Web (depuis votre PC) puis visiter l’URL précédente.

Il se peut que le message suivant s’affiche:

/bin/sh: xdg-open: not found

Il n’a aucun impact sur le bon fonctionnement du daemon dropboxd.

Le programme va ensuite créer votre répertoire ~/Dropbox et y copier le contenu de votre Dropbox (personnellement, j’ai déplacé le répertoire Dropbox vers un disque virtuel attaché à mon VPS puis j’ai créé un lien symbolique entre ce répertoire et mon répertoire ~/Dropbox). Il va également générer un répertoire ~/.dropbox avec un cache et des informations sur votre compte Dropbox.

Une fois terminé, on peut ensuite quitter le programme d’installation avec un CTRL-C.

Automatisation du lancement de Dropbox

On commence par récupérer le script suivant:

http://wiki.dropbox.com/TipsAndTricks/TextBasedLinuxInstall/UbuntuStartup

Ensuite on fait un copier/coller du script dans le fichier /etc/init.d/dropbox . On édite ce fichier et on change la première ligne en mettant la liste des utilisateurs Dropbox sur notre serveur. Par exemple, pour un seul utilisateur nommé nicolargo:

DROPBOX_USERS= »nicolargo »

Puis on change les propriétés du fichier:

sudo chmod a+rx /etc/init.d/dropbox

Et on automatise le lancement:

sudo update-rc.d dropbox defaults

Enfin on essaye une séquence stop / startpour vérifier que le script fonctionne correctement:

/etc/init.d/dropbox stop

Stopping dropbox…

/etc/init.d/dropbox status

dropboxd for USER nicolargo: not running.

/etc/init.d/dropbox stop

Stopping dropbox…

/etc/init.d/dropbox status

dropboxd for USER nicolargo: running (pid 10996)

Test de la Dropbox

Le plus simple est de copier un fichier dans le répertoire ~/Dropbox et de voir si il est bien copié dans votre Dropbox (attendre quelques secondes/minutes selon la taille de votre fichier)…

touch ~/fichiertest.txt

… à l’inverse, si vous supprimé ce fichier de votre Dropbox, il devrait également être supprimé de votre répertoire ~/Dropbox.

Sur mon serveur VPS Gandi, cela marche du tonnerre 🙂

Aller plus loin avec la ligne de commande

Dropbox propose un script en Python (sous licence libre GPL v3) permettant d’administrer sa Dropbox à partir de la ligne de commande cotre serveur. Pour récupérer et installer la dernière version du script, il faut saisir les commandes suivantes:

cd

wget -O dropbox.py http://www.dropbox.com/download?dl=packages/dropbox.py

chmod a+rx dropbox.py

sudo mv dropbox.py /usr/local/bin/

On lance le script sans paramètre pour voir la liste des fonctions disponibles:

/usr/local/bin/dropbox.py

Dropbox command-line interface

commands:

status       get current status of the dropboxd

help         provide help

puburl       get public url of a file in your dropbox

filestatus   get current sync status of one or more files

ls           list directory contents with current sync status

Les plus intéressantes:

dropbox.py status: affiche ce que le daemon Dropbox est en train de faire (exemple: « Downloading 62 files (630.8 KB/sec, 1 hr left) »).

dropbox.py  puburl ~/Dropbox/Public/conky-faenza-nicolargo.tar.gz: affiche l’URL publique de votre fichier.

Maintenir le bouzin à jour

Rien de bien compliqué, une fois la configuration faite, elle restera en mémoire même en cas de mise à jour. La séquence de commande suivante devrait faire l’affaire:

sudo /etc/init.d/dropbox stop

cd

wget -O ~/dropbox.tar.gz http://www.dropbox.com/download/?plat=lnx.x86

tar zxvf dropbox.tar.gz

rm -f ~/dropbox.tar.gz

sudo /etc/init.d/dropbox start

wget -O dropbox.py http://www.dropbox.com/download?dl=packages/dropbox.py

chmod a+rx dropbox.py

sudo mv dropbox.py /usr/local/bin/

Des remarques, questions ? Les commentaires sont là pour ça !

Sources utilisées pour la rédaction de ce billet:

Catégories
Open-source

BitTorrent – Les liens vers les ISO Ubuntu

Ceci est un petit billet à usage interne pour retrouver rapidement les liens torrents des dernières distributions Ubuntu. Je maintiendrai donc ce billet à jour à chaque publication d’une nouvelle version d’Ubuntu.

Pour rappel il faut distinguer chez Ubuntu les « releases » standards (support de 2 ans) des « releases » LTS (Long Time Support – support de 3 ans pour les versions Desktop et 5 ans pour les versions Server).

Je conseille d’utiliser les versions standards pour les PC Desktop/Netbook et les versions LTS pour les serveurs.

Tableau mis à jour en avril 2012

Distribution Architecture Version Lien téléchargement
Ubuntu Desktop 32 bits 12.04 LTS Torrent
Ubuntu Desktop 64 bits 12.04 LTS Torrent
Ubuntu Alternate 32 bits 12.04 LTS Torrent
Ubuntu Alternate 64 bits 12.04 LTS Torrent
Ubuntu Server 32 bits 12.04 LTS Torrent
Ubuntu Server 64 bits 12.04 LTS Torrent
Catégories
Open-source Planet-libre Systeme

8 choses à faire après l’installation d’Ubuntu

Nous allons dans ce billet partager une petite « todo list » des actions que  j’effectue après avoir installé une distribution GNU/Linux Ubuntu Desktop. Cette liste est personnelle et me permet d’avoir un environnement de travail qui corresponde à mes besoins. Je compte sur vous pour ajouter vos commentaires et nous faire découvrir de nouvelles choses.

La connaissance s’accroît quand on la partage…

1_  Lancement du script UbuntupostInstall.sh

Ce script shell à pour but d’automatiser toutes une série d’actions que je fais plus ou moins systématiquement quand j’installe un PC sous Ubuntu Desktop. C’est la première chose que je fais sur un nouveau PC.

On peut notamment citer:

  • Ajout de dépôts pour avoir de nouveaux logiciels ou des versions plus récentes.
  • Installation d’applications indispensable à mes yeux et non présente dans la distribution de base.
  • Configuration système standard.
  • Voir un liste des actions ici…

2_ De belles fenêtres, de beaux icônes

Le script précédant installe la configuration GTK suivante: Look des fenêtre Equinox et icônes Faenza.

Il faut les activer en allant dans le menu “Système > Préférences > Apparences > Thème > Equinox Evolution“.

3_ Un menu dock comme sous Mac OS X

J’utilise depuis quelques jours Docky et je dois avouer qu’après un début difficile je commence à y prendre goût… Voici mon paramétrage:

et un aperçu de la bête:

4_ Des informations directement sur votre bureau

Mon coté geek fait que j’aime bien connaître ce qui se passe dans ma bécane: son occupation CPU, mémoire, la place disponible sur le disque, les débits réseau, le nom de la musique que je suis en train d’écouter…

Pour cela j’utilise Conky avec la configuration suivante (télécharger mon fichier .conkyrc puis l’adapter à votre configuration):

5_ Configurer le tableau de bord

Rien de très original de ce coté, j’utilise un seul tableau de bord ou l’essentiel des éléments se trouvent en haut à droite de mon écran:

J’utilise l’application me permettant d’avoir un aperçu de mes 2 bureaux virtuels (plus de 2 et je n’arrive pas à m’en sortir :)).

6_ Un beau fond d’écran

Je maintien une base d’environ 70 fond d’écran que je puise dans différentes sources. Par exemple, mon fond d’écran du moment (que je change tout les mois) est disponible ici.

7_ Gestion des mes fichiers personnels

J’utilise le service Dropbox pour sauvegarder et synchroniser mes documents entre mes différentes machines (2 PC GNU/Linux, 1 MBP, 1 iPhone).

Pour adapter la Dropbox à mon environnement GNU/Linux, je fais des liens symboliques entre le répertoire ~/Dropbox et les répertoires systèmes suivants:

bin -> ../bin/: Mes scripts shells

dev -> ../dev/: Le répertoire contenant mes développements en cours

Documents -> ../Documents/: Mes documents persos

Images -> ../Images/: Mes images, photos persos

8_ Mes applications de tous les jours…

J’utilise Docky pour avoir un accès rapide aux applications suivantes:

A vous de nous faire découvrir votre monde !

Catégories
Open-source Planet-libre Reseau Web

Installation d’un serveur OpenVPN sous Debian/Ubuntu

Dernière mise à jour de ce billet: Le 20 octobre 2013.

Sur la longue route menant à la protection de la vie privée sur Internet, on entend de plus en plus parler des réseaux privés virtuels (VPN pour les geek). Cette technique permet la création d’une liaison chiffrée entre votre machine et un serveur hébergé sur Internet (par exemple chez un fournisseur d’accès se trouvant en France ou à l’étranger). Tous vos accès à Internet seront alors vus à partir de l’adresse IP de ce serveur VPN et non plus par celle de votre machine.

Avec la généralisation des systèmes de surveillance mis en place pour les lois de type Hadopi&Co, les offres de VPN payantes ont tendances à fleurir en ce moment sur le marché.

Nous allons dans ce billet voir comment installer et configurer son propre serveur VPN sous Ubuntu basée sur OpenVPN, une solution libre et compatible avec des clients multi-OS.

Toute petite introduction à OpenVPN

OpenVPN n’est pas un VPN IPSec. C’est un VPN SSL se basant sur la création d’un tunnel IP (UDP ou TCP au choix) authentifié et chiffré avec la bibliothèque OpenSSL.

Quelques avantages des tunnels VPN SSL:

  • Facilité pour passer les réseaux NATés (pas de configuration à faire)
  • Logiciel clients disponibles sur GNU/Linux, BSD, Windows et Mac OS X.

Installation du serveur OpenVPN

Nous allons détailler l’installation du serveur OpenVPN sur une distribution Ubuntu Server LTS 10.04 (mais la procédure doit être la même sur Debian like).

On commence par installer OpenVPN à partir des dépôts officiels:

sudo aptitude install openvpn

On copie ensuite les fichiers de configurations:

sudo mkdir /etc/openvpn/easy-rsa/

sudo cp -r /usr/share/doc/openvpn/examples/easy-rsa/2.0/* /etc/openvpn/easy-rsa/

sudo chown -R $USER /etc/openvpn/easy-rsa/

Configuration du serveur OpenVPN

A l’aide des scripts installés dans le répertoire /etc/openvpn/easy-rsa/ nous allons configurer OpenVPN pour utiliser une authentification par clés et certificats.

On commence par éditer le fichier /etc/openvpn/easy-rsa/vars:

export KEY_COUNTRY= »FR »

export KEY_PROVINCE= »06″

export KEY_CITY= »Nissa »

export KEY_ORG= »nicolargo.com »

export KEY_EMAIL= »dtc@hadopi.fr »

Ensuite on lance la séquence suivante qui va générer les clés (.key) et les certificats (.crt):

cd /etc/openvpn/easy-rsa/

source vars

./clean-all

./build-dh

./pkitool –initca

./pkitool –server server

sudo openvpn –genkey –secret keys/ta.key

On copie ensuite les clés et les certificats utiles pour le serveur dans le répertoire /etc/openvpn/:

sudo cp keys/ca.crt keys/ta.key keys/server.crt keys/server.key keys/dh1024.pem /etc/openvpn/

Puis on génère un répertoire /etc/openvpn/jail dans lequel le processus OpenVPN sera chrooté (afin de limiter les dégâts en cas de faille dans OpenVPN) puis un autre répertoire (/etc/openvpn/clientconf) qui contiendra la configuration des clients:

sudo mkdir /etc/openvpn/jail

sudo mkdir /etc/openvpn/clientconf

Enfin on créé le fichier de configuration /etc/openvpn/server.conf:

# Serveur TCP/443

mode server

proto tcp

port 443

dev tun

# Cles et certificats

ca ca.crt

cert server.crt

key server.key

dh dh1024.pem

tls-auth ta.key 1

key-direction 0

cipher AES-256-CBC

# Reseau

server 10.8.0.0 255.255.255.0

push « redirect-gateway def1 bypass-dhcp »

push « dhcp-option DNS 208.67.222.222 »

push « dhcp-option DNS 208.67.220.220 »

keepalive 10 120

# Securite

user nobody

group nogroup

chroot /etc/openvpn/jail

persist-key

persist-tun

comp-lzo

# Log

verb 3

mute 20

status openvpn-status.log

; log-append /var/log/openvpn.log

Ce fichier permet de créer un serveur VPN SSL routé basée sur le protocole TCP et utilisant le port HTTPS (443) enfin de maximiser sont accessibilité depuis des réseaux sécurisés par des Firewalls. Les clients obtiendrons une nouvelle adresse IP dans le range 10.8.0.0/24.

On teste la configuration en saisissant la commande suivante:

cd /etc/openvpn

sudo openvpn server.conf

On doit obtenir les messages suivants:

Si le serveur démarre correctement, on peut terminer la configuration sur serveur OpenVPN en décommentant la dernière ligne du fichier /etc/openvpn/server.conf :

log-append /var/log/openvpn.log

On lance le serveur avec la commande:

sudo /etc/init.d/openvpn start

A ce stade les machines clientes vont pouvoir se connecter au serveur VPN. Par contre impossible d’aller plus loin que ce dernier car l’adresse 10.8.0.x ne sera par routée en dehors de votre serveur. Il faut donc configurer le serveur pour qu’il joue le rôle de routeur entre l’interface VPN (tun0) et l’interface physique (eth0) et de NATeur entre les adresses en 10.8.0.x et son adresse IP réelle.

Configuration du routage:

sudo sh -c ‘echo 1 > /proc/sys/net/ipv4/ip_forward’

Pour rendre ce paramètrage de routage permanant (même après un reboot), il faut ajouter la ligne suivante au fichier /etc/sysctl.conf:

net.ipv4.ip_forward = 1

Puis configuration d’IpTables (si utilisé sur votre serveur) :

# règles obligatoires pour ouvrir déverrouiller l’accès :

sudo iptables -I FORWARD -i tun0 -j ACCEPT

sudo iptables -I FORWARD -o tun0 -j ACCEPT

sudo iptables -I OUTPUT -o tun0 -j ACCEPT

# autres règles : Translation d’adresses

sudo iptables -A FORWARD -i tun0 -o eth0 -j ACCEPT

sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

sudo iptables -t nat -A POSTROUTING -s 10.8.0.0/24 -o eth0 -j MASQUERADE

sudo iptables -t nat -A POSTROUTING -s 10.8.0.2/24 -o eth0 -j MASQUERADE

Pour rendre cette règle de NAT persistante après un reboot de votre serveur, il faut commencer par créer un script de chargement de règles de Firewall (ou utiliser  un script existant):

sudo sh -c « iptables-save > /etc/iptables.rules »

Puis éditer votre fichier /etc/network/interfaces pour y ajouter la ligne suivante après la définition de votre interface réseau principale (« iface eth0 inet… » par exemple):

pre-up iptables-restore < /etc/iptables.rules

Le serveur est maintenant prêt à accueillir les clients. Nous allons donc voir dans le chapitre suivant comment déclaration un client sur le serveur.

Création d’un compte client OpenVPN

Imaginons que l’on veuille créer une clés pour le client « pcportablenicolargo » (c’est un exemple :)), alors il suffit de saisir les commandes suivantes sur le serveur:

cd /etc/openvpn/easy-rsa

source vars

./build-key pcportablenicolargo

Note: si vous souhaitez protéger l’accès à vos clés par un mot de passe (c’est à dire qu’un mot de passe sera demandé à la monté du tunnel VPN), il faut utiliser la commande ./build-key-pass en lieu et place de ./buil-key.

Le script ./build-key va générer 3 fichiers dans le répertoire /etc/openvpn/easy-rsa/keys:

  • pcportablenicolargo.crt: Certificat pour le client
  • pcportablenicolargo.csr: Certificat à garder sur le serveur
  • pcportablenicolargo.key: Clés pour le client

On copie les fichiers nécessaires un sous répertoire du répertoire /etc/openvpn/clientconf/ préalablement créé:

sudo mkdir /etc/openvpn/clientconf/pcportablenicolargo/

sudo cp /etc/openvpn/ca.crt /etc/openvpn/ta.key keys/pcportablenicolargo.crt keys/pcportablenicolargo.key /etc/openvpn/clientconf/pcportablenicolargo/

On va ensuite dans le répertoire /etc/openvpn/clientconf/pcportablenicolargo/:

cd /etc/openvpn/clientconf/pcportablenicolargo/

Puis on créé le fichier client.conf (il faut remplacer A.B.C.D par l’adresse publique de votre serveur VPN que vous pouvez obtenir avec la commande « wget -qO- ifconfig.me/ip »):

# Client

client

dev tun

proto tcp-client

remote A.B.C.D 443

resolv-retry infinite

cipher AES-256-CBC

; client-config-dir ccd

# Cles

ca ca.crt

cert pcportablenicolargo.crt

key pcportablenicolargo.key

tls-auth ta.key 1

key-direction 1

# Securite

nobind

persist-key

persist-tun

comp-lzo

verb 3

Pour assurer la compatibilité avec le client Windows OpenVPN, on fait une copie du fichier client.conf vers client.ovpn:

sudo cp client.conf client.ovpn

On devrait ainsi avoir les fichiers suivants dans le répertoire /etc/openvpn/clientconf/pcportablenicolargo/:

  • ca.crt: Certificat du serveur
  • client.conf: Fichier de configuration du client OpenVPN (Linux, BSD, MacOS X)
  • client.ovpn: Fichier de configuration du client OpenVPN (Windows)
  • hennionn.crt: Certificat du client
  • hennionn.key: Clés du client
  • ta.key: Clés pour l’authentification

Il ne reste plus qu’à mettre ces fichiers dans une archive ZIP et de la transmettre sur le PC client:

sudo zip pcportablenicolargo.zip *.*

Update

Pour les plus fainéants, j’ai créé un script (dépôt source sous GitHub) permettant d’automatiser les étapes décrites dans ce paragraphe et donc de permettre simplement la déclaration d’un nouveau client VPN sur votre serveur:

/Update

Attribuer une adresse IP statique à un client VPN

Ce qui est expliqué dans ce chapitre est optionnel.

Pour des raisons de sécurité (par exemple l’application de filtre IP), il est parfois nécessaire d’affecter une adresse IP statique à un client VPN. Pour cela, il faut créer un répertoire qui va contenir les configurations statiques:

sudo mkdir /etc/openvpn/ccd

sudo ln -s /etc/openvpn/ccd /etc/openvpn/jail/ccd

Ensuite on édite à l’intérieur de ce répertoire un fichier correspondant au CNAME (X509) de l’utilisateur dont on veut rendre la configuration statique (par exemple pcportablenicolargo):

sudo vi /etc/openvpn/ccd/pcportablenicolargo

ifconfig-push 10.8.0.18 10.8.0.17

La syntaxe est la suivante: ifconfig-push @IPCLIENTTUNNELVPN @IPSERVEURTUNNELVPN.

Ainsi quand le client pcportablenicolargo se connectera au serveur VPN il obtiendra une adresse en 10.8.0.18. Le bout du tunnel VPN (coté serveur) sera lui en 10.8.0.17.

Note: A chaque modification de ce répertoire il faut en faire une copie vers le chroot (jail, à adapter à votre configuration):

cp /etc/openvpn/ccd/* /etc/openvpn/jail/ccd

On dé-commente la ligne suivante au niveau de la configuration du serveur (/etc/openvpn/server.conf):

client-config-dir ccd

Puis on relance le serveur:

sudo /etc/init.d/openvpn restart

Configuration d’un client OpenVPN sous Ubuntu

Les opérations suivantes sont à faire sur le PC client que l’on veut connecter au serveur VPN.

On part sur le principe ou le fichier pcportablenicolargo.zip a été téléchargé et dézippé dans le répertoire /etc/openvpn/pcportablenicolargo.

Gnome permet de configurer de manière graphique le client OpenVPN. Pour celà il faut ajouter les packages suivants sur sa distribution (Ubuntu Desktop 10.10 dans mon exemple):

sudo aptitude install openvpn resolvconf network-manager-openvpn-gnome

Il faut redémarrer la machine pour finaliser l’installation.

Déclaration du VPN sous Ubuntu

Ensuite on clique gauche sur l’icone réseau du Tableau de bord > Connexions VPN > Configurer le VPN.

On clique sur le bouton Importer.

On va dans le répertoire /etc/openvpn/pcportablenicolargo et on sélectionne le fichier client.conf.

La fenêtre suivante devrait s’afficher:

Il ne reste plus qu’à cliquer sur Appliquer.

Utilisation du VPN sous Ubuntu

Rien de très compliqué :). Si vous avez nommé votre déclaration de VPN Client alors, il suffit de cliquer gauche sur l’icone réseau du Tableau de bord > Connexions VPN > Client.

L’icône réseau du tableau de bord devrait se voir modifier (apparition d’un petit cadenas).

Pour ce déconnecter du VPN: Tableau de bord > Connexions VPN > Déconnecter le VPN.

Si vous avez une erreur lors de la connexion, vous pouvez essayer la méthode fournie par ce lecteur dans ce commentaire.

Configuration d’un client OpenVPN sous Windows

Update

Après quelques tests sous Windows XP, le client que je préconise ci dessous n’est vraiment pas concluant (impossible de se connecter au serveur une fois sur deux, pas de log…).

Je conseille donc l’utilisation d’une solution libre “OpenVPN  Windows” (à télécharger sur le site http://openvpn.net/index.php/open-source/downloads.html).

Une fois installé, il suffit de décompresser l’archive pcportablenicolargo.zip dans le répertoire C:\Programs Files\Openvpn\conf\ et de se connecter à partir du bouton qui se trouve dans la barre des taches.

/Update

On part sur le principe ou le fichier pcportablenicolargo.zip a été téléchargé et dézippé dans le répertoire c:\vpn\pcportablenicolargo.

On va utiliser le client OpenVPN pour Windows nommé « OpenVPN Acccess Server Windows client » téléchargeable sur le site suivant (il nécessite l’installation préalable du framework .NET 3.5 SP1, téléchargeable sur le même site).

Déclaration du VPN sous Windows

Une fois le logiciel téléchargé puis installé. Il suffit de cliquer sur le nouvel icône dans la barre des taches. La fenêtre suivante devrait apparaître. Il faut alors cliquer sur le bouton + pour ajouter une nouvelle connexion VPN.

Ensuite on sélectionne l’option d’importation locale (1) et on clique sur Import (2):

On sélectionne ensuite le fichier client.ovpn qui se trouve dans c:\vpn\pcportablenicolargo\:

On sauvegarde la configuration:

La nouvelle connexion VPN devrait apparaître dans la fenêtre principale:

Utilisation du VPN sous Windows

Il suffit de cliquer sur le nouvel icône dans la barre des taches.  Il faut alors cliquer sur le bouton correspondant à votre connexion VPN définie dans le paragraphe précédant.

Une fois la connexion établie, on a le message suivant:

Pour se déconnecter du VPN, il suffit de cliquer sur le bouton… « Disconnect » (bravo):

Surveiller les connexions VPN

Dans la configuration fournie en exemple, le processus OpenVPN server va écrire toute les minutes un état des clients connectés au serveur dans le fichier /etc/openvpn/openvpn-status.log.

On a, par exemple, les informations suivantes:

OpenVPN CLIENT LIST
Updated,Fri Jan 21 15:48:06 2011
Common Name,Real Address,Bytes Received,Bytes Sent,Connected Since
client1,27.12.245.248:10086,306367,620864,Fri Jan 21 13:58:25 2011
ROUTING TABLE
Virtual Address,Common Name,Real Address,Last Ref
10.8.0.10,client1,27.12.245.248:10086,Fri Jan 21 15:47:14 2011
GLOBAL STATS
Max bcast/mcast queue length,0
END

Sources:

Catégories
Open-source Planet-libre Systeme

Transformer son iPhone en trackpad pour GNU/Linux

Apple vient de sortir son Magic Trackpad qui sera supporté nativement dans la prochaine version d’Ubuntu (la 10.10). Néanmoins, beaucoup d’entrenous disposons d’un dispositif de pointage multi-point performant dans notre poche: l’iPhone… Nous allons donc voir dans ce billet comment piloter notre système GNU/Linux (Ubuntu pour l’exemple mais la procédure doit pouvoir marcher sur d’autres distributions) depuis notre smartphone Apple !

Le logiciel en question permettant de réaliser ce « truc de geek » se nomme RemotePad à le bon goût d’être disponible sous Windows, Mac OS, BSD et Linux. Il utilise l’IP comme protocole de transport. Il faut donc que le PC à contrôler et l’iPhone (qui jouera la fonction de trackpad) soient connectés sur le même réseau local.

Le principe est relativement simple: il faut installer un serveur RemotePad (sous licence GPL v2) sur le PC à contrôler et l’application cliente RemotePad sur l’iPhone.

Installation du serveur sur le PC GNU/Linux

Le serveur doit être compilé à partir des sources, rien de compliqué, il suffit de saisir les commandes suivantes dans un terminal:

sudo aptitude install libxtst-dev

mkdir ~/src

cd ~/src

wget http://iphone-remotepad.googlecode.com/files/RemotePadServer-1.10-X11-Source.tgz

tar zxvf RemotePadServer-1.10-X11-Source.tgz

cd RemotePad\ Server/

cd X11

./configure

make

sudo make install

Lancement du serveur sur le PC GNU/Linux

Il suffit de lancer la commande suivante dans un terminal:

remotepad

Si tout ce passe bien, le message suivant devrait apparaître:

RemotePad Server for X11 version 1.10

Application launched.

enter 192.168.0.3 in your iPhone/iPod touch.

En gros, cela dit que le serveur est bien lancé et écoute sur l’adresse 192.168.0.3.

Installation de l’application sur l’Iphone

Rien de bien difficile:

Ensuite on lance le logiciel et on entre l’adresse IP fournie lors du démarrage du serveur:

Et voilà, votre Iphone joue maintenant le rôle d’un trackpad. Le serveur devrait afficher la ligne suivante:

Connected!

Et cela donne quoi ?

Je vous conseille d’aller dans les propriétés du client iPhone pour régler la vitesse du trackpad et la disposition des boutons. Après ces menu réglages, les premiers tests sont concluants même si, de temps en temps, il y a un léger « lag » surement due à mon réseau Wifi pas très performant. De plus je n’arrive pas à faire fonctionner le clavier.

Bref un exercice amusant mais pas forcement une solution de remplacement par rapport à un vrai trackpad !