Microservice

Dalam beberapa tahun terakhir, arsitektur microservice telah menjadi pendekatan yang populer dalam pengembangan perangkat lunak. Microservice menawarkan fleksibilitas dan skalabilitas yang tinggi dibandingkan dengan arsitektur monolitik tradisional. Artikel ini bertujuan untuk menjelaskan konsep microservice, keuntungan yang ditawarkannya, serta memberikan contoh penerapan microservice menggunakan Node.js, Express.js, dan Axios.

Apa itu Microservice?

Microservice adalah pendekatan arsitektur perangkat lunak yang memecah aplikasi besar dan monolitik menjadi sekumpulan layanan kecil yang dapat berjalan secara independen. Setiap layanan, atau “microservice”, menangani satu fungsi bisnis spesifik dan dapat dikembangkan, diuji, serta dideploy secara terpisah dari layanan lainnya.

Karakteristik Microservice

• Loose Coupling: Layanan tidak saling bergantung erat, memungkinkan fleksibilitas dalam pengembangan dan deployment.
• Independently Deployable: Setiap layanan dapat dideploy secara independen tanpa mengganggu layanan lainnya.
• Technology Agnostic: Setiap layanan dapat dikembangkan menggunakan bahasa atau teknologi yang berbeda.
• Focused on Business Capability: Setiap layanan difokuskan pada fungsi bisnis tertentu.

Keuntungan Microservice

Skalabilitas

Microservice memungkinkan skala horizontal yang lebih baik karena setiap layanan dapat diskalakan secara independen berdasarkan kebutuhan. Sebagai contoh, jika layanan autentikasi mengalami beban yang lebih tinggi, layanan tersebut dapat diskalakan tanpa mempengaruhi layanan lainnya.

Peningkatan Kecepatan Pengembangan

Dengan layanan yang lebih kecil dan tim yang terpisah, pengembangan dan deployment dapat dilakukan lebih cepat dan lebih sering. Ini memungkinkan pengembang untuk mengadopsi metodologi DevOps dan CI/CD dengan lebih efektif.

Ketahanan

Jika satu layanan gagal, layanan lainnya tetap dapat berjalan, meningkatkan ketahanan sistem secara keseluruhan. Sebagai contoh, jika layanan pembayaran mengalami kegagalan, layanan pencarian produk masih dapat berfungsi dengan baik.

Fleksibilitas Teknologi

Setiap tim dapat memilih teknologi yang paling sesuai dengan kebutuhan layanan mereka, memungkinkan adopsi teknologi baru tanpa harus mengubah seluruh aplikasi.

Contoh Penerapan Microservice

Arsitektur Sederhana

Untuk contoh ini, kita akan membangun dua layanan microservice sederhana menggunakan Node.js dan Express.js:

• User Service: Menyediakan API untuk operasi CRUD pengguna.
• Order Service: Mengelola pesanan dan memanggil User Service untuk mendapatkan informasi pengguna.

Langkah-langkah Implementasi

1. Membangun User Service

User Service akan bertanggung jawab untuk mengelola informasi pengguna. Ini termasuk operasi seperti membuat pengguna baru, mendapatkan daftar pengguna, mendapatkan detail pengguna berdasarkan ID, memperbarui informasi pengguna, dan menghapus pengguna.

File: userService.js

const express = require('express');
const app = express();
app.use(express.json());

let users = [
    { id: 1, name: 'John Doe' },
    { id: 2, name: 'Jane Smith' }
];

app.get('/users', (req, res) => {
    res.json(users);
});

app.get('/users/:id', (req, res) => {
    const user = users.find(u => u.id === parseInt(req.params.id));
    if (user) {
        res.json(user);
    } else {
        res.status(404).send('User not found');
    }
});

app.post('/users', (req, res) => {
    const newUser = {
        id: users.length + 1,
        name: req.body.name
    };
    users.push(newUser);
    res.status(201).json(newUser);
});

