O il tuo compito è piccolo o puoi suddividerlo in compiti più piccoli. E una piccola attività è perfetta per un microservizio.

La progettazione del software è una fase essenziale nello sviluppo del software. L'approccio progettuale può influenzare l'intero progetto e il modo in cui gestisci i diversi requisiti.

Gli sviluppatori hanno spesso utilizzato un'architettura monolitica, raggruppando tutti i componenti software in un unico modulo. Tuttavia, questo approccio può rivelarsi inefficiente, in particolare per le applicazioni più grandi.

I microservizi mirano a risolvere queste limitazioni. Un microservizio è una piccola applicazione modulare che esegue funzioni specifiche. A differenza delle applicazioni monolitiche, i microservizi consentono la distribuzione e il ridimensionamento indipendenti. Di conseguenza, sono più flessibili e più facili da mantenere.

L'architettura dei microservizi

L'architettura dei microservizi è un approccio di progettazione software che suddivide un'applicazione di grandi dimensioni in servizi indipendenti, con ogni servizio progettato per soddisfare un requisito aziendale specifico.

instagram viewer

Questi servizi vengono eseguiti su risorse dedicate, incluse istanze di database separate e potenza di calcolo. A differenza dei sistemi monolitici, le applicazioni di microservizi sono accoppiate liberamente consentendo una maggiore flessibilità.

In un sistema distribuito, i nodi del server distribuiscono ed eseguono applicazioni di microservizi separatamente processi—che comunicano tra loro utilizzando protocolli di comunicazione come HTTP o tramite broker di messaggi come RabbitMQ.

Essenzialmente, questo approccio architetturale consente ai servizi di mantenere la loro indipendenza l'uno dall'altro pur operando efficacemente all'interno del sistema software.

In questo tutorial, ti guideremo attraverso l'implementazione di un semplice microservizio utente che gestisce i dati utente utilizzando Flask e PostgreSQL

Impostare un database PostgreSQL

Per iniziare, installa PostgreSQL. Se non hai installato PostgreSQL, puoi scoprirlo come installare PostgreSQL su Windows O come installare PostgreSQL su macOS.

In alternativa, puoi configurare a database PostgreSQL remoto esempio.

Questa guida utilizzerà il livello gratuito di Render per configurare un database PostgreSQL. Segui questi per creare un'istanza di database PostgreSQL su Render:

  1. Vai a Sito web di render, crea un account e accedi al tuo pannello di controllo pagina.
  2. Nella pagina del dashboard, dall'elenco dei servizi visualizzati, seleziona il servizio PostgreSQL.
  3. Nella pagina delle impostazioni del database, inserisci i dettagli richiesti e assicurati di selezionare il file livello gratuitoe infine fare clic Crea banca dati.

Puoi trovare il codice di questo progetto in questo Deposito GitHub.

Creare un microservizio Flask

  1. Nel tuo terminale, crea una nuova directory e cambia in essa:
    mkdir pallone-microservizio
    cd pallone-microservizio
  2. Quindi, installa virtualenv, per creare un ambiente di sviluppo virtuale isolato.
    pip installa virtualenv
  3. Crea un ambiente virtuale nel tuo progetto:
    virtualenv venv
  4. Infine, attiva l'ambiente virtuale.
    # Finestre: 
    .\venv\Scripts\activate
    # Unix o macOS: 
    sorgente venv/bin/activate

Installa i pacchetti richiesti

  1. Crea un nuovo requisiti.txt file nella directory principale e aggiungi questi pacchetti:
    borraccia
    psycopg2-binario
    sqlalchemy
  2. Successivamente, installa i pacchetti.
    pip install -r requisiti.txt

Crea un server Flask

