Cloner une base de données MySQL sur Compute Engine

Last reviewed 2019-10-08 UTC

Ce tutoriel présente deux méthodes pour cloner une base de données MySQL exécutée sur Compute Engine. L'une d'entre elles consiste à utiliser des instantanés de disque persistant. L'autre méthode utilise l'exportation et l'importation natives MySQL en transférant le fichier d'exportation à l'aide de Cloud Storage. Cloud Storage est le service de stockage d'objets Google Cloud. Il offre un moyen simple, sécurisé, durable et hautement disponible de stocker des fichiers.

Le clonage consiste à copier une base de données sur un autre serveur. La copie est indépendante de la base de données source et est conservée en tant qu'instantané à un moment précis. Vous pouvez utiliser une base de données clonée à des fins diverses sans charger le serveur de production ou nuire à l'intégrité des données de production. Voici certains objectifs de ce processus :

Effectuer des requêtes analytiques
Effectuer des tests de charge ou d'intégration sur vos applications
Extraire des données pour remplir des entrepôts de données
Effectuer des tests sur les données

Chaque méthode de clonage décrite dans ce tutoriel présente des avantages et des inconvénients. La méthode la plus adaptée dépend de votre situation. Le tableau suivant met en évidence certains problèmes clés.

Problème	Méthode 1 : instantanés de disque	Méthode 2 : exportation et importation à l'aide de Cloud Storage
Espace disque supplémentaire requis pour les instances MySQL	Aucun espace disque supplémentaire requis	Espace supplémentaire requis pour le stockage du fichier d'exportation lors de la création et de la restauration
Charge supplémentaire sur les instances MySQL sources lors du clonage	Aucune charge supplémentaire	Charge supplémentaire sur le processeur et les E/S lors de la création et de l'importation du fichier d'exportation
Durée du clonage	Relativement rapide pour les bases de données volumineuses	Relativement lent pour les bases de données volumineuses
Clonage possible à partir d'instances MySQL externes à Google Cloud	Non	Oui
Complexité	Séquence complexe de commandes pour installer des disques clonés	Ensemble de commandes relativement simples pour le clonage
Possibilité d'exploiter des systèmes de sauvegarde existants	Oui, si le système de sauvegarde utilise des instantanés de disque Google Cloud	Oui, si le système de sauvegarde exporte des fichiers vers Cloud Storage
Précision du clonage	Ne peut cloner que des disques entiers	Ne peut cloner que la base de données spécifiée
Cohérence des données	Cohérence au moment de l'instantané	Cohérence au moment de l'exportation
Possibilité d'utiliser Cloud SQL comme source	Non	Oui, si la même version est utilisée
Possibilité d'utiliser Cloud SQL comme destination	Non	Oui

Dans ce tutoriel, nous partons du principe que vous connaissez la ligne de commande Linux et l'administration des bases de données MySQL.

Objectifs

Découvrez comment exécuter une base de données MySQL sur Google Cloud.
Apprendre à créer une base de données de démonstration sur un disque secondaire
Découvrez comment cloner une base de données MySQL à l'aide d'instantanés de disque Compute Engine.
Découvrez comment cloner une base de données MySQL en transférant un fichier d'exportation à l'aide de Cloud Storage.
Découvrez comment cloner une base de données MySQL vers Cloud SQL en transférant un fichier d'exportation à l'aide de Cloud Storage.

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Activez l'API Compute Engine.

Activer l'API

Configurer l'environnement

Pour suivre ce tutoriel, vous devez configurer votre environnement informatique avec les éléments suivants :

Une instance MySQL sur Compute Engine (nommée mysql-prod) pour représenter votre serveur de base de données de production.
Un disque supplémentaire (nommé mysql-prod-data) associé à votre serveur de production pour stocker votre base de données de production.
Une copie de la base de données Employees importée dans mysql-prod pour simuler la base de données de production que vous souhaitez cloner.
Une instance MySQL sur Compute Engine (nommée mysql-test) pour représenter votre serveur de base de données de test. Vous clonez votre base de données sur ce serveur.

Cette architecture est décrite dans le schéma suivant.

