Virtuelle utviklingsmiljø med Vagrant, VirtualBox og Puppet

Virtuelle utviklingsmiljø med Vagrant, VirtualBox og Puppet

Konsulenter og andre som driver med programvareutvikling vil ofte måtte bruke ulike verktøy og produkter i ulike prosjekter. Ofte må en utvikler trå til i et gammelt prosjekt for å rette feil eller gjøre endringer, og da må det installeres utviklingsmiljø med riktige versjoner av basis programvare som applikasjonstjener, database og ulike biblioteker. Samtidig vil den enkelte utvikler helst bruke egen maskin og selvvalgt operativsystem og editor eller IDE.

En måte å løse dette på ganske elegant er å ta i bruk virtuelle utviklingsmiljø. Med denne teknikken kan utviklere raskt installere et miljø med riktige versjoner av programvare, gjøre nødvendig utvikling, testing og utrulling, og deretter stenge ned og fjerne miljøet fra egen maskin.

Dette innlegget er en introduksjon til hvordan dette kan gjøres.

For å kjøre eksemplene trenger du å ha Vagrant, VirtualBox og git installert på egen maskin, og ca 2,5 Gb ledig diskplass.

Komme i gang med Vagrant og VirtualBox

Vagrant brukes til å skripte VirtualBox eller andre virtaliseringsplattformer som VMware og Docker. Med Vagrant kan du laste ned og starte en virtuell maskin med noen få enkle kommandoer:

$ mkdir vagrant_test
$ cd vagrant_test
$ vagrant init puppetlabs/centos-7.0-64-puppet
$ vagrant up

Første gang du kjører dette tar det litt tid siden Vagrant-boksen må lastes ned til maskinen din. En Vagrant-boks er et OS image for en provider, f eks VirtualBox, som er konfigurert til å fungere med Vagrant. Du kan lage dine egne bokser, men det enkleste er å finne bokser laget av andre. Denne siden har en katalog med bokser du fritt kan bruke.

Dersom alt har gått bra skal du nå ha en kjørende virtuell maskin med CentOS 7. Denne kan du logge inn på med ssh:

$ vagrant ssh

Du er nå logget inn som brukeren vagrant som har sudo-rettigheter. Katalogen fra vertsmaskinen finner du igjen som katalogen /vagrant.

Kommandoen vagrant init lager filen Vagrantfile som brukes til å konfigurere den virtuelle maskinen (gjestmaskinen). I Vagrantfile kan du konfigurere kataloger som skal deles mellom vert- og gjestmaskinen, mapping av porter, spesifisere hvor mye minne gjesten kan bruke, nettverk, og mye mer. Vi skal se på noe av det som kan konfigureres:

Konfigurere nettverk

Til bruk som utviklingsmiljø kan det være greit å tildele gjestmaskinen en statisk ip-adresse. Dette gjøres ved hjelp av denne i Vagrantfile:

config.vm.network "private_network", ip: "192.168.33.10"

I tillegg kan vi sette at port 80 på gjestmaskinen skal mappes til port 8080 på vertsmaskinen:

config.vm.network "forwarded_port", guest: 80, host: 8080

Så må maskinen restartes:

$ vagrant reload

Provisjonering

Vi kan nå prøve å aksessere port 80 på gjestemaskinen med URL http://localhost:8080, men der får vi lite respons siden ingen prosesser på gjestmaskinen lytter på port 80. Dette kan vi ordne ved å legge til provisjonering i Vagrantfile, enten ved hjelp av shell-kommandoer, eller ved hjelp av et system for konfigurasjonshåndtering som Puppet eller Chef. Vi kan begynne med shell-kommandoer. Legg til i Vagrantfile:

config.vm.provision "shell", inline: <<-SHELL
  sudo yum -y install httpd
  sudo systemctl start httpd.service
  sudo firewall-cmd --zone=public --add-service=http --permanent && firewall-cmd --reload
SHELL

For å kjøre provisjonering kan vi kjøre denne kommandoen:

$ vagrant provision

Etter dette kan vi prøve http://localhost:8080 igjen og skal da få opp Apache testside.

Provisjonering med Puppet

Provisjonering med Shell-kommandoer som brukt over er enkelt å komme i gang med. Men med Puppet blir det mye mer elegant. For å ta i bruk Puppet kan vi følge disse stegene:

