wtorek, 13 maja 2008

Witaj świecie w Google App Engine

Instalujemy Google App Engine SDK Od 28 maja 2008 roku można publikować własne serwisy oparte na Google App Engine.

Po zainstalowaniu można sobie wsiąść się za tworzenie prostej aplikacji w Django. Bo GAE opiera się na silniku frameworka Django. Jeżeli komuś zależy na testowaniu aplikacji w klasycznym Django w Polsce to może wypróbować hosting na megiteam.pl przez 15 dni.

Po zainstalowaniu GAE SDK zrobiłem folder C:\appEngine, następnie utworzymy podkatalog witaj i tak do katalogu C:\appengine\witaj dodałem plik konfiguracyjny app.yaml oraz plik skryptu witaj.py

Ponieważ Google App Engine opiera się na WCGI więc trzeba stworzyć plik konfiguracyjny app.yaml Kod pliku app.yaml:


# nazwa aplikacji
application: appengine
#wersja aplikacji
version: 1
#silnik wykonawczy
runtime: python
#wersja silnika wykonawczego
api_version: 1

#lista adresów URL które maja być obsługiwane
handlers:
- url: /.*
script: witaj.py
# powyżej pokazuje że wszystkie adresy maja
# być obsługiwane przez skrypt witaj.py


Pliki powinny być zakodowane w UTF-8. Oto kod w pliku witaj.py

print 'Content-Type: text/plain'
print ''
print 'Witaj świecie'


W folderze C:\appengine\ zrobimy plik wsadowy start.bat z takim kodem

dev_appserver.py -d witaj


Teraz uruchomiamy plik C:\appengine\start.bat, a potem wpisujemy w przeglądarce internetowej http://localhost:8080/.

Tak wygląda pierwszy krok. Drugi krok to uruchomienie panela administracyjnego
http://localhost:8080/_ah/admin/datastore z przeglądarką danych i z interaktywna konsolą.

Następną aplikację zrobimy na bazie Djangoguestbook. Jest ona w folderze
C:\Program Files\Google\google_appengine\demos\guestbook

Robimy folder C:\appengine\djangoguestbook. W tym folderze dodajemy plik konfiguracyjny app.yaml z takim kodem

application: djangoguestbook
version: 1
runtime: python
api_version: 1

handlers:
- url: .*
script: main.py


Tworzymy plik main.py z takim kodem

import os
import sys
# Google App Engine imports.
from google.appengine.ext.webapp import util

# tworzymy własny plik z ustawieniami
from django.conf import settings
settings._target = None
os.environ['DJANGO_SETTINGS_MODULE'] = 'settings'

# Import various parts of Django.
import django.core.handlers.wsgi
import django.core.signals
import django.dispatch.dispatcher
import django.db


def main():
# Wtworzymy aplikacje Django WSGI.
application = django.core.handlers.wsgi.WSGIHandler()

# Uruchamiamy WSGI CGI z ta naszą aplikacja.
util.run_wsgi_app(application)

# konstruktor
if __name__ == '__main__':
main()


Skoro już wiemy co mamy uruchamiać, to następnie trzeba zrobić plik z ustawieniami aplikacji setting.py Oto kod w pliku setting.py:

import os

DEBUG = True
TEMPLATE_DEBUG = DEBUG
APPEND_SLASH = False
LANGUAGE_CODE = 'en-us'
SITE_ID = 1

# If you set this to False, Django will make some
# optimizations so as not
# to load the internationalization machinery.
USE_I18N = True

# URL prefix for admin media -- CSS, JavaScript and images.
# Make sure to use a
# trailing slash.
# Examples: "http://foo.com/media/", "/media/".
ADMIN_MEDIA_PREFIX = '/media/'

# List of callables that know how to import templates from various sources.
TEMPLATE_LOADERS = (
'django.template.loaders.filesystem.load_template_source',
'django.template.loaders.app_directories.load_template_source',
)