Schéma illustrant la configuration du clonage d'une base de données MySQL dans ce tutoriel.

Créer l'instance de VM de production

Pour simuler un environnement de production, vous devez configurer une instance de VM Compute Engine exécutant MySQL sur Debian Linux.

L'instance de VM de ce tutoriel utilise deux disques : un disque de 50 Go pour le système d'exploitation et les comptes utilisateur, et un disque de 100 Go pour le stockage de la base de données.

Dans Compute Engine, l'utilisation de disques distincts n'offre aucun avantage en termes de performances. Les performances des disques sont déterminées par la capacité de stockage totale de tous les disques installés sur une instance et par le nombre total de processeurs virtuels sur votre instance de VM. Par conséquent, la base de données et le fichier journal peuvent résider sur le même disque.

Ouvrez Cloud Shell.

Ouvrir Cloud Shell

Définissez la zone de votre choix :

ZONE=us-east1-b
REGION=us-east1
gcloud config set compute/zone "${ZONE}"

Créez une instance Compute Engine :
```
gcloud compute instances create mysql-prod \
    --machine-type=n1-standard-2 \
    --scopes=cloud-platform \
    --boot-disk-size=50GB \
    --boot-disk-device-name=mysql-prod \
    --create-disk="mode=rw,size=100,type=pd-standard,name=mysql-prod-data,device-name=mysql-prod-data"
```
Cette commande accorde à l'instance un accès complet aux API Google Cloud, crée un disque secondaire de 100 Go et installe le disque sur l'instance. Ignorez l'avertissement sur les performances du disque, car vous n'avez pas besoin de performances élevées pour ce tutoriel.

Configurer le disque supplémentaire

Le deuxième disque installé sur l'instance de production sert à stocker votre base de données de production. Ce disque est vide. Vous devez donc le partitionner, le formater et l'installer.

Dans Google Cloud Console, accédez à la page Instances de VM.

Accéder à la page "Instances de VM"
Assurez-vous qu'une coche verte s'affiche à côté du nom de votre instance mysql-prod, indiquant que l'instance est prête.
Cliquez sur le bouton SSH à côté de l'instance mysql-prod. Le navigateur ouvre une connexion de terminal vers l'instance.
Dans la fenêtre du terminal, affichez la liste des disques installés sur votre instance :
```
lsblk
```
Le résultat est le suivant :
```
NAME   MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
sda      8:0    0   50G  0 disk
└─sda1   8:1    0   50G  0 part /
sdb      8:16   0  100G  0 disk
```
Le disque nommé sdb (100 Go) est votre disque de données.

Formatez le disque sdb et créez une partition unique avec un système de fichiers ext4 :

sudo mkfs.ext4 -m 0 -F -E lazy_itable_init=0,lazy_journal_init=0,discard \
    /dev/sdb

Créez le répertoire de données MySQL servant de point d'installation au disque de données :
```
sudo mkdir -p /var/lib/mysql
```
Pour installer automatiquement le disque au point d'installation que vous avez créé, ajoutez une entrée dans le fichier /etc/fstab :
```
echo "UUID=`sudo blkid -s UUID -o value /dev/sdb` /var/lib/mysql ext4 discard,defaults,nofail 0 2" \
   | sudo tee -a /etc/fstab
```
Installez le disque :
```
sudo mount -av
```
Supprimez tous les fichiers du disque de données afin que MySQL puisse l'utiliser en tant que répertoire de données :
```
sudo rm -rf /var/lib/mysql/*
```

Installer le serveur MySQL

Vous devez télécharger et installer MySQL Community Edition. Le répertoire de données MySQL est créé sur le disque supplémentaire.

Dans la session SSH connectée à l'instance mysql-prod, téléchargez et installez le package de configuration MySQL :
```
wget http://repo.mysql.com/mysql-apt-config_0.8.13-1_all.deb
sudo dpkg -i mysql-apt-config_0.8.13-1_all.deb
```
Lorsque vous y êtes invité, sélectionnez l'option Serveur et cluster MySQL, puis sélectionnez mysql-5.7.
Dans la liste, sélectionnez l'option OK pour terminer la configuration du package.

