Artikel
01/30/2018

Januar 2018

Band 33, Nummer 1

Data Points: Erstellen von Azure Functions für die Interaktion mit Cosmos DB

Julie Lerman In meiner letzten Kolumne habe ich Ihnen schrittweise gezeigt, wie eine einfache UWP-App (universelle Windows-Plattform) erstellt wird: ein Spiel namens CookieBinge, das im Grunde genommen ein Vorwand dafür war, die Verwendung von Entity Framework Core 2.0 (EF Core) in einer gerätegebundenen Windows 10-Anwendung zu untersuchen. Durch die Hinzufügung von Anbietern für portable Datenbanken wie SQLite wird das Bild vervollständigt, um eine solche Möglichkeit zu schaffen.

Die App speichert in ihrem aktuellen Zustand die Spielstände lokal auf dem Gerät, auf dem das Spiel gespielt wird, indem sie EF Core 2.0 verwendet, um die Daten in einer SQLite-Datenbank persistent zu speichern. In diesem letzten Artikel habe ich versprochen, dass die nächste Iteration dieses Spiels es den Benutzern ermöglichen würde, diese Daten mit anderen Spielern im Internet zu teilen. Um dieses Ziel zu erreichen, werde ich zwei coole Features von Azure verwenden: Azure Cosmos DB und Azure Functions.

Einige Informationen zu Azure Cosmos DB

Azure Cosmos DB ist die nächste Generation dessen, was als Azure Document DB begann, eine Technologie, über die ich in dieser Kolumne schon mehrfach berichtet habe. Auf „Eine Übersicht über Microsoft Azure DocumentDB“ (msdn.com/magazine/mt147238) im Juni 2015 folgten zwei weitere Artikel, in denen ich diese Technologie als Back-End einer Aurelia-Web-App über eine Node.js-Server-API verwendet habe.

DocumentDB hat sich zu einer global verteilten Datenbank mit einigen außergewöhnlichen Features entwickelt. Abgesehen von der Einfachheit, mit der sie global verteilt werden kann, wurden ihre Konsistenzmodelle neu ausgerichtet, sodass sie mehr bietet als nur Stärke und Globalität. Zwischen diesen beiden Extremen können Benutzer nun auch zwischen Bounded Staleness, Sitzungs- oder Präfixkonsistenz wählen. Es gibt viele weitere wichtige Features zur Unterstützung des Datenspeichers, und die Dokumentdatenbank wird jetzt durch eine Reihe weiterer Datenmodelle ergänzt: Dokumente, auf die über MongoDB-APIs zugegriffen werden kann, Diagrammdatenbanken, Tabellen- (Schlüssel-Wert-Paare) und Spaltendatenspeicherung. Alle diese Modelle finden sich unter dem Dach von Cosmos DB. Wenn Sie eine Azure DocumentDB verwendet haben, wurde diese tatsächlich automatisch auf eine Azure Cosmos DB umgestellt, sodass Ihre vorhandene Dokumentdatenbank von allen neuen Features profitieren kann, die Cosmos DB bietet. Zahlreiche weitere Informationen zu Cosmos DB finden Sie unter cosmosdb.com.

Einige Informationen zu Azure Functions

Ich werde Cosmos DB benutzen, um die Spielstände von CookieBinge zu speichern. Anstatt jedoch den gesamten Code selbst mithilfe der Document DB-APIs zu schreiben, nutze ich ein weiteres relativ neues Feature von Azure: Azure Functions. Azure Functions ist das Angebot von Microsoft für „serverloses Computing“. Ich war schon immer skeptisch gegenüber dieser Bezeichnung, weil das Computing immer noch auf einem Server ausgeführt wird. Eben nur nicht auf meinem Server. Aber nachdem ich endlich die Möglichkeit hatte, mit Azure Functions zu arbeiten, habe ich nun großen Respekt vor dem Konzept. Mit Azure Functions können Sie sich auf die eigentliche Programmlogik konzentrieren, die Sie in der App ausführen möchten, während Azure Functions sich um die bereichsübergreifenden Belange wie Bereitstellung, Unterstützung von APIs und Verbindungen mit anderen Funktionen wie Datenspeicherung oder E-Mail-Versand kümmert. Ich habe das nicht ganz verstanden, bis ich es selbst gemacht habe. Ich hoffe daher, dass Sie auch Ihr Aha-Erlebnis haben werden, wenn Sie meinem Weg folgen, während ich dieses Feature für die CookieBinge-App vorbereite.

