Albo twoje zadanie jest małe, albo możesz je podzielić na mniejsze zadania. A małe zadanie idealnie pasuje do mikroserwisu.

Projektowanie oprogramowania jest istotną fazą w rozwoju oprogramowania. Podejście projektowe może mieć wpływ na cały projekt i sposób radzenia sobie z różnymi wymaganiami.

Deweloperzy często stosowali architekturę monolityczną, łącząc wszystkie komponenty oprogramowania w jeden moduł. Jednak takie podejście może okazać się nieefektywne, szczególnie w przypadku większych aplikacji.

Mikrousługi mają na celu rozwiązanie tych ograniczeń. Mikroserwis to mała, modułowa aplikacja, która wykonuje określone funkcje. W przeciwieństwie do aplikacji monolitycznych, mikrousługi umożliwiają niezależne wdrażanie i skalowanie. Dzięki temu są bardziej elastyczne i łatwiejsze w utrzymaniu.

Architektura mikroserwisów

Architektura mikrousług to podejście do projektowania oprogramowania, które dzieli dużą aplikację na niezależne usługi, z których każda jest zaprojektowana w celu spełnienia określonego wymagania biznesowego.

instagram viewer

Usługi te działają na dedykowanych zasobach, w tym oddzielnych instancjach baz danych i mocy obliczeniowej. W przeciwieństwie do systemów monolitycznych aplikacje mikrousługowe są luźno powiązane, co zapewnia większą elastyczność.

W systemie rozproszonym węzły serwera wdrażają i wykonują aplikacje mikrousług jako oddzielne procesów — komunikujących się ze sobą za pomocą protokołów komunikacyjnych, takich jak HTTP lub za pośrednictwem brokerów komunikatów jak RabbitMQ.

Zasadniczo takie podejście architektoniczne umożliwia usługom zachowanie niezależności od siebie przy jednoczesnym efektywnym działaniu w ramach systemu oprogramowania.

W tym samouczku przeprowadzimy Cię przez wdrożenie prostej mikrousługi użytkownika, która zarządza danymi użytkownika za pomocą Flask i PostgreSQL

Skonfiguruj bazę danych PostgreSQL

Aby rozpocząć, zainstaluj PostgreSQL. Jeśli nie masz zainstalowanego PostgreSQL, możesz się dowiedzieć jak zainstalować PostgreSQL w systemie Windows Lub jak zainstalować PostgreSQL na macOS.

Alternatywnie możesz skonfigurować a zdalna baza danych PostgreSQL instancja.

Ten przewodnik użyje bezpłatnej warstwy Rendera do skonfigurowania bazy danych PostgreSQL. Postępuj zgodnie z poniższymi instrukcjami, aby uruchomić instancję bazy danych PostgreSQL w Renderze:

  1. Udaj się do strona rendera, załóż konto i zaloguj się do swojego panel strona.
  2. Na stronie pulpitu nawigacyjnego z wyświetlonej listy usług wybierz usługę PostgreSQL.
  3. Na stronie ustawień bazy danych podaj wymagane dane i upewnij się, że wybrałeś darmowy poziom, a na koniec kliknij Utwórz bazę danych.

Możesz znaleźć kod tego projektu w this Repozytorium GitHub.

Utwórz mikrousługę Flask

  1. W swoim terminalu utwórz nowy katalog i przejdź do niego:
    mkdir flask-mikroserwis
    cd flask-mikroserwis
  2. Następnie zainstaluj wirtualna, aby stworzyć izolowane wirtualne środowisko programistyczne.
    pip zainstaluj virtualenv
  3. Stwórz wirtualne środowisko w swoim projekcie:
    wirtualna wartość venv
  4. Na koniec aktywuj środowisko wirtualne.
    # Okna: 
    .\venv\Scripts\aktywacja
    # Unix lub MacOS: 
    źródło venv/bin/aktywuj

Zainstaluj wymagane pakiety

  1. Stwórz nowy wymagania.txt plik w katalogu głównym i dodaj te pakiety:
    kolba
    psycopg2-binarny
    sqlalchemia
  2. Następnie zainstaluj pakiety.
    pip install -r wymagania.txt

Utwórz serwer Flask