Actualisez le cache du dépôt et installez les packages mysql-community :

sudo apt-get update
sudo apt-get install -y mysql-community-server mysql-community-client

Lorsque vous êtes averti que le répertoire de données existe déjà, sélectionnez OK.
Lorsque vous êtes invité à fournir un mot de passe racine, créez et saisissez un mot de passe. Notez le mot de passe ou stockez-le temporairement dans un endroit sûr.

Télécharger et installer l'exemple de base de données

Dans la session SSH connectée à l'instance mysql-prod, installez git :
```
sudo apt-get install -y git
```
Clonez le dépôt GitHub contenant les scripts de la base de données Employees :
```
git clone https://github.com/datacharmer/test_db.git
```
Remplacez le répertoire par celui du script de la base de données Employees :
```
cd test_db
```
Exécutez le script de création de la base de données Employees :
```
mysql -u root -p -q < employees.sql
```
Lorsque vous y êtes invité, saisissez le mot de passe racine que vous avez créé précédemment.
Pour vérifier que l'exemple de base de données fonctionne, vous pouvez exécuter une requête qui compte le nombre de lignes dans la table employees :
```
mysql -u root -p -e "select count(*) from employees.employees;"
```
Lorsque vous y êtes invité, saisissez le mot de passe racine que vous avez créé précédemment.

Le résultat est le suivant :
```
+----------+
| count(*) |
+----------+
|   300024 |
+----------+
```

Créer l'instance de VM de test

Dans cette section, vous allez créer une instance de VM MySQL nommée mysql-test comme destination de la base de données clonée. La configuration de cette instance est identique à celle de l'instance de production. Cependant, vous n'allez pas créer de deuxième disque de données. À la place, vous allez installer le disque de données comme décrit plus loin dans ce tutoriel.

Ouvrez Cloud Shell.

Ouvrir Cloud Shell
Créez l'instance MySQL de test :
```
gcloud compute instances create mysql-test \
  --machine-type=n1-standard-2 \
  --scopes=cloud-platform \
  --boot-disk-size=50GB \
  --boot-disk-device-name=mysql-test
```
Vous pouvez ignorer l'avertissement sur les performances du disque, car vous n'avez pas besoin de performances élevées pour ce tutoriel.

Installer le serveur MySQL sur l'instance de VM de test

Vous devez également télécharger et installer MySQL Community Edition sur l'instance de VM mysql-test.

Dans la session SSH connectée à l'instance mysql-test, téléchargez et installez le package de configuration MySQL :
```
wget http://repo.mysql.com/mysql-apt-config_0.8.13-1_all.deb
sudo dpkg -i mysql-apt-config_0.8.13-1_all.deb
```
Lorsque vous y êtes invité, sélectionnez l'option Serveur et cluster MySQL, puis sélectionnez mysql-5.7.
Dans la liste, sélectionnez l'option OK pour terminer la configuration du package.

Actualisez le cache du dépôt et installez les packages mysql-community :

sudo apt-get update
sudo apt-get install -y mysql-community-server mysql-community-client

Lorsque vous êtes invité à fournir un mot de passe racine, créez et saisissez un mot de passe. Notez le mot de passe ou stockez-le temporairement dans un endroit sûr.

Cloner la base de données à l'aide d'instantanés de disque Compute Engine

L'une des méthodes pour cloner une base de données MySQL exécutée sur Compute Engine consiste à stocker la base de données sur un disque de données distinct et à utiliser des instantanés de disque persistant pour créer un clone de ce disque.

Les instantanés de disque persistant vous permettent d'obtenir une copie des données sur disque à un moment précis. La programmation des instantanés de disque permet de sauvegarder automatiquement vos données.

Dans cette section du tutoriel, vous allez :

réaliser un instantané du disque de données du serveur de production ;
créer un disque à partir de l'instantané ;
Installer le nouveau disque sur le serveur de test
Redémarrer le serveur MySQL sur l'instance de test de sorte que le serveur utilise le nouveau disque comme disque de données

Le schéma suivant montre comment une base de données est clonée à l'aide d'instantanés de disque.

