Bagaimana Cara Menerapkan Aplikasi Deno?

Berbagai opsi penerapan tersedia untuk aplikasi web yang dibangun dengan Deno. Namun, kontainerisasi sebagai platform layanan telah menjadi pilihan populer belakangan ini karena berbagai keuntungan yang ditawarkannya dibandingkan opsi penerapan lainnya.

Dalam artikel ini, Anda akan menjelajahi Deno, kelebihan, dan keterbatasannya. Selain itu, Anda akan membuat aplikasi Deno sederhana dan menerapkannya pada kontainer Back4app.

Apa itu Deno?

Deno adalah runtime yang aman dan modern untuk JavaScript dan TypeScript yang dibuat untuk mengatasi keterbatasan dan kekurangan desain yang ditemukan di Node.js.

Tidak seperti Node.js, ini menekankan keamanan secara default, memberlakukan izin granular untuk sistem file dan akses jaringan.

Selain itu, Deno secara native mendukung TypeScript, sehingga tidak perlu lagi melakukan langkah penyiapan atau transpilasi, di antara fitur-fitur lainnya.

Sejak dirilis pada tahun 2018, Deno telah menarik perhatian dan minat para pengembang karena peningkatannya atas Node.js.

Namun, meskipun Deno menawarkan peningkatan, Node.js tetap menjadi ekosistem yang matang dengan dukungan komunitas yang luas dan repositori paket yang sangat besar.

Meskipun demikian, Deno telah menarik komunitas pengembang yang terus berkembang yang menghargai pendekatannya dan mengeksplorasi potensinya.

Keuntungan dari Deno

Naiknya popularitas Deno disebabkan oleh beberapa alasan yang mendasarinya. Beberapa di antaranya adalah sebagai berikut.

Peningkatan Keamanan pada Node.js

Deno menawarkan keamanan yang lebih baik sebagai keunggulan utama, menerapkan model keamanan berbasis izin dan menjalankan aplikasi dalam lingkungan sandbox.

Ini menerapkan model keamanan berbasis izin, di mana otorisasi eksplisit diperlukan untuk mengakses sumber daya seperti sistem file dan jaringan.

Secara default, Deno beroperasi dalam mode terbatas dan menjalankan aplikasi di lingkungan kotak pasir, membatasi tindakan yang berpotensi berisiko, mengisolasinya dari sistem yang mendasarinya, dan mencegah akses langsung ke sumber daya yang sensitif.

Audit keamanan yang komprehensif dan tinjauan kode yang cermat semakin memperkuat keamanan Deno yang kuat. Langkah-langkah ini memberi Anda platform yang dapat diandalkan dan aman untuk membangun aplikasi, menanamkan kepercayaan pada keamanannya, dan melindungi dari potensi kerentanan.

Manajemen Ketergantungan

Deno menawarkan pendekatan yang berbeda untuk manajemen ketergantungan dibandingkan dengan lingkungan runtime JavaScript tradisional seperti Node.js.

Alih-alih mengandalkan registri paket terpusat, Deno memanfaatkan URL untuk mengimpor modul langsung dari web.

Pendekatan ini menyederhanakan proses dengan menghilangkan kebutuhan akan manajer paket terpisah seperti npm dan mengurangi kekhawatiran yang terkait dengan konflik versi dan kerumitan mengelola folder “node_modules”.

Anda dapat menentukan dependensi dengan menentukan URL modul yang ingin diimpor, sehingga membuat pembagian dan pendistribusian kode menjadi lebih mudah. Pendekatan terdesentralisasi untuk manajemen ketergantungan di Deno ini mendorong kesederhanaan, mengurangi gesekan, dan membantu memastikan pengalaman pengembangan yang lebih efisien.

Dukungan TypeScript di Luar Kotak

Deno menawarkan dukungan asli dan tanpa batas untuk TypeScript, menjadikannya pilihan yang sangat baik jika Anda lebih suka atau memerlukan TypeScript dalam proyek Anda.

TypeScript adalah superset pengetikan JavaScript yang menghadirkan pengetikan statis dan fitur bahasa tingkat lanjut lainnya ke dalam pengembangan JavaScript. Dengan Deno, tidak diperlukan konfigurasi tambahan atau langkah-langkah pembuatan untuk menggunakan TypeScript.

