Was ist eine Backend-Infrastruktur?

Die Auswahl der richtigen Backend-Infrastruktur ist entscheidend für die Entwicklung Ihres Backends.

Sie kann sich auf die Leistung, Flexibilität und Wartungsfreundlichkeit Ihres Backends auswirken, um nur einige zu nennen.

In diesem Artikel wird erklärt, was eine Backend-Infrastruktur ist, welche verschiedenen Arten von Backend-Infrastrukturen es gibt und welche Faktoren Sie bei Ihrer Entscheidung beachten müssen.

Außerdem erfahren Sie, wie Sie eine Backend-Infrastruktur mit Back4app erstellen können.

Ziele

Am Ende dieses Artikels können Sie:

• Erklären, was eine Backend-Infrastruktur ist
• Verschiedene Arten von Backend-Infrastrukturen besprechen (einschließlich IaaS, PaaS und BaaS)
• Die richtige Backend-Infrastruktur für Ihr Projekt auszuwählen
• Ihr eigenes Backend mit Back4app erstellen

Was ist eine Backend-Infrastruktur?

Die Backend-Infrastruktur ist die Kombination aus Software- und Hardwarekomponenten, die ein Backend-System unterstützen.

Dazu gehören die Server, Container, Netzwerkkomponenten, Firewall und andere Ressourcen.

Die Backend-Infrastruktur ist verantwortlich für hohe Verfügbarkeit, Skalierung, Lastausgleich, Sicherheit, Routing und so weiter.

Die Backend-Infrastruktur muss so konzipiert sein, dass sie ein nahtloses Benutzererlebnis bietet.

Was ist bei der Auswahl einer Backend-Infrastruktur zu beachten?

Im Folgenden werden die wesentlichen Faktoren erörtert, die bei der Auswahl einer Backend-Infrastruktur zu berücksichtigen sind.

Geschwindigkeit

Die Geschwindigkeit ist eine der wichtigsten Eigenschaften der Backend-Infrastruktur. Ihre Benutzer möchten, dass die Anwendung so reibungslos wie möglich funktioniert.

Aus diesem Grund müssen Sie die Kommunikation zwischen Client und Backend optimieren.

Um die Wahrnehmung von Kommunikationsverzögerungen zu mildern, können Sie einige clevere Tricks anwenden.

So können Sie z. B. Skelettbildschirme, Ladebalken und Anzeigetipps und -tricks in die Benutzeroberfläche integrieren.

Geschwindigkeit ist auch einer der wichtigsten Faktoren bei der Suchmaschinenoptimierung.

Flexibilität

Flexibilität bezieht sich darauf, welche Programmiersprachen, Frameworks und andere Technologien (z. B. Datenbanken) Ihre Backend-Infrastruktur unterstützt.

Achten Sie bei der Auswahl einer Backend-Infrastruktur darauf, dass diese eine Vielzahl von Technologien unterstützt.

Skalierbarkeit

Sie sollten die Skalierbarkeit von dem Moment an berücksichtigen, in dem Sie mit der Entwicklung Ihrer Anwendung beginnen.

Überlegen Sie, wie Ihre Anwendung genutzt werden soll. Wird die Zahl der Nutzer konstant bleiben oder wird sie manchmal sprunghaft ansteigen?

Ihre Backend-Infrastruktur muss so aufgebaut sein, dass sie auch extremen Arbeitsbelastungen standhält.

Um die Serverkosten zu minimieren, sollten die Instanzen Ihrer Anwendung im laufenden Betrieb erstellt und vernichtet werden.

Wartungsfreundlichkeit

Die Entwicklung und Veröffentlichung Ihrer Anwendung macht nur 80 % der Arbeit aus. Danach müssen Sie viel Zeit in die Wartung Ihrer Anwendung investieren.

Die Aktualisierung Ihrer Serversoftware und die Bereitstellung von Sicherheits-Patches sollten so einfach wie möglich sein.

Entscheiden Sie sich für eine Backend-Infrastruktur mit einem integrierten CI/CD-System oder implementieren Sie Ihr eigenes.

DevOps-Anforderungen

Einige Arten von Backend-Infrastrukturen sind schwieriger zu verwenden. Wählen Sie die Backend-Infrastruktur, für deren Verwaltung Sie die nötige Zeit und die Ressourcen haben.

