Apa yang dimaksud dengan Infrastruktur Backend?

Bahasa Indonesia

Memilih infrastruktur backend yang tepat sangat penting saat merancang backend Anda. Hal ini dapat memengaruhi kinerja, fleksibilitas, dan kemudahan pemeliharaan backend Anda.

Dalam artikel ini, kami akan menjelaskan apa itu infrastruktur backend, menjelajahi berbagai jenis infrastruktur backend, dan membahas faktor-faktor penting yang perlu diingat saat membuat keputusan.

Selain itu, kita akan melihat cara membuat infrastruktur backend menggunakan Back4app.

Tujuan

Pada akhir artikel ini, Anda akan dapat melakukannya:

Jelaskan apa itu infrastruktur backend
Mendiskusikan berbagai jenis infrastruktur backend (termasuk IaaS, PaaS, dan BaaS)
Pilih infrastruktur backend yang tepat untuk proyek Anda
Bangun backend Anda sendiri menggunakan Back4app

Apa yang dimaksud dengan infrastruktur backend?

Infrastruktur backend adalah kombinasi komponen perangkat lunak dan perangkat keras yang mendukung sistem backend. Ini termasuk server, kontainer, komponen jaringan, firewall, dan sumber daya lainnya.

Infrastruktur backend bertanggung jawab atas ketersediaan tinggi, penskalaan, penyeimbangan beban, keamanan, perutean, dan lain-lain. Infrastruktur backend perlu dirancang sedemikian rupa untuk menawarkan pengalaman pengguna yang mulus.

Apa yang perlu dipertimbangkan saat memilih infrastruktur backend?

Mari kita bahas faktor-faktor penting yang perlu dipertimbangkan saat memilih infrastruktur backend.

Kecepatan

Kecepatan adalah salah satu karakteristik penting dari infrastruktur backend. Pengguna Anda ingin aplikasi bekerja selancar mungkin. Oleh karena itu, Anda perlu mengoptimalkan sisi klien untuk komunikasi backend.

Untuk mengurangi persepsi penundaan komunikasi, Anda dapat menggunakan beberapa trik cerdas. Sebagai contoh, Anda dapat mengimplementasikan layar kerangka, bilah pemuatan, dan menampilkan tips & trik, pada antarmuka pengguna.

Kecepatan juga merupakan salah satu faktor yang paling penting dalam SEO.

Fleksibilitas

Fleksibilitas mengacu pada bahasa pemrograman, kerangka kerja, dan teknologi lain (misalnya, basis data) yang didukung oleh infrastruktur backend Anda. Ketika memilih infrastruktur backend, pastikan untuk memilih sesuatu yang mendukung berbagai teknologi.

Skalabilitas

Anda harus mempertimbangkan skalabilitas sejak Anda mulai membuat aplikasi. Pikirkan bagaimana aplikasi Anda akan digunakan. Apakah Anda akan memiliki jumlah pengguna yang stabil, atau akankah pengguna melonjak kadang-kadang?

Infrastruktur backend Anda perlu dibangun sedemikian rupa untuk mengakomodasi beban kerja yang ekstrem. Untuk meminimalkan biaya server, instance aplikasi Anda harus dibuat dan dihancurkan dengan cepat.

Pemeliharaan

Mengembangkan dan mempublikasikan aplikasi Anda hanya 80% dari pekerjaan. Setelah itu, Anda harus menginvestasikan banyak waktu untuk memelihara aplikasi Anda. Memperbarui perangkat lunak server Anda dan menerapkan patch keamanan harus semudah mungkin.

Pilihlah infrastruktur backend dengan sistem CI/CD bawaan, atau terapkan sistem Anda sendiri.

Persyaratan DevOps

Beberapa jenis infrastruktur backend lebih sulit digunakan. Pilihlah infrastruktur backend yang Anda punya waktu dan sumber daya untuk mengelolanya. Jika Anda memutuskan untuk menggunakan infrastruktur backend tingkat rendah, seperti IaaS, Anda akan membutuhkan tim DevOps khusus untuk mengelolanya.

