Entah tugas Anda kecil, atau Anda dapat memecahnya menjadi tugas yang lebih kecil. Dan tugas kecil sangat cocok untuk layanan mikro.

Perancangan perangkat lunak merupakan fase penting dalam pengembangan perangkat lunak. Pendekatan desain dapat memengaruhi keseluruhan proyek dan cara Anda menangani persyaratan yang berbeda.

Pengembang sering menggunakan arsitektur monolitik, menggabungkan semua komponen perangkat lunak ke dalam satu modul. Namun, pendekatan ini terbukti tidak efisien, terutama untuk aplikasi yang lebih besar.

Layanan mikro bertujuan untuk mengatasi keterbatasan ini. Layanan mikro adalah aplikasi modular kecil yang menjalankan fungsi tertentu. Tidak seperti aplikasi monolitik, layanan mikro memungkinkan penerapan dan penskalaan independen. Hasilnya, mereka lebih fleksibel dan lebih mudah dirawat.

Arsitektur Layanan Mikro

Arsitektur layanan mikro adalah pendekatan desain perangkat lunak yang memecah aplikasi besar menjadi layanan independen, dengan setiap layanan dirancang untuk memenuhi kebutuhan bisnis tertentu.

instagram viewer

Layanan ini berjalan pada sumber daya khusus, termasuk instans database terpisah dan daya komputasi. Tidak seperti sistem monolitik, aplikasi layanan mikro digabungkan secara longgar sehingga memungkinkan fleksibilitas yang lebih besar.

Dalam sistem terdistribusi, node server menerapkan dan menjalankan aplikasi layanan mikro secara terpisah proses — berkomunikasi satu sama lain menggunakan protokol komunikasi seperti HTTP atau melalui perantara pesan seperti RabbitMQ.

Pada dasarnya, pendekatan arsitektural ini memungkinkan layanan mempertahankan independensinya satu sama lain sambil beroperasi secara efektif dalam sistem perangkat lunak.

Dalam tutorial ini, kami akan memandu Anda mengimplementasikan layanan mikro pengguna sederhana yang mengelola data pengguna menggunakan Flask dan PostgreSQL

Menyiapkan Database PostgreSQL

Untuk memulai, instal PostgreSQL. Jika Anda belum menginstal PostgreSQL, Anda dapat mengetahuinya cara menginstal PostgreSQL di Windows atau cara menginstal PostgreSQL di macOS.

Alternatifnya, Anda dapat mengonfigurasi a basis data PostgreSQL jarak jauh contoh.

Panduan ini akan menggunakan tier gratis Render untuk menyiapkan database PostgreSQL. Ikuti ini untuk menjalankan instance database PostgreSQL di Render:

  1. Pergilah ke situs Render, daftar akun, dan masuk ke akun Anda dasbor halaman.
  2. Di halaman dasbor Anda, dari daftar layanan yang ditampilkan, pilih layanan PostgreSQL.
  3. Pada halaman pengaturan basis data, isi detail yang diperlukan dan pastikan untuk memilih tingkat gratis, dan terakhir klik Buat basis data.

Anda dapat menemukan kode proyek ini di sini repositori GitHub.

Buat Layanan Mikro Flask

  1. Di terminal Anda, buat direktori baru dan ubah ke dalamnya:
    mkdir flask-microservice
    cd flask-layanan mikro
  2. Selanjutnya, instal virtualenv, untuk membuat lingkungan pengembangan virtual yang terisolasi.
    pip instal virtualenv
  3. Buat lingkungan virtual di proyek Anda:
    virtualenv venv
  4. Terakhir, aktifkan lingkungan virtual.
    # Jendela: 
    .\venv\Scripts\aktifkan
    # Unix atau MacOS: 
    sumber venv/bin/aktifkan

Instal Paket yang Diperlukan

  1. Buat yang baru persyaratan.txt file di direktori root dan tambahkan paket-paket ini:
    labu
    psycopg2-binary
    sqlalchemy
  2. Selanjutnya, instal paket.
    pip instal -r persyaratan.txt

Buat Server Flask

