Deploy the networking-calico helm chart on Oracle Kubernetes Engine (OKE)

Question

Pulumi · Accepted Answer

To deploy the Networking-Calico Helm chart on Oracle Kubernetes Engine (OKE), we will begin by setting up the necessary prerequisites, which include creating an OKE cluster and configuring kubectl to interact with the cluster. After the setup, we will use the Pulumi Kubernetes provider to deploy the Calico Helm chart on OKE.

Below is a Pulumi program written in TypeScript that demonstrates how to perform the deployment:

Set up an OKE cluster – Firstly, you need an Oracle Kubernetes Engine cluster to work with. Pulumi provides the oci.ContainerEngine.Cluster resource for creating an OKE cluster, which can be configured as per your requirements, including the number of nodes, shapes, version of Kubernetes, etc.
Install the Pulumi Kubernetes provider – Pulumi uses providers to manage resources. For deploying Helm charts on Kubernetes, we'll install the Pulumi Kubernetes provider.
Deploy the Networking-Calico Helm chart – Helm charts are used to deploy applications on Kubernetes. The kubernetes.helm.v3.Chart resource from Pulumi's Kubernetes provider will allow us to deploy the Networking-Calico Helm chart on our OKE cluster.
Configure Pulumi to use the correct kubeconfig – Ensure that Pulumi has the correct kubeconfig for your OKE cluster, which contains the necessary credentials to interact with your Kubernetes cluster.

Let's proceed with the Pulumi TypeScript program:

import * as pulumi from '@pulumi/pulumi';
import * as oci from '@pulumi/oci';
import * as kubernetes from '@pulumi/kubernetes';

// We assume that the OCI provider and OKE cluster are already set up and configured.
// Please replace `<INSERT_YOUR_VAR_HERE>` with appropriate values such as compartmentId or vcnId.

// Let's define the OKE cluster. You can customize it according to your needs.
const cluster = new oci.containerengine.Cluster("okeCluster", {
    // The `compartmentId` should be the OCID of the compartment where the cluster is located.
    compartmentId: "<INSERT_COMPARTMENT_OCID_HERE>",
    // The `vcnId` should be the OCID of the VCN associated with the OKE cluster.
    vcnId: "<INSERT_VCN_OCID_HERE>",
    // Define other parameters like Kubernetes version, node pool configuration, etc.
    // Refer to the Pulumi OCI documentation for more details on configuration options.
    // Documentation: https://www.pulumi.com/registry/packages/oci/api-docs/containerengine/cluster/
});

// Once the cluster is created, we retrieve its kubeconfig.
const kubeconfig = cluster.kubeconfigs.apply(kc => kc[0].content);

// Create a Kubernetes Provider instance using the kubeconfig from the cluster
const k8sProvider = new kubernetes.Provider("okeK8sProvider", {
    kubeconfig: kubeconfig,
});

// Use the Pulumi Kubernetes provider to deploy Calico using the Helm chart.
// This presumes you have Helm installed and configured in your environment.
const calicoChart = new kubernetes.helm.v3.Chart("calico", {
    chart: "calico",
    repo: "projectcalico", // Replace with the correct Helm repo for Networking-Calico if different.
    // Configure chart values as needed; these values are just an example.
    // Consult the Calico Helm chart's documentation for configurable options.
    // Documentation: https://artifacthub.io/packages/helm/calico/calico
    values: {
        calico: {
            // Add custom values for the Calico Helm chart here.
        },
    },
}, { provider: k8sProvider });

// Export the public URL for the Calico dashboard
export const calicoDashboardUrl = pulumi.interpolate`https://calico.example.com`; // Replace with actual URL if available.

Make sure to replace <INSERT_COMPARTMENT_OCID_HERE> and <INSERT_VCN_OCID_HERE> with the actual OCIDs from your Oracle Cloud Infrastructure setup. The example above is a minimal template and should be customized based on the specific requirements, such as node shapes, Kubernetes versions, and Calico Helm chart configurations.

In this program, we're using the Pulumi OCI package to create an instance of a Cluster for OKE, then fetching the kubeconfig needed to communicate with the cluster. We then create a new provider instance for Kubernetes that uses this kubeconfig. With the Kubernetes provider configured, we define a calicoChart using the kubernetes.helm.v3.Chart class, which will deploy the Networking-Calico Helm chart to our OKE cluster.

Once the chart is deployed, the Calico network policy engine will be active and available for use. We've also shown how to export a value (in this case, a placeholder URL for the Calico dashboard) which you can use to obtain outputs from your Pulumi program.

Before running this Pulumi program, you need to have Pulumi CLI installed, be logged in to your Pulumi account, and have the OCI configuration settings provided correctly to interact with your Oracle Cloud Infrastructure.

Lastly, to execute this Pulumi program:

Save the above code in a file named index.ts.
Run pulumi up in the terminal in the directory where you saved the index.ts file. The Pulumi CLI will take care of deploying resources defined in the program to your OCI and setting up Calico on OKE.