Deploy the ibm-cp4d-data-virtualization-instance helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

Deploying an IBM Cloud Pak for Data (CP4D) Data Virtualization instance on Azure Kubernetes Service (AKS) using Pulumi and Helm involves several steps. You'll first need to create an AKS cluster, and then within that cluster, you'll deploy the IBM CP4D Data Virtualization using its corresponding Helm chart.

Below is a TypeScript program that shows how to use Pulumi to provision an AKS cluster and deploy the IBM CP4D Data Virtualization Helm chart on it.

1. First, we define the Azure resource group and AKS cluster using `azure-native`.
2. We then configure the Kubernetes provider to point to the newly created AKS cluster.
3. Finally, we use the `kubernetes.helm.v3.Chart` resource to deploy the IBM CP4D Data Virtualization Helm chart into our AKS cluster.

Here's the rather detailed TypeScript program:

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

// Step 1: Set up a resource group and AKS cluster.
const resourceGroupName = new azure.core.ResourceGroup("rg", {
    location: "East US", // You can choose a different Azure region if required.
});

// Create an Azure AD application for AKS.
const app = new azuread.Application("app");

// Create a Service Principal for the Azure AD Application.
const servicePrincipal = new azuread.ServicePrincipal("servicePrincipal", {
    applicationId: app.applicationId,
});

// Create the Service Principal Password.
const spPassword = new azuread.ServicePrincipalPassword("spPassword", {
    servicePrincipalId: servicePrincipal.id,
    value: "password", // Replace with a secure password.
    endDate: "2099-01-01T00:00:00Z",
});

// Create the AKS cluster.
const cluster = new azure.containerservice.KubernetesCluster("aksCluster", {
    resourceGroupName: resourceGroupName.name,
    location: resourceGroupName.location,
    agentPoolProfiles: [{
        name: "agentpool",
        count: 2,
        vmSize: "Standard_DS2_v2", // You can choose a different VM size based on your requirements.
    }],
    dnsPrefix: "aksCluster",
    linuxProfile: {
        adminUsername: "aksuser",
        sshKey: {
            keyData: "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQD", // Replace with your SSH public key.
        },
    },
    servicePrincipal: {
        clientId: servicePrincipal.applicationId,
        clientSecret: spPassword.value,
    },
    kubernetesVersion: "1.19.11", // Choose a supported AKS Kubernetes version.
}, { dependsOn: [servicePrincipal, spPassword] });

// Export the AKS cluster kubeconfig.
export const kubeconfig = cluster.kubeConfigRaw;

// Step 2: Set up Pulumi to use the created AKS cluster as the Kubernetes provider.
const k8sProvider = new kubernetes.Provider("k8sProvider", {
    kubeconfig: cluster.kubeConfigRaw,
});

// Step 3: Deploy IBM CP4D Data Virtualization instance using Helm Chart.
const cp4dChart = new kubernetes.helm.v3.Chart("ibm-cp4d-data-virtualization-instance", {
    chart: "ibm-cp4d-data-virtualization",
    fetchOpts: {
        repo: "https://raw.githubusercontent.com/IBM/charts/master/repo/stable/", // The Helm repository URL.
    },
    // Set the necessary values for the Helm chart.
    // This is where you'd set your configuration for the deployment.
    // values: { ... }
}, { provider: k8sProvider });

// Export the Helm chart deployment status
export const cp4dDeploymentStatus = cp4dChart.status;

```

### Understanding the Program

- The program sets up a new resource group using the `azure.core.ResourceGroup` resource. This group will contain your AKS cluster.
- Next, an Azure AD application and service principal are created. These are used by AKS for interacting with other Azure services securely.
- Then, a password for the service principal is created. Note that you should choose a secure password instead of using a hardcoded value like "password".
- An AKS cluster resource is created with the name "aksCluster". It is configured with a single agent pool with two virtual machines.
- We export the `kubeconfig` of the AKS cluster, which allows you to interact with your Kubernetes cluster using kubectl or other Kubernetes tools.
- A Kubernetes provider is set up with the newly acquired `kubeconfig` to interact with your AKS cluster through Pulumi.
- Finally, the program deploys the IBM CP4D Data Virtualization instance using the `kubernetes.helm.v3.Chart` resource to the AKS cluster.

Please replace placeholders such as `ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQD` with your actual SSH public key and follow similar security best practices for other sensitive data.

Before running this program, make sure you have the necessary permissions to create resources in Azure and have configured Pulumi CLI with access to your Azure account.