Deploy the kube-monitoring-telegram-bot helm chart on Oracle Kubernetes Engine (OKE)

Question

Pulumi · Accepted Answer

To deploy the `kube-monitoring-telegram-bot` helm chart on Oracle Kubernetes Engine (OKE), we need to follow these general steps:

1. Ensure that we have an Oracle Kubernetes Engine (OKE) cluster up and running. We'll use the `oci.ContainerEngine.Cluster` resource from the OCI Pulumi provider to represent such cluster in code, if it's not already existing.
2. Set up Pulumi to work with the OKE cluster. This typically involves configuring the provider with the necessary credentials and endpoint information.
3. Use the `kubernetes.helm.sh/v3.Chart` resource from the Kubernetes Pulumi provider to deploy the Helm chart to the cluster.

Before we jump into the code, make sure that you have the following prerequisites in place:

- An Oracle Cloud Infrastructure (OCI) account with access to the Oracle Kubernetes Engine.
- Pulumi CLI installed and configured with your OCI credentials.
- The necessary credentials for accessing your OKE cluster, including kubeconfig.

Now we'll proceed with the Pulumi code which is written in TypeScript. The code will demonstrate how to deploy the `kube-monitoring-telegram-bot` helm chart to an existing OKE cluster. In this example, we assume you have the cluster and kubeconfig in place; we will focus on using the Kubernetes provider in Pulumi to deploy the helm chart.

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

// Assume that we have existing kubeconfig for our OKE cluster.
// This kubeconfig allow us to interact with the Kubernetes cluster API.
const kubeconfig = `your-kubeconfig-here`;

// Create a Kubernetes provider instance using the existing kubeconfig.
const provider = new k8s.Provider("oke-k8s", {
    kubeconfig: kubeconfig,
});

// Define the helm chart for kube-monitoring-telegram-bot.
// You need to provide the appropriate repository and chart name that corresponds
// to the kube-monitoring-telegram-bot application.
const chart = new k8s.helm.v3.Chart("kube-monitoring-telegram-bot", {
    chart: "kube-monitoring-telegram-bot",
    version: "chart-version", // specify the chart version if necessary
    fetchOpts: {
        repo: "https://helm-repository-containing-the-chart.com/", // where your helm chart is stored
    },
    values: { // specify your values for helm chart
        // An example value that typically needs to be configured:
        telegram: {
            botToken: "TELEGRAM_BOT_TOKEN", // replace with the actual Telegram bot token
            // ... other Telegram bot configurations
        },
        // ... additional configurations
    },
}, { provider: provider });

// Export any pertinent details such as the service endpoint.
export const telegramBotServiceEndpoint = chart.getResourceProperty(
    "v1/Service", "kube-monitoring-telegram-bot", "status"
).apply(status => status.loadBalancer.ingress[0].ip || status.loadBalancer.ingress[0].hostname);
```

Ensure you replace:

- `your-kubeconfig-here` - with the actual contents of your kubeconfig file for the OKE cluster.
- `chart-version` - with the version number of the `kube-monitoring-telegram-bot` Helm chart you wish to deploy if needed.
- `https://helm-repository-containing-the-chart.com/` - with the actual URL to the Helm repository that contains the `kube-monitoring-telegram-bot` chart.
- `TELEGRAM_BOT_TOKEN` - with your Telegram bot token.

After populating the placeholder values with actual data, you can apply this Pulumi program to deploy the Helm chart to your Oracle Kubernetes Engine (OKE) cluster.

The last line of the code creates an export statement which can be used to output the service endpoint of the telegram bot, once the deployment is completed and if it is exposed via a `LoadBalancer` service. If you use a different kind of service (e.g., `ClusterIP`, `NodePort`, or none at all), you might need to adapt or remove this export statement.