Demande.tn

🔒
❌
Il y a de nouveaux articles disponibles, cliquez pour rafraĂźchir la page.
À partir d’avant-hierLe blog de NicoLargo

A la découverte de Check my Website

Par nicolargo

Depuis fĂ©vrier 2014, Olivier Jan et son Ă©quipe ont lancĂ© un service en ligne permettant de surveiller ses sites Web et d'ĂȘtre alertĂ© uniquement en cas de problĂšme. Cette supervision minimaliste rĂ©pond Ă  un besoin croissant dans les infrastructures informatique actuelles: contrĂŽler le ressenti utilisateur plutĂŽt que les indicateurs techniques. En plus, la solution technique qui se cache derriĂšre le site Check my Website se base sur des solutions open-source largement partagĂ©s sur le blog officiel qui est une source d'information que je vous conseille de suivre.

Pour quels besoins ?

Check my Website a pour objectif de surveiller, Ă  travers le temps, la disponibilitĂ©, le temps de rĂ©ponse et la conformitĂ© aux standards de performances du Web de vos sites Internet. En cas de problĂšme, on peut ĂȘtre alertĂ© par mail ou SMS. Une console, que nous prĂ©senterons plus loin dans cet article, permet de visualiser, sous la forme de courbes et de tableau, l'ensemble des indicateurs.

Il ne nĂ©cessite aucune installation sur votre site Web, que cela soit sur le serveur ou mĂȘme dans les pages de votre site. Il construit ses statistiques en utilisant des requĂȘtes HTTP. Ce n'est donc pas une solution de supervision classique. On ne pourra pas, par exemple, connaĂźtre le taux d'occupation mĂ©moire ou la charge CPU du serveur hĂ©bergeant votre site.

Le tour du propriétaire

La mise en route de la supervision de votre site ne prend pas plus de 5 minutes. Il suffit de s'inscrire sur le site et de dĂ©clarer l'adresse du site Ă  surveiller. Une pĂ©riode d'essai gratuite de 15 jours est proposĂ©e. Il faudra ensuite choisir votre forfait en fonction du nombre de site Ă  surveiller et des fonctions proposĂ©es. Par exemple, pour un site, le ticket d'entrĂ©e est de 16€ par an (tarif au 10 juin 2015).

A noter que Check my Website propose un service 'Free for FOSS" entiĂšrement gratuit pour les sites de projets Open Source et/ou associatifs (voir les condition sur le site) !

SĂ©lection_366

Une fois les sites déclarés, les statistiques arrivent sur la console. On commence par la vue générale offrant une vue d'ensemble de vos sites:

SĂ©lection_361

Pour chaque site, on a un tableau de bord qui résumant les indicateurs critiques:

SĂ©lection_362

On peut ensuite faire un focus sur un site en particulier pour consulter les statistiques (menu metrics):

  • temps de rĂ©ponse
  • disponibiltĂ©
  • temps de chargement total de la page

SĂ©lection_363

Il est bien sûr possible de zoomer sur les courbes et de revenir sur des périodes passées:

SĂ©lection_368

SĂ©lection_367

Dans l'onglet performance, on retrouve des informations et conseils pouvant vous permettre d'améliorer l'expérience utilisateur des visiteurs de votre site.

 

SĂ©lection_365

Enfin, en cas de problÚme, il est possible d'entrée dans le détail du temps de chargement de votre site:

SĂ©lection_364

Mon impression

J'ai eu la chance de tester gratuitement le service pendant plusieurs semaines sur 3 de mes sites personnels (notamment le blog que vous ĂȘtes en train de lire). Check my Website "fait le job". L'interface utilisateur est simple et intuitive. Il se fait oublier, alerte en cas de problĂšme et il alors facile d'identifier la pĂ©riode d'indisponibilitĂ© ou de baisse de performance. Il peut aussi ĂȘtre trĂšs utile dans les phases de migration (lors d'un changement d'hĂ©bergeur ou d'un thĂšme) pour juger du maintient des performances.

Il manque cependant Ă  mon goĂ»t des statistiques internes (CPU, RAM, occupation disque, Ă©tat des services de la stack web...) mais qui ne peuvent pas ĂȘtre mis en place sans l'installation d'un composant ou d'une configuration cĂŽtĂ© serveur.

Pour conclure, c'est un service que je conseille Ă  toutes les personnes possĂ©dant un site Web sensible et qui ne veulent pas s'embĂȘter avec la mise en place d'une solution de supervision type Nagios ou Shinken.Il serait d'ailleurs sympa que le service soit proposĂ© en option par les hĂ©bergeurs (cc: Online.fr, OVH, Web4All...).

Cet article A la découverte de Check my Website est apparu en premier sur Le blog de NicoLargo.

RĂ©solution du problĂšme de DNS avec OpenVPN sous Ubuntu

Par nicolargo

Un petit billet Ă  usage personnel (mais pas que) concernant un problĂšme pour le moins gĂȘnant dans le cas ou vous essayez de monter une liaison VPN (OpenVPN) Ă  partir d'Ubuntu 14.04.

Le symptĂŽme

Vous avez un beau fichier .ovpn fourni par votre fournisseur de service VPN ou par votre OpenVPN server auto-hébergé. Quand vous montez le VPN avec la commande suivante:

$ sudo openvpn --config Paris.ovpn
Fri Feb 27 21:17:12 2015 OpenVPN 2.3.6 x86_64-pc-linux-gnu [SSL (OpenSSL)] [LZO] [EPOLL] [PKCS11] [MH] [IPv6] built on Jan 22 2015
Fri Feb 27 21:17:12 2015 library versions: OpenSSL 1.0.1f 6 Jan 2014, LZO 2.06
Enter Auth Username:xxx
Enter Auth Password:xxx
Fri Feb 27 21:17:21 2015 UDPv4 link local: [undef]
Fri Feb 27 21:17:21 2015 UDPv4 link remote: [AF_INET]5.196.80.160:443
Fri Feb 27 21:17:21 2015 WARNING: this configuration may cache passwords in memory -- use the auth-nocache option to prevent this
Fri Feb 27 21:17:25 2015 VERIFY OK: depth=1, C=GB, ST=LN, L=London, O=vpnsvc, OU=vpnsvc, CN=vpnsvc.com, name=vpnsvc, emailAddress=noc@vpnsvc.com
Fri Feb 27 21:17:25 2015 VERIFY OK: nsCertType=SERVER
Fri Feb 27 21:17:25 2015 VERIFY OK: depth=0, C=GB, ST=LN, L=London, O=vpnsvc, OU=vpnsvc, CN=vpnsvc, name=vpnsvc, emailAddress=noc@vpnsvc.com
Fri Feb 27 21:17:31 2015 Data Channel Encrypt: Cipher 'BF-CBC' initialized with 128 bit key
Fri Feb 27 21:17:31 2015 Data Channel Encrypt: Using 160 bit message hash 'SHA1' for HMAC authentication
Fri Feb 27 21:17:31 2015 Data Channel Decrypt: Cipher 'BF-CBC' initialized with 128 bit key
Fri Feb 27 21:17:31 2015 Data Channel Decrypt: Using 160 bit message hash 'SHA1' for HMAC authentication
Fri Feb 27 21:17:31 2015 Control Channel: TLSv1, cipher TLSv1/SSLv3 DHE-RSA-AES256-SHA, 2048 bit RSA
Fri Feb 27 21:17:31 2015 [vpnsvc] Peer Connection Initiated with [AF_INET]5.196.80.160:443
Fri Feb 27 21:17:33 2015 TUN/TAP device tun0 opened
Fri Feb 27 21:17:33 2015 do_ifconfig, tt->ipv6=0, tt->did_ifconfig_ipv6_setup=0
Fri Feb 27 21:17:33 2015 /sbin/ip link set dev tun0 up mtu 1500
Fri Feb 27 21:17:33 2015 /sbin/ip addr add dev tun0 10.10.10.139/27 broadcast 10.10.10.159
Fri Feb 27 21:17:33 2015 Initialization Sequence Completed

Tout semble se passer pour le mieux:

$ ping 74.125.71.94
PING 74.125.71.94 (74.125.71.94) 56(84) bytes of data.
64 bytes from 74.125.71.94: icmp_seq=1 ttl=46 time=76.9 ms
64 bytes from 74.125.71.94: icmp_seq=2 ttl=46 time=125 ms
...

sauf qu'il n'y a pas de résolution DNS !

$ ping www.google.fr
<vide inter stellaire>

La cause

C'est la faute à Ubuntu qui ne prend pas en compte les @ des serveurs DNS envoyés par le serveur VPN. Le bug est connu est référencé depuis octobre 2013 mais manifestement il n'est pas jugé important par les développeur de Canonical.

La solution

Rien de bien compliqué. Il suffit d'ajouter les 3 lignes suivant à la fin de votre fichier .ovpn (mais avant votre certificat s'il est inclus dans le fichier):

