Apa yang dimaksud dengan Fungsi Tanpa Server?

Pada artikel ini, kita akan membahas tentang komputasi tanpa server, berbagai arsitektur perangkat lunak, fungsi-fungsi tanpa server, manfaatnya, dan kasus penggunaannya. Di bagian kedua artikel ini, kita akan mempelajari cara membangun backend tanpa server di Back4app menggunakan fungsi Cloud Code.

Apa yang dimaksud dengan fungsi tanpa server?

Fungsi tanpa server adalah bagian kode yang digerakkan oleh peristiwa yang melayani satu tujuan. Fungsi ini dapat dipicu oleh peristiwa tertentu seperti permintaan HTTP, perubahan basis data, atau pesan lainnya. Fungsi-fungsi ini ditulis oleh pengembang perangkat lunak dan kemudian disebarkan ke cloud. Penyedia cloud kemudian mengelola infrastruktur, keamanan, menjalankan kode, dan secara otomatis menskalakan sumber daya berdasarkan permintaan.

Fungsi tanpa server sering disalahartikan sebagai komputasi tanpa server. Meskipun kedua istilah ini terkait satu sama lain, keduanya tidak dapat digunakan secara bergantian. Komputasi tanpa server adalah model komputasi awan di mana penyedia awan mengelola infrastruktur yang diperlukan untuk menjalankan aplikasi, sedangkan fungsi tanpa server adalah jenis komputasi tanpa server yang memungkinkan pengembang untuk dengan mudah menjalankan dan menggunakan potongan kecil kode di awan.

Bagaimana cara kerja fungsi tanpa server?

Sebagian besar aplikasi modern dibagi menjadi dua bagian: bagian depan dan bagian belakang. Frontend adalah apa yang dilihat pengguna dan dapat berinteraksi dengannya, sedangkan backend adalah segala sesuatu yang tidak dapat dilihat oleh pengguna. Ini termasuk logika bisnis, penyimpanan data, basis data, API, dan sebagainya.

Fungsi tanpa server menyederhanakan komponen backend aplikasi perangkat lunak, membagi backend menjadi beberapa fungsi tujuan tunggal yang dapat digunakan kembali. Fungsi-fungsi ini nantinya dapat dihubungkan untuk melakukan tugas-tugas yang kompleks.

Cara termudah untuk memahami fungsi-fungsi tanpa server adalah dengan melihat contoh dunia nyata. Misalkan kita memiliki toko e-commerce di mana pengguna dapat melihat produk, menambahkan produk ke troli, menghapus produk dari troli, dan melakukan pembayaran.

Backend tanpa server kami kemungkinan besar akan mencakup fungsi-fungsi berikut:

getProductList()                       -> retrieves the products from the database
getProduct(productId)                  -> retrieves a specific product from the database
getCart(user)                          -> returns the products in the user's cart
addToCart(user, productId)             -> adds a product to the user's cart
removeFromCart(user, productId)        -> removes the product from the user's cart
clearCart(user)                        -> clears user's cart

Dan kemudian kami juga akan memiliki fungsi yang lebih kompleks yang memanfaatkan fungsi tanpa server lainnya:

checkout()
    cart = getCart(user)
    finalizeCheckout(user, cart)       -> deducts money from user's account
    clearCart(user)
    sendConfirmationEmail(user, cart)  -> sends a confirmation email to the user

Oke, tetapi bagaimana cara kerja fungsi tanpa server di balik tenda?

Di balik tenda, fungsi tanpa server bekerja dengan memanfaatkan teknologi kontainerisasi, yang melibatkan pengemasan kode ke dalam wadah yang ringan dan terisolasi yang dapat dengan mudah digunakan dan diskalakan sesuai permintaan. Ketika fungsi tanpa server dipicu, penyedia cloud membuat instance baru dari kontainer, menjalankan kode di dalamnya, dan kemudian menutup kontainer ketika kode selesai dieksekusi.

