Crear una aplicación a partir de recursos que ya tienes

En esta guía de inicio rápido se muestra cómo organizar los servicios de Google Cloud en una aplicación de App Hub. Primero, despliega una configuración de ejemplo que usarás para definir una aplicación web global registrando sus componentes como una aplicación en App Hub.

Este enfoque está dirigido a los usuarios que quieren usar su infraestructura para obtener visibilidad y control operativo agrupando los recursos en aplicaciones lógicas.

Antes de empezar

Antes de empezar esta guía de inicio rápido, haz lo siguiente:

  1. Configura el menú de aplicaciones con una carpeta habilitada para aplicaciones.

    Google Cloud

  2. Anota el ID del proyecto de gestión que vas a usar en este documento.

  3. Comprueba que las siguientes APIs estén habilitadas en el proyecto de gestión. Cuando configuras una carpeta habilitada para aplicaciones, la mayoría de las APIs que necesitas para esta guía de inicio rápido se habilitan automáticamente.

    • API de Compute Engine (compute.googleapis.com)
    • API Infrastructure Manager (config.googleapis.com)

    Habilitar APIs

Roles obligatorios

Para obtener los permisos que necesitas para habilitar las APIs obligatorias y crear una aplicación de ejemplo a partir de recursos ya creados, pide a tu administrador que te conceda los siguientes roles de gestión de identidades y accesos en el proyecto de gestión:

Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar acceso a proyectos, carpetas y organizaciones.

También puedes conseguir los permisos necesarios a través de roles personalizados u otros roles predefinidos.

Desplegar recursos para la aplicación

Primero debes implementar un conjunto de recursos de ejemplo que usarás más adelante para definir una aplicación global en App Hub:

  • Un servicio de Cloud Run que actúa como backend de la aplicación.
  • Un balanceador de carga de aplicación externo global que dirige el tráfico al servicio de Cloud Run como regla de reenvío.

Para implementar estos recursos, sigue estos pasos:

gcloud

  1. Define las variables de entorno necesarias:

    export PROJECT_ID="PROJECT_ID"
export REGION="REGION"

    Haz los cambios siguientes:

    • PROJECT_ID: el ID de tu proyecto de gestión.
    • REGION: la región que hayas elegido para los recursos (por ejemplo, us-central1).

  2. Despliega un servicio de Cloud Run de ejemplo llamado hello-run:

    gcloud run deploy hello-run \
    --image=us-docker.pkg.dev/cloudrun/container/hello \
    --allow-unauthenticated \
    --region=${REGION} \
    --project=${PROJECT_ID}

  3. Crea el balanceador de carga de aplicación externo global. Este proceso implica los siguientes pasos:

    1. Crea un grupo de endpoints de red (NEG) sin servidor llamado hello-run-neg:

      gcloud compute network-endpoint-groups create hello-run-neg \
    --region=${REGION} \
    --network-endpoint-type=serverless \
    --cloud-run-service=hello-run \
    --project=${PROJECT_ID}

      La NEG actúa como backend del balanceador de carga y apunta a tu servicio hello-run.

    2. Crea un servicio de backend para gestionar cómo se distribuye el tráfico a la NEG:

      gcloud compute backend-services create hello-backend-service \
    --global \
    --load-balancing-scheme=EXTERNAL_MANAGED \
    --project=${PROJECT_ID}

    3. Añade el NEG sin servidor como backend al servicio de backend:

      gcloud compute backend-services add-backend hello-backend-service \
    --global \
    --network-endpoint-group=hello-run-neg \
    --network-endpoint-group-region=${REGION} \
    --project=${PROJECT_ID}

    4. Crea un mapa de URLs para enrutar las solicitudes entrantes al servicio de backend:

      gcloud compute url-maps create hello-url-map \
    --default-service=hello-backend-service \
    --project=${PROJECT_ID}

    5. Crea un proxy HTTP para recibir solicitudes y enrutarlas mediante el mapa de URLs:

      gcloud compute target-http-proxies create hello-http-proxy \
    --url-map=hello-url-map \
    --project=${PROJECT_ID}

    6. Crea una regla de reenvío global:

      gcloud compute forwarding-rules create hello-forwarding-rule \
    --global \
    --load-balancing-scheme=EXTERNAL_MANAGED \
    --target-http-proxy=hello-http-proxy \
    --ports=80 \
    --project=${PROJECT_ID}

      Esta regla de reenvío proporciona una dirección IP pública y un puerto para gestionar las solicitudes de los usuarios entrantes y las dirige al proxy.

Terraform

  1. Crea un archivo main.tf y añade el siguiente código:

    # Provider configuration
