Fie sarcina ta este mică, fie o poți împărți în sarcini mai mici. Și o sarcină mică se potrivește perfect pentru un microserviciu.

Proiectarea software-ului este o etapă esențială în dezvoltarea software-ului. Abordarea de proiectare poate afecta întregul proiect și modul în care gestionați diferite cerințe.

Dezvoltatorii au folosit adesea o arhitectură monolitică, grupând toate componentele software într-un singur modul. Cu toate acestea, această abordare se poate dovedi ineficientă, în special pentru aplicații mai mari.

Microservicii urmăresc să abordeze aceste limitări. Un microserviciu este o aplicație mică, modulară, care îndeplinește funcții specifice. Spre deosebire de aplicațiile monolitice, microserviciile permit implementarea și scalarea independentă. Drept urmare, sunt mai flexibile și mai ușor de întreținut.

Arhitectura de microservicii

Arhitectura de microservicii este o abordare de proiectare software care descompune o aplicație mare în servicii independente, fiecare serviciu fiind conceput pentru a răspunde unei cerințe specifice de afaceri.

instagram viewer

Aceste servicii rulează pe resurse dedicate, inclusiv instanțe separate de baze de date și putere de calcul. Spre deosebire de sistemele monolitice, aplicațiile de microservicii sunt slab cuplate, permițând o mai mare flexibilitate.

Într-un sistem distribuit, nodurile de server implementează și execută aplicații de microservicii separat procese — comunicând între ele folosind protocoale de comunicare precum HTTP sau prin brokeri de mesaje ca RabbitMQ.

În esență, această abordare arhitecturală permite serviciilor să-și mențină independența unul față de celălalt în timp ce funcționează eficient în cadrul sistemului software.

În acest tutorial, vă vom ghida prin implementarea unui microserviciu simplu de utilizator care gestionează datele utilizatorului folosind Flask și PostgreSQL

Configurați o bază de date PostgreSQL

Pentru a începe, instalați PostgreSQL. Dacă nu aveți PostgreSQL instalat, puteți afla cum se instalează PostgreSQL pe Windows sau cum se instalează PostgreSQL pe macOS.

Alternativ, puteți configura a baza de date PostgreSQL la distanță instanță.

Acest ghid va folosi nivelul gratuit Render pentru a configura o bază de date PostgreSQL. Urmați acestea pentru a porni o instanță a bazei de date PostgreSQL pe Render:

  1. Du-te la Site-ul lui Render, creați un cont și conectați-vă la dvs bord pagină.
  2. Pe pagina tabloului de bord, din lista de servicii afișată, selectați serviciul PostgreSQL.
  3. Pe pagina de setări a bazei de date, completați detaliile necesare și asigurați-vă că ați selectat nivel gratuitși în cele din urmă dați clic Creați o bază de date.

Puteți găsi codul acestui proiect în aceasta Depozitul GitHub.

Creați un microserviciu Flask

  1. În terminalul dvs., faceți un director nou și schimbați-l în el:
    mkdir flask-microservice
    cd balon-microserviciu
  2. Apoi, instalați virtualenv, pentru a crea un mediu de dezvoltare virtual izolat.
    pip install virtualenv
  3. Creați un mediu virtual în proiectul dvs.:
    virtualenv venv
  4. În cele din urmă, activați mediul virtual.
    # Windows: 
    .\venv\Scripts\activate
    # Unix sau MacOS: 
    sursă venv/bin/activate

Instalați pachetele necesare

  1. Creaza un nou cerințe.txt fișier în directorul rădăcină și adăugați aceste pachete:
    balon
    psycopg2-binar
    sqlalchimie
  2. Apoi, instalați pachetele.
    pip install -r requirements.txt

Creați un server Flask

