Django deployment using Stackato

Installing the Stackato commmand line tool

Next you need to download the Stackato command-line tool, a small binary client written in TCL (if you’re curious, you can look at the source in their Github account). The Stackato docs have a whole section ondeploying Django that will be useful to reference as we walk through this example.

For convenience, put the client in your /usr/local/bin directory so that it’s available from anywhere:

Mezzanine revisited

Mezzanine is the most popular CMS/blogging add-on for Django, and we’re going to use it as the example Django project to deploy to Stackato, and all subsequent PaaS providers in this blog article series. In this postwe described how to get a stock Mezzanine site set up and running locally. You can see the this Mezzanine project template in the master branch, and the Stackato version that we’re going to make below in theStackato branch.

Configure WSGI

Stackato uses uWSGI by default, so we need to create a wsgi.py file that uWSGI will use to load Django. Put this file in the paasbakeoff directory:

Create requirements.txt file

You can see that the ‘mezzanine-website’ command has made a skeleton Mezzanine project for us, including a requirements directory, which contains a project.txt. Since Stackato requires the requirements.txt file to be in the top level directory, let’s make a requirements.txt file in the root, which points to this project.txt file:

Target and login to the Stackato endpoint

Now we’re going to try to push the app to the Stackato’s sandbox. First we need to tell Stackato what API endpoint to use. In this case it’s api.stacka.to, but if you’re using your own EC2 or microcloud then that domain name instead.

Deploy to the Stackato sandbox

Now that we’ve successfully logged in, let’s deploy the app to the Stackato sandbox with the ‘push’ command. We’ll answer a bunch of questions the first time, and at the end it will prompt us to save this configuration as a stackato.yml file:

This will fail with this error:

The solution is to add ‘pillow’ as a PyPm dependency in the stackato.yml file. This is described in the stackato.yml reference in the Stackato docs (http://docs.stackato.com/reference/stackatoyml.html#language-modules).

Defining package dependencies

The auto-generated stackato.yml file looks like this:

We’re going to add a requirements section to include pillow as a dependency, and while we’re at it, since we chose PostgreSQL as our database above, we also need to add psycopg2 as a requirement (if we were using MySQL, then we would add MySQL-python instead):

If we wanted to install psycopg2 using pip, we could have added a pip requirements section:

Or we could have added it to our requirements.txt file with:

But using ActiveState’s PyPm repository is faster than using pip, since the PyPm packages are already compiled.

Once you’ve pushed the app the first time, subsequent pushes must be done with the ‘update’ command:

We won’t start it yet, because there’s still something we need to do in order for Mezzanine to recognize the PostgreSQL database that Stackato has created for us. Modify the settings.py file, to include these imports at the top of the file:

And replace the ‘DATABASES’ section with the following:

Run the stackato update command again:

If it doesn’t start up, you can start it with:

If there are any problems, you can look at the logs with:

Even though it looks like everything worked properly, there is a problem because Stackato is using local_settings.py which defines SQLite as the database, which will override our special Stackato database settings. We need to make sure that .gitignore has this file included, and it doesn’t hurt to add an ignores: section in stackato.yml as well:

Run stackato update -n after you make this change.

Running manage.py syncdb

The database is not set up yet because we haven’t run manage.py syncdb. (Note: in Django 1.4, the manage.py file is one directory above where the settings.py file is, so for the following command you would drop the ‘mywebsite’ prefix if you’ve created a new Django project using the django-admin.py startproject command):

Serving up static assets

When we go to http://paasbakeoff.stacka.to/ we can see that the site is up, but none of the images or CSS are loading properly. This is because we need to collect all the static files using the collectstatic command:

You can make sure that the files were copied to the right place with this command:

And then we need to tell Stackato to serve up these static assets using uWSGI. This is easy to setup, by a few lines to our stackato.yml file:

Run stackato update -n after you make this change.

Read more about serving static files using uWSGI

Run syncdb and collectstatic commands on every deploy

It would be nice if the syncdb and collectstatic commands would be run every time we do a deploy. We can add these to a post-staging hook in the stackato.yml file:

Note: it’s important to put the –noinput, or else the command will halt waiting for user input.

South migrations

If we were using South for database schema migrations (which is highly recommended), then we could add a manage.py migrate command here as well:

Just make sure that you add South to the PyPm requirements in stackato.yml, or add it to your requirements.txt file:

Persisted filesystem for file uploads

Mezzanine, like many other Django-based CMSes lets users upload files (images, PDFs, etc.) which need to be persisted on the server’s filesystem. By default, the filesystem is ephemeral meaning, that it will get wiped out on each deploy. Thankfully, Stackato provides a way to persist these files across deploys. You need to add a filesystem service to the services section of stackato.yml:

In then in settings.py, we need to tell Django to use this as the MEDIA_ROOT:

Run stackato update -n after you make this change.

Read more about the persistent filesystem support on Stackato here.

Caching with memcache

One of the supported services of Stackato is memcached, and to provision a new memcached instance, you simply add it to the services section of stackato.yml, and add python-memcached as a dependency in the pypm requirements:

And then you need to add the following to your settings.py file:

And make sure that these are in your middleware classes (should already be there in default Mezzanine):

Run stackato update -n after you make this change.

Read more about memcached support on Stackato.

The benefits of using Linux Containers

Stackato uses Linux Containers (LXC), almost like a lightweight virtual machine, to isolate each app from the other apps running on the server. This is not only more secure but it prevents one rogue app from sucking up all the memory on the machine, because each app is memory-bound.

SSHing into the container

Another benefit of using LXC is that it’s possible to SSH into the container and have full control without the risk of affecting other apps:

Defining OS dependencies

Since each app is essentially running in its own Linux box, you can install OS-level dependencies with apt-get or yum. You can either do this by SSHing into the container, or to persist the changes across deploys, it’s best to define these dependencies in the stackato.yml file.

For example, if we wanted to define python-lxml as a OS level package to be installed, we could add it as follows:

Read more about OS dependencies on Stackato

Wrap up

That concludes the first article in this PaaS deployment for Django series! I hope you enjoyed learning how to get your Django app deployed quickly using Stackato. For the next article, we’ll walk through how to deploy Mezzanine with Dotcloud.

If you find an errors in the examples, or have feedback, I welcome you to use the feedback button on the right of the page, or the live chat button on the bottom of the page. You can also submit an issue to the Github issue tracker, and we’ll fix it right away.

Don’t miss the next article!

If you’d like to be notified when new articles in this series are posted, sign up for the SaaS Developers Kitannouncement list, and we’ll shoot you an email as soon a new post is available.