Windows Azure

Création d'une plateforme extrêmement adaptable pour les appareils grand public sur Windows Azure

Bruno Terkaly
Ricardo Villalobos

Télécharger l'exemple de code

Cet article est consacré à l'adaptabilité et à l'interopérabilité, deux caractéristiques nécessaires dans les architectures afin de prendre en charge la diversité des plateformes mobiles populaires d'aujourd'hui, celles-ci regroupant potentiellement des millions d'utilisateurs. La figure 1 décrit cette diversité, un scénario courant, mais qui relève du défi pour les développeurs actuels. Le fait de fournir des services Web aux appareils mobiles est une tâche redoutable, qui requiert des outils, des langages et des IDE distincts et divers. Au-delà de cette diversité, une adaptabilité élastique est également nécessaire, en termes de services Web disponibles et de données susceptibles d'atteindre une taille en téraoctets.

Figure 1 Un ensemble divers de technologies mobiles représente un défi pour les développeurs

Type d'application	Plateforme	Environnement de développement	Langage
Mobile	Windows Phone	Visual Studio	C#
Mobile	Android	Eclipse	Java
Mobile	iOS	Xcode	Objective-C
Serveur Web en nuage	Windows Azure	Visual Studio	C#

Les développeurs doivent adapter leurs applications Web dans deux dimensions différentes. La première dimension relève du calcul, qui se résume au nombre d'instances de service Web rendues disponibles par le fournisseur d'hébergement pour répondre aux requêtes Web mobiles. La deuxième dimension concerne les données adaptables : certaines plateformes de nuage offrent des données adaptables via des services de stockage dédiés, ce qui permet aux développeurs de faire évoluer des téraoctets de données pour des millions d'utilisateurs mobiles et de les partitionner sans aucun effort sur plusieurs serveurs, ce qui entraîne des performances rapides, de la redondance et la prise en charge de pétaoctets de capacité.

Afin de prendre en charge la communication vers autant de clients variés que possible, il est crucial d'adopter une approche interopérable. Il est nécessaire de réfléchir attentivement à tout, des formats de données aux protocoles réseau. Une solution doit réduire au minimum le codage personnalisé et utiliser des normes ouvertes autant que possible.

Dans cet article, nous utilisons les services Web RESTful hébergés dans Windows Azure, la plateforme de nuage Microsoft, afin de résoudre le problème d'adaptabilité élastique et les défis posés par l'interopérabilité.

Une architecture de référence reposant sur les services Web RESTful est décrite à la figure 2. Les architectures RESTful sont interopérables parce qu'elles sont développées avec HTTP/1.x et fournissent une communication cohérente sur un large groupe de clients. L'alternative à REST pour l'architecture est SOAP. Nous avons choisi de ne pas utiliser SOAP parce qu'il a des charges utiles de données plus importantes et plus lentes, ainsi que des complexités supplémentaires.

Figure 2 Une solution reposant sur les normes ouvertes

Windows Azure facilite l'augmentation et la diminution de l'adaptation à la demande. Il suffit de modifier un nombre, le « nombre d'instances », via le portail Windows Azure ou une API de gestion, pour adapter les services Web RESTful presque sans effort afin de répondre à tous les niveaux de demande.

Notre implémentation utilise JSON (et non XML) comme format de données car il est compact et bénéficie d'une large prise en charge. XML souffre de charges utiles plus importantes.

Bien que de nombreux fournisseurs proposent des solutions d'hébergement en nuage pour les services Web RESTful, Windows Azure présente quelques avantages. Tout d'abord, vous pouvez choisir parmi six centres de données hautement automatisés en Asie, Europe et Amérique du Nord, dont une prise en charge par 24 réseaux de distribution de contenus (CDN), ce qui permet une connexion aux utilisateurs avec une faible latence et la localité des données.

Windows Azure propose un large éventail d'options de stockage et de calcul, outre des outils développeur puissants. Divers mécanismes de stockage sont disponibles, des objets BLOB (Binary Large Object) aux magasins relationnels. Windows Azure fournit également des systèmes de gestion de l'identité, une messagerie sécurisée, ainsi que des fonctionnalités hybrides de connectivité en nuage/locale.

Pour commencer

Le reste de cet article divisera l'architecture et l'implémentation en quatre parties :

1. Configurer un compte à l'aide du portail Windows Azure.
2. Créer un projet de nuage Windows Azure et écrire du code pour définir un service Web RESTful.
3. Déployer le projet de nuage sur le compte à l'aide du portail Windows Azure.
4. Créer des applications mobiles pour : Windows Phone, Android et iOS (iPhone/iPad).

