Getting Started with Platform9: A Beginner’s Guide to Managed Kubernetes

Remember the first time you tried to set up a Kubernetes cluster from scratch? The endless YAML files, the networking headaches, the “it works on my machine” syndrome that somehow never translated to production? I’ve been there, and honestly, I was ready to give up until I discovered Platform9 Managed Kubernetes (PMK).

Here’s what we’re going to build today: a fully functional, production-ready Kubernetes cluster that someone else actually monitors and maintains for you. Yes, you read that right – we’re going to get all the power of Kubernetes without becoming a full-time Kubernetes administrator.

What Makes Platform9 Different?

Before we dive in, let’s talk about why Platform9 is worth your attention. Unlike DIY Kubernetes or even managed services from cloud providers, PMK uses a SaaS-managed model. Think of it like this: you provide the infrastructure (VMs, bare metal, or cloud instances), and Platform9’s control plane – running in their cloud – does all the heavy lifting of monitoring, upgrading, and healing your clusters.

The best part? It works anywhere. Your data center, AWS, Azure, your laptop (well, maybe not recommended for production, but you get the idea).

Prerequisites

Let’s make sure you have everything ready:

Required:

• A Linux VM or physical server running:
  • Ubuntu 18.04 LTS or newer (20.04 recommended)
  • CentOS 7/8 or RHEL 7/8
• Minimum 4GB RAM, 2 CPUs (8GB/4 CPUs recommended)
• Root or sudo access
• Stable internet connection
• Platform9 account (free tier available at platform9.com/signup)

Optional but Helpful:

• Basic familiarity with kubectl
• Understanding of Linux command line
• A cup of coffee ☕ (this will be easier than you think!)

---

Step 1: Create Your Platform9 Account and Access the Dashboard

Let’s start at the very beginning. Head over to Platform9’s website and sign up for the free tier. I went with the “Freedom” plan which gives you up to 20 nodes – more than enough for learning and even some production workloads.

Once you’ve verified your email, you’ll land in the Platform9 management console. This is your command center. Here’s what surprised me when I first logged in: everything is visual. No kubectl config files to wrestle with (yet), no YAML nightmares. Just a clean dashboard.

# Take note of these from your Platform9 dashboard:
# 1. Your Platform9 FQDN (looks like: pmkft-XXXXXXX.platform9.io)
# 2. Your account email
# 3. Your password

💡 Pro Tip: Bookmark your Platform9 management URL. You’ll be coming back here often, and it’s much better than trying to remember that random string of numbers.

---

Step 2: Prepare Your First Node

This is where the magic starts. Platform9 uses what they call a “BareOS” model – basically, you bring your own operating system, and they transform it into a Kubernetes-ready node.

First, SSH into your Linux VM:

ssh user@your-vm-ip

Now we need to install the Platform9 CLI tool. This little utility makes node preparation a breeze:

# Download the Platform9 CLI installer
curl -O https://raw.githubusercontent.com/platform9/express-cli/master/cli-setup.sh

# Make it executable
chmod +x cli-setup.sh

# Run the installer
sudo bash ./cli-setup.sh

During installation, you’ll be prompted for:

1. Your Platform9 FQDN (from Step 1)
2. Your account username (email)
3. Your password

Here’s where I got stuck the first time: On Ubuntu 20.04 and newer, you might hit a Python error. Platform9’s installer expects Python 2, but newer Ubuntu versions only ship with Python 3. Here’s the quick fix:

# Install Python 2 if missing
sudo apt update
sudo apt install python2 -y

# Create a symlink
sudo ln -s /usr/bin/python2 /usr/bin/python

---

Step 3: Prep Your Node for Kubernetes

With the CLI installed, let’s prepare this node to join our soon-to-be-created cluster:

# Prepare the node
pf9ctl cluster prep node
```

This command does several things behind the scenes:
- Installs the Platform9 agent
- Sets up required system packages
- Configures networking
- Registers the node with your Platform9 account

The process takes 2-5 minutes. Grab that coffee I mentioned!

When it completes successfully, you should see output similar to:
```
✓ Node preparation completed successfully
✓ Node registered with Platform9 management plane
✓ Node ID: node-abc123def456

What if…? If the prep fails with network errors, check if your VM can reach platform9.io on port 443. Platform9 needs to maintain a tunnel connection to the management plane.

---

Step 4: Create Your First Kubernetes Cluster

Now for the fun part! Head back to your Platform9 dashboard in your browser.

1. Navigate to Infrastructure > Clusters in the left sidebar
2. Click “Add Cluster”
3. Select “BareOS” as the cluster type
4. Name your cluster (I called mine “my-first-pmk-cluster”)

You’ll see your prepared node appear in the available nodes list. Here’s the configuration I recommend for beginners:

Cluster Configuration:
  Kubernetes Version: 1.21+ (latest stable)
  Container Runtime: containerd
  Network Plugin: Calico
  Service CIDR: 10.96.0.0/12 (default is fine)
  Pod CIDR: 10.20.0.0/16 (default is fine)
  
Master Nodes: Select your prepared node
Worker Nodes: Same node (for single-node setup)

