Enten er oppgaven din liten, eller så kan du dele den opp i mindre oppgaver. Og en liten oppgave passer perfekt for en mikrotjeneste.

Programvaredesign er en viktig fase i programvareutvikling. Designtilnærmingen kan påvirke hele prosjektet og hvordan du håndterer ulike krav.

Utviklere har ofte brukt en monolitisk arkitektur, og samlet alle programvarekomponentene i en enkelt modul. Imidlertid kan denne tilnærmingen vise seg å være ineffektiv, spesielt for større applikasjoner.

Mikrotjenester tar sikte på å løse disse begrensningene. En mikrotjeneste er en liten, modulær applikasjon som utfører spesifikke funksjoner. I motsetning til monolittiske applikasjoner tillater mikrotjenester uavhengig distribusjon og skalering. Som et resultat er de mer fleksible og lettere å vedlikeholde.

Mikrotjenestearkitekturen

Mikrotjenestearkitekturen er en programvaredesigntilnærming som bryter ned en stor applikasjon i uavhengige tjenester, med hver tjeneste designet for å møte et spesifikt forretningsbehov.

Disse tjenestene kjører på dedikerte ressurser, inkludert separate databaseforekomster og datakraft. I motsetning til monolittiske systemer, er mikrotjenesteapplikasjoner løst koblet, noe som gir større fleksibilitet.

I et distribuert system distribuerer og kjører servernoder mikrotjenesteapplikasjoner som separate prosesser – kommuniserer med hverandre ved hjelp av kommunikasjonsprotokoller som HTTP eller via meldingsmeglere som RabbitMQ.

I hovedsak gjør denne arkitektoniske tilnærmingen tjenestene i stand til å opprettholde sin uavhengighet fra hverandre mens de fungerer effektivt innenfor programvaresystemet.

I denne opplæringen vil vi veilede deg gjennom implementering av en enkel brukermikrotjeneste som administrerer brukerdata ved hjelp av Flask og PostgreSQL

Sett opp en PostgreSQL-database

For å komme i gang, installer PostgreSQL. Hvis du ikke har PostgreSQL installert, kan du finne det ut hvordan installere PostgreSQL på Windows eller hvordan installere PostgreSQL på macOS.

Alternativt kan du konfigurere en ekstern PostgreSQL-database forekomst.

Denne veiledningen vil bruke Renders gratis nivå for å sette opp en PostgreSQL-database. Følg disse for å spinne opp en PostgreSQL-databaseforekomst på Render:

  1. Gå over til Renders hjemmeside, registrer deg for en konto og logg inn på din dashbord side.
  2. Velg PostgreSQL-tjenesten fra listen over tjenester som vises på dashbordsiden.
  3. På siden for databaseinnstillinger fyller du inn de nødvendige opplysningene og sørg for å velge gratis lag, og klikk til slutt Opprett database.

Du finner dette prosjektets kode i denne GitHub-depot.

Opprett en Flask Microservice

  1. I terminalen din, lag en ny katalog og bytt til den:
    mkdir flask-microservice
    cd flask-microservice
  2. Neste, installer virtualenv, for å skape et isolert virtuelt utviklingsmiljø.
    pip installer virtualenv
  3. Lag et virtuelt miljø i prosjektet ditt:
    virtualenv venv
  4. Til slutt, aktiver det virtuelle miljøet.
    # Windows: 
    .\venv\Scripts\aktiver
    # Unix eller MacOS: 
    kilde venv/bin/activate

Installer de nødvendige pakkene

  1. Lage en ny krav.txt fil i rotkatalogen og legg til disse pakkene:
    kolbe
    psychopg2-binær
    sqlalchemy
  2. Installer deretter pakkene.
    pip install -r requirements.txt

Opprett en flaskeserver

