Esegui la migrazione dei dati MySQL da Persistent Disk a Hyperdisk in GKE

Questo tutorial mostra come eseguire la migrazione dei dati MySQL esistenti da un Persistent Disk (DP) a Hyperdisk su Google Kubernetes Engine per migliorare le prestazioni di archiviazione. Hyperdisk offre un numero di IOPS e un throughput superiori rispetto a Persistent Disk, il che può migliorare le prestazioni di MySQL riducendo la latenza per le query e le transazioni del database. Puoi utilizzare gli snapshot del disco per eseguire la migrazione dei dati a tipi di dischi diversi a seconda della compatibilità del tipo di macchina. Ad esempio, i volumi Hyperdisk sono compatibili solo con alcuni tipi di macchine di terza, quarta e successive generazioni, come N4, che non supportano i dischi permanenti. Per ulteriori informazioni, consulta le serie di macchine disponibili.

Per dimostrare la migrazione da Persistent Disk a Hyperdisk, questo tutorial utilizza il database Sakila per fornire un set di dati di esempio. Sakila è un database di esempio fornito da MySQL che puoi utilizzare come schema per tutorial ed esempi. Rappresenta un negozio di noleggio di DVD fittizio e include tabelle per film, attori, clienti e noleggi.

Questa guida è destinata agli specialisti e agli amministratori dell'archiviazione che creano e allocano spazio di archiviazione e gestiscono la sicurezza e l'accesso ai dati. Per scoprire di più sui ruoli comuni e sulle attività di esempio a cui facciamo riferimento nei contenuti di Google Cloud , consulta Ruoli utente e attività comuni di GKE.

Architettura di deployment

Il seguente diagramma illustra la procedura di migrazione da un Persistent Disk a un Hyperdisk.

  • Un'applicazione MySQL viene eseguita su un pool di nodi GKE con tipi di macchina N2, memorizzando i dati su un disco permanente SSD.
  • Per garantire la coerenza dei dati, l'applicazione viene ridimensionata per impedire nuove scritture.
  • Viene creato uno snapshot del Persistent Disk, che funge da backup point-in-time completo dei dati.
  • Viene eseguito il provisioning di un nuovo Hyperdisk dallo snapshot e viene eseguito il deployment di una nuova istanza MySQL su un pool di nodi N4 separato e compatibile con Hyperdisk. Questa nuova istanza viene collegata all'Hyperdisk appena creato, completando la migrazione all'archiviazione con prestazioni più elevate.
Diagramma dell'architettura che mostra la migrazione dei dati MySQL dal Persistent Disk a Hyperdisk utilizzando uno snapshot.
Figura 1: migrazione dei dati MySQL da Persistent Disk a Hyperdisk utilizzando uno snapshot.

Prepara l'ambiente

  1. In Cloud Shell, imposta le variabili di ambiente per il progetto, la località e il prefisso del cluster.

    export PROJECT_ID=PROJECT_ID
export EMAIL_ADDRESS=EMAIL_ADDRESS
export KUBERNETES_CLUSTER_PREFIX=offline-hyperdisk-migration
export LOCATION=us-central1-a

    Sostituisci quanto segue:

    • PROJECT_ID: il tuo Google Cloud ID progetto.
    • EMAIL_ADDRESS: il tuo indirizzo email.
    • LOCATION: la zona in cui vuoi creare le risorse di deployment. Ai fini di questo tutorial, utilizza la zona us-central1-a.

  2. Clona il repository del codice campione da GitHub:

    git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples

  3. Vai alla directory offline-hyperdisk-migration per iniziare a creare risorse di deployment:

    cd kubernetes-engine-samples/databases/offline-hyperdisk-migration

Crea il cluster GKE e i node pool

Questo tutorial utilizza un cluster a livello di zona per semplicità, perché i volumi Hyperdisk sono risorse a livello di zona e sono accessibili solo all'interno di una singola zona.

  1. Crea un cluster GKE di zona:

    gcloud container clusters create ${KUBERNETES_CLUSTER_PREFIX}-cluster \
    --location ${LOCATION} \
    --node-locations ${LOCATION} \
    --shielded-secure-boot \
    --shielded-integrity-monitoring \
    --machine-type "e2-micro" \
    --num-nodes "1"

  2. Aggiungi un pool di nodi con un tipo di macchina N2 per il deployment iniziale di MySQL:

    gcloud container node-pools create regular-pool \
    --cluster ${KUBERNETES_CLUSTER_PREFIX}-cluster \
    --machine-type n2-standard-4 \
    --location ${LOCATION} \
    --num-nodes 1

  3. Aggiungi un pool di nodi con un tipo di macchina N4 su Hyperdisk in cui verrà eseguita la migrazione e l'esecuzione del deployment di MySQL:

    gcloud container node-pools create hyperdisk-pool \
    --cluster ${KUBERNETES_CLUSTER_PREFIX}-cluster \
    --machine-type n4-standard-4 \
    --location ${LOCATION} \
    --num-nodes 1

  4. Connettiti al cluster:

    gcloud container clusters get-credentials ${KUBERNETES_CLUSTER_PREFIX}-cluster --location ${LOCATION}