Nous allons examiner ces étapes ensemble. La première se déroule dans le portail Windows Azure auquel vous pouvez accéder à l'adresse windows.azure.com si vous disposez d'un abonnement. Pour plus d'informations, consultez le site azure.com.

Partie 1 : Configuration du service Web dans le portail Windows Azure

Dans le portail Windows Azure, les deux options clés sont les suivantes : nouveau service hébergé et nouveau compte de stockage.

La figure 3 illustre le workflow de configuration d'un « service hébergé ». Ce processus va créer une URL représentant le point de terminaison dans un centre de données Microsoft où le service Web RESTful sera déployé. Les développeurs d'applications Windows Phone, Android et iOS auront besoin de cette URL pour communiquer avec le service.

Figure 3 Configuration du service Web RESTful Windows Azure

Le workflow de mise en place de tout cela est simple :

1. Connectez-vous au portail Windows Azure.
2. Sélectionnez « New Hosted Service ». Spécifiez un nom de compte, une URL et une région (emplacement du centre de données).
3. Stockez l'URL générée par le portail Windows Azure. Elle sera utilisée, avec le nom de compte, lors de la création du service Web RESTful et des clients mobiles. Le nom de compte sera également utilisé au cours de la troisième partie.

Remarque : l'exemple de cet article utilise le nom de compte « fastmotorcycleservice » avec l'URL « http://fastmotorcycleservice.cloudapp.net ».

La deuxième tâche du portail Windows Azure consiste à créer un compte de stockage. La figure 4 illustre ce processus, dont le nom et l'emplacement des tables Windows Azure. Nous vous rappelons ici encore qu'il est possible de choisir parmi les six centres de données. Il est judicieux d'héberger le service Web et les données dans le même centre de données afin de réduire les coûts et d'améliorer les performances.

Figure 4 Configuration du compte de stockage Windows Azure

Le workflow est similaire à celui du « service hébergé » que nous avons vu précédemment :

1. Connectez-vous au portail Windows Azure.
2. Créez un nouveau compte de stockage et fournissez un nom de compte et une région.
3. Stockez la clé d'accès générée et fournie par le portail Windows Azure, ainsi que le nom de compte. Ces informations seront nécessaires lors de la création du service Web RESTful.

Maintenant que la première partie est terminée, les informations nécessaires du portail Windows Azure peuvent être utilisées pour écrire le service Web RESTful, ainsi que les applications Windows Phone, Android et iOS.

Partie 2 : Création du service Web RESTful hébergé par Windows Azure

Il est simple de créer un service Web RESTful dans Visual Studio. Ouvrez Visual Studio en tant qu'administrateur depuis Démarrer | Tous les programmes | Microsoft Visual Studio 2010 en cliquant avec le bouton droit sur le raccourci de Microsoft Visual Studio 2010 et en sélectionnant « Exécuter en tant qu'administrateur ». Dans le menu Fichier, sélectionnez Nouveau | Projet.

Dans la boîte de dialogue Nouveau projet, développez le langage favori dans la liste Modèles installés, puis sélectionnez Nuage. Choisissez le modèle Projet Windows Azure, définissez le nom du projet sur FastMotorcycleProject, puis définissez l'emplacement qui vous convient.

Vous trouverez une vidéo illustrant ces étapes en détails sur bit.ly/VideoAzureRestfulService.

L'Explorateur de solutions ressemblera à la figure 5.

Figure 5 Création d'un projet Windows Azure

La figure 6 illustre certaines étapes de base qui ne sont pas couvertes dans cet article (mais qui le sont dans la vidéo référencée).

Figure 6 Étapes de base non couvertes dans cet article

Tâche couverte dans la vidéo	Remarques
Ajout d'un rôle Web ASP.NET	Sera utilisée pour héberger le service Web RESTful
Ajout d'une DataConnectionString	Comprendra le nom de compte et la clé d'accès
Ajout d'un code de démarrage de base pour initialiser les données	Ajouter du code à global.asax.cs pour lire la DataConnectionString

Ces étapes sont communes à presque tous les projets Windows Azure. Par exemple, il est courant d'utiliser un rôle Web pour héberger les services Web RESTful. Une DataConnectionString est nécessaire pour accéder au compte de stockage défini précédemment sur le portail Windows Azure. Un code de démarrage est nécessaire dans le projet Visual Studio pour lire les noms de compte et les clés d'accès des fichiers de configuration à utiliser pour les comptes de stockage.