Vorbereitung für das Erstellen der ersten Azure-Funktion

Es gibt drei Möglichkeiten, mit Azure Functions Funktionen zu erstellen. Eine davon sind die Tools in Visual Studio 2017. Eine weitere Möglichkeit ist das direkte Erstellen im Azure-Portal. Sie können auch Visual Studio Code in Kombination mit der Azure-Befehlszeilenschnittstelle (CLI) verwenden. Ich habe mich entschieden, mit dem Erlernen von Azure Functions über das Portal zu beginnen, weil es mich durch alle Schritte geführt hat, die erforderlich waren. Ein weiterer Vorteil besteht darin, dass ich ohne die Hilfe der Tools von Visual Studio 2017 gezwungen war, etwas mehr über alle beweglichen Elemente nachzudenken. Ich habe das Gefühl, dass ich auf diese Weise ein viel besseres Verständnis gewonnen habe. Natürlich gibt es auch in Visual Studio 2017 viele fabelhafte Ressourcen, die zu diesem Zweck verwendet werden können. Aber es gibt noch eine andere Sache, die ich an der Verwendung des Portals mag: Es ist webbasiert und stellt daher eine plattformübergreifende Option dar. Sie können Ihren Funktionscode und Ihre Ressourcen zwar aus der Quellcodeverwaltung in Azure bereitstellen, aber denken Sie daran, dass alles, was Sie direkt im Portal erstellen, auf Ihren Computer heruntergeladen werden (eine einfache Aufgabe) und von dort mithilfe von Push in Ihr Repository verschoben werden muss.

Wenn Sie meine Aktionen nachvollziehen möchten und noch nicht über ein Azure-Abonnement verfügen, freut es mich, Ihnen mitteilen zu können, dass Sie ein kostenloses Abonnement erhalten können, und zwar nicht nur für einen kurzen Testzeitraum. Einige Azure-Produkte werden ein Jahr lang kostenlos sein, und es gibt ein paar Dutzend, die immer kostenlos sein werden. Navigieren Sie zu azure.com/free, um ihre Vorbereitungen zu treffen. Ich verwende das Konto, das ich als Teil meines Visual Studio-Abonnements erhalte, das über eine monatliche Gutschrift für das Experimentieren mit Azure verfügt.

Bevor ich die Funktionen erstelle, muss ich meine Ziele definieren. Ich möchte, dass meine App Folgendes ermöglicht:

Speichern von Spielständen der Benutzer im Web, wobei nicht nur einige Benutzerinformationen und das Datum zusammen mit der Punktzahl gespeichert werden, sondern auch die Art des Geräts, auf dem das Spiel gespielt wurde.
Ermöglichen, dass Benutzer ihre höchsten Punktzahlen auf allen Geräten abzurufen können, auf denen sie spielen.
Ermöglichen, dass ein Benutzer die höchsten Punktzahlen aller Benutzer abrufen kann.

Ich werde diese Demo nicht durch Dinge wie das Erstellen und Authentifizieren von Konten erschweren, obwohl dies natürlich für die reale Welt erforderlich wäre. Mein Ziel ist es, Ihnen Azure Functions vorzustellen und schließlich die Interaktion mit der UWP-App zu zeigen.

Erstellen der Azure Functions-Funktion im Azure-Portal

