Wie stellt man eine Deno-Anwendung bereit?

Es gibt verschiedene Bereitstellungsoptionen für mit Deno erstellte Webanwendungen. In letzter Zeit hat sich jedoch die Containerisierung als Service-Plattform aufgrund der verschiedenen Vorteile, die sie gegenüber anderen Bereitstellungsoptionen bietet, zu einer beliebten Wahl entwickelt.

In diesem Artikel werden Sie Deno, seine Vorteile und seine Grenzen kennenlernen. Außerdem werden Sie eine einfache Deno-Anwendung erstellen und sie in Back4app-Containern bereitstellen.

Was ist Deno?

Deno ist eine sichere und moderne Laufzeitumgebung für JavaScript und TypeScript, die entwickelt wurde, um Einschränkungen und Designfehler von Node.js zu beheben.

Im Gegensatz zu Node.js betont es standardmäßig die Sicherheit und erzwingt granulare Berechtigungen für das Dateisystem und den Netzwerkzugriff.

Darüber hinaus unterstützt Deno nativ TypeScript, wodurch u. a. zusätzliche Einrichtungs- oder Transpilierungsschritte überflüssig sind.

Seit seiner Veröffentlichung im Jahr 2018 hat Deno aufgrund seiner Verbesserungen gegenüber Node.js die Aufmerksamkeit und das Interesse von Entwicklern geweckt.

Doch auch wenn Deno Verbesserungen bietet, bleibt Node.js ein ausgereiftes Ökosystem mit umfangreicher Community-Unterstützung und einem riesigen Paket-Repository.

Nichtsdestotrotz hat Deno eine wachsende Gemeinschaft von Entwicklern angezogen, die seinen Ansatz zu schätzen wissen und sein Potenzial ausloten.

Vorteile von Deno

Der Anstieg der Popularität von Deno ist auf einige grundlegende Gründe zurückzuführen. Einige davon sind die folgenden.

Verbesserte Sicherheit über Node.js

Ein wesentlicher Vorteil von Deno ist die verbesserte Sicherheit durch die Implementierung eines auf Berechtigungen basierenden Sicherheitsmodells und die Ausführung von Anwendungen in einer Sandbox-Umgebung.

Es implementiert ein erlaubnisbasiertes Sicherheitsmodell, bei dem eine explizite Autorisierung für den Zugriff auf Ressourcen wie das Dateisystem und das Netzwerk erforderlich ist.

Standardmäßig arbeitet Deno in einem eingeschränkten Modus und führt Anwendungen in einer Sandbox-Umgebung aus, um potenziell riskante Aktionen einzuschränken, sie vom zugrunde liegenden System zu isolieren und den direkten Zugriff auf sensible Ressourcen zu verhindern.

Umfassende Sicherheitsaudits und sorgfältige Codeüberprüfungen verstärken die robuste Sicherheit von Deno zusätzlich. Diese Maßnahmen bieten Ihnen eine zuverlässige und sichere Plattform für die Erstellung von Anwendungen, die Vertrauen in deren Sicherheit schafft und vor potenziellen Schwachstellen schützt.

Verwaltung von Abhängigkeiten

Im Vergleich zu traditionellen JavaScript-Laufzeitumgebungen wie Node.js bietet Deno einen anderen Ansatz für das Abhängigkeitsmanagement.

Anstatt sich auf eine zentrale Paketregistrierung zu verlassen, verwendet Deno URLs für den Import von Modulen direkt aus dem Internet.

Dieser Ansatz vereinfacht den Prozess, indem er einen separaten Paketmanager wie npm überflüssig macht und Bedenken bezüglich Versionskonflikten und der Komplexität der Verwaltung des Ordners “node_modules” ausräumt.

Sie können Abhängigkeiten angeben, indem Sie die URLs der zu importierenden Module angeben, was die gemeinsame Nutzung und Verteilung von Code erleichtert. Dieser dezentralisierte Ansatz für die Verwaltung von Abhängigkeiten in Deno fördert die Einfachheit, reduziert Reibungsverluste und trägt zu einer optimierten Entwicklung bei.

Sofortige TypeScript-Unterstützung

