Freigeben über

  • Artikel

Dieser Artikel wurde maschinell übersetzt.

Windows Azure

Creazione di una piattaforma estremamente scalabile per dispositivi consumer in Windows Azure

Bruno Terkaly
Ricardo Villalobos

Questo articolo parla di scalabilità e interoperabilità, due caratteristiche che sono tenute in architetture a sostenere la diversità delle popolari piattaforme mobili di oggi, potenzialmente avere milioni di utenti.Figura 1 raffigura questa diversità, una comune — ancora impegnativo — scenario per gli sviluppatori di oggi.Fornitura di servizi basati sul Web per dispositivi mobili è un compito arduo, che richiede utensili distinti e diversificata, lingue e idi.Di là di questa diversità è la necessità di scala elastico — in termini di servizi Web disponibili e per i dati che possono raggiungere terabyte di dimensioni.

Figura 1 diversi Set di tecnologie Mobile È una sfida per gli sviluppatori

Tipo di applicazione Platform Ambiente di sviluppo Linguaggio
Cellulare Windows Phone Visual Studio C#
Cellulare Androide Eclissi Java
Cellulare iOS Xcode Objective C
Server Web basato su cloud Windows Azure Visual Studio C#

Gli sviluppatori devono ridimensionare le proprie applicazioni Web in due dimensioni diverse.La prima dimensione è il calcolo, che semplicemente si riduce il numero di istanze del servizio Web messi a disposizione dal provider di hosting per rispondere alle richieste Web mobile.La seconda dimensione è dati scalabile: Alcune piattaforme di nube offrono dati scalabile attraverso servizi di archiviazione dedicata, consentire agli sviluppatori di scala terabyte di dati a milioni di utenti di telefonia mobile e senza sforzo di partizione su più server, con conseguente prestazioni veloci, ridondanza e supporto per petabyte di capacità.

Per supportare la comunicazione ai clienti diversi come molti possibili, un approccio interoperabile è cruciale.Tutto, dai formati dati per i protocolli di rete ha bisogno di un'attenta considerazione.Una soluzione deve ridurre al minimo la codifica personalizzata e sfruttare gli standard aperti nella massima misura possibile.

Stiamo utilizzando servizi RESTful Web ospitati in Windows Azure — piattaforma Microsoft nube — in questo articolo per risolvere i problemi di interoperabilità sia il problema su scala elastico.

Un'architettura di riferimento basata su servizi RESTful Web viene raffigurata in Figura 2.Architetture riposante sono interoperabili, perché stai sviluppati insieme a HTTP/1.x e fornire una comunicazione coerenza attraverso una vasta gamma di clienti.L'alternativa di architettura al resto è SOAP.Abbiamo scelto di non utilizzare sapone perché ha carichi di dati più grande, più lento e ulteriore complessità.

A Solution Based on Open Standards
Figura 2 soluzione basata su standard aperti

Windows Azure rende facile per aumentare e diminuire la scala su richiesta.Cambiando semplicemente un numero — "Conte di istanza" — attraverso il portale Azure di Windows o un management API, potete ridimensionare servizi RESTful Web quasi senza sforzo per soddisfare qualsiasi livello della domanda.

La nostra implementazione utilizza JSON (e non XML) come i dati formato perché è compatto e ampiamente supportato.XML soffre di più ampia portata.

Anche se molti fornitori offrono soluzioni per servizi RESTful Web hosting nube, Windows Azure ha alcuni vantaggi.Per cominciare, è possibile scegliere tra sei centri dati altamente automatizzati in Asia, Europa e Nord America, tra cui il supporto da 24 Content Delivery Network (CDN), rendendo possibile connettere gli utenti con bassa latenza e località dei dati.

Windows Azure offre una matrice di archiviazione e di elaborazione opzioni oltre al potente sviluppatore dell'utensileria.Una varietà di meccanismi di archiviazione sono disponibili, da grandi oggetti BLOB (Binary) ai negozi relazionale.Windows Azure fornisce anche sistemi di gestione di identità, sicuri di messaggistica e le funzionalità di connettività nube/locale ibrido.

 Guida introduttiva

