Activer Private Service Connect sur une instance Cloud SQL existante exécutant PSA (Terraform)

1. Présentation

Il existe plusieurs options pour se connecter à une instance Cloud SQL privée à partir d'un autre projet ou réseau VPC. Vous pouvez utiliser l'accès aux services privés (PSA, Private Services Access) pour atteindre les adresses IP internes des services Google et tiers à l'aide de connexions privées. Pour étendre l'accès à la base de données, vous pouvez également activer Private Service Connect (PSC).

Private Service Connect (PSC) permet aux producteurs de services d'exposer leurs services via des rattachements de service, que les consommateurs peuvent utiliser pour créer des points de terminaison et/ou des backends PSC dans leur environnement. Grâce à ces points de terminaison PSC, ils peuvent se connecter aux services du producteur via une adresse IP privée spécifiée par l'utilisateur.

Dans cet atelier, vous pouvez configurer et tester l'option.

Remarque : Cette solution présente certaines limites. Vous pouvez les consulter dans la section Limites de Private Service Connect de la documentation.

Dans cet atelier, vous allez créer une architecture simple qui illustre l'utilisation de l'accès aux points de terminaison PSA et PSC avec Cloud SQL.

Figure 1.

Pour cet atelier, vous aurez besoin de deux projets ou de deux VPC distincts dans le même projet.

Remarque : Vous pouvez activer l'accès mondial sur le point de terminaison PSC pour le rendre disponible dans d'autres régions.

Objectifs

Dans cet atelier, vous apprendrez à effectuer les tâches suivantes :

• Activer le service de mise en réseau
• Configurer PSA
• Créer une instance Cloud SQL avec PSA
• Activez le rattachement de service PSC.
• Créez un point de terminaison PSC dans le VPC consommateur pour vous connecter à la base de données CloudSQL.
• Vérifier l'accès à la base de données SQL depuis les VM de test, dans les VPC producteur et consommateur

Remarque : Plusieurs consommateurs peuvent utiliser cette conception. En savoir plus sur le multitenancy Private Service Connect

2. Préparation

Configuration de l'environnement au rythme de chacun

1. Connectez-vous à la console Google Cloud, puis créez un projet ou réutilisez un projet existant. Si vous n'avez pas encore de compte Gmail ou Google Workspace, vous devez en créer un.

• Le nom du projet est le nom à afficher pour les participants au projet. Il s'agit d'une chaîne de caractères non utilisée par les API Google. Vous pourrez toujours le modifier.
• L'ID du projet est unique parmi tous les projets Google Cloud et non modifiable une fois défini. La console Cloud génère automatiquement une chaîne unique (en général, vous n'y accordez d'importance particulière). Dans la plupart des ateliers de programmation, vous devrez indiquer l'ID de votre projet (généralement identifié par PROJECT_ID). Si l'ID généré ne vous convient pas, vous pouvez en générer un autre de manière aléatoire. Vous pouvez également en spécifier un et voir s'il est disponible. Après cette étape, l'ID n'est plus modifiable et restera donc le même pour toute la durée du projet.
• Pour information, il existe une troisième valeur (le numéro de projet) que certaines API utilisent. Pour en savoir plus sur ces trois valeurs, consultez la documentation.

Attention : Un ID de projet est unique. Une fois que vous l'avez choisi, personne d'autre ne peut l'employer. Vous en êtes le seul utilisateur. Même si un projet est supprimé, son ID ne peut pas être réutilisé.

Remarque : Si vous utilisez un compte Gmail, vous pouvez conserver l'emplacement par défaut défini sur Aucune organisation. Si vous utilisez un compte Google Workspace, choisissez un emplacement qui ait du sens pour votre organisation.

2. Vous devez ensuite activer la facturation dans la console Cloud pour utiliser les ressources/API Cloud. L'exécution de cet atelier de programmation est très peu coûteuse, voire sans frais. Pour désactiver les ressources et éviter ainsi que des frais ne vous soient facturés après ce tutoriel, vous pouvez supprimer le projet ou les ressources que vous avez créées. Les nouveaux utilisateurs de Google Cloud peuvent participer au programme d'essai sans frais pour bénéficier d'un crédit de 300 $.

Démarrer Cloud Shell

