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 recursos de Google Cloud en una aplicación de App Hub registrándolos como servicios. Primero, implementa componentes de ejemplo, que luego usas para definir una aplicación web global en App Hub.

Esta guía de inicio rápido está dirigida a los usuarios que quieran usar su infraestructura para obtener visibilidad y control operativo agrupando recursos en aplicaciones lógicas. Google Cloud

Antes de empezar

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

  1. Elige el modelo de configuración de la aplicación. En esta guía de inicio rápido se da por hecho que has definido un límite de gestión de aplicaciones a nivel de carpeta y se crea una aplicación con el proyecto de gestión de la carpeta. Para obtener más información sobre la configuración de este recurso, consulta el modelo de recursos de App Hub.

  2. Anota el ID del proyecto de gestión que vas a usar en este documento. Para obtener más información, consulta Buscar el nombre, el número y el ID del proyecto.

  3. Comprueba que las siguientes APIs estén habilitadas en el proyecto de gestión. Cuando configuras un proyecto de gestión, 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 componentes de ejemplo para la aplicación

Primero, debe implementar un conjunto de recursos de ejemplo Google Cloud que usará más adelante para definir una aplicación global en App Hub registrándolos como componentes de aplicación:

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 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 al 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 de App Hub registrándolos como servicios de la aplicación:

Consola

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

    Ve 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 componentes de la aplicación.

    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 como servicios.

  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 google_apphub_service registran formalmente los recursos detectados en tu aplicación como servicios. En este paso se vincula tu infraestructura con 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 productos integrados para monitorizar su estado y rendimiento:Google Cloud

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. Anula el registro de los servicios.
  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, elimina el proyecto.

Siguientes pasos