Even though you can’t always avoid the problem, you CERTAINLY can try to minimize the potential damage that you can do.

Download the RPM Forge Repository Package

wget http://pkgs.repoforge.org/rpmforge-release/rpmforge-release-0.5.2-1.el6.rf.x86_64.rpm

Install the RPM Forge Repository

rpm -ivh rpmforge-release-0.5.2-1.el6.rf.x86_64.rpm

You’ll get a warning, but it will proceed based on the flags that you set.

warning: rpmforge-release-0.5.2-1.el6.rf.x86_64.rpm : Header V3 DSA/SHA1 Signature, key ID 6b8d79e6: NOKEY
Preparing... ########################################### [100%]
1:rpmforge-release ########################################### [100%]

Set YUM priorities

Now you need to edit /etc/yum.repos.d/CentOS-Base.repo and add these priorities to the bottoms of each of the following repo sections:

[base]
priority=1

[extras]
priority=1

Save your changes on this file and edit the rpmforge.repo file. You’ll only need to edit the one repository section.

[rpmforge]
priority=5

Save your changes and you’re finished.

Setting this repo to a higher priority ensures that this repo is only used if the other repos don’t have what you’re looking for. Like Pure-FTPd. The above assumes you’re using 64bit Centos 6. if you’re using 32bit today stop and ask yourself why. Then, use the link and substitute the 32 bit links instead.

Install a test package

In this case we don’t see Pure-FTPd in the stock CentOS repos. let’s update yum and then install PureFTPd.

yum update
yum install pure-ftpd

viola! you should see the package install now and you’re pulling this from the newly install RPM Forge repository.

What is SparkleShare?

From the sparkleshare website: “SparkleShare is a collaboration and sharing tool that is designed to keep things simple and to stay out of your way.” Feature wise, it acts very similarly to dropbox, but provides some additional functionality. It leverages a Git repository on the back end, and is extremely flexible.

My only concern with it, or any hosted data story, is ensuring that my data is always available and more importantly, that it doesn’t corrupt over time. That’s why I’m using illumian.

What is Illumian?

illumian was started by Nexenta to create an illumos distribution with Debian style package management tools for familiarity and compatibility with existing tools. This distribution uses the same versions of externally maintained packages as the OpenIndiana project uses today. Where NCP was based on OpenSolaris and some interesting ways to get debian packages ported, illumian is a based on the work in the continued new work in the illumos project. The recent 1.0 release contains only a small number of maintained packages and a simple command line installer. No GUI required.

Download illumian

you can download the illumian iso from illumian.org

Base VM configuration

On the road and working in a hotel, I’m using VMware workstation for this installation and have assigned the following items to the VM:

• 2 8G disks for the syspool (OS install disks)
• 2 16G disks for data (I’ll mirror these as well)
• 2G of RAM
• 1 vCPU

Install Illumian

Boot from your illumian ISO and start the install process.

select language, keyboard and timezone.

You’ll be prompted to select the installation drives, very similar to a Nexenta installation, I’ve selected the two 8G drives as shown below.

disk layout

It will ask if you would like to add an additional drive as a hot spare. I selected no.
Next it will prompt you to make sure you want to erase all the data on the drives, select yes.

Once the installation is complete, it will prompt you to enter the root password for the system.

Enter the password twice you want to use and select next.

Create a user account.

enter the password twice for the new user, and select next.
Commit the changes for the new user.

Enter the hostname for the new system, select next, and commit the changes for the hostname.

The next step is configuring the network adapter. Illumian (and Nexenta) allow for some pretty serious network configurations out of the box, but for this one we’re going to just use dhcp for getting up and running. We can go back and change it as needed later.

You should be presented for the network interface that you’ve assigned or is installed in your system. Select Yes to configure it.

When prompted if you want to enable DHCP, select yes.
When prompted if you want to enable ipv6 I selected no.
Select yes that you’re done configuring the device and the installation will proceed.

With the installation completed, disconnect your cdrom and reboot into your new illumian installation.

Like ubuntu, the first user created has sudo privileges. First thing after logging in as your user you’ll want to do is update the system.

sudo apt-get update

Once that’s complete, we can install git

sudo apt-get install git

Before we actually get started with sparkleshare we want to create a new mirrored zpool with the additional 16G drives we added to the VM. With illumian, (and Nexenta) we can grow this zpool as needed when we need additional space. I don’t expect to need more than 16G to start, but I want to keep my options open.