Penyedia cloud biasanya menangani semua aspek pengelolaan infrastruktur yang mendasarinya, termasuk penskalaan, penyeimbangan beban, dan alokasi sumber daya, sehingga pengembang tidak perlu khawatir tentang mengonfigurasi atau mengelola server. Sebaliknya, pengembang cukup menulis kode, mengunggahnya ke penyedia cloud, dan menentukan kondisi pemicu kapan kode tersebut harus dijalankan.

Apa saja arsitektur perangkat lunak yang berbeda?

Selain fungsi tanpa server, kami juga memiliki arsitektur monolitik dan arsitektur layanan mikro. Mari kita lihat keduanya.

Arsitektur Monolitik

Dalam arsitektur monolitik, aplikasi dibangun sebagai satu kesatuan dengan semua komponen yang terintegrasi erat. Semua fungsi digabungkan ke dalam satu basis kode, dan aplikasi digunakan sebagai satu paket. Arsitektur monolitik mudah dibangun dan dipelihara, tetapi dapat menjadi kompleks dan sulit untuk ditingkatkan seiring dengan pertumbuhan aplikasi.

Arsitektur Layanan Mikro

Arsitektur layanan mikro adalah pendekatan untuk membangun aplikasi perangkat lunak sebagai kumpulan layanan kecil dan independen yang berkomunikasi satu sama lain melalui API. Setiap layanan mikro bertanggung jawab atas fungsi tertentu dari aplikasi dan dapat dikembangkan, digunakan, dan diskalakan secara independen. Pendekatan ini memungkinkan fleksibilitas, skalabilitas, dan ketahanan yang lebih besar, tetapi juga dapat menimbulkan kompleksitas dalam hal komunikasi dan manajemen layanan.

Kesimpulannya, aplikasi monolitik paling cocok untuk proyek-proyek yang lebih sederhana yang tidak perlu banyak diskalakan. Di sisi lain, layanan mikro dan tanpa server umumnya lebih sesuai untuk proyek yang lebih kompleks yang harus sangat terukur dan fleksibel. Selain semua keuntungan dari layanan mikro, arsitektur tanpa server juga mengabstraksikan manajemen infrastruktur. Oleh karena itu, Anda dapat menghemat banyak waktu dan uang.

Apa saja manfaat dari fungsi tanpa server?

Fungsi sebagai Layanan (FaaS) hadir dengan banyak manfaat.

Pengembangan lebih cepat

Fungsi tanpa server memungkinkan pengembangan dan penerapan yang lebih cepat karena tidak perlu mengelola infrastruktur, mengonfigurasi server, mengatur penskalaan, atau mengelola server. Karena fungsi tanpa server adalah potongan-potongan kecil kode yang melayani satu tujuan, fungsi ini dapat dengan mudah diuji dan di-debug. Yang terbaik dari semuanya, fungsi tanpa server dapat dengan mudah diintegrasikan dengan layanan cloud lain atau API pihak ketiga untuk mengatasi banyak masalah umum.

Skalabilitas & ketersediaan yang tinggi

Fungsi tanpa server dapat menangani sejumlah besar permintaan dan menskalakan secara otomatis berdasarkan permintaan. Hal ini memastikan bahwa aplikasi dapat mengakomodasi tingkat lalu lintas apa pun. Selain itu, jika tidak ada yang menggunakan layanan Anda, lingkungan bisa menjadi nol, sehingga menghemat banyak uang.

Anda juga dapat menggunakan Functions-as-a-Service (FaaS) Anda ke beberapa zona. Hal ini dapat membantu Anda meningkatkan ketersediaan aplikasi Anda dengan mendistribusikan fungsi-fungsi Anda ke seluruh dunia.

Fleksibilitas yang lebih besar

Fungsi tanpa server memungkinkan pengembang untuk memilih bahasa pemrograman dan alat yang paling sesuai dengan kebutuhan mereka. Sebagian besar vendor serverless mendukung berbagai bahasa seperti JavaScript, Java, Python, Go, dan .NET. Hal ini memberikan fleksibilitas yang lebih besar dalam mengembangkan dan menerapkan aplikasi.

Efektivitas biaya

Serverless adalah arsitektur yang paling hemat biaya karena Anda hanya membayar apa yang Anda konsumsi. Yaitu runtime fungsi Anda dan layanan terkelola lainnya yang digunakan fungsi Anda. Selain itu, Anda tidak perlu membayar sumber daya yang tidak digunakan.

