BitNami's Blog

BitNami Makes it Easy to Test Rails 3 beta

2010-02-11T18:22:01+00:00

Now that the beta release of Ruby on Rails 3 is available, we wanted to make it easy for you to check out all of the improvements that have been made. We just released a new version of BitNami RubyStack that allows you to install a complete, ready-to-run Rails 3 environment in just a few clicks. If you choose to install the stack natively, you will be asked if you want to install the Rails 3 gems or not. If you opt out, you will have a stable release of Rails installed and completely configured.

As with all BitNami Stacks, RubyStack is completely self-contained and relocatable. This means that you can install the Rails 3 beta stack alongside your existing Rails installation without interfering with it, so you can work with older versions of Rails at the same time you are testing the latest release. A bundled uninstaller makes it easy to remove the complete Rails 3 beta environment when you no longer need it.

In addition to a native installer, BitNami RubyStack is also available as a virtual appliance and an Amazon Machine Image (AMI), so you can deploy it in a virtual environment or to the Amazon EC2 cloud.

If you haven’t been following the development of Rails 3, a number of ideas from the Merb framework and other improvements have been added to the product. Rails 3 features include new Bundler functionality which makes it easier to specify and include gems with Rails applications, a new router with an emphasis on RESTful declarations, a new Active Record chainable query language, a new Action Mailer API and JavaScript helpers with drivers for Prototype and jQuery. Rails 3 resources and tutorials are available at Rails3Info.com if you would like to learn more.

rails3info.com launched !

2010-02-05T16:24:06+00:00

Visit rails3info.com and find out all you need to know about the new Ruby on Rails 3! Tutorials, presentations and articles in one convenient place…. more

The easiest way to test Rails 3

2010-02-05T16:25:28+00:00

Rails 3 Beta has been just released and it comes with plenty of new features. You can try this new version using BitNami RubyStack easily. With RubyStack, you can keep separated, self-contained environments that you can create or remove with ease, so you can test Rails 3 without disrupting your current development setup. RubyStack is available as native installers, virtual appliances or cloud images.

For Windows users:

Start the “Use BitNami RubyStack” console from the Windows shortcuts. It is necessary to start it as Administrator user.

Type the following in the command prompt:

> gem install tzinfo builder memcache-client rack rack-test rack-mount erubis mail text-format thor bundler i18n --no-ri --no-rdoc
> gem install rails --pre

That’s all. Once all gem are installed you can create and test your Rails 3 application:
```
> rails demo
> cd demo
> ruby script/rails server
```
You can go to your favorite browser at http//127.0.0.1:3000 to visit the default Rails 3 application.

For Linux and OS X users:

Start the “rubyconsole” in your installation directory. You can double-click in the console icon or launch it from a Terminal:
```
$ cd <rubystack_installation_directory>
$ ./rubyconsole 
```
Install the required gems and the rails 3 Beta gem:

$ gem install tzinfo builder memcache-client rack rack-test rack-mount erubis mail text-format thor bundler i18n --no-ri --no-rdoc
$ gem install rails --pre

Once all gem are installed you can create and test your Rails 3 application using MySQL database:
```
$ cd projects
$ rails demo -d mysql
```
It is necessary to configure the database. You can copy the same configuration from the previous demo application.
```
$ cp rubystack/config/database.yml demo/config
```
That’s all. You can start the demo application.
```
$ cd demo
$ script/rails server
```
You can go to your favorite browser at http//127.0.0.1:3000 to visit the default Rails 3 application.

How to install Ubuntu Desktop on EC2 EBS

2010-02-02T12:17:51+00:00

Ctdh, a BitNami community member, has generously provided us with a great tutorial on how to make persistent data in Amazon Machine Images :

" Many of the instances of Ubuntu on EC2 are not based on an EBS instance which means you cannot stop/start the service without loosing the data and you cannot create your own ami fresh from the instance. So here is How to create your own Ubuntu Desktop on an EBS based EC2:

First follow:
http://bitnami.org/tutorials/amazon_machine_images

Make sure the AWS security group has port 22 open for the IP address you are using locally.

