Was sind serverlose Funktionen?

In diesem Artikel sprechen wir über serverloses Computing, verschiedene Software-Architekturen, serverlose Funktionen, ihre Vorteile und Anwendungsfälle. Im zweiten Teil des Artikels lernen wir, wie man ein serverloses Backend auf Back4app mit Cloud Code-Funktionen erstellt.

Was ist eine serverlose Funktion?

Eine serverlose Funktion ist ein ereignisgesteuertes Codestück, das einem einzigen Zweck dient. Sie kann durch bestimmte Ereignisse wie HTTP-Anforderungen, Datenbankänderungen oder andere Nachrichten ausgelöst werden. Diese Funktionen werden von einem Softwareentwickler geschrieben und später in der Cloud bereitgestellt. Der Cloud-Anbieter verwaltet dann die Infrastruktur und die Sicherheit, kümmert sich um die Ausführung des Codes und skaliert die Ressourcen automatisch je nach Bedarf.

Serverlose Funktionen werden oft mit serverlosem Computing verwechselt. Obwohl die Begriffe miteinander verwandt sind, dürfen sie nicht austauschbar verwendet werden. Serverloses Computing ist ein Cloud-Computing-Modell, bei dem Cloud-Anbieter die für die Ausführung der Anwendungen erforderliche Infrastruktur verwalten, während serverlose Funktionen eine Art von serverlosem Computing sind, das es Entwicklern ermöglicht, kleine Codestücke einfach in der Cloud auszuführen und bereitzustellen.

Wie funktionieren die serverlosen Funktionen?

Die meisten modernen Anwendungen sind in zwei Teile gegliedert: das Frontend und das Backend. Das Frontend ist das, was der Benutzer sieht und womit er interagieren kann, während das Backend alles ist, was der Benutzer nicht sehen kann. Dazu gehören Geschäftslogik, Datenspeicherung, Datenbanken, APIs und so weiter.

Serverlose Funktionen vereinfachen die Backend-Komponente von Softwareanwendungen, indem sie das Backend in mehrere wiederverwendbare Einzweckfunktionen aufteilen. Diese Funktionen können später miteinander verbunden werden, um komplexe Aufgaben auszuführen.

Der einfachste Weg, serverlose Funktionen zu verstehen, ist ein Beispiel aus der Praxis. Nehmen wir an, wir haben einen E-Commerce-Shop, in dem ein Benutzer Produkte anzeigen, Produkte zum Warenkorb hinzufügen, Produkte aus dem Warenkorb entfernen und zur Kasse gehen kann.

Unser serverloses Backend würde höchstwahrscheinlich die folgenden Funktionen umfassen:

getProductList()                       -> retrieves the products from the database
getProduct(productId)                  -> retrieves a specific product from the database
getCart(user)                          -> returns the products in the user's cart
addToCart(user, productId)             -> adds a product to the user's cart
removeFromCart(user, productId)        -> removes the product from the user's cart
clearCart(user)                        -> clears user's cart

Und dann hätten wir auch komplexere Funktionen, die andere serverlose Funktionen nutzen:

checkout()
    cart = getCart(user)
    finalizeCheckout(user, cart)       -> deducts money from user's account
    clearCart(user)
    sendConfirmationEmail(user, cart)  -> sends a confirmation email to the user

Okay, aber wie funktionieren die serverlosen Funktionen unter der Haube?

Unter der Haube funktionieren serverlose Funktionen durch die Nutzung der Containerisierungstechnologie, bei der Code in leichtgewichtige, isolierte Container verpackt wird, die bei Bedarf einfach bereitgestellt und skaliert werden können. Wenn eine serverlose Funktion ausgelöst wird, erstellt der Cloud-Anbieter eine neue Instanz des Containers, führt den Code darin aus und fährt den Container wieder herunter, wenn die Ausführung des Codes abgeschlossen ist.

Der Cloud-Anbieter kümmert sich in der Regel um alle Aspekte der Verwaltung der zugrunde liegenden Infrastruktur, einschließlich Skalierung, Lastausgleich und Ressourcenzuweisung, sodass sich die Entwickler nicht um die Konfiguration oder Verwaltung von Servern kümmern müssen. Stattdessen schreiben die Entwickler einfach Code, laden ihn zum Cloud-Anbieter hoch und definieren die Auslösebedingungen dafür, wann der Code ausgeführt werden soll.

