GoCD's current roadmap consists of two main parts:
- Better support for cloud deployments (cloud-native GoCD support).
- Better user experience.
- Be universal and easily extensible.
- Improve support for APIs and the ability for users to configure it without using the UI (this includes declarative definitions of pipelines as code).
- Produce more supporting content for improving the way people do CD (mostly on the GoCD blog).
Better support for cloud deployments (cloud-native)Container systems (almost single-handedly Docker) have changed how applications are built. The fact that applications can now be shipped and shared in a standardized manner with dependencies defined or bundled in a standardized manner changes both the development side and the operations side. Applications can now be defined in terms of container images and the interactions between containers. Container orchestration systems (such as Kubernetes and Mesos) are in the middle of a major shift in how applications are deployed and managed. They are the shipping infrastructure equivalent of the virtual world and by the abstractions they provide, they make it easier to deploy, manage and monitor entire fleets of containerized applications across multiple nodes, physical or virtual. Quite often, these nodes are in the cloud and these orchestration systems provide reasonable abstractions over them. All of these changes inevitably affect the CD workflow. The good news is that in many cases, it becomes simpler. The processes and underlying workflows will still need to be considered and modeled. Though the generic nature of GoCD allows these changes to be modeled today, GoCD will be extended to embrace these changes and make them easier and more streamlined. Most of this work will focus on Kubernetes as the first implementation, since it seems to be the most mature and accepted container orchestration system. All of the work will be done as generically as possible, so that GoCD is not tied irrevocably to Kubernetes. Extension points will be identified, so that the Kubernetes-related work can be inside plugins, so that these ideas can be extended to other orchestration systems. The work will be based on these high-level ideas:
Running GoCD natively on Kubernetes: Involves ...
- Running the GoCD server in Kubernetes.
- Running automatically scaled elastic agents in Kubernetes.
Better support for the Docker workflow: Involves ...
- The idea of building an image and propagating it across multiple environments till production.
- This involves allowing build artifacts to be natively published to artifact repositories (such as a Docker Registry, Artifactory or S3).
Deployments to Kubernetes: Involves ...
- These can be modeled using simple commands (and that is encouraged).
- More support for generating deployment yamls and helm charts with the correct versions.
- Ability to monitor deployments (they might be done asynchronously by Kubernetes).
- More content around CD in this new world. It's not always as straightforward as you think.
Better user experienceThis involves a refresh of the GoCD user experience (not just the user interface). Based on many interviews with users of GoCD and other solutions, there has been a lot of feedback gathered about changes to the user experience of GoCD. These changes will take the form of:
- Better discoverability of features.
- Improved movement through the app (easier to get to what you need).
- Better use of colors and icons.
- Better wayfinding (headers).
- Rewrites of significant parts of the application to provide new data or existing data in a better form.