Deploy the twitter-app helm chart on Oracle Kubernetes Engine (OKE)

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Oracle Kubernetes Engine (OKE), you would typically need to follow these steps:

1. Set up and configure the Oracle Cloud Infrastructure (OCI) account and OKE cluster.
2. Install and configure `kubectl` and Helm CLI tools on your local machine.
3. Use `kubectl` to configure access to your OKE cluster.
4. Use Helm to deploy your application using the twitter-app Helm chart.

With Pulumi, you can automate the deployment of a Helm chart on OKE using the Pulumi OCI and Kubernetes providers. Below is a TypeScript program that demonstrates how to:

- Create a Kubernetes namespace where the Helm chart will be deployed.
- Deploy the Helm chart in the created namespace using the Helm Release resource.

Before running the Pulumi program, you need to have Pulumi CLI installed and set up the environment with your OCI configuration.

Here's a detailed TypeScript program that guides you through the process.

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

// Pulumi program entry point
async function main() {
    // Enter the necessary OCI configuration details
    const okeClusterId = "your-oke-cluster-id"; // Replace with your OKE cluster ID

// Obtain the kubeconfig from OCI for the OKE cluster
    const kubeconfig = oci.containerEngine.getClusterKubeconfig({
        clusterId: okeClusterId,
    });

// Create a provider for the OKE cluster using the obtained kubeconfig
    const provider = new k8s.Provider("oke-k8s-provider", {
        kubeconfig: kubeconfig.kubeconfig,
    });

// Create a new Kubernetes namespace for the twitter-app deployment
    const namespace = new k8s.core.v1.Namespace("twitter-app-ns", {
        metadata: {
            name: "twitter-app",
        },
    }, { provider: provider });

// Deploy the twitter-app using Helm chart
    const twitterAppChart = new k8s.helm.v3.Chart("twitter-app-chart", {
        chart: "twitter-app", // Replace with the correct chart name if it differs
        version: "1.0.0", // Specify the version of the chart you wish to deploy
        namespace: namespace.metadata.name,
        // Specify any custom values file or configuration required for the twitter-app
        // For example, if you have customValues.yaml, use the 'values' property to specify its path
        // values: {
        //     // Custom values for the Helm chart
        // }
    }, { provider: provider, dependsOn: [namespace] });

// Export the namespace name and other relevant information if needed
    return {
        namespaceName: namespace.metadata.name,
        // ...other exports
    };
}

// Run the Pulumi program
main().then((outputs) => {
    console.log("Successfully deployed twitter-app Helm chart:");
    console.log(`- Namespace: ${outputs.namespaceName}`);
    // Output other relevant information based on the returned values from 'main'
}).catch((error) => {
    console.error("Failed to deploy twitter-app Helm chart:", error);
});
```

In this program, we are using two major Pulumi resources:

- `@pulumi/oci.containerEngine.getClusterKubeconfig`: This function retrieves the kubeconfig from OCI for an existing OKE cluster.
- `@pulumi/kubernetes.helm.v3.Chart`: This resource is used to deploy applications on Kubernetes using Helm charts.

Please replace placeholders like `"your-oke-cluster-id"` and `"twitter-app"` with the actual IDs or names for your environment.

You will run this Pulumi program using the Pulumi CLI. First, navigate to the directory containing this script, and then execute the following commands:

```bash
# Install the necessary Pulumi providers
pulumi plugin install resource oci v0.0.0
pulumi plugin install resource kubernetes v0.0.0

# To preview the deployment without making any changes
pulumi preview

# To deploy the changes
pulumi up

# To destroy the resources (if needed at some point)
pulumi destroy
```

Replace `v0.0.0` with the actual version numbers of the OCI and Kubernetes Pulumi providers that are appropriate for your use case.

Remember that this program assumes that you have already configured your Pulumi CLI with the necessary OCI credentials and that your OKE cluster is up and running. The Helm chart for the `twitter-app` should also be available in a repository that is accessible from your Kubernetes cluster.