Skip to main content
Version: 1.42

Helm Configuration

The Okteto Helm chart accepts the following values to configure your Okteto instance.

General Settings​

license​

You receive a license key with your Okteto subscription. If you haven't received it, open a support ticket.

If you are interested in evaluating Okteto, sign up for our Free Tier (5 seats, 1 year), no credit card required.

license: XXXXX

You can also store the license in a secret.

subdomain​

Okteto's automatic SSL endpoints allows you to expose secure and unique public endpoints for your development environments. By default, all endpoints created by Okteto will use a combination of the name of the app, the namespace, and the subdomain. For example, if you have a development environment named app in the cindy namespace, it will be accessible at https://app-cindy.example.com if subdomain is example.com.

subdomain: "example.com"

The Okteto frontend and API are available at https://okteto.$SUBDOMAIN. Once Okteto is installed, get the public address of the Okteto NGINX Ingress Controller with kubectl:

kubectl get service -l=app.kubernetes.io/name=ingress-nginx,app.kubernetes.io/component=controller --namespace=okteto

The output looks like this:

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
okteto-ingress-nginx-controller LoadBalancer 10.0.7.73 34.68.230.234 80:30795/TCP,443:32481/TCP,1234:30885/TCP 5m

Create a DNS entry for *.$SUBDOMAIN that points to the EXTERNAL-IP address.

To change the Okteto public URL, use the publicOverride field.

publicOverride​

Overrides the public URL where Okteto is available. It replaces okteto.$SUBDOMAIN with the FQDN you choose.

publicOverride: "example.com"

Once you set this in your Helm configuration file, make sure to point the Okteto Ingress Controller's IP address to this domain using your DNS provider. The IP address can be found by running the following command (like we did during the install phase):

kubectl get service -l=app.kubernetes.io/name=ingress-nginx,app.kubernetes.io/component=controller --namespace=okteto

Important: When you use publicOverride, the certificate that wildcardCertificate.name refers to must be valid for publicOverride, registry.$SUBDOMAIN, and buildkit.$SUBDOMAIN.

When publicOverride is set, Okteto deploys an additional component for Okteto Private Endpoints. Configure it in the privateEndpoints section.

The callback URL and the origin URL of your auth provider change to:

Callback URL:

https://${publicOverride}/auth/callback
https://private-endpoints.${subdomain}/auth/callback

Origin URL:

https://${publicOverride}
https://private-endpoints.${subdomain}

auth​

The auth property defines which users can access Okteto and how they log in.

Okteto integrates with these OAuth2 providers:

For evaluations, Okteto also supports single-user authentication with a token.

Theme​

Customizes the logo and the sidebar colors of the Okteto UI to match your team's identity.

  • logo: The logo displayed at the far top left of the Okteto UI. The value can be a url or a Base64 encoded image.
  • primary: The primary color of the sidebar. This is used for the color of the sidebar. The value can be a HTML color name (e.g. blue, red) or a hexadecimal code.
  • secondary: The secondary color of the sidebar. This is used for the icons and the text displayed in the sidebar. The value can be a HTML color name (e.g. blue, red) or a hexadecimal code.
theme:
logo: http://example.com/icon.png
primary: \#EFF3F2
secondary: black

Okteto Components​

api​

The API service. Account and Kubernetes credentials management, namespace creation, and sharing, deployment via the catalog, etc...

  • annotations: Annotations to add to the API pods.
  • extraEnv: Environment variables for the API containers.
  • labels: Labels to add to the API pods.
  • priorityClassName: The priority class for the API pods. The PriorityClass must already exist in your cluster. This value takes precedence over globals.priorityClassName. If it isn't set, the pods inherit the priority class from globals.priorityClassName.
  • replicaCount: The number of API pods. It defaults to 2.
  • resources: The resources for the API pods.
api:
extraEnv:
- name: NO_PROXY
value: ".example.com"
replicaCount: 2
resources:
requests:
cpu: 100m
memory: 128Mi

autoscaler (deprecated)​

The cluster autoscaler service. Disabled by default. It instructs the Kubernetes cluster autoscaler to scale nodes if the real cpu/memory usage of a node is beyond the limits. Use tolerations.devPool to limit the autoscaler analysis to a subset of cluster nodes.

Requirements: the cluster autoscaler and the metrics server must be installed in your cluster.

  • annotations: Annotations to add to the autoscaler pods.
  • cpu.up: Increase the cluster size when the CPU consumption is greater than or equal to this value. It defaults to 60 percent.
  • cpu.down: Decrease the cluster size when the CPU consumption is less than this value. It defaults to 40 percent.
  • image: The image the autoscaler uses to deploy the autoscaler agent. It defaults to busybox.
  • labels: Labels to add to the autoscaler pods.
  • memory.up: Increase the cluster size when the Memory consumption is greater than or equal to this value. It defaults to 70 percent.
  • memory.down: Decrease the cluster size when the Memory consumption is lesser than this value. It defaults to 50 percent.
  • nodes.increment: The number of new nodes to request when all the current nodes are overloaded. e.g. if this value is 3, the autoscaler will request 3 new nodes when all the cluster nodes are overloaded. It defaults to 1.
  • nodes.min: Minimum number of nodes in the cluster. It defaults to 1.
  • nodes.max: Maximum number of nodes in the cluster. It defaults to 10. Zero means unlimited.
  • nodes.poolLabel: The node label that identifies a node's pool. For example, cloud.google.com/gke-nodepool in GKE and eks.amazonaws.com/nodegroup in EKS. If set, the autoscaler scales each node pool independently.
  • pods.up: Increase the cluster size when the ratio of pods in a node to the maximum pods per node is greater than or equal to this value. It defaults to 90 percent.
  • pods.down: Decrease the cluster size when the ratio of pods in a node to the maximum pods per node is less than this value. It defaults to 80 percent.
  • priorityClassName: The priority class for the autoscaler pods.
  • schedule: How often, in seconds, the autoscaler checks whether the cluster needs scaling. It defaults to 300.
  • slackWebhook: A Slack webhook URL where the autoscaler sends notifications of its events.
  • volumes.up: Increase the cluster size when the ratio of volumes in a node to the maximum volumes per node is greater than or equal to this value. It defaults to 90 percent.
  • volumes.down: Decrease the cluster size when the ratio of volumes in a node to the maximum volumes per node is less than this value. It defaults to 80 percent.
autoscaler:
enabled: false
image: busybox
schedule: 300
cpu:
up: 60
down: 40
memory:
up: 70
down: 50
pods:
up: 90
down: 80
volumes:
up: 90
down: 80
nodes:
increment: 1
min: 1
max: 10
poolLabel: cloud.google.com/gke-nodepool
slackWebhook: https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX

buildkit​

