Initial commit

manifests/nearle/atlantis-sts.yaml

@@ -0,0 +1,61 @@
+apiVersion: apps/v1
+kind: StatefulSet
+metadata:
+  name: atlantis
+  namespace: nearle
+  labels:
+    app: atlantis
+spec:
+  serviceName: "atlantis"
+  replicas: 2
+  selector:
+    matchLabels:
+      app: atlantis
+  template:
+    metadata:
+      labels:
+        app: atlantis
+    spec:
+      tolerations:
+      - key: dedicated
+        operator: Equal
+        value: apps
+        effect: NoSchedule
+      affinity:
+        nodeAffinity:
+          requiredDuringSchedulingIgnoredDuringExecution:
+            nodeSelectorTerms:
+            - matchExpressions:
+              - key: node-role.workolik/app
+                operator: In
+                values:
+                - "true"
+        podAntiAffinity:
+          preferredDuringSchedulingIgnoredDuringExecution:
+          - weight: 100
+            podAffinityTerm:
+              labelSelector:
+                matchLabels:
+                  app: atlantis
+              topologyKey: kubernetes.io/hostname
+      topologySpreadConstraints:
+      - maxSkew: 1
+        topologyKey: kubernetes.io/hostname
+        whenUnsatisfiable: ScheduleAnyway
+        labelSelector:
+          matchLabels:
+            app: atlantis
+      containers:
+      - name: backend
+        image: nearlecommerce/atlantis:v0.0.41
+        imagePullPolicy: Always
+        ports:
+        - containerPort: 3000
+        env:
+        - name: PORT
+          value: "3000"
+        envFrom:
+        - configMapRef:
+            name: nearle-config
+        - secretRef:
+            name: app-secrets

manifests/nearle/atlantis-svc.yaml

@@ -0,0 +1,16 @@
+apiVersion: v1
+kind: Service
+metadata:
+  name: atlantis
+  namespace: nearle
+  labels:
+    app: atlantis
+spec:
+  type: NodePort
+  ports:
+  - port: 80
+    targetPort: 3000
+    nodePort: 30825
+    protocol: TCP
+  selector:
+    app: atlantis

manifests/nearle/fiesta-gateway.yaml

