Die Google App Engine ist die Cloud-Lösung von Google. Das Prinzip ist, dass man sich in der Implementierung seiner Applikation an die Vorgaben von Google hält und im Anschluss daran seine Applikation auf die Server von Google hochlädt und dort deren Ressourcen bis zu einem gewissen Grad kostenlos nutzen kann. Darüberhinaus hat man die Möglichkeit gegen Bezahlung weitere Ressourcen zu benutzen. Die Vorgaben sind entweder Python oder Java als Programmiersprache zu verwenden und gewisse Einschränkungen bei der Implementierung zu beachten, wie zum Beispiel keine direkten Filesystemzugriffe zu machen.

Im Gegenzug bekommt man eine API, mit der man auf die von Google zu Verfügung gestellte Infrastruktur zugreifen kann. Daten werden beispielsweise nicht in einer Datenbank gespeichert, sondern im Bigtable-Datastore. Das fühlt sich im ersten Moment an wie eine Datenbank, hat allerdings z.B. die Einschränkung keine Joins zu unterstützen, wodurch man ab und zu dazu gezwungen ist, seine Daten zwecks besserer Performance zu denormalisieren (siehe Artikel How I Learned to Stop Worrying and Love Using a Lot of Disk Space to Scale).

Das Projekt

Eins gleich vorweg: Ich zeige euch hier nicht, wie ihr mit der Google App Engine ein Blog implementiert. Ich glaube es gibt tausende Tutorials, die das tun. In diesem Artikel werde ich mit der Python-Version der Google App Engine eine kleine Applikation implementieren, die von Twitter die neuesten Tweets zieht, die mit dem Hashtag “#confession” getaggt sind. Wie die fertige Applikation einmal aussehen soll, könnt ihr euch hier ansehen: http://confessiontweets.appspot.com.

Ich werde die wichtigsten Features der Google App Engine hier jeweils kurz anreißen – weitere Details findet ihr in der sehr guten, aber leider nicht auf Deutsch verfügbaren Anleitung unter http://code.google.com/appengine/. Ich bitte meine manchmal vielleicht ein bisschen unbeholfene Art, Python zu implementieren zu entschuldigen – eigentlich komme ich aus der Java-Welt und habe die Google App Engine auch dazu benutzt, ein bisschen Python zu lernen.

Der vollständige Source-Code kann hier heruntergeladen werden: ConfessionTweets.zip

Update: Der Source-Code ist jetzt auch auf GitHub zu finden: https://github.com/zustandsforschung/ConfessionTweets.

Die Applikation

Die Applikation selbst basiert auf dem mit der App Engine mitgelieferten webapp Framework. Der Einstiegspunkt in die Applikation ist der folgende Code in der Datei “controller.py“:

application = webapp.WSGIApplication([('/', ConfessionListPage),
                                      ('/c/.*', SingleConfessionPage),
                                      ('/ajax', AjaxConfessionService)])
 
def main():
  run_wsgi_app(application)
 
if __name__ == "__main__":
  main()

Hier wird im Wesentlichen definiert, dass Zugriffe auf “/” auf die Klasse “ConfessionListPage” gemappt werden sollen, Zugriffe auf “/c/.*” – also auf alles was mit “/c/” anfängt auf die Klasse “SingleConfessionPage” und Zugriffe auf “/ajax” auf die Klasse “AjaxConfessionService“.
Für die beiden Klassen, die einzelne Seiten darstellen, habe ich eine gemeinsame Superklasse “Page” geschrieben, die bereits einige Variablen bereitstellt, die von beiden Klassen benötigt werden. Diese Klasse erbt selbst von “webapp.RequestHandler“, und hat damit deren Funktion als Einsprungpunkt in die Applikation.