provider "google" {
  project = "PROJECT_ID"
}

# Cloud Run service
resource "google_cloud_run_v2_service" "default" {
  name     = "hello-run"
  location = "REGION"
  template {
    containers {
      image = "us-docker.pkg.dev/cloudrun/container/hello"
    }
  }
}

# Allow unauthenticated access to the Cloud Run service
resource "google_cloud_run_v2_service_iam_member" "noauth" {
  project  = google_cloud_run_v2_service.default.project
  location = google_cloud_run_v2_service.default.location
  name     = google_cloud_run_v2_service.default.name
  role     = "roles/run.invoker"
  member   = "allUsers"
}

    Haz los cambios siguientes:

    • PROJECT_ID: el ID de tu proyecto de gestión.
    • REGION: la región que hayas elegido para los recursos (por ejemplo, us-central1).

    Este bloque define el Google Cloud proveedor y configura un servicio de Cloud Run público mediante una imagen de contenedor hello-world de ejemplo. También incluye un enlace de política de gestión de identidades y accesos para permitir las invocaciones sin autenticar, lo que hace que el servicio sea accesible públicamente.

  2. Añade el siguiente código a tu archivo main.tf para crear el balanceador de carga de aplicación externo global:

    # Serverless NEG for the Cloud Run service
resource "google_compute_region_network_endpoint_group" "serverless_neg" {
  name                  = "hello-run-neg"
  network_endpoint_type = "SERVERLESS"
  region                = "REGION"
  cloud_run {
    service = google_cloud_run_v2_service.default.name
  }
}

# Global external backend service
resource "google_compute_backend_service" "default" {
  name                            = "hello-backend-service"
  protocol                        = "HTTP"
  load_balancing_scheme           = "EXTERNAL_MANAGED"
  backend {
    group = google_compute_region_network_endpoint_group.serverless_neg.id
  }
}

# URL map to route requests to the backend service
resource "google_compute_url_map" "default" {
  name            = "hello-url-map"
  default_service = google_compute_backend_service.default.id
}

# HTTP proxy to route requests to the URL map
resource "google_compute_target_http_proxy" "default" {
  name    = "hello-http-proxy"
  url_map = google_compute_url_map.default.id
}

# Global forwarding rule to handle incoming requests
resource "google_compute_global_forwarding_rule" "default" {
  name       = "hello-forwarding-rule"
  target     = google_compute_target_http_proxy.default.id
  port_range = "80"
}

    Este bloque define los siguientes componentes:

    • Un grupo de endpoints de red (NEG) sin servidor, que actúa como backend del balanceador de carga y apunta al servicio de Cloud Run.
    • Un servicio de backend que dirige el tráfico al NEG sin servidor.
    • Un mapa de URLs para enrutar las solicitudes entrantes al servicio de backend.
    • Un proxy HTTP para recibir solicitudes y enrutarlas mediante el mapa de URLs.
    • Una regla de reenvío global, que proporciona una dirección IP pública y un puerto para gestionar las solicitudes de los usuarios entrantes y dirigirlas al proxy.

  3. Inicializa y aplica la configuración de Terraform:

    terraform init
terraform apply

    Terraform desplegará los recursos en tu proyecto.

Definir la aplicación en App Hub

Después de desplegar los recursos como una regla de reenvío y un servicio de Cloud Run, sigue estos pasos para agruparlos en una aplicación en App Hub:

Consola

  1. Ve a la página Aplicaciones desde el Centro de aplicaciones:

    Ir a Aplicaciones

  2. Haz clic en Crear aplicación.

  3. Selecciona Global como ubicación de la aplicación.

  4. Introduce my-global-app en el campo Nombre de la aplicación y haz clic en Continuar.

  5. También puedes añadir un nombre visible, una criticidad, un entorno y propietarios.

  6. Haz clic en Crear.

  7. En la pestaña Servicios y cargas de trabajo, haga clic en Registrar servicio o carga de trabajo.

  8. Selecciona la regla de reenvío, asígnale el nombre frontend-service y haz clic en Registrar.

  9. Selecciona el servicio de Cloud Run, asígnale el nombre backend-service y haz clic en Registrar.

gcloud

  1. Crea la aplicación:

    gcloud apphub applications create my-global-app \
    --location=global \
    --display-name="My Global Application" \
    --project=${PROJECT_ID}

  2. Descubre los IDs de la regla de reenvío y del servicio de Cloud Run en la región correspondiente:

    gcloud apphub discovered-services list \
    --location=global \
    --project=${PROJECT_ID}