@@ -0,0 +1,514 @@
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: fiesta-gateway-script
+  namespace: nearle
+data:
+  app.py: |
+    #!/usr/bin/env python3
+    """
+    FastAPI application with multiple endpoints that publish to NATS JetStream
+    Each endpoint corresponds to an external API that workers will forward to
+    """
+    import os
+    import json
+    import asyncio
+    from fastapi import FastAPI, HTTPException, Request, Body
+    from fastapi.responses import JSONResponse
+    from fastapi.middleware.cors import CORSMiddleware
+    from starlette.middleware.base import BaseHTTPMiddleware
+    from starlette.requests import Request as StarletteRequest
+    from starlette.responses import Response as StarletteResponse
+    from pydantic import BaseModel
+    import nats
+    import nats.errors
+
+    from prometheus_client import Counter, Histogram, generate_latest, REGISTRY
+    from starlette.responses import Response
+    import uvicorn
+    from typing import Optional, Dict, Any, List, Union
+
+    # Prometheus metrics
+    request_count = Counter('http_requests_total', 'Total HTTP requests', ['method', 'endpoint', 'status'])
+    request_duration = Histogram('http_request_duration_seconds', 'HTTP request duration', ['method', 'endpoint'])
+
+    app = FastAPI(title="NATS Backend API - Multi-Endpoint", version="1.0.0")
+
+    # Custom CORS middleware to ensure headers are always added
+    class CORSHeaderMiddleware(BaseHTTPMiddleware):
+        async def dispatch(self, request: StarletteRequest, call_next):
+            origin = request.headers.get("origin", "*")
+            response = await call_next(request)
+            response.headers["Access-Control-Allow-Origin"] = origin
+            response.headers["Access-Control-Allow-Methods"] = "GET, POST, PUT, PATCH, DELETE, OPTIONS"
+            response.headers["Access-Control-Allow-Headers"] = "*"
+            response.headers["Access-Control-Allow-Credentials"] = "false"
+            response.headers["Access-Control-Max-Age"] = "600"
+            return response
+
+    # Add custom CORS middleware first
+    app.add_middleware(CORSHeaderMiddleware)
+
+    # Also add FastAPI's CORS middleware as backup
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origin_regex=r".*",  # Match all origins
+        allow_credentials=False,
+        allow_methods=["*"],  # Allow all HTTP methods
+        allow_headers=["*"],  # Allow all headers
+        expose_headers=["*"],  # Expose all headers
+        max_age=600,
+    )
+
+    # NATS connection (will be initialized on startup)
+    nc = None
+    js = None
+
+    # Configuration
+    NATS_URL = os.getenv("NATS_URL", "nats://nats-server:4222")
+    NATS_USER = os.getenv("NATS_USER", "admin")
+    NATS_PASSWORD = os.getenv("NATS_PASSWORD", "package@321#")
+
+    # Endpoint to NATS subject mapping
+    ENDPOINT_ROUTES = {
+        "/live/api/v1/deliveries/createdeliveries": "api.v1.deliveries.createdeliveries",
+        "/live/api/v1/deliveries/updatedelivery": "api.v1.deliveries.updatedelivery",
+        "/live/api/v2/partners/createriderlog": "api.v2.partners.createriderlog",
+        "/live/api/v2/deliveries/createdeliverylog": "api.v2.deliveries.createdeliverylog",
+        "/live/api/v2/partners/createbreaklog": "api.v2.partners.createbreaklog",
+        "/live/api/v2/partners/updatebreaklog": "api.v2.partners.updatebreaklog",
+        "/live/api/v1/mob/orders/createorder": "api.v1.mob.orders.createorder",
+        "/live/api/v1/web/products/create": "api.v1.web.products.create",
+        # Customer Endpoints (Sync)
+        "/live/api/v1/mob/customers/login": "api.v1.mob.customers.login",
+        "/live/api/v1/mob/customers/create": "api.v1.mob.customers.create",
+    }
+
+    @app.on_event("startup")
+    async def startup():
+        """Initialize NATS connection on startup"""
+        global nc, js
+        try:
+            print(f"Connecting to NATS at {NATS_URL}...")
+            nc = await nats.connect(
+                servers=[NATS_URL],
+                user=NATS_USER,
+                password=NATS_PASSWORD,
+                reconnect_time_wait=2,
+                max_reconnect_attempts=10
+            )
+            js = nc.jetstream()
+            print("✅ Connected to NATS JetStream")
+            print(f"✅ Configured {len(ENDPOINT_ROUTES)} endpoint routes")
+        except Exception as e:
+            print(f"❌ Failed to connect to NATS: {e}")
+            raise
+
+    @app.on_event("shutdown")
+    async def shutdown():
+        """Close NATS connection on shutdown"""
+        global nc
+        if nc:
+            await nc.close()
+            print("NATS connection closed")
+
+    @app.options("/{full_path:path}")
+    async def options_handler(full_path: str, request: Request):
+        """Handle OPTIONS requests for CORS preflight"""
+        origin = request.headers.get("origin")
+        return JSONResponse(
+            status_code=200,
+            content={},
+            headers={
+                "Access-Control-Allow-Origin": origin if origin else "*",
+                "Access-Control-Allow-Methods": "GET, POST, PUT, PATCH, DELETE, OPTIONS",
+                "Access-Control-Allow-Headers": "*",
+                "Access-Control-Allow-Credentials": "false",
+                "Access-Control-Max-Age": "600",
+            }
+        )
+
+    @app.get("/health")
+    async def health():
+        """Health check endpoint"""
+        return {"status": "healthy", "nats_connected": nc.is_connected if nc else False}
+
+    @app.get("/ready")
+    async def ready():
+        """Readiness check endpoint"""
+        if nc and nc.is_connected:
+            return {"status": "ready"}
+        raise HTTPException(status_code=503, detail="Not ready")
+
+    async def publish_to_nats(endpoint: str, data: Union[Dict[str, Any], List[Dict[str, Any]]], request_method: str = "POST"):
+        """Publish message to NATS with endpoint metadata"""
+        payload = {
+            "endpoint": endpoint,
+            "method": request_method,
+            "data": data,
+            "received_at": int(asyncio.get_event_loop().time() * 1000),
+            "original_path": endpoint
+        }
+    
+        # Get NATS subject for this endpoint
+        subject = ENDPOINT_ROUTES.get(endpoint, "api.unknown")
+    
+        if js:
+            try:
+                ack = await js.publish(subject, json.dumps(payload).encode())
+                return ack.seq
+            except Exception as e:
+                print(f"❌ Failed to publish to NATS: {e}")
+                raise HTTPException(status_code=500, detail=f"Failed to publish message: {str(e)}")
+        else:
+            raise HTTPException(status_code=503, detail="NATS not connected")
+
+    async def publish_request_to_nats(endpoint: str, data: Dict[str, Any], request_method: str = "POST", timeout: int = 10):
+        """
+        Publish to NATS and WAIT for a reply (Request-Reply pattern).
+        Used for synchronous endpoints like Login.
+        """
+        payload = {
+            "endpoint": endpoint,
+            "method": request_method,
+            "data": data,
+            "received_at": int(asyncio.get_event_loop().time() * 1000),
+            "original_path": endpoint
+        }
+    
+        subject = ENDPOINT_ROUTES.get(endpoint, "api.unknown")
+    
+        if not js:
+            raise HTTPException(status_code=503, detail="NATS by connected")
+
+        try:
+            # Create a unique inbox for the reply
+            inbox = nc.new_inbox()
+        
+            # Subscribe to the inbox first
+            sub = await nc.subscribe(inbox, max_msgs=1)
+        
+            # Publish request with reply inbox
+            # Note: We use js.publish to ensure it goes to the Stream (Queue), but attach a reply subject
+            await js.publish(subject, json.dumps(payload).encode(), reply=inbox)
+        
+            # Wait for valid response
+            try:
+                msg = await sub.next_msg(timeout=timeout)
+                response_data = json.loads(msg.data.decode())
+                return response_data
+            except nats.errors.TimeoutError:
+                raise HTTPException(status_code=504, detail="Gateway Timeout: Upstream service did not respond in time")
+            finally:
+                await sub.unsubscribe()
+            
+        except HTTPException:
+            raise
+        except Exception as e:
+            print(f"❌ Failed to request from NATS: {e}")
+            raise HTTPException(status_code=500, detail=f"RPC Error: {str(e)}")
+
+    # Endpoint 1: Update Delivery (v1) - External API requires PUT
+    @app.put("/live/api/v1/deliveries/updatedelivery")
+    async def update_delivery_v1(data: Dict[str, Any], request: Request):
+        """Update Delivery endpoint - forwards to NATS (PUT only, as external API requires PUT)"""
+        start_time = asyncio.get_event_loop().time()
+        endpoint = "/live/api/v1/deliveries/updatedelivery"
+        method = "PUT"  # Always use PUT for this endpoint
+    
+        try:
+            message_id = await publish_to_nats(endpoint, data, method)
+            duration = asyncio.get_event_loop().time() - start_time
+            request_duration.labels(method="PUT", endpoint=endpoint).observe(duration)
+            request_count.labels(method="PUT", endpoint=endpoint, status="200").inc()
+        
+            return JSONResponse(
+                status_code=200,
+                content={"status": "accepted", "message_id": message_id, "endpoint": endpoint}
+            )
+        except HTTPException:
+            raise
+        except Exception as e:
+            request_count.labels(method="PUT", endpoint=endpoint, status="500").inc()
+            print(f"❌ Error processing {endpoint}: {e}")
+            raise HTTPException(status_code=500, detail=str(e))
+
+    # Endpoint: Create Deliveries (v1)
+    @app.post("/live/api/v1/deliveries/createdeliveries")
+    async def create_deliveries_v1(data: Union[Dict[str, Any], List[Dict[str, Any]]], request: Request):
+        """Create Deliveries endpoint - forwards payload to NATS"""
+        start_time = asyncio.get_event_loop().time()
+        endpoint = "/live/api/v1/deliveries/createdeliveries"
+        method = request.method
+    
+        try:
+            message_id = await publish_to_nats(endpoint, data, method)
+            duration = asyncio.get_event_loop().time() - start_time
+            request_duration.labels(method=method, endpoint=endpoint).observe(duration)
+            request_count.labels(method=method, endpoint=endpoint, status="200").inc()
+        
+            return JSONResponse(
+                status_code=200,
+                content={"status": "accepted", "message_id": message_id, "endpoint": endpoint}
+            )
+        except HTTPException:
+            raise
+        except Exception as e:
+            request_count.labels(method=method, endpoint=endpoint, status="500").inc()
+            print(f"❌ Error processing {endpoint}: {e}")
+            raise HTTPException(status_code=500, detail=str(e))
+
+    # Endpoint 2: Create Rider Log (v2)
+    @app.post("/live/api/v2/partners/createriderlog")
+    async def create_rider_log_v2(data: Dict[str, Any], request: Request):
+        """Create Rider Log endpoint - forwards to NATS"""
+        start_time = asyncio.get_event_loop().time()
+        endpoint = "/live/api/v2/partners/createriderlog"
+        method = request.method
+    
+        try:
+            message_id = await publish_to_nats(endpoint, data, method)
+            duration = asyncio.get_event_loop().time() - start_time
+            request_duration.labels(method=method, endpoint=endpoint).observe(duration)
+            request_count.labels(method=method, endpoint=endpoint, status="200").inc()
+        
+            return JSONResponse(
+                status_code=200,
+                content={"status": "accepted", "message_id": message_id, "endpoint": endpoint}
+            )
+        except HTTPException:
+            raise
+        except Exception as e:
+            request_count.labels(method=method, endpoint=endpoint, status="500").inc()
+            print(f"❌ Error processing {endpoint}: {e}")
+            raise HTTPException(status_code=500, detail=str(e))
+
+    # Endpoint 3: Create Delivery Log (v2)
+    @app.post("/live/api/v2/deliveries/createdeliverylog")
+    async def create_delivery_log_v2(
+        request: Request,
+        data: List[Dict[str, Any]] = Body(
+            ...,
+            example=[{
+                "logid": 0,
+                "tenantid": 1,
+                "partnerid": 44,
+                "locationid": 1,
+                "orderheaderid": 123456,
+                "deliveryid": 654321,
+                "userid": 1111,
+                "orderid": "1-20231624",
+                "orderstatus": "active",
+                "starttime": "2025-12-10 17:51:03",
+                "logdate": "2025-12-10 18:14:04",
+                "latitude": "11.0050664",
+                "longitude": "76.9508776"
+            }]
+        )
+    ):
+        """
+        Create Delivery Log endpoint - forwards to NATS.
+        Accepts either a single dict or a list of dicts to align with external API expectations.
+        """
+        start_time = asyncio.get_event_loop().time()
+        endpoint = "/live/api/v2/deliveries/createdeliverylog"
+        method = request.method
+    
+        try:
+            # Expect only a list of dicts
+            if not isinstance(data, list) or not all(isinstance(item, dict) for item in data):
+                raise HTTPException(status_code=422, detail="Body must be a list of objects")
+
+            normalized_data = data
+
+            message_id = await publish_to_nats(endpoint, normalized_data, method)
+            duration = asyncio.get_event_loop().time() - start_time
+            request_duration.labels(method=method, endpoint=endpoint).observe(duration)
+            request_count.labels(method=method, endpoint=endpoint, status="200").inc()
+        
+            return JSONResponse(
+                status_code=200,
+                content={"status": "accepted", "message_id": message_id, "endpoint": endpoint}
+            )
+        except HTTPException:
+            raise
+        except Exception as e:
+            request_count.labels(method=method, endpoint=endpoint, status="500").inc()
+            print(f"❌ Error processing {endpoint}: {e}")
+            raise HTTPException(status_code=500, detail=str(e))
+
+    # Endpoint 4: Create Break Rider Log (v2)
+    @app.post("/live/api/v2/partners/createbreaklog")
+    async def create_break_log_v2(data: Dict[str, Any], request: Request):
+        """Create Break Rider Log endpoint - forwards to NATS"""
+        start_time = asyncio.get_event_loop().time()
+        endpoint = "/live/api/v2/partners/createbreaklog"
+        method = request.method
+    
+        try:
+            message_id = await publish_to_nats(endpoint, data, method)
+            duration = asyncio.get_event_loop().time() - start_time
+            request_duration.labels(method=method, endpoint=endpoint).observe(duration)
+            request_count.labels(method=method, endpoint=endpoint, status="200").inc()
+        
+            return JSONResponse(
+                status_code=200,
+                content={"status": "accepted", "message_id": message_id, "endpoint": endpoint}
+            )
+        except HTTPException:
+            raise
+        except Exception as e:
+            request_count.labels(method=method, endpoint=endpoint, status="500").inc()
+            print(f"❌ Error processing {endpoint}: {e}")
+            raise HTTPException(status_code=500, detail=str(e))
+
+    # Endpoint 5: Update Break Rider Log (v2) - Supports both POST and PUT
+    @app.post("/live/api/v2/partners/updatebreaklog")
+    @app.put("/live/api/v2/partners/updatebreaklog")
+    async def update_break_log_v2(data: Dict[str, Any], request: Request):
+        """Update Break Rider Log endpoint - forwards to NATS"""
+        start_time = asyncio.get_event_loop().time()
+        endpoint = "/live/api/v2/partners/updatebreaklog"
+        method = request.method  # Will be POST or PUT
+    
+        try:
+            message_id = await publish_to_nats(endpoint, data, method)
+            duration = asyncio.get_event_loop().time() - start_time
+            request_duration.labels(method=method, endpoint=endpoint).observe(duration)
+            request_count.labels(method=method, endpoint=endpoint, status="200").inc()
+        
+            return JSONResponse(
+                status_code=200,
+                content={"status": "accepted", "message_id": message_id, "endpoint": endpoint}
+            )
+        except HTTPException:
+            raise
+        except Exception as e:
+            request_count.labels(method=method, endpoint=endpoint, status="500").inc()
+            print(f"❌ Error processing {endpoint}: {e}")
+            raise HTTPException(status_code=500, detail=str(e))
+
+    @app.get("/metrics")
+    async def metrics():
+        """Prometheus metrics endpoint"""
+        return Response(content=generate_latest(REGISTRY), media_type="text/plain")
+
+    @app.get("/routes")
+    async def list_routes():
+        """List all configured routes"""
+        return {
+            "routes": ENDPOINT_ROUTES,
+            "total": len(ENDPOINT_ROUTES)
+        }
+
+
+    # Endpoint 6: Create Order (Mob V1)
+    @app.post("/live/api/v1/mob/orders/createorder")
+    async def create_order_mob_v1(data: Dict[str, Any], request: Request):
+        """Create Order endpoint (Mobile) - forwards to NATS"""
+        start_time = asyncio.get_event_loop().time()
+        endpoint = "/live/api/v1/mob/orders/createorder"
+        method = request.method
+    
+        try:
+            message_id = await publish_to_nats(endpoint, data, method)
+            duration = asyncio.get_event_loop().time() - start_time
+            request_duration.labels(method=method, endpoint=endpoint).observe(duration)
+            request_count.labels(method=method, endpoint=endpoint, status="200").inc()
+        
+            return JSONResponse(
+                status_code=200,
+                content={"status": "accepted", "message_id": message_id, "endpoint": endpoint}
+            )
+        except HTTPException:
+            raise
+        except Exception as e:
+            request_count.labels(method=method, endpoint=endpoint, status="500").inc()
+            print(f"❌ Error processing {endpoint}: {e}")
+            raise HTTPException(status_code=500, detail=str(e))
+
+    # Endpoint 7: Create Product (Web V1)
+    @app.post("/live/api/v1/web/products/create")
+    async def create_product_web_v1(data: Dict[str, Any], request: Request):
+        """Create Product endpoint (Web) - forwards to NATS"""
+        start_time = asyncio.get_event_loop().time()
+        endpoint = "/live/api/v1/web/products/create"
+        method = request.method
+    
+        try:
+            message_id = await publish_to_nats(endpoint, data, method)
+            duration = asyncio.get_event_loop().time() - start_time
+            request_duration.labels(method=method, endpoint=endpoint).observe(duration)
+            request_count.labels(method=method, endpoint=endpoint, status="200").inc()
+        
+            return JSONResponse(
+                status_code=200,
+                content={"status": "accepted", "message_id": message_id, "endpoint": endpoint}
+            )
+        except HTTPException:
+            raise
+        except Exception as e:
+            request_count.labels(method=method, endpoint=endpoint, status="500").inc()
+            print(f"❌ Error processing {endpoint}: {e}")
+            raise HTTPException(status_code=500, detail=str(e))
+
+
+
+    # Endpoint 8: Customer Login (Sync Request-Reply)
+    @app.post("/live/api/v1/mob/customers/login")
+    async def customer_login(data: Dict[str, Any], request: Request):
+        """Customer Login - Waits for response from worker"""
+        start_time = asyncio.get_event_loop().time()
+        endpoint = "/live/api/v1/mob/customers/login"
+        method = request.method
+    
+        try:
+            # Wait for reply!
+            response_data = await publish_request_to_nats(endpoint, data, method)
+        
+            duration = asyncio.get_event_loop().time() - start_time
+            request_duration.labels(method=method, endpoint=endpoint).observe(duration)
+            request_count.labels(method=method, endpoint=endpoint, status="200").inc()
+        
+            # Return the actual backend response
+            return JSONResponse(
+                status_code=200,
+                content=response_data
+            )
+        except HTTPException:
+            raise
+        except Exception as e:
+            request_count.labels(method=method, endpoint=endpoint, status="500").inc()
+            print(f"❌ Error processing {endpoint}: {e}")
+            raise HTTPException(status_code=500, detail=str(e))
+
+    # Endpoint 9: Customer Create (Sync Request-Reply)
+    @app.post("/live/api/v1/mob/customers/create")
+    async def customer_create(data: Dict[str, Any], request: Request):
+        """Customer Create - Waits for response from worker"""
+        start_time = asyncio.get_event_loop().time()
+        endpoint = "/live/api/v1/mob/customers/create"
+        method = request.method
+    
+        try:
+            # Wait for reply!
+            response_data = await publish_request_to_nats(endpoint, data, method)
+        
+            duration = asyncio.get_event_loop().time() - start_time
+            request_duration.labels(method=method, endpoint=endpoint).observe(duration)
+            request_count.labels(method=method, endpoint=endpoint, status="200").inc()
+        
+            return JSONResponse(
+                status_code=200,
+                content=response_data
+            )
+        except HTTPException:
+            raise
+        except Exception as e:
+            request_count.labels(method=method, endpoint=endpoint, status="500").inc()
+            print(f"❌ Error processing {endpoint}: {e}")
+            raise HTTPException(status_code=500, detail=str(e))
+
+    if __name__ == "__main__":
+        uvicorn.run(app, host="0.0.0.0", port=8000)
+

