Bagaimana Cara Menerapkan Aplikasi Web Node.js?

Node.js adalah lingkungan runtime JavaScript yang memungkinkan Anda menjalankan kode JavaScript di luar browser.

Node.js dibangun di atas mesin JavaScript Chrome V8 dan memiliki fitur model I/O non-blocking yang digerakkan oleh peristiwa yang membuatnya sangat efisien untuk membangun aplikasi sisi server.

Pada artikel ini, Anda akan menjelajahi keunggulan dan keterbatasan Node.js untuk pengembangan aplikasi sisi server dan opsi penyebaran untuk aplikasi Node.js.

Selain itu, Anda akan membangun, melakukan dockerisasi, dan menggunakan aplikasi Node.js ke Back4app Container secara gratis.

Keuntungan Node.js untuk Pengembangan Aplikasi Web

Sejak Node.js dirilis pada tahun 2009, Node.js telah menjadi pilihan utama untuk membangun aplikasi web sisi server. Berikut adalah beberapa alasannya.

Efisiensi dan Skalabilitas

Seperti yang telah disebutkan sebelumnya, Node.js berjalan pada mesin V8 Chrome, yang memungkinkannya untuk menjalankan kode JavaScript. Mesin ini menggunakan kompilasi Just-in-time (JIT) untuk mengonversi kode JavaScript asli ke kode mesin.

Pada saat runtime, komponen Turbofan dan Crankshaft V8 menganalisis kode mesin dan mengkompilasinya kembali untuk memberikan performa terbaik.

Selain itu, karena model Node.js yang digerakkan oleh peristiwa, Node.js dapat mengeksekusi kode sebagai respons terhadap peristiwa, seperti interaksi pengguna, tanpa memblokir utas utama aplikasi, sehingga ideal untuk aplikasi dengan lalu lintas yang besar.

Arsitektur modular Node.js dan dukungan bawaan untuk pengelompokan membuat aplikasi yang dikembangkan dengannya mudah untuk diskalakan. Arsitektur modularnya memungkinkan Anda untuk memecah aplikasi Anda menjadi beberapa bagian komponen yang dapat diskalakan secara independen.

Sementara modul cluster memungkinkan Anda untuk menelurkan beberapa contoh aplikasi Anda di beberapa core atau server. Hal ini memungkinkan penskalaan horizontal, di mana aplikasi dapat diskalakan dengan menambahkan lebih banyak server ke dalam cluster.

Kurva Pembelajaran Dangkal

Node.js didasarkan pada JavaScript, bahasa pemrograman yang banyak digunakan untuk pengembangan web. Penggunaan JavaScript di Node.js telah membuat pengembangan sisi server dengan Node.js lebih mudah diakses oleh para pengembang yang sudah terbiasa dengan JavaScript.

Hal ini mengurangi kerumitan pengembangan web dan merampingkan proses pengembangan.

Ekosistem Besar

Node.js memiliki komunitas pengembang yang besar dan aktif yang telah menciptakan ekosistem modul dan paket yang luas.

Manajer paket Node.js, npm, memiliki lebih dari satu juta paket yang dapat Anda gunakan untuk menambahkan fungsionalitas ke aplikasi mereka.

Paket-paket ini dapat berkisar dari pustaka utilitas kecil seperti lodash hingga kerangka kerja besar Nest.js yang dapat digunakan untuk membangun aplikasi web yang kompleks.

Ketersediaan berbagai macam modul dan paket dapat secara signifikan mengurangi waktu dan upaya yang diperlukan untuk mengembangkan aplikasi web.

Anda bisa memanfaatkan paket-paket ini untuk menambahkan fitur-fitur seperti autentikasi, integrasi basis data, dan rendering sisi server pada aplikasi Anda.

Keterbatasan Node.js untuk Pengembangan Aplikasi Web

Dalam hal pengembangan aplikasi web, Node.js menawarkan banyak manfaat, seperti kinerja yang efisien, skalabilitas, dan ekosistem modul dan paket yang luas. Namun, seperti teknologi apa pun, Node.js memiliki beberapa keterbatasan. Beberapa keterbatasannya antara lain sebagai berikut.