În directorul rădăcină, creați un fișier nou: service.py, și următorul cod:

  1. Efectuați următoarele importuri:
    din balon import Flacon, cerere, jsonify
    din sqlalchimie import create_engine, Column, Integer, String
    din sqlalchemy.orm import sessionmaker
    din sqlalchemy.ext.declarative import bază_declarativă
    import psicopg2
  2. Creați instanța Flask și configurați conexiunea la baza de date.
    aplicație = Balon (__nume__)
    motor = create_engine(„postgresql+psycopg2://flask_service_fe0v_user: 4785MhjfkdjfhjfjyUx67O2Nuzjchb2MQIP@dpg-chffjfjdkgfk54d6mb7860-a.oregon-postgres.renderkservice.com/fla0v”)
    Copiați URL extern al bazei de date pe pagina de setări a bazei de date Render. Vom folosi SQLAlchemy create_engine metoda si Psycopg2 pentru a configura conexiunea la baza de date. Asigurați-vă că actualizați și înlocuiți adresa URL a bazei de date din codul de mai sus cu adresa URL a propriei instanțe PostgreSQL care se potrivește cu formatul specificat mai sus. Dacă formatul URL este incorect, codul va genera o eroare.
  3. Creați un model SQLAlchemy pentru baza de date.
    Baza = baza_declarativa()
    clasăUtilizator(Baza):
     __tablename__ = „utilizatori”
     id = coloană (întreg, cheie_primară=Adevărat)
     nume = Coloană (Șir(50))
    Base.metadata.create_all (motor)
    imprimare(„Tabelul „utilizatori” a fost creat cu succes.”)
    Sesiune = sesiune (motor)
    Codul definește un model de date pentru tabelul utilizatorilor. După definirea modelului, acesta creează tabelul folosind SQLAlchemy create_all metoda care preia baza de date obiect motor de conexiune ca parametru. În cele din urmă, creează o instanță a sesiune maker folosind același obiect motor pentru a activa interacțiunile cu baza de date.
  4. În cele din urmă, definiți rutele API pentru microserviciu.
    @app.route("/api/user", metode=["POST"])
    defcreaza utilizator():
     date = request.get_json()
     nume = date["Nume"]
    încerca:
     sesiune = Sesiune()
     new_user = Utilizator (nume=nume)
     session.add (utilizator_nou)
     session.commit()
    întoarcere {"id": new_user.id, "Nume": nume de utilizator nou, "mesaj": f"Utilizator {Nume} creată."}, 201
    cu exceptia Excepție la fel de e:
     imprimare(f"Eroarea"{e}' a avut loc.")
    întoarcere {"eroare": „A apărut o eroare la crearea utilizatorului.”}, 500
    @app.route("/api/user", metode=["GET"])
    defobține_toți_utilizatorii():
    încerca:
     sesiune = Sesiune()
     utilizatori = session.query (Utilizator).all()
    dacă utilizatori:
     rezultat = []
    pentru utilizator în utilizatori:
     result.append({"id": ID-ul de utilizator, "Nume": nume de utilizator})
    întoarcere jsonify (rezultat)
    altfel:
    întoarcere jsonify({"eroare": f„Utilizatori nu au fost găsiți”.}), 404
    cu exceptia Excepție la fel de e:
     imprimare(f"Eroarea"{e}' a avut loc.")
    întoarcere {"eroare": „A apărut o eroare la obținerea tuturor utilizatorilor.”}, 500
    dacă __nume__ == "__principal__":
     app.run (depanare=Adevărat, gazdă="0.0.0.0")

Testați microserviciul

Codul de mai sus demonstrează un microserviciu simplu de date utilizator care adaugă și preia date dintr-o bază de date PostgreSQL. În mod ideal, microserviciile oglindesc Arhitectura API REST deoarece permite o abordare flexibilă a construirii de servicii web — această arhitectură se potrivește bine cu modelul de design al microserviciilor.

Cu toate acestea, este important de reținut că microserviciile pot utiliza și alte tipuri de abordări de proiectare și protocoale de comunicare, în funcție de nevoile specifice ale sistemului.

Pentru a testa serviciul, porniți serverul de dezvoltare și mergeți la Postman pentru a face solicitări HTTP către punctele finale definite.

flask --aplicație rulează serviciul

În Postman, faceți o solicitare POST pentru a adăuga date utilizator.

Containerizarea microserviciilor cu Docker

Docker grupează aplicațiile și dependențele acestora în containere. Această abordare eficientizează dezvoltarea, implementarea și gestionarea microserviciilor într-un mediu de producție deoarece fiecare serviciu poate funcționa independent și poate comunica cu alte servicii folosind comunicația configurată protocol.

Înainte de a începe, mai întâi trebuie să instalați Docker urmând pașii de pe Site-ul web Docker. Apoi, construiți o imagine Docker dintr-un fișier Docker care conține instrucțiunile necesare pentru configurarea dependențelor necesare pentru a rula aplicația într-un container.

  1. Creați un Dockerfile în directorul rădăcină al folderului proiectului și adăugați aceste instrucțiuni:
    DIN piton:3.9-alpin
    WORKDIR /app
    COPIE cerințe.txt ./
    ALERGA pip install -r requirements.txt
    COPIE. .
    EXPUNE5000
    CMD ["piton", „./service.py”]
  2. Rulați comanda de mai jos pentru a construi imaginea Docker.
     docker build -t flask-microservice .
  3. În cele din urmă, rulați containerul Docker.
    docker run -p 5000:5000 flask-microservice

Aceasta va porni un container Docker care rulează microserviciul Flask și va expune portul 5000 al containerului portul 8000 de pe mașina gazdă, permițându-vă să efectuați solicitări HTTP din browserul dvs. web sau Poștaș folosind URL http://localhost: 5000.

Adoptarea arhitecturii microservicii

Arhitectura de microservicii a devenit o abordare populară pentru dezvoltarea de aplicații software scalabile și robuste. Prin împărțirea aplicației în servicii mici, implementabile independent, arhitectura microserviciilor facilitează întreținerea și scalarea sistemului.

Deși această arhitectură are beneficii potențiale, nu este potrivită pentru toate cazurile de utilizare. În orice caz, cerințele specifice de afaceri ale proiectului ar trebui să influențeze în primul rând abordarea de proiectare adoptată.