manifests/nearle/fiesta-sts.yaml

@@ -0,0 +1,99 @@
+apiVersion: apps/v1
+kind: StatefulSet
+metadata:
+  name: fiesta
+  namespace: nearle
+  labels:
+    app: fiesta
+spec:
+  serviceName: "fiesta"
+  replicas: 3
+  selector:
+    matchLabels:
+      app: fiesta
+  template:
+    metadata:
+      labels:
+        app: fiesta
+    spec:
+      tolerations:
+      - key: dedicated
+        operator: Equal
+        value: apps
+        effect: NoSchedule
+      affinity:
+        nodeAffinity:
+          requiredDuringSchedulingIgnoredDuringExecution:
+            nodeSelectorTerms:
+            - matchExpressions:
+              - key: node-role.workolik/app
+                operator: In
+                values:
+                - "true"
+        podAntiAffinity:
+          preferredDuringSchedulingIgnoredDuringExecution:
+          - weight: 100
+            podAffinityTerm:
+              labelSelector:
+                matchLabels:
+                  app: fiesta
+              topologyKey: kubernetes.io/hostname
+      topologySpreadConstraints:
+      - maxSkew: 1
+        topologyKey: kubernetes.io/hostname
+        whenUnsatisfiable: ScheduleAnyway
+        labelSelector:
+          matchLabels:
+            app: fiesta
+      containers:
+      - name: backend
+        image: nearlecommerce/fiesta:v1.3.67
+        imagePullPolicy: Always
+        ports:
+        - containerPort: 1122
+        envFrom:
+        - configMapRef:
+            name: nearle-config
+        - secretRef:
+            name: app-secrets
+        env:
+        - name: PORT
+          value: "1122"
+        - name: NATS_USER
+          valueFrom:
+            secretKeyRef:
+              name: nats-credentials
+              key: username
+        - name: NATS_PASSWORD
+          valueFrom:
+            secretKeyRef:
+              name: nats-credentials
+              key: password
+      - name: gateway
+        image: workolik360/alaska:v1.2.0
+        imagePullPolicy: Always
+        ports:
+        - containerPort: 8000
+          name: http
+        volumeMounts:
+        - name: gateway-script
+          mountPath: /app/app.py
+          subPath: app.py
+        envFrom:
+        - configMapRef:
+            name: nearle-config
+        env:
+        - name: NATS_USER
+          valueFrom:
+            secretKeyRef:
+              name: nats-credentials
+              key: username
+        - name: NATS_PASSWORD
+          valueFrom:
+            secretKeyRef:
+              name: nats-credentials
+              key: password
+      volumes:
+      - name: gateway-script
+        configMap:
+          name: fiesta-gateway-script

