Créer une application mobile avec Google Compute Engine et REST

L'exécution de votre backend mobile sur Compute Engine et l'utilisation de REST comme protocole de communication entre votre application mobile et le serveur backend présentent plusieurs avantages :

  • Il s'agit du moyen le plus rapide de déplacer un service existant, fonctionnant sur une machine sur site ou virtuelle, vers Google Cloud.
  • Vous obtenez un contrôle total sur la configuration de votre machine virtuelle et de votre serveur.
  • Vous pouvez recourir à des bibliothèques tierces.
  • Vous pouvez configurer un autoscaler pour mettre à l'échelle le nombre de machines virtuelles nécessaires afin de répondre à la demande.

L'inconvénient de l'exécution de votre service sur Compute Engine est que vous êtes responsable de la maintenance et de la mise à jour du serveur.

Ce tutoriel vous explique comment créer un exemple d'application mobile appelée "Stickynotes". Cet exemple d'application exploite le protocole REST pour se connecter à un service de backend s'exécutant sur Compute Engine.

Le code de l'exemple Stickynotes correspond à une application mobile frontend et à un service de backend, qui fonctionnent ensemble dans le workflow suivant :

  1. L'application mobile vous permet de saisir un message dans un champ de texte.
  2. L'application envoie le message à un point de terminaison REST dans le service de backend.
  3. Le service de backend crée une image contenant le message texte à l'aide de la bibliothèque draw2d.
  4. Le service de backend renvoie l'image à l'application mobile.
  5. L'application mobile affiche l'image avec le message intégré.

L'application cliente est une application iOS et le service de backend est écrit dans le langage de programmation Go.

Objectifs

Ce tutoriel montre comment :

  • créer une application mobile iOS qui se connecte à un point de terminaison REST dans le service de backend ;
  • configurer et exécuter un service de backend REST sur Compute Engine.

Coûts

Ce tutoriel utilise une instance Compute Engine, un composant facturable de Google Cloud.

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de GCP peuvent bénéficier d'un essai gratuit.

Avant de commencer

  1. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.
  2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  3. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

Installez les composants suivants :

Cloner l'exemple de code

Exécutez la commande suivante pour cloner l'exemple de code :

git clone https://github.com/GoogleCloudPlatform/ios-docs-samples.git

Accédez ensuite au répertoire /solutions/stickynoteapi/REST pour trouver l'exemple de code de cette solution.

Exécuter le serveur localement

Exécutez la commande suivante dans le répertoire /stickynoteapi/REST/Go :

sh SETUP

La commande affiche le résultat suivant :

1. Set gopath and search path
2. Get the server and client dependencies
3. Build the server and client
4. Stop any previously-running instances of the server
5. Start the server
6. Run the client
2016/03/02 11:34:48 OK: message.png
7. Open the image in message.png

La configuration exécute également un client local pour tester le serveur avec la phrase "Remember the milk." Le serveur génère un fichier message.png contenant l'image correspondante.

Remember the milk.

Pour générer des images de vos propres messages avec le client de ligne de commande, exécutez la commande suivante :

./client "This is a test..."

Le fichier /stickynoteapi/REST/Go/go/src/server/server.go contient le code qui exécute le serveur REST. La fonction "main" définit un gestionnaire pour le répertoire à la racine, et écoute le trafic sur le port 8080.

func main() {
	http.HandleFunc("/stickynote", handler)
	http.ListenAndServe(":8080", nil)
	//http.ListenAndServeTLS(":443", "ssl.crt", "ssl.key", nil)
}

Le serveur achemine les requêtes entrantes vers la fonction handler, qui effectue les actions suivantes :

  1. Elle extrait le message texte de la requête REST.
  2. Elle crée une image basée sur le message texte à l'aide des fonctions définies dans sticky.go.
  3. Elle renvoie l'image au client dans une réponse REST.
func handler(w http.ResponseWriter, r *http.Request) {
	var sticky Sticky
	sticky.Message = r.FormValue("message")
	sticky.Centered = false
	stickyBytes, err := sticky.DrawPNG(512, 512)
	if err == nil {
		w.Write(*stickyBytes)
	}
}

Laissez le serveur local en cours d'exécution afin que vous puissiez vous en servir pour tester l'application cliente dans la section suivante.

