Eclipse Che

Eclipse Che is a Kubernetes‑native cloud development platform that bundles the entire developer stack—IDE, language runtimes, build tools, and application code—inside containerized workspaces. From a technical standpoint it exposes a RESTful API for workspace lifecycle management, a custom resource definition (CRD) called CheCluster for cluster‑level configuration, and a pluggable extensions system that mirrors the Visual Studio Code marketplace. The platform is built on top of the Red Hat OpenShift Operator framework, allowing it to leverage Kubernetes primitives such as Pods, Services, and Secrets for secure, isolated development environments that can be spun up in seconds.

Che’s core is a Java‑based microservice cluster that runs as a set of container images on Kubernetes. The stack includes:

• Java 17 / Spring Boot for the Che Server, exposing a GraphQL/REST API.
• Node.js / TypeScript for the Che Dashboard, which serves the web UI and orchestrates workspace creation.
• Etcd as a distributed key‑value store for runtime configuration and workspace state.
• MongoDB (optional) for persisting user data, extension registries, and telemetry.
• OpenShift / Kubernetes CRDs (CheCluster, Workspace) that define the declarative configuration for Che and individual workspaces.
• Devfile (CNCF‑approved) as the schema for declaring container images, tools, and commands that constitute a workspace.

Workspaces are represented as Kubernetes Pods with sidecar containers for the IDE (VS Code or JetBrains Projector) and any language runtimes. Networking is handled by the cluster’s Ingress, exposing each workspace through a unique sub‑domain or path.

• Workspace Lifecycle API: Create, start, stop, delete workspaces via HTTP/GraphQL; automatically provision containers based on a Devfile definition.
• Extension Marketplace: Embed VS Code extensions, JetBrains plugins, or custom web components; manage a private Open‑VSX registry.
• IDE Integration: Run VS Code in the browser via the built‑in web‑based editor, or host JetBrains IDEs using Projector.
• Git Integration: Clone repositories by URL, support for GitOps workflows, and automatic credentials injection via Kubernetes Secrets.
• Devfile Support: Declarative workspace definition that is versioned in Git, enabling reproducible environments across teams.
• Telemetry & Metrics: Export Prometheus metrics and logs; integrate with Kubernetes monitoring stacks.

Che is designed for self‑hosting on any compliant Kubernetes distribution—OpenShift, GKE, EKS, AKS, or a local Minikube cluster. The operator pattern ensures zero‑touch upgrades: the CheOperator watches for CheCluster CRDs and reconciles the desired state. For scalability, each workspace is a lightweight Pod; horizontal pod autoscaling can be applied to the Che backend services. Storage for persistent code repositories is typically backed by a PVC or an external Git provider; optional integration with Minio or S3 for large binary artifacts.

• CRD Customization: The CheCluster CR provides fine‑grained configuration for authentication (OAuth, LDAP), metrics endpoints, and feature toggles.
• Webhooks & Eventing: Workspace events can trigger external CI/CD pipelines or Slack notifications.
• Custom Extensions: Developers can write server‑side extensions in Java or client‑side widgets in TypeScript; the extension API exposes workspace events, command execution, and IDE UI hooks.
• Devfile Plugins: External tools can be added via the Devfile components field, allowing integration with Docker Compose, Helm charts, or custom scripts.

Che offers a comprehensive online playground (Red Hat hosted) for quick experimentation, while the open‑source distribution is fully documented on eclipse.dev/che/docs. The documentation covers end‑to‑end scenarios—from initializing a workspace to configuring custom extension registries—and includes an API reference for the workspace controller. The community is active on GitHub, Discord, and the Eclipse Che mailing list; contributions are encouraged through the well‑structured issue tracker and pull request workflow.

• Enterprise Continuous Development: Teams can spin up isolated, reproducible environments that mirror production Kubernetes clusters, reducing the “works‑on‑my‑machine” problem.
• Remote Collaboration: Multiple developers share a single workspace pod, enabling pair‑programming or code reviews directly in the browser.
• Educational Platforms: Instructors can publish pre‑configured Devfiles for labs, ensuring every student starts with the same tooling stack.
• Rapid Prototyping: New projects can be launched from a Git repo or template Devfile, automatically provisioning all dependencies in the cloud.

Che’s Kubernetes‑native design delivers true developer portability: a workspace can be moved across clusters without code changes. The declarative Devfile model eliminates ad‑hoc setup scripts, leading to faster onboarding and consistent environments. Licensing under the Eclipse Public License 2.0 ensures no vendor lock‑in, while the open‑source ecosystem provides a rich set of extensions and community support. Performance-wise, containerized workspaces share the host’s kernel, resulting in near‑native IDE responsiveness and efficient resource utilization compared to VM‑based solutions.