Procer Cloud-Native Modernization

Challenge: 50+ retail units, each needing identical infrastructure but with location-specific configs (IP addresses, store IDs, local databases).

Solution:

• • Terraform modules for repeatable infrastructure (compute, networking, storage)
• • Workspace per retail unit (terraform workspace select loja-42)
• • Variables file per location (loja-42.tfvars with store-specific config)
• • Remote state in GitLab backend (prevents concurrent edits)

Key Benefit: Onboarding new retail unit went from 3 days (manual setup) to 30 minutes (terraform apply -var-file=loja-new.tfvars).

Application Stack:

• Backend API: Python FastAPI containerized, deployed as Kubernetes Deployment with 3 replicas
• Frontend: Next.js static export served via NGINX ingress controller
• PostgreSQL: StatefulSet with persistent volumes for database state
• Ceres API Gateway: NGINX-based reverse proxy for microservices routing

Kubernetes Resources:

• • Deployments: Application pods with rolling update strategy
• • StatefulSets: PostgreSQL with stable network identity and persistent storage
• • Services: Internal ClusterIP for service-to-service communication
• • Ingress: External traffic routing with TLS termination
• • ConfigMaps: Application configuration (environment-specific)
• • Secrets: Database credentials, API keys (encrypted at rest)
• • HorizontalPodAutoscaler: Auto-scaling based on CPU/memory thresholds

Problem: Retail units need to sync data to central warehouse for reporting/analytics. Previous solution: nightly batch jobs taking 4+ hours, blocking morning operations.

Solution: Kafka Connect + Debezium for real-time CDC

• • Debezium PostgreSQL Connector: Captures PostgreSQL WAL (Write-Ahead Log) changes in real-time
• • Kafka: Message broker streaming database changes to central data warehouse
• • No Application Changes: CDC operates at database level, zero code changes required
• • Exactly-Once Semantics: Kafka transactional guarantees prevent duplicate records

Result: Data replication latency reduced from 4+ hours (batch) to < 5 seconds (streaming). Morning operations no longer blocked by overnight sync jobs.

Deployment Flow:

1. Developer pushes code to GitLab feature branch
2. GitLab CI builds Docker image, pushes to container registry
3. Developer updates Kubernetes manifest (deployment.yaml) with new image tag
4. Merge request reviewed and merged to main branch
5. ArgoCD detects Git change, syncs to Kubernetes cluster automatically
6. Kubernetes performs rolling update (zero downtime)
7. ArgoCD health check verifies deployment success

Rollback: Git revert + ArgoCD sync = instant rollback to previous version. No manual kubectl commands needed.

Problem: Dashboard queries taking 15+ seconds during peak traffic, causing timeout errors and poor user experience.

Analysis:

• • Used EXPLAIN ANALYZE to identify slow queries
• • Found missing indexes on foreign keys
• • Sequential scans on 500K+ row tables
• • N+1 query problem in ORM (SQLAlchemy)

Optimizations:

• • Added composite indexes on frequently queried columns
• • Implemented eager loading (joinedload) to eliminate N+1 queries
• • Created materialized views for complex aggregations
• • Added PostgreSQL connection pooling (pgBouncer)

Result: Query time reduced from 15 seconds to < 500ms. Dashboard now usable during peak traffic.

Before: 20+ separate Jenkins pipelines with duplicated logic (build, test, deploy steps copy-pasted).

After: Single unified pipeline with branch-based deployment strategy:

• • feature/* branches: Build + run tests only
• • develop branch: Deploy to development environment
• • staging branch: Deploy to staging environment
• • main branch: Deploy to production (requires manual approval)

Benefit: Single Jenkinsfile to maintain. Changes propagate to all environments automatically.