Deploy the aws-api-gateway-operator helm chart on Oracle Kubernetes Engine (OKE)

Question

Pulumi · Accepted Answer

Deploying a Helm chart on an Oracle Kubernetes Engine (OKE) requires a Kubernetes cluster and Helm, a package manager for Kubernetes. Oracle Cloud Infrastructure (OCI) does not have a dedicated Pulumi resource for OKE, but it offers a `ContainerEngine` service (OKE) which can be managed using Kubernetes-related Pulumi resources.

Here's how we can approach this:

1. Set up an OCI Kubernetes cluster (OKE) using Pulumi.
2. Configure Pulumi to use `kubeconfig` to connect to the OCI Kubernetes cluster.
3. Use Pulumi's Kubernetes provider to deploy the Helm chart.

The following Pulumi program in TypeScript demonstrates how to use Pulumi to deploy the "aws-api-gateway-operator" Helm chart on OKE. Before running this program, ensure that you have:
- Installed Pulumi CLI and set up pulumi account.
- Set up the OCI configuration with the required credentials.
- Installed `kubectl` command-line tool.

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

// Create an instance of the Oracle Kubernetes Engine (OKE) Cluster
const cluster = new oci.core.Cluster("my-oke-cluster", {
    // You need to replace this with your actual OCI configuration details
    // The specifics depend on your OCI setup, such as the VCN and compartment IDs
    compartmentId: "your-compartment-id",
    vcnId: "your-vcn-id",
    kubernetesVersion: "v1.19.7", // Use a compatible Kubernetes version for the Helm chart
    // Add your node pool configuration with other related details as needed
});

// Once our cluster is created, we can obtain the kubeconfig file required to communicate with it
const kubeconfig = cluster.kubeconfig.apply(kubeconfigString =>
    pulumi.output(kubeconfigString).apply(JSON.parse));

// Create the Pulumi Kubernetes Provider to interact with the OKE cluster
const okeK8sProvider = new k8s.Provider("okeK8sProvider", {
    kubeconfig: kubeconfig.apply(kc => JSON.stringify(kc)),
});

// Deploy the aws-api-gateway-operator Helm chart on the OKE cluster
const awsApiGatewayOperatorChart = new k8s.helm.v3.Chart("aws-api-gateway-operator", {
    chart: "aws-api-gateway-operator",
    // Points to the Helm repository where the chart is hosted, you may have to replace this with the actual URL
    // Ensure that this Helm chart is compatible with your cluster version
    repo: "aws-api-gateway-operator-repo", 
    version: "chart-version", // Specify the version of the Helm chart
    // Specify necessary values that configure aws-api-gateway-operator to work in your environment
    values: {
        // Use this to pass custom configuration to your helm chart
    },
}, { provider: okeK8sProvider });

// Export the URL of the deployed application
export const appUrl = awsApiGatewayOperatorChart.getResourceProperty("v1/Service", "aws-api-gateway-operator-service", "status").apply(status => status.loadBalancer.ingress[0].ip);

```

### Explanation:

- We're using the `oci` package to create an OKE cluster. This package allows Pulumi to manage resources on Oracle Cloud Infrastructure. Note that the specific details for creating the OKE cluster, like `compartmentId`, `vcnId`, and node pool configuration need to be provided based on your OCI configuration.
- We use the `@pulumi/kubernetes` package to provide Kubernetes-related functionalities.
- The `kubeconfig` is generated after the OKE cluster is set up. We use a call to `apply` to convert it from a string (which is how it's stored in OCI) to a JSON object that Pulumi can work with.
- We then create an instance of `k8s.Provider` using this kubeconfig that allows us to interact with our newly created Kubernetes cluster.
- The `k8s.helm.v3.Chart` resource is used to deploy the Helm chart on our Kubernetes cluster. We must provide the chart name, repository, and version. Moreover, you can pass custom parameters to the Helm chart via the `values` argument.
- The `export const appUrl` line will output the URL where the deployed service can be accessed after deployment is complete. The `.getResourceProperty` method helps retrieve specific attributes from the deployed resources.

This flow sets up the necessary infrastructure and deploys the specified Helm chart to OKE. The actual values, OCI details, and Helm chart configurations would need to be adjusted according to the real deployment requirements.