Wenn Sie sich für eine weniger anspruchsvolle Backend-Infrastruktur wie IaaS entscheiden, benötigen Sie ein spezialisiertes DevOps-Team, um diese zu verwalten.

Sicherheit

Sie tragen die volle Verantwortung für die Sicherheit der Daten Ihrer Benutzer. Angesichts der steigenden Zahl von Cyberangriffen müssen Sie sicherstellen, dass Ihre Backend-Infrastruktur den neuesten Sicherheitsstandards entspricht.

Verwenden Sie starke, automatisch generierte Passwörter, richten Sie eine Firewall ein, lassen Sie keine nicht vertrauenswürdige Software auf Ihren Servern laufen, führen Sie regelmäßige Sicherheitsüberprüfungen durch usw.

Arten der Backend-Infrastruktur

Sie können Ihre Server (die so genannte traditionelle Infrastruktur) verwenden oder eine Cloud-Infrastruktur für die Bereitstellung Ihres Backends nutzen.

In den letzten zehn Jahren haben sich viele Unternehmen auf Cloud-Modelle verlegt, weil sie damit Zeit und Geld sparen können.

Lassen Sie uns einige der beliebtesten Modelle analysieren.

Infrastructure as a Service oder IaaS

Infrastructure as a Service (IaaS) ist das am wenigsten abstrahierte Cloud-Computing-Modell. Bei diesem Modell stellt der Cloud-Anbieter Rechenressourcen in einer virtualisierten Umgebung bereit, z. B. Server, Speicher, Betriebssysteme und Netzwerkkomponenten.

IaaS gibt es seit 2010 und ist immer noch das beliebteste Cloud-Computing-Modell. Zu seinen Vorteilen gehören die hohe Skalierbarkeit, die umfassende Kontrolle und die Preiseffizienz.

Die Nachteile sind dagegen die komplexe Verwaltung und die im Vergleich zu anderen Cloud-Modellen höheren Wartungskosten.

Einige der beliebtesten IaaS-Anbieter sind:

• Google Cloud Platform (GCP)
• Amazon Web Services (AWS)
• Microsoft Azure

Plattform as a Service oder PaaS

Platform as a Service (PaaS) ist ein Cloud-Computing-Modell, das eine benutzerfreundliche Umgebung für die Entwicklung, Verwaltung und Bereitstellung von Anwendungen bietet.

Es umfasst verschiedene integrierte Tools für die Anwendungsentwicklung, mit denen Sie Ihre Anwendung leicht zum Laufen bringen können.

PaaS rationalisiert die Verwaltung der Infrastruktur und bietet einen schnelleren Markteintritt, mehr Sicherheit, Kosteneinsparungen, Skalierbarkeit, hohe Verfügbarkeit und weniger Programmieraufwand.

Andererseits kann es Sie an die Fähigkeiten des Anbieters binden, das Risiko der Anbieterbindung mit sich bringen und die Flexibilität und Kontrolle einschränken.

Beispiele für PaaS-Lösungen sind:

• Render
• Heroku
• Fly.io

Backend as a Service oder BaaS

Backend as a Service (BaaS) automatisiert die serverseitige Entwicklung und die Verwaltung der Cloud-Infrastruktur.

Es bietet Echtzeit-Datenbanken, Benutzerverwaltung, Authentifizierung, Benachrichtigungen, Social-Media-Integrationen und so weiter.

BaaS befreit Entwickler von Backend-Problemen, so dass sie sich auf das Frontend und das Kerngeschäft konzentrieren können.

BaaS kombiniert die Vorteile von IaaS und PaaS mit der Abstraktion des Backends, was zu einer schnelleren Markteinführung und Kosteneinsparungen führt.

Die Nachteile sind die fehlende Kontrolle, das Risiko einer Anbieterbindung und die relativ hohen Kosten.

Meine persönlichen Favoriten unter den BaaS-Plattformen sind:

• Back4app
• Firebase
• Backendless

Container as a Service oder CaaS

Containers as a Service (CaaS) ist ein Cloud-Computing-Modell zum Hochladen, Erstellen, Skalieren und Verwalten von Containern.