Schéma illustrant la configuration du clonage d'une base de données MySQL à l'aide d'instantanés de disque.

Créer l'instantané de disque

Ouvrez Cloud Shell.

Ouvrir Cloud Shell
Créez un instantané de votre disque de données dans la même zone que l'instance de VM :
```
gcloud compute disks snapshot mysql-prod-data \
     --snapshot-names=mysql-prod-data-snapshot \
     --zone="${ZONE}"
```
Au bout de quelques minutes, votre instantané est créé.

Installer l'instantané de disque sur l'instance de test

Vous devez créer un disque de données à partir de l'instantané que vous avez créé, puis l'installer sur l'instance mysql-test.

Ouvrez Cloud Shell.

Ouvrir Cloud Shell

Créez un disque persistant en utilisant le contenu de l'instantané du disque de production :

gcloud beta compute disks create mysql-test-data \
     --size=100GB \
     --source-snapshot=mysql-prod-data-snapshot \
     --zone="${ZONE}"

Installez le nouveau disque sur votre instance mysql-test avec des autorisations de lecture/écriture :
```
gcloud compute instances attach-disk mysql-test \
    --disk=mysql-test-data --mode=rw
```

Installer le nouveau disque de données sous Linux

Pour utiliser le disque de données cloné en tant que répertoire de données MySQL, vous devez arrêter l'instance MySQL et installer le disque.

Dans la session SSH connectée à mysql-test, arrêtez le service MySQL :
```
sudo service mysql stop
```
Dans la fenêtre du terminal, affichez la liste des disques installés sur votre instance :
```
lsblk
```
Le résultat est le suivant :
```
NAME   MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
sda      8:0    0   50G  0 disk
└─sda1   8:1    0   50G  0 part /
sdb      8:16   0  100G  0 disk
```
Le disque nommé sdb (100 Go) est votre disque de données.
Installez le disque de données MySQL dans le répertoire de données MySQL :
```
sudo mount -o discard,defaults /dev/sdb /var/lib/mysql
```
L'installation de ce disque permet de masquer les fichiers de configuration et les espaces de table MySQL en les remplaçant par le contenu du disque.

Avec cette commande, le disque est temporairement installé et n'est pas réinstallé au démarrage du système. Si vous souhaitez installer le disque au démarrage du système, créez une entrée fstab. Pour en savoir plus, consultez la section Configurer le disque supplémentaire plus haut dans ce tutoriel.

Remarque : Dans ce tutoriel, les instances mysql-prod et mysql-test utilisent le même ID utilisateur Unix pour l'utilisateur mysql. Différents ID utilisateur peuvent être employés dans un environnement de production. Si les ID utilisateur sont différents, vous devez remplacer le propriétaire par mysql sur tous les fichiers et répertoires du disque de données en exécutant la commande suivante : chown -hR mysql.mysql /var/lib/mysql

Démarrer MySQL dans l'instance de test

Dans la session SSH connectée à mysql-test, démarrez le service MySQL :
```
sudo service mysql start
```
Pour vérifier que la base de données clonée fonctionne, exécutez une requête pour compter le nombre de lignes dans la table employees :
```
mysql -u root -p -e "select count(*) from employees.employees;"
```
Lorsque vous y êtes invité, saisissez le mot de passe racine du serveur de la base de données mysql-prod. Le mot de passe racine de l'instance de production est obligatoire, car l'intégralité du répertoire de données MySQL est un clone du répertoire de données de l'instance mysql-prod. Par conséquent, toutes les bases de données, ainsi que tous les utilisateurs de la base de données et leurs mots de passe sont copiés.
```
+----------+
| count(*) |
+----------+
|   300024 |
+----------+
```
Le nombre de lignes est identique à celui de l'instance mysql-prod.

Maintenant que vous savez comment cloner une base de données à l'aide d'instantanés de disque persistant, vous pouvez essayer de cloner une base de données en utilisant l'exportation et l'importation. Pour suivre le tutoriel de cette seconde approche, vous devez désinstaller le disque cloné.

Désinstaller le disque cloné

Pour désinstaller le disque cloné que vous avez créé à l'aide d'instantanés de disque, procédez comme suit :

