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"
After you set it in your Helm configuration file, use your DNS provider to point this domain to the IP address of the Okteto Ingress Controller. Get the IP address with the same command that the installation guides use:
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 overglobals.priorityClassName. If it isn't set, the pods inherit the priority class fromglobals.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 tells the Kubernetes cluster autoscaler to scale nodes when the actual CPU or memory usage of a node exceeds the limits. To limit the autoscaler's analysis to a subset of nodes, use globals.nodeSelectors.dev. The deprecated tolerations.devPool still works and, when set, takes precedence.
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 tobusybox.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-nodepoolin GKE andeks.amazonaws.com/nodegroupin 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 to443.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 to1.hpa.max: Maximum number of BuildKit pods to scale to. Defaults to5.hpa.metrics: The target metrics that make the HPA scale the BuildKit pods. Defaults to theokteto_build_active_buildsmetric with an average value target of0.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 overglobals.priorityClassName. If it isn't set, the pods inherit the priority class fromglobals.priorityClassName.hpa.adapter.replicaCount: The number of adapter pods. Defaults to2.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 tov1beta2.custom.metrics.k8s.io.hpa.adapter.apiService.group: The API group. Defaults tocustom.metrics.k8s.io.hpa.adapter.apiService.version: The API version. Defaults tov1beta2.hpa.adapter.apiService.groupPriorityMinimum: The priority of the API group. Defaults to100.hpa.adapter.apiService.versionPriority: The priority of the API version. Defaults to100.labels: Labels to add to the BuildKit pods.podManagementPolicy: The podManagementPolicy of the BuildKit pods. Defaults toParallel.priorityClassName: The priority class for the BuildKit pods. The PriorityClass must already exist in your cluster. This value takes precedence overglobals.priorityClassName. If it isn't set, the pods inherit the priority class fromglobals.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 totrue.serviceAccount.name: The name of the BuildKit service account. Defaults tookteto-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 to750Gi.persistence.cacheRatio: What percentage the persistence size should be used for the cache. Value should be between 0 and 1. Defaults to0.5.terminationGracePeriodSeconds: Duration in seconds for graceful pod termination. Defaults to600(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 inglobals.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 inglobals.nodeSelectors.okteto.network.mode: Controls the networking environment for containers during the build process. Defaults toautobut can be set tohost,none, orbridge. 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 afterOKTETO_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: Iftrue, the server allows keepalive pings even when there are no active streams (RPCs). Iffalseand the client sends pings with no active streams, the server sends a GOAWAY and closes the connection. Defaults tofalse.
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 toghcr.io.repository: The repository path for the Okteto CLI image. Defaults tookteto/okteto.
cli:
image:
registry: "my-custom-registry:5000"
repository: "okteto/okteto"
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 bemyregistry/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 totrue.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 tofalse. It's disabled ifregcredsManager.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 overglobals.priorityClassNameif both are set. If this value is not set, the pods will inherit the priority class defined by the value set inglobals.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=trueandregcredsManager.pullSecrets.enabled=false). - Installs your CA if
wildcardCertificate.privateCAis 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:
globals:
nodeSelectors:
dev:
okteto-node-pool: dev
tolerations:
dev:
- key: okteto-node-pool
operator: Equal
value: dev
effect: NoSchedule
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 totrue.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 to8080.priorityClassName: The priority class for the defaultBackend pods. The PriorityClass must already exist in your cluster. This value takes precedence overglobals.priorityClassName. If it isn't set, the pods inherit the priority class fromglobals.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.
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 overglobals.priorityClassName. If it isn't set, the pods inherit the priority class fromglobals.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: Iftrue, the Garbage Collector scalesokteto upsessions 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 overglobals.priorityClassName. If it isn't set, the pods inherit the priority class fromglobals.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 tofalse.bearerSecret.name: The name of the secret that stores the token to access the Okteto Insights metrics. Defaults tookteto-insights.bearerSecret.key: The key in the secret that stores the token to access the Okteto Insights metrics. Defaults tobearer.
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 overglobals.priorityClassName. If it isn't set, the pods inherit the priority class fromglobals.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 overglobals.priorityClassName. If it isn't set, the pods inherit the priority class fromglobals.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 ofglobals.registry.repository: The repository path for the installer image. Defaults tookteto/pipeline-runner.tag: The image tag to deploy. Defaults to1.47.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 overglobals.priorityClassName. If it isn't set, the pods inherit the priority class fromglobals.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.47.0
extraEnv:
- name: NO_PROXY
value: ".example.com"
activeDeadlineSeconds: 1800
gitSSHUser: git
sshSecretName: "okteto-ssh"
securityContext:
allowPrivilegeEscalation: false
resources:
requests:
cpu: 10m
memory: 50Mi
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 to8080.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 overglobals.priorityClassName. If it isn't set, the pods inherit the priority class fromglobals.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: Overridesauth.*.clientID.clientSecret: Overridesauth.*.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.
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 totrue.priorityClassName: The priority class for the prepull images pods. The PriorityClass must already exist in your cluster. This value takes precedence overglobals.priorityClassName. If it isn't set, the pods inherit the priority class fromglobals.priorityClassName.
prepullImages:
enabled: true
priorityClassName: "high-priority"
The daemonset prepulls these images on every node:
- ghcr.io/okteto/backend:1.47.0
- ghcr.io/okteto/pipeline-runner:1.47.0
- ghcr.io/okteto/okteto:3.22.0
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 overglobals.priorityClassName. If it isn't set, the pods inherit the priority class fromglobals.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 totrue.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 tookteto/redis.image.tag: The image tag for the Redis image. Defaults to 1.47.0.labels: Labels to add to the Redis pods.port: The port Redis listens on. Defaults to6379.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 totrue.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 overglobals.priorityClassName. If it isn't set, the pods inherit the priority class fromglobals.priorityClassName.recommendations.correction: A floating-point multiplier that adjusts for over- or under-provisioning of resources. It must be greater than 0. The default is1.1, which over-provisions by 10%. For example,0.9under-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 to5m.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 to10Mi.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 is0.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. Withcluster, any Okteto user can pull any image from the registry. Withnamespace, only users with access to a Namespace can pull its images. It defaults tonamespace.priorityClassName: The priority class for the registry pods. The PriorityClass must already exist in your cluster. This value takes precedence overglobals.priorityClassName. If it isn't set, the pods inherit the priority class fromglobals.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 thesecret.namesecret. Defaults toaccessKey.secret.secretKey: The key for the secret key in thesecret.namesecret. Defaults tosecretKey.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 to3000.priorityClassName: The priority class for the ssh-agent pods. The PriorityClass must already exist in your cluster. This value takes precedence overglobals.priorityClassName. If it isn't set, the pods inherit the priority class fromglobals.priorityClassName.replicaCount: The number of ssh-agent pods. Defaults to2.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 totrue.priorityClassName: The priority class for the telemetry pods. The PriorityClass must already exist in your cluster. This value takes precedence overglobals.priorityClassName. If it isn't set, the pods inherit the priority class fromglobals.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 tofalse.labels: Labels to add to the webhook pods.port: The port of the webhook Deployment. Defaults to443.priorityClassName: The priority class for the webhook pods. The PriorityClass must already exist in your cluster. This value takes precedence overglobals.priorityClassName. If it isn't set, the pods inherit the priority class fromglobals.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 of type LoadBalancer or NodePort to ClusterIP and creates an ingress for them. Services of type ExternalName aren't affected. 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 totrue.install: Installs and upgrades the CRDs when you install the chart. Defaults totrue.
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 byokteto 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 to86400(1 day).
globals:
jobs:
ttlSecondsAfterFinished: 86400
nodeSelectors
Node selectors for pods, grouped under okteto and dev:
okteto: Node selectors for the pods in theoktetonamespace, except the Okteto Daemonset.dev: Node selectors for the pods of user applications, which run in Namespaces managed by Okteto. They also apply to the Okteto Daemonset.
globals:
nodeSelectors:
okteto:
okteto-node-label: okteto
dev:
okteto-node-label: dev
region: east
If the nodes you select are tainted, you must also define a matching toleration in globals.tolerations.dev. A node selector on its own places user workloads on nodes they can't tolerate, and they stay Pending.
These node selectors don't apply to the ingress controllers or Reloader, which you configure as described in Node selectors and tolerations.
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 for the pods in theoktetonamespace, except the Okteto Daemonset.dev: Tolerations for the pods of user applications, which run in Namespaces managed by Okteto. They also apply 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"
The older tolerations.oktetoPool, tolerations.buildPool, and tolerations.devPool values are deprecated and will be removed in Okteto Chart 2.0. Installing the chart while they are set prints a deprecation warning. Use globals.tolerations and globals.nodeSelectors instead, together with buildkit.tolerations and buildkit.nodeSelectors for BuildKit. The migration guide has the full mapping.
If the nodes selected by globals.nodeSelectors.dev are tainted, define a matching toleration under dev above so that user workloads can schedule onto them.
These tolerations don't apply to the ingress controllers or Reloader, which you configure as described in Node selectors and tolerations.
ingress
Default values for the ingresses that Okteto creates.
annotations: The annotations to apply to all the ingresses created during the Okteto installation.oktetoIngressClass: TheingressClassNameto apply to all the ingresses created during the Okteto installation (defaults tookteto-controlplane-nginx).class: If set, Okteto sets it as theingressClassNameof 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 iningress.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 thekubernetes.io/tlssecret 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 thaninstaller.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-expirationflag 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 inserviceAccounts.roleBindings.namespaces. This gives every pod without a custom service account access to the Kubernetes API. Defaults totrue.
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 theokteto-botuser 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 typeLoadBalancerper Namespace.maxNodePorts: Maximum number of services of typeNodePortper 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 tocluster-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 toview.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.
personalAccessToken.max: The maximum number of Personal Access Tokens each user can create. Defaults to5.
store:
personalAccessToken:
max: 5
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 insupportedStorageClasses.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 tofalse.allowIDAnnotation: Allows your cloud provider's snapshot ID as the data source. Defaults totrue.
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: Iffalse, Okteto doesn't create a self-signed wildcard certificate.duration: The duration of the self-signed certificate. Ignored ifcreateisfalse.name: The name of the secret that stores the certificate.privateCA.enabled: Set it totruewhen 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"
Setting create: false isn't enough on its own to serve your own certificate. The ingress-nginx ingress controller reads its default certificate from ingress-nginx.controller.extraArgs.default-ssl-certificate, which isn't derived from wildcardCertificate.name. Whenever you set create: false, point that argument at the same secret, as shown in bring your own certificate. Otherwise that secret no longer exists, the ingress controller falls back to its own built-in fake certificate, and browsers show a certificate warning.
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 behindingress-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.
Node selectors and tolerations
globals.nodeSelectors and globals.tolerations apply to Okteto's own components. They do not reach the two ingress controllers or Reloader, which are separate charts and read their own values instead.
If you run Okteto on dedicated node pools, or on any node pool that carries a taint, configure all of them:
globals:
nodeSelectors:
okteto:
okteto-node-pool: okteto
tolerations:
okteto:
- key: okteto-node-pool
operator: Equal
value: okteto
effect: NoSchedule
ingress-nginx:
controller:
nodeSelector:
okteto-node-pool: okteto
tolerations:
- key: okteto-node-pool
operator: Equal
value: okteto
effect: NoSchedule
okteto-nginx:
controller:
nodeSelector:
okteto-node-pool: okteto
tolerations:
- key: okteto-node-pool
operator: Equal
value: okteto
effect: NoSchedule
reloader:
reloader:
deployment:
nodeSelector:
okteto-node-pool: okteto
tolerations:
- key: okteto-node-pool
operator: Equal
value: okteto
effect: NoSchedule
Leaving these out fails silently. The chart installs successfully, and the ingress controllers and Reloader schedule onto whichever nodes accept them, which on a cluster with dedicated pools is usually the untainted default pool. If every pool in the cluster is tainted, they stay Pending instead.
These charts also accept affinity, topologySpreadConstraints and priorityClassName under the same keys. They are maintained upstream, so check their own value references for the authoritative list: ingress-nginx, used by both the ingress-nginx and okteto-nginx keys, and Reloader.
ARM Support has a worked example for ARM node pools, which GKE taints by default.
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.
Reloader doesn't inherit globals.nodeSelectors or globals.tolerations. If you run Okteto on dedicated or tainted node pools, set its own scheduling values as shown in Node selectors and tolerations.
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.