Cloud Computing

2-Day workshop on Cloud Computing and Google App Engine by OSAHUB Technologies.

For any query feel free to call us at 9013955267, 9555505352

Organize / Join this Workshop

About Workshop

A workshop on "CLOUD COMPUTING & GOOGLE APP ENGINE" presented by OSAHUB Technologies.

Cloud computing is biggest emerging trend in IT industry, which will change the way Computing is done. There are many providers in industry today who offer various Cloud Services ranging from infrastructure to softwares. It is important to understand now what Cloud Computing is, why it is so promising and what impacts it will have on IT industry.

Google App Engine (GAE) is a major cloud platform for hosting scalable internet applications. Google has opened it's massively scalable infrastructure to host applications developed using Google App Engine APIs. It is absolutely free to start hosting applications on Google App Engine until the application crosses a certain level of resource usage. This training program is developed for java developers to understand the features and capabilities of Google app engine and how to build large scale applications for the cloud. The participants will be able to develop a basic web application and deploy it on Google App engine cloud in a day.

This workshop is for Architects, technical managers, senior developer and programmers. The participants should have a very basic knowledge of java and developing web applications using servlets/jsp.

  • Comprehensive course material will be provided to participants
  • Software tool kit CD having e-books, videos, software, codes etc.
  • Learn & Interact with renowned Industry Experts
  • Receive an unparalleled education on the art of upcoming technology with personal one-on-one attention
  • Hands on Demonstrations of Latest Computing Techniques & Tools
  • Power Point Presentation, Live Demos, Interactive Question & Answer session and comprehensive reading material
  • Passion to learn new creative things
  • Knowledge of how to use Computer
  • Knowledge of Computer Languages
  • Having basic knowledge of Web & Internet