Was sind die verschiedenen Software-Architekturen?

Neben den serverlosen Funktionen gibt es auch die monolithische Architektur und die Microservices-Architektur. Schauen wir sie uns an.

Monolithische Architektur

Bei einer monolithischen Architektur wird die Anwendung als eine einzige Einheit mit allen Komponenten erstellt, die eng integriert sind. Alle Funktionalitäten sind in einer Codebasis zusammengefasst, und die Anwendung wird als ein einziges Paket bereitgestellt. Eine monolithische Architektur ist einfach zu erstellen und zu warten, kann aber komplex und schwer zu skalieren sein, wenn die Anwendung wächst.

Microservices-Architektur

Die Microservices-Architektur ist ein Ansatz für die Entwicklung von Softwareanwendungen in Form einer Sammlung kleiner, unabhängiger Dienste, die über APIs miteinander kommunizieren. Jeder Microservice ist für eine bestimmte Funktion der Anwendung zuständig und kann unabhängig entwickelt, bereitgestellt und skaliert werden. Dieser Ansatz ermöglicht eine größere Flexibilität, Skalierbarkeit und Ausfallsicherheit, kann aber auch zu einer höheren Komplexität in Bezug auf die Kommunikation und Verwaltung der Dienste führen.

Zusammenfassend lässt sich sagen, dass monolithische Anwendungen am besten für einfachere Projekte geeignet sind, die nicht stark skaliert werden müssen. Auf der anderen Seite sind Microservices und Serverless im Allgemeinen besser für komplexere Projekte geeignet, die hoch skalierbar und flexibel sein müssen. Neben all den Vorteilen von Microservices abstrahiert die serverlose Architektur auch von der Verwaltung der Infrastruktur. Dadurch sparen Sie eine Menge Zeit und Geld.

Was sind die Vorteile von serverlosen Funktionen?

Funktionen als Service (FaaS) bringen viele Vorteile mit sich.

Schnellere Entwicklung

Serverlose Funktionen ermöglichen eine schnellere Entwicklung und Bereitstellung, da keine Notwendigkeit besteht, die Infrastruktur zu verwalten, die Server zu konfigurieren, die Skalierung einzurichten oder die Server zu verwalten. Da es sich bei serverlosen Funktionen um kleine Codestücke handelt, die einem einzigen Zweck dienen, können sie leicht getestet und debuggt werden. Das Beste daran ist, dass serverlose Funktionen leicht in andere Cloud-Dienste oder APIs von Drittanbietern integriert werden können, wodurch viele gängige Probleme entfallen.

Hohe Skalierbarkeit und Verfügbarkeit

Serverlose Funktionen können eine große Anzahl von Anfragen verarbeiten und skalieren automatisch je nach Bedarf. Dadurch wird sichergestellt, dass die Anwendung jede Art von Datenverkehr bewältigen kann. Darüber hinaus kann die Umgebung auf Null skaliert werden, wenn niemand Ihren Dienst nutzt, wodurch Sie viel Geld sparen.

Es ist auch möglich, Ihre Functions-as-a-Service (FaaS) in mehreren Zonen bereitzustellen. Dies kann Ihnen helfen, die Verfügbarkeit Ihrer App zu verbessern, indem Sie Ihre Funktionen über die ganze Welt verteilen.

Größere Flexibilität

Serverlose Funktionen ermöglichen es Entwicklern, die Programmiersprache und die Tools zu wählen, die ihren Anforderungen am besten entsprechen. Die meisten Serverless-Anbieter unterstützen mehrere Sprachen wie JavaScript, Java, Python, Go und .NET. Dies sorgt für mehr Flexibilität bei der Entwicklung und Bereitstellung von Anwendungen.

Kosten-Wirksamkeit

Serverless ist die kostengünstigste Architektur, da Sie nur für das bezahlen, was Sie verbrauchen. Das sind Ihre Funktionslaufzeit und andere verwaltete Dienste, die Ihre Funktionen nutzen. Außerdem müssen Sie nicht für ungenutzte Ressourcen bezahlen.

Was sind einige der Anwendungsfälle für serverlose Funktionen?

