Getting Started with Django on Heroku



Getting Started with Django on Heroku




Table of Contents


This quickstart will get you going with a Python/Django application that uses a Postgres database, deployed to Heroku. For other Python apps, see Getting Started with Python on Heroku.

Prerequisites

Start a Django app inside a Virtualenv

First, we’ll create an empty top-level directory for our project:
$ mkdir hellodjango && cd hellodjango
Make sure you’re using the latest virtualenv release. If you’re using a version that comes with Ubuntu, you may need to add the --no-site-packages flag.
Next, we’ll create a Python Virtualenv (v0.7):

$ virtualenv venv --distributeNew python executable in venv/bin/pythonInstalling distribute...............done.Installing pip...............done.
To use our new virtualenv, we need to activate it. (You must source the virtualenv environment for each terminal session where you wish to run your app.)
Windows users can runvenv\Scripts\activate.bat for the same effect.
$ source venv/bin/activate
Next, install our application’s dependencies with pip. In this case, we will be installing Django (the web framework), Gunicorn (the web server), and dj-database-url (a Django configuration helper).
Windows users, if you have issues installing psycopg2, see thisalternative installation method.
$ pip install Django psycopg2 gunicorn dj-database-urlDownloading Django-1.5.tar.gz (8.0MB): 8.0MB downloaded  Running setup.py egg_info for package Django
Downloading/unpacking psycopg2  Downloading psycopg2-2.4.6.tar.gz (667kB): 667kB downloaded  Running setup.py egg_info for package psycopg2
Downloading/unpacking gunicorn  Downloading gunicorn-0.17.2.tar.gz (360kB): 360kB downloaded  Running setup.py egg_info for package gunicorn    Downloading/unpacking dj-database-url  Downloading dj-database-url-0.2.1.tar.gz  Running setup.py egg_info for package dj-database-url    Installing collected packages: Django, psycopg2, gunicorn, dj-database-url  Running setup.py install for Django  Running setup.py install for psycopg2  Running setup.py install for gunicorn  Running setup.py install for dj-database-url    ...Successfully installed Django psycopg2 gunicorn dj-database-urlCleaning up...
Now that we have a clean Python environment to work in, we’ll create our simple Django application.
Don’t forget the . at the end. This tells Django to put the extract the into the current directory, instead of putting it in a new subdirectory.
$ django-admin.py startproject hellodjango .

Declare process types with Procfile

Use a Procfile, a text file in the root directory of your application, to explicitly declare what command should be executed to start a web dyno. In this case, you need to execute Gunicorn with a few arguments.
Here’s a Procfile for our new app. It should be called Procfile and live at the root directory of our project:
web: gunicorn hellodjango.wsgi
You can now start the processes in your Procfile locally using Foreman (installed as part of the Toolbelt):
$ foreman start2013-04-03 16:11:22 [8469] [INFO] Starting gunicorn 0.14.62013-04-03 16:11:22 [8469] [INFO] Listening at: http://127.0.0.1:8000 (8469)
Make sure things are working properly curl or a web browser, then Ctrl-C to exit.

Specify dependencies with Pip

Heroku recognizes Python applications by the existence of arequirements.txt file in the root of a repository. This simple format is used by most Python projects to specify the external Python modules the application requires.
Pip has a nice command (pip freeze) that will generate this file for us:
$ pip freeze > requirements.txt
$ cat requirements.txtDjango==1.5dj-database-url==0.2.1psycopg2==2.4.6gunicorn==0.17.2
Pip can also be used for advanced dependency management. See Python Dependencies via Pip to learn more.

Django settings

Next, configure the application for the Heroku environment, including Heroku’s Postgres database. The dj-database-url module will parse the values of theDATABASE_URL environment variable and convert them to something Django can understand.
Make sure ‘dj-database-url’ is in your requirements file, then add the following to the bottom of your settings.py file:
# Parse database configuration from $DATABASE_URL
import dj_database_url
DATABASES['default'] =  dj_database_url.config()

# Honor the 'X-Forwarded-Proto' header for request.is_secure()
SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')

Store your app in Git

Now that we’ve written and tested our application, we need to store the project in a Git repository.
Since our current directory contains a lof of extra files, we’ll want to configure our repository to ignore these files with a .gitignore file:
GitHub provides an excellent Python gitignore file that can be installed system-wide.

.gitignore

venv
*.pyc
Next, we’ll create a new git repository and save our changes.
$ git initInitialized empty Git repository in /Users/kreitz/hellodjango/.git/$ git add .$ git commit -m "my django app"[master (root-commit) 2943412] my django app 7 files changed, 230 insertions(+) create mode 100644 .gitignore create mode 100644 Procfile create mode 100644 hellodjango/__init__.py create mode 100644 hellodjango/settings.py create mode 100644 hellodjango/urls.py create mode 100644 hellodjango/wsgi.py create mode 100644 manage.py create mode 100644 requirements.txt

Deploy to Heroku

