Of je taak is klein, of je kunt het opsplitsen in kleinere taken. En een kleine taak past perfect bij een microservice.

Softwareontwerp is een essentiële fase in softwareontwikkeling. De ontwerpbenadering kan van invloed zijn op het hele project en hoe u met verschillende eisen omgaat.

Ontwikkelaars hebben vaak een monolithische architectuur gebruikt, waarbij alle softwarecomponenten in één module zijn gebundeld. Deze aanpak kan echter inefficiënt blijken te zijn, vooral voor grotere toepassingen.

Microservices proberen deze beperkingen aan te pakken. Een microservice is een kleine, modulaire applicatie die specifieke functies uitvoert. In tegenstelling tot monolithische applicaties, maken microservices onafhankelijke implementatie en schaalbaarheid mogelijk. Hierdoor zijn ze flexibeler en makkelijker te onderhouden.

De microservice-architectuur

De microservice-architectuur is een softwareontwerpbenadering die een grote applicatie opsplitst in onafhankelijke services, waarbij elke service is ontworpen om aan een specifieke zakelijke behoefte te voldoen.

instagram viewer

Deze services draaien op speciale bronnen, inclusief afzonderlijke database-instanties en rekenkracht. In tegenstelling tot monolithische systemen zijn microservice-applicaties losjes gekoppeld, wat meer flexibiliteit mogelijk maakt.

In een gedistribueerd systeem implementeren en voeren serverknooppunten microservice-applicaties afzonderlijk uit processen—met elkaar communiceren via communicatieprotocollen zoals HTTP of via message brokers zoals RabbitMQ.

In wezen stelt deze architecturale benadering de services in staat om hun onafhankelijkheid van elkaar te behouden terwijl ze effectief binnen het softwaresysteem werken.

In deze zelfstudie begeleiden we u bij het implementeren van een eenvoudige gebruikersmicroservice die gebruikersgegevens beheert met behulp van Flask en PostgreSQL

Zet een PostgreSQL-database op

Installeer PostgreSQL om aan de slag te gaan. Als u PostgreSQL niet hebt geïnstalleerd, kunt u dit achterhalen hoe PostgreSQL op Windows te installeren of hoe PostgreSQL op macOS te installeren.

Als alternatief kunt u een externe PostgreSQL-database voorbeeld.

Deze handleiding gebruikt de gratis laag van Render om een ​​PostgreSQL-database op te zetten. Volg deze om een ​​PostgreSQL-database-instantie op Render te laten draaien:

  1. Ga naar Renders website, meld u aan voor een account en log in op uw dashboard bladzijde.
  2. Selecteer op uw dashboardpagina in de lijst met weergegeven services de PostgreSQL-service.
  3. Vul op de pagina met database-instellingen de vereiste gegevens in en zorg ervoor dat u de gratis niveauen klik ten slotte op Maak een databank aan.

U kunt de code van dit project hierin vinden GitHub-opslagplaats.

Maak een Flask-microservice

  1. Maak in uw terminal een nieuwe map en verander deze in:
    mkdir kolf-microservice
    cd flask-microservice
  2. Installeer vervolgens virtualenv, om een ​​geïsoleerde virtuele ontwikkelomgeving te creëren.
    pip virtualenv installeren
  3. Creëer een virtuele omgeving in uw project:
    virtualenv venv
  4. Activeer ten slotte de virtuele omgeving.
    # Ramen: 
    .\venv\Scripts\activeren
    # Unix of macOS: 
    source venv/bin/activeren

Installeer de vereiste pakketten

  1. Maak een nieuwe aan vereisten.txt bestand in de hoofdmap en voeg deze pakketten toe:
    kolf
    psycopg2-binair
    sqlchemie
  2. Installeer vervolgens de pakketten.
    pip install -r vereisten.txt

Maak een Flask-server