W katalogu głównym utwórz nowy plik: usługa.py, oraz następujący kod:

  1. Wykonaj następujące importy:
    z kolba import Kolba, prośba, jsonify
    z sqlalchemia import create_engine, Column, Integer, String
    z sqlalchemy.orm import sesjonarz
    z sqlalchemy.ext.declarative import podstawa_deklaracyjna
    import psycopg2
  2. Utwórz instancję Flask i skonfiguruj połączenie z bazą danych.
    aplikacja = Kolba (__nazwa__)
    silnik = utwórz_silnik("postgresql+psycopg2://flask_service_fe0v_user: 4785MhjfkdjfhjfjyUx67O2Nuzjchb2MQIP@dpg-chffjfjdkgfk54d6mb7860-a.oregon-postgres.render.com/flask_service_fe0v")
    Skopiuj URL zewnętrznej bazy danych na stronie ustawień bazy danych Rendera. użyjemy SQLAlchemy utwórz_silnik metoda i Psychopg2 skonfigurować połączenie z bazą danych. Pamiętaj, aby zaktualizować i zastąpić adres URL bazy danych w powyższym kodzie adresem URL własnej instancji PostgreSQL, która odpowiada formatowi określonemu powyżej. Jeśli format adresu URL jest nieprawidłowy, kod zgłosi błąd.
  3. Utwórz model SQLAlchemy dla bazy danych.
    podstawa = deklaratywna_podstawa()
    klasaUżytkownik(Baza):
     __nazwatabeli__ = „użytkownicy”
     id = kolumna (liczba całkowita, klucz_podstawowy =PRAWDA)
     nazwa = Kolumna (String(50))
    Base.metadata.create_all (silnik)
    wydrukować("Tabela 'użytkownicy' została utworzona pomyślnie.")
    Sesja = twórca sesji (silnik)
    Kod definiuje model danych dla tabeli użytkowników. Po zdefiniowaniu modelu tworzy tabelę za pomocą SQLAlchemy utwórz_wszystko Metoda pobierająca bazę danych obiekt silnika połączenia jako parametr. Na koniec tworzy instancję pliku twórca sesji używając tego samego obiektu silnika, aby umożliwić interakcje z bazą danych.
  4. Na koniec zdefiniuj trasy interfejsu API dla mikrousługi.
    @app.route("/api/user", metody=["POST"])
    pokStwórz użytkownika():
     dane = żądanie.get_json()
     nazwa = dane["nazwa"]
    próbować:
     sesja = sesja()
     nowy_użytkownik = Użytkownik (nazwa=nazwa)
     sesja.add (nowy_użytkownik)
     sesja.zatwierdzenie()
    powrót {"ID": nowy_użytkownik.id, "nazwa": Nowa nazwa użytkownika, "wiadomość": f"Użytkownik {nazwa} Utworzony."}, 201
    z wyjątkiem Wyjątek Jak mi:
     wydrukować(f"Błąd '{mi}' wystąpił.")
    powrót {"błąd": „Wystąpił błąd podczas tworzenia użytkownika”.}, 500
    @app.route("/api/user", metody=["GET"])
    pokget_all_users():
    próbować:
     sesja = sesja()
     użytkownicy = sesja.zapytanie (użytkownik).all()
    Jeśli użytkownicy:
     wynik = []
    Do użytkownik W użytkownicy:
     wynik.dołącz({"ID": identyfikator użytkownika, "nazwa": nazwa użytkownika})
    powrót jsonify (wynik)
    w przeciwnym razie:
    powrót jsonify({"błąd": f"Nie znaleziono użytkowników."}), 404
    z wyjątkiem Wyjątek Jak mi:
     wydrukować(f"Błąd '{mi}' wystąpił.")
    powrót {"błąd": „Wystąpił błąd podczas pobierania wszystkich użytkowników”.}, 500
    Jeśli __nazwa__ == "__główny__":
     app.run (debugowanie=PRAWDA, host="0.0.0.0")

Przetestuj mikroserwis

Powyższy kod demonstruje prostą mikrousługę danych użytkownika, która dodaje i pobiera dane z bazy danych PostgreSQL. Idealnie, mikrousługi odzwierciedlają Architektura REST API ponieważ pozwala na elastyczne podejście do budowania usług sieciowych – ta architektura dobrze wpisuje się w wzorce projektowe mikroserwisów.

Należy jednak pamiętać, że mikrousługi mogą również korzystać z innych typów metod projektowania i protokołów komunikacyjnych, w zależności od konkretnych potrzeb systemu.

Aby przetestować usługę, uruchom serwer programistyczny i przejdź do Postmana, aby wysyłać żądania HTTP do zdefiniowanych punktów końcowych.

kolba -- uruchomienie usługi aplikacji

W Postman wykonaj żądanie POST, aby dodać dane użytkownika.

Konteneryzacja mikroserwisów za pomocą Dockera

Docker łączy aplikacje i ich zależności w kontenerach. Takie podejście usprawnia opracowywanie, wdrażanie i zarządzanie mikrousługami w środowisku produkcyjnym ponieważ każda usługa może działać niezależnie i komunikować się z innymi usługami za pomocą skonfigurowanej komunikacji protokół.

Zanim zaczniesz, musisz najpierw zainstalować Dockera, postępując zgodnie z instrukcjami na Witryna Dockera. Następnie zbuduj obraz platformy Docker z pliku Docker, który zawiera niezbędne instrukcje dotyczące konfigurowania wymaganych zależności do uruchamiania aplikacji w kontenerze.

  1. Utwórz plik Dockerfile w katalogu głównym folderu projektu i dodaj następujące instrukcje:
    Z pyton:3.9-alpejski
    KIEROW.ROB /app
    KOPIUJ wymagania.txt ./
    URUCHOMIĆ pip install -r wymagania.txt
    KOPIUJ. .
    UJAWNIĆ5000
    CMD ["pyton", "./usługa.py"]
  2. Uruchom poniższe polecenie, aby zbudować obraz platformy Docker.
     docker build -t flask-microservice .
  3. Na koniec uruchom kontener Docker.
    docker run -p 5000:5000 kolba-mikroserwis

Spowoduje to uruchomienie kontenera platformy Docker z mikrousługą Flask i udostępnienie portu 5000 w kontenerze port 8000 na maszynie hosta, umożliwiając wysyłanie żądań HTTP z przeglądarki internetowej lub programu Postman za pomocą Adres URL http://localhost: 5000.

Przyjęcie architektury mikrousług

Architektura mikrousług stała się popularnym podejściem do tworzenia skalowalnych i solidnych aplikacji. Dzieląc aplikację na małe, niezależnie wdrażane usługi, architektura mikrousług ułatwia utrzymanie i skalowanie systemu.

Chociaż ta architektura ma potencjalne zalety, nie jest odpowiednia dla niektórych przypadków użycia. W każdym przypadku na przyjęte podejście projektowe powinny przede wszystkim wpływać specyfika wymagań biznesowych projektu.