# Glossary - Google App Engine - Google Code

English ▼
Skip to page content Skip to main navigation
e.g. "templates" or "datastore"

# Glossary

This page defines App Engine-specific terms and concepts.

A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z

## A

Administration Console
  A web-based user interface for managing your application. You can use it to create new apps, change which version of your application is serving, and perform tasks such as viewing error logs and analyzing client requests. You can also use the administration console to administer your datastore, manage task queues, and test new versions of your app.
Ancestor
  A datastore entity that is a parent of another entity.
Ancestor Query
  A query over a single entity group using the key of a parent entity. Ancestor query results are strongly consistent in the high replication datastore.
Apache Ant
  A third-party Java library used to build and test your App Engine applications. While Apache Ant is not a Google tool, App Engine's Java SDK includes a set of Ant macros to perform common App Engine development tasks, including starting your development server and uploading your apps to App Engine.
AppCfg Command Line Tool
  The appcfg.py command uploads new versions of your code, configuration, and static files for your application to App Engine. You can also use this command to manage datastore indexes and download log data.
appengine-web.xml
  `appengine-web.xml` is a required configuration file for Java applications. At a minimum, this file specifies the application ID and version.
Application ID
  Your application ID is a unique name that you choose when you create your application.
Appspot
  Your application serves from `http://your_app_id.appspot.com` by default.
Appstats
  The Java and Python SDKs each include a suite of tools called appstats for measuring the performance of your application. Appstats integrates with your application to record events, and it provides a web-based administrative interface for browsing statistics.
app.yaml
  Python applications must use app.yaml is the main configuration file for Python applications. Java applications can use either app.yaml or web.xml.
App Engine
  App Engine is Google's highly scalable platform for hosting web services. It consists of runtimes and SDKs for Java, Python, and Go programming languages.
App Engine SDK
  The App Engine Software Development Kits (SDKs) for Java, Python, and Go each include a web server application that emulates all of the App Engine services on your local computer. Each SDK includes all of the APIs and libraries available on App Engine. The web server also simulates the secure sandbox environment, including checks for attempts to access system resources disallowed in the App Engine runtime environment. Each SDK also includes a tool to upload your application to App Engine.
Asynchronous Datastore
  The asynchronous datastore API allows you to make parallel, non-blocking calls to the datastore and to retrieve the results of these calls at a later point in the handling of the request. This API is available in both Java and Python.
Authentication
  App Engine applications can authenticate users using any one of three methods: Google Accounts, accounts on your own Google Apps domains, or OpenID identifiers. An application can detect whether the current user has signed in, and can redirect the user to the appropriate sign-in page. With a signed in user, the application can access the user's email address (or OpenID identifier if your application is using OpenID). The application can also detect whether the current user is an administrator, making it easy to implement admin-only areas of the app.

Back to top

## B

Backend Instance
  An instance that is exempt from request deadlines and has access to more memory and CPU than normal instances. Its duration is determined by your configuration with limited scaling based on your settings. App Engine provides backends for applications that need faster performance, large amounts of addressable memory, and continuous or long-running background processes.
backends.xml
  A file that Java applications can use to configure backends. Java applications can also use `backends.yaml`.
backends.yaml
  Python applications must use backends.yaml to configure backends. Java applications may use either backends.yaml or backends.xml.
Billable Quota
  Billable quotas are resource maximums set by you, the application's administrator, to prevent the cost of your application from exceeding your budget. Every application gets an amount of each billable quota for free. You can increase billable quotas for your application by enabling billing, setting a daily budget, then allocating the budget to the quotas. Google charges you for only the resources that your application uses, and only for the amount of resources used above the free quota thresholds.
Blob
  An acronym for "Binary Large Object". A blob may refer to a large data object in the blobstore API, or it may refer to a property type in the datastore API.
Blobstore API
  Supported in Java, Python, and Go, the blobstore API allows your application to serve data objects called blobs, which are much larger than the size allowed for objects in the datastore service.

Back to top

## C