class Page(webapp.RequestHandler):
  collection = None
  template_values = {}
  template_url = ''
 
  def get(self):
 
    header_path = os.path.join(os.path.dirname(__file__), '../templates/header.html')
    footer_path = os.path.join(os.path.dirname(__file__), '../templates/footer.html')
 
    live = 'localhost' not in self.request.host    
 
    self.template_values.update({ 'header_path' : header_path,
                                 'footer_path' : footer_path,
                                 'live' : live })
 
    self.page_title = 'ConfessionTweets'
 
    self.service()
 
    self.template_values.update({ 'page_title' : self.page_title })
 
    path = os.path.join(os.path.dirname(__file__), self.template_url)
    try:
        self.response.out.write(template.render(path, self.template_values))
    except TemplateDoesNotExist:
        logging.error('Template %s not found!' % self.template_url)

Die Methode “get” wird automatisch vom webapp Framework aufgerufen, wenn eine Seite (per GET-Request) angefragt wurde. Ebenso gibt es Framework-Methoden für POST- oder HEAD-Requests. Dann werden hier einige Werte initialisiert wie beispielsweise der Pfad zu Header und Footer oder der Seitentitel. Dann folgt ein Aufruf der Methode “service“, die wie wir gleich sehen werden von den erbenden Klassen implementiert wird. Abschließend wird die Methode “template.render” aufgerufen, die als Parameter den Pfad zum Template, das die Seite darstellt und ein Dictionary mit den auf dem Template verwendeten Werten bekommt. Innerhalb dieser Methode werden die Werte in das Template geschrieben und das Resultat in die Response ausgegeben.

Die ConfessionListPage

Von dieser Klasse wird nun die Klasse “ConfessionListPage” abgeleitet. Diese Klasse ist für die Listendarstellung der einzelnen Tweets verantwortlich.

class ConfessionListPage(Page):
 
    def service(self):
        self.template_url = '../templates/confession_list.html'
 
        twitter_request = TwitterRequest()
        tweets = twitter_request.get_latest_tweets()
 
        self.template_values.update({ 'tweets' : tweets })

Da alles andere schon in der “Page“-Klasse passiert, muss hier nur noch die “service“-Methode implementiert werden, die von der Page-Klasse aufgerufen wird. Als erstes wird der Pfad zum Template, also der View für diese Seite definiert. Dann wird mit Hilfe der Klasse “TwitterRequest“, die wir gleich implementieren werden, eine Liste von “Tweets” erzeugt, die dann mit der Anweisung “self.template_values.update” an das Template übergeben werden.

Im Template selbst findet sich der folgende Code:

{% include header_path %}
{% for tweet in tweets %}
	<script type="text/javascript" >
		confessions["{{ tweet.key.name }}"] = "{{ tweet.key.name }}";
	</script>
	{% if forloop.first %}
		<div id="{{ tweet.key.name }}" class="first_confession">
			<h3><a href="/c/{{ tweet.key.name }}">{{ tweet.title }}</a></h3>
			<p>Confessed {{ tweet.published|timesince }} ago by <a href="{{ tweet.author_url }}">{{ tweet.author }}</a></p>
		</div>
	{% else %}
		<div id="{{ tweet.key.name }}" class="confession">
			<h3><a href="/c/{{ tweet.key.name }}">{{ tweet.title }}</a></h3>
			<p>Confessed {{ tweet.published|timesince }} ago by <a href="{{ tweet.author_url }}">{{ tweet.author }}</a></p>
		</div>
	{% endif %}
{% endfor %}
	<div id="new_confessions" ></div>
	&darr; <a id="more_button" href="javascript:void(0)" onclick="getConfessions(confessions)" >more</a> &darr;
{% include footer_path %}

Die Templates für die Goolge App Engine werden mit Hilfe des Django-Frameworks erzeugt. Eine Liste von verwendbaren Template-Tags kann man daher der Django-Dokumentation selbst entnehmen: Built-in template tags and filters. Die erste und letzte Zeile binden den Header und Footer entsprechend den in der Klasse “Page” definierten Pfaden ein. Dann wird über die Liste der Tweets mittels “for tweet in tweets” iteriert. Innerhalb dieser Schleife stehen die einzelnen Listenelemente dann in der Variable “tweet” zur Verfügung. Da wir das erste Element dieser Liste speziell formatieren wollen, machen wir von der innerhalb von “for“-Schleifen vorhandenen Variable “forloop.first” gebrauch: Wenn wir das erste Element haben, dann schreiben wir einen anderen Div um die Ausgabe drumherum als für alle anderen Schleifenelemente. Zur Optimierung könnte man sicherlich nur das “class“-Attribut in den if-else-Block setzen, ich habe das hier aber nicht gemacht, um zu verdeutlichen, was mit diesem Template-Tag so alles möglich ist.