Dans la session SSH connectée à votre instance mysql-test, arrêtez le service MySQL :
```
sudo service mysql stop
```
Désinstallez le disque de données cloné à partir du répertoire de données MySQL :
```
sudo umount /var/lib/mysql
```
Redémarrez le service MySQL :
```
sudo service mysql start
```

Cloner la base de données à l'aide de l'exportation et de l'importation

Une deuxième méthode pour cloner une base de données MySQL exécutée sur Compute Engine consiste à utiliser l'exportation (à l'aide de mysqldump) et l'importation natives MySQL. Avec cette approche, vous transférez le fichier d'exportation à l'aide de Cloud Storage.

Cette section du tutoriel utilise les ressources que vous avez créées dans la section Cloner la base de données à l'aide d'instantanés de disque Compute Engine. Si vous n'avez pas terminé cette section, vous devez le faire avant de continuer.

Dans cette section du tutoriel, vous allez :

créer un bucket Cloud Storage ;
exporter la base de données sur l'instance de production en l'écrivant dans Cloud Storage ;
importer le fichier d'exportation dans l'instance de test en le lisant à partir de Cloud Storage.

Le schéma suivant illustre comment cloner une base de données en transférant un fichier d'exportation à l'aide de Cloud Storage.

Schéma illustrant la configuration du clonage d'une base de données MySQL à l'aide de Cloud Storage.

Les systèmes en dehors de Google Cloud peuvent accéder à Cloud Storage. Vous pouvez donc utiliser cette méthode pour cloner des bases de données à partir d'instances MySQL externes.

Créer un bucket Cloud Storage

Vous devez créer un bucket Cloud Storage qui stocke les fichiers d'exportation pendant que vous les transférez de l'instance mysql-prod vers l'instance mysql-test.

Ouvrez Cloud Shell.

Ouvrir Cloud Shell

Créez un bucket Cloud Storage dans la même région que vos instances de VM :

gcloud storage buckets create "gs://$(gcloud config get-value project)-bucket" --location="${REGION}"

Exporter la base de données

Dans votre environnement de production, il est possible que vous puissiez déjà effectuer des sauvegardes à l'aide de fichiers d'exportation mysqldump. Vous pouvez utiliser ces sauvegardes comme base pour cloner votre base de données.

Dans ce tutoriel, vous allez créer un fichier d'exportation en utilisant mysqldump, ce qui n'a aucune incidence sur les programmations de sauvegarde complète ou incrémentielle existantes.

Dans la session SSH connectée à l'instance mysql-prod, exportez la base de données Employees en la transférant dans un objet Cloud Storage vers le bucket que vous avez créé précédemment :
```
mysqldump --user=root -p --default-character-set=utf8mb4 --add-drop-database --verbose  --hex_blob \
    --databases employees |\
     gcloud storage cp - "gs://$(gcloud config get-value project)-bucket/employees-dump.sql"
```
Lorsque vous y êtes invité, saisissez le mot de passe racine du serveur de base de données mysql-prod.

Vous utilisez le jeu de caractères utf8mb4 lors de l'exportation pour éviter tout problème d'encodage de caractères.

L'option --add-drop-database permet d'inclure les instructions DROP DATABASE et CREATE DATABASE dans l'exportation.

Importer le fichier exporté

Dans la session SSH connectée à l'instance mysql-test, transférez le fichier exporté de votre bucket Cloud Storage vers l'application de ligne de commande mysql :
```
gcloud storage cat "gs://$(gcloud config get-value project)-bucket/employees-dump.sql" |\
    mysql --user=root -p --default-character-set=utf8mb4
```
Lorsque vous y êtes invité, saisissez le mot de passe racine du serveur de base de données mysql-test.

Vous utilisez le jeu de caractères utf8mb4 lors de l'importation pour éviter tout problème d'encodage de caractères.
Pour vérifier que la base de données clonée fonctionne, exécutez une requête pour compter le nombre de lignes dans la table employees :
```
mysql -u root -p -e "select count(*) from employees.employees;"
```
Lorsque vous y êtes invité, saisissez le mot de passe racine du serveur de base de données mysql-test.
```
+----------+
| count(*) |
+----------+
|   300024 |
+----------+
```
Le nombre de lignes est identique à celui de l'instance mysql-prod.