Apa saja kasus penggunaan fungsi tanpa server?

Fungsi tanpa server dapat digunakan di hampir semua proyek. Anda dapat menggunakan fungsi tanpa server untuk membangun proyek dari awal atau hanya untuk tugas-tugas tertentu. Kasus penggunaan utama meliputi:

• Aplikasi web
• Membangun API RESTful
• Tugas berbasis pemicu
• Otomatisasi tugas terjadwal
• Pemrosesan asinkron
• Internet of Things (IoT)
• CI / CD

Sebagian besar tim pengembang bermigrasi ke serverless secara bertahap. Mereka memigrasikan tugas demi tugas hingga tidak ada lagi kebutuhan akan server tradisional.

Apa saja contoh lingkungan tanpa server?

Platform sebagai Layanan (PaaS)

Platform as a Service (PaaS) adalah solusi komputasi awan yang menguntungkan yang menawarkan kemampuan kepada pengguna untuk membuat, mengelola, dan menggunakan aplikasi dalam lingkungan berbasis awan.

Ini menyediakan alat yang telah dikonfigurasi sebelumnya untuk pengembangan, penyesuaian, dan pengujian aplikasi, menghilangkan banyak waktu yang dihabiskan untuk manajemen infrastruktur.

Mengembangkan aplikasi yang akan digunakan pada PaaS tidak jauh berbeda dengan membangun aplikasi tradisional. Vendor PaaS tidak mendukung fungsi tanpa server secara langsung.

Layanan PaaS meliputi: Heroku, AWS Elastic Beanstalk, DigitalOcean App Platform dan Fly.io.

Backend sebagai Layanan (BaaS)

BaaS merampingkan dan menyederhanakan pengembangan backend dengan menyediakan platform untuk mengelola infrastruktur cloud.

BaaS menangani semua tugas-tugas membosankan yang terkait dengan membangun backend, sehingga pengembang dapat fokus pada pembuatan aplikasi. Dengan mengotomatiskan banyak proses ini, BaaS membantu pengembang membuat aplikasi yang kuat dengan cepat dan efisien.

Platform ini menawarkan berbagai macam fitur termasuk manajemen pengguna, notifikasi, integrasi media sosial, dan penyimpanan. Menjadikannya pilihan ideal untuk bisnis yang ingin membangun kehadiran digital mereka. Selain itu, platform ini memberikan kenyamanan dan kemudahan penggunaan yang membuatnya dapat diakses oleh pengguna di seluruh dunia.

Para pengembang dibebaskan dari kebutuhan untuk mengkhawatirkan infrastruktur backend dan sebagai gantinya dapat memfokuskan upaya mereka untuk menciptakan frontend proyek mereka. Hal ini memungkinkan mereka untuk berkonsentrasi pada bisnis inti tanpa harus mencurahkan waktu dan energi untuk tugas-tugas lain.

Beberapa vendor BaaS juga mengizinkan kita untuk menggunakan fungsi-fungsi tanpa server:

• Back4app memiliki fungsi Cloud Code
• Firebase memiliki Fungsi Google Cloud
• AWS Amplify memiliki AWS Lambda

Vendor BaaS lainnya termasuk Supabase, Kinvey dan Parse.

Fungsi sebagai Layanan (FaaS)

Function as a Service (FaaS) adalah model komputasi awan yang dikhususkan untuk fungsi tanpa server. FaaS memungkinkan pengembang untuk fokus pada penulisan dan penerapan fungsi individual daripada membangun dan mengelola tumpukan aplikasi secara penuh. Fungsi tanpa server biasanya terintegrasi dengan API pihak ketiga dan layanan cloud lainnya. Model komputasi ini dapat menskalakan secara otomatis dan cepat untuk mengakomodasi lalu lintas apa pun.

Perbedaan utama antara BaaS dan FaaS terletak pada:

• Konstruksi aplikasi
• Skalabilitas
• Model penetapan harga