Azure Functions ist ein Dienst, der in einer Funktionen-App gruppiert ist, die es Ihnen ermöglicht, Einstellungen für alle Funktionen zu definieren und freizugeben. Ich beginne also damit, eine neue Funktionen-App zu erstellen. Klicken Sie im Azure-Portal auf „Neu“ und filtern Sie auf „Funktionen-App“, um diese Option einfach zu finden. Klicken Sie in der Ergebnisliste auf „Funktionen-App“ und dann auf „Erstellen“. Sie werden nun aufgefordert, einige Metadaten einzugeben, z.B. einen Namen für Ihre App. Ich habe meine App „cookiebinge.azurewebsites.net“ genannt. Da es sich hier nur um eine einfache Demo handelt, übernehme ich den Rest der Standardeinstellungen auf der Seite „Erstellen“. Um in Zukunft einfachen Zugriff auf Ihre neue Funktionen-App zu erhalten, aktivieren Sie die Option „An Dashboard anheften“ und klicken dann auf die Schaltfläche „Erstellen“. Es hat nur etwa 30 Sekunden gedauert, bis die Bereitstellung meiner neuen Funktionen-App abgeschlossen war.

Nun können Sie der Funktionen-App einige Funktionen hinzufügen. Meine Funktionen werden so gestaltet, dass sie die Liste der zuvor genannten Ziele unterstützen. Der Azure Functions-Dienst verfügt über eine vordefinierte (und recht umfangreiche) Sammlung von Ereignissen, auf die er reagieren kann, z.B. eine HTTP-Anforderung, eine Änderung in einer Cosmos DB-Datenbank oder ein Ereignis in einem Blob oder einer Warteschlange. Da ich diese Funktionen aus der UWP-App aufrufen möchte, stelle ich mir Funktionen vor, die auf Anforderungen antworten, die über HTTP eingehen. Das Portal bietet eine Vielzahl von Vorlagen in verschiedenen Sprachen: Bash, Batch, C#, F#, JavaScript, PHP, PowerShell, Python und TypeScript. Ich werden C# verwenden.

Um die erste Funktion innerhalb der Funktionen-App zu erstellen, klicken Sie auf das Pluszeichen neben der Überschrift „Funktionen“. Es werden Schaltflächen angezeigt, mit denen Sie vordefinierte Funktionen erstellen können. Wenn Sie jedoch unterhalb dieser Schaltflächen nach unten scrollen, finden Sie einen Link zum Erstellen einer benutzerdefinierten Funktion. Wählen Sie diese Option aus. Nun wird ein scrollbares Raster mit Vorlagenoptionen geöffnet, wie in Abbildung 1 gezeigt. „HTTP-Trigger - C#“ sollte ganz oben in dieser Liste aufgeführt werden. Diese Option sollten Sie auswählen.

Abbildung 1: Ein Ausschnitt aus der Vorlagenliste zum Erstellen neuer, benutzerdefinierter Azure Functions-Funktionen

Benennen Sie die Funktion, und klicken Sie dann auf die Schaltfläche „Erstellen“. Ich habe meine Funktion „StoreScores“ genannt.

Das Portal erstellt eine Funktion mit etwas Standardcode, sodass Sie sehen können, wie er strukturiert ist. Die Funktion wird in einer Datei namens „run.csx“ erstellt (siehe Abbildung 2). Sie können auch zusätzliche Logik in unterstützenden Dateien verwenden, aber das ist weiter fortgeschrittene Technik als für diese ersten Versuche erforderlich ist.

Abbildung 2: Standardfunktionslogik für einen neuen HTTPTrigger

Die einzige Methode im Beispiel heißt „Run“. Diese wird Azure als Antwort auf eine HTTP-Anforderung an diese Funktion aufrufen. Sie verfügt über einen Parameter für die Erfassung der Anforderung und einen weiteren für die Weitergabe von Informationen an ein Protokoll.

Im Beispiel können Sie erkennen, dass die Funktion nach eingehenden Daten sucht, die einen Namen darstellen, und die Funktion ist flexibel genug, um nach diesen in den Abfrageparametern und im Anforderungstext zu suchen. Wenn der Name nicht gefunden wird, gibt die Funktion eine HttpResponseMessage mit einer benutzerfreundlichen Fehlermeldung zurück, andernfalls gibt sie in der Antwort „Hello [name]“ zurück.