Il resto di questo articolo si divide l'architettura e l'implementazione in quattro parti:

  1. Eseguire il provisioning di un account tramite il portale Azure di Windows.
  2. Creare un progetto di Windows Azure Cloud e scrivere del codice per definire un servizio RESTful Web.
  3. Distribuire il progetto nube l'account utilizzando il portale Azure di Windows.
  4. Costruire applicazioni mobili per: Windows Phone, Android e iOS (iPhone/iPad).

Andiamo attraverso questi passaggi insieme.Il primo si si svolge presso il portale Azure Windows, cui è possibile accedere a azure.microsoft.com se avete un abbonamento.(Per ulteriori informazioni, visitare azure.com.)

Parte 1: Il servizio Web alle finestre di provisioning azzurro Portal

Le due opzioni principali presso il portale Azure Windows sono: Nuovo servizio e nuovo Storage Account ospitato.

Figura 3 illustra il flusso di lavoro per il provisioning di un "servizio ospitato." Questo processo si tradurrà in un URL che rappresenta l'endpoint in un datacenter Microsoft dove verrà distribuito il servizio RESTful Web.Gli sviluppatori di applicazioni Windows Phone, Android e/O bisogno di questo URL per comunicare con il servizio.

Provisioning the Windows Azure RESTful Web Service
Figura 3 il servizio azzurro RESTful Web Windows di Provisioning**

Il flusso di lavoro per ottenere tutto questo lavoro è semplice:

  1. Accedi alle finestre azzurre Portal.
  2. Selezionare "Nuovo servizio ospitato". Specificare un nome di account, un URL e una regione (posizione del datacenter).
  3. Negozio l'URL il portale Azure Windows genera; esso verrà utilizzato — insieme con il nome dell'account — quando si costruisce il client mobile sia il servizio RESTful Web.Il nome dell'account servirà anche nella parte 3.

Nota: L'esempio in questo articolo utilizza il nome account "fastmotorcycleservice," con l'URL "http://fastmotorcycleservice.cloudapp.netto".

La seconda attività presso il portale Azure Windows è la creazione di un Account di archiviazione.Figura 4 illustra questo processo, tra cui il nome e la posizione delle tabelle Windows Azure.Ancora una volta, è possibile scegliere tra i sei datacenter.Ha senso per ospitare i dati nel datacenter stesso ridurre i costi e migliorare le prestazioni e il servizio Web.

Provisioning the Windows Azure Storage Account
Figura 4 l'Account di Windows Storage azzurro di Provisioning

Il flusso di lavoro è simile al "servizio ospitato", ha spiegato in precedenza:

  1. Accedi alle finestre azzurre Portal.
  2. Creare un nuovo account di archiviazione e fornire un nome di account e di una regione.
  3. Store la chiave di accesso al portale Azure Windows genera e fornisce, come pure il nome dell'account; essi saranno richiesti quando si costruisce il servizio RESTful Web.

Ora che la parte 1 è completa, le informazioni necessarie portale Azure Windows consente di scrivere il servizio RESTful Web così come le applicazioni Windows Phone, Android e iOS.

Parte 2: Costruire le finestre Azure ospitato di servizio RESTful Web

Creazione di un servizio RESTful Web in Visual Studio è semplice.Aprire Visual Studio come amministratore dall'inizio | Tutti i programmi | Microsoft Visual Studio 2010 cliccando col tasto destro la scorciatoia di Microsoft Visual Studio 2010 e selezionando "Esegui come amministratore". Scegliere nuovo dal menu File | Progetto.

Nella finestra di dialogo nuovo progetto, espandere la lingua di preferenza nell'elenco modelli installati e selezionare Cloud.Scegliere il modello di progetto di Windows Azure, impostare il nome del progetto su FastMotorcycleProject e impostare il percorso su qualcosa di comodo.

Un video che dimostrano questi passaggi in dettaglio può essere trovato alla bit.ly/VideoAzureRestfulService.

Esplora sarà simile a Figura 5.

Creating a New Windows Azure Project
Nella figura 5, creando un nuovo Windows azzurro del progetto