Keamanan

Anda bertanggung jawab penuh untuk menjaga keamanan data pengguna Anda. Dengan meningkatnya jumlah serangan siber, Anda harus memastikan bahwa infrastruktur backend Anda mengikuti standar keamanan terbaru.

Gunakan kata sandi yang kuat dan dibuat secara otomatis, siapkan firewall, jangan jalankan perangkat lunak yang tidak terpercaya pada server Anda, lakukan pemeriksaan keamanan secara teratur, dan lain-lain.

Jenis-jenis infrastruktur backend

Anda bisa menggunakan server Anda (yang disebut infrastruktur tradisional) atau memanfaatkan infrastruktur cloud untuk menerapkan backend Anda.

Dalam satu dekade terakhir, banyak perusahaan telah beralih ke model cloud karena memungkinkan mereka untuk menghemat waktu dan uang.

Mari kita menganalisis beberapa yang paling populer.

Infrastruktur sebagai Layanan atau IaaS

Infrastructure as a Service (IaaS) adalah model komputasi awan yang paling tidak abstrak. Dalam model ini, vendor cloud menyediakan sumber daya komputasi dalam lingkungan tervirtualisasi, seperti server, penyimpanan, OS, dan komponen jaringan.

IaaS sudah ada sejak 2010 dan masih merupakan model komputasi awan yang paling populer. Kelebihannya meliputi skalabilitas yang tinggi, kontrol tingkat tinggi, dan efisiensi harga. Sebaliknya, kekurangannya adalah manajemen yang kompleks dan biaya pemeliharaan yang lebih tinggi daripada model cloud lainnya.

Platform sebagai Layanan atau PaaS

Platform as a Service (PaaS) adalah model komputasi awan yang menawarkan lingkungan pengembangan, pengelolaan, dan pengiriman aplikasi yang mudah digunakan. Model ini mencakup berbagai alat pengembangan aplikasi bawaan, sehingga memudahkan Anda untuk membuat dan menjalankan aplikasi Anda.

PaaS menyederhanakan manajemen infrastruktur, menyediakan jalan masuk pasar yang lebih cepat, keamanan yang lebih baik, penghematan biaya, skalabilitas, ketersediaan yang tinggi, dan mengurangi pengkodean. Di sisi lain, PaaS dapat mengikat Anda pada kemampuan vendor, menimbulkan risiko penguncian vendor, dan membatasi fleksibilitas dan kontrol.

Backend sebagai Layanan atau BaaS

Backend as a Service (BaaS) mengotomatiskan pengembangan sisi server dan manajemen infrastruktur cloud. Layanan ini menawarkan basis data real-time, manajemen pengguna, autentikasi, notifikasi, integrasi media sosial, dan sebagainya.

BaaS membebaskan pengembang dari kekhawatiran backend, sehingga mereka dapat fokus pada frontend dan bisnis inti. BaaS menggabungkan manfaat IaaS dan PaaS dengan abstraksi backend, sehingga menghasilkan waktu yang lebih cepat ke pasar dan penghematan biaya. Kelemahannya adalah kurangnya kontrol, risiko penguncian vendor, dan relatif mahal.

Wadah sebagai Layanan atau CaaS

Containers as a Service (CaaS) adalah model komputasi awan untuk mengunggah, membangun, menskalakan, dan mengelola kontainer. CaaS biasanya mencakup runtime kontainer, registri kontainer, fungsionalitas penskalaan otomatis, sistem CI/CD bawaan, penyeimbangan beban & banyak lagi!

CaaS menyederhanakan penanganan kontainer, menghilangkan kekhawatiran tentang infrastruktur yang mendasarinya. Ini mendorong pengembangan yang gesit, memfasilitasi arsitektur layanan mikro, dan mempercepat pembuatan aplikasi yang sangat skalabel.