Anpassen der Funktion für die Interaktion mit Cosmos DB

Ziel der Funktion ist es, die eingehenden Daten in einer Cosmos DB-Datenbank zu speichern. Hier beginnt die Magie. Es ist nicht erforderlich, Verbindungen und Befehle sowie anderen Code zu erstellen, um diese Aufgabe zu erledigen. Azure Functions besitzt die Fähigkeit, sich leicht in eine Reihe anderer Azure-Produkte zu integrieren, und Cosmos DB ist eines davon.

In der Funktionsliste sollten Ihre neue Funktion und drei Elemente unter ihr angezeigt werden. Eines dieser Elemente ist „Integrieren“. Wählen Sie diese Option aus. Das teilweise in Abbildung 3 gezeigte Formular wird angezeigt. Beachten Sie, dass es besagt, dass der Trigger eine HTTP-Anforderung ist und die Ausgabe etwas über HTTP zurückgibt. Da ich eine Erfolgs- oder Fehlermeldung zurückgeben möchte, möchte ich diese HTTP-Ausgabe beibehalten. Aber ich möchte auch eine Ausgabe hinzufügen, die eine Cosmos DB-Sammlung als Ziel hat.

Abbildung 3: Definieren der Funktionsintegrationspunkte

Klicken Sie zu diesem Zweck auf „Neue Ausgabe“, um eine Liste mit Symbolen anzuzeigen. Scrollen Sie nach unten zum Symbol mit dem Namen „Azure Cosmos DB“, und wählen Sie dieses aus. Weiter unten auf der Seite wird dann eine Schaltfläche „AUSWÄHLEN“ angezeigt. Sie wissen, was zu tun ist. (Klicken Sie auf diese Schaltfläche!)

Der Bildschirm zum Einrichten dieser Integration wird mit Standardeinstellungen voraufgefüllt. Der Dokumentparametername stellt den Parameter dar, den Sie in „run.csx“ verwenden. Ich behalte den Standardnamen (outputDocument) bei. Als nächstes folgen die Namen der Cosmos DB-Datenbank und die Sammlung innerhalb dieser Datenbank sowie die Verbindung mit dem Cosmos DB-Konto, in dem die Datenbank gespeichert ist. Sie sehen auch ein Kontrollkästchen, um die Datenbank automatisch für Sie zu erstellen. Ich habe bereits einige Cosmos DB-Konten erstellt, also werde ich eines dieser Konten verwenden. Aber ich lasse meine Funktion eine neue Datenbank namens „CookieBinge“ mit einer Sammlung namens „Binges“ in diesem Konto erstellen. Abbildung 4 zeigt, wie ich dieses Formular ausgefüllt habe, bevor ich die Ausgabedefinition gespeichert habe. Da ich das Kontrollkästchen aktiviert habe, um die Datenbank und die Sammlung zu erstellen, werden diese Objekte für mich erstellt. Dies ist aber nicht der Fall, wenn ich diese Ausgabe speichere. Wenn die Funktion erstmals versucht, Daten in der Datenbank zu speichern und feststellt, dass sie nicht vorhanden ist, erstellt die Funktion die Datenbank sofort.

Abbildung 4: Definieren einer Cosmos DB-Datenbank als Ausgabe für die Funktion

Anpassen von „Run.csx“

Nun ist es an der Zeit, den Funktionscode neu zu definieren. Die neue Version der Funktion erwartet, dass ein JSON-Objekt übergeben wird, das mit dieser BingeRequest Klasse übereinstimmt, die ich in der Datei „run.csx“ unter der Run-Methode hinzugefügt habe:

public class BingeRequest{
  public string userId {get;set;}
  public string userName {get;set;}
  public string deviceName {get;set;}
  public DateTime dateTime {get;set;}
  public int score{get;set;}
  public bool worthit {get;set;}
}

