Włączanie funkcji Private Service Connect w istniejącej instancji Cloud SQL z usługą PSA (Terraform)

1. Omówienie

Istnieje kilka opcji połączenia z prywatną instancją Cloud SQL z innego projektu lub sieci VPC. Za pomocą prywatnego dostępu do usług (PSA) możesz łączyć się z wewnętrznymi adresami IP Google i usług innych firm za pomocą połączeń prywatnych. Aby rozszerzyć dostęp do bazy danych, możesz teraz też włączyć Private Service Connect (PSC).

Usługa Private Service Connect (PSC) umożliwia producentom usług udostępnianie ich za pomocą załączników usług, których użytkownicy mogą używać do tworzenia punktów końcowych PSC lub backendów PSC w swoim środowisku. Za pomocą tych punktów końcowych PSC mogą łączyć się z usługami producenta za pomocą prywatnego adresu IP podanego przez użytkownika.

W tym laboratorium możesz skonfigurować i przetestować tę opcję.

Uwaga: to rozwiązanie ma pewne ograniczenia. Więcej informacji znajdziesz w sekcji Ograniczenia usługi Private Service Connect w dokumentacji.

W tym module utworzysz prostą architekturę, która ilustruje użycie dostępu do punktów końcowych PSA i PSC w CloudSQL.

Rysunek 1.

Do wykonania tego ćwiczenia potrzebne będą 2 projekty lub osobne środowiska VPC w tym samym projekcie.

Uwaga: dostęp globalny można włączyć w punkcie końcowym PSC, aby udostępnić go w innych regionach.

Cele

Z tego modułu dowiesz się, jak wykonać te czynności:

• Włączanie sieci usług
• Konfigurowanie PSA
• Tworzenie instancji CloudSQL za pomocą PSA
• Włącz przyłącze usługi PSC.
• Utwórz punkt końcowy PSC w sieci VPC konsumenta, aby połączyć się z bazą danych CloudSQL
• Sprawdź dostęp do bazy danych SQL z maszyn testowych w sieciach VPC producenta i konsumenta.

Uwaga: ten projekt może być używany przez wielu konsumentów. Dowiedz się więcej o wielodzierżalności usługi Private Service Connect.

2. Konfiguracja i wymagania

Konfiguracja środowiska w samodzielnym tempie

1. Zaloguj się w konsoli Google Cloud i utwórz nowy projekt lub użyj istniejącego. Jeśli nie masz jeszcze konta Gmail ani Google Workspace, musisz je utworzyć.

• Nazwa projektu to wyświetlana nazwa uczestników tego projektu. Jest to ciąg znaków, którego nie używają interfejsy API Google. Zawsze możesz ją zaktualizować.
• Identyfikator projektu jest niepowtarzalny w ramach wszystkich projektów Google Cloud i nie można go zmienić (po ustawieniu). Konsola Cloud automatycznie generuje unikalny ciąg znaków. Zwykle nie ma znaczenia, jaki to ciąg. W większości laboratoriów z kodem trzeba podać identyfikator projektu (zwykle oznaczony jako PROJECT_ID). Jeśli nie podoba Ci się wygenerowany identyfikator, możesz wygenerować inny losowy. Możesz też spróbować użyć własnego adresu e-mail, aby sprawdzić, czy jest on dostępny. Nie można go zmienić po wykonaniu tego kroku. Pozostanie on na stałe w ramach projektu.
• Informacyjnie: istnieje jeszcze 3 wartość, numer projektu, której używają niektóre interfejsy API. Więcej informacji o wszystkich 3 wartościach znajdziesz w dokumentacji.

Uwaga: identyfikator projektu jest globalnie niepowtarzalny i po jego wybraniu nie może być używany przez nikogo innego. Jesteś jedyną osobą, która używa tego identyfikatora. Nawet jeśli projekt zostanie usunięty, nie można ponownie użyć jego identyfikatora.

Uwaga: jeśli używasz konta Gmail, możesz pozostawić domyślną lokalizację ustawioną na Brak organizacji. Jeśli korzystasz z konta Google Workspace, wybierz lokalizację odpowiednią dla Twojej organizacji.