What You'll Learn

  • Understand What is Cloud Computing
  • Understand What is Virtualization and its benefits
  • Understand What is are public and private cloud and creating your own cloud.
  • Understand What Google App Engine platform provides
  • Google App Engine features and data store concepts
  • Learn how to develop applications for Google App Engine
  • Learn how to deploy and manage applications on the app engine cloud
  • Learn few best practices on how to build applications for Google App Engine


  • Instructor has a good hold on the subject and has lot of patience to take all possible questions from the participant. Appreciate all the analogies presented to explain the subject in a layman's language. It became really easy to correlate and make you remember and relate to the concept in a very easy way.

    Priyanka Agarwal

  • It has been a wonderful experience. All the staff members are really helpful.

    Vishal Kawatra


  • Cloud Computing – Definition
  • History/ Origin of Cloud computing
  • Cloud Computing- Concept
    • Grid Computing
    • Cluster Computing
    • Distributed computing
    • Utility Computing
    • Converged Infrastructure
    • Shared Services
    • Virtualization
    • Multitenancy
  • Cloud Computing: Characteristics
  • Cloud service Models
    • Software as a Service (SaaS)
    • Platform as a Service (PaaS)
    • Infrastructure as a Service (IaaS)
    • Network as a service (NaaS)
  • Comparison of SAAS, PAAS, IAAS, NAAS
  • Cloud Management
  • Cloud Management Challenges
  • Cloud Clients
  • Cloud Deployment Models
  • Introduction to Java and Object Oriented Programming
  • Setup JVM environment (JRE and Java SDK)
  • Installing Eclipse JavaEE IDE
  • Basic Java programming concepts
  • Basic Java Script Programming
  • Basic HTML/CSS Understanding
  • Basic Database Concept
  • Introduction Google App Engine Development
  • Learn about Google App Engine Plug-in and SDK
  • Configuring the GAE Development environment
  • Workaround with eclipse and learn some important operations
  • Build a basic project on eclipse
  • What Is Google App Engine?
  • Why does App Engine exist?
  • The Runtime Environment
  • The DataStore
  • Brief introduction to the service of app engine
  • Google Accounts
  • Administration console
  • Limitations
  • Setting up SDK in eclipse
  • Create your first app in Google App Engine
  • File structure of a Google App Engine project
  • Registering the application
  • Deploying the application
  • monitoring the application using administration console
  • Life Cycle of a request in App Engine
  • Managing App on Google Cloud
  • App IDs and Versions
  • Handling Request
  • DataStore
    • Entities , Key and Properties
    • Entities Operation (CURD)
    • DataStore Queries
  • Indexes: Automatic and custom indexes
  • Filters and sort orders in queries
  • DataStore Transactions
    • Entities and entity group
    • Ancestors and Ancestor queries
    • Batch queries
  • Google Cloud SQL
  • Third party APIs for using Datastore
  • BlobStore
  • App Identity:

    Code sometimes needs to determine the identifier of the application in which it is executing. This may be to generate a URL or email address, or possibly to make some run-time decision. App Engine includes an Application Identity service for this purpose.

    • Identifying itself
    • Asserting identity to other App Engine apps
    • Asserting identity to Google APIs
    • Asserting identity to other systems

  • Blobstore:

    The Blobstore API allows your application to serve data objects, called blobs, that are much larger than the size allowed for objects in the Datastore service. Blobs are useful for serving large files, such as video or image files, and for allowing users to upload large data files.

  • Channel API:

    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. This is useful for applications designed to update users about new information immediately. Some example use-cases include collaborative applications, multi-player games, or chat rooms.

  • Images:

    App Engine provides the ability to manipulate image data using a dedicated Images service. The Images service can resize, rotate, flip, and crop images; it can composite multiple images into a single image; and it can convert image data between several formats. It can also enhance photographs using a predefined algorithm. The API can also provide information about an image, such as its format, width, height, and a histogram of color values.

  • Logs:

    The Logs API provides access to the application and request logs for your application. You can control how much log data your application stores by means of its log retention settings in the Admin Console.

  • Mail:

    App Engine applications can send email messages on behalf of the app's administrators, and on behalf of users with Google Accounts. Apps can receive email at various addresses. Apps send messages using the Mail service and receive messages in the form of HTTP requests initiated by App Engine and posted to the app.

    • Sending mail
    • Receiving mail
    • Receiving bounce notification
    • Sending mail with attachments
    • Sending mail with headers
    • Mail and the development server
    • Authenticating mail
    • Bulk senders guidelines

  • Memcache:

    One use of a memory cache is to speed up common Datastore queries. If many requests make the same query with the same parameters, and changes to the results do not need to appear on the web site right away, the app can cache the results in the Memcache. Subsequent requests can check the Memcache, and only perform the Datastore query if the results are absent or expired. Session data, user preferences, and any other queries performed on most pages of a site are good candidates for caching.

  • Multitenancy:

    The Namespaces API in Google App Engine makes it easy to compartmentalize your Google App Engine data. This API is implemented via a new package called the namespace manager, and is incorporated in certain namespace-enabled APIs.

    When you set a namespace in the namespace manager, these APIs get the current namespace and use it globally. You can explicitly declare a namespace locally, but you need to exercise caution when explicitly declaring namespaces, because you could inadvertently create data leaks and other bugs. Any App Engine request can access any namespace, leaving the application to enforce an access control policy across namespaces.

  • OAuth:

    OAuth is a protocol that allows a user to grant a third party limited permission to access a web application on her behalf, without sharing her 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 user, such as a desktop application or an app running on a smart phone. In the terms of the OAuth specification, the application seeking permission is the consumer, and the application providing the data is the service provider.

  • Search:

    The Search API provides a model for indexing documents that contain structured data. You can search an index, and organize and present search results. The API supports partial text matching on string fields. Documents and indexes are saved in a separate persistent store optimized for search operations. The Search API can index any number of documents. However, an index search can find no more than 10,000 matching documents. The App Engine Datastore may be more appropriate for applications that need to retrieve very large result sets.

  • Task Queue:

    With the Task Queue API, applications can perform work outside of a user request, initiated by a user request. If an app needs to execute some background work, it can use the Task Queue API to organize that work into small, discrete units, called tasks. The app adds tasks to task queues to be executed later.

    App Engine provides two different queue configurations:

    • Push Queue
    • Pull Queue

  • URL Fetch:

    App Engine applications can communicate with other applications or access other resources on the web by fetching URLs. An app can use the URL Fetch service to issue HTTP and HTTPS requests and receive responses. The URL Fetch service uses

    Google's network infrastructure for efficiency and scaling purposes.

    • Fetching URLs with
    • Making requests
    • Secure connections and HTTPS
    • Request headers
    • Responses
    • URL Fetch and the development server

  • Users:

    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 to sign in or, if your app uses Google Accounts authentication, create a new account. While a user is signed in to the application, the app can access the user's email address (or OpenID identifier if your app is using OpenID). The app can also detect whether the current user is an administrator, making it easy to implement admin-only areas of the app.

    • User authentication in Java
    • Authentication options
    • Signing in and out
    • Accessing account information
    • Users and the Datastore
    • Google accounts and the development server

  • XMPP:

    An App Engine application can send and receive chat messages to and from any XMPP-compatible chat messaging service, such as Google Talk. An app can send and receive chat messages, send chat invites, request a user's chat presence and status, and provide a chat status.Incoming XMPP messages are handled by request handlers, similar to web requests.

    Some possible uses of chat messages include automated chat participants ("chat bots"), chat notifications, and chat interfaces to services. A rich client with a connection to an XMPP server (such as Google Talk) can use XMPP to interact with an App Engine application in real time, including receiving messages initiated by the app.

  • Deploying your app on Google Cloud
  • Understanding and using with versions
  • Managing Indexes
  • App settings
  • Quotas and Billing
  • Calendar API
  • Drive API
  • Map API
  • Contacts API

Other Related Courses