Antingen är din uppgift liten, eller så kan du dela upp den i mindre uppgifter. Och en liten uppgift passar perfekt för en mikrotjänst.

Mjukvarudesign är en viktig fas i mjukvaruutveckling. Designupplägget kan påverka hela projektet och hur man hanterar olika krav.

Utvecklare har ofta använt en monolitisk arkitektur och samlat alla programvarukomponenter i en enda modul. Detta tillvägagångssätt kan dock visa sig vara ineffektivt, särskilt för större applikationer.

Mikrotjänster syftar till att åtgärda dessa begränsningar. En mikrotjänst är en liten, modulär applikation som utför specifika funktioner. Till skillnad från monolitiska applikationer tillåter mikrotjänster oberoende distribution och skalning. Som ett resultat är de mer flexibla och lättare att underhålla.

Mikroservicearkitekturen

Mikrotjänstarkitekturen är ett tillvägagångssätt för mjukvarudesign som bryter ner en stor applikation i oberoende tjänster, där varje tjänst är utformad för att möta ett specifikt affärsbehov.

Dessa tjänster körs på dedikerade resurser, inklusive separata databasinstanser och datorkraft. Till skillnad från monolitiska system är mikroserviceapplikationer löst kopplade vilket möjliggör större flexibilitet.

instagram viewer

I ett distribuerat system distribuerar och exekverar servernoder mikrotjänstapplikationer separat processer – kommunicerar med varandra med hjälp av kommunikationsprotokoll som HTTP eller via meddelandeförmedlare som RabbitMQ.

I huvudsak gör detta arkitektoniska tillvägagångssätt att tjänsterna kan bibehålla sitt oberoende från varandra samtidigt som de fungerar effektivt inom mjukvarusystemet.

I den här handledningen guidar vi dig genom att implementera en enkel användarmikrotjänst som hanterar användardata med hjälp av Flask och PostgreSQL

Konfigurera en PostgreSQL-databas

För att komma igång, installera PostgreSQL. Om du inte har PostgreSQL installerat kan du ta reda på det hur man installerar PostgreSQL på Windows eller hur man installerar PostgreSQL på macOS.

Alternativt kan du konfigurera en fjärr PostgreSQL-databas exempel.

Den här guiden kommer att använda Renders gratisnivå för att ställa in en PostgreSQL-databas. Följ dessa för att snurra upp en PostgreSQL-databasinstans på Render:

  1. Gå över till Renders hemsida, registrera dig för ett konto och logga in på ditt instrumentbräda sida.
  2. Välj PostgreSQL-tjänsten på din instrumentpanelsida från listan över tjänster som visas.
  3. På sidan för databasinställningar, fyll i de nödvändiga uppgifterna och se till att välja gratis nivåoch klicka slutligen Skapa databas.

Du kan hitta detta projekts kod i denna GitHub-förråd.

Skapa en Flask Microservice

  1. Skapa en ny katalog i din terminal och byt till den:
    mkdir flask-microservice
    cd flask-microservice
  2. Installera sedan virtualenv, för att skapa en isolerad virtuell utvecklingsmiljö.
    pip installera virtualenv
  3. Skapa en virtuell miljö i ditt projekt:
    virtualenv venv
  4. Slutligen, aktivera den virtuella miljön.
    # Windows: 
    .\venv\Scripts\aktivera
    # Unix eller MacOS: 
    source venv/bin/activate

Installera de nödvändiga paketen

  1. Skapa en ny krav.txt fil i rotkatalogen och lägg till dessa paket:
    flaska
    psychopg2-binär
    sqlalchemy
  2. Installera sedan paketen.
    pip installation -r requirements.txt

Skapa en kolvserver

