Django on GAE (google app engine)

What is GAE?

Google App Engine (often referred to as GAE or simply App Engine) is a platform as a service (PaaS) cloud computing platform for developing and hosting web applications in Google-managed data centers. Applications are sandboxed and run across multiple servers.App Engine offers automatic scaling for web applications—as the number of requests increases for an application, App Engine automatically allocates more resources for the web application to handle the additional demand.

We can upload any kind of web applications developed in any programming language like Java, Python, PHP.... etc.,Here in this blog let us see how to upload a simple Django application into the Google App Engine.

Simple procedure to upload a Simple django applicaion to GAE:

STEP 1:First create a simple PyDev Google App Engine Project by following the steps given below.

1. Go to File > New > Project
2. Choose PyDev Google App Engine Project under PyDev folder.
3. Choose your own project name.
4. If the Python interpreter for Eclipse has not been configured, you would see the link Please configure an interpreter in the related preferences before proceeding.
5. Clicking the link will lead you to the Python Interpreters set up. ClickAuto Config. The system will help add the necessary paths to your PythonPath. Just click OK to proceed.
6. Choose the Default interpreter and click Next.
7. Browse your installed Google App Engine sdk directory.
8. Click OK to include the recommended packages and then click Next.
9. Fill in your registered App ID. (given as application identifier while creating the app)
10. Choose one of the given starter template and click Finish.

STEP 2:Creating a Django Project folder:

• Create a Django Stand Alone application to project folder of the Django on App Engine application the file manage.py and the folder Project_Name including the inside files __init__.py, settings.py, urls.py.
• Create a new file named main.py in the project folder.

Your application folder should have the simple structure as below:

With this folder structure, we would modify the individual files accordingly as explained below.

main.py:

• main.py Include the below content in your file. This is to define the WSGI for the web server.

import django.core.handlers.wsgi

application = django.core.handlers.wsgi.WSGIHandler()

settings.py:

• Remove the settings for DATABASES and WSGI_APPLICATION because we would be using Google App Engine datastore and have defined our WSGI in main.py above.
• Change the setting for ROOT_URLCONF to the correct 'Project_Name.urls'.

ROOT_URLCONF = 'Project_Name.urls'

manage.py:

• Change the setting for DJANGO_SETTINGS_MODULE to the correct "Project_Name.settings".

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "Project_Name.settings")

app.yaml:

• Change the runtime to python27 and add threadsafe: true to inform Google App Engine that we are running Python 2.7.
• Change the handlers script to main.application because it is where we define our WSGI.
• Include Django with the corresponding version in the list of libraries because we are going to use it here.
• Set the env_variables - DJANGO_SETTINGS_MODULE to 'Project_Name.settings' so that the application can locate where our Django settings.py is.

application: django-demoapp
version: 1
runtime: python27
api_version: 1
threadsafe: true

handlers:

- url: /.*
script: main.application

libraries:

- name: django
version: "1.4"

env_variables:
DJANGO_SETTINGS_MODULE: 'Project_Name.settings'

STEP 3:Creating your Django application folder:

Creating a Simple Application to show "Hello MicroPyramid"

To create our application, we would proceed with the following steps:

1. Create the application folder
2. Defining the models(if any)
3. Defining the views
4. Defining the templates(if any)
5. Defining the static file folder(if any)
6. Defining the urls

• Create the Application Folder

Create an application folder In the root project folder (together with main.py and manage.py and at the same level with Project_Name folder). A folder with an __init__.py is created as a result.

• Defining the Views

we will define our requierd views here.Here is the simple view that returns a simple Httpresponse to print "Hello MicroPyramid".

from django.http import HttpResponse

def home(request):
    return HttpResponse("hello welcome to google app engine")

• Defining the URLs

We would define a URL to serve the  view home. We first modify the urls.py file in the Project_Name package to direct all requests to your application:

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    (r'^', include('firapp.urls')),
)

We would then create another PyDev module urls (which is just a fileurls.py) in the firapp package to process all requests related to your application:

from django.conf.urls.defaults import *
from firapp.views import home

urlpatterns = patterns('',
    (r'^home/$', home),

)

Our application has been completed! The final folder structure would look like below:

STEP 4:To Test Run Your Application

Our application would run on the bundled Google Appp Engine development server.

1. Right click on the Project Name
2. Select Run As > PyDev: Google App Run
3. According to the console, your application can now be accesed at http://localhost:8080 .
4. Done!

STEP 5:To Deploy Your Application

These steps would deploy your application to the real system.

1. Right click on the Project Name
2. Select PyDev: Google App Engine > Upload
3. Input your email and password in the Send to prompt when prompted.
4. Your application is now available online at http://your-app-id.appspot.com/
5. Done!