Safer deployment of streaming applications

Summary

Stateful stream processing frameworks like Apache Flink present unique deployment challenges because conventional canary and blue-green strategies can cause data inaccuracies or state divergence. Grab's real-time data platform team encountered risks of state loss, manual rollback overhead, and absent health checks in their Kubernetes and Spinnaker deployment pipeline. To resolve these operational issues, the team redesigned the deployment workflow around automated Flink savepointing and programmatic health monitoring. The new pipeline halts existing applications after capturing state snapshots and Kafka offsets, monitors target deployments via API health probes, and executes automated rollbacks using versioned ConfigMaps and replica metadata annotations. This automated process ensures state consistency during upgrades and eliminates manual intervention during deployment failures.

Context

Deploying stateful Flink streaming applications on Kubernetes at Grab was error-prone because existing CI/CD processes lacked automated health probes, risked losing application state, and required slow, manual rollbacks across interconnected streaming pipelines.

Approach / What changed

Grab built an automated Spinnaker deployment workflow that captures Flink savepoints via API before shutdown, deploys new versions with stored replica count annotations, conducts automated API health probes after a stabilisation period, and rolls back configuration and infrastructure upon failure.

Takeaways

• Canary deployments are unsuitable for stateful Flink stream joins because splitting traffic across versions leads to incomplete data inputs and inaccurate processing.
• Capturing a Flink savepoint before stopping an application preserves Kafka consumer offsets, ensuring consistent data replay and zero message loss if a rollback occurs.
• Dynamic TaskManager replica counts from autoscaling are not tracked in standard Kubernetes deployment specs, necessitating custom metadata annotations for accurate cluster rollbacks.

Related reading

• Grab · Apr 23, 2024

  Ensuring data reliability and observability in risk systems

  Grab's in-house risk management platform, GrabDefence, relies on ingesting large volumes of upstream data to drive real-time heuristic rules and data science models. To prevent data discrepancies and missing information from degrading fraud detection, the team implemented a real-time data observability pipeline. The solution uses Apache Flink SQL alongside custom table functions like JSONEXPLOAD to flatten nested JSON structures and aggregate metrics over 5-minute tumbling windows. Processed metrics are sent to Datadog, where counters are grouped by source stream and evaluated using anomaly detection algorithms. Alerts are routed directly to Slack, reducing anomaly detection latency from days or weeks down to within the same day or hour.

  Yi Ni Ong

• Grab · Jun 5, 2024

  Profile-guided optimisation (PGO) on Grab services

  Profile-guided optimisation (PGO) improves Go application performance by feeding production CPU profile data into subsequent compiler builds. Teams evaluated PGO across multiple Grab services, including TalariaDB and an orchestrator within the Catwalk service, using Go 1.20 and Go 1.21 builds. TalariaDB saw substantial resource savings after compiling Docker images with a 360-second pprof profile, resulting in at least a 10% drop in CPU usage, a 30% drop in memory consumption, and a 38% reduction in persistent volume usage for event ingestion queues. Conversely, testing on Catwalk showed only a 5% performance gain after adjusting the profiling duration from 59 seconds to 6 minutes, an outcome deemed insufficient to justify pipeline modifications. Broader adoption across monorepo services remains constrained until the central build process supports PGO arguments and automated profile retrieval.

  Yonghao Hu

• Grab · May 3, 2024

  No version left behind: Our epic journey of GitLab upgrades

  Grab's self-hosted GitLab instance fell approximately 14 months behind official releases, serving thousands of engineers and monorepos reaching up to 39TB in total footprint. To address security updates and system stability, the team established a structured upgrade routine using Terraform, Packer, and Ansible across GitLab's 5,000-user reference architecture. They implemented staged deployments, upgraded stateful Gitaly nodes via in-place rotation, and resolved primary node clustering bottlenecks under Praefect. By utilizing official GitLab Upgrade Paths and parallelizing component deployments, the team caught up on 24 months of releases in 11 months and reduced release lag from 396 days down to 35 days.

  Saurabh Vajpayee

• Grab · Apr 3, 2024

  Iris - Turning observations into actionable insights for enhanced decision making

  Standard infrastructure monitoring tools track CPU and memory usage at the host or container level, obscuring the precise resource consumption of individual Spark jobs on shared instances. To achieve granular observability, the Iris platform gathers job metrics directly at the Java Virtual Machine level without requiring changes to user application code. Data collection relies on Uber's JVM Profiler for deep JVM, thread, and memory pool diagnostics alongside sparkMeasure for stage and task execution statistics. Collected metrics route asynchronously through an Apache Kafka queue to avoid execution bottlenecks, feeding a Telegraf, InfluxDB, and Grafana stack for real-time monitoring while archiving to a data lake for offline analytics. This multi-tiered telemetry enables engineering teams to identify over- or under-provisioned jobs and optimize ETL resource allocations.

  Huong Vuong