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

# Amazon Elastic Kubernetes Service

> Provision AWS infrastructure and install FalkorDB Enterprise on EKS.

## Prerequisites

* [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) (`aws`) v2, configured with credentials that can create VPCs, EKS clusters, node groups, and IAM roles (`aws configure` or SSO).
* [`eksctl`](https://eksctl.io) 0.180 or later.
* `kubectl`, `helm`, and `base64` on the machine that runs the installer.
* At least 3 worker nodes with 4 CPU and 16 GB of memory each.
* Outbound access from the cluster to pull images: `registry.falkordb.cloud` (Enterprise images, credentials required), `docker.io`, `apecloud-registry.cn-zhangjiakou.cr.aliyuncs.com`, `registry.k8s.io`, and `ghcr.io` — or `registry.falkordb.cloud` alone, since every image is also mirrored there (see [Private registries](/deployment/private-images)).

Confirm the CLI is authenticated against the right account:

```bash theme={null}
aws sts get-caller-identity
```

## Required infrastructure

A production EKS install needs:

| Resource                                 | Purpose                                                                                   |
| ---------------------------------------- | ----------------------------------------------------------------------------------------- |
| VPC and subnets                          | Network for the EKS control plane and nodes (created by `eksctl`).                        |
| EKS cluster                              | Kubernetes control plane and a small system node group.                                   |
| Managed node group                       | Dedicated capacity for FalkorDB database workloads.                                       |
| Amazon EBS CSI driver                    | Persistent volumes and snapshot-based backups (not enabled by default — installed below). |
| Load balancer or ingress with public DNS | External access to the Admin UI and Admin Server.                                         |

Set common variables used by the commands below:

```bash theme={null}
export AWS_REGION=us-east-1
export CLUSTER_NAME=falkordb-enterprise
export K8S_VERSION=1.34
```

### 1. Create the EKS cluster

Create a cluster with a small system node group and an IAM OIDC provider (required for the EBS CSI driver in the next step). `eksctl` creates the VPC and subnets automatically:

```bash theme={null}
eksctl create cluster \
  --name "$CLUSTER_NAME" \
  --region "$AWS_REGION" \
  --version "$K8S_VERSION" \
  --nodegroup-name system \
  --node-type m6i.xlarge \
  --nodes 2 \
  --nodes-min 2 \
  --nodes-max 3 \
  --with-oidc \
  --managed
```

Add `--zones us-east-1a,us-east-1b,us-east-1c` to pin the cluster to specific availability zones if needed.

### 2. Create a managed node group for databases

Size this pool for your FalkorDB memory footprint. Memory-optimized `r6i` instances are a good fit for graph workloads.

```bash theme={null}
eksctl create nodegroup \
  --cluster "$CLUSTER_NAME" \
  --region "$AWS_REGION" \
  --name falkordb \
  --node-type r6i.2xlarge \
  --nodes 3 \
  --nodes-min 3 \
  --nodes-max 10 \
  --node-labels "workload=falkordb" \
  --managed
```

### 3. Get cluster credentials

```bash theme={null}
aws eks update-kubeconfig \
  --region "$AWS_REGION" \
  --name "$CLUSTER_NAME"

kubectl config current-context
kubectl get nodes
```

### 4. Install the Amazon EBS CSI driver

EKS does not provision persistent volumes out of the box — the Amazon EBS CSI driver add-on must be installed explicitly, with an IAM role scoped to it:

```bash theme={null}
export AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)

eksctl create iamserviceaccount \
  --cluster "$CLUSTER_NAME" \
  --region "$AWS_REGION" \
  --namespace kube-system \
  --name ebs-csi-controller-sa \
  --role-name "AmazonEKS_EBS_CSI_DriverRole_${CLUSTER_NAME}" \
  --attach-policy-arn arn:aws:iam::aws:policy/service-role/AmazonEBSCSIDriverPolicy \
  --role-only \
  --approve

eksctl create addon \
  --cluster "$CLUSTER_NAME" \
  --region "$AWS_REGION" \
  --name aws-ebs-csi-driver \
  --service-account-role-arn "arn:aws:iam::${AWS_ACCOUNT_ID}:role/AmazonEKS_EBS_CSI_DriverRole_${CLUSTER_NAME}" \
  --force
```

### 5. Verify storage and snapshot support

FalkorDB Enterprise uses persistent volumes for databases and the Admin Server, and volume snapshots for backups. Create a `gp3` storage class and mark it default:

```bash theme={null}
cat <<'EOF' | kubectl apply -f -
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: gp3
  annotations:
    storageclass.kubernetes.io/is-default-class: "true"
provisioner: ebs.csi.aws.com
parameters:
  type: gp3
volumeBindingMode: WaitForFirstConsumer
allowVolumeExpansion: true
EOF

kubectl get storageclass
kubectl get crd volumesnapshots.snapshot.storage.k8s.io
```

EKS does not ship the `VolumeSnapshot` CRDs or a snapshot controller by default, so leave the installer's bundled Snapshot Controller enabled (this is the default — no extra flag needed).

## Install FalkorDB Enterprise

### Quick install

With the EKS context active, run the installer:

```bash theme={null}
curl -fsSL https://raw.githubusercontent.com/FalkorDB/FalkorDB-Enterprise/refs/heads/main/scripts/install.sh | \
  bash -s -- --yes
```

On a default EKS install, the installer deploys ingress-nginx (unless the cluster already has a default `IngressClass`), exposes the Admin UI and Admin Server API on a single public hostname through the gateway Ingress, and prints the URL. The ingress-nginx controller Service provisions a Classic Load Balancer by default. See [Quickstart](/get-started/quickstart) for what the installer does and how to validate it.

### Production install

For production, prepare a values file with TLS ingress, a stable JWT secret, and a bootstrap admin user as described in [Production install](/deployment/production). A ready-to-edit EKS example is available at [helm/falkordb-enterprise/examples/values-eks.yaml](https://github.com/FalkorDB/FalkorDB-Enterprise/blob/main/helm/falkordb-enterprise/examples/values-eks.yaml). Example EKS-specific values:

```yaml theme={null}
gateway:
  enabled: true
  ingress:
    enabled: true
    className: nginx
    hosts:
      - host: admin.example.com
    tls:
      - secretName: falkordb-enterprise-admin-tls
        hosts:
          - admin.example.com

adminServer:
  env:
    nodeEnv: production
    corsOrigin: https://admin.example.com
    cookieSecure: true
  persistence:
    enabled: true
    size: 8Gi
    storageClassName: gp3
```

To use a Network Load Balancer instead of the default Classic Load Balancer, annotate the ingress-nginx controller Service after install:

```bash theme={null}
kubectl annotate service ingress-nginx-controller -n ingress-nginx \
  service.beta.kubernetes.io/aws-load-balancer-type=nlb
```

Then install:

```bash theme={null}
curl -fsSL https://raw.githubusercontent.com/FalkorDB/FalkorDB-Enterprise/refs/heads/main/scripts/install.sh | \
  JWT_SECRET="$(openssl rand -hex 32)" bash -s -- \
    --kube-context "$(kubectl config current-context)" \
    --namespace falkordb-system \
    --kubeblocks-namespace kb-system \
    --values production-values.yaml \
    --yes
```

### DNS

Point your Admin UI hostname at the ingress load balancer:

```bash theme={null}
kubectl get ingress -n falkordb-system
```

Create a Route 53 record for `admin.example.com` pointing at the `ADDRESS` (hostname) shown:

```bash theme={null}
aws route53 change-resource-record-sets \
  --hosted-zone-id "<hosted-zone-id>" \
  --change-batch '{
    "Changes": [{
      "Action": "UPSERT",
      "ResourceRecordSet": {
        "Name": "admin.example.com",
        "Type": "CNAME",
        "TTL": 300,
        "ResourceRecords": [{"Value": "<ingress-hostname>"}]
      }
    }]
  }'
```

## Validate the install

```bash theme={null}
helm status kubeblocks -n kb-system
helm status falkordb-enterprise -n falkordb-system
kubectl get pods -n kb-system
kubectl get pods -n falkordb-system
kubectl get ingress -n falkordb-system
```

Open the Admin UI URL and sign in with the bootstrap admin user.

## Clean up

Delete the Enterprise release first (see [uninstall](/upgrades/uninstall)), then remove the AWS resources:

```bash theme={null}
eksctl delete nodegroup --cluster "$CLUSTER_NAME" --region "$AWS_REGION" --name falkordb
eksctl delete cluster --name "$CLUSTER_NAME" --region "$AWS_REGION"
```

Deleting the cluster removes the VPC, subnets, node groups, and load balancers `eksctl` created for it.
