Farih.co.id
Home Programming Cara Membangun Layanan Mikro dengan Python

Cara Membangun Layanan Mikro dengan Python

add video player in react js

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.

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.

Pagar tangan logam abu-abu

Dalam sistem terdistribusi, node server menerapkan dan menjalankan aplikasi layanan mikro sebagai proses terpisah—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 mengetahui cara menginstal PostgreSQL di Windows atau cara menginstal PostgreSQL di macOS.

Alternatifnya, Anda dapat mengonfigurasi instance database PostgreSQL jarak jauh.

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

  1. Pergilah ke situs Renderdaftar akun, dan masuk ke akun Anda dasbor halaman.
    Beranda render
  2. Di halaman dasbor Anda, dari daftar layanan yang ditampilkan, pilih layanan PostgreSQL.
    Daftar layanan web yang disediakan oleh platform cloud Render.
  3. Pada halaman pengaturan basis data, isi detail yang diperlukan dan pastikan untuk memilih tingkat gratisdan terakhir klik Buat basis data.
    Halaman pengaturan instance database PostgreSQL baru di Render.

Buat Layanan Mikro Flask

  1. Di terminal Anda, buat direktori baru dan ubah ke dalamnya:
     mkdir flask-microservice
    cd flask-microservice
  2. Selanjutnya, instal virtualenvuntuk membuat lingkungan pengembangan virtual yang terisolasi.
     pip install virtualenv 
  3. Buat lingkungan virtual di proyek Anda:
     virtualenv venv 
  4. Terakhir, aktifkan lingkungan virtual.
     # Windows: 
    .\venv\Scripts\activate
    # Unix or MacOS:
    source venv/bin/activate

Instal Paket yang Diperlukan

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

Buat Server Flask

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

  1. Lakukan impor berikut:
     from flask import Flask, request, jsonify
    from sqlalchemy import create_engine, Column, Integer, String
    from sqlalchemy.orm import sessionmaker
    from sqlalchemy.ext.declarative import declarative_base
    import psycopg2
  2. Buat instance Flask dan konfigurasikan koneksi database.
     app = Flask(__name__)

    engine = create_engine("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.
     Base = declarative_base()
    class User(Base):
        __tablename__ = 'users'
        id = Column(Integer, primary_key=True)
        name = Column(String(50))
    Base.metadata.create_all(engine)
    print("Table 'users' created successfully.")
    Session = sessionmaker(engine)

    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.
     @app.route("/api/user", methods=["POST"])
    def create_user():
        data = request.get_json()
        name = data["name"]
        try:
            session = Session()
            new_user = User(name=name)
            session.add(new_user)
            session.commit()
            return {"id": new_user.id, "name": new_user.name, "message": f"User {name} created."}, 201
        except Exception as e:
            print(f"The error '{e}' occurred.")
            return {"error": "An error occurred while creating the user."}, 500
    @app.route("/api/user", methods=["GET"])
    def get_all_users():
        try:
            session = Session()
            users = session.query(User).all()
            if users:
                result = []
                for user in users:
                    result.append({"id": user.id, "name": user.name})
                return jsonify(result)
            else:
                return jsonify({"error": f"Users not found."}), 404
        except Exception as e:
            print(f"The error '{e}' occurred.")
            return {"error": "An error occurred while getting all users."}, 500
    if __name__ == "__main__":
        app.run(debug=True, host="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 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.

 flask --app service run 

Di Postman, buat permintaan POST untuk menambahkan data pengguna.

Permintaan HTTP API POST di tukang pos

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 protokol komunikasi yang dikonfigurasi.

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:
     FROM python:3.9-alpine
    WORKDIR /app
    COPY requirements.txt ./
    RUN pip install -r requirements.txt
    COPY . .
    EXPOSE 5000
    CMD ["python", "./service.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 ke port 8000 pada 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 memudahkan pemeliharaan dan penskalaan sistem.

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

Comment
Share:

Leave a Reply

Your email address will not be published. Required fields are marked *

beli jitu https://167.71.217.241/ https://188.166.210.27/ https://103.253.147.8/ https://139.59.194.132/ https://152.42.192.54/ https://152.42.187.123/ https://188.166.196.248/ https://163.47.9.78/ https://157.230.245.144/ http://68.183.96.87/ http://147.182.210.122/ http://147.182.128.234/ http://167.172.1.184/ http://157.245.5.74/ http://139.59.217.59/ http://163.47.9.16/ http://144.126.251.215/ http://139.59.217.128/ http://103.186.0.254/ http://161.35.251.176/ http://157.245.29.71/ https://170.64.254.102/ https://www.markas303.ac.id/ https://www.markas303.or.id/ https://www.markas303.sch.id/ http://103.172.205.75/ http://103.245.38.119/ http://138.197.224.231/ http://138.197.224.231/

Ad

BIJI18 BIJI18 https://goremekoop.com/ AGEN77 3DBET OBOR138 GACOR168JP YING77 RUMAH258 POHONHOKI99 ASALBET88 PARIS128 66KBET LONG111 DESA333 DEWAGACOR89 YING77
https://146.190.200.68/ https://188.166.204.36/