Over the last five years, a massive shift in how applications get deployed has occurred. It’s gone from self-hosted infrastructure to the world of the cloud and Kubernetes clusters. This change in deployment practices brought a lot of new things to the world of developers, including containers, cloud provider configuration, container orchestration, and more. There’s been a shift away from coding monoliths towards cloud-native applications consisting of multiple microservices.
While application deployment has advanced, the workflows and tooling for development have largely remained stagnant. They didn’t adapt completely or feel “native” to this brave new world of cloud-native applications. This can mean an unpleasant developer experience, involving a massive loss in developer productivity.
But there’s a better way. What if you could seamlessly integrate Kubernetes and unlimited cloud resources with your favorite local development tools?
The current state of cloud-native development
Imagine that you’re building a cloud-native application that includes a Postgres database in a managed application platform, a data set, and three different microservices.
Normally, this would involve the following steps:
- Open a ticket to get your IT team to provision a DB in your corporate AWS account.
- Go through documentation to find where to get a copy of last week’s DB dump from your staging environment (you are not using prod data in dev, right?)
- Figure out how to install and run service one on your local machine
- Figure out how to install and run service two on your local machine
- Figure out how to install and run service three on your local machine
And that’s just to get started. Once you’ve made your code changes, you then have to go through these steps to test them in a realistic environment:
- Create a Git branch
- Commit your changes
- Figure out a meaningful commit message
- Push your changes
- Wait your turn in the CI queue
- CI builds your artifacts
- CI deploys your application
- You finally validate your changes
I’ve worked with teams where this process takes anything from a few minutes to several hours. But as a developer, waiting even a few minutes to see whether my code works was a terrible experience. It was slow, frustrating, and made me dread making complex changes.
Simplify your cloud-native development workflow with Crossplane and Okteto
Crossplane is an open source project that connects your Kubernetes cluster to external, non-Kubernetes resources and allows platform teams to build a custom Kubernetes API to consume those resources. This enables you to do something like
kubectl apply -f db.yaml to create a database in any cloud provider. And this enables your DevOps or IT team to give you access to cloud infra without having to create accounts, distribute passwords, or manually limit what you can or can’t do. It's self-service heaven.
The Okteto CLI is an open source tool that enables you to build, develop, and debug cloud native applications directly in any Kubernetes cluster. Instead of writing code, building, and then deploying in Kubernetes to see your changes, you simply run
okteto up, and your code changes are synchronized in real time. At the same time, your application is hot-reloaded in the container. It’s a fast inner loop for cloud-native applications.
On their own, each of these tools is very useful, and I recommend you try them both. The Crossplane and Okteto projects enable you to build a great developer experience for you and your team, making building cloud-native applications easier, faster, and joyful.
Here’s the example I mentioned in the previous section, but instead of a traditional setup, imagine you’re using Crossplane and Okteto:
- You type
- Okteto deploys your services in Kubernetes while Crossplane provisions your database (and data!)
- Okteto synchronizes your code changes and enables hot-reloading in all your services
At this point, you have a live environment in Kubernetes, just for you. You saved a ton of time by not having to go through IT, figuring out local dependencies, and remembering the commands needed to run each service. And because everything is defined as code, it means that everyone in your team can get their environment in exactly the same way. No degree in cloud infrastructure required.
But there’s one more thing. Every time you make a code change, Okteto automatically refreshes your services without requiring you to commit code. There’s no waiting for artifacts to build, no redeploying your application, or going through lengthy CI queues. You can write code, save the file, and see your changes running live in Kubernetes in less than a second.
How’s that for a fast cloud-native development experience?
Get into the cloud
If you’re building applications meant to run in Kubernetes, why are you not developing in Kubernetes?
Using Crossplane and Okteto together gives your team a fast cloud-native development workflow. By introducing Crossplane and Okteto into your team:
- Everyone on your team can spin up a fully-configured environment by running a single command
- Your cloud development environment spans Kubernetes-based workloads, as well as cloud services
- Your team can share a single Kubernetes cluster instead of having to spin up one cluster on every developer machine, CI pipeline, and so on
- Your development environment looks a lot like your production environment
- You don’t have to train every developer on Kubernetes, containers, cloud providers, and so on.
okteto up, and you’re developing within seconds!