Szkolenie z Architektury Mikroserwisowej w Pythonie

Dzień 1: Podstawy Architektury Mikroserwisowej

Architektura monolityczna i mikroserwisowa

• Cechy architektury monolitycznej – wspólny model wdrożeniowy, centralizacja zależności, prostota operacyjna, ograniczenia skalowania i granice zastosowania.
• Założenia architektury mikroserwisowej oraz różnice względem monolitu modularnego – autonomiczne usługi, niezależne cykle rozwoju, izolacja danych, koszty komunikacji i złożoność operacyjna.

Przegląd wzorców architektury mikroserwisowej

• API Gateway – centralny punkt routingu, uwierzytelnianie, limity ruchu, agregacja odpowiedzi i separacja klientów od usług.
• CQRS – rozdzielenie modeli zapisu i odczytu, niezależna optymalizacja operacji, spójność danych i dodatkowa złożoność rozwiązania.
• Event Sourcing – historia zdarzeń jako źródło stanu, odtwarzanie danych, audytowalność, wersjonowanie zdarzeń i obsługa zmian schematu.
• DDD – bounded contexts, język domenowy, modele domenowe, granice odpowiedzialności oraz zgodność podziału technicznego z procesami biznesowymi.
• Wzorzec Sidecar – funkcje infrastrukturalne poza kodem usługi, telemetria, proxy sieciowe, zarządzanie konfiguracją i wpływ na zasoby środowiska.
• Scenariusze zastosowania, kompromisy i ryzyka poszczególnych wzorców – koszt implementacji, dojrzałość zespołu, wymagania jakościowe i konsekwencje operacyjne.

Granice odpowiedzialności usług

• Analiza domeny, bounded contexts, granice odpowiedzialności i identyfikacja komponentów na podstawie procesów biznesowych, danych, zależności i częstotliwości zmian.
• Laboratorium: projekt podziału monolitu na mikroserwisy z mapą kontekstów, listą usług, odpowiedzialnościami i zależnościami komunikacyjnymi.
• Przykładowa aplikacja monolityczna – funkcje biznesowe, moduły, współdzielone dane, zależności techniczne i krytyczne przepływy informacji.
• Granice odpowiedzialności na podstawie scenariuszy biznesowych, własności danych, niezależności wdrożeń i ograniczenia sprzężenia między usługami.
• Kontrakty i modele komunikacji między usługami – REST, komunikaty asynchroniczne, wersjonowanie, idempotencja, kompatybilność i obsługa błędów.

Aplikacje mikroserwisowe w języku Python

• Wzorce projektowe w Pythonie dla mikroserwisów – warstwy aplikacyjne, adaptery, repozytoria, wstrzykiwanie zależności i separacja logiki domenowej od infrastruktury.
• Frameworki API i ASGI – FastAPI, Starlette, Uvicorn oraz kryteria doboru związane z wydajnością, walidacją danych, asynchronicznością i ergonomią rozwoju.
• Szablony aplikacji, standardy repozytorium i weryfikacja kodu generowanego przy wsparciu AI – struktura projektu, konwencje, testy, przegląd bezpieczeństwa i kontrola zależności.
• Kontrakty API, OpenAPI i wersjonowanie – schematy żądań i odpowiedzi, kody błędów, kompatybilność wsteczna, dokumentacja i testy kontraktowe.
• Workery, współbieżność i procesy wieloprocesowe – zadania w tle, kolejki, izolacja procesów, obsługa obciążenia i dobór modelu wykonania.
  • Model asynchroniczny, pule wątków i ograniczenia GIL – operacje I/O, zadania obliczeniowe, event loop, blokowanie wykonania i kryteria skalowania.
  • Zarządzanie zależnościami, lockfile i powtarzalność środowisk – wersje pakietów, rozwiązywanie konfliktów, kontrola łańcucha dostaw i reprodukowalne instalacje.
  • Obsługa zdarzeń, logów i błędów – struktury komunikatów, kategorie wyjątków, korelacja żądań, ponawianie operacji i bezpieczne komunikaty diagnostyczne.
