Skip to main content
Version: 1.18

Okteto Manifest Overview

The Okteto Manifest is how you configure the behavior for building, deploying, and developing your application in Okteto. These are the main sections of the Okteto Manifest:

buildConfigure a list of images to build for your application
deployConfigure a list of commands to deploy your application. You can also refer to Docker Compose files
dependenciesConfigure a list of git repositories to deploy as part of your application
destroyConfigure a list of commands to destroy your application
devConfigure a list of Development Containers to define how okteto up works when you are iterating on your application
externalConfigure a list of External Resources that exist outside of the Kubernetes cluster (e.g. cloud resources, dashboards).

There are other sections to help you build your ideal development experience in Okteto, but this document focuses solely on introducing you to the core concepts of the Okteto Manifest. You can learn more about the other Okteto Manifest options in the manifest reference.


This section contains the instructions for Okteto to build the images for each service of your application.

Your build section might look like this:

context: api
context: frontend
dockerfile: Dockerfile
npmrc: .npmrc

This configuration defines images to be built for three services: api, and frontend. It also defines a context for each image, which tells Okteto which folder/subfolder to use for building each container image. In this case, Okteto is using the api subfolder for the api image, and the frontend subfolder for the frontend image. For the frontend image, it's also defining the dockerfile path and a build secret.

You can learn more about other build parameters here.


This section tells Okteto how to deploy your application. It typically uses a combination of helm, kubectl, and okteto commands. All the resources created by these commands will appear in the Okteto UI as part of a single Development Environment that represents the whole of your application.


If you have external resources you'd like to configure and show within the Okteto development environment, you must configure those in the external section.

Your deploy section might look like this:

- name: Deploy PostgreSQL
command: helm upgrade --install postgresql postgresql/postgresql-11.6.21.tgz -f postgresql/values.yml --version 11.6.21
- name: Deploy Frontend
command: helm upgrade --install frontend frontend/chart --set image=${OKTETO_BUILD_FRONTEND_IMAGE}
- name: Deploy API
command: helm upgrade --install api api/chart --set image=${OKTETO_BUILD_API_IMAGE} --set load=${API_LOAD_DATA:-true}

In this sample the deploy section instructs Okteto to execute three commands: deploy a postgresql database, deploy the frontend helm chart (refering the frontend image using an environment variable), and deploy the api chart (refering the api image using an environment variables).

You can learn more about the deploy section here.


This section tells Okteto to deploy a list of git repositories as part of the deployment of your application.

Your dependencies section might look like this:

wait: true

In this sample the dependencies section instructs Okteto to deploy the repo and wait until its resources are available before running the commands in the deploy section of the Okteto Manifest.

You can learn more about the dependencies section here.


This section contains a list of Development Containers that determine how the Okteto CLI and, specifically, the okteto up command behave. This section is how Okteto hot reloads and debug the code between your local computer and your Development Environment.

Your dev section might look like this:

command: ["bash"]
- 8080:8080
- 9229:9229
- api:/usr/src/app
command: yarn start
- frontend:/usr/src/app

In this sampple, the api section will tell Okteto to create a Development Container that exists specifically to sync code between your local computer and the api Kubernetes Deployment so you can see your changes in real-time within your Development Environment.

You can learn more about the dev section here.


This section contains a list of resources external to the Kubernetes cluster such as cloud resources or dashboards, but that are part of your application. Configuring your external resources enables you to build a more complete development experience in Okteto.

Your external section might look like this:

icon: okteto
- name: Try it out!
icon: aws
notes: docs/
- name: function

This section provides only the metadata to represent and link to external resources in the Okteto UI and does not create any resources in a cloud provider. Creating or destroying the resources themselves is done in the deploy and destroy sections, respectively.

You can learn more about the external section here.


This section tells Okteto how to destroy your application. The Okteto CLI command okteto destroy will automatically destroy any Kubernetes resources created by the okteto deploy command. The commands you define in the destroy section will ensure any resources external to the Kubernetes cluster are destroyed when destroying the Development Environment.

Your destroy section might look like this:

image: okteto/pipeline-runner:1.0.0-sam
- name: destroy worker service
command: |
sam delete --no-prompts --stack-name "${OKTETO_NAMESPACE}-voting-texkhnclxd" --region us-east-1

In this sample the destroy section instructs Okteto to delete the worker service running in AWS. When the application is deleted, Okteto will execute this command ensuring orphaned resources don't remain active.

You can learn more about the destroy section here.