Serverlose Funktionen können in praktisch jedem Projekt verwendet werden. Sie können serverlose Funktionen verwenden, um das Projekt von Grund auf aufzubauen oder nur für bestimmte Aufgaben. Zu den wichtigsten Anwendungsfällen gehören:

• Web-Anwendungen
• Aufbau von RESTful APIs
• Auslöserbasierte Aufgaben
• Automatisierung geplanter Aufgaben
• Asynchrone Verarbeitung
• Internet der Dinge (IoT)
• CI/CD

Die meisten Entwicklerteams migrieren schrittweise zu Serverless. Sie migrieren Aufgabe für Aufgabe, bis kein Bedarf mehr an herkömmlichen Servern besteht.

Was sind Beispiele für serverlose Umgebungen?

Plattform als Dienstleistung (PaaS)

Platform as a Service (PaaS) ist eine vorteilhafte Cloud-Computing-Lösung, die den Benutzern die Möglichkeit bietet, Anwendungen in einer Cloud-basierten Umgebung zu erstellen, zu verwalten und bereitzustellen.

Es bietet vorkonfigurierte Tools für die Anwendungsentwicklung, -anpassung und -prüfung, wodurch ein Großteil des Zeitaufwands für die Infrastrukturverwaltung entfällt.

Die Entwicklung einer App, die auf PaaS bereitgestellt werden soll, unterscheidet sich nicht wesentlich von der Entwicklung einer herkömmlichen App. PaaS-Anbieter unterstützen serverlose Funktionen nicht von Haus aus.

Zu den PaaS-Diensten gehören: Heroku, AWS Elastic Beanstalk, DigitalOcean App Platform und Fly.io.

Backend als Dienstleistung (BaaS)

BaaS rationalisiert und vereinfacht die Backend-Entwicklung durch die Bereitstellung einer Plattform zur Verwaltung der Cloud-Infrastruktur.

Es übernimmt alle mühsamen Aufgaben, die mit der Erstellung eines Backends verbunden sind, so dass sich die Entwickler auf die Erstellung von Anwendungen konzentrieren können. Durch die Automatisierung vieler dieser Prozesse hilft BaaS Entwicklern, schnell und effizient robuste Anwendungen zu erstellen.

Die Plattform bietet eine breite Palette von Funktionen wie Benutzerverwaltung, Benachrichtigungen, Integration sozialer Medien und Speicherplatz. Damit ist sie die ideale Wahl für Unternehmen, die ihre digitale Präsenz ausbauen wollen. Außerdem bietet sie Komfort und Benutzerfreundlichkeit, die sie für alle Nutzer zugänglich macht.

Die Entwickler müssen sich nicht mehr um die Backend-Infrastruktur kümmern und können sich stattdessen auf die Erstellung des Frontends ihrer Projekte konzentrieren. So können sie sich auf ihr Kerngeschäft konzentrieren, ohne Zeit und Energie für andere Aufgaben aufwenden zu müssen.

Einige BaaS-Anbieter ermöglichen uns auch die Bereitstellung serverloser Funktionen:

• Back4app hat Cloud Code Funktionen
• Firebase hat Google Cloud Functions
• AWS Amplify hat AWS Lambda

Zu den anderen BaaS-Anbietern gehören Supabase, Kinvey und Parse.

Funktion als Dienstleistung (FaaS)

Function as a Service (FaaS) ist ein Cloud-Computing-Modell, das auf serverlose Funktionen spezialisiert ist. FaaS ermöglicht es Entwicklern, sich auf das Schreiben und Bereitstellen einzelner Funktionen zu konzentrieren, anstatt einen kompletten Anwendungsstapel zu erstellen und zu verwalten. Serverlose Funktionen lassen sich in der Regel mit APIs von Drittanbietern und anderen Cloud-Diensten integrieren. Dieses Computing-Modell kann automatisch und schnell skaliert werden, um jeden Datenverkehr zu bewältigen.

Die Hauptunterschiede zwischen BaaS und FaaS liegen darin:

• Konstruktion der Anwendung
• Skalierbarkeit
• Preismodell

Serverlose Funktionen werden in Containern ausgeführt, sind besser skalierbar und kosteneffizienter, da Sie nur für die Laufzeit Ihrer Funktionen zahlen. BaaS hingegen verfügt über viele integrierte Funktionen wie Benutzerverwaltung, Push-Benachrichtigungen, Social-Media-Integrationen und andere sofort einsatzbereite Tools, mit denen Sie schnell Backends erstellen können. Darüber hinaus ist BaaS extrem einfach zu bedienen.