Figura 6 mostra alcuni passaggi di base non trattate in questo articolo (ma che sono coperte nel video di cui si fa riferimento).

Figura 6 passaggi fondamentali non trattati in questo articolo

Compito coperto in Video Nota
Aggiunta di una pagina ASP.Ruolo NET Web Verrà utilizzato per ospitare il servizio RESTful Web
Aggiunta di un DataConnectionString Comprenderà la chiave di accesso e il nome di conto
Aggiunta di qualche codice di avvio di base per inizializzare i dati Aggiungere il codice al global.asax.cs per leggere il DataConnectionString

Questi passaggi sono comuni a quasi tutti i progetti di Windows Azure.Ad esempio, è una pratica standard per utilizzare un ruolo Web per ospitare i servizi RESTful Web.Un DataConnectionString è necessaria per accedere all'account di archiviazione definito in precedenza al portale Azure Windows.Codice di avvio è necessario all'interno del progetto di Visual Studio per leggere i nomi di account e accedere ai tasti dal file di configurazione da utilizzare contro i conti di deposito.

Una volta passi preliminari sono completi, un servizio RESTful Web può essere aggiunti utilizzando il modello servizio WCF in Visual Studio.

Per aggiungere un servizio WCF, pulsante destro del mouse nella cartella FastMotorcycleProject_WebRole, selezionare Aggiungi | Finestra di dialogo nuovo elemento e impostare il nome della classe per FastMotorcycleService.

FastMotorcycleService.svc.cs verrà generato.Sostituire l'intero codice della classe con il codice mostrato in Figura 7.

La chiave per far funzionare questo è sapere come eseguire il mapping di URI differente e verbi ai metodi RESTful.Per questo, è necessario aggiungere gli attributi WebGet e WebInvoke il codice in Figura 7.

Figura 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);
  }
}

Questi attributi raccontano il quadro che il metodo dovrebbe rispondere alle richieste HTTP GET. WebInvoke viene mappato a HTTP POST per impostazione predefinita. Anche per impostazione predefinita, l'URI è determinata dal nome del metodo (aggiunto sull'URI di base dell'endpoint). Alcuni esperti o i puristi del resto potrebbero obiettare che i nostri nomi di metodo non dovrebbero essere i verbi ma piuttosto i sostantivi.

Il modello di programmazione WCF REST mostrato in Figura 8 consente la personalizzazione di URI per ogni metodo utilizzando i modelli che possono essere impostati tramite la proprietà UriTemplate attributi WebInvoke e WebGet. Il modello è spiegato nel seguente elenco, con i numeri corrispondenti a quelli in Figura 8:

Workflow for Mobile Application Requesting RESTful Data
Figura 8 Workflow per applicazione Mobile che richiede dati riposanti

  1. Un'applicazione mobile utilizza standard HTTP per inviare una richiesta di messaggio, che comprende un verbo HTTP oltre a un URL.
  2. Il servizio RESTful Web intercetta la richiesta del messaggio di applicazioni mobili (richiesta di dati) ed effettua una chiamata a GetItems, passando "Bruno" come parametro. GetItems query per i dati utilizzando una query LINQ, utilizzando "Bruno" come parte del dove clausola.
  3. Solo i record in cui il PartitionKey è uguale a "Bruno" vengono restituiti dal servizio Windows Azure Table.
  4. I dati vengono convertiti in formato JSON (in automatico) e restituiti al dispositivo mobile.
  5. I dati sono disponibili per l'applicazione mobile. I dati vengono utilizzati per popolare un controllo ListBox e presentati all'utente applicazione mobile.

Le prossime tre classi che discutiamo sono gli oggetti di supporto, che sono necessari per interagire con il servizio di Windows Azure Table. Veloce­MotorcycleListDataProvider, FastMotorcycleListItem e FastMotorcycleList sono classi che astraggono via archiviazione e API Windows Azure tabella specifica dettagli dal codice in Figura 9, consentendo all'applicazione di eseguire operazioni Create, Read, Update e Delete (CRUD) con il servizio di Windows Azure Table.

In Visual Studio, aggiungere un nuovo modulo di classe chiamato FastMotorcycleListDataProvider.cs. Sostituire il codice con il codice di Figura 9.