Bien que Google Cloud puisse être utilisé à distance depuis votre ordinateur portable, nous allons nous servir de Google Cloud Shell pour cet atelier de programmation, un environnement de ligne de commande exécuté dans le cloud.

Dans la console Google Cloud, cliquez sur l'icône Cloud Shell dans la barre d'outils supérieure :

Le provisionnement et la connexion à l'environnement prennent quelques instants seulement. Une fois l'opération terminée, le résultat devrait ressembler à ceci :

Cette machine virtuelle contient tous les outils de développement nécessaires. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud, ce qui améliore nettement les performances du réseau et l'authentification. Vous pouvez effectuer toutes les tâches de cet atelier de programmation dans un navigateur. Vous n'avez rien à installer.

3. Tâche 1 : Configurer l'environnement pour le projet de base de données avec Terraform

Veuillez noter que certaines ressources que vous activez entraîneront des frais. Pour réduire les coûts, assurez-vous que les ressources sont détruites à la fin de l'atelier. Nous vous recommandons de vérifier la facturation et de vous assurer que cela vous convient.

Dans le projet de base de données, nous allons activer la mise en réseau des services, créer un VPC, créer une plage d'adresses IP privées de service, créer un appairage de mise en réseau des services et créer des règles de pare-feu. Ouvrez la console Cloud et sélectionnez le projet que vous utiliserez pour la base de données.

1. Ouvrez Cloud Shell en haut à droite de la console. Assurez-vous que l'ID de projet de la base de données s'affiche pour le projet de base de données dans Cloud Shell, puis confirmez les éventuelles invites pour autoriser l'accès.
2. Créez un dossier appelé terraform-db-psc et accédez-y.

mkdir terraform-db-psc  && cd terraform-db-psc

3. Créez les fichiers main.tf, variable.tf, nat-vm.tf et database.tf.

touch main.tf variable.tf nat-vm.tf database.tf 

4. Passez à la vue Éditeur Cloud Shell. Sélectionnez éditeur et assurez-vous d'autoriser toutes les invites nécessaires pour que l'interface puisse se charger.
5. Une fois le fichier chargé, accédez à File > Open Folder (Fichier > Ouvrir le dossier), puis accédez à /home/your-user-name/terraform-db-psc et sélectionnez Ok (OK) pour ouvrir le dossier dans l'éditeur.
6. Sélectionnez le fichier variable.tf et ajoutez-y le code suivant. Remplacez le texte your-database-project-id-here par l'ID réel de votre projet de base de données entre guillemets. Remplacez le texte your-consumer-project-id-here par l'ID réel de votre projet consommateur entre guillemets.

variable "project_id" {
  type = string
  default = "your-database-project-id-here"
}

variable "project_id_consumer" {
  type = set(string)
  default = ["your-consumer-project-id-here"]
}

variable "network_id" {
  type = string
  default = "database-net"
}

variable "region_id" {
  type = string
  default = "us-east1"
}

variable "db_password" {
  type = string
  default = "cloudsql24"
}

7. Ensuite, ouvrez le fichier main.tf. Nous allons ajouter du code Terraform pour effectuer différentes actions, comme expliqué ci-dessous.

Activer les API	resource "google_project_service" "default"
Créer un VPC	resource "google_compute_network" "default"
Ajouter des règles de pare-feu	resource "google_compute_firewall" "allow_icmp"
Créer une plage d'annonces d'intérêt public	resource "google_compute_global_address" "psa_range"
Créer un peering	resource "google_service_networking_connection" "private_connection"

8. Copiez et collez le texte suivant dans le fichier main .tf.

resource "google_project_service" "default" {
 for_each = toset([
   "compute.googleapis.com",
   "servicenetworking.googleapis.com", 
   "sqladmin.googleapis.com",
   "cloudresourcemanager.googleapis.com"
 ])

 service            = each.value
 disable_on_destroy = false
}

resource "google_compute_network" "default" {
 project                = var.project_id
 name                    = var.network_id
 auto_create_subnetworks = true
 mtu                     = 1460
 routing_mode            = "GLOBAL"
}

resource "google_compute_global_address" "psa_range" {
  name                  = "psa-range-${google_compute_network.default.name}"
  project               = var.project_id
  purpose               = "VPC_PEERING"
  address_type          = "INTERNAL"
  prefix_length         = 20
  address               = "172.18.0.0"
  network               = google_compute_network.default.id

}