First let’s get a look at what the installer did:
zpool status

with that listed we can see what drives are being used by the syspool.

The easiest way to get a drive list is via format.
sudo format

This shows us the initial two 8G drives that we saw in the initial zpool as well as the additional two drives that aren’t currently in use.
press:
ctrl+c
to exit format.

Now we’ll create our new zpool for the sparkleshare repository.

sudo zpool create sparkle mirror c1t2d0 c1t3d0

another:

zpool status

should show us our new zpool:

One thing to remember if you’re new to illumian or ZFS in general, when you create a zpool there is automatically a zfs filesystem created on it. The mountpoint defaults to the poolname. So my pool “sparkle” is mounted as a zfs filesystem at /sparkle by default.

Now we can configure illumian for hosting the sparkleshare repository.

Create our user
sudo useradd git
Set the password for the user as a value that cannot be used for login, but does not lock the account.
sudo passwd -N git
Create our project folder
sudo mkdir /sparkle/git
Change the permissions on the project folder
sudo chown -R git.staff /sparkle/git
cd /sparkle/git
create the project
sudo git init ––bare MyProject
create and change dir to the users home directory
sudo mdkir /home/git
cd /home/git
create the ssh folder
sudo mkdir .ssh
create the authorized keys file
sudo touch .ssh/authorized_keys
set the permissions on git’s home directory
sudo chown -R git.staff /home/git

On the Client System
Install sparkleshare for you OS, I’m going to be testing with the new Windows client. Head over to sparkleshare.org and download the windows client.

Start the installer.

It’s a simple accept the license next, next, install, finish affair.

Start SparkleShare and enter your name and email address.

Continue through the installer to finish the installation.

Once done, you’ll see a SparkleShare icon in your taskbar.

Right click on it and open your SparkleShare folder.

During the install SparkleShare will have created a key for you to use. This key will be in your SparkleShare directory. Copy the contents of the key file.

Back on the Server

Open up the .ssh/authorized_keys file we created earlier in a text editor and paste the key that you previously copied at The client side step on a new line at the end of the file. This gives the client access to the git repository.

Now lock down the ssh directory and the authorized key file.

sudo chmod 700 .ssh
sudo chmod 600 .ssh/authorized_keys
sudo chown -R git.staff .

Add a project to the client

With that done, move or delete the key in the sparkleshare directory. Notice that before moving (or deleting) this file, the option to “Add Hosted Project” is grayed out. The key file needs to be moved or deleted before you are allowed to add a project.

Right click on the sparkleshare folder and select “Add Hosted Project”

In the Setup screen, select “On my own Server” and enter the address and remote path you created for the project.

Select Add and when complete, Finish!

You’re up and running!

From here you can add files to your project folder and it will sync the data with the server automatically.

If you want to give more people access to your project, just paste their keys on a new line at the end of the authorized_keys file. Don’t share your client key, append it. This will allow you to add a lot of users based on the project as needed.

On top of this you can add multiple projects and servers to sync to. This opens up a range of ideas, from projects down to the team level, to organization wide distribution.

On top of this you get all the benefits of ZFS at the file system layer managing your data.

Let me know if you have any questions, or if this works for you. SparkleShare is a great looking project and when you add in the data security that ZFS provides it makes a pretty solid combination.

When you’re ready, continue on to part two.

Why Nexenta is different

If you’re coming from the standard storage arena, it’s hard to put a bead on Nexenta. First off, it’s just software. But more than that, at it’s core is open source software. Think of it as a gobstopper with three layers. At it’s core it’s based off of illumos and ZFS. Added on top is NexentaOS, a ubuntu userland that makes software management easy. If you’re ever tried Ubuntu, you know that it’s pretty simple to install updates. The third and outermost layer to Nexenta are the additional modules that add additional enterprise functionality to the storage appliance.

What is illumos

The illumos project started as a binary compatible distribution of OpenSolaris, the comunity supported distribution of Solaris.  Years ago, for me anyway, it was the most cost effective way to learn Solaris.  The intent was to create a straight fork that would stay compatible with any possible future releases that Oracle makes to the community.  It turned out this was a pretty wise move.  The OpenSolaris project within Sun didn’t adjust well to the transition [1].  Now illumos stands at the center of a new OS community, with a SOLID enterprise class foundation.  Many of the folks that were contributing/creating to the solaris codebase continue to contribute to illumos, and it will continue to be an interesting project to watch.