Konsumsi Memori Besar

Node.js menggunakan model I/O non-blocking, yang berarti dapat menangani banyak permintaan secara bersamaan tanpa membuat utas baru. Namun, setiap permintaan masih membutuhkan memori yang dialokasikan untuk pemrosesannya.

Ini berarti bahwa aplikasi Node.js dapat menghabiskan banyak memori, terutama jika aplikasi tersebut menangani banyak permintaan secara bersamaan. Hal ini dapat menjadi masalah bagi aplikasi yang berjalan pada sistem dengan memori terbatas.

Model Pemrograman Asinkron

Meskipun model pemrograman asinkron Node.js merupakan keuntungan yang signifikan, namun juga dapat menjadi sumber kerumitan bagi para pengembang.

Pemrograman asinkron membutuhkan cara berpikir yang berbeda tentang alur program. Pergeseran ini dapat menjadi tantangan bagi pengembang yang terbiasa dengan pemrograman sinkron.

Selain itu, pemrograman asinkron dapat menyebabkan neraka callback, sebuah situasi di mana kode menjadi sulit untuk dibaca dan dipelihara karena adanya callback yang bertumpuk.

Lingkaran Peristiwa berulir tunggal

Node.js dirancang untuk menangani tugas-tugas intensif I/O, seperti komunikasi jaringan, I/O file, dan operasi basis data.

Namun, ini mungkin bukan pilihan terbaik untuk tugas-tugas yang memerlukan CPU intensif seperti penghitungan yang rumit, pemrosesan data, atau pembelajaran mesin.

Hal ini karena Node.js menggunakan model event loop berulir tunggal, yang berarti hanya dapat mengeksekusi satu tugas dalam satu waktu.

Jika sebuah tugas membutuhkan waktu lama untuk diselesaikan, tugas tersebut dapat memblokir event loop dan membuat aplikasi tidak responsif.

Menerapkan Aplikasi Web Node.js

Ada beberapa cara untuk menerapkan aplikasi Node.js. Mari kita jelajahi beberapa di antaranya.

Layanan Cloud Hosting

Layanan cloud hosting memungkinkan Anda menerapkan aplikasi Node.js Anda pada server yang dikelola oleh perusahaan seperti Amazon Web Services (AWS), Google Cloud Platform (GCP), atau Microsoft Azure.

Mereka menawarkan manfaat seperti skalabilitas, ketersediaan global, penerapan yang mudah, dan harga bayar sesuai penggunaan. Selain itu, mereka berintegrasi dengan layanan cloud lainnya seperti basis data dan penyeimbangan beban untuk membantu Anda membangun aplikasi yang lebih baik.

Anda cukup men-deploy aplikasi Node.js Anda ke server penyedia cloud untuk menggunakan layanan cloud hosting. Kemudian, Anda dapat mengakses aplikasi Anda melalui peramban web atau aplikasi klien lainnya.

Beberapa contoh layanan hosting awan untuk Node.js meliputi:

• AWS Elastic Beanstalk
• GCP App Engine
• Microsoft Azure App Service

Platform-platform ini memudahkan Anda untuk menyebarkan, menskalakan, dan mengelola aplikasi Node.js Anda tanpa perlu mengkhawatirkan infrastruktur yang mendasarinya.

Ditambah lagi, mereka menawarkan fitur-fitur seperti penskalaan otomatis, penyeimbangan beban, dan pemantauan bawaan untuk membantu Anda menjaga aplikasi Anda tetap berjalan dengan lancar.

Server Pribadi Virtual (VPS)

Virtual Private Server (VPS) adalah mesin virtual yang berjalan pada server fisik, memungkinkan Anda untuk menginstal dan menjalankan aplikasi Node.js seolah-olah berjalan pada server khusus.