Deno dibundel dengan kompiler TypeScript, yang memungkinkan Anda untuk menulis dan menjalankan kode TypeScript secara langsung.

Dukungan asli ini menghilangkan kerumitan dalam menyiapkan toolchain TypeScript yang terpisah dan menyederhanakan proses pengembangan.

Ini memungkinkan Anda untuk memanfaatkan pemeriksaan tipe TypeScript, perkakas yang lebih baik, dan pengalaman pengembang yang lebih baik saat membangun aplikasi dengan Deno.

Keterbatasan Deno

Namun, Deno memiliki beberapa keterbatasan yang mempengaruhi pengadopsiannya. Beberapa di antaranya adalah sebagai berikut.

Ekosistem yang belum matang

Salah satu keterbatasan Deno adalah kematangan ekosistemnya. Dibandingkan dengan Node.js yang sudah ada sejak lama, ekosistem Deno masih relatif baru dan terus berkembang.

Ini berarti mungkin ada lebih sedikit pustaka, kerangka kerja, dan alat pihak ketiga yang dirancang khusus untuk Deno. Anda mungkin perlu membangun fungsionalitas tertentu dari awal atau mengadaptasi paket Node.js yang sudah ada untuk digunakan di Deno.

Ukuran komunitas yang lebih kecil juga berarti bahwa mungkin ada lebih sedikit sumber daya, tutorial, dan dukungan komunitas yang tersedia dibandingkan dengan ekosistem Node.js yang sudah mapan.

Namun, seiring dengan popularitas dan adopsi Deno, ekosistemnya diharapkan akan tumbuh dan matang, menawarkan lebih banyak pustaka dan alat di masa depan.

Kurva Pembelajaran yang Curam

Keterbatasan lain dari Deno adalah kurva pembelajaran yang terkait dengan transisi dari lingkungan runtime JavaScript lainnya, seperti Node.js.

Deno memperkenalkan konsep, API, dan pola baru yang mungkin perlu Anda kenali. Ini termasuk memahami sistem modul Deno, model keamanan berbasis izin, dan perbedaan dalam bagaimana fungsi tertentu diimplementasikan dibandingkan dengan runtime lain.

Pengembang yang sudah mahir dalam Node.js mungkin perlu menginvestasikan waktu dan upaya untuk mempelajari dan beradaptasi dengan fitur dan konvensi khusus Deno.

Namun, kurva pembelajaran dapat dikelola dengan mengacu pada dokumentasi resmi Deno, terlibat dengan komunitas Deno, dan mengeksplorasi sumber daya pembelajaran yang tersedia.

Kompatibilitas dengan Perpustakaan Node.js

Kompatibilitas dengan pustaka Node.js adalah keterbatasan lain dari Deno. Karena perbedaan dalam sistem modul dan lingkungan runtime, tidak semua pustaka dan modul Node.js dapat langsung digunakan di Deno tanpa modifikasi.

Deno menggunakan modul ES (modul ECMAScript) sebagai sistem modulnya, sedangkan Node.js secara tradisional menggunakan modul CommonJS. Perbedaan format modul ini dapat menyebabkan ketidakcocokan saat mengimpor dan menggunakan modul khusus Node.js di Deno.

Pengembang mungkin perlu melakukan penyesuaian atau mencari pustaka alternatif yang dirancang khusus untuk bekerja dengan sistem modul Deno.

Meskipun Deno menyediakan lapisan kompatibilitas untuk menjalankan beberapa modul Node.js, lapisan ini mungkin tidak mencakup semua kasus, dan modifikasi atau adaptasi manual mungkin diperlukan.

Opsi Penerapan Deno

Ada beberapa opsi penyebaran untuk aplikasi Deno, dan beberapa di antaranya adalah sebagai berikut.

Infrastruktur sebagai Layanan (IaaS)

Infrastructure-as-a-Service (IaaS) adalah model komputasi awan yang menawarkan sumber daya komputasi tervirtualisasi. Dengan IaaS, Anda bisa menyewa mesin virtual, penyimpanan, dan jaringan dari penyedia layanan cloud dengan sistem bayar sesuai pemakaian. Hal ini memungkinkan Anda untuk mengatur dan mengelola infrastruktur tervirtualisasi Anda sendiri tanpa berinvestasi pada perangkat keras fisik.