Capabilities API
  Supported in Java, Python, and Go, with the capabilities API, your application can detect outages and scheduled downtime for specific API capabilities. With this information, you can disable the unavailable capability in your application before it impacts your users.
CGI
  See common gateway interface.
Channel API
  Supported in Java, Python, and Go, the channel API creates a persistent connection between your application and Google servers, allowing your application to send messages to JavaScript clients in real time without the use of polling. This is useful for applications designed to update users about new information immediately. Some example scenarios are collaborative applications, multi-player games, or chat rooms.
Common Gateway Interface (CGI)
  The common gateway interface (CGI) is a standard that defines how web server software can delegate the generation of web pages to a stand-alone application. App Engine uses the CGI standard with the Python runtime to communicate the request data to the handler, and receive the response.
Concurrency
  Concurrency occurs when systems execute computations simultaneously, and these computations interact with each other.
Concurrency Control
  Concurrency control ensures that systems generate correct results for concurrent operations while getting those results as quickly as possible.
Concurrent Request
  App Engine can send multiple requests in parallel to a web server.
Configuration File
  All App Engine applications require a configuration file to set important details like the application ID and version number. Python applications must use app.yaml as their main configuration file. Java applications can use either app.yaml or web.xml.
CPU Time
  CPU time is the amount of time for which a central processing unit (CPU) in a Google data center processes requests from your application.
Cron Job
  The App Engine cron service allows users to create tasks to run at regular intervals.
cron.xml
  For your Java application, a configuration file called `cron.xml` or `cron.yaml` file controls scheduled tasks. It consists of a number of job definition pairs, each containing a `<url>` tag and a `<schedule>` tag.
cron.yaml
  For your Python application, a configuration file called `cron.yaml` file controls scheduled tasks. It consists of a number of job definition pairs, each containing a `url` field and a `schedule` field.
Custom Domain
  To serve your application on another domain besides appspot.com, you need to register your domain with Google apps.

Back to top

## D

Datastore
  Google App Engine uses a datastore to distribute, replicate, and load balance your data through a simple API. It also includes a powerful query engine and processes transactions.
Datastore Blob Property
  For datastore storage, you must use the blob property value type to store unencoded byte strings longer than 500 bytes. Blobs stored in this way are not indexed.
Datastore Call Deadline
  The datastore call deadline is the maximum amount of time your API call to the datastore can take. If your API call does not complete by the deadline, the datastore aborts with an error and returns control to your application.
Datastore Index
  Every datastore query uses an index, a table containing the results for the query in the desired order.
Datastore Index Configuration
  The App Engine datastore uses indexes for every query your application makes. The datastore updates these indexes whenever an entity changes, so the datastore quickly returns results to you when your application makes a query. To do this, the datastore needs to know in advance which queries the application will make. You specify which indexes your application needs in a configuration file.
Denial of Service Protection Service
  The App Engine denial of service (DoS) protection service allows you to protect your application from running out of quota when subjected to denial of service attacks or similar forms of abuse. You can blacklist IP addresses or subnets, and the service drops requests routed from those addresses or subnets before App Engine calls your code.
Deployment Descriptor
  Java web applications use a deployment descriptor file called `web.xml` to determine how URLs map to servlets, which URLs require authentication, and other information.
dev_appserver
  See development web server.
Development Console
  The development web server includes a console web application. The console in Java and Python, both let you browse the local datastore, but each console has also unique features.
Development Web Server
  The App Engine SDK includes a development web server for testing your application on your computer. In Java, the development web server simulates the App Engine Java runtime environment and all of its services, including the datastore. In Python, the development web server simulates your application running in the App Engine Python runtime environment; this simulated environment enforces some sandbox restrictions such as restricted system functions and Python module imports.
dev_appserver.py
  A command-line tool for interacting with the Python development server.
dev_appserver.sh
  A command-line tool for interacting with the Java development server.
Django
  Django is a high-level Python web framework that encourages rapid development.
DoS
  See denial of service protection service.
dos.xml
  A configuration file allowing Java applications to configure denial of service protection. Java applications may also use dos.yaml.
dos.yaml
  A configuration file allowing Python or Java applications to configure denial of service protection.