• Środowisko Python i konfiguracja warsztatu – wersja interpretera, układ projektu, narzędzia jakościowe, konfiguracja uruchomieniowa i przygotowanie usług.
  • Zarządzanie zależnościami i pakietami z użyciem plików deklaratywnych, lockfile, prywatnych repozytoriów i kontroli znanych podatności.
  • Środowiska wirtualne i ich rola w systemach kontenerowych – izolacja pakietów, zgodność wersji, budowa obrazów i eliminacja różnic między środowiskami.
  • Migracje baz danych i kompatybilność schematów – wersjonowanie zmian, migracje bez przestojów, kolejność publikacji i współistnienie wersji aplikacji.

Dzień 2: Migracja i Podstawy Orkiestracji

Proces migracji z monolitu do mikroserwisów

• Etapy migracji: analiza stanu obecnego, wybór obszaru pilotażowego, zabezpieczenie kontraktów, stopniowa dekompozycja i kontrola ryzyka.
  • Automatyzacja testów i charakterystyka kontraktów – testy regresji, testy integracyjne, zachowanie istniejących interfejsów i mierzalne kryteria akceptacji.
  • Środowiska wdrożeniowe: planowane, tymczasowe i odtwarzalne – konfiguracja, dane testowe, automatyczne tworzenie zasobów i spójność między etapami procesu.
  • Granice usług i dekompozycja monolitu – zależności funkcjonalne, własność danych, wzorzec Strangler Fig i etapowe przenoszenie odpowiedzialności.
  • Struktura repozytoriów i optymalizacja pod CI/CD – mono-repo, multi-repo, wspólne biblioteki, wersjonowanie i niezależne pipeline’y usług.
  • Modele wdrożeń dla stref publicznych, prywatnych i DMZ – segmentacja sieci, przepływy ruchu, ekspozycja usług i wymagania bezpieczeństwa.
    • Wdrożenia przez hosty pośredniczące i kontrola dostępu – bastion host, zarządzanie poświadczeniami, rejestrowanie operacji i ograniczenie uprawnień.
    • Automatyzacja GitOps i deklaratywny stan środowisk – repozytorium jako źródło prawdy, przegląd zmian, synchronizacja konfiguracji i możliwość wycofania wersji.
• Laboratorium: walidacja migracji na podstawie usług w Pythonie z testami regresji, kontrolą kontraktów i oceną poprawności granic domenowych.
  • Funkcje monolitu jako odrębne mikroserwisy z własnymi interfejsami, konfiguracją, cyklem uruchomienia i zakresem odpowiedzialności.
  • Lokalne uruchomienie usług, testy kontraktowe i walidacja granic z analizą błędów komunikacji, zależności oraz zgodności danych.

Konteneryzacja aplikacji monolitycznej i mikroserwisowej

• Podstawy Docker i konteneryzacji oraz zasady bezpiecznych i lekkich obrazów – warstwy, cache, kontekst budowania, konfiguracja procesu i minimalizacja powierzchni ataku.
  • Typowe błędy, podatności i pułapki – niekontrolowane wersje bazowe, sekrety w obrazie, nadmiarowe uprawnienia, duży rozmiar i brak limitów zasobów.
  • Dobre praktyki: obrazy minimalne, multi-stage build i użytkownik bez uprawnień root, jednoznaczne wersje zależności oraz skanowanie artefaktów.
• Laboratorium: konteneryzacja aplikacji w Pythonie z optymalizacją warstw, konfiguracją procesu, obsługą sygnałów i kontrolą bezpieczeństwa obrazu.
  • Dockerfile dla poszczególnych komponentów mikroserwisowych z osobnymi etapami budowania, instalacją zależności i konfiguracją użytkownika aplikacyjnego.
  • Testy lokalne, health checks i analiza wpływu awarii na system – gotowość, żywotność, zależności usług, restarty i zachowanie przy utracie połączenia.