What is ZFS

In short, ZFS is an enterprise grade file system. It was designed by Sun to be a modern filesystem to handle modern hardware. To understand why ZFS is important you also need to understand how modern harddrives work:

A modern hard disk devotes a large portion of its capacity to error detection data. Many errors occur during normal usage, but are corrected by the disk’s internal software, and thus are not visible to the host software. A tiny fraction of errors are not corrected. For example, a modern Enterprise SAS disk specification estimates this fraction to be one uncorrected error in every 1016 bits, or approximately one in every 1.2 PB.[19] A smaller fraction of errors are not even detected by the disk firmware or the host operating system. This is known as “silent corruption”. In a recent study, CERN found this issue to be problematic.

As hard drives get bigger, we’re all seeing data corruption become more of an issue. The changes of corruption, both noticed and silent, increase. In vmware envionments silent data corruption can ruin your day. I’m actually not sure how common it is, but in a service provider environment I worked at we had VMs that would not let us do anything with the vmdk. It seemed “stuck”. We couldn’t storage vmotion it, and it would continually give us grief. After troubleshooting for couple days, the only thing we could do was clone it and delete the original VM. That’s worked fine, but it could have been a lot worse. As storage envionments get bigger, silent data corruption will eventually happen in your environment unless you protect against it.

ZFS checksums every block that is written and automatically repairs blocks where corruption occurs. This provides end to end data integrity allowing you to be confident there won’t be a problem with the data when you need it.

Beyond this feature, ZFS allows for heterogeneous block and file replication, UNLIMITED snapshots and clones, compression, deduplication, non-disruptive volume increases and a host of other features. I’ll work through (and link to from here) these features in the future, but it’s important to get some other base functions explained.

What is the ARC

As legacy storage vendors will tell you; Cache is king.  The ability to cache data efficiently or “move blocks” or “other fancy caching name here” basically does one thing.  It moves data that is most accessed to a faster tier, or more responsive, layer.  ZFS leverages the ARC as it’s front line cache for most accessed blocks.  This means if your Nexenta appliance has 24G of RAM, it’s going to get 23 or so gigs to use to cache the most heavily used blocks.  As RAM is added, the ARC cache grows.  RAM being A LOT faster than SSD’s this proves invaluable for providing FAST response times and lower latency to the client devices.

What is the L2ARC

Below the ARC ZFS can leverage additional cache devices, in most configurations today this is SSD drives.  Cheaper than RAM, but still way faster than spinning tin.  This is the 2nd level of cache that Nexenta appliances use for caching “warm” data.  This hybrid storage model allows for Nexenta to use slow SLOOOOOWWWW disks for it’s main storage pool of the working size set (average amount of blocks that are constantly active) fit inside both the L2ARC and ARC cache.

What is the ZIL

The ZIL (ZFS intent Log) is the write cache.  Random R/W is the bane of every VMware administrators life.  Not only does Nexenta leverage a read cache, we can cache writes to more efficiently lay down blocks on the slow disks to better handle write workloads.

How does all of this tie together?

For our lab environment, if you can move the L2ARC and the ZIL to an SSD drive, you’ll already start being able to use some of the performance gains that Nexenta brings to the table. Even in a two drive configuration, if one of them is SSD, and there is plenty of Ram available, Nexenta can start helping increase performance through it’s caching technology.  But that’s not it, Nexenta brings to the table a host of other features.

1. Nexenta provides a software stack that can deliver NAS (NFS/CIFS) and/or SAN (iSCSI/FC)
   storage that allows for high performance allowing users to leverage current commodity technologies (ex SSD for performance).
2. It provides UNLIMITED snapshots and clones
3. It can be configured in a fully active/active HA configuration.
4. It provides block and file level replication that can be leveraged for easy DR configurations either in a syncronous or asynchronous configuration.
5. It’s vmware certified
6. It provides compession, dedupe and inline virus scanning. (not post process!)
7. metro clustering
8. global namespace
9. (this goes on and on)

[1] The opensolaris project wasn’t alone. Oracle’s purchase of Sun resulted in the forking of LibreOffice from OpenOffice.org, and MariaDB from MySQL. Bryan Cantrill’s talk at LISA  this year pretty much sums up oracle in a nutshell.