Utiliser Cloud SQL comme destination de clonage

Si votre base de données de destination est hébergée sur Cloud SQL et que la base de données d'origine se trouve sur Compute Engine, le seul mécanisme compatible pour le clonage consiste à exporter la base de données vers Cloud Storage, puis à l'importer dans Cloud SQL.

Comme expliqué dans la documentation de Cloud SQL, Cloud SQL ne peut importer le fichier exporté que s'il ne contient aucun déclencheur, ni aucune procédure stockée, vue ou fonction.

Si votre base de données repose sur l'un de ces éléments, vous devez les exclure de l'exportation à l'aide des arguments de ligne de commande --skip-triggers et --ignore-table [VIEW_NAME], puis les recréer manuellement après l'importation.

Créer une instance Cloud SQL pour MySQL

Ouvrez Cloud Shell.

Ouvrir Cloud Shell
Créez une instance Cloud SQL pour MySQL exécutant la même version de base de données que votre instance mysql-prod :
```
gcloud sql instances create mysql-cloudsql \
    --tier=db-n1-standard-2 --region=${REGION} --database-version MYSQL_5_7
```
Après quelques minutes, votre base de données Cloud SQL est créée.
Réinitialisez le mot de passe utilisateur racine en saisissant une valeur connue :
```
gcloud sql users set-password root \
    --host=% --instance=mysql-cloudsql  --prompt-for-password
```
Lorsque vous êtes invité à fournir un mot de passe racine, créez et saisissez un mot de passe. Notez le mot de passe ou stockez-le temporairement dans un endroit sûr.

Exporter la base de données

Pour exporter la base de données dans un format adapté à l'importation dans Cloud SQL, vous devez exclure toutes les vues de la base de données.

Dans la session SSH connectée à l'instance mysql-prod, définissez une variable d'environnement contenant un ensemble d'arguments de ligne de commande pour la commande mysqldump afin qu'elle ignore les vues de la base de données Employees :
```
DATABASE_NAME=employees
IGNORE_TABLES_ARGS="`mysql -u root -p -s -s -e \"
    SELECT CONCAT('--ignore-table ${DATABASE_NAME}.',TABLE_NAME)
    FROM information_schema.TABLES
    WHERE TABLE_TYPE LIKE 'VIEW' AND TABLE_SCHEMA = '${DATABASE_NAME}';
    \"`"
```
Lorsque vous y êtes invité, saisissez le mot de passe racine du serveur de base de données mysql-prod.

Affichez le contenu des variables pour vérifier qu'elles ont été définies correctement :

echo "${IGNORE_TABLES_ARGS}"

--ignore-table employees.current_dept_emp
--ignore-table employees.dept_emp_latest_date

Exportez la base de données Employees, à l'exclusion des déclencheurs et des vues, en la transférant directement dans un objet Cloud Storage du bucket que vous avez créé précédemment :

mysqldump --user=root -p --default-character-set=utf8mb4 --add-drop-database --verbose \
    --hex-blob --skip-triggers --set-gtid-purged=OFF \
    $IGNORE_TABLES_ARGS \
    --databases employees |\
    gcloud storage cp - "gs://$(gcloud config get-value project)-bucket/employees-cloudsql-import.sql"

Lorsque vous y êtes invité, saisissez le mot de passe racine du serveur de base de données mysql-prod.

Mettre à jour les autorisations des objets

Vous devez définir les autorisations appropriées à la fois sur le bucket Cloud Storage et sur l'objet d'exportation pour que le compte de service Cloud SQL puisse les lire. Ces autorisations sont définies automatiquement lorsque vous utilisez la console Google Cloud pour importer l'objet. Vous pouvez également les définir à l'aide des commandes gcloud.

Ouvrez Cloud Shell.

Ouvrir Cloud Shell
Définissez une variable d'environnement contenant l'adresse du compte de service de votre instance Cloud SQL :
```
CLOUDSQL_SA="$(gcloud sql instances describe mysql-cloudsql --format='get(serviceAccountEmailAddress)')"
```

Ajoutez le compte de service à la stratégie IAM du bucket en tant que lecteur et rédacteur :

gcloud storage buckets add-iam-policy-binding "gs://$(gcloud config get-value project)-bucket/" \
    --member=user:"${CLOUDSQL_SA}" --role=roles/storage.objectUser

Importer la base de données exportée

Ouvrez Cloud Shell.

Ouvrir Cloud Shell

Importez le fichier exporté dans votre instance Cloud SQL :

gcloud sql import sql mysql-cloudsql \
    "gs://$(gcloud config get-value project)-bucket/employees-cloudsql-import.sql"

Lorsque vous y êtes invité, saisissez y.

Pour vérifier que la base de données clonée fonctionne, exécutez une requête pour compter le nombre de lignes dans la table employees :
```
echo "select count(*) from employees.employees;" |\
    gcloud sql connect mysql-cloudsql --user=root