The Okteto Build Service. okteto build uses it to build container images in the cluster.

  • port: The port of the BuildKit StatefulSet. Defaults to 443.
  • annotations: Annotations to add to the BuildKit pods.
  • extraEnv: Environment variables for the BuildKit containers.
  • hpa.enabled: Enables horizontal pod autoscaling for the BuildKit pods. Disabled by default.
  • hpa.min: Minimum number of BuildKit pods to keep running. Defaults to 1.
  • hpa.max: Maximum number of BuildKit pods to scale to. Defaults to 5.
  • hpa.metrics: The target metrics that make the HPA scale the BuildKit pods. Defaults to the okteto_build_active_builds metric with an average value target of 0.99.
  • hpa.behavior: The scaling behavior of the HPA for the BuildKit pods. By default, it adds up to one pod every 30 seconds when builds pile up, and after a 600-second stabilization window it removes up to one pod every 150 seconds.
  • hpa.adapter.enabled: Creates the metrics adapter Deployment, Service, and APIService. Enabled by default when the HPA is enabled. The adapter exposes BuildKit metrics through the Kubernetes custom metrics API.
  • hpa.adapter.extraEnv: Environment variables for the adapter containers.
  • hpa.adapter.priorityClassName: The priority class for the adapter pods. The PriorityClass must already exist in your cluster. This value takes precedence over globals.priorityClassName. If it isn't set, the pods inherit the priority class from globals.priorityClassName.
  • hpa.adapter.replicaCount: The number of adapter pods. Defaults to 2.
  • hpa.adapter.resources: The resources for the adapter pods. Defaults to 100m CPU and 128Mi memory requests.
  • hpa.adapter.apiService.name: The name of the APIService. Defaults to v1beta2.custom.metrics.k8s.io.
  • hpa.adapter.apiService.group: The API group. Defaults to custom.metrics.k8s.io.
  • hpa.adapter.apiService.version: The API version. Defaults to v1beta2.
  • hpa.adapter.apiService.groupPriorityMinimum: The priority of the API group. Defaults to 100.
  • hpa.adapter.apiService.versionPriority: The priority of the API version. Defaults to 100.
  • labels: Labels to add to the BuildKit pods.
  • podManagementPolicy: The podManagementPolicy of the BuildKit pods. Defaults to Parallel.
  • priorityClassName: The priority class for the BuildKit pods. The PriorityClass must already exist in your cluster. This value takes precedence over globals.priorityClassName. If it isn't set, the pods inherit the priority class from globals.priorityClassName.
  • replicaCount: The number of BuildKit pods. It defaults to 1.
  • resources: The resources for the BuildKit pods.
  • serviceAccount.create: Creates a service account for BuildKit. Defaults to true.
  • serviceAccount.name: The name of the BuildKit service account. Defaults to okteto-buildkit.
  • serviceAccount.annotations: Annotations for the BuildKit service account.
  • serviceAccount.labels: Labels for the BuildKit service account.
  • service.loadBalancerSourceRanges: List of CIDR blocks allowed to access the BuildKit service when using a LoadBalancer. Defaults to []. Ignored for other service types.
  • persistence.enabled: Configures a persistence volume for buildkit. Enabled by default.
  • persistence.class: The storage class of the persistence volume attached to every buildkit pod.
  • persistence.size: The size of the persistence volume attached to every buildkit pod. Defaults to 750Gi.
  • persistence.cacheRatio: What percentage the persistence size should be used for the cache. Value should be between 0 and 1. Defaults to 0.5.
  • terminationGracePeriodSeconds: Duration in seconds for graceful pod termination. Defaults to 600 (10 minutes). This allows ongoing builds to complete before the pod is terminated.
  • tolerations: List of tolerations to be added to the Buildkit pods. If not set, the Buildkit pods will inherit the tolerations list set in globals.tolerations.okteto.
  • nodeSelectors: Dictionary of node selectors to be added to the Buildkit pods. If not set, the Buildkit pods will inherit the node selectors dictionary set in globals.nodeSelectors.okteto.
  • network.mode: Controls the networking environment for containers during the build process. Defaults to auto but can be set to host, none, or bridge. Bridge mode can be useful for preventing port collisions in concurrent builds by isolating network environments.
buildkit:
port: 443
extraEnv:
- name: NO_PROXY
value: ".example.com"
replicaCount: 1
persistence:
enabled: true
class: ssd
size: 180Gi
cacheRatio: 0.8
tolerations:
- key: "okteto-buildkit"
operator: "Equal"
value: "buildkit"
effect: "NoExecute"
nodeSelectors:
okteto-node-label: build
region: west
terminationGracePeriodSeconds: 600
hpa:
enabled: true
min: 1
max: 5
metrics:
- type: Pods
pods:
metric:
name: okteto_build_active_builds
target:
type: AverageValue
averageValue: "0.99"
behavior:
scaleUp:
policies:
- type: Pods
value: 1
periodSeconds: 30
scaleDown:
stabilizationWindowSeconds: 600
policies:
- type: Pods
value: 1
periodSeconds: 150
adapter:
enabled: true
replicaCount: 2
resources:
requests:
cpu: 100m
memory: 128Mi

To handle timeouts in the communication between the client and the BuildKit daemon, set these environment variables on the server side:

  • OKTETO_KEEPALIVE_SERVER_TIME_MS: If the server sees no activity for this duration, it pings the client to check that the transport is still alive. Values below 1s are raised to 1s. Defaults to 2 hours.
  • OKTETO_KEEPALIVE_SERVER_TIMEOUT_MS: After a keepalive ping, the server waits this long for activity. If it sees none, it closes the connection. Defaults to 20 seconds.
  • OKTETO_KEEPALIVE_SERVER_MAX_CONN_IDLE_MS: How long a connection can stay idle before the server closes it by sending a GOAWAY. A connection is idle since it was established or since the number of outstanding RPCs last dropped to zero, whichever is more recent. Defaults to infinity.
  • OKTETO_KEEPALIVE_SERVER_MAX_CONN_AGE_MS: The maximum time a connection can exist before the server closes it by sending a GOAWAY. The server adds a random jitter of +/-10% to the value to spread out connection storms. Defaults to infinity.
  • OKTETO_KEEPALIVE_SERVER_MAX_CONN_AGE_GRACE_MS: An extra period after OKTETO_KEEPALIVE_SERVER_MAX_CONN_AGE_MS, after which the server forcibly closes the connection. Defaults to infinity.
  • OKTETO_KEEPALIVE_SERVER_POLICY_MINTIME_MS: The minimum time a client should wait before sending a keepalive ping. Defaults to 5 minutes.
  • OKTETO_KEEPALIVE_SERVER_POLICY_PERMIT_WITHOUT_STREAM: If true, the server allows keepalive pings even when there are no active streams (RPCs). If false and the client sends pings with no active streams, the server sends a GOAWAY and closes the connection. Defaults to false.

cli​

Settings for the Okteto CLI. The cli section sets the Docker image that the Okteto CLI uses for cluster-wide operations. Change it to use your own Docker images.

  • image: The image settings for the Okteto CLI.
    • registry: The registry where the Okteto CLI image is hosted. Defaults to ghcr.io.
    • repository: The repository path for the Okteto CLI image. Defaults to okteto/okteto.
