Kubernetes RoadmapBy the end of march Kubernetes version 1.2 will be released with the following highlights:
- New abstraction "Deployment": A deployment groups pod/rc/service definitions
with additional deployment metadata. A deployment describes the desired target
state of an application on a k8s cluster. When a deployment is applied k8s
drives the current cluster state towards the desired state. This is
performed on the server side and not on the client side (unlike in k8s < 1.2).
- ConfigMaps & Secrets: Kubernetes can now handle configuration
files & parameters as well as secrets and certificates cluster-wide.
It stores the configs inside of etcd and makes it accessible through
the k8s API. The configs are exposed by mounting the files
into the pods (as tmpfs) and via env vars. They can also be referenced
in the YAML files. They are updated live and atomically.
- Brand new web UI: The Kubernetes Dashboard.
- Improved scalability and support for multiple regions.
- Better support for third-party extensions.
- DaemonSet to better support the Sidekick pattern.
- Better support for legacy applications with mechanisms like IP persistence.
- Cluster federation (project Ubernetes) to join multiple k8s clusters together.
- Further improved scalability.
- Cluster autoscaling (automatically acquiring & releasing resources from the cloud provider).
- In-Cluster IAM (LDAP / AM integration).
- Scheduled jobs to better support batch processing on k8s.
- Public cloud dashboard for Kubernetes-as-a-Service scenarios.
- ... and more to come / to be discussed in the community.
The hot topics in my opinion were:
- Higher-level abstractions & tools: Despite Kubernetes is a great advance in
bridging the gap between devs and ops, there is the need for higher-level
abstractions & tools - especially for the devs (cite: "Kubernetes should be
an implementation detail for devs"). This is addressed by k8s
itself (deployment abstraction) as well as by different approaches like
kdeploy (https://github.com/kubernauts/kploy), Puppet Kubernetes (https://forge.puppetlabs.com/garethr/kubernetes), dgr (https://github.com/blablacar/dgr) or DEIS (http://deis.io). From a high-level point of view the community
is putting the bricks on Kubernetes towards PaaS.
- Continuous Delivery: Kubernetes is an enabler
of continuous delivery (CD) and developing cloud native applications
on k8s demands for CD. There were some industrial
experience reports on using Kubernetes as execution environment
for their CD workflows. Kubernetes handles scaling the CI/CD server as
well as the application itself. Best practice here is to separate
different applications and stages by using k8s namespaces and to use
ChatOps tools like Hubot (https://hubot.github.com) to provide fast feedback to
the devs & ops.
- Stateful services: Kubernetes is great in running stateless Microservices. But a lot of applications have to deal with (persistent) state. But how to run stateful services and even databases on Kubernetes without loosing its benefits or even loosing data in case of a re-scheduling? K8S to the rescue! The answer is persistent volumes providing cluster-wide non-ephemeral storage. A couple of different cluster storage providers are available for persistent volumes in k8s: More classic ones like NFS and SCSI; cloud native ones like GlusterFS and Ceph; cloud provider specific ones for GCE and AWS and storage abstraction layers like Flocker. The competition is open!
- Diagnosability: As applications and infrastructure is getting more and more fine-grained and distributed with platforms like k8s the problem of diagnosing failures and optimization potentials arises. Time for cluster-aware diagnosis tools like sysdig (http://www.sysdig.org), Scope (https://github.com/weaveworks/scope) and Kubernetes Dashboard (https://github.com/kubernetes/dashboard)!