Aber das ist nicht die gleiche Struktur wie die Daten, die ich speichern möchte, weil ich eine weitere Eigenschaft erfassen möchte: das Datum und die Uhrzeit der Protokollierung der Daten in der Datenbank. Dafür verwende ich eine zweite Klasse (BingeDocument), die von BingeRequest erbt, wodurch alle Eigenschaften von BingeRequest geerbt werden, und füge außerdem eine weitere Eigenschaft namens „logged“ hinzu. Der Konstruktor nimmt eine mit Daten aufgefüllte BingeRequest an und überträgt BingeRequest-Werte in seine eigenen Eigenschaften, nachdem er den Wert „logged“ festgelegt hat:

public class BingeDocument:BingeRequest
  {     
    public BingeDocument(BingeRequest binge){
    logged=System.DateTime.Now;
    userId=binge.userId;
    userName=binge.userName;
    deviceName=binge.deviceName;
    dateTime=binge.dateTime;
    score=binge.score;
    }
    public DateTime logged{get;set;}
  }

Wenn diese Typen vorhanden sind, kann die Run-Methode sie nutzen. Abbildung 5 zeigt die geänderte Auflistung für „run.csx“, einschließlich Platzhaltern für die zuvor beschriebenen Klassen BingeRequest und BingeDocument.

Analysieren wir die neue Run-Methode. Ihre Signatur nimmt genau wie die Originalsignatur eine Anforderung und einen TraceWriter an, aber jetzt verfügt sie auch über einen asynchronen Ausgabeparameter namens outputDocument. Das Ergebnis des Ausgabeparameters sind die Werte, die mithilfe von Push in die von mir definierte Cosmos DB-Ausgabe verschoben werden. Beachten Sie, dass ihr Name mit dem Namen des Ausgabeparameters in der Ausgabekonfiguration in Abbildung 4 übereinstimmt. Mit TraceWriter kann ich Meldungen in das Protokollfenster unterhalb des Codefensters ausgeben. Ich werde diese schlussendlich entfernen, aber es ist wie in alten Zeiten, ohne IDEs, mit denen Sie debuggen können. Verstehen Sie mich jedoch nicht falsch. Das Codefenster ist beeindruckend beim Analysieren der Sprache, in der Sie arbeiten, und wenn Sie speichern, werden alle Compilerfehler (die sehr detailliert sind) auch im Debugfenster ausgegeben. Es übernimmt auch Dinge wie das Einfügen einer schließenden Klammer, wenn Sie eine öffnende Klammer eingeben. Es ist tatsächlich eine beeindruckende Anzahl von Editor-Features vorhanden. Klicken Sie beispielsweise mit der rechten Maustaste auf das Editor-Fenster, um die lange Liste der Editor-Features anzuzeigen, die Sie nutzen können.

Abbildung 5: Die neue Datei „run.csx“, die das Binge-Verhalten erfasst und in der Ausgabe (Cosmos DB) speichert

using System.Net;
public static async Task<HttpResponseMessage> Run(HttpRequestMessage req,
  TraceWriter log,    IAsyncCollector<object> outputDocument)
{
  BingeRequest bingeData =  await req.Content.ReadAsAsync<BingeRequest>();
  log.Verbose("Incoming userId:" + bingeData.userId);
  var doc=new BingeDocument(bingeData,log);
  log.Verbose("Outgoing userId:" + doc.userId);
  await outputDocument.AddAsync(doc);
  if (doc.userId !=" " ){
    return req.CreateResponse(HttpStatusCode.OK,$"{doc.userId} was created" );
  }
  else {
    return req.CreateResponse(HttpStatusCode.BadRequest,
      $"The request was incorrectly formatted." );
  }
}
public class BingeRequest{ . . . }
public class BingeDocument { . . . }

Die erste Codezeile in „Run“ liest asynchron die Anforderung und konvertiert das Ergebnis in ein BingeRequest-Objekt.