manifests/nearle/fiesta-svc.yaml

@@ -0,0 +1,21 @@
+apiVersion: v1
+kind: Service
+metadata:
+  name: fiesta
+  namespace: nearle
+  labels:
+    app: fiesta
+spec:
+  type: NodePort
+  ports:
+  - port: 80
+    targetPort: 1122
+    nodePort: 30823
+    protocol: TCP
+    name: main
+  - port: 8000
+    targetPort: 8000
+    name: gateway
+    protocol: TCP
+  selector:
+    app: fiesta

manifests/nearle/jupiter-cors-proxy.yaml

@@ -0,0 +1,97 @@
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: jupiter-cors-config
+  namespace: nearle
+data:
+  nginx.conf: |
+    events {}
+    http {
+        upstream jupiter_backend {
+            server jupiter:80;
+        }
+
+        server {
+            listen 80;
+
+            location / {
+                proxy_pass http://jupiter_backend;
+                proxy_set_header Host $host;
+                proxy_set_header X-Real-IP $remote_addr;
+                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+                proxy_set_header X-Forwarded-Proto $scheme;
+
+                add_header 'Access-Control-Allow-Origin' '*' always;
+                add_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS, PUT, PATCH, DELETE' always;
+                add_header 'Access-Control-Allow-Headers' 'Content-Type, Authorization, X-Requested-With, Accept, Origin, X-Auth-Token' always;
+
+                if ($request_method = 'OPTIONS') {
+                    add_header 'Access-Control-Allow-Origin' '*';
+                    add_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS, PUT, PATCH, DELETE';
+                    add_header 'Access-Control-Allow-Headers' 'Content-Type, Authorization, X-Requested-With, Accept, Origin, X-Auth-Token';
+                    add_header 'Access-Control-Max-Age' 1728000;
+                    add_header 'Content-Type' 'text/plain; charset=utf-8';
+                    add_header 'Content-Length' 0;
+                    return 204;
+                }
+            }
+        }
+    }
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: jupiter-cors-proxy
+  namespace: nearle
+  labels:
+    app: jupiter-cors-proxy
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: jupiter-cors-proxy
+  template:
+    metadata:
+      labels:
+        app: jupiter-cors-proxy
+    spec:
+      tolerations:
+      - key: dedicated
+        operator: Equal
+        value: apps
+        effect: NoSchedule
+      containers:
+      - name: nginx
+        image: nginx:alpine
+        ports:
+        - containerPort: 80
+        volumeMounts:
+        - name: nginx-config
+          mountPath: /etc/nginx/nginx.conf
+          subPath: nginx.conf
+        resources:
+          requests:
+            memory: "32Mi"
+            cpu: "10m"
+          limits:
+            memory: "64Mi"
+            cpu: "100m"
+      volumes:
+      - name: nginx-config
+        configMap:
+          name: jupiter-cors-config
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: jupiter-cors-proxy
+  namespace: nearle
+  labels:
+    app: jupiter-cors-proxy
+spec:
+  selector:
+    app: jupiter-cors-proxy
+  ports:
+  - port: 80
+    targetPort: 80
+    protocol: TCP

