Block and File Storage on Google Cloud

gcloud services enable compute.googleapis.com

export PROJECT_ID=$(gcloud config get-value project)
export REGION=us-central1
export ZONE=us-central1-a
export VM=catalog-api-1          # an existing VM in $ZONE

# Create a Hyperdisk Balanced data disk with explicit IOPS (per disk) and throughput (MiB/s)
gcloud compute disks create bookshelf-catalog-data \
  --zone="$ZONE" \
  --type=hyperdisk-balanced \
  --size=100GB \
  --provisioned-iops=3000 \
  --provisioned-throughput=140 \
  --labels=app=bookshelf,component=catalog-api

# Attach it to the running VM
gcloud compute instances attach-disk "$VM" \
  --zone="$ZONE" \
  --disk=bookshelf-catalog-data \
  --device-name=catalog-data

ls -l /dev/disk/by-id/google-catalog-data         # stable name for the disk
sudo mkfs.ext4 -m 0 -E lazy_itable_init=0,lazy_journal_init=0,discard \
  /dev/disk/by-id/google-catalog-data              # only for a new, empty disk
sudo mkdir -p /data
sudo mount -o discard,defaults /dev/disk/by-id/google-catalog-data /data
sudo blkid /dev/disk/by-id/google-catalog-data     # use the UUID in /etc/fstab with the nofail option

gcloud compute disks resize bookshelf-catalog-data --zone="$ZONE" --size=200GB
gcloud compute disks update bookshelf-catalog-data --zone="$ZONE" \
  --provisioned-iops=6000 --provisioned-throughput=250

# Inside the VM: grow an ext4 file system to fill the disk
sudo resize2fs /dev/disk/by-id/google-catalog-data

resource "google_compute_disk" "catalog_data" {
  name                   = "bookshelf-catalog-data"
  type                   = "hyperdisk-balanced"
  zone                   = "us-central1-a"
  size                   = 100
  provisioned_iops       = 3000
  provisioned_throughput = 140
  labels = {
    app       = "bookshelf"
    component = "catalog-api"
  }
}

gcloud compute disks create bookshelf-catalog-ha \
  --region="$REGION" \
  --replica-zones=us-central1-a,us-central1-b \
  --type=hyperdisk-balanced-high-availability \
  --size=100GB

# Creating the secondary disk in another region, pointing at the primary, starts replication
gcloud compute disks create bookshelf-catalog-data-dr \
  --zone=us-east1-b \
  --type=hyperdisk-balanced \
  --size=100GB \
  --primary-disk=bookshelf-catalog-data \
  --primary-disk-zone="$ZONE" \
  --primary-disk-project="$PROJECT_ID"

# A standard snapshot, stored in the multi-region "us"
gcloud compute snapshots create bookshelf-catalog-data-pre-upgrade \
  --source-disk=bookshelf-catalog-data \
  --source-disk-zone="$ZONE" \
  --storage-location=us \
  --description="before upgrade"

# An archive snapshot for long retention
gcloud compute snapshots create bookshelf-catalog-data-archive-2026 \
  --source-disk=bookshelf-catalog-data \
  --source-disk-zone="$ZONE" \
  --snapshot-type=ARCHIVE \
  --storage-location=us

# An instant snapshot in the disk's own zone
gcloud compute instant-snapshots create bookshelf-catalog-data-instant \
  --source-disk=bookshelf-catalog-data \
  --zone="$ZONE"

gcloud compute snapshots list \
  --filter="name~^bookshelf" \
  --format="table(name,diskSizeGb,snapshotType,status,storageLocations.list())"

gcloud compute resource-policies create snapshot-schedule bookshelf-daily \
  --region="$REGION" \
  --max-retention-days=14 \
  --on-source-disk-delete=keep-auto-snapshots \
  --daily-schedule --start-time=02:00 \
  --storage-location=us

gcloud compute disks add-resource-policies bookshelf-catalog-data \
  --zone="$ZONE" --resource-policies=bookshelf-daily

# 1. Create a disk from the snapshot (the disk can be in any zone; the type can differ from the original)
gcloud compute disks create bookshelf-catalog-restored \
  --zone="$ZONE" \
  --source-snapshot=bookshelf-catalog-data-pre-upgrade \
  --type=hyperdisk-balanced

# 2a. Restore a whole VM: create it with the restored disk as its boot disk
#     (use this when the snapshot was taken of a boot disk)
gcloud compute instances create catalog-api-restored \
  --zone="$ZONE" \
  --disk=name=bookshelf-catalog-restored,boot=yes,auto-delete=yes