CaaS umfasst in der Regel eine Container-Laufzeitumgebung, eine Container-Registry, automatische Skalierungsfunktionen, ein integriertes CI/CD-System, Lastausgleich und vieles mehr!

CaaS vereinfacht die Handhabung von Containern und beseitigt Bedenken hinsichtlich der zugrunde liegenden Infrastruktur.

Es fördert die agile Entwicklung, erleichtert die Microservice-Architektur und beschleunigt die Erstellung hochskalierbarer Anwendungen.

CaaS-Plattformen umfassen:

• Back4app Containers
• Amazon Elastic Container Service
• Google Cloud Kubernetes

Wie erstellt man eine Backend-Infrastruktur?

In diesem Teil des Artikels werden wir eine Backend-Infrastruktur mit Back4app erstellen.

Was ist Back4app?

Back4app ist eine außergewöhnliche Backend as a Service (BaaS) Plattform. Sie ermöglicht es Ihnen, Backends für Web- und mobile Anwendungen schnell zu erstellen.

Die Plattform basiert auf Open-Source-Technologien und verfügt über zahlreiche Funktionen. Zu den Funktionen gehören Spreadsheet-ähnliche Datenbanken, Dateispeicher, Benutzerverwaltung, Authentifizierung, automatisch generierte APIs, Benachrichtigungen und vieles mehr!

Back4app kann Ihnen helfen, Ihre Markteinführung erheblich zu beschleunigen. Durch den Einsatz von Back4app können Sie sich auf den Kern Ihres Geschäfts konzentrieren, anstatt sich um das Backend oder die zugrunde liegende Infrastruktur kümmern zu müssen.

Sie brauchen keine spezialisierten DevOps-Ingenieure, und Ihre Wartungskosten sind geringer.

Das Beste an Back4app ist, dass es eine kostenlose Version gibt. Diese eignet sich hervorragend zum Testen der Plattform oder zum Hosten von kleinen Projekten. Wenn Ihre App erfolgreich ist, können Sie auf Premium- Stufenaufsteigen.

Um mehr über Back4app zu erfahren, lesen Sie bitte Was ist Back4app?

Projektübersicht

Um zu zeigen, wie man ein Backend erstellt, werden wir einen einfachen E-Commerce-Backend-Dienst aufbauen. Das Backend wird es uns ermöglichen, Produkte, Kategorien und Bestellungen zu verwalten.

Das ER-Diagramm unseres Projekts wird wie folgt aussehen.

Wir werden das Backend mit einem Minimum an Code erstellen und zeigen, wie es auf der Client-Seite verwendet werden kann (über SDKs, REST API und GraphQL API).

App erstellen

Um mitzumachen, ist ein Back4app-Konto erforderlich. Sie brauchen eins? Melden Sie sich noch heute an!

Nachdem Sie sich bei Ihrem Back4app-Konto angemeldet haben, sehen Sie die Liste Ihrer Apps. Klicken Sie auf die Schaltfläche „ Build app “, um den Prozess der App-Erstellung zu starten.

Wählen Sie als Nächstes „BaaS“, da wir ein Backend einrichten wollen.

Wählen Sie einen App-Namen, wählen Sie „NoSQL“, und erstellen Sie die App.

Back4app wird einige Zeit brauchen, um alles einzurichten. Es kümmert sich um die Anwendungsschicht, die Datenbank, Backups, Skalierung und mehr.

Sobald die App erstellt ist, werden Sie zur Echtzeit-Datenbank Ihrer App weitergeleitet.

Datenbank einrichten

Nachdem wir nun unsere Anwendung erstellt haben, kümmern wir uns um die Datenbank.

Zuerst müssen wir eine Klasse erstellen, um Daten in der Datenbank zu speichern. Sie können die Klassen als Tabellen (SQL-Terminologie) oder Modelle (ORM-Terminologie) betrachten. Jede Klasse hat standardmäßig die folgenden vier Felder:

+-------------+-------------+------------------------------------------+
| Type        | Name        | Description                              |
+-------------+-------------+------------------------------------------+
| String      | objectId    | Object's unique identifier               |
+-------------+-------------+------------------------------------------+
| Date        | updatedAt   | Date time of the last update             |
+-------------+-------------+------------------------------------------+
| Date        | createdAt   | Date time of creation                    |
+-------------+-------------+------------------------------------------+
| ACL         | ACL         | Access Control List                      |
+-------------+-------------+------------------------------------------+