Back to top

## E

Eclipse
  Eclipse is an open-source integrated development environment (IDE) for Java developers. Java developers primarily use Eclipse, but it also supports other languages (including Python) because of its robust set of plugins.
Entity
  The datastore writes data in objects known as entities, and each entity has a key that identifies the entity.
Entity Group
  An entity group is a set of entities whose keys all specify the same root entity.
Experimental
  Features marked “Experimental” are innovative new features that we are developing rapidly. The App Engine SLA does not support these features, and Google may make backwards-incompatible changes to them at any time.
Exploding Index
  Custom indexes that refer to multiple properties with multiple values can get very large with only a few values. To completely record such properties, the index table must include a row for every permutation of the values of every property for the index. Because exploding indexes contain so many values, they increase the amount of datastore CPU time that your application uses. The SDK attempts to detect exploding indexes and suggests an alternative, but in some cases you may require custom configuration. See Big Entities and Exploding Indexes for more information.

Back to top

## F

Filter Class
  A filter is a class that acts on a request like a servlet, but may allow the handling of the request to continue with other filters or servlets.
Frontend Instance
  An instance running your code and scaling dynamically based on the incoming requests but limited in how long a request can run

Back to top

## G

Google App Engine Launcher
  The Python SDK for Windows and Mac includes Google App Engine launcher, an application that runs on your computer and provides a graphical interface that simplifies many common App Engine development tasks.
Google App Engine SDK
  With App Engine, you can build web applications using either Java, Python, or Go programming languages. Your applications runs in a secured “sandbox” environment to isolate your application from security threats.
Google Plugin for Eclipse
  With the Google Plugin for Eclipse, you create, test, and upload your Java App Engine applications from within Eclipse. The Google Plugin for Eclipse also makes it easy to develop applications using Google Web Toolkit (GWT) to run on App Engine or in any other environment.
Google Web Toolkit (GWT)
  Google Web Toolkit (GWT) is a free, open source development toolkit for building and optimizing complex browser-based applications. Its goal is to enable productive development of high-performance web applications without the developer having to be an expert in browser quirks, XMLHttpRequest, and JavaScript.
Go Programming Language
  By being expressive, concise, clean, and efficient, the Go programming language is an open source project to make programmers more productive. Its concurrency mechanisms make it easy to write programs optimized for multicore and networked machines while its novel type system enables flexible and modular program construction. Go compiles quickly to machine code, but it has the convenience of garbage collection and the power of run-time reflection.
GWT
  See Google Web Toolkit.

Back to top

## H

High Replication Datastore (HRD)
  The HRD is a highly available, highly reliable storage solution. It remains available for reads and writes during planned downtime and is extremely resilient in the face of catastrophic failure. The high replication datastore provides higher availability for your reads and writes because it stores data synchronously in multiple data centers.

Back to top

## I

Index
  Every datastore query uses an index, a table containing the results for the query in the desired order. The datastore maintains an index for every query an application intends to make. As the entities change, the datastore updates the indexes with the correct results. When the application executes a query, the datastore fetches the results directly from the corresponding index.
index.yaml
  A configuration file for datastore indexes available for Python and Java applications.
Instance
  A small virtual environment to run your code with a reserved amount of CPU and Memory.

Back to top

## J

Java ARchive (JAR)
  A Java ARchive combines multiple files into one usually to distribute Java applications or Java libraries over the Internet.
Java Data Object (JDO)
  Java Data Objects (JDO) is a standard interface for storing objects containing data into a database. The standard defines interfaces for annotating Java objects, retrieving objects with queries, and interacting with a database using transactions. An application that uses the JDO interface can work with different kinds of databases without using any database-specific code, including relational databases, hierarchical databases, and object databases.
Java Development Server
  The App Engine Java SDK includes a development web server for testing your application on your computer. The development web server simulates the App Engine Java runtime environment and all of its services, including the datastore. The Google Plugin for Eclipse can run the server in the Eclipse debugger. You can also run the development server from the command line.
