Cloud EndPoints : création d'une application Android avec un backend Cloud App Engine

Ce tutoriel se veut simple, à la portée d'un débutant en programmation pour Android. Cependant, pour sa bonne compréhension, il est nécessaire de disposer des notions de base en :

• développement Android ;
• développement Java ;
• Utilisation des services Web.

Les smartphones font de plus en plus partie du quotidien des utilisateurs et commencent également à se faire une place dans le milieu professionnel. Cependant, ces dispositifs sont faibles en ressources et ne disposent pas d'espace de stockage important.

De plus, dans un environnement professionnel, le smartphone devrait permettre d'accéder à distance aux données et y effectuer des opérations, notamment des mises à jour ou des suppressions.

Si vous développez des applications pour des terminaux mobiles, il sera assez probable que vous soyez confronté un jour à ces problèmes. Une solution pourrait être la délégation de l'exécution des tâches complexes et du stockage des données à une plateforme distante : un PaaS (Paltform as a Service), par exemple.

L'objectif à atteindre dans le cadre de ce tutoriel est la mise en œuvre d'une application pour terminaux Android, qui exploite un backend Cloud pour l'exécution et le stockage des données. Nous reviendrons plus tard sur la présentation du backend Cloud.

Les avantages d'une telle architecture sont multiples. Nous pouvons notamment citer :

• gain en performance ;
• délégation du traitement des tâches complexes ;
• stockage centralisé ;
• temps de réponse amélioré ;
• gestion de la montée en charge ;
• facilité de maintenance ;
• redimensionnement automatique du stockage des données ;
• meilleure gestion des transactions ;
• synchronisation ;
• fiabilité.

Pour mettre sur pied notre solution, nous aurons besoin des outils suivants :

• Eclipse : la version 4.3 (Kepler) a été utilisée dans le cadre de ce tutoriel  ;
• JDK (Java SE Development Kit) : nous avons eu recours à la version 7 du JDK :
• Android SDK : la version 22 a été utilisée  ;
• App Engine Java SDK version 1.9 a été exploitée pour cet article ;
• Google Cloud EndPoints : inclus par défaut dans App Engine ;
• Google Plugin for Eclipse ; nous avons utilisé la version 3.7.

Vous devez également disposer d'un compte Google.

VI-A. Android▲

VI-B. App Engine ▲

App Engine est une plateforme PaaS, qui permet de créer des applications Web à l'aide des technologies Java, Python ou encore JavaScript et de les exécuter sur l'architecture évolutive de Google.

App Engine permet de développer en toute simplicité des applications qui s'exécutent de manière fiable, même lorsqu'elles sont surchargées et doivent faire face à des volumes de données importants . App Engine comprend les fonctionnalités suivantes :

• diffusion Web dynamique, avec prise en charge intégrale des technologies Web courantes ;
• stockage permanent avec requêtes, tri et transactions ;
• équilibrage des charges et évolutivité automatique ;
• API qui permettent d'authentifier les utilisateurs et d'envoyer des e-mails via Google Accounts ;
• un environnement de développement local complet qui simule Google App Engine sur votre ordinateur ;
• des files d'attente de tâches qui permettent d'effectuer du travail en dehors du champ d'une requête Web ;
• des tâches planifiées qui déclenchent les événements aux moments spécifiés ou à intervalles réguliers.

App Engine dispose d'un ensemble riche de services pour faciliter le développement d'applications qui seront hébergées dans le Cloud de Google. Pour notre travail, nous allons utiliser l'environnement d'exécution Java (JRE), la base de données (DataStore), et les outils Google Cloud EndPoints.

VI-B-1. L'environnement d'exécution Java▲

L'environnement d'exécution Java d'App Engine fournit une machine virtuelle qui supporte Java 8 et permet l'exécution des applications dans un environnement Cloud sécurisé (sandbox). Le Runtine Java de la plateforme offre également une interface Servlet Java et la prise en charge des interfaces standard avec le magasin de données et les services évolutifs App Engine tels que JDO (Java Data Objects), JPA (Java Persistence API), JavaMail et JCache. La prise en charge des normes facilite le développement des applications et permet de porter celles-ci vers et depuis votre propre environnement de servlets.

VI-B-2. La base de données (DataStore) ▲