...
script-security 2
up /etc/openvpn/update-resolv-conf
down /etc/openvpn/update-resolv-conf
...

On se retrouve ensuite avec un VPN pleinement fonctionnel...

Cet article RĂ©solution du problĂšme de DNS avec OpenVPN sous Ubuntu est apparu en premier sur Le blog de NicoLargo.

Les nouveautés de Glances 2.3

Par nicolargo

Glances vient de sortir en version 2.3. Cette version propose un grand nombre de nouveautés que nous allons détailler dans cet article. Pour installer ou mettre à jour Glances dans cette derniÚre version, je vous conseille la lecture de la documentation officielle.

Attachez vos ceintures, c'est parti pour le tour d'horizon...

Le plugin Docker

Ce plugin est développé autour de la librairie Docker-Py et de fonctions maison pour permettre à l'utilisateur de superviser les conteneurs lancés sur la machine à superviser. Le fonctionnement est relativement simple. Glances va identifier, grùce à la librairie Docker-Py, la liste des conteneurs comme le ferait la commande 'docker ps'. Pour chacun des conteneurs, il va ensuite aller chercher dans les répertoires /sys/fs/cgroup/cpuacct/docker et /sys/fs/cgroup/memory/docker les informations concernant leurs occupations CPU et mémoire.

Le plgin ne s'affiche que si la librairie Docker-Py est installé et si au moins un conteneur est lancé. Le résultat final est le suivant dans un interface console:

SĂ©lection_294

Le plugin Docker est Ă©galement dans l'interface Web de Glances.

Le plugin RAID

La supervision de l'état des contrÎleurs RAID des machines est un point critique. Ainsi, cette nouvelle version de Glances inclus un nouveau plugin permettant de remplir cette tùche. Ce plugin ce base sur la librairie PyMdstat que j'ai créé pour l'occasion et qui est utilisable dans d'autres applications.

Le plugin ne s'affiche que si la librairie PyMdstat est installé et qu'un contrÎleur RAID est détecté. Par exemple, sur un serveur avec un contrÎleur RAID 5 avec 5 disques en bon état, Glances va afficher:

Par contre, dans le cas d'un contrĂŽleur RAID 5 avec 6 disques et l'un de ces disques dans un Ă©tat pas terrible:

Enfin, avec un contrÎleur RAID 5 désactivé:

 

Le plugin RAID étant un extension du plugin FileSystem, il s'affichera, si nécessaire à gauche dans l'interface console/terminal ou Web de Glances.

Modules d'exports vers Statsd, InfluxDB et CSV

Une refonte complÚte du module d'exportation des données vers des briques externes a été codé dans cette nouvelle version. Ainsi, il est possible nativement, d'exporter les statistiques remontées par Glances dans un fichier à plat au format CSV et/ou dans des bases de données de type temps/valeurs comme Statsd ou InfluxDB.

Commençons par l'export CSV que l'on peut choisir en mode standalone, pour récupérer les statistiques de notre machine locale ou en mode client pour une machine distante. On doit utiliser l'option suivante:

glances --export-csv /tmp/glances.csv

On se retrouve avec un fichier /tmp/glances.csv qui va contenir toutes les stats disponibles (hormis les processus) parfaitement exploitable dans une bĂȘte feuille Excel ou via un script Python avec la fameuse librairie Panda:

load_cpucore,load_min1,load_min5,load_min15,memswap_used,memswap_percent,memswap_free,memswap_sout,memswap_total,memswap_sin,diskio_sda2_key,diskio_sda2_time_since_update,diskio_sda2_read_bytes,diskio_sda2_write_bytes,diskio_sda2_disk_name,diskio_sda3_key,diskio_sda3_time_since_update,diskio_sda3_read_bytes,diskio_sda3_write_bytes,diskio_sda3_disk_name,diskio_sda1_key,diskio_sda1_time_since_update,diskio_sda1_read_bytes,diskio_sda1_write_bytes,diskio_sda1_disk_name,fs_/_mnt_point,fs_/_used,fs_/_percent,fs_/_free,fs_/_device_name,fs_/_fs_type,fs_/_key,fs_/_size,fs_/boot/efi_mnt_point,fs_/boot/efi_used,fs_/boot/efi_percent,fs_/boot/efi_free,fs_/boot/efi_device_name,fs_/boot/efi_fs_type,fs_/boot/efi_key,fs_/boot/efi_size,mem_available,mem_used,mem_cached,mem_percent,mem_free,mem_inactive,mem_active,mem_total,mem_buffers,network_lo_tx,network_lo_cumulative_rx,network_lo_rx,network_lo_cumulative_cx,network_lo_time_since_update,network_lo_cx,network_lo_cumulative_tx,network_lo_key,network_lo_interface_name,network_docker0_tx,network_docker0_cumulative_rx,network_docker0_rx,network_docker0_cumulative_cx,network_docker0_time_since_update,network_docker0_cx,network_docker0_cumulative_tx,network_docker0_key,network_docker0_interface_name,network_wlan0_tx,network_wlan0_cumulative_rx,network_wlan0_rx,network_wlan0_cumulative_cx,network_wlan0_time_since_update,network_wlan0_cx,network_wlan0_cumulative_tx,network_wlan0_key,network_wlan0_interface_name,processcount_running,processcount_total,processcount_thread,processcount_sleeping,cpu_softirq,cpu_iowait,cpu_system,cpu_guest,cpu_idle,cpu_user,cpu_guest_nice,cpu_irq,cpu_total,cpu_steal,cpu_nice
4,0.18,0.2,0.23,0,0.0,8490315776,0,8490315776,0,disk_name,1,933888,413696,sda2,disk_name,1,0,0,sda3,disk_name,1,0,0,sda1,/,145566900224,59.9,97453883392,/dev/sda2,ext4,mnt_point,243020783616,/boot/efi,3510272,0.7,532295680,/dev/sda1,vfat,mnt_point,535805952,6620909568,1652637696,1202855936,20.0,6620909568,1018507264,1797070848,8273547264,204804096,200,356764,200,713528,1,400,356764,interface_name,lo,0,0,0,0,1,0,0,interface_name,docker0,0,21354827,0,26332988,1,0,4978161,interface_name,wlan0,1,200,477,199,0.0,2.2,13.3,0.0,33.3,51.1,0.0,0.0,66.7,0.0,0.0
4,0.17,0.2,0.23,disk_name,3.128045082092285,36864,1003520,sda2,disk_name,3.128045082092285,0,0,sda3,disk_name,3.128045082092285,0,0,sda1,/,145566859264,59.9,97453924352,/dev/sda2,ext4,mnt_point,243020783616,/boot/efi,3510272,0.7,532295680,/dev/sda1,vfat,mnt_point,535805952,6627594240,1645953024,1202880512,19.9,6627594240,1018691584,1789747200,8273547264,204951552,1260,358024,1260,716048,3.131376028060913,2520,358024,interface_name,lo,0,0,0,0,3.131376028060913,0,0,interface_name,docker0,10241,21367420,12593,26355822,3.131376028060913,22834,4988402,interface_name,wlan0,1,200,477,199,0.1,0.5,0.5,0.0,95.3,3.6,0.0,0.0,4.7,0.0,0.0
4,0.17,0.2,0.23,0,0.0,8490315776,0,8490315776,0,disk_name,3.1066739559173584,4096,1376256,sda2,disk_name,3.1066739559173584,0,0,sda3,disk_name,3.1066739559173584,0,0,sda1,/,145566867456,59.9,97453916160,/dev/sda2,ext4,mnt_point,243020783616,/boot/efi,3510272,0.7,532295680,/dev/sda1,vfat,mnt_point,535805952,6626533376,1647013888,1202917376,19.9,6626533376,1018888192,1790480384,8273547264,205172736,509,358533,509,717066,3.1057980060577393,1018,358533,interface_name,lo,0,0,0,0,3.1057980060577393,0,0,interface_name,docker0,4009,21383069,15649,26375480,3.1057980060577393,19658,4992411,interface_name,wlan0,1,199,476,198,0.0,0.6,0.6,0.0,93.9,4.9,0.0,0.0,6.1,0.0,0.0