Bagaimana cara membuat infrastruktur backend?

Pada bagian artikel ini, kita akan membuat infrastruktur backend menggunakan Back4app.

Apa itu Back4app?

Back4app adalah platform Backend sebagai Layanan (BaaS) yang luar biasa. Platform ini memungkinkan Anda membangun backend untuk aplikasi web dan seluler dengan cepat.

Platform ini dibangun menggunakan teknologi sumber terbuka dan memiliki banyak fitur. Fitur-fiturnya meliputi basis data seperti spreadsheet, penyimpanan file, manajemen pengguna, autentikasi, API yang dibuat secara otomatis, pemberitahuan, dan masih banyak lagi!

Back4app dapat membantu Anda mempercepat waktu ke pasar secara signifikan. Dengan memanfaatkannya, Anda dapat fokus pada inti bisnis Anda alih-alih mengkhawatirkan backend atau infrastruktur yang mendasarinya.

Anda tidak memerlukan teknisi DevOps khusus, dan biaya pemeliharaan Anda akan lebih rendah.

Hal terbaik dari Back4app adalah ia hadir dengan tingkat gratis. Tingkat gratis sangat bagus untuk menguji platform atau hosting proyek-proyek kecil. Jika aplikasi Anda berhasil, Anda bisa meningkatkan ke tingkat premium.

Untuk mempelajari lebih lanjut tentang Back4app, lihat Apa itu Back4app?

Gambaran Umum Proyek

Untuk menunjukkan cara membuat backend, kita akan membangun layanan backend e-commerce sederhana. Backend akan memungkinkan kita untuk mengelola produk, kategori, dan pesanan.

Diagram ER proyek kita akan terlihat seperti ini:

Kami akan membuat backend dengan sedikit kode dan mendemonstrasikan bagaimana hal ini dapat digunakan di sisi klien (melalui SDK, REST API, dan GraphQL API).

Buat Aplikasi

Untuk mengikutinya, diperlukan akun Back4app. Butuh satu? Daftar sekarang juga!

Setelah masuk ke akun Back4app, Anda akan melihat daftar aplikasi Anda. Klik tombol “Bangun aplikasi” untuk memulai proses pembuatan aplikasi.

Selanjutnya, pilih “BaaS” karena kita sedang menyiapkan backend.

Pilih nama aplikasi, pilih “NoSQL”, dan buat aplikasi.

Back4app akan membutuhkan waktu untuk mengatur semuanya. Ini akan menangani lapisan aplikasi, basis data, cadangan, penskalaan, dan banyak lagi.

Setelah aplikasi selesai dibuat, Anda akan dibawa ke basis data real-time aplikasi Anda.

Menyiapkan Basis Data

Sekarang setelah kita membuat aplikasi, mari kita mengurus database.

Pertama-tama kita harus membuat sebuah kelas untuk menyimpan data dalam database. Anda dapat melihat kelas sebagai tabel (terminologi SQL) atau model (terminologi ORM). Setiap kelas memiliki empat bidang berikut secara default:

+-------------+-------------+------------------------------------------+
| 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                      |
+-------------+-------------+------------------------------------------+

Seperti yang telah disebutkan dalam gambaran umum proyek, proyek kita akan memiliki tiga kelas. Buat yang pertama dengan mengklik tombol “Buat kelas” di bilah sisi. Beri nama ProductCategory:

Tambahkan bidang berikut:

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

Lakukan langkah yang sama untuk kelas Produk:

+-----------------------------+-------------+---------------+----------+
| 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      |
+-----------------------------+-------------+---------------+----------+

Kami menggunakan tipe data Relation untuk menangani hubungan banyak-ke-banyak.

Terakhir, buatlah kelas 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      |
+-----------------------------+------------+---------------+----------+