Server pribadi virtual memberi Anda kontrol dan opsi penyesuaian yang lebih besar daripada hosting bersama, sekaligus memberikan alternatif yang lebih hemat biaya daripada server khusus.

Untuk menggunakan hosting VPS untuk aplikasi Node.js Anda, pilih penyedia hosting yang menawarkan gambar Node.js yang sudah dikonfigurasi sebelumnya atau instal Node.js dan dependensi lainnya sendiri.

Beberapa contoh penyedia hosting VPS untuk Node.js meliputi:

• DigitalOcean
• Linode
• Vultr

Kontainerisasi

Kontainerisasi adalah teknik untuk menyebarkan dan menjalankan aplikasi dalam lingkungan kontainer yang mengisolasi mereka dari infrastruktur yang mendasarinya.

Kontainer menyediakan alternatif yang ringan dan fleksibel untuk mesin virtual tradisional, sehingga ideal untuk men-deploy aplikasi Node.js.

Mereka portabel, memungkinkan Anda untuk membangun dan menguji aplikasi pada mesin lokal mereka dan kemudian menyebarkannya ke platform apa pun yang mendukung kontainerisasi.

Kontainer juga dapat dengan mudah ditingkatkan atau diturunkan tergantung pada beban kerja, sehingga meningkatkan skalabilitas. Mereka memberikan konsistensi di berbagai platform, membuat pengelolaan dan pemeliharaan aplikasi menjadi lebih mudah.

Beberapa contoh platform yang menawarkan Containerization as a Service (CaaS) meliputi:

• Back4app Containers
• AWS ECS
• Azure ACI
• Google GKE

Menerapkan Aplikasi Node.js di Back4app menggunakan Kontainer Back4app

Back4app adalah sebuah platform cloud yang memungkinkan Anda untuk membuat, mengelola, dan menerapkan aplikasi web menggunakan UI yang intuitif atau alat CLI berfitur lengkap. Back4app menawarkan berbagai layanan, salah satunya adalah kontainerisasi.

Kontainer Back4app menghilangkan kesenjangan antara pengembangan dan produksi dengan mengotomatiskan tugas-tugas yang berulang dan mengelola infrastruktur sisi server Anda, memastikan Anda tidak perlu khawatir tentang DevOps.

Pada artikel ini, Anda akan membangun dan menggunakan aplikasi Node.js sederhana menggunakan kontainer Back4app. Aplikasi Node.js yang akan Anda buat adalah API toko buku sederhana dengan dukungan fungsionalitas CRUD (Create, Read, Update, Delete).

Menyiapkan Lingkungan Pengembangan Anda

Buat direktori proyek baru dan inisialisasi npm di direktori proyek dengan menjalankan perintah di bawah ini:

mkdir bookstoreapp && cd bookstoreapp && npm init -y

Selanjutnya, instal dependensi yang diperlukan untuk proyek dengan menjalankan perintah di bawah ini:

npm install express dotenv mysql knex

Ketergantungan yang Anda instal di atas adalah:

• Express.js: Express adalah kerangka kerja Node.js yang menyederhanakan proses pengembangan aplikasi Node.js.
• dotenv: dotenv adalah paket npm yang dapat Anda gunakan untuk mengelola variabel lingkungan Anda.
• MySQL: Ketergantungan MySQL adalah driver Node.js untuk MySQL, yang akan Anda gunakan sebagai basis data untuk aplikasi ini.
• Knex: Knex adalah pembuat kueri untuk JavaScript. Anda akan membutuhkan ketergantungan ini untuk berinteraksi dengan basis data Anda tanpa menulis kueri SQL mentah.

Selanjutnya, buatlah file routes.js dan index.js di direktori root proyek Anda.

Kemudian, tambahkan blok kode di bawah ini ke berkas index.js Anda:

//index.js
require("dotenv").config();
const express = require("express");
const app = express();
const port = 3000;
const router = require("./routes.js");

app.use(express.json());
app.use(express.urlencoded({ extended: true }));
app.use("/", router);