Plus fun et moderne, l'export vers des bases de données NoSQL de type temps/valeurs. Pour l'instant, Glances supporte les implémentations Statsd et InfluxDB. Par exemple, pour exporter les statistiques vers un serveur InfluxDB, il faut dans un premier temps éditer le fichier de configuration de Glances.

Note: pour connaßtre l'emplacement du fichier de configuration de Glances utilisé, il suffit de consulter le fichier de log (par défaut /tmp/glances.log). Il est aussi possible de forcer l'utilisation d'un fichier de configuration spécifique avec l'option -C.

Par exemple, pour utiliser un serveur InfluxDB qui tourne sur la machine locale (localhost), sur le port TCP par défaut (8086) avec l'utilisateur/password (root/root) et la base de donnée nommée glances, il suffit d'ajouter la section suivante:

[influxdb]
host=localhost
port=8086
user=root
password=root
db=glances

On lance ensuite Glances avec l'option:

glances --export-influxdb

Et magie de la technologie moderne:

DĂ©clenchement d'actions sur alerte

RĂ©clamĂ©e depuis un certain temps par les utilisateurs, cette nouvelle fonction permet de dĂ©clencher des alertes pour n'importe quelle alarme levĂ©e par Glances. Par exemple, si vous voulez ĂȘtre prĂ©venu par mail quand l'espace disque disponible devient critique, il suffit d'Ă©diter le fichier de configuration de la maniĂšre suivante:

[fs]
careful=20
warning=70
critical=90
critical_action=mail -s "Disk almost full..." user@domain.com

Encore mieux, Glances supporte les mustaches {{...}} et permet donc d'utiliser les variables disponibles dans les API pour personnaliser les actions. Ainsi, pour préciser le nom du disque et le pourcentage utilisé, il suffit de changer la configuration de la maniÚre suivante:

[fs]
careful=20
warning=70
critical=90
critical_action=mail -s "Disk {{mnt_point}} almost full: {{percent}}%" user@domain.com

Note: cette fonction se base sur la librairie Pystache.

Support des mots de passe dans le mode browser

La grande nouveauté de la version précédente de Glances (la 2.2) était l'apparition du mode browser permettant à partir d'un client unique de superviser plusieurs serveurs. Il est maintenant possible d'accéder à des serveurs protégés par des mots de passes.

SĂ©lection_295

Note: il faut obligatoirement que le client (celui qui lance --browser) et les serveurs (-s) soient Ă  minima dans la version 2.3 pour que cette fonction marche correctement.

Amélioration de l'interface Web

Enfin pour finir en beauté ce panorama des nouveautés de cette version 2.3 je voulais signaler le remarquable travail effectué par Nicolas Hart sur la refonte de l'interface Web avec notamment un optimisation de l'affichage ("responsive design"):

glances-responsive-webdesign

Nicolas travaille en ce moment avec Sylvain Mouquet sur la refonte complÚte de l'interface Web pour passer sur des technologies dynamiques (utilisation d'AngularJS coté client). Cela devrait normalement arriver dans la prochaine version (Glances 2.4).

J'espÚre que cette version de Glances répondra à vos besoins. N'hésitez pas à laisser un petit message pour partager avec nous comment vous utilisez Glances au quotidien et également proposer des améliorations.

Cet article Les nouveautés de Glances 2.3 est apparu en premier sur Le blog de NicoLargo.

Installation de Krita sous Ubuntu (non KDE)

Par nicolargo

Une petit billet "quick and dirty" entre deux lignes de code sur la prochaine version de Glances qui s'annonce dantesque, pour installer Krita, une alternative pas si improbable Ă  Photoshop, sur votre machine Ubuntu Gnome ou Unity.

La preuve ? L'université de Paris 8 vient juste de migrer de Photoshop vers Krita pour sa section Art et technologie de l'image

J'ai un peu galérer avant d'avoir un logiciel complÚtement utilisable sur une machine non nativement KDE (comme mon Ubuntu Gnome Edition). Donc voici les commandes à saisir:

sudo add-apt-repository ppa:kubuntu-ppa/backports
sudo apt-get update
sudo apt-get install krita kritasketch oxygen-icon-theme
kbuildsycoca4

Et hop, le résultat est là:

krita01.psd – Krita_273

Cet article Installation de Krita sous Ubuntu (non KDE) est apparu en premier sur Le blog de NicoLargo.

Glances 2.2 a besoin de vous

Par nicolargo

L'activitĂ© sur ce blog Ă©tant inversement proportionnelle Ă  mon activitĂ© sur le logiciel Glances, vous pouvez, je l’espĂšre, comprendre le peux d'activitĂ© sur ce site. Le dĂ©veloppement de la future version 2.2 de Glances me prends les quelques temps libres qui me reste. Je fais donc appel Ă  vous, chers lecteurs, pour m'aider Ă  valider et trouver les derniers bugs dans cette version en cours de dĂ©veloppement.

Quoi de neuf ?

La version 2.2 apportera, en plus de son lots de corrections de bugs les fonctionnalités suivantes:

  • un nouveau mode nommĂ© "browser" (option --browser) permettant de superviser un ensemble de serveurs Glances ou SNMP Ă  partir d'un point central
  • une vu en arbre pour les processus avec l'option --tree
  • amĂ©lioration de la fonction de tracĂ© de graphique initialisĂ© dans la version 2.1 de Glances
  • ajout du raccourci 'F' et de son option --fs-free-space pour afficher l'espace libre en lieu et place de l'espace utilisĂ©
  • ajout du raccourci '2' et de son option (--disable-left-sidebar) pour cacher la sidebar gauche et donc afficher tout l'espace du bas de l'Ă©cran avec les processus
  • ajout du raccourci 't' pour trier les processus en fonction du temps CPU ("CPU times")

C'est surtout sur la fonction "browser" que j'ai besoin de vous. En effet, je l'ai testé dans un environnement limité et je suis à la recherche d'administrateur systÚme avec un bon petit parc de machines pour effectuer une validation plus complÚte.

Focus sur le mode browser

Ce nouveau mode permet donc de lancer Glances en tant que "super" client qui va afficher dans une premiĂšre fenĂȘtre la liste des serveurs Glances dĂ©tectĂ©s sur son rĂ©seau ou configurĂ© dans le fichier de configuration.

SĂ©lection_251