Exécuter le client iOS avec le serveur local

  1. Ouvrez le fichier stickynotes.xcodeproj du répertoire stickynoteapi/REST/Objective-C/ dans Xcode.
  2. Sélectionnez Produit > Exécuter pour compiler et démarrer l'application cliente.
  3. Saisissez un message dans le champ de texte, puis appuyez sur Entrée.

L'image d'une note jaune contenant le message apparaît sous le champ de texte.

This is a test...

L'application cliente définit l'emplacement du service de backend dans le fichier StickyNotesViewController.m. À des fins de test, il est initialement défini sur "localhost" sur le port 8080.

static NSString * const kHostAddress = @"localhost:8080";

Lorsque vous appuyez sur Return (Entrée) après avoir saisi le message dans le champ de texte, l'application encode le message dans une chaîne de requête, puis l'envoie au serveur dans une requête REST. L'application reçoit la réponse REST, extrait l'image générée et l'affiche dans une vue d'image. Le code suivant montre l'action qui gère ces tâches :

- (IBAction) textFieldDidEndEditing:(UITextField *)textField
{
  NSString *queryString = [NSString stringWithFormat:@"http://%@/stickynote?message=%@",
                           kHostAddress,
                           [textField.text urlencode]];
  NSURL *URL = [NSURL URLWithString:queryString];
  _request = [NSMutableURLRequest requestWithURL:URL];

  NSURLSession *session = [NSURLSession sharedSession];
  _task = [session dataTaskWithRequest:_request
                     completionHandler:
           ^(NSData *data, NSURLResponse *response, NSError *error) {
             UIImage *image = [UIImage imageWithData:data];
             dispatch_async(dispatch_get_main_queue(), ^{
                              self.imageView.image = image;
                            });
           }];
  [_task resume];
}

Exécuter le serveur sur Compute Engine

Pour héberger le serveur sur Compute Engine, créez une instance de calcul :

  1. Dans Cloud Console, accédez à la page Instances de VM.

    Accéder à la page Instances de VM

  2. Cliquez sur Créer une instance.
  3. Définissez le paramètre Nom sur sticky-rest.
  4. Dans la section Disque de démarrage, cliquez sur Modifier pour commencer à configurer le disque de démarrage.
  5. Dans l'onglet Public images, sélectionnez Google Drawfork Debian GNU/Linux 9.

  6. Cliquez sur Sélectionner.
  7. Dans la section Pare-feu, sélectionnez Autoriser le trafic HTTP et Autoriser le trafic HTTPS.
  8. Cliquez sur Créer pour créer l'instance.

Pour permettre au client d'effectuer des requêtes sur l'instance, créez une règle de pare-feu :

  1. Accédez à la page Pare-feu dans Cloud Console.

    Accéder à la page Pare-feu

  2. Dans la page Créer une règle de pare-feu, saisissez les informations suivantes :

    • Nom : sticky-rest
    • Tags cibles : http-server
    • Plages d'adresses IP sources : 0.0.0.0/0
    • Protocole et ports : tcp:8080
  3. Cliquez sur Créer.

Pour démarrer le serveur sur l'instance, clonez le code du serveur et exécutez le script d'installation :

  1. Dans la liste des instances de machine virtuelle, cliquez sur SSH sur la ligne de l'instance à laquelle vous souhaitez vous connecter.

    bouton SSH en regard du nom de l'instance.

  2. Notez l'adresse IP de votre instance de VM. Vous la trouverez dans la colonne External IP (Adresse IP externe).
  3. Installez Git sur l'instance :

    sudo apt update
    sudo apt install git
    
  4. Installez les outils Go :

    sudo wget https://storage.googleapis.com/golang/go1.10.linux-amd64.tar.gz
    sudo tar -C /usr/local -xzf go1.10.linux-amd64.tar.gz
    export PATH="/usr/local/go/bin:${PATH}"
    
  5. Clonez le code du serveur Stickynotes :

    git clone https://github.com/GoogleCloudPlatform/ios-docs-samples.git
    
  6. Démarrez le serveur Stickynotes sur l'instance. Exécutez la commande suivante dans le répertoire /solutions/stickynoteapi/REST/Go :

    sh SETUP
    

