La app de tres niveles es una aplicación de tareas simple diseñada como una aplicación de 3 niveles estándar:
- Backend
- Base de datos: MySQL: Cloud SQL
- Almacenamiento en caché: Redis: Cloud Memorystore
- Middleware o API
- API alojada en contenedores: Golang - Cloud Run
- Front End/IU
- IU alojada en contenedor: Nginx + HTML/JS/CSS - Cloud Run
- Implementación
- Implementación continua: Cloud Build
- Administración de secretos: Cloud Secret Manager
Comenzar
Haz clic en el siguiente vínculo para obtener una copia del código fuente en Cloud Shell. Una vez allí, un solo comando iniciará una copia de trabajo de la aplicación en tu proyecto.
Ver el código fuente en GitHub
Componentes de la app de tres niveles
La arquitectura de apps de tres niveles usa varios productos. A continuación, se enumeran los componentes, junto con más información sobre ellos, incluidos vínculos a videos relacionados, documentación del producto y explicaciones interactivas.
Secuencias de comandos
La secuencia de comandos de instalación usa un ejecutable escrito en go y herramientas de la CLI de Terraform para tomar un proyecto vacío e instalar la aplicación en él. El resultado debe ser una aplicación que funcione y una URL para la dirección IP del balanceador de cargas.
./main.tf
Habilita los servicios
Los servicios de Google Cloud están inhabilitados en un proyecto de forma predeterminada. ToDo requiere que habilites los siguientes servicios:
- Herramientas de redes de servicios y acceso a VPC sin servidores: Permite que Cloud Run se comunique con SQL y Redis en una red privada, lo que mantiene estos servidores inaccesibles desde llamadas externas que provienen de la API.
- Cloud Build: Crea imágenes de contenedor y las implementa en Cloud Run.
- Cloud Memorystore: Proporciona una capa de almacenamiento en caché para la aplicación.
- Cloud Run: Es la herramienta sin servidores que alojará los contenedores y proporcionará las URLs desde las que se puede acceder a la aplicación.
- Cloud SQL: Almacenamiento de bases de datos para la aplicación
- Cloud Storage: Cloud Build lo usa para cargar el esquema en la base de datos.
- Cloud Secret Manager: Se usa para insertar las IP de host de SQL y Redis en Cloud Build para Cloud Run.
- Artifact Registry: Almacena las imágenes de Docker para usarlas con 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
}
Configurar permisos
El siguiente comando establece los roles y permisos de IAM que permiten que Cloud Build implemente servicios.
- Habilita la cuenta de servicio de Cloud Build para implementar en Cloud Run
- Habilita la cuenta de servicio de Cloud Build para establecer el acceso a VPN para Cloud Run
- Habilita la cuenta de servicio de Cloud Build para realizar actividades de la cuenta de servicio
- Habilita la cuenta de servicio de Cloud Build para que actúe en nombre de la cuenta de servicio de Compute
- Habilita la cuenta de servicio de Cloud Build para publicar en Cloud Run
- Habilita la cuenta de servicio de Cloud Build para consumir secretos
- Habilita la cuenta de servicio de Cloud Build para almacenar contenedores en Artifact Registry
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]
}
Crea redes para la instancia de SQL
El siguiente comando permite que se pueda acceder a Cloud SQL desde Cloud Run:
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]
}
Crea un conector de acceso a VPC
Conecta Cloud Run a la base de datos y el almacenamiento en caché
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]
}
Crea el servidor de Redis
Configura e inicializa una instancia del servidor Redis.
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]
}
Crea un servidor de SQL
El siguiente comando configura e inicializa una instancia de SQL Server.
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}"
}
}
Crea el repositorio de Artifact Registry
El siguiente comando almacena imágenes de Docker para usarlas con Cloud Run.
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]
}
Crea secretos
El siguiente comando almacena datos de host de Redis y SQL en Secretos de Cloud.
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]
}
Crea un artefacto para el middleware
El siguiente comando crea la imagen de Docker y la aloja en Artifact Registry: ./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
]
}
Implementa el contenedor de API en Cloud Run
El siguiente comando usa Cloud Build para iniciar un servicio en Cloud Run con el contenedor que acabas de compilar.
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
]
}
Abre el servicio de la API de Cloud Run para que sea de lectura para todos.
El navegador del usuario llamará a esta capa de API de la aplicación, pero los servicios de Cloud Run no son públicos de forma predeterminada. Para que los usuarios consuman este servicio, debemos abrir los permisos en estos servicios para que el público pueda acceder a ellos.
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
}
Crea un artefacto para el frontend
El siguiente comando crea la imagen de Docker y la aloja en Artifact Registry: ./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
]
}
Implementa el contenedor del frontend en Cloud Run
El siguiente comando usa Cloud Build para iniciar un servicio en Cloud Run con el contenedor que acabamos de crear.
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]
}
Abre el servicio de frontend de Cloud Run para que sea legible en todo el mundo
Este es el frontend de la aplicación, que renderizará el HTML/JS/CSS con el que el usuario interactúa con la aplicación. De forma predeterminada, los servicios de Cloud Run no son públicos. Para que esta aplicación funcione, debemos abrir permisos en estos servicios para que el público pueda acceder a ellos.
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
Inicializa el esquema de la base de datos
Este comando crea un bucket temporal de Cloud Storage para subir el esquema a Cloud SQL.
PROJECT=$1
SQLNAME=$2
SQLSERVICEACCOUNT=$(gcloud sql instances describe $SQLNAME --format="value(serviceAccountEmailAddress)" | xargs)
gcloud storage buckets create gs://$PROJECT-temp
gcloud storage cp schema.sql gs://$PROJECT-temp/schema.sql
gcloud storage buckets add-iam-policy-binding gs://$PROJECT-temp/ --member=serviceAccount:$SQLSERVICEACCOUNT --role=roles/storage.objectViewer
gcloud sql import sql $SQLNAME gs://$PROJECT-temp/schema.sql -q
gcloud storage rm gs://$PROJECT-temp --recursive
./code/middleware/clouldbuild.yaml
Compila el contenedor de la API
Este código crea una imagen de Docker para la capa de middleware.
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']
Sustituciones
El siguiente código crea variables con valores predeterminados para que estos valores se puedan cambiar en el momento de la implementación.
substitutions:
_REGION: us-central1
_BASENAME: todo
./code/frontend/clouldbuild.yaml
Contenido del código de masaje
El frontend es completamente estático en HTML/JS/CSS. La app debe apuntar a la URL del servicio de API que acabamos de crear, pero a los servicios de Cloud Run se les asigna una URL con una cadena aleatorizada. Esta "secuencia de comandos de masaje" captura esa URL aleatoria y la inserta en el código del JS estático en este contenedor.
name: 'gcr.io/google.com/cloudsdktool/cloud-sdk'
entrypoint: bash
args: [ './massage.sh', '$_REGION' ]
Compila el contenedor de la API
El siguiente código crea una imagen de Docker para la capa de middleware:
name: 'gcr.io/cloud-builders/docker'
args: [ 'build', '-t', '$_REGION-docker.pkg.dev/$PROJECT_ID/$_BASENAME-app/fe', '.' ]
Envía el contenedor de API a Artifact Registry
Enviar el contenedor a Artifact Registry permite que Cloud Run obtenga la imagen y la entregue.
name: 'gcr.io/cloud-builders/docker'
args: ['push', '$_REGION-docker.pkg.dev/$PROJECT_ID/$_BASENAME-app/fe']
Sustituciones
Crea una variable con un valor predeterminado para que estos valores se puedan cambiar en el momento del despliegue.
substitutions:
_REGION: us-central1
_BASENAME: todo
./code/frontend/massage.sh
Edita JavaScript
Este comando inserta el extremo del middleware en el código JavaScript del frontend.
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
Conclusión
Ahora tienes una aplicación de tareas simple de 3 niveles que se ejecuta en Cloud Run en tu proyecto. También tienes todo el código para modificar o extender esta solución para que se adapte a tu entorno.