Outside the office I had the opportunities to get involved elsewhere as well. VMworld this year was awesome and I’m still watching presentations I didn’t watch live. VMunderground this year was pretty amazing. We had our biggest event ever. As always we had great sponsors and we were really impressed with the support and turnout from the community. I was invited to attend TechFieldDay6 but due to an unruly internal organ, attended TechFieldDay7 instead. Stephen Foskett runs a great event, and I was honored to be invited.

Locally, and against better judgement, I was voted in as president for my local LUG, and even though I didn’t have any intentions of running, I’m looking forward to it nonetheless. I’m also excited that we may be able to start more coordinated and focused efforts with the Iowa Ubuntu LoCo, as I’m moving into a more active role there as well.

One of the more interesting things I’ve done this year was take some time to attend the Open Storage Summit in San Jose. Great week, great presentations, and I took away a ton of information. Maybe more importantly, I took away the knowledge that these guys (and gals) are really building something different, something open, and something with community at the forefront. The team around illumos is really focused on making a difference. Nexenta has been a big supporter of VMUGs around the globe, and of course VMunderground as well.

The storage market has got to be a tough nut to crack. Buying your storage from a software company is something new in the minds of many companies and IT management, but it isn’t a new idea. Most of us in the industry today are completely ok with buying our compute and OS resource management from a software company. VMware has effectively moved the cheese for many MANY hardware companies. I don’t need to buy “windows specific” or linux optimized” hardware. Solid hardware that supports VMware is enough. This change isn’t done yet. I think Stephen Foskett’s assessment of VMware as Oedipus has legs. This doesn’t mean that traditional storage vendors are going to toss in the towel, there is significant innovation going on industry wide and they’ve got huge war chests to spend. It just means, like always, things are changing. This is a really exciting time to be involved in technology.

With the adaption of vmware’s VSA it’s important to realize, now more than ever, you don’t have to wrap mostly expensive tin around your software anywhere, anymore. You can leverage commodity hardware. You can build what you need, when you need it.

Which brings me back to the beginning of this tirade. New projects and new challenges. At this point it should be pretty evident where I’m placing my chips. It was a tough decision but I’ve decided to leave LightEdge and jump feet first into the open storage arena. I’ll be starting soon with Nexenta helping get open storage based solutions deployed to customers around the globe. Lightedge has been a great company to work for and I wish them the best of luck as they move forward.

In charting a new course I’m looking forward to new and exciting challenges. Wish me luck!

• it’s wildly successful

to me this means lots of updates and support for packages both from the vendor (canonical) as well as the community.

• support available from ONE install

What other distribution has one install for the community AND commercial support? Yea. I can’t think of one either. This allows users to choose how much support they want/need from one virtual appliance/installation.

• small minimal virtual machine footprint

The ovf will fit neatly on a 512M usb drive when complete.

why another virtual appliance tutorial?

I know that building virtual appliances is old hat for many of you, but I keep getting the question about how to build virtual appliances for distribution. In a recent scenario at my work, they were looking for a splunk virtual appliance that members of the consulting group could quickly leave on site. I thought this would be a good walkthrough. Let me know if you have any questions.

let’s get started!

First things first we need to download a copy of ubuntu server. Once you’ve got your iso downloaded, go ahead and build out the base VM that you’re going to use. For these types of deployments, I go ahead and configure the appliance inside a vApp as we are starting to deploy more of these on vCloud deployments.

build your vApp and VM

• In vSphere, right click on your cluster or host and select New vApp.
• Name your vApp, select next.
• If you need/want to isolate resources specifically for this vApp you can do so on the Resource Allocation screen. I’ll go ahead and reserve 1G of Memory cause I’m greedy like that. Select next.
• Select Finish and find your vApp in the VM list.
  Now we need to add the VM to the vApp.
