Deploy the laravel-octane helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

In order to deploy the Laravel Octane Helm chart on Azure Kubernetes Service (AKS), you'll need to perform several steps:

Set up an AKS Cluster: Begin by creating a resource group and an AKS cluster within Azure. AKS will serve as the environment to host your Docker containers.
Install and Configure Helm: Helm is a package manager for Kubernetes, which allows you to define, install, and upgrade even the most complex Kubernetes applications. You'll use Helm to deploy Laravel Octane.
Deploy Laravel Octane: Use Helm to deploy Laravel Octane to your AKS cluster by referencing its Helm chart.

Below is a Pulumi program written in TypeScript that follows these steps:

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

// Create a resource group for the AKS cluster
const resourceGroup = new azure.core.ResourceGroup("aksResourceGroup", {
    location: "EastUS",
});
  
// Create an Azure Active Directory application for the AKS cluster
const aksApp = new azuread.Application("aks");

// Create a service principal for the application
const aksSp = new azuread.ServicePrincipal("aksSp", { applicationId: aksApp.applicationId });

// Create the AKS cluster
const aksCluster = new azure.containerservice.KubernetesCluster("aksCluster", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    agentPoolProfiles: [{
        count: 2,
        vmSize: "Standard_DS2_v2",
    }],
    dnsPrefix: "akspulumi",
    linuxProfile: {
        adminUsername: "adminuser",
        sshKey: {
            keyData: "<YOUR_SSH_PUBLIC_KEY>",
        },
    },
    servicePrincipal: {
        clientId: aksApp.applicationId,
        clientSecret: aksSp.applicationPassword,
    },
});

// Export the kubeconfig
export const kubeconfig = aksCluster.kubeConfigRaw;

// Create a K8s provider using the kubeconfig
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: aksCluster.kubeConfigRaw,
});

// Install Laravel Octane Helm chart using the new K8s provider
const laravelOctaneChart = new k8s.helm.v3.Chart("laravelOctane", {
    chart: "laravel-octane",
    version: "1.0.0", // Replace with the actual chart version
    fetchOpts:{
        repo: "http://helm-repository-url/", // Replace with the actual Helm chart repository URL
    },
}, { provider: k8sProvider });

// Export the public endpoint of Laravel Octane service
export const endpoint = laravelOctaneChart.getResourceProperty("v1/Service", "laravel-octane", "status").apply(status => status.loadBalancer.ingress[0].ip);

In this program, the following steps are being taken:

You define a new AKS cluster by creating a KubernetesCluster resource with the azure.containerservice module.
The cluster is configured with Linux nodes (due to the linuxProfile block), and it uses a service principal for Azure integrations.
Note: Replace "<YOUR_SSH_PUBLIC_KEY>" with your actual SSH public key.
Once the cluster is provisioned, the output kubeConfigRaw is exported, and a Pulumi Kubernetes provider is created using this kubeconfig.
Using the k8s.helm.v3.Chart class from the @pulumi/kubernetes library, we define the Laravel Octane Helm chart with its corresponding version and repository URL. Adjust the version and repo value accordingly to match the specifics of the Laravel Octane Helm chart you want to deploy.
Finally, you can retrieve and export the public IP address of the Laravel Octane service through the getResourceProperty method, which accesses the service properties once the Helm chart is deployed.

Note: Before running this program, ensure you have Pulumi installed and configured with your Azure credentials. You'll also need to have kubectl installed to interact with your AKS cluster from the command line.

To execute this Pulumi program:

Save the code in a file with a .ts extension, such as deployLaravelOctane.ts.
Run pulumi up to preview and then deploy the changes.
Once deployed, you can use the exported kubeconfig by saving it locally and pointing kubectl to it, or by using the Pulumi stack's outputs to interact with your cluster.