Automatyczna zmiana: 1752257920

.jenkins/Jenkinsfile

@@ -0,0 +1,92 @@
+pipeline {
+    agent {
+        kubernetes {
+            yamlFile '.jenkins/podTemplate.yaml'
+        }
+    }
+
+    environment {
+        ACR_NAME = 'marcin00'
+        CLIENT_ID = 'c302726f-fafb-4143-94c1-67a70975574a'
+        DOCKER_REGISTRY_URL = 'marcin00.azurecr.io'
+        DOCKER_IMAGE = "${DOCKER_REGISTRY_URL}/user-microservice:${GIT_COMMIT}"
+        DEPLOY_REPO = 'ssh://[email protected]:20343/pikram/user-microservice-deploy.git'
+    }
+
+    stages {
+        stage('Code Tests') {
+            steps {
+                container('python') {
+                    dir('api') {
+                        sh '''
+                            python3 -m venv env
+                            source env/bin/activate
+                            pip install -r requirements.txt pytest
+                            python3 -m pytest --junit-xml=pytest_junit.xml
+                        '''
+                    }
+                }
+            }
+            post {
+                always {
+                    junit testResults: '**/*pytest_junit.xml'
+                }
+            }
+        }
+
+        stage('Build & Push Docker') {
+            steps {
+                container('docker') {
+                    sh '''
+                        docker build -t ${DOCKER_IMAGE} --build-arg APP_VERSION=${GIT_COMMIT} --build-arg BUILD_DATE=$(date -u +"%Y-%m-%dT%H:%M:%SZ") .
+                        az login --identity --client-id ${CLIENT_ID}
+                        az acr login --name ${ACR_NAME}
+                        docker push ${DOCKER_IMAGE}
+                    '''
+                }
+            }
+        }
+        stage('Commit new version to GitOps repo') {
+            steps {
+                container('git') {
+                    withCredentials([string(credentialsId: 'gitea-known-host', variable: 'GITEA_KNOWN_HOST')]) {
+                        sh '''
+                            mkdir -p ~/.ssh
+                            echo "$GITEA_KNOWN_HOST" >> ~/.ssh/known_hosts
+                            chmod 644 ~/.ssh/known_hosts
+
+                            git config --global user.name "jenkins[bot]"
+                            git config --global user.email "[email protected]"
+                        '''
+                        sshagent(['gitea-deploy-key']) {
+                            sh 'git clone ${DEPLOY_REPO} --branch fluxcd'
+                        }
+                    }
+                    sh '''
+                        cd user-microservice-deploy/apps/user-microservice
+                        # Podmień tag obrazu w pliku deploy.yaml
+                        awk -v commit="$GIT_COMMIT" '
+                        $0 ~ /name:[[:space:]]*api/ { in_api_container = 1; print; next }
+                        in_api_container && $0 ~ /^[[:space:]]*image:[[:space:]]*/ {
+                            sub(/:[^:[:space:]]+$/, ":" commit)
+                            in_api_container = 0
+                            print
+                            next
+                        }
+                        { print }
+                        ' deploy.yaml > deploy.tmp && mv deploy.tmp deploy.yaml
+                        '''
+
+                    sshagent(['gitea-deploy-key']) {
+                        sh '''
+                            cd user-microservice-deploy/apps/user-microservice
+                            git add deploy.yaml
+                            git diff-index --quiet HEAD || git commit -m "JENKINS: Changed deployed version to $GIT_COMMIT"
+                            git push origin fluxcd
+                        '''
+                    }
+                }
+            }
+        }
+    }
+}

.jenkins/podTemplate.yaml

