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

Question

Pulumi · Accepted Answer

To deploy a Helm chart to the Digital Ocean Kubernetes Service, you would need to go through a few steps:

1. Provision the Digital Ocean Kubernetes cluster.
2. Deploy the Helm chart to this cluster.

In Pulumi, this is achieved via two major steps:

1. First, you create the Kubernetes cluster using `digitalocean.KubernetesCluster` which represents a managed Kubernetes cluster in Digital Ocean.
2. Once the cluster is up and running, you can use `kubernetes.helm.sh/v3.Chart` to deploy a Helm chart onto this cluster.

Below is a Pulumi program that demonstrates this process. This program uses TypeScript, which is one of the supported programming languages for Pulumi.

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

// Create a Digital Ocean 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,
    },
});

// Export the kubeconfig to use when deploying the helm chart.
export const kubeConfig = cluster.kubeConfigs[0].rawConfig;

// After the cluster is provisioned, we use the kubeconfig to interact with it and deploy Helm charts.
// We output the kubeconfig to a file since we are using Helm to deploy the application.
// This step usually happens on your CI/CD pipeline or machine from where deployments are made.
pulumi.all([cluster.name, kubeConfig]).apply(([name, kubeConfig]) => {
    require("fs").writeFileSync(`kubeconfig-${name}`, kubeConfig);
});

// Wait for the K8s cluster to be up and running before proceeding with Helm chart deployment.
const k8sProvider = new kubernetes.Provider("do-k8s-provider", {
    kubeconfig: kubeConfig,
});

// Deploy a Helm chart for the Symfony application using the Digital Ocean Kubernetes cluster as the provider.
// The Helm chart would be pulled from a Helm chart repository that you specify, or from a local path.
// Replace 'REPO_URL' with the URL of your Helm chart's repository and 'CHART_VERSION' with your chart's version.
const symfonyAppChart = new kubernetes.helm.v3.Chart("symfony-app", {
    chart: "symfony-app",
    fetchOpts: {
        repo: "REPO_URL", // Insert the URL of your Helm chart repo
    },
    version: "CHART_VERSION", // Pin to a specific version of the chart
    values: {
        // Define values for the Helm chart if necessary.
    },
}, { provider: k8sProvider });

// Optionally, export a URL or other stack outputs you wish to view or access.
// For instance, if your application has an external IP you can export here.
// export const applicationUrl = ...
```

In this program, we start by importing the necessary packages for Digital Ocean and Kubernetes. The `digitalocean` package contains the necessary resources to interact with Digital Ocean, and the `kubernetes` package contains resources for Kubernetes objects including those for Helm charts.

Next, we create an instance of `digitalocean.KubernetesCluster` which provisions a new Kubernetes cluster in the Digital Ocean cloud. This instance is configured with a name, region, Kubernetes version, and specifications for its node pool.

After provisioning the cluster, we export the generated kubeconfig. This kubeconfig file is used to interact with the Kubernetes cluster and deploy applications, including Helm charts.

The `kubernetes.Provider` resource is then instantiated, which allows us to specify the Kubernetes cluster that we'll be interacting with when managing Helm charts and other Kubernetes resources.

Finally, we deploy the Helm chart using the `kubernetes.helm.v3.Chart` resource. Here, you need to replace `'REPO_URL'` with the actual URL of your Helm chart's repository and `'CHART_VERSION'` with the version of the chart you wish to deploy. You may also specify `values` if your Helm chart requires configuration.

This is a basic outline for deploying a Symfony application to Digital Ocean Kubernetes using Pulumi and TypeScript. It assumes that your Pulumi CLI is set up and authenticated with Digital Ocean.