Deploy the caddy-reverse-proxy helm chart on Oracle Kubernetes Engine (OKE)

Question

Pulumi · Accepted Answer

To deploy the `caddy-reverse-proxy` Helm chart on Oracle Kubernetes Engine (OKE), you will follow the below steps using Pulumi with TypeScript:

1. Configure the OCI provider to connect with your Oracle Cloud Infrastructure (OCI).
2. Create an instance of the Oracle Kubernetes Engine (OKE) cluster using the `oci.ContainerEngine.Cluster` resource.
3. Use the Helm Chart resource from the Kubernetes package to deploy the `caddy-reverse-proxy` chart onto the OKE cluster.

First, you need to ensure you have Pulumi installed and set up, as well as access to your Oracle Cloud Infrastructure with the necessary permissions to create and manage a Kubernetes cluster and deploy Helm charts.

Below is a TypeScript program that accomplishes the task:

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

// Ensure your OCI provider is correctly configured.
// This uses information from your environment or OCI configuration file.
const provider = new oci.Provider("oci", {
    // You can define specific provider configuration here if needed
});

// Replace the below properties with the appropriate values for your environment
const compartmentId = "ocid1.compartment.oc1..aaaaaaa...";
const adName = "AD-1";
const vcnId = "ocid1.vcn.oc1..aaaaaaa...";

// Create an OKE cluster
const cluster = new oci.ContainerEngine.Cluster("okeCluster", {
    compartmentId: compartmentId,
    vcnId: vcnId,
    kubernetesVersion: "v1.17.9", // use the version that suits your needs
    options: {
        serviceLbSubnetIds: [], // specify your LB subnet IDs
    },
});

// Create a Kubernetes provider instance using the kubeconfig from the created OKE cluster
const k8sProvider = new k8s.Provider("okeK8s", {
    kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

// Define the Helm Release for caddy-reverse-proxy
const caddyReverseProxyChart = new k8s.helm.v3.Chart(
    "caddy-reverse-proxy",
    {
        chart: "caddy-reverse-proxy",
        version: "0.1.0", // specify the chart version you want to deploy
        fetchOpts: {
            repo: "https://helm.caddyserver.com/", // add the Helm repository URL hosting the caddy chart
        },
    },
    { provider: k8sProvider }
);

// Export the cluster's kubeconfig and the service endpoint
export const kubeconfig = cluster.kubeconfig;
export const caddyServiceIp = caddyReverseProxyChart.getResourceProperty(
    "v1/Service", // The type of resource
    "caddy-reverse-proxy", // Name of the service resource, derived from the Helm release and chart
    "status" // The property of the Service we're interested in
).apply(status => status.loadBalancer.ingress[0].ip);

```

Here's what this program does:

- Imports the necessary Pulumi modules for Kubernetes and OCI.
- Sets up an OCI provider to authenticate against your OCI account.
- Creates an OKE cluster within your compartment and VCN.
- Uses the kubeconfig from your OKE cluster to create a Kubernetes provider.
- Deploys the `caddy-reverse-proxy` Helm chart onto the OKE cluster using the Helm chart resource. Ensure that you have added the Caddy helm repository to your Helm setup and the chart is available under the mentioned name.
- Exports the kubeconfig and service IP for the `caddy-reverse-proxy` to allow you to interact with your service from outside the cluster.

Remember, you need to fill in your specific OCI details for the compartment ID, availability domain, VCN ID, and service LB subnet IDs. The Oracle Kubernetes Engine will automatically provision worker nodes for you based on the settings you define.

Refer to the [OCI Provider documentation](https://www.pulumi.com/registry/packages/oci/) and the Pulumi [Kubernetes API documentation](https://www.pulumi.com/registry/packages/kubernetes/api-docs/) for additional details and configurations that can be applied.