MIDDLEWARE_CLASSES = (
'django.middleware.common.CommonMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.doc.XViewMiddleware',
)
# odnośnik do pliku konfiguracyjnego urls.py
ROOT_URLCONF = 'urls'
# odnośnik do folderu w którym jest aplikacja
ROOT_PATH = os.path.dirname(__file__)
#wskazuje na miejsce gdzie są szablony Django
TEMPLATE_DIRS = (
os.path.join(ROOT_PATH, 'templates')
)


Można zauważyć, że odwołujemy się do adresów URL w pliku urls.py, a oto jego kod:

from django.conf.urls.defaults import *

urlpatterns = patterns('',
(r'^$', 'views.index'),
(r'^sign$', 'views.sign'),
)

Widać w nim 2 adresy internetowe: jeden do wyświetlania formularza do wpisywania danych, a drugi do rejestracji, jeśli ktoś nie jest jeszcze zalogowany. Tak więc ustawiliśmy aplikację Django, teraz trzeba zająć się danymi aplikacji czyli jej modelem oraz widokami w szablonach.

Na początek zajmiemy się danymi, które mają być przechowywane w bazie danych na serwerach Google obsługujących GAE. W praktyce lokalny serwer WWW umieszcza swoje dane w plikach. Tworzymy plik model.py

from google.appengine.ext import db

class Post(db.Model):
author = db.UserProperty()
message = db.StringProperty(multiline=True, required=True)
date = db.DateTimeProperty(auto_now_add=True)

Utworzyliśmy tabelę Post z 3 kolumnami (author, message, date) W tej tabeli będą zapisywane dane z formularza i jak odczytywane poprzednie wpisy. Cala logika aplikacji oparta o obsługę widoków jest trzymana w pliku views.py

import datetime

from django.http import HttpResponseRedirect
from django.shortcuts import render_to_response

from google.appengine.api import users

from models import Post
from forms import GuestbookForm

def index(request):
query = Post.gql('ORDER BY date DESC')
form = GuestbookForm()
return render_to_response('index.html',
{'posts': query.fetch(20),
'form': form
}
)

def sign(request):
form = GuestbookForm(request.POST)
if form.is_valid():
post = Post(message=form.clean_data['message'])
if users.GetCurrentUser():
post.author = users.GetCurrentUser()

post.put()

return HttpResponseRedirect('/')


Trzeba zwrócić uwagę na to, że do obsługi zapytań używamy dialektu GQL, który jest podobny do SQL. Nasz aplikacja ma też odrębna klasę wiążącą formularz z danymi czyli klasę GuestbookForm, której kod jest w pliku forms.py

from django import newforms as forms

class GuestbookForm(forms.Form):
message = forms.CharField(label='Sign the Guestbook', widget=forms.Textarea())


Widzimy jak za pomocą modułu Django newforms tworzy się nowe pole formularza, które zostanie użyte w szablonach.

Teraz utworzymy nowy katalog templates. A w katalogu C:\appengine\djangoguestbook\templates dodajemy plik index.html, z takim kodem:



W ten sposób pozostało nam zrobienie skryptu djangoguestbook.bat w katalogu C:\appengine z takim skryptem:

dev_appserver.py -d djangoguestbook


Wystarczy uruchomić ten plik C:\appengine\djangoguestbook.bat
I zobaczyć jak to działa.

1 komentarz:

Gordon_Freeman pisze...

Dzięki, bardzo przydatny post. Niewiele jest informacji na razie o Django + Google apps.
Kilka drobiazgów:
1) Literówka: powinno być settings.py, nie setting.py
2)Literówka powinno być models.py, nie model.py
3) Byłoby miło dostać całośc w postaci zipa (miałem trochę problemów z polskimi literami przy copy-paste, myślę że moje pliki nie są UTF8 jak powinny)
Pozdrawiam i dzięki!