Wie in der Projektübersicht erwähnt, wird unser Projekt drei Klassen haben. Erstellen Sie die erste Klasse, indem Sie auf die Schaltfläche „ Create class “ in der Seitenleiste klicken. Nennen Sie sie ProductCategory:

Fügen Sie die folgenden Felder hinzu:

+-----------------------------+-------------+---------------+----------+
| Type                        | Name        | Default value | Required |
+-----------------------------+-------------+---------------+----------+
| String                      | name        | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+
| String                      | description | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+

Führen Sie die gleichen Schritte für die Klasse Product durch:

+-----------------------------+-------------+---------------+----------+
| Type                        | Name        | Default value | Required |
+-----------------------------+-------------+---------------+----------+
| String                      | name        | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+
| String                      | description | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+
| Relation -> ProductCategory | categories  | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+
| Number                      | price       | 0             | yes      |
+-----------------------------+-------------+---------------+----------+

Wir haben den Datentyp Relation verwendet, um die Many-to-many-Beziehung zu handhaben.

Erstellen Sie abschließend die Klasse Order:

+-----------------------------+------------+---------------+----------+
| Data type                   | Name       | Default value | Required |
+-----------------------------+------------+---------------+----------+
| Pointer -> Product          | product    | <leave blank> | yes      |
+-----------------------------+------------+---------------+----------+
| String                      | cFirstName | <leave blank> | yes      |
+-----------------------------+------------+---------------+----------+
| String                      | cLastName  | <leave blank> | yes      |
+-----------------------------+------------+---------------+----------+
| String                      | cAddress   | <leave blank> | yes      |
+-----------------------------+------------+---------------+----------+
| Number                      | delivered  | false         | yes      |
+-----------------------------+------------+---------------+----------+

Wir haben den Datentyp Pointer verwendet, um die Eins-zu-Viel-Beziehung zu behandeln.

Sobald Sie fertig sind, sollten Sie die Klassen in der Seitenleiste sehen.

Befüllen der Datenbank

Lassen Sie uns nun die Datenbank befüllen.

Beginnen Sie mit der Erstellung einiger Produktkategorien, Produkte und Bestellungen (in dieser Reihenfolge). Wenn Sie keine Ideen mehr haben, können Sie dieses Material auch importieren.

Um eine JSON-Datei zu importieren, verwenden Sie die Option „Mehr > Importieren > Klassendaten > Datei auswählen“. Achten Sie darauf, dass Sie die JSON-Dateien in der folgenden Reihenfolge importieren:

1. ProductCategory.json
2. Product.json
3. _Join꞉categories꞉Product.json
4. Order.json

Wenn Sie fertig sind, sollten Sie einige Produkte, Kategorien und Bestellungen in Ihrer Datenbank haben.

Dieser Schritt ist erforderlich, da wir einige Daten benötigen, um das Backend in einer späteren Phase zu testen.

Sichern Sie die Datenbank

Wenn Sie fertig sind, sollten Sie einige Produkte, Kategorien und Bestellungen in Ihrer Datenbank haben. Dieser Schritt ist erforderlich, da wir einige Daten benötigen, um das Backend in einer späteren Phase zu testen.

Standardmäßig werden Datenbankklassen im „Geschützten Modus“ erstellt. Im geschützten Modus ist die einzige Möglichkeit, mit Objekten zu interagieren und sie zu verwalten, die Verwendung des Hauptschlüssels. Dies ist nicht optimal, da wir keine Objekte von der Client-Seite abrufen oder verwalten können.

Um dies zu ermöglichen, müssen wir einige Beschränkungen aufheben. Back4app/Parse verfügt über zwei Beschränkungsmechanismen:

1. Class-level permissions (CLPs)
2. Access-level permissions (ACLs)

Mit CLPs können wir Beschränkungen auf der Klassenebene durchsetzen, während ACLs Beschränkungen auf der Objektebene ermöglichen. Beide Mechanismen können eine Klasse oder ein Objekt auf eine bestimmte Role oder einen bestimmten User beschränken.

Wählen Sie in der Seitenleiste die Klasse Product aus und klicken Sie auf den Text „Geschützt“ am oberen Rand des Bildschirms. Ändern Sie dann die CLPs:

Führen Sie die gleichen Schritte für das ProductCategory Modell durch.

Aktualisieren Sie dann die CLPs für die Klasse Order:

Achten Sie auf das Bild. Hier aktivieren wir auch die Berechtigung Create.

Mit den neuen CLPs können nicht authentifizierte Benutzer Producte und ProductCategoryies abrufen, abfragen und zählen, aber nicht ändern. Dasselbe gilt für die Klasse Order, aber hier können die Benutzer auch neue Bestellungen erstellen.

Weitere Informationen finden Sie in unserem Artikel zur Sicherheit von Parse Server.

Verwaltungs-App

Zurzeit können Sie Objekte in Ihrer Datenbank nur über die Datenbankansicht verwalten. Das funktioniert zwar für Entwickler, ist aber für nicht-technische Benutzer nicht intuitiv. Darüber hinaus gibt es den Benutzern zu viel Kontrolle und ist anfällig für menschliche Fehler.

Glücklicherweise können Sie mit Back4app ganz einfach die „Admin App“-Funktionalität aktivieren. Die Admin App ist eine einfach zu bedienende Verwaltungsoberfläche, die auf Ihre Datenbankklassen zugeschnitten ist.

Aktivieren Sie es, indem Sie zunächst in der Seitenleiste zu „Mehr > Admin App“ navigieren. Klicken Sie dann auf „Aktivieren“:

Back4app fordert Sie auf, einen Benutzernamen, ein Passwort und eine Subdomain zu wählen. Ich habe mich für die folgende Variante entschieden:

user:        root
pass:        complexpassword123
subdomain:   https://binfra.admin.back4app.com/

Gut, das ist alles, was Sie tun müssen.

Sie können auf das Administrationspanel zugreifen, indem Sie auf die „Admin App URL“ klicken.

Wenn Sie darauf klicken, öffnet sich ein neues Browser-Fenster und Sie werden aufgefordert, Ihre Administrator-Anmeldedaten einzugeben. Sobald Sie eingeloggt sind, können Sie Objekte erstellen, aktualisieren und löschen.

Probieren Sie das Dashboard aus, um sich mit ihm vertraut zu machen.

Cloud Code

Back4app ermöglicht es Ihnen, benutzerdefinierten JavaScript-Code über den sogenannten Cloud Code auszuführen. Mit Cloud Code können Sie Funktionen definieren, die durch Parse oder HTTP-Anfragen ausgelöst oder periodisch ausgeführt werden können. Außerdem kann Cloud Code verwendet werden, um Webanwendungen mit Express zu erstellen.

Cloud Code Function

Angenommen, wir möchten eine Cloud Code-Funktion, die den aktuellen Umsatz berechnet.

Navigieren Sie zunächst zu „Cloud Code > Funktion & Webhosting“ in der Seitenleiste. Sie werden feststellen, dass die Cloud Code-Ansicht in zwei Teile geteilt ist. Auf der linken Seite sehen Sie die Verzeichnisstruktur und auf der rechten Seite den Code.

Öffnen Sie nun cloud/main.js und fügen Sie den folgenden Code ein:

// cloud/main.js

Parse.Cloud.define("calculateSales", async (request) => {
  const orderClass = Parse.Object.extend("Order");
  const orderQuery = new Parse.Query(orderClass);
  let sales = 0;

  try {
    const orders = await orderQuery.find();

    for (var i = 0; i < orders.length; i++) {
      let order = orders[i];
      let productId = order.get("product")["id"];

      const productClass = Parse.Object.extend("Product");
      const productQuery = new Parse.Query(productClass);
      const product = await productQuery.get(productId);

      sales += product.get("price");
    }
    return { 
      sales: sales,
    };
  } catch (error) {
    console.error("Error calculating the sales: " + error.message);
    return {
      sales: 0,
    }
  }
});

Parse.Cloud.job("printSales", async (request, status) => {
  try {
    const result = await Parse.Cloud.run("calculateSales");
    console.log("Sales: " + result.sales + "$");
  } catch (error) {
    console.error("Error calculating the sales: " + error.message);
  }
});