App Engine fournit un service performant de stockage distribué de données qui comprend un moteur de recherche et la gestion des transactions. En même temps que les serveurs Web distribués augmentent avec votre trafic, la base de données grossit avec vos données.

Le datastore App Engine n'est pas comme une base de données relationnelle traditionnelle. Les objets de données ou « entités » ont des propriétés. Les recherches peuvent retourner des entités selon un filtre donné et les trier selon les propriétés de leurs valeurs.

Les entités Datastore n'ont pas de schéma. La structure de données des entités est fournie et mise en place par le code de l'application. Les interfaces JDO/JPA incluent les dispositifs pour mettre en place la structure à l'intérieur de l'application. L'application peut aussi accéder au datastore directement pour mettre en place une structure répondant plus précisément aux besoins du développeur.

Le datastore implémente les transactions à travers son réseau distribué en utilisant des « groupes d'entités ». Une transaction manipule des entités à l'intérieur d'un simple groupe. Les entités du même groupe sont enregistrées ensemble par souci d'efficacité d'exécution des transactions.

VI-B-3. Google Cloud EndPoints▲

Pour faciliter le développement d'applications mobiles utilisant App Egine, Google a développé un ensemble d'API connu sous le nom de « Cloud Endpoints ».

Cloud Endpoints permet de définir la logique métier sur App Engine et d'y accéder via des API RESTful ou RPC (Remote Procedure Call) sur de multiples plateformes, y compris Android , iOS et sur le Web (JavaScript). Cloud Endpoints est construit en utilisant l'infrastructure de Google API, ce qui facilite l'interopérabilité avec des services Google.

Cloud Endpoints a été construit pour simplifier la tâche aux développeurs, en permettant un développement flexible et agile. Il permet de :

• libérer le développeur des travaux complexes de rédaction et de maintenance de code pour les interactions et les protocoles client-serveur ;
• générer du code optimisé pour les opérations CRUD ;
• faciliter la création des API personnalisées (REST ou RPC).

VI-B-3-a. Architecture basique de Cloud EndPoints▲

Cloud EndPoints a pour objectif d'aider le développeur à connecter son ou ses applications frontends avec son application backend en générant les API nécessaires.

Le développement d'une solution en utilisant Cloud EndPoints revient donc à créer :

• le backend qui sera hébergé sur App Engine. Le backend permet d'implémenter sur App Engine la logique métier de l'application et effectue tous les calculs et le stockage sur le DataStore ;
• les frontends (Android, Web ou Java) seront les interfaces qui permettront aux utilisateurs d'interagir avec le backend.

Les fonctionnalités du backend sont mises à la disposition des clients par le biais de Endpoints , qui expose une API que les frontends peuvent appeler.

VI-B-3-b. Bibliothèques, outils et modèles de Cloud Endpoints▲

Cloud Endpoints dans le SDK App Engine met à la disposition du développeur les bibliothèques et outils suivants :

• des bibliothèques Endpoints dans le SDK ;
• des artefacts Maven pour la création de nouveaux projets backend, la génération de l'API client, de la documentation, etc. ;
• l'outil en ligne de commande endpoints.sh (sur Linux) et endpoints.cmd (sur Windows) qui est un substitut à Maven pour la création du backend et la génération de l'API client
• le support de Endpoints dans Google Plugin pour Eclipse, qui permet d'utiliser l'EDI pour les tâches citées ci-dessus. C'est l'outil que nous utiliserons pour la création de notre solution.

Avant de débuter avec la création de votre solution, vous devez disposer d'Eclipse avec le SDK Android et le SDK App Engine installés sur votre machine.

Ensuite, vous devez via l'interface du menu Help > Install New Software, installer le plugin Eclipse pour Android et pour App Engine.

Pour installer les plugins nécessaires, vous devez renseigner le lien suivant dans la zone « Work with » : http://dl.google.com/eclipse/plugin/4.3.

Vous devez sélectionner dans la liste proposée les éléments suivants :