manifests/nearle/jupiter-sts.yaml

@@ -0,0 +1,77 @@
+apiVersion: apps/v1
+kind: StatefulSet
+metadata:
+  name: jupiter
+  namespace: nearle
+  labels:
+    app: jupiter
+spec:
+  serviceName: "jupiter"
+  replicas: 3
+  selector:
+    matchLabels:
+      app: jupiter
+  template:
+    metadata:
+      labels:
+        app: jupiter
+    spec:
+      tolerations:
+      - key: dedicated
+        operator: Equal
+        value: apps
+        effect: NoSchedule
+      affinity:
+        nodeAffinity:
+          requiredDuringSchedulingIgnoredDuringExecution:
+            nodeSelectorTerms:
+            - matchExpressions:
+              - key: node-role.workolik/app
+                operator: In
+                values:
+                - "true"
+        podAntiAffinity:
+          preferredDuringSchedulingIgnoredDuringExecution:
+          - weight: 100
+            podAffinityTerm:
+              labelSelector:
+                matchLabels:
+                  app: jupiter
+              topologyKey: kubernetes.io/hostname
+      topologySpreadConstraints:
+      - maxSkew: 1
+        topologyKey: kubernetes.io/hostname
+        whenUnsatisfiable: ScheduleAnyway
+        labelSelector:
+          matchLabels:
+            app: jupiter
+      containers:
+      - name: jupiter
+        image: nearlecommerce/jupiter:v2.7.53
+        imagePullPolicy: Always
+        ports:
+        - containerPort: 1009
+        env:
+        - name: PORT
+          value: "1009"
+        - name: TZ
+          value: "Asia/Kolkata"
+        volumeMounts:
+        - name: tz-config
+          mountPath: /etc/localtime
+          readOnly: true
+        - name: tz-data
+          mountPath: /usr/share/zoneinfo
+          readOnly: true
+        envFrom:
+        - configMapRef:
+            name: nearle-config
+        - secretRef:
+            name: app-secrets
+      volumes:
+      - name: tz-config
+        hostPath:
+          path: /usr/share/zoneinfo/Asia/Kolkata
+      - name: tz-data
+        hostPath:
+          path: /usr/share/zoneinfo

