Deploy the k8s-node-image-nginx-1-22 helm chart on Oracle Kubernetes Engine (OKE)

Question

Pulumi · Accepted Answer

To deploy a Helm chart on the Oracle Kubernetes Engine using Pulumi, you will need to set up your Pulumi environment for Oracle Cloud Infrastructure (OCI) and Kubernetes. The process involves installing the necessary packages, writing the TypeScript code, and deploying the resources.

Here, I will guide you through the steps necessary to accomplish this, including creating a Kubernetes cluster on Oracle Cloud, setting up Helm to deploy the Nginx chart, and understanding each component of the Pulumi program.

First, you will need to install the Pulumi CLI and set up your Oracle Cloud account. Once that is all set, you can proceed with writing the TypeScript code.

We'll use the following Pulumi resources for our deployment:

- `oci.ContainerEngine.Cluster`: This resource is used to create and manage a Kubernetes cluster in OCI's Container Engine for Kubernetes service, often abbreviated as OKE. Before provisioning a Kubernetes cluster, ensure you have a Virtual Cloud Network (VCN) and necessary policies set up in your OCI account.
- `kubernetes.helm.sh/v3.Chart`: This resource deploys a Helm chart to a Kubernetes cluster. Helm is a package manager for Kubernetes, which allows you to define, install, and upgrade even the most complex Kubernetes applications.

Keep in mind that Pulumi programs are run using the Pulumi CLI, which communicates with your cloud providers to manage your infrastructure. The credentials for Oracle Cloud and Kubernetes should be configured beforehand, typically through environment variables or configuration files.

Here's how you can write a Pulumi program to deploy the `k8s-node-image-nginx-1-22` Helm chart on OKE:

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

// Create a new OKE Kubernetes Cluster
const cluster = new oci.ContainerEngine.Cluster("my-cluster", {
    // Parameters for cluster creation here...
    /* You will need to specify the appropriate details here according to your
       Oracle Cloud Infrastructure, such as compartmentId, vcnId, etc. */
});

// Kubeconfig to access our new Kubernetes cluster on OKE
const kubeconfig = cluster.kubeconfig.apply(kc => kc.content);

// Use the cluster kubeconfig to create a k8s provider instance
const k8sProvider = new k8s.Provider("my-k8s-provider", {
    kubeconfig: kubeconfig,
});

// Deploy the 'k8s-node-image-nginx-1-22' Helm chart using the k8s provider
const nginxChart = new k8s.helm.v3.Chart("nginx-chart", {
    chart: "nginx",
    version: "1.22", // Specify the chart version you wish to deploy
    fetchOpts: {
        // Add the repo where 'k8s-node-image-nginx-1-22' is located,
        // if it's not in the stable repository
    },
}, { provider: k8sProvider });

// Export the kubeconfig to access the cluster using `kubectl`
export const kubeconfigFile = cluster.kubeconfig;

// Additionally, you might want to export the public endpoint of the nginx service
// once it's deployed and has a load balancer associated with it. For instance:
export const nginxEndpoint = nginxChart.getResourceProperty("v1/Service", "nginx-chart", "status")
    .apply(status => status.loadBalancer.ingress[0].ip || status.loadBalancer.ingress[0].hostname);

```

In this TypeScript program:

- A new Kubernetes cluster is created in Oracle Cloud using the `oci.ContainerEngine.Cluster` resource. Replace the placeholder comments with actual values for `compartmentId`, `vcnId`, etc., according to your OCI setup.
- A kubeconfig is generated to enable access to the cluster.
- A `k8s.Provider` is instantiated with this kubeconfig, which will be used by Pulumi to communicate with your Kubernetes cluster.
- The `k8s.helm.v3.Chart` resource is used to deploy Nginx using the specified Helm chart. If your Nginx chart is not located in the default Helm repo, you need to provide the `fetchOpts` with details about the repository URL.
- We export the kubeconfig so that you can access your Kubernetes cluster with `kubectl` from your local machine after deployment.
- We also try to export the Nginx service endpoint, which might have an IP or a hostname provided by a LoadBalancer, depending on the service type defined in the Helm chart.

To deploy this program, you will use the `pulumi up` command, which will provision the specified resources in OCI and deploy the Helm chart to your OKE cluster. Ensure to review the deployment plan and confirm the changes before they are applied.

Please replace the placeholders and add necessary configurations specific to your environment before running the program. Always review the documentation for the OCI Pulumi provider and the Kubernetes Pulumi provider to understand the configuration options and best practices.