Fungsi-fungsi tanpa server dijalankan dalam kontainer, lebih terukur, dan lebih hemat biaya karena Anda hanya membayar untuk runtime fungsi-fungsi Anda. BaaS di sisi lain memiliki banyak fitur bawaan seperti manajemen pengguna, notifikasi push, integrasi media sosial, dan alat bantu out-of-the-box lainnya yang memungkinkan Anda membangun backend dengan cepat. Selain itu, BaaS sangat mudah digunakan.

Beberapa contoh FaaS meliputi: AWS Lambda, Google Cloud Functions, dan Azure Functions.

Membangun Backend Tanpa Server di Back4app

Di bagian tutorial ini, kami akan mendemonstrasikan cara membuat kode dan menerapkan fungsi Cloud Code ke Back4app. Selain itu, kita akan mempelajari cara menghubungkan frontend ke backend tanpa server.

Tujuan:

Pada akhir tutorial ini, Anda akan dapat melakukannya:

• Jelaskan apa saja fungsi Cloud Code dan cara kerjanya
• Membuat kode fungsi Cloud Code Anda yang dapat memanipulasi basis data
• Gunakan fungsi Cloud Code untuk mengambil data dari API pihak ketiga
• Buat Pekerjaan Cloud Anda sendiri dan jadwalkan
• Menghubungkan proyek frontend dengan backend tanpa server

Apa itu Back4app?

Back4app adalah platform BaaS – Backend as a Service terkemuka yang menyediakan alat dan fitur yang dibutuhkan pengembang untuk membuat aplikasi web dan seluler dengan mudah.

Dengan serangkaian keunggulannya yang komprehensif, ini memungkinkan para pengembang untuk fokus pada aspek-aspek utama bisnis mereka daripada mengkhawatirkan kompleksitas backend atau masalah infrastruktur. Ini adalah salah satu solusi BaaS sumber terbuka yang paling disukai yang tersedia saat ini.

Solusi komprehensif ini hadir dengan dasbor interaktif dan CLI – Command Line Interface yang fleksibel untuk kenyamanan maksimal. Selain itu, solusi ini menyediakan SDK yang kompatibel dengan React Native, Flutter, Node.js, Angular, iOS, Android, dan banyak lagi – membuat integrasi ke dalam sistem yang sudah ada menjadi sangat mudah!

Fitur-fitur inti Back4app menggabungkan basis data bergaya spreadsheet, GraphQL dan REST API, kueri langsung, autentikasi dengan opsi login sosial, skalabilitas untuk hosting, dan notifikasi yang semuanya tersedia dalam platform yang hebat ini.

Untuk informasi tambahan, silakan baca Fitur Back4app.

Back4app menawarkan model hemat biaya untuk semua jenis aplikasi, mulai dari yang kecil hingga yang besar. Mereka menyediakan paket gratis yang sempurna untuk mengembangkan dan bereksperimen dengan platform ini.

Pengenalan Proyek

Kita akan membuat aplikasi manajemen stasiun cuaca sederhana. Pertama-tama kita akan membuat stasiun cuaca virtual dan kemudian menggunakan WeatherAPI untuk mendapatkan informasi cuaca aktual di lokasi stasiun cuaca. Untuk mendefinisikan logika aplikasi, kita akan menggunakan fungsi Cloud Code dan Cloud Jobs. Pada akhirnya, kita akan mendemonstrasikan cara menghubungkan proyek frontend ke backend tanpa server dengan mudah.

Buat Aplikasi

Jika Anda belum memiliki akun Back4app, daftar sekarang untuk memanfaatkan layanan gratis mereka. Jika tidak, masuklah ke akun Anda yang sudah ada dan lanjutkan dengan langkah-langkah berikut.

Untuk mulai menggunakan Back4app, Anda harus membuat aplikasi. Masuk ke dasbor Anda untuk melihat daftar aplikasi dan klik “Buat aplikasi baru” untuk mulai membangun aplikasi Anda.

Karena kita akan menggunakan framework Parse untuk membangun aplikasi kita, pilih “Backend as a Service”.

Selanjutnya, masukkan nama aplikasi khusus, pilih “NoSQL Database” sebagai basis data Anda, dan terakhir klik “Create”.