Die SingleConfessionPage

Da ich auch in der Lage sein möchte, jeden Tweet unter seiner eigenen URL darstellen zu können, habe ich eine Tweet-Klasse implementiert, die alle Daten aus dem Feed im Datastore speichert:

class Tweet(db.Model):
    published = db.DateTimeProperty(required=True)
    status_url = db.StringProperty(required=True)
    title = db.StringProperty(required=True)
    content = db.StringProperty(required=True)
    profile_image = db.StringProperty()
    author = db.StringProperty(required=True)
    author_url = db.StringProperty(required=True)

Diese Klasse erbt von der vom App-Engine-Framework zur Verfügung gestellten Basisklasse db.Model und hat damit schon eine Menge Funktionen, wie z.B. die get_or_insert-Methode, die innerhalb der __get_tweet_from_xml__-Methode der TwitterRequest-Klasse aufgerufen wird, und die alle übergebenen Daten auch gleich im Datastore speichert, falls es den gleichen Tweet nicht schon gibt:

        tweet = Tweet.get_or_insert(key_name=key_name, published=published, status_url=status_url, title=title, content=content, profile_image=profile_image, author=author, author_url=author_url)

Man muss diese statische Methode nicht benutzen, um ein Objekt im Datastore zu erzeugen, man kann auch einfach den Konstruktor der Klasse verwenden und dann mit der “put“-Methode die Daten persistieren:

	tweet = Tweet(key_name=key_name, published=published, status_url=status_url, title=title, content=content, profile_image=profile_image, author=author, author_url=author_url)
	tweet.put()

Ich identifiziere dabei die einzelnen Tweets anhand der base-64-codierten Status-URL, die mir von Twitter geliefert wird und die pro Tweet eindeutig ist. Diesen Wert verwende ich nicht nur hier als key_name, sondern auch in der URL für die einzelnen Tweets, die dann etwa “/c/eG94T3BhbEFtYW5kYS9zdGF0dXNlcy8yMjgzMTI0MDg5” lautet. Eine solche URL wird dann vom Controller auf die get-Methode der Klasse SingleConfessionPage gemappt:

class SingleConfessionPage(Page):
 
    def service(self):
        self.template_url = '../templates/confession.html'
 
        match = re.match("/c/(.*)", self.request.path)
        if match is not None:
            key_name = urllib.unquote(match.group(1))
 
        tweet = Tweet.get_by_key_name(key_name)
 
        if tweet is None:
            self.redirect('/')
            return
 
        self.page_title += ' - A confession by ' + tweet.author + ' made ' + timesince.timesince(tweet.published) + ' ago ' 
 
        self.template_values.update({ 'tweet' : tweet })

Dort lese ich den Key wieder aus der URL aus, und hole dann den entsprechenden Tweet per “Tweet.get_by_key_name(key_name)” aus dem Datastore und übergebe ihn ans Template, das dann eine vereinfachte Variante von dem für die ConfessionListPage ist:

	{% include header_path %}
			<div id="{{ tweet.key.name }}" class="first_confession">
				<h3><a href="{{ tweet.status_url }}">{{ tweet.title }}</a></h3>
				<p>Confessed {{ tweet.published|timesince }} ago by <a href="{{ tweet.author_url }}">{{ tweet.author }}</a></p>
			</div>
	{% include footer_path %}

Der TwitterRequest-Service

