Deploy the archiva helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy the Archiva Helm chart on Digital Ocean Kubernetes Service using Pulumi, you will need to complete a few steps:

1. **Create a Kubernetes cluster** on Digital Ocean using the `digitalocean.KubernetesCluster` resource.
2. **Install the Helm chart for Archiva** on the created Kubernetes cluster using the `kubernetes.helm.sh/v3.Chart` resource.

Here's a breakdown of how you can accomplish these steps using Pulumi and TypeScript:

- **Setting up the Digital Ocean Kubernetes Cluster**: We will use the `digitalocean.KubernetesCluster` resource to provision a Kubernetes cluster on Digital Ocean. You should specify the region, version of Kubernetes, and details for the node pool including the size and count of nodes.

- **Installing the Archiva Helm Chart**: Once the cluster is up and running, we will install the Archiva Helm chart on it. We will employ the `kubernetes.helm.sh/v3.Chart` resource from the `@pulumi/kubernetes` package for this purpose. The Helm chart will be fetched from its repository, and you can also supply a set of values to configure the Archiva Helm chart according to your needs.

Remember, before you run this Pulumi program, you should have Pulumi installed, along with access to Digital Ocean and the `pulumi` CLI configured with your Digital Ocean token.

Below is the complete Pulumi program in TypeScript that illustrates these steps:

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

// Create a new Digital Ocean Kubernetes cluster
const cluster = new digitalocean.KubernetesCluster("do-cluster", {
    region: "nyc3",
    version: "latest", // Use the latest available version of Kubernetes
    nodePool: {
        name: "default",
        size: "s-2vcpu-2gb", // Specifies the type of Droplet to use as workers
        nodeCount: 2, // Number of nodes in the node pool
    },
});

// Once the cluster is provisioned, we can get its kubeconfig for cluster access
const kubeConfig = pulumi.all([cluster.name, cluster.kubeConfigs]).apply(([name, kubeConfigs]) => {
    return kubeConfigs[0].rawConfig;
});

// Set up the K8s provider to use the kubeconfig from the cluster
const k8sProvider = new k8s.Provider("do-k8s", {
    kubeconfig: kubeConfig,
});

// Deploy the Archiva Helm chart on the cluster
const archivaChart = new k8s.helm.v3.Chart("archiva", {
    chart: "archiva",
    version: "0.1.0", // Specify the chart version you wish to deploy
    fetchOpts: {
        repo: "https://helm.repository.url", // Replace with the actual Helm chart repository URL
    },
}, { provider: k8sProvider });

// Export the cluster's name and kubeconfig
export const clusterName = cluster.name;
export const kubeConfigOutput = kubeConfig;
```

### What does the program do?

1. The `digitalocean.KubernetesCluster` resource initializes the cluster's configuration, setting the region and node pool properties. You can adjust the `size` to meet your resource needs, and `nodeCount` for redundancy and load balancing.

2. `kubeConfig` is a computed value that retrieves the raw Kubernetes configuration string once the cluster is created, allowing you to communicate with the cluster.

3. We instantiate a `k8s.Provider`, which is a Pulumi concept that allows us to interact with the Kubernetes cluster. The provider is configured with the previously obtained `kubeConfig`.

4. `k8s.helm.v3.Chart` represents the Archiva Helm chart deployment. It is tied to the provider we created, meaning the operations will target the newly created Digital Ocean Kubernetes cluster.

5. Finally, we're exporting the `clusterName` as well as the `kubeConfigOutput` to easily access the cluster outside of the Pulumi application (e.g., with `kubectl`).

### Deployment

To deploy this application:

1. Save this code in a file named `index.ts`.
2. Run `pulumi up` command in the terminal within the same directory where the code is saved.

Pulumi will execute the code and show a preview of the resources that will be created. Confirm the deployment, and it will provision the Digital Ocean Kubernetes cluster and deploy the Archiva Helm chart onto it. Once the deployment finishes successfully, you can use the output `kubeConfig` with `kubectl` to interact with your Kubernetes cluster.