Kami menggunakan tipe data Pointer untuk menangani hubungan satu-ke-banyak.

Setelah selesai, Anda akan melihat kelas-kelas di bilah samping.

Mengisi basis data

Selanjutnya, mari kita isi database.

Mulailah dengan membuat beberapa kategori produk, produk, dan pesanan (dalam urutan ini). Jika Anda kehabisan ide, jangan ragu untuk mengimpor perlengkapan ini.

Untuk mengimpor file JSON, gunakan “Opsi lainnya > Impor > Data kelas > Pilih file”. Pastikan untuk mengimpor file JSON dengan urutan sebagai berikut:

ProductCategory.json
Product.json
_Bergabung꞉kategori꞉Produk.json
Order.json

Setelah Anda selesai, Anda akan memiliki beberapa produk, kategori, dan pesanan dalam database Anda. Langkah ini diperlukan karena kita akan membutuhkan beberapa data untuk menguji backend pada tahap selanjutnya.

Mengamankan Basis Data

Secara default, kelas database dibuat dalam “mode Terproteksi”. Ketika berada dalam mode terproteksi, satu-satunya cara untuk berinteraksi dan mengelola objek adalah dengan menggunakan kunci master. Hal ini tidak optimal karena kita tidak dapat mengambil atau mengelola objek dari sisi klien.

Untuk dapat melakukan itu, kita harus melonggarkan beberapa pembatasan. Back4app/Parse hadir dengan dua mekanisme pembatasan:

Izin tingkat kelas (CLP)
Izin tingkat akses (ACL)

CLP memungkinkan kita untuk memberlakukan pembatasan pada tingkat kelas, sementara ACL memungkinkan kita untuk memberlakukan pembatasan pada tingkat objek. Kedua mekanisme ini dapat membatasi kelas atau objek ke Role atau Pengguna tertentu.

Pilih Kelas produk pada bilah sisi, dan klik teks “Dilindungi” di bagian atas layar. Kemudian modifikasi CLP:

Lakukan langkah yang sama untuk model ProductCategory.

Kemudian perbarui CLP untuk kelas Order:

Perhatikan gambarnya. Di sini, kami juga mengaktifkan izin Buat.

CLP baru akan memungkinkan pengguna yang tidak terautentikasi untuk mengambil, meminta, dan menghitung Produk, dan ProductCategories, tetapi tidak dapat memodifikasinya. Hal yang sama berlaku untuk kelas Order, tetapi di sini, pengguna juga dapat membuat order baru.

Untuk mempelajari lebih lanjut, lihat artikel Keamanan Server Parse kami.

Aplikasi Admin

Saat ini, satu-satunya cara untuk mengelola objek dalam database Anda adalah dengan menggunakan tampilan database. Meskipun cara ini berfungsi untuk pengembang, namun tidak intuitif bagi pengguna non-teknologi. Selain itu, hal ini memberikan terlalu banyak kontrol kepada pengguna dan rentan terhadap kesalahan manusia.

Untungnya, Back4app memungkinkan Anda dengan mudah mengaktifkan fungsionalitas “Aplikasi Admin”. Aplikasi Admin adalah panel administrasi yang mudah digunakan yang disesuaikan dengan kelas basis data Anda.

Aktifkan dengan terlebih dahulu menavigasi ke “Lainnya > Aplikasi Admin” pada bilah sisi. Kemudian klik “Aktifkan”:

Back4app akan meminta Anda untuk memilih nama pengguna, kata sandi, dan subdomain. Saya memutuskan untuk memilih yang berikut ini:

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

Bagus, hanya itu yang harus Anda lakukan.

Anda dapat mengakses panel administrasi dengan mengklik “URL Aplikasi Admin”. Jendela browser baru akan terbuka dengan mengekliknya, dan Anda akan diminta untuk memasukkan kredensial admin Anda. Setelah masuk, Anda dapat membuat, memperbarui, dan menghapus objek.

