Development Environments

One of the advantages of using Okteto is the ability to configure development environments as code, side by side with your application.

Instead of having to keep a wiki with a never-ending list of tools, dependencies and scripts to install and run, you just have to clone your repository, deploy your application and run okteto up to start developing in seconds.

Getting started

At a high level, a development environment is a Docker container that contains:

  • One or more language runtimes (e.g python, ruby, node)
  • SDKs for your language runtime (e.g JDK, python-dev)
  • Binary dependencies (e.g. openssl, git)
  • Tools to manage and install dependencies (e.g. pip, bundler, yarn)
  • Tools to run your tests and analyze your code (e.g nosetest, pylint)
  • Your source code

When you run the okteto init command on a local repository, okteto will analyze your source code and will guess the main programming language you’re using. Based on this, it will select a base development environment configuration and create a default okteto.yml for you.

For example, if your repository is mostly golang, it will look like this:

1
2
3
4
5
6
7
name: dev
image: golang:alpine
volumes:
- /go/pkg/
- /root/.cache/go-build/
forward:
- 8080:8080

Out of the box, Okteto creates default development environments for the following languages:

  • node
  • golang
  • python
  • java
  • ruby

Create your own

The default development environments are a great way to start. They use the latest official docker image for your language runtime and include the most common developer tools. But they might not have everything you need. Your team might need to support a very specific version of your runtime, or you might need some extra tooling available.

Development environments are defined via Docker containers, so any existing Docker image can be used as a development environment.

Do the following to create your own development environment:

  1. Create a Dockerfile.
  2. Pick a base image.
  3. Add your extra dependencies, tools and files.
  4. Build your image, tag it and push it to your docker registry.
  5. Update the image key in your okteto.yml with your new image.

Once you do that, the next time you run okteto up, your new development environment will be deployed automatically.

Besides following Docker’s best practices, we also recommend the following:

  • Create the docker image in CI, so it’s clear how and when it was built.
  • Pin all your dependencies so there aren’t any surprises.
  • Keep the Dockerfile in your repository, next to your code.
  • When using multi-stage builds, use your development environment’s image as the first stage, so that you have the same tools and images in dev than in CI/CD.
  • Add your source code in the same folder that the workdir value of okteto.yml. By doing this, the content of the folder will be used to initialize the file synchronization service, instead of requiring a full initial sync. This will make okteto up faster.