1. Wir haben eine Cloud-Code-Funktion namens calculateSales() definiert. Die Funktion durchläuft alle Bestellungen, holt die entsprechenden Produkte und summiert deren Preise.
2. Wir haben einen Cloud-Code-Job namens printSales() definiert, der es uns ermöglicht, die Funktion vom Parse-Dashboard aus auszuführen und sie regelmäßig zu planen.

Klicken Sie abschließend auf „Deploy“, um den Cloud-Code bereitzustellen.

Vergewissern Sie sich, dass der Job funktioniert, indem Sie in der Seitenleiste zu „Cloud Code > Jobs“ navigieren und dann den Job printSales() ausführen. Wenn alles gut funktioniert, sollten Sie in den Protokollen eine Meldung sehen, z. B. Sales: 1440$.

Cloud Code Scheduling

Um den Job zu planen, müssen Sie in der Seitenleiste zu „App Settings > Server Settings“ navigieren. Scrollen Sie nach unten zu „ Background jobs“, klicken Sie auf „Schedule a job“, und füllen Sie das Formular aus.

Um sicherzugehen, dass es funktioniert, überprüfen Sie noch einmal die Protokolle.

Client Side

Es gibt mehrere Möglichkeiten, mit Ihrem Back4app-basierten Backend zu interagieren:

1. Parse SDK
2. RESTful API (automatisch generiert)
3. GraphQL API (automatisch generiert)

Als Faustregel gilt, dass Sie immer das Parse SDK verwenden sollten, wenn es für Ihre Plattform verfügbar ist.

Wenn nicht, verwenden Sie entweder die RESTful-API oder die GraphQL-API. Die Wahl zwischen den APIs hängt von Ihren Daten ab.

As a rule of thumb, you should always use Parse SDK if it’s available for your platform. If not, either go with RESTful API or GraphQL API. The choice between the APIs depends on your data.

Wie Sie Parse SDK mit verschiedenen Frameworks verwenden können, erfahren Sie in den Dokumenten.

Nichtsdestotrotz sollten wir unser Backend mit der integrierten REST-Konsole testen.

Navigieren Sie zu „API > REST“ in der Seitenleiste und versuchen Sie, alle Produkte abzufragen, indem Sie das Formular ausfüllen:

Sie sollten eine ähnliche Antwort erhalten:

{
    "results": [
        {
            "objectId": "4ZyHH3X0RQ",
            "name": "Fitness Tracker Watch",
            "description": "...",
            "price": 80,
            "createdAt": "2023-10-17T20:03:55.424Z",
            "updatedAt": "2023-10-17T20:24:12.322Z",
            "categories": {
                "__type": "Relation",
                "className": "ProductCategory"
            }
        },
        {
            "objectId": "cDqlGJzT5U",
            "name": "Organic Fruit Basket",
            "description": "...",
            "price": 40,
            "createdAt": "2023-10-17T20:04:10.063Z",
            "updatedAt": "2023-10-17T20:24:00.382Z",
            "categories": {
                "__type": "Relation",
                "className": "ProductCategory"
            }
        },
    // ...
}

Versuchen Sie, die folgenden Abfragen durchzuführen:

1. Alle Produkte abrufen, die teurer sind als 50
2. Alle Bestellungen abrufen, die noch nicht geliefert worden sind
3. Ein neues Produkt erstellen und ihm eine Kategorie hinzufügen
4. Eine Bestellung löschen

Zusammenfassung

Sie wissen nun, was eine Backend-Infrastruktur ist, kennen die verschiedenen Arten von Backend-Infrastrukturen und wissen, wie Sie die richtige Infrastruktur für Ihr Projekt auswählen.

Darüber hinaus haben Sie gelernt, wie Sie eine Backend-Infrastruktur auf Back4app erstellen können. Sie haben sich um die Datenbank, die Datenbanksicherheit, den benutzerdefinierten Code, das Job Scheduling und die API-Tests gekümmert.

Eine Anleitung zur Erstellung der Client-Seite für ein Back4app-basiertes Backend finden Sie in unseren anderen Artikeln:

1. Wie hostet man Frontend und Backend?
2. Wie entwickelt man eine Social Media App?
3. Wie baut man einen Chatbot mit React?

Zusätzliche Artikel-Ressourcen sind in einem GitHub-Repositorium verfügbar.