Java Persistence API (JPA)
  Java persistence API (JPA) is a standard interface for storing objects containing data into a relational database. The standard defines interfaces for annotating Java objects, retrieving objects using queries, and interacting with a database using transactions.
Java Runtime Environment (JRE)
  App Engine applications can be implemented using the Java programming language, and other languages that use the java virtual machine. The App Engine Java runtime environment includes the Java 6 JVM and interfaces to the App Engine services that conform to industry standards, such as servlets and JDO/JPA. You can also use raw APIs to the services for implementing other interfaces.
Java Servlet
  A servlet is a Java programming language class used to extend the capabilities of servers that host applications accessed via a request-response programming model. Although servlets can respond to any type of request, you commonly use them to extend the applications hosted by web servers. When App Engine receives a web request from your application, it invokes the servlet that corresponds to the URL as described in your application's deployment descriptor. It uses the Java servlet API to provide the request data to the servlet, and accept the response data.
JRE Class White List
  The list of available Java classes in the Java standard library to develop App Engine applications.

Back to top

## K

Key
  A key is a unique identifier for each entity in the datastore. Keys consist of a kind, a unique name assigned either by the app or the datastore, and an optional ancestor path that specifies a parent entity. If an ancestor path is present, the entity belongs to an entity group defined by that parent.
Kind
  Each datastore entity is of a particular kind, which is simply a name specified by the application. A kind categorizes the entity for the purpose of queries. For example, a human resources application might represent each employee at a company with an entity of the kind “Employee”. Unlike rows in a table, two entities of the same kind need not have the same properties. If required, an application can establish such a restriction in its data model.
Kindless Query
  In a kindless query, App Engine datastore returns all entites matching query constraints regardless of kind.
Kindless Ancestor Query
  In a kindless ancestor query, App Engine datastore returns all ancestors to a given entity in a query regardless of kind.

Back to top

## L

Back to top

## M

Mail
  An App Engine API to send email from the application.
MapReduce
  A computing model developed by Google to do efficient distributed computing over large data sets. Input data values in the MapReduce model are processed in three stages:
  1. Values are mapped (assigned lookup keys) and stored in intermediate storage.
  2. The resulting key-value pairs are shuffled (collated by key).
  3. The collated values are reduced (manipulated to yield desired results).
Master/Slave Datastore
  The master-slave replication system asynchronously replicates data to other data centers as you write it. Since only one datacenter is the master for writing at any given time, this option offers strong consistency for all reads and queries, but your data may be temporarily unavailable during data center issues or planned downtime. The master/slave datastore is suitable only for applications that do not require high availability of data, can tolerate spikes in datastore latency, or need to incur the lowest possible serving cost.
Maximum Pending Latency
  The maximum length of time a request must wait in the pending request queue before App Engine starts a new instance to serve it. A higher value means users may wait longer for your application to serve their request; a lower value means users don't have to wait as long, but your application may cost more to run. App Engine can automatically determine the maximum pending latency based on recent request data, or you can adjust this setting manually to trade off latency for cost.
Memcache
  A distributed in-memory data cache to speed up common datastore queries.
Metadata Queries
  Metadata queries construct expressions that return metadata from your datastore about namespaces, kinds, and properties. The queries return your metadata in dynamically generated entities. The most common use for metadata is to implement, for example, back-end administrative functions and meta-programming environments.
Minimum Pending Latency
  The minimum amount of time a request can wait in the pending queue before being served by an instance. In the Applications Settings of the administration console, the minimum pending latency slider allows you to specify a minimum pending latency, or you can let App Engine choose it for you automatically based on request volume.
Multitenancy
  Multitenancy is the name given to a software architecture in which one instance of an application, running on a remote server, serves many client organizations (also known as tenants).
M/S Datastore
  See master/slave datastore.

Back to top

## N

Namespaces API
  The namespaces API in Google App Engine allows you to segregate entities into specific namespaces.

Back to top

## O

OAuth
  OAuth is a protocol that allows users to grant a third party limited permission to access a web application, without sharing their credentials (username and password) with the third party. The third party can be a web application, or any other application with the capability of invoking a web browser for the users, such as a desktop application or an application running on a smart phone.