Launch ami-b3c0ebc7 AWS EBS instance (from http://alestic.com) using default settings.

If you use Windows to connect to the Amazon cloud, you can use the PuTTY tool, set the Host to ubuntu@[use the public DNS] and set Connection/SSH/Auth/Private Key file to the mykey.ppk you created in http://bitnami.org/tutorials/amazon_machine_images

Set Connection/SSH/Tunnels Source port: 9000 and to Destination: localhost:5901

If you want to install the Ubuntu Desktop you can enter the following commands at the terminal prompt:

sudo apt-get update
sudo apt-get install ubuntu-desktop
sudo apt-get install vnc4server
vncserver :1

Enter a password when prompted

You can then install tightvnc client on your local machine and open a connection to 127.0.0.1:9000 whilst the PuTTY ssh connection is still open.

When your vnc client connects, you will be presented with a terminal window in the desktop. Type the following command to start your gnome desktop:

nohup gnome-session &

Apparently NXserver is better, but I have not managed to install it yet.

Hope this helps someone. "

Announcing the First OpsCamp, Sponsored by BitNami and Others

2010-01-19T17:52:27+00:00

We’re excited to announce the first ever OpsCamp, sponsored by BitNami, Zenoss, Redmonk and ReductiveLabs. OpsCamp is an unconference for systems management professionals interested in cloud computing. It is being held on January 30th in Austin, Texas. Attendance is free, but space is limited, so if you are interested in attending, be sure to register soon.

If you’re not familiar with the unconference format, it is a participant-drive event that encourages everyone to get involved. The sessions are proposed and scheduled at the start of an event and anyone can propose and lead a session if there is enough interest. We think this is the ideal format for conferences that explore such a rapidly evolving topic.

We think Michael Coté, an Analyst at Redmonk and co-host of the IT Management Podcast, did a great job of explaining the goal of OpsCamp: “After many years of steady pace in the IT world, the tools and technologies used to do the daily work of operations are rapidly changing. Thanks to virtualization and cloud computing moving mainstream, new, hopefully better ways to deliver IT are emerging. These things aren’t always fully baked yet, but the thought-leaders and early adopters are quickly crystallizing. OpsCamp is an exciting chance to get involved in these conversations whether you want to start directing this shift in operations, figure out if it works for you, or just check it out.”

We hope to see you there!

New Enano CMS stack released

2009-12-26T13:17:40+00:00

A few days ago we released Enano CMS 1.1.7. This release incorporates multiple new features:

A new, lean wiki engine
A brand new theme, Enanium, usable while looking great.
A redesigned Administrative dashboard in the Administrative Control Panel
A new interface for viewing site logs, with more logged data to be able to audit more effectively
Includes PostgreSQL support
Improved Internet Explorer support.
Unicode (UTF-8) support everywhere.
A new (work in progress) tutorial for new users.
Live Re-Authentication. Administrator authentication doesn’t reload the whole page.
And more…

Enano CMS has addons available to extend its functionality. More information about addons can be found at Enano Plugin page

New Kademar Linux - Joomla! distro based on BitNami Stack

2010-01-07T07:51:20+00:00

The Kademar team has just released a new Linux distribution based on Kademar Leo 4.9.1 and BitNami Stack for Joomla!. This distribution was released on Joomla!Day 2009 in Barcelona where it got a warm welcome. It lets you work in a Live-CD or boot from a USB. An indispensable tool for teachers who want to teach the operation of Joomla! Content Management System or for testing before changing something on your website. It also shipped a new "BitNami Controller" to manage the servers with a simple click.

New BitNami Stacks for Ruby on Rails Apps

2009-12-17T19:26:51+00:00

As you may know, we recently released BitNami RubyStack 2.0, which includes a number of updates and enhancements. The primary changes are the addition of Ruby Enterprise for OS X and Linux and Phussion Passenger configured by default with Apache and Nginx. We have also improved performance and streamlined the deployment process.

If you haven’t experimented with Ruby on Rails yet, BitNami RubyStack makes it incredibly easy. Just visit the download page and choose from a native installer, a virtual machine image, or a cloud template (for Amazon and GoGrid). Regardless of the deployment option you choose, you will have everything you need to get up and running with Rails.

Along with the updated RubyStack, we have released a number of new Rails-based applications as BitNami Stacks. The new BitNami-packaged applications are available both as stand alone BitNami Stacks and as Modules. BitNami Modules allow you to run several applications on top of a single stack, so you don’t have multiple instances of infrastructure components such as Apache, Rails, and so on. This means that you can try out all of the new BitNami-packed Rails apps on top of one RubyStack installation!

The new BitNami Stacks are:

Spree (e-commerce): Spree capitalizes on the dynamic nature of the Ruby programming language to provide the most flexible commerce platform available. It has been designed from the ground up to be as open and extensible as possible. Spree supports over 50 payment gateways and includes the ability to add customized logic for taxation, shipping, discounts and coupons, along with a host of other features.

Radiant (content management system): Radiant is a no-fluff, open source content management system designed for small teams. Radiant features an elegant user interface, flexible templating with layouts, snippets, page parts, and a custom tagging language, a first-class extension/plugin system and more.

Typo (blogging platform): Typo is the oldest and most powerful Ruby on Rails blogware, providing custom templates, powerful drag and drop plugins API, advanced SEO capabilities, XMLRPC API and many more features.

As with all BitNami Stacks, they are available as native installers, virtual appliances and cloud templates for Amazon and GoGrid.

We would love to get your feedback on the new Stacks. Please take a moment to post your thoughts on our forums.

How to install VMWare tools on BitNami Virtual Appliances

2009-12-16T08:04:07+00:00

One of the most repeated questions in the BitNami forums is how to install vmware-tools in the BitNami Virtual Appliances. In this post we will try to explain the process to install them manually.

Before starting your Virtual Appliance, you should add a cdrom device to the machine if this device does not exist. If you have VMWare Workstation, VMWare Player or you simply are using a web interface you can add easily a new cdrom device from your Control Panel.

You should install the latest kernel, in case a new one has been released since the virtual machine was created. You can do so issuing the following command:

# zypper update kernel-default

If no newer version is found, the command will not take effect. If the zypper package tool installed a new kernel, you will need to reboot the machine:

# reboot

Once the machine is started using the new Linux kernel, you can access the VMWare tools. In the version of VMWare that we tested there is an option in the Control Panel: VM -> Install VMWare tools ...

This action simulates mounting a cdrom that includes the tools. Now it is necessary to mount the cdrom to install them:

# mkdir /mnt/cdrom
# mount /dev/cdrom /mnt/cdrom
# cd /mnt/cdrom
# rpm -i VMWareTools-.rpm

Before running the VMWare configuration tool it is necessary to install some dependencies:

# zypper install gcc make tar kernel-source

Finally you can configure the VMWare tools installed in the BitNami Virtual Appliance.

# vmware-config-tools.pl

Tutorial: Rubystack Deployment Alternatives

2010-01-07T07:44:40+00:00

BitNami RubyStack provides different deployment options. This article explains the different steps to follow in order to get your application running on top of RubyStack.

We will describe the settings to use:

Apache or Nginx as web server.
Mongrel, Thin or Phussion Passenger as the engine for Ruby web applications.

1. Initial steps

Some steps are common across all deployment approaches for Rails applications:

Extract the application files to a specific directory. For example, inside ${installdir}/apps/app_name

Setup the database in ${rails_application_dir}/config/database.yml to use the bundled RubyStack MySQL. Here is an example:

production:
  adapter: mysql 
  database: rails_app_production 
  host: 127.0.0.1
  username: ${mysql_user}
  password: ${mysql_password}
  port: ${mysql_port}

In Linux and OS X you should use the socket instead of “port”, adding:

  socket: ${installdir}/mysql/tmp/mysql.sock

Install any additional gems required by the application. This can be usually done by running:
```
cd ${rails_application_dir}
rake gems:install
```

Create the database and perform migrations:

cd ${rails_application_dir}
rake db:create  RAILS_ENV=production
rake db:migrate RAILS_ENV=production

Perform any application-specific configuration steps. For instance, some applications may require you to add smtp parameters in config/email.yml.
If the application is correctly configured, you should be able to access it at http://127.0.0.1:3000/ after running:
```
cd ${rails_application_dir}
ruby script/server -p 3000 -e production
```
Once the application is ready, we must set up Apache or Nginx to serve it.

2. Based on Mongrels

Mongrel is a fast HTTP library and server for Ruby that is intended for hosting Ruby web applications. You can learn more about Mongrel at http://mongrel.rubyforge.org.

In this case, we are going to configure a group of Mongrel processes that will be running in different ports. Once they are set up, we configure Apache or Nginx as a proxy balancer. All the Rails requests coming to the server will be redirected to the different ports.

This solution is available in all supported platforms and is the default approach followed by Rails BitNami Modules.

In order to set up the group of Mongrels, you can configure a mongrel cluster or generate a Windows service for each of them.

On Linux and OS X, you can use mongrel_cluster gem to configure/start/restart/stop a group of mongrels easily. You can create a mongrel cluster configuration file by running:

mongrel_rails cluster::configure -e production -p 3001 -N 5
  -C ${rails_application_dir}/config/mongrel_cluster.yml --prefix appname

This will create a cluster with 5 mongrels starting at port 3001 and ending at 3005. The option prefix is added in order to deploy the application inside a sub URI. These settings will be stored in mongrel_cluster.yml :

prefix: /appname
log_file: log/mongrel.log
port: "3001"
environment: production
pid_file: tmp/pids/mongrel.pid
servers: 5

Then, to start the cluster, type:

cd ${rails_application_dir}
mongrel_rails cluster::start

On Windows, you must install the mongrels as individual services. In other words, for each mongrel you should use an unique service name and port, calling mongrel_rails gem for each as follows:

mongrel_rails service::install -N "service_name_1" -p "3001" -c "application_directory" --prefix appname
mongrel_rails service::install -N "service_name_2" -p "3002" -c "application_directory" --prefix appname
...

To start the service you can use theWindows service tool or you type:

net start "service_name"

To uninstall the service:

mongrel_rails service::remove -N "service_name"

sc delete "service_name"

The number of Mongrels to be usedshould be decided according to the traffic that must be supported and the machine resources.

2.1 Using Apache

These are the steps to follow if you want to use Apache as the main server. You must include a new configuration file at ${rails_application_dir}/conf/http.conf containing something similar to:

ProxyPass /appname balancer://appcluster
ProxyPassReverse /appname balancer://appcluster

<Proxy balancer://appcluster>
  BalancerMember http://127.0.0.1:3001/appname
  BalancerMember http://127.0.0.1:3002/appname
  ...
</Proxy>

With a BalancerMember entry for each mongrel. Then, include the file from the main apache configuration ${installdir}/apache2/conf/httpd.conf:

Include "${rails_application_dir}/conf/http.conf"

That way, each time a Rails request is received, it will be redirected to the mongrels running in ports 3001, 3002...

After restarting Apache the application should be accessible at http://:/appname.

2.2. Using Nginx

You can use the nginx web server instead of Apache. Nginx is designed to be a high-performance server with low resource requirements. You can learn more about nginx at http://nginx.org

In Linux and OS X, it can be easily started instead of apache through ctlscript.sh by modifying the following line:

APACHE_SCRIPT=$INSTALLDIR/nginx/scripts/ctl.sh

To make nginx serve the application, you must include a new file nginx/conf/vhosts/railsapp.conf with the contents:

upstream backend  {
  server 127.0.0.1:3001/appname;
  server 127.0.0.1:3002/appname;
  ...
}

server {
  location /appname {
    proxy_redirect off;
    port_in_redirect off;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

    if (-f $request_filename) {
      break;
    }

    if (!-f $request_filename) {
      proxy_pass  http://backend;
      break;
    }
  }
}

That way, each time a Rails request is received, it will be sent to the mongrels defined inside the upstream backend section. This setup also makes ngingx serve static files located in public directory directly.

Finally, start nginx:

<installation directory>/nginx/sbin/nginx (linux, osx)
<installation directory>\nginx\nginx.exe  (windows)

The application should be accessible at http://domain:nginx_port/appname. You may modify the port were nginx is listening adding a "listen" parameter to the server definition. By default, port 1234 is used.

RubyStack nginx was compiled with the Upstream Fair Module, which will send the incoming requests to the least busy backend server. In order to use it, modify the upstream backend element as follows:

upstream backend {
  : server 127.0.0.1:3001/appname;
  : server 127.0.0.1:3002/appname;
        ...
  : fair;
}

You can learn more about this module at: http://wiki.nginx.org/NginxHttpUpstreamFairModule

3. Based on Thin

Thin is another ruby web server which can be used to deploy your application. It is based in Mongrel parser, Event Machine and Rack. You can learn more about it at http://code.macournoyer.com/thin.

The steps to use it are similar to the ones described in the Mongrel approach: you will have a group of processes listening in different ports.

In Linux and OS X, you can store the configuration in a yml file and use it to start and stop the group easily. For example:

cd ${rails_application_dir}
thin -s 5 -p 3000 -e production --prefix /appname -C config/thin.yml config

Which will configure 5 processes in ports 3000 to 3004, running in a production environment and using prefix /appname. Once the configuration file has been generated, you can start, stop or restart the by running:

thin -C ${rails_application_dir}/config/thin.yml start/stop/restart

If you are using RubyStack on Windows, you can't start multiple servers using '.-s' option. You will need to call a command for each instance:

cd ${rails_application_dir}
thin -p 3000 -e production --prefix /appname start
thin -p 3001 -e production --prefix /appname start
...

In order to configure Apache or Nginx, you can follow the steps described in the previous section, using the ports where thin processes are listening.

4. Based on Phusion Passenger

If you are using Linux or OS X, you can deploy the application with Phusion Passenger. This approach simplifies the development of Ruby web applications because it is not necessary to configure any additional Mongrel or Thin processes. Furthermore, it allows Ruby on Rails applications to use about 33% less memory when used in combination with Ruby Enterprise Edition, which is the version included in RubyStack.

You can find more information about Phusion Passenger at http://www.modrails.com/.

4.2. Using Apache

To use this method, you just need to include a virtual host which DocumentRoot points to 'public' directory in Rails application.

<VirtualHost *:80>
  ServerName myapplication.com
  DocumentRoot ${rails_app_dir}/public
  <Directory ${rails_app_dir}/public>
    Allow from all
    Options -MultiViews
  </Directory>
</VirtualHost>

You should make sure that the 'public' and 'config' application folders and their parent directories are readable and executable by Apache. After restarting Apache, the applications will be accessible at: http://:/

It is also possible to deploy a set of applications to different sub URIs. In order to do so, create a root directory which contains links to each of the application's public paths. For example, you can do something like:

mkdir ${installdir}/webapps
ln -s ${installdir}/app/railsapp1/public ${installdir}/webapps/railsapp1
ln -s ${installdir}/app/railsapp2/public ${installdir}/webapps/railsapp2
...

Once the links are created, configure Apache using a RailsBaseURI entry for each application to be deployed:

<VirtualHost *:80>
  ServerName myapplication.com 
  DocumentRoot ${installdir}/webapps
  <Directory ${installdir}/webapps> 
    Allow from all 
    Options -MultiViews
  </Directory> 

  RailsBaseURI /railsapp1
  RailsBaseURI /railsapp2
  ...
</VirtualHost>

After restarting Apache, the applications will be accessible at:

  http://<domain>:<port>/railsapp1/
  http://<domain>:<port>/railsapp2/
  ...

4.3 Using Nginx

Nginx has been compiled with the Phusion Passenger module in Linux and OS X systems. In order to use it, include the options "passenger_enabled" and specify the root path and rails environment.

You can do this by adding a new file in nginx/conf/vhosts/appname.conf containing:

server  {
  ...
  root ${rails_appdir}/public; # Path to rails application public dir
  passenger_enabled on;
  rails_env production;
  ...
}

In this case, it is not necessary to start additional processes apart from Nginx. After restarting the web server, the application will be accessible at http://domain:nginx_port/.

You can also deploy multiple applications following similar steps to the ones described for Apache using passenger_base_uri option. First, create a common directory containing links to public directories:

mkdir ${installdir}/webapps
ln -s ${installdir}/app/railsapp1/public ${installdir}/webapps/railsapp1
ln -s ${installdir}/app/railsapp2/public ${installdir}/webapps/railsapp2
...

Then, add a passenger_base_uri option for each of them inside the server element:

server  {
  ...
  root /websites/phusion;
  passenger_enabled on;
  passenger_base_uri /railsapp;
  passenger_base_uri /railsapp2;
  ...
}

After restarting Nginx, the applications will be accessible at:

  http://domain:nginx_port/railsapp/
  http://domain:nginx_port/railsapps2/
  ...

How-To Video: Launching BitNami Virtual Appliances

2009-12-14T09:45:56+00:00

We put together the video below to show you how easy it is to get up and running with one of the BitNami virtual machine images, or ‘virtual appliances’. This video features the BitNami Joomla! Stack on VMWare Player, but the steps are virtually the same for every BitNami virtual appliance. All of the virtual appliances will also run in VirtualBox. … more

New RubyStack Version with Passenger, Ruby Enterprise

2009-12-17T19:01:35+00:00

We are glad to announce a new version of RubyStack that includes improved performance and deployment options with Ruby Enterprise and Phusion Passenger You can download it now at the RubyStack section… more

CodeIgniter and MAMPStack

2009-11-25T13:37:12+00:00

Quick start guide from the guys at Frugle… more

How to Install Multiple Joomla! Sites on One BitNami Stack

2009-11-24T10:52:48+00:00

Thanks to BitNami user mzhulaev, who originally posted this in our forums, we now have the tutorial below on how to run multiple Joomla! sites on one BitNami Stack. Although this article is focused on Joomla!, it should apply to other Stacks as well.

Here is the how-to:

1. Go to the file at “C:\Program Files\BitNami RubyStack\apache2\conf\httpd.conf”

2. Add the following line to the end of the file:

Include “C:/Program Files/BitNami RubyStack/apps/NEW_INSTANCE_NAME/conf/NEW_INSTANCE_NAME.conf”

3. If you want to see the new instance on the BitNami application load page (http://localhost), edit the following file in html-editor (otherwise, you can skip this step)

“C:\Program Files\BitNami RubyStack\apache2\htdocs\applications.html”

4. Copy the following block:

<!-- START BitNami Joomla 1.5.15-0 Module joomla --> 

********

<!-- END BitNami Joomla 1.5.15-0 Module joomla -->

and correct the following:

<h2>NEW_INSTANCE_NAME</h2>
<div align=“right” class=“module_access”><a href=“/NEW_INSTANCE_NAME”>Access</a></div>

5. Create the following folders

“C:\Program Files\BitNami RubyStack\apps\NEW_INSTANCE_NAME\conf”

“C:\Program Files\BitNami RubyStack\apps\NEW_INSTANCE_NAME\htdocs”

6.Copy the following file from the original Joomla instance to the NEW_INSTANCE folder and rename it:
Original: “C:\Program Files\BitNami RubyStack\apps\Joomla\conf\Joomla.conf”
To: “C:\Program Files\BitNami RubyStack\apps\NEW_INSTANCE_NAME\conf\NEW_INSTANCE_NAME.conf”

7. Edit the following lines in this file:

Alias /NEW_INSTANCE_NAME/ “C:/Program Files/BitNami RubyStack/apps/NEW_INSTANCE_NAME/htdocs/”
Alias /NEW_INSTANCE_NAME “C:/Program Files/BitNami RubyStack/apps/NEW_INSTANCE_NAME/htdocs”

8. Download the latest Joomla version (i.e. from here: www.joomla.org)

9. Copy and extract the archive in this folder
“C:\Program Files\BitNami RubyStack\apps\NEW_INSTANCE_NAME\htdocs”

10. Use phpMyAdmin to create a new DB_instance and user.

11. Install the new Joomla instance. This procedure is explained in detail on many sites. There is one posted at this link.

9. Restart the Apache Server

10. You should be able to access the new instance using this link: http://localhost/NEW_INSTANCE_NAME or from the BitNami application load page (if you performed step #3)

BitNami Moodle Stack in Australia

2009-11-18T21:47:49+00:00

Thanks to BitNami Moodle Stack user Tim Daniels, BitNami will be showcased at the Converge Conference in Victoria, Australia. Tim will be teaching people about BitNami and Moodle and showing off the online learning environment he built using BitNami Moodle Stack.

Tim started working on developing web-based resources for his local Community Center three years ago on their local server. As the project grew, it began to get a bit unwieldy. He found Moodle online but then realized he would have to install and configure PHP, MySQL and other dependencies – something he was not familiar with. He then came across BitNami and was able to install the BitNami Moodle Stack without manually installing and configuring everything. Tim says “Your Bitnami Moodle stack is just wonderful because it enables easy development of courses on an XP machine without the need to be online.”

Now that the BitNami Moodle Stack is up and running their online learning environment at the Community Center, Tim was able to get government funding earmarked for e-learning projects. This is allowing him to continue developing online courses to benefit his community.

Many thanks to Tim for sharing his story, doing great work in his community and helping to spread the word about BitNami. We wish him the best of luck with the conference!

WordPress Wins the 2009 Overall Best Open Source CMS Award

2009-11-17T08:54:19+00:00

Last Friday, Packt Publishing announced the winners of this year’s Open Source CMS Award. Congratulations to Wordpress for earning 1st place as the Best Overall CMS System! Congratulations also goes to MODx and Silverstripe for tying for 2nd place. If you would like to take Wordpress for a spin, BitNami offers ready-to-run packages of Wordpress and everything it requires to run as a native installer, virtual appliance and cloud template, so you can run it on your server, in a virtual environment or in the cloud. To read more about the winners, visit Packt Publishing’s… more

Wordpress MU 2.8: Beginner's Guide Now Available - Sample Chapter for Download

2009-11-17T08:53:18+00:00

We just received word that Wordpress MU 2.8: Beginner’s Guide is now available from Packt Publishing. Since we know a lot of our users are running Wordpress, we thought the book might be of interest. We haven’t had a chance to review the book, but Packt sent over a sample chapter that we have posted for download. Here is their summary of the book:

"WordPress MU enables you to build a complete, professional blog network. Each user gets their own blog, and can choose their favorite templates and plug-ins, and develop their own content. WordPress MU powers some of the largest blog networks in the world, including the mighty WordPress.com – home to thousands of bloggers.

This book will take you through the setup of a WordPress MU-powered blogging network, using a real, working blog network as an example, so that you can follow the creation process step-by-step. Your blogging network will be complete with professional features such as friends lists, status feeds, groups, forums, photo galleries, and more, to build your own WordPress.com – a place where users can quickly come and create a blog for themselves.

The book starts with a clean install of WordPress MU, and as you work through the book, you will build the blog network, and add on more and more features, all seamlessly integrated to achieve a professional, custom-built look.

You will find new themes and plug-ins added to the site, as well as customization of the WordPress multi-user code. The book will also look at ways you can manage your community, and keep your site safe and secure, ensuring that it is a spam-free, enjoyable community for your users. In the later chapters, you will add a forum using the bbPress script, and add BuddyPress social networking components to your site.

Imagine how good you’ll feel when your first WordPress multi-user blog network launches."

How to Install Wordpress in 5 Minutes Using BitNami

2009-11-06T17:56:55+00:00

There is a great post up on Techsnot (yes, a somewhat unfortunate name :) on how to install Wordpress on a Mac in under 5 minutes using the BitNami Wordpress Stack. Although the author (‘dogsnot’) installs the Stack on a Mac, the steps are the same on Windows or Linux. In a future article, the author will explain how BitNami Modules work. If you are using BitNami and want to help us out, writing tutorials like this is a great way to contribute. Thanks to Dogsnot for his article!… more

European PostgreSQL conference 2009

2009-10-02T14:48:05+00:00

The PGDay 2009 is a chance for European users and developers of PostgreSQL to catch up, learn, build relationships, get to know each other and consolidate a real network of professionals that use this outstanding product for the daily management of relational and object databases. The event will take place November 6, 7 in Paris, so start planning for it. Checkout the PGDay website for more details… more

How to backup and update the BitNami Redmine Stack

2009-09-17T08:08:33+00:00

A lot of BitNami users have asked in our forums how to create a backup or update Redmine. We have compiled all questions and solutions in this post to facilitate this task for other BitNami users. Although this post is based on the BitNami Redmine Stack, some of these solutions are valid for other BitNami applications.

Throughout the article, we will use the installdir term to refer us to the installation directory. On Linux it is usually “/home/redmine-version” when installed as a regular user or “/opt/redmine-version” in the case of an installation as the root user. On OS X the installation directory is “/Applications/redmine-version” by default and on Windows is “C:\Program Files\BitNami Redmine Stack”.

All commands should be executed from the BitNami Redmine Stack console. On Linux or OS X you should only run the “use_redmine” script or the “rubyconsole” script:


$ ./use_redmine
$ mysql --version
/home/bitrock/redmine-0.8.4-1/mysql/bin/mysql.bin  Ver 14.12 Distrib 5.0.67,
for redhat-linux-gnu (i686) using readline 5.1

On Windows you have a specific “use_redmine” shortcut to launch the console.

HOW TO CREATE A BACKUP

There are different ways of creating a backup. If you are interested in a backup of only the database data, you can create a dump file using the “mysqldump” tool.

Remember that you should run this command from the BitNami Redmine Stack console.


$ mysqldump -u root -p bitnami_redmine > redmine_backup.sql

This operation could take some time depending on the data size. Once you have the backup file, you can restore it:


$ mysql -u root -p bitnami_redmine < redmine_backup.sql

If you want to restore the database and the database schema does not exist, it is necessary to first follow the steps described below. As a side note, you can find the value for BITNAMI_USER_PASSWORD below at “installdir/apps/redmine/config/database.yml” file.


$ mysql -u root -p
mysql> create database bitnami_redmine;
mysql> grant all privileges on bitnami_redmine.* to 'bitnami'@'localhost'
identified by 'BITNAMI_USER_PASSWORD';
mysql> flush privileges;
mysql> exit;
$ mysql -u root -p bitnami_redmine < redmine_backup.sql

Note that the steps previously described will only back up the state of your database. Other files that you should take into account when performing a backup are files that have been uploaded to the
application. These files are stored in the “installdir/apps/redmine/files” folder so you can copy this folder to have a backup of your uploaded files.

Another option for creating a backup is to copy the whole BitNami Stack installation. Because BitNami stacks are self-contained, the simplest option for performing your backups is to copy or compress the BitNami Redmine Stack installation directory. To do so in a safe manner, you will need to stop all servers, so this method may not be appropriate if you have people accessing the application continously.


$ cd <installdir>
$ ./ctlscript.sh stop
$ cp -r <installdir> redmine-backup

Or you can create a tarball:


$ tar -czvf redmine-backup.tar.gz <installdir>

To restore this backup you only need to uncompress the backup tarball in the same location. It is important to use the same path that was used when the stack was originally installed.

For example if you have a backup in a Red Hat machine, you can copy it to an Ubuntu Linux machine (a different distro!) in the same location. Then start the servers and that’s all.


$ cd <installdir>
$ ./ctlscript.sh start

On Windows, you should follow the same process. Stop the servers using the shortcuts and copy the whole installation directory. To restore the system, copy the directory to a different Windows machine in the same location and follow these steps from a command prompt:


$ cd <installdir>
$ serviceinstall.bat INSTALL

You can access your BitNami Redmine at the usual URL.

HOW TO UPDATE REDMINE

It is strongly recommended that you create a backup before starting the update process. If you have important data, it is advisable that you create and try to restore a backup to ensure that everything works properly.

First, you have to download the new Redmine version. You can choose to download the latest stable version of Redmine from RubyForge or you can download the latest repository version. In that case, you can use the Subversion tool included in the Stack:


$ svn co svn://rubyforge.org/var/svn/redmine/trunk redmine

Once you have downloaded the newer Redmine version, you need to stop the servers and rename the old redmine folder:


$ cd <installdir>
$ ./ctlscript.sh stop
$ mv apps/redmine apps/redmine-old

On Windows:


$ cd <installdir>
$ servicerun.bat STOP
$ cd apps
$ rename redmine redmine-old

Move the new redmine version to the apps folder and name it “redmine” and then copy the following folders and files from the old copy to the new one: “scripts”, “conf” and “files” folders and all the yml files inside “config”. It is also necessary to create the “apps/redmine/tmp/pids” folder.


$ cd <installdir>/apps
$ cp -r redmine-old/scripts redmine-old/conf redmine-old/files redmine-old/files redmine/
$ cp redmine-old/config/*.yml redmine/config/
$ mkdir redmine/tmp/pids

If you want to keep using the currently installed Rails version, you should comment out the following line in “redmine/config/environment.rb”


RAILS_GEM_VERSION = 'x.x.x' unless defined? RAILS_GEM_VERSION

It is also necessary to update the database to merge the changes in the new version. Remember to start the “use_redmine” script or the shortcut on Windows before typing the following commands:


$ cd <installdir>/apps/redmine
$ rake db:migrate RAILS_ENV="production"

If you have installed plugins you should also run these commands:


$ rake db:migrate:upgrade_plugin_migrations RAILS_ENV="production"
$ rake db:migrate_plugins RAILS_ENV="production"

Finally you should clean the cache and the sessions:


$ rake tmp:cache:clear
$ rake tmp:sessions:clear

Restart the servers and you can access to your new Redmine.