app.listen(port, () => {
  console.log(`App listening at ${port}`);
});

Blok kode di atas membuat server Express dan mendengarkan permintaan HTTP yang masuk pada port 3000. Ini menggunakan fungsi middleware untuk mengurai data yang masuk dan mengaitkan router dengan jalur root untuk menangani permintaan yang masuk.

Terakhir, memulai server dan mencatat pesan ke konsol yang mengindikasikan bahwa server sedang berjalan dan mendengarkan pada port yang ditentukan.

Selanjutnya, tambahkan skrip awal ke berkas package.json Anda. Seperti ini:

"start": "node index.js",

Menghubungkan ke Basis Data Anda

Knex membutuhkan file knex yang berisi opsi konfigurasi untuk menghubungkan ke database.

Jalankan perintah di bawah ini untuk membuat knexfile:

knex init

Untuk mengonfigurasi Knex agar menggunakan MySQL, ganti isi file knexfile.js Anda dengan blok kode di bawah ini:

// Update with your config settings.

require("dotenv").config()

/**
 * @type { Object.<string, import("knex").Knex.Config> }
 */
module.exports = {
  development: {
    client: "mysql",
    connection: {
      host: process.env.DEV_HOST,
      user: process.env.DEV_USER,
      password: process.env.DEV_PASSWORD,
      database: process.env.DEV_NAME,
    },
    migrations: {
      directory: "./db/migrations",
    }
  },
  production: {
    client: "mysql",
    connection: {
      host: process.env.DB_HOST,
      user: process.env.DB_USER,
      password: process.env.DB_PASSWORD,
      database: process.env.DB_NAME,
    },
    migrations: {
      directory: "./db/migrations",
    }
  },
};

Selanjutnya, buat folder db di direktori root proyek Anda dan buat file db.js.

Tambahkan blok kode di bawah ini ke file db.js Anda:

//db.js

const knex = require("knex");
const knexFile = require("../knexfile.js");

const environment = process.env.NODE_ENV || "development";

module.exports = knex(knexFile[environment]);

Blok kode di atas menetapkan variabel lingkungan ke variabel lingkungan NODE_ENV atau pengembangan jika NODE_ENV tidak ditetapkan. Dengan demikian, Anda dapat menentukan konfigurasi yang berbeda untuk lingkungan yang berbeda, seperti pengembangan atau produksi.

Membuat File Migrasi

Jalankan perintah di bawah ini untuk membuat file migrasi untuk database Anda:

knex migrate:make bookstore

Perintah di atas membuat berkas migrasi di jalur berkas yang ditentukan knexfile.js Anda (“./db/migrations”).

Selanjutnya, buka file migrasi Anda dan ganti kode di dalamnya dengan blok kode di bawah ini:

/**
 * @param { import("knex").Knex } knex
 * @returns { Promise<void> }
 */
exports.up = function (knex) {
  return knex.schema.createTable("books", (table) => {
    table.increments("id").primary();
    table.string("title");
    table.string("author");
    table.string("genre");
    table.timestamps(true, true);
  });
};

/**
 * @param { import("knex").Knex } knex
 * @returns { Promise<void> }
 */
exports.down = function (knex) {
  return knex.schema.dropTableIfExists("books");
};

Kemudian, jalankan perintah di bawah ini untuk menjalankan file migrasi:

knex migrate:latest

Menerapkan Perutean

Terakhir, tambahkan blok kode di bawah ini ke file routes.js Anda:

const express = require("express");
const router = express.Router();
const db = require("./db/db.js");

// GET /books
router.get("/books", async (req, res) => {
  try {
    const books = await db("books");
    res.json(books);
  } catch (err) {
    console.error(err);
    res.status(500).send("Internal Server Error");
  }
});

//POST /books/new
router.post("/books/new", async (req, res) => {
  try {
    const { title, author, genre } = req.body;
    const book = await db("books").insert({
      title,
      author,
      genre,
    });
    res.status(201).json(book);
  } catch (err) {
    console.error(err);
    res.status(500).send("Internal Server Error");
  }
});

