Je suis développeur web freelance et propose des formations à Symfony2 ! Contactez-moi pour en discuter.

Depuis quelques temps, j’ai un serveur chez DigitalOcean, qui me sert principalement pour bricoler des petites applis, et jouer autour de nouvelles technos. DigitalOcean m’a séduit par le rapport pricing/résultat. Même s’il y a des choses à redire, où s’il existe des offres similaires moins chères, je suis très satisfait de pouvoir créer/détruire des machines virtuelles en 2 clics. Cela correspond en fait totalement à mon cas d’utilisation, qui consiste à monter une machine pour tester une techno, bidouiller dessus, et la détruire quand j’ai fait le tour de ce que je voulais voir.

Par contre, il est du coup un peu pénible de devoir réinstaller sa machine virtuelle à chaque fois. Installer un LAMP basique avc phpmyadmin se fait assez vite, ça tient en quelques ligne de bash :

1
2
3
4
5
6
7
8
9
10
11
12
13
#!/bin/sh
apt-get update
#install apache
apt-get install apache2
#install mysql
apt-get install mysql-server
mysql_secure_installation
#install php
apt-get install php5 php-pear php5-suhosin php5-mysql
service apache2 restart
# install phpmyadmin
apt-get install phpmyadmin
ln -s /usr/share/phpmyadmin/ /var/www

Mais dès qu’on veut faire quoi que ce soit de plus évolué, la complexité augmente rapidement. En plus d’installer des paquets il faut aller modifier des fichiers de configuration, ce qui devient rapidement chronophage, et me détourne de l’essentiel, le développement. Avec l’habitude on finit par connaitre les écueils à éviter pour aller vite, mais on y passe quand même du temps.

C’est là où Vagrant devient intéressant. Couplés à PuPHPet et DigitalOcean, j’ai personnellement atteint le nirvana de l’installation de VM en à peine 2H.

Vagrant sert à piloter des machines virtuelles. On lui file un répertoire de configuration pour définir l’environnement à installer sur une machine virtuelle. PuPHPet est une appli web qui permet de construire sa configuration pour Vagrant via une IHM, ce qui évite de devoir lire la doc. On est forcément plus limité que si on faisait tout soi même, mais dans mon cas (déployer un environnement apache ou nginx avec mysql ou postgresql, suivant l’humeur), j’ai de bonnes bases pour pouvoir faire ce qui m’intéresse sans m’embêter.

De l’intérêt de Vagrant

En fait, mon cas d’utilisation (déployer des VM kamikaze) est loin d’être le plus intéressant. Là où Vagrant prend tout son sens, c’est lorsqu’on travaille en équipe, et que l’on a le besoin de pouvoir avoir finalement de nouvelles machines identiques. Par exemple, lorsqu’un nouvel arrivant doit installer sa machine et qu’on veut une belle machine toute neuve, sans avoir à copier l’ISO de celle d’un copain, sans faire d’efforts, et sans surprises.
Et même s’il y a une valeur ajoutée à ce qu’un nouvel arrivant installe sa machine et comprenne ce qui s’y trouve, lorsqu’on plante sa bécane, on a pas forcément envie de passer du temps à tout réinstaller. De plus, une installation automatique et scénarisée permet d’assurer que tout le monde a le même environnement, ce qui n’est pas le cas d’un installation manuelle (« j’ai pas réussi à faire les choses telles qu’elles étaient décrites dans le manuel, donc j’ai googlé une alternative »), et qui peut souvent poser problème.

Autre avantage, toute la configuration de la machine à déployer tient en quelque fichiers de configuration. On peut donc la modifier, la versionner, la partager, la livrer… beaucoup plus facilement qu’on le ferait avec un manuel d’installation.

Ok, on a compris, on fait comment ?

PuPHPet vous permet de déployer des machines en local, chez DigitalOcean ou Amazon EC2.
Je vais décrire les étapes par lesquelles je suis passé pour partir de rien, et déployer une machine virtuelle sur Digital Ocean. Avoir un compte chez eux (associé à une carte bancaire) est nécessaire pour aller jusqu’au bout, mais la logique est la même si vous voulez déployer ailleurs.

Configuration de la machine locale