resource "google_service_networking_connection" "private_connection" {
  network = google_compute_network.default.self_link
  service = "servicenetworking.googleapis.com"

  reserved_peering_ranges = [
    google_compute_global_address.psa_range.name,
  ]
}

resource "google_compute_firewall" "allow_icmp" {
 name    = "allow-icmp-${google_compute_network.default.name}"
 network = google_compute_network.default.id
 project = var.project_id

 allow {
   protocol = "icmp"
 }

 source_ranges = ["0.0.0.0/0"]
 target_tags   = ["allow-icmp"]
}

resource "google_compute_firewall" "allow_ssh" {
 name    = "allow-ssh-${google_compute_network.default.name}"
 network = google_compute_network.default.id
 project = var.project_id

 allow {
   protocol = "tcp"
   ports    = ["22"]
 }

 source_ranges = ["0.0.0.0/0"]
 target_tags   = ["allow-ssh"]
}

resource "google_compute_firewall" "allow_sql" {
 name    = "allow-sql-${google_compute_network.default.name}"
 network = google_compute_network.default.id
 project = var.project_id

 allow {
   protocol = "tcp"
   ports    = ["3306"]
 }

 source_ranges = ["0.0.0.0/0"]
}

resource "google_compute_firewall" "allow_internal" {
 name    = "allow-internal-${google_compute_network.default.name}"
 network = google_compute_network.default.id
 project = var.project_id

 allow {
   protocol = "icmp"
 }

 allow {
   protocol = "tcp"
   ports    = ["0-65535"]
 }
 allow {
   protocol = "udp"
   ports    = ["0-65535"]
 }

 source_ranges = ["10.128.0.0/9", "172.18.0.0/20"] # Include PSA range
}

9. Revenez au terminal Cloud Shell, assurez-vous d'être dans le répertoire terraform-db-psc cd terraform-db-psc, puis exécutez les commandes suivantes :

terraform init

Initialise le répertoire de travail. Cette étape télécharge les fournisseurs requis pour la configuration donnée.

terraform plan

Génère un plan d'exécution, qui indique les actions que Terraform effectuera pour déployer votre infrastructure.

10. Pour créer les ressources, exécutez la commande terraform apply et saisissez yes pour l'exécuter.

Vérifiez votre configuration :

Vérifier si une plage d'adresses IP PSA appairée au réseau VPC avec service-networking activé est allouée à votre environnement

Réseau VPC en mode automatique appelé "database-net" créé

Règles de pare-feu créées

4. Tâche 2 : Créer une instance Cloud SQL avec PSA (Terraform)

Utilisons Terraform pour créer une instance CloudSQL, avec l'option PSA pour autoriser la connectivité. Effectuez cette configuration dans le projet de base de données.

1. Passez à la vue Éditeur Cloud Shell. Assurez-vous d'être dans le dossier terraform-db-psc. Sélectionnez le fichier database.tf et ajoutez-y le code suivant.

resource "google_sql_database_instance" "default" {
  name             = "psc-psa-sql-db"
  region           = var.region_id
  database_version = "MYSQL_8_0"  
  settings {
    tier              = "db-f1-micro"
    availability_type = "REGIONAL"
    backup_configuration {
      enabled            = true
      binary_log_enabled = true
    }
    ip_configuration {      
      ipv4_enabled    = "false"
      private_network = google_compute_network.default.id
      
    }
  }
  deletion_protection = false 
}

resource "google_sql_user" "users" {
  name     = "testsql"
  instance = google_sql_database_instance.default.name
  password = var.db_password 
}

2. Revenez au terminal Cloud Shell et assurez-vous d'être dans le répertoire terraform-db-psc. Pour créer les ressources, exécutez la commande terraform apply et saisissez yes pour l'exécuter. La création de l'instance Cloud SQL avec PSA peut prendre plus de 15 minutes.

Vérifier la base de données

3. Une fois l'opération terminée, accédez à SQL dans la console, puis sélectionnez l'instance de base de données psc-psa-sql-db que vous venez de créer.
4. Sur la gauche, développez le panneau coulissant des options SQL et sélectionnez Connexions.
5. L'onglet "Récapitulatif" contient des informations sur la connexion.
6. Copiez l'adresse IP interne et enregistrez-la quelque part sur votre système. Comme vous pouvez le voir, il a été attribué à partir de la plage que nous avons réservée.
7. Vous aurez besoin de cette adresse IP pour effectuer l'étape 5 de la tâche 3.

