Google App Engine：自动扩展的Web应用平台

5星 · 超过95%的资源需积分: 9 121 浏览量更新于2024-07-26 1 收藏 10.92MB PDF 举报

Google App Engine（GAE）是Google提供的一项云平台服务，专为构建、部署和管理Web应用而设计。它是一种基于云计算的应用托管服务，支持实时动态应用程序，特别适合那些需要处理大量并发用户的场景。GAE的核心优势在于自动扩展能力，当用户量增加时，会自动分配更多的资源来保证性能，而开发者无需过多关注资源管理。 GAE主要由三个部分组成：一是应用实例（Application Instances），即运行用户请求的服务实例，它们在后台持续运行，处理用户的请求；二是可扩展的数据存储（Scalable Data Storage），这包括Google Cloud Datastore，一种分布式、无模式的数据库，能够轻松扩展存储容量以适应数据增长；三是可扩展的服务（Scalable Services），如电子邮件服务、身份验证服务等，这些都是GAE内置的服务，可以帮助开发者快速构建功能。编程GoogleAppEngine，第二版的作者Dan Sanderson深入探讨了如何利用这个平台开发高效、可扩展的Web应用。书中涵盖了GAE的基础概念、API使用、部署策略以及与Google其他服务（如Google Apps、Google Cloud Storage）的集成。使用GAE的好处在于成本效益，仅需为实际使用的资源付费，这对于初创企业和小型项目来说是一大优点。此外，GAE还提供了许多特性，如任务队列（Task Queue）、URL路由、安全性措施（如HTTPS支持）、以及版本管理，使得开发者可以更专注于应用逻辑，而不是底层基础设施的运维。同时，GAE支持多种编程语言，如Python、Java，以及Node.js等，开发者可以根据自身熟悉的语言进行开发。 GAE的更新历史可见其持续优化和完善，第二版于2012年发布，对于想要学习或使用GAE的人来说，它不仅是一份技术指南，也是一份宝贵的实践经验分享。Google App Engine为开发者提供了一个强大的工具，助力他们在互联网上快速构建和部署高性能的Web应用。

Preface

On the Internet, popularity is swift and fleeting. A mention of your website on a popular

blog can bring 300,000 potential customers your way at once, all expecting to find out

who you are and what you have to offer. But if you’re a small company just starting

out, your hardware and software aren’t likely to be able to handle that kind of traffic.

Chances are, you’ve sensibly built your site to handle the 30,000 visits per hour you’re

actually expecting in your first 6 months. Under heavy load, such a system would be

incapable of showing even your company logo to the 270,000 others that showed up

to look around. And those potential customers are not likely to come back after the

traffic has subsided.

The answer is not to spend time and money building a system to serve millions of visitors

on the first day, when those same systems are only expected to serve mere thousands

per day for the subsequent months. If you delay your launch to build big, you miss the

opportunity to improve your product by using feedback from your customers. Building

big before allowing customers to use the product risks building something your cus-

tomers don’t want.

Small companies usually don’t have access to large systems of servers on day one. The

best they can do is to build small and hope meltdowns don’t damage their reputation

as they try to grow. The lucky ones find their audience, get another round of funding,

and halt feature development to rebuild their product for larger capacity. The unlucky

ones, well, don’t.

But these days, there are other options. Large Internet companies such as Amazon.com,

Google, and Microsoft are leasing parts of their high-capacity systems by using a pay-

per-use model. Your website is served from those large systems, which are plenty ca-

pable of handling sudden surges in traffic and ongoing success. And since you pay only

for what you use, there is no up-front investment that goes to waste when traffic is low.

As your customer base grows, the costs grow proportionally.

Google App Engine, Google’s application hosting service, does more than just provide

access to hardware. It provides a model for building applications that grow automati-

cally. App Engine runs your application so that each user who accesses it gets the same

experience as every other user, whether there are dozens of simultaneous users or

thousands. The application uses the same large-scale services that power Google’s ap-

plications for data storage and retrieval, caching, and network access. App Engine takes

care of the tasks of large-scale computing, such as load balancing, data replication, and

fault tolerance, automatically.

The App Engine model really kicks in at the point where a traditional system would

outgrow its first database server. With such a system, adding load-balanced web servers

and caching layers can get you pretty far, but when your application needs to write data

to more than one place, you have a hard problem. This problem is made harder when

development up to that point has relied on features of database software that were never

intended for data distributed across multiple machines. By thinking about your data in

terms of App Engine’s model up front, you save yourself from having to rebuild the

whole thing later.

Often overlooked as an advantage, App Engine’s execution model helps to distribute

computation as well as data. App Engine excels at allocating computing resources to

small tasks quickly. This was originally designed for handling web requests from users,

where generating a response for the client is the top priority. With App Engine’s task

queue service, medium-to-large computational tasks can be broken into chunks that

are executed in parallel. Tasks are retried until they succeed, making tasks resilient in

the face of service failures. The App Engine execution model encourages designs opti-

mized for the parallelization and robustness provided by the platform.

Running on Google’s infrastructure means you never have to set up a server, replace a

failed hard drive, or troubleshoot a network card. And you don’t have to be woken up

in the middle of the night by a screaming pager because an ISP hiccup confused a service

alarm. And with automatic scaling, you don’t have to scramble to set up new hardware

as traffic increases.

Google App Engine lets you focus on your application’s functionality and user expe-

rience. You can launch early, enjoy the flood of attention, retain customers, and start

improving your product with the help of your users. Your app grows with the size of

your audience—up to Google-sized proportions—without having to rebuild for a new

architecture. Meanwhile, your competitors are still putting out fires and configuring

databases.

