Deploy the voltha-adapter-simulated helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy the `voltha-adapter-simulated` Helm chart on a DigitalOcean Kubernetes Service (DOKS) using Pulumi, you'll first need to create a DOKS cluster and then deploy the chart to it. Below is a detailed guide and a Pulumi TypeScript program to accomplish this.

### Prerequisites:
Before you begin, make sure you have the following prerequisites met:
1. Pulumi CLI installed and configured with your DigitalOcean token.
2. Access to the `voltha-adapter-simulated` Helm chart and its repository information.

### Creating a DigitalOcean Kubernetes Cluster:
The first resource we will define is a `KubernetesCluster` from the `digitalocean` package. This represents a Kubernetes cluster in DigitalOcean. The cluster will be configured with a name, region, version, and node pool details.

### Deploying the Helm Chart:
Once the Kubernetes cluster is up and running, we'll deploy the Helm chart using the `Chart` resource from the `kubernetes` package.

The `Chart` resource requires several inputs:
- `chart`: The name of the chart, in this case, `voltha-adapter-simulated`.
- `repo`: The Helm chart repository URL where the chart can be found.
- `version`: (Optional) The specific version of the Helm chart to deploy.
- `values`: (Optional) Configuration overrides that correspond to the contents of the Helm chart's `values.yaml` file.

### Pulumi Program Structure:
Here's the structure of our Pulumi program:
1. Import necessary Pulumi libraries.
2. Create a new DigitalOcean Kubernetes cluster.
3. Deploy the `voltha-adapter-simulated` Helm chart to the cluster.

Let's look at the complete program:

```typescript
import * as pulumi from '@pulumi/pulumi';
import * as digitalocean from '@pulumi/digitalocean';
import * as kubernetes from '@pulumi/kubernetes';

// Step 1: Create a new DigitalOcean Kubernetes Cluster
const cluster = new digitalocean.KubernetesCluster('do-cluster', {
    region: 'nyc1',
    version: '1.21.5-do.0',
    nodePool: {
        name: 'default',
        size: 's-2vcpu-2gb',
        nodeCount: 2, // Specify the number of nodes in the node pool
    },
});

// Step 2: Configure the DigitalOcean provider to deploy resources in the created cluster
const kubeProvider = new kubernetes.Provider('do-k8s-provider', {
    kubeconfig: cluster.kubeConfigs[0].rawConfig,
});

// Step 3: Deploy the `voltha-adapter-simulated` Helm chart on the created cluster
const helmChart = new kubernetes.helm.v3.Chart('voltha-simulated-chart', {
    chart: 'voltha-adapter-simulated',
    // Replace `REPO_URL` with the actual repository URL of the `voltha-adapter-simulated` Helm chart
    fetchOpts: {
        repo: 'REPO_URL',
    },
    // Uncomment and modify the following if you need to pass specific values to the Helm chart
    // values: {
    //     key: "value", // Replace with actual configuration keys and values
    // },
}, { provider: kubeProvider });

// Export the kubeconfig and the public endpoint of the Kubernetes cluster
export const kubeConfig = cluster.kubeConfigs[0].rawConfig;
export const clusterEndpoint = cluster.endpoint;
```

In this program:

- A DigitalOcean Kubernetes cluster named `do-cluster` is created with the specified version and node count.
- A `kubeProvider` is initialized using the cluster's kubeconfig. This provider is used for deploying Kubernetes resources into the cluster.
- The `voltha-adapter-simulated` Helm chart is deployed using the `Chart` resource. Make sure to replace `'REPO_URL'` with the actual Helm repository URL.
- The Kubeconfig and cluster endpoint are exported, which can be used to interact with the cluster using tools like `kubectl`.

To run this Pulumi program, save the code to a `index.ts` file, run `pulumi up`, and follow the prompts from the Pulumi CLI to deploy your infrastructure.