8. Sur la gauche, développez le panneau coulissant des options SQL et sélectionnez Utilisateurs.
9. Vous devriez voir un utilisateur nommé testsql avec le mot de passe cloudsql24(il servira à accéder à la base de données ultérieurement).

Vérifiez votre configuration :

1 instance de base de données SQL avec une adresse IP privée

Un utilisateur nommé testsql et un mot de passe cloudsql24

5. Tâche 3 : Créer une VM de test et se connecter à une instance SQL depuis un projet de base de données (Terraform)

Utilisons Terraform pour créer une VM de test et une passerelle NAT. Effectuez cette configuration dans le projet de base de données.

1. Passez à la vue Éditeur Cloud Shell. Assurez-vous d'être dans le dossier terraform-db-psc. Sélectionnez le fichier nat-vm.tf et ajoutez-y le code suivant.

resource "google_compute_router" "default" {
  name    = "outbound-nat"
  region  = var.region_id
  network = google_compute_network.default.id

 bgp {
  asn = 64514
  }
}

resource "google_compute_router_nat" "default" {
  name = "outbound-nat-gw"
  router = google_compute_router.default.name
  region = google_compute_router.default.region
  nat_ip_allocate_option = "AUTO_ONLY"
  source_subnetwork_ip_ranges_to_nat = "ALL_SUBNETWORKS_ALL_IP_RANGES"

  log_config {
    enable = true
    filter = "ERRORS_ONLY"
  }
}


resource "google_compute_instance" "sql_net_vm" {
  name         = "db-vm-test"
  machine_type = "e2-medium"
  zone         = "${var.region_id}-b"
  project      = var.project_id

  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-11"
    }
  }

  network_interface {
    network = google_compute_network.default.self_link
  }

  # No external IP address
  network_performance_config {
    total_egress_bandwidth_tier = "DEFAULT"
  }

  tags = ["allow-icmp", "allow-ssh", "allow-internal", "allow-health-check"]

  # Install MariaDB at startup
  metadata_startup_script = <<EOF
#!/bin/bash
apt-get update
apt-get install -y mariadb-server
systemctl enable mariadb
EOF
}

2. Revenez au terminal Cloud Shell et assurez-vous d'être dans le répertoire terraform-db-psc. Pour créer les ressources, exécutez la commande terraform plan, then terraform apply et saisissez yes pour l'exécuter. Cela créera une passerelle NAT et une VM avec MariaDB installé.

Vérifier la base de données

Effectuez cette opération dans le projet client.

3. Accédez à Instance de VM. Sélectionnez db-vm-test.
4. Sélectionnez l'option SSH pour vous connecter à la VM.
5. Connectez-vous à la base de données via l'adresse IP locale que vous avez copiée précédemment :

mysql --host=172.18.0.2 --user=testsql --password=cloudsql24

P.S. : Remplacez l'adresse IP par votre adresse IP réelle pour que la connexion puisse s'établir.

6. Une fois la connexion établie, créez une base de données avec le nom localvpcsqldb.

CREATE DATABASE localvpcsqldb;

7. Une fois l'opération terminée, saisissez "exit" pour fermer la connexion. Saisissez à nouveau "exit" pour fermer la VM.

Vérifiez votre configuration :

1 passerelle NAT

Une VM appelée db-vm-test

6. Tâche 4 : Activer PSC sur l'instance Cloud SQL

Utilisons les commandes gcloud pour activer l'option PSC afin d'autoriser la connectivité. Effectuez cette configuration dans le projet de base de données.

1. Passez à la vue Cloud Shell.
2. Exécutez la commande suivante dans Cloud Shell.

• Remplacez YOUR_DB_PROJECT_HERE par l'ID du projet de base de données.
• Remplacez YOUR_CONSUMER_PROJECT_HERE par l'ID du projet client.

project_id=YOUR_DB_PROJECT_HERE
allowed_project=YOUR_CONSUMER_PROJECT_HERE

gcloud beta sql instances patch psc-psa-sql-db \
--project=$project_id \
--enable-private-service-connect \
--allowed-psc-projects=$allowed_project

