Landasan Keandalan: Mencapai Keamanan Tipe Pemrosesan Terdistribusi dalam Komputasi Edge Generik

Paradigma komputasi sedang mengalami perubahan seismik. Selama beberapa dekade, cloud telah menjadi pusat pemrosesan data, raksasa terpusat dengan kekuatan besar. Namun, perbatasan baru berkembang pesat: edge. Komputasi edge—praktik memproses data di dekat sumbernya daripada di pusat data yang jauh—bukan hanya tren; ini adalah revolusi. Ini memberdayakan kota pintar kita, kendaraan otonom, pabrik yang terhubung, dan perangkat perawatan kesehatan waktu nyata. Distribusi kecerdasan ini menjanjikan latensi yang lebih rendah, peningkatan privasi, dan ketahanan operasional yang lebih besar. Namun, kekuatan terdesentralisasi ini hadir dengan tantangan tersembunyi dan mendalam: menjaga integritas data di seluruh ekosistem yang luas, heterogen, dan seringkali kacau. Inti dari tantangan ini terletak pada konsep yang akrab bagi para insinyur perangkat lunak tetapi sekarang diperbesar ke skala global: keamanan tipe.

Dalam aplikasi monolitik tradisional, memastikan bahwa suatu fungsi yang mengharapkan bilangan bulat tidak menerima string adalah masalah standar yang dapat dipecahkan. Dalam dunia komputasi edge generik, di mana ribuan atau bahkan jutaan perangkat yang beragam berkomunikasi melalui jaringan yang tidak andal, ketidakcocokan tipe sederhana dapat berubah menjadi kegagalan yang dahsyat. Hal ini dapat merusak kumpulan data, menghentikan jalur produksi, atau menyebabkan keputusan penting yang salah. Posting ini adalah pembahasan mendalam tentang mengapa keamanan tipe pemrosesan terdistribusi bukan hanya 'nice-to-have' tetapi landasan mutlak dari sistem edge yang andal, terukur, dan generik. Kita akan menjelajahi tantangan, membedah strategi yang ampuh, dan menyusun pola arsitektur untuk menjinakkan kompleksitas dan membangun edge yang tangguh, satu bagian data yang diketik dengan benar pada satu waktu.

Revolusi Komputasi Edge: Lebih dari Sekadar Server Jarak Jauh

Sebelum kita mempelajari seluk-beluk keamanan tipe, penting untuk memahami sifat unik dari lingkungan edge. Tidak seperti cloud, yang dicirikan oleh server yang relatif homogen, kuat, dan dikelola dengan baik, edge adalah lambang keragaman. Ini mencakup spektrum perangkat:

• Sensor Terbatas: Mikrokontroler (MCU) berdaya rendah dalam pengaturan industri atau monitor lingkungan yang mengumpulkan titik data sederhana seperti suhu atau tekanan.
• Perangkat Pintar: Perangkat yang lebih mumpuni seperti kamera pintar, sistem point-of-sale, atau monitor medis yang dapat melakukan analisis dan agregasi lokal.
• Gateway Edge: Node komputasi yang kuat yang mengumpulkan data dari banyak perangkat yang lebih kecil, melakukan pemrosesan yang kompleks, dan berfungsi sebagai jembatan komunikasi ke cloud atau lokasi edge lainnya.
• Sistem Otonom: Sistem edge yang sangat canggih seperti kendaraan otonom atau lengan robot yang membuat keputusan waktu nyata yang penting berdasarkan aliran data sensor.

Distribusi ini bukan hanya tentang lokasi; ini tentang fungsi. Pemrosesan bukan lagi tugas monolitik tetapi alur kerja terdistribusi. Sebuah sensor mungkin menangkap data mentah, gateway terdekat mungkin membersihkan dan memfilternya, server edge regional mungkin menjalankan model pembelajaran mesin di atasnya, dan cloud mungkin menerima wawasan agregat akhir untuk analisis jangka panjang. Pipeline pemrosesan multi-tahap dan multi-perangkat inilah tempat risiko korupsi data berlipat ganda secara eksponensial.

Sang Penyabot Diam-Diam: Apa itu Keamanan Tipe dan Mengapa Itu Penting di Edge?