Einige Beispiele für FaaS sind: AWS Lambda, Google Cloud Functions und Azure Functions.

Aufbau eines serverlosen Backends auf Back4app

In diesem Abschnitt des Tutorials zeigen wir Ihnen, wie Sie Cloud Code-Funktionen für Back4app programmieren und bereitstellen. Außerdem lernen wir, wie man ein Frontend mit einem serverlosen Backend verbindet.

Zielsetzungen:

Am Ende dieses Tutorials werden Sie in der Lage sein:

• Erklären Sie, was Cloud-Code-Funktionen sind und wie sie funktionieren
• Programmieren Sie Ihre Cloud Code-Funktionen, die die Datenbank manipulieren können
• Verwendung von Cloud-Code-Funktionen zum Abrufen von Daten aus APIs von Drittanbietern
• Erstellen Sie Ihre eigenen Cloud-Jobs und planen Sie sie
• Verbinden Sie ein Frontend-Projekt mit einem serverlosen Backend

Was ist Back4app?

Back4app ist eine führende BaaS – Backend as a Service Plattform, die Entwicklern die Werkzeuge und Funktionen zur Verfügung stellt, die sie für die einfache Erstellung von Web- und Mobile-Apps benötigen.

Mit seinen umfassenden Vorteilen ermöglicht es Entwicklern, sich auf die Hauptaspekte ihres Geschäfts zu konzentrieren, anstatt sich um Backend-Komplexitäten oder Infrastrukturfragen zu kümmern. Es ist eine der beliebtesten Open-Source-BaaS-Lösungen, die heute verfügbar sind.

Die umfassende Lösung verfügt über ein interaktives Dashboard und ein flexibles CLI – Command Line Interface für maximalen Komfort. Darüber hinaus bietet sie SDKs, die mit React Native, Flutter, Node.js, Angular, iOS, Android und mehr kompatibel sind – für eine mühelose Integration in bestehende Systeme!

Zu den Kernfunktionen von Back4app gehören eine Datenbank im Tabellenkalkulationsstil, GraphQL- und REST-APIs, Live-Abfragen, Authentifizierung mit sozialen Anmeldeoptionen, Skalierbarkeit für das Hosting und Benachrichtigungen, die alle in dieser leistungsstarken Plattform verfügbar sind.

Für weitere Informationen lesen Sie bitte Back4app Features.

Back4app bietet ein kostengünstiges Modell für alle Arten von Apps, von kleinen bis hin zu großen. Sie bieten einen kostenlosen Plan, der perfekt für die Entwicklung und das Experimentieren mit der Plattform ist.

Projekt-Einführung

Wir werden eine einfache App zur Verwaltung von Wetterstationen entwickeln. Wir werden zunächst virtuelle Wetterstationen erstellen und dann WeatherAPI verwenden, um aktuelle Wetterinformationen an den Standorten der Wetterstationen zu erhalten. Um unsere App-Logik zu definieren, verwenden wir Cloud Code-Funktionen und Cloud Jobs. Zum Schluss demonstrieren wir, wie man ein Frontend-Projekt ganz einfach mit einem serverlosen Backend verbinden kann.

App erstellen

Wenn Sie noch kein Back4app-Konto haben, melden Sie sich jetzt an, um die Vorteile der kostenlosen Dienste zu nutzen. Andernfalls loggen Sie sich in Ihr bestehendes Konto ein und führen Sie die folgenden Schritte aus.

Um Back4app nutzen zu können, müssen Sie eine App erstellen. Loggen Sie sich in Ihr Dashboard ein, um die Liste der Apps anzuzeigen und klicken Sie auf “Neue App erstellen”, um mit der Erstellung Ihrer App zu beginnen.

Da wir das Parse-Framework zur Erstellung unserer Anwendung verwenden werden, wählen Sie “Backend as a Service”.

Geben Sie als Nächstes einen benutzerdefinierten App-Namen ein, wählen Sie “NoSQL Database” als Datenbank aus und klicken Sie abschließend auf “Create”.

Back4app wird alle notwendigen Komponenten für Ihre App einrichten, einschließlich Datenbank, Anwendungsschicht, Skalierung, Backups und Sicherheit. Es dauert nur eine kurze Zeit, bis alles erledigt ist.

