Deploy the aws-api-gateway-operator helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the `aws-api-gateway-operator` Helm chart on Azure Kubernetes Service (AKS), you will need to complete a few steps.

1. **Provision an AKS cluster**: You will need to create an AKS cluster where the Helm chart will be deployed. Pulumi provides a resource called `ProvisionedCluster` under the `azure-native.hybridcontainerservice` module to create an AKS cluster.

2. **Install Helm on the local machine**: Helm is a package manager for Kubernetes, which you will use to deploy your chart. Make sure it is installed on your local machine or wherever you are running Pulumi from.

3. **Install and configure `kubectl`**: `kubectl` is a command-line tool for interacting with Kubernetes and is required to manage your AKS cluster.

4. **Deploy the Helm chart**: Once the cluster is up and running, you can use Pulumi's `Chart` resource from the `kubernetes` package to deploy your Helm chart.

Below you'll find a TypeScript program that shows you how you can accomplish this. First, it declares a new AKS cluster, then it installs the Helm chart to that cluster. Make sure you have Pulumi installed and configured for use with your Azure account.

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

// Create an Azure Resource Group
const resourceGroup = new azure_native.resources.ResourceGroup("resourceGroup", {
    resourceGroupName: "aksResourceGroup",
    location: "EastUS", // Replace with your Azure region
});

// Create an AD service principal for the AKS cluster.
const adApp = new azuread.Application("adApp", {
    displayName: "aks",
});
const adSp = new azuread.ServicePrincipal("adSp", {
    applicationId: adApp.applicationId,
});
const adSpPassword = new azuread.ServicePrincipalPassword("adSpPassword", {
    servicePrincipalId: adSp.id,
    value: "REPLACE_WITH_STRONG_PASSWORD",
    endDate: "2099-01-01T00:00:00Z",
});

// Create the AKS cluster.
const aksCluster = new azure_native.hybridcontainerservice.ProvisionedCluster("aksCluster", {
    // Required properties – replace with your own configuration
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    // assuming that you have the relevant roles and permissions set up in Azure Active Directory
    identity: {
        type: "SystemAssigned",
    },
    properties: {
        enableRbac: true, // RBAC should be enabled
        // more properties will be needed according to your specific setup
        kubernetesVersion: "1.21.2", // Specify your desired Kubernetes version
        agentPoolProfiles: [{
            count: 1,
            vmSize: "Standard_DS2_v2",
            osType: "Linux",
            mode: "User",
            name: "agentpool",
        }],
    },
});

// Export the kubeconfig for the AKS cluster
export const kubeconfig = pulumi.all([aksCluster.name, resourceGroup.name]).apply(([aksClusterName, rgName]) => {
    return aksCluster.properties.controlPlane.kubeConfig.value;
});

// Create a Kubernetes provider instance that uses our kubeconfig
const k8sProvider = new kubernetes.Provider("k8sProvider", {
    kubeconfig: kubeconfig,
});

// Deploy the aws-api-gateway-operator Helm chart
const awsApiGatewayOperatorChart = new kubernetes.helm.v3.Chart("awsApiGatewayOperator", {
    chart: "aws-api-gateway-operator",
    // Replace with the URL of the chart repository or the name of the chart in the official Helm repository
    fetchOpts: {
        repo: "https://example.com/helm-charts",
    },
    // If your helm chart needs specific values, declare them like the example below
    values: {
        // ... add your values here
    },
}, { provider: k8sProvider });

// Export the URL of the deployed application
export const applicationUrl = awsApiGatewayOperatorChart.getResourceProperty("v1/Service", "aws-api-gateway-operator-service", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

In this program:

- A new AKS cluster is created using Pulumi's `azure-native.hybridcontainerservice.ProvisionedCluster` resource. Adjust the configurations like `location`, `kubernetesVersion`, and `agentPoolProfiles` as per your requirements.
  
- The `kubeconfig` output of the AKS cluster is captured and is used to instantiate a new Kubernetes provider.

- The Helm chart for `aws-api-gateway-operator` is deployed through the Pulumi's `kubernetes.helm.v3.Chart` resource. You will need to find or host this Helm chart, as it's not available in the default Helm repositories.

Upon running this Pulumi program, it will automatically handle the process to stand up your AKS cluster and deploy the Helm chart onto it.

Remember to replace `REPLACE_WITH_STRONG_PASSWORD` with a strong password, and you must provide the correct Helm `repo` URL. The program also assumes you have the necessary Azure Active Directory roles and permissions set up for the service principal.

Please also note that you need to have Pulumi, `kubectl`, and Helm installed and configured.