Deploy the gtm helm chart on Oracle Kubernetes Engine (OKE)

Question

Pulumi · Accepted Answer

Deploying the GTM (Global Traffic Management) Helm chart on Oracle Kubernetes Engine (OKE) involves several steps that include setting up OKE, configuring Helm for K8s deployment, and then deploying the chart itself. I'll walk you through these steps using Pulumi in TypeScript, providing explanations for each part of the process.

First, we need to install the required Pulumi packages. Make sure you have Pulumi installed and configured to connect to your Oracle Cloud Infrastructure (OCI). You'll also need to have `kubectl`, Helm, and the OCI CLI installed on your system to work with OKE and Helm charts.

Below is a program that will set up an OKE cluster and deploy a Helm chart to it. In this syntax, `pulumi.all` and `then` are used to ensure that the cluster is fully set up before attempting to deploy the Helm chart.

### Pulumi Program for Deploying Helm Chart on OKE

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

// Define the OKE cluster configuration
const okeCluster = new oci.ContainerEngine.Cluster("myOkeCluster", {
    // Replace the following with your OCI configuration
    compartmentId: oci.config.compartmentId,
    vcnId: "your-vcn-id", // VCN ID where the OKE cluster will be created
    kubernetesVersion: "v1.20.8", // Set the Kubernetes version
    options: {
        // Provide additional OKE options if needed
        serviceLbSubnetIds: ["your-lb-subnet-id-1", "your-lb-subnet-id-2"], // Subnet IDs for load balancing
        // Add any other required options
    },
    // Add other cluster parameters
});

// Get the Kubeconfig for the cluster after creation
const kubeconfig = pulumi.all([okeCluster.id, okeCluster.name]).apply(([id, name]) => {
    return oci.containerengine.getClusterKubeconfig({
        clusterId: id,
        name: name,
    });
});

// Create a Kubernetes provider pointing to the OKE cluster
const provider = new k8s.Provider("okeK8sProvider", {
    kubeconfig: kubeconfig.apply(c => c.content),
});

// Deploy the GTM Helm chart using the OKE cluster provider
const gtmHelmChart = new k8s.helm.v3.Chart("gtmHelmChart", {
    chart: "gtm",
    // Optionally specify the Helm repository
    // repo: "https://charts.example.com/", 
    namespace: "default", // Specify the namespace if different from 'default'
    values: {
        // Provide the necessary values for the GTM chart
        // replicaCount: 2,
        // service: { type: "LoadBalancer" },
        // ... other chart values ...
    },
}, { provider: provider });

// Export the cluster name and chart status
export const clusterName = okeCluster.name;
export const chartStatus = gtmHelmChart.status;

```

### Explanation of the Program

1. **Import Dependencies**: Import the Pulumi libraries for pulumi, the OCI provider, and the Kubernetes provider.

2. **Create OKE Cluster**: `oci.ContainerEngine.Cluster` is a Pulumi resource that creates a new OKE cluster. We are providing various parameters, including compartmentId, vcnId, and kubernetesVersion. Replace `"your-vcn-id"` and `"your-lb-subnet-id"` with actual IDs from your OCI setup. For more options, you can refer to the [ContainerEngine.Cluster documentation](https://www.pulumi.com/registry/packages/oci/api-docs/containerengine/cluster/).

3. **Kubernetes Configuration**: Obtain the kubeconfig file that will be used by Kubernetes-related Pulumi resources to interact with the OKE cluster. This is fetched using `oci.containerengine.getClusterKubeconfig` after the cluster is provisioned.

4. **Kubernetes Provider**: Instantiate a Kubernetes provider which encapsulates the kubeconfig and directs Kubernetes resources to use this specific cluster.

5. **Deploy Helm Chart**: With the `k8s.helm.v3.Chart` resource, you can deploy the chart of interest. Specify the chart (`gtm`), the namespace for the deployment, and the chart values according to the Helm chart's configuration requirements.

6. **Export Outputs**: At the end of the program, we export the generated cluster name and the Helm chart status for external access.

Keep in mind that before running this program, you'll need to have the following set up:

- An OCI account with appropriate permissions and API credentials configured.
- Pulumi CLI installed and configured to use your OCI credentials.
- OCI CLI and kubectl installed for OKE cluster and Helm management.

After setting up the project and writing this code to a TypeScript file (e.g., `index.ts`), you will run it using the Pulumi CLI.

This is a high-level framework of what deploying a Helm chart to OKE with Pulumi looks like. Depending on the specific GTM Helm chart, you might need to adjust the `values` or add additional configuration parameters specific to the chart. Make sure to check the Helm chart’s documentation for required value changes.