Sobald Ihre Bewerbung abgeschlossen ist, werden Sie zum Dashboard Ihrer App weitergeleitet.

Datenbank

Lassen Sie uns unsere Datenbankmodelle definieren. Wir werden zwei Modelle erstellen:

1. WeatherStation stellt eine virtuelle Wetterstation dar, die sich an einem bestimmten Ort befindet.
2. WeatherRecord stellt eine Messung des Wetters an einer bestimmten WeatherStation dar.

Navigieren Sie zu Ihrer “Datenbank” und klicken Sie auf “Eine Klasse erstellen”. Nennen Sie sie WeatherStation, stellen Sie sicher, dass Sie “Public Read and Write” aktivieren und fügen Sie die folgenden Felder hinzu:

+---------------------------+-----------------+---------------+----------+
| Data type                 | Name            | Default value | Required |
+---------------------------+-----------------+---------------+----------+
| String                    | name            | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+
| String                    | location        | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+

Führen Sie anschließend dieselben Schritte aus, um eine weitere Klasse namens WeatherRecord mit den folgenden Feldern zu erstellen:

+---------------------------+-----------------+---------------+----------+
| Data type                 | Name            | Default value | Required |
+---------------------------+-----------------+---------------+----------+
| Pointer -> WeatherStation | weatherStation  | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+
| String                    | weatherText     | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+
| String                    | weatherIcon     | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+
| Number                    | weatherCode     | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+

Navigieren Sie abschließend zum Modell WeatherStation und erstellen Sie zwei Wetterstationen. Beispiel:

+---------------------------+---------------+
| name                      | location      |
+---------------------------+---------------+
| Sunnyvale Station         | sunnyvale     |
+---------------------------+---------------+
| Mountain View Station     | mountain view |
+---------------------------+---------------+

Gut, das war’s mit der Datenbank.

WetterAPI

Um die aktuellen Wetterinformationen abzurufen, verwenden wir eine kostenlose API namens WeatherAPI.

Die folgenden Schritte setzen voraus, dass Sie ein WeatherAPI-Konto haben. Wenn Sie noch keines haben, melden Sie sich an, ansonsten loggen Sie sich in Ihr Dashboard ein.

Sobald Sie eingeloggt sind, notieren Sie sich Ihren API-Schlüssel:

Öffnen Sie nun Ihr Terminal und versuchen Sie, die aktuellen Wetterdaten für “Sunnyvale” mit Ihrem API-Schlüssel abzurufen:

curl "https://api.weatherapi.com/v1/current.json?key=<your_api_key>&q=<location>&aqi=no"

# Example:
# curl "https://api.weatherapi.com/v1/current.json?key=354fc376a4c&q=Sunnyvale&aqi=no"

Sie sollten eine ähnliche Antwort wie diese erhalten:

{
    "location": {
        "name": "Sunnyvale",
        "region": "California",
        "country": "United States of America",
        "lat": 37.37,
        "lon": -122.04,
    },
    "current": {
        "temp_c": 7.0,
        "temp_f": 44.6,
        "is_day": 1,
        "condition": {
            "text": "Light rain",
            "icon": "//cdn.weatherapi.com/weather/64x64/day/296.png",
            "code": 1183
        },
        ...
    }
}

Im nächsten Abschnitt des Artikels werden wir Cloud Code-Funktionen verwenden, um Wetterinformationen von der WeatherAPI abzurufen und sie dann in der Datenbank zu speichern.

Wolken-Code

Cloud-Code-Funktionen sind eine leistungsstarke Funktion von Parse Server, die es Entwicklern ermöglicht, benutzerdefinierten serverseitigen JavaScript-Code auszuführen. Entwickler können diese Funktionen verwenden, um Geschäftslogik zu implementieren, Daten zu validieren, komplexe Daten zu verarbeiten und allgemein serverlose Backends zu erstellen.

Navigieren Sie zu Ihrem Back4app-App-Dashboard und wählen Sie “Funktionen & Webhosting” unter “Cloud Code” in der Seitenleiste.

Die Back4app Cloud Code-Benutzeroberfläche ist einfach zu bedienen. Auf der linken Seite des Bildschirms können Sie die Verzeichnisstruktur sehen. Standardmäßig gibt es zwei Verzeichnisse:

1. cloud ist ein Verzeichnis für den gesamten Cloud-Code
2. public ist ein Verzeichnis für öffentliche Dateien wie Bilder, Stylesheets und mehr

Und auf der rechten Seite des Bildschirms befindet sich ein integrierter Code-Editor.

Cloud-Code-Funktionen definieren

Wir werden die folgenden Funktionen definieren:

1. weatherLocations liefert die Liste der Standorte der Wetterstationen.
2. weatherInfo liefert den Wetterbericht für einen bestimmten Ort.

Aber vorher installieren wir noch ein Drittanbieter-Paket namens axios. Axios ist ein auf Versprechen basierender HTTP-Client für JavaScript, der die Erstellung von HTTP-Anfragen stark vereinfacht.

Erstellen Sie eine neue Datei namens package.json im Cloud-Ordner und fügen Sie darin Folgendes ein:

{
  "dependencies": {
    "axios": "*"
  }
}

Als nächstes definieren Sie die Cloud-Code-Funktionen in cloud/main.js wie folgt:

// cloud/main.js

const axios = require("axios");

// make sure to replace `<api_key>` with your actual WeatherAPI key
const WEATHER_API_BASE = "https://api.weatherapi.com/v1/current.json?key=<api_key>";

Parse.Cloud.define("weatherLocations", async (request) => {
  const WeatherStation = Parse.Object.extend("WeatherStation");
  const weatherStationQuery = new Parse.Query(WeatherStation);
  const weatherStationResults = await weatherStationQuery.find();

  return weatherStationResults.map(result => result.get("location"))
});

Parse.Cloud.define("weatherInfo", async (request) => {
  let location = request.params.location;

  if (!location) {
    throw new Parse.Error(400, "Location not provided.");
  }

  const WeatherStation = Parse.Object.extend("WeatherStation");
  const weatherStationQuery = new Parse.Query(WeatherStation);
  weatherStationQuery.equalTo("location", location);
  const weatherStationResults = await weatherStationQuery.find();

  if (weatherStationResults.length == 0) {
    throw new Parse.Error(400, "Invalid location.");
  }

  const WeatherRecord = Parse.Object.extend("WeatherRecord");
  const weatherRecordQuery = new Parse.Query(WeatherRecord);
  weatherRecordQuery.equalTo("weatherStation", weatherStationResults[0]);
  weatherRecordQuery.descending("createdAt");
  weatherRecordQuery.limit(5);
  const weatherRecordResults = await weatherRecordQuery.find();

  return weatherRecordResults;
});

Klicken Sie schließlich unten rechts auf dem Bildschirm auf “Bereitstellen”, um Ihre Funktionen auf Back4app zu übertragen.

Cloud Job

Mit Cloud Jobs können Entwickler Hintergrundaufgaben ausführen, z. B. das Senden von Push-Benachrichtigungen oder die Verarbeitung von Daten. Diese Aufträge werden ähnlich wie Cloud-Code-Funktionen geschrieben und können für eine einmalige oder wiederkehrende Ausführung geplant werden.

Erstellen wir einen Cloud-Job, der das Wetter an allen unseren Wetterstationen alle 30 Minuten misst.

Cloud-Job definieren

Wählen Sie “Cloud Code” in der Seitenleiste und fügen Sie den folgenden Code am Ende der Datei cloud/main.js ein:

// cloud/main.js

// ...

Parse.Cloud.job("weatherCapture", async (request) => {
  const {params, headers, log, message} = request;
  message("weatherCapture just started...");

  const WeatherStation = Parse.Object.extend("WeatherStation");
  const weatherStationQuery = new Parse.Query(WeatherStation);
  const weatherStationResults = await weatherStationQuery.find();

  for (let i = 0; i < weatherStationResults.length; i++) {
    let weatherStation = weatherStationResults[i];

    try {
      const response = await axios.get(
        WEATHER_API_BASE + "&q=" + weatherStation.get("location") + "&aqi=no"
      );
      const currentWeather = response.data.current.condition;
      let icon = currentWeather.icon
        .replace("//", "https://")
        .replace("64x64", "128x128");

      const WeatherRecord = Parse.Object.extend("WeatherRecord");
      const weatherRecord = new WeatherRecord();
      weatherRecord.set("weatherStation", weatherStation);
      weatherRecord.set("weatherText", currentWeather.text);
      weatherRecord.set("weatherIcon", icon);
      weatherRecord.set("weatherCode", currentWeather.code);
      weatherRecord.save();
    } catch (error) {
      throw new Parse.Error(400, error);
    }
  }

  message("weatherCapture just finished!");
});