Esegui il deployment di MySQL sul Persistent Disk

In questa sezione, esegui il deployment di un'istanza MySQL che utilizza un Persistent Disk per l'archiviazione e caricala con dati di esempio.

  1. Crea e applica un StorageClass per Hyperdisk. Questo StorageClass verrà utilizzato più avanti nel tutorial.

    apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: balanced-storage
provisioner: pd.csi.storage.gke.io
volumeBindingMode: WaitForFirstConsumer
allowVolumeExpansion: true
parameters:
  type: hyperdisk-balanced
  provisioned-throughput-on-create: "250Mi"
  provisioned-iops-on-create: "7000"
     
    kubectl apply -f manifests/01-storage-class/storage-class-hdb.yaml

  2. Crea ed esegui il deployment di un'istanza MySQL che includa l'affinità dei nodi per garantire che i pod vengano pianificati sui nodi regular-pool e che venga eseguito il provisioning di un volume SSD del disco permanente.

    apiVersion: v1
kind: Service
metadata:
  name: regular-mysql
  labels:
    app: mysql
spec:
  ports:
    - port: 3306
  selector:
    app: mysql
  clusterIP: None
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mysql-pv-claim
  labels:
    app: mysql
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 30Gi
  storageClassName: premium-rwo
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: existing-mysql
  labels:
    app: mysql
spec:
  selector:
    matchLabels:
      app: mysql
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: mysql
    spec:
      containers:
      - image: mysql:8.0
        name: mysql
        env:
        - name: MYSQL_ROOT_PASSWORD
          value: migration
        - name: MYSQL_DATABASE
          value: mysql
        - name: MYSQL_USER
          value: app
        - name: MYSQL_PASSWORD
          value: migration
        ports:
        - containerPort: 3306
          name: mysql
        volumeMounts:
        - name: mysql-persistent-storage
          mountPath: /var/lib/mysql
      affinity: 
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            preference:
              matchExpressions:
              - key: "node.kubernetes.io/instance-type"
                operator: In
                values:
                - "n2-standard-4"
      volumes:
      - name: mysql-persistent-storage
        persistentVolumeClaim:
          claimName: mysql-pv-claim
     
    kubectl apply -f manifests/02-mysql/mysql-deployment.yaml

    Questo manifest crea un deployment e un servizio MySQL, con un Persistent Disk di cui viene eseguito il provisioning dinamico per l'archiviazione dei dati. La password per l'utente root è migration.

  3. Esegui il deployment di un pod client MySQL per caricare i dati e verificare la migrazione dei dati:

    apiVersion: v1
kind: Pod
metadata:
  name: mysql-client
spec:
  containers:
  - name: main
    image: mysql:8.0
    command: ["sleep", "360000"]
    resources:
      requests:
        memory: 1Gi
        cpu: 500m
      limits:
        memory: 1Gi
        cpu: "1"
    env:
    - name: MYSQL_ROOT_PASSWORD
      value: migration
     
    kubectl apply -f manifests/02-mysql/mysql-client.yaml
kubectl wait pods mysql-client --for condition=Ready --timeout=300s

  4. Connettiti al pod client:

    kubectl exec -it mysql-client -- bash

  5. Dalla shell del pod client, scarica e importa il set di dati di esempio Sakila:

    # Download the dataset
curl --output dataset.tgz "https://downloads.mysql.com/docs/sakila-db.tar.gz"

# Extract the dataset
tar -xvzf dataset.tgz -C /home/mysql

# Import the dataset into MySQL (the password is "migration").
mysql -u root -h regular-mysql.default -p
    SOURCE /sakila-db/sakila-schema.sql;
    SOURCE /sakila-db/sakila-data.sql;

  6. Verifica che i dati siano stati importati:

    USE sakila;
SELECT      table_name,      table_rows  FROM      INFORMATION_SCHEMA.TABLES  WHERE TABLE_SCHEMA = 'sakila';

    L'output mostra un elenco di tabelle con il conteggio delle righe.

    | TABLE_NAME                 | TABLE_ROWS |
+----------------------------+------------+
| actor                      |        200 |
| actor_info                 |       NULL |
| address                    |        603 |
| category                   |         16 |
| city                       |        600 |
| country                    |        109 |
| customer                   |        599 |
| customer_list              |       NULL |
| film                       |       1000 |
| film_actor                 |       5462 |
| film_category              |       1000 |
| film_list                  |       NULL |
| film_text                  |       1000 |
| inventory                  |       4581 |
| language                   |          6 |
| nicer_but_slower_film_list |       NULL |
| payment                    |      16086 |
| rental                     |      16419 |
| sales_by_film_category     |       NULL |
| sales_by_store             |       NULL |
| staff                      |          2 |
| staff_list                 |       NULL |
| store                      |          2 |
+----------------------------+------------+
23 rows in set (0.01 sec)

  7. Esci dalla sessione mysql:

    exit;

  8. Esci dalla shell del pod client:

    exit

  9. Recupera il nome del PersistentVolume (PV) creato per MySQL e archivialo in una variabile di ambiente:

    export PV_NAME=$(kubectl get pvc mysql-pv-claim -o jsonpath='{.spec.volumeName}')

