I just released the initial version of PuPHPet, my GUI-based gnerator for Vagrant/Puppet environments! [...] Enter PuPHPet, my GUI configurator. I have created a simple, easy to use web app that targets PHP developers and the classic LAMP stack. You will not need to learn the ins and outs of Vagrant or Puppet to build your own working VM to your specific needs. As of now you can define things like custom virtual hosts, what version of PHP to install, set up some MySQL databases, etc, all without having to touch a manifest file.

His tool (hosted version is here) lets you define things like machine name, IP address, memory and target folder. You can pick from various server, PHP, MySQL and Apache packages you want installed as well. A custom archive (zip) file will be created that can be dropped into your system ready for use.

I have been using a Linux install for a couple years now and it has development checkouts (and matching databases + live data) for dozens of sites. Since I create a new virtual host for each site there hasn't been any problems piling more and more projects into this system. However, this computer won't last forever. [...] Should I setup a new VM + debian install for each project (seems like a lot of work). Should I just move everything to an external drive and point the MySQL data, MongoDB data, Nginx web folders to the attached drive? How do others handle this?

There's several suggestions made in the comments including things like:

• Using Ansible for configuration management
• Bundling the current linux install into one portable VM
• Using Vagrant for VM management
• Using source control that can be accessed from any device/VM

Have a VM management method you've found useful in your development? Share some about it here.

Creating a staging environment is specific to your production environment. There is no magic solution that works in every situation. But most cases follow a similar pattern, and I'll cover all the key points as we go along. It's fair to assume that most people deploy their apps with some kind of versioning tool (like GIT). [...] Besides GIT, you have to think about the languages, software, and "special" features your production servers offer.

All of the commands and configuration files you'll need to make the automatic setup work are included in the article. It's based on a Debian (Squeeze) base image and uses packages to install the needed software. They also install other PHP extensions like mycrypt, GD, curl, APC and database support (MySQL, SQLite and Postgres). They help you get Apache set up to serve the application and work with git and its hooks to push the code and run Composer.

Now-a-days, you have frameworks that need to be setup [as a part of your environment], include paths that need to be changed, modules that need to be installed, web servers that need to be configured for your routing, etc. Then you might not just have MySQL, but Redis, Mongo, Couch, Memcached, Postgres, or any other dozen other servers. Then in Production you might have load balancers, multiple web servers, clusters of databases, and the list goes on. Simply put: web development environments are complex.

He introduces Vagrant and talks a bit about how it helped them with the setup and configuration of two new remote developers they had limited contact with. After some initial quirks, Vagrant made it simple for them to get up and running with new environments in a day.

I was a little scared when it came to setting up Selenium, I figured it was going to be difficult to setup and configure. So I was pleasantly surprised when it really wasn't. So here are a few of the mistakes I made; since I use Vagrant to do all my development I actually grabbed Selenium and started from there. Not a good place to start, although as I found out later; not a total dead end.

He includes the initial setup of things like PHPUnit and the Selenium .jar file as well as a sample test that loads a page and checks the title of the page. His second post shows how to set it up in the VM (using Vagrant, xvfb to capture the output and Firefox to execute the tests).

Together with other tools, setting up a complete development environment with just a single command is not only reality, but it's becoming for a lot of developers a daily practice. But even for open source projects like joind.in and protalk.me are seeing the benefits of having "development environment on the fly". New contributors don't have to spend a lot of time setting up their environment, but it's automatically generated: the code setup, the database server together with a filled set of data, any additional components like varnish, memcache, reddis etc. This blog post gives an overview on how to setup a symfony2 project with the help of vagrant and puppet.

He provides you with some examples in the form of a Vagrantfile that sets up a 64 bit CentOS instance and configures the server with a few settings and points it to a Puppet configuration. He includes a basic set of Puppet configuration examples and shows how to use it to install various packages, set up MySQL, load phpMyAdmin, configure PHP and, finally, bootstrap the Symfony2 by seeding a Doctrine schema.

I've been hearing great things about puppet, chef, vagrant, and friends for a while now, but since I work on my own I tend to either develop straight onto my ubuntu machine or grab an appropriate existing VM and use that. So I read about this brave new world of virtualisation but (as with most tools) they can be hard to introduce on your own, and I didn't. [...] Then I went to WhiskyWeb, which had a hackathon [...] with the shiny new technology all packaged for me, I decided it was time to take a look!

She shows you how to get the VM started up using vagrant, pausing the instance and removing it all together (destroy). She also includes the command to directly access the VM via ssh and links to the joind.in project with its sample puppet configuration and Vagrant file.

Vagrant is a fantastic tool that enables you to manage and run virtual machines from the command line, including automatic provisioning of them using puppet or chef. The really cool thing about it however from my point of view is that vagrant automatically sets up the VM with a folder called /vagrant that holds the code on your local hard drive from where you started the VM. This means that you can continue to edit your code in your local editor/IDE and test it within the VM easily

Inspired by similar work on the joind.in project, he's created the instructions to make a Vagrantfile that, using VirtualBox and this puppet configuration, sets up and configures a VM you can ssh into and execute your tests.

I like the idea of using Vagrant to create virtual machines for my development work. Doing things this way I think keeps the host machine cleaner and allows you the ability to distribute those VM's to other people as well. My old boss Ben Ramsey did a very informative post on getting PHP 5.4 configured on CentOS so I decided to one-up him by taking his instructions and creating a Puppet manifest so you could do this using Vagrant or on any server that you can provision using Puppet.

He example is based off of the publiclly available Vagrant setup and provides the contents of the Vagrantfile that he uses to set up the machine. From there, Puppet takes over and uses his configuration (also included) to set up things like the Apache server, some configurations for it, a list of PHP extensions and, of course, PHP itself.

In case you've been living under a rock for the past couple of years, Vagrant is the latest development in easily controlled virtualised environments. [...] Vagrant automates creation and provisioning of virtual machines within VirtualBox via the command line, whilst also allowing for easy distribution and reuse across multiple projects. In this article, I'm going to look at how it can make life considerably easier when dealing with development environments.

Included in the post is just about everything you'll need to get started using this powerful tool:

• A link to Vagrant images
• A guide to the VagrantFile
• the Provisioning process
• Interacting/Controllig the Vagrant VMs

He also includes a basic setup of an environment (with the Vagrant config to create it) and an example of using Puppet to provision the Vagrant VMs.