Helm Chart Components

Helm chart components allow you to deploy any helm from a public or connected repo.

Configuring a Helm component

To configure a Helm component, specify a repo, the required configuration values and version to deploy it with.

components/helm_chart.toml

# helm
name       = "helm_chart"
type       = "helm_chart"
chart_name = "<your-app>"

[connected_repo]
directory = "components/helm-chart"
repo      = "<your-org>/<your-repo>"
branch    = "main"

[[values_file]]
contents = """
image:
  tag: "{{.nuon.components.docker_build.image.name}}"
"""

# alternatively, you can read from disk
[[values_file]]
source = "./values.yaml"

You can also put the Helm chart source inside of the same repo as the app, and point to it.

If you include the Helm chart source in the app repo, you must push the entire repo and do a manual build of the component in the dashboard or CLI. The CLI’s nuon apps sync will not recognize that the component has changed so will not do the build.

Multiple ways to use Helm with components

You can configure Helm components to use either a Helm repository (using a helm_repo block), a public repo (using a public_repo block), or a private GitHub repo (using a connected_repo block). Read more about VCS configuration here.

Using Public Helm Repositories

Helm repositories are the standard way to share and discover Helm charts across the Kubernetes ecosystem. You can deploy charts directly from public Helm repositories without needing to store them in your own Git repository. To use a public Helm chart, specify the repository URL and chart name:

components/prometheus.toml

# helm
name       = "prometheus"
type       = "helm_chart"
chart_name = "prometheus"

[helm_repo]
repo_url = "https://prometheus-community.github.io/helm-charts"
chart    = "kube-prometheus-stack"

This is equivalent to the Helm CLI command:

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm install prometheus prometheus-community/kube-prometheus-stack

You can find public Helm charts on Artifact Hub, which indexes thousands of open-source Helm charts. Each chart page lists its repository URL, which you can use in the repo_url field.

Open Source and Private Charts

Nuon supports any Helm chart that can be accessed using git. It is common for apps to have both a combination of public, open source helm charts for deploying standard components and private helm charts for application specific configuration.

Helm Value Configuration

One of the most important parts of deploying a Helm chart into a customer account, includes setting values properly. Values can be used for everything from accessing infrastructure, setting images or scaling pods. Variables allow you to set default values for a Nuon app, expose customer configuration options, reference infrastructure from other components or access an image that was synced into the customer account. Examples for accessing common interpolated variables:

components/helm_chart.toml

# helm
name       = "helm_chart"
type       = "helm_chart"
chart_name = "<your-app>"

[connected_repo]
directory = "components/helm-chart"
repo      = "<your-org>/<your-repo>"
branch    = "main"

[values]
# access a synced image
image_repository = "{{.nuon.components.image.image.repository.uri}}"
image_tag        = "{{.nuon.components.image.image.tag}}"
# access outputs from a terraform component
output_value = "{{.nuon.components.terraform.outputs.output_value}}"
# access outputs from the sandbox
aws_region = "{{.nuon.install.sandbox.outputs.account.aws_region}}"
vpc_id     = "{{.nuon.install.sandbox.outputs.vpc.id}}"
# access information about the install domain
public_root_domain   = "{{.nuon.sandbox.outputs.nuon_dns.public_domain.name}}"
internal_root_domain = "{{.nuon.sandbox.outputs.nuon_dns.internal_domain.name}}"

Using a Helm Values File

You can add a values file and locate it in the app repository.

components/grafana.toml

# helm
name           = "grafana"
type           = "helm_chart"
chart_name     = "grafana"
namespace      = "grafana"
storage_driver = "configmap"
dependencies   = ["prometheus", "grafana_secrets", "exampledb_secrets"]

[public_repo]
repo      = "grafana/helm-charts"
directory = "charts/grafana"
branch    = "main"

[[values_file]]
contents = "./values/grafana/values.yaml"

Nuon Managed Sandbox Components and DNS

The aws-eks-sandbox managed sandbox ships with standard Helm components + DNS zones to solve for common use cases, such as exposing a public or private https service. This includes:

The Sandboxes are open source and can be customized, if these components do not work for your application.

Using Domains

The Nuon managed Sandboxes automatically deploy the components required to provision DNS, Certificate and Load Balancer resources using Helm. There are multiple ways to use these components. Here are examples of the two most common.

AWS NLB with AWS ACM

If you want to leverage AWS services, you can provision an NLB that uses an ACM certificate. Your chart would contain a Service resource, configured so that the operator will create an NLB.

nlb_public.tpl