Back4app akan menyiapkan semua komponen yang diperlukan untuk aplikasi Anda termasuk basis data, lapisan aplikasi, penskalaan, pencadangan, dan keamanan. Hanya butuh waktu singkat untuk menyelesaikannya.

Setelah aplikasi Anda selesai, Anda akan diarahkan ke dasbor aplikasi Anda.

Basis data

Mari kita mendefinisikan model database kita. Kita akan membuat dua model:

1. WeatherStation merupakan stasiun cuaca virtual yang terletak di suatu lokasi.
2. WeatherRecord mewakili pengukuran cuaca di WeatherStation tertentu.

Masuk ke “Database” Anda dan klik “Buat kelas”. Beri nama WeatherStation, pastikan untuk mengaktifkan “Public Read and Write” dan tambahkan bidang berikut ini:

+---------------------------+-----------------+---------------+----------+
| Data type                 | Name            | Default value | Required |
+---------------------------+-----------------+---------------+----------+
| String                    | name            | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+
| String                    | location        | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+

Selanjutnya, ikuti langkah yang sama untuk membuat kelas lain bernama WeatherRecord dengan bidang-bidang berikut:

+---------------------------+-----------------+---------------+----------+
| Data type                 | Name            | Default value | Required |
+---------------------------+-----------------+---------------+----------+
| Pointer -> WeatherStation | weatherStation  | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+
| String                    | weatherText     | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+
| String                    | weatherIcon     | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+
| Number                    | weatherCode     | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+

Terakhir, navigasikan ke model WeatherStation dan buat dua stasiun cuaca. Contoh:

+---------------------------+---------------+
| name                      | location      |
+---------------------------+---------------+
| Sunnyvale Station         | sunnyvale     |
+---------------------------+---------------+
| Mountain View Station     | mountain view |
+---------------------------+---------------+

Bagus, itu saja untuk database.

WeatherAPI

Untuk mengambil informasi cuaca saat ini, kita akan menggunakan API gratis yang disebut WeatherAPI.

Langkah-langkah berikut ini mengharuskan Anda memiliki akun WeatherAPI. Jika Anda belum memilikinya, silakan mendaftar, jika tidak, masuk ke dasbor Anda.

Setelah Anda masuk, catat kunci API Anda:

Selanjutnya, buka terminal Anda dan coba ambil informasi cuaca saat ini untuk “Sunnyvale” menggunakan kunci API Anda:

curl "https://api.weatherapi.com/v1/current.json?key=<your_api_key>&q=<location>&aqi=no"

# Example:
# curl "https://api.weatherapi.com/v1/current.json?key=354fc376a4c&q=Sunnyvale&aqi=no"

Anda akan mendapatkan respons yang serupa dengan yang satu ini:

{
    "location": {
        "name": "Sunnyvale",
        "region": "California",
        "country": "United States of America",
        "lat": 37.37,
        "lon": -122.04,
    },
    "current": {
        "temp_c": 7.0,
        "temp_f": 44.6,
        "is_day": 1,
        "condition": {
            "text": "Light rain",
            "icon": "//cdn.weatherapi.com/weather/64x64/day/296.png",
            "code": 1183
        },
        ...
    }
}

Pada bagian selanjutnya dari artikel ini, kita akan menggunakan fungsi Cloud Code untuk mengambil informasi cuaca dari WeatherAPI dan kemudian menyimpannya dalam database.

Kode Cloud

Fungsi Cloud Code adalah fitur canggih dari Parse Server yang memungkinkan pengembang untuk menjalankan kode JavaScript sisi server khusus. Pengembang dapat menggunakan fungsi-fungsi ini untuk mengimplementasikan logika bisnis, memvalidasi data, memproses data yang kompleks, dan membangun backend tanpa server secara umum.

Buka dasbor aplikasi Back4app Anda dan pilih “Fungsi & Hosting Web” di bawah “Kode Cloud” pada bilah samping.

UI Back4app Cloud Code mudah digunakan. Di sisi kiri layar, Anda dapat melihat struktur direktori. Secara default ada dua direktori:

1. cloud adalah direktori untuk semua kode cloud
2. public adalah direktori untuk berkas-berkas publik seperti gambar, lembar gaya, dan lainnya

Dan di sisi kanan layar, Anda memiliki editor kode bawaan.

Tentukan fungsi Cloud Code

Kami akan mendefinisikan fungsi-fungsi berikut ini:

1. weatherLocations mengembalikan daftar lokasi stasiun cuaca.
2. weatherInfo mengembalikan laporan cuaca untuk lokasi tertentu.

Namun sebelum itu, mari kita instal paket pihak ketiga yang disebut axios. Axios adalah klien HTTP berbasis janji untuk JavaScript yang sangat menyederhanakan pembuatan permintaan HTTP.

Buat file baru bernama package.json di dalam folder cloud dan letakkan file berikut di dalamnya:

{
  "dependencies": {
    "axios": "*"
  }
}

Selanjutnya, tentukan fungsi Cloud Code di cloud/main.js seperti ini:

// cloud/main.js

const axios = require("axios");

// make sure to replace `<api_key>` with your actual WeatherAPI key
const WEATHER_API_BASE = "https://api.weatherapi.com/v1/current.json?key=<api_key>";

Parse.Cloud.define("weatherLocations", async (request) => {
  const WeatherStation = Parse.Object.extend("WeatherStation");
  const weatherStationQuery = new Parse.Query(WeatherStation);
  const weatherStationResults = await weatherStationQuery.find();

  return weatherStationResults.map(result => result.get("location"))
});

Parse.Cloud.define("weatherInfo", async (request) => {
  let location = request.params.location;

  if (!location) {
    throw new Parse.Error(400, "Location not provided.");
  }

  const WeatherStation = Parse.Object.extend("WeatherStation");
  const weatherStationQuery = new Parse.Query(WeatherStation);
  weatherStationQuery.equalTo("location", location);
  const weatherStationResults = await weatherStationQuery.find();

  if (weatherStationResults.length == 0) {
    throw new Parse.Error(400, "Invalid location.");
  }

  const WeatherRecord = Parse.Object.extend("WeatherRecord");
  const weatherRecordQuery = new Parse.Query(WeatherRecord);
  weatherRecordQuery.equalTo("weatherStation", weatherStationResults[0]);
  weatherRecordQuery.descending("createdAt");
  weatherRecordQuery.limit(5);
  const weatherRecordResults = await weatherRecordQuery.find();

  return weatherRecordResults;
});

Terakhir, klik “Deploy” di bagian kanan bawah layar untuk menyebarkan fungsi Anda ke Back4app.

Pekerjaan Awan

Cloud Jobs memungkinkan pengembang untuk menjalankan pekerjaan di latar belakang, seperti mengirim pemberitahuan push atau memproses data. Pekerjaan ini ditulis mirip dengan fungsi Cloud Code dan dapat dijadwalkan untuk dijalankan satu kali atau berulang.

Mari kita buat Cloud Job yang mengukur cuaca di semua stasiun cuaca setiap 30 menit.

Tentukan Pekerjaan Cloud

Pilih “Cloud Code” pada sidebar dan tempelkan kode berikut ke bagian bawah cloud/main.js:

// cloud/main.js

// ...

Parse.Cloud.job("weatherCapture", async (request) => {
  const {params, headers, log, message} = request;
  message("weatherCapture just started...");

  const WeatherStation = Parse.Object.extend("WeatherStation");
  const weatherStationQuery = new Parse.Query(WeatherStation);
  const weatherStationResults = await weatherStationQuery.find();

  for (let i = 0; i < weatherStationResults.length; i++) {
    let weatherStation = weatherStationResults[i];

    try {
      const response = await axios.get(
        WEATHER_API_BASE + "&q=" + weatherStation.get("location") + "&aqi=no"
      );
      const currentWeather = response.data.current.condition;
      let icon = currentWeather.icon
        .replace("//", "https://")
        .replace("64x64", "128x128");

      const WeatherRecord = Parse.Object.extend("WeatherRecord");
      const weatherRecord = new WeatherRecord();
      weatherRecord.set("weatherStation", weatherStation);
      weatherRecord.set("weatherText", currentWeather.text);
      weatherRecord.set("weatherIcon", icon);
      weatherRecord.set("weatherCode", currentWeather.code);
      weatherRecord.save();
    } catch (error) {
      throw new Parse.Error(400, error);
    }
  }

  message("weatherCapture just finished!");
});

