Deploy the v3-oracle helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the v3-oracle Helm chart on Azure Kubernetes Service (AKS), you'll follow a series of steps:

1. **Set up an AKS cluster**: First, you need to have a working Kubernetes cluster on Azure. Pulumi provides resources to create and manage AKS clusters.

2. **Install the Helm chart**: After the AKS cluster is running, you'll use Pulumi's Helm release resource from the `@pulumi/kubernetes` package, which allows you to deploy Helm charts.

Below you'll find the TypeScript Pulumi program that demonstrates these steps. Make sure you have the Pulumi CLI installed and have authenticated with Azure before running this program.

First, we will create an AKS cluster:

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

// Create an Azure Resource Group
const resourceGroup = new azure.core.ResourceGroup("myResourceGroup", {
    location: "East US",
});

// Create an AKS cluster
const cluster = new azure.containerservice.KubernetesCluster("myAKSCluster", {
    resourceGroupName: resourceGroup.name,
    defaultNodePool: {
        name: "aksagentpool",
        nodeCount: 2,
        vmSize: "Standard_DS2_v2",
    },
    dnsPrefix: "myakscluster",
    identity: {
        type: "SystemAssigned",
    },
    location: resourceGroup.location,
});

// Export the Kubeconfig file to a local configuration
export const kubeconfig = cluster.kubeConfigRaw;
```

This block defines an AKS cluster with a default node pool containing two virtual machines.

Next, we'll deploy the `v3-oracle` Helm chart to the cluster we've just provisioned. Ensure you have the Helm chart's repository added and updated in your local Helm CLI, as Pulumi uses the Helm CLI to fetch charts.

```typescript
// Create a Kubernetes provider instance that uses our cluster from above.
const provider = new k8s.Provider("k8sProvider", {
    kubeconfig: cluster.kubeConfigRaw,
});

// Deploy v3-oracle Helm chart using the Kubernetes provider
const oracleChart = new k8s.helm.v3.Chart("v3-oracle-chart", {
    // Specify the chart, version, and repository here
    chart: "v3-oracle",
    // You will need to change with the actual version of your Helm chart
    version: "x.y.z",
    // If your chart is from a Helm repo, specify the repo URL here:
    fetchOpts: {
        repo: "https://[helm-chart-repository]",
    },
    // Specify the namespace if needed
    namespace: "default",
    // Values to pass to the Helm chart
    values: {
        // ...your custom values here
    },
}, { provider: provider });

// Export the public Service endpoint
export const oracleService = oracleChart.getResourceProperty("v1/Service", "my-service", "status");
```

Replace `"https://[helm-chart-repository]"` with the actual repository URL for the `v3-oracle` Helm chart and `"x.y.z"` with the chart's version you intend to deploy. If the chart needs custom values, provide them in the `values` object.

This program will create an AKS cluster and then deploy the `v3-oracle` Helm chart to your cluster using the credentials from the AKS cluster to communicate with the Kubernetes API.

Remember to install the required npm packages before running the program:

```bash
npm install @pulumi/pulumi @pulumi/azure @pulumi/kubernetes
```

Once your `index.ts` is set up with the above code, deploy your Pulumi stack with the following commands:

```bash
pulumi up # To preview and deploy changes
pulumi stack export kubeconfig --path [path-to-kubeconfig] # Output the kubeconfig to a file
```

After you run `pulumi up`, you'll see a preview of the resources Pulumi plans to create. Confirm the deployment by selecting `yes`, and Pulumi will provision the AKS cluster and deploy the Helm chart.

Note: Ensure your Helm CLI has access to the repository containing the `v3-oracle` chart and that your Pulumi CLI is logged in to your desired Azure account with the appropriate permissions.