cli:
image:
registry: "my-custom-registry:5000"
repository: "okteto/okteto"
note

Please Note:

  • Modifying these settings will change the image used globally by all users of the Okteto CLI in the cluster
  • The hosted CLI version must match the original version to ensure compatibility with the remote. For example, if your cluster supports ghcr.io/okteto/okteto:3.2.0, the hosted image should be myregistry/okteto:3.2.0
  • This configuration is separate from the initContainer setting in the okteto.yaml manifest. While the CLI settings apply globally to all users and operations, the initContainer setting is specific to a Development Environment or application and can be customized for pre-startup tasks

daemonset​

The daemonset configures every node in your cluster to work with Okteto.

  • enabled: Whether to install the daemonset. Defaults to true.
  • annotations: Annotations to add to the daemonset pods.
  • extraEnv: Environment variables for the daemonset containers.
  • labels: Labels to add to the daemonset pods.
  • configurePrivateRegistriesInNodes.enabled: Specifies if the daemonset should configure the private registry credentials in the nodes for kubelet or not. It defaults to false. It's disabled if regcredsManager.pullSecrets.enabled=true.
  • priorityClassName: The priority class to be used by the daemonset pods. The PriorityClass must already exist in your cluster before using this setting. This value has precedence over globals.priorityClassName if both are set. If this value is not set, the pods will inherit the priority class defined by the value set in globals.priorityClassName.

The daemonset runs these tasks on each node:

  • Overrides the Okteto Registry hostname resolution to use internal IPs.
  • Overrides the default kernel values for file watchers on every node.
  • Configures the kubelet with registry credentials for private registries (if configurePrivateRegistriesInNodes.enabled=true and regcredsManager.pullSecrets.enabled=false).
  • Installs your CA if wildcardCertificate.privateCA is enabled.
  • Installs a CA if using self-signed certificates (wildcardCertificate.create: true).

To restrict the nodes where the daemonset runs, use the dev tolerations and nodeSelectors:

tolerations:
devPool: dev

defaultBackend​

The defaultBackend receives failed requests from the ingress controller, transforms them, and returns them to the client.

  • affinity: Affinities to add to the defaultBackend pods.
  • annotations: Annotations to add to the defaultBackend pods.
  • enabled: Whether to deploy the defaultBackend. Defaults to true.
  • extraEnvs: Environment variables for the defaultBackend containers.
  • labels: Labels to add to the defaultBackend pods.
  • nameOverride: Overrides the full name of the defaultBackend service.
  • port: The internal port of the defaultBackend. Defaults to 8080.
  • priorityClassName: The priority class for the defaultBackend pods. The PriorityClass must already exist in your cluster. This value takes precedence over globals.priorityClassName. If it isn't set, the pods inherit the priority class from globals.priorityClassName.
  • replicaCount: The number of defaultBackend pods. It defaults to 2.
  • resources: The resources for the defaultBackend pods.
defaultBackend:
replicaCount: 3
resources:
requests:
cpu: 100m
memory: 128Mi

The defaultBackend provides these features:

  • Autowake Namespaces: When a user accesses an endpoint of a sleeping Namespace, the defaultBackend issues a wake command.
  • Custom error pages: When an endpoint returns an error, the defaultBackend serves a custom error page with hints to resolve the issue, instead of a generic error message. Common cases are sleeping Namespaces and unavailable services. The error pages work automatically, with no configuration.
tolerations:
devPool: dev

frontend​

The frontend service serves the Okteto web application.

  • annotations: Annotations to add to the frontend pods.
  • extraEnv: Environment variables for the frontend containers.
  • labels: Labels to add to the frontend pods.
  • priorityClassName: The priority class for the frontend pods. The PriorityClass must already exist in your cluster. This value takes precedence over globals.priorityClassName. If it isn't set, the pods inherit the priority class from globals.priorityClassName.
  • replicaCount: The number of frontend pods. It defaults to 2.
  • resources: The resources for the frontend pods.
frontend:
extraEnv:
- name: NO_PROXY
value: ".example.com"
replicaCount: 2
resources:
requests:
cpu: 100m
memory: 128Mi

gc​

The Okteto Garbage Collector scales idle applications to zero and deletes unused Namespaces to reduce infrastructure costs. It's enabled by default.

You can also configure the Garbage Collector in the Admin Dashboard, under Admin → Garbage Collector in the Settings section.

  • annotations: Annotations to add to the Garbage Collector pods.
  • labels: Labels to add to the Garbage Collector pods.
  • slackWebhook: If set, the Garbage Collector sends a notification when it scales a resource to zero or deletes a Namespace.
  • upSessionByLastSyncedFile: If true, the Garbage Collector scales okteto up sessions to zero when no files were synchronized during the scale-to-zero period. By default, it checks for an active connection, regardless of inactivity.
  • priorityClassName: The priority class for the Garbage Collector pods. The PriorityClass must already exist in your cluster. This value takes precedence over globals.priorityClassName. If it isn't set, the pods inherit the priority class from globals.priorityClassName.
gc:
enabled: true
upSessionByLastSyncedFile: false
slackWebhook: https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX

insights​

Configures the Okteto Insights component in your Okteto instance.

  • enabled: Whether to enable Okteto Insights. Defaults to false.
  • bearerSecret.name: The name of the secret that stores the token to access the Okteto Insights metrics. Defaults to okteto-insights.
  • bearerSecret.key: The key in the secret that stores the token to access the Okteto Insights metrics. Defaults to bearer.
insights:
enabled: false
bearerSecret:
name: okteto-insights
key: bearer

When Okteto Insights is enabled, Okteto also installs the Event Exporter component and the Insights Metrics CronJob.

The Event Exporter receives Okteto CLI events through Kubernetes Events and injects them as Okteto Insights metrics.

  • priorityClassName: The priority class for the Event Exporter pods. The PriorityClass must already exist in your cluster. This value takes precedence over globals.priorityClassName. If it isn't set, the pods inherit the priority class from globals.priorityClassName.
  • podAnnotations: Annotations to add to the Event Exporter pods.
  • podLabels: Labels to add to the Event Exporter pods.
  • resources: The resources for the Event Exporter pods.
insights:
eventsExporter:
priorityClassName:
podLabels: {}
podAnnotations: {}
resources:
requests:
cpu: 50m
memory: 20Mi
limits:
memory: 100Mi

Insights Metrics is a CronJob that precomputes metrics for the Okteto Insights /metrics endpoint.

  • annotations: Annotations to add to the Insights Metrics pods.
  • labels: Labels to add to the Insights Metrics pods.
  • priorityClassName: The priority class for the Insights Metrics pods. The PriorityClass must already exist in your cluster. This value takes precedence over globals.priorityClassName. If it isn't set, the pods inherit the priority class from globals.priorityClassName.
  • resources: The resources for the Insights Metrics pods.
  • schedule: How often the CronJob runs, in cron syntax. Defaults to every 5 minutes (*/5 * * * *).