Di direktori root, buat file baru: service.py, dan kode berikut:

  1. Lakukan impor berikut:
    dari labu impor Labu, permintaan, jsonify
    dari sqlalchemy impor create_engine, Kolom, Integer, String
    dari sqlalchemy.orm impor pembuat sesi
    dari sqlalchemy.ext.deklaratif impor deklaratif_base
    impor psycopg2
  2. Buat instance Flask dan konfigurasikan koneksi database.
    aplikasi = Labu (__nama__)
    mesin = buat_mesin("postgresql+psycopg2://flask_service_fe0v_user: 4785MhjfkdjfhjfjyUx67O2Nuzjchb2MQIP@dpg-chffjfjdkgfk54d6mb7860-a.oregon-postgres.render.com/flask_service_fe0v")
    Salin URL basis data eksternal pada halaman pengaturan basis data Render. Kami akan menggunakan SQLAlchemy create_engine metode dan Psycopg2 untuk mengkonfigurasi koneksi database. Pastikan untuk memperbarui dan mengganti URL basis data pada kode di atas dengan URL instance PostgreSQL Anda sendiri yang cocok dengan format yang ditentukan di atas. Jika format URL salah, kode akan menampilkan kesalahan.
  3. Buat model SQLAlchemy untuk database.
    Basis = deklaratif_base()
    kelasPengguna(Basis):
     __namatabel__ = 'pengguna'
     id = Kolom (Integer, primary_key=BENAR)
     nama = Kolom (String(50))
    Base.metadata.create_all (mesin)
    mencetak("Tabel 'pengguna' berhasil dibuat.")
    Sesi = pembuat sesi (mesin)
    Kode mendefinisikan model data untuk tabel pengguna. Setelah mendefinisikan model, itu membuat tabel menggunakan SQLAlchemy buat_semua metode yang mengambil database objek mesin koneksi sebagai parameter. Akhirnya, itu menciptakan sebuah instance dari pembuat sesi menggunakan objek mesin yang sama untuk mengaktifkan interaksi dengan database.
  4. Terakhir, tentukan rute API untuk layanan mikro.
    @ aplikasi.rute("/api/pengguna", metode=["POST"])
    defbuat pengguna():
     data = permintaan.get_json()
     nama = data["nama"]
    mencoba:
     sesi = Sesi()
     pengguna_baru = Pengguna (nama=nama)
     session.add (pengguna_baru)
     sesi.komit()
    kembali {"pengenal": pengguna_baru.id, "nama": nama baru, "pesan": f"Pengguna {nama} diciptakan."}, 201
    kecuali Pengecualian sebagai e:
     mencetak(f"Kesalahan '{e}' muncul.")
    kembali {"kesalahan": "Terjadi kesalahan saat membuat pengguna."}, 500
    @ aplikasi. rute("/api/pengguna", metode = ["DAPATKAN"])
    defget_all_users():
    mencoba:
     sesi = Sesi()
     pengguna = session.query (Pengguna).semua()
    jika pengguna:
     hasil = []
    untuk pengguna di dalam pengguna:
     result.append({"pengenal": identitas pengguna, "nama": nama belakang})
    kembali jsonify (hasil)
    kalau tidak:
    kembali jsonify({"kesalahan": f"Pengguna tidak ditemukan."}), 404
    kecuali Pengecualian sebagai e:
     mencetak(f"Kesalahan '{e}' muncul.")
    kembali {"kesalahan": "Terjadi kesalahan saat mendapatkan semua pengguna."}, 500
    jika __nama__ == "__utama__":
     aplikasi.jalankan (debug=BENAR, tuan rumah="0.0.0.0")

Uji Layanan Mikro

Kode di atas menunjukkan layanan mikro data pengguna sederhana yang menambahkan dan mengambil data dari database PostgreSQL. Idealnya, layanan mikro mencerminkan arsitektur REST API karena memungkinkan pendekatan yang fleksibel untuk membangun layanan web—arsitektur ini sangat cocok dengan pola desain layanan mikro.

Namun, penting untuk dicatat bahwa layanan mikro juga dapat menggunakan jenis pendekatan desain dan protokol komunikasi lainnya, tergantung pada kebutuhan spesifik sistem.

Untuk menguji layanan, aktifkan server pengembangan dan buka Postman untuk membuat permintaan HTTP ke titik akhir yang ditentukan.

labu --layanan aplikasi dijalankan

Di Postman, buat permintaan POST untuk menambahkan data pengguna.

Mengkontainerkan Layanan Mikro Dengan Docker

Docker menggabungkan aplikasi dan dependensinya dalam wadah. Pendekatan ini merampingkan pengembangan, penerapan, dan pengelolaan layanan mikro di lingkungan produksi karena setiap layanan dapat beroperasi secara independen dan berkomunikasi dengan layanan lain menggunakan komunikasi yang dikonfigurasi protokol.

Sebelum memulai, Anda harus menginstal Docker terlebih dahulu dengan mengikuti langkah-langkah di situs Docker. Kemudian, buat image Docker dari Dockerfile yang berisi instruksi yang diperlukan untuk menyiapkan dependensi yang diperlukan untuk menjalankan aplikasi dalam wadah.

  1. Buat Dockerfile di direktori root folder proyek Anda dan tambahkan instruksi ini:
    DARI ular piton:3.9-alpine
    WORKDIR /app
    MENYALIN persyaratan.txt ./
    BERLARI pip instal -r persyaratan.txt
    MENYALIN. .
    MEMBUKA5000
    CMD ["ular piton", "./layanan.py"]
  2. Jalankan, perintah di bawah ini untuk membuat image Docker.
     docker build -t flask-microservice .
  3. Terakhir, jalankan wadah Docker.
    docker run -p 5000:5000 flask-microservice

Ini akan memulai wadah Docker yang menjalankan layanan mikro Flask dan mengekspos port 5000 pada wadah port 8000 di mesin host, memungkinkan Anda membuat permintaan HTTP dari browser web atau Tukang pos menggunakan URL http://localhost: 5000.

Mengadopsi Arsitektur Layanan Mikro

Arsitektur layanan mikro telah menjadi pendekatan populer untuk mengembangkan aplikasi perangkat lunak yang dapat diskalakan dan tangguh. Dengan membagi aplikasi menjadi layanan kecil yang dapat diterapkan secara independen, arsitektur layanan mikro mempermudah pemeliharaan dan penskalaan sistem.

Meskipun arsitektur ini memiliki manfaat potensial, namun tidak cocok untuk semua kasus penggunaan. Bagaimanapun, persyaratan bisnis spesifik dari proyek terutama harus mempengaruhi pendekatan desain yang diadopsi.