Opsi IaaS memungkinkan Anda untuk menjalankan aplikasi Deno pada mesin virtual. Platform IaaS yang populer seperti AWS, Google Cloud, dan Microsoft Azure menawarkan solusi yang fleksibel dan dapat diskalakan, sehingga Anda dapat mengonfigurasi infrastruktur sesuai dengan kebutuhan spesifik aplikasi Anda.

Namun, meskipun IaaS memberi Anda kontrol yang lebih besar dan isolasi sumber daya, IaaS juga menuntut lebih banyak pengaturan dan manajemen manual, yang melibatkan tugas-tugas seperti penyediaan server, pembaruan keamanan, dan pemantauan.

Oleh karena itu, IaaS adalah pilihan yang tepat ketika Anda membutuhkan kontrol yang luas atas infrastruktur Anda dan memiliki keahlian untuk menangani kerumitannya secara efektif.

Kontainer sebagai Layanan (CaaS)

Container-as-a-Service (CaaS) adalah model komputasi awan yang menyederhanakan penyebaran dan pengelolaan aplikasi dalam kontainer.

Dengan CaaS, Anda bisa fokus membangun dan menerapkan aplikasi tanpa perlu mengkhawatirkan infrastruktur yang mendasarinya.

Aplikasi Deno dapat digunakan dalam kontainer, memastikan konsistensi dan isolasi. Kontainer Back4app adalah opsi CaaS yang populer untuk penerapan Deno.

Platform CaaS menawarkan skalabilitas dan isolasi sumber daya, dengan setiap aplikasi berjalan dalam wadahnya sendiri, meningkatkan keamanan dan stabilitas.

Konsistensi kontainer memastikan bahwa aplikasi Deno dapat dengan mudah digunakan pada platform apa pun yang mendukung kontainer.

Meskipun solusi CaaS memiliki kurva pembelajaran, solusi ini memberikan manfaat yang signifikan untuk aplikasi yang membutuhkan penskalaan dan penyebaran dinamis di beberapa node atau cluster.

Proses Instalasi Deno

Sebelum Anda bisa menggunakan Deno, Anda harus mengunduh dan menginstalnya. Instalasi Deno bervariasi tergantung pada sistem operasi Anda.

Di macOS dan Linux, Anda bisa menginstal Deno dengan menjalankan perintah di bawah ini:

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

Pada Windows, Anda dapat menginstal Deno menggunakan Powershell dengan menjalankan perintah di bawah ini:

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

Untuk mengonfirmasi bahwa instalasi Anda berhasil, Anda dapat menjalankan perintah di bawah ini, dan perintah tersebut akan mencetak nomor versi ke terminal Anda.

deno --version

Jika Anda tidak melihat nomor versi, coba instal Deno lagi.

Menyiapkan Proyek Deno

Untuk membuat API sederhana dengan Deno, Anda memerlukan router, server, dan database.

Sebelum mengikuti langkah-langkah di bawah ini, buatlah folder src di direktori root proyek Anda. Folder ini akan berisi semua file sumber proyek Anda.

Langkah 1: Membuat File Ketergantungan

Tidak seperti Node.js, Deno tidak menggunakan manajer paket seperti NPM atau Yarn. Sebaliknya, paket-paket diimpor langsung dari URL-nya.

Untuk meniru fungsi dari berkas package.json, buat deps.ts di direktori root proyek Anda dan tambahkan blok kode di bawah ini ke dalamnya.

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

Blok kode di atas mengimpor (menginstal) dan mengekspor Aplikasi, Router, dan RouterContex dari Oak. config dari dotenv dan Klien dari deno-postgres.

Langkah 2: Membuat Server

Pada langkah ini, Anda akan membuat server HTTP sederhana dengan Oak. Oak adalah middleware untuk server HTTP Deno yang berbasis Koa.js, sebuah kerangka kerja untuk Node.js yang mirip dengan Express tetapi lebih ringan.

Untuk membuat server HTTP dengan Oak, buat file server.ts di src Anda dan tambahkan blok kode di bawah ini.

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

Blok kode di atas membuat server HTTP dengan Oak dan mendaftarkan router untuk menangani semua lalu lintas yang masuk.

Baris app.use(router.routes()) mendaftarkan rute router sebagai middleware dalam aplikasi Oak. Semua permintaan yang masuk akan dicocokkan dengan rute yang terdaftar, dan penangan yang sesuai akan dieksekusi jika ditemukan kecocokan.

Jika kecocokan tidak ditemukan, baris app.use(router.allowedMethods()) akan menanganinya dengan mengirimkan respons yang sesuai, seperti 404 not found atau 405 not allowed.

Langkah 3: Mengelola Variabel Lingkungan

Menyimpan data sensitif, seperti API Key, kredensial basis data, dll., dalam teks biasa menimbulkan risiko keamanan. Siapa pun yang mendapatkan kunci atau kredensial Anda dapat memiliki akses tak terbatas ke aplikasi Anda. Hal ini dapat mengakibatkan kehilangan data dan pencurian data, di antara kemungkinan eksploitasi lainnya.

Merupakan praktik yang baik untuk menyimpan data sensitif dalam variabel lingkungan untuk menghindari situasi seperti ini.

Buat file .env di folder root proyek Anda dan simpan kredensial basis data dan informasi sensitif lainnya di dalam file tersebut.

Sepertinya begitu:

#.env
DB_URI = <YOUR_POSTGRES_DB_URI>
PORT = 8000

Ganti dengan kredensial basis data Anda.

Selanjutnya, buat folder config di folder root proyek Anda, dan di dalam folder config, buat file default.ts dan tambahkan blok kode di bawah ini.

//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;

Blok kode di atas dengan aman mengambil nilai yang tersimpan dalam file .env dan memaparkannya ke seluruh aplikasi Anda.

Langkah 3: Menghubungkan ke Basis Data

Pada langkah ini, Anda akan menghubungkan aplikasi Anda ke database Postgres. Anda akan membutuhkan database untuk menyimpan dan mengambil data untuk aplikasi Anda.

Buat file db.ts di folder src Anda dan tambahkan blok kode di bawah ini ke dalamnya.

//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;

Blok kode di atas mencoba menghubungkan aplikasi Anda ke database Postgres menggunakan URI yang Anda sediakan di file .env.

Langkah 4: Membuat Repositori Basis Data

Buat berkas blogRepository di folder src Anda dan tambahkan kode di bawah ini ke berkas Anda.

//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();

Blok kode di atas akan menangani semua operasi basis data dengan mengabstraksi kueri SQL mentah dan mengekspos metode sederhana yang dapat Anda gunakan untuk berinteraksi dengan basis data Postgres Anda.

Langkah 5: Membuat Penangan Rute

Pada langkah ini, Anda akan membuat penangan rute untuk menangani fungsi CRUD sederhana untuk aplikasi Anda. Rute yang didukung adalah sebagai berikut:

• GET /api/blogs: Mengembalikan semua blog dalam basis data Anda
• GET /api/blog/:id: Mengembalikan satu blog dengan id yang cocok yang disediakan dalam parameter URL.
• POST /api/blog/new: Membuat blog baru di basis data Anda.
• PUT /api/blog/:id: Memperbarui blog dengan id yang cocok yang disediakan dalam parameter URL.
• DELETE /api/blog/:id: Menghapus blog dengan id yang cocok yang disediakan dalam parameter URL.

Buat file router.ts di folder src Anda dan tambahkan impor berikut ini ke dalamnya.

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

Selanjutnya, buatlah instance router dengan menambahkan blok kode di bawah ini:

const router = new Router();

Untuk mendaftarkan penangan router Anda, Anda harus merantainya ke instance router.

Sebagai contoh (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;
  })

Blok kode di atas membuat penangan rute untuk GET /api/blogs dengan merantai logika penangan ke instans router.

Rantai mereka ke metode rantai sebelumnya untuk mendaftarkan rute lainnya. Seperti itu:

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

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

Kemudian, ekspor contoh router Anda. Seperti itu:

export default router;

Terakhir, modifikasi file server.ts Anda untuk membuat basis data blog ketika aplikasi Anda dimulai untuk pertama kalinya.

Sepertinya begitu:

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

Kode yang dimodifikasi menambahkan IIFE yang membuat tabel blog baru dalam database Anda ke file server.ts.

Menerapkan Aplikasi Deno Anda di Wadah Back4app

Untuk menggunakan aplikasi Deno Anda di kontainer Back4app, Anda perlu mengikuti langkah-langkah di bawah ini:

Langkah 1: Membuat file Docker

Dockerfile menyediakan instruksi spesifik untuk membangun citra Docker. Instruksi ini memandu proses membangun citra.

Jalankan perintah di bawah ini untuk membuat Dockerfile:

touch Dockerfile

Perintah di atas membuat sebuah Dockerfile di direktori root proyek Anda.

Selanjutnya, tambahkan blok kode di bawah ini ke Dockerfile Anda:

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"]

Dockerfile di atas menyiapkan lingkungan terkontainerisasi untuk menjalankan aplikasi Deno. Dockerfile ini menyimpan dependensi aplikasi dan titik masuk, lalu menjalankan aplikasi Deno dengan izin yang ditentukan saat kontainer dimulai.

Aplikasi ini diharapkan untuk mendengarkan pada port 8000, meskipun pemetaan port yang sebenarnya harus dilakukan saat menjalankan kontainer.

Terakhir, dorong kode Anda ke GitHub.

Langkah 2: Buat Aplikasi Back4app baru

Untuk membuat aplikasi Back4app, kunjungi situs web resmi Back4app. Sesampainya di sana, cari tombol Daftar di sudut kanan atas halaman arahan Back4app. Anda akan diarahkan ke formulir pendaftaran setelah mengklik tombol Daftar. Lanjutkan untuk mengisi formulir ini dengan detail yang diperlukan, seperti alamat email, nama pengguna, dan kata sandi Anda. Pastikan untuk memberikan informasi yang akurat. Setelah mengisi formulir, kirimkan.

Jika Anda sudah memiliki akun, klik Masuk.

Setelah Anda berhasil mengatur akun Back4app Anda, masuklah untuk mengakses dasbor akun Anda. Dari sana, cari tombol “APLIKASI BARU” dan klik tombol tersebut.

Tindakan ini akan mengarahkan Anda ke halaman di mana Anda akan disajikan dengan berbagai opsi untuk membuat aplikasi baru. Karena tujuan Anda adalah menerapkan menggunakan kontainerisasi, pilihlah opsi“Kontainer sebagai Layanan“.

Selanjutnya, hubungkan akun GitHub Anda ke akun Back4app. Anda dapat memberi Back4app akses ke semua repositori di akun Anda atau repositori tertentu.

Pilih aplikasi yang ingin Anda gunakan, dalam hal ini, aplikasi yang Anda buat dalam tutorial ini, dan klik Pilih.

Mengklik tombol pilih akan membawa Anda ke halaman di mana Anda akan diminta untuk mengisi beberapa informasi tentang aplikasi Anda, seperti nama, cabang, direktori root, opsi penerapan otomatis, port, kesehatan, dan variabel lingkungan.

Pastikan Anda memberikan semua variabel lingkungan yang diperlukan aplikasi Anda agar dapat beroperasi dengan benar. Setelah Anda selesai mengisi informasi yang diperlukan, lanjutkan dengan mengeklik tombol ‘Buat Aplikasi’.

Ini akan memulai proses deployment, dan setelah beberapa saat, deployment Anda akan siap. Jika proses deployment Anda memakan banyak waktu, Anda dapat memeriksa log untuk melihat apakah ada kesalahan yang terjadi pada deployment atau memeriksa panduan pemecahan masalah Back4app.

Kesimpulan

Dalam artikel ini, Anda telah menjelajahi Deno, kelebihan, keterbatasannya, opsi penyebarannya yang populer, cara membuat aplikasi dengan Deno, dan menyebarkan aplikasi Anda menggunakan kontainer Back4app.

Terlepas dari keterbatasannya, karena model keamanannya, Deno dapat menjadi ideal untuk membangun aplikasi yang sangat aman dan sensitif. Selain itu, dukungan TypeScript bawaannya menghilangkan masalah pengaturan TypeScript dalam proyek Anda.

Dengan mengikuti langkah-langkah yang diuraikan dalam artikel ini, Anda dapat dengan mudah membuat dan menggunakan aplikasi Deno di kontainer Back4app.

PERTANYAAN YANG SERING DIAJUKAN