insights:
metrics:
annotations: {}
labels: {}
priorityClassName:
resources:
requests:
cpu: 50m
memory: 20Mi
limits:
memory: 100Mi
schedule: "*/5 * * * *"

installer​

The jobs that deploy your application environments from Git.

  • annotations: Annotations to add to the installer job pods.
  • extraEnv: Environment variables for the installer job containers.
  • labels: Labels to add to the installer job pods.
  • runner: Configures your custom installer image.
    • registry: The registry where the installer image is hosted. Defaults to the value of globals.registry.
    • repository: The repository path for the installer image. Defaults to okteto/pipeline-runner.
    • tag: The image tag to deploy. Defaults to 1.42.0.
  • activeDeadlineSeconds: The maximum duration of the pipeline, in seconds.
  • gitSSHUser: The user for cloning Git repositories over SSH.
  • sshSecretName: The name of the secret with the private key for cloning Git repositories over SSH. If the secret doesn't exist, Okteto generates the key and the secret.
  • resources: The resources for the installer job pods.
  • priorityClassName: The priority class for the installer job pods. The PriorityClass must already exist in your cluster. This value takes precedence over globals.priorityClassName. If it isn't set, the pods inherit the priority class from globals.priorityClassName.
  • securityContext: The security context for the installer job container, in the Kubernetes syntax. Not set by default.
  • extraInitContainers: List of init containers to add to the installer job pods.
installer:
runner:
repository: okteto/pipeline-runner
tag: 1.42.0
extraEnv:
- name: NO_PROXY
value: ".example.com"
activeDeadlineSeconds: 1800
gitSSHUser: git
sshSecretName: "okteto-ssh"
securityContext:
allowPrivilegeEscalation: false
resources:
requests:
cpu: 10m
memory: 50Mi

oktetoAI​

The Okteto AI section configures the Okteto AI feature in your cluster:

  • enabled: Whether to enable Okteto AI in your cluster. Defaults to true.
  • image.repository: The repository path for the Okteto AI image. Defaults to okteto/agent.
  • image.tag: The image tag to deploy. Defaults to 1.42.0.
  • resources: The resources for the Okteto AI Agent pods.
oktetoAI:
enabled: true
resources:
requests:
cpu: 50m
memory: 400Mi

privateEndpoints​

When publicOverride is set, Okteto deploys an additional component for Okteto Private Endpoints. It authenticates and authorizes the requests to Okteto Endpoints in private mode.

  • port: The internal port of the Private Endpoints component. Defaults to 8080.
  • resources: The resources for the Private Endpoints component pods.
  • replicaCount: The number of Private Endpoints component pods. It defaults to 1.
  • annotations: Annotations to add to the Private Endpoints component pods.
  • priorityClassName: The priority class for the Private Endpoints pods. The PriorityClass must already exist in your cluster. This value takes precedence over globals.priorityClassName. If it isn't set, the pods inherit the priority class from globals.priorityClassName.

By default, the Private Endpoints component inherits the configuration of the auth section. You can override some of its values with these properties:

  • clientID: Overrides auth.*.clientID.
  • clientSecret: Overrides auth.*.clientSecret.

prepullImages​

The prepull images daemonset makes the essential Okteto images available on every node in your cluster. Jobs and operations start faster, because their containers don't pull images when they're created.

note

The prepullImages feature assumes that your cluster nodes can pull every Okteto image, either because the images are public or through IAM roles or permissions configured on the nodes. Okteto makes the same assumption for every image in the Okteto control plane. This feature doesn't add image pull secrets or any authentication configuration.

  • enabled: Whether to install the prepull images daemonset. It defaults to true.
  • priorityClassName: The priority class for the prepull images pods. The PriorityClass must already exist in your cluster. This value takes precedence over globals.priorityClassName. If it isn't set, the pods inherit the priority class from globals.priorityClassName.
prepullImages:
enabled: true
priorityClassName: "high-priority"

The daemonset prepulls these images on every node:

  • ghcr.io/okteto/backend:1.42.0
  • ghcr.io/okteto/pipeline-runner:1.42.0
  • ghcr.io/okteto/okteto:3.17.1

regcredsManager​

Settings for the Registry Credentials Operator's controller manager.

The controller manager runs as a Deployment and manages the private registry credentials in the cluster. If pullSecrets.enabled=true, it copies every private registry credential to the okteto-regcred secret in users' Namespaces and in Preview Environments. If pullSecrets.enabled=false and daemonset.configurePrivateRegistriesInNodes.enabled=true, the Okteto daemonset copies the credentials to every node.

  • priorityClassName: The priority class for the controller manager pods. The PriorityClass must already exist in your cluster. This value takes precedence over globals.priorityClassName. If it isn't set, the pods inherit the priority class from globals.priorityClassName.
  • pullSecrets.enabled: If enabled, Okteto writes the private registry credentials defined in the cluster to users' Namespaces as pull secrets, instead of to the nodes. Defaults to true.
  • podAnnotations: Annotations to add to the controller manager pods.
  • podLabels: Labels to add to the controller manager pods.
  • webhookTimeout: The timeout, in seconds, for requests to the validating webhook server.
  • replicas: The number of controller manager pods. The controller runs as a Deployment with leader election. Use at least 2 replicas.
  • resources: The resources for the controller manager pods.
regcredsManager:
priorityClassName:
pullSecrets:
enabled: true
podLabels: {}
podAnnotations: {}
webhookTimeout: 30
replicas: 2
resources:
requests:
cpu: 50m
memory: 100Mi
limits:
memory: 800Mi

redis​

Configures Redis for the Resource Manager. Okteto installs Redis only when the Resource Manager is enabled.

  • annotations: Annotations to add to the Redis pods.
  • args: Additional arguments for the Redis container command.
  • extraEnv: Environment variables for the Redis containers.
  • image.repository: The repository path for the Redis image. Defaults to okteto/redis.
  • image.tag: The image tag for the Redis image. Defaults to 1.42.0.
  • labels: Labels to add to the Redis pods.
  • port: The port Redis listens on. Defaults to 6379.
  • resources: The resources for the Redis pods.

resourceManager​

