Deploy the pizza-app helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

Deploying an application using a Helm chart on Digital Ocean's Kubernetes Service involves several steps:

1. **Set up a Kubernetes cluster** on Digital Ocean: We use the `digitalocean.KubernetesCluster` resource to create a Kubernetes cluster. We define the configuration of our cluster, including the number of nodes, region, and version of Kubernetes.

2. **Deploy the application using Helm**: Once our Kubernetes cluster is ready, we use the `kubernetes.helm.sh/v3.Chart` resource to deploy our application—in this case, the `pizza-app`—using a Helm chart. Helm is a package manager for Kubernetes, which simplifies deployment and management of applications. A Helm chart contains all the necessary resources and configuration files to deploy an application.

Now, let's walk through the Pulumi TypeScript program that accomplishes this:

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

// Create a DigitalOcean Kubernetes cluster with default settings
const cluster = new digitalocean.KubernetesCluster("do-cluster", {
    region: digitalocean.Regions.NYC3, // Choose the region where you want your cluster
    version: "latest", // Use the latest available Kubernetes version
    nodePool: {
        name: "default", // Name of the node pool
        size: digitalocean.DropletSlugs.DropletS2VCPU2GB, // Size of droplets to use for nodes
        nodeCount: 2, // Number of nodes in the node pool
    },
});

// Once the cluster is created, we can deploy application using Helm chart
// Let's assume pizza-app is a publicly available helm chart
const pizzaAppChart = new kubernetes.helm.sh/v3.Chart("pizza-app", {
    chart: "pizza-app", // Change this to the actual chart name
    // You can specify the repository if the chart is in a custom helm repo:
    // repo: "https://charts.example.com/",
    // version: "1.0.0", // The version of the chart to deploy
    namespace: "default", // Namespace where you want to install your application
    values: { // Custom values for your application
        // Provide configuration specific to the pizza-app chart
        // For example:
        // service: {
        //     type: "LoadBalancer",
        // },
    },
}, { provider: new kubernetes.Provider("k8s-provider", { kubeconfig: cluster.kubeConfigs[0].rawConfig }) });

// Export the cluster's kubeconfig and the application service endpoint
export const kubeconfig = cluster.kubeConfigs[0].rawConfig;
```
In this program:

- We first import the necessary modules from Pulumi's Digital Ocean and Kubernetes libraries.
- We create a Kubernetes cluster in Digital Ocean with the desired region, version, node pool name, droplet size, and node count configuration.
- Then, we define a Helm chart for the `pizza-app` application. In the chart's properties, there could be a repository URL if this application is hosted on a custom Helm repo; otherwise, it will default to the public Helm repository.
- We also specify a namespace where the application will live. If not given, it defaults to the `default` namespace.
- The `values` object is used to provide any custom values that the `pizza-app` chart expects; these values include configurations that the Helm chart uses to customize the deployment.
- Finally, we set up a Kubernetes provider with the cluster's kubeconfig, which is needed to deploy resources to our cluster.
- We export the kubeconfig, which allows us to interact with the Kubernetes cluster using `kubectl` or similar tools.

Please replace the placeholder values and configurations with actual values that apply to your `pizza-app` and preferred Digital Ocean settings. Remember to provide the actual Helm chart name for `pizza-app` if it is hosted elsewhere and not available in the public Helm repository.