Go Introduction

Introduction

J’ai regardé Docker. Docker est en Go ainsi que pas mal de projets en fait. J’ai donc décidé d’essayer.

Dans ce chapitre nous n’allons pas trop discuter du langage mais surtout mettre en place tout les outils.

Docker-machine

Introduction

Nous allons voir docker-machine. Docker-machine permet de simplifier l’installation/gestion/déploiement de Docker.

Je joue donc je programme

Il existe des jeux vidéos pour apprendre à programmer. Voici quelques exemples.

VimAdventure

Vim adventure permet d’apprendre les touches de Vim de manière ludique. Personnellement j’ai beaucoup joué à Dungeon Crawl qui utilise les touches h, j, k, l

Docker-compose

Dans le post précèdent sur docker, j’avais expliqué comment automatiser la création des containers grâce au Dockerfile aujourd’hui je vais expliquer docker-compose

Awesome et liste de liens

Introduction

Les développeurs aiment les liens. Il y a toujours un article à partager et/ou sauvegarder. Pour les sauvegarder, Personnelement j’utilisai un fichier texte ou j’ajoutai en favori dans mon navigateur (avec plus ou moins de bonheur au moment du changement d’ordinateur). Des gens ont décidé de versionner leurs listes de liens sur Github. Cela s’appelle Awesome-(la techno ou le thème que vous vous voulez)

par exemple:

PHP : awesome-php
Symfony2 : awesome-symfony2
Docker : awesome-docker
Les meilleurs cours en ligne : awesome-courses
React : awesome-react
Sysadmin: awesome-sysadmin
Web Performance Optimization:awesome-wpo
etc ..

Des listes qui contiennent des listes.

Ben oui la liste est longue. C’est pour cela qu’il existe une awesome-list de awesome

awesome-awesomeness

Une conclusion

Si vous cherchez à vous former dans une techno, je crois que vous savez par où commencer.

Docker et Dockerfile

Introduction

Je continue dans mon exploration de Docker, aujourd’hui nous allons voir comment automatiser la création d’un container à l’aide d’un Dockerfile.