Intinya, keamanan tipe adalah prinsip bahwa suatu program atau sistem mencegah atau menghalangi kesalahan yang timbul dari ketidakcocokan antara tipe data yang berbeda. Misalnya, ini memastikan Anda tidak dapat melakukan penambahan matematis pada string teks atau memperlakukan stempel waktu sebagai koordinat geografis. Dalam bahasa yang dikompilasi, banyak dari pemeriksaan ini terjadi pada waktu kompilasi, menangkap bug sebelum kode dijalankan. Dalam bahasa yang diketik secara dinamis, kesalahan ini ditangkap pada waktu proses, yang berpotensi merusak program.

Dalam lingkungan edge terdistribusi, konsep ini melampaui satu program. Ini menjadi tentang memastikan bahwa kontrak pertukaran data antara dua layanan independen, yang berpotensi ditulis dalam bahasa yang berbeda dan berjalan pada perangkat keras yang berbeda, dihormati dengan ketat. Ketika sensor edge di Singapura mengirimkan pembacaan suhu, node pemrosesan di Frankfurt harus menafsirkan data tersebut bukan hanya sebagai angka, tetapi sebagai angka floating-point 32-bit yang mewakili derajat Celcius. Jika node Frankfurt mengharapkan bilangan bulat 16-bit yang mewakili Fahrenheit, seluruh logika sistem akan terganggu.

Tantangan Inti: Heterogenitas dan "Wild West" Data Edge

Alasan utama keamanan tipe begitu sulit di edge adalah karena heterogenitas lingkungan yang murni dan tidak terkendali. Kita tidak bekerja di dalam dinding yang bersih dan terdefinisi dengan baik dari satu pusat data. Kita beroperasi di "wild west" digital.

Ledakan Cambrian Perangkat

Jaringan edge terdiri dari perangkat dari produsen yang tak terhitung jumlahnya, dibuat pada waktu yang berbeda, dengan tujuan yang berbeda. Pengontrol industri warisan dari tahun 1990-an mungkin berkomunikasi menggunakan protokol biner berpemilik, sementara kamera AI baru mengalirkan data yang dikodekan dalam format modern. Sistem edge generik harus mampu menelan, memahami, dan memproses data dari semuanya tanpa dibangun khusus untuk masing-masing sistem. Ini membutuhkan cara yang kuat untuk mendefinisikan dan memberlakukan struktur data di seluruh keragaman ini.

Babel Protokol dan Bahasa

Tidak ada 'bahasa' tunggal dari edge. Perangkat berbicara melalui MQTT, CoAP, AMQP, HTTP, dan protokol lainnya yang tak terhitung jumlahnya. Perangkat lunak yang berjalan di atasnya dapat ditulis dalam C, C++, Python, Rust, Go, atau Java. Layanan Python yang mengharapkan objek JSON dengan bidang `{"timestamp": "2023-10-27T10:00:00Z"}` akan gagal jika layanan C++ mengirimkan stempel waktu sebagai bilangan bulat epoch Unix `{"timestamp": 1698397200}`. Tanpa pemahaman tipe data yang dibagikan dan ditegakkan, seluruh sistem adalah rumah kartu.

Biaya Nyata dari Ketidakcocokan Tipe

Ini bukan masalah akademis. Kesalahan tipe dalam sistem edge terdistribusi memiliki konsekuensi yang parah dan nyata:

• Manufaktur Industri: Lengan robot mengharapkan koordinat sebagai `{x: 10.5, y: 20.2, z: 5.0}`. Karena pembaruan sistem, sensor baru mengirimkannya sebagai string `"10.5, 20.2, 5.0"`. Kesalahan penguraian menyebabkan robot berhenti, menghentikan jalur produksi multi-juta dolar sampai bug ditemukan dan diperbaiki.
• Perawatan Kesehatan yang Terhubung: Monitor detak jantung pasien mengirimkan data setiap detik. Bug menyebabkannya sesekali mengirimkan nilai `null` alih-alih bilangan bulat. Sistem peringatan hilir, yang tidak dirancang untuk menangani `null`, mogok. Peringatan kejadian jantung kritis terlewatkan, yang membahayakan nyawa pasien.
• Logistik Otonom: Armada drone pengiriman otonom bergantung pada data GPS. Sebuah drone dari satu produsen melaporkan ketinggiannya dalam meter (misalnya, `95.5`), sementara yang lain melaporkannya dalam kaki tetapi menggunakan tipe numerik yang sama. Layanan agregator, dengan asumsi semua data dalam meter, salah menghitung ketinggian drone, yang menyebabkan nyaris celaka atau tabrakan.