Le mode de détection automatique repose sur le protocole Zeroconf qui fonctionne en client/serveur multicast. Il est nécessaire que les clients et les serveurs soit dans la version 2.2 de Glances (voir la procédure d'installation dans le chapitre suivant).

Remarque sur le protocole Zeroconf: Qui dit multicast, dit une dĂ©tection uniquement sur le rĂ©seau local. En clair, votre "super" client Glances ne verra que les serveurs sur le mĂȘme rĂ©seau Ethernet (Ă  moins que vos routeurs ne soient compatibles avec le routage multicast).

En plus de ce mode dynamique (qui est bien sur désactivable à la fois coté client mais aussi coté serveur), il est possible de configurer une liste de serveurs dans le fichier de configuration de Glances (voir exemple ici).

Une fois la liste des serveurs affiché, il suffit de cliquer sur la touche 'ENTER' pour visualiser les statistiques de la machine (en clair, lancer le client Glances classique sur le serveur sélectionné).

Ce nouveau mode, trÚs demandé par les utilisateur est en phase de développement et est susceptible d'évoluer dans les prochaines versions. Je suis d'ailleurs à l'écoute de vos remarques sur cette fonction.

Comment tester la version 2.2 de Glances ?

Je vous propose de simplement lire le Wiki officiel (en cliquant ici) qui va vous guider pour installer cette version de dĂ©veloppement (bĂȘta) sur vos machines sans "casser" le Glances existant.

D'avance merci !

PS: faite tourner le billet 🙂

Cet article Glances 2.2 a besoin de vous est apparu en premier sur Le blog de NicoLargo.

Varnish, NGinx et PHP-FPM sous Docker

Par nicolargo

Suite au précédent article d'introduction sur Docker (que je vous conseille de lire avant de dévorer cet article), je me suis penché sur le problÚme suivant: comment créer et maintenir une "stack web" de compétition (Varnish + Nginx + PHP-FPM) basée sur cette technologie de virtualisation par conteneurs.

Quel est l'objectif ?

Nous allons donc, dans ce billet, détailler l'installation et la mise à jour d'une infrastructure, basée sur Docker, qui pourra servir à l'hébergement d'un site personnel, d'un blog ou bien du site d'une PME:

  • la base de donnĂ©e sera portĂ©e par l'implĂ©mentation libre de MySQL, c'est Ă  dire MariaDB (nous aborderons cette partie dans un deuxiĂšme billet)
  • pour le moteur PHP, j'utilise PHP-FPM
  • pour le serveur Web, je ne jure que par Nginx (lĂ©ger, bien documentĂ©)
  • afin pour tenir la charge (notamment si vous utilisĂ© un moteur de blog de type WordPress, j'utilise le systĂšme de cache Varnish)LEMP (Docker)

Dans le reste de de l'article, on appellera machine hÎte, la machine qui hébergera Docker (lire ce billet pour la procédure d'installation de Docker).

Cette derniĂšre peut ĂȘtre un PC portable ou bien un serveur dĂ©diĂ©. C'est un des avantages de la virtualisation par conteneurs. Une fois validĂ© sur une machine , on est sĂ»r que le conteneur fonctionnera de maniĂšre identique sur une autre installation de Docker. Ainsi pour la rĂ©daction de ce billet, j'ai utiisĂ© mon PC portable sous Ubuntu 14.04 et un (superbe) VPS mis Ă  disposition par les amis de Web4All sous Debian 7 (merci AurĂ©lien !).

Pour respecter la philosophie de la virtualisation par conteneur, chaque brique sera mise dans un conteneur dédié. On aura ainsi 4 conteneurs sur une machine hÎte.

Chaque conteneur communiquera avec les autres selon le schéma ci-dessus.

Les données (data base DB, page statique du site et cache) seront stockées sur la machine hÎte.

Création des conteneurs

Il y a deux méthodes pour choisie les images qui seront à la base de nos conteneurs.

La premiĂšre, la plus noble mais la plus longue Ă  mettre en œuvre, est d'Ă©crire soit mĂȘme les DockersFiles permettant l'installation et l'exĂ©cution des logiciels. On garde ainsi le contrĂŽle de notre infrastructure et la possibilitĂ© de configurer finement les applications (notamment au niveau des options de compilation). Dans ce cas, et pour respecter les "best practices" de Docker, il faudra, pour chaque conteneur, repartir d'une image de base de type Debian sur laquelle on viendra installer les briques logicielles de notre LEMP.

La seconde, que j'ai choisi dans ce billet (pas parce-que je suis un gros fainéant mais par manque de temps), est de partir des images disponibles sur la registry officielle de Docker. On gagne ainsi en rapidité de mise en place.  Les composants de notre web stack étant trÚs populaires, on trouve des images supportées et maintenues par la communauté Docker (notamment NGinx). Cependant, on constatera une trop grande diversité dans les systÚmes de bases (Ubuntu, CentOS...).

Avant de commencer, nous allons créer un répertoire sur la machine hÎte qui hébergera les fichiers utiles à notre infrastructure:

mkdir -p $HOME/data/webstack/conf $HOME/data/webstack/www

Le conteneur NGinx

Pierre angulaire de notre "web stack", le serveur NGinx est trÚs présent sur la "registry" officielle de Docker (plus de 900 images disponibles au moment de l'écriture de ce billet). J'ai choisi d'utiliser l'image officielle proposé par Docker (elle est conçue à partir de cete DockerFile).

On commence par télécharger les images NGinx officielle:

docker pull nginx

Puis on vérifie que les images sont visibles sur notre machine hÎte (NGinx version 1.7.5 au moment de l'écriture de cet article):

$ docker images
REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE
nginx 1.7.5 d2d79aebd368 7 days ago 100.2 MB
nginx latest d2d79aebd368 7 days ago 100.2 MB
nginx 1 d2d79aebd368 7 days ago 100.2 MB
nginx 1.7 d2d79aebd368 7 days ago 100.2 MB

On lance le conteneur:

$ docker run --name webstack_nginx_1 -v $HOME/data/webstack/www:/usr/share/nginx/html:ro -p 8080:80 -d nginx
f7baa81cebdc8799947327e6470a74ae73fe73bb0eb644ecfb2951847c40154b

Notre conteneur a le doux nom de webstack_nginx_1, il redirige le port TCP/8080 de notre hÎte vers le port TCP/80 du conteneur (port par défaut de NGinx) et il assigne, en lecture seule, le volume /usr/share/nginx/html au répertoire hÎte $HOME/data/www (à adapter à votre configuration). Pour résumer, toutes les pages HTML disponible dans le répertoire /home/nicolargo/data/www, seront accessible via le port HTTP/8080 de votre machine locale.

On ajoute une page HTML statique de test et une autre pour le test PHP que l'on utilisera dans le chapitre suivant:

echo "My first page" > $HOME/data/webstack/www/index.html
echo "<?php phpinfo(); ?>" > $HOME/data/webstack/www/phpinfo.php

Puis on valide que le serveur NGinx est bien opérationnel:

$ curl http://localhost:8080
My first page

Ou directement depuis votre navigateur Web préféré:

Sélection_245L'image NGinx utilisée redirige les fichiers de log (access.log et error.log vert la sortie standard). Il est donc possible de visualiser les accÚs à son serveur Web en "attachant" le terminal de notre hÎte à la sortie standard du conteneur:

$ docker attach --sig-proxy=false webstack_nginx_1
2014/10/08 13:47:59 [error] 9#0: *1 open() "/usr/share/nginx/html/inconnu.html" failed (2: No such file or directory), client: 172.17.0.103, server: localhost, request: "GET /inconnu.html HTTP/1.1", host: "localhost"
172.17.0.103 - - [08/Oct/2014:13:47:59 +0000] "GET /inconnu.html HTTP/1.1" 404 168 "-" "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:32.0) Gecko/20100101 Firefox/32.0" "172.17.42.1"

Note: bien penser à mettre l'option --sig-proxy=true sous peine de stopper le conteneur lors de l'appuie sur ^C. Je vous conseille  de créer un alias dans votre shell.

Le conteneur PHP-FPM

Pour le moteur PHP, il n'existe pas d'image officielle. Mon choix s'est donc porté vers l'utilisation du repository de Jprjr basée sur une installation de PHP-FPM sous ArchLinux avec pas mal d'extensions par défaut (voir la liste dans le DockerFile).

On télécharge la derniÚre version des images avec:

docker pull jprjr/php-fpm

On obtient bien:

$ docker images | grep jprjr
jprjr/php-fpm          latest                 d40698b35f83        6 weeks ago         347.8 MB

On lance le conteneur:

docker run --name webstack_php_01 -p 9000:9000 -d jprjr/php-fpm

Le conteneur est configuré par défaut pour écouter sur le port TCP/9000.

TrÚs bien, on doit donc avoir le serveur NGinx et le moteur PHP-FPM qui sont lancés dans deux conteneurs différents. On va vérifier cela avec la commande:

$ docker ps
CONTAINER ID        IMAGE                  COMMAND                CREATED             STATUS              PORTS                           NAMES
e9dd04e7ceec        jprjr/php-fpm:latest   "php-fpm -F"           13 seconds ago      Up 12 seconds       0.0.0.0:9000->9000/tcp          webstack_php_01
f7baa81cebdc        nginx:1                "nginx -g 'daemon of   46 minutes ago      Up 46 minutes       443/tcp, 0.0.0.0:8080->80/tcp   webstack_nginx_01

Faire communiquer les deux conteneurs (NGinx & PHP-FPM)

Tout cela est trĂšs beau mais les deux conteneurs ne se connaissent pas. Il faut, pour cela, configurer le serveur NGinx pour utiliser le moteur PHP et donc que le conteneur NGinx connaisse l'adresse IP du conteneur PHP-FPM.

Heureusement, Docker propose l'option --link permettant de répondre à ce besoin. Cette option, à utiliser au moment du lancement du conteneur, va créer dynamiquement des entrées dans le fichier host et dans des variables d'environnement du conteneur, permettant ainsi à ce dernier de connaßtre comment joindre ses congénÚres.

Par exemple:

$ docker run -it -v --link webstack_php_01:webstack_php nginx /bin/bash
root@2ce3cdb8a767:/# cat /etc/hosts | grep webstack
172.17.0.5	webstack-php
root@d9ff8a80f12a:/# env | grep WEBSTACK
WEBSTACK_PHP_PORT=tcp://172.17.0.5:9000
WEBSTACK_PHP_PORT_9000_TCP=tcp://172.17.0.5:9000
WEBSTACK_PHP_PORT_9000_TCP_ADDR=172.17.0.5
WEBSTACK_PHP_PORT_9000_TCP_PORT=9000
WEBSTACK_PHP_NAME=/webstack_nginx/webstack_php
WEBSTACK_PHP_PORT_9000_TCP_PROTO=tcp
root@2ce3cdb8a767:/# exit
exit
$ docker rm `docker ps -lq`

Maintenant que l'on sait comment faire communiquer les deux conteneurs, il suffit de configurer NGinx pour rediriger les fichier .PHP vers le moteur PHP-FPM du second conteneur.

Pour cela, plusieurs solutions sont là encore possibles. La plus simple est de surcharger la configuration NGinx par défaut(nginx.conf). Sur notre hÎte, nous allons créer le fichier de configuration en question:

$ docker webstack_nginx_01/etc/nginx/nginx.conf $HOME/data/webstack/conf/nginx.conf
$ vi $HOME/data/webstack/conf/nginx.conf
daemon off;
user  nginx;
worker_processes  1;
error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;
events {
    worker_connections  1024;
}
http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';
    access_log  /var/log/nginx/access.log  main;
    sendfile        on;
    #tcp_nopush     on;
    keepalive_timeout  65;
    #gzip  on;
    server {
        listen       80;
        server_name  localhost;
        location / {
            root   /usr/share/nginx/html;
            index  index.html index.htm;
        }
        #error_page  404              /404.html;
        # redirect server error pages to the static page /50x.html
        #
        #error_page   500 502 503 504  /50x.html;
        #location = /50x.html {
        #    root   /usr/share/nginx/html;
        #}
        # Pass PHP scripts to PHP-FPM
        location ~* \.php$ {
            fastcgi_index   index.php;
            fastcgi_pass    webstack_php:9000;
            #fastcgi_pass   unix:/var/run/php-fpm/php-fpm.sock;
            include         fastcgi_params;
            fastcgi_param   SCRIPT_FILENAME    /srv/http$fastcgi_script_name;
            fastcgi_param   SCRIPT_NAME        $fastcgi_script_name;
        }
        # deny access to .htaccess files, if Apache's document root
        # concurs with nginx's one
        location ~ /\.ht {
            deny  all;
        }
    }
}

Note:

  • "fastcgi_pass webstack_php:9000;" qui utilise donc le hostname prĂ©sent dans le fichier host
  • "fastcgi_param   SCRIPT_FILENAME    /srv/http$fastcgi_script_name;" qui va permettre Ă  PHP-FPM d'aller chercher les pages PHP dans le mĂȘme volume que le serveur Nginx mais assignĂ© au rĂ©pertoire /srv/http du conteneur (c'est la configuration par dĂ©faut de notre conteneur PHP-FPM)

Revenons à notre cas. Nous souhaitons que le conteneur NGinx (nommé webstack_nginx_01) connaisse le conteneur PHP (webstack_php_01).

On commence donc par supprimer les deux conteneurs existant:

docker stop webstack_php_01 && docker rm webstack_php_01
docker stop webstack_nginx_01 && docker rm webstack_nginx_01

puis de les recréer avec l'option --link (pour le conteneur NGinx qui va initier la connexion TCP vers le moteur PHP-FPM), la nouvelle configuration de NGinx et les volumes pointant sur notre page HTML et PHP:

docker run --name webstack_php_01 -v $HOME/data/webstack/www:/srv/http:ro -p 9000:9000 -d jprjr/php-fpm
docker run --name webstack_nginx_01 -v $HOME/data/webstack/www:/usr/share/nginx/html:ro -v $HOME/data/webstack/conf/nginx.conf:/nginx.conf:ro -p 8080:80 --link webstack_php_01:webstack_php -d nginx nginx -c /nginx.conf

On teste:

$ curl http://localhost:8080/index.html
My first page
$ curl http://localhost:8080/phpinfo.php
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"><head>
<style type="text/css">
...

SĂ©lection_246

Bingo !

A ce stade, nous avons donc deux conteneurs communiquant entre eux pour nous offrir un serveur Web compatible avec le langage PHP.

Le conteneur Varnish en frontal

Si vous suivez ce blog, vous savez tout le bien que je pense de l'utilisation du cache Varnish pour absorber la montée en charge des sites Web (sinon, vous pouvez effectuer une session de rattrapage en lisant ces articles). Nous allons donc créer un nouveau conteneur qui exposera le port TCP/80 et qui mettra en cache les pages construites par le serveur NGinx (qui est en écoute sur le port TCP/8080 si vous avez bien suivi...).

Nous allons utiliser l'image Varnish mise Ă  disposition et maintenue par le contributeur jacksoncage.

On commence par la récupérer:

docker pull jacksoncage/varnish

Puis on vérifie qu'elle est bien disponible sur notre hÎte:

$ docker images | grep jacksoncage
jacksoncage/varnish    latest                 46f0ea7021c1        8 months ago        472.2 MB

Comme il est indiqué dans la documentation de l'image, il faut écrire le fichier de configuration par défaut de Varnish (le fichier default.vcl):

$ vi $HOME/data/webstack/conf/default.vcl
backend default {
    .host = "webstack_nginx";
    .port = "80";
}

On demande donc à Varnish d'aller directement communiquer avec le conteneur NGinx via l'adresse IP webstack-nginx (rappelez-vous que le hostname est créé dynamiquement par Docker au démarrage du conteneur avec l'option --link) et sur le port TCP 80 (attention, ce n'est pas le port TCP/8080 exposé par Docker sur notre hÎte mais celui vraiment utilisé par NGinx dans le conteneur).

A noter que cette configuration est à compléter, notamment si vous voulez héberger un blog sous WordPress (des exemples de fichiers de configuration sont disponibles ici). Attentinon, ces exemples sont pour Varnish 4.0, donc à adapter si la version du conteneur jacksoncage/varnish n'est pas en ligne.

Puis lancer le conteneur avec les options suivantes:

docker run --name webstack_varnish_01 -v $HOME/data/webstack/conf/default.vcl:/etc/varnish/default.vcl:ro -p 80:80 --link webstack_nginx_01:webstack_nginx -d jacksoncage/varnish

On redirige le port 80 du conteneur vers le port 80 de votre hÎte (il ne doit bien sûr pas y avoir de serveur Web déjà en écoute sur ce port) puis on fait le lien entre le conteneur Varnish et le conteneur NGinx.

On vérifie que nos trois conteneurs sont lancés:

$ docker ps
CONTAINER ID        IMAGE                        COMMAND                CREATED             STATUS              PORTS                           NAMES
a1b853f1a38e        jacksoncage/varnish:latest   "/start"               4 seconds ago       Up 3 seconds        0.0.0.0:80->80/tcp              webstack_varnish_01
c2bd3138864a        nginx:1                      "nginx -c /nginx.con   54 minutes ago      Up 54 minutes       443/tcp, 0.0.0.0:8080->80/tcp   webstack_nginx_01,webstack_varnish_01/webstack-nginx
7cc072bb0df2        jprjr/php-fpm:latest         "php-fpm -F"           54 minutes ago      Up 54 minutes       0.0.0.0:9000->9000/tcp          ...

Et on teste notre serveur de cache Varnish:

$ curl -I http://localhost/index.html
HTTP/1.1 200 OK
Server: nginx/1.7.5
Content-Type: text/html
Last-Modified: Sat, 04 Oct 2014 16:30:45 GMT
ETag: "543020b5-15"
Content-Length: 21
Accept-Ranges: bytes
Date: Sun, 05 Oct 2014 15:26:47 GMT
X-Varnish: 320901887 320901884
Age: 46
Via: 1.1 varnish
Connection: keep-aliv

Le "Via: 1.1 varnish" confirme que notre infra commence Ă  avoir de la gueule :).