Une fois les étapes préliminaires terminées, un service Web RESTful peut être ajouté à l'aide du modèle Service WCF dans Visual Studio.

Pour ajouter un service WCF, cliquez avec le bouton droit sur le dossier FastMotorcycleProject_WebRole, sélectionnez la boîte de dialogue Ajouter | Nouvel élément et définissez le nom de la classe sur FastMotorcycleService.

FastMotorcycleService.svc.cs est généré. Remplacez tout le code de la classe par celui illustré à la figure 7.

Pour que cela fonctionne, l'astuce consiste à savoir mapper différents URI et verbes aux méthodes RESTful. Pour cela, les attributs WebGet et WebInvoke doivent être ajoutés au code de la figure 7.

Figure 7 FastMotorcycleListService.svc.cs

[ServiceContract]
public class FastMotorcycleListService
{
  private FastMotorcycleListDataProvider _data;
  
  public FastMotorcycleListService()
  {
    _data = new FastMotorcycleListDataProvider();
  }

  [OperationContract]
  [WebGet(UriTemplate = "/list/{owner}", ResponseFormat = 
    WebMessageFormat.Json)]
  public List<string> GetItems(string owner)
  {
    return _data.GetItems(owner);
  }

  [OperationContract]
  [WebInvoke(UriTemplate = "/list/{owner}", Method = "POST",
    RequestFormat = WebMessageFormat.Json)]
  public void AddItem(string owner, string item)
  { 
    _data.AddItem(owner, item);
  }

  [OperationContract]
  [WebInvoke(UriTemplate = "/list/{owner}/{item}", Method = "DELETE")]
  public void DeleteItem(string owner, string item)
  {
    _data.DeleteItem(owner, item);
  }
}