Configures the Resource Manager.

  • annotations: Annotations to add to the Resource Manager pods.
  • deletePeriodDays: The retention period for recommendations, in days. When a service is no longer deployed in your cluster, Okteto deletes its recommendation after this period. It defaults to 15 days.
  • enabled: Whether to install the Resource Manager. When it's installed, Okteto creates a CronJob that computes CPU and memory recommendations for your pods. It defaults to true.
  • labels: Labels to add to the Resource Manager pods.
  • priorityClassName: The priority class for the Resource Manager pods. The PriorityClass must already exist in your cluster. This value takes precedence over globals.priorityClassName. If it isn't set, the pods inherit the priority class from globals.priorityClassName.
  • recommendations.correction: A floating-point multiplier that adjusts for over- or under-provisioning of resources. It must be greater than 0. The default is 1.1, which over-provisions by 10%. For example, 0.9 under-provisions by 10% compared to the average utilization.
  • recommendations.min.cpu: The minimum CPU request that the Resource Manager sets when it applies recommendations. It uses this value when a recommendation isn't calculated yet or is lower. It defaults to 5m.
  • recommendations.min.memory: The minimum memory request that the Resource Manager sets when it applies recommendations. It uses this value when a recommendation isn't calculated yet or is lower. It defaults to 10Mi.
  • recommendations.weight: A floating-point number between 0 and 1 used to stabilize CPU and memory recommendation calculations. A higher value (closer to 1) gives more weight to historical resource usage trends, making the Resource Manager less responsive to recent changes or spikes. A lower value (closer to 0) makes it more reactive to recent usage patterns, including spikes. The default value is 0.9, which makes the Resource Manager conservative: it favors existing trends and tries to ignore minor fluctuations.
  • resources: The resources for the Resource Manager pods.
  • schedule: How often Okteto calculates resource recommendations, in cron syntax. Defaults to every 5 minutes (*/5 * * * *).
resourceManager:
enabled: true
schedule: "*/5 * * * *"
deletePeriodDays: 15
recommendations:
weight: 0.9
correction: 1.1
min:
cpu: 5m
memory: 10Mi
priorityClassName:
labels: {}
annotations: {}
resources: {}

registry​

Configures the Okteto Registry. The Okteto Registry storage guides explain how to store your images in the storage driver you choose.

The Okteto Registry settings are:

  • annotations: Annotations to add to the registry pods.
  • extraEnv: Environment variables for the registry containers.
  • ingress.annotations: Annotations to add to the registry ingress. These annotations take precedence over the ones defined in the ingress section.
  • labels: Labels to add to the registry pods.
  • pullPolicy: The security policy for image pulls. With cluster, any Okteto user can pull any image from the registry. With namespace, only users with access to a Namespace can pull its images. It defaults to namespace.
  • priorityClassName: The priority class for the registry pods. The PriorityClass must already exist in your cluster. This value takes precedence over globals.priorityClassName. If it isn't set, the pods inherit the priority class from globals.priorityClassName.
  • replicaCount: The number of registry pods. It defaults to 1.
  • resources: The resources for the registry pods.
  • serviceAccountName: An alternative service account for the registry. It must exist in the namespace of the Okteto Helm release. Defaults to none.
  • serviceAccount.annotations: Annotations to add to the registry service account.
  • secret.name: With external storage, the name of the secret that holds your cloud provider credentials.
  • secret.accessKey: The key for the access key in the secret.name secret. Defaults to accessKey.
  • secret.secretKey: The key for the secret key in the secret.name secret. Defaults to secretKey.
  • storage: The storage configuration, described in the Okteto Registry storage guides.

sshAgent​

The SSH Agent service. It runs an SSH agent with Okteto's SSH key, which the commands in your Okteto Manifest use to clone private repositories during Remote Execution.

  • annotations: Annotations to add to the ssh-agent pods.
  • extraEnv: Environment variables for the ssh-agent containers.
  • labels: Labels to add to the ssh-agent pods.
  • port: The internal port the ssh-agent listens on. Defaults to 3000.
  • priorityClassName: The priority class for the ssh-agent pods. The PriorityClass must already exist in your cluster. This value takes precedence over globals.priorityClassName. If it isn't set, the pods inherit the priority class from globals.priorityClassName.
  • replicaCount: The number of ssh-agent pods. Defaults to 2.
  • resources: The resource requests and limits for the ssh-agent pods.
sshAgent:
annotations: {}
extraEnv: []
labels: {}
port: 3000
priorityClassName:
replicaCount: 2
resources:
requests:
cpu: 10m
memory: 10Mi

telemetry​

The telemetry job sends this information to Okteto once a day:

  • Number of managed users
  • Number of managed Namespaces
  • Kubernetes version and platform
  • A unique install ID
  • Your license ID
  • The name of the authentication provider
  • The name of the cloud provider

Okteto uses this information to understand how customers use Okteto and to prioritize fixes and features. We don't share your information with anyone else.

  • enabled: Whether to run the telemetry job. Defaults to true.
  • priorityClassName: The priority class for the telemetry pods. The PriorityClass must already exist in your cluster. This value takes precedence over globals.priorityClassName. If it isn't set, the pods inherit the priority class from globals.priorityClassName.
telemetry:
enabled: true

Disabling telemetry also disables the Okteto CLI analytics.

webhook​

The webhook service. Ingress creation, generation of hostnames, enforcement of policies, etc...

  • annotations: Annotations to add to the webhook pods.
  • extraEnv: Environment variables for the webhook containers.
  • hostNetwork: Whether the webhook Deployment uses host networking. Defaults to false.
  • labels: Labels to add to the webhook pods.
  • port: The port of the webhook Deployment. Defaults to 443.
  • priorityClassName: The priority class for the webhook pods. The PriorityClass must already exist in your cluster. This value takes precedence over globals.priorityClassName. If it isn't set, the pods inherit the priority class from globals.priorityClassName.
  • replicaCount: The number of webhook pods. It defaults to 2.
  • resources: The resources for the webhook pods.

Advanced Configuration​

affinity​

Default affinities for the pods in Namespaces managed by Okteto (devPool) and for the Okteto pods (oktetoPool).

  • devPool: Affinities for pods created in Namespaces managed by Okteto.
  • oktetoPool: Affinities for pods created during the Okteto installation.
affinity:
devPool:
preferredDuringSchedulingIgnoredDuringExecution:
- preference:
matchExpressions:
- key: cloud.google.com/spot
operator: In
values:
- "true"
weight: 10
oktetoPool:
preferredDuringSchedulingIgnoredDuringExecution:
- preference:
matchExpressions:
- key: dev.okteto.com/overloaded
operator: DoesNotExist
weight: 50

In this example, pods in Namespaces created by Okteto prefer to land on spot nodes.

autowake​

When enabled, Okteto wakes up a sleeping Namespace when it receives a request to any of the Namespace's public endpoints (default: true).

autowake:
enabled: true

convertLoadBalancedServices​

Converts services with type LoadBalancer into ClusterIP and automatically creates an ingress. Enabled by default.

convertLoadBalancedServices:
enabled: true

crds​

Configures the CRDs that Okteto manages.

  • annotations: The annotations to apply to the CRDs created during the Okteto installation.
  • keep: Keeps the CRDs when you uninstall the chart. Defaults to true.
  • install: Installs and upgrades the CRDs when you install the chart. Defaults to true.
crds:
install: true
keep: true
annotations: {}

devStorageClass​

Sets the storage class for every persistent volume claim that okteto up creates. It overrides any storage class defined in the Okteto Manifest. Disabled by default.

  • storageClass: The storage class enforced for persistent volume claims created by okteto up.