2. Następnie musisz włączyć rozliczenia w konsoli Cloud, aby korzystać z zasobów i interfejsów API Cloud. Przejście przez ten samouczek nie będzie kosztowne, a być może nawet bezpłatne. Aby wyłączyć zasoby i uniknąć obciążenia opłatami po zakończeniu samouczka, możesz usunąć utworzone zasoby lub usunąć projekt. Nowi użytkownicy Google Cloud mogą skorzystać z bezpłatnego okresu próbnego, w którym mają do dyspozycji środki w wysokości 300 USD.

Uruchamianie Cloud Shell

Google Cloud można obsługiwać zdalnie z laptopa, ale w tym ćwiczeniu będziesz korzystać z Google Cloud Shell, czyli środowiska wiersza poleceń działającego w chmurze.

W konsoli Google Cloud kliknij ikonę Cloud Shell na pasku narzędzi w prawym górnym rogu:

Uzyskanie dostępu do środowiska i połączenie się z nim powinno zająć tylko kilka chwil. Po jego zakończeniu powinno wyświetlić się coś takiego:

Ta maszyna wirtualna zawiera wszystkie potrzebne narzędzia dla programistów. Zawiera stały katalog domowy o pojemności 5 GB i działa w Google Cloud, co znacznie poprawia wydajność sieci i uwierzytelnianie. Wszystkie zadania w tym CodeLab możesz wykonać w przeglądarce. Nie musisz niczego instalować.

3. Zadanie 1. Konfigurowanie środowiska projektu bazy danych za pomocą Terraform

Pamiętaj, że włączenie niektórych zasobów wiąże się z kosztami. Aby zmniejszyć koszty, upewnij się, że zasoby zostaną zniszczone po zakończeniu modułu. Sprawdź, czy masz możliwość dokonania płatności.

W projekcie bazy danych włączymy sieci usług, utworzymy sieć VPC, zakres PSA, połączenie sieci usług i reguły zapory sieciowej. Otwórz konsolę Google Cloud i wybierz projekt, którego będziesz używać do bazy danych.

1. Otwórz Cloud Shell, który znajduje się u góry konsoli po prawej stronie. Upewnij się, że w Cloud Shell widzisz identyfikator projektu bazy danych. Potwierdź wszystkie monity, aby zezwolić na dostęp.
2. Utwórz folder o nazwie terraform-db-psc i przenieś go do folderu

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

3. Utwórz pliki main.tf, variable.tf, nat-vm.tf i database.tf.

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

4. Przełącz się na widok Edytor Cloud Shell. Wybierz Edytor i pozwól na wyświetlanie wszystkich wymaganych komunikatów, aby umożliwić wczytanie interfejsu.
5. Po załadowaniu przejdź do Plik > Otwórz folder, przejdź do folderu /home/nazwa_użytkownika/terraform-db-psc i kliknij OK, aby otworzyć folder w edytorze.
6. Wybierz plik variable.tf i dodaj te informacje. Zastąp tekst your-database-project-id-here cudzysłowami z identyfikatorem swojego projektu bazy danych. Zastąp tekst your-consumer-project-id-here cudzymi znakami cudzysłownymi identyfikator projektu dla konsumentów.

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. Następnie otwórz plik main.tf. Dodamy kod terraform, który wykona różne działania opisane poniżej.

Włączanie interfejsów API	resource "google_project_service" "default"
Utwórz VPC	resource "google_compute_network" "default"
Dodaj reguły zapory sieciowej	resource "google_compute_firewall" "allow_icmp"
Tworzenie zakresu PSA	resource "google_compute_global_address" "psa_range"
Tworzenie połączenia równorzędnego	resource "google_service_networking_connection" "private_connection"

8. Skopiuj i wklej ten kod do głównego pliku .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. Wróć do terminala Cloud Shell i upewnij się, że jesteś w katalogu terraform-db-psc cd terraform-db-psc, a następnie uruchom te polecenia.

terraform init

Inicjuje katalog roboczy. Na tym etapie pobierani są dostawcy wymagani w danej konfiguracji.

terraform plan

Tworzy plan wykonania, który pokazuje, jakie działania Terraform wykona, aby wdrożyć Twoją infrastrukturę.

10. Aby utworzyć zasoby, uruchom polecenie terraform apply i wpisz yes, aby je uruchomić.

Sprawdzanie konfiguracji:

Sprawdź, czy w środowisku przydzielono zakres adresów IP PSA w sieci VPC z włączoną usługą networkingu.

Utworzono sieć VPC w trybie automatycznym o nazwie database-net

Reguły zapory sieciowej zostały utworzone.

4. Zadanie 2. Tworzenie instancji CloudSQL za pomocą PSA (Terraform)