Mendefinisikan Komputasi Edge "Generik": Paradigma untuk Interoperabilitas

Solusi untuk heterogenitas ini bukanlah dengan memaksa setiap perangkat untuk menjadi identik. Itu tidak mungkin. Solusinya adalah membangun kerangka kerja komputasi edge generik. Sistem generik adalah sistem yang tidak terikat pada perangkat keras, sistem operasi, atau bahasa pemrograman tertentu. Ini bergantung pada abstraksi dan kontrak yang terdefinisi dengan baik untuk memungkinkan komponen yang berbeda beroperasi bersama dengan mulus.

Pikirkan seperti peti kemas pengiriman standar. Sebelum penemuannya, memuat kapal adalah proses yang kacau dan dipesan lebih dahulu untuk setiap jenis kargo. Kontainer menstandarisasi antarmuka (bentuk dan titik koneksi) sambil tetap agnostik tentang konten (apa yang ada di dalam). Dalam komputasi edge generik, keamanan tipe menyediakan antarmuka standar ini untuk data. Ini memastikan bahwa tidak peduli perangkat apa yang menghasilkan data atau layanan apa yang menggunakannya, struktur dan makna data tersebut tidak ambigu dan andal.

Strategi Mendasar untuk Menegakkan Keamanan Tipe di Seluruh Edge

Mencapai tingkat keandalan ini membutuhkan pendekatan multi-layer. Ini bukan tentang menemukan satu peluru ajaib, tetapi tentang menggabungkan beberapa strategi yang ampuh untuk menciptakan pertahanan mendalam terhadap korupsi data.

Strategi 1: Desain Schema-First dengan Format Serialisasi Data

Strategi paling mendasar adalah secara eksplisit mendefinisikan struktur data Anda. Alih-alih hanya mengirim JSON atau blob biner yang lepas, Anda menggunakan skema untuk membuat kontrak formal. Skema ini bertindak sebagai sumber kebenaran tunggal untuk tampilan sebuah data.

Teknologi terkemuka di bidang ini meliputi:

• Protocol Buffers (Protobuf): Dikembangkan oleh Google, Protobuf adalah mekanisme agnostik bahasa dan netral platform untuk menserialisasikan data terstruktur. Anda mendefinisikan struktur data Anda dalam file `.proto` sederhana, dan kompiler Protobuf menghasilkan kode sumber untuk bahasa pilihan Anda untuk dengan mudah menulis dan membaca data terstruktur Anda. Ini memberikan keamanan waktu kompilasi dan serialisasi biner yang sangat efisien, yang ideal untuk perangkat edge dengan sumber daya terbatas.
• Apache Avro: Avro adalah sistem serialisasi data yang kuat lainnya. Fitur utama adalah bahwa skema disimpan dengan data (seringkali di header), yang sangat baik untuk mengembangkan skema dari waktu ke waktu dan untuk sistem seperti data lake dan platform streaming di mana data dari versi skema yang berbeda dapat hidup berdampingan.
• JSON Schema: Untuk sistem yang sangat bergantung pada JSON, JSON Schema menyediakan kosakata untuk membuat anotasi dan memvalidasi dokumen JSON. Ini kurang berperforma daripada format biner seperti Protobuf tetapi sangat mudah dibaca manusia dan berfungsi dengan pustaka JSON standar apa pun.

Contoh: Menggunakan Protocol Buffers untuk Data Sensor

Bayangkan kita ingin mendefinisikan struktur untuk pembacaan sensor lingkungan standar. Kita akan membuat file bernama `sensor.proto`:

(Catatan: Ini adalah representasi, bukan kode yang dapat dieksekusi dalam konteks ini)

