Buď je vaša úloha malá, alebo ju môžete rozdeliť na menšie úlohy. A malá úloha sa perfektne hodí pre mikroservis.

Návrh softvéru je dôležitou fázou vývoja softvéru. Dizajnový prístup môže ovplyvniť celý projekt a spôsob, akým zvládnete rôzne požiadavky.

Vývojári často používajú monolitickú architektúru, ktorá spája všetky softvérové ​​komponenty do jedného modulu. Tento prístup sa však môže ukázať ako neefektívny, najmä pri väčších aplikáciách.

Cieľom mikroslužieb je riešiť tieto obmedzenia. Mikroslužba je malá modulárna aplikácia, ktorá vykonáva špecifické funkcie. Na rozdiel od monolitických aplikácií umožňujú mikroslužby nezávislé nasadenie a škálovanie. Vďaka tomu sú pružnejšie a ľahšie sa udržiavajú.

Architektúra mikroservisov

Architektúra mikroslužieb je prístup k návrhu softvéru, ktorý rozdeľuje veľkú aplikáciu na nezávislé služby, pričom každá služba je navrhnutá tak, aby riešila špecifickú obchodnú požiadavku.

Tieto služby bežia na vyhradených zdrojoch vrátane samostatných inštancií databázy a výpočtového výkonu. Na rozdiel od monolitických systémov sú aplikácie mikroslužieb voľne spojené, čo umožňuje väčšiu flexibilitu.

instagram viewer

V distribuovanom systéme serverové uzly nasadzujú a spúšťajú aplikácie mikroslužieb ako samostatné procesy – vzájomná komunikácia pomocou komunikačných protokolov, ako je HTTP alebo prostredníctvom sprostredkovateľov správ ako RabbitMQ.

Tento architektonický prístup v podstate umožňuje službám zachovať si svoju vzájomnú nezávislosť a zároveň efektívne fungovať v rámci softvérového systému.

V tomto návode vás prevedieme implementáciou jednoduchej používateľskej mikroslužby, ktorá spravuje používateľské dáta pomocou Flask a PostgreSQL

Nastavte databázu PostgreSQL

Ak chcete začať, nainštalujte PostgreSQL. Ak nemáte nainštalovaný PostgreSQL, môžete to zistiť ako nainštalovať PostgreSQL na Windows alebo ako nainštalovať PostgreSQL na macOS.

Prípadne môžete nakonfigurovať a vzdialená databáza PostgreSQL príklad.

Táto príručka použije bezplatnú vrstvu Render na nastavenie databázy PostgreSQL. Ak chcete spustiť inštanciu databázy PostgreSQL v Renderi, postupujte takto:

  1. Zamierte k Webová stránka Renderu, zaregistrujte si účet a prihláste sa do svojho prístrojová doska stránku.
  2. Na stránke dashboardu zo zobrazeného zoznamu služieb vyberte službu PostgreSQL.
  3. Na stránke nastavení databázy vyplňte požadované údaje a vyberte možnosť voľná úroveňa nakoniec kliknite Vytvorte databázu.

Kód tohto projektu nájdete v tomto úložisko GitHub.

Vytvorte mikroslužbu banky

  1. Vo svojom termináli vytvorte nový adresár a zmeňte ho:
    mkdir flask-microservice
    cd flask-mikroservis
  2. Ďalej nainštalujte virtualenvvytvoriť izolované virtuálne vývojové prostredie.
    pip install virtualenv
  3. Vytvorte virtuálne prostredie vo svojom projekte:
    virtualenv venv
  4. Nakoniec aktivujte virtuálne prostredie.
    # Windows: 
    .\venv\Scripts\activate
    # Unix alebo MacOS: 
    zdroj venv/bin/activate

Nainštalujte požadované balíky

  1. Vytvorte nový request.txt súbor v koreňovom adresári a pridajte tieto balíčky:
    banke
    psycopg2-binary
    sqlalchemy
  2. Ďalej nainštalujte balíčky.
    pip install -r requirements.txt

Vytvorte Flask Server

