Developing with Google App Engine
The book is ready! Learn how to develop Google App Engine applications, along with
the basics of cloud computing, Platform as a Service software, and how a distributed
database model helps with scalability.
Table of Contents
- Chapter 1: The Google App Engine
- What is the Google App Engine?
- Google App Engine and Cloud Computing
- End-user Apps in the Cloud
- Services on the Cloud
- Google App Engine and the Cloud
- Things You Need to Know Before Starting
- Set Your Development Environment Up
- Hello, World!
- Chapter 2: Exploring the SDK
- Google App Engine and Cloud Computing
- The webapp Framework
- The Sandboxed Python Runtime
- Things That an Application Can't Do
- Things That an Application Can Do
- Putting the Application Together
- Templates or Inline HTML?
- How Many Event Handlers?
- Debugging the App
- Debug Options for the Development Web Server
- The WSGIApplication Debug Option
- Implementing a Debugging Aid
- Interactive Debugging
- Publishing to the Web
- Creating and Registering the App
- Uploading the Application
- Configuring the App to Run from a Custom Domain
- Chapter 3: Design of a Google App Engine Application
- The BookmarksBin Application
- The Data Model
- Wait... No User Table?
- Web Application Architecture
- Pages-to-Components Mapping
- Chapter 4: Building an Application
- webapp Framework
- Are Templates Necessary?
- Does It Work with Other Frameworks?
- Application Layout and webapp Templates
- Templates Hierarchy
- Assembling the Templates and Handlers Together
- Static Files
- Displaying a favicon.ico
- Beautify Your User Interface: CSS
- Downloading the Source Files for the Templates
- Chapter 5: What About the Users?
- Authentication and Google Accounts
- Using GData Services
- User Objects
- What About Specific Domains?
- Getting a Valid User Object and the Users API
- Other Users API Functions
- User Objects in the Datastore
- Configuring Administrative Users
- Defining Admin Users
- Validating Admin Users in the Code
- Chapter 6: Using the Datastore
- Bigtable and the Datastore
- The Datastore API
- Entities and Unique Identifiers
- Disallowed Property Names
- Entity Groups and Transactions
- Implementing Persistence for the BookmarksBin Application
- How to Persist and Query an Entity
- Are All Those Calls to the Datastore Necessary?
- Associating and Manipulating Entities
- One-to-Many Relationships
- Querying and Adding Entities
- Deleting an Entity Using db.Query
- Use Query or GqlQuery?
- The Google Query Language
- Indexing Entities in the Datastore
- How to Specify Conditional Clauses
- Automatic Indexing and Queries
- Defining Indices Manually
- Restrictions on Queries
- Committing Data in Transactions
- Why Use Transactions?
- Using the Transaction API
- Many-to-Many Relationships
- Storing and Deleting Entities
- Chapter 7: Memcache and Session Data
- What is Memcache?
- Using Memcache for Session Data
- Caching the Session Owner
- Implementing Memcache Calls with Entities
- Defining Unique Key Names
- Using Memcache Services Throughout an Application
- Caching Data from Complex Queries
- Invalidating the Cache
- Other Memcache Functions
- Chapter 8: Mail, URL Fetching, and Image Manipulation
- Sending E-mail
- Configuring dev_appserver.py
- Configuring the App Engine to Send Mail
- Sending E-mail From an Application
- Using E-mail Templates
- Sending Multipart E-mail Messages
- Validating E-mail Addresses
- Using the Fetch URL API
- Calling a Web Service
- Fetching a Resource From Another Site
- Manipulating Images
- Required for Development: The Python Imaging Library (PIL)
- PIL Installation Pitfalls
- Using the Images API
- Chapter 9: Managing the App
- Managing Apps
- Accessing the App Management Console
- Creating an Application
- Changing the Application Configuration
- The App Administration Logs
- The Dashboard
- The Run-time Logs
- Off-line Log Analysis
- Logs and Quotas
- Viewing Active Indices
- Viewing and Manipulating Datastore Objects
- The Development Console