Użyj Terraform do utworzenia instancji CloudSQL z opcją PSA, aby umożliwić połączenie. Przeprowadź tę konfigurację w projekcie bazy danych.

1. Przełącz się na widok Edytor Cloud Shell. Upewnij się, że jesteś w folderze terraform-db-psc. Wybierz plik database.tf i dodaj te informacje.

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. Wróć do terminala Cloud Shell i sprawdź,czy jesteś w katalogu terraform-db-psc. Aby utworzyć zasoby, uruchom polecenie terraform apply i wpisz yes, aby je uruchomić. Tworzenie instancji CloudSQL za pomocą PSA może potrwać ponad 15 minut.

Weryfikowanie bazy danych

3. Po zakończeniu procesu w konsoli przejdź do sekcji SQL i wybierz nowo utworzoną instancję bazy danych psc-psa-sql-db.
4. Po lewej stronie rozwiń panel opcji SQL i wybierz Połączenia.
5. Na karcie Podsumowanie znajdziesz informacje o połączeniu.
6. Skopiuj wewnętrzny adres IP i zapisz go w dowolnym miejscu w systemie. Jak widać, został on przypisany z zarezerwowanego przez nas zakresu.
7. Ten adres IP będzie potrzebny do wykonania zadania 3, krok 5.

8. Po lewej stronie rozwiń panel opcji SQL i wybierz Użytkownicy.
9. Powinien pojawić się użytkownik o nazwie testsql z hasłem cloudsql24. (Będzie on używany do późniejszego uzyskiwania dostępu do bazy danych)

Sprawdzanie konfiguracji:

1 instancja bazy danych SQL z prywatnym adresem IP

1 użytkownik o nazwie testsql i hasło cloudsql24

5. Zadanie 3. Tworzenie testowej maszyny wirtualnej i nawiązywanie połączenia z instancją SQL z poziomu projektu bazy danych (Terraform)

Użyjemy Terraform do utworzenia testowej maszyny wirtualnej i bramy NAT. Przeprowadź tę konfigurację w projekcie bazy danych.

1. Przełącz się na widok Edytor Cloud Shell. Upewnij się, że jesteś w folderze terraform-db-psc. Wybierz plik nat-vm.tf i dodaj te informacje.

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. Wróć do terminala Cloud Shell i sprawdź,czy jesteś w katalogu terraform-db-psc. Aby utworzyć zasoby, uruchom polecenie terraform plan, then terraform apply i wpisz yes, aby je uruchomić. Spowoduje to utworzenie bramy NAT i maszyny wirtualnej z zainstalowaną MariaDB.

Weryfikowanie bazy danych

Wykonaj to w projekcie konsumenta

3. Otwórz instancję maszyny wirtualnej. Wybierz db-vm-test.
4. Aby połączyć się z maszyną wirtualną, wybierz opcję SSH.
5. Połącz się z bazą danych za pomocą skopiowanego wcześniej lokalnego adresu IP:

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

p.s. Zmień adres IP na swój rzeczywisty adres IP, aby można było nawiązać połączenie.

6. Po nawiązaniu połączenia utwórz bazę danych o nazwie localvpcsqldb.

CREATE DATABASE localvpcsqldb;

7. Po zakończeniu wpisz exit, aby zakończyć połączenie. Aby zamknąć maszynę wirtualną, wpisz exit jeszcze raz.

Sprawdzanie konfiguracji:

1 brama NAT

1 maszyna wirtualna o nazwie db-vm-test

6. Zadanie 4. Włączanie PSC w instancji CloudSQL

Użyj poleceń gcloud, aby włączyć opcję PSC i umożliwić połączenie. Przeprowadź tę konfigurację w projekcie bazy danych.

1. Przełącz się na widok Cloud Shell.
2. Uruchom to polecenie w Cloud Shell.

• Zastąp YOUR_DB_PROJECT_HERE identyfikatorem projektu bazy danych.
• Zastąp YOUR_CONSUMER_PROJECT_HERE identyfikatorem projektu konsumenta.

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. Spowoduje to zaktualizowanie istniejącej bazy danych o załącznik PSC. Zajmie to co najmniej 10 minut.

Jeśli wystąpi błąd oczekiwania z powodu przekroczenia limitu czasu, powinieneś też zobaczyć polecenie, które pozwoli Ci kontynuować sprawdzanie postępu. "Możesz kontynuować oczekiwanie na wykonanie operacji, uruchamiając polecenie `gcloud beta sql operations wait –project ".