3. La base de données existante sera mise à jour avec la pièce jointe PSC. Cette opération prendra un certain temps (plus de 10 minutes).

Si vous obtenez une erreur de délai d'attente, la commande permettant de continuer à suivre la progression devrait également s'afficher. Un message semblable à Vous pouvez continuer à attendre la fin de l'opération en exécutant la commande `gcloud beta sql operations wait –project

Veuillez noter que vous pouvez déployer une nouvelle base de données avec PSA et PSC activés dès le début.

Vérifier la base de données

4. Une fois l'opération terminée, accédez à SQL dans la console, puis sélectionnez l'instance de base de données psc-psa-sql-db.
5. Sur la gauche, développez le panneau coulissant des options SQL et sélectionnez Connexions.
6. L'onglet "Récapitulatif" contient des informations sur la connexion.
7. Copiez l'adresse de l'attachement de service et enregistrez-la quelque part sur votre système.
8. Vous en aurez besoin pour effectuer la tâche 5, étape 8.

Vérifiez votre configuration :

Une instance de base de données SQL avec un rattachement de service

7. Tâche 5 : Configurer l'environnement pour le projet consommateur (Terraform)

Dans le projet consommateur,nous allons créer un VPC personnalisé avec des règles de pare-feu et un sous-réseau. Ouvrez la console Cloud et sélectionnez le projet que vous allez utiliser.

1. En haut de la console, à droite de l'icône Google Cloud, cliquez sur le menu déroulant, puis sélectionnez l'onglet Tous.

2. Dans la liste des projets, sélectionnez l'ID de votre projet consommateur pour continuer.
3. Ouvrez Cloud Shell en haut à droite de la console. Assurez-vous que l'ID du projet consommateur s'affiche dans Cloud Shell et confirmez les éventuelles invites à autoriser l'accès.
4. Créez un dossier appelé terraform-consumer-psc et accédez-y.

mkdir terraform-consumer-psc  && cd terraform-consumer-psc

5. Créez les fichiers main.tf, variable.tf et psc.tf.

touch main.tf variable.tf psc.tf 

6. Passez à la vue Éditeur Cloud Shell pour l'ID du projet consommateur. Sélectionnez éditeur et assurez-vous d'autoriser toutes les invites nécessaires pour que l'interface puisse se charger.
7. Une fois chargé, accédez à Fichier > Ouvrir le dossier, puis accédez à /home/your-user-name/terraform-consumer-psc et sélectionnez OK pour ouvrir le dossier dans l'éditeur.
8. Sélectionnez le fichier variable.tf et ajoutez-y le code suivant. Remplacez le texte your-consumer-project-id-here par l'ID de votre projet consommateur entre guillemets. Remplacez le texte your-psc-attachment-id-here par l'adresse de votre pièce jointe PSC entre guillemets. Il s'agit de l'ID que vous avez copié dans la section 5 à 7 de la tâche 4 .

variable "project_id" {
  type = string
  default = "your-consumer-project-id-here"
}

variable "psc_attachment_id" {
  type = string
  default = "your-psc-attachment-id-here"
}

variable "network_id" {
  type = string
  default = "psc-endpoint-vpc"
}

variable "region_id" {
  type = string
  default = "us-east1"
}

9. Ensuite, ouvrez le fichier main.tf. Nous allons ajouter du code Terraform pour effectuer différentes actions, comme expliqué ci-dessous.

Activer les API	resource "google_project_service"
Créer un VPC	resource "google_compute_network"
Créer une passerelle NAT	resource "google_compute_router" resource "google_compute_router_nat"
Ajouter des règles de pare-feu	resource "google_compute_firewall"

10. Copiez et collez le texte suivant dans le fichier main .tf.

resource "google_project_service" "default" {
  for_each = toset([
    "compute.googleapis.com",
    "cloudresourcemanager.googleapis.com"
  ])

  service            = each.value
  disable_on_destroy = false
}

resource "google_compute_network" "default" {
  project                 = var.project_id
  name                    = var.network_id
  auto_create_subnetworks = false
  mtu                     = 1460
  routing_mode            = "GLOBAL"
}

resource "google_compute_subnetwork" "vm_subnet_pc" {
  name          = "vm-net"
  ip_cidr_range = "192.168.80.0/24"
  region        = var.region_id
  network       = google_compute_network.default.name
  project       = var.project_id
}

