Deploying Stateful Applications with Persistent Volumes in GKE - Tutorial

Deploying stateful applications in a Kubernetes environment requires handling data persistence. Google Kubernetes Engine (GKE) provides a solution through persistent volumes, which allow your applications to store and access data even when pods are rescheduled or restarted. This tutorial will guide you through the process of deploying stateful applications with persistent volumes in GKE.

Introduction to Persistent Volumes in GKE

Persistent volumes in GKE provide a way to decouple storage from individual pods and allow data to persist beyond the lifetime of pods. Persistent volumes can be dynamically provisioned or manually created, and they provide a consistent and reliable storage solution for stateful applications in Kubernetes clusters.

Prerequisites

Before getting started, ensure you have the following:

• A Google Cloud Platform (GCP) project with a GKE cluster
• Basic knowledge of Kubernetes concepts

Steps to Deploy Stateful Applications with Persistent Volumes in GKE

Follow these steps to deploy stateful applications with persistent volumes in GKE:

Step 1: Create a Persistent Volume

Create a persistent volume manifest file (e.g., pv.yaml) and define the storage characteristics and access modes for the volume. Here's an example of a persistent volume manifest:

apiVersion: v1
kind: PersistentVolume
metadata:
  name: my-pv
spec:
  capacity:
    storage: 1Gi
  accessModes:
    - ReadWriteOnce
  storageClassName: standard
  hostPath:
    path: /data/my-pv

This manifest creates a persistent volume named "my-pv" with a storage capacity of 1Gi and ReadWriteOnce access mode. The storageClassName and hostPath specify the storage class and the path on the host machine where the volume is located.

Step 2: Apply the Persistent Volume Manifest

Apply the persistent volume manifest by running the following command:

kubectl apply -f pv.yaml

This command creates the persistent volume in your GKE cluster.

Step 3: Create a Persistent Volume Claim

Create a persistent volume claim manifest file (e.g., pvc.yaml) to request storage from the persistent volume. Here's an example of a persistent volume claim manifest:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
  storageClassName: standard

This manifest requests a 1Gi storage capacity with ReadWriteOnce access mode. The storageClassName should match the one defined in the persistent volume manifest.

Step 4: Apply the Persistent Volume Claim Manifest

Apply the persistent volume claim manifest by running the following command:

kubectl apply -f pvc.yaml

This command creates the persistent volume claim, which binds to the available persistent volume and reserves the requested storage.

Step 5: Deploy Stateful Applications

Create a deployment manifest file (e.g., app.yaml) to define your stateful application deployment. In the manifest, specify the persistent volume claim as the volume source. Here's an example of a deployment manifest:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
        - name: my-app
          image: gcr.io/my-project/my-app:v1
          volumeMounts:
            - name: data
              mountPath: /data
      volumes:
        - name: data
          persistentVolumeClaim:
            claimName: my-pvc

This manifest creates a deployment named "my-app" with one replica. It mounts the persistent volume claim, "my-pvc," to the container's /data directory.

Step 6: Apply the Deployment Manifest

Apply the deployment manifest by running the following command:

kubectl apply -f app.yaml

This command deploys your stateful application with the persistent volume bound to it.

Common Mistakes to Avoid

• Not properly defining the persistent volume manifest with correct storage capacity, access modes, and storageClassName.
• Using different storage class names between the persistent volume and the persistent volume claim.
• Forgetting to apply the persistent volume claim before deploying the stateful application.

Frequently Asked Questions (FAQs)

1. Can I resize a persistent volume in GKE?

   No, GKE does not currently support resizing persistent volumes. However, you can create a new persistent volume with the desired size and migrate your data to the new volume.

2. Can I share a persistent volume among multiple pods?

   No, persistent volumes are designed to be used by a single pod at a time. If you need to share data among multiple pods, consider using a shared network file system (NFS) or a distributed storage solution.

3. How can I back up data stored in persistent volumes?

   You can back up data stored in persistent volumes by taking snapshots of the underlying storage system or using specialized backup tools that support Kubernetes volumes. Consult your storage provider's documentation for specific backup procedures.

4. What happens to the data in a persistent volume when a pod is deleted?

   The data in a persistent volume remains intact even if the pod using the volume is deleted. The volume can be reused by another pod, and the data will still be available.

5. Can I use different storage classes for different persistent volumes?

   Yes, you can define multiple storage classes and use different storage classes for different persistent volumes based on your application's requirements.

Summary

In this tutorial, you learned how to deploy stateful applications with persistent volumes in Google Kubernetes Engine (GKE). By following the steps outlined in this tutorial, you can ensure that your stateful applications have reliable and persistent storage in your GKE clusters. Remember to properly define and apply the persistent volume, persistent volume claim, and deployment manifests to successfully deploy your stateful applications.