Pamiętaj, że możesz wdrożyć nową bazę danych z włączonymi usługami PSA i PSC od samego początku.

Weryfikowanie bazy danych

4. Po zakończeniu w konsoli otwórz SQL i wybierz instancję bazy danych psc-psa-sql-db.
5. Po lewej stronie rozwiń panel opcji SQL i wybierz Połączenia.
6. Na karcie Podsumowanie znajdziesz informacje o połączeniu.
7. Skopiuj adres załącznika usługi i zapisz go gdzieś w systemie.
8. Będziesz go potrzebować do wykonania następnego zadania (krok 8).

Sprawdzanie konfiguracji:

1 wystąpienie bazy danych SQL z dołączoną usługą

7. Zadanie 5. Konfigurowanie środowiska dla projektu konsumenta (Terraform)

W projekcie klienta utworzymy niestandardowe środowisko VPC z regułami zapory sieciowej i podsiecią. Otwórz konsolę Google Cloud i wybierz projekt, którego będziesz używać.

1. U góry konsoli po prawej stronie obok ikony Google Cloud kliknij menu i wybierz kartę all (Wszystkie).

2. Aby kontynuować, wybierz z listy identyfikator projektu dla konsumentów.
3. Otwórz Cloud Shell, który znajduje się u góry konsoli po prawej stronie. Upewnij się, że w Cloud Shell widać identyfikator projektu konsumenta. Potwierdź wyświetlone prośby o dostęp.
4. Utwórz folder o nazwie terraform-consumer-psc i przenieś go do folderu

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

5. Utwórz pliki main.tf, variable.tf i psc.tf.

touch main.tf variable.tf psc.tf 

6. Przełącz się na widok edytora Cloud Shell dla identyfikatora projektu klienta. Wybierz Edytor i pozwól na wyświetlanie wszystkich wymaganych komunikatów, aby umożliwić wczytanie interfejsu.
7. Po załadowaniu przejdź do Plik > Otwórz folder, przejdź do katalogu /home/nazwa_użytkownika/terraform-consumer-psc i kliknij OK, aby otworzyć folder w edytorze.
8. Wybierz plik variable.tf i dodaj te informacje. Zastąp tekst your-consumer-project-id-here cudzy tekst rzeczywistym identyfikatorem projektu w cudzysłowie. Zastąp tekst your-psc-attachment-id-here adresem załącznika psc w cudzysłowie. To identyfikator skopiowany w kroku 4 w sekcji 5–7.

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. Następnie otwórz plik main.tf. Dodamy kod terraform, który wykona różne działania opisane poniżej.

Włączanie interfejsów API	resource "google_project_service"
Utwórz VPC	resource "google_compute_network"
Tworzenie bramy NAT	resource "google_compute_router" resource "google_compute_router_nat"
Dodaj reguły zapory sieciowej	resource "google_compute_firewall"

10. Skopiuj i wklej ten kod do głównego pliku .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. Wróć do terminala Cloud Shell i sprawdź, czy jesteś w katalogu terraform-consumer-psc cd terraform-consumer-psc w projekcie dla konsumenta. Następnie uruchom te polecenia.

terraform init

Inicjuje katalog roboczy. Na tym etapie pobierani są dostawcy wymagani w danej konfiguracji.

terraform plan

Tworzy plan wykonania, który pokazuje, jakie działania Terraform wykona, aby wdrożyć Twoją infrastrukturę.

12. Aby utworzyć zasoby, uruchom polecenie terraform apply i wpisz yes, aby je uruchomić.

Sprawdzanie konfiguracji:

Sprawdź swoje środowisko pod kątem

1 niestandardowe VPC o nazwie psc-endpoint-vpc

Brama NAT z regułami zapory sieciowej

8. Zadanie 6. Tworzenie w projekcie konsumenta połączenia punktu końcowego PSC z bazą danych SQL i testowanie maszyny wirtualnej (Terraform)

Przeprowadź tę konfigurację w projekcie konsumenta.

1. Wróć do edytora Cloud Shell, otwórz katalog terraform-consumer-psc i wybierz plik psc.tf. Dodaj do tego pliku ten kod Terraform. Spowoduje to utworzenie stałego wewnętrznego adresu IP, punktu końcowego PSC i testowej maszyny wirtualnej z zainstalowaną bazą danych MariaDB.

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. Wróć do terminala Cloud Shell i sprawdź, czy jesteś w katalogu terraform-consumer-psc cd terraform-consumer-psc w projekcie dla konsumenta. Następnie uruchom te polecenia.