Als nächstes instanziiere ich ein neues BingeDocument, indem ich das Objekt übergebe, das ich soeben aus der Anforderung erstellt habe. Dies führt zu einem vollständig mit Daten aufgefüllten BingeDocument-Objekt und einer mit Daten aufgefüllten logged-Eigenschaft.

Ich verwende dann TraceWriter, um einige Daten aus der Anforderung in den Protokollen anzuzeigen, sodass ich beim Debuggen feststellen kann, ob BingeDocument tatsächlich die Daten aus dem Anforderungsobjekt abgerufen hat.

Schließlich füge ich das soeben erstellte BingeDocument asynchron in das asynchrone outputDocument ein.

Das Ergebnis dieses outputDocument-Objekts sind die Daten, die von der Funktion an Cosmos DB gesendet werden. Sie werden als JSON in der DocumentDB gespeichert: Die Funktion konvertiert sie für Sie im Hintergrund erneut. Da ich alles mit den Integrationseinstellungen verbunden habe, muss ich keinen Code schreiben, damit dies geschieht.

Wenn alles gesagt und getan ist, gebe ich über HttpResponse eine Meldung zurück, die den Erfolg oder Misserfolg der Funktion übermittelt.

Kompilieren und Testen der Funktion

Funktionen werden kompiliert, wenn Sie sie speichern. Ich werde nach dem Zufallsprinzip etwas Wichtiges im Code löschen, damit Sie den Compiler in Aktion erleben können, wobei die Ergebnisse im Protokollfenster unter dem Codefenster angezeigt werden. Abbildung 6 zeigt die Compilerausgabe und hebt das Chaos hervor, das ich durch das Löschen einer öffnenden Klammer aus Zeile 13 verursacht habe. Sogar ohne Debugger habe ich festgestellt, dass das Anzeigen dieser Fehler mir hilft, Code zu überprüfen, den ich ohne die Hilfe von IntelliSense oder anderen Codierungstools in meinen IDEs schreiben musste. Gleichzeitig habe ich gelernt, wie sehr ich auf diese Tools angewiesen bin!

Abbildung 6: Das Protokollfenster, in dem Compilerinformationen und Fehler angezeigt werden

Wenn der Code repariert und der Compiler zufrieden ist, zeigt das Protokoll die Meldung „Reloading“ an, gefolgt von „Compilation successful“.

Jetzt ist es an der Zeit, die Funktion zu testen. Dieser Test kann direkt im gleichen Fenster erfolgen, in dem Sie die Funktion codieren. Rechts neben dem Code-Editor befinden sich zwei Bereiche mit Registerkarten. Ein Bereich zeigt die Liste der Dateien an, die mit der Funktion in Verbindung stehen. Standardmäßig gibt es nur zwei Dateien: die Datei „run.csx“, die ich gerade betrachte, und eine Datei „function.json“, die alle Einstellungen enthält, die in der Benutzeroberfläche definiert sind. Die andere Registerkarte dient zum Ausführen von Tests. Diese integrierte Testbenutzeroberfläche gleicht einer Postman- oder Fiddler-Minianwendung, um HTTP-Anforderungen mit viel weniger Aufwand zu erstellen, da sie die zu testende Funktion bereits kennt. Sie müssen lediglich ein JSON-Objekt einfügen, das die eingehende Anforderung darstellt. Die Testbenutzeroberfläche ist standardmäßig auf das Senden von „HTTP Post“ festgelegt, sodass Sie für diesen Test nicht einmal diese Einstellung ändern müssen. Geben Sie den folgenden JSON-Code in das Textfeld „Anforderungstext“ ein. Das Schema ist wichtig, aber Sie können beliebige Werte verwenden:

{
  "userId": "54321",
  "userName": "Julie",
  "deviceName" : "XBox",
  "dateTime": "2017-10-25 15:26:00",
  "score" : "5",
  "worthit" : "true",
  "logged": ""
}

