Vagy kicsi a feladatod, vagy kisebb feladatokra bonthatod. Egy kis feladat pedig tökéletesen illeszkedik egy mikroszolgáltatáshoz.

A szoftvertervezés a szoftverfejlesztés elengedhetetlen szakasza. A tervezési megközelítés hatással lehet az egész projektre és arra, hogyan kezeli a különböző követelményeket.

A fejlesztők gyakran monolitikus architektúrát alkalmaznak, egyetlen modulba csomagolva az összes szoftverkomponenst. Ez a megközelítés azonban nem bizonyulhat hatékonynak, különösen nagyobb alkalmazások esetén.

A mikroszolgáltatások célja, hogy ezeket a korlátokat kezeljék. A mikroszolgáltatás egy kis, moduláris alkalmazás, amely meghatározott funkciókat lát el. A monolitikus alkalmazásokkal ellentétben a mikroszolgáltatások független telepítést és méretezést tesznek lehetővé. Ennek eredményeként rugalmasabbak és könnyebben karbantarthatók.

A mikroszolgáltatási architektúra

A mikroszolgáltatási architektúra egy olyan szoftvertervezési megközelítés, amely egy nagy alkalmazást független szolgáltatásokra bont, és mindegyik szolgáltatást egy adott üzleti követelmény kielégítésére tervezték.

instagram viewer

Ezek a szolgáltatások dedikált erőforrásokon futnak, beleértve a különálló adatbázispéldányokat és a számítási teljesítményt. A monolitikus rendszerekkel ellentétben a mikroszolgáltatási alkalmazások lazán kapcsolódnak egymáshoz, ami nagyobb rugalmasságot tesz lehetővé.

Elosztott rendszerekben a kiszolgálócsomópontok külön-külön telepítik és hajtják végre a mikroszolgáltatási alkalmazásokat folyamatok – egymással kommunikációs protokollok, például HTTP vagy üzenetközvetítők segítségével történő kommunikáció mint a RabbitMQ.

Lényegében ez az architekturális megközelítés lehetővé teszi a szolgáltatások számára, hogy megőrizzék függetlenségüket egymástól, miközben hatékonyan működnek a szoftverrendszeren belül.

Ebben az oktatóanyagban végigvezetjük Önt egy egyszerű felhasználói mikroszolgáltatás megvalósításán, amely Flask és PostgreSQL segítségével kezeli a felhasználói adatokat.

Állítson be egy PostgreSQL adatbázist

A kezdéshez telepítse a PostgreSQL-t. Ha nincs telepítve a PostgreSQL, megtudhatja hogyan kell telepíteni a PostgreSQL-t Windows rendszeren vagy hogyan kell telepíteni a PostgreSQL-t macOS-re.

Alternatív megoldásként beállíthatja a távoli PostgreSQL adatbázis példa.

Ez az útmutató a Render ingyenes rétegét használja a PostgreSQL adatbázis beállításához. Kövesse az alábbiakat egy PostgreSQL adatbázispéldány létrehozásához a Renderen:

  1. Irány a Render weboldala, regisztráljon egy fiókot, és jelentkezzen be Irányítópult oldalon.
  2. Az irányítópult oldalán a megjelenített szolgáltatások listájából válassza ki a PostgreSQL szolgáltatást.
  3. Az adatbázis-beállítások oldalon adja meg a szükséges adatokat, és feltétlenül válassza ki a ingyenes szint, és végül kattintson Adatbázis létrehozása.

A projekt kódját itt találja meg GitHub adattár.

Hozzon létre egy lombik mikroszolgáltatást

  1. A terminálon hozzon létre egy új könyvtárat, és módosítsa azt:
    mkdir lombik-mikroszolgáltatás
    cd lombik-mikroszolgáltatás
  2. Ezután telepítse virtualenv, egy elszigetelt virtuális fejlesztői környezet létrehozásához.
    pip install virtualenv
  3. Hozzon létre egy virtuális környezetet a projektben:
    virtualenv venv
  4. Végül aktiválja a virtuális környezetet.
    # Ablakok: 
    .\venv\Scripts\activate
    # Unix vagy MacOS: 
    forrás venv/bin/activate