Dieser Code definiert einen neuen Cloud-Auftrag namens weatherCapture. Der Auftrag durchläuft eine Schleife durch alle WeatherStation, holt die Wetterinformationen von der WeatherAPI und speichert sie in der Datenbank.

Um zu testen, ob es funktioniert, navigieren Sie zu “Jobs > Alle Jobs” in der Seitenleiste und versuchen Sie, den Job auszuführen. Wenn alles gut geht, sollten danach zwei neue WeatherRecords in der Datenbank vorhanden sein.

Planen Sie Cloud-Jobs

Wir planen den Auftrag so, dass er alle 30 Minuten ausgeführt wird.

Wählen Sie in der Seitenleiste “App-Einstellungen > Servereinstellungen” und suchen Sie nach “Hintergrundaufträge”. Klicken Sie dann auf die Schaltfläche “Einstellungen”:

Planen Sie dann einen neuen Auftrag mit den folgenden Angaben:

1. Beschreibung: Misst das Wetter an allen Stationen
2. Wolkenauftrag: weatherCapture
3. Parameter: Leer lassen
4. Zeit einplanen: Beginn sofort
5. Soll sie wiederholt werden? Ja
6. Frequenz: Intervall
7. In welchem Intervall wird sie wiederholt? 30 Minuten

Das war’s. Der weatherCapture-Auftrag wird nun alle 30 Minuten ausgeführt.

Unser serverloses Backend ist nun fertig. Im nächsten Abschnitt sehen wir uns an, wie wir ein Frontend mit dem serverlosen Backend verbinden.

Frontend

Die Erstellung eines benutzerdefinierten Frontends von Grund auf ist nicht Gegenstand dieses Tutorials. Dennoch werde ich die grundlegenden Schritte zur Verbindung eines JavaScript-Frontends mit einem serverlosen Backend beschreiben.

• Installieren Sie Parse über npm oder yarn und importieren Sie es.
• Initialisieren Sie Parse in Ihrer App.js oder _app.js wie folgt:

import Parse from "parse/dist/parse.min.js";
    
// to get the keys navigate to your Back4app app > App Settings > Security & Keys
Parse.initialize(
  "<your_app_id>",              // replace me
  "<your_javascript_key>",      // replace me
);
Parse.serverURL = "https://parseapi.back4app.com/";

• Sie können dann Cloud Code-Funktionen wie diese aufrufen:

const fetchWeatherLocations = async () => {
    return await Parse.Cloud.run("weatherLocations");
};

Weitere Informationen finden Sie in der offiziellen Dokumentation.

Ich habe auch ein Beispielprojekt für unser Wetterstations-Backend vorbereitet. Das Projekt ist auf GitHub verfügbar. Die README.md enthält alle Informationen, die Sie benötigen, um das Projekt lokal zum Laufen zu bringen. Fühlen Sie sich frei, es zu forken und damit herumzuspielen.

Schlussfolgerung

Serverloses Computing ist eine zunehmend beliebte Lösung für Entwickler, die Anwendungen erstellen und bereitstellen möchten, ohne sich um die Verwaltung von Servern kümmern zu müssen.

In diesem Artikel haben wir verschiedene Software-Architekturen erkundet, uns mit serverlosen Funktionen beschäftigt und ihre Vorteile und Anwendungsfälle hervorgehoben. Schließlich haben wir gezeigt, wie man ein einfaches serverloses Backend auf Back4app mit Cloud-Code-Funktionen erstellt.

Der endgültige Quellcode ist im back4app-serverless Repo auf GitHub zu finden.

Künftige Schritte

1. Schauen Sie sich Parse Server Security an, um Ihr Backend sicherer zu machen.
2. Werfen Sie einen Blick auf The Ultimate Guide to Deploy Docker Apps, um zu erfahren, wie Sie ein benutzerdefiniertes Frontend für Back4app Containers erstellen und bereitstellen.
3. Erfahren Sie mehr über Parse Triggers.

FAQ