Cobalah bermain-main dengan dasbor untuk membiasakan diri.

Kode Cloud

Back4app memungkinkan Anda untuk menjalankan kode JavaScript khusus melalui apa yang disebut Cloud Code. Dengan Cloud Code, Anda dapat mendefinisikan fungsi yang dapat dipicu oleh Parse, permintaan HTTP, atau dijalankan secara berkala. Selain itu, Cloud Code dapat digunakan untuk membangun aplikasi web menggunakan Express.

Fungsi Kode Cloud

Misalkan kita menginginkan fungsi Cloud Code yang menghitung penjualan saat ini.

Pertama, buka “Cloud Code > Function & Web Hosting” pada bilah sisi. Anda akan melihat bahwa tampilan Cloud Code terbagi menjadi dua bagian. Di sisi kiri, Anda dapat melihat struktur direktori dan kode di sisi kanan.

Selanjutnya, buka cloud/main.js dan tempelkan kode berikut:

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

Kami mendefinisikan fungsi Cloud Code yang disebut calculateSales(). Fungsi ini mengulang semua pesanan, mengambil produk yang sesuai, dan menjumlahkan harganya.
Kami mendefinisikan Cloud Code Job bernama printSales(), yang memungkinkan kami menjalankan fungsi dari dasbor Parse dan menjadwalkannya secara berkala.

Terakhir, klik “Deploy” untuk menerapkan Cloud Code.

Pastikan pekerjaan berjalan dengan menavigasi ke “Cloud Code > Jobs” pada sidebar dan kemudian jalankan pekerjaan printSales(). Jika semuanya berjalan dengan baik, Anda akan melihat pesan yang mengatakan, misalnya, Sales: 1440$ saat memeriksa log.

Penjadwalan Kode Cloud

Untuk menjadwalkan pekerjaan, Anda harus menavigasi ke “Pengaturan Aplikasi > Pengaturan Server” di bilah sisi. Gulir ke bawah ke “Pekerjaan latar belakang”, klik “Jadwalkan pekerjaan”, dan isi formulir.

Untuk memastikannya berfungsi, periksa log sekali lagi.

Sisi Klien

Ada beberapa cara untuk berinteraksi dengan backend berbasis Back4app Anda:

Mengurai SDK
API RESTful (dibuat secara otomatis)
API GraphQL (dibuat secara otomatis)

Sebagai aturan praktis, Anda harus selalu menggunakan Parse SDK jika tersedia untuk platform Anda. Jika tidak, gunakan RESTful API atau GraphQL API. Pilihan di antara API tergantung pada data Anda.

Pelajari cara menggunakan Parse SDK dengan berbagai framework dengan melihat dokumen.

Namun demikian, mari kita uji backend kita menggunakan REST Console bawaan.

Navigasikan ke “API > REST” pada bilah samping, dan coba lakukan kueri untuk semua produk dengan mengisi formulir:

Anda akan mendapatkan respons yang serupa:

{
    "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"
            }
        },
    // ...
}

Coba lakukan kueri berikut ini:

Ambil semua produk yang lebih mahal dari 50
Mengambil semua pesanan yang belum terkirim
Buat produk baru dan tambahkan kategori ke produk tersebut
Menghapus pesanan

Kesimpulan

Kesimpulannya, Anda sekarang mengetahui apa itu infrastruktur backend, mengenal berbagai jenis infrastruktur backend, dan mengetahui cara memilih infrastruktur yang tepat untuk proyek Anda.

Selain itu, Anda telah mempelajari cara membuat infrastruktur backend di Back4app. Anda telah menangani basis data, keamanan basis data, kode kustom, penjadwalan pekerjaan, dan pengujian API.

Untuk panduan membuat sisi klien untuk backend berbasis Back4app, jelajahi artikel kami yang lain:

Sumber artikel tambahan bersumber terbuka di repositori GitHub.