Enten er din opgave lille, eller også kan du opdele den i mindre opgaver. Og en lille opgave passer perfekt til en mikroservice.

Softwaredesign er en væsentlig fase i softwareudvikling. Designtilgangen kan påvirke hele projektet, og hvordan du håndterer forskellige krav.

Udviklere har ofte brugt en monolitisk arkitektur, der samler alle softwarekomponenterne i et enkelt modul. Denne tilgang kan dog vise sig at være ineffektiv, især til større applikationer.

Microservices sigter mod at løse disse begrænsninger. En mikroservice er en lille, modulær applikation, der udfører specifikke funktioner. I modsætning til monolitiske applikationer giver mikrotjenester mulighed for uafhængig implementering og skalering. Som et resultat er de mere fleksible og nemmere at vedligeholde.

Mikroservicearkitekturen

Mikroservicearkitekturen er en softwaredesigntilgang, der opdeler en stor applikation i uafhængige tjenester, hvor hver service er designet til at imødekomme et specifikt forretningskrav.

Disse tjenester kører på dedikerede ressourcer, herunder separate databaseinstanser og computerkraft. I modsætning til monolitiske systemer er mikroserviceapplikationer løst koblede, hvilket giver mulighed for større fleksibilitet.

I et distribueret system implementerer og udfører servernoder mikroserviceapplikationer som separate processer - kommunikerer med hinanden ved hjælp af kommunikationsprotokoller såsom HTTP eller via meddelelsesmæglere ligesom RabbitMQ.

Grundlæggende gør denne arkitektoniske tilgang det muligt for tjenesterne at bevare deres uafhængighed af hinanden, mens de fungerer effektivt i softwaresystemet.

I denne tutorial guider vi dig gennem implementering af en simpel brugermikrotjeneste, der administrerer brugerdata ved hjælp af Flask og PostgreSQL

Opsæt en PostgreSQL-database

For at komme i gang skal du installere PostgreSQL. Hvis du ikke har PostgreSQL installeret, kan du finde ud af det hvordan man installerer PostgreSQL på Windows eller hvordan man installerer PostgreSQL på macOS.

Alternativt kan du konfigurere en ekstern PostgreSQL-database eksempel.

Denne guide vil bruge Renders gratis niveau til at opsætte en PostgreSQL-database. Følg disse for at oprette en PostgreSQL-databaseinstans på Render:

  1. Gå over til Renders hjemmeside, tilmeld dig en konto, og log ind på din dashboard side.
  2. På din dashboard-side skal du vælge PostgreSQL-tjenesten fra den viste liste over tjenester.
  3. På siden med databaseindstillinger skal du udfylde de nødvendige oplysninger og sørge for at vælge gratis lag, og klik til sidst Opret database.

Du kan finde dette projekts kode i denne GitHub-depot.

Opret en Flask Microservice

  1. I din terminal skal du lave en ny mappe og skifte til den:
    mkdir flask-microservice
    cd kolbe-mikroservice
  2. Installer derefter virtualenv, for at skabe et isoleret virtuelt udviklingsmiljø.
    pip installer virtualenv
  3. Opret et virtuelt miljø i dit projekt:
    virtualenv venv
  4. Til sidst skal du aktivere det virtuelle miljø.
    # Windows: 
    .\venv\Scripts\aktiver
    # Unix eller MacOS: 
    kilde venv/bin/activate

Installer de nødvendige pakker

  1. Opret en ny krav.txt fil i rodmappen og tilføj disse pakker:
    kolbe
    psychopg2-binær
    sqlalchemy
  2. Installer derefter pakkerne.
    pip install -r requirements.txt

Opret en Flask Server