Nous allons créer un container pour tig.. C’est un interface git qui marche sous un terminal. Pour moi, c’est un magnifique outil de travail. Je m’en sers très souvent (surtout la vue de status (touche S) puis u pour ajouter, ! pour reverter, C pour commit, e pour lancer mon éditeur (Bien entendu Vim)

Nous allons faire

L’installation à la main
Puis écrire le Dockerfile qui automatise la partie 1
Optimiser un peu celui-ci en utilisant une autre distribution
Faire des commit sous Github, puis sous DockerHub

Création du container à la main

Je commence avec une Ubuntu que je lance en mode interactif.

docker run -it ubuntu:14.10

Je mets à jour ma distribution

apt-get update

J’installe tig (il est dans les dépôts officiels)

apt-get install -y tig

A cause du apt-get update Ubuntu a téléchargé toutes les sources des dépôts dans le répertoire var/lib/apt/lists/ pour ne pas alourdir le container je vais effacer celui-ci

rm -rf /var/lib/apt/lists/*

Je lance tig

root@0a475b7fbed7:/# tig
tig: Not a git repository

Il n’y a pas de dépot git à la racine c’est normal.

je quitte mon container et je liste

docker ps -a
CONTAINER ID        IMAGE                                         COMMAND                CREATED             STATUS                            PORTS                                                                         NAMES
0a475b7fbed7        ubuntu:14.10                                  "/bin/bash"            13 minutes ago      Exited (130) About a minute ago

Je vais le committer.

docker commit -m "add tig" -a "mcamuzat" admiring_yonath mcamuzat/tig:v1

Je vais le relancer avec la commande suivante.

docker run -t -i -v `pwd`:/project mcamuzat/tig:v1

En gros j’ai crée un lien symbolique qui pointe le répertoire courant de mon ordinateur vers le répertoire project du container.

je me place dans le répertoire project.

cd /project

et je lance tig

tig

Si dans le répertoire courant il y a un dépôt git. Normalement l’interface de Tig apparait.

Voila j’ai placé tig dans un container.

Automatisation via un DockerFile.

On se place dans un répertoire vide

Je crée un fichier DockerFile avec le contenu suivant

FROM ubuntu:14.10
MAINTAINER Marc Camuzat <marco@crans.org>
RUN apt-get update \
    && apt-get install -y mysql-client \
    && rm -rf /var/lib/apt/lists/*
WORKDIR /project
VOLUME  /project
ENTRYPOINT ["tig"]

WORKDIR et VOLUME indique à Docker que le répertoire par défault est project et que l’on lance tig

On va maintenant demander à docker de builder l’image à l’aide de la commande suivante

docker build -t mcamuzat/tig:v2 .

On attend un peu.. Et on relance

docker run -t -i -v `pwd`:/project mcamuzat/tig:v2

C’est beaucoup plus rapide.

Optimisons la taille.

Quand je liste mon image via la commande suivante

REPOSITORY              TAG                     IMAGE ID            CREATED             VIRTUAL SIZE
mcamuzat/tig            v2                      103a05c16a2b        3 minutes ago       234.6 MB

Mon container fait 234 méga ! C’est beaucoup pour un simple utilitaire. pour simplifier je vais utiliser une autre distribution alpine-linux (que je ne connaissais pas ..) et le dockerhub suivant qui réduit la distribution à 5 méga !

Voici mon DockerFile

FROM gliderlabs/alpine:3.1
RUN apk --update add tig
WORKDIR /project
VOLUME  /project
ENTRYPOINT ["tig"]

Je relance un build.

docker build -t mcamuzat/tig:v3 .

Maintenant mon container ne fait plus que 24 Méga !

Publions sous Github

Nous allons créer un nouveau dépôt avec un README.

Que je vais cloner.

git clone https://github.com/mcamuzat/tig-docker.git

Je vais ajouter mon DockerFile, Commiter et Pusher

git add Dockerfile
git commit -m"initial commit"
git push origin master

Et c’est tout.

Résultat ici

Publions sur DockerHub

Je pars du principe que vous avez un compte sur DockerHub.

Cliquer sur le bouton Add Repository->Automated Build
choisir Github.
Puis On va vous demander de relier votre compte DockerHub à Github.
DockerHub va vous demander quel projet vous souhaitez builder automatiquement.

Résultat ici

Conclusion

Le Dockerfile sert à automatiser la création d’image. il est plus simple de stocker le Dockerfile que le container (puisque Dockerhub s’occupe de faire build)

J’ai crée mon premier dépôt. Ce n’est pas très compliqué. Dans un prochain article, je vais essayer d’expérimenter docker compose.

Correction orthographique et VIM

J’ai assisté à un Meetup sur VIM.

Le speaker parlait de la correction orthographique sous VIM. Je savais que c’était possible, mais je ne m’en suis jamais servis. J’ai donc décidé de réessayer.. Et j’ai vu de façon différente mes posts sur ce blog. Je suis repasser un peu sur tout.

Voici la commande pour activer/installer la correction automatique

set spell spelllang=fr

Normalement Vim va télécharger pour vous les différents fichiers sur le Ftp officiel. Il y a une commande interactive pour vous aider dans l’installation. Si jamais il a un souci le wiki français indique de se placer dans son répertoire spell (chez moi ~/.vim/spell) et de lancer les commandes suivantes

wget http://ftp.vim.org/vim/runtime/spell/fr.latin1.spl
wget http://ftp.vim.org/vim/runtime/spell/fr.latin1.sug
wget http://ftp.vim.org/vim/runtime/spell/fr.utf-8.spl
wget http://ftp.vim.org/vim/runtime/spell/fr.utf-8.sug

La touche magique ici est z= puis les touches du 0..n. ]s pour aller à l’erreur suivante [s pour l’erreur précédente. Il y a différentes touches pour ajouter à son propre dictionnaire. J’avoue que cela ne m’intéresse pas trop de suite.

On peut aussi faire de l’auto complétion ou plutôt de l’auto correction pendant la saisie avec les touche Ctrl-x + s.

Résumé

Touche	Description
`z=`	auto correct si `spell` est activée
`[s`	erreur précédente
`]s`	erreur suivante
`Crtl-x s`	auto complétion via le dictionnaire

Warning : Ctrl-s parfois freeze le terminal (option pratique quand je regarde les tests fonctionnels passés). Pour defreezer le terminal c’est Ctrl-Q

Conclusion:

Il manque le correcteur grammatical :-)

Docker et CI

Introduction

je continue sur ma découverte de Docker. Je vais parler de deux containers

phaudit pour faire de la qualité de code
JoliCi pour l’intégration continu

Faire de la qualité avec Docker

Il y a un container fourni par phaudit qui contient déjà des outils pour auditer le code.

Voici la ligne de commande pour l’installer

docker pull jolicode/phaudit

Et je me place dans mon répertoire projet

Listes des programmes

PHPLoc phploc donne le nombre de ligne, le nombre de classes etc ..

docker run -t -i -v `pwd`:/project jolicode/phaudit phploc src
Directories                                         10
Files                                               91

Size
  Lines of Code (LOC)                             7295
  Comment Lines of Code (CLOC)                    3228 (44.25%)
  Non-Comment Lines of Code (NCLOC)               4067 (55.75%)
  Logical Lines of Code (LLOC)                     774 (10.61%)
    Classes                                        711 (91.86%)
      Average Class Length                           8
        Minimum Class Length                         0
        Maximum Class Length                        67
      Average Method Length                          1
        Minimum Method Length                        0

PHP Mess Detector phpmd donne un retour sur la qualité du code (nommage des variables etc..)

phaudit phpmd . text naming
/project/src/Allmy/Protocol/LineReceiver.php:38   Avoid variables with short names like $b. Configured minimum length is 3.
/project/src/Allmy/Reactor/StreamSelectReactor.php:32 Avoid variables with short names like $id. Configured minimum length is 3.
/project/src/Allmy/Reactor/StreamSelectReactor.php:43 Avoid variables with short names like $id. Configured minimum length is 3.
/project/src/Allmy/Reactor/StreamSelectReactor.php:53 Avoid variables with short names like $id. Configured minimum length is 3.
...
...

PHP_CodeSniffer phpcs erreur de convention de code (Psr-..) et phpcbfpour les fixer automatiquement

docker run -t -i -v `pwd`:/project jolicode/phaudit phpcs src/Allmy/Reactor/StreamSelectReactor.php
FILE: /project/src/Allmy/Reactor/StreamSelectReactor.php
----------------------------------------------------------------------
FOUND 85 ERRORS AND 3 WARNINGS AFFECTING 63 LINES
----------------------------------------------------------------------
   2 | ERROR   | [ ] Missing file doc comment
  11 | ERROR   | [ ] Missing class doc comment
  15 | ERROR   | [ ] Private member variable "timers" must be
.....
.....
.....
 275 | ERROR   | [ ] Parameter tags must be grouped together in a doc

PHP Copy/Paste Detector phpcpd détecte les copier/coller

docker run -t -i -v `pwd`:/project jolicode/phaudit phpcpd src
Found 2 exact clones with 101 duplicated lines in 4 files:

  -   /project/src/Allmy/Stream/Factory.php:9-53
  /project/src/Allmy/Internet/Factory.php:9-53
 
  -   /project/src/Allmy/Transport/TcpServer.php:9-66
  /project/src/Allmy/Socket/Server.php:9-66
 
1.38% duplicated lines out of 7295 total lines of code.

d’autre commandes que je connais un peu moins

PHP_Depend pdepend donnes des analyses, dépendences, complexités etc..
PHP Dead Code Detector phpdcd détecte le code qui semble ne pas servir.
PhpMetrics phpmetrics donnes des métriques (Je ne connais pas)

docker run -t -i -v `pwd`:/project jolicode/phaudit phpmetrics --report-cli .

PHP Coding Standards Fixer as php-cs-fixer une autre commandes pour fixer le code par Sensio

L’astuce est de se créer l’alias suivant

alias phaudit="docker run --rm -ti \
    -v \`pwd\`:/project \
    jolicode/phaudit"

alors les lignes de commandes précédentes deviennent plus simple

phaudit phpmd . text naming

Tester sur toutes les versions de php

Fait par la même équipe.

il est possible de faire une intégration continue en local. Il va lancer les builds en testant toutes versions de php spécifié dans un fichier yml.

L’installation est très simple il suffit de télécharger le .phar à l’url suivante

wget url du fichier phar

il faut créer un fichier .travis.yml voici les lignes à ajouter pour un projet en php

language: php
php:
  - "5.5"
  - "5.4"
  - "5.3"

puis la commande suivante:

php jolici.phar run
Creating builds...
3 builds created

Running job php = 5.5

PHPUnit 3.7.38 by Sebastian Bergmann.

Configuration read from /home/project/phpunit.xml.dist

......

Time: 106 ms, Memory: 3.50Mb

OK (6 tests, 34 assertions)

Running job php = 5.4

PHPUnit 3.7.38 by Sebastian Bergmann.

Configuration read from /home/project/phpunit.xml.dist

......

Time: 131 ms, Memory: 3.50Mb

OK (6 tests, 34 assertions)

Running job php = 5.3

PHPUnit 3.7.38 by Sebastian Bergmann.

Configuration read from /home/project/phpunit.xml.dist

......

Time: 7 ms, Memory: 6.25Mb

OK (6 tests, 34 assertions)

En ajoutant un fichier .yml et sans installer aucune version de php, je peux tester sur trois plateformes mon code. C’est vraiment impressionnant.

Conclusion

Nous avons vus ensemble deux applications très simples qui permettent d’intégrer Docker dans notre workflow.

Merci à l’équipe JoliCode pour ces deux outils.

Je me suis inspiré de la présentation suivante. http://slides.com/jeremyderusse/docker-dev#/5/2

10print

Je suis tombé un peu par hasard sur la critique du livre 10 PRINT , le pdf du livre est gratuit et plutôt joli, il parle de programmation, d’art et d’aléatoire. Tout le livre est centré sur le programme de basic suivant qui donne l’image de la couverture.

10 PRINT CHR$(205.5+RND(1)); : GOTO 10
/\\\\\\//\\////\\/\/\/\//\///////\\/////\///\\/\\
\/\///\/\//\\//\\\/\\\/\///\\\\\\/\/\\\\\\/\\\/\\
\\////\/////\\\\\\\/\\\\\\\\\\\//////\/\/\\\\/\//
/\//\\\/\\\/\\///\\//\////\\/\/\//\\//\//\\/////\
///\\/\\\\///\\/\/////\\\/\\\///\//\\\\//\\//\//\
//\\\\//\\/\//\\//\///\\/////\///\/\//\/\//\//\\/
//\/\/\///\\\/\//\////\\\//\/\/\\\\\\//\\\\\///\/
//\\/\\\//\////\//\\\\\/\////\\\///\/\\/\//\\\///
//\//\/\\\\\//////\///\/\\\/\/\/\\//\\/\\\//\//\\
//\/\/\\\/\\/\/\////\//\\//\\//\/\///\/\/////\///
//\\//\\\/////\//\//\\/\\//\/\//\//\\/\//\\\\\//\

Bon la police d’écriture ne rend pas vraiment justice au code.

C’est possible de faire le même motif en PHP et en peu de code ?

Une solution

$out = array('/', '\\');
for($i = 0; $i < 1000; $i++){
    echo $out[array_rand($out)];
}

Attention array_rand renvoie la clé et non la valeur d’où le $out[array_rand($out)]

Et puis je me suis dit que array_rand ne sert pas à grand chose.

Donc j’ai essayé

$out = array('/', '\\');
for($i =0; $i < 1000; $i++){
 echo $out[rand(0,1)];
}

pour générer des nombres aléatoire, il vaut mieux utiliser mt_rand qui d’après la documentation génère des nombres aléatoires plus intéressants (?). Pour des vrai nombres aléatoires pour les mots de passe, on utilise des librairies voir cette présentation.

Mais il est possible d’initialiser plus d’une constante dans la boucle for.

for($i =0, $out = array('/', '\\'); $i < 1000; $i++){
 echo $out[mt_rand(0,1)];
}

On peut aussi faire plus d’une action dans l’incrémentation.

for($i = 0, $out = array('/', '\\'); $i < 1000; $i++, echo $out[mt_rand(0,1)])
);

On minimise les variables et la notation avec les []

Nous obtenons le code suivant

for($i =0, $o = ['/', '\\']; $i < 1000; $i++, echo $o[mt_rand(0,1)]);

Je n’avais jamais écris de boucle for sans corps({..}).

La documentation de PHP est plutôt claire sur le for

Docker Je débute

Docker

Suite à une présentation à une conférence. J’ai commencé à m’y mettre. J’écris ce post en tant que grand débutant..

Docker est une solution de virtualisation d’instance, plus précisément de container. Il y a pas mal de différence avec les différentes visualisations de Virtual box/Xen/VmWare. On isole juste les process et le file-system. Ce qui fait que l’on consomme très peu de processeurs.

Installation

Installer docker n’est pas très compliqué sous ubuntu 14.04.

sudo apt-get install docker.io

Et c’est tout !

Pour éviter de préfixer sudo à chaque commande il est plus facile d’ajouter son utilisateur au group docker.

sudo addgroup <votre user> docker

Hello world sous docker

Lancer docker

docker run ubuntu:14.04 /bin/echo 'Hello world'

Cette commande fait plusieurs choses:

si l’image ubuntu:14.04 n’existe pas, elle va la télécharger.
Puis on lance le container
Puis on exécute echo ‘Hello world’

D’ailleurs si on relance la même commande, on constate que l’image est déjà sur le disque dur.

la commande prend moins d’une seconde. Pourtant on a chargé un container et lancer une commande !

Essayons la commande suivante

docker run ubuntu:14.04 - it /bin/bash
root@b2634b81c3dc:/#

Nous avons un bash intéractif. -i mode interactif, et -t affiche un pseudo terminal

Il faut comprendre que dès que la commande principale est finie, l’instance aussi. Dans le cas Echo 'Hello World' la commande se finit de suite. Dans le cas de /bin/bash On spécifie le mode interactif. Donc l’instance continue tant que l’on a pas quitté le bash.

Ouvrons un nouveau terminal

docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
b2634b81c3dc        ubuntu:14.04        /bin/bash           43 seconds ago      Up 42 seconds                           sharp_archimedes

On voit que mon image est toujours en cours.

La commande docker ps affiche tout les containers allumés pour afficher tout les containers allumés pendant la session. C’est dockers ps -a

On peux inspecter une instance avec la commande

docker inspect sharp_archimedes
docker inspect b2634b81c3dc

Cela renvoie un json.

On peux aussi lister les images disponibles via la commande

docker images

Vous voulez télécharger des images

docker pull centos

Vous cherchez une images particulières

docker search php56

La liste des images disponibles est disponible sur Docker Hub . D’ailleurs Dockers est très couplé avec DockerHub. DockerHub est un le GitHub pour Docker. On peux très bien faire du Git sans GitHub. C’est la même chose pour docker.

Docker et Git partage aussi la notion de commit et de push.

relancons notre instance

docker run -it ubuntu:14.04 /bin/bash
root@f5882f7f608d:/#

Installons un paquet au hasard

sudo apt-get install vim

On quitte Exit

puis on commit

sudo docker commit f5882f7f608do marc/vim
4f177bd27a9ff0f6dc2a830403925b5360bfe0b93d476f7fc3231110e7f71b1c

Si je liste les images.

docker images

je vois apparaitre mon marc/vim

Je peux ainsi réutiliser mon container ainsi

sudo docker run -it marc/vim vim

On peux ainsi se créer ses propres containers. Mais c’est un peu laborieux. Docker utilise des DockerFile pour automatiser le process. Cela fera un prochain post

Résumé des commandes

docker run -i -t ubuntu:14.10 /bin/bash lance en mode interactif et un terminal avec la commande Bash.
docker run -i -t ubuntu:14.10 'hello world'
docker ps liste les containers en cours.
docker ps -a liste tout les containers.
docker images liste toutes les images.
docker pull centos pour télécharger une image (tout les images officielles sont sur le Hub
docker inspect uuid affiche les informations sur l’instance.
docker commit uuid namepour commiter.

Conclusion

Bon j’avoue que je débute depuis 2 jours. Ce qui m’impressionne dans Docker c’est la vitesse (moins d’une seconde pour démarrer). C’est plutôt simple d’utilisation. La notion de commit a l’air sympa (Même si au fond c’est l’équivalent d’un snapshot sous vmware). J’espère pouvoir faire mon premier dépôt sous DockerHub bientôt.

← Older Blog Archives Newer →