On-Demand Instances
  Instances that are started up and scaled down based on the current volume of requests to your application. This lets you avoid having to commit to using a certain number of instance hours. Compare reserved instances.

Back to top

## P

Parent Entity
  A parent entity is the root of an entity group.
Partitioning
  See sharding.
Pending Latency
  The amount of time a request spends in the pending request queue while waiting to be served. See maximum pending latency for more information.
Pending Request Queue
  A component of push queues where pending requests wait when no instances are available to serve them. By default, App Engine automatically determines how long requests wait in the pending queue, but you can also manually configure this and other aspects of task processing using the Application Settings tab of the Administration Console.
ProtoRPC
  ProtoRPC is a simple way to create well-defined, easy-to-use, web-based remote procedure call (RPC) services. An RPC service is a collection of message types and remote methods that provide a structured way for external applications to interact with web applications. Because it is possible to define messages and services using only the Python programming language, it's easy to get started developing your own services.
Pull Queue
  A pull queue is a type of task queue in which a task consumer “pulls” tasks from your application, processes them outside your application, and then deletes them. The task consumer can be part of your App Engine application (such as a backend) or a system outside of App Engine (using the task queue REST API).
Push Queue
  A push queue is a type of task queue in which your application processes tasks using HTTP request handlers. Each Task object contains an application-specific URL with a request handler for the task, and an optional data payload that parameterizes the task. For example, consider a calendaring application that needs to notify an invitee, via email, that an event has been updated. The data payload for this task consists of the email address and name of the invitee, along with a description of the event. You can only use push queues within the App Engine environment; if you need to access App Engine tasks from outside of App Engine, use pull queues instead.
Python Development Server
  The App Engine Python SDK includes a web server application you can run on your computer that simulates your application running in the App Engine Python runtime environment. The simulated environment enforces some sandbox restrictions, such as restricted system functions and Python module imports, but not others, like request time-outs or quotas. The server also simulates the services by performing their tasks locally.
Python Runtime Environment
  App Engine applications can be implemented using the Python programming language. The App Engine Python runtime environment includes a specialized version of the Python interpreter, the standard Python library, libraries and APIs for App Engine, and a standard interface to the web server layer.

Back to top

## Q

Query
  A query retrieves datastore entities that meet a specified set of conditions. The query specifies an entity kind, zero or more conditions based on entity property values (sometimes called "filters"), and zero or more sort order descriptions. When the query is executed, it fetches all entities of the given kind that meet all of the given conditions, sorted in the order described.
Query Cursor
  Query cursors allow an application to perform a query and retrieve a batch of results, then fetch additional results for the same query in a subsequent web request without the overhead of a query offset. After the application fetches some results for a query, it can ask for an encoded string that represents the location in the result set after the last result fetched (the “cursor”). The application can use the cursor to fetch additional results starting from that point at a later time.
queue.xml
  This file configures task queues for Java applications. This file controls many parameters of task queues such as the storage limit, processing rate, the maximum number of concurrent requests, and other values. This configuration file is optional for push queues.
queue.yaml
  This file configures task queues for Python applications and for Java applications that use YAML configuration.
Quota
  An App Engine application can consume resources up to certain maximums, or quotas. With quotas, App Engine ensures that your application won't exceed your budget, and that other applications running on App Engine won't impact the performance of your app.

Back to top

## R

Read Policy
  In order to increase data availability, you can set the datastore read policy so that all reads and queries are eventually consistent. While the API also allows you to explicitly set a strong consistency policy, in the high replication datastore, non-ancestor queries are always eventually consistent.
Remote Procedure Call
  In a remote procedure call (RPC), a computer program executes a method in another address space (commonly on another computer on a shared network) without the programmer explicitly coding the details for this remote interaction. From the programmer's point of view, the call is local to the executing program.
Reserved Instances
  Instances that are always available to your application. When you sign up for reserved instances, you pre-commit to paying for a certain number of instance-hours per week, even if you don't use them all. Compare on-demand instances.