app.put('/users/:id', (req, res) => {
    const user = users.find(u => u.id === parseInt(req.params.id));
    if (user) {
        user.name = req.body.name;
        res.json(user);
    } else {
        res.status(404).send('User not found');
    }
});

app.delete('/users/:id', (req, res) => {
    users = users.filter(u => u.id !== parseInt(req.params.id));
    res.status(204).send();
});

app.listen(3000, () => {
    console.log('User Service is running on port 3000');
});

2. Membangun Order Service

Order Service akan mengelola pesanan dan memanggil User Service untuk mendapatkan informasi pengguna yang membuat pesanan.

File: orderService.js

const express = require('express');
const axios = require('axios');
const app = express();
app.use(express.json());

let orders = [
    { id: 1, userId: 1, product: 'Laptop', quantity: 1 },
    { id: 2, userId: 2, product: 'Phone', quantity: 2 }
];

app.get('/orders', (req, res) => {
    res.json(orders);
});

app.get('/orders/:id', async (req, res) => {
    const order = orders.find(o => o.id === parseInt(req.params.id));
    if (order) {
        try {
            const response = await axios.get(`http://localhost:3000/users/${order.userId}`);
            res.json({
                ...order,
                user: response.data
            });
        } catch (error) {
            res.status(500).send('Error retrieving user information');
        }
    } else {
        res.status(404).send('Order not found');
    }
});

app.post('/orders', async (req, res) => {
    const newOrder = {
        id: orders.length + 1,
        userId: req.body.userId,
        product: req.body.product,
        quantity: req.body.quantity
    };
    try {
        const response = await axios.get(`http://localhost:3000/users/${newOrder.userId}`);
        if (response.data) {
            orders.push(newOrder);
            res.status(201).json(newOrder);
        } else {
            res.status(404).send('User not found');
        }
    } catch (error) {
        res.status(500).send('Error retrieving user information');
    }
});

app.listen(3001, () => {
    console.log('Order Service is running on port 3001');
});

Menjalankan Layanan

Jalankan userService.js di port 3000:

node userService.js

Jalankan orderService.js di port 3001:

node orderService.js

Sekarang, kedua layanan berjalan secara independen dan Order Service dapat memanggil User Service untuk mendapatkan informasi pengguna.

Tantangan Microservice

Kompleksitas Distribusi

Microservice memperkenalkan kompleksitas dalam hal komunikasi antar layanan dan pengelolaan data yang terdistribusi. Memastikan konsistensi data dan koordinasi antar layanan menjadi lebih sulit dibandingkan dengan arsitektur monolitik.

Monitoring dan Debugging

Dengan banyaknya layanan yang berjalan secara independen, monitoring dan debugging menjadi lebih menantang. Setiap layanan perlu diawasi secara terpisah dan alat-alat khusus seperti distributed tracing mungkin diperlukan untuk melacak alur eksekusi antar layanan.

Latency dan Overhead

Komunikasi antar layanan melalui jaringan dapat menambah latensi dan overhead. Setiap panggilan API antar layanan memerlukan waktu tambahan, yang dapat mempengaruhi kinerja aplikasi secara keseluruhan.

Pengelolaan Versi

Mengelola versi berbagai layanan yang berjalan secara independen memerlukan strategi yang baik untuk menghindari masalah kompatibilitas. Versi baru dari satu layanan mungkin tidak kompatibel dengan versi lama dari layanan lain, sehingga memerlukan perhatian khusus dalam pengelolaan versi dan deployment.

Kesimpulan

Microservice menawarkan banyak keuntungan dalam hal skalabilitas, kecepatan pengembangan, dan ketahanan. Namun, kompleksitas yang ditambahkannya juga memerlukan pendekatan yang hati-hati dalam hal desain, pengembangan, dan pengelolaan. Dengan contoh penerapan sederhana di atas, Anda bisa mulai memahami bagaimana microservice bekerja dan bagaimana implementasinya dalam aplikasi nyata.