Nous aurons besoin d’une clé SSH pour nous authentifier par la suite, créons la.

1
2
cd ~/.ssh
ssh-keygen -t rsa -C "votre@email.com"

Je l’ai appelé digital_ocean au lieu d’id_rsa.

Il est nécessaire d’installer vagrant et virtual box. Vous pouvez récupérez les derniers paquets sur http://downloads.vagrantup.com/
https://www.virtualbox.org/wiki/Linux_Downloads

Sur Ubuntu/Debian, on installe les fichiers .deb avec sudo dpkg -i *.deb

Il également installer le plugin pour digital ocean :

1
2
vagrant plugin install vagrant-digitalocean
vagrant box add dummy https://github.com/smdahlen/vagrant-digitalocean/raw/master/box/digital_ocean.box

Créer un projet

1
mkdir vagrant_env

C’est dans ce répertoire que nous mettrons le code de configuration utilisé par vagrant. En général, on fait un vagrant init pour démarrer un nouveau fichier de configuration, mais nous allons utiliser PuPHPet qui va faire ça pour nous.

Configurer digital ocean

Enregistrez la clé SSH que vous avez créé : https://cloud.digitalocean.com/ssh_keys

Il faut ensuite récupérer votre identifiant utilisateur et votre clé API : https://cloud.digitalocean.com/generate_api_key

Notez la clé API quelquepart, car elle n est plus affichée quand on revient sur la page et le seul moyen d’en avoir une est de la regénérer.

Configurez votre machine avec PuPHPet

Je vous laisse configurer votre machine aux petits oignons avec PuPHPet. N’oubliez pas de renseigner toutes les informations sur la configuration Digitalocean (clés API), nom de la machine, et type de machine.
Vous pouvez choisir le type de serveur (apache2/nginx), postgresql ou mysql, installer ou non phpmyadmin, la configuration de PHP, les packages divers à installer… c’est très simple.

Une fois terminé, un immense bouton permet de télécharger vos fichiers de configuration. Décompressez les dans un répertoire, vous devriez avoir l’arborescence suivante :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
.
├── files
│   └── dot
├── hiera.yaml
├── puppet
│   ├── hieradata
│   │   └── common.yaml
│   ├── manifests
│   │   └── default.pp
│   └── Puppetfile
├── shell
│   ├── initial-setup.sh
│   ├── librarian-puppet-vagrant.sh
│   ├── os-detect.sh
│   ├── self-promotion.txt
│   └── update-puppet.sh
└── Vagrantfile

Dans le fichier puppet/hieradata/common.yaml, vous trouverez toutes les informations que vous avez spécifiées sur comment configurer votre machine. Dans le répertoire files/dot, vous pouvez ajouter un fichier .bashrc, .vimrc… qui seront déployées lors de l’installation de votre machine.

Normalement, on est prêt à déployer sa machine :

1
vagrant up

Ca n’a pas marché pour moi (machine sous Ubuntu 12.04), il fallait encore faire quelques légères modifications. La clé ssh n’a pas été bien prise en compte lorsque je l’ai précisé dans PuPHPet, j’ai du modifier

1
config.ssh.private_key_path = "~/.ssh/digitalocean" dans le fichier VagrantFile

Il a également fallu ajouter dans mon fichier .bashrc

1
export SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt

puis dans le fichier VagrantFile, ajouter la ligne

1
provider.ca_path = "/etc/ssl/certs/ca-certificates.crt"

dans vm.provider

Voici donc un exemple de configuration qu’on peut avoir. Vous pouvez voir que c’est au final très simple, on dit ce dont on a besoin et comment le configurer, et vagrant se charge de l’installer pour nous. Grâce au plugin DigitalOcean, il crée même la machine pour nous.

Fichier VagrantFile

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
ENV['VAGRANT_DEFAULT_PROVIDER'] = 'digital_ocean'

