Deploy the plex-media-server helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the Plex Media Server on an Azure Kubernetes Service (AKS) cluster using a Helm chart, you would perform the following high-level steps:

1. Provision an AKS cluster.
2. Install Helm and Tiller on the AKS cluster (if Helm 3 is not used as it doesn't require Tiller).
3. Use Helm to deploy the Plex Media Server chart to the AKS cluster.

First, you need to have an AKS cluster running. The AKS cluster serves as the platform where the Plex Media Server will be deployed. AKS is a managed Kubernetes service that simplifies the deployment and operations of a Kubernetes cluster in Azure.

Next, Helm is a package manager for Kubernetes, which allows you to define, install, and upgrade complex Kubernetes applications. Helm charts are pre-configured Kubernetes resources that can be deployed as packages to your Kubernetes cluster.

The `kubernetes.helm.v3.Chart` resource from the Pulumi Kubernetes provider can be used to deploy a Helm chart into a Kubernetes cluster.

Below is the Pulumi TypeScript program that creates an AKS cluster and deploys the Plex Media Server to it using a Helm chart:

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

// Create an AKS cluster.
const cluster = new azure.containerservice.KubernetesCluster("aksCluster", {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [{
        name: "aksagentpool",
        count: 1,
        vmSize: "Standard_DS2_v2",
    }],
    dnsPrefix: "plexmediadns",
    linuxProfile: {
        adminUsername: "aksuser",
        sshKeys: [{
            keyData: "ssh-rsa PUB_KEY_HERE",
        }],
    },
    servicePrincipal: {
        clientId: "YOUR_CLIENT_ID",
        clientSecret: "YOUR_CLIENT_SECRET",
    },
});

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

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

// Deploy the Plex Media Server Helm chart.
const plexChart = new k8s.helm.v3.Chart("plexMediaServer", {
    chart: "plex-media-server",
    fetchOpts: {
        repo: "https://example-repo.com/charts", // Replace with the actual Helm chart repo URL
    },
    values: {
        claimToken: "YOUR_CLAIM_TOKEN", // Replace with actual Plex claim token if needed
    },
}, { provider: k8sProvider });

// Export the external IP to access the Plex Media Server.
export const plexServiceIp = plexChart.getResourceProperty("v1/Service", "plex", "status").apply((status: any) => status.loadBalancer.ingress[0].ip);
```

Here's a breakdown of what this program does:

- Creates an AKS cluster with a single node using the `azure.containerservice.KubernetesCluster` resource. 
- Exports the raw Kubernetes config (kubeconfig), which is used to communicate with your AKS cluster.
- Creates a Pulumi Kubernetes provider using the exported kubeconfig.
- Deploys the Plex Media Server using the `k8s.helm.v3.Chart` resource. You'll need the actual Helm chart repository URL and any required values, such as a claim token if needed.

Please replace the placeholders `PUB_KEY_HERE`, `YOUR_CLIENT_ID`, `YOUR_CLIENT_SECRET`, and `YOUR_CLAIM_TOKEN` with your actual SSH public key, Azure Service Principal client ID and secret, and the Plex claim token if needed. The Helm repo URL `https://example-repo.com/charts` should be replaced with the actual repository containing the Plex Media Server Helm chart.

After running this program with Pulumi CLI (running `pulumi up`), the Plex Media Server should be deployed on the AKS cluster and the external IP address to access the Plex Media Server will be exported.

Remember that managing cloud resources involves costs, and running an AKS cluster will incur charges on your Azure account. Make sure to shut down resources with `pulumi destroy` when you're done to avoid unnecessary charges.