manifests/nearle/jupiter-svc.yaml

@@ -0,0 +1,16 @@
+apiVersion: v1
+kind: Service
+metadata:
+  name: jupiter
+  namespace: nearle
+  labels:
+    app: jupiter
+spec:
+  type: NodePort
+  ports:
+  - port: 80
+    targetPort: 1009
+    nodePort: 30822
+    protocol: TCP
+  selector:
+    app: jupiter

manifests/nearle/nearle-app-secrets.yaml

@@ -0,0 +1,23 @@
+apiVersion: v1
+kind: Secret
+metadata:
+  name: app-secrets
+  namespace: nearle
+  labels:
+    app: fiesta
+type: Opaque
+stringData:
+  # The IP of your BigRock Server
+  DATABASE_HOST: "66.116.207.225"
+  DB_HOST: "66.116.207.225"
+
+  # The user we confirmed works
+  DATABASE_USERNAME: "admin"
+  DB_USER: "admin"
+  
+  # The password we confirmed works
+  DATABASE_PASSWORD: "Package@123#"
+  DB_PASSWORD: "Package@123#"
+  
+  # The rest...
+  JWT_SECRET_KEY: "nearle"

manifests/nearle/nearle-ariane.yaml

@@ -0,0 +1,99 @@
+apiVersion: apps/v1
+kind: StatefulSet
+metadata:
+  name: ariane
+  namespace: nearle
+  labels:
+    app: ariane
+spec:
+  serviceName: "ariane"
+  replicas: 3
+  selector:
+    matchLabels:
+      app: ariane
+  template:
+    metadata:
+      labels:
+        app: ariane
+    spec:
+      tolerations:
+      - key: dedicated
+        operator: Equal
+        value: apps
+        effect: NoSchedule
+      affinity:
+        nodeAffinity:
+          requiredDuringSchedulingIgnoredDuringExecution:
+            nodeSelectorTerms:
+            - matchExpressions:
+              - key: node-role.workolik/app
+                operator: In
+                values:
+                - "true"
+        podAntiAffinity:
+          preferredDuringSchedulingIgnoredDuringExecution:
+          - weight: 100
+            podAffinityTerm:
+              labelSelector:
+                matchLabels:
+                  app: ariane
+              topologyKey: kubernetes.io/hostname
+      topologySpreadConstraints:
+      - maxSkew: 1
+        topologyKey: kubernetes.io/hostname
+        whenUnsatisfiable: ScheduleAnyway
+        labelSelector:
+          matchLabels:
+            app: ariane
+      containers:
+      - name: backend
+        image: nearlecommerce/ariane:v1.0.22
+        imagePullPolicy: Always
+        ports:
+        - containerPort: 1000
+        env:
+        - name: PORT
+          value: "1000"
+        envFrom:
+        - configMapRef:
+            name: nearle-config
+        - secretRef:
+            name: app-secrets
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: ariane
+  namespace: nearle
+  labels:
+    app: ariane
+spec:
+  type: ClusterIP
+  ports:
+  - port: 80
+    targetPort: 1000
+    protocol: TCP
+  selector:
+    app: ariane
+---
+apiVersion: gateway.networking.k8s.io/v1
+kind: HTTPRoute
+metadata:
+  name: ariane-route
+  namespace: nearle
+  labels:
+    app: ariane
+spec:
+  parentRefs:
+  - name: gateway
+    namespace: alaska
+  hostnames:
+  - "ariane.nearle.app"
+  rules:
+  - matches:
+    - path:
+        type: PathPrefix
+        value: /
+    backendRefs:
+    - name: ariane
+      port: 80

manifests/nearle/nearle-atlantis.yaml

@@ -0,0 +1,100 @@
+apiVersion: apps/v1
+kind: StatefulSet
+metadata:
+  name: atlantis
+  namespace: nearle
+  labels:
+    app: atlantis
+spec:
+  serviceName: "atlantis"
+  replicas: 2
+  selector:
+    matchLabels:
+      app: atlantis
+  template:
+    metadata:
+      labels:
+        app: atlantis
+    spec:
+      tolerations:
+      - key: dedicated
+        operator: Equal
+        value: apps
+        effect: NoSchedule
+      affinity:
+        nodeAffinity:
+          requiredDuringSchedulingIgnoredDuringExecution:
+            nodeSelectorTerms:
+            - matchExpressions:
+              - key: node-role.workolik/app
+                operator: In
+                values:
+                - "true"
+        podAntiAffinity:
+          preferredDuringSchedulingIgnoredDuringExecution:
+          - weight: 100
+            podAffinityTerm:
+              labelSelector:
+                matchLabels:
+                  app: atlantis
+              topologyKey: kubernetes.io/hostname
+      topologySpreadConstraints:
+      - maxSkew: 1
+        topologyKey: kubernetes.io/hostname
+        whenUnsatisfiable: ScheduleAnyway
+        labelSelector:
+          matchLabels:
+            app: atlantis
+      containers:
+      - name: backend
+        image: nearlecommerce/atlantis:v0.0.41
+        imagePullPolicy: Always
+        ports:
+        - containerPort: 3000
+        env:
+        - name: PORT
+          value: "3000"
+        envFrom:
+        - configMapRef:
+            name: nearle-config
+        - secretRef:
+            name: app-secrets
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: atlantis
+  namespace: nearle
+  labels:
+    app: atlantis
+spec:
+  type: NodePort
+  ports:
+  - port: 80
+    targetPort: 3000
+    nodePort: 30825
+    protocol: TCP
+  selector:
+    app: atlantis
+---
+apiVersion: gateway.networking.k8s.io/v1
+kind: HTTPRoute
+metadata:
+  name: atlantis-route
+  namespace: nearle
+  labels:
+    app: atlantis
+spec:
+  parentRefs:
+  - name: gateway
+    namespace: alaska
+  hostnames:
+  - "atlantis.nearle.app"
+  rules:
+  - matches:
+    - path:
+        type: PathPrefix
+        value: /
+    backendRefs:
+    - name: atlantis
+      port: 80

