Using Portworx Shared Volumes

Difficulty: Intermediate

Estimated Time: 10 minutes

Portworx is a software defined persistent storage solution designed and purpose built for applications deployed as containers, via container orchestrators such as Kubernetes, Marathon and Swarm. It is a clustered block storage solution and provides a Cloud-Native layer from which containerized stateful applications programmatically consume block, file and object storage services directly through the scheduler.

In this tutorial, you will learn how to deploy multiple replicas of Nginx on Kubernetes and use Portworx Shared Volumes:

Use a Portworx Storage Class to create a shared volume PVC with 3 replicas of the data
Use a simple YAML file to deploy Nginx using this PVC
See how the shared volume allows 3 pods to use the volume at the same time and read/write data to the same file

Shared Volumes Overview

To learn more about how shared volumes can be useful check out our docs page.

This scenario assumes you have already covered the following scenarios:

Thank you for trying the playground. To view all our scenarios, go here

To learn more about Portworx, below are some useful references.

Your environment is currently being packaged as a Docker container and the download will begin shortly. To run the image locally, once Docker has been installed, use the commands

cat scrapbook_portworx_px-k8s-vol-shared_container.tar | docker load

docker run -it /portworx_px-k8s-vol-shared:

Restart Scenario

Next Scenario

Step 1 of 6

Wait for Kubernetes & Portworx to be ready

Let's first wait for Kubernetes and Portworx to be ready.

Step: Wait for Kubernetes to be ready

Click the below section which waits for all Kubernetes nodes to be ready.

watch kubectl get nodes

When all 4 nodes show status Running then hit clear to ctrl-c and clear the screen.

Step: Wait for Portworx to be ready

Watch the Portworx pods and wait for them to be ready on all the nodes. This can take a few minutes since it involves pulling multiple docker images. You will see 'No resources found' until all images are pulled.

watch kubectl get pods -n kube-system -l name=portworx -o wide

When all the pods show STATUS Running and READY 1/1 then hit clear to ctrl-c and clear the screen.

Now that we have the Portworx cluster up, let's proceed to the next step !

Create shared volume

In this step, we will create a Portworx volume (PVC) for nginx.

Step: Create StorageClass

Take a look at the StorageClass definition for Portworxcat px-shared-sc.yaml

The parameters are declarative policies for your storage volume. See here for a full list of supported parameters. In our case the key parameter is shared=true.

Create the storage class using:

kubectl create -f px-shared-sc.yaml

Step: Create PersistentVolumeClaim

Take a look at the Persistent Volume Claimcat px-shared-pvc.yaml

Here we're pointing at the storage class defined above and giving our volume a maximum size (Portworx thinly provisions volumes so that space will not be reserved up-front).

Create the PersistentVolumeClaim using:

kubectl create -f px-shared-pvc.yaml

Now that we have the volumes created, let's deploy a few nginx instances and see how the shared volumes work!

Deploy nginx

In this step, we will deploy the nginx application using the PersistentVolumeClaim created before.

Step deploy 3 instances of nginx

Take a look at the yaml: cat deploy-webapps.yaml

Observe the volumeMounts and volumes sections where we mount the PVC.

Now use kubectl to deploy nginx.

kubectl create -f deploy-webapps.yaml

Step: Verify nginx pods are ready

Run the below command and wait till all three nginx pods are in ready state.

watch kubectl get pods -l group=webapp -o wide

When all three pods are in Running state then then hit clear to ctrl-c and clear the screen. Be patient, if it's staying in Pending state for a while it's because it has to fetch the docker image on each node.

Inspect the volume

In this step, we will use pxctl to inspect the volume

Step: Inspect the Portworx volume

Portworx ships with a pxctl command line that can be used to manage Portworx.

Below we will use pxctl to inspect the underlying volume for our PVC.

VOL=`kubectl get pvc | grep px-shared-pvc | awk '{print $3}'`
PX_POD=$(kubectl get pods -l name=portworx -n kube-system -o jsonpath='{.items[0].metadata.name}')
kubectl exec -it $PX_POD -n kube-system -- /opt/pwx/bin/pxctl volume inspect ${VOL}

Make the following observations in the volume list

Status indicates the volume is attached and shows the node on which it is attached. For shared volumes, this is the transaction coordinator node which all other nodes will go through to write the data.
HA shows the number of configured replicas for this volume (shared volumes can be replicated of course, you can try it by modifying the storage class in step 2)
Shared shows if the volume is shared
IO Priority shows the relative priority of this volume's IO (high, medium, or low)

Now that we have our shared volumes created and mounted into all three nginx containers, let's proceed to write some data into the html folder of nginx and see how it gets read by all three containers.

Validate

In this step, we will check the state of our sample postgres database.

Step: Confirm our nginx servers are up

Get webapp1 IP address and curl

IP=`kubectl get svc | grep webapp1-svc | awk '{print $3}'` && curl $IP

You should see the following:

<head><title>403 Forbidden</title></head>
<body bgcolor="white">
<center><h1>403 Forbidden</h1></center>
<hr><center>nginx/xxx</center>
</body>
</html>

Step: Create index.html nginx html folder on webapp1

Copy index.html into webapp1's pod:

POD=`kubectl get pods -l app=webapp1 | grep Running | awk '{print $1}'`
kubectl cp index.html $POD:/usr/share/nginx/html/index.html

Now let's try all three URLs and see our hello world message is showing up on all three. This is because all three are attached to the same volume so updating one updates all three.

This will execute in Terminal 1

IP=`kubectl get svc | grep webapp1-svc | awk '{print $3}'` && curl $IP

IP=`kubectl get svc | grep webapp2-svc | awk '{print $3}'` && curl $IP

IP=`kubectl get svc | grep webapp3-svc | awk '{print $3}'` && curl $IP

File Ping Pong

In this step, we will play some file ping pong

Step: Open some bash sessions in webapps 1-3

Let's open a couple more terminals and have fun with shared volumes.

Open a terminal for webapp1: Terminal 1.

POD=`kubectl get pods -l app=webapp1 | grep Running | awk '{print $1}'`
kubectl exec -it $POD bash
cd /usr/share/nginx/html/
clear
PS1="ping-pong-1# "
echo "pong" > pingpong

Open a terminal for webapp2: Terminal 2.

POD=`kubectl get pods -l app=webapp2 | grep Running | awk '{print $1}'`
kubectl exec -it $POD bash
cd /usr/share/nginx/html/
clear
PS1="ping-pong-2# "
echo "pong" > pingpong

Open a terminal for webapp3: Terminal 3.

POD=`kubectl get pods -l app=webapp3 | grep Running | awk '{print $1}'`
kubectl exec -it $POD bash
cd /usr/share/nginx/html/
clear
PS1="ping-pong-3# "
echo "ping" > pingpong

Watch Ping - Pong Match between webapp1 and webapp2

tail -f pingpong

webapp1 is a pinger

while sleep 2; do  echo "pong" >> pingpong; done

webapp2 is a ponger

while sleep 1; do  echo "pong" >> pingpong; done

You can have some more fun by using terminals 1,2,3 to see how they all share data in the mounted /usr/share/nginx/html folder.

Terminal

cd <directory>	Change directory
ls	List directory
echo 'contents' > <file>	Write contents to a file
cat <file>	Output contents of file

i	In Command Mode	Change into Insert Mode, you can now insert and edit text in the file
esc	In Insert Mode	Change into Command Mode, you can now execute commands
:wq	In Command Mode	Save and Exit

Welcome!

Using Portworx Shared Volumes

Shared Volumes Overview

Congratulations!

You've completed the scenario!

Scenario Rating

Steps