The next step is to push the application’s repository to Heroku. First, we have to get a place to push to from Heroku. We can do this with the heroku createcommand:
$ heroku createCreating simple-spring-9999... done, stack is cedarhttp://simple-spring-9999.herokuapp.com/ | git@heroku.com:simple-spring-9999.gitGit remote heroku added
This automatically added the Heroku remote for our app (git@heroku.com:simple-spring-9999.git) to our repository. Now we can do a simple git push to deploy our application:
$ git push heroku masterCounting objects: 11, done.Delta compression using up to 4 threads.Compressing objects: 100% (9/9), done.Writing objects: 100% (11/11), 4.01 KiB, done.Total 11 (delta 0), reused 0 (delta 0)-----> Python app detected-----> No runtime.txt provided; assuming python-2.7.4.-----> Preparing Python runtime (python-2.7.4)-----> Installing Distribute (0.6.36)-----> Installing Pip (1.3.1)-----> Installing dependencies using Pip (1.3.1)       Downloading/unpacking Django==1.5 (from -r requirements.txt (line 1))       ...       Successfully installed Django psycopg2 gunicorn dj-database-url        Cleaning up...-----> Collecting static files       0 static files copied.
-----> Discovering process types       Procfile declares types -> web
-----> Compiled slug size is 29.5MB-----> Launching... done, v6       http://simple-spring-9999.herokuapp.com deployed to Heroku
To git@heroku.com:simple-spring-9999.git* [new branch]      master -> master

Visit your application

You’ve deployed your code to Heroku, and specified the process types in aProcfile. You can now instruct Heroku to execute a process type. Heroku does this by running the associated command in a dyno - a lightweight container which is the basic unit of composition on Heroku.
Let’s ensure we have one dyno running the web process type:
$ heroku ps:scale web=1
You can check the state of the app’s dynos. The heroku ps command lists the running dynos of your application:
$ heroku ps=== web: `gunicorn hellodjango.wsgi`web.1: up for 10s
Here, one dyno is running.
We can now visit the app in our browser with heroku open.
$ heroku openOpening simple-spring-9999.herokuapp.com... done
You should see the satisfying “It worked!” Django welcome page.

Dyno idling and scaling

Having only a single web dyno running will result in Heroku periodically idling the dyno after a period of inactivity. This causes a delay of a few seconds for the first request after idling. Subsequent requests will perform normally.
To avoid this, you can scale to more than one web dyno. For example:
$ heroku ps:scale web=2
For each application, Heroku provides 750 free dyno-hours. Running your app at 2 dynos would exceed this free, monthly allowance, so let’s scale back:
$ heroku ps:scale web=1

View the logs

Heroku treats logs as streams of time-ordered events aggregated from the output streams of all the dynos running the components of your application. Heroku’sLogplex provides a single channel for all of these events.
View information about your running app using one of the logging commands,heroku logs:
$ heroku logs2012-04-06T19:38:25+00:00 heroku[web.1]: State changed from created to starting2012-04-06T19:38:29+00:00 heroku[web.1]: Starting process with command `gunicorn hellodjango.wsgi`2012-04-06T19:38:29+00:00 app[web.1]: Validating models...2012-04-06T19:38:29+00:00 app[web.1]:2012-04-06T19:38:29+00:00 app[web.1]: 0 errors found2012-04-06T19:38:29+00:00 app[web.1]: Django version 1.5, using settings 'hellodjango.settings'2012-04-06T19:38:29+00:00 app[web.1]: Development server is running at http://0.0.0.0:6566/2012-04-06T19:38:29+00:00 app[web.1]: Quit the server with CONTROL-C.2012-04-06T19:38:30+00:00 heroku[web.1]: State changed from starting to up2012-04-06T19:38:32+00:00 heroku[slugc]: Slug compilation finished

Syncing the database

The heroku run command lets you run one-off admin dynos. You can use this to sync the Django models with the database schema:
$ heroku run python manage.py syncdbRunning python manage.py syncdb attached to terminal... up, run.1Creating tables ...Creating table auth_permissionCreating table auth_group_permissionsCreating table auth_groupCreating table auth_user_groupsCreating table auth_user_user_permissionsCreating table auth_userCreating table django_content_typeCreating table django_sessionCreating table django_site
You just installed Django's auth system, which means you don't have any superusers defined.Would you like to create one now? (yes/no): yesUsername (leave blank to use 'u53976'): kennethEmail address: kenneth@heroku.comPassword: Password (again): Superuser created successfully.Installing custom SQL ...Installing indexes ...Installed 0 object(s) from 0 fixture(s)

Using the Django shell

Similarly, you can use heroku run to get a Django shell for executing arbitrary code against your deployed app:
$ heroku run python manage.py shellRunning python manage.py shell attached to terminal... up, run.1Python 2.7.4 (default, Apr  6 2013, 22:14:13)[GCC 4.4.3] on linux2Type "help", "copyright", "credits" or "license" for more information.(InteractiveConsole)>>> from django.contrib.auth.models import User>>> User.objects.all()[<User: kenneth>]

Next steps

SHARE

About Lasha Gogua

    Blogger Comment
    Facebook Comment

0 comments:

Post a Comment