V koreňovom adresári vytvorte nový súbor: service.pya nasledujúci kód:

  1. Vykonajte nasledujúce importy:
    od banke importovať Banka, žiadosť, jsonify
    od sqlalchemy importovať create_engine, Column, Integer, String
    od sqlalchemy.orm importovať sessionmaker
    od sqlalchemy.ext.deklarative importovať deklaratívny_základ
    importovať psycopg2
  2. Vytvorte inštanciu Flask a nakonfigurujte pripojenie k databáze.
    app = Banka (__name__)
    motor = create_engine("postgresql+psycopg2://flask_service_fe0v_user: 4785MhjfkdjfhjfjyUx67O2Nuzjchb2MQIP@dpg-chffjfjdkgfk54d6mb7860-a.oregon-postgres.render_service.fe0vsk")
    Skopírujte URL externej databázy na stránke nastavení databázy Render. Použijeme SQLAlchemy create_engine metóda a Psychopg2 na konfiguráciu pripojenia k databáze. Nezabudnite aktualizovať a nahradiť webovú adresu databázy vo vyššie uvedenom kóde webovou adresou vašej vlastnej inštancie PostgreSQL, ktorá zodpovedá formátu uvedenému vyššie. Ak je formát adresy URL nesprávny, kód zobrazí chybu.
  3. Vytvorte model SQLAlchemy pre databázu.
    Základ = deklaratívny_základ()
    triedaPoužívateľ(základňa):
     __názov tabuľky__ = 'používatelia'
     id = stĺpec (celé číslo, primárny_kľúč=Pravda)
     meno = Stĺpec (String(50))
    Base.metadata.create_all (motor)
    vytlačiť ("Tabuľka 'používatelia' bola úspešne vytvorená.")
    Relácia = sessionmaker (motor)
    Kód definuje dátový model pre tabuľku používateľov. Po definovaní modelu vytvorí tabuľku pomocou SQLAlchemy create_all metóda, ktorá využíva databázu objekt spojovacieho motora ako parameter. Nakoniec vytvorí inštanciu súboru tvorca relácie pomocou rovnakého objektu motora na umožnenie interakcií s databázou.
  4. Nakoniec definujte trasy API pre mikroslužbu.
    @app.route("/api/user", methods=["POST"])
    defcreate_user():
     data = request.get_json()
     meno = údaje["názov"]
    skúste:
     relácia = relácia()
     new_user = Používateľ (meno=meno)
     session.add (new_user)
     session.commit()
    vrátiť {"id": new_user.id, "názov": new_user.name, "správa": f"Používateľ {názov} vytvorené“.}, 201
    okrem Výnimka ako e:
     vytlačiť (f"Chyba"{e}' došlo.")
    vrátiť {"chyba": "Pri vytváraní používateľa sa vyskytla chyba."}, 500
    @app.route("/api/user", methods=["GET"])
    defget_all_users():
    skúste:
     relácia = relácia()
     používatelia = session.query (User).all()
    ak používatelia:
     výsledok = []
    pre užívateľ v používatelia:
     result.append({"id": ID používateľa, "názov": user.name})
    vrátiť jsonify (výsledok)
    inak:
    vrátiť jsonify({"chyba": f"Používatelia sa nenašli."}), 404
    okrem Výnimka ako e:
     vytlačiť (f"Chyba"{e}' došlo.")
    vrátiť {"chyba": "Pri získavaní všetkých používateľov sa vyskytla chyba."}, 500
    ak __meno__ == "__Hlavná__":
     app.run (ladenie=Pravda, hostiteľ="0.0.0.0")

Otestujte mikroservis

Vyššie uvedený kód demonštruje jednoduchú mikroslužbu používateľských údajov, ktorá pridáva a načítava údaje z databázy PostgreSQL. V ideálnom prípade mikroslužby odzrkadľujú Architektúra REST API keďže umožňuje flexibilný prístup k budovaniu webových služieb – táto architektúra dobre zapadá do návrhového vzoru mikroslužieb.

Je však dôležité poznamenať, že mikroslužby môžu využívať aj iné typy návrhových prístupov a komunikačných protokolov v závislosti od špecifických potrieb systému.

Ak chcete službu otestovať, spustite vývojový server a prejdite na Postman, aby ste zadali požiadavky HTTP na definované koncové body.

flask --spustenie služby aplikácie

V Postman zadajte požiadavku POST na pridanie používateľských údajov.

Kontajnerovanie mikroslužieb pomocou Dockera

Docker spája aplikácie a ich závislosti do kontajnerov. Tento prístup zjednodušuje vývoj, nasadenie a správu mikroslužieb v produkčnom prostredí pretože každá služba môže fungovať nezávisle a komunikovať s inými službami pomocou nakonfigurovanej komunikácie protokol.

Skôr ako začnete, musíte najprv nainštalovať Docker podľa krokov na Webová stránka Docker. Potom vytvorte obraz Docker zo súboru Docker, ktorý obsahuje potrebné pokyny na nastavenie požadovaných závislostí na spustenie aplikácie v kontajneri.

  1. Vytvorte Dockerfile v koreňovom adresári priečinka projektu a pridajte tieto pokyny:
    OD python:3.9-alpský
    WORKDIR /app
    KOPÍROVAŤ requirements.txt ./
    RUN pip install -r requirements.txt
    KOPÍROVAŤ. .
    VYSTAVIŤ5000
    CMD ["python", "./service.py"]
  2. Spustite príkaz uvedený nižšie na vytvorenie obrazu Docker.
     docker build -t flask-microservice .
  3. Nakoniec spustite kontajner Docker.
    docker run -p 5000:5000 flask-microservice

Tým sa spustí kontajner Docker, na ktorom je spustená mikroslužba Flask a vystaví sa port 5000 na kontajneri port 8000 na hostiteľskom počítači, ktorý vám umožňuje vytvárať požiadavky HTTP z vášho webového prehliadača alebo Postmana pomocou URL http://localhost: 5000.

Prijatie architektúry mikroslužieb

Architektúra mikroslužieb sa stala populárnym prístupom pre vývoj škálovateľných a robustných softvérových aplikácií. Rozdelením aplikácie na malé, nezávisle nasaditeľné služby, architektúra mikroslužieb uľahčuje údržbu a škálovanie systému.

Aj keď má táto architektúra potenciálne výhody, nie je vhodná pre všetky prípady použitia. V každom prípade by špecifické obchodné požiadavky projektu mali primárne ovplyvniť prijatý dizajnový prístup.