devStorageClass:
enabled: true
storageClass: ebs-sc

There's one exception: if you configure Volume Snapshots and the snapshots require a storage class, that storage class takes precedence.

fullnameOverride​

The Okteto chart combines the release name and the chart name into a prefix for the names of the Kubernetes resources it creates. This property overrides the whole prefix. To override only the chart name, use the nameOverride setting.

fullnameOverride: custom-prefix

fullnameOverride can be up to 34 characters long. If you need a longer prefix, extend the limit to 40 characters.

globals​

Global settings for all Okteto components.

jobs​

Global configuration for the jobs created in the okteto namespace:

  • ttlSecondsAfterFinished: How long, in seconds, to keep a finished job before deleting it. Defaults to 86400 (1 day).
globals:
jobs:
ttlSecondsAfterFinished: 86400

nodeSelectors​

Node selectors for pods, grouped under okteto and dev:

  • okteto: Node selectors applied to pods running in the okteto namespace, excluding the Okteto Daemonset.
  • dev: Node selectors applied to pods created by user applications, which run in namespaces managed by Okteto. These node selectors are only applied when a corresponding tolerations.devPool is defined. It also applies to the Okteto Daemonset. This is a legacy behavior and may change in future releases.
globals:
nodeSelectors:
okteto:
okteto-node-label: okteto
dev:
okteto-node-label: dev
region: east
note

Node selectors defined in globals.nodeSelectors.dev will not be applied to user workloads unless a tolerations.devPool value is also set. This coupling is due to a legacy implementation and may be revised in future updates.

priorityClassName​

The priority class for all pods in the okteto namespace. The priority class must already exist in your cluster.

globals:
priorityClassName: okteto-priority

registry​

The registry for all Okteto components, except the Okteto CLI. The air-gapped installation guide has more details.

globals:
registry: my-custom-registry:5000

tolerations​

Tolerations for pods, grouped under okteto and dev:

  • okteto: Tolerations applied to pods running in the okteto namespace, excluding the Okteto Daemonset.
  • dev: Tolerations applied to pods created by user applications, which run in namespaces managed by Okteto. Required for globals.nodeSelectors.dev to take effect. This also applies to the Okteto Daemonset.
globals:
tolerations:
okteto:
- key: "kubernetes.io/arch"
operator: "Equal"
value: "arm64"
effect: "NoSchedule"
dev:
- key: "kubernetes.io/arch"
operator: "Equal"
value: "arm64dev"
effect: "NoSchedule"
note

To apply node selectors for user workloads, you must define a devPool entry in globals.tolerations. See the nodeSelectors section for more details.

ingress​

Default values for the ingresses that Okteto creates.

  • annotations: The annotations to apply to all the ingresses created during the Okteto installation.
  • oktetoIngressClass: The ingressClassName to apply to all the ingresses created during the Okteto installation (defaults to okteto-controlplane-nginx).
  • class: If set, Okteto sets it as the ingressClassName of every ingress it manages. Set it when your cluster has more than one ingress controller. If not set, Okteto falls back to the cluster's default ingress class.
  • forceIngressClass: If enabled, every ingress deployed in Namespaces managed by Okteto gets the ingress class defined in ingress.class (default: false).
  • forceIngressSubdomain: If enabled, the host subdomain of every ingress deployed in Namespaces managed by Okteto must match the Okteto wildcard subdomain (default: false).
  • ip: The internal IP of the ingress. Pods call the Okteto API and the Okteto Registry on this IP. Required if you disable the installation of the Okteto NGINX Ingress Controller.
ingress:
annotations: {}
oktetoIngressClass: nginx
class: nginx
forceIngressClass: false
forceIngressSubdomain: true
ip: ""

ingressLimits​

Connection limits for the ingress of each public endpoint. Disabled by default.

  • connections: Maximum parallel connections for each ingress.
  • rps: Maximum requests per second for each ingress.
  • rpm: Maximum requests per minute for each ingress.
ingressLimits:
enabled: true
connections: 40
rps: 40
rpm: 400

internalCertificate​

Configures the certificate that Okteto creates for internal communication. The MutatingWebhookConfiguration and ValidatingWebhookConfiguration Kubernetes objects that Okteto creates use this certificate.

  • durationDays: The expiration time, in days (default: 10 years).
  • annotations: Annotations to add to the kubernetes.io/tls secret that stores the certificate.
internalCertificate:
durationDays: 3650
annotations: {}

kubetoken​

  • lifetimeSeconds: The lifetime, in seconds, of the tokens that Okteto generates for its Kubernetes credentials. It must be equal to or greater than installer.activeDeadlineSeconds, so the tokens stay valid for the whole installer run. Defaults to 86400 seconds (1 day).

The maximum expiration time depends on the --service-account-max-token-expiration flag of the Kubernetes API server, so your tokens might get a different expiration time than the one you set here. If you set a higher value, you get the maximum that the API server allows. Some Kubernetes providers don't let you change this flag and enforce their own value.

nameOverride​

The Okteto chart combines the release name and the chart name into a prefix for the names of the Kubernetes resources it creates. This property overrides the chart name part of the prefix. To override the whole prefix, use the fullnameOverride setting.

nameOverride: custom-chart-name-override

The whole prefix can be up to 34 characters long. If you need a longer prefix, extend the limit to 40 characters.

namespace​

Custom annotations and labels for the Namespaces that Okteto creates. Okteto adds them to the annotations and labels it already applies.

  • annotations: Annotations for each Namespace that Okteto creates.
  • labels: Labels for each Namespace that Okteto creates.
  • ingress.annotations: Annotations for the ingresses in Namespaces that Okteto creates.
  • ingress.labels: Labels for the ingresses in Namespaces that Okteto creates.
  • autoRoleBinding.enabled: Binds the default service account of every Namespace managed by Okteto to the cluster role set in serviceAccounts.roleBindings.namespaces. This gives every pod without a custom service account access to the Kubernetes API. Defaults to true.
namespace:
annotations:
development: "true"
labels:
istio-injection: enabled
ingress:
annotations:
cert-manager.io/issuer: "letsencrypt"
labels:
development: "true"

networkPolicies​

Configures network policies that isolate the network traffic of each Namespace. Disabled by default.

  • ingress: Ingress list of rules (NetworkPolicyIngressRule) to be applied on every namespace managed by Okteto. (optional).
  • egress: Egress list of rules (NetworkPolicyEgressRule) to be applied on every namespace managed by Okteto (optional).
networkPolicies:
enabled: true
ingress:
- from:
- ipBlock:
cidr: 172.17.0.0/16
except:
- 172.17.1.0/24
- namespaceSelector:
matchLabels:
project: myproject
- podSelector:
matchLabels:
role: frontend
ports:
- protocol: TCP
port: 6379
egress:
- to:
- ipBlock:
cidr: 10.0.0.0/24
ports:
- protocol: TCP
port: 5978

