> ## Documentation Index
> Fetch the complete documentation index at: https://docs.nebuly.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Self-hosting Nebuly on Azure

## Overview

Nebuly on Azure is deployed on an Azure Kubernetes Service (AKS) cluster provisioned
via a Terraform module, with all platform components managed through an official Helm chart.

The setup involves two layers:

* **Infrastructure** — Terraform provisions AKS, Azure Database for PostgreSQL, Azure Blob
  Storage, Azure Key Vault, and supporting networking and identity resources.
* **Platform** — the `nebuly-platform` Helm chart deploys all Nebuly services onto the
  provisioned cluster, configured using the values produced by Terraform.

A bootstrap Helm chart (`bootstrap-azure`) handles AKS-specific dependencies (ingress,
Key Vault secret integration via CSI driver, storage classes) and must be installed before
the platform chart.

## Terraform module

Terraform module for provisioning Nebuly Platform resources on Microsoft Azure.

Available on [Terraform Registry](https://registry.terraform.io/modules/nebuly-ai/nebuly-platform/azurerm/latest).

## Helm chart

The Nebuly Platform Helm chart is the official way to deploy and manage the Nebuly Platform
on Kubernetes. It packages all platform components and is configured using the values
produced by the Nebuly Terraform module.

Available on [GHCR](https://github.com/nebuly-ai/helm-charts).

## Prerequisites

### Nebuly Credentials

Before using this Terraform module, ensure that you have your Nebuly credentials ready.
These credentials are necessary to activate your installation and should be provided as input via the `nebuly_credentials` input.

### Required Azure Quotas

Ensure that you have the necessary Azure quotas available to provision the resources required for the Nebuly Platform:

* **Standard NCADS\_A100\_v4 Family vCPUs**: at least 24 vCPUs
* **Azure OpenAI gpt-4o**: at least 80k tokens per minute

## Quickstart

To get started with Nebuly installation on Microsoft Azure, you can follow the steps below.

These instructions will guide you through the installation using Nebuly's default standard configuration with the Nebuly Helm Chart.

For specific configurations or assistance, reach out to the Nebuly Slack channel or email [support@nebuly.ai](mailto:support@nebuly.ai).

### 1. Terraform setup

Import Nebuly into your Terraform root module, provide the necessary variables, and apply the changes.

For configuration examples, you can refer to the [Examples](#examples).

Once the Terraform changes are applied, proceed with the next steps to deploy Nebuly on the provisioned Azure Kubernetes Service (AKS) cluster.

### 2. Connect to the Azure Kubernetes Service cluster

Prerequisites: install the [Azure CLI](https://learn.microsoft.com/en-us/cli/azure/install-azure-cli).

* Fetch the command for retrieving the credentials from the module outputs:

```shell theme={null}
terraform output aks_get_credentials
```

* Run the command you got from the previous step

### 3. Create image pull secret

The auto-generated Helm values use the name defined in the k8s\_image\_pull\_secret\_name input variable for the Image Pull Secret. If you prefer a custom name, update either the Terraform variable or your Helm values accordingly.
Create a Kubernetes [Image Pull Secret](https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/) for
authenticating with your Docker registry and pulling the Nebuly Docker images.

### 4. Bootstrap AKS cluster

Retrieve the auto-generated values from the Terraform outputs and save them to a file named `values-bootstrap.yaml`:

```shell theme={null}
terraform output helm_values_bootstrap
```

Install the bootstrap Helm chart to set up all the dependencies required for installing the Nebuly Platform Helm chart on AKS.

Refer to the [chart documentation](https://github.com/nebuly-ai/helm-charts/tree/main/bootstrap-azure) for all the configuration details.

```shell theme={null}
helm install oci://ghcr.io/nebuly-ai/helm-charts/bootstrap-azure \
  --namespace nebuly-bootstrap \
  --generate-name \
  --create-namespace \
  -f values-bootstrap.yaml
```

### 5. Create Secret Provider Class

Create a Secret Provider Class to allow AKS to fetch credentials from the provisioned Key Vault.

* Get the Secret Provider Class YAML definition from the Terraform module outputs:
  ```shell theme={null}
  terraform output secret_provider_class
  ```

* Copy the output of the command into a file named secret-provider-class.yaml.

* Run the following commands to install Nebuly in the Kubernetes namespace nebuly:

  ```shell theme={null}
  kubectl create ns nebuly
  kubectl apply --server-side -f secret-provider-class.yaml
  ```

### 6. Install nebuly-platform chart

Retrieve the auto-generated values from the Terraform outputs and save them to a file named `values.yaml`:

```shell theme={null}
terraform output helm_values
```

Install the Nebuly Platform Helm chart.
Refer to the [chart documentation](https://github.com/nebuly-ai/helm-charts/tree/main/nebuly-platform) for detailed configuration options.

```shell theme={null}
helm install <your-release-name> oci://ghcr.io/nebuly-ai/helm-charts/nebuly-platform \
  --namespace nebuly \
  -f values.yaml \
  --timeout 30m 
```

> ℹ️  During the initial installation of the chart, all required Nebuly LLMs are uploaded to your model registry.
> This process can take approximately 5 minutes. If the helm install command appears to be stuck, don't worry: it's simply waiting for the upload to finish.

### 7. Access Nebuly

Retrieve the IP of the Load Balancer to access the Nebuly Platform:

```shell theme={null}
kubectl get svc -n nebuly-bootstrap -o jsonpath='{range .items[?(@.status.loadBalancer.ingress)]}{.status.loadBalancer.ingress[0].ip}{"\n"}{end}'
```

You can then register a DNS A record pointing to the Load Balancer IP address to access Nebuly via the custom domain you provided
in the input variable `platform_domain`.

## Upgrade to a new version

You can upgrade the Nebuly Platform Helm chart by running the following command:

```shell theme={null}
helm upgrade <your-release-name> oci://ghcr.io/nebuly-ai/helm-charts/nebuly-platform \
  --namespace nebuly \
  -f values.yaml \ 
  -- version=<version> \ 
  --timeout 30m
```

You can find the list of available versions and their changelogs in the
[releases page](https://github.com/nebuly-ai/helm-charts/tags).

## Examples

You can find examples of code that uses this Terraform module in the [examples](https://github.com/nebuly-ai/terraform-azurerm-nebuly-platform/tree/main/examples) directory.