Self-Service Portals for Developers: Insights from KubeCon 2023
Shout out to Shahar Shmaram and Ran Mansoor of the AppsFlyer DevOps platform team – this piece is inspired by your excellent presentation at Kubecon 2023 Amsterdam.
The developer’s need for a Self Service Portal
Time was when developers lived in their own little box, running local processes and throwing built artifacts for other people to deploy and test. And while it was fun while it lasted – I do not miss those times and the never-ending “works on my machine” chant.
As DevOps practices became widely accepted, developers were required to test their work on production-like environments, monitor their creations during load tests and follow key metrics in staging and production. Couple that with the continuing rise in runtime complexity (micro-services, anyone?), and you are into a world of pain:
– Spinning up (and releasing!) a production-enough environment
– Accessing the correct logs for the correct services in the correct cluster
– Subscribing to the relevant alerts
– Understanding what environment to look at to see “THE” issue, etc.
This is why creating various systems, tools, and practices is underway to tackle issues and simplify the developer experience. A crucial part of this effort involves establishing a Self-Service Portal specifically for developers.
What makes an effective Self Service Portal
Self-service portals enable developers to access and use resources, tools, and services to build and deploy applications without the need for human (read: DevOps) intervention.
These portals typically offer a range of features and functionalities that developers can use to streamline their workflows and improve their productivity.
The key features of such a self-service portal are:
– One-click secure access to resources related to runtime environments – development, staging, and even production:
– Logging platforms
– Configuration data
– Observability and debug tools
– Database access
– One-click ability to spin additional environments if needed and deploy varying versions of services
– Wizards to kick off new services, features – anything that requires multiple configurations, boiler code, etc.
Self-service portals are particularly useful for developers working on large-scale projects or those who need to work quickly and independently. By providing developers with the tools and resources they need to build, test, and deploy their applications, self-service portals can significantly improve productivity and reduce development time.
Building such portals is not a new practice, and multiple tools and techniques have been applied over the years. At the time of writing, there is no clear toolset that will fit most situations, and each team that decides to create such a portal will have to select based on their needs and development competencies.
Using Kubernetes Backstage as a foundation for developers’ portal: Insights from AppsFlyer’s successful migration
At Kubecon 2023, Shahar Shmaram and Ran Mansoor of AppsFlyer made a clear case for using backstage as the basis to implement your own developer portal.
Kubernetes Backstage, an Open Source CNCF project that originated in Spotify, provides a centralized platform for developers to manage their software development workflows and tooling.
Kubernetes Backstage offers a wide range of features, including:
– A customizable dashboard that provides a unified view of development pipelines, services, and tooling.
– A plugin architecture that allows developers to integrate with third-party tools and services easily.
– Service catalog management, which enables developers to discover, provision, and manage services easily.
– A robust permissions and access control system that allows administrators to manage access to resources.
The AppsFlyer team used it as a cornerstone in their strategy to move a huge and diverse development organization from existing infrastructure and practices to newer Terraform, Kubernetes, and GitOps-based toolsets.
By providing a user-friendly portal and making the new way of “doing business” more accessible to the developers, they encouraged them to make the leap.
Backstages built-in flow and Kubernetes observability, along with the ease of creating code generation templates and writing custom plugins, allowed them to implement a powerful self-service portal and customize it to specific needs as the transformation advanced and encompassed more teams.
In a span of five months, they managed to migrate more than 1,000 micro-services to the new infrastructure and convert 45 development teams to new working procedures. Having a developer-friendly experience based on the Backstage portal was a huge part of this win.
Is Backstage the right tool for your team?
Talking with Shahar and Ran, they emphasized several competencies that will allow you to create a good portal and some that will help you specifically with backstage.
Before you plunge into building a portal, make sure you have the following:
– Solid understanding of the developer needs and the DevOps toolset you have
– A vision of how developers should work and how the portal will be part of their flow
– Clear communication lines with key developers
– The ability to listen and adjust – your vision will change through the process
For Backstage, you should make sure you have the following:
– Good understanding of basic UI/UX principles
– Frontend development capabilities – React, Typescript, HTML, and CSS
– Knowledge of how to work with Web APIs in order to tie in systems
The plugin architecture of backstage promises a bright future of many ready-made additions, but we are not quite there yet, and you can assume you will need to write/adapt some of your own.
Doubling down on Developer Experience is a major part of the DevOps way, so if you do not have a Self Service Portal for your developers, this may be a good time to envision one.
Take a look backstage to get ideas and maybe start the ball rolling.