• Right click on the vApp and select New Virtual Machine.
• Name your virtual machine and select Next (this demo will be for spunk so I’ll use the ever so cunning name splunk. Select Next.
• select which datastore you want this VM to temporarily live, select next.
• select the Guest Operating System for this VM, in this case, select the Linux radio button, and select Ubuntu Linux (64-bit) in the Version dropdown window. Select Next. (you did download the 64bit version right?!)
• Set the size of your virtual appliance, I’ll crank this down to 10G, as the splunk data directories will be remote NFS mounted in most cases. I’m a huge fan of thin provisioning. check it if it’s appropriate for your workload. select Next.
• Select Finish.
  

  install ubuntu

  mount the iso to your vm, and start ‘er up. Once you’ve selected your language, on the initial install screen…

• select f4

• select Install a minimal virtual machine [1]

• select enter (this takes you back to the main screen)
• select Install Ubuntu Server (should be checked by default) Select Next
• select your language again (don’t ask) Hit Enter
• select your location. hit Enter
• select No for keyboard layout
• select your Keyboard language (English (US) is default)
• select your Keyboard layout (English (US) is default)
• The system will load additional components as needed
• Network configuration. I SERIOUSLY recommend DHCP for just about everything. It’s 2011 folks, DNS and DHCP works.
• give your appliance a hostname (splunkappliance in my case) Select next.
• it’ll start up the clock and check your time zone. change it if needed or select Yes.
• For partitioning, I select Guided – use entire disk and set up LVM to make it easier to expand the install as needed down the road if required. Select this and hit enter
• default vm will have one disk listed, select it and hit enter.
• Select Yes to write the changes to disk, and hit enter
• If using LVM you’ll be prompted with the maximum amount of space in the volume group. Select Continue and hit enter.
• Select Yes to write the changes to disk and hit enter
• Enter your default full username, select continue.
• Enter your default user name, select continue.
• Enter your default password, select continue.
• You’ll be prompted with “How do you want to manage upgrades on this system?” I select install security updates automatically so I don’t have to worry about being blamed for something that is WAY outside my control 6 months from now. It’ll still happen, but I’ll sleep easier. Select which of the first two you want, and hit enter.
• Choose software to install. The only thing I select here is OpenSSH server. that’s it. select it and select continue.
• This will start the package install, and it should go relatively fast
• select Yes to install the GRUB boot loader to the master boot record.
• Select Continue to finish your installation
• unmount the iso from vSphere client
• The above will install a really base system for your virtual appliance. I go ahead and install openssh-server on the vm so that it doesn’t need unproxied internet access during it’s first boot to get it installed. As I’m regenerating the ssh keys anyway, I don’t worry about it too much. This VM should boot REALLY really fast.
  

  /etc/issue

  /etc/issue.net is the file that handles what is displayed before a user logs in. like this:
  

  that’s pretty boring right? what we want for our appliance is to have something awesome like this:

  

  To get this we’ll need to do a couple of things. we’ll want to create a new script that is run at bootup every time. This will generate the /etc/issue.net for us after we get our ip address. Here’s the contents of a generic one I used for this demo. Adjust as needed.

  
  #! /bin/bash
  #
  # issue-reset set ipaddr in /etc/issue
  #
  # chkconfig: 2345 90 60
  # description: this will echo the ip address to /etc/issue for display
  #
  # Source function library.
  #. /etc/init.d/functions
  RETVAL=0
  #
  # See how we were called.
  #
  prog=”issue-reset”
  start() {
  #
  #change /etc/issue to display ip address
  #
  echo “AWESOMETACULAR Splunk Appliance” > /etc/issue
  echo “Powered by Ubuntu Linux and caffeine” >> /etc/issue
  echo ” ” >> /etc/issue
  netcount=$(/sbin/ifconfig | grep -o “inet”)
  if [[ $netcount > 1 ]]
  then
  echo “To manage this virtual appliance please use a web ” >> /etc/issue
  echo “browser on a different system and navigate to ” >> /etc/issue
  echo ” ” >> /etc/issue
  /sbin/ifconfig | grep “inet addr” | grep -v “127.0.0.1″ | awk ‘{ print $2 }’ | awk -F: ‘{ print “http://”$2″:8000″ }’>> /etc/issue
  echo ” ” >> /etc/issue
  else
  echo “This appliance does not have networking configured. Please log in to configure networking” >> /etc/issue
  fi
  echo ” ” >> /etc/issue
  cp /etc/issue /etc/issue.net
  # RETVAL=$?
  echo
  [ $RETVAL -eq 0 ]
  return $RETVAL
  }
  case “$1″ in
  start)
  start
  ;;
  *)
  echo $”Usage: $0 {start}”
  exit 1
  esac

  exit $?
  

  Once you’ve downloaded this, we’re going to move it to the /etc/init.d directory and rename it banner:
  mv ./banner.txt /etc/init.d/banner
  change the owner to root, and make it executable.
  sudo chmod +x /etc/init.d/banner && sudo chown root.root /etc/init.d banner
  add /etc/init.d/banner to be run at startup:
  sudo update-rc.d banner defaults

  that’s it! You’ll want to edit that file to make it reflect what you want it to say, but it’s pretty self explanatory.

  firstboot startup script

  There are a couple of ways to handle first boot only startup scripts. The easiest way I’ve found is to edit the rc.local file to run a script, and when complete, clean up after itself. Here’s what my firstboot script looks like:

  
  #This script is run the first time a user logs in
  echo “Your Splunk appliance is almost finished being deployed”

  INSTALL=”apt-get install -y”
  REMOVE=”apt-get remove -y”
  SPLUNK_HOME=”/opt/splunk”
  apt-get update

  # email
  $INSTALL exim4-daemon-heavy

  # expire the user account passwd
  passwd -e defaultuser

  # new ssh key generation
  rm /etc/ssh/ssh_host*key*
  dpkg-reconfigure -f noninteractive -p critical openssh-server

  # splunk
  dpkg -i /root/splunk-4.2.4-110225-linux-2.6-amd64.deb

  #start splunk server for the first time
  $SPLUNK_HOME/bin/splunk start –accept-license

  #configure splunk to autostart at boot
  $SPLUNK_HOME/bin/splunk enable boot-start

  # clean up
  sed -i ‘s_/root/firstboot.sh_exit 0_’ /etc/rc.local

  echo “firstboot complete”
  

  You’ll want create a file with that as the content, save it, and put it somewhere where it can be run during boot. For ease of this demo, we’re going to put it in our home folder. Don’t Judge, this is just a demo.

  sudo mv ./firstboot.txt /root/firstboot.sh && sudo chmod +x /root/firstboot.sh && sudo chown root.root /root/firstboot.sh

  Now we’re going to setup this script to be run during first boot. using whatever editor you want edit /etc/rc.local and remove the exit 0 line and substitute it with the following line:

  /root/firstboot.sh

  Let’s walk through firstboot.sh and take a look at what we’re doing. In our example, we’re creating a splunk virtual appliance, so from the top:

• we’re updating our repositories
• we’re installing an MTA for splunk to use.
• we’re expiring the password for our default user account. Change this to reflect whatever username you selected.
• we’re deleting and regenerating ssh keys
• we’re installing splunk. For this example, you’ll need to get the splunk .deb package downloaded and put somewhere accessible. It’s free, go grab it now.
• Now we’re going to do some startup specific commands for splunk, first we’re going to set splunk to start for the first time and accept the license.
• Next we’re going to go ahead and configure splunk to start every time the server starts.
• after that’s complete, we’re going to clean up /etc/rc.local to not run this script again.That’s it for our startup script. pretty straightforward.
  

  Test your appliance

• power off the VM and create a snapshot.
• Power the vm on and test the startup, the install of our splunk package, and the firstboot configuration steps.
• If everything works, go ahead and roll back our changes and create your ovf below
• if it doesn’t power back on and dig in
  

  add some info to your appliance

  If you’re planning on posting updates to this, or you want to provide the default username and password information directly in the ovf file, you’ll want to edit some of the details of your vApp.

• Right-click on your vApp and select Edit Settings.
• On the options tab, select Advanced.
• Enter your appliance name, website, and any other information that you want to provide.

• export to ovf

• From the vSphere client, select the vApp, and in the File menu select Export, Export OVF Template.
• pick a directory where you can store your appliance
• export!

• test appliance

  one last test of your appliance and you’re ready for deployments. This last check for me usually provides a sanity check for the finished appliance. to deploy from vSphere client just:

• select file
• deploy OVF template
• browse to the directory and select the OVF file
• the only thing you should have to do other than picking a datastore, is selecting a network
• Go get a cup of coffee while the deployment occurs
• done!

• conclusion

  This walkthrough for a splunk appliance is pretty simple but if done correctly virtual appliances deployments can shave hours off of simple traditional application installations for your team. Getting more advanced versions of this, you could get fancy and add additional layers like puppet autoconfigs to further automate package deployments. Let me know what you think and if this worked for you!

  [1] this is what used to be the ubuntu JeOS install.