Nella figura 9, le classi di FastMotorcycleList, FastMotorcycleListItem e FastMotorcycleListDataProvider

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");
    }
  }
}

Parte 3: Distribuzione del servizio Web riposante

Questo è uno dei settori dove brilla davvero Windows Azure. È semplice distribuire 100 istanze del servizio RESTful Web come è per distribuire uno solo. Nota: il seguente elenco di passaggi:

  1. In Visual Studio, fare clic destro su FastMotorcycleProject e selezionare il pacchetto.
  2. Tornare al browser con il portale e selezionare "Hosted Services, account di archiviazione & CDN."
  3. Nel riquadro superiore, selezionare "Servizi Hosted".
  4. Nel riquadro centrale, selezionare il servizio Hosted creato in precedenza.
  5. Pulsante destro del mouse e selezionare "Nuova produzione distribuzione" e caricare i file (FastMotorcycleProject.cspkg e ServiceConfiguration.Cloud.cscfg); Questi sono stati generati nel primo passaggio.

Parte 4: Consumando il servizio RESTful Web da applicazioni mobili

Discuteremo ora consumando i servizi RESTful Web da varie applicazioni mobile. Questa sezione è destinata a evidenziare l'interoperabilità che questo approccio fornisce.

La JSONKit (github.com/johnezang/JSONKit) consente di interagire con il servizio RESTful Web da dispositivi iOS più facili. Con poche righe di codice, è possibile chiamare il servizio RESTful Web, scaricare i dati in formato JSON, convertirlo in un formato più fruibile e associare i dati convertiti a un controllo Table View, utilizzato dalle applicazioni iPhone o iPad (vedere Figura 10).

Figura 10 Objective C codice che analizza i dati 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];

Lo sviluppo di Android coinvolge il linguaggio, che è stato intorno per lungo tempo e in modo nativo consente di analizzare dati JSON Java. Figura 11 mostra un esempio. Windows Phone SDK include il supporto nativo per chiamare servizi RESTful Web ed elaborare i dati in formato JSON. il SDK rende facile al trattamento dei dati JSON con DataContractJsonSerializer. Figura 12 mostra un esempio. Infine, se vi piacerebbe vedere un più robusto toolkit per lo sviluppo di Android e iOS, potete visitare questo link sanzionato Microsoft: github.com/microsoft-dpe.

Figura 11 codice androide che analizza i dati 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);
      }

Codice c# nella Figura 12 che analizza i dati 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
  }
}

Accesso all'intero spettro dei dispositivi

Poiché i servizi di hosting Windows Azure RESTful Web sono basati su HTTP, qualsiasi applicazione client che supporti questo protocollo è in grado di comunicare con loro. Questo apre un ampio spettro di dispositivi per gli sviluppatori, perché la maggior parte dei dispositivi che rientrano in questa categoria. Anche se abbiamo coperto di piattaforme mobili in questo articolo, implementazioni di JavaScript come jQuery sono anche in grado di consumare servizi RESTful Web. Indipendentemente dal percorso piattaforme mobili prendere a riguardo alla diversità dell'interfaccia utente, farà sempre senso per costruire su semplice, aperto, architetture di servizio Web basato su HTTP.

Bruno Terkaly funziona come un developer evangelist per Microsoft. Sua profondità di conoscenza deriva da anni di esperienza nel settore, scrive codice utilizzando una moltitudine di piattaforme, linguaggi, quadri, SDK, le librerie e le API. Trascorre il codice in fase di scrittura, blogging e dando presentazioni dal vivo sulla creazione di applicazioni basate su cloud, in particolare utilizzando la piattaforma Windows Azure.

Ricardo Villalobos è un progettista software condito con più di 15 anni di esperienza di progettazione e creazione di applicazioni per le aziende nel settore della gestione catena fornitura. Con diverse certificazioni Microsoft, come pure un MBA in Supply Chain Management da University of Dallas, entrò Microsoft nel 2010 come un evangelist architetto Windows Azure.

Grazie ai seguenti esperti tecnici per la revisione di questo articolo: Reza Alizadeh e Wade Wegner