source: Nicolargo
Cette année encore, la Telecom Valley nous gâte avec une série de 4 soirées de conférences accessible gratuitement sur le campus SophiaTech à Sophia-Antipolis (06).
Lundi 30/06 | Mardi 01/07 | Mercredi 02/07 | Jeudi 03/07 | |
Lieux | Campus SophiaTech | Campus SophiaTech | Campus SophiaTech | Campus SophiaTech |
Horaires | Accueil à 17h45 18h00 - 20h00 | Accueil à 17h45 18h00 - 20h00 | Accueil à 17h45 18h00 - 20h00 | Accueil à 17h45 18h00 - 20h00 |
Intervenants | Pascal BODIN Alexis MOUSSINE-POUCHKINE Google Alexandru CARACAS Jean DEMARTINI Benjamin CABE Julien HOLTZER (Pobot)
| Didier GIRARD (SFEIR, Google Developer Expert) Aurélien GOUJET (MapR) Edmond CISSE Cyril GROSJEAN Aurélien MAZOYER Olivier TAVARD Julien MARECHAL Jérémy MEYER
| Fabien GANDON Christophe DESCLAUX Mylène LEITZELMAN Laurent BIHANIC Guillaume VILAND (Orange Portail) | Alexis MOUSSINE-POUCHKINE Bertrand LAPORTE Benoît CHARBONIER Pawel KOZLOWSKI |
Infos pratiques | Entrée gratuite, inscription obligatoire Inscrivez-vous en cliquant ici. |
Vous pouvez vous inscrire en ligne à partir du site officiel: http://www.telecom-valley.fr/webform/inscription-sophiaconf2014
Cet article Un sacré programme pour les SophiaConf 2014 est apparu en premier sur Le blog de NicoLargo.
Dans le petit monde des DevOps, la solution de virtualisation Docker a le vent en poupe. Nous allons dans ce billet essayer de décrypter ce qui ce cache derrière ce nouvel outil et proposer un tutoriel sur l'installation et les premiers pas pour une utilisation souple et efficace.
Docker est un logiciel open-source (sous licence Apache 2.0) et un service en ligne optionnel (Docker.io) permettant de gérer des conteneurs ("dockers").
Contrairement aux machines virtuelles classiques qui comprennent un système hôte ("guest OS") et les librairies/applications, les conteneurs ne contiennent, au maximum, que les applications/librairies.
Quand je dis au maximum c'est qu'une copie d'un conteneur qui ne change que la partie application ne contiendra que les différences par rapport au conteneur initial.
Le système hôte est ainsi géré directement par le Docker Engine (en vert dans le premier schéma). On a ainsi une mutualisation qui permet de lancer les conteneurs de manière très rapide: le temps de lancement d'un conteneur est presque le même que le temps de lancement des applications qu'il contient. En effet, le système d'exploitation est déjà lancé. Donc pas de phase de démarrage ni d'initialisation de cette couche. Il faut quand même avoir à l'esprit que même si l'on est pas dans une machine virtuelle, on dispose tout de même d'un environnement isolé (processus, système de fichier, ports réseau). L'utilisateur n'a qu'à se préoccuper que de ce qu'il veut virtualiser (les applications/services) et ne s'occupe pas du reste.
L'autre gros avantage de cette technologie est la portabilité. En effet, il est tout à fait possible de concevoir un conteneur sur son PC portable puis ensuite de le déployer sur son infrastructure de production physique ou virtuelle. La taille des conteneurs étant relativement réduite, on peut donc imaginer un workflow de déploiement basée sur un repo central (type Git) et des Docker Engine installés sur les machines qui font elle même tourner des conteneurs. Il n'y a pas vraiment de limite au nombre de conteneurs qu'une machine puisse faire tourner. La limite vient de l'occupation mémoire/CPU/réseau de vos applications.
Si vous avez encore des questions sur la différence entre Docker et VM, je vous conseille la lecture de cette question sur StackOverflow: "How is Docker.io different from a normal virtual-machine ?".
Note (merci à @jb_barth pour le commentaire): jusqu'à la version 0.9, Docker se basait sur la technologie LXC ("Linux Containers") du noyau Linux et ne fonctionnait donc que sur des distributions GNU/Linux avec un noyau >= 2.6.24. La dépendance stricte à LXC a sauté depuis la v0.9.0, le driver par défaut est maintenant libcontainer, une lib pur go produite par le projet pour accéder de façon propre aux APIs dispos dans le kernel. C'est ce qui a permis de supporter des noyaux aussi vieux d'ailleurs, au début c'était >= 3.8
Voici les étapes à suivre pour installer Docker sur une distribution Ubuntu 14.04 LTS. A noter, pour les miséreux développeurs sous Windows ou Mac OS, il est est toujours possible de faire tourner une VM Ubuntu (par exemple avec VirtualBox) et de suivre cette installation.
Docker est directement disponible dans les repositories d'Ubuntu, donc un simple
sudo apt-get install docker.io sudo ln -sf /usr/bin/docker.io /usr/local/bin/docker
suffit pour effectuer l'installation complète de Docker sur notre machine comprenant:
Cependant su vous souhaiter travailler avec une version plus ressente il faut utiliser les commandes suivantes:
sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 36A1D7869245C8950F966E92D8576A8BA88D21E9 sudo sh -c "echo deb https://get.docker.io/ubuntu docker main \ > /etc/apt/sources.list.d/docker.list" sudo apt-get update sudo apt-get install lxc-docker
Comme les conteneurs vont utiliser les serveurs DNS de la machine hôte, il est nécessaire de configurer les adresses des serveurs DNS dans le fichier /etc/default/docker.io (par exemple avec les serveurs OpenDNS):
$ vi /etc/default/docker.io # Use DOCKER_OPTS to modify the daemon startup options. DOCKER_OPTS="-dns 208.67.220.220 -dns 208.67.220.222"
Pour que la configuration soit prise en compte, il faut relancer le service Docker avec la commande:
sudo service docker restart
Un petit ps permet de voir que le service est bien lancé:
0.0 0.1 563M 9.65M 733 root 0 S 0:00.46 0 0 /usr/bin/docker.io -d -dns 208.67.220.220 -dns 208.67.220.222
Nous allons commencer par récupérer des images qui vont servir de de bases à notre conteneur. Une liste assez conséquente d'images sont disponibles sur le site officiel du projet. Vous pouvez ainsi récupérer celle qui est le plus proche de l'environnement que vous recherché. Un moteur de recherche est disponible à l'adresse https://index.docker.io/ pour trouver des images conçues par les développeurs du projet et par des contributeurs.
On retrouve ainsi des distributions GNU/Linux minimales comme Ubuntu, CentOS, BusyBox pour ne siter que les images officiellement supportées par le projet Docker.io (il existe également des repos non officiels avec Fedora, RH, Arch...).
Petit mention spéciale pour les images BusyBox qui sont vraiment très légère (moins de 10 Mo) pour un système fonctionnel !
Même si il est possible de directement télécharger l'image au lancement du conteneur, je préfère avoir sur ma machine les images des différentes versions de l'OS que j'utilise le plus: Ubuntu.
Pour récupérer l'ensemble des images du repo Ubuntu qui contient les versio minimale d'Ubuntu de la version 10.04 à 14.04), il faut saisir la commande suivante:
$ sudo docker pull ubuntu 74fe38d11401: Pulling dependent layers 316b678ddf48: Pulling dependent layers 3db9c44f4520: Pulling dependent layers 5e019ab7bf6d: Pulling dependent layers 99ec81b80c55: Pulling dependent layers a7cf8ae4e998: Pulling dependent layers 511136ea3c5a: Download complete e2aa6665d371: Downloading [==> ] 2.027 MB/40.16 MB 6m14s
Note: le téléchargement initial des images peut prendre un peu de temps selon la vitesse de votre liaison Internet.
Il est également possible de faire de même avec les autres distributions citées ci-dessus:
$ sudo docker pull centos $ sudo docker pull busybox
Une fois le téléchargement terminé, on peut demandé à Docker un status de son état actuel:
$ sudo docker info Containers: 64 Images: 46 Storage Driver: aufs Root Dir: /var/lib/docker/aufs Dirs: 174 Execution Driver: native-0.1 Kernel Version: 3.13.0-24-generic WARNING: No swap limit support
ainsi que la liste des images disponibles:
$ sudo docker images REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE busybox buildroot-2013.08.1 352f47ad2ecf 17 hours ago 2.489 MB busybox ubuntu-14.04 6a95c08a9391 17 hours ago 5.609 MB busybox ubuntu-12.04 1720a1681f1c 17 hours ago 5.455 MB busybox buildroot-2014.02 f66342b343ae 17 hours ago 2.433 MB busybox latest f66342b343ae 17 hours ago 2.433 MB ubuntu glances_develop a483f92d9ab3 24 hours ago 556.8 MB ubuntu 14.04_nicolargo 8574cc29575e 28 hours ago 440.8 MB ubuntu 13.10 5e019ab7bf6d 4 weeks ago 180 MB ubuntu saucy 5e019ab7bf6d 4 weeks ago 180 MB ubuntu 12.04 74fe38d11401 4 weeks ago 209.6 MB ubuntu precise 74fe38d11401 4 weeks ago 209.6 MB ubuntu 12.10 a7cf8ae4e998 4 weeks ago 171.3 MB ubuntu quantal a7cf8ae4e998 4 weeks ago 171.3 MB ubuntu 14.04 99ec81b80c55 4 weeks ago 266 MB ubuntu latest 99ec81b80c55 4 weeks ago 266 MB ubuntu trusty 99ec81b80c55 4 weeks ago 266 MB ubuntu 13.04 316b678ddf48 4 weeks ago 169.4 MB ubuntu raring 316b678ddf48 4 weeks ago 169.4 MB ubuntu lucid 3db9c44f4520 5 weeks ago 183 MB ubuntu 10.04 3db9c44f4520 5 weeks ago 183 MB centos centos6 0b443ba03958 6 weeks ago 297.6 MB centos 6.4 539c0211cd76 14 months ago 300.6 MB centos latest 539c0211cd76 14 months ago 300.6 MB
Comme alternative du moteur de recherche https://index.docker.io/, il est bien sûr possible d'utiliser la ligne de commande. Par exemple pour trouver toutes les images Ubuntu disponibles sur le repo central:
sudo docker search ubuntu | less
A noter qu'il est tout à fait possible, si vous ne trouvez pas votre bonheur de concevoir "from scratch" votre propre image système en suivant cette documentation sur le site officiel (la procédure se base sur DebootStrap).
Bon assez de préliminaires, nous allons maintenant pourvoir créer notre premier conteneur qui va se limiter à exécuter la commande 'ls' (si c'est pas du conteneur de compétition):
$ sudo docker run ubuntu:latest /bin/ls -alF total 8280 drwxr-xr-x 46 root root 4096 May 28 06:50 ./ drwxr-xr-x 46 root root 4096 May 28 06:50 ../ -rw-r--r-- 1 root root 102 May 28 06:50 .dockerenv -rwx------ 1 root root 8394118 May 27 15:37 .dockerinit* drwxr-xr-x 2 root root 4096 Apr 16 20:36 bin/ drwxr-xr-x 2 root root 4096 Apr 10 22:12 boot/ drwxr-xr-x 4 root root 4096 May 28 06:50 dev/ drwxr-xr-x 64 root root 4096 May 28 06:50 etc/ drwxr-xr-x 2 root root 4096 Apr 10 22:12 home/ drwxr-xr-x 12 root root 4096 Apr 16 20:36 lib/ drwxr-xr-x 2 root root 4096 Apr 16 20:35 lib64/ drwxr-xr-x 2 root root 4096 Apr 16 20:35 media/ drwxr-xr-x 2 root root 4096 Apr 10 22:12 mnt/ drwxr-xr-x 2 root root 4096 Apr 16 20:35 opt/ dr-xr-xr-x 236 root root 0 May 28 06:50 proc/ drwx------ 2 root root 4096 Apr 16 20:36 root/ drwxr-xr-x 7 root root 4096 Apr 16 20:36 run/ drwxr-xr-x 2 root root 4096 Apr 24 16:17 sbin/ drwxr-xr-x 2 root root 4096 Apr 16 20:35 srv/ dr-xr-xr-x 13 root root 0 May 28 06:50 sys/ drwxrwxrwt 2 root root 4096 Apr 24 16:17 tmp/ drwxr-xr-x 11 root root 4096 Apr 16 20:35 usr/ drwxr-xr-x 14 root root 4096 Apr 16 20:36 var/
Arrêtons-nous un peu sur la commande: sudo docker.io run ubuntu:latest /bin/ls -alF
On demande donc le lancement (run) d'un conteneur basée sur la dernière version d'Ubuntu (ubuntu:latest qui est un lien vers l'image minimale de la version 14.04) qui va exécuter la commande ls (/bin/ls -alF). Comme vous pouvez le voir dans le résultat de la commande, on est dans un environnement isolé avec son propre système de fichier.
Première constatation, la vitesse d’exécution de notre environnement virtuel est vraiment impressionnante. Sur une petit commande,on peut voir que l'overhead de lancement du conteneur est négligeable:
$ time sudo docker run ubuntu:latest ls -alF / ... real 0m0.331s user 0m0.014s sys 0m0.012s $ time ls -alF / ... real 0m0.007s user 0m0.003s sys 0m0.004s
Passons maintenant à la création d'un conteneur persistant, c'est à dire un conteneur qui va faire tourner une tache pendant un temps indéterminé (je prends par exemple un pin infini vers le site Google).
$ sudo docker run -d ubuntu:latest ping www.google.fr 7404bfa4beca4ba97459c96f8d93242c4fba6ecf2c5b11d18c09acd2fce9991e
Noter le -d dans la ligne de commande pour détacher le conteneur et ainsi lui permettre de tourner en tache de fond.
En retour on obtient le numéro d'identifiant unique du conteneur qui va nous permettre de le contrôler.
On commence donc par vérifier qu'il tourne bien:
$ sudo docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 7404bfa4beca ubuntu:14.04 ping www.google.fr 3 minutes ago Up 3 minutes mad_lumiere
On peut ainsi, l'arrêter:
sudo docker stop 7404bfa4beca
Le démarrer:
sudo docker start 7404bfa4beca
Le redémarrer (l'équivalent d'un stop/start):
sudo docker restart 7404bfa4beca
Lui envoyer des signaux:
sudo docker kill 7404bfa4beca
Ensute on supprime le conteneur avec la séquence stop/rm:
sudo docker stop 7404bfa4beca sudo docker rm 7404bfa4beca
Pour accéder à un shell dans le conteneur, il faut utiliser les options suivantes dans la ligne de commande:
$ sudo docker run -i -t ubuntu:latest bash root@bb89ed6cdd3c:/#
Les Dockerfiles sont des fichiers textes décrivant les différentes étapes pour la création d'un conteneur. Idéalement, ce sont ces fichiers que vous aller gérer en configuration et que vous aller partager avec les différentes personnes utilisatrices de votre projet. Pour illustrer mes dires, je vais prendre l'exemple d'un dockerfile qui va permettre aux contributeurs du projet Glances de tester simplement la branche de développement du logiciel.
En gros, le dockfile doit:
Le dockfile glances_develop_install correspondant est alors le suivant:
# Install Glances Development branch # # $ sudo docker build -t ubuntu:glances_develop - < glances_develop_install # # VERSION 1.0 # Use the ubuntu base image provided by dotCloud FROM ubuntu MAINTAINER Nicolargo, nicolas@nicolargo.com # Make sure the package repository is up to date RUN apt-get -y update # Install prerequirement RUN apt-get install -y python-dev python-pip git lm-sensors RUN pip install psutil bottle batinfo https://bitbucket.org/gleb_zhulik/py3sensors/get/tip.tar.gz # Patch for current Docker version RUN ln -s /proc/mounts /etc/mtab # Install Glances from the Pipy repository RUN git clone -b develop https://github.com/nicolargo/glances.git
Voyons un peu en détail le contenu du fichier. On commence donc par définir l'OS de base:
FROM ubuntu
On peut bien sûr utiliser l'image/tag que l'on souhaite.
Ensuite on passe aux commandes que l'on souhaite exécuter:
RUN apt-get -y update
RUN apt-get install -y python-dev python-pip git lm-sensors
RUN pip install psutil bottle batinfo https://bitbucket.org/gleb_zhulik/py3sensors/get/tip.tar.gz
RUN ln -s /proc/mounts /etc/mtab
RUN git clone -b develop https://github.com/nicolargo/glances.git
Rien de bien compliqué, il suffit de faire précéder la commande Unix par le mot clé RUN...
Il ne reste plus qu'à lancer la construction du conteneur et son exportation vers une nouvelle image (nommé ubuntu:glances_develop) à partir de la ligne de commande:
sudo docker build -t ubuntu:glances_develop - < glances_develop_install
ou alors directement depuis un repos (par exemple GitHub) ou vos Dockers files sont gérés en configuration:
sudo docker build -t ubuntu:glances_develop https://raw.githubusercontent.com/nicolargo/dockersfiles/master/glances_develop_install
On vérifie ensuite que l'image a bien été créée:
$ sudo docker images | grep glances ubuntu glances_develop a483f92d9ab3 31 hours ago 556.8 MB
Puis on lance Glances depuis ce conteneur (en le metant à jour par un pull avant le lancement):
sudo docker run -i -t --entrypoint /bin/bash ubuntu:glances_develop -c "cd glances ; git pull origin develop ; python -m glances"
Et hop c'est magique:
Un des trucs fun avec Docker c'est que si l'on souhaite modifier un conteneur en ajoutant par exemple l'installation d'un nouveau logiciel, il suffit de modifier le Docker file puis de refaire la commande de build. L'installation ne se fera que par delta par rapport au premier conteneur.
Une fonction intéressante de Docker est sa capacité de contraindre un conteneur en terme de CPU et de MEM. Par exemple on peut limiter le conteneur à 512 Mo de RAM et donner un priorité moins forte en terme de CPU à ce conteneur par rapport aux autres. Il faut cependant que le hôte qu héberge Docker soit compatible avec ces options ce qui n'est pas mon cas:
$ sudo docker run -m 512m -i -t --entrypoint /bin/bash ubuntu:glances_develop -c "cd glances ; git pull origin develop ; python -m glances" WARNING: Your kernel does not support swap limit capabilities. Limitation discarded.
Pour activer ces options sous Ubuntu, il faut modifier la configuration du Kernel via GRUB. Pour cela, il est nécessaire de suivre cette procédure.
L'approche est vraiment différente des solutions de virtualisation classiques mais si vous cherchez un outil simple pour valider vos applications Linux dans un environnement controlé alors Docker est définitivement une solution à envisager. Sa souplesse et sa légéreté en font une solution idéale à embarquer sur son PC portable ou à mettre en production sur son infrastructure.
Je vous conseille de vous plonger dans la documentation officielle qui est vraiment complète et très bien faite.
Des expériences à nous faire partager sur l'utilisation de Docker ?
Quelques références:
Cet article Virtualisation légère avec Docker est apparu en premier sur Le blog de NicoLargo.
Cela fait maintenant plusieurs mois que je délaisse mon bébé blog pour me consacrer au développement de la version 2.0 de Glances. Avec l'aide d'Alessio Sergi, nous avons effectué un refactoring complet du code et apporté de nouvelles fonctions qui, je l’espère, vous serons utiles.
Cependant, avant la mise à disposition officielle, j'ai besoin de vous pour tester la première Release Candidate (RC1). Le développement ayant été fait sous Ubuntu 14.04, je recherche donc des personnes de bonne volonté pour valider cette RC1 sur d'autres système d'exploitation: autres distributions GNU/Linux, BSD, Mac OS, Windows.
Le plus simple est de suivre les instructions de la page Wiki qui va vous permettre de tester cette nouvelle version sans impacter votre système existant (utilisation d'un environnement virtuel avec virtualenv).
Il est important de bien vérifier que l'on est sur la branche DEVELOP avant de lancer les tests suivants. Pour vérifier cela:
cd ~/tmp/glances LANGUAGE=en_US.utf8 ~/glances-venv/bin/python -m glances -V
devrait afficher comme résultat:
Glances v2.0_RC1 with psutil v2.1.0
A vrai dire un peut tout...
Le plus simple est de commencer par lancer Glances en mode standalone (supervision de son propre système):
cd ~/tmp/glances LANGUAGE=en_US.utf8 ~/glances-venv/bin/python -m glances -C ~/tmp/glances/conf/glances-monitor.conf
Votre terminal devrait afficher les statistiques (rafraîchissement par défaut de 3 secondes). En appuyant sur la touche 'h', vous obtiendrez une liste des différentes fonctions.
Je vous propose ensuite de passer au mode client/serveur qui peut être testé sur une unique machine (le client et le serveur étant lancé sur la même machine) ou bien sur deux machines différentes.
On commence par lancer le serveur:
cd ~/tmp/glances LANGUAGE=en_US.utf8 ~/glances-venv/bin/python -m glances -C ~/tmp/glances/conf/glances-monitor.conf -s
Puis le client:
cd ~/tmp/glances LANGUAGE=en_US.utf8 ~/glances-venv/bin/python -m glances -C ~/tmp/glances/conf/glances-monitor.conf -c @IPSERVER
Votre terminal va alors afficher les statistiques du serveur.
C'est une nouveauté de la version 2.0. Ce mode permet de lancer un client vers une machine ou le serveur Glances n'est pas lancé. Il va ainsi essayé de se connecter a un serveur SNMP (si celui-ci est installé sur votre serveur). Cette fonction est encore expérimentale et ne fonctionne correctement qu'avec des agents SNMP GNU/Linux.
Pour tester, il suffit de lancer le client:
cd ~/tmp/glances LANGUAGE=en_US.utf8 ~/glances-venv/bin/python -m glances -C ~/tmp/glances/conf/glances-monitor.conf -c @IPSERVER
Votre terminal va alors afficher les statistiques minimale du serveur (par exemple, on a pas la liste des processus).
Egalement une nouveauté de la version 2.0, ce mode permet de lancer un serveur Glances qui va proposer une interface Web. Glances utilise pour cela le framework Bootle qui a déjà fait ses preuves dans de nombreux autres projets libres.
Pour lancer le serveur en mode Web, il faut saisir la ligne de commande suivante:
cd ~/tmp/glances LANGUAGE=en_US.utf8 ~/glances-venv/bin/python -m glances -C ~/tmp/glances/conf/glances-monitor.conf -w
Puis pointer son navigateur Web préféré sur l'adresse suivante: http://<ip serveur>:61208/
Il faut disposer d'un compte Github et de cliquer sur le lien suivant: Remonter un bug dans Glances.
Dans la description, faire systématiquement apparaître:
Je compte sur vous
Cet article Glances v2.0 RC – J’ai besoin de vous ! est apparu en premier sur Le blog de NicoLargo.
Il y a quelques mois, j'avais rédigé un billet sur ma shortlist d'UltraBooks compatible avec un système d'exploitation GNU/Linux. Depuis, mon choix s'est porté vers le Dell XPS 13'' Developer Edition (version 2014 Sputnik). J'ai un peu attendu avant de me lancer dans la rédaction de cet article afin d'avoir le recul suffisant.
On commence par le premier contact avec la machine: l'extérieur. Première chose qui me vient: il est beau. La preuve: même ma femme qui ne jure que par Apple m'a complimenté sur les lignes fines et la qualité des matières (aluminium et plastique). On peut donc le laisser traîner sans problème au milieu de salon.
Au niveau de la taille, il se rapproche du format d'un MacBook Air sans en atteindre la finesse. Comparé à mon ancienne machine, celle-ci passe pour un dinosaure.
Taille du Dell XPS comparé à un Apple MBP 13"
Basé sur processeur Intel i7 4500U cadencé à 3 GHz et disposant de 8 Go de RAM, il est livré avec un disque dur SSD de 250 Go avec Ubuntu 12.04 LTS pré-installé. Pour mon utilisation personnelle (majoritairement du développement, du blogging, de la navigation Internet et de la visualisation de films/séries TV), le dimensionnement de la machine est suffisant. J'aurai cependant aimé pouvoir gonfler la mémoire vive à 16 voir 32 Go de RAM mais Dell ne propose pas cette customisation (d'après certains forums, il semble que la RAM soit soudée à la carte mère...).
L'autonomie est d'environ 6 heures avec une luminosité d'écran adapté (je suis à un peu plus de 50% à l'intérieur de ma maison) et une utilisation mixte (développement, surf et visionnage de vidéos HD). On est donc dans la moyenne des machines de la même catégorie.
L'écran de 13.3 pouces (résolution full HD de 1920x1024) est superbe: lumineux, uniforme en terme de rendu des couleurs et tactile. Ce dernier point est très bien géré, avec notamment la gestion des gestes comme le pincé/écarté pour le zoom/dé-zoom ou le scrolling haut et bas.
C'est un vrai bonheur à regarder. Cependant, il est brillant et donc dédié à une utilisation à l'intérieur.
Ecran superbe mais brillant, donc utilisation en extérieur à éviter... (photo prise avec soleil dans le dos)
Les touches sont très agréables, relativement silencieuses. Seul bémol, il n'y a pas de touches Page Up et Page Down, il faut appuyer sur une combinaison de touches (Fn+Up et Fn+Down). C'est un peu gênant surtout pour les développeurs qui se servent souvent de ces touches pour naviguer à l'intérieur des codes sources. Cependant, après quelques jours, j'ai pris l'habitude des combinaisons.
Un rétro-éclairage du plus bel effet se déclenche automatiquement en cas de besoin. On peut donc continuer à coder dans la nuit :).
Grand, très grand, trop grand. Bien que réactif et précis, il m'arrive régulièrement de cliquer dessus en saisissant un texte sur le clavier. Sous Ubuntu 14.04, il faut saisir la ligne de commande suivante pour avoir un touchpad fonctionnel avec la gestion multitouch:
echo "blacklist i2c_hid" | sudo tee -a /etc/modprobe.d/blacklist.conf
Puis rebooter la machine.
Le Dell XPS Dev Edition est livré en standard avec Ubuntu 12.04 LTS. Au premier démarrage, on tombe donc sur le wizard qui permet de configurer le nom de la machine, le compte utilisateur et la configuration locale (clavier, heure...). Il est donc utilisable en moins de 5 minutes avec un environnement graphique Unity. Avant la réception de ma machine, j'ai consulté les forums de Dell pour savoir si une évolution vers Ubuntu 14.04 LTS était prévue: malheureusement ce n'est pas le cas. On voit ici les limites de la stratégie Linux de Dell. Si on peut louer la démarche de Dell de proposer un PC portable de cette qualité sans Windows, on ne peut que déplorer les limites comme le fait de travailler avec une version qui date de plus de deux ans (même si le support long terme est de cinq ans). Les acheteurs de ce type de configuration sont des geeks qui s'en foutent d'avoir sur leur PC perso une version "stable" de Linux, ils veulent de la nouveauté.
Cependant, cette machine supportant tous les systèmes de dernière génération, j'ai donc téléchargé l'ISO d'Ubuntu Gnome Edition version 14.04 et j'ai fait un test à partir d'une clés USB live pour vérifier que le matériel était compatible. Une fois fait, j'ai donc réinstallé complètement la machine.
Une fois correctement configuré, la machine est très réactive et agréable à utiliser.
Ma prochaine étape sera d'essayer une Arch Linux avec un environnement Gnome 3.12.
Je suis globalement très satisfait de mon achat. Pour avoir bien étudié les différentes alternatives, le Dell XPS est un bon compromis entre la qualité, la puissance et le coût de la machine.
Cet article Mon avis sur le Dell XPS Dev Edition 2014 est apparu en premier sur Le blog de NicoLargo.
Si la nature a rendu une chose moins propre que toutes les autres à la propriété exclusive, c’est l’action de la puissance pensante appelée une idée, qu’un individu possède seulement tant qu’il la garde pour soi; dès l’instant où elle est divulguée, elle s’impose à la possession de tous et celui qui la reçoit ne peut s’en défaire. Ce qui en fait aussi sa particularité est que personne ne la possède moins, car chacun la possède en entier. Celui qui reçoit une idée de moi, l’ajoute à son savoir sans diminuer le mien; de même que celui qui allume sa torche au feu de la mienne, reçoit la lumière sans me plonger dans les ténèbres.
Thomas Jefferson
Découvert lors du visionnage du TEDx 2012 de Cédric Villani.
Cet article Les idées et les logiciels libres est apparu en premier sur Le blog de NicoLargo.