@@ -0,0 +1,60 @@
+apiVersion: v1
+kind: Pod
+metadata:
+  annotations:
+    io.kubernetes.cri-o.userns-mode: "auto:size=65536"
+  labels:
+    jenkins: "slave"
+    jenkins/label: "kubernetes-agent"
+spec:
+  runtimeClassName: sysbox-runc
+  containers:
+    - name: jnlp
+      image: jenkins/inbound-agent:alpine
+      tty: false
+      workingDir: /home/jenkins/agent
+      volumeMounts:
+        - name: workspace-volume
+          mountPath: /home/jenkins/agent
+      env:
+        - name: JENKINS_WEB_SOCKET
+          value: "true"
+        - name: REMOTING_OPTS
+          value: "-noReconnectAfter 1d"
+
+    - name: python
+      image: python:3.11.7-alpine
+      command:
+        - cat
+      tty: true
+      workingDir: /home/jenkins/agent
+      volumeMounts:
+        - name: workspace-volume
+          mountPath: /home/jenkins/agent
+
+    - name: docker
+      image: marcin00.azurecr.io/azure-cli-docker:slim-bookworm
+      tty: true
+      workingDir: /home/jenkins/agent
+      volumeMounts:
+        - name: workspace-volume
+          mountPath: /home/jenkins/agent
+
+    - name: git
+      image: alpine/git:latest
+      command:
+        - cat
+      tty: true
+      workingDir: /home/jenkins/agent
+      volumeMounts:
+        - name: workspace-volume
+          mountPath: /home/jenkins/agent
+
+  nodeSelector:
+    kubernetes.io/os: linux
+
+  restartPolicy: Never
+
+  volumes:
+    - name: workspace-volume
+      emptyDir: {}

Dockerfile

@@ -1,5 +1,18 @@
-FROM python:3.11.7-slim-bookworm
+FROM python:3.11.7-alpine
+
+# Wersja i data builda jako build-arg
+ARG APP_VERSION=unknown
+ARG BUILD_DATE=unknown
+
+# Ustawiamy zmienne w ENV, by były dostępne w kontenerze
+ENV APP_VERSION=$APP_VERSION
+ENV BUILD_DATE=$BUILD_DATE
+
 WORKDIR /app
+
 COPY api .
+
+RUN apk add --no-cache curl
 RUN pip install -r requirements.txt
+
 CMD python3 app.py

README.md