Klicken Sie anschließend im Testbereich auf die Schaltfläche „Ausführen“. Der Test ruft die Funktion auf, übergibt den Anforderungstext und zeigt dann alle HTTP-Ergebnisse im Ausgabefenster an. In Abbildung 7 können Sie die Ausgabe „54321 was created“ sowie die Protokollausgabe aus der Funktion im Protokollfenster sehen.

Abbildung 7: Der Testbereich nach dem Ausführen eines Tests für die Funktion

Anzeigen der neuen Daten in der Cosmos DB-Datenbank

Was Sie hier nicht erkennen können: Als Ergebnis dieses ersten erfolgreichen Tests wurde die Cosmos DB-Datenbank „CookieBinge“ erstellt und darin die Binge-Sammlung, in der dieses Dokument gespeichert wurde. Werfen wir einen Blick darauf, bevor wir diese Folge meiner mehrteiligen Kolumne abschließen.

Sie können zu diesem Zweck zunächst das Cosmos DB-Konto in dem Portal öffnen, in dem Sie diese Datenbank erstellt haben. Meine Datenbank trägt den Namen „datapointscosmosdb“, also navigiere ich zu „Alle Ressourcen“ und gebe „datapoints“ in den Filter ein, um sie zu finden. Sobald ich das Konto geöffnet habe, werden alle meine Sammlungen und Datenbanken angezeigt. Die einzige Sammlung, über die ich zurzeit verfüge, ist meine Binges-Sammlung in der CookieBinge-Datenbank. Abbildung 8 zeigt dies. Diese Elemente wurden soeben von der Funktion erstellt.

Abbildung 8: Die im datapointscosmosdb-Konto aufgelistete Binges-Sammlung

Klicken Sie auf „Binges“, um den Daten-Explorer für diese Sammlung zu öffnen. Ich habe den Test zwei Mal ausgeführt, sodass Sie in Abbildung 9 sehen können, dass zwei Dokumente in der Sammlung gespeichert wurden. Die ersten sieben Eigenschaften im Dokument sind die von mir definierten Eigenschaften. Der Rest sind Metadaten, die Cosmos DB und die zugehörigen APIs für Aufgaben wie Indizierung, Suche, Partitionierung und vieles mehr verwenden.

Abbildung 9: Anzeigen der in Cosmos DB gespeicherten Dokumente im Portal

Blick in die Zukunft

Wenn Sie sich Abbildung 7 noch einmal ansehen, werden Sie feststellen, dass sich über dem Codefenster ein Link „Funktions-URL abrufen“ befindet. Diese URL verwende ich in der CookieBinge-App, um Daten in die Cloud zu senden.

Nachdem Sie nun gesehen haben, wie Sie die Funktion erstellen und mit Cosmos DB verbinden, erfahren Sie in meiner nächsten Kolumne, wie Sie zwei weitere Funktionen erstellen können, um verschiedene Ansichten der Daten abzurufen. In der letzten Folge dieser Serie wird gezeigt, wie die Funktionen aus der CookieBinge-App aufgerufen und die Ergebnisse angezeigt werden.

Julie Lerman ist Microsoft Regional Director, Microsoft MVP, Coach für das Softwareteam und Unternehmensberaterin. Sie lebt in den Bergen von Vermont. Sie hält bei User Groups und Konferenzen in der ganzen Welt Vorträge zum Thema Datenzugriff und zu anderen Themen. Julie Lerman führt unter thedatafarm.com/blog einen Blog. Sie ist die Autorin von „Programming Entity Framework“ sowie der Ausgaben „Code First“ und „DbContext“ (alle bei O’Reilly Media erschienen). Folgen Sie ihr auf Twitter: @julielerman, und sehen Sie sich ihre Pluralsight-Kurse unter juliel.me/PS-Videos an.

Unser Dank gilt dem folgenden technischen Microsoft-Experten für die Durchsicht dieses Artikels: Jeff Hollan

Diesen Artikel im MSDN Magazine-Forum diskutieren