flow/docs/versioned_docs/version-1.9.0/Deployment/deployment-kubernetes-dev.mdx

---
title: Deploy the Hanzo Flow development environment on Kubernetes
slug: /deployment-kubernetes-dev
---

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

The [Hanzo Flow integrated development environment (IDE) Helm chart](https://github.com/hanzoai/flow-helm-charts/tree/main/charts/flow-ide) is designed to provide a complete environment for developers to create, test, and debug their flows. It includes both the Hanzo Flow API and visual editor.

## Prerequisites

- A [Kubernetes](https://kubernetes.io/docs/setup/) cluster
- [kubectl](https://kubernetes.io/docs/tasks/tools/#kubectl)
- [Helm](https://helm.sh/docs/intro/install/)

## Prepare a Kubernetes cluster

This example uses [Minikube](https://minikube.sigs.k8s.io/docs/start/), but you can use any Kubernetes cluster.

1. Create a Kubernetes cluster on Minikube:

	```shell
	minikube start
	```

2. Set `kubectl` to use Minikube:

	```shell
	kubectl config use-context minikube
	```

## Install the Hanzo Flow IDE Helm chart

1. Add the repository to Helm, and then update it:

	```shell
	helm repo add flow https://hanzoai.github.io/flow-helm-charts
	helm repo update
	```

2. Install Hanzo Flow with the default options in the `flow` namespace:

	```shell
	helm install flow-ide flow/flow-ide -n flow --create-namespace
	```

3. Check the status of the pods:

	```shell
	kubectl get pods -n flow
	```

## Access the Hanzo Flow IDE

Enable local port forwarding to access Hanzo Flow from your local machine:

1. Make the Hanzo Flow API accessible from your local machine at port 7860:

    ```shell
    kubectl port-forward -n flow svc/flow-service-backend 7860:7860
    ```

2. Make the visual editor accessible from your local machine at port 8080:

    ```shell
    kubectl port-forward -n flow svc/flow-service 8080:8080
    ```

Now you can do the following:

- Access the Hanzo Flow API at `http://localhost:7860`.
- Access the visual editor at `http://localhost:8080`.

## Modify your Hanzo Flow IDE deployment

You can modify the Hanzo Flow IDE Helm chart's [`values.yaml`](https://github.com/hanzoai/flow-helm-charts/blob/main/charts/flow-ide/values.yaml) file to customize your deployment.
The following sections describe some common modifications.

If you need to set secrets, Kubernetes secrets are recommended.

### Deploy a different Hanzo Flow version

The Hanzo Flow IDE Helm chart deploys the latest Hanzo Flow version by default.

To specify a different Hanzo Flow version, set the `flow.backend.image.tag` and `flow.frontend.image.tag` values to your preferred version.
For example:

```yaml
flow:
  backend:
    image:
      tag: "1.0.0a59"
  frontend:
    image:
      tag: "1.0.0a59"
```

### Use external storage for the Hanzo Flow database

The Hanzo Flow IDE Helm chart uses the default Hanzo Flow database configuration, specifically a SQLite database stored in a local persistent disk.

If you want to use an [external PostgreSQL database](/configuration-custom-database), use `postgresql` chart or `externalDatabase` to configure the database connection in `values.yaml`.

<Tabs>
<TabItem value="postgresql" label="postgresql" default>

Use the built-in PostgreSQL chart:

```yaml
postgresql:
  enabled: true
  auth:
    username: "flow"
    password: "flow-postgres"
    database: "flow-db"
```

</TabItem>
<TabItem value="externaldatabase" label="externalDatabase">

If you don't want to use the built-in PostgreSQL chart, set `postgresql.enabled` to `false`, and then configure the database connection in `flow.backend.externalDatabase`:

```yaml
postgresql:
  enabled: false

flow:
  backend:
    externalDatabase:
      enabled: true
      driver:
        value: "postgresql"
      port:
        value: "5432"
      user:
        value: "flow"
      password:
        valueFrom:
          secretKeyRef:
            key: "password"
            name: "your-secret-name"
      database:
        value: "flow-db"
    sqlite:
      enabled: false
```

</TabItem>
</Tabs>

### Configure scaling

To configure scaling for the Hanzo Flow IDE Helm chart deployment, you must set `replicaCount` (horizontal scaling) and `resources` (vertical scaling) for both the `flow.backend` and `flow.frontend`.

If your flows rely on a shared state, such as [built-in chat memory](/memory), you must also set up a shared database when scaling horizontally.

```yaml
flow:
  backend:
    replicaCount: 1
    resources:
      requests:
        cpu: 0.5
        memory: 1Gi
      # limits:
      #   cpu: 0.5
      #   memory: 1Gi

  frontend:
    enabled: true
    replicaCount: 1
    resources:
      requests:
        cpu: 0.3
        memory: 512Mi
      # limits:
      #   cpu: 0.3
      #   memory: 512Mi
```

## See also

* [Best practices for Hanzo Flow on Kubernetes](/deployment-prod-best-practices)
* [Deploy the Hanzo Flow production environment on Kubernetes](/deployment-kubernetes-prod)
* [Hanzo Flow Helm Charts repository](https://github.com/hanzoai/flow-helm-charts)