Introduction to google endpoints

Introduction to Google Endpoints

SHINTO ANTO

Your Application

How can you build a shared backend for web clients and mobile clients such as Android and IOS.

• How to create a shared backend for the web and mobile clients?

• How to handle the scalability and availability?

• How to migrate the current backend version to all the clients?

Endpoints provides a simple way to develop a shared web backend and also provides critical infrastructures, such as OAuth 2.0 authentication, eliminating a great deal of work that would otherwise be needed.

Google Cloud Endpoints consists of tools, libraries and capabilities that allow you to generate APIs and client libraries from an App Engine application, referred to as an API backend, to simplify client access to data from other applications

Google Cloud Endpoints

Cloud Endpoints makes it easy to expose your code via RESTful API & RPC services that can easily be consumed by web and mobile applications.

V1 V2

API Burgeoning support by Cloud Endpoints

Different Api versions can co-exist and you can do a gradual stage of roll out of these changes.

New clients can talk to V2 where as the older ones can slowly move over until we deprecate the V1

Why App Engine?

With App Engine comes the ability to scale very easily.

As we get more traffic Google automatically spins up more app engine instances.

When the traffic levels are off the peak it kills off instances that are not needed anymore

Endpoints libraries, tools, and samples


Google Cloud Endpoints provide the following libraries and tools:• The Endpoints library in the SDK.• Maven artifacts for creating new backend API projects,

generating client libraries and discovery docs• Alternatively to Maven, the endpoints.sh command line

tool (for Linux), or endpoints.cmd (for Windows) that you can use to generate client libraries and discovery documents.

• Another alternative to Maven is Endpoints support in the Google Plugin for Eclipse.


• To use Endpoints, be sure you're using the latest version of the Google App Engine Java SDK.

• If you are using the Google Plugin for Eclipse (GPE) to generate endpoints and client libraries, you'll need the latest GPE version.

• You'll also need to be familiar with development using Google App Engine and the Java runtime.

• And finally, you'll need to know how to develop the client of your choice, such as JavaScript web clients, or mobile clients of your choice, such as Android or iOS.

Requirements


• Create your backend API project (using Maven to do this is the easiest method), then write your API backend code.

• Annotate your API backend code, so classes and client libraries can be generated from it. (Alternatively, use the Google Plugin for Eclipse, which can annotate for you.)

• Generate the client library using Maven, or alternatively, the endpoints.sh command line tool. (Another alternative is to use the Google Plugin for Eclipse to generate the client library.)

• Write your client app, using the client library when making calls to the API backend.

The development process

Endpoint Annotations• @Api: API-Scoped Annotations• @ApiMethod: Method-Scoped Annotations• @Named• @ApiClass• @ApiNamespace

• Required Imports– import com.google.api.server.spi.config.Api;

import com.google.api.server.spi.config.AnnotationBoolean;import com.google.api.server.spi.config.ApiMethod;import com.google.api.server.spi.config.ApiMethod.HttpMethod;import javax.inject.Named;

/** * Defines conference APIs. */@Api(name = "conference", version = "v1", scopes = {Constants.EMAIL_SCOPE }, clientIds = {Constants.WEB_CLIENT_ID,Constants.API_EXPLORER_CLIENT_ID }, description = "API for the Conference Central Backend application.")

public class ConferenceApi {/** * Returns a Conference object with the given conferenceId. * */ @ApiMethod(name = "getConference“,path = "conference/{websafeConferenceKey}“, httpMethod = HttpMethod.GET) public Conference getConference(@Named("websafeConferenceKey") final String websafeConferenceKey) throws NotFoundException { Key<Conference> conferenceKey = Key.create(websafeConferenceKey); Conference conference = ofy().load().key(conferenceKey).now(); if (conference == null) { throw new NotFoundException("No Conference found with key: " + websafeConferenceKey); } return conference; }

<?xml version="1.0" encoding="utf-8"?><appengine-web-app xmlns="http://appengine.google.com/ns/1.0"> <application>your-app-id</application> <version>version_number</version> <threadsafe>true</threadsafe>

<system-properties> <property name="java.util.logging.config.file" value="WEB-INF/logging.properties"/> </system-properties></appengine-web-app>

appengine-web.xml

Required Files and Configuration

web.xml<?xml version="1.0" encoding="utf-8" standalone="no"?><web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.5" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"> <servlet> <servlet-name>SystemServiceServlet</servlet-name> <servlet-class>com.google.api.server.spi.SystemServiceServlet</servlet-class> <init-param> <param-name>services</param-name> <param-value>com.google.devrel.training.conference.spi.ConferenceApi</param-value> </init-param> </servlet> <servlet-mapping> <servlet-name>SystemServiceServlet</servlet-name> <url-pattern>/_ah/spi/*</url-pattern> </servlet-mapping> <welcome-file-list> <welcome-file>index.html</welcome-file> </welcome-file-list></web-app>

Running and testing API backends locally

• Start the API backend by invoking the development app server.

• In your browser, visit the URL

• Double-click the API you created to display the list of its methods.

mvn appengine:devserver

Wait till...INFO: Dev App Server is now running.

http://localhost:8080/_ah/api/explorer

Deploying an API backend• Change directory to your project main directory

containing the pom.xml file.

• Invoke Maven as follows:

• After you deploy, you can use the API Explorer to experiment with your API without using a client app by visiting.

mvn appengine:update

https://your_app_id.appspot.com/_ah/api/explorer

Api Explorer

List of Created Api’s

Parameters for API Call

Enabling a JavaScript client for Endpoints

• Add the script that includes the Google-hosted JavaScript client library to your HTML:

• Notice that the JavaScript line above includes an onload property specifying the function to be used as a callback after the library loads. Replace "init" with the name of your page initialization function if you did not name it init.

• Inside your callback function, load your Endpoint:

<script src="https://apis.google.com/js/client.js?onload=init"></script><script src="https://apis.google.com/js/client.js?onload=init"></script>

<script src="https://apis.google.com/js/client.js?onload=init"></script>

function init() { gapi.client.load('conference', 'v1', null, '//' + window.location.host +'/_ah/api'); gapi.client.load('oauth2', 'v2', function () { angular.bootstrap(document, ['conferenceApp']); }); };

So Start Coding Now

Introduction to google endpoints

Presentations & Public Speaking

Transcript of Introduction to google endpoints