Esegui la migrazione dei dati a un volume Hyperdisk

Ora hai un workload MySQL con dati archiviati su un volume SSD Persistent Disk. Questa sezione descrive come eseguire la migrazione di questi dati a un volume Hyperdisk utilizzando uno snapshot. Questo approccio di migrazione conserva anche il volume Persistent Disk originale, il che ti consente di eseguire il rollback all'utilizzo dell'istanza MySQL originale, se necessario.

  1. Anche se puoi creare snapshot dai dischi senza scollegarli dai carichi di lavoro, per garantire l'integrità dei dati per MySQL devi interrompere qualsiasi nuova scrittura sul disco durante la creazione dello snapshot. Ridimensiona il deployment MySQL a 0 repliche per interrompere le scritture:

    kubectl scale deployment regular-mysql --replicas=0

  2. Crea uno snapshot dal Persistent Disk esistente:

    gcloud compute disks snapshot ${PV_NAME} --location=${LOCATION} --snapshot-name=original-snapshot --description="snapshot taken from pd-ssd"

  3. Crea un nuovo volume Hyperdisk denominato mysql-recovery dallo snapshot:

    gcloud compute disks create mysql-recovery --project=${PROJECT_ID} \
    --type=hyperdisk-balanced \
    --size=150GB --location=${LOCATION} \
    --source-snapshot=projects/${PROJECT_ID}/global/snapshots/original-snapshot

  4. Aggiorna il file manifest per il PV ripristinato con l'ID progetto:

    apiVersion: v1
kind: PersistentVolume
metadata:
  name: backup
spec:
  storageClassName: balanced-storage
  capacity:
    storage: 150G
  accessModes:
    - ReadWriteOnce
  claimRef:
    name: hyperdisk-recovery
    namespace: default
  csi:
    driver: pd.csi.storage.gke.io
    volumeHandle: projects/PRJCTID/zones/us-central1-a/disks/mysql-recovery
    fsType: ext4
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  namespace: default
  name: hyperdisk-recovery
spec:
  storageClassName: balanced-storage
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 150G
     
    sed -i "s/PRJCTID/$PROJECT_ID/g" manifests/02-mysql/restore_pv.yaml

  5. Crea PersistentVolume (PVC) e PersistentVolumeClaim dal nuovo Hyperdisk:

    kubectl apply -f manifests/02-mysql/restore_pv.yaml

Verificare la migrazione dei dati

Esegui il deployment di una nuova istanza MySQL che utilizza il volume Hyperdisk appena creato. Questo pod verrà pianificato sul pool di nodi hyperdisk-pool, che è costituito da nodi N4.

  1. Esegui il deployment della nuova istanza MySQL:

    apiVersion: v1
kind: Service
metadata:
  name: recovered-mysql
  labels:
    app: new-mysql
spec:
  ports:
    - port: 3306
  selector:
    app: new-mysql
  clusterIP: None
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: new-mysql
  labels:
    app: new-mysql
spec:
  selector:
    matchLabels:
      app: new-mysql
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: new-mysql
    spec:
      containers:
      - image: mysql:8.0
        name: mysql
        env:
        - name: MYSQL_ROOT_PASSWORD
          value: migration
        - name: MYSQL_DATABASE
          value: mysql
        - name: MYSQL_USER
          value: app
        - name: MYSQL_PASSWORD
          value: migration
        ports:
        - containerPort: 3306
          name: mysql
        volumeMounts:
        - name: mysql-persistent-storage
          mountPath: /var/lib/mysql
      affinity: 
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            preference:
              matchExpressions:
              - key: "cloud.google.com/gke-nodepool"
                operator: In
                values:
                - "hyperdisk-pool"      
      volumes:
      - name: mysql-persistent-storage
        persistentVolumeClaim:
          claimName: hyperdisk-recovery
     
    kubectl apply -f manifests/02-mysql/recovery_mysql_deployment.yaml

  2. Per verificare l'integrità dei dati, connettiti di nuovo al pod client MySQL:

    kubectl exec -it mysql-client -- bash

  3. All'interno del pod client, connettiti al nuovo database MySQL (recovered-mysql.default) e verifica i dati. La password è migration.

    mysql -u root -h recovered-mysql.default -p
USE sakila;
SELECT table_name, table_rows FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = 'sakila';

    I dati devono essere gli stessi dell'istanza MySQL originale sul volume Persistent Disk.

  4. Esci dalla sessione mysql:

    exit;

  5. Esci dalla shell del pod client:

    exit