Deno bietet native und nahtlose Unterstützung für TypeScript und ist damit eine ausgezeichnete Wahl, wenn Sie TypeScript in Ihren Projekten bevorzugen oder benötigen.

TypeScript ist eine typisierte Obermenge von JavaScript, die statische Typisierung und andere erweiterte Sprachfunktionen für die JavaScript-Entwicklung bietet. Mit Deno sind keine zusätzlichen Konfigurations- oder Build-Schritte erforderlich, um TypeScript zu verwenden.

Deno wird zusammen mit dem TypeScript-Compiler ausgeliefert, so dass Sie TypeScript-Code direkt schreiben und ausführen können.

Durch diese native Unterstützung entfällt die Komplexität der Einrichtung einer separaten TypeScript-Toolchain und der Entwicklungsprozess wird vereinfacht.

Sie ermöglicht es Ihnen, die Vorteile der TypeScript-Typüberprüfung, der verbesserten Werkzeuge und der erweiterten Entwicklererfahrung bei der Erstellung von Anwendungen mit Deno zu nutzen.

Beschränkungen von Deno

Deno hat jedoch bestimmte Einschränkungen, die seine Akzeptanz beeinträchtigen. Einige davon sind wie folgt.

Unreifes Ökosystem

Eine der Einschränkungen von Deno ist der Reifegrad seines Ökosystems. Im Vergleich zu Node.js, das es schon länger gibt, ist das Ökosystem von Deno noch relativ neu und in der Entwicklung begriffen.

Das bedeutet, dass es möglicherweise weniger Bibliotheken, Frameworks und Tools von Drittanbietern gibt, die speziell für Deno entwickelt wurden. Möglicherweise müssen Sie bestimmte Funktionen von Grund auf neu erstellen oder vorhandene Node.js-Pakete für die Verwendung in Deno anpassen.

Die geringere Größe der Community bedeutet auch, dass im Vergleich zum etablierten Node.js-Ökosystem weniger Ressourcen, Tutorials und Community-Support verfügbar sind.

Mit zunehmender Popularität und Akzeptanz von Deno wird das Ökosystem jedoch voraussichtlich wachsen und reifen und in Zukunft eine breitere Palette von Bibliotheken und Tools anbieten.

Steile Lernkurve

Eine weitere Einschränkung von Deno ist die Lernkurve, die mit dem Übergang von anderen JavaScript-Laufzeitumgebungen, wie z. B. Node.js, verbunden ist.

Deno führt neue Konzepte, APIs und Muster ein, mit denen Sie sich möglicherweise erst vertraut machen müssen. Dazu gehört das Verständnis des Modulsystems von Deno, des auf Berechtigungen basierenden Sicherheitsmodells und der Unterschiede bei der Implementierung bestimmter Funktionen im Vergleich zu anderen Laufzeiten.

Entwickler, die Node.js bereits beherrschen, müssen möglicherweise Zeit und Mühe investieren, um die spezifischen Funktionen und Konventionen von Deno zu erlernen und sich an sie anzupassen.

Die Lernkurve kann jedoch durch Nachschlagen in der offiziellen Deno-Dokumentation, den Austausch mit der Deno-Community und die Erkundung verfügbarer Lernressourcen bewältigt werden.

Kompatibilität mit Node.js-Bibliotheken

Die Kompatibilität mit Node.js-Bibliotheken ist eine weitere Einschränkung von Deno. Aufgrund von Unterschieden in den Modulsystemen und Laufzeitumgebungen können nicht alle Node.js-Bibliotheken und -Module direkt und ohne Änderungen in Deno verwendet werden.

Deno verwendet ES-Module (ECMAScript-Module) als Modulsystem, während Node.js traditionell CommonJS-Module verwendet. Dieser Unterschied in den Modulformaten kann zu Inkompatibilitäten beim Importieren und Verwenden von Node.js-spezifischen Modulen in Deno führen.

Entwickler müssen unter Umständen Anpassungen vornehmen oder alternative Bibliotheken finden, die speziell für das Modulsystem von Deno konzipiert sind.

Deno bietet zwar eine Kompatibilitätsschicht für die Ausführung einiger Node.js-Module, deckt aber nicht alle Fälle ab, so dass manuelle Änderungen oder Anpassungen erforderlich sein können.

Deno-Bereitstellungsoptionen

Es gibt mehrere Bereitstellungsoptionen für Deno-Anwendungen, darunter die folgenden.

Infrastruktur-as-a-Service (IaaS)

Infrastructure-as-a-Service (IaaS) ist ein Cloud-Computing-Modell, das virtualisierte Datenverarbeitungsressourcen anbietet. Mit IaaS können Sie virtuelle Maschinen, Speicher und Netzwerke von Cloud-Anbietern auf einer Pay-as-you-go-Basis mieten. So können Sie Ihre eigene virtualisierte Infrastruktur einrichten und verwalten, ohne in physische Hardware zu investieren.

IaaS-Optionen ermöglichen Ihnen die Ausführung von Deno-Anwendungen auf virtuellen Maschinen. Beliebte IaaS-Plattformen wie AWS, Google Cloud und Microsoft Azure bieten flexible und skalierbare Lösungen, mit denen Sie die Infrastruktur entsprechend den spezifischen Anforderungen Ihrer Anwendung konfigurieren können.

IaaS bietet Ihnen zwar mehr Kontrolle und Ressourcenisolierung, erfordert aber auch einen höheren manuellen Aufwand bei der Einrichtung und Verwaltung, z. B. bei der Serverbereitstellung, Sicherheitsaktualisierung und Überwachung.

Daher ist IaaS eine gute Wahl, wenn Sie eine umfassende Kontrolle über Ihre Infrastruktur benötigen und über das nötige Fachwissen verfügen, um deren Komplexität effektiv zu bewältigen.

Container-as-a-Service (CaaS)

Container-as-a-Service (CaaS) ist ein Cloud-Computing-Modell, das die Bereitstellung und Verwaltung von containerisierten Anwendungen vereinfacht.

Mit CaaS können Sie sich auf die Entwicklung und Bereitstellung von Anwendungen konzentrieren, ohne sich um die zugrunde liegende Infrastruktur kümmern zu müssen.

Deno-Anwendungen können in Containern bereitgestellt werden, um Konsistenz und Isolierung zu gewährleisten. Back4app-Container sind eine beliebte CaaS-Option für die Deno-Bereitstellung.

CaaS-Plattformen bieten Skalierbarkeit und Ressourcenisolierung, wobei jede Anwendung in einem eigenen Container läuft, was die Sicherheit und Stabilität erhöht.

Die Konsistenz der Container gewährleistet, dass Deno-Anwendungen problemlos auf jeder Plattform eingesetzt werden können, die Container unterstützt.

CaaS-Lösungen haben zwar eine gewisse Lernkurve, bieten aber erhebliche Vorteile für Anwendungen, die eine dynamische Skalierung und Bereitstellung über mehrere Knoten oder Cluster hinweg erfordern.

Deno-Installationsprozess

Bevor Sie Deno verwenden können, müssen Sie es herunterladen und installieren. Die Installation von Deno hängt von Ihrem Betriebssystem ab.

Unter macOS und Linux können Sie Deno installieren, indem Sie den folgenden Befehl ausführen:

curl -fsSL <https://deno.land/x/install/install.sh> | sh

Unter Windows können Sie Deno mit Powershell installieren, indem Sie den folgenden Befehl ausführen:

irm <https://deno.land/install.ps1> | iex

Um zu bestätigen, dass die Installation erfolgreich war, können Sie den unten stehenden Befehl ausführen, der eine Versionsnummer in Ihr Terminal ausgibt.

deno --version

Wenn Sie die Versionsnummer nicht sehen, versuchen Sie, Deno erneut zu installieren.

Einrichten eines Deno-Projekts

Um eine einfache API mit Deno zu erstellen, benötigen Sie einen Router, einen Server und eine Datenbank.

Bevor Sie die folgenden Schritte ausführen, erstellen Sie einen Ordner src im Stammverzeichnis Ihres Projekts. Dieser Ordner wird alle Quelldateien Ihres Projekts enthalten.

Schritt 1: Erstellen einer Abhängigkeitsdatei

Im Gegensatz zu Node.js verwendet Deno keine Paketmanager wie NPM oder Yarn. Vielmehr werden die Pakete direkt über ihre URL importiert.

Um die Funktionen einer package.json-Datei zu imitieren, erstellen Sie eine deps.ts im Stammverzeichnis Ihres Projekts und fügen Sie den folgenden Codeblock hinzu.

export { Application, Router } from "https://deno.land/x/[email protected]/mod.ts";
export type { RouterContext} from "https://deno.land/x/[email protected]/mod.ts";
export { config as dotenvConfig } from "https://deno.land/x/[email protected]/mod.ts";
export { Client } from "https://deno.land/x/[email protected]/mod.ts";

Der obige Codeblock importiert (installiert) und exportiert Application, Router und RouterContex von Oak. config von dotenv und Client von deno-postgres.

Schritt 2: Erstellen eines Servers

In diesem Schritt werden Sie einen einfachen HTTP-Server mit Oak erstellen. Oak ist eine Middleware für den HTTP-Server von Deno, die auf Koa.js basiert, einem Framework für Node.js, das Express ähnelt, aber leichter ist.

Um einen HTTP-Server mit Oak zu erstellen, erstellen Sie eine server.ts-Datei in Ihrer src und fügen Sie den folgenden Codeblock hinzu.

import { Application } from "../deps.ts";
import config from "../config/default.ts";

import router from "./router.ts";

const app = new Application();

app.use(router.routes());
app.use(router.allowedMethods());

await app.listen({ port: config.port });

Der obige Codeblock erstellt einen HTTP-Server mit Oak und registriert einen Router, der den gesamten eingehenden Datenverkehr verarbeitet.

Die Zeile app.use(router.routes()) registriert die Routen des Routers als Middleware in der Anwendung Oak. Alle eingehenden Anfragen werden mit den registrierten Routen abgeglichen, und die entsprechenden Handler werden ausgeführt, wenn eine Übereinstimmung gefunden wird.

Wird keine Übereinstimmung gefunden, werden sie in der Zeile app.use(router.allowedMethods()) behandelt, indem geeignete Antworten wie 404 not found oder 405 not allowed gesendet werden.

Schritt 3: Management von Umweltvariablen

Die Speicherung sensibler Daten wie API-Schlüssel, Datenbankanmeldeinformationen usw. im Klartext stellt ein Sicherheitsrisiko dar. Jeder, der in den Besitz Ihrer Schlüssel oder Anmeldedaten gelangt, kann uneingeschränkten Zugang zu Ihrer Anwendung erhalten. Dies kann unter anderem zu Datenverlusten und Datendiebstahl führen.

Es gilt als gute Praxis, sensible Daten in Umgebungsvariablen zu speichern, um Situationen wie diese zu vermeiden.

Erstellen Sie eine .env-Datei im Stammordner Ihres Projekts und speichern Sie Ihre Datenbankanmeldedaten und andere vertrauliche Informationen in dieser Datei.

Etwa so:

#.env
DB_URI = <YOUR_POSTGRES_DB_URI>
PORT = 8000

Ersetzen Sie durch Ihre Datenbankanmeldedaten.

Als Nächstes erstellen Sie einen config-Ordner im Stammordner Ihres Projekts. Im config-Ordner erstellen Sie eine default.ts-Datei und fügen den unten stehenden Codeblock hinzu.

//default.ts
import { dotenvConfig } from "../deps.ts";

dotenvConfig({
  export: true,
  path: "../.env",
});

const config = {
  db: {
    dbUri: Deno.env.get("DB_URI"),
  },
  port: 3000
};

export default config;

Der obige Codeblock ruft die in Ihrer .env-Datei gespeicherten Werte sicher ab und macht sie für den Rest Ihrer Anwendung zugänglich.

Schritt 3: Verbinden mit einer Datenbank

In diesem Schritt werden Sie Ihre Anwendung mit einer Postgres-Datenbank verbinden. Sie benötigen die Datenbank, um Daten für Ihre Anwendung zu speichern und abzurufen.

Erstellen Sie eine Datei db.ts in Ihrem src-Ordner und fügen Sie den folgenden Codeblock hinzu.

//db.ts
import { Client } from "../deps.ts";
import config from "../config/default.ts";

let postgresConfiguration = config.db.dbUri;

const client = new Client(postgresConfiguration);

await client.connect();

export default client;

Der obige Codeblock versucht, Ihre Anwendung mit einer Postgres-Datenbank zu verbinden, indem er den URI verwendet, den Sie in Ihrer .env-Datei angegeben haben.

Schritt 4: Erstellen eines Datenbank-Repositorys

Erstellen Sie eine blogRepository-Datei in Ihrem src-Ordner und fügen Sie den folgenden Code in Ihre Datei ein.

//blogRepository.ts
import client from "./db.ts";

class BlogRepository {
  async createBlogTable() {
    const blog = await client.queryArray(
      `CREATE TABLE IF NOT EXISTS blogs (id SERIAL PRIMARY KEY, title VARCHAR(255), body VARCHAR(255), author VARCHAR(255))`
    );

    return blog;
  }

  async getAllBlogs() {
    const allBlogs = await client.queryArray("SELECT * FROM blogs");

    return allBlogs;
  }

  async getBlogById(id: string) {
    const blog = await client.queryArray(
      `SELECT * FROM blogs WHERE id = ${id}`
    );

    return blog;
  }

  async createBlog(title: string, body: string, author: string) {
    const blog = await client.queryArray(
      `INSERT INTO blogs (title, body, author) VALUES ('${title}', '${body}', '${author}')`
    );

    return blog;
  }

  async updateBlog(id: string, title: string, body: string, author: string) {
    const blog = await client.queryArray(
      `UPDATE blogs SET title = '${title}', body = '${body}', author = '${author}' WHERE id = ${id}`
    );

    return blog;
  }

  async deleteBlog(id: string) {
    const blog = await client.queryArray(`DELETE FROM blogs WHERE id = ${id}`);

    return blog;
  }
}

export default new BlogRepository();

Der obige Codeblock behandelt alle Datenbankoperationen, indem er rohe SQL-Abfragen abstrahiert und einfache Methoden bereitstellt, die Sie zur Interaktion mit Ihrer Postgres-Datenbank verwenden können.

Schritt 5: Erstellen von Route Handlern

In diesem Schritt werden Sie Routen-Handler erstellen, um einfache CRUD-Funktionen für Ihre Anwendung zu verarbeiten. Die unterstützten Routen sind die folgenden:

• GET /api/blogs: Liefert alle Blogs in Ihrer Datenbank
• GET /api/blog/:id: Gibt ein einzelnes Blog mit der in den URL-Parametern angegebenen ID zurück.
• POST /api/blog/new: Erzeugt einen neuen Blog in Ihrer Datenbank.
• PUT /api/blog/:id: Aktualisiert ein Blog mit der in den URL-Parametern angegebenen ID.
• DELETE /api/blog/:id: Löscht ein Blog mit der in den URL-Parametern angegebenen ID.

Erstellen Sie eine Datei router.ts in Ihrem src-Ordner und fügen Sie ihr die folgenden Importe hinzu.

import { Router, RouterContext } from "../deps.ts";
import blogRepository from "./blogRepository.ts";

Als Nächstes erstellen Sie eine Router-Instanz, indem Sie den folgenden Codeblock hinzufügen:

const router = new Router();

Um Ihre Router-Handler zu registrieren, müssen Sie sie mit der Router-Instanz verketten.

Zum Beispiel (GET /api/blogs):

router
  .get("/api/blogs", async (ctx: RouterContext<"/api/blogs">) => {
    const data = await blogRepository.getAllBlogs();
    console.log(data);

    //format data
    const allBlogs = data.rows.map((blog) => {
      return {
        id: blog[0],
        title: blog[1],
        body: blog[2],
        author: blog[3]
      };
    });

    ctx.response.body = allBlogs;
  })

Der obige Codeblock erstellt einen Routehandler für GET /api/blogs, indem er die Handlerlogik mit der Routerinstanz verkettet.

Verknüpfen Sie diese mit der zuvor verknüpften Methode, um die restlichen Routen zu registrieren. Zum Beispiel so:

GET /api/blog/:id:

.get("/api/blog/:id", async (ctx: RouterContext<"/api/blog/:id">) => {
    try {
      const data = await blogRepository.getBlogById(ctx.params.id);
      console.log(data);

      //format data
      const blog = data.rows.map((blog) => {
        return {
          id: blog[0],
          title: blog[1],
          body: blog[2],
          author: blog[3]
        };
      });

      ctx.response.body = blog;
    } catch (error) {
      ctx.response.status = 500;
      ctx.response.body = {
        msg: "Error getting blog",
        error,
      };
    }
  })

POST /api/blog/new

.post("/api/blog/new", async (ctx: RouterContext<"/api/blog/new">) => {
    const resBody = ctx.request.body();
    const blog = await resBody.value;

    if (!blog) {
      ctx.response.status = 400;
      ctx.response.body = { msg: "Invalid data. Please provide a valid blog." };
      return;
    }

    const { title, body, author } = blog;

    if (!(title && body && author)) {
      ctx.response.status = 400;
      ctx.response.body = {
        msg: "Title or description missing. Please provide a valid blog.",
      };
      return;
    }

    try {
      await blogRepository.createBlog(title, body, author);

      ctx.response.status = 201;
      ctx.response.body = {
        msg: "blog added successfully",
      };
    } catch (error) {
      ctx.response.status = 500;
      ctx.response.body = {
        msg: "Error adding blog",
        error,
      };
    }
  })

PUT /api/blog/:id:

.put("/api/blog/:id", async (ctx: RouterContext<"/api/blog/:id">) => {
    try {
      const resBody = ctx.request.body();
      const blog = await resBody.value;

      if (!blog) {
        ctx.response.status = 400;
        ctx.response.body = {
          msg: "Invalid data. Please provide a valid blog.",
        };
        return;
      }

      const { title, body, author } = blog;

      if (!(title && body && author)) {
        ctx.response.status = 400;
        ctx.response.body = {
          msg: "Title or description missing. Please provide a valid blog.",
        };

        return;
      }

      await blogRepository.updateBlog(ctx.params.id, title, body, author);

      ctx.response.status = 200;
      ctx.response.body = {
        msg: "blog updated successfully",
      };
    } catch (error) {
      console.log(error);
      ctx.response.status = 500;
      ctx.response.body = {
        msg: "Error updating blog",
        error: error.message,
      };
    }
  })

DELETE /api/blog/:id:

.delete("/api/blog/:id", async (ctx: RouterContext<"/api/blog/:id">) => {
    await blogRepository.deleteBlog(ctx.params.id);

    ctx.response.status = 200;
    ctx.response.body = {
      msg: "blog deleted successfully",
    };
  });

Exportieren Sie dann Ihre Router-Instanz. Zum Beispiel so:

export default router;

Ändern Sie schließlich die Datei server.ts, um eine Blog-Datenbank zu erstellen, wenn Ihre Anwendung zum ersten Mal startet.

Etwa so:

import { Application } from "../deps.ts";
import config from "../config/default.ts";
import blogRepository from "./blogRepository.ts";

import router from "./router.ts";

const app = new Application();

(async () => {
  await blogRepository.createBlogTable();
})();

app.use(router.routes());
app.use(router.allowedMethods());

await app.listen({ port: config.port });

Der geänderte Code fügt der Datei server.ts ein IIFE hinzu, das eine neue Blog-Tabelle in Ihrer Datenbank erstellt.

Bereitstellen Ihrer Deno-App auf Back4app-Containern

Um Ihre Deno-App auf Back4app-Containern bereitzustellen, müssen Sie die folgenden Schritte ausführen:

Schritt 1: Erstellen einer Dockerdatei

Ein Dockerfile enthält spezifische Anweisungen für die Erstellung eines Docker-Images. Diese Anweisungen leiten den Prozess der Erstellung des Abbilds.

Führen Sie den folgenden Befehl aus, um ein Dockerfile zu erstellen:

touch Dockerfile

Mit dem obigen Befehl wird eine Dockerdatei im Stammverzeichnis Ihres Projekts erstellt.

Als Nächstes fügen Sie den folgenden Codeblock in Ihre Dockerdatei ein:

FROM denoland/deno:latest

EXPOSE 8000

WORKDIR /app

COPY deps.ts .
RUN deno cache deps.ts

COPY . .

RUN deno cache src/server.ts

CMD ["run", "--allow-net", "--allow-env", "--allow-read", "src/server.ts"]

Das obige Dockerfile richtet eine containerisierte Umgebung für die Ausführung einer Deno-Anwendung ein. Es speichert die Anwendungsabhängigkeiten und den Einstiegspunkt und führt dann die Deno-Anwendung mit den angegebenen Berechtigungen aus, wenn der Container gestartet wird.

Es wird erwartet, dass die Anwendung auf Port 8000 lauscht, obwohl die tatsächliche Portzuordnung beim Ausführen des Containers vorgenommen werden muss.

Zum Schluss stellen Sie Ihren Code auf GitHub ein.

Schritt 2: Erstellen Sie eine neue Back4app-Anwendung

Um eine Back4app-Anwendung zu erstellen, besuchen Sie die offizielle Back4app-Website. Suchen Sie dort die Schaltfläche ” Anmelden” in der oberen rechten Ecke der Back4app-Landing Page. Wenn Sie auf die Schaltfläche ” Anmelden ” klicken, werden Sie zu einem Registrierungsformular weitergeleitet. Füllen Sie dieses Formular mit den erforderlichen Angaben aus, z. B. Ihrer E-Mail-Adresse, Ihrem Benutzernamen und Ihrem Passwort. Achten Sie darauf, dass die Angaben korrekt sind. Nachdem Sie das Formular ausgefüllt haben, senden Sie es ab.

Wenn Sie bereits ein Konto haben, klicken Sie stattdessen auf Anmelden.

Sobald Sie Ihr Back4app-Konto erfolgreich eingerichtet haben, melden Sie sich an, um auf Ihr Konto-Dashboard zuzugreifen. Suchen Sie dort die Schaltfläche “NEUE APP” und klicken Sie auf sie.

Diese Aktion leitet Sie zu einer Seite weiter, auf der Sie verschiedene Optionen für die Erstellung Ihrer neuen App finden. Da Sie beabsichtigen, die Containerisierung zu verwenden, wählen Sie die Option“Container als Service“.

Als nächstes verbinden Sie Ihr GitHub-Konto mit Ihrem Back4app-Konto. Sie können Back4app Zugriff auf alle Repositories in Ihrem Konto oder auf bestimmte Repositories geben.

Wählen Sie die Anwendung aus, die Sie bereitstellen möchten, in diesem Fall die Anwendung, die Sie in diesem Lernprogramm erstellt haben, und klicken Sie auf Auswählen.

Wenn Sie auf die Schaltfläche “Auswählen” klicken, werden Sie zu einer Seite weitergeleitet, auf der Sie einige Informationen über Ihre Anwendung eingeben müssen, z. B. den Namen, die Verzweigung, das Stammverzeichnis, die Optionen für die automatische Bereitstellung, den Port, den Zustand und die Umgebungsvariablen.

Stellen Sie sicher, dass Sie alle notwendigen Umgebungsvariablen angeben, die Ihre Anwendung benötigt, um korrekt zu funktionieren. Sobald Sie die erforderlichen Informationen ausgefüllt haben, klicken Sie auf die Schaltfläche “App erstellen”.

Dadurch wird der Bereitstellungsprozess gestartet, und nach einer Weile sollte Ihre Bereitstellung fertig sein. Wenn der Bereitstellungsprozess viel Zeit in Anspruch nimmt, können Sie in den Protokollen nachsehen, ob ein Fehler bei der Bereitstellung aufgetreten ist, oder die Anleitung zur Fehlerbehebung von Back4app lesen.

Schlussfolgerung

In diesem Artikel haben Sie Deno, seine Vorteile, Einschränkungen und beliebten Bereitstellungsoptionen kennengelernt und erfahren, wie Sie eine App mit Deno erstellen und Ihre App mit Back4app-Containern bereitstellen können.

Trotz seiner Einschränkungen ist Deno aufgrund seines Sicherheitsmodells ideal für die Entwicklung sehr sicherer und sensibler Anwendungen geeignet. Darüber hinaus entfällt durch die native TypeScript-Unterstützung der Aufwand für die Einrichtung von TypeScript in Ihrem Projekt.

Wenn Sie die in diesem Artikel beschriebenen Schritte befolgen, können Sie Ihre Deno-Anwendung einfach erstellen und auf Back4app-Containern bereitstellen.

FAQ