syntax = "proto3"; package edge.monitoring; message SensorReading { string device_id = 1; int64 timestamp_unix_ms = 2; // Unix epoch dalam milidetik float temperature_celsius = 3; float humidity_percent = 4; optional int32 signal_strength_dbm = 5; }

Dari file sederhana ini, kita dapat menghasilkan kode C++ untuk firmware sensor kita, kode Python untuk skrip pemrosesan gateway kita, dan kode Go untuk layanan penyerapan cloud kita. Setiap kelas yang dihasilkan akan memiliki bidang yang diketik secara kuat. Secara terprogram menjadi tidak mungkin untuk memasukkan string ke dalam bidang `timestamp_unix_ms`. Ini menangkap kesalahan pada waktu kompilasi, jauh sebelum kode disebarkan ke ribuan perangkat.

Strategi 2: Komunikasi yang Aman untuk Tipe dengan gRPC

Mendefinisikan struktur data adalah setengah dari pertempuran. Setengah lainnya adalah memastikan saluran komunikasi menghormati definisi ini. Di sinilah kerangka kerja seperti gRPC (gRPC Remote Procedure Call) unggul. gRPC juga dikembangkan oleh Google dan menggunakan Protocol Buffers secara default untuk mendefinisikan kontrak layanan dan format pesan.

Dengan gRPC, Anda tidak hanya mendefinisikan pesan ('apa') tetapi juga layanan dan metodenya ('bagaimana'). Ini menciptakan stub klien dan server yang diketik secara kuat. Ketika klien memanggil metode jarak jauh, gRPC memastikan bahwa pesan permintaan cocok dengan tipe yang diperlukan dan menserialisasikannya. Server kemudian mendeserialisasikannya dan dijamin menerima objek yang diketik dengan benar. Ini mengabstraksi detail yang berantakan dari komunikasi dan serialisasi jaringan, memberikan apa yang terasa seperti panggilan fungsi lokal yang aman untuk tipe.

Strategi 3: Pengembangan Berbasis Kontrak untuk API

Untuk layanan edge yang berkomunikasi melalui API RESTful menggunakan HTTP dan JSON, Spesifikasi OpenAPI (sebelumnya Swagger) adalah standar industri. Mirip dengan Protobuf, Anda mendefinisikan kontrak (dalam file YAML atau JSON) yang menentukan setiap endpoint, parameter permintaan yang diharapkan dan tipenya, dan struktur badan respons. Kontrak ini dapat digunakan untuk menghasilkan SDK klien, stub server, dan middleware validasi, memastikan bahwa semua komunikasi HTTP mematuhi tipe yang ditentukan.

Strategi 4: Kekuatan Bahasa yang Diketik Secara Statis

Meskipun skema dan kontrak menyediakan jaring pengaman, pilihan bahasa pemrograman memainkan peran penting. Bahasa yang diketik secara statis seperti Rust, Go, C++, Java, atau TypeScript memaksa pengembang untuk mendeklarasikan tipe data variabel. Kompiler kemudian memeriksa konsistensi tipe di seluruh basis kode. Ini adalah pendekatan proaktif yang kuat untuk menghilangkan seluruh kelas bug sebelum terjadi.

Rust, khususnya, semakin populer di edge dan IoT karena kinerja, keamanan memori, dan sistem tipe yang kuat, yang membantu membangun aplikasi yang sangat kuat dan andal untuk lingkungan dengan sumber daya terbatas.

Strategi 5: Validasi dan Sanitasi Runtime yang Kuat

Bahkan dengan semua pemeriksaan waktu kompilasi di dunia, Anda tidak selalu dapat mempercayai data yang datang dari dunia luar. Perangkat yang salah konfigurasi atau aktor jahat dapat mengirimkan data yang salah bentuk. Oleh karena itu, setiap layanan edge harus memperlakukan inputnya sebagai tidak tepercaya. Ini berarti menerapkan lapisan validasi di batas layanan Anda yang secara eksplisit memeriksa data yang masuk terhadap skema yang diharapkan sebelum memprosesnya. Ini adalah garis pertahanan terakhir Anda. Jika data tidak sesuai—jika bidang yang diperlukan hilang atau bilangan bulat berada di luar rentang yang diharapkan—data tersebut harus ditolak, dicatat, dan dikirim ke antrean surat mati untuk dianalisis, daripada diizinkan untuk merusak sistem.

Pola Arsitektur untuk Ekosistem Edge yang Aman untuk Tipe

Menerapkan strategi ini bukan hanya tentang alat; ini tentang arsitektur. Pola tertentu dapat secara dramatis meningkatkan keamanan tipe di seluruh sistem terdistribusi.

Registri Skema Pusat: Sumber Kebenaran Tunggal

Dalam penyebaran edge skala besar, skema dapat berkembang biak. Untuk menghindari kekacauan, Registri Skema sangat penting. Ini adalah layanan terpusat yang bertindak sebagai repositori master untuk semua skema data (baik itu Protobuf, Avro, atau JSON Schema). Layanan tidak menyimpan skema secara lokal; mereka mengambilnya dari registri. Ini memastikan bahwa setiap komponen dalam sistem menggunakan versi yang sama dari kontrak yang sama. Ini juga menyediakan kemampuan yang kuat untuk evolusi skema, memungkinkan Anda untuk memperbarui struktur data dengan cara yang kompatibel mundur atau maju tanpa merusak seluruh sistem.

Edge Service Mesh: Menegakkan Kebijakan di Tingkat Jaringan

Service mesh (seperti Linkerd atau Istio, atau alternatif yang lebih ringan yang dirancang untuk edge) dapat membebaskan beberapa logika validasi dari aplikasi itu sendiri. Proksi service mesh yang berada di samping aplikasi Anda dapat dikonfigurasi untuk memeriksa lalu lintas dan memvalidasi pesan terhadap skema yang dikenal. Ini memberlakukan keamanan tipe di tingkat jaringan, memberikan lapisan perlindungan yang konsisten untuk semua layanan di dalam mesh, terlepas dari bahasa yang ditulisnya.

Pipeline Data Immutable: Mencegah Kerusakan Status

Salah satu sumber umum kesalahan terkait tipe adalah mutasi status dari waktu ke waktu. Sebuah objek dimulai dalam keadaan yang valid, tetapi serangkaian operasi mengubahnya menjadi tidak valid. Dengan mengadopsi pola immutability—di mana data, setelah dibuat, tidak dapat diubah—Anda dapat mencegah bug ini. Alih-alih memodifikasi data, Anda membuat salinan baru dengan nilai yang diperbarui. Konsep pemrograman fungsional ini menyederhanakan penalaran tentang alur data dan memastikan bahwa sepotong data yang valid pada satu titik dalam pipeline tetap valid di seluruh siklus hidupnya.

Studi Kasus dalam Aksi: Jaringan Pertanian Cerdas Global

Mari kita dasarkan konsep-konsep ini dalam skenario global yang realistis.

Skenario

Agribisnis multinasional, 'AgriGlobal', ingin membuat platform 'pertanian pintar' terpadu. Mereka mengoperasikan pertanian di Amerika Utara, Amerika Selatan, dan Eropa. Perangkat keras mereka adalah campuran pengontrol irigasi lama yang mengeluarkan data CSV melalui port serial, sensor kelembaban tanah modern dari vendor Eropa yang menggunakan JSON melalui MQTT, dan armada drone otonom baru dari produsen Asia yang mengalirkan umpan video biner dan data GPS. Tujuannya adalah untuk mengumpulkan semua data ini di gateway edge regional, memprosesnya secara real-time untuk membuat keputusan (misalnya, menyesuaikan irigasi), dan mengirim wawasan agregat ke platform cloud pusat untuk perkiraan hasil panen bertenaga AI.

Implementasi

Arsitek AgriGlobal memutuskan untuk tidak menulis pengurai khusus untuk setiap perangkat. Sebaliknya, mereka mengadopsi arsitektur generik yang digerakkan oleh skema:

1. Registri Skema Pusat: Mereka menyiapkan Registri Skema Avro pusat. Mereka mendefinisikan skema untuk konsep inti seperti `SoilMoistureReading`, `GpsCoordinate`, dan `IrrigationStatus`.
2. Layanan Adaptor: Untuk setiap jenis perangkat, mereka menulis layanan 'adaptor' kecil yang berjalan di gateway edge. Adaptor pengontrol lama membaca data CSV serial dan mengubahnya menjadi objek Avro `IrrigationStatus` yang valid. Adaptor sensor menerima pesan MQTT JSON dan mengubahnya menjadi objek Avro `SoilMoistureReading`. Setiap adaptor hanya bertanggung jawab untuk satu hal: menerjemahkan output mentah perangkat tertentu ke dalam format kanonik yang diketik secara kuat yang didefinisikan dalam registri skema.
3. Pipeline Pemrosesan yang Aman untuk Tipe: Layanan pemrosesan hilir, yang ditulis dalam Go, tidak perlu tahu tentang CSV atau JSON. Mereka hanya menggunakan data Avro yang bersih dan tervalidasi dari bus pesan seperti Kafka atau NATS. Logika bisnis mereka disederhanakan, dan mereka sepenuhnya dipisahkan dari perangkat keras fisik.

Hasil

Investasi di muka dalam arsitektur yang digerakkan oleh skema terbayar dengan sangat baik:

• Integrasi Cepat: Ketika mereka mengakuisisi pertanian baru dengan merek stasiun cuaca yang berbeda, mereka hanya perlu menulis layanan adaptor baru yang kecil. Pipeline pemrosesan inti tetap tidak berubah. Waktu integrasi untuk perangkat keras baru turun dari bulan menjadi hari.
• Peningkatan Keandalan: Kegagalan pemrosesan terkait data turun lebih dari 90%. Kesalahan ditangkap di edge oleh adaptor, yang akan menandai data yang salah bentuk dari sensor yang rusak sebelum dapat meracuni model analitik pusat.
• Bukti Masa Depan: Sistem ini sekarang generik. Ini dibangun di sekitar tipe data abstrak, bukan perangkat keras tertentu. Hal ini memungkinkan AgriGlobal untuk berinovasi lebih cepat, mengadopsi teknologi terbaik di kelasnya dari vendor mana pun tanpa membangun kembali seluruh platform datanya.

Cakrawala Masa Depan: Apa Selanjutnya untuk Keamanan Tipe di Edge?

Pencarian keamanan tipe yang kuat adalah perjalanan yang berkelanjutan, dan beberapa teknologi menarik siap untuk meningkatkan standar lebih tinggi.

WebAssembly (Wasm): Runtime Aman untuk Tipe Universal

WebAssembly adalah format instruksi biner untuk mesin virtual berbasis tumpukan. Ini memungkinkan kode yang ditulis dalam bahasa seperti Rust, C++, dan Go untuk berjalan di lingkungan sandbox di mana saja—termasuk pada perangkat edge. Wasm memiliki model memori yang terdefinisi dengan baik dan diketik secara kuat. Hal ini menjadikannya target yang menarik untuk menyebarkan fungsi yang aman, portabel, dan aman untuk tipe di edge, menciptakan runtime universal yang dapat mengabstraksi perangkat keras dan OS yang mendasarinya.

Deteksi Anomali Bertenaga AI untuk Tipe Data

Sistem masa depan dapat menggunakan model pembelajaran mesin untuk mempelajari 'bentuk' aliran data normal. Model-model ini dapat mendeteksi tidak hanya kesalahan tipe yang mencolok (misalnya, string alih-alih int) tetapi juga anomali semantik yang halus (misalnya, pembacaan suhu yang secara teknis merupakan float yang valid tetapi secara fisik tidak mungkin untuk lokasinya). Ini menambahkan lapisan validasi yang cerdas dan sadar konteks.

Verifikasi Formal dan Sistem yang Terbukti Benar

Untuk sistem edge yang paling penting (seperti kedirgantaraan atau perangkat medis), kita mungkin melihat peningkatan dalam verifikasi formal. Ini adalah pendekatan matematis untuk membuktikan bahwa perangkat lunak bebas dari kelas kesalahan tertentu, termasuk kesalahan tipe. Meskipun kompleks dan intensif sumber daya, ini menawarkan jaminan kebenaran tertinggi.

Kesimpulan: Membangun Edge yang Tangguh, Satu Tipe pada Satu Waktu

Pergeseran global menuju komputasi edge tidak dapat dihentikan. Ini membuka kemampuan dan efisiensi yang belum pernah terjadi sebelumnya di setiap industri. Tetapi masa depan terdistribusi ini dapat berupa rapuh dan kacau atau kuat dan andal. Perbedaannya terletak pada ketelitian yang kita terapkan pada fondasinya.

Keamanan tipe pemrosesan terdistribusi bukanlah fitur; ini adalah prasyarat. Ini adalah disiplin yang memungkinkan kita untuk membangun sistem generik dan interoperable yang dapat berkembang dan diskalakan. Dengan merangkul pola pikir skema-pertama, memanfaatkan alat dan protokol yang aman untuk tipe, dan merancang pola arsitektur yang tangguh, kita dapat melampaui pembangunan solusi yang dipesan lebih dahulu untuk perangkat individual. Kita dapat mulai membangun edge yang benar-benar global, generik, dan dapat dipercaya—ekosistem di mana data mengalir dengan andal, keputusan dibuat dengan percaya diri, dan janji besar kecerdasan terdistribusi terwujud sepenuhnya.