resource "google_compute_subnetwork" "psc_subnet_ip" {
  name          = "psc-subnet"
  ip_cidr_range = "192.168.100.0/24"
  region        = var.region_id
  network       = google_compute_network.default.name
  project       = var.project_id
}

resource "google_compute_router" "default" {
  name    = "outbound-nat"
  region  = var.region_id
  network = google_compute_network.default.id

 bgp {
  asn = 64514
  }
}

resource "google_compute_router_nat" "default" {
  name = "outbound-nat-gw"
  router = google_compute_router.default.name
  region = google_compute_router.default.region
  nat_ip_allocate_option = "AUTO_ONLY"
  source_subnetwork_ip_ranges_to_nat = "ALL_SUBNETWORKS_ALL_IP_RANGES"

  log_config {
    enable = true
    filter = "ERRORS_ONLY"
  }
}

resource "google_compute_firewall" "allow_icmp" {
  name    = "allow-icmp-${google_compute_network.default.name}"
  network = google_compute_network.default.id
  project = var.project_id

  allow {
    protocol = "icmp"
  }

  source_ranges = ["0.0.0.0/0"]
  
}

resource "google_compute_firewall" "allow_ssh" {
  name    = "allow-ssh-${google_compute_network.default.name}"
  network = google_compute_network.default.id
  project = var.project_id

  allow {
    protocol = "tcp"
    ports    = ["22"]
  }

  source_ranges = ["0.0.0.0/0"]
  target_tags   = ["allow-ssh"]
}


resource "google_compute_firewall" "allow_internal" {
  name    = "allow-internal-${google_compute_network.default.name}"
  network = google_compute_network.default.id
  project = var.project_id

  allow {
    protocol = "icmp"
    }


  allow {
    protocol = "tcp"
    ports    = ["0-65535"]
  }
  allow {
    protocol = "udp"
    ports    = ["0-65535"]
  }

  source_ranges = ["192.168.0.0/16"]
 }

11. Revenez au terminal Cloud Shell, assurez-vous d'être dans le répertoire terraform-consumer-psc cd terraform-consumer-psc du projet consommateur, puis exécutez les commandes suivantes :

terraform init

Initialise le répertoire de travail. Cette étape télécharge les fournisseurs requis pour la configuration donnée.

terraform plan

Génère un plan d'exécution, qui indique les actions que Terraform effectuera pour déployer votre infrastructure.

12. Pour créer les ressources, exécutez la commande terraform apply et saisissez yes pour l'exécuter.

Vérifiez votre configuration :

Vérifiez votre environnement pour

1 VPC personnalisé appelé "psc-endpoint-vpc"

Passerelle NAT avec règles de pare-feu

8. Tâche 6 : Créer le rattachement du point de terminaison PSC à la base de données SQL dans le projet client et la VM de test (Terraform)

Effectuez cette configuration dans le projet client.

1. Revenez à l'éditeur Cloud Shell, ouvrez le répertoire terraform-consumer-psc et sélectionnez le fichier psc.tf. Ajoutez le code Terraform suivant au fichier. Cela crée une adresse IP interne statique, un point de terminaison PSC et une VM de test avec MariaDB installé.

resource "google_compute_address" "default" {
  name = "psc-ip-1"
  region = var.region_id
  address_type = "INTERNAL"
  subnetwork = google_compute_subnetwork.psc_subnet_ip.name
  address = "192.168.100.100" 
}

resource "google_compute_forwarding_rule" "default" {
  name = "psc-sql-endpoint"
  region = var.region_id
  network = google_compute_network.default.name
  ip_address = google_compute_address.default.self_link
  load_balancing_scheme = ""
  target = var.psc_attachment_id
}


resource "google_compute_instance" "sql_test_vm" {
  name         = "remote-sql-test-vm"
  machine_type = "e2-medium"
  zone         = "${var.region_id}-b"
  project      = var.project_id

  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-11"
    }
  }

  network_interface {
    subnetwork = google_compute_subnetwork.vm_subnet_pc.name
  }

  # No external IP address
  network_performance_config {
    total_egress_bandwidth_tier = "DEFAULT"
  }

  tags = ["allow-icmp", "allow-ssh", "allow-internal", "allow-health-check"]

  # Install MariaDB at startup
  metadata_startup_script = <<EOF
