feat: LinkedIn profile search engine (Django + React + Elasticsearch + ELK)

Full-stack implementation of the Cyberyan full-stack trial task.

Backend (Django 5 / DRF)
- Normalised PostgreSQL model (Profile, Company, School, Skill, Experience,
  Education) as the source of truth, with GIN + trigram indexes.
- Self-healing CSV reader: the supplied export carries an injected watermark
  column, missing columns, rows split by broken quoting and a duplicated
  header. A signature-scored Needleman-Wunsch alignment reconstructs 284 clean
  records out of 336 physical rows; only 10 rows parse correctly without it.
- Pluggable search layer (Strategy): Elasticsearch by default, PostgreSQL
  full-text search as a fallback selected by a single environment variable.
- Keyword search with per-field boosts, fuzziness and phrase boosting, six
  faceted filters (OR within a filter, AND across filters), an experience
  range, four sort orders, highlighting and facet aggregations.
- JWT auth with rotation + blacklist, three roles, PII masking, scoped rate
  limits, a single error envelope, OpenAPI schema and health probes.

Frontend (React 18 / TypeScript / Vite)
- Debounced search with type-ahead, faceted filter panel, result cards,
  profile drawer, URL-synced search state, automatic token refresh.
- Highlight snippets rendered without dangerouslySetInnerHTML.

Infrastructure
- Hardened multi-stage images (non-root, read-only rootfs, healthchecks).
- docker-compose for the full stack plus dev and production overlays.
- ELK: structured JSON logs shipped asynchronously to Logstash, routed per
  event type, with a composable index template and a Kibana setup script.

Quality
- 61 backend tests (85% coverage), ruff/black/bandit/mypy, ESLint + tsc,
  GitHub Actions running lint, tests and both image builds.
- Persian documentation: README plus architecture, search, API, data,
  security and operations guides.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GnFo6fNaHCTAkJbfcdkqtG

backend/apps/core/views.py

@@ -0,0 +1,74 @@
+"""Operational endpoints used by Docker/Kubernetes probes and by humans."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from django.conf import settings
+from django.db import connection
+from drf_spectacular.utils import extend_schema
+from rest_framework import status
+from rest_framework.permissions import AllowAny
+from rest_framework.request import Request
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from apps.search.backends import get_search_backend
+
+
+class LivenessView(APIView):
+    """Cheap check: the process is up and can answer HTTP."""
+
+    permission_classes = [AllowAny]
+    authentication_classes: list = []
+    throttle_classes: list = []
+
+    @extend_schema(tags=["health"], responses={200: dict})
+    def get(self, request: Request) -> Response:  # noqa: ARG002
+        return Response({"status": "ok", "service": settings.SERVICE_NAME})
+
+
+class ReadinessView(APIView):
+    """
+    Deep check: verifies every dependency the API needs to serve traffic.
+
+    Returns 503 when any dependency is down so an orchestrator stops routing
+    traffic to this instance.
+    """
+
+    permission_classes = [AllowAny]
+    authentication_classes: list = []
+    throttle_classes: list = []
+
+    @extend_schema(tags=["health"], responses={200: dict, 503: dict})
+    def get(self, request: Request) -> Response:  # noqa: ARG002
+        checks: dict[str, Any] = {
+            "database": _check(_database),
+            "search": _check(_search),
+        }
+        healthy = all(c["healthy"] for c in checks.values())
+        return Response(
+            {"status": "ok" if healthy else "degraded", "checks": checks},
+            status=status.HTTP_200_OK if healthy else status.HTTP_503_SERVICE_UNAVAILABLE,
+        )
+
+
+def _check(fn) -> dict[str, Any]:  # noqa: ANN001
+    try:
+        detail = fn()
+    except Exception as exc:  # noqa: BLE001 - health checks must never raise
+        return {"healthy": False, "detail": str(exc)[:200]}
+    return {"healthy": True, "detail": detail}
+
+
+def _database() -> str:
+    with connection.cursor() as cursor:
+        cursor.execute("SELECT 1")
+        cursor.fetchone()
+    return "reachable"
+
+
+def _search() -> str:
+    backend = get_search_backend()
+    backend.ping()
+    return f"{backend.name} reachable"