Vagrant.configure("2") do |config|
  config.ssh.private_key_path = "~/.ssh/digitalocean"
  config.ssh.username = "clem"

  config.vm.box = "dummy"

  config.ssh.private_key_path = "~/.ssh/digitalocean"

  config.vm.hostname = "plop"
  config.vm.provider :digital_ocean do |provider|
    provider.client_id = "id_digital_ocean_que_vous_avez_fourni"
    provider.api_key = "cle_api_digital_ocean_que_vous_avez_fourni"
    provider.image = "Debian 7.0 x64"
    provider.region = "Amsterdam 1"
    provider.size = "512MB"
    provider.ca_path = "/etc/ssl/certs/ca-certificates.crt"
  end

  config.vm.synced_folder "./", "/var/www", id: "webroot"

  config.vm.provision :shell, :path => "shell/initial-setup.sh"
  config.vm.provision :shell, :path => "shell/update-puppet.sh"
  config.vm.provision :shell, :path => "shell/librarian-puppet-vagrant.sh"
  config.vm.provision :puppet do |puppet|
    puppet.facter = {
      "ssh_username" => "clem"
    }

    puppet.manifests_path = "puppet/manifests"
    puppet.options = ["--verbose", "--hiera_config /vagrant/hiera.yaml", "--parser future"]
  end

  config.ssh.shell = "bash -l"

  config.ssh.keep_alive = true
  config.ssh.forward_agent = false
  config.ssh.forward_x11 = false
  config.vagrant.host = :detect
end

Fichier common.yml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
---
vagrantfile-digital_ocean:
    vm:
        box: digital_ocean
        hostname: nom_de_votre_machine
        network:
            private_network: 192.168.56.101
            forwarded_port: {  }
        provider:
            digital_ocean:
                image: 'Debian 7.0 x64'
                region: 'Amsterdam 1'
                size: 512MB
                client_id: id_digital_ocean_que_vous_avez_fourni
                api_key: cle_api_digital_ocean_que_vous_avez_fourni
        provision:
            puppet:
                manifests_path: puppet/manifests
                options:
                    - --verbose
                    - '--hiera_config /vagrant/hiera.yaml'
                    - '--parser future'
        synced_folder:
            DXt5BtQJjHh3:
                id: webroot
                source: ./
                target: /var/www
    ssh:
        host: null
        port: null
        private_key_path: ~/.ssh/digitalocean
        username: clem
        guest_port: null
        keep_alive: true
        forward_agent: false
        forward_x11: false
        shell: 'bash -l'
    vagrant:
        host: ':detect'
server:
    packages:
        - vim
        - git
    dot_files:
        -
            bash_aliases: null
    _prevent_empty: ''
nginx:
    vhosts:
        1Zbx9ZeVKOfF:
            server_name: awesome.dev
            server_aliases:
                - www.awesome.dev
            www_root: /var/www/awesome.dev
            listen_port: '80'
            index_files:
                - index.html
                - index.htm
                - index.php
            envvars:
                - 'APP_ENV dev'
php:
    version: '55'
    composer: '1'
    modules:
        php:
            - cli
            - intl
            - mcrypt
            - curl
            - common
            - gd
            - fpm
            - memcache
            - memcached
            - xcache
        pear: {  }
        pecl:
            - pecl_http
    ini:
        display_errors: On
        error_reporting: '-1'
        session.save_path: /var/lib/php/session
    timezone: Europe/Paris
xdebug:
    install: 0
    settings:
        xdebug.default_enable: '1'
        xdebug.remote_autostart: '0'
        xdebug.remote_connect_back: '1'
        xdebug.remote_enable: '1'
        xdebug.remote_handler: dbgp
        xdebug.remote_port: '9000'
mysql:
    root_password: votre_mot_de_passe_root_bdd
    phpmyadmin: '1'
    databases:
        T7hssen8Pk2a:
            grant:
                - ALL
            name: clem
            host: localhost
            user: clem
            password: votre_mot_de_passe_bdd
            sql_file: ''

Bref, j’ai vraiment été séduit par le rapport effort/résultat. Il m’aura fallu environ 1h30 pour générer cette configuration de machine que je peux redéployer à volonté, ce qui est à peine plus que le temps que ça m’aurait pris si je l’avais fait à la main. Sauf que maintenant, tous les déploiements suivants peuvent se faire via vagrant up, et que si je souhaite travailler avec des collègues sur les projets pour lesquels j’ai construit cette machine, je peux leur fournir la configuration exacte de la machine à installer.

Répondre

Unable to load the Are You a Human PlayThru™. Please contact the site owner to report the problem.