#!/bin/bash
apt-get update
apt-get install -y mariadb-server
systemctl enable mariadb
EOF
}

2. Revenez au terminal Cloud Shell, assurez-vous d'être dans le répertoire terraform-consumer-psc cd terraform-consumer-psc du projet consommateur, puis exécutez les commandes suivantes :

terraform plan

Génère un plan d'exécution, qui indique les actions que Terraform effectuera pour déployer votre infrastructure.

3. Pour créer les ressources, exécutez la commande terraform apply et saisissez yes pour l'exécuter.

9. Tâche 7 : Vérifier la connectivité du point de terminaison à partir de la VM via l'adresse IP PSC

Effectuez cette opération dans le projet client.

8. Accédez à Instance de VM. Sélectionnez remote-sql-test-vm.
9. Sélectionnez l'option SSH pour vous connecter à la VM.
10. Connectez-vous à la base de données via le point de terminaison avec les éléments suivants :

mysql --host=192.168.100.100 --user=testsql --password=cloudsql24

11. Une fois la connexion établie, créez une base de données avec psc-sql-db.

CREATE DATABASE remotepscpsasqldb;

12. Une fois l'opération terminée, saisissez "exit" pour fermer la connexion. Saisissez à nouveau "exit" pour fermer la VM.

10. Tâche 8 : Vérifier l'entrée de la base de données

Effectuez cette validation dans le projet de base de données.

1. En haut de la console, à droite de l'icône Google Cloud, cliquez sur le menu déroulant, puis sélectionnez l'onglet Tous.

2. Dans la liste des projets, sélectionnez l'ID de projet de votre base de données pour continuer.
3. Accédez à SQL, sélectionnez la base de données psc-psa-sql-db, développez les options SQL, puis sélectionnez Bases de données. Vous devriez voir la base de données que vous venez de créer, appelée remotepscpsasqldb, à partir de la VM du projet client et également localvpcsqldb à partir de la VM du projet de base de données**.**

Remarque : Vous pouvez également vous connecter à l'aide d'un nom DNS. Pour en savoir plus sur la configuration du DNS, consultez Configurer une zone gérée DNS et un enregistrement DNS.

11. Effectuer un nettoyage

Veillez à effectuer un nettoyage pour éviter des frais inutiles.

Effectuez cette opération dans le projet client.

1. Sélectionnez l'ID du projet consommateur.
2. Accédez à Cloud Shell et assurez-vous que l'ID du projet consommateur s'affiche.
3. Accédez au répertoire terraform-consumer-psc cd terraform-consumer-psc, puis exécutez la commande suivante terraform destroy et saisissez yes. Toutes les ressources que vous avez créées dans votre projet consommateur avec Terraform seront supprimées.

Effectuez cette étape dans le projet de base de données.

1. Sélectionnez l'ID du projet de base de données.
2. Accédez à Cloud Shell et assurez-vous que l'ID du projet de base de données s'affiche.
3. Accédez au répertoire terraform-db-psc cd terraform-db-psc, puis exécutez la commande suivante terraform destroy et saisissez yes. La plupart des ressources que vous avez créées dans votre projet de base de données avec Terraform seront supprimées. Il est possible que le service de mise en réseau ne puisse pas être supprimé et qu'une erreur s'affiche.
4. Supprimez ensuite les fichiers suivants du dossier terraform-db-psc.

rm -r terraform.tfstate terraform.tfstate.backup

5. Ensuite, dans la console, accédez à Réseaux VPC.
6. Sélectionnez le VPC database-net, puis ACCÈS AUX SERVICES PRIVÉS. Sous Plages d'adresses IP allouées aux services, sélectionnez psa-range-database-net, puis l'option Libérer.

7. Sélectionnez ensuite APPAIRAGE DE RÉSEAUX VPC,puis servicenetworking-googleapis-com et l'option Supprimer.

8. Ensuite, sélectionnez Supprimer le réseau VPC .

12. Félicitations

Félicitations ! Vous avez configuré une instance Cloud SQL avec un rattachement PSA et PSC, et créé un point de terminaison Private Service Connect dans un autre VPC.

En savoir plus

En savoir plus sur Private Service Connect et Cloud SQL

Autre atelier de programmation associé : https://codelabs.developers.google.com/codelabs/cloudsql-psc-terraform