@@ -1,353 +0,0 @@
-# user-microservice
-
-Mikroserwis REST do zarządzania kontami użytkowników, zbudowany w celu **porównania
-narzędzi CI/CD do automatycznego budowania i wdrażania aplikacji skonteneryzowanych**.
-Projekt powstał w ramach pracy magisterskiej.
-
-To repozytorium zawiera **kod aplikacji** oraz **potoki CI** (budowanie, testy, publikacja
-obrazu, aktualizacja repozytorium GitOps). Manifesty Kubernetes i konfiguracje narzędzi CD
-znajdują się w drugim repozytorium: **[`user-microservice-deploy`](../user-microservice-deploy)**.
-
----
-
-## Spis treści
-
-- [Cel projektu](#cel-projektu)
-- [Architektura rozwiązania](#architektura-rozwiązania)
-- [Porównywane narzędzia (5)](#porównywane-narzędzia-5)
-- [Scenariusze pomiarowe](#scenariusze-pomiarowe)
-- [Mapa branchy](#mapa-branchy)
-- [Aplikacja](#aplikacja)
-  - [Stos technologiczny](#stos-technologiczny)
-  - [API](#api)
-  - [Model danych](#model-danych)
-  - [Konfiguracja (zmienne środowiskowe)](#konfiguracja-zmienne-środowiskowe)
-  - [Uruchomienie lokalne](#uruchomienie-lokalne)
-  - [Testy](#testy)
-- [Potoki CI](#potoki-ci)
-  - [Jenkins](#jenkins)
-  - [Woodpecker CI](#woodpecker-ci)
-  - [Argo Workflows](#argo-workflows)
-  - [Wspólny schemat potoku CI](#wspólny-schemat-potoku-ci)
-- [Infrastruktura](#infrastruktura)
-- [Pomiar dostarczenia zmiany](#pomiar-dostarczenia-zmiany)
-- [Struktura repozytorium](#struktura-repozytorium)
-
----
-
-## Cel projektu
-
-Zaprojektowano jednolity proces CI/CD (build → test → publikacja obrazu → wdrożenie na
-Kubernetes) i zaimplementowano go w **pięciu narzędziach**, a następnie **zmierzono czas
-dostarczenia zmiany** (od commita do działającej aplikacji) dla różnych kombinacji narzędzi
-CI i CD. Celem była obiektywna, ilościowa i jakościowa charakterystyka tych narzędzi.
-
-Proces jest identyczny funkcjonalnie w każdym narzędziu:
-
-1. Uruchomienie po zdarzeniu `push` do repozytorium aplikacji.
-2. Uruchomienie testów jednostkowych (`pytest`).
-3. Zbudowanie obrazu kontenera i opublikowanie go w rejestrze (Azure Container Registry),
-   z tagiem równym SHA commita.
-4. Zaktualizowanie manifestu wdrożenia w repozytorium GitOps (`user-microservice-deploy`) —
-   podmiana taga obrazu na nowy SHA.
-5. Wdrożenie nowej wersji na klaster Kubernetes (Azure AKS) przez narzędzie CD.
-
-## Architektura rozwiązania
-
-```
-        ┌──────────────────────────┐         push          ┌───────────────────────────┐
-        │  user-microservice (Git) │ ────────────────────▶ │        Potok CI           │
-        │  kod aplikacji + potoki  │                       │  Jenkins / Woodpecker /   │
-        └──────────────────────────┘                       │      Argo Workflows       │
-                                                            └────────────┬──────────────┘
-                                                                         │
-                          ┌──────────────────────────────────┬──────────┴───────┐
-                          │ 1. pytest                         │                  │
-                          │ 2. docker build + push            ▼                  ▼
-                          │                       ┌────────────────────┐  ┌───────────────┐
-                          │                       │  Azure Container   │  │  commit taga  │
-                          │                       │  Registry (ACR)    │  │  do repo      │
-                          │                       └────────────────────┘  │  GitOps       │
-                          │                                                └───────┬───────┘
-                          ▼                                                        │
-                                                                                   ▼
-        ┌──────────────────────────┐        obserwuje / webhook       ┌───────────────────────────┐
-        │ user-microservice-deploy │ ◀──────────────────────────────▶│         Potok CD          │
-        │  manifesty K8s (GitOps)  │                                  │  kubectl / ArgoCD / Flux  │
-        └──────────────────────────┘                                  └────────────┬──────────────┘
-                                                                                    │ apply / sync
-                                                                                    ▼
-                                                                        ┌───────────────────────────┐
-                                                                        │   Azure Kubernetes (AKS)  │
-                                                                        │   namespace: user-...     │
-                                                                        └───────────────────────────┘
-```
-
-## Porównywane narzędzia (5)
-
-| Rola | Narzędzie | Model działania |
-|------|-----------|-----------------|
-| **CI** (build/test/push) | **Jenkins** | Potok deklaratywny (`Jenkinsfile`), agent w Kubernetes (pod z wieloma kontenerami) |
-| **CI** | **Woodpecker CI** | Potok YAML (`.woodpecker/build.yaml`), backend Kubernetes |
-| **CI** | **Argo Workflows** | Sterowany zdarzeniami (Argo Events: `EventSource` + `Sensor` → `Workflow`) |
-| **CD** (deploy) | **ArgoCD** | GitOps typu *pull* — synchronizuje stan klastra z repo deploymentowym |
-| **CD** | **FluxCD** | GitOps typu *pull* — `GitRepository` + `Kustomization` + `Receiver` |
-
-Dodatkowo każde narzędzie CI potrafi też pełnić rolę CD w wariancie „to samo narzędzie":
-wdrożenie realizowane jest wtedy imperatywnie przez `kubectl apply` (potok wyzwalany
-commitem do repo GitOps).
-
-## Scenariusze pomiarowe
-
-Pełna macierz to **3 narzędzia CI × 3 warianty CD = 9 scenariuszy**:
-
-| # | CI | CD |
-|---|----|----|
-| Scenariusz 1 | Jenkins | Jenkins (`kubectl apply`) |
-| Scenariusz 2 | Jenkins | ArgoCD |
-| Scenariusz 3 | Jenkins | FluxCD |
-| Scenariusz 4 | Woodpecker | Woodpecker (`kubectl apply`) |
-| Scenariusz 5 | Woodpecker | ArgoCD |
-| Scenariusz 6 | Woodpecker | FluxCD |
-| Scenariusz 7 | Argo Workflows | Argo Workflows |
-| Scenariusz 8 | Argo Workflows | ArgoCD |
-| Scenariusz 9 | Argo Workflows | FluxCD |
-
-> Scenariusze 1–3 obejmują Jenkinsa, 4–6 Woodpeckera, a 7–9 Argo Workflows — w każdej trójce
-> kolejno: to samo narzędzie do CD, ArgoCD oraz FluxCD.
-
-## Mapa branchy
-
-Każda kombinacja narzędzi ma osobny branch — w obu repozytoriach. Poniżej odwzorowanie
-scenariuszy na branche.
-
-**Repozytorium aplikacji (`user-microservice`) — definicje CI:**
-
-| Branch | Zawartość |
-|--------|-----------|
-| `main` | Kod aplikacji (bazowy), ten README, skrypty analizy |
-| `dev` | Gałąź rozwojowa aplikacji + narzędzia pomiarowe (`deployment_timer.sh`, `data_analysis.py`) |
-| `jenkins-pipeline` | CI w Jenkins (`.jenkins/Jenkinsfile`, `podTemplate.yaml`) |
-| `woodpecker` | CI w Woodpecker (`.woodpecker/build.yaml`) |
-| `argo-workflows` | CI w Argo Workflows / Argo Events (`argo-workflows/*`) |
-| `jenkins-fluxcd`, `woodpecker-argocd`, `woodpecker-fluxcd`, `argoworkflow-argocd`, `argoworkflow-fluxcd` | Warianty CI dostrojone do konkretnego narzędzia CD (np. docelowy branch repo GitOps) |
-
-**Repozytorium deploymentowe (`user-microservice-deploy`) — manifesty i CD:**
-
-| Branch | Scenariusz |
-|--------|-----------|
-| `master` | Baza manifestów |
-| `jenkins-kubernetes` | Sc 1 — Jenkins wdraża przez `kubectl` |
-| `jenkins-argocd-deploy` | Sc 2 — ArgoCD |
-| `jenkins-fluxcd-deploy` | Sc 3 — FluxCD |
-| `woodpecker-deploy` | Sc 4 — Woodpecker wdraża przez `kubectl` |
-| `woodpecker-argocd-deploy` | Sc 5 — ArgoCD |
-| `woodpecker-fluxcd-deploy` | Sc 6 — FluxCD |
-| `argo-deploy` | Sc 7 — Argo Workflows |
-| `argoworkflow-argocd` | Sc 8 — ArgoCD |
-| `argoworkflow-fluxcd` / `fluxcd` | Sc 9 — FluxCD |
-
-> Uwaga: warianty FluxCD używają układu katalogów `apps/` + `clusters/prod/` wymaganego przez
-> Flux, pozostałe warianty trzymają manifesty w katalogu głównym repo GitOps.
-
----
-
-## Aplikacja
-
-Mikroserwis udostępnia API REST do zarządzania kontami użytkowników wraz z uwierzytelnianiem
-JWT (tokeny w ciasteczkach), rolami oraz mechanizmem wylogowania (unieważnianie tokenów).
-
-### Stos technologiczny
-
-- **Python 3.11**, **Flask 3**
-- **Flask-JWT-Extended** — uwierzytelnianie JWT
-- **Flask-SQLAlchemy / SQLAlchemy 2** — ORM
-- **MySQL** (produkcyjnie), **SQLite in-memory** (testy)
-- **waitress** — produkcyjny serwer WSGI
-- **pytest** — testy jednostkowe
-- **Docker** — konteneryzacja (obraz bazowy `python:3.11.7-slim-bookworm`)
-
-### API
-
-| Metoda | Ścieżka | Opis | Autoryzacja |
-|--------|---------|------|-------------|
-| `POST` | `/users` | Utworzenie użytkownika | brak (konto `Administrator` wymaga tokena admina) |
-| `GET` | `/users` | Lista wszystkich użytkowników | tylko `Administrator` |
-| `GET` | `/users/<id>` | Szczegóły użytkownika | właściciel lub `Administrator` |
-| `PUT`/`PATCH` | `/users/<id>` | Edycja użytkownika (`PUT` wymaga wszystkich pól) | właściciel lub `Administrator` |
-| `DELETE` | `/users/<id>` | Usunięcie użytkownika | właściciel lub `Administrator` |
-| `POST` | `/login` | Logowanie, ustawia token JWT w ciasteczku | brak |
-| `GET` | `/logout` | Wylogowanie (unieważnienie tokena) | zalogowany |
-| `GET` | `/health` | Sprawdzenie stanu aplikacji i połączenia z bazą | brak *(dostępne na branchach z potokami CI/CD)* |
-| `GET` | `/version` | Zwraca wdrożoną wersję (`APP_VERSION` = SHA commita) i czas budowy | brak *(dostępne na branchach z potokami CI/CD)* |
-
-Przy pierwszym uruchomieniu, jeśli baza jest pusta, tworzone jest domyślne konto administratora
-(zob. zmienne `ADMIN_*`).
-
-### Model danych
-
-- **`User`** — `id`, `username` (unikalny), `email` (unikalny), `role` (`Administrator`/`User`),
-  `password` (hash).
-- **`RevokedToken`** — `jti` unieważnionych tokenów JWT (blocklist przy wylogowaniu).
-
-### Konfiguracja (zmienne środowiskowe)
-
-| Zmienna | Opis | Domyślna |
-|---------|------|----------|
-| `SQLALCHEMY_DATABASE_URI` | Połączenie do bazy MySQL | — (wymagana poza testami) |
-| `JWT_SECRET_KEY` | Klucz podpisujący tokeny JWT | `changeme` |
-| `APP_PORT` | Port serwera | `80` |
-| `ADMIN_USERNAME` | Login domyślnego admina | `admin` |
-| `ADMIN_EMAIL` | E-mail domyślnego admina | `[email protected]` |
-| `ADMIN_PASSWORD` | Hasło domyślnego admina | `admin` |
-
-Produkcyjnie sekrety (`SQLALCHEMY_DATABASE_URI`, hasła MySQL) są dostarczane z **Azure Key
-Vault** przez sterownik CSI `secrets-store` — zob. repozytorium deploymentowe.
-
-### Uruchomienie lokalne
-
-Za pomocą Docker Compose (uruchamia API + MySQL):
-
-```bash
-# przygotuj pliki api/.env oraz db/.env ze zmiennymi środowiskowymi
-docker compose up --build
-```
-
-Bez konteneryzacji:
-
-```bash
-cd api
-python3 -m venv env && source env/bin/activate
-pip install -r requirements.txt
-python3 app.py
-```
-
-Aplikacja czeka na gotowość bazy danych przy starcie (`wait_for_db`, do 100 prób co 3 s).
-
-### Testy
-
-```bash
-cd api
-python3 -m venv env && source env/bin/activate
-pip install -r requirements.txt pytest
-python3 -m pytest
-```
-
-Testy używają bazy SQLite w pamięci (konfiguracja `testing`) i pokrywają operacje CRUD oraz
-uwierzytelnianie. Ten sam zestaw testów jest uruchamiany w każdym potoku CI.
-
-> Wcześniejsze wersje potoków korzystały dodatkowo z testów kontenera **Goss** — zostały one
-> ostatecznie usunięte z potoków (por. historia commitów), a walidację przejęły testy
-> `pytest` oraz health check po wdrożeniu.
-
----
-
-## Potoki CI
-
-Definicje potoków znajdują się na branchach poszczególnych narzędzi. Wszystkie realizują ten
-sam trzyetapowy proces: **testy → build&push → commit do GitOps**.
-
-### Jenkins
-
-Branch `jenkins-pipeline`, plik `.jenkins/Jenkinsfile`. Potok deklaratywny uruchamiany na
-**agencie w Kubernetes** — pod z osobnymi kontenerami do każdego etapu (`podTemplate.yaml`):
-
-- `python` — uruchomienie `pytest` (wyniki jako JUnit XML),
-- `docker` — `docker build` + logowanie do ACR (Azure managed identity) + `docker push`,
-- `git` — sklonowanie repo GitOps, podmiana taga obrazu (`awk`) i commit na branch
-  `jenkins-kubernetes`.
-
-Build kontenera działa bez uprawnień roota dzięki **sysbox** (`runtimeClassName: sysbox-runc`).
-
-### Woodpecker CI
-
-Branch `woodpecker`, plik `.woodpecker/build.yaml`. Trzy kroki (`code-tests`,
-`build-and-push`, `gitops-commit`) na backendzie Kubernetes. Docker-in-Docker uruchamiany
-lokalnie (`dockerd &`) w kontenerze z sysbox. Sekrety (klucz deploy do Gitea, known hosts)
-pobierane z sekretów Woodpeckera.
-
-### Argo Workflows
-
-Branch `argo-workflows`, katalog `argo-workflows/`. Podejście **sterowane zdarzeniami** przez
-Argo Events:
-
-- `source.yaml` — `EventSource` (webhook, dwa endpointy: dla repo aplikacji i deploymentowego),
-- `sensor.yaml` — `Sensor` reagujący na push i tworzący `Workflow` budujący (etapy:
-  `checkout` → `tests` → `build-and-push-image` → `gitops-commit`),
-- `eventbus-default.yaml` — szyna zdarzeń (NATS),
-- `permissions.yaml` — `ServiceAccount` + `Role`/`RoleBinding`,
-- `secret-store.yaml` — dostęp do sekretów z Key Vault.
-
-### Wspólny schemat potoku CI
-
-Wszystkie trzy narzędzia wykonują tę samą logikę, różniąc się jedynie składnią i modelem
-uruchamiania:
-
-```
-push → [pytest] → [docker build → az acr login → docker push (tag = SHA)] → [clone repo GitOps → awk: podmiana tagu → commit → push]
-```
-
-Aktualizacja manifestu w repo GitOps jest realizowana identycznym skryptem `awk`, który
-znajduje kontener `api` i podmienia w nim tag obrazu na SHA nowego commita.
-
-## Infrastruktura
-
-| Element | Zastosowanie |
-|---------|--------------|
-| **Azure Kubernetes Service (AKS)** | Klaster docelowy; działają na nim także agenci CI oraz kontrolery CD |
-| **Azure Container Registry** (`marcin00.azurecr.io`) | Rejestr obrazów |
-| **Azure Key Vault** + CSI `secrets-store` | Dostarczanie sekretów do podów |
-| **Managed Identity** | Bezhasłowe uwierzytelnianie do ACR / AKS / Key Vault |
-| **Gitea** (self-hosted, `gitea.marcin00.pl`) | Repozytoria Git + webhooki wyzwalające potoki |
-| **sysbox** (`sysbox-runc`) | Budowanie obrazów bez uprawnień roota (rootless DinD) |
-| **NGINX Ingress** | Wystawienie aplikacji (`user-microservice.marcin00.pl`) |
-
-## Pomiar dostarczenia zmiany
-
-Metryką porównawczą jest **czas dostarczenia zmiany** — od commita do momentu, w którym nowa
-wersja aplikacji faktycznie działa na klastrze. Pomiar jest w pełni zautomatyzowany, a
-narzędzia znajdują się na branchu **`dev`**:
-
-- **[`deployment_timer.sh`](../../tree/dev/deployment_timer.sh)** — automatyczny pomiar
-  pojedynczego wdrożenia. Skrypt:
-  1. odczytuje aktualną wersję z endpointu `/version`,
-  2. zapisuje znacznik czasu do pliku, commituje go (`Automatyczna zmiana: <timestamp>`)
-     i wykonuje `git push` — co wyzwala cały łańcuch CI/CD,
-  3. odpytuje `/version` co sekundę, aż zwrócona wersja się zmieni,
-  4. zapisuje wynik (`start,koniec,czas,stara_wersja,nowa_wersja`) do pliku
-     `deployment_times.csv`.
-
-  Wykrycie zmiany opiera się na tym, że potok CI buduje obraz z `APP_VERSION` równym SHA
-  commita, a `/version` zwraca tę wartość. Commity `Automatyczna zmiana: <timestamp>` widoczne
-  w historii repozytorium pochodzą właśnie z kolejnych przebiegów tego skryptu.
-
-- **[`data_analysis.py`](../../tree/dev/data_analysis.py)** — agreguje zebrane pomiary
-  (po 20 wdrożeń na scenariusz) i generuje wykresy słupkowe średnich czasów dostarczenia do
-  katalogu `plots/`. Tworzy 6 porównań: trzy według narzędzia CI (dla każdego CD) i trzy
-  według narzędzia CD (dla każdego CI), obejmując wszystkie [9 scenariuszy](#scenariusze-pomiarowe).
-
-  ```bash
-  pip install matplotlib
-  python3 data_analysis.py   # zapisuje plots/mean_times_0..5.png
-  ```
-
-> Pliki wynikowe pomiarów (`deployment_times.csv`, katalog `plots/`) są generowane przez
-> powyższe skrypty i nie są śledzone w repozytorium.
-
-## Struktura repozytorium
-
-```
-user-microservice/
-├── api/
-│   ├── app.py               # fabryka aplikacji Flask, konfiguracja, start serwera waitress
-│   ├── views.py             # endpointy API (użytkownicy, login/logout)
-│   ├── models.py            # modele SQLAlchemy: User, RevokedToken
-│   ├── utils.py             # autoryzacja, oczekiwanie na bazę, inicjalizacja admina
-│   ├── requirements.txt     # zależności aplikacji
-│   └── tests/               # testy pytest (conftest.py, test_users.py)
-├── Dockerfile               # obraz aplikacji
-└── docker-compose.yml       # lokalne uruchomienie API + MySQL
-```
-
-> Definicje potoków CI (`Jenkinsfile`, `.woodpecker/`, `argo-workflows/`) znajdują się na
-> odpowiednich branchach — zob. [Mapa branchy](#mapa-branchy).

api/app.py

@@ -4,6 +4,7 @@ from flask_jwt_extended import JWTManager
 from jwt import ExpiredSignatureError
 from models import db, RevokedToken
 import os
+from tech_views import tech_bp
 from utils import init_db, wait_for_db
 from views import user_bp
 from werkzeug.exceptions import HTTPException
@@ -26,6 +27,7 @@ def create_app(config_name="default"):
 
     # Blueprints registration
     app.register_blueprint(user_bp)
+    app.register_blueprint(tech_bp)
 
     # Database and JWT initialization
     db.init_app(app)
@@ -53,7 +55,7 @@ def create_app(config_name="default"):
 
     # Fill database by initial values (only if we are not testing)
     with app.app_context():
-        wait_for_db()
+        wait_for_db(max_retries=100)
         db.create_all()
         if config_name != "testing":
             init_db()

api/tech_views.py

@@ -0,0 +1,20 @@
+from flask import Blueprint, jsonify
+from models import db
+from sqlalchemy import text
+from utils import db_ready
+
+# Blueprint with technical endpoints
+tech_bp = Blueprint('tech_bp', __name__)
+
+@tech_bp.route('/health', methods=['GET'])
+def health_check():
+    "Check if service works and database is functional"
+    try:
+        with db.engine.connect() as connection:
+            connection.execute(text("SELECT 1"))
+        return jsonify(status="healthy"), 200
+    except Exception:
+        if db_ready:
+            return jsonify(status="unhealthy"), 500
+        else:
+            return jsonify(status="starting"), 503

api/utils.py

@@ -3,19 +3,21 @@ from flask_jwt_extended import get_jwt_identity
 from models import User, db
 import os
 from sqlalchemy import text
-from sqlalchemy.exc import DatabaseError
+from sqlalchemy.exc import DatabaseError, InterfaceError
 import time
 from werkzeug.security import generate_password_hash
 
+db_ready = False
 
 def admin_required(user_id, message='Access denied.'):
+    "Check if common user try to make administrative action."
     user = db.session.get(User, user_id)
     if user is None or user.role != "Administrator":
         abort(403, message)
 
 
 def validate_access(owner_id, message='Access denied.'):
-    # Check if user try to access or edit resource that does not belong to them 
+    "Check if user try to access or edit resource that does not belong to them."
     logged_user_id = int(get_jwt_identity())
     logged_user_role = db.session.get(User, logged_user_id).role
     if logged_user_role != "Administrator" and logged_user_id != owner_id:
@@ -30,20 +32,18 @@ def get_user_or_404(user_id):
     return user
 
 
-MAX_RETRIES = 100
+def wait_for_db(max_retries):
-
+    "Try to connect with database <max_retries> times."
-def wait_for_db():
+    global db_ready
-    for retries in range(MAX_RETRIES):
+    for _ in range(max_retries):
         try:
             with db.engine.connect() as connection:
                 connection.execute(text("SELECT 1"))
-            print("Successfully connected with database.")
+            db_ready = True
             return
-        except DatabaseError:
+        except DatabaseError | InterfaceError:
-            print(f"Waiting for database... (retry {retries + 1})")
             time.sleep(3)
-    print("Failed to connect to database.")
+    raise Exception("Failed to connect to database.")
-    raise Exception("Database not ready after multiple retries.")
 
 
 def init_db():

api/views.py

@@ -2,6 +2,7 @@ from flask import Blueprint, jsonify, request, abort
 from flask_jwt_extended import create_access_token, set_access_cookies, jwt_required, \
 verify_jwt_in_request, get_jwt_identity, unset_jwt_cookies, get_jwt
 from models import db, RevokedToken, User
+import os
 from utils import admin_required, validate_access, get_user_or_404
 from werkzeug.security import check_password_hash, generate_password_hash
 
@@ -110,3 +111,10 @@ def user_logout():
     response = jsonify({"msg": "User logged out successfully."})
     unset_jwt_cookies(response)
     return response
+
+@user_bp.route('/version', methods=['GET'])
+def version():
+    return jsonify({
+        "version": os.getenv("APP_VERSION", "unknown"),
+        "build_time": os.getenv("BUILD_DATE", "unknown")
+    })

deployment_timer.sh

@@ -0,0 +1,65 @@
+#!/bin/bash
+
+# === KONFIGURACJA ===
+APP_URL="https://user-microservice.marcin00.pl/version"
+MARKER_FILE="version_marker.txt"
+OUTPUT_FILE="deployment_times.csv"
+CHECK_INTERVAL=1  # sekundy
+
+# === POBRANIE AKTUALNEJ WERSJI APLIKACJI ===
+echo "[INFO] Pobieranie aktualnej wersji z /version..."
+OLD_VERSION=$(curl -s "$APP_URL" | jq -r '.version')
+
+if [[ -z "$OLD_VERSION" ]]; then
+  echo "[ERROR] Nie udało się pobrać aktualnej wersji aplikacji."
+  exit 1
+fi
+
+echo "[INFO] Aktualna wersja: $OLD_VERSION"
+
+# === Modyfikacja pliku, commit i push ===
+TIMESTAMP=$(date +%s)
+echo "$TIMESTAMP" > "$MARKER_FILE"
+
+git add "$MARKER_FILE"
+git commit -m "Automatyczna zmiana: $TIMESTAMP"
+START_TIME=$(date +%s)
+
+echo "[INFO] Wykonuję git push..."
+git push
+
+if [[ $? -ne 0 ]]; then
+  echo "[ERROR] Push nie powiódł się."
+  exit 1
+fi
+
+echo "[INFO] Oczekiwanie na wdrożenie nowej wersji..."
+
+# === Odpytywanie endpointa /version ===
+WAITED=0
+echo "[WAIT] Oczekiwanie na nową wersję..."
+
+while true; do
+  sleep $CHECK_INTERVAL
+  WAITED=$((WAITED + CHECK_INTERVAL))
+
+  NEW_VERSION=$(curl -s "$APP_URL" | jq -r '.version')
+
+  if [[ "$NEW_VERSION" != "$OLD_VERSION" ]]; then
+    END_TIME=$(date +%s)
+    DURATION=$((END_TIME - START_TIME))
+
+    # Nadpisujemy linię z licznikiem
+    printf "\r[INFO] Nowa wersja wdrożona po %ds: %s\n" "$WAITED" "$NEW_VERSION"
+    echo "[INFO] Czas wdrożenia: $DURATION sekund"
+
+    echo "$START_TIME,$END_TIME,$DURATION,$OLD_VERSION,$NEW_VERSION" >> "$OUTPUT_FILE"
+    break
+  else
+    # Nadpisujemy TYLKO linię z licznikiem
+    printf "\r[WAIT] Czekam... %ds" "$WAITED"
+  fi
+done
+
+# Żeby kursor przeszedł do nowej linii po zakończeniu
+echo ""

docker-compose.yml

@@ -7,9 +7,24 @@ services:
     build: .
     env_file:
       - api/.env
+    ports:
+      - 80:80
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost/health"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+      start_period: 15s
   db:
     container_name: db
     hostname: db
     image: mysql:latest
     env_file:
       - db/.env
+    ports:
+      - 3306:3306
+    healthcheck:
+      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
+      interval: 10s
+      timeout: 5s
+      retries: 5

version_marker.txt

@@ -0,0 +1 @@
+1752257920