• Developper Tools ;
• Google Plugin for Eclipse ;
• Google App Engine Java SDK (si vous ne l'avez pas déjà installé sur votre poste).

Le reste d'outils est optionnel.

La solution que nous allons mettre sur pied sera constituée de deux applications. Une application App Engine qui fera office de Backend et une application Android qui sera le client (frontend). Les données seront stockées sur le datastore d'App Engine.

Le diagramme de composants ci-dessous permet d'avoir une idée plus précise sur les composants de notre solution et son architecture physique et statistique.

VIII-A. Architecture en couche de l'application Android▲

L'application Android sera constituée des couches suivantes :

• la couche présentation (IHM - Interface Homme Machine) : elle correspond à la partie visible de l'application. La couche présentation relaie les requêtes de l'utilisateur à destination de la couche métier, et en retour lui présente les informations renvoyées par les traitements de cette couche ;
• la couche métier (BLL - Business Logic Layer) : la couche métier sera utilisée pour développer toute la logique métier de l'application Android. Elle est intercalée entre l'IHM et la bibliothèque App Engine Client Lib, et permettra d'effectuer toutes les manipulations de données nécessaires en fonction des requêtes effectuées par les utilisateurs au travers de la couche présentation ;
• App Engine Backend Client Lib : cette couche fournit un accès simplifié à l'application serveur hébergée sur App Engine via Google Cloud Endpoints ;
• le modèle objets : le modèle ici représente les ressources qui seront manipulées par notre application et notre API.

VIII-B. Architecture en couche de l'application App Engine▲

Les différentes couches que nous allons utiliser pour cette application sont les suivantes :

• les classes Endpoints : les classes Endpoints représentent en quelque sorte la couche d'accès aux données. Les méthodes que chaque classe Endpoint possède permettent d'insérer, mettre à jour et supprimer les objets dans le DataStore ;
• le modèle objets : le modèle ici représente les ressources qui seront manipulées par les classes Endpoint.

VIII-C. Étapes de création de la solution ▲

Maintenant que nous nous sommes familiarisés avec les outils que nous allons utiliser et que nous sommes informés sur les objectifs à atteindre, entrons dans le vif du sujet de ce tutoriel. Nous allons débuter par la création de notre application Android.

Pour cela, démarrez votre EDI Eclipse. Cliquez sur le menu « Fichier », ensuite « Nouveau » puis « Projet ».

L'interface de création d'un nouveau projet s'affiche. Déroulez la zone « Android » et sélectionnez « Android Application Project », comme l'illustre la capture ci-dessous.

Cliquez ensuite sur « Suivant ». Dans la fenêtre qui s'affiche, renseignez le nom de votre application, celui du projet, ainsi que le nom du package. Vous pouvez également à partir de cette interface définir les versions d'Android que votre application va cibler. Laissez les valeurs renseignées par défaut.

Cliquez sur « Suivant » et configurez votre projet, si besoin, avant de finaliser avec sa création.

À partir de l'application Android que nous venons de créer, nous allons procéder à la création de l'application App Engine (notre Backend Cloud).

Pour cela, vous allez faire un clic droit sur votre projet dans l'explorateur de projet. Ensuite, vous allez cliquer sur « Google » puis sur « Generate App Engine Backend », comme l'illustre la capture ci-dessous :

Le plugin Google se chargera de la génération de votre application Backend, puis ajoutera à l'application Android la classe nécessaire pour assurer la communication entre vos deux applications. Il s'agit de la classe CloudEndpointsUtils.

Après la création de nos projets, nous allons dans un premier temps travailler sur l'application App Engine. Nous allons commencer par créer les objets qui seront manipulés par notre application.

Pour cela, vous allez faire un clic droit sur « src », puis vous allez cliquer sur « Nouveau », puis sur « Class ». Dans la fenêtre qui va s'afficher, renseignez le nom de votre classe, puis cliquez sur « Finish ».

Les objets de notre modèle doivent être des classes entités.

Les classes Entities sont :

• des simples POJO (c'est-à-dire qu'elles n'implémentent pas d'interface spécifique à un framework ) ;
• annotées avec JPA (@Entity, @Id, etc.) ou JDP ;
• implémentent des accesseurs (get) et des mutateurs (set) ;

Notre classe Entity GdaysSession aura donc la structure suivante :

Après la création de notre classe Entity, nous allons passer à la génération de l'API Endpoints correspondante.

Pour cela, vous allez faire un clic droit sur votre classe Entity, ensuite sélectionner « Google », puis cliquer sur « Generate Cloud Endpoint Class », comme l'illustre la capture ci-dessous :

Cloud EndPoints procède à la génération du code pour votre API. Celui-ci est généré en utilisant JPA ou GDO avec par défaut des méthodes pour :

• l'insertion (exposée comme une requête HTTP POST) ;
• la sélection (exposée comme une requête HTTP GET) ;
• la modification (exposée comme une requête HTTP PUT) ;
• la suppression (exposée comme une requête HTTP DELETE).

Le code qui est généré est le suivant :

package com.example.roma.gdaysapp;

import com.example.roma.gdaysapp.EMF;

import com.google.api.server.spi.config.Api;
import com.google.api.server.spi.config.ApiMethod;
import com.google.api.server.spi.config.ApiNamespace;
import com.google.api.server.spi.response.CollectionResponse;
import com.google.appengine.api.datastore.Cursor;
import com.google.appengine.datanucleus.query.JPACursorHelper;

import java.util.List;

import javax.annotation.Nullable;
import javax.inject.Named;
import javax.persistence.EntityExistsException;
import javax.persistence.EntityNotFoundException;
import javax.persistence.EntityManager;
import javax.persistence.Query;

@Api(name = "gdayssessionendpoint", 
namespace = @ApiNamespace(ownerDomain = "example.com", ownerName = "example.com", 
             packagePath = "roma.gdaysapp")
)
public class GdaysSessionEndpoint {

    /**
     * This method lists all the entities inserted in datastore.
     * It uses HTTP GET method and paging support.
     *
     * @return A CollectionResponse class containing the list of all entities
     * persisted and a cursor to the next page.
     */
    @SuppressWarnings({ "unchecked", "unused" })
    @ApiMethod(name = "listGdaysSession")
    public CollectionResponse<GdaysSession> listGdaysSession(
            @Nullable @Named("cursor") String cursorString,
            @Nullable @Named("limit") Integer limit) {

        EntityManager mgr = null;
        Cursor cursor = null;
        List<GdaysSession> execute = null;

        try {
            mgr = getEntityManager();
            Query query = mgr
                    .createQuery("select from GdaysSession as GdaysSession");
            if (cursorString != null && cursorString != "") {
                cursor = Cursor.fromWebSafeString(cursorString);
                query.setHint(JPACursorHelper.CURSOR_HINT, cursor);
            }

            if (limit != null) {
                query.setFirstResult(0);
                query.setMaxResults(limit);
            }

            execute = (List<GdaysSession>) query.getResultList();
            cursor = JPACursorHelper.getCursor(execute);
            if (cursor != null)
                cursorString = cursor.toWebSafeString();

            // Tight loop for fetching all entities from datastore and accomodate
            // for lazy fetch.
            for (GdaysSession obj : execute)
                ;
        } finally {
            mgr.close();
        }

        return CollectionResponse.<GdaysSession> builder().setItems(execute)
                .setNextPageToken(cursorString).build();
    }

    /**
     * This method gets the entity having primary key id. It uses HTTP GET method.
     *
     * @param id the primary key of the java bean.
     * @return The entity with primary key id.
     */
    @ApiMethod(name = "getGdaysSession")
    public GdaysSession getGdaysSession(@Named("id") Long id) {
        EntityManager mgr = getEntityManager();
        GdaysSession gdayssession = null;
        try {
            gdayssession = mgr.find(GdaysSession.class, id);
        } finally {
            mgr.close();
        }
        return gdayssession;
    }
    

    /**
     * This inserts a new entity into App Engine datastore. If the entity already
     * exists in the datastore, an exception is thrown.
     * It uses HTTP POST method.
     *
     * @param gdayssession the entity to be inserted.
     * @return The inserted entity.
     */
    @ApiMethod(name = "insertGdaysSession")
    public GdaysSession insertGdaysSession(GdaysSession gdayssession) {
        EntityManager mgr = getEntityManager();
        try {
            /*if (containsGdaysSession(gdayssession)) {
                throw new EntityExistsException("Object already exists");
            }*/
            mgr.persist(gdayssession);
        } finally {
            mgr.close();
        }
        return gdayssession;
    }

    /**
     * This method is used for updating an existing entity. If the entity does not
     * exist in the datastore, an exception is thrown.
     * It uses HTTP PUT method.
     *
     * @param gdayssession the entity to be updated.
     * @return The updated entity.
     */
    @ApiMethod(name = "updateGdaysSession")
    public GdaysSession updateGdaysSession(GdaysSession gdayssession) {
        EntityManager mgr = getEntityManager();
        try {
            if (!containsGdaysSession(gdayssession)) {
                throw new EntityNotFoundException("Object does not exist");
            }
            mgr.persist(gdayssession);
        } finally {
            mgr.close();
        }
        return gdayssession;
    }

    /**
     * This method removes the entity with primary key id.
     * It uses HTTP DELETE method.
     *
     * @param id the primary key of the entity to be deleted.
     */
    @ApiMethod(name = "removeGdaysSession")
    public void removeGdaysSession(@Named("id") Long id) {
        EntityManager mgr = getEntityManager();
        try {
            GdaysSession gdayssession = mgr.find(GdaysSession.class, id);
            mgr.remove(gdayssession);
        } finally {
            mgr.close();
        }
    }

    private boolean containsGdaysSession(GdaysSession gdayssession) {
        EntityManager mgr = getEntityManager();
        boolean contains = true;
        try {
            GdaysSession item = mgr.find(GdaysSession.class,
                    gdayssession.getKey());
            if (item == null) {
                contains = false;
            }
        } finally {
            mgr.close();
        }
        return contains;
    }

    private static EntityManager getEntityManager() {
        return EMF.get().createEntityManager();
    }

}

Vous pouvez modifier ce code et y ajouter de nouvelles méthodes qui seront explosées par l'API. Mais avant, vous devez être capable de comprendre celui-ci, ainsi que les règles qu'il faut respecter afin que la classe demeure une classe Endpoint valide.

XII-A. Les annotations Cloud Endpoints ▲

@Api(name = "gdayssessionendpoint", 
version = "v2",
description = "API qui manipule l'objet GdaySession",
namespace = @ApiNamespace(ownerDomain = "example.com", ownerName = "example.com", 
             packagePath = "roma.gdaysapp")
)

@ApiMethod(name = "getGdaysSession", 
path="get_gdayssession", 
httpMethod="GET" )

public CollectionResponse<GdaysSession> listGdaysSession(
            @Nullable @Named("cursor") String cursorString,
            @Nullable @Named("limit") Integer limit) {

Si votre API a été créée correctement, vous pouvez générer la bibliothèque client Endpoint correspondante pour exploiter les méthodes de votre Backend Cloud depuis un client Android.

Pour cela, faites un clic droit dans l'explorateur de solution d'Eclipse sur votre projet App Engine, puis cliquez sur « Google », ensuite sur « Generation Cloud Endpoint Client Library », comme l'illustre la capture ci-dessous :

Dès que vous avez généré votre bibliothèque client Cloud Endpoint, le nouveau code qui apparaît dans votre projet Android correspond aux fonctionnalités que vous avez exposées dans votre application App Engine. Ce code est référencé dans un dossier dont le chemin d'accès contient « endpoint-libs ».

Dans votre application Android, créez une nouvelle activité. Cette activité sera utilisée pour l'insertion d'un nouvel élément dans le datastore. Pour créer une nouvelle activité, faites un clic droit sur votre application Android, sélectionnez « Nouveau », puis cliquez sur « Autre ». Dans la fenêtre qui s'affiche, sectionnez « Android Activity ». Cliquez ensuite sur « Suivant », puis renseignez le nom de l'activité et cliquez enfin sur « Fin ».

Ajoutez dans le code Java de votre activité la classe interne asynchrone suivante :

public class EndpointsTask extends AsyncTask<GdaysSession, Void, Long> {
        
        protected Long doInBackground(GdaysSession... params) {

               Gdayssessionendpoint.Builder endpointBuilder = new Gdayssessionendpoint.Builder(
              AndroidHttp.newCompatibleTransport(),
              new JacksonFactory(),
              new HttpRequestInitializer() {
              public void initialize(HttpRequest httpRequest) { }
              });
               Gdayssessionendpoint endpoint = CloudEndpointUtils.updateBuilder(
      endpointBuilder).build();
      try {
                 
          GdaysSession result = endpoint.insertGdaysSession(params[0]).execute();
      } catch (IOException e) {
        e.printStackTrace();
      }
          return (long) 0;
        }
    }

Pour l'affichage des données, vous pouvez utiliser la classe asynchrone suivante :

    private class ListOfGdaysSessionsAsyncRetriever extends AsyncTask<Void, Void, CollectionResponseGdaysSession> {

        @Override
        protected CollectionResponseGdaysSession doInBackground(Void... params) {

            Gdayssessionendpoint.Builder endpointBuilder = new Gdayssessionendpoint.Builder(
              AndroidHttp.newCompatibleTransport(), new JacksonFactory(), null);
         
          endpointBuilder = CloudEndpointUtils.updateBuilder(endpointBuilder);

          CollectionResponseGdaysSession result;

          Gdayssessionendpoint endpoint = endpointBuilder.build();

          try {
            result = endpoint.listGdaysSession().execute();
            
          } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            result = null;
          }
          return result;
        }

        @Override
        @SuppressWarnings("null")
        protected void onPostExecute(CollectionResponseGdaysSession result) {
         
        }
      }

Pour tester l'application sur votre serveur local App Engine, vous devez éditer le fichier CloudEndpointUtils.java de l'application Android et mettre la valeur de LOCAL_ANDROID_RUN à « true ». Ensuite, vous devez renseigner l'URL pour interroger votre serveur au niveau de la variable «  LOCAL_APP_ENGINE_SERVER_URL ».

public class CloudEndpointUtils {

  /*
   * TODO: Need to change this to 'true' if you're running your backend locally using
   * the DevAppServer. See
   * http://developers.google.com/eclipse/docs/cloud_endpoints for more
   * information.
   */
  protected static final boolean LOCAL_ANDROID_RUN = true;

  /*
   * The root URL of where your DevAppServer is running (if you're running the
   * DevAppServer locally).
   */
  protected static final String LOCAL_APP_ENGINE_SERVER_URL = "http://10.0.2.2:8888";

Démarrez ensuite votre serveur local de développement App Engine. Pour cela, faites un clic droit sur votre projet App Engine, puis cliquez sur « Debug As », ensuite sur « Web Application », comme l'illustre la capture ci-dessous :

Dans la procédure onCreate de votre activité, ajoutez les lignes de code suivantes qui permettent d'ajouter un nouvel élément dans la base de données, en utilisant la classe asynchrone que nous avons définie plus haut :

GdaysSession gdaysSession = new GdaysSession();
        
        gdaysSession.setTitle("Introduction à Cloud Endpoints");
        gdaysSession.setDescription("Booster les performances de vote application Android avec App Engine");
        gdaysSession.setTag("Cloud");
        
        new EndpointsTask().execute(gdaysSession);

Enregistrez les modifications, puis procédez à l'exécution de votre application Android.

Pour visualiser les données enregistrées sur votre serveur App Engine local, ouvrez la page suivante dans une fenêtre de votre navigateur : http://localhost:8888/_ah/admin/datastore

Cette page permet d'accéder à l'interface locale de gestion de votre datastore.

Après le test en local, vous pouvez passer au déploiement de votre application Cloud sur App Engine.

Vous allez dans un premier temps renseigner l'ID de votre application sur App Engine. Pour cela, vous allez faire un clic droit sur votre projet, puis cliquer sur « propriétés » et ensuite sur « App Engine » dans la fenêtre qui va s'afficher.

Après avoir renseigné cette information, vous pouvez passer au déploiement de votre application. Il suffira de faire un clic droit sur votre projet, de sélectionner « Google », puis de cliquer sur « Deply to App Engine. »

Pour utiliser l'application déployée sur App Engine dans votre application, il vous suffira juste d'éditer le fichier CloudEndpointUtils.java et mettre « LOCAL_ANDROID_RUN » à « False ». Et c'est tout.

Cloud EndPoints est un outil qui offre souplesse et simplicité au développeur qui souhaite créer une application sur App Engine, dont les fonctionnalités seront exploitées par divers clients, quelle que soit leur plateforme exécution. Au travers de cet article, vous avez découvert comment vous pouvez créer facilement une application Android avec un backend Cloud, dont le code peut évoluer sans difficulté.

• Documentation officielle sur Cloud EndPoints
• Utilisation des EndPoints dans un client Android
• Série de tutoriels de rominirani sur Cloud EndPointsSérie de tutoriels de rominirani sur Cloud EndPoints
• Documentation sur les annotations Cloud EndPointsDocumentation sur les annotations Cloud EndPoints

Je tiens à remercier ClaudeLELOUP pour sa relecture et correction orthographique.