# 2b. Recover a single file: attach the new disk to a recovery VM, mount it read-only, copy the file
gcloud compute instances attach-disk "$VM" --zone="$ZONE" \
  --disk=bookshelf-catalog-restored --device-name=restore
sudo mkdir -p /restore
sudo mount -o ro,noload /dev/disk/by-id/google-restore /restore    # noload skips journal replay on ext4
cp /restore/exports/orders-2026-09.csv /data/exports/
sudo umount /restore

# 3. Remove the temporary disk
gcloud compute instances detach-disk "$VM" --zone="$ZONE" --disk=bookshelf-catalog-restored
gcloud compute disks delete bookshelf-catalog-restored --zone="$ZONE" --quiet

gcloud services enable backupdr.googleapis.com

# A backup vault that refuses deletion of backups for the first 7 days
gcloud backup-dr backup-vaults create bookshelf-vault \
  --location="$REGION" \
  --backup-min-enforced-retention=7d \
  --description="Bookshelf backups"

gcloud backup-dr backup-vaults list --location="$REGION"

gcloud services enable file.googleapis.com

export NETWORK=default

gcloud filestore instances create bookshelf-exports \
  --location="$REGION" \
  --tier=REGIONAL \
  --file-share=name=exports,capacity=1TiB \
  --network=name="$NETWORK" \
  --labels=app=bookshelf

# The mount address is in the IP address and share name of the instance
gcloud filestore instances describe bookshelf-exports --location="$REGION" \
  --format="value(networks[0].ipAddresses[0])"

sudo apt-get install -y nfs-common               # Debian and Ubuntu; use nfs-utils on Red Hat family
sudo mkdir -p /mnt/exports
sudo mount -o rw,intr FILESTORE_IP:/exports /mnt/exports   # FILESTORE_IP from the describe command
echo 'FILESTORE_IP:/exports /mnt/exports nfs defaults,_netdev,nofail 0 0' | sudo tee -a /etc/fstab

resource "google_filestore_instance" "exports" {
  name     = "bookshelf-exports"
  location = "us-central1"
  tier     = "REGIONAL"

  file_shares {
    name        = "exports"
    capacity_gb = 1024
  }

  networks {
    network = "default"
    modes   = ["MODE_IPV4"]
  }
}

# Standard clusters only: enable the Filestore CSI driver (Autopilot has it on already)
gcloud container clusters update bookshelf-gke --region="$REGION" \
  --update-addons=GcpFilestoreCsiDriver=ENABLED

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: hyperdisk-balanced-retain
provisioner: pd.csi.storage.gke.io
parameters:
  type: hyperdisk-balanced
  provisioned-iops-on-create: "3000"
  provisioned-throughput-on-create: "140Mi"
reclaimPolicy: Retain
volumeBindingMode: WaitForFirstConsumer
allowVolumeExpansion: true
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: orders-exports
spec:
  accessModes: ["ReadWriteMany"]
  storageClassName: zonal-rwx
  resources:
    requests:
      storage: 1Ti

apiVersion: apps/v1
kind: Deployment
metadata:
  name: orders-api
spec:
  replicas: 2
  selector:
    matchLabels:
      app: orders-api
  template:
    metadata:
      labels:
        app: orders-api
    spec:
      containers:
        - name: orders-api
          image: us-central1-docker.pkg.dev/my-project-id/bookshelf/orders-api:1.0.0
          env:
            - name: BOOKSHELF_EXPORTS_DIR
              value: /mnt/exports
          volumeMounts:
            - name: exports
              mountPath: /mnt/exports
      volumes:
        - name: exports
          persistentVolumeClaim:
            claimName: orders-exports

package com.example.bookshelf.orders;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class ExportWriter {

    private final Path exportsDir;

    public ExportWriter(@Value("${bookshelf.exports.dir:/mnt/exports}") Path exportsDir) {
        this.exportsDir = exportsDir;
    }

    /** Writes the file under a temporary name and renames it, so readers never see a partial export. */
    public Path write(String name, byte[] content) throws IOException {
        Files.createDirectories(exportsDir);
        Path temp = Files.createTempFile(exportsDir, name, ".part");
        Files.write(temp, content);
        return Files.move(temp, exportsDir.resolve(name), StandardCopyOption.ATOMIC_MOVE);
    }
}

bookshelf:
  exports:
    dir: ${BOOKSHELF_EXPORTS_DIR:/mnt/exports}