manifests/nearle/nearle-config.yaml

@@ -0,0 +1,23 @@
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: nearle-config
+  namespace: nearle
+  labels:
+    app: fiesta
+data:
+  NATS_URL: "nats://66.116.226.161:4222"
+  LOG_LEVEL: "info"
+  # The stream is set to ORDERS as per your request
+  NATS_STREAM: "ORDERS"
+  # Base subject pattern - the app likely appends the path to this or uses it as a listener filter
+  NATS_SUBJECT: "api.>" 
+  ALLOWED_ORIGINS: "*"
+  ENV: "production"
+  DATABASE_NAME: "nearledb"
+  DB_NAME: "nearledb"
+  DATABASE_PORT: "5432"
+  DB_PORT: "5432"
+  DATABASE_SERVER_HOST: "66.116.207.225"
+  DB_HOST: "66.116.207.225"
+  USER_CONTEXT_KEY: "nearle"

manifests/nearle/nearle-fiesta.yaml

@@ -0,0 +1,157 @@
+apiVersion: apps/v1
+kind: StatefulSet
+metadata:
+  name: fiesta
+  namespace: nearle
+  labels:
+    app: fiesta
+spec:
+  serviceName: "fiesta"
+  replicas: 3
+  selector:
+    matchLabels:
+      app: fiesta
+  template:
+    metadata:
+      labels:
+        app: fiesta
+    spec:
+      tolerations:
+      - key: dedicated
+        operator: Equal
+        value: apps
+        effect: NoSchedule
+      affinity:
+        nodeAffinity:
+          requiredDuringSchedulingIgnoredDuringExecution:
+            nodeSelectorTerms:
+            - matchExpressions:
+              - key: node-role.workolik/app
+                operator: In
+                values:
+                - "true"
+        podAntiAffinity:
+          preferredDuringSchedulingIgnoredDuringExecution:
+          - weight: 100
+            podAffinityTerm:
+              labelSelector:
+                matchLabels:
+                  app: fiesta
+              topologyKey: kubernetes.io/hostname
+      topologySpreadConstraints:
+      - maxSkew: 1
+        topologyKey: kubernetes.io/hostname
+        whenUnsatisfiable: ScheduleAnyway
+        labelSelector:
+          matchLabels:
+            app: fiesta
+      containers:
+      - name: backend
+        image: nearlecommerce/fiesta:v1.3.50
+        imagePullPolicy: Always
+        ports:
+        - containerPort: 1122
+        envFrom:
+        - configMapRef:
+            name: nearle-config
+        - secretRef:
+            name: app-secrets
+        env:
+        - name: PORT
+          value: "1122"
+        - name: NATS_USER
+          valueFrom:
+            secretKeyRef:
+              name: nats-credentials
+              key: username
+        - name: NATS_PASSWORD
+          valueFrom:
+            secretKeyRef:
+              name: nats-credentials
+              key: password
+      - name: gateway
+        image: workolik360/alaska:v1.2.0
+        imagePullPolicy: Always
+        ports:
+        - containerPort: 8000
+          name: http
+        volumeMounts:
+        - name: gateway-script
+          mountPath: /app/app.py
+          subPath: app.py
+        envFrom:
+        - configMapRef:
+            name: nearle-config
+        env:
+        - name: NATS_USER
+          valueFrom:
+            secretKeyRef:
+              name: nats-credentials
+              key: username
+        - name: NATS_PASSWORD
+          valueFrom:
+            secretKeyRef:
+              name: nats-credentials
+              key: password
+      volumes:
+      - name: gateway-script
+        configMap:
+          name: fiesta-gateway-script
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: fiesta
+  namespace: nearle
+  labels:
+    app: fiesta
+spec:
+  type: NodePort
+  ports:
+  - port: 80
+    targetPort: 1122
+    nodePort: 30823
+    protocol: TCP
+    name: main
+  - port: 8000
+    targetPort: 8000
+    name: gateway
+    protocol: TCP
+  selector:
+    app: fiesta
+---
+apiVersion: gateway.networking.k8s.io/v1
+kind: HTTPRoute
+metadata:
+  name: fiesta-route
+  namespace: nearle
+  labels:
+    app: fiesta
+spec:
+  parentRefs:
+  - name: gateway
+    namespace: alaska
+  hostnames:
+  - "fiesta.nearle.app"
+  rules:
+  - matches:
+    - path:
+        type: PathPrefix
+        value: /live/api/v1/mob/orders/createorder
+    backendRefs:
+    - name: fiesta
+      port: 8000
+  - matches:
+    - path:
+        type: PathPrefix
+        value: /live/api/v1/web/products/create
+    backendRefs:
+    - name: fiesta
+      port: 8000
+  - matches:
+    - path:
+        type: PathPrefix
+        value: /
+    backendRefs:
+    - name: fiesta
+      port: 80

manifests/nearle/nearle-gateway.yaml