Check the box: “Allow workloads on master nodes” – for a single-node learning cluster, this is essential.

Click Create Cluster and watch the magic happen. Platform9 will:

• Deploy Kubernetes components
• Configure networking (Calico CNI)
• Set up the control plane
• Install monitoring agents (Prometheus, Grafana)
• Deploy the Kubernetes dashboard

This takes about 10-15 minutes. The progress bar in the UI is actually accurate (unlike some other tools we won’t name).

---

Step 5: Access Your Cluster with kubectl

Your cluster is running! Now let’s interact with it. In the Platform9 dashboard:

1. Click on your cluster name
2. Navigate to “API Access” tab
3. Click “Download Kubeconfig”

Save this file as ~/.kube/config on your local machine:

# On your local machine (not the VM)
mkdir -p ~/.kube
mv ~/Downloads/pmk-config ~/.kube/config

# Set proper permissions
chmod 600 ~/.kube/config

# Test it out!
kubectl get nodes
```

You should see your node listed with status "Ready". If you see this, congratulations – you have a working Kubernetes cluster!
```
NAME              STATUS   ROLES           AGE   VERSION
my-node           Ready    master,worker   5m    v1.21.3-pmk.72

Here’s where I spent an hour debugging: If kubectl commands timeout from your local machine, you might need to connect from within the cluster node itself. This is because Platform9 uses a tunnel interface for management. For local development, I found it easier to install kubectl directly on the VM:

# On your Ubuntu VM
sudo snap install kubectl --classic
sudo cp /etc/kubernetes/admin.conf ~/.kube/config
kubectl get nodes  # This should work!

---

Step 6: Deploy Your First Application

Theory is great, but let’s run something real. We’ll deploy nginx as a simple test:

# Create a namespace to keep things organized
kubectl create namespace demo

# Deploy nginx
kubectl create deployment nginx --image=nginx:latest -n demo

# Expose it as a service
kubectl expose deployment nginx --port=80 --type=NodePort -n demo

# Check what we've created
kubectl get all -n demo
```

You should see:
```
NAME                         READY   STATUS    RESTARTS   AGE
pod/nginx-7848d4b86f-x9k2l   1/1     Running   0          30s

NAME            TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
service/nginx   NodePort   10.96.167.123   <none>        80:31234/TCP   15s

NAME                    READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/nginx   1/1     1            1           30s

To access your nginx server:

# Get the NodePort
kubectl get svc nginx -n demo

# Access it (use your VM's IP and the NodePort)
curl http://your-vm-ip:31234

You should see the nginx welcome page HTML!

---

Step 7: Explore Platform9’s Built-in Monitoring

This is where Platform9 really shines. Remember how I said someone else monitors your cluster? Let’s see it in action:

1. In the Platform9 dashboard, click on your cluster
2. Navigate to “Monitoring” tab

You’ll see:

• Real-time metrics: CPU, memory, network usage per node
• Pod health: Which pods are running, restarting, or failing
• Cluster events: Detailed logs of what’s happening
• Prometheus/Grafana dashboards: Pre-configured for you!

The beauty here is that you didn’t have to install or configure any of this. It’s all managed by Platform9’s SaaS plane.

---

Going Further: Experiments to Try

Now that you have a working cluster, here are some fun experiments:

Experiment 1: Try Multi-Node Clustering

Prepare a second VM using the same pf9ctl process, then add it to your existing cluster through the dashboard. Watch how Platform9 automatically balances workloads!

Experiment 2: Explore GitOps with ArgoCD

Platform9 includes ArgoCD out of the box. Try setting up a GitOps workflow:

# Access ArgoCD UI from Platform9 dashboard
# Navigate to Applications > ArgoCD

Experiment 3: Test the Profile Engine

Create an RBAC profile for your cluster, then see how Platform9’s “drift detection” alerts you when someone manually changes permissions. This is enterprise-grade governance made easy.

Experiment 4: Deploy a Stateful Application

Try running a database like PostgreSQL with persistent volumes. Platform9’s CSI support makes this surprisingly straightforward.

# Create a persistent volume claim
cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: postgres-pvc
  namespace: demo
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi
EOF

What’s Next?

Congratulations! You’ve just deployed your first managed Kubernetes cluster. But this is just the beginning. Here’s your learning path forward:

1. Week 1-2: Get comfortable with kubectl and deploy more complex applications
2. Week 3-4: Explore Platform9’s monitoring and alerting
3. Month 2: Try multi-cluster management (Platform9’s sweet spot)
4. Month 3: Implement GitOps workflows with ArgoCD

Resources to explore:
– Platform9 Documentation: docs.platform9.com
– Platform9 Community Slack: Great for getting help
– Kubernetes Official Docs: Your best friend for understanding the underlying tech

A final thought: What I love about Platform9 is that it doesn’t hide Kubernetes from you – you still get full kubectl access, you can still deploy any workload. But it removes the operational burden of keeping the cluster healthy. It’s like having a Kubernetes SRE team on standby 24/7.

So go ahead, deploy that app you’ve been putting off because “Kubernetes is too complex.” With Platform9, you might just find it’s easier than you thought.

Ready to share your Platform9 success story? Drop a comment below with what you built!