Each Nuon app allows you to deploy to a single platform, by combining a Sandbox with your application and infrastructure code. This document outlines the supported platforms, and how you can use a platform that is not currently supported by Nuon.

While Nuon has first class support for the following platforms, terraform components can be used to provision any custom resources in a customer’s cloud account.

AWS EKS

Nuon supports running your app via AWS EKS. You can create apps that provision a completely new network (VPC) and k8s cluster, or use an existing customer managed network or cluster (using app-inputs).

To use AWS EKS, configure your app with the following:

[sandbox]
terraform_version = "1.7.5"
[sandbox.public_repo]
directory = "aws-eks"
repo = "nuonco/sandboxes"
branch = "main"

[runner]
runner_type = "aws-eks"

We provide a supported aws-eks sandbox that creates a new VPC, as well as a byo-vpc sandbox. Both sandboxes support customization using app inputs, to override values such as the cluster version and more.

Read more about this in sandboxes.

AWS ECS

Nuon supports running your app via AWS ECS. You can create apps that provision a completely new network (VPC) and ECS cluster, or use an existing customer managed network or cluster (using app-inputs).

To use AWS ECS, configure your app with the following:

[sandbox]
terraform_version = "1.5.4"
[sandbox.public_repo]
directory = "aws-ecs"
repo = "nuonco/sandboxes"
branch = "main"

[runner]
runner_type = "aws-ecs"

We provide a supported aws-ecs sandbox that creates a new VPC, as well as a byo-vpc sandbox. Both sandboxes support customization using app inputs, to override values such as the cluster version and more.

Read more about this in sandboxes.

AWS Serverless

Nuon supports running any app using AWS Lambda, by configuring your app using the AWS ECS section above and configuring all serverless resources using terraform.

You can configure any serverless infrastructure using terraform components, and can model your container images using either docker or external image components.

If you have a serverless use case, we would love to hear more. Please get in touch.

Azure AKS

We are currently building Azure AKS support with a handful of early customers.

If you have an Azure app, customers who are asking for Azure deployments or are trying to sell into the EU, please get in touch.

Custom Infrastructure as Code

You can provision custom IAC resources on any platform using a terraform component.

This is useful for configuring additional resources such as databases, storage buckets and other resources that your application requires.

To provision third party cloud providers, please refer to Supporting Custom Platforms.

Supporting Multiple Platforms

You can support deploying your product to multiple platforms, by creating different apps that reference the same component code.

For example, you can create an app to deploy a containerized service to ECS, using our ECS sandbox and a Terraform component.

nuon.<your-app>-aws-ecs.toml
version = "v1"

[runner]
runner_type = "aws-ecs"

[sandbox]
terraform_version = "1.5.4"
[sandbox.public_repo]
directory = "aws-ecs"
repo = "nuonco/sandboxes"
branch = "main"

[[components]]
name = "<your-app>-image"
type = "container_image"
[components.public]
image_url = "<your-image-url>"
tag = "latest"

[[components]]
name = "<your-app>-ecs-service"
type = "terraform_module"
terraform_version = "1.7.5"
[components.connected_repo]
directory = "components/ecs-service"
repo = "<your-app>"
branch = "main"

Then, create another app using our EKS sandbox and a Helm chart component to deploy the same container to EKS.

nuon.<your-app>-aws-eks.toml
version = "v1"

[runner]
runner_type = "aws-eks"

[sandbox]
terraform_version = "1.7.5"
[sandbox.public_repo]
directory = "aws-eks"
repo = "nuonco/sandboxes"
branch = "main"
[sandbox.vars]
enable_nginx_ingress_controller = "false"

[[components]]
name = "<your-app>-image"
type = "container_image"
[components.public]
image_url = "<your-image-url>"
tag = "latest"

[[components]]
name = "<your-app>-helm-chart"
type = "helm_chart"
chart_name = "<your-app>"
[components.public_repo]
directory = "component/helm-chart"
repo = "<your-app>"
branch = "main"

You can accomplish the same task with our Terraform provider. For the ECS app, you would have a config that looks something like this.

aws-ecs.tf
resource "nuon_app" "aws_ecs" {
  name = "aws-ecs"
}

resource "nuon_app_sandbox" "aws_ecs" {
  app_id            = nuon_app.aws_ecs.id
  terraform_version = "v1.6.3"

  public_repo = {
    repo      = "nuonco/sandboxes"
    directory = "aws-ecs"
    branch    = "main"
  }
}

resource "nuon_app_runner" "aws_ecs" {
  app_id      = nuon_app.main.id
  runner_type = "aws-ecs"
}

resource "nuon_container_image_component" "aws_ecs" {
  name   = "<your-app>-image"
  app_id = nuon_app.aws_ecs.id

  public = {
    image_url = "<your-image-url>"
    tag       = "latest"
  }
}

resource "nuon_terraform_module_component" "aws_ecs" {
  name   = "<your-app>_ecs_service"
  app_id = nuon_app.main.id
  terraform_version = "1.6.3"

  connected_repo = {
    directory = "components/ecs-service"
    repo      = "<your-org>/<your-repo>"
    branch    = "main"
  }
}

For the EKS app, you would have a config that looks like this.

resource "nuon_app" "aws_eks" {
  name = "aws-eks"
}

resource "nuon_app_sandbox" "aws_eks" {
  app_id            = nuon_app.aws_eks.id
  terraform_version = "v1.6.3"

  public_repo = {
    repo      = "nuonco/sandboxes"
    branch    = "main"
    directory = "aws-eks"
  }
}

resource "nuon_app_runner" "aws_eks" {
  app_id      = nuon_app.aws_eks.id
  runner_type = "aws-eks"
}

resource "nuon_container_image_component" "aws_eks" {
  name   = "<your-app>-image"
  app_id = nuon_app.aws_eks.id

  public = {
    image_url = "<your-image-url>"
    tag       = "latest"
  }
}

resource "nuon_helm_chart_chart_component" "aws_eks" {
  name               = "<your_app>_helm_chart"
  app_id             = nuon_app.aws_eks.id
  helm_chart_version = "1.6.3"

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

Supporting Custom Platforms

If you would like to support third party cloud providers that Nuon does not natively support, you can use app inputs and terraform components. This is useful for managing things such as third party databases, AI tools, or even CDN providers alongside your application.

For example, if you would like to provision additional resources using a provider such as the Cloudflare Terraform Provider,

First, define an app input to require a customer api token:

[inputs]
[[inputs.input]]
name         = "cloudflare_api_token"
description  = "Token to use for integrating with Cloudflare."
display_name = "Cloudflare API Token"
required     = true

Second, configure your terraform component to use this api token. This will be set as a terraform variable and can be used to configure the provider.

[[components]]
name   = "cloudflare"
app_id = nuon_app.<your_app>.id
[[components.env_vars]]
name  = "cloudflare_api_token"
value = "{{.nuon.install.inputs.cloudflare_api_token}}"
[[components.vars]]
name  = "CLOUDFLARE_API_TOKEN"
value = "{{.nuon.install.inputs.cloudflare_api_token}}"

In some cases, customizations can be handled using a custom sandbox, if they do not require a different cloud provider. Read more about customizing sandboxes here.