Vagrant Tutorial

Vagrant (zu Deutsch: „umherwandernd“) ist ein klasse Tool für verteilte Entwicklung. Muss man sich so vorstellen: Entwickler A soll soll einen Bug fixen, holt die entsprechende Vagrant-Box hervor und findet in ihr die komplette Projektumgebung wieder – Apache, MySQL, PHP in der jeweils korrekten Version, Anbindung an den CI-Server und alles was man eben so benötigt. Nach getaner Arbeit wird das Projekt deployed und die Vagrant Box gespeichert. Wenn dann später wieder jemand an diesem Projekt arbeitet, schnappt er sich einfach die Box und legt los. Kein lästiges Umherkämpfen mit vhosts, falschen Softwareversionen und allem, worauf eigentlich niemand Lust hat. Aber der Reihe nach.

Vagrant installieren

Zuerst wird die VirtualBox von Oracle benötigt. Hier ist allerdings Vorsicht geboten. Vagrant unterstützt unter Umständen nicht die neuste Version, also hier nachlesen, welche Versionen supported werden und dann von hier herunterladen. Vagrant verwendet VirtualBox zur Virtualisierung des Betriebssystems in der Box. Danach ist Vagrant selbst dran – Download befindet sich hier.

Nun muss der Hauptordner von VirtualBox zum PATH (Umgebungsvariable) hinzugefügt werden.

PATH

PATH

Als nächstes ins bin-Verzeichnis von Vagrant per cmd wechseln, bei mir ist das D:\vagrant\vagrant\bin. Weiter mit der Installation der Box.

Eine Box installieren

Wir installieren Ubuntu 12.04 Precise Pangolin, die Box dazu befindet sich unter http://files.vagrantup.com/precise32.box.

vagrant box add webdev http://files.vagrantup.com/precise32.box

Box installieren

Box installieren

Die Box ist heruntergeladen, nun gehts weiter mit:

vagrant init

Dieser Befehl erstellt ein sog. Vagrantfile im bin-Ordner, welches die Konfiguration beinhaltet. Hier kann bspw. festgelegt werden, welche Ports benutzt werden sollen und ob Ordner zwischen Hostsystem und Box geteilt werden.

Das Vagrant-File

Im Wesentlichen sieht ein Vagrantfile (Ruby-Syntax) – auf die nötigsten Optionen reduziert – so aus:

Vagrant::Config.run do |config|
  config.vm.box = "webdev"
  config.vm.box_url = "http://files.vagrantup.com/precise32.box"

  config.vm.share_folder("v-web", "/vagrant/www", "D:/www")
  config.vm.forward_port 80, 3456

  config.vm.define "webdev" do |default_config|

    #Puppet
    default_config.vm.provision :puppet do |puppet|
      puppet.facter = { "fqdn" => "local.dev", "hostname" => "www" }
      puppet.manifests_path = "puppet/manifests"
      puppet.manifest_file  = "ubuntu-apache2-mysql-php5.pp"
      puppet.module_path  = "puppet/modules"
    end
  end
end

Beachtenswerte Zeilen:

  • config.vm.share_folder – Der Ordner D:/www wird im Vagrant-Filesystem unter /vagrant/www verfügbar gemacht.
  • config.vm.forward_port – Port 3456 auf unserem Host-System soll in Port 80 der Vagrant-Box enden.
  • Wir verwenden Puppet zum Konfigurieren der „webdev“ genannten Box, dazu gleich mehr

Puppet-File anlegen

Das in der Config angegebene Puppet-File ubuntu-apache2-mysql-php5.pp beinhaltet sämtliche Anweisungen für die Vagrant-Box. Alternativ lässt sich auch Chef zum Konfigurieren verwenden. Puppet machte auf mich aber einen besseren Eindruck.

Wir legen unter \vagrant\vagrant\bin\puppet\manifests eine leere Datei ubuntu-apache2-mysql-php5.pp an.

Puppet-File

Puppet-File

Folgenden Inhalt packen wir in die ubuntu-apache2-mysql-php5.pp hinein:

Exec { path => [ "/bin/", "/sbin/" , "/usr/bin/", "/usr/sbin/" ] }

class system-update {

  exec { 'apt-get update':
    command => 'apt-get update -y',
  }

  $sysPackages = [ "build-essential" ]
  package { $sysPackages:
    ensure => "installed",
    require => Exec['apt-get update'],
  }
}

include system-update

class php5 {

  package { "php5":
    ensure => present,
  }

  $phpPackages = [ "php5-cli", "php5-common", "php5-dev", "php5-mysql", "php5-curl" ]
  package { $phpPackages:
    ensure => "installed",
    require => Exec['apt-get update']
  }
  
  package { "libapache2-mod-php5":
	ensure => present,
  }
}

include php5

class apache2 {

	package { "apache2":
		ensure => present,
	}

	service { "apache2":
		ensure => running,
		require => Package["apache2"]
	}
}

include apache2

package { "php-pear" :
    ensure => present,
    require => Package['php5'],
	notify  => Service['apache2']
}


class mysql {
	 package {
		["mysql-client", "mysql-server", "libmysqlclient-dev"]: 
		  ensure => installed, require => Exec['apt-get update'],
		  notify  => Service['apache2']
	  }
}

include mysql

class development {

  $devPackages = [ "curl", "git" ]
  package { $devPackages:
    ensure => "installed",
    require => Exec['apt-get update'],
  }
}

include development

file { "/var/www/index.html":
	ensure => absent
}
 
