Deploy the nuxt2-spa helm chart on Oracle Kubernetes Engine (OKE)

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Oracle Kubernetes Engine (OKE) using Pulumi, we need to understand a few core components:

1. **Oracle Kubernetes Engine (OKE) Cluster**: This is the Oracle Cloud managed Kubernetes service where we will deploy our Helm Chart.
2. **Helm Chart**: This is a packaged set of pre-configured Kubernetes resources that can be deployed as a single unit. In your case, you want to deploy a `nuxt2-spa` Helm chart, which will contain the configuration for a Nuxt.js SPA (Single Page Application).

### Steps to Deploy a Helm Chart on OKE

1. **Provision an OKE Cluster**: First, we need to create an OKE cluster. If you already have one, you can skip this step and use your existing cluster's kubeconfig.

2. **Setup Helm Release Resource**: After setting up the OKE cluster, we use the `kubernetes.helm.v3.Chart` resource to deploy the `nuxt2-spa` Helm chart into our cluster. This resource allows us to specify the details of the Helm release like chart name, version, and any custom values we want to override.

### Pulumi Program

Here is a Pulumi TypeScript program that illustrates deploying the `nuxt2-spa` Helm chart on OKE:

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

// Replace these with the appropriate values for your environment.
const compartmentId = "your-compartment-id";
const chartRepo = "your-chart-repo";
const chartVersion = "your-chart-version";
const releaseName = "nuxt2-spa-release";

// Create an OKE cluster (if necessary).
const cluster = new oci.containerengine.Cluster("my-cluster", {
    // Cluster configuration ...
    compartmentId: compartmentId,
    // Other cluster configurations such as VCN, subnet, etc.
});

// Once the cluster is provisioned, we use the kubeconfig to interact with it via Pulumi.
const kubeconfig = cluster.kubeconfig.getContent();

// Create a provider instance that uses the above kubeconfig.
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig
});

// Deploy the 'nuxt2-spa' Helm chart to the cluster.
const nuxt2Spa = new k8s.helm.v3.Chart(releaseName, {
    chart: "nuxt2-spa",
    version: chartVersion,
    fetchOpts:{
        repo: chartRepo,
    },
}, { provider: k8sProvider });

// Export the URL of the deployed Nuxt.js SPA (assuming the service type is LoadBalancer).
export const spaUrl = nuxt2Spa.getResourceProperty("v1/Service", "nuxt2-spa-svc", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

### Explanation

The program begins by importing the necessary Pulumi oci and kubernetes packages. We've defined a few placeholders such as `compartmentId`, `chartRepo`, and `chartVersion` which should be filled with your specific details.

- We create an OKE cluster using the `oci.containerengine.Cluster` resource. This step involves setting various OKE-specific configurations like compartment ID, networking, and others. You'll need to fill in those details based on your OCI setup.

- We obtain the `kubeconfig` from the created cluster, which allows us to interact with the Kubernetes API server hosted on OCI.

- We set up the Kubernetes provider using the obtained `kubeconfig`. This tells Pulumi how to communicate with your cluster.

- We then declare a Helm chart resource using `k8s.helm.v3.Chart`. In this resource, we specify the details for the Helm release including the name of the chart (`nuxt2-spa`), its version, and the repository where it can be found.

- Once the chart is deployed, we export the URL where the SPA is accessible. This assumes that your Helm chart creates a Kubernetes `Service` of type `LoadBalancer` which provides an external IP to access your application.

### Before Running the Program

Make sure you have:

- Installed Pulumi CLI and set up the OCI provider.
- Authenticated with OCI (Oracle Cloud Infrastructure).
- Access to an OCI compartment and permissions to create resources.

To run the above Pulumi program, you would execute the following commands:

```bash
pulumi stack init dev                     # Initialize a new stack called 'dev'
pulumi up                                 # Deploy the stack
```

This will prompt you for confirmation before proceeding to make any changes. Once confirmed, Pulumi will execute the program and display the progress and results in the terminal.