Cloud Foundry Diego Project
Cloud Foundry Diego Project is a Cloud Foundry runtime subsystem that schedules, places, and manages application and task containers across a cluster of Vulnerability Management System (VMS) (container orchestration / Platform-as-a-Service (PaaS) runtime).
- Distributed scheduling and placement of application instances and tasks on a pool of virtual machines (container orchestration).
- Execution and lifecycle management of application and task containers, including start, stop, and health checking (application runtime management).
- Management of desired vs. actual state for workloads through a central data model and convergent reconciliation loop (control plane / state management).
- Pluggable cell-based architecture with components running on Diego Cells to host and manage containers (node and workload management).
- Integration as the application runtime layer for Cloud Foundry, interfacing with higher-level CF APIs and routing components (PaaS integration).
More About Cloud Foundry Diego Project
Cloud Foundry Diego Project is the runtime and container management subsystem within the Cloud Foundry platform, designed to place and run application instances and tasks across a cluster of virtual machines in a predictable and automated way (container orchestration / PaaS runtime). It replaces the earlier Droplet Execution Agent (DEA) architecture and provides a convergent system that works to align the actual workload state with a declarative desired state stored in a central data model.
Diego targets the problem of reliably scheduling and running large numbers of application instances and one-off tasks in multi-tenant Cloud Foundry deployments (application runtime management). It distributes workloads across multiple Diego Cells, which are virtual machines responsible for hosting containers. A central control plane coordinates scheduling decisions, task execution, and health monitoring so that applications are placed on available capacity and restarted if they fail or if underlying infrastructure changes.
The project uses a desired-state model, where higher-level Cloud Foundry components declare how many instances of an application or what tasks should run, and Diego works to converge the actual cluster state toward that model (control plane / state management). Diego tracks both desired and actual state and uses a reconciliation loop to reschedule instances when nodes fail, workloads crash, or capacity changes. This design supports automated recovery and rescheduling without manual operator intervention.
Within Cloud Foundry, Diego integrates with the Cloud Controller, router, and logging and metrics components to provide complete application lifecycle behavior (PaaS integration). When developers push code through Cloud Foundry APIs or Command-Line Interface (CLI), the resulting application droplets or containers are scheduled onto Diego Cells for execution. Diego manages container startup, environment configuration, health checks, and stop operations, and it exposes state information back to the platform so that APIs and tooling can report instance status and support scaling operations.
Enterprises use Diego as the underlying runtime layer whenever they deploy Cloud Foundry distributions that rely on this architecture (enterprise application platform). Operators manage Diego components as part of the broader Cloud Foundry deployment, typically using BOSH for infrastructure provisioning and lifecycle management (infrastructure automation). Diego’s cell-based architecture and control-plane separation fit into environments that require workload isolation, capacity management, and automated healing for stateless and task-based workloads.
In a technical taxonomy, Cloud Foundry Diego Project is positioned as a container scheduling and execution subsystem within a PaaS stack, providing workload placement, lifecycle management, and convergent state control for applications and tasks running on Cloud Foundry-based platforms (container orchestration / PaaS runtime).