Pour configurer et exécuter l'application cliente :

  1. Dans Xcode, modifiez StickyNotesViewController.m pour remplacer "localhost" par la valeur du champ Adresse IP externe de votre instance Compute Engine obtenue à une étape précédente.

    // static NSString \* const kHostAddress = @"localhost:8080";
    static NSString \* const kHostAddress = @"[YOUR-INSTANCE-EXTERNAL-IP]:8080";
    
  2. Sélectionnez File > Save (Fichier > Enregistrer) pour enregistrer les modifications.

  3. Sélectionnez Product > Run (Produit > Exécuter) pour compiler et démarrer l'application cliente.

  4. Saisissez un message dans le champ de texte, puis appuyez sur Return (Entrée).

L'image d'une note jaune contenant le message remplace l'arrière-plan gris.

Testing on remote server...

Nettoyer

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et les ressources individuelles.

Supprimer le projet

Le moyen le plus simple d'empêcher la facturation est de supprimer le projet que vous avez créé pour ce tutoriel.

Pour supprimer le projet :

  1. Dans Cloud Console, accédez à la page Gérer les ressources.

    Accéder à la page Gérer les ressources

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Supprimer des instances

Pour supprimer une instance Compute Engine, procédez comme suit :

  1. Dans Cloud Console, accédez à la page Instances de VM.

    Accéder à la page Instances de VM

  2. Cochez la case correspondant à votre instance sticky-rest.
  3. Pour supprimer l'instance, cliquez sur Autres actions , cliquez sur Supprimer, puis suivez les instructions.

Supprimer des règles de pare-feu pour le réseau par défaut

Pour supprimer une règle de pare-feu, procédez comme suit :

  1. Dans Cloud Console, accédez à la page Pare-feu.

    Accéder à la page "Pare-feu"

  2. Cochez la case correspondant à règle de pare-feu que vous souhaitez supprimer.
  3. Pour supprimer la règle de pare-feu, cliquez sur  Supprimer.

Étapes suivantes

Cet exemple explique la procédure de base pour connecter une application mobile au code exécuté sur Compute Engine à l'aide du protocole REST. Pour intégrer cet exemple à une application réelle, ajoutez les améliorations suivantes :

  • Ajoutez une adresse IP statique à votre serveur. Par défaut, l'adresse externe associée à une instance Compute Engine est provisoire. Dans une application de production, associez une adresse IP externe statique à l'instance. Pour en savoir plus, consultez la page Configurer l'adresse IP d'une instance.

  • Connectez-vous à un serveur HTTPS à l'aide d'identifiants. Assurez-vous que l'application mobile ne peut pas appeler le service de backend sans identifiants avec lesquels s'authentifier sur le serveur. Protégez la confidentialité des données que les utilisateurs envoient au serveur en utilisant le protocole chiffré HTTPS plutôt que HTTP. Pour ce faire, vous pouvez exécuter un serveur NGINX en tant que proxy SSL sur l'instance, ou exécuter le serveur backend dans l'environnement flexible App Engine. Pour en savoir plus, consultez la page Se connecter en toute sécurité aux instances de VM.

  • Mettez en place l'équilibrage de charge et l'autoscaling. Gérez les pics de trafic de façon optimale en configurant un équilibreur de charge et un autoscaler, pour générer des instances supplémentaires lorsque la demande augmente, et pour répartir le trafic de façon uniforme entre ces instances. Pour en savoir plus, consultez les pages Configurer l'équilibrage de charge HTTP(S) et Procéder à l'autoscaling de groupes d'instances.

  • Essayez le protocole gRPC au lieu de REST. gRPC est un framework qui permet à une application mobile d'appeler directement des méthodes sur un service de backend comme s'il s'agissait d'un objet local. gRPC vous permet de rendre votre application mobile plus économe en bande passante et de réduire la latence entre l'application et le service de backend exécuté sur GCP. Pour obtenir un exemple décrivant l'utilisation de gRPC pour Stickynotes, consultez la page "Créer une application mobile avec Google Compute Engine et gRPC".

  • Envisagez d'autres options d'hébergement pour votre service de backend. Compute Engine offre le plus haut niveau de contrôle sur votre machine virtuelle. Mais pour en profiter, vous devez mettre à jour et gérer manuellement votre instance. Pour en savoir plus sur les autres façons d'héberger un service de backend mobile sur Cloud Platform, consultez la page Créer des applications mobiles avec Google Cloud.