Deploy the etcd-operator helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the etcd-operator Helm chart on Azure Kubernetes Service (AKS), you need to perform several steps:

1. **Create an AKS cluster**: You'll need a Kubernetes cluster running on AKS. This is where your etcd-operator will be deployed.

2. **Install the Helm chart**: Once you have a Kubernetes cluster, you can use Helm to install the etcd-operator chart.

Here's a detailed guide and Pulumi program in TypeScript to help you achieve this:

### Set up AKS Cluster

The first step is to create an AKS cluster. The following program demonstrates how to create an AKS cluster using the `azure-native` provider. The `azure-native` provider uses the native Azure Resource Manager API to provision resources, which allows for more control and uses the latest features available in Azure.

### Install etcd-operator Helm Chart

Once you have your Kubernetes cluster, you can install the etcd-operator Helm chart. Pulumi allows you to deploy Helm charts natively within your Pulumi program. You will install the etcd-operator into your AKS cluster using the `kubernetes` provider to communicate with your Kubernetes cluster and the Helm Chart resource to install the chart.

Now, let's look at the entire Pulumi program:

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

// Create a new password for the AKS cluster
const password = new random.RandomPassword("password", {
    length: 20,
    special: true,
}).result;

// Create a new resource group for the AKS cluster
const resourceGroup = new azure_native.resources.ResourceGroup("resourceGroup", {
    resourceGroupName: "etcd-operator-rg",
    location: "EastUS", // Choose the appropriate location
});

// Create an AKS cluster
const cluster = new azure_native.containerservice.ManagedCluster("aksCluster", {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [{
        count: 1, // Single node should suffice for demonstration
        maxPods: 110,
        mode: "System",
        name: "agentpool",
        osDiskSizeGB: 30,
        osType: "Linux",
        vmSize: "Standard_DS2_v2", // Choose the appropriate VM size
    }],
    dnsPrefix: pulumi.interpolate`${resourceGroup.name}-kube`,
    enableRBAC: true,
    kubernetesVersion: "1.20.7", // Specify your desired Kubernetes version
    linuxProfile: {
        adminUsername: "adminuser",
        ssh: {
            publicKeys: [{
                // A placeholder SSH public key - replace with your own
                keyData: "ssh-rsa ...",
            }],
        },
    },
    servicePrincipalProfile: {
        clientId: "CLIENT_ID", // Replace with your service principal's client ID
        secret: password,
    },
    nodeResourceGroup: pulumi.interpolate`${resourceGroup.name}-aks`,
}, { dependsOn: resourceGroup });

// Export the AKS cluster kubeconfig
export const kubeconfig = pulumi.
    all([cluster.name, resourceGroup.name]).
    apply(([clusterName, rgName]) => {
        return azure_native.containerservice.listManagedClusterUserCredentials({
            resourceName: clusterName,
            resourceGroupName: rgName,
        });
    }).
    apply(creds => Buffer.from(creds.kubeconfigs[0].value, 'base64').toString());

// Create a provider for the AKS cluster
const aksProvider = new k8s.Provider("aksProvider", {
    kubeconfig: kubeconfig,
});

// Install the etcd-operator Helm chart using the AKS cluster's provider
const etcdOperatorChart = new k8s.helm.v3.Chart("etcd-operator", {
    chart: "etcd-operator",
    version: "0.10.2", // specify the chart version you want to install
    namespace: "default", // choose the appropriate Kubernetes namespace
    fetchOpts: {
        // Specify the repository if needed
        repo: "https://charts.helm.sh/stable",
    },
}, { provider: aksProvider });
```

In this program, we accomplish the following:

- Generate a random password for the AKS cluster.
- Create a new resource group in Azure where all our resources will live.
- Create the AKS cluster with one node.
- Export the kubeconfig required to communicate with the cluster.
- Set up a Kubernetes provider with the exported kubeconfig.
- Finally, we use that Kubernetes provider to install the etcd-operator Helm chart.

The `version` property under `etcdOperatorChart` can be changed to deploy a specific version of the chart, and you should specify the correct `repo` where the chart is hosted.

Remember to replace the placeholder values like `ssh-rsa ...`, `CLIENT_ID`, and the repo for the chart with your actual values.

After defining this program, simply run `pulumi up` via your command line, and Pulumi will handle the provisioning and setup of your AKS cluster and the deployment of the etcd-operator Helm chart.