En este instructivo, se muestra cómo migrar tus datos existentes de MySQL de un disco persistente (PD) a Hyperdisk en Google Kubernetes Engine para mejorar el rendimiento del almacenamiento. Hyperdisk ofrece más IOPS y capacidad de procesamiento que Persistent Disk, lo que puede mejorar el rendimiento de MySQL al reducir la latencia de las consultas y transacciones de la base de datos. Puedes usar instantáneas de disco para migrar tus datos a diferentes tipos de discos según la compatibilidad del tipo de máquina. Por ejemplo, los volúmenes de Hyperdisk solo son compatibles con algunos tipos de máquinas de tercera, cuarta y generaciones posteriores, como N4, que no admiten discos persistentes. Para obtener más información, consulta las series de máquinas disponibles.
Para demostrar la migración de Persistent Disk a Hyperdisk, en este instructivo, se usa la base de datos Sakila para proporcionar un conjunto de datos de muestra. Sakila es una base de datos de muestra proporcionada por MySQL que puedes usar como esquema para instructivos y ejemplos. Representa una tienda de alquiler de DVD ficticia y contiene tablas para películas, actores, clientes y alquileres.
Esta guía está dirigida a los especialistas y administradores de almacenamiento que crean y asignan almacenamiento, y administran la seguridad y el acceso a los datos. Para obtener más información sobre los roles comunes y las tareas de ejemplo a las que hacemos referencia en el contenido de Google Cloud , consulta Roles de usuario y tareas comunes de GKE.
Arquitectura de implementación
En el siguiente diagrama, se ilustra el proceso de migración de un Persistent Disk a un Hyperdisk.
- Una aplicación de MySQL se ejecuta en un grupo de nodos de GKE con tipos de máquinas N2 y almacena sus datos en un SSD de disco persistente.
- Para garantizar la coherencia de los datos, la aplicación se reduce para evitar nuevas escrituras.
- Se crea una instantánea del Persistent Disk, que sirve como copia de seguridad completa de los datos en un momento determinado.
- Se aprovisiona un nuevo Hyperdisk a partir de la instantánea y se implementa una nueva instancia de MySQL en un grupo de nodos N4 independiente y compatible con Hyperdisk. Esta nueva instancia se conecta al Hyperdisk recién creado, lo que finaliza la migración al almacenamiento de mayor rendimiento.
Prepare el entorno
En Cloud Shell, configura las variables de entorno para tu proyecto, ubicación y prefijo del clúster.
export PROJECT_ID=PROJECT_ID export EMAIL_ADDRESS=EMAIL_ADDRESS export KUBERNETES_CLUSTER_PREFIX=offline-hyperdisk-migration export LOCATION=us-central1-a
Reemplaza lo siguiente:
PROJECT_ID
: El Google Cloud ID del proyecto.EMAIL_ADDRESS
: el dirección de correo electrónicoLOCATION
: Es la zona en la que deseas crear los recursos de implementación. Para los fines de este instructivo, usa la zonaus-central1-a
.
Clona el repositorio de código de muestra de GitHub:
git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
Navega al directorio
offline-hyperdisk-migration
para comenzar a crear recursos de implementación:cd kubernetes-engine-samples/databases/offline-hyperdisk-migration
Crea el clúster de GKE y los grupos de nodos
En este instructivo, se usa un clúster zonal para simplificar el proceso, ya que los volúmenes de Hyperdisk son recursos zonales y solo se puede acceder a ellos dentro de una sola zona.
Crea un clúster de GKE zonal:
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"
Agrega un grupo de nodos con un tipo de máquina N2 para la implementación inicial de MySQL:
gcloud container node-pools create regular-pool \ --cluster ${KUBERNETES_CLUSTER_PREFIX}-cluster \ --machine-type n2-standard-4 \ --location ${LOCATION} \ --num-nodes 1
Agrega un grupo de nodos con un tipo de máquina N4 en Hyperdisk donde se migrará y ejecutará la implementación de MySQL:
gcloud container node-pools create hyperdisk-pool \ --cluster ${KUBERNETES_CLUSTER_PREFIX}-cluster \ --machine-type n4-standard-4 \ --location ${LOCATION} \ --num-nodes 1
Conéctese al clúster:
gcloud container clusters get-credentials ${KUBERNETES_CLUSTER_PREFIX}-cluster --location ${LOCATION}
Implementa MySQL en Persistent Disk
En esta sección, implementarás una instancia de MySQL que usa un Persistent Disk para el almacenamiento y la cargarás con datos de muestra.
Crea y aplica un objeto
StorageClass
para Hyperdisk. EsteStorageClass
se usará más adelante en el instructivo.kubectl apply -f manifests/01-storage-class/storage-class-hdb.yaml
Crea e implementa una instancia de MySQL que incluya afinidad de nodos para garantizar que los Pods se programen en nodos
regular-pool
y aprovisione un volumen de SSD de disco persistente.kubectl apply -f manifests/02-mysql/mysql-deployment.yaml
Este manifiesto crea una implementación y un servicio de MySQL, con un Persistent Disk aprovisionado de forma dinámica para el almacenamiento de datos. La contraseña del usuario
root
esmigration
.Implementa un Pod de cliente de MySQL para cargar datos y verificar la migración de datos:
kubectl apply -f manifests/02-mysql/mysql-client.yaml kubectl wait pods mysql-client --for condition=Ready --timeout=300s
Conéctate al Pod cliente:
kubectl exec -it mysql-client -- bash
Desde el shell del Pod del cliente, descarga e importa el conjunto de datos de muestra de 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;
Verifica que los datos se hayan importado:
USE sakila; SELECT table_name, table_rows FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = 'sakila';
El resultado muestra una lista de tablas con recuentos de filas.
| 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)
Sal de la sesión de
mysql
:exit;
Sal de la shell del Pod del cliente:
exit
Obtén el nombre del PersistentVolume (PV) creado para MySQL y almacénalo en una variable de entorno:
export PV_NAME=$(kubectl get pvc mysql-pv-claim -o jsonpath='{.spec.volumeName}')
Migra los datos a un volumen de Hyperdisk
Ahora tienes una carga de trabajo de MySQL con datos almacenados en un volumen de SSD de disco persistente. En esta sección, se describe cómo migrar estos datos a un volumen de Hyperdisk con una instantánea. Este enfoque de migración también conserva el volumen original del Persistent Disk, lo que te permite revertir el uso de la instancia original de MySQL si es necesario.
Si bien puedes crear instantáneas de los discos sin desconectarlos de las cargas de trabajo, para garantizar la integridad de los datos de MySQL, debes detener cualquier operación de escritura nueva en el disco durante la creación de la instantánea. Reduce la escala de la implementación de MySQL a
0
réplicas para detener las escrituras:kubectl scale deployment regular-mysql --replicas=0
Crea una instantánea a partir del Persistent Disk existente:
gcloud compute disks snapshot ${PV_NAME} --location=${LOCATION} --snapshot-name=original-snapshot --description="snapshot taken from pd-ssd"
Crea un volumen de Hyperdisk nuevo llamado
mysql-recovery
a partir de la instantánea: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
Actualiza el archivo de manifiesto del PV restablecido con el ID de tu proyecto:
sed -i "s/PRJCTID/$PROJECT_ID/g" manifests/02-mysql/restore_pv.yaml
Crea el PersistentVolume (PV) y el PersistentVolumeClaim a partir del nuevo Hyperdisk:
kubectl apply -f manifests/02-mysql/restore_pv.yaml
Verifica la migración de datos
Implementa una instancia de MySQL nueva que use el volumen de Hyperdisk recién creado. Este Pod se programará en el grupo de nodos hyperdisk-pool
, que consta de nodos N4.
Implementa la nueva instancia de MySQL:
kubectl apply -f manifests/02-mysql/recovery_mysql_deployment.yaml
Para verificar la integridad de los datos, vuelve a conectarte al Pod del cliente de MySQL:
kubectl exec -it mysql-client -- bash
Dentro del Pod de cliente, conéctate a la nueva base de datos de MySQL (
recovered-mysql.default
) y verifica los datos. La contraseña esmigration
.mysql -u root -h recovered-mysql.default -p USE sakila; SELECT table_name, table_rows FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = 'sakila';
Los datos deben ser los mismos que en tu instancia original de MySQL en el Persistent Disk persistente.
Sal de la sesión de
mysql
:exit;
Sal de la shell del Pod del cliente:
exit