overrideFileWatchers​

Overrides the default kernel values for file watchers on every node. Enable it if you run databases or use okteto up in the cluster. It requires permission to mount and modify /proc values.

  • maxUserWatches: The maximum number of allowed inotify watchers.
  • maxMapCount: The maximum number of memory map areas a process may have.
  • aioMaxNR: The maximum number of concurrent I/O requests.
overrideFileWatchers:
enabled: true
maxUserWatches: 10048576
maxMapCount: 262144
aioMaxNR: 1000000

overrideRegistryResolution​

Overrides the registry hostname resolution to use internal IPs. It requires permission to mount and modify the /etc/hosts file of the cluster nodes.

overrideRegistryResolution:
enabled: true

oktetoBotUser​

Overrides the name of the user for Admin access tokens. Defaults to okteto-bot.

pullAlways​

Forces the PullAlways image pull policy in the cluster. Disabled by default.

pullAlways:
enabled: true

quotas​

Enables resource quotas per Namespace. They apply to every Namespace that Okteto manages, including development Namespaces and Preview Environments.

  • resources: Limits the number of resources that a user can create.
    • maxNamespaces: Maximum number of Namespaces that a user can create. It doesn't apply to the okteto-bot user for Admin access tokens.
    • maxPods: Maximum number of pods per Namespace.
    • maxReplicationControllers: Maximum number of replication controllers per Namespace.
    • maxSecrets: Maximum number of secrets per Namespace.
    • maxServices: Maximum number of services per Namespace.
    • maxJobs: Maximum number of jobs per Namespace.
    • maxCronjobs: Maximum number of cronjobs per Namespace.
    • maxLoadBalancers: Maximum number of services of type LoadBalancer per Namespace.
    • maxNodePorts: Maximum number of services of type NodePort per Namespace.
    • maxConfigMaps: Maximum number of config maps per Namespace.
    • maxPVCs: Maximum number of persistent volume claims per Namespace.
    • maxVolumeSnapshots: Maximum number of volume snapshots per Namespace.
    • maxIngresses: Maximum number of ingresses per Namespace.
  • bandwidth: Limits the incoming and outgoing bandwidth per pod. Requires the Okteto NGINX Ingress Controller.
    • ingress: Maximum ingress bandwidth.
    • egress: Maximum egress bandwidth.
    • up: Limits the incoming and outgoing bandwidth per Development Container.
      • ingress: Maximum ingress bandwidth for a Development Container.
      • egress: Maximum egress bandwidth for a Development Container.
  • requests: Limits the maximum resource requests per Namespace.
    • cpu: Maximum CPU resource requests.
    • memory: Maximum memory resource requests.
    • storage: Maximum storage resource requests.
  • limits: Limits the maximum resource limits per Namespace.
    • cpu: Maximum CPU resource limits.
    • memory: Maximum memory resource limits.
    • storage: Maximum storage resource limits.
  • limitranges: Configures the limit ranges of each Namespace.
    • max: Configures the maximum resources per container.
      • cpu: Maximum CPU resource limits.
      • memory: Maximum memory resource limits.
    • requests: Configures the default resource requests per container.
      • cpu: Default CPU resource requests.
      • memory: Default memory resource requests.
    • limits: Configures the default resource limits per container.
      • cpu: Default CPU resource limits.
      • memory: Default memory resource limits.

The default configuration values are shown below. A value of "-1" indicates that no quota is enforced for that specific resource:

quotas:
resources:
enabled: false
maxNamespaces: "3"
maxPods: "-1"
maxServices: "-1"
maxLoadBalancers: "0"
maxNodePorts: "0"
maxReplicationControllers: "-1"
maxSecrets: "-1"
maxConfigMaps: "-1"
maxPVCs: "-1"
maxVolumeSnapshots: "-1"
maxIngresses: "-1"
maxJobs: "-1"
maxCronjobs: "-1"
bandwidth:
enabled: false
ingress: "800M"
egress: "800M"
up:
enabled: false
ingress: "800M"
egress: "800M"
requests:
enabled: false
cpu: "1"
memory: "2Gi"
storage: "20Gi"
limits:
enabled: false
cpu: "4"
memory: "8Gi"
storage: "20Gi"
limitranges:
max:
enabled: false
cpu: "3"
memory: "12Gi"
requests:
enabled: true
cpu: "10m"
memory: "50Mi"
limits:
enabled: true
cpu: "2"
memory: "8Gi"

secret​

Labels and annotations for the secret that the chart creates, for example to integrate with Vault or a similar secret store.

secret:
annotations:
your.custom.annotation: "10"
labels:
your.custom.label: "20"

serviceAccounts​

The serviceAccounts section configures the labels, annotations, and role bindings of the service accounts that Okteto generates for user accounts.

  • annotations: Annotations for each service account that Okteto generates for a user account.
  • labels: Labels for each service account that Okteto generates for a user account.
  • roleBindings.namespaces: Okteto binds this cluster role to every admin, owner, and member of each Namespace it manages, with a namespace-scoped role binding. Okteto does not create this cluster role: it must already exist in the cluster. Defaults to cluster-admin.
  • roleBindings.previews: Okteto binds this cluster role to every Okteto user in every global Preview Environment, with a namespace-scoped role binding. Okteto does not create this cluster role: it must already exist in the cluster. Defaults to view.
  • clusterRoleBinding: Okteto binds this cluster role to every user with a cluster role binding. Disabled by default. Use it to give every developer account access to cluster-level resources, such as the Node API. Okteto does not create this cluster role: it must already exist in the cluster.
  • extraRoleBindings: Okteto binds every cluster role listed under a namespace to every user, with a namespace-scoped role binding in that namespace. Okteto doesn't create the ClusterRoles or the namespaces: they must already exist in the cluster.
serviceAccounts:
annotations:
custom.annotation/one: one
custom.annotation/two: two
labels:
custom.label/one: one
custom.label/two: two
roleBindings:
namespaces: cluster-admin
previews: view
clusterRoleBinding: "example-cluster-role"
extraRoleBindings:
namespace-name1:
- cluster-role1
- cluster-role2
namespace-name2:
- cluster-role3

To bind more than one cluster role in any of these settings, use ClusterRole aggregation to combine them into one.

store​

Configures how Okteto persists user data.

store:
personalAccessToken:
max: 5
note

Okteto stores each Personal Access Token as a Kubernetes Secret. A cluster has a finite capacity for the total number of Secrets it can hold, so set personalAccessToken.max in proportion to the number of users on your instance. A high value multiplied across many users can exhaust the cluster's Secret capacity.

userDefinedNamespaces​

Disable it to enforce the username as a suffix for Namespaces and ingress hosts. Enabled by default.

userDefinedNamespaces: false

userPodAffinity​

When enabled Okteto automatically adds a preferred affinity to every pod, which leans towards placing pods from the same namespace and in the same node (default: true).

  • antiAffinity: When enabled Okteto adds an anti-affinity to the pod to ensure that all pods in the same namespace are placed in the same node. Disabled by default
