Verifying the Deployment

./scripts/tools/platform-status.sh

MATIH Platform Status
=====================

Cluster: matih-aks-cluster (Azure AKS)
Kubernetes: v1.29.1

Namespaces:
  matih-system     ............ OK
  matih-shared     ............ OK
  tenant-acme-corp ............ OK

Control Plane Services:
  iam-service          2/2 pods ready .... OK
  tenant-service       2/2 pods ready .... OK
  config-service       1/1 pods ready .... OK
  api-gateway          2/2 pods ready .... OK
  notification-service 1/1 pods ready .... OK
  audit-service        1/1 pods ready .... OK

Data Plane Services (tenant-acme-corp):
  ai-service           2/2 pods ready .... OK
  query-engine         2/2 pods ready .... OK
  bi-service           1/1 pods ready .... OK
  ml-service           1/1 pods ready .... OK

Infrastructure:
  postgresql           1/1 pods ready .... OK
  redis                1/1 pods ready .... OK
  kafka                3/3 pods ready .... OK

Overall Status: HEALTHY

./scripts/disaster-recovery/health-check.sh

# Check node status
kubectl get nodes -o wide
 
# Expected: All nodes showing STATUS "Ready"
# NAME            STATUS   ROLES    AGE    VERSION
# node-pool-0     Ready    <none>   2d     v1.29.1
# node-pool-1     Ready    <none>   2d     v1.29.1
# node-pool-2     Ready    <none>   2d     v1.29.1

# Check all pods across namespaces
kubectl get pods -A --field-selector=status.phase!=Running,status.phase!=Succeeded
 
# This should return no results (no failing pods)
# If pods are failing, investigate with:
# kubectl describe pod <pod-name> -n <namespace>
# kubectl logs <pod-name> -n <namespace>

# Using port-forward (if not exposed via ingress)
kubectl port-forward svc/iam-service 8081:8081 -n matih-system &
 
# Check health
curl -s http://localhost:8081/actuator/health | jq .

{
  "status": "UP",
  "components": {
    "db": { "status": "UP" },
    "redis": { "status": "UP" },
    "kafka": { "status": "UP" },
    "diskSpace": { "status": "UP" }
  }
}

# AI Service health
curl -s http://localhost:8000/health | jq .
 
# Expected:
# {
#   "status": "healthy",
#   "version": "1.0.0",
#   "dependencies": {
#     "database": "connected",
#     "redis": "connected",
#     "kafka": "connected"
#   }
# }

# Check database pods
kubectl get pods -l app=postgresql -A
 
# Check database service
kubectl get svc -l app=postgresql -A

# Check Kafka pods
kubectl get pods -l app=kafka -A
 
# Verify topic creation (topics should exist after service deployment)
kubectl exec -it kafka-0 -n matih-shared -- \
  kafka-topics.sh --list --bootstrap-server localhost:9092

# Check ingress resources
kubectl get ingress -A
 
# Check certificate status
kubectl get certificates -A
 
# Validate tenant ingress
./scripts/tools/validate-tenant-ingress.sh --tenant acme-corp

./scripts/tools/validate-ports.sh

# Register a test user
curl -s -X POST http://localhost:8081/api/v1/auth/register \
  -H "Content-Type: application/json" \
  -d '{
    "email": "test@acme.com",
    "password": "Test@12345",
    "firstName": "Test",
    "lastName": "User"
  }' | jq .status
 
# Login
curl -s -X POST http://localhost:8081/api/v1/auth/login \
  -H "Content-Type: application/json" \
  -d '{
    "email": "test@acme.com",
    "password": "Test@12345"
  }' | jq .tokenType
 
# Expected: "Bearer"

# Test a simple query (requires configured data source)
curl -s -X POST http://localhost:8000/api/v1/query \
  -H "Authorization: Bearer ${ACCESS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "question": "How many tables are in the database?",
    "tenantId": "acme-corp"
  }' | jq .status
 
# Expected: "success" or "completed"

# Check pod events
kubectl describe pod <pod-name> -n <namespace>
 
# Check container logs
kubectl logs <pod-name> -n <namespace>
 
# Check previous container logs (if restarting)
kubectl logs <pod-name> -n <namespace> --previous

kubectl describe pod <pod-name> -n <namespace>
# Look at the Events section for the specific error

# Check service endpoints
kubectl get endpoints <service-name> -n <namespace>
 
# Check network policies
kubectl get networkpolicies -n <namespace>
 
# Test connectivity from within a pod
kubectl exec -it <pod-name> -n <namespace> -- \
  curl -s http://<target-service>:<port>/health

# Test database connectivity
kubectl exec -it <pod-name> -n <namespace> -- \
  pg_isready -h <db-host> -p 5432 -U matih
 
# Check database secrets
kubectl get secret <secret-name> -n <namespace> -o jsonpath='{.data.password}' | base64 -d

# Check certificate status
kubectl get certificates -A
kubectl describe certificate <cert-name> -n <namespace>
 
# Check cert-manager logs
kubectl logs -l app=cert-manager -n cert-manager