Maak in de hoofdmap een nieuw bestand aan: service.py, en de volgende code:

  1. Voer de volgende invoer uit:
    van kolf importeren Kolf, verzoek, jsonify
    van sqlchemie importeren create_engine, kolom, geheel getal, tekenreeks
    van sqlalchemy.orm importeren sessiemaker
    van sqlalchemy.ext.declaratief importeren declaratieve_basis
    importeren psychopg2
  2. Maak de Flask-instantie en configureer de databaseverbinding.
    app = Fles (__naam__)
    engine = create_engine("postgresql+psycopg2://flask_service_fe0v_user: 4785MhjfkdjfhjfjyUx67O2Nuzjchb2MQIP@dpg-chffjfjdkgfk54d6mb7860-a.oregon-postgres.render.com/flask_service_fe0v")
    Kopieer de externe database-URL op de pagina met database-instellingen van Render. We gebruiken de SQLAlchemy create_engine methode en Psycopg2 om de databaseverbinding te configureren. Zorg ervoor dat u de database-URL in de bovenstaande code bijwerkt en vervangt door de URL van uw eigen PostgreSQL-instantie die overeenkomt met de hierboven opgegeven indeling. Als de URL-indeling onjuist is, genereert de code een fout.
  3. Maak een SQLAlchemy-model voor de database.
    Basis = declaratieve_basis()
    klasGebruiker(Baseren):
     __tabelnaam__ = 'gebruikers'
     id = Kolom (geheel getal, primary_key=WAAR)
     naam = Kolom (String(50))
    Base.metadata.create_all (engine)
    afdrukken("Tabel 'gebruikers' succesvol aangemaakt.")
    Sessie = sessiemaker (engine)
    De code definieert een gegevensmodel voor de gebruikerstabel. Nadat het model is gedefinieerd, wordt de tabel gemaakt met behulp van de SQLAlchemy create_all methode die de database gebruikt verbinding engine-object als parameter. Ten slotte maakt het een exemplaar van de sessie maker hetzelfde engine-object gebruiken om interacties met de database mogelijk te maken.
  4. Definieer ten slotte de API-routes voor de microservice.
    @app.route("/api/user", methods=["POST"])
    defmaak_gebruiker():
     gegevens = verzoek.get_json()
     naam = gegevens["naam"]
    poging:
     sessie = Sessie()
     new_user = Gebruiker (naam=naam)
     session.add (nieuwe_gebruiker)
     sessie.commit()
    opbrengst {"ID kaart": nieuwe_gebruiker.id, "naam": nieuwe gebruikersnaam, "bericht": f"Gebruiker {naam} gemaakt."}, 201
    behalve Uitzondering als e:
     afdrukken(f"De fout '{e}' heeft plaatsgevonden.")
    opbrengst {"fout": "Er is een fout opgetreden bij het maken van de gebruiker."}, 500
    @app.route("/api/user", methods=["GET"])
    defget_all_users():
    poging:
     sessie = Sessie()
     gebruikers = sessie.query (Gebruiker).all()
    als gebruikers:
     resultaat = []
    voor gebruiker in gebruikers:
     resultaat.toevoegen({"ID kaart": gebruikersnaam, "naam": gebruikersnaam})
    opbrengst jsonify (resultaat)
    anders:
    opbrengst jsonify({"fout": f"Gebruikers niet gevonden."}), 404
    behalve Uitzondering als e:
     afdrukken(f"De fout '{e}' heeft plaatsgevonden.")
    opbrengst {"fout": "Er is een fout opgetreden bij het ophalen van alle gebruikers."}, 500
    als __naam__ == "__voornaamst__":
     app.run (debug=WAAR, gastheer="0.0.0.0")

Test de microservice

De bovenstaande code demonstreert een eenvoudige microservice voor gebruikersgegevens die gegevens toevoegt aan en ophaalt uit een PostgreSQL-database. Idealiter spiegelen microservices de REST API-architectuur omdat het een flexibele benadering voor het bouwen van webservices mogelijk maakt, past deze architectuur goed bij het ontwerppatroon van microservices.

Het is echter belangrijk op te merken dat microservices ook andere soorten ontwerpbenaderingen en communicatieprotocollen kunnen gebruiken, afhankelijk van de specifieke behoeften van het systeem.

Om de service te testen, start u de ontwikkelingsserver en gaat u naar Postman om HTTP-verzoeken te doen aan de gedefinieerde eindpunten.

kolf --app service uitgevoerd

Maak in Postman een POST-verzoek om gebruikersgegevens toe te voegen.

Microservices in containers plaatsen met Docker

Docker bundelt applicaties en hun afhankelijkheden in containers. Deze aanpak stroomlijnt de ontwikkeling, implementatie en het beheer van microservices in een productieomgeving aangezien elke service onafhankelijk kan werken en met andere services kan communiceren met behulp van de geconfigureerde communicatie protocol.

Voordat u aan de slag gaat, moet u eerst Docker installeren door de stappen op de Docker-website. Bouw vervolgens een Docker-image van een Dockerfile die de nodige instructies bevat voor het instellen van de vereiste afhankelijkheden om de toepassing in een container uit te voeren.

  1. Maak een Dockerfile in de hoofdmap van uw projectmap en voeg deze instructies toe:
    VAN Python:3.9- alpen
    WERKDIR /app
    KOPIËREN vereisten.txt ./
    LOOP pip install -r vereisten.txt
    KOPIËREN. .
    BLOOTSTELLEN5000
    CMD ["Python", "./service.py"]
  2. Voer de onderstaande opdracht uit om de Docker-image te bouwen.
     docker build -t flask-microservice .
  3. Voer ten slotte de Docker-container uit.
    docker run -p 5000:5000 kolf-microservice

Hiermee start u een Docker-container met de Flask-microservice en stelt u poort 5000 op de container bloot poort 8000 op de hostcomputer, zodat u HTTP-verzoeken kunt doen vanuit uw webbrowser of Postman met behulp van de URL http://localhost: 5000.

De microservice-architectuur adopteren

Microservices-architectuur is een populaire benadering geworden voor het ontwikkelen van schaalbare en robuuste softwaretoepassingen. Door de toepassing op te splitsen in kleine, onafhankelijk inzetbare services, maakt de architectuur van microservices het gemakkelijker om het systeem te onderhouden en te schalen.

Hoewel deze architectuur potentiële voordelen heeft, is deze niet geschikt voor alle gebruikssituaties. In ieder geval moeten de specifieke zakelijke vereisten van het project in de eerste plaats van invloed zijn op de gekozen ontwerpbenadering.