Bigbang is a tool to create clusters using Amazon EC2 in a scriptable way. You create a descriptor file (called universe file) which describes your whole cluster and then you can launch it on EC2 with a single command. Bigbang allows you to use the same “universe” file to create multiple “universes”, say for example a live, a QA and staging clusters. You can even use it to automate the creation of a cluster for performance testing purposes.

BigBang can do the following:

• startup ec2 instances

• allocate and assign elastic ip’s to instances

• assign instances to load balancer

• create DNS record entries (Amazon and Zerigo supported).

• shutdown your whole cluster

As stated before, all you have to do is create a “universe.rb” file which describes your cluster. You then run “bigbang explode <cluster-name>” and it will “explode your universe” :).

$> gem install bigbang

Bigbang uses a “git-based” bootstraper. What it means it that you configure a git repo which contains a “run” script. Bigbang will make sure this repo is cloned inside your ec2 instance and executed. What this script does is up to you. It can then for example install and setup puppet or chef which will continue the provisioning of the instance.

Consider the following universe file:

BigBang::DSL::Universe.new do
   config do |c|
      c.access_key_id = "YOUR-AMAZON-ACCESS_KEY"
      c.secret_key = "YOUR-AMAZON-SECRET_KEY"

      c.dns :provider => 'Zerigo', 
         :zerigo_email => "example@example.com",
         :zerigo_token => 'xxxxxxxxxxxxx'

      c.domain = "example.com"
   end

   # describe your instance
   instance "ubuntu" do |i|
      i.ami = "ami-e2af508b"
      i.key_name = "dev"
      i.type = "m1.small"
      i.bootstrap_repo = "git://github.com/giorgenes/ec2-chef-bootstrap.git"
   end

   # run a single instance
   run_single_instance("ubuntu") do |r|
        r.domain = ["db"]
        r.wildcard_domain = true
        r.elastic_ip = true
   end

   # runs a cluster of db instances
   run_cluster("ubuntu") do |r|
      r.domain = ["app"]
      availability_zone "us-east-1a" => 1
      availability_zone "us-east-1b" => 1
      r.load_balancer("app") do |lb|
         lb.domains = ["app"]
         lb.listeners = [
            { :protocol => 'http', :load_balancer_port => 80, :instance_port => 80 }
         ]
         lb.availability_zones = ["us-east-1a", "us-east-1b"]
      end
   end
end

In this example we have a single instance of “ubuntu” AND a cluster of “ubuntu”. So if you run for example “bigbang explode live” it will do the following:

• For the single instance:

  • create an ec2 instance with type “m1.small” and ami and key as stated.

  • allocate an elastic ip and associate with the intance.

  • clone the specified repo inside the box and run it (in this example, it will install chef).

  • create DNS records pointing to the instance: live.db.example.com

  • it will also create wildcard DNS records: *.live.db.example.com

• For the cluster

  • create 2 ec2 instances on the specified availability zones.

  • clone the repo in the boxes and install chef

  • create DNS records to the boxes: live.app0.example.com and live.app1.example.com

  • create a load balancer called “app” for the http protocol mapping ports 80 to 80.

  • assign the cluster instances to the created load balancer

  • create a CNAME record for the load balancer: live.app.example.com

• creates a universe called <universe-name>

  bigbang explode <universe-name>

• list universes

  bigbang list
  

• kill a universe

  bigbang kill <universe-name>

• test configuration

  bigbang test
  

This gem is still in very early development stage.