Skapa en ny fil i rotkatalogen: service.py, och följande kod:

  1. Gör följande importer:
    från flaska importera Flask, request, jsonify
    från sqlalchemy importera create_engine, kolumn, heltal, sträng
    från sqlalchemy.orm importera sessionsmakare
    från sqlalchemy.ext.deklarativ importera deklarativ_bas
    importera psychopg2
  2. Skapa Flask-instansen och konfigurera databasanslutningen.
    app = Kolv (__namn__)
    motor = skapa_motor("postgresql+psycopg2://flask_service_fe0v_user: 4785MhjfkdjfhjfjyUx67O2Nuzjchb2MQIP@dpg-chffjfjdkgfk54d6mb7860-a.oregon-postgres.render.com/flask_service_fe0v")
    Kopiera extern databas URL på Renders sida med databasinställningar. Vi kommer att använda SQLAlchemy create_engine metod och Psychopg2 för att konfigurera databasanslutningen. Se till att uppdatera och ersätta databasens URL i ovanstående kod med URL: en för din egen PostgreSQL-instans som matchar formatet som anges ovan. Om URL-formatet är felaktigt kommer koden att ge ett fel.
  3. Skapa en SQLAlchemy-modell för databasen.
    Bas = deklarativ_bas()
    klassAnvändare(Bas):
     __tabellnamn__ = "användare"
     id = Kolumn (heltal, primärnyckel=Sann)
     namn = Kolumn (Sträng(50))
    Base.metadata.create_all (motor)
    skriva ut("Tabell 'användare' har skapats framgångsrikt.")
    Session = sessionsmaker (motor)
    Koden definierar en datamodell för användarens tabell. Efter att ha definierat modellen skapar den tabellen med hjälp av SQLAlchemy create_all metod som tar databasen anslutningsmotorobjekt som en parameter. Slutligen skapar det en instans av session maker använder samma motorobjekt för att möjliggöra interaktioner med databasen.
  4. Slutligen, definiera API-rutter för mikrotjänsten.
    @app.route("/api/user", methods=["POST"])
    defskapa användare():
     data = request.get_json()
     namn = data["namn"]
    Prova:
     session = Session()
     new_user = Användare (namn=namn)
     session.add (ny_användare)
     session.commit()
    lämna tillbaka {"id": new_user.id, "namn": nytt användarnamn, "meddelande": f"Användare {namn} skapat."}, 201
    bortsett från Undantag som e:
     skriva ut(f"felet"{e}' inträffade.")
    lämna tillbaka {"fel": "Ett fel uppstod när användaren skapades."}, 500
    @app.route("/api/user", methods=["GET"])
    deffå_alla_användare():
    Prova:
     session = Session()
     användare = session.query (User).all()
    om användare:
     resultat = []
    för användare i användare:
     result.append({"id": användar ID, "namn": Användarnamn})
    lämna tillbaka jsonify (resultat)
    annan:
    lämna tillbaka jsonify({"fel": f"Användare hittades inte."}), 404
    bortsett från Undantag som e:
     skriva ut(f"felet"{e}' inträffade.")
    lämna tillbaka {"fel": "Ett fel uppstod när alla användare skulle hämtas."}, 500
    om __namn__ == "__huvud__":
     app.run (debug=Sann, värd="0.0.0.0")

Testa mikrotjänsten

Ovanstående kod visar en enkel användardatamikrotjänst som lägger till och hämtar data från en PostgreSQL-databas. Helst speglar mikrotjänster REST API-arkitektur eftersom det möjliggör ett flexibelt tillvägagångssätt för att bygga webbtjänster – passar den här arkitekturen väl med mikrotjänsters designmönster.

Det är dock viktigt att notera att mikrotjänster också kan använda andra typer av designmetoder och kommunikationsprotokoll, beroende på systemets specifika behov.

För att testa tjänsten, snurra upp utvecklingsservern och gå över till Postman för att göra HTTP-förfrågningar till de definierade slutpunkterna.

flask --app-tjänst körs

I Postman, gör en POST-förfrågan för att lägga till användardata.

Containerizing mikrotjänster med Docker

Docker paketerar applikationer och deras beroenden i behållare. Detta tillvägagångssätt effektiviserar utvecklingen, driftsättningen och hanteringen av mikrotjänster i en produktionsmiljö eftersom varje tjänst kan fungera självständigt och kommunicera med andra tjänster med hjälp av den konfigurerade kommunikationen protokoll.

Innan du börjar måste du först installera Docker genom att följa stegen på Dockers webbplats. Bygg sedan en Docker-avbildning från en Dockerfil som innehåller nödvändiga instruktioner för att ställa in de nödvändiga beroenden för att köra programmet i en behållare.

  1. Skapa en Dockerfile i din projektmapps rotkatalog och lägg till dessa instruktioner:
    FRÅN pytonorm:3.9-alpint
    WORKDIR /app
    KOPIERA requirements.txt ./
    SPRINGA pip installation -r requirements.txt
    KOPIERA. .
    ÖVERSIKT5000
    CMD ["pytonorm", "./service.py"]
  2. Kör, kommandot nedan för att bygga Docker-bilden.
     docker build -t flask-microservice .
  3. Slutligen, kör Docker-behållaren.
    docker run -p 5000:5000 flask-microservice

Detta kommer att starta en Docker-behållare som kör Flask-mikrotjänsten och exponera port 5000 på behållaren för port 8000 på värddatorn, så att du kan göra HTTP-förfrågningar från din webbläsare eller Postman med hjälp av URL http://localhost: 5000.

Antagande av Microservice-arkitekturen

Microservices-arkitektur har blivit ett populärt tillvägagångssätt för att utveckla skalbara och robusta programvaruapplikationer. Genom att dela upp applikationen i små, oberoende driftsättningsbara tjänster gör mikroservicearkitekturen det enklare att underhålla och skala systemet.

Även om den här arkitekturen har potentiella fördelar, är den inte lämplig för alla användningsfall. I vilket fall som helst bör de specifika affärskraven för projektet i första hand påverka den antagna designmetoden.