Kubernetes is an open-source project for automating deployment, scaling, and management of containers. It has rapidly become the standard to run production workloads and the community around it is just great!
But developing in Kubernetes presents some challenges. The typical development workflow looks like this: write code, build a Docker image, push it to the registry, redeploy, validate your changes and repeat. This workflow is slow, and as anti-python as it could be. Python is famous for it’s quick Read-Eval-Print loop, after all. We don’t want to give that away when bulding Cloud Native applications.
Okteto was created to solve this problem. On this blog post, we will show you how Okteto improves the developer experience in Kubernetes for Python developers. You will be able to take full advantage of using an instant development environment, dependency caching, hot-reloading and even the PyCharm debugger while developing your application directly in Kubernetes.
Get a local version of the Python Sample App by executing the following commands:
git clone https://github.com/okteto/python-getting-started
k8s.yml file contains the Kubernetes manifests to deploy the Python Sample App. Run the application by executing:
kubectl create -f k8s.yml
deployment.apps "hello-world" created
One command and a dev version of your application is ready to go 😎.
The Okteto CLI is an open-source project that lets you develop your applications directly in Kubernetes while taking advantage of your language’s toolkit. We will use it to speed up our development cycle instead of using the typical development workflow based on building docker images and redeploying containers.
Install the Okteto CLI:
MacOS / Linux
curl https://get.okteto.com -sSfL | sh
WindowsDownload https://downloads.okteto.com/cli/okteto.exe and add it to your `$PATH`.
With the Python Sample Application deployed, run the following command:
✓ Development container activated
okteto up command starts a development container, which means:
- The Python Sample App container is updated with the docker image
okteto/hello-world:python-dev. This image contains the required dev tools to build, test, debug and run the Python Sample App. Check the Dockerfile to see how it is generated.
- A file synchronization service is created to keep your changes up-to-date between your local filesystem and your development container.
- Container port 8080 (the application) is forward to localhost.
- Container post 3500 (the debugger) is reverse forwarded to localhost.
All of this (and more) can be customized via the
okteto.yml manifest file:
You can also use the file
.stignoreto skip files from file synchronization. This is useful to avoid synchronizing virtual environments or git metadata.
Okteto automatically forwards port
8080 from your local computer to the development container, making it accessible via
localhost. Test your application by running the command below in a local shell:
app.py file in your favorite local IDE and modify the response message on line 7 to be Hello world from the cluster!. Save your changes.
Okteto will synchronize your changes to your development container. Flask’s auto-reloader will detect the changes automatically and restart the application with the new code.
* Detected change in '/okteto/app.py', reloading
Call your application from a local shell to validate the changes:
Hello world from the cluster!
Cool! Your code changes were instantly applied to Kubernetes. No commit, build or push required 😎!
Okteto enables you to debug your applications directly from your favorite IDE. Let’s take a look at how that works in one of python’s most popular IDE’s, PyCharm.
First, open the project in PyCharm, remove the comments on
if __name__ == '__main__':
Second, launch the Remote Debug Server by clicking on the Debug button on the top right. Ensure that the Debug Tool Window shows the
Waiting for process connection.. message. This message will be shown until you launch your app on the development container shell and it connects to the Debug Server.
Starting hello-world server...
On your local machine, switch to the Debug Tool Window. Once the app connects it will show the connection to the pydev debugger. Press the
resume button to let the execution continue.
Add a breakpoint on
app.py, line 10, and then call your application from your local shell:
The execution will halt at your breakpoint. You can then inspect the request, the available variables, etc. Your code is executing in your development container in Kubernetes, but is being debugged on the local machine. Pretty cool no? 😉
The PyCharm project includes a debugging configuration to start the remote debug server and to listen for connections on
localhost:3500. The Okteto manifest is configured to start a reverse tunnel on port 3500 when the development container is activated.
This way, when the service it’s started in your development container, the connection is sent back to your local machine through the reverse tunnel, where the remote debug server receives and starts the debugging process.
This configuration allows you debug your application while fully integrated in Kubernetes. And the coolest thing is that since all of this is described in your
.idea and Okteto manifests, everyone collaborating in your project will get the exact same configuration by simply running
okteto up 🤖.
Kubernetes has the potential to be a great development platform, providing replicable, resource-efficient and production-like development environments. We have shown you how to use Okteto to create a development workflow that also lets you take advantage of features like incremental builds, hot reloaders or debuggers while developing your application directly in Kubernetes.