Opprett en ny fil i rotkatalogen: service.py, og følgende kode:

  1. Gjør følgende importer:
    fra kolbe import Flask, request, jsonify
    fra sqlalchemy import create_engine, Column, Integer, String
    fra sqlalchemy.orm import sessionmaker
    fra sqlalchemy.ext.declarative import deklarativ_grunnlag
    import psychopg2
  2. Opprett Flask-forekomsten og konfigurer databasetilkoblingen.
    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 databaseinnstillinger-side. Vi vil bruke SQLAlchemy create_engine metode og Psychopg2 for å konfigurere databasetilkoblingen. Sørg for å oppdatere og erstatte database-URLen i koden ovenfor med URL-en til din egen PostgreSQL-forekomst som samsvarer med formatet spesifisert ovenfor. Hvis URL-formatet er feil, vil koden gi en feil.
  3. Lag en SQLAlchemy-modell for databasen.
    Base = declarative_base()
    klasseBruker(Utgangspunkt):
     __tabellnavn__ = 'brukere'
     id = Kolonne (heltall, primærnøkkel=ekte)
     navn = Kolonne (String(50))
    Base.metadata.create_all (motor)
    skrive ut("Tabell 'brukere' opprettet vellykket.")
    Session = sessionmaker (motor)
    Koden definerer en datamodell for brukertabellen. Etter å ha definert modellen, oppretter den tabellen ved hjelp av SQLAlchemy create_all metode som tar databasen koblingsmotorobjekt som en parameter. Til slutt oppretter den en forekomst av sesjonsmaker bruke samme motorobjekt for å aktivere interaksjoner med databasen.
  4. Til slutt, definer API-rutene for mikrotjenesten.
    @app.route("/api/user", methods=["POST"])
    defOpprett bruker():
     data = request.get_json()
     navn = data["Navn"]
    prøve:
     økt = økt()
     new_user = Bruker (navn=navn)
     session.add (ny_bruker)
     session.commit()
    komme tilbake {"id": new_user.id, "Navn": ny_bruker.navn, "beskjed": f"Bruker {Navn} opprettet."}, 201
    unntatt Unntak som e:
     skrive ut(f"Feilen"{e}' skjedde.")
    komme tilbake {"feil": "Det oppstod en feil under opprettelsen av brukeren."}, 500
    @app.route("/api/user", methods=["GET"])
    deffå_alle_brukere():
    prøve:
     økt = økt()
     brukere = session.query (User).all()
    hvis brukere:
     resultat = []
    til bruker i brukere:
     result.append({"id": bruker-ID, "Navn": bruker.navn})
    komme tilbake jsonify (resultat)
    ellers:
    komme tilbake jsonify({"feil": f"Brukere ikke funnet."}), 404
    unntatt Unntak som e:
     skrive ut(f"Feilen"{e}' skjedde.")
    komme tilbake {"feil": "Det oppsto en feil under henting av alle brukere."}, 500
    hvis __navn__ == "__hoved__":
     app.run (debug=ekte, vert="0.0.0.0")

Test mikrotjenesten

Koden ovenfor demonstrerer en enkel brukerdatamikrotjeneste som legger til og henter data fra en PostgreSQL-database. Ideelt sett speiler mikrotjenester REST API-arkitektur siden den åpner for en fleksibel tilnærming til å bygge webtjenester – passer denne arkitekturen godt med designmønsteret til mikrotjenester.

Det er imidlertid viktig å merke seg at mikrotjenester også kan bruke andre typer designtilnærminger og kommunikasjonsprotokoller, avhengig av de spesifikke behovene til systemet.

For å teste tjenesten, snurr du opp utviklingsserveren og går over til Postman for å sende HTTP-forespørsler til de definerte endepunktene.

flask --app tjeneste kjøres

I Postman, foreta en POST-forespørsel om å legge til brukerdata.

Containerisering av mikrotjenester med Docker

Docker samler applikasjoner og deres avhengigheter i containere. Denne tilnærmingen effektiviserer utvikling, distribusjon og administrasjon av mikrotjenester i et produksjonsmiljø siden hver tjeneste kan operere uavhengig og kommunisere med andre tjenester ved hjelp av den konfigurerte kommunikasjonen protokoll.

Før du kommer i gang, må du først installere Docker ved å følge trinnene på Dockers nettsted. Bygg deretter et Docker-bilde fra en Dockerfil som inneholder de nødvendige instruksjonene for å sette opp de nødvendige avhengighetene for å kjøre applikasjonen i en beholder.

  1. Opprett en Dockerfile i prosjektmappens rotkatalog og legg til disse instruksjonene:
    FRA python:3.9-alpint
    WORKDIR /app
    KOPIERE requirements.txt ./
    LØPE pip install -r requirements.txt
    KOPIERE. .
    AVDEKKE5000
    CMD ["pyton", "./service.py"]
  2. Kjør, kommandoen nedenfor for å bygge Docker-bildet.
     docker build -t flask-microservice .
  3. Til slutt, kjør Docker-beholderen.
    docker run -p 5000:5000 flask-microservice

Dette vil starte en Docker-beholder som kjører Flask-mikrotjenesten og utsette port 5000 på beholderen for port 8000 på vertsmaskinen, slik at du kan sende HTTP-forespørsler fra nettleseren eller Postman ved å bruke URL http://localhost: 5000.

Vedta Microservice-arkitekturen

Mikrotjenester-arkitektur har blitt en populær tilnærming for å utvikle skalerbare og robuste programvareapplikasjoner. Ved å dele applikasjonen inn i små, uavhengig distribuerbare tjenester, gjør mikrotjenestearkitekturen det enklere å vedlikeholde og skalere systemet.

Selv om denne arkitekturen har potensielle fordeler, er den ikke egnet for alle brukstilfeller. I alle fall bør de spesifikke forretningskravene til prosjektet primært påvirke den vedtatte designtilnærmingen.