Deploy the tyk-pump helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

To deploy the Tyk Pump Helm chart on Azure Managed OpenShift Service using Pulumi, you will have to perform the following steps:

1. Set up an Azure OpenShift Managed Cluster - this will be your Kubernetes cluster environment where the Tyk Pump will eventually run.
2. Configure Kubernetes provider to interact with the Azure OpenShift cluster.
3. Use the Helm Chart resource to deploy the Tyk Pump chart into your OpenShift cluster.

Before you begin, make sure you have the Pulumi CLI and Azure CLI installed, and you have logged in to both the Pulumi and Azure with the appropriate accounts.

### Step 1: Create an Azure OpenShift Managed Cluster

Here is the Pulumi TypeScript program that sets up an Azure OpenShift Managed Cluster:

```typescript
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

// Create a resource group if you don't have one already
const resourceGroup = new azure_native.resources.ResourceGroup("resourceGroup", {
    resourceGroupName: "myResourceGroup",
    location: "East US", // Recommended to choose the location nearest to you
});

// Deploy an Azure OpenShift Managed Cluster
const openshiftCluster = new azure_native.redhatopenshift.OpenShiftCluster("openshiftCluster", {
    resourceGroupName: resourceGroup.name,
    resourceName: "myOpenShiftCluster",
    location: resourceGroup.location,
    masterProfile: {
        vmSize: "Standard_D4s_v3",
    },
    networkProfile: {
        // Replace with your VNet CIDR and subnet CIDRs
        podCidr: "10.0.0.0/14",
        serviceCidr: "172.30.0.0/16",
    },
    workerProfiles: [{
        name: "worker",
        count: 3,
        vmSize: "Standard_D4s_v3",
    }],
});

// Export the OpenShift managed cluster's API server URL for further configuration
export const openshiftApiServerUrl = openshiftCluster.apiserverProfile.url;
```

This program creates an OpenShift managed cluster with the necessary profiles for the master and worker nodes. You should replace the placeholders with actual values suitable for your use case. Additionally, ensure you have the necessary Azure credentials and permissions to create these resources.

### Step 2: Configure Kubernetes Provider to Interact with the OpenShift Cluster

You will need to set up Kubernetes provider configuration to point to your OpenShift cluster. This usually involves setting the `kubeconfig` to point to your OpenShift cluster's API server and credentials.

### Step 3: Deploy Tyk Pump Using Helm

After setting up the cluster, you will use Pulumi's Kubernetes provider to interact with the cluster and deploy the Tyk Pump using Helm. Here's how to continue your Pulumi program to deploy the Helm chart:

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

// Configure the Kubernetes provider using the generated kubeconfig
const provider = new k8s.Provider("openshiftK8s", {
    kubeconfig: openshiftApiServerUrl.apply(url => {
        // Logic to retrieve kubeconfig from OpenShift API server
        // This can involve interacting with the Azure CLI or OpenShift CLI to get the kubeconfig for your cluster.
        // You would typically use the API server URL to get access tokens and construct a kubeconfig.
        // Pseudocode:
        // const token = getTokenFromOpenShift(url);
        // const kubeconfig = getKubeconfig(url, token);
        // return kubeconfig;
    }),
});

// Deploy Tyk Pump using Helm chart
const tykPumpChart = new k8s.helm.v3.Chart("tyk-pump", {
    chart: "tyk-pump",
    version: "your-chart-version", // specify the version of Tyk Pump Helm chart you wish to deploy
    fetchOpts: {
        repo: "https://helm.tyk.io/public/helm/charts/", // the Helm repository where the Tyk Pump chart is located
    },
}, { provider });

// Export the deployment name
export const tykPumpDeploymentName = tykPumpChart.getResource("v1/Deployment", "tyk-pump");
```

This part of the program defines the deployment of the Tyk Pump Helm chart. Make sure to specify the version you want to deploy and to use the correct URL for the Tyk Helm repository. You need to replace the pseudocode for `kubeconfig` logic with actual code depending on how you manage to retrieve kubeconfig from Azure’s OpenShift clusters.

After completing these steps, you can run the Pulumi program using `pulumi up` from your command line within the project directory. This will initiate the deployment process.

Remember to review the plan output by Pulumi before confirming the deployment. Once it is deployed, Pulumi will give you outputs as defined in the program, such as the API server URL for the OpenShift cluster or the deployment name for the Tyk Pump Helm chart.