Role
  App Engine provides three roles—`Viewer`, `Developer`, `Owner`—supplying different levels of access to administration console features. Each progressively stronger role includes all permissions from the previous role.
Root Entity
  An entity without a parent. Root entities may serve as a parent entity for an entity group.
RPC
  See remote procedure call.

Back to top

## S

Safety Quota
  Safety quotas are resource maximums set by App Engine to ensure the integrity of the system. These resources describe the boundaries of the architecture, and App Engine expects all applications to run within the same limits.
Scheduler
  The infrastructure component that determines how many instances are needed to serve your application's current traffic and to which instance to send a request.
Service Stub
  A service stub is a method that simulates the behavior of a service in the SDK.
Servlet
  See Java servlet.
Sharding
  Sharding is a means of partitioning data in a database.
Snapshot Isolation
  See transaction isolation.
Static Files
  Static files are files to be served directly to the user for a given URL, such as images, CSS stylesheets, or JavaScript source files. Static file handlers describe which files in the application directory are static files, and which URLs serve them.

Back to top

## T

Task Queues
  Tasks queues enable your applications to schedule tasks to be done later in the background. As such, your application defines tasks, adds them to a queue, and then uses the queue to process them in aggregate. You can configure queue settings in `queue.yaml` or `queue.xml`. See Queue Definitions for more information about configuring queues.
Token Bucket
  In App Engine task queues, the token bucket algorithm used by App Engine determines the rate at which the App Engine task queue processes push tasks.
Transaction
  The App Engine datastore supports transactions. A transaction is an operation or set of operations that is atomic—either all of the operations in the transaction occur, or none of them occur. An application can perform multiple operations and calculations in a single transaction.
Transaction Isolation
  In the App Engine datastore, the isolation level means how much impact a query has on other simultaneous queries being executed. Preferably, each query must run in its own vacuum to avoid any concurrency issues. For a more in-depth discussion on these concerns, see transaction isolation.

Back to top

## U

Unit Testing
  You write unit tests while you develop your App Engine applications. This methodology provides small, maintainable, and reusable units of code and your tests run in your development environment without involving remote components. App Engine provides testing utilities that use local implementations of datastore and other App Engine services. This means you can exercise your code's use of these services locally, without deploying your code to App Engine, by using service stubs. A service stub is a method that simulates the behavior of a service.
Upload App
  Upload app is an AppCfg command that you use to upload your application to App Engine. This is a required step after you have registered your application with the administration console.
URL Fetch Service
  App Engine applications can communicate with other applications or access other resources on the web by fetching URLs. An application can use the URL fetch service to issue HTTP and HTTPS requests and receive responses.
Users Service
  The Users service provides APIs for your application to integrate with Google user accounts. With the users service, your users can use the Google accounts they already have to sign in to your application.

Back to top

## V

Back to top

## W

Webapp Framework
  The webapp framework is a simple web application framework you can use for developing Python web applications for App Engine. It is compatible with the WSGI standard for Python web application containers.
Web Application Archive (WAR)
  Web application archives bundle web clients to deploy in browsers over the Internet. They contain server-side utility classes, HTML files, image & sound files, and client-side classes such as applets.
Web Server Gateway Interface (WSGI)
  The web server gateway interface is a simple and universal interface between web servers and web applications or frameworks for the Python programming language.
web.xml
  See deployment descriptor.
White List
  See JRE class white list.
WSGI
  See web server gateway interface.

Back to top

## X

XMPP
  The XMMP (Extensible Messaging and Presence Protocol) API makes it possible to write App Engine applications that communicate with users—or even other applications—over the XMPP protocol. XMPP is also known as "Jabber" and is supported by Google Talk and other chat clients

Back to top

## Y

YAML (Yet Another Markup Language)
  YAML is a generic data serialization language that you can easily read. It can be used to express the data structures of most modern programming languages. Usually, you use YAML in configuration files, or as a way to print logging/debugging information. App Engine has several different YAML configuration files available for services such as the datastore, task queue, and backends. For more information, see Configuration.

Back to top

## Z

Back to top