file { "/var/www/index.php":
	ensure => present,
	content => '<?php echo "Hello, World!";',
	mode => 644,
	owner => www-data,
	group => www-data
}

Das muss man jetzt erstmal auf sich wirken lassen. Prinzipiell ist das Puppet-File so aufgebaut, dass die Instruktionen in Klassen stecken, die nach ihrem include dann ausgeführt werden. Wir definieren zuerst eine Exec-Funktion, die an den typischen Orten nach ausführbaren Dateien sucht – brauchen wir später noch. Zuerst machen wir ein System-Update, dass alles auf dem neusten Stand ist. Weiterhin werden die „build-essentials“ installiert – kann man immer gebrauchen. Dann der Reihe nach PHP mit den Paketen „php5-cli“, „php5-common“, „php5-dev“, „php5-mysql“, „php5-curl“ und Apache. Dann noch pear und mysql. Nach der Installation von mysql wird Apache benachrichtigt, dass er bitte neu laden soll („notify“). Abschließend holen wir dann noch curl und git. Zu guter Letzt löschen wir die Apache-Standard „index.html“-Datei im /var/www/-Verzeichnis und packen dafür eine index.php-Datei hinein. Ich denke, das Prinzip sollte klar sein. Weiterführende Erklärung zu Puppet finden sich hier.

vagrant up

Es wird Zeit, die Box zu starten. Das läuft mit vagrant up. Alternativ können wir auch vagrant up webdev verwenden, wenn mehrere Boxen existieren – unsere Box heißt ja schließlich webdev. Nun startet die Box und installiert alle gewünschten Dependencies aus dem Puppet-File – das dauert etwas, allerdings ist die vollständige Installation ein einmaliger Vorgang, weil danach nur noch inkrementelle Updates nötig sind, falls sich am Puppet-File etwas ändert. Übrigens: Ist die Box einmal geladen und ihr nehmt am Puppet-File eine Änderung vor, muss nicht die ganze Box neu gestartet werden. Folgendes Kommando tuts auch: vagrant provision. Hier wird allerdings nur das Provisioning durchgeführt (=alles, was sich in der Puppet-Datei befindet). vagrant reload lädt im Gegensatz dazu auch die Konfiguration neu.

Installation fertig

Installation fertig

Verbindung zur Box

Nun ist die Box gestartet und läuft brav im Hintergrund mit. Als nächstes verbinden wir uns mit Putty per SSH auf die Box. Dazu feuern wir erstmal das Kommando

vagrant ssh ab, was uns folgendes verrät:

`vagrant ssh` isn't available on the Windows platform. You are still able
to SSH into the virtual machine if you get a Windows SSH client (such as
PuTTY). The authentication information is shown below:

Host: 127.0.0.1
Port: 2200
Username: vagrant
Private key: C:/Users/dav/.vagrant.d/insecure_private_key

Also schnappen wir uns den Private Key aus genanntem Verzeichnis und laden uns PuTTYgen herunter, um den Private Key ins Putty-Format zu konvertieren. PuTTygen starten, auf „Load“ drücken und den Private Key C:/Users/dav/.vagrant.d/insecure_private_key auswählen.

PuTTygen

PuTTygen

Nun auf Save Private Key (jaja, ohne Passwort…) und den ins Putty-Format konvertierten Private Key auf der Festplatte speichern. Jetzt kommt wieder Putty selbst zum Einsatz. Wir verbinden uns auf 127.0.0.1 mit Port 2222. Dann unter Connection -> SSH -> Auth wählen wir den Key und speichern die Session.

Private Key

Private Key

Und wenn alles klargegangen ist, begrüßt uns eine vollwertige Linux-Shell:

SSH

SSH

Hier sind jetzt bereits Apache, PHP, MySQL und alle anderen Raffinessen aus dem Puppet-File aufgespielt. Nun den Browser auf dem Host-System angeworfen und http://127.0.0.1:3456/ besucht – voilà. Der Rest erschließt sich jetzt von alleine. Wenn die Box in ihrem fertigen Zustand gespeichert werden soll, benötigt es das vagrant package-Command. Näheres hierzu findet sich auf der Vagrant-Seite zum Packaging.

Weitere Posts:

Dieser Beitrag wurde unter webdev, Linux, misc IT veröffentlicht. Setze ein Lesezeichen auf den Permalink.

6 Antworten auf Vagrant Tutorial

  1. Alex sagt:

    Vielen Dank, endlich was nachvollziehbares beim lesen und sehen und auch genau für einen Web-Entwickler ;)

    Gelungen!

  2. Pingback: Vagrant - Fortsetzung nur nicht von mir!

  3. Manu sagt:

    Klasse Anleitung hat mir sehr geholfen, aber irgendwie konnte mein apache kein PHP interpretieren. Ich musste dann noch
    „sudo apt-get install libapache2-mod-php5
    sudo /etc/init.d/apache2 restart“ installieren.

    Gruß

  4. Kapello sagt:

    Super Anleitung für einen schnellen und groben Einstieg!

    Allerdings gibt es scheinbar Probleme beim speichern von Änderungen neuer Dateien mittels nano…

  5. Alex sagt:

    Ich würde gerne mal diesen Link hier hinterlassen ;)

    https://puphpet.com/

  6. Matus sagt:

    Hi,
    nettes Tutorial.
    Nur eine kleine Anmerkung.
    Ich musste unter Windows 7 manuell den Ordner „puppet/modules“ anlegen
    da beim ersten „vagrant up“ gemeldet wurde das der modules-Ordner nicht existiert.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.