Ces attributs indiquent à l'infrastructure que la méthode doit répondre aux requêtes HTTP GET. WebInvoke est mappée à HTTP POST par défaut. En outre, par défaut, l'URI est déterminé par le nom de la méthode (ajouté à l'URI de base du point de terminaison). Certains experts ou puristes REST pourraient soutenir que les noms de méthode ne doivent pas être des verbes, mais plutôt des noms.

Le modèle de programmation WCF REST illustré à la figure 8 permet une personnalisation des URI pour chaque méthode à l'aide de modèles susceptibles d'être définis via la propriété UriTemplate sur les attributs WebInvoke et WebGet. Ce modèle est expliqué dans la liste suivante, avec des chiffres correspondant à ceux de la figure 8 :

Figure 8 Workflow d'une application mobile demandant des données RESTful

1. Une application mobile utilise le HTTP standard pour envoyer une demande de message qui comprend un verbe HTTP plus une URL.
2. Le service Web RESTful intercepte la demande de message de l'application mobile (demande de données) et appelle GetItems, en passant « Bruno » comme paramètre. GetItems interroge les données à l'aide de la requête LINQ, en utilisant « Bruno » comme partie de la clause.
3. Seuls les enregistrements dans lesquels la PartitionKey est égale à « Bruno » sont renvoyées du service de table Windows Azure.
4. Les données sont converties au format JSON (automatiquement) et renvoyées vers l'appareil mobile.
5. Les données sont disponibles pour l'application mobile. Ces données sont utilisées pour remplir une ListBox et présentées à l'utilisateur de l'application mobile.

Les trois classes suivantes dont nous allons parler ici sont des objets d'assistance nécessaires pour interagir avec le service de table Windows Azure. FastMotorcycleListDataProvider, FastMotorcycleListItem et FastMotorcycleList sont des classes qui retirent des détails d'API propres aux tables Windows Azure du code illustré à la figure 9, permettant ainsi à l'application d'effectuer des opérations CRUD (Create, Read, Update, Delete) avec le service de table Windows Azure.

Dans Visual Studio, ajoutez un module de classe nommé FastMotorcycleListDataProvider.cs. Remplacez le code par celui de la figure 9.

Figure 9 Les classes FastMotorcycleListDataProvider, FastMotorcycleListItem et FastMotorcycleList

public class FastMotorcycleListDataProvider
{
  private FastMotorcycleList _list;

  public FastMotorcycleListDataProvider()
  {
    string configValue = RoleEnvironment.GetConfigurationSettingValue(
      "DataConnectionString");
    var account = CloudStorageAccount.Parse(configValue);

    _list = new FastMotorcycleList(account.TableEndpoint.ToString(),
                                   account.Credentials);
  }
 
  public List<string> GetItems(string owner)
  {
    var results = from entity in _list.Items
                  where entity.PartitionKey == owner
                  select entity;

    var list = new List<string>();
    foreach (var item in results)
    {
      list.Add(item.RowKey);
    }

    return list;
  }
 
  public void AddItem(string owner, string item)
  {
    _list.AddObject("FastBikes", new FastMotorcycleListItem(owner, item));
    _list.SaveChanges();
  }

  public void DeleteItem(string owner, string item)
  {
    var entity = (from i in _list.Items
                  where i.PartitionKey == owner
                  && i.RowKey == item
                  select i).Single();

    _list.DeleteObject(entity);
    _list.SaveChanges();
  }
}

 
public class FastMotorcycleListItem : TableServiceEntity
{
  public FastMotorcycleListItem()
  {
  }
 
  public FastMotorcycleListItem(string partitionKey, string rowKey)
    : base(partitionKey, rowKey)
  {
  }
}
 
public class FastMotorcycleList : TableServiceContext
{
  public FastMotorcycleList(string baseAddress,
    StorageCredentials storageCredentials)
    : base(baseAddress, storageCredentials)
  {
  }
 
  public DataServiceQuery<FastMotorcycleListItem> Items
  {
    get
    {
      return this.CreateQuery<FastMotorcycleListItem>("FastBikes");
    }
  }
}

Partie 3 : Déploiement du service Web RESTful

Il s'agit de l'un des domaines dans lesquels Windows Azure brille véritablement. Il est aussi simple de déployer 100 instances de service Web RESTful que d'en déployer une seule. Notez la liste d'étapes suivantes :

1. Dans Visual Studio, cliquez avec le bouton droit sur FastMotorcycleProject et sélectionnez Package.
2. Revenez dans le navigateur avec le portail et sélectionnez « Hosted Services, Storage Accounts & CDN ».
3. Dans le volet supérieur, sélectionnez « Hosted Services ».
4. Dans le volet central, sélectionnez le service hébergé créé précédemment.
5. Cliquez avec le bouton droit et sélectionnez « New Production Deployment », puis téléchargez les fichiers (FastMotorcycleProject.cspkg et ServiceConfiguration.Cloud.cscfg). Ces fichiers ont été générés au cours de la première étape.

Partie 4 : Utilisation du service Web RESTful à partir d'applications mobiles

Nous allons maintenant aborder l'utilisation des services Web RESTful à partir de diverses applications mobiles. Cette section est destinée à souligner l'interopérabilité fournie par cette approche.

Le JSONKit (github.com/johnezang/JSONKit) facilite l'interaction avec le service Web RESTful à partir d'appareils iOS. Avec quelques lignes de code, il est possible d'appeler le service Web RESTful, de télécharger les données formatées JSON, de les convertir en un format plus utilisable et d'associer les données converties à un contrôle Vue Table utilisé par les applications iPhone ou iPad (voir la figure 10).

Figure 10 Code Objective-C qui analyse les données JSON

NSString *username = @"Bruno"; // Gets passed to the RESTful Web Service
  
NSString *serviceUri = "http://your_hosted_service_name.cloudapp.net/"+
  "FastMotorcycleListService.svc/list/";
// Build the service URI (will point to our RESTful Web service
NSString *url = [NSString stringWithFormat:@"%@%@", serviceUri, username];
      
// Retrieve the data in the form of a JSON array
NSData *json = [NSData dataWithContentsOfURL:[NSURL URLWithString:url]];
     
// Convert from JSON array to NSArray
// This allows us to populate the table view more easily
NSArray *itemArray = [json objectFromJSONData];
     
// Assign the array to the TableView
// fastbikes is the name of our TableView control
self.fastbikes = [[NSMutableArray alloc] initWithArray:itemArray];

Le développement pour Android implique le langage de programmation Java qui existe depuis longtemps et peut analyser les données JSON en mode natif. La figure 11 en propose un exemple. Le Windows Phone SDK comprend une prise en charge native pour appeler les services Web RESTful et traiter les données formatées JSON. Ce Kit de développement logiciel facilite le traitement des données JSON avec DataContractJsonSerializer. La figure 12 en propose un exemple. En dernier lieu, si vous souhaitez voir une boîte à outils plus robuste afin de développer pour Android et iOS, vous pouvez consulter le site suivant approuvé par Microsoft : github.com/microsoft-dpe.

Figure 11 Code Android qui analyse les données JSON

    // HttpClient used to talk to Web service
    HttpClient httpclient = new DefaultHttpClient();
                  
    String url = 
      "http://your_hosted_service_name.cloudapp.net/"+
      "FastMotorcycleListService.svc/list/Bruno";
    // This will be the array we need to convert
    // We get the data from the Web service
    JSONArray listItems = null;
    String jason = null;
                  
    // Set up the RESTful call to 'GET' the data
    HttpGet request_http_get = new HttpGet(url);
      
                  
    // Read the JSON data and assign it to ListView
    try 
    {
      // Fill a response object using a request
      HttpResponse response_http_get = httpclient.execute(request_http_get);
                
      // Length represents the number of data items returned
      // by RESTful Web service
      long length = response_http_get.getEntity().getContentLength();
    
      // "entity" ends up being the data coming back from Web server
      HttpEntity entity = response_http_get.getEntity();
     
      // Read the bytes, one byte at a time
      InputStream stream = entity.getContent();
                     
      // Allocate a series of bytes
      byte[] buffer = new byte[(int) length];
                    
      // Read bytes from RESTful Web service
      // After this loop, we end up with something like -> 
      // ["busa","gxr1000","ninja250"]
      for (int i = 0; i < length; i++) 
      {
        buffer[i] = (byte) stream.read();
      }
      // Create an array of strings
      jason = new String(buffer);
      // Convert to JSON array for Android ListBox
      // listItems ends up being a three-element JSON array (see "busa")
      listItems = new JSONArray(jason);
      } 
      catch (Exception e) 
      {
        System.out.println(e);
      }

Figure 12 Code C# qui analyse les données JSON

private void LoadList()
{
  string uri =   
    @"http://your_hosted_service_name.cloudapp.net/"+
    "FastMotorcycleListService.svc/list/Bruno";
  var webRequest = (HttpWebRequest)WebRequest.Create(uri);
  webRequest.Method = "GET";
 
  try
  {
    webRequest.BeginGetResponse(new AsyncCallback((result) =>
    {
      var webResponse = 
        (HttpWebResponse)webRequest.EndGetResponse(result);
  
      if (webResponse.StatusCode == HttpStatusCode.OK)
      {
        var jsonDeserializer = 
          new DataContractJsonSerializer(typeof(List<string>));
        List<string> items = 
          (List<string>)jsonDeserializer.ReadObject(
          webResponse.GetResponseStream());                      

        shoppingListBox.Dispatcher.BeginInvoke(new Action(() =>
        {
          shoppingListBox.Items.Clear();
          foreach (var item in items)
          {
            shoppingListBox.Items.Add(item);
          }
        }));
      }

    }), null);
  }
  catch
  {
     // Ignored
  }
}

Accès à toute la gamme d'appareils

Étant donné que les services Web RESTful hébergés sur Windows Azure reposent sur HTTP, toute application cliente qui prend en charge ce protocole est capable de communiquer avec eux. Les développeurs ont ainsi accès à un large éventail d'appareils étant donné que la plupart d'entre eux tombent dans cette catégorie. Bien que nous ayons couvert les plateformes mobiles dans cet article, les implémentations JavaScript telles que jQuery sont également capables d'utiliser des services Web RESTful. Quel que soit le chemin pris par les plateformes mobiles en ce qui concerne la diversité des interfaces utilisateur, il sera toujours judicieux de se reposer sur des architectures de service Web HTTP simples et ouvertes.

Bruno Terkaly est développeur pour Microsoft. Ses connaissances approfondies sont issues d'années d'expérience dans le domaine, au cours desquelles il a écrit du code à l'aide d'une multitude de plateformes, de langages, d'infrastructures, de SDK, de bibliothèques et d'API. Il se consacre à l'écriture de code, à l'écriture sur un blog et à des présentations sur la création d'applications de nuage, plus particulièrement à l'aide de la plateforme Windows Azure.

Ricardo Villalobos est un architecte logiciel aguerri qui bénéficie de plus de 15 ans d'expérience dans la conception et la création d'applications pour des entreprises exerçant dans le secteur de gestion de la chaîne d'approvisionnement. Il a reçu différentes certifications Microsoft, ainsi qu'un MBA en gestion de la chaîne d'approvisionnement de l'Université de Dallas. Il a rejoint Microsoft en 2010 au poste d'architecte Windows Azure.

Merci aux experts techniques suivants d'avoir relu cet article : Reza Alizadeh et Wade Wegner