Crea una aplicación a partir de recursos existentes

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

Este enfoque es para los usuarios que desean usar su infraestructura existente para obtener visibilidad y control operativo agrupando los recursos en aplicaciones lógicas.

Antes de comenzar

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

  1. Configura App Hub con una carpeta habilitada para apps.

  2. Toma nota del ID del proyecto de administración que usarás en todo este documento.

  3. Verifica que las siguientes APIs estén habilitadas en el proyecto de administració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 de Infrastructure Manager (config.googleapis.com)

    Habilita las API

Roles requeridos

Para obtener los permisos que necesitas para habilitar las APIs requeridas y crear una aplicación de muestra a partir de recursos existentes, pídele a tu administrador que te otorgue los siguientes roles de IAM en el proyecto de administración:

Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios a través de roles personalizados o cualquier otro rol predefinido.

Implementa recursos para la aplicación

Primero debes implementar un conjunto de recursos de muestra 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 cargas de aplicaciones externo global que dirige el tráfico al servicio de Cloud Run como una regla de reenvío.

Sigue estos pasos para implementar estos recursos:

gcloud

  1. Configura las variables de entorno necesarias:

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

    Reemplaza lo siguiente:

    • PROJECT_ID: Es el ID de tu proyecto de administración.
    • REGION: La región que elegiste para los recursos, por ejemplo, us-central1.

  2. Implementa un servicio de muestra de Cloud Run 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 cargas de aplicaciones externo global. Este proceso implica los siguientes pasos:

    1. Crea un grupo de extremos de red (NEG) sin servidores 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}

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

    2. Crea un servicio de backend para administrar cómo se distribuye el tráfico al NEG:

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

    3. Agrega el NEG sin servidores como un 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 URL 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 con el mapa de URL:

      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 controlar las solicitudes entrantes de los usuarios y las dirige al proxy.

Terraform

  1. Crea un archivo main.tf y agrega 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"
}

    Reemplaza lo siguiente:

    • PROJECT_ID: Es el ID de tu proyecto de administración.
    • REGION: La región que elegiste para los recursos, por ejemplo, us-central1.

    Este bloque define el Google Cloud proveedor y configura un servicio de Cloud Run público con una imagen de contenedor de muestrahello-world. También incluye una vinculación de política de IAM para permitir invocaciones no autenticadas, lo que hace que el servicio sea accesible públicamente.

  2. Agrega el siguiente código a tu archivo main.tf para crear el balanceador de cargas de aplicaciones 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 extremos de red (NEG) sin servidores, que actúa como backend para el balanceador de cargas y apunta al servicio de Cloud Run.
    • Un servicio de backend que dirige el tráfico al NEG sin servidores
    • Un mapa de URL para enrutar las solicitudes entrantes al servicio de backend
    • Un proxy HTTP para recibir solicitudes y enrutarlas con el mapa de URL.
    • Una regla de reenvío global, que proporciona una dirección IP pública y un puerto para controlar las solicitudes entrantes de los usuarios y dirigirlas al proxy.

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

    terraform init
terraform apply

    Terraform implementa los recursos en tu proyecto.

Define la aplicación en App Hub

Después de implementar 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:

Console

  1. Ve a la página Applications desde App Hub:

    Ir a Aplicaciones

  2. Haz clic en Crear aplicación.

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

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

  5. De manera opcional, agrega un nombre visible, un nivel de gravedad, un entorno y propietarios.

  6. Haz clic en Crear.

  7. En la pestaña Servicios y cargas de trabajo, haz 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 el servicio de Cloud Run en la región adecuada:

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

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

    Toma nota del 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}

    Reemplaza 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}

    Reemplaza BACKEND_ID por el ID del servicio de Cloud Run.

Terraform

  1. Crea un archivo application.tf y agrega 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 para la gobernanza y la detección, como la importancia, el entorno y los propietarios. Puedes modificar esos valores para tu configuración de muestra.

  2. Agrega el siguiente código a application.tf para descubrir tus recursos implementados:

    # 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 de google_apphub_discovered_service encuentran los nombres de recursos de tu infraestructura existente según sus URIs. Este paso permite que App Hub identifique los recursos específicos que deseas registrar.

  3. Agrega 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 descubiertos en tu aplicación. Este paso crea el vínculo entre tu infraestructura y la aplicación que definiste 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: Supervisa tu nueva aplicación

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

Limpia

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en esta página.

  1. Cancelar el registro de servicios y cargas de trabajo
  2. Borra la aplicación global.
  3. Si usaste Terraform para implementar tu aplicación, ejecuta terraform destroy en el directorio que contiene tus archivos de Terraform para anular el aprovisionamiento de todos los recursos que creaste.
  4. Opcional: Si creaste un proyecto nuevo para esta guía de inicio rápido, bórralo.

¿Qué sigue?