@@ -0,0 +1,27 @@
+apiVersion: gateway.networking.k8s.io/v1
+kind: Gateway
+metadata:
+  name: gateway
+  namespace: nearle
+  labels:
+    app.kubernetes.io/name: gateway
+    app.kubernetes.io/part-of: nearle
+spec:
+  gatewayClassName: standard
+  listeners:
+  - name: http
+    protocol: HTTP
+    port: 8202
+    allowedRoutes:
+      namespaces:
+        from: Same
+  - name: https
+    protocol: HTTPS
+    port: 8442
+    allowedRoutes:
+      namespaces:
+        from: Same
+    tls:
+      mode: Terminate
+      certificateRefs:
+      - name: nearle-tls-cert 

manifests/nearle/nearle-jupiter.yaml

@@ -0,0 +1,94 @@
+apiVersion: apps/v1
+kind: StatefulSet
+metadata:
+  name: jupiter
+  namespace: nearle
+  labels:
+    app: jupiter
+spec:
+  serviceName: "jupiter"
+  replicas: 3
+  selector:
+    matchLabels:
+      app: jupiter
+  template:
+    metadata:
+      labels:
+        app: jupiter
+    spec:
+      tolerations:
+      - key: dedicated
+        operator: Equal
+        value: apps
+        effect: NoSchedule
+      affinity:
+        nodeAffinity:
+          requiredDuringSchedulingIgnoredDuringExecution:
+            nodeSelectorTerms:
+            - matchExpressions:
+              - key: node-role.workolik/app
+                operator: In
+                values:
+                - "true"
+        podAntiAffinity:
+          preferredDuringSchedulingIgnoredDuringExecution:
+          - weight: 100
+            podAffinityTerm:
+              labelSelector:
+                matchLabels:
+                  app: jupiter
+              topologyKey: kubernetes.io/hostname
+      topologySpreadConstraints:
+      - maxSkew: 1
+        topologyKey: kubernetes.io/hostname
+        whenUnsatisfiable: ScheduleAnyway
+        labelSelector:
+          matchLabels:
+            app: jupiter
+      containers:
+      - name: jupiter
+        image: nearlecommerce/jupiter:v2.7.31
+        imagePullPolicy: Always
+        ports:
+        - containerPort: 1009
+        env:
+        - name: PORT
+          value: "1009"
+        - name: TZ
+          value: "Asia/Kolkata"
+        volumeMounts:
+        - name: tz-config
+          mountPath: /etc/localtime
+          readOnly: true
+        - name: tz-data
+          mountPath: /usr/share/zoneinfo
+          readOnly: true
+        envFrom:
+        - configMapRef:
+            name: nearle-config
+        - secretRef:
+            name: app-secrets
+      volumes:
+      - name: tz-config
+        hostPath:
+          path: /usr/share/zoneinfo/Asia/Kolkata
+      - name: tz-data
+        hostPath:
+          path: /usr/share/zoneinfo
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: jupiter
+  namespace: nearle
+  labels:
+    app: jupiter
+spec:
+  type: NodePort
+  ports:
+  - port: 80
+    targetPort: 1009
+    nodePort: 30822
+    protocol: TCP
+  selector:
+    app: jupiter

manifests/nearle/nearle-namespace.yaml

@@ -0,0 +1,6 @@
+apiVersion: v1
+kind: Namespace
+metadata:
+  name: nearle
+  labels:
+    name: nearle

manifests/nearle/nearle-reference-grant.yaml

@@ -0,0 +1,14 @@
+apiVersion: gateway.networking.k8s.io/v1beta1
+kind: ReferenceGrant
+metadata:
+  name: allow-alaska-gateway
+  namespace: nearle
+spec:
+  from:
+  - group: gateway.networking.k8s.io
+    kind: HTTPRoute
+    namespace: alaska
+  to:
+  - group: ""
+    kind: Service
+    name: fiesta

manifests/nearle/nearle-secrets.yaml

@@ -0,0 +1,11 @@
+apiVersion: v1
+kind: Secret
+metadata:
+  name: nats-credentials
+  namespace: nearle
+  labels:
+    app: fiesta
+type: Opaque
+stringData:
+  username: admin
+  password: package@321#

manifests/nearle/nearle-titan.yaml

@@ -0,0 +1,91 @@
+apiVersion: apps/v1
+kind: StatefulSet
+metadata:
+  name: titan
+  namespace: nearle
+  labels:
+    app: titan
+spec:
+  serviceName: "titan"
+  replicas: 3
+  selector:
+    matchLabels:
+      app: titan
+  template:
+    metadata:
+      labels:
+        app: titan
+    spec:
+      tolerations:
+      - key: dedicated
+        operator: Equal
+        value: apps
+        effect: NoSchedule
+      affinity:
+        nodeAffinity:
+          requiredDuringSchedulingIgnoredDuringExecution:
+            nodeSelectorTerms:
+            - matchExpressions:
+              - key: node-role.workolik/app
+                operator: In
+                values:
+                - "true"
+        podAntiAffinity:
+          preferredDuringSchedulingIgnoredDuringExecution:
+          - weight: 100
+            podAffinityTerm:
+              labelSelector:
+                matchLabels:
+                  app: titan
+              topologyKey: kubernetes.io/hostname
+      topologySpreadConstraints:
+      - maxSkew: 1
+        topologyKey: kubernetes.io/hostname
+        whenUnsatisfiable: ScheduleAnyway
+        labelSelector:
+          matchLabels:
+            app: titan
+      containers:
+      - name: backend
+        image: groomgear/groomgear:v1.0.41
+        imagePullPolicy: Always
+        ports:
+        - containerPort: 1006
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: titan
+  namespace: nearle
+  labels:
+    app: titan
+spec:
+  type: ClusterIP
+  ports:
+  - port: 80
+    targetPort: 1006
+    protocol: TCP
+  selector:
+    app: titan
+---
+apiVersion: gateway.networking.k8s.io/v1
+kind: HTTPRoute
+metadata:
+  name: titan-route
+  namespace: nearle
+  labels:
+    app: titan
+spec:
+  parentRefs:
+  - name: gateway
+    namespace: alaska
+  hostnames:
+  - "titan.nearle.app"
+  rules:
+  - matches:
+    - path:
+        type: PathPrefix
+        value: /
+    backendRefs:
+    - name: titan
+      port: 80