Keep up with the latest announcements from Google Cloud Next '21. Click here.

GKE

5 tips to maximize the Kubernetes developer experience with Cloud Code

k8s best practices

Starting a new project that deploys to Kubernetes can be a time consuming process. It’s easy to get caught up with configuring your infrastructure instead of actually writing your application’s business logic. Developer tools and practices that help streamline Kubernetes workflows, while keeping you focused on code, are key to driving your productivity. 

Here are a few tips to keep in mind as you begin your app development journey with Kubernetes. You can also try out our interactive Kubernetes tutorial to see how Cloud Code can transform your development journey!

1. Develop where you're most comfortable

As a developer, you probably spend most of your time in your favorite IDE. To simplify Kubernetes development, enhance your IDE with extensions. Extensions can make the process of building, deploying, scaling, and managing Kubernetes infrastructure and applications a breeze. To increase your productivity and make your IDE Kubernetes ready, consider installing Cloud Code. It’s an IDE extension, available for VS Code and Intellij, that helps you write, debug and deploy your container-based apps faster.

If you’re new to Kubernetes and don’t like the idea of consuming your local machine’s resources, a browser-based, development-ready environment is a great alternative. 

One example of a browser-based IDE is Cloud Shell Editor. Cloud Shell Editor is an online development and operations environment accessible anywhere from a browser. To reduce your setup overhead, Cloud Shell Editor is preloaded with tools like kubectl, Docker, and Skaffold. Cloud Code is also preinstalled, so you can deploy to your app easily and manage your Kubernetes infrastructure right from your browser-based IDE.

Whether you're using Cloud Shell Editor or your local IDE, choose the development environment that works best for you and that you feel most productive with. 

2. Reduce context switching

Context switching is time consuming and breaks up your workflow. While developing Kubernetes applications, you might switch between your IDE, Cloud Console, documentation, and logs. To keep you focused on coding, consider how the extensions you add to your IDE can reduce context switching. 

Cloud Code comes with built-in capabilities to reduce context switching. For example, with Cloud Code’s Kubernetes explorer, you can visualize, monitor, and view information about your cluster resources without running any CLI commands. And in a couple clicks, you can view the logs of your clusters.

Our developer favorite to reduce context switching are our in-context tutorials available within Cloud Shell Editor. You no longer need to switch between documentation and code, learn more here

3. Simplify Local Development 

In general, IDE extensions should make the process of working on your code and getting feedback on local changes easier and more streamlined. 

As a developer, you’d prefer to focus on writing your business logic, rather than how to get it running in a container. Buildpacks are an open-source technology that makes it fast and easy for you to create secure, production-ready container images from source code without needing to write and maintain a Dockerfile. 

Cloud Code makes it easy to build containers with Buildpacks and deploy them to Docker Desktop or Minikube. Minikube creates a local cluster on your machine, giving you a playground to run your application and experiment with Kubernetes. Cloud Code also supports remote clusters to offload CPU and memory resources from your machine. 

Iterating locally on your Kubernetes application requires building container images, updating Kubernetes manifests, and redeploying your applications. Doing this manually can be a chore. Cloud Code is key to simplifying these repetitive tasks and leverages Skaffold to run this process automatically every time you make a code change. 

Skaffold is a command-line tool that simplifies common operational tasks that you perform when developing on Kubernetes. To speed up and simplify your development loop, Skaffold’s Watch Mode watches local source code for changes, and rebuilds and redeploys applications to your cluster in real time. Recently Skaffold introduced its File Sync feature, letting you see your code changes in seconds by skipping rebuilding and redeploying.

4. Spend less time writing YAML

Getting used to working with the Kubernetes YAML syntax and scheme takes time, and a lot of that time is trial and error. Cloud Code lets you spend more time writing code thanks to its YAML authoring support features. Cloud Code’s inline documentation, snippets, completions, and schema validation, a.k.a. “Linting.” make writing YAML files a more enjoyable experience.

As Kubernetes has grown more popular, many developers have extended the Kubernetes API with new Operators and Custom Resource Definitions (CRDs). These new Operators and CRDs expanded the Kubernetes ecosystem with new functionality such as continuous integration and delivery, machine learning, and network security. 

Cloud Code provides YAML authoring support for over 400 Kubernetes CRDs out of the box, making it easier to write, understand, and see errors in your YAML files.Cloud Code also supports all CRDs installed on your cluster. 

5. Debug in real time

We've often heard that debugging applications running on Kubernetes clusters can be difficult to set up. There are a variety of methods to debug your running pods, but emulating a local debugging experience in your IDE is difficult to configure and requires exposing debugging ports and port forwarding t. Tools like Skaffold can make the debugging experience painless. Because Cloud Code leverages Skaffold, you can simply place breakpoints in your code. Once your breakpoint is triggered, you can step through the code, hover over variable properties, and view the logs from your container. If you're looking for a way to debug your application from your IDE, try Cloud Code. If you prefer the command line, Skaffold could be an option for you.

Debugging locally on a Kubernetes cluster means you'll be able to discover runtime errors before they make it to CI, staging, or production. The earlier you discover these errors, the faster time to resolution. This speeds up overall development time.

Conclusion

The best tools to integrate into your workflow to streamline the Kubernetes development process are those that increase your productivity. Today we’ve shared just a few tips to keep in mind when developing on Kubernetes. Enhancing your IDE with developer friendly extensions is an easy first step towards maximizing your productivity.