---
apiVersion: v1
kind: Service
metadata:
  name: nlb-public
  namespace: {{ .Release.Namespace }}
  labels: {}

  annotations:
    service.beta.kubernetes.io/aws-load-balancer-nlb-target-type: ip
    service.beta.kubernetes.io/aws-load-balancer-scheme: internet-facing
    service.beta.kubernetes.io/aws-load-balancer-target-group-attributes: preserve_client_ip.enabled=false
    service.beta.kubernetes.io/aws-load-balancer-ssl-cert: {{ .Values.api.nlbs.public_domain_certificate_arn }}
    service.beta.kubernetes.io/aws-load-balancer-ssl-ports: https
    service.beta.kubernetes.io/aws-load-balancer-backend-protocol: tcp
    external-dns.alpha.kubernetes.io/hostname: {{ .Values.api.nlbs.public_domain }}
spec:
  type: LoadBalancer
  loadBalancerClass: service.k8s.aws/nlb
  allocateLoadBalancerNodePorts: false
  externalTrafficPolicy: Local
  internalTrafficPolicy: Local
  selector:
    {}
  ports:
    - name: https
      port: 443
      targetPort: http

You would parametrize the Service with the following values in your chart’s values.yaml file, to accept public and private domains and an ACM certificate ARN.

nlbs:
  public_domain: nlb.INSTALL_PUBLIC_DOMAIN
  internal_domain: nlb.internal.INSTALL_INTERNAL_DOMAIN
  public_domain_certificate: nbl.PUBLIC_DOMAIN_CERTIFICATE

Then, you could set those values per install with the following component config.

components/nlb.toml

# helm
name       = "nlb"
type       = "helm_chart"
chart_name = "nlb"

[connected_repo]
directory = "components/nlb"
repo      = "<your-org>/<your-repo>"
branch    = "main"

[values]
"nlbs.public_domain"                 = "nlb.{{.nuon.sandbox.outputs.nuon_dns.public_domain.name}}"
"nlbs.public_domain_certificate_arn" = "{{.nuon.components.infra.outputs.public_domain_certificate_arn}}"

Nginx Ingress with Cert Manager

If you would prefer to manage resources within Kubernetes instead, you could use the Nginx ingress and have the cert-manager operator provision a certificate. In your chart, you would define the Ingress and Certificate resources.

components/api_public.tpl

---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: api-public
  namespace: {{ .Release.Namespace }}
  labels: {}
  annotations:
    external-dns.alpha.kubernetes.io/hostname: {{ .Values.nginx.public_domain }}
    kubernetes.io/ingress.class: nginx
spec:
  tls:
  - hosts:
    - {{ .Values.nginx.public_domain }}
    secretName: e2e-ingress-public-tls
  rules:
    - host: {{ .Values.nginx.public_domain}}
      http:
        paths:
        - path: /
          pathType: Prefix
          backend:
            service:
              name: api
              port:
                number: 80

---
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: api-nginx
  namespace: {{ .Release.Namespace }}
  labels:
    {{- include "common.apiLabels" . | nindent 4 }}
spec:
  secretName: e2e-ingress-public-tls
  dnsNames:
    - {{ .Values.nginx.public_domain }}
  issuerRef:
    name: public-issuer
    kind: ClusterIssuer

Then, allow configuring the domain in the chart’s values.yaml file.

nginx:
  public_domain: nlb.INSTALL_PUBLIC_DOMAIN

You could then set the domain per install in your Component config.

components/nlb.toml

# helm
name       = "nlb"
type       = "helm_chart"
chart_name = "nlb"

[connected_repo]
directory = "components/nlb"
repo      = "<your-org>/<your-repo>"
branch    = "main"

[values]
"nlbs.public_domain"                 = "nlb.{{.nuon.sandbox.outputs.nuon_dns.public_domain.name}}"

By default, Nuon provisions a custom domain for each install id under the nuon.run domain (eg: inl8ybt7gajofh33e0h3pqyw1t.nuon.run).If you would like to use a customer provided domain, you can accept customer domains using inputs. We are planning to improve support for this, and would love to hear about your use case.

Per-install value overrides

To customize a Helm chart’s values for a single install without changing your app config, use component overrides.

Connect Your App

Install with a Customer

Day 2 Operations

Integrations

Advanced

Configuring a Helm component

Multiple ways to use Helm with components

Using Public Helm Repositories

Open Source and Private Charts

Helm Value Configuration

Using a Helm Values File

Nuon Managed Sandbox Components and DNS

Using Domains

AWS NLB with AWS ACM

Nginx Ingress with Cert Manager

Per-install value overrides

​Configuring a Helm component

​Multiple ways to use Helm with components

​Using Public Helm Repositories

​Open Source and Private Charts

​Helm Value Configuration

​Using a Helm Values File

​Nuon Managed Sandbox Components and DNS

​Using Domains

​AWS NLB with AWS ACM

​Nginx Ingress with Cert Manager

​Per-install value overrides

Configuring a Helm component

Multiple ways to use Helm with components

Using Public Helm Repositories

Open Source and Private Charts

Helm Value Configuration

Using a Helm Values File

Nuon Managed Sandbox Components and DNS

Using Domains

AWS NLB with AWS ACM

Nginx Ingress with Cert Manager

Per-install value overrides