```
Lorsque vous y êtes invité, saisissez le mot de passe racine du serveur de base de données mysql-cloudsql.

Le résultat est le suivant :
```
Connecting to database with SQL user [root].Enter password:
count(*)
300024
```
Le nombre de lignes est identique à celui de l'instance mysql-prod.

Remarque : La base de données importée ne contient aucun déclencheur, ni aucune procédure stockée, vue ou fonction de la base de données d'origine. Si ces éléments sont requis, vous devez les recréer manuellement.

Informations supplémentaires pour les systèmes de production

Utiliser des instantanés de disque

Pour les sauvegardes physiques, telles que les instantanés de disque, la documentation MySQL recommande de suspendre les écritures dans la base de données avant de prendre un instantané. Pour ce faire, exécutez la commande FLUSH TABLES WITH READ LOCK. Une fois l'instantané terminé, vous pouvez utiliser UNLOCK TABLES pour redémarrer les écritures.

Pour les bases de données qui utilisent des tables InnoDB, nous vous recommandons de prendre directement l'instantané sans exécuter la commande FLUSH TABLES WITH READ LOCK. Cela permet à la base de données de continuer à fonctionner correctement. Cependant, l'état de l'instantané peut être incohérent. Si cela se produit, le moteur InnoDB peut recréer les tables dans un état cohérent au démarrage du clone.

Pour les bases de données utilisant des tables MyISAM, l'exécution de la commande FLUSH TABLES WITH READ LOCK bloque toutes les écritures dans les tables. La base de données est donc en mode lecture seule jusqu'à ce que la commande UNLOCK TABLES soit exécutée.

Si vous prenez un instantané sans d'abord vider et verrouiller les tables, la base de données nouvellement clonée risque de contenir des données incohérentes ou d'être corrompue.

Par conséquent, pour obtenir un instantané cohérent sur les bases de données utilisant des tables MyISAM, nous vous recommandons d'exécuter la commande FLUSH TABLES WITH READ LOCK sur une instance dupliquée avec accès en lecture et de capturer un instantané de cette instance, afin que les performances de la base de données principale (maîtresse) ne soient pas affectées.

Utiliser la commande mysqldump

Pour créer un fichier d'exportation cohérent avec la base de données source, la commande mysqldump verrouille toutes les tables au cours de l'opération d'exportation. Cela signifie que les écritures dans la base de données sont bloquées pendant son exportation.

Par conséquent, nous vous recommandons d'exécuter la commande mysqldump sur une instance dupliquée avec accès en lecture afin que l'instance de la base de données principale ne soit pas bloquée.

Nettoyer

Pour éviter que les ressources utilisées dans ce tutoriel soient facturées sur votre compte Google Cloud, vous pouvez supprimer le projet Google Cloud que vous avez créé pour ce tutoriel.

Attention : La suppression d'un projet entraîne les effets décrits ci-dessous :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Étape suivante

Découvrez comment surveiller vos requêtes lentes dans MySQL avec Cloud Monitoring.
Découvrez des architectures de référence, des schémas et des bonnes pratiques concernant Google Cloud. Consultez notre Centre d'architecture cloud.