Delete the pod. The file stays.

Delete a pod and its container filesystem goes with it — every log line, every temp file, every write, gone the instant the container stops. That is by design: pods are meant to be replaced, not nursed. But a database, a queue, anything stateful needs the opposite guarantee, and Kubernetes gives it one through a separate object: the PersistentVolumeClaim. A PVC is a request for storage that outlives whatever pod currently has it mounted — on AKS, backed by an Azure Disk, provisioned through the built-in managed-csi storage class. This lab proves the claim directly: write, delete the pod, read it back from the replacement. Then it proves the fine print — an Azure Disk PVC is ReadWriteOnce, mountable read-write by pods on exactly one node at a time, which is why it is the wrong choice the moment you need two pods sharing one volume.

The pod is disposable. The claim is not.

If you still have the cluster from Your first AKS cluster, skip to get-credentials. Otherwise recreate it with the identical command.

# Windows/Git Bash: stop it mangling /subscriptions/... arguments (harmless on macOS/Linux)
export MSYS_NO_PATHCONV=1

RG="campux-lab-aks-rg"
az group create -n "$RG" -l eastus

# same command as the first-cluster lab: free control plane, one small node
az aks create -n campux-aks -g "$RG" \
  --tier free \
  --node-count 1 \
  --node-vm-size Standard_B2s \
  --enable-managed-identity \
  --generate-ssh-keys

az aks get-credentials -n campux-aks -g "$RG"
kubectl get nodes
kubectl get storageclass

Request the smallest disk the class allows and mount it into a pod at /data.

kubectl create namespace storage-demo

cat > pvc.yaml <<'EOF'
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: demo-pvc
  namespace: storage-demo
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: managed-csi
  resources:
    requests:
      storage: 1Gi
EOF

kubectl apply -f pvc.yaml
kubectl get pvc demo-pvc -n storage-demo -w   # Ctrl-C once STATUS is Bound

Run a pod that mounts the claim, write a file to it, confirm the claim is now Bound, then delete the pod outright.

cat > pod-v1.yaml <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: writer
  namespace: storage-demo
spec:
  containers:
  - name: app
    image: busybox:1.28
    command: ["sh", "-c", "echo 'the disk remembers this' > /data/note.txt && sleep 3600"]
    volumeMounts:
    - name: data
      mountPath: /data
  volumes:
  - name: data
    persistentVolumeClaim:
      claimName: demo-pvc
EOF

kubectl apply -f pod-v1.yaml
kubectl wait --for=condition=Ready pod/writer -n storage-demo --timeout=120s
kubectl get pvc demo-pvc -n storage-demo
kubectl exec writer -n storage-demo -- cat /data/note.txt

kubectl delete pod writer -n storage-demo
kubectl get pod writer -n storage-demo   # -> Error from server (NotFound)

Start a new pod — different name, does not write anything — that mounts the same claim and reads the file the deleted pod left behind.

cat > pod-v2.yaml <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: reader
  namespace: storage-demo
spec:
  containers:
  - name: app
    image: busybox:1.28
    command: ["sh", "-c", "sleep 3600"]
    volumeMounts:
    - name: data
      mountPath: /data
  volumes:
  - name: data
    persistentVolumeClaim:
      claimName: demo-pvc
EOF

kubectl apply -f pod-v2.yaml
kubectl wait --for=condition=Ready pod/reader -n storage-demo --timeout=120s
kubectl exec reader -n storage-demo -- cat /data/note.txt

With reader still running and holding the claim, try to schedule a second pod that mounts the same PVC.

cat > pod-v3.yaml <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: second-reader
  namespace: storage-demo
spec:
  containers:
  - name: app
    image: busybox:1.28
    command: ["sh", "-c", "sleep 3600"]
    volumeMounts:
    - name: data
      mountPath: /data
  volumes:
  - name: data
    persistentVolumeClaim:
      claimName: demo-pvc
EOF

kubectl apply -f pod-v3.yaml
kubectl get pod second-reader -n storage-demo -w   # Ctrl-C once it stops changing

kubectl delete pod reader second-reader -n storage-demo

Delete the PVC before the namespace — otherwise wait for it to finish reclaiming, since the disk itself keeps billing until it does. Then delete the cluster.

kubectl delete pvc demo-pvc -n storage-demo
kubectl delete namespace storage-demo

az group delete -n campux-lab-aks-rg --yes --no-wait
az group exists -n campux-lab-aks-rg      # -> false once complete

You created a PersistentVolumeClaim backed by a real Azure Disk, wrote a file from one pod, deleted that pod, and read the identical file back from a pod that never wrote it — proof that a PVC's lifetime is independent of any pod that mounts it. You then scheduled a second pod against the same claim and read the exact meaning of ReadWriteOnce off the events, not off a guess: one node, not one pod, and a real limit that decides whether Azure Disk or Azure Files is the right call for a given workload.