Cloud native applications have gone mainstream in enterprise IT environments where scalability, security, and efficiency are critical
SlashData reports that 5.6 million developers use Kubernetes worldwide, representing 31% of all backend developers.
This rapid adoption of cloud technologies, such as Docker and Kubernetes, combined with the increasing numbers of enterprise developers, means that effective collaboration across development teams and cloud environment cost control are now table stakes.
The Rise of Cloud Native Architectures
The rise of cloud native architectures and accompanying technologies is a response to the slower monolithic approach to development and its big bang release cycles (often coupled with coding "merge hell"). With Kubernetes and microservices, it's possible to decouple everything to create more efficient workflows.
Decentralized and distributed services let developers work on independent releases of individual microservices rather than everyone working on a single code base, thus limiting risk and enabling faster releases.
More microservices, more challenges, more cost
As much as adopting a microservice based architecture brings many benefits, it often leads to a seemingly exponential increase in services created within the enterprise.
Developers often struggle to configure development environments that are both realistic enough to detect issues before they end up in production and provide fast feedback as they are coding and sharing progress within their teams. It’s not uncommon for developers to request bigger and more powerful hardware, either as an expensive laptop or pay-as-you-go dedicated cloud-based environments.
Both approaches have tradeoffs and limitations. The hidden costs of creating and maintaining local development environments containing all the services a developer needs to accomplish their task can impact productivity and the engagement of individual developers and teams. The CPU and memory capabilities of individual developers’ cloud environments only scale so far before the cost becomes prohibitive. Surely there is a better way
Making the remote local without friction: Telepresence
Debug Services Locally
The outline to the solution appears obvious. We need to combine the fast feedback that comes from local development with the ability to interact with additional services running on a shared remote Kubernetes development environment. Telepresence is designed specifically for developers who need to code, test and ship their application into Kubernetes but still need to debug services locally. Telepresence enables a developer to interact with remote services and apps locally without changing their workflow.
Remote-local Challenge
Telepresence is made for the remote-local challenge, letting Kubernetes developers code as though their laptop is in their Kubernetes cluster. Telepresence runs code locally and forwards requests to and from the remote Kubernetes cluster, bypassing the much slower process of waiting for a container to build, be pushed to a registry, and deployed before seeing the impact of code changes. By effectively providing developers with direct access to Kubernetes cluster resources, Telepresence completely removes one of the big cloud native challenges from the equation
Some ways Telepresence can tackle common Kubernetes debugging and testing challenges include
SPEEDING UP
the dev loop
PERFORMING
integration testing
GAINING
visibility
INSIGHTS
running services
Speed up the dev loops
In a cloud environment, developers often experience a slowed-down dev loop and the need to re-deploy containers. They are no longer coding and seeing the impact of the changes immediately, as was the case with monolithic environments.
Now, there are the aforementioned external dependencies that must be managed before they can see their code changes in action.
Perform Integration Testing
Cloud native applications are often made up of many different microservices, and these microservices work interdependently and need to communicate with each other.
This involves multidirectional, service-to-service communication that requires integration testing on microservices before deploying any changes. Testing alone isn't adequate to predict the behavior of the application in the target environment.
Telepresence is one way to solve integration testing in this context. You can test the local service against remote services so that even when your changes don't work as expected, you can easily make modifications and push them to production. Without Telepresence, integration testing would require running multiple services and connecting to (potentially remote) middleware and data stores using several different techniques and various tooling that add time and complexity to the equation, which is exactly what you're trying to avoid.
Gain visibility into end-to-end distributed application flow for debugging
Applications drawing on a multiplicity of services makes it increasingly difficult to debug in Kubernetes. The "too many services" phenomenon makes it crucial to get visibility into the end-to-end flow of your application.
This enables understanding of what is calling what, what is causing a bottleneck, and so on. While Telepresence itself does not provide cross-service visibility, you need observability and tracing tools to get to the information that will help you debug with Telepresence.
Get insight into other running services
When you need to run all other microservices that are a part of making your application work and aren't familiar with all of them, you could easily spend a lot of time setting up testing for an integration environment, but this slows down your road to actual debugging. Telepresence can step in and make it easier and faster to figure out the issue, debug it and push fixes to version control.
Telepresence in Action
The right development environment and development tools support the speed, efficiency and collaboration for which cloud native development is increasingly adopted. The rapid and continuous feedback loop Telepresence helps development teams achieve effective collaboration with ease: more action, less friction.