With this book, you will learn how to develop applications that run on Google App

Engine, and how to get the most out of the scalable model. A significant portion of the

book discusses the App Engine scalable datastore, which does not behave like the re-

lational databases that have been a staple of web development for the past decade. The

application model and the datastore together represent a new way of thinking about

web applications that, while being almost as simple as the model we’ve known, requires

reconsidering a few principles we often take for granted.

This book introduces the major features of App Engine, including the scalable services

(such as for sending email and manipulating images), tools for deploying and managing

applications, and features for integrating your application with Google Accounts and

xvi | Preface

Google Apps using your own domain name. The book also discusses techniques for

optimizing your application, using task queues and offline processes, and otherwise

getting the most out of Google App Engine.

Using This Book

App Engine supports three technology stacks for building web applications: Java,

Python, and Go (a new programming language invented at Google). The Java technol-

ogy stack lets you develop web applications by using the Java programming language

(or most other languages that compile to Java bytecode or have a JVM-based inter-

preter) and Java web technologies such as servlets and JSPs. The Python technology

stack provides a fast interpreter for the Python programming language, and is compat-

ible with several major open source web application frameworks such as Django. The

Go runtime environment compiles your Go code on the server and executes it at native

CPU speeds.

This book covers concepts that apply to all three technology stacks, as well as important

language-specific subjects for Java and Python. If you’ve already decided which lan-

guage you’re going to use, you probably won’t be interested in information that doesn’t

apply to that language. This poses a challenge for a printed book: how should the text

be organized so information about one technology doesn’t interfere with information

about the other?

Foremost, we’ve tried to organize the chapters by the major concepts that apply to all

App Engine applications. Where necessary, chapters split into separate sections to talk

about specifics for Python and Java. In cases where an example in one language illus-

trates a concept equally well for other languages, the example is given in Python. If

Python is not your language of choice, hopefully you’ll be able to glean the equivalent

information from other parts of the book or from the official App Engine documenta-

tion on Google’s website.

As of this writing, the Go runtime environment is released as an “experimental” feature,

and the API may be changing rapidly. The language has stabilized at version 1, so if

you’re interested in Go, I highly recommend visiting the Go website and the Go App

Engine documentation. We are figuring out how to best add material on Go to a future

edition of this book.

The datastore is a large enough subject that it gets multiple chapters to itself. Starting

with Chapter 5, datastore concepts are introduced alongside Python and Java APIs

related to those concepts. Python examples use the ext.db data modeling library, and

Java examples use the Java datastore API, both provided in the App Engine SDK. Some

Java developers may prefer a higher-level data modeling library such as the Java Per-

sistence API, which supports fewer features of the datastore but can be adapted to run

on other database solutions. We discuss data modeling libraries separately, in Chap-

ter 9 for Python, and in Chapter 10 for Java.

Preface | xvii

This book has the following chapters:

Chapter 1, Introducing Google App Engine

A high-level overview of Google App Engine and its components, tools, and major

features.

Chapter 2, Creating an Application

An introductory tutorial for both Python and Java, including instructions on setting

up a development environment, using template engines to build web pages, setting

up accounts and domain names, and deploying the application to App Engine. The

tutorial application demonstrates the use of several App Engine features—Google

Accounts, the datastore, and memcache—to implement a pattern common to

many web applications: storing and retrieving user preferences.

Chapter 3, Configuring an Application

A description of how App Engine handles incoming requests, and how to configure

this behavior. This introduces App Engine’s architecture, the various features of

the frontend, app servers, and static file servers. The frontend routes requests to

the app servers and the static file servers, and manages secure connections and

Google Accounts authentication and authorization. This chapter also discusses

quotas and limits, and how to raise them by setting a budget.

Chapter 4, Request Handlers and Instances

A closer examination of how App Engine runs your code. App Engine routes in-

coming web requests to request handlers. Request handlers run in long-lived con-

tainers called instances. App Engine creates and destroys instances to accommo-

date the needs of your traffic. You can make better use of your instances by writing

threadsafe code and enabling the multithreading feature.

Chapter 5, Datastore Entities

The first of several chapters on the App Engine datastore, a scalable object data

storage system with support for local transactions and two modes of consistency

guarantees (strong and eventual). This chapter introduces data entities, keys and

properties, and Python and Java APIs for creating, updating, and deleting entities.

Chapter 6, Datastore Queries

An introduction to datastore queries and indexes, and the Python and Java APIs

for queries. The App Engine datastore’s query engine uses prebuilt indexes for all

queries. This chapter describes the features of the query engine in detail, and how

each feature uses indexes. The chapter also discusses how to define and manage

indexes for your application’s queries. Recent features like query cursors and pro-

jection queries are also covered.

Chapter 7, Datastore Transactions

How to use transactions to keep your data consistent. The App Engine datastore

uses local transactions in a scalable environment. Your app arranges its entities in

units of transactionality known as entity groups. This chapter attempts to provide

a complete explanation of how the datastore updates data, and how to design your

xviii | Preface

剩余537页未读，继续阅读

fluber

粉丝: 0
资源: 16

Google App Engine：自动扩展的Web应用平台

sprunge:适用于Google Appengine的命令行pastebin

Google App Engine 最新版 (google_appengine_1.9.91.zip)

在 google app engine 上搭建自己的在线代理

google app engine

AppEngine：Google App Engine代码

appengine:Google AppEngine 代理应用程序

learn-appengine:Google App Engine 使用入门

wtforms-appengine:适用于Google App Engine的WTForms集成

appengine-publisher:Google AppEngine 的 PubSubHubbub 发布者示例

appengine-subscriber:Google AppEngine 的 PubSubHubbub 订阅者示例

最新资源