Telepítse a szükséges csomagokat

  1. Újat csinálni követelmények.txt fájlt a gyökérkönyvtárba, és adja hozzá ezeket a csomagokat:
    lombik
    psycopg2-bináris
    sqlalchemy
  2. Ezután telepítse a csomagokat.
    pip install -r követelmények.txt

Hozzon létre egy Flask szervert

A gyökérkönyvtárban hozzon létre egy új fájlt: service.py, és a következő kódot:

  1. Végezze el a következő importálást:
    tól től lombik import Lombik, kérés, jsonify
    tól től sqlalchemy import create_engine, Oszlop, Egész szám, Karakterlánc
    tól től sqlalchemy.orm import üléskészítő
    tól től sqlalchemy.ext.declarative import deklaratív_alap
    import pszichopg2
  2. Hozza létre a Flask példányt, és konfigurálja az adatbázis-kapcsolatot.
    app = Lombik (__name__)
    engine = create_engine("postgresql+psycopg2://flask_service_fe0v_user: 4785MhjfkdjfhjfjyUx67O2Nuzjchb2MQIP@dpg-chffjfjdkgfk54d6mb7860-a.oregon-postgres.v_service_feflaskv_service.)
    Másolja a külső adatbázis URL-je a Render adatbázis-beállítások oldalán. Használjuk a SQLAlchemy create_engine módszer és Psycopg2 az adatbázis-kapcsolat konfigurálásához. Ügyeljen arra, hogy frissítse és cserélje ki a fenti kódban szereplő adatbázis URL-címét a saját PostgreSQL-példányának URL-címére, amely megfelel a fent megadott formátumnak. Ha az URL formátuma helytelen, a kód hibát jelez.
  3. Hozzon létre egy SQLAlchemy modellt az adatbázishoz.
    Alap = deklaratív_alap()
    osztályFelhasználó(Bázis):
     __táblanév__ = "felhasználók"
     id = Oszlop (Egész szám, elsődleges_kulcs=Igaz)
     name = Oszlop (String(50))
    Base.metadata.create_all (motor)
    nyomtatás("A "felhasználók" tábla sikeresen létrehozva.")
    Session = sessionmaker (motor)
    A kód adatmodellt határoz meg a felhasználók táblájához. A modell definiálása után a táblázat segítségével elkészíti a táblázatot SQLAlchemy create_all módszer, amely átveszi az adatbázist kapcsolat motor objektum paraméterként. Végül létrehoz egy példányt a munkamenet készítő ugyanazt a motorobjektumot használja az adatbázissal való interakciók engedélyezéséhez.
  4. Végül határozza meg a mikroszolgáltatás API-útvonalait.
    @app.route("/api/user", method=["POST"])
    deffelhasználó létrehozása():
     adatok = request.get_json()
     név = adat["név"]
    próbáld ki:
     munkamenet = Munkamenet()
     new_user = Felhasználó (név=név)
     session.add (új_felhasználó)
     session.commit()
    Visszatérés {"azonosító": new_user.id, "név": új felhasználónév, "üzenet": f"Felhasználó {név} létre."}, 201
    kivéve Kivétel mint e:
     nyomtatás(f "A hiba"{e}' történt.")
    Visszatérés {"hiba": "Hiba történt a felhasználó létrehozásakor."}, 500
    @app.route("/api/user", method=["GET"])
    defget_all_users():
    próbáld ki:
     munkamenet = Munkamenet()
     userek = session.query (Felhasználó).all()
    ha felhasználók:
     eredmény = []
    számára felhasználó ban ben felhasználók:
     result.append({"azonosító": Felhasználói azonosító, "név": felhasználónév})
    Visszatérés jsonify (eredmény)
    más:
    Visszatérés jsonify({"hiba": f"A felhasználók nem találhatók."}), 404
    kivéve Kivétel mint e:
     nyomtatás(f "A hiba"{e}' történt.")
    Visszatérés {"hiba": "Hiba történt az összes felhasználó lekérésekor."}, 500
    ha __név__ == "__fő__":
     app.run (debug=Igaz, host="0.0.0.0")

Tesztelje a Microservice-t

A fenti kód egy egyszerű felhasználói adatok mikroszolgáltatást mutat be, amely adatokat ad hozzá és lekér egy PostgreSQL adatbázisból. Ideális esetben a mikroszolgáltatások tükrözik a REST API architektúra mivel rugalmas megközelítést tesz lehetővé a webszolgáltatások felépítésében – ez az architektúra jól illeszkedik a mikroszolgáltatások tervezési mintájához.

Fontos azonban megjegyezni, hogy a mikroszolgáltatások más típusú tervezési megközelítéseket és kommunikációs protokollokat is használhatnak, a rendszer speciális igényeitől függően.

A szolgáltatás teszteléséhez forgassa fel a fejlesztői kiszolgálót, és lépjen a Postmanhoz, hogy HTTP-kéréseket küldjön a meghatározott végpontokhoz.

flask --app szolgáltatás futtatása

A Postman alkalmazásban küldjön POST-kérést felhasználói adatok hozzáadásához.

Mikroszolgáltatások konténerezése Dockerrel

A Docker tárolókba csomagolja az alkalmazásokat és azok függőségeit. Ez a megközelítés egyszerűsíti a mikroszolgáltatások fejlesztését, telepítését és kezelését éles környezetben mivel az egyes szolgáltatások önállóan működhetnek és kommunikálhatnak más szolgáltatásokkal a konfigurált kommunikáció segítségével jegyzőkönyv.

Mielőtt elkezdené, először telepítenie kell a Dockert a következő lépések végrehajtásával Docker webhely. Ezután készítsen egy Docker-lemezképet egy Docker-fájlból, amely tartalmazza az alkalmazás tárolóban történő futtatásához szükséges függőségek beállításához szükséges utasításokat.

  1. Hozzon létre egy Docker-fájlt a projektmappa gyökérkönyvtárában, és adja hozzá az alábbi utasításokat:
    TÓL TŐL piton:3.9-alpesi
    WORKDIR /app
    MÁSOLAT követelmények.txt ./
    FUSS pip install -r követelmények.txt
    MÁSOLAT. .
    KIFEJEZNI5000
    CMD ["piton", "./service.py"]
  2. Futtassa az alábbi parancsot a Docker-kép létrehozásához.
     docker build -t flask-microservice .
  3. Végül futtassa a Docker-tárolót.
    docker run -p 5000:5000 lombik-mikroszolgáltatás

Ez elindít egy Docker-tárolót, amely a Flask mikroszolgáltatást futtatja, és a tároló 5000-es portját teszi elérhetővé. 8000-es port a gazdagépen, amely lehetővé teszi, hogy HTTP-kéréseket küldjön a webböngészőből vagy a Postmanból a URL http://localhost: 5000.

A mikroszolgáltatási architektúra elfogadása

A Microservices architektúra népszerű megközelítéssé vált a méretezhető és robusztus szoftveralkalmazások fejlesztésében. Azáltal, hogy az alkalmazást kis, egymástól függetlenül telepíthető szolgáltatásokra osztja fel, a mikroszolgáltatási architektúra megkönnyíti a rendszer karbantartását és méretezését.

Noha ennek az architektúrának vannak potenciális előnyei, nem alkalmas minden felhasználási esetre. Mindenesetre a projekt konkrét üzleti követelményeinek elsősorban az elfogadott tervezési megközelítést kell befolyásolniuk.