En aparté, on peut d'ailleurs juger de la puissance de Varnish en lançant un simple bench tout d'abord directement sur le serveur NGinx (donc en baille-passant Varnish):

$ ab -t 30 -c 5 http://localhost:8080/
Complete requests:      7107
Requests per second:    232.24 [#/sec] (mean)
Time per request:       21.529 [ms] (mean)
Time per request:       4.306 [ms] (mean, across all concurrent requests)

Puis en faisant le mĂȘme test en passant par Varnish:

$ ab -t 30 -c 5 http://localhost/
Complete requests:      50000
Requests per second:    3694.60 [#/sec] (mean)
Time per request:       1.353 [ms] (mean)
Time per request:       0.271 [ms] (mean, across all concurrent requests)

Les chiffres parlent d'eux mĂȘme...

Gestion des conteneurs

Un simple pull sur les images préalablement téléchargé s'occupera de leurs mises à jour:

docker pull nginx
docker pull jprjr/php-fpm
docker pull jacksoncage/varnish

Comme l'on reconstruit notre infrastructure Ă  partir de ces images, il suffira ensuite d'arrĂȘter et de relancer les conteneurs:

docker stop webstack_varnish_01 && docker rm webstack_varnish_01
docker stop webstack_nginx_01 && docker rm webstack_nginx_01
docker stop webstack_php_01 && docker rm webstack_php_01
docker run --name webstack_php_01 -v $HOME/data/webstack/www:/srv/http:ro -p 9000:9000 -d jprjr/php-fpm
docker run --name webstack_nginx_01 -v $HOME/data/webstack/www:/usr/share/nginx/html:ro -v $HOME/data/webstack/conf/nginx.conf:/nginx.conf:ro -p 8080:80 --link webstack_php_01:webstack_php -d nginx nginx -c /nginx.conf
docker run --name webstack_varnish_01 -v $HOME/data/webstack/conf/default.vcl:/etc/varnish/default.vcl:ro -p 80:80 --link webstack_nginx_01:webstack_nginx -d jacksoncage/varnish

Note: Il est Ă©galement possible de crĂ©er des images maison (avec commit + tag) et de les relancer. Cette phase peut ĂȘtre utile dans le cadre d'un dĂ©ploiement d'une infrastructure Ă  une autre.

Orchestration de l'infrastructure

On vient de voir que le lancement d'une infrastructure basĂ©e sur Docker peut rapidement devenir compliquĂ©. Les conteneurs doivent ĂȘtre lancĂ©s dans un certain ordre, avec des options spĂ©cifiques. Il est toujours possible de scripter les commandes du chapitre prĂ©cĂ©dent ou plus simplement d'utiliser un outil d'orchestration.

Vagrant vous vient en tĂȘte ? Pourtant, ce n'est pas la solution que nous allons utiliser dans ce billet.

Nous allons nous tourner vers docker-compose (anciennement Fig). C'est un logiciel en ligne de commande permettant de d'Ă©crire son infrastructure Docker Ă  partir d'un fichier de configuration texte au format YAML.

L'installation de Fig se fait via la commande:

sudo pip install docker-compose

Note: pour d'autre méthode d'installation, consultez la documentation sur le site officiel.

Le fichier de configuration Fig correspondant Ă  notre infrastructure est le suivant (Ă  Ă©diter dans le fichier $HOME/data/webstack/docker-compose.yml):

# Webstack PHP
php:
    image: jprjr/php-fpm
    volumes:
    - www:/srv/http
    ports:
    - 9000:9000
# Webstack NGINX
nginx:
    image: nginx
    links:
    - php:webstack_php
    volumes:
    - www:/usr/share/nginx/html
    - conf/nginx.conf:/nginx.conf
    ports:
    - 8080:80
    command: nginx -c /nginx.conf
# Webstack VARNISH
varnish:
    image: jacksoncage/varnish
    links:
    - nginx:webstack_nginx
    volumes:
    - conf/default.vcl:/etc/varnish/default.vcl
    ports:
    - 80:80

On lance ensuite notre infrastructure en une seule et unique commande:

$ docker-compose up -d
Creating webstack_php_1...
Creating webstack_nginx_1...
Creating webstack_varnish_1...

Tout comme avec la ligne de commande Docker, on peut voir les conteneurs en cours d'exécution:

$ docker-compose ps
       Name                Command          State           Ports
-------------------------------------------------------------------------
webstack_php_1                              Up      9000->9000/tcp
webstack_nginx_1     nginx -c /nginx.conf   Up      443/tcp, 8080->80/tcp
webstack_varnish_1   /start                 Up      80->80/tcp

Les arrĂȘter (sans les supprimer):

$ docker-compose stop
Stopping webstack_varnish_1...
Stopping webstack_nginx_1...
Stopping webstack_php_1...

Les relancer:

$ docker-compose start
Starting webstack_php_1...
Starting webstack_nginx_1...
Starting webstack_varnish_1...

Les supprimer:

docker-compose stop && docker-compose rm

Je vous laisse découvrir les autres commandes de docker-compose sur le site officiel de la documentation.

Conclusion

Nous venons de créer les bases d'une infrastructure Web performante, facilement maintenable et évolutive. Il est ainsi facile d'y ajouter d'autres services comme une base de donnée (type MariaDB), un serveur sFTP (pour la mise à jour des pages Web) ou bien encore un outil d'analyse des logs (Varnish et NGinx).

Et de votre coté, avez-vous mis en place une infrastructure Docker pour votre serveur Web ? Si oui comment ?

Partagez votre expérience avec nous !

Cet article Varnish, NGinx et PHP-FPM sous Docker est apparu en premier sur Le blog de NicoLargo.

Support de présentation de Docker

Par nicolargo

A l'occasion de la commission open-source de la Telecom Valley, j'ai eu le plaisir de faire un talk sur le sujet à la mode du moment: Docker ou la virtualisation par conteneurs (j'en avais déjà parlé sur ce blog dans un précédent billet).

Au vu des questions et débats qui ont suivi la présentation, je ne doute pas de l'explosion des cas d'usage sur le sujet dans les prochains mois !

Et vous chers lecteurs, ou en ĂȘtes vous dans vos projets autours de l'Ă©cosystĂšme Docker ? En phase de test ? De production ?

Partagez avec nous vos XP sur le sujet !

Cet article Support de présentation de Docker est apparu en premier sur Le blog de NicoLargo.

Voici Glances 2.1 qui pointe son nez

Par nicolargo

La nouvelle version de Glances vient d'ĂȘtre publiĂ©e. En voici les nouveautĂ©s.

Comment installer Glances 2.1 ?

La premiĂšre solution et la plus simple est d'utiliser le script d'autoinstall (uniquement fonctionnel pour certaines distribution GNU/Linux):

curl -L http://bit.ly/glances | /bin/bash

ou alors en consultant la documentation.

Amélioration de l'affichage des processus

Cette version de Glances apporte les fonctionnalités suivantes pour l'affichage des processus dans Glances:

  • possibilitĂ© d'appliquer un filtre (sous la forme d'une expression rĂ©guliĂšre) sur le nom et la ligne de commande des processus Ă  afficher. Pour cela, il suffit d'appuyer sur la touche ENTREE puis de saisir le filtre. Par exemple, le filtre firefox va afficher le ou les processus du navigateur Firefox tandis que le filtre .*firefox.* va afficher tous les programmes ou le mot clĂ© Firefox apparaĂźt dans la ligne de commande (Ă  noter que cette nouvelle fonction est, pour l'instant, uniquement disponible dans le mode standalone de Glances).SĂ©lection_229
  • informations complĂ©mentaire pour le 'top process' (le processus que Glances juge le plus consommateur de ressources): CPU affinity, extended memory information (shared, text, lib, datat, dirty, swap), openned threads/files and TCP/UDP network sessions, IO nice level (Ă  noter que cette nouvelle fonction est, pour l'instant, uniquement disponible dans le mode standalone de Glances).SĂ©lection_230
  • optimisation du nombre de processus surveillĂ©s par Glances: dans les anciennes versions, Glances recupĂ©rait l'ensemble des statisiques pour tous les processus (mĂȘme ceux qui n'Ă©taient pas affichĂ©s). Dans cette version le nombre de processus est configurable via la clĂ© de configuration max_processes du fichier de configuration (par dĂ©faut top 10) .Cette version apporte donc un gain de footprint CPU d'environ 15% Ă  30%:SĂ©lection_235Ainsi, pour augmenter Ă  20 le nombre de processus affichĂ©, il suffit d'Ă©diter le fichier de configuration de la maniĂšre suivante:
    [processlist]
    # Maximum number of processes to show in the UI
    # Note: Only limit number of showed processes (not the one returned by the API)
    # Default is 20 processes (Top 20)
    max_processes=20

    Note: si aucune configuration n'est faite alors Glances affichera tous les processus.
  • il est maintenant possible de basculer entre l'affichage actuel du nom du processus (qui affiche le nom court ou la ligne de commande complĂšte selon la place disponible) et un mode ou uniquement le nom court est affichĂ©. Pour cela, on peut utiliser le tag --process-short-name au niveau de la ligne de commande ou bien la touche '/' pendant le fonctionnement de Glances.Mode shortname:
    SĂ©lection_233 Mode standard:SĂ©lection_232

 

Alias pour le nom des disques, interfaces réseau et sensors

Les noms des disques (sda par exemple sous Linux), des interfaces réseau (eth0, wlan0) et des sensors (temp1) n'est pas forcement trÚs parlant pour un humain normalement constitué (!geek). Glances permet donc de configurer des alias qui seront affichés en lieu et place des noms "barbares". La définition se fait dans le fichier de configuration:

[network]
# WLAN0 alias name
wlan0_alias=Wireless
[diskio]
# Alias for sda1
sda1_alias=IntDisk
[sensors]
# Sensors alias
temp1_alias=Motherboard 0
temp2_alias=Motherboard 1
core 0_alias=CPU Core 0
core 1_alias=CPU Core 1

Rien de bien compliqué. On doit utiliser la syntaxe: <nom barbare>_alias = <nom humain>.

SĂ©lection_234

Cette fonction est surtout utile pour les utilisateurs de Windows ou les noms sont vraiment... comment dire... Windowsiens...

API RESTFull pour le serveur Web

Le serveur HTTP intĂ©grant l'interface Web (option -w) disponible dans Glances depuis la version 2.0 ne disposait pas d'une API RESFull. C'est maintenant le cas. Il est donc possible Ă  partir d'une application tierce de faire des requĂȘtes du type suivant:

http://<serverglances>:61209/api/v2/mem

qui donnera une réponse HTTP avec un code 200 et:

{"available": 5071183872, "used": 3255848960, "cached": 1827352576, "percent": 39.1, "free": 5071183872, "inactive": 1388982272, "active": 3679604736, "total": 8327032832, "buffers": 477982720}

La documentation complĂšte de l'API est disponible sur la page suivante dans le Wiki.

Fonction expérimentale de génération de graphes

J'ai ajoutĂ© dans cette version une fonction expĂ©rimentale (uniquement disponible dans le mode standalone de Glances) qui sera amĂ©liorĂ©e dans les prochaines versions en cas de demande de la part des utilisateurs. L'objectif de cette fonction est de gĂ©nĂ©rer des graphiques des statistiques (CPU, LOAD et MEM) quand l'utilisateur clique sur la touche 'g'.  ConcrĂštement, Glances va mĂ©moriser les statistiques et les "grapher" en utilisant la librairy Matplotlib (qui doit ĂȘtre prĂ©sente sur votre systĂšme).

Les graphes sont générés dans le répertoire /tmp:

ll /tmp/glances*.png
-rw-rw-r-- 1 nicolargo nicolargo 22911 août  31 16:09 /tmp/glances_cpu.png
-rw-rw-r-- 1 nicolargo nicolargo 19962 août  31 16:09 /tmp/glances_load.png
-rw-rw-r-- 1 nicolargo nicolargo 12059 août  31 16:09 /tmp/glances_mem.png

glances_mem glances_load glances_cpuEn appuyant sur la touche 'r', l'utilisateur peut ré-initialiser l'historique et donc repartir avec un nouveau graphe (attention pour l'instant les graphes sont écrasés à chaque appui sur le bouton 'g').

Des logs et un mode debug

Il manquait à Glances un vrai mode débug avec un fichier de log permettant de facilement identifier les problÚmes d'utilisation et d'exécution de ce logiciel. C'est maintenant chose faite avec cette version 2.1 ou un gros travail a été fait sur la généralisation des message de logs standards et debug (en utilisant l'option -d au niveau de la ligne de commande).

Le fichier de log de Glances est disponible dans le fichier /tmp/glances.log, en voici un extrait en mode normal (sans le -d):

2014-08-31 15:52:00,312 -- INFO -- Start Glances 2.1_RC7
2014-08-31 15:52:00,312 -- INFO -- CPython 2.7.6 and PSutil 2.1.1 detected
2014-08-31 15:52:00,316 -- INFO -- Read configuration file ./conf/glances-test.conf
2014-08-31 15:52:00,316 -- INFO -- Start standalone mode
2014-08-31 15:52:10,465 -- INFO -- Set process filter to firefox
2014-08-31 15:52:15,180 -- INFO -- Stop Glances

et en mode debug (-d):

2014-08-31 15:52:47,185 -- INFO -- Start Glances 2.1_RC7
2014-08-31 15:52:47,185 -- INFO -- CPython 2.7.6 and PSutil 2.1.1 detected
2014-08-31 15:52:47,190 -- INFO -- Read configuration file ./conf/glances-test.conf
2014-08-31 15:52:47,190 -- INFO -- Start standalone mode
2014-08-31 15:52:47,218 -- DEBUG -- Available plugins list: ['load', 'core', 'uptime', 'fs', 'monitor', 'percpu', 'mem', 'cpu', 'help', 'system', 'alert', 'psutilversion', 'memswap', 'diskio', 'hddtemp', 'processcount', 'batpercent', 'now', 'processlist', 'sensors', 'network']
2014-08-31 15:52:47,219 -- DEBUG -- Monitor plugin configuration detected in the configuration file
2014-08-31 15:52:47,220 -- DEBUG -- Limit maximum displayed processes to 20
2014-08-31 15:52:47,220 -- DEBUG -- Extended stats for top process is enabled (default behavor)
2014-08-31 15:52:53,140 -- DEBUG -- User enters the following process filter patern: firefox
2014-08-31 15:52:53,140 -- INFO -- Set process filter to firefox
2014-08-31 15:52:53,140 -- DEBUG -- Process filter regular expression compilation OK: firefox
2014-08-31 15:52:57,344 -- INFO -- Stop Glances

Cette nouvelle fonction permettra, je l'espÚre, de facilité les rapports de bugs remontés dans GitHub.

Et pour finir...

En plus des corrections de bugs et amélioration diverses et variés, Glances 2.1 permet un affichage optimisé pour les tordus d'entre vous utilisant un fond blanc pour leur terminal (option --theme-white) ainsi que le support des routeurs Cisco et des serveurs VMWare ESXi pour le fallback SNMP en mode client/serveur.

Comme d'habitude, les bugs/demandes de fonctions sont à remonter dans GitHub en suivant cette procédure.

Merci Ă  vous !

Cet article Voici Glances 2.1 qui pointe son nez est apparu en premier sur Le blog de NicoLargo.

Utiliser son enceinte MiniJamBox sous Ubuntu

Par nicolargo

Mes vieilles enceintes portables ayant rendu l'Ăąme juste avant le dĂ©part des vacances estivales, j'ai dĂ©cidĂ© d'acheter une enceinte portable Bluetooth. AprĂšs quelques essais en magasin, mon choix s'est portĂ© vers une MiniJamBox du constructeur JawBone. Pour environ 100€, elle offre des performances acceptables dans un volume de poche et avec une bonne autonomie.

SĂ©lection_220

L'association c'est effectué sans problÚme avec mes "eDevices": iPhones 5S & Mac Book Pro de ma femme et mes iPhone 4 & Google Nexus 5.

Cependant, impossible de la faire détecter par mon PC Ubuntu 14.04...

Le problĂšme

Lors de la connexion Bluetooth, le message d'erreur suivant est affiché:

Failed to connect to the device...

En fouillant dans les logs, j'ai trouvé les messages suivants:

(bluetooth-wizard:18445): Bluetooth-WARNING **: CreateDevice failed: GDBus.Error:org.bluez.Error.ConnectionAttemptFailed: Page Timeout
** (bluetooth-wizard:18445): WARNING **: Setting up 'MINIJAMBOX by Jawbone' failed: GDBus.Error:org.bluez.Error.ConnectionAttemptFailed: Page Timeout

La solution

C'est sur le forum AskUbuntu (et grùce à Xavier) que j'ai trouvé la solution à mon problÚme.

Pour résumer, il faut commencer par éditer le fichier /etc/bluetooth/audio.conf pour y ajouter la ligne suivant dans la section [general]:

Disable = Media

Installer le package bluez-tools:

sudo apt-get install bluez-tools
sudo service bluetooth restart

Effectuer l'association avec la MiniJamBox en suivant la documentation du constructeur et via le logiciel bluetooth-wizard.

ParamĂštres_218

Enfin commenter la ligne préalablement ajouté dans le fichier audio.conf:

#Disable = Media

Puis relancer le service bluetooth:

sudo service bluetooth restart

Et voilà, il ne reste plus qu'à sélectionner la MiniJamBox dans les préférences sons d'Ubuntu et de sélectionner le mode haute fidélité (A2DP):

SĂ©lection_219

Et voilĂ  le travail !

 

Cet article Utiliser son enceinte MiniJamBox sous Ubuntu est apparu en premier sur Le blog de NicoLargo.

Glances version 2.0 est lĂ 

Par nicolargo

AprĂšs plusieurs mois de travail, la nouvelle version majeure de Glances vient d'ĂȘtre publiĂ©. L'objectif de ce billet est de faire une rapide prĂ©sentation des nouveautĂ©s, un article plus complet est disponible sur LinuxFR.

Pour ceux d'entre vous qui ne connaissent pas encore Glances, c'est un logiciel permettant de superviser le plus simplement possible ses machines en disposant sur une seule et unique page (terminal ou interface Web) les informations importantes (CPU, mémoire, charge, processus...).

Il peut ĂȘtre utilisĂ© dans des configurations diffĂ©rentes:

  • standalone: superviser la machine sur laquelle on se trouve Ă  partir d'une interface Curse
  • client/serveur: superviser une machine distante Ă  partir d'une interface Curse
  • serveur Web: superviser une machine distante Ă  partir d'un navigateur Internet
  • API: accĂšs aux statistique via une API XML/RPC

screenshot-wide

Comment installer cette nouvelle version ?

Le plus simple est de passer par le gestionnaire de paquet de Python (PiPy).

Pour une installation complÚte avec toutes les dépendances:

sudo pip install glances pysnmp bottle batinfo https://bitbucket.org/gleb_zhulik/py3sensors/get/tip.tar.gz

Note: selon votre configuration, il est peut ĂȘtre  nĂ©cessaire d'installer certains prĂ©-requis avant de faire cette installation. Par exemple sur un systĂšme Debian/Ubuntu:

sudo apt-get install -y python-dev python-pip lm-sensors

Pour la mise à jour d'une version existante et l'installation des dépendances:

sudo pip install pysnmp bottle batinfo https://bitbucket.org/gleb_zhulik/py3sensors/get/tip.tar.gz
sudo pip install --upgrade glances

Les nouveautés...

Au niveau du code

La plus grande nouveauté n'est pas visible car c'est un refactoring complet du code avec notamment l'utilisation d'un systÚme de plugins. Toutes les statistiques collectées par Glances sont des plugins. Le principal avantage de cette architecture est une rapidité de développement accrue pour les nouvelles fonctionnalités par rapport à la version précédente. Chaque plugin hérite de méthodes communes permettant de factoriser le code.

Cette version a été développée en suivant le workfow Git Flow et les prochains correctifs et nouvelles fonctions devront respecter ce processus (j'ai ajouté une page sur le sujet dans le Wiki).

Interface Curse

L'interface standalone a été optimisée pour afficher le maximum d'informations de la maniÚre la plus lisible et dans un minimum d'espace. L'objectif principal et le but de Glance étant que le problÚme de performance d'une machine saute aux yeux.

Interface Web

A la suite de pas mal de demandes, Glances v2.0 intÚgre maintenant un mode serveur Web qui permet d'accéder simplement au statistique depuis n'importe quel navigateur Internet à travers une page HTML5/CSS3 (plus ou moins "Responsive Web Design" mais je suis pas un pro sur le sujet).

Pour lancer le mode serveur Web:

# glances -w
Bottle v0.12.7 server starting up (using WSGIRefServer())...
Listening on http://0.0.0.0:61208/
Hit Ctrl-C to quit.

Par exemple sur ma tablette Nexus 5, cela donne cela:

screenshot-web2

Le mode fallback SNMP

Dans le cas ou il n'est pas possible de lancer un serveur Glances sur une machine (problÚme de droit ou "appliance"), il est maintenant possible d'accéder à certaines statistiques via le protocole SNMP (limitation actuelle au mode SNMP v2/2c).

Quand vous lancez Glances en mode client, il va d'abord essayer de détecter un serveur Glances puis essayer le protocole SNMP:

# glances -c localhost
Info: Connection to Glances server failed. Trying fallback to SNMP...

C'est pour l'instant une fonction expérimentale qui ne fonctionne pas avec tous les agents SNMP. Des évolutions sont prévues dans les prochaines version et je suis à la recherche de contributeurs sur ce point (notamment pour un accÚs aux statistiques des machines Cisco et autres équipementiers réseau).

SĂ©lection_213

Amélioration du fichier de configuration

Si vous utilisiez un fichier de configuration (notamment pour fixer vos propres limites au niveau des statistiques), il va falloir l'adapter pour cette nouvelle version. Un fichier par défaut se trouve sous GNU/Linux dans  /etc/glances/glances.conf. Je vous conseille de vous inspirer de ce fichier: https://github.com/nicolargo/glances/blob/master/conf/glances-monitor.conf.

Conclusion

En attendant que vous lisiez le billet sur LinuxFr, j'espĂšre que cette mise en bouche vous a convaincu d'essayer cette nouvelle version.

J'attends vos avis avec impatiente !

Cet article Glances version 2.0 est lĂ  est apparu en premier sur Le blog de NicoLargo.

❌