Opret en ny fil i rodmappen: service.py, og følgende kode:

  1. Foretag følgende importer:
    fra kolbe importere Flask, request, jsonify
    fra sqlalchemy importere create_engine, Column, Integer, String
    fra sqlalchemy.orm importere sessionsmager
    fra sqlalchemy.ext.declarative importere deklarativ_base
    importere psychopg2
  2. Opret Flask-forekomsten, og konfigurer databaseforbindelsen.
    app = Kolbe (__navn__)
    motor = create_engine("postgresql+psycopg2://flask_service_fe0v_user: 4785MhjfkdjfhjfjyUx67O2Nuzjchb2MQIP@dpg-chffjfjdkgfk54d6mb7860-a.oregon-postgres.render.com/flask_service_fe0v")
    Kopier ekstern database URL på Renders databaseindstillingsside. Vi vil bruge SQLAlchemy create_engine metode og Psychopg2 for at konfigurere databaseforbindelsen. Sørg for at opdatere og erstatte database-URL'en i ovenstående kode med URL'en på din egen PostgreSQL-instans, der matcher formatet angivet ovenfor. Hvis URL-formatet er forkert, vil koden give en fejl.
  3. Opret en SQLAlchemy-model til databasen.
    Base = declarative_base()
    klasseBruger(Grundlag):
     __tabelnavn__ = 'brugere'
     id = Kolonne (heltal, primær_nøgle=Rigtigt)
     navn = Kolonne (String(50))
    Base.metadata.create_all (motor)
    Print("Tabel 'brugere' oprettet med succes.")
    Session = sessionmaker (motor)
    Koden definerer en datamodel for brugernes tabel. Efter at have defineret modellen, opretter den tabellen ved hjælp af SQLAlchemy create_all metode, der tager databasen forbindelsesmotorobjekt som en parameter. Endelig opretter det en instans af session maker bruger det samme motorobjekt til at aktivere interaktioner med databasen.
  4. Til sidst skal du definere API-ruterne for mikrotjenesten.
    @app.route("/api/bruger", methods=["POST"])
    defoprette_bruger():
     data = request.get_json()
     navn = data["navn"]
    prøve:
     session = Session()
     new_user = Bruger (navn=navn)
     session.add (ny_bruger)
     session.commit()
    Vend tilbage {"id": ny_bruger.id, "navn": ny_bruger.navn, "besked": f"Bruger {navn} skabt."}, 201
    undtagen Undtagelse som e:
     Print(f"Fejlen"{e}' fandt sted.")
    Vend tilbage {"fejl": "Der opstod en fejl under oprettelse af brugeren."}, 500
    @app.route("/api/bruger", methods=["GET"])
    deffå_alle_brugere():
    prøve:
     session = Session()
     brugere = session.query (User).all()
    hvis brugere:
     resultat = []
    til bruger i brugere:
     result.append({"id": bruger ID, "navn": bruger.navn})
    Vend tilbage jsonify (resultat)
    andet:
    Vend tilbage jsonify({"fejl": f"Brugere ikke fundet."}), 404
    undtagen Undtagelse som e:
     Print(f"Fejlen"{e}' fandt sted.")
    Vend tilbage {"fejl": "Der opstod en fejl under hentning af alle brugere."}, 500
    hvis __navn__ == "__main__":
     app.run (debug=Rigtigt, vært="0.0.0.0")

Test Microservice

Ovenstående kode demonstrerer en simpel brugerdatamikrotjeneste, der tilføjer og henter data fra en PostgreSQL-database. Ideelt set afspejler mikrotjenester REST API-arkitektur da det giver mulighed for en fleksibel tilgang til at bygge webtjenester - passer denne arkitektur godt med mikrotjenesters designmønster.

Det er dog vigtigt at bemærke, at mikrotjenester også kan bruge andre typer designtilgange og kommunikationsprotokoller, afhængigt af systemets specifikke behov.

For at teste tjenesten skal du dreje udviklingsserveren op og gå over til Postman for at lave HTTP-anmodninger til de definerede slutpunkter.

flask --app service køre

Lav en POST-anmodning i Postman for at tilføje brugerdata.

Containerisering af mikrotjenester med Docker

Docker samler applikationer og deres afhængigheder i containere. Denne tilgang strømliner udvikling, implementering og styring af mikrotjenester i et produktionsmiljø da hver tjeneste kan fungere uafhængigt og kommunikere med andre tjenester ved hjælp af den konfigurerede kommunikation protokol.

Før du går i gang, skal du først installere Docker ved at følge trinene på Dockers hjemmeside. Byg derefter et Docker-image fra en Dockerfil, der indeholder de nødvendige instruktioner til opsætning af de nødvendige afhængigheder til at køre applikationen i en container.

  1. Opret en Dockerfile i din projektmappes rodmappe, og tilføj disse instruktioner:
    FRA python:3.9-alpine
    WORKDIR /app
    KOPI requirements.txt ./
    LØB pip install -r requirements.txt
    KOPI. .
    UDSÆTTE5000
    CMD ["python", "./service.py"]
  2. Kør kommandoen nedenfor for at bygge Docker-billedet.
     docker build -t flask-microservice .
  3. Kør endelig Docker-beholderen.
    docker run -p 5000:5000 flask-microservice

Dette vil starte en Docker-container, der kører Flask-mikrotjenesten og udsætte port 5000 på containeren for port 8000 på værtsmaskinen, så du kan lave HTTP-anmodninger fra din webbrowser eller Postman ved hjælp af URL http://localhost: 5000.

Vedtagelse af mikroservicearkitekturen

Mikroservicearkitektur er blevet en populær tilgang til udvikling af skalerbare og robuste softwareapplikationer. Ved at opdele applikationen i små tjenester, der kan implementeres uafhængigt, gør mikroservicearkitekturen det nemmere at vedligeholde og skalere systemet.

Selvom denne arkitektur har potentielle fordele, er den ikke egnet til alle anvendelsestilfælde. Under alle omstændigheder bør de specifikke forretningskrav til projektet primært have indflydelse på den vedtagne designtilgang.