terraform plan

Tworzy plan wykonania, który pokazuje, jakie działania Terraform wykona, aby wdrożyć Twoją infrastrukturę.

3. Aby utworzyć zasoby, uruchom polecenie terraform apply i wpisz yes, aby je uruchomić.

9. Zadanie 7. Sprawdzanie łączności punktu końcowego z maszyny wirtualnej za pomocą adresu IP PSC

Wykonaj to w projekcie konsumenta

8. Otwórz instancję maszyny wirtualnej. Wybierz remote-sql-test-vm.
9. Aby połączyć się z maszyną wirtualną, wybierz opcję SSH.
10. Połącz się z bazą danych za pomocą punktu końcowego, korzystając z tych opcji:

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

11. Po nawiązaniu połączenia utwórz bazę danych o nazwie psc-sql-db.

CREATE DATABASE remotepscpsasqldb;

12. Po zakończeniu wpisz exit, aby zakończyć połączenie. Aby zamknąć maszynę wirtualną, wpisz exit jeszcze raz.

10. Zadanie 8. Weryfikowanie wpisu w bazie danych

Przeprowadź tę weryfikację w projekcie bazy danych.

1. U góry konsoli po prawej stronie obok ikony Google Cloud kliknij menu i wybierz kartę all (Wszystkie).

2. Aby kontynuować, wybierz z listy identyfikator projektu bazy danych.
3. Przejdź do sekcji SQL, wybierz bazę danych psc-psa-sql-db, rozwiń opcje SQL i wybierz Bazy danych. Powinna się wyświetlić baza danych o nazwie remotepscpsasqldb utworzona w maszynie wirtualnej projektu konsumenta oraz baza danych localvpcsqldb utworzona w maszynie wirtualnej projektu bazy danych**.**.

Uwaga: możesz też połączyć się za pomocą nazwy DNS. Więcej informacji o konfigurowaniu DNS znajdziesz tutaj: Konfigurowanie strefy zarządzanej przez DNS i rekordu DNS.

11. Czyszczenie

Aby uniknąć zbędnych opłat, pamiętaj o czyszczeniu danych.

Wykonaj to w projekcie dotyczącym konsumentów

1. Wybierz identyfikator projektu konsumenta
2. Otwórz Cloud Shell i sprawdź, czy widzisz identyfikator projektu konsumenta.
3. Otwórz katalog terraform-consumer-psc cd terraform-consumer-psc i uruchom to polecenie terraform destroy, a potem wpisz yes. Wszystkie zasoby utworzone w projekcie konsumenta za pomocą Terraform zostaną usunięte.

Wykonaj to w projekcie bazy danych

1. Wybierz identyfikator projektu bazy danych
2. Otwórz Cloud Shell i sprawdź, czy widzisz identyfikator projektu bazy danych.
3. Otwórz katalog terraform-db-psc cd terraform-db-psc i uruchom to polecenie terraform destroy, a potem wpisz yes. Większość zasobów utworzonych w projekcie bazy danych za pomocą Terraform zostanie usunięta. Sieć usług może nie zostać usunięta i może wyświetlić błąd.
4. Następnie usuń z folderu terraform-db-psc te pliki:

rm -r terraform.tfstate terraform.tfstate.backup

5. Następnie w konsoli otwórz Sieci VPC.
6. Wybierz sieć VPC database-net, wybierz DOSTĘP DO USŁUG PRYWATNYCH, w sekcji Przydzielone zakresy adresów IP dla usług wybierz psa-range-database-net i kliknij Opublikuj.

7. Następnie wybierz POŁĄCZENIE RÓWNORZĘDNE SIECI VPC,servicenetworking-googleapis-com i opcję Usuń.

8. Następnie kliknij Usuń sieć VPC .

12. Gratulacje

Gratulacje! Udało Ci się skonfigurować instancję Cloud SQL z przyłączem PSA i PSC oraz utworzyć punkt końcowy Private Service Connect w innej sieci VPC.

Więcej informacji

Więcej informacji o Private Service Connect i Cloud SQL

Inne powiązane ćwiczenia z programowania: https://codelabs.developers.google.com/codelabs/cloudsql-psc-terraform