Erstatte shell-provisjoneringen i Vagrantfile med dette:

config.vm.provision :puppet, run: "always" do |puppet|
  puppet.manifests_path = "provisioning/manifests"
  puppet.manifest_file = "development.pp"
end

Opprette katalogen provisioning/manifests:

$ mkdir -p provisioning/manifests

Og lage filen provisioning/manifests/development.pp med innhold:

node default {
  Exec {
   path => "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
  }
  package { "httpd":
   ensure => present
  }
  service { "httpd":
   ensure => running,
   enable => true,
   require => Package["httpd"]
  }
  exec { "firewall-config":
   command => "firewall-cmd --zone=public --add-service=http --permanent &&  firewall-cmd --reload"
  }
}

Deretter kan vi bygge gjestemaskinen på nytt:

$ vagrant destroy
$ vagrant up

Og Apache på http://localhost:8080 skal da være tilgjengelig som før.

Puppet moduler

På nettet finner du puppet-moduler for det aller meste, du kan søke hos Puppet Labs, eller bruke Google. Da kan det være du snubler over denne repositoryen jeg har på Github: https://github.com/bjornhjelle/solr-puppet.

La oss kopiere en modul derifra og bruke den til å installere Apache Solr:

$ mkdir provisioning/modules
$ cd ..
$ git clone https://github.com/bjornhjelle/solr-puppet.git
$ cp -r solr-puppet/provisioning/modules/solr vagrant_test/provisioning/modules/.
$ cp -r solr-puppet/solr_home vagrant_test/.
$ cp -r solr-puppet/sampledocs vagrant_test/.
$ cd vagrant_test

Så må vi legge til module_path i Vagrantfile:

config.vm.provision :puppet, :module_path => "provisioning/modules", run: "always" do |puppet|
  puppet.manifests_path = "provisioning/manifests"
  puppet.manifest_file = "development.pp"
end

Vi legger til solr-modulen i manifestet, installerer java, og lager en link til katalogen som er delt med vertsmaskinen:

file { "/home/vagrant/solr_home":
  ensure => link,
  target => '/vagrant/solr_home'
}
package { "java-1.7.0-openjdk":
  ensure => present
}
class { "solr":
  user => "vagrant",
  group => "vagrant",
  home_dir => "/home/vagrant",
  require => [File["/home/vagrant/solr_home"], Package["java-1.7.0-openjdk"]]
}

Og kjører provisjonering på nytt:

$ vagrant provision

Så legger vi til mapping av port 8983 i Vagrantfile:

config.vm.network "forwarded_port", guest: 8983, host: 8983

Deretter tar vi reload på maskinen:

$ vagrant reload

Etter dette skal vi kunne nå Solr admingrensesnitt på URL: http://localhost:8983/solr

For å se at Solr virker kan vi indeksere noen dokumenter:

$ cd sampledocs
$ ./post.sh manufacturers.xml hd.xml

Og vi kan utføre et søk ved å åpne denne URLen i en nettleser.

Oppsummering

Da håper jeg at du som har fulgt stegene i denne introduksjonen til virtuelle utviklingsmiljø ser nytteverdien av denne teknikken. Vagrantfile og provisioning-katalogen kan med fordel underlegges versjonskontroll sammen med resten av kildekoden du måtte ha i prosjektet ditt, og kan brukes i et oppsett for kontinuerlig leveranse (mer informasjon om dette her). Med kildekode på din egen maskin kan du bruke din favoritt editor samtidig som du er sikret å bruke samme versjon av kjøremiljøet som de andre i prosjektet. I tillegg utgjør manifestet og modulene du bruker nøyaktig og oppdatert dokumentasjon av alle installerte komponenter.

Vagrant skal også kunne brukes til å installere og provisjonere Docker-kontainere på tilsvarende måte som vi har gjort med VirtualBox og Puppet, men det får heller bli tema for et annet blogg-innlegg.

For å fjerne alle spor av den virtuelle maskinen kan du gjøre dette:

$ vagrant destroy
$ rm ~/.vagrant.d/boxes/puppetlabs-VAGRANTSLASH-centos-7.0-64-puppet

Hjelle, Bjørn

Hjelle, Bjørn

Konsulent // Application Lifecycle Management
bjorn.hjelle@acando.no
comments powered by Disqus