Diese Klasse führt in der Methode “get_latest_tweets” den eigentlichen Request an Twitter aus, mit dem die Applikation ihre Daten erhält. Dabei wird in der Methode “__get_xml__” mittels der urlfetch-Methode des Frameworks von der Twitter-Suche ein XML geholt und in eine DOM-Datenstruktur überführt:

class TwitterRequest:
 
    def __init__(self):
        self.request_url = 'http://search.twitter.com/search.atom?q=%23confession&rpp=5'
 
    def get_latest_tweets(self, page='1'):
        tweets = []
 
        self.request_url += '&page=' + page;
        logging.debug('Requesting %s' % self.request_url)
 
        twitter_response = self.__get_xml__(self.request_url)                
 
        if twitter_response is None:
            logging.warning('Trying again...')
            twitter_response = self.__get_xml__(self.request_url)
 
        if twitter_response is None:
            return None 
 
        for entry in twitter_response.getElementsByTagName('entry'):
            tweets.append(self.__get_tweet_from_xml__(entry))
 
        return tweets
 
    def __get_xml__(self, request_url):
        try:
            result = urlfetch.fetch(request_url)
        except DownloadError:
            logging.error('Could not contact webservice.')
            return None
        if result.status_code == 200:
            return parseString(result.content)
 
    def __get_tweet_from_xml__(self, entry):
        published_string = entry.getElementsByTagName('published')[0].firstChild.data
        published = datetime.datetime.strptime(published_string, "%Y-%m-%dT%H:%M:%SZ")        
 
        status_url = entry.getElementsByTagName('link')[0].getAttribute('href')
        title = entry.getElementsByTagName('title')[0].firstChild.data
        content = entry.getElementsByTagName('content')[0].firstChild.data
        author = entry.getElementsByTagName('author')[0].getElementsByTagName('name')[0].firstChild.data
        author_url = entry.getElementsByTagName('author')[0].getElementsByTagName('uri')[0].firstChild.data
        profile_image = entry.getElementsByTagName('link')[1].getAttribute('href')
 
        key_name = base64.standard_b64encode(status_url[len('http://twitter.com/'):len(status_url)])
        tweet = Tweet.get_or_insert(key_name=key_name, published=published, status_url=status_url, title=title, content=content, profile_image=profile_image, author=author, author_url=author_url)
        return tweet

Dann rufe ich für jeden “entry“-Knoten in diesem XML die “__get_tweet_from_xml__“-Methode auf, die die relevanten Daten aus dem Knoten ausliest und letztendlich mit der “get_or_insert“-Methode von db.Model die Daten im Datastore abspeichert. Die “get_latest_tweets“-Methode gibt schließlich eine Liste mit den einzelnen Tweet-Objekten, die aus dem XML des Webservice abgerufen wurden zurück.

Der AjaxConfessionService

Ich möchte auf der Startseite auch die Möglichkeit bieten, durch die Liste der Tweets blättern zu können. Zu diesem Zweck benutze ich eine AJAX-Schnittstelle, um beim Klick auf den more-Link weitere Tweets von Twitter abzuholen und einzublenden. Das JavaScript schickt den Request an den Pfad “/ajax“, der auf die Klasse “AjaxConfessionService” gemappt wird. Auch diese Klasse erbt wieder von “webapp.RequestHandler” und implementiert die “get“-Methode:

class AjaxConfessionService(webapp.RequestHandler):
 
    def get(self):
        page = self.request.get('page', '');
 
        twitter_request = TwitterRequest()
        tweets = twitter_request.get_latest_tweets(page)
        self.response.out.write('{ "confessions": {')
        for tweet in tweets:
            self.response.out.write('"' + tweet.key().name() + '" : { ')
            self.response.out.write('"title" : "' + tweet.title.replace('"', '\\"') + '", ')
            self.response.out.write('"author" : "' + tweet.author.replace('"', '\\"') + '", ')
            self.response.out.write('"author_url" : "' + tweet.author_url.replace('"', '\\"') + '", ')
            self.response.out.write('"published" : "' + timesince.timesince(tweet.published) + '"')
            self.response.out.write('}')
            if tweet is not tweets[-1]:
                self.response.out.write(', ')
        self.response.out.write('}}')