userPodAffinity:
enabled: true
antiAffinity:
enabled: false

virtualServices​

When enabled, the Okteto UI shows the public endpoints associated with Istio Virtual Services (default: false).

virtualServices:
enabled: false

volumes​

Settings for volumes.

  • validate: Configures volume validation.
    • enabled: Enables volume validation. Disabled by default.
    • supportedStorageClasses: List of supported storage classes.
    • forceStorageClass: Whether to enforce a storage class when a volume uses an unsupported one. If set, Okteto enforces the first storage class in supportedStorageClasses.
    • supportedAccessModes: List of supported access modes.
volumes:
validate:
enabled: true
supportedStorageClasses: ["standard", "standard-rwo"]
forceStorageClass: true
supportedAccessModes: ["ReadWriteOnce"]

volumeSnapshots​

Lets users initialize persistent volume claims with the contents of an existing volume snapshot.

This feature requires a CSI driver in your cluster.

  • driver: The name of the CSI driver used when creating snapshots.
  • class: The VolumeSnapshotClass of the volume snapshot.
  • storageClass: The storage class required by volumes initialized from snapshots (optional).
  • enableNamespaceAccessValidation: When enabled, only users with access to the Namespace that stores a volume snapshot can use it in their application environments. Defaults to false.
  • allowIDAnnotation: Allows your cloud provider's snapshot ID as the data source. Defaults to true.
volumeSnapshots:
enabled: true
driver: ebs.csi.aws.com
class: snapclass
storageClass: ebs-sc

Add the dev.okteto.com/from-snapshot-id annotation to any persistent volume claim to tell Okteto to initialize your persistent volume claim, as shown below:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
annotations:
dev.okteto.com/from-snapshot-id: snap-xxxxxxxx
name: pvc-name
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 10Gi

When the persistent volume claim is created, Okteto imports the snapshot into Kubernetes as a VolumeSnapshotContent and sets it as the source of the persistent volume claim.

wildcardCertificate​

By default, Okteto configures a self-signed wildcard certificate for your instance, which makes evaluations simpler. For a production installation, configure your own wildcard certificate and disable the default behavior.

The certificate settings are:

  • create: If false, Okteto doesn't create a self-signed wildcard certificate.
  • duration: The duration of the self-signed certificate. Ignored if create is false.
  • name: The name of the secret that stores the certificate.
  • privateCA.enabled: Set it to true when you use a private certificate authority.
  • privateCA.secret.name: The name of the secret that stores the private certificate authority's certificate.
  • privateCA.secret.key: The key in the secret that stores the private certificate authority's certificate.
  • annotations: Annotations to add to the self-signed certificate that Okteto generates.
wildcardCertificate:
create: true
duration: 2160h0m0s
name: default-ssl-certificate
annotations:
argocd.argoproj.io/compare-options: IgnoreExtraneous
# if using a private CA, specify the name of the TLS secret that stores the certificate
privateCA:
enabled: false
secret:
name: "okteto-ca"
key: "ca.crt"

Dependencies​

The default Okteto installation includes two instances of the NGINX Ingress Controller, installed from its official Helm chart.

Each instance has a specific role:

  • ingress-nginx: The ingress controller for all inbound traffic to the Okteto cluster, including BuildKit, the Okteto Registry, the Okteto API, the Okteto frontend, and users' ingresses.
  • okteto-nginx: The ingress controller dedicated to the inbound traffic of users' ingresses. By default, it runs behind ingress-nginx.

Okteto Ingress Controllers​

Okteto has two nginx-related keys you can define in your configuration file (e.g. config.yaml or any other config file where you specify these keys): ingress-nginx and okteto-nginx. These each serve a different function.

ingress-nginx​

This key is used to specify ingress behavior for Okteto's platform components (e.g. api, buildkit, registry) and supports passthrough/proxy behavior to okteto-nginx. This configuration will serve through a *.$subdomain internal ingress pointing to okteto-nginx. This ingress controller resides within the control plane of the Okteto cluster.

okteto-nginx​

Configures the ingress behavior for application environments. It parses and registers developers' ingresses. This ingress controller runs in the cluster and manages ingress traffic to and between developers' applications.

When a user request arrives at Okteto, ingress-nginx receives it and proxies it to okteto-nginx, which proxies it to the backend pod.

Sample configuration​

This example changes the number of ingress-nginx replicas:

ingress-nginx:
controller:
replicaCount: 2

The ingress-nginx chart values list every available value.

ingress-nginx & okteto-nginx default values​

Okteto sets specific values on the embedded ingress-nginx chart to enable features that depend on the ingress controller. To check them, run:

  • ingress-nginx:

    helm show values okteto/okteto --jsonpath '{.ingress-nginx}'
  • okteto-nginx:

    helm show values okteto/okteto --jsonpath '{.okteto-nginx}'

Using Your Own Ingress Controller​

The community guide on using your own ingress controller explains how to disable the Okteto NGINX Ingress Controller and expose Okteto behind your own ingress controller.

Reloader​

The Okteto chart uses Reloader to run rolling upgrades of the Okteto components when specific secrets change. To customize Reloader, set its parameters under the reloader.reloader value.

Store Sensitive Configuration Values using a Secret​

Create a secret named okteto-cloud-secret to store these values instead of setting them in your Helm configuration file:

  • OKTETO_LICENSE: replaces .Values.license.
  • GOOGLE_CLIENTSECRET: replaces .Values.auth.google.clientSecret.
  • GITHUB_CLIENTSECRET: replaces .Values.auth.github.clientSecret.
  • BITBUCKET_CLIENTSECRET: replaces .Values.auth.bitbucket.clientSecret.
  • OPENID_CLIENTSECRET: replaces .Values.auth.openid.clientSecret.
  • GITHUB_INTEGRATION_CLIENTSECRET: replaces .Values.github.clientSecret.
  • GITHUB_APP_PRIVATE_KEY: replaces .Values.github.appPrivateKey.

Handling a Long Release Name​

The Okteto chart combines the release name and the chart name into a prefix for the names of the Kubernetes resources it creates.

Kubernetes limits the length of resource names. For example, CronJob names can't exceed 52 characters, and Service names can't be longer than 63 characters. Helm also limits release names to 53 characters.

The Okteto chart creates many Kubernetes resources, so it uses specific strategies to stay within these limits and to minimize the need for extra configuration.

The Okteto prefix can be up to 34 characters long: the maximum name length in Kubernetes (63 characters) minus the length of the longest Okteto component suffix (-ingress-nginx-defaultbackend). The 34 characters split into 27 for the release name and 7 for the chart name (-okteto).

To extend the limit to 40 characters, override the name of the defaultBackend component with the defaultBackend.nameOverride value.

For a release name longer than 40 characters, use the nameOverride or fullnameOverride settings to shorten the prefix.