gcloud apphub discovered-services list \
    --location=${REGION} \
    --project=${PROJECT_ID}

    Anota el ID de la regla de reenvío y del servicio de Cloud Run.

  3. Registra la regla de reenvío en la aplicación global:

    gcloud apphub applications services create frontend-service \
    --application=my-global-app \
    --discovered-service=projects/${PROJECT_ID}/locations/global/discoveredServices/FRONTEND_ID \
    --display-name="Frontend Service" \
    --location=global \
    --project=${PROJECT_ID}

    Sustituye FRONTEND_ID por el ID de la regla de reenvío.

  4. Registra el servicio de Cloud Run en la aplicación global:

    gcloud apphub applications services create backend-service \
    --application=my-global-app \
    --discovered-service=projects/${PROJECT_ID}/locations/${REGION}/discoveredServices/BACKEND_ID \
    --display-name="Backend Service" \
    --location=global \
    --project=${PROJECT_ID}

    Sustituye BACKEND_ID por el ID del servicio de Cloud Run.

Terraform

  1. Crea un archivo application.tf y añade el siguiente código:

    # Application
resource "google_apphub_application" "my_global_app" {
  project        = "PROJECT_ID"
  location       = "global"
  application_id = "my-global-app"
  display_name   = "My Global Web App"
  description    = "A sample global web application."
  scope {
    type = "GLOBAL"
  }
  attributes {
    criticality {
      type = "MEDIUM"
    }
    environment {
      type = "DEVELOPMENT"
    }
    business_owners {
      display_name = "Example Business Owner"
      email        = "business-owner@example.com"
    }
    developer_owners {
      display_name = "Example Developer"
      email        = "dev-owner@example.com"
    }
    operator_owners {
      display_name = "Example Operator"
      email        = "operator-owner@example.com"
    }
  }
}

    Este bloque usa el recurso google_apphub_application para crear una agrupación lógica de tus servicios y cargas de trabajo.

    En este ejemplo, se crea una aplicación global y se definen atributos de gobernanza y visibilidad, como la importancia, el entorno y los propietarios. Puede modificar esos valores en su configuración de ejemplo.

  2. Añade el siguiente código a application.tf para descubrir los recursos que has implementado:

    # Discover the forwarding rule
data "google_apphub_discovered_service" "frontend_service" {
  location = "global"
  service_uri = "//compute.googleapis.com/${google_compute_global_forwarding_rule.default.id}"
}

# Discover the Cloud Run service
data "google_apphub_discovered_service" "backend_service" {
  location    = "REGION"
  service_uri = "//run.googleapis.com/${google_cloud_run_v2_service.default.id}"
}

    Las fuentes de datos google_apphub_discovered_service buscan los nombres de recursos de tu infraestructura en función de sus URIs. Este paso permite que App Hub identifique los recursos específicos que quieres registrar.

  3. Añade el siguiente código a application.tf para registrar los recursos descubiertos:

    # Register the forwarding rule as a service in the application
resource "google_apphub_service" "frontend" {
  project            = "PROJECT_ID"
  location           = "global"
  application_id     = google_apphub_application.my_global_app.application_id
  service_id         = "frontend-service"
  display_name       = "Frontend Service (LB)"
  discovered_service = data.google_apphub_discovered_service.frontend_service.name
}

# Register the Cloud Run service as a service in the application
resource "google_apphub_service" "backend" {
  project            = "PROJECT_ID"
  location           = "global"
  application_id     = google_apphub_application.my_global_app.application_id
  service_id         = "backend-service"
  display_name       = "Backend Service (Cloud Run)"
  discovered_service = data.google_apphub_discovered_service.backend_service.name
}

    Los recursos de google_apphub_service registran formalmente los recursos descubiertos en tu aplicación. En este paso se crea el enlace entre tu infraestructura y la aplicación que has definido en App Hub.

  4. Inicializa y aplica la configuración de Terraform:

    terraform init
terraform apply

    Terraform registra los recursos en tu aplicación my-global-app en App Hub.

Opcional: Monitorizar la nueva aplicación

Después de definir tu aplicación en App Hub, puedes usar los servicios integrados deGoogle Cloud para monitorizar su estado y rendimiento:

Limpieza

Para evitar que se apliquen cargos en tu cuenta de Google Cloud por los recursos utilizados en esta página, sigue estos pasos.

  1. Anular el registro de servicios y cargas de trabajo.
  2. Elimina la aplicación global.
  3. Si has usado Terraform para implementar tu aplicación, ejecuta terraform destroy en el directorio que contiene tus archivos de Terraform para desaprovisionar todos los recursos que hayas creado.
  4. Opcional: Si has creado un proyecto para esta guía de inicio rápido, elimínalo.

Siguientes pasos