Hier werden auch wieder die aktuellsten Tweets der entsprechenden Ergebnisseite bei Twitter abgeholt. Hier habe ich kein Template verwendet, sondern wandle die resultierenden Tweet-Objekte direkt in einen JSON-String um, den ich in die Response schreibe. Auf der Clientseite liest jetzt mein JavaScript wiederum das JSON aus und konstruiert HTML, das in die Seite eingefügt wird.

Konfiguration

Damit die Applikation überhaupt in der Google-App-Engine lauffähig ist, braucht sie noch eine Konfiguration. Diese wird in der Markup-Language YAML geschrieben und landet in einer Datei “app.yaml” im Wurzelverzeichnis der Applikation:

application: confessiontweets
version: 1
runtime: python
api_version: 1
 
handlers:
- url: /robots.txt
  static_files: robots.txt
  upload: robots.txt
 
- url: /css
  static_dir: css
  expiration: 1h
 
- url: /images
  static_dir: images
  expiration: 1d
 
- url: /js
  static_dir: js
  expiration: 60s
 
- url: /.*
  script: confession/controller.py

Zuoberst muss man das Label seiner Applikation deklarieren, so wie man es später auch in der Verwaltung der App-Engine angibt. Dann kommt die Version der Applikation und die Runtime – in unserem Fall Python. Die API-Version ist aktuell noch immer 1.

Unterhalb dieser Sektion definiert man nun einzelne Handler für verschiedene Files. Man kann keine der hochgeladenen Files direkt aufrufen, daher definiere ich hier zunächst die Position der robots.txt und der Verzeichnisse für CSS, Bilder und JavaScript, jeweils mit einer unterschiedlichen Cache-Expiry-Zeit.

Als letztes definiere ich noch, dass alles, was bisher nicht gemappt werden konnte an das Skript “/confession/controller.py” delegiert werden soll.

Und jetzt ins Internet damit…

Um das ganze wirklich ins Netz zu bringen, muss man sich mit einem Google-Account auf der Seite anmelden und bekommt dann einen Freischaltcode per SMS zugeschickt. Damit kann man dann bis zu 10 Google-App-Engine-Applikationen hosten lassen. Im Web-Interface muss ich jetzt zunächst eine Applikation mit dem gleichen Label wie in der Konfiguration unter “application” angegeben anlegen:

Da diese Applikations-Ids über die gesamte Google-App-Engine eindeutig sind, muss man unter Umständen ein bisschen rumprobieren, bis man einen Namen gefunden hat, der noch verfügbar ist.

Der Upload der Applikation erfolgt dann über ein mitgeliefertes Python-Skript:

	python appcfg.py update

Man wird noch nach Mailadresse und Passwort gefragt und kann anschließend sein Werk im Internet bewundern.

Wenn man jetzt noch ein bisschen Styling und eine nette Hintergrundgrafik hinzufügt, erhält man bereits ein nettes kleines Mashup. Ich habe der ganzen Sache noch ein paar nette Animationseffekte spendiert und im Endergebnis sieht das ganze dann folgendermaßen aus:

Fazit

Natürlich hat man bei Verwendung der Google-App-Engine einen gewissen Vendor-Lock-In-Effekt, vor allem durch die Verwendung des Datastore statt einer Datenbank. Auf der anderen Seite bietet die GAE eine interessante Möglichkeit, mit einer neuen Idee schnell und günstig – weil kostenlos – Live zu gehen und erst wenn die Applikation ein gewisses Maß an Usern erreicht hat muss man sich über Rentabilität überhaupt Gedanken machen.

Außer dem hier beschriebenen Mini-Mashup habe ich noch meine Video-Verwaltungsapplikation “veedemus – movie collection” mit der Google App Engine implementiert. Dort kann man schon eher sehen, dass nicht nur Spielereien, sondern auch komplexe Applikationen mit der GAE umsetzbar sind.