Kode ini mendefinisikan pekerjaan awan baru bernama weatherCapture. Pekerjaan ini mengulang semua WeatherStation, mengambil informasi cuaca dari WeatherAPI, dan menyimpannya dalam database.

Untuk menguji apakah berhasil, buka “Pekerjaan > Semua Pekerjaan” pada sidebar dan coba jalankan pekerjaan tersebut. Jika semuanya berjalan dengan baik, seharusnya ada dua WeatherRecord baru dalam database setelahnya.

Jadwalkan Pekerjaan Cloud

Mari kita jadwalkan pekerjaan untuk berjalan setiap 30 menit.

Pilih “Pengaturan Aplikasi > Pengaturan Server” pada bilah sisi dan cari “Pekerjaan Latar Belakang”. Kemudian klik tombol “Pengaturan”:

Selanjutnya, jadwalkan pekerjaan baru dengan detail berikut:

1. Deskripsi: Mengukur cuaca di semua stasiun
2. Pekerjaan awan: weatherCapture
3. Parameter: Biarkan kosong
4. Jadwalkan waktu: Mulai segera
5. Haruskah diulang? Ya.
6. Frekuensi: Interval
7. Pada interval berapa ia akan diulang? 30 menit

Itu dia. Pekerjaan WeatherCapture sekarang akan berjalan setiap 30 menit.

Backend tanpa server kita sekarang sudah selesai. Pada bagian selanjutnya, kita akan melihat cara menghubungkan frontend ke backend tanpa server.

Frontend

Membangun sebuah frontend kustom dari awal sampai akhir berada di luar cakupan tutorial ini. Namun demikian, saya akan menjelaskan langkah-langkah dasar untuk menghubungkan frontend JavaScript ke backend tanpa server.

• Instal Parse melalui npm atau yarn dan impor.
• Inisialisasi Parse di App.js atau _app.js Anda seperti ini:

import Parse from "parse/dist/parse.min.js";
    
// to get the keys navigate to your Back4app app > App Settings > Security & Keys
Parse.initialize(
  "<your_app_id>",              // replace me
  "<your_javascript_key>",      // replace me
);
Parse.serverURL = "https://parseapi.back4app.com/";

• Anda kemudian dapat memanggil fungsi Cloud Code seperti ini:

const fetchWeatherLocations = async () => {
    return await Parse.Cloud.run("weatherLocations");
};

Untuk informasi lebih lanjut, lihat dokumentasi resmi.

Saya juga telah menyiapkan proyek contoh untuk backend stasiun cuaca kami. Proyek ini dapat diakses di GitHub. README.md berisi semua informasi yang Anda perlukan untuk menjalankan proyek secara lokal. Jangan ragu untuk mencomotnya dan bermain-main dengannya.

Kesimpulan

Komputasi tanpa server telah menjadi solusi yang semakin populer bagi para pengembang yang ingin membangun dan menggunakan aplikasi tanpa perlu khawatir mengelola server.

Pada artikel ini, kami telah menjelajahi berbagai arsitektur perangkat lunak, melihat fungsi-fungsi tanpa server, dan menyoroti manfaat dan kasus penggunaannya. Terakhir, kami telah mendemonstrasikan cara membangun backend tanpa server sederhana di Back4app menggunakan fungsi Cloud Code.

Kode sumber akhir dapat ditemukan di repo back4app-serverless di GitHub.

Langkah-langkah ke depan

1. Lihatlah Parse Server Security untuk membuat backend Anda lebih aman.
2. Lihatlah Panduan Utama untuk Menyebarkan Aplikasi Docker untuk mempelajari cara membangun dan menyebarkan frontend kustom ke Kontainer Back4app.
3. Pelajari tentang Pemicu Parse.

PERTANYAAN YANG SERING DIAJUKAN