Orkiestracja przy użyciu Kubernetes

• Podstawy Kubernetes i główne zasoby: Pod, Deployment i Service – deklaratywny model, kontrolery, replikacja, aktualizacje i komunikacja sieciowa.
• Managed Kubernetes, Rancher i K3s – kryteria wyboru związane ze skalą, kosztami, odpowiedzialnością operacyjną, środowiskiem brzegowym i kompetencjami zespołu.
• Laboratorium: mikroserwisy w Kubernetes z konfiguracją wdrożeń, sieci, parametrów aplikacji, sekretów i podstawowych mechanizmów odporności.
  • Środowisko warsztatowe Kubernetes, wdrożenie i podstawowa obserwowalność usług – stan zasobów, logi kontenerów, zdarzenia klastra i diagnostyka błędów.
  • Manifesty YAML: Deployment, Service, ConfigMap, Secret oraz probes z limitami zasobów, strategiami aktualizacji i rozdzieleniem konfiguracji od obrazu.
• Metodyka GitOps i deklaratywne zarządzanie zmianą – wersjonowanie manifestów, proces akceptacji, automatyczna synchronizacja, audyt i odtwarzanie konfiguracji.

Dzień 3: Obserwowalność, CI/CD oraz „12-Factor App”

Monitoring, tracing, przetwarzanie logów i alerty

• Narzędzia: Prometheus, Grafana, OpenTelemetry i Jaeger – metryki, pulpity, śledzenie rozproszone, propagacja kontekstu i wspólny model telemetrii.
• Laboratorium: monitoring i alerty dla mikroserwisów w Kubernetes z konfiguracją źródeł danych, reguł alarmowych i scenariuszy diagnostycznych.
  • Metryki Prometheus i pulpity Grafana – liczba żądań, błędy, opóźnienia, wykorzystanie zasobów, percentyle i wizualizacja zależności między usługami.
    • Docker i automatyzacja konfiguracji z użyciem Ansible – powtarzalne środowiska, role konfiguracyjne, parametryzacja i kontrola zgodności hostów.
    • Kubernetes i deklaratywna infrastruktura z użyciem Terraform – zasoby infrastrukturalne, stan konfiguracji, moduły, plan zmian i separacja odpowiedzialności.
  • Śledzenie rozproszone, korelacja logów i eksport telemetryczny przez OTLP – trace ID, span ID, kontekst żądania, sampling i analiza ścieżki błędu.

Proces deploymentu w oparciu o CI/CD

• Zasady CI/CD dla mikroserwisów i podstawowa konfiguracja pipeline’u – niezależność usług, automatyczne testy, kontrola jakości, bezpieczeństwo i promocja artefaktów.
• Laboratorium: podstawowy pipeline CI/CD z regułami uruchamiania, cache zależności, raportami testów i kontrolą błędów procesu.
• Pipeline build–test–scan–deploy oraz kontrola jakości artefaktów – budowa obrazu, testy automatyczne, skan zależności, publikacja i wdrożenie do środowiska.
• Wersjonowanie SemVer, niezmienne obrazy i współistnienie wersji usługi – tagi, digesty, kompatybilność kontraktów, migracje danych i bezpieczne wycofanie zmiany.

Zasady „12-Factor App” w mikroserwisach

• Dwanaście zasad aplikacji mikroserwisowej – baza kodu, zależności, konfiguracja, usługi zewnętrzne, proces budowania, bezstanowość, logi i zgodność środowisk.
• Laboratorium: ocena usług względem standardu „12-Factor App” z listą niezgodności, priorytetami zmian i kryteriami akceptacji.
  • Analiza usług pod kątem konfiguracji, procesów, logów i zależności oraz separacji kodu, parametrów środowiskowych i zasobów zewnętrznych.
  • Korekty wybranych usług zgodnie ze standardem „12-Factor App” – konfiguracja środowiskowa, bezstanowe procesy, logi strumieniowe i deklaratywne zależności.