Nella directory principale, crea un nuovo file: servizio.py, e il seguente codice:

  1. Effettua le seguenti importazioni:
    da borraccia importare Boccetta, richiesta, jsonify
    da sqlalchemy importare create_engine, Colonna, Integer, Stringa
    da sqlalchemy.orm importare sessionman
    da sqlalchemy.ext.declarative importare base_dichiarativa
    importare psycopg2
  2. Crea l'istanza di Flask e configura la connessione al database.
    app = Boccetta (__name__)
    motore = crea_motore("postgresql+psycopg2://flask_service_fe0v_user: 4785MhjfkdjfhjfjyUx67O2Nuzjchb2MQIP@dpg-chffjfjdkgfk54d6mb7860-a.oregon-postgres.render.com/flask_service_fe0v")
    Copia il URL del database esterno nella pagina delle impostazioni del database di Render. Useremo il SQLAlchemy create_engine metodo e Psicopg2 per configurare la connessione al database. Assicurati di aggiornare e sostituire l'URL del database nel codice precedente con l'URL della tua istanza PostgreSQL che corrisponde al formato specificato sopra. Se il formato dell'URL non è corretto, il codice genererà un errore.
  3. Creare un modello SQLAlchemy per il database.
    Base = base_dichiarativa()
    classeUtente(Base):
     __nometabella__ = 'utenti'
     id = Colonna (Numero intero, primary_key=VERO)
     nome = Colonna (Stringa(50))
    Base.metadata.create_all (motore)
    stampa("La tabella 'utenti' è stata creata correttamente.")
    Session = sessionmaker (motore)
    Il codice definisce un modello di dati per la tabella degli utenti. Dopo aver definito il modello, crea la tabella utilizzando il file SQLAlchemy create_all metodo che accetta il database oggetto motore di connessione come parametro. Infine, crea un'istanza di creatore di sessioni utilizzando lo stesso oggetto motore per abilitare le interazioni con il database.
  4. Infine, definisci le route API per il microservizio.
    @app.route("/api/user", metodi=["POST"])
    defcreare un utente():
     dati = richiesta.get_json()
     nome = dati["nome"]
    Tentativo:
     sessione = Sessione()
     new_user = Utente (nome=nome)
     sessione.add (nuovo_utente)
     sessione.commit()
    ritorno {"id": new_user.id, "nome": nuovo nome utente, "Messaggio": f"Utente {nome} creato."}, 201
    tranne Eccezione COME e:
     stampa(f"L'errore '{e}' si è verificato.")
    ritorno {"errore": "Si è verificato un errore durante la creazione dell'utente."}, 500
    @app.route("/api/user", metodi=["GET"])
    defget_all_users():
    Tentativo:
     sessione = Sessione()
     utenti = sessione.query (Utente).all()
    Se utenti:
     risultato = []
    per utente In utenti:
     risultato.append({"id": ID utente, "nome": utente.nome})
    ritorno jsonify (risultato)
    altro:
    ritorno jsonify({"errore": f"Utenti non trovati."}), 404
    tranne Eccezione COME e:
     stampa(f"L'errore '{e}' si è verificato.")
    ritorno {"errore": "Si è verificato un errore durante il recupero di tutti gli utenti."}, 500
    Se __nome__ == "__principale__":
     app.run (debug=VERO, ospite="0.0.0.0")

Testare il microservizio

Il codice precedente mostra un semplice microservizio di dati utente che aggiunge e recupera dati da un database PostgreSQL. Idealmente, i microservizi rispecchiano il Architettura dell'API REST poiché consente un approccio flessibile alla creazione di servizi Web, questa architettura si adatta bene al modello di progettazione dei microservizi.

Tuttavia, è importante notare che i microservizi possono usare anche altri tipi di approcci di progettazione e protocolli di comunicazione, a seconda delle esigenze specifiche del sistema.

Per testare il servizio, avvia il server di sviluppo e vai su Postman per effettuare richieste HTTP agli endpoint definiti.

flask --esecuzione del servizio app

In Postman, effettua una richiesta POST per aggiungere dati utente.

Containerizzazione dei microservizi con Docker

Docker raggruppa le applicazioni e le relative dipendenze nei contenitori. Questo approccio semplifica lo sviluppo, la distribuzione e la gestione dei microservizi in un ambiente di produzione poiché ogni servizio può operare in modo indipendente e comunicare con altri servizi utilizzando la comunicazione configurata protocollo.

Prima di iniziare, devi prima installare Docker seguendo i passaggi sul file Sito web Docker. Quindi, crea un'immagine Docker da un Dockerfile che contiene le istruzioni necessarie per configurare le dipendenze richieste per eseguire l'applicazione in un contenitore.

  1. Crea un Dockerfile nella directory principale della cartella del progetto e aggiungi queste istruzioni:
    DA pitone:3.9-alpino
    WORKDIR /app
    COPIA requisiti.txt ./
    CORRERE pip install -r requisiti.txt
    COPIA. .
    ESPORRE5000
    cmd ["pitone", "./servizio.py"]
  2. Esegui, il comando seguente per creare l'immagine Docker.
     docker build -t pallone-microservizio .
  3. Infine, esegui il contenitore Docker.
    docker run -p 5000:5000 pallone-microservizio

Questo avvierà un contenitore Docker che esegue il microservizio Flask ed esporrà la porta 5000 nel contenitore a porta 8000 sulla macchina host, consentendo di effettuare richieste HTTP dal browser Web o da Postman utilizzando il URL http://localhost: 5000.

Adozione dell'architettura dei microservizi

L'architettura dei microservizi è diventata un approccio diffuso per lo sviluppo di applicazioni software robuste e scalabili. Dividendo l'applicazione in piccoli servizi distribuibili in modo indipendente, l'architettura dei microservizi semplifica la manutenzione e la scalabilità del sistema.

Sebbene questa architettura presenti potenziali vantaggi, non è adatta a tutti i casi d'uso. In ogni caso, i requisiti di business specifici del progetto dovrebbero influenzare principalmente l'approccio progettuale adottato.