Okteto

Okteto is a Go-based CLI that replaces the slow “docker build, push, redeploy” inner loop of Kubernetes development with a live development container running directly inside your cluster. Running okteto up swaps a target Deployment for a Development Container preloaded with your toolchain (compilers, debuggers, package managers) while inheriting the exact secrets, config maps, volumes, and network identity of the original workload. Local file changes are synced into the container in near real time via a bundled Syncthing instance, so whatever hot-reload tooling the app already uses (nodemon, air, and similar) picks up changes instantly with no container rebuild.

Because the development container runs against the real cluster, developers get access to actual databases, internal APIs, and cluster-only resources instead of approximating them locally, eliminating a class of “works on my machine” integration bugs. The CLI ships as a single static binary for macOS, Linux, and Windows and works with any standard Kubernetes cluster, local (kind, minikube) or remote — no server-side component is required for the open-source okteto up / okteto down / okteto context workflow.

Okteto Inc. also sells a commercial Okteto Platform (a Helm chart installed into your own cluster) that layers team-oriented features on top of the same CLI: SSO-backed access control, a remote build service, preview environments per pull request, and environment-level observability. The open-source CLI in this repository covers only the dev section of the Okteto manifest, but that subset is fully functional and free for individual and team use.

What You Get

• Development Containers - okteto up swaps a Kubernetes Deployment for a container running your dev toolchain while inheriting its secrets, config maps, and volumes.
• Real-time file sync - A bundled Syncthing instance mirrors local file changes into the remote container in near real time, triggering whatever hot-reload tooling the app already uses.
• Cross-platform static binary - A single Go binary distributed for macOS, Linux, and Windows with no runtime dependency beyond kubectl cluster access.
• Manifest-driven configuration - The Okteto manifest (okteto.yml) declares the dev image, sync folders, port forwards, and commands in YAML, validated against a published JSON Schema.
• Deployment-agnostic workflow - Works alongside however you already deploy (kubectl, Helm, Kustomize, CI) — okteto up only intercepts the running workload, it doesn’t own the deploy step.
• Language starter samples - Ready-made getting-started manifests and guides for Go, Node.js, Python, Ruby, PHP, Java (Gradle/Maven), and ASP.NET.

Common Use Cases

• Debugging a microservice live in-cluster - A backend engineer attaches a debugger to a service running with production-like secrets and network access instead of stubbing dependencies locally.
• Fast inner loop for compiled languages - A Go or Java developer skips the docker build/push/redeploy cycle by recompiling inside the synced dev container and seeing changes in seconds.
• Onboarding developers into a complex microservices app - New team members run okteto up against a shared cluster instead of provisioning a local Kubernetes stack that drifts from production.
• Testing integration points that only exist in-cluster - Teams validate code against internal APIs, message queues, or databases that are impractical to mock outside the cluster.

Under The Hood

Architecture main.go builds a Cobra root command that wires together largely independent command packages (cmd/up, cmd/build, cmd/deploy, cmd/destroy, cmd/exec, cmd/context, cmd/pipeline, cmd/preview, cmd/namespace, cmd/kubetoken, cmd/remoterun, cmd/test, cmd/logs), each drawing on a shared pkg/ service layer — pkg/okteto for the cluster/platform API client, pkg/k8s for Kubernetes API interactions, pkg/model for manifest parsing and validation, pkg/syncthing for the file-sync subsystem, plus pkg/analytics, pkg/discovery, and pkg/deployable. cmd/up/up.go is the densest entry point, orchestrating manifest loading, Kubernetes context resolution, on-demand image builds, replacement of the target Deployment, Syncthing startup, port forwarding, and an interactive shell in one coordinated flow — cmd/ acts as an imperative orchestration layer over cohesive pkg/ services rather than a strict layered architecture, and changing the core Dev/Manifest abstraction in pkg/model would ripple through nearly every cmd/ package that consumes it directly.

Tech Stack Written in Go, using Cobra for the CLI command tree and the full client-go/k8s.io family (client-go, apimachinery, cli-runtime, kubectl) for Kubernetes API access. File synchronization is delegated to a managed Syncthing binary rather than a custom sync protocol. Image builds pull in Moby/BuildKit and go-containerregistry, platform integration uses gRPC and go-github, and afero provides a filesystem abstraction that supports in-memory testing. The project builds a static, cross-platform binary via a multi-stage Dockerfile and is validated through CircleCI alongside supporting GitHub Actions workflows.

Code Quality An extensive suite of unit tests accompanies nearly every package in cmd/ and pkg/, separate from a dedicated integration test suite; sampled files use table-driven tests with in-memory filesystem fakes (afero) to avoid touching real disks or networks. Errors are wrapped through dedicated error packages rather than swallowed, and Cobra commands propagate failures up to main.go for centralized reporting. A comprehensive golangci-lint configuration and pre-commit hooks run alongside CI on every change, and naming follows conventional Go style throughout.

What Makes It Unique Okteto’s specific bet is replacing a cluster’s live workload in place with a development container that inherits its exact runtime context — secrets, volumes, sidecars, and service identity — then relying on a managed Syncthing process for bidirectional file sync instead of a custom remote-mount layer. This sidesteps both the rebuild-per-change cost of a standard Kubernetes dev loop and the fidelity loss of purely local emulation via docker-compose or kind. The idea isn’t unique to the “cloud dev environment” category — Tilt, Garden, DevSpace, and Telepresence address similar problems — but the specific swap-sync-restore mechanic is a distinctive, well-executed implementation of it rather than a copy of any one competitor.

Self-Hosting

Licensing Model Apache License 2.0 — the entire CLI in this repository is fully open source with no license keys or gated commands for local or team use.

Self-Hosting Restrictions

• None inside the open-source CLI: okteto up, okteto down, and okteto context are unrestricted against any Kubernetes cluster.

Enterprise Features

• The separately sold Okteto Platform (a Helm chart deployed into your own cluster) adds, per the README’s feature comparison table: SSO/identity-provider-backed access control, a remote build service, per-pull-request preview environments, dynamic environment scaling, a secrets manager, and Okteto Insights observability.

Cloud vs Self-Hosted Both the free CLI and the paid Platform are self-hosted (installed into your own cluster); the difference is team/enterprise tooling layered on top of the same okteto up primitive, not a hosted-versus-self-hosted split.

License Key Required No — the open-source CLI commands in this repository require no license key. A license is only required to unlock the additional Okteto Platform commands (build, deploy, destroy, and related Platform-mode features).