Die Three Tier App ist eine einfache To-do-Anwendung, die als einfache 3-Tier-Anwendung konzipiert ist:
- Back-End
- Datenbank – MySQL – Cloud SQL
- Caching – Redis – Cloud Memorystore
- Middleware/API
- Von Containern gehostete API – Golang – Cloud Run
- Front-End/Benutzeroberfläche
- Von Containern gehostete UI – Nginx + HTML/JS/CSS – Cloud Run
- Bereitstellung
- Kontinuierliche Bereitstellung – Cloud Build
- Secret Management – Cloud Secret Manager
Jetzt starten
Klicken Sie auf den folgenden Link, um den Quellcode in Cloud Shell zu kopieren. Dort wird mit einem einzigen Befehl eine funktionierende Kopie der Anwendung in Ihrem Projekt erstellt.
Dreistufige App-Komponenten
Die dreistufige App-Architektur nutzt mehrere Produkte. Im Folgenden finden Sie eine Liste der Komponenten sowie weitere Informationen zu den Komponenten, einschließlich Links zu ähnlichen Videos, Produktdokumentationen und interaktiven Schritt-für-Schritt-Anleitungen.
Skripts
Das Installationsskript verwendet eine ausführbare Datei, die in go und Terraform-Befehlszeilentools geschrieben ist, um ein leeres Projekt zu erstellen und die Anwendung darin zu installieren. Die Ausgabe sollte eine funktionierende Anwendung und eine URL für die Load-Balancing-IP-Adresse sein.
./main.tf
Dienste aktivieren
Google Cloud-Dienste sind in einem Projekt standardmäßig deaktiviert. Für ToDo müssen Sie die folgenden Dienste aktivieren:
- Dienstnetzwerk und serverloser VPC-Zugriff: Ermöglicht Cloud Run die Kommunikation mit SQL und Redis in einem privaten Netzwerk, sodass diese Server für externe Aufrufe von der API nicht zugänglich sind.
- Cloud Build – erstellt Container-Images und stellt sie in Cloud Run bereit
- Cloud Memorystore – stellt eine Caching-Ebene für die Anwendung bereit.
- Cloud Run: Das serverlose Tool, das die Container hostet und URLs bereitstellt, über die auf die Anwendung zugegriffen werden kann.
- Cloud SQL – Datenbankspeicher für die Anwendung
- Cloud Storage: Wird von Cloud Build verwendet und zum Laden des Schemas in die Datenbank verwendet.
- Cloud Secret Manager: Wird verwendet, um die Host-IP-Adressen für SQL und Redis in Cloud Build for Cloud Run einzufügen.
- Artifact Registry – speichert die Docker-Images zur Verwendung mit Cloud Build
variable "gcp_service_list" {
description = "The list of apis necessary for the project"
type = list(string)
default = [
"compute.googleapis.com",
"cloudapis.googleapis.com",
"vpcaccess.googleapis.com",
"servicenetworking.googleapis.com",
"cloudbuild.googleapis.com",
"sql-component.googleapis.com",
"sqladmin.googleapis.com",
"storage.googleapis.com",
"secretmanager.googleapis.com",
"run.googleapis.com",
"artifactregistry.googleapis.com",
"redis.googleapis.com"
]
}
resource "google_project_service" "all" {
for_each = toset(var.gcp_service_list)
project = var.project_number
service = each.key
disable_on_destroy = false
}
Berechtigungen festlegen
Mit dem folgenden Befehl werden IAM-Rollen und -Berechtigungen festgelegt, mit denen Cloud Build Dienste bereitstellen kann.
- Cloud Build-Dienstkonto für Bereitstellungen in Cloud Run aktivieren
- Aktivieren Sie das Cloud Build-Dienstkonto, um den VPN-Zugriff für Cloud Run festzulegen
- Cloud Build-Dienstkonto zum Ausführen von Dienstkontoaktivitäten aktivieren
- Zulassen, dass das Cloud Build-Dienstkonto im Namen des Compute-Dienstkontos agiert
- Cloud Build-Dienstkonto für Veröffentlichung in Cloud Run aktivieren
- Cloud Build-Dienstkonto zum Verarbeiten von Secrets aktivieren
- Cloud Build-Dienstkonto zum Speichern von Containern in Artifact Registry aktivieren
variable "build_roles_list" {
description = "The list of roles that build needs for"
type = list(string)
default = [
"roles/run.developer",
"roles/vpaccess.user",
"roles/iam.serviceAccountUser",
"roles/run.admin",
"roles/secretmanager.secretAccessor",
"roles/artifactregistry.admin",
]
}
resource "google_project_iam_member" "allbuild" {
for_each = toset(var.build_roles_list)
project = var.project_number
role = each.key
member = "serviceAccount:${local.sabuild}"
depends_on = [google_project_service.all]
}
Netzwerk für SQL-Instanz erstellen
Mit dem folgenden Befehl kann über Cloud Run auf Cloud SQL zugegriffen werden:
resource "google_compute_global_address" "google_managed_services_vpn_connector" {
name = "google-managed-services-vpn-connector"
purpose = "VPC_PEERING"
address_type = "INTERNAL"
prefix_length = 16
network = local.defaultnetwork
project = var.project_id
depends_on = [google_project_service.all]
}
resource "google_service_networking_connection" "vpcpeerings" {
network = local.defaultnetwork
service = "servicenetworking.googleapis.com"
reserved_peering_ranges = [google_compute_global_address.google_managed_services_vpn_connector.name]
}
VPC-Zugriffs-Connector erstellen
Verbindet Cloud Run mit Datenbank und Caching
resource "google_vpc_access_connector" "connector" {
provider = google-beta
project = var.project_id
name = "vpc-connector"
ip_cidr_range = "10.8.0.0/28"
network = "default"
region = var.region
depends_on = [google_compute_global_address.google_managed_services_vpn_connector, google_project_service.all]
}
Redis-Server erstellen
Konfiguriert und initialisiert eine Redis-Serverinstanz.
resource "google_redis_instance" "todo_cache" {
authorized_network = local.defaultnetwork
connect_mode = "DIRECT_PEERING"
location_id = var.zone
memory_size_gb = 1
name = "${var.basename}-cache"
project = var.project_id
redis_version = "REDIS_6_X"
region = var.region
reserved_ip_range = "10.137.125.88/29"
tier = "BASIC"
transit_encryption_mode = "DISABLED"
depends_on = [google_project_service.all]
}
SQL Server erstellen
Mit dem folgenden Befehl wird eine SQL Server-Instanz konfiguriert und initialisiert.
resource "google_sql_database_instance" "todo_database" {
name="${var.basename}-db-${random_id.id.hex}"
database_version = "MYSQL_5_7"
region = var.region
project = var.project_id
settings {
tier = "db-g1-small"
disk_autoresize = true
disk_autoresize_limit = 0
disk_size = 10
disk_type = "PD_SSD"
ip_configuration {
ipv4_enabled = false
private_network = local.defaultnetwork
}
location_preference {
zone = var.zone
}
}
deletion_protection = false
depends_on = [
google_project_service.all,
google_service_networking_connection.vpcpeerings
]
# This handles loading the schema after the database installs.
provisioner "local-exec" {
working_dir = "${path.module}/code/database"
command = "./load_schema.sh ${var.project_id} ${google_sql_database_instance.todo_database.name}"
}
}
Artifact Registry-Repository erstellen
Mit dem folgenden Befehl werden Docker-Images zur Verwendung mit Cloud Run gespeichert.
resource "google_artifact_registry_repository" "todo_app" {
provider = google-beta
format = "DOCKER"
location = var.region
project = var.project_id
repository_id = "${var.basename}-app"
depends_on = [google_project_service.all]
}
Secrets erstellen
Mit dem folgenden Befehl werden Redis- und SQL-Hostdaten in Cloud Secrets gespeichert.
resource "google_secret_manager_secret" "redishost" {
project = var.project_number
replication {
automatic = true
}
secret_id = "redishost"
depends_on = [google_project_service.all]
}
resource "google_secret_manager_secret_version" "redishost" {
enabled = true
secret = "projects/${var.project_number}/secrets/redishost"
secret_data = google_redis_instance.todo_cache.host
depends_on = [google_project_service.all, google_redis_instance.todo_cache, google_secret_manager_secret.redishost]
}
resource "google_secret_manager_secret" "sqlhost" {
project = var.project_number
replication {
automatic = true
}
secret_id = "sqlhost"
depends_on = [google_project_service.all]
}
resource "google_secret_manager_secret_version" "sqlhost" {
enabled = true
secret = "projects/${var.project_number}/secrets/sqlhost"
secret_data = google_sql_database_instance.todo_database.private_ip_address
depends_on = [google_project_service.all, google_sql_database_instance.todo_database, google_secret_manager_secret.sqlhost]
}
Artefakt für Middleware erstellen
Mit dem folgenden Befehl wird das Docker-Image erstellt und in Artifact Registry gehostet: ./code/frontend/clouldbuild.yaml
resource "null_resource" "cloudbuild_api" {
provisioner "local-exec" {
working_dir = "${path.module}/code/middleware"
command = "gcloud builds submit . --substitutions=_REGION=${var.region},_BASENAME=${var.basename}"
}
depends_on = [
google_artifact_registry_repository.todo_app,
google_secret_manager_secret_version.redishost,
google_secret_manager_secret_version.sqlhost,
google_project_service.all
]
}
API-Container in Cloud Run bereitstellen
Der folgende Befehl verwendet Cloud Build, um einen Dienst in Cloud Run mithilfe des soeben erstellten Containers zu starten.
resource "google_cloud_run_service" "api" {
name = "${var.basename}-api"
location = var.region
project = var.project_id
template {
spec {
containers {
image = "${var.region}-docker.pkg.dev/${var.project_id}/${var.basename}-app/api"
env {
name = "REDISHOST"
value_from {
secret_key_ref {
name = google_secret_manager_secret.redishost.secret_id
key = "latest"
}
}
}
env {
name = "todo_host"
value_from {
secret_key_ref {
name = google_secret_manager_secret.sqlhost.secret_id
key = "latest"
}
}
}
env {
name = "todo_user"
value = "todo_user"
}
env {
name = "todo_pass"
value = "todo_pass"
}
env {
name = "todo_name"
value = "todo"
}
env {
name = "REDISPORT"
value = "6379"
}
}
}
metadata {
annotations = {
"autoscaling.knative.dev/maxScale" = "1000"
"run.googleapis.com/cloudsql-instances" = google_sql_database_instance.todo_database.connection_name
"run.googleapis.com/client-name" = "terraform"
"run.googleapis.com/vpc-access-egress" = "all"
"run.googleapis.com/vpc-access-connector" = google_vpc_access_connector.connector.id
}
}
}
autogenerate_revision_name = true
depends_on = [
null_resource.cloudbuild_api,
google_project_iam_member.secretmanager_secretAccessor
]
}
Öffnen Sie den Cloud Run API-Dienst, um allgemein lesbar zu sein.
Diese API-Ebene der Anwendung wird vom Browser des Nutzers aufgerufen, aber standardmäßig sind Cloud Run-Dienste nicht öffentlich. Damit Nutzer diesen Dienst nutzen können, müssen wir Berechtigungen für diese Dienste öffnen, damit sie weltweit zugänglich sind.
resource "google_cloud_run_service_iam_policy" "noauth_api" {
location = google_cloud_run_service.api.location
project = google_cloud_run_service.api.project
service = google_cloud_run_service.api.name
policy_data = data.google_iam_policy.noauth.policy_data
}
Artefakt für Front-End erstellen
Mit dem folgenden Befehl wird das Docker-Image erstellt und in Artifact Registry gehostet: ./code/frontend/clouldbuild.yaml
resource "null_resource" "cloudbuild_fe" {
provisioner "local-exec" {
working_dir = "${path.module}/code/frontend"
command = "gcloud builds submit . --substitutions=_REGION=${var.region},_BASENAME=${var.basename}"
}
depends_on = [
google_artifact_registry_repository.todo_app,
google_cloud_run_service.api
]
}
Front-End-Container in Cloud Run bereitstellen
Der nächste Befehl verwendet Cloud Build, um einen Dienst in Cloud Run mithilfe des soeben erstellten Containers zu starten.
resource "google_cloud_run_service" "fe" {
name = "${var.basename}-fe"
location = var.region
project = var.project_id
template {
spec {
containers {
image = "${var.region}-docker.pkg.dev/${var.project_id}/${var.basename}-app/fe"
ports {
container_port = 80
}
}
}
}
depends_on = [null_resource.cloudbuild_fe]
}
Cloud Run-Front-End-Dienst für allgemein lesbare Zwecke öffnen
Dies ist das Front-End der Anwendung, das den HTML-/JS-/CSS-Code rendert, über den der Nutzer mit der Anwendung interagiert. Standardmäßig sind Cloud Run-Dienste nicht öffentlich. Damit diese Anwendung funktioniert, müssen wir Berechtigungen für diese Dienste erteilen, damit sie weltweit zugänglich sind.
resource "google_cloud_run_service_iam_policy" "noauth_fe" {
location = google_cloud_run_service.fe.location
project = google_cloud_run_service.fe.project
service = google_cloud_run_service.fe.name
policy_data = data.google_iam_policy.noauth.policy_data
}
./code/database/load_schema.sh
Datenbankschema initialisieren
Dieser Befehl erstellt einen temporären Cloud Storage-Bucket, um das Schema in Cloud SQL hochzuladen.
PROJECT=$1
SQLNAME=$2
SQLSERVICEACCOUNT=$(gcloud sql instances describe $SQLNAME --format="value(serviceAccountEmailAddress)" | xargs)
gsutil mb gs://$PROJECT-temp
gsutil cp schema.sql gs://$PROJECT-temp/schema.sql
gsutil iam ch serviceAccount:$SQLSERVICEACCOUNT:objectViewer gs://$PROJECT-temp/
gcloud sql import sql $SQLNAME gs://$PROJECT-temp/schema.sql -q
gsutil rm gs://$PROJECT-temp/schema.sql
gsutil rb gs://$PROJECT-temp
./code/middleware/clouldbuild.yaml
API-Container erstellen
Mit diesem Code wird ein Docker-Image für die Middleware-Ebene erstellt.
name: 'gcr.io/cloud-builders/docker'
args: [ 'build', '-t', '$_REGION-docker.pkg.dev/$PROJECT_ID/$_BASENAME-app/api', '.' ]
```
#### Push API container to Artifact Registry
Pushing the container to Artifact Registry makes it possible for Cloud Run to
get the image and serve it.
``` yaml
name: 'gcr.io/cloud-builders/docker'
args: ['push', '$_REGION-docker.pkg.dev/$PROJECT_ID/$_BASENAME-app/api']
Ersetzungen
Mit dem folgenden Code werden Variablen mit Standardwerten erstellt, sodass diese Werte bei der Bereitstellung geändert werden können.
substitutions:
_REGION: us-central1
_BASENAME: todo
./code/frontend/clouldbuild.yaml
Inhalt des Massagecodes
Das Front-End ist vollständig statisches HTML/JS/CSS. Die Anwendung muss auf die URL für den gerade erstellten API-Dienst verweisen. Cloud Run-Diensten wird jedoch eine URL mit einem zufälligen String zugewiesen. Dieses "Massage-Skript" erfasst diese zufällige URL und fügt sie in den Code des statischen JS in diesem Container ein.
name: 'gcr.io/google.com/cloudsdktool/cloud-sdk'
entrypoint: bash
args: [ './massage.sh', '$_REGION' ]
API-Container erstellen
Mit dem folgenden Code wird ein Docker-Image für die Middleware-Ebene erstellt:
name: 'gcr.io/cloud-builders/docker'
args: [ 'build', '-t', '$_REGION-docker.pkg.dev/$PROJECT_ID/$_BASENAME-app/fe', '.' ]
API-Container per Push an Artifact Registry übertragen
Durch Push in Artifact Registry kann Cloud Run das Image abrufen und bereitstellen.
name: 'gcr.io/cloud-builders/docker'
args: ['push', '$_REGION-docker.pkg.dev/$PROJECT_ID/$_BASENAME-app/fe']
Ersetzungen
Erstellen Sie eine Variable mit einem Standardwert, damit diese Werte zum Zeitpunkt der Bereitstellung geändert werden können.
substitutions:
_REGION: us-central1
_BASENAME: todo
./code/frontend/massage.sh
JavaScript bearbeiten
Mit diesem Befehl wird der Endpunkt für die Middleware in das JavaScript des Front-Ends eingefügt.
API=$(gcloud run services describe todo-api --region=$1 --format="value(status.url)")
stripped=$(echo ${API/https:\/\//})
sed -i"" -e "s/127.0.0.1:9000/$stripped/" www/js/main.js
Fazit
Sie haben jetzt eine einfache dreistufige To-do-Anwendung, die in Ihrem Projekt in Cloud Run ausgeführt wird. Sie haben auch den gesamten Code, um diese Lösung an Ihre Umgebung anzupassen oder zu erweitern.