Deploy the wikibase-ingress helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the Wikibase Ingress Helm chart on Azure Kubernetes Service (AKS), we'll go through the process step by step. Pulumi provides an easy way to define and deploy cloud infrastructure that includes managed Kubernetes clusters and Helm charts.

Here's how the process works:

1. **Set up the AKS Cluster**: You first need to create an instance of Azure Kubernetes Service. This will provide the necessary Kubernetes environment for deploying your Helm chart.

2. **Deploy the Helm Chart**: Once you have your Kubernetes cluster ready, you will deploy the Wikibase Ingress Helm chart onto it. Helm is a package manager for Kubernetes, which allows you to define, install, and upgrade even the most complex Kubernetes applications.

3. **Configure Ingress**: The ingress controller that you will be created using the Helm chart will manage external access to the services in the cluster, typically HTTP.

Now, let's translate these steps into Pulumi code using TypeScript.

First, ensure you've installed the Pulumi CLI and logged in, and have the Azure CLI installed and logged in. You should also have Node.js installed to run the TypeScript program.

Next, create a new Pulumi project and set it up for TypeScript:

```shell
pulumi new azure-typescript
```

This command creates a new Pulumi project preconfigured for use with TypeScript and the Azure cloud.

Next, replace the contents of `index.ts` with the following program:

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

// Step 1: Set up AKS
// Create a new service principal for the AKS cluster.
const adApp = new azuread.Application("aks");
const adSp = new azuread.ServicePrincipal("aksSp", { applicationId: adApp.applicationId });
const adSpPassword = new azuread.ServicePrincipalPassword("aksSpPassword", {
    servicePrincipalId: adSp.id,
    value: pulumi.secret("password"), // Replace with an actual secure password
    endDate: "2099-01-01T00:00:00Z",
});

// Create a resource group for the AKS cluster.
const resourceGroup = new azure.core.ResourceGroup("aksRg", {
    location: "East US", // Azure location to deploy the resources
});

// Now create the AKS cluster.
const aksCluster = new azure.containerservice.KubernetesCluster("aksCluster", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    defaultNodePool: {
        name: "aksagentpool",
        nodeCount: 2,
        vmSize: "Standard_DS2_v2",
    },
    dnsPrefix: `${pulumi.getStack()}-kube`,
    linuxProfile: {
        adminUsername: "adminuser",
        sshKey: {
            keyData: "ssh-rsa ...", // Replace with your SSH public key
        },
    },
    servicePrincipal: {
        clientId: adApp.applicationId,
        clientSecret: adSpPassword.value,
    },
    kubernetesVersion: "1.18.14",
});

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

// Step 2: Deploy the Helm Chart
// Use the kubernetes provider to interact with the AKS cluster.
const provider = new k8s.Provider("k8sProvider", {
    kubeconfig: aksCluster.kubeConfigRaw,
});

// Install the wikibase-ingress Helm chart.
const wikibaseIngressChart = new k8s.helm.v3.Chart("wikibase-ingress", {
    chart: "wikibase-ingress",
    version: "1.0.0", // Replace with the desired chart version
    fetchOpts: {
        repo: "http://helm-repo/path/to/wikibase", // Replace with the Helm chart repository URL
    },
    // Set necessary values according to the wikibase-ingress chart's requirements.
    values: {
        // Chart values go here.
    },
}, { provider });

// Step 3: Configure Ingress (Optional)
// The following is an example of how you might configure an ingress rule for wikibase.
// It assumes the wikibase-ingress Helm chart exposes the necessary configuration options to set up ingress rules.
const wikibaseIngressRule = {
    apiVersion: "networking.k8s.io/v1",
    kind: "Ingress",
    metadata: {
        name: "wikibase-ingress-rule",
        annotations: {
            "kubernetes.io/ingress.class": "nginx",
        },
    },
    spec: {
        rules: [
            {
                http: {
                    paths: [
                        {
                            path: "/",
                            pathType: "Prefix",
                            backend: {
                                service: {
                                    name: "wikibase-service",
                                    port: {
                                        number: 80, // Adjust the service name and port according to your Helm chart's services.
                                    },
                                },
                            },
                        },
                    ],
                },
            },
        ],
    },
};

// Apply the Ingress rule to the Kubernetes cluster.
const ingress = new k8s.networking.v1.Ingress("wikibase-ingress", wikibaseIngressRule, { provider });

```

In this code:

- We set up an Azure Kubernetes Service cluster with a specified node count and VM size.
- We deploy the Wikibase Ingress Helm chart onto this cluster by creating a `Chart` resource with Pulumi's Kubernetes package.
- Optionally, we configure an ingress rule for the Wikibase application, but this will depend on the specifics of the Helm chart and your requirements.
  
After you've set up the program, install the necessary Pulumi and NPM packages:

```shell
pulumi up                  # to preview and deploy changes
npm install @pulumi/azure  # Azure Resource provider
npm install @pulumi/azuread # Azure Active Directory provider
npm install @pulumi/kubernetes # Kubernetes provider
npm install @pulumi/pulumi # Pulumi SDK
```

Finally, run `pulumi up` to preview and deploy your infrastructure. Pulumi will provide a preview and, upon confirmation, proceed to deploy the specified resources and Helm chart.

Please replace placeholders like `ssh-rsa ...` and `"password"` with your actual SSH public key and a secure password before running `pulumi up`. Also, amend the repo URL, chart version, and any other relevant chart values for `wikibase-ingress`.