//PUT /books/:id
router.put("/books/:id", async (req, res) => {
  const { id } = req.params;

  try {
    const { title, author, genre } = req.body;
    const book = await db("books").where({ id }).update(
      {
        title,
        author,
        genre,
      },
      ["id", "title", "author", "genre"]
    );

    if (book.length !== 0) {
      res.status(201).send(book);
    } else {
      res.status(404).json({ error: "Book not found" });
    }
  } catch (err) {
    console.error(err);
    res.status(500).send("Internal Server Error");
  }
});

//DELETE /books/:id
router.delete("/books/:id", async (req, res) => {
  const { id } = req.params;

  try {
    const book = await db("books").where({ id }).del();

    if (book !== 0) {
      res.status(200).json({ message: "Book deleted" });
    } else {
      res.status(404).json({ error: "Book not found" });
    }
  } catch (err) {
    console.error(err);
    res.status(500).send("Internal Server Error");
  }
});

module.exports = router;

Blok kode di atas mendefinisikan beberapa rute untuk menangani permintaan HTTP, termasuk mendapatkan semua buku, membuat buku baru, memperbarui buku yang sudah ada, dan menghapus buku.

Membuat berkas Docker

Dockerfile adalah berkas yang berisi sekumpulan instruksi, yang ditulis dalam format tertentu, tentang cara membangun citra Docker. Citra Docker adalah cuplikan kontainer yang mencakup segala sesuatu yang dibutuhkan untuk menjalankan aplikasi, seperti kode aplikasi, runtime, pustaka, dan alat sistem.

Untuk menjalankan aplikasi Node.js di Kontainer Back4app, Anda harus membuat berkas Docker yang berisi instruksi untuk membangun citra Docker.

Jalankan perintah di bawah ini untuk membuat Dockerfile:

touch Dockerfile

Selanjutnya, Anda harus memilih citra dasar untuk aplikasi Node.js Anda. Citra dasar di Docker adalah titik awal untuk membangun citra Docker baru. Citra dasar merupakan fondasi di mana citra Docker Anda dibangun.

Tambahkan blok kode di bawah ini ke Dockerfile Anda untuk menentukan citra dasar Anda:

# Specify base image
FROM node:18-alpine

Baris ini menentukan citra dasar tempat citra Docker ini akan dibangun. Dalam kasus ini, versi Node.js 18 berjalan pada distribusi Linux Alpine.

Selanjutnya, Anda perlu menentukan direktori kerja Anda. Semua perintah berikutnya dalam Dockerfile akan dieksekusi secara relatif ke direktori ini.

Tambahkan blok kode di bawah ini ke Dockerfile Anda untuk menentukan direktori kerja Anda:

# Specify working directory
WORKDIR /app

Kemudian, Anda perlu menyalin berkas package.json dan package-lock.json dari direktori saat ini (yaitu, direktori yang berisi Dockerfile) ke direktori kerja(/app).

Tambahkan blok kode di bawah ini ke Dockerfile Anda untuk menyalin berkas:

# Copy package.json and package-lock.json
COPY package*.json ./

Selanjutnya, Anda perlu menjalankan perintah install npm di direktori kerja untuk menginstal dependensi Node.js yang terdaftar di package.json dan package-lock.json.

Tambahkan kode di bawah ini ke Dockerfile Anda untuk menginstal dependensi:

# Install dependencies
RUN npm install

Perintah di atas akan menginstal semua dependensi yang tercantum dalam berkas package.json ****dan package-lock.json Anda dan menyimpannya dalam folder node_modules di direktori kerja yang ditentukan.

Selanjutnya, Anda perlu menyalin kode sumber aplikasi Anda ke dalam direktori kerja Anda.

Tambahkan blok kode di bawah ini ke Dockerfile Anda untuk menyalin kode sumber:

# Copy source code
COPY . .

Selanjutnya, Anda perlu mengekspos sebuah porta ke mesin host. Mengekspos port memungkinkan kontainer Docker menerima koneksi jaringan yang masuk pada port yang diekspos saat Anda menjalankannya.

Tambahkan blok kode di bawah ini ke Dockerfile Anda untuk mengekspos porta 3000 ke mesin hos:

# Expose port 3000
EXPOSE 3000

Terakhir, Anda perlu menentukan perintah yang harus dijalankan ketika kontainer Docker dimulai. Biasanya, aplikasi Node.js dimulai menggunakan perintah npm start.

Tambahkan blok kode di bawah ini ke Dockerfile Anda untuk menentukan perintah:

# Run the app
CMD ["npm", "start"]

Dockerfile Anda yang sudah jadi akan terlihat seperti blok kode di bawah ini:

# Specify base image
FROM node:18-alpine

# Specify working directory
WORKDIR /app

# Copy package.json and package-lock.json
COPY package*.json ./

# Install dependencies
RUN npm install

# Copy source code
COPY . .

# Expose port 3000
EXPOSE 3000

# Run the app
CMD ["npm", "start"]

Setelah membuat berkas Docker Anda, dorong kode Anda ke GitHub.

Membuat Aplikasi Back4app baru

Langkah pertama untuk men-deploy aplikasi Node.js di Back4app adalah membuat akun di Back4app (jika Anda belum memilikinya). Anda dapat membuatnya dengan mengikuti langkah-langkah di bawah ini.

1. Buka situs web Back4app.
2. Selanjutnya, klik tombol Daftar di sudut kanan atas halaman arahan.
3. Terakhir, isi formulir pendaftaran dan kirimkan.

Setelah berhasil membuat akun Back4app Anda, masuk ke akun Back4app Anda dan klik tombol APLIKASI BARU di pojok kanan atas.

Mengklik tombol ini akan membawa Anda ke halaman di mana Anda memilih “Bagaimana Anda ingin membuat aplikasi baru?”. Karena Anda menerapkan menggunakan kontainerisasi, pilihlah Containers as a Service, seperti yang ditunjukkan pada gambar di bawah ini.

Selanjutnya, hubungkan akun GitHub Anda ke akun Back4app. Anda dapat memilih untuk memberikan Back4app akses ke semua repositori di akun Anda atau ke 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, dan variabel lingkungan.

Pastikan untuk mengisi semua variabel lingkungan yang dibutuhkan aplikasi Anda agar dapat berfungsi. Setelah Anda mengisi detail yang diperlukan, klik Buat Aplikasi, seperti yang ditunjukkan pada gambar di bawah ini.

Mengklik tombol Buat Aplikasi akan memulai proses penerapan. Setelah proses penyebaran selesai, URL tempat aplikasi yang telah disebarkan dapat diakses akan ditentukan di sudut kiri layar, seperti yang ditunjukkan pada gambar di bawah ini.

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

Node.js adalah framework populer yang menawarkan banyak keuntungan, seperti performa yang cepat, skalabilitas, dan fleksibilitas. Namun, Node.js juga memiliki beberapa keterbatasan, seperti sifatnya yang berulir tunggal, yang dapat membuatnya sulit untuk menangani beban kerja yang berat.

Terlepas dari keterbatasan ini, beberapa opsi penyebaran tersedia untuk aplikasi Node.js, termasuk Back4app, yang menyediakan platform yang andal dan mudah digunakan untuk menghosting dan mengelola aplikasi Node.js.

Dengan membuat aplikasi Node.js dan mengikuti langkah-langkah yang diuraikan dalam artikel ini, Anda dapat dengan mudah menggunakan aplikasi Node.js Anda di Back4app dan memanfaatkan banyak manfaatnya.

Masih tertarik dengan penerapan dan hosting Node.js? Silakan lihat dua tutorial ini:

• Cara meng-host aplikasi Node.js menggunakan CaaS – Container as